@atlashub/smartstack-cli 4.74.0 → 4.75.0

package/templates/skills/business-analyse/references/04-semantic-validation-matrix.md

@@ -0,0 +1,118 @@
+# Semantic Validation Matrix
+
+> **Purpose:** Define all semantic validation checks and contract verification rules required before consolidation approval.
+> These checks catch data integrity gaps and ensure downstream skills have complete information.
+
+## 13 Semantic Checks (Per Module)
+
+Execute these checks for each completed module:
+
+```javascript
+const semanticChecks = [
+  { check: "permission-orpheline", severity: "WARNING" },
+  { check: "uc-sans-fr", severity: "WARNING" },
+  { check: "entity-sans-endpoint", severity: "WARNING" },
+  { check: "uc-sans-scenario", severity: "WARNING" },
+  { check: "role-sans-permissions", severity: "WARNING" },
+  { check: "navigation-sans-traduction", severity: "ERROR" },
+  { check: "lifecycle-terminal", severity: "WARNING" },
+  { check: "schema-conformity", severity: "ERROR" },
+  { check: "wireframe-coverage", severity: "ERROR" },
+  { check: "entity-doublon", severity: "ERROR" },
+  { check: "permission-fantome", severity: "ERROR" },
+  { check: "dashboard-coverage", severity: "WARNING" },
+  { check: "permission-uc-alignment", severity: "WARNING" }
+];
+```
+
+**Blocking rule:** 0 ERROR → PASS, ≥1 ERROR → BLOCK (user must fix before proceeding)
+
+## Contract Verification (Per Module)
+
+Verify the data contract that downstream skills (`/business-analyse-handoff`, `/business-analyse-develop`) depend on.
+These checks catch gaps that abstract semantic checks miss.
+
+```javascript
+for (const module of completedModules) {
+  const ent = module.entities || [];
+  const brs = ba-reader.readSection(module.code, "rules")?.rules || [];
+  const ucs = ba-reader.readSection(module.code, "usecases")?.useCases || [];
+  const perms = ba-reader.readSection(module.code, "permissions");
+
+  // CHECK 1: BR-CALC must have formula (C13)
+  for (const br of brs) {
+    if (br.category === 'calculation' && !br.formula) {
+      errors.push({module: module.code, check: "br-calc-sans-formula",
+        details: `${br.id} is category:calculation but missing 'formula' field`});
+    }
+  }
+
+  // CHECK 2: Computed attributes must have corresponding BR-CALC (C11)
+  for (const entity of ent) {
+    for (const attr of (entity.attributes || [])) {
+      if (attr.computed === true) {
+        const hasBRCalc = brs.some(br =>
+          br.category === 'calculation' && (br.entities || []).includes(entity.name)
+        );
+        if (!hasBRCalc) {
+          errors.push({module: module.code, check: "computed-sans-br-calc",
+            details: `${entity.name}.${attr.name} is computed:true but no BR-CALC references ${entity.name}`});
+        }
+      }
+    }
+  }
+
+  // CHECK 3: UC count minimum (C6)
+  if (ucs.length < 4) {
+    errors.push({module: module.code, check: "uc-count-critical",
+      details: `Only ${ucs.length} use cases (minimum: 4)`});
+  } else if (ucs.length < 6) {
+    warnings.push({module: module.code, check: "uc-count-low",
+      details: `Only ${ucs.length} use cases (recommended: >= 6)`});
+  }
+
+  // CHECK 4: Permission path count (C7)
+  const permCount = perms?.permissionPaths?.length || 0;
+  if (permCount < 5) {
+    warnings.push({module: module.code, check: "permission-count-low",
+      details: `Only ${permCount} permission paths (recommended: >= 5 — check for missing Export/Import)`});
+  }
+
+  // CHECK 5: Versioned attributes detection (C15)
+  const sensitiveKeywords = ['salary', 'rate', 'grade', 'price', 'tarif'];
+  for (const entity of ent) {
+    for (const attr of (entity.attributes || [])) {
+      if (sensitiveKeywords.some(k => attr.name.toLowerCase().includes(k))) {
+        if (!entity.versionedAttributes?.length) {
+          warnings.push({module: module.code, check: "missing-versioned-attributes",
+            details: `${entity.name}.${attr.name} may need versioning but no versionedAttributes defined`});
+        }
+      }
+    }
+  }
+}
+```
+
+## Execution Logic
+
+```javascript
+for (const module of completedModules) {
+  for (const check of semanticChecks) {
+    const result = executeSemanticCheck(module, check);
+    if (result.status === "ERROR") {
+      errors.push({module: module.code, check: check.check, details: result.details});
+    } else if (result.status === "WARNING") {
+      warnings.push({module: module.code, check: check.check, details: result.details});
+    }
+  }
+}
+
+// Blocking rule: 0 ERROR → PASS, ≥1 ERROR → BLOCK (ask user for each)
+if (errors.length > 0) {
+  BLOCKING_ERROR("Semantic validation failed");
+  for (const error of errors) {
+    ERROR(`  [${error.module}] ${error.check}: ${error.details}`);
+  }
+  STOP - User must fix before proceeding
+}
+```

