@atlashub/smartstack-cli 3.34.0 → 3.35.0

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

@@ -262,7 +262,13 @@ 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 | 43 checks from references/post-checks.md | PASS / N/A |
+| Migration completeness | ModelSnapshot covers ALL DbSet entities (POST-CHECK 44, 49) | PASS / N/A |
+| NavRoute kebab-case | NavRoute + permissions use kebab-case (POST-CHECK 48) | PASS / N/A |
+| DateOnly DTOs | Date fields use DateOnly not string (POST-CHECK 47) | PASS / N/A |
+| I18n registration | Namespaces registered in i18n config (POST-CHECK 45) | PASS / N/A |
+| Validators DI | FluentValidation registered in DI (POST-CHECK 46) | PASS / N/A |
+| Route/NavRoute conflict | No [Route] alongside [NavRoute] on controllers (POST-CHECK 50) | PASS / N/A |
+| POST-CHECKs | 50 checks from references/post-checks.md | PASS / N/A |
 | Acceptance criteria | AC1..ACn | {X}/{Y} PASS |
 ```
 

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

@@ -43,6 +43,7 @@ The skill auto-detects which use case applies by scanning existing features in `
 
 Step-00 handles detection automatically:
 - **New vs Update**: scans `docs/business/` for existing applications
+- **Single vs Multi-app**: multi-app detection in step-01, application identity confirmed in step-01b (always)
 - **Single vs Multi-module**: determined during step-02 decomposition
 - **Language**: detected from config or asked once
 - **Review mode**: if `-review` flag, routes directly to step-06
@@ -151,7 +152,7 @@ When step-00 detects that the description matches an existing application:
 **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 01b:** *(multi-app only)* Application decomposition: identify applications, contexts, prefixes, inter-app dependencies
+- **Step 01b:** Application identity (always): confirm code, route, icon, seed data (lightweight single-app / full decomposition multi-app)
 - **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
@@ -207,12 +208,12 @@ When step-00 detects that the description matches an existing application:
 | ---- | --------------------------------- | ------ | ---------------------------------------------------- |
 | 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 + multi-app detection |
-| 01b  | `steps/step-01b-applications.md`  | Opus   | *(multi-app only)* Application decomposition, contexts, prefixes, inter-app dependencies |
+| 01b  | `steps/step-01b-applications.md`  | Opus   | Application identity: confirm code, route, icon, seedData (lightweight single-app, full decomposition multi-app) |
 | 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 |
-| 03c  | `steps/step-03c-compile.md`       | Opus   | Per-module: actors, UCs, FRs, permissions, navigation, seedDataCore (7 arrays), i18n |
+| 03c  | `steps/step-03c-compile.md`       | Opus   | Per-module: actors, UCs, FRs, permissions, navigation, seedDataCore (9 arrays), i18n |
 | 03d  | `steps/step-03d-validate.md`      | Sonnet | Per-module: validation, write, incremental HTML, loop decision |
 | 04a  | `steps/step-04a-collect.md`       | Opus   | Collect module summaries & cross-module interactions |
 | 04b  | `steps/step-04b-analyze.md`       | Opus   | Analyze permission coherence, semantic validation, E2E flows |

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

