@atlashub/smartstack-cli 3.5.0 → 3.7.0

package/templates/skills/business-analyse/steps/step-05b-deploy.md

@@ -1,25 +1,30 @@
 ---
 name: step-05b-deploy
-description: Generate prd.json, progress.txt, deploy ba-interactive.html, manifest, user choice
+description: Generate prd.json, deploy artifacts, interactive HTML
 model: sonnet
 next_step: null
 ---
 
-> **Context files:** `_shared.md`
+> **Context files:** _shared.md
 
-# Step 5b: Handoff - Deploy Artifacts
+# Step 5b: Deploy Artifacts & Interactive HTML
 
 ## MANDATORY EXECUTION RULES
 
 - **ALWAYS** verify all module handoffs are complete before generating artifacts
 - **ALWAYS** derive prd.json from feature.json (NEVER independently)
 - **NEVER** invent entities/FRs/BRs not in feature.json
-- **ALWAYS** deploy ba-interactive.html PRE-POPULATED with all data
 - **ALWAYS** update BA manifest at docs/business/index.json
+- **ALWAYS** deploy ba-interactive.html PRE-POPULATED with all data
+- **ALWAYS** follow references/html-data-mapping.md EXACTLY for FEATURE_DATA and EMBEDDED_ARTIFACTS mapping
+- **FEATURE_DATA.moduleSpecs MUST be populated for EACH module** — empty moduleSpecs = BROKEN specification tabs
+- **FEATURE_DATA.cadrage.scope must use HTML keys** (vital/important/optional/excluded) NOT feature.json keys (mustHave/shouldHave/couldHave/outOfScope)
+- **FEATURE_DATA.metadata.vibeCoding must be set** from master.metadata.vibeCoding (controls section visibility)
+- **NEVER leave FEATURE_DATA or EMBEDDED_ARTIFACTS empty or partial**
 
 ## YOUR TASK
 
-Generate deployment artifacts from the handoff data written in step-05a: prd.json (per module), progress.txt, interactive HTML document, BA manifest, and present development approach choice to the user.
+Generate deployment artifacts (prd.json, progress.txt, BA manifest) and deploy the interactive HTML document pre-populated with all analysis data.
 
 ---
 
@@ -140,77 +145,7 @@ IF ANY category shows FAIL → **STOP AND RE-RUN `ss derive-prd`**. DO NOT proce
 
 ---
 
