@atlashub/smartstack-cli 3.2.0 → 3.3.1

package/package.json

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

package/templates/agents/ba-reader.md

@@ -357,7 +357,7 @@ This agent provides context for:
 - **feature-full**: Source for comprehensive feature documentation
 - **Code generation**: Permission paths and entity definitions
 - **ba-writer**: Finding features for enrichment operations
-- **step-03-specify**: Completed module summaries for cross-module references
+- **step-03a-specify**: Completed module summaries for cross-module references
 - **step-04-consolidation**: Application context and module summaries for cross-module validation
 - Other skills needing business analysis context
 

package/templates/agents/ba-writer.md

@@ -44,6 +44,13 @@ Create an initial feature.json with metadata and draft status.
    - For module scope: discovery: {}, analysis: {}, specification: {}, validation: {}, handoff: {}, suggestions: [], applicationContext: {}
 5. Update `.business-analyse/config.json` with new lastFeatureId
 6. Append entry to changelog
+7. IF scope = "module" AND applicationRef provided AND moduleCode provided:
+   a. Read master feature.json (via applicationRef FEAT-NNN)
+   b. Find module in modules[] where code === moduleCode
+   c. Set module.featureJsonPath to the relative path of the created feature.json
+      (relative from BA root, e.g. "modules/{moduleCode}/business-analyse/v{X.Y}/feature.json")
+   d. Write master feature.json back
+8. Return feature ID, path, and confirmation
 
 ### createApplicationFeature
 Create a master application-level feature.json. Shorthand for `create` with `scope: "application"`.
@@ -152,7 +159,7 @@ Update the status of a specific module in the master feature.json.
 **Input:**
 - featureId: FEAT-NNN of the master
 - moduleCode: string (PascalCase module code)
-- status: "pending" | "in-progress" | "specified" | "validated"
+- status: "pending" | "in-progress" | "specified" | "validated" | "handed-off"
 
 **Process:**
 1. Find master feature.json

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

@@ -1,17 +1,16 @@
 ---
 name: business-analyse
-description: Business Analysis v6.1 - Iterative multi-module workflow with optimized performance (schema caching), automatic skill launch transition, and streamlined execution.
+description: Iterative multi-module business analysis with progressive context loading, JSON-first architecture, and interactive HTML deliverables.
 argument-hint: "[-a] [-e] [-q <FEAT-ID> \"question\"] [-r <FEAT-ID> \"change\"] [-m] [-x <json-path>] <feature description>"
 ---
 
 <objective>
 Execute VibeCoding-focused business analysis workflows. This skill produces a single feature.json progressively enriched at each step, published to docs/business/ for web app rendering. Supports 5 use cases: new feature analysis, questions about existing features, feature refactoring, one-shot micro-features, and extraction from interactive HTML documentation.
 
-**New in v6.1:**
-- ⚡ **Performance:** Schema deployment caching (~75% faster subsequent runs)
-- 🚀 **Seamless transition:** Automatic launch of chosen development approach (Ralph Loop / Feature Full)
-- 🎯 **Simplified:** Removed interactive mode (-i flag), streamlined execution
-- 📂 **Modern only:** Legacy `.business-analyse/` structure no longer supported
+**Architecture highlights:**
+- Conditional context loading: each step loads only the shared files it needs (~54% context reduction)
+- Split long steps for reliability: 03→03a+03b, 05→05a+05b with self-verification at transitions
+- Templates and references extracted to separate files, loaded on demand
 </objective>
 
 <quick_start>
@@ -174,16 +173,13 @@ When provided, step-00 will:
 - **Step 00:** Parse flags, create master feature.json (draft)
 - **Step 01:** Cadrage: context, stakeholders, scope, application roles (framed)
 - **Step 02:** Decomposition: modules, dependencies, client checkpoint (decomposed)
-- **Step 03:** Iterative specification per module (specified)
-  - For each module in dependency order:
-    - Walk through sections & resources with client
-    - Propose ASCII/SVG mockups per section
-    - Define entities + business rules
-    - Generate specification (UC, FR, permissions, SeedData)
-    - Per-module validation + client confirmation
+- **Step 03a:** Interactive specification per module: sections, wireframes, entities, BR, use cases
+- **Step 03b:** Compilation: write spec to feature.json, validate, deploy HTML, loop decision
+  - Loop: 03a → 03b → 03a (next module) until all specified (specified)
 - **Step 04:** Cross-module consolidation (consolidated)
-- **Step 05:** Handoff with per-module prd.json (handed-off)
-  - **NEW v6.1:** User chooses development approach (AskUserQuestion)
+- **Step 05a:** Build handoff data: file mapping, BR-to-code, API summary, write to feature.json
+- **Step 05b:** Deploy artifacts: prd.json, progress.txt, HTML, manifest, user choice (handed-off)
+  - User chooses development approach (AskUserQuestion)
   - **If "Ralph Loop":** Automatic launch → `/ralph-loop` (seamless transition)
   - **If "Feature Full":** Automatic launch → `/feature-full` (parallel generation)
   - **If "Terminer":** BA ends, manual development
@@ -192,15 +188,13 @@ When provided, step-00 will:
 - **Step 00:** Parse flags, create master feature.json (draft)
 - **Step 01:** Cadrage: context, stakeholders, scope, roles (framed)
 - **Step 02:** Decomposition: trivial (1 module), quick checkpoint (decomposed)
-- **Step 03:** Specification: single iteration (specified)
+- **Step 03a → 03b:** Specification: single iteration (specified)
 - **Step 04:** Consolidation: auto-pass (consolidated)
-- **Step 05:** Handoff (handed-off)
-  - **NEW v6.1:** Automatic skill launch based on user choice
+- **Step 05a → 05b:** Handoff + deploy (handed-off)
 
 **Micro workflow:**
 - **Step 00:** Create minimal feature.json
-- **Step 05:** Direct handoff (skip 01-04)
-  - **NEW v6.1:** Automatic skill launch
+- **Step 05a → 05b:** Direct handoff + deploy (skip 01-04)
 
 **Extract workflow (from interactive HTML):**
 - **Step 00:** Parse `-x` flag, validate JSON file
@@ -241,9 +235,11 @@ When provided, step-00 will:
 | 00   | `steps/step-00-init.md`           | Haiku  | Parse flags, route use case, create master feature.json |
 | 01   | `steps/step-01-cadrage.md`        | Opus   | Framing: context, stakeholders, scope, application roles |
 | 02   | `steps/step-02-decomposition.md`  | Sonnet | Module decomposition, dependency graph, client checkpoint |
-| 03   | `steps/step-03-specify.md`        | Opus   | Iterative per-module specification + validation |
+| 03a  | `steps/step-03a-specify.md`       | Opus   | Per-module specification: interactive phase (sections, entities, BR, wireframes, use cases) |
+| 03b  | `steps/step-03b-compile.md`       | Opus   | Per-module compilation: write spec, validate, HTML deploy, loop decision |
 | 04   | `steps/step-04-consolidation.md`  | Sonnet | Cross-module validation, E2E flows, permissions coherence |
-| 05   | `steps/step-05-handoff.md`        | Opus   | Development prompt + Ralph Loop prd.json |
+| 05a  | `steps/step-05a-handoff.md`       | Sonnet | Build handoff data, write to module + master feature.json |
+| 05b  | `steps/step-05b-deploy.md`        | Sonnet | Generate prd.json, progress.txt, deploy HTML, manifest, user choice |
 | 06   | `steps/step-06-extract.md`        | Sonnet | Extract interactive HTML export → feature.json |
 
 </step_files>
@@ -288,13 +284,15 @@ Load ONLY relevant categories based on feature type:
 | spec     | `templates/tpl-frd.md`              | 02           |
 | handoff  | `templates/tpl-handoff.md`          | 04           |
 | suggestions | `patterns/suggestion-catalog.md` | 01           |
-| interactive | `html/ba-interactive.html`        | 05 (deploy)  |
+| interactive | `html/ba-interactive.html`        | 03b (incremental), 05b (final deploy)  |
 
 </template_files>
 
 <execution_rules>
 
 - **Load one step at a time** - Only load the current step file
+- **Load shared files conditionally** - Each step loads only the _shared files it needs (see step headers)
+- **Reference files on demand** - Templates and mappings in references/ and templates/ are loaded only when needed
 - **ULTRATHINK** for steps 01, 02, 04 (critical thinking)
 - **State persisted in feature.json** (NOT markdown files)
 - **Use ba-writer agent** for all JSON writes

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

@@ -0,0 +1,123 @@
+# Business Analysis - SmartStack Architecture Reference (_architecture.md)
+
+> **Loaded by:** step-01-cadrage, step-03a-specify, step-05a-handoff
+> **Purpose:** Provide architectural context for relevant questions and aligned recommendations
+
+---
+
+## 5 Couches (Clean Architecture)
+
+| Couche | Projet | Contenu | Impact BA |
+|--------|--------|---------|-----------|
+| **Domain** | `SmartStack.Domain` | Entites, enums, interfaces | Entites identifiees en discovery |
+| **Application** | `SmartStack.Application` | CQRS (Commands/Queries), validations, DTOs | Use cases de la specification |
+| **Infrastructure** | `SmartStack.Infrastructure` | EF Core, services externes, jobs | Integrations et contraintes techniques |
+| **API** | `SmartStack.API` | Controllers REST, permissions | Endpoints et securite |
+| **Web** | `smartstack-web` | React 19, pages, composants | UI/UX et navigation |
+
+---
+
+## Classes de Base des Entites
+
+| Classe | Interface | Champs auto-inclus | Quand utiliser |
+|--------|-----------|---------------------|----------------|
+| `BaseEntity` | - | `Id` (Guid), `TenantId`, `CreatedAt`, `UpdatedAt` | **Defaut pour toute entite metier** |
+| `BaseEntity` | `IAuditableEntity` | + `CreatedBy`, `UpdatedBy` | Entite avec audit complet |
+| `SystemEntity` | - | `Id` (Guid), `CreatedAt` (pas de TenantId) | Entites systeme (navigation, permissions) |
+| `BaseEntity` | `ISoftDeletable` | + `IsDeleted`, `DeletedBy`, `DeletedAt` | Entite avec suppression logique |
+| `HierarchicalEntity` | - | + `ParentId`, `Level`, `Path` | Arborescences (categories, menus) |
+
+> **IMPORTANT :** Ne JAMAIS proposer `CreatedBy`, `UpdatedBy`, `IsDeleted`, `TenantId` comme champs explicites — ils sont AUTOMATIQUES via la classe de base ou l'interface.
+
+---
+
+## Services d'Integration Disponibles
+
+| Service | Interface | Quand le proposer |
+|---------|-----------|-------------------|
+| Notifications in-app | `INotificationService` | Alertes, evenements, rappels |
+| Workflow automatise | `IWorkflowService` | Emails transactionnels, webhooks, actions chainees |
+| Completion IA | `IAICompletionService` | Suggestions, classification, generation contenu |
+| SignalR temps reel | `IHubContext<BusinessHub>` | Mises a jour en temps reel |
+| Jobs planifies | Hangfire `IBackgroundJobClient` | Traitements differes, purges, imports |
+
+---
+
+## Conventions Base de Donnees
+
+| Aspect | Convention | Exemple |
+|--------|------------|---------|
+| Schema | `core` (socle SmartStack) vs `extensions` (entites client/metier) | `core.auth_Roles`, `nav_Applications`, `supp_Tickets` |
+| Tables | `{prefix}_{EntityPlural}` (prefixe domaine + PascalCase pluriel) | `auth_Users`, `nav_Applications`, `supp_Tickets` |
+| Prefixes domaine | `auth_`, `nav_`, `cfg_`, `ref_`, `wkf_`, `ai_`, `loc_`, `lic_`, `tenant_`, `support_` | Pour un nouveau module metier : choisir un prefixe court (3-5 chars) |
+| FK | `{Entity}Id` (ex: `ClientId`, `OrderId`) | |
+| Index | `IX_{Table}_{Column}` | `IX_bik_FreeBickes_TenantId_Code` |
+| Migration | 1 migration par feature, nommee via MCP (`suggest_migration`) | `extensions_v1.0.0_001_AddFreeBicke` |
+
+---
+
+## Conventions de Dossiers (Clean Architecture)
+
+| Couche | Pattern de dossiers | Exemple (module FreeBicke dans business > operations) |
+|--------|--------------------|---------------------------------------------------------|
+| **Domain** | `{Project}.Domain/Business/{Application}/{Module}/` | `Domain/Business/Operations/FreeBicke/FreeBicke.cs` |
+| **Application/DTOs** | `{Project}.Application/Business/{Application}/{Module}/DTOs/` | `Application/Business/Operations/FreeBicke/DTOs/FreeBickeDto.cs` |
+| **Application/Interfaces** | `{Project}.Application/Common/Interfaces/` | `Application/Common/Interfaces/IFreeBickeService.cs` |
+| **Infrastructure/Config** | `{Project}.Infrastructure/Persistence/Configurations/{Module}/` | `Configurations/FreeBicke/FreeBickeConfiguration.cs` |
+| **Infrastructure/Services** | `{Project}.Infrastructure/Services/{Module}/` | `Services/FreeBicke/FreeBickeService.cs` |
+| **Infrastructure/SeedData** | `{Project}.Infrastructure/Persistence/Seeding/Data/{Module}/` | `Seeding/Data/FreeBicke/FreeBickeSeedData.cs` |
+| **API/Controllers** | `{Project}.Api/Controllers/Business/{Application}/` | `Controllers/Business/Operations/FreeBickeController.cs` |
+| **Frontend/Pages** | `web/src/pages/business/{application}/{module}/` | `pages/business/operations/freebicke/page.tsx` |
+| **Frontend/i18n** | `web/src/i18n/locales/{lang}/{module}.json` | `locales/fr/freebicke.json` |
+
+> **IMPORTANT :** Chaque module a son **propre sous-dossier** dans chaque couche. Ne JAMAIS mettre tous les fichiers a la racine d'une couche.
+
+---
+
+## SeedData Core (Obligatoire pour chaque feature)
+
+> **Chaque nouvelle feature necessite des SeedData dans 5 fichiers core** pour etre fonctionnelle (navigation visible, permissions actives, roles assignes).
+
+| # | Fichier | Contenu | Mecanisme |
+|---|---------|---------|-----------|
+| 1 | `NavigationModuleConfiguration.cs` | Entree module dans `nav_Modules` (HasData) | EF Core Migration |
+| 2 | `NavigationTranslationConfiguration.cs` | Traductions du module (4 langues x chaque entite nav) | EF Core Migration |
+| 3 | `PermissionConfiguration.cs` | Permissions CRUD + wildcards dans `nav_Permissions` (HasData) | EF Core Migration |
+| 4 | `Permissions.cs` (Application layer) | Constantes compile-time pour `[RequirePermission]` | Code |
+| 5 | `RolePermissionConfiguration.cs` | Associations role-permission dans `auth_RolePermissions` (HasData) | EF Core Migration |
+
+**Roles par defaut pour chaque application (4 niveaux) :**
+
+| Role | Permissions | Description |
+|------|-------------|-------------|
+| **{App} Admin** | `{context}.{app}.*` (wildcard) | Acces complet a l'application |
+| **{App} Manager** | `read`, `create`, `update`, `assign` | Gestion complete sans suppression |
+| **{App} Contributor** | `read`, `create`, `update` | Contribution active |
+| **{App} Viewer** | `read` uniquement | Consultation seule |
+
+> **CRITIQUE :** Si les SeedData ne sont pas crees, le module sera invisible dans la navigation et les permissions retourneront 403.
+
+---
+
+## Contraintes Non-Negociables
+
+| Contrainte | Detail |
+|------------|--------|
+| **Multi-tenant** | `TenantId` sur toute entite metier, isolation automatique |
+| **RBAC** | Permissions `business.{app}.{module}.{action}`, HasData pattern |
+| **CQRS** | Commands (write) et Queries (read) separes via MediatR |
+| **Validation** | FluentValidation pour toute commande |
+| **i18n** | 4 langues obligatoires (fr, en, it, de) |
+| **Soft Delete** | Pas de DELETE physique sauf purge RGPD planifiee |
+
+---
+
+## Outils MCP Pertinents pour le BA
+
+| Phase BA | Outil MCP | Usage |
+|----------|-----------|-------|
+| Pre-research (01) | `analyze_extension_points` | Decouvrir modules/entites existants |
+| Pre-research (01) | `api_docs` | Consulter la documentation API existante |
+| Analyse (02) | `validate_conventions` | Verifier les noms d'entites proposes |
+| Specification (03) | `generate_permissions` | Generer la matrice de permissions |
+| Handoff (05) | `scaffold_extension` | Preparer le scaffolding |

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

