@atlashub/smartstack-cli 4.40.0 → 4.42.0

package/templates/skills/{ba-review → business-analyse-review}/SKILL.md

@@ -1,17 +1,17 @@
 ---
-name: ba-review
+name: business-analyse-review
 description: "Apply client corrections from ba-review.json and regenerate the interactive HTML document"
 model: opus
 user_invocable: true
 ---
 
-# /ba-review
+# /business-analyse-review
 
 Apply corrections exported from the interactive HTML review (`ba-review.json`) to create a new version of the business analysis, then regenerate the HTML document.
 
 ## Triggers
 
-- Explicit invocation: `/ba-review`
+- Explicit invocation: `/business-analyse-review`
 - When `ba-review.json` is detected in the project root
 
 ## Parameters
@@ -30,12 +30,13 @@ Apply corrections exported from the interactive HTML review (`ba-review.json`) t
 
 | Step | File | Role |
 |------|------|------|
-| 01 | `steps/step-01-apply.md` | Read ba-review.json, create new version, apply corrections to JSON files |
+| 00 | `steps/step-00-init.md` | Locate ba-review.json, detect feature, initialize variables |
+| 01 | `steps/step-01-apply.md` | Create new version, apply corrections to JSON files |
 
 After step-01 completes:
 1. Determine correction scope (analysis data vs UI design vs both)
 2. Route to the appropriate phase for re-execution
-3. Regenerate HTML via `/ba-generate-html`
+3. Regenerate HTML via `/business-analyse-html`
 
 ## Correction Routing
 
@@ -44,10 +45,10 @@ After applying corrections, ask the client which phase to re-execute:
 | Correction type | Route to | Reason |
 |-----------------|----------|--------|
 | Entities, rules, UCs, permissions changed | `/business-analyse` step-03 (specify) | Re-run analysis for affected modules |
-| Screens, wireframes, navigation changed | `/ba-design-ui` | Re-run UI design for affected modules |
-| Both analysis and UI changed | `/business-analyse` step-03, then `/ba-design-ui` | Full re-specification |
-| Only cadrage/scope corrections | `/ba-generate-html` | Just regenerate HTML |
-| Client approves (no corrections) | `/derive-prd` | Proceed to PRD generation |
+| Screens, wireframes, navigation changed | `/business-analyse-design` | Re-run UI design for affected modules |
+| Both analysis and UI changed | `/business-analyse` step-03, then `/business-analyse-design` | Full re-specification |
+| Only cadrage/scope corrections | `/business-analyse-html` | Just regenerate HTML |
+| Client approves (no corrections) | `/business-analyse-handoff` | Proceed to PRD generation |
 
 ## References
 
@@ -57,4 +58,4 @@ After applying corrections, ask the client which phase to re-execute:
 
 ## Entry Point
 
-**FIRST ACTION:** Load `steps/step-01-apply.md`
+**FIRST ACTION:** Load `steps/step-00-init.md`

package/templates/skills/{ba-review → business-analyse-review}/references/review-data-mapping.md

@@ -1,8 +1,8 @@
 # Review Data Mapping Reference (references/review-data-mapping.md)
 
-> **Used by:** /ba-review step-01-apply (Apply Review Corrections)
+> **Used by:** /business-analyse-review step-01-apply (Apply Review Corrections)
 > **Purpose:** Reverse mapping from ba-review.json (HTML export) back to module JSON files format
-> **Complement of:** `/ba-generate-html/references/data-mapping.md` (forward mapping)
+> **Complement of:** `/business-analyse-html/references/data-mapping.md` (forward mapping)
 
 ---
 

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