-### 3. Deploy Interactive HTML Document (MANDATORY)
-
-> **The interactive HTML document is deployed to the project PRE-POPULATED with ALL analysis data.**
-> The client opens it in a browser and sees the complete analysis (cadrage, modules, entities, UCs, BRs, wireframes, permissions, consolidation).
-> The client can then review, edit, enrich, and export modifications as JSON.
-> That JSON can be re-imported via `/business-analyse -x` to update the feature.json.
-
-**Source:** `html/ba-interactive.html` (relative to skill root = `~/.claude/skills/business-analyse/html/`)
-
-**Destination:** `docs/business/{app}/business-analyse/v{version}/ba-interactive.html`
-
-**Deployment steps:**
-
-#### Step 1: Read source data
-
-1. Read the HTML template from skill directory
-2. Read the master feature.json (application level)
-3. Read EACH module feature.json (module level)
-
-> **Reference:** Read `references/html-data-mapping.md` for the complete FEATURE_DATA and EMBEDDED_ARTIFACTS mapping specification.
-
-**Key requirements:**
-- FEATURE_DATA must be pre-populated with ALL analysis data (empty data = BUG)
-- EMBEDDED_ARTIFACTS contains wireframes, E2E diagrams, dependency graph
-- Both objects are serialized as JSON with 2-space indentation
-- All data mapped from master and module feature.json files
-
-#### Step 3: Replace placeholders in template
-
-1. Serialize the FEATURE_DATA object as JSON (with 2-space indentation for readability)
-2. Serialize the EMBEDDED_ARTIFACTS object as JSON (with 2-space indentation)
-3. Replace `{{FEATURE_DATA}}` with the serialized FEATURE_DATA JSON
-4. Replace `{{EMBEDDED_ARTIFACTS}}` with the serialized EMBEDDED_ARTIFACTS JSON
-5. Replace `{{APPLICATION_NAME}}` → `{application_name}` (still used in `<title>` and header)
-6. Replace `{{APPLICATION_ID}}` → `{feature_id}` (still used in `APP_KEY`)
-7. Replace `{{VERSION}}` → `{version}`
-8. Replace `{{CREATED_AT}}` → `{ISO timestamp}`
-
-> **NOTE:** `{{APPLICATION_NAME}}`, `{{APPLICATION_ID}}`, `{{VERSION}}`, `{{CREATED_AT}}` still appear
-> in the HTML body (`<title>`, header, `APP_KEY`). They MUST be replaced separately from FEATURE_DATA.
-
-> **NEW:** `{{EMBEDDED_ARTIFACTS}}` is a separate JavaScript variable in the HTML that stores all visual artifacts (wireframes, E2E diagrams, dependency graph) for client-side rendering and export.
-
-#### Step 4: Write and confirm
-
-1. Write the populated HTML to the output directory
-2. Display deployment confirmation:
-
-```
-✓ Interactive HTML deployed:
-  Path: docs/business/{app}/business-analyse/v{version}/ba-interactive.html
-  Pre-populated with: {stakeholder_count} stakeholders, {module_count} modules,
-    {total_uc} use cases, {total_br} business rules, {total_entity} entities
-  Visual artifacts: {total_wireframes} wireframes, {e2e_flow_count} E2E diagrams
-  Open in browser to review and edit the business analysis.
-  Export JSON and re-import with: /business-analyse -x <exported-json-path>
-```
-
-**Why a FINAL deployment at handoff?**
-- Step 03 already deploys the HTML incrementally after each module (partial data)
-- This final deployment adds the COMPLETE data: all modules + consolidation + handoff info
-- The client sees the FULL analysis pre-populated — including cross-module interactions and E2E flows
-- The client can review, edit, and enrich directly in the browser
-- Any client modifications can be re-imported via `-x` extraction mode
-- The HTML is standalone (no server required) with localStorage persistence
-- On first open: pre-populated data displays. After client edits: localStorage overrides
-- **NOTE:** This overwrites the incremental HTML from step-03 with the complete version
-
----
-
-### 4. Update BA Manifest (MANDATORY)
+### 3. Update BA Manifest (MANDATORY)
 
 > **The BA manifest enables the SmartStack web app to discover and display all available business analyses.**
 > It is a JSON index file at `docs/business/index.json` that lists all feature.json files.
@@ -267,11 +202,248 @@ IF ANY category shows FAIL → **STOP AND RE-RUN `ss derive-prd`**. DO NOT proce
 
 ---
 