package/templates/skills/business-analyse/references/domain-research-playbook.md

@@ -0,0 +1,234 @@
+# Domain Research Playbook
+
+> **Web research is the #1 quality differentiator.**
+> An analysis WITHOUT research is a 2/10 regardless of structural quality.
+> An analysis WITH multi-level research can be 8-10/10.
+> This step takes 2-5 minutes per application and dramatically improves analysis quality.
+
+## MANDATORY — BLOCKING
+
+Web research is **MANDATORY and BLOCKING**. This is NOT optional.
+
+If WebSearch tool is unavailable:
+1. Display WARNING to user: "WebSearch indisponible. Qualite d'analyse degradee."
+2. AskUserQuestion: "Continuer sans recherche web ? (Non recommande — qualite 4/10 max)"
+3. IF user declines → STOP and recommend fixing WebSearch availability
+4. IF user confirms → proceed with `{domain_research}.source = "built-in-only"`
+   and flag EVERY module with `qualityFlag: "no-web-research"`
+   → Load `references/module-completeness-challenge.md` as primary fallback data source
+
+---
+
+## Level 1 : Recherche par APPLICATION (step-01 cadrage)
+
+> **WHEN:** During step-01 Phase 1 (ECOUTE), BEFORE engaging the client.
+> **WHO:** For EACH candidate application in a multi-app project, or the single app.
+
+For EACH application:
+
+### 1a. Module Discovery Search (MANDATORY)
+
+```
+Query: "{app_type} application modules features complete list"
+```
+
+Examples:
+- "billing invoicing application modules features complete list ERP"
+- "HR human resources application modules features complete list"
+- "CRM application modules features complete list"
+- "project management application modules features complete list"
+
+**EXTRACT:**
+- Standard modules for this app type
+- Which are CORE (always present) vs STANDARD vs OPTIONAL
+- Common module names and their scope
+- Module dependencies
+
+### 1b. Competitive Research (MANDATORY)
+
+```
+Query: "best {app_type} software features comparison"
+```
+
+Examples:
+- "best invoicing software features comparison 2025"
+- "best HR software absence management features"
+- "best CRM software features comparison"
+- "best project management software features"
+
+**EXTRACT:**
+- What do real commercial products offer? (BambooHR, Sage, Salesforce, etc.)
+- Common features users expect as baseline
+- Differentiating features that add value
+- Features that are table stakes vs nice-to-have
+
+### 1c. Data Model Research (1 per app)
+
+```
+Query: "{app_type} data model entities relationships best practices"
+```
+
+**EXTRACT:**
+- Standard entities and their relationships
+- Common anti-patterns to avoid (e.g., "storing salary on Employee instead of salary history table")
+- Industry-standard naming and cardinality
+
+### Storage Format
+
+```yaml
+{domain_research}.applications[{app_code}]:
+  standardModules:
+    - name: "Invoices"
+      classification: "CORE"  # CORE | STANDARD | OPTIONAL
+      description: "Invoice lifecycle management"
+      standardSections: ["list", "detail", "generate", "dashboard"]
+    - name: "CreditNotes"
+      classification: "CORE"
+      description: "Legally required for invoice corrections/cancellations"
+      standardSections: ["list", "detail"]
+  competitiveInsights:
+    - product: "Sage"
+      keyFeatures: ["auto-numbering", "multi-currency", "credit notes", "recurring invoices"]
+    - product: "Stripe Invoicing"
+      keyFeatures: ["payment tracking", "dunning", "tax calculation"]
+  dataModel:
+    entities: ["Invoice", "InvoiceLine", "CreditNote", "Payment", "PaymentTerm"]
+    relationships: ["Invoice → Client (N:1)", "Invoice → InvoiceLine (1:N)"]
+    antiPatterns: ["single invoice entity without credit notes"]
+```
+
+---
+
+## Level 2 : Recherche par MODULE (step-03 specify)
+
+> **WHEN:** During step-03 section A-bis, BEFORE entity specification.
+> **WHO:** For EACH module with >= 2 entities. SKIP: Portal, pure config modules.
+
+For EACH module:
+
+### 2a. Section/UX Research (MANDATORY)
+
+```
+Query: "{module_domain} management system features screens views UX"
+```
+
+Examples:
+- "absence management system features screens views"
+- "invoice management application features views UX"
+- "CRM opportunity pipeline features screens"
+
+**EXTRACT:**
+- Standard sections/views (list, detail, calendar, kanban, etc.)
+- **Contextual filtered views** — this is CRITICAL:
+  - Workflow modules: open-requests, rejected, history, my-{entity}
+  - Data modules: by-status, by-period, by-category
+- Dashboard/reporting expectations
+- Standard UX patterns (approval queue, batch actions, etc.)
+
+### 2b. Business Rules Research (MANDATORY for workflow modules)
+
+```
+Query: "{module_domain} business rules validation constraints best practices"
+```
+
+Examples:
+- "absence leave management business rules HR constraints"
+- "invoice billing business rules validation constraints"
+- "CRM opportunity management business rules"
+
+**EXTRACT:**
+- **Domain-specific validation rules** (NOT just "date must be valid"):
+  - Half-day absences, notice periods, capacity limits
+  - Invoice sequential numbering, credit note linking
+  - Opportunity probability rules, stage-gate validation
+- Calculation rules with formulas
+- Workflow constraints and edge cases
+- Regulatory/compliance requirements
+
+### 2c. Entity Design Research (1 per complex entity, OPTIONAL)
+
+```
+Query: "{entity_name} entity design pattern ERP best practices"
+```
+
+**EXTRACT:**
+- Standard attributes for this entity type
+- Versioned vs. inline data patterns (e.g., salary history)
+- Common relationships and cardinality
+- Known anti-patterns
+
+### Storage Format
+
+```yaml
+{domain_research}.modules[{module_code}]:
+  sections:
+    standard: ["list", "detail", "approve", "calendar"]
+    contextualViews: ["open-requests", "rejected", "history", "my-balance"]
+    dashboard: ["absence-kpi", "team-calendar"]
+  businessRules:
+    domainSpecific:
+      - "Half-day absences (morning/afternoon)"
+      - "Minimum 48h notice for planned leave"
+      - "Max 30% of team absent simultaneously"
+      - "Carry-over days expire after March 31"
+      - "Medical certificate for absences > 3 days"
+    regulatory:
+      - "Minimum 25 days paid leave per year (France)"
+  entityPatterns:
+    Absence:
+      standardAttributes: ["employeeId", "typeId", "startDate", "endDate", "duration", "status", "halfDay"]
+      versionedData: []
+      workflowStates: ["Draft", "Submitted", "Approved", "Rejected", "Cancelled"]
+```
+
+---
+
+## Level 3 : Recherche reglementaire (si applicable)
+
+> **WHEN:** During step-01 for applicable domains, alongside Level 1 research.
+> **WHO:** Billing/Finance, HR, any domain with legal requirements.
+
+### For Billing/Finance domains:
+```
+Query: "{country} invoice legal requirements numbering format"
+```
+
+**EXTRACT:** Sequential numbering, immutability of sent invoices, retention period, credit note requirements, VAT rules.
+
+### For HR domains:
+```
+Query: "{country} absence leave legal requirements types"
+```
+
+**EXTRACT:** Mandatory leave types, minimum days, carry-over rules, medical certificate requirements.
+
+Store in: `{domain_research}.regulatory[]`
+
+---
+
+## Search Budget
+
+| Project Type | Level 1 (per app) | Level 2 (per module) | Level 3 | Total |
+|---|---|---|---|---|
+| Single-app, 1-3 modules | 3 searches | 2/module = 4-6 | 0-2 | **7-11** |
+| Single-app, 4-6 modules | 3 searches | 2/module = 8-12 | 0-2 | **11-17** |
+| Multi-app (4 apps, ~10 modules) | 3/app = 12 | 2/module = 16-20 | 0-4 | **28-36** |
+
+> **Token impact:** Each search returns ~500-1000 tokens. Total for a 4-app project: ~15K-30K tokens.
+> This is a small price for dramatically improved analysis quality.
+
+---
+
+## Critical Notes
+
+> **CRITICAL:** This research is INTERNAL context. Do NOT show raw search results to the client.
+> Use the findings to:
+> - **Challenge scope completeness** — flag CORE modules the user didn't mention
+> - **Ground entity architecture** — use real-world data models, not guesswork
+> - **Propose domain-specific business rules** — go beyond generic CRUD validation
+> - **Anticipate contextual views** — workflow modules need filtered views
+> - **Inform proactive suggestions** — "standard billing also includes credit notes because..."
+> - **Prevent common anti-patterns** — catch mistakes before they become architecture
+
+> **NEVER use research as an excuse to skip user validation.**
+> Research INFORMS your proposals. The user VALIDATES them.