@@ -98,6 +98,15 @@ Level 1: Context (business)
             Level 4: Section (approve)           ← sidebar nav (workflow)
 ```
 
+**CRITICAL — Application identification (Level 2):**
+The application is formally identified in step-01b (ALWAYS, even for single-app mode):
+- Code: PascalCase (e.g., "HumanResources")
+- Route: kebab-case (e.g., "/business/human-resources")
+- Icon: Lucide icon name
+- Sort order: position in navigation
+This creates the `seedDataCore.navigationApplications` entry that links modules to their parent application.
+The `seedDataCore.applicationRoles` entries are also built from `cadrage.applicationRoles`.
+
 | BA Phase | Levels treated | What is defined |
 |----------|---------------|-----------------|
 | Cadrage (step-01) | Context + Application | Problem, stakeholders, scope, application-level roles |

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

@@ -54,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",

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

@@ -129,10 +129,116 @@ 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.
 
+## Step 3b: Early Multi-Application Detection from Prompt (NEW)
+
+> **Detect multi-app structure BEFORE asking for a single application name.**
+> When the user's prompt explicitly describes multiple applications, we must recognize this immediately
+> and set `workflow.mode = "project"` to avoid doing cadrage for a single app.
+
+**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,
+];
+
+const isMultiApp = multiAppPatterns.some(p => p.test(feature_description));
+```
+
+**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:
+
+```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
+```
+
+3. Display detection result and confirm:
+
+```
+{language == "fr"
+  ? "### Détection multi-application\n\nJ'ai détecté **{candidates.length} applications** dans votre description :"
+  : "### Multi-application detection\n\nI detected **{candidates.length} applications** in your description:"}
+
+| # | Application | Modules identifiés |
+|---|-------------|-------------------|
+{for each candidate: index | name | modules.join(", ")}
+
+{sharedModules.length > 0
+  ? "⚠️ **Modules partagés détectés :** {sharedModules.join(', ')} — ces modules apparaissent dans plusieurs applications. Ils pourraient constituer une application transversale dédiée."
+  : ""}
+```
+
+Ask via AskUserQuestion:
+```
+question: "{language == 'fr' ? 'Confirmez-vous cette structure multi-application ?' : 'Do you confirm this multi-application structure?'}"
+header: "Architecture"
+options:
+  - label: "{language == 'fr' ? 'Oui, {candidates.length} applications' : 'Yes, {candidates.length} applications'}"
+    description: "{language == 'fr' ? 'Créer un projet avec les applications identifiées' : 'Create a project with the identified applications'}"
+  - label: "{language == 'fr' ? 'Extraire les modules partagés' : 'Extract shared modules'}" (only if sharedModules.length > 0)
+    description: "{language == 'fr' ? 'Créer une application dédiée pour {sharedModules.join(', ')} ({candidates.length + 1} applications au total)' : 'Create a dedicated app for {sharedModules.join(', ')} ({candidates.length + 1} total)'}"
+  - label: "{language == 'fr' ? 'Application unique' : 'Single application'}"
+    description: "{language == 'fr' ? 'Tout regrouper en une seule application avec plusieurs modules' : 'Group everything into one application with multiple modules'}"
+```
+
+**IF "Oui, N applications" or "Extraire les modules partagés":**
+
+```yaml
+workflow_mode: "project"
+project_name: derived from feature_description
+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
+→ Continue to step 5 (language selection)
+
+**IF "Application unique":**
+
+```yaml
+workflow_mode: "application"
+```
+
+→ Continue to step 4 normally
+
+**IF no multi-app patterns detected:**
+→ Continue to step 4 normally
+
 ## Step 4: Determine Application Name
 
+> **This step is SKIPPED if `workflow_mode = "project"` (multi-app detected in step 3b).**
+
 ```
-IF workflow_type = "update":
+IF workflow_mode = "project":
+  application_name = project_name  // Project-level name, not a single app name
+  context = "business"  // Default, each app can have its own context
+  → Skip to step 5
+
+ELSE IF workflow_type = "update":
   application_name = existing app name (from step 3)
 ELSE:
   Analyze {feature_description} to extract application name
@@ -149,12 +255,13 @@ ELSE:
 **Validate business context:**
 ```
 validate_business_context("business")
-→ BA restricted to 'business' context only
+→ BA restricted to 'business' context only (in standalone mode)
+→ In project mode, each application can target any context
 ```
 
 **Store:**
 ```yaml
-application_name: string
+application_name: string  # or project_name if project mode
 context: "business"
 ```
 
