@atlashub/smartstack-cli 3.33.0 → 3.35.0

package/templates/skills/business-analyse/questionnaire/00b-project.md

@@ -0,0 +1,85 @@
+# Questionnaire Category 00b: Project-Level Questions
+
+> **Loaded by:** step-01-cadrage (when multi-application mode detected)
+> **Condition:** Only loaded when user confirms "Multiple applications"
+> **Purpose:** Gather project-level information that spans all applications
+
+---
+
+## Questions
+
+### Q0b.1: Project Name
+```
+question: "{language == 'fr' ? 'Quel nom souhaitez-vous donner au projet global ?' : 'What name would you like for the overall project?'}"
+header: "Projet"
+options:
+  - label: "{suggested_project_name}"
+    description: "{language == 'fr' ? 'Nom suggéré basé sur votre description' : 'Suggested name based on your description'}"
+  - label: "{language == 'fr' ? 'Personnaliser' : 'Customize'}"
+    description: "{language == 'fr' ? 'Choisir un autre nom' : 'Choose another name'}"
+```
+
+### Q0b.2: Deployment Model
+```
+question: "{language == 'fr' ? 'Comment ces applications seront-elles déployées ?' : 'How will these applications be deployed?'}"
+header: "Déploiement"
+options:
+  - label: "{language == 'fr' ? 'Ensemble' : 'Together'}"
+    description: "{language == 'fr' ? 'Toutes les applications sont déployées en même temps' : 'All applications deployed at the same time'}"
+  - label: "{language == 'fr' ? 'Par phases' : 'Phased'}"
+    description: "{language == 'fr' ? 'Chaque application est livrée séparément, par priorité' : 'Each application delivered separately, by priority'}"
+```
+
+### Q0b.3: Cross-Application Data Flows
+```
+question: "{language == 'fr' ? 'Existe-t-il des flux de données entre les applications identifiées ?' : 'Are there data flows between the identified applications?'}"
+header: "Flux"
+options:
+  - label: "{language == 'fr' ? 'Oui, plusieurs' : 'Yes, several'}"
+    description: "{language == 'fr' ? 'Des données sont partagées entre applications (ex: employés RH utilisés par le self-service)' : 'Data is shared between applications (e.g., HR employees used by self-service)'}"
+  - label: "{language == 'fr' ? 'Quelques liens' : 'A few links'}"
+    description: "{language == 'fr' ? 'Peu de dépendances entre applications' : 'Few dependencies between applications'}"
+  - label: "{language == 'fr' ? 'Indépendantes' : 'Independent'}"
+    description: "{language == 'fr' ? 'Les applications sont autonomes, pas de données partagées' : 'Applications are autonomous, no shared data'}"
+```
+
+### Q0b.4: Global vs Per-Application Roles
+```
+question: "{language == 'fr' ? 'Les rôles utilisateur sont-ils partagés entre applications ?' : 'Are user roles shared across applications?'}"
+header: "Rôles"
+options:
+  - label: "{language == 'fr' ? 'Rôles globaux' : 'Global roles'}"
+    description: "{language == 'fr' ? 'Les mêmes rôles (admin, manager...) s'appliquent à toutes les applications' : 'Same roles (admin, manager...) apply to all applications'}"
+  - label: "{language == 'fr' ? 'Rôles spécifiques' : 'Specific roles'}"
+    description: "{language == 'fr' ? 'Chaque application a ses propres rôles (ex: RH Admin vs Employee)' : 'Each application has its own roles (e.g., HR Admin vs Employee)'}"
+  - label: "{language == 'fr' ? 'Mixte' : 'Mixed'}"
+    description: "{language == 'fr' ? 'Certains rôles sont globaux, d'autres spécifiques à une application' : 'Some roles are global, others are application-specific'}"
+```
+
+### Q0b.5: Shared Infrastructure
+```
+question: "{language == 'fr' ? 'Quelles infrastructures partagées doivent être prises en compte ?' : 'What shared infrastructure needs to be considered?'}"
+header: "Infra"
+multiSelect: true
+options:
+  - label: "SSO / Auth"
+    description: "{language == 'fr' ? 'Authentification unique entre applications' : 'Single sign-on between applications'}"
+  - label: "Notifications"
+    description: "{language == 'fr' ? 'Service de notification partagé (email, in-app)' : 'Shared notification service (email, in-app)'}"
+  - label: "{language == 'fr' ? 'Base de données partagée' : 'Shared database'}"
+    description: "{language == 'fr' ? 'Toutes les applications partagent la même base de données' : 'All applications share the same database'}"
+  - label: "{language == 'fr' ? 'Aucune' : 'None'}"
+    description: "{language == 'fr' ? 'Chaque application est autonome' : 'Each application is autonomous'}"
+```
+
+---
+
+## Mapping to Project Feature.json
+
+| Question | Target Field |
+|----------|-------------|
+| Q0b.1 | `metadata.projectName` |
+| Q0b.2 | `cadrage.deploymentModel` |
+| Q0b.3 | Informs `applicationDependencyGraph.edges[]` |
+| Q0b.4 | Informs `cadrage.globalRoles[]` vs per-app `applications[].applicationRoles[]` |
+| Q0b.5 | `cadrage.sharedInfrastructure[]` |

