@atlashub/smartstack-cli 3.32.0 → 3.34.0

package/templates/skills/business-analyse/steps/step-05a-handoff.md

@@ -32,8 +32,20 @@ Build the development handoff data: verify consolidation, choose implementation
 Use ba-reader to locate the feature and verify consolidation status:
 
 ```
-ba-reader.findFeature({feature_id})
-→ Check status = "consolidated"
+// Determine feature source based on workflow mode
+IF workflow.mode === "project":
+  projectFeature = ba-reader.findProjectFeature()
+  // Verify ALL applications are specified
+  FOR each app in projectFeature.applications:
+    appFeature = ba-reader.findFeature(app.featureJsonPath)
+    IF appFeature.status !== "consolidated":
+      BLOCKING ERROR: "Application {app.code} not consolidated (status: {appFeature.status})"
+      → Return to step-04a-collect.md
+  // Use project-level feature for overall consolidation
+  feature = projectFeature
+ELSE:
+  ba-reader.findFeature({feature_id})
+  → Check status = "consolidated"
 ```
 
 **IF** status ≠ "consolidated" → **STOP**. Return to step-04a-collect.md.
@@ -42,18 +54,22 @@ Display validation summary:
 
 ```
 ✓ Consolidation: APPROVED
+✓ Applications: {app_count} (project mode only)
 ✓ Modules: {count} specified and validated
 ✓ Cross-module: interactions mapped
+✓ Cross-application: interactions mapped (project mode only)
 ✓ Permissions: coherent
 → Proceeding to handoff...
 ```
 
 Include:
-- Number of modules
+- Number of applications (project mode only)
+- Number of modules across all applications
 - Number of entities across all modules
 - Number of use cases across all modules
 - Number of business rules across all modules
 - Cross-module interaction count
+- Cross-application interaction count (project mode only)
 
 ---
 
