@atlashub/smartstack-cli 4.56.0 → 4.57.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlashub/smartstack-cli",
-  "version": "4.56.0",
+  "version": "4.57.0",
   "description": "SmartStack Claude Code automation toolkit - GitFlow, EF Core migrations, prompts and more",
   "author": {
     "name": "SmartStack",

package/templates/project/Dockerfile.frontend.template

@@ -11,14 +11,14 @@ WORKDIR /app
 ARG VITE_API_URL
 ARG VITE_WS_URL
 
-# Copy package files for npm cache
-COPY package.json package-lock.json ./
+# Copy package files for npm cache (context = project root)
+COPY web/{{ProjectNameLower}}-web/package.json web/{{ProjectNameLower}}-web/package-lock.json ./
 
 # Install dependencies (cached layer)
 RUN npm install
 
 # Copy source code
-COPY . .
+COPY web/{{ProjectNameLower}}-web/ .
 
 # Build for production
 RUN npm run build:prod

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

@@ -8,23 +8,24 @@ Feature data is stored as granular JSON files, NOT markdown. Each module has an
 
 ```
 docs/
-  business-analyse/v{X.Y}/
-    index.json           ← Project index (multi-app only)
-    cadrage.json         ← Project-level framing
-  {app}/
-    business-analyse/v{X.Y}/
-      index.json         ← Application index
-      cadrage.json       ← App-level framing
-    {module}/
-      business-analyse/v{X.Y}/
-        index.json       ← Module index
-        entities.json    ← Entities, attributes, relations
-        rules.json       ← Business rules
-        usecases.json    ← Use cases
-        permissions.json ← Permissions matrix
-        screens.json     ← Interface specs (sections, resources, mockups)
-        validation.json  ← Validation results
-        handoff.json     ← File mapping, API specs
+  {projet-slug}/                     ← Project (kebab-case, 100% autonomous)
+    v{X.Y}/
+      index.json                     ← Project master index
+      cadrage.json                   ← Project-level framing
+      consolidation.json             ← Cross-module validation
+      navigation.json                ← Navigation tree
+      validation.json                ← Validation results
+      ba-interactive.html            ← Generated HTML deliverable
+      {app-kebab}/                   ← Application (kebab-case)
+        index.json                   ← Application index
+        {module-kebab}/              ← Module (kebab-case)
+          index.json                 ← Module index
+          entities.json              ← Entities, attributes, relations
+          rules.json                 ← Business rules
+          usecases.json              ← Use cases
+          permissions.json           ← Permissions matrix
+          screens.json               ← Interface specs (sections, resources, mockups)
+          handoff.json               ← File mapping, API specs
 ```
 
 ### Index.json structure
@@ -72,10 +73,12 @@ Steps load only the files they need:
 ### Workflow detection
 
 ```
-1. Check for existing docs/**/index.json → mode = "update"
+1. Check for existing docs/*/v*/index.json → mode = "update"
 2. Otherwise → mode = "new"
 ```
 
+> **Legacy detection:** Also check `docs/business-analyse/v*/index.json` and `docs/*/business-analyse/v*/index.json` for backward compatibility with pre-ba-006 projects.
+
 > **Note:** Review mode (`ba-review.json`) is handled by the `/business-analyse-review` skill.
 
 ## Navigation Hierarchy
@@ -91,11 +94,54 @@ Maps to SmartStack DB tables:
 
 ### Naming conventions
 
-- **Application code**: PascalCase (e.g., `HumanResources`)
-- **Module code**: PascalCase (e.g., `Employees`)
+- **Project directory**: kebab-case slug (e.g., `projet-rh`, `commande-repas`)
+- **Application directory**: kebab-case (e.g., `human-resources`) — derived from PascalCase code via `toKebabCase()`
+- **Module directory**: kebab-case (e.g., `employees`) — derived from PascalCase code via `toKebabCase()`
+- **Application code** (in JSON): PascalCase (e.g., `HumanResources`)
+- **Module code** (in JSON): PascalCase (e.g., `Employees`)
 - **Section code**: kebab-case (e.g., `list`, `detail`, `dashboard`)
 - **Resource code**: kebab-case (e.g., `employees-grid`, `employee-form`)
 
+### Directory name conversion
+
+```javascript
+function toKebabCase(code) {
+  return code
+    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
+    .toLowerCase();
+}
+```
+
+### Project detection and selection
+
+Projects are discovered by glob — no central registry:
+
+```
+1. Glob: docs/*/v*/index.json
+2. If 0 projects → ERROR "No project found. Run /business-analyse first."
+3. If 1 project → auto-select
+4. If N projects → AskUserQuestion "Which project?"
+   Options: [{label: "{slug} (v{X.Y})", description: "{appCount} apps, {moduleCount} modules, status: {status}"}, ...]
+5. Store selection in .business-analyse/config.json
+```
+
+### Path resolution helpers
+
+```javascript
+function resolveProjectDir(projectSlug, version) {
+  return `docs/${projectSlug}/v${version}`;
+}
+
+function resolveAppDir(projectDir, appCode) {
+  return `${projectDir}/${toKebabCase(appCode)}`;
+}
+
+function resolveModuleDir(projectDir, appCode, moduleCode) {
+  return `${projectDir}/${toKebabCase(appCode)}/${toKebabCase(moduleCode)}`;
+}
+```
+
 ## Permission Paths
 
 Format: `{ApplicationCode}.{ModuleCode}.{Action}`
@@ -111,12 +157,14 @@ For section-level: `{ApplicationCode}.{ModuleCode}.{SectionCode}.{Action}`
 ### ba-writer
 
 Writes granular JSON files. Key operations:
-- `create(scope, data)` — Create index.json + initial files
+- `create(scope, data)` — Create index.json + initial files in `docs/{projectSlug}/v{X.Y}/`
 - `enrichSection(fileType, data)` — Write to specific file (entities.json, rules.json, etc.)
 - `updateIndex(summary)` — Update index.json metadata and summary
 - `createVersion(type)` — Create new version (major/minor)
 - `applyReview(reviewData)` — Apply ba-review.json corrections
 
+All paths follow the pattern: `docs/{projectSlug}/v{X.Y}/{appKebab}/{moduleKebab}/`
+
 ### ba-reader
 
 Reads via index.json. Key operations:

package/templates/skills/business-analyse/references/canonical-json-formats.md

@@ -1,7 +1,7 @@
 # Canonical JSON Formats Reference
 
 > **Purpose:** Single source of truth for all JSON file formats produced by the BA pipeline.
-> **Used by:** `/business-analyse` (step-03), `/business-analyse-design` (step-01), `/business-analyse-html`, `/business-analyse-handoff`, `/business-analyse-develop`
+> **Used by:** `step-03`, `/business-analyse-design` (step-01), `/business-analyse-html`, `/business-analyse-handoff`, `/business-analyse-develop`
 > **Rule:** All producers MUST write canonical format. All consumers MUST accept canonical + deprecated fallbacks.
 
 ---

package/templates/skills/business-analyse/references/naming-conventions.md

@@ -13,6 +13,14 @@
 - `metadata.application` = **PascalCase** (e.g., `"HumanResources"`)
 - Used for: C# namespaces, file paths, class names, folder structure
 
+### In Directory Names (BA docs structure)
+
+- **Project directories**: kebab-case slug chosen by user (e.g., `projet-rh`, `commande-repas`)
+- **Application directories**: kebab-case derived from PascalCase code (e.g., `HumanResources` → `human-resources`)
+- **Module directories**: kebab-case derived from PascalCase code (e.g., `Employees` → `employees`, `TimeManagement` → `time-management`)
+- **"My*" modules**: treated as normal modules (e.g., `MyFollowUp` → `my-follow-up`)
+- Path pattern: `docs/{project-slug}/v{X.Y}/{app-kebab}/{module-kebab}/`
+
 ### In URL Routes
 
 - **kebab-case lowercase** (e.g., `"/human-resources/employees"`)
@@ -86,7 +94,8 @@ const route = `/${toKebabCase(appCode)}/${toKebabCase(moduleCode)}`;
 ```javascript
 function toKebabCase(code) {
   return code
-    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
     .toLowerCase();
 }
 ```
@@ -104,7 +113,8 @@ const webPath = `/${navRoute.split('.').map(toKebabCase).join('/')}`;
 ```typescript
 function toKebabCase(str: string): string {
   return str
-    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
     .toLowerCase();
 }
 ```

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

@@ -84,8 +84,8 @@ mcp__smartstack__validate_conventions({ checks: ["tables"] })
 
 Execute workflow detection algorithm:
 1. **Review Mode Detection:** Check if `{feature_description}` starts with `-review`
-2. **Existing Projects Scanner:** Glob `docs/business-analyse/*/index.json` (project-level)
-3. **Existing Applications Scanner:** Glob `docs/*/business-analyse/*/index.json`
+2. **Existing Projects Scanner:** Glob `docs/*/v*/index.json` (new ba-006 format)
+3. **Legacy Scanner (backward compat):** Glob `docs/business-analyse/*/index.json` AND `docs/*/business-analyse/*/index.json` (pre-ba-006 format)
 4. **Similarity Analysis:** Score user intent against existing apps (>= 80 = strong match)
 5. **Decision Tree:** Prompt user with relevant options
 
@@ -117,7 +117,7 @@ existing_apps: array of { app, featureId, description, version }
 existing_projects: array of { projectName, projectId, applications[], version }
 ```
 
-> **Project Resume Detection:** If a project-level index.json is found at `docs/business-analyse/*/index.json`, check its `metadata.workflow` to determine resume point. The project may have partially completed applications.
+> **Project Resume Detection:** If a project-level index.json is found at `docs/*/v*/index.json`, check its `metadata.workflow` to determine resume point. The project may have partially completed applications. Also check legacy path `docs/business-analyse/*/index.json` for backward compat.
 
 ## Step 3b: Early Multi-Application Detection from Prompt (NEW)
 
@@ -254,9 +254,36 @@ workflow_mode: "application"
 **IF no multi-app detected (neither Tier 1 nor Tier 2):**
 → Continue to step 4 normally
 
-## Step 4: Determine Application Name
+## Step 4: Determine Project Name & Application Name
 
-> **This step is SKIPPED if `workflow_mode = "project"` (multi-app detected in step 3b).**
+### 4a. Project Name (ALWAYS — creates the top-level directory)
+
+```
+IF workflow_type = "update":
+  projectSlug = existing project slug (from step 3 detection)
+  → Skip to 4b
+
+ELSE:
+  Analyze {feature_description} to derive a project slug
+  Ask via AskUserQuestion:
+    question: "{language == 'fr' ? 'Quel nom pour ce projet ?' : 'What name for this project?'}"
+    header: "Project"
+    options:
+      - label: "{detected_slug}"
+        description: "{language == 'fr' ? 'Nom détecté depuis votre description (sera le dossier docs/)' : 'Name detected from description (will be the docs/ folder)'}"
+      - label: "{language == 'fr' ? 'Autre' : 'Other'}"
+        description: "{language == 'fr' ? 'Saisir un nom personnalisé' : 'Enter a custom name'}"
+
+  Ensure projectSlug is kebab-case:
+    projectSlug = userAnswer
+      .toLowerCase()
+      .replace(/[^a-z0-9\s-]/g, '')
+      .replace(/\s+/g, '-')
+      .replace(/-+/g, '-')
+      .trim()
+```
+
+### 4b. Application Name
 
 ```
 IF workflow_mode = "project":
@@ -268,17 +295,18 @@ ELSE IF workflow_type = "update":
 ELSE:
   Analyze {feature_description} to extract application name
   Ask via AskUserQuestion:
-    question: "Quel nom pour cette application ?"
+    question: "{language == 'fr' ? 'Quel nom pour cette application ?' : 'What name for this application?'}"
     header: "Application"
     options:
       - label: "{detected_name}"
-        description: "Nom détecté depuis votre description"
-      - label: "Autre"
-        description: "Saisir un nom personnalisé"
+        description: "{language == 'fr' ? 'Nom détecté depuis votre description' : 'Name detected from description'}"
+      - label: "{language == 'fr' ? 'Autre' : 'Other'}"
+        description: "{language == 'fr' ? 'Saisir un nom personnalisé' : 'Enter a custom name'}"
 ```
 
 **Store:**
 ```yaml
+projectSlug: string       # kebab-case directory name (e.g., "projet-rh")
 application_name: string  # or project_name if project mode
 ```
 
@@ -340,22 +368,25 @@ feature_id: string
 ## Step 7: Create Output Directory Structure
 
 ```
-IF workflow_mode = "project":
-  // Project mode: create project-level directory + per-app directories later
-  mkdir -p docs/business-analyse/v1.0
-  docs_dir = "docs/business-analyse/v{version}"
+projectDir = "docs/" + projectSlug + "/v" + version
 
-ELSE IF workflow_type = "new":
-  mkdir -p docs/{application_name}/business-analyse/v1.0
-  docs_dir = "docs/{app}/business-analyse/v{version}"
+IF workflow_type = "new":
+  mkdir -p {projectDir}
+  docs_dir = projectDir
 
 ELSE:
-  Directory already exists from previous session
+  // Directory already exists from previous session
+  docs_dir = projectDir
 ```
 
+> **Key change (ba-006):** All project data lives under `docs/{projectSlug}/v{X.Y}/`.
+> No more `business-analyse/` intermediate directory. Applications and modules are
+> direct subdirectories: `docs/{projectSlug}/v{X.Y}/{appKebab}/{moduleKebab}/`.
+
 **Store:**
 ```yaml
-docs_dir: string
+docs_dir: string      # e.g., "docs/projet-rh/v1.0"
+projectSlug: string   # e.g., "projet-rh"
 ```
 
 ## Step 8: Deploy JSON Schemas to Project (MANDATORY)
@@ -405,7 +436,7 @@ IF workflow_mode = "project":
     }
   })
 
-  Output path: docs/business-analyse/v{version}/index.json
+  Output path: docs/{projectSlug}/v{version}/index.json
   Thematic files — EXACTLY these 3, NO OTHERS:
     - cadrage.json
     - validation.json
@@ -441,7 +472,7 @@ ELSE:
     }
   })
 
-  Output path: docs/{app}/business-analyse/v{version}/index.json
+  Output path: docs/{projectSlug}/v{version}/index.json
   Thematic files — EXACTLY these 3, NO OTHERS:
     - cadrage.json
     - validation.json
@@ -474,6 +505,7 @@ Write ALL context variables to `.business-analyse/config.json`. This file is the
   "currentFeature": {
     "id": "{feature_id}",
     "version": "{version}",
+    "projectSlug": "{projectSlug}",
     "docsDir": "{docs_dir}",
     "workflowType": "{workflow_type}",
     "workflowMode": "{workflow_mode}",
@@ -530,6 +562,7 @@ feature_id: string               # FEAT-NNN (single-app) or PROJ-NNN (project)
 feature_description: string
 workflow_type: "new" | "update"
 workflow_mode: "application" | "project"
+projectSlug: string              # kebab-case directory name (e.g., "projet-rh")
 application_name: string         # Single-app: app name. Project: project name.
 applicationCode: string          # PascalCase derived from application_name (preliminary, confirmed in step-01)
 project_id: string | null        # PROJ-NNN if project mode, null if single-app
@@ -556,7 +589,7 @@ version: string
 If initialization was interrupted:
 
 1. Check `.business-analyse/config.json` for currentFeature or currentProject
-2. If project ID exists, search for project index.json in `docs/business-analyse/`
+2. If project ID exists, search for project index.json in `docs/*/v*/` (or legacy `docs/business-analyse/`)
    - If found with scope = "project": resume project mode (see Project Resume below)
 3. If feature ID exists, search for index.json in `docs/`
 4. If found, check status and `metadata.workflow.lastCompletedStep`:

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

@@ -26,10 +26,13 @@ next_step: steps/step-02-structure.md
 Re-read session variables from `.business-analyse/config.json` (do NOT rely on LLM memory):
 ```javascript
 const config = readJSON('.business-analyse/config.json').currentFeature;
-const { id: feature_id, docsDir: docs_dir, application: application_name,
+const { id: feature_id, docsDir: docs_dir, projectSlug, application: application_name,
         applicationCode, workflowMode: workflow_mode, language, version } = config;
 ```
 
+> **Path resolution (ba-006):** `docs_dir` points to `docs/{projectSlug}/v{version}`.
+> Cadrage.json is written directly in `{docs_dir}/cadrage.json`.
+
 ## YOUR TASK
 
 Frame the analysis scope at the **application level** through an interactive conversation with the client: understand the problem, stakeholders, scope, and define application-level roles. The analysis phase is ALWAYS interactive — the AI listens, reformulates, challenges, and validates with the user.
@@ -90,7 +93,7 @@ Launch 4 agents in parallel:
   Agent 1: Search for existing domain entities (Glob: **/Domain/**/*.cs)
   Agent 2: Search for existing services/integrations (Grep: IService, IRepository)
   Agent 3: Search for existing page patterns (Glob: **/pages/**/*.tsx)
-  Agent 4: Scan existing BA documentation (Glob: docs/**/business-analyse/**/index.json)
+  Agent 4: Scan existing BA documentation (Glob: docs/*/v*/index.json, docs/**/business-analyse/**/index.json)
            → For each found file: read metadata.application, metadata.module, status, modules[].code
            → Also scan: docs/**/*.md (ERD, guides, specs)
 
@@ -227,6 +230,7 @@ _preAnalysis:
 ```
 ## {language == "fr" ? "Voici ce que j'ai compris de votre besoin" : "Here is my understanding of your need"}
 
+**Projet :** {projectSlug}
 **Application :** {detected application name}
 **Objectif :** {reformulation in 2-3 sentences of the global need — in the client's own words, not technical jargon}
 

package/templates/skills/business-analyse/steps/step-02-structure.md

@@ -16,8 +16,15 @@ Identify the complete hierarchy **Application > Module > Section > Resource** fr
 Re-read session variables from `.business-analyse/config.json`:
 ```javascript
 const config = readJSON('.business-analyse/config.json').currentFeature;
-const { id: feature_id, docsDir: docs_dir, application: application_name,
+const { id: feature_id, docsDir: docs_dir, projectSlug, application: application_name,
         applicationCode, workflowMode: workflow_mode, language } = config;
+
+// Path helpers (ba-006)
+function toKebabCase(code) {
+  return code.replace(/([a-z0-9])([A-Z])/g, '$1-$2').replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2').toLowerCase();
+}
+function resolveAppDir(appCode) { return `${docs_dir}/${toKebabCase(appCode)}`; }
+function resolveModuleDir(appCode, moduleCode) { return `${docs_dir}/${toKebabCase(appCode)}/${toKebabCase(moduleCode)}`; }
 ```
 
 ## Prerequisites
@@ -185,10 +192,13 @@ Ask: "Does this structure match your vision? Any missing modules, sections, or r
 ## Output
 
 Write via ba-writer:
-1. **Application index** (`docs/{app}/business-analyse/v1.0/index.json`) with modules list
-2. **Module registrations** in application index
+1. **Application index** (`{docs_dir}/{appKebab}/index.json`) with modules list
+2. **Module directories** created as `{docs_dir}/{appKebab}/{moduleKebab}/`
 3. **Each module's anticipated sections** as `anticipatedSections` in module data
 
+> **ba-006 path pattern:** `docs/{projectSlug}/v{X.Y}/{appKebab}/{moduleKebab}/`
+> No `business-analyse/` intermediate directory.
+
 ### Data written
 
 ```json

package/templates/skills/business-analyse/steps/step-03-specify.md

@@ -16,10 +16,21 @@ For each module (in dependency order), produce complete specifications: entities
 Re-read session variables from `.business-analyse/config.json`:
 ```javascript
 const config = readJSON('.business-analyse/config.json').currentFeature;
-const { id: feature_id, docsDir: docs_dir, application: application_name,
+const { id: feature_id, docsDir: docs_dir, projectSlug, application: application_name,
         applicationCode, workflowMode: workflow_mode, language } = config;
+
+// Path helpers (ba-006)
+function toKebabCase(code) {
+  return code.replace(/([a-z0-9])([A-Z])/g, '$1-$2').replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2').toLowerCase();
+}
+function resolveModuleDir(appCode, moduleCode) {
+  return `${docs_dir}/${toKebabCase(appCode)}/${toKebabCase(moduleCode)}`;
+}
 ```
 
+> **Module directory (ba-006):** `mod.dir = resolveModuleDir(applicationCode, module.code)`
+> Example: `docs/projet-rh/v1.0/human-resources/employees/`
+
 ## Prerequisites
 
 - Step 02 (structure) completed
@@ -301,6 +312,8 @@ const errors = [];
 const warnings = [];
 
 for (const mod of modules) {
+  // mod.dir = resolveModuleDir(applicationCode, mod.code)
+  // e.g., docs/projet-rh/v1.0/human-resources/employees/
   const ent = READ(mod.dir + '/entities.json')?.entities || [];
   const ucs = READ(mod.dir + '/usecases.json')?.useCases || [];
   const brs = READ(mod.dir + '/rules.json')?.rules || [];

package/templates/skills/business-analyse/steps/step-04-consolidate.md

@@ -21,10 +21,12 @@ next_step: none
 Re-read session variables from `.business-analyse/config.json`:
 ```javascript
 const config = readJSON('.business-analyse/config.json').currentFeature;
-const { id: feature_id, docsDir: docs_dir, application: application_name,
+const { id: feature_id, docsDir: docs_dir, projectSlug, application: application_name,
         applicationCode, workflowMode: workflow_mode, language } = config;
 ```
 
+> **Consolidation output (ba-006):** Written to `{projectDir}/consolidation.json`.
+
 ## YOUR TASK
 Consolidate all modules by validating cross-module interactions, permission coherence, data model integrity, E2E flows, and global risks. Obtain client approval and write consolidation data.
 

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

@@ -16,10 +16,21 @@ For each module, define all sections and resources with detailed interface speci
 Re-read session variables (do NOT rely on LLM memory from prior skill invocation):
 ```javascript
 const config = readJSON('.business-analyse/config.json').currentFeature;
-const { id: feature_id, docsDir: docs_dir, application: application_name,
+const { id: feature_id, docsDir: docs_dir, projectSlug, application: application_name,
         applicationCode, language } = config;
+
+// Path helpers (ba-006)
+function toKebabCase(code) {
+  return code.replace(/([a-z0-9])([A-Z])/g, '$1-$2').replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2').toLowerCase();
+}
+function resolveModuleDir(appCode, moduleCode) {
+  return `${docs_dir}/${toKebabCase(appCode)}/${toKebabCase(moduleCode)}`;
+}
 ```
 
+> **screens.json output (ba-006):** Written to `resolveModuleDir(appCode, moduleCode)/screens.json`
+> Example: `docs/projet-rh/v1.0/human-resources/employees/screens.json`
+
 ## Prerequisites
 
 - `/business-analyse` completed (entities, usecases, permissions exist)

package/templates/skills/business-analyse-design/steps/step-03-navigation.md

@@ -99,7 +99,8 @@ Application
 
 ### 4. Write navigation.json
 
-Write via ba-writer at project level (alongside master index.json). Update index.json with navigation.json reference.
+Write via ba-writer at project level: `{docs_dir}/navigation.json` (e.g., `docs/projet-rh/v1.0/navigation.json`).
+Update index.json with navigation.json reference.
 
 ## Validation
 
@@ -123,8 +124,8 @@ Write via ba-writer at project level (alongside master index.json). Update index
 
 | Artifact        | Path                              |
 |-----------------|-----------------------------------|
-| screens.json    | {module-path}/screens.json        |
-| navigation.json | {project-path}/navigation.json    |
+| screens.json    | {docs_dir}/{app-kebab}/{module-kebab}/screens.json |
+| navigation.json | {docs_dir}/navigation.json                        |
 
 NEXT STEPS:
 1. Run /business-analyse-html to produce the interactive HTML with mockups

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

@@ -63,14 +63,14 @@ For **EACH module** in topological order, use the **Agent tool** (subagent_type:
 Transform module "{moduleCode}" for handoff.
 
 ## Input
-- Module BA directory: {moduleDir}
+- Module BA directory: {moduleDir}  // ba-006: {docs_dir}/{appKebab}/{moduleKebab}/
 - Application code: {appCode}
 - Application name: {appName}
 - Feature description: {featureDescription}
 - Module index: {moduleDir}/index.json
 
 ## Instructions
-Read the following 5 files from {moduleDir}:
+Read the following 5 files from {moduleDir} (ba-006: docs/{projectSlug}/v{X.Y}/{appKebab}/{moduleKebab}/):
   1. entities.json → entities[]
   2. usecases.json → useCases[] (canonical key: "useCases", fallback: "usecases")
   3. rules.json → rules[] (canonical key: "rules", fallback: "businessRules")

package/templates/skills/business-analyse-handoff/steps/step-02-export.md

@@ -168,10 +168,20 @@ IF .ralph/progress.txt exists AND contains "Iteration" entries:
 
 Write to: `.ralph/progress.txt`
 
-### 5. Update BA Manifest (docs/index.json)
+### 5. Update Project Index (status tracking)
 
-**Schema:**
+> **ba-006:** No global `docs/index.json` manifest. Projects are autonomous.
+> Update the project's own `{docs_dir}/index.json` with handoff status instead.
 
+**Update logic:**
+
+1. Read `{docs_dir}/index.json` (project master index)
+2. Update status to `"handed-off"` for each processed module
+3. Update `metadata.lastModified` timestamp
+4. Write back
+5. Display: "Project index updated: {docs_dir}/index.json (status: handed-off)"
+
+**Legacy (pre-ba-006):** If `docs/index.json` global manifest exists, also update it for backward compatibility:
 ```json
 {
   "version": "1.0",
@@ -185,21 +195,13 @@ Write to: `.ralph/progress.txt`
       "version": "{version}",
       "status": "handed-off",
       "featureDescription": "{description}",
-      "path": "{app_code}/business-analyse/v{version}/index.json",
+      "path": "{projectSlug}/v{version}/index.json",
       "updatedAt": "{ISO timestamp}"
     }
   ]
 }
 ```
 
-**Update logic:**
-
-1. Read existing manifest (or create empty)
-2. **PROJECT MODE:** Add/update project entry + all app entries + all module entries per app
-3. **SINGLE-APP MODE:** Update app entry + module entries for this app
-4. Write manifest back with updated timestamp
-5. Display: "BA manifest updated: docs/index.json ({total} entries)"
-
 ### 6. Display Completion Summary
 
 ```
@@ -229,7 +231,7 @@ Artifacts generated:
   .ralph/prd-{module}.permissions.json    — Permissions (companion)
   .ralph/progress.txt                     — Progression tracker
   .ralph/modules-queue.json               — Module execution order (if multi-module)
-  docs/index.json                         — BA manifest (status: handed-off)
+  {docs_dir}/index.json                   — Project index (status: handed-off)
 
 [NEXT] Development:
   1. Run /business-analyse-develop to begin implementation
@@ -246,7 +248,7 @@ Artifacts generated:
 1. `.ralph/prd-{module}.json` exists for ALL modules (>100 bytes each)
 2. `.ralph/progress.txt` exists (>500 bytes)
 3. `.ralph/modules-queue.json` exists (if 2+ modules)
-4. `docs/index.json` updated with correct entry count and status "handed-off"
+4. `{docs_dir}/index.json` updated with handoff status (legacy: `docs/index.json` if it exists)
 5. All PRD files have $version=3.0.0 or 4.0.0, file manifest present, 8 categories
 6. File counts match between PRD and handoff for all categories
 7. For EACH module: 5 companion files exist in `.ralph/` (entities, rules, usecases, screens, permissions)

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

@@ -27,6 +27,20 @@ Generate the interactive HTML document of the business analysis from the JSON an
 - JSON analysis files must exist (at minimum `index.json` + `cadrage.json`)
 - Feature status must be `consolidated`
 
+## Project Detection (ba-006)
+
+When launched, detect and select the target project:
+
+```
+1. Glob: docs/*/v*/index.json
+2. If 0 projects → BLOCKING ERROR "No project found. Run /business-analyse first."
+3. If 1 project → auto-select
+4. If N projects → AskUserQuestion "Which project?"
+5. Store projectSlug, docs_dir in session
+```
+
+**Legacy fallback:** Also check `docs/business-analyse/v*/index.json` and `docs/*/business-analyse/v*/index.json`.
+
 ## Workflow
 
 4 progressive steps: