@atlashub/smartstack-cli 4.23.0 → 4.24.0

package/templates/skills/derive-prd/SKILL.md

@@ -29,8 +29,8 @@ Transforms consolidated BA data into structured handoff and PRD files.
 
 ## Input
 
-- Consolidated BA feature (`status = "consolidated"`)
-- Source: `docs/{app}/{module}/business-analyse/v{X.Y}/index.json`
+- Consolidated BA feature (`status = "consolidated"` or `"specified"`)
+- Source: `docs/{app}/business-analyse/v{X.Y}/index.json` (app-level) + `docs/{app}/{module}/business-analyse/v{X.Y}/` (flat files per module)
 - Usage: `--feature <path>` or auto-detection from `docs/`
 
 ## Output
@@ -45,14 +45,14 @@ Transforms consolidated BA data into structured handoff and PRD files.
 
 ## Handoff Categories (8)
 
-| Category | Source | Key rules |
+| Category | Source (flat files) | 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 |
-| **seedData** | `specification.seedDataCore` | CORE + 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 |
+| **seedData** | Generated from entities + permissions | CORE + business |
 | **tests** | All layers | Unit, Integration, Security tests |
 | **documentation** | All layers | Technical docs, user guides, API specs |
 

package/templates/skills/derive-prd/references/acceptance-criteria.md

@@ -1,169 +1,219 @@
 # Module Acceptance Criteria (Shared Reference)
 
-> **Loaded by:** step-03-specify (post-check), step-05-deploy (pre-handoff gate), ralph-loop step-01-task (input validation)
-> **Purpose:** Define measurable, bash-verifiable acceptance criteria that a module MUST pass before being marked "specified".
-> **Key principle:** These checks read the REAL JSON files on disk — NOT in-memory data the model "thinks" it wrote.
+> **Loaded by:** step-00-validate (pre-gate), step-01-transform (post-check)
+> **Purpose:** Define measurable, bash-verifiable acceptance criteria that a module MUST pass.
+> **Key principle:** These checks read the REAL JSON files on disk — NOT in-memory data.
 
 ---
 
-## Why Bash-Verifiable?
+## Architecture: Flat-File Format
 
-All previous checks were **pseudocode interpreted by the model**. The model can "decide" a check passes even when it fails (hallucination of validation). Bash checks are **objective** — they read the actual file and count real elements.
+`/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[]` |
+
+The validation script **assembles** these files before checking.
 
 ---
 