-### 5. Completion Summary
+### 4. Read Source Data for HTML
+
+1. Read the HTML template from skill directory: `html/ba-interactive.html` (relative to `~/.claude/skills/business-analyse/`)
+2. Read the master feature.json (application level)
+3. Read EACH module feature.json (module level)
+
+> **Reference:** Read `references/html-data-mapping.md` for the complete FEATURE_DATA and EMBEDDED_ARTIFACTS mapping specification.
+
+**Key requirements:**
+- FEATURE_DATA must be pre-populated with ALL analysis data (empty data = BUG)
+- FEATURE_DATA.**moduleSpecs** MUST be populated for EACH module (use cases, business rules, entities, permissions) — empty moduleSpecs = BROKEN specification tabs
+- FEATURE_DATA.**cadrage.scope** must use HTML keys (vital/important/optional/excluded) NOT feature.json keys (mustHave/shouldHave/couldHave/outOfScope)
+- FEATURE_DATA.**metadata.vibeCoding** must be set from `master.metadata.vibeCoding` (controls section visibility)
+- EMBEDDED_ARTIFACTS contains wireframes, E2E diagrams, dependency graph
+- Both objects are serialized as JSON with 2-space indentation
+- All data mapped from master and module feature.json files — follow `html-data-mapping.md` EXACTLY
+
+---
+
+### 5. Build FEATURE_DATA Object
+
+Reference `references/html-data-mapping.md` EXACTLY. The FEATURE_DATA object must contain:
+
+**Structure:**
+```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
+    // Each entry keyed by moduleCode:
+    "{moduleCode}": {
+      useCases: module.specification.useCases || [],
+      businessRules: module.analysis.businessRules || [],
+      entities: module.analysis.entities || [],
+      permissions: module.specification.permissions || [],
+      apiEndpoints: module.specification.apiEndpoints || []
+    }
+  },
+  consolidation: {
+    // Cross-module analysis
+    integrations: master.consolidation.integrations || [],
+    sharedEntities: master.consolidation.sharedEntities || [],
+    sequenceDiagrams: master.consolidation.e2eFlows || []
+  },
+  handoff: {
+    // From feature.json handoff section
+    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:
+   - Use cases from specification.useCases
+   - Business rules from analysis.businessRules
+   - Entities from analysis.entities
+   - Permissions from specification.permissions
+   - API endpoints from specification.apiEndpoints
+6. Extract consolidation data (integrations, shared entities, E2E flows)
+7. Extract handoff section (complexity, strategy, module order, file counts)
+
+---
+
+### 6. Build EMBEDDED_ARTIFACTS Object
+
+Extract visual artifacts and diagrams from the analysis:
+
+```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
+
+---
+
+### 7. Replace Placeholders in Template
+
+1. Serialize the FEATURE_DATA object as JSON (with 2-space indentation)
+2. Serialize the EMBEDDED_ARTIFACTS object as JSON (with 2-space indentation)
+3. Replace `{{FEATURE_DATA}}` with the serialized FEATURE_DATA JSON
+4. Replace `{{EMBEDDED_ARTIFACTS}}` with the serialized EMBEDDED_ARTIFACTS JSON
+5. Replace `{{APPLICATION_NAME}}` with `{application_name}`
+6. Replace `{{APPLICATION_ID}}` with `{feature_id}`
+7. Replace `{{VERSION}}` with `{version}`
+8. Replace `{{CREATED_AT}}` with `{ISO timestamp}`
+
+**Verification during replacement:**
+- Ensure FEATURE_DATA JSON is valid (no trailing commas, proper nesting)
+- Ensure EMBEDDED_ARTIFACTS JSON is valid
+- Verify placeholders are completely replaced (grep for `{{` to confirm)
+
+---
+
+### 8. Write and Verify
+
+1. Write the populated HTML to the output directory: `docs/business/{app}/business-analyse/v{version}/ba-interactive.html`
+2. Display deployment confirmation:
+
+```
+[OK] Interactive HTML deployed:
+  Path: docs/business/{app}/business-analyse/v{version}/ba-interactive.html
+  Pre-populated with: {stakeholder_count} stakeholders, {module_count} modules,
+    {total_uc} use cases, {total_br} business rules, {total_entity} entities
+  Visual artifacts: {total_wireframes} wireframes, {e2e_flow_count} E2E diagrams
+  Open in browser to review and edit the business analysis.
+  Export JSON and re-import with: /business-analyse -x <exported-json-path>
+```
+
+---
+
+## SELF-VERIFICATION (BEFORE COMPLETION)
 
-Display the completion summary after successful handoff:
+Before displaying completion, VERIFY:
 
-> **Reference:** Read `templates/tpl-launch-displays.md` for user-facing display templates.
+1. **`.ralph/prd-{module}.json`** exists for ALL modules (file size > 100 bytes each)
+2. **`.ralph/progress.txt`** exists (file size > 500 bytes)
+3. **`docs/business/index.json`** exists with correct entry count
+4. **ba-interactive.html** exists and file size > 100KB
+5. **FEATURE_DATA contains moduleSpecs** with entries for ALL modules
+6. **cadrage.scope uses HTML keys** (vital/important/optional/excluded)
+
+**IF any check fails → GENERATE the missing artifact before proceeding to completion.**
+
+---
+
+## POST-CHECK (BLOCKING)
+
+After writing the HTML file, verify:
+
+1. **File size > 100KB** (indicates pre-populated, not empty template)
+   ```bash
+   file_size=$(stat --format=%s "{output_path}/ba-interactive.html")
+   if [ $file_size -lt 100000 ]; then
+     BLOCKING_ERROR("ba-interactive.html is only ${file_size} bytes — not pre-populated")
+   fi
+   ```
+
+2. **Grep for "moduleSpecs"** — MUST be present in generated HTML
+   ```bash
+   if ! grep -q '"moduleSpecs"' "{output_path}/ba-interactive.html"; then
+     BLOCKING_ERROR("moduleSpecs not found in HTML — FEATURE_DATA not serialized correctly")
+   fi
+   ```
+
+3. **moduleSpecs must have entries for ALL modules** (not empty object `{}`)
+   ```bash
+   # Count moduleSpecs entries — should equal module count
+   moduleSpec_count=$(grep -o '"moduleCode"' "{output_path}/ba-interactive.html" | wc -l)
+   if [ $moduleSpec_count -lt {module_count} ]; then
+     BLOCKING_ERROR("moduleSpecs has only ${moduleSpec_count} entries but need {module_count}")
+   fi
+   ```
+
+4. **cadrage.scope must use HTML keys** (vital/important/optional/excluded)
+   ```bash
+   if grep -q '"mustHave"' "{output_path}/ba-interactive.html"; then
+     BLOCKING_ERROR("cadrage.scope still has feature.json keys (mustHave) — must convert to HTML keys (vital)")
+   fi
+   ```
+
+**IF ANY CHECK FAILS → DO NOT PROCEED. Fix the data mapping and regenerate.**
+
+---
+
+## COMPLETION
+
+> **IMPORTANT:** La BA ne lance JAMAIS /ralph-loop automatiquement.
+> Il peut y avoir une phase de revue/modification de la documentation entre les deux étapes.
+> L'utilisateur lance `/ralph-loop` manuellement quand il est prêt.
+
+Display completion using the template from `templates/tpl-launch-displays.md`:
 
 ```
 ═══════════════════════════════════════════════════════════════
@@ -285,9 +457,9 @@ Tasks:     {total tasks} ({core_count} CORE + {biz_count} business + {dev_count}
 Complexity: {complexity}
 Effort:    {total_days} days ({total_hours} hours)
 
-[DIR] Artefacts generés:
+[DIR] Artefacts générés:
   ✓ feature.json (master + per-module) - spécification complète
-  ✓ .ralph/prd.json or .ralph/prd-{module}.json - task breakdown
+  ✓ .ralph/prd-{module}.json - task breakdown per module
   ✓ .ralph/progress.txt - tracker de progression
   ✓ ba-interactive.html - document de revue interactif
 
@@ -302,21 +474,6 @@ Effort:    {total_days} days ({total_hours} hours)
 ═══════════════════════════════════════════════════════════════
 ```
 