package/templates/skills/business-analyse/references/entity-sourcing-presentation.md

@@ -0,0 +1,166 @@
+# Entity Sourcing Presentation (4-Phase Flow)
+
+> **When the analysis detects a referenced entity/concept (e.g., "Projets" referenced by activities, "Clients" referenced by orders), ALWAYS analyze and recommend BEFORE asking the client.**
+> This pattern detects potential new modules not mentioned in the original brief.
+
+## PHASE 1 — ULTRATHINK: Silent Architecture Analysis (NO output to client)
+
+> **The AI reasons about the entity BEFORE presenting options. This is internal thinking only.**
+
+```
+ULTRATHINK — Entity Architecture Analysis for {entity_name}:
+
+1. DOMAIN COHERENCE (from decision tree in reference)
+   - Application domain: {app_description}
+   - Entity fit: CORE | SUPPORT | PERIPHERAL
+   - Justification: {1 sentence — why this entity is/isn't core to the app}
+   - Example: "Projets" in a time management app = CORE (without projects, time entries have no target)
+   - Example: "Codes d'imputation" in a time management app = SUPPORT (useful for accounting, but not central)
+
+2. ENTITY SCORING (5 criteria, 0-3 each — from scoring grid in reference)
+   - Lifecycle:  {score}/3 — {brief justification}
+   - Actors:     {score}/3 — {brief justification}
+   - Relations:  {score}/3 — {brief justification}
+   - Volume:     {score}/3 — {brief justification}
+   - Autonomy:   {score}/3 — {brief justification}
+   - TOTAL:      {total}/15 → {classification: config_list | in_app | light_module | full_module}
+
+3. PRE-CLASSIFICATION CHECK (from entity patterns in reference)
+   - Does {entity_name} match a known pattern? → {yes: which one | no: use scoring}
+   - Override needed? → {yes: why | no}
+
+4. RECOMMENDATION
+   - Option: {config_list | in_app_section | new_module | external_system}
+   - Confidence: HIGH | MEDIUM | LOW
+   - Reasoning: {1-2 sentences}
+   - Risk if wrong choice: {what goes wrong if user picks a different option}
+
+5. IF recommendation = new_module → PRE-BUILD ARCHITECTURE
+   - 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 sections: dashboard, approve, import, rapport...)
+   - Dependencies: [{which modules reference/are referenced by this entity}]
+   - Topological position: layer {N} (foundation if no dependencies)
+```
+
+## PHASE 2 — Present Analysis & Recommendation to Client
+
+**BEFORE the AskUserQuestion, display the analysis as markdown:**
+
+```
+### {language == "fr" ? "Analyse" : "Analysis"} : {entity_plural}
+
+{language == "fr"
+  ? "Les **{entity_plural}** sont référencés par {parent_module} ({relationship_description})."
+  : "**{entity_plural}** are referenced by {parent_module} ({relationship_description})."}
+
+{language == "fr" ? "**Mon analyse :**" : "**My analysis:**"}
+- {language == "fr" ? "Cohérence domaine" : "Domain coherence"} : **{CORE|SUPPORT|PERIPHERAL}** — {justification}
+- {language == "fr" ? "Score de complexité" : "Complexity score"} : **{score}/15** ({classification})
+- {language == "fr" ? "Recommandation" : "Recommendation"} : **{recommended_option}** — {reasoning}
+```
+
+**IF recommendation = new_module AND confidence >= MEDIUM, ALSO display:**
+
+```
+{language == "fr" ? "**Architecture proposée :**" : "**Proposed architecture:**"}
+
+| {language == "fr" ? "Niveau" : "Level"} | {language == "fr" ? "Valeur" : "Value"} | {language == "fr" ? "Justification" : "Rationale"} |
+|--------|--------|---------------|
+| Application | `{app_code}` | {app_name} |
+| Module | `{ModuleCode}` | {language == "fr" ? "{pourquoi ce découpage}" : "{why this decomposition}"} |
+
+| Section | {language == "fr" ? "Justification" : "Rationale"} | Resources |
+|---------|---------------|-----------|
+| `list` | {language == "fr" ? "Page principale : grille, création, navigation vers détail" : "Main page: grid, create action, navigate to detail"} | {entity}-grid, {entity}-filters, {entity}-form |
+| {additional_section} | {justification} | {resources} |
+
+{language == "fr"
+  ? "**Page détail** (onglets accessibles depuis la liste) :"
+  : "**Detail page** (tabs accessible from list):"}
+
+| {language == "fr" ? "Onglet" : "Tab"} | {language == "fr" ? "Contenu" : "Content"} |
+|--------|---------|
+| {language == "fr" ? "Informations" : "Information"} | {language == "fr" ? "Fiche principale" : "Main record"} |
+| {tab_name} | {tab_content} |
+
+{language == "fr"
+  ? "**Impact :** {ModuleName} deviendra une dépendance de {parent_module} (couche {N} du graphe)."
+  : "**Impact:** {ModuleName} will become a dependency of {parent_module} (layer {N} in the graph)."}
+```
+
+## PHASE 3 — Ask with Recommended Option First
+
+**Order the options with the recommendation FIRST, marked "(Recommandé)" / "(Recommended)":**
+
+```
+question: "{language == 'fr'
+  ? 'Comment souhaitez-vous gérer les {entity_plural} ?'
+  : 'How do you want to manage {entity_plural}?'}"
+header: "{entity_name}"
+options:
+  (ORDER: recommended option FIRST, then the 3 remaining options in logical order)
+
+  IF recommendation = new_module:
+  - label: "{language == 'fr' ? 'Nouveau module dédié (Recommandé)' : 'New dedicated module (Recommended)'}"
+    description: "{language == 'fr'
+      ? 'Module {ModuleCode} avec page liste, détail par onglets, permissions dédiées'
+      : '{ModuleCode} module with list page, tabbed detail, dedicated permissions'}"
+  - label: "{language == 'fr' ? 'Géré dans l\'app' : 'Managed in app'}"
+    description: "..."
+  - label: "{language == 'fr' ? 'Système externe' : 'External system'}"
+    description: "..."
+  - label: "{language == 'fr' ? 'Liste simple en config' : 'Simple config list'}"
+    description: "..."
+
+  IF recommendation = config_list:
+  - label: "{language == 'fr' ? 'Liste simple en config (Recommandé)' : 'Simple config list (Recommended)'}"
+    description: "{language == 'fr'
+      ? 'Table de référence administrable, pas de module dédié'
+      : 'Admin-managed reference table, no dedicated module'}"
+  - label: "{language == 'fr' ? 'Géré dans l\'app' : 'Managed in app'}"
+    description: "..."
+  - label: "{language == 'fr' ? 'Nouveau module dédié' : 'New dedicated module'}"
+    description: "..."
+  - label: "{language == 'fr' ? 'Système externe' : 'External system'}"
+    description: "..."
+
+  IF recommendation = in_app_section:
+  - label: "{language == 'fr' ? 'Géré dans l\'app (Recommandé)' : 'Managed in app (Recommended)'}"
+    description: "{language == 'fr'
+      ? 'Accessible via un onglet dans la page détail de {parent_module}'
+      : 'Accessible via a tab in {parent_module} detail page'}"
+  - label: "{language == 'fr' ? 'Nouveau module dédié' : 'New dedicated module'}"
+    description: "..."
+  - label: "{language == 'fr' ? 'Liste simple en config' : 'Simple config list'}"
+    description: "..."
+  - label: "{language == 'fr' ? 'Système externe' : 'External system'}"
+    description: "..."
+
+  IF recommendation = external_system:
+  - label: "{language == 'fr' ? 'Système externe (Recommandé)' : 'External system (Recommended)'}"
+    description: "{language == 'fr'
+      ? 'Les {entity_plural} viennent d\'un autre système (import ou API)'
+      : '{entity_plural} come from another system (import or API)'}"
+  - label: "{language == 'fr' ? 'Nouveau module dédié' : 'New dedicated module'}"
+    description: "..."
+  - label: "{language == 'fr' ? 'Géré dans l\'app' : 'Managed in app'}"
+    description: "..."
+  - label: "{language == 'fr' ? 'Liste simple en config' : 'Simple config list'}"
+    description: "..."
+
+  IF confidence = LOW (no clear recommendation):
+  (all 4 options in neutral order, NO "(Recommandé)" tag)
+```
+
+## PHASE 4 — Process Answer
+
+| 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 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. |
+
+> **CRITICAL:** The intelligence of this step is in the ULTRATHINK analysis. The AI must REASON about domain coherence, score the entity, and recommend — not just present 4 neutral options. The client can always override the recommendation, but they should benefit from expert architectural guidance.

