feat(front) : page ajouter un client (formulaire principal + onglets) (ERP-63)

- pages/clients/new.vue : route /clients/new gatee par commercial.clients.manage.
  Formulaire principal (POST /clients) puis validation incrementale des onglets
  via MalioTabList ; un onglet valide passe en lecture seule, passage automatique
  au suivant. Information (PATCH groupe information), Contact/Adresse (sous-ressources
  contacts/addresses), Comptabilite (PATCH scalaires accounting + POST ribs, gate
  accounting.view/manage), onglets coquille auto-avances. Mode strict RG-1.28 :
  chaque requete ne porte que les champs de son groupe.
- i18n : cles commercial.clients.form.* (formulaire, onglets, confirmation, toasts).

RG-1.04 (Information obligatoire pour la Commerciale) : non miroitee cote front
(roles = IRIs dans /api/me, Bureau == Commerciale en permissions) ; appliquee de
maniere fiable par le back. A rebrancher quand un code de role sera expose.

config/version.yaml

@@ -1,2 +1,2 @@
 parameters:
-    app.version: '0.1.62'
+    app.version: '0.1.66'

docs/specs/M0-categories/spec-back.md

@@ -118,6 +118,8 @@ Aucun pattern soft delete existant dans Starseed (vérifié, aucune entité ne p
 
 Index unique partiel sur `(LOWER(name), category_type_id) WHERE deleted_at IS NULL`. Permet de recréer une catégorie avec le même `(name, type)` après suppression logique. Postgres supporte nativement (`CREATE UNIQUE INDEX ... WHERE`). Pattern propre, pas besoin de validator applicatif maison côté unicité — la contrainte SQL fait le job.
 
+> **🔗 Évolution ERP-78 (refonte taxonomie M1)** : `Category` porte désormais une colonne **`code`** (`VARCHAR(50)`, NOT NULL), slug MAJUSCULE auto-généré du nom (figé à la création, lecture seule via l'API), avec un **second index unique partiel** `uq_category_code (code) WHERE deleted_at IS NULL`. Ce code est la clé métier stable utilisée par le M1 Commercial (RG-1.03 / RG-1.29). Détail : `docs/specs/M1-clients/spec-back.md` § 3.3.
+
 ### 2.5 Audit & traces temporelles — deux niveaux complémentaires
 
 Deux mécanismes **indépendants** cohabitent :

docs/specs/M1-clients/spec-back.md

@@ -465,26 +465,32 @@ CREATE TABLE client_rib (
 CREATE INDEX idx_client_rib_client ON client_rib(client_id);
 ```
 
-### 3.3 Seed `CategoryType` (extension du M0)
+### 3.3 Seed taxonomie — type unique `CLIENT` + `Category.code` (refonte ERP-78)
 
-Au M0, la table `category_type` a été créée mais reste vide (HP-1 du M0). Le M1 lève cette restriction avec un seed initial des **types métier** dont le module Tiers a besoin :
+> **⚠ Refonte ERP-78 (décision produit 01/06) — le modèle ci-dessous remplace l'ancien.**
+> Historique : à l'origine (#38), `DISTRIBUTEUR` / `COURTIER` / `SECTEUR` / `AUTRE` étaient des **`category_type`**. Le modèle a été **inversé** :
+>
+> - **UN SEUL `category_type` : `CLIENT`** (code `CLIENT`, label « Client »).
+> - `Distributeur` / `Courtier` / `Secteur` / `Autre` (+ catégories métier fines) sont désormais des **`Category`** rattachées au type `CLIENT`.
+> - Le filtrage métier ne se fait plus sur le **type** mais sur un **`code` stable porté par la `Category`** (NOT NULL, unique parmi les actifs — index partiel `uq_category_code`). Le code est un **slug MAJUSCULE auto-généré du nom** (`CategoryCodeGenerator`), figé à la création, et exposé en **lecture seule** (groupe `category:read`). Les codes `DISTRIBUTEUR` / `COURTIER` (anciennement portés par le type) sont reportés sur les `Category` correspondantes.
+
+Seed cible (migration corrective `Version20260602100000`, namespace racine) :
 
 ```sql
-INSERT INTO category_type (code, label, position) VALUES
-    ('DISTRIBUTEUR', 'Distributeur', 10),
-    ('COURTIER',     'Courtier',     20),
-    ('SECTEUR',      'Secteur',      30),
-    ('AUTRE',        'Autre',        99);
+-- Type unique
+INSERT INTO category_type (code, label) VALUES ('CLIENT', 'Client') ON CONFLICT (code) DO NOTHING;
+-- Catégories système sous CLIENT (codes stables pilotant les RG)
+-- Distributeur -> DISTRIBUTEUR, Courtier -> COURTIER, Secteur -> SECTEUR, Autre -> AUTRE
 ```
 
-> **Note** : le CRUD admin de `CategoryType` reste HP (cf. M0).
+> **Note** : le CRUD admin de `CategoryType` reste HP (cf. M0). Le `code` de `Category` n'est PAS saisissable via l'API (auto-généré côté serveur).
 >
-> **Seed en DEUX endroits (décision 29/05, vérifiée empiriquement)** : le `make db-reset` lance les fixtures, dont le purger Doctrine **vide `category_type`** (entité M0 mappée) avant `load()` → un seed posé uniquement en migration disparaît en dev/test. Donc :
-> 1. **Migration** (`ON CONFLICT (code) DO NOTHING`) → sert en **prod** (pas de fixtures).
-> 2. **Fixture Commercial idempotente** (ex. `CommercialReferentialFixtures`) re-seedant les 4 types → survit au `db-reset`, satisfait le critère « 4 types présents après db-reset ».
+> **Seed en DEUX endroits (décision 29/05, vérifiée empiriquement)** : le `make db-reset` lance les fixtures, dont le purger Doctrine **vide `category` / `category_type`** (entités M0 mappées) avant `load()` → un seed posé uniquement en migration disparaît en dev/test. Donc :
+> 1. **Migration** (`ON CONFLICT` / guards `NOT EXISTS`) → sert en **prod** (pas de fixtures).
+> 2. **Fixtures idempotentes** (`CategoryTypeFixtures` → type CLIENT ; `CategoryFixtures` → catégories codées sous CLIENT) → survivent au `db-reset`.
 >
 > ⚠ **À venir en ERP-54** : `tva_mode` / `payment_delay` / `payment_type` / `bank` ne sont pas encore des entités mappées au M1.0 → le purger ne les touche pas, leur seed migration survit. **Dès qu'ERP-54 crée leurs entités, ils seront purgés au db-reset** → il faudra les ajouter à la même fixture référentielle.
-> 🔗 **Coordination ERP-68** : ERP-53 pose la fixture référentielle minimale (4 category_types). ERP-68 l'**étend** (clients de démo, ~12-15) sans la dupliquer.
+> 🔗 **Coordination ERP-68** : ERP-78 (cette refonte) atterrit avant ERP-68. `CategoryFixtures` / `ClientFixtures` ont été adaptées au type unique CLIENT + codes (les tiers distributeur/courtier portent les `Category` de code DISTRIBUTEUR/COURTIER).
 
 ### 3.4 Entité `Client` — squelette
 
@@ -742,7 +748,7 @@ class Client implements TimestampableInterface, BlamableInterface
 - **Security** : `is_granted('commercial.clients.view')`
 - **Query params** :
   - `includeArchived=true|false` (default `false`)
-  - `categoryType=<code>` (filtre par type de catégorie via `SearchFilter`)
+  - `categoryCode=<code>` (filtre les clients ayant ≥ 1 `Category` de ce code stable — ERP-78 ; ex. `DISTRIBUTEUR`, `COURTIER`)
   - `search=<text>` (recherche fuzzy sur companyName + lastName + email)
 - **Tri par défaut** : `companyName ASC`
 - **Pagination** : front via `<MalioDataTable>` (volumétrie cible faible). Pas de pagination serveur au M1.
@@ -881,7 +887,7 @@ Cf. § 2.6. Pattern Shared standard.
 
 - **RG-1.01** : Au moins l'un des champs `firstName` (Prénom du contact principal) ou `lastName` (Nom du contact principal) doit être renseigné. Sinon → 422.
 - **RG-1.02** : Le champ `phoneSecondary` est optionnel et apparaît au clic sur un bouton `+` côté front. Maximum 2 téléphones (primary + secondary). Comportement purement front au niveau UI ; côté serveur, les 2 colonnes existent et sont distinctes.
-- **RG-1.03** : Les champs `distributor` et `broker` sont **mutuellement exclusifs** (au plus une seule des deux est renseignée). Tentative d'envoyer les deux → 422. Contrainte CHECK en base également : `NOT (distributor_id IS NOT NULL AND broker_id IS NOT NULL)`. La liste front de `distributor` = clients ayant au moins une catégorie de type `DISTRIBUTEUR` ; idem pour `broker` avec `COURTIER`.
+- **RG-1.03** : Les champs `distributor` et `broker` sont **mutuellement exclusifs** (au plus une seule des deux est renseignée). Tentative d'envoyer les deux → 422. Contrainte CHECK en base également : `NOT (distributor_id IS NOT NULL AND broker_id IS NOT NULL)`. Un `distributor` référencé doit porter une **`Category` de code `DISTRIBUTEUR`** ; un `broker` une **`Category` de code `COURTIER`** — sinon 422. _(Refonte ERP-78 : le filtrage se fait sur le `code` de la `Category`, plus sur le type — `ClientProcessor::hasCategoryCode`.)_ La liste front de `distributor` = clients ayant une catégorie de code `DISTRIBUTEUR`, via `GET /api/clients?categoryCode=DISTRIBUTEUR` ; idem `broker` avec `COURTIER`.
 
 ### Onglet Information
 
@@ -946,9 +952,9 @@ Cf. § 2.6. Pattern Shared standard.
 
 - **RG-1.28** : Si un PATCH contient des champs de **plusieurs groupes** de sérialisation et que l'utilisateur **n'a pas toutes les permissions** correspondantes, le `ClientProcessor` renvoie **403 Forbidden sur l'ensemble du payload** (mode strict — pas de filtrage silencieux). Le front est responsable de ne JAMAIS envoyer de champs hors-permission (les onglets masqués via `usePermissions()` ne génèrent pas de payload). Cette règle protège contre les appels API directs malveillants. Exemple : un Bureau qui envoie `{ "companyName": "...", "siren": "..." }` → 403, le message d'erreur précise « Champ `siren` requiert la permission `commercial.clients.accounting.manage` ».
 
-### Catégorie sur ClientAddress (filtrage par type)
+### Catégorie sur ClientAddress (filtrage par code)
 
-- **RG-1.29** : Le `<MalioSelectCheckbox>` Catégorie de l'onglet Adresse n'expose **que** les `Category` dont `categoryType.code IN ('SECTEUR', 'AUTRE')`. Les types `DISTRIBUTEUR` et `COURTIER` qualifient une **relation entre clients** (cf. RG-1.03) et n'ont pas de sens sur une adresse physique. Implémentation : `ClientAddressProvider` filtre côté serveur via paramètre de requête à l'endpoint `GET /api/categories?categoryType.code[]=SECTEUR&categoryType.code[]=AUTRE` (SearchFilter API Platform). Côté validation du POST/PATCH : si l'utilisateur tente de poster une catégorie de type DISTRIBUTEUR ou COURTIER sur une adresse → **422** avec violation `categories: "Type de catégorie non autorisé sur une adresse."`.
+- **RG-1.29** _(refonte ERP-78)_ : sur une adresse, les `Category` de **code `DISTRIBUTEUR` ou `COURTIER`** sont **interdites** — elles qualifient une **relation entre clients** (cf. RG-1.03) et n'ont pas de sens sur une adresse physique. **Toute autre** catégorie (type unique CLIENT) est autorisée. Validation du POST/PATCH : poster une catégorie de code DISTRIBUTEUR/COURTIER sur une adresse → **422** avec violation `categories: "Type de catégorie non autorisé sur une adresse."` (`ClientAddress::validateCategoryCodes`). Côté front, le `<MalioSelectCheckbox>` Catégorie de l'onglet Adresse exclut les `Category` de code `DISTRIBUTEUR` / `COURTIER` (le `code` est exposé en lecture sur `/api/categories`).
 
 ## 8. Tests à automatiser
 
@@ -957,7 +963,7 @@ Cf. § 2.6. Pattern Shared standard.
 - [ ] **RG-1.01** : POST sans firstName ni lastName → 422
 - [ ] **RG-1.02** : POST avec phoneSecondary rempli → persistance OK ; PATCH ajoutant un 3e téléphone → côté API, 2 colonnes uniquement (test que le payload ne peut pas créer un 3e)
 - [ ] **RG-1.03** : POST avec distributor ET broker → 422 ; POST distributor seul → 201
-- [ ] **RG-1.03** : POST distributor référençant un client SANS catégorie de type DISTRIBUTEUR → 422 (validation custom)
+- [ ] **RG-1.03** : POST distributor référençant un client SANS catégorie de code DISTRIBUTEUR → 422 (validation custom `ClientProcessor::hasCategoryCode`)
 - [ ] **RG-1.04** : PATCH onglet Information par un user Commerciale avec champs incomplets → 422 ; même PATCH par Admin → 200
 - [ ] **RG-1.05** : POST contact sans firstName ni lastName → 422 (BDD CHECK lève une exception)
 - [ ] **RG-1.06/07/08** : POST adresse avec isProspect=true ET isDelivery=true → 422 / CHECK

docs/specs/M1-clients/spec-front.md

@@ -96,8 +96,8 @@ C'est le 1er bloc à remplir. Sans validation de ce formulaire, les onglets ne s
 | **Téléphone secondaire** | `<MalioInputText>` (masque tel) | Non | Apparaît au clic sur le bouton `+` (RG-1.02). Max 2 — bouton `+` disparaît une fois rempli. |
 | **Email** | `<MalioInputText>` type email | Oui | RG-1.21 (lowercase) |
 | **Distributeur / Courtier** | `<MalioSelect>` | Non | Valeurs : `Dépend du distributeur` / `Dépend du courtier` / `Aucun`. RG-1.03 conditionne les 2 champs suivants. |
-| **Nom du distributeur** | `<MalioSelect>` | Conditionnel | Visible si « Dépend du distributeur ». Liste = clients ayant ≥ 1 catégorie de type `DISTRIBUTEUR`. RG-1.03. |
-| **Nom du courtier** | `<MalioSelect>` | Conditionnel | Visible si « Dépend du courtier ». Liste = clients ayant ≥ 1 catégorie de type `COURTIER`. RG-1.03. |
+| **Nom du distributeur** | `<MalioSelect>` | Conditionnel | Visible si « Dépend du distributeur ». Liste = clients ayant ≥ 1 catégorie de **code** `DISTRIBUTEUR` (ERP-78), via `GET /api/clients?categoryCode=DISTRIBUTEUR`. RG-1.03. |
+| **Nom du courtier** | `<MalioSelect>` | Conditionnel | Visible si « Dépend du courtier ». Liste = clients ayant ≥ 1 catégorie de **code** `COURTIER` (ERP-78), via `GET /api/clients?categoryCode=COURTIER`. RG-1.03. |
 | **Prestation de triage** | `<MalioCheckbox>` | Non | — |
 
 **Action** : « Valider » (`<MalioButton>`) → POST `/api/clients` ([`spec-back.md` § 4.3](./spec-back.md)). Si succès, on passe automatiquement à l'onglet « Information ».
@@ -150,7 +150,7 @@ Saisir une ou plusieurs adresses du client, rattachées à un ou plusieurs sites
 | **Prospect** | `<MalioCheckbox>` | Non | RG-1.06 — masque Adresse de livraison + Facturation si coché |
 | **Adresse de livraison** | `<MalioCheckbox>` | Non | RG-1.07 — masque Prospect si coché |
 | **Facturation** | `<MalioCheckbox>` | Non | RG-1.08 — masque Prospect si coché ; affiche le champ Email (RG-1.11) |
-| **Catégorie** | `<MalioSelectCheckbox>` (multi) | Oui | Liste des `Category` de **type SECTEUR + AUTRE** uniquement (cf. décision Q5 — DISTRIBUTEUR et COURTIER qualifient une relation entre clients, pas un lieu) |
+| **Catégorie** | `<MalioSelectCheckbox>` (multi) | Oui | Liste des `Category` **hors codes `DISTRIBUTEUR` / `COURTIER`** (ERP-78 — ces codes qualifient une relation entre clients, pas un lieu). Le front exclut ces 2 codes du select (le `code` est exposé en lecture sur `/api/categories`). |
 | **Pays** | `<MalioSelect>` | Oui | Préremplie « France » |
 | **Code postal** | `<MalioInputText>` (masque numérique) | Oui | RG-1.09 — déclenche autocomplete ville via BAN |
 | **Ville** | `<MalioSelect>` | Oui | RG-1.09 — alimentée par api-adresse.data.gouv.fr suivant le CP |
@@ -268,7 +268,7 @@ Le composant `Code postal` + `Ville` + `Adresse` est branché sur **api-adresse.
 
 | # | Zone d'ombre V0 | Résolution (cf. `spec-back.md`) |
 |---|---|---|
-| 1 | Catégorie en multi-select non clarifiée (1 ou n par client) | **M2M `client_category`** validée. CategoryType seedé avec `DISTRIBUTEUR`, `COURTIER`, `SECTEUR`, `AUTRE` (HP-3 du M0 levé). |
+| 1 | Catégorie en multi-select non clarifiée (1 ou n par client) | **M2M `client_category`** validée. Refonte ERP-78 : type unique `CLIENT` ; `Distributeur`/`Courtier`/`Secteur`/`Autre` (+ catégories métier) sont des `Category` portant un `code` stable (HP-3 du M0 levé). |
 | 2 | Distributeur / Courtier : liste de quoi ? | **Auto-référence Client** via 2 FK nullables `distributor_id` et `broker_id` (cf. RG-1.03). Une seule des deux est remplie à la fois. |
 | 3 | Onglet « Comptabilité » : qui édite ? | **Admin et Compta** peuvent éditer l'onglet Comptabilité (`commercial.clients.accounting.manage`). Bureau / Commerciale ne voient pas l'onglet. Compta ne peut pas créer un client (pas de `manage` global), mais peut éditer la partie comptable d'un client existant. |
 | 4 | Workflow par onglet | **Sauvegarde incrémentale**. POST formulaire principal crée le `Client` (status implicite « actif »). Chaque onglet validé = PATCH partiel par groupe de sérialisation dédié. Pas d'état « draft ». |

frontend/i18n/locales/fr.json

@@ -44,7 +44,147 @@
     },
     "commercial": {
         "title": "Commercial",
-        "welcome": "Module Commercial"
+        "welcome": "Module Commercial",
+        "clients": {
+            "title": "Répertoire clients",
+            "add": "Ajouter",
+            "export": "Exporter",
+            "empty": "Aucun client pour l'instant.",
+            "column": {
+                "companyName": "Nom",
+                "categories": "Catégories",
+                "sites": "Site",
+                "lastActivity": "Dernière activité"
+            },
+            "filters": {
+                "title": "Filtres",
+                "search": "Recherche",
+                "categories": "Catégories",
+                "sites": "Sites",
+                "status": "Statut",
+                "archivedOnly": "Voir les archivés",
+                "apply": "Voir les résultats",
+                "reset": "Réinitialiser"
+            },
+            "tab": {
+                "information": "Information",
+                "contact": "Contact",
+                "address": "Adresse",
+                "transport": "Transport",
+                "accounting": "Comptabilité",
+                "statistics": "Statistiques",
+                "reports": "Rapports",
+                "exchanges": "Échanges"
+            },
+            "action": {
+                "edit": "Modifier",
+                "archive": "Archiver",
+                "restore": "Restaurer"
+            },
+            "toast": {
+                "createSuccess": "Client créé avec succès",
+                "updateSuccess": "Client mis à jour avec succès",
+                "archiveSuccess": "Client archivé avec succès",
+                "restoreSuccess": "Client restauré avec succès",
+                "error": "Une erreur est survenue. Réessayez.",
+                "exportError": "L'export du répertoire clients a échoué. Réessayez."
+            },
+            "validation": {
+                "informationRequiredForCommercial": "Les informations de l'entreprise sont obligatoires pour le rôle Commerciale.",
+                "contactRequired": "Au moins un contact (nom ou prénom) est obligatoire.",
+                "siteRequired": "Au moins un site Starseed doit être rattaché à l'adresse.",
+                "billingEmailRequired": "L'email de facturation est obligatoire pour une adresse de facturation.",
+                "bankRequiredForTransfer": "La banque est obligatoire pour un règlement par virement.",
+                "ribRequiredForLcr": "Au moins un RIB complet est obligatoire pour un règlement par LCR.",
+                "phoneFormat": "Format de téléphone invalide (attendu : XX XX XX XX XX).",
+                "emailFormat": "Format d'email invalide.",
+                "addressCategoryForbidden": "Une catégorie « Distributeur » ou « Courtier » ne peut pas qualifier une adresse."
+            },
+            "form": {
+                "title": "Ajouter un client",
+                "submit": "Valider",
+                "duplicateCompany": "Un client portant ce nom de société existe déjà.",
+                "main": {
+                    "companyName": "Nom de l'entreprise",
+                    "firstName": "Prénom",
+                    "lastName": "Nom",
+                    "email": "Email",
+                    "phonePrimary": "Téléphone",
+                    "phoneSecondary": "Téléphone (2)",
+                    "addPhone": "Ajouter un numéro",
+                    "categories": "Catégories",
+                    "relation": "Relation",
+                    "relationNone": "Aucune",
+                    "relationDistributor": "Distributeur",
+                    "relationBroker": "Courtier",
+                    "distributorName": "Nom du distributeur",
+                    "brokerName": "Nom du courtier",
+                    "triageService": "Prestation de triage"
+                },
+                "information": {
+                    "description": "Description",
+                    "competitors": "Concurrents",
+                    "foundedAt": "Date de création",
+                    "employeesCount": "Nombre de salariés",
+                    "revenueAmount": "Chiffre d'affaires",
+                    "profitAmount": "Résultat",
+                    "directorName": "Dirigeant"
+                },
+                "contact": {
+                    "title": "Contact {n}",
+                    "lastName": "Nom",
+                    "firstName": "Prénom",
+                    "jobTitle": "Fonction",
+                    "email": "Email",
+                    "phonePrimary": "Téléphone",
+                    "phoneSecondary": "Téléphone (2)",
+                    "addPhone": "Ajouter un numéro",
+                    "remove": "Supprimer le contact",
+                    "add": "Nouveau contact"
+                },
+                "address": {
+                    "title": "Adresse {n}",
+                    "prospect": "Prospect",
+                    "delivery": "Adresse de livraison",
+                    "billing": "Facturation",
+                    "categories": "Catégorie",
+                    "country": "Pays",
+                    "postalCode": "Code postal",
+                    "city": "Ville",
+                    "street": "Adresse",
+                    "streetComplement": "Adresse complémentaire",
+                    "sites": "Sites Starseed",
+                    "contacts": "Contact(s) rattaché(s)",
+                    "billingEmail": "Email de facturation",
+                    "remove": "Supprimer l'adresse",
+                    "add": "Nouvelle adresse",
+                    "degraded": "Service d'adresse indisponible : saisie de la ville et de l'adresse en mode libre."
+                },
+                "accounting": {
+                    "siren": "SIREN",
+                    "accountNumber": "Numéro de compte",
+                    "tvaMode": "Mode de TVA",
+                    "nTva": "N° de TVA",
+                    "paymentDelay": "Délai de règlement",
+                    "paymentType": "Type de règlement",
+                    "bank": "Banque",
+                    "ribTitle": "RIB {n}",
+                    "ribLabel": "Libellé",
+                    "ribBic": "BIC",
+                    "ribIban": "IBAN",
+                    "addRib": "Ajouter un RIB",
+                    "removeRib": "Supprimer le RIB"
+                },
+                "confirmDelete": {
+                    "title": "Confirmer la suppression",
+                    "contact": "Supprimer ce contact ?",
+                    "address": "Supprimer cette adresse ?",
+                    "rib": "Supprimer ce RIB ?",
+                    "cancel": "Annuler",
+                    "confirm": "Confirmer"
+                }
+            }
+        }
     },
     "auth": {
         "login": "Connexion",

frontend/modules/commercial/components/ClientAddressBlock.vue

@@ -0,0 +1,280 @@
+<template>
+    <div class="rounded-md border border-neutral-200 bg-white p-6">
+        <div class="mb-4 flex items-center justify-between">
+            <h3 class="text-lg font-bold">{{ title }}</h3>
+            <!-- ariaLabel via v-bind objet (prop camelCase ; aria-* serait un attribut HTML). -->
+            <MalioButtonIcon
+                v-if="removable && !readonly"
+                icon="mdi:trash-can-outline"
+                variant="ghost"
+                v-bind="{ ariaLabel: t('commercial.clients.form.address.remove') }"
+                @click="$emit('remove')"
+            />
+        </div>
+
+        <!-- Usage de l'adresse : Prospect exclusif de Livraison/Facturation
+             (RG-1.06/07/08). On masque l'option incompatible selon l'etat. -->
+        <div class="mb-4 flex flex-wrap gap-6">
+            <MalioCheckbox
+                v-if="canSelectProspect(model)"
+                :model-value="model.isProspect"
+                :label="t('commercial.clients.form.address.prospect')"
+                :readonly="readonly"
+                @update:model-value="(v: boolean) => toggleFlag('isProspect', v)"
+            />
+            <MalioCheckbox
+                v-if="canSelectDeliveryOrBilling(model)"
+                :model-value="model.isDelivery"
+                :label="t('commercial.clients.form.address.delivery')"
+                :readonly="readonly"
+                @update:model-value="(v: boolean) => toggleFlag('isDelivery', v)"
+            />
+            <MalioCheckbox
+                v-if="canSelectDeliveryOrBilling(model)"
+                :model-value="model.isBilling"
+                :label="t('commercial.clients.form.address.billing')"
+                :readonly="readonly"
+                @update:model-value="(v: boolean) => toggleFlag('isBilling', v)"
+            />
+        </div>
+
+        <div class="grid grid-cols-1 gap-4 md:grid-cols-2">
+            <MalioSelectCheckbox
+                :model-value="model.categoryIris"
+                :options="categoryOptions"
+                :label="t('commercial.clients.form.address.categories')"
+                :display-tag="true"
+                :disabled="readonly"
+                @update:model-value="(v: (string | number)[]) => update('categoryIris', v.map(String))"
+            />
+
+            <MalioSelect
+                :model-value="model.country"
+                :options="countryOptions"
+                :label="t('commercial.clients.form.address.country')"
+                :disabled="readonly"
+                @update:model-value="(v: string | number | null) => update('country', String(v ?? 'France'))"
+            />
+
+            <MalioInputText
+                :model-value="model.postalCode"
+                :label="t('commercial.clients.form.address.postalCode')"
+                :mask="POSTAL_CODE_MASK"
+                :readonly="readonly"
+                @update:model-value="onPostalCodeChange"
+            />
+
+            <!-- Ville : MalioSelect alimente par le code postal (BAN). En mode
+                 degrade (service indisponible), bascule en saisie libre. -->
+            <MalioSelect
+                v-if="!degraded"
+                :model-value="model.city"
+                :options="cityOptions"
+                :label="t('commercial.clients.form.address.city')"
+                :disabled="readonly"
+                empty-option-label=""
+                @update:model-value="(v: string | number | null) => update('city', v === null ? null : String(v))"
+            />
+            <MalioInputText
+                v-else
+                :model-value="model.city"
+                :label="t('commercial.clients.form.address.city')"
+                :readonly="readonly"
+                @update:model-value="(v: string) => update('city', v)"
+            />
+
+            <!-- Adresse : saisie assistee (BAN) ou libre en mode degrade. -->
+            <MalioInputAutocomplete
+                v-if="!degraded"
+                :model-value="model.street"
+                :options="addressOptions"
+                :loading="addressLoading"
+                :min-search-length="3"
+                :label="t('commercial.clients.form.address.street')"
+                :readonly="readonly"
+                @update:model-value="(v: string | number | null) => update('street', v === null ? null : String(v))"
+                @search="onAddressSearch"
+                @select="onAddressSelect"
+            />
+            <MalioInputText
+                v-else
+                :model-value="model.street"
+                :label="t('commercial.clients.form.address.street')"
+                :readonly="readonly"
+                @update:model-value="(v: string) => update('street', v)"
+            />
+
+            <MalioInputText
+                :model-value="model.streetComplement"
+                :label="t('commercial.clients.form.address.streetComplement')"
+                :readonly="readonly"
+                @update:model-value="(v: string) => update('streetComplement', v)"
+            />
+
+            <MalioSelectCheckbox
+                :model-value="model.siteIris"
+                :options="siteOptions"
+                :label="t('commercial.clients.form.address.sites')"
+                :display-tag="true"
+                :disabled="readonly"
+                @update:model-value="(v: (string | number)[]) => update('siteIris', v.map(String))"
+            />
+
+            <MalioSelectCheckbox
+                :model-value="model.contactIris"
+                :options="contactOptions"
+                :label="t('commercial.clients.form.address.contacts')"
+                :display-tag="true"
+                :disabled="readonly"
+                @update:model-value="(v: (string | number)[]) => update('contactIris', v.map(String))"
+            />
+
+            <!-- Email de facturation : visible/obligatoire seulement si Facturation
+                 est coche (RG-1.11). -->
+            <MalioInputText
+                v-if="isBillingEmailRequired(model)"
+                :model-value="model.billingEmail"
+                :label="t('commercial.clients.form.address.billingEmail')"
+                :required="true"
+                :readonly="readonly"
+                @update:model-value="(v: string) => update('billingEmail', v)"
+            />
+        </div>
+    </div>
+</template>
+
+<script setup lang="ts">
+import {
+    applyProspectExclusivity,
+    canSelectDeliveryOrBilling,
+    canSelectProspect,
+    isBillingEmailRequired,
+    type AddressFlagsDraft,
+} from '~/modules/commercial/utils/clientFormRules'
+import { useAddressAutocomplete, type AddressSuggestion } from '~/shared/composables/useAddressAutocomplete'
+import type { CategoryOption, RefOption } from '~/modules/commercial/composables/useClientReferentials'
+import type { AddressFormDraft } from '~/modules/commercial/types/clientForm'
+
+// Masque code postal FR : 5 chiffres.
+const POSTAL_CODE_MASK = '#####'
+
+const props = defineProps<{
+    /** Brouillon de l'adresse (v-model). */
+    modelValue: AddressFormDraft
+    title: string
+    /** Categories autorisees sur une adresse (DISTRIBUTEUR/COURTIER exclus, RG-1.29). */
+    categoryOptions: CategoryOption[]
+    /** Sites Starseed disponibles. */
+    siteOptions: RefOption[]
+    /** Contacts deja saisis, rattachables a l'adresse. */
+    contactOptions: RefOption[]
+    /** Pays disponibles (France par defaut). */
+    countryOptions: RefOption[]
+    removable?: boolean
+    readonly?: boolean
+}>()
+
+const emit = defineEmits<{
+    'update:modelValue': [value: AddressFormDraft]
+    'remove': []
+    /** Emis une fois quand le service d'autocompletion bascule en indisponible. */
+    'degraded': []
+}>()
+
+const { t } = useI18n()
+const autocomplete = useAddressAutocomplete()
+
+const model = computed(() => props.modelValue)
+
+// Mode degrade : service BAN indisponible → Ville/Adresse en saisie libre.
+const degraded = ref(false)
+const cityOptions = ref<RefOption[]>([])
+const addressOptions = ref<RefOption[]>([])
+const addressLoading = ref(false)
+// Conserve les suggestions d'adresse pour retrouver ville/CP au moment du select.
+let lastAddressSuggestions: AddressSuggestion[] = []
+
+/** Emet un nouveau brouillon avec le champ modifie (immutabilite). */
+function update<K extends keyof AddressFormDraft>(field: K, value: AddressFormDraft[K]): void {
+    emit('update:modelValue', { ...props.modelValue, [field]: value })
+}
+
+/** Applique l'exclusivite Prospect / (Livraison|Facturation) au changement. */
+function toggleFlag(field: keyof AddressFlagsDraft, value: boolean): void {
+    const flags = applyProspectExclusivity(
+        { isProspect: model.value.isProspect, isDelivery: model.value.isDelivery, isBilling: model.value.isBilling },
+        field,
+        value,
+    )
+    emit('update:modelValue', { ...props.modelValue, ...flags })
+}
+
+/** Bascule définitivement en mode degrade et previent le parent (toast unique). */
+function enterDegraded(): void {
+    if (!degraded.value) {
+        degraded.value = true
+        emit('degraded')
+    }
+}
+
+/** Saisie du code postal → met a jour le champ + interroge la BAN pour la ville. */
+async function onPostalCodeChange(value: string): Promise<void> {
+    update('postalCode', value)
+
+    if (degraded.value) {
+        return
+    }
+    const digits = (value ?? '').replace(/\D/g, '')
+    if (digits.length < 5) {
+        return
+    }
+    try {
+        const suggestions = await autocomplete.searchCity(digits)
+        cityOptions.value = suggestions.map(s => ({ value: s.city, label: s.city }))
+    }
+    catch {
+        enterDegraded()
+    }
+}
+
+/** Recherche d'adresse assistee (event de MalioInputAutocomplete). */
+async function onAddressSearch(query: string): Promise<void> {
+    if (degraded.value) {
+        return
+    }
+    addressLoading.value = true
+    try {
+        const postalCode = (model.value.postalCode ?? '').replace(/\D/g, '') || undefined
+        const suggestions = await autocomplete.searchAddress(query, postalCode)
+        lastAddressSuggestions = suggestions
+        addressOptions.value = suggestions.map(s => ({ value: s.street, label: s.label }))
+    }
+    catch {
+        enterDegraded()
+    }
+    finally {
+        addressLoading.value = false
+    }
+}
+
+/**
+ * Selection d'une suggestion d'adresse → remplit rue + ville + CP.
+ * Le type d'option suit le contrat MalioInputAutocomplete ({ label, value }).
+ */
+function onAddressSelect(option: { label: string, value: string | number } | null): void {
+    if (option === null) {
+        return
+    }
+    const suggestion = lastAddressSuggestions.find(s => s.street === option.value)
+    if (!suggestion) {
+        update('street', String(option.value))
+        return
+    }
+    emit('update:modelValue', {
+        ...props.modelValue,
+        street: suggestion.street,
+        city: suggestion.city,
+        postalCode: suggestion.postalCode,
+    })
+}
+</script>

frontend/modules/commercial/components/ClientContactBlock.vue

@@ -0,0 +1,102 @@
+<template>
+    <div class="rounded-md border border-neutral-200 bg-white p-6">
+        <div class="mb-4 flex items-center justify-between">
+            <h3 class="text-lg font-bold">{{ title }}</h3>
+            <!-- Suppression : ouvre une modal de confirmation cote parent. Masquee
+                 si non supprimable (1er bloc obligatoire RG-1.14) ou en lecture seule. -->
+            <!-- ariaLabel passe via v-bind objet : la prop du composant est
+                 camelCase (aria-* serait traite en attribut HTML, jamais en prop). -->
+            <MalioButtonIcon
+                v-if="removable && !readonly"
+                icon="mdi:trash-can-outline"
+                variant="ghost"
+                v-bind="{ ariaLabel: t('commercial.clients.form.contact.remove') }"
+                @click="$emit('remove')"
+            />
+        </div>
+
+        <div class="grid grid-cols-1 gap-4 md:grid-cols-2">
+            <MalioInputText
+                :model-value="model.lastName"
+                :label="t('commercial.clients.form.contact.lastName')"
+                :readonly="readonly"
+                @update:model-value="(v: string) => update('lastName', v)"
+            />
+            <MalioInputText
+                :model-value="model.firstName"
+                :label="t('commercial.clients.form.contact.firstName')"
+                :readonly="readonly"
+                @update:model-value="(v: string) => update('firstName', v)"
+            />
+            <MalioInputText
+                :model-value="model.jobTitle"
+                :label="t('commercial.clients.form.contact.jobTitle')"
+                :readonly="readonly"
+                @update:model-value="(v: string) => update('jobTitle', v)"
+            />
+            <MalioInputEmail
+                :model-value="model.email"
+                :label="t('commercial.clients.form.contact.email')"
+                :readonly="readonly"
+                @update:model-value="(v: string) => update('email', v)"
+            />
+            <MalioInputPhone
+                :model-value="model.phonePrimary"
+                :label="t('commercial.clients.form.contact.phonePrimary')"
+                :mask="PHONE_MASK"
+                :readonly="readonly"
+                :addable="!model.hasSecondaryPhone && !readonly"
+                :add-button-label="t('commercial.clients.form.contact.addPhone')"
+                @update:model-value="(v: string) => update('phonePrimary', v)"
+                @add="revealSecondaryPhone"
+            />
+            <MalioInputPhone
+                v-if="model.hasSecondaryPhone"
+                :model-value="model.phoneSecondary"
+                :label="t('commercial.clients.form.contact.phoneSecondary')"
+                :mask="PHONE_MASK"
+                :readonly="readonly"
+                @update:model-value="(v: string) => update('phoneSecondary', v)"
+            />
+        </div>
+    </div>
+</template>
+
+<script setup lang="ts">
+import type { ContactFormDraft } from '~/modules/commercial/types/clientForm'
+
+// Masque telephone FR : 5 groupes de 2 chiffres (la normalisation finale reste
+// serveur, cf. formatPhoneFR re-applique a la valeur renvoyee).
+const PHONE_MASK = '## ## ## ## ##'
+
+const props = defineProps<{
+    /** Brouillon du contact (v-model). */
+    modelValue: ContactFormDraft
+    /** Titre du bloc (ex: « Contact 1 »). */
+    title: string
+    /** Affiche l'icone de suppression (1er bloc non supprimable, RG-1.14). */
+    removable?: boolean
+    /** Bloc en lecture seule (onglet valide). */
+    readonly?: boolean
+}>()
+
+const emit = defineEmits<{
+    'update:modelValue': [value: ContactFormDraft]
+    'remove': []
+}>()
+
+const { t } = useI18n()
+
+// Alias local pour la lisibilite du template.
+const model = computed(() => props.modelValue)
+
+/** Emet un nouveau brouillon avec le champ modifie (immutabilite). */
+function update<K extends keyof ContactFormDraft>(field: K, value: ContactFormDraft[K]): void {
+    emit('update:modelValue', { ...props.modelValue, [field]: value })
+}
+
+/** Revele le 2e numero (RG-1.02/1.20 : max 1 secondaire, le « + » disparait). */
+function revealSecondaryPhone(): void {
+    emit('update:modelValue', { ...props.modelValue, hasSecondaryPhone: true })
+}
+</script>

frontend/modules/commercial/components/TabPlaceholderBlank.vue

@@ -0,0 +1,14 @@
+<template>
+    <!--
+        Placeholder des onglets non encore implementes (Transport, Statistiques,
+        Rapports, Echanges). Frame vide blanche : aucun champ, aucun bouton,
+        aucun message « En cours » (decision Tristan 28/05). L'orchestrateur passe
+        automatiquement a l'onglet suivant — ce composant n'est qu'une coquille
+        visuelle reutilisee par 1.11/1.12.
+    -->
+    <div class="min-h-[240px] rounded-md bg-white" />
+</template>
+
+<script setup lang="ts">
+// Composant purement presentationnel : aucune prop, aucun event.
+</script>

frontend/modules/commercial/composables/__tests__/useClientsRepository.spec.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import type { HydraCollection } from '~/shared/utils/api'
+import type { Client } from '../useClientsRepository'
+
+// `useApi` est un auto-import Nuxt : on le stubbe globalement pour intercepter
+// les appels declenches par usePaginatedList (que useClientsRepository enveloppe)
+// et controler les reponses. Meme pattern que useCategoriesAdmin.spec.ts.
+const mockGet = vi.hoisted(() => vi.fn())
+vi.stubGlobal('useApi', () => ({
+    get: mockGet,
+    post: vi.fn(),
+    put: vi.fn(),
+    patch: vi.fn(),
+    delete: vi.fn(),
+}))
+
+// Import APRES le stub pour que useApi soit bien resolu au top-level du module.
+const { useClientsRepository } = await import('../useClientsRepository')
+
+/** Envelope Hydra minimale (la liste reelle des membres importe peu ici). */
+function makeHydra(total: number): HydraCollection<Client> {
+    return { totalItems: total, member: [] }
+}
+
+describe('useClientsRepository', () => {
+    beforeEach(() => {
+        mockGet.mockReset()
+        // 25 items → 3 pages a 10/page : permet de tester la navigation page 2.
+        mockGet.mockResolvedValue(makeHydra(25))
+    })
+
+    it('cible la ressource /clients en page 1 par defaut', async () => {
+        const repo = useClientsRepository()
+        await repo.fetch()
+
+        expect(mockGet).toHaveBeenLastCalledWith(
+            '/clients',
+            { page: 1, itemsPerPage: 10 },
+            expect.objectContaining({ toast: false }),
+        )
+    })
+
+    it('pousse les filtres du drawer (categories multi, sites, archives) et retombe en page 1', async () => {
+        const repo = useClientsRepository()
+        await repo.fetch()
+        await repo.goToPage(2)
+        expect(repo.currentPage.value).toBe(2)
+
+        await repo.setFilters(
+            {
+                search: 'acme',
+                'categoryCode[]': ['DISTRIBUTEUR', 'COURTIER'],
+                'siteId[]': ['1', '2'],
+                archivedOnly: true,
+            },
+            { replace: true },
+        )
+
+        expect(repo.currentPage.value).toBe(1)
+        expect(mockGet).toHaveBeenLastCalledWith(
+            '/clients',
+            {
+                search: 'acme',
+                'categoryCode[]': ['DISTRIBUTEUR', 'COURTIER'],
+                'siteId[]': ['1', '2'],
+                archivedOnly: true,
+                page: 1,
+                itemsPerPage: 10,
+            },
+            expect.objectContaining({ toast: false }),
+        )
+    })
+
+    it('repasse a une query propre apres reinitialisation des filtres', async () => {
+        const repo = useClientsRepository()
+        await repo.setFilters({ search: 'acme', archivedOnly: true }, { replace: true })
+        await repo.setFilters({}, { replace: true })
+
+        expect(mockGet).toHaveBeenLastCalledWith(
+            '/clients',
+            { page: 1, itemsPerPage: 10 },
+            expect.objectContaining({ toast: false }),
+        )
+    })
+})

frontend/modules/commercial/composables/useClientReferentials.ts

@@ -0,0 +1,141 @@
+import { ref } from 'vue'
+
+/**
+ * Charge les referentiels (listes courtes) alimentant les selects de l'ecran
+ * « Ajouter un client » : categories, sites, modes de TVA, delais et types de
+ * reglement, banques, et les listes distributeurs / courtiers.
+ *
+ * Toutes les collections sont recuperees en entier via l'echappatoire prevue
+ * `?pagination=false` (referentiels de quelques dizaines d'entrees max), avec
+ * l'en-tete `Accept: application/ld+json` impose par API Platform 4 pour obtenir
+ * l'enveloppe Hydra (`member`). Les valeurs d'option sont les IRI Hydra (`@id`)
+ * pour pouvoir etre renvoyees telles quelles dans les payloads POST/PATCH
+ * (relations ManyToOne / ManyToMany).
+ *
+ * Etat 100 % local a l'instance (refs) — aucune persistance URL.
+ */
+
+/** Option generique au format attendu par MalioSelect / MalioSelectCheckbox ({ label, value }). */
+export interface RefOption {
+    value: string
+    label: string
+}
+
+/** Option de type de reglement enrichie de son code stable (RG-1.12 / RG-1.13). */
+export interface PaymentTypeOption extends RefOption {
+    code: string
+}
+
+/** Option de categorie enrichie de son code stable (filtrage RG-1.29 cote adresse). */
+export interface CategoryOption extends RefOption {
+    code: string
+}
+
+/** Option de client (distributeur / courtier) — value = IRI du client lie. */
+export type ClientOption = RefOption
+
+interface HydraMember {
+    '@id': string
+}
+
+interface CategoryMember extends HydraMember {
+    code: string
+    name: string
+}
+
+interface SiteMember extends HydraMember {
+    name: string
+}
+
+interface ReferentialMember extends HydraMember {
+    code: string
+    label: string
+}
+
+interface ClientMember extends HydraMember {
+    companyName: string
+}
+
+const LD_JSON_HEADERS = { Accept: 'application/ld+json' }
+
+export function useClientReferentials() {
+    const api = useApi()
+
+    const categories = ref<CategoryOption[]>([])
+    const sites = ref<RefOption[]>([])
+    const tvaModes = ref<RefOption[]>([])
+    const paymentDelays = ref<RefOption[]>([])
+    const paymentTypes = ref<PaymentTypeOption[]>([])
+    const banks = ref<RefOption[]>([])
+    const distributors = ref<ClientOption[]>([])
+    const brokers = ref<ClientOption[]>([])
+
+    /** Recupere une collection complete (pagination desactivee) en Hydra. */
+    async function fetchAll<T extends HydraMember>(
+        url: string,
+        query: Record<string, string | string[]> = {},
+    ): Promise<T[]> {
+        const res = await api.get<{ member?: T[] }>(
+            url,
+            { pagination: 'false', ...query },
+            { headers: LD_JSON_HEADERS, toast: false },
+        )
+        return res.member ?? []
+    }
+
+    /**
+     * Charge en parallele les referentiels communs (hors distributeurs/courtiers,
+     * charges a la demande selon la relation choisie). Les selects compta ne sont
+     * pertinents que si l'utilisateur a acces a l'onglet, mais le cout est
+     * negligeable et simplifie l'orchestration.
+     */
+    async function loadCommon(): Promise<void> {
+        const [cats, sitesList, tva, delays, types, banksList] = await Promise.all([
+            fetchAll<CategoryMember>('/categories'),
+            fetchAll<SiteMember>('/sites'),
+            fetchAll<ReferentialMember>('/tva_modes'),
+            fetchAll<ReferentialMember>('/payment_delays'),
+            fetchAll<ReferentialMember>('/payment_types'),
+            fetchAll<ReferentialMember>('/banks'),
+        ])
+
+        categories.value = cats.map(c => ({ value: c['@id'], label: c.name, code: c.code }))
+        sites.value = sitesList.map(s => ({ value: s['@id'], label: s.name }))
+        tvaModes.value = tva.map(t => ({ value: t['@id'], label: t.label }))
+        paymentDelays.value = delays.map(d => ({ value: d['@id'], label: d.label }))
+        paymentTypes.value = types.map(t => ({ value: t['@id'], label: t.label, code: t.code }))
+        banks.value = banksList.map(b => ({ value: b['@id'], label: b.label }))
+    }
+
+    /** Liste des clients pouvant etre choisis comme distributeur (code DISTRIBUTEUR). */
+    async function loadDistributors(): Promise<void> {
+        if (distributors.value.length > 0) {
+            return
+        }
+        const clients = await fetchAll<ClientMember>('/clients', { categoryCode: 'DISTRIBUTEUR' })
+        distributors.value = clients.map(c => ({ value: c['@id'], label: c.companyName }))
+    }
+
+    /** Liste des clients pouvant etre choisis comme courtier (code COURTIER). */
+    async function loadBrokers(): Promise<void> {
+        if (brokers.value.length > 0) {
+            return
+        }
+        const clients = await fetchAll<ClientMember>('/clients', { categoryCode: 'COURTIER' })
+        brokers.value = clients.map(c => ({ value: c['@id'], label: c.companyName }))
+    }
+
+    return {
+        categories,
+        sites,
+        tvaModes,
+        paymentDelays,
+        paymentTypes,
+        banks,
+        distributors,
+        brokers,
+        loadCommon,
+        loadDistributors,
+        loadBrokers,
+    }
+}

frontend/modules/commercial/composables/useClientsRepository.ts

@@ -0,0 +1,53 @@
+import { usePaginatedList } from '~/shared/composables/usePaginatedList'
+
+/**
+ * Site Starseed rattache a une adresse du client, tel qu'embarque en LISTE
+ * (groupe site:read) pour la colonne « Site(s) » du Repertoire (badges colores).
+ */
+export interface ClientSite {
+    id: number
+    name: string
+    color: string
+}
+
+/**
+ * Categorie rattachee au client, embarquee en LISTE (groupe category:read).
+ * Seul le `code` (stable, MAJUSCULE — ERP-78) est affiche dans la colonne
+ * « Catégories ». Les autres champs sont presents mais non utilises ici.
+ */
+export interface ClientCategory {
+    code: string
+    name?: string
+}
+
+/**
+ * Vue MINIMALE d'un client pour le Repertoire (datatable). Volontairement
+ * partielle : seuls les champs des colonnes + l'id (navigation) sont types ici.
+ * Le detail complet (onglets) est hors perimetre de cet ecran (ERP-62).
+ */
+export interface Client {
+    id: number
+    companyName: string
+    categories: ClientCategory[]
+    sites: ClientSite[]
+    /** Date ISO de derniere modification (default:read) — colonne « Dernière activité ». */
+    updatedAt: string | null
+    isArchived: boolean
+}
+
+/**
+ * Repertoire clients (ERP-62) — simple enveloppe de `usePaginatedList<Client>`
+ * sur la ressource `/clients` (RG-13 : pagination serveur obligatoire ; jamais
+ * de chargement integral en memoire).
+ *
+ * Les filtres (recherche, categories, sites, archives) sont pilotes par la page
+ * via `setFilters` du composable partage — la remise en page 1 est garantie.
+ *
+ * Volontairement PAR INSTANCE (pas de singleton module-level) : l'etat tableau
+ * est propre a l'ecran Repertoire et meurt avec lui, comme tout consommateur de
+ * `usePaginatedList` (cf. sites.vue / categories.vue). Aucun reset au logout a
+ * gerer.
+ */
+export function useClientsRepository() {
+    return usePaginatedList<Client>({ url: '/clients' })
+}

frontend/modules/commercial/pages/clients/index.vue

@@ -0,0 +1,421 @@
+<template>
+    <div>
+        <PageHeader>
+            {{ t('commercial.clients.title') }}
+            <template #actions>
+                <!-- gap-12 = 48px d'espacement entre Ajouter et Filtres. -->
+                <div class="flex items-center gap-12">
+                    <MalioButton
+                        v-if="canManage"
+                        variant="secondary"
+                        :label="t('commercial.clients.add')"
+                        icon-name="mdi:add-bold"
+                        icon-position="left"
+                        @click="goToCreate"
+                    />
+                    <!-- Bouton Filtres a DROITE d'Ajouter : meme design que
+                         l'audit-log. Le compteur reflete les filtres actifs. -->
+                    <MalioButton
+                        v-if="canView"
+                        variant="tertiary"
+                        :label="filterButtonLabel"
+                        icon-name="mdi:tune"
+                        icon-position="left"
+                        icon-size="24"
+                        button-class="w-[184px] justify-start gap-4 text-black"
+                        @click="openFilters"
+                    />
+                </div>
+            </template>
+        </PageHeader>
+
+        <!-- Datatable branchee sur usePaginatedList via useClientsRepository :
+             pagination serveur, tri companyName ASC par defaut (cote back). -->
+        <MalioDataTable
+            :columns="columns"
+            :items="rows"
+            :total-items="totalItems"
+            :page="currentPage"
+            :per-page="itemsPerPage"
+            :per-page-options="itemsPerPageOptions"
+            row-clickable
+            table-class="table-fixed"
+            :empty-message="t('commercial.clients.empty')"
+            @row-click="onRowClick"
+            @update:page="goToPage"
+            @update:per-page="setItemsPerPage"
+        >
+            <!-- Categories : codes stables separes par une virgule (ERP-78). -->
+            <template #cell-categories="{ item }">
+                {{ formatCategories(item) }}
+            </template>
+
+            <!-- Sites : badges colores (name + color), agreges des adresses. -->
+            <template #cell-sites="{ item }">
+                <span class="flex flex-wrap gap-1">
+                    <span
+                        v-for="site in (item.sites as ClientSite[])"
+                        :key="site.id"
+                        class="inline-flex items-center rounded-full px-2 py-0.5 text-xs font-medium text-white"
+                        :style="{ backgroundColor: site.color }"
+                    >
+                        {{ site.name }}
+                    </span>
+                </span>
+            </template>
+
+            <!-- Derniere activite : date de derniere modification (updatedAt). -->
+            <template #cell-lastActivity="{ item }">
+                {{ formatLastActivity(item) }}
+            </template>
+        </MalioDataTable>
+
+        <div class="flex justify-center mt-6">
+            <MalioButton
+                v-if="canView"
+                variant="primary"
+                :label="t('commercial.clients.export')"
+                :disabled="exporting"
+                @click="exportXlsx"
+            />
+        </div>
+
+        <!-- Drawer de filtres : etat BROUILLON, applique uniquement au clic sur
+             « Appliquer ». Meme pattern que l'audit-log. Etat 100 % local, jamais
+             dans l'URL (regle ABSOLUE n°6). -->
+        <MalioDrawer
+            v-model="filterDrawerOpen"
+            drawer-class="max-w-[450px]"
+            body-class="p-0"
+            footer-class="justify-between border-t border-black p-6"
+        >
+            <template #header>
+                <h2 class="text-[24px] font-bold uppercase">{{ t('commercial.clients.filters.title') }}</h2>
+            </template>
+
+            <MalioAccordion>
+                <!-- Recherche : nom societe + contact + email (param `search`). -->
+                <MalioAccordionItem :title="t('commercial.clients.filters.search')" value="search">
+                    <MalioInputText
+                        v-model="draftSearch"
+                        icon-name="mdi:magnify"
+                    />
+                </MalioAccordionItem>
+
+                <!-- Categories : cases a cocher (multi). Valeur = code stable. -->
+                <MalioAccordionItem :title="t('commercial.clients.filters.categories')" value="categories">
+                    <div class="flex flex-col">
+                        <MalioCheckbox
+                            v-for="opt in categoryOptions"
+                            :id="`filter-category-${opt.value}`"
+                            :key="opt.value"
+                            :label="opt.label"
+                            :model-value="draftCategoryCodes.includes(opt.value)"
+                            @update:model-value="(val: boolean) => toggleCategory(opt.value, val)"
+                        />
+                    </div>
+                </MalioAccordionItem>
+
+                <!-- Sites : cases a cocher (multi). Valeur = id du site. -->
+                <MalioAccordionItem :title="t('commercial.clients.filters.sites')" value="sites">
+                    <div class="flex flex-col">
+                        <MalioCheckbox
+                            v-for="opt in siteOptions"
+                            :id="`filter-site-${opt.value}`"
+                            :key="opt.value"
+                            :label="opt.label"
+                            :model-value="draftSiteIds.includes(opt.value)"
+                            @update:model-value="(val: boolean) => toggleSite(opt.value, val)"
+                        />
+                    </div>
+                </MalioAccordionItem>
+
+                <!-- Statut : bool unique. Coche = archives uniquement, sinon actifs. -->
+                <MalioAccordionItem :title="t('commercial.clients.filters.status')" value="status">
+                    <MalioCheckbox
+                        id="filter-archived-only"
+                        :label="t('commercial.clients.filters.archivedOnly')"
+                        :model-value="draftArchivedOnly"
+                        @update:model-value="(val: boolean) => draftArchivedOnly = val"
+                    />
+                </MalioAccordionItem>
+            </MalioAccordion>
+
+            <template #footer>
+                <MalioButton
+                    variant="tertiary"
+                    :label="t('commercial.clients.filters.reset')"
+                    button-class="w-m-btn-action"
+                    @click="resetFilters"
+                />
+                <MalioButton
+                    variant="primary"
+                    :label="t('commercial.clients.filters.apply')"
+                    button-class="w-[170px]"
+                    @click="applyFilters"
+                />
+            </template>
+        </MalioDrawer>
+    </div>
+</template>
+
+<script setup lang="ts">
+import { computed, onMounted, ref } from 'vue'
+import type { Client, ClientSite } from '~/modules/commercial/composables/useClientsRepository'
+
+interface FilterOption {
+    value: string
+    label: string
+}
+
+const { t } = useI18n()
+const api = useApi()
+const router = useRouter()
+const toast = useToast()
+const { can } = usePermissions()
+
+useHead({ title: t('commercial.clients.title') })
+
+// Bouton « Ajouter » reserve a `manage` (POST /clients garde manage seul →
+// Compta / Usine ne creent pas). « Exporter » et « Filtres » suivent `view`.
+const canManage = computed(() => can('commercial.clients.manage'))
+const canView = computed(() => can('commercial.clients.view'))
+
+const {
+    items: clients,
+    totalItems,
+    currentPage,
+    itemsPerPage,
+    itemsPerPageOptions,
+    fetch: loadClients,
+    goToPage,
+    setItemsPerPage,
+    setFilters,
+} = useClientsRepository()
+
+// Mappe les clients en objets « plats » pour MalioDataTable (items typees
+// Record<string, unknown>[]) : un objet litteral porte une signature d'index
+// implicite, contrairement a l'interface Client. Meme pattern que sites.vue.
+const rows = computed(() => clients.value.map(client => ({
+    id: client.id,
+    companyName: client.companyName,
+    categories: client.categories,
+    sites: client.sites,
+    updatedAt: client.updatedAt,
+})))
+
+const columns = [
+    { key: 'companyName', label: t('commercial.clients.column.companyName') },
+    { key: 'categories', label: t('commercial.clients.column.categories') },
+    { key: 'sites', label: t('commercial.clients.column.sites') },
+    { key: 'lastActivity', label: t('commercial.clients.column.lastActivity') },
+]
+
+/** Codes des categories du client, separes par une virgule (ERP-78). */
+function formatCategories(item: Record<string, unknown>): string {
+    const categories = (item.categories as Client['categories']) ?? []
+    return categories.map(c => c.code).join(', ')
+}
+
+/**
+ * Derniere activite : faute de suivi d'activite metier au M1, on affiche la
+ * date de derniere modification de la fiche (updatedAt, expose en liste via
+ * default:read). Format court francais jj/mm/aaaa.
+ */
+function formatLastActivity(item: Record<string, unknown>): string {
+    const value = item.updatedAt as string | null | undefined
+    if (!value) {
+        return ''
+    }
+
+    // Garde-fou date invalide : un updatedAt mal forme donnerait « Invalid Date ».
+    const date = new Date(value)
+    if (Number.isNaN(date.getTime())) {
+        return ''
+    }
+
+    return date.toLocaleDateString('fr-FR')
+}
+
+/** Clic sur une ligne → ecran Consultation (route a plat /clients/{id}). */
+function onRowClick(item: Record<string, unknown>): void {
+    router.push(`/clients/${item.id}`)
+}
+
+function goToCreate(): void {
+    router.push('/clients/new')
+}
+
+// ── Filtres (drawer) ────────────────────────────────────────────────────────
+// Deux niveaux d'etat (pattern audit-log) :
+//  - APPLIED : pilote la liste/l'export + le compteur du bouton. Modifie
+//    uniquement au clic « Appliquer » / « Réinitialiser ».
+//  - DRAFT : edite librement dans le drawer ; recopie vers applied a la validation.
+const filterDrawerOpen = ref(false)
+
+const draftSearch = ref('')
+const draftCategoryCodes = ref<string[]>([])
+const draftSiteIds = ref<string[]>([])
+const draftArchivedOnly = ref(false)
+
+const appliedSearch = ref('')
+const appliedCategoryCodes = ref<string[]>([])
+const appliedSiteIds = ref<string[]>([])
+const appliedArchivedOnly = ref(false)
+
+// Options des selects multi, chargees une fois (referentiels courts).
+const categoryOptions = ref<FilterOption[]>([])
+const siteOptions = ref<FilterOption[]>([])
+
+const activeFilterCount = computed(() => {
+    let count = 0
+    if (appliedSearch.value.trim() !== '') count++
+    if (appliedCategoryCodes.value.length > 0) count++
+    if (appliedSiteIds.value.length > 0) count++
+    if (appliedArchivedOnly.value) count++
+    return count
+})
+
+const filterButtonLabel = computed(() => {
+    const base = t('commercial.clients.filters.title')
+    return activeFilterCount.value > 0 ? `${base} (${activeFilterCount.value})` : base
+})
+
+// Recopie l'etat applique vers le brouillon puis ouvre le drawer : la
+// reouverture reflete les filtres actifs.
+function openFilters(): void {
+    draftSearch.value = appliedSearch.value
+    draftCategoryCodes.value = [...appliedCategoryCodes.value]
+    draftSiteIds.value = [...appliedSiteIds.value]
+    draftArchivedOnly.value = appliedArchivedOnly.value
+    filterDrawerOpen.value = true
+}
+
+function toggleCategory(code: string, selected: boolean): void {
+    draftCategoryCodes.value = selected
+        ? [...draftCategoryCodes.value, code]
+        : draftCategoryCodes.value.filter(c => c !== code)
+}
+
+function toggleSite(id: string, selected: boolean): void {
+    draftSiteIds.value = selected
+        ? [...draftSiteIds.value, id]
+        : draftSiteIds.value.filter(s => s !== id)
+}
+
+/**
+ * Construit le payload de filtres serveur a partir de l'etat applique. Cles
+ * `categoryCode[]` / `siteId[]` pour que PHP les parse en tableaux (OR cote back).
+ * Les filtres vides sont omis pour une query propre.
+ */
+function buildFilterPayload(): Record<string, string | string[] | boolean> {
+    const payload: Record<string, string | string[] | boolean> = {}
+    if (appliedSearch.value.trim() !== '') payload.search = appliedSearch.value.trim()
+    if (appliedCategoryCodes.value.length > 0) payload['categoryCode[]'] = [...appliedCategoryCodes.value]
+    if (appliedSiteIds.value.length > 0) payload['siteId[]'] = [...appliedSiteIds.value]
+    if (appliedArchivedOnly.value) payload.archivedOnly = true
+    return payload
+}
+
+// « Appliquer » : recopie brouillon → applied, pousse les filtres (retombe en
+// page 1 via usePaginatedList) et ferme le drawer.
+function applyFilters(): void {
+    appliedSearch.value = draftSearch.value.trim()
+    appliedCategoryCodes.value = [...draftCategoryCodes.value]
+    appliedSiteIds.value = [...draftSiteIds.value]
+    appliedArchivedOnly.value = draftArchivedOnly.value
+
+    setFilters(buildFilterPayload(), { replace: true })
+    filterDrawerOpen.value = false
+}
+
+// « Réinitialiser » : vide brouillon ET applied, recharge la liste complete.
+// Le drawer reste ouvert pour montrer le formulaire vide.
+function resetFilters(): void {
+    draftSearch.value = ''
+    draftCategoryCodes.value = []
+    draftSiteIds.value = []
+    draftArchivedOnly.value = false
+
+    appliedSearch.value = ''
+    appliedCategoryCodes.value = []
+    appliedSiteIds.value = []
+    appliedArchivedOnly.value = false
+
+    setFilters({}, { replace: true })
+}
+
+/** Charge les referentiels du drawer (categories + sites) via ?pagination=false. */
+async function loadFilterOptions(): Promise<void> {
+    const [cats, sites] = await Promise.all([
+        api.get<{ member?: Array<{ code: string, name: string }> }>(
+            '/categories',
+            { pagination: 'false' },
+            { headers: { Accept: 'application/ld+json' }, toast: false },
+        ),
+        api.get<{ member?: Array<{ id: number, name: string }> }>(
+            '/sites',
+            { pagination: 'false' },
+            { headers: { Accept: 'application/ld+json' }, toast: false },
+        ),
+    ])
+
+    categoryOptions.value = (cats.member ?? []).map(c => ({ value: c.code, label: c.name }))
+    siteOptions.value = (sites.member ?? []).map(s => ({ value: String(s.id), label: s.name }))
+}
+
+// ── Export XLSX ─────────────────────────────────────────────────────────────
+// Memes filtres que la vue. La colonne SIREN n'est dans le fichier que si
+// l'utilisateur a accounting.view (gere cote back).
+const exporting = ref(false)
+
+async function exportXlsx(): Promise<void> {
+    if (exporting.value) {
+        return
+    }
+    exporting.value = true
+    try {
+        // useApi type ses options en JSON ; l'export renvoie un binaire, donc on
+        // force responseType:'blob' (transmis tel quel a ofetch au runtime). Cast
+        // contenu faute d'overload blob sur le client partage — a generaliser via
+        // un ticket dedie si d'autres exports binaires arrivent.
+        const blob = await api.get<Blob>('/clients/export.xlsx', buildFilterPayload(), {
+            responseType: 'blob',
+            toast: false,
+        } as unknown as Parameters<typeof api.get>[2])
+
+        triggerDownload(blob, 'repertoire-clients.xlsx')
+    }
+    catch {
+        toast.error({
+            title: t('commercial.clients.toast.error'),
+            message: t('commercial.clients.toast.exportError'),
+        })
+    }
+    finally {
+        exporting.value = false
+    }
+}
+
+/** Declenche le telechargement d'un blob via un lien temporaire. */
+function triggerDownload(blob: Blob, filename: string): void {
+    const url = URL.createObjectURL(blob)
+    const link = document.createElement('a')
+    link.href = url
+    link.download = filename
+    document.body.appendChild(link)
+    link.click()
+    link.remove()
+    URL.revokeObjectURL(url)
+}
+
+onMounted(() => {
+    loadClients()
+    // Echec du chargement des referentiels non bloquant : la liste s'affiche,
+    // l'utilisateur perd juste les options de filtre.
+    loadFilterOptions().catch(() => {
+        categoryOptions.value = []
+        siteOptions.value = []
+    })
+})
+</script>

frontend/modules/commercial/pages/clients/new.vue

@@ -0,0 +1,891 @@
+<template>
+    <div>
+        <PageHeader>{{ t('commercial.clients.form.title') }}</PageHeader>
+
+        <!-- ── Formulaire principal (pre-onglets) ─────────────────────────────
+             Sans validation de ce bloc, les onglets restent inaccessibles. Au
+             succes du POST, les champs passent en lecture seule et on bascule
+             automatiquement sur l'onglet Information. -->
+        <section class="mb-8 rounded-md border border-neutral-200 bg-white p-6">
+            <div class="grid grid-cols-1 gap-4 md:grid-cols-2">
+                <MalioInputText
+                    v-model="main.companyName"
+                    :label="t('commercial.clients.form.main.companyName')"
+                    :required="true"
+                    :readonly="mainLocked"
+                />
+                <MalioInputEmail
+                    v-model="main.email"
+                    :label="t('commercial.clients.form.main.email')"
+                    :required="true"
+                    :readonly="mainLocked"
+                />
+                <MalioInputText
+                    v-model="main.lastName"
+                    :label="t('commercial.clients.form.main.lastName')"
+                    :readonly="mainLocked"
+                />
+                <MalioInputText
+                    v-model="main.firstName"
+                    :label="t('commercial.clients.form.main.firstName')"
+                    :readonly="mainLocked"
+                />
+                <MalioInputPhone
+                    v-model="main.phonePrimary"
+                    :label="t('commercial.clients.form.main.phonePrimary')"
+                    :mask="PHONE_MASK"
+                    :required="true"
+                    :readonly="mainLocked"
+                    :addable="!main.hasSecondaryPhone && !mainLocked"
+                    :add-button-label="t('commercial.clients.form.main.addPhone')"
+                    @add="main.hasSecondaryPhone = true"
+                />
+                <MalioInputPhone
+                    v-if="main.hasSecondaryPhone"
+                    v-model="main.phoneSecondary"
+                    :label="t('commercial.clients.form.main.phoneSecondary')"
+                    :mask="PHONE_MASK"
+                    :readonly="mainLocked"
+                />
+                <MalioSelectCheckbox
+                    :model-value="main.categoryIris"
+                    :options="referentials.categories.value"
+                    :label="t('commercial.clients.form.main.categories')"
+                    :display-tag="true"
+                    :disabled="mainLocked"
+                    @update:model-value="(v: (string | number)[]) => main.categoryIris = v.map(String)"
+                />
+                <MalioSelect
+                    :model-value="main.relationType"
+                    :options="relationOptions"
+                    :label="t('commercial.clients.form.main.relation')"
+                    :disabled="mainLocked"
+                    @update:model-value="onRelationChange"
+                />
+                <MalioSelect
+                    v-if="main.relationType === 'distributeur'"
+                    :model-value="main.distributorIri"
+                    :options="referentials.distributors.value"
+                    :label="t('commercial.clients.form.main.distributorName')"
+                    :disabled="mainLocked"
+                    @update:model-value="(v: string | number | null) => main.distributorIri = v === null ? null : String(v)"
+                />
+                <MalioSelect
+                    v-if="main.relationType === 'courtier'"
+                    :model-value="main.brokerIri"
+                    :options="referentials.brokers.value"
+                    :label="t('commercial.clients.form.main.brokerName')"
+                    :disabled="mainLocked"
+                    @update:model-value="(v: string | number | null) => main.brokerIri = v === null ? null : String(v)"
+                />
+            </div>
+
+            <div class="mt-4 flex items-center gap-6">
+                <MalioCheckbox
+                    v-model="main.triageService"
+                    :label="t('commercial.clients.form.main.triageService')"
+                    :readonly="mainLocked"
+                />
+                <MalioButton
+                    v-if="!mainLocked"
+                    class="ml-auto"
+                    variant="primary"
+                    :label="t('commercial.clients.form.submit')"
+                    :disabled="!isMainValid || mainSubmitting"
+                    @click="submitMain"
+                />
+            </div>
+        </section>
+
+        <!-- ── Onglets a validation incrementale ─────────────────────────────-->
+        <MalioTabList v-model="activeTab" :tabs="tabs">
+            <!-- Onglet Information -->
+            <template #information>
+                <div class="rounded-md border border-neutral-200 bg-white p-6">
+                    <div class="grid grid-cols-1 gap-4 md:grid-cols-2">
+                        <MalioInputTextArea
+                            v-model="information.description"
+                            :label="t('commercial.clients.form.information.description')"
+                            :disabled="isValidated('information')"
+                            group-class="md:col-span-2"
+                        />
+                        <MalioInputText
+                            v-model="information.competitors"
+                            :label="t('commercial.clients.form.information.competitors')"
+                            :readonly="isValidated('information')"
+                        />
+                        <MalioDate
+                            v-model="information.foundedAt"
+                            :label="t('commercial.clients.form.information.foundedAt')"
+                            :readonly="isValidated('information')"
+                        />
+                        <MalioInputNumber
+                            v-model="information.employeesCount"
+                            :label="t('commercial.clients.form.information.employeesCount')"
+                            min="0"
+                            :disabled="isValidated('information')"
+                        />
+                        <MalioInputText
+                            v-model="information.directorName"
+                            :label="t('commercial.clients.form.information.directorName')"
+                            :readonly="isValidated('information')"
+                        />
+                        <MalioInputAmount
+                            v-model="information.revenueAmount"
+                            :label="t('commercial.clients.form.information.revenueAmount')"
+                            :disabled="isValidated('information')"
+                        />
+                        <MalioInputAmount
+                            v-model="information.profitAmount"
+                            :label="t('commercial.clients.form.information.profitAmount')"
+                            :disabled="isValidated('information')"
+                        />
+                    </div>
+                    <div v-if="!isValidated('information')" class="mt-4 flex justify-end">
+                        <MalioButton
+                            variant="primary"
+                            :label="t('commercial.clients.form.submit')"
+                            :disabled="tabSubmitting"
+                            @click="submitInformation"
+                        />
+                    </div>
+                </div>
+            </template>
+
+            <!-- Onglet Contact -->
+            <template #contact>
+                <div class="flex flex-col gap-4">
+                    <ClientContactBlock
+                        v-for="(contact, index) in contacts"
+                        :key="index"
+                        :model-value="contact"
+                        :title="t('commercial.clients.form.contact.title', { n: index + 1 })"
+                        :removable="index > 0"
+                        :readonly="isValidated('contact')"
+                        @update:model-value="(v) => contacts[index] = v"
+                        @remove="askRemoveContact(index)"
+                    />
+                    <div v-if="!isValidated('contact')" class="flex items-center justify-between">
+                        <MalioButton
+                            variant="secondary"
+                            icon-name="mdi:plus"
+                            icon-position="left"
+                            :label="t('commercial.clients.form.contact.add')"
+                            :disabled="!canAddContact"
+                            @click="addContact"
+                        />
+                        <MalioButton
+                            variant="primary"
+                            :label="t('commercial.clients.form.submit')"
+                            :disabled="!canValidateContacts || tabSubmitting"
+                            @click="submitContacts"
+                        />
+                    </div>
+                </div>
+            </template>
+
+            <!-- Onglet Adresse -->
+            <template #address>
+                <div class="flex flex-col gap-4">
+                    <ClientAddressBlock
+                        v-for="(address, index) in addresses"
+                        :key="index"
+                        :model-value="address"
+                        :title="t('commercial.clients.form.address.title', { n: index + 1 })"
+                        :category-options="addressCategoryOptions"
+                        :site-options="referentials.sites.value"
+                        :contact-options="contactOptions"
+                        :country-options="countryOptions"
+                        :removable="index > 0"
+                        :readonly="isValidated('address')"
+                        @update:model-value="(v) => addresses[index] = v"
+                        @remove="askRemoveAddress(index)"
+                        @degraded="onAddressDegraded"
+                    />
+                    <div v-if="!isValidated('address')" class="flex items-center justify-between">
+                        <MalioButton
+                            variant="secondary"
+                            icon-name="mdi:plus"
+                            icon-position="left"
+                            :label="t('commercial.clients.form.address.add')"
+                            @click="addAddress"
+                        />
+                        <MalioButton
+                            variant="primary"
+                            :label="t('commercial.clients.form.submit')"
+                            :disabled="!canValidateAddresses || tabSubmitting"
+                            @click="submitAddresses"
+                        />
+                    </div>
+                </div>
+            </template>
+
+            <!-- Onglet Comptabilite (present uniquement si accounting.view) -->
+            <template v-if="canAccountingView" #accounting>
+                <div class="flex flex-col gap-4">
+                    <div class="rounded-md border border-neutral-200 bg-white p-6">
+                        <div class="grid grid-cols-1 gap-4 md:grid-cols-2">
+                            <MalioInputText
+                                v-model="accounting.siren"
+                                :label="t('commercial.clients.form.accounting.siren')"
+                                :mask="SIREN_MASK"
+                                :readonly="accountingReadonly"
+                            />
+                            <MalioInputText
+                                v-model="accounting.accountNumber"
+                                :label="t('commercial.clients.form.accounting.accountNumber')"
+                                :readonly="accountingReadonly"
+                            />
+                            <MalioSelect
+                                :model-value="accounting.tvaModeIri"
+                                :options="referentials.tvaModes.value"
+                                :label="t('commercial.clients.form.accounting.tvaMode')"
+                                :disabled="accountingReadonly"
+                                empty-option-label=""
+                                @update:model-value="(v: string | number | null) => accounting.tvaModeIri = v === null ? null : String(v)"
+                            />
+                            <MalioInputText
+                                v-model="accounting.nTva"
+                                :label="t('commercial.clients.form.accounting.nTva')"
+                                :readonly="accountingReadonly"
+                            />
+                            <MalioSelect
+                                :model-value="accounting.paymentDelayIri"
+                                :options="referentials.paymentDelays.value"
+                                :label="t('commercial.clients.form.accounting.paymentDelay')"
+                                :disabled="accountingReadonly"
+                                empty-option-label=""
+                                @update:model-value="(v: string | number | null) => accounting.paymentDelayIri = v === null ? null : String(v)"
+                            />
+                            <MalioSelect
+                                :model-value="accounting.paymentTypeIri"
+                                :options="referentials.paymentTypes.value"
+                                :label="t('commercial.clients.form.accounting.paymentType')"
+                                :disabled="accountingReadonly"
+                                empty-option-label=""
+                                @update:model-value="onPaymentTypeChange"
+                            />
+                            <MalioSelect
+                                v-if="isBankRequired"
+                                :model-value="accounting.bankIri"
+                                :options="referentials.banks.value"
+                                :label="t('commercial.clients.form.accounting.bank')"
+                                :disabled="accountingReadonly"
+                                empty-option-label=""
+                                @update:model-value="(v: string | number | null) => accounting.bankIri = v === null ? null : String(v)"
+                            />
+                        </div>
+                    </div>
+
+                    <!-- Blocs RIB (0..n) — obligatoires si type de reglement = LCR. -->
+                    <div
+                        v-for="(rib, index) in ribs"
+                        :key="index"
+                        class="rounded-md border border-neutral-200 bg-white p-6"
+                    >
+                        <div class="mb-4 flex items-center justify-between">
+                            <h3 class="text-lg font-bold">{{ t('commercial.clients.form.accounting.ribTitle', { n: index + 1 }) }}</h3>
+                            <!-- ariaLabel via v-bind objet (prop camelCase ; aria-* serait un attribut HTML). -->
+                            <MalioButtonIcon
+                                v-if="!accountingReadonly"
+                                icon="mdi:trash-can-outline"
+                                variant="ghost"
+                                v-bind="{ ariaLabel: t('commercial.clients.form.accounting.removeRib') }"
+                                @click="askRemoveRib(index)"
+                            />
+                        </div>
+                        <div class="grid grid-cols-1 gap-4 md:grid-cols-3">
+                            <MalioInputText
+                                v-model="rib.label"
+                                :label="t('commercial.clients.form.accounting.ribLabel')"
+                                :readonly="accountingReadonly"
+                            />
+                            <MalioInputText
+                                v-model="rib.bic"
+                                :label="t('commercial.clients.form.accounting.ribBic')"
+                                :readonly="accountingReadonly"
+                            />
+                            <MalioInputText
+                                v-model="rib.iban"
+                                :label="t('commercial.clients.form.accounting.ribIban')"
+                                :readonly="accountingReadonly"
+                            />
+                        </div>
+                    </div>
+
+                    <div v-if="!accountingReadonly" class="flex items-center justify-between">
+                        <MalioButton
+                            variant="secondary"
+                            icon-name="mdi:plus"
+                            icon-position="left"
+                            :label="t('commercial.clients.form.accounting.addRib')"
+                            @click="addRib"
+                        />
+                        <MalioButton
+                            variant="primary"
+                            :label="t('commercial.clients.form.submit')"
+                            :disabled="!canValidateAccounting || tabSubmitting"
+                            @click="submitAccounting"
+                        />
+                    </div>
+                </div>
+            </template>
+
+            <!-- Onglets non encore implementes : frame vide, passage automatique. -->
+            <template #transport><TabPlaceholderBlank /></template>
+            <template #statistics><TabPlaceholderBlank /></template>
+            <template #reports><TabPlaceholderBlank /></template>
+            <template #exchanges><TabPlaceholderBlank /></template>
+        </MalioTabList>
+
+        <!-- Modal de confirmation generique (suppression contact/adresse/RIB). -->
+        <MalioModal v-model="confirmModal.open" modal-class="max-w-md">
+            <template #header>
+                <h2 class="text-[24px] font-bold">{{ t('commercial.clients.form.confirmDelete.title') }}</h2>
+            </template>
+            <p>{{ confirmModal.message }}</p>
+            <template #footer>
+                <MalioButton
+                    variant="secondary"
+                    button-class="flex-1"
+                    :label="t('commercial.clients.form.confirmDelete.cancel')"
+                    @click="confirmModal.open = false"
+                />
+                <MalioButton
+                    variant="danger"
+                    button-class="flex-1"
+                    :label="t('commercial.clients.form.confirmDelete.confirm')"
+                    @click="runConfirm"
+                />
+            </template>
+        </MalioModal>
+    </div>
+</template>
+
+<script setup lang="ts">
+import { computed, onMounted, reactive, ref, watch } from 'vue'
+import { useClientReferentials, type RefOption } from '~/modules/commercial/composables/useClientReferentials'
+import {
+    buildClientFormTabKeys,
+    CLIENT_FORM_PLACEHOLDER_TABS,
+    hasAtLeastOneValidContact,
+    isBankRequiredForPaymentType,
+    isBillingEmailRequired,
+    isContactNamed,
+    isRibRequiredForPaymentType,
+} from '~/modules/commercial/utils/clientFormRules'
+import {
+    emptyAddress,
+    emptyContact,
+    emptyRib,
+    type AddressFormDraft,
+    type ContactFormDraft,
+    type RibFormDraft,
+} from '~/modules/commercial/types/clientForm'
+import { formatPhoneFR } from '~/shared/utils/phone'
+
+// Masques de saisie (la normalisation finale reste serveur).
+const PHONE_MASK = '## ## ## ## ##'
+const SIREN_MASK = '#########'
+
+// Codes de categorie interdits sur une adresse (RG-1.29, ERP-78).
+const FORBIDDEN_ADDRESS_CATEGORY_CODES = ['DISTRIBUTEUR', 'COURTIER']
+
+const { t } = useI18n()
+const api = useApi()
+const toast = useToast()
+const { can } = usePermissions()
+
+useHead({ title: t('commercial.clients.form.title') })
+
+// Gating de la route : la creation est reservee a `manage`. Compta (accounting
+// seul) et Usine sont rediriges vers le repertoire (cf. §0 du ticket).
+if (!can('commercial.clients.manage')) {
+    await navigateTo('/clients')
+}
+
+const canAccountingView = computed(() => can('commercial.clients.accounting.view'))
+const canAccountingManage = computed(() => can('commercial.clients.accounting.manage'))
+
+const referentials = useClientReferentials()
+
+// ── Etat du client cree ────────────────────────────────────────────────────
+const clientId = ref<number | null>(null)
+const mainLocked = ref(false)
+const mainSubmitting = ref(false)
+const tabSubmitting = ref(false)
+
+// ── Formulaire principal ────────────────────────────────────────────────────
+const main = reactive({
+    companyName: null as string | null,
+    firstName: null as string | null,
+    lastName: null as string | null,
+    email: null as string | null,
+    phonePrimary: null as string | null,
+    phoneSecondary: null as string | null,
+    hasSecondaryPhone: false,
+    categoryIris: [] as string[],
+    relationType: 'aucun' as 'aucun' | 'distributeur' | 'courtier',
+    distributorIri: null as string | null,
+    brokerIri: null as string | null,
+    triageService: false,
+})
+
+const relationOptions = computed<RefOption[]>(() => [
+    { value: 'aucun', label: t('commercial.clients.form.main.relationNone') },
+    { value: 'distributeur', label: t('commercial.clients.form.main.relationDistributor') },
+    { value: 'courtier', label: t('commercial.clients.form.main.relationBroker') },
+])
+
+// RG-1.01 : firstName OU lastName, + companyName / email / phonePrimary requis.
+const isMainValid = computed(() => {
+    const filled = (v: string | null) => v !== null && v.trim() !== ''
+    return filled(main.companyName)
+        && filled(main.email)
+        && filled(main.phonePrimary)
+        && (filled(main.firstName) || filled(main.lastName))
+})
+
+async function onRelationChange(value: string | number | null): Promise<void> {
+    const relation = String(value ?? 'aucun') as typeof main.relationType
+    main.relationType = relation
+    // Reinitialise la FK non concernee (une seule remplie a la fois, RG-1.03).
+    if (relation !== 'distributeur') main.distributorIri = null
+    if (relation !== 'courtier') main.brokerIri = null
+
+    if (relation === 'distributeur') await referentials.loadDistributors()
+    if (relation === 'courtier') await referentials.loadBrokers()
+}
+
+/** POST /clients (groupe client:write:main). Au succes : verrouille + bascule Information. */
+async function submitMain(): Promise<void> {
+    if (!isMainValid.value || mainSubmitting.value) return
+    mainSubmitting.value = true
+    try {
+        const payload: Record<string, unknown> = {
+            companyName: main.companyName,
+            firstName: main.firstName || null,
+            lastName: main.lastName || null,
+            email: main.email,
+            phonePrimary: main.phonePrimary,
+            phoneSecondary: main.hasSecondaryPhone ? (main.phoneSecondary || null) : null,
+            categories: main.categoryIris,
+            distributor: main.relationType === 'distributeur' ? main.distributorIri : null,
+            broker: main.relationType === 'courtier' ? main.brokerIri : null,
+            triageService: main.triageService,
+        }
+        const created = await api.post<ClientResponse>('/clients', payload, {
+            headers: { Accept: 'application/ld+json' },
+            toast: false,
+        })
+
+        clientId.value = created.id
+        // Reaffiche les valeurs normalisees renvoyees par le serveur.
+        main.companyName = created.companyName ?? main.companyName
+        main.firstName = created.firstName ?? null
+        main.lastName = created.lastName ?? null
+        main.email = created.email ?? main.email
+        main.phonePrimary = formatPhoneFR(created.phonePrimary) || main.phonePrimary
+        main.phoneSecondary = formatPhoneFR(created.phoneSecondary) || null
+
+        // Pre-remplit le 1er contact a partir du formulaire principal (editable).
+        prefillFirstContact()
+
+        mainLocked.value = true
+        unlockedIndex.value = 0
+        activeTab.value = 'information'
+        toast.success({ title: t('commercial.clients.toast.createSuccess') })
+    }
+    catch (error) {
+        // 409 = doublon nom de societe (RG d'unicite) → message explicite.
+        const status = (error as { response?: { status?: number } })?.response?.status
+        toast.error({
+            title: t('commercial.clients.toast.error'),
+            message: status === 409 ? t('commercial.clients.form.duplicateCompany') : undefined,
+        })
+    }
+    finally {
+        mainSubmitting.value = false
+    }
+}
+
+// ── Onglets : ordre + gating progressif ─────────────────────────────────────
+const activeTab = ref('information')
+// Index du dernier onglet deverrouille (-1 tant que le client n'est pas cree).
+const unlockedIndex = ref(-1)
+// Onglets valides (passent en lecture seule).
+const validated = reactive<Record<string, boolean>>({})
+
+const tabKeys = computed(() => buildClientFormTabKeys(canAccountingView.value))
+
+const tabs = computed(() => tabKeys.value.map((key, index) => ({
+    key,
+    label: t(`commercial.clients.tab.${key}`),
+    disabled: index > unlockedIndex.value,
+})))
+
+function isValidated(key: string): boolean {
+    return validated[key] === true
+}
+
+function tabIndex(key: string): number {
+    return tabKeys.value.indexOf(key)
+}
+
+/** Marque l'onglet valide, deverrouille et avance automatiquement au suivant. */
+function completeTab(key: string): void {
+    validated[key] = true
+    const next = tabKeys.value[tabIndex(key) + 1]
+    unlockedIndex.value = Math.max(unlockedIndex.value, tabIndex(key) + 1)
+    if (next) activeTab.value = next
+}
+
+// Passage automatique sur les onglets coquille (Transport, Stats, Rapports, Echanges).
+watch(activeTab, (key) => {
+    if ((CLIENT_FORM_PLACEHOLDER_TABS as readonly string[]).includes(key)) {
+        const next = tabKeys.value[tabIndex(key) + 1]
+        unlockedIndex.value = Math.max(unlockedIndex.value, tabIndex(key) + 1)
+        if (next) activeTab.value = next
+    }
+})
+
+// ── Onglet Information ──────────────────────────────────────────────────────
+const information = reactive({
+    description: null as string | null,
+    competitors: null as string | null,
+    foundedAt: null as string | null,
+    employeesCount: null as string | null,
+    revenueAmount: null as string | null,
+    profitAmount: null as string | null,
+    directorName: null as string | null,
+})
+
+/** PATCH /clients/{id} — mode strict : uniquement les champs du groupe information. */
+async function submitInformation(): Promise<void> {
+    if (clientId.value === null || tabSubmitting.value) return
+    tabSubmitting.value = true
+    try {
+        await api.patch(`/clients/${clientId.value}`, {
+            description: information.description || null,
+            competitors: information.competitors || null,
+            foundedAt: information.foundedAt || null,
+            employeesCount: information.employeesCount ? Number(information.employeesCount) : null,
+            revenueAmount: information.revenueAmount || null,
+            profitAmount: information.profitAmount || null,
+            directorName: information.directorName || null,
+        }, { toast: false })
+        completeTab('information')
+        toast.success({ title: t('commercial.clients.toast.updateSuccess') })
+    }
+    catch {
+        toast.error({ title: t('commercial.clients.toast.error') })
+    }
+    finally {
+        tabSubmitting.value = false
+    }
+}
+
+// ── Onglet Contact ──────────────────────────────────────────────────────────
+const contacts = ref<ContactFormDraft[]>([emptyContact()])
+
+/** Pre-remplit le 1er contact depuis le formulaire principal (apres creation). */
+function prefillFirstContact(): void {
+    const first = contacts.value[0]
+    if (!first) return
+    first.lastName = main.lastName
+    first.firstName = main.firstName
+    first.email = main.email
+    first.phonePrimary = main.phonePrimary
+}
+
+// « + Nouveau contact » desactive tant que le dernier bloc n'a ni nom ni prenom.
+const canAddContact = computed(() => {
+    const last = contacts.value[contacts.value.length - 1]
+    return last !== undefined && isContactNamed(last)
+})
+
+// RG-1.14 : au moins un contact nomme pour finaliser l'onglet.
+const canValidateContacts = computed(() => hasAtLeastOneValidContact(contacts.value))
+
+function addContact(): void {
+    if (canAddContact.value) contacts.value.push(emptyContact())
+}
+
+function askRemoveContact(index: number): void {
+    askConfirm(t('commercial.clients.form.confirmDelete.contact'), () => {
+        contacts.value.splice(index, 1)
+    })
+}
+
+/** POST/PATCH des contacts sur la sous-ressource /clients/{id}/contacts. */
+async function submitContacts(): Promise<void> {
+    if (clientId.value === null || !canValidateContacts.value || tabSubmitting.value) return
+    tabSubmitting.value = true
+    try {
+        for (const contact of contacts.value) {
+            // On ignore les blocs totalement vides (ni nom ni prenom).
+            if (!isContactNamed(contact)) continue
+
+            const body = {
+                firstName: contact.firstName || null,
+                lastName: contact.lastName || null,
+                jobTitle: contact.jobTitle || null,
+                phonePrimary: contact.phonePrimary || null,
+                phoneSecondary: contact.hasSecondaryPhone ? (contact.phoneSecondary || null) : null,
+                email: contact.email || null,
+            }
+
+            if (contact.id === null) {
+                const created = await api.post<ContactResponse>(
+                    `/clients/${clientId.value}/contacts`,
+                    body,
+                    { headers: { Accept: 'application/ld+json' }, toast: false },
+                )
+                contact.id = created.id
+                contact.iri = created['@id'] ?? null
+            }
+            else {
+                await api.patch(`/client_contacts/${contact.id}`, body, { toast: false })
+            }
+        }
+        completeTab('contact')
+        toast.success({ title: t('commercial.clients.toast.updateSuccess') })
+    }
+    catch {
+        toast.error({ title: t('commercial.clients.toast.error') })
+    }
+    finally {
+        tabSubmitting.value = false
+    }
+}
+
+// ── Onglet Adresse ──────────────────────────────────────────────────────────
+const addresses = ref<AddressFormDraft[]>([emptyAddress()])
+const addressDegradedNotified = ref(false)
+
+// Categories autorisees sur une adresse : toutes SAUF DISTRIBUTEUR/COURTIER (RG-1.29).
+const addressCategoryOptions = computed(() =>
+    referentials.categories.value.filter(c => !FORBIDDEN_ADDRESS_CATEGORY_CODES.includes(c.code)),
+)
+
+// Contacts deja crees, rattachables a une adresse (M2M, via leur IRI).
+const contactOptions = computed<RefOption[]>(() =>
+    contacts.value
+        .filter(c => c.iri !== null)
+        .map(c => ({
+            value: c.iri as string,
+            label: [c.firstName, c.lastName].filter(Boolean).join(' ') || (c.email ?? ''),
+        })),
+)
+
+// France par defaut au M1 (liste pays minimale ; a etendre quand le besoin viendra).
+const countryOptions: RefOption[] = [{ value: 'France', label: 'France' }]
+
+// RG-1.10 (>= 1 site) + RG-1.11 (email facturation si Facturation) sur chaque adresse.
+const canValidateAddresses = computed(() =>
+    addresses.value.length > 0
+    && addresses.value.every((a) => {
+        const filledBillingEmail = a.billingEmail !== null && a.billingEmail.trim() !== ''
+        return a.siteIris.length >= 1 && (!isBillingEmailRequired(a) || filledBillingEmail)
+    }),
+)
+
+function addAddress(): void {
+    addresses.value.push(emptyAddress())
+}
+
+function askRemoveAddress(index: number): void {
+    askConfirm(t('commercial.clients.form.confirmDelete.address'), () => {
+        addresses.value.splice(index, 1)
+    })
+}
+
+/** Avertit une seule fois quand l'autocompletion d'adresse bascule en degrade. */
+function onAddressDegraded(): void {
+    if (addressDegradedNotified.value) return
+    addressDegradedNotified.value = true
+    toast.warning({
+        title: t('commercial.clients.toast.error'),
+        message: t('commercial.clients.form.address.degraded'),
+    })
+}
+
+/** POST des adresses sur la sous-ressource /clients/{id}/addresses. */
+async function submitAddresses(): Promise<void> {
+    if (clientId.value === null || !canValidateAddresses.value || tabSubmitting.value) return
+    tabSubmitting.value = true
+    try {
+        for (const address of addresses.value) {
+            const body = {
+                isProspect: address.isProspect,
+                isDelivery: address.isDelivery,
+                isBilling: address.isBilling,
+                country: address.country,
+                postalCode: address.postalCode || null,
+                city: address.city || null,
+                street: address.street || null,
+                streetComplement: address.streetComplement || null,
+                categories: address.categoryIris,
+                sites: address.siteIris,
+                contacts: address.contactIris,
+                billingEmail: isBillingEmailRequired(address) ? (address.billingEmail || null) : null,
+            }
+
+            if (address.id === null) {
+                const created = await api.post<{ id: number }>(
+                    `/clients/${clientId.value}/addresses`,
+                    body,
+                    { headers: { Accept: 'application/ld+json' }, toast: false },
+                )
+                address.id = created.id
+            }
+            else {
+                await api.patch(`/client_addresses/${address.id}`, body, { toast: false })
+            }
+        }
+        completeTab('address')
+        toast.success({ title: t('commercial.clients.toast.updateSuccess') })
+    }
+    catch {
+        toast.error({ title: t('commercial.clients.toast.error') })
+    }
+    finally {
+        tabSubmitting.value = false
+    }
+}
+
+// ── Onglet Comptabilite ─────────────────────────────────────────────────────
+const accounting = reactive({
+    siren: null as string | null,
+    accountNumber: null as string | null,
+    tvaModeIri: null as string | null,
+    nTva: null as string | null,
+    paymentDelayIri: null as string | null,
+    paymentTypeIri: null as string | null,
+    bankIri: null as string | null,
+})
+const ribs = ref<RibFormDraft[]>([])
+
+// L'onglet est editable seulement avec accounting.manage (sinon lecture seule).
+const accountingReadonly = computed(() => isValidated('accounting') || !canAccountingManage.value)
+
+// Code du type de reglement selectionne (pour RG-1.12 / RG-1.13).
+const selectedPaymentTypeCode = computed(() =>
+    referentials.paymentTypes.value.find(p => p.value === accounting.paymentTypeIri)?.code ?? null,
+)
+const isBankRequired = computed(() => isBankRequiredForPaymentType(selectedPaymentTypeCode.value))
+const isRibRequired = computed(() => isRibRequiredForPaymentType(selectedPaymentTypeCode.value))
+
+function onPaymentTypeChange(value: string | number | null): void {
+    accounting.paymentTypeIri = value === null ? null : String(value)
+    // La banque n'a de sens que pour un virement : on la vide sinon (RG-1.12).
+    if (!isBankRequired.value) accounting.bankIri = null
+}
+
+function ribIsComplete(rib: RibFormDraft): boolean {
+    const filled = (v: string | null) => v !== null && v.trim() !== ''
+    return filled(rib.label) && filled(rib.bic) && filled(rib.iban)
+}
+
+// RG-1.12 : banque requise si VIREMENT. RG-1.13 : >= 1 RIB complet si LCR.
+const canValidateAccounting = computed(() => {
+    if (isBankRequired.value && (accounting.bankIri === null)) return false
+    if (isRibRequired.value && !ribs.value.some(ribIsComplete)) return false
+    return true
+})
+
+function addRib(): void {
+    ribs.value.push(emptyRib())
+}
+
+function askRemoveRib(index: number): void {
+    askConfirm(t('commercial.clients.form.confirmDelete.rib'), () => {
+        ribs.value.splice(index, 1)
+    })
+}
+
+/**
+ * Valide l'onglet Comptabilite : PATCH des scalaires (groupe client:write:accounting)
+ * PUIS POST des RIB sur /clients/{id}/ribs. Deux appels distincts (mode strict
+ * RG-1.28 : il n'existe pas d'endpoint /accounting, cf. recon back).
+ */
+async function submitAccounting(): Promise<void> {
+    if (clientId.value === null || !canValidateAccounting.value || tabSubmitting.value) return
+    tabSubmitting.value = true
+    try {
+        await api.patch(`/clients/${clientId.value}`, {
+            siren: accounting.siren || null,
+            accountNumber: accounting.accountNumber || null,
+            tvaMode: accounting.tvaModeIri,
+            nTva: accounting.nTva || null,
+            paymentDelay: accounting.paymentDelayIri,
+            paymentType: accounting.paymentTypeIri,
+            bank: isBankRequired.value ? accounting.bankIri : null,
+        }, { toast: false })
+
+        for (const rib of ribs.value) {
+            if (!ribIsComplete(rib)) continue
+            if (rib.id === null) {
+                const created = await api.post<{ id: number }>(
+                    `/clients/${clientId.value}/ribs`,
+                    { label: rib.label, bic: rib.bic, iban: rib.iban },
+                    { headers: { Accept: 'application/ld+json' }, toast: false },
+                )
+                rib.id = created.id
+            }
+            else {
+                await api.patch(`/client_ribs/${rib.id}`, { label: rib.label, bic: rib.bic, iban: rib.iban }, { toast: false })
+            }
+        }
+
+        completeTab('accounting')
+        toast.success({ title: t('commercial.clients.toast.updateSuccess') })
+    }
+    catch {
+        toast.error({ title: t('commercial.clients.toast.error') })
+    }
+    finally {
+        tabSubmitting.value = false
+    }
+}
+
+// ── Modal de confirmation generique ─────────────────────────────────────────
+const confirmModal = reactive({
+    open: false,
+    message: '',
+    action: null as null | (() => void),
+})
+
+function askConfirm(message: string, action: () => void): void {
+    confirmModal.message = message
+    confirmModal.action = action
+    confirmModal.open = true
+}
+
+function runConfirm(): void {
+    confirmModal.action?.()
+    confirmModal.action = null
+    confirmModal.open = false
+}
+
+// ── Types de reponse API ────────────────────────────────────────────────────
+interface ClientResponse {
+    id: number
+    companyName: string | null
+    firstName: string | null
+    lastName: string | null
+    email: string | null
+    phonePrimary: string | null
+    phoneSecondary: string | null
+}
+
+interface ContactResponse {
+    '@id'?: string
+    id: number
+}
+
+onMounted(() => {
+    // Echec du chargement des referentiels non bloquant : les selects restent vides.
+    referentials.loadCommon().catch(() => {})
+})
+</script>

frontend/modules/commercial/types/clientForm.ts

@@ -0,0 +1,98 @@
+/**
+ * Types « brouillon » de l'ecran « Ajouter un client » (M1 Commercial).
+ *
+ * Ces interfaces decrivent l'etat LOCAL du formulaire (refs Vue), distinct des
+ * DTO de l'API : elles portent en plus des champs purement UI (`hasSecondaryPhone`)
+ * et l'`iri` Hydra des entites creees (necessaire pour rattacher une adresse a
+ * des contacts deja persistes, M2M). Partage par la page et les blocs reutilisables
+ * `ClientContactBlock` / `ClientAddressBlock` (reutilises par 1.11/1.12).
+ */
+
+/** Un contact du client (onglet Contact). */
+export interface ContactFormDraft {
+    /** Id serveur une fois le contact cree (null tant que non persiste). */
+    id: number | null
+    /** IRI Hydra du contact cree — utilise pour le rattachement M2M cote adresse. */
+    iri: string | null
+    firstName: string | null
+    lastName: string | null
+    jobTitle: string | null
+    phonePrimary: string | null
+    phoneSecondary: string | null
+    email: string | null
+    /** UI : le 2e numero a ete revele via le bouton « + ». */
+    hasSecondaryPhone: boolean
+}
+
+/** Une adresse du client (onglet Adresse). */
+export interface AddressFormDraft {
+    id: number | null
+    isProspect: boolean
+    isDelivery: boolean
+    isBilling: boolean
+    country: string
+    postalCode: string | null
+    city: string | null
+    street: string | null
+    streetComplement: string | null
+    /** IRI des categories rattachees (hors DISTRIBUTEUR/COURTIER — RG-1.29). */
+    categoryIris: string[]
+    /** IRI des sites Starseed rattaches (>= 1 obligatoire — RG-1.10). */
+    siteIris: string[]
+    /** IRI des contacts rattaches (= blocs Contact deja crees). */
+    contactIris: string[]
+    /** Email de facturation (obligatoire si isBilling — RG-1.11). */
+    billingEmail: string | null
+}
+
+/** Un RIB du client (onglet Comptabilite). */
+export interface RibFormDraft {
+    id: number | null
+    label: string | null
+    bic: string | null
+    iban: string | null
+}
+
+/** Fabrique un contact vierge. */
+export function emptyContact(): ContactFormDraft {
+    return {
+        id: null,
+        iri: null,
+        firstName: null,
+        lastName: null,
+        jobTitle: null,
+        phonePrimary: null,
+        phoneSecondary: null,
+        email: null,
+        hasSecondaryPhone: false,
+    }
+}
+
+/** Fabrique une adresse vierge (pays prerempli « France »). */
+export function emptyAddress(): AddressFormDraft {
+    return {
+        id: null,
+        isProspect: false,
+        isDelivery: false,
+        isBilling: false,
+        country: 'France',
+        postalCode: null,
+        city: null,
+        street: null,
+        streetComplement: null,
+        categoryIris: [],
+        siteIris: [],
+        contactIris: [],
+        billingEmail: null,
+    }
+}
+
+/** Fabrique un RIB vierge. */
+export function emptyRib(): RibFormDraft {
+    return {
+        id: null,
+        label: null,
+        bic: null,
+        iban: null,
+    }
+}

frontend/modules/commercial/utils/__tests__/clientFormRules.spec.ts

@@ -0,0 +1,144 @@
+import { describe, it, expect } from 'vitest'
+import {
+    applyProspectExclusivity,
+    buildClientFormTabKeys,
+    canSelectDeliveryOrBilling,
+    canSelectProspect,
+    hasAtLeastOneValidContact,
+    isBankRequiredForPaymentType,
+    isBillingEmailRequired,
+    isContactNamed,
+    isRibRequiredForPaymentType,
+    type ContactDraft,
+} from '../clientFormRules'
+
+describe('buildClientFormTabKeys (gating onglet Comptabilite)', () => {
+    it('inclut l onglet accounting si l utilisateur a accounting.view', () => {
+        expect(buildClientFormTabKeys(true)).toContain('accounting')
+    })
+
+    it('exclut l onglet accounting sinon (Bureau / Commerciale)', () => {
+        expect(buildClientFormTabKeys(false)).not.toContain('accounting')
+    })
+
+    it('place accounting entre transport et statistics quand present', () => {
+        const keys = buildClientFormTabKeys(true)
+        expect(keys).toEqual([
+            'information',
+            'contact',
+            'address',
+            'transport',
+            'accounting',
+            'statistics',
+            'reports',
+            'exchanges',
+        ])
+    })
+})
+
+describe('isContactNamed (RG-1.05)', () => {
+    it('vrai si le prenom est renseigne', () => {
+        expect(isContactNamed({ firstName: 'Alice', lastName: null })).toBe(true)
+    })
+
+    it('vrai si le nom est renseigne', () => {
+        expect(isContactNamed({ firstName: null, lastName: 'Martin' })).toBe(true)
+    })
+
+    it('faux si les deux sont vides ou espaces uniquement', () => {
+        expect(isContactNamed({ firstName: null, lastName: null })).toBe(false)
+        expect(isContactNamed({ firstName: '  ', lastName: '' })).toBe(false)
+    })
+})
+
+describe('hasAtLeastOneValidContact (RG-1.14)', () => {
+    it('faux sur une liste vide', () => {
+        expect(hasAtLeastOneValidContact([])).toBe(false)
+    })
+
+    it('faux si aucun contact n a de nom ni prenom', () => {
+        const contacts: ContactDraft[] = [
+            { firstName: null, lastName: null },
+            { firstName: '', lastName: '  ' },
+        ]
+        expect(hasAtLeastOneValidContact(contacts)).toBe(false)
+    })
+
+    it('vrai des qu un contact a un nom ou un prenom', () => {
+        const contacts: ContactDraft[] = [
+            { firstName: null, lastName: null },
+            { firstName: 'Bob', lastName: null },
+        ]
+        expect(hasAtLeastOneValidContact(contacts)).toBe(true)
+    })
+})
+
+describe('exclusivite Prospect / Livraison / Facturation (RG-1.06/07/08)', () => {
+    it('Prospect est selectionnable tant que ni Livraison ni Facturation', () => {
+        expect(canSelectProspect({ isProspect: false, isDelivery: false, isBilling: false })).toBe(true)
+        expect(canSelectProspect({ isProspect: false, isDelivery: true, isBilling: false })).toBe(false)
+        expect(canSelectProspect({ isProspect: false, isDelivery: false, isBilling: true })).toBe(false)
+    })
+
+    it('Livraison / Facturation selectionnables tant que pas Prospect', () => {
+        expect(canSelectDeliveryOrBilling({ isProspect: false, isDelivery: false, isBilling: false })).toBe(true)
+        expect(canSelectDeliveryOrBilling({ isProspect: true, isDelivery: false, isBilling: false })).toBe(false)
+    })
+
+    it('cocher Prospect efface Livraison et Facturation', () => {
+        const next = applyProspectExclusivity(
+            { isProspect: false, isDelivery: true, isBilling: true },
+            'isProspect',
+            true,
+        )
+        expect(next).toEqual({ isProspect: true, isDelivery: false, isBilling: false })
+    })
+
+    it('cocher Livraison efface Prospect', () => {
+        const next = applyProspectExclusivity(
+            { isProspect: true, isDelivery: false, isBilling: false },
+            'isDelivery',
+            true,
+        )
+        expect(next).toEqual({ isProspect: false, isDelivery: true, isBilling: false })
+    })
+
+    it('cocher Facturation efface Prospect mais conserve Livraison', () => {
+        const next = applyProspectExclusivity(
+            { isProspect: true, isDelivery: true, isBilling: false },
+            'isBilling',
+            true,
+        )
+        expect(next).toEqual({ isProspect: false, isDelivery: true, isBilling: true })
+    })
+
+    it('decocher un drapeau ne reactive rien d autre', () => {
+        const next = applyProspectExclusivity(
+            { isProspect: false, isDelivery: true, isBilling: true },
+            'isBilling',
+            false,
+        )
+        expect(next).toEqual({ isProspect: false, isDelivery: true, isBilling: false })
+    })
+})
+
+describe('isBillingEmailRequired (RG-1.11)', () => {
+    it('obligatoire uniquement si Facturation est coche', () => {
+        expect(isBillingEmailRequired({ isProspect: false, isDelivery: false, isBilling: true })).toBe(true)
+        expect(isBillingEmailRequired({ isProspect: false, isDelivery: true, isBilling: false })).toBe(false)
+    })
+})
+
+describe('regles type de reglement (RG-1.12 / RG-1.13)', () => {
+    it('banque obligatoire si VIREMENT', () => {
+        expect(isBankRequiredForPaymentType('VIREMENT')).toBe(true)
+        expect(isBankRequiredForPaymentType('LCR')).toBe(false)
+        expect(isBankRequiredForPaymentType(null)).toBe(false)
+    })
+
+    it('RIB obligatoire si LCR', () => {
+        expect(isRibRequiredForPaymentType('LCR')).toBe(true)
+        expect(isRibRequiredForPaymentType('VIREMENT')).toBe(false)
+        expect(isRibRequiredForPaymentType(null)).toBe(false)
+    })
+})

frontend/modules/commercial/utils/clientFormRules.ts

@@ -0,0 +1,143 @@
+/**
+ * Regles metier pures de l'ecran « Ajouter un client » (M1 Commercial).
+ *
+ * Centralisees ici (hors composant) pour rester testables unitairement et
+ * partagees entre la page de creation et les futurs ecrans d'edition (1.11/1.12).
+ * Ces helpers ne touchent ni a l'API ni a l'etat reactif : ils prennent des
+ * brouillons « plats » et retournent des booleens / nouveaux objets.
+ *
+ * Le back reste la source de verite (les RG sont re-validees serveur) ; ces
+ * regles ne servent qu'au feedback UI immediat (gating de boutons, visibilite).
+ *
+ * NOTE RG-1.04 (Information obligatoire pour la Commerciale) : volontairement
+ * NON miroite cote front pour l'instant. Le payload /api/me ne porte pas le code
+ * de role (roles = IRIs opaques) et Bureau partage les memes permissions que
+ * Commerciale : aucun signal fiable pour distinguer le role cote front. Le back
+ * (ClientProcessor, via BusinessRoleAware) applique la regle de maniere fiable ;
+ * a rebrancher ici des qu'un code de role sera expose dans /api/me.
+ */
+
+/**
+ * Onglets « coquille » (non encore implementes) : frame vide, passage
+ * automatique a l'onglet suivant (decision Tristan 28/05).
+ */
+export const CLIENT_FORM_PLACEHOLDER_TABS = ['transport', 'statistics', 'reports', 'exchanges'] as const
+
+/**
+ * Construit l'ordre des onglets de l'ecran « Ajouter un client ». L'onglet
+ * Comptabilite n'est present que si l'utilisateur a `accounting.view` — sinon il
+ * est totalement absent (Bureau / Commerciale ne le voient pas). Ordre aligne
+ * sur la spec M1 § Ecran « Ajouter un client ».
+ */
+export function buildClientFormTabKeys(canAccountingView: boolean): string[] {
+    const keys = ['information', 'contact', 'address', 'transport']
+    if (canAccountingView) {
+        keys.push('accounting')
+    }
+    keys.push('statistics', 'reports', 'exchanges')
+    return keys
+}
+
+/** Sous-ensemble d'un contact necessaire aux regles de nommage (RG-1.05/1.14). */
+export interface ContactDraft {
+    firstName: string | null
+    lastName: string | null
+}
+
+/** Drapeaux d'usage d'une adresse (RG-1.06/07/08/11). */
+export interface AddressFlagsDraft {
+    isProspect: boolean
+    isDelivery: boolean
+    isBilling: boolean
+}
+
+/** Vrai si une chaine porte au moins un caractere non-espace. */
+function isFilled(value: string | null | undefined): boolean {
+    return value !== null && value !== undefined && value.trim() !== ''
+}
+
+/**
+ * RG-1.05 : un contact est valide des qu'il porte un nom OU un prenom.
+ */
+export function isContactNamed(contact: ContactDraft): boolean {
+    return isFilled(contact.firstName) || isFilled(contact.lastName)
+}
+
+/**
+ * RG-1.14 : l'onglet Contact ne peut etre finalise que s'il reste au moins un
+ * contact nomme (nom ou prenom).
+ */
+export function hasAtLeastOneValidContact(contacts: ContactDraft[]): boolean {
+    return contacts.some(isContactNamed)
+}
+
+/**
+ * RG-1.06/07/08 : une adresse de prospection est exclusive d'une adresse de
+ * livraison/facturation. Prospect n'est selectionnable que si ni Livraison ni
+ * Facturation ne sont coches.
+ */
+export function canSelectProspect(flags: AddressFlagsDraft): boolean {
+    return !flags.isDelivery && !flags.isBilling
+}
+
+/**
+ * RG-1.06/07/08 : Livraison et Facturation ne sont selectionnables que si
+ * Prospect n'est pas coche.
+ */
+export function canSelectDeliveryOrBilling(flags: AddressFlagsDraft): boolean {
+    return !flags.isProspect
+}
+
+/**
+ * Applique l'exclusivite Prospect / (Livraison|Facturation) au changement d'un
+ * drapeau. Cocher Prospect efface Livraison + Facturation ; cocher Livraison ou
+ * Facturation efface Prospect. Decocher n'a aucun effet de bord. Retourne un
+ * nouvel objet (pas de mutation de l'entree).
+ */
+export function applyProspectExclusivity(
+    flags: AddressFlagsDraft,
+    field: keyof AddressFlagsDraft,
+    value: boolean,
+): AddressFlagsDraft {
+    const next: AddressFlagsDraft = { ...flags, [field]: value }
+
+    if (value && field === 'isProspect') {
+        next.isDelivery = false
+        next.isBilling = false
+    }
+    else if (value && (field === 'isDelivery' || field === 'isBilling')) {
+        next.isProspect = false
+    }
+
+    return next
+}
+
+/**
+ * RG-1.11 : l'email de facturation n'est visible/obligatoire que si l'adresse
+ * est une adresse de facturation.
+ */
+export function isBillingEmailRequired(flags: AddressFlagsDraft): boolean {
+    return flags.isBilling
+}
+
+/** Code stable du type de reglement « virement » (cf. PaymentType.code, RG-1.12). */
+const PAYMENT_TYPE_TRANSFER = 'VIREMENT'
+
+/** Code stable du type de reglement « lettre de change » (RG-1.13). */
+const PAYMENT_TYPE_LCR = 'LCR'
+
+/**
+ * RG-1.12 : la banque est obligatoire lorsque le type de reglement est un
+ * virement.
+ */
+export function isBankRequiredForPaymentType(code: string | null | undefined): boolean {
+    return code === PAYMENT_TYPE_TRANSFER
+}
+
+/**
+ * RG-1.13 : au moins un RIB complet est obligatoire lorsque le type de reglement
+ * est une LCR.
+ */
+export function isRibRequiredForPaymentType(code: string | null | undefined): boolean {
+    return code === PAYMENT_TYPE_LCR
+}

frontend/shared/composables/useAddressAutocomplete.ts

@@ -0,0 +1,60 @@
+// STUB ERP-63 — remplacé par l'implémentation BAN d'ERP-66.
+//
+// Ce fichier appartient fonctionnellement à ERP-66 (#66). ERP-63 n'en livre
+// qu'un STUB pour ne pas se bloquer : la vraie implémentation (appels
+// api-adresse.data.gouv.fr) viendra remplacer le CORPS des deux méthodes SANS
+// changer leur signature ni l'usage côté composant.
+//
+// Contrat figé par ERP-66 (c'est lui qui fait foi) :
+//   searchCity(postalCode)       -> liste { city, postalCode }
+//   searchAddress(query, cp?)    -> liste { label, street, postalCode, city }
+//   En cas d'erreur/timeout, la méthode THROW. Le composant catch l'erreur,
+//   affiche un toast d'avertissement et bascule en saisie libre (MalioInputText).
+//
+// Comportement du stub : les deux méthodes throw systématiquement → l'onglet
+// Adresse part directement en mode dégradé (Ville + Adresse en saisie libre,
+// Code postal saisi manuellement). Aucun appel réseau n'est émis ici.
+
+/** Une suggestion de ville renvoyée à partir d'un code postal. */
+export interface CitySuggestion {
+    city: string
+    postalCode: string
+}
+
+/** Une suggestion d'adresse complète (saisie assistée du champ « Adresse »). */
+export interface AddressSuggestion {
+    label: string
+    street: string
+    postalCode: string
+    city: string
+}
+
+export interface AddressAutocomplete {
+    searchCity(postalCode: string): Promise<CitySuggestion[]>
+    searchAddress(query: string, postalCode?: string): Promise<AddressSuggestion[]>
+}
+
+/** Erreur signalant que le service d'autocomplétion BAN n'est pas disponible. */
+export class AddressAutocompleteUnavailableError extends Error {
+    constructor() {
+        // Message technique (non affiché tel quel) : le composant remonte son
+        // propre libellé i18n. Sert au debug / aux logs uniquement.
+        super('Address autocomplete (BAN) is not available yet — ERP-66 stub.')
+        this.name = 'AddressAutocompleteUnavailableError'
+    }
+}
+
+/**
+ * STUB : renvoie un composable conforme au contrat ERP-66 dont les méthodes
+ * échouent toujours, forçant le mode dégradé côté onglet Adresse.
+ */
+export function useAddressAutocomplete(): AddressAutocomplete {
+    return {
+        async searchCity(_postalCode: string): Promise<CitySuggestion[]> {
+            throw new AddressAutocompleteUnavailableError()
+        },
+        async searchAddress(_query: string, _postalCode?: string): Promise<AddressSuggestion[]> {
+            throw new AddressAutocompleteUnavailableError()
+        },
+    }
+}

frontend/shared/utils/__tests__/phone.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest'
+import { formatPhoneFR } from '../phone'
+
+describe('formatPhoneFR', () => {
+    it('formate un numero 10 chiffres en XX XX XX XX XX', () => {
+        expect(formatPhoneFR('0612345678')).toBe('06 12 34 56 78')
+    })
+
+    it('tolere une saisie deja pointee ou espacee', () => {
+        expect(formatPhoneFR('06.12.34.56.78')).toBe('06 12 34 56 78')
+        expect(formatPhoneFR('06 12 34 56 78')).toBe('06 12 34 56 78')
+    })
+
+    it('retourne une chaine vide pour une valeur vide ou nulle', () => {
+        expect(formatPhoneFR('')).toBe('')
+        expect(formatPhoneFR(null)).toBe('')
+        expect(formatPhoneFR(undefined)).toBe('')
+    })
+
+    it('groupe par 2 meme un nombre impair de chiffres (dernier groupe seul)', () => {
+        expect(formatPhoneFR('123')).toBe('12 3')
+    })
+})

frontend/shared/utils/phone.ts

@@ -0,0 +1,23 @@
+/**
+ * Formatage d'un numero de telephone francais en groupes de 2 chiffres
+ * (`XX XX XX XX XX`).
+ *
+ * Helper PARTAGE volontaire : les telephones sont presents un peu partout dans
+ * l'app (fiches clients, contacts, fournisseurs, prestataires...). Introduit ici
+ * comme util transverse stable plutot que duplique a chaque ecran. La signature
+ * `formatPhoneFR(value): string` est coordonnee avec ERP-66, qui pourra enrichir
+ * l'implementation (validation, indicatif international) sans casser les appelants.
+ *
+ * - Ne garde que les chiffres puis groupe par 2 (tolere une saisie deja espacee
+ *   ou pointee, ex: `06.12.34.56.78` ou `0612345678`).
+ * - Retourne une chaine vide si la valeur est vide/nulle (cellule vide propre).
+ */
+export function formatPhoneFR(value: string | null | undefined): string {
+    const digits = (value ?? '').replace(/\D/g, '')
+    if (digits.length === 0) {
+        return ''
+    }
+
+    // Groupe par paquets de 2 ; un dernier groupe impair reste tel quel.
+    return digits.match(/.{1,2}/g)?.join(' ') ?? digits
+}

makefile

@@ -208,6 +208,8 @@ migration-migrate:
 #     exprimables via les attributs Doctrine ORM (fonctionnel + partiel), donc
 #     ils disparaissent apres schema:update. On les recree par dbal:run-sql :
 #       - `uq_category_name_type_active` (M0 Catalog) : tests RG-1.07.
+#       - `uq_category_code` (Catalog ERP-78) : unicite du code categorie parmi
+#         les actifs (slug du nom), pilote RG-1.03/1.29.
 #       - `uq_client_company_name_active` (M1 Commercial) : unicite nom societe
 #         parmi actifs non archives/non supprimes (RG-1.16), tests ERP-55.
 #     Sans ces restores, les POST doublons remontent 201 au lieu de 409.
@@ -225,6 +227,7 @@ test-db-setup:
 	$(SYMFONY_CONSOLE) --env=test --no-interaction app:sync-permissions
 	$(SYMFONY_CONSOLE) --env=test --no-interaction app:seed-rbac
 	$(SYMFONY_CONSOLE) --env=test dbal:run-sql "CREATE UNIQUE INDEX IF NOT EXISTS uq_category_name_type_active ON category (LOWER(name), category_type_id) WHERE deleted_at IS NULL"
+	$(SYMFONY_CONSOLE) --env=test dbal:run-sql "CREATE UNIQUE INDEX IF NOT EXISTS uq_category_code ON category (code) WHERE deleted_at IS NULL"
 	$(SYMFONY_CONSOLE) --env=test dbal:run-sql "CREATE UNIQUE INDEX IF NOT EXISTS uq_client_company_name_active ON client (LOWER(company_name)) WHERE is_archived = FALSE AND deleted_at IS NULL"
 
 fixtures:

migrations/Version20260528120000.php

@@ -39,20 +39,40 @@ final class Version20260528120000 extends AbstractMigration
 
     public function up(Schema $schema): void
     {
-        // Ne commente que les tables deja presentes a ce stade de la chaine de
-        // migrations. Les modules crees plus tard (ex: M1 Commercial, 06-01)
-        // figurent desormais dans le catalogue partage mais leurs tables
-        // n'existent pas encore ici : elles posent leurs propres COMMENT dans
-        // leur migration dediee (regle ABSOLUE n°12). Garde-fou indispensable,
-        // sinon l'ajout d'un module au catalogue casse ce retrofit avec un
-        // "relation X does not exist".
-        $existingTables = array_values(array_filter(
-            array_keys(ColumnCommentsCatalog::comments()),
-            static fn (string $table): bool => $schema->hasTable($table),
-        ));
+        // Ne commente que les tables ET colonnes deja presentes a ce stade de la
+        // chaine de migrations. Les tables des modules crees plus tard (M1
+        // Commercial, 06-01) ET les colonnes ajoutees ensuite sur une table
+        // existante (ex: category.code, ERP-78 06-02) figurent desormais dans le
+        // catalogue partage mais n'existent pas encore ici : elles posent leur
+        // propre COMMENT dans leur migration dediee (regle ABSOLUE n°12). Garde-fou
+        // indispensable (table + colonne), sinon enrichir le catalogue casse ce
+        // retrofit avec un "relation/column X does not exist".
+        foreach (ColumnCommentsCatalog::comments() as $table => $entries) {
+            if (!$schema->hasTable($table)) {
+                continue;
+            }
 
-        foreach (ColumnCommentsCatalog::toSqlStatements($existingTables) as $sql) {
-            $this->addSql($sql);
+            $dbTable     = $schema->getTable($table);
+            $quotedTable = '"'.str_replace('"', '""', $table).'"';
+
+            foreach ($entries as $column => $description) {
+                if ('_table' === $column) {
+                    $this->addSql(sprintf('COMMENT ON TABLE %s IS $_$%s$_$', $quotedTable, $description));
+
+                    continue;
+                }
+
+                if (!$dbTable->hasColumn($column)) {
+                    continue;
+                }
+
+                $this->addSql(sprintf(
+                    'COMMENT ON COLUMN %s.%s IS $_$%s$_$',
+                    $quotedTable,
+                    '"'.str_replace('"', '""', $column).'"',
+                    $description,
+                ));
+            }
         }
     }
 

migrations/Version20260602100000.php

@@ -0,0 +1,189 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DoctrineMigrations;
+
+use App\Shared\Infrastructure\Database\CategoryCodeSql;
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+/**
+ * ERP-78 — Refonte de la taxonomie Categories (M0/M1).
+ *
+ * Modele AVANT (merge via Version20260527164000 + Version20260601000000) :
+ * DISTRIBUTEUR / COURTIER / SECTEUR / AUTRE sont des `category_type`.
+ *
+ * Modele APRES (decision produit 01/06) :
+ *  - UN SEUL `category_type` : CLIENT (code CLIENT, label « Client ») ;
+ *  - Distributeur / Courtier / Secteur / Autre (+ categories metier fines)
+ *    deviennent des `Category` rattachees au type CLIENT ;
+ *  - filtrage metier sur un `code` stable porte par la `Category` (et non plus
+ *    par le type) : on reporte les codes DISTRIBUTEUR / COURTIER sur la categorie
+ *    correspondante. RG-1.03 (distributor/broker) et RG-1.29 (categorie interdite
+ *    sur adresse) s'appuient desormais sur `category.code`.
+ *
+ * Migration CORRECTIVE et NOUVELLE : la migration mergee Version20260601000000
+ * (qui a pu tourner en CI / chez d'autres devs) n'est PAS editee.
+ *
+ * Namespace racine `DoctrineMigrations` (regle ABSOLUE n°11) et NON modulaire
+ * Catalog : avec plusieurs migrations_paths, Doctrine Migrations 3.x trie par
+ * FQCN alphabetique (AlphabeticalComparator). Introduire la 1re migration
+ * modulaire `App\Module\Catalog\...` la ferait trier AVANT toutes les
+ * `DoctrineMigrations\...` sur base vide -> elle s'executerait avant la creation
+ * des tables et le seed dont elle depend. Le namespace racine garantit l'ordre
+ * par timestamp.
+ *
+ * Idempotence : `ADD COLUMN IF NOT EXISTS`, `INSERT ... ON CONFLICT` / guards
+ * `NOT EXISTS`, `CREATE UNIQUE INDEX IF NOT EXISTS`. En prod la table `category`
+ * est vide (aucune fixture metier) : l'ajout de `code NOT NULL` est sur. En
+ * dev/test, le purger Doctrine vide `category`/`category_type` avant les
+ * fixtures, qui reproduisent le meme etat final (cf. CategoryTypeFixtures /
+ * CategoryFixtures).
+ */
+final class Version20260602100000 extends AbstractMigration
+{
+    /**
+     * Categories systeme reportees depuis les anciens types : nom => code.
+     * Le code est la cle metier stable (RG-1.03 / RG-1.29).
+     */
+    private const array SYSTEM_CATEGORIES = [
+        'Distributeur' => 'DISTRIBUTEUR',
+        'Courtier'     => 'COURTIER',
+        'Secteur'      => 'SECTEUR',
+        'Autre'        => 'AUTRE',
+    ];
+
+    /** Anciens codes de `category_type` devenus inutiles. */
+    private const array LEGACY_TYPE_CODES = ['DISTRIBUTEUR', 'COURTIER', 'SECTEUR', 'AUTRE'];
+
+    public function getDescription(): string
+    {
+        return 'ERP-78 : Category.code + type unique CLIENT (categories Distributeur/Courtier/Secteur/Autre codees, anciens types supprimes).';
+    }
+
+    public function up(Schema $schema): void
+    {
+        // 1. Colonne `code` (nullable d'abord pour pouvoir backfiller, NOT NULL ensuite).
+        $this->addSql('ALTER TABLE category ADD COLUMN IF NOT EXISTS code VARCHAR(50) DEFAULT NULL');
+
+        // 2. Type unique CLIENT (idempotent via l'index unique uq_category_type_code).
+        $this->addSql(<<<'SQL'
+            INSERT INTO category_type (code, label) VALUES ('CLIENT', 'Client')
+            ON CONFLICT (code) DO NOTHING
+            SQL);
+
+        // 3. Re-pointer toute categorie pre-existante (rattachee a un ancien type)
+        //    vers le type CLIENT, en lui donnant un code derive du nom si absent.
+        //    En prod la table est vide -> no-op ; defensif pour les envs qui
+        //    auraient deja seede des categories sous les anciens types. Le slug
+        //    SQL est le miroir EXACT de CategoryCodeGenerator::slugify (cf.
+        //    CategoryCodeSql + CategoryCodeSqlSlugTest) : un nom accentue produit
+        //    le meme code que la generation applicative (« Independant » ->
+        //    INDEPENDANT, et non IND_PENDANT).
+        $this->addSql(
+            'UPDATE category c '
+            ."SET category_type_id = (SELECT id FROM category_type WHERE code = 'CLIENT'), "
+            .'code = COALESCE(c.code, '.CategoryCodeSql::slugExpression('c.name').') '
+            .'WHERE c.category_type_id IN (SELECT id FROM category_type WHERE code IN (:legacyCodes))',
+            ['legacyCodes' => self::LEGACY_TYPE_CODES],
+            ['legacyCodes' => \Doctrine\DBAL\ArrayParameterType::STRING],
+        );
+
+        // 4. Creer les 4 categories systeme sous CLIENT (si leur code est libre
+        //    parmi les actifs). created_at/updated_at NOT NULL -> now() ; le blame
+        //    reste null (seed hors contexte HTTP, libelle « Systeme » cote front).
+        foreach (self::SYSTEM_CATEGORIES as $name => $code) {
+            $this->addSql(<<<'SQL'
+                INSERT INTO category (name, code, category_type_id, created_at, updated_at)
+                SELECT :name, :code, ct.id, NOW(), NOW()
+                FROM category_type ct
+                WHERE ct.code = 'CLIENT'
+                  AND NOT EXISTS (
+                      SELECT 1 FROM category c WHERE c.code = :code AND c.deleted_at IS NULL
+                  )
+                SQL, ['name' => $name, 'code' => $code]);
+        }
+
+        // 5. Backfill defensif : toute categorie encore sans code recoit un slug
+        //    de son nom (garantit que le SET NOT NULL passe). Meme expression de
+        //    slug fidele au generateur applicatif (CategoryCodeSql).
+        $this->addSql(
+            'UPDATE category SET code = '.CategoryCodeSql::slugExpression('name').' WHERE code IS NULL',
+        );
+
+        // 6. Index unique partiel sur le code parmi les actifs (non exprimable en
+        //    ORM : recree aussi dans `test-db-setup` apres schema:update).
+        $this->addSql('CREATE UNIQUE INDEX IF NOT EXISTS uq_category_code ON category (code) WHERE deleted_at IS NULL');
+
+        // 7. Code desormais obligatoire.
+        $this->addSql('ALTER TABLE category ALTER COLUMN code SET NOT NULL');
+
+        // 8. Documentation SQL (regle ABSOLUE n°12). Dollar-quoting Postgres.
+        $this->addSql(<<<'SQL'
+            COMMENT ON COLUMN category.code IS $_$Code technique stable (slug MAJUSCULE du nom, <= 50) — unique parmi les actifs (uq_category_code). Fige a la creation. DISTRIBUTEUR/COURTIER pilotent RG-1.03/1.29.$_$
+            SQL);
+
+        // 9. Supprimer les anciens types devenus orphelins (aucune categorie ne
+        //    les reference plus apres le re-pointage de l'etape 3). Le guard
+        //    NOT EXISTS evite de casser sur la FK RESTRICT category.category_type_id.
+        $this->addSql(<<<'SQL'
+            DELETE FROM category_type
+            WHERE code IN (:legacyCodes)
+              AND NOT EXISTS (
+                  SELECT 1 FROM category c WHERE c.category_type_id = category_type.id
+              )
+            SQL, ['legacyCodes' => self::LEGACY_TYPE_CODES], ['legacyCodes' => \Doctrine\DBAL\ArrayParameterType::STRING]);
+
+        // 10. Realigner la doc SQL de client_address_category (migration mergee
+        //     Version20260601000000, non editable) sur le nouveau modele RG-1.29.
+        $this->addSql(<<<'SQL'
+            COMMENT ON TABLE client_address_category IS $_$Jointure M2M client_address <-> category — codes DISTRIBUTEUR/COURTIER interdits sur une adresse (RG-1.29).$_$
+            SQL);
+        $this->addSql(<<<'SQL'
+            COMMENT ON COLUMN client_address_category.category_id IS $_$FK -> category.id, ON DELETE RESTRICT — categorie d adresse (tout code sauf DISTRIBUTEUR/COURTIER, RG-1.29).$_$
+            SQL);
+    }
+
+    public function down(Schema $schema): void
+    {
+        // Best-effort : rollback du modele CLIENT vers les 4 anciens types.
+        // 1. Retirer l'index unique sur le code.
+        $this->addSql('DROP INDEX IF EXISTS uq_category_code');
+
+        // 2. Recreer les 4 anciens types.
+        $this->addSql(<<<'SQL'
+            INSERT INTO category_type (code, label) VALUES
+                ('DISTRIBUTEUR', 'Distributeur'),
+                ('COURTIER',     'Courtier'),
+                ('SECTEUR',      'Secteur'),
+                ('AUTRE',        'Autre')
+            ON CONFLICT (code) DO NOTHING
+            SQL);
+
+        // 3. Re-pointer les categories systeme (par code) vers leur type d'origine.
+        //    Codes inlines : constantes controlees (self::SYSTEM_CATEGORIES), pas
+        //    d'entree utilisateur — evite le binding d'un parametre nomme repete.
+        foreach (self::SYSTEM_CATEGORIES as $name => $code) {
+            $this->addSql(sprintf(
+                "UPDATE category SET category_type_id = (SELECT id FROM category_type WHERE code = '%s') WHERE code = '%s'",
+                $code,
+                $code,
+            ));
+        }
+
+        // 4. Supprimer le type CLIENT s'il ne reference plus aucune categorie.
+        $this->addSql(<<<'SQL'
+            DELETE FROM category_type
+            WHERE code = 'CLIENT'
+              AND NOT EXISTS (
+                  SELECT 1 FROM category c WHERE c.category_type_id = category_type.id
+              )
+            SQL);
+
+        // 5. Retirer la colonne code (les categories libres sans type d'origine
+        //    restent sous CLIENT si encore presentes — rollback uniquement
+        //    pertinent en prod ou seules les 4 categories systeme existent).
+        $this->addSql('ALTER TABLE category DROP COLUMN IF EXISTS code');
+    }
+}

src/Module/Catalog/Application/Service/CategoryCodeGenerator.php

@@ -0,0 +1,77 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Catalog\Application\Service;
+
+use App\Module\Catalog\Domain\Repository\CategoryRepositoryInterface;
+use Symfony\Component\String\Slugger\AsciiSlugger;
+
+/**
+ * Genere le code technique stable d'une Category a partir de son nom (ERP-78).
+ *
+ * Regle (decision produit 02/06) : `code` est obligatoire et auto-genere — un
+ * slug MAJUSCULE du nom, sans accent, separateurs non alphanumeriques reduits a
+ * `_`, borne a 50 caracteres (longueur colonne). Exemples :
+ *  - « Distributeur »      -> DISTRIBUTEUR
+ *  - « Agro-alimentaire »  -> AGRO_ALIMENTAIRE
+ *  - « Transport/Logistique » -> TRANSPORT_LOGISTIQUE
+ *
+ * Le code est FIGE a la creation (jamais recalcule sur renommage) afin de rester
+ * une cle deterministe stable entre environnements (RG-1.03 / RG-1.29 cote M1).
+ *
+ * Unicite : l'index partiel `uq_category_code` (WHERE deleted_at IS NULL) impose
+ * l'unicite parmi les categories actives. Deux noms distincts peuvent produire
+ * le meme slug (« Agro alimentaire » / « Agro-alimentaire ») : on suffixe alors
+ * le code par `_2`, `_3`... jusqu'a obtenir un code libre.
+ */
+final class CategoryCodeGenerator
+{
+    /** Longueur maximale de la colonne `category.code`. */
+    private const int MAX_LENGTH = 50;
+
+    private readonly AsciiSlugger $slugger;
+
+    public function __construct(
+        private readonly CategoryRepositoryInterface $categoryRepository,
+    ) {
+        $this->slugger = new AsciiSlugger();
+    }
+
+    /**
+     * Slug brut (sans garantie d'unicite) — utile pour les seeds deterministes.
+     */
+    public function slugify(string $name): string
+    {
+        $slug = $this->slugger->slug($name, '_')->upper()->toString();
+
+        // Borne a la longueur colonne, puis retire un eventuel `_` terminal
+        // introduit par la troncature.
+        $slug = substr($slug, 0, self::MAX_LENGTH);
+        $slug = trim($slug, '_');
+
+        // Garde-fou : un nom uniquement compose de caracteres non alphanumeriques
+        // (theorique, le nom est NotBlank + Length>=2) donnerait un slug vide.
+        return '' === $slug ? 'CATEGORY' : $slug;
+    }
+
+    /**
+     * Code unique parmi les categories actives : slug du nom, suffixe `_N` en
+     * cas de collision. `$excludeId` ignore la categorie courante (PATCH).
+     */
+    public function generateUnique(string $name, ?int $excludeId = null): string
+    {
+        $base      = $this->slugify($name);
+        $candidate = $base;
+        $suffix    = 2;
+
+        while ($this->categoryRepository->existsActiveByCode($candidate, $excludeId)) {
+            $suffixStr = '_'.$suffix;
+            // Retronque la base pour que `base + suffixe` tienne dans 50 caracteres.
+            $candidate = substr($base, 0, self::MAX_LENGTH - strlen($suffixStr)).$suffixStr;
+            ++$suffix;
+        }
+
+        return $candidate;
+    }
+}

src/Module/Catalog/Domain/Entity/Category.php

@@ -74,10 +74,11 @@ use Symfony\Component\Validator\Constraints as Assert;
 )]
 #[ORM\Entity(repositoryClass: DoctrineCategoryRepository::class)]
 #[ORM\Table(name: 'category')]
-// Index nommes pour matcher la migration (cf. Role/Permission/Site). L'index
-// unique partiel `uq_category_name_type_active` (LOWER(name), category_type_id
-// WHERE deleted_at IS NULL) reste possede par la seule migration : Doctrine ORM
-// ne sait pas exprimer un index fonctionnel + partiel via attribut.
+// Index nommes pour matcher la migration (cf. Role/Permission/Site). Les index
+// uniques partiels `uq_category_name_type_active` (LOWER(name), category_type_id
+// WHERE deleted_at IS NULL) et `uq_category_code` (code WHERE deleted_at IS NULL)
+// restent possedes par la seule migration : Doctrine ORM ne sait pas exprimer un
+// index partiel via attribut.
 #[ORM\Index(name: 'idx_category_deleted_at', columns: ['deleted_at'])]
 #[ORM\Index(name: 'idx_category_type_id', columns: ['category_type_id'])]
 #[ORM\Index(name: 'idx_category_created_by', columns: ['created_by'])]
@@ -109,6 +110,16 @@ class Category implements TimestampableInterface, BlamableInterface, CategoryInt
     #[Groups(['category:read', 'category:write'])]
     private ?string $name = null;
 
+    // Code technique stable (slug MAJUSCULE du nom) — NOT NULL + unique parmi les
+    // actifs (index partiel `uq_category_code` possede par la migration). Genere
+    // par le CategoryProcessor a la creation puis fige (jamais recalcule sur
+    // renommage) : sert de cle metier deterministe (RG-1.03 / RG-1.29). Lecture
+    // seule cote API (hors groupe category:write) : le front filtre dessus mais
+    // ne le saisit pas.
+    #[ORM\Column(length: 50)]
+    #[Groups(['category:read'])]
+    private ?string $code = null;
+
     #[ORM\ManyToOne(targetEntity: CategoryType::class)]
     #[ORM\JoinColumn(name: 'category_type_id', referencedColumnName: 'id', nullable: false, onDelete: 'RESTRICT')]
     #[Assert\NotNull(message: 'Type de catégorie obligatoire.')]
@@ -141,6 +152,21 @@ class Category implements TimestampableInterface, BlamableInterface, CategoryInt
         return $this;
     }
 
+    /**
+     * Implemente CategoryInterface : code technique stable de la categorie.
+     */
+    public function getCode(): ?string
+    {
+        return $this->code;
+    }
+
+    public function setCode(string $code): static
+    {
+        $this->code = $code;
+
+        return $this;
+    }
+
     public function getCategoryType(): ?CategoryType
     {
         return $this->categoryType;

src/Module/Catalog/Domain/Repository/CategoryRepositoryInterface.php

@@ -13,6 +13,13 @@ interface CategoryRepositoryInterface
 
     public function save(Category $category): void;
 
+    /**
+     * Vrai si une categorie active (deleted_at IS NULL) porte deja ce code.
+     * `$excludeId` exclut une categorie precise du test (cas PATCH). Sert a
+     * garantir l'unicite du code generee par le CategoryCodeGenerator (ERP-78).
+     */
+    public function existsActiveByCode(string $code, ?int $excludeId = null): bool;
+
     /**
      * Construit un QueryBuilder de liste avec filtre soft-delete et tri par defaut.
      * - $includeDeleted = false : exclut les categories soft-deleted (RG-1.08)

src/Module/Catalog/Infrastructure/ApiPlatform/State/Processor/CategoryProcessor.php

@@ -7,6 +7,7 @@ namespace App\Module\Catalog\Infrastructure\ApiPlatform\State\Processor;
 use ApiPlatform\Metadata\DeleteOperationInterface;
 use ApiPlatform\Metadata\Operation;
 use ApiPlatform\State\ProcessorInterface;
+use App\Module\Catalog\Application\Service\CategoryCodeGenerator;
 use App\Module\Catalog\Domain\Entity\Category;
 use DateTimeImmutable;
 use Doctrine\DBAL\Exception\UniqueConstraintViolationException;
@@ -16,10 +17,13 @@ use Symfony\Component\HttpKernel\Exception\HttpException;
 /**
  * Processor Category : applique les regles de gestion en ecriture.
  *
- * - POST / PATCH : trim du nom (RG-1.03) puis delegation au persist_processor
- *   Doctrine ORM. Toute UniqueConstraintViolationException remontee par Postgres
- *   (collision sur l'index partiel uq_category_name_type_active) est traduite
- *   en HTTP 409 avec le message attendu par la spec (RG-1.07).
+ * - POST / PATCH : trim du nom (RG-1.03) ; a la CREATION, generation du `code`
+ *   technique stable (slug MAJUSCULE du nom, unique parmi les actifs — ERP-78)
+ *   via CategoryCodeGenerator ; puis delegation au persist_processor Doctrine
+ *   ORM. Le code est FIGE a la creation (jamais recalcule sur PATCH). Toute
+ *   UniqueConstraintViolationException remontee par Postgres (collision sur
+ *   l'index partiel uq_category_name_type_active) est traduite en HTTP 409 avec
+ *   le message attendu par la spec (RG-1.07).
  * - DELETE : soft delete (RG-1.12). On NE delegue PAS au remove_processor ;
  *   on pose deletedAt = now() puis on delegue au persist_processor pour que
  *   le UPDATE Doctrine parte et que le TimestampableBlamableSubscriber mette
@@ -32,6 +36,7 @@ final class CategoryProcessor implements ProcessorInterface
     public function __construct(
         #[Autowire(service: 'api_platform.doctrine.orm.state.persist_processor')]
         private readonly ProcessorInterface $persistProcessor,
+        private readonly CategoryCodeGenerator $codeGenerator,
     ) {}
 
     public function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): mixed
@@ -62,6 +67,14 @@ final class CategoryProcessor implements ProcessorInterface
             $data->setName(trim($data->getName()));
         }
 
+        // ERP-78 : le code est genere a la CREATION puis fige. On le (re)genere
+        // uniquement s'il est absent (POST, ou entite seedee sans code) — un PATCH
+        // sur une categorie existante conserve son code. Genere depuis le nom
+        // (NotBlank, deja trimme), unique parmi les actifs.
+        if (null === $data->getCode() && null !== $data->getName()) {
+            $data->setCode($this->codeGenerator->generateUnique($data->getName(), $data->getId()));
+        }
+
         try {
             return $this->persistProcessor->process($data, $operation, $uriVariables, $context);
         } catch (UniqueConstraintViolationException $e) {

src/Module/Catalog/Infrastructure/DataFixtures/CategoryFixtures.php

@@ -14,19 +14,19 @@ use RuntimeException;
 use Symfony\Component\DependencyInjection\Attribute\Autowire;
 
 /**
- * Fixtures dev/test du module Catalog : ~12 categories de demonstration reparties
- * sur les 4 types metier (DISTRIBUTEUR / COURTIER / SECTEUR / AUTRE). Alimente le
- * repertoire clients (ClientFixtures, module Commercial) avec des donnees
- * realistes couvrant les categorisations RG-1.03 (DISTRIBUTEUR/COURTIER) et
- * RG-1.29 (SECTEUR/AUTRE sur adresse).
+ * Fixtures dev/test du module Catalog : ~11 categories de demonstration, toutes
+ * rattachees au type unique CLIENT (refonte taxonomie ERP-78). Chaque categorie
+ * porte un `code` stable. Alimente le repertoire clients (ClientFixtures, module
+ * Commercial) avec des donnees realistes couvrant RG-1.03 (codes DISTRIBUTEUR /
+ * COURTIER) et RG-1.29 (codes interdits sur adresse).
  *
- * Depend de CategoryTypeFixtures : les 4 CategoryType doivent etre seedes avant
- * de pouvoir y rattacher des Category.
+ * Depend de CategoryTypeFixtures : le type CLIENT doit etre seede avant de
+ * pouvoir y rattacher des Category.
  *
- * Idempotence : lookup par (name, categoryType) parmi les categories non
- * supprimees (deletedAt null), coherent avec l'index unique partiel
- * uq_category_name_type_active (LOWER(name), category_type_id WHERE deleted_at
- * IS NULL). Rejouable sans doublon meme si le purger Doctrine est desactive.
+ * Idempotence : lookup par `code` parmi les categories non supprimees (deletedAt
+ * null), coherent avec l'index unique partiel uq_category_code (code WHERE
+ * deleted_at IS NULL). Rejouable sans doublon meme si le purger Doctrine est
+ * desactive.
  *
  * Audit / Blamable : persist hors contexte HTTP -> created_by / updated_by
  * restent null (« Systeme » cote front), c'est attendu.
@@ -34,39 +34,33 @@ use Symfony\Component\DependencyInjection\Attribute\Autowire;
  * Portee : DONNEES DE DEMONSTRATION (dev uniquement). En environnement `test`,
  * la fixture ne charge rien : les tests seedent et nettoient leurs propres
  * categories (prefixe dedie) et comptent sur une table `category` vierge — y
- * injecter 12 categories de demo casserait comptages et cleanups FK
+ * injecter des categories de demo casserait comptages et cleanups FK
  * (client_category). Cf. ClientFixtures (meme garde-fou).
  */
 class CategoryFixtures extends Fixture implements DependentFixtureInterface
 {
+    /** Code du type unique (cf. CategoryTypeFixtures, migration ERP-78). */
+    private const string CLIENT_TYPE_CODE = 'CLIENT';
+
     /**
-     * Source unique des categories de demonstration : code de type metier =>
-     * liste de noms. Les noms sont stockes tels quels (l'unicite est
-     * case-insensitive cote index).
+     * Source unique des categories de demonstration : nom => code stable. Les 4
+     * premieres (Distributeur / Courtier / Secteur / Autre) sont les categories
+     * « systeme » reportees des anciens types ; leurs codes pilotent les RG.
      *
-     * @var array<string, list<string>>
+     * @var array<string, string>
      */
     private const CATEGORIES = [
-        'SECTEUR' => [
-            'BTP',
-            'Industrie',
-            'Agro-alimentaire',
-            'Transport/Logistique',
-            'Services',
-        ],
-        'DISTRIBUTEUR' => [
-            'Distributeur Grand Sud-Ouest',
-            'Distributeur National Premium',
-            'Grossiste régional',
-        ],
-        'COURTIER' => [
-            'Cabinet de courtage Léonard',
-            'Cabinet de courtage Bernard',
-        ],
-        'AUTRE' => [
-            'Indépendant',
-            'Association',
-        ],
+        'Distributeur'         => 'DISTRIBUTEUR',
+        'Courtier'             => 'COURTIER',
+        'Secteur'              => 'SECTEUR',
+        'Autre'                => 'AUTRE',
+        'BTP'                  => 'BTP',
+        'Industrie'            => 'INDUSTRIE',
+        'Agro-alimentaire'     => 'AGRO_ALIMENTAIRE',
+        'Transport/Logistique' => 'TRANSPORT_LOGISTIQUE',
+        'Services'             => 'SERVICES',
+        'Association'          => 'ASSOCIATION',
+        'Indépendant'          => 'INDEPENDANT',
     ];
 
     public function __construct(
@@ -90,41 +84,39 @@ class CategoryFixtures extends Fixture implements DependentFixtureInterface
             return;
         }
 
-        // Index des types metier par code (CategoryTypeFixtures les a seedes).
-        $typesByCode = [];
+        $clientType = null;
         foreach ($this->categoryTypeRepository->findAllOrderedByLabel() as $type) {
-            $typesByCode[$type->getCode()] = $type;
+            if (self::CLIENT_TYPE_CODE === $type->getCode()) {
+                $clientType = $type;
+
+                break;
+            }
         }
 
-        foreach (self::CATEGORIES as $typeCode => $names) {
-            $type = $typesByCode[$typeCode] ?? null;
-            if (!$type instanceof CategoryType) {
-                // Misconfiguration : CategoryTypeFixtures n'a pas tourne avant.
-                throw new RuntimeException(sprintf(
-                    'CategoryTypeFixtures doit avoir seede le type "%s" avant CategoryFixtures.',
-                    $typeCode,
-                ));
-            }
+        if (!$clientType instanceof CategoryType) {
+            // Misconfiguration : CategoryTypeFixtures n'a pas tourne avant.
+            throw new RuntimeException(
+                'CategoryTypeFixtures doit avoir seede le type "CLIENT" avant CategoryFixtures.',
+            );
+        }
 
-            foreach ($names as $name) {
-                $this->ensureCategory($manager, $name, $type);
-            }
+        foreach (self::CATEGORIES as $name => $code) {
+            $this->ensureCategory($manager, $name, $code, $clientType);
         }
 
         $manager->flush();
     }
 
     /**
-     * Cree la categorie (name, type) si elle n'existe pas encore parmi les
-     * categories actives, sinon la laisse en place. Lookup aligne sur l'index
-     * unique partiel (nom + type, hors soft-deleted).
+     * Cree la categorie (name, code) sous le type CLIENT si son code n'existe pas
+     * encore parmi les categories actives, sinon la laisse en place. Lookup
+     * aligne sur l'index unique partiel uq_category_code.
      */
-    private function ensureCategory(ObjectManager $manager, string $name, CategoryType $type): void
+    private function ensureCategory(ObjectManager $manager, string $name, string $code, CategoryType $type): void
     {
         $existing = $manager->getRepository(Category::class)->findOneBy([
-            'name'         => $name,
-            'categoryType' => $type,
-            'deletedAt'    => null,
+            'code'      => $code,
+            'deletedAt' => null,
         ]);
 
         if (null !== $existing) {
@@ -133,6 +125,7 @@ class CategoryFixtures extends Fixture implements DependentFixtureInterface
 
         $category = new Category();
         $category->setName($name);
+        $category->setCode($code);
         $category->setCategoryType($type);
         $manager->persist($category);
     }

src/Module/Catalog/Infrastructure/DataFixtures/CategoryTypeFixtures.php

@@ -10,17 +10,19 @@ use Doctrine\Bundle\FixturesBundle\Fixture;
 use Doctrine\Persistence\ObjectManager;
 
 /**
- * Fixtures du module Catalog : seed des types de categorie metier (M1).
+ * Fixtures du module Catalog : seed du type de categorie (M1).
  *
- * La table `category_type` est creee vide au M0 ; le M1 la peuple avec les 4
- * types DISTRIBUTEUR / COURTIER / SECTEUR / AUTRE (cf. spec M1 § 3.3).
+ * Refonte taxonomie ERP-78 : le modele n'a plus qu'UN SEUL `category_type`,
+ * CLIENT (code CLIENT, label « Client »). Distributeur / Courtier / Secteur /
+ * Autre (et les categories metier fines) sont desormais des `Category` codees
+ * rattachees a ce type (cf. CategoryFixtures + migration Version20260602100000).
  *
- * Pourquoi une fixture EN PLUS du seed de la migration (Version20260601000000) :
- * `category_type` est une entite managee par l ORM, donc le purger Doctrine la
- * vide avant chaque `doctrine:fixtures:load`. Sans cette fixture, les 4 types
- * seedes par la migration disparaitraient apres `make db-reset` / setup de test.
- * Le seed migration couvre la prod (ou les fixtures ne tournent pas) ; cette
- * fixture re-aligne dev et test. Les deux chemins produisent un etat identique.
+ * Pourquoi une fixture EN PLUS du seed de la migration : `category_type` est une
+ * entite managee par l ORM, donc le purger Doctrine la vide avant chaque
+ * `doctrine:fixtures:load`. Sans cette fixture, le type CLIENT seede par la
+ * migration disparaitrait apres `make db-reset` / setup de test. Le seed
+ * migration couvre la prod (ou les fixtures ne tournent pas) ; cette fixture
+ * re-aligne dev et test. Les deux chemins produisent un etat identique.
  *
  * Idempotence : lookup par `code` parmi les types existants avant insertion,
  * sur le modele d AppFixtures::ensureSystemRole. Rejouable sans doublon meme
@@ -29,14 +31,11 @@ use Doctrine\Persistence\ObjectManager;
 class CategoryTypeFixtures extends Fixture
 {
     /**
-     * Source unique des 4 types metier : code technique => libelle FR.
-     * Doit rester aligne sur le seed de la migration Version20260601000000.
+     * Source unique du type : code technique => libelle FR. Doit rester aligne
+     * sur le seed de la migration Version20260602100000 (type unique CLIENT).
      */
     private const TYPES = [
-        'DISTRIBUTEUR' => 'Distributeur',
-        'COURTIER'     => 'Courtier',
-        'SECTEUR'      => 'Secteur',
-        'AUTRE'        => 'Autre',
+        'CLIENT' => 'Client',
     ];
 
     public function __construct(

src/Module/Catalog/Infrastructure/Doctrine/DoctrineCategoryRepository.php

@@ -31,6 +31,23 @@ class DoctrineCategoryRepository extends ServiceEntityRepository implements Cate
         $this->getEntityManager()->flush();
     }
 
+    public function existsActiveByCode(string $code, ?int $excludeId = null): bool
+    {
+        $qb = $this->createQueryBuilder('c')
+            ->select('1')
+            ->andWhere('c.code = :code')
+            ->andWhere('c.deletedAt IS NULL')
+            ->setParameter('code', $code)
+            ->setMaxResults(1)
+        ;
+
+        if (null !== $excludeId) {
+            $qb->andWhere('c.id != :excludeId')->setParameter('excludeId', $excludeId);
+        }
+
+        return [] !== $qb->getQuery()->getResult();
+    }
+
     public function createListQueryBuilder(bool $includeDeleted = false): QueryBuilder
     {
         $qb = $this->createQueryBuilder('c')

src/Module/Commercial/Domain/Entity/Client.php

@@ -15,6 +15,7 @@ use App\Module\Commercial\Infrastructure\Doctrine\DoctrineClientRepository;
 use App\Shared\Domain\Attribute\Auditable;
 use App\Shared\Domain\Contract\BlamableInterface;
 use App\Shared\Domain\Contract\CategoryInterface;
+use App\Shared\Domain\Contract\SiteInterface;
 use App\Shared\Domain\Contract\TimestampableInterface;
 use App\Shared\Domain\Trait\TimestampableBlamableTrait;
 use DateTimeImmutable;
@@ -58,27 +59,39 @@ use Symfony\Component\Validator\Constraints as Assert;
     operations: [
         new GetCollection(
             security: "is_granted('commercial.clients.view')",
-            normalizationContext: ['groups' => ['client:read', 'default:read']],
+            // La liste embarque les categories (avec leur code, groupe
+            // category:read) et les sites agreges des adresses (groupe
+            // site:read) pour alimenter les colonnes « Catégories » et
+            // « Site(s) » du Repertoire (ERP-62). Cf. getSites() plus bas.
+            normalizationContext: ['groups' => ['client:read', 'default:read', 'category:read', 'site:read']],
             provider: ClientProvider::class,
         ),
         new Get(
             security: "is_granted('commercial.clients.view')",
-            // Detail : client + sous-collections embarquees. Le groupe
-            // client:read:accounting est ajoute par le context builder selon la
-            // permission, donc absent ici volontairement.
+            // Detail : client + sous-collections embarquees.
+            //  - client:read:accounting est ajoute par le context builder selon la
+            //    permission (gate les scalaires comptables ET les RIB embarques),
+            //    donc absent ici volontairement.
+            //  - client_rib:read N'EST PLUS dans le contexte : le contenu des RIB
+            //    embarques est desormais porte par client:read:accounting (gate),
+            //    ce qui retire la fuite IBAN/BIC vers les users sans accounting.view.
+            //  - category:read et site:read sont indispensables pour embarquer le
+            //    code/libelle des categories et des sites (sinon stub IRI nu) :
+            //    Category.code/name vivent sous category:read, Site.name sous site:read.
             normalizationContext: ['groups' => [
                 'client:read',
                 'client:item:read',
                 'client_contact:read',
                 'client_address:read',
-                'client_rib:read',
+                'category:read',
+                'site:read',
                 'default:read',
             ]],
             provider: ClientProvider::class,
         ),
         new Post(
             security: "is_granted('commercial.clients.manage')",
-            normalizationContext: ['groups' => ['client:read', 'default:read']],
+            normalizationContext: ['groups' => ['client:read', 'default:read', 'category:read', 'site:read']],
             denormalizationContext: ['groups' => ['client:write:main']],
             processor: ClientProcessor::class,
         ),
@@ -96,7 +109,7 @@ use Symfony\Component\Validator\Constraints as Assert;
             // autoriser/refuser onglet par onglet (RG-1.22 / RG-1.28) : les
             // champs accounting exigent accounting.manage, isArchived exige
             // archive, le reste (main/information) exige manage.
-            normalizationContext: ['groups' => ['client:read', 'default:read']],
+            normalizationContext: ['groups' => ['client:read', 'default:read', 'category:read', 'site:read']],
             denormalizationContext: ['groups' => [
                 'client:write:main',
                 'client:write:information',
@@ -651,8 +664,38 @@ class Client implements TimestampableInterface, BlamableInterface
         return $this;
     }
 
+    /**
+     * Sites distincts rattaches a au moins une adresse du client (RG-1.10).
+     * Le Client ne porte pas de sites en propre : ils vivent sur les adresses.
+     * Agrege en lecture seule pour la colonne « Site(s) » du Repertoire (badges
+     * colores) — expose en LISTE via le groupe client:read (les adresses
+     * completes restent reservees au detail, client:item:read).
+     *
+     * @return list<SiteInterface>
+     */
+    #[Groups(['client:read'])]
+    public function getSites(): array
+    {
+        $sites = [];
+        foreach ($this->addresses as $address) {
+            foreach ($address->getSites() as $site) {
+                // Deduplication par identite d'objet : un meme site peut etre
+                // rattache a plusieurs adresses du client.
+                $sites[spl_object_id($site)] = $site;
+            }
+        }
+
+        return array_values($sites);
+    }
+
+    // Embed gate sur le groupe COMPTABLE (et non client:item:read comme contacts/
+    // adresses) : client:read:accounting n'est ajoute au contexte que si l'user a
+    // accounting.view (ClientReadGroupContextBuilder). Resultat : la cle `ribs` est
+    // TOTALEMENT ABSENTE du detail pour un user sans accounting.view (ex. Commerciale),
+    // au meme titre que les scalaires comptables — corrige la fuite de RIB ou la
+    // Commerciale recevait IBAN/BIC en clair.
     /** @return Collection<int, ClientRib> */
-    #[Groups(['client:item:read'])]
+    #[Groups(['client:read:accounting'])]
     public function getRibs(): Collection
     {
         return $this->ribs;

src/Module/Commercial/Domain/Entity/ClientAddress.php

@@ -22,6 +22,7 @@ use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
 use Symfony\Component\Serializer\Attribute\Groups;
+use Symfony\Component\Serializer\Attribute\SerializedName;
 use Symfony\Component\Validator\Constraints as Assert;
 use Symfony\Component\Validator\Context\ExecutionContextInterface;
 
@@ -39,7 +40,7 @@ use Symfony\Component\Validator\Context\ExecutionContextInterface;
  *  - sites : SiteInterface (module Sites) via resolve_target_entities
  *  - contacts : ClientContact (meme module)
  *  - categories : CategoryInterface (module Catalog) via resolve_target_entities
- *    — limitees aux types SECTEUR/AUTRE (RG-1.29, validateCategoryTypes, ERP-76)
+ *    — codes DISTRIBUTEUR/COURTIER interdits (RG-1.29, validateCategoryCodes, ERP-78)
  *
  * Audite (#[Auditable]) + Timestampable/Blamable.
  *
@@ -87,8 +88,12 @@ class ClientAddress implements TimestampableInterface, BlamableInterface
 {
     use TimestampableBlamableTrait;
 
-    /** RG-1.29 : seuls ces types de categorie qualifient une adresse physique. */
-    private const array ALLOWED_CATEGORY_TYPES = ['SECTEUR', 'AUTRE'];
+    /**
+     * RG-1.29 (ERP-78) : ces codes de categorie decrivent une relation entre
+     * clients (distributeur / courtier) et n'ont pas de sens sur une adresse.
+     * Toute autre categorie du type CLIENT est autorisee.
+     */
+    private const array FORBIDDEN_CATEGORY_CODES = ['DISTRIBUTEUR', 'COURTIER'];
 
     #[ORM\Id]
     #[ORM\GeneratedValue]
@@ -100,16 +105,23 @@ class ClientAddress implements TimestampableInterface, BlamableInterface
     #[ORM\JoinColumn(name: 'client_id', referencedColumnName: 'id', nullable: false, onDelete: 'CASCADE')]
     private ?Client $client = null;
 
+    // Groupe d'ECRITURE uniquement sur la propriete (denormalisation PATCH/POST).
+    // Le groupe de LECTURE est porte par le getter isProspect()/isDelivery()/
+    // isBilling() avec SerializedName : sans cela, Symfony strip le prefixe "is"
+    // des getters booleens et exposerait les cles "prospect"/"delivery"/"billing"
+    // — en pratique le #[Groups] etant sur la propriete `isX` et le getter
+    // derivant l'attribut `x`, la cle etait totalement DROPPEE du JSON (meme bug
+    // que Client::isArchived). Pattern corrige : Groups + SerializedName sur le getter.
     #[ORM\Column(name: 'is_prospect', options: ['default' => false])]
-    #[Groups(['client_address:read', 'client_address:write'])]
+    #[Groups(['client_address:write'])]
     private bool $isProspect = false;
 
     #[ORM\Column(name: 'is_delivery', options: ['default' => false])]
-    #[Groups(['client_address:read', 'client_address:write'])]
+    #[Groups(['client_address:write'])]
     private bool $isDelivery = false;
 
     #[ORM\Column(name: 'is_billing', options: ['default' => false])]
-    #[Groups(['client_address:read', 'client_address:write'])]
+    #[Groups(['client_address:write'])]
     private bool $isBilling = false;
 
     #[ORM\Column(length: 80, options: ['default' => 'France'])]
@@ -165,7 +177,7 @@ class ClientAddress implements TimestampableInterface, BlamableInterface
     #[Groups(['client_address:read', 'client_address:write'])]
     private Collection $contacts;
 
-    // RG-1.29 : categories de type SECTEUR/AUTRE uniquement (validateCategoryTypes).
+    // RG-1.29 : categories de code DISTRIBUTEUR/COURTIER interdites (validateCategoryCodes).
     /** @var Collection<int, CategoryInterface> */
     #[ORM\ManyToMany(targetEntity: CategoryInterface::class)]
     #[ORM\JoinTable(name: 'client_address_category')]
@@ -232,18 +244,19 @@ class ClientAddress implements TimestampableInterface, BlamableInterface
     }
 
     /**
-     * RG-1.29 : seules les categories de type SECTEUR / AUTRE qualifient une
-     * adresse physique. Les types DISTRIBUTEUR / COURTIER decrivent une relation
-     * entre clients (RG-1.03) et n'ont pas de sens sur une adresse -> 422 avec
-     * violation sur le champ `categories`. S'appuie sur
-     * CategoryInterface::getCategoryTypeCode() (pas d'import du module Catalog).
+     * RG-1.29 (ERP-78) : une adresse interdit les categories de code
+     * DISTRIBUTEUR / COURTIER — elles decrivent une relation entre clients
+     * (RG-1.03) et n'ont pas de sens sur une adresse physique -> 422 avec
+     * violation sur le champ `categories`. Toute autre categorie (type unique
+     * CLIENT) est acceptee. S'appuie sur CategoryInterface::getCode() (pas
+     * d'import du module Catalog — regle ABSOLUE n°1).
      */
     #[Assert\Callback]
-    public function validateCategoryTypes(ExecutionContextInterface $context): void
+    public function validateCategoryCodes(ExecutionContextInterface $context): void
     {
         foreach ($this->categories as $category) {
             if ($category instanceof CategoryInterface
-                && !in_array($category->getCategoryTypeCode(), self::ALLOWED_CATEGORY_TYPES, true)) {
+                && in_array($category->getCode(), self::FORBIDDEN_CATEGORY_CODES, true)) {
                 $context->buildViolation('Type de catégorie non autorisé sur une adresse.')
                     ->atPath('categories')
                     ->addViolation()
@@ -271,6 +284,12 @@ class ClientAddress implements TimestampableInterface, BlamableInterface
         return $this;
     }
 
+    // Groupe de lecture + nom serialise explicite (cf. note sur la propriete) :
+    // sans SerializedName, Symfony exposerait la cle "prospect" (strip du prefixe
+    // "is" sur les getters) et, le groupe etant declare sur la propriete `isProspect`,
+    // droppait silencieusement la cle du JSON.
+    #[Groups(['client_address:read'])]
+    #[SerializedName('isProspect')]
     public function isProspect(): bool
     {
         return $this->isProspect;
@@ -283,6 +302,8 @@ class ClientAddress implements TimestampableInterface, BlamableInterface
         return $this;
     }
 
+    #[Groups(['client_address:read'])]
+    #[SerializedName('isDelivery')]
     public function isDelivery(): bool
     {
         return $this->isDelivery;
@@ -295,6 +316,8 @@ class ClientAddress implements TimestampableInterface, BlamableInterface
         return $this;
     }
 
+    #[Groups(['client_address:read'])]
+    #[SerializedName('isBilling')]
     public function isBilling(): bool
     {
         return $this->isBilling;

src/Module/Commercial/Domain/Entity/ClientRib.php

@@ -79,10 +79,17 @@ class ClientRib implements TimestampableInterface, BlamableInterface
 {
     use TimestampableBlamableTrait;
 
+    // Double groupe de lecture :
+    //  - `client_rib:read` : sous-ressource autonome GET /api/client_ribs/{id}
+    //    (deja securisee par commercial.clients.accounting.view).
+    //  - `client:read:accounting` : embed des RIB sous le detail Client, ajoute
+    //    DYNAMIQUEMENT par ClientReadGroupContextBuilder uniquement si l'user a
+    //    accounting.view. Ce double marquage gate les RIB embarques au meme titre
+    //    que les scalaires comptables (RG : la Commerciale ne voit aucun RIB).
     #[ORM\Id]
     #[ORM\GeneratedValue]
     #[ORM\Column]
-    #[Groups(['client_rib:read'])]
+    #[Groups(['client_rib:read', 'client:read:accounting'])]
     private ?int $id = null;
 
     #[ORM\ManyToOne(targetEntity: Client::class, inversedBy: 'ribs')]
@@ -92,23 +99,23 @@ class ClientRib implements TimestampableInterface, BlamableInterface
     #[ORM\Column(length: 120)]
     #[Assert\NotBlank]
     #[Assert\Length(max: 120, normalizer: 'trim')]
-    #[Groups(['client_rib:read', 'client_rib:write'])]
+    #[Groups(['client_rib:read', 'client:read:accounting', 'client_rib:write'])]
     private ?string $label = null;
 
     #[ORM\Column(length: 20)]
     #[Assert\NotBlank]
     #[Assert\Bic]
-    #[Groups(['client_rib:read', 'client_rib:write'])]
+    #[Groups(['client_rib:read', 'client:read:accounting', 'client_rib:write'])]
     private ?string $bic = null;
 
     #[ORM\Column(length: 34)]
     #[Assert\NotBlank]
     #[Assert\Iban]
-    #[Groups(['client_rib:read', 'client_rib:write'])]
+    #[Groups(['client_rib:read', 'client:read:accounting', 'client_rib:write'])]
     private ?string $iban = null;
 
     #[ORM\Column(options: ['default' => 0])]
-    #[Groups(['client_rib:read', 'client_rib:write'])]
+    #[Groups(['client_rib:read', 'client:read:accounting', 'client_rib:write'])]
     private int $position = 0;
 
     public function getId(): ?int

src/Module/Commercial/Domain/Repository/ClientRepositoryInterface.php

@@ -16,20 +16,31 @@ interface ClientRepositoryInterface
     /**
      * Construit un QueryBuilder de liste pour le repertoire clients.
      * - Exclut toujours les clients soft-deletes (deleted_at IS NOT NULL, RG-1.24).
-     * - Exclut les archives sauf si $includeArchived = true (RG-1.25).
+     * - Archivage (RG-1.25) :
+     *     - $archivedOnly = true  -> uniquement les archives (is_archived = true) ;
+     *     - sinon $includeArchived = true -> actifs + archives (echappatoire) ;
+     *     - sinon (defaut) -> uniquement les actifs (is_archived = false).
+     *   $archivedOnly a la priorite sur $includeArchived.
      * - Tri par defaut : companyName ASC (RG-1.26).
      * - $search : recherche fuzzy insensible a la casse sur companyName +
      *   lastName + email (metacaracteres LIKE echappes). Ignore si null/vide.
-     * - $categoryType : restreint aux clients possedant au moins une categorie
-     *   du type donne (code). Ignore si null/vide.
+     * - $categoryCodes : restreint aux clients possedant au moins une categorie
+     *   dont le code est dans la liste (OR — ERP-78). Liste vide = pas de filtre.
+     * - $siteIds : restreint aux clients ayant au moins une adresse rattachee a
+     *   l'un des sites donnes (OR — RG-1.10). Liste vide = pas de filtre.
      *
      * Filtrage centralise ICI (et non dans les providers/controllers) pour que
      * la liste paginee (ClientProvider) et l'export (ClientExportController)
      * partagent strictement la meme logique de selection.
+     *
+     * @param list<string> $categoryCodes
+     * @param list<int>    $siteIds
      */
     public function createListQueryBuilder(
         bool $includeArchived = false,
         ?string $search = null,
-        ?string $categoryType = null,
+        array $categoryCodes = [],
+        array $siteIds = [],
+        bool $archivedOnly = false,
     ): QueryBuilder;
 }

src/Module/Commercial/Infrastructure/ApiPlatform/State/Processor/ClientProcessor.php

@@ -457,8 +457,9 @@ final class ClientProcessor implements ProcessorInterface
 
     /**
      * RG-1.03 : distributor et broker mutuellement exclusifs ; un distributor
-     * doit referencer un client de categorie DISTRIBUTEUR (idem broker ->
-     * COURTIER).
+     * doit referencer un client portant la categorie de code DISTRIBUTEUR (idem
+     * broker -> COURTIER). Depuis ERP-78, le filtrage se fait sur le code de la
+     * Category (et non plus sur le type, devenu unique CLIENT).
      */
     private function validateDistributorBroker(Client $data): void
     {
@@ -473,7 +474,7 @@ final class ClientProcessor implements ProcessorInterface
             );
         }
 
-        if (null !== $distributor && !$this->hasCategoryType($distributor, 'DISTRIBUTEUR')) {
+        if (null !== $distributor && !$this->hasCategoryCode($distributor, 'DISTRIBUTEUR')) {
             $this->throwViolation(
                 'distributor',
                 'Le distributeur référencé doit être un client de catégorie DISTRIBUTEUR.',
@@ -481,7 +482,7 @@ final class ClientProcessor implements ProcessorInterface
             );
         }
 
-        if (null !== $broker && !$this->hasCategoryType($broker, 'COURTIER')) {
+        if (null !== $broker && !$this->hasCategoryCode($broker, 'COURTIER')) {
             $this->throwViolation(
                 'broker',
                 'Le courtier référencé doit être un client de catégorie COURTIER.',
@@ -530,13 +531,13 @@ final class ClientProcessor implements ProcessorInterface
     }
 
     /**
-     * Vrai si au moins une categorie du client porte le type donne. S'appuie
-     * sur CategoryInterface::getCategoryTypeCode() (pas d'import de Category).
+     * Vrai si au moins une categorie du client porte le code donne. S'appuie sur
+     * CategoryInterface::getCode() (pas d'import de Category — regle ABSOLUE n°1).
      */
-    private function hasCategoryType(Client $client, string $typeCode): bool
+    private function hasCategoryCode(Client $client, string $code): bool
     {
         foreach ($client->getCategories() as $category) {
-            if ($category instanceof CategoryInterface && $category->getCategoryTypeCode() === $typeCode) {
+            if ($category instanceof CategoryInterface && $category->getCode() === $code) {
                 return true;
             }
         }

src/Module/Commercial/Infrastructure/ApiPlatform/State/Provider/ClientProvider.php

@@ -24,7 +24,7 @@ use Symfony\Component\DependencyInjection\Attribute\Autowire;
  *    exclus au M1) — RG-1.25 ;
  *  - tri par defaut companyName ASC — RG-1.26 ;
  *  - filtres ?search=... (fuzzy companyName + lastName + email) et
- *    ?categoryType=<code> (clients ayant >= 1 categorie de ce type) ;
+ *    ?categoryCode=<code> (clients ayant >= 1 categorie de ce code — ERP-78) ;
  *  - pagination obligatoire (convention Starseed ERP-72) : Paginator ORM ;
  *    echappatoire ?pagination=false pour alimenter un <select> sans pagination.
  *
@@ -64,14 +64,20 @@ final class ClientProvider implements ProviderInterface
     {
         $filters         = $context['filters'] ?? [];
         $includeArchived = $this->readBool($filters['includeArchived'] ?? false);
+        $archivedOnly    = $this->readBool($filters['archivedOnly'] ?? false);
         $search          = $filters['search'] ?? null;
-        $categoryType    = $filters['categoryType'] ?? null;
+        // categoryCode accepte un code unique (?categoryCode=DISTRIBUTEUR, selects
+        // RG-1.03) OU une liste (?categoryCode[]=A&categoryCode[]=B, drawer multi).
+        $categoryCodes = $this->readStringList($filters['categoryCode'] ?? []);
+        $siteIds       = $this->readIntList($filters['siteId'] ?? []);
 
         // Filtrage delegue au repository (logique partagee avec l'export XLSX).
         $qb = $this->repository->createListQueryBuilder(
             $includeArchived,
             is_string($search) ? $search : null,
-            is_string($categoryType) ? $categoryType : null,
+            $categoryCodes,
+            $siteIds,
+            $archivedOnly,
         );
 
         // Echappatoire ?pagination=false : collection complete sans Paginator
@@ -127,4 +133,44 @@ final class ClientProvider implements ProviderInterface
 
         return is_string($raw) && in_array(strtolower($raw), ['true', '1'], true);
     }
+
+    /**
+     * Normalise un filtre en liste de chaines. Tolere un code unique (string)
+     * ou une liste (?key[]=a&key[]=b). Trim + retrait des vides.
+     *
+     * @return list<string>
+     */
+    private function readStringList(mixed $raw): array
+    {
+        $values = is_array($raw) ? $raw : [$raw];
+
+        $out = [];
+        foreach ($values as $value) {
+            if (is_string($value) && '' !== trim($value)) {
+                $out[] = trim($value);
+            }
+        }
+
+        return $out;
+    }
+
+    /**
+     * Normalise un filtre en liste d'identifiants entiers positifs. Tolere une
+     * valeur unique ou une liste (?key[]=1&key[]=2).
+     *
+     * @return list<int>
+     */
+    private function readIntList(mixed $raw): array
+    {
+        $values = is_array($raw) ? $raw : [$raw];
+
+        $out = [];
+        foreach ($values as $value) {
+            if ((is_int($value) || (is_string($value) && ctype_digit($value))) && (int) $value > 0) {
+                $out[] = (int) $value;
+            }
+        }
+
+        return $out;
+    }
 }

src/Module/Commercial/Infrastructure/Controller/ClientExportController.php

@@ -52,12 +52,19 @@ final class ClientExportController
     public function __invoke(Request $request): Response
     {
         $includeArchived = $this->readBool($request->query->get('includeArchived'));
+        $archivedOnly    = $this->readBool($request->query->get('archivedOnly'));
         $search          = $request->query->getString('search') ?: null;
-        $categoryType    = $request->query->getString('categoryType') ?: null;
+
+        // Memes filtres que la vue liste : categoryCode/siteId tolerent une valeur
+        // unique ou une liste (?categoryCode[]=A&siteId[]=1). On lit via all() pour
+        // ne pas lever d'exception sur une valeur scalaire.
+        $query         = $request->query->all();
+        $categoryCodes = $this->readStringList($query['categoryCode'] ?? []);
+        $siteIds       = $this->readIntList($query['siteId'] ?? []);
 
         /** @var list<Client> $clients */
         $clients = $this->repository
-            ->createListQueryBuilder($includeArchived, $search, $categoryType)
+            ->createListQueryBuilder($includeArchived, $search, $categoryCodes, $siteIds, $archivedOnly)
             ->getQuery()
             ->getResult()
         ;
@@ -198,4 +205,44 @@ final class ClientExportController
     {
         return is_string($raw) && in_array(strtolower($raw), ['true', '1'], true);
     }
+
+    /**
+     * Normalise un filtre en liste de chaines (valeur unique ou liste).
+     * Aligne sur ClientProvider pour un comportement identique a la liste.
+     *
+     * @return list<string>
+     */
+    private function readStringList(mixed $raw): array
+    {
+        $values = is_array($raw) ? $raw : [$raw];
+
+        $out = [];
+        foreach ($values as $value) {
+            if (is_string($value) && '' !== trim($value)) {
+                $out[] = trim($value);
+            }
+        }
+
+        return $out;
+    }
+
+    /**
+     * Normalise un filtre en liste d'identifiants entiers positifs (valeur unique
+     * ou liste). Aligne sur ClientProvider.
+     *
+     * @return list<int>
+     */
+    private function readIntList(mixed $raw): array
+    {
+        $values = is_array($raw) ? $raw : [$raw];
+
+        $out = [];
+        foreach ($values as $value) {
+            if ((is_int($value) || (is_string($value) && ctype_digit($value))) && (int) $value > 0) {
+                $out[] = (int) $value;
+            }
+        }
+
+        return $out;
+    }
 }

src/Module/Commercial/Infrastructure/DataFixtures/ClientFixtures.php

@@ -54,9 +54,9 @@ use Symfony\Component\DependencyInjection\Attribute\Autowire;
  *
  * Audit / Blamable : persist hors contexte HTTP -> created_by / updated_by
  * restent null (« Systeme » cote front), c'est attendu. Les donnees respectent
- * les CHECK BDD ET les validators applicatifs ERP-76 (exclusivite Prospect,
- * billingEmail ssi facturation, aucune categorie DISTRIBUTEUR/COURTIER sur une
- * adresse).
+ * les CHECK BDD ET les validators applicatifs (exclusivite Prospect, billingEmail
+ * ssi facturation, aucune categorie de code DISTRIBUTEUR/COURTIER sur une adresse
+ * — RG-1.29, ERP-78).
  *
  * Depend de CategoryFixtures (categories), SitesFixtures (sites) et
  * CommercialReferentialFixtures (referentiels comptables Bank / PaymentType).
@@ -116,7 +116,7 @@ class ClientFixtures extends Fixture implements DependentFixtureInterface
             lastName: 'Garnier',
             phonePrimary: '05 56 10 20 30',
             email: 'contact@distrib-gso.fr',
-            categoryNames: ['Distributeur Grand Sud-Ouest'],
+            categoryNames: ['Distributeur'],
         );
         if ($gsoIsNew) {
             $this->addContact($gso, 'Paul', 'Garnier', 'Directeur commercial', '05 56 10 20 30', null, 'paul.garnier@distrib-gso.fr');
@@ -131,7 +131,7 @@ class ClientFixtures extends Fixture implements DependentFixtureInterface
             lastName: 'Léonard',
             phonePrimary: '05 49 11 22 33',
             email: 'contact@cabinet-leonard.fr',
-            categoryNames: ['Cabinet de courtage Léonard'],
+            categoryNames: ['Courtier'],
         );
         if ($leonardIsNew) {
             $this->addContact($leonard, 'Sophie', 'Léonard', 'Gérante', '05 49 11 22 33', null, 'sophie.leonard@cabinet-leonard.fr');
@@ -422,11 +422,11 @@ class ClientFixtures extends Fixture implements DependentFixtureInterface
 
     /**
      * Ajoute une adresse au client (cascade persist via Client.addresses). Les
-     * donnees respectent les validators ERP-76 : exclusivite Prospect,
-     * billingEmail ssi facturation, categories limitees a SECTEUR/AUTRE.
+     * donnees respectent les validators : exclusivite Prospect, billingEmail ssi
+     * facturation, aucune categorie de code DISTRIBUTEUR/COURTIER (RG-1.29).
      *
      * @param list<string> $siteNames     au moins un site (RG-1.10)
-     * @param list<string> $categoryNames categories SECTEUR/AUTRE uniquement (RG-1.29)
+     * @param list<string> $categoryNames categories hors DISTRIBUTEUR/COURTIER (RG-1.29)
      */
     private function addAddress(
         Client $client,

src/Module/Commercial/Infrastructure/Doctrine/DoctrineClientRepository.php

@@ -34,19 +34,34 @@ class DoctrineClientRepository extends ServiceEntityRepository implements Client
     public function createListQueryBuilder(
         bool $includeArchived = false,
         ?string $search = null,
-        ?string $categoryType = null,
+        array $categoryCodes = [],
+        array $siteIds = [],
+        bool $archivedOnly = false,
     ): QueryBuilder {
         $qb = $this->createQueryBuilder('c')
+            // Jointures + addSelect pour hydrater en une seule requete les
+            // collections affichees par le Repertoire (colonnes Catégories /
+            // Site(s)) : sans cela, la serialisation declenche un N+1 (une
+            // requete par client, puis par adresse). Le Paginator ORM
+            // (fetchJoinCollection: true, cf. ClientProvider) gere le COUNT
+            // malgre ces jointures to-many.
+            ->leftJoin('c.categories', 'cat')->addSelect('cat')
+            ->leftJoin('c.addresses', 'addr')->addSelect('addr')
+            ->leftJoin('addr.sites', 'site')->addSelect('site')
             ->andWhere('c.deletedAt IS NULL')
             ->orderBy('c.companyName', 'ASC')
         ;
 
-        if (!$includeArchived) {
+        // Perimetre d'archivage : archivedOnly prioritaire sur includeArchived.
+        if ($archivedOnly) {
+            $qb->andWhere('c.isArchived = true');
+        } elseif (!$includeArchived) {
             $qb->andWhere('c.isArchived = false');
         }
 
         $this->applySearch($qb, $search);
-        $this->applyCategoryType($qb, $categoryType);
+        $this->applyCategoryCodes($qb, $categoryCodes);
+        $this->applySiteIds($qb, $siteIds);
 
         return $qb;
     }
@@ -73,13 +88,18 @@ class DoctrineClientRepository extends ServiceEntityRepository implements Client
     }
 
     /**
-     * Restreint aux clients possedant au moins une categorie du type donne.
-     * Sous-requete IN (plutot qu'un JOIN sur la collection M2M) pour ne pas
-     * perturber le DISTINCT / ORDER BY de la requete principale.
+     * Restreint aux clients possedant au moins une categorie dont le code figure
+     * dans la liste (OR — ERP-78). Alimente le filtre « Catégories » du drawer
+     * (multi) ainsi que les selects « distributeur »/« courtier » (un seul code,
+     * RG-1.03). Sous-requete IN (plutot qu'un JOIN sur la collection M2M) pour ne
+     * pas perturber le DISTINCT / ORDER BY principal.
+     *
+     * @param list<string> $categoryCodes
      */
-    private function applyCategoryType(QueryBuilder $qb, ?string $categoryType): void
+    private function applyCategoryCodes(QueryBuilder $qb, array $categoryCodes): void
     {
-        if (null === $categoryType || '' === trim($categoryType)) {
+        $codes = $this->normalizeStringList($categoryCodes);
+        if ([] === $codes) {
             return;
         }
 
@@ -87,12 +107,84 @@ class DoctrineClientRepository extends ServiceEntityRepository implements Client
             ->select('c2.id')
             ->from(Client::class, 'c2')
             ->join('c2.categories', 'cat2')
-            ->join('cat2.categoryType', 'ct2')
-            ->where('ct2.code = :categoryType')
+            ->where('cat2.code IN (:categoryCodes)')
         ;
 
         $qb->andWhere($qb->expr()->in('c.id', $sub->getDQL()))
-            ->setParameter('categoryType', trim($categoryType))
+            ->setParameter('categoryCodes', $codes)
         ;
     }
+
+    /**
+     * Restreint aux clients ayant au moins une adresse rattachee a l'un des
+     * sites donnes (OR — RG-1.10 : les sites vivent sur les adresses, pas sur le
+     * client). Sous-requete IN pour ne pas perturber le tri/pagination principal.
+     *
+     * @param list<int> $siteIds
+     */
+    private function applySiteIds(QueryBuilder $qb, array $siteIds): void
+    {
+        $ids = $this->normalizeIntList($siteIds);
+        if ([] === $ids) {
+            return;
+        }
+
+        $sub = $this->getEntityManager()->createQueryBuilder()
+            ->select('c3.id')
+            ->from(Client::class, 'c3')
+            ->join('c3.addresses', 'addr3')
+            ->join('addr3.sites', 'site3')
+            ->where('site3.id IN (:siteIds)')
+        ;
+
+        $qb->andWhere($qb->expr()->in('c.id', $sub->getDQL()))
+            ->setParameter('siteIds', $ids)
+        ;
+    }
+
+    /**
+     * Nettoie une liste de chaines : trim, retrait des vides, reindexation.
+     * Defensive : tolere des elements scalaires non-string (cast) et ignore le
+     * reste sans lever de TypeError, le contrat etant justement de normaliser une
+     * entree potentiellement brute (query params).
+     *
+     * @param array<mixed> $values
+     *
+     * @return list<string>
+     */
+    private function normalizeStringList(array $values): array
+    {
+        $out = [];
+        foreach ($values as $value) {
+            if (is_string($value) || is_int($value) || is_float($value)) {
+                $trimmed = trim((string) $value);
+                if ('' !== $trimmed) {
+                    $out[] = $trimmed;
+                }
+            }
+        }
+
+        return $out;
+    }
+
+    /**
+     * Nettoie une liste d'identifiants : cast int, retrait des <= 0, reindexation.
+     * Defensive (cf. normalizeStringList) : accepte des entiers ou des chaines
+     * numeriques ('1', '2') sans TypeError, ignore le reste.
+     *
+     * @param array<mixed> $values
+     *
+     * @return list<int>
+     */
+    private function normalizeIntList(array $values): array
+    {
+        $out = [];
+        foreach ($values as $value) {
+            if (is_numeric($value) && (int) $value > 0) {
+                $out[] = (int) $value;
+            }
+        }
+
+        return $out;
+    }
 }

src/Shared/Domain/Contract/CategoryInterface.php

@@ -20,13 +20,25 @@ interface CategoryInterface
 
     public function getName(): ?string;
 
+    /**
+     * Code technique stable de la categorie (Category::code), ou null si non
+     * encore renseigne. Slug MAJUSCULE derive du nom a la creation, fige ensuite.
+     * Expose pour permettre a un module tiers de filtrer/valider par categorie
+     * metier sans dependre du libelle (`name`) ni de l'`id` (non deterministe
+     * entre environnements) ni importer la classe concrete Category (regle
+     * ABSOLUE n°1). Pilote, cote M1 Commercial :
+     *  - RG-1.03 : un distributor doit referencer un client portant la categorie
+     *    de code DISTRIBUTEUR (resp. COURTIER pour broker) ;
+     *  - RG-1.29 : une adresse interdit les categories de code DISTRIBUTEUR /
+     *    COURTIER (relations entre clients, pas des attributs d'adresse).
+     */
+    public function getCode(): ?string;
+
     /**
      * Code du type de categorie rattache (CategoryType::code), ou null si la
-     * categorie n'a pas de type. Expose pour permettre a un module tiers de
-     * raisonner sur le type metier (ex: M1 Commercial — RG-1.03 : un distributor
-     * doit referencer un client categorise DISTRIBUTEUR ; RG-1.29 : categorie
-     * d'adresse limitee a SECTEUR/AUTRE) sans importer la classe concrete
-     * Category (regle ABSOLUE n°1).
+     * categorie n'a pas de type. Depuis ERP-78, le modele n'a plus qu'un seul
+     * type (CLIENT) : le filtrage metier passe desormais par getCode() ci-dessus.
+     * Conserve pour l'affichage / la retrocompatibilite.
      */
     public function getCategoryTypeCode(): ?string;
 }

src/Shared/Infrastructure/Database/CategoryCodeSql.php

@@ -0,0 +1,60 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Shared\Infrastructure\Database;
+
+/**
+ * Miroir SQL de `CategoryCodeGenerator::slugify()` (module Catalog, ERP-78).
+ *
+ * Le `code` d'une `Category` est un slug MAJUSCULE deterministe du nom. A
+ * l'execution (POST/PATCH API), il est genere en PHP par `CategoryCodeGenerator`
+ * via `AsciiSlugger`. Mais la migration corrective `Version20260602100000` doit
+ * backfiller le `code` des categories pre-existantes en SQL pur (le backfill
+ * tourne dans le plan `addSql`, sans acces aux services applicatifs).
+ *
+ * Deux implementations d'un meme slug = risque de derive : un nom accentue
+ * comme « Independant » doit produire le MEME code (`INDEPENDANT`) quel que soit
+ * le chemin. Cette classe est la SOURCE UNIQUE de l'expression SQL ; son egalite
+ * avec le générateur PHP est verrouillee par `CategoryCodeSqlSlugTest`.
+ *
+ * Domaine couvert : noms francais / Latin-1 (tous les accents, minuscule +
+ * majuscule, translitteres vers l'ASCII comme le fait `AsciiSlugger`). Limite
+ * connue et assumee : les ligatures (`Œ`->`OE`, `ß`->`SS`) ne sont PAS gerees
+ * par `translate()` (mapping 1->1 uniquement) ; elles n'apparaissent pas dans
+ * les noms de categories CLIENT et le backfill ne s'execute de toute facon que
+ * sur des bases dev deja peuplees (en prod la table `category` est vide).
+ */
+final class CategoryCodeSql
+{
+    /** Longueur maximale de la colonne `category.code` (cf. CategoryCodeGenerator). */
+    private const int MAX_LENGTH = 50;
+
+    /**
+     * Accents Latin-1 (minuscules puis majuscules) translitteres vers leur
+     * equivalent ASCII minuscule — `UPPER()` repasse tout en majuscule ensuite.
+     * `translate()` mappe caractere a caractere : `ACCENT_FROM` et `ACCENT_TO`
+     * doivent avoir EXACTEMENT le meme nombre de caracteres.
+     */
+    private const string ACCENT_FROM = 'àâäáãåçéèêëíìîïñóòôöõúùûüýÿÀÂÄÁÃÅÇÉÈÊËÍÌÎÏÑÓÒÔÖÕÚÙÛÜÝŸ';
+    private const string ACCENT_TO   = 'aaaaaaceeeeiiiinooooouuuuyyaaaaaaceeeeiiiinooooouuuuyy';
+
+    /**
+     * Expression SQL produisant le slug du `$column` donne (ex: `name`, `c.name`).
+     * Reproduit fidelement `CategoryCodeGenerator::slugify` : translitteration des
+     * accents, separateurs non alphanumeriques reduits a `_`, MAJUSCULE, borne a
+     * 50, `_` de bord retires, fallback `CATEGORY` si vide.
+     */
+    public static function slugExpression(string $column): string
+    {
+        return sprintf(
+            "COALESCE(NULLIF(TRIM(BOTH '_' FROM "
+            ."LEFT(UPPER(REGEXP_REPLACE(translate(%s, '%s', '%s'), '[^A-Za-z0-9]+', '_', 'g')), %d)"
+            ."), ''), 'CATEGORY')",
+            $column,
+            self::ACCENT_FROM,
+            self::ACCENT_TO,
+            self::MAX_LENGTH,
+        );
+    }
+}

src/Shared/Infrastructure/Database/ColumnCommentsCatalog.php

@@ -53,6 +53,7 @@ final class ColumnCommentsCatalog
                 '_table'           => 'Categories M0 — referentiel type par category_type, soft-delete via deleted_at, unicite (LOWER(name), category_type_id) parmi les actifs.',
                 'id'               => 'Identifiant interne auto-incremente.',
                 'name'             => 'Libelle de la categorie (≤ 120 caracteres) — unique par type parmi les actifs (RG-1.06).',
+                'code'             => 'Code technique stable (slug MAJUSCULE du nom, ≤ 50) — unique parmi les actifs (uq_category_code). Fige a la creation. DISTRIBUTEUR/COURTIER pilotent RG-1.03/1.29.',
                 'category_type_id' => 'Reference au type de la categorie — FK -> category_type.id, ON DELETE RESTRICT (un type ne peut etre supprime tant qu il a des categories).',
                 'deleted_at'       => 'Horodatage UTC du soft-delete (archivage logique) — null si la categorie est active.',
             ] + self::timestampableBlamableComments(),

tests/Module/Catalog/Api/AbstractCatalogApiTestCase.php

@@ -83,6 +83,9 @@ abstract class AbstractCatalogApiTestCase extends AbstractApiTestCase
         $suffix   = substr(bin2hex(random_bytes(4)), 0, 8);
         $category = new Category();
         $category->setName($name ?? self::TEST_CATEGORY_PREFIX.$suffix);
+        // ERP-78 : code NOT NULL + unique parmi les actifs (uq_category_code).
+        // Nonce aleatoire -> unicite garantie entre seeds successifs du test.
+        $category->setCode('TEST_'.strtoupper($suffix));
         $category->setCategoryType($type);
         if (null !== $deletedAt) {
             $category->setDeletedAt($deletedAt);

tests/Module/Catalog/Api/CategoryCodeSqlSlugTest.php

@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Module\Catalog\Api;
+
+use App\Module\Catalog\Application\Service\CategoryCodeGenerator;
+use App\Shared\Infrastructure\Database\CategoryCodeSql;
+use Doctrine\DBAL\Connection;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
+
+/**
+ * Garde-fou ERP-78 : l'expression SQL de slug (CategoryCodeSql, utilisee par le
+ * backfill de la migration Version20260602100000) doit produire EXACTEMENT le
+ * meme code que le generateur applicatif (CategoryCodeGenerator::slugify), sur
+ * tout le domaine de noms francais / Latin-1.
+ *
+ * Verrouille la cause racine du bug initial : deux implementations d'un meme
+ * slug qui derivent silencieusement (« Independant » -> IND_PENDANT cote SQL
+ * faute de translitteration des accents, vs INDEPENDANT cote PHP). On ne couvre
+ * volontairement PAS les ligatures (`Œ`, `ß`) : `translate()` est 1->1 et ne
+ * peut produire `OE`/`SS` ; elles sont hors du domaine des categories CLIENT.
+ *
+ * @internal
+ */
+final class CategoryCodeSqlSlugTest extends KernelTestCase
+{
+    /**
+     * Noms representatifs du domaine reel : accents, cedille, apostrophe,
+     * separateurs varies, parentheses, majuscules accentuees.
+     *
+     * @return iterable<string, array{string}>
+     */
+    public static function nameProvider(): iterable
+    {
+        yield 'sans accent'         => ['Distributeur'];
+        yield 'tiret'               => ['Agro-alimentaire'];
+        yield 'slash'               => ['Transport/Logistique'];
+        yield 'accent aigu'         => ['Indépendant'];
+        yield 'apostrophe + accent' => ["L'Oréal"];
+        yield 'esperluette'         => ['Forêt & Bûcheron'];
+        yield 'cedille majuscule'   => ['Ça va'];
+        yield 'accents multiples'   => ['Naïve façade'];
+        yield 'circonflexe'         => ["Côte d'Azur"];
+        yield 'parentheses'         => ['Zone (Sud)'];
+    }
+
+    #[DataProvider('nameProvider')]
+    public function testSqlSlugMatchesPhpSlug(string $name): void
+    {
+        self::bootKernel();
+        $container = self::getContainer();
+
+        /** @var Connection $conn */
+        $conn = $container->get('doctrine')->getConnection();
+        /** @var CategoryCodeGenerator $generator */
+        $generator = $container->get(CategoryCodeGenerator::class);
+
+        // Evaluation pure de l'expression (aucune table requise) : le nom est
+        // passe en parametre lie a la place de la colonne.
+        $sqlSlug = $conn->fetchOne(
+            'SELECT '.CategoryCodeSql::slugExpression(':name'),
+            ['name' => $name],
+        );
+
+        self::assertSame(
+            $generator->slugify($name),
+            $sqlSlug,
+            sprintf('SQL et PHP doivent produire le meme slug pour "%s".', $name),
+        );
+    }
+}

tests/Module/Catalog/Api/CategoryCodeTest.php

@@ -0,0 +1,90 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Module\Catalog\Api;
+
+/**
+ * Tests ERP-78 : le `code` technique stable de Category.
+ *
+ * Cas couverts :
+ *  - POST : le code est auto-genere (slug MAJUSCULE du nom) et expose en lecture ;
+ *  - le code est en lecture seule : un `code` envoye dans le payload est ignore
+ *    (genere depuis le nom) ;
+ *  - deux noms produisant le meme slug recoivent des codes distincts (suffixe).
+ *
+ * @internal
+ */
+final class CategoryCodeTest extends AbstractCatalogApiTestCase
+{
+    public function testPostGeneratesAndExposesCode(): void
+    {
+        $type   = $this->createCategoryType();
+        $client = $this->createAdminClient();
+
+        $response = $client->request('POST', '/api/categories', [
+            'headers' => ['Content-Type' => 'application/ld+json'],
+            'json'    => [
+                'name'         => self::TEST_CATEGORY_PREFIX.'Agro-alimentaire',
+                'categoryType' => '/api/category_types/'.$type->getId(),
+            ],
+        ]);
+        self::assertResponseStatusCodeSame(201);
+
+        $payload = $response->toArray();
+        // Slug MAJUSCULE du nom, separateurs non alphanumeriques -> `_`.
+        self::assertSame(
+            strtoupper(self::TEST_CATEGORY_PREFIX).'AGRO_ALIMENTAIRE',
+            $payload['code'],
+        );
+    }
+
+    public function testCodeIsReadOnlyAndIgnoredFromPayload(): void
+    {
+        $type   = $this->createCategoryType();
+        $client = $this->createAdminClient();
+
+        $response = $client->request('POST', '/api/categories', [
+            'headers' => ['Content-Type' => 'application/ld+json'],
+            'json'    => [
+                'name'         => self::TEST_CATEGORY_PREFIX.'readonly',
+                'categoryType' => '/api/category_types/'.$type->getId(),
+                // Le client tente d'imposer un code : doit etre ignore.
+                'code'         => 'CLIENT_FORGED',
+            ],
+        ]);
+        self::assertResponseStatusCodeSame(201);
+
+        $payload = $response->toArray();
+        self::assertNotSame('CLIENT_FORGED', $payload['code']);
+        self::assertSame(strtoupper(self::TEST_CATEGORY_PREFIX).'READONLY', $payload['code']);
+    }
+
+    public function testCollidingSlugsGetDistinctCodes(): void
+    {
+        $type   = $this->createCategoryType();
+        $client = $this->createAdminClient();
+
+        // Deux noms differents (donc autorises par uq_category_name_type_active)
+        // mais qui produisent le meme slug -> codes distincts (suffixe `_2`).
+        $first = $client->request('POST', '/api/categories', [
+            'headers' => ['Content-Type' => 'application/ld+json'],
+            'json'    => [
+                'name'         => self::TEST_CATEGORY_PREFIX.'Agro Plus',
+                'categoryType' => '/api/category_types/'.$type->getId(),
+            ],
+        ])->toArray();
+
+        $second = $client->request('POST', '/api/categories', [
+            'headers' => ['Content-Type' => 'application/ld+json'],
+            'json'    => [
+                'name'         => self::TEST_CATEGORY_PREFIX.'Agro-Plus',
+                'categoryType' => '/api/category_types/'.$type->getId(),
+            ],
+        ])->toArray();
+
+        self::assertResponseStatusCodeSame(201);
+        self::assertNotSame($first['code'], $second['code']);
+        self::assertStringEndsWith('_2', (string) $second['code']);
+    }
+}

tests/Module/Commercial/Api/AbstractCommercialApiTestCase.php

@@ -17,13 +17,17 @@ use DateTimeImmutable;
  * Base des tests fonctionnels du module Commercial (M1 — repertoire clients).
  *
  * Etend la base Core : ajoute des factories pour seeder vite des categories
- * typees (DISTRIBUTEUR / COURTIER / SECTEUR) et des clients, plus un helper
- * d'authentification admin.
+ * codees (DISTRIBUTEUR / COURTIER / SECTEUR...) sous le type unique CLIENT et
+ * des clients, plus un helper d'authentification admin.
+ *
+ * Refonte taxonomie ERP-78 : il n'y a plus qu'un type CLIENT ; le code metier
+ * vit desormais sur la Category. `createCategory($code)` est un fetch-or-create
+ * PAR CODE (idempotent) sous CLIENT — deux clients d'un meme test partagent ainsi
+ * la categorie de meme code sans violer l'index unique partiel uq_category_code.
  *
  * Cleanup : tearDown purge clients, categories `test_cli_cat_*` et users/roles
- * `test_*`. Les category_types business sont fetch-or-create (idempotents) et
- * laisses en place (pas de DELETE pour ne pas entrer en conflit avec d'autres
- * suites). Pas de DAMA en local -> purge manuelle obligatoire.
+ * `test_*`. Le type CLIENT est fetch-or-create (idempotent) et laisse en place.
+ * Pas de DAMA en local -> purge manuelle obligatoire.
  *
  * @internal
  */
@@ -31,6 +35,14 @@ abstract class AbstractCommercialApiTestCase extends AbstractApiTestCase
 {
     protected const string TEST_CATEGORY_PREFIX = 'test_cli_cat_';
 
+    /**
+     * Codes pilotant les RG (RG-1.03 distributor/broker, RG-1.29 adresse) : ils
+     * doivent matcher exactement, donc createCategory() les fetch-or-create par
+     * code. Les autres codes sont traites comme de simples libelles generiques et
+     * produisent une categorie a code UNIQUE (cf. createCategory).
+     */
+    private const array RG_EXACT_CODES = ['DISTRIBUTEUR', 'COURTIER'];
+
     protected function tearDown(): void
     {
         $this->cleanupCommercialTestData();
@@ -43,20 +55,20 @@ abstract class AbstractCommercialApiTestCase extends AbstractApiTestCase
     }
 
     /**
-     * Recupere (ou cree) un CategoryType par son code metier. Idempotent : la
+     * Recupere (ou cree) le type unique CLIENT (refonte ERP-78). Idempotent : la
      * contrainte d'unicite sur category_type.code interdit les doublons.
      */
-    protected function createCategoryType(string $code): CategoryType
+    protected function clientCategoryType(): CategoryType
     {
         $em       = $this->getEm();
-        $existing = $em->getRepository(CategoryType::class)->findOneBy(['code' => $code]);
+        $existing = $em->getRepository(CategoryType::class)->findOneBy(['code' => 'CLIENT']);
         if (null !== $existing) {
             return $existing;
         }
 
         $type = new CategoryType();
-        $type->setCode($code);
-        $type->setLabel(ucfirst(strtolower($code)));
+        $type->setCode('CLIENT');
+        $type->setLabel('Client');
         $em->persist($type);
         $em->flush();
 
@@ -64,15 +76,38 @@ abstract class AbstractCommercialApiTestCase extends AbstractApiTestCase
     }
 
     /**
-     * Cree une Category de test rattachee a un type metier donne (code).
+     * Cree une Category de test sous le type unique CLIENT (ERP-78).
+     *
+     * - Code RG (DISTRIBUTEUR / COURTIER) : fetch-or-create par code EXACT — le
+     *   code doit matcher la regle de gestion, et l'appel repete dans un test
+     *   renvoie la meme categorie (pas de violation de uq_category_code).
+     * - Autre code (SECTEUR, AUTRE, ...) : simple libelle generique -> categorie
+     *   a code UNIQUE (suffixe aleatoire). Garantit que deux categories
+     *   « generiques » d'un meme test sont DISTINCTES (ex: detection de
+     *   changement de categorie dans les tests RBAC).
      */
-    protected function createCategory(string $typeCode = 'SECTEUR'): Category
+    protected function createCategory(string $code = 'SECTEUR'): Category
     {
-        $em       = $this->getEm();
-        $suffix   = substr(bin2hex(random_bytes(4)), 0, 8);
+        $em = $this->getEm();
+
+        if (in_array($code, self::RG_EXACT_CODES, true)) {
+            $existing = $em->getRepository(Category::class)->findOneBy(['code' => $code, 'deletedAt' => null]);
+            if (null !== $existing) {
+                return $existing;
+            }
+
+            $effectiveCode = $code;
+            $name          = self::TEST_CATEGORY_PREFIX.strtolower($code);
+        } else {
+            $suffix        = substr(bin2hex(random_bytes(4)), 0, 8);
+            $effectiveCode = strtoupper($code).'_'.strtoupper($suffix);
+            $name          = self::TEST_CATEGORY_PREFIX.strtolower($code).'_'.$suffix;
+        }
+
         $category = new Category();
-        $category->setName(self::TEST_CATEGORY_PREFIX.$suffix);
-        $category->setCategoryType($this->createCategoryType($typeCode));
+        $category->setName($name);
+        $category->setCode($effectiveCode);
+        $category->setCategoryType($this->clientCategoryType());
         $em->persist($category);
         $em->flush();
 
@@ -81,9 +116,10 @@ abstract class AbstractCommercialApiTestCase extends AbstractApiTestCase
 
     /**
      * Seede directement un Client en base (sans passer par l'API), pour les
-     * tests de liste / archivage. Le client porte une categorie SECTEUR.
+     * tests de liste / archivage. Le client porte une categorie du code donne
+     * (defaut SECTEUR — categorie generique non interdite sur adresse).
      */
-    protected function seedClient(string $companyName, bool $isArchived = false, string $categoryTypeCode = 'SECTEUR'): ClientEntity
+    protected function seedClient(string $companyName, bool $isArchived = false, string $categoryCode = 'SECTEUR'): ClientEntity
     {
         $em     = $this->getEm();
         $client = new ClientEntity();
@@ -93,7 +129,7 @@ abstract class AbstractCommercialApiTestCase extends AbstractApiTestCase
         $client->setLastName('Seed');
         $client->setPhonePrimary('0102030405');
         $client->setEmail(strtolower(str_replace(' ', '', $companyName)).'@seed.test');
-        $client->addCategory($this->createCategory($categoryTypeCode));
+        $client->addCategory($this->createCategory($categoryCode));
         $client->setIsArchived($isArchived);
         if ($isArchived) {
             $client->setArchivedAt(new DateTimeImmutable());

tests/Module/Commercial/Api/ClientAddressTest.php

@@ -15,8 +15,8 @@ use App\Module\Sites\Domain\Entity\Site;
  *  - RG-1.06 / RG-1.07 / RG-1.08 : exclusivite is_prospect vs
  *    is_delivery / is_billing ;
  *  - RG-1.11 : billing_email obligatoire ssi is_billing ;
- *  - RG-1.29 : seules les categories de type SECTEUR / AUTRE sont autorisees sur
- *    une adresse (DISTRIBUTEUR / COURTIER -> 422).
+ *  - RG-1.29 (ERP-78) : les categories de code DISTRIBUTEUR / COURTIER sont
+ *    interdites sur une adresse (-> 422) ; toute autre categorie est acceptee.
  *
  * Depuis ERP-76, ces regles sont portees par des Assert\Callback sur l'entite
  * ClientAddress (mirror applicatif des CHECK Postgres) : la combinaison invalide

tests/Module/Commercial/Api/ClientApiTest.php

@@ -4,6 +4,11 @@ declare(strict_types=1);
 
 namespace App\Tests\Module\Commercial\Api;
 
+use ApiPlatform\Symfony\Bundle\Test\Client;
+use App\Module\Commercial\Domain\Entity\Client as ClientEntity;
+use App\Module\Commercial\Domain\Entity\ClientAddress;
+use App\Module\Sites\Domain\Entity\Site;
+
 /**
  * Tests fonctionnels de l'API /api/clients (M1) — branche ERP-55.
  *
@@ -175,6 +180,49 @@ final class ClientApiTest extends AbstractCommercialApiTestCase
         self::assertResponseStatusCodeSame(201);
     }
 
+    public function testPostBrokerReferencingNonBrokerReturns422(): void
+    {
+        $client    = $this->createAdminClient();
+        $cat       = $this->createCategory('SECTEUR');
+        $notBroker = $this->seedClient('Pas Un Courtier', false, 'SECTEUR');
+
+        $client->request('POST', '/api/clients', [
+            'headers' => ['Content-Type' => self::LD],
+            'json'    => [
+                'companyName'  => 'Bad Broker Ref',
+                'firstName'    => 'A',
+                'phonePrimary' => '0102030405',
+                'email'        => 'badbroker@test.fr',
+                'categories'   => ['/api/categories/'.$cat->getId()],
+                'broker'       => '/api/clients/'.$notBroker->getId(),
+            ],
+        ]);
+
+        // RG-1.03 (le broker doit porter la categorie de code COURTIER)
+        self::assertResponseStatusCodeSame(422);
+    }
+
+    public function testPostValidBrokerReturns201(): void
+    {
+        $client = $this->createAdminClient();
+        $cat    = $this->createCategory('SECTEUR');
+        $broker = $this->seedClient('Vrai Courtier', false, 'COURTIER');
+
+        $client->request('POST', '/api/clients', [
+            'headers' => ['Content-Type' => self::LD],
+            'json'    => [
+                'companyName'  => 'Client Avec Courtier',
+                'firstName'    => 'A',
+                'phonePrimary' => '0102030405',
+                'email'        => 'okbroker@test.fr',
+                'categories'   => ['/api/categories/'.$cat->getId()],
+                'broker'       => '/api/clients/'.$broker->getId(),
+            ],
+        ]);
+
+        self::assertResponseStatusCodeSame(201);
+    }
+
     public function testListSortedByCompanyNameAscAndExcludesArchived(): void
     {
         $client = $this->createAdminClient();
@@ -282,4 +330,146 @@ final class ClientApiTest extends AbstractCommercialApiTestCase
         self::assertArrayHasKey('addresses', $data);
         self::assertArrayHasKey('ribs', $data);
     }
+
+    /**
+     * ERP-62 : la LISTE doit alimenter les colonnes « Catégories » (codes) et
+     * « Site(s) » (badges name + color) du Repertoire. On verifie donc que la
+     * collection embarque le `code` de chaque categorie et les sites agreges des
+     * adresses (accessoire Client::getSites()).
+     */
+    public function testListEmbedsCategoryCodesAndAggregatedSites(): void
+    {
+        $client = $this->createAdminClient();
+
+        // Client seede + une adresse rattachee a un site (fixtures Sites).
+        $seed = $this->seedClient('Embed List Co', false, 'DISTRIBUTEUR');
+        $em   = $this->getEm();
+        $site = $em->getRepository(Site::class)->findOneBy([]);
+        self::assertNotNull($site, 'Aucun site seede : impossible de tester la colonne Site(s).');
+
+        $address = new ClientAddress();
+        $address->setClient($seed);
+        $address->setPostalCode('86100');
+        $address->setCity('Châtellerault');
+        $address->setStreet('1 rue du Test');
+        $address->addSite($site);
+        $em->persist($address);
+        $em->flush();
+
+        $member = $client->request('GET', '/api/clients?pagination=false', [
+            'headers' => ['Accept' => self::LD],
+        ])->toArray()['member'];
+
+        $row = null;
+        foreach ($member as $candidate) {
+            if ('EMBED LIST CO' === $candidate['companyName']) {
+                $row = $candidate;
+
+                break;
+            }
+        }
+        self::assertNotNull($row, 'Le client seede doit figurer dans la liste.');
+
+        // Colonne « Catégories » : chaque categorie embarquee porte son code.
+        self::assertNotEmpty($row['categories']);
+        self::assertArrayHasKey('code', $row['categories'][0]);
+        self::assertSame('DISTRIBUTEUR', $row['categories'][0]['code']);
+
+        // Colonne « Site(s) » : sites agreges des adresses, avec name + color.
+        self::assertArrayHasKey('sites', $row);
+        self::assertNotEmpty($row['sites']);
+        self::assertArrayHasKey('name', $row['sites'][0]);
+        self::assertArrayHasKey('color', $row['sites'][0]);
+        self::assertSame($site->getName(), $row['sites'][0]['name']);
+    }
+
+    /**
+     * ERP-62 (drawer) : filtre Catégories multi (?categoryCode[]=A&categoryCode[]=B)
+     * — union des clients possedant l'un OU l'autre code.
+     */
+    public function testListFilterByMultipleCategoryCodes(): void
+    {
+        $client = $this->createAdminClient();
+        $this->seedClient('Filtre Distrib Co', false, 'DISTRIBUTEUR');
+        $this->seedClient('Filtre Courtier Co', false, 'COURTIER');
+        $this->seedClient('Filtre Secteur Co', false, 'SECTEUR');
+
+        $names = $this->companyNames($client, '/api/clients?pagination=false&categoryCode[]=DISTRIBUTEUR&categoryCode[]=COURTIER');
+
+        self::assertContains('FILTRE DISTRIB CO', $names);
+        self::assertContains('FILTRE COURTIER CO', $names);
+        self::assertNotContains('FILTRE SECTEUR CO', $names);
+    }
+
+    /**
+     * ERP-62 (drawer) : filtre Sites (?siteId[]=X) — clients ayant >= 1 adresse
+     * rattachee au site donne.
+     */
+    public function testListFilterBySite(): void
+    {
+        $client = $this->createAdminClient();
+        $em     = $this->getEm();
+
+        $sites = $em->getRepository(Site::class)->findBy([], null, 2);
+        self::assertCount(2, $sites, 'Deux sites seedes requis pour ce test.');
+        [$siteA, $siteB] = $sites;
+
+        $onSiteA = $this->seedClient('Client Sur Site A');
+        $this->attachAddressWithSite($onSiteA, $siteA);
+
+        $onSiteB = $this->seedClient('Client Sur Site B');
+        $this->attachAddressWithSite($onSiteB, $siteB);
+
+        $names = $this->companyNames($client, '/api/clients?pagination=false&siteId[]='.$siteA->getId());
+
+        self::assertContains('CLIENT SUR SITE A', $names);
+        self::assertNotContains('CLIENT SUR SITE B', $names);
+    }
+
+    /**
+     * ERP-62 (drawer) : statut « Archivés » (?archivedOnly=true) — uniquement les
+     * archives, contrairement a includeArchived qui ajoute les archives aux actifs.
+     */
+    public function testListArchivedOnlyReturnsOnlyArchived(): void
+    {
+        $client = $this->createAdminClient();
+        $this->seedClient('Actif Visible Co');
+        $this->seedClient('Archive Visible Co', true);
+
+        $names = $this->companyNames($client, '/api/clients?pagination=false&archivedOnly=true');
+
+        self::assertContains('ARCHIVE VISIBLE CO', $names);
+        self::assertNotContains('ACTIF VISIBLE CO', $names);
+    }
+
+    /**
+     * Rattache une adresse minimale portant un site au client (les sites vivent
+     * sur les adresses, RG-1.10).
+     */
+    private function attachAddressWithSite(ClientEntity $client, Site $site): void
+    {
+        $em      = $this->getEm();
+        $address = new ClientAddress();
+        $address->setClient($client);
+        $address->setPostalCode('86100');
+        $address->setCity('Châtellerault');
+        $address->setStreet('1 rue du Test');
+        $address->addSite($site);
+        $em->persist($address);
+        $em->flush();
+    }
+
+    /**
+     * Helper : recupere les companyName d'une collection /api/clients.
+     *
+     * @return list<string>
+     */
+    private function companyNames(Client $client, string $url): array
+    {
+        $members = $client->request('GET', $url, [
+            'headers' => ['Accept' => self::LD],
+        ])->toArray()['member'];
+
+        return array_map(static fn (array $c): string => $c['companyName'], $members);
+    }
 }

tests/Module/Commercial/Api/ClientExportControllerTest.php

@@ -74,14 +74,14 @@ final class ClientExportControllerTest extends AbstractCommercialApiTestCase
         self::assertNotContains('OTHER BETA', $names);
     }
 
-    public function testExportRespectsCategoryTypeFilter(): void
+    public function testExportRespectsCategoryCodeFilter(): void
     {
         $client = $this->createAdminClient();
         $this->seedClient('Distrib Co', false, 'DISTRIBUTEUR');
         $this->seedClient('Secteur Co', false, 'SECTEUR');
 
         $names = $this->companyNames(
-            $client->request('GET', self::EXPORT_URL.'?categoryType=DISTRIBUTEUR')->getContent(),
+            $client->request('GET', self::EXPORT_URL.'?categoryCode=DISTRIBUTEUR')->getContent(),
         );
 
         self::assertContains('DISTRIB CO', $names);

tests/Module/Commercial/Api/ClientSerializationContractTest.php

@@ -0,0 +1,281 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Module\Commercial\Api;
+
+use App\Module\Commercial\Domain\Entity\Client as ClientEntity;
+use App\Module\Commercial\Domain\Entity\ClientAddress;
+use App\Module\Commercial\Domain\Entity\ClientContact;
+use App\Module\Commercial\Domain\Entity\ClientRib;
+use App\Module\Sites\Domain\Entity\Site;
+
+/**
+ * Tests anti-regression du CONTRAT DE SERIALISATION du repertoire clients (M1).
+ *
+ * Captures reelles du 02/06/2026 (cf. docs/specs/M2-suppliers/spec-back.md
+ * § 4.0.ter) ayant revele 4 bugs silencieux du contrat (aucune erreur levee) :
+ *  - #81 : booleens d'adresse (isProspect/isDelivery/isBilling) absents du JSON
+ *          (Groups sur la propriete `isX`, getter `isX()` derivant l'attribut `x`).
+ *  - #80 : fuite RIB (IBAN/BIC) vers un user sans accounting.view.
+ *  - #82 : code/libelle de Category et Site non embarques (stub IRI nu).
+ *  - enveloppe AP4 : member/totalItems/view sans prefixe `hydra:`, archives exclus.
+ *
+ * REGLE D'OR : ces tests assertent sur le CORPS JSON reel, jamais sur les
+ * annotations. Toute regression de groupe de serialisation casse ici.
+ *
+ * Limite connue (dependance module Sites) : l'entite Site ne porte PAS de champ
+ * `code` (ni SiteInterface) — son libelle est `name`. Les « codes 86/17/82 » de
+ * la spec M2 correspondent en realite au prefixe du code postal des 3 sites
+ * fixtures (86100/17400/82400). On asserte donc le libelle `name` du site
+ * embarque ; l'ajout d'un `Site.code` reste un ticket cote module Sites.
+ *
+ * @internal
+ */
+final class ClientSerializationContractTest extends AbstractCommercialApiTestCase
+{
+    private const string LD         = 'application/ld+json';
+    private const string VALID_IBAN = 'FR1420041010050500013M02606';
+    private const string VALID_BIC  = 'BNPAFRPPXXX';
+
+    // === #81 — Booleens d'adresse presents dans le JSON ===
+
+    public function testAddressBooleansArePresentInDetail(): void
+    {
+        $this->skipIfSitesModuleDisabled();
+
+        $seed = $this->seedCompleteClient('Bool Addr Co');
+        $id   = $seed->getId();
+
+        $http = $this->createAdminClient();
+        $data = $http->request('GET', '/api/clients/'.$id, ['headers' => ['Accept' => self::LD]])->toArray();
+
+        self::assertArrayHasKey('addresses', $data);
+        self::assertNotEmpty($data['addresses']);
+        $address = $data['addresses'][0];
+
+        // Le bug droppait TOTALEMENT ces cles. Apres correctif (Groups +
+        // SerializedName sur le getter), elles sont presentes ET typees bool.
+        self::assertArrayHasKey('isProspect', $address);
+        self::assertArrayHasKey('isDelivery', $address);
+        self::assertArrayHasKey('isBilling', $address);
+
+        // L'adresse seedee est livraison + facturation (prospect exclusif, RG-1.06).
+        // Prouve qu'un booleen `true` est bien serialise (le bug masquait meme les true).
+        self::assertFalse($address['isProspect']);
+        self::assertTrue($address['isDelivery']);
+        self::assertTrue($address['isBilling']);
+    }
+
+    // === #80 — Gating des RIB par accounting.view ===
+
+    public function testRibsPresentForAdminWithAccountingView(): void
+    {
+        $this->skipIfSitesModuleDisabled();
+
+        $seed = $this->seedCompleteClient('Rib Admin Co');
+        $id   = $seed->getId();
+
+        $http = $this->createAdminClient();
+        $data = $http->request('GET', '/api/clients/'.$id, ['headers' => ['Accept' => self::LD]])->toArray();
+
+        // Admin bypass RBAC -> accounting.view -> RIB embarques (label/bic/iban).
+        self::assertArrayHasKey('ribs', $data);
+        self::assertNotEmpty($data['ribs']);
+        self::assertSame('Compte principal', $data['ribs'][0]['label']);
+        self::assertSame(self::VALID_IBAN, $data['ribs'][0]['iban']);
+        self::assertSame(self::VALID_BIC, $data['ribs'][0]['bic']);
+    }
+
+    public function testRibsAbsentForUserWithoutAccountingView(): void
+    {
+        $this->skipIfSitesModuleDisabled();
+
+        $seed = $this->seedCompleteClient('Rib Commerciale Co');
+        $id   = $seed->getId();
+
+        // Commerciale : commercial.clients.view SANS accounting.view.
+        $creds = $this->createUserWithPermission('commercial.clients.view');
+        $http  = $this->authenticatedClient($creds['username'], $creds['password']);
+
+        $data = $http->request('GET', '/api/clients/'.$id, ['headers' => ['Accept' => self::LD]])->toArray();
+
+        // La cle `ribs` est ABSENTE (pas null) : le groupe client:read:accounting
+        // n'est pas ajoute au contexte -> getRibs() jamais serialise. Fin de la
+        // fuite IBAN/BIC.
+        self::assertArrayNotHasKey('ribs', $data);
+    }
+
+    // === #80.bis — Gating par OMISSION des scalaires comptables ===
+
+    public function testAccountingScalarsGatedByOmission(): void
+    {
+        $this->skipIfSitesModuleDisabled();
+
+        $seed = $this->seedCompleteClient('Compta Gating Co');
+        $id   = $seed->getId();
+
+        // Admin : scalaires comptables presents.
+        $admin = $this->createAdminClient();
+        $adminData = $admin->request('GET', '/api/clients/'.$id, ['headers' => ['Accept' => self::LD]])->toArray();
+        self::assertArrayHasKey('siren', $adminData);
+        self::assertSame('123456789', $adminData['siren']);
+        self::assertArrayHasKey('accountNumber', $adminData);
+
+        // Commerciale : scalaires comptables ABSENTS (omission, pas null).
+        $creds = $this->createUserWithPermission('commercial.clients.view');
+        $http  = $this->authenticatedClient($creds['username'], $creds['password']);
+        $data  = $http->request('GET', '/api/clients/'.$id, ['headers' => ['Accept' => self::LD]])->toArray();
+
+        self::assertArrayNotHasKey('siren', $data);
+        self::assertArrayNotHasKey('accountNumber', $data);
+        self::assertArrayNotHasKey('nTva', $data);
+        self::assertArrayNotHasKey('ribs', $data);
+    }
+
+    // === #82 — Embed code/libelle des Category et Site ===
+
+    public function testCategoriesEmbedCodeAndLabel(): void
+    {
+        $this->skipIfSitesModuleDisabled();
+
+        $seed = $this->seedCompleteClient('Embed Cat Co');
+        $id   = $seed->getId();
+
+        $http = $this->createAdminClient();
+        $data = $http->request('GET', '/api/clients/'.$id, ['headers' => ['Accept' => self::LD]])->toArray();
+
+        self::assertNotEmpty($data['categories']);
+        $category = $data['categories'][0];
+        // Avant correctif : seuls @id/@type/createdAt/updatedAt (category:read
+        // absent du contexte). Apres : code + name (libelle) embarques.
+        self::assertArrayHasKey('code', $category);
+        self::assertArrayHasKey('name', $category);
+        self::assertNotSame('', $category['code']);
+    }
+
+    public function testAddressSitesEmbedLabel(): void
+    {
+        $this->skipIfSitesModuleDisabled();
+
+        $seed = $this->seedCompleteClient('Embed Site Co');
+        $id   = $seed->getId();
+
+        $http = $this->createAdminClient();
+        $data = $http->request('GET', '/api/clients/'.$id, ['headers' => ['Accept' => self::LD]])->toArray();
+
+        $address = $data['addresses'][0];
+        self::assertArrayHasKey('sites', $address);
+        self::assertNotEmpty($address['sites']);
+        // Site embarque : libelle `name` present (avant : stub @id/@type nu).
+        // NB : Site n'a pas de champ `code` (cf. note de classe) -> on asserte name.
+        self::assertArrayHasKey('name', $address['sites'][0]);
+        self::assertNotSame('', $address['sites'][0]['name']);
+
+        // L'adresse seedee est multi-sites : preuve que l'embed parcourt la collection.
+        self::assertGreaterThanOrEqual(2, count($address['sites']));
+
+        // Categories d'adresse : code embarque (category:read dans le contexte).
+        self::assertArrayHasKey('categories', $address);
+        self::assertNotEmpty($address['categories']);
+        self::assertArrayHasKey('code', $address['categories'][0]);
+    }
+
+    // === Enveloppe AP4 (sans prefixe hydra:) + exclusion des archives ===
+
+    public function testCollectionEnvelopeShapeAndArchivedExcluded(): void
+    {
+        $http   = $this->createAdminClient();
+        $prefix = 'EnvCheck'.substr(bin2hex(random_bytes(3)), 0, 6);
+
+        $this->seedClient($prefix.' Active');
+        $this->seedClient($prefix.' Archived', true);
+
+        // Liste par defaut filtree sur le prefixe : enveloppe member/totalItems
+        // sans prefixe hydra:, archive EXCLU du totalItems (RG-1.24).
+        $default = $http->request('GET', '/api/clients?search='.$prefix, ['headers' => ['Accept' => self::LD]])->toArray();
+
+        self::assertArrayHasKey('member', $default);
+        self::assertArrayHasKey('totalItems', $default);
+        self::assertArrayNotHasKey('hydra:member', $default);
+        self::assertArrayNotHasKey('hydra:totalItems', $default);
+        self::assertSame(1, $default['totalItems'], 'Archive exclu du totalItems par defaut.');
+
+        // includeArchived : l'archive reintegre le total.
+        $all = $http->request('GET', '/api/clients?search='.$prefix.'&includeArchived=true', ['headers' => ['Accept' => self::LD]])->toArray();
+        self::assertSame(2, $all['totalItems']);
+
+        // `view` (PartialCollectionView) sans prefixe hydra: : force le multi-page
+        // via itemsPerPage=1 sur les 2 resultats archives inclus.
+        $paged = $http->request('GET', '/api/clients?search='.$prefix.'&includeArchived=true&itemsPerPage=1', ['headers' => ['Accept' => self::LD]])->toArray();
+        self::assertArrayHasKey('view', $paged);
+        self::assertArrayNotHasKey('hydra:view', $paged);
+    }
+
+    // === Helper ===
+
+    /**
+     * Seede un client COMPLET (sans passer par l'API, validations applicatives
+     * non rejouees mais CHECK BDD respectes) : bloc comptable non nul, >= 1 RIB,
+     * >= 1 adresse multi-sites avec categories, >= 1 contact, >= 1 categorie.
+     *
+     * L'adresse est livraison + facturation (prospect exclusif, RG-1.06 ; email
+     * de facturation present, RG-1.11) afin de poser des booleens `true`
+     * serialisables tout en respectant les CHECK Postgres.
+     */
+    private function seedCompleteClient(string $companyName): ClientEntity
+    {
+        $em = $this->getEm();
+
+        // Nom unique parmi les actifs (index partiel uq_client_company_name_active).
+        $suffix = substr(bin2hex(random_bytes(3)), 0, 6);
+
+        $client = new ClientEntity();
+        $client->setCompanyName(mb_strtoupper($companyName.' '.$suffix, 'UTF-8'));
+        $client->setLastName('Complet');
+        $client->setPhonePrimary('0102030405');
+        $client->setEmail('complet'.$suffix.'@seed.test');
+        $client->addCategory($this->createCategory('SECTEUR'));
+        // Bloc comptable non nul (gating par omission cote Commerciale).
+        $client->setSiren('123456789');
+        $client->setAccountNumber('C0001');
+        $client->setNTva('FR00123456789');
+        $em->persist($client);
+
+        // >= 2 sites fixtures pour une adresse multi-sites (RG-1.10).
+        $sites = $em->getRepository(Site::class)->findBy([], null, 2);
+        self::assertGreaterThanOrEqual(2, count($sites), 'Au moins 2 sites fixtures requis (SitesFixtures).');
+
+        $address = new ClientAddress();
+        $address->setClient($client);
+        $address->setIsProspect(false);
+        $address->setIsDelivery(true);
+        $address->setIsBilling(true);
+        $address->setBillingEmail('billing'.$suffix.'@seed.test');
+        $address->setPostalCode('86000');
+        $address->setCity('Poitiers');
+        $address->setStreet('12 rue des Acacias');
+        foreach ($sites as $site) {
+            $address->addSite($site);
+        }
+        $address->addCategory($this->createCategory('SECTEUR'));
+        $em->persist($address);
+
+        $rib = new ClientRib();
+        $rib->setClient($client);
+        $rib->setLabel('Compte principal');
+        $rib->setBic(self::VALID_BIC);
+        $rib->setIban(self::VALID_IBAN);
+        $em->persist($rib);
+
+        $contact = new ClientContact();
+        $contact->setClient($client);
+        $contact->setFirstName('Marie');
+        $contact->setLastName('Martin');
+        $em->persist($contact);
+
+        $em->flush();
+
+        return $client;
+    }
+}