-## Acceptance Criteria Table
-
-| # | Criterion | Minimum | Field Path | Blocking | Category |
-|---|-----------|---------|------------|----------|----------|
-| AC-01 | Entities present | 2 | `analysis.entities[]` | YES | Data Model |
-| AC-02 | Entity attributes have `type` field | ALL | `analysis.entities[].attributes[].type` | YES | Data Model |
-| AC-03 | Use cases present | 2 | `specification.useCases[]` | YES | Requirements |
-| AC-04 | Functional requirements present | 4 | `specification.functionalRequirements[]` | YES | Requirements |
-| AC-05 | Wireframes present | 1 | `specification.uiWireframes[] \|\| specification.wireframes[]` | YES | UI |
-| AC-06 | Wireframes >= sections | count match | wireframes.length >= sections.length | YES | UI |
-| AC-07 | Wireframe content non-empty | ALL | `wireframe.mockup \|\| wireframe.ascii \|\| wireframe.content` | YES | UI |
-| AC-08 | Sections present | 1 | `specification.sections[]` | YES | UI |
-| AC-09 | SeedDataCore 9 arrays non-empty | 9/9 | `specification.seedDataCore.*` | YES | Seed Data |
-| AC-10 | Gherkin scenarios is array | `Array.isArray` | `specification.gherkinScenarios` | YES | Format |
-| AC-11 | API endpoints present | 1 | `specification.apiEndpoints[]` | YES | API |
-| AC-12 | Messages present | 4 | `specification.messages[]` | YES | Messages |
-| AC-13 | Validations present | 1 | `specification.validations[]` | YES | Validation |
-| AC-14 | Wireframe field naming | canonical | `screen` not `title`, `mockup` not `ascii` | WARNING | Convention |
-| AC-15 | Validation rules format | ALL array | `specification.validations[].rules` is `Array` | YES | Format |
-| AC-16 | Messages have `message` field | ALL present | `specification.messages[].message` truthy | YES | Format |
-| AC-17 | Gherkin content structure | ALL valid | Each element has `feature` (string) + `scenarios` (array) | YES | Format |
+## AC Split: Input vs Output
+
+ACs are split into two groups based on **when** they can be validated:
+
+### Input ACs (checked in step-00-validate)
+
+These verify data that `/business-analyse` produces:
+
+| # | Criterion | Minimum | Source File | Blocking |
+|---|-----------|---------|-------------|----------|
+| AC-01 | Entities present | 2 | `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 |
+| AC-05 | Screens present | 1 | `screens.json > screens[]` | YES |
+| AC-06 | Permissions present | 1 | `permissions.json > permissionPaths[]` | YES |
+| AC-07 | Module status consolidated or specified | match | `index.json > metadata.status` | YES |
+
+### Output ACs (checked in step-01 post-transform)
+
+These verify data that `/derive-prd` step-01 generates:
+
+| # | Criterion | Minimum | Location | Blocking |
+|---|-----------|---------|----------|----------|
+| AC-08 | Handoff has 8 categories | 8 | `handoff.filesToCreate` | YES |
+| AC-09 | BR-to-code mapping present | 1 | `handoff.brToCodeMapping[]` | YES |
+| AC-10 | API endpoint summary present | 1 | `handoff.apiEndpointSummary[]` | YES |
+| AC-11 | SeedData entries have category | ALL | `handoff.filesToCreate.seedData[].category` | YES |
 
 ---
 
-## Bash Verification Script (node -e)
+## Input Validation Script (step-00)
 
-> **Usage:** Called from step-03 post-check after writing module JSON files.
-> Also callable standalone for debugging: `node -e "..." path/to/index.json`
+> **Usage:** Validates BA flat files before transformation.
+> Resolves file paths from module `index.json > files` references.
 
 ```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'));
-const spec = data.specification || {};
-const analysis = data.analysis || {};
-const wf = spec.uiWireframes || spec.wireframes || [];
-const sections = spec.sections || [];
-const sdc = spec.seedDataCore || {};
-
-const checks = [
-  ['AC-01: entities >= 2',          (analysis.entities||[]).length,               2],
-  ['AC-03: useCases >= 2',          (spec.useCases||[]).length,                   2],
-  ['AC-04: FRs >= 4',               (spec.functionalRequirements||[]).length,     4],
-  ['AC-05: wireframes >= 1',        wf.length,                                    1],
-  ['AC-06: wireframes >= sections', wf.length,                                    sections.length],
-  ['AC-08: sections >= 1',          sections.length,                               1],
-  ['AC-09: seedDataCore 9 arrays',  Object.keys(sdc).filter(k => Array.isArray(sdc[k]) && sdc[k].length > 0).length, 9],
-  ['AC-10: gherkin is array',       Array.isArray(spec.gherkinScenarios) ? 1 : 0,  1],
-  ['AC-11: apiEndpoints >= 1',      (spec.apiEndpoints||[]).length,                1],
-  ['AC-12: messages >= 4',          (spec.messages||[]).length,                    4],
-  ['AC-13: validations >= 1',       (spec.validations||[]).length,                 1]
-];
+const path = require('path');
+const dir = process.argv[1];
+
+// Load index.json
+const index = JSON.parse(fs.readFileSync(path.join(dir, 'index.json'), 'utf-8'));
+const files = index.files || {};
+
+// Load flat files (with fallbacks)
+function loadFile(key) {
+  const ref = files[key];
+  if (!ref || !ref.path) return null;
+  const filePath = path.join(dir, ref.path);
+  if (!fs.existsSync(filePath)) return null;
+  return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+}
+
+const entitiesData = loadFile('entities') || {};
+const usecasesData = loadFile('usecases') || {};
+const rulesData = loadFile('rules') || {};
+const permissionsData = loadFile('permissions') || {};
+const screensData = loadFile('screens') || {};
+
+const entities = entitiesData.entities || [];
+const useCases = usecasesData.useCases || [];
+const rules = rulesData.rules || [];
+const permissions = permissionsData.permissionPaths || permissionsData.permissions || [];
+const screens = screensData.screens || [];
+const status = index.metadata?.status || 'unknown';
 
 const fails = [];