package/templates/skills/business-analyse/references/init-resume-logic.md

@@ -0,0 +1,70 @@
+# Initialize Resume Logic & Error Handling
+
+> **Purpose:** Handle interruptions, resume previous workflows, and route based on status.
+> Executed at the end of initialization to check if a workflow can be resumed.
+
+## Error Handling Matrix
+
+| Error | Action |
+|-------|--------|
+| Config missing | Create fresh with defaults, continue |
+| Directory creation fails | Check permissions, display error, EXIT |
+| index.json creation fails | Validate ba-writer, retry or fallback |
+| Feature ID not unique | Generate new ID, retry |
+
+## Resume After Interruption
+
+If initialization was interrupted:
+
+1. Check `.business-analyse/config.json` for currentFeature or currentProject
+2. If project ID exists, search for project index.json in `docs/*/v*/` (or legacy `docs/business-analyse/`)
+   - If found with scope = "project": resume project mode (see Project Resume below)
+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"` or `"consolidated"`
+
+→ 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`
+
+→ 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-03-specify.md` (continue specifying remaining modules)
+→ Display: "Resuming module specification ({completedCount}/{totalCount})..."
+
+### Otherwise
+
+→ Offer to resume from last completed step
+
+### If not found
+
+→ Create fresh index.json
+
+## Project Resume (project mode)
+
+If a project-level index.json is found (scope = "project"):
+
+### If status = `"draft"` or `"framed"`
+
+→ 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-04-consolidate.md`
+
+### If status = `"consolidated"`
+
+→ Display: "BA workflow complete. Use /business-analyse-html to generate HTML."
+→ **STOP**