-**No AskUserQuestion here.** The BA ends after displaying the summary. The user will manually launch `/ralph-loop -r` when ready (typically after stakeholder validation).
-
----
-
-## SELF-VERIFICATION (FINAL)
-
-Before presenting completion summary, VERIFY:
-
-1. **`.ralph/prd-{module}.json`** exists for ALL modules (file size > 100 bytes each)
-2. **`.ralph/progress.txt`** exists (file size > 500 bytes)
-3. **`ba-interactive.html`** exists at `docs/business/{app}/business-analyse/v{version}/` and file size > 100KB (pre-populated, not empty template)
-4. **`docs/business/index.json`** exists with correct entry count (1 app + N modules)
-
-**IF any check fails → GENERATE the missing artifact before presenting completion summary.**
-
 ---
 
 ## MODE SUPPORT
@@ -350,115 +507,6 @@ Focused handoff for changes:
 
 ---
 
-## OUTPUT
-
-> **FORBIDDEN:** Do NOT generate separate JSON files (specification.json, analysis.json, etc.).
-> **ONLY:** feature.json is the mandatory JSON deliverable.
-> **PLUS:** prd.json and progress.txt are additional working files.
-
-This step enriches **feature.json** (master + per-module) with:
-- **handoff** section: complexity, implementationStrategy, moduleOrder, filesToCreate (7 categories), brToCodeMapping, apiEndpointSummary, prdFiles
-- **status:** "handed-off"
-
-Also generates working files and updates the manifest:
-
-- **ba-interactive.html** (deployed to docs/business/{app}/business-analyse/v{version}/)
-  - Standalone interactive HTML document for client review
-  - Pre-populated with application name, ID, version
-  - Client can edit, add use cases, modify scope, and export JSON
-  - Re-importable via `/business-analyse -x <exported-json-path>`
-
-- **.ralph/prd.json** (or .ralph/prd-{module}.json per module structure)
-  - Derived entirely from feature.json
-  - Single source of truth for development team
-  - Includes all entities, use cases, business rules, API endpoints
-  - Task breakdown and implementation sequence
-
-- **.ralph/progress.txt**
-  - Main development task tracker
-  - Hierarchical structure (module → layer → tasks)
-  - Checkboxes for progress tracking
-  - Effort estimates per module
-  - Cross-module integration tasks (if multi-module)
-
-Completion: Display summary with `/ralph-loop -r` command for later execution after stakeholder validation.
-
----
-
-## EXAMPLES & TEMPLATES
-
-### Example: Simple Single Module (Orders)
-
-**Feature:** Order Management
-**Module:** Orders (1 entity, 2 use cases, 3 BRs)
-
-**Output:**
-- feature.json with handoff section
-- .ralph/prd.json (single consolidated file)
-- .ralph/progress.txt (~150 lines, 20-30 tasks)
-
-Strategy: Module by module (only 1 module)
-
-### Example: Medium Multi-Module (E-Commerce)
-
-**Feature:** E-Commerce Platform
-**Modules:** Customers (4 entities), Products (6 entities), Orders (8 entities), Invoices (3 entities)
-
-**Dependencies:**
-- Customers: Foundation (no deps)
-- Products: Foundation (no deps)
-- Orders: Depends on Customers + Products
-- Invoices: Depends on Orders
-
-**Output:**
-- feature.json (master + 4 module features) with handoff sections
-- User chooses: per-module prd (.ralph/prd-customers.json, .ralph/prd-products.json, etc.) or consolidated (.ralph/prd.json)
-- .ralph/progress.txt (~400 lines, 100+ tasks)
-- Module order: Customers, Products → Orders → Invoices (topological)
-
-Strategy options: Module by module (recommended), Layer by layer, Hybrid
-
-### Example: Complex Multi-Module (ERP)
-
-**Feature:** Enterprise Resource Planning
-**Modules:** Accounting, Sales, Purchasing, Inventory, HR, Finance (20+ entities total, 50+ use cases, 100+ BRs)
-
-**Output:**
-- feature.json (master + 6 module features) with handoff sections
-- Per-module prd.json (recommended for complexity management)
-- .ralph/progress.txt (~800+ lines, 200+ tasks)
-
-Complexity: Complex (highest across all modules)
-Strategy: Hybrid recommended (Foundation modules layer-by-layer, then dependent modules module-by-module)
-
----
-
-## VALIDATION CHECKLIST
-
-Before presenting handoff to user:
-
-- [ ] Status verified: "consolidated"
-- [ ] Implementation strategy selected or defaulted
-- [ ] Complexity calculated for each module and overall
-- [ ] filesToCreate: 7 categories complete, no free text
-- [ ] **WIREFRAME TRACEABILITY:** Every frontend Page/DashboardPage has `linkedWireframes[]` referencing specification.uiWireframes[].screen
-- [ ] **WIREFRAME ACCEPTANCE:** Every frontend Page/DashboardPage has `wireframeAcceptanceCriteria` describing expected layout
-- [ ] brToCodeMapping: All business rules from analysis.businessRules[] mapped
-- [ ] apiEndpointSummary: Exact copy from specification.apiEndpoints[]
-- [ ] prd.json: Derived from feature.json, not independently generated
-- [ ] prd.json: Includes all UCs, FRs, BRs, entities, API endpoints from source
-- [ ] progress.txt: Hierarchical, all modules in topological order, 5 CORE SeedData per module
-- [ ] progress.txt: Frontend tasks reference wireframe identifiers [wireframe: {screen}]
-- [ ] Module order: Follows topological dependency graph
-- [ ] feature.json updated: handoff section + status "handed-off"
-- [ ] All paths use project namespace from .smartstack/config.json
-- [ ] No invented requirements (everything traced to feature.json)
-- [ ] ba-interactive.html deployed PRE-POPULATED with all analysis data (not empty)
-- [ ] BA manifest (docs/business/index.json) updated with current analysis entries
-- [ ] User ready for next agent selection
-
----
-
 ## TROUBLESHOOTING
 
 | Issue | Resolution |
@@ -466,10 +514,12 @@ Before presenting handoff to user:
 | 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-interactive.html deployment failed | Verify output directory exists. Check file permissions. Ensure HTML template is readable. |
-| BA manifest not found | Create docs/business/index.json if missing. Use schema provided in section 4. |
-| HTML pre-populated but empty | Verify FEATURE_DATA and EMBEDDED_ARTIFACTS objects are serialized correctly. Check JSON syntax. |
-
----
-
-END OF STEP 5b: DEPLOY ARTIFACTS
+| 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/templates/tpl-frd.md

@@ -1,7 +1,7 @@
 # Template Functional Requirements Document
 
 > **Usage:** Template for 3-functional-specification.md
-> **Loaded in:** step-03a-specify.md
+> **Loaded in:** step-03a-data.md
 
 ---
 

package/templates/skills/business-analyse/templates/tpl-launch-displays.md

@@ -1,6 +1,6 @@
 # Skill Launch Display Templates (templates/tpl-launch-displays.md)
 
-> **Used by:** step-05b-deploy (section 5: Completion Summary)
+> **Used by:** step-05b-deploy (Completion Summary)
 > **Purpose:** User-facing display templates for BA completion
 > **Note:** No emojis - uses text markers per Claude Code conventions
 

package/templates/skills/controller/steps/step-03-generate.md