-checks.forEach(c => {
-  if (c[1] < c[2]) {
-    fails.push(c);
-    console.error('FAIL: ' + c[0] + ' = ' + c[1] + ' (min: ' + c[2] + ')');
-  }
-});
-
-// AC-02: Entity attribute types
-const badAttrs = (analysis.entities||[]).flatMap(e =>
-  (e.attributes||[]).filter(a => !a.type).map(a => e.name + '.' + a.name)
+
+// 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-02: Entity attributes have type
+const badAttrs = entities.flatMap(e =>
+  (e.attributes || []).filter(a => !a.type).map(a => e.name + '.' + a.name)
 );
 if (badAttrs.length > 0) {
-  fails.push(['AC-02: attr.type missing', badAttrs.length, 0]);
-  console.error('FAIL: AC-02: ' + badAttrs.length + ' attributes without type: ' + badAttrs.slice(0, 5).join(', ') + (badAttrs.length > 5 ? '...' : ''));
+  fails.push('AC-02: ' + badAttrs.length + ' attributes without type');
+  console.error('FAIL: AC-02: ' + badAttrs.length + ' attributes without type: ' + badAttrs.slice(0, 5).join(', '));
 }
 
-// AC-07: Wireframe content non-empty
-const emptyWf = wf.filter(w => !w.mockup && !w.ascii && !w.content);
-if (emptyWf.length > 0) {
-  fails.push(['AC-07: wireframe content empty', emptyWf.length, 0]);
-  console.error('FAIL: AC-07: ' + emptyWf.length + ' wireframes have EMPTY content');
+// AC-03: Use cases >= 2
+if (useCases.length < 2) {
+  fails.push('AC-03: useCases = ' + useCases.length + ' (min: 2)');
+  console.error('FAIL: AC-03: useCases >= 2 = ' + useCases.length + ' (min: 2)');
 }
 
-// AC-14: Wireframe field naming (WARNING only)
-const badFields = wf.filter(w => w.title || w.ascii || (w.name && !w.screen));
-if (badFields.length > 0) {
-  console.warn('WARNING: AC-14: ' + badFields.length + ' wireframes use non-canonical field names (title/ascii/name)');
+// AC-04: Business rules >= 2
+if (rules.length < 2) {
+  fails.push('AC-04: rules = ' + rules.length + ' (min: 2)');
+  console.error('FAIL: AC-04: rules >= 2 = ' + rules.length + ' (min: 2)');
 }
 
-// AC-15: Validation rules format (rules must be array, not string)
-const badRules = (spec.validations||[]).filter(v => v.rules && !Array.isArray(v.rules));
-if (badRules.length > 0) {
-  fails.push(['AC-15: validations[].rules not array', badRules.length, 0]);
-  console.error('FAIL: AC-15: ' + badRules.length + ' validations have rules as string instead of array');
+// 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)');
 }
 
-// AC-16: Messages must have 'message' field
-const noMsg = (spec.messages||[]).filter(m => !m.message);
-if (noMsg.length > 0) {
-  fails.push(['AC-16: messages[].message missing', noMsg.length, 0]);
-  console.error('FAIL: AC-16: ' + noMsg.length + ' messages missing "message" field');
+// AC-06: Permissions >= 1
+if (permissions.length < 1) {
+  fails.push('AC-06: permissions = ' + permissions.length + ' (min: 1)');
+  console.error('FAIL: AC-06: permissions >= 1 = ' + permissions.length + ' (min: 1)');
 }
 
-// AC-17: Gherkin content structure (each element needs feature + scenarios[])
-if (Array.isArray(spec.gherkinScenarios)) {
-  const badGherkin = spec.gherkinScenarios.filter(g => !g.feature || !Array.isArray(g.scenarios));
-  if (badGherkin.length > 0) {
-    fails.push(['AC-17: gherkin content invalid', badGherkin.length, 0]);
-    console.error('FAIL: AC-17: ' + badGherkin.length + ' gherkin entries missing feature or scenarios[]');
-  }
+// AC-07: Status consolidated or specified
+if (status !== 'consolidated' && status !== 'specified') {
+  fails.push('AC-07: status = ' + status + ' (expected: consolidated or specified)');
+  console.error('FAIL: AC-07: status = ' + status + ' (expected: consolidated or specified)');
 }
 
 // Summary
 if (fails.length > 0) {
-  console.error('\\nBLOCKING: ' + fails.length + ' acceptance criteria FAILED');
+  console.error('\\nBLOCKING: ' + fails.length + ' input acceptance criteria FAILED');
   process.exit(1);
 }
-console.log('PASS: All acceptance criteria met (AC-01 to AC-17)');
-" "$MODULE_JSON"
+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);
+" "$MODULE_DIR"
 ```
 
 ---
 
-## Integration Points
+## Output Validation Script (step-01 post-check)
 
-### 1. step-03-specify.md (post-check)
+> **Usage:** Validates handoff data after step-01 transformation.
 
-After writing module JSON files, run the bash script above.
-IF FAIL → re-execute section 11 write with corrected data → re-run until PASS.
+```bash
+MODULE_JSON="{module_index_json_path}"
+node -e "
+const fs = require('fs');
+const data = JSON.parse(fs.readFileSync(process.argv[1], 'utf-8'));
+const handoff = data.handoff || {};
+const ftc = handoff.filesToCreate || {};
+
+const fails = [];
+
+// AC-08: All 8 categories present
+const categories = ['domain', 'application', 'infrastructure', 'api', 'frontend', 'seedData', 'tests', 'documentation'];
+const missing = categories.filter(cat => !ftc[cat]);
+if (missing.length > 0) {
+  fails.push('AC-08: missing categories: ' + missing.join(', '));
+  console.error('FAIL: AC-08: missing categories: ' + missing.join(', '));
+}
 
-### 2. step-05-deploy.md (pre-handoff gate)
+// AC-09: BR-to-code mapping present
+if (!handoff.brToCodeMapping || handoff.brToCodeMapping.length === 0) {
+  fails.push('AC-09: brToCodeMapping is empty');
+  console.error('FAIL: AC-09: brToCodeMapping is empty');
+}
 
-Before writing handoff for each module, run the bash script on the module index.json.
-IF FAIL → STOP handoff for this module, report which criteria failed.
+// AC-10: API endpoint summary present
+if (!handoff.apiEndpointSummary || handoff.apiEndpointSummary.length === 0) {
+  fails.push('AC-10: apiEndpointSummary is empty');
+  console.error('FAIL: AC-10: apiEndpointSummary is empty');
+}
 
-### 3. ralph-loop step-01-task.md (input validation)
+// AC-11: SeedData entries have category
+const seedEntries = ftc.seedData || [];
+const noCat = seedEntries.filter(s => !s.category);
+if (noCat.length > 0) {
+  fails.push('AC-11: ' + noCat.length + ' seedData entries missing category');
+  console.error('FAIL: AC-11: ' + noCat.length + ' seedData entries missing category field');
+}
 
-At PRD load time, run the bash script on each module index.json.
-IF FAIL → BLOCKING: "Module {name} does not meet acceptance criteria — run /business-analyse to fix".
-This prevents ralph-loop from generating code from incomplete specifications.
+if (fails.length > 0) {
+  console.error('\\nBLOCKING: ' + fails.length + ' output acceptance criteria FAILED');
+  process.exit(1);
+}
+console.log('PASS: All output acceptance criteria met (AC-08 to AC-11)');
+" "$MODULE_JSON"
+```
 
 ---
 
-## Recovery Actions per Criterion
+## Recovery Actions
 
 | Criterion | 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 `[gherkinScenarios]` |
-| 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 title→screen, ascii→mockup |
-| AC-15 | Auto-fix: wrap string in array `[rules]` |
-| AC-16 | Auto-fix: copy `description` → `message` |
-| AC-17 | Re-run step-03 gherkin — ensure each entry has `feature` string + `scenarios` array |
+| 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 specification |
+| AC-05 | Re-run `/business-analyse` screen specification |
+| AC-06 | Re-run `/business-analyse` permission specification |
+| AC-07 | Run `/business-analyse` step-04 consolidation |
+| AC-08 | Re-run `/derive-prd` step-01 transform (missing categories) |
+| AC-09 | Re-run `/derive-prd` step-01 transform (BR mapping) |
+| AC-10 | Re-run `/derive-prd` step-01 transform (API endpoints) |
+| AC-11 | Re-run `/derive-prd` step-01 transform (seedData categories) |

package/templates/skills/derive-prd/references/entity-domain-mapping.md

@@ -12,8 +12,8 @@ Each entity identified during business analysis maps to exactly one file in the
 ### Entity -> Domain Entity File
 
 ```
-BA: analysis.entities[].name = "{EntityName}"
-    analysis.entities[].module = "{ModuleCode}"
+BA: entities.json > entities[].name = "{EntityName}"
+    entities.json > entities[].module = "{ModuleCode}"
     metadata.application = "{AppName}"
 
 Domain: src/SmartStack.{AppName}.Domain/{ModuleCode}/Entities/{EntityName}.cs
@@ -21,7 +21,7 @@ Domain: src/SmartStack.{AppName}.Domain/{ModuleCode}/Entities/{EntityName}.cs
 
 **Example:**
 ```
-BA: analysis.entities[].name = "Employee"
+BA: entities.json > entities[].name = "Employee"
     module = "Employees"
     application = "HumanResources"
 
@@ -31,7 +31,7 @@ Domain: src/SmartStack.HumanResources.Domain/Employees/Entities/Employee.cs
 ### ValueObject -> Domain ValueObject File
 
 ```
-BA: analysis.entities[].valueObjects[].name = "{VOName}"
+BA: entities.json > entities[].valueObjects[].name = "{VOName}"
 
 Domain: src/SmartStack.{AppName}.Domain/{ModuleCode}/ValueObjects/{VOName}.cs
 ```
@@ -47,7 +47,7 @@ Domain: src/SmartStack.HumanResources.Domain/Employees/ValueObjects/Address.cs
 ### Enum -> Domain Enum File
 
 ```
-BA: analysis.entities[].enums[].name = "{EnumName}"
+BA: entities.json > entities[].enums[].name = "{EnumName}"
     OR attributes with type "enum" and enumValues[]
 
 Domain: src/SmartStack.{AppName}.Domain/{ModuleCode}/Enums/{EnumName}.cs

package/templates/skills/derive-prd/references/handoff-file-templates.md

@@ -6,7 +6,7 @@
 
 ## 4.1 Domain Files
 
-From `analysis.entities[]`:
+From `entities.json > entities[]`:
 
 ```json
 "domain": [
@@ -18,7 +18,7 @@ Include: Value objects, Enums (`src/Domain/Enums/...`), Domain exceptions (`src/
 
 ## 4.2 Application Files
 
-From `analysis.useCases[]`:
+From `usecases.json > useCases[]`:
 
 ```json
 "application": [
@@ -32,7 +32,7 @@ Include: Service per UC cluster, DTOs for API contracts, Validators (FluentValid
 
 ## 4.3 Infrastructure Files
 
-From `analysis.entities[]`:
+From `entities.json > entities[]`:
 
 ```json
 "infrastructure": [
@@ -44,7 +44,7 @@ Include: EF Core config per entity, DbSet in IExtensionsDbContext, DI registrati
 
 ## 4.4 API Files
 
-From `specification.apiEndpoints[]`:
+Generated from `usecases.json` + `entities.json`:
 
 ```json
 "api": [
@@ -56,7 +56,7 @@ Include: One controller per aggregate root, all HTTP methods, error handling
 
 ## 4.5 Frontend Files
 
-From `specification.uiWireframes[]`, `specification.dashboards[]` and `analysis.useCases[]`:
+From `screens.json > screens[]` and `usecases.json > useCases[]`:
 
 > **WIREFRAME TRACEABILITY:** Every frontend file MUST include `linkedWireframes[]` referencing wireframe `screen` identifiers.
 
@@ -86,13 +86,13 @@ From `specification.uiWireframes[]`, `specification.dashboards[]` and `analysis.
 
 ```json
 "seedData": [
-  { "path": "src/Infrastructure/Persistence/Seeding/Data/NavigationApplicationSeedData.cs", "type": "SeedData", "category": "core", "source": "specification.seedDataCore.navigationApplications", "module": "shared", "description": "Application-level navigation seed data. Created ONCE per application (FIRST). Provides ApplicationId for modules and roles." },
-  { "path": "src/Infrastructure/Persistence/Seeding/Data/ApplicationRolesSeedData.cs", "type": "SeedData", "category": "core", "source": "specification.seedDataCore.rolePermissions", "module": "shared", "description": "Application-scoped role definitions (admin, manager, contributor, viewer). Created ONCE per application. Provides role entries for SeedRolesAsync()." },
-  { "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}/NavigationSectionSeedData.cs", "type": "SeedData", "category": "core", "source": "specification.seedDataCore.navigationSections", "module": "{moduleCode}", "description": "MANDATORY when sections defined. Seeds section-level navigation entries (list, dashboard, etc.) with full absolute routes." },
-  { "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.rolePermissions", "module": "{moduleCode}" },
-  { "path": "src/Infrastructure/Persistence/Seeding/Data/{ModuleName}/{Entity}SeedData.cs", "type": "SeedData", "category": "business", "source": "specification.seedDataBusiness.{module}", "module": "{moduleCode}" }
+  { "path": "src/Infrastructure/Persistence/Seeding/Data/NavigationApplicationSeedData.cs", "type": "SeedData", "category": "core", "source": "generated from permissions.json + screens.json", "module": "shared", "description": "Application-level navigation seed data. Created ONCE per application (FIRST). Provides ApplicationId for modules and roles." },
+  { "path": "src/Infrastructure/Persistence/Seeding/Data/ApplicationRolesSeedData.cs", "type": "SeedData", "category": "core", "source": "generated from permissions.json + screens.json", "module": "shared", "description": "Application-scoped role definitions (admin, manager, contributor, viewer). Created ONCE per application. Provides role entries for SeedRolesAsync()." },
+  { "path": "src/Infrastructure/Persistence/Seeding/Data/{ModuleName}/NavigationModuleSeedData.cs", "type": "SeedData", "category": "core", "source": "generated from permissions.json + screens.json", "module": "{moduleCode}" },
+  { "path": "src/Infrastructure/Persistence/Seeding/Data/{ModuleName}/NavigationSectionSeedData.cs", "type": "SeedData", "category": "core", "source": "generated from permissions.json + screens.json", "module": "{moduleCode}", "description": "MANDATORY when sections defined. Seeds section-level navigation entries (list, dashboard, etc.) with full absolute routes." },
+  { "path": "src/Infrastructure/Persistence/Seeding/Data/{ModuleName}/PermissionsSeedData.cs", "type": "SeedData", "category": "core", "source": "generated from permissions.json + screens.json", "module": "{moduleCode}" },
+  { "path": "src/Infrastructure/Persistence/Seeding/Data/{ModuleName}/RolesSeedData.cs", "type": "SeedData", "category": "core", "source": "generated from permissions.json + screens.json", "module": "{moduleCode}" },
+  { "path": "src/Infrastructure/Persistence/Seeding/Data/{ModuleName}/{Entity}SeedData.cs", "type": "SeedData", "category": "business", "source": "generated from entities.json", "module": "{moduleCode}" }
 ]
 ```
 

package/templates/skills/derive-prd/references/handoff-mappings.md

@@ -2,7 +2,7 @@
 
 ## Business Rules to Code Mapping
 
-Derive from module index.json `analysis.businessRules[]` of **EACH module**.
+Derive from module `rules.json > rules[]` of **EACH module**.
 
 Generate complete mapping for each BR:
 
@@ -26,21 +26,21 @@ Generate complete mapping for each BR:
 ```
 
 For each BR include:
-- **ruleId**: Reference to analysis.businessRules[].id
+- **ruleId**: Reference to `rules.json > rules[].id`
 - **title**: The rule statement
 - **module**: Which module it belongs to
-- **severity**: "critical", "high", "medium", "low"
+- **severity**: From `rule.severity` (blocking, info, etc.) mapped to "critical", "high", "medium", "low"
 - **implementationPoints**: Array of {layer, component, method, implementation}
 
 Layers: Domain, Application, Infrastructure, API, Frontend
 
 ## Person Extension Mapping
 
-When an entity has `personRoleConfig` in its analysis data, it MUST be carried into the PRD:
+When an entity has `personRoleConfig` in its entity data, it MUST be carried into the PRD:
 
-| Source (index.json) | Target (PRD) |
-|----------------------|--------------|
-| `analysis.entities[].personRoleConfig` | `modules[].entities[].personRoleConfig` |
+| Source (entities.json) | Target (PRD) |
+|------------------------|--------------|
+| `entities[].personRoleConfig` | `modules[].entities[].personRoleConfig` |
 | `personRoleConfig.userLinkMode` | Determines scaffold options: `isPersonRole: true, userLinkMode: "{mode}"` |
 | `personRoleConfig.inheritedFields` | Fields to exclude from entity (mandatory) or mark as fallback (optional) |
 
@@ -50,7 +50,8 @@ The `personRoleConfig` object is passed through verbatim to ensure `/apex` and `
 
 ## API Endpoint Summary
 
-> **ABSOLUTE RULE:** Copy **EXACTLY** from index.json `specification.apiEndpoints[]`. **NEVER** reinvent routes.
+> **Generated by step-01 from `usecases.json > useCases[]` + `entities.json > entities[]` + `permissions.json`.**
+> BA does not produce apiEndpoints directly -- they are derived during transformation.
 
 ```json
 {
@@ -60,7 +61,6 @@ The `personRoleConfig` object is passed through verbatim to ensure `/apex` and `
       "method": "GET",
       "route": "/api/orders",
       "linkedUC": "UC-001",
-      "linkedFR": "FR-001",
       "permissions": ["orders.read"],
       "requestSchema": { "type": "query", "params": ["pageNumber", "pageSize", "status"] },
       "responseSchema": { "type": "PaginatedOrderDto[]" },
@@ -72,7 +72,6 @@ The `personRoleConfig` object is passed through verbatim to ensure `/apex` and `
       "method": "POST",
       "route": "/api/orders",
       "linkedUC": "UC-002",
-      "linkedFR": "FR-002",
       "permissions": ["orders.create"],
       "requestSchema": { "type": "body", "schema": "CreateOrderDto" },
       "responseSchema": { "type": "OrderDto" },
@@ -84,11 +83,11 @@ The `personRoleConfig` object is passed through verbatim to ensure `/apex` and `
 ```
 
 For each endpoint:
-- **operation**: Use case name
+- **operation**: Derived from 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
+- **route**: Generated from app/module path convention
+- **linkedUC**: Use case ID from usecases.json
+- **permissions**: Array of permission paths from permissions.json
 - **requestSchema**: Input contract (query params or body)
 - **responseSchema**: Output contract
 - **errorCodes**: Expected HTTP error codes

package/templates/skills/derive-prd/references/handoff-seeddata-generation.md

@@ -306,7 +306,7 @@ IF seedDataCore.navigationSections.length === 0:
 ```javascript
 ba-writer.enrichSection({
   featureId: {feature_id},
-  section: "specification.seedDataCore",
+  section: "generated seedData (core)",
   data: seedDataCore
 })
 ```