@atlashub/smartstack-cli 3.7.0 → 3.9.0

package/templates/skills/business-analyse/references/cadrage-structure-cards.md

@@ -0,0 +1,78 @@
+# Cadrage Structure Cards
+
+> Reference for step-01-cadrage.md — exact JSON formats for cadrage section fields.
+
+## stakeholders[]
+
+```json
+{
+  "role": "Fleet Manager",
+  "function": "Manages daily fleet operations",
+  "involvement": "decision-maker",
+  "tasks": ["Monitor vehicles", "Approve repairs", "Export reports"],
+  "frequency": "Daily",
+  "painPoints": ["Manual tracking in spreadsheets", "No real-time visibility"]
+}
+```
+**MANDATORY fields:** `role`, `function`, `involvement`, `tasks`
+**involvement values:** `approver`, `decision-maker`, `consulted`, `informed`, `end-user`
+**FORBIDDEN fields:** Do NOT use `expertise`, `systemRole`, `description` (use `function` instead).
+
+## applicationRoles[]
+
+```json
+{
+  "role": "{App} Admin",
+  "description": "Full access to all modules",
+  "level": "admin",
+  "permissionPattern": "business.{app}.*"
+}
+```
+**MANDATORY fields:** `role`, `level`, `permissionPattern`
+**level values:** `admin`, `manager`, `contributor`, `viewer`
+**FORBIDDEN fields:** Do NOT use `permissions` (use `permissionPattern`), `isDefault`.
+
+## risks[]
+
+```json
+{
+  "id": "RISK-001",
+  "type": "business|technical|organizational",
+  "description": "CSV data may contain duplicates and errors",
+  "probability": "high|medium|low",
+  "impact": "high|medium|low",
+  "priority": "critical|medium|low",
+  "mitigation": "Data cleaning phase before import, detailed error reports"
+}
+```
+**MANDATORY fields:** `id` (pattern: RISK-NNN), `type`, `description`, `mitigation`
+**FORBIDDEN fields:** Do NOT use `risk` (name), `severity`. Use `id` + `description` + `priority`.
+
+## acceptanceCriteria[]
+
+```json
+{ "id": "AC-001", "criterion": "All must-have features delivered and tested", "validated": false }
+```
+**MANDATORY:** This section must NOT be omitted.
+
+## coverageMatrix[]
+
+```json
+{
+  "item": "User management with CRUD",
+  "category": "mustHave|shouldHave|couldHave|outOfScope|implicit",
+  "module": "Users",
+  "ucRef": "UC-UM-001",
+  "notes": "Foundation module, must be implemented first"
+}
+```
+**MANDATORY fields:** `item`, `category`, `module`
+**category values:** `mustHave`, `shouldHave`, `couldHave`, `outOfScope`, `implicit` (camelCase)
+**FORBIDDEN fields:** Do NOT use `id`, `feature`, `priority`. Use `item` + `category`.
+
+## codebaseContext
+
+Must be a string, NOT an object:
+```json
+"codebaseContext": "Greenfield project, no existing entities. SmartStack 2.1.0 with Extensions DbContext."
+```

package/templates/skills/business-analyse/references/cadrage-vibe-coding.md