@@ -33,8 +33,9 @@ Read: templates/templates.md
 
 **Target path:**
 ```
-src/SmartStack.Api/Controllers/{area}/{module}Controller.cs
+src/SmartStack.Api/Controllers/{ContextShort}/{Application}/{entity}Controller.cs
 ```
+> Context mapping: `business` → `Business`, `platform` → `Admin`, `personal` → `User`
 
 **Apply template with variables:**
 

package/templates/skills/ralph-loop/SKILL.md

@@ -12,11 +12,11 @@ Execute the Ralph Weegund technique - an iterative development methodology where
 <quick_start>
 **Three ways to start Ralph Loop:**
 
-1. **From Business Analysis (RECOMMENDED - NEW v6.1):**
+1. **From Business Analysis (RECOMMENDED):**
    ```bash
    /business-analyse MyFeature
-   # At the end, choose "Ralph Loop" → automatic launch
-   # No arguments needed - prd.json already generated
+   # At the end, BA offers to launch ralph-loop automatically
+   # If PRD files are missing, ralph-loop auto-recovers via ss derive-prd
    ```
 
 2. **Manual start with existing prd.json:**
@@ -311,6 +311,12 @@ Before ANY work, verify MCP servers:
 | 04 | `steps/step-04-check.md` | Check completion, decide next action |
 | 05 | `steps/step-05-report.md` | Generate final report |
 
+**Reference files (loaded conditionally):**
+
+| Ref | File | Loaded when |
+|-----|------|-------------|
+| - | `references/core-seed-data.md` | Infrastructure task involves seed data or IClientSeedDataProvider |
+
 </step_files>
 
 <file_structure>
@@ -402,14 +408,23 @@ Before ANY work, verify MCP servers:
 
 <execution_rules>
 
+- **NEVER DELEGATE THE LOOP** - The Ralph loop MUST execute in the MAIN agent context. NEVER use the Task tool to spawn a sub-agent for loop execution. Sub-agents lose ALL skill context (step files, COMPACT LOOP logic, MCP requirements, SmartStack conventions) and WILL stop prematurely. This is FORBIDDEN. The only acceptable use of Task is for isolated read-only research (e.g., looking up documentation via Context7).
 - **Load step files ONCE** - Step files are read only on FIRST iteration. After that, use the COMPACT LOOP in step-04 section 5.
 - **VERIFY MCP FIRST** - Never skip MCP validation at init
 - **BATCH same-category tasks** - Execute up to 5 tasks of the same category per iteration (reduces loop iterations from 30+ to ~8)
 - **COMMIT AFTER EACH BATCH** - One commit per batch, not per individual task
 - **UPDATE progress.txt** - Persist learnings
 - **NEVER fake completion** - Only output promise when truly done
-- **NEVER STOP THE LOOP** - The loop is AUTONOMOUS. DO NOT pause between iterations. DO NOT wait for user input. Only stop on: completion, max iterations, dead-end, or explicit user interruption. Stopping for any other reason wastes context and causes re-reads.
-- **COMPACT OUTPUT** - During loop iterations, use 1-2 lines per task. Save verbose output for the final report.
+- **NEVER STOP THE LOOP** - The loop is AUTONOMOUS. Stopping is a BUG. Specifically FORBIDDEN:
+  - DO NOT pause between iterations
+  - DO NOT wait for user input
+  - DO NOT output a summary and stop ("I'll continue later")
+  - DO NOT decide to stop because "quality over quantity" or "this is enough for now"
+  - DO NOT stop after completing one module when others remain in the queue
+  - DO NOT reduce scope autonomously ("I'll skip frontend/tests to save time")
+  - The ONLY valid stop reasons: ALL tasks complete, max iterations reached, dead-end (all remaining blocked/failed), or explicit user interruption via Ctrl+C
+- **CONTEXT BUDGET** - Keep ALL output COMPACT during loop iterations. Verbose reasoning wastes context tokens and causes premature termination. Use 1-2 lines per task during the loop. Save detailed output for the final report ONLY. During init, skip verbose MCP output and keep summaries minimal.
+- **MODULE COMPLETENESS** - A module is NOT complete unless ALL expected layers have completed tasks: domain, infrastructure, application, api, frontend, i18n, test. If any layer is missing, inject guardrail tasks before advancing to the next module.
 </execution_rules>
 
 <success_criteria>