@@ -0,0 +1,206 @@
+# Business Analysis - Elicitation & Interaction (_elicitation.md)
+
+> **Loaded by:** step-01-cadrage, step-03a-specify
+> **Purpose:** Interactive questioning techniques, AskUserQuestion formatting, ULTRATHINK mode
+
+---
+
+## Interactive Elicitation Protocol
+
+> **RULE: ALL questions MUST be asked interactively using `AskUserQuestion`.**
+> **NEVER dump a list of questions as text. ALWAYS use the tool.**
+
+### Protocol
+
+1. **Group questions by theme** — max 4 questions per `AskUserQuestion` call (tool limit)
+2. **Propose predefined options** — for questions with predictable answers, provide 2-4 options
+3. **The user can always choose "Other"** — the tool adds this automatically for free-text answers
+4. **Process answers immediately** — apply ULTRATHINK + follow-ups before moving to next group
+5. **Adapt next questions** — based on previous answers, skip irrelevant questions
+
+### Batching Strategy
+
+| Category | Questions | Batches |
+|----------|-----------|---------|
+| 01-context | Q1.1-Q1.4 | 1 call |
+| 02-stakeholders | Q2.1-Q2.8 | 2 calls |
+| 03-scope | Q3.1-Q3.8 | 2 calls |
+| 04-data | Q4.1-Q4.8 | 2 calls |
+| 05-integrations | Q5.1-Q5.8 | 2 calls |
+| 06-security | Q6.1-Q6.8 | 2 calls |
+| 07-ui | Q7.1-Q7.8 | 2 calls |
+| 08-performance | Q8.1-Q8.4 | 1 call |
+| 09-constraints | Q9.1-Q9.4 | 1 call |
+| 10-documentation | Q10.1-Q10.4 | 1 call |
+| 11-data-lifecycle | Q11.1-Q11.8 | 2 calls |
+| 12-migration | Q12.1-Q12.8 | 2 calls |
+| 13-cross-module | Q13.1-Q13.8 | 2 calls |
+
+### AskUserQuestion Format
+
+> **FORMATTING CRITICAL: `AskUserQuestion` does NOT support markdown or line breaks.**
+> Le champ `question` est rendu en texte brut (plain text). Il n'y a pas de retour a la ligne,
+> pas de gras, pas de puces. Une question simple reste lisible meme longue. Mais du contenu
+> structure (listes, resumes multi-points, tableaux) devient un mur de texte illisible.
+
+| Field | Rule |
+|-------|------|
+| `question` | **1 question ou 1 phrase.** Jamais de liste, resume multi-points ou contenu structure. |
+| `header` | 1-2 mots (max 12 chars) |
+| `label` (option) | Court et clair (~20 chars) |
+| `description` (option) | 1 phrase explicative (~60 chars) |
+
+> **Pour afficher du contenu structure** (resumes, listes, tableaux, syntheses) :
+> **TOUJOURS** utiliser du **texte direct** (output text) AVANT l'appel `AskUserQuestion`.
+> Le texte direct supporte le markdown et sera correctement formate avec titres, puces, gras, etc.
+>
+> **Exemple — Validation de synthese :**
+> 1. Afficher le resume structure en markdown (texte direct)
+> 2. Puis poser une question courte : "Cette synthese est-elle correcte ?"
+
+```
+AskUserQuestion({
+  questions: [
+    {
+      question: "Quel probleme metier ce module doit-il resoudre ?",
+      header: "Probleme",       // max 12 chars
+      options: [
+        { label: "Processus manuel", description: "Automatiser un processus existant fait manuellement" },
+        { label: "Donnees dispersees", description: "Centraliser des donnees eparpillees dans plusieurs outils" },
+        { label: "Manque visibilite", description: "Obtenir des indicateurs et du suivi inexistants aujourd'hui" },
+        { label: "Conformite", description: "Repondre a une obligation reglementaire ou de securite" }
+      ],
+      multiSelect: false
+    },
+    // ... up to 4 questions per call
+  ]
+})
+```
+
+### After Each Batch
+
+1. **Evaluate answer quality** (see Answer Quality Indicators)
+2. **If insufficient** -> follow-up AskUserQuestion with targeted probes from the Elicitation Guide
+3. **If solution-oriented** -> reframe using Technique 1 before proceeding
+4. **If sufficient/excellent** -> record and move to next batch
+5. **Summarize** what was understood before moving to the next category
+
+---
+
+## Techniques d'elicitation
+
+> **Objectif :** Guider COMMENT questionner, pas seulement QUOI demander.
+> **Principe :** Chaque technique doit etre appliquee naturellement dans le flux de la conversation,
+> pas comme un outil supplementaire. L'analyste choisit la technique adaptee a la situation.
+
+### Technique 1 : Reformulation du besoin
+
+Quand le client decrit une **solution** (bouton, ecran, champ, outil), reformuler en **besoin** :
+
+| Le client dit | L'analyste demande |
+|---------------|-------------------|
+| "Il me faut un menu deroulant pour les roles" | "Quel probleme rencontrez-vous aujourd'hui avec la gestion des acces ? Pourquoi certaines personnes doivent-elles avoir des acces differents ?" |
+| "On a besoin d'un bouton d'export" | "Que faites-vous avec les donnees une fois exportees ? Qui en a besoin et pourquoi ?" |
+| "Ajoutez un champ statut" | "Quel parcours suit cet element du debut a la fin ? Quels evenements declenchent un changement d'etat ?" |
+
+### Technique 2 : Chaine des pourquoi
+
+Quand le besoin semble superficiel, enchainez jusqu'a 5 "Pourquoi ?" pour trouver la cause racine :
+
+```
+Client : "On a besoin de suivre l'activite des utilisateurs"
+-> Pourquoi ? "Pour savoir qui a modifie quoi"
+-> Pourquoi ? "Parce qu'on a eu des problemes de donnees incorrectes"
+-> Pourquoi ? "Parce que plusieurs personnes modifient les memes fiches"
+-> CAUSE RACINE : Conflit d'edition simultanee -> Besoin de journal d'activite + protection des modifications
+```
+
+### Technique 3 : Extraction de scenario concret
+
+Ne jamais accepter de descriptions abstraites. Toujours demander un **scenario de vie reelle** :
+
+```
+"Racontez-moi une journee type : vous arrivez au bureau, vous ouvrez l'application.
+ Quelle est la PREMIERE chose que vous devez faire ?
+ Puis ensuite ? Quelles informations consultez-vous ? Quelles decisions prenez-vous ?"
+```
+
+### Technique 4 : Test d'absence
+
+Valider la necessite en demandant ce qui se passe SANS :
+
+```
+"Si cette fonctionnalite N'EXISTAIT PAS, que feriez-vous a la place ?
+ Combien de temps ou d'argent le contournement actuel coute-t-il ?"
+```
+
+### Technique 5 : Verification de completude
+
+Pour chaque reponse sous forme de liste, verifier qu'il ne manque rien :
+
+| Type de reponse | Relance |
+|-----------------|---------|
+| "Il y a 3 types d'utilisateurs" | "Y a-t-il des acteurs externes ? Des auditeurs ? Des administrateurs systeme ? Des processus automatiques ?" |
+| "Le flux principal est A puis B puis C" | "Que se passe-t-il si l'utilisateur annule a l'etape B ? Si l'etape C echoue ? S'il veut revenir a A ?" |
+| "Champs obligatoires : nom et email" | "Quelles contraintes d'unicite ? Quel format ? Que se passe-t-il en cas de doublon ?" |
+
+### Technique 6 : Projection dans le futur
+
+Demander au client de se projeter pour decouvrir des besoins non exprimes :
+
+```
+"Imaginons que nous sommes 2 ans dans le futur et que l'application fonctionne parfaitement.
+ Qu'est-ce qui a change dans votre facon de travailler ?
+ Quels nouveaux besoins sont apparus auxquels vous ne pensez pas aujourd'hui ?"
+```
+
+### Technique 7 : Test de contradiction
+
+Quand deux reponses semblent contradictoires, les confronter pour clarifier :
+
+```
+"Vous avez mentionne que [affirmation A], mais vous dites aussi que [affirmation B].
+ Ces deux elements semblent en tension. Pouvez-vous m'aider a comprendre
+ comment ils coexistent dans la realite ?"
+```
+
+### Technique 8 : Escalade d'impact
+
+Augmenter progressivement l'echelle pour tester les limites :
+
+```
+"Aujourd'hui vous avez 50 fiches. Que se passe-t-il avec 500 ? Avec 5000 ?
+ Est-ce que le processus reste le meme ou faudrait-il faire differemment ?"
+```
+
+### Indicateurs de qualite des reponses
+
+| Qualite | Signal | Action |
+|---------|--------|--------|
+| **Insuffisante** | Moins d'une phrase, "je ne sais pas", adjectif vague | Appliquer les techniques 1 a 8, demander un exemple concret |
+| **Orientee solution** | Contient des termes d'interface ou techniques (bouton, champ, base de donnees) | Appliquer la technique 1 (reformuler en besoin) |
+| **Suffisante** | Contient QUI, QUOI, POURQUOI et un exemple concret | Continuer, noter le niveau de confiance |
+| **Excellente** | Inclut les cas limites, les contraintes et des criteres mesurables | Continuer, marquer comme "Confirme" |
+
+---
+
+## ULTRATHINK
+
+Behavioral mode for critical phases (01, 03a):
+
+```
+ULTRATHINK MODE:
+- Consider ALL edge cases
+- Challenge EVERY assumption
+- Anticipate UNEXPRESSED needs
+- Validate completeness before output
+- Apply Elicitation Techniques (see above)
+
+DO NOT:
+- Accept vague answers
+- Skip question categories
+- Assume stakeholder thought of everything
+- Accept solutions without understanding the problem first
+```
+
+**DO NOT invoke** as a skill/tool - it is a thinking mode.