package/templates/skills/business-analyse/references/deploy-modes.md

@@ -31,6 +31,75 @@ Focused handoff for changes:
 - Update only affected prd.json sections
 - Progress tracker shows only delta tasks
 
+### Multi-Application Mode (workflow.mode = "project")
+
+Full handoff across multiple applications within a project:
+
+**Artifacts generated:**
+- Per-module: `.ralph/prd-{moduleCode}.json` (one per module across all applications)
+- Per-application cross-module: `.ralph/prd-CrossModule-{appCode}.json` (if app has 2+ modules)
+- Cross-application: `.ralph/prd-CrossApplication.json` (integration tests between applications)
+- Progress tracker: `.ralph/progress.txt` (grouped by application, then by module)
+- BA manifest: `docs/business/index.json` (project-level entry + per-application + per-module entries)
+- Interactive HTML: one HTML file per application at `docs/{context}/{app}/business-analyse/v{version}/ba-interactive.html`
+
+**Project-level manifest entry:**
+```json
+{
+  "scope": "project",
+  "projectId": "PROJ-001",
+  "projectName": "HR Platform",
+  "version": "1.0",
+  "status": "handed-off",
+  "applications": ["HumanResources", "EmployeeSelfService"],
+  "path": "business-analyse/v1.0/feature.json",
+  "updatedAt": "2026-02-16T..."
+}
+```
+
+**Progress tracker structure (multi-app):**
+```
+# Progress Tracker — {projectName}
+
+## Application: {app1Name} ({app1Context})
+
+### Module: {module1} (Layer 0 — simple)
+- [ ] Domain: Entity1.cs
+- [ ] Application: Entity1Service.cs
+...
+
+### Module: {module2} (Layer 1 — medium)
+...
+
+## Application: {app2Name} ({app2Context})
+...
+
+## Cross-Application Integration
+- [ ] SharedEntityValidationTests.cs
+- [ ] CrossAppPermissionTests.cs
+- [ ] CrossAppE2EFlowTests.cs
+
+## Summary
+| Application | Modules | Files | Tasks | Complexity |
+|-------------|---------|-------|-------|------------|
+| {app1}      | {n}     | {n}   | {n}   | {level}    |
+| {app2}      | {n}     | {n}   | {n}   | {level}    |
+| Cross-App   | —       | 3     | 3     | —          |
+| **Total**   | {n}     | {n}   | {n}   | {global}   |
+```
+
+**seedDataCore differences:**
+- `navigationApplications[]` has one entry per application (different contexts possible)
+- `navigationModules[]` includes `applicationCode` field for each module
+- `permissions[]` use per-application context prefixes (e.g., `business.hr.*` vs `platform.admin.*`)
+- `rolePermissions[]` are scoped per application (same role can have different permissions per app)
+- Seed data order: applications in topological order, then modules within each application
+
+**ralph-loop execution (recommended):**
+- Run `/ralph-loop` once per application (module-by-module within each app)
+- Cross-application PRD runs last after all applications are implemented
+- Application order follows `applicationDependencyGraph.topologicalOrder`
+
 ## Troubleshooting
 
 | Issue | Resolution |

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

@@ -7,6 +7,57 @@
 
 ---
 
