@atlashub/smartstack-cli 4.41.0 → 4.43.0

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

@@ -101,7 +101,7 @@ Execute workflow detection algorithm:
    - Continue to application name determination.
 
 **Key decision points:**
-1. IF review mode → inform user to use `/ba-review` skill instead
+1. IF review mode → inform user to use `/business-analyse-review` skill instead
 2. IF no existing apps → workflow_type = "new"
 3. IF existing apps → analyze similarity → prompt user
 
@@ -418,7 +418,7 @@ This guard catches any accidental creation of module-only files at the wrong sco
 
 ## Step 10: Update Config
 
-Update `.business-analyse/config.json` with new feature information.
+Write ALL context variables to `.business-analyse/config.json`. This file is the **single source of truth** for session state — downstream steps MUST re-read it instead of assuming LLM memory.
 
 ```json
 {
@@ -427,12 +427,22 @@ Update `.business-analyse/config.json` with new feature information.
     "version": "{version}",
     "docsDir": "{docs_dir}",
     "workflowType": "{workflow_type}",
-    "application": "{application_name}"
+    "workflowMode": "{workflow_mode}",
+    "application": "{application_name}",
+    "applicationCode": "{applicationCode}",
+    "projectId": "{project_id}",
+    "language": "{language}",
+    "analysisMode": "interactive",
+    "mcpAvailable": true,
+    "candidateApplications": "{candidate_applications}",
+    "sharedModulesExtracted": "{shared_modules_extracted}"
   },
   "lastInitialized": "{ISO timestamp}"
 }
 ```
 
+> **CRITICAL:** Every downstream step (01-04) MUST start by reading this file to recover variables. Do NOT rely on LLM memory for `docs_dir`, `feature_id`, `applicationCode`, or `workflow_mode`.
+
 ## Step 11: Display Summary
 
 ```
@@ -505,7 +515,7 @@ If initialization was interrupted:
    **Status-based resume routing (check in this order):**
 
    - If status = `"handed-off"` or `"consolidated"`:
-     → Display: "BA workflow complete. Use /ba-generate-html to generate HTML, /ba-review for corrections."
+     → Display: "BA workflow complete. Use /business-analyse-html to generate HTML, /business-analyse-review for corrections."
      → STOP
 
    - If status = `"specified"` AND `metadata.workflow.allModulesSpecified === true`:
@@ -535,5 +545,5 @@ If a project-level index.json is found (scope = "project"):
      → All applications specified → Resume at `step-04-consolidate.md`
 
    - If status = `"consolidated"`:
-     → Display: "BA workflow complete. Use /ba-generate-html to generate HTML."
+     → Display: "BA workflow complete. Use /business-analyse-html to generate HTML."
      → STOP

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

@@ -21,6 +21,15 @@ next_step: steps/step-02-structure.md
 - **NEVER skip the reformulation phase** — it is the foundation of good analysis
 - **NEVER auto-infer cadrage data without client validation** — every key decision is confirmed
 
+## CONTEXT RECOVERY
+
+Re-read session variables from `.business-analyse/config.json` (do NOT rely on LLM memory):
+```javascript
+const config = readJSON('.business-analyse/config.json').currentFeature;
+const { id: feature_id, docsDir: docs_dir, application: application_name,
+        applicationCode, workflowMode: workflow_mode, language, version } = config;
+```
+
 ## YOUR TASK
 
 Frame the analysis scope at the **application level** through an interactive conversation with the client: understand the problem, stakeholders, scope, and define application-level roles. The analysis phase is ALWAYS interactive — the AI listens, reformulates, challenges, and validates with the user.
@@ -127,9 +136,9 @@ Analyze `{feature_description}` silently:
 4. **Prepare challenge questions** — specific to this brief, not generic
 5. **Pre-identify anticipated sections and resources** per detected module
 
-Store in `{pre_analysis}` (internal use only, NOT written to index.json):
+Store in `{pre_analysis}` — Write pre_analysis to cadrage.json as a `_preAnalysis` field (transient — removed on cadrage completion). This ensures the data survives context compaction:
 ```yaml
-pre_analysis:
+_preAnalysis:
   problem_type: "new_tool|replace|automate|centralize"
   detected_modules: [{name, description, detected_sections}]
   shadow_zones: [{topic, why_it_matters, challenge_question}]
@@ -227,7 +236,7 @@ Apply ULTRATHINK after the batch:
 
 Ask in 1-2 batches. After each batch:
 - If only 1 user type mentioned → probe: "Who else interacts? Managers? Admins? External users?"
-- If "everyone sees everything" → challenge: "Even interns? Contractors? Salary data?"
+- If "no restrictions" → probe: "Are there sensitive data (salary, contracts, personal info) that should be restricted to specific roles?"
 - If tasks are generic → ask for a concrete scenario: "Walk me through a typical day"
 
 #### 4c. Functional Scope (ALWAYS — from `questionnaire/02-stakeholders-scope.md`)
@@ -310,7 +319,7 @@ ULTRATHINK — Entity Architecture Analysis for {entity_name}:
    - Module code: {PascalCase}
    - Section `list`: {main entity grid + create action + navigation to detail}
    - Detail page tabs: [{tab_name: content}] (accessible by clicking a row in list)
-   - Additional sections: [{code: justification}] (ONLY functional zones: dashboard, approve, import, rapport...)
+   - Additional sections: [{code: justification}] (ONLY functional sections: dashboard, approve, import, rapport...)
    - Dependencies: [{which modules reference/are referenced by this entity}]
    - Topological position: layer {N} (foundation if no dependencies)
 ```
@@ -430,7 +439,7 @@ options:
 | Choice | Action |
 |--------|--------|
 | **Géré dans l'app** | Entity becomes a sub-entity of the parent module. Add as a **tab in the detail page** of the referencing module. Note in coverageMatrix with `parentModule` field. |
-| **Nouveau module dédié** | **Add new module to `{pre_analysis}.detected_modules[]`** with the proposed architecture (sections, detail tabs, dependencies). Add to `coverageMatrix` as inScope. The `list` section is ALWAYS the main section. Additional sections ONLY for distinct functional zones (dashboard, approve, import...). `create` and `edit` are ACTIONS within `list` and detail pages, NEVER standalone sections. |
+| **Nouveau module dédié** | **Add new module to `{pre_analysis}.detected_modules[]`** with the proposed architecture (sections, detail tabs, dependencies). Add to `coverageMatrix` as inScope. The `list` section is ALWAYS the main section. Additional sections ONLY for distinct functional sections (dashboard, approve, import...). `create` and `edit` are ACTIONS within `list` and detail pages, NEVER standalone sections. |
 | **Système externe** | Flag for integration specification. Add to `coverageMatrix` as integration. Load questionnaire materials on integrations if not already covered. |
 | **Liste simple en config** | Entity becomes a lookup/reference table (no dedicated module, no section). Note in coverageMatrix as config data. |
 
@@ -583,7 +592,7 @@ BEFORE transitioning to step-02:
    - Create an entry in `cadrage.coverageMatrix[]`
    - Assign it to inScope or outOfScope
    - Assign the module that will cover it (or null if cross-cutting)
-   - List anticipated sections (Level 4) — ONLY functional zones
+   - List anticipated sections (Level 4) — ONLY functional sections
    - List anticipated resources (Level 5) for each section
    - List detail page tabs — for entities accessible via click from `list`
 

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

@@ -11,6 +11,15 @@ next_step: steps/step-03-specify.md
 
 Identify the complete hierarchy **Application > Module > Section > Resource** from the cadrage data, then CHALLENGE each element to ensure nothing is missing or superfluous.
 
+## Context Recovery
+
+Re-read session variables from `.business-analyse/config.json`:
+```javascript
+const config = readJSON('.business-analyse/config.json').currentFeature;
+const { id: feature_id, docsDir: docs_dir, application: application_name,
+        applicationCode, workflowMode: workflow_mode, language } = config;
+```
+
 ## Prerequisites
 
 - Step 01 (cadrage) completed
@@ -83,7 +92,7 @@ For each section:
 | sectionType | permissionMode | When to use | Examples |
 |---|---|---|---|
 | `primary` | `crud` | Main entry point of the module, visible in menu | list |
-| `functional` | `crud` or `custom` | Independent functional zone with own access control | approve, import, planning |
+| `functional` | `crud` or `custom` | Independent functional section with own access control | approve, import, planning |
 | `view` | `inherit` | Subordinate view reached from a primary section | detail, edit |
 | `embedded` | `read-only` | Widget or tab embedded in another section | dashboard (when embedded in module) |
 
@@ -182,6 +191,13 @@ Write via ba-writer:
 }
 ```
 
+## Status Update
+
+After writing the structure, update the application status:
+```javascript
+ba-writer.updateStatus({feature_id}, "decomposed")
+```
+
 ## Transition
 
 → Step 03 (specify) — Sequential module specification

package/templates/skills/business-analyse/steps/step-03-specify.md

@@ -9,7 +9,16 @@ next_step: steps/step-04-consolidate.md
 
 ## Objective
 
-For each module (in dependency order), produce complete specifications: entities, business rules, use cases, and permissions. Interface specs (screens, wireframes, navigation) are handled by Phase 2 (`/ba-design-ui`).
+For each module (in dependency order), produce complete specifications: entities, business rules, use cases, and permissions. Interface specs (screens, wireframes, navigation) are handled by Phase 2 (`/business-analyse-design`).
+
+## Context Recovery
+
+Re-read session variables from `.business-analyse/config.json`:
+```javascript
+const config = readJSON('.business-analyse/config.json').currentFeature;
+const { id: feature_id, docsDir: docs_dir, application: application_name,
+        applicationCode, workflowMode: workflow_mode, language } = config;
+```
 
 ## Prerequisites
 
@@ -51,8 +60,12 @@ For each entity identified in step 02:
     { "name": "departmentId", "type": "guid", "required": true, "description": "Département d'affectation" },
     { "name": "hireDate", "type": "date", "required": true, "description": "Date d'embauche" },
     { "name": "position", "type": "string", "description": "Poste occupé" },
-    { "name": "status", "type": "enum", "options": ["Active", "Inactive", "OnLeave", "Terminated"], "description": "Statut de l'employé" }
+    { "name": "status", "type": "enum", "options": ["Active", "Inactive", "OnLeave", "Terminated"], "defaultValue": "Active", "description": "Statut de l'employé" },
+    { "name": "salary", "type": "decimal", "validation": { "min": 0 }, "description": "Salaire mensuel" }
   ],
