@atlashub/smartstack-cli 4.17.1 → 4.19.0

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

@@ -1,6 +1,6 @@
 ---
 name: step-00-init
-description: Initialize Business Analysis - Auto-detect new/update, create feature.json
+description: Initialize Business Analysis - Auto-detect new/update, create index.json structure
 model: sonnet
 next_step: steps/step-01-cadrage.md
 ---
@@ -17,7 +17,7 @@ next_step: steps/step-01-cadrage.md
 ═══════════════════════════════════════════════════════════════
 ```
 
-Initialize the business analysis workflow by auto-detecting whether this is a new application or an update to an existing one, then creating the initial feature.json structure.
+Initialize the business analysis workflow by auto-detecting whether this is a new application or an update to an existing one, then creating the initial index.json structure with thematic JSON files.
 
 ## Flow
 
@@ -29,7 +29,7 @@ Initialize the business analysis workflow by auto-detecting whether this is a ne
 6. Generate feature ID
 7. Create output directory structure
 8. Deploy JSON schemas
-9. Create master feature.json
+9. Create master index.json
 10. Update config
 11. Display summary
 12. Load next step
@@ -85,29 +85,20 @@ mcp__smartstack__validate_conventions({ checks: ["tables"] })
 
 Execute workflow detection algorithm:
 1. **Review Mode Detection:** Check if `{feature_description}` starts with `-review`
-2. **Existing Projects Scanner:** Glob `docs/business-analyse/*/feature.json` (project-level)
-2b. **Existing Applications Scanner:** Glob `docs/*/business-analyse/*/feature.json`
-3. **Similarity Analysis:** Score user intent against existing apps (>= 80 = strong match)
-4. **Decision Tree:** Prompt user with relevant options
+2. **Existing Projects Scanner:** Glob `docs/business-analyse/*/index.json` (project-level)
+3. **Existing Applications Scanner:** Glob `docs/*/business-analyse/*/index.json`
+4. **Similarity Analysis:** Score user intent against existing apps (>= 80 = strong match)
+5. **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
@@ -127,7 +118,7 @@ existing_apps: array of { app, featureId, description, version }
 existing_projects: array of { projectName, projectId, applications[], version }
 ```
 
-> **Project Resume Detection:** If a project-level feature.json is found at `docs/business-analyse/*/feature.json`, check its `metadata.workflow` to determine resume point. The project may have partially completed applications.
+> **Project Resume Detection:** If a project-level index.json is found at `docs/business-analyse/*/index.json`, check its `metadata.workflow` to determine resume point. The project may have partially completed applications.
 
 ## Step 3b: Early Multi-Application Detection from Prompt (NEW)
 
@@ -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"] }
-// ]
-```
-
-2. Detect shared modules across candidates:
+**Extraction algorithm (3 steps):**
 
-```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:
 
@@ -214,7 +191,7 @@ candidate_applications: [{ name, description, modules, context }]
 shared_modules_extracted: boolean  # true if user chose extraction
 ```
 
-→ Skip step 4 (application name) — applications will be confirmed in step-01b
+→ Skip step 4 (application name) — applications will be confirmed in step-01-cadrage
 → Continue to step 5 (language selection)
 
 **IF "Application unique":**
@@ -285,7 +262,7 @@ language: string (code, e.g., "en", "fr")
 
 > The analysis phase is ALWAYS interactive — the AI listens, reformulates,
 > challenges, and validates with the user. This is non-negotiable regardless
-> of development mode. Vibe coding applies to code execution (step-03+), NOT to analysis.
+> of development mode.
 
 **Set directly (no question):**
 
@@ -315,7 +292,7 @@ feature_id: string
 
 ```
 IF workflow_mode = "project":
-  // Project mode: create project-level directory + per-app directories later (in step-01b)
+  // Project mode: create project-level directory + per-app directories later
   mkdir -p docs/business-analyse/v1.0
   docs_dir = "docs/business-analyse/v{version}"
 
@@ -324,7 +301,7 @@ ELSE IF workflow_type = "new":
   docs_dir = "docs/{app}/business-analyse/v{version}"
 
 ELSE:
