@atlashub/smartstack-cli 3.32.0 → 3.34.0

package/templates/skills/apex/steps/step-03-execute.md

@@ -17,6 +17,8 @@ All code goes through skills (/controller, /application, /ui-components, /efcore
 - **ALWAYS** read `references/smartstack-frontend.md` — lazy loading, i18n, page structure, CSS variables
 - Read `references/smartstack-layers.md` for execution rules per layer
 - If NOT `{economy_mode}` AND Layer 1 has parallel work: read `references/agent-teams-protocol.md`
+- If `{delegate_mode}` AND seedData tasks exist: read `references/core-seed-data.md` — comprehensive seed data templates
+- If build failure during execution: read `references/error-classification.md` — error diagnosis categories A-F
 
 ---
 
@@ -92,13 +94,24 @@ Code stays in CreateDto, user provides it, validator has regex rule.
 **For frontend tasks (economy_mode):** Follow the same rules as exec-frontend above:
 - `MCP scaffold_api_client` → API client + types + React Query hook
 - `MCP scaffold_routes` with `outputFormat: 'clientRoutes'` for lazy imports
-- Pages: use `/ui-components` skill — MANDATORY for entity lists, grids, tables, dashboards
-- **Form pages: Create `EntityCreatePage.tsx` (route: `/create`) and `EntityEditPage.tsx` (route: `/:id/edit`)**
+- **INVOKE `/ui-components` skill** (read SKILL.md + ALL patterns) — MANDATORY for ALL page types
+- **Create ALL 4 page types per module:**
+  - `ListPage.tsx` — entity list with SmartTable/EntityCard
+  - `DetailPage.tsx` — entity detail view
+  - `EntityCreatePage.tsx` (route: `/create`) — FULL PAGE form, NEVER modal
+  - `EntityEditPage.tsx` (route: `/:id/edit`) — FULL PAGE form, NEVER modal
+- **Wire ALL routes in App.tsx:** `index` (ListPage), `:id` (DetailPage), `create` (CreatePage), `:id/edit` (EditPage)
 - **FK FIELDS (CRITICAL):** Any Guid FK property (e.g., EmployeeId, DepartmentId) MUST use `EntityLookup` component — NEVER a `<select>` dropdown, NEVER a `<input type="text">`. A `<select>` loaded from API state is NOT a substitute for EntityLookup. See `smartstack-frontend.md` section 6.
 - **ZERO modals/popups/drawers for forms — ALL forms are full pages with their own URL**
+- **TABS ON DETAIL PAGES (CRITICAL):** Tabs MUST switch content LOCALLY via `setActiveTab()` — NEVER `navigate()` to another page. Sub-resource data (e.g., employee's leaves) loads inline via API call filtered by parent entity ID. See `smartstack-frontend.md` section 3 "Tab Behavior Rules".
 - **Form tests: Generate `EntityCreatePage.test.tsx` and `EntityEditPage.test.tsx` (co-located)**
 - **SECTION PERMISSIONS:** After calling `MCP generate_permissions` for the module navRoute (3 segments: `{context}.{app}.{module}`), also call it for EACH section navRoute (4 segments: `{context}.{app}.{module}.{section}`)
 - **SECTION ROUTES:** After generating module routes, add section child routes to the module's `children` array. Wire `PermissionGuard` for section routes with section-level permissions.
+- **SUB-RESOURCE COMPLETENESS:** If a section controller has sub-resource endpoints (e.g., `[HttpGet("types")]` for LeaveTypes inside LeavesController), you MUST EITHER:
+  - Create dedicated frontend pages for the sub-resource (ListPage, CreatePage, EditPage) with routes wired in App.tsx, OR
+  - NOT include any `navigate()` button that links to those sub-resource pages
+  - **Prefer separate controllers** with `[NavRoute(..., Suffix = "types")]` — see `smartstack-api.md` Sub-Resource Pattern
+  - A dead link (navigate to a route with no page) is a BLOCKING issue (POST-CHECK 42)
 - Read `references/smartstack-frontend.md` for mandatory patterns (sections 3b + 8)
 - Generate i18n JSON files for all 4 languages (fr, en, it, de) — `src/i18n/locales/{lang}/{module}.json`
 - All pages must follow loading → error → content pattern with CSS variables
@@ -146,6 +159,12 @@ Spawn 2 teammates (Opus, full tools):
       → ZERO modals/popups/drawers/dialogs for forms
       → Back button with navigate(-1) on every form page
       → See smartstack-frontend.md section 3b for templates
+    - **TABS ON DETAIL PAGES (CRITICAL):** Tabs MUST switch content LOCALLY:
+      → Tab click handler: setActiveTab(tabKey) ONLY — NEVER navigate() to another page
+      → Tab content: render inline with {activeTab === 'tabKey' && <TabContent />}
+      → Sub-resource data: fetch via API filtered by parent ID, display in tab panel
+      → FORBIDDEN: navigate('../leaves?employee=${id}') in tab handler
+      → See smartstack-frontend.md section 3 'Tab Behavior Rules'
     - **FK FIELDS (CRITICAL):** Foreign key Guid fields (e.g., EmployeeId) MUST use EntityLookup:
       → NEVER render FK fields as `<input>` — users cannot type GUIDs
       → NEVER render FK fields as `<select>` — even with API-loaded options, `<select>` is NOT acceptable
@@ -382,6 +401,27 @@ Each file MUST contain these keys: `title`, `description`, `actions`, `labels`,
 
 ---
 
+## PRD State Update (delegate mode only)
+
+> **After completing EACH layer**, update the PRD file so `/ralph-loop` can track progress.
+
+```
+IF delegate_mode:
+  After each layer completes successfully:
+    Read {delegate_prd_path}
+    For each task executed in this layer:
+      task.status = 'completed'  (or 'failed' if errors)
+      task.completed_at = new Date().toISOString()
+      task.iteration = 1  (delegate mode = single iteration)
+      task.commit_hash = $(git rev-parse --short HEAD)
+      task.files_changed = { created: [...files created...], modified: [...files modified...] }
+      task.validation = "APEX_PASS" (or error details)
+    prd.updated_at = new Date().toISOString()
+    Write back to {delegate_prd_path}
+```
+
+---
+
 ## Commits Per Layer
 
 After each layer completes, gates pass, and builds pass:

package/templates/skills/apex/steps/step-04-examine.md

@@ -51,6 +51,83 @@ Verify:
 - No orphan routes
 ```
 
+### 3b. Frontend Page Completeness (BLOCKING)
+
+> **ROOT CAUSE (test-v4-015):** Frontend generation created List + Detail pages but SKIPPED
+> Create + Edit pages. ListPage buttons navigated to /create and /:id/edit → white screen / 404.
+> Tests were also missing. This section catches that failure mode.
+
+```bash
+PAGE_DIR=$(find . -path "*/src/pages" -not -path "*/node_modules/*" -type d 2>/dev/null | head -1)
+APP_TSX=$(find . -name "App.tsx" -not -path "*/node_modules/*" 2>/dev/null | head -1)
+
+if [ -n "$PAGE_DIR" ]; then
+  # Check each module's ListPage for dead navigation links
+  LIST_PAGES=$(find "$PAGE_DIR" -name "*ListPage.tsx" -o -name "*sPage.tsx" 2>/dev/null | grep -v test | grep -v node_modules)
+  FAIL=false
+  for LIST_PAGE in $LIST_PAGES; do
+    LP_DIR=$(dirname "$LIST_PAGE")
+    MOD=$(basename "$LP_DIR")
+
+    HAS_CREATE_NAV=$(grep -P "navigate\(.*['/]create" "$LIST_PAGE" 2>/dev/null)
+    HAS_EDIT_NAV=$(grep -P "navigate\(.*['/]edit" "$LIST_PAGE" 2>/dev/null)
+
+    CREATE_PAGE=$(find "$LP_DIR" -name "*CreatePage.tsx" 2>/dev/null | head -1)
+    EDIT_PAGE=$(find "$LP_DIR" -name "*EditPage.tsx" 2>/dev/null | head -1)
+
+    if [ -n "$HAS_CREATE_NAV" ] && [ -z "$CREATE_PAGE" ]; then
+      echo "BLOCKING: $MOD ListPage navigates to /create but CreatePage does NOT exist → dead link"
+      FAIL=true
+    fi
+    if [ -n "$HAS_EDIT_NAV" ] && [ -z "$EDIT_PAGE" ]; then
+      echo "BLOCKING: $MOD ListPage navigates to /:id/edit but EditPage does NOT exist → dead link"
+      FAIL=true
+    fi
+  done
+
+  # Check route wiring in App.tsx
+  if [ -n "$APP_TSX" ]; then
+    CREATE_PAGES=$(find "$PAGE_DIR" -name "*CreatePage.tsx" 2>/dev/null | grep -v test)
+    EDIT_PAGES=$(find "$PAGE_DIR" -name "*EditPage.tsx" 2>/dev/null | grep -v test)
+    if [ -n "$CREATE_PAGES" ] && ! grep -qP "path:.*create" "$APP_TSX"; then
+      echo "BLOCKING: CreatePage exists but no 'create' route in App.tsx"
+      FAIL=true
+    fi
+    if [ -n "$EDIT_PAGES" ] && ! grep -qP "path:.*:id/edit" "$APP_TSX"; then
+      echo "BLOCKING: EditPage exists but no ':id/edit' route in App.tsx"
+      FAIL=true
+    fi
+  fi
+
+  # Check test files exist for form pages
+  FORM_PAGES=$(find "$PAGE_DIR" -name "*CreatePage.tsx" -o -name "*EditPage.tsx" 2>/dev/null | grep -v test)
+  if [ -n "$FORM_PAGES" ]; then
+    for FP in $FORM_PAGES; do
+      TF="${FP%.tsx}.test.tsx"
+      if [ ! -f "$TF" ]; then
+        echo "BLOCKING: Form page missing test: $FP → expected $TF"
+        FAIL=true
+      fi
+    done
+  fi
+
+  # Check at least SOME tests exist when pages exist
+  PAGE_COUNT=$(find "$PAGE_DIR" -name "*.tsx" ! -name "*.test.tsx" 2>/dev/null | grep -v node_modules | wc -l)
+  TEST_COUNT=$(find "$PAGE_DIR" -name "*.test.tsx" 2>/dev/null | grep -v node_modules | wc -l)
+  if [ "$PAGE_COUNT" -gt 0 ] && [ "$TEST_COUNT" -eq 0 ]; then
+    echo "BLOCKING: $PAGE_COUNT pages but ZERO test files"
+    FAIL=true
+  fi
+
+  if [ "$FAIL" = true ]; then
+    echo "Fix: Go back to step-03 and generate missing pages/tests/routes"
+    # MUST fix before proceeding
+  fi
+fi
+```
+
+**If ANY check fails → return to step-03 to generate the missing pages, tests, or routes.**
+
 ---
 
 ## 4. Build Verification
@@ -66,7 +143,13 @@ dotnet clean && dotnet restore && dotnet build
 npm run typecheck
 ```
 
-**BLOCKING:** Both must pass. If failure, fix and retry.
+**BLOCKING:** Both must pass. If failure, classify error per `references/error-classification.md` before attempting fix:
+- Category A (missing package) → `dotnet add package` → rebuild
+- Category B (assembly conflict) → resolve version → rebuild
+- Category C (DI missing) → fix DI registration → rebuild
+- Category D (migration broken) → fix migration → rebuild
+- Category E (config) → fix config → rebuild
+- Category F (source code) → fix code → rebuild
 
 ---
 
@@ -179,7 +262,7 @@ AC2: {criterion} → PASS / FAIL (evidence: {file:line or test})
 | Security | TenantId filter, RequirePermission, no Guid.Empty, no !.Value | PASS / N/A |
 | Seed data | completeness, deterministic GUIDs, no ContextId/RoleId constants | PASS / N/A |
 | Code quality | PaginatedResult, EntityLookup (no FK select/input), CSS vars, search param | PASS / N/A |
-| POST-CHECKs | 30 checks from references/post-checks.md | PASS / N/A |
+| POST-CHECKs | 43 checks from references/post-checks.md | PASS / N/A |
 | Acceptance criteria | AC1..ACn | {X}/{Y} PASS |
 ```
 
@@ -211,3 +294,28 @@ ELSE:
 The success criteria require: "Tests: 100% pass, >= 80% coverage" — this is impossible without step-07.
 
 **NEXT ACTION:** Load `steps/step-07-tests.md` now.
+
+---
+
+## 11. PRD Final Reconciliation (delegate mode only)
+
+> **After all validation passes**, ensure the PRD file reflects the completed state.
+
+```
+IF delegate_mode:
+  Read {delegate_prd_path}
+
+  For ALL tasks belonging to this module:
+    IF task was executed by apex AND all checks passed:
+      Verify task.status == 'completed'
+    IF task was NOT in scope (different module):
+      Leave unchanged
+
+  Set prd.updated_at = new Date().toISOString()
+
+  If ALL module tasks completed:
+    Set prd.status = 'completed' (if single module)
+    OR leave prd.status = 'in_progress' (if multi-module, other modules remain)
+
+  Write back to {delegate_prd_path}
+```

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

@@ -5,13 +5,14 @@ argument-hint: "<feature description>"
 ---
 
 <objective>
-Execute business analysis workflows. This skill produces a single feature.json progressively enriched at each step, published to docs/business/ for web app rendering.
+Execute business analysis workflows. This skill produces feature.json files progressively enriched at each step, published to docs/ for web app rendering.
 
-**Two use cases:**
-1. **New application** — full analysis workflow for a new business need
+**Three use cases:**
+1. **New application** — full analysis workflow for a new business need (single or multi-application)
 2. **Update** — delta changes on an existing application or module
+3. **Multi-application project** — when a project spans multiple independent applications (e.g., HR Management + Employee Self-Service)
 
-The skill auto-detects which use case applies by scanning existing features in `docs/business/`.
+The skill auto-detects which use case applies by scanning existing features in `docs/business/`, `docs/platform/`, `docs/personal/`, and `docs/business-analyse/`.
 
 **Architecture highlights:**
 - Conditional context loading: each step loads only the shared files it needs (~54% context reduction)
@@ -52,14 +53,18 @@ Step-00 handles detection automatically:
 **All outputs saved to PROJECT directory:**
 
 ```
-docs/business/
-    index.json                    # BA manifest (auto-updated at handoff, consumed by web app viewer)
-    {app}/business-analyse/v{X.Y}/
-        feature.json              # APPLICATION-level master (modules, dependencies, roles)
-        ba-interactive.html       # Client-facing interactive review document (deployed at handoff)
-    {app}/{module}/business-analyse/v{X.Y}/
-        feature.json              # MODULE-level detail (entities, UC, FR, permissions, mockups)
+docs/
+    business-analyse/v{X.Y}/
+        feature.json              # PROJECT-level master (only if multi-app: applications, dependencies)
+    {context}/                    # "business" | "platform" | "personal"
+        index.json                # BA manifest (auto-updated at handoff, consumed by web app viewer)
+        {app}/business-analyse/v{X.Y}/
+            feature.json          # APPLICATION-level master (modules, dependencies, roles)
+            ba-interactive.html   # Client-facing interactive review document (deployed at handoff)
+        {app}/{module}/business-analyse/v{X.Y}/
+            feature.json          # MODULE-level detail (entities, UC, FR, permissions, mockups)
 ```
+> In standalone mode (single app), the project-level file is NOT created and `{context}` is always `business`.
 
 **Ralph Loop files (generated by step-05):**
 ```
@@ -143,10 +148,11 @@ When step-00 detects that the description matches an existing application:
 4. If no match → new application
 5. Create master feature.json and proceed to step-01
 
-**New application workflow:**
+**New application workflow (single or multi-app):**
 - **Step 00:** Detection, scan existing, create master feature.json (draft)
 - **Step 01:** Cadrage: context, stakeholders, scope, application roles (framed)
-- **Step 02:** Decomposition: modules, dependencies, client checkpoint (decomposed)
+- **Step 01b:** *(multi-app only)* Application decomposition: identify applications, contexts, prefixes, inter-app dependencies
+- **Step 02:** Decomposition: modules, dependencies, client checkpoint (decomposed) — per application in multi-app mode
 - **Step 03a:** Per-module data: sections, entities, business rules, questionnaires
 - **Step 03b:** Per-module UI: state machines, wireframes, layouts, dashboards
 - **Step 03c:** Per-module compile: actors, UCs, FRs, permissions, navigation, seed data, i18n
@@ -180,8 +186,9 @@ When step-00 detects that the description matches an existing application:
 | `{version}`             | string  | SemVer (1.0, 1.1, 2.0, etc.)                           |
 | `{application_name}`    | string  | Target application name                                |
 | `{module_name}`         | string  | Target module name                                     |
-| `{context}`             | string  | Always "business" for BA                               |
-| `{workflow_mode}`       | string  | "application" or "module"                              |
+| `{project_id}`          | string  | Project identifier (e.g., `PROJ-001`) — only in multi-app mode |
+| `{context}`             | string  | "business" (default), "platform", or "personal" per application |
+| `{workflow_mode}`       | string  | "project" (multi-app), "application" (single-app multi-module), or "module" (single) |
 | `{analysisMode}`        | string  | Always "interactive" — analysis phase is always interactive with the user |
 | `{docs_dir}`            | string  | `docs/business/{app}/{module}/business-analyse/v{X.Y}/` |
 
@@ -199,8 +206,9 @@ When step-00 detects that the description matches an existing application:
 | Step | File                              | Model  | Purpose                                              |
 | ---- | --------------------------------- | ------ | ---------------------------------------------------- |
 | 00   | `steps/step-00-init.md`           | Sonnet | Auto-detect new/update, scan existing, create master feature.json |
-| 01   | `steps/step-01-cadrage.md`        | Opus   | Framing: context, stakeholders, scope, application roles |
-| 02   | `steps/step-02-decomposition.md`  | Opus   | Module decomposition, dependency graph, client checkpoint |
+| 01   | `steps/step-01-cadrage.md`        | Opus   | Framing: context, stakeholders, scope, application roles + multi-app detection |
+| 01b  | `steps/step-01b-applications.md`  | Opus   | *(multi-app only)* Application decomposition, contexts, prefixes, inter-app dependencies |
+| 02   | `steps/step-02-decomposition.md`  | Opus   | Module decomposition, dependency graph, client checkpoint (per application in multi-app) |
 | 03a1 | `steps/step-03a1-setup.md`        | Opus   | Per-module: setup, sections, questionnaires, cross-refs |
 | 03a2 | `steps/step-03a2-analysis.md`     | Opus   | Per-module: objectives, entities, BRs, process flow |
 | 03b  | `steps/step-03b-ui.md`            | Opus   | Per-module: state machines, wireframes, layouts, dashboards |
@@ -223,7 +231,8 @@ Load ONLY relevant categories based on feature type:
 
 | Categorie | Fichier                               | Questions | Quand charger |
 | --------- | ------------------------------------- | --------- | ------------- |
-| 00        | `questionnaire/00-application.md`     | 18        | Si workflow_mode = "application" |
+| 00b       | `questionnaire/00b-project.md`        | 5         | Si workflow_mode = "project" (multi-app) |
+| 00        | `questionnaire/00-application.md`     | 18        | Si workflow_mode = "application" ou "project" |
 | 01        | `questionnaire/01-context.md`         | 32        | Toujours      |
 | 02        | `questionnaire/02-stakeholders.md`    | 33        | Toujours      |
 | 03        | `questionnaire/03-scope.md`           | 32        | Toujours      |
@@ -271,10 +280,11 @@ Load ONLY relevant categories based on feature type:
 - **Use ba-writer agent** for all JSON writes
 - **Use ba-reader agent** for all JSON reads
 - **Follow next_step directive** at end of each step
-- **Context: business only** - Reject platform/personal/system contexts
+- **Context:** business-only in standalone mode; business/platform/personal per-application in project mode
 - **Use parallel agents** for codebase exploration
 - **Team mode** (2+ modules): After step-02, load `references/team-orchestration.md` and follow team protocol
 - **Inline mode** (1 module): Classic sequential execution, no team
+- **Project mode** (2+ applications): Application loop wraps module loop — see `_module-loop.md`
 </execution_rules>
 
 <team_mode>

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

@@ -1,11 +1,11 @@
 # Business Analysis - Module Loop Protocol (_module-loop.md)
 
 > **Loaded by:** step-03a1-setup, step-03b-ui, step-03c-compile, step-03d-validate
-> **Purpose:** State management and iteration logic for multi-module specification loop
+> **Purpose:** State management and iteration logic for multi-module specification loop + application loop (project mode)
 
 ---
 
-## State Management
+## State Management (Application Mode — single app)
 
 ```json
 {
@@ -21,20 +21,61 @@
 }
 ```
 
-## Loop Logic (end of each step-03 iteration)
+## State Management (Project Mode — multi app)
 
+Project-level feature.json tracks the application loop:
+
+```json
+{
+  "metadata": {
+    "workflow": {
+      "mode": "project",
+      "applicationOrder": ["HumanResources", "EmployeeSelfService"],
+      "currentApplicationIndex": 0,
+      "completedApplications": [],
+      "currentApplication": "HumanResources"
+    }
+  }
+}
 ```
-1. Mark current module as "validated" in master feature.json
+
+Each application-level feature.json tracks its own module loop (same as application mode).
+
+## Module Loop Logic (end of each step-03 iteration)
+
+```
+1. Mark current module as "validated" in application-level feature.json
 2. Add to completedModules[]
 3. IF currentModuleIndex + 1 < moduleOrder.length:
      currentModuleIndex++
      currentModule = moduleOrder[currentModuleIndex]
-     Write master feature.json
+     Write application-level feature.json
      Display: "Module {name} complete. Next: {next_name} ({N}/{total})"
      RE-LOAD: steps/step-03a1-setup.md
-4. ELSE:
-     master.status = "specified"
-     Load: steps/step-04a-collect.md
+4. ELSE (all modules for current application specified):
+     IF workflow.mode === "project":
+       → Execute APPLICATION LOOP LOGIC (below)
+     ELSE:
+       application.status = "specified"
+       Load: steps/step-04a-collect.md
+```
+
+## Application Loop Logic (project mode only)
+
+> Only applicable when `workflow.mode === "project"` in the project-level feature.json.
+
+```
+1. Mark current application as "specified" in project feature.json
+   ba-writer.updateApplicationStatus(projectId, currentApp, "specified")
+2. Add to completedApplications[]
+   ba-writer.advanceApplicationLoop(projectId)
+3. IF currentApplicationIndex + 1 < applicationOrder.length:
+     Display: "═══ Application {currentApp} complete ({N}/{total}). Next: {nextApp} ═══"
+     Load: steps/step-02-decomposition.md (for next application's module decomposition)
+4. ELSE (all applications specified):
+     Display: "═══ All applications specified! Proceeding to cross-application consolidation... ═══"
+     project.status = "specified"
+     Load: steps/step-04a-collect.md (with cross-application consolidation)
 ```
 
 ## Context Management During Loop
@@ -43,14 +84,32 @@ 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
+- **In project mode — completed applications:** Only load compact summary via `ba-reader.getCompletedApplicationsSummary()` (max 50 lines per app)
 
 ## Resume After Interruption
 
+### Application Mode (single app)
 ```
-1. ba-reader.findApplicationFeature() -> locate master feature.json
+1. ba-reader.findApplicationFeature() -> locate application-level feature.json
 2. Read metadata.workflow.currentModuleIndex
 3. IF currentModule has a feature.json with status != "validated":
      Resume step-03a1-setup for that module
 4. ELSE:
      Start step-03a1-setup for next module
 ```
+
+### Project Mode (multi app)
+```
+1. ba-reader.findProjectFeature() -> locate project-level feature.json
+2. Read metadata.workflow.currentApplicationIndex
+3. Locate current application's feature.json
+4. Read application's metadata.workflow.currentModuleIndex
+5. IF currentModule has a feature.json with status != "validated":
+     Resume step-03a1-setup for that module in that application
+6. ELSE IF application has unspecified modules:
+     Start step-03a1-setup for next module in current application
+7. ELSE IF more applications remain:
+     Start step-02-decomposition for next application
+8. ELSE:
+     All done → Resume step-04a-collect
+```

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

@@ -12,25 +12,41 @@
 
 ## JSON-First Architecture
 
-All BA outputs are stored in **two levels** of feature.json, enriched progressively:
+All BA outputs are stored in up to **three levels** of feature.json, enriched progressively:
+
+### Project-Level (Multi-App Master) — Only if 2+ applications
+**Path:** `docs/business-analyse/v{X.Y}/feature.json`
+**Schema:** `docs/business-analyse/schemas/project-schema.json`
+**$schema:** `"../schemas/project-schema.json"`
+
+| Step | Section enriched | Status after |
+|------|-----------------|--------------|
+| 00-init | metadata | draft |
+| 01-cadrage | cadrage (global problem, stakeholders, scope, roles) | framed |
+| 01b-applications | applications[], applicationDependencyGraph | decomposed |
+| 02-05 | applications[].status updated per iteration | specified → handed-off |
+
+> **Backward compatibility:** If only 1 application is identified, the project level is NOT created. The application-level feature.json remains the master (current behavior).
 
 ### Application-Level (Master)
-**Path:** `docs/business/{app}/business-analyse/v{X.Y}/feature.json`
-**Schema:** `docs/business/{app}/business-analyse/schemas/application-schema.json` (deployed to project by step-00)
+**Path:** `docs/{context}/{app}/business-analyse/v{X.Y}/feature.json`
+**Schema:** `docs/{context}/{app}/business-analyse/schemas/application-schema.json` (deployed to project by step-00)
 **$schema:** `"../schemas/application-schema.json"` (relative in feature.json)
 
 | Step | Section enriched | Status after |
 |------|-----------------|--------------|
-| 00-init | metadata | draft |
+| 00-init (or 01b) | metadata | draft |
 | 01-cadrage | cadrage (problem, stakeholders, scope, roles) | framed |
 | 02-decomposition | modules, dependencyGraph | decomposed |
 | 03-specify | modules[].status updated per iteration | specified |
 | 04-consolidation | consolidation | consolidated |
 | 05-handoff | (per-module handoff) | handed-off |
 
+> **{context}** = `business` (default) | `platform` | `personal` — determined per application. In standalone mode, always `business`.
+
 ### Module-Level (Per Module)
-**Path:** `docs/business/{app}/{module}/business-analyse/v{X.Y}/feature.json`
-**Schema:** `docs/business/{app}/business-analyse/schemas/feature-schema.json` (deployed to project by step-00)
+**Path:** `docs/{context}/{app}/{module}/business-analyse/v{X.Y}/feature.json`
+**Schema:** `docs/{context}/{app}/business-analyse/schemas/feature-schema.json` (deployed to project by step-00)
 **$schema:** `"../../../business-analyse/schemas/feature-schema.json"` (relative in feature.json)
 
 | Step | Section enriched | Status after |
@@ -42,10 +58,18 @@ All BA outputs are stored in **two levels** of feature.json, enriched progressiv
 | 03-specify (validate) | validation | validated |
 
 **Agents:**
-- **ba-writer**: Writes/updates feature.json (create, enrichSection, updateStatus, createVersion, createApplicationFeature, advanceModuleLoop)
-- **ba-reader**: Reads feature.json (findFeature, readSection, answerQuestion, getSummaryForSkill, readApplicationContext, getCompletedModulesSummary)
+- **ba-writer**: Writes/updates feature.json (create, enrichSection, updateStatus, createVersion, createApplicationFeature, createProjectFeature, enrichApplicationRegistry, advanceModuleLoop, advanceApplicationLoop)
+- **ba-reader**: Reads feature.json (findFeature, findProjectFeature, readSection, answerQuestion, getSummaryForSkill, readApplicationContext, getCompletedModulesSummary, getCompletedApplicationsSummary)
+
+**Schemas:** Deployed to project at `docs/{context}/{app}/business-analyse/schemas/` (10 files, including project-schema.json). Source: `schemas/` in skill directory. Every feature.json includes `$schema` relative reference.
 
-**Schemas:** Deployed to project at `docs/business/{app}/business-analyse/schemas/` (9 files). Source: `schemas/` in skill directory. Every feature.json includes `$schema` relative reference.
+### Workflow Modes
+
+| Mode | Trigger | Master Level | Loop |
+|------|---------|-------------|------|
+| `"module"` | 1 module only | Application | No loop |
+| `"application"` | 1 app, 2+ modules | Application | Module loop |
+| `"project"` | 2+ applications | Project | Application loop → Module loop per app |
 
 ---
 
@@ -135,15 +159,25 @@ Level 1: Context (business)
 ## Business Context Validation
 
 ```
-validate_business_context(context):
-  IF context IN ['platform', 'personal', 'system'] THEN
-    ERROR "BA restricted to 'business' context. Contact: support@atlshub.ch"
+validate_business_context(context, workflow_mode):
+  IF workflow_mode === "project" THEN
+    // In project mode, applications can target any context
+    IF context IN ['business', 'platform', 'personal'] THEN
+      RETURN true
+    END IF
+    ERROR "Invalid context '${context}'. Allowed: business, platform, personal"
     RETURN false
+  ELSE
+    // In standalone mode, only business context is allowed
+    IF context IN ['platform', 'personal', 'system'] THEN
+      ERROR "BA restricted to 'business' context in standalone mode. Use multi-application project mode for other contexts."
+      RETURN false
+    END IF
+    RETURN true
   END IF
-  RETURN true
 ```
 
-**CRITICAL:** BusinessAnalyze works ONLY for the `business` context.
+**CRITICAL:** In standalone mode (single application), BA works ONLY for the `business` context. In project mode (multi-application), each application can target `business`, `platform`, or `personal` contexts.
 
 ---
 
@@ -151,12 +185,18 @@ validate_business_context(context):
 
 ```
 docs/
-  business/
+  business-analyse/                       <- PROJECT level (only if multi-app)
+      schemas/
+          project-schema.json
+      v1.0/
+          feature.json                    <- PROJECT master ($schema: ../schemas/project-schema.json)
+  {context}/                              <- "business" | "platform" | "personal"
     {application}/
         business-analyse/
-            schemas/                  <- JSON SCHEMAS (deployed by step-00)
+            schemas/                      <- JSON SCHEMAS (deployed by step-00)
                 feature-schema.json
                 application-schema.json
+                project-schema.json
                 sections/
                     analysis-schema.json
                     discovery-schema.json
@@ -167,17 +207,19 @@ docs/
                 shared/
                     common-defs.json
             v1.0/
-                feature.json          <- APPLICATION master ($schema: ../schemas/application-schema.json)
+                feature.json              <- APPLICATION master ($schema: ../schemas/application-schema.json)
         {module1}/
             business-analyse/
                 v1.0/
-                    feature.json      <- MODULE detail ($schema: ../../../business-analyse/schemas/feature-schema.json)
+                    feature.json          <- MODULE detail ($schema: ../../../business-analyse/schemas/feature-schema.json)
         {module2}/
             business-analyse/
                 v1.0/
-                    feature.json      <- MODULE detail
+                    feature.json          <- MODULE detail
 ```
 
+> In standalone mode (single app), `{context}` is always `business` and the project-level directory is NOT created.
+
 **Ralph Loop Integration (generated by step-05):**
 
 ```
@@ -198,6 +240,12 @@ generate_feature_id():
   new_id = last_id + 1
   update_config(".business-analyse/config.json", "lastFeatureId", new_id)
   RETURN format("FEAT-%03d", new_id)
+
+generate_project_id():
+  last_id = read_config(".business-analyse/config.json", "lastProjectId") OR 0
+  new_id = last_id + 1
+  update_config(".business-analyse/config.json", "lastProjectId", new_id)
+  RETURN format("PROJ-%03d", new_id)
 ```
 
 ---
@@ -206,10 +254,12 @@ generate_feature_id():
 
 | Level | Format | Example |
 |-------|--------|---------|
-| Module | `{context}.{app}.{module}.{action}` | `business.sales.orders.read` |
-| Section | `{context}.{app}.{module}.{section}.{action}` | `business.sales.orders.dashboard.read` |
+| Module | `{context}.{app}.{module}.{action}` | `business.human-resources.employees.read` |
+| Section | `{context}.{app}.{module}.{section}.{action}` | `business.human-resources.employees.departments.read` |
 
 > **Rule:** Use module-level permissions for standard CRUD. Use section-level permissions only when a section requires distinct access control (e.g., dashboard, approve, import).
+>
+> **CRITICAL — All segments use kebab-case:** Multi-word codes MUST have hyphens. `human-resources`, NOT `humanresources`. Matches NavRoute convention. SmartStack.app ref: `business.support-client.my-tickets.read`
 
 | Action | Permission | Usage |
 |--------|------------|-------|

package/templates/skills/business-analyse/questionnaire/00-application.md

@@ -1,8 +1,10 @@
 # Categorie 0 : Identite de l'application
 
-> **Charge par :** step-01-cadrage.md (mode application uniquement)
-> **Quand :** Toujours charge quand le mode est "application" (multi-module)
+> **Charge par :** step-01-cadrage.md (mode application uniquement) ou step-01b-applications.md (mode project)
+> **Quand :** Toujours charge quand le mode est "application" (multi-module) ou "project" (multi-application)
 > **Objectif :** Definir le cadre global de l'application avant d'entrer dans les details
+>
+> **Mode projet :** Si `workflow.mode === "project"`, certaines questions ont deja ete repondues au niveau projet (probleme, stakeholders, vision). Se concentrer sur l'identite specifique a cette application : nom, contexte, prefixe, roles specialises. Ne PAS re-demander les stakeholders et le probleme global.
 
 ---