+## Multi-Application Team Structure (Project Mode)
+
+> **Only applies when `workflow.mode === "project"`** (multiple applications in a single BA session).
+> In single-application mode, skip this section entirely.
+
+When the project contains multiple applications, the team structure adds an **application-level outer loop** around the existing module-level inner loop:
+
+```
+Team Lead (project level)
+├── Application 1 (in topological order)
+│   ├── mod-{app1-module1} (parallel per dependency layer)
+│   ├── mod-{app1-module2}
+│   └── consolidation-{app1}
+├── Application 2
+│   ├── mod-{app2-module1}
+│   ├── mod-{app2-module2}
+│   └── consolidation-{app2}
+├── Cross-Application Consolidation Agent
+└── Handoff Agent (all applications)
+```
+
+**Application Loop Protocol:**
+
+```
+FOR each application in projectFeature.applicationDependencyGraph.topologicalOrder:
+  1. Load application feature.json
+  2. Read module decomposition for this application
+  3. Execute §1-§4 (team setup → module specification → review → layer completion)
+     - Team name: "ba-{projectName}-{appCode}"
+     - Agent names: "mod-{appCode}-{moduleCode}"
+     - Context passed to agents includes application-specific: context, tablePrefix, applicationRoles
+  4. After all modules in this application are specified:
+     - Run per-application consolidation (§5 — scoped to this application's modules)
+     - Mark application as "specified" in project feature.json
+     - Clean up application team
+
+AFTER all applications specified:
+  5. Run cross-application consolidation (§5-bis)
+  6. Run unified handoff (§6 — all applications at once)
+  7. Cleanup (§7)
+```
+
+**Key differences from single-application mode:**
+- Team names include application code to avoid collisions
+- Agent prompts include application context (not just module context)
+- Cross-application consolidation runs AFTER all per-application consolidations
+- Handoff generates one PRD per module + one cross-application PRD
+- The team lead tracks both `completedApplications[]` and `completedModules[]`
+
+---
+
 ## 1. Team Setup
 
 After step-02 decomposition is complete and client has approved the module structure:
@@ -612,13 +663,101 @@ AskUserQuestion: "Approuvez-vous la consolidation ?"
 - "Approuver" → send APPROVED to agent → agent writes consolidation to master feature.json
 - "Réviser" → send feedback → agent adjusts
 
-After approval → shutdown consolidation agent → proceed to §6.
+After approval → shutdown consolidation agent.
+
+**IF `workflow.mode === "project"`:** proceed to §5-bis (cross-application consolidation).
+**ELSE:** proceed to §6 (handoff).
+
+---
+
+## 5-bis. Cross-Application Consolidation (Project Mode Only)
+
+> **Only runs when `workflow.mode === "project"` AND all applications have been consolidated.**
+> This step validates interactions BETWEEN applications, not just between modules within one application.
+
+```javascript
+Task({
+  subagent_type: "general-purpose",
+  team_name: teamContext.teamName,
+  name: "cross-app-consolidation",
+  model: "opus",
+  mode: "bypassPermissions",
+  prompt: `
+You are a cross-application consolidation agent for project "{projectName}".
+
+## Your Mission
+Validate interactions between ALL applications in the project:
+
+1. Cross-application shared entities
+   → Entity defined in App A, referenced by App B via data dependency
+2. Cross-application permission path consistency
+   → Each app uses its own context prefix (e.g., business.hr.* vs business.selfservice.*)
+3. Cross-application role consistency
+   → Same role names have compatible permission levels across apps
+4. Cross-application navigation coherence
+   → Applications appear in correct contexts with non-colliding routes
+5. Cross-application seed data ordering
+   → Foundation applications must seed first (NavigationApplication order)
+
+## Context
+- Project ID: {projectId}
+- Applications: ${JSON.stringify(projectFeature.applications.map(a => ({
+    code: a.code, context: a.context, modules: a.modules.map(m => m.code)
+  })))}
+- Application dependency graph: ${JSON.stringify(projectFeature.applicationDependencyGraph)}
+
+## Output
+Send CROSS_APP_CONSOLIDATION_READY with:
+- Cross-application interactions found
+- Permission path conflicts (if any)
+- Role inconsistencies (if any)
+- Recommended seed data order
+  `,
+  description: "Cross-app consolidation"
+});
+```
+
+When CROSS_APP_CONSOLIDATION_READY received:
+
+```
+═══════════════════════════════════════════════════════════
+  Cross-Application Consolidation — {projectName}
+═══════════════════════════════════════════════════════════
+
+{cross-application consolidation report}
+
+─────────────────────────────────────────────────────────
+```
+
+AskUserQuestion: "Approuvez-vous la consolidation inter-applications ?"
+- "Approuver" → write cross-application interactions to project feature.json → proceed to §6
+- "Réviser" → send feedback → agent adjusts
+
+After approval → shutdown agent → proceed to §6.
 
 ---
 
 ## 6. Handoff Phase
 
 ```javascript
+// Project mode: handoff agent processes ALL applications at once
+// Single-app mode: handoff agent processes one application
+const handoffContext = workflow.mode === "project"
+  ? {
+      scope: "project",
+      projectId: projectId,
+      applications: projectFeature.applications.map(a => ({
+        code: a.code, context: a.context, featureId: a.featureJsonPath,
+        modules: a.modules.map(m => m.code)
+      })),
+      totalModules: projectFeature.applications.reduce((sum, a) => sum + a.modules.length, 0)
+    }
+  : {
+      scope: "application",
+      featureId: featureId,
+      modules: moduleOrder
+    };
+
 Task({
   subagent_type: "general-purpose",
   team_name: teamContext.teamName, // ← ACTUAL name from TeamCreate result
@@ -626,7 +765,7 @@ Task({
   model: "sonnet",
   mode: "bypassPermissions",
   prompt: `