@@ -0,0 +1,97 @@
+# Cadrage: Vibe Coding Flow
+
+> Reference for step-01-cadrage.md — accelerated 3-lot questionnaire for vibe coding mode.
+
+## Lot 1: Problem & Scope
+
+Ask 2 questions:
+
+```
+question: "Quel est le besoin principal de cette application ?"
+header: "Besoin"
+options:
+  - label: "Automatiser un processus manuel"
+    description: "Remplacer des taches repetitives par une application"
+  - label: "Creer un outil manquant"
+    description: "Construire quelque chose qui n'existe pas encore"
+  - label: "Remplacer un outil existant"
+    description: "Remplacer un logiciel ou tableur qui ne convient plus"
+  - label: "Centraliser des donnees"
+    description: "Rassembler des informations dispersees en un seul endroit"
+```
+
+```
+question: "Quelles fonctionnalites sont indispensables pour la V1 ?"
+header: "Indispensable"
+multiSelect: true
+options:
+  → Generate 4 options dynamically from {feature_description}
+  → Each option = one functional area detected in the description
+```
+
+**Store:** `problem_type` (from Q1), `must_have_features[]` (from Q2)
+
+## Lot 2: Users & Permissions
+
+```
+question: "Qui va utiliser cette application ?"
+header: "Utilisateurs"
+options:
+  - label: "Moi seul"
+    description: "Application mono-utilisateur, je suis l'unique admin"
+  - label: "Quelques utilisateurs (2-10)"
+    description: "Petite equipe avec des roles differents"
+  - label: "Organisation (10+)"
+    description: "Deploiement a l'echelle d'une equipe ou entreprise"
+```
+
+**Auto-set rules:**
+- "Moi seul" → 1 admin role, 1 stakeholder, SKIP role question
+- "Quelques utilisateurs" → standard 4-tier roles, ask confirmation, 2 stakeholders (Admin + User)
+- "Organisation" → standard 4-tier roles, ask confirmation, 3 stakeholders (Admin + Manager + User)
+
+## Lot 3: Technical Challenges
+
+```
+question: "Quels defis techniques anticipez-vous ?"
+header: "Defis"
+multiSelect: true
+options:
+  - label: "Regles metier complexes"
+    description: "Calculs, validations ou workflows difficiles a specifier"
+  - label: "Volume de donnees"
+    description: "Grandes quantites de donnees a gerer ou migrer"
+  - label: "Integrations externes"
+    description: "APIs, services tiers ou synchronisation avec d'autres systemes"
+  - label: "Interface riche"
+    description: "Ecrans avec beaucoup d'interactions, graphiques ou visualisations"
+```
+
+## Auto-Inferred Cadrage Data
+
+DO NOT ask these — derive from answers:
+
+```yaml
+cadrage.problem: "{feature_description} — {problem_type}"
+cadrage.asIs: "Aucun systeme en place" | "Processus manuel existant" | "Outil existant a remplacer"
+  → Derived from Lot 1 problem_type
+cadrage.toBe: "Application {application_name} couvrant: {must_have_features joined}"
+cadrage.trigger: "Projet vibe coding initie par le developpeur"
+cadrage.risks:
+  → Map each selected technical challenge to a RISK entry:
+    - "Regles metier complexes" → RISK-001, type: "technical", probability: "medium", impact: "high"
+    - "Volume de donnees" → RISK-002, type: "technical", probability: "low", impact: "medium"
+    - "Integrations externes" → RISK-003, type: "technical", probability: "medium", impact: "medium"
+    - "Interface riche" → RISK-004, type: "technical", probability: "low", impact: "low"
+  → Add mitigation for each: "Specification detaillee dans step-03 + generation iterative"
+cadrage.acceptanceCriteria:
+  - { id: "AC-001", criterion: "Toutes les fonctionnalites must-have implementees et fonctionnelles", validated: false }
+  - { id: "AC-002", criterion: "Application deployable et utilisable", validated: false }
+cadrage.globalScope:
+  mustHave: {must_have_features}
+  shouldHave: [] → Determined later in coverage matrix
+  couldHave: [] → Determined later in coverage matrix
+  outOfScope: []
+```
+
+After Lot 3: Go directly to **section 9 (Coverage Matrix)**.

package/templates/skills/business-analyse/references/consolidation-structural-checks.md