-  Directory already exists from ba-writer.createVersion()
+  Directory already exists from previous session
 ```
 
 **Store:**
@@ -334,57 +311,29 @@ docs_dir: string
 
 ## Step 8: Deploy JSON Schemas to Project (MANDATORY)
 
-> **The JSON Schemas MUST be present in the project alongside the generated feature.json files.**
-> Without schemas, feature.json files cannot be validated and have no structural reference.
+> **The JSON Schemas MUST be present in the project alongside the generated index.json files.**
+> Without schemas, JSON files cannot be validated and have no structural reference.
 
-See [references/init-schema-deployment.md](../references/init-schema-deployment.md) for cache-based deployment logic (9 schema files, version-checked via `.schema-cache.json`).
+See [references/init-schema-deployment.md](../references/init-schema-deployment.md) for cache-based deployment logic:
+- 7 thematic schemas: entities.json, rules.json, usecases.json, permissions.json, screens.json, validation.json, handoff.json
+- Version-checked via `.schema-cache.json`
 
-## Step 8b: Cache Warming (PERFORMANCE OPTIMIZATION)
+**Deployment logic:**
+1. Read `.schema-cache.json` if present
+2. Compare current smartstack version with cached version
+3. If versions match, skip deployment (already done)
+4. If versions differ or cache missing:
+   - Deploy all 7 schema files from `@smartstack/cli/schemas/` to `{docs_dir}/schemas/`
+   - Update `.schema-cache.json` with new version
 
-> **Objective:** Pre-load frequently-used templates and context files to reduce redundant reads.
-> **Expected token savings:** 15-20% across entire BA session
+## Step 9: Create Master index.json and Thematic Files
 
-**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
-}
-
-read("~/.claude/skills/business-analyse/patterns/suggestion-catalog.md");
-
-// Display status
-console.log(`
-✓ Cache warmed: 9 schemas + 16 questionnaires + 1 catalog
-  Expected savings: 15-20% session tokens
-  Retention: schemas (session-wide), questionnaires (until step-02)
-`);
-```
-
-**Bucket Strategy:**
-
-See [references/cache-warming-strategy.md](../references/cache-warming-strategy.md) for complete documentation on:
-- 5 cache buckets (schemas, questionnaires, moduleSpec, handoff, etc.)
-- Retention policies and clearing rules
-- Token savings calculations (baseline vs optimized)
-- Monitoring cache efficiency
-- When to pre-load vs lazy-load
-
-## Step 9: Create Master feature.json
-
-Create the master feature document using ba-writer agent.
+Create the master index document and initialize thematic JSON files using ba-writer agent.
 
 ```
 IF workflow_mode = "project":
-  // PROJECT MODE: Create project-level feature.json
-  ba-writer.createProjectFeature({
+  // PROJECT MODE: Create project-level index.json
+  ba-writer.createProjectIndex({
     id: generate_project_id(),  // PROJ-NNN
     version: {version},
     scope: "project",
@@ -407,15 +356,23 @@ IF workflow_mode = "project":
     }
   })
 
-  Output path: docs/business-analyse/v{version}/feature.json
+  Output path: docs/business-analyse/v{version}/index.json
+  Thematic files (empty, initialized): docs/business-analyse/v{version}/*.json
+    - entities.json
+    - rules.json
+    - usecases.json
+    - permissions.json
+    - screens.json
+    - validation.json
+    - handoff.json
 
   Store:
     project_id: string  // PROJ-NNN
     feature_id: project_id  // In project mode, feature_id = project_id for step-01
 
 ELSE:
-  // SINGLE-APP MODE: Create application-level feature.json
-  ba-writer.createApplicationFeature({
+  // SINGLE-APP MODE: Create application-level index.json + thematic files
+  ba-writer.createApplicationIndex({
     id: {feature_id},
     version: {version},
     scope: "application",
@@ -437,11 +394,19 @@ ELSE:
     }
   })
 
-  Output path: docs/{app}/business-analyse/v{version}/feature.json
+  Output path: docs/{app}/business-analyse/v{version}/index.json
+  Thematic files (empty, initialized): docs/{app}/business-analyse/v{version}/*.json
+    - entities.json
+    - rules.json
+    - usecases.json
+    - permissions.json
+    - screens.json
+    - validation.json
+    - handoff.json
 ```
 
-> **Note:** In project mode, per-application feature.json files are created later in step-01b.
-> In single-app mode, step-02 (decomposition) determines if it's single or multi-module.
+> **Note:** In project mode, per-application index.json files are created later in step-01-cadrage.
+> In single-app mode, step-02 (structure) determines if it's single or multi-module.
 
 ## Step 10: Update Config
 
@@ -474,7 +439,7 @@ Update `.business-analyse/config.json` with new feature information.
 | Workflow           | {workflow_type}                               |
 | Mode               | {workflow_mode === "project" ? "Multi-application project" : "Single application"} |
 | Application/Project| {workflow_mode === "project" ? project_name + " (" + candidate_applications.length + " apps)" : application_name} |