@@ -216,15 +323,22 @@ feature_id: string
 ## Step 7: Create Output Directory Structure
 
 ```
-IF workflow_type = "new":
+IF workflow_mode = "project":
+  // Project mode: create project-level directory + per-app directories later (in step-01b)
+  mkdir -p docs/business-analyse/v1.0
+  docs_dir = "docs/business-analyse/v{version}"
+
+ELSE IF workflow_type = "new":
   mkdir -p docs/business/{application_name}/business-analyse/v1.0
+  docs_dir = "docs/business/{app}/business-analyse/v{version}"
+
 ELSE:
   Directory already exists from ba-writer.createVersion()
 ```
 
 **Store:**
 ```yaml
-docs_dir: "docs/business/{app}/business-analyse/v{version}"
+docs_dir: string
 ```
 
 ## Step 8: Deploy JSON Schemas to Project (MANDATORY)
@@ -277,34 +391,67 @@ See [references/cache-warming-strategy.md](../references/cache-warming-strategy.
 Create the master feature document using ba-writer agent.
 
 ```
-ba-writer.createApplicationFeature({
-  id: {feature_id},
-  version: {version},
-  scope: "application",
-  status: "draft",
-  metadata: {
-    application: {application_name},
-    context: "business",
-    language: {language},
-    featureDescription: {feature_description},
-    workflowType: {workflow_type},
-    analysisMode: "interactive",
-    mcpAvailable: true,
-    workflow: {
-      mode: "application",
-      moduleOrder: [],
-      currentModuleIndex: 0,
-      completedModules: [],
-      currentModule: null
+IF workflow_mode = "project":
+  // PROJECT MODE: Create project-level feature.json
+  ba-writer.createProjectFeature({
+    id: generate_project_id(),  // PROJ-NNN
+    version: {version},
+    scope: "project",
+    status: "draft",
+    metadata: {
+      projectName: {project_name},
+      language: {language},
+      featureDescription: {feature_description},
+      workflowType: {workflow_type},
+      analysisMode: "interactive",
+      mcpAvailable: true,
+      candidateApplications: {candidate_applications},  // From step 3b detection
+      sharedModulesExtracted: {shared_modules_extracted},
+      workflow: {
+        mode: "project",
+        applicationOrder: [],
+        currentApplicationIndex: 0,
+        completedApplications: []
+      }
     }
-  }
-})
-```
+  })
 
-**Output path:**
-`docs/business/{app}/business-analyse/v{version}/feature.json`
+  Output path: docs/business-analyse/v{version}/feature.json
 
-> **Note:** Always create the master feature.json first. Step-02 (decomposition) determines if it's single or multi-module.
+  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({
+    id: {feature_id},
+    version: {version},
+    scope: "application",
+    status: "draft",
+    metadata: {
+      application: {application_name},
+      context: "business",
+      language: {language},
+      featureDescription: {feature_description},
+      workflowType: {workflow_type},
+      analysisMode: "interactive",
+      mcpAvailable: true,
+      workflow: {
+        mode: "application",
+        moduleOrder: [],
+        currentModuleIndex: 0,
+        completedModules: [],
+        currentModule: null
+      }
+    }
+  })
+
+  Output path: docs/business/{app}/business-analyse/v{version}/feature.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.
 
 ## Step 10: Update Config
 
@@ -335,13 +482,18 @@ Update `.business-analyse/config.json` with new feature information.
 |--------------------|----------------------------------------------|
 | Feature ID         | {feature_id}                                 |
 | Workflow           | {workflow_type}                               |
-| Application        | business/{application_name}                  |
+| Mode               | {workflow_mode === "project" ? "Multi-application project" : "Single application"} |
+| Application/Project| {workflow_mode === "project" ? project_name + " (" + candidate_applications.length + " apps)" : "business/" + application_name} |
 | Output Path        | {docs_dir}/feature.json                      |
 | Language           | {language}                                   |
 | Version            | {version}                                    |
 | MCP Available      | true                                         |
 | Analysis Mode      | Interactive (always)                         |
 
+{workflow_mode === "project"
+  ? "Candidate applications: " + candidate_applications.map(a => a.name).join(", ")
+  : ""}
+
 NEXT STEP: step-01-cadrage
 ═══════════════════════════════════════════════════════════════
 ```
@@ -352,14 +504,18 @@ After showing initialization summary, proceed to `./step-01-cadrage.md`
 
 **Pass context variables:**
 ```yaml