@@ -0,0 +1,92 @@
+# Consolidation Structural Schema Conformity Checks
+
+> Post-generation validation. After semantic checks, verify ALL module feature.json files conform to JSON schema.
+
+## 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 |
+
+## B. Field Name Conformity
+
+| Section | FORBIDDEN fields | Correct fields |
+|---------|-----------------|----------------|
+| `entities[].attributes[]` | `type`, `values`, `rules` | `description`, `unique`, `validation` |
+| `businessRules[]` | `rule`, `condition` (singular) | `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 |
+
+## D. Cross-Module ID Uniqueness
+
+```
+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
+
+```
+IF missing componentMapping[] -> ERROR
+IF missing layout object -> ERROR
+IF missing layout.regions[] -> ERROR
+FOR each region: IF missing position or components[] -> ERROR
+```
+
+## F. SeedDataCore Translation Coverage
+
+```
+FOR each navigationModules[].code:
+  FOR each language in [fr, en, nl, de]:
+    IF NOT EXISTS navigationTranslations[] with moduleCode AND language -> ERROR
+```
+
+## Result Aggregation
+
+```json
+{
+  "structuralChecks": [
+    { "check": "required-sections", "module": "...", "status": "PASS|ERROR", "details": "..." },
+    { "check": "field-names", "module": "...", "status": "PASS|ERROR", "details": "..." },
+    { "check": "id-patterns", "module": "...", "status": "PASS|ERROR", "details": "..." },
+    { "check": "id-uniqueness", "module": "...", "status": "PASS|ERROR", "details": "..." },
+    { "check": "wireframe-layout", "module": "...", "status": "PASS|ERROR", "details": "..." },
+    { "check": "seeddata-translations", "module": "...", "status": "PASS|ERROR", "details": "..." }
+  ]
+}
+```
+
+**Blocking rule:** 0 ERROR -> PASS. >=1 ERROR -> BLOCK (attempt auto-fix, re-write, re-check).

package/templates/skills/business-analyse/references/deploy-data-build.md

@@ -0,0 +1,121 @@
+# FEATURE_DATA & EMBEDDED_ARTIFACTS Build Reference
+
+> Reference for step-05b-deploy.md — complete mapping specification for the interactive HTML.
+
+## FEATURE_DATA Object
+
+```javascript
+const FEATURE_DATA = {
+  metadata: {
+    applicationName: master.application_name,
+    applicationId: master.feature_id,
+    version: master.version,
+    createdAt: ISO_TIMESTAMP,
+    vibeCoding: master.metadata.vibeCoding // "enabled" or "disabled" — controls UI section visibility
+  },
+  cadrage: {
+    goal: master.cadrage.goal,
+    vision: master.cadrage.vision,
+    success_criteria: master.cadrage.success_criteria,
+    scope: {
+      // CONVERT feature.json keys to HTML keys:
+      // mustHave → vital, shouldHave → important, couldHave → optional, outOfScope → excluded
+      vital: master.globalScope.mustHave || [],
+      important: master.globalScope.shouldHave || [],
+      optional: master.globalScope.couldHave || [],
+      excluded: master.globalScope.outOfScope || []
+    },
+    constraints: master.cadrage.constraints || [],
+    risks: master.cadrage.risks || [],
+    stakeholders: master.stakeholders || []
+  },
+  modules: [
+    {
+      moduleCode: module.code,
+      moduleName: module.name,
+      moduleDescription: module.description || "",
+      // ... per-module fields from feature.json
+    }
+  ],
+  moduleSpecs: {
+    // CRITICAL: Must have ONE entry per module with ALL module data
+    "{moduleCode}": {
+      useCases: module.specification.useCases || [],
+      businessRules: module.analysis.businessRules || [],
+      entities: module.analysis.entities || [],
+      permissions: module.specification.permissions || [],
+      apiEndpoints: module.specification.apiEndpoints || []
+    }
+  },
+  consolidation: {
+    integrations: master.consolidation.integrations || [],
+    sharedEntities: master.consolidation.sharedEntities || [],
+    sequenceDiagrams: master.consolidation.e2eFlows || []
+  },
+  handoff: {
+    complexity: master.handoff.complexity,
+    implementationStrategy: master.handoff.implementationStrategy,
+    moduleOrder: master.handoff.moduleOrder,
+    filesToCreate: master.handoff.filesToCreate,
+    brToCodeMapping: master.handoff.brToCodeMapping,
+    apiEndpointSummary: master.handoff.apiEndpointSummary
+  }
+};
+```
+
+### Build Process
+
+1. Extract metadata from master feature.json
+2. Extract cadrage from master feature.json (CONVERT scope keys)
+3. Extract stakeholders from master.stakeholders
+4. Iterate ALL modules and populate moduleSpecs (THIS IS CRITICAL — empty moduleSpecs = BUG)
+5. For EACH module, extract: useCases, businessRules, entities, permissions, apiEndpoints
+6. Extract consolidation data (integrations, shared entities, E2E flows)
+7. Extract handoff section (complexity, strategy, module order, file counts)
+
+## EMBEDDED_ARTIFACTS Object
+
+```javascript
+const EMBEDDED_ARTIFACTS = {
+  wireframes: [
+    // Extract from each module's specification.uiWireframes
+    {
+      moduleCode: "{moduleCode}",
+      screen: wireframe.screen,
+      description: wireframe.description,
+      layout: wireframe.layout || "responsive",
+      components: wireframe.components || []
+    }
+  ],
+  e2eFlows: [
+    // Extract from master consolidation.e2eFlows
+    {
+      flowName: flow.name,
+      description: flow.description,
+      sequence: flow.sequence || [],
+      modules: flow.modules || []
+    }
+  ],
+  dependencyGraph: {
+    // From master consolidation.dependencyGraph
+    nodes: master.consolidation.dependencyGraph?.nodes || [],
+    edges: master.consolidation.dependencyGraph?.edges || []
+  }
+};
+```
+
+### Artifact Gathering
+
+1. Read each module's `specification.uiWireframes[]` and add to wireframes array
+2. Read master's `consolidation.e2eFlows[]` and add to e2eFlows array
+3. Read master's `consolidation.dependencyGraph` and include as-is
+4. Serialize as JSON with 2-space indentation
+
+## Placeholder Replacement
+
+1. Serialize FEATURE_DATA as JSON (2-space indent)
+2. Serialize EMBEDDED_ARTIFACTS as JSON (2-space indent)
+3. Replace `{{FEATURE_DATA}}` with serialized FEATURE_DATA
+4. Replace `{{EMBEDDED_ARTIFACTS}}` with serialized EMBEDDED_ARTIFACTS
+5. Replace `{{APPLICATION_NAME}}`, `{{APPLICATION_ID}}`, `{{VERSION}}`, `{{CREATED_AT}}`
+6. Verify: grep for `{{` to confirm all placeholders replaced

