@atlashub/smartstack-cli 4.17.0 → 4.18.0

package/templates/skills/business-analyse/references/team-orchestration.md

@@ -576,6 +576,41 @@ Display:
 "═══ Progress: {completedModules.length}/{moduleOrder.length} modules ═══"
 ```
 
+### 4b-bis. Deploy Incremental Interactive HTML (MANDATORY)
+
+> **Module agents do NOT generate the HTML** — this responsibility belongs to the team lead.
+> After each layer is approved, the team lead generates/updates the interactive HTML with all completed modules.
+> This gives clients early access to review completed modules while the next layer is being specified.
+
+**Execute the incremental HTML deployment:**
+
+1. **Read** the HTML template: `html/ba-interactive.html` (relative to skill root `~/.claude/skills/business-analyse/html/`)
+2. **Read** `references/html-data-mapping.md` for the complete FEATURE_DATA and EMBEDDED_ARTIFACTS mapping specification
+3. **Read** the master feature.json (application level)
+4. **Read** EACH completed module's feature.json (all modules in `teamContext.completedModules`)
+5. **Build FEATURE_DATA** following `references/validate-incremental-html.md`:
+   - `metadata`, `cadrage`, `modules[]`, `dependencies[]` → from master feature.json
+   - `moduleSpecs[moduleCode]` → only for modules with status "specified" (completed so far)
+   - `consolidation` → empty `{ interactions: [], e2eFlows: [] }` (not yet consolidated)
+   - `handoff` → empty `{}` (not yet handed off)
+   - `cadrage.scope` MUST use HTML keys (`vital`/`important`/`optional`/`excluded`), NOT feature.json keys
+6. **Build EMBEDDED_ARTIFACTS** with wireframes for completed modules:
+   - Rename fields: `mockupFormat` → `format`, `mockup` → `content`
+   - Safety net: check BOTH key names (`uiWireframes` / `wireframes`, `mockup` / `ascii` / `content`)
+   - Include dependency graph from master
+7. **Replace placeholders** in template: `{{FEATURE_DATA}}`, `{{EMBEDDED_ARTIFACTS}}`, `{{APPLICATION_NAME}}`, `{{VERSION}}`, etc.
+8. **Write** to `docs/{app}/business-analyse/v{version}/ba-interactive.html`
+
+**Display confirmation:**
+```
+✓ Interactive HTML updated (incremental):
+  Path: docs/{app}/business-analyse/v{version}/ba-interactive.html
+  Modules included: {completedModules.length}/{totalModules} specified
+  → Client can open in browser to review completed modules now.
+```
+
+> **Reference:** See [references/validate-incremental-html.md](validate-incremental-html.md) for the complete deployment process and field mapping details.
+
 ### 4c. Build Updated Context for Next Layer
 
 Before spawning the next layer's agents, rebuild the `completedModulesSummary`:
@@ -768,10 +803,45 @@ Task({
 You are a handoff agent for business-analyse ${workflow.mode === "project" ? `project "${projectName}"` : `application "${appName}"`}.
 
 ## Your Mission
-Execute the handoff sequence (steps 05a + 05b + 05c):
-1. Load steps/step-05a-handoff.md and execute (file mapping, BR-to-code, API summary)
-2. Load steps/step-05b-deploy.md and execute (prd.json, ba-interactive.html, manifest)
-3. Load steps/step-05c-ralph-readiness.md and execute (quality gate)
+Execute the handoff sequence (steps 05a + 05b + 05c). ALL THREE STEPS ARE MANDATORY.
+
+### Step 1: Handoff (step-05a-handoff.md)
+Load steps/step-05a-handoff.md and execute:
+- File mapping (7 categories: domain, application, infrastructure, api, frontend, seedData, tests)
+- BR-to-code mapping
+- API endpoint summary
+
+### Step 2: Deploy Artifacts (step-05b-deploy.md)
+Load steps/step-05b-deploy.md and execute ALL sections:
+
+a. **Generate prd.json** for each module via \`ss derive-prd\` (section 1)
+b. **Initialize progress tracker** (section 2)
+c. **Update BA manifest** docs/index.json (section 3)
+d. **CRITICAL — Deploy ba-interactive.html** (sections 4-8):
+   - Read HTML template from \`html/ba-interactive.html\` (relative to skill root \`~/.claude/skills/business-analyse/html/\`)
+   - Read \`references/html-data-mapping.md\` for the EXACT FEATURE_DATA and EMBEDDED_ARTIFACTS field mapping
+   - Read the master feature.json (application level)
+   - Read EACH module feature.json (module level)
+   - Build FEATURE_DATA object (metadata, cadrage, modules, moduleSpecs, consolidation, handoff)
+     - FEATURE_DATA.moduleSpecs MUST have ONE entry per module (empty = BUG)
+     - FEATURE_DATA.cadrage.scope MUST use HTML keys (vital/important/optional/excluded)
+     - FEATURE_DATA.metadata.analysisMode MUST be set (always "interactive")
+   - Build EMBEDDED_ARTIFACTS object (wireframes with field renames, e2eFlows, dependencyGraph)
+     - Rename: mockupFormat → format, mockup → content
+   - Replace placeholders: {{FEATURE_DATA}}, {{EMBEDDED_ARTIFACTS}}, {{APPLICATION_NAME}}, {{VERSION}}, etc.
+   - Write to docs/{app}/business-analyse/v{version}/ba-interactive.html
+   - Run POST-CHECK: file size > 100KB, moduleSpecs non-empty for ALL modules, cadrage.scope uses HTML keys
+
+> **WARNING:** The ba-interactive.html is the PRIMARY deliverable of the BA.
+> Generating PRD files WITHOUT generating the HTML is a BLOCKING BUG.
+> The HTML MUST be pre-populated with ALL analysis data (not an empty template).
+
+### Step 3: Quality Gate (step-05c-ralph-readiness.md)
+Load steps/step-05c-ralph-readiness.md and execute:
+- ULTRATHINK quality review
+- Validate all handoffs are complete
+- Verify PRD structural integrity
+- Verify ba-interactive.html exists and is > 100KB
 
 ## Context
 ${workflow.mode === "project" ? `