-feature_id: string
+feature_id: string               # FEAT-NNN (single-app) or PROJ-NNN (project)
 feature_description: string
 workflow_type: "new" | "update"
-application_name: string
+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)
+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
 language: string
 docs_dir: string
 mcp_available: boolean
-workflow_mode: "application"
 analysisMode: "interactive"
 version: string
 ```

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

@@ -41,14 +41,31 @@ Phase 5: PERIMETRE         → Bound scope with roles, coverage matrix (sections
 
 ---
 
+## PROJECT vs APPLICATION MODE
+
+> **When `workflow_mode = "project"` (detected in step-00 from prompt structure):**
+> The cadrage operates at the **PROJECT level**, not at a single application level.
+> - Phase 1-3: Gather requirements for the ENTIRE project (all applications combined)
+> - Phase 4: ANTICIPATION analyzes cross-application shared modules and suggests extracting them as dedicated applications
+> - Phase 5: Coverage matrix maps requirements to APPLICATIONS first, then modules within each application
+> - `candidate_applications` from step-00 are used as starting structure (can be modified during cadrage)
+>
+> **When `workflow_mode = "application"` (single-app):**
+> The cadrage operates at the application level as before.
+
 ## PHASE 1: ECOUTE (Listen)
 
 ### 1. Read Current State
 
 ```
-ba-reader.findFeature({feature_id})
-→ Read metadata: application, language, workflow.mode, useCase
-→ Read cadrage section (if resuming)
+IF workflow_mode === "project":
+  ba-reader.findProjectFeature({project_id})
+  → Read metadata: projectName, language, candidateApplications
+  → Read cadrage section (if resuming)
+ELSE:
+  ba-reader.findFeature({feature_id})
+  → Read metadata: application, language, workflow.mode, useCase
+  → Read cadrage section (if resuming)
 ```
 
 IF cadrage already completed (status = "framed"):
@@ -507,6 +524,91 @@ options:
 
 6. Accepted suggestions enrich `coverageMatrix` and `globalScope`.
 
+### 5b. Cross-Application Shared Module Detection (PROJECT MODE ONLY)
+
+> **When `workflow_mode = "project"`, analyze candidate applications for shared modules.**
+> A module that appears in 2+ applications should be extracted as a dedicated transversal application.
+
+**This section is SKIPPED if `workflow_mode !== "project"`.**
+
+**Process:**
+
+1. Build module inventory per candidate application:
+
+```javascript
+// From candidateApplications (step-00) + enriched by cadrage phases 1-4
+const modulesByApp = {};
+for (const app of candidate_applications) {
+  modulesByApp[app.name] = app.modules;  // e.g., { "RH": ["Employes", "Conges", "Temps"], "Projet": ["Projets", "Temps"] }
+}
+```
+
+2. Detect modules appearing in 2+ applications:
+
+```javascript
+const allModules = Object.values(modulesByApp).flat();
+const moduleCounts = {};
+for (const mod of allModules) {
+  const normalized = normalizeModuleName(mod);  // "Temps", "Saisie du temps", "Time Tracking" → same concept
+  moduleCounts[normalized] = (moduleCounts[normalized] || 0) + 1;
+}
+const sharedModules = Object.entries(moduleCounts)
+  .filter(([_, count]) => count >= 2)
+  .map(([name, count]) => ({ name, appearsIn: count, applications: findAppsContaining(name) }));
+```
+
+3. IF shared modules found, propose extraction:
+
+```
+{language == "fr"
+  ? "### Modules partagés détectés\n\nCertains modules apparaissent dans plusieurs applications. Les extraire en application(s) dédiée(s) améliore la réutilisabilité et évite la duplication :"
+  : "### Shared modules detected\n\nSome modules appear in multiple applications. Extracting them as dedicated application(s) improves reusability and avoids duplication:"}
+
+| Module | Présent dans | Suggestion |
+|--------|-------------|-----------|
+{for each shared: name | apps.join(", ") | "Extraire en application '{name}'" }
+
+{language == "fr"
+  ? "**Exemple :** Si 'Gestion du temps' est dans RH et Projet, créer une application 'Temps' dédiée que les deux autres consomment."
+  : "**Example:** If 'Time Management' is in HR and Project, create a dedicated 'Time' application that the other two consume."}
+```
+
+Ask via AskUserQuestion:
+```
+question: "{language == 'fr' ? 'Souhaitez-vous extraire les modules partagés en application(s) dédiée(s) ?' : 'Do you want to extract shared modules as dedicated application(s)?'}"
+header: "Extraction"
+options:
+  - label: "{language == 'fr' ? 'Oui, extraire' : 'Yes, extract'}"
+    description: "{language == 'fr' ? 'Créer {sharedModules.length} application(s) transversale(s) supplémentaire(s)' : 'Create {sharedModules.length} additional cross-cutting application(s)'}"
+  - label: "{language == 'fr' ? 'Non, garder en l\'état' : 'No, keep as-is'}"
+    description: "{language == 'fr' ? 'Chaque application garde sa propre version du module' : 'Each application keeps its own version of the module'}"
+```
+
+**IF "Oui, extraire":**
+```javascript
+for (const shared of sharedModules) {
+  // Create new candidate application
+  candidate_applications.push({
+    name: shared.name,
+    description: `Application transversale pour ${shared.name}`,
+    modules: [shared.name],
+    context: "business",
+    isTransversal: true,
+    consumedBy: shared.applications
+  });
+
+  // Remove the shared module from original applications
+  for (const appName of shared.applications) {
+    const app = candidate_applications.find(a => a.name === appName);
+    app.modules = app.modules.filter(m => normalizeModuleName(m) !== shared.name);
+    app.dependencies = app.dependencies || [];
+    app.dependencies.push({ target: shared.name, type: "data-dependency" });
+  }
+}
+```
+
+Update `candidate_applications` in the project feature.json.
+
 ---
 
 ## PHASE 5: PERIMETRE (Bound Scope)
@@ -720,9 +822,25 @@ ba-writer.enrichSection({
 ba-writer.updateStatus({feature_id}, "framed")
 ```
 