-You are a handoff agent for business-analyse application "{appName}".
+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):
@@ -635,9 +774,17 @@ Execute the handoff sequence (steps 05a + 05b + 05c):
 3. Load steps/step-05c-ralph-readiness.md and execute (quality gate)
 
 ## Context
-- Feature ID: {featureId}
-- Modules: {moduleOrder.join(", ")}
+${workflow.mode === "project" ? `
+- Project ID: ${projectId}
+- Applications: ${JSON.stringify(handoffContext.applications)}
+- Total modules: ${handoffContext.totalModules}
+- Workflow mode: project
+- All applications and modules consolidated
+` : `
+- Feature ID: ${featureId}
+- Modules: ${moduleOrder.join(", ")}
 - All modules consolidated
+`}
 
 ## Output
 Send HANDOFF_READY with:
@@ -646,8 +793,8 @@ Send HANDOFF_READY with:
 - Quality gate result (PASS/FAIL with details)
 
 ## Communication
-- HANDOFF_READY:{appName}\n{report} → when all artifacts deployed
-- ERROR:{appName}:{description} → on blocking issue
+- HANDOFF_READY:${workflow.mode === "project" ? projectName : appName}\n{report} → when all artifacts deployed
+- ERROR:${workflow.mode === "project" ? projectName : appName}:{description} → on blocking issue
   `,
   description: "Handoff & deploy"
 });
@@ -760,7 +907,8 @@ If the entire session crashes:
 | Condition | Action |
 |-----------|--------|
 | 1 module | NO team, classic inline execution |
-| 2+ modules | Team mode (Propose & Review) |
+| 2+ modules (single app) | Team mode (Propose & Review) |
+| 2+ applications (project mode) | Application loop + per-app team mode |
 | Modules in same dependency layer | Spawn ALL in parallel (single message) |
 | Modules in different layers | Sequential — complete layer N before spawning layer N+1 |
 | Layer with 1 module | Standard single-agent propose-review |
@@ -774,6 +922,9 @@ If the entire session crashes:
 | Layer consistency check fails | Auto-fix via targeted REVISION |
 | Context > 50% on team lead | Minimize presentation, suggest auto-approve |
 | Session crash | Resume from feature.json + completedModules state |
+| Project mode + all app modules done | Run per-app consolidation → advance to next app |
+| Project mode + all apps done | Run cross-app consolidation (§5-bis) → unified handoff |
+| Project mode + app has 1 module | Inline mode for that app (no team) |
 
 ---
 

package/templates/skills/business-analyse/schemas/application-schema.json

@@ -34,7 +34,8 @@
         "createdAt": { "type": "string", "format": "date-time" },
         "updatedAt": { "type": "string", "format": "date-time" },
         "application": { "type": "string", "description": "Application name (PascalCase)" },
-        "context": { "type": "string", "const": "business" },
+        "context": { "type": "string", "enum": ["business", "platform", "personal"], "description": "Navigation context (business by default, other contexts allowed in project mode)" },
+        "projectRef": { "type": ["string", "null"], "description": "Parent project ID (PROJ-XXX) when part of a multi-application project, null for standalone" },
         "language": { "type": "string", "enum": ["fr", "en", "it", "de"] },
         "featureDescription": { "type": "string" },
         "workflowType": {
@@ -53,6 +54,19 @@
           "pattern": "^[a-z]{2,5}_$",
           "description": "Application table prefix for database tables (e.g., rh_, fi_, crm_). Defined during cadrage, used by all entities in this application."
         },
+        "applicationCode": {
+          "type": "string",
+          "description": "PascalCase application code for navigation hierarchy (e.g., HumanResources). Confirmed in step-01b."
+        },
+        "applicationRoute": {
+          "type": "string",
+          "pattern": "^/[a-z-/]+$",
+          "description": "Kebab-case route path for navigation (e.g., /business/human-resources). Confirmed in step-01b."
+        },
+        "applicationIcon": {
+          "type": "string",
+          "description": "Lucide icon name for application navigation entry (e.g., users, shopping-cart). Confirmed in step-01b."
+        },
         "workflow": {
           "type": "object",
           "description": "Iterative module loop state",