@@ -0,0 +1,107 @@
+---
+name: step-00-init
+description: Initialize review workflow — locate ba-review.json, detect feature, set variables
+model: sonnet
+next_step: steps/step-01-apply.md
+---
+
+# Step 00: Initialize Review
+
+## YOUR TASK
+
+Locate `ba-review.json`, identify the target feature, and initialize variables for step-01-apply.
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Locate ba-review.json
+
+```javascript
+// Search order:
+// 1. Project root: ./ba-review.json
+// 2. docs/ subdirectories: docs/**/ba-review.json
+const candidates = [
+  './ba-review.json',
+  ...glob('docs/**/ba-review.json')
+];
+
+const review_json_path = candidates.find(p => existsSync(p));
+if (!review_json_path) {
+  BLOCKING_ERROR("ba-review.json not found. Export it from the interactive HTML document first.");
+}
+```
+
+### 2. Read Review Metadata
+
+```javascript
+const review = readJSON(review_json_path);
+
+// Validate structure
+if (!review._reviewMeta) {
+  BLOCKING_ERROR("ba-review.json missing _reviewMeta — not a valid review export");
+}
+if (!review.metadata?.applicationId) {
+  BLOCKING_ERROR("ba-review.json missing metadata.applicationId");
+}
+
+const application_name = review.metadata.applicationName || review.metadata.applicationId;
+const application_id = review.metadata.applicationId;
+const source_version = review._reviewMeta.sourceVersion || "1.0";
+```
+
+### 3. Locate Feature Docs Directory
+
+```javascript
+// Find the matching BA feature directory
+const docs_dir = glob(`docs/**/business-analyse/v*/index.json`)
+  .map(p => dirname(p))
+  .find(dir => {
+    const index = readJSON(join(dir, 'index.json'));
+    return index.id === application_id || index.metadata?.application === application_name;
+  });
+
+if (!docs_dir) {
+  BLOCKING_ERROR("Cannot find BA feature directory for application: " + application_name);
+}
+```
+
+### 4. Verify BA Status
+
+```javascript
+const masterIndex = readJSON(join(docs_dir, 'index.json'));
+const status = masterIndex.metadata?.status || masterIndex.status;
+
+if (!['consolidated', 'reviewed', 'specified'].includes(status)) {
+  BLOCKING_ERROR("Feature status is '" + status + "' — expected 'consolidated', 'reviewed', or 'specified'");
+}
+```
+
+### 5. Set Variables
+
+```javascript
+const workflow_type = "review";
+
+// Variables available to step-01-apply:
+// {workflow_type}     = "review"
+// {review_json_path}  = path to ba-review.json
+// {application_name}  = application display name
+// {docs_dir}          = path to BA feature directory
+// {source_version}    = version the review was exported from
+```
+
+### 6. Display Summary
+
+```
+REVIEW INITIALIZED
+Application: {application_name}
+Review file: {review_json_path}
+Source version: {source_version}
+Has changes: {review._reviewMeta.hasChanges}
+Changes: {review._reviewMeta.changeSummary}
+→ Applying corrections...
+```
+
+## NEXT STEP
+
+Load: `steps/step-01-apply.md`

package/templates/skills/{ba-review → business-analyse-review}/steps/step-01-apply.md