@@ -101,9 +117,9 @@ See [references/cache-warming-strategy.md](../references/cache-warming-strategy.
 
 ---
 
-### 2. Implementation Strategy Choice (Multi-Module)
+### 2. Implementation Strategy Choice (Multi-Module/Multi-App)
 
-**IF** more than 1 module defined in feature.json:
+**IF** more than 1 module defined in feature.json (or project mode with multiple applications):
 
 Ask via AskUserQuestion:
 
@@ -117,8 +133,12 @@ options:
     description: "Implémenter toutes les entités, puis tous les services, puis tous les contrôleurs, etc. Plus de parallélisation possible mais plus complexe."
   - label: "Hybride"
     description: "Modules fondation en premier (couche par couche), puis modules dépendants (module par module)"
+  - label: "Application par application (Recommandé multi-app)"
+    description: "Implémenter chaque application complètement avant de passer à la suivante. Suit l'ordre topologique inter-applications."
 ```
 
+> **Note:** "Application par application" only appears for project mode with 2+ applications.
+
 Store the chosen strategy in `handoff.implementationStrategy`.
 
 **IF** only 1 module → default to "Module par module" (no choice needed).
@@ -335,6 +355,31 @@ Generate `.ralph/prd-CrossModule.json` with:
 
 Add to progress.txt after all module tasks.
 
+### 6d. Cross-Application PRD (Project Mode Only)
+
+> **Only generated when `workflow.mode === "project"`.**
+> Contains cross-application integration tests and shared entity validation.
+
+```json
+{
+  "$version": "3.0.0",
+  "implementation": {
+    "filesToCreate": {
+      "tests": [
+        { "path": "src/Tests/Integration/CrossApplication/SharedEntityValidationTests.cs", "type": "IntegrationTests", "module": "CrossApplication" },
+        { "path": "src/Tests/Integration/CrossApplication/CrossAppPermissionTests.cs", "type": "SecurityTests", "module": "CrossApplication" },
+        { "path": "src/Tests/Integration/CrossApplication/CrossAppE2EFlowTests.cs", "type": "E2ETests", "module": "CrossApplication" }
+      ]
+    }
+  }
+}
+```
+
+Write to: `.ralph/prd-CrossApplication.json`
+
+> This PRD is generated IN ADDITION to the per-module cross-module PRD.
+> It validates interactions between applications, not just between modules within the same application.
+
 ---
 
 ### 7. Write Handoff to Feature.json
@@ -434,53 +479,119 @@ const lang = master.metadata.language || "fr";
 
 const seedDataCore = {
   // Application-level navigation (MANDATORY — one entry per application)
-  navigationApplications: [{
-    code: appCode.toLowerCase(),
-    name: appCode,
-    labels: {
-      fr: lang === "fr" ? (master.cadrage?.applicationName || appLabel) : appLabel,
-      en: lang === "en" ? (master.cadrage?.applicationName || appLabel) : appLabel,
-      it: appLabel,
-      de: appLabel
-    },
-    description: {
-      fr: lang === "fr" ? appDesc : `Gestion ${appLabel}`,
-      en: lang === "en" ? appDesc : `${appLabel} management`,
-      it: `Gestione ${appLabel}`,
-      de: `${appLabel} Verwaltung`
-    },
-    icon: inferIconFromApplication(master) || "layout-grid",
-    iconType: "lucide",
-    context: contextCode,
-    route: `/${contextCode}/${toKebabCase(appCode)}`,
-    displayOrder: 1
-  }],
-
-  navigationModules: master.modules.map((m, i) => ({
-    code: m.code,
-    label: m.name || m.code,
-    description: m.description,
-    icon: inferIconFromModule(m) || "folder",  // MUST be non-null — use sensible default
-    iconType: "lucide",
-    route: `/${contextCode}/${toKebabCase(appCode)}/${toKebabCase(m.code)}`,
-    displayOrder: (i + 1) * 10
-  })),
-
-  navigationSections: master.modules.flatMap(m =>
-    (m.anticipatedSections || []).map((s, j) => ({
-      moduleCode: m.code,
-      code: s.code,
-      label: s.description?.split(':')[0] || s.code,
-      description: s.description || "",
-      route: s.code === "list"
-        ? `/${contextCode}/${toKebabCase(appCode)}/${toKebabCase(m.code)}`
-        : s.code === "detail"
-          ? `/${contextCode}/${toKebabCase(appCode)}/${toKebabCase(m.code)}/:id`
-          : `/${contextCode}/${toKebabCase(appCode)}/${toKebabCase(m.code)}/${toKebabCase(s.code)}`,
-      displayOrder: (j + 1) * 10,
-      navigation: s.code === "detail" ? "hidden" : "visible"
-    }))
-  ),
+  // PROJECT MODE: Generate one entry per application from project feature.json
+  // SINGLE-APP MODE: Generate one entry from master feature.json
+  navigationApplications: (() => {
+    if (workflow.mode === "project") {
+      // Multi-app: one navigation entry per application
+      return projectFeature.applications.map((app, idx) => {
+        const appLabel = toHumanReadable(app.code);
+        const appContext = app.context || "business";
+        return {
+          code: app.code.toLowerCase(),
+          name: app.code,
+          labels: {
+            fr: lang === "fr" ? (app.name || appLabel) : appLabel,
+            en: lang === "en" ? (app.name || appLabel) : appLabel,
+            it: appLabel,
+            de: appLabel
+          },
+          description: {
+            fr: lang === "fr" ? (app.description || `Gestion ${appLabel}`) : `Gestion ${appLabel}`,
+            en: lang === "en" ? (app.description || `${appLabel} management`) : `${appLabel} management`,
+            it: `Gestione ${appLabel}`,
+            de: `${appLabel} Verwaltung`
+          },
+          icon: app.icon || inferIconFromApplication({ metadata: { application: app.code } }) || "layout-grid",
+          iconType: "lucide",
+          context: appContext,
+          route: `/${appContext}/${toKebabCase(app.code)}`,
+          displayOrder: (idx + 1) * 10
+        };
+      });
+    } else {
+      // Single-app: one navigation entry
+      return [{
+        code: appCode.toLowerCase(),
+        name: appCode,
+        labels: {
+          fr: lang === "fr" ? (master.cadrage?.applicationName || appLabel) : appLabel,
+          en: lang === "en" ? (master.cadrage?.applicationName || appLabel) : appLabel,
+          it: appLabel,
+          de: appLabel
+        },
+        description: {
+          fr: lang === "fr" ? appDesc : `Gestion ${appLabel}`,
+          en: lang === "en" ? appDesc : `${appLabel} management`,
+          it: `Gestione ${appLabel}`,
+          de: `${appLabel} Verwaltung`
+        },
+        icon: inferIconFromApplication(master) || "layout-grid",
+        iconType: "lucide",
+        context: contextCode,
+        route: `/${contextCode}/${toKebabCase(appCode)}`,
+        displayOrder: 1
+      }];
+    }
+  })(),
+
+  // PROJECT MODE: Flatten modules from ALL applications
+  // SINGLE-APP MODE: Use master.modules directly
+  navigationModules: (() => {
+    if (workflow.mode === "project") {
+      let order = 0;
+      return projectFeature.applications.flatMap(app => {
+        const appContext = app.context || "business";
+        return (app.modules || []).map(m => ({
+          code: m.code,
+          applicationCode: app.code,
+          label: m.name || m.code,
+          description: m.description,
+          icon: inferIconFromModule(m) || "folder",
+          iconType: "lucide",
+          route: `/${appContext}/${toKebabCase(app.code)}/${toKebabCase(m.code)}`,
+          displayOrder: (++order) * 10
+        }));
+      });
+    } else {
+      return master.modules.map((m, i) => ({
+        code: m.code,
+        label: m.name || m.code,
+        description: m.description,
+        icon: inferIconFromModule(m) || "folder",
+        iconType: "lucide",
+        route: `/${contextCode}/${toKebabCase(appCode)}/${toKebabCase(m.code)}`,
+        displayOrder: (i + 1) * 10
+      }));
+    }
+  })(),
+
+  navigationSections: (() => {
+    const buildSections = (modules, appContextCode, appCode) =>
+      modules.flatMap(m =>
+        (m.anticipatedSections || []).map((s, j) => ({
+          moduleCode: m.code,
+          code: s.code,
+          label: s.description?.split(':')[0] || s.code,
+          description: s.description || "",
+          route: s.code === "list"
+            ? `/${appContextCode}/${toKebabCase(appCode)}/${toKebabCase(m.code)}`
+            : s.code === "detail"
+              ? `/${appContextCode}/${toKebabCase(appCode)}/${toKebabCase(m.code)}/:id`
+              : `/${appContextCode}/${toKebabCase(appCode)}/${toKebabCase(m.code)}/${toKebabCase(s.code)}`,
+          displayOrder: (j + 1) * 10,
+          navigation: s.code === "detail" ? "hidden" : "visible"
+        }))
+      );
+
+    if (workflow.mode === "project") {
+      return projectFeature.applications.flatMap(app =>
+        buildSections(app.modules || [], app.context || "business", app.code)
+      );
+    } else {
+      return buildSections(master.modules, contextCode, appCode);
+    }
+  })(),
 
   navigationResources: master.cadrage.coverageMatrix
     .filter(cm => cm.module && cm.anticipatedResources?.length > 0)
@@ -504,37 +615,73 @@ const seedDataCore = {
     }));
   }),
 
-  permissions: master.modules.flatMap(m => {
-    const basePath = `business.${master.metadata.application.toLowerCase()}.${m.code.toLowerCase()}`;
-    const actions = ['read', 'create', 'update', 'delete'];
-    return [
-      { path: `${basePath}.*`, action: '*', description: `Full ${m.name || m.code} access` },
-      ...actions.map(action => ({
-        path: `${basePath}.${action}`,
-        action: action,
-        description: `${action.charAt(0).toUpperCase() + action.slice(1)} ${m.name || m.code}`
-      }))
-    ];
-  }),
-
-  rolePermissions: master.cadrage.applicationRoles.map(role => ({
-    role: role.role,
-    level: role.level,
-    permissions: master.modules.map(m => `business.${master.metadata.application.toLowerCase()}.${m.code.toLowerCase()}.${
-      role.level === 'admin' ? '*' :
-      role.level === 'manager' ? 'read,create,update' :
-      role.level === 'contributor' ? 'read,create' : 'read'
-    }`)
-  })),
-
-  permissionConstants: master.modules.flatMap(m =>
-    ['Read', 'Create', 'Update', 'Delete', 'Validate', 'Export'].map(action => ({
-      module: m.code,
-      action: action,
-      constant: `${master.metadata.application}${m.code}${action}`,
-      path: `business.${master.metadata.application.toLowerCase()}.${m.code.toLowerCase()}.${action.toLowerCase()}`
-    }))
-  )
+  // PROJECT MODE: permissions scoped per application context
+  // SINGLE-APP MODE: all permissions under business.{app}
+  permissions: (() => {
+    const buildPermissions = (modules, appContext, appCode) =>
+      modules.flatMap(m => {
+        const basePath = `${appContext}.${toKebabCase(appCode)}.${toKebabCase(m.code)}`;
+        const actions = ['read', 'create', 'update', 'delete'];
+        return [
+          { path: `${basePath}.*`, action: '*', description: `Full ${m.name || m.code} access` },
+          ...actions.map(action => ({
+            path: `${basePath}.${action}`,
+            action: action,
+            description: `${action.charAt(0).toUpperCase() + action.slice(1)} ${m.name || m.code}`
+          }))
+        ];
+      });
+
+    if (workflow.mode === "project") {
+      return projectFeature.applications.flatMap(app =>
+        buildPermissions(app.modules || [], app.context || "business", app.code)
+      );
+    } else {
+      return buildPermissions(master.modules, contextCode, appCode);
+    }
+  })(),
+
+  rolePermissions: (() => {
+    const buildRolePermissions = (roles, modules, appContext, appCode) =>
+      roles.map(role => ({
+        role: role.role,
+        level: role.level,
+        permissions: modules.map(m => `${appContext}.${toKebabCase(appCode)}.${toKebabCase(m.code)}.${
+          role.level === 'admin' ? '*' :
+          role.level === 'manager' ? 'read,create,update' :
+          role.level === 'contributor' ? 'read,create' : 'read'
+        }`)
+      }));
+
+    if (workflow.mode === "project") {
+      return projectFeature.applications.flatMap(app =>
+        buildRolePermissions(app.applicationRoles || [], app.modules || [], app.context || "business", app.code)
+      );
+    } else {
+      return buildRolePermissions(master.cadrage.applicationRoles, master.modules, contextCode, appCode);
+    }
+  })(),
+
+  permissionConstants: (() => {
+    const buildConstants = (modules, appCode) =>
+      modules.flatMap(m =>
+        ['Read', 'Create', 'Update', 'Delete', 'Validate', 'Export'].map(action => ({
+          module: m.code,
+          application: appCode,
+          action: action,
+          constant: `${appCode}${m.code}${action}`,
+          path: `${contextCode}.${toKebabCase(appCode)}.${toKebabCase(m.code)}.${action.toLowerCase()}`
+        }))
+      );
+
+    if (workflow.mode === "project") {
+      return projectFeature.applications.flatMap(app =>
+        buildConstants(app.modules || [], app.code)
+      );
+    } else {
+      return buildConstants(master.modules, appCode);
+    }
+  })()
 };
 
 // Icon inference for APPLICATION level (NEVER leave as null)
@@ -609,26 +756,72 @@ IF seedDataCore.navigationSections.length === 0:
 #### 7c. Master Handoff (after ALL modules written + seedDataCore generated)
 
 ```
-ba-writer.enrichSection({
-  featureId: {feature_id},
-  section: "handoff",
-  data: {
-    status: "handed-off",
-    complexity: "{simple|medium|complex}",
-    implementationStrategy: "{strategy}",
-    moduleCount: {count},
-    moduleOrder: [...],
-    totalFilesToCreate: {sum across all modules},
-    totalTasks: {sum across all modules},
-    prdStructure: "per-module | consolidated",
-    prdFiles: [
-      { module: "{module1}", path: ".ralph/prd-{module1}.json" },
-      { module: "{module2}", path: ".ralph/prd-{module2}.json" }
-    ],
-    progressTrackerPath: ".ralph/progress.txt",
-    handedOffAt: "{ISO timestamp}"
-  }
-})
+// Write handoff to application-level feature.json (single-app mode)
+// OR to each application feature.json + project feature.json (project mode)
+
+IF workflow.mode === "project":
+  // Write handoff to EACH application feature.json
+  FOR each app in projectFeature.applications:
+    ba-writer.enrichSection({
+      featureId: app.featureJsonPath,
+      section: "handoff",
+      data: {
+        status: "handed-off",
+        complexity: "{app-level complexity}",
+        implementationStrategy: "{strategy}",
+        moduleCount: app.modules.length,
+        moduleOrder: app.modules.map(m => m.code),
+        totalFilesToCreate: {sum across app modules},
+        totalTasks: {sum across app modules},
+        prdFiles: app.modules.map(m => ({ module: m.code, path: `.ralph/prd-${m.code}.json` })),
+        handedOffAt: "{ISO timestamp}"
+      }
+    })
+
+  // Write project-level handoff summary
+  ba-writer.enrichSection({
+    featureId: {project_id},
+    section: "handoff",
+    data: {
+      status: "handed-off",
+      complexity: "{global complexity}",
+      implementationStrategy: "{strategy}",
+      applicationCount: projectFeature.applications.length,
+      applicationOrder: projectFeature.applicationDependencyGraph.topologicalOrder,
+      totalModuleCount: {sum of all app module counts},
+      totalFilesToCreate: {sum across ALL applications and modules},
+      totalTasks: {sum across ALL applications and modules},
+      prdStructure: "per-module",
+      prdFiles: [
+        ...allModulePrdFiles,
+        { module: "CrossModule", path: ".ralph/prd-CrossModule.json" },
+        { module: "CrossApplication", path: ".ralph/prd-CrossApplication.json" }
+      ],
+      progressTrackerPath: ".ralph/progress.txt",
+      handedOffAt: "{ISO timestamp}"
+    }
+  })
+ELSE:
+  ba-writer.enrichSection({
+    featureId: {feature_id},
+    section: "handoff",
+    data: {
+      status: "handed-off",
+      complexity: "{simple|medium|complex}",
+      implementationStrategy: "{strategy}",
+      moduleCount: {count},
+      moduleOrder: [...],
+      totalFilesToCreate: {sum across all modules},
+      totalTasks: {sum across all modules},
+      prdStructure: "per-module | consolidated",
+      prdFiles: [
+        { module: "{module1}", path: ".ralph/prd-{module1}.json" },
+        { module: "{module2}", path: ".ralph/prd-{module2}.json" }
+      ],
+      progressTrackerPath: ".ralph/progress.txt",
+      handedOffAt: "{ISO timestamp}"
+    }
+  })
 ```
 
 #### 7d. Final Verification (BLOCKING)

package/templates/skills/business-analyse/steps/step-05b-deploy.md

@@ -176,21 +176,38 @@ IF ANY category shows FAIL → **STOP AND RE-RUN `ss derive-prd`**. DO NOT proce
 **Update logic:**
 
 1. Read existing manifest at `docs/business/index.json` (or create empty `{ "version": "1.0", "updatedAt": "", "analyses": [] }`)
-2. For the APPLICATION-level feature.json:
-   - Find existing entry where `appCode == {app_code}` AND `moduleCode == null` AND `version == {version}`
-   - If found: update `status`, `updatedAt`, `featureDescription`
-   - If not found: append new entry with `moduleCode: null` and `path: "{app_code}/business-analyse/v{version}/feature.json"`
-3. For EACH MODULE-level feature.json:
-   - Find existing entry where `appCode == {app_code}` AND `moduleCode == {module_code}` AND `version == {version}`
-   - If found: update `status`, `updatedAt`, `featureDescription`
-   - If not found: append new entry with `moduleCode: "{module_code}"` and `path: "{app_code}/{module_code}/business-analyse/v{version}/feature.json"`
+
+2. **PROJECT MODE (`workflow.mode === "project"`):**
+   a. Add/update PROJECT-level entry:
+      - Find existing entry where `projectId == {project_id}` AND `scope == "project"`
+      - If found: update `status`, `updatedAt`
+      - If not found: append new entry with `scope: "project"`, `projectId: "{project_id}"`, `path: "business-analyse/v{version}/feature.json"`
+   b. For EACH APPLICATION:
+      - Find existing entry where `appCode == {app_code}` AND `moduleCode == null` AND `version == {version}`
+      - If found: update `status`, `updatedAt`, `featureDescription`
+      - If not found: append new entry with `moduleCode: null`, `context: "{app.context}"`, and `path: "{context}/{app_code}/business-analyse/v{version}/feature.json"`
+   c. For EACH MODULE within each application:
+      - Find existing entry where `appCode == {app_code}` AND `moduleCode == {module_code}` AND `version == {version}`
+      - If found: update `status`, `updatedAt`, `featureDescription`
+      - If not found: append new entry with `path: "{context}/{app_code}/{module_code}/business-analyse/v{version}/feature.json"`
+
+3. **SINGLE-APP MODE (default):**
+   a. For the APPLICATION-level feature.json:
+      - Find existing entry where `appCode == {app_code}` AND `moduleCode == null` AND `version == {version}`
+      - If found: update `status`, `updatedAt`, `featureDescription`
+      - If not found: append new entry with `moduleCode: null` and `path: "{app_code}/business-analyse/v{version}/feature.json"`
+   b. For EACH MODULE-level feature.json:
+      - Find existing entry where `appCode == {app_code}` AND `moduleCode == {module_code}` AND `version == {version}`
+      - If found: update `status`, `updatedAt`, `featureDescription`
+      - If not found: append new entry with `moduleCode: "{module_code}"` and `path: "{app_code}/{module_code}/business-analyse/v{version}/feature.json"`
+
 4. Update root `updatedAt` to current timestamp
 5. Write manifest back to `docs/business/index.json`
 
 **Display confirmation:**
 ```
 ✓ BA manifest updated: docs/business/index.json
-  Entries: {total_count} ({app_count} applications, {module_count} modules)
+  Entries: {total_count} ({project_count} projects, {app_count} applications, {module_count} modules)
   Web viewer: /system/docs/ba
 ```
 
@@ -205,20 +222,28 @@ IF ANY category shows FAIL → **STOP AND RE-RUN `ss derive-prd`**. DO NOT proce
 ### 4. Read Source Data for HTML
 
 1. Read the HTML template from skill directory: `html/ba-interactive.html` (relative to `~/.claude/skills/business-analyse/`)
-2. Read the master feature.json (application level)
-3. Read EACH module feature.json (module level)
+2. **SINGLE-APP MODE:** Read the master feature.json (application level)
+3. **PROJECT MODE:** Read the project feature.json + ALL application feature.json files
+4. Read EACH module feature.json (module level, across all applications in project mode)
 
 > **Reference:** Read `references/html-data-mapping.md` for the complete FEATURE_DATA and EMBEDDED_ARTIFACTS mapping specification.
 
 **Key requirements:**
 - FEATURE_DATA must be pre-populated with ALL analysis data (empty data = BUG)
-- FEATURE_DATA.**moduleSpecs** MUST be populated for EACH module (use cases, business rules, entities, permissions) — empty moduleSpecs = BROKEN specification tabs
+- FEATURE_DATA.**moduleSpecs** MUST be populated for EACH module across ALL applications (use cases, business rules, entities, permissions) — empty moduleSpecs = BROKEN specification tabs
 - FEATURE_DATA.**cadrage.scope** must use HTML keys (vital/important/optional/excluded) NOT feature.json keys (mustHave/shouldHave/couldHave/outOfScope)
 - FEATURE_DATA.**metadata.analysisMode** must be set from `master.metadata.analysisMode` (always "interactive")
 - EMBEDDED_ARTIFACTS contains wireframes, E2E diagrams, dependency graph
 - Both objects are serialized as JSON with 2-space indentation
 - All data mapped from master and module feature.json files — follow `html-data-mapping.md` EXACTLY
 
+**PROJECT MODE additions to FEATURE_DATA:**
+- `FEATURE_DATA.project` — project-level metadata (name, applicationCount, applicationOrder)
+- `FEATURE_DATA.applications` — array of application summaries with their modules
+- `FEATURE_DATA.modules` — flattened list of ALL modules across ALL applications (each with `applicationCode` field)
+- `FEATURE_DATA.consolidation.crossApplicationInteractions` — from project feature.json
+- FEATURE_DATA.**metadata.workflowMode** must be `"project"` (enables multi-app tabs in HTML)
+
 ---
 
 ### 5-7. Build FEATURE_DATA, EMBEDDED_ARTIFACTS & Replace Placeholders
@@ -426,9 +451,13 @@ Display completion using the template from `templates/tpl-launch-displays.md`:
 
 ```
 ═══════════════════════════════════════════════════════════════
-  [OK] BUSINESS ANALYSE TERMINEE - {application_name}
+  [OK] BUSINESS ANALYSE TERMINEE - {application_name OR project_name}
 ═══════════════════════════════════════════════════════════════
 
+{IF workflow.mode === "project":}
+Project:   {project_name}
+Apps:      {app_count} ({app_names})
+{ENDIF}
 Modules:   {count} ({names})
 Strategy:  {strategy}
 Files:     {total files across all modules}
@@ -437,8 +466,11 @@ Complexity: {complexity}
 Effort:    {total_days} days ({total_hours} hours)
 
 [DIR] Artefacts générés:
-  ✓ feature.json (master + per-module) - spécification complète
+  ✓ feature.json ({IF project: "project + " ENDIF}master + per-module) - spécification complète
   ✓ .ralph/prd-{module}.json - task breakdown per module
+  {IF workflow.mode === "project":}
+  ✓ .ralph/prd-CrossApplication.json - cross-application integration tests
+  {ENDIF}
   ✓ .ralph/progress.txt - tracker de progression
   ✓ ba-interactive.html - document de revue interactif