-### 9. Multi-Application Detection (NEW)
+### 9. Multi-Application Detection
 
 > **Analyze whether the project spans multiple independent applications.**
+> **SKIP this section entirely if `workflow_mode = "project"`** — multi-app was already detected in step-00
+> and cross-app analysis was done in section 5b above.
+
+**IF `workflow_mode === "project"`:**
+→ SKIP section 9 entirely. Candidate applications are already identified and enriched.
+→ Write cadrage data to project-level feature.json:
+```
+ba-writer.enrichSection({
+  projectId: {project_id},
+  section: "cadrage",
+  data: {cadrage data collected in phases 1-5 above}
+})
+```
+→ Continue to section 10 (summary).
+
+**IF `workflow_mode === "application"` (single-app mode):**
 
 After coverage matrix is validated, check if the identified functional domains suggest multiple applications:
 
@@ -763,15 +881,15 @@ ba-writer.createProjectFeature({
   metadata: {
     projectName: {project_name derived from feature_description},
     language: {language},
-    featureDescription: {feature_description}
+    featureDescription: {feature_description},
+    candidateApplications: [{detected candidates}]
   },
   cadrage: {cadrage data already collected in this step}
 })
 ```
-2. Set `workflow.mode = "project"` in project feature.json
+2. Set `workflow_mode = "project"` and `project_id = PROJ-NNN`
 3. Load `questionnaire/00b-project.md` for additional project-level questions
-4. Load `steps/step-01b-applications.md` for application decomposition
-5. **STOP — DO NOT load step-02**
+4. Continue to section 10 and then step-01b
 
 **IF "Single application":**
 → Continue to step 10 (display summary) and step-02 as usual.
@@ -807,5 +925,6 @@ ba-writer.createProjectFeature({
 
 ## NEXT STEP
 
-**IF workflow.mode === "project":** Load: `./step-01b-applications.md`
-**ELSE:** Load: `./step-02-decomposition.md`
+Load: `./step-01b-applications.md`
+
+> step-01b handles both single-app (lightweight identity confirmation) and multi-app (full application decomposition).