@@ -178,6 +178,8 @@ review_section = {
 Create review.json with review_section and update hash in index.json
 ```
 
+> `review.json` is an AUDIT artifact — it preserves the review trail for traceability. No downstream skill consumes it.
+
 ## Step 8: Determine Correction Routing
 
 Analyze the corrections applied to determine which phase needs re-execution:
@@ -204,10 +206,10 @@ ELSE:
 
 ## Step 9: Regenerate Interactive HTML
 
-Delegate HTML generation to `/ba-generate-html` skill:
+Delegate HTML generation to `/business-analyse-html` skill:
 
 ```
-1. Load skill: /ba-generate-html with feature_id
+1. Load skill: /business-analyse-html with feature_id
 2. The skill handles: collect → build → render → verify
 3. Output: {new_version_dir}/ba-interactive.html
 ```
@@ -222,6 +224,12 @@ Delegate HTML generation to `/ba-generate-html` skill:
 5. Write docs/index.json
 ```
 
+## Step 10b: Update Status
+
+```javascript
+ba-writer.updateStatus({feature_id}, "reviewed")
+```
+
 ## Step 11: Display Completion Summary
 
 ```
@@ -261,25 +269,25 @@ Display next steps based on `route`:
 ```
 IF route == "analysis":
   "1. Run /business-analyse step-03 for modules: {corrected_module_list}"
-  "2. Then run /ba-design-ui to update UI specs"
-  "3. Then run /ba-generate-html to regenerate documentation"
+  "2. Then run /business-analyse-design to update UI specs"
+  "3. Then run /business-analyse-html to regenerate documentation"
 
 IF route == "ui":
-  "1. Run /ba-design-ui for modules: {corrected_module_list}"
-  "2. Then run /ba-generate-html to regenerate documentation"
+  "1. Run /business-analyse-design for modules: {corrected_module_list}"
+  "2. Then run /business-analyse-html to regenerate documentation"
 
 IF route == "both":
   "1. Run /business-analyse step-03 for modules: {analysis_corrected_modules}"
-  "2. Then run /ba-design-ui for modules: {ui_corrected_modules}"
-  "3. Then run /ba-generate-html to regenerate documentation"
+  "2. Then run /business-analyse-design for modules: {ui_corrected_modules}"
+  "3. Then run /business-analyse-html to regenerate documentation"
 
 IF route == "html-only":
   "HTML has been regenerated. Review the updated document."
-  "If satisfied, run /derive-prd to generate PRD files."
+  "If satisfied, run /business-analyse-handoff to generate PRD files."
 
 IF no corrections (client approves):
-  "No corrections needed. Run /derive-prd to generate PRD files."
-  "Then run /ralph-loop to start development."
+  "No corrections needed. Run /business-analyse-handoff to generate PRD files."
+  "Then run /business-analyse-develop to start development."
 ```
 
 ```

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

@@ -0,0 +1,118 @@
+---
+name: business-analyse-status
+description: Display the current state of business analysis cycle, show progress per module, and recommend next steps.
+model: sonnet
+user-invocable: true
+---
+
+# /business-analyse-status
+
+Display the current state of the business analysis cycle for the active feature.
+
+## Trigger
+
+- Explicit: `/business-analyse-status` or `/business-analyse-status <feature-id>`
+- When the user asks "where are we?", "what's the status?", "what's left to do?"
+
+## Execution
+
+### Step 1 — Locate feature
+
+1. If `<feature-id>` is provided, search for `docs/business/<feature-id>/index.json`
+2. If not provided, scan `docs/business/*/index.json` — if exactly 1 feature exists, use it; if multiple, list them and ask which one
+3. If no feature found, display:
+   ```
+   Aucune analyse métier trouvée dans docs/business/.
+   → Lancez /business-analyse pour démarrer.
+   ```
+
+### Step 2 — Read state
+
+Read the following files (all optional — missing = not done):
+
+| File | What it tells us |
+|------|-----------------|
+| `index.json` | Feature exists, metadata, status, module list |
+| `cadrage.json` | Cadrage done |
+| Per module: `entities.json` | Entities specified |
+| Per module: `rules.json` | Business rules specified |
+| Per module: `usecases.json` | Use cases specified |
+| Per module: `permissions.json` | Permissions defined |
+| Per module: `screens.json` | UI design done |
+| Per module: `navigation.json` | Navigation tree done |
+| Per module: `handoff.json` | Handoff/PRD generated |
+| `ba-interactive.html` (in project root or feature dir) | HTML document generated |
+| `ba-review.json` (in project root) | Client review pending |
+
+### Step 3 — Compute progress
+
+For each module, determine completion of each phase:
+
+| Phase | Required files | Skill |
+|-------|---------------|-------|
+| Cadrage | status >= `"framed"` AND `cadrage.json` has context/stakeholders/scope | `/business-analyse` |
+| Structure | status >= `"decomposed"` AND modules[] non-empty with anticipatedSections | `/business-analyse` |
+| Specification | status >= `"specified"` (per module) AND entities/rules/usecases/permissions non-empty | `/business-analyse` |
+| Consolidation | status >= `"consolidated"` AND consolidation.json exists | `/business-analyse` |
+| Design | status >= `"designed"` AND `screens.json` non-empty per module | `/business-analyse-design` |
+| HTML | `ba-interactive.html` exists and > 100KB | `/business-analyse-html` |
+| Review | status >= `"reviewed"` OR `ba-review.json` exists (pending) | `/business-analyse-review` |
+| Handoff | status >= `"handed-off"` AND `.ralph/prd-*.json` exists | `/business-analyse-handoff` |
+
+### Step 4 — Display
+
+Use this exact format:
+
+```
+══════════════════════════════════════════════════
+  Business Analyse — {applicationName}
+  Version {version} · {lastModified}
+══════════════════════════════════════════════════
+
+  {checkmark} Cadrage              {status}
+  {checkmark} Spécification        {X}/{Y} modules
+  {checkmark} Design UI            {X}/{Y} modules
+  {checkmark} Document HTML        {status}
+  {checkmark} Review client        {status}
+  {checkmark} Handoff              {status}
+
+  Détail par module :
+  ┌──────────────────┬──────┬────────┬────────┬──────────┐
+  │ Module           │ Spec │ Design │ Review │ Handoff  │
+  ├──────────────────┼──────┼────────┼────────┼──────────┤
+  │ {moduleName}     │  ✓   │  ✓     │  ○     │  ·       │
+  │ {moduleName}     │  ✓   │  ○     │  ·     │  ·       │
+  └──────────────────┴──────┴────────┴────────┴──────────┘
+
+  Prochaine étape recommandée :
+  → {recommendation}
+
+══════════════════════════════════════════════════
+```
+
+Legend:
+- `✓` = done (green if terminal supports it)
+- `○` = in progress / partial
+- `·` = not started
+
+### Step 5 — Recommend next step
+
+Based on the current state, recommend ONE next action:
+
+| State | Recommendation |
+|-------|---------------|
+| No cadrage | `Lancez /business-analyse pour démarrer l'analyse.` |
+| Cadrage done, spec incomplete | `Continuez /business-analyse pour spécifier les modules restants.` |
+| All modules specified, no design | `Lancez /business-analyse-design <feature-id> pour concevoir les interfaces.` |
+| Design done, no HTML | `Lancez /business-analyse-html <feature-id> pour générer le document client.` |
+| HTML generated, no review | `Envoyez ba-interactive.html au client pour review.` |
+| ba-review.json exists | `Lancez /business-analyse-review pour appliquer les corrections client.` |
+| Review done / approved | `Lancez /business-analyse-handoff pour générer les PRD.` |
+| Handoff done | `Analyse complète ! Lancez /business-analyse-develop pour démarrer le développement.` |
+
+## Rules
+
+- This skill is READ-ONLY — it never modifies any file
+- Use the `ba-reader` agent to read JSON files if available
+- Keep output concise — the user wants a quick overview, not a full report
+- If a module has partial data (e.g., entities but no rules), show it as `○` (in progress)

package/templates/skills/documentation/SKILL.md

@@ -23,7 +23,7 @@ Works in synergy with the `/documentation module` command.
 ## WHEN THIS SKILL ACTIVATES
 
 ### PREREQUISITE — ONLY post-implementation
-This skill requires the feature page to already exist (generated by /ralph-loop).
+This skill requires the feature page to already exist (generated by /business-analyse-develop).
 It reads real TSX pages, controllers, and entities. Without them, nothing to document.
 
 → For reviewing/editing the analysis BEFORE implementation: use ba-interactive.html (/business-analyse step-05)
@@ -32,7 +32,7 @@ Claude automatically invokes this skill when it detects:
 
 | Trigger | Example |
 |---------|---------|
-| ❌ NEVER during BA | Before /ralph-loop — feature page does not exist yet |
+| ❌ NEVER during BA | Before /business-analyse-develop — feature page does not exist yet |
 | Explicit request | "Document the SLA module" |
 | Documentation mention | "We should create the doc for..." |
 | After implementation | "The feature is done, generate the doc" |

package/templates/skills/sketch/SKILL.md

@@ -0,0 +1,172 @@
+---
+name: sketch
+description: |
+  Transform a vague idea into a precise /apex command in under 5 minutes.
+  Use this skill when:
+  - User has a vague idea ("I want an HR app with employees and absences")
+  - User doesn't know the exact entities, fields, or structure needed
+  - User needs help designing a module before running /apex
+  Zero MCP, zero file generation — pure domain inference.
+model: opus
+argument-hint: "<vague idea in natural language>"
+---
+
+<objective>
+Transform a vague user prompt into a precise, ready-to-run /apex command. /sketch is a rapid design assistant — it infers entities, properties, relationships, labels, and code patterns from minimal input using domain heuristics and LLM knowledge.
+
+**Key principles:**
+- MAX 2 questions total (1 subject guard + 1 optional confirmation)
+- Zero MCP calls — pure inference (validation is /apex's job)
+- Zero file generation — output is text in conversation only
+- Domain heuristics ACCELERATE inference, they do NOT limit it
+</objective>
+
+<quick_start>
+
+```bash
+/sketch une app RH avec employés et absences
+/sketch I want to manage customer orders and invoices
+/sketch gestion de projets avec tâches et jalons
+/sketch stock management
+```
+
+</quick_start>
+
+<anti_patterns>
+- DO NOT ask more than 2 questions total
+- DO NOT generate any files (no JSON, no code, no documents)
+- DO NOT call any MCP tools (validation is /apex's job)
+- DO NOT scan the entire codebase (max 1 Glob for app detection)
+- DO NOT duplicate business analysis logic (no stakeholders, risks, use cases)
+- DO NOT output structured syntax — /apex parses natural language, not custom formats
+- DO NOT call Skill("apex") directly — instruct the agent to do it based on user choice
+</anti_patterns>
+
+<algorithm>
+
+## 1. SUBJECT GUARD
+
+Check if the user prompt contains at least one identifiable business object (noun that could be an entity: employees, orders, projects, invoices, etc.).
+
+```
+IF no business object identifiable in prompt:
+  → AskUserQuestion: "What do you want to manage? (e.g., employees, orders, projects, invoices...)"
+  → Wait for answer, then continue to step 2
+  → This is the ONLY mandatory question
+```
+
+## 2. LOAD DOMAIN HEURISTICS
+
+Read `references/domain-heuristics.md` — domain pattern table with entities, properties, FK relationships, and i18n labels for 15 common business domains.
+
+## 3. ULTRA THINK — Domain Inference
+
+**ULTRA THINK deeply about the user's domain before proceeding.**
+
+From the user prompt + domain heuristics table:
+
+1. **Extract keywords** from user prompt (nouns, domain terms, action verbs)
+2. **Match against heuristics table** — find the closest domain pattern(s)
+3. **If no match:** use general LLM knowledge (the table accelerates, it does NOT limit)
+4. **Infer entities:** name, key properties, types, nullable flags
+5. **Infer FK relationships:** between entities (EmployeeId→Employee, etc.)
+6. **Infer sections:** 1 section per main entity, code = plural kebab-case (e.g., "employees")
+7. **Infer i18n labels** in 4 languages (fr, en, it, de) — from table or LLM knowledge
+8. **Deduce code_patterns:** strategy = "sequential" by default, prefix = first 3 letters of entity name
+9. **Deduce tenantMode:** "strict" by default (multi-tenant)
+10. **Deduce complexity:**
+    - `simple-crud` if ≤ 2 entities with no workflow/status transitions
+    - `crud-rules` otherwise (validations, computed fields, status)
+    - `crud-workflow` if mentions approval, email, notification
+    - `complex` if > 4 entities with specific business logic
+
+## 4. DETECT EXISTING APPLICATION
+
+```
+Glob("**/NavigationApplicationSeedData.cs")  ← single scan, MAX 1
+
+IF files found:
+  → Extract application names from seed data classes
+  → Check if the inferred module fits an existing application
+  → If multiple apps match: flag as ambiguity for step 5
+
+IF no files found:
+  → New application — infer name from domain
+  → app_name = domain-appropriate PascalCase name (e.g., "HumanResources")
+```
+
+## 5. CONFIRMATION GATE — MAX 1 optional question
+
+```
+IF real ambiguity exists (multiple matching apps, genuinely ambiguous domain):
+  → AskUserQuestion with specific options to resolve the ambiguity
+  → This is the ONLY optional question
+
+IF no ambiguity:
+  → Zero questions — proceed directly to output
+```
+
+## 6. OUTPUT — Display result and choices
+
+Display the design summary and generated /apex prompt using the exact format below.
+
+</algorithm>
+
+<output_format>
+
+```
+══════════════════════════════════════════════════════════
+  /sketch — Module Design Complete
+══════════════════════════════════════════════════════════
+
+  Application:  {app_name}
+  Module:       {module_code}
+  Sections:     {section1_code} ({fr_label}/{en_label}/{it_label}/{de_label})
+                {section2_code} ({fr_label}/{en_label}/{it_label}/{de_label})
+  Entities:     {Entity1} ({prop1}:{type}, {prop2}:{type}, {fk}:{type} FK→{Target})
+                {Entity2} ({prop1}:{type}, {prop2}:{type}, {fk}:{type} FK→{Target})
+  Complexity:   {complexity}
+  Code:         {Entity1} → {prefix}-{tenant}-00001 | {Entity2} → {prefix}-{tenant}-00001
+
+  Ready to run:
+  ──────────────────────────────────────────────────────
+  /apex add {sections} sections to {app_name} module with
+  {Entity1} entity ({properties with types and FKs}) and
+  {Entity2} entity ({properties with types and FKs}),
+  code patterns sequential {prefixes}, complexity {complexity}
+  ──────────────────────────────────────────────────────
+
+  [1] Run this /apex command now
+  [2] Edit before running
+  [3] Cancel
+```
+
+**Rules for the generated /apex prompt:**
+- Natural language, dense but readable
+- Include ALL entities with their key properties and types
+- Include FK relationships explicitly (e.g., "EmployeeId:Guid FK→Employee")
+- Include code pattern prefixes
+- Include complexity level
+- Mention the target application name
+
+</output_format>
+
+<handoff>
+
+Based on user selection:
+
+```
+IF user selects [1]:
+  → Call: Skill("apex", args: "{the generated prompt text}")
+
+IF user selects [2]:
+  → Display the generated prompt for the user to edit
+  → Wait for edited version
+  → Re-display choices [1] Run / [3] Cancel
+
+IF user selects [3]:
+  → Display: "Cancelled. Run /sketch again when ready."
+  → STOP
+```
+
+</handoff>

package/templates/skills/sketch/references/domain-heuristics.md

@@ -0,0 +1,116 @@
+# Domain Heuristics — /sketch
+
+> **Purpose:** Accelerate entity/property inference for common business domains.
+> This table is an **accelerator**, not a limiter. If the user's domain is not listed,
+> the LLM infers entities and properties from general knowledge.
+
+---
+
+## HR / Ressources Humaines
+
+- **Employee** (FirstName:string, LastName:string, Email:string, HireDate:DateTime, DepartmentId:Guid→Department)
+  labels: { fr: "Employé", en: "Employee", it: "Dipendente", de: "Mitarbeiter" }
+- **Department** (Name:string, Code:string, ParentDepartmentId:Guid?→Department)
+  labels: { fr: "Département", en: "Department", it: "Dipartimento", de: "Abteilung" }
+
+## Absences / Congés
+
+- **Absence** (StartDate:DateTime, EndDate:DateTime, Type:string, Status:string, EmployeeId:Guid→Employee)
+  labels: { fr: "Absence", en: "Absence", it: "Assenza", de: "Abwesenheit" }
+- **AbsenceType** (Name:string, Code:string, MaxDays:int, IsPaid:bool)
+  labels: { fr: "Type d'absence", en: "Absence Type", it: "Tipo di assenza", de: "Abwesenheitstyp" }
+
+## CRM / Clients
+
+- **Customer** (FirstName:string, LastName:string, Email:string, Phone:string, CompanyName:string?)
+  labels: { fr: "Client", en: "Customer", it: "Cliente", de: "Kunde" }
+- **Contact** (FirstName:string, LastName:string, Email:string, Phone:string, CustomerId:Guid→Customer)
+  labels: { fr: "Contact", en: "Contact", it: "Contatto", de: "Kontakt" }
+
+## Commandes / Orders
+
+- **Order** (OrderDate:DateTime, TotalAmount:decimal, Status:string, CustomerId:Guid→Customer)
+  labels: { fr: "Commande", en: "Order", it: "Ordine", de: "Bestellung" }
+- **OrderLine** (Quantity:int, UnitPrice:decimal, TotalPrice:decimal, ProductId:Guid→Product, OrderId:Guid→Order)
+  labels: { fr: "Ligne de commande", en: "Order Line", it: "Riga d'ordine", de: "Bestellposition" }
+
+## Facturation / Invoicing
+
+- **Invoice** (InvoiceDate:DateTime, DueDate:DateTime, TotalAmount:decimal, Status:string, CustomerId:Guid→Customer)
+  labels: { fr: "Facture", en: "Invoice", it: "Fattura", de: "Rechnung" }
+- **InvoiceLine** (Description:string, Quantity:int, UnitPrice:decimal, TotalPrice:decimal, InvoiceId:Guid→Invoice)
+  labels: { fr: "Ligne de facture", en: "Invoice Line", it: "Riga di fattura", de: "Rechnungsposition" }
+
+## Projets / Projects
+
+- **Project** (Name:string, Code:string, StartDate:DateTime, EndDate:DateTime?, Status:string, ManagerId:Guid?→Employee)
+  labels: { fr: "Projet", en: "Project", it: "Progetto", de: "Projekt" }
+- **Task** (Title:string, Description:string?, DueDate:DateTime?, Status:string, Priority:string, ProjectId:Guid→Project, AssigneeId:Guid?→Employee)
+  labels: { fr: "Tâche", en: "Task", it: "Attività", de: "Aufgabe" }
+- **Milestone** (Name:string, DueDate:DateTime, Status:string, ProjectId:Guid→Project)
+  labels: { fr: "Jalon", en: "Milestone", it: "Traguardo", de: "Meilenstein" }
+
+## Stock / Inventaire
+
+- **Product** (Name:string, Code:string, Description:string?, UnitPrice:decimal, CategoryId:Guid?→Category)
+  labels: { fr: "Produit", en: "Product", it: "Prodotto", de: "Produkt" }
+- **Category** (Name:string, Code:string, ParentCategoryId:Guid?→Category)
+  labels: { fr: "Catégorie", en: "Category", it: "Categoria", de: "Kategorie" }
+- **StockMovement** (Quantity:int, Type:string, Date:DateTime, ProductId:Guid→Product, WarehouseId:Guid?→Warehouse)
+  labels: { fr: "Mouvement de stock", en: "Stock Movement", it: "Movimento di stock", de: "Lagerbewegung" }
+
+## Contrats / Contracts
+
+- **Contract** (Title:string, StartDate:DateTime, EndDate:DateTime?, Status:string, Amount:decimal?, CustomerId:Guid→Customer)
+  labels: { fr: "Contrat", en: "Contract", it: "Contratto", de: "Vertrag" }
+- **ContractAmendment** (Description:string, Date:DateTime, Amount:decimal?, ContractId:Guid→Contract)
+  labels: { fr: "Avenant", en: "Amendment", it: "Emendamento", de: "Nachtrag" }
+
+## Tickets / Support
+
+- **Ticket** (Title:string, Description:string, Priority:string, Status:string, Category:string, CustomerId:Guid?→Customer, AssigneeId:Guid?→Employee)
+  labels: { fr: "Ticket", en: "Ticket", it: "Ticket", de: "Ticket" }
+- **TicketComment** (Content:string, IsInternal:bool, TicketId:Guid→Ticket)
+  labels: { fr: "Commentaire", en: "Comment", it: "Commento", de: "Kommentar" }
+
+## Fournisseurs / Suppliers
+
+- **Supplier** (Name:string, Email:string, Phone:string, Address:string?, VatNumber:string?)
+  labels: { fr: "Fournisseur", en: "Supplier", it: "Fornitore", de: "Lieferant" }
+- **PurchaseOrder** (OrderDate:DateTime, Status:string, TotalAmount:decimal, SupplierId:Guid→Supplier)
+  labels: { fr: "Bon de commande", en: "Purchase Order", it: "Ordine d'acquisto", de: "Bestellung" }
+
+## Documents / GED
+
+- **Document** (Title:string, FileName:string, FileSize:long, MimeType:string, FolderId:Guid?→Folder)
+  labels: { fr: "Document", en: "Document", it: "Documento", de: "Dokument" }
+- **Folder** (Name:string, ParentFolderId:Guid?→Folder)
+  labels: { fr: "Dossier", en: "Folder", it: "Cartella", de: "Ordner" }
+
+## Réservations / Bookings
+
+- **Booking** (StartDate:DateTime, EndDate:DateTime, Status:string, ResourceId:Guid→Resource, ContactId:Guid?→Contact)
+  labels: { fr: "Réservation", en: "Booking", it: "Prenotazione", de: "Buchung" }
+- **Resource** (Name:string, Type:string, Capacity:int?, Location:string?)
+  labels: { fr: "Ressource", en: "Resource", it: "Risorsa", de: "Ressource" }
+
+## Événements / Events
+
+- **Event** (Title:string, Description:string?, StartDate:DateTime, EndDate:DateTime, Location:string?, MaxAttendees:int?)
+  labels: { fr: "Événement", en: "Event", it: "Evento", de: "Veranstaltung" }
+- **Registration** (Status:string, RegisteredAt:DateTime, EventId:Guid→Event, ContactId:Guid?→Contact)
+  labels: { fr: "Inscription", en: "Registration", it: "Iscrizione", de: "Anmeldung" }
+
+## Formation / Training
+
+- **Training** (Title:string, Description:string?, StartDate:DateTime, EndDate:DateTime, MaxParticipants:int?, TrainerId:Guid?→Employee)
+  labels: { fr: "Formation", en: "Training", it: "Formazione", de: "Schulung" }
+- **Enrollment** (Status:string, EnrolledAt:DateTime, TrainingId:Guid→Training, EmployeeId:Guid→Employee)
+  labels: { fr: "Inscription", en: "Enrollment", it: "Iscrizione", de: "Anmeldung" }
+
+## Maintenance / Equipment
+
+- **Equipment** (Name:string, SerialNumber:string?, Status:string, Location:string?, CategoryId:Guid?→Category)
+  labels: { fr: "Équipement", en: "Equipment", it: "Attrezzatura", de: "Ausrüstung" }
+- **MaintenanceRequest** (Title:string, Description:string, Priority:string, Status:string, EquipmentId:Guid→Equipment, RequestedById:Guid?→Employee)
+  labels: { fr: "Demande de maintenance", en: "Maintenance Request", it: "Richiesta di manutenzione", de: "Wartungsanfrage" }