+  "estimatedVolume": { "monthly": 50, "total2y": 1200 },
+  "searchableFields": ["code", "position", "status"],
+  "defaultFilters": ["status"],
   "relationships": [
     { "target": "Department", "type": "ManyToOne", "description": "Appartient à un département" },
     { "target": "Contract", "type": "OneToMany", "description": "Possède plusieurs contrats" }
@@ -62,13 +75,14 @@ For each entity identified in step 02:
 
 ### C. Business Rules
 
-For each entity/process, identify rules:
+For each entity/process, identify rules. **Each rule MUST specify `sectionCode`** matching a code from `anticipatedSections[]`:
 
 ```json
 {
   "id": "BR-VAL-EMPLOYEES-001",
   "name": "Validation date embauche",
   "category": "validation",
+  "sectionCode": "list",
   "statement": "La date d'embauche ne peut pas être dans le futur",
   "example": "Date embauche = 2027-01-01 → erreur car > date du jour",
   "entities": ["Employee"],
@@ -76,16 +90,32 @@ For each entity/process, identify rules:
 }
 ```
 
-Categories: `validation`, `calculation`, `workflow`, `security`, `data`
+Categories: `validation`, `calculation`, `workflow`, `security`, `data`, `notification`
+
+> **OBLIGATOIRE** : Chaque attribut `enum` DOIT avoir un `defaultValue`. Chaque attribut numérique borné DOIT avoir `validation.min/max`. Les types userId (FK vers Identity) DOIVENT utiliser le type `string` (convention ASP.NET Identity).
+
+> **OBLIGATOIRE** : Chaque attribut marqué "calculé" dans entities.json DOIT avoir une règle `category: "calculation"` correspondante avec le champ `formula`.
+
+Exemple de règle de calcul :
+```json
+{
+  "id": "BR-CALC-INV-003",
+  "category": "calculation",
+  "statement": "Le reste à payer = total - montant payé",
+  "formula": "remainingAmount = total - paidAmount",
+  "entities": ["Invoice"]
+}
+```
 
 ### D. Use Cases
 
-For each stakeholder action:
+For each stakeholder action. **Each use case MUST specify `sectionCode`** matching a code from `anticipatedSections[]` — this links the UC to the screen/page where it happens:
 
 ```json
 {
   "id": "UC-EMPLOYEES-001",
   "name": "Créer un employé",
+  "sectionCode": "list",
   "actor": "Responsable RH",
   "preconditions": ["L'utilisateur a la permission HumanResources.Employees.Create"],
   "steps": [
@@ -127,49 +157,129 @@ Define the permission matrix:
 - If the cadrage mentions "export", "Excel", "CSV", or "télécharger" → automatically add `.export` permission and an export use case (UC-{PREFIX}-EXPORT)
 - If the cadrage mentions "import", "importer", "upload" → automatically add `.import` permission and an import use case (UC-{PREFIX}-IMPORT)
 
-### F. Interface Specs — Delegated to /ba-design-ui
+### F. Seed Data pour tables de référence
+
+> **OBLIGATOIRE** : Chaque entité de type "table de référence" (lookup, étapes de pipeline, types) DOIT avoir ses valeurs initiales documentées.
+
+```json
+{
+  "entity": "OpportunityStage",
+  "type": "reference-table",
+  "seedData": [
+    { "name": "Qualification", "sortOrder": 1, "defaultProbability": 20, "isWon": false, "isLost": false },
+    { "name": "Proposition", "sortOrder": 2, "defaultProbability": 50, "isWon": false, "isLost": false },
+    { "name": "Négociation", "sortOrder": 3, "defaultProbability": 75, "isWon": false, "isLost": false },
+    { "name": "Gagné", "sortOrder": 4, "defaultProbability": 100, "isWon": true, "isLost": false },
+    { "name": "Perdu", "sortOrder": 5, "defaultProbability": 0, "isWon": false, "isLost": true }
+  ]
+}
+```
+
+### G. Interface Specs — Delegated to /business-analyse-design
 
 > **Screen specifications are NOT produced in this step.**
-> Interface design (SmartTable columns, SmartForm fields, wireframes, navigation) is handled by Phase 2: `/ba-design-ui`.
+> Interface design (SmartTable columns, SmartForm fields, wireframes, navigation) is handled by Phase 2: `/business-analyse-design`.
 > This separation allows iterating on UI design without replaying the full analysis cycle.
 
-### G. Write & Advance
+### H. Write & Advance
 
 After completing all sub-steps for a module:
 
-1. Write via ba-writer:
+1. **Validate against schema BEFORE writing** (uses schemas deployed in step-00):
+   ```javascript
+   ba-writer.validate("entities", entitiesData, docs_dir + "/schemas/entities.json")
+   ba-writer.validate("rules", rulesData, docs_dir + "/schemas/rules.json")
+   ba-writer.validate("usecases", usecasesData, docs_dir + "/schemas/usecases.json")
+   ba-writer.validate("permissions", permissionsData, docs_dir + "/schemas/permissions.json")
+   ```
+   > If validation fails: fix the data and re-validate. Do NOT write invalid JSON.
+
+2. Write via ba-writer:
    - `entities.json`
    - `rules.json`
    - `usecases.json`
    - `permissions.json`
    - Update `index.json` (hashes, summary counts)
 
-2. Update module status to `specified`
+3. Update module status to `specified`
 
 3. Advance to next module in topological order
 
-### H. Module Completion Check
+### I. Module Completion Check
 
 After all modules are specified:
 - Verify all modules have status `specified`
 - Display summary: total entities, rules, UCs, permissions across all modules
-- Remind user: "Run /ba-design-ui to design interfaces for these modules"
+- Remind user: "Run /business-analyse-design to design interfaces for these modules"
 - Transition to step 04
 
-## POST-CHECK
-
-Before advancing to step 04, verify:
-- [ ] Every module has at least 1 entity
-- [ ] Every module has at least 1 use case
-- [ ] Every module has at least 1 business rule
-- [ ] Every module has permissions defined
-- [ ] Entity attributes have `type` defined (string, int, date, enum, guid, etc.)
-- [ ] All entity relationships reference existing entities
-- [ ] All UC business rule references exist
-- [ ] All permission paths follow the convention
-- [ ] Sections with `sectionType: view` do NOT appear in `permissionPaths` (they inherit from module)
-- [ ] Sections with `permissionMode: read-only` only have `.read` in `permissionPaths` (no create/update/delete)
-- [ ] Sections with `permissionMode: inherit` have ZERO entries in `permissionPaths`
+## POST-CHECK (EXECUTABLE — BLOCKING)
+
+Before advancing to step 04, run these validations for EACH module:
+
+```javascript
+const errors = [];
+const warnings = [];
+
+for (const mod of modules) {
+  const ent = READ(mod.dir + '/entities.json')?.entities || [];
+  const ucs = READ(mod.dir + '/usecases.json')?.useCases || [];
+  const brs = READ(mod.dir + '/rules.json')?.rules || [];
+  const perms = READ(mod.dir + '/permissions.json');
+  const sections = mod.anticipatedSections || [];
+  const sectionCodes = new Set(sections.map(s => s.code));
+
+  // Mandatory checks (BLOCKING)
+  if (ent.length === 0) errors.push(mod.code + ": 0 entities");
+  if (ucs.length === 0) errors.push(mod.code + ": 0 use cases");
+  if (brs.length === 0) errors.push(mod.code + ": 0 business rules");
+  if (!perms?.permissionPaths?.length) errors.push(mod.code + ": no permissions");
+
+  // sectionCode validation
+  for (const uc of ucs) {
+    if (!uc.sectionCode) errors.push(mod.code + ": UC '" + uc.id + "' missing sectionCode");
+    else if (!sectionCodes.has(uc.sectionCode)) errors.push(mod.code + ": UC '" + uc.id + "' sectionCode '" + uc.sectionCode + "' not in anticipatedSections");
+  }
+  for (const br of brs) {
+    if (!br.sectionCode) errors.push(mod.code + ": BR '" + br.id + "' missing sectionCode");
+    else if (!sectionCodes.has(br.sectionCode)) errors.push(mod.code + ": BR '" + br.id + "' sectionCode '" + br.sectionCode + "' not in anticipatedSections");
+  }
+
+  // Entity attribute checks
+  for (const e of ent) {
+    for (const a of (e.attributes || [])) {
+      if (!a.type) warnings.push(mod.code + ": entity " + e.name + " attr '" + a.name + "' missing type");
+      if (a.type === 'enum' && !a.defaultValue) errors.push(mod.code + ": enum attr '" + a.name + "' missing defaultValue");
+    }
+  }
+
+  // Cross-reference checks
+  for (const uc of ucs) {
+    for (const brRef of (uc.businessRules || [])) {
+      if (!brs.find(br => br.id === brRef)) warnings.push(mod.code + ": UC '" + uc.id + "' references non-existent BR '" + brRef + "'");
+    }
+  }
+
+  // Section permission checks
+  for (const section of sections) {
+    if (section.sectionType === 'view') {
+      const viewPerms = (perms?.permissionPaths || []).filter(p => p.includes('.' + section.code + '.'));
+      if (viewPerms.length > 0) errors.push(mod.code + ": view section '" + section.code + "' has " + viewPerms.length + " permissions (should inherit)");
+    }
+  }
+}
+
+if (errors.length > 0) {
+  Display("POST-CHECK FAILED (" + errors.length + " errors):");
+  errors.forEach(e => Display("  ✗ " + e));
+  BLOCKING_ERROR("Fix all errors before advancing to step 04");
+}
+if (warnings.length > 0) {
+  Display("POST-CHECK warnings (" + warnings.length + "):");
+  warnings.forEach(w => Display("  ⚠ " + w));
+}
+Display("POST-CHECK PASS: " + modules.length + " modules validated");
+```
 
 ## Transition
 

package/templates/skills/business-analyse/steps/step-04-consolidate.md

@@ -16,8 +16,17 @@ next_step: none
 - NEVER duplicate module content - work with summaries only
 - Single-module shortcut: auto-approve consolidation if only 1 module
 
+## Context Recovery
+
+Re-read session variables from `.business-analyse/config.json`:
+```javascript
+const config = readJSON('.business-analyse/config.json').currentFeature;
+const { id: feature_id, docsDir: docs_dir, application: application_name,
+        applicationCode, workflowMode: workflow_mode, language } = config;
+```
+
 ## YOUR TASK
-Consolidate all modules by validating cross-module interactions, permission coherence, data model integrity, E2E flows, and global risks. Obtain client approval and write consolidation data to validation.json.
+Consolidate all modules by validating cross-module interactions, permission coherence, data model integrity, E2E flows, and global risks. Obtain client approval and write consolidation data.
 
 ---
 
@@ -35,7 +44,7 @@ ba-reader.readApplicationContext({feature_id})
 
 IF status already "consolidated":
   Display: "Consolidation already completed. BA workflow finished."
-  Display: "Next: invoke /ba-generate-html then /ba-review for client cycle."
+  Display: "Next: invoke /business-analyse-design to design interfaces, then /business-analyse-html for client review."
   STOP
 ```
 
@@ -294,8 +303,33 @@ const risks = [
   riskMetrics.sharedEntities > 5 ? {risk: "Many shared entities", severity: "medium"} : null,
   riskMetrics.maxE2EFlowLength > 8 ? {risk: "Long E2E flow", severity: "medium"} : null
 ].filter(r => r !== null);
+
+// OBLIGATOIRE : risks[] ne peut pas être vide
+if (risks.length === 0) {
+  // Force au minimum un risque auto-détecté basé sur les métriques
+  risks.push({
+    risk: `Complexity baseline: ${riskMetrics.totalEntities} entities, ${riskMetrics.totalBRs} BRs, ${riskMetrics.crossModuleDependencies} cross-module deps`,
+    severity: "low",
+    mitigation: "Monitor implementation velocity and adjust estimates if needed"
+  });
+}
 ```
 
+### 7bis. Critères d'acceptation globaux
+
+> **OBLIGATOIRE** : Générer au minimum 1 critère d'acceptation par module.
+
+```json
+"acceptanceCriteria": [
+  { "module": "Invoices", "criteria": "Une facture créée depuis un devis reprend automatiquement le client, les lignes et le montant", "type": "functional" },
+  { "module": "Invoices", "criteria": "Le statut passe automatiquement à 'Paid' quand paidAmount >= total", "type": "business-rule" }
+]
+```
+
+Les types possibles : `functional`, `business-rule`, `performance`, `security`.
+
+Les critères d'acceptation sont écrits dans `validation.json` au même niveau que `globalRiskAssessment`.
+
 ### 8. Consolidation Summary Display
 
 ```
@@ -448,9 +482,10 @@ Display final summary:
 ✓ Status: consolidated
 
 BA workflow complete. Next steps:
-→ Invoke /ba-generate-html to generate the interactive HTML
-→ Invoke /ba-review to apply client corrections
-→ Invoke /derive-prd → /ralph-loop for implementation
+→ Invoke /business-analyse-design to design interfaces (screens, wireframes, navigation)
+→ Invoke /business-analyse-html to generate the interactive HTML for client review
+→ Invoke /business-analyse-review to apply client corrections (if needed)
+→ Invoke /business-analyse-handoff → /business-analyse-develop for implementation
 ```
 
 ---
@@ -483,6 +518,7 @@ BA workflow complete. Next steps:
 ## NEXT STEPS
 
 BA workflow ends here. After consolidation:
-1. Invoke `/ba-generate-html` to generate the interactive HTML document
-2. Invoke `/ba-review` to apply client corrections (if needed)
-3. Invoke `/derive-prd` then `/ralph-loop` for implementation
+1. Invoke `/business-analyse-design` to design interfaces (screens, wireframes, navigation)
+2. Invoke `/business-analyse-html` to generate the interactive HTML document
+3. Invoke `/business-analyse-review` to apply client corrections (if needed)
+4. Invoke `/business-analyse-handoff` then `/business-analyse-develop` for implementation

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

@@ -1,6 +1,6 @@
 # Template Development Handoff
 
-> **Usage:** Template for /derive-prd
+> **Usage:** Template for /business-analyse-handoff
 > **Data source:** index.json (sections: metadata, analysis, specification, handoff)
 
 ---
@@ -12,7 +12,7 @@
 > **Version:** {version}
 > **Validated Specs:** index.json (validation.decision = APPROVED)
 > **Source:** `docs/{app}/{module}/business-analyse/v{version}/index.json`
-> **Implementation:** `/ralph-loop`
+> **Implementation:** `/business-analyse-develop`
 
 ## DEVELOPER INSTRUCTIONS
 
@@ -20,10 +20,10 @@ This document is a self-contained prompt for Claude Code.
 
 **Lancement:**
 ```
-/ralph-loop
+/business-analyse-develop
 ```
 > Ralph-loop auto-detects BA artifacts and derives PRD task breakdowns.
-> Use `/ralph-loop -r` only to resume an interrupted loop.
+> Use `/business-analyse-develop -r` only to resume an interrupted loop.
 
 ---
 
@@ -184,6 +184,6 @@ From: `index.json.specification.seedDataCore` and `index.json.specification.perm
 
 **Lancement:**
 ```bash
-/ralph-loop
+/business-analyse-develop
 ```
 ```

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:** /ba-generate-html (Completion Summary)
+> **Used by:** /business-analyse-html (Completion Summary)
 > **Purpose:** User-facing display templates for BA completion
 > **Note:** No emojis - uses text markers per Claude Code conventions
 
@@ -34,10 +34,10 @@ Effort:    {total_days} days ({total_hours} hours)
   3. Si retours --> relancer /business-analyse pour une nouvelle itération
   4. Une fois validé, lancer le développement:
 
-     /ralph-loop
+     /business-analyse-develop
 
-     Note: /ralph-loop -r sert UNIQUEMENT à reprendre une boucle interrompue.
-           Après un /business-analyse, toujours utiliser /ralph-loop (sans -r).
+     Note: /business-analyse-develop -r sert UNIQUEMENT à reprendre une boucle interrompue.
+           Après un /business-analyse, toujours utiliser /business-analyse-develop (sans -r).
 
 ═══════════════════════════════════════════════════════════════
 ```

package/templates/skills/business-analyse/templates-frd.md

@@ -353,7 +353,7 @@ Feature: {FEAT-XXX} {Feature Name}
 > **Module:** business/{application}/{module}
 > **Version:** 1.0
 > **Validated Specs:** Specification v1.0 (validation.json)
-> **Implementation:** `/ralph-loop`
+> **Implementation:** `/business-analyse-develop`
 
 ## DEVELOPER INSTRUCTIONS
 
@@ -361,10 +361,10 @@ This document is a self-contained prompt for Claude Code.
 
 **Lancement:**
 ```
-/ralph-loop
+/business-analyse-develop
 ```
 > Ralph-loop auto-detects BA artifacts and derives PRD task breakdowns.
-> Use `/ralph-loop -r` only to resume an interrupted loop.
+> Use `/business-analyse-develop -r` only to resume an interrupted loop.
 
 ---
 
@@ -460,7 +460,7 @@ FRONTEND:
 
 **Lancement:**
 ```bash
-/ralph-loop
+/business-analyse-develop
 ```
 ```
 

package/templates/skills/{ba-design-ui → business-analyse-design}/SKILL.md

@@ -1,19 +1,19 @@
 ---
-name: ba-design-ui
+name: business-analyse-design
 description: "Design user interfaces for each module: screens, wireframes, and navigation tree from Phase 1 analysis data."
 model: opus
 user_invocable: true
 ---
 
-# /ba-design-ui
+# /business-analyse-design
 
 Design user interfaces for each module based on the business analysis data (entities, use cases, permissions) produced by `/business-analyse`.
 
 ## Triggers
 
-- Explicit invocation: `/ba-design-ui <feature-id>`
+- Explicit invocation: `/business-analyse-design <feature-id>`
 - After `/business-analyse` step-04 (consolidation complete)
-- After `/ba-review` when corrections target UI/screens
+- After `/business-analyse-review` when corrections target UI/screens
 
 ## Parameters
 
@@ -66,16 +66,16 @@ Project-level:
 ## Post-Design Workflow
 
 ```
-/ba-design-ui completes
+/business-analyse-design completes
     |
     v
-/ba-generate-html (generates interactive HTML with mockups, ERD, permission matrix)
+/business-analyse-html (generates interactive HTML with mockups, ERD, permission matrix)
     |
     v
 Client reviews HTML
     |
     v
-/ba-review (apply corrections, route back to /business-analyse or /ba-design-ui)
+/business-analyse-review (apply corrections, route back to /business-analyse or /business-analyse-design)
 ```
 
 ## References
@@ -83,8 +83,8 @@ Client reviews HTML
 | File | Content |
 |------|---------|
 | `/business-analyse` skill | Source analysis data (entities, UCs, permissions) |
-| `/ba-generate-html` skill | HTML generation consuming screens.json |
-| `ba-generate-html/references/data-mapping.md` | JSON to FEATURE_DATA field mapping |
+| `/business-analyse-html` skill | HTML generation consuming screens.json |
+| `business-analyse-html/references/data-mapping.md` | JSON to FEATURE_DATA field mapping |
 
 ## Entry Point
 

package/templates/skills/{ba-design-ui → business-analyse-design}/steps/step-01-screens.md

@@ -11,6 +11,15 @@ next_step: steps/step-02-wireframes.md
 
 For each module, define all sections and resources with detailed interface specifications: SmartTable columns, SmartForm fields with types, SmartDashboard KPIs, SmartKanban columns.
 
+## Context Recovery
+
+Re-read session variables (do NOT rely on LLM memory from prior skill invocation):
+```javascript
+const config = readJSON('.business-analyse/config.json').currentFeature;
+const { id: feature_id, docsDir: docs_dir, application: application_name,
+        applicationCode, language } = config;
+```
+
 ## Prerequisites
 
 - `/business-analyse` completed (entities, usecases, permissions exist)