-| Output Path        | {docs_dir}/feature.json                      |
+| Output Path        | {docs_dir}/index.json                        |
 | Language           | {language}                                   |
 | Version            | {version}                                    |
 | MCP Available      | true                                         |
@@ -499,7 +464,7 @@ feature_description: string
 workflow_type: "new" | "update"
 workflow_mode: "application" | "project"
 application_name: string         # Single-app: app name. Project: project name.
-applicationCode: string          # PascalCase derived from application_name (preliminary, confirmed in step-01b)
+applicationCode: string          # PascalCase derived from application_name (preliminary, confirmed in step-01)
 project_id: string | null        # PROJ-NNN if project mode, null if single-app
 candidate_applications: array | null  # Pre-identified apps from prompt (project mode only)
 shared_modules_extracted: boolean     # True if user chose to extract shared modules as new app
@@ -516,7 +481,7 @@ version: string
 |-------|--------|
 | Config missing | Create fresh with defaults, continue |
 | Directory creation fails | Check permissions, display error, EXIT |
-| feature.json creation fails | Validate ba-writer, retry or fallback |
+| index.json creation fails | Validate ba-writer, retry or fallback |
 | Feature ID not unique | Generate new ID, retry |
 
 ### Resume After Interruption
@@ -524,52 +489,46 @@ version: string
 If initialization was interrupted:
 
 1. Check `.business-analyse/config.json` for currentFeature or currentProject
-2. If project ID exists, search for project feature.json in `docs/business-analyse/`
+2. If project ID exists, search for project index.json in `docs/business-analyse/`
    - If found with scope = "project": resume project mode (see Project Resume below)
-3. If feature ID exists, search for feature.json in `docs/`
+3. If feature ID exists, search for index.json in `docs/`
 4. If found, check status and `metadata.workflow.lastCompletedStep`:
 
    **Status-based resume routing (check in this order):**
 
-   - If status = `"handed-off"` AND `ba-interactive.html` missing:
-     → Resume at `step-05b-deploy.md` (deploy artifacts + HTML)
-     → Display: "Handoff complete but HTML/artifacts missing — deploying..."
-
-   - If status = `"handed-off"` AND `.ralph/prd-*.json` files missing:
-     → Resume at `step-05b-deploy.md` (only deploy artifacts needed)
-     → Display: "Handoff complete but PRD files missing — deploying..."
+   - If status = `"handed-off"`:
+     → Resume at `step-06-review.md`
+     → Display: "Handoff complete — proceeding to review..."
 
-   - If status = `"consolidated"` OR lastCompletedStep = `"step-04-consolidation"`:
-     → Resume directly at `step-05a-handoff.md` (skip steps 00-04)
-     → Display: "Resuming from consolidation — proceeding to handoff..."
+   - If status = `"consolidated"`:
+     → Resume directly at `step-05-deploy.md`
+     → Display: "Resuming from consolidation — proceeding to deployment..."
 
    - If status = `"specified"` AND `metadata.workflow.allModulesSpecified === true`:
-     → Resume at `step-04a-collect.md` (consolidation phase)
+     → Resume at `step-04-consolidate.md`
      → Display: "All modules specified — resuming at consolidation..."
 
    - If status = `"specified"` AND `metadata.workflow.completedModules.length > 0` AND `metadata.workflow.completedModules.length < metadata.workflow.moduleOrder.length`:
-     → Resume at `step-03a1-setup.md` (continue specifying remaining modules)
+     → Resume at `step-03-specify.md` (continue specifying remaining modules)
      → Display: "Resuming module specification ({completedCount}/{totalCount})..."
 
    - Otherwise: offer to resume from last completed step
 
-4. If not found, create fresh feature.json
+5. If not found, create fresh index.json
 
 **Project Resume (project mode):**
 
-If a project-level feature.json is found (scope = "project"):
+If a project-level index.json is found (scope = "project"):
 
    - If status = `"draft"` or `"framed"`:
-     → Resume at `step-01-cadrage.md` or `step-01b-applications.md`
+     → Resume at `step-01-cadrage.md`
 
    - If status = `"decomposed"`:
      → Check `metadata.workflow.currentApplicationIndex` and `completedApplications[]`
      → Resume module specification for current application (step-02 or step-03)
 
    - If status = `"specified"`:
-     → All applications specified → Resume at `step-04a-collect.md`
+     → All applications specified → Resume at `step-04-consolidate.md`
 
    - If status = `"consolidated"`:
-     → Resume at `step-05a-handoff.md`
-
-   Follow `_module-loop.md` "Project Mode (multi app)" resume logic for detailed routing.
+     → Resume at `step-05-deploy.md`