package/templates/skills/business-analyse/_module-loop.md

@@ -0,0 +1,56 @@
+# Business Analysis - Module Loop Protocol (_module-loop.md)
+
+> **Loaded by:** step-03a-specify, step-03b-compile
+> **Purpose:** State management and iteration logic for multi-module specification loop
+
+---
+
+## State Management
+
+```json
+{
+  "metadata": {
+    "workflow": {
+      "mode": "application",
+      "moduleOrder": ["Customers", "Products", "Orders", "Invoices"],
+      "currentModuleIndex": 2,
+      "completedModules": ["Customers", "Products"],
+      "currentModule": "Orders"
+    }
+  }
+}
+```
+
+## Loop Logic (end of each step-03 iteration)
+
+```
+1. Mark current module as "validated" in master feature.json
+2. Add to completedModules[]
+3. IF currentModuleIndex + 1 < moduleOrder.length:
+     currentModuleIndex++
+     currentModule = moduleOrder[currentModuleIndex]
+     Write master feature.json
+     Display: "Module {name} complete. Next: {next_name} ({N}/{total})"
+     RE-LOAD: steps/step-03a-specify.md
+4. ELSE:
+     master.status = "specified"
+     Load: steps/step-04-consolidation.md
+```
+
+## Context Management During Loop
+
+To prevent context explosion as modules accumulate:
+- **Current module:** Load full module feature.json
+- **Completed modules:** Only load compact summary via `ba-reader.getCompletedModulesSummary()` (max 100 lines)
+- **Master feature.json:** Only read workflow state + application roles
+
+## Resume After Interruption
+
+```
+1. ba-reader.findApplicationFeature() -> locate master feature.json
+2. Read metadata.workflow.currentModuleIndex
+3. IF currentModule has a feature.json with status != "validated":
+     Resume step-03a-specify for that module
+4. ELSE:
+     Start step-03a-specify for next module
+```