package/templates/skills/business-analyse/references/deploy-modes.md

@@ -0,0 +1,49 @@
+# Deploy Mode Support & Troubleshooting
+
+> Reference for step-05b-deploy.md — mode variations and common issues.
+
+## Mode Support
+
+### Standard Mode
+
+Full handoff with all implementation details:
+- All 7 file categories
+- Complete BR-to-code mapping
+- Full API endpoint summary
+- Detailed prd.json
+- Comprehensive progress tracker
+
+### Micro Mode (use_case = micro)
+
+Simplified handoff with minimal scope:
+- Only essential CRUD entity + controller
+- 3 core SeedData entries (omit some optional ones)
+- Basic prd.json with simplified sections
+- Lightweight progress.txt
+- Display `/ralph-loop -r` command for later use
+
+### Delta Mode (use_case = refactoring)
+
+Focused handoff for changes:
+- Only affected modules listed
+- Reuse existing implementation patterns
+- Highlight what changed vs baseline
+- Update only affected prd.json sections
+- Progress tracker shows only delta tasks
+
+## Troubleshooting
+
+| Issue | Resolution |
+|-------|-----------|
+| All modules missing handoff data | Return to step-05a-handoff.md. Handoff MUST be written to each module feature.json. |
+| prd.json generation failed | Verify ss derive-prd command is installed and feature.json path is correct. |
+| progress.txt incomplete | Ensure all 5 CORE SeedData entries are present per module. Check topological order. |
+| BA manifest not found | Create docs/business/index.json if missing. Use schema provided in section 3. |
+| Manifest entries incorrect | Verify appCode, moduleCode, and version match feature.json metadata exactly. |
+| ba-interactive.html is too small (< 100KB) | FEATURE_DATA not serialized correctly. Verify JSON structure. Re-run FEATURE_DATA build. |
+| moduleSpecs missing from HTML | FEATURE_DATA.moduleSpecs is empty or not included in JSON. Verify each module is iterated and populated. |
+| Scope keys still show "mustHave" instead of "vital" | Conversion from feature.json keys to HTML keys failed. Check cadrage.scope conversion logic. |
+| Wireframes array is empty | Verify each module has specification.uiWireframes. If missing, add wireframe stubs. |
+| dependencyGraph missing | Verify master feature.json has consolidation.dependencyGraph. If missing, create empty nodes/edges arrays. |
+| HTML opens but data blank (localStorage issue) | Clear browser localStorage. HTML will load pre-populated FEATURE_DATA on first load. |
+| Export/re-import fails | Verify exported JSON matches original feature.json schema. Validate with `/business-analyse -x --validate`. |

