fix(audit-log) : exclut audit_log du schema_filter Doctrine

La table audit_log n'a pas d'entite ORM (ecriture DBAL brut via
AuditLogWriter pour eviter la recursion du listener). doctrine:schema:update
la considerait donc comme orpheline et la droppait systematiquement, ce qui
cassait la base de test apres chaque make test-db-setup (DROP TABLE audit_log
genere par schema:update --force, apres les migrations qui l'avaient creee).

Un schema_filter en negative lookahead sur la connexion default exclut la
table de toute comparaison de schema (schema:update, schema:validate, diff
de migrations). La creation / suppression reste pilotee exclusivement par
la migration Version20260420202749.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

CLAUDE.md

@@ -234,6 +234,7 @@ Exemples : `feat : add login page`, `fix(auth) : prevent null token crash`
 - Controllers custom sous `/api/` : ajouter `priority: 1` sur `#[Route]` pour eviter le conflit avec API Platform `{id}`
 - Serialization : pour embarquer une relation (pas IRI), ajouter le groupe du parent aux proprietes de l'entite cible
 - Upload fichiers : utiliser `$file->getMimeType()` (pas `getClientMimeType()`) pour valider cote serveur
+- **Audit obligatoire** : toute entite (nouvelle ou existante) doit porter `#[Auditable]` (dans `Shared/Domain/Attribute/`). Les champs sensibles (password, token, secret) doivent etre annotes `#[AuditIgnore]`. Spec complete : `doc/audit-log.md`
 
 ### Frontend
 
@@ -246,6 +247,14 @@ Exemples : `feat : add login page`, `fix(auth) : prevent null token crash`
 - Traductions dans `frontend/i18n/locales/` avec le namespace `sidebar.*` pour la nav
 - 4 espaces d'indentation
 - Les labels de sidebar sont des cles i18n, jamais du texte brut (le layout applique `t()` dessus)
+- **Tableaux : pas de persistance URL.** Aucun etat de tableau (filtres, pagination, tri, tri par colonne, selection, ligne active...) ne doit etre persiste dans la query string ou reinjecte depuis `route.query` au montage. L'etat vit uniquement dans le composant (reactive locale). Seuls les deep links "de navigation metier" (ex: ouvrir un detail precis `/users/42`) sont dans l'URL, jamais l'etat UI du tableau. Exceptions autorisees sur demande explicite de l'utilisateur.
+- **Composants formulaires : utiliser `@malio/layer-ui`.** Tout champ de formulaire / filtre doit utiliser les composants `Malio*` (MalioInputText, MalioSelect, MalioSelectCheckbox, MalioCheckbox, MalioRadioButton, MalioInputNumber, MalioInputAmount, MalioInputPassword, MalioInputTextArea, MalioInputUpload, MalioTime, MalioButton, MalioButtonIcon) plutot que des `<input>` / `<select>` bruts.
+  - **Exceptions autorisees** (a commenter en TODO lors du premier usage, pour pouvoir migrer quand la lib evoluera) :
+    1. Type de champ non couvert par la lib : `datetime-local`, `date`, `color picker`, `file drag & drop`, etc.
+    2. Bug connu bloquant du composant : ex. `MalioSelect` avec options a valeur string (cf. note dans le Lesstime CLAUDE.md). Documenter le bug avec un commentaire pointant la limitation.
+  - Toute autre exception doit etre validee par l'equipe avant merge.
+- **Tableaux de donnees : utiliser `MalioDataTable`.** Tout affichage LISTE tabulaire (donnees metier paginees, CRUD admin) doit passer par `MalioDataTable` (pagination + slots `#header-*` pour filtres + `#cell-*` pour rendu custom). Pas de `<table>` brut avec pagination custom. **Exception** : les tableaux purement presentationnels non-paginables (diff field/old/new, grille de comparaison, matrice RBAC, etc.) peuvent rester en `<table>` HTML brut — MalioDataTable n'est pas adapte a ces cas.
+- **Audit ManyToMany** : le listener trace les modifications de collections to-many (`permissions`, etc.) sous forme `{fieldName: {added: [ids], removed: [ids]}}`. Toute nouvelle entite `#[Auditable]` portant des ManyToMany a auditer beneficie automatiquement de cette couverture — aucune action supplementaire requise.
 
 ### Nginx
 

composer.json

@@ -31,6 +31,8 @@
         "symfony/runtime": "8.0.*",
         "symfony/security-bundle": "8.0.*",
         "symfony/serializer": "8.0.*",
+        "symfony/twig-bundle": "8.0.*",
+        "symfony/uid": "8.0.*",
         "symfony/validator": "8.0.*",
         "symfony/yaml": "8.0.*"
     },

composer.lock

@@ -4,7 +4,7 @@
         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
         "This file is @generated automatically"
     ],
-    "content-hash": "75f8e672f2a401290886fbcf01befd3f",
+    "content-hash": "d65a546151abb6b977fbf7f1c86d14fe",
     "packages": [
         {
             "name": "api-platform/doctrine-common",
@@ -7226,6 +7226,198 @@
             ],
             "time": "2025-07-15T13:41:35+00:00"
         },
+        {
+            "name": "symfony/twig-bridge",
+            "version": "v8.0.8",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/symfony/twig-bridge.git",
+                "reference": "a892d0b7f3d5d51b35895467e48aafbd1f2612a0"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/symfony/twig-bridge/zipball/a892d0b7f3d5d51b35895467e48aafbd1f2612a0",
+                "reference": "a892d0b7f3d5d51b35895467e48aafbd1f2612a0",
+                "shasum": ""
+            },
+            "require": {
+                "php": ">=8.4",
+                "symfony/translation-contracts": "^2.5|^3",
+                "twig/twig": "^3.21"
+            },
+            "conflict": {
+                "phpdocumentor/reflection-docblock": "<5.2|>=7",
+                "phpdocumentor/type-resolver": "<1.5.1",
+                "symfony/form": "<7.4.4|>8.0,<8.0.4",
+                "symfony/mime": "<7.4.8|>8.0,<8.0.8"
+            },
+            "require-dev": {
+                "egulias/email-validator": "^2.1.10|^3|^4",
+                "league/html-to-markdown": "^5.0",
+                "phpdocumentor/reflection-docblock": "^5.2|^6.0",
+                "symfony/asset": "^7.4|^8.0",
+                "symfony/asset-mapper": "^7.4|^8.0",
+                "symfony/console": "^7.4|^8.0",
+                "symfony/dependency-injection": "^7.4|^8.0",
+                "symfony/emoji": "^7.4|^8.0",
+                "symfony/expression-language": "^7.4|^8.0",
+                "symfony/finder": "^7.4|^8.0",
+                "symfony/form": "^7.4.4|^8.0.4",
+                "symfony/html-sanitizer": "^7.4|^8.0",
+                "symfony/http-foundation": "^7.4|^8.0",
+                "symfony/http-kernel": "^7.4|^8.0",
+                "symfony/intl": "^7.4|^8.0",
+                "symfony/mime": "^7.4.8|^8.0.8",
+                "symfony/polyfill-intl-icu": "^1.0",
+                "symfony/property-info": "^7.4|^8.0",
+                "symfony/routing": "^7.4|^8.0",
+                "symfony/security-acl": "^2.8|^3.0",
+                "symfony/security-core": "^7.4|^8.0",
+                "symfony/security-csrf": "^7.4|^8.0",
+                "symfony/security-http": "^7.4|^8.0",
+                "symfony/serializer": "^7.4|^8.0",
+                "symfony/stopwatch": "^7.4|^8.0",
+                "symfony/translation": "^7.4|^8.0",
+                "symfony/validator": "^7.4|^8.0",
+                "symfony/web-link": "^7.4|^8.0",
+                "symfony/workflow": "^7.4|^8.0",
+                "symfony/yaml": "^7.4|^8.0",
+                "twig/cssinliner-extra": "^3",
+                "twig/inky-extra": "^3",
+                "twig/markdown-extra": "^3"
+            },
+            "type": "symfony-bridge",
+            "autoload": {
+                "psr-4": {
+                    "Symfony\\Bridge\\Twig\\": ""
+                },
+                "exclude-from-classmap": [
+                    "/Tests/"
+                ]
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Fabien Potencier",
+                    "email": "fabien@symfony.com"
+                },
+                {
+                    "name": "Symfony Community",
+                    "homepage": "https://symfony.com/contributors"
+                }
+            ],
+            "description": "Provides integration for Twig with various Symfony components",
+            "homepage": "https://symfony.com",
+            "support": {
+                "source": "https://github.com/symfony/twig-bridge/tree/v8.0.8"
+            },
+            "funding": [
+                {
+                    "url": "https://symfony.com/sponsor",
+                    "type": "custom"
+                },
+                {
+                    "url": "https://github.com/fabpot",
+                    "type": "github"
+                },
+                {
+                    "url": "https://github.com/nicolas-grekas",
+                    "type": "github"
+                },
+                {
+                    "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+                    "type": "tidelift"
+                }
+            ],
+            "time": "2026-03-30T15:14:47+00:00"
+        },
+        {
+            "name": "symfony/twig-bundle",
+            "version": "v8.0.8",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/symfony/twig-bundle.git",
+                "reference": "f83767b78e2580ca9fe9a2cf6fcff19cd5389bc1"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/symfony/twig-bundle/zipball/f83767b78e2580ca9fe9a2cf6fcff19cd5389bc1",
+                "reference": "f83767b78e2580ca9fe9a2cf6fcff19cd5389bc1",
+                "shasum": ""
+            },
+            "require": {
+                "composer-runtime-api": ">=2.1",
+                "php": ">=8.4",
+                "symfony/config": "^7.4|^8.0",
+                "symfony/dependency-injection": "^7.4|^8.0",
+                "symfony/http-foundation": "^7.4|^8.0",
+                "symfony/http-kernel": "^7.4|^8.0",
+                "symfony/twig-bridge": "^7.4|^8.0"
+            },
+            "require-dev": {
+                "symfony/asset": "^7.4|^8.0",
+                "symfony/expression-language": "^7.4|^8.0",
+                "symfony/finder": "^7.4|^8.0",
+                "symfony/form": "^7.4|^8.0",
+                "symfony/framework-bundle": "^7.4|^8.0",
+                "symfony/routing": "^7.4|^8.0",
+                "symfony/runtime": "^7.4|^8.0",
+                "symfony/stopwatch": "^7.4|^8.0",
+                "symfony/translation": "^7.4|^8.0",
+                "symfony/web-link": "^7.4|^8.0",
+                "symfony/yaml": "^7.4|^8.0"
+            },
+            "type": "symfony-bundle",
+            "autoload": {
+                "psr-4": {
+                    "Symfony\\Bundle\\TwigBundle\\": ""
+                },
+                "exclude-from-classmap": [
+                    "/Tests/"
+                ]
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Fabien Potencier",
+                    "email": "fabien@symfony.com"
+                },
+                {
+                    "name": "Symfony Community",
+                    "homepage": "https://symfony.com/contributors"
+                }
+            ],
+            "description": "Provides a tight integration of Twig into the Symfony full-stack framework",
+            "homepage": "https://symfony.com",
+            "support": {
+                "source": "https://github.com/symfony/twig-bundle/tree/v8.0.8"
+            },
+            "funding": [
+                {
+                    "url": "https://symfony.com/sponsor",
+                    "type": "custom"
+                },
+                {
+                    "url": "https://github.com/fabpot",
+                    "type": "github"
+                },
+                {
+                    "url": "https://github.com/nicolas-grekas",
+                    "type": "github"
+                },
+                {
+                    "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+                    "type": "tidelift"
+                }
+            ],
+            "time": "2026-03-30T15:14:47+00:00"
+        },
         {
             "name": "symfony/type-info",
             "version": "v8.0.8",
@@ -7807,6 +7999,86 @@
             ],
             "time": "2026-03-30T15:14:47+00:00"
         },
+        {
+            "name": "twig/twig",
+            "version": "v3.24.0",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/twigphp/Twig.git",
+                "reference": "a6769aefb305efef849dc25c9fd1653358c148f0"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/twigphp/Twig/zipball/a6769aefb305efef849dc25c9fd1653358c148f0",
+                "reference": "a6769aefb305efef849dc25c9fd1653358c148f0",
+                "shasum": ""
+            },
+            "require": {
+                "php": ">=8.1.0",
+                "symfony/deprecation-contracts": "^2.5|^3",
+                "symfony/polyfill-ctype": "^1.8",
+                "symfony/polyfill-mbstring": "^1.3"
+            },
+            "require-dev": {
+                "php-cs-fixer/shim": "^3.0@stable",
+                "phpstan/phpstan": "^2.0@stable",
+                "psr/container": "^1.0|^2.0",
+                "symfony/phpunit-bridge": "^5.4.9|^6.4|^7.0"
+            },
+            "type": "library",
+            "autoload": {
+                "files": [
+                    "src/Resources/core.php",
+                    "src/Resources/debug.php",
+                    "src/Resources/escaper.php",
+                    "src/Resources/string_loader.php"
+                ],
+                "psr-4": {
+                    "Twig\\": "src/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "BSD-3-Clause"
+            ],
+            "authors": [
+                {
+                    "name": "Fabien Potencier",
+                    "email": "fabien@symfony.com",
+                    "homepage": "http://fabien.potencier.org",
+                    "role": "Lead Developer"
+                },
+                {
+                    "name": "Twig Team",
+                    "role": "Contributors"
+                },
+                {
+                    "name": "Armin Ronacher",
+                    "email": "armin.ronacher@active-4.com",
+                    "role": "Project Founder"
+                }
+            ],
+            "description": "Twig, the flexible, fast, and secure template language for PHP",
+            "homepage": "https://twig.symfony.com",
+            "keywords": [
+                "templating"
+            ],
+            "support": {
+                "issues": "https://github.com/twigphp/Twig/issues",
+                "source": "https://github.com/twigphp/Twig/tree/v3.24.0"
+            },
+            "funding": [
+                {
+                    "url": "https://github.com/fabpot",
+                    "type": "github"
+                },
+                {
+                    "url": "https://tidelift.com/funding/github/packagist/twig/twig",
+                    "type": "tidelift"
+                }
+            ],
+            "time": "2026-03-17T21:31:11+00:00"
+        },
         {
             "name": "webmozart/assert",
             "version": "2.1.6",

config/bundles.php

@@ -11,6 +11,7 @@ use Nelmio\CorsBundle\NelmioCorsBundle;
 use Symfony\Bundle\FrameworkBundle\FrameworkBundle;
 use Symfony\Bundle\MonologBundle\MonologBundle;
 use Symfony\Bundle\SecurityBundle\SecurityBundle;
+use Symfony\Bundle\TwigBundle\TwigBundle;
 
 return [
     FrameworkBundle::class              => ['all' => true],
@@ -22,4 +23,5 @@ return [
     DoctrineFixturesBundle::class       => ['dev' => true, 'test' => true],
     LexikJWTAuthenticationBundle::class => ['all' => true],
     MonologBundle::class                => ['all' => true],
+    TwigBundle::class                   => ['all' => true],
 ];

config/modules.php

@@ -3,8 +3,10 @@
 declare(strict_types=1);
 use App\Module\Commercial\CommercialModule;
 use App\Module\Core\CoreModule;
+use App\Module\Sites\SitesModule;
 
 return [
     CoreModule::class,
     CommercialModule::class,
+    SitesModule::class,
 ];

config/packages/api_platform.yaml

@@ -9,6 +9,9 @@ api_platform:
     mapping:
         paths:
             - '%kernel.project_dir%/src/Module/Core/Domain/Entity'
+            # Resources virtuelles (sans entite Doctrine) declarees via #[ApiResource]
+            # en dehors de Domain/Entity : AuditLogResource, etc.
+            - '%kernel.project_dir%/src/Module/Core/Infrastructure/ApiPlatform/Resource'
     formats:
         jsonld: ['application/ld+json']
         json: ['application/json']

config/packages/doctrine.yaml

@@ -1,7 +1,25 @@
 doctrine:
     dbal:
-        url: '%env(resolve:DATABASE_URL)%'
-        profiling_collect_backtrace: '%kernel.debug%'
+        # Deux connexions pointant sur le meme DSN : l'ORM utilise `default`,
+        # l'AuditLogWriter utilise `audit` pour ecrire hors de la transaction
+        # Doctrine et eviter tout entanglement transactionnel en batch.
+        default_connection: default
+        connections:
+            default:
+                url: '%env(resolve:DATABASE_URL)%'
+                profiling_collect_backtrace: '%kernel.debug%'
+                # Exclut `audit_log` de toute operation de comparaison de schema
+                # (doctrine:schema:update, schema:validate, diff de migrations...).
+                # Cette table n'a volontairement aucune entite mappee : elle est
+                # append-only via DBAL brut (AuditLogWriter) pour eviter la
+                # recursion du listener Doctrine. Sans ce filtre, schema:update
+                # la considere comme "orpheline" et genere un `DROP TABLE
+                # audit_log` qui casse la base de test apres chaque
+                # `make test-db-setup`. La creation / suppression de la table
+                # reste pilotee par les migrations (cf. Version20260420202749).
+                schema_filter: '~^(?!audit_log$).+~'
+            audit:
+                url: '%env(resolve:DATABASE_URL)%'
     orm:
         validate_xml_mapping: true
         naming_strategy: doctrine.orm.naming_strategy.underscore_number_aware
@@ -15,13 +33,54 @@ doctrine:
                 dir: '%kernel.project_dir%/src/Module/Core/Domain/Entity'
                 prefix: 'App\Module\Core\Domain\Entity'
                 alias: Core
+            # Mapping inconditionnelle du module Sites : la structure DB
+            # existe meme si SitesModule::class est retire de config/modules.php.
+            # L'activation fonctionnelle (ex: exposition des permissions, futurs
+            # endpoints API) passe exclusivement par config/modules.php.
+            Sites:
+                type: attribute
+                is_bundle: false
+                dir: '%kernel.project_dir%/src/Module/Sites/Domain/Entity'
+                prefix: 'App\Module\Sites\Domain\Entity'
+                alias: Sites
         controller_resolver:
             auto_mapping: false
 
 when@test:
     doctrine:
         dbal:
-            dbname_suffix: '_test%env(default::TEST_TOKEN)%'
+            # Le suffixe "_test" doit etre propage aux deux connexions : l'ORM
+            # l'herite via `default`, l'AuditLogWriter via `audit`. Sans cela,
+            # la connexion `audit` ecrirait dans la base dev pendant que l'ORM
+            # ecrit dans la base test — divergence invisible en apparence mais
+            # fatale pour les tests du journal d'audit.
+            #
+            # `idle_connection_ttl: 1` (au lieu du defaut 600s) : en test on
+            # reboote le kernel a chaque test. Sans TTL court, les connexions
+            # orphelines s'accumulent dans PG et on finit par saturer le pool
+            # (max_connections=100) sur une suite de 200+ tests qui utilisent
+            # 2 connexions chacun (default + audit).
+            connections:
+                default:
+                    dbname_suffix: '_test%env(default::TEST_TOKEN)%'
+                    idle_connection_ttl: 1
+                audit:
+                    dbname_suffix: '_test%env(default::TEST_TOKEN)%'
+                    idle_connection_ttl: 1
+        orm:
+            mappings:
+                # Entite fictive SiteAware utilisee uniquement en tests du
+                # module Sites (ticket 4). Le mapping n'est charge qu'en
+                # environnement test, donc aucun impact sur les schemas
+                # dev/prod. La table est creee a la volee par les tests
+                # d'integration (via `SchemaTool::createSchema`) dans le
+                # setUp de SiteScopedQueryExtensionTest.
+                TestFixtures:
+                    type: attribute
+                    is_bundle: false
+                    dir: '%kernel.project_dir%/tests/Fixtures/SiteAware'
+                    prefix: 'App\Tests\Fixtures\SiteAware'
+                    alias: TestFixtures
 
 when@prod:
     doctrine:

config/packages/twig.yaml

@@ -0,0 +1,6 @@
+twig:
+    file_name_pattern: '*.twig'
+
+when@test:
+    twig:
+        strict_variables: true

config/reference.php

@@ -467,7 +467,7 @@ use Symfony\Component\Config\Loader\ParamConfigurator as Param;
  *     },
  *     disallow_search_engine_index?: bool|Param, // Enabled by default when debug is enabled. // Default: true
  *     http_client?: bool|array{ // HTTP Client configuration
- *         enabled?: bool|Param, // Default: true
+ *         enabled?: bool|Param, // Default: false
  *         max_host_connections?: int|Param, // The maximum number of connections to a single host.
  *         default_options?: array{
  *             headers?: array<string, mixed>,

config/services.yaml

@@ -24,3 +24,9 @@ services:
 
     App\Module\Core\Domain\Repository\UserRepositoryInterface:
         alias: App\Module\Core\Infrastructure\Doctrine\DoctrineUserRepository
+
+    App\Module\Sites\Domain\Repository\SiteRepositoryInterface:
+        alias: App\Module\Sites\Infrastructure\Doctrine\DoctrineSiteRepository
+
+    App\Module\Sites\Application\Service\CurrentSiteProviderInterface:
+        alias: App\Module\Sites\Application\Service\CurrentSiteProvider

config/sidebar.php

@@ -6,34 +6,62 @@ declare(strict_types=1);
  * Sidebar configuration.
  *
  * This file defines the sidebar sections displayed in the frontend.
- * Each item references the module that owns it via the `module` key.
- * Items whose module is not active (see config/modules.php) are filtered out.
- * Items may also declare a `permission` key (RBAC permission code) : the item
- * is hidden from users who do not hold that permission.
+ *
+ * Each SECTION may declare :
+ *   - `label` (required)    : i18n key resolved by the frontend
+ *   - `icon`  (required)    : MDI icon name
+ *   - `items` (required)    : list of items (see below)
+ *   - `permission` (opt.)   : RBAC permission code ; when set, the whole
+ *                             section (and every one of its items) is hidden
+ *                             from users who do not hold that permission.
+ *                             Use this for "umbrella" sections like
+ *                             Administration where you want to gate the
+ *                             entire group behind one coarse permission.
+ *
+ * Each ITEM may declare :
+ *   - `label`      (required)  : i18n key
+ *   - `to`         (required)  : Nuxt route
+ *   - `icon`       (required)  : MDI icon name
+ *   - `module`     (required)  : owner module ID ; item is hidden if the
+ *                                module is not listed in config/modules.php
+ *   - `permission` (opt.)      : RBAC permission code ; finer-grained gate
+ *                                applied in addition to the section-level one
+ *
+ * Precedence : section-level `permission` is evaluated first. If it fails,
+ * the whole section is skipped and every item's `to` is added to the
+ * `disabledRoutes` payload of /api/sidebar (so the front middleware can
+ * redirect any direct navigation). Individual items without their own
+ * permission are implicitly protected by the section-level one.
  *
  * This config is decoupled from the modules themselves: you can freely
  * move an item from one section to another without touching the module code.
- *
- * Label keys are i18n keys resolved by the frontend (see frontend/i18n/locales/).
  */
 
 return [
+    // Section "Administration" : regroupe toutes les pages de configuration
+    // applicative (RBAC, users, sites, audit log).
+    //
+    // CONVENTION : "etre admin" = detenir au moins une permission admin-scoped.
+    // En pratique, le groupe `core.*` represente l'administration applicative
+    // (users, roles, audit_log) ; les autres permissions admin-scoped proviennent
+    // des modules qui exposent leur propre page d'admin dans cette section
+    // (ex: `sites.view`). Un user qui n'a AUCUNE de ces permissions n'a pas
+    // acces a l'administration.
+    //
+    // Gate implicite : tous les items de cette section declarent une `permission`.
+    // Sans aucune permission correspondante, tous les items sont filtres, la
+    // section devient vide et est automatiquement masquee par SidebarProvider
+    // (cf. la boucle de filtrage : section vide => `continue`). Inutile donc
+    // d'ajouter un gate explicite au niveau section tant que chaque item porte
+    // sa propre permission.
+    //
+    // Pour imposer un gate explicite supplementaire (ex: "seuls les membres du
+    // groupe support voient l'administration, meme s'ils ont des permissions
+    // individuelles"), ajouter : 'permission' => 'core.admin.access'.
     [
-        'label' => 'sidebar.general.section',
-        'icon'  => 'mdi:view-dashboard-outline',
+        'label' => 'sidebar.administration.section',
+        'icon'  => 'mdi:cog-outline',
         'items' => [
-            [
-                'label'  => 'sidebar.general.dashboard',
-                'to'     => '/',
-                'icon'   => 'mdi:view-dashboard-outline',
-                'module' => 'core',
-            ],
-            [
-                'label'  => 'sidebar.general.admin',
-                'to'     => '/admin',
-                'icon'   => 'mdi:cog-outline',
-                'module' => 'core',
-            ],
             [
                 'label'      => 'sidebar.core.roles',
                 'to'         => '/admin/roles',
@@ -49,10 +77,18 @@ return [
                 'permission' => 'core.users.view',
             ],
             [
-                'label'  => 'sidebar.general.logout',
-                'to'     => '/logout',
-                'icon'   => 'mdi:logout',
-                'module' => 'core',
+                'label'      => 'sidebar.core.sites',
+                'to'         => '/admin/sites',
+                'icon'       => 'mdi:domain',
+                'module'     => 'sites',
+                'permission' => 'sites.view',
+            ],
+            [
+                'label'      => 'sidebar.core.audit_log',
+                'to'         => '/admin/audit-log',
+                'icon'       => 'mdi:clipboard-text-clock',
+                'module'     => 'core',
+                'permission' => 'core.audit_log.view',
             ],
         ],
     ],
@@ -68,4 +104,25 @@ return [
             ],
         ],
     ],
+    // Section "Mon compte" : espace personnel. Accessible a tout user authentifie
+    // (aucune permission RBAC requise, tous les items restent dans `core` pour
+    // rester toujours presents meme quand les modules metier sont desactives).
+    [
+        'label' => 'sidebar.account.section',
+        'icon'  => 'mdi:account-circle-outline',
+        'items' => [
+            [
+                'label'  => 'sidebar.account.dashboard',
+                'to'     => '/',
+                'icon'   => 'mdi:view-dashboard-outline',
+                'module' => 'core',
+            ],
+            [
+                'label'  => 'sidebar.account.logout',
+                'to'     => '/logout',
+                'icon'   => 'mdi:logout',
+                'module' => 'core',
+            ],
+        ],
+    ],
 ];

config/version.yaml

@@ -1,2 +1,2 @@
 parameters:
-    app.version: '0.1.31'
+    app.version: '0.1.34'

doc/audit-log.md

@@ -0,0 +1,411 @@
+# Audit Log — Specification technique
+
+## Objectif
+
+Tracer l'historique de toutes les modifications BDD dans une table `audit_log` append-only. L'audit est opt-in via l'attribut `#[Auditable]` sur les entites, expose en lecture seule via API Platform (permission RBAC `core.audit_log.view`), et visualise dans le frontend via une page dediee et un composant timeline reutilisable.
+
+**Regle projet** : toute entite (nouvelle ou existante) doit etre annotee `#[Auditable]` avec `#[AuditIgnore]` sur les champs sensibles. L'audit n'est pas optionnel — il est obligatoire sur toutes les entites metier.
+
+---
+
+## Architecture
+
+```
+src/
+  Shared/
+    Domain/
+      Attribute/
+        Auditable.php              # Attribut classe — active le tracking
+        AuditIgnore.php            # Attribut propriete — exclut un champ
+  Module/
+    Core/
+      CoreModule.php               # + permission core.audit_log.view
+      Application/
+        DTO/
+          AuditLogOutput.php       # DTO lecture seule
+      Infrastructure/
+        Audit/
+          AuditLogWriter.php       # Ecrit via DBAL (pas Doctrine ORM)
+          RequestIdProvider.php    # UUID v4 par requete HTTP
+        Doctrine/
+          AuditListener.php        # Listener onFlush/postFlush
+          Migrations/              # (migration dans migrations/ racine — cf. bug tri FQCN)
+        ApiPlatform/
+          Resource/
+            AuditLogResource.php   # ApiResource read-only
+          State/
+            Provider/
+              AuditLogProvider.php  # Provider DBAL
+
+frontend/
+  shared/
+    composables/
+      useAuditLog.ts               # Composable partage (page + timeline)
+    components/
+      audit/
+        AuditTimeline.vue          # Timeline verticale reutilisable
+    types/
+      index.ts                     # + AuditLogEntry, AuditLogFilters, HydraView
+    utils/
+      api.ts                       # + support hydra:view pagination
+  modules/
+    core/
+      pages/
+        admin/
+          audit-log.vue            # Page globale admin
+```
+
+---
+
+## Table PostgreSQL `audit_log`
+
+Table non geree par Doctrine ORM (pas d'entite). Ecriture via DBAL uniquement pour eviter la recursion des listeners.
+
+### Schema
+
+| Colonne | Type | Contrainte | Description |
+|---------|------|-----------|-------------|
+| `id` | uuid | PK | UUID v7 genere en PHP (`Uuid::v7()->toRfc4122()`) — type natif PG (16 octets vs 36 en varchar) |
+| `entity_type` | varchar(100) | NOT NULL | Format `module.Entity` (ex: `core.User`, `commercial.Client`) — evite les collisions inter-modules |
+| `entity_id` | varchar(64) | NOT NULL | ID de l'entite (supporte int et UUID) |
+| `action` | varchar(10) | NOT NULL | `create`, `update`, `delete` |
+| `changes` | jsonb | NOT NULL DEFAULT '{}' | Changements (format selon action) |
+| `performed_by` | varchar(100) | NOT NULL | Username denormalise (survit a la suppression du user) |
+| `performed_at` | timestamptz | NOT NULL | Horodatage de l'action |
+| `ip_address` | varchar(45) | NULL | Adresse IP (null en CLI) |
+| `request_id` | varchar(36) | NULL | UUID v4 par requete HTTP (null en CLI) |
+
+### Index
+
+- `idx_audit_entity_time` : `(entity_type, entity_id, performed_at)` — recherche par entite
+- `idx_audit_performer` : `(performed_by, performed_at)` — recherche par utilisateur
+- `idx_audit_time` : `(performed_at)` — tri chronologique global
+
+### Regles
+
+- **Append-only** : pas d'UPDATE, pas de DELETE
+- **Colonnes en minuscules** (convention PostgreSQL du projet)
+- **Champs sensibles exclus** : `password`, `plainPassword`, `token`, `secret` ne doivent jamais apparaitre dans `changes`
+- **`performed_by` denormalise** : string, pas FK — le nom persiste meme si l'utilisateur est supprime
+- **Migration** : dans `migrations/` (namespace racine `DoctrineMigrations`) a cause du bug de tri alphabetique FQCN de Doctrine Migrations 3.x entre namespaces
+
+---
+
+## Composants backend
+
+### `AuditLogWriter`
+
+**Emplacement** : `src/Module/Core/Infrastructure/Audit/AuditLogWriter.php`
+
+Service responsable de l'ecriture dans `audit_log` via `Connection::executeStatement()`.
+
+**Dependances** :
+- `Doctrine\DBAL\Connection` — connexion DBAL dediee `audit` (meme DSN, service separe) pour eviter l'entanglement transactionnel avec l'ORM. Config : `doctrine.dbal.connections.audit` dans `doctrine.yaml`. Injection via `#[Autowire(service: 'doctrine.dbal.audit_connection')]`.
+- `Symfony\Bundle\SecurityBundle\Security`
+- `Symfony\Component\HttpFoundation\RequestStack`
+- `RequestIdProvider`
+
+**Methode principale** :
+```php
+public function log(
+    string $entityType,
+    string $entityId,
+    string $action,
+    array $changes,
+): void
+```
+
+**Comportement** :
+- Genere `id` via `Uuid::v7()->toRfc4122()`
+- `performed_by` = `$security->getUser()?->getUserIdentifier() ?? 'system'`
+- `ip_address` = `$requestStack->getCurrentRequest()?->getClientIp()`
+- `request_id` = `$requestIdProvider->getRequestId()`
+- `performed_at` = `new \DateTimeImmutable('now', new \DateTimeZone('UTC'))`
+- Filtre les cles sensibles (`password`, `plainPassword`, `token`, `secret`) de `$changes`
+- INSERT SQL brut via DBAL
+
+**Necessite** : `composer require symfony/uid`
+
+### `RequestIdProvider`
+
+**Emplacement** : `src/Module/Core/Infrastructure/Audit/RequestIdProvider.php`
+
+Service singleton qui genere un UUID v4 unique par requete HTTP principale.
+
+**Comportement** :
+- Ecoute `kernel.request` via `#[AsEventListener]`
+- Ignore les sub-requests : `if (!$event->isMainRequest()) return;`
+- Genere `Uuid::v4()->toRfc4122()` a chaque requete principale
+- Expose `getRequestId(): ?string` (null en CLI)
+
+### Attributs `#[Auditable]` et `#[AuditIgnore]`
+
+**Emplacement** : `src/Shared/Domain/Attribute/` (dans Shared, pas Core — tous les modules doivent y acceder)
+
+- `#[Auditable]` : attribut de classe, marqueur vide. Active le tracking sur l'entite.
+- `#[AuditIgnore]` : attribut de propriete, marqueur vide. Exclut un champ du tracking.
+
+### `AuditListener`
+
+**Emplacement** : `src/Module/Core/Infrastructure/Doctrine/AuditListener.php`
+
+Listener Doctrine (pas EventSubscriber — deprecie Symfony 8) utilisant `#[AsDoctrineListener]`.
+
+**Evenements** :
+- `onFlush` : collecte les changesets (aucune ecriture)
+- `postFlush` : ecrit via `AuditLogWriter` (hors transaction Doctrine)
+
+**Dependances** :
+- `AuditLogWriter`
+- `LoggerInterface`
+
+**Logique `onFlush`** :
+1. Recupere `UnitOfWork`
+2. Parcourt insertions, updates, deletions
+3. Pour chaque entite : verifie `#[Auditable]` via `ReflectionClass::getAttributes()`
+4. Filtre les proprietes `#[AuditIgnore]` + blacklist hardcodee
+5. Formate les changements :
+   - **create** : snapshot complet de toutes les proprietes non-ignorees
+   - **update** : `{champ: {old: x, new: y}}` via `getEntityChangeSet()`
+   - **delete** : snapshot complet
+6. ManyToOne : log l'ID via `?->getId()` (null-safe pour les relations nullable), pas l'objet
+7. Stocke dans `$pendingLogs` (propriete privee)
+
+**Logique `postFlush`** — pattern swap-and-clear (protection contre flush re-entrant) :
+1. Copie `$pendingLogs` dans variable locale, vide immediatement `$this->pendingLogs = []`
+2. Pour chaque log copie → `AuditLogWriter::log()`
+3. Try/catch : erreur → `$logger->error(...)`, jamais de crash
+
+**Cas particuliers** :
+- Flush sans changement → rien
+- Entite sans `#[Auditable]` → ignoree
+- Batch (fixtures, import) → chaque entite auditee, groupees par `request_id`
+- Console → `performed_by = 'system'`, `ip_address = null`, `request_id = null`
+- ManyToMany : non couvert par `getEntityChangeSet()` — limitation connue. Les changements de collections (ex: `User::$rbacRoles`) ne sont pas audites. Ajout futur possible via `getScheduledCollectionUpdates()`.
+
+---
+
+## API Platform — Lecture seule
+
+### `AuditLogResource`
+
+**Emplacement** : `src/Module/Core/Infrastructure/ApiPlatform/Resource/AuditLogResource.php`
+
+**Operations** :
+- `GET /api/audit-logs` — collection paginee (30 items/page), tri `performed_at DESC`
+- `GET /api/audit-logs/{id}` — detail
+
+**Securite** : `is_granted('core.audit_log.view')` — permission RBAC, 403 sinon
+
+**Pas d'endpoints d'ecriture** : POST, PUT, PATCH, DELETE → 405
+
+### `AuditLogOutput`
+
+**Emplacement** : `src/Module/Core/Application/DTO/AuditLogOutput.php`
+
+DTO readonly avec les champs : `id`, `entityType`, `entityId`, `action`, `changes`, `performedBy`, `performedAt`, `ipAddress`, `requestId`.
+
+### `AuditLogProvider`
+
+**Emplacement** : `src/Module/Core/Infrastructure/ApiPlatform/State/Provider/AuditLogProvider.php`
+
+Provider DBAL (pas Doctrine ORM).
+
+**Filtres** (query params, combinables en AND) :
+- `entity_type` : filtre exact
+- `entity_id` : filtre exact
+- `action` : filtre exact
+- `performed_by` : filtre exact
+- `performed_at[after]` : date minimum (incluse)
+- `performed_at[before]` : date maximum (incluse)
+
+**Pagination** : via un `DbalPaginator` implementant `ApiPlatform\State\Pagination\PaginatorInterface` (`getCurrentPage()`, `getLastPage()`, `getTotalItems()`, `getItemsPerPage()`, `count()`, `getIterator()`). Le provider retourne ce paginator — API Platform genere automatiquement `hydra:view`. Pas de construction manuelle de la pagination.
+
+### Permission RBAC
+
+Ajouter dans `CoreModule::permissions()` :
+- `core.audit_log.view`
+
+---
+
+## Frontend
+
+### Composable `useAuditLog.ts`
+
+**Emplacement** : `frontend/shared/composables/useAuditLog.ts`
+
+Composable partage, reutilise par la page globale (ticket 4) et le composant timeline (ticket 5).
+
+**Methodes** :
+- `fetchLogs(filters?: AuditLogFilters): Promise<HydraCollection<AuditLogEntry>>`
+- `fetchLogById(id: string): Promise<AuditLogEntry>`
+- `fetchEntityLogs(entityType: string, entityId: string, page?: number): Promise<HydraCollection<AuditLogEntry>>`
+
+Utilise `useApi().get()`.
+
+Si le composable maintient du state singleton (refs module-level pour cache), il doit exposer `resetAuditLog()` et etre reinitialise au logout (regle CLAUDE.md).
+
+### Types
+
+Ajouter dans `frontend/shared/types/index.ts` :
+
+```typescript
+export interface AuditLogEntry {
+    id: string
+    entityType: string
+    entityId: string
+    action: 'create' | 'update' | 'delete'
+    changes: Record<string, unknown>
+    performedBy: string
+    performedAt: string
+    ipAddress: string | null
+    requestId: string | null
+}
+
+export interface AuditLogFilters {
+    entityType?: string
+    entityId?: string
+    action?: string
+    performedBy?: string
+    performedAtAfter?: string
+    performedAtBefore?: string
+    page?: number
+}
+
+interface HydraView {
+    'hydra:first'?: string
+    'hydra:last'?: string
+    'hydra:next'?: string
+    'hydra:previous'?: string
+}
+```
+
+Le type `HydraView` doit etre ajoute dans `frontend/shared/utils/api.ts` (a cote de `HydraCollection`) et `HydraCollection` doit etre etendu avec un champ optionnel `'hydra:view'?: HydraView`.
+
+### Page `admin/audit-log.vue`
+
+**Emplacement** : `frontend/modules/core/pages/admin/audit-log.vue`
+
+**Acces** : permission RBAC `core.audit_log.view` (verifie via `usePermissions().can('core.audit_log.view')`)
+
+**Elements** :
+- Tableau pagine avec style projet (header `bg-tertiary-500`, rows hover)
+- Filtres : plage dates, type entite (select), utilisateur (input), action (checkboxes), bouton reset
+- Filtres persistes dans les query params URL
+- Ligne expandable au clic :
+  - update : tableau champ / ancienne valeur / nouvelle valeur
+  - create/delete : snapshot complet
+- Badges action :
+  - create : `bg-green-100 text-green-800`
+  - update : `bg-yellow-100 text-yellow-800`
+  - delete : `bg-red-100 text-red-800`
+- Pagination prev/next via `hydra:view`
+- Etat vide : message i18n "Aucune activite enregistree"
+- Chargement initial : 30 dernieres entrees sans filtre
+
+### Sidebar
+
+Ajouter entree dans `config/sidebar.php` :
+- Label : `sidebar.core.audit_log`
+- Route : `/admin/audit-log`
+- Icon : a definir (ex: `mdi:clipboard-text-clock`)
+- Module : `core`
+- Permission : `core.audit_log.view` — filtre automatiquement cote SidebarProvider
+
+### Composant `AuditTimeline.vue`
+
+**Emplacement** : `frontend/shared/components/audit/AuditTimeline.vue`
+
+Composant reutilisable, auto-importe par Nuxt.
+
+**Props** :
+- `entityType: string`
+- `entityId: string | number`
+
+**Comportement** :
+- Garde permission : si `!usePermissions().can('core.audit_log.view')` → rendu vide, aucun appel API
+- Timeline verticale : bordure gauche (`border-l-2 border-gray-200`) + dots colores par action
+- Chaque entree : icone + date relative FR (`Intl.RelativeTimeFormat('fr')`) + date absolue en tooltip + utilisateur + resume
+- Update : affiche old → new par champ
+- Lazy loading : 10 items initiaux + bouton "Voir plus"
+- Skeleton loader pendant le chargement
+- Etat vide : "Aucun historique"
+
+**Premiere integration** : sur la page `admin/audit-log.vue`
+
+---
+
+## i18n
+
+Cles a ajouter dans `frontend/i18n/locales/fr.json` :
+
+Structure imbriquee (respecte le format existant de `fr.json`) :
+
+```json
+{
+    "sidebar": {
+        "core": {
+            "audit_log": "Journal d'audit"
+        }
+    },
+    "audit": {
+        "action": {
+            "create": "Création",
+            "update": "Modification",
+            "delete": "Suppression"
+        },
+        "entity": {
+            "user": "Utilisateur"
+        },
+        "empty": "Aucune activité enregistrée",
+        "no_results": "Aucun résultat pour ces filtres",
+        "timeline": {
+            "empty": "Aucun historique",
+            "load_more": "Voir plus"
+        },
+        "filters": {
+            "reset": "Réinitialiser",
+            "date_from": "Du",
+            "date_to": "Au",
+            "entity_type": "Type d'entité",
+            "user": "Utilisateur",
+            "action": "Action"
+        },
+        "detail": {
+            "field": "Champ",
+            "old_value": "Ancienne valeur",
+            "new_value": "Nouvelle valeur"
+        }
+    }
+}
+```
+
+---
+
+## Ordre d'implementation
+
+```
+Ticket 1 ────► Ticket 2 ────► Ticket 3 ────┬──► Ticket 4
+  Table +        Attributs +     API           │    Page admin
+  Writer         Listener        read-only     │
+                                               └──► Ticket 5
+                                                    Timeline
+                                            (4 et 5 en parallele)
+```
+
+---
+
+## Decisions techniques (issues reviews)
+
+- **Connexion DBAL dediee** : `AuditLogWriter` utilise une connexion separee `audit` (meme DSN) pour eviter l'entanglement transactionnel avec l'ORM en batch
+- **PaginatorInterface** : le provider retourne un `DbalPaginator` implementant l'interface API Platform — pas de construction manuelle `hydra:view`
+- **Type natif `uuid` PG** : 16 octets vs 36 en varchar, index 40% plus petit sur table append-only a croissance infinie
+- **Pattern swap-and-clear** dans `postFlush` : protection contre flush re-entrant
+- **Blacklist exact-match** sur noms de proprietes (`password`, `plainPassword`, `token`, `secret`) — en defense-in-depth avec `#[AuditIgnore]`
+- **ManyToMany non audite** : limitation connue, `getEntityChangeSet()` ne couvre pas les collections
+- **Erreur audit silencieuse** : loguee, jamais propagee — pas de retry/dead-letter (acceptable pour CRM interne)
+- **`entity_type` format `module.Entity`** : evite collisions si deux modules ont des entites de meme nom
+
+## Dependances externes
+
+- `symfony/uid` : generation UUID v7 (id) et v4 (request_id)

docker-compose.yml

@@ -45,7 +45,10 @@ services:
     restart: unless-stopped
   db:
     image: postgres:16-alpine
-    command: -p ${POSTGRES_PORT:-5436}
+    # max_connections eleve (defaut PG=100) pour absorber la suite de tests :
+    # ~220 tests * kernel reboot par test * 2 connexions (default + audit)
+    # peut saturer le pool, meme avec idle_connection_ttl court cote Doctrine.
+    command: -p ${POSTGRES_PORT:-5436} -c max_connections=300
     environment:
       POSTGRES_DB: ${POSTGRES_DB}
       POSTGRES_USER: ${POSTGRES_USER}

docs/modules/site-aware.md

@@ -0,0 +1,287 @@
+# Guide développeur — `SiteAwareInterface` (opt-in)
+
+Ce guide explique comment adopter le pattern **site-aware** sur une entité
+d'un module métier pour que ses données soient automatiquement filtrées
+par le site courant de l'utilisateur connecté, et pour que les créations
+soient rattachées implicitement au site courant.
+
+Ce pattern est **opt-in strict** : aucune entité n'est affectée tant qu'un
+module ne choisit pas explicitement d'implémenter `SiteAwareInterface`.
+
+Livré par le ticket 4/4 du module Sites (cf. `docs/sites/ticket-04-spec.md`).
+
+## 1. Quand adopter ?
+
+Adopte le pattern si :
+
+- Chaque ligne de l'entité appartient à **un et un seul site**.
+- Les utilisateurs du site A ne doivent **jamais** voir les lignes du site B.
+- Créer une ligne sans connaître le site n'a pas de sens métier.
+
+Exemples typiques : `Supplier`, `Order`, `StockEntry`, `Employee` (si chaque
+site a sa propre équipe), `Invoice` (si facturation par site).
+
+## 2. Quand NE PAS adopter ?
+
+**Entités globales** : partagées par tous les sites, pas de notion de
+propriétaire. Ne pas adopter.
+
+- `Role`, `Permission`, `User` (les users sont transverses, rattachés à
+  plusieurs sites via la relation M2M `user_site`).
+- Catalogues mutualisés : produits, catégories, taxes — sauf si chaque
+  site a son propre catalogue.
+- Documents / contrats multi-site (ex: contrat-cadre qui couvre plusieurs
+  sites).
+
+**Entités "par tenant"** : si le scope naturel est plus large que le site
+(ex: un groupe qui possède plusieurs sites comme entités filiales
+juridiquement distinctes), utilise plutôt `TenantAwareInterface` (déjà
+présent dans `src/Shared/Domain/Contract/`).
+
+**Entités hybrides** : certaines lignes globales, d'autres par site. Le
+pattern ne supporte pas ce cas — crée deux entités distinctes si
+nécessaire.
+
+## 3. Comment adopter ? Check-list
+
+### 3.1 Entité
+
+```php
+use App\Module\Sites\Domain\Entity\Site;
+use App\Shared\Domain\Contract\SiteAwareInterface;
+
+class Supplier implements SiteAwareInterface
+{
+    #[ORM\ManyToOne(targetEntity: Site::class)]
+    #[ORM\JoinColumn(name: 'site_id', referencedColumnName: 'id', nullable: false, onDelete: 'CASCADE')]
+    private ?Site $site = null;
+
+    public function getSite(): ?Site
+    {
+        return $this->site;
+    }
+
+    public function setSite(Site $site): void
+    {
+        $this->site = $site;
+    }
+}
+```
+
+Points critiques :
+
+- `nullable: false` au niveau de la `JoinColumn` — la table n'accepte
+  jamais `site_id IS NULL` en régime nominal.
+- `onDelete: 'CASCADE'` — la suppression d'un site entraîne la suppression
+  de toutes les lignes associées. À remplacer par `RESTRICT` (blocage) si
+  ton métier exige d'empêcher la suppression d'un site contenant des
+  données.
+- Le getter retourne `?Site` (nullable) pour permettre des états
+  transitoires pré-persist (entité construite avant injection du site).
+
+### 3.2 Migration
+
+**Cas 1 — Nouvelle table** : ajoute directement `site_id INT NOT NULL`
+avec FK et index.
+
+**Cas 2 — Table existante avec données legacy** : migration en trois étapes
+distinctes.
+
+```php
+// Version1.php
+$this->addSql('ALTER TABLE supplier ADD site_id INT DEFAULT NULL');
+$this->addSql('CREATE INDEX IDX_supplier_site ON supplier (site_id)');
+$this->addSql('ALTER TABLE supplier ADD CONSTRAINT FK_supplier_site FOREIGN KEY (site_id) REFERENCES site (id) ON DELETE CASCADE');
+
+// Backfill (manuellement ou via script custom selon ton métier)
+$this->addSql("UPDATE supplier SET site_id = (SELECT id FROM site WHERE name = 'Chatellerault') WHERE site_id IS NULL");
+
+// Version2.php — après backfill confirmé
+$this->addSql('ALTER TABLE supplier ALTER COLUMN site_id SET NOT NULL');
+```
+
+**Index obligatoire** : le filtre généré par `SiteScopedQueryExtension`
+est `WHERE x.site = :currentSite`. Sans index sur `site_id`, chaque
+requête fait un full-scan de la table. Ajoute-le dans la migration.
+
+### 3.3 Sérialisation API
+
+Expose la relation `site` dans le groupe de lecture de la ressource pour
+que le frontend sache à quel site appartient chaque ligne :
+
+```php
+#[Groups(['supplier:read'])]
+private ?Site $site = null;
+```
+
+Si tu veux aussi permettre à un admin de créer une ligne sur un autre
+site que son `currentSite` (ex: admin multi-site), ajoute aussi le groupe
+d'écriture :
+
+```php
+#[Groups(['supplier:read', 'supplier:write'])]
+```
+
+Dans ce cas, `SiteAwareInjectionProcessor` respecte la valeur explicite
+envoyée par le client (voir §4).
+
+### 3.4 Processor custom
+
+Si le module a déjà un processor custom sur les opérations POST/PATCH,
+assure-toi qu'il délègue à `api_platform.doctrine.orm.state.persist_processor`
+(et non à `$em->persist()` direct) pour que le decorator
+`SiteAwareInjectionProcessor` s'applique.
+
+Pattern aligné sur `UserRbacProcessor` :
+
+```php
+use Symfony\Component\DependencyInjection\Attribute\Autowire;
+
+public function __construct(
+    #[Autowire(service: 'api_platform.doctrine.orm.state.persist_processor')]
+    private readonly ProcessorInterface $persistProcessor,
+) {}
+
+public function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): mixed
+{
+    // Gardes métier custom ici...
+
+    // Délègue au persist processor décoré : SiteAwareInjectionProcessor
+    // interceptera l'appel et injectera le currentSite si besoin.
+    return $this->persistProcessor->process($data, $operation, $uriVariables, $context);
+}
+```
+
+## 4. Comportement du processor d'injection
+
+Le decorator `SiteAwareInjectionProcessor` s'applique automatiquement à
+**toute** persistance API Platform. Son comportement :
+
+| Cas | Action |
+|---|---|
+| `$data` n'implémente pas `SiteAwareInterface` | Délégation directe (no-op). |
+| `$data` est `SiteAware` avec `$site` déjà positionné (ex: payload POST avec `site` explicite) | Délégation directe, **la valeur explicite est préservée**. |
+| `$data` est `SiteAware` sans site, `CurrentSiteProvider::get()` retourne un `Site` | Injection `$data->setSite($currentSite)` puis délégation. |
+| `$data` est `SiteAware` sans site, `CurrentSiteProvider::get()` retourne `null` | **Throw `BadRequestHttpException`** avec message "aucun site sélectionné". |
+
+Conséquence : un user sans `currentSite` ne peut **pas** créer de ligne
+sur une entité `SiteAware`. C'est intentionnel : mieux vaut un 400 clair
+que persister une ligne incohérente.
+
+## 5. Comportement en mode dégradé
+
+### 5.1 Module Sites désactivé
+
+Si `SitesModule::class` est retiré de `config/modules.php`,
+`CurrentSiteProvider::get()` retourne **toujours `null`** :
+
+- `SiteScopedQueryExtension` → no-op. Toutes les lignes visibles, comme
+  si le filtre n'existait pas.
+- `SiteAwareInjectionProcessor` → **throw 400 sur tout POST/PATCH** sans
+  site explicite. L'écriture d'entités `SiteAware` nécessite que le
+  client envoie systématiquement `site` dans le payload.
+
+**Conséquence** : un module qui adopte le pattern **ne peut pas vivre**
+sans le module Sites actif pour les opérations d'écriture. À documenter
+fortement dans le README du module adopté.
+
+### 5.2 User sans site (sites = [], currentSite = null)
+
+Même comportement qu'un module désactivé : lecture no-op (tout visible),
+écriture bloquée par 400. L'UX doit gérer ce cas (ex: écran d'onboarding
+qui force l'assignation d'un site avant d'accéder aux écrans métier).
+
+### 5.3 Bypass admin via `sites.bypass_scope`
+
+Un utilisateur avec la permission `sites.bypass_scope` (ou admin par
+bypass total via `isAdmin = true`) voit **toutes** les lignes, tous
+sites confondus. Pratique pour audit, reporting, consolidation groupe.
+
+Le processor d'injection ne respecte **pas** ce bypass : même un user
+avec `bypass_scope` verra son `currentSite` injecté à la création s'il
+n'envoie pas de `site` explicite. Le bypass est un droit de lecture,
+pas d'écriture multi-site.
+
+## 6. Anti-patterns et gotchas
+
+### 6.1 Sous-collections (`/api/clients/{id}/contacts`)
+
+Si seul `Client` est `SiteAware` (et `Contact` hérite du scope via son
+parent), le filtre **ne se propage pas automatiquement** aux contacts.
+Deux options :
+
+- Rendre `Contact` aussi `SiteAware` (redondance mais simple).
+- Ajouter un filtre custom qui joint sur `contact.client.site` et compare
+  au `currentSite`.
+
+Ce ticket ne couvre pas le second cas : à implémenter par le module
+concerné.
+
+### 6.2 Repositories custom
+
+Le filtre API Platform ne s'applique **qu'aux requêtes** générées par
+API Platform (via `ItemProvider` / `CollectionProvider` Doctrine). Si un
+repository custom fait une requête DQL manuelle (ex: `findTopRated()`
+appelé depuis un service), **aucun filtre n'est appliqué**.
+
+Responsabilité du développeur du module : injecter `CurrentSiteProvider`
+dans le repository / service et ajouter manuellement la clause WHERE.
+
+### 6.3 Tests d'intégration
+
+Les tests qui persistent des entités `SiteAware` doivent :
+
+- Soit logger un user avec un `currentSite` positionné (cas nominal).
+- Soit utiliser un user avec `sites.bypass_scope` pour voir toutes les
+  lignes (cas reporting).
+- Soit positionner le site **explicitement** sur chaque entité persistée
+  via fixture (bypass du processor d'injection qui n'est pas actif hors
+  contexte HTTP).
+
+### 6.4 Cascade delete d'un site
+
+La migration type du §3.2 déclare `onDelete: 'CASCADE'` sur la FK
+`site_id`. **Conséquence** : supprimer un site détruit **toutes** les
+lignes de **toutes** les tables `SiteAware` rattachées à ce site, en
+cascade. Pour un `Supplier`, ça signifie perte de l'historique fournisseur
+du site supprimé.
+
+Alternatives selon le besoin métier :
+
+- `onDelete: 'RESTRICT'` : bloque la suppression du site tant qu'il reste
+  des lignes. L'admin doit nettoyer manuellement avant delete.
+- `onDelete: 'SET NULL'` : transforme les lignes en "globales" après
+  suppression du site — mais incompatible avec `nullable: false`, donc
+  nécessite de relâcher la contrainte. Généralement à éviter.
+
+## 7. Exemple d'adoption minimale (pseudo-ticket)
+
+Pour un futur ticket qui adopte `SiteAwareInterface` sur `Supplier` du
+module Commercial :
+
+1. Modifier `src/Module/Commercial/Domain/Entity/Supplier.php` : ajouter
+   `implements SiteAwareInterface` + relation `$site`.
+2. Créer migration `Version<timestamp>.php` : `ALTER TABLE supplier ADD
+   site_id ...`, backfill, `SET NOT NULL`, `CREATE INDEX`.
+3. Ajouter `#[Groups(['supplier:read'])]` sur `$site`.
+4. Mettre à jour les fixtures `CommercialFixtures` pour rattacher chaque
+   supplier à un site (`setSite(...)`).
+5. Ajouter un test d'intégration qui vérifie que la collection
+   `/api/suppliers` retourne bien uniquement les suppliers du site
+   courant pour un user donné.
+6. Documenter dans le README du module Commercial que les opérations
+   d'écriture sur Supplier nécessitent le module Sites actif + un user
+   avec `currentSite`.
+
+## 8. Permission `sites.bypass_scope`
+
+Déclarée par `SitesModule::permissions()`, synchronisée automatiquement
+en base par `app:sync-permissions`. Une fois synchronisée, elle est
+assignable :
+
+- Directement à un user via `/admin/users` (drawer RBAC, section
+  "Permissions directes").
+- Via un rôle personnalisé (ex: rôle "Auditeur groupe") qui la porte.
+
+Les admins l'obtiennent automatiquement par bypass total (`isAdmin`), pas
+besoin d'assignation explicite.

docs/rbac/ticket-345-spec.md

@@ -572,3 +572,78 @@ Chaque etape doit etre revue (spec compliance + code quality) avant de passer a
 - Branche de travail : `feat/rbac-voter`, tiree de `feat/rbac-api`.
 - Pas de PR dediee : les commits #345 s'empilent sur la PR #3 existante ouverte vers `develop`.
 - Une fois la PR #3 mergee, la branche finale de l'epic RBAC (`feat/rbac-admin-ui` pour #346) partira de `develop`.
+
+## 18. Evolutions post-livraison — `UserRbacProcessor` defense in depth
+
+Voir aussi : `docs/sites/ticket-02-spec.md` § 10 pour la problematique cote
+Sites qui a motive cette evolution.
+
+### 18.1 — Semantique `merge-patch+json` respectee
+
+Le processor originel appliquait telles quelles les mutations produites par la
+denormalisation API Platform. Or API Platform reinstancie par defaut une
+`ArrayCollection` vide pour chaque propriete ManyToMany absente du payload,
+ce qui viole la semantique `application/merge-patch+json` : les cles absentes
+ne doivent PAS muter les proprietes correspondantes.
+
+Consequence concrete du bug : un PATCH minimal comme `{ "isAdmin": true }`
+detruisait silencieusement toutes les collections (`rbacRoles`,
+`directPermissions`, `sites`) du user cible.
+
+La garde `restoreAbsentCollections()` introduite dans `UserRbacProcessor`
+resout cela en :
+
+1. Injectant `RequestStack` pour lire le body JSON brut de la requete.
+2. Decodant les cles effectivement envoyees par le client.
+3. Pour chaque cle RBAC (`roles`, `directPermissions`, `sites`) absente du
+   payload : restaurant la collection a son etat d'origine a partir du
+   snapshot Doctrine (`PersistentCollection::getSnapshot()`), puis appelant
+   `takeSnapshot()` pour marquer la collection comme non-dirty (aucune query
+   `UPDATE` n'est emise sur les tables de jointure).
+4. No-op si la cle est presente (la denormalisation fait foi).
+
+Matrice finale :
+
+| Payload                         | Effet                               |
+|---------------------------------|-------------------------------------|
+| Cle absente                     | Propriete preservee (BDD inchangee) |
+| Cle presente = `[]`             | Collection videe (vidage explicite) |
+| Cle presente = `[...]`          | Collection remplacee                |
+
+### 18.2 — Nouvelle operation `GET /users/{id}/rbac`
+
+Le drawer d'edition (`UserRbacDrawer.vue`) ne peut plus dependre du payload
+de liste `/api/users` (groupe `user:list`) pour initialiser l'etat `sites`
+car ce groupe reste volontairement leger (cf. ticket Sites #02). Une
+operation `Get` dediee est ajoutee, symetrique au `Patch` existant :
+
+- URI : `/users/{id}/rbac`
+- Security : `is_granted('core.users.manage')` (plus strict que `.view`)
+- Groupe : `user:rbac:read` (contient `isAdmin`, `roles`, `directPermissions`,
+  `sites`).
+
+Le drawer charge desormais ce GET en parallele des referentiels au moment
+de l'ouverture, via un watch combine `[modelValue, user.id]` qui recharge
+correctement si le user change sans fermeture du drawer entre-temps.
+
+### 18.3 — Impact sur les tests
+
+`UserRbacProcessorTest` : le constructor gagne un argument `RequestStack`.
+Les tests existants injectent une `RequestStack` avec une `Request` vide
+(body `""`), ce qui rend la garde no-op — le comportement des assertions
+existantes est conserve. De nouveaux tests couvrent la garde :
+
+- PATCH sans cle `sites` ne mute pas la collection d'origine.
+- PATCH avec `sites: []` vide bien la collection (pas de regression du cas
+  "vidage explicite").
+- PATCH avec `sites: [...]` remplace comme avant.
+
+### 18.4 — Criteres de validation additionnels
+
+- [ ] `GET /users/{id}/rbac` retourne 200 avec `core.users.manage`, 403 sans.
+- [ ] Le payload contient `{ id, isAdmin, roles, directPermissions, sites }`.
+- [ ] `PATCH /users/{id}/rbac` avec cle absente preserve la collection BDD.
+- [ ] `PATCH /users/{id}/rbac` avec `[]` vide la collection et declenche
+      `ensureCurrentSiteConsistency` (cas sites).
+- [ ] Les 228 tests PHPUnit existants passent apres ajout du parametre
+      `RequestStack` au constructor.

docs/sites/ticket-01-spec.md

@@ -0,0 +1,410 @@
+# Ticket #01 — 1/4 — Brique fondatrice du module Sites (Backend)
+
+## 1. Objectif
+
+Ce ticket livre la couche de donnees du module optionnel Sites. Il cree le bounded context, declare le module a Symfony, enregistre ses permissions RBAC, installe la table `site` en base et seed trois etablissements de demonstration utilises par les tickets suivants.
+
+Le resultat attendu est un socle de persistance activable par tenant via `config/modules.php`, sans UI, sans API publique, sans couplage au module Core, et sur lequel les tickets 2/3/4 pourront greffer : rattachement utilisateurs, selecteur de site dans la navbar, administration CRUD.
+
+## 2. Périmètre
+
+### IN
+
+- Creer le module `/home/m-tristan/workspace/Coltura/src/Module/Sites/SitesModule.php` avec `ID = 'sites'`, `LABEL = 'Sites'`, `REQUIRED = false`, et une methode statique `permissions()` declarant les deux codes RBAC `sites.view` et `sites.manage`.
+- Creer l'entite Doctrine `Site` avec `id`, `name` (unique), `city`, `postalCode`, `color`, `fullAddress`, `createdAt`, `updatedAt` et les contraintes de validation applicatives associees (NotBlank, Length, Regex hex `#RRGGBB`, Regex CP FR `^\d{5}$`, UniqueEntity).
+- Creer l'interface `SiteRepositoryInterface` et son implementation Doctrine `DoctrineSiteRepository`, avec un contrat CRUD complet (`findById`, `findByName`, `findAllOrderedByName`, `save`, `remove`) en anticipation du ticket 2.
+- Creer une migration Doctrine creant la table `site` avec son index unique `uniq_site_name`. La migration est placee dans `/home/m-tristan/workspace/Coltura/migrations/` au namespace racine `DoctrineMigrations` conformement a l'exception documentee dans `CLAUDE.md` (bug de tri alphabetique des migrations multi-namespaces dans Doctrine Migrations 3.x).
+- Creer `SitesFixtures` creant trois sites de demonstration : `Chatellerault` (`#056CF2`), `Saint-Jean` (`#10B981`), `Pommevic` (`#F59E0B`). Fixtures idempotentes via lookup par nom lorsque le purger Doctrine est desactive.
+- Enregistrer `SitesModule::class` dans `/home/m-tristan/workspace/Coltura/config/modules.php` pour l'activer par defaut.
+- Declarer le mapping Doctrine du module dans `/home/m-tristan/workspace/Coltura/config/packages/doctrine.yaml` (inconditionnel, le mapping reste charge meme si le module est retire de `modules.php`).
+- Enregistrer l'alias service `SiteRepositoryInterface → DoctrineSiteRepository` dans `/home/m-tristan/workspace/Coltura/config/services.yaml`.
+- Ajouter deux suites de tests PHPUnit :
+  - `SiteTest` (pure `TestCase`) pour le comportement de l'entite (constructeur, getters/setters, lifecycle `PreUpdate`).
+  - `SiteValidationTest` (`KernelTestCase`) pour la validation complete : regex hex, regex CP FR, NotBlank, Length, UniqueEntity via Doctrine.
+
+### OUT
+
+- Ticket `#02` : relation `User ↔ Site` (FK ou ManyToMany selon decision UX), expose les sites de l'utilisateur courant via `/api/me` et propage l'autorisation au niveau des ressources decoupees par site.
+- Ticket `#03` : integration dans la navbar Coltura (selecteur de site actif, persistance du choix cote front, consommation du flux issu du ticket 2).
+- Ticket `#04` : ecran d'administration CRUD des sites (page admin/sites, DataTable, drawer creation/edition, modale suppression, API Platform `Site` resource avec voters RBAC).
+- Gestion des soft-deletes sur `Site` : non introduite dans ce ticket.
+- Rattachement historique ou audit trail des modifications : hors scope.
+
+## 3. Fichiers à créer
+
+### Domaine — Entité
+
+- `/home/m-tristan/workspace/Coltura/src/Module/Sites/Domain/Entity/Site.php` : entite Doctrine porteuse des attributs metier (nom unique, ville, code postal FR, couleur hex, adresse complete multi-ligne) et des timestamps auto-maintenus via lifecycle callbacks.
+
+### Domaine — Repository
+
+- `/home/m-tristan/workspace/Coltura/src/Module/Sites/Domain/Repository/SiteRepositoryInterface.php` : contrat d'acces domaine a l'entite Site (CRUD applicatif ; l'acces API Platform du ticket 4 utilisera le provider Doctrine par defaut).
+
+### Infrastructure — Doctrine
+
+- `/home/m-tristan/workspace/Coltura/src/Module/Sites/Infrastructure/Doctrine/DoctrineSiteRepository.php` : implementation Doctrine de `SiteRepositoryInterface` basee sur `ServiceEntityRepository`.
+
+### Infrastructure — Migration
+
+- `/home/m-tristan/workspace/Coltura/migrations/Version<timestamp>.php` : migration racine (namespace `DoctrineMigrations`) qui cree la table `site` et son index unique. Emplacement racine et non modulaire, cf. exception documentee dans `CLAUDE.md` (bug Doctrine 3.x sur le tri alphabetique des migrations multi-namespaces).
+
+### Infrastructure — DataFixtures
+
+- `/home/m-tristan/workspace/Coltura/src/Module/Sites/Infrastructure/DataFixtures/SitesFixtures.php` : fixture Doctrine seedant les 3 sites de demonstration. Ne declare pas de `DependentFixtureInterface` (aucune dependance a AppFixtures dans ce ticket).
+
+### Module — Declaration
+
+- `/home/m-tristan/workspace/Coltura/src/Module/Sites/SitesModule.php` : marker class du module avec `ID`, `LABEL`, `REQUIRED` et `permissions()`. Meme pattern que `CoreModule`.
+
+### Tests
+
+- `/home/m-tristan/workspace/Coltura/tests/Module/Sites/Domain/Entity/SiteTest.php` : tests unitaires purs (`TestCase`) couvrant constructeur, getters, setters et lifecycle `PreUpdate`.
+- `/home/m-tristan/workspace/Coltura/tests/Module/Sites/Domain/Entity/SiteValidationTest.php` : tests de validation (`KernelTestCase`) couvrant regex hex, regex CP FR, NotBlank, Length sur tous les champs, et `UniqueEntity` via la DB de test.
+
+## 4. Fichiers à modifier
+
+- `/home/m-tristan/workspace/Coltura/config/modules.php` : ajouter `App\Module\Sites\SitesModule::class` dans le tableau de retour. Le module est actif par defaut. Le commenter suffit a le desactiver sans autre intervention (les permissions deviendront orphelines a la prochaine sync mais la table reste).
+- `/home/m-tristan/workspace/Coltura/config/packages/doctrine.yaml` : ajouter une mapping `Sites:` alignee sur le pattern du module `Core:`. Le mapping est inconditionnel : il reste declare meme si `SitesModule::class` est retire de `modules.php`. Le commentaire doit etre explicite sur cette decoupe (activation fonctionnelle via `modules.php`, structure DB via la mapping Doctrine).
+- `/home/m-tristan/workspace/Coltura/config/services.yaml` : ajouter l'alias `App\Module\Sites\Domain\Repository\SiteRepositoryInterface` → `App\Module\Sites\Infrastructure\Doctrine\DoctrineSiteRepository`. Pattern aligne sur les trois aliases Core existants.
+
+## 5. Schéma cible — mapping Doctrine
+
+Comme pour le ticket RBAC (ticket-343), le schema est decrit par les attributs Doctrine plutot que par le SQL brut. Le fichier de migration contient le SQL final (section 6).
+
+### Conventions respectées
+
+- `declare(strict_types=1)` en tete de tous les fichiers PHP.
+- Identifiants de classe et proprietes en anglais, commentaires en francais (cf. `CLAUDE.md`).
+- PostgreSQL : noms de colonnes en snake_case minuscules, Doctrine les deduit des proprietes camelCase (`postalCode` → `postal_code`, `fullAddress` → `full_address`, `createdAt` → `created_at`, `updatedAt` → `updated_at`).
+- Le nom de table `site` n'est pas un mot reserve PostgreSQL : pas de backtick necessaire.
+
+### Entité `Site`
+
+```php
+#[ORM\Entity(repositoryClass: DoctrineSiteRepository::class)]
+#[ORM\Table(name: 'site')]
+#[ORM\UniqueConstraint(name: 'uniq_site_name', columns: ['name'])]
+#[ORM\HasLifecycleCallbacks]
+#[UniqueEntity(fields: ['name'], message: 'Un site avec ce nom existe deja.')]
+class Site
+{
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    #[ORM\Column]
+    private ?int $id = null;
+
+    #[ORM\Column(length: 100)]
+    #[Assert\NotBlank(message: 'Le nom du site est requis.')]
+    #[Assert\Length(max: 100, ...)]
+    private string $name;
+
+    #[ORM\Column(length: 100)]
+    #[Assert\NotBlank(message: 'La ville du site est requise.')]
+    #[Assert\Length(max: 100, ...)]
+    private string $city;
+
+    #[ORM\Column(name: 'postal_code', length: 10)]
+    #[Assert\NotBlank(message: 'Le code postal est requis.')]
+    #[Assert\Length(max: 10, ...)]
+    #[Assert\Regex(pattern: '/^\d{5}$/', message: '...')]
+    private string $postalCode;
+
+    #[ORM\Column(length: 7)]
+    #[Assert\NotBlank(message: 'La couleur est requise.')]
+    #[Assert\Regex(pattern: '/^#[0-9A-Fa-f]{6}$/', message: '...')]
+    private string $color;
+
+    #[ORM\Column(name: 'full_address', type: Types::TEXT)]
+    #[Assert\NotBlank(message: 'L\'adresse complete est requise.')]
+    #[Assert\Length(max: 500, ...)]
+    private string $fullAddress;
+
+    #[ORM\Column(name: 'created_at', type: Types::DATETIME_IMMUTABLE)]
+    private DateTimeImmutable $createdAt;
+
+    #[ORM\Column(name: 'updated_at', type: Types::DATETIME_IMMUTABLE)]
+    private DateTimeImmutable $updatedAt;
+}
+```
+
+Contraintes fonctionnelles :
+- `name` est unique en base (`uniq_site_name`) et porte egalement la contrainte applicative `UniqueEntity` pour que le validator remonte une violation lisible avant d'atteindre la violation DB.
+- `color` est contraint par regex a un code hex strict de 7 caracteres `#RRGGBB`, majuscules ou minuscules. La colonne `VARCHAR(7)` est dimensionnee au plus juste car la regex est exhaustive.
+- `postalCode` est contraint a 5 chiffres exacts via regex (format FR). La colonne `VARCHAR(10)` est volontairement plus large que la regex pour laisser marge si le projet etend plus tard la regex a d'autres formats (UK, PT, ...). Choix assume : evite une migration DDL au ticket suivant, cout DB negligeable sur un champ court.
+- `fullAddress` est de type `TEXT` (PostgreSQL) pour permettre une adresse multi-ligne, mais borne cote applicatif a 500 caracteres via `Assert\Length(max: 500)` comme garde DoS basique (une adresse FR complete tient largement dans cette enveloppe).
+- `createdAt` est seede dans le constructeur et **ne change plus jamais** apres persistance.
+- `updatedAt` est seede dans le constructeur a la meme valeur que `createdAt`, puis refresh a chaque update via le callback `#[ORM\PreUpdate]`.
+
+### Mapping Doctrine — `doctrine.yaml`
+
+```yaml
+# Mapping inconditionnelle du module Sites : la structure DB existe meme
+# si SitesModule::class est retire de config/modules.php. L'activation
+# fonctionnelle (ex: exposition des permissions, futurs endpoints API)
+# passe exclusivement par config/modules.php.
+Sites:
+    type: attribute
+    is_bundle: false
+    dir: '%kernel.project_dir%/src/Module/Sites/Domain/Entity'
+    prefix: 'App\Module\Sites\Domain\Entity'
+    alias: Sites
+```
+
+## 6. Plan de migration Doctrine
+
+La migration est placee dans `/home/m-tristan/workspace/Coltura/migrations/Version<timestamp>.php` au namespace racine `DoctrineMigrations`, conformement a l'exception documentee dans `CLAUDE.md`. Tant que le bug de tri alphabetique des `MigrationsComparator` multi-namespaces n'est pas resolu (via un comparator custom ou un upgrade Doctrine), toute migration d'initialisation (creation de table sur base vide) reste au namespace racine.
+
+### `up()` — ordre des instructions
+
+1. Creer la table `site` avec toutes les colonnes NOT NULL :
+   - `id INT GENERATED BY DEFAULT AS IDENTITY NOT NULL`
+   - `name VARCHAR(100) NOT NULL`
+   - `city VARCHAR(100) NOT NULL`
+   - `postal_code VARCHAR(10) NOT NULL`
+   - `color VARCHAR(7) NOT NULL`
+   - `full_address TEXT NOT NULL`
+   - `created_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL`
+   - `updated_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL`
+   - `PRIMARY KEY (id)`
+2. Creer l'index unique `uniq_site_name` sur `site(name)` pour garantir l'invariant metier "un site porte un nom unique" au niveau DB. Le validator applicatif `UniqueEntity` s'appuie dessus en lecture avant qu'une tentative d'insertion concurrente ne remonte la violation DB.
+
+### `down()` — rollback
+
+1. `DROP TABLE site`. Aucune FK n'existe depuis ou vers cette table dans ce ticket ; le rollback est donc trivial et safe.
+
+### Precision timestamp
+
+PostgreSQL `TIMESTAMP(0) WITHOUT TIME ZONE` stocke a la seconde pres. Les DateTimeImmutable PHP portent une precision microseconde mais perdent cette precision au round-trip DB. Les tests unitaires de lifecycle doivent en tenir compte (cf. section 10 — usage de reflection plutot qu'un `sleep`).
+
+## 7. Intégration avec sync-permissions
+
+Le ticket ne modifie pas `SyncPermissionsCommand`. Il exploite l'algorithme existant (cf. ticket-343 section 7) en declarant `SitesModule::permissions()` dans un format strictement conforme au contrat attendu par la commande :
+
+```php
+public static function permissions(): array
+{
+    return [
+        ['code' => 'sites.view', 'label' => 'Voir les sites'],
+        ['code' => 'sites.manage', 'label' => 'Gerer les sites (creer, editer, supprimer)'],
+    ];
+}
+```
+
+Regles de validation appliquees par `SyncPermissionsCommand` :
+- Chaque entree doit contenir exactement les cles `code` et `label`.
+- Le prefixe du code doit correspondre a `SitesModule::ID . '.'`, soit `sites.`.
+- Ni `code` ni `label` ne peuvent etre une chaine vide.
+
+Comportement a attendre :
+- Apres `php bin/console app:sync-permissions`, les deux lignes `sites.view` et `sites.manage` sont presentes dans la table `permission` avec `module = 'sites'` et `orphan = false`.
+- Si `SitesModule::class` est retire de `config/modules.php` et la commande relancee, les deux lignes sont marquees `orphan = true` (non supprimees, pour preserver les assignations). Reactiver le module les remet a `orphan = false`.
+- La cle `module` n'est **pas** presente dans le payload : elle est auto-injectee par la commande depuis `SitesModule::ID`.
+
+### Granularité des permissions
+
+`sites.manage` est une permission **composite** couvrant creation, edition et suppression. Ce choix reste simple pour un ticket fondateur, mais le ticket 4 (administration CRUD) devra arbitrer si une granularite plus fine (`sites.create`, `sites.edit`, `sites.delete`) est necessaire pour les besoins UX. Si oui, la migration de permissions se fera naturellement via la commande de sync : ajouter les trois codes dans `permissions()`, retirer `sites.manage` → la sync marque l'ancien orphelin sans casser les roles deja existants.
+
+## 8. Méthodes clés détaillées
+
+### `Site::__construct`
+
+Le constructeur prend les cinq champs metier obligatoires et positionne les deux timestamps a la meme valeur :
+
+```php
+public function __construct(
+    string $name,
+    string $city,
+    string $postalCode,
+    string $color,
+    string $fullAddress,
+) {
+    $this->name        = $name;
+    $this->city        = $city;
+    $this->postalCode  = $postalCode;
+    $this->color       = $color;
+    $this->fullAddress = $fullAddress;
+    $now               = new DateTimeImmutable();
+    $this->createdAt   = $now;
+    $this->updatedAt   = $now;
+}
+```
+
+Justification :
+- Tous les champs sont passes au constructeur pour forcer l'invariant "un Site instancie est toujours complet". L'alternative (setters post-new) autoriserait des etats transitoires invalides.
+- `createdAt` et `updatedAt` partagent la meme valeur a l'instanciation, ce qui garantit `updated_at >= created_at` au niveau base. Le premier appel a `onPreUpdate()` fera avancer uniquement `updatedAt`.
+
+### `Site::onPreUpdate`
+
+```php
+#[ORM\PreUpdate]
+public function onPreUpdate(): void
+{
+    $this->updatedAt = new DateTimeImmutable();
+}
+```
+
+Justification :
+- Callback Doctrine declenche **uniquement** quand Doctrine detecte au moins un changement sur l'entite en session de persistance. Pas de risque de tick silencieux sur un find pur.
+- `createdAt` n'est volontairement jamais touche ici : il est immuable apres persistance.
+- Pas de `#[ORM\PrePersist]` : le constructeur gere deja l'initialisation, inutile de dupliquer la logique dans un callback qui pourrait etre appele a vide.
+
+### `SitesFixtures::ensureSite`
+
+```php
+private function ensureSite(
+    ObjectManager $manager,
+    string $name,
+    string $city,
+    string $postalCode,
+    string $color,
+    string $fullAddress,
+): Site {
+    $site = $this->siteRepository->findByName($name);
+
+    if (null === $site) {
+        $site = new Site($name, $city, $postalCode, $color, $fullAddress);
+        $manager->persist($site);
+
+        return $site;
+    }
+
+    $site->setCity($city);
+    $site->setPostalCode($postalCode);
+    $site->setColor($color);
+    $site->setFullAddress($fullAddress);
+
+    return $site;
+}
+```
+
+Contrat honnete sur l'idempotence (cf. docblock en tete de fixture) :
+- **Supporte** : lookup par nom avec purger Doctrine actif (cas nominal de `doctrine:fixtures:load`).
+- **Supporte** : lookup par nom hors purger si la fixture est rejouee telle quelle sur une base deja seedee → les autres champs sont re-alignes sur les valeurs de reference.
+- **Non supporte** : chargement cumulatif apres qu'une autre fixture ait `persist` (sans `flush`) des Site dans la meme session → `findByName` via `findOneBy` n'inspecte pas l'unit-of-work et peut creer un doublon.
+- **Non supporte** : renommage d'un site dans la fixture → le lookup par `name` rate, un nouveau site est cree, l'ancien reste en base si le purger est desactive.
+
+## 9. Fixtures Sites
+
+Trois sites de demonstration, avec des couleurs distinctes suffisamment contrastees pour un futur affichage visuel (ticket 3 — navbar) :
+
+| Nom | Ville | CP | Couleur | Commentaire |
+|-----|-------|-----|---------|-------------|
+| Chatellerault | Chatellerault | 86100 | `#056CF2` | Couleur imposee par le ticket (bleu Coltura). |
+| Saint-Jean | Saint-Jean-de-Sauves | 86330 | `#10B981` | Vert emeraude (contraste avec le bleu). |
+| Pommevic | Pommevic | 82400 | `#F59E0B` | Ambre (troisieme teinte nettement distincte). |
+
+Les adresses completes sont des chaines multi-lignes (voie + CP/ville), cas nominal d'exploitation du type `TEXT` sur `full_address`.
+
+### Ordre d'execution global des fixtures
+
+`SitesFixtures` est une `Fixture` sans dependance : elle peut s'executer dans n'importe quel ordre relatif aux autres fixtures Core (`AppFixtures`). Aucune FK inter-modules dans ce ticket.
+
+Le ticket 2 introduira probablement une relation `User ↔ Site` ; `SitesFixtures` devra alors etre declare comme dependance de `AppFixtures` (ou inversement, selon la direction de la FK) via `DependentFixtureInterface::getDependencies()`.
+
+## 10. Plan de tests PHPUnit
+
+Deux suites separees, motivation :
+- `SiteTest` reste en `TestCase` pur (pas de kernel) pour tester le comportement mecanique de l'entite — rapide, zero dependance DB.
+- `SiteValidationTest` utilise `KernelTestCase` pour avoir acces au validator applicatif, **indispensable** pour tester `UniqueEntity` dont le validator est backed par Doctrine et necessite donc un `ManagerRegistry` reel.
+
+### `SiteTest` — tests unitaires purs
+
+1. `testConstructorInitialState` : verifie que le constructeur positionne correctement les 5 champs metier et les deux timestamps (`DateTimeImmutable`).
+2. `testCreatedAtAndUpdatedAtAreInitiallyEqual` : verifie l'invariant "a l'instanciation, `createdAt == updatedAt`".
+3. `testOnPreUpdateAdvancesUpdatedAtOnly` : utilise `Reflection` pour forcer `updatedAt` a une valeur anterieure (`-1 hour`), appelle `onPreUpdate()`, et verifie que `updatedAt` avance strictement mais que `createdAt` reste immuable.
+   - **Justification reflection** : eviter un `sleep/usleep` flaky en CI et lent.
+4. `testSettersMutateFields` : verifie que les setters publics modifient correctement les champs metier.
+
+### `SiteValidationTest` — tests d'integration validator
+
+Bootstrap : `self::bootKernel()` dans `setUp()`, recuperation de `ValidatorInterface` et `EntityManagerInterface` depuis le container.
+
+Tests de validation scalaire (via `DataProvider` PHPUnit 12+, attribut `#[DataProvider]`) :
+1. `testValidSitePassesValidation` : un Site correct passe sans violation.
+2. `testColorMustBeHexRrggbb` / `testValidColorsAreAccepted` : jeu de donnees invalide (`red`, `#FFF`, `FFFFFF`, `rgb(...)`, `#1234567`, `#12345G`, `""`) vs valide (`#ABCDEF`, `#abcdef`, `#0a1B2c`, `#000000`, `#FFFFFF`).
+3. `testPostalCodeMustMatchFrFormat` / `testValidPostalCodesAreAccepted` : jeu de donnees invalide (`1234`, `123456`, `8610A`, `86-100`, `""`, `86 100`) vs valide (`86100`, `75001`, `97100`, `20000`).
+4. `testBlankNameIsRejected`, `testBlankCityIsRejected`, `testBlankFullAddressIsRejected` : `NotBlank` sur chaque champ obligatoire.
+5. `testNameLongerThan100CharsIsRejected`, `testCityLongerThan100CharsIsRejected` : `Length(max: 100)`.
+
+Test d'unicite :
+6. `testDuplicateNameIsRejected` : **auto-suffisant** — persiste lui-meme un site porteur d'un nom unique (`Test-Duplicate-<uniqid>`), flush, tente de valider un second Site avec le meme nom, verifie qu'au moins une violation porte `UniqueEntity::NOT_UNIQUE_ERROR` sur la property `name`, puis supprime le site en `finally`.
+   - **Justification** : pas de dependance aux fixtures (robustesse, pas de couplage sur `Chatellerault`). Assertion precise sur le `code` de violation + `propertyPath`, pas sur le message (resistant aux traductions).
+
+### Pattern `finally` pour cleanup
+
+```php
+try {
+    $duplicate  = new Site($name, ...);
+    $violations = $this->validator->validate($duplicate);
+    // assertions...
+} finally {
+    $this->em->remove($original);
+    $this->em->flush();
+}
+```
+
+Garantit le cleanup meme si une assertion rate, sans dependre d'une transaction globale de test.
+
+## 11. Risques et points d'attention
+
+### Risque 1 — Mapping Doctrine inconditionnel
+
+Le mapping `Sites:` est declare dans `doctrine.yaml` sans dependance a `config/modules.php`. Consequence : retirer `SitesModule::class` de `modules.php` ne desactive **pas** le mapping Doctrine ni la table `site`.
+
+Decision assumee et alignee avec le traitement du module `Core` :
+- La structure DB est "toujours la" (migrations jouees inconditionnellement).
+- L'activation fonctionnelle (exposition des permissions, futurs endpoints) passe exclusivement par `modules.php`.
+
+Cela doit etre **explicite dans `doctrine.yaml`** via un commentaire en tete du bloc `Sites:` pour eviter qu'un futur reviewer n'interprete le mapping comme un oubli.
+
+### Risque 2 — Migration racine vs migration modulaire
+
+La migration est placee dans `migrations/` et non dans `src/Module/Sites/Infrastructure/Doctrine/Migrations/`. C'est une exception documentee dans `CLAUDE.md` et dans le docblock de la migration elle-meme, motivee par un bug de tri alphabetique des `MigrationsComparator` en Doctrine Migrations 3.x lorsque plusieurs `migrations_paths` sont declares.
+
+Consequence pour les tickets futurs :
+- Tant que le bug n'est pas resolu, **toute nouvelle migration d'initialisation** (creation de table sur base vide) continuera d'aller au namespace racine.
+- Les migrations applicatives (ajout de colonne, backfill) qui supposent un schema deja en place peuvent vivre dans le namespace modulaire, comme prevu.
+- Une fois le bug resolu (comparator custom ou upgrade Doctrine), migrer les fichiers vers le namespace modulaire sera un simple `git mv` + ajustement du namespace PHP.
+
+### Risque 3 — Idempotence des fixtures non cumulative
+
+Le docblock de `SitesFixtures` declare explicitement les cas d'idempotence supportes et non supportes (cf. section 8). Ne pas promettre une robustesse que le pattern ne tient pas : si un futur ticket introduit une fixture persistant des Site **avant** `SitesFixtures` sans flush intermediaire, un doublon peut apparaitre. Le contrat ecrit permet au reviewer de ce futur ticket de reagir.
+
+### Risque 4 — Regex couleur non normalisee
+
+La regex `/^#[0-9A-Fa-f]{6}$/` accepte majuscules et minuscules. Les fixtures utilisent des majuscules ; si l'UI du ticket 4 permet de saisir en minuscules, deux couleurs "visuellement identiques" pourront coexister en base avec casse differente, cassant toute comparaison naive (`$a->color === $b->color`). A decider au ticket 4 : normaliser en uppercase a la persistance, ou assumer le stockage tel quel et normaliser uniquement a la comparaison.
+
+### Risque 5 — Precision timestamp PostgreSQL TIMESTAMP(0)
+
+PostgreSQL `TIMESTAMP(0)` ecrete a la seconde pres. Deux updates espaces de moins d'une seconde produisent le meme `updated_at` en base. Pas un probleme pour les cas d'usage metier de ce ticket (edition manuelle), mais a garder en tete si un ticket futur introduit un `updatedAt` comme cle de tri ou de detection de version optimiste.
+
+## 12. Ordre d'exécution recommandé
+
+1. **Exploration** — Lire le module Core (`CoreModule.php`, `User.php`, `Role.php`) pour aligner le style.
+2. **Module declaration** — Creer `SitesModule.php` avec `permissions()`.
+3. **Entite** — Creer `Site.php` avec tous les attributs Doctrine et contraintes de validation.
+4. **Repository** — Creer `SiteRepositoryInterface.php` puis `DoctrineSiteRepository.php`.
+5. **Configuration** — Enregistrer le mapping dans `doctrine.yaml`, l'alias dans `services.yaml`, le module dans `modules.php`.
+6. **Migration** — Generer le fichier de migration (manuellement ou via `doctrine:migrations:diff` puis ajuster), jouer `make migration-migrate`.
+7. **Fixtures** — Creer `SitesFixtures.php`, jouer `make fixtures` puis `make sync-permissions`.
+8. **Tests unitaires** — Ecrire `SiteTest.php` (TestCase pur).
+9. **Tests validation** — Ecrire `SiteValidationTest.php` (KernelTestCase).
+10. **Validation DoD** — `make test-db-setup && make test` (doit passer 148/148), verifier que designer SitesModule ne casse rien.
+11. **CS fixer** — `make php-cs-fixer-allow-risky FILES="src/Module/Sites tests/Module/Sites migrations/Version<timestamp>.php config/..."`.
+
+## 13. Critères d'acceptation (DoD)
+
+- [ ] `SitesModule.php` existe et declare exactement 2 permissions (`sites.view`, `sites.manage`) prefixees `sites.` conformement au format attendu par `SyncPermissionsCommand`.
+- [ ] `SitesModule::class` est enregistre dans `config/modules.php` et active par defaut.
+- [ ] Entite `Site` creee avec tous les champs, contraintes de validation (`NotBlank`, `Length`, `Regex hex`, `Regex CP FR`, `UniqueEntity`) et timestamps auto.
+- [ ] `SiteRepositoryInterface` expose au minimum `findById`, `findByName`, `findAllOrderedByName`, `save`, `remove` ; `DoctrineSiteRepository` l'implemente.
+- [ ] La migration existe dans `migrations/` (namespace `DoctrineMigrations`), cree la table `site` et l'index unique `uniq_site_name`, est jouable via `make migration-migrate`.
+- [ ] `SitesFixtures` cree les 3 sites avec couleurs distinctes et docblock honnete sur son idempotence.
+- [ ] `make fixtures` charge les 3 sites sans erreur et est rejouable apres purge.
+- [ ] Apres `app:sync-permissions`, la table `permission` contient `sites.view` et `sites.manage` avec `module = 'sites'` et `orphan = false`.
+- [ ] Le mapping `Sites:` est declare dans `doctrine.yaml` avec un commentaire explicite sur son caractere inconditionnel.
+- [ ] L'alias `SiteRepositoryInterface → DoctrineSiteRepository` est declare dans `services.yaml`.
+- [ ] `make test` passe 148/148 tests avec `SitesModule::class` active.
+- [ ] `make test` passe 148/148 tests avec `SitesModule::class` commente dans `config/modules.php`.
+- [ ] `make php-cs-fixer-allow-risky` ne signale aucune correction sur les fichiers du ticket.
+- [ ] Aucun import direct depuis `src/Module/Core/...` vers `src/Module/Sites/...` ni l'inverse (independance des bounded contexts).

docs/sites/ticket-02-spec.md

@@ -0,0 +1,701 @@
+# Ticket #02 — 2/4 — Exposition API, rattachement utilisateurs et admin CRUD
+
+## 1. Objectif
+
+Ce ticket transforme la brique de donnees du ticket 1 en module fonctionnel : il expose la ressource `Site` via API Platform (CRUD admin avec RBAC), introduit la notion de **sites autorises** et de **site courant** sur chaque utilisateur, ouvre un endpoint dedie au basculement du site courant, et livre la page d'administration `/admin/sites` ainsi que l'assignation des sites dans le drawer RBAC d'un user.
+
+Le resultat attendu est un module Sites utilisable de bout en bout cote admin (creer, editer, supprimer des sites et en assigner aux users), avec une API `/api/me` enrichie que le ticket 3 consommera pour alimenter le selecteur de site dans la navbar. Le ticket etablit le couplage Core → Sites **au niveau modele** (la table `user` gagne deux relations vers `site`) tout en conservant le contrat "desactiver Sites dans `config/modules.php` ne casse pas l'app" via des decisions DB/mapping assumees.
+
+## 2. Périmètre
+
+### IN
+
+- Exposer `Site` comme ressource API Platform avec les operations `GetCollection`, `Get`, `Post`, `Patch`, `Delete`, securisees par les permissions `sites.view` (lecture) et `sites.manage` (ecriture).
+- Ajouter deux relations sur `User` (module Core) :
+  - `$sites` (M2M, `user_site`) : sites autorises.
+  - `$currentSite` (M2O nullable) : site actuellement selectionne.
+- Ajouter la relation inverse `$users` sur `Site` (non exposee API).
+- Generer la migration Doctrine creant la table `user_site` et la colonne `user.current_site_id` avec les bonnes strategies `ON DELETE` pour garantir les cascades attendues (suppression d'un site → `user_site` purge, `currentSite` mis a `NULL`).
+- Etendre `/api/me` pour exposer `sites: Site[]` et `currentSite: Site | null` en objets serialises (pas en IRI), via les groupes `me:read` sur `User` **et** sur `Site`.
+- Ajouter un endpoint dedie de switch du site courant, implemente comme une ressource API Platform virtuelle `CurrentSite` avec une operation `Patch uriTemplate: '/me/current-site'` et un processor dedie. Le processor garantit que le site cible fait partie des `sites` de l'utilisateur authentifie, sinon il leve une exception traduite en `403`.
+- Etendre `UserRbacProcessor` et l'operation `PATCH /api/users/{id}/rbac` pour accepter un champ `sites: string[]` (IRIs) en plus des roles et permissions directes. Cas limite : si le `currentSite` du user cible n'est plus dans la liste, le processor le bascule a `NULL`.
+- Etendre l'exception metier Core pour couvrir "site non autorise" via une nouvelle exception domaine `SiteNotAuthorizedException` placee dans le module Sites, traduite en `ForbiddenHttpException` au niveau API.
+- Ajouter l'entree sidebar `sidebar.admin.sites` filtree par `module: 'sites'` + `permission: 'sites.view'` dans `config/sidebar.php`, sous la section admin Core existante.
+- Livrer la page d'administration `/admin/sites` cote front (layer Nuxt `frontend/modules/sites/`) : DataTable + drawer creation/edition + modale suppression, alignee visuellement et structurellement sur `/admin/roles` et `/admin/users`.
+- Etendre le drawer `UserRbacDrawer.vue` (module Core) pour afficher et editer la liste des sites autorises d'un user via un multi-select.
+- Ajouter les fixtures : rattacher les 3 users existants (`admin`, `alice`, `bob`) a au moins un site et positionner un `currentSite` coherent.
+- Couverture de tests PHPUnit : CRUD `/api/sites`, endpoint `/me/current-site` (cas OK + 403), extension `/api/me`, cascade DB a la suppression d'un site, extension `UserRbacProcessor` (ajout/retrait sites, auto-reset currentSite).
+
+### OUT
+
+- Ticket `#03` : selecteur de site dans la navbar, persistance du site actif cote front, integration visuelle avec la couleur du site.
+- Ticket `#04` : filtrage metier par site (ex: bloquer l'acces aux ressources Commercial si l'user n'est pas rattache au site de la ressource).
+- Soft-delete des sites : non introduit.
+- Audit trail des modifications : hors scope.
+- Color picker avance : un input hex simple avec preview de la puce suffit.
+- Recherche / tri server-side sur `/api/sites` : non requis, le volume reste <20 sites par instance.
+- Gestion des site "globaux" ou "par defaut" pour les nouveaux users : non introduite, les users crees via `CreateUserCommand` ou `/api/users` POST auront `sites: []` et `currentSite: null` jusqu'a rattachement explicite.
+
+## 3. Fichiers à créer
+
+### Backend — Module Sites
+
+- `/home/m-tristan/workspace/Coltura/src/Module/Sites/Domain/Exception/SiteNotAuthorizedException.php` : exception domaine levee si un user tente de switcher vers un site qui ne fait pas partie de ses sites autorises. Porte un message i18n-able et le code du site cible.
+- `/home/m-tristan/workspace/Coltura/src/Module/Sites/Infrastructure/ApiPlatform/Resource/CurrentSiteResource.php` : ressource API Platform **virtuelle** (pas de mapping Doctrine, pas de `#[ORM\Entity]`). Sert uniquement a porter l'operation `Patch` `/me/current-site`. Expose une propriete `site: Site` en denormalisation pour recevoir l'IRI du site cible, et re-expose l'user courant en normalisation via le groupe `me:read`.
+- `/home/m-tristan/workspace/Coltura/src/Module/Sites/Infrastructure/ApiPlatform/State/Processor/CurrentSiteProcessor.php` : processor dedie a l'operation de switch. Valide l'appartenance du site aux `user.sites`, positionne `user.currentSite`, flush, retourne l'user.
+- `/home/m-tristan/workspace/Coltura/src/Module/Sites/Infrastructure/ApiPlatform/EventListener/SiteNotAuthorizedExceptionListener.php` : listener Kernel qui convertit `SiteNotAuthorizedException` en `ForbiddenHttpException` (403) avec un code i18n stable (cf. pattern `SystemRoleDeletionException` du module Core dans les tickets RBAC precedents).
+
+### Backend — Migration
+
+- `/home/m-tristan/workspace/Coltura/migrations/Version<timestamp2>.php` : migration au namespace racine `DoctrineMigrations` (cf. exception Doctrine documentee dans `CLAUDE.md`). Cree la table `user_site` et la colonne `user.current_site_id` avec les FKs et cascades appropriees.
+
+### Backend — Tests API
+
+- `/home/m-tristan/workspace/Coltura/tests/Module/Sites/Api/SiteApiTest.php` : CRUD complet `/api/sites` avec matrices RBAC (admin, user avec `sites.view`, user avec `sites.manage`, user sans permission).
+- `/home/m-tristan/workspace/Coltura/tests/Module/Sites/Api/CurrentSiteSwitchApiTest.php` : PATCH `/me/current-site` (OK avec site autorise, 403 avec site non autorise, 400 avec IRI invalide).
+- `/home/m-tristan/workspace/Coltura/tests/Module/Sites/Api/MeEndpointSitesTest.php` : `/api/me` expose bien `sites` et `currentSite` en objets. User sans site : `sites: []`, `currentSite: null`.
+- `/home/m-tristan/workspace/Coltura/tests/Module/Sites/Api/SiteCascadeTest.php` : suppression d'un site `X` → toutes les lignes `user_site` referencant `X` sont supprimees, tous les users ayant `X` en `currentSite` voient leur `currentSite` repasser a `NULL`.
+- `/home/m-tristan/workspace/Coltura/tests/Module/Core/Api/UserRbacSitesApiTest.php` : extension du endpoint `/api/users/{id}/rbac` — ajout de `sites: []` dans le payload, retrait du `currentSite` quand le site retire etait le courant.
+
+### Frontend — Module Sites (nouveau layer)
+
+- `/home/m-tristan/workspace/Coltura/frontend/modules/sites/nuxt.config.ts` : marker de layer Nuxt (vide). Declenche l'auto-detection par `nuxt.config.ts` racine.
+- `/home/m-tristan/workspace/Coltura/frontend/modules/sites/pages/admin/sites.vue` : page `/admin/sites`. Reutilise les composants Malio UI (`MalioDataTable`, `MalioButton`, `MalioInputText`, `MalioInputTextArea`). Pattern identique a `frontend/modules/core/pages/admin/roles.vue`.
+- `/home/m-tristan/workspace/Coltura/frontend/modules/sites/components/SiteDrawer.vue` : drawer creation/edition. Formulaire 5 champs (nom, ville, CP, couleur avec preview puce, adresse). Valide cote front sur le submit avant d'envoyer.
+- `/home/m-tristan/workspace/Coltura/frontend/modules/sites/components/SiteDeleteModal.vue` : modale de confirmation suppression. Pattern aligne sur `RoleDeleteModal.vue`.
+
+### Frontend — Types partages
+
+- `/home/m-tristan/workspace/Coltura/frontend/shared/types/sites.ts` : types `Site`, `SiteInput`. Pattern identique a `frontend/shared/types/rbac.ts`.
+
+### Tests frontend (optionnels mais recommandes)
+
+- `/home/m-tristan/workspace/Coltura/frontend/modules/sites/pages/admin/sites.spec.ts` : smoke test Vitest (rendu + clic bouton "Nouveau site" ouvre le drawer).
+
+## 4. Fichiers à modifier
+
+### Backend — Module Core
+
+- `/home/m-tristan/workspace/Coltura/src/Module/Core/Domain/Entity/User.php` :
+  - Ajouter `private Collection $sites;` (M2M, `fetch: EAGER`, `JoinTable: user_site`), groupes `me:read`, `user:list`, `user:rbac:read`, `user:rbac:write`.
+  - Ajouter `private ?Site $currentSite = null;` (M2O, `fetch: EAGER`, `onDelete: 'SET NULL'`), groupe `me:read`.
+  - Initialiser `$this->sites = new ArrayCollection();` dans le constructeur.
+  - Ajouter les accesseurs `getSites()`, `addSite(Site)`, `removeSite(Site)`, `hasSite(Site)`, `getCurrentSite()`, `setCurrentSite(?Site)`.
+  - **Important** : `import` direct `App\Module\Sites\Domain\Entity\Site`. Ce ticket assume le couplage Core → Sites au niveau code PHP (cf. Risque 1).
+- `/home/m-tristan/workspace/Coltura/src/Module/Core/Infrastructure/ApiPlatform/State/Processor/UserRbacProcessor.php` :
+  - Etendre le contrat d'entree pour accepter le champ `sites` (collection d'IRIs denormalisees en `Collection<Site>`).
+  - Apres l'application des roles et permissions directes, detecter si `currentSite` du user cible n'est plus dans la nouvelle collection `sites` → basculer `currentSite` a `null`.
+  - Conserver toutes les gardes existantes (auto-suicide admin, dernier admin global).
+- `/home/m-tristan/workspace/Coltura/src/Module/Core/Infrastructure/DataFixtures/AppFixtures.php` :
+  - Declarer l'implementation `DependentFixtureInterface` avec `getDependencies(): [SitesFixtures::class]` (inversion de l'ordre actuel : AppFixtures doit tourner **apres** SitesFixtures pour pouvoir reference les sites).
+  - Rattacher chaque user a au moins un site : `admin` a tous les sites (`Chatellerault`, `Saint-Jean`, `Pommevic`), `alice` a `Chatellerault`, `bob` a `Saint-Jean`.
+  - Positionner `currentSite` : `admin.currentSite = Chatellerault`, `alice.currentSite = Chatellerault`, `bob.currentSite = Saint-Jean`.
+
+### Backend — Module Sites
+
+- `/home/m-tristan/workspace/Coltura/src/Module/Sites/Domain/Entity/Site.php` :
+  - Ajouter les attributs `#[ApiResource]` + operations (cf. section 5 Schema).
+  - Ajouter les groupes de serialisation `site:read`, `site:write`, `me:read` sur les proprietes scalaires.
+  - Ajouter la relation inverse `private Collection $users;` (M2M mappedBy=`sites`), **sans** groupe de serialisation (pas d'exposition API cote Site).
+  - Initialiser `$this->users = new ArrayCollection();` dans le constructeur.
+  - Ajouter les accesseurs `getUsers()` pour les besoins metier (count / cascade manuel si besoin).
+- `/home/m-tristan/workspace/Coltura/src/Module/Sites/Infrastructure/DataFixtures/SitesFixtures.php` : aucun changement de contenu, mais verifier que la fixture n'est plus en bout de chaine de dependance (AppFixtures depend d'elle maintenant).
+
+### Backend — Configuration
+
+- `/home/m-tristan/workspace/Coltura/config/sidebar.php` : inserer l'entree `Sites` dans la section `sidebar.general.section` entre `sidebar.core.users` et `sidebar.general.logout` :
+  ```php
+  [
+      'label'      => 'sidebar.core.sites',
+      'to'         => '/admin/sites',
+      'icon'       => 'mdi:domain',
+      'module'     => 'sites',
+      'permission' => 'sites.view',
+  ],
+  ```
+- `/home/m-tristan/workspace/Coltura/config/services.yaml` : aucun changement requis. `CurrentSiteProcessor`, `SiteNotAuthorizedExceptionListener` sont autoconfigures.
+
+### Frontend
+
+- `/home/m-tristan/workspace/Coltura/frontend/modules/core/components/UserRbacDrawer.vue` :
+  - Charger `GET /api/sites?itemsPerPage=999` a l'ouverture du drawer (parallelement aux roles et permissions deja charges).
+  - Ajouter une section `sidebar.admin.usersDrawer.sitesSection` sous la section permissions directes, avec un groupe de `MalioCheckbox` par site (ou un `MalioMultiSelect` si le composant existe dans `@malio/layer-ui`).
+  - Etendre le payload `PATCH /api/users/{id}/rbac` avec `sites: Array<string>` (IRIs).
+  - Auto-refresh de l'auth store apres save si `isSelfEdit` (deja present, conserver).
+- `/home/m-tristan/workspace/Coltura/frontend/shared/types/rbac.ts` : ajouter le champ `sites: string[]` a `UserListItem` (IRIs de sites attaches).
+- `/home/m-tristan/workspace/Coltura/frontend/shared/stores/auth.ts` : le store auth expose deja `user` via `/api/me`. Aucune modification requise, les nouveaux champs `sites` et `currentSite` suivent automatiquement via la typologie — a condition de mettre a jour le type `UserData` dans `shared/types/` (ajouter `sites: Site[]` et `currentSite: Site | null`).
+- `/home/m-tristan/workspace/Coltura/frontend/i18n/locales/fr.json` : cles
+  - `sidebar.core.sites` = "Sites".
+  - `admin.sites.title`, `admin.sites.newSite`, `admin.sites.editSite`, `admin.sites.createSite`, `admin.sites.noSites`.
+  - `admin.sites.table.{name, city, postalCode, color, fullAddress}`.
+  - `admin.sites.form.{name, city, postalCode, color, fullAddress}`.
+  - `admin.sites.delete.{title, message}`.
+  - `admin.sites.toast.{created, updated, deleted}`.
+  - `admin.users.drawer.sitesSection` = "Sites autorises".
+  - `errors.sites.notAuthorized` = "Vous n'etes pas autorise a selectionner ce site.".
+
+## 5. Schéma cible — ApiResource et Doctrine
+
+### Entite `Site` — attributs ApiResource
+
+```php
+#[ApiResource(
+    operations: [
+        new GetCollection(
+            security: "is_granted('sites.view')",
+            normalizationContext: ['groups' => ['site:read']],
+        ),
+        new Get(
+            security: "is_granted('sites.view')",
+            normalizationContext: ['groups' => ['site:read']],
+        ),
+        new Post(
+            security: "is_granted('sites.manage')",
+            normalizationContext: ['groups' => ['site:read']],
+            denormalizationContext: ['groups' => ['site:write']],
+        ),
+        new Patch(
+            security: "is_granted('sites.manage')",
+            normalizationContext: ['groups' => ['site:read']],
+            denormalizationContext: ['groups' => ['site:write']],
+        ),
+        new Delete(security: "is_granted('sites.manage')"),
+    ],
+)]
+```
+
+Groupes sur les proprietes de `Site` :
+- `id` : `site:read`, `me:read`.
+- `name`, `city`, `postalCode`, `color`, `fullAddress` : `site:read`, `site:write`, `me:read`.
+- `createdAt`, `updatedAt` : `site:read` uniquement (pas exposes en embed `me:read` pour garder le payload /me leger).
+
+### Evolution de `User` — nouvelles relations
+
+```php
+/** @var Collection<int, Site> */
+#[ORM\ManyToMany(targetEntity: Site::class, fetch: 'EAGER')]
+#[ORM\JoinTable(name: 'user_site')]
+#[Groups(['me:read', 'user:list', 'user:rbac:read', 'user:rbac:write'])]
+private Collection $sites;
+
+#[ORM\ManyToOne(targetEntity: Site::class, fetch: 'EAGER')]
+#[ORM\JoinColumn(name: 'current_site_id', referencedColumnName: 'id', nullable: true, onDelete: 'SET NULL')]
+#[Groups(['me:read'])]
+private ?Site $currentSite = null;
+```
+
+Justification fetch=EAGER :
+- Aligne sur les collections `$rbacRoles` et `$directPermissions` (cf. `User.php:87`).
+- Critique pour eviter un lazy-load silencieux pendant un refresh JWT (cf. ticket 343 section 11 risque 1).
+- Surcout SQL accepte a l'echelle d'un CRM PME (≤20 sites par instance).
+
+### Relation inverse sur `Site`
+
+```php
+/** @var Collection<int, User> */
+#[ORM\ManyToMany(targetEntity: User::class, mappedBy: 'sites')]
+private Collection $users;
+```
+
+Pas de `#[Groups]` : la collection inverse n'est pas exposee dans la reponse API. Sa seule utilite est metier (compter les users d'un site, iterer pour un cascade applicatif si la cascade DB ne suffisait pas).
+
+### Ressource virtuelle `CurrentSite`
+
+```php
+#[ApiResource(
+    shortName: 'CurrentSite',
+    operations: [
+        new Patch(
+            uriTemplate: '/me/current-site',
+            security: "is_granted('ROLE_USER')",
+            normalizationContext: ['groups' => ['me:read']],
+            denormalizationContext: ['groups' => ['current-site:write']],
+            processor: CurrentSiteProcessor::class,
+            read: false,
+        ),
+    ],
+)]
+final class CurrentSiteResource
+{
+    #[Groups(['current-site:write'])]
+    public ?Site $site = null;
+}
+```
+
+- `read: false` : API Platform ne tente pas de charger une entite existante via un Provider — il se contente de denormaliser le body et de passer la ressource au processor.
+- `shortName: 'CurrentSite'` : evite la collision de nommage avec l'entite `Site`.
+- `security: "is_granted('ROLE_USER')"` : tout user authentifie peut tenter un switch ; l'autorisation fine (appartenance du site aux `sites` du user) est verifiee par le processor, pas par la voter RBAC.
+
+## 6. Plan de migration Doctrine
+
+La migration est placee dans `/home/m-tristan/workspace/Coltura/migrations/Version<timestamp2>.php` au namespace racine (cf. Risque 2 du ticket 1 et `CLAUDE.md`).
+
+### `up()` — ordre des instructions
+
+1. `ALTER TABLE "user" ADD current_site_id INT DEFAULT NULL` — colonne nullable, pas besoin de backfill.
+2. `CREATE TABLE user_site (user_id INT NOT NULL, site_id INT NOT NULL, PRIMARY KEY (user_id, site_id))`.
+3. `CREATE INDEX IDX_user_site_user ON user_site (user_id)`.
+4. `CREATE INDEX IDX_user_site_site ON user_site (site_id)`.
+5. `ALTER TABLE user_site ADD CONSTRAINT FK_user_site_user FOREIGN KEY (user_id) REFERENCES "user" (id) ON DELETE CASCADE`.
+6. `ALTER TABLE user_site ADD CONSTRAINT FK_user_site_site FOREIGN KEY (site_id) REFERENCES site (id) ON DELETE CASCADE`.
+7. `CREATE INDEX IDX_user_current_site ON "user" (current_site_id)`.
+8. `ALTER TABLE "user" ADD CONSTRAINT FK_user_current_site FOREIGN KEY (current_site_id) REFERENCES site (id) ON DELETE SET NULL`.
+
+### `down()` — rollback
+
+1. `ALTER TABLE "user" DROP CONSTRAINT FK_user_current_site`.
+2. `DROP INDEX IDX_user_current_site`.
+3. `ALTER TABLE "user" DROP current_site_id`.
+4. `ALTER TABLE user_site DROP CONSTRAINT FK_user_site_site`.
+5. `ALTER TABLE user_site DROP CONSTRAINT FK_user_site_user`.
+6. `DROP TABLE user_site`.
+
+### Comportement des cascades
+
+| Action | Effet |
+|--------|-------|
+| `DELETE FROM site WHERE id = X` | Toutes les lignes `user_site` avec `site_id = X` sont supprimees (FK `ON DELETE CASCADE`). Tous les users avec `current_site_id = X` voient leur `current_site_id` passer a `NULL` (FK `ON DELETE SET NULL`). |
+| `DELETE FROM "user" WHERE id = Y` | Toutes les lignes `user_site` avec `user_id = Y` sont supprimees. Pas d'effet sur `site`. |
+| `DELETE FROM user_site WHERE user_id = Y AND site_id = X` | Aucun effet auto sur `user.current_site_id` — si `X` etait le courant de `Y`, c'est le **UserRbacProcessor** qui doit le basculer a `NULL` en Php (cf. section 8). |
+
+**Important** : la derniere ligne du tableau est la raison pour laquelle la logique de "retirer un site qui etait le courant remet currentSite a null" vit dans `UserRbacProcessor` cote applicatif et non dans la DB via un trigger. C'est un compromis assume : la regle est metier ("retirer un droit ne doit pas laisser l'user pointer sur un site interdit"), pas purement DB.
+
+## 7. Algorithme du switch de site courant — `CurrentSiteProcessor`
+
+### Entree
+
+Body JSON envoye par le client :
+```json
+{ "site": "/api/sites/3" }
+```
+
+API Platform denormalise vers `CurrentSiteResource { site: Site }` en resolvant l'IRI via son `IriConverter`.
+
+### Algorithme
+
+1. Recuperer l'user authentifie via `Security::getUser()`. Si absent → `LogicException` (l'operation exige `ROLE_USER`, ne doit pas arriver).
+2. Extraire `$targetSite = $resource->site`. Si `null` → `BadRequestHttpException('Le champ "site" est requis.')`.
+3. Verifier `$user->hasSite($targetSite)` :
+   - Implementation : `$this->sites->contains($targetSite)` (comparaison par reference ; Doctrine garantit l'identite d'objet dans la meme session).
+   - Si `false` → throw `SiteNotAuthorizedException($targetSite->getId())`.
+4. `$user->setCurrentSite($targetSite)`.
+5. `$this->entityManager->flush()`.
+6. Retourner `$user` — API Platform le normalise via les groupes `me:read` definis sur l'operation.
+
+### Mapping d'exception
+
+`SiteNotAuthorizedException` est convertie en `Symfony\Component\HttpKernel\Exception\HttpException` avec statut `403` par `SiteNotAuthorizedExceptionListener` (event `kernel.exception`, priority standard). Le corps de la reponse porte un code i18n-able `errors.sites.notAuthorized` pour le front.
+
+## 8. Évolution du `UserRbacProcessor`
+
+### Nouveau champ en entree
+
+Le payload accepte desormais :
+```json
+{
+  "isAdmin": false,
+  "roles": ["/api/roles/2"],
+  "directPermissions": [],
+  "sites": ["/api/sites/1", "/api/sites/3"]
+}
+```
+
+Le champ `sites` est optionnel : si absent, la collection n'est pas touchee (comportement PATCH standard). Si present, il remplace integralement la collection `$user->sites`.
+
+### Garde "currentSite coherent"
+
+Apres application des champs par le persist processor decore, `UserRbacProcessor` execute un controle final :
+
+```php
+$currentSite = $data->getCurrentSite();
+if ($currentSite !== null && !$data->hasSite($currentSite)) {
+    $data->setCurrentSite(null);
+}
+```
+
+Justification : si un admin retire un site qui etait le `currentSite` de la cible, le modele serait incoherent (currentSite pointant vers un site non autorise). Le processor corrige automatiquement.
+
+**Variante rejetee** : basculer vers "le premier site restant" plutot que `null`. Rejetee car :
+- "Premier restant" n'a pas de semantique metier claire (ordre de la collection non garanti strict).
+- `null` est une valeur deja supportee (user sans site courant) et explicite : le front du ticket 3 devra gerer ce cas de toute facon.
+
+### Ordre d'execution dans le processor
+
+1. Gardes auto-suicide admin + dernier admin global (code existant, inchange).
+2. `$this->persistProcessor->process($data, ...)` — applique tous les champs (roles, permissions directes, **sites**).
+3. Post-persist : controle coherence currentSite (code ajoute par ce ticket), flush si changement.
+4. Retour du user.
+
+## 9. Fixtures — évolution de `AppFixtures`
+
+`AppFixtures` devient dependant de `SitesFixtures` (inversion du "pas de dependance dure" declare au ticket 1 — justifie par le passage fonctionnel a la relation User ↔ Site). 
+
+```php
+class AppFixtures extends Fixture implements DependentFixtureInterface
+{
+    public function getDependencies(): array
+    {
+        return [SitesFixtures::class];
+    }
+    // ...
+}
+```
+
+Dans `load()`, apres la creation des users et avant le `flush` final :
+
+```php
+$chatellerault = $this->siteRepository->findByName('Chatellerault');
+$saintJean = $this->siteRepository->findByName('Saint-Jean');
+$pommevic = $this->siteRepository->findByName('Pommevic');
+
+$admin->addSite($chatellerault);
+$admin->addSite($saintJean);
+$admin->addSite($pommevic);
+$admin->setCurrentSite($chatellerault);
+
+$alice->addSite($chatellerault);
+$alice->setCurrentSite($chatellerault);
+
+$bob->addSite($saintJean);
+$bob->setCurrentSite($saintJean);
+```
+
+Le repository `SiteRepositoryInterface` est injecte dans le constructeur.
+
+**Regle** : les 3 sites sont deja en base au moment ou `AppFixtures::load()` s'execute grace a `getDependencies()`. Si `findByName` retourne `null`, c'est une misconfiguration qui doit faire echouer fort (assertion via `\assert`).
+
+## 10. Frontend — Page `/admin/sites`
+
+### Structure
+
+```
+frontend/modules/sites/
+├── nuxt.config.ts                 # marker layer Nuxt (vide)
+├── pages/
+│   └── admin/
+│       └── sites.vue              # page listing
+└── components/
+    ├── SiteDrawer.vue             # creation/edition
+    └── SiteDeleteModal.vue        # confirmation suppression
+```
+
+### `pages/admin/sites.vue` — pattern
+
+Aligne sur `frontend/modules/core/pages/admin/roles.vue` :
+- En-tete : titre + bouton `Nouveau site` (visible si `can('sites.manage')`).
+- `MalioDataTable` : colonnes `name`, `city`, `postalCode`, `color` (slot custom pour la puce), `fullAddress` (tronque).
+- Row click → ouvre `SiteDrawer` en mode edition si `can('sites.manage')`, sinon pas de clic (row-clickable guard).
+- `SiteDrawer` emet `saved` → reload de la liste, et `delete` → ouvre `SiteDeleteModal`.
+- `SiteDeleteModal` → DELETE `/api/sites/{id}` + reload.
+
+### `components/SiteDrawer.vue`
+
+Formulaire a 5 champs + preview de la couleur. Pattern `RoleDrawer.vue` :
+- `MalioInputText` pour `name`, `city`, `postalCode`.
+- `MalioInputText` pour `color` avec preview : une puce `<span>` 24×24 arrondie affichant la couleur en temps reel a cote du champ. Valider localement via regex avant submit (ne pas envoyer un hex invalide au backend).
+- `MalioInputTextArea` pour `fullAddress`.
+- Bouton save (variant primary), bouton delete (variant danger, visible uniquement en mode edition, **aucune garde system comme pour les roles** — tous les sites sont supprimables), bouton cancel (variant tertiary).
+
+### `components/SiteDeleteModal.vue`
+
+Pattern `RoleDeleteModal.vue` :
+- Modal avec message "Supprimer le site {name} ? Cette action est irreversible et retirera ce site a tous les utilisateurs rattaches."
+- Bouton cancel (secondary) + bouton delete (danger avec icone poubelle).
+- Emet `confirm` au clic delete.
+
+### Extension de `UserRbacDrawer.vue`
+
+Ajout d'une nouvelle section entre "Permissions directes" et "Resume des permissions effectives" :
+
+```vue
+<!-- Section Sites autorises -->
+<div>
+    <h4 class="mb-3 text-sm font-semibold text-neutral-700">
+        {{ t('admin.users.drawer.sitesSection') }}
+    </h4>
+    <div class="flex flex-col gap-2">
+        <MalioCheckbox
+            v-for="site in allSites"
+            :key="site.id"
+            :id="`site-${site.id}`"
+            :label="site.name"
+            :model-value="selectedSiteIds.has(site.id)"
+            label-class="text-sm text-neutral-600"
+            @update:model-value="(val: boolean) => toggleSite(site.id, val)"
+        />
+    </div>
+</div>
+```
+
+Chargement : ajout a `loadData()` d'un `api.get<{ member: Site[] }>('/sites', { itemsPerPage: 999 }, { toast: false })`.
+
+Le `PATCH /api/users/{id}/rbac` envoie desormais `sites: Array.from(selectedSiteIds).map(id => `/api/sites/${id}`)`.
+
+### Types TypeScript
+
+`frontend/shared/types/sites.ts` :
+
+```ts
+export interface Site {
+    id: number
+    name: string
+    city: string
+    postalCode: string
+    color: string
+    fullAddress: string
+}
+
+export interface SiteInput {
+    name: string
+    city: string
+    postalCode: string
+    color: string
+    fullAddress: string
+}
+```
+
+`frontend/shared/types/rbac.ts` : ajouter `sites: string[]` (IRIs) dans `UserListItem`.
+
+`frontend/shared/types/` (fichier utilisateur courant, probablement `user.ts` ou expose dans l'auth store) : ajouter `sites: Site[]` et `currentSite: Site | null` sur le type expose via `/api/me`.
+
+### Sidebar
+
+Entree ajoutee dans `config/sidebar.php` (cf. section 4). Le `SidebarProvider` filtre deja par `module` actif et par `permission`, aucune modification backend nouvelle.
+
+i18n :
+```json
+"sidebar": {
+    "core": {
+        "sites": "Sites"
+    }
+}
+```
+
+## 11. Plan de tests PHPUnit
+
+### `SiteApiTest` — CRUD `/api/sites`
+
+1. `testAdminCanListSites` : admin → 200, 3 sites.
+2. `testUserWithSitesViewCanListSites` : user avec `sites.view` → 200.
+3. `testUserWithoutPermissionGetsForbidden` : user sans `sites.view` → 403.
+4. `testAdminCanCreateSite` : POST → 201, site present en base.
+5. `testAdminCanPatchSite` : PATCH `color` → 200.
+6. `testAdminCanDeleteSite` : DELETE → 204, site absent en base.
+7. `testUserWithViewButNotManageCannotDelete` : user avec `sites.view` mais pas `sites.manage` → 403 sur DELETE.
+8. `testCreateSiteWithDuplicateNameReturns422` : collision `uniq_site_name` → 422 avec message UniqueEntity.
+9. `testCreateSiteWithInvalidColorReturns422` : validation regex → 422.
+
+### `CurrentSiteSwitchApiTest` — PATCH `/me/current-site`
+
+1. `testUserCanSwitchToAuthorizedSite` : alice a `Chatellerault` dans ses sites → PATCH OK, 200, `currentSite.name == 'Chatellerault'`.
+2. `testUserCannotSwitchToUnauthorizedSite` : alice n'a pas `Pommevic` dans ses sites → PATCH → 403, pas de modification en base.
+3. `testSwitchWithMissingSiteFieldReturns400` : body `{}` → 400.
+4. `testSwitchWithInvalidIriReturns400` : body `{"site": "/api/sites/99999"}` (site inexistant) → 400 ou 404 (selon API Platform).
+5. `testAnonymousUserCannotSwitch` : client non authentifie → 401.
+
+### `MeEndpointSitesTest` — extension `/api/me`
+
+1. `testMeExposesSitesAsObjects` : alice → `sites[0]` est un objet avec `id`, `name`, `city`, ... (pas une string IRI).
+2. `testMeExposesCurrentSiteAsObject` : alice → `currentSite` est un objet, pas `null`.
+3. `testUserWithoutSitesHasEmptyArrayAndNullCurrent` : creer un user jetable sans sites → `sites: []`, `currentSite: null`.
+
+### `SiteCascadeTest` — cascade DB a la suppression
+
+1. `testDeletingSitePurgesUserSiteRows` : supprimer `Chatellerault` → les users qui l'avaient dans `sites` ne l'ont plus.
+2. `testDeletingSiteSetsCurrentSiteToNullOnReferencingUsers` : alice.currentSite = `Chatellerault`, supprimer `Chatellerault` → alice.currentSite = `null`.
+
+### `UserRbacSitesApiTest` — extension `/rbac`
+
+1. `testAdminCanAssignSitesToUser` : PATCH `/users/{alice}/rbac` avec `sites: ["/api/sites/2"]` → alice a desormais 1 site (`Saint-Jean`), plus `Chatellerault`.
+2. `testRemovingCurrentSiteResetsCurrentSiteToNull` : alice.currentSite = `Chatellerault`, PATCH avec `sites: []` → alice.currentSite = `null`.
+3. `testEmptySitesPayloadReplacesCollection` : alice avait 1 site, PATCH avec `sites: []` → 0 site.
+4. `testSitesPayloadWithDuplicateIrisIsAccepted` : PATCH avec `sites: ["/api/sites/1", "/api/sites/1"]` → 1 seul site (dedoublonnage via `ArrayCollection::contains`).
+
+### Tests fixtures (sanity check)
+
+Dans `AbstractApiTestCase` ou dans un test dedie `FixturesIntegrityTest` : verifier apres `make test-db-setup` que les 3 users fixtures ont bien leurs sites attendus. Evite qu'un renommage dans la fixture passe inapercu.
+
+## 12. Risques et points d'attention
+
+### Risque 1 — Couplage Core → Sites au niveau code PHP
+
+L'ajout de `use App\Module\Sites\Domain\Entity\Site;` dans `User.php` introduit une dependance directe du module Core vers le module Sites. Consequence :
+
+- **Desactiver `SitesModule::class` dans `config/modules.php` n'empeche pas Doctrine de charger le mapping `Site` ni `User`**, grace au caractere inconditionnel des mappings declares dans `doctrine.yaml` (choix assume ticket 1).
+- En revanche, la contrainte forte introduite ici est que **la table `site` doit exister** pour que la table `user` puisse etre creee (FK `user.current_site_id → site.id`). Si la migration Sites (ticket 1) n'a pas ete jouee, la migration de ce ticket echouera.
+- Conclusion : Sites n'est plus "optionnel au sens strict" apres ce ticket. Le declarer `REQUIRED = false` dans `SitesModule` reste vrai du point de vue de l'activation fonctionnelle (exposer les permissions et la sidebar), mais faux du point de vue DB. **A documenter explicitement dans le docblock de `SitesModule::REQUIRED`** au moment de ce ticket.
+
+### Risque 2 — Cascade DB vs regle applicative
+
+La cascade `user_site` → `ON DELETE CASCADE` gere la suppression d'un site, mais **n'est pas triggered** quand on retire un site d'un user (DELETE d'une ligne `user_site` uniquement). Dans ce cas, `user.current_site_id` peut rester pointe vers un site que l'user n'a plus — etat incoherent qui serait masque au niveau DB mais visible a l'usage.
+
+La correction vit dans `UserRbacProcessor` (cf. section 8). Si un autre chemin applicatif modifie `user.sites` sans passer par ce processor (ex: une commande console custom), il devra dupliquer cette garde. **Point d'attention a consigner dans le docblock de `User::addSite()` / `User::removeSite()`** : "apres modification, verifier la coherence de `currentSite`".
+
+### Risque 3 — Ressource virtuelle et routing API Platform
+
+Le choix d'une ressource virtuelle `CurrentSite` avec `uriTemplate: '/me/current-site'` est fragile : si un futur ticket introduit une autre operation sur une URI qui commence par `/me/`, il faut verifier que le routing API Platform n'entre pas en conflit. Le pattern `priority: 1` (cf. `CLAUDE.md` section Backend) est recommande par prevention sur l'operation Patch. A valider par un test fonctionnel qui appelle explicitement `/api/me` (GET) et `/api/me/current-site` (PATCH) dans le meme scenario.
+
+### Risque 4 — EAGER loading et payload `/api/me`
+
+`User` a deja 3 collections EAGER (`$rbacRoles`, `$directPermissions`, plus les `permissions` de chaque role). Ajouter `$sites` (EAGER M2M) et `$currentSite` (EAGER M2O) augmente la taille du payload `/api/me` et le nombre de requetes SQL a chaque auth.
+
+Mesure : apres implementation, verifier via le profiler Symfony que le nombre de requetes SQL sur `/api/me` reste raisonnable (≤ 6-8). Si >10, envisager une projection custom (cf. ticket 343 discussion `findForSecurity`). Pas bloquant dans ce ticket, mais a reverifier.
+
+### Risque 5 — Tests fixtures-dependents
+
+Les tests API existants (`UserApiTest`, `RoleApiTest`) s'appuient sur les users fixtures. L'evolution de `AppFixtures` (ajout de sites aux 3 users) modifie l'etat initial de la DB de test. Verifier que les tests existants continuent de passer (chaines d'assertions du type "user a 1 role" ne doivent pas casser). En particulier :
+- Les tests qui comptent les lignes d'une collection `member[]` sur `/api/users` peuvent voir le payload grossir (sites et currentSite ajoutes).
+- Les tests qui assertent sur la forme stricte d'un user (snapshot-like) devront etre adapter.
+
+### Risque 6 — Serialisation infinie User ↔ Site
+
+`User::$sites` expose `Site` en `me:read`. `Site::$users` est la collection inverse. Si un jour `Site::$users` recevait le groupe `me:read`, la serialisation entrerait dans une boucle infinie (User → sites → users → sites → ...). **Garde** : `Site::$users` ne doit **jamais** porter de `#[Groups]`. A verifier par un test qui serialise `/api/me` et asserte qu'aucun `Site` renvoye ne contient de cle `users`.
+
+### Risque 7 — Pas de recours si l'utilisateur se retire tous ses sites
+
+Le ticket autorise un user sans sites (`sites: []`, `currentSite: null`). Mais aucune garde ne l'empeche de se retirer tous ses sites via `/api/users/{mon_id}/rbac` si il porte `sites.manage`. Consequence : l'user se retrouve bloque sur l'app si le ticket 3 rend un site actif obligatoire pour naviguer. Compromis assume pour ce ticket : on ne bloque pas l'auto-retrait (coherence avec le pattern du ticket RBAC — l'auto-retrait admin est bloque, mais pas le reste). **A reevaluer au ticket 3** si le selecteur de navbar devient bloquant.
+
+## 13. Ordre d'exécution recommandé
+
+1. **Schema backend** — modifier `User.php` (ajout `$sites`, `$currentSite`, `$users` inverse sur `Site`). Ajouter attributs `ApiResource` sur `Site`.
+2. **Configuration** — aucun changement requis a `doctrine.yaml` ni `services.yaml` ni `modules.php`.
+3. **Migration** — ecrire `Version<timestamp2>.php` racine. Jouer `make migration-migrate`.
+4. **Fixtures** — modifier `AppFixtures` pour dependre de `SitesFixtures` et rattacher les users. Jouer `make fixtures && make sync-permissions`.
+5. **Endpoint CRUD sites** — verifier via `curl`/Postman que `GET /api/sites`, `POST /api/sites` etc. repondent avec les bonnes protections RBAC.
+6. **Endpoint switch** — creer `CurrentSiteResource`, `CurrentSiteProcessor`, `SiteNotAuthorizedException`, `SiteNotAuthorizedExceptionListener`. Tester via `curl`.
+7. **Extension MeProvider** — tester via `curl /api/me` que `sites` et `currentSite` apparaissent comme objets. Aucun code a changer dans `MeProvider` lui-meme, le travail est 100% fait via les groupes.
+8. **Extension UserRbacProcessor** — ajouter le champ `sites` et la garde `currentSite`. Tests d'integration.
+9. **Tests API** — ecrire et faire passer les 5 suites de tests decrites section 11.
+10. **Sidebar** — ajouter l'entree dans `config/sidebar.php` + cle i18n.
+11. **Frontend — types** — creer `shared/types/sites.ts`, etendre `shared/types/rbac.ts` et les types user.
+12. **Frontend — page admin** — creer `modules/sites/nuxt.config.ts`, `pages/admin/sites.vue`, `SiteDrawer.vue`, `SiteDeleteModal.vue`.
+13. **Frontend — extension UserRbacDrawer** — ajouter la section sites.
+14. **Frontend — i18n** — completer `fr.json`.
+15. **Validation end-to-end** — clique-droit sur chaque scenario UX : creer un site, l'editer, le supprimer, assigner sites a un user, switcher le site courant de l'user authentifie.
+16. **Tests front (si Vitest du ticket)** — smoke test du rendu de `/admin/sites`.
+17. **CS fixer** — `make php-cs-fixer-allow-risky` sur tous les fichiers touches.
+18. **DoD** — valider les 10 criteres section 14.
+
+## 14. Critères d'acceptation (DoD)
+
+- [ ] `GET /api/sites`, `GET /api/sites/{id}` retournent 200 pour un user avec `sites.view`, 403 sinon.
+- [ ] `POST /api/sites`, `PATCH /api/sites/{id}`, `DELETE /api/sites/{id}` retournent le code attendu pour un user avec `sites.manage`, 403 sinon.
+- [ ] `GET /api/me` retourne `sites: Site[]` (objets complets) et `currentSite: Site | null`, avec les 3 sites pour `admin`, 1 pour `alice`, 1 pour `bob`.
+- [ ] `PATCH /api/me/current-site` avec un site autorise → 200, `currentSite` mis a jour. Avec un site non autorise → 403.
+- [ ] `DELETE /api/sites/{id}` cascade correctement : les lignes `user_site` sont purgees, les `current_site_id` pointant dessus repassent a `NULL`.
+- [ ] `PATCH /api/users/{id}/rbac` accepte le champ `sites` ; retirer le `currentSite` de la liste le bascule a `null`.
+- [ ] Page `/admin/sites` : liste, creation, edition, suppression fonctionnelles.
+- [ ] `UserRbacDrawer.vue` : section "Sites autorises" visible et fonctionnelle.
+- [ ] Sidebar : entree "Sites" visible pour un user avec `sites.view`, masquee sinon. Disparait si `SitesModule::class` est retire de `config/modules.php`.
+- [ ] `make test` passe toutes les suites (les 5 nouvelles + les existantes ajustees aux fixtures).
+- [ ] `make php-cs-fixer-allow-risky` propre sur les fichiers nouveaux et modifies.
+- [ ] Desactiver `SitesModule::class` dans `config/modules.php` ne casse pas les endpoints Core (la DB reste valide, les users conservent leurs sites meme si l'UI ne les expose plus).
+
+## 10. Evolutions post-livraison — drawer RBAC et defense in depth
+
+Apres la livraison initiale du ticket, un bug utilisateur a revele que le drawer
+`UserRbacDrawer.vue` demarrait toujours avec 0 site coche pour un user qui en
+avait en BDD, et que la sauvegarde ecrasait silencieusement les sites
+existants. Root cause : l'endpoint `GET /api/users` utilise le groupe `user:list`
+qui n'expose pas la collection `sites` (choix assume pour garder le payload
+leger et eviter toute fuite croisee site). Le drawer initialisait donc
+`selectedSiteIds` a partir d'un `user.sites` toujours `undefined`.
+
+Deux evolutions ont ete apportees pour corriger cela proprement sans elargir la
+surface de fuite de `/api/users` :
+
+### 10.1 — Nouvelle operation `GET /users/{id}/rbac`
+
+Une operation API Platform `Get` est ajoutee sur `User`, symetrique au `Patch`
+existant, sous la meme URI `/users/{id}/rbac` :
+
+```php
+new Get(
+    name: 'user_rbac_get',
+    uriTemplate: '/users/{id}/rbac',
+    security: "is_granted('core.users.manage')",
+    normalizationContext: ['groups' => ['user:rbac:read']],
+),
+```
+
+Raisons du design :
+- **Symetrie REST** : GET et PATCH partagent la meme URI et le meme groupe de
+  normalisation, documentation OpenAPI et appels clients lisibles.
+- **Separation list/detail** : `/api/users` (`user:list`) reste maigre — pas de
+  collection, pas de fuite. `/users/{id}/rbac` (`user:rbac:read`) porte le
+  detail riche requis par le drawer d'edition.
+- **Garde de permission plus stricte** : `core.users.manage` (et non `.view`)
+  — le detail RBAC est concu pour l'edition, pas la consultation.
+- **Isolation du couplage Sites** : la dependance au module Sites reste scopee
+  a cet endpoint et a `/api/me`. Elle n'est pas disseminee dans tous les
+  payloads de liste.
+
+Cote frontend (`UserRbacDrawer.vue`) :
+- `loadData(userId)` fetch desormais `/users/{id}/rbac` en parallele des
+  referentiels (roles, permissions, sites globaux).
+- Le watch combine `[modelValue, user.id]` recharge le detail a chaque
+  ouverture ou changement de user sans dependance fragile sur `props.user`.
+- Le type `UserListItem` perd `sites` (inutilise) ; un nouveau type
+  `UserRbacDetail` represente le payload du GET dedie.
+- La colonne "Sites" de `/admin/users` est retiree : l'info est consultee
+  dans le drawer. Cela supprime aussi le second fetch `/api/sites` sur la
+  page de liste.
+
+### 10.2 — Garde anti-ecrasement dans `UserRbacProcessor`
+
+API Platform denormalize les collections ManyToMany comme des `ArrayCollection`
+vides quand la cle JSON correspondante est absente du payload, violant la
+semantique `merge-patch+json` qui impose que les cles absentes ne mutent PAS
+les proprietes. Pour un PATCH qui ne veut toucher que `isAdmin`, cela
+detruirait tous les sites/roles/directPermissions du user.
+
+Le processor injecte desormais `RequestStack`, lit le body JSON brut au debut
+de `process()`, et pour chaque collection absente du payload restaure l'etat
+d'origine a partir du snapshot Doctrine :
+
+```php
+// Mapping cle JSON → accesseurs PHP (note : 'roles' → getRbacRoles)
+private const COLLECTION_MAP = [
+    'roles'             => ['getter' => 'getRbacRoles', ...],
+    'directPermissions' => ['getter' => 'getDirectPermissions', ...],
+    'sites'             => ['getter' => 'getSites', ...],
+];
+
+private function restoreAbsentCollections(User $user): void
+{
+    $payload = json_decode($this->requestStack->getCurrentRequest()?->getContent() ?? '', true);
+    foreach (self::COLLECTION_MAP as $jsonKey => $accessors) {
+        if (array_key_exists($jsonKey, $payload)) {
+            continue; // cle presente = la denormalisation fait foi
+        }
+        // cle absente = restaurer le snapshot PersistentCollection
+        // (voir implementation complete dans UserRbacProcessor.php)
+    }
+}
+```
+
+Semantique finale garantie :
+
+| Payload                         | Effet sur la collection            |
+|---------------------------------|------------------------------------|
+| Cle absente                     | Preservee (etat BDD inchange)      |
+| `"sites": []`                   | Collection videe explicitement     |
+| `"sites": ["/api/sites/1"]`     | Collection remplacee               |
+
+La garde `ensureCurrentSiteConsistency` continue de s'executer apres persist
+avec la meme logique : elle est triggered uniquement si la collection a
+effectivement mute (detection via `PersistentCollection::isDirty()` post-restore).
+
+### 10.3 — Criteres de validation additionnels
+
+- [ ] `GET /users/{id}/rbac` retourne 200 pour `core.users.manage`, 403 sinon.
+- [ ] Le payload contient `{ id, isAdmin, roles, directPermissions, sites }`.
+- [ ] `GET /api/users` ne contient plus `sites` (verification non-regression).
+- [ ] Ouvrir le drawer d'un user avec des sites en BDD affiche les cases
+      pre-cochees correspondantes.
+- [ ] `PATCH /users/{id}/rbac` avec `{ "isAdmin": true }` (sans autre cle) ne
+      modifie pas sites/roles/directPermissions.
+- [ ] `PATCH /users/{id}/rbac` avec `{ "sites": [] }` vide explicitement la
+      collection et bascule `currentSite` a `NULL` via la garde existante.
+- [ ] `PATCH /users/{id}/rbac` avec `{ "sites": [...] }` remplace la
+      collection comme auparavant.

docs/sites/ticket-03-spec.md

@@ -0,0 +1,542 @@
+# Ticket #03 — 3/4 — Barre de sélection de site (navbar horizontale)
+
+## 0. Pivots post-implémentation (2026-04-20)
+
+Écarts assumés entre la spec initiale (écrite avant exploration de la lib) et
+le code livré après implémentation et test visuel. À lire en premier pour
+comprendre les divergences lors de la relecture.
+
+1. **Contraste texte auto supprimé, texte blanc forcé conforme Figma.**
+   La spec (sections 5, 6, 10) prévoyait un calcul de luminance WCAG pour
+   décider entre texte noir et blanc sur chaque tile. Après test visuel, le
+   choix design retenu est d'imposer **texte blanc partout** (default Malio
+   `text-white font-bold uppercase tracking-wide`). Conséquence : charge à
+   l'admin de choisir des couleurs de site suffisamment foncées pour que le
+   blanc reste lisible. Les utilitaires `parseHex`, `getRelativeLuminance`,
+   `getReadableTextColor` ont été supprimés comme code mort. Seul
+   `isValidSiteColor(hex)` reste dans `shared/utils/color.ts` (consommé par
+   `SiteDrawer`).
+
+2. **Taille texte explicite `text-2xl` (24 px) appliquée via `labelClass`.**
+   Malio applique `font-bold uppercase tracking-wide` sans taille explicite.
+   Le wrapper `SiteSelector.vue` passe `labelClass="text-2xl"` pour garantir
+   les 24 px de la maquette Figma.
+
+3. **A11y : `ariaGroupLabel` au niveau radiogroup** au lieu de
+   `ariaLabelActive` / `ariaLabelInactive` par tile. La raison : Malio rend
+   déjà un `role="radio"` avec `aria-checked` par tile — le lecteur d'écran
+   annonce "bouton radio coché/non coché" + le nom visible. Ajouter un
+   `aria-label` par tile aurait dupliqué l'info et alourdi sans bénéfice.
+   Le seul ajout nécessaire était un label au groupe, fait via
+   `:aria-label="t('sites.selector.ariaGroupLabel')"` sur `MalioSiteSelector`.
+
+4. **Auto-détection composables des layers dans `nuxt.config.ts`.**
+   Pas prévu dans la spec. Ajouté car `imports.dirs` explicite override les
+   auto-imports par défaut de Nuxt pour les composables de layer. Sans ça,
+   `useCurrentSite` n'est pas résolu par Nuxt. Scan dynamique aligné sur le
+   pattern `moduleLayers` existant.
+
+5. **Couleurs fixtures finales :** `#056CF2` (Châtellerault), `#F3CB00`
+   (Saint-Jean), `#74BF04` (Pommevic). Choix client post-maquette.
+
+## 1. Objectif
+
+Ce ticket livre l'UI de consommation du module Sites pour l'utilisateur final : une barre horizontale en haut de l'application qui liste les sites autorises de l'utilisateur connecte, met en avant le site courant et permet de basculer d'un site a l'autre en un clic.
+
+Le ticket consomme la donnee posee par le ticket 2 (`/api/me` expose `sites` et `currentSite`, `PATCH /api/me/current-site` permet le switch) et s'appuie sur un nouveau composant `MalioSiteSelector` fourni par la version a jour de `@malio/layer-ui`.
+
+Resultat attendu : apres merge, un user avec ≥ 1 site voit une barre sous la navbar horizontale ; un clic sur un site non actif le rend actif, change l'etat global, et est persiste cote serveur.
+
+## 2. Périmètre
+
+### IN
+
+- **Upgrade** de `@malio/layer-ui` (actuellement `^1.3.0`) vers la version contenant `MalioSiteSelector`. La signature exacte du composant (props, slots, events) doit etre lue dans `node_modules/@malio/layer-ui/COMPONENTS.md` apres installation — la spec decrit le contrat attendu, le developpeur adapte selon l'API reelle (cf. Risque 1).
+- Ajouter les champs `sites: Site[]` et `currentSite: Site | null` dans le type `UserData` (`frontend/shared/types/user-data.ts`) pour refleter le payload `/api/me` enrichi au ticket 2.
+- Ajouter le type partage `Site` dans `frontend/shared/types/sites.ts` (deja cree au ticket 2, sinon a creer).
+- Creer le composable `useCurrentSite()` dans `frontend/modules/sites/composables/` qui expose `currentSite`, `availableSites`, `switchSite(site)`, `resetCurrentSite()`. Pattern aligne sur `useSidebar()`.
+- Creer le composable `useModules()` dans `frontend/shared/composables/` qui consomme `/api/modules` et expose `isModuleActive(id: string)`. Necessaire car `isModuleActive` est requis par le ticket mais n'existe pas encore cote front.
+- Creer `SiteSelector.vue` dans `frontend/modules/sites/components/` : wrapper fin autour de `MalioSiteSelector` qui branche le composable `useCurrentSite()`, gere l'optimistic update avec rollback, emet un toast de succes/erreur.
+- Integrer le selecteur dans `frontend/app/layouts/default.vue` — render conditionnel sur `isModuleActive('sites') && user.sites.length > 0`.
+- Appeler `resetCurrentSite()` au logout (`frontend/modules/core/pages/logout.vue`), aligne sur `resetSidebar()` deja present.
+- Gestion du **contraste automatique** : le texte du bloc passe en noir ou en blanc selon la luminance de `site.color`. Fonction utilitaire `getReadableTextColor(hex: string): 'black' | 'white'` dans `frontend/shared/utils/color.ts` (nouveau fichier utilitaire partage).
+- Accessibilite : chaque bloc est un `<button>` natif avec `aria-pressed` sur le site courant, focus visible (ring Tailwind), navigation clavier Tab + Enter fonctionnelle.
+- Responsive minimal : `flex-1` sur chaque bloc avec `min-w-[200px]` et `overflow-x-auto` sur le conteneur pour les cas 4+ sites sur petits ecrans.
+- Tests Vitest : unite sur `useCurrentSite` (switch, rollback, reset), unite sur `getReadableTextColor`, smoke test sur `SiteSelector.vue` (rendu, emission du PATCH, rollback en cas d'echec).
+
+### OUT
+
+- Ticket `#04` : filtrage metier par site (ex: bloquer l'acces aux ressources Commercial si l'user n'est pas rattache au site cible). Le site courant est simplement un **contexte UX** dans ce ticket, aucune regle d'autorisation ne s'appuie encore dessus.
+- Modification du layout `auth.vue` (login) : le selecteur n'est **jamais** rendu hors session authentifiee. Le layout login reste inchange.
+- Persistance du site actif cote front (localStorage, cookies) : le backend est source de verite, le front ne cache pas independamment.
+- Gestion d'une image / d'un logo par site : les sites sont identifies par nom + couleur uniquement dans ce ticket.
+- Pre-mount du selecteur sans `/api/me` complet : le middleware `auth.global.ts` garantit deja que `auth.user` est resolu avant le rendu — pas besoin de gerer un etat "chargement" specifique dans le selecteur.
+- Validation cote back d'une couleur "trop claire" : non introduite. Le ticket 2 accepte `#FFFFFF`. La compensation est faite cote front via le calcul de contraste ; une contrainte back arrivera si un abus se materialise.
+
+## 3. Fichiers à créer
+
+### Frontend — Module Sites (layer deja cree au ticket 2)
+
+- `/home/m-tristan/workspace/Coltura/frontend/modules/sites/components/SiteSelector.vue` : wrapper Vue autour de `MalioSiteSelector`. Branche `useCurrentSite()`, gere l'optimistic update et les toasts.
+- `/home/m-tristan/workspace/Coltura/frontend/modules/sites/composables/useCurrentSite.ts` : composable global exposant l'etat `currentSite` / `availableSites`, les actions `switchSite`, `resetCurrentSite`, et un flag `switching: Ref<boolean>` pour desactiver le selecteur pendant une requete en vol.
+
+### Frontend — Shared
+
+- `/home/m-tristan/workspace/Coltura/frontend/shared/composables/useModules.ts` : composable qui charge `/api/modules` et expose `isModuleActive(id: string): boolean`. Pattern aligne sur `useSidebar()` : ref singleton au niveau module, chargement idempotent, `resetModules()` expose pour le logout.
+- `/home/m-tristan/workspace/Coltura/frontend/shared/utils/color.ts` : fonctions utilitaires de couleur, au minimum :
+  - `parseHex(hex: string): { r: number; g: number; b: number }` — tolere la casse, rejette les formats hors `#RRGGBB`.
+  - `getRelativeLuminance({r, g, b}): number` — formule WCAG standard.
+  - `getReadableTextColor(hex: string): 'black' | 'white'` — renvoie `'black'` si la luminance > 0.5, `'white'` sinon. Seuil simple, suffisant pour un CRM interne (pas WCAG AAA).
+
+### Frontend — Tests
+
+- `/home/m-tristan/workspace/Coltura/frontend/modules/sites/composables/__tests__/useCurrentSite.spec.ts` : Vitest. Tests :
+  - `switchSite` met a jour l'etat localement avant la requete (optimistic).
+  - Si la requete reussit, l'etat reste aligne.
+  - Si la requete echoue, l'etat rollback a l'ancien `currentSite`.
+  - `resetCurrentSite` vide l'etat.
+- `/home/m-tristan/workspace/Coltura/frontend/shared/composables/__tests__/useModules.spec.ts` : Vitest. Tests `isModuleActive` apres chargement, `resetModules` vide l'etat.
+- `/home/m-tristan/workspace/Coltura/frontend/shared/utils/__tests__/color.spec.ts` : Vitest. Jeu de donnees sur `getReadableTextColor` : `#000000` → white, `#FFFFFF` → black, `#056CF2` (bleu Coltura) → white, `#F59E0B` (ambre) → black, `#10B981` (vert) → black ou white selon seuil (a verifier). Tester aussi le rejet de formats invalides.
+- `/home/m-tristan/workspace/Coltura/frontend/modules/sites/components/__tests__/SiteSelector.spec.ts` : smoke test Vitest.
+
+## 4. Fichiers à modifier
+
+- `/home/m-tristan/workspace/Coltura/frontend/package.json` : upgrade `@malio/layer-ui` vers la version qui inclut `MalioSiteSelector`. Commit du `package-lock.json` dans le meme changeset.
+- `/home/m-tristan/workspace/Coltura/frontend/shared/types/user-data.ts` : ajouter les champs
+  ```ts
+  sites: Site[]
+  currentSite: Site | null
+  ```
+  Import du type `Site` depuis `./sites`. Note : si le type `Site` a deja ete introduit au ticket 2, reutiliser ; sinon, ce ticket le cree dans `frontend/shared/types/sites.ts`.
+- `/home/m-tristan/workspace/Coltura/frontend/shared/types/sites.ts` : si absent, creer avec l'interface `Site` (cf. section Schema ticket 2 pour la forme). Si present, aucune modification.
+- `/home/m-tristan/workspace/Coltura/frontend/app/layouts/default.vue` : integrer `SiteSelector` sous le header, avant `<main>`, dans le flex column. Rendu conditionnel via `v-if="showSiteSelector"` ou via un `defineAsyncComponent` chargement lazy si on veut eviter l'import statique quand le module est off.
+- `/home/m-tristan/workspace/Coltura/frontend/app/middleware/auth.global.ts` : ajouter le chargement de `useModules().loadModules()` apres `loadSidebar()`. Necessaire pour que `isModuleActive` soit resolu quand le layout se rend.
+- `/home/m-tristan/workspace/Coltura/frontend/modules/core/pages/logout.vue` : appeler `useCurrentSite().resetCurrentSite()` et `useModules().resetModules()` apres le `auth.logout()`, aligne sur le pattern `resetSidebar()` deja present.
+- `/home/m-tristan/workspace/Coltura/frontend/i18n/locales/fr.json` : ajouter les cles
+  ```json
+  "sites": {
+      "selector": {
+          "switchSuccess": "Site courant change",
+          "switchError": "Impossible de changer de site",
+          "ariaLabelActive": "Site actif : {name}",
+          "ariaLabelInactive": "Basculer sur le site {name}"
+      }
+  }
+  ```
+  Ne **pas** mettre le nom du site en cle i18n : le nom est une donnee metier, pas un label.
+
+## 5. Schéma cible — Composant `SiteSelector.vue`
+
+### Render attendu (conforme Figma)
+
+- Hauteur fixe : `h-[72px]`.
+- `width: 100%` (parent du `<main>` dans `layouts/default.vue`, donc occupe toute la zone a droite de la sidebar).
+- Flex horizontal, chaque bloc = `flex-1` avec `min-w-[200px]`.
+- Conteneur parent : `overflow-x-auto` pour scroll horizontal si 4+ sites sur ecran etroit.
+- Fond de chaque bloc : `site.color` (inline style car dynamique).
+- Texte : centre horizontalement et verticalement, `font-inter font-bold text-[24px] uppercase tracking-wide`, couleur calculee par `getReadableTextColor(site.color)`.
+- Opacite : `opacity-100` pour le site courant, `opacity-40` pour les autres.
+- Hover sur les inactifs : `hover:opacity-70 cursor-pointer transition-opacity`.
+- Focus clavier : `focus:ring-2 focus:ring-offset-2 focus:ring-primary-500 focus:outline-none`.
+- Semantique : chaque bloc est un `<button type="button">` (pas `<div>`), avec :
+  - `aria-pressed="true"` sur le site courant.
+  - `aria-label` dynamique via i18n (`sites.selector.ariaLabelActive` ou `ariaLabelInactive`).
+
+### Contrat du wrapper `SiteSelector.vue`
+
+```vue
+<template>
+    <MalioSiteSelector
+        :sites="availableSites"
+        :current-site-id="currentSite?.id"
+        :disabled="switching"
+        @switch="handleSwitch"
+    />
+</template>
+
+<script setup lang="ts">
+const { availableSites, currentSite, switching, switchSite } = useCurrentSite()
+
+async function handleSwitch(siteId: number) {
+    const target = availableSites.value.find(s => s.id === siteId)
+    if (!target) return
+    await switchSite(target)
+}
+</script>
+```
+
+**Hypothese** : la signature exacte de `MalioSiteSelector` (nom du prop, nom de l'event) doit etre verifiee dans `@malio/layer-ui/COMPONENTS.md` apres upgrade. Si elle differe, adapter le wrapper sans toucher au composable. Le wrapper reste le seul point d'adherence a l'API externe.
+
+Si `MalioSiteSelector` **n'embarque pas** le calcul de contraste texte, le wrapper doit le gerer en passant `:text-color` ou en injectant un style calcule. Si le composant delegue la couleur a un slot ou a un formatteur, ajuster l'appel.
+
+### Composable `useCurrentSite()`
+
+```ts
+import type { Site } from '~/shared/types/sites'
+
+const currentSite = ref<Site | null>(null)
+const availableSites = ref<Site[]>([])
+const switching = ref(false)
+
+export function useCurrentSite() {
+    const auth = useAuthStore()
+    const api = useApi()
+    const { t } = useI18n()
+
+    // Hydratation depuis le store auth — single source of truth
+    function syncFromAuth() {
+        availableSites.value = auth.user?.sites ?? []
+        currentSite.value = auth.user?.currentSite ?? null
+    }
+
+    async function switchSite(site: Site) {
+        if (switching.value) return
+        const previous = currentSite.value
+
+        // Optimistic update
+        currentSite.value = site
+        switching.value = true
+
+        try {
+            await api.patch('/me/current-site', { site: `/api/sites/${site.id}` }, {
+                toastSuccessMessage: t('sites.selector.switchSuccess'),
+            })
+            // Propage au store auth pour que tous les consommateurs soient alignes
+            if (auth.user) {
+                auth.user.currentSite = site
+            }
+        } catch (error) {
+            // Rollback
+            currentSite.value = previous
+            throw error // useApi a deja toast l'erreur si toast est active
+        } finally {
+            switching.value = false
+        }
+    }
+
+    function resetCurrentSite() {
+        currentSite.value = null
+        availableSites.value = []
+        switching.value = false
+    }
+
+    return {
+        currentSite,
+        availableSites,
+        switching,
+        switchSite,
+        resetCurrentSite,
+        syncFromAuth,
+    }
+}
+```
+
+**Pattern** : state singleton au niveau module (refs module-level), meme convention que `useSidebar()`. Le singleton est necessaire pour que le logout + les consommateurs multiples partagent le meme etat. `resetCurrentSite()` est appele explicitement au logout (cf. section 4).
+
+**Hydratation** : `syncFromAuth()` est appele au mount de `SiteSelector.vue` (dans un `onMounted` ou un `watch` sur `auth.user`). Alternative : appeler dans `auth.global.ts` apres `ensureSession()`.
+
+### Composable `useModules()`
+
+Pattern strictement aligne sur `useSidebar()` (cf. `frontend/shared/composables/useSidebar.ts`) :
+
+```ts
+const activeModuleIds = ref<string[]>([])
+const loaded = ref(false)
+
+export function useModules() {
+    async function loadModules() {
+        try {
+            const api = useApi()
+            const data = await api.get<{ modules: string[] }>('/modules', {}, { toast: false })
+            activeModuleIds.value = data.modules ?? []
+            loaded.value = true
+        } catch {
+            activeModuleIds.value = []
+            loaded.value = true
+        }
+    }
+
+    function isModuleActive(id: string): boolean {
+        return activeModuleIds.value.includes(id)
+    }
+
+    function resetModules() {
+        activeModuleIds.value = []
+        loaded.value = false
+    }
+
+    return { activeModuleIds, loaded, loadModules, isModuleActive, resetModules }
+}
+```
+
+**Attention** : verifier la forme exacte de la reponse `/api/modules` via `curl /api/modules`. Les specs RBAC anterieurs suggerent `{ modules: string[] }` mais il faut valider.
+
+## 6. Contraste automatique du texte
+
+### Algorithme
+
+Formule de luminance relative WCAG 2.1 (simplifiee) :
+
+```ts
+function getRelativeLuminance({ r, g, b }: RGB): number {
+    const [R, G, B] = [r, g, b].map(c => {
+        const normalized = c / 255
+        return normalized <= 0.03928
+            ? normalized / 12.92
+            : ((normalized + 0.055) / 1.055) ** 2.4
+    })
+    return 0.2126 * R + 0.7152 * G + 0.0722 * B
+}
+
+export function getReadableTextColor(hex: string): 'black' | 'white' {
+    const rgb = parseHex(hex)
+    return getRelativeLuminance(rgb) > 0.5 ? 'black' : 'white'
+}
+```
+
+Le seuil 0.5 est un compromis pragmatique : simple, lisible, pas parfait WCAG AAA mais suffisant pour distinguer blancs/jaunes pales (→ texte noir) des bleus/verts/rouges saturés (→ texte blanc).
+
+### Integration dans le selecteur
+
+Le composable ou le template calcule la couleur pour chaque site une seule fois :
+
+```ts
+const textColorsBySiteId = computed(() => {
+    const map = new Map<number, string>()
+    for (const site of availableSites.value) {
+        map.set(site.id, getReadableTextColor(site.color))
+    }
+    return map
+})
+```
+
+Le template applique `:style="{ color: textColorsBySiteId.get(site.id) }"` sur chaque bloc, ou passe la map au composant `MalioSiteSelector` si son API l'accepte.
+
+### Cas limite — hex invalide
+
+`parseHex` leve une `Error` si le format ne matche pas `#[0-9A-Fa-f]{6}`. Au niveau du selecteur, le template entoure l'acces dans un try/catch logique : si un site a une couleur invalide (improbable car la regex backend du ticket 1 bloque), fallback a texte blanc.
+
+## 7. Intégration dans `layouts/default.vue`
+
+### Structure actuelle
+
+```
+<div class="h-screen overflow-hidden">
+  <div class="flex h-full">
+    <MalioSidebar ... />
+    <div class="h-full flex-1 flex flex-col min-h-0 min-w-0">
+      <main>...</main>
+    </div>
+  </div>
+</div>
+```
+
+### Structure cible
+
+```
+<div class="h-screen overflow-hidden">
+  <div class="flex h-full">
+    <MalioSidebar ... />
+    <div class="h-full flex-1 flex flex-col min-h-0 min-w-0">
+      <SiteSelector v-if="showSiteSelector" />
+      <main>...</main>
+    </div>
+  </div>
+</div>
+```
+
+Script :
+```ts
+const auth = useAuthStore()
+const { isModuleActive } = useModules()
+
+const showSiteSelector = computed(() =>
+    isModuleActive('sites') && (auth.user?.sites?.length ?? 0) > 0,
+)
+```
+
+### Render conditionnel et flash
+
+Le middleware `auth.global.ts` resout deja `auth.user` (via `ensureSession()`) avant le rendu des pages. Le middleware doit en plus declencher `loadModules()` pour que `isModuleActive` soit resolu au premier render. Sans ca, `showSiteSelector` sera `false` pendant un premier paint, puis `true` apres le chargement de `/api/modules` → flash visuel.
+
+**Solution** : dans `auth.global.ts`, appeler `loadModules()` au meme niveau que `loadSidebar()`.
+
+### Import statique vs dynamique
+
+Deux options :
+- **Import statique** (`SiteSelector.vue` est toujours dans le bundle) : simple, le `v-if` gere l'affichage. Impact bundle minimal.
+- **Import dynamique** (`defineAsyncComponent`) : le composant n'est charge que si le module est actif. Plus propre au sens "desactiver Sites = zero code sites dans le bundle", mais le layer Nuxt rend le composant auto-importable → le code est deja dans le bundle de toute facon.
+
+**Recommandation** : import statique. L'economie de bundle est marginale et le layer Nuxt charge deja tout le module.
+
+## 8. i18n
+
+### Clés ajoutées
+
+```json
+{
+    "sites": {
+        "selector": {
+            "switchSuccess": "Site courant change",
+            "switchError": "Impossible de changer de site",
+            "ariaLabelActive": "Site actif : {name}",
+            "ariaLabelInactive": "Basculer sur le site {name}"
+        }
+    }
+}
+```
+
+### Règles
+
+- **Jamais** traduire le nom d'un site (`site.name`). C'est une donnee metier, affichee telle quelle. L'`uppercase` est applique en CSS (`text-transform: uppercase`), pas dans la donnee.
+- Les `aria-label` interpollent `{name}` directement.
+- `switchError` est consomme par le toast d'erreur de `useApi` si la route serveur renvoie un code non-2xx. Pour une erreur 403 "site non autorise" (cf. ticket 2), le serveur renvoie deja un message traduit ou un code i18n stable — a arbitrer au moment de l'implementation selon la decision prise au ticket 2.
+
+## 9. Accessibilité
+
+- Chaque bloc est un `<button type="button">` (pas un `<div>` avec `role="button"` — preferer la semantique native).
+- `aria-pressed="true"` sur le bloc du site courant, `aria-pressed="false"` sur les autres.
+- `aria-label` : l'uppercase CSS est visuel ; l'aria-label garde la casse originale du nom pour le screen reader (`aria-label="Site actif : Chatellerault"`).
+- Focus visible : `focus:ring-2 focus:ring-offset-2 focus:ring-primary-500 focus:outline-none`.
+- Tab : parcourt les blocs de gauche a droite.
+- Enter / Espace : declenche le switch (comportement natif du `<button>`).
+- `tabindex="0"` n'est pas requis sur un `<button>` (deja focusable natif). Ne pas ajouter `tabindex="-1"` sur le bloc courant : l'user doit pouvoir revenir dessus.
+
+## 10. Plan de tests
+
+### Vitest — `useCurrentSite.spec.ts`
+
+1. `switchSite met a jour currentSite localement immediatement` : avant la resolution de la promise, `currentSite.value` est deja le nouveau site.
+2. `switchSite persiste via /api/me/current-site` : mock `useApi`, verifier que la requete PATCH est appelee avec `site: '/api/sites/{id}'`.
+3. `switchSite rollback en cas d'erreur` : mock `useApi` pour rejeter, verifier que `currentSite.value` repasse a l'ancien site.
+4. `switchSite propagate au store auth apres succes` : `auth.user.currentSite` est mis a jour apres succes.
+5. `resetCurrentSite vide l'etat` : apres appel, `currentSite = null`, `availableSites = []`, `switching = false`.
+6. `switching est vrai pendant la requete, faux apres` : verifier le flag sur tout le cycle.
+7. `double switchSite concurrent est ignore` : si `switching = true`, un second appel retourne immediatement sans effet (garde anti-double-submit).
+
+### Vitest — `useModules.spec.ts`
+
+1. `loadModules charge /api/modules et alimente activeModuleIds`.
+2. `isModuleActive retourne true si l'id est present, false sinon`.
+3. `resetModules vide l'etat`.
+4. `loadModules swallow les erreurs et laisse activeModuleIds vide` (alignement avec `useSidebar`).
+
+### Vitest — `color.spec.ts`
+
+1. `getReadableTextColor('#FFFFFF') === 'black'`.
+2. `getReadableTextColor('#000000') === 'white'`.
+3. `getReadableTextColor('#056CF2') === 'white'` (bleu sature).
+4. `getReadableTextColor('#F59E0B') === 'black'` (ambre clair).
+5. `getReadableTextColor('#10B981') === 'white'` (vert medium-foncé). A verifier a l'implementation ; adapter l'assertion.
+6. `parseHex('red') → throw` (format invalide).
+7. `parseHex('#FFF') → throw` (hex court non supporte).
+8. `parseHex('#abcdef')` et `parseHex('#ABCDEF')` → meme resultat (tolere la casse).
+
+### Vitest — `SiteSelector.spec.ts`
+
+1. `Rendu : 3 sites rendus, bloc du site courant a opacity-100`.
+2. `Bloc inactif a opacity-40 et aria-pressed="false"`.
+3. `Clic sur un bloc inactif appelle switchSite avec le bon site`.
+4. `Si switchSite throw, l'UI affiche toujours l'ancien site courant` (via rollback).
+5. `Texte d'un site avec couleur claire (#FFFFFF) est rendu noir`.
+6. `Texte d'un site avec couleur foncee (#056CF2) est rendu blanc`.
+
+### Tests PHPUnit
+
+Pas de nouveau test backend dans ce ticket — le ticket 2 couvre deja l'endpoint `/api/me/current-site`. Si un comportement nouveau est introduit cote serveur (ce qui ne devrait pas arriver), ajouter les tests en consequence.
+
+### Test visuel manuel
+
+- `make dev-nuxt` (port 3004).
+- Login `admin` / `admin` → selecteur avec 3 blocs (Chatellerault actif, Saint-Jean et Pommevic a 40%).
+- Clic sur `Pommevic` → Pommevic devient actif (100%), Chatellerault passe a 40%, toast "Site courant change".
+- F5 → site actif persiste (Pommevic).
+- Logout puis re-login → Pommevic toujours actif.
+- Login `bob` / `bob` → un seul bloc (Saint-Jean), affiche par coherence (cf. regle metier "afficher meme pour 1 site").
+- Retirer tous les sites a `alice` via `/admin/users` → login alice → selecteur absent.
+- Desactiver `SitesModule::class` dans `config/modules.php`, restart backend, refresh front → selecteur absent, layout identique au comportement d'avant ce ticket.
+
+## 11. Risques et points d'attention
+
+### Risque 1 — Signature de `MalioSiteSelector` inconnue au moment de la spec
+
+La version de `@malio/layer-ui` installee localement (1.3.0) ne contient pas `MalioSiteSelector`. La spec decrit le contrat attendu (props `sites`, `current-site-id`, event `switch`), mais la signature reelle est definie par la lib et peut differer (nom du prop, structure de l'event, slots disponibles, gestion du contraste texte).
+
+**Mitigation** : apres `npm install` de la nouvelle version, consulter `node_modules/@malio/layer-ui/COMPONENTS.md` ou le fichier Vue du composant, adapter `SiteSelector.vue` (wrapper) sans toucher au composable `useCurrentSite()`. Le wrapper est le seul point d'adherence a l'API externe.
+
+### Risque 2 — Flash au premier paint
+
+Si `showSiteSelector` est `false` le temps de resoudre `/api/modules`, l'user voit le layout sans selecteur puis avec → flash desagreable. La solution est de bloquer le rendu sur `loaded.value` du composable modules dans le middleware `auth.global.ts` avant que le layout ne soit instancie.
+
+A verifier apres implementation : ouvrir le devtools "Network throttling" en Slow 3G, login, observer. Si flash : ajouter une garde d'attente avant de rendre le layout ou utiliser un skeleton.
+
+### Risque 3 — `auth.user` muté directement
+
+Le composable `switchSite` mute `auth.user.currentSite = site` pour propager le changement au store auth. Pinia autorise cette mutation mais elle contourne les actions formelles. Alternative plus propre : ajouter une action `auth.setCurrentSite(site)` et l'appeler. Choix pragmatique dans cette spec → privilegier la mutation directe pour rester aligne sur le pattern existant (`auth.user.currentSite` est une propriete simple) ; si un reviewer prefere l'action formelle, c'est un changement localisé sans impact autre.
+
+### Risque 4 — Composable singleton et tests
+
+Les refs `currentSite`, `availableSites`, `switching` sont declarees au niveau module → partagees entre tous les appels a `useCurrentSite()`. En Vitest, cela fuit entre tests si on ne fait pas un `beforeEach(() => resetCurrentSite())`. A documenter en tete du fichier de tests pour eviter des bugs inter-tests.
+
+### Risque 5 — Contraste texte et faux positifs
+
+Le seuil de 0.5 sur la luminance peut donner des rendus sous-optimaux sur des couleurs "limite" (ex: vert emeraude `#10B981` a une luminance qui balance pres du seuil). Si un reviewer trouve le texte peu lisible en usage reel, deux options :
+- Raffiner le calcul : passer a la formule de contraste WCAG complete (ratio entre fond et texte, seuil a 4.5:1).
+- Contraindre la couleur a l'entree : ajouter une validation back (ticket 4 ?) qui rejette les couleurs trop claires si le texte noir donne < 4.5:1 de contraste.
+
+Pour ce ticket, le seuil 0.5 suffit (fixtures testees : `#056CF2` bleu sombre → blanc, `#F59E0B` ambre clair → noir, `#10B981` vert → a voir ; l'admin peut toujours eviter les couleurs pales).
+
+### Risque 6 — Debordement responsive avec 4+ sites
+
+`flex-1` + `min-w-[200px]` + `overflow-x-auto` sur le conteneur gere le debordement de maniere acceptable. Mais sur ecran tres etroit (tablette portrait 768px) avec 4 sites a 200px chacun, le user doit scroller horizontalement — experience sous-optimale.
+
+Alternative : `flex-wrap` + `h-auto` pour laisser les blocs passer a la ligne → le header n'est plus a hauteur fixe 72px. Compromis a trancher selon les usages reels. Ce ticket implemente la solution scroll car la contrainte Figma est "barre de 72px" ; relecture de cette contrainte au ticket 4 si besoin.
+
+### Risque 7 — Auto-selection du currentSite au login si null
+
+Le ticket mentionne : "si currentSite est null et user a ≥1 site, le backend doit avoir auto-selectionne le premier (ou a defaut, faire le switch cote frontend au premier mount du selecteur)".
+
+Le ticket 2 **ne fait pas** d'auto-selection cote backend. Il faut donc gerer cote front : au mount du selecteur, si `currentSite === null && availableSites.length > 0`, appeler `switchSite(availableSites[0])` automatiquement. Cela genere un PATCH au premier chargement d'un user nouvellement rattache — acceptable.
+
+**Alternative** : faire l'auto-selection cote backend au ticket 2. Si cette alternative est choisie en amont, retirer ce comportement cote front. A clarifier au sprint planning.
+
+### Risque 8 — Conflit avec le scroll principal
+
+Le selecteur est dans `flex-1 flex flex-col` au-dessus de `<main>`. `<main>` a `overflow-y-auto` qui permet son propre scroll. Le selecteur est en dehors du `overflow-y-auto` du `<main>` → il reste fige au top quand on scrolle le contenu. Verifier qu'il n'y a pas de collision avec le `sticky top-0 h-8` deja present dans `<main>` (ligne 19-21 de `default.vue`), qui sert de "gradient de lecture" sur le contenu.
+
+## 12. Ordre d'exécution recommandé
+
+1. **Upgrade Malio** — `npm install @malio/layer-ui@<version>`, verifier `node_modules/@malio/layer-ui/COMPONENTS.md` pour la signature de `MalioSiteSelector`.
+2. **Utilitaire couleur** — creer `frontend/shared/utils/color.ts` et ses tests. Isole et rapide a valider.
+3. **Types** — mettre a jour `frontend/shared/types/user-data.ts` et verifier que `frontend/shared/types/sites.ts` existe (sinon le creer).
+4. **Composable modules** — creer `useModules()` et ses tests.
+5. **Composable current site** — creer `useCurrentSite()` et ses tests.
+6. **Middleware** — brancher `loadModules()` dans `auth.global.ts`.
+7. **Composant SiteSelector** — creer `SiteSelector.vue`, implementer wrapper autour de `MalioSiteSelector`, gerer contraste texte.
+8. **Tests composant** — smoke test Vitest sur `SiteSelector.vue`.
+9. **Integration layout** — modifier `frontend/app/layouts/default.vue`, brancher `showSiteSelector`.
+10. **Logout reset** — ajouter `useCurrentSite().resetCurrentSite()` et `useModules().resetModules()` dans `frontend/modules/core/pages/logout.vue`.
+11. **i18n** — completer `frontend/i18n/locales/fr.json`.
+12. **Test visuel** — `make dev-nuxt`, scenarios section 10 "Test visuel manuel".
+13. **Nuxt-lint** — `make nuxt-lint`.
+14. **Vitest full run** — `make nuxt-test`, s'assurer que 100% des tests passent.
+
+## 13. Critères d'acceptation (DoD)
+
+- [ ] `@malio/layer-ui` upgrade vers la version contenant `MalioSiteSelector`. `package-lock.json` committe.
+- [ ] Layer `frontend/modules/sites/` contient bien les dossiers `components/` et `composables/` (layer deja initialise au ticket 2 pour la page admin).
+- [ ] `SiteSelector.vue` : hauteur `h-[72px]`, blocs `flex-1 min-w-[200px]`, text uppercase Inter Bold 24, fond = `site.color`, opacity 100% sur actif / 40% sur inactifs, hover 70% + cursor pointer.
+- [ ] Contraste texte calcule dynamiquement : `#FFFFFF` → noir, `#056CF2` → blanc, `#F59E0B` → noir (tests Vitest verts).
+- [ ] Chaque bloc est un `<button type="button">` avec `aria-pressed` et `aria-label` i18n, focus visible, navigation Tab/Enter fonctionnelle.
+- [ ] Integre dans `layouts/default.vue`, rendu conditionnel `isModuleActive('sites') && user.sites.length > 0`.
+- [ ] Clic sur un bloc inactif → PATCH `/api/me/current-site` via `useApi`, optimistic update, toast succes.
+- [ ] Erreur PATCH → rollback du `currentSite`, toast d'erreur (celui de `useApi` par defaut).
+- [ ] Switch persistant : F5 conserve le nouveau site actif.
+- [ ] Desactiver `SitesModule::class` dans `config/modules.php` → selecteur absent, layout identique a avant ce ticket.
+- [ ] User avec 0 site → selecteur absent (pas de "barre vide").
+- [ ] User avec 1 site → selecteur present (1 bloc unique, bloc actif).
+- [ ] User avec 4+ sites → scroll horizontal fonctionne, pas de debordement casse a 1280px.
+- [ ] `useCurrentSite().resetCurrentSite()` et `useModules().resetModules()` appeles au logout.
+- [ ] `make nuxt-lint` propre.
+- [ ] `make nuxt-test` passe tous les tests (existants + 4 nouveaux suites).
+- [ ] `make dev-nuxt` : aucun warning ni erreur console lors du switch et des cycles login/logout.

docs/sites/ticket-04-spec.md

@@ -0,0 +1,531 @@
+# Ticket #04 — 4/4 — Outillage opt-in « site-scoped » pour modules métier
+
+## 1. Objectif
+
+Ce ticket livre l'outillage qui permettra aux modules metier (Commercial, Stock, Production, etc.) de declarer leurs entites comme **scopees par site** : une fois l'adoption effectuee, un utilisateur ne verra en lecture que les lignes dont `site_id` correspond a son site courant, et les creations/editions injectent automatiquement ce site courant si le payload ne le precise pas.
+
+Le ticket est volontairement **strictement infrastructurel** : il n'adopte le pattern sur aucune entite existante. Aucun module metier n'est modifie, aucune migration n'est jouee sur des tables deja en place. Les tickets futurs (ou des tickets annexes par module) adopteront l'interface au cas par cas apres arbitrage metier.
+
+Le ticket livre aussi une documentation developpeur (`docs/modules/site-aware.md`) qui explique comment et quand adopter le pattern, et quelles entites **ne doivent pas** l'adopter (roles, permissions, users, catalogues globaux, etc.).
+
+## 2. Périmètre
+
+### IN
+
+- Creer le contrat `App\Shared\Domain\Contract\SiteAwareInterface` : interface minimale `getSite(): ?Site` / `setSite(Site $site): void`, place dans `Shared/Domain/Contract/` pour que les modules metier en dependent **sans** importer le module Sites.
+- Creer `CurrentSiteProvider` (module Sites, couche Application) qui resout le site courant a partir de `Security::getUser()` + `User::getCurrentSite()`, et renvoie `null` si : pas d'user authentifie, `currentSite` null, **ou** module Sites inactif dans `config/modules.php`.
+- Creer `SiteScopedQueryExtension` (module Sites, Infrastructure API Platform) implementant `QueryCollectionExtensionInterface` et `QueryItemExtensionInterface` : ajoute la clause `WHERE <alias>.site = :currentSite` quand la resource cible implemente `SiteAwareInterface`, le provider retourne un site, et l'user n'a pas `sites.bypass_scope`.
+- Creer `SiteAwareInjectionProcessor` (module Sites, decorator de `api_platform.doctrine.orm.state.persist_processor`) : avant de deleguer la persistance, si `$data` est une instance de `SiteAwareInterface` et n'a pas deja de site positionne, injecte le `currentSite` fourni par le provider.
+- Declarer la permission `sites.bypass_scope` dans `SitesModule::permissions()`. Admin ou user avec cette permission → le filtre Query Extension saute, visibilite globale.
+- Ecrire `docs/modules/site-aware.md` : guide developpeur complet (cf. section 10).
+- Tests PHPUnit avec une entite fictive `FakeSiteAwareEntity` declaree uniquement dans la suite de tests (jamais en production) pour prouver que le filtrage et l'injection automatique fonctionnent bout en bout.
+- Tests du cas "Sites desactive" : desactiver `SitesModule::class` dans `config/modules.php` avant la suite, re-sync, verifier que l'outillage est no-op et qu'aucun test existant ne casse.
+
+### OUT
+
+- Adoption du pattern sur une entite metier reelle (ex: `Supplier`, `Client`, etc.) : **hors scope**. C'est aux tickets annexes ou aux tickets de feature de l'adopter quand necessaire, en suivant la doc.
+- Migration de donnees "legacy" : ce ticket documente le piege (entites existantes sans `site_id`) mais ne livre aucune migration par module.
+- Support CLI / commandes console : le filtre est uniquement actif dans le contexte API Platform (via les extensions). Une commande batch lira toutes les lignes sans filtre, comportement attendu pour les taches admin. Une eventuelle reimplementation via un Doctrine SQL Filter generique est citee en alternative non retenue (cf. Risque 4).
+- Double-ecriture avec un Doctrine `SQLFilter` : non retenu dans ce ticket. Le filtre via extension API Platform couvre 100% des usages HTTP, qui est le seul contexte ou le site courant a un sens metier (user authentifie). Les commandes CLI doivent gerer la portee explicitement.
+- Changement du comportement cote front : aucun. Le filtrage est transparent, le front continue de faire `GET /api/suppliers` et recoit une collection pre-filtree. Si une entite est adoptee au ticket futur, la page existante continue de fonctionner sans modification.
+- Support d'entites "partiellement site-aware" (colonne site_id nullable, certaines lignes globales partagees) : non retenu. Une entite est soit SiteAware, soit globale. Si un module a besoin de la semantique hybride, il devra creer deux entites distinctes.
+
+## 3. Fichiers à créer
+
+### Shared — Contrat
+
+- `/home/m-tristan/workspace/Coltura/src/Shared/Domain/Contract/SiteAwareInterface.php` : interface minimale. Depends uniquement du type `App\Module\Sites\Domain\Entity\Site`, qui est deja couple cote Core depuis le ticket 2 — le placement dans Shared n'introduit pas de nouvelle dependance transversale non souhaitee.
+
+### Module Sites — Application
+
+- `/home/m-tristan/workspace/Coltura/src/Module/Sites/Application/Service/CurrentSiteProvider.php` : service injecte partout ou le site courant doit etre lu (extensions, processor, futurs voters). Gere les trois cas de retour `null` : pas d'user, `currentSite` null, module desactive.
+
+### Module Sites — Infrastructure
+
+- `/home/m-tristan/workspace/Coltura/src/Module/Sites/Infrastructure/ApiPlatform/Extension/SiteScopedQueryExtension.php` : une seule classe, implementant a la fois `QueryCollectionExtensionInterface` et `QueryItemExtensionInterface`. Le comportement est identique pour les deux, modulo que l'item manque retourne 404 (API Platform converti un `getOneOrNullResult` null en 404).
+- `/home/m-tristan/workspace/Coltura/src/Module/Sites/Infrastructure/ApiPlatform/State/Processor/SiteAwareInjectionProcessor.php` : decorator sur le persist processor Doctrine. Injecte le site courant sur `$data` si applicable, puis delegue a `$persistProcessor`.
+
+### Documentation
+
+- `/home/m-tristan/workspace/Coltura/docs/modules/site-aware.md` : guide developpeur (cf. contenu section 10).
+
+### Tests
+
+- `/home/m-tristan/workspace/Coltura/tests/Module/Sites/Infrastructure/ApiPlatform/Extension/SiteScopedQueryExtensionTest.php` : tests d'integration (`KernelTestCase`) avec l'entite `FakeSiteAwareEntity` (declaree uniquement dans le dossier de tests). Verifie :
+  - Le filtre s'applique sur une resource `SiteAware` quand le provider retourne un site.
+  - Le filtre est no-op si `SiteAware` mais provider null.
+  - Le filtre est no-op si resource non `SiteAware`.
+  - Le filtre est no-op si user a `sites.bypass_scope`.
+  - `totalItems` Hydra reflete bien le filtrage.
+- `/home/m-tristan/workspace/Coltura/tests/Module/Sites/Infrastructure/ApiPlatform/State/Processor/SiteAwareInjectionProcessorTest.php` : tests unitaires (`TestCase` pur) avec mocks. Verifie :
+  - `$data` SiteAware sans site → injection du site courant.
+  - `$data` SiteAware avec site deja positionne → pas d'overwrite.
+  - `$data` non-SiteAware → delegation directe sans modification.
+  - Provider retourne null (module off ou user sans site) ET `$data` SiteAware sans site → BadRequestHttpException (400) "aucun site selectionne".
+- `/home/m-tristan/workspace/Coltura/tests/Module/Sites/Application/Service/CurrentSiteProviderTest.php` : tests unitaires `TestCase`. Couvre :
+  - User authentifie avec currentSite → retourne le Site.
+  - User authentifie sans currentSite → null.
+  - Pas d'user → null.
+  - Module desactive dans config/modules.php de test → null meme si user.currentSite existe.
+- `/home/m-tristan/workspace/Coltura/tests/Fixtures/SiteAware/FakeSiteAwareEntity.php` : entite Doctrine minimale (`id`, `name`, `site`) utilisee **uniquement** en tests. Mapping Doctrine declare via un `#[ORM\Entity]` mais la table n'existe jamais en prod car la fixture n'est jamais chargee hors tests. **Alternative** : utiliser un schema DB dedie au dossier de tests, cree a la volee par un helper setUp. A trancher a l'implementation.
+
+## 4. Fichiers à modifier
+
+- `/home/m-tristan/workspace/Coltura/src/Module/Sites/SitesModule.php` : ajouter la permission `sites.bypass_scope` dans `permissions()` :
+  ```php
+  ['code' => 'sites.bypass_scope', 'label' => 'Voir les donnees site-scoped de tous les sites (bypass du filtrage)'],
+  ```
+  **Note importante** : la methode `permissions()` signale l'existence de la permission mais c'est la commande `app:sync-permissions` (inchangee) qui la positionne en base.
+- `/home/m-tristan/workspace/Coltura/config/services.yaml` : aucun changement requis. `SiteScopedQueryExtension`, `SiteAwareInjectionProcessor` et `CurrentSiteProvider` sont autoconfigures via les `_defaults` du module. Le decorator du persist processor est declare via `#[AsDecorator]` ou via tag (cf. section 8).
+- `/home/m-tristan/workspace/Coltura/phpunit.dist.xml` : aucune modification requise si la config des fixtures de tests est autonome. Si `FakeSiteAwareEntity` necessite un mapping dedie, l'option la plus propre est un `doctrine.yaml.test` ajoute via `when@test`, sans polluer la config dev/prod (cf. Risque 3).
+
+## 5. Contrat `SiteAwareInterface`
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Shared\Domain\Contract;
+
+use App\Module\Sites\Domain\Entity\Site;
+
+/**
+ * Contrat opt-in pour les entites dont la visibilite est scopee par site.
+ *
+ * Une entite implementant cette interface sera :
+ *  - filtree en lecture par SiteScopedQueryExtension (collection + item)
+ *    selon le site courant de l'utilisateur authentifie ;
+ *  - alimentee automatiquement en POST/PATCH par SiteAwareInjectionProcessor
+ *    si le payload ne precise pas de site.
+ *
+ * L'implementation concrete doit :
+ *  - Declarer une relation ManyToOne(Site::class) avec colonne `site_id` NOT NULL.
+ *  - Indexer `site_id` en base (sinon le filtre WHERE genere un full-scan).
+ *
+ * Ne PAS implementer cette interface pour :
+ *  - Des entites globales (catalogue partage, roles, permissions, users).
+ *  - Des entites dont le scope est "par tenant" plus large que le site
+ *    (utiliser TenantAwareInterface le cas echeant).
+ *  - Des entites transversales references par plusieurs sites.
+ *
+ * Voir `docs/modules/site-aware.md` pour le guide d'adoption complet.
+ */
+interface SiteAwareInterface
+{
+    public function getSite(): ?Site;
+
+    public function setSite(Site $site): void;
+}
+```
+
+### Remarque sur le typage du getter
+
+`getSite(): ?Site` retourne nullable pour deux raisons :
+- Coherence avec des entites en cours de construction (pre-persist, avant injection).
+- Compat avec des colonnes qui deviendraient nullable lors d'une migration progressive (ex: deploiement en 2 etapes avec backfill).
+
+En regime nominal, apres persistance, `getSite()` ne doit jamais etre null. Un `assert($entity->getSite() !== null)` dans du code sensible est acceptable.
+
+## 6. Service `CurrentSiteProvider`
+
+### Responsabilite
+
+Expose **une seule** methode `get(): ?Site`. Resout le site courant selon la chaine :
+1. Si `SitesModule::class` n'est pas present dans `config/modules.php` → `null`.
+2. Sinon, si `Security::getUser()` est null → `null`.
+3. Sinon, si `$user->getCurrentSite()` est null → `null`.
+4. Sinon → retourne le Site.
+
+### Detection d'activation du module
+
+Deux strategies possibles :
+
+**Strategie A — lire `config/modules.php` au boot du service** (pattern `ModulesProvider`) :
+```php
+public function __construct(
+    private readonly Security $security,
+    #[Autowire(param: 'kernel.project_dir')]
+    string $projectDir,
+) {
+    $moduleClasses       = require $projectDir.'/config/modules.php';
+    $this->sitesActive   = in_array(SitesModule::class, $moduleClasses, true);
+}
+```
+
+**Strategie B — extraire un service `ActiveModulesRegistry`** partage entre `ModulesProvider` et `CurrentSiteProvider` (refactor mineur).
+
+**Recommandation** : strategie A dans ce ticket pour rester minimal. Si un troisieme consommateur apparait (probable), extraire le registry dans un ticket dedie.
+
+### Contrat complet
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Sites\Application\Service;
+
+use App\Module\Core\Domain\Entity\User;
+use App\Module\Sites\Domain\Entity\Site;
+use App\Module\Sites\SitesModule;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\DependencyInjection\Attribute\Autowire;
+
+final class CurrentSiteProvider
+{
+    private readonly bool $sitesActive;
+
+    public function __construct(
+        private readonly Security $security,
+        #[Autowire(param: 'kernel.project_dir')]
+        string $projectDir,
+    ) {
+        $moduleClasses     = require $projectDir.'/config/modules.php';
+        $this->sitesActive = in_array(SitesModule::class, $moduleClasses, true);
+    }
+
+    public function get(): ?Site
+    {
+        if (!$this->sitesActive) {
+            return null;
+        }
+
+        $user = $this->security->getUser();
+        if (!$user instanceof User) {
+            return null;
+        }
+
+        return $user->getCurrentSite();
+    }
+}
+```
+
+## 7. Extensions API Platform
+
+### `SiteScopedQueryExtension`
+
+Implemente a la fois `QueryCollectionExtensionInterface` et `QueryItemExtensionInterface`. La logique est commune et factorisee dans une methode privee `applyScope()`.
+
+```php
+public function applyToCollection(
+    QueryBuilder $queryBuilder,
+    QueryNameGeneratorInterface $queryNameGenerator,
+    string $resourceClass,
+    ?Operation $operation = null,
+    array $context = [],
+): void {
+    $this->applyScope($queryBuilder, $queryNameGenerator, $resourceClass);
+}
+
+public function applyToItem(
+    QueryBuilder $queryBuilder,
+    QueryNameGeneratorInterface $queryNameGenerator,
+    string $resourceClass,
+    array $identifiers,
+    ?Operation $operation = null,
+    array $context = [],
+): void {
+    $this->applyScope($queryBuilder, $queryNameGenerator, $resourceClass);
+}
+
+private function applyScope(
+    QueryBuilder $queryBuilder,
+    QueryNameGeneratorInterface $queryNameGenerator,
+    string $resourceClass,
+): void {
+    // 1) Resource SiteAware ?
+    if (!is_subclass_of($resourceClass, SiteAwareInterface::class)) {
+        return;
+    }
+
+    // 2) Bypass admin / permission dediee ?
+    if ($this->security->isGranted('sites.bypass_scope')) {
+        return;
+    }
+
+    // 3) Site courant disponible ?
+    $currentSite = $this->currentSiteProvider->get();
+    if ($currentSite === null) {
+        // Decision assumee : no-op plutot que collection vide (cf. section 11 Risque 1).
+        return;
+    }
+
+    // 4) Applique WHERE site = :currentSite
+    $rootAlias    = $queryBuilder->getRootAliases()[0];
+    $parameterName = $queryNameGenerator->generateParameterName('currentSite');
+    $queryBuilder
+        ->andWhere(sprintf('%s.site = :%s', $rootAlias, $parameterName))
+        ->setParameter($parameterName, $currentSite);
+}
+```
+
+### Ordre de priorite
+
+L'extension doit s'executer **apres** les filtres natifs API Platform (Pagination, Order, Search). Priorite par defaut (0) convient, mais si un autre filtre custom est ajoute plus tard, verifier qu'il ne court-circuite pas. Declarer la priorite explicitement via `#[AsTaggedItem(priority: -100)]` est une option pour s'executer en dernier et etre robuste a l'ordre d'ajout d'autres extensions.
+
+### JSON-LD `totalItems`
+
+API Platform execute un `COUNT(*)` separe pour produire le `totalItems` dans la reponse Hydra. Ce count passe par les memes extensions → le totalItems reflete automatiquement le filtrage. A verifier par un test dedie (cf. section 11).
+
+### `applyToItem` et 404
+
+Quand un GET `/api/suppliers/{id}` cible un supplier qui existe en base mais appartient a un autre site, la requete `SELECT ... WHERE id = :id AND site = :currentSite` retourne `null` → API Platform converti en 404. Comportement desire : l'user ne doit pas pouvoir distinguer "cet item n'existe pas" de "cet item existe mais pas dans mon site" (anti-enumeration).
+
+## 8. Processor d'injection automatique `SiteAwareInjectionProcessor`
+
+### Pattern decorator
+
+Le plus propre en API Platform est de decorer le processor de persistance Doctrine :
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Sites\Infrastructure\ApiPlatform\State\Processor;
+
+use ApiPlatform\Metadata\Operation;
+use ApiPlatform\State\ProcessorInterface;
+use App\Module\Sites\Application\Service\CurrentSiteProvider;
+use App\Shared\Domain\Contract\SiteAwareInterface;
+use Symfony\Component\DependencyInjection\Attribute\AsDecorator;
+use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
+
+#[AsDecorator('api_platform.doctrine.orm.state.persist_processor')]
+final class SiteAwareInjectionProcessor implements ProcessorInterface
+{
+    public function __construct(
+        private readonly ProcessorInterface $inner,
+        private readonly CurrentSiteProvider $currentSiteProvider,
+    ) {}
+
+    public function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): mixed
+    {
+        if ($data instanceof SiteAwareInterface && $data->getSite() === null) {
+            $currentSite = $this->currentSiteProvider->get();
+
+            if ($currentSite === null) {
+                throw new BadRequestHttpException(
+                    'Impossible de creer l\'enregistrement : aucun site selectionne.',
+                );
+            }
+
+            $data->setSite($currentSite);
+        }
+
+        return $this->inner->process($data, $operation, $uriVariables, $context);
+    }
+}
+```
+
+### Effets de bord et compatibilite
+
+- **S'applique a TOUS les processors qui heritent du persist processor natif API Platform**. Si un processor custom (ex: `UserRbacProcessor`) delegue a `api_platform.doctrine.orm.state.persist_processor` via autowire, il passe aussi par ce decorator — transparent pour User (non SiteAware).
+- **N'ecrase jamais un site deja positionne** : un admin qui POST un supplier avec `site: '/api/sites/2'` garde cette valeur, meme si son `currentSite` est 1. La regle metier "site different autorise uniquement si l'user a plusieurs sites" du ticket n'est **pas** implementee dans ce decorator : c'est au voter de securite (hors scope de ce ticket) de l'enforcer si necessaire.
+- **Erreur explicite si pas de site** : BadRequestHttpException plutot qu'un `null` silencieux. Le user comprend que l'operation necessite un site actif.
+
+### Alternative rejetee — EventListener Doctrine `prePersist`
+
+Un listener Doctrine intercepterait toutes les persistances, y compris hors HTTP (CLI, fixtures). **Rejetee** car :
+- `CurrentSiteProvider` depend de `Security`, indisponible en CLI.
+- Les fixtures doivent positionner explicitement le site (cf. `AppFixtures` ticket 2), ce qui est plus correct metier.
+- Les commandes batch peuvent vouloir creer des entites sans site actif (backoffice multi-sites) — un listener silencieux les bloquerait.
+
+Le decorator HTTP-only est plus aligne avec le principe "opt-in controle".
+
+## 9. Permission `sites.bypass_scope`
+
+### Déclaration
+
+Dans `SitesModule::permissions()` :
+
+```php
+public static function permissions(): array
+{
+    return [
+        ['code' => 'sites.view', 'label' => 'Voir les sites'],
+        ['code' => 'sites.manage', 'label' => 'Gerer les sites (creer, editer, supprimer)'],
+        ['code' => 'sites.bypass_scope', 'label' => 'Voir les donnees site-scoped de tous les sites (bypass du filtrage)'],
+    ];
+}
+```
+
+### Semantique
+
+- User avec `sites.bypass_scope` → le filtre `WHERE site = :currentSite` n'est pas applique. La collection retournee est **globale** (toutes les lignes).
+- User **admin** (`isAdmin = true`) → `is_granted()` retourne toujours true pour toute permission → le bypass est automatique. Pas besoin d'assignation explicite.
+- Cas typique d'attribution : un admin financier qui veut consolider les suppliers a l'echelle groupe.
+
+### Absence de bypass sur le processor
+
+Le processor d'injection ne respecte **pas** `sites.bypass_scope` : meme un user avec bypass verra son `currentSite` injecte si le payload n'en precise pas. Justification : l'injection n'est pas une restriction, c'est un default value. Le user bypass peut toujours envoyer un site explicite different.
+
+## 10. Documentation développeur — `docs/modules/site-aware.md`
+
+Le fichier livre **5 sections** :
+
+### 10.1 Quand adopter `SiteAwareInterface`
+
+- Entite qui existe "par site" : chaque ligne appartient a un et un seul site, les users ne doivent voir que celles de leur site courant.
+- Exemples : `Supplier` (chaque site a ses fournisseurs), `Order`, `StockEntry`, `Employee` (si chaque site a sa propre equipe).
+
+### 10.2 Quand NE PAS adopter
+
+- Entites globales : `Role`, `Permission`, `User` (les users sont transverses, rattaches a plusieurs sites).
+- Catalogues partages : produits, categories, taxes — s'ils sont mutualises entre sites.
+- Entites transversales : `Invoice` globale, `Contract` multi-site.
+- Entites dont la portee naturelle est "par tenant" plus large que "par site" : utiliser `TenantAwareInterface` (si pertinent pour le projet multi-tenant futur).
+
+### 10.3 Comment adopter (check-list)
+
+1. **Entite** :
+   - Implementer `App\Shared\Domain\Contract\SiteAwareInterface`.
+   - Ajouter la relation `#[ORM\ManyToOne(targetEntity: Site::class)] #[ORM\JoinColumn(name: 'site_id', nullable: false, onDelete: 'CASCADE')] private Site $site`.
+   - Implementer `getSite()` et `setSite()`.
+2. **Migration** :
+   - Creer une migration dediee au module concerne (ou racine si init critique, voir `CLAUDE.md`).
+   - `ALTER TABLE <table> ADD COLUMN site_id INT NOT NULL`.
+   - **Gestion legacy** : si des lignes existent deja, la colonne ne peut pas etre NOT NULL directement. Strategie :
+     1. Ajouter la colonne nullable.
+     2. Backfill manuel ou par script (ex: tout rattacher au site "Chatellerault" par defaut, ou laisser l'admin arbitrer).
+     3. Rendre la colonne NOT NULL via une seconde migration.
+   - **Index** : `CREATE INDEX IDX_<table>_site ON <table> (site_id)`. **Obligatoire** — le filtre `WHERE site_id = ?` genere un full-scan sinon.
+3. **Serialisation** : ajouter `site` au groupe de lecture API (`#[Groups(['<resource>:read'])]`) pour que le front voie a quel site appartient la ligne.
+4. **Processor custom** : si le module a deja un processor sur l'operation POST/PATCH, s'assurer qu'il delegue a `api_platform.doctrine.orm.state.persist_processor` (et non `ObjectManager::persist` direct) pour que le decorator d'injection s'applique.
+
+### 10.4 Comportement en mode degrade
+
+- **Module Sites desactive** (`config/modules.php`) : `CurrentSiteProvider::get()` retourne `null` → le filtre ne s'applique plus → toutes les lignes sont visibles, comme avant l'adoption. L'app reste fonctionnelle, juste sans segmentation. **Mais** : la colonne `site_id` NOT NULL reste en place, et le processor d'injection leve une 400 sur tout POST/PATCH sans site explicite. Consequence : **un module adopte ne peut pas vivre sans Sites active** pour les operations d'ecriture, sauf a envoyer systematiquement un `site` explicite dans le payload. A documenter **fortement**.
+- **User sans site** (sites.length = 0, currentSite = null) : meme comportement → no-op en lecture, 400 en ecriture. Le module doit documenter l'UX degradee.
+
+### 10.5 Gotchas et anti-patterns
+
+- **Sous-collections** (`/api/clients/{id}/contacts`) : l'extension s'applique a la resource chargee, ici `Contact`. Si `Contact` est SiteAware, le filtre passe. Si seul `Client` est SiteAware (et Contact herite du scope via son parent), **le filtre ne se propage pas automatiquement** : il faut soit rendre Contact SiteAware aussi (redondance), soit ajouter un filtre custom qui verifie `contact.client.site == currentSite`. Ce ticket ne couvre pas le second cas.
+- **Jointures** : si un repository custom fait une requete sans passer par API Platform (ex: `findByX()` appele depuis un processor), le filtre ne s'applique pas. Responsabilite du developpeur du module d'ajouter `->andWhere('x.site = :currentSite')` manuellement ou de passer par le `CurrentSiteProvider`.
+- **Tests d'integration** : les tests existants d'un module adopte devront soit logger un user avec un site actif, soit utiliser `sites.bypass_scope` pour voir toute la donnee. La suite de fixtures devra positionner un site coherent sur les entites de test.
+- **Cascade delete d'un site** : le ticket 2 met `user.current_site_id` a NULL si le site est supprime. Si une entite adoptee declare `onDelete: CASCADE` sur sa FK site, elle perdra toutes ses lignes au delete d'un site. Choisir explicitement : cascade (aligne sur l'invariant "une ligne SiteAware a toujours un site") ou blocage (empecher la suppression d'un site s'il reste des lignes adoptees).
+
+## 11. Risques et points d'attention
+
+### Risque 1 — Comportement "no-op si pas de site courant"
+
+La spec choisit **no-op plutot que collection vide** quand `CurrentSiteProvider::get() === null`. Arbitrage :
+
+- **No-op** (retenu) : un user sans site voit tout, un admin sans site aussi. Risque de fuite de donnees d'un site a l'autre, mais l'app reste utilisable.
+- **Collection vide** : un user sans site ne voit rien. Plus strict, mais bloque un admin qui consulterait l'app avant d'avoir configure un site.
+
+Le ticket retient **no-op** car l'app reste utilisable. La permission `sites.bypass_scope` est explicite pour les admins qui veulent voir tout. Si la decision metier evolue, le changement est localise dans `SiteScopedQueryExtension::applyScope()`.
+
+### Risque 2 — Fuite de donnees entre sites
+
+Si un module adopte `SiteAwareInterface` mais qu'un repository custom court-circuite API Platform, le filtre ne s'applique pas. Consequence : un endpoint custom (`GET /api/suppliers/top-rated`) pourrait exposer tous les suppliers sans filtrage.
+
+**Mitigation** : la doc insiste sur la responsabilite du developpeur d'adopter le filtre manuellement dans les repositories custom. Un test d'integration par module adopte est **fortement recommande**.
+
+### Risque 3 — `FakeSiteAwareEntity` en tests
+
+L'entite fictive doit etre mappee par Doctrine pour que le QueryBuilder fonctionne. Trois options :
+
+1. **Declaration via `when@test`** : ajouter `config/packages/doctrine.yaml` dans un bloc `when@test` avec un mapping dedie pointant vers `tests/Fixtures/SiteAware/`. Propre mais ajoute un fichier de config.
+2. **Attribute Doctrine dans le fichier de test** : fonctionne si le kernel de test decouvre le namespace. Pas elegant.
+3. **Mock integral du QueryBuilder** : pas d'entite reelle, on mock Doctrine. Tests plus unitaires mais moins realistes.
+
+**Recommandation** : option 1 (mapping `when@test`). La classe reste dans `tests/` et ne pollue jamais la prod.
+
+### Risque 4 — Pas de Doctrine SQL Filter
+
+Un Doctrine `SQLFilter` appliquerait le filtrage a **toutes** les requetes Doctrine, y compris hors API Platform (CLI, fixtures, cron, reports). Plus defensif mais plus risque :
+
+- Les commandes batch devraient l'activer/desactiver explicitement.
+- Les fixtures devraient le desactiver pour seeder plusieurs sites.
+- Les tests d'integration devraient le gerer.
+
+Le ticket retient la strategie **API Platform only** car le site courant n'a de sens que dans un contexte HTTP authentifie. Si un besoin emerge (rapport automatique scope par site, webhook multi-site, etc.), le refactor vers un SQL filter sera localise.
+
+### Risque 5 — Priorite des extensions
+
+Si un autre module introduit plus tard une extension avec une clause `HAVING` ou un `setMaxResults` qui suppose que le filtre de base n'est pas modifie, il peut y avoir des surprises. Declarer explicitement une priorite negative (`priority: -100`) sur `SiteScopedQueryExtension` via `#[AsTaggedItem]` la fait s'executer apres la plupart des filtres natifs, ce qui est generalement souhaitable pour un filtre applicatif.
+
+### Risque 6 — `UserRbacProcessor` et les autres processors custom
+
+Le decorator `SiteAwareInjectionProcessor` decore `api_platform.doctrine.orm.state.persist_processor`. Si un module declare un processor custom qui **ne delegue pas** au persist processor (ex: fait `$em->persist($data); $em->flush()` directement), l'injection de site n'a **pas** lieu. Le module doit explicitement passer par le persist processor pour beneficier du pattern.
+
+A mitiger par un test qui genere une entite `FakeSiteAwareEntity` via un POST `api_platform.doctrine.orm.state.persist_processor` mocke et verifie que le decorator a bien injecte le site.
+
+### Risque 7 — Performance du `require` au boot
+
+`CurrentSiteProvider` fait un `require 'config/modules.php'` au constructeur. Le fichier est un simple `return [...]` → l'overhead est minimal et le resultat est opcache par PHP. Meme pattern que `ModulesProvider`, sans regression perf documentee.
+
+### Risque 8 — Doc developpeur en francais vs anglais
+
+Le fichier `docs/modules/site-aware.md` s'adresse aux developpeurs de Coltura. Il est redige en **francais**, aligne sur la convention projet (CLAUDE.md : "commentaires en francais, code en anglais"). Aucun extrait de code ne doit etre traduit, seules les explications.
+
+## 12. Plan de tests
+
+### Tests unitaires (`TestCase` pur)
+
+#### `CurrentSiteProviderTest`
+
+1. `testReturnsNullIfSitesModuleInactive` : config/modules.php de test ne contient pas SitesModule → null meme si user + site fixent.
+2. `testReturnsNullIfNoUser` : Security::getUser() = null → null.
+3. `testReturnsNullIfUserHasNoCurrentSite` : user.currentSite = null → null.
+4. `testReturnsSiteIfAllConditionsMet` : user + currentSite set → retourne le Site.
+
+#### `SiteAwareInjectionProcessorTest`
+
+1. `testInjectsCurrentSiteOnNewSiteAwareData` : $data SiteAware + getSite() = null + provider retourne Site → setSite appele avec le bon site.
+2. `testDoesNotOverrideExistingSite` : $data SiteAware + getSite() non-null → pas d'appel a setSite, delegation directe.
+3. `testSkipsNonSiteAwareData` : $data qui n'implemente pas SiteAwareInterface → aucune modification, delegation.
+4. `testThrowsBadRequestIfNoCurrentSite` : $data SiteAware + getSite() = null + provider retourne null → BadRequestHttpException 400.
+5. `testDelegatesToInnerAlways` : inner->process est appele dans tous les cas (sauf quand 400 throw).
+
+### Tests d'intégration (`KernelTestCase`)
+
+#### `SiteScopedQueryExtensionTest`
+
+Fixture : 2 sites (siteA, siteB), 3 FakeSiteAwareEntity (2 sur siteA, 1 sur siteB), 1 user rattache a siteA.
+
+1. `testCollectionFilteredByCurrentSite` : user avec currentSite=siteA → collection retourne 2 entites (celles de siteA).
+2. `testCollectionNotFilteredIfNoCurrentSite` : user sans currentSite → collection retourne 3 entites (no-op).
+3. `testCollectionNotFilteredIfResourceNotSiteAware` : query sur une entite non SiteAware → aucune clause additionnelle.
+4. `testCollectionNotFilteredIfBypassPermission` : user avec `sites.bypass_scope` → 3 entites.
+5. `testCollectionNotFilteredIfSitesModuleInactive` : desactiver SitesModule → provider null → no-op, 3 entites.
+6. `testItemNotFoundIfWrongSite` : GET sur un id dont le site est siteB alors que user sur siteA → 404 (ou `null` retourne par le QueryBuilder).
+7. `testItemFoundIfCorrectSite` : GET sur un id du site courant → 200.
+8. `testTotalItemsReflectsFilter` : collection Hydra `totalItems: 2` (et non 3) quand le filtre s'applique.
+
+### Tests de non-régression
+
+Apres implementation, **re-jouer toute la suite existante** en mode module Sites active et en mode module desactive. Aucun test existant ne doit changer.
+
+## 13. Ordre d'exécution recommandé
+
+1. **Contrat** — `SiteAwareInterface` dans `Shared/Domain/Contract/`.
+2. **Provider** — `CurrentSiteProvider` + tests unitaires.
+3. **Processor decorator** — `SiteAwareInjectionProcessor` + tests unitaires avec mocks.
+4. **Entite de test** — `FakeSiteAwareEntity` + mapping `when@test` si retenu.
+5. **Query extension** — `SiteScopedQueryExtension` + tests d'integration.
+6. **Permission bypass** — ajout dans `SitesModule::permissions()`, `make sync-permissions`, verifier en base.
+7. **Tests exhaustifs** — faire passer la matrice des 8 cas d'integration.
+8. **Tests non-regression** — `make test` avec SitesModule actif puis inactif.
+9. **Documentation** — rediger `docs/modules/site-aware.md` (5 sections).
+10. **CS fixer** — `make php-cs-fixer-allow-risky`.
+11. **DoD** — valider la check-list section 14.
+
+## 14. Critères d'acceptation (DoD)
+
+- [ ] `App\Shared\Domain\Contract\SiteAwareInterface` existe avec les deux methodes `getSite(): ?Site` et `setSite(Site $site): void`.
+- [ ] `CurrentSiteProvider::get()` retourne `null` dans les 3 cas : pas d'user, pas de currentSite, module inactif. Retourne le Site sinon.
+- [ ] `SiteScopedQueryExtension` applique le WHERE sur les resources SiteAware quand un site courant est resolu et que l'user n'a pas `sites.bypass_scope`.
+- [ ] `SiteAwareInjectionProcessor` injecte automatiquement le site courant sur POST/PATCH d'entites SiteAware sans site explicite.
+- [ ] `SiteAwareInjectionProcessor` leve une 400 si l'entite SiteAware n'a pas de site ET que le provider retourne null.
+- [ ] Permission `sites.bypass_scope` declaree dans `SitesModule::permissions()` et presente en base apres `app:sync-permissions`.
+- [ ] `docs/modules/site-aware.md` livre les 5 sections (quand/comment adopter, anti-patterns, degrade, gotchas).
+- [ ] Tests d'integration : au moins 8 cas couvrant filtrage collection/item, no-op dans les 3 scenarios (pas de site, resource non SiteAware, bypass), et `totalItems` Hydra.
+- [ ] Tests unitaires sur `CurrentSiteProvider` et `SiteAwareInjectionProcessor`.
+- [ ] Aucune migration sur des tables metier existantes (`supplier`, `client`, `user`, ...) — seules les migrations du ticket 1 et 2 sont presentes. Verifier via `make migration-migrate` : aucun SQL attendu sur la suite existante.
+- [ ] `make test` passe avec `SitesModule::class` actif dans `config/modules.php`.
+- [ ] `make test` passe avec `SitesModule::class` desactive dans `config/modules.php`.
+- [ ] `make php-cs-fixer-allow-risky` propre sur les fichiers nouveaux.
+- [ ] Aucun module metier (Commercial, Core hors User, etc.) n'a ete modifie par ce ticket — diff ne touche que `src/Shared/`, `src/Module/Sites/`, `tests/`, et `docs/`.

frontend/app/layouts/default.vue

@@ -14,6 +14,7 @@
             </MalioSidebar>
 
             <div class="h-full flex-1 flex flex-col min-h-0 min-w-0">
+                <SiteSelector v-if="showSiteSelector"/>
                 <main
                     class="flex flex-1 flex-col overflow-y-auto overflow-x-hidden bg-white px-4 pb-24 sm:px-8 lg:px-16">
                     <div
@@ -30,8 +31,21 @@
 const {t} = useI18n()
 const ui = useUiStore()
 const {sections} = useSidebar()
+const {isModuleActive} = useModules()
+const auth = useAuthStore()
 const route = useRoute()
 
+// Le SiteSelector est rendu si :
+//  - le module Sites est actif dans config/modules.php (sinon la feature
+//    n'a pas de sens, cf. ticket 3 spec criteres d'acceptation) ;
+//  - ET l'user connecte a au moins un site autorise (sinon "barre vide"
+//    sans tile cliquable).
+// Les deux flags sont resolus par le middleware auth.global.ts avant
+// que le layout ne soit rendu (plan load parallele), donc pas de flash.
+const showSiteSelector = computed(() =>
+    isModuleActive('sites') && (auth.user?.sites?.length ?? 0) > 0,
+)
+
 const translatedSections = computed(() =>
     sections.value.map(section => ({
         label: t(section.label),

frontend/app/middleware/auth.global.ts

@@ -15,9 +15,16 @@ export default defineNuxtRouteMiddleware(async (to) => {
     }
 
     if (auth.isAuthenticated) {
-        const { loaded, loadSidebar } = useSidebar()
-        if (!loaded.value) {
-            await loadSidebar()
-        }
+        const { loaded: sidebarLoaded, loadSidebar } = useSidebar()
+        const { loaded: modulesLoaded, loadModules } = useModules()
+
+        // Chargement parallele sidebar + modules actifs : les deux sont
+        // consommes par layouts/default.vue (sidebar pour la nav, modules
+        // pour conditionner le SiteSelector). Charger en parallele evite
+        // le flash au premier paint de la barre.
+        await Promise.all([
+            sidebarLoaded.value ? Promise.resolve() : loadSidebar(),
+            modulesLoaded.value ? Promise.resolve() : loadModules(),
+        ])
     }
 })

frontend/i18n/locales/fr.json

@@ -13,10 +13,12 @@
         "actions": "Actions"
     },
     "sidebar": {
-        "general": {
-            "section": "Général",
+        "administration": {
+            "section": "Administration"
+        },
+        "account": {
+            "section": "Mon compte",
             "dashboard": "Tableau de bord",
-            "admin": "Administration",
             "logout": "Déconnexion"
         },
         "commercial": {
@@ -25,7 +27,9 @@
         },
         "core": {
             "roles": "Gestion des rôles",
-            "users": "Utilisateurs"
+            "users": "Utilisateurs",
+            "sites": "Sites",
+            "audit_log": "Journal d'audit"
         }
     },
     "dashboard": {
@@ -54,8 +58,48 @@
             "put": "Erreur lors de la mise a jour",
             "patch": "Erreur lors de la modification",
             "delete": "Erreur lors de la suppression"
+        },
+        "sites": {
+            "notAuthorized": "Vous n'êtes pas autorisé à sélectionner ce site."
         }
     },
+    "sites": {
+        "selector": {
+            "ariaGroupLabel": "Sélecteur de site actif",
+            "switchSuccess": "Site courant changé"
+        }
+    },
+    "audit": {
+        "action": {
+            "create": "Création",
+            "update": "Modification",
+            "delete": "Suppression"
+        },
+        "entity": {
+            "user": "Utilisateur"
+        },
+        "empty": "Aucune activité enregistrée",
+        "no_results": "Aucun résultat pour ces filtres",
+        "timeline": {
+            "empty": "Aucun historique",
+            "load_more": "Voir plus"
+        },
+        "filters": {
+            "reset": "Réinitialiser",
+            "date_from": "Du",
+            "date_to": "Au",
+            "entity_type": "Type d'entité",
+            "user": "Utilisateur",
+            "action": "Action",
+            "all_actions": "Toutes les actions"
+        },
+        "detail": {
+            "field": "Champ",
+            "old_value": "Ancienne valeur",
+            "new_value": "Nouvelle valeur"
+        },
+        "detail_title": "Détail de l'entrée"
+    },
     "success": {
         "auth": {
             "logout": "Deconnexion reussie"
@@ -102,7 +146,8 @@
                 "username": "Nom d'utilisateur",
                 "admin": "Administrateur",
                 "roles": "Roles",
-                "directPermissions": "Permissions directes"
+                "directPermissions": "Permissions directes",
+                "sites": "Sites"
             },
             "drawer": {
                 "title": "Permissions de {username}",
@@ -110,6 +155,7 @@
                 "adminToggle": "Administrateur (bypass total)",
                 "rolesSection": "Rôles",
                 "directPermissionsSection": "Permissions directes",
+                "sitesSection": "Sites autorisés",
                 "summarySection": "Résumé des permissions effectives",
                 "noEffectivePermissions": "Aucune permission effective",
                 "sourceRole": "via {role}",
@@ -119,6 +165,54 @@
             "toast": {
                 "updated": "Permissions mises à jour avec succès"
             }
+        },
+        "auditLog": {
+            "title": "Journal d'audit",
+            "table": {
+                "performedAt": "Date",
+                "performedBy": "Utilisateur",
+                "entityType": "Entité",
+                "entityId": "ID",
+                "action": "Action",
+                "summary": "Résumé"
+            },
+            "pagination": {
+                "previous": "Précédent",
+                "next": "Suivant"
+            }
+        },
+        "sites": {
+            "title": "Gestion des sites",
+            "newSite": "Nouveau site",
+            "editSite": "Modifier le site",
+            "createSite": "Créer un site",
+            "noSites": "Aucun site configuré",
+            "table": {
+                "name": "Nom",
+                "city": "Ville",
+                "postalCode": "Code postal",
+                "color": "Couleur",
+                "fullAddress": "Adresse complète"
+            },
+            "form": {
+                "name": "Nom",
+                "street": "Rue",
+                "complement": "Complément d'adresse",
+                "complementPlaceholder": "Bâtiment, escalier, BP... (optionnel)",
+                "postalCode": "Code postal",
+                "city": "Ville",
+                "color": "Couleur (format #RRGGBB)",
+                "colorInvalid": "Format attendu : #RRGGBB (6 caractères hexadécimaux)"
+            },
+            "delete": {
+                "title": "Supprimer le site",
+                "message": "Êtes-vous sûr de vouloir supprimer le site \"{name}\" ? Cette action est irréversible et retirera ce site à tous les utilisateurs rattachés."
+            },
+            "toast": {
+                "created": "Site créé avec succès",
+                "updated": "Site mis à jour avec succès",
+                "deleted": "Site supprimé avec succès"
+            }
         }
     }
 }

frontend/modules/core/components/UserRbacDrawer.vue

@@ -64,6 +64,27 @@
                 </div>
             </div>
 
+            <!-- Section Sites autorises (ticket 2 module Sites) -->
+            <div>
+                <h4 class="mb-3 text-sm font-semibold text-neutral-700">
+                    {{ t('admin.users.drawer.sitesSection') }}
+                </h4>
+                <div v-if="allSites.length === 0" class="text-sm text-neutral-400">
+                    {{ t('admin.sites.noSites') }}
+                </div>
+                <div class="flex flex-col gap-2">
+                    <MalioCheckbox
+                        v-for="site in allSites"
+                        :id="`site-${site.id}`"
+                        :key="site.id"
+                        :label="site.name"
+                        :model-value="selectedSiteIds.has(site.id)"
+                        label-class="text-sm text-neutral-600"
+                        @update:model-value="(val: boolean) => toggleSite(site.id, val)"
+                    />
+                </div>
+            </div>
+
             <!-- Section Resume permissions effectives -->
             <div>
                 <h4 class="mb-3 text-sm font-semibold text-neutral-700">
@@ -91,7 +112,8 @@
 </template>
 
 <script setup lang="ts">
-import type { Permission, Role, UserListItem, EffectivePermission } from '~/shared/types/rbac'
+import type { Permission, Role, UserListItem, UserRbacDetail, EffectivePermission } from '~/shared/types/rbac'
+import type { Site } from '~/shared/types/sites'
 
 interface PermissionModule {
     module: string
@@ -115,10 +137,12 @@ const emit = defineEmits<{
 const saving = ref(false)
 const allRoles = ref<Role[]>([])
 const allPermissions = ref<Permission[]>([])
+const allSites = ref<Site[]>([])
 
 const form = ref({ isAdmin: false })
 const selectedRoleIds = ref(new Set<number>())
 const selectedDirectPermissionIds = ref(new Set<number>())
+const selectedSiteIds = ref(new Set<number>())
 
 // Detecter l'auto-edition
 const isSelfEdit = computed(() => props.user?.id === auth.user?.id)
@@ -182,34 +206,44 @@ const effectivePermissions = computed<EffectivePermission[]>(() => {
         .sort((a, b) => a.code.localeCompare(b.code))
 })
 
-// Charger roles et permissions
-async function loadData() {
-    const [rolesData, permsData] = await Promise.all([
+// Charger les referentiels (roles, permissions, sites) + le detail RBAC du user
+// en parallele pour minimiser le TTFB a l'ouverture du drawer.
+// Le detail RBAC est la seule source de verite pour l'etat initial du formulaire :
+// props.user vient de la liste /api/users qui n'expose pas les sites (groupe leger).
+async function loadData(userId: number) {
+    const [rolesData, permsData, sitesData, userRbac] = await Promise.all([
         api.get<{ member: Role[] }>('/roles', {}, { toast: false }),
         api.get<{ member: Permission[] }>('/permissions', { orphan: false, itemsPerPage: 999 }, { toast: false }),
+        api.get<{ member: Site[] }>('/sites', { itemsPerPage: 999 }, { toast: false }),
+        api.get<UserRbacDetail>(`/users/${userId}/rbac`, {}, { toast: false }),
     ])
     allRoles.value = rolesData.member
     allPermissions.value = permsData.member
+    allSites.value = sitesData.member
+
+    form.value.isAdmin = userRbac.isAdmin
+    selectedRoleIds.value = new Set((userRbac.roles ?? []).map(iriToId))
+    selectedDirectPermissionIds.value = new Set((userRbac.directPermissions ?? []).map(iriToId))
+    selectedSiteIds.value = new Set((userRbac.sites ?? []).map(iriToId))
 }
 
-// Remplir le formulaire quand le user change
-watch(() => props.user, (user) => {
-    if (user) {
-        form.value.isAdmin = user.isAdmin
-        selectedRoleIds.value = new Set(user.roles.map(iriToId))
-        selectedDirectPermissionIds.value = new Set(user.directPermissions.map(iriToId))
-    } else {
-        form.value.isAdmin = false
-        selectedRoleIds.value = new Set()
-        selectedDirectPermissionIds.value = new Set()
+function resetForm() {
+    form.value.isAdmin = false
+    selectedRoleIds.value = new Set()
+    selectedDirectPermissionIds.value = new Set()
+    selectedSiteIds.value = new Set()
+}
+
+// Recharger a l'ouverture OU quand le user change pendant que le drawer est ouvert.
+// Le watch combine evite un double fetch si les deux changent dans le meme tick.
+watch([() => props.modelValue, () => props.user?.id], ([open, userId]) => {
+    if (open && userId) {
+        loadData(userId)
+    } else if (!open) {
+        resetForm()
     }
 }, { immediate: true })
 
-// Charger les donnees quand le drawer s'ouvre
-watch(() => props.modelValue, (open) => {
-    if (open) loadData()
-})
-
 function toggleRole(id: number, selected: boolean) {
     const ids = new Set(selectedRoleIds.value)
     if (selected) ids.add(id)
@@ -235,6 +269,13 @@ function handleToggleAll(module: string, selected: boolean) {
     selectedDirectPermissionIds.value = ids
 }
 
+function toggleSite(id: number, selected: boolean) {
+    const ids = new Set(selectedSiteIds.value)
+    if (selected) ids.add(id)
+    else ids.delete(id)
+    selectedSiteIds.value = ids
+}
+
 async function handleSave() {
     if (!props.user) return
     saving.value = true
@@ -243,6 +284,7 @@ async function handleSave() {
             isAdmin: form.value.isAdmin,
             roles: Array.from(selectedRoleIds.value).map(id => `/api/roles/${id}`),
             directPermissions: Array.from(selectedDirectPermissionIds.value).map(id => `/api/permissions/${id}`),
+            sites: Array.from(selectedSiteIds.value).map(id => `/api/sites/${id}`),
         }, {
             toastSuccessMessage: t('admin.users.toast.updated'),
         })

frontend/modules/core/pages/admin/audit-log.vue

@@ -0,0 +1,405 @@
+<template>
+    <div>
+        <div class="flex items-center justify-between">
+            <h1 class="text-xl font-bold text-primary-500 sm:text-2xl">
+                {{ t('admin.auditLog.title') }}
+            </h1>
+        </div>
+
+        <!-- Filtres -->
+        <section class="mt-4 rounded border border-gray-200 bg-white p-4">
+            <!-- Labels uniformes au-dessus : les composants Malio sont utilises sans
+                 leur `label` flottant interne pour ne pas mixer deux patterns de label. -->
+            <div class="grid grid-cols-1 items-start gap-3 md:grid-cols-5">
+                <!-- TODO(malio-ui): remplacer par un composant Malio quand la lib
+                     exposera un datetime picker. Cf. exception documentee dans
+                     CLAUDE.md (section "Composants formulaires"). -->
+                <div>
+                    <label class="mb-1 block text-xs font-medium text-gray-600">
+                        {{ t('audit.filters.date_from') }}
+                    </label>
+                    <input
+                        v-model="filters.performedAtAfter"
+                        type="datetime-local"
+                        class="h-[40px] w-full rounded-md border border-m-muted bg-white px-3 text-sm outline-none focus-visible:border-2 focus-visible:border-m-primary"
+                    >
+                </div>
+                <!-- TODO(malio-ui): idem ci-dessus. -->
+                <div>
+                    <label class="mb-1 block text-xs font-medium text-gray-600">
+                        {{ t('audit.filters.date_to') }}
+                    </label>
+                    <input
+                        v-model="filters.performedAtBefore"
+                        type="datetime-local"
+                        class="h-[40px] w-full rounded-md border border-m-muted bg-white px-3 text-sm outline-none focus-visible:border-2 focus-visible:border-m-primary"
+                    >
+                </div>
+                <div>
+                    <label class="mb-1 block text-xs font-medium text-gray-600">
+                        {{ t('audit.filters.entity_type') }}
+                    </label>
+                    <div class="[&>div>div]:!mt-0">
+                        <MalioSelectCheckbox
+                            v-model="selectedEntityTypes"
+                            :options="entityTypeOptions"
+                            :display-select-all="true"
+                            :display-tag="true"
+                            min-width="w-full"
+                            text-field="text-sm"
+                            text-value="text-sm"
+                        />
+                    </div>
+                </div>
+                <div>
+                    <label class="mb-1 block text-xs font-medium text-gray-600">
+                        {{ t('audit.filters.user') }}
+                    </label>
+                    <MalioInputText
+                        v-model="performedByInput"
+                        icon-name="mdi:account-search"
+                        input-class="text-sm"
+                        group-class="h-10"
+                    />
+                </div>
+                <!-- TODO(malio-ui): remplacer par MalioSelect quand la lib
+                     supportera de maniere fiable des options a valeur string
+                     (cf. note Lesstime CLAUDE.md). Exception documentee dans
+                     CLAUDE.md (section "Composants formulaires"). -->
+                <div>
+                    <label class="mb-1 block text-xs font-medium text-gray-600">
+                        {{ t('audit.filters.action') }}
+                    </label>
+                    <select
+                        v-model="actionValue"
+                        class="h-[40px] w-full rounded-md border border-m-muted bg-white px-3 text-sm outline-none focus-visible:border-2 focus-visible:border-m-primary"
+                    >
+                        <option value="">{{ t('audit.filters.all_actions') }}</option>
+                        <option v-for="opt in actionOptions" :key="opt.value" :value="opt.value">
+                            {{ opt.label }}
+                        </option>
+                    </select>
+                </div>
+            </div>
+
+            <div class="mt-3 flex justify-end">
+                <MalioButton
+                    variant="tertiary"
+                    :label="t('audit.filters.reset')"
+                    button-class="text-xs"
+                    @click="resetFilters"
+                />
+            </div>
+        </section>
+
+        <!-- Tableau -->
+        <MalioDataTable
+            class="mt-4"
+            :columns="columns"
+            :items="rows"
+            :total-items="totalItems"
+            :page="filters.page ?? 1"
+            :per-page="filters.itemsPerPage ?? 10"
+            :per-page-options="[10, 25, 50]"
+            :empty-message="isFiltered ? t('audit.no_results') : t('audit.empty')"
+            @update:page="onPageChange"
+            @update:per-page="onPerPageChange"
+            @row-click="onRowClick"
+        >
+            <template #cell-action="{ item }">
+                <span
+                    class="inline-flex items-center rounded-full px-2 py-0.5 text-xs font-medium"
+                    :class="actionBadgeClass(item.action as string)"
+                >
+                    {{ t(`audit.action.${item.action}`) }}
+                </span>
+            </template>
+            <template #cell-entityType="{ item }">
+                <span class="font-mono text-xs">{{ item.entityType }}</span>
+            </template>
+            <template #cell-entityId="{ item }">
+                <span class="font-mono text-xs">{{ item.entityId }}</span>
+            </template>
+            <template #cell-summary="{ item }">
+                <span class="text-xs text-gray-600">{{ item.summary }}</span>
+            </template>
+        </MalioDataTable>
+
+        <!-- Drawer detail : diff courant + timeline complete de l'entite -->
+        <MalioDrawer
+            v-model="drawerOpen"
+            :title="drawerTitle"
+            drawer-class="max-w-2xl"
+        >
+            <div v-if="selectedEntry">
+                <AuditLogDetail :entry="selectedEntry" />
+                <div class="mt-4 border-t border-gray-200 pt-3">
+                    <h3 class="text-sm font-medium text-gray-700 mb-2">
+                        {{ selectedEntry.entityType }} #{{ selectedEntry.entityId }}
+                    </h3>
+                    <AuditTimeline
+                        :entity-type="selectedEntry.entityType"
+                        :entity-id="selectedEntry.entityId"
+                    />
+                </div>
+            </div>
+        </MalioDrawer>
+    </div>
+</template>
+
+<script setup lang="ts">
+import { computed, nextTick, onMounted, reactive, ref, watch } from 'vue'
+import type { AuditLogEntry, AuditLogFilters } from '~/shared/types'
+
+const { t } = useI18n()
+const { can } = usePermissions()
+const { fetchLogs, fetchEntityTypes } = useAuditLog()
+
+// Protection cote UI : le middleware `modules.global.ts` filtre deja les
+// routes desactivees, mais si quelqu'un atterit ici sans la permission on
+// renvoie une 403 plutot que de flasher un ecran vide.
+if (!can('core.audit_log.view')) {
+    throw createError({ statusCode: 403, statusMessage: 'Forbidden' })
+}
+
+useHead({ title: t('admin.auditLog.title') })
+
+// Etat des filtres : local uniquement, JAMAIS persiste dans l'URL (cf. regle
+// CLAUDE.md "Tableau : pas de persistance URL").
+const filters = reactive<AuditLogFilters>({
+    performedAtAfter:  undefined,
+    performedAtBefore: undefined,
+    entityType:        undefined,
+    performedBy:       undefined,
+    action:            undefined,
+    page:              1,
+    itemsPerPage:      10,
+})
+
+// Multi-selection entity_type : bind dedie au MalioSelectCheckbox.
+// Attention : les composants Malio attendent `{ label, value }` (pas `{ text }`).
+const selectedEntityTypes = ref<(string | number)[]>([])
+const entityTypes = ref<string[]>([])
+const entityTypeOptions = computed(() =>
+    entityTypes.value.map(t => ({ value: t, label: t })),
+)
+
+// Bind champ performedBy : MalioInputText attend `string | null`, on ne peut
+// pas binder directement un `string | undefined` reactive.
+const performedByInput = ref<string>('')
+
+// Action : MalioSelect ne gere pas fiablement des options a valeur string (cf.
+// note Lesstime CLAUDE.md). On utilise un `<select>` natif stylise comme les
+// inputs dates pour garder un look coherent. '' = "toutes les actions".
+const actionValue = ref<string>('')
+const actionOptions = [
+    { value: 'create', label: t('audit.action.create') },
+    { value: 'update', label: t('audit.action.update') },
+    { value: 'delete', label: t('audit.action.delete') },
+]
+
+const entries = ref<AuditLogEntry[]>([])
+const totalItems = ref(0)
+const loading = ref(false)
+
+const drawerOpen = ref(false)
+const selectedEntry = ref<AuditLogEntry | null>(null)
+
+const columns = [
+    { key: 'performedAt', label: t('admin.auditLog.table.performedAt') },
+    { key: 'performedBy', label: t('admin.auditLog.table.performedBy') },
+    { key: 'entityType',  label: t('admin.auditLog.table.entityType') },
+    { key: 'entityId',    label: t('admin.auditLog.table.entityId') },
+    { key: 'action',      label: t('admin.auditLog.table.action') },
+    { key: 'summary',     label: t('admin.auditLog.table.summary') },
+]
+
+// Transforme chaque AuditLogEntry en ligne compatible MalioDataTable.
+// On conserve `id` pour retrouver l'entry complete sur row-click.
+const rows = computed(() =>
+    entries.value.map(entry => ({
+        id: entry.id,
+        performedAt: formatDate(entry.performedAt),
+        performedBy: entry.performedBy,
+        entityType:  entry.entityType,
+        entityId:    entry.entityId,
+        action:      entry.action,
+        summary:     summarize(entry),
+    })),
+)
+
+const drawerTitle = computed(() =>
+    selectedEntry.value
+        ? `${selectedEntry.value.entityType} #${selectedEntry.value.entityId}`
+        : t('audit.detail_title'),
+)
+
+const isFiltered = computed(() =>
+    Boolean(filters.performedAtAfter || filters.performedAtBefore
+        || (Array.isArray(filters.entityType) ? filters.entityType.length : filters.entityType)
+        || filters.performedBy || filters.action),
+)
+
+// Anti-race : chaque fetch incremente un compteur ; seul le dernier en date
+// ecrit les resultats dans `entries`/`totalItems`. Evite qu'une reponse tardive
+// (reseau lent) n'ecrase les resultats d'une requete ulterieure.
+let requestToken = 0
+
+// Pendant un reset, on suspend temporairement les watchers pour ne pas
+// declencher 4 fetchs paralleles (un par champ mute). Les watchers Vue 3
+// sont asynchrones (microtask) : il faut attendre un `nextTick` avant de
+// les relacher, sinon le flag est deja `false` au moment ou ils s'executent
+// et les fetchs partent quand meme. Un seul loadEntries() est appele
+// explicitement apres la liberation.
+let watchersSuspended = false
+
+async function resetFilters(): Promise<void> {
+    watchersSuspended = true
+    filters.performedAtAfter = undefined
+    filters.performedAtBefore = undefined
+    filters.entityType = undefined
+    filters.performedBy = undefined
+    filters.action = undefined
+    filters.page = 1
+    selectedEntityTypes.value = []
+    performedByInput.value = ''
+    actionValue.value = ''
+    // Les watchers mute de Vue 3 se planifient en microtask : on attend
+    // leur execution avec le flag `true`, puis on libere.
+    await nextTick()
+    watchersSuspended = false
+    loadEntries()
+}
+
+async function loadEntries(): Promise<void> {
+    const token = ++requestToken
+    loading.value = true
+    try {
+        const data = await fetchLogs({
+            ...filters,
+            // Convertit datetime-local (YYYY-MM-DDTHH:MM) en ISO pour l'API.
+            performedAtAfter:  filters.performedAtAfter ? toIso(filters.performedAtAfter) : undefined,
+            performedAtBefore: filters.performedAtBefore ? toIso(filters.performedAtBefore) : undefined,
+        })
+        // Reponse obsolete (un fetch plus recent a ete lance entre-temps) :
+        // on ignore le resultat pour ne pas overwrite l'etat courant.
+        if (token !== requestToken) return
+        entries.value = data.member ?? []
+        totalItems.value = data.totalItems ?? 0
+    } finally {
+        if (token === requestToken) {
+            loading.value = false
+        }
+    }
+}
+
+// Debounce utilitaire pour le champ texte performedBy : evite un refetch a
+// chaque frappe (reseau + SQL) et laisse l'utilisateur finir sa saisie.
+function debounce<T extends (...args: never[]) => void>(fn: T, delay: number): T {
+    let timer: ReturnType<typeof setTimeout> | null = null
+    return ((...args: Parameters<T>) => {
+        if (null !== timer) clearTimeout(timer)
+        timer = setTimeout(() => fn(...args), delay)
+    }) as T
+}
+
+const debouncedReload = debounce(() => loadEntries(), 300)
+
+function toIso(localDateTime: string): string {
+    // datetime-local n'a pas de timezone : on assume heure locale et on
+    // laisse le navigateur generer l'ISO via Date().
+    return new Date(localDateTime).toISOString()
+}
+
+function formatDate(iso: string): string {
+    return new Date(iso).toLocaleString('fr-FR', {
+        dateStyle: 'short',
+        timeStyle: 'short',
+    })
+}
+
+function actionBadgeClass(action: string): string {
+    switch (action) {
+        case 'create': return 'bg-green-100 text-green-800'
+        case 'update': return 'bg-yellow-100 text-yellow-800'
+        case 'delete': return 'bg-red-100 text-red-800'
+        default: return 'bg-gray-100 text-gray-800'
+    }
+}
+
+function summarize(entry: AuditLogEntry): string {
+    const keys = Object.keys(entry.changes)
+    if (keys.length === 0) return '—'
+    if (keys.length <= 3) return keys.join(', ')
+    return `${keys.slice(0, 3).join(', ')}… (+${keys.length - 3})`
+}
+
+function onRowClick(item: Record<string, unknown>): void {
+    const entry = entries.value.find(e => e.id === item.id)
+    if (entry) {
+        selectedEntry.value = entry
+        drawerOpen.value = true
+    }
+}
+
+function onPageChange(value: number): void {
+    filters.page = value
+    loadEntries()
+}
+
+function onPerPageChange(value: number): void {
+    filters.itemsPerPage = value
+    filters.page = 1
+    loadEntries()
+}
+
+// Sync MalioSelectCheckbox -> filters.entityType + reset page 1 + reload.
+watch(selectedEntityTypes, values => {
+    if (watchersSuspended) return
+    filters.entityType = values.length > 0 ? values.map(v => String(v)) : undefined
+    filters.page = 1
+    loadEntries()
+})
+
+// Sync select action natif -> filters.action.
+watch(actionValue, value => {
+    if (watchersSuspended) return
+    filters.action = value === '' ? undefined : value
+    filters.page = 1
+    loadEntries()
+})
+
+// Sync performedBy : frappe utilisateur -> debounce 300ms pour eviter un
+// refetch par caractere. Le reset passe par debouncedReload egalement pour
+// coalescer si plusieurs watchers tirent en meme temps.
+watch(performedByInput, value => {
+    if (watchersSuspended) return
+    filters.performedBy = value === '' ? undefined : value
+    filters.page = 1
+    debouncedReload()
+})
+
+// Synchronisation reactive : tout changement de dates declenche un fetch +
+// reset de la pagination a la page 1.
+watch(
+    () => [filters.performedAtAfter, filters.performedAtBefore],
+    () => {
+        if (watchersSuspended) return
+        filters.page = 1
+        loadEntries()
+    },
+)
+
+onMounted(async () => {
+    // Charge les entity types en parallele de la liste principale : un
+    // echec du premier endpoint (ex: reseau flaky) ne doit pas empecher
+    // le tableau d'audit de s'afficher. En cas d'erreur, on laisse le
+    // filtre vide — l'utilisateur pourra quand meme consulter le journal.
+    try {
+        entityTypes.value = await fetchEntityTypes()
+    } catch {
+        entityTypes.value = []
+    }
+    await loadEntries()
+})
+</script>

frontend/modules/core/pages/admin/users.vue

@@ -52,6 +52,10 @@ const loading = ref(false)
 const drawerOpen = ref(false)
 const selectedUser = ref<UserListItem | null>(null)
 
+// La colonne "Sites" n'est plus affichee dans la liste : le detail des sites
+// rattaches est consulte/edite via le drawer (GET /users/{id}/rbac). Garder
+// un payload leger sur /api/users facilite la pagination et evite de fuiter
+// l'info cross-site aux users partageant juste un site avec l'appelant.
 const columns = [
     { key: 'username', label: t('admin.users.table.username') },
     { key: 'admin', label: t('admin.users.table.admin') },
@@ -66,18 +70,14 @@ const userItems = computed(() =>
         admin: user.isAdmin,
         roles: user.roles.length,
         directPermissions: user.directPermissions.length,
-    }))
+    })),
 )
 
 async function loadUsers() {
     loading.value = true
     try {
-        const data = await api.get<{ member: UserListItem[] }>(
-            '/users',
-            {},
-            { toast: false },
-        )
-        users.value = data.member
+        const usersData = await api.get<{ member: UserListItem[] }>('/users', {}, { toast: false })
+        users.value = usersData.member
     } finally {
         loading.value = false
     }

frontend/modules/core/pages/logout.vue

@@ -9,10 +9,25 @@ definePageMeta({ layout: 'auth' })
 
 const auth = useAuthStore()
 const { resetSidebar } = useSidebar()
+const { resetModules } = useModules()
+const { resetCurrentSite } = useCurrentSite()
+const { resetAuditLog } = useAuditLog()
 
 onMounted(async () => {
-    await auth.logout()
-    resetSidebar()
-    await navigateTo('/login')
+    try {
+        await auth.logout()
+    } finally {
+        // Les resets sont garantis meme si auth.logout() rejette : eviter
+        // qu'un user suivant (connecte sur le meme onglet) voie l'etat de
+        // l'ancien. Toutes les fonctions reset sont synchrones et ne
+        // peuvent pas throw (juste des assignations reactives).
+        // navigateTo est dans le finally pour garantir la redirection
+        // meme si auth.logout() lance une exception (ex: reseau coupé).
+        resetSidebar()
+        resetModules()
+        resetCurrentSite()
+        resetAuditLog()
+        await navigateTo('/login')
+    }
 })
 </script>

frontend/modules/sites/components/SiteDeleteModal.vue

@@ -0,0 +1,76 @@
+<template>
+    <Teleport to="body">
+        <Transition name="fade">
+            <div
+                v-if="modelValue"
+                class="fixed inset-0 z-50 flex items-center justify-center bg-black/50"
+                @click.self="cancel"
+            >
+                <div class="w-full max-w-md rounded-lg bg-white p-6 shadow-xl">
+                    <h3 class="text-lg font-semibold text-neutral-900">
+                        {{ t('admin.sites.delete.title') }}
+                    </h3>
+                    <p class="mt-3 text-sm text-neutral-600">
+                        {{ t('admin.sites.delete.message', { name: siteName }) }}
+                    </p>
+                    <div class="mt-6 flex justify-end gap-3">
+                        <MalioButton
+                            :label="t('common.cancel')"
+                            variant="secondary"
+                            @click="cancel"
+                        />
+                        <MalioButton
+                            :label="t('common.delete')"
+                            variant="danger"
+                            icon-name="mdi:delete-outline"
+                            icon-position="left"
+                            :disabled="loading"
+                            @click="confirm"
+                        />
+                    </div>
+                </div>
+            </div>
+        </Transition>
+    </Teleport>
+</template>
+
+<script setup lang="ts">
+const { t } = useI18n()
+
+defineProps<{
+    modelValue: boolean
+    siteName: string
+    loading: boolean
+}>()
+
+const emit = defineEmits<{
+    'update:modelValue': [value: boolean]
+    confirm: []
+}>()
+
+function cancel() {
+    emit('update:modelValue', false)
+}
+
+function confirm() {
+    emit('confirm')
+}
+
+function onKeydown(e: KeyboardEvent) {
+    if (e.key === 'Escape') cancel()
+}
+
+onMounted(() => document.addEventListener('keydown', onKeydown))
+onUnmounted(() => document.removeEventListener('keydown', onKeydown))
+</script>
+
+<style scoped>
+.fade-enter-active,
+.fade-leave-active {
+    transition: opacity 0.2s ease;
+}
+.fade-enter-from,
+.fade-leave-to {
+    opacity: 0;
+}
+</style>

frontend/modules/sites/components/SiteDrawer.vue

@@ -0,0 +1,185 @@
+<template>
+    <MalioDrawer
+        :model-value="modelValue"
+        :title="isEditMode ? t('admin.sites.editSite') : t('admin.sites.createSite')"
+        drawer-class="w-full max-w-lg"
+        @update:model-value="emit('update:modelValue', $event)"
+    >
+        <form class="flex flex-col gap-6 p-4" @submit.prevent="handleSave">
+            <MalioInputText
+                v-model="form.name"
+                :label="t('admin.sites.form.name')"
+                input-class="w-full"
+                required
+            />
+
+            <MalioInputText
+                v-model="form.street"
+                :label="t('admin.sites.form.street')"
+                input-class="w-full"
+                required
+            />
+
+            <MalioInputText
+                v-model="form.complement"
+                :label="t('admin.sites.form.complement')"
+                :placeholder="t('admin.sites.form.complementPlaceholder')"
+                input-class="w-full"
+            />
+
+            <!-- Code postal FR : masque "#####" (5 chiffres stricts) +
+                 maxLength en double securite. La regex backend validera la
+                 forme finale, le masque empeche juste la saisie de
+                 caracteres non numeriques. -->
+            <MalioInputText
+                v-model="form.postalCode"
+                :label="t('admin.sites.form.postalCode')"
+                input-class="w-full"
+                mask="#####"
+                max-length="5"
+                required
+            />
+
+            <MalioInputText
+                v-model="form.city"
+                :label="t('admin.sites.form.city')"
+                input-class="w-full"
+                required
+            />
+
+            <!-- Champ couleur avec preview puce -->
+            <div>
+                <label class="mb-1 block text-sm font-semibold text-neutral-700">
+                    {{ t('admin.sites.form.color') }}
+                </label>
+                <div class="flex items-center gap-3">
+                    <MalioInputText
+                        v-model="form.color"
+                        placeholder="#RRGGBB"
+                        input-class="w-full font-mono"
+                        required
+                    />
+                    <span
+                        :style="{ backgroundColor: isValidHex ? form.color : 'transparent' }"
+                        class="inline-block size-10 shrink-0 rounded-lg border border-neutral-200"
+                        :class="{ 'border-dashed': !isValidHex }"
+                    />
+                </div>
+                <p v-if="form.color && !isValidHex" class="mt-1 text-xs text-red-600">
+                    {{ t('admin.sites.form.colorInvalid') }}
+                </p>
+            </div>
+
+            <!-- Boutons -->
+            <div class="flex justify-end gap-3 border-t border-neutral-200 pt-4">
+                <MalioButton
+                    v-if="isEditMode"
+                    :label="t('common.delete')"
+                    variant="danger"
+                    icon-name="mdi:delete-outline"
+                    icon-position="left"
+                    @click="emit('delete')"
+                />
+                <MalioButton
+                    v-else
+                    :label="t('common.cancel')"
+                    variant="tertiary"
+                    @click="emit('update:modelValue', false)"
+                />
+                <MalioButton
+                    :label="t('common.save')"
+                    variant="primary"
+                    :disabled="saving || !isValidHex"
+                    @click="handleSave"
+                />
+            </div>
+        </form>
+    </MalioDrawer>
+</template>
+
+<script setup lang="ts">
+import type { Site } from '~/shared/types/sites'
+import { isValidSiteColor } from '~/shared/utils/color'
+
+const { t } = useI18n()
+const api = useApi()
+
+const props = defineProps<{
+    modelValue: boolean
+    site: Site | null
+}>()
+
+const emit = defineEmits<{
+    'update:modelValue': [value: boolean]
+    saved: []
+    delete: []
+}>()
+
+const saving = ref(false)
+
+const form = ref({
+    name: '',
+    street: '',
+    complement: '',
+    postalCode: '',
+    city: '',
+    color: '#000000',
+})
+
+const isEditMode = computed(() => props.site !== null)
+
+// Validation locale du format hex #RRGGBB avant envoi backend.
+const isValidHex = computed(() => isValidSiteColor(form.value.color))
+
+// Remplir le formulaire quand le site change
+watch(() => props.site, (site) => {
+    if (site) {
+        form.value.name = site.name
+        form.value.street = site.street
+        form.value.complement = site.complement ?? ''
+        form.value.postalCode = site.postalCode
+        form.value.city = site.city
+        form.value.color = site.color
+    } else {
+        form.value.name = ''
+        form.value.street = ''
+        form.value.complement = ''
+        form.value.postalCode = ''
+        form.value.city = ''
+        form.value.color = '#056CF2'
+    }
+}, { immediate: true })
+
+async function handleSave() {
+    if (!isValidHex.value) return
+    saving.value = true
+    try {
+        // Le champ complement est optionnel cote DB : on envoie null si vide
+        // pour que le backend stocke NULL plutot qu'une chaine vide.
+        const trimmedComplement = form.value.complement.trim()
+        const payload = {
+            name: form.value.name,
+            street: form.value.street,
+            complement: trimmedComplement === '' ? null : trimmedComplement,
+            postalCode: form.value.postalCode,
+            city: form.value.city,
+            color: form.value.color,
+        }
+
+        if (isEditMode.value && props.site) {
+            await api.patch(`/sites/${props.site.id}`, payload, {
+                toastSuccessMessage: t('admin.sites.toast.updated'),
+            })
+        } else {
+            await api.post('/sites', payload, {
+                toastSuccessMessage: t('admin.sites.toast.created'),
+            })
+        }
+
+        emit('saved')
+        emit('update:modelValue', false)
+    } finally {
+        saving.value = false
+    }
+}
+</script>

frontend/modules/sites/components/SiteSelector.vue

@@ -0,0 +1,92 @@
+<template>
+    <MalioSiteSelector
+        :sites="mappedSites"
+        :model-value="currentSite ? String(currentSite.id) : undefined"
+        :group-class="groupClass"
+        :tile-class="tileClass"
+        :label-class="labelClass"
+        :aria-label="t('sites.selector.ariaGroupLabel')"
+        @change="onChange"
+    />
+</template>
+
+<script setup lang="ts">
+const { t } = useI18n()
+const { currentSite, availableSites, syncFromAuth, switchSite } = useCurrentSite()
+const auth = useAuthStore()
+
+// Hydratation initiale + watcher : garde le state aligne sur auth.user
+// meme si un autre composant modifie auth.user.currentSite (ex: switch
+// depuis un autre onglet via /api/me/current-site, ou refresh du token).
+// Le rollback de switchSite restaure AUSSI auth.user.currentSite (voir
+// useCurrentSite::switchSite) pour eviter tout cycle watchEffect -> sync
+// qui ecraserait l'etat local apres une erreur PATCH.
+watchEffect(() => {
+    void auth.user?.currentSite
+    void auth.user?.sites
+    syncFromAuth()
+})
+
+// Conversion id number -> string : l'API de MalioSiteSelector (v1.4.0)
+// travaille en string alors que notre type metier Site utilise un int
+// (ID Doctrine). On reconvertit dans onChange.
+const mappedSites = computed(() =>
+    availableSites.value.map(site => ({
+        id: String(site.id),
+        name: site.name,
+        color: site.color,
+    })),
+)
+
+// Note de rendu : MalioSiteSelector v1.4.0 utilise UNE SEULE `activeColor`
+// (couleur du site courant) comme fond pour TOUS les tiles. Les inactifs
+// sont differencies uniquement par `opacity: 0.4`. Le texte est TOUJOURS
+// blanc (conforme maquette Figma) — charge aux admins de choisir des
+// couleurs de site suffisamment foncees pour garantir la lisibilite.
+// On surcharge `labelClass` uniquement pour imposer la taille 24px
+// (Figma), le reste des attributs tex (blanc, bold, uppercase, tracking)
+// vient du default Malio via twMerge.
+
+// Classes Tailwind passees a MalioSiteSelector via twMerge :
+//  - groupClass : hauteur fixe 72px (spec Figma) + scroll horizontal si
+//    debordement de 4+ sites sur petits ecrans.
+//  - tileClass : largeur minimale pour lisibilite + focus ring WCAG.
+//  - labelClass : taille de texte 24px imposee par la maquette Figma.
+//    Tailwind `text-2xl` = 1.5rem = 24px. Merge avec le default Malio
+//    (`text-white font-bold uppercase tracking-wide`).
+const groupClass = 'h-[72px] overflow-x-auto'
+const tileClass = 'min-w-[200px] flex items-center justify-center focus-visible:ring-2 focus-visible:ring-primary-500 focus-visible:ring-offset-2'
+const labelClass = 'text-2xl'
+
+async function onChange(site: { id: string; name: string; color: string }): Promise<void> {
+    const target = availableSites.value.find(s => String(s.id) === site.id)
+    if (!target) {
+        // Divergence entre mappedSites et availableSites (peut arriver si
+        // un refresh concurrent a vide la collection). On ignore mais on
+        // trace en dev pour faciliter le debug.
+        if (import.meta.dev) {
+            // Utilise console.error (pas warn) car la convention projet
+            // eslint n'autorise que error (no-console avec allow: ['error']).
+            console.error(`[SiteSelector] Site inconnu emis par MalioSiteSelector : id=${site.id}`)
+        }
+        return
+    }
+
+    // TODO(cross-tab) : si l'utilisateur a change de site dans un autre
+    // onglet, currentSite.value ici peut etre obsolete (state singleton
+    // non synchronise entre onglets). La garde ci-dessous est donc
+    // intentionnellement supprimee pour garantir qu'un clic sur le tile
+    // "actif selon cet onglet" envoie quand meme le PATCH et re-synchronise
+    // l'etat. Amelioration future : ecouter l'evenement `storage` sur la
+    // cle `coltura:site-switch` pour mettre a jour les onglets inactifs
+    // sans clic via auth.fetchUser() / auth.refreshUser().
+
+    try {
+        await switchSite(target)
+    } catch {
+        // L'erreur est deja toastee par useApi ; le composable a rollback
+        // le state local ET le store auth. Rien a faire ici au-dela de
+        // silencer pour eviter une unhandledRejection dans la console.
+    }
+}
+</script>

frontend/modules/sites/components/__tests__/SiteSelector.spec.ts

@@ -0,0 +1,189 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { mount, flushPromises } from '@vue/test-utils'
+import { computed, defineComponent, h, ref, watchEffect } from 'vue'
+import type { Site } from '~/shared/types/sites'
+import { useCurrentSite } from '~/modules/sites/composables/useCurrentSite'
+import SiteSelector from '../SiteSelector.vue'
+
+const mockPatch = vi.hoisted(() => vi.fn())
+const mockAuthUser = vi.hoisted(() => ({
+    value: null as { sites: Site[]; currentSite: Site | null } | null,
+}))
+
+// Stubs des auto-imports Nuxt. SiteSelector.vue utilise useCurrentSite,
+// useAuthStore, useI18n, watchEffect, computed sans import explicite
+// (pattern Nuxt). En Vitest on les expose comme globals.
+vi.stubGlobal('useCurrentSite', useCurrentSite)
+vi.stubGlobal('useApi', () => ({ patch: mockPatch }))
+vi.stubGlobal('useAuthStore', () => ({
+    get user() {
+        return mockAuthUser.value
+    },
+    setCurrentSite(site: Site | null) {
+        if (mockAuthUser.value) {
+            mockAuthUser.value.currentSite = site
+        }
+    },
+}))
+vi.stubGlobal('useI18n', () => ({ t: (key: string) => key }))
+vi.stubGlobal('watchEffect', watchEffect)
+vi.stubGlobal('computed', computed)
+vi.stubGlobal('ref', ref)
+// useSidebar et refreshNuxtData sont consommes par useCurrentSite apres
+// un switch reussi — stubs minimaux pour eviter ReferenceError au mount.
+vi.stubGlobal('useSidebar', () => ({ loadSidebar: vi.fn() }))
+vi.stubGlobal('refreshNuxtData', vi.fn())
+
+// Stub de MalioSiteSelector : on se contente de tracker les props recues
+// et de re-emettre `change` quand on le simule via `trigger`. Evite de
+// monter la vraie lib Malio (qui aurait besoin de tout Tailwind + twMerge).
+const MalioSiteSelectorStub = defineComponent({
+    name: 'MalioSiteSelector',
+    props: {
+        sites: { type: Array, required: true },
+        modelValue: { type: String, default: undefined },
+        groupClass: { type: String, default: '' },
+        tileClass: { type: String, default: '' },
+        labelClass: { type: String, default: '' },
+    },
+    emits: ['update:modelValue', 'change'],
+    setup(props, { emit }) {
+        return () => h('div', {
+            'data-testid': 'malio-site-selector',
+            'data-sites-count': String((props.sites as unknown[]).length),
+            'data-active-id': String(props.modelValue ?? ''),
+            'data-label-class': props.labelClass,
+        }, [
+            ...(props.sites as Array<{ id: string; name: string; color: string }>).map(site =>
+                h('button', {
+                    'data-testid': `tile-${site.id}`,
+                    // Emet les deux events comme le vrai MalioSiteSelector
+                    // (update:modelValue + change). Le wrapper n'ecoute que
+                    // change aujourd'hui, mais tracker les deux grave la
+                    // signature et prepare un eventuel v-model futur.
+                    onClick: () => {
+                        emit('update:modelValue', site.id)
+                        emit('change', site)
+                    },
+                }, site.name),
+            ),
+        ])
+    },
+})
+
+const SITE_A: Site = {
+    id: 1,
+    name: 'Chatellerault',
+    street: '14 All.',
+    complement: null,
+    postalCode: '86100',
+    city: 'Châtellerault',
+    color: '#056CF2',
+    fullAddress: '14 All.\n86100 Châtellerault',
+}
+const SITE_B: Site = {
+    id: 2,
+    name: 'Saint-Jean',
+    street: 'Z i',
+    complement: null,
+    postalCode: '17400',
+    city: 'Fontenet',
+    color: '#F3CB00',
+    fullAddress: 'Z i\n17400 Fontenet',
+}
+
+function mountSelector() {
+    return mount(SiteSelector, {
+        global: {
+            stubs: { MalioSiteSelector: MalioSiteSelectorStub },
+        },
+    })
+}
+
+describe('SiteSelector', () => {
+    beforeEach(() => {
+        mockPatch.mockReset()
+        mockAuthUser.value = {
+            sites: [SITE_A, SITE_B],
+            currentSite: SITE_A,
+        }
+    })
+
+    it('rend un tile par site autorise', () => {
+        const wrapper = mountSelector()
+        const stub = wrapper.find('[data-testid="malio-site-selector"]')
+
+        expect(stub.attributes('data-sites-count')).toBe('2')
+    })
+
+    it('marque le site courant via modelValue (string)', () => {
+        const wrapper = mountSelector()
+        const stub = wrapper.find('[data-testid="malio-site-selector"]')
+
+        // Chatellerault id=1 => '1'
+        expect(stub.attributes('data-active-id')).toBe('1')
+    })
+
+    it('passe labelClass="text-2xl" pour forcer 24px conforme Figma', () => {
+        // Decision design : texte blanc par defaut Malio mais taille 24px
+        // imposee par la maquette. Le reste des attributs text (white, bold,
+        // uppercase, tracking-wide) provient du default Malio via twMerge.
+        const wrapper = mountSelector()
+        const stub = wrapper.find('[data-testid="malio-site-selector"]')
+
+        expect(stub.attributes('data-label-class')).toBe('text-2xl')
+    })
+
+    it('clic sur un tile inactif declenche switchSite via PATCH /me/current-site', async () => {
+        mockPatch.mockResolvedValueOnce({})
+        const wrapper = mountSelector()
+
+        await wrapper.find('[data-testid="tile-2"]').trigger('click')
+        await flushPromises()
+
+        expect(mockPatch).toHaveBeenCalledWith(
+            '/me/current-site',
+            { site: '/api/sites/2' },
+            expect.anything(),
+        )
+    })
+
+    it('clic sur le tile deja actif declenche un PATCH (resync cross-tab)', async () => {
+        // Le court-circuit "si deja actif, ne rien faire" a ete supprime
+        // pour couvrir le cas ou un autre onglet a modifie le site courant
+        // cote serveur : un clic sur la tile localement "active" (etat
+        // potentiellement stale) force une resync via PATCH. Le prix est un
+        // PATCH superflu quand l'etat local est effectivement a jour.
+        const wrapper = mountSelector()
+
+        await wrapper.find('[data-testid="tile-1"]').trigger('click')
+        await flushPromises()
+
+        expect(mockPatch).toHaveBeenCalledWith(
+            '/me/current-site',
+            { site: '/api/sites/1' },
+            expect.anything(),
+        )
+    })
+
+    it('rollback visuel : sur erreur PATCH, data-active-id revient au site initial', async () => {
+        // Scenario : admin clique sur Saint-Jean alors que Chatellerault est
+        // actif, mais le serveur rejette (ex : 500). Apres rollback dans
+        // useCurrentSite, le composant doit re-afficher Chatellerault actif.
+        mockPatch.mockRejectedValueOnce(new Error('server down'))
+        const wrapper = mountSelector()
+
+        // Avant : Chatellerault (id=1) actif.
+        expect(wrapper.find('[data-testid="malio-site-selector"]').attributes('data-active-id'))
+            .toBe('1')
+
+        await wrapper.find('[data-testid="tile-2"]').trigger('click')
+        await flushPromises()
+
+        // Apres rollback : Chatellerault (id=1) de nouveau actif.
+        expect(wrapper.find('[data-testid="malio-site-selector"]').attributes('data-active-id'))
+            .toBe('1')
+        // Le store auth ne doit PAS avoir ete laisse avec SITE_B.
+        expect(mockAuthUser.value?.currentSite).toEqual(SITE_A)
+    })
+})

frontend/modules/sites/composables/__tests__/useCurrentSite.spec.ts

@@ -0,0 +1,219 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import type { Site } from '~/shared/types/sites'
+import { useCurrentSite } from '../useCurrentSite'
+
+const mockPatch = vi.hoisted(() => vi.fn())
+const mockAuthUser = vi.hoisted(() => ({
+    value: null as { sites: Site[]; currentSite: Site | null } | null,
+}))
+
+// Stub des auto-imports Nuxt consommes par le composable.
+vi.stubGlobal('useApi', () => ({ patch: mockPatch }))
+vi.stubGlobal('useAuthStore', () => ({
+    get user() {
+        return mockAuthUser.value
+    },
+    // Mime l'action Pinia ajoutee au ticket 3 review (S6) : mute
+    // user.currentSite si user present, no-op sinon.
+    setCurrentSite(site: Site | null) {
+        if (mockAuthUser.value) {
+            mockAuthUser.value.currentSite = site
+        }
+    },
+}))
+vi.stubGlobal('useI18n', () => ({
+    t: (key: string) => key,
+}))
+// useSidebar est consomme par useCurrentSite pour rafraichir la sidebar
+// apres un switch reussi. Stub minimal retournant un loadSidebar no-op.
+vi.stubGlobal('useSidebar', () => ({
+    loadSidebar: vi.fn(),
+}))
+// refreshNuxtData est appele apres un switch pour invalider les donnees
+// de page precedemment fetchees. Stub no-op pour les tests unitaires.
+vi.stubGlobal('refreshNuxtData', vi.fn())
+
+const SITE_A: Site = {
+    id: 1,
+    name: 'Chatellerault',
+    street: '14 All. d\'Argenson',
+    complement: null,
+    postalCode: '86100',
+    city: 'Châtellerault',
+    color: '#056CF2',
+    fullAddress: '14 All. d\'Argenson\n86100 Châtellerault',
+}
+const SITE_B: Site = {
+    id: 2,
+    name: 'Saint-Jean',
+    street: 'Z i',
+    complement: null,
+    postalCode: '17400',
+    city: 'Fontenet',
+    color: '#F3CB00',
+    fullAddress: 'Z i\n17400 Fontenet',
+}
+
+describe('useCurrentSite', () => {
+    beforeEach(() => {
+        mockPatch.mockReset()
+        mockAuthUser.value = {
+            sites: [SITE_A, SITE_B],
+            currentSite: SITE_A,
+        }
+        const { resetCurrentSite } = useCurrentSite()
+        resetCurrentSite()
+    })
+
+    it('syncFromAuth hydrate le state depuis le store auth', () => {
+        const { syncFromAuth, currentSite, availableSites } = useCurrentSite()
+
+        syncFromAuth()
+
+        expect(currentSite.value).toEqual(SITE_A)
+        expect(availableSites.value).toEqual([SITE_A, SITE_B])
+    })
+
+    it('syncFromAuth gere le cas user null (deconnecte)', () => {
+        mockAuthUser.value = null
+        const { syncFromAuth, currentSite, availableSites } = useCurrentSite()
+
+        syncFromAuth()
+
+        expect(currentSite.value).toBeNull()
+        expect(availableSites.value).toEqual([])
+    })
+
+    it('switchSite met a jour currentSite localement AVANT la requete (optimistic)', async () => {
+        mockPatch.mockImplementation(async () => {
+            // Au moment du resolve, currentSite est deja basculé.
+            const state = useCurrentSite()
+            expect(state.currentSite.value).toEqual(SITE_B)
+            return {}
+        })
+
+        const { syncFromAuth, switchSite, currentSite } = useCurrentSite()
+        syncFromAuth()
+        await switchSite(SITE_B)
+
+        expect(currentSite.value).toEqual(SITE_B)
+        expect(mockPatch).toHaveBeenCalledWith(
+            '/me/current-site',
+            { site: '/api/sites/2' },
+            expect.objectContaining({ toastSuccessMessage: expect.any(String) }),
+        )
+    })
+
+    it('switchSite propage le nouveau currentSite au store auth en cas de succes', async () => {
+        mockPatch.mockResolvedValueOnce({})
+        const { syncFromAuth, switchSite } = useCurrentSite()
+        syncFromAuth()
+
+        await switchSite(SITE_B)
+
+        expect(mockAuthUser.value?.currentSite).toEqual(SITE_B)
+    })
+
+    it('switchSite rollback le currentSite local si la requete echoue', async () => {
+        mockPatch.mockRejectedValueOnce(new Error('network'))
+        const { syncFromAuth, switchSite, currentSite } = useCurrentSite()
+        syncFromAuth()
+
+        await expect(switchSite(SITE_B)).rejects.toThrow('network')
+
+        expect(currentSite.value).toEqual(SITE_A)
+    })
+
+    it('switchSite ne propage pas au store auth en cas d\'echec', async () => {
+        mockPatch.mockRejectedValueOnce(new Error('network'))
+        const { syncFromAuth, switchSite } = useCurrentSite()
+        syncFromAuth()
+
+        await expect(switchSite(SITE_B)).rejects.toThrow()
+
+        expect(mockAuthUser.value?.currentSite).toEqual(SITE_A)
+    })
+
+    it('switching est vrai pendant la requete et faux apres', async () => {
+        let resolveRequest: (value: unknown) => void = () => {}
+        mockPatch.mockImplementation(
+            () => new Promise((resolve) => { resolveRequest = resolve }),
+        )
+
+        const { syncFromAuth, switchSite, switching } = useCurrentSite()
+        syncFromAuth()
+
+        const pending = switchSite(SITE_B)
+        expect(switching.value).toBe(true)
+
+        resolveRequest({})
+        await pending
+
+        expect(switching.value).toBe(false)
+    })
+
+    it('double switchSite concurrent : le second appel est un no-op silencieux', async () => {
+        let resolveRequest: (value: unknown) => void = () => {}
+        mockPatch.mockImplementation(
+            () => new Promise((resolve) => { resolveRequest = resolve }),
+        )
+
+        const { syncFromAuth, switchSite } = useCurrentSite()
+        syncFromAuth()
+
+        const first = switchSite(SITE_B)
+        await switchSite(SITE_A) // doit etre no-op (switching=true)
+
+        // Le second appel ne declenche pas de PATCH additionnel.
+        expect(mockPatch).toHaveBeenCalledTimes(1)
+
+        resolveRequest({})
+        await first
+    })
+
+    it('resetCurrentSite vide tout l\'etat singleton', () => {
+        const { syncFromAuth, resetCurrentSite, currentSite, availableSites, switching } = useCurrentSite()
+        syncFromAuth()
+        expect(currentSite.value).not.toBeNull()
+
+        resetCurrentSite()
+
+        expect(currentSite.value).toBeNull()
+        expect(availableSites.value).toEqual([])
+        expect(switching.value).toBe(false)
+    })
+
+    it('capture useI18n/useApi/useAuthStore UNE FOIS au setup (garde anti-regression bug runtime)', async () => {
+        // Historique : une premiere version du composable appelait useI18n()
+        // dans `switchSite` plutot qu'au top du setup. Consequence en runtime :
+        // l'appel depuis un event handler (click) hors contexte setup levait
+        // "Must be called at the top of a setup function". Ce test grave le
+        // contrat : useCurrentSite() DOIT capturer les 3 services a
+        // l'initialisation, pas paresseusement.
+        //
+        // Verification : on remplace useI18n par un mock qui throw au 2e appel.
+        // Si switchSite invoque useI18n() lui-meme, ce test cassera.
+        let i18nCallCount = 0
+        vi.stubGlobal('useI18n', () => {
+            i18nCallCount++
+            if (i18nCallCount > 1) {
+                throw new Error('useI18n called more than once — regression bug runtime')
+            }
+            return { t: (key: string) => key }
+        })
+
+        mockPatch.mockResolvedValueOnce({})
+        const { syncFromAuth, switchSite } = useCurrentSite()
+        syncFromAuth()
+
+        // Si switchSite appelait useI18n() en interne, ce call incrementerait
+        // i18nCallCount a 2 et throw. La garde du test passe uniquement si
+        // la capture a bien eu lieu au setup (i18nCallCount reste a 1).
+        await switchSite(SITE_B)
+
+        expect(i18nCallCount).toBe(1)
+
+        // Restaure le stub par defaut pour les tests suivants.
+        vi.stubGlobal('useI18n', () => ({ t: (key: string) => key }))
+    })
+})

frontend/modules/sites/composables/useCurrentSite.ts

@@ -0,0 +1,130 @@
+/**
+ * Composable de gestion du site courant (ticket 3 module Sites).
+ *
+ * Pattern aligne sur `useSidebar` : state singleton au niveau module,
+ * hydrate depuis `useAuthStore().user`, mute de maniere optimistic avec
+ * rollback si la requete PATCH `/api/me/current-site` echoue.
+ *
+ * Garantie d'unicite : le flag `switching` bloque les double-clicks
+ * concurrents. Le reset explicite est appele au logout
+ * (voir `modules/core/pages/logout.vue`).
+ *
+ * Auto-select : aucun. Le backend (`UserRbacProcessor::ensureCurrentSiteConsistency`)
+ * garantit deja l'invariant "user avec sites non vide => currentSite non null"
+ * apres tout PATCH /rbac. Le front consomme l'etat renvoye tel quel.
+ *
+ * Contrainte d'appel : `useCurrentSite()` doit etre invoque au top du
+ * `setup()` d'un composant (ou d'un autre composable appele au setup).
+ * Les dependances `useI18n`, `useApi` et `useAuthStore` sont resolues
+ * a l'initialisation et reutilisees par `switchSite` — ceci evite le
+ * "Must be called at the top of a setup function" qui se produirait
+ * si on les appelait paresseusement depuis une fonction async declenchee
+ * par un handler d'event (hors contexte setup).
+ */
+import { ref } from 'vue'
+import type { Site } from '~/shared/types/sites'
+import { onAuthSessionCleared } from '~/shared/stores/auth'
+
+const currentSite = ref<Site | null>(null)
+const availableSites = ref<Site[]>([])
+const switching = ref(false)
+
+// Enregistrement unique au niveau module (singleton) : quand clearSession()
+// est appelee par l'intercepteur 401 de useApi, le state local est purgé
+// de la meme facon qu'au logout explicite (logout.vue).
+onAuthSessionCleared(() => {
+    currentSite.value = null
+    availableSites.value = []
+    switching.value = false
+})
+
+export function useCurrentSite() {
+    // Resolution au setup : les 3 services doivent etre invoques dans un
+    // contexte composant. Leur capture ici permet a switchSite() de
+    // s'executer plus tard (handler de click, async) sans crash.
+    const auth = useAuthStore()
+    const api = useApi()
+    const { t } = useI18n()
+    const { loadSidebar } = useSidebar()
+
+    /**
+     * Synchronise le state singleton depuis le store auth. A appeler au
+     * mount du SiteSelector (ou via un watcher sur `auth.user`).
+     */
+    function syncFromAuth(): void {
+        availableSites.value = auth.user?.sites ?? []
+        currentSite.value = auth.user?.currentSite ?? null
+    }
+
+    /**
+     * Bascule le site courant. Optimistic UI : la mutation locale precede
+     * la requete HTTP. En cas d'echec (`api.patch` throw), l'etat local est
+     * restaure — le store auth n'a PAS ete muté a ce stade (la propagation
+     * `auth.setCurrentSite` se fait uniquement apres un succes HTTP), donc
+     * aucun rollback cote auth n'est necessaire.
+     *
+     * Garde anti-double-submit : si un switch est deja en vol, le second
+     * appel est un no-op silencieux.
+     */
+    async function switchSite(site: Site): Promise<void> {
+        if (switching.value) {
+            return
+        }
+
+        const previousLocal = currentSite.value
+        currentSite.value = site
+        switching.value = true
+
+        try {
+            await api.patch(
+                '/me/current-site',
+                { site: `/api/sites/${site.id}` },
+                { toastSuccessMessage: t('sites.selector.switchSuccess') },
+            )
+            // Propage au store auth via l'action dediee — plus tracable que
+            // la mutation directe et garantit la notification des watchers.
+            // N'est appele qu'apres un succes HTTP donc pas de rollback a
+            // prevoir sur cette ligne.
+            auth.setCurrentSite(site)
+
+            // Apres un switch reussi : recharger la sidebar (les filtres de
+            // modules peuvent dependre du site courant via SiteScopedQueryExtension)
+            // et invalider toutes les donnees de page pour eviter que l'utilisateur
+            // voie les donnees de l'ancien site sous un toast "Site change".
+            try {
+                await loadSidebar()
+            } catch {
+                // No-op : la sidebar non rafraichie n'est pas bloquante.
+            }
+            try {
+                await refreshNuxtData()
+            } catch {
+                // No-op : certaines pages n'ont pas de useAsyncData a invalider.
+            }
+        } catch (error) {
+            currentSite.value = previousLocal
+            throw error
+        } finally {
+            switching.value = false
+        }
+    }
+
+    /**
+     * Vide l'etat singleton. Appele au logout pour eviter qu'un user
+     * suivant (connecte sur le meme onglet) voie les sites de l'ancien.
+     */
+    function resetCurrentSite(): void {
+        currentSite.value = null
+        availableSites.value = []
+        switching.value = false
+    }
+
+    return {
+        currentSite,
+        availableSites,
+        switching,
+        switchSite,
+        syncFromAuth,
+        resetCurrentSite,
+    }
+}

frontend/modules/sites/nuxt.config.ts

@@ -0,0 +1 @@
+export default defineNuxtConfig({})

frontend/modules/sites/pages/admin/sites.vue

@@ -0,0 +1,170 @@
+<template>
+    <div>
+        <!-- En-tete -->
+        <div class="flex items-center justify-between">
+            <h1 class="text-xl font-bold text-primary-500 sm:text-2xl">
+                {{ t('admin.sites.title') }}
+            </h1>
+            <MalioButton
+                v-if="can('sites.manage')"
+                :label="t('admin.sites.newSite')"
+                icon-name="mdi:plus"
+                icon-position="left"
+                @click="openCreateDrawer"
+            />
+        </div>
+
+        <!-- Table des sites -->
+        <MalioDataTable
+            class="mt-6"
+            :columns="columns"
+            :items="siteItems"
+            :total-items="sites.length"
+            :row-clickable="canManage"
+            :empty-message="t('admin.sites.noSites')"
+            @row-click="onRowClick"
+        >
+            <template #cell-color="{ item }">
+                <span class="inline-flex items-center gap-2">
+                    <span
+                        :style="{ backgroundColor: item.color }"
+                        class="inline-block size-5 rounded-full border border-neutral-200"
+                    />
+                    <span class="font-mono text-xs">{{ item.color }}</span>
+                </span>
+            </template>
+            <template #cell-fullAddress="{ item }">
+                <span class="line-clamp-2 text-xs text-neutral-600">
+                    {{ item.fullAddress }}
+                </span>
+            </template>
+        </MalioDataTable>
+
+        <!-- Drawer creation/edition -->
+        <SiteDrawer
+            v-model="drawerOpen"
+            :site="selectedSite"
+            @saved="onSiteSaved"
+            @delete="onDeleteRequest"
+        />
+
+        <!-- Modale de suppression -->
+        <SiteDeleteModal
+            v-model="deleteModalOpen"
+            :site-name="siteToDelete?.name ?? ''"
+            :loading="deleting"
+            @confirm="handleDelete"
+        />
+    </div>
+</template>
+
+<script setup lang="ts">
+import type { Site } from '~/shared/types/sites'
+
+const { t } = useI18n()
+const api = useApi()
+const auth = useAuthStore()
+const { can } = usePermissions()
+const canManage = computed(() => can('sites.manage'))
+
+useHead({ title: t('admin.sites.title') })
+
+const sites = ref<Site[]>([])
+const loading = ref(false)
+
+const columns = [
+    { key: 'name', label: t('admin.sites.table.name') },
+    { key: 'city', label: t('admin.sites.table.city') },
+    { key: 'postalCode', label: t('admin.sites.table.postalCode') },
+    { key: 'color', label: t('admin.sites.table.color') },
+    { key: 'fullAddress', label: t('admin.sites.table.fullAddress') },
+]
+
+// Transformer les sites en items compatibles MalioDataTable.
+// `fullAddress` provient du getter computed cote backend (Site::getFullAddress)
+// au format multi-lignes — on l'aplatit en virgules pour l'affichage table.
+const siteItems = computed(() =>
+    sites.value.map(site => ({
+        id: site.id,
+        name: site.name,
+        city: site.city,
+        postalCode: site.postalCode,
+        color: site.color,
+        fullAddress: site.fullAddress.split('\n').join(', '),
+    })),
+)
+
+function getSiteById(id: number): Site | undefined {
+    return sites.value.find(s => s.id === id)
+}
+
+function onRowClick(item: Record<string, unknown>) {
+    const site = getSiteById(item.id as number)
+    if (site) openEditDrawer(site)
+}
+
+const drawerOpen = ref(false)
+const selectedSite = ref<Site | null>(null)
+const deleteModalOpen = ref(false)
+const siteToDelete = ref<Site | null>(null)
+const deleting = ref(false)
+
+async function loadSites() {
+    loading.value = true
+    try {
+        const data = await api.get<{ member: Site[] }>(
+            '/sites',
+            { itemsPerPage: 999 },
+            { toast: false },
+        )
+        sites.value = data.member
+    } finally {
+        loading.value = false
+    }
+}
+
+function openCreateDrawer() {
+    selectedSite.value = null
+    drawerOpen.value = true
+}
+
+function openEditDrawer(site: Site) {
+    selectedSite.value = site
+    drawerOpen.value = true
+}
+
+function onDeleteRequest() {
+    if (!selectedSite.value) return
+    siteToDelete.value = selectedSite.value
+    deleteModalOpen.value = true
+}
+
+async function handleDelete() {
+    if (!siteToDelete.value) return
+    deleting.value = true
+    try {
+        await api.delete(`/sites/${siteToDelete.value.id}`, {}, {
+            toastSuccessMessage: t('admin.sites.toast.deleted'),
+        })
+        deleteModalOpen.value = false
+        siteToDelete.value = null
+        drawerOpen.value = false
+        await loadSites()
+        // Rafraichit auth.user apres suppression d'un site : le backend
+        // applique ON DELETE SET NULL sur user.current_site_id, donc
+        // auth.user.currentSite peut etre devenu null sans que le front
+        // le sache. refreshUser() resynchronise depuis GET /api/me.
+        await auth.refreshUser()
+    } finally {
+        deleting.value = false
+    }
+}
+
+function onSiteSaved() {
+    loadSites()
+}
+
+onMounted(() => {
+    loadSites()
+})
+</script>

frontend/nuxt.config.ts

@@ -3,11 +3,21 @@ import { resolve } from 'node:path'
 
 // Auto-detect module layers: every directory under frontend/modules/ becomes a Nuxt layer.
 const modulesDir = resolve(__dirname, 'modules')
-const moduleLayers = existsSync(modulesDir)
+const moduleDirs = existsSync(modulesDir)
     ? readdirSync(modulesDir, { withFileTypes: true })
         .filter(d => d.isDirectory())
-        .map(d => `./modules/${d.name}`)
+        .map(d => d.name)
     : []
+const moduleLayers = moduleDirs.map(name => `./modules/${name}`)
+
+// Auto-detect composables dirs pour chaque layer module. Necessaire car le
+// `imports.dirs` explicite ci-dessous override le comportement par defaut
+// de Nuxt (qui scannerait composables/ de chaque layer automatiquement).
+// Sans ca, useCurrentSite / autres composables des modules ne seraient pas
+// resolus a l'execution — cf. ticket 3 bug detecte apres review.
+const moduleComposableDirs = moduleDirs
+    .map(name => `./modules/${name}/composables`)
+    .filter(path => existsSync(resolve(__dirname, path)))
 
 export default defineNuxtConfig({
     compatibilityDate: '2025-07-15',
@@ -51,6 +61,7 @@ export default defineNuxtConfig({
             'shared/composables',
             'shared/utils',
             'shared/stores',
+            ...moduleComposableDirs,
         ],
     },
     vite: {

frontend/package-lock.json

@@ -7,7 +7,7 @@
       "name": "coltura-frontend",
       "hasInstallScript": true,
       "dependencies": {
-        "@malio/layer-ui": "^1.3.0",
+        "@malio/layer-ui": "^1.4.2",
         "@nuxt/icon": "^2.2.1",
         "@nuxtjs/i18n": "^10.2.3",
         "@nuxtjs/tailwindcss": "^6.14.0",
@@ -22,6 +22,7 @@
         "@nuxt/eslint-config": "^1.9.0",
         "@typescript-eslint/eslint-plugin": "^8.44.1",
         "@typescript-eslint/parser": "^8.44.1",
+        "@vitejs/plugin-vue": "^6.0.6",
         "@vue/test-utils": "^2.4.6",
         "eslint": "^9.36.0",
         "eslint-plugin-vue": "^10.5.0",
@@ -83,6 +84,7 @@
       "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz",
       "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.29.0",
         "@babel/generator": "^7.29.0",
@@ -580,27 +582,6 @@
       "integrity": "sha512-/B8YJGPzaYq1NbsQmwgP8EZqg40NpTw4ZB3suuI0TplbxKHeK94jeaawLmVhCv+YwUnOpiWEz9U6SeThku/8JQ==",
       "license": "MIT"
     },
-    "node_modules/@emnapi/core": {
-      "version": "1.10.0",
-      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.10.0.tgz",
-      "integrity": "sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw==",
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "@emnapi/wasi-threads": "1.2.1",
-        "tslib": "^2.4.0"
-      }
-    },
-    "node_modules/@emnapi/runtime": {
-      "version": "1.10.0",
-      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.10.0.tgz",
-      "integrity": "sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA==",
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "tslib": "^2.4.0"
-      }
-    },
     "node_modules/@emnapi/wasi-threads": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.1.tgz",
@@ -1839,9 +1820,9 @@
       "license": "MIT"
     },
     "node_modules/@malio/layer-ui": {
-      "version": "1.3.0",
-      "resolved": "https://gitea.malio.fr/api/packages/MALIO-DEV/npm/%40malio%2Flayer-ui/-/1.3.0/layer-ui-1.3.0.tgz",
-      "integrity": "sha512-Gs4pnlWTWrhoF3QQKxYBu4IxN65O9B4bls7s+ONm05qvI2Y2x7N4VNFGjWvT+rNQ4BzHFCxSCzN4V3o6p0Q7uw==",
+      "version": "1.4.2",
+      "resolved": "https://gitea.malio.fr/api/packages/MALIO-DEV/npm/%40malio%2Flayer-ui/-/1.4.2/layer-ui-1.4.2.tgz",
+      "integrity": "sha512-H8f5FJXHFH9ZI1Jx4u9XE7w6VlR/d9Zr2encfQyMax1I0UZ3SiGBUjictcL33r0OhgsrgSmPq0J9aF6aab85Nw==",
       "dependencies": {
         "@nuxt/icon": "^2.2.1",
         "@nuxtjs/tailwindcss": "^6.14.0",
@@ -2186,6 +2167,7 @@
       "resolved": "https://registry.npmjs.org/@nuxt/kit/-/kit-4.4.2.tgz",
       "integrity": "sha512-5+IPRNX2CjkBhuWUwz0hBuLqiaJPRoKzQ+SvcdrQDbAyE+VDeFt74VpSFr5/R0ujrK4b+XnSHUJWdS72w6hsog==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "c12": "^3.3.3",
         "consola": "^3.4.2",
@@ -2288,6 +2270,7 @@
       "resolved": "https://registry.npmjs.org/@nuxt/schema/-/schema-4.4.2.tgz",
       "integrity": "sha512-/q6C7Qhiricgi+PKR7ovBnJlKTL0memCbA1CzRT+itCW/oeYzUfeMdQ35mGntlBoyRPNrMXbzuSUhfDbSCU57w==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@vue/shared": "^3.5.30",
         "defu": "^6.1.4",
@@ -3957,9 +3940,9 @@
       "license": "MIT"
     },
     "node_modules/@rolldown/pluginutils": {
-      "version": "1.0.0-rc.2",
-      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.2.tgz",
-      "integrity": "sha512-izyXV/v+cHiRfozX62W9htOAvwMo4/bXKDrQ+vom1L1qRuexPock/7VZDAhnpHCLNejd3NJ6hiab+tO0D44Rgw==",
+      "version": "1.0.0-rc.13",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.13.tgz",
+      "integrity": "sha512-3ngTAv6F/Py35BsYbeeLeecvhMKdsKm4AoOETVhAA+Qc8nrA2I0kF7oa93mE9qnIurngOSpMnQ0x2nQY2FPviA==",
       "license": "MIT"
     },
     "node_modules/@rollup/plugin-alias": {
@@ -4628,6 +4611,7 @@
       "integrity": "sha512-+qIYRKdNYJwY3vRCZMdJbPLJAtGjQBudzZzdzwQYkEPQd+PJGixUL5QfvCLDaULoLv+RhT3LDkwEfKaAkgSmNQ==",
       "devOptional": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "undici-types": "~7.19.0"
       }
@@ -4690,6 +4674,7 @@
       "integrity": "sha512-/Zb/xaIDfxeJnvishjGdcR4jmr7S+bda8PKNhRGdljDM+elXhlvN0FyPSsMnLmJUrVG9aPO6dof80wjMawsASg==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@typescript-eslint/scope-manager": "8.58.2",
         "@typescript-eslint/types": "8.58.2",
@@ -5206,12 +5191,12 @@
       }
     },
     "node_modules/@vitejs/plugin-vue": {
-      "version": "6.0.5",
-      "resolved": "https://registry.npmjs.org/@vitejs/plugin-vue/-/plugin-vue-6.0.5.tgz",
-      "integrity": "sha512-bL3AxKuQySfk1iGcBsQnoRVexTPJq0Z/ixFVM8OhVJAP6ZXXXLtM7NFKWhLl30Kg7uTBqIaPXbh+nuQCuBDedg==",
+      "version": "6.0.6",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-vue/-/plugin-vue-6.0.6.tgz",
+      "integrity": "sha512-u9HHgfrq3AjXlysn0eINFnWQOJQLO9WN6VprZ8FXl7A2bYisv3Hui9Ij+7QZ41F/WYWarHjwBbXtD7dKg3uxbg==",
       "license": "MIT",
       "dependencies": {
-        "@rolldown/pluginutils": "1.0.0-rc.2"
+        "@rolldown/pluginutils": "1.0.0-rc.13"
       },
       "engines": {
         "node": "^20.19.0 || >=22.12.0"
@@ -5469,6 +5454,7 @@
       "resolved": "https://registry.npmjs.org/@vue/compiler-sfc/-/compiler-sfc-3.5.32.tgz",
       "integrity": "sha512-8UYUYo71cP/0YHMO814TRZlPuUUw3oifHuMR7Wp9SNoRSrxRQnhMLNlCeaODNn6kNTJsjFoQ/kqIj4qGvya4Xg==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@babel/parser": "^7.29.2",
         "@vue/compiler-core": "3.5.32",
@@ -5712,6 +5698,7 @@
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz",
       "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==",
       "license": "MIT",
+      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -6099,6 +6086,7 @@
       "resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.8.2.tgz",
       "integrity": "sha512-riJjyv1/mHLIPX4RwiK+oW9/4c3TEUeORHKefKAKnZ5kyslbN+HXowtbaVEqt4IMUB7OXlfixcs6gsFeo/jhiQ==",
       "license": "Apache-2.0",
+      "peer": true,
       "peerDependencies": {
         "bare-abort-controller": "*"
       },
@@ -6296,6 +6284,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.10.12",
         "caniuse-lite": "^1.0.30001782",
@@ -6410,6 +6399,7 @@
       "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
       "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=8"
       }
@@ -6604,7 +6594,8 @@
       "version": "0.2.2",
       "resolved": "https://registry.npmjs.org/citty/-/citty-0.2.2.tgz",
       "integrity": "sha512-+6vJA3L98yv+IdfKGZHBNiGW5KHn22e/JwID0Strsz8h4S/csAu/OuICwxrg44k5MRiZHWIo8XXuJgQTriRP4w==",
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/clean-regexp": {
       "version": "1.0.0",
@@ -7657,6 +7648,7 @@
       "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.4.tgz",
       "integrity": "sha512-XoMjdBOwe/esVgEvLmNsD3IRHkm7fbKIUGvrleloJXUZgDHig2IPWNniv+GwjyJXzuNqVjlr5+4yVUZjycJwfQ==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.8.0",
         "@eslint-community/regexpp": "^4.12.1",
@@ -8815,6 +8807,7 @@
       "integrity": "sha512-GZZ9mKe8r646NUAf/zemnGbjYh4Bt8/MqASJY+pSm5ZDtc3YQox+4gsLI7yi1hba6o+eCsGxpHn5+iEVn31/FQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@types/node": ">=20.0.0",
         "@types/whatwg-mimetype": "^3.0.2",
@@ -11205,6 +11198,7 @@
       "resolved": "https://registry.npmjs.org/nuxt/-/nuxt-4.4.2.tgz",
       "integrity": "sha512-iWVFpr/YEqVU/CenqIHMnIkvb2HE/9f+q8oxZ+pj2et+60NljGRClCgnmbvGPdmNFE0F1bEhoBCYfqbDOCim3Q==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@dxup/nuxt": "^0.4.0",
         "@nuxt/cli": "^3.34.0",
@@ -12263,6 +12257,7 @@
       "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
       "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "deep-is": "^0.1.3",
         "fast-levenshtein": "^2.0.6",
@@ -12314,6 +12309,7 @@
       "resolved": "https://registry.npmjs.org/oxc-parser/-/oxc-parser-0.112.0.tgz",
       "integrity": "sha512-7rQ3QdJwobMQLMZwQaPuPYMEF2fDRZwf51lZ//V+bA37nejjKW5ifMHbbCwvA889Y4RLhT+/wLJpPRhAoBaZYw==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@oxc-project/types": "^0.112.0"
       },
@@ -12580,6 +12576,7 @@
       "resolved": "https://registry.npmjs.org/pinia/-/pinia-3.0.4.tgz",
       "integrity": "sha512-l7pqLUFTI/+ESXn6k3nu30ZIzW5E2WZF/LaHJEpoq6ElcLD+wduZoB2kBN19du6K/4FDpPMazY2wJr+IndBtQw==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@vue/devtools-api": "^7.7.7"
       },
@@ -12658,6 +12655,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "nanoid": "^3.3.11",
         "picocolors": "^1.1.1",
@@ -13201,6 +13199,7 @@
       "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz",
       "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "cssesc": "^3.0.0",
         "util-deprecate": "^1.0.2"
@@ -13820,6 +13819,7 @@
       "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.60.1.tgz",
       "integrity": "sha512-VmtB2rFU/GroZ4oL8+ZqXgSA38O6GR8KSIvWmEFv63pQ0G6KaBH9s07PO8XTXP4vI+3UJUEypOfjkGfmSBBR0w==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@types/estree": "1.0.8"
       },
@@ -14717,6 +14717,7 @@
       "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.19.tgz",
       "integrity": "sha512-3ofp+LL8E+pK/JuPLPggVAIaEuhvIz4qNcf3nA1Xn2o/7fb7s/TYpHhwGDv1ZU3PkBluUVaF8PyCHcm48cKLWQ==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@alloc/quick-lru": "^5.2.0",
         "arg": "^5.0.2",
@@ -15372,6 +15373,7 @@
       "dev": true,
       "hasInstallScript": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "napi-postinstall": "^0.3.0"
       },
@@ -15638,6 +15640,7 @@
       "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.2.tgz",
       "integrity": "sha512-Bby3NOsna2jsjfLVOHKes8sGwgl4TT0E6vvpYgnAYDIF/tie7MRaFthmKuHx1NSXjiTueXH3do80FMQgvEktRg==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "esbuild": "^0.27.0",
         "fdir": "^6.5.0",
@@ -16556,6 +16559,7 @@
       "resolved": "https://registry.npmjs.org/vue/-/vue-3.5.32.tgz",
       "integrity": "sha512-vM4z4Q9tTafVfMAK7IVzmxg34rSzTFMyIe0UUEijUCkn9+23lj0WRfA83dg7eQZIUlgOSGrkViIaCfqSAUXsMw==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@vue/compiler-dom": "3.5.32",
         "@vue/compiler-sfc": "3.5.32",
@@ -16600,6 +16604,7 @@
       "integrity": "sha512-Vxi9pJdbN3ZnVGLODVtZ7y4Y2kzAAE2Cm0CZ3ZDRvydVYxZ6VrnBhLikBsRS+dpwj4Jv4UCv21PTEwF5rQ9WXg==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "debug": "^4.4.0",
         "eslint-scope": "^8.2.0 || ^9.0.0",
@@ -16636,6 +16641,7 @@
       "resolved": "https://registry.npmjs.org/vue-i18n/-/vue-i18n-11.3.1.tgz",
       "integrity": "sha512-azq8fhVnCwJAw0iXW7i44h9P+Bj+snNuevBAaJ9bxn0I3YVsRU3deVFPNnTfZ2uxVJefGp83JUmL68ddCPw5Pw==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@intlify/core-base": "11.3.1",
         "@intlify/devtools-types": "11.3.1",

frontend/package.json

@@ -15,7 +15,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@malio/layer-ui": "^1.3.0",
+    "@malio/layer-ui": "^1.4.2",
     "@nuxt/icon": "^2.2.1",
     "@nuxtjs/i18n": "^10.2.3",
     "@nuxtjs/tailwindcss": "^6.14.0",
@@ -30,6 +30,7 @@
     "@nuxt/eslint-config": "^1.9.0",
     "@typescript-eslint/eslint-plugin": "^8.44.1",
     "@typescript-eslint/parser": "^8.44.1",
+    "@vitejs/plugin-vue": "^6.0.6",
     "@vue/test-utils": "^2.4.6",
     "eslint": "^9.36.0",
     "eslint-plugin-vue": "^10.5.0",

frontend/shared/components/audit/AuditLogDetail.vue

@@ -0,0 +1,98 @@
+<template>
+    <!--
+        Vue de detail d'une ligne d'audit : tableau field/old/new pour une
+        update, sinon snapshot complet sous forme de liste { cle: valeur }.
+    -->
+    <div class="text-sm">
+        <p class="text-xs text-gray-500 mb-2">
+            <span v-if="entry.ipAddress">IP: {{ entry.ipAddress }}</span>
+            <span v-if="entry.requestId" class="ml-3">Req: {{ entry.requestId }}</span>
+        </p>
+
+        <div v-if="entry.action === 'update'">
+            <!-- Tableau de comparaison field/old/new. MalioDataTable n'est
+                 pas adapte ici : cas presentationnel non-paginable (cf.
+                 exception documentee dans CLAUDE.md). -->
+            <table class="min-w-full border border-gray-200 text-xs">
+                <thead class="bg-gray-100">
+                    <tr>
+                        <th class="px-2 py-1 text-left font-medium">{{ t('audit.detail.field') }}</th>
+                        <th class="px-2 py-1 text-left font-medium">{{ t('audit.detail.old_value') }}</th>
+                        <th class="px-2 py-1 text-left font-medium">{{ t('audit.detail.new_value') }}</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    <tr v-for="(diff, field) in updateDiff" :key="field" class="border-t border-gray-200">
+                        <td class="px-2 py-1 font-mono">{{ field }}</td>
+                        <td class="px-2 py-1 text-red-700">{{ formatValue(diff.old) }}</td>
+                        <td class="px-2 py-1 text-green-700">{{ formatValue(diff.new) }}</td>
+                    </tr>
+                    <!-- Modifications de collections to-many : shape different
+                         { added: [ids], removed: [ids] } → affiche + et - sur
+                         la meme ligne pour garder une colonne field unique. -->
+                    <tr v-for="(diff, field) in collectionDiff" :key="`col-${field}`" class="border-t border-gray-200">
+                        <td class="px-2 py-1 font-mono">{{ field }}</td>
+                        <td class="px-2 py-1 text-red-700">
+                            <span v-if="diff.removed.length">− {{ diff.removed.join(', ') }}</span>
+                            <span v-else class="text-gray-400">∅</span>
+                        </td>
+                        <td class="px-2 py-1 text-green-700">
+                            <span v-if="diff.added.length">+ {{ diff.added.join(', ') }}</span>
+                            <span v-else class="text-gray-400">∅</span>
+                        </td>
+                    </tr>
+                </tbody>
+            </table>
+        </div>
+
+        <div v-else class="space-y-1">
+            <div v-for="(value, key) in entry.changes" :key="key" class="flex gap-2">
+                <span class="font-mono text-xs text-gray-600">{{ key }}:</span>
+                <span class="text-xs">{{ formatValue(value) }}</span>
+            </div>
+        </div>
+    </div>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue'
+import type { AuditLogEntry } from '~/shared/types'
+
+const props = defineProps<{ entry: AuditLogEntry }>()
+
+const { t } = useI18n()
+
+// Extrait les entrees au shape { old, new } pour les updates scalaires.
+const updateDiff = computed<Record<string, { old: unknown; new: unknown }>>(() => {
+    const out: Record<string, { old: unknown; new: unknown }> = {}
+    for (const [key, value] of Object.entries(props.entry.changes)) {
+        if (value && typeof value === 'object' && 'old' in value && 'new' in value) {
+            out[key] = value as { old: unknown; new: unknown }
+        }
+    }
+    return out
+})
+
+// Extrait les entrees au shape { added, removed } pour les modifications
+// de collections to-many (cf. AuditListener::captureCollectionChange).
+const collectionDiff = computed<Record<string, { added: unknown[]; removed: unknown[] }>>(() => {
+    const out: Record<string, { added: unknown[]; removed: unknown[] }> = {}
+    for (const [key, value] of Object.entries(props.entry.changes)) {
+        if (value && typeof value === 'object' && 'added' in value && 'removed' in value) {
+            const diff = value as { added: unknown; removed: unknown }
+            out[key] = {
+                added:   Array.isArray(diff.added) ? diff.added : [],
+                removed: Array.isArray(diff.removed) ? diff.removed : [],
+            }
+        }
+    }
+    return out
+})
+
+function formatValue(value: unknown): string {
+    if (value === null || value === undefined) return '∅'
+    if (typeof value === 'boolean') return value ? 'oui' : 'non'
+    if (typeof value === 'object') return JSON.stringify(value)
+    return String(value)
+}
+</script>

frontend/shared/components/audit/AuditTimeline.vue

@@ -0,0 +1,242 @@
+<template>
+    <!--
+        Garde permission : aucun rendu DOM ni appel API si l'utilisateur n'a
+        pas le droit. On wrappe le contenu dans un bloc v-if plutot qu'un div
+        vide pour eviter de polluer la layout quand le composant est embarque
+        dans une page qui rend deja sa propre structure.
+    -->
+    <div v-if="canView" class="audit-timeline">
+        <!-- Skeleton loader initial -->
+        <ul v-if="loading && entries.length === 0" class="space-y-3">
+            <li v-for="i in 3" :key="i" class="flex gap-3">
+                <div class="h-3 w-3 rounded-full bg-gray-200 animate-pulse mt-1.5" />
+                <div class="flex-1 space-y-2">
+                    <div class="h-3 w-1/3 rounded bg-gray-200 animate-pulse" />
+                    <div class="h-2 w-2/3 rounded bg-gray-100 animate-pulse" />
+                </div>
+            </li>
+        </ul>
+
+        <p
+            v-else-if="!loading && entries.length === 0"
+            class="text-sm text-gray-500 italic"
+        >
+            {{ t('audit.timeline.empty') }}
+        </p>
+
+        <ul v-else class="relative border-l-2 border-gray-200 pl-6 space-y-5">
+            <li
+                v-for="entry in entries"
+                :key="entry.id"
+                class="relative"
+            >
+                <!-- Dot sur la barre verticale. Couleur selon action. -->
+                <span
+                    class="absolute -left-[31px] top-1 h-3 w-3 rounded-full ring-2 ring-white"
+                    :class="dotClass(entry.action)"
+                />
+
+                <div class="flex items-start justify-between gap-4">
+                    <div class="flex-1 min-w-0">
+                        <p class="text-sm">
+                            <span class="font-medium">{{ entry.performedBy }}</span>
+                            <span class="text-gray-500"> — {{ t(`audit.action.${entry.action}`) }}</span>
+                        </p>
+
+                        <!-- Update : diff field-by-field. Create/Delete : liste des champs. -->
+                        <div v-if="entry.action === 'update'" class="mt-1 text-xs text-gray-600 space-y-0.5">
+                            <div v-for="(diff, field) in updateDiff(entry)" :key="field">
+                                <span class="font-medium">{{ field }}</span> :
+                                <span class="line-through text-red-600">{{ formatValue(diff.old) }}</span>
+                                <span class="mx-1">→</span>
+                                <span class="text-green-700">{{ formatValue(diff.new) }}</span>
+                            </div>
+                            <!-- Modifications de collections to-many. -->
+                            <div v-for="(diff, field) in collectionDiff(entry)" :key="`col-${field}`">
+                                <span class="font-medium">{{ field }}</span> :
+                                <span v-if="diff.removed.length" class="text-red-600">−{{ diff.removed.join(', ') }}</span>
+                                <span v-if="diff.removed.length && diff.added.length" class="mx-1"> </span>
+                                <span v-if="diff.added.length" class="text-green-700">+{{ diff.added.join(', ') }}</span>
+                            </div>
+                        </div>
+                        <div v-else class="mt-1 text-xs text-gray-600">
+                            {{ snapshotSummary(entry) }}
+                        </div>
+                    </div>
+
+                    <!-- Date relative FR + tooltip absolu -->
+                    <time
+                        :title="absoluteDate(entry.performedAt)"
+                        class="shrink-0 text-xs text-gray-500"
+                    >
+                        {{ relativeDate(entry.performedAt) }}
+                    </time>
+                </div>
+            </li>
+        </ul>
+
+        <!-- Lazy loading : bouton "Voir plus" si plus de pages. -->
+        <div v-if="hasMore" class="mt-4 flex justify-center">
+            <button
+                type="button"
+                class="px-3 py-1.5 text-sm rounded border border-gray-300 hover:bg-gray-50 disabled:opacity-60"
+                :disabled="loading"
+                @click="loadMore"
+            >
+                {{ loading ? t('common.loading') : t('audit.timeline.load_more') }}
+            </button>
+        </div>
+    </div>
+</template>
+
+<script setup lang="ts">
+import { computed, onMounted, ref, toRefs, watch } from 'vue'
+import type { AuditLogEntry } from '~/shared/types'
+
+const props = defineProps<{
+    entityType: string
+    entityId: string | number
+}>()
+
+const { entityType, entityId } = toRefs(props)
+
+const { t } = useI18n()
+const { can } = usePermissions()
+const { fetchEntityLogs } = useAuditLog()
+
+const canView = computed(() => can('core.audit_log.view'))
+
+const entries = ref<AuditLogEntry[]>([])
+const page = ref(1)
+const totalItems = ref(0)
+const loading = ref(false)
+
+// Lazy loading : 10 items par page cote UX. On aligne la pagination backend
+// (itemsPerPage=10 dans fetchEntityLogs) avec cette taille pour eviter de
+// slicer cote client — sinon les items 11-30 de chaque page etaient ignores.
+const PAGE_SIZE = 10
+
+// Anti-race : un utilisateur qui change rapidement d'entite affichee (ouvre
+// une ligne puis une autre dans le tableau admin) peut declencher deux fetchs
+// dont le premier repond en retard et ecrase l'etat de la seconde timeline.
+// On incremente un token a chaque fetch ; seule la derniere requete ecrit le
+// resultat. loadMore() est aussi protege : une reponse tardive append sur
+// une timeline dont l'entite a deja change serait visuellement confuse.
+let requestToken = 0
+
+const hasMore = computed(() => entries.value.length < totalItems.value)
+
+async function loadPage(targetPage: number, append: boolean): Promise<void> {
+    if (!canView.value) return
+
+    const token = ++requestToken
+    loading.value = true
+    try {
+        const data = await fetchEntityLogs(entityType.value, entityId.value, targetPage, PAGE_SIZE)
+        if (token !== requestToken) return
+        const items = data.member ?? []
+        entries.value = append ? [...entries.value, ...items] : items
+        totalItems.value = data.totalItems ?? entries.value.length
+        page.value = targetPage
+    } catch {
+        if (token !== requestToken) return
+        // Erreur silencieuse (timeline secondaire) — useApi n'affiche pas de toast avec toast: false.
+        entries.value = append ? entries.value : []
+    } finally {
+        if (token === requestToken) {
+            loading.value = false
+        }
+    }
+}
+
+async function loadMore(): Promise<void> {
+    await loadPage(page.value + 1, true)
+}
+
+function dotClass(action: string): string {
+    switch (action) {
+        case 'create': return 'bg-green-500'
+        case 'update': return 'bg-yellow-500'
+        case 'delete': return 'bg-red-500'
+        default: return 'bg-gray-400'
+    }
+}
+
+// Relativise une date en francais via Intl.RelativeTimeFormat. On selectionne
+// l'unite la plus grossiere possible (minutes < heures < jours < semaines).
+const rtf = new Intl.RelativeTimeFormat('fr', { numeric: 'auto' })
+
+function relativeDate(iso: string): string {
+    const diffMs = Date.now() - new Date(iso).getTime()
+    const diffSec = Math.round(diffMs / 1000)
+    const absSec = Math.abs(diffSec)
+
+    if (absSec < 60) return rtf.format(-Math.sign(diffSec) * Math.abs(diffSec), 'second')
+    if (absSec < 3600) return rtf.format(-Math.sign(diffSec) * Math.round(absSec / 60), 'minute')
+    if (absSec < 86400) return rtf.format(-Math.sign(diffSec) * Math.round(absSec / 3600), 'hour')
+    if (absSec < 604800) return rtf.format(-Math.sign(diffSec) * Math.round(absSec / 86400), 'day')
+    return rtf.format(-Math.sign(diffSec) * Math.round(absSec / 604800), 'week')
+}
+
+function absoluteDate(iso: string): string {
+    return new Date(iso).toLocaleString('fr-FR', {
+        dateStyle: 'medium',
+        timeStyle: 'short',
+    })
+}
+
+function updateDiff(entry: AuditLogEntry): Record<string, { old: unknown; new: unknown }> {
+    // Format attendu: { champ: { old, new } }. On filtre defensivement les
+    // valeurs qui ne correspondent pas a ce shape (pas d'erreur runtime).
+    const out: Record<string, { old: unknown; new: unknown }> = {}
+    for (const [key, value] of Object.entries(entry.changes)) {
+        if (value && typeof value === 'object' && 'old' in value && 'new' in value) {
+            const diff = value as { old: unknown; new: unknown }
+            out[key] = diff
+        }
+    }
+    return out
+}
+
+function collectionDiff(entry: AuditLogEntry): Record<string, { added: unknown[]; removed: unknown[] }> {
+    // Format to-many : { champ: { added: [ids], removed: [ids] } } produit
+    // par AuditListener::captureCollectionChange.
+    const out: Record<string, { added: unknown[]; removed: unknown[] }> = {}
+    for (const [key, value] of Object.entries(entry.changes)) {
+        if (value && typeof value === 'object' && 'added' in value && 'removed' in value) {
+            const diff = value as { added: unknown; removed: unknown }
+            out[key] = {
+                added:   Array.isArray(diff.added) ? diff.added : [],
+                removed: Array.isArray(diff.removed) ? diff.removed : [],
+            }
+        }
+    }
+    return out
+}
+
+function snapshotSummary(entry: AuditLogEntry): string {
+    const keys = Object.keys(entry.changes)
+    if (keys.length === 0) return '—'
+    if (keys.length <= 4) return keys.join(', ')
+    return `${keys.slice(0, 4).join(', ')}…`
+}
+
+function formatValue(value: unknown): string {
+    if (value === null || value === undefined) return '∅'
+    if (typeof value === 'boolean') return value ? 'oui' : 'non'
+    if (typeof value === 'object') return JSON.stringify(value)
+    return String(value)
+}
+
+// Reload si l'entite affichee change.
+watch([entityType, entityId], () => {
+    entries.value = []
+    page.value = 1
+    totalItems.value = 0
+    loadPage(1, false)
+})
+
+onMounted(() => {
+    loadPage(1, false)
+})
+</script>

frontend/shared/composables/__tests__/useModules.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { useModules } from '../useModules'
+
+// Mock de useApi : on peut scripter la reponse de /api/modules.
+const mockApiGet = vi.hoisted(() => vi.fn())
+
+// useApi est auto-importe par Nuxt en prod. En Vitest isole, on expose le
+// mock comme global pour que l'appel sans import dans useModules.ts
+// (pattern aligne sur useSidebar) fonctionne.
+vi.stubGlobal('useApi', () => ({ get: mockApiGet }))
+
+describe('useModules', () => {
+    beforeEach(() => {
+        mockApiGet.mockReset()
+        // Reset l'etat singleton entre tests.
+        const { resetModules } = useModules()
+        resetModules()
+    })
+
+    it('charge la liste des modules actifs depuis /api/modules', async () => {
+        mockApiGet.mockResolvedValueOnce({ modules: ['core', 'sites'] })
+        const { loadModules, activeModuleIds, loaded } = useModules()
+
+        await loadModules()
+
+        expect(mockApiGet).toHaveBeenCalledWith('/modules', {}, { toast: false })
+        expect(activeModuleIds.value).toEqual(['core', 'sites'])
+        expect(loaded.value).toBe(true)
+    })
+
+    it('isModuleActive retourne true pour un id present', async () => {
+        mockApiGet.mockResolvedValueOnce({ modules: ['core', 'sites'] })
+        const { loadModules, isModuleActive } = useModules()
+        await loadModules()
+
+        expect(isModuleActive('sites')).toBe(true)
+        expect(isModuleActive('core')).toBe(true)
+    })
+
+    it('isModuleActive retourne false pour un id absent', async () => {
+        mockApiGet.mockResolvedValueOnce({ modules: ['core'] })
+        const { loadModules, isModuleActive } = useModules()
+        await loadModules()
+
+        expect(isModuleActive('sites')).toBe(false)
+        expect(isModuleActive('inexistant')).toBe(false)
+    })
+
+    it('swallow les erreurs reseau et laisse la liste vide', async () => {
+        mockApiGet.mockRejectedValueOnce(new Error('boom'))
+        const { loadModules, activeModuleIds, loaded, isModuleActive } = useModules()
+
+        await loadModules()
+
+        expect(activeModuleIds.value).toEqual([])
+        expect(loaded.value).toBe(true)
+        expect(isModuleActive('sites')).toBe(false)
+    })
+
+    it('resetModules vide l\'etat', async () => {
+        mockApiGet.mockResolvedValueOnce({ modules: ['core', 'sites'] })
+        const { loadModules, resetModules, activeModuleIds, loaded } = useModules()
+        await loadModules()
+        expect(activeModuleIds.value.length).toBeGreaterThan(0)
+
+        resetModules()
+
+        expect(activeModuleIds.value).toEqual([])
+        expect(loaded.value).toBe(false)
+    })
+})

frontend/shared/composables/__tests__/useSidebar.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { useSidebar } from '../useSidebar'
+
+const mockApiGet = vi.hoisted(() => vi.fn())
+vi.stubGlobal('useApi', () => ({ get: mockApiGet }))
+
+/**
+ * Tests de l'invariant "loadSidebar ne reject jamais".
+ *
+ * Garantie utilisee par le middleware auth.global.ts qui fait un
+ * Promise.all([loadSidebar(), loadModules()]) — si l'un throw, le
+ * middleware echoue et toute l'app avec. Le swallow interne est donc
+ * load-bearing et ce test le verrouille.
+ */
+describe('useSidebar', () => {
+    beforeEach(() => {
+        mockApiGet.mockReset()
+        const { resetSidebar } = useSidebar()
+        resetSidebar()
+    })
+
+    it('charge sections et disabledRoutes depuis /api/sidebar', async () => {
+        mockApiGet.mockResolvedValueOnce({
+            sections: [{ label: 's', icon: 'i', items: [] }],
+            disabledRoutes: ['/foo'],
+        })
+        const { loadSidebar, sections, disabledRoutes, loaded } = useSidebar()
+
+        await loadSidebar()
+
+        expect(sections.value).toHaveLength(1)
+        expect(disabledRoutes.value).toEqual(['/foo'])
+        expect(loaded.value).toBe(true)
+    })
+
+    it('swallow les erreurs reseau sans rejeter (invariant middleware)', async () => {
+        mockApiGet.mockRejectedValueOnce(new Error('boom'))
+        const { loadSidebar, sections, disabledRoutes, loaded } = useSidebar()
+
+        // Assertion principale : la promise resout normalement meme sur erreur.
+        await expect(loadSidebar()).resolves.toBeUndefined()
+        expect(sections.value).toEqual([])
+        expect(disabledRoutes.value).toEqual([])
+        expect(loaded.value).toBe(true)
+    })
+
+    it('isRouteDisabled matche exactement un chemin', async () => {
+        mockApiGet.mockResolvedValueOnce({ sections: [], disabledRoutes: ['/foo'] })
+        const { loadSidebar, isRouteDisabled } = useSidebar()
+        await loadSidebar()
+
+        expect(isRouteDisabled('/foo')).toBe(true)
+        expect(isRouteDisabled('/foo/bar')).toBe(true)
+        expect(isRouteDisabled('/other')).toBe(false)
+    })
+
+    it('resetSidebar vide l\'etat', async () => {
+        mockApiGet.mockResolvedValueOnce({
+            sections: [{ label: 's', icon: 'i', items: [] }],
+            disabledRoutes: ['/foo'],
+        })
+        const { loadSidebar, resetSidebar, sections, loaded } = useSidebar()
+        await loadSidebar()
+        expect(loaded.value).toBe(true)
+
+        resetSidebar()
+
+        expect(sections.value).toEqual([])
+        expect(loaded.value).toBe(false)
+    })
+})

frontend/shared/composables/useAuditLog.ts

@@ -0,0 +1,139 @@
+import { ref } from 'vue'
+import type { AuditLogEntityTypes, AuditLogEntry, AuditLogFilters } from '~/shared/types'
+import type { HydraCollection } from '~/shared/utils/api'
+import { onAuthSessionCleared } from '~/shared/stores/auth'
+
+/**
+ * Cache module-level : evite un double-fetch si la page et le composant
+ * Timeline demandent la meme page simultanement. Volontairement minimaliste :
+ * on ne cache que le dernier resultat, pas un LRU par filtre — un CRM interne
+ * n'en a pas besoin et le cache complexe complique le reset.
+ *
+ * Un logout / 401 doit purger ce cache : on s'enregistre au callback
+ * `onAuthSessionCleared` expose par auth.ts.
+ */
+const lastCollection = ref<HydraCollection<AuditLogEntry> | null>(null)
+
+function resetAuditLog(): void {
+    lastCollection.value = null
+}
+
+// Auto-enregistrement singleton : si la session est invalidee (401,
+// logout) le cache est purge automatiquement, evitant qu'un autre user
+// connecte ensuite ne voit des donnees residuelles.
+onAuthSessionCleared(resetAuditLog)
+
+/**
+ * Traduit le modele front (camelCase) en query params API Platform
+ * (snake_case, avec la syntaxe performed_at[after] / [before]).
+ *
+ * @returns objet plat directement consommable par `useApi().get(url, query)`.
+ */
+function buildQuery(filters: AuditLogFilters | undefined): Record<string, string | number | string[]> {
+    const query: Record<string, string | number | string[]> = {}
+    if (!filters) return query
+
+    // `entity_type` : chaine simple ou liste pour un filtre multi-selection.
+    // Cote PHP, la syntaxe `entity_type[]=X&entity_type[]=Y` est requise pour
+    // que $_GET['entity_type'] soit un tableau (sinon "last wins").
+    if (Array.isArray(filters.entityType)) {
+        if (filters.entityType.length > 0) query['entity_type[]'] = filters.entityType
+    } else if (filters.entityType) {
+        query.entity_type = filters.entityType
+    }
+    if (filters.entityId) query.entity_id = filters.entityId
+    if (filters.action) query.action = filters.action
+    if (filters.performedBy) query.performed_by = filters.performedBy
+    if (filters.performedAtAfter) query['performed_at[after]'] = filters.performedAtAfter
+    if (filters.performedAtBefore) query['performed_at[before]'] = filters.performedAtBefore
+    if (filters.page) query.page = filters.page
+    if (filters.itemsPerPage) query.itemsPerPage = filters.itemsPerPage
+
+    return query
+}
+
+/**
+ * Composable partage entre la page globale d'audit (admin) et le composant
+ * Timeline. Expose des methodes de lecture + une fonction `resetAuditLog()`
+ * pour purger le cache (conforme a la regle CLAUDE.md sur les composables
+ * singletons, cf. `useSidebar.resetSidebar`).
+ */
+// Accept explicitement JSON-LD : API Platform 4 retourne un tableau PLAT (liste
+// d'items, sans envelope de pagination) sous `application/json`, et un objet
+// Hydra complet avec `member`, `totalItems` et `view` (first/last/next/previous)
+// sous `application/ld+json`. Pour obtenir `view` cote front — indispensable
+// a la pagination prev/next — on force donc ld+json.
+const JSONLD_HEADERS = { Accept: 'application/ld+json' } as const
+
+export function useAuditLog() {
+    const api = useApi()
+
+    async function fetchLogs(filters?: AuditLogFilters): Promise<HydraCollection<AuditLogEntry>> {
+        return api.get<HydraCollection<AuditLogEntry>>(
+            '/audit-logs',
+            buildQuery(filters),
+            { toast: false, headers: JSONLD_HEADERS },
+        )
+    }
+
+    /**
+     * Variante de `fetchLogs` qui met a jour le cache `lastCollection`.
+     * N'est utilisee que par la page admin — le composant Timeline appelle
+     * `fetchEntityLogs` qui bypass le cache pour ne pas polluer la reference
+     * page-level quand plusieurs timelines sont ouvertes.
+     */
+    async function fetchLogsCached(filters?: AuditLogFilters): Promise<HydraCollection<AuditLogEntry>> {
+        const data = await fetchLogs(filters)
+        lastCollection.value = data
+        return data
+    }
+
+    async function fetchLogById(id: string): Promise<AuditLogEntry> {
+        return api.get<AuditLogEntry>(`/audit-logs/${id}`, {}, { toast: false, headers: JSONLD_HEADERS })
+    }
+
+    /**
+     * Liste des valeurs distinctes de `entity_type` pour alimenter le filtre
+     * multi-selection. Alimente par un endpoint DBAL, aucune cache cote front
+     * (la liste peut evoluer a chaque nouvelle ecriture d'audit).
+     */
+    async function fetchEntityTypes(): Promise<string[]> {
+        const data = await api.get<AuditLogEntityTypes>(
+            '/audit-log-entity-types',
+            {},
+            { toast: false, headers: JSONLD_HEADERS },
+        )
+        return data.entityTypes ?? []
+    }
+
+    async function fetchEntityLogs(
+        entityType: string,
+        entityId: string | number,
+        page: number = 1,
+        itemsPerPage: number = 10,
+    ): Promise<HydraCollection<AuditLogEntry>> {
+        // Volontairement via `fetchLogs` (sans cache) pour ne pas ecraser
+        // `lastCollection` — la timeline peut etre rendue simultanement a
+        // la page globale et doit rester independante.
+        //
+        // Le backend pagine a 30 par defaut (paginationItemsPerPage) ; on
+        // passe explicitement itemsPerPage ici pour que la taille de page
+        // soit alignee avec l'UX timeline (10 items + bouton "Voir plus").
+        // Sans ce param, le client slice a 10 et rate 20 entrees par page.
+        return fetchLogs({
+            entityType,
+            entityId: String(entityId),
+            page,
+            itemsPerPage,
+        })
+    }
+
+    return {
+        lastCollection,
+        fetchLogs: fetchLogsCached,
+        fetchLogById,
+        fetchEntityLogs,
+        fetchEntityTypes,
+        resetAuditLog,
+    }
+}

frontend/shared/composables/useModules.ts

@@ -0,0 +1,49 @@
+/**
+ * Composable de lecture des modules actifs (source : `/api/modules`).
+ *
+ * State singleton au niveau module : `useSidebar` suit la meme convention.
+ * Chargement idempotent via le flag `loaded`, reset explicite au logout
+ * (voir pages/logout.vue).
+ */
+import { ref } from 'vue'
+
+const activeModuleIds = ref<string[]>([])
+const loaded = ref(false)
+
+export function useModules() {
+    async function loadModules() {
+        try {
+            const api = useApi()
+            const data = await api.get<{ modules: string[] }>(
+                '/modules',
+                {},
+                { toast: false },
+            )
+            activeModuleIds.value = data.modules ?? []
+            loaded.value = true
+        } catch {
+            // Swallow volontaire aligne sur useSidebar : un echec reseau ne
+            // doit pas bloquer le rendu, l'app affichera juste sans la
+            // granularite module (selector masque par defaut).
+            activeModuleIds.value = []
+            loaded.value = true
+        }
+    }
+
+    function isModuleActive(id: string): boolean {
+        return activeModuleIds.value.includes(id)
+    }
+
+    function resetModules() {
+        activeModuleIds.value = []
+        loaded.value = false
+    }
+
+    return {
+        activeModuleIds,
+        loaded,
+        loadModules,
+        isModuleActive,
+        resetModules,
+    }
+}

frontend/shared/composables/useSidebar.ts

@@ -1,3 +1,4 @@
+import { ref } from 'vue'
 import type { SidebarSection } from '~/shared/types'
 
 const sections = ref<SidebarSection[]>([])

frontend/shared/stores/auth.ts

@@ -1,7 +1,26 @@
 import { defineStore } from 'pinia'
 import type { UserData } from '~/shared/types/user-data'
+import type { Site } from '~/shared/types/sites'
 import { getCurrentUser, login, logout } from '~/shared/services/auth'
 
+/**
+ * Callbacks enregistres par les composables singletons qui doivent
+ * reinitialiser leur etat quand la session est invalidee (ex: expiration
+ * JWT, logout depuis un intercepteur 401). Utilise le pattern
+ * "callback registration" (Option C) pour eviter une dependance croisee
+ * depuis shared/ vers modules/ — chaque composable s'auto-enregistre.
+ */
+const onSessionClearedCallbacks: Array<() => void> = []
+
+/**
+ * Enregistre un callback a invoquer lorsque clearSession() est appelee.
+ * Typiquement invoque au setup-time du composable (module-level), donc
+ * une seule fois par instance de composable singleton.
+ */
+export function onAuthSessionCleared(cb: () => void): void {
+    onSessionClearedCallbacks.push(cb)
+}
+
 export const useAuthStore = defineStore('auth', {
     state: () => ({
         user: null as UserData | null,
@@ -16,6 +35,10 @@ export const useAuthStore = defineStore('auth', {
             this.user = null
             this.checked = true
             this.isLoading = false
+            // Notifie les composables singletons (useCurrentSite, etc.) afin
+            // qu'ils reinitialisation leur etat — necessaire quand la session
+            // est invalidee par un intercepteur 401 sans passer par logout.vue.
+            onSessionClearedCallbacks.forEach((cb) => cb())
         },
         async ensureSession() {
             if (this.checked) {
@@ -66,6 +89,18 @@ export const useAuthStore = defineStore('auth', {
             } catch {
                 // Silently fail — user session might have expired
             }
+        },
+        /**
+         * Action dediee au switch du site courant (ticket 3 module Sites).
+         * Utilisee par useCurrentSite apres la confirmation serveur, et en
+         * rollback si la requete PATCH echoue apres une mutation optimistic.
+         * Passer explicitement par une action plutot que muter user.currentSite
+         * directement garantit la tracabilite Pinia (devtools).
+         */
+        setCurrentSite(site: Site | null) {
+            if (this.user) {
+                this.user.currentSite = site
+            }
         }
     }
 })

frontend/shared/types/index.ts

@@ -9,3 +9,44 @@ export interface SidebarSection {
     icon: string
     items: SidebarItem[]
 }
+
+/**
+ * Entree d'audit telle qu'elle est renvoyee par GET /api/audit-logs.
+ *
+ * `changes` est un payload libre dont le format depend de `action` :
+ *  - `create` / `delete` : snapshot complet { champ: valeur } ;
+ *  - `update`            : diff { champ: { old, new } }.
+ */
+export interface AuditLogEntry {
+    id: string
+    entityType: string
+    entityId: string
+    action: 'create' | 'update' | 'delete'
+    changes: Record<string, unknown>
+    performedBy: string
+    performedAt: string
+    ipAddress: string | null
+    requestId: string | null
+}
+
+/**
+ * Filtres combinables en query params (AND) pour GET /api/audit-logs.
+ * Les bornes de date utilisent la syntaxe API Platform `performed_at[after]` /
+ * `performed_at[before]`.
+ */
+export interface AuditLogFilters {
+    /** Chaine pour un seul type, liste pour un filtre multi-selection. */
+    entityType?: string | string[]
+    entityId?: string
+    action?: string
+    performedBy?: string
+    performedAtAfter?: string
+    performedAtBefore?: string
+    page?: number
+    itemsPerPage?: number
+}
+
+export interface AuditLogEntityTypes {
+    id: string
+    entityTypes: string[]
+}

frontend/shared/types/rbac.ts

@@ -23,6 +23,20 @@ export interface UserListItem {
     directPermissions: string[]
 }
 
+/**
+ * Detail RBAC d'un user, renvoye par GET /api/users/{id}/rbac (groupe user:rbac:read).
+ * Utilise par UserRbacDrawer pour initialiser son formulaire avec l'etat complet
+ * (sites inclus). Le endpoint de liste /api/users reste volontairement leger et
+ * n'expose pas ces champs.
+ */
+export interface UserRbacDetail {
+    id: number
+    isAdmin: boolean
+    roles: string[]
+    directPermissions: string[]
+    sites: string[]
+}
+
 export interface EffectivePermission {
     code: string
     label: string

frontend/shared/types/sites.ts

@@ -0,0 +1,24 @@
+export interface Site {
+    id: number
+    name: string
+    street: string
+    complement: string | null
+    postalCode: string
+    city: string
+    color: string
+    /** Adresse complete reconstituee cote backend (getter computed). Lecture seule. */
+    fullAddress: string
+}
+
+/**
+ * Payload accepte en POST/PATCH /api/sites. Volontairement sans `fullAddress`
+ * (computed cote backend) ni champs read-only (id, timestamps).
+ */
+export interface SiteInput {
+    name: string
+    street: string
+    complement: string | null
+    postalCode: string
+    city: string
+    color: string
+}

frontend/shared/types/user-data.ts

@@ -1,3 +1,5 @@
+import type { Site } from './sites'
+
 export interface UserData {
     id: number
     username: string
@@ -6,4 +8,8 @@ export interface UserData {
     isAdmin: boolean
     /** Codes de permission effectifs de l'utilisateur, tries alphabetiquement, sans doublon. */
     effectivePermissions: string[]
+    /** Sites autorises pour l'utilisateur (ticket 2 module Sites). */
+    sites: Site[]
+    /** Site actuellement selectionne par l'utilisateur, ou null si aucun. */
+    currentSite: Site | null
 }

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

@@ -0,0 +1,42 @@
+import { describe, it, expect } from 'vitest'
+import { isValidSiteColor } from '../color'
+
+describe('isValidSiteColor', () => {
+    it('accepte un hex majuscule', () => {
+        expect(isValidSiteColor('#ABCDEF')).toBe(true)
+    })
+
+    it('accepte un hex minuscule', () => {
+        expect(isValidSiteColor('#abcdef')).toBe(true)
+    })
+
+    it('accepte un hex mixte', () => {
+        expect(isValidSiteColor('#0a1B2c')).toBe(true)
+    })
+
+    it('accepte les couleurs fixtures du projet', () => {
+        expect(isValidSiteColor('#056CF2')).toBe(true)
+        expect(isValidSiteColor('#F3CB00')).toBe(true)
+        expect(isValidSiteColor('#74BF04')).toBe(true)
+    })
+
+    it('rejette un nom CSS', () => {
+        expect(isValidSiteColor('red')).toBe(false)
+    })
+
+    it('rejette un hex court', () => {
+        expect(isValidSiteColor('#FFF')).toBe(false)
+    })
+
+    it('rejette un hex sans diese', () => {
+        expect(isValidSiteColor('FFFFFF')).toBe(false)
+    })
+
+    it('rejette un caractere non hex', () => {
+        expect(isValidSiteColor('#12345G')).toBe(false)
+    })
+
+    it('rejette une chaine vide', () => {
+        expect(isValidSiteColor('')).toBe(false)
+    })
+})

frontend/shared/utils/api.ts

@@ -1,8 +1,33 @@
+/**
+ * Schemas Hydra / API Platform 4.
+ *
+ * Important : API Platform 4 abandonne le prefixe `hydra:` dans les noms de
+ * proprietes (compare a la version 3). Un GET /api/audit-logs renvoie :
+ *   { "@context": ..., "@id": ..., "@type": "...",
+ *     "member": [...],
+ *     "totalItems": 30,
+ *     "view": { "@id": ..., "@type": "...", "first": ..., "next": ..., ... } }
+ *
+ * En `application/json` (sans ld), API Platform retourne un simple tableau
+ * plat sans ces metadonnees — on doit donc explicitement demander
+ * `application/ld+json` (via l'option `headers: { Accept: ... }` de useApi)
+ * pour avoir acces a la pagination.
+ */
+export interface HydraView {
+    '@id'?: string
+    '@type'?: string
+    first?: string
+    last?: string
+    next?: string
+    previous?: string
+}
+
 export interface HydraCollection<T> {
-    'hydra:member': T[]
-    'hydra:totalItems': number
+    member: T[]
+    totalItems: number
+    view?: HydraView
 }
 
 export function extractHydraMembers<T>(collection: HydraCollection<T>): T[] {
-    return collection['hydra:member'] ?? []
+    return collection.member ?? []
 }

frontend/shared/utils/color.ts

@@ -0,0 +1,19 @@
+/**
+ * Utilitaires de couleur partages.
+ *
+ * Aligne sur la regex backend stricte #RRGGBB (voir Site.php).
+ */
+
+const HEX_COLOR_REGEX = /^#[0-9A-Fa-f]{6}$/
+
+/**
+ * Valide qu'une chaine respecte le format #RRGGBB strict (7 caracteres,
+ * 6 chiffres hexadecimaux apres le #). Tolere la casse (majuscules,
+ * minuscules, mixte).
+ *
+ * Utilise cote front par SiteDrawer pour bloquer le submit avant l'envoi
+ * backend — miroir du pattern Symfony Assert\Regex sur Site::$color.
+ */
+export function isValidSiteColor(hex: string): boolean {
+    return HEX_COLOR_REGEX.test(hex)
+}

frontend/tailwind.config.ts

@@ -1,13 +1,26 @@
 import type {Config} from 'tailwindcss'
 
+/**
+ * Config Tailwind du projet Coltura.
+ *
+ * @nuxtjs/tailwindcss merge automatiquement les configs de chaque layer
+ * Nuxt declare dans `nuxt.config.ts:extends`. Le layer `@malio/layer-ui`
+ * apporte deja :
+ *  - borderRadius.malio (var CSS --m-radius)
+ *  - colors.m.{primary,surface,border,text,muted,bg,disabled,danger,
+ *    success,btn-*,site-blue,site-yellow,site-green}
+ *  - fontFamily.sans (Helvetica Neue)
+ *
+ * Cette config locale ne redeclare QUE ce qui est specifique a Coltura
+ * ou absent de la config Malio — evite la duplication et les derives.
+ */
 export default <Partial<Config>>{
     darkMode: 'class',
     theme: {
         extend: {
-            fontFamily: {
-                sans: ['"Helvetica Neue"', 'Helvetica', 'Arial', 'sans-serif']
-            },
             colors: {
+                // Couleurs applicatives Coltura (hors namespace `m` reserve
+                // au design system Malio partage).
                 primary: {
                     500: '#222783',
                 },
@@ -20,27 +33,10 @@ export default <Partial<Config>>{
                 blue: {
                     500: '#056CF2'
                 },
+                // Extensions au namespace `m` non couvertes par Malio 1.4.1.
                 m: {
-                    primary: 'rgb(var(--m-primary) / <alpha-value>)',
                     secondary: 'rgb(var(--m-secondary, 75 77 237) / <alpha-value>)',
                     tertiary: 'rgb(var(--m-tertiary, 243 244 248) / <alpha-value>)',
-                    border: 'rgb(var(--m-border) / <alpha-value>)',
-                    text: 'rgb(var(--m-text) / <alpha-value>)',
-                    muted: 'rgb(var(--m-muted) / <alpha-value>)',
-                    bg: 'rgb(var(--m-bg) / <alpha-value>)',
-                    surface: 'rgb(var(--m-surface) / <alpha-value>)',
-                    disabled: 'rgb(var(--m-disabled) / <alpha-value>)',
-                    danger: 'rgb(var(--m-danger) / <alpha-value>)',
-                    success: 'rgb(var(--m-success) / <alpha-value>)',
-                    'btn-primary': 'rgb(var(--m-btn-primary) / <alpha-value>)',
-                    'btn-primary-hover': 'rgb(var(--m-btn-primary-hover) / <alpha-value>)',
-                    'btn-primary-active': 'rgb(var(--m-btn-primary-active) / <alpha-value>)',
-                    'btn-secondary': 'rgb(var(--m-btn-secondary) / <alpha-value>)',
-                    'btn-secondary-hover': 'rgb(var(--m-btn-secondary-hover) / <alpha-value>)',
-                    'btn-secondary-active': 'rgb(var(--m-btn-secondary-active) / <alpha-value>)',
-                    'btn-danger': 'rgb(var(--m-btn-danger) / <alpha-value>)',
-                    'btn-danger-hover': 'rgb(var(--m-btn-danger-hover) / <alpha-value>)',
-                    'btn-danger-active': 'rgb(var(--m-btn-danger-active) / <alpha-value>)',
                 }
             }
         }

frontend/vitest.config.ts

@@ -1,7 +1,9 @@
 import { defineConfig } from 'vitest/config'
+import vue from '@vitejs/plugin-vue'
 import { fileURLToPath } from 'node:url'
 
 export default defineConfig({
+    plugins: [vue()],
     test: {
         environment: 'happy-dom',
         globals: true,

infra/dev/Dockerfile

@@ -81,7 +81,7 @@ RUN mkdir -p /var/www/.composer/cache/vcs \
 ENV COMPOSER_HOME=/var/www/.composer
 
 # Création de la structure du projet
-RUN mkdir /var/www/html/LOG
+RUN mkdir -p /var/www/html/LOG /var/www/html/var/cache /var/www/html/var/log
 
 ###> User ###
 ARG CURRENT_UID

makefile

@@ -44,6 +44,8 @@ install: copy-git-hook composer-install cache-clear node-use build-nuxtJS migrat
 reset: delete_built_dir remove_orphans build-without-cache start wait install
 
 composer-install:
+	$(EXEC_PHP_ROOT) mkdir -p /var/www/html/var/cache /var/www/html/var/log
+	$(EXEC_PHP_ROOT) chown -R www-data:www-data /var/www/html/var
 	$(EXEC_PHP) composer install
 	$(SYMFONY_CONSOLE) lexik:jwt:generate-keypair --skip-if-exists
 
@@ -85,10 +87,23 @@ migration-migrate:
 
 # Cree et initialise la base de test utilisee par PHPUnit
 # (le suffixe "_test" est applique automatiquement par Doctrine en APP_ENV=test)
-# Ordre : fixtures -> sync-permissions, car fixtures:load purge la table permission
+#
+# Ordre :
+#  1. migrations : crees le schema metier reel.
+#  2. schema:update : cree les tables mappees en `when@test` uniquement
+#     (ex: fake_site_aware_entity du ticket 4) qui n'ont pas de migration.
+#     `--force` sans `--complete` : ajoute les tables manquantes aux
+#     mappings sans drop les tables DB non mappees (no-op sur un schema
+#     deja aligne avec les migrations). Necessaire car le purger
+#     doctrine:fixtures:load essaie de DELETE toutes les tables connues
+#     via les mappings — si fake_site_aware_entity est mappe mais absent
+#     en DB, le purger crash.
+#  3. fixtures -> sync-permissions : fixtures:load purge la table permission,
+#     donc sync doit passer apres.
 test-db-setup:
 	$(SYMFONY_CONSOLE) doctrine:database:create --env=test --if-not-exists
 	$(SYMFONY_CONSOLE) doctrine:migrations:migrate --env=test --no-interaction
+	$(SYMFONY_CONSOLE) doctrine:schema:update --env=test --force
 	$(SYMFONY_CONSOLE) --env=test --no-interaction doctrine:fixtures:load
 	$(SYMFONY_CONSOLE) --env=test --no-interaction app:sync-permissions
 

migrations/Version20260417120000.php

@@ -0,0 +1,72 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DoctrineMigrations;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+/**
+ * Module Sites - Ticket 1/4 : brique fondatrice de donnees.
+ *
+ * Cree la table `site` qui porte les etablissements physiques de l'instance
+ * Coltura. La table est creee inconditionnellement : meme si SitesModule est
+ * desactive dans `config/modules.php`, la structure DB existe (pas de
+ * dependance dure depuis Core, mais pas de coin d'ombre schema non plus).
+ *
+ * Note sur l'emplacement du fichier :
+ *  Par convention projet les migrations vivent dans
+ *  `src/Module/{Module}/Infrastructure/Doctrine/Migrations/`, sauf pour les
+ *  initialisations critiques. Cf. CLAUDE.md (section "Regles d'architecture")
+ *  qui documente le bug de tri alphabetique de Doctrine Migrations 3.x avec
+ *  plusieurs `migrations_paths` : tant que ce n'est pas corrige, toute
+ *  migration d'initialisation (creation de table sur base vide) reste au
+ *  namespace racine `DoctrineMigrations` dans `migrations/`.
+ */
+final class Version20260417120000 extends AbstractMigration
+{
+    public function getDescription(): string
+    {
+        return 'Module Sites : creation de la table site (nom, ville, cp, couleur, adresse complete, timestamps).';
+    }
+
+    public function up(Schema $schema): void
+    {
+        // Creation de la table site. Toutes les colonnes sont NOT NULL :
+        //  - le champ `color` est contraint cote applicatif au format #RRGGBB
+        //    (7 caracteres), la longueur DB est dimensionnee en consequence ;
+        //  - `postal_code` est limite a 10 caracteres pour laisser marge a
+        //    d'eventuels formats etrangers plus tard, tout en le validant
+        //    strictement en 5 chiffres cote applicatif (format FR).
+        //
+        // Note : `full_address` est restructure au ticket 2 (migration
+        // Version20260420130000) en `street` + `complement` (nullable). La
+        // structure d'origine est conservee ici pour ne pas casser les devs
+        // qui ont deja joue cette migration en local.
+        $this->addSql(<<<'SQL'
+                CREATE TABLE site (
+                  id INT GENERATED BY DEFAULT AS IDENTITY NOT NULL,
+                  name VARCHAR(100) NOT NULL,
+                  city VARCHAR(100) NOT NULL,
+                  postal_code VARCHAR(10) NOT NULL,
+                  color VARCHAR(7) NOT NULL,
+                  full_address TEXT NOT NULL,
+                  created_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL,
+                  updated_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL,
+                  PRIMARY KEY (id)
+                )
+            SQL);
+
+        // Index unique sur le nom : garantit l'invariant metier "un site porte
+        // un nom unique" et permet a la contrainte UniqueEntity cote Symfony
+        // de s'appuyer sur une erreur DB en cas de race condition.
+        $this->addSql('CREATE UNIQUE INDEX uniq_site_name ON site (name)');
+    }
+
+    public function down(Schema $schema): void
+    {
+        // Drop direct : aucune FK depuis/vers la table dans ce ticket.
+        $this->addSql('DROP TABLE site');
+    }
+}

migrations/Version20260417150000.php

@@ -0,0 +1,88 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DoctrineMigrations;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+/**
+ * Module Sites - Ticket 2/4 : rattachement User ↔ Site.
+ *
+ * Introduit deux nouvelles structures sur le schema existant :
+ *  - la table de jointure `user_site` (M2M) : liste des sites autorises
+ *    pour chaque utilisateur.
+ *  - la colonne `"user".current_site_id` (M2O nullable) : site actuellement
+ *    selectionne par l'utilisateur pour son contexte UX.
+ *
+ * Cascades choisies :
+ *  - `user_site.user_id` → `ON DELETE CASCADE` : supprimer un user purge
+ *    naturellement ses rattachements.
+ *  - `user_site.site_id` → `ON DELETE CASCADE` : supprimer un site purge
+ *    tous les rattachements a ce site.
+ *  - `"user".current_site_id` → `ON DELETE SET NULL` : supprimer un site
+ *    repasse le currentSite des users concernes a NULL (plutot que de
+ *    detruire les users, ce qui serait catastrophique).
+ *
+ * Note sur l'emplacement du fichier (namespace racine `DoctrineMigrations`)
+ *  Conforme a l'exception documentee dans `CLAUDE.md` : tant que le bug de
+ *  tri alphabetique des MigrationsComparator Doctrine 3.x n'est pas resolu,
+ *  toute migration touchant a la topologie des tables (creation, FKs
+ *  cross-module) vit au namespace racine. La migration croise ici les tables
+ *  `"user"` (module Core) et `site` (module Sites) — placement racine donc
+ *  justifie pour garantir l'ordre d'execution deterministe vis-a-vis des
+ *  deux migrations d'init deja presentes.
+ */
+final class Version20260417150000 extends AbstractMigration
+{
+    public function getDescription(): string
+    {
+        return 'Module Sites : table user_site (M2M) + colonne user.current_site_id (M2O SET NULL).';
+    }
+
+    public function up(Schema $schema): void
+    {
+        // 1) Creation de la table de jointure user_site.
+        $this->addSql(<<<'SQL'
+                CREATE TABLE user_site (
+                  user_id INT NOT NULL,
+                  site_id INT NOT NULL,
+                  PRIMARY KEY (user_id, site_id)
+                )
+            SQL);
+        $this->addSql('CREATE INDEX IDX_user_site_user ON user_site (user_id)');
+        $this->addSql('CREATE INDEX IDX_user_site_site ON user_site (site_id)');
+        $this->addSql(<<<'SQL'
+                ALTER TABLE user_site
+                ADD CONSTRAINT FK_user_site_user
+                FOREIGN KEY (user_id) REFERENCES "user" (id) ON DELETE CASCADE
+            SQL);
+        $this->addSql(<<<'SQL'
+                ALTER TABLE user_site
+                ADD CONSTRAINT FK_user_site_site
+                FOREIGN KEY (site_id) REFERENCES site (id) ON DELETE CASCADE
+            SQL);
+
+        // 2) Ajout de la colonne nullable user.current_site_id + FK SET NULL.
+        $this->addSql('ALTER TABLE "user" ADD current_site_id INT DEFAULT NULL');
+        $this->addSql('CREATE INDEX IDX_user_current_site ON "user" (current_site_id)');
+        $this->addSql(<<<'SQL'
+                ALTER TABLE "user"
+                ADD CONSTRAINT FK_user_current_site
+                FOREIGN KEY (current_site_id) REFERENCES site (id) ON DELETE SET NULL
+            SQL);
+    }
+
+    public function down(Schema $schema): void
+    {
+        // Rollback en ordre inverse : enfants avant parents.
+        $this->addSql('ALTER TABLE "user" DROP CONSTRAINT FK_user_current_site');
+        $this->addSql('DROP INDEX IDX_user_current_site');
+        $this->addSql('ALTER TABLE "user" DROP current_site_id');
+
+        $this->addSql('ALTER TABLE user_site DROP CONSTRAINT FK_user_site_site');
+        $this->addSql('ALTER TABLE user_site DROP CONSTRAINT FK_user_site_user');
+        $this->addSql('DROP TABLE user_site');
+    }
+}

migrations/Version20260420130000.php

@@ -0,0 +1,78 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DoctrineMigrations;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+/**
+ * Module Sites - Ticket 2/4 : restructuration de l'adresse.
+ *
+ * Splitte la colonne `site.full_address` (TEXT NOT NULL, multi-lignes) en
+ * deux champs structures :
+ *  - `street` (VARCHAR(255) NOT NULL) : numero + voie ;
+ *  - `complement` (VARCHAR(255) DEFAULT NULL) : batiment, escalier, BP...
+ *
+ * L'adresse complete affichable est desormais reconstituee cote applicatif
+ * par Site::getFullAddress() (concatenation multi-lignes street\n[complement\n]CP ville)
+ * et exposee en lecture API via le groupe `site:read` + `me:read`. Plus de
+ * colonne DB redondante.
+ *
+ * Strategie de backfill (entre creation des nouvelles colonnes et drop de
+ * l'ancienne) :
+ *  - `street` recoit la totalite de l'ancien `full_address` pour ne perdre
+ *    aucune donnee. C'est imparfait pour les adresses multi-lignes mais
+ *    safe : aucun risque de tronquage si l'ancienne adresse depasse 255
+ *    chars (PostgreSQL leve une erreur explicite ; charge a l'admin de
+ *    nettoyer manuellement si necessaire).
+ *  - `complement` reste null : pas d'heuristique fiable pour decouper une
+ *    adresse libre en street/complement.
+ *
+ * Cette migration evite un `make db-reset` force pour les developpeurs
+ * ayant deja joue Version20260417120000 dans son etat initial (table site
+ * avec full_address). Les fixtures sont mises a jour en parallele.
+ */
+final class Version20260420130000 extends AbstractMigration
+{
+    public function getDescription(): string
+    {
+        return 'Module Sites : split full_address en street + complement (getter computed cote applicatif).';
+    }
+
+    public function up(Schema $schema): void
+    {
+        // 1) Ajout des nouvelles colonnes en mode permissif :
+        //    - `street` nullable temporairement pour permettre le backfill.
+        //    - `complement` definitivement nullable.
+        $this->addSql('ALTER TABLE site ADD street VARCHAR(255) DEFAULT NULL');
+        $this->addSql('ALTER TABLE site ADD complement VARCHAR(255) DEFAULT NULL');
+
+        // 2) Backfill : recopier full_address dans street pour ne pas perdre
+        //    les donnees existantes. Les retours a la ligne sont preserves
+        //    (PostgreSQL VARCHAR accepte \n) ; un admin pourra reformater
+        //    apres coup si besoin. Cas d'adresse > 255 chars : la migration
+        //    echoue cleanly (pas de tronquage silencieux).
+        $this->addSql('UPDATE site SET street = full_address');
+
+        // 3) Bascule street en NOT NULL une fois le backfill applique.
+        $this->addSql('ALTER TABLE site ALTER COLUMN street SET NOT NULL');
+
+        // 4) Drop de l'ancienne colonne full_address.
+        $this->addSql('ALTER TABLE site DROP full_address');
+    }
+
+    public function down(Schema $schema): void
+    {
+        // Recreation de full_address (NOT NULL via DEFAULT '' pour eviter
+        // un crash si la table a deja des lignes), puis backfill inverse,
+        // puis drop des nouvelles colonnes.
+        $this->addSql("ALTER TABLE site ADD full_address TEXT NOT NULL DEFAULT ''");
+        $this->addSql("UPDATE site SET full_address = street || COALESCE(E'\\n' || complement, '')");
+        $this->addSql('ALTER TABLE site ALTER COLUMN full_address DROP DEFAULT');
+
+        $this->addSql('ALTER TABLE site DROP street');
+        $this->addSql('ALTER TABLE site DROP complement');
+    }
+}

migrations/Version20260420202749.php

@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DoctrineMigrations;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+/**
+ * Audit log — Ticket 1 : table append-only `audit_log`.
+ *
+ * Table non geree par Doctrine ORM (aucune entite associee). Ecriture via
+ * DBAL uniquement par l'AuditLogWriter pour eviter la recursion du listener
+ * Doctrine (flush re-entrant). Colonnes en minuscules snake_case comme
+ * partout dans le projet.
+ *
+ * Type natif PostgreSQL `uuid` (16 octets) plutot que varchar(36) : index
+ * 40% plus petit sur une table append-only a croissance infinie.
+ *
+ * Migration placee au namespace racine `DoctrineMigrations` a cause du bug
+ * de tri FQCN alphabetique de Doctrine Migrations 3.x documente dans
+ * CLAUDE.md.
+ */
+final class Version20260420202749 extends AbstractMigration
+{
+    public function getDescription(): string
+    {
+        return 'Audit log : creation de la table append-only audit_log + index.';
+    }
+
+    public function up(Schema $schema): void
+    {
+        $this->addSql(<<<'SQL'
+            CREATE TABLE audit_log (
+                id uuid NOT NULL,
+                entity_type VARCHAR(100) NOT NULL,
+                entity_id VARCHAR(64) NOT NULL,
+                action VARCHAR(10) NOT NULL,
+                changes JSONB NOT NULL DEFAULT '{}'::jsonb,
+                performed_by VARCHAR(100) NOT NULL,
+                performed_at TIMESTAMP(0) WITH TIME ZONE NOT NULL,
+                ip_address VARCHAR(45) DEFAULT NULL,
+                request_id VARCHAR(36) DEFAULT NULL,
+                PRIMARY KEY(id)
+            )
+            SQL);
+
+        // Index pour recherche par entite (detail d'historique d'un objet).
+        $this->addSql('CREATE INDEX idx_audit_entity_time ON audit_log (entity_type, entity_id, performed_at)');
+
+        // Index pour recherche par utilisateur (qui a fait quoi).
+        $this->addSql('CREATE INDEX idx_audit_performer ON audit_log (performed_by, performed_at)');
+
+        // Index pour tri chronologique global (listing pagine DESC).
+        $this->addSql('CREATE INDEX idx_audit_time ON audit_log (performed_at)');
+    }
+
+    public function down(Schema $schema): void
+    {
+        $this->addSql('DROP TABLE audit_log');
+    }
+}

phpunit.dist.xml

@@ -16,6 +16,46 @@
         <server name="APP_ENV" value="test" force="true" />
         <server name="SHELL_VERBOSITY" value="-1" />
         <server name="KERNEL_CLASS" value="App\Kernel" />
+
+        <!-- ###+ symfony/framework-bundle ### -->
+        <!-- APP_ENV est force a "test" en <server> ci-dessus : on ne doit PAS
+             re-injecter "dev" ici via <env>, sinon la suite tourne sous
+             framework.test=false et `test.service_container` n'est pas cable
+             (cf. cc8d5 du fix pre-existant). -->
+        <env name="APP_ENV" value="test"/>
+        <env name="APP_SECRET" value=""/>
+        <env name="APP_SHARE_DIR" value="var/share"/>
+        <!-- ###- symfony/framework-bundle ### -->
+
+        <!-- ###+ symfony/routing ### -->
+        <!-- Configure how to generate URLs in non-HTTP contexts, such as CLI commands. -->
+        <!-- See https://symfony.com/doc/current/routing.html#generating-urls-in-commands -->
+        <env name="DEFAULT_URI" value="http://localhost"/>
+        <!-- ###- symfony/routing ### -->
+
+        <!-- ###+ doctrine/doctrine-bundle ### -->
+        <!-- Format described at https://www.doctrine-project.org/projects/doctrine-dbal/en/latest/reference/configuration.html#connecting-using-a-url -->
+        <!-- IMPORTANT: You MUST configure your server version, either here or in config/packages/doctrine.yaml -->
+        <!--  -->
+        <!-- DATABASE_URL="sqlite:///%kernel.project_dir%/var/data_%kernel.environment%.db" -->
+        <!-- DATABASE_URL="mysql://app:!ChangeMe!@127.0.0.1:3306/app?serverVersion=8.0.32&charset=utf8mb4" -->
+        <!-- DATABASE_URL="mysql://app:!ChangeMe!@127.0.0.1:3306/app?serverVersion=10.11.2-MariaDB&charset=utf8mb4" -->
+        <env name="DATABASE_URL" value="postgresql://app:!ChangeMe!@127.0.0.1:5432/app?serverVersion=16&amp;charset=utf8"/>
+        <!-- ###- doctrine/doctrine-bundle ### -->
+
+        <!-- ###+ lexik/jwt-authentication-bundle ### -->
+        <env name="JWT_SECRET_KEY" value="%kernel.project_dir%/config/jwt/private.pem"/>
+        <env name="JWT_PUBLIC_KEY" value="%kernel.project_dir%/config/jwt/public.pem"/>
+        <!-- Doit correspondre a la passphrase utilisee lors de la generation
+             des cles JWT (config/jwt/*.pem). En local dev, c'est la valeur
+             par defaut "change_me_in_env_local" du .env (override possible
+             via .env.test.local si les cles ont ete regenerees autrement). -->
+        <env name="JWT_PASSPHRASE" value="change_me_in_env_local"/>
+        <!-- ###- lexik/jwt-authentication-bundle ### -->
+
+        <!-- ###+ nelmio/cors-bundle ### -->
+        <env name="CORS_ALLOW_ORIGIN" value="'^https?://(localhost|127\.0\.0\.1)(:[0-9]+)?$'"/>
+        <!-- ###- nelmio/cors-bundle ### -->
     </php>
 
     <testsuites>

src/Module/Core/Application/DTO/AuditLogOutput.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Core\Application\DTO;
+
+use DateTimeImmutable;
+
+/**
+ * DTO de sortie pour une ligne d'audit.
+ *
+ * Readonly : aucune mutation possible apres hydration. La resource API
+ * Platform expose directement ce DTO (pas d'entite sous-jacente car la
+ * table audit_log n'est pas geree par l'ORM).
+ */
+final readonly class AuditLogOutput
+{
+    public function __construct(
+        public string $id,
+        public string $entityType,
+        public string $entityId,
+        public string $action,
+        /** @var array<string, mixed> */
+        public array $changes,
+        public string $performedBy,
+        public DateTimeImmutable $performedAt,
+        public ?string $ipAddress,
+        public ?string $requestId,
+    ) {}
+}

src/Module/Core/CoreModule.php

@@ -34,6 +34,7 @@ final class CoreModule
             ['code' => 'core.users.manage', 'label' => 'Gerer les utilisateurs (creer, editer, supprimer)'],
             ['code' => 'core.roles.view', 'label' => 'Voir les roles RBAC'],
             ['code' => 'core.roles.manage', 'label' => 'Gerer les roles et permissions'],
+            ['code' => 'core.audit_log.view', 'label' => 'Consulter le journal d\'audit'],
         ];
     }
 }

src/Module/Core/Domain/Entity/Permission.php

@@ -11,6 +11,7 @@ use ApiPlatform\Metadata\ApiResource;
 use ApiPlatform\Metadata\Get;
 use ApiPlatform\Metadata\GetCollection;
 use App\Module\Core\Infrastructure\Doctrine\DoctrinePermissionRepository;
+use App\Shared\Domain\Attribute\Auditable;
 use Doctrine\ORM\Mapping as ORM;
 use InvalidArgumentException;
 use Symfony\Component\Serializer\Attribute\Groups;
@@ -31,6 +32,7 @@ use Symfony\Component\Serializer\Attribute\Groups;
 #[ApiFilter(BooleanFilter::class, properties: ['orphan'])]
 #[ORM\Entity(repositoryClass: DoctrinePermissionRepository::class)]
 #[ORM\Table(name: 'permission')]
+#[Auditable]
 #[ORM\UniqueConstraint(name: 'uniq_permission_code', columns: ['code'])]
 #[ORM\Index(name: 'idx_permission_module', columns: ['module'])]
 #[ORM\Index(name: 'idx_permission_orphan', columns: ['orphan'])]

src/Module/Core/Domain/Entity/Role.php

@@ -15,6 +15,7 @@ use ApiPlatform\Metadata\Post;
 use App\Module\Core\Domain\Exception\SystemRoleDeletionException;
 use App\Module\Core\Infrastructure\ApiPlatform\State\Processor\RoleProcessor;
 use App\Module\Core\Infrastructure\Doctrine\DoctrineRoleRepository;
+use App\Shared\Domain\Attribute\Auditable;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\DBAL\Types\Types;
@@ -64,6 +65,7 @@ use Symfony\Component\Validator\Constraints as Assert;
 #[ApiFilter(BooleanFilter::class, properties: ['isSystem'])]
 #[ORM\Entity(repositoryClass: DoctrineRoleRepository::class)]
 #[ORM\Table(name: '`role`')]
+#[Auditable]
 #[ORM\UniqueConstraint(name: 'uniq_role_code', columns: ['code'])]
 #[ORM\Index(name: 'idx_role_is_system', columns: ['is_system'])]
 #[UniqueEntity(fields: ['code'], message: 'Un role avec ce code existe deja.')]

src/Module/Core/Domain/Entity/User.php

@@ -15,6 +15,16 @@ use App\Module\Core\Infrastructure\ApiPlatform\State\Processor\UserProcessor;
 use App\Module\Core\Infrastructure\ApiPlatform\State\Processor\UserRbacProcessor;
 use App\Module\Core\Infrastructure\ApiPlatform\State\Provider\MeProvider;
 use App\Module\Core\Infrastructure\Doctrine\DoctrineUserRepository;
+// Note architecture : User.php utilise SiteInterface (Shared) pour les
+// type-hints afin de ne pas coupler le module Core au module Sites.
+// La seule reference concrete a Site subsiste dans les metadonnees ORM
+// (targetEntity) via FQCN string, ce qui est obligatoire pour Doctrine.
+// SiteNotAuthorizedException est importee depuis Shared (sa location canonique).
+use App\Module\Sites\Domain\Entity\Site;
+use App\Shared\Domain\Attribute\Auditable;
+use App\Shared\Domain\Attribute\AuditIgnore;
+use App\Shared\Domain\Contract\SiteInterface;
+use App\Shared\Domain\Exception\SiteNotAuthorizedException;
 use DateTimeImmutable;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
@@ -41,6 +51,16 @@ use Symfony\Component\Serializer\Attribute\SerializedName;
         ),
         new Post(security: "is_granted('core.users.manage')", processor: UserPasswordHasherProcessor::class),
         new Patch(security: "is_granted('core.users.manage')", processor: UserPasswordHasherProcessor::class),
+        // Lecture dediee au drawer d'edition RBAC : meme URI que le PATCH pour une
+        // API symetrique, groupe `user:rbac:read` qui expose sites/roles/directPermissions.
+        // Garde `core.users.manage` (pas `.view`) car c'est l'endpoint de detail prevu
+        // pour l'edition, pas la consultation generale (elle passe par GET /users/{id}).
+        new Get(
+            name: 'user_rbac_get',
+            uriTemplate: '/users/{id}/rbac',
+            security: "is_granted('core.users.manage')",
+            normalizationContext: ['groups' => ['user:rbac:read']],
+        ),
         new Patch(
             name: 'user_rbac_patch',
             uriTemplate: '/users/{id}/rbac',
@@ -55,6 +75,7 @@ use Symfony\Component\Serializer\Attribute\SerializedName;
 )]
 #[ORM\Entity(repositoryClass: DoctrineUserRepository::class)]
 #[ORM\Table(name: '`user`')]
+#[Auditable]
 class User implements UserInterface, PasswordAuthenticatedUserInterface
 {
     #[ORM\Id]
@@ -107,10 +128,51 @@ class User implements UserInterface, PasswordAuthenticatedUserInterface
     #[Groups(['me:read', 'user:list', 'user:rbac:write', 'user:rbac:read'])]
     private Collection $directPermissions;
 
+    /**
+     * Sites autorises pour l'utilisateur (ticket 2 du module Sites).
+     *
+     * Relation ManyToMany avec table de jointure `user_site`. Fetch LAZY :
+     * le chargement est defere jusqu'a l'acces explicite a la collection.
+     * MeProvider (ou un futur provider avec JOIN FETCH) est responsable de
+     * precharger cette collection pour /api/me afin d'eviter N+1.
+     *
+     * Le groupe `user:list` a ete retire deliberement (securite : evite
+     * de fuiter la liste des sites de chaque user via GET /api/users).
+     *
+     * @var Collection<int, Site>
+     */
+    #[ORM\ManyToMany(targetEntity: 'App\Module\Sites\Domain\Entity\Site', inversedBy: 'users', fetch: 'LAZY')]
+    #[ORM\JoinTable(name: 'user_site')]
+    #[Groups(['me:read', 'user:rbac:read', 'user:rbac:write'])]
+    private Collection $sites;
+
+    /**
+     * Site courant selectionne par l'utilisateur (ticket 2 du module Sites).
+     *
+     * Relation ManyToOne nullable : un user peut ne pas avoir encore choisi
+     * de site actif (par ex. apres creation avant premier login). La FK porte
+     * `onDelete: SET NULL` pour que la suppression d'un site ne detruise pas
+     * les users qui le pointaient — ils repassent simplement a `null`.
+     *
+     * Doit TOUJOURS pointer vers un site present dans `$sites`. L'invariant
+     * est enforce par UserRbacProcessor qui bascule automatiquement a `null`
+     * si le site courant est retire des sites autorises.
+     *
+     * Fetch LAZY : MeProvider (ou un futur provider avec JOIN FETCH) assure
+     * le prechargement pour /api/me. Le groupe `user:list` a ete retire
+     * deliberement (securite : evite de fuiter le site actif via /api/users).
+     */
+    #[ORM\ManyToOne(targetEntity: 'App\Module\Sites\Domain\Entity\Site', fetch: 'LAZY')]
+    #[ORM\JoinColumn(name: 'current_site_id', referencedColumnName: 'id', nullable: true, onDelete: 'SET NULL')]
+    #[Groups(['me:read'])]
+    private ?SiteInterface $currentSite = null;
+
     #[ORM\Column]
+    #[AuditIgnore]
     private ?string $password = null;
 
     #[Groups(['user:write'])]
+    #[AuditIgnore]
     private ?string $plainPassword = null;
 
     #[ORM\Column(type: 'datetime_immutable')]
@@ -121,6 +183,7 @@ class User implements UserInterface, PasswordAuthenticatedUserInterface
         $this->createdAt         = new DateTimeImmutable();
         $this->rbacRoles         = new ArrayCollection();
         $this->directPermissions = new ArrayCollection();
+        $this->sites             = new ArrayCollection();
     }
 
     public function getId(): ?int
@@ -313,4 +376,95 @@ class User implements UserInterface, PasswordAuthenticatedUserInterface
     {
         $this->plainPassword = null;
     }
+
+    /**
+     * @return Collection<int, Site>
+     */
+    public function getSites(): Collection
+    {
+        return $this->sites;
+    }
+
+    /**
+     * Idempotent : ajouter deux fois le meme site n'entraine pas de doublon.
+     * Synchronise la collection inverse Site::$users en memoire pour eviter
+     * un etat incoherent entre les deux cotes de la M2M dans une meme
+     * session Doctrine (cf. ticket 2 review point #1).
+     *
+     * Le parametre est type SiteInterface pour eviter le couplage Core → Sites.
+     * En pratique seule App\Module\Sites\Domain\Entity\Site est passee ici.
+     */
+    public function addSite(SiteInterface $site): static
+    {
+        if (!$this->sites->contains($site)) {
+            $this->sites->add($site);
+            // @phpstan-ignore-next-line : Site concret toujours passe en pratique
+            $site->addUser($this);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Retire un site de la collection + maintient la collection inverse en
+     * memoire (cf. addSite). Attention : ne met PAS a jour `$currentSite`
+     * si le site retire en etait le courant — cet invariant est enforce
+     * par UserRbacProcessor (cote applicatif) ou doit etre maintenu
+     * explicitement par l'appelant. Voir Risque 2 du ticket 2 spec.
+     */
+    public function removeSite(SiteInterface $site): static
+    {
+        if ($this->sites->removeElement($site)) {
+            // @phpstan-ignore-next-line : Site concret toujours passe en pratique
+            $site->removeUser($this);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Garde applicative rapide : teste la presence d'un site dans la
+     * collection autorisee, via comparaison d'identite d'objet Doctrine.
+     * Utilise par CurrentSiteProcessor pour valider un switch.
+     */
+    public function hasSite(SiteInterface $site): bool
+    {
+        return $this->sites->contains($site);
+    }
+
+    public function getCurrentSite(): ?SiteInterface
+    {
+        return $this->currentSite;
+    }
+
+    /**
+     * Setter brut, sans garde. Usage interne pour les flux qui doivent
+     * pouvoir positionner un site arbitraire ou null (reset de coherence
+     * post-PATCH RBAC, fixtures, init). Pour le flux user-facing
+     * "selectionner un site dans la liste autorisee", utiliser
+     * switchCurrentSite() qui porte la garde domaine.
+     */
+    public function setCurrentSite(?SiteInterface $currentSite): static
+    {
+        $this->currentSite = $currentSite;
+
+        return $this;
+    }
+
+    /**
+     * Garde domaine du switch utilisateur : refuse un site qui n'est pas
+     * dans la collection autorisee. Levee d'une exception domaine que le
+     * processor HTTP traduit en 403 (pattern aligne sur Role::ensureDeletable
+     * → SystemRoleDeletionException).
+     *
+     * @throws SiteNotAuthorizedException si $site n'appartient pas a $this->sites
+     */
+    public function switchCurrentSite(SiteInterface $site): void
+    {
+        if (!$this->hasSite($site)) {
+            throw SiteNotAuthorizedException::forSite($site);
+        }
+
+        $this->currentSite = $site;
+    }
 }

src/Module/Core/Infrastructure/ApiPlatform/Pagination/DbalPaginator.php

@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Core\Infrastructure\ApiPlatform\Pagination;
+
+use ApiPlatform\State\Pagination\PaginatorInterface;
+use ArrayIterator;
+use IteratorAggregate;
+use Traversable;
+
+/**
+ * Paginator pour resources alimentees par DBAL (pas par Doctrine ORM).
+ *
+ * Implemente PaginatorInterface : API Platform l'introspecte pour generer
+ * automatiquement la section `hydra:view` (first / next / previous / last)
+ * dans la reponse JSON-LD. Aucun calcul manuel de liens.
+ *
+ * @template T of object
+ *
+ * @implements PaginatorInterface<T>
+ */
+final readonly class DbalPaginator implements PaginatorInterface, IteratorAggregate
+{
+    /**
+     * @param list<T> $items        Items deja decoupes sur la page courante
+     * @param int     $currentPage  Page courante (1-indexee)
+     * @param int     $itemsPerPage Limite appliquee a la requete SQL
+     * @param int     $totalItems   Resultat du COUNT(*) sans limite
+     */
+    public function __construct(
+        private array $items,
+        private int $currentPage,
+        private int $itemsPerPage,
+        private int $totalItems,
+    ) {}
+
+    public function getCurrentPage(): float
+    {
+        return (float) $this->currentPage;
+    }
+
+    public function getLastPage(): float
+    {
+        if ($this->itemsPerPage <= 0) {
+            return 1.0;
+        }
+
+        return (float) max(1, (int) ceil($this->totalItems / $this->itemsPerPage));
+    }
+
+    public function getItemsPerPage(): float
+    {
+        return (float) $this->itemsPerPage;
+    }
+
+    public function getTotalItems(): float
+    {
+        return (float) $this->totalItems;
+    }
+
+    public function count(): int
+    {
+        return count($this->items);
+    }
+
+    /**
+     * @return Traversable<int, T>
+     */
+    public function getIterator(): Traversable
+    {
+        return new ArrayIterator($this->items);
+    }
+}

src/Module/Core/Infrastructure/ApiPlatform/Resource/AuditLogEntityTypesResource.php

@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Core\Infrastructure\ApiPlatform\Resource;
+
+use ApiPlatform\Metadata\ApiResource;
+use ApiPlatform\Metadata\Get;
+use App\Module\Core\Infrastructure\ApiPlatform\State\Provider\AuditLogEntityTypesProvider;
+
+/**
+ * Retourne la liste des valeurs distinctes de `entity_type` presentes dans
+ * `audit_log`, pour alimenter le filtre multi-selection cote front (journal
+ * d'audit). La liste evolue automatiquement avec les nouvelles entites
+ * `#[Auditable]` au fil des ecritures.
+ */
+#[ApiResource(
+    shortName: 'AuditLogEntityTypes',
+    operations: [
+        new Get(
+            uriTemplate: '/audit-log-entity-types',
+            security: "is_granted('core.audit_log.view')",
+            provider: AuditLogEntityTypesProvider::class,
+        ),
+    ],
+)]
+final class AuditLogEntityTypesResource
+{
+    /** @param list<string> $entityTypes */
+    public function __construct(
+        public readonly string $id = 'entity-types',
+        public readonly array $entityTypes = [],
+    ) {}
+}

src/Module/Core/Infrastructure/ApiPlatform/Resource/AuditLogResource.php

@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Core\Infrastructure\ApiPlatform\Resource;
+
+use ApiPlatform\Metadata\ApiResource;
+use ApiPlatform\Metadata\Get;
+use ApiPlatform\Metadata\GetCollection;
+use App\Module\Core\Application\DTO\AuditLogOutput;
+use App\Module\Core\Infrastructure\ApiPlatform\State\Provider\AuditLogProvider;
+
+/**
+ * Resource API Platform en lecture seule sur le journal d'audit.
+ *
+ * Aucune operation d'ecriture exposee (POST/PUT/PATCH/DELETE -> 405)
+ * conformement au caractere append-only de la table `audit_log`.
+ *
+ * La resource est un simple porteur de metadonnees #[ApiResource] ; le
+ * provider lit via DBAL et retourne directement des instances du DTO
+ * `AuditLogOutput` (declare via `output:`). La table n'est pas geree par
+ * l'ORM : aucune entite Doctrine n'est necessaire ici.
+ *
+ * Filtres query-param supportes par le provider :
+ *   ?entity_type=core.User
+ *   ?entity_id=42
+ *   ?action=update
+ *   ?performed_by=admin
+ *   ?performed_at[after]=2026-04-01T00:00:00Z
+ *   ?performed_at[before]=2026-04-30T23:59:59Z
+ *
+ * La pagination est assuree par le provider via DbalPaginator (implementant
+ * ApiPlatform\State\Pagination\PaginatorInterface), ce qui genere
+ * automatiquement hydra:view — aucune construction manuelle.
+ */
+#[ApiResource(
+    shortName: 'AuditLog',
+    operations: [
+        new GetCollection(
+            uriTemplate: '/audit-logs',
+            paginationItemsPerPage: 30,
+            paginationClientItemsPerPage: true,
+            paginationMaximumItemsPerPage: 100,
+            security: "is_granted('core.audit_log.view')",
+            provider: AuditLogProvider::class,
+        ),
+        new Get(
+            uriTemplate: '/audit-logs/{id}',
+            requirements: ['id' => '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}'],
+            security: "is_granted('core.audit_log.view')",
+            provider: AuditLogProvider::class,
+        ),
+    ],
+    output: AuditLogOutput::class,
+)]
+final class AuditLogResource {}

src/Module/Core/Infrastructure/ApiPlatform/State/Processor/UserRbacProcessor.php

@@ -9,10 +9,14 @@ use ApiPlatform\State\ProcessorInterface;
 use App\Module\Core\Domain\Entity\User;
 use App\Module\Core\Domain\Exception\LastAdminProtectionException;
 use App\Module\Core\Domain\Security\AdminHeadcountGuardInterface;
+use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\PersistentCollection;
 use LogicException;
 use Symfony\Bundle\SecurityBundle\Security;
 use Symfony\Component\DependencyInjection\Attribute\Autowire;
+use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
 use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
 
 /**
@@ -29,17 +33,51 @@ use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
  *  - Dernier admin global : impossible de retirer `isAdmin` si c'est le
  *    dernier administrateur de l'instance, meme par un tiers. Enforce via
  *    AdminHeadcountGuardInterface.
+ *  - Permission sites.manage : si le payload mute la collection `sites`,
+ *    la permission `sites.manage` est requise en plus de `core.users.manage`.
+ *  - Coherence currentSite (ticket 2 module Sites) : apres persist des
+ *    sites autorises, si le `currentSite` n'est plus dans la collection,
+ *    il est repositionne automatiquement :
+ *     a) repasse a `null` s'il pointait vers un site retire ;
+ *     b) est auto-selectionne sur le premier site de `sites` s'il etait
+ *        null alors que la collection vient d'etre modifiee et n'est pas vide.
+ *    Un second flush est emis uniquement si la coherence a du etre corrigee.
+ *    La garde coherence est skippee si ni les sites ni le currentSite n'ont
+ *    change (evite le silent site-switch sur un PATCH ne touchant pas aux sites).
+ *
+ * Atomicite : persistProcessor->process() + ensureCurrentSiteConsistency() sont
+ * executes dans une meme transaction wrapInTransaction pour eviter un etat
+ * partiellement persiste en cas d'erreur entre les deux flush.
  *
  * @implements ProcessorInterface<User, User>
  */
 final class UserRbacProcessor implements ProcessorInterface
 {
+    /**
+     * Mapping cle-payload → (property-path PHP, accesseur, setter utilise pour
+     * reattacher les items lors de la restauration). Permet au gardefou
+     * anti-ecrasement de savoir quelles collections restaurer si elles sont
+     * absentes du payload JSON.
+     *
+     * Note : la cle JSON "roles" correspond a la propriete PHP `rbacRoles`
+     * (renommee via #[SerializedName] pour eviter la collision avec
+     * UserInterface::getRoles()).
+     *
+     * @var array<string, array{getter: string, remover: string, adder: string}>
+     */
+    private const array COLLECTION_MAP = [
+        'roles'             => ['getter' => 'getRbacRoles', 'remover' => 'removeRbacRole', 'adder' => 'addRbacRole'],
+        'directPermissions' => ['getter' => 'getDirectPermissions', 'remover' => 'removeDirectPermission', 'adder' => 'addDirectPermission'],
+        'sites'             => ['getter' => 'getSites', 'remover' => 'removeSite', 'adder' => 'addSite'],
+    ];
+
     public function __construct(
         #[Autowire(service: 'api_platform.doctrine.orm.state.persist_processor')]
         private readonly ProcessorInterface $persistProcessor,
         private readonly EntityManagerInterface $entityManager,
         private readonly Security $security,
         private readonly AdminHeadcountGuardInterface $adminHeadcountGuard,
+        private readonly RequestStack $requestStack,
     ) {}
 
     public function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): mixed
@@ -55,6 +93,19 @@ final class UserRbacProcessor implements ProcessorInterface
             ));
         }
 
+        // Garde anti-ecrasement (defense in depth) : PATCH merge-patch+json impose
+        // que les cles absentes du payload ne mutent PAS les proprietes
+        // correspondantes. La denormalisation API Platform ne respecte pas cet
+        // invariant pour les collections ManyToMany — elle reinstancie une
+        // ArrayCollection vide des que la cle n'est pas presente. Sans cette
+        // garde, un client qui PATCHe juste `{ "isAdmin": true }` verrait toutes
+        // ses roles/directPermissions/sites detruits.
+        //
+        // On lit le body brut de la requete pour connaitre les cles envoyees,
+        // puis on restaure les collections absentes a partir de l'etat d'origine
+        // charge par Doctrine (snapshot des PersistentCollection).
+        $this->restoreAbsentCollections($data);
+
         $currentUser = $this->security->getUser();
 
         // Calcul partage entre les deux gardes : l'user perdait-il le flag admin ?
@@ -80,6 +131,156 @@ final class UserRbacProcessor implements ProcessorInterface
             }
         }
 
-        return $this->persistProcessor->process($data, $operation, $uriVariables, $context);
+        // Detection de la mutation de la collection `sites` avant tout flush.
+        // La collection est deja denormalisee dans $data quand process() est appele.
+        // On utilise PersistentCollection::isDirty() pour savoir si l'ORM a detecte
+        // une modification depuis le chargement initial (ajout/retrait d'elements).
+        $sitesCollection  = $data->getSites();
+        $sitesWereMutated = $sitesCollection instanceof PersistentCollection
+            && $sitesCollection->isDirty();
+
+        // Capture de l'ID du currentSite avant persist pour la detection post-flush.
+        $originalCurrentSiteId = $data->getCurrentSite()?->getId();
+
+        // Garde sites.manage : la modification de la collection de sites rattaches
+        // a un user est une operation sensible qui requiert une permission distincte
+        // de core.users.manage (evite le bypass de sites.manage via /rbac).
+        if ($sitesWereMutated && !$this->security->isGranted('sites.manage')) {
+            throw new AccessDeniedHttpException(
+                'La modification des sites rattaches a un user requiert la permission sites.manage.'
+            );
+        }
+
+        // Persistance + correction de coherence currentSite dans une seule transaction.
+        // wrapInTransaction rollback automatiquement sur toute exception et la re-lance,
+        // ce qui preserve le comportement attendu pour BadRequestHttpException.
+        $result = null;
+        $this->entityManager->wrapInTransaction(function () use (
+            $data,
+            $operation,
+            $uriVariables,
+            $context,
+            $sitesWereMutated,
+            $originalCurrentSiteId,
+            &$result,
+        ): void {
+            $result = $this->persistProcessor->process($data, $operation, $uriVariables, $context);
+
+            // Garde coherence currentSite (ticket 2 module Sites).
+            // Post-persist : le champ `sites` a ete applique par le persist processor.
+            // On s'assure que `currentSite` pointe toujours vers un site present
+            // dans la collection ou est recale automatiquement — mais UNIQUEMENT si
+            // les sites ou le currentSite ont effectivement ete touches dans ce PATCH.
+            $currentSiteChangedByPersist = $originalCurrentSiteId !== $data->getCurrentSite()?->getId();
+            if ($sitesWereMutated || $currentSiteChangedByPersist) {
+                $this->ensureCurrentSiteConsistency($data);
+            }
+        });
+
+        return $result;
+    }
+
+    /**
+     * Applique deux corrections post-persist sur `currentSite` :
+     *  - si l'actuel n'est plus dans `sites` apres update → repasse a null ;
+     *  - si null et `sites` non vide → auto-selectionne le premier site
+     *    (coherent avec le choix de ne jamais laisser un user rattache a
+     *    plusieurs sites sans contexte courant apres une mutation effective).
+     *
+     * N'emet un flush additionnel que si une correction a ete necessaire :
+     * pas de cout DB sur la majorite des requetes /rbac qui ne touchent pas
+     * aux sites.
+     *
+     * Cette methode ne doit etre appelee que si les sites ont reellement
+     * ete mutes dans la requete courante (voir logique dans process()).
+     */
+    private function ensureCurrentSiteConsistency(User $user): void
+    {
+        $currentSite = $user->getCurrentSite();
+        $sites       = $user->getSites();
+        $changed     = false;
+
+        if (null !== $currentSite && !$user->hasSite($currentSite)) {
+            $user->setCurrentSite(null);
+            $changed = true;
+        }
+
+        if (null === $user->getCurrentSite() && !$sites->isEmpty()) {
+            $user->setCurrentSite($sites->first() ?: null);
+            $changed = true;
+        }
+
+        if ($changed) {
+            $this->entityManager->flush();
+        }
+    }
+
+    /**
+     * Pour chaque collection RBAC (roles, directPermissions, sites) absente du
+     * payload JSON, restaure l'etat d'origine a partir du snapshot Doctrine et
+     * marque la collection comme non-dirty. Idempotent : si la cle est presente
+     * dans le payload, no-op (la denormalisation fait foi).
+     *
+     * Cas d'usage : un client qui PATCHe partiellement (`{ "isAdmin": true }`)
+     * ne doit pas voir ses autres collections reinitialisees. API Platform
+     * reinstancie par defaut une collection vide pour les cles absentes, ce
+     * qui casse la semantique de merge-patch+json.
+     *
+     * Pas de fallback si la collection d'origine n'est pas une PersistentCollection
+     * (ex: User fraichement construit) : dans ce cas aucune restauration n'est
+     * possible puisqu'il n'y a pas d'etat persiste a restaurer.
+     */
+    private function restoreAbsentCollections(User $user): void
+    {
+        $request = $this->requestStack->getCurrentRequest();
+        if (null === $request) {
+            return;
+        }
+
+        $rawBody = $request->getContent();
+        if ('' === $rawBody) {
+            return;
+        }
+
+        /** @var null|array<string, mixed> $payload */
+        $payload = json_decode($rawBody, true);
+        if (!is_array($payload)) {
+            return;
+        }
+
+        foreach (self::COLLECTION_MAP as $jsonKey => $accessors) {
+            if (array_key_exists($jsonKey, $payload)) {
+                continue;
+            }
+
+            /** @var Collection<int, object> $currentCollection */
+            $currentCollection = $user->{$accessors['getter']}();
+
+            if (!$currentCollection instanceof PersistentCollection) {
+                continue;
+            }
+
+            // Snapshot = etat charge depuis la BDD avant denormalisation.
+            // On restaure en retirant les items actuels et en ajoutant les
+            // originaux via l'adder/remover pour que les collections inverses
+            // (ex: Site::users) restent coherentes.
+            $snapshot = $currentCollection->getSnapshot();
+
+            foreach ($currentCollection->toArray() as $currentItem) {
+                if (!in_array($currentItem, $snapshot, true)) {
+                    $user->{$accessors['remover']}($currentItem);
+                }
+            }
+
+            foreach ($snapshot as $originalItem) {
+                if (!$currentCollection->contains($originalItem)) {
+                    $user->{$accessors['adder']}($originalItem);
+                }
+            }
+
+            // Marquer comme non-dirty pour que Doctrine ne detecte pas de diff
+            // et n'emette pas de requete UPDATE inutile sur la table de jointure.
+            $currentCollection->takeSnapshot();
+        }
     }
 }

src/Module/Core/Infrastructure/ApiPlatform/State/Provider/AuditLogEntityTypesProvider.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Core\Infrastructure\ApiPlatform\State\Provider;
+
+use ApiPlatform\Metadata\Operation;
+use ApiPlatform\State\ProviderInterface;
+use App\Module\Core\Infrastructure\ApiPlatform\Resource\AuditLogEntityTypesResource;
+use Doctrine\DBAL\Connection;
+use Symfony\Component\DependencyInjection\Attribute\Autowire;
+
+/**
+ * Provider DBAL : SELECT DISTINCT entity_type FROM audit_log.
+ *
+ * @implements ProviderInterface<AuditLogEntityTypesResource>
+ */
+final readonly class AuditLogEntityTypesProvider implements ProviderInterface
+{
+    public function __construct(
+        #[Autowire(service: 'doctrine.dbal.default_connection')]
+        private Connection $connection,
+    ) {}
+
+    public function provide(Operation $operation, array $uriVariables = [], array $context = []): AuditLogEntityTypesResource
+    {
+        /** @var list<string> $types */
+        $types = $this->connection
+            ->executeQuery('SELECT DISTINCT entity_type FROM audit_log ORDER BY entity_type ASC')
+            ->fetchFirstColumn()
+        ;
+
+        return new AuditLogEntityTypesResource(entityTypes: $types);
+    }
+}

src/Module/Core/Infrastructure/ApiPlatform/State/Provider/AuditLogProvider.php

@@ -0,0 +1,209 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Core\Infrastructure\ApiPlatform\State\Provider;
+
+use ApiPlatform\Metadata\CollectionOperationInterface;
+use ApiPlatform\Metadata\Operation;
+use ApiPlatform\State\Pagination\Pagination;
+use ApiPlatform\State\ProviderInterface;
+use App\Module\Core\Application\DTO\AuditLogOutput;
+use App\Module\Core\Infrastructure\ApiPlatform\Pagination\DbalPaginator;
+use DateTimeImmutable;
+use Doctrine\DBAL\ArrayParameterType;
+use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\Query\QueryBuilder;
+use Symfony\Component\DependencyInjection\Attribute\Autowire;
+
+/**
+ * Provider API Platform pour la resource AuditLog.
+ *
+ * Lit la table `audit_log` via DBAL (pas d'entite ORM). Retourne soit :
+ *  - une instance unique d'AuditLogOutput (operation Get) ;
+ *  - un DbalPaginator de AuditLogOutput (operation GetCollection).
+ *
+ * Le paginator implementant PaginatorInterface laisse API Platform generer
+ * automatiquement la section `hydra:view` : aucune manipulation manuelle.
+ *
+ * Connexion DBAL : `default` (lecture — aucun besoin de la connexion `audit`
+ * reservee a l'ecriture hors transaction ORM).
+ */
+final readonly class AuditLogProvider implements ProviderInterface
+{
+    public function __construct(
+        #[Autowire(service: 'doctrine.dbal.default_connection')]
+        private Connection $connection,
+        private Pagination $pagination,
+    ) {}
+
+    public function provide(Operation $operation, array $uriVariables = [], array $context = []): AuditLogOutput|DbalPaginator|null
+    {
+        if (!$operation instanceof CollectionOperationInterface) {
+            return $this->provideItem((string) $uriVariables['id']);
+        }
+
+        return $this->provideCollection($operation, $context);
+    }
+
+    private function provideItem(string $id): ?AuditLogOutput
+    {
+        /** @var array<string, mixed>|false $row */
+        $row = $this->connection->fetchAssociative(
+            'SELECT id, entity_type, entity_id, action, changes, performed_by, performed_at, ip_address, request_id
+             FROM audit_log WHERE id = :id',
+            ['id' => $id],
+        );
+
+        if (false === $row) {
+            return null;
+        }
+
+        return $this->hydrate($row);
+    }
+
+    /**
+     * @param array<string, mixed> $context
+     */
+    private function provideCollection(Operation $operation, array $context): DbalPaginator
+    {
+        $page         = $this->pagination->getPage($context);
+        $itemsPerPage = $this->pagination->getLimit($operation, $context);
+        $offset       = ($page - 1) * $itemsPerPage;
+        $filters      = $this->extractFilters($context['filters'] ?? []);
+
+        $dataQuery = $this->buildBaseQuery()
+            ->select('id', 'entity_type', 'entity_id', 'action', 'changes', 'performed_by', 'performed_at', 'ip_address', 'request_id')
+            ->orderBy('performed_at', 'DESC')
+            ->setFirstResult($offset)
+            ->setMaxResults($itemsPerPage)
+        ;
+
+        $countQuery = $this->buildBaseQuery()->select('COUNT(*)');
+
+        $this->applyFilters($dataQuery, $filters);
+        $this->applyFilters($countQuery, $filters);
+
+        /** @var list<array<string, mixed>> $rows */
+        $rows       = $dataQuery->executeQuery()->fetchAllAssociative();
+        $totalItems = (int) $countQuery->executeQuery()->fetchOne();
+
+        $items = array_map(fn (array $row) => $this->hydrate($row), $rows);
+
+        return new DbalPaginator($items, $page, $itemsPerPage, $totalItems);
+    }
+
+    private function buildBaseQuery(): QueryBuilder
+    {
+        return $this->connection->createQueryBuilder()->from('audit_log');
+    }
+
+    /**
+     * @param array<string, mixed> $raw
+     *
+     * @return array{entity_type?: list<string>|string, entity_id?: string, action?: string, performed_by?: string, performed_at_after?: string, performed_at_before?: string}
+     */
+    private function extractFilters(array $raw): array
+    {
+        $filters = [];
+
+        // `entity_type` accepte soit une chaine, soit une liste (query syntax
+        // `entity_type[]=core.User&entity_type[]=core.Role`) pour le filtre
+        // multi-selection cote front. On normalise en list<string> non-vide.
+        if (isset($raw['entity_type'])) {
+            if (is_string($raw['entity_type']) && '' !== $raw['entity_type']) {
+                $filters['entity_type'] = $raw['entity_type'];
+            } elseif (is_array($raw['entity_type'])) {
+                $cleaned = array_values(array_filter(
+                    $raw['entity_type'],
+                    static fn ($v): bool => is_string($v) && '' !== $v,
+                ));
+                if ([] !== $cleaned) {
+                    $filters['entity_type'] = $cleaned;
+                }
+            }
+        }
+
+        foreach (['entity_id', 'action', 'performed_by'] as $key) {
+            if (isset($raw[$key]) && is_string($raw[$key]) && '' !== $raw[$key]) {
+                $filters[$key] = $raw[$key];
+            }
+        }
+
+        // Filtres de plage `performed_at[after]` / `performed_at[before]`.
+        if (isset($raw['performed_at']) && is_array($raw['performed_at'])) {
+            $range = $raw['performed_at'];
+            if (isset($range['after']) && is_string($range['after']) && '' !== $range['after']) {
+                $filters['performed_at_after'] = $range['after'];
+            }
+            if (isset($range['before']) && is_string($range['before']) && '' !== $range['before']) {
+                $filters['performed_at_before'] = $range['before'];
+            }
+        }
+
+        return $filters;
+    }
+
+    /**
+     * @param array<string, list<string>|string> $filters
+     */
+    private function applyFilters(QueryBuilder $qb, array $filters): void
+    {
+        if (isset($filters['entity_type'])) {
+            if (is_array($filters['entity_type'])) {
+                $qb->andWhere('entity_type IN (:entity_types)')
+                    ->setParameter('entity_types', $filters['entity_type'], ArrayParameterType::STRING)
+                ;
+            } else {
+                $qb->andWhere('entity_type = :entity_type')->setParameter('entity_type', $filters['entity_type']);
+            }
+        }
+        if (isset($filters['entity_id'])) {
+            $qb->andWhere('entity_id = :entity_id')->setParameter('entity_id', $filters['entity_id']);
+        }
+        if (isset($filters['action'])) {
+            $qb->andWhere('action = :action')->setParameter('action', $filters['action']);
+        }
+        if (isset($filters['performed_by'])) {
+            // Recherche contains insensible a la casse pour matcher "adm" → "admin".
+            // On echappe `%`, `_` et `\` saisis par l'utilisateur pour qu'ils soient
+            // interpretes comme caracteres litteraux (sinon `%` matche tout, `_`
+            // matche n'importe quel caractere). La clause `ESCAPE '\\'` indique
+            // a PostgreSQL le caractere d'echappement utilise dans le motif.
+            $escaped = str_replace(['\\', '%', '_'], ['\\\\', '\%', '\_'], $filters['performed_by']);
+            $qb->andWhere("performed_by ILIKE :performed_by ESCAPE '\\'")
+                ->setParameter('performed_by', '%'.$escaped.'%')
+            ;
+        }
+        if (isset($filters['performed_at_after'])) {
+            $qb->andWhere('performed_at >= :performed_at_after')->setParameter('performed_at_after', $filters['performed_at_after']);
+        }
+        if (isset($filters['performed_at_before'])) {
+            $qb->andWhere('performed_at <= :performed_at_before')->setParameter('performed_at_before', $filters['performed_at_before']);
+        }
+    }
+
+    /**
+     * @param array<string, mixed> $row
+     */
+    private function hydrate(array $row): AuditLogOutput
+    {
+        /** @var string $rawChanges */
+        $rawChanges = $row['changes'] ?? '{}';
+
+        /** @var array<string, mixed> $changes */
+        $changes = is_array($rawChanges) ? $rawChanges : json_decode((string) $rawChanges, true, 512, JSON_THROW_ON_ERROR);
+
+        return new AuditLogOutput(
+            id: (string) $row['id'],
+            entityType: (string) $row['entity_type'],
+            entityId: (string) $row['entity_id'],
+            action: (string) $row['action'],
+            changes: $changes,
+            performedBy: (string) $row['performed_by'],
+            performedAt: new DateTimeImmutable((string) $row['performed_at']),
+            ipAddress: null !== $row['ip_address'] ? (string) $row['ip_address'] : null,
+            requestId: null !== $row['request_id'] ? (string) $row['request_id'] : null,
+        );
+    }
+}

src/Module/Core/Infrastructure/Audit/AuditLogWriter.php

@@ -0,0 +1,100 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Core\Infrastructure\Audit;
+
+use DateTimeImmutable;
+use DateTimeZone;
+use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\Types\Types;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\DependencyInjection\Attribute\Autowire;
+use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\Uid\Uuid;
+
+/**
+ * Service bas-niveau responsable de l'ecriture dans la table `audit_log`.
+ *
+ * Utilise une connexion DBAL dediee `audit` (meme DSN que `default`, service
+ * separe) pour ecrire hors de la transaction ORM : indispensable pour que
+ * les lignes d'audit survivent meme si le flush applicatif est rollback,
+ * et pour eviter tout entanglement transactionnel en batch (fixtures).
+ *
+ * Les cles sensibles (password, plainPassword, token, secret) sont filtrees
+ * en defense-in-depth meme si les entites declarent deja ces proprietes
+ * #[AuditIgnore].
+ *
+ * Erreur silencieuse : en cas d'echec SQL, on lance pas l'exception plus
+ * haut — l'audit ne doit jamais faire crasher un flux metier. Le listener
+ * wrappe l'appel dans un try/catch + logger (cf. AuditListener).
+ */
+final class AuditLogWriter
+{
+    /** @var list<string> cles systematiquement strippees du payload `changes` */
+    private const array SENSITIVE_KEYS = ['password', 'plainPassword', 'token', 'secret'];
+
+    public function __construct(
+        #[Autowire(service: 'doctrine.dbal.audit_connection')]
+        private readonly Connection $connection,
+        private readonly Security $security,
+        private readonly RequestStack $requestStack,
+        private readonly RequestIdProvider $requestIdProvider,
+    ) {}
+
+    /**
+     * Ecrit une ligne d'audit.
+     *
+     * @param string               $entityType Format "module.Entity" (ex: "core.User")
+     * @param string               $entityId   ID de l'entite (int ou UUID serialise)
+     * @param string               $action     create|update|delete
+     * @param array<string, mixed> $changes    Payload JSON (filtre des cles sensibles)
+     */
+    public function log(
+        string $entityType,
+        string $entityId,
+        string $action,
+        array $changes,
+    ): void {
+        $filteredChanges = $this->stripSensitive($changes);
+
+        $this->connection->insert('audit_log', [
+            'id'           => Uuid::v7()->toRfc4122(),
+            'entity_type'  => $entityType,
+            'entity_id'    => $entityId,
+            'action'       => $action,
+            'changes'      => $filteredChanges,
+            'performed_by' => $this->security->getUser()?->getUserIdentifier() ?? 'system',
+            'performed_at' => new DateTimeImmutable('now', new DateTimeZone('UTC')),
+            'ip_address'   => $this->requestStack->getCurrentRequest()?->getClientIp(),
+            'request_id'   => $this->requestIdProvider->getRequestId(),
+        ], [
+            // Types de conversion DBAL : UUID natif PG + jsonb + datetimetz.
+            // Sans 'id' => GUID, DBAL passerait un varchar et Postgres ferait
+            // un cast implicite — ca marche mais l'intention est floue.
+            'id'           => Types::GUID,
+            'changes'      => Types::JSON,
+            'performed_at' => Types::DATETIMETZ_IMMUTABLE,
+        ]);
+    }
+
+    /**
+     * Supprime recursivement les cles sensibles du payload.
+     *
+     * Utile pour les snapshots complets (create/delete) ou les changes
+     * d'update : le listener prefiltre deja mais on garde cette garde
+     * en defense-in-depth si un appelant direct oublie `#[AuditIgnore]`.
+     *
+     * @param array<string, mixed> $data
+     *
+     * @return array<string, mixed>
+     */
+    private function stripSensitive(array $data): array
+    {
+        foreach (self::SENSITIVE_KEYS as $sensitiveKey) {
+            unset($data[$sensitiveKey]);
+        }
+
+        return $data;
+    }
+}

src/Module/Core/Infrastructure/Audit/RequestIdProvider.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Core\Infrastructure\Audit;
+
+use Symfony\Component\EventDispatcher\Attribute\AsEventListener;
+use Symfony\Component\HttpKernel\Event\RequestEvent;
+use Symfony\Component\Uid\Uuid;
+
+/**
+ * Fournit un identifiant de requete HTTP (UUID v4) partage par toutes les
+ * lignes d'audit produites au cours d'une meme requete principale.
+ *
+ * Utilite : retrouver d'un seul coup d'oeil toutes les ecritures liees a un
+ * meme appel utilisateur (ex: PATCH qui cascade des updates sur plusieurs
+ * entites). Null en CLI (fixtures, commandes batch).
+ *
+ * Service singleton (scope container par defaut) — un unique UUID est
+ * genere au kernel.request principal et reutilise pour toute la requete.
+ */
+final class RequestIdProvider
+{
+    private ?string $requestId = null;
+
+    #[AsEventListener(event: 'kernel.request')]
+    public function onKernelRequest(RequestEvent $event): void
+    {
+        // Ignorer les sub-requests (ESI, forward interne) pour ne pas
+        // ecraser l'UUID de la requete principale.
+        if (!$event->isMainRequest()) {
+            return;
+        }
+
+        $this->requestId = Uuid::v4()->toRfc4122();
+    }
+
+    public function getRequestId(): ?string
+    {
+        return $this->requestId;
+    }
+}

src/Module/Core/Infrastructure/DataFixtures/AppFixtures.php

@@ -8,26 +8,50 @@ use App\Module\Core\Domain\Entity\Role;
 use App\Module\Core\Domain\Entity\User;
 use App\Module\Core\Domain\Repository\RoleRepositoryInterface;
 use App\Module\Core\Domain\Security\SystemRoles;
+use App\Module\Sites\Domain\Entity\Site;
+use App\Module\Sites\Domain\Repository\SiteRepositoryInterface;
+use App\Module\Sites\Infrastructure\DataFixtures\SitesFixtures;
 use Doctrine\Bundle\FixturesBundle\Fixture;
+use Doctrine\Common\DataFixtures\DependentFixtureInterface;
 use Doctrine\Persistence\ObjectManager;
+use RuntimeException;
 use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
 
 /**
  * Fixtures de base du module Core : 3 utilisateurs (1 admin + 2 standards)
- * rattaches aux roles systeme RBAC seedes par la migration Version20260414150034.
+ * rattaches aux roles systeme RBAC seedes par la migration Version20260414150034,
+ * puis (ticket 2 module Sites) rattaches a au moins un site avec un currentSite
+ * coherent.
  *
  * Note : le purger Doctrine execute avant load() supprime l'ensemble des
  * entites managees, ce qui inclut la table role. On re-seede donc les roles
  * systeme de maniere idempotente avant de rattacher les utilisateurs, afin
  * que le workflow "make db-reset && make fixtures" reste one-shot.
+ *
+ * Dependance explicite a SitesFixtures (ticket 2) : les 3 sites Chatellerault,
+ * Saint-Jean et Pommevic doivent etre presents en base avant d'etre rattaches
+ * aux users. L'inversion volontaire de l'ordre (AppFixtures ← SitesFixtures)
+ * casse l'independance declaree au ticket 1 : c'est un couplage assume car
+ * apres ticket 2 le modele metier exprime un besoin legitime de rattachement.
  */
-class AppFixtures extends Fixture
+class AppFixtures extends Fixture implements DependentFixtureInterface
 {
     public function __construct(
         private readonly UserPasswordHasherInterface $passwordHasher,
         private readonly RoleRepositoryInterface $roleRepository,
+        private readonly SiteRepositoryInterface $siteRepository,
     ) {}
 
+    /**
+     * @return array<int, class-string>
+     */
+    public function getDependencies(): array
+    {
+        // SitesFixtures doit tourner AVANT AppFixtures pour que les sites
+        // soient disponibles au rattachement des users ci-dessous.
+        return [SitesFixtures::class];
+    }
+
     public function load(ObjectManager $manager): void
     {
         $adminRole = $this->ensureSystemRole(
@@ -43,23 +67,43 @@ class AppFixtures extends Fixture
             'Role de base sans permission specifique',
         );
 
+        // Recupere les 3 sites seedes par SitesFixtures. Si absents, c'est
+        // une misconfiguration (fixture hors purge ou dependance ignoree) :
+        // on fail fort avec un message explicite plutot que de continuer
+        // avec des users orphelins de site.
+        $chatellerault = $this->requireSite('Chatellerault');
+        $saintJean     = $this->requireSite('Saint-Jean');
+        $pommevic      = $this->requireSite('Pommevic');
+
         $admin = new User();
         $admin->setUsername('admin');
         $admin->setIsAdmin(true);
         $admin->setPassword($this->passwordHasher->hashPassword($admin, 'admin'));
         $admin->addRbacRole($adminRole);
+        // Admin rattache aux 3 sites pour faciliter le dev / les tests manuels.
+        $admin->addSite($chatellerault);
+        $admin->addSite($saintJean);
+        $admin->addSite($pommevic);
+        $admin->setCurrentSite($chatellerault);
         $manager->persist($admin);
 
         $alice = new User();
         $alice->setUsername('alice');
         $alice->setPassword($this->passwordHasher->hashPassword($alice, 'alice'));
         $alice->addRbacRole($userRole);
+        // Alice : un seul site, site courant = ce site.
+        $alice->addSite($chatellerault);
+        $alice->setCurrentSite($chatellerault);
         $manager->persist($alice);
 
         $bob = new User();
         $bob->setUsername('bob');
         $bob->setPassword($this->passwordHasher->hashPassword($bob, 'bob'));
         $bob->addRbacRole($userRole);
+        // Bob : site different de Alice, pour prouver le filtrage par site
+        // dans les futurs tests (ticket 4 outillage SiteAware).
+        $bob->addSite($saintJean);
+        $bob->setCurrentSite($saintJean);
         $manager->persist($bob);
 
         $manager->flush();
@@ -90,4 +134,19 @@ class AppFixtures extends Fixture
 
         return $role;
     }
+
+    private function requireSite(string $name): Site
+    {
+        $site = $this->siteRepository->findByName($name);
+
+        if (null === $site) {
+            throw new RuntimeException(sprintf(
+                'SitesFixtures doit avoir seede le site "%s" avant le chargement des users. '
+                .'Verifier que SitesFixtures est bien en dependance de AppFixtures.',
+                $name,
+            ));
+        }
+
+        return $site;
+    }
 }

src/Module/Core/Infrastructure/Doctrine/AuditListener.php

@@ -0,0 +1,505 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Core\Infrastructure\Doctrine;
+
+use App\Module\Core\Infrastructure\Audit\AuditLogWriter;
+use App\Shared\Domain\Attribute\Auditable;
+use App\Shared\Domain\Attribute\AuditIgnore;
+use DateTimeInterface;
+use Doctrine\Bundle\DoctrineBundle\Attribute\AsDoctrineListener;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Event\OnFlushEventArgs;
+use Doctrine\ORM\Event\PostFlushEventArgs;
+use Doctrine\ORM\Events;
+use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\ORM\PersistentCollection;
+use Doctrine\ORM\UnitOfWork;
+use Psr\Log\LoggerInterface;
+use ReflectionClass;
+use ReflectionProperty;
+use Throwable;
+
+/**
+ * Listener Doctrine qui produit les lignes d'audit pour les entites portant
+ * l'attribut #[Auditable].
+ *
+ * Pipeline en deux temps :
+ *  1. onFlush : on traverse UnitOfWork (insertions / updates / deletions) et
+ *     on capture les changements en memoire. Aucune ecriture SQL cote audit
+ *     a ce stade pour ne pas interferer avec la transaction ORM en cours.
+ *  2. postFlush : on ecrit via AuditLogWriter (connexion DBAL dediee).
+ *
+ * Pattern swap-and-clear dans postFlush :
+ *  - on copie localement la liste des evenements ;
+ *  - on vide la propriete pendingLogs immediatement ;
+ *  - on itere la copie.
+ * Pourquoi : si une ecriture audit declenchait un flush re-entrant (cas rare,
+ * ex: callback listener externe), l'etat de pendingLogs serait deja nettoye —
+ * pas de double insertion, pas de boucle infinie.
+ *
+ * Erreurs silencieuses : un INSERT audit qui echoue est logue en error mais
+ * jamais propage. Acceptable pour un CRM interne ; a reconsiderer si besoin
+ * de garantie forte (dead-letter queue, retry).
+ *
+ * Collections (OneToMany / ManyToMany) :
+ *  - Les modifications de collections sont tracees via
+ *    `getScheduledCollectionUpdates()` et reportees comme un changement
+ *    `{fieldName: {added: [ids], removed: [ids]}}` dans le changeset de
+ *    l'entite proprietaire.
+ *  - Si l'entite proprietaire est deja scheduled pour insertion, la diff
+ *    est merge dans le snapshot create (en tant que liste d'IDs initiaux).
+ *  - Si l'entite proprietaire est scheduled pour deletion, les collections
+ *    associees sont ignorees (deja couvertes par le snapshot delete).
+ *
+ * Limitations connues :
+ *  - Les ManyToOne sont tracees par ID (null-safe via `?->getId()`).
+ *  - Les DELETE / UPDATE bulk DQL et les `Connection::executeStatement()`
+ *    bruts BYPASSENT le listener : onFlush n'est jamais appele. Toute
+ *    operation de purge/nettoyage qui doit etre auditee doit passer par
+ *    `EntityManager::remove()` + `flush()`. Si un futur batch (ex: commande
+ *    "purger users inactifs") utilise du DQL bulk, les suppressions ne
+ *    seront pas dans `audit_log` — choix d'architecture explicite a faire.
+ */
+#[AsDoctrineListener(event: Events::onFlush)]
+#[AsDoctrineListener(event: Events::postFlush)]
+final class AuditListener
+{
+    /**
+     * Cache par FQCN : true si la classe porte #[Auditable], false sinon.
+     * Evite une ReflectionClass par entite a chaque flush.
+     *
+     * @var array<class-string, bool>
+     */
+    private array $auditableCache = [];
+
+    /**
+     * Cache par FQCN : liste des noms de proprietes ignorees (#[AuditIgnore]).
+     *
+     * @var array<class-string, list<string>>
+     */
+    private array $ignoredPropertiesCache = [];
+
+    /**
+     * Logs en attente d'ecriture (remplis en onFlush, consommes en postFlush).
+     *
+     * Pour les inserts, l'ID est assignee DURANT le flush : on capture la
+     * reference de l'entite et on resout l'ID au moment du postFlush.
+     *
+     * @var list<array{entity: object, metadata: ClassMetadata, entityType: string, action: string, changes: array<string, mixed>, capturedId: ?string}>
+     */
+    private array $pendingLogs = [];
+
+    public function __construct(
+        private readonly AuditLogWriter $writer,
+        private readonly LoggerInterface $logger,
+    ) {}
+
+    public function onFlush(OnFlushEventArgs $args): void
+    {
+        /** @var EntityManagerInterface $em */
+        $em  = $args->getObjectManager();
+        $uow = $em->getUnitOfWork();
+
+        foreach ($uow->getScheduledEntityInsertions() as $entity) {
+            $this->capturePendingLog($entity, $em, $uow, 'create');
+        }
+
+        foreach ($uow->getScheduledEntityUpdates() as $entity) {
+            $this->capturePendingLog($entity, $em, $uow, 'update');
+        }
+
+        foreach ($uow->getScheduledEntityDeletions() as $entity) {
+            $this->capturePendingLog($entity, $em, $uow, 'delete');
+        }
+
+        // Collections to-many (OneToMany / ManyToMany) : `getEntityChangeSet()`
+        // ne les expose pas, il faut interroger `UnitOfWork` separement. On
+        // merge la diff dans le log de l'entite proprietaire si elle est deja
+        // scheduled, sinon on cree une entree "update" dediee.
+        foreach ($uow->getScheduledCollectionUpdates() as $collection) {
+            $this->captureCollectionChange($collection, $em, cleared: false);
+        }
+
+        foreach ($uow->getScheduledCollectionDeletions() as $collection) {
+            $this->captureCollectionChange($collection, $em, cleared: true);
+        }
+    }
+
+    public function postFlush(PostFlushEventArgs $args): void
+    {
+        // Swap-and-clear : protege d'un flush re-entrant (aucune double
+        // insertion meme si un callback utilisateur re-declenche un flush).
+        $logs              = $this->pendingLogs;
+        $this->pendingLogs = [];
+
+        foreach ($logs as $log) {
+            // Pour les inserts, l'ID n'etait pas encore disponible en onFlush :
+            // on la resout maintenant (Doctrine l'a hydratee pendant le flush).
+            $entityId = $log['capturedId'] ?? $this->resolveEntityId($log['entity'], $log['metadata']);
+
+            if (null === $entityId) {
+                $this->logger->warning(
+                    'AuditListener : impossible de resoudre l\'ID de l\'entite apres flush, entree ignoree',
+                    ['entityType' => $log['entityType'], 'action' => $log['action']]
+                );
+
+                continue;
+            }
+
+            try {
+                $this->writer->log(
+                    $log['entityType'],
+                    $entityId,
+                    $log['action'],
+                    $log['changes'],
+                );
+            } catch (Throwable $e) {
+                // Erreur audit : logue mais ne crashe jamais le flux metier.
+                $this->logger->error(
+                    'Echec d\'ecriture audit_log',
+                    [
+                        'exception'  => $e,
+                        'entityType' => $log['entityType'],
+                        'entityId'   => $entityId,
+                        'action'     => $log['action'],
+                    ]
+                );
+            }
+        }
+    }
+
+    private function capturePendingLog(object $entity, EntityManagerInterface $em, UnitOfWork $uow, string $action): void
+    {
+        // Resolution via ClassMetadata : `$entity::class` renvoie le FQCN du
+        // proxy Doctrine pour une entite chargee en lazy (ex:
+        // `Proxies\__CG__\App\Module\Core\Domain\Entity\User`) — `isAuditable()`
+        // le verrait comme non-auditable car `#[Auditable]` n'est declare que
+        // sur la classe parente.
+        $metadata = $em->getClassMetadata($entity::class);
+        $class    = $metadata->getName();
+
+        if (!$this->isAuditable($class)) {
+            return;
+        }
+
+        // Sur `delete`, on inclut aussi les collections to-many dans le
+        // snapshot : c'est la derniere occasion de capturer l'etat complet
+        // (ex: quelles permissions etaient rattachees au role supprime).
+        // Sur `create`, les collections initiales sont rapportees via
+        // captureCollectionChange quand l'entite est scheduled avec un
+        // collection update dans le meme flush.
+        $changes = match ($action) {
+            'update' => $this->buildUpdateChanges($entity, $uow, $class),
+            'create' => $this->buildSnapshot($entity, $metadata, $class, includeCollections: false),
+            'delete' => $this->buildSnapshot($entity, $metadata, $class, includeCollections: true),
+            default  => [],
+        };
+
+        if ('update' === $action && [] === $changes) {
+            // Flush sans changement reel sur une entite auditable : on n'emet pas.
+            return;
+        }
+
+        // Pour delete/update, l'ID est deja set en onFlush — on la capture
+        // maintenant (apres postFlush, l'entite detachee peut perdre sa ref
+        // dans l'identity map). Pour create (IDENTITY), l'ID est generee par
+        // le flush — on differe a postFlush.
+        $capturedId = 'create' === $action ? null : $this->resolveEntityId($entity, $metadata);
+
+        $this->pendingLogs[] = [
+            'entity'     => $entity,
+            'metadata'   => $metadata,
+            'entityType' => $this->formatEntityType($class),
+            'action'     => $action,
+            'changes'    => $changes,
+            'capturedId' => $capturedId,
+        ];
+    }
+
+    /**
+     * Capture la modification d'une collection to-many.
+     *
+     * Strategie de merge :
+     *  - Si l'entite proprietaire est deja scheduled pour `delete` → ignore
+     *    (redondant avec le snapshot delete deja produit).
+     *  - Si l'entite est deja scheduled pour `create` → on ajoute le champ
+     *    collection au snapshot initial, sous forme de liste d'IDs ajoutes.
+     *  - Si l'entite est deja scheduled pour `update` → on merge la diff
+     *    {added, removed} dans le changeset existant.
+     *  - Sinon → on cree une nouvelle entree `update` dediee pour l'entite
+     *    proprietaire (cas d'une collection modifiee sans autre changement
+     *    sur l'entite elle-meme, ex : ajout d'une permission a un role).
+     *
+     * @param bool $cleared true si la collection entiere est supprimee
+     *                      (getScheduledCollectionDeletions) — tous les
+     *                      items du snapshot sont consideres comme retires
+     */
+    private function captureCollectionChange(PersistentCollection $collection, EntityManagerInterface $em, bool $cleared): void
+    {
+        $owner = $collection->getOwner();
+        if (null === $owner) {
+            return;
+        }
+
+        // Voir capturePendingLog : meme contournement proxy Doctrine.
+        $class = $em->getClassMetadata($owner::class)->getName();
+        if (!$this->isAuditable($class)) {
+            return;
+        }
+
+        $fieldName = $collection->getMapping()->fieldName;
+        if (in_array($fieldName, $this->getIgnoredProperties($class), true)) {
+            return;
+        }
+
+        if ($cleared) {
+            $added   = [];
+            $removed = array_map(
+                fn ($item): mixed => $this->normalizeValue($item),
+                $collection->getSnapshot(),
+            );
+        } else {
+            $added = array_map(
+                fn ($item): mixed => $this->normalizeValue($item),
+                $collection->getInsertDiff(),
+            );
+            $removed = array_map(
+                fn ($item): mixed => $this->normalizeValue($item),
+                $collection->getDeleteDiff(),
+            );
+        }
+
+        if ([] === $added && [] === $removed) {
+            return;
+        }
+
+        // Chercher un log deja en attente pour cette entite, pour merger la
+        // diff au lieu de creer une entree d'audit redondante.
+        foreach ($this->pendingLogs as $idx => $log) {
+            if ($log['entity'] !== $owner) {
+                continue;
+            }
+
+            if ('delete' === $log['action']) {
+                // Deletion de l'entite : la collection suit mecaniquement,
+                // pas d'entree dediee (le snapshot delete contient deja
+                // l'etat a supprimer).
+                return;
+            }
+
+            if ('create' === $log['action']) {
+                // Insertion : le snapshot create ne contient pas les
+                // collections (buildSnapshot ignore les to-many). On ajoute
+                // donc la liste des items initiaux comme IDs, pour avoir
+                // une trace complete de l'etat a la creation. array_values
+                // garantit un array JSON (pas un objet) si les cles du diff
+                // ne sont pas sequentielles.
+                $this->pendingLogs[$idx]['changes'][$fieldName] = array_values($added);
+
+                return;
+            }
+
+            // Update : on merge dans le changeset existant.
+            $this->pendingLogs[$idx]['changes'][$fieldName] = [
+                'added'   => array_values($added),
+                'removed' => array_values($removed),
+            ];
+
+            return;
+        }
+
+        // Aucun log existant : l'entite n'a eu QUE des changements de
+        // collection. On cree une entree update minimale.
+        $metadata = $em->getClassMetadata($class);
+
+        $this->pendingLogs[] = [
+            'entity'     => $owner,
+            'metadata'   => $metadata,
+            'entityType' => $this->formatEntityType($class),
+            'action'     => 'update',
+            'changes'    => [$fieldName => [
+                'added'   => array_values($added),
+                'removed' => array_values($removed),
+            ]],
+            'capturedId' => $this->resolveEntityId($owner, $metadata),
+        ];
+    }
+
+    /**
+     * Build du changeset "update" : {champ: {old, new}} a partir de
+     * `UnitOfWork::getEntityChangeSet()`. ManyToOne : on log l'ID,
+     * null-safe via `?->getId()`.
+     *
+     * @return array<string, array{old: mixed, new: mixed}>
+     */
+    private function buildUpdateChanges(object $entity, UnitOfWork $uow, string $class): array
+    {
+        $changeSet       = $uow->getEntityChangeSet($entity);
+        $ignored         = $this->getIgnoredProperties($class);
+        $filteredChanges = [];
+
+        foreach ($changeSet as $field => [$oldValue, $newValue]) {
+            if (in_array($field, $ignored, true)) {
+                continue;
+            }
+
+            $filteredChanges[$field] = [
+                'old' => $this->normalizeValue($oldValue),
+                'new' => $this->normalizeValue($newValue),
+            ];
+        }
+
+        return $filteredChanges;
+    }
+
+    /**
+     * Build d'un snapshot complet (create / delete) : lit toutes les
+     * proprietes non-ignorees via Reflection.
+     *
+     * @param bool $includeCollections si true, les associations to-many sont
+     *                                 aussi snapshotees (liste d'IDs). Utilise
+     *                                 uniquement sur `delete` pour preserver
+     *                                 l'etat des relations au moment de la
+     *                                 suppression. En create, on laisse
+     *                                 captureCollectionChange enrichir le
+     *                                 snapshot si une collection est modifiee
+     *                                 dans le meme flush.
+     *
+     * @return array<string, mixed>
+     */
+    private function buildSnapshot(object $entity, ClassMetadata $metadata, string $class, bool $includeCollections): array
+    {
+        $ignored  = $this->getIgnoredProperties($class);
+        $snapshot = [];
+
+        foreach ($metadata->getFieldNames() as $field) {
+            if (in_array($field, $ignored, true)) {
+                continue;
+            }
+
+            $snapshot[$field] = $this->normalizeValue($metadata->getFieldValue($entity, $field));
+        }
+
+        foreach ($metadata->getAssociationNames() as $assoc) {
+            if (in_array($assoc, $ignored, true)) {
+                continue;
+            }
+
+            if ($metadata->isSingleValuedAssociation($assoc)) {
+                $related          = $metadata->getFieldValue($entity, $assoc);
+                $snapshot[$assoc] = null !== $related && method_exists($related, 'getId')
+                    ? $related->getId()
+                    : null;
+
+                continue;
+            }
+
+            if (!$includeCollections) {
+                continue;
+            }
+
+            // Collection to-many : snapshot = liste d'IDs. On itere la
+            // Collection (PersistentCollection ou ArrayCollection) pour
+            // obtenir les elements. Pour un delete, la collection est deja
+            // chargee (Doctrine en a besoin pour les cascades).
+            $collection = $metadata->getFieldValue($entity, $assoc);
+            if (!is_iterable($collection)) {
+                continue;
+            }
+            $ids = [];
+            foreach ($collection as $item) {
+                $ids[] = $this->normalizeValue($item);
+            }
+            $snapshot[$assoc] = $ids;
+        }
+
+        return $snapshot;
+    }
+
+    private function isAuditable(string $class): bool
+    {
+        if (array_key_exists($class, $this->auditableCache)) {
+            return $this->auditableCache[$class];
+        }
+
+        $reflection                   = new ReflectionClass($class);
+        $isAuditable                  = [] !== $reflection->getAttributes(Auditable::class);
+        $this->auditableCache[$class] = $isAuditable;
+
+        return $isAuditable;
+    }
+
+    /**
+     * @return list<string>
+     */
+    private function getIgnoredProperties(string $class): array
+    {
+        if (array_key_exists($class, $this->ignoredPropertiesCache)) {
+            return $this->ignoredPropertiesCache[$class];
+        }
+
+        $ignored    = [];
+        $reflection = new ReflectionClass($class);
+
+        foreach ($reflection->getProperties(ReflectionProperty::IS_PROTECTED | ReflectionProperty::IS_PRIVATE | ReflectionProperty::IS_PUBLIC) as $property) {
+            if ([] !== $property->getAttributes(AuditIgnore::class)) {
+                $ignored[] = $property->getName();
+            }
+        }
+
+        $this->ignoredPropertiesCache[$class] = $ignored;
+
+        return $ignored;
+    }
+
+    /**
+     * Transforme un FQCN `App\Module\Core\Domain\Entity\User` en `core.User`.
+     *
+     * Format `module.Entity` pour eviter les collisions inter-modules.
+     */
+    private function formatEntityType(string $class): string
+    {
+        if (1 === preg_match('#^App\\\Module\\\(?<module>[^\\\]+)\\\.+\\\(?<entity>[^\\\]+)$#', $class, $matches)) {
+            return strtolower($matches['module']).'.'.$matches['entity'];
+        }
+
+        // Fallback : on retourne le FQCN complet si la regex ne matche pas
+        // (entite hors structure modulaire — ne devrait pas arriver).
+        return $class;
+    }
+
+    private function resolveEntityId(object $entity, ClassMetadata $metadata): ?string
+    {
+        $identifier = $metadata->getIdentifierValues($entity);
+        if ([] === $identifier) {
+            return null;
+        }
+
+        // Cle composee : on concatene les valeurs. Cas rare sur le projet.
+        return implode('-', array_map(static fn ($v) => (string) $v, $identifier));
+    }
+
+    /**
+     * Normalise une valeur pour encodage JSON stable.
+     */
+    private function normalizeValue(mixed $value): mixed
+    {
+        if ($value instanceof DateTimeInterface) {
+            return $value->format(DateTimeInterface::ATOM);
+        }
+
+        if (is_object($value)) {
+            // Relation to-one non parsee par buildSnapshot (cas update sur
+            // un champ qui devient un objet) : on tente getId() si possible.
+            if (method_exists($value, 'getId')) {
+                return $value->getId();
+            }
+
+            return (string) $value;
+        }
+
+        return $value;
+    }
+}

src/Module/Sites/Application/Service/CurrentSiteProvider.php

@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Sites\Application\Service;
+
+use App\Module\Core\Domain\Entity\User;
+use App\Module\Sites\Domain\Entity\Site;
+use App\Module\Sites\SitesModule;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\DependencyInjection\Attribute\Autowire;
+
+use function in_array;
+
+/**
+ * Resout le site courant de l'utilisateur authentifie pour les besoins de
+ * l'outillage opt-in "site-aware" (ticket 4 module Sites).
+ *
+ * Consomme par :
+ *  - SiteScopedQueryExtension : filtrage automatique des collections API.
+ *  - SiteAwareInjectionProcessor : injection automatique sur POST/PATCH.
+ *
+ * Retourne `null` dans trois cas distincts (chacun volontairement
+ * silencieux pour que les extensions/processor deviennent no-op sans
+ * erreur visible) :
+ *  1. Le module Sites est desactive dans `config/modules.php`.
+ *  2. Aucun user n'est authentifie (appel depuis un endpoint public).
+ *  3. L'user authentifie n'a pas de `currentSite` positionne (cas rare
+ *     grace a la garde `UserRbacProcessor::ensureCurrentSiteConsistency`).
+ *
+ * Le flag `sitesActive` est calcule UNE FOIS au boot du service pour
+ * eviter un `require` a chaque resolution.
+ */
+final class CurrentSiteProvider implements CurrentSiteProviderInterface
+{
+    private readonly bool $sitesActive;
+
+    public function __construct(
+        private readonly Security $security,
+        #[Autowire(param: 'kernel.project_dir')]
+        string $projectDir,
+    ) {
+        // Lit config/modules.php (tableau de FQCN) et verifie la presence
+        // de SitesModule::class. Pattern aligne sur ModulesProvider.
+        $configPath    = $projectDir.'/config/modules.php';
+        $moduleClasses = file_exists($configPath) ? require $configPath : [];
+
+        $this->sitesActive = in_array(SitesModule::class, $moduleClasses, true);
+    }
+
+    /**
+     * Retourne le site courant de l'utilisateur authentifie, ou null si
+     * l'une des 3 conditions de desactivation est remplie (cf. docblock
+     * de classe).
+     */
+    public function get(): ?Site
+    {
+        if (!$this->sitesActive) {
+            return null;
+        }
+
+        $user = $this->security->getUser();
+        if (!$user instanceof User) {
+            return null;
+        }
+
+        return $user->getCurrentSite();
+    }
+}

src/Module/Sites/Application/Service/CurrentSiteProviderInterface.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Sites\Application\Service;
+
+use App\Module\Sites\Domain\Entity\Site;
+
+/**
+ * Contrat de resolution du site courant pour l'outillage opt-in
+ * "site-aware" (ticket 4 module Sites).
+ *
+ * Facilite le test de l'extension et du processor en permettant un mock
+ * sans dependre de l'implementation concrete (qui garde `final` pour
+ * l'immutabilite du service en prod).
+ *
+ * Retourne `null` dans trois cas (cf. CurrentSiteProvider) :
+ *  - module Sites desactive dans config/modules.php
+ *  - pas d'user authentifie
+ *  - user sans currentSite positionne
+ */
+interface CurrentSiteProviderInterface
+{
+    public function get(): ?Site;
+}

src/Module/Sites/Domain/Entity/Site.php

@@ -0,0 +1,329 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Sites\Domain\Entity;
+
+use ApiPlatform\Metadata\ApiResource;
+use ApiPlatform\Metadata\Delete;
+use ApiPlatform\Metadata\Get;
+use ApiPlatform\Metadata\GetCollection;
+use ApiPlatform\Metadata\Patch;
+use ApiPlatform\Metadata\Post;
+use App\Module\Core\Domain\Entity\User;
+use App\Module\Sites\Infrastructure\Doctrine\DoctrineSiteRepository;
+use App\Shared\Domain\Attribute\Auditable;
+use App\Shared\Domain\Contract\SiteInterface;
+use DateTimeImmutable;
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\Collections\Collection;
+use Doctrine\DBAL\Types\Types;
+use Doctrine\ORM\Mapping as ORM;
+use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
+use Symfony\Component\Serializer\Attribute\Groups;
+use Symfony\Component\Validator\Constraints as Assert;
+
+/**
+ * Site physique (usine / etablissement) appartenant a l'instance Coltura.
+ *
+ * Adresse decomposee en champs structures (rue, complement, CP, ville) pour
+ * permettre des recherches/tris fins ulterieurs et eviter les divergences
+ * entre champs duplique. La methode `getFullAddress()` fournit la version
+ * concatenee multi-lignes pour les usages d'affichage.
+ *
+ * Expose en API Platform pour l'administration CRUD avec RBAC :
+ *  - lecture (GET list / item) : requiert la permission `sites.view`
+ *  - ecriture (POST / PATCH / DELETE) : requiert la permission `sites.manage`
+ *
+ * Egalement embarque dans la reponse `/api/me` (groupe `me:read`) pour que
+ * le frontend connaisse les sites autorises et le site courant de l'user.
+ */
+#[ApiResource(
+    operations: [
+        new GetCollection(
+            normalizationContext: ['groups' => ['site:read']],
+            security: "is_granted('sites.view')",
+        ),
+        new Get(
+            normalizationContext: ['groups' => ['site:read']],
+            security: "is_granted('sites.view')",
+        ),
+        new Post(
+            normalizationContext: ['groups' => ['site:read']],
+            denormalizationContext: ['groups' => ['site:write']],
+            security: "is_granted('sites.manage')",
+        ),
+        new Patch(
+            normalizationContext: ['groups' => ['site:read']],
+            denormalizationContext: ['groups' => ['site:write']],
+            security: "is_granted('sites.manage')",
+        ),
+        new Delete(security: "is_granted('sites.manage')"),
+    ],
+    normalizationContext: ['groups' => ['site:read']],
+    denormalizationContext: ['groups' => ['site:write']],
+)]
+#[ORM\Entity(repositoryClass: DoctrineSiteRepository::class)]
+#[ORM\Table(name: 'site')]
+#[Auditable]
+#[ORM\UniqueConstraint(name: 'uniq_site_name', columns: ['name'])]
+#[ORM\HasLifecycleCallbacks]
+#[UniqueEntity(fields: ['name'], message: 'Un site avec ce nom existe deja.')]
+class Site implements SiteInterface
+{
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    #[ORM\Column]
+    #[Groups(['site:read', 'me:read'])]
+    private ?int $id = null;
+
+    #[ORM\Column(length: 100)]
+    #[Assert\NotBlank(message: 'Le nom du site est requis.')]
+    #[Assert\Length(max: 100, maxMessage: 'Le nom du site ne peut pas depasser {{ limit }} caracteres.')]
+    #[Groups(['site:read', 'site:write', 'me:read'])]
+    private string $name;
+
+    // Premiere ligne d'adresse : numero + voie. Requise.
+    #[ORM\Column(length: 255)]
+    #[Assert\NotBlank(message: 'La rue est requise.')]
+    #[Assert\Length(max: 255, maxMessage: 'La rue ne peut pas depasser {{ limit }} caracteres.')]
+    #[Groups(['site:read', 'site:write', 'me:read'])]
+    private string $street;
+
+    // Complement d'adresse optionnel : batiment, escalier, BP, etc.
+    #[ORM\Column(length: 255, nullable: true)]
+    #[Assert\Length(max: 255, maxMessage: 'Le complement ne peut pas depasser {{ limit }} caracteres.')]
+    #[Groups(['site:read', 'site:write', 'me:read'])]
+    private ?string $complement = null;
+
+    // Colonne mappee sur le snake_case PostgreSQL (convention projet : noms de
+    // colonnes en minuscules dans le SQL brut). Le format est contraint au
+    // code postal francais strict : 5 chiffres numeriques.
+    #[ORM\Column(name: 'postal_code', length: 10)]
+    #[Assert\NotBlank(message: 'Le code postal est requis.')]
+    #[Assert\Length(max: 10, maxMessage: 'Le code postal ne peut pas depasser {{ limit }} caracteres.')]
+    #[Assert\Regex(
+        pattern: '/^\d{5}$/',
+        message: 'Le code postal doit etre compose de 5 chiffres (format FR).',
+    )]
+    #[Groups(['site:read', 'site:write', 'me:read'])]
+    private string $postalCode;
+
+    #[ORM\Column(length: 100)]
+    #[Assert\NotBlank(message: 'La ville du site est requise.')]
+    #[Assert\Length(max: 100, maxMessage: 'La ville ne peut pas depasser {{ limit }} caracteres.')]
+    #[Groups(['site:read', 'site:write', 'me:read'])]
+    private string $city;
+
+    // Couleur d'identification visuelle du site au format hex #RRGGBB (7 chars
+    // incluant le diese). Utilisee par la navbar (ticket 3) pour distinguer
+    // les sites d'un coup d'oeil.
+    #[ORM\Column(length: 7)]
+    #[Assert\NotBlank(message: 'La couleur est requise.')]
+    #[Assert\Regex(
+        pattern: '/^#[0-9A-Fa-f]{6}$/',
+        message: 'La couleur doit etre un code hex de 7 caracteres au format #RRGGBB.',
+    )]
+    #[Groups(['site:read', 'site:write', 'me:read'])]
+    private string $color;
+
+    // createdAt / updatedAt volontairement exclus du groupe `me:read` :
+    // le payload `/api/me` doit rester leger, ces metadonnees ne sont utiles
+    // qu'a l'admin (exposees uniquement via `site:read` sur /api/sites).
+    #[ORM\Column(name: 'created_at', type: Types::DATETIME_IMMUTABLE)]
+    #[Groups(['site:read'])]
+    private DateTimeImmutable $createdAt;
+
+    #[ORM\Column(name: 'updated_at', type: Types::DATETIME_IMMUTABLE)]
+    #[Groups(['site:read'])]
+    private DateTimeImmutable $updatedAt;
+
+    /**
+     * Collection inverse des users rattaches a ce site.
+     *
+     * Volontairement SANS `#[Groups]` : la collection n'est jamais exposee via
+     * l'API pour deux raisons :
+     *  - eviter une boucle de serialisation infinie User → sites → users → ...
+     *    si un jour un developpeur ajoute `me:read` ici par megarde ;
+     *  - l'inverse n'a de valeur qu'en interne (compter les users d'un site,
+     *    iterer en test de cascade).
+     *
+     * @var Collection<int, User>
+     */
+    #[ORM\ManyToMany(targetEntity: User::class, mappedBy: 'sites')]
+    private Collection $users;
+
+    public function __construct(
+        string $name,
+        string $street,
+        ?string $complement,
+        string $postalCode,
+        string $city,
+        string $color,
+    ) {
+        $this->name       = $name;
+        $this->street     = $street;
+        $this->complement = $complement;
+        $this->postalCode = $postalCode;
+        $this->city       = $city;
+        $this->color      = $color;
+        $now              = new DateTimeImmutable();
+        $this->createdAt  = $now;
+        $this->updatedAt  = $now;
+        $this->users      = new ArrayCollection();
+    }
+
+    /**
+     * Callback Doctrine : a chaque update en base on rafraichit updatedAt.
+     * Ne pas toucher a createdAt ici (immutable apres creation).
+     */
+    #[ORM\PreUpdate]
+    public function onPreUpdate(): void
+    {
+        $this->updatedAt = new DateTimeImmutable();
+    }
+
+    public function getId(): ?int
+    {
+        return $this->id;
+    }
+
+    public function getName(): string
+    {
+        return $this->name;
+    }
+
+    public function setName(string $name): static
+    {
+        $this->name = $name;
+
+        return $this;
+    }
+
+    public function getStreet(): string
+    {
+        return $this->street;
+    }
+
+    public function setStreet(string $street): static
+    {
+        $this->street = $street;
+
+        return $this;
+    }
+
+    public function getComplement(): ?string
+    {
+        return $this->complement;
+    }
+
+    public function setComplement(?string $complement): static
+    {
+        $this->complement = $complement;
+
+        return $this;
+    }
+
+    public function getPostalCode(): string
+    {
+        return $this->postalCode;
+    }
+
+    public function setPostalCode(string $postalCode): static
+    {
+        $this->postalCode = $postalCode;
+
+        return $this;
+    }
+
+    public function getCity(): string
+    {
+        return $this->city;
+    }
+
+    public function setCity(string $city): static
+    {
+        $this->city = $city;
+
+        return $this;
+    }
+
+    public function getColor(): string
+    {
+        return $this->color;
+    }
+
+    public function setColor(string $color): static
+    {
+        $this->color = $color;
+
+        return $this;
+    }
+
+    /**
+     * Adresse complete reconstituee : street, [complement,] {CP} {ville},
+     * separes par des sauts de ligne. Methode pure, jamais persistee.
+     *
+     * Expose en lecture API (groupes site:read + me:read) pour que les
+     * consommateurs (frontend, exports PDF) recoivent une adresse prete a
+     * afficher sans dupliquer la logique de concatenation cote client.
+     */
+    #[Groups(['site:read', 'me:read'])]
+    public function getFullAddress(): string
+    {
+        $lines = [$this->street];
+
+        if (null !== $this->complement && '' !== trim($this->complement)) {
+            $lines[] = $this->complement;
+        }
+
+        $lines[] = sprintf('%s %s', $this->postalCode, $this->city);
+
+        return implode("\n", $lines);
+    }
+
+    public function getCreatedAt(): DateTimeImmutable
+    {
+        return $this->createdAt;
+    }
+
+    public function getUpdatedAt(): DateTimeImmutable
+    {
+        return $this->updatedAt;
+    }
+
+    /**
+     * @return Collection<int, User>
+     */
+    public function getUsers(): Collection
+    {
+        return $this->users;
+    }
+
+    /**
+     * Synchronise la collection inverse cote Site quand User::addSite est
+     * appele. Idempotent. Ne re-appelle pas $user->addSite($this) pour
+     * eviter une recursion infinie : User::addSite est le point d'entree
+     * unique de la mutation.
+     *
+     * @internal Appele uniquement par User::addSite()
+     */
+    public function addUser(User $user): static
+    {
+        if (!$this->users->contains($user)) {
+            $this->users->add($user);
+        }
+
+        return $this;
+    }
+
+    /**
+     * @internal Appele uniquement par User::removeSite()
+     */
+    public function removeUser(User $user): static
+    {
+        $this->users->removeElement($user);
+
+        return $this;
+    }
+}

src/Module/Sites/Domain/Exception/SiteNotAuthorizedException.php

@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Sites\Domain\Exception;
+
+use App\Shared\Domain\Exception\SiteNotAuthorizedException as SharedSiteNotAuthorizedException;
+
+/**
+ * Alias de retrocompatibilite vers Shared\Domain\Exception\SiteNotAuthorizedException.
+ *
+ * La classe canonique a ete deplacee dans Shared pour rompre le couplage
+ * Core → Sites. Les consommateurs existants dans le module Sites
+ * (CurrentSiteProcessor) continuent de l'attraper ici sans modification.
+ *
+ * @see SharedSiteNotAuthorizedException
+ */
+final class SiteNotAuthorizedException extends SharedSiteNotAuthorizedException {}

src/Module/Sites/Domain/Repository/SiteRepositoryInterface.php

@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Sites\Domain\Repository;
+
+use App\Module\Sites\Domain\Entity\Site;
+
+interface SiteRepositoryInterface
+{
+    public function findById(int $id): ?Site;
+
+    public function findByName(string $name): ?Site;
+
+    /**
+     * @return list<Site>
+     */
+    public function findAllOrderedByName(): array;
+
+    public function save(Site $site): void;
+
+    public function remove(Site $site): void;
+}

src/Module/Sites/Infrastructure/ApiPlatform/Extension/SiteCollectionScopedExtension.php

@@ -0,0 +1,110 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Sites\Infrastructure\ApiPlatform\Extension;
+
+use ApiPlatform\Doctrine\Orm\Extension\QueryCollectionExtensionInterface;
+use ApiPlatform\Doctrine\Orm\Extension\QueryItemExtensionInterface;
+use ApiPlatform\Doctrine\Orm\Util\QueryNameGeneratorInterface;
+use ApiPlatform\Metadata\Operation;
+use App\Module\Core\Domain\Entity\User;
+use App\Module\Sites\Domain\Entity\Site;
+use Doctrine\ORM\QueryBuilder;
+use Symfony\Bundle\SecurityBundle\Security;
+
+use function sprintf;
+
+/**
+ * Extension API Platform qui restreint les collections et items de la
+ * resource Site (/api/sites) aux seuls sites auxquels l'utilisateur
+ * authentifie est rattache (ticket module Sites — prevention de la fuite
+ * de donnees cross-tenant).
+ *
+ * `Site` n'implemente pas `SiteAwareInterface` (ce serait circulaire : un
+ * site ne s'appartient pas a lui-meme). Cette extension complementaire
+ * cible specifiquement `Site::class` et applique un filtre IN sur les IDs
+ * des sites de l'utilisateur.
+ *
+ * Comportement selon les cas :
+ *  - resource != Site::class          → no-op (les autres resources sont
+ *                                        gerees par SiteScopedQueryExtension) ;
+ *  - is_granted('sites.bypass_scope') → pas de filtre (admin / bypass) ;
+ *  - user non authentifie             → no-op (API Platform renvoie 401 avant) ;
+ *  - user sans aucun site             → WHERE 1 = 0 (aucun acces) ;
+ *  - cas normal                       → WHERE site.id IN (:allowedSites).
+ *
+ * Consequence anti-enumeration : GET /api/sites/{id} retourne 404 et non
+ * 403 si l'item existe mais n'appartient pas aux sites de l'utilisateur
+ * (comportement natif API Platform quand Doctrine retourne null).
+ */
+final class SiteCollectionScopedExtension implements QueryCollectionExtensionInterface, QueryItemExtensionInterface
+{
+    public function __construct(
+        private readonly Security $security,
+    ) {}
+
+    public function applyToCollection(
+        QueryBuilder $queryBuilder,
+        QueryNameGeneratorInterface $queryNameGenerator,
+        string $resourceClass,
+        ?Operation $operation = null,
+        array $context = [],
+    ): void {
+        $this->applyScope($queryBuilder, $queryNameGenerator, $resourceClass);
+    }
+
+    public function applyToItem(
+        QueryBuilder $queryBuilder,
+        QueryNameGeneratorInterface $queryNameGenerator,
+        string $resourceClass,
+        array $identifiers,
+        ?Operation $operation = null,
+        array $context = [],
+    ): void {
+        $this->applyScope($queryBuilder, $queryNameGenerator, $resourceClass);
+    }
+
+    /**
+     * Applique le filtre IN sur les IDs de sites autorises si les conditions
+     * d'application sont remplies. No-op sinon.
+     */
+    private function applyScope(
+        QueryBuilder $queryBuilder,
+        QueryNameGeneratorInterface $queryNameGenerator,
+        string $resourceClass,
+    ): void {
+        // 1) Cette extension cible uniquement la resource Site.
+        if (Site::class !== $resourceClass) {
+            return;
+        }
+
+        // 2) Admin ou user avec bypass explicite : visibilite globale.
+        if ($this->security->isGranted('sites.bypass_scope')) {
+            return;
+        }
+
+        // 3) Pas d'user authentifie -> no-op (API Platform gere le 401 en amont).
+        $user = $this->security->getUser();
+        if (!$user instanceof User) {
+            return;
+        }
+
+        $rootAlias = $queryBuilder->getRootAliases()[0];
+
+        // 4) User sans aucun site rattache -> aucun acces possible.
+        $siteIds = $user->getSites()->map(fn (Site $s) => $s->getId())->toArray();
+        if (empty($siteIds)) {
+            $queryBuilder->andWhere('1 = 0');
+
+            return;
+        }
+
+        // 5) Cas normal : restriction aux sites autorises de l'utilisateur.
+        $param = $queryNameGenerator->generateParameterName('allowedSites');
+        $queryBuilder
+            ->andWhere(sprintf('%s.id IN (:%s)', $rootAlias, $param))
+            ->setParameter($param, $siteIds)
+        ;
+    }
+}

src/Module/Sites/Infrastructure/ApiPlatform/Extension/SiteScopedQueryExtension.php

@@ -0,0 +1,108 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Sites\Infrastructure\ApiPlatform\Extension;
+
+use ApiPlatform\Doctrine\Orm\Extension\QueryCollectionExtensionInterface;
+use ApiPlatform\Doctrine\Orm\Extension\QueryItemExtensionInterface;
+use ApiPlatform\Doctrine\Orm\Util\QueryNameGeneratorInterface;
+use ApiPlatform\Metadata\Operation;
+use App\Module\Sites\Application\Service\CurrentSiteProviderInterface;
+use App\Shared\Domain\Contract\SiteAwareInterface;
+use Doctrine\ORM\QueryBuilder;
+use Symfony\Bundle\SecurityBundle\Security;
+
+use function is_subclass_of;
+use function sprintf;
+
+/**
+ * Extension API Platform qui filtre automatiquement les collections et les
+ * items des resources implementant SiteAwareInterface selon le site
+ * courant de l'utilisateur authentifie (ticket 4 module Sites).
+ *
+ * Appliquee automatiquement par API Platform sur toutes les requetes GET
+ * (collection + item), mais devient no-op si :
+ *  - la resource cible n'implemente pas SiteAwareInterface ;
+ *  - l'user a la permission `sites.bypass_scope` ;
+ *  - CurrentSiteProvider::get() retourne null (module desactive, pas
+ *    d'user authentifie, ou user sans currentSite).
+ *
+ * Le filtrage est identique pour les deux interfaces Collection et Item,
+ * factorise dans `applyScope()`. Consequence sur GET /api/resource/{id} :
+ * si l'item existe en base mais appartient a un autre site, Doctrine
+ * retourne null apres filtrage et API Platform converti en 404
+ * (anti-enumeration : le user ne peut pas distinguer "n'existe pas" de
+ * "appartient a un autre site").
+ */
+final class SiteScopedQueryExtension implements QueryCollectionExtensionInterface, QueryItemExtensionInterface
+{
+    public function __construct(
+        private readonly CurrentSiteProviderInterface $currentSiteProvider,
+        private readonly Security $security,
+    ) {}
+
+    public function applyToCollection(
+        QueryBuilder $queryBuilder,
+        QueryNameGeneratorInterface $queryNameGenerator,
+        string $resourceClass,
+        ?Operation $operation = null,
+        array $context = [],
+    ): void {
+        $this->applyScope($queryBuilder, $queryNameGenerator, $resourceClass);
+    }
+
+    public function applyToItem(
+        QueryBuilder $queryBuilder,
+        QueryNameGeneratorInterface $queryNameGenerator,
+        string $resourceClass,
+        array $identifiers,
+        ?Operation $operation = null,
+        array $context = [],
+    ): void {
+        $this->applyScope($queryBuilder, $queryNameGenerator, $resourceClass);
+    }
+
+    /**
+     * Ajoute la clause `WHERE <alias>.site = :currentSite` au query builder
+     * si les 3 conditions d'application sont remplies. No-op sinon.
+     */
+    private function applyScope(
+        QueryBuilder $queryBuilder,
+        QueryNameGeneratorInterface $queryNameGenerator,
+        string $resourceClass,
+    ): void {
+        // 1) Filtrer uniquement les resources qui ont opt-in via l'interface.
+        //    `is_subclass_of` gere a la fois `implements` direct et herite.
+        if (!is_subclass_of($resourceClass, SiteAwareInterface::class)) {
+            return;
+        }
+
+        // 2) Admin ou user avec bypass explicite : visibilite globale.
+        //    is_granted('sites.bypass_scope') retourne true pour les admins
+        //    (bypass total via isAdmin) meme sans permission explicite.
+        if ($this->security->isGranted('sites.bypass_scope')) {
+            return;
+        }
+
+        // 3) Pas de site courant -> no-op plutot que collection vide.
+        //    Decision assumee (cf. ticket 4 spec Risque 1) : un user sans
+        //    currentSite voit tout. L'alternative "collection vide" est
+        //    rejetee car elle rendrait l'app inutilisable pour un user
+        //    mal configure.
+        $currentSite = $this->currentSiteProvider->get();
+        if (null === $currentSite) {
+            return;
+        }
+
+        // Application du filtre : alias racine du QueryBuilder, parametre
+        // genere pour eviter les collisions avec d'autres extensions.
+        $rootAlias     = $queryBuilder->getRootAliases()[0];
+        $parameterName = $queryNameGenerator->generateParameterName('currentSite');
+
+        $queryBuilder
+            ->andWhere(sprintf('%s.site = :%s', $rootAlias, $parameterName))
+            ->setParameter($parameterName, $currentSite)
+        ;
+    }
+}

src/Module/Sites/Infrastructure/ApiPlatform/Extension/UserSiteScopedExtension.php

@@ -0,0 +1,116 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Sites\Infrastructure\ApiPlatform\Extension;
+
+use ApiPlatform\Doctrine\Orm\Extension\QueryCollectionExtensionInterface;
+use ApiPlatform\Doctrine\Orm\Extension\QueryItemExtensionInterface;
+use ApiPlatform\Doctrine\Orm\Util\QueryNameGeneratorInterface;
+use ApiPlatform\Metadata\Operation;
+use App\Module\Core\Domain\Entity\User;
+use App\Module\Sites\Domain\Entity\Site;
+use Doctrine\ORM\QueryBuilder;
+use Symfony\Bundle\SecurityBundle\Security;
+
+use function sprintf;
+
+/**
+ * Extension API Platform qui restreint /api/users (collection + item) aux
+ * utilisateurs partageant au moins un site commun avec l'appelant.
+ *
+ * Objectif : empecher l'enumeration cross-site des utilisateurs. Sans ce
+ * filtre, un user du site A pourrait lister tous les users du site B via
+ * GET /api/users.
+ *
+ * Conditions de bypass :
+ *  - is_granted('sites.bypass_scope') → visibilite totale (admin ou bypass
+ *    explicite) ;
+ *  - user non authentifie             → no-op (API Platform renvoie 401) ;
+ *
+ * Cas particulier — appelant sans aucun site rattache :
+ *  Comportement defensif : l'utilisateur ne voit que lui-meme. Cela evite
+ *  de bloquer completement un user mal configure tout en ne lui revelant
+ *  aucun autre utilisateur.
+ *
+ * Strategie DQL : JOIN sur la relation ManyToMany `.sites` + DISTINCT pour
+ * eviter les doublons si un user partage plusieurs sites avec l'appelant.
+ * Le alias `s_scope` est utilise pour la jointure intermediaire.
+ */
+final class UserSiteScopedExtension implements QueryCollectionExtensionInterface, QueryItemExtensionInterface
+{
+    public function __construct(
+        private readonly Security $security,
+    ) {}
+
+    public function applyToCollection(
+        QueryBuilder $queryBuilder,
+        QueryNameGeneratorInterface $queryNameGenerator,
+        string $resourceClass,
+        ?Operation $operation = null,
+        array $context = [],
+    ): void {
+        $this->applyScope($queryBuilder, $queryNameGenerator, $resourceClass);
+    }
+
+    public function applyToItem(
+        QueryBuilder $queryBuilder,
+        QueryNameGeneratorInterface $queryNameGenerator,
+        string $resourceClass,
+        array $identifiers,
+        ?Operation $operation = null,
+        array $context = [],
+    ): void {
+        $this->applyScope($queryBuilder, $queryNameGenerator, $resourceClass);
+    }
+
+    /**
+     * Applique le filtre de partage de site si les conditions d'application
+     * sont remplies. No-op sinon.
+     */
+    private function applyScope(
+        QueryBuilder $queryBuilder,
+        QueryNameGeneratorInterface $queryNameGenerator,
+        string $resourceClass,
+    ): void {
+        // 1) Cette extension cible uniquement la resource User.
+        if (User::class !== $resourceClass) {
+            return;
+        }
+
+        // 2) Admin ou bypass explicite : visibilite totale.
+        if ($this->security->isGranted('sites.bypass_scope')) {
+            return;
+        }
+
+        // 3) Pas d'user authentifie -> no-op (API Platform gere le 401 en amont).
+        $user = $this->security->getUser();
+        if (!$user instanceof User) {
+            return;
+        }
+
+        $rootAlias     = $queryBuilder->getRootAliases()[0];
+        $callerSiteIds = $user->getSites()->map(fn (Site $s) => $s->getId())->toArray();
+
+        // 4) Appelant sans site : comportement defensif -> il ne voit que lui-meme.
+        if (empty($callerSiteIds)) {
+            $queryBuilder
+                ->andWhere(sprintf('%s.id = :self', $rootAlias))
+                ->setParameter('self', $user->getId())
+            ;
+
+            return;
+        }
+
+        // 5) Cas normal : garder uniquement les users qui partagent au moins
+        //    un site avec l'appelant. JOIN sur la relation ManyToMany `.sites`
+        //    + filtre IN + DISTINCT pour eviter les lignes dupliquees.
+        $param = $queryNameGenerator->generateParameterName('callerSites');
+        $queryBuilder
+            ->innerJoin(sprintf('%s.sites', $rootAlias), 's_scope')
+            ->andWhere(sprintf('s_scope.id IN (:%s)', $param))
+            ->setParameter($param, $callerSiteIds)
+            ->distinct()
+        ;
+    }
+}

src/Module/Sites/Infrastructure/ApiPlatform/Resource/CurrentSiteResource.php

@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Sites\Infrastructure\ApiPlatform\Resource;
+
+use ApiPlatform\Metadata\ApiResource;
+use ApiPlatform\Metadata\Patch;
+use App\Module\Sites\Domain\Entity\Site;
+use App\Module\Sites\Infrastructure\ApiPlatform\State\Processor\CurrentSiteProcessor;
+use Symfony\Component\Serializer\Attribute\Groups;
+
+/**
+ * Ressource API Platform virtuelle (non mappee Doctrine) qui porte
+ * l'operation `PATCH /api/me/current-site` : basculement du site courant
+ * de l'utilisateur authentifie.
+ *
+ * `read: false` informe API Platform qu'il ne doit pas tenter de charger
+ * une entite existante via un Provider — l'operation denormalise le payload
+ * directement dans cette ressource, puis CurrentSiteProcessor prend le relais.
+ *
+ * `shortName: 'CurrentSite'` : evite toute collision avec l'entite `Site`
+ * dans le routage et la documentation OpenAPI.
+ *
+ * Securite : l'autorisation "ROLE_USER" suffit au niveau voter — la verification
+ * fine (le site demande fait-il partie des sites autorises de l'user ?)
+ * est faite par CurrentSiteProcessor, car elle dependence de l'user
+ * authentifie, pas d'une permission statique.
+ */
+#[ApiResource(
+    shortName: 'CurrentSite',
+    operations: [
+        new Patch(
+            uriTemplate: '/me/current-site',
+            security: "is_granted('ROLE_USER')",
+            normalizationContext: ['groups' => ['me:read']],
+            denormalizationContext: ['groups' => ['current-site:write']],
+            processor: CurrentSiteProcessor::class,
+            read: false,
+            priority: 1,
+        ),
+    ],
+)]
+final class CurrentSiteResource
+{
+    /**
+     * Site cible du switch, denormalise depuis l'IRI envoye dans le body :
+     * `{ "site": "/api/sites/{id}" }`. Resolu automatiquement par
+     * l'IriConverter d'API Platform en instance de `Site`.
+     */
+    #[Groups(['current-site:write'])]
+    public ?Site $site = null;
+}

src/Module/Sites/Infrastructure/ApiPlatform/State/Processor/CurrentSiteProcessor.php

@@ -0,0 +1,99 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Sites\Infrastructure\ApiPlatform\State\Processor;
+
+use ApiPlatform\Metadata\Operation;
+use ApiPlatform\State\ProcessorInterface;
+use App\Module\Core\Domain\Entity\User;
+use App\Module\Sites\Domain\Exception\SiteNotAuthorizedException;
+use App\Module\Sites\Infrastructure\ApiPlatform\Resource\CurrentSiteResource;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\OptimisticLockException;
+use LogicException;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
+use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
+
+/**
+ * Processor de l'operation `PATCH /api/me/current-site`.
+ *
+ * Flux :
+ *  1. Recupere l'user authentifie via Security.
+ *  2. Extrait le site cible depuis la ressource denormalisee.
+ *  3. Refresh de l'user depuis la BDD pour eliminer la race condition TOCTOU :
+ *     si un autre thread a revoque le site entre le chargement de session et
+ *     ce PATCH, le refresh garantit que hasSite() reflete l'etat reel en base.
+ *  4. Valide que le site fait partie des `sites` de l'user — sinon leve
+ *     SiteNotAuthorizedException convertie immediatement en 403.
+ *  5. Positionne `currentSite`, flush, retourne l'user pour normalisation
+ *     par API Platform via les groupes `me:read` (payload identique a /api/me).
+ *
+ * Les etapes 3-5 sont executees dans une meme transaction pour garantir
+ * un rollback propre en cas d'erreur entre le refresh et le flush.
+ *
+ * @implements ProcessorInterface<CurrentSiteResource, User>
+ */
+final class CurrentSiteProcessor implements ProcessorInterface
+{
+    public function __construct(
+        private readonly Security $security,
+        private readonly EntityManagerInterface $entityManager,
+    ) {}
+
+    public function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): mixed
+    {
+        if (!$data instanceof CurrentSiteResource) {
+            throw new LogicException(sprintf(
+                'CurrentSiteProcessor attend une instance de %s, %s recu.',
+                CurrentSiteResource::class,
+                get_debug_type($data),
+            ));
+        }
+
+        $user = $this->security->getUser();
+        if (!$user instanceof User) {
+            // security: "is_granted('ROLE_USER')" sur l'operation doit deja
+            // bloquer ce cas — garde defensive si la config change.
+            throw new AccessDeniedHttpException('Authentification requise pour changer de site courant.');
+        }
+
+        $targetSite = $data->site;
+        if (null === $targetSite) {
+            throw new BadRequestHttpException('Le champ "site" est requis.');
+        }
+
+        // Refresh + switchCurrentSite + flush dans une transaction atomique.
+        // Le refresh elimine la race condition TOCTOU : si un PATCH /rbac concurrent
+        // a revoque le site de l'user entre le chargement de session et ici, le
+        // refresh force un re-fetch de l'user et de sa collection de sites depuis
+        // la BDD, garantissant que hasSite() reflete l'etat reel persisté.
+        try {
+            $this->entityManager->wrapInTransaction(function () use ($user, $targetSite): void {
+                // Re-fetch de l'user + ses collections depuis la BDD (elimination TOCTOU).
+                $this->entityManager->refresh($user);
+
+                try {
+                    $user->switchCurrentSite($targetSite);
+                } catch (SiteNotAuthorizedException $e) {
+                    // Traduction HTTP immediate (pas de listener kernel necessaire) :
+                    // aligne sur le pattern RoleProcessor → SystemRoleDeletionException.
+                    throw new AccessDeniedHttpException($e->getMessage(), $e);
+                }
+
+                $this->entityManager->flush();
+            });
+        } catch (OptimisticLockException $e) {
+            // Protection future : si un champ @Version est ajoute sur User,
+            // le conflit de version sera intercepte ici plutot que de remonter
+            // comme une erreur generique.
+            throw new BadRequestHttpException(
+                'Conflit de version detecte lors du changement de site courant. Veuillez reessayer.',
+                $e,
+            );
+        }
+
+        return $user;
+    }
+}

src/Module/Sites/Infrastructure/ApiPlatform/State/Processor/SiteAwareInjectionProcessor.php

@@ -0,0 +1,94 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Sites\Infrastructure\ApiPlatform\State\Processor;
+
+use ApiPlatform\Metadata\Operation;
+use ApiPlatform\State\ProcessorInterface;
+use App\Module\Core\Domain\Entity\User;
+use App\Module\Sites\Application\Service\CurrentSiteProviderInterface;
+use App\Module\Sites\Domain\Entity\Site;
+use App\Shared\Domain\Contract\SiteAwareInterface;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\DependencyInjection\Attribute\AsDecorator;
+use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
+use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
+
+/**
+ * Decorator du processor de persistance Doctrine d'API Platform qui injecte
+ * automatiquement le site courant de l'utilisateur sur les entites
+ * implementant SiteAwareInterface, si le payload ne precise pas de site.
+ *
+ * S'applique a TOUTES les operations POST/PATCH qui deleguent au persist
+ * processor natif. Les processors custom qui appellent
+ * `$this->persistProcessor->process()` (pattern UserRbacProcessor) passent
+ * aussi par ce decorator, transparent pour les entites non-SiteAware.
+ *
+ * Comportement :
+ *  - $data pas SiteAware -> delegation directe (no-op).
+ *  - $data SiteAware avec site deja positionne, appelant a `sites.bypass_scope`
+ *    -> delegation directe (ex: admin qui cree une entite dans un autre site).
+ *  - $data SiteAware avec site deja positionne, appelant SANS `sites.bypass_scope`
+ *    -> validation que le site precise appartient aux sites autorises de l'user.
+ *    Si non, leve AccessDeniedHttpException (cross-site write interdite).
+ *  - $data SiteAware sans site, provider retourne un Site -> injection
+ *    puis delegation.
+ *  - $data SiteAware sans site, provider retourne null -> throw 400
+ *    BadRequestHttpException avec message explicite.
+ *
+ * Volontairement HTTP-only : ne couvre pas les persistances hors API
+ * Platform (fixtures, commandes CLI, imports). Ces contextes doivent
+ * positionner le site explicitement — c'est assume dans la doc
+ * d'adoption (`docs/modules/site-aware.md`).
+ *
+ * @implements ProcessorInterface<mixed|SiteAwareInterface, mixed>
+ */
+#[AsDecorator('api_platform.doctrine.orm.state.persist_processor')]
+final class SiteAwareInjectionProcessor implements ProcessorInterface
+{
+    public function __construct(
+        private readonly ProcessorInterface $inner,
+        private readonly CurrentSiteProviderInterface $currentSiteProvider,
+        private readonly Security $security,
+    ) {}
+
+    public function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): mixed
+    {
+        if ($data instanceof SiteAwareInterface) {
+            if (null !== $data->getSite()) {
+                // Le payload precise un site explicite : on valide que le site
+                // appartient aux sites autorises de l'utilisateur courant, sauf
+                // si celui-ci dispose de la permission `sites.bypass_scope`
+                // (ex: admin effectuant une operation cross-site).
+                if (!$this->security->isGranted('sites.bypass_scope')) {
+                    $user         = $this->security->getUser();
+                    $explicitSite = $data->getSite();
+                    // hasSite() attend un Site concret. Si l'agent entity fait
+                    // evoluer la signature vers SiteInterface, le instanceof
+                    // reste valide (Site implemente SiteInterface) et le cast
+                    // disparaitra naturellement lors du prochain nettoyage.
+                    if ($user instanceof User && $explicitSite instanceof Site && !$user->hasSite($explicitSite)) {
+                        throw new AccessDeniedHttpException(
+                            'Le site specifie n\'est pas dans les sites autorises pour cet utilisateur.'
+                        );
+                    }
+                }
+            } else {
+                // Aucun site dans le payload : injection automatique depuis le
+                // site courant de l'utilisateur.
+                $currentSite = $this->currentSiteProvider->get();
+
+                if (null === $currentSite) {
+                    throw new BadRequestHttpException(
+                        'Impossible de creer l\'enregistrement : aucun site selectionne.',
+                    );
+                }
+
+                $data->setSite($currentSite);
+            }
+        }
+
+        return $this->inner->process($data, $operation, $uriVariables, $context);
+    }
+}

src/Module/Sites/Infrastructure/DataFixtures/SitesFixtures.php

@@ -0,0 +1,112 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Sites\Infrastructure\DataFixtures;
+
+use App\Module\Sites\Domain\Entity\Site;
+use App\Module\Sites\Domain\Repository\SiteRepositoryInterface;
+use Doctrine\Bundle\FixturesBundle\Fixture;
+use Doctrine\Persistence\ObjectManager;
+
+/**
+ * Fixtures du module Sites : 3 etablissements de demonstration utilises par
+ * les tickets suivants (rattachement utilisateurs, navbar, etc.).
+ *
+ * Idempotence supportee : le purger Doctrine (ORMPurger) vide la table
+ * `site` avant chaque `doctrine:fixtures:load`. Si le purger est
+ * desactive et la fixture rejouee telle quelle sur une base deja seedee,
+ * le lookup par nom evite le doublon et re-aligne les autres champs.
+ *
+ * Idempotence NON supportee :
+ *  - chargement cumulatif apres qu'une autre fixture ait persiste (sans
+ *    flush) des Site dans la meme session : `findByName()` s'appuie sur
+ *    `findOneBy`, qui n'inspecte pas les entites en attente dans l'unit-of-work
+ *    et peut renvoyer null alors qu'un homonyme est deja manage ;
+ *  - renommage d'un site : le nom etant la cle de lookup, modifier
+ *    `name` dans cette fixture cree un nouveau site et laisse l'ancien
+ *    en base (purger desactive). Les autres champs (city, color, etc.)
+ *    sont en revanche bien re-synchronises pour un site retrouve.
+ */
+class SitesFixtures extends Fixture
+{
+    public function __construct(
+        private readonly SiteRepositoryInterface $siteRepository,
+    ) {}
+
+    public function load(ObjectManager $manager): void
+    {
+        // Chatellerault : bleu Coltura.
+        $this->ensureSite(
+            $manager,
+            name: 'Chatellerault',
+            street: "14 All. d'Argenson",
+            complement: null,
+            postalCode: '86100',
+            city: 'Châtellerault',
+            color: '#056CF2',
+        );
+
+        // Saint-Jean : jaune vif. Le nom du site (identifier) ne reflete
+        // pas la ville reelle (Fontenet) — c'est une nomenclature interne
+        // client.
+        $this->ensureSite(
+            $manager,
+            name: 'Saint-Jean',
+            street: 'Z i',
+            complement: null,
+            postalCode: '17400',
+            city: 'Fontenet',
+            color: '#F3CB00',
+        );
+
+        // Pommevic : vert clair.
+        $this->ensureSite(
+            $manager,
+            name: 'Pommevic',
+            street: '1 Av. Jean Duquesne',
+            complement: null,
+            postalCode: '82400',
+            city: 'Pommevic',
+            color: '#74BF04',
+        );
+
+        $manager->flush();
+    }
+
+    /**
+     * Cree le site s'il n'existe pas encore, sinon re-aligne rue, complement,
+     * code postal, ville et couleur sur les valeurs de reference.
+     *
+     * Note : le nom sert de cle de lookup (il est unique en base) et n'est
+     * donc pas resynchronise. Consequence : renommer un site dans la
+     * fixture cree un nouveau site sans supprimer l'ancien, sauf si le
+     * purger Doctrine est actif (cas nominal de `doctrine:fixtures:load`).
+     */
+    private function ensureSite(
+        ObjectManager $manager,
+        string $name,
+        string $street,
+        ?string $complement,
+        string $postalCode,
+        string $city,
+        string $color,
+    ): Site {
+        $site = $this->siteRepository->findByName($name);
+
+        if (null === $site) {
+            $site = new Site($name, $street, $complement, $postalCode, $city, $color);
+            $manager->persist($site);
+
+            return $site;
+        }
+
+        $site->setStreet($street);
+        $site->setComplement($complement);
+        $site->setPostalCode($postalCode);
+        $site->setCity($city);
+        $site->setColor($color);
+
+        return $site;
+    }
+}

src/Module/Sites/Infrastructure/Doctrine/DoctrineSiteRepository.php

@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Sites\Infrastructure\Doctrine;
+
+use App\Module\Sites\Domain\Entity\Site;
+use App\Module\Sites\Domain\Repository\SiteRepositoryInterface;
+use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
+use Doctrine\Persistence\ManagerRegistry;
+
+/**
+ * @extends ServiceEntityRepository<Site>
+ */
+class DoctrineSiteRepository extends ServiceEntityRepository implements SiteRepositoryInterface
+{
+    public function __construct(ManagerRegistry $registry)
+    {
+        parent::__construct($registry, Site::class);
+    }
+
+    public function findById(int $id): ?Site
+    {
+        return $this->find($id);
+    }
+
+    public function findByName(string $name): ?Site
+    {
+        return $this->findOneBy(['name' => $name]);
+    }
+
+    /**
+     * @return list<Site>
+     */
+    public function findAllOrderedByName(): array
+    {
+        // @var list<Site> $sites
+        return $this->findBy([], ['name' => 'ASC']);
+    }
+
+    public function save(Site $site): void
+    {
+        $this->getEntityManager()->persist($site);
+        $this->getEntityManager()->flush();
+    }
+
+    public function remove(Site $site): void
+    {
+        $this->getEntityManager()->remove($site);
+        $this->getEntityManager()->flush();
+    }
+}

src/Module/Sites/SitesModule.php

@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Sites;
+
+final class SitesModule
+{
+    public const string ID     = 'sites';
+    public const string LABEL  = 'Sites';
+    public const bool REQUIRED = false;
+
+    /**
+     * Liste declarative des permissions RBAC exposees par le module Sites.
+     *
+     * Consommee par la commande `app:sync-permissions` (SyncPermissionsCommand)
+     * qui se charge d'upserter ces entrees dans la table `permission`, de
+     * reactiver les codes precedemment marques orphelins et de marquer comme
+     * orphelins ceux qui ont disparu du code source.
+     *
+     * La cle `module` est auto-injectee par le sync command a partir de
+     * `self::ID`, il est donc inutile de la repeter dans chaque entree.
+     *
+     * Convention de nommage des codes : `module.resource[.sub].action` en
+     * snake_case, le prefixe module devant correspondre exactement a
+     * `self::ID` (verifie par la commande de synchronisation).
+     *
+     * @return array<int, array{code: string, label: string}>
+     */
+    public static function permissions(): array
+    {
+        return [
+            ['code' => 'sites.view', 'label' => 'Voir les sites'],
+            ['code' => 'sites.manage', 'label' => 'Gerer les sites (creer, editer, supprimer)'],
+            ['code' => 'sites.bypass_scope', 'label' => 'Voir les donnees site-scoped de tous les sites (bypass du filtrage)'],
+        ];
+    }
+}

src/Shared/Domain/Attribute/AuditIgnore.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Shared\Domain\Attribute;
+
+use Attribute;
+
+/**
+ * Marqueur a poser sur une propriete d'entite pour l'exclure du tracking audit.
+ *
+ * Usage typique : champs sensibles (password, token), champs bruyants (updatedAt
+ * si recalcule sur chaque ecriture), champs derives. L'AuditLogWriter porte
+ * deja une blacklist exact-match sur les noms les plus dangereux (password,
+ * plainPassword, token, secret) en defense-in-depth, mais la regle de base
+ * reste : annoter explicitement ce qu'on ne veut pas voir trace.
+ */
+#[Attribute(Attribute::TARGET_PROPERTY)]
+final class AuditIgnore {}

src/Shared/Domain/Attribute/Auditable.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Shared\Domain\Attribute;
+
+use Attribute;
+
+/**
+ * Marqueur a poser sur une entite Doctrine pour activer le tracking audit.
+ *
+ * Emplacement dans Shared (pas dans Core) pour que tous les modules puissent
+ * l'utiliser sans dependance circulaire vers Core.
+ *
+ * Regle projet (cf. doc/audit-log.md) : toute entite metier DOIT porter cet
+ * attribut, avec #[AuditIgnore] sur les champs sensibles ou bruyants.
+ */
+#[Attribute(Attribute::TARGET_CLASS)]
+final class Auditable {}

src/Shared/Domain/Contract/SiteAwareInterface.php

@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Shared\Domain\Contract;
+
+/**
+ * Contrat opt-in pour les entites dont la visibilite est scopee par site.
+ *
+ * Une entite implementant cette interface sera :
+ *  - filtree en lecture par SiteScopedQueryExtension (collection + item)
+ *    selon le site courant de l'utilisateur authentifie ;
+ *  - alimentee automatiquement en POST/PATCH par SiteAwareInjectionProcessor
+ *    si le payload ne precise pas de site.
+ *
+ * L'implementation concrete doit :
+ *  - Declarer une relation ManyToOne vers l'entite concrete Site avec colonne
+ *    `site_id` NOT NULL (targetEntity: \App\Module\Sites\Domain\Entity\Site).
+ *  - Indexer `site_id` en base (sinon le filtre WHERE genere un full-scan).
+ *
+ * Les signatures utilisent SiteInterface (et non la classe concrete Site)
+ * pour que Shared n'importe pas directement le module Sites.
+ *
+ * Ne PAS implementer cette interface pour :
+ *  - Des entites globales (catalogue partage, roles, permissions, users).
+ *  - Des entites dont le scope est "par tenant" plus large que le site
+ *    (utiliser TenantAwareInterface le cas echeant).
+ *  - Des entites transversales references par plusieurs sites.
+ *
+ * Voir `docs/modules/site-aware.md` pour le guide d'adoption complet.
+ */
+interface SiteAwareInterface
+{
+    public function getSite(): ?SiteInterface;
+
+    public function setSite(SiteInterface $site): void;
+}

src/Shared/Domain/Contract/SiteInterface.php

@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Shared\Domain\Contract;
+
+/**
+ * Interface minimale exposant ce que le noyau (Shared/Core) doit connaitre
+ * d'un Site, sans creer de couplage direct vers le module Sites.
+ *
+ * Implemente par App\Module\Sites\Domain\Entity\Site.
+ * Utilisee comme type-hint dans SiteAwareInterface, User et toute entite
+ * Shared/Core qui manipule un site sans avoir besoin des details metier.
+ */
+interface SiteInterface
+{
+    public function getId(): ?int;
+
+    public function getName(): ?string;
+}

src/Shared/Domain/Exception/SiteNotAuthorizedException.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Shared\Domain\Exception;
+
+use App\Shared\Domain\Contract\SiteInterface;
+use DomainException;
+
+/**
+ * Levee lorsqu'un utilisateur tente de selectionner comme site courant un
+ * site qui ne fait pas partie de ses sites autorises.
+ *
+ * Exception purement domaine : la traduction HTTP (403) est faite par le
+ * CurrentSiteProcessor via try/catch, aligne sur le pattern
+ * SystemRoleDeletionException du module Core.
+ *
+ * Deplacee dans Shared/Domain/Exception/ pour eviter que le module Core
+ * n'importe directement depuis le module Sites (violation du principe de
+ * non-couplage inter-modules).
+ */
+class SiteNotAuthorizedException extends DomainException
+{
+    public static function forSite(SiteInterface $site): self
+    {
+        return new self(sprintf(
+            'Le site "%s" ne fait pas partie de vos sites autorises.',
+            $site->getName(),
+        ));
+    }
+}

src/Shared/Infrastructure/ApiPlatform/State/SidebarProvider.php

@@ -17,7 +17,7 @@ class SidebarProvider implements ProviderInterface
     /** @var list<string> */
     private readonly array $activeModuleIds;
 
-    /** @var list<array{label: string, icon: string, items: list<array{label: string, to: string, icon: string, module: string, permission?: string}>}> */
+    /** @var list<array{label: string, icon: string, permission?: string, items: list<array{label: string, to: string, icon: string, module: string, permission?: string}>}> */
     private readonly array $sidebarConfig;
 
     public function __construct(private readonly Security $security)
@@ -47,6 +47,23 @@ class SidebarProvider implements ProviderInterface
         $disabledRoutes = [];
 
         foreach ($this->sidebarConfig as $section) {
+            // Gate de section (optionnel) : si la section declare une permission
+            // et que l'utilisateur ne la possede pas, la section entiere est
+            // masquee. Toutes les routes de ses items basculent dans
+            // `disabledRoutes` pour que le middleware front redirige toute
+            // navigation directe, y compris si l'item n'a pas de permission
+            // individuelle (la section agit comme un umbrella gate).
+            $sectionPermission = $section['permission'] ?? null;
+            if (null !== $sectionPermission && !$this->security->isGranted($sectionPermission)) {
+                foreach ($section['items'] ?? [] as $item) {
+                    if (isset($item['to'])) {
+                        $disabledRoutes[] = $item['to'];
+                    }
+                }
+
+                continue;
+            }
+
             $items = [];
             foreach ($section['items'] ?? [] as $item) {
                 $isActive = in_array($item['module'] ?? null, $this->activeModuleIds, true);

templates/base.html.twig

@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="UTF-8">
+        <title>{% block title %}Welcome!{% endblock %}</title>
+        <link rel="icon" href="data:image/svg+xml,<svg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 128 128%22><text y=%221.2em%22 font-size=%2296%22>⚫️</text><text y=%221.3em%22 x=%220.2em%22 font-size=%2276%22 fill=%22%23fff%22>sf</text></svg>">
+        {% block stylesheets %}
+        {% endblock %}
+
+        {% block javascripts %}
+        {% endblock %}
+
+        {% set frankenphpHotReload = app.request.server.get('FRANKENPHP_HOT_RELOAD') %}
+        {% if frankenphpHotReload %}
+        <meta name="frankenphp-hot-reload:url" content="{{ frankenphpHotReload }}">
+        <script src="https://cdn.jsdelivr.net/npm/idiomorph"></script>
+        <script src="https://cdn.jsdelivr.net/npm/frankenphp-hot-reload/+esm" type="module"></script>
+        {% endif %}
+    </head>
+    <body>
+        {% block body %}{% endblock %}
+    </body>
+</html>

tests/Fixtures/SiteAware/FakeSiteAwareEntity.php

@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Fixtures\SiteAware;
+
+use App\Module\Sites\Domain\Entity\Site;
+use App\Shared\Domain\Contract\SiteAwareInterface;
+use App\Shared\Domain\Contract\SiteInterface;
+use Doctrine\ORM\Mapping as ORM;
+use InvalidArgumentException;
+
+/**
+ * Entite fictive utilisee UNIQUEMENT en tests (ticket 4 module Sites).
+ *
+ * Implemente SiteAwareInterface pour valider que l'outillage
+ * (SiteScopedQueryExtension + SiteAwareInjectionProcessor) se comporte
+ * correctement sans avoir a adopter le pattern sur une entite metier
+ * reelle. Le mapping Doctrine n'est charge qu'en environnement `test`
+ * via un bloc `when@test` dans `config/packages/doctrine.yaml`, donc
+ * cette classe n'existe jamais dans un schema prod.
+ *
+ * Le nom de table `fake_site_aware_entity` est volontairement verbeux
+ * pour reduire le risque de collision avec une future table metier.
+ */
+#[ORM\Entity]
+#[ORM\Table(name: 'fake_site_aware_entity')]
+class FakeSiteAwareEntity implements SiteAwareInterface
+{
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    #[ORM\Column]
+    private ?int $id = null;
+
+    #[ORM\Column(length: 100)]
+    private string $name;
+
+    #[ORM\ManyToOne(targetEntity: Site::class)]
+    #[ORM\JoinColumn(name: 'site_id', referencedColumnName: 'id', nullable: false, onDelete: 'CASCADE')]
+    private ?Site $site = null;
+
+    public function __construct(string $name)
+    {
+        $this->name = $name;
+    }
+
+    public function getId(): ?int
+    {
+        return $this->id;
+    }
+
+    public function getName(): string
+    {
+        return $this->name;
+    }
+
+    public function setName(string $name): void
+    {
+        $this->name = $name;
+    }
+
+    public function getSite(): ?SiteInterface
+    {
+        return $this->site;
+    }
+
+    public function setSite(SiteInterface $site): void
+    {
+        if (!$site instanceof Site) {
+            throw new InvalidArgumentException('FakeSiteAwareEntity requires a concrete Site (Doctrine ManyToOne target).');
+        }
+        $this->site = $site;
+    }
+}

tests/Module/Core/Api/AbstractApiTestCase.php

@@ -9,6 +9,7 @@ use ApiPlatform\Symfony\Bundle\Test\Client;
 use App\Module\Core\Domain\Entity\Permission;
 use App\Module\Core\Domain\Entity\Role;
 use App\Module\Core\Domain\Entity\User;
+use App\Module\Sites\Domain\Entity\Site;
 use Doctrine\ORM\EntityManagerInterface;
 use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
 
@@ -123,6 +124,19 @@ abstract class AbstractApiTestCase extends ApiTestCase
         $user->setIsAdmin(false);
         $user->setPassword($hasher->hashPassword($user, $password));
         $user->addRbacRole($role);
+
+        // Le helper attache le user jetable a tous les sites existants pour
+        // neutraliser le filtrage par UserSiteScopedExtension : la plupart
+        // des tests assume une visibilite globale sur les users cibles. Les
+        // tests qui valident le comportement "sans sites" doivent creer leur
+        // user a la main (pas via ce helper).
+        $siteRepository = $em->getRepository(Site::class);
+        if (null !== $siteRepository) {
+            foreach ($siteRepository->findAll() as $site) {
+                $user->addSite($site);
+            }
+        }
+
         $em->persist($user);
 
         $em->flush();
@@ -130,4 +144,34 @@ abstract class AbstractApiTestCase extends ApiTestCase
 
         return ['username' => $username, 'password' => $password];
     }
+
+    /**
+     * Skip le test courant si le module Sites est desactive dans
+     * `config/modules.php` de l'environnement de test.
+     *
+     * Mecanisme : on cherche la permission `sites.view` en base. Si le
+     * module Sites est desactive, `app:sync-permissions` aura marque cette
+     * permission comme orpheline et l'aura supprimee de la table — donc
+     * `findOneBy(['code' => 'sites.view'])` renvoie null.
+     *
+     * Quand utiliser ce helper : tests qui s'appuient sur
+     * `createUserWithPermission('sites.*')`. Les tests qui utilisent
+     * uniquement l'admin (qui bypass via isAdmin) n'en ont pas besoin :
+     * la classe Site reste mappee Doctrine et exposee via API Platform
+     * meme module desactive (mapping inconditionnel, decision assumee
+     * ticket 1).
+     */
+    protected function skipIfSitesModuleDisabled(): void
+    {
+        if (!self::$kernel) {
+            self::bootKernel();
+        }
+        $perm = $this->getEm()
+            ->getRepository(Permission::class)
+            ->findOneBy(['code' => 'sites.view'])
+        ;
+        if (null === $perm) {
+            self::markTestSkipped('Module Sites desactive : permission sites.view introuvable en base.');
+        }
+    }
 }