@@ -788,8 +858,9 @@ ${workflow.mode === "project" ? `
 
 ## Output
 Send HANDOFF_READY with:
-- PRD files generated (list)
-- HTML deployed (path)
+- PRD files generated (list with file paths)
+- ba-interactive.html deployed (path + file size — MUST be > 100KB)
+- BA manifest updated (docs/index.json entry count)
 - Quality gate result (PASS/FAIL with details)
 
 ## Communication

package/templates/skills/business-analyse/references/validation-checklist.md

@@ -1,5 +1,6 @@
 # Module Specification Checklist
 
+> **Authoritative minimums:** See `_rules.md` § "Minimum Counts" for the single source of truth on all minimum thresholds.
 > **CRITICAL:** This checklist MUST be FULLY COMPLETED before marking module status = "specified".
 > **Rationale:** Prevents incomplete modules from reaching handoff, reduces ralph-loop failures.
 
@@ -12,7 +13,7 @@ const checklist = {
   // SECTION 1: DATA MODEL (BLOCKING)
   entities: {
     minimum: 2,
-    actual: specification.entities.length,
+    actual: analysis.entities.length,
     status: actual >= minimum ? "PASS" : "FAIL",
     blocking: true,
     details: "At least 2 entities required for a meaningful module"
@@ -34,7 +35,7 @@ const checklist = {
 
   entitySchemaCompliance: {
     check: "All entities use canonical format: attributes[] (not fields[]), relationships[] array present",
-    status: specification.entities.every(e =>
+    status: analysis.entities.every(e =>
       Array.isArray(e.attributes) && e.attributes.length > 0 &&
       !e.fields && !e.tableName && !e.primaryKey
     ) ? "PASS" : "FAIL",
@@ -189,7 +190,7 @@ const checklist = {
   // SECTION 6: I18N & MESSAGES (BLOCKING)
   i18nKeys: {
     minimum: 42,  // Realistic minimum for a module
-    actual: specification.i18nKeys.length,
+    actual: Object.keys(specification.i18nKeys || {}).length,
     status: actual >= minimum ? "PASS" : "FAIL",
     blocking: true,
     details: "Keys needed: entities (×2), fields, messages, validation, navigation"
@@ -212,8 +213,10 @@ const checklist = {
 
   // SECTION 7: SEED DATA (BLOCKING)
   seedDataCore: {
-    check: "All 7 CORE seed data sections present",
+    check: "All 9 CORE seed data sections present",
     requiredSections: [
+      "navigationApplications",
+      "applicationRoles",
       "navigationModules",
       "navigationSections",
       "navigationResources",

package/templates/skills/business-analyse/schemas/shared/common-defs.json

@@ -16,7 +16,8 @@
 
     "moduleStatus": {
       "type": "string",
-      "enum": ["draft", "framed", "analysed", "specified", "approved", "consolidated", "handed-off"]
+      "description": "Status of a module or application through the BA workflow. Module flow: draft → analysed → specified → approved → handed-off. Application flow: draft → framed → decomposed → specified → consolidated → handed-off.",
+      "enum": ["draft", "framed", "decomposed", "analysed", "specified", "rejected", "approved", "consolidated", "handed-off"]
     },
 
     "priority": {

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

@@ -90,24 +90,15 @@ Execute workflow detection algorithm:
 3. **Similarity Analysis:** Score user intent against existing apps (>= 80 = strong match)
 4. **Decision Tree:** Prompt user with relevant options
 
-```javascript
-const detectionResult = detectWorkflowType(feature_description, existingApps);
+**Decision logic:**
 
-IF detectionResult.error OR detectionResult.ambiguous:
-  // CONDITIONAL LOAD: Only load detection strategies on error or ambiguity
-  Read references/detection-strategies.md
-  Display:
-    - Detailed similarity scoring algorithm
-    - Decision tree with thresholds
-    - Error handling procedures
-    - Review mode troubleshooting (if review mode failed)
-
-  → Resolve ambiguity with user clarification
-
-ELSE:
-  Workflow detected: {detectionResult.workflow_type} ✓
-  → Continue to application name determination
-```
+1. Run workflow detection: compare `{feature_description}` against `existingApps` using similarity scoring.
+2. **IF detection fails or is ambiguous:**
+   - **CONDITIONAL LOAD:** Read `references/detection-strategies.md` for detailed scoring algorithm, decision tree, and error handling.
+   - Resolve ambiguity with user clarification.
+3. **IF detection succeeds:**
+   - `Workflow detected: {workflow_type} ✓`
+   - Continue to application name determination.
 
 **Key decision points:**
 1. IF review mode → load ba-review.json, skip to step-06-review.md
@@ -137,44 +128,30 @@ existing_projects: array of { projectName, projectId, applications[], version }
 
 **Detection patterns (ANY match = multi-app detected):**
 
-```javascript
-const multiAppPatterns = [
-  // French patterns
-  /une\s+application\s+\w+.*une\s+application\s+\w+/is,
-  /application\s*\d?\s*[:]\s*\w+.*application\s*\d?\s*[:]\s*\w+/is,
-  /premier[e]?\s+application.*deuxième\s+application/is,
-  /app\s*1\s*[:.].*app\s*2\s*[:.]*/is,
-  // English patterns
-  /an?\s+application\s+(for\s+)?\w+.*an?\s+application\s+(for\s+)?\w+/is,
-  /application\s*#?\d\s*[:.].*application\s*#?\d\s*[:.]*/is,
-  /first\s+app.*second\s+app/is,
-];
+French patterns:
+- "une application X ... une application Y" (two occurrences of "une application")
+- "application 1: X ... application 2: Y" (numbered applications)
+- "première application ... deuxième application"
+- "app 1: ... app 2: ..."
 
-const isMultiApp = multiAppPatterns.some(p => p.test(feature_description));
-```
+English patterns:
+- "an application (for) X ... an application (for) Y" (two occurrences)
+- "application #1: ... application #2: ..." (numbered)
+- "first app ... second app"
+
+If ANY of these patterns is found in `{feature_description}`, set `isMultiApp = true`.
 
 **IF multi-app detected:**
 
 1. Extract candidate applications from the prompt:
 
-```javascript
-// Parse the prompt to identify application boundaries
-// Each "une application X" / "an application X" block = one candidate
-const candidates = extractApplicationCandidates(feature_description);
-// Result example:
-// [
-//   { name: "RH", description: "gestion des employes, conges, temps", modules: ["Employes", "Conges", "Temps"] },
-//   { name: "Projet", description: "gestion des projets, saisie du temps", modules: ["Projets", "Temps"] }
-// ]
-```
+**Extraction algorithm (3 steps):**
 
-2. Detect shared modules across candidates:
-
-```javascript
-const allModules = candidates.flatMap(c => c.modules);
-const sharedModules = allModules.filter((m, i) => allModules.indexOf(m) !== i);
-// Example: sharedModules = ["Temps"] → appears in both RH and Projet
-```
+1. **Identify boundaries:** Split the prompt at each "une application" / "an application" occurrence. Each block = one candidate.
+2. **Extract per candidate:** For each block, derive `name` (application name), `description` (summary of purpose), and `modules[]` (listed modules/features).
+   - Example result: `[{ name: "RH", description: "gestion des employes, conges, temps", modules: ["Employes", "Conges", "Temps"] }, ...]`
+3. **Detect shared modules:** Collect all module names across all candidates. Any module appearing in more than one candidate is a shared module.
+   - Example: `sharedModules = ["Temps"]` (appears in both RH and Projet)
 
 3. Display detection result and confirm:
 
@@ -346,26 +323,17 @@ See [references/init-schema-deployment.md](../references/init-schema-deployment.
 
 **Implementation:**
 
-```javascript
-// Pre-load CRITICAL (schemas) and HIGH (questionnaires) priority buckets
-const schemaFiles = glob("docs/{app}/business-analyse/schemas/**/*.json");
-for (const file of schemaFiles) {
-  read(file);  // Triggers cache
-}
-
-const questionnaireFiles = glob("~/.claude/skills/business-analyse/questionnaire/*.md");
-for (const file of questionnaireFiles) {
-  read(file);  // Triggers cache
-}
+**Files to pre-load:**
 
-read("~/.claude/skills/business-analyse/patterns/suggestion-catalog.md");
+1. **Schemas (CRITICAL):** All JSON files under `docs/{app}/business-analyse/schemas/**/*.json` (9 files)
+2. **Questionnaires (HIGH):** All `.md` files under `~/.claude/skills/business-analyse/questionnaire/` (16 files)
+3. **Catalog:** `~/.claude/skills/business-analyse/patterns/suggestion-catalog.md` (1 file)
 
-// Display status
-console.log(`
+**After loading, display:**
+```
 ✓ Cache warmed: 9 schemas + 16 questionnaires + 1 catalog
   Expected savings: 15-20% session tokens
   Retention: schemas (session-wide), questionnaires (until step-02)
-`);
 ```
 
 **Bucket Strategy:**

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

@@ -2,7 +2,7 @@
 name: step-01-cadrage
 description: Application/module framing - listen, reformulate, challenge, anticipate, bound scope
 model: opus
-next_step: steps/step-02-decomposition.md
+next_step: steps/step-01b-applications.md
 ---
 
 > **Context files:** `_shared.md` | `_elicitation.md` | `_architecture.md` | `_suggestions.md`
@@ -92,16 +92,42 @@ IF mcp_available:
   Store findings in {codebase_context}
 ```
 
-**Phase 2b: Parallel Codebase Agents**
+**Phase 2b: Parallel Codebase + Docs Agents**
 ```
-Launch 3 agents in parallel:
+Launch 4 agents in parallel:
   Agent 1: Search for existing domain entities (Glob: **/Domain/**/*.cs)
   Agent 2: Search for existing services/integrations (Grep: IService, IRepository)
   Agent 3: Search for existing page patterns (Glob: **/pages/**/*.tsx)
+  Agent 4: Scan existing BA documentation (Glob: docs/**/business-analyse/**/feature.json)
+           → For each found file: read metadata.application, metadata.module, status, modules[].code
+           → Also scan: docs/**/*.md (ERD, guides, specs)
 
 Merge findings into {codebase_context}
 ```
 
+**Phase 2c: Existing Documentation Context**
+
+> **Load existing BAs and documentation BEFORE engaging the client.**
+> This prevents re-specifying what already exists and surfaces integration constraints early.
+
+```
+IF Agent 4 found existing feature.json files:
+  For each file found:
+    → Extract: application, modules[], entities[], status, version
+    → Store as {existing_ba_context}: list of existing applications with their modules and key entities
+  Display (silent — internal context only, not shown to client):
+    "Found {count} existing BA(s): {app names} — {total modules} modules already specified"
+
+IF docs/**/*.md files found:
+  → Scan for ERD diagrams, API specs, architecture decisions
+  → Store relevant findings in {codebase_context}
+```
+
+**Use in pre-analysis (§2b):**
+- Cross-reference detected modules against `{existing_ba_context}` — flag modules that already exist
+- Pre-identify integration points: new feature may depend on or extend existing modules
+- NEVER re-specify what's already handed-off (status = "handed-off") — reference it instead
+
 ### 2b. Silent Pre-Analysis (ULTRATHINK — no output to client)
 
 > **The AI prepares the conversation before speaking.** This is NOT output — it's internal reasoning.
@@ -232,6 +258,20 @@ Ask in 1-2 batches. After each batch:
 - If no exclusions → probe: "What should this system explicitly NOT do?"
 - If journey is too simple → detail: "What happens when something goes wrong? When someone cancels?"
 
+> **MANDATORY Error Path Challenge (run for EVERY project after the main journey is described):**
+>
+> Ask via AskUserQuestion (1 batch, 2-3 questions):
+> - "Si l'action principale échoue (erreur serveur, données invalides, timeout), que doit-il se passer ?"
+> - "Qui est notifié en cas d'erreur ? L'utilisateur ? Un administrateur ? Via quel canal ?"
+> - "L'état doit-il être annulé (rollback) ou conservé partiellement ?"
+>
+> Record answers in `cadrage.errorFlows[]`:
+> ```json
+> { "scenario": "...", "trigger": "...", "notification": "...", "recovery": "rollback|partial|manual" }
+> ```
+>
+> These error flows become **Business Rules** in step-03a2 (BR-WF category: workflow/guard conditions).
+
 > **BLOCKING RULE — MoSCoW DISTRIBUTION:**
 > If the client classifies ALL features as "must-have", you MUST challenge this BEFORE proceeding.
 > **Reference:** Load `references/cadrage-challenge-patterns.md` § "MoSCoW Prioritization Template" for the exact question format.
@@ -439,10 +479,36 @@ Based on brief analysis, load additional categories if relevant:
 | External system integration | 05 | `questionnaire/05-integrations.md` |
 | Performance requirements | 08 | `questionnaire/08-performance.md` |
 | Technical constraints | 09 | `questionnaire/09-constraints.md` |
-| Documentation needs | 10 | `questionnaire/10-documentation.md` |
 
 > **Categories 04 (data), 07 (UI), 11 (lifecycle), 12 (migration), 13 (cross-module) are per-module and loaded in step-03.**
 
+#### 4g. Documentation Needs (ALWAYS — from `questionnaire/10-documentation.md`)
+
+> **Every application requires documentation decisions made upfront, not as an afterthought.**
+> Load `questionnaire/10-documentation.md` unconditionally — 7 questions, mandatory minimum 2 (Q10.1 + Q10.2).
+
+Ask in 1 batch via AskUserQuestion (max 3 questions):
+- Q10.1: Will users need documentation (guide, FAQ, in-app tooltips)?
+- Q10.2: Is technical documentation required (API docs, ERD, developer guide)?
+- Q10.3: Who is responsible for maintaining documentation after delivery?
+
+After the batch:
+- If "Non" to Q10.1 AND Q10.2 → probe: "Pas même les docs API ou un guide d'accueil pour les nouveaux utilisateurs ?"
+- If "Oui" without detail → ask format: "Tooltips intégrés ? Guide PDF ? Wiki ? Portail dédié ?"
+- If "La doc se fera après" → challenge: "La documentation est planifiée maintenant et générée par `/documentation` après `/ralph-loop`. Quel niveau souhaitez-vous ?"
+
+**Store in `cadrage.documentation`:**
+```json
+{
+  "userDocumentation": { "needed": true, "format": "tooltips|guide|wiki|pdf|portal", "audience": "..." },
+  "technicalDocumentation": { "needed": true, "format": "swagger|erd|developer-guide", "generated": true },
+  "owner": "who maintains it",
+  "skill": "/documentation — runs after /ralph-loop"
+}
+```
+
+This feeds directly into handoff step-05a category `documentation` in `filesToCreate`.
+
 ---
 
 ## PHASE 4: ANTICIPATION (Suggest Unexpressed Needs)
@@ -603,11 +669,35 @@ BEFORE transitioning to step-02:
    - List anticipated resources (Level 5) for each section
    - List detail page tabs — for entities accessible via click from `list`
 
-4. **OUTPUT the matrix as text** (do NOT put it inside AskUserQuestion — it won't render)
+4. **RECONCILIATION CHECK (MANDATORY — BLOCKING):**
+
+   > **Every explicitly requested item MUST appear in the coverage matrix.**
+   > This check prevents silent omissions — if the user asked for 5 modules, all 5 must be tracked.
+
+   ```
+   // Extract all explicit requests from the original prompt
+   requestedItems = extract_explicit_items({feature_description})
+   // Include: modules mentioned by name, features listed, applications named
+
+   // Verify each requested item has a coverage matrix entry
+   uncoveredItems = requestedItems.filter(item =>
+     !coverageMatrix.some(entry => fuzzyMatch(entry.feature, item))
+   )
+
+   IF uncoveredItems.length > 0:
+     BLOCKING: "The following requested items have no coverage matrix entry:
+       {uncoveredItems.map(i => '- ' + i).join('\n')}
+     Add them to the coverage matrix before proceeding."
+
+   ELSE:
+     Display: "✓ Coverage reconciliation: all {requestedItems.length} requested items mapped"
+   ```
+
+5. **OUTPUT the matrix as text** (do NOT put it inside AskUserQuestion — it won't render)
 
-5. **THEN** (after the table is displayed) ask via AskUserQuestion for confirmation
+6. **THEN** (after the table is displayed) ask via AskUserQuestion for confirmation
 
-6. Iterate until the client confirms
+7. Iterate until the client confirms
 
 **The reference file includes:**
 - Section rule clarification (list, detail, create, edit, dashboard, etc.)

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

@@ -5,7 +5,7 @@ model: opus
 next_step: steps/step-03a2-analysis.md
 ---
 
-> **Context files:** `_shared.md` | `_elicitation.md` | `_architecture.md` | `_module-loop.md`
+> **Context files:** `_shared.md` | `_elicitation.md` | `_architecture.md` | `_module-loop.md` | `_rules.md`
 > **Reference (5-bis):** `references/entity-architecture-decision.md` — Entity scoring, domain coherence, section patterns
 
 # Step 3a1: Setup - Module Initialization
@@ -20,27 +20,7 @@ next_step: steps/step-03a2-analysis.md
 - ALL questions via AskUserQuestion tool
 - ALL communication in `{language}`
 - NEVER skip per-module validation
-- **ID NAMING RULE (MANDATORY, NO EXCEPTION):**
-  All IDs MUST include a module prefix to guarantee application-wide uniqueness.
-  The prefix is derived from the module code initials (2-4 chars):
-    UserManagement → UM | VehicleManagement → VM | PartsInventory → PI
-    RepairManagement → RM | MaintenanceSchedule → MS | DataSync → DS
-    Notifications → NT | Dashboard → DB | Orders → OR | Customers → CU
-
-  Patterns:
-    UC-{PREFIX}-{NNN}        → UC-RM-001, UC-PI-003
-    BR-{CAT}-{PREFIX}-{NNN}  → BR-VAL-RM-001, BR-CALC-PI-002
-    FR-{PREFIX}-{NNN}        → FR-RM-001
-    OBJ-{PREFIX}-{NNN}       → OBJ-RM-001
-    AC-{PREFIX}-{NNN}        → AC-RM-001
-    RISK-{PREFIX}-{NNN}      → RISK-RM-001
-
-  NEVER use bare IDs (UC-001, BR-VAL-001) in multi-module mode.
-- **SCHEMA CONFORMITY RULE:**
-  ALL data MUST fit within the defined feature-schema.json structure.
-  NEVER create custom top-level fields (KPIDefinitions, ChartConfigurations, etc.)
-  Dashboard modules MUST use specification.dashboards[] (it exists in the schema).
-  If truly needed, use specification.extensions: {} (additionalProperties: true).
+- **Rules:** See `_rules.md` § "ID Naming Convention" and § "Schema Conformity" (MANDATORY, NO EXCEPTION)
 
 ## MODE DETECTION
 
@@ -323,7 +303,7 @@ Based on module type, load questionnaires per-module:
 
 | Condition | Category | Questionnaire |
 |-----------|----------|---------------|
-| Always | 04 | `questionnaire/04-data.md` |
+| featureType != "reporting" | 04 | `questionnaire/04-data.md` |
 | Has UI sections | 07 | `questionnaire/07-ui.md` |
 | Has lifecycle | 11 | `questionnaire/11-data-lifecycle.md` |
 | Has migration needs | 12 | `questionnaire/12-migration.md` |

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

@@ -5,7 +5,7 @@ model: opus
 next_step: steps/step-03b-ui.md
 ---
 
-> **Context files:** `_shared.md` | `_elicitation.md` | `_architecture.md` | `_module-loop.md`
+> **Context files:** `_shared.md` | `_elicitation.md` | `_architecture.md` | `_module-loop.md` | `_rules.md`
 > **Reference (check 7):** `references/entity-architecture-decision.md` — Entity scoring for unresolved relationship targets
 
 # Step 3a2: Analysis - Entities & Business Logic
@@ -14,8 +14,7 @@ next_step: steps/step-03b-ui.md
 
 - ALWAYS use ULTRATHINK mode
 - This step follows step-03a1-setup.md (module already initialized)
-- **ID NAMING RULE:** All IDs MUST include module prefix (BR-{CAT}-{PREFIX}-{NNN}, OBJ-{PREFIX}-{NNN}, etc.)
-- **SCHEMA CONFORMITY RULE:** ALL data MUST fit within feature-schema.json structure
+- **Rules:** See `_rules.md` § "ID Naming Convention" and § "Schema Conformity"
 
 ## MODE DETECTION (inherited from step-03a1)
 

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

@@ -5,7 +5,7 @@ model: opus
 next_step: steps/step-03c-compile.md
 ---
 
-> **Context files:** `_shared.md` | `_module-loop.md`
+> **Context files:** `_shared.md` | `_module-loop.md` | `_rules.md`
 
 # Step 3b: Specification - UI & Visualization
 
@@ -26,27 +26,7 @@ next_step: steps/step-03c-compile.md
 
 **IF you are running in the MAIN CONVERSATION** (classic inline mode):
   → Normal interactive mode — display wireframes then ask for validation via `AskUserQuestion`
-- **ID NAMING RULE (MANDATORY, NO EXCEPTION):**
-  All IDs MUST include a module prefix to guarantee application-wide uniqueness.
-  The prefix is derived from the module code initials (2-4 chars):
-    UserManagement → UM | VehicleManagement → VM | PartsInventory → PI
-    RepairManagement → RM | MaintenanceSchedule → MS | DataSync → DS
-    Notifications → NT | Dashboard → DB | Orders → OR | Customers → CU
-
-  Patterns:
-    UC-{PREFIX}-{NNN}        → UC-RM-001, UC-PI-003
-    BR-{CAT}-{PREFIX}-{NNN}  → BR-VAL-RM-001, BR-CALC-PI-002
-    FR-{PREFIX}-{NNN}        → FR-RM-001
-    OBJ-{PREFIX}-{NNN}       → OBJ-RM-001
-    AC-{PREFIX}-{NNN}        → AC-RM-001
-    RISK-{PREFIX}-{NNN}      → RISK-RM-001
-
-  NEVER use bare IDs (UC-001, BR-VAL-001) in multi-module mode.
-- **SCHEMA CONFORMITY RULE:**
-  ALL data MUST fit within the defined feature-schema.json structure.
-  NEVER create custom top-level fields (KPIDefinitions, ChartConfigurations, etc.)
-  Dashboard modules MUST use specification.dashboards[] (it exists in the schema).
-  If truly needed, use specification.extensions: {} (additionalProperties: true).
+- **Rules:** See `_rules.md` § "ID Naming Convention" and § "Schema Conformity" (MANDATORY, NO EXCEPTION)
 
 ## YOUR TASK