package/templates/skills/business-analyse/references/handoff-file-templates.md

@@ -0,0 +1,119 @@
+# Handoff File Templates (7 Categories)
+
+> **PATH HIERARCHY CONVENTION:** All backend file paths MUST include the context and application hierarchy.
+> - `{ContextPascal}` = PascalCase of `metadata.context` (e.g., `"business"` -> `"Business"`)
+> - `{ApplicationName}` = `metadata.application` (e.g., `"HumanResources"`)
+> - `{ModuleName}` = `metadata.module` (e.g., `"Projects"`)
+>
+> **Controller context-to-folder mapping (`{ContextShort}`):**
+> | metadata.context | Controller Folder |
+> |-----------------|-------------------|
+> | `business` | `Business` |
+> | `platform` | `Admin` |
+> | `personal` | `User` |
+
+## 4.1 Domain Files
+
+From `analysis.entities[]`:
+
+```json
+"domain": [
+  { "path": "src/Domain/Entities/{ContextPascal}/{ApplicationName}/{ModuleName}/{EntityName}.cs", "type": "Entity", "linkedFRs": [], "linkedUCs": [], "module": "{moduleCode}" }
+]
+```
+
+Include: Value objects, Enums (`src/Domain/Enums/...`), Domain exceptions (`src/Domain/Exceptions/...`)
+
+## 4.2 Application Files
+
+From `analysis.useCases[]`:
+
+```json
+"application": [
+  { "path": "src/Application/Services/{ContextPascal}/{ApplicationName}/{ModuleName}/{ServiceName}Service.cs", "type": "Service", "linkedFRs": [], "linkedUCs": [], "module": "{moduleCode}" },
+  { "path": "src/Application/DTOs/{ContextPascal}/{ApplicationName}/{ModuleName}/{DtoName}Dto.cs", "type": "Dto", "linkedUCs": [], "module": "{moduleCode}" },
+  { "path": "src/Application/Validators/{ContextPascal}/{ApplicationName}/{ModuleName}/{ValidatorName}Validator.cs", "type": "Validator", "linkedFRs": [], "module": "{moduleCode}" }
+]
+```
+
+Include: Service per UC cluster, DTOs for API contracts, Validators (FluentValidation), Query handlers
+
+## 4.3 Infrastructure Files
+
+From `analysis.entities[]`:
+
+```json
+"infrastructure": [
+  { "path": "src/Infrastructure/Persistence/Configurations/{ContextPascal}/{ApplicationName}/{ModuleName}/{EntityName}Configuration.cs", "type": "EFConfiguration", "linkedFRs": [], "module": "{moduleCode}" }
+]
+```
+
+Include: EF Core config per entity, DbSet in IExtensionsDbContext, DI registration, Specifications
+
+## 4.4 API Files
+
+From `specification.apiEndpoints[]`:
+
+```json
+"api": [
+  { "path": "src/API/Controllers/{ContextShort}/{ApplicationName}/{EntityName}Controller.cs", "type": "ApiController", "linkedUCs": [], "linkedFRs": [], "module": "{moduleCode}" }
+]
+```
+
+Include: One controller per aggregate root, all HTTP methods, error handling
+
+## 4.5 Frontend Files
+
+From `specification.uiWireframes[]`, `specification.dashboards[]` and `analysis.useCases[]`:
+
+> **WIREFRAME TRACEABILITY:** Every frontend file MUST include `linkedWireframes[]` referencing wireframe `screen` identifiers.
+
+```json
+"frontend": [
+  { "path": "src/pages/{ModuleName}/{PageName}Page.tsx", "type": "Page", "linkedUCs": [], "linkedWireframes": ["{module}-list"], "module": "{moduleCode}", "wireframeAcceptanceCriteria": "Layout MUST match wireframe..." },
+  { "path": "src/pages/{ModuleName}/{PageName}DetailPage.tsx", "type": "Page", "linkedUCs": [], "linkedWireframes": ["{module}-detail"], "module": "{moduleCode}" },
+  { "path": "src/pages/{ModuleName}/{DashboardName}DashboardPage.tsx", "type": "DashboardPage", "linkedUCs": [], "linkedWireframes": ["{module}-dashboard"], "module": "{moduleCode}", "dashboardRef": "{module}-dashboard", "instructions": "Use Recharts library..." },
+  { "path": "src/components/{ModuleName}/{ComponentName}.tsx", "type": "Component", "linkedUCs": [], "linkedWireframes": [], "module": "{moduleCode}" },
+  { "path": "src/hooks/use{ModuleName}{Hook}.ts", "type": "Hook", "linkedUCs": [], "module": "{moduleCode}" }
+]
+```
+
+**Dashboard acceptance criteria:** Chart library (Recharts), chart types matching spec, KPI cards, filters, CSS variables, responsive layout, wireframe-matching positions.
+
+## 4.6 SeedData Files
+
+**OBLIGATORY: 5 CORE + business per module:**
+
+```json
+"seedData": [
+  { "path": "src/Infrastructure/Persistence/Seeding/Data/{ModuleName}/NavigationModuleSeedData.cs", "type": "SeedData", "category": "core", "source": "specification.seedDataCore.navigationModules", "module": "{moduleCode}" },
+  { "path": "src/Infrastructure/Persistence/Seeding/Data/{ModuleName}/PermissionsSeedData.cs", "type": "SeedData", "category": "core", "source": "specification.seedDataCore.permissions", "module": "{moduleCode}" },
+  { "path": "src/Infrastructure/Persistence/Seeding/Data/{ModuleName}/RolesSeedData.cs", "type": "SeedData", "category": "core", "source": "specification.seedDataCore.roles", "module": "{moduleCode}" },
+  { "path": "src/Infrastructure/Persistence/Seeding/Data/{ModuleName}/TenantSeedData.cs", "type": "SeedData", "category": "core", "source": "specification.seedDataCore.tenants", "module": "{moduleCode}" },
+  { "path": "src/Infrastructure/Persistence/Seeding/Data/{ModuleName}/UserSeedData.cs", "type": "SeedData", "category": "core", "source": "specification.seedDataCore.users", "module": "{moduleCode}" },
+  { "path": "src/Infrastructure/Persistence/Seeding/Data/{ModuleName}/{Entity}SeedData.cs", "type": "SeedData", "category": "business", "source": "specification.seedDataBusiness.{module}", "module": "{moduleCode}" }
+]
+```
+
+**For client projects (ExtensionsDbContext), add MANDATORY infrastructure files:**
+
+```json
+[
+  { "path": "src/Infrastructure/Persistence/Seeding/{AppPascalName}SeedDataProvider.cs", "type": "IClientSeedDataProvider", "category": "infrastructure", "description": "Runtime provider that injects core seed data into Core schema" },
+  { "path": "src/Infrastructure/Persistence/Seeding/DevDataSeeder.cs", "type": "DevDataSeeder", "category": "infrastructure" },
+  { "path": "src/Infrastructure/Persistence/Seeding/Data/SeedConstants.cs", "type": "SeedConstants", "category": "infrastructure" }
+]
+```
+
+**Path convention:** All seed data under `Persistence/Seeding/Data/`. NEVER use `Data/SeedData/`.
+
+## 4.7 Test Files
+
+```json
+"tests": [
+  { "path": "src/Tests/Unit/Domain/{ContextPascal}/{ApplicationName}/{ModuleName}/{Entity}Tests.cs", "type": "UnitTests", "linkedFRs": [], "module": "{moduleCode}" },
+  { "path": "src/Tests/Unit/Application/{ContextPascal}/{ApplicationName}/{ModuleName}/{ServiceName}ServiceTests.cs", "type": "UnitTests", "linkedFRs": [], "linkedUCs": [], "module": "{moduleCode}" },
+  { "path": "src/Tests/Integration/{ContextPascal}/{ApplicationName}/{ModuleName}/{ApiControllerName}ControllerTests.cs", "type": "IntegrationTests", "linkedUCs": [], "module": "{moduleCode}" },
+  { "path": "src/Tests/Security/{ContextPascal}/{ApplicationName}/{ModuleName}/{ModuleName}SecurityTests.cs", "type": "SecurityTests", "linkedFRs": [], "module": "{moduleCode}" }
+]
+```

package/templates/skills/business-analyse/references/handoff-mappings.md

@@ -0,0 +1,81 @@
+# Handoff Mappings: BR-to-Code & API Summary
+
+## Business Rules to Code Mapping
+
+Derive from `analysis.businessRules[]` of **EACH module**.
+
+Generate complete mapping for each BR:
+
+```json
+{
+  "brToCodeMapping": [
+    {
+      "ruleId": "BR-VAL-001",
+      "title": "Order total must equal sum of item prices",
+      "module": "{moduleCode}",
+      "severity": "critical",
+      "implementationPoints": [
+        { "layer": "Domain", "component": "Order.cs", "method": "CalculateTotal()", "implementation": "Validate sum equals sum of OrderItems.Price" },
+        { "layer": "Application", "component": "CreateOrderService.cs", "method": "Handle()", "implementation": "Calculate total before persisting" },
+        { "layer": "API", "component": "OrdersController.cs", "method": "CreateOrder()", "implementation": "Return validation error if total mismatch" },
+        { "layer": "Frontend", "component": "OrderForm.tsx", "method": "calculateTotal()", "implementation": "Real-time calculation on item change" }
+      ]
+    }
+  ]
+}
+```
+
+For each BR include:
+- **ruleId**: Reference to analysis.businessRules[].id
+- **title**: The rule statement
+- **module**: Which module it belongs to
+- **severity**: "critical", "high", "medium", "low"
+- **implementationPoints**: Array of {layer, component, method, implementation}
+
+Layers: Domain, Application, Infrastructure, API, Frontend
+
+## API Endpoint Summary
+
+> **ABSOLUTE RULE:** Copy **EXACTLY** from `specification.apiEndpoints[]`. **NEVER** reinvent routes.
+
+```json
+{
+  "apiEndpointSummary": [
+    {
+      "operation": "ListOrders",
+      "method": "GET",
+      "route": "/api/business/orders",
+      "linkedUC": "UC-001",
+      "linkedFR": "FR-001",
+      "permissions": ["business.orders.read"],
+      "requestSchema": { "type": "query", "params": ["pageNumber", "pageSize", "status"] },
+      "responseSchema": { "type": "PaginatedOrderDto[]" },
+      "errorCodes": [401, 403, 400, 500],
+      "module": "{moduleCode}"
+    },
+    {
+      "operation": "CreateOrder",
+      "method": "POST",
+      "route": "/api/business/orders",
+      "linkedUC": "UC-002",
+      "linkedFR": "FR-002",
+      "permissions": ["business.orders.create"],
+      "requestSchema": { "type": "body", "schema": "CreateOrderDto" },
+      "responseSchema": { "type": "OrderDto" },
+      "errorCodes": [400, 401, 403, 422, 500],
+      "module": "{moduleCode}"
+    }
+  ]
+}
+```
+
+For each endpoint:
+- **operation**: Use case name
+- **method**: HTTP method (GET, POST, PUT, DELETE, PATCH)
+- **route**: Full API path from specification
+- **linkedUC/linkedFR**: Use case and feature requirement IDs
+- **permissions**: Array of exact permission paths
+- **requestSchema**: Input contract (query params or body)
+- **responseSchema**: Output contract
+- **errorCodes**: Expected HTTP error codes
+- **module**: Which module

package/templates/skills/business-analyse/references/html-data-mapping.md

@@ -161,8 +161,16 @@ function buildPermissionKeys(moduleFeature) {
   (matrix.roleAssignments || []).forEach(ra => {
     (ra.permissions || []).forEach(permPath => {
       const action = permPath.split(".").pop();         // last segment = action
-      const uiAction = actionMap[action] || action;
-      keys.push(ra.role + "|" + uiAction);
+      if (action === "*") {
+        // Wildcard: expand to all standard actions
+        Object.values(actionMap).forEach(uiAction => {
+          const key = ra.role + "|" + uiAction;
+          if (!keys.includes(key)) keys.push(key);
+        });
+      } else {
+        const uiAction = actionMap[action] || action;
+        keys.push(ra.role + "|" + uiAction);
+      }
     });
   });
   return keys;