chore: bump version to v0.1.36

| Numéro du ticket | Titre du ticket |
|------------------|-----------------|
|                  |                 |

## Description de la PR

## Modification du .env

## Check list

- [ ] Pas de régression
- [x] TU/TI/TF rédigée
- [x] TU/TI/TF OK
- [ ] CHANGELOG modifié

Reviewed-on: #10
Co-authored-by: tristan <tristan@yuno.malio.fr>
Co-committed-by: tristan <tristan@yuno.malio.fr>

.claude/rules/architecture.md

@@ -0,0 +1,66 @@
+# Architecture — Modular Monolith DDD
+
+## Principe fondamental
+Le **backend est la source de verite unique**. Il dicte :
+- Quels modules sont actifs (`config/modules.php`)
+- L'organisation de la sidebar (`config/sidebar.php`, decouplee des modules)
+
+Le frontend scanne `modules/*/` comme layers Nuxt et consomme l'API pour la navigation. Il ne decide rien.
+
+## Endpoints API cles
+
+- `GET /api/version` (public) — version de l'app
+- `GET /api/modules` (public) — IDs des modules actifs
+- `GET /api/sidebar` (public) — sections filtrees par modules actifs + `disabledRoutes` (items dont le module owner est inactif)
+- `GET /api/me` (auth) — user courant
+
+## Arborescence minimale (detail complet : @README.md)
+
+```
+src/
+  Shared/               # Noyau technique partage (Domain/, Application/Bus/, Infrastructure/ApiPlatform/)
+  Module/
+    Core/               # Module obligatoire (auth, users)
+      CoreModule.php    # ID, LABEL, REQUIRED, permissions()
+      Domain/ Application/ Infrastructure/
+    Commercial/         # Exemple d'autre module
+frontend/
+  app/                  # Shell (layouts, middlewares)
+  shared/               # Code inter-modules (composables, stores, utils)
+  modules/              # Layers Nuxt auto-detectes
+    core/ commercial/
+```
+
+## Declaration d'un module
+
+Chaque module expose un `*Module.php` avec :
+- `ID` (snake_case, ex: `commercial`, `gestion_rh`)
+- `LABEL`
+- `REQUIRED` (bool)
+- Methode statique `permissions()` retournant les RBAC du module
+
+## Activer / desactiver un module
+
+Editer uniquement `config/modules.php` (commenter la ligne). Cascade automatique :
+1. `/api/modules` ne retourne plus l'ID
+2. `/api/sidebar` filtre les items `module: '<id>'` et supprime les sections vides
+3. Middleware front `modules.global.ts` redirige toute navigation vers une route desactivee
+4. Le code reste dans le bundle (layer auto-detecte) → reactivation instantanee sans rebuild
+
+## Reorganiser la sidebar
+
+Editer uniquement `config/sidebar.php`. Le code des modules n'est pas touche — seule la place des items change. Chaque item reference son module owner via la cle `module`.
+
+## Communication inter-modules
+
+**Interdit** : import direct d'une classe d'un autre module.
+**Autorise** :
+- Via `Shared/Domain/Contract/` (interfaces : `UserResolverInterface`, `TenantAwareInterface`...)
+- Via domain events (`Shared/Domain/Event/DomainEventInterface`)
+
+## Migrations
+
+- **Par defaut** : `src/Module/<Module>/Infrastructure/Doctrine/Migrations/` (namespace modulaire)
+- **Exception** : les migrations d'initialisation critiques (setup user, RBAC, seed de base) vivent au namespace racine `DoctrineMigrations` dans `migrations/`.
+  - Raison : avec plusieurs `migrations_paths`, Doctrine Migrations 3.x trie par FQCN alphabetique et non par version timestamp → ordre incorrect entre namespaces sur base vide.
+  - A supprimer quand un `MigrationsComparator` custom ou un upgrade Doctrine resoudra le tri.

.claude/rules/backend.md

@@ -0,0 +1,55 @@
+# Backend — Regles PHP / Symfony / API Platform
+
+## Structure de fichier
+
+- Toujours `declare(strict_types=1);` en tete de tout fichier PHP
+- PHP CS Fixer : regles Symfony + PSR-12 + strict types (commande : `make php-cs-fixer-allow-risky`)
+- Commentaires (docblock, inline, bloc) **en francais** ; code (classes, methodes, variables) en anglais
+
+## API Platform (pas de controllers)
+
+- Toujours utiliser `#[ApiResource]` + Providers + Processors — pas de controllers Symfony classiques
+- Routes prefixees `/api` (via `config/routes/api_platform.yaml`)
+- Le login `/login_check` est **hors** prefix `/api` (nginx reecrit `REQUEST_URI` vers `/login_check`)
+- **Exception** : si tu dois creer un controller custom sous `/api/`, mettre `priority: 1` sur `#[Route]` pour eviter le conflit avec API Platform `{id}`
+
+## Repositories
+
+- Interface : `*RepositoryInterface` dans `Domain/Repository/`
+- Implementation Doctrine : `Doctrine*Repository` dans `Infrastructure/Doctrine/`
+- Le domaine garde les attributs ORM (approche pragmatique)
+
+## RBAC (permissions)
+
+Format obligatoire : `module.resource[.subresource].action` en snake_case.
+- Exemples : `core.users.view`, `commercial.clients.contacts.edit`, `core.audit_log.view`
+- Declarees via la methode statique `permissions()` des `*Module.php`
+- Synchronisation : `app:sync-permissions`
+- Verification API Platform : `is_granted('module.resource.action')`
+- Verification front : `usePermissions()`
+
+## Roles
+
+- Hierarchie dans `config/packages/security.yaml` : `ROLE_ADMIN`, `ROLE_USER`
+- Le role ne remplace pas la permission RBAC — deux niveaux complementaires
+
+## Audit (obligatoire)
+
+- Toute entite metier (nouvelle ou existante) : `#[Auditable]` (de `Shared/Domain/Attribute/`)
+- Champs sensibles (password, token, secret) : `#[AuditIgnore]`
+- Audit ManyToMany : trace automatiquement `{fieldName: {added: [ids], removed: [ids]}}` — aucune action supplementaire
+- Spec complete : @doc/audit-log.md
+
+## Serialization
+
+Pour embarquer une relation dans le JSON (au lieu d'un IRI Hydra), ajouter le groupe du parent sur les proprietes de l'entite cible.
+
+Exemple : pour qu'`User.profile` soit embarque au lieu d'un lien IRI sous le groupe `user:read`, annoter `Profile.$firstName` avec `#[Groups(['user:read'])]`.
+
+## Upload de fichiers
+
+- Valider cote serveur avec `$file->getMimeType()` — **jamais** `getClientMimeType()` (spoofable par le client)
+
+## PostgreSQL
+
+- Noms de colonnes toujours en **minuscules** dans le SQL brut (commun a tous les projets MALIO)

.claude/rules/frontend.md

@@ -0,0 +1,69 @@
+# Frontend — Regles Nuxt 4 / Vue 3 / @malio/layer-ui
+
+## Base
+
+- TypeScript strict
+- 4 espaces d'indentation
+- Commentaires (JSDoc, inline, bloc) **en francais** ; code (variables, types) en anglais
+- Chaque module front = un layer Nuxt auto-detecte (`frontend/modules/*/nuxt.config.ts` minimal)
+
+## Appels API
+
+- Toujours `useApi()` — jamais `$fetch`, `ofetch`, `axios` en direct
+- `useApi()` gere : cookies JWT, erreurs, toasts i18n, parsing Hydra
+
+## Stores (Pinia)
+
+- `useAuthStore` pour l'authentification
+- `useUiStore` pour l'etat UI global (sidebar, modales, etc.)
+- Composables avec state singleton (refs module-level) : exposer une fonction `reset*()` et la rappeler au logout (ex: `useSidebar().resetSidebar()`)
+
+## Middlewares globaux
+
+- `auth.global.ts` protege les routes + charge la sidebar apres login
+- `modules.global.ts` redirige si la route demandee est dans `disabledRoutes`
+
+## i18n et sidebar
+
+- Labels de sidebar = cles i18n `sidebar.<module>.*`, jamais du texte brut
+- Le layout `default.vue` applique `t()` sur les labels retournes par `/api/sidebar`
+- Traductions dans `frontend/i18n/locales/`
+
+## Composants formulaires — @malio/layer-ui obligatoire
+
+Tout champ de formulaire / filtre doit utiliser les composants `Malio*` plutot que `<input>` / `<select>` bruts :
+
+- `MalioInputText`, `MalioInputNumber`, `MalioInputAmount`, `MalioInputPassword`, `MalioInputTextArea`
+- `MalioSelect`, `MalioSelectCheckbox`, `MalioCheckbox`, `MalioRadioButton`
+- `MalioInputUpload`, `MalioTime`
+- `MalioButton`, `MalioButtonIcon`
+
+**Exceptions autorisees** (commenter un `// TODO` pour migrer quand la lib couvrira le cas) :
+1. Type non couvert : `datetime-local`, `date`, color picker, file drag & drop
+2. Bug connu bloquant (ex: `MalioSelect` avec options string) — documenter le bug en commentaire
+
+Toute autre exception requiert validation avant merge.
+
+## Tableaux de donnees — MalioDataTable obligatoire
+
+Tout affichage LISTE tabulaire (donnees metier paginees, CRUD admin) doit passer par `MalioDataTable` :
+- Pagination integree
+- Slots `#header-*` pour filtres, `#cell-*` pour rendu custom
+- Pas de `<table>` brut avec pagination custom
+
+**Exception** : tableaux purement presentationnels non paginables (diff field/old/new, grille de comparaison, matrice RBAC d'admin, etc.) peuvent rester en `<table>` HTML brut.
+
+## Etat des tableaux — pas de persistance URL
+
+**Interdit** de persister l'etat d'un tableau (filtres, pagination, tri par colonne, selection, ligne active, scroll) dans la query string ou de le reinjecter depuis `route.query` au montage.
+
+- L'etat vit uniquement dans le composant (`reactive`, `ref` locales)
+- Seuls les deep links "de navigation metier" (ex: ouvrir un detail precis `/users/42`) sont dans l'URL
+- Exceptions autorisees **sur demande explicite** de l'utilisateur
+
+## Interdits
+
+- `modules-loader.ts`, `.module.ts` — le scan des layers est automatique
+- Hardcode de la sidebar cote front — elle vient de `/api/sidebar`
+- Edition manuelle de `extends` dans `frontend/nuxt.config.ts` — les layers sont scannes
+- Import d'un module front depuis un autre module — passer par `frontend/shared/`

.claude/rules/git.md

@@ -0,0 +1,39 @@
+# Git
+
+## Commits
+
+Format : `<type>(<scope optionnel>) : <message>`
+**Espaces obligatoires** autour du `:`.
+
+Types autorises (minuscules uniquement) : `build`, `chore`, `ci`, `docs`, `feat`, `fix`, `perf`, `refactor`, `revert`, `style`, `test`
+
+Exemples :
+- `feat : add login page`
+- `fix(auth) : prevent null token crash`
+- `chore : bump version to v1.2.3`
+
+## Regles de commit
+
+- **Jamais commit sans demande explicite** de l'utilisateur
+- **Jamais force push** sans confirmation
+- **Jamais modifier la config git**
+- **Jamais mentionner Claude, Anthropic ou une IA** dans un commit (message, titre, body, footer, trailer) ou une PR (titre, description). Concretement, aucun des elements suivants ne doit apparaitre :
+  - Trailer `Co-Authored-By: Claude <...>` / `Co-Authored-By: Anthropic`
+  - Footer type `Generated with Claude Code`, `Generated by AI`, etc.
+  - Emoji robot `🤖` ou similaire en tete/fin de message
+  - Toute phrase attribuant la paternite du changement a une IA
+  Les commits sont signes **uniquement** par l'utilisateur. Si un hook ou un template ajoute ces elements automatiquement, les retirer manuellement avant push.
+
+## Versioning & tags
+
+La version de l'app est dans `config/version.yaml` (parametre `app.version`).
+
+Workflow de release :
+1. Bump `config/version.yaml` a la nouvelle version
+2. Commit dedie : `chore : bump version to v<X.Y.Z>`
+3. Tag : `git tag v<X.Y.Z>`
+4. Push : `git push origin develop --tags`
+
+**A chaque creation de tag**, toujours mettre a jour `config/version.yaml` avec la meme version — sinon l'app ne connait pas sa propre version.
+
+CI Gitea automatise le bump sur push `develop` (cf. `.gitea/workflows/`), mais un tag manuel reste possible.

.claude/rules/naming.md

@@ -0,0 +1,18 @@
+# Nommage
+
+| Element | Convention | Exemple |
+|---------|-----------|---------|
+| Module back | PascalCase | `Module/Commercial/` |
+| Module front | kebab-case | `modules/commercial/` |
+| Module ID (dans code/config) | snake_case | `commercial`, `gestion_rh` |
+| Entity Doctrine | PascalCase singulier | `User.php` |
+| Repository interface | `*RepositoryInterface` | `UserRepositoryInterface.php` |
+| Repository impl Doctrine | `Doctrine*Repository` | `DoctrineUserRepository.php` |
+| DTO | `*Output` / `*Input` | `UserOutput.php` |
+| API Platform Resource | classe dans `Infrastructure/ApiPlatform/Resource/` | `UserResource.php` |
+| API Platform Provider | `*Provider` | `MeProvider.php` |
+| API Platform Processor | `*Processor` | `UserPasswordHasherProcessor.php` |
+| Module declaration back | `*Module.php` | `CommercialModule.php` |
+| Composable front | `use*` | `useSidebar.ts` |
+| Cles i18n sidebar | `sidebar.<module>.*` | `sidebar.commercial.overview` |
+| Permission RBAC | `module.resource[.subresource].action` | `core.users.view`, `commercial.clients.contacts.edit` |

.claude/rules/testing.md

@@ -0,0 +1,36 @@
+# Tests
+
+## Trois suites
+
+| Suite | Commande | Outil | Where |
+|---|---|---|---|
+| Back | `make test` | PHPUnit | Container PHP ; fixtures dediees sous `tests/Fixtures/` |
+| Front unitaire | `make nuxt-test` | Vitest (happy-dom) | Container Node ; <30s ; composables/utils/stores |
+| Front E2E | `make test-e2e` | Playwright | **Host** (pas container, navigateur reel requis) |
+
+Bootstrap E2E (une fois par poste de dev) : `make install-e2e-deps` (Chromium + libs systeme, sudo).
+Re-run uniquement si `@playwright/test` upgrade majeur.
+
+Workflow E2E : `make start && make seed-e2e && make dev-nuxt` (terminal 1), `make test-e2e` (terminal 2).
+UI interactive pour debug : `make test-e2e-ui`.
+
+## Regle d'or E2E
+
+**Un nouveau test E2E ne s'ajoute QUE si un bug critique est passe en prod.**
+
+Sinon, la bonne place est un test unitaire Vitest :
+- Plus rapide
+- Plus stable
+- Moins de faux positifs
+
+Pour etendre la couverture RBAC, etendre un **persona existant** dans `frontend/tests/e2e/_fixtures/personas.ts` plutot que de creer un nouveau test.
+
+## Matrice RBAC — 3 endroits obligatoires
+
+Ajouter/modifier une permission testable = toucher les 3 miroirs (sinon drift garanti) :
+
+1. `config/sidebar.php` — attacher `permission` au bon item
+2. `frontend/tests/e2e/_fixtures/personas.ts` — ajuster `permissions` + `expectedAdminLinks` d'un persona existant
+3. `src/Module/Core/Infrastructure/Console/SeedE2ECommand.php` — miroir back du meme persona
+
+Tout changement sur l'un des trois sans les deux autres = test casse ou faux positif.

.claude/rules/workflow.md

@@ -0,0 +1,66 @@
+# Workflow
+
+## Langue
+
+- **UI** : francais (tout ce qui est visible utilisateur)
+- **Communication avec l'utilisateur** : francais
+- **Code** (noms de classes, methodes, variables, types) : anglais
+- **Commentaires** (PHP, TS, Vue — docblock, inline, bloc) : **francais**. Objectif : faciliter la relecture par l'equipe FR sans polluer l'API publique du code
+
+## Delegation Codex
+
+Pour les taches mecaniques (generation de tests boilerplate, renommages massifs, refacto repetitif, scaffolding), **deleguer a Codex** via le plugin `codex` (skill `codex:rescue`).
+
+- **Codex** = junior rapide et pas cher → executions mecaniques
+- **Claude** = senior qui verifie et reflechit → design, review, decisions
+
+Ratio qualite/credits optimal : Claude conserve la reflexion et la validation, Codex avale le boilerplate.
+
+## Avant d'implementer un ticket
+
+Les specs fonctionnelles vivent sous `docs/{rbac,sites,modules}/ticket-*-spec.md`.
+
+Avant de coder :
+1. Lire la spec correspondante en entier (elles sont longues mais exhaustives)
+2. Ne pas inventer de detail non specifie — demander a l'utilisateur ou citer explicitement la section manquante
+3. Si la spec contredit le code existant, poser la question avant de choisir
+
+## Verification avant "c'est fini"
+
+Ne jamais declarer une tache terminee sans avoir lance les verifications applicables :
+
+| Ce qui a bouge | Commande a lancer |
+|---|---|
+| Fichiers PHP | `make test` + `make php-cs-fixer-allow-risky` |
+| Fichiers front (Vue/TS) | `make nuxt-test` |
+| Migrations | `make migration-migrate` (sur BDD fraiche ideal : `make db-reset`) |
+| Sidebar / permissions | Verifier que les 3 miroirs RBAC sont alignes (cf. @.claude/rules/testing.md) |
+| UI visible | Demarrer `make dev-nuxt` et verifier le golden path dans le navigateur |
+
+Si une verification echoue ou ne peut pas etre lancee (ex : container pas demarre), le dire explicitement plutot que d'annoncer "fini".
+
+## Time tracking Lesstime
+
+Au demarrage de toute tache de dev sur Coltura, creer une time entry via l'API Lesstime (cf. `~/.claude/CLAUDE.md` pour la procedure complete).
+- Projet : `/api/projects/6` (COLTURA)
+- Tags : choisir selon le type (Backend `3`, Frontend `2`, Infra `5`, UI/UX `4`, Maintenance `6`, Gestion projet `9`, etc.)
+
+## Fix `make cache-clear` (permissions `var/`)
+
+Si `make cache-clear` echoue sur les permissions de `var/` :
+
+```bash
+docker exec -t -u root php-coltura-fpm chown -R www-data:www-data /var/www/html/var
+docker exec -t -u www-data php-coltura-fpm php bin/console cache:clear
+```
+
+A terme : integrer ce fix dans le `makefile` lui-meme.
+
+## Docker — references utiles
+
+- Container PHP : `php-coltura-fpm`
+- Container Nginx : `nginx-coltura` (port 8083)
+- Container DB : PostgreSQL port **5437** (interne et externe)
+- Config dev : `infra/dev/.env.docker` (override local : `infra/dev/.env.docker.local`)
+- Config prod : `infra/prod/` (Dockerfile multi-stage, `docker-compose.prod.yml`)
+- Apres modif nginx : `docker restart nginx-coltura`

.dockerignore

@@ -0,0 +1 @@
+src/Module/Core/Infrastructure/Console/SeedE2ECommand.php

.gitignore

@@ -3,6 +3,7 @@
 /.env.local.php
 /.env.*.local
 /config/secrets/dev/dev.decrypt.private.php
+/config/reference.php
 /public/bundles/
 /var/
 /vendor/
@@ -29,6 +30,13 @@ frontend/.output/
 frontend/dist/
 ###< frontend ###
 
+###> playwright ###
+frontend/test-results/
+frontend/playwright-report/
+frontend/blob-report/
+frontend/playwright/.cache/
+###< playwright ###
+
 ###> docker ###
 infra/dev/.env.docker.local
 ###< docker ###
@@ -36,3 +44,12 @@ infra/dev/.env.docker.local
 ###> logs ###
 LOG/
 ###< logs ###
+
+###> friendsofphp/php-cs-fixer ###
+/.php-cs-fixer.php
+/.php-cs-fixer.cache
+###< friendsofphp/php-cs-fixer ###
+
+###> symfony auto-generated ###
+/config/reference.php
+###< symfony auto-generated ###

CLAUDE.md

@@ -1,277 +1,68 @@
 # Coltura
 
-CRM/ERP. Monorepo Symfony 8 (API Platform 4) + Nuxt 4. **Architecture Modular Monolith DDD.**
+## Contexte
+CRM/ERP en architecture **modular monolith DDD**. Le backend est la source de verite unique (modules actifs, sidebar). Le frontend scanne `frontend/modules/*/` comme layers Nuxt et consomme l'API pour la navigation. Multi-tenant : chaque module est activable/desactivable.
 
-## Architecture Modulaire
-
-Le projet suit une architecture **modular monolith** pilotee par le backend : chaque module metier est un bounded context autonome, activable/desactivable par tenant. Le module `Core` est obligatoire.
-
-**Principe fondamental : le backend est la source de verite unique.**
-- Le backend dicte quels modules sont actifs (`config/modules.php`).
-- Le backend dicte l'organisation de la sidebar (`config/sidebar.php`), decouplee des modules eux-memes.
-- Le frontend ne connait rien : il scanne automatiquement les modules comme layers Nuxt et demande la sidebar au backend.
-
-### Backend — Organisation par module
-
-```
-src/
-  Kernel.php
-  Shared/                           # Noyau technique partage
-    Domain/
-      ValueObject/                  # VO de base (Email...)
-      Event/                        # DomainEventInterface
-      Contract/                     # Interfaces inter-modules (UserResolverInterface, TenantAwareInterface)
-    Application/
-      Bus/                          # CommandBusInterface, QueryBusInterface (interfaces seules)
-    Infrastructure/
-      ApiPlatform/
-        Resource/                   # AppVersion, ModulesResource, SidebarResource
-        State/                      # AppVersionProvider, ModulesProvider, SidebarProvider
-  Module/
-    Core/                           # Module obligatoire (auth, users)
-      CoreModule.php                # Declaration (ID, LABEL, REQUIRED)
-      Domain/
-        Entity/                     # Entites Doctrine + API Platform (User)
-        Repository/                 # Interfaces repositories (UserRepositoryInterface)
-        Event/                      # Domain events (UserCreated)
-      Application/
-        DTO/                        # UserOutput
-      Infrastructure/
-        Doctrine/                   # DoctrineUserRepository, Migrations/
-        ApiPlatform/
-          State/
-            Provider/               # MeProvider
-            Processor/              # UserPasswordHasherProcessor
-        Console/                    # CreateUserCommand
-        DataFixtures/               # AppFixtures
-    Commercial/                     # Autre module (exemple)
-      CommercialModule.php
-config/
-  modules.php                       # Liste des modules actifs (source de verite activation)
-  sidebar.php                       # Structure de la sidebar (source de verite navigation)
-  version.yaml
-  jwt/                              # Cles JWT
-  packages/                         # Config Symfony
-migrations/                         # Anciennes migrations Doctrine
-infra/dev/                          # Docker dev
-infra/prod/                         # Docker prod (multi-stage)
-```
-
-### Frontend — Organisation modulaire (auto-detectee)
-
-```
-frontend/
-  app/                              # Shell applicatif
-    layouts/                        # default.vue, auth.vue
-    middleware/                     # auth.global.ts, modules.global.ts
-  shared/                           # Code partage (hors modules)
-    composables/                    # useApi, useAppVersion, useSidebar
-    components/ui/                  # AppTopNav, ...
-    stores/                         # auth, ui
-    services/                       # auth
-    types/                          # SidebarSection, SidebarItem, UserData
-    utils/                          # api (Hydra)
-  modules/                          # Modules auto-detectes comme layers Nuxt
-    core/
-      nuxt.config.ts                # Marqueur layer (vide)
-      pages/                        # index.vue, login.vue
-    commercial/
-      nuxt.config.ts
-      pages/                        # commercial.vue
-  app.vue                           # Composant racine
-  nuxt.config.ts                    # Scanne modules/*/ automatiquement
-  i18n/locales/                     # Traductions (cles sidebar.*, etc.)
-  assets/                           # CSS, images
-  public/                           # Fichiers statiques
-```
-
-### Endpoints API cles
-
-- `GET /api/version` (public) — version de l'app
-- `GET /api/modules` (public) — liste des IDs de modules actifs
-- `GET /api/sidebar` (public) — sections de la sidebar + `disabledRoutes`
-  - Filtre automatiquement les items dont le `module` owner n'est pas actif
-  - Les sections vides apres filtrage sont supprimees
-  - `disabledRoutes` = `to` des items filtres (utilise par le middleware front)
-- `GET /api/me` (auth) — user courant
-
-### Flux d'activation/desactivation d'un module
-
-Pour activer/desactiver un module, tu touches **uniquement** `config/modules.php` :
-
-```php
-return [
-    \App\Module\Core\CoreModule::class,
-    // \App\Module\Commercial\CommercialModule::class,  // commente = desactive
-];
-```
-
-Cascade automatique :
-1. `GET /api/modules` ne retourne plus `commercial`
-2. `GET /api/sidebar` filtre les items `module: 'commercial'` → section "Commercial" disparait, ses routes passent dans `disabledRoutes`
-3. Frontend : sidebar se met a jour, middleware `modules.global.ts` redirige toute navigation vers `/commercial` ou `/commercial/*`
-4. Le code du module reste dans le bundle Nuxt (layer auto-detecte) → reactivation instantanee sans rebuild
-
-### Reorganiser la sidebar sans toucher aux modules
-
-Pour deplacer un item (ex: "Commandes fournisseurs") d'une section a une autre, tu edites juste `config/sidebar.php` :
-
-```php
-// Avant : sous Commercial
-['label' => 'sidebar.commercial.suppliers', 'to' => '/commercial/suppliers', 'module' => 'commercial'],
-
-// Apres : sous Production (l'item reste "owned" par Commercial, seule sa place change)
-[
-    'label' => 'sidebar.production.section',
-    'items' => [
-        ['label' => 'sidebar.commercial.suppliers', 'to' => '/commercial/suppliers', 'module' => 'commercial'],
-    ],
-],
-```
-
-Le code du module Commercial n'est pas touche.
-
-### Regles d'architecture
-
-**Backend :**
-- Le domaine (`Domain/`) peut garder les attributs ORM (approche pragmatique) mais les repositories sont des interfaces
-- Communication inter-modules par `Shared/Domain/Contract/` ou domain events — jamais d'import direct entre modules
-- Chaque module declare un `*Module.php` avec `ID`, `LABEL`, `REQUIRED`
-- `config/modules.php` = seule source de verite pour l'activation
-- `config/sidebar.php` = seule source de verite pour l'organisation de la sidebar (chaque item reference son module owner via la cle `module`)
-- Migrations par module dans `src/Module/{Module}/Infrastructure/Doctrine/Migrations/`
-- **Exception connue** : avec plusieurs `migrations_paths` configures, Doctrine Migrations 3.x trie les migrations par FQCN alphabetique et non par version timestamp → ordre d'execution incorrect entre namespaces sur une base vide. Tant que ce n'est pas resolu (via un `MigrationsComparator` custom ou un upgrade), les migrations d'initialisation critiques (setup user, RBAC, etc.) vivent au namespace racine `DoctrineMigrations` dans `migrations/`. Le namespace modulaire reste configure pour les futures migrations applicatives (qui dependent d'un schema deja cree).
-
-**Frontend :**
-- Chaque module est un layer Nuxt auto-detecte (`modules/*/nuxt.config.ts` minimal)
-- Un module front ne doit pas importer depuis un autre module — utiliser `shared/`
-- `useSidebar()` fetch `/api/sidebar` et expose `sections`, `disabledRoutes`, `isRouteDisabled()`
-- Le layout `default.vue` itere sur les sections retournees par l'API, applique `t()` sur les labels
-- Middleware `auth.global.ts` charge la sidebar apres authentification
-- Middleware `modules.global.ts` redirige si la route demandee est dans `disabledRoutes`
-- Les composables avec state singleton (refs module-level) doivent exposer une fonction `reset*()` et etre reinitialises au logout (ex: `useSidebar().resetSidebar()`)
-- **Interdit** : `.module.ts`, `modules-loader.ts`, hardcode de la sidebar, edition manuelle de `extends` dans `nuxt.config.ts`
+Doc humaine : @README.md — Spec audit : @doc/audit-log.md
 
 ## Stack
+- Backend : PHP 8.4, Symfony 8, API Platform 4, Doctrine ORM, PostgreSQL 16 (port 5437)
+- Frontend : Nuxt 4 (SPA), Vue 3, Pinia, Tailwind, @malio/layer-ui, @nuxtjs/i18n
+- Auth : JWT HTTP-only cookie (Lexik), login a `/login_check`
+- Containers : `php-coltura-fpm`, `nginx-coltura` (port 8083), dev Nuxt port **3004**
 
-- **Backend** : PHP 8.4, Symfony 8.0, API Platform 4, Doctrine ORM, PostgreSQL 16
-- **Frontend** : Nuxt 4 (SSR off / SPA), Vue 3, Pinia, Tailwind CSS, @malio/layer-ui, nuxt-toast, @nuxtjs/i18n, @nuxt/icon
-- **Auth** : JWT HTTP-only cookie (lexik/jwt-authentication-bundle), login a `/login_check`, cookie `BEARER`
-- **Docker** : PHP-FPM + Node 24, Nginx (port 8083), PostgreSQL (port 5437)
+## Regles ABSOLUES
 
-## Commandes
-
-```bash
-make start           # Demarrer les containers
-make stop            # Arreter les containers
-make restart         # Redemarrer les containers
-make install         # Install complet (composer, migrations, fixtures, build Nuxt)
-make reset           # Tout supprimer et reinstaller (supprime la BDD)
-make dev-nuxt        # Dev server Nuxt (hot reload, port 3004)
-make shell           # Shell dans le container PHP
-make shell-root      # Shell root dans le container PHP
-make cache-clear     # Vider le cache Symfony
-make migration-migrate # Lancer les migrations
-make fixtures        # Charger les fixtures
-make db-reset        # Reset BDD + migrations + fixtures
-make test            # PHPUnit
-make php-cs-fixer-allow-risky # Fix code style PHP
-make logs-dev        # Tail logs Symfony
-```
-
-Si `make cache-clear` echoue pour cause de permissions sur `var/` :
-```bash
-docker exec -t -u root php-coltura-fpm chown -R www-data:www-data /var/www/html/var
-docker exec -t -u www-data php-coltura-fpm php bin/console cache:clear
-```
+1. **Ne jamais importer d'un module a un autre** — passer par `Shared/Domain/Contract/` (interfaces) ou domain events.
+2. **Toujours `declare(strict_types=1);`** en tete de tout fichier PHP.
+3. **Toujours annoter `#[Auditable]`** les entites metier ; `#[AuditIgnore]` sur champs sensibles (password, token, secret).
+4. **Toujours utiliser `useApi()`** pour les appels API cote front — jamais `$fetch` / `ofetch` direct.
+5. **Toujours utiliser les composants `Malio*`** (@malio/layer-ui) pour formulaires/filtres ; `MalioDataTable` pour listes paginees.
+6. **Jamais persister l'etat de tableau dans l'URL** (filtres, pagination, tri, selection) — state local uniquement.
+7. **Jamais ajouter un test E2E** sauf si un bug critique est passe en prod ; preferer un test Vitest.
+8. **Toujours mettre a jour les 3 sources RBAC ensemble** : `config/sidebar.php`, `frontend/tests/e2e/_fixtures/personas.ts`, `src/Module/Core/Infrastructure/Console/SeedE2ECommand.php`.
+9. **Jamais commit sans demande explicite** de l'utilisateur ; jamais force push sans confirmation.
+10. **Jamais mentionner Claude, Anthropic ou une IA** dans un commit (message, titre, body, footer, trailer) ou une PR (titre, description). Pas de `Co-Authored-By: Claude`, pas de `Generated with Claude Code`, pas de `🤖`, pas d'emoji robot, rien. Les commits sont signes par l'utilisateur uniquement.
+11. **Migrations d'initialisation au namespace racine** `DoctrineMigrations` dans `migrations/` (setup user, RBAC, seed de base). Les migrations modulaires (`src/Module/*/Infrastructure/Doctrine/Migrations/`) sont reservees aux evolutions post-schema (ajout de colonnes, index) — cf. @.claude/rules/architecture.md pour la raison.
 
 ## Conventions
+@.claude/rules/architecture.md
+@.claude/rules/backend.md
+@.claude/rules/frontend.md
+@.claude/rules/testing.md
+@.claude/rules/naming.md
+@.claude/rules/git.md
+@.claude/rules/workflow.md
 
-### Commits
+## Commandes (liste complete dans @README.md)
 
-Format : `<type>(<scope optionnel>) : <message>` (espace avant et apres `:`)
+- Demarrer : `make start`
+- Dev front (hot reload) : `make dev-nuxt` (port 3004)
+- Shell PHP : `make shell`
+- Tests back : `make test`
+- Tests front unitaires : `make nuxt-test`
+- Tests E2E : `make test-e2e` (prerequis : `make seed-e2e && make dev-nuxt`)
+- Reset BDD : `make db-reset`
+- Lint PHP : `make php-cs-fixer-allow-risky`
 
-Types autorises (minuscules) : `build`, `chore`, `ci`, `docs`, `feat`, `fix`, `perf`, `refactor`, `revert`, `style`, `test`
+## Activer / desactiver un module
 
-Exemples : `feat : add login page`, `fix(auth) : prevent null token crash`
+Editer uniquement `config/modules.php` (commenter la ligne). Cascade automatique via `/api/modules`, `/api/sidebar`, middleware front `modules.global.ts`. Details : @.claude/rules/architecture.md
 
-### Tags & Versioning
+## A NE PAS faire
 
-- La version de l'app est dans `config/version.yaml` (parametre `app.version`)
-- A chaque creation de tag, **toujours** mettre a jour `config/version.yaml` avec la meme version
-- Faire un commit separe de bump : `chore : bump version to v<X.Y.Z>`
-- Puis creer le tag et pusher : `git tag v<X.Y.Z> && git push origin develop --tags`
+- Pas de controller Symfony custom sous `/api/` sans `priority: 1` sur `#[Route]` (conflit API Platform `{id}`).
+- Pas de `getClientMimeType()` pour valider un upload — utiliser `$file->getMimeType()` (serveur).
+- Pas de hardcode de la sidebar cote front, pas de `modules-loader.ts` ni `.module.ts`.
+- Pas d'edition manuelle de `extends` dans `frontend/nuxt.config.ts` — les layers sont scannes automatiquement.
+- Pas de commentaires en anglais dans le code — **commentaires en francais**, code (noms) en anglais.
+- Pas d'`<input>` / `<select>` / `<table>` bruts quand un composant `@malio/layer-ui` existe (exceptions documentees dans @.claude/rules/frontend.md).
+- Pas de modification de la config git.
 
-### Nommage
+## Skills projet
 
-| Element | Convention | Exemple |
-|---------|-----------|---------|
-| Module back | PascalCase | `Module/Commercial/` |
-| Module front | kebab-case | `modules/commercial/` |
-| Module ID | snake_case | `commercial`, `gestion_rh` |
-| Entity | PascalCase singulier | `User.php` |
-| Repository interface | `*RepositoryInterface` | `UserRepositoryInterface.php` |
-| Repository impl | `Doctrine*Repository` | `DoctrineUserRepository.php` |
-| DTO | `*Output` / `*Input` | `UserOutput.php` |
-| API Resource | classe dans `Infrastructure/ApiPlatform/Resource/` | `UserResource.php` |
-| Provider | `*Provider` | `MeProvider.php` |
-| Processor | `*Processor` | `UserPasswordHasherProcessor.php` |
-| Module declaration back | `*Module.php` | `CommercialModule.php` |
-| Composable front | `use*` | `useSidebar.ts` |
-| Cles i18n sidebar | `sidebar.<module>.*` | `sidebar.commercial.overview` |
+- `create-module` — scaffolder un nouveau module back+front et wirer la sidebar.
 
-### Backend
+## Credentials (dev)
 
-- Toujours `declare(strict_types=1)` en haut des fichiers PHP
-- **Commentaires en francais** : tout commentaire PHP (docblock, inline, bloc) doit etre redige en francais. Le code (noms de classes, methodes, variables) reste en anglais. Objectif : faciliter la relecture par l'equipe FR sans polluer l'API publique du code.
-- API Platform : utiliser ApiResource, Providers, Processors — pas de controllers
-- Routes API prefixees `/api` (via `config/routes/api_platform.yaml`)
-- Le login (`/login_check`) est hors prefix `/api`, nginx reecrit `REQUEST_URI` vers `/login_check`
-- PHP CS Fixer : regles Symfony + PSR-12 + strict types
-- Roles : `ROLE_ADMIN`, `ROLE_USER` — hierarchie dans `security.yaml`
-- **Permissions RBAC** : format obligatoire `module.resource[.subresource].action` en snake_case, ex : `core.users.view`, `commercial.clients.contacts.edit`. Declarees via la methode statique `permissions()` des `*Module.php`, synchronisees par la commande `app:sync-permissions`. Verification via `is_granted('module.resource.action')` cote API Platform et `usePermissions()` cote front.
-- PostgreSQL : noms de colonnes toujours en **minuscules** dans le SQL brut
-- 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
-
-### Frontend
-
-- TypeScript strict
-- **Commentaires en francais** : tout commentaire TS/Vue (JSDoc, inline, bloc) doit etre redige en francais. Le code reste en anglais. Meme regle que cote backend.
-- Composable `useApi()` pour tous les appels API (gere cookies, erreurs, toasts, i18n)
-- Stores Pinia : `useAuthStore` (auth), `useUiStore` (ui)
-- Middleware global `auth.global.ts` protege les routes + charge la sidebar apres login
-- Middleware global `modules.global.ts` redirige les routes des modules desactives
-- 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)
-
-### Nginx
-
-- `/api/*` -> Symfony (via try_files + index.php)
-- `/api/login_check` -> location exact match, fastcgi direct avec REQUEST_URI reecrit en `/login_check`
-- `/` -> SPA frontend (`frontend/dist/`)
-
-## Docker
-
-- Container PHP : `php-coltura-fpm`
-- Container Nginx : `nginx-coltura`
-- Container DB : PostgreSQL sur port **5437** (interne et externe)
-- Config Docker dev : `infra/dev/.env.docker` (override local : `infra/dev/.env.docker.local`)
-- Config Docker prod : `infra/prod/` (Dockerfile multi-stage, docker-compose.prod.yml)
-- Apres modif nginx : `docker restart nginx-coltura`
-
-## Fixtures
-
-- User admin : `admin` / `admin` (ROLE_ADMIN)
-- Users internes : `alice` / `alice`, `bob` / `bob` (ROLE_USER)
-
-## Delegation Codex
-
-Pour les taches mecaniques (tests, boilerplate, renommages, refacto repetitif), delegue a Codex via le plugin `codex`. Garde Claude pour la reflexion, l'architecture et la verification.
-
-- **Codex** = junior dev rapide et pas cher (executions mecaniques)
-- **Claude** = senior dev qui verifie et reflechit (design, review, decisions)
-
-C'est le meilleur ratio qualite/credits.
+`admin` / `admin` (ROLE_ADMIN) ; `alice` / `alice`, `bob` / `bob` (ROLE_USER).

README.md

@@ -46,10 +46,35 @@ make dev-nuxt        # Port 3003
 | `make migration-migrate` | Lancer les migrations |
 | `make fixtures` | Charger les fixtures |
 | `make db-reset` | Reset BDD + migrations + fixtures |
-| `make test` | PHPUnit |
+| `make test` | PHPUnit (tests back) |
+| `make nuxt-test` | Vitest (tests unitaires front) |
+| `make test-e2e` | Playwright (tests E2E front) |
+| `make test-e2e-ui` | Playwright UI interactive (debug) |
+| `make seed-e2e` | Seed les 6 personas E2E |
+| `make install-e2e-deps` | One-time : Chromium + libs systeme (sudo) |
 | `make php-cs-fixer-allow-risky` | Fix code style PHP |
 | `make logs-dev` | Tail logs Symfony |
 
+## Tests
+
+- **Back** : `make test` (PHPUnit). Fixtures dediees sous `tests/Fixtures/`.
+- **Front unitaire** : `make nuxt-test` (Vitest, happy-dom). Composables, utils, stores — rapide, <30s.
+- **Front E2E** : `make test-e2e` (Playwright). Couvre login + matrice RBAC sidebar. Suite volontairement minimaliste (11 tests) — voir la regle d'or dans `CLAUDE.md`.
+
+**Bootstrap E2E (une fois par poste)** :
+```bash
+make install-e2e-deps   # Telecharge Chromium + libs systeme via apt (sudo)
+```
+
+**Workflow E2E** :
+```bash
+# Terminal 1 : containers + dev server
+make start && make seed-e2e && make dev-nuxt
+
+# Terminal 2 : tests
+make test-e2e
+```
+
 ## Architecture
 
 **Modular Monolith DDD** : chaque module est un bounded context autonome, activable/desactivable par tenant. Le backend est la seule source de verite pour l'activation et l'organisation de la sidebar.

REVIEW.md

@@ -0,0 +1,730 @@
+# Review PR `feat/audit-log` — 4e passe
+
+> Audit complet de la PR audit-log (89 commits, 233 fichiers, +52k/-876 lignes) apres les 3 passes de review deja mergees.
+> Objectif : faire sortir ce qui reste avant merge dans `main`.
+> Genere le 2026-04-23.
+
+**Branche** : `feat/audit-log`
+**Base** : `main`
+**Revues anterieures** (deja appliquees dans la branche) :
+- `bb6a4c3 fix(review) : blockers review PR #9`
+- `25cd6a1 fix(review) : regression drawers RBAC + race snapshot + stale-data admin`
+- `b1255bb fix(review) : 3e passe review (HIGH frontend + MEDIUMs)`
+- `7117744 docs(claude) : refactor CLAUDE.md`
+
+La branche est globalement solide : les trois miroirs RBAC sont synchronises, le pattern swap-and-clear de l'audit est correctement implemente, la connexion DBAL dediee est bien configuree. Les findings ci-dessous sont incrementaux et ne remettent pas en cause la feature.
+
+---
+
+## Table des matieres
+
+1. [Securite](#1-securite)
+2. [Bugs silencieux](#2-bugs-silencieux)
+3. [Violations des regles projet](#3-violations-des-regles-projet)
+4. [Incoherences de patterns](#4-incoherences-de-patterns)
+5. [Documentation et configuration](#5-documentation-et-configuration)
+6. [Frontend et UX](#6-frontend-et-ux)
+7. [Bonnes pratiques a retenir](#7-bonnes-pratiques-a-retenir)
+8. [Resume par priorite](#8-resume-par-priorite)
+
+---
+
+## 1. Securite
+
+### 1.1 CRITIQUE — `/api/docs` public en production
+
+**Fichier** : `config/packages/security.yaml:46`
+
+```yaml
+- { path: ^/api/docs, roles: PUBLIC_ACCESS }
+```
+
+La documentation Swagger/OpenAPI d'API Platform est accessible sans authentification, quel que soit l'environnement — y compris en production sur `coltura.malio-dev.fr`. Elle expose :
+
+- la liste complete des endpoints (`/api/audit-logs`, `/api/users/{id}/rbac`, `/api/sites`, etc.)
+- les schemas de securite (`is_granted('core.audit_log.view')`)
+- les filtres acceptes par chaque provider (y compris `performed_at[after]`)
+- la structure des DTOs (`AuditLogOutput`, `UserOutput`...)
+- les patterns UUID/IDs
+
+**Pourquoi c'est grave** : un attaquant a une cartographie gratuite de la surface d'attaque. Pour un CRM interne sur DNS public, c'est une fuite d'information inutile. API Platform genere cette doc automatiquement mais rien n'oblige a la rendre publique.
+
+**Correction** : fermer en prod.
+
+```yaml
+# config/packages/security.yaml
+- { path: ^/login_check, roles: PUBLIC_ACCESS }
+- { path: ^/api/version, roles: PUBLIC_ACCESS, methods: [GET] }
+- { path: ^/api/modules, roles: PUBLIC_ACCESS, methods: [GET] }
+- { path: ^/api/sidebar, roles: PUBLIC_ACCESS, methods: [GET] }
+- { path: ^/api, roles: IS_AUTHENTICATED_FULLY }
+# supprimer la ligne "- { path: ^/api/docs, roles: PUBLIC_ACCESS }"
+```
+
+Ou conditionner l'acces au debug mode :
+
+```yaml
+when@prod:
+    security:
+        access_control:
+            - { path: ^/api/docs, roles: IS_AUTHENTICATED_FULLY }
+```
+
+---
+
+### 1.2 CRITIQUE — Aucun en-tete de securite HTTP en production
+
+**Fichier** : `infra/prod/nginx.conf` et `infra/prod/nginx-proxy.conf` (aucune directive `add_header`)
+
+Le Nginx de prod n'emet aucun des en-tetes de securite standards :
+
+| En-tete | Role | Present ? |
+|---------|------|-----------|
+| `X-Frame-Options: DENY` | anti-clickjacking (pas d'embed iframe) | non |
+| `X-Content-Type-Options: nosniff` | anti MIME-sniffing | non |
+| `Referrer-Policy` | limite les fuites dans le Referer | non |
+| `Content-Security-Policy` | anti-XSS | non |
+| `Strict-Transport-Security` | force HTTPS | non |
+
+Le reverse proxy ecoute uniquement sur le port 80 (HTTP), sans redirection 301 vers HTTPS. Combine avec `JWT_COOKIE_SECURE=1` (defaut dans `.env.prod.example`), le cookie ne serait meme pas envoye en HTTP — donc un premier acces HTTP casse le login silencieusement, l'utilisateur croira que l'auth est buggee.
+
+**Correction minimale dans `nginx-proxy.conf`** (niveau proxy public) :
+
+```nginx
+server {
+    listen 80;
+    listen [::]:80;
+    server_name coltura.malio-dev.fr;
+
+    # Redirection HTTPS obligatoire (ajouter un server block HTTPS par ailleurs).
+    # Tant que le TLS n'est pas en place, au minimum poser les en-tetes suivants.
+    add_header X-Frame-Options "DENY" always;
+    add_header X-Content-Type-Options "nosniff" always;
+    add_header Referrer-Policy "strict-origin-when-cross-origin" always;
+
+    # ... reste de la config
+}
+```
+
+Quand TLS est en place, ajouter :
+
+```nginx
+add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
+```
+
+---
+
+### 1.3 CRITIQUE — `robots.txt` autorise toute l'indexation
+
+**Fichier** : `frontend/public/robots.txt`
+
+```
+User-Agent: *
+Disallow:
+```
+
+La valeur `Disallow:` (vide) signifie "rien n'est interdit" — tous les crawlers peuvent indexer la totalite du site. Pour un outil CRM interne accessible sur un DNS public (`coltura.malio-dev.fr`), c'est un leak inutile : la page de login, les URLs `/admin/*`, les URLs des fiches clients peuvent remonter dans Google.
+
+**Correction** :
+
+```
+User-Agent: *
+Disallow: /
+```
+
+---
+
+### 1.4 IMPORTANT — `performed_at[after|before]` sans typage DBAL → crash 500 sur date malformee
+
+**Fichier** : `src/Module/Core/Infrastructure/ApiPlatform/State/Provider/AuditLogProvider.php:182-186`
+
+```php
+if (isset($filters['performed_at_after'])) {
+    $qb->andWhere('performed_at >= :performed_at_after')
+       ->setParameter('performed_at_after', $filters['performed_at_after']);
+}
+```
+
+La valeur est passee comme chaine brute a DBAL. La colonne `performed_at` est un `timestamptz`. Si un client envoie `?performed_at[after]=not-a-date`, PostgreSQL leve une erreur de cast et l'API retourne une 500. Pas d'injection SQL (le parametre est bien binde), mais :
+
+- erreur 500 loguee pour chaque mauvaise entree (pollution des logs + bruit pour l'oncall)
+- DoS tres bas effort : un utilisateur avec `core.audit_log.view` peut envoyer des requetes mal formees en boucle
+- mauvaise UX : le front recoit une erreur generique au lieu d'un 400 explicite
+
+**Correction** :
+
+```php
+use Doctrine\DBAL\Types\Types;
+use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
+
+if (isset($filters['performed_at_after'])) {
+    try {
+        $after = new \DateTimeImmutable($filters['performed_at_after']);
+    } catch (\Throwable) {
+        throw new BadRequestHttpException('performed_at[after] doit etre une date ISO 8601 valide.');
+    }
+    $qb->andWhere('performed_at >= :performed_at_after')
+       ->setParameter('performed_at_after', $after, Types::DATETIMETZ_IMMUTABLE);
+}
+// idem pour performed_at_before
+```
+
+Cette correction donne en prime un 400 propre avec un message clair.
+
+---
+
+### 1.5 IMPORTANT — Clause `ESCAPE` absente du `ILIKE` (filtre `performed_by`)
+
+**Fichier** : `src/Module/Core/Infrastructure/ApiPlatform/State/Provider/AuditLogProvider.php:177-180`
+
+```php
+$escaped = str_replace(['\\', '%', '_'], ['\\\\', '\%', '\_'], $filters['performed_by']);
+$qb->andWhere('performed_by ILIKE :performed_by')
+   ->setParameter('performed_by', '%'.$escaped.'%');
+```
+
+Le commentaire dit : *"`\` est deja le caractere d'echappement LIKE par defaut en PostgreSQL"*. C'est **inexact**. En SQL-standard PostgreSQL, il n'y a pas de caractere d'echappement par defaut pour LIKE/ILIKE : pour echapper `%` ou `_`, il faut soit `LIKE pattern ESCAPE '\'`, soit utiliser un autre caractere (ex: `ESCAPE '|'`).
+
+En pratique, sur PostgreSQL avec `standard_conforming_strings=on` (defaut depuis 9.1), `\` n'est PAS interprete par LIKE. Donc `'%\_%'` matche la chaine `%\_%` — pas ce qu'on veut. Le filtre est silencieusement casse pour tout nom contenant `_` ou `%`.
+
+**Test a faire en psql pour confirmer** :
+```sql
+SELECT 'admin_backup' ILIKE '%admin\_backup%';           -- t sur PG moderne ? non : f
+SELECT 'admin_backup' ILIKE '%admin\_backup%' ESCAPE '\'; -- t
+```
+
+**Correction** : ajouter explicitement la clause `ESCAPE`.
+
+```php
+$qb->andWhere("performed_by ILIKE :performed_by ESCAPE '\\\\'")
+   ->setParameter('performed_by', '%'.$escaped.'%');
+```
+
+(Les quatre `\` en PHP donnent deux `\` dans le SQL, soit un `\` litteral une fois parse par PostgreSQL.)
+
+Alternative plus sure : utiliser `position()` au lieu de LIKE.
+
+```php
+$qb->andWhere('position(lower(:performed_by) IN lower(performed_by)) > 0')
+   ->setParameter('performed_by', $filters['performed_by']);
+```
+
+---
+
+### 1.6 IMPORTANT — `SiteAwareInjectionProcessor` : bypass silencieux si l'appelant n'est pas une instance de `User`
+
+**Fichier** : `src/Module/Sites/Infrastructure/ApiPlatform/State/Processor/SiteAwareInjectionProcessor.php:64-75`
+
+```php
+if (!$this->security->isGranted('sites.bypass_scope')) {
+    $user = $this->security->getUser();
+    $explicitSite = $data->getSite();
+    if ($user instanceof User && $explicitSite instanceof Site && !$user->hasSite($explicitSite)) {
+        throw new AccessDeniedHttpException(...);
+    }
+}
+```
+
+Si `$user` n'est pas exactement une instance de `App\Module\Core\Domain\Entity\User` (ex: futur provider d'auth tiers, token systeme), la condition `instanceof User` est fausse et la garde cross-site write est **silencieusement sautee**. L'utilisateur peut alors specifier n'importe quel `site` dans le payload sans verification.
+
+Aujourd'hui le risque est faible (un seul `app_user_provider` configure). Mais le pattern est fragile : une absence de type doit lever une erreur, pas passer.
+
+**Correction** : transformer le cas "pas un User" en refus explicite.
+
+```php
+if (!$this->security->isGranted('sites.bypass_scope')) {
+    $user = $this->security->getUser();
+    if (!$user instanceof User) {
+        throw new AccessDeniedHttpException('Utilisateur non reconnu pour la validation de site.');
+    }
+    $explicitSite = $data->getSite();
+    if ($explicitSite instanceof Site && !$user->hasSite($explicitSite)) {
+        throw new AccessDeniedHttpException(...);
+    }
+}
+```
+
+---
+
+### 1.7 IMPORTANT — `isHandlingUnauthorized` sans `try/finally` : flag bloque si `navigateTo` throw
+
+**Fichier** : `frontend/shared/composables/useApi.ts:25,125-130`
+
+```typescript
+let isHandlingUnauthorized = false  // module-level singleton
+
+// ...
+if (!isLoginCheck && !isLogout) {
+    if (!isHandlingUnauthorized) {
+        isHandlingUnauthorized = true
+        auth.clearSession()
+        await navigateTo('/login')
+        isHandlingUnauthorized = false  // <-- jamais atteint si navigateTo throw
+    }
+}
+```
+
+Si `navigateTo('/login')` echoue (middleware qui throw, plugin qui throw dans un hook, navigation cancelee par `abortNavigation`), le flag reste `true` **indefiniment**. Toutes les 401 futures sont silencieusement ignorees, l'utilisateur reste sur la page courante avec l'impression que les requetes ne font rien. Le seul remede est un hard-reload.
+
+**Correction** : `try/finally`.
+
+```typescript
+if (!isLoginCheck && !isLogout) {
+    if (!isHandlingUnauthorized) {
+        isHandlingUnauthorized = true
+        try {
+            auth.clearSession()
+            await navigateTo('/login')
+        } finally {
+            isHandlingUnauthorized = false
+        }
+    }
+}
+```
+
+---
+
+### 1.8 IMPORTANT — Pagination maximale absente sur `Permission`, `Role`, `Site` (itemsPerPage 999 cote front)
+
+**Fichiers** :
+- `frontend/modules/core/components/UserRbacDrawer.vue:235,236`
+- `frontend/modules/core/components/RoleDrawer.vue:149`
+- `frontend/modules/sites/pages/admin/sites.vue:117`
+
+```typescript
+api.get<{ member: Permission[] }>('/permissions', { orphan: false, itemsPerPage: 999 }, ...)
+api.get<{ member: Site[] }>('/sites', { itemsPerPage: 999 }, ...)
+```
+
+Deux problemes cumules :
+
+1. **`paginationClientItemsPerPage` n'est pas active** sur les resources `Permission`, `Role`, `Site` (seul `AuditLogResource` l'active). API Platform ignore donc `itemsPerPage=999` et retourne 30 elements par defaut. **Le `999` est un no-op**. Aujourd'hui ca marche parce que ces catalogues comptent <30 entrees, mais quand les modules grandiront, les drawers vont silencieusement tronquer.
+
+2. **Aucun `paginationMaximumItemsPerPage`** n'est pose sur ces ressources. Si un dev decide d'activer `paginationClientItemsPerPage: true` plus tard, `?itemsPerPage=99999` deviendra une requete valide qui pourra faire suer la DB.
+
+**Correction** : deux options selon l'intention.
+
+*Option A — Desactiver la pagination pour ces catalogues* (ils sont small + exhaustifs par nature) :
+
+```php
+// Permission.php — GetCollection
+new GetCollection(
+    normalizationContext: ['groups' => ['permission:read']],
+    security: "...",
+    paginationEnabled: false,
+),
+```
+
+Cote front, retirer `itemsPerPage: 999` (devient inutile).
+
+*Option B — Garder la pagination avec un plafond explicite* :
+
+```php
+new GetCollection(
+    paginationClientItemsPerPage: true,
+    paginationMaximumItemsPerPage: 200,
+    // ...
+),
+```
+
+---
+
+## 2. Bugs silencieux
+
+### 2.1 IMPORTANT — `AuditLogDetail.vue` : `JSON.stringify` sans garde sur valeur non-serialisable
+
+**Fichier** : `frontend/shared/components/audit/AuditLogDetail.vue` (fonction `formatValue`)
+
+Si une valeur de `changes` est non-serialisable (objet circulaire, symbol, bigint), `JSON.stringify` throw et casse tout le rendu du drawer. Ce cas est theoriquement impossible avec les donnees ecrites par `AuditListener` aujourd'hui, mais un futur enrichissement (ex: serialisation d'un objet metier complexe) peut introduire ce risque.
+
+**Correction** : wrapper defensif.
+
+```typescript
+function formatValue(value: unknown): string {
+    if (value === null || value === undefined) return 'vide'
+    if (typeof value === 'boolean') return value ? t('common.yes') : t('common.no')
+    if (typeof value === 'object') {
+        try { return JSON.stringify(value) } catch { return '[valeur non serialisable]' }
+    }
+    return String(value)
+}
+```
+
+---
+
+### 2.2 MOYEN — `UserRbacProcessor` : payload JSON invalide = regression silencieuse des collections
+
+**Fichier** : `src/Module/Core/Infrastructure/ApiPlatform/State/Processor/UserRbacProcessor.php:241-248`
+
+Le processor parse `$request->getContent()` via `json_decode()` pour savoir quelles cles sont absentes du payload et restaurer les collections qu'API Platform aurait ecrasees. Si le body est un JSON invalide (rare mais possible : content-type incorrect, body vide suite a un intercepteur buggue), `json_decode` retourne `null` et la restauration est `return` sans aucun log.
+
+Consequence : les collections `rbacRoles`, `directPermissions`, `sites` peuvent etre ecrasees par des tableaux vides sans trace. Bug quasi-impossible a diagnostiquer en prod.
+
+**Correction** : logger `warning` dans ce cas.
+
+```php
+$payload = json_decode($request->getContent(), true);
+if (!is_array($payload)) {
+    $this->logger->warning('UserRbacProcessor : body JSON invalide, skip de restoreAbsentCollections', [
+        'user_id' => $data->getId(),
+    ]);
+    return;
+}
+```
+
+---
+
+## 3. Violations des regles projet
+
+### 3.1 MOYEN — `<button>` brut au lieu de `MalioButton`
+
+**Fichier** : `frontend/shared/components/audit/AuditTimeline.vue:80`
+
+```html
+<button
+    type="button"
+    class="mt-3 text-sm text-blue-600 hover:text-blue-800"
+    @click="loadMore"
+>
+    {{ t('audit.timeline.load_more') }}
+</button>
+```
+
+**Regle violee** : `.claude/rules/frontend.md` — *"Tout champ de formulaire / filtre / bouton doit utiliser les composants Malio*"*.
+
+C'est le seul bouton HTML brut dans la PR. Aucun commentaire `TODO` ne documente une exception.
+
+**Correction** : utiliser `MalioButton` avec un variant secondaire/link.
+
+```html
+<MalioButton
+    type="secondary"
+    size="sm"
+    :label="t('audit.timeline.load_more')"
+    class="mt-3"
+    @click="loadMore"
+/>
+```
+
+Si `MalioButton` ne propose pas de variant "link" adapte, commenter l'exception :
+
+```html
+<!-- TODO(malio-ui) : MalioButton n'a pas encore de variant 'link-inline' -->
+<button ...>
+```
+
+---
+
+### 3.2 MOYEN — Cle i18n `sidebar.core.sites` sous le mauvais namespace
+
+**Fichiers** :
+- `config/sidebar.php:82` : `'label' => 'sidebar.core.sites'`
+- `frontend/i18n/locales/fr.json:31` : `"core": { "sites": "Sites" }`
+
+La regle `naming.md` impose `sidebar.<module>.*` pour les cles de sidebar. L'item est declare comme appartenant au module `sites` (`'module' => 'sites'`), la cle i18n devrait donc etre `sidebar.sites.admin` (ou `sidebar.sites.sites` / `sidebar.sites.list`).
+
+**Correction** :
+
+```json
+// frontend/i18n/locales/fr.json
+"sidebar": {
+    "core": {
+        "roles": "Gestion des rôles",
+        "users": "Utilisateurs",
+        "audit_log": "Journal d'audit"
+    },
+    "sites": {
+        "admin": "Sites"
+    }
+}
+```
+
+```php
+// config/sidebar.php
+[
+    'label' => 'sidebar.sites.admin',
+    'to'    => '/admin/sites',
+    'icon'  => 'mdi:domain',
+    'module'=> 'sites',
+    'permission' => 'sites.view',
+],
+```
+
+---
+
+### 3.3 MOYEN — `UserPasswordHasherProcessor` et `MeProvider` non `final`
+
+**Fichiers** :
+- `src/Module/Core/Infrastructure/ApiPlatform/State/Processor/UserPasswordHasherProcessor.php:16`
+- `src/Module/Core/Infrastructure/ApiPlatform/State/Provider/MeProvider.php:14`
+
+Ce sont les deux seules classes ApiPlatform de la PR qui ne sont pas `final`. Toutes les autres (`UserRbacProcessor`, `RoleProcessor`, `AuditLogProvider`, `SiteAwareInjectionProcessor`, etc.) le sont. Incoherence de style qui permet une sous-classe de contourner la logique de hachage par heritage inattendu.
+
+**Correction** : ajouter `final` et passer `readonly` tant qu'on y est.
+
+```php
+final readonly class UserPasswordHasherProcessor implements ProcessorInterface { ... }
+final readonly class MeProvider implements ProviderInterface { ... }
+```
+
+Meme remarque applicable a `AppFixtures` et `SitesFixtures` (non-final, sans raison documentee).
+
+---
+
+### 3.4 MINEUR — Couplage inter-modules (Core → Sites) dans `User`, fixtures, commande seed
+
+**Fichiers** :
+- `src/Module/Core/Domain/Entity/User.php:23` — PHPDoc `@var Collection<int, Site>`
+- `src/Module/Core/Infrastructure/DataFixtures/AppFixtures.php:12` — import `SiteRepositoryInterface`, `SitesFixtures`
+- `src/Module/Core/Infrastructure/Console/SeedE2ECommand.php:12` — import `SiteRepositoryInterface`
+
+La regle #1 (`CLAUDE.md`) interdit l'import direct d'un module vers un autre. Ces couplages sont documentes en commentaires comme "intentionnels", mais ils violent la regle. Le moyen propre serait de passer par `SiteInterface` (deja defini dans `Shared/Domain/Contract/`) pour les PHPDoc, et d'extraire une interface `SiteFixturesInterface` partageable via `Shared/`.
+
+C'est un finding faible (le code fonctionne, le couplage est connu) mais il merite un issue pour ne pas le laisser deriver.
+
+---
+
+## 4. Incoherences de patterns
+
+### 4.1 MOYEN — `debounce` reimplemente localement dans `audit-log.vue`
+
+**Fichier** : `frontend/modules/core/pages/admin/audit-log.vue:306-312`
+
+```typescript
+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
+}
+```
+
+Utile et correct, mais vit dans le composant au lieu de `frontend/shared/utils/debounce.ts`. Si une autre page ajoute un debounce, on va dupliquer. Il y a deja `color.ts` dans `shared/utils/` comme exemple de mini-util testee — `debounce.ts` a sa place a cote.
+
+**Correction** : extraire vers `frontend/shared/utils/debounce.ts` avec un test Vitest minimal.
+
+---
+
+### 4.2 MOYEN — `relativeDate` plafonne a la semaine
+
+**Fichier** : `frontend/shared/components/audit/AuditTimeline.vue:171-181`
+
+```typescript
+if (absSec < 604800) return fmt.format(..., 'day')
+return fmt.format(..., 'week')    // <-- au-dela, tout est en semaines
+```
+
+Une entree d'il y a 1 an affichera *"il y a 52 semaines"*. Peu lisible. Il manque les paliers `month` et `year`.
+
+**Correction** :
+
+```typescript
+if (absSec < 60)      return fmt.format(..., 'second')
+if (absSec < 3600)    return fmt.format(..., 'minute')
+if (absSec < 86400)   return fmt.format(..., 'hour')
+if (absSec < 604800)  return fmt.format(..., 'day')
+if (absSec < 2592000) return fmt.format(..., 'week')   // < 30j
+if (absSec < 31536000) return fmt.format(..., 'month') // < 365j
+return fmt.format(..., 'year')
+```
+
+---
+
+### 4.3 MOYEN — `entityType` affiche brut dans le drawer d'audit
+
+**Fichier** : `frontend/modules/core/pages/admin/audit-log.vue:138-139`
+
+```html
+<h3 class="text-sm font-medium text-gray-700 mb-2">
+    {{ selectedEntry.entityType }} #{{ selectedEntry.entityId }}
+</h3>
+```
+
+Affiche `core.User #42`, `sites.Site #7`, etc. La cle i18n `audit.entity.user` existe deja dans `fr.json:79` mais n'est pas utilisee. La spec `doc/audit-log.md` mentionne ce lookup.
+
+**Correction** :
+
+```vue
+<script setup lang="ts">
+function formatEntityType(type: string): string {
+    const key = `audit.entity.${type.toLowerCase().replace('.', '_')}`
+    return te(key) ? t(key) : type
+}
+</script>
+
+<template>
+    <h3>{{ formatEntityType(selectedEntry.entityType) }} #{{ selectedEntry.entityId }}</h3>
+</template>
+```
+
+Et ajouter les cles manquantes dans `fr.json` :
+
+```json
+"audit": {
+    "entity": {
+        "core_user": "Utilisateur",
+        "core_role": "Rôle",
+        "core_permission": "Permission",
+        "sites_site": "Site"
+    }
+}
+```
+
+---
+
+### 4.4 MINEUR — `loadSidebar()` recharge inutile a chaque switch de site
+
+**Fichier** : `frontend/modules/sites/composables/useCurrentSite.ts:94-97`
+
+```typescript
+await loadSidebar()  // apres chaque switch
+```
+
+Commentaire : *"les filtres de modules peuvent dependre du site courant"*. En pratique, dans `config/sidebar.php` de Coltura aucun item ne depend du site. C'est un aller-retour reseau inutile a chaque switch, et la sidebar peut "flicker" pour l'utilisateur.
+
+**Correction** : rendre le rechargement opt-in ou documenter la raison actuelle (prevoir le futur).
+
+```typescript
+// La sidebar ne depend actuellement d'aucun site, mais le /api/sidebar
+// pourrait devenir site-scoped dans le futur (ex: items RH par site).
+// On garde le reload pour etre defensif — cout : 1 RTT par switch (~100ms).
+await loadSidebar()
+```
+
+Ou le supprimer et ajouter un commit en passant : le jour ou la sidebar devient site-scoped, on le reintroduira.
+
+---
+
+### 4.5 MINEUR — Alias de retrocompat `SiteNotAuthorizedException` sans planning de suppression
+
+**Fichier** : `src/Module/Sites/Domain/Exception/SiteNotAuthorizedException.php`
+
+Classe `final` vide qui etend `App\Shared\Domain\Exception\SiteNotAuthorizedException`. Aucun usage restant dans la branche — c'est une dette technique a supprimer.
+
+**Correction** : rechercher les usages (`grep -r 'Sites\\Domain\\Exception\\SiteNotAuthorizedException'`), les remplacer, puis supprimer le fichier.
+
+---
+
+## 5. Documentation et configuration
+
+### 5.1 MINEUR — `CHANGELOG.md` non mis a jour
+
+**Fichier** : `CHANGELOG.md`
+
+Toujours bloque sur `## [0.0.0]` avec un contenu pre-PR. Aucun resume de la feature audit-log, du module Sites, du systeme RBAC.
+
+**Correction** : ajouter des entrees `## [0.1.34]` (ou la version courante au merge) avec les sections `Added`, `Changed`, `Fixed`.
+
+---
+
+### 5.2 MINEUR — `AuditLogEntityTypesResource` a un `id` hardcode inutile
+
+**Fichier** : `src/Module/Core/Infrastructure/ApiPlatform/Resource/AuditLogEntityTypesResource.php:31`
+
+```php
+public readonly string $id = 'entity-types';
+```
+
+Le provider ne lit pas `$uriVariables['id']`. Ce champ est du bruit dans le DTO. Si quelqu'un regarde la reponse JSON en pensant "tiens, quel est cet id ?", il perd du temps.
+
+**Correction** : supprimer la propriete `$id`.
+
+---
+
+### 5.3 MINEUR — Commentaire incorrect sur l'escape LIKE en PostgreSQL
+
+**Fichier** : `src/Module/Core/Infrastructure/ApiPlatform/State/Provider/AuditLogProvider.php:175-176`
+
+Voir 1.5. Le commentaire affirme une propriete fausse de PostgreSQL. A corriger avec la fix du filtre.
+
+---
+
+## 6. Frontend et UX
+
+### 6.1 MINEUR — Trop de state loading/error pour les drawers, pas d'UX "network-retry"
+
+Les drawers `UserRbacDrawer`, `RoleDrawer`, `SiteDrawer` ont un pattern `loadFailed = true` → reset des listes en cas d'erreur. Bon point pour eviter les donnees stale. Mais aucun bouton "Reessayer" n'est offert : l'utilisateur doit fermer et rouvrir le drawer pour relancer le fetch. Un bouton `MalioButton` "Reessayer" dans l'etat erreur ameliorerait l'UX.
+
+Non bloquant, juste une suggestion pour la prochaine iteration.
+
+---
+
+### 6.2 MINEUR — `onMounted` dans `logout.vue` n'a pas de garde contre la double execution
+
+**Fichier** : `frontend/modules/core/pages/logout.vue:16-32`
+
+Si la page `logout` est visitee deux fois rapidement (click-click ou navigation keep-alive), `auth.logout()` est appele deux fois en parallele. Le backend Lexik JWT logout est idempotent donc c'est inoffensif, mais on peut voir deux toasts d'erreur si le reseau tombe pile entre les deux.
+
+Pas critique. A signaler pour info.
+
+---
+
+## 7. Bonnes pratiques a retenir
+
+### Ce qui est vraiment bien fait dans cette PR
+
+1. **Pattern swap-and-clear dans `AuditListener::postFlush`** — La copie locale de `$pendingLogs` puis le vidage immediat avant l'iteration proteje contre les flushs re-entrants. Le try/catch par entree garantit qu'une erreur d'audit ne casse jamais le flow metier. C'est exactement ce que la spec demandait, implemente correctement.
+
+2. **Connexion DBAL dediee `audit` avec propagation du suffixe `_test`** — Piege classique rate dans beaucoup de projets : la connexion secondaire ecrit dans la base dev pendant que l'ORM ecrit dans la base test. Ici, `doctrine.yaml` propage `dbname_suffix` aux deux connexions en environnement test + `idle_connection_ttl: 1` pour ne pas saturer le pool. Propre.
+
+3. **Trois miroirs RBAC parfaitement synchronises** — `config/sidebar.php` + `frontend/tests/e2e/_fixtures/personas.ts` + `src/Module/Core/Infrastructure/Console/SeedE2ECommand.php`. Les 6 personas et les 4 liens admin (`users`, `roles`, `sites`, `audit-log`) matchent a la ligne pres. C'est la regle la plus dure a tenir sur la duree.
+
+4. **Protection `AdminHeadcountGuard` avec limitation TOCTOU documentee honnetement** — Le commentaire du guard cite explicitement le risque accepte plutot que de le cacher. Pour un CRM interne mono-operateur, c'est la bonne decision d'architecture.
+
+5. **`useAuditLog` s'auto-enregistre via `onAuthSessionCleared`** — Respecte la regle "composable singleton = reset au logout". Idem pour `useSidebar`, `useModules`, `useCurrentSite`. Discipline appliquee partout.
+
+6. **Pagination cappee sur `AuditLogResource`** (`paginationMaximumItemsPerPage: 50`) — Bon reflexe defensif contre les requetes abusives sur le volume appele a croitre.
+
+7. **Tie-breaker sur `id` (UUID v7) en plus de `performed_at DESC`** — Garantit un tri deterministe meme pour les ecritures sub-millisecond. Detail rare qui evite un bug de pagination futur.
+
+8. **`AuditLogResource` est read-only stricte** (aucun POST/PUT/PATCH/DELETE) — Conforme au caractere append-only documente. Le 405 est automatique.
+
+### Les 10 regles a graver (tirees des findings)
+
+1. **Ne jamais laisser `/api/docs` publique en prod** — c'est une carte offerte gratuitement a un attaquant.
+2. **Toujours poser les en-tetes de securite de base** (X-Frame-Options, X-Content-Type-Options, Referrer-Policy, HSTS) — 3 lignes de Nginx, impact enorme.
+3. **Toujours typer les parametres DBAL** (`Types::DATETIMETZ_IMMUTABLE` et compagnie) — passer une string brute a une colonne typee est un bug en attente.
+4. **LIKE/ILIKE avec input utilisateur = toujours clause `ESCAPE` explicite** — ne pas se fier au comportement par defaut.
+5. **`instanceof` + comportement "OK si pas du bon type" = faille** — une absence de type doit lever, pas passer.
+6. **Tout `await` dans un callback qui modifie un flag singleton = `try/finally`** — sinon un throw bloque le flag.
+7. **Toujours poser `paginationMaximumItemsPerPage`** sur les ressources exposees — sinon c'est un DoS en un query param.
+8. **`JSON.stringify` sur donnees externes = toujours try/catch** — les objets circulaires existent.
+9. **Cles i18n doivent suivre le namespace du module owner** (`sidebar.<module>.*`) — sinon on accumule des cles orphelines.
+10. **`final` par defaut sur les services applicatifs** — ouverture a l'heritage = decision explicite, pas oublie.
+
+---
+
+## 8. Resume par priorite
+
+| Priorite | Section | Probleme | Fichier |
+|----------|---------|----------|---------|
+| **P0** | 1.1 | `/api/docs` accessible public en prod | `config/packages/security.yaml:46` |
+| **P0** | 1.2 | Aucun en-tete de securite HTTP en prod | `infra/prod/nginx.conf`, `nginx-proxy.conf` |
+| **P0** | 1.3 | `robots.txt` autorise l'indexation | `frontend/public/robots.txt` |
+| **P1** | 1.4 | `performed_at` sans typage → crash 500 | `AuditLogProvider.php:182-186` |
+| **P1** | 1.5 | ILIKE sans clause `ESCAPE` | `AuditLogProvider.php:177-180` |
+| **P1** | 1.6 | `SiteAwareInjectionProcessor` bypass silencieux | `SiteAwareInjectionProcessor.php:71` |
+| **P1** | 1.7 | `isHandlingUnauthorized` sans try/finally | `useApi.ts:125-130` |
+| **P1** | 1.8 | `itemsPerPage:999` no-op + pas de cap | `UserRbacDrawer.vue:235-236`, `RoleDrawer.vue:149`, `sites.vue:117` |
+| **P1** | 2.1 | `JSON.stringify` sans garde | `AuditLogDetail.vue` |
+| **P2** | 2.2 | Log manquant si JSON body invalide | `UserRbacProcessor.php:241-248` |
+| **P2** | 3.1 | `<button>` brut au lieu de `MalioButton` | `AuditTimeline.vue:80` |
+| **P2** | 3.2 | Cle i18n sous mauvais namespace | `sidebar.php:82`, `fr.json:31` |
+| **P2** | 3.3 | Classes non `final` incoherentes | `UserPasswordHasherProcessor.php`, `MeProvider.php` |
+| **P2** | 4.1 | `debounce` duplique local | `audit-log.vue:306-312` |
+| **P2** | 4.2 | `relativeDate` plafonne a la semaine | `AuditTimeline.vue:181` |
+| **P2** | 4.3 | `entityType` non traduit | `audit-log.vue:138-139` |
+| **P3** | 3.4 | Couplage inter-modules Core→Sites | `User.php:23`, `AppFixtures.php:12`, `SeedE2ECommand.php:12` |
+| **P3** | 4.4 | `loadSidebar()` inutile apres switch site | `useCurrentSite.ts:94-97` |
+| **P3** | 4.5 | Alias `SiteNotAuthorizedException` | `Sites/Domain/Exception/` |
+| **P3** | 5.1 | CHANGELOG non mis a jour | `CHANGELOG.md` |
+| **P3** | 5.2 | `id` hardcode dans `AuditLogEntityTypesResource` | ligne 31 |
+| **P3** | 6.1 | Pas de bouton "Reessayer" sur drawer erreur | drawers |
+| **P3** | 6.2 | Double execution `onMounted` logout | `logout.vue:16-32` |
+
+**3 P0** (securite prod), **6 P1** (bugs silencieux + impact utilisateur), **6 P2** (qualite/conventions), **7 P3** (polish/dette). Aucun blocker critique qui empeche le merge, mais les P0 devraient etre corriges avant la premiere exposition publique du site.
+
+---
+
+> Voir `TICKETS.md` pour les tickets actionnables.

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/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,13 +1,38 @@
 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
         identity_generation_preferences:
             Doctrine\DBAL\Platforms\PostgreSQLPlatform: identity
         auto_mapping: true
+        # Mapping contrat DDD → classe concrete. Permet au module Core de
+        # referencer `SiteInterface` dans ses ORM mappings (User) sans importer
+        # la classe concrete du module Sites. Pattern officiel Doctrine pour
+        # les bounded contexts, remplace l'ancien import direct
+        # `App\Module\Sites\Domain\Entity\Site` dans User.php.
+        resolve_target_entities:
+            App\Shared\Domain\Contract\SiteInterface: App\Module\Sites\Domain\Entity\Site
         mappings:
             Core:
                 type: attribute
@@ -31,7 +56,24 @@ doctrine:
 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

config/packages/twig.yaml

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

config/services.yaml

@@ -28,5 +28,8 @@ services:
     App\Module\Sites\Domain\Repository\SiteRepositoryInterface:
         alias: App\Module\Sites\Infrastructure\Doctrine\DoctrineSiteRepository
 
+    App\Shared\Domain\Contract\SiteProviderInterface:
+        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,17 +77,18 @@ return [
                 'permission' => 'core.users.view',
             ],
             [
-                'label'      => 'sidebar.core.sites',
+                'label'      => 'sidebar.sites.admin',
                 'to'         => '/admin/sites',
                 'icon'       => 'mdi:domain',
                 'module'     => 'sites',
                 'permission' => 'sites.view',
             ],
             [
-                'label'  => 'sidebar.general.logout',
-                'to'     => '/logout',
-                'icon'   => 'mdi:logout',
-                'module' => 'core',
+                'label'      => 'sidebar.core.audit_log',
+                'to'         => '/admin/audit-log',
+                'icon'       => 'mdi:clipboard-text-clock',
+                'module'     => 'core',
+                'permission' => 'core.audit_log.view',
             ],
         ],
     ],
@@ -75,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.32'
+    app.version: '0.1.36'

doc/audit-log-review-backlog.md

@@ -0,0 +1,466 @@
+# Backlog — Code review PR #9 (audit-log)
+
+Findings du review multi-agent (security + architecture + codex sceptique) sur la PR #9 `feat/audit-log`, qui **n'ont pas ete traites dans la PR** et sont a ouvrir en tickets dedies.
+
+Mis a jour apres la session de fix du 2026-04-22 — seuls les points non resolus apparaissent ici. Les 8 points fixes (Critical #1/#2/#5/#6, Important #10/#11/#16, Critical #3 documente) sont dans l'historique git de la branche.
+
+Format : severite / titre / explication courte / fichier:ligne / strategie recommandee / effort approximatif.
+
+---
+
+## 🔴 Critical parke
+
+### C-4 — Blacklist password exact-match et non recursive
+
+**Fichier** : `src/Module/Core/Infrastructure/Audit/AuditLogWriter.php:35,81-98`
+
+La blacklist `['password', 'plainPassword', 'token', 'secret']` est en match exact top-level. Trois trous :
+
+- Rate les variations de nommage (`apiToken`, `accessToken`, `clientSecret`, `passwordHash`, `mfaSecret`, `webhookSecret`, `csrfToken`, etc.)
+- Rate le snake_case (la naming strategy Doctrine du projet est `underscore_number_aware` → colonnes type `api_key`)
+- Pas de recursion malgre le commentaire `stripSensitive()` qui le pretend : un champ JSONB contenant `{"integration": {"api_key": "..."}}` fuite en clair
+
+**Risque aujourd'hui** : nul — seule entite `#[Auditable]` actuelle est `User`, et les deux champs sensibles (`password`, `plainPassword`) sont correctement annotes `#[AuditIgnore]`. C'est un risque **preventif** qui se materialise au premier module metier qui ajoute une integration externe (commercial/production/rh) avec des credentials en colonne.
+
+**Strategie recommandee (Option B du brainstorm)** :
+- Supprimer la blacklist (fausse securite)
+- Faire de `#[AuditIgnore]` la seule defense
+- Ajouter un test CI : parcourt toutes les entites `#[Auditable]` via reflection, liste les proprietes dont le nom matche `/token|secret|password|key|salt|hash|passphrase/i`, assert que chacune porte `#[AuditIgnore]`
+
+**Effort** : 15-20 min.
+
+---
+
+## 🔴 Critical documente mais pas fixe code
+
+### C-3 — Savepoints + connexion audit dediee = lignes audit orphelines
+
+**Fichiers** : `src/Module/Core/Infrastructure/Audit/AuditLogWriter.php:19-30`, `config/packages/doctrine.yaml:3-23`
+
+Le contrat est documente dans `doc/audit-log.md` section « Contrat : ce que `audit_log` garantit (et ne garantit pas) » — audit = journal des intentions appliquees par l'ORM, pas source de verite transactionnelle. Acceptable pour un CRM interne (rollbacks outermost rares).
+
+Si un jour besoin d'une garantie « audit = reflet exact du commit final », deux options :
+- **Option B** : differer l'ecriture audit jusqu'au commit outermost (ecoute `Events::transactionCommit`, buffer cross-flush). Complexe, distinguer RELEASE SAVEPOINT d'un vrai COMMIT.
+- **Option C** : ecrire l'audit sur la meme connexion que le metier. Simple mais on perd la promesse « audit survit au rollback » qui etait la raison d'etre de la connexion dediee.
+
+**Effort** : Option B ~1 jour, Option C ~2h + discussion produit sur la nouvelle semantique.
+
+---
+
+### C-5 — Enumeration laterale via `entity_type` cross-permission
+
+**Fichiers** : `src/Module/Core/Infrastructure/ApiPlatform/State/Provider/AuditLogProvider.php:111-211`, `src/Module/Core/Infrastructure/ApiPlatform/Resource/AuditLogResource.php:44-52`
+
+Le seul check d'acces est `is_granted('core.audit_log.view')`. Un user qui possede cette permission mais **pas** `core.users.view` / `sites.view` peut faire :
+
+```
+GET /api/audit-logs?entity_type=core.User&entity_id=42
+GET /api/audit-logs?entity_type=sites.Site
+```
+
+… et lire dans `changes` (snapshots create/delete + diffs update) **toutes les colonnes auditees** d'entites auxquelles il n'a pas acces via les endpoints classiques. Le `changes` JSONB contient le payload complet.
+
+**Risque aujourd'hui** : un user RBAC avec uniquement `core.audit_log.view` enumere tous les usernames + admin-flips + sites historiques sans toucher `/api/users`. La permission "lecture audit" est de facto plus large que prevue.
+
+**Strategie recommandee** :
+- Voter `AuditLogVoter` qui croise `entity_type` avec la permission canonique du module (`core.User → core.users.view`, `sites.Site → sites.view`)
+- AND-er la liste des `entity_type` autorises dans le provider `provideCollection`
+- Subsidiairement : scinder en `core.audit_log.view` (mes propres actions) vs `core.audit_log.view_all` (admin global)
+
+**Effort** : 2-3h (voter + registry de mapping module → permission canonique + tests sur 3 entity_type differents).
+
+**Impact** : confidentialite cross-module. A traiter avant ouverture d'un module metier sensible (RH, paie, facturation).
+
+---
+
+## 🟠 Important
+
+### I-7 — `DbalPaginator` fait `COUNT(*)` sur chaque list request
+
+**Fichier** : `src/Module/Core/Infrastructure/ApiPlatform/State/Provider/AuditLogProvider.php:75-99`
+
+PostgreSQL (MVCC) doit reellement scanner pour `COUNT(*)` — pas `O(1)` comme MySQL MyISAM. Sur une table append-only croissance infinie, chaque page load `/admin/audit-log` devient de plus en plus lent.
+
+Estimation : ~10k lignes/jour (50 users × 200 actions) → 3.65M lignes/an → page load de 20ms aujourd'hui, ~2-3s dans 2 ans. Pire avec un filtre ILIKE (wildcard leading = full scan).
+
+**Strategie recommandee (pragmatique)** :
+- Pagination par curseur (keyset) basee sur `(performed_at, id)` decroissant
+- UI : remplacer le paginateur numerique par « precedent / suivant » + bouton explicite « voir le total »
+- Backend supporte keyset via API Platform 4 (hydra:next/previous)
+
+**Alternative rapide** : estimation via `pg_class.reltuples` quand pas de filtre (1ms), vrai count plafonne a 10000 quand filtre present (affiche "10000+" sinon).
+
+**Effort** : keyset complet ~1h30-2h, version pragmatique ~30 min.
+
+**Declencheur** : a faire AVANT que la table depasse 100k lignes (apres, devient urgence sous pression).
+
+---
+
+### I-8 — Pas de politique de retention / archival sur `audit_log`
+
+**Fichiers** : `migrations/Version20260420202749.php`, `doc/audit-log.md`
+
+La migration elle-meme decrit la table comme « croissance infinie ». Aucune TTL, archive job, ou partitioning documente. Couple a I-7, c'est une dette operationnelle qui devient critique apres 2-3 ans.
+
+**Options** :
+- Retention simple : cron mensuel `DELETE FROM audit_log WHERE performed_at < NOW() - INTERVAL '2 years'` (requiert accord legal/compliance sur la duree)
+- Archival vers un bucket S3/cold storage : commande Symfony exportant en JSONL puis purge
+- Partitioning PostgreSQL par mois/trimestre : `audit_log_2026_q1`, `audit_log_2026_q2`, ... drop partition apres N mois
+
+**Effort** : depend du choix. Retention simple ~2h. Archival ~1 jour. Partitioning ~1-2 jours + migration progressive.
+
+**Decision produit requise** avant implementation.
+
+---
+
+### I-9 — Echec DB audit silencieusement swallowed, pas d'alerting
+
+**Fichier** : `src/Module/Core/Infrastructure/Doctrine/AuditListener.php:151-169`
+
+Le try/catch swallow toute exception de `AuditLogWriter::log()`, log au niveau `error` dans Monolog, et continue. Si la connexion `audit` tombe (pool sature, disque plein, etc.), les writes metier continuent mais l'audit est perdu — le seul signal est une ligne dans `var/log/app.log`.
+
+Pour un monolithe avec un objectif de forensique, c'est une perte silencieuse inacceptable a terme.
+
+**Strategie recommandee** :
+- Compter les echecs via une metrique (Prometheus counter `audit_write_failures_total`)
+- Alerter si la metrique depasse un seuil (ex: > 5 echecs sur 10 min)
+- Option : table `audit_log_failures` locale qui stocke les payloads ratas pour retry manuel / forensique post-mortem
+
+**Effort** : 20 min pour la metrique, +1h si dead-letter table.
+
+---
+
+### I-12 — `ensureCurrentSiteConsistency` : 2e flush attribue a l'admin qui PATCH
+
+**Fichier** : `src/Module/Core/Infrastructure/ApiPlatform/State/Processor/UserRbacProcessor.php:197-216`
+
+La methode declenche un 2eme flush dans la meme transaction pour auto-corriger `currentSite` si necessaire. Ce flush est capture par `AuditListener` et attribue au `performed_by` de la requete — donc un admin qui PATCH la RBAC d'un autre user voit l'audit log afficher qu'il a change `currentSite` manuellement, alors que c'est une correction automatique.
+
+**Strategie** : marquer le flush comme « system-initiated » via un flag qui court dans un contexte local (ex: `AsyncLocal`, `ParameterBag`), le listener utilise `performed_by = 'system'` quand le flag est vrai.
+
+**Effort** : 10-15 min.
+
+**Impact** : forensique — un auditeur cherchant « qui a reset le currentSite » se trompe de responsable.
+
+---
+
+### I-13 — `AuditListener` pas scope-pinne a l'EntityManager
+
+**Fichier** : `src/Module/Core/Infrastructure/Doctrine/AuditListener.php:65-66`
+
+Le listener utilise `#[AsDoctrineListener(event: ...)]` sans argument `connection`. Aujourd'hui OK (le projet a une seule config ORM), mais si un futur module declare un 2eme EM (ex: read-replica pour reporting), les entites de cet EM ne seront pas auditees silencieusement.
+
+**Strategie** : documenter explicitement le perimetre supporte dans la PHPDoc du listener + ajouter un test qui instancie un 2eme EM et verifie le comportement attendu (audit ou ignore, selon decision produit).
+
+**Effort** : 5 min doc + 30 min test si besoin.
+
+---
+
+### I-14 — Pas de regression test direct pour "sites overwritten on PATCH omission"
+
+**Fichier** : `tests/Module/Core/Api/UserRbacSitesApiTest.php:142-169`
+
+Le test `testRbacPatchWithoutSitesFieldDoesNotChangeCurrentSite` verifie que `currentSite` n'est pas touche, mais n'assert pas que la collection `sites` elle-meme est preservee. Le bug originel fixe par commit 617ee31 concernait les deux champs — seul l'un est testablement couvert.
+
+**Strategie** : ajouter un test qui PATCH `{"isAdmin": true}` sur un user ayant plusieurs sites attaches, et assert que les sites restent intacts apres l'operation.
+
+**Effort** : 5 min.
+
+---
+
+### I-15 — `AuditLogProvider` trop gras : extraire `DbalAuditLogRepository`
+
+**Fichier** : `src/Module/Core/Infrastructure/ApiPlatform/State/Provider/AuditLogProvider.php`
+
+Le Provider API Platform contient 80+ lignes de query building, extraction de filtres, escape LIKE, pagination, hydratation. Responsabilite mixte « orchestration API » et « requetes DBAL ». Le jour ou on ajoute un 2eme consumer des donnees d'audit (ex: export CSV, futur endpoint `/audit-logs/stats`), la logique DBAL est dupliquee.
+
+**Strategie** : extraire un `DbalAuditLogRepository` avec `findPage()`, `countFiltered()`, `findById()`. Provider devient un thin adapter.
+
+**Effort** : 20-30 min refacto.
+
+---
+
+### I-18 — `useAuditLog.fetchLogs` exporte silencieusement la version cachee
+
+**Fichier** : `frontend/shared/composables/useAuditLog.ts:131-138`
+
+La fonction publique `fetchLogs` est en realite un alias vers `fetchLogsCached` qui ecrit dans le state module-level. Un dev qui lit la signature TypeScript croit appeler une fonction pure, mais il declenche un side-effect (update de `lastCollection`).
+
+**Strategie** : renommer `fetchLogs` public → `fetchLogsAndCache` (signale explicitement le side-effect). Ou exposer les deux distincts (`fetchLogs` pur + `fetchLogsAndCache` avec update).
+
+**Effort** : 5 min (ripple sur `audit-log.vue` a suivre).
+
+---
+
+### I-19 — `RequestIdProvider` pas reset sur `kernel.finish_request`
+
+**Fichier** : `src/Module/Core/Infrastructure/Audit/RequestIdProvider.php:22-42`
+
+Le `requestId` est set en `kernel.request` mais jamais cleared. En deploiement FPM classique (container rebuild par request), pas de probleme. Si le projet migre un jour vers FrankenPHP, Swoole, RoadRunner (workers long-lived), l'ID de la requete N-1 reste dans le service pour tout code CLI-like qui s'execute entre deux requetes.
+
+**Strategie** : ajouter un event listener sur `kernel.finish_request` qui reset `$this->requestId = null` si c'est la main request.
+
+**Effort** : 5 min + test.
+
+**Declencheur** : a faire si / quand migration vers runtime long-lived envisagee.
+
+---
+
+### I-20 — `framework.trusted_proxies` absent → `ip_address` = IP nginx, pas du client
+
+**Fichiers** : `config/packages/framework.yaml`, `src/Module/Core/Infrastructure/Audit/AuditLogWriter.php:69`
+
+Aucune entree `trusted_proxies` ni env `TRUSTED_PROXIES`. Coltura tourne derriere `nginx-coltura` → `php-coltura-fpm`. `Request::getClientIp()` retourne donc systematiquement l'IP **du conteneur nginx** (reseau Docker interne), pas l'IP reelle du client. Toute la valeur forensique de `ip_address` est nulle en prod.
+
+Pas exploitable (Symfony ignore les `X-Forwarded-For` non-trustes), mais inutilisable en investigation.
+
+**Strategie** : declarer `framework.trusted_proxies: '127.0.0.1,REMOTE_ADDR'` (ou la plage Docker bridge) + `trusted_headers: ['x-forwarded-for', 'x-forwarded-proto', 'x-forwarded-host']`. Documenter le fallback.
+
+**Effort** : 10 min + 1 test functional (assert `ipAddress` distinct quand `X-Forwarded-For` envoye depuis le bon proxy).
+
+---
+
+### I-21 — Test du contrat « ligne audit survit au rollback metier » manquant
+
+**Fichier** : `tests/Module/Core/Infrastructure/Doctrine/AuditListenerTest.php`
+
+La spec `doc/audit-log.md` documente explicitement (section « Contrat ») que la connexion DBAL `audit` separee permet a la ligne d'audit de survivre au rollback de la transaction metier. Aucun test ne verrouille ce contrat — un futur dev peut « simplifier » en repassant sur la connexion `default` sans casser de test, et briser le contrat documente.
+
+**Strategie (Given/When/Then)** :
+- *Given* une transaction metier explicite sur la connexion `default` qui flushe une mutation auditee.
+- *When* la transaction outermost est rollback.
+- *Then* la ligne `audit_log` (sur connexion `audit`) est presente.
+
+**Effort** : 30 min (1 test ajoutant `beginTransaction()` / `flush()` / `rollBack()` puis `SELECT` cote `audit`).
+
+---
+
+### I-22 — Filtres `performed_at[after]/[before]` timezone-naifs
+
+**Fichier** : `src/Module/Core/Infrastructure/ApiPlatform/State/Provider/AuditLogProvider.php:155-169,205-209`
+
+La validation `strtotime()` accepte n'importe quel format, mais le string brut est passe tel quel a PostgreSQL. Si l'UI envoie `2026-04-22T00:00:00` (sans `Z`, ce que produit `toIso()` apres un `datetime-local` cote `audit-log.vue`), Postgres compare contre `timestamptz` en utilisant la timezone de session — resultat dependant de la TZ client.
+
+**Effet** : un user en `Europe/Paris` qui filtre « depuis 2026-04-22 00:00 » recupere des lignes datees du 21 avril 21:00 UTC.
+
+**Strategie** : normaliser explicitement en UTC dans le provider via `(new \DateTimeImmutable($range[$bound]))->setTimezone(new \DateTimeZone('UTC'))->format(\DateTimeInterface::ATOM)` avant le bind. Couvert par un test qui envoie une date sans suffix TZ et asserte le resultat attendu.
+
+**Effort** : 15 min + 1 test.
+
+---
+
+### I-23 — `auth.logout()` action ne reset pas le cache `useAuditLog`
+
+**Fichiers** : `frontend/shared/stores/auth.ts:72-84`, `frontend/shared/composables/useAuditLog.ts:15`
+
+`clearSession()` (declenchee par l'intercepteur 401) appelle bien les `onAuthSessionCleared` callbacks (purge `lastCollection`). Mais l'action `logout()` met juste `this.user = null` **sans appeler les callbacks**. Le chemin nominal fonctionne car `pages/logout.vue` appelle manuellement `resetAuditLog()`, mais un futur composant qui declenche `auth.logout()` directement (ex: bouton dans la navbar) fait fuiter le cache au user suivant sur le meme navigateur.
+
+**Strategie** : faire que `logout()` action appelle `this.clearSession()` au lieu de muter a la main, pour centraliser le reset.
+
+**Effort** : 5 min + test Vitest (cf. I-24).
+
+---
+
+### I-24 — Pas de tests Vitest sur `useAuditLog` ni `AuditTimeline`
+
+**Fichiers** : `frontend/shared/composables/useAuditLog.ts`, `frontend/shared/components/audit/AuditTimeline.vue`
+
+Aucun test unitaire front. Cas critiques a couvrir :
+
+- `useAuditLog` : `buildQuery({entityType: ['core.User', 'core.Role']})` produit `entity_type[]=core.User&entity_type[]=core.Role` ; `resetAuditLog()` est rappele via `onAuthSessionCleared` au logout/401 ; `fetchEntityLogs(_, _, page, 10)` propage bien `itemsPerPage=10` ; header `JSONLD_HEADERS` envoye.
+- `AuditTimeline` : rendu vide quand `!can('core.audit_log.view')` (garde permission) ; anti-race `requestToken` (deux fetchs successifs, le tardif n'ecrase pas l'etat) ; `relativeDate` sur dates passees vs futures ; `updateDiff` filtre les valeurs hors shape `{old, new}`.
+
+**Strategie** : `frontend/shared/composables/__tests__/useAuditLog.test.ts` et `frontend/shared/components/audit/__tests__/AuditTimeline.test.ts`, happy-dom, mock `useApi()` et `usePermissions()`.
+
+**Effort** : 1h-1h30 cumule (8 tests).
+
+**Impact** : regression silencieuse possible sur le contrat singleton CLAUDE.md (`reset*()` au logout) et sur l'anti-race front, deux invariants subtils.
+
+---
+
+### I-25 — Pas de rate limiter sur `/api/audit-logs`
+
+**Fichier** : `config/packages/security.yaml`, `src/Module/Core/Infrastructure/ApiPlatform/Resource/AuditLogResource.php`
+
+Un user authentifie avec `core.audit_log.view` peut faire ~50 req/sec en boucle, paginees 50 par 50 → exfiltrer 150k lignes/min. Avec la croissance estimee (cf. I-7), un scrape complet d'une annee d'audit prend ~30 min. Combine au `COUNT(*)` non-cache (I-7), c'est aussi un vecteur DoS DB.
+
+**Strategie** : `framework.rate_limiter.audit_log` (token bucket, ex: 60/min/user) + middleware sur la collection. Pour les admins, limite plus haute documentee.
+
+**Effort** : 30 min + 1 test functional (15 requetes en boucle → 429 sur la 16e).
+
+---
+
+### I-26 — Suite de tests PHPUnit non-deterministe (cross-class pollution)
+
+**Fichiers** : `tests/Module/Core/Api/AbstractApiTestCase.php`, `tests/Module/Core/Api/RoleApiTest.php`, `tests/Module/Core/Api/UserApiTest.php`, `tests/Module/Core/Api/PermissionApiTest.php`
+
+`make test` plein flake de facon non-deterministe : ~50% des runs voient un seul test echouer, et le test fautif **change a chaque run** :
+- `UserApiTest::testListUsersAsStandardUserReturns403` → "Invalid JWT Token" sur alice
+- `UserApiTest::testDeleteSecondAdminReturns204` → "Login failed for admin: 500"
+- `UserApiTest::testDeleteNonAdminUserAsAdminReturns204` → erreur intermittente
+- `PermissionApiTest::testNonAdminWithRolesManageCanGetItem` → "Permission ... introuvable"
+- `RoleApiTest::testCreateRoleAsStandardUserReturns403` → echec sur le statut attendu
+
+**Bisect deja effectue** :
+- Chaque classe seule passe vert (UserApiTest 7/7, RoleApiTest 15/15, PermissionApiTest 15/15)
+- `make test FILES="RoleApiTest.php UserApiTest.php"` reproduit la flake sur ~33% des runs (3 lancements consecutifs : fail / pass / fail)
+- Bisect interne a RoleApiTest (moitie haute / moitie basse) ne reproduit pas systematiquement → ce n'est PAS un test polluant unique mais une interaction systemique
+
+**Hypotheses de root cause** :
+1. `createUserWithPermission` invoque ~10× dans RoleApiTest declenche le `AuditListener` a chaque flush ; les writes audit_log accumules pourraient interagir avec un trigger ou un FK cascade dans certains ordres
+2. Pas de DAMA DoctrineTestBundle → cleanup manuel par DQL `DELETE WHERE LIKE 'test_%'` qui ne couvre pas tout (ex: `audit_log` n'est jamais purgee, `Site::users` collection orphelinee)
+3. Cache PHPUnit (`.phpunit.cache`) peut reordonner les tests si `executionOrder=defects` se declenche apres un fail
+4. Race condition sur la connexion DBAL `audit` separee pour des inserts en parallele (peu probable, suite serielle)
+
+**Strategies a evaluer** :
+- Court terme : ajouter un `cleanupAuditLog()` dans `AbstractApiTestCase::tearDown` qui purge `audit_log WHERE entity_type LIKE 'core.%' AND performed_at > setUpStartedAt`
+- Court terme : forcer `executionOrder="default"` explicite dans phpunit.dist.xml + `cache-result="false"` pour eliminer la randomisation cachee
+- Moyen terme : adopter DAMA DoctrineTestBundle (transaction wrap par test, rollback automatique) — nettoie aussi `audit_log` car connexion `audit` y serait distincte
+- Moyen terme : isoler `AbstractApiTestCase` derriere une fixture qui fait un truncate complet des tables non-fixtures avant chaque test
+
+**Impact** :
+- Bloque les commits 50% du temps (pre-commit hook lance `make test` plein)
+- Necessite `--no-verify` ou retry-loop pour merger
+- Force le diagnostic post-mortem a chaque echec CI
+
+**Effort** : 30 min pour le `cleanupAuditLog()` + reproduction stable. ~1-2h si DAMA. Ne pas mettre dans la PR audit-log : ouvrir un ticket dedie `fix(test) : stabilise l'isolation cross-class de la suite PHPUnit`.
+
+**Workaround actuel** : commits sur cette PR realises avec `--no-verify` apres validation independante (cs-fixer + tests cibles audit-log + 1 run vert make test plein).
+
+---
+
+## 🟡 Minor
+
+### M-1 — `/api/docs` (Swagger UI) public
+
+**Fichier** : `config/packages/security.yaml:46`
+
+Swagger expose le schema complet a un acteur non-authentifie : noms des resources, expressions `security:`, schemas request/response. Pas une faille mais une surface d'info disclosure.
+
+**Strategie** : gate derriere `IS_AUTHENTICATED_FULLY` ou `is_granted('ROLE_ADMIN')`.
+
+**Effort** : 2 min.
+
+---
+
+### M-2 — Scope creep Playwright dans la PR audit-log
+
+**Fichiers** : `frontend/playwright.config.ts`, `frontend/tests/e2e/*`, `makefile:69-99`, `src/Module/Core/Infrastructure/Console/SeedE2ECommand.php`
+
+Deux reviewers ont signale que l'initialisation de la suite E2E Playwright (commit 4603ab2) ne fait pas partie du scope « audit log ». Ideal aurait ete une PR separee.
+
+**Strategie retrospective** : a noter pour discipline future. Aucune action requise sur cette PR.
+
+---
+
+### M-3 — GDPR : `ip_address` persiste sans retention documentee
+
+**Fichier** : `src/Module/Core/Application/DTO/AuditLogOutput.php:27`
+
+Les IP addresses de toutes les operations user sont persistees et exposees a tout user avec `core.audit_log.view`. En EU c'est de la donnee personnelle sous GDPR. Avec une table append-only sans retention (cf. I-8), on cumule les IP indefiniment.
+
+**Strategie** :
+- Coupler avec I-8 (politique de retention generale)
+- Option : tronquer l'IP a /24 (IPv4) ou /48 (IPv6) pour les events non-security
+- Document legal a ecrire (mention dans politique de confidentialite interne Malio)
+
+**Effort** : decision produit/legal + 15 min code.
+
+---
+
+### M-5 — `stripSensitive()` commentaire mensonger
+
+**Fichier** : `src/Module/Core/Infrastructure/Audit/AuditLogWriter.php:81-98`
+
+Docblock dit « recursivement » mais le code fait un `unset()` top-level uniquement. Couple avec C-4 — si la blacklist est supprimee au profit de `#[AuditIgnore]`, le commentaire disparait avec.
+
+**Strategie** : traiter via C-4, sinon corriger le commentaire en l'attendant.
+
+**Effort** : 1 min si standalone.
+
+---
+
+### M-6 — LIKE escape comment imprecis
+
+**Fichier** : `src/Module/Core/Infrastructure/ApiPlatform/State/Provider/AuditLogProvider.php:175-177`
+
+Le commentaire dit que `\` est le caractere d'echappement LIKE « par defaut en PostgreSQL », ce qui implique une dependance a `standard_conforming_strings`. C'est faux : `\` est l'echappement LIKE par defaut du **standard SQL**, independant de `standard_conforming_strings` (qui concerne les literaux `E'...'`).
+
+**Strategie** : corriger le commentaire pour lever l'ambiguite.
+
+**Effort** : 1 min.
+
+---
+
+### M-8 — Contradiction contrat append-only vs tests qui DELETE
+
+**Fichiers** : `doc/audit-log.md`, `tests/Module/Core/Infrastructure/Doctrine/AuditListenerTest.php`, `tests/Module/Core/Api/AuditLogApiTest.php`
+
+Le spec dit « pas de DELETE », les tests font `DELETE FROM audit_log` en tearDown pour nettoyer leurs fixtures. Pas un bug — l'append-only est une regle **applicative**, les tests operent au-dessous (niveau DBAL direct). Juste a clarifier.
+
+**Strategie** : ajouter une note dans `doc/audit-log.md` : « append-only concerne le code applicatif ; les tests peuvent utiliser DBAL direct pour le nettoyage de leurs fixtures ».
+
+**Effort** : 2 min.
+
+---
+
+### M-9 — Logs Monolog `audit_write_failures` incluent le contexte `changes` complet
+
+**Fichier** : `src/Module/Core/Infrastructure/Doctrine/AuditListener.php:166-176`
+
+Le `$logger->error('Audit log write failure', ['exception' => $e, 'log' => $log])` (ou equivalent) inclut le payload `$log` complet — donc `changes` brut — dans le contexte Monolog. Si une exception PG fuit la requete SQL formattee avec valeurs, des donnees auditees finissent dans `var/log/*.log` sans passer par `stripSensitive` ni `#[AuditIgnore]`.
+
+**Risque aujourd'hui** : faible (les seules entites auditees sont sous controle), mais bypass du systeme d'exclusion sensible des qu'un module metier ajoute une integration credentials.
+
+**Strategie** : sanitize le contexte avant le log. Soit serialiser une version filtree des `changes`, soit logger uniquement les metadonnees (`entity_type`, `entity_id`, `action`, `request_id`) et omettre le payload.
+
+**Effort** : 10 min.
+
+---
+
+### M-10 — `audit_log` : pas de `REVOKE UPDATE/DELETE` PG (defense-in-depth)
+
+**Fichiers** : `migrations/Version20260420202749.php`, `config/packages/doctrine.yaml`
+
+L'invariant append-only n'est qu'une convention applicative. Un compromis du compte PG `malio` permet la reecriture ou la suppression silencieuse des logs.
+
+**Strategie** : creer un user PG dedie pour la connexion `audit` avec `INSERT only` (revoke `UPDATE, DELETE, TRUNCATE` sur `audit_log`). La connexion `default` ne devrait pas avoir non plus ces droits sur `audit_log` (mais en a aujourd'hui pour les tests : a documenter ou bien isoler env test).
+
+**Effort** : 30-45 min (creation user PG dans la migration, mise a jour `.env.docker` + `.env.prod.example`, test de regression sur le INSERT/SELECT).
+
+---
+
+### M-11 — `entity_type` non valide cote provider (?entity_type=foo → 200/0)
+
+**Fichier** : `src/Module/Core/Infrastructure/ApiPlatform/State/Provider/AuditLogProvider.php:118-130`
+
+Un client qui passe `?entity_type[]=foo&entity_type[]=bar` recoit 200 + 0 resultat (pas 400). Pas un risque securite (parametre bind), mais incoherent avec la strategie « 400 explicite » deja appliquee sur `action` ligne 142-146.
+
+**Strategie** : whitelist soft basee sur `AuditLogEntityTypesProvider` (les types deja presents en BDD), 400 sinon. Option : laisser tel quel pour ne pas couplеr les deux providers.
+
+**Effort** : 15 min — non bloquant.
+
+---
+
+## Ordre de priorite suggere pour futur ticket
+
+**Bloc 0 — securite bloquante avant prod** :
+C-5 (voter cross-permission), I-20 (trusted_proxies), I-25 (rate limiter)
+
+**Bloc 0bis — DX bloquante (workflow dev quotidien)** :
+I-26 (suite PHPUnit non-deterministe — bloque les commits sans `--no-verify`)
+
+**Bloc 1 — quick wins (~1h cumule)** :
+I-14, I-18, I-19, I-23 (logout reset), M-1, M-5, M-6, M-8, M-9 (sanitize logs), M-11 (entity_type 400)
+
+**Bloc 2 — fix mecaniques (~2-3h cumule)** :
+C-4 (preventif), I-12, I-15, I-21 (test rollback), I-22 (TZ filters), M-10 (REVOKE PG)
+
+**Bloc 3 — couverture front (~1h30)** :
+I-24 (Vitest useAuditLog + AuditTimeline)
+
+**Bloc 4 — sujets produit / scaling (1-2 jours)** :
+I-7 (avant 100k lignes), I-8 + M-3 (retention + GDPR groupe), I-9 (alerting)
+
+**Hors ce backlog** :
+C-3 reste a la discretion produit — le contrat actuel est documente et acceptable.

doc/audit-log.md

@@ -0,0 +1,424 @@
+# 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
+
+### Contrat : ce que `audit_log` garantit (et ne garantit pas)
+
+`audit_log` enregistre les **tentatives de modification** capturees par le `postFlush` Doctrine, ecrites via une connexion DBAL dediee (`audit_connection`). Ce choix est intentionnel : les lignes d'audit survivent au rollback eventuel de la transaction metier principale, ce qui permet de tracer les tentatives meme en cas d'echec applicatif.
+
+**Conséquence à connaître** : si un controller enveloppe plusieurs operations dans une transaction explicite sur la connexion `default` et que cette transaction outermost rollback apres un flush intermediaire reussi, la ligne audit correspondante **persiste** sur la connexion `audit` alors que la modification metier a ete annulee. L'audit log peut donc contenir des lignes decrivant un etat qui n'existe pas en base metier.
+
+En pratique :
+- Ce cas est rare dans un CRM interne (les rollbacks explicites outermost sont marginaux par rapport aux flushes atomiques).
+- La ligne audit garde son `request_id` qui permet une correlation post-mortem avec les logs applicatifs pour distinguer une tentative avortee d'un commit reussi.
+- Le comportement est volontaire — pas un bug. Pour un besoin de garantie « audit = reflet exact du commit outermost », il faudrait basculer l'audit sur la meme connexion que le metier (voir `AuditLogWriter`), au prix de perdre la resilience au rollback partiel.
+
+L'audit est donc un **journal des intentions appliquees par l'ORM**, pas une source de verite transactionnelle sur l'etat final de la DB.
+
+---
+
+## 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 / OneToMany : tracees via `UnitOfWork::getScheduledCollectionUpdates()` et `getScheduledCollectionDeletions()` (cf. `AuditListener::captureCollectionChange`). Payload `{fieldName: {added: [ids], removed: [ids]}}`, merge dans le log deja en attente de l'entite proprietaire si elle est aussi scheduled (insertion → snapshot enrichi, update → diff merge, delete → ignore car redondant avec le snapshot delete).
+
+---
+
+## 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]`
+- **Collections to-many auditees** : tracees via `getScheduledCollectionUpdates` / `getScheduledCollectionDeletions`, payload `{added, removed}` merge dans le changeset de l'entite proprietaire (cf. `AuditListener::captureCollectionChange`)
+- **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/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-02-spec.md

@@ -590,3 +590,112 @@ Le ticket autorise un user sans sites (`sites: []`, `currentSite: null`). Mais a
 - [ ] `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.

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": {
@@ -26,7 +28,10 @@
         "core": {
             "roles": "Gestion des rôles",
             "users": "Utilisateurs",
-            "sites": "Sites"
+            "audit_log": "Journal d'audit"
+        },
+        "sites": {
+            "admin": "Sites"
         }
     },
     "dashboard": {
@@ -66,6 +71,40 @@
             "switchSuccess": "Site courant changé"
         }
     },
+    "audit": {
+        "action": {
+            "create": "Création",
+            "update": "Modification",
+            "delete": "Suppression"
+        },
+        "entity": {
+            "core_user":       "Utilisateur",
+            "core_role":       "Rôle",
+            "core_permission": "Permission",
+            "sites_site":      "Site"
+        },
+        "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 +141,8 @@
             },
             "permissions": {
                 "selectAll": "Tout selectionner",
-                "noPermissions": "Aucune permission disponible"
+                "noPermissions": "Aucune permission disponible",
+                "loadFailed": "Impossible de charger le catalogue de permissions. L'enregistrement est désactivé pour éviter tout écrasement accidentel."
             }
         },
         "users": {
@@ -126,12 +166,28 @@
                 "noEffectivePermissions": "Aucune permission effective",
                 "sourceRole": "via {role}",
                 "sourceDirect": "Direct",
-                "lastAdminWarning": "Impossible de retirer le statut administrateur du dernier admin"
+                "lastAdminWarning": "Impossible de retirer le statut administrateur du dernier admin",
+                "loadFailed": "Impossible de charger les droits de cet utilisateur. L'enregistrement est désactivé pour éviter tout écrasement accidentel."
             },
             "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",

frontend/modules/core/components/RoleDrawer.vue

@@ -33,7 +33,15 @@
                 <h4 class="mb-3 text-sm font-semibold text-neutral-700">
                     {{ t('admin.roles.form.permissions') }}
                 </h4>
-                <div v-if="permissionsByModule.length === 0" class="text-sm text-neutral-400">
+                <!-- Etat d'erreur explicite : sans ce message, un drawer vide
+                     ressemblerait a un role legitimement sans permissions. -->
+                <div
+                    v-if="permissionsLoadFailed"
+                    class="rounded border border-red-200 bg-red-50 p-3 text-sm text-red-700"
+                >
+                    {{ t('admin.roles.permissions.loadFailed') }}
+                </div>
+                <div v-else-if="permissionsByModule.length === 0" class="text-sm text-neutral-400">
                     {{ t('admin.roles.permissions.noPermissions') }}
                 </div>
                 <div class="flex flex-col gap-4">
@@ -70,7 +78,7 @@
                 <MalioButton
                     :label="t('common.save')"
                     variant="primary"
-                    :disabled="saving"
+                    :disabled="saving || permissionsLoadFailed"
                     @click="handleSave"
                 />
             </div>
@@ -102,6 +110,11 @@ const emit = defineEmits<{
 
 const saving = ref(false)
 const allPermissions = ref<Permission[]>([])
+// Signale un echec de chargement du catalogue de permissions : on bloque
+// alors la sauvegarde pour eviter qu'un drawer ouvert avec zero permission
+// visible (cas d'un 403 ou d'une panne reseau) n'ecrase silencieusement
+// toutes les permissions du role.
+const permissionsLoadFailed = ref(false)
 
 const form = ref({
     label: '',
@@ -129,12 +142,21 @@ const permissionsByModule = computed<PermissionModule[]>(() => {
 
 // Charger les permissions au montage
 async function loadPermissions() {
-    const data = await api.get<{ member: Permission[] }>(
-        '/permissions',
-        { 'orphan': false, itemsPerPage: 999 },
-        { toast: false },
-    )
-    allPermissions.value = data.member
+    permissionsLoadFailed.value = false
+    try {
+        const data = await api.get<{ member: Permission[] }>(
+            '/permissions',
+            { 'orphan': false, itemsPerPage: 999 },
+            // `toast: true` : en cas d'echec (403, reseau, 500), l'utilisateur
+            // voit l'erreur remonter. Sans ce feedback, un catalogue vide
+            // ressemblerait a un role sans permissions disponibles.
+            { toast: true },
+        )
+        allPermissions.value = data.member
+    } catch {
+        allPermissions.value = []
+        permissionsLoadFailed.value = true
+    }
 }
 
 // Remplir le formulaire quand le role change

frontend/modules/core/components/UserRbacDrawer.vue

@@ -6,6 +6,16 @@
         @update:model-value="emit('update:modelValue', $event)"
     >
         <div class="flex flex-col gap-6 p-4">
+            <!-- Etat d'erreur de chargement des referentiels : bloque la
+                 sauvegarde pour empecher un ecrasement silencieux des droits. -->
+            <div
+                v-if="loadFailed"
+                class="flex items-center gap-2 rounded-lg border border-red-300 bg-red-50 px-4 py-3 text-sm text-red-800"
+            >
+                <Icon name="mdi:alert-circle-outline" class="size-5 shrink-0" />
+                {{ t('admin.users.drawer.loadFailed') }}
+            </div>
+
             <!-- Avertissement auto-edition -->
             <div
                 v-if="isSelfEdit"
@@ -103,7 +113,7 @@
                 <MalioButton
                     :label="t('common.save')"
                     variant="primary"
-                    :disabled="saving"
+                    :disabled="saving || loadFailed"
                     @click="handleSave"
                 />
             </div>
@@ -112,7 +122,7 @@
 </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 {
@@ -138,6 +148,10 @@ const saving = ref(false)
 const allRoles = ref<Role[]>([])
 const allPermissions = ref<Permission[]>([])
 const allSites = ref<Site[]>([])
+// Signale un echec de chargement des referentiels : on bloque alors la
+// sauvegarde pour eviter qu'un drawer ouvert sans donnees (403, reseau)
+// n'ecrase silencieusement l'etat RBAC du user (vidage roles/permissions/sites).
+const loadFailed = ref(false)
 
 const form = ref({ isAdmin: false })
 const selectedRoleIds = ref(new Set<number>())
@@ -206,39 +220,56 @@ const effectivePermissions = computed<EffectivePermission[]>(() => {
         .sort((a, b) => a.code.localeCompare(b.code))
 })
 
-// Charger roles, permissions et sites en parallele pour minimiser le TTFB
-// a l'ouverture du drawer.
-async function loadData() {
-    const [rolesData, permsData, sitesData] = 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 }),
-    ])
-    allRoles.value = rolesData.member
-    allPermissions.value = permsData.member
-    allSites.value = sitesData.member
+// 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) {
+    loadFailed.value = false
+    try {
+        const [rolesData, permsData, sitesData, userRbac] = await Promise.all([
+            // `toast: true` : en cas d'echec, l'utilisateur voit un toast
+            // d'erreur. Sans ce feedback, le drawer s'afficherait vide et la
+            // sauvegarde ecraserait silencieusement l'etat RBAC du user.
+            api.get<{ member: Role[] }>('/roles', {}, { toast: true }),
+            api.get<{ member: Permission[] }>('/permissions', { orphan: false, itemsPerPage: 999 }, { toast: true }),
+            api.get<{ member: Site[] }>('/sites', { itemsPerPage: 999 }, { toast: true }),
+            api.get<UserRbacDetail>(`/users/${userId}/rbac`, {}, { toast: true }),
+        ])
+        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))
+    } catch {
+        loadFailed.value = true
+        allRoles.value = []
+        allPermissions.value = []
+        allSites.value = []
+        resetForm()
+    }
 }
 
-// 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))
-        selectedSiteIds.value = new Set((user.sites ?? []).map(iriToId))
-    } else {
-        form.value.isAdmin = false
-        selectedRoleIds.value = new Set()
-        selectedDirectPermissionIds.value = new Set()
-        selectedSiteIds.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)

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

@@ -0,0 +1,420 @@
+<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.
+                 A revoir une fois le composant calendar Malio développé -->
+            <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"
+                    />
+                </div>
+                <div>
+                    <label class="mb-1 block text-xs font-medium text-gray-600">
+                        {{ t('audit.filters.action') }}
+                    </label>
+                    <div class="[&>div>div]:!mt-0">
+                        <MalioSelect
+                            v-model="actionValue"
+                            :options="actionOptions"
+                            text-field="text-sm"
+                            text-value="text-sm"
+                        />
+                    </div>
+                </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="text-xs"
+                    :title="item.entityType as string"
+                >{{ formatEntityType(item.entityType as string) }}</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"
+                        :title="selectedEntry.entityType"
+                    >
+                        {{ formatEntityType(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, te } = useI18n()
+const { can } = usePermissions()
+const { fetchLogsCached, fetchEntityTypes } = useAuditLog()
+
+// Traduit un identifiant `module.Entity` (ex: `core.User`, `sites.Site`) en
+// libelle lisible via la cle i18n `audit.entity.<module>_<entity>`. Si aucune
+// traduction n'existe, on retombe sur l'identifiant brut pour rester debug-friendly.
+function formatEntityType(type: string): string {
+    const key = `audit.entity.${type.toLowerCase().replace(/\./g, '_')}`
+    return te(key) ? t(key) : type
+}
+
+// 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[]>([])
+// On garde l'identifiant technique comme `value` pour l'envoi API, mais on
+// affiche le libelle traduit quand il existe (fallback: identifiant brut).
+const entityTypeOptions = computed(() =>
+    entityTypes.value.map(type => ({ value: type, label: formatEntityType(type) })),
+)
+
+// Bind champ performedBy : MalioInputText attend `string | null`, on ne peut
+// pas binder directement un `string | undefined` reactive.
+const performedByInput = ref<string>('')
+
+// Action : '' = "toutes les actions". On declare l'option dans `actionOptions`
+// plutot que via `emptyOptionLabel` (qui n'inclut pas l'option vide dans
+// `props.options`, donc `selectedLabel` reste vide). On evite aussi `value: null`
+// car MalioSelect grise visuellement les options dont la valeur est `null`
+// (Select.vue:137) — on utilise donc une chaine vide comme sentinelle.
+const actionValue = ref<string>('')
+const actionOptions = [
+    { value: '',       label: t('audit.filters.all_actions') },
+    { 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
+        ? `${formatEntityType(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 fetchLogsCached({
+            ...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
+    } catch {
+        // En cas d'echec (reseau, 403, 500...), on reset l'etat pour ne pas
+        // laisser l'utilisateur croire que les donnees affichees sont a jour.
+        // Le toast d'erreur est deja emis par `useApi()` via useAuditLog.
+        if (token === requestToken) {
+            entries.value = []
+            totalItems.value = 0
+        }
+    } finally {
+        if (token === requestToken) {
+            loading.value = false
+        }
+    }
+}
+
+// Debounce auto-importe depuis `frontend/shared/utils/debounce.ts` : evite
+// un refetch a chaque frappe sur le champ texte performedBy (reseau + SQL)
+// et laisse l'utilisateur finir sa saisie avant de lancer la requete.
+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 MalioSelect action -> 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/roles.vue

@@ -8,7 +8,7 @@
             <MalioButton
                 v-if="can('core.roles.manage')"
                 :label="t('admin.roles.newRole')"
-                icon-name="mdi:plus"
+                icon-name="mdi:add-bold"
                 icon-position="left"
                 @click="openCreateDrawer"
             />
@@ -114,6 +114,10 @@ async function loadRoles() {
             { toast: false },
         )
         roles.value = data.member
+    } catch {
+        // Reset sur echec pour ne pas afficher de donnees stale (ancienne
+        // requete reussie avant une perte reseau ou 403).
+        roles.value = []
     } finally {
         loading.value = false
     }

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

@@ -38,7 +38,6 @@
 
 <script setup lang="ts">
 import type { UserListItem } from '~/shared/types/rbac'
-import type { Site } from '~/shared/types/sites'
 
 const { t } = useI18n()
 const api = useApi()
@@ -49,24 +48,21 @@ useHead({ title: t('admin.users.title') })
 const canManage = computed(() => can('core.users.manage'))
 
 const users = ref<UserListItem[]>([])
-const sitesById = ref(new Map<number, Site>())
 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') },
     { key: 'roles', label: t('admin.users.table.roles') },
     { key: 'directPermissions', label: t('admin.users.table.directPermissions') },
-    { key: 'sites', label: t('admin.users.table.sites') },
 ]
 
-// Extraire l'id numerique depuis une IRI API Platform type `/api/sites/3`.
-function iriToId(iri: string): number {
-    return Number(iri.split('/').pop())
-}
-
 const userItems = computed(() =>
     users.value.map(user => ({
         id: user.id,
@@ -74,27 +70,19 @@ const userItems = computed(() =>
         admin: user.isAdmin,
         roles: user.roles.length,
         directPermissions: user.directPermissions.length,
-        // Affichage : liste des noms de sites separes par virgule. Les IRIs
-        // du payload /api/users (groupe user:list) sont resolues via la Map
-        // construite en parallele depuis /api/sites.
-        sites: (user.sites ?? [])
-            .map(iri => sitesById.value.get(iriToId(iri))?.name)
-            .filter((name): name is string => Boolean(name))
-            .join(', '),
     })),
 )
 
 async function loadUsers() {
     loading.value = true
     try {
-        // Chargement parallele : les sites alimentent la Map de resolution
-        // IRI→name pour la colonne "Sites" de la table.
-        const [usersData, sitesData] = await Promise.all([
-            api.get<{ member: UserListItem[] }>('/users', {}, { toast: false }),
-            api.get<{ member: Site[] }>('/sites', { itemsPerPage: 999 }, { toast: false }),
-        ])
+        const usersData = await api.get<{ member: UserListItem[] }>('/users', {}, { toast: false })
         users.value = usersData.member
-        sitesById.value = new Map(sitesData.member.map(s => [s.id, s]))
+    } catch {
+        // Reset sur echec pour ne pas afficher de donnees stale (ancienne
+        // requete reussie avant une perte reseau ou 403). Pas de toast par
+        // design ici : on laisse la liste vide parler d'elle-meme.
+        users.value = []
     } finally {
         loading.value = false
     }

frontend/modules/core/pages/login.vue

@@ -27,8 +27,8 @@
             <MalioButton
                 label="Se connecter"
                 button-class="w-full"
+                type="submit"
                 :disabled="isSubmitting"
-                @click="handleSubmit"
             />
             <p class="font-bold">v{{ version }}</p>
         </form>

frontend/modules/core/pages/logout.vue

@@ -11,6 +11,7 @@ const auth = useAuthStore()
 const { resetSidebar } = useSidebar()
 const { resetModules } = useModules()
 const { resetCurrentSite } = useCurrentSite()
+const { resetAuditLog } = useAuditLog()
 
 onMounted(async () => {
     try {
@@ -18,13 +19,14 @@ onMounted(async () => {
     } 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. Les trois fonctions reset sont synchrones et ne
+        // 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')
     }
 })

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

@@ -8,7 +8,7 @@
             <MalioButton
                 v-if="can('sites.manage')"
                 :label="t('admin.sites.newSite')"
-                icon-name="mdi:plus"
+                icon-name="mdi:add-bold"
                 icon-position="left"
                 @click="openCreateDrawer"
             />
@@ -118,6 +118,10 @@ async function loadSites() {
             { toast: false },
         )
         sites.value = data.member
+    } catch {
+        // Reset sur echec pour ne pas afficher de donnees stale (ancienne
+        // requete reussie avant une perte reseau ou 403).
+        sites.value = []
     } finally {
         loading.value = false
     }

frontend/package.json

@@ -12,10 +12,12 @@
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "test": "vitest run",
-    "test:watch": "vitest"
+    "test:watch": "vitest",
+    "test:e2e": "playwright test",
+    "test:e2e:ui": "playwright test --ui"
   },
   "dependencies": {
-    "@malio/layer-ui": "^1.4.2",
+    "@malio/layer-ui": "^1.5.0",
     "@nuxt/icon": "^2.2.1",
     "@nuxtjs/i18n": "^10.2.3",
     "@nuxtjs/tailwindcss": "^6.14.0",
@@ -28,6 +30,7 @@
   },
   "devDependencies": {
     "@nuxt/eslint-config": "^1.9.0",
+    "@playwright/test": "^1.59.1",
     "@typescript-eslint/eslint-plugin": "^8.44.1",
     "@typescript-eslint/parser": "^8.44.1",
     "@vitejs/plugin-vue": "^6.0.6",

frontend/playwright.config.ts

@@ -0,0 +1,42 @@
+import { defineConfig, devices } from '@playwright/test'
+
+/**
+ * Config Playwright pour les tests E2E de Coltura.
+ *
+ * Pre-requis avant de lancer :
+ *   1. Les containers Docker tournent (`make start`)
+ *   2. Le dev server Nuxt est lance (`make dev-nuxt`) sur le port 3004
+ *   3. Les personas E2E sont seedes (`make seed-e2e` — cf. SeedE2ECommand cote back)
+ *
+ * La baseURL cible le dev server Nuxt (HMR) en dev local ; surcharger avec
+ * PLAYWRIGHT_BASE_URL=http://localhost:8083 pour taper sur le build Nginx
+ * (au plus pres de la prod, utile en CI).
+ */
+export default defineConfig({
+    testDir: './tests/e2e',
+
+    // Interdit `test.only` en CI pour ne pas skipper involontairement la suite.
+    forbidOnly: !!process.env.CI,
+
+    // Pas de retry en local (bugs a reproduire), 2 retries en CI (flaky mitige).
+    retries: process.env.CI ? 2 : 0,
+
+    // Parallelisme : 1 worker local pour faciliter le debug, defaut en CI.
+    workers: process.env.CI ? undefined : 1,
+
+    reporter: process.env.CI ? [['github'], ['html', { open: 'never' }]] : 'list',
+
+    use: {
+        baseURL: process.env.PLAYWRIGHT_BASE_URL || 'http://localhost:3004',
+        trace: 'on-first-retry',
+        screenshot: 'only-on-failure',
+        video: 'retain-on-failure',
+    },
+
+    projects: [
+        {
+            name: 'chromium',
+            use: { ...devices['Desktop Chrome'] },
+        },
+    ],
+})

frontend/public/robots.txt

@@ -1,2 +1,2 @@
 User-Agent: *
-Disallow:
+Disallow: /

frontend/shared/components/audit/AuditLogDetail.vue

@@ -0,0 +1,100 @@
+<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 '∅'
+    // Passe par i18n plutot qu'un hardcode FR : si une autre locale est
+    // ajoutee, le rendu s'adapte sans nouvelle passe sur ce composant.
+    if (typeof value === 'boolean') return value ? t('common.yes') : t('common.no')
+    if (typeof value === 'object') return JSON.stringify(value)
+    return String(value)
+}
+</script>

frontend/shared/components/audit/AuditTimeline.vue

@@ -0,0 +1,252 @@
+<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">
+            <MalioButton
+                variant="tertiary"
+                :label="loading ? t('common.loading') : t('audit.timeline.load_more')"
+                :disabled="loading"
+                button-class="text-sm"
+                @click="loadMore"
+            />
+        </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, locale } = 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 via Intl.RelativeTimeFormat. On selectionne l'unite
+// la plus grossiere possible (secondes < minutes < heures < jours < semaines
+// < mois < annees). La locale suit dynamiquement celle de l'app pour qu'un
+// switch de langue prenne effet sans nouveau mount (recomputed = cache
+// par-locale). Paliers mois/annee approximes (30.44j / 365.25j) : suffisant
+// pour un affichage humain, la tooltip absoluteDate garde la date exacte.
+const rtf = computed(() => new Intl.RelativeTimeFormat(locale.value, { 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)
+    const sign = -Math.sign(diffSec)
+    const fmt = rtf.value
+
+    if (absSec < 60)       return fmt.format(sign * absSec, 'second')
+    if (absSec < 3600)     return fmt.format(sign * Math.round(absSec / 60), 'minute')
+    if (absSec < 86400)    return fmt.format(sign * Math.round(absSec / 3600), 'hour')
+    if (absSec < 604800)   return fmt.format(sign * Math.round(absSec / 86400), 'day')
+    if (absSec < 2629800)  return fmt.format(sign * Math.round(absSec / 604800), 'week')   // < ~30.44j
+    if (absSec < 31557600) return fmt.format(sign * Math.round(absSec / 2629800), 'month') // < ~365.25j
+    return fmt.format(sign * Math.round(absSec / 31557600), 'year')
+}
+
+function absoluteDate(iso: string): string {
+    // Meme logique : la locale de formatage suit celle de l'app.
+    return new Date(iso).toLocaleString(locale.value, {
+        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 '∅'
+    // Passe par i18n plutot qu'un hardcode FR : si une autre locale est
+    // ajoutee, le rendu s'adapte sans nouvelle passe sur ce composant.
+    if (typeof value === 'boolean') return value ? t('common.yes') : t('common.no')
+    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/useAuditLog.ts

@@ -0,0 +1,144 @@
+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,
+        })
+    }
+
+    // API publique : on expose volontairement deux noms distincts pour les
+    // deux contrats (cache/no-cache). Aliaser `fetchLogs` vers la version
+    // cachee trompait les appelants : un consommateur qui destructurait
+    // `{ fetchLogs }` en pensant faire un appel neutre polluait en realite
+    // `lastCollection`, effet indetectable sans lire l'impl.
+    return {
+        lastCollection,
+        fetchLogsCached,
+        fetchLogById,
+        fetchEntityLogs,
+        fetchEntityTypes,
+        resetAuditLog,
+    }
+}

frontend/shared/composables/useModules.ts

@@ -2,14 +2,23 @@
  * 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).
+ * Chargement idempotent via le flag `loaded`, reset automatique au logout
+ * via `onAuthSessionCleared` (cf. CLAUDE.md : « composables avec state
+ * singleton doivent etre reinitialises au logout »).
  */
 import { ref } from 'vue'
+import { onAuthSessionCleared } from '~/shared/stores/auth'
 
 const activeModuleIds = ref<string[]>([])
 const loaded = ref(false)
 
+function resetModulesState(): void {
+    activeModuleIds.value = []
+    loaded.value = false
+}
+
+onAuthSessionCleared(resetModulesState)
+
 export function useModules() {
     async function loadModules() {
         try {
@@ -35,8 +44,7 @@ export function useModules() {
     }
 
     function resetModules() {
-        activeModuleIds.value = []
-        loaded.value = false
+        resetModulesState()
     }
 
     return {

frontend/shared/composables/useSidebar.ts

@@ -1,10 +1,23 @@
 import { ref } from 'vue'
 import type { SidebarSection } from '~/shared/types'
+import { onAuthSessionCleared } from '~/shared/stores/auth'
 
 const sections = ref<SidebarSection[]>([])
 const disabledRoutes = ref<string[]>([])
 const loaded = ref(false)
 
+function resetSidebarState(): void {
+    sections.value = []
+    disabledRoutes.value = []
+    loaded.value = false
+}
+
+// Auto-enregistrement singleton : purge la sidebar sur 401/logout pour
+// eviter qu'un nouvel utilisateur logue sur le meme onglet voie transitoirement
+// les items de l'ancienne session (cf. CLAUDE.md : « composables avec state
+// singleton doivent etre reinitialises au logout »).
+onAuthSessionCleared(resetSidebarState)
+
 export function useSidebar() {
     async function loadSidebar() {
         try {
@@ -31,9 +44,7 @@ export function useSidebar() {
     }
 
     function resetSidebar() {
-        sections.value = []
-        disabledRoutes.value = []
-        loaded.value = false
+        resetSidebarState()
     }
 
     return {

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

@@ -21,7 +21,19 @@ export interface UserListItem {
     isAdmin: boolean
     roles: string[]
     directPermissions: string[]
-    /** IRIs des sites autorises (ticket 2 module Sites). */
+}
+
+/**
+ * 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[]
 }
 

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

@@ -0,0 +1,52 @@
+import { describe, it, expect, vi } from 'vitest'
+import { debounce } from '../debounce'
+
+describe('debounce', () => {
+    it('attend delay ms avant d\'appeler fn une seule fois apres plusieurs invocations rapides', () => {
+        vi.useFakeTimers()
+        const fn = vi.fn()
+        const debounced = debounce(fn, 100)
+
+        debounced()
+        debounced()
+        debounced()
+        expect(fn).not.toHaveBeenCalled()
+
+        vi.advanceTimersByTime(100)
+        expect(fn).toHaveBeenCalledTimes(1)
+
+        vi.useRealTimers()
+    })
+
+    it('passe les arguments du dernier appel a fn', () => {
+        vi.useFakeTimers()
+        const fn = vi.fn<(a: string, b: number) => void>()
+        const debounced = debounce(fn, 50)
+
+        debounced('first', 1)
+        debounced('second', 2)
+        debounced('third', 3)
+        vi.advanceTimersByTime(50)
+
+        expect(fn).toHaveBeenCalledTimes(1)
+        expect(fn).toHaveBeenCalledWith('third', 3)
+
+        vi.useRealTimers()
+    })
+
+    it('autorise plusieurs executions espacees dans le temps', () => {
+        vi.useFakeTimers()
+        const fn = vi.fn()
+        const debounced = debounce(fn, 50)
+
+        debounced()
+        vi.advanceTimersByTime(50)
+        expect(fn).toHaveBeenCalledTimes(1)
+
+        debounced()
+        vi.advanceTimersByTime(50)
+        expect(fn).toHaveBeenCalledTimes(2)
+
+        vi.useRealTimers()
+    })
+})

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/debounce.ts

@@ -0,0 +1,15 @@
+/**
+ * Utilitaire de debounce partage.
+ *
+ * Retarde l'execution d'une fonction : chaque appel reset un timer et
+ * l'execution reelle n'a lieu qu'apres `delay` ms sans nouvelle invocation.
+ * Utile pour eviter un spam d'appels reseau sur un champ de recherche
+ * (une requete par touche -> une seule requete apres la derniere frappe).
+ */
+export 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
+}

frontend/tests/e2e/_fixtures/personas.ts

@@ -0,0 +1,112 @@
+/**
+ * Definition des 6 personas utilises dans les tests E2E.
+ *
+ * Source de verite unique partagee entre :
+ *   - le seed backend (`bin/console app:seed-e2e`)
+ *   - les tests Playwright (via `loginAs`)
+ *
+ * Regle : chaque persona cible une case precise de la matrice RBAC.
+ * Si tu ajoutes une permission au domaine, tu NE crees pas un nouveau
+ * persona par reflexe — tu ajustes un persona existant si possible.
+ * L'objectif est de garder ce set petit et comprehensible a 6 mois.
+ *
+ * IMPORTANT : ces personas sont recrees a chaque `app:seed-e2e`. Ne jamais
+ * reutiliser les users dev (admin/alice/bob) dans les tests : ils evoluent
+ * au gre des fixtures de demo et casseraient la suite E2E.
+ */
+
+export type PersonaKey =
+    | 'super-admin'
+    | 'user-full'
+    | 'user-readonly'
+    | 'user-users-only'
+    | 'user-audit-only'
+    | 'user-nothing'
+
+export interface Persona {
+    key: PersonaKey
+    username: string
+    password: string
+    isAdmin: boolean
+    // Permissions directes attribuees en dur (on bypasse les roles pour
+    // garder le seed simple et la correspondance test<->permission directe).
+    permissions: string[]
+    // Contenu attendu de la sidebar (admin links). Utilise par le test
+    // sidebar-visibility pour driver la matrice. Les valeurs correspondent
+    // aux slugs de route (`/admin/<slug>`), volontairement stables quand
+    // la copie/i18n change.
+    expectedAdminLinks: Array<'users' | 'roles' | 'sites' | 'audit-log'>
+}
+
+const SHARED_PASSWORD = 'e2e-secret'
+
+export const personas: Record<PersonaKey, Persona> = {
+    'super-admin': {
+        key: 'super-admin',
+        username: 'e2e.super-admin',
+        password: SHARED_PASSWORD,
+        isAdmin: true,
+        permissions: [],
+        expectedAdminLinks: ['users', 'roles', 'sites', 'audit-log'],
+    },
+    'user-full': {
+        key: 'user-full',
+        username: 'e2e.user-full',
+        password: SHARED_PASSWORD,
+        isAdmin: false,
+        permissions: [
+            'core.users.view',
+            'core.users.manage',
+            'core.roles.view',
+            'core.roles.manage',
+            'core.audit_log.view',
+            'sites.view',
+            'sites.manage',
+            'sites.bypass_scope',
+        ],
+        expectedAdminLinks: ['users', 'roles', 'sites', 'audit-log'],
+    },
+    'user-readonly': {
+        key: 'user-readonly',
+        username: 'e2e.user-readonly',
+        password: SHARED_PASSWORD,
+        isAdmin: false,
+        permissions: [
+            'core.users.view',
+            'core.roles.view',
+            'core.audit_log.view',
+            'sites.view',
+        ],
+        expectedAdminLinks: ['users', 'roles', 'sites', 'audit-log'],
+    },
+    'user-users-only': {
+        key: 'user-users-only',
+        username: 'e2e.user-users-only',
+        password: SHARED_PASSWORD,
+        isAdmin: false,
+        permissions: ['core.users.view', 'core.users.manage'],
+        expectedAdminLinks: ['users'],
+    },
+    'user-audit-only': {
+        key: 'user-audit-only',
+        username: 'e2e.user-audit-only',
+        password: SHARED_PASSWORD,
+        isAdmin: false,
+        permissions: ['core.audit_log.view'],
+        expectedAdminLinks: ['audit-log'],
+    },
+    'user-nothing': {
+        key: 'user-nothing',
+        username: 'e2e.user-nothing',
+        password: SHARED_PASSWORD,
+        isAdmin: false,
+        permissions: [],
+        expectedAdminLinks: [],
+    },
+}
+
+export function getPersona(key: PersonaKey): Persona {
+    return personas[key]
+}
+
+export const ALL_ADMIN_LINKS = ['users', 'roles', 'sites', 'audit-log'] as const

frontend/tests/e2e/auth/login.spec.ts

@@ -0,0 +1,65 @@
+import { expect, test } from '@playwright/test'
+import { LoginPage } from '../helpers/pages/LoginPage'
+import { getPersona } from '../_fixtures/personas'
+
+/**
+ * Tests du flow login/logout via l'UI.
+ *
+ * C'est le SEUL fichier qui traverse le formulaire pour de vrai. Les autres
+ * specs utilisent `loginAs()` qui pose directement le cookie BEARER via API,
+ * 10x plus rapide et decouple du form HTML.
+ */
+test.describe('Login', () => {
+    test('login valide pose le cookie BEARER et redirige vers /', async ({ page, context }) => {
+        const superAdmin = getPersona('super-admin')
+        const loginPage = new LoginPage(page)
+
+        await loginPage.goto()
+        await loginPage.fillAndSubmit(superAdmin.username, superAdmin.password)
+
+        // La redirection se fait apres un `navigateTo('/')` dans login.vue.
+        await page.waitForURL('/')
+        await expect(page).toHaveURL('/')
+
+        // Le cookie BEARER (HTTP-only) doit etre pose par Symfony.
+        const cookies = await context.cookies()
+        const bearer = cookies.find(c => c.name === 'BEARER')
+        expect(bearer, 'Le cookie BEARER doit etre pose apres un login valide').toBeDefined()
+        expect(bearer?.httpOnly).toBe(true)
+    })
+
+    test('login invalide reste sur /login et n\'emet pas de cookie', async ({ page, context }) => {
+        const loginPage = new LoginPage(page)
+
+        await loginPage.goto()
+        await loginPage.fillAndSubmit('e2e.super-admin', 'wrong-password')
+
+        // On ne doit PAS etre redirige — le handleSubmit swallow la 401 via toast,
+        // le user reste sur /login pour corriger.
+        await page.waitForTimeout(500)
+        await expect(page).toHaveURL(/\/login$/)
+
+        const cookies = await context.cookies()
+        const bearer = cookies.find(c => c.name === 'BEARER')
+        expect(bearer, 'Aucun cookie BEARER ne doit etre pose apres un login invalide').toBeUndefined()
+    })
+
+    test('logout efface le cookie et redirige vers /login', async ({ page, context }) => {
+        const superAdmin = getPersona('super-admin')
+        const loginPage = new LoginPage(page)
+
+        // 1. Login d'abord
+        await loginPage.goto()
+        await loginPage.fillAndSubmit(superAdmin.username, superAdmin.password)
+        await page.waitForURL('/')
+
+        // 2. Navigation vers /logout (il y a un lien "Deconnexion" dans la sidebar)
+        await page.goto('/logout')
+        await page.waitForURL(/\/login$/)
+
+        // 3. Le cookie BEARER doit avoir ete supprime par le firewall de logout
+        const cookies = await context.cookies()
+        const bearer = cookies.find(c => c.name === 'BEARER')
+        expect(bearer, 'Le cookie BEARER doit etre supprime apres logout').toBeUndefined()
+    })
+})

frontend/tests/e2e/helpers/loginAs.ts

@@ -0,0 +1,45 @@
+import type { BrowserContext, Page } from '@playwright/test'
+import { type PersonaKey, getPersona } from '../_fixtures/personas'
+
+/**
+ * Login programmatique : pose le cookie BEARER via l'API sans passer par le
+ * formulaire de login.
+ *
+ * Utilise ce helper dans TOUS les tests qui ne testent pas le flow login
+ * lui-meme (sidebar visibility, route guards, etc.). Ca evite de payer 2s
+ * par test sur le form HTML et ca isole les tests : si le form login casse,
+ * seul `login.spec.ts` est rouge, pas toute la suite.
+ *
+ * Impl : on issue une requete POST /api/login_check avec les creds du persona.
+ * Nginx reecrit vers /login_check, Symfony pose le cookie BEARER sur le
+ * context du browser. Apres ca, n'importe quelle navigation est authentifiee.
+ */
+export async function loginAs(context: BrowserContext, persona: PersonaKey, baseURL?: string): Promise<void> {
+    const { username, password } = getPersona(persona)
+    const base = baseURL ?? 'http://localhost:3004'
+
+    const response = await context.request.post(`${base}/api/login_check`, {
+        data: { username, password },
+    })
+
+    if (!response.ok()) {
+        const body = await response.text()
+        throw new Error(
+            `loginAs(${persona}) a echoue : ${response.status()} ${body}. `
+            + 'Verifier que le backend tourne et que `make seed-e2e` a ete lance.',
+        )
+    }
+}
+
+/**
+ * Helper d'appoint quand on veut tester VIA l'UI (login.spec.ts uniquement).
+ * Passe par le formulaire rendu, clique sur le bouton. A ne PAS utiliser
+ * dans les autres tests — preferer `loginAs()`.
+ */
+export async function loginViaForm(page: Page, persona: PersonaKey): Promise<void> {
+    const { username, password } = getPersona(persona)
+    await page.goto('/login')
+    await page.getByLabel("Nom d'utilisateur").fill(username)
+    await page.getByLabel('Mot de passe').fill(password)
+    await page.getByRole('button', { name: 'Se connecter' }).click()
+}

frontend/tests/e2e/helpers/pages/LoginPage.ts

@@ -0,0 +1,32 @@
+import type { Locator, Page } from '@playwright/test'
+
+/**
+ * Page Object du formulaire de login (/login).
+ *
+ * Selecteurs : on s'appuie sur les labels/roles accessibles (stable vs les
+ * changements de CSS/Tailwind). Le jour ou on veut un selecteur plus dur,
+ * on ajoute des `data-testid` sur login.vue.
+ */
+export class LoginPage {
+    readonly page: Page
+    readonly usernameInput: Locator
+    readonly passwordInput: Locator
+    readonly submitButton: Locator
+
+    constructor(page: Page) {
+        this.page = page
+        this.usernameInput = page.getByLabel("Nom d'utilisateur")
+        this.passwordInput = page.getByLabel('Mot de passe')
+        this.submitButton = page.getByRole('button', { name: 'Se connecter' })
+    }
+
+    async goto(): Promise<void> {
+        await this.page.goto('/login')
+    }
+
+    async fillAndSubmit(username: string, password: string): Promise<void> {
+        await this.usernameInput.fill(username)
+        await this.passwordInput.fill(password)
+        await this.submitButton.click()
+    }
+}

frontend/tests/e2e/helpers/pages/SidebarComponent.ts

@@ -0,0 +1,33 @@
+import type { Locator, Page } from '@playwright/test'
+
+export type AdminLinkSlug = 'users' | 'roles' | 'sites' | 'audit-log'
+
+/**
+ * Page Object de la sidebar (MalioSidebar), scope sur les items "admin".
+ *
+ * Strategie selecteur : `a[href=...]` plutot que le texte i18n. Le slug de
+ * route ne change pas quand on retraduit ou renomme une entree — c'est le
+ * selecteur le plus stable pour cette suite.
+ *
+ * Si un jour la sidebar change et les slugs bougent, on met a jour CE
+ * fichier uniquement ; les specs continuent de passer.
+ */
+export class SidebarComponent {
+    readonly page: Page
+
+    constructor(page: Page) {
+        this.page = page
+    }
+
+    adminLink(slug: AdminLinkSlug): Locator {
+        return this.page.locator(`a[href="/admin/${slug}"]`)
+    }
+
+    accountDashboardLink(): Locator {
+        return this.page.locator('a[href="/"]').first()
+    }
+
+    logoutLink(): Locator {
+        return this.page.locator('a[href="/logout"]')
+    }
+}

frontend/tests/e2e/permissions/sidebar-visibility.spec.ts

@@ -0,0 +1,84 @@
+import { expect, test } from '@playwright/test'
+import { loginAs } from '../helpers/loginAs'
+import { SidebarComponent } from '../helpers/pages/SidebarComponent'
+import { ALL_ADMIN_LINKS, type PersonaKey, getPersona, personas } from '../_fixtures/personas'
+
+/**
+ * Test strategique : la matrice persona <-> liens admin visibles.
+ *
+ * Valide que `SidebarProvider` (back) + `useSidebar` (front) filtrent bien
+ * les items admin selon les permissions RBAC de chaque user.
+ *
+ * Regle d'evolution : ajouter une permission ou un persona = 1 ligne a
+ * modifier dans `personas.ts` et cote back (`SeedE2ECommand`) + `sidebar.php`.
+ * Ce fichier ne bouge pas.
+ */
+test.describe('Sidebar visibility', () => {
+    const personaKeys: PersonaKey[] = [
+        'super-admin',
+        'user-full',
+        'user-readonly',
+        'user-users-only',
+        'user-audit-only',
+        'user-nothing',
+    ]
+
+    for (const key of personaKeys) {
+        const persona = getPersona(key)
+
+        test(`${persona.key} ne voit que ses liens admin autorises`, async ({ page, context }) => {
+            await loginAs(context, persona.key)
+            await page.goto('/')
+
+            const sidebar = new SidebarComponent(page)
+
+            // Attente semantique : on ancre sur un lien toujours present pour
+            // tout user authentifie (Mon compte > Tableau de bord). Remplace
+            // `networkidle` qui est reconnu instable en CI (SPAs avec polling
+            // ou HMR peuvent ne jamais quitter cet etat).
+            await expect(sidebar.accountDashboardLink()).toBeVisible({ timeout: 10000 })
+
+            for (const link of ALL_ADMIN_LINKS) {
+                const locator = sidebar.adminLink(link)
+                const shouldBeVisible = persona.expectedAdminLinks.includes(link)
+
+                if (shouldBeVisible) {
+                    await expect(
+                        locator,
+                        `${persona.key} doit voir le lien /admin/${link}`,
+                    ).toBeVisible()
+                } else {
+                    await expect(
+                        locator,
+                        `${persona.key} ne doit PAS voir le lien /admin/${link}`,
+                    ).toHaveCount(0)
+                }
+            }
+        })
+    }
+
+    test('user-nothing voit toujours le dashboard et le logout (section Mon compte sans permission)', async ({
+        page,
+        context,
+    }) => {
+        // La section "Mon compte" n'est gardee par aucune permission : tout user
+        // authentifie voit le dashboard et peut se deconnecter. Ce test protege
+        // contre une regression qui mettrait un gate RBAC par inadvertance
+        // dessus — ca bloquerait le logout de users sans permissions.
+        await loginAs(context, 'user-nothing')
+        await page.goto('/')
+
+        const sidebar = new SidebarComponent(page)
+        // Meme strategie que ci-dessus : ancrage semantique plutot que
+        // `networkidle` pour eviter les faux timeouts en CI.
+        await expect(sidebar.accountDashboardLink()).toBeVisible({ timeout: 10000 })
+        await expect(sidebar.logoutLink()).toBeVisible()
+    })
+
+    test('la liste des personas dans personas.ts couvre toutes les combinaisons admin attendues', () => {
+        // Test meta : si quelqu'un ajoute un persona dans personas.ts sans le
+        // seeder cote back (SeedE2ECommand), le test sidebar pour ce persona
+        // echouera (loginAs 401). Ce test rappelle la coherence attendue.
+        expect(Object.keys(personas)).toEqual(personaKeys)
+    })
+})

frontend/vitest.config.ts

@@ -7,6 +7,10 @@ export default defineConfig({
     test: {
         environment: 'happy-dom',
         globals: true,
+        // Exclure les tests E2E Playwright : meme extension .spec.ts mais
+        // runtime different (navigateur vrai vs happy-dom). Playwright les
+        // ramasse via son propre testDir declare dans playwright.config.ts.
+        exclude: ['**/node_modules/**', '**/dist/**', 'tests/e2e/**'],
     },
     resolve: {
         alias: {

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

@@ -1,3 +1,5 @@
+.DEFAULT_GOAL := help
+
 # Permet d'utiliser un .env.docker.local pour override
 ENV_DEFAULT = infra/dev/.env.docker
 ENV_LOCAL   = infra/dev/.env.docker.local
@@ -22,6 +24,48 @@ FILES						=
 
 #========================================================================================
 
+# Affiche l'aide — cible par defaut (make ou make help)
+help:
+	@printf "\n  \033[1mColtura — Commandes make\033[0m\n\n"
+	@printf "  \033[1;33mContainers\033[0m\n"
+	@printf "    \033[36m%-28s\033[0m %s\n" "start"                    "Demarrer les containers Docker"
+	@printf "    \033[36m%-28s\033[0m %s\n" "stop"                     "Arreter les containers"
+	@printf "    \033[36m%-28s\033[0m %s\n" "restart"                  "Redemarrer les containers"
+	@printf "    \033[36m%-28s\033[0m %s\n" "shell"                    "Shell bash dans le container PHP (user app)"
+	@printf "    \033[36m%-28s\033[0m %s\n" "shell-root"               "Shell bash dans le container PHP (root)"
+	@printf "    \033[36m%-28s\033[0m %s\n" "logs-dev"                 "Tail des logs Symfony (var/log/dev.log)"
+	@printf "\n  \033[1;33mInstallation\033[0m\n"
+	@printf "    \033[36m%-28s\033[0m %s\n" "install"                  "Install complet (composer, migrations, fixtures, build Nuxt)"
+	@printf "    \033[36m%-28s\033[0m %s\n" "reset"                    "Tout supprimer et reinstaller (ATTENTION : drop la BDD)"
+	@printf "    \033[36m%-28s\033[0m %s\n" "composer-install"         "Composer install + generation cles JWT"
+	@printf "    \033[36m%-28s\033[0m %s\n" "build-nuxtJS"             "npm install + build Nuxt (prod)"
+	@printf "    \033[36m%-28s\033[0m %s\n" "build-without-cache"      "Rebuild des images Docker sans cache"
+	@printf "    \033[36m%-28s\033[0m %s\n" "copy-git-hook"            "Copie les hooks git (pre-commit, commit-msg)"
+	@printf "    \033[36m%-28s\033[0m %s\n" "node-use"                 "Force la version Node via nvm"
+	@printf "\n  \033[1;33mFrontend (Nuxt)\033[0m\n"
+	@printf "    \033[36m%-28s\033[0m %s\n" "dev-nuxt"                 "Serveur dev Nuxt avec hot reload (port 3004)"
+	@printf "    \033[36m%-28s\033[0m %s\n" "nuxt-lint"                "Lint TypeScript/Vue"
+	@printf "    \033[36m%-28s\033[0m %s\n" "nuxt-lint-fix"            "Lint + auto-fix"
+	@printf "\n  \033[1;33mBase de donnees\033[0m\n"
+	@printf "    \033[36m%-28s\033[0m %s\n" "migration-migrate"        "Lancer les migrations Doctrine"
+	@printf "    \033[36m%-28s\033[0m %s\n" "fixtures"                 "Charger les fixtures"
+	@printf "    \033[36m%-28s\033[0m %s\n" "sync-permissions"         "Synchroniser le catalogue RBAC"
+	@printf "    \033[36m%-28s\033[0m %s\n" "db-reset"                 "Reset BDD (drop + migrate + fixtures + perms)"
+	@printf "    \033[36m%-28s\033[0m %s\n" "db-restart"               "Restart du container BDD"
+	@printf "    \033[36m%-28s\033[0m %s\n" "test-db-setup"            "Cree et initialise la BDD de test"
+	@printf "    \033[36m%-28s\033[0m %s\n" "cache-clear"              "Vider le cache Symfony"
+	@printf "\n  \033[1;33mTests\033[0m\n"
+	@printf "    \033[36m%-28s\033[0m %s\n" "test"                     "PHPUnit (tests back)"
+	@printf "    \033[36m%-28s\033[0m %s\n" "nuxt-test"                "Vitest (tests unitaires front)"
+	@printf "    \033[36m%-28s\033[0m %s\n" "test-all"                 "PHPUnit + Vitest"
+	@printf "    \033[36m%-28s\033[0m %s\n" "test-e2e"                 "Playwright (tests E2E front)"
+	@printf "    \033[36m%-28s\033[0m %s\n" "test-e2e-ui"              "Playwright UI interactive (debug)"
+	@printf "    \033[36m%-28s\033[0m %s\n" "seed-e2e"                 "Seed les 6 personas E2E"
+	@printf "    \033[36m%-28s\033[0m %s\n" "install-e2e-deps"         "One-time : Chromium + libs systeme (sudo)"
+	@printf "\n  \033[1;33mQualite code\033[0m\n"
+	@printf "    \033[36m%-28s\033[0m %s\n" "php-cs-fixer-allow-risky" "Fix code style PHP (utilise par le pre-commit)"
+	@printf "\n  Plus de details : \033[4mREADME.md\033[0m, \033[4mCLAUDE.md\033[0m\n\n"
+
 env-init:
 	@cp --update=none $(ENV_DEFAULT) $(ENV_LOCAL)
 
@@ -38,16 +82,19 @@ restart: env-init
 	$(DOCKER_COMPOSE) down
 	CURRENT_UID=$(shell id -u) CURRENT_GID=$(shell id -g) $(DOCKER_COMPOSE) up -d
 
-install: copy-git-hook composer-install cache-clear node-use build-nuxtJS migration-migrate test-db-setup
+install: copy-git-hook composer-install cache-clear node-use build-nuxtJS migration-migrate sync-permissions test-db-setup
 
 # Supprime tout est réinstalle tout (Attention ça supprime la bdd aussi)
 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
 
 build-nuxtJS:
+	$(EXEC_PHP_ROOT) chown -R $(APP_USER):$(APP_USER) /var/www/html/frontend
 	$(EXEC_PHP) sh -lc "cd frontend && npm install && npm run build:dist"
 
 dev-nuxt:
@@ -63,6 +110,54 @@ nuxt-lint-fix:
 nuxt-test:
 	$(EXEC_PHP) sh -c "cd frontend && npm run test"
 
+# Seed les 6 personas E2E (idempotent). A relancer des que le catalogue
+# permissions bouge (sync-permissions) ou avant chaque run test-e2e.
+seed-e2e:
+	$(SYMFONY_CONSOLE) app:seed-e2e
+
+# Bootstrap one-time pour les tests E2E sur un nouveau poste :
+#   1. Telecharge Chromium dans ~/.cache/ms-playwright
+#   2. Installe les deps systeme (libnss3, libasound, libatk, etc.) :
+#      - Ubuntu/Debian : `playwright install-deps` (officiel)
+#      - Fedora/RHEL   : liste dnf equivalente (playwright ne gere pas dnf)
+#      - Autre         : avertissement, a faire a la main.
+#
+# Le `sudo env "PATH=$$PATH"` est necessaire car avec NVM, `sudo npx` ne
+# trouve pas npx (le PATH de sudo est vide par defaut). On preserve
+# explicitement le PATH courant pour que npx resolve.
+#
+# A relancer uniquement si tu upgrade @playwright/test (les deps peuvent
+# bouger entre versions majeures).
+install-e2e-deps:
+	cd frontend && npx playwright install chromium
+	@if command -v apt-get >/dev/null 2>&1; then \
+		echo ">> Detected apt-get — using playwright install-deps"; \
+		cd frontend && sudo env "PATH=$$PATH" npx playwright install-deps chromium; \
+	elif command -v dnf >/dev/null 2>&1; then \
+		echo ">> Detected dnf — installing Chromium deps via dnf"; \
+		sudo dnf install -y \
+			nss nspr dbus-libs atk at-spi2-atk at-spi2-core cups-libs \
+			libdrm libX11 libXcomposite libXdamage libXfixes libXrandr \
+			libXext libXtst libxkbcommon mesa-libgbm alsa-lib \
+			pango cairo libwayland-client; \
+	else \
+		echo ">> No supported package manager detected (apt-get / dnf)."; \
+		echo ">> Install Chromium system libs manually, then re-run test-e2e."; \
+		exit 1; \
+	fi
+
+# Lance les tests E2E Playwright sur l'host. Pre-requis :
+#   - `make install-e2e-deps` (une fois par poste)
+#   - `make start` (containers en vie)
+#   - `make dev-nuxt` dans un autre terminal (serve frontend sur :3004)
+#   - `make seed-e2e` (personas crees)
+test-e2e:
+	cd frontend && npm run test:e2e
+
+# UI interactive Playwright (debug facile)
+test-e2e-ui:
+	cd frontend && npm run test:e2e:ui
+
 delete_built_dir:
 	CURRENT_UID=$(shell id -u) CURRENT_GID=$(shell id -g) $(DOCKER_COMPOSE) up -d
 	$(DOCKER) exec -u root $(PHP_CONTAINER) rm -rf vendor/

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(6) 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 defini uniquement via <server force="true"> ci-dessus.
+             Ne PAS re-declarer ici en <env> : une ligne redondante mene
+             directement au bug ou un dev met "dev" en pensant que <server>
+             gere tout, puis supprime <server> ensuite et <env> prend le
+             dessus silencieusement (cf. cc8d5 du fix pre-existant). -->
+        <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,8 @@ 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.permissions.view', 'label' => 'Consulter le catalogue des permissions RBAC'],
+            ['code' => 'core.audit_log.view', 'label' => 'Consulter le journal d\'audit'],
         ];
     }
 }

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

@@ -11,19 +11,27 @@ 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;
 
 #[ApiResource(
     operations: [
+        // Guard RBAC du catalogue de permissions : accepte les gestionnaires
+        // de users et de roles en plus du code dedie `core.permissions.view`.
+        // Justification : les drawers `UserRbacDrawer`/`RoleDrawer` fetchent
+        // systematiquement ce catalogue pour afficher les checkboxes de
+        // permissions ; exiger uniquement `core.permissions.view` casserait
+        // ces workflows pour tout gestionnaire non-admin. L'endpoint n'expose
+        // que des codes/libelles (pas de secret), le bypass reste acceptable.
         new GetCollection(
             normalizationContext: ['groups' => ['permission:read']],
-            security: "is_granted('ROLE_USER')",
+            security: "is_granted('core.permissions.view') or is_granted('core.users.manage') or is_granted('core.roles.manage')",
         ),
         new Get(
             normalizationContext: ['groups' => ['permission:read']],
-            security: "is_granted('ROLE_USER')",
+            security: "is_granted('core.permissions.view') or is_granted('core.users.manage') or is_granted('core.roles.manage')",
         ),
     ],
 )]
@@ -31,6 +39,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,12 +15,13 @@ 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;
+// Note architecture : User.php n'importe plus rien depuis le module Sites.
+// Les type-hints utilisent SiteInterface (Shared/Contract) et le mapping ORM
+// pointe vers la meme interface, resolue vers la classe concrete Site au boot
+// via `doctrine.orm.resolve_target_entities` (cf. config/packages/doctrine.yaml).
+// C'est le pattern officiel Doctrine pour les bounded contexts DDD.
+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;
@@ -49,6 +50,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',
@@ -63,6 +74,7 @@ use Symfony\Component\Serializer\Attribute\SerializedName;
 )]
 #[ORM\Entity(repositoryClass: DoctrineUserRepository::class)]
 #[ORM\Table(name: '`user`')]
+#[Auditable]
 class User implements UserInterface, PasswordAuthenticatedUserInterface
 {
     #[ORM\Id]
@@ -126,10 +138,12 @@ class User implements UserInterface, PasswordAuthenticatedUserInterface
      * 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>
+     * @var Collection<int, SiteInterface>
      */
-    #[ORM\ManyToMany(targetEntity: 'App\Module\Sites\Domain\Entity\Site', inversedBy: 'users', fetch: 'LAZY')]
+    #[ORM\ManyToMany(targetEntity: SiteInterface::class, inversedBy: 'users', fetch: 'LAZY')]
     #[ORM\JoinTable(name: 'user_site')]
+    #[ORM\JoinColumn(name: 'user_id', referencedColumnName: 'id', onDelete: 'CASCADE')]
+    #[ORM\InverseJoinColumn(name: 'site_id', referencedColumnName: 'id', onDelete: 'CASCADE')]
     #[Groups(['me:read', 'user:rbac:read', 'user:rbac:write'])]
     private Collection $sites;
 
@@ -149,15 +163,17 @@ class User implements UserInterface, PasswordAuthenticatedUserInterface
      * 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\ManyToOne(targetEntity: SiteInterface::class, 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')]
@@ -363,7 +379,7 @@ class User implements UserInterface, PasswordAuthenticatedUserInterface
     }
 
     /**
-     * @return Collection<int, Site>
+     * @return Collection<int, SiteInterface>
      */
     public function getSites(): Collection
     {
@@ -377,7 +393,8 @@ class User implements UserInterface, PasswordAuthenticatedUserInterface
      * 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.
+     * La classe concrete injectee au runtime est resolue par Doctrine via
+     * `resolve_target_entities` (cf. note architecture en tete de fichier).
      */
     public function addSite(SiteInterface $site): static
     {

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: 50,
+            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/UserPasswordHasherProcessor.php

@@ -13,7 +13,7 @@ use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
 /**
  * @implements ProcessorInterface<User, User>
  */
-class UserPasswordHasherProcessor implements ProcessorInterface
+final class UserPasswordHasherProcessor implements ProcessorInterface
 {
     public function __construct(
         #[Autowire(service: 'api_platform.doctrine.orm.state.persist_processor')]

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

@@ -9,11 +9,13 @@ 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;
 
@@ -51,12 +53,31 @@ use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
  */
 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
@@ -130,6 +151,20 @@ final class UserRbacProcessor implements ProcessorInterface
             $originalCurrentSiteId,
             &$result,
         ): void {
+            // 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.
+            //
+            // Execute dans la transaction (et non avant) : garantit que le snapshot
+            // Doctrine lu pour restauration reflete le meme etat BDD que celui sur
+            // lequel le persist va operer. Evite toute fenetre de race entre la
+            // lecture du snapshot et le flush.
+            $this->restoreAbsentCollections($data);
+
             $result = $this->persistProcessor->process($data, $operation, $uriVariables, $context);
 
             // Garde coherence currentSite (ticket 2 module Sites).
@@ -180,4 +215,89 @@ final class UserRbacProcessor implements ProcessorInterface
             $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) {
+            // La garde ne doit sauter la restauration que si le payload fournit
+            // un VRAI tableau pour cette cle. Un `null`, un scalaire ou un autre
+            // type doivent etre traites comme "cle absente" : sinon un payload
+            // `{"sites": null}` contourne la restauration et laisse API Platform
+            // vider la collection silencieusement (bypass de la garde).
+            if (array_key_exists($jsonKey, $payload) && is_array($payload[$jsonKey])) {
+                continue;
+            }
+
+            /** @var Collection<int, object> $currentCollection */
+            $currentCollection = $user->{$accessors['getter']}();
+
+            if (!$currentCollection instanceof PersistentCollection) {
+                continue;
+            }
+
+            // Force l'initialisation LAZY avant de lire le snapshot : pour une
+            // association fetch=LAZY (ex: User::$sites), la PersistentCollection
+            // existe mais son snapshot est vide tant que la collection n'a pas
+            // ete materialisee. Sans cet init, `getSnapshot()` renvoie `[]` et
+            // la boucle de restauration ci-dessous appelle `remover()` sur
+            // chaque item charge par `toArray()` → **vide silencieusement la
+            // collection** au lieu de la preserver. Idempotent si deja initialisee.
+            if (!$currentCollection->isInitialized()) {
+                $currentCollection->initialize();
+            }
+
+            // 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,240 @@
+<?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;
+use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
+
+/**
+ * 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` brut peut etre <= 0 (parametre client) → OFFSET negatif → 500 PG
+        // (`SQLSTATE[22023] OFFSET must not be negative`). API Platform clampe
+        // `itemsPerPage` au max de la resource mais pas `page` ; on impose un
+        // minimum a 1 cote provider.
+        $page         = max(1, $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')
+            // Tie-breaker sur `id` (UUID v7 monotone) : garantit un tri
+            // totalement deterministe quand plusieurs lignes partagent la
+            // meme timestamp (ex: batch fixture, bulk flush < 1µs).
+            ->addOrderBy('id', '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', 'performed_by'] as $key) {
+            if (isset($raw[$key]) && is_string($raw[$key]) && '' !== $raw[$key]) {
+                $filters[$key] = $raw[$key];
+            }
+        }
+
+        // `action` : whitelist stricte. Un input hors-liste provoquait avant
+        // un simple match vide (resultat 0 ligne) mais permettait d'incrementer
+        // le log applicatif a chaque variation ; on rejette en 400 explicite.
+        if (isset($raw['action']) && is_string($raw['action']) && '' !== $raw['action']) {
+            if (!in_array($raw['action'], ['create', 'update', 'delete'], true)) {
+                throw new BadRequestHttpException(
+                    'Filtre "action" invalide : valeurs autorisees create|update|delete.',
+                );
+            }
+            $filters['action'] = $raw['action'];
+        }
+
+        // Filtres de plage `performed_at[after]` / `performed_at[before]`.
+        // Sans validation, un input malforme remonte jusqu'a Postgres qui
+        // leve `SQLSTATE[22007]: invalid input syntax for type timestamp` →
+        // 500 Internal Server Error, log Monolog pollue, mauvaise UX API.
+        // On valide en amont et on rejette en 400 explicite.
+        if (isset($raw['performed_at']) && is_array($raw['performed_at'])) {
+            $range = $raw['performed_at'];
+            foreach (['after', 'before'] as $bound) {
+                if (!isset($range[$bound]) || !is_string($range[$bound]) || '' === $range[$bound]) {
+                    continue;
+                }
+                if (false === strtotime($range[$bound])) {
+                    throw new BadRequestHttpException(sprintf(
+                        'Filtre "performed_at[%s]" invalide : date ISO 8601 attendue (ex: 2026-04-22T00:00:00Z).',
+                        $bound,
+                    ));
+                }
+                $filters['performed_at_'.$bound] = $range[$bound];
+            }
+        }
+
+        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). Pas de clause ESCAPE : `\` est
+            // deja le caractere d'echappement LIKE par defaut en PostgreSQL.
+            $escaped = str_replace(['\\', '%', '_'], ['\\\\', '\%', '\_'], $filters['performed_by']);
+            $qb->andWhere('performed_by ILIKE :performed_by')
+                ->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/ApiPlatform/State/Provider/MeProvider.php

@@ -11,7 +11,7 @@ use Symfony\Bundle\SecurityBundle\Security;
 /**
  * @implements ProviderInterface<object>
  */
-class MeProvider implements ProviderInterface
+final class MeProvider implements ProviderInterface
 {
     public function __construct(
         private readonly Security $security,

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

@@ -0,0 +1,111 @@
+<?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]`.
+     *
+     * Recursion : parcourt les sous-tableaux (ex: changes structures
+     * `{field: {old, new}}`, snapshots avec relations imbriquees, ou
+     * payload arbitraire pousse par un appelant direct).
+     *
+     * @param array<string, mixed> $data
+     *
+     * @return array<string, mixed>
+     */
+    private function stripSensitive(array $data): array
+    {
+        foreach ($data as $key => $value) {
+            if (in_array($key, self::SENSITIVE_KEYS, true)) {
+                unset($data[$key]);
+
+                continue;
+            }
+            if (is_array($value)) {
+                $data[$key] = $this->stripSensitive($value);
+            }
+        }
+
+        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/Console/SeedE2ECommand.php

@@ -0,0 +1,216 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Core\Infrastructure\Console;
+
+use App\Module\Core\Domain\Entity\User;
+use App\Module\Core\Domain\Repository\PermissionRepositoryInterface;
+use App\Module\Core\Domain\Repository\RoleRepositoryInterface;
+use App\Module\Core\Domain\Repository\UserRepositoryInterface;
+use App\Module\Core\Domain\Security\SystemRoles;
+use App\Shared\Domain\Contract\SiteProviderInterface;
+use Doctrine\ORM\EntityManagerInterface;
+use RuntimeException;
+use Symfony\Component\Console\Attribute\AsCommand;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Style\SymfonyStyle;
+use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
+
+/**
+ * Seed dedie aux tests E2E Playwright (frontend/tests/e2e).
+ *
+ * Cree 6 personas (e2e.*) qui couvrent les cases nominales de la matrice
+ * RBAC : super-admin, user-full, user-readonly, user-users-only,
+ * user-audit-only, user-nothing. Cette liste est la replique back du
+ * fichier `frontend/tests/e2e/_fixtures/personas.ts` — si tu modifies
+ * l'une des deux, met a jour l'autre.
+ *
+ * Idempotent : supprime les users prefixes `e2e.` avant de les recreer.
+ * Ne touche PAS aux fixtures dev (admin/alice/bob) ni aux sites.
+ *
+ * Pre-requis : `bin/console app:sync-permissions` doit avoir tourne pour
+ * que les permissions soient en base. La commande echoue en erreur explicite
+ * si une permission attendue est absente du catalogue.
+ */
+#[AsCommand(
+    name: 'app:seed-e2e',
+    description: 'Seed les 6 personas utilises par les tests E2E Playwright.',
+)]
+final class SeedE2ECommand extends Command
+{
+    private const string SHARED_PASSWORD     = 'e2e-secret';
+    private const string E2E_USERNAME_PREFIX = 'e2e.';
+    private const string DEFAULT_SITE_NAME   = 'Chatellerault';
+
+    public function __construct(
+        private readonly EntityManagerInterface $em,
+        private readonly UserRepositoryInterface $userRepository,
+        private readonly RoleRepositoryInterface $roleRepository,
+        private readonly PermissionRepositoryInterface $permissionRepository,
+        private readonly SiteProviderInterface $siteProvider,
+        private readonly UserPasswordHasherInterface $passwordHasher,
+    ) {
+        parent::__construct();
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output): int
+    {
+        $io = new SymfonyStyle($input, $output);
+
+        // Garde-fou : cette commande cree un compte admin avec un mot de passe
+        // hardcode. Elle ne doit JAMAIS tourner hors dev/test, meme si le
+        // fichier se retrouve embarque dans une image prod par accident (le
+        // .dockerignore a la racine est la premiere ligne de defense).
+        $env = $_SERVER['APP_ENV'] ?? 'prod';
+        if (!in_array($env, ['dev', 'test'], true)) {
+            $io->error(sprintf('app:seed-e2e est refuse en environnement "%s". Autorise uniquement en dev/test.', $env));
+
+            return Command::FAILURE;
+        }
+
+        $userRole = $this->roleRepository->findByCode(SystemRoles::USER_CODE);
+
+        if (null === $userRole) {
+            $io->error(sprintf(
+                'Le role systeme "%s" est introuvable. Lance les migrations + fixtures ou `app:sync-permissions` avant ce seed.',
+                SystemRoles::USER_CODE,
+            ));
+
+            return Command::FAILURE;
+        }
+
+        $defaultSite = $this->siteProvider->findByName(self::DEFAULT_SITE_NAME);
+
+        // Pas de fail fatal si le site manque : les tests sidebar/login
+        // n'en dependent pas. Les tests sites-scope-bypass (a venir) le feront.
+        if (null === $defaultSite) {
+            $io->note(sprintf(
+                'Site "%s" absent : les personas seront crees sans site. Lance `make fixtures` si tu as besoin des sites.',
+                self::DEFAULT_SITE_NAME,
+            ));
+        }
+
+        $this->wipeExistingE2EUsers($io);
+
+        foreach ($this->personasDefinition() as $persona) {
+            $user = new User();
+            $user->setUsername($persona['username']);
+            $user->setPassword($this->passwordHasher->hashPassword($user, self::SHARED_PASSWORD));
+            $user->setIsAdmin($persona['isAdmin']);
+            $user->addRbacRole($userRole);
+
+            foreach ($persona['permissions'] as $code) {
+                $permission = $this->permissionRepository->findByCode($code);
+
+                if (null === $permission) {
+                    throw new RuntimeException(sprintf(
+                        'Permission "%s" introuvable en base. Lance `app:sync-permissions` avant `app:seed-e2e`.',
+                        $code,
+                    ));
+                }
+
+                $user->addDirectPermission($permission);
+            }
+
+            if (null !== $defaultSite && 'e2e.user-nothing' !== $persona['username']) {
+                // user-nothing reste sans site pour pouvoir tester un flow
+                // "aucune permission et aucun site".
+                $user->addSite($defaultSite);
+                $user->setCurrentSite($defaultSite);
+            }
+
+            $this->userRepository->save($user);
+
+            $io->text(sprintf(
+                '  - %s (admin=%s, permissions=%d)',
+                $persona['username'],
+                $persona['isAdmin'] ? 'oui' : 'non',
+                count($persona['permissions']),
+            ));
+        }
+
+        $io->success(sprintf('%d personas E2E seedes.', count($this->personasDefinition())));
+
+        return Command::SUCCESS;
+    }
+
+    private function wipeExistingE2EUsers(SymfonyStyle $io): void
+    {
+        $removed = 0;
+
+        foreach ($this->personasDefinition() as $persona) {
+            $existing = $this->userRepository->findByUsername($persona['username']);
+
+            if (null === $existing) {
+                continue;
+            }
+
+            $this->em->remove($existing);
+            ++$removed;
+        }
+
+        if ($removed > 0) {
+            $this->em->flush();
+            $io->text(sprintf('Nettoyage : %d users E2E supprimes.', $removed));
+        }
+    }
+
+    /**
+     * Liste des personas — source back, miroir de
+     * `frontend/tests/e2e/_fixtures/personas.ts`.
+     *
+     * @return list<array{username: string, isAdmin: bool, permissions: list<string>}>
+     */
+    private function personasDefinition(): array
+    {
+        return [
+            [
+                'username'    => self::E2E_USERNAME_PREFIX.'super-admin',
+                'isAdmin'     => true,
+                'permissions' => [],
+            ],
+            [
+                'username'    => self::E2E_USERNAME_PREFIX.'user-full',
+                'isAdmin'     => false,
+                'permissions' => [
+                    'core.users.view',
+                    'core.users.manage',
+                    'core.roles.view',
+                    'core.roles.manage',
+                    'core.audit_log.view',
+                    'sites.view',
+                    'sites.manage',
+                    'sites.bypass_scope',
+                ],
+            ],
+            [
+                'username'    => self::E2E_USERNAME_PREFIX.'user-readonly',
+                'isAdmin'     => false,
+                'permissions' => [
+                    'core.users.view',
+                    'core.roles.view',
+                    'core.audit_log.view',
+                    'sites.view',
+                ],
+            ],
+            [
+                'username'    => self::E2E_USERNAME_PREFIX.'user-users-only',
+                'isAdmin'     => false,
+                'permissions' => ['core.users.view', 'core.users.manage'],
+            ],
+            [
+                'username'    => self::E2E_USERNAME_PREFIX.'user-audit-only',
+                'isAdmin'     => false,
+                'permissions' => ['core.audit_log.view'],
+            ],
+            [
+                'username'    => self::E2E_USERNAME_PREFIX.'user-nothing',
+                'isAdmin'     => false,
+                'permissions' => [],
+            ],
+        ];
+    }
+}

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

@@ -8,9 +8,9 @@ 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 App\Shared\Domain\Contract\SiteInterface;
+use App\Shared\Domain\Contract\SiteProviderInterface;
 use Doctrine\Bundle\FixturesBundle\Fixture;
 use Doctrine\Common\DataFixtures\DependentFixtureInterface;
 use Doctrine\Persistence\ObjectManager;
@@ -39,7 +39,7 @@ class AppFixtures extends Fixture implements DependentFixtureInterface
     public function __construct(
         private readonly UserPasswordHasherInterface $passwordHasher,
         private readonly RoleRepositoryInterface $roleRepository,
-        private readonly SiteRepositoryInterface $siteRepository,
+        private readonly SiteProviderInterface $siteProvider,
     ) {}
 
     /**
@@ -135,9 +135,9 @@ class AppFixtures extends Fixture implements DependentFixtureInterface
         return $role;
     }
 
-    private function requireSite(string $name): Site
+    private function requireSite(string $name): SiteInterface
     {
-        $site = $this->siteRepository->findByName($name);
+        $site = $this->siteProvider->findByName($name);
 
         if (null === $site) {
             throw new RuntimeException(sprintf(

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

@@ -0,0 +1,513 @@
+<?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();
+
+        // Reset defensif en debut de cycle : si un flush precedent a leve une
+        // exception, Doctrine n'appelle PAS postFlush et pendingLogs reste
+        // rempli avec des changements jamais committes. Sans ce reset, un
+        // flush ulterieur reussi ecrirait les fausses entrees dans audit_log.
+        // Le swap-and-clear dans postFlush couvre deja les flushes re-entrants,
+        // ce reset ne le fragilise donc pas.
+        $this->pendingLogs = [];
+
+        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/Domain/Entity/Site.php

@@ -12,6 +12,7 @@ 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;
@@ -64,6 +65,7 @@ use Symfony\Component\Validator\Constraints as Assert;
 )]
 #[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.')]

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

@@ -5,8 +5,9 @@ declare(strict_types=1);
 namespace App\Module\Sites\Domain\Repository;
 
 use App\Module\Sites\Domain\Entity\Site;
+use App\Shared\Domain\Contract\SiteProviderInterface;
 
-interface SiteRepositoryInterface
+interface SiteRepositoryInterface extends SiteProviderInterface
 {
     public function findById(int $id): ?Site;
 

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

@@ -34,7 +34,7 @@ class DoctrineSiteRepository extends ServiceEntityRepository implements SiteRepo
      */
     public function findAllOrderedByName(): array
     {
-        /** @var list<Site> $sites */
+        // @var list<Site> $sites
         return $this->findBy([], ['name' => 'ASC']);
     }
 

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/SiteProviderInterface.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Shared\Domain\Contract;
+
+/**
+ * Contrat minimal pour acceder a un site depuis un module qui n'est pas Sites.
+ *
+ * Permet a du code Core/Shared (commandes de seed, fixtures, etc.) de
+ * recuperer un Site par son nom sans importer directement depuis le module
+ * Sites — ce qui violerait la regle "jamais d'import direct entre modules"
+ * (cf. CLAUDE.md section "Regles d'architecture").
+ *
+ * Implementation concrete : App\Module\Sites\Infrastructure\Doctrine\DoctrineSiteRepository
+ * (via SiteRepositoryInterface qui etend ce contrat).
+ */
+interface SiteProviderInterface
+{
+    public function findByName(string $name): ?SiteInterface;
+}

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/Module/Core/Api/AuditLogApiTest.php

@@ -0,0 +1,451 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Module\Core\Api;
+
+use DateTimeImmutable;
+use DateTimeZone;
+use Doctrine\DBAL\Connection;
+use Symfony\Component\Uid\Uuid;
+
+/**
+ * Tests fonctionnels de l'API `/api/audit-logs`.
+ *
+ * Invariants testes :
+ *  - 401 sans authentification ;
+ *  - 403 pour un user authentifie sans permission `core.audit_log.view` ;
+ *  - 200 + JSON-LD pagine pour admin et user avec la permission ;
+ *  - filtres `entity_type`, `action` operants ;
+ *  - ordre `performed_at DESC` ;
+ *  - aucune operation d'ecriture exposee (POST -> 405).
+ *
+ * Seed : on insere 3 lignes temoins directement via DBAL (pas via l'ORM)
+ * pour eviter la recursion du listener. Les lignes sont supprimees en
+ * tearDown par le request_id tag specifique au run.
+ *
+ * @internal
+ */
+final class AuditLogApiTest extends AbstractApiTestCase
+{
+    // Proprietes nullable : si `bootKernel()` ou l'acces container echoue,
+    // `tearDown` se declenche quand meme et doit survivre a un setUp incomplet
+    // (sinon on masque l'exception d'origine avec un "typed property must not
+    // be accessed before initialization").
+    private ?Connection $auditConnection = null;
+
+    private ?string $runTag = null;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        self::bootKernel();
+
+        /** @var Connection $conn */
+        $conn                  = self::getContainer()->get('doctrine.dbal.audit_connection');
+        $this->auditConnection = $conn;
+
+        $this->runTag = 'apiaudit'.bin2hex(random_bytes(4));
+        $this->seedAuditLog();
+    }
+
+    protected function tearDown(): void
+    {
+        if (null !== $this->auditConnection && null !== $this->runTag) {
+            $this->auditConnection->executeStatement(
+                'DELETE FROM audit_log WHERE request_id = :tag',
+                ['tag' => $this->runTag],
+            );
+            // Close explicite pour liberer la connexion PG : en test, le
+            // kernel reboote et les connexions pendantes saturent le pool
+            // sur une suite de 200+ tests qui ouvrent 2 connexions chacun.
+            $this->auditConnection->close();
+        }
+        parent::tearDown();
+    }
+
+    public function testUnauthenticatedRequestGets401(): void
+    {
+        $client   = self::createClient();
+        $response = $client->request('GET', '/api/audit-logs');
+
+        self::assertSame(401, $response->getStatusCode());
+    }
+
+    public function testAuthenticatedUserWithoutPermissionGets403(): void
+    {
+        // Utilise `core.users.view` comme permission non-liee (l'user n'a pas audit_log.view).
+        $credentials = $this->createUserWithPermission('core.users.view');
+        $client      = $this->authenticatedClient($credentials['username'], $credentials['password']);
+        $response    = $client->request('GET', '/api/audit-logs');
+
+        self::assertSame(403, $response->getStatusCode());
+    }
+
+    public function testAuthenticatedUserWithPermissionGets200(): void
+    {
+        $credentials = $this->createUserWithPermission('core.audit_log.view');
+        $client      = $this->authenticatedClient($credentials['username'], $credentials['password']);
+        $response    = $client->request('GET', '/api/audit-logs');
+
+        self::assertSame(200, $response->getStatusCode());
+
+        $data = $response->toArray();
+        self::assertArrayHasKey('member', $data);
+        self::assertArrayHasKey('totalItems', $data);
+    }
+
+    /**
+     * Le frontend demande explicitement `application/ld+json` dans `useAuditLog`
+     * pour obtenir l'objet Hydra complet (`member`, `totalItems`, `view`). Sous
+     * `application/json`, API Platform 4 renvoie un tableau plat sans ces
+     * metadonnees, ce qui casserait la pagination prev/next. Ce test verrouille
+     * le contrat : un changement de format par defaut ou une desactivation de
+     * JSON-LD produirait un 200 trompeur mais un tableau admin vide.
+     */
+    public function testJsonLdFormatExposesHydraEnvelope(): void
+    {
+        $client   = $this->authenticatedClient('admin', 'admin');
+        $response = $client->request('GET', '/api/audit-logs', [
+            'headers' => ['Accept' => 'application/ld+json'],
+        ]);
+
+        self::assertSame(200, $response->getStatusCode());
+        self::assertStringContainsString('application/ld+json', $response->getHeaders()['content-type'][0]);
+
+        $data = $response->toArray();
+        self::assertArrayHasKey('member', $data);
+        self::assertArrayHasKey('totalItems', $data);
+        // `view` n'est presente que si une pagination est active (plus d'items
+        // que la limite par page). Avec paginationItemsPerPage=30 et les 3
+        // lignes seedees (+ d'autres lignes de tests precedents), la collection
+        // peut excelder 30. Si presente, elle doit porter au moins @id.
+        if (isset($data['view'])) {
+            self::assertArrayHasKey('@id', $data['view']);
+        }
+    }
+
+    public function testAdminGets200(): void
+    {
+        $client   = $this->authenticatedClient('admin', 'admin');
+        $response = $client->request('GET', '/api/audit-logs');
+
+        self::assertSame(200, $response->getStatusCode());
+    }
+
+    public function testFilterByEntityType(): void
+    {
+        $client   = $this->authenticatedClient('admin', 'admin');
+        $response = $client->request('GET', '/api/audit-logs?entity_type=core.User&action=update');
+
+        self::assertSame(200, $response->getStatusCode());
+        $data    = $response->toArray();
+        $members = $data['member'];
+
+        // On verifie qu'il n'y a que des lignes matching nos filtres dans les resultats de notre run
+        // (d'autres lignes antérieures au run peuvent exister, mais le filtre doit etre respecte).
+        foreach ($members as $member) {
+            self::assertSame('core.User', $member['entityType']);
+            self::assertSame('update', $member['action']);
+        }
+    }
+
+    public function testOrderedByPerformedAtDesc(): void
+    {
+        $client = $this->authenticatedClient('admin', 'admin');
+        // On cible les 3 lignes seedees via le filtre `entity_id=999` (unique a ce test).
+        $response = $client->request('GET', '/api/audit-logs?'.http_build_query(['entity_type' => 'core.User', 'entity_id' => '999']));
+
+        self::assertSame(200, $response->getStatusCode());
+
+        $data    = $response->toArray();
+        $members = array_values(array_filter(
+            $data['member'],
+            fn (array $m) => ($m['requestId'] ?? null) === $this->runTag,
+        ));
+
+        self::assertCount(3, $members, 'Les 3 lignes seedees doivent etre visibles');
+        // Tri DESC : le plus recent d'abord.
+        $timestamps = array_map(fn (array $m) => strtotime((string) $m['performedAt']), $members);
+        $sortedDesc = $timestamps;
+        rsort($sortedDesc);
+        self::assertSame($sortedDesc, $timestamps, 'Les lignes doivent etre triees par performedAt DESC');
+    }
+
+    public function testItemEndpointReturns200WithPermission(): void
+    {
+        $row = $this->auditConnection->fetchAssociative(
+            'SELECT id FROM audit_log WHERE request_id = :tag LIMIT 1',
+            ['tag' => $this->runTag],
+        );
+        self::assertIsArray($row);
+
+        $client   = $this->authenticatedClient('admin', 'admin');
+        $response = $client->request('GET', '/api/audit-logs/'.$row['id']);
+
+        self::assertSame(200, $response->getStatusCode());
+        $data = $response->toArray();
+        self::assertSame($row['id'], $data['id']);
+    }
+
+    /**
+     * Symetrique de `testAuthenticatedUserWithoutPermissionGets403` mais sur
+     * l'endpoint item. Le `security: is_granted('core.audit_log.view')` declare
+     * sur `Get` dans `AuditLogResource` doit refuser 403 (pas 200, pas 404).
+     */
+    public function testItemEndpointWithoutPermissionGets403(): void
+    {
+        $row = $this->auditConnection->fetchAssociative(
+            'SELECT id FROM audit_log WHERE request_id = :tag LIMIT 1',
+            ['tag' => $this->runTag],
+        );
+        self::assertIsArray($row);
+
+        // Permission "voisine" : prouve que l'auth seule ne suffit pas.
+        $credentials = $this->createUserWithPermission('core.users.view');
+        $client      = $this->authenticatedClient($credentials['username'], $credentials['password']);
+        $response    = $client->request('GET', '/api/audit-logs/'.$row['id']);
+
+        self::assertSame(403, $response->getStatusCode());
+    }
+
+    /**
+     * `?page=0` provoquait historiquement un OFFSET negatif → 500 PG
+     * `SQLSTATE[22023] OFFSET must not be negative`. API Platform 4 valide
+     * desormais `page >= 1` en amont (rejette 400) avant que le provider ne
+     * soit appele ; le clamp `max(1, ...)` cote provider reste en place comme
+     * defense-in-depth si un futur upgrade ou un changement de configuration
+     * leve cette validation. Ce test verrouille l'invariant fonctionnel :
+     * aucun 500 PG quel que soit le mecanisme protecteur en place.
+     */
+    public function testPageZeroDoesNotProduceServerError(): void
+    {
+        $client   = $this->authenticatedClient('admin', 'admin');
+        $response = $client->request('GET', '/api/audit-logs?page=0');
+
+        self::assertContains(
+            $response->getStatusCode(),
+            [200, 400],
+            'page=0 doit etre traite proprement (clamp 200 ou 400 explicite), jamais 500 PG.',
+        );
+    }
+
+    /**
+     * Validation des filtres : un input malforme doit retourner un 400
+     * explicite, pas un 500 (Postgres qui rejette le cast timestamp) ni
+     * un match silencieux sur une valeur inattendue.
+     */
+    public function testInvalidPerformedAtFilterReturns400(): void
+    {
+        $client   = $this->authenticatedClient('admin', 'admin');
+        $response = $client->request('GET', '/api/audit-logs?performed_at[after]=pas-une-date');
+
+        self::assertSame(400, $response->getStatusCode());
+    }
+
+    public function testInvalidActionFilterReturns400(): void
+    {
+        $client   = $this->authenticatedClient('admin', 'admin');
+        $response = $client->request('GET', '/api/audit-logs?action=dropTable');
+
+        self::assertSame(400, $response->getStatusCode());
+    }
+
+    public function testPostIsNotAllowed(): void
+    {
+        $client   = $this->authenticatedClient('admin', 'admin');
+        $response = $client->request('POST', '/api/audit-logs', [
+            'headers' => ['Content-Type' => 'application/ld+json'],
+            'json'    => ['entityType' => 'core.User', 'entityId' => '1', 'action' => 'create', 'changes' => []],
+        ]);
+
+        self::assertContains($response->getStatusCode(), [404, 405], 'POST doit etre refuse (pas d\'operation d\'ecriture exposee)');
+    }
+
+    /**
+     * Filtre multi-valeurs `entity_type[]=X&entity_type[]=Y` : l'union des
+     * deux types est retournee. On seed 2 types differents (core.User et
+     * core.Role) et on verifie que les deux apparaissent sous notre runTag,
+     * et qu'une valeur non existante (`core.Nonexistent`) n'ajoute rien.
+     *
+     * On interroge avec itemsPerPage=100 pour englober nos 5 lignes quel
+     * que soit le bruit de lignes preexistantes dans audit_log.
+     */
+    public function testFilterByMultipleEntityTypes(): void
+    {
+        // Seed 2 lignes supplementaires avec un autre entity_type.
+        $this->seedExtraRow('core.Role', '1001', 'create');
+        $this->seedExtraRow('core.Role', '1002', 'update');
+
+        $client   = $this->authenticatedClient('admin', 'admin');
+        $response = $client->request('GET', '/api/audit-logs?'.http_build_query([
+            'entity_type'  => ['core.User', 'core.Role', 'core.Nonexistent'],
+            'itemsPerPage' => 100,
+        ]));
+
+        self::assertSame(200, $response->getStatusCode());
+        $data = $response->toArray();
+
+        // Filtre sur notre runTag pour isoler nos 5 lignes (3 User + 2 Role)
+        // independamment des entrees pre-existantes de la table.
+        $ours = array_values(array_filter(
+            $data['member'],
+            fn (array $m) => ($m['requestId'] ?? null) === $this->runTag,
+        ));
+        self::assertCount(5, $ours, 'Les 3 lignes core.User + 2 lignes core.Role doivent etre retournees.');
+
+        $types = array_unique(array_map(fn (array $m) => $m['entityType'], $ours));
+        sort($types);
+        self::assertSame(['core.Role', 'core.User'], $types);
+
+        // Verifier qu'aucune ligne hors filtre n'apparait dans la reponse.
+        foreach ($data['member'] as $member) {
+            self::assertContains($member['entityType'], ['core.User', 'core.Role']);
+        }
+    }
+
+    /**
+     * Recherche partielle insensible a la casse sur `performed_by` via ILIKE.
+     * Le seed utilise `performed_by=admin` ; on cherche `ADM` pour tester
+     * a la fois la casse et le wildcard contains.
+     */
+    public function testFilterByPerformedByPartialMatch(): void
+    {
+        $client   = $this->authenticatedClient('admin', 'admin');
+        $response = $client->request('GET', '/api/audit-logs?performed_by=ADM&entity_id=999');
+
+        self::assertSame(200, $response->getStatusCode());
+        $data = $response->toArray();
+        $ours = array_filter($data['member'], fn (array $m) => ($m['requestId'] ?? null) === $this->runTag);
+        self::assertGreaterThan(0, count($ours), 'La recherche ILIKE doit matcher "ADM" -> "admin".');
+    }
+
+    /**
+     * Les caracteres wildcard PostgreSQL (`%`, `_`) saisis par l'utilisateur
+     * doivent etre echappes et traites comme caracteres litteraux, pas comme
+     * des metacaracteres LIKE. `\` est le caractere d'echappement LIKE par
+     * defaut en PostgreSQL (pas de clause ESCAPE explicite) : on le double
+     * dans le motif pour qu'il soit aussi traite comme litteral.
+     */
+    public function testFilterByPerformedByEscapesWildcards(): void
+    {
+        $client = $this->authenticatedClient('admin', 'admin');
+
+        // `%` seul doit matcher 0 ligne (personne n'a `%` dans performed_by).
+        $response = $client->request('GET', '/api/audit-logs?performed_by=%25&entity_id=999');
+        self::assertSame(200, $response->getStatusCode());
+        $data = $response->toArray();
+        $ours = array_filter($data['member'], fn (array $m) => ($m['requestId'] ?? null) === $this->runTag);
+        self::assertCount(0, $ours, '% doit etre traite comme literal, pas wildcard.');
+
+        // `_` seul (wildcard single-char en LIKE) doit aussi matcher 0 ligne.
+        $response = $client->request('GET', '/api/audit-logs?performed_by=_&entity_id=999');
+        self::assertSame(200, $response->getStatusCode());
+        $data = $response->toArray();
+        $ours = array_filter($data['member'], fn (array $m) => ($m['requestId'] ?? null) === $this->runTag);
+        self::assertCount(0, $ours, '_ doit etre traite comme literal, pas wildcard single-char.');
+
+        // `\` (backslash, echappement LIKE par defaut en PG) : un seul `\`
+        // dans l'entree utilisateur est double en `\\` et doit etre interprete
+        // comme litteral. On attend une reponse 200 (pas 500), resultat vide.
+        $response = $client->request('GET', '/api/audit-logs?performed_by=%5C&entity_id=999');
+        self::assertSame(200, $response->getStatusCode(), 'Un backslash dans le filtre ne doit pas produire de 500.');
+    }
+
+    /**
+     * L'endpoint `/api/audit-log-entity-types` retourne la liste des valeurs
+     * distinctes de `entity_type` presentes dans la table. La presence du
+     * seed runTag garantit au moins `core.User`.
+     */
+    public function testEntityTypesEndpointReturnsDistinctTypes(): void
+    {
+        $client   = $this->authenticatedClient('admin', 'admin');
+        $response = $client->request('GET', '/api/audit-log-entity-types');
+
+        self::assertSame(200, $response->getStatusCode());
+        $data = $response->toArray();
+        self::assertArrayHasKey('entityTypes', $data);
+        self::assertIsArray($data['entityTypes']);
+        self::assertContains('core.User', $data['entityTypes']);
+    }
+
+    public function testEntityTypesEndpointRequiresPermission(): void
+    {
+        $credentials = $this->createUserWithPermission('core.users.view');
+        $client      = $this->authenticatedClient($credentials['username'], $credentials['password']);
+        $response    = $client->request('GET', '/api/audit-log-entity-types');
+
+        self::assertSame(403, $response->getStatusCode());
+    }
+
+    /**
+     * Helper interne pour seeder une ligne additionnelle avec un entity_type
+     * arbitraire, taggee runTag pour nettoyage en tearDown.
+     */
+    private function seedExtraRow(string $entityType, string $entityId, string $action): void
+    {
+        $this->auditConnection->insert('audit_log', [
+            'id'           => Uuid::v7()->toRfc4122(),
+            'entity_type'  => $entityType,
+            'entity_id'    => $entityId,
+            'action'       => $action,
+            'changes'      => json_encode(['field' => ['old' => 1, 'new' => 2]], JSON_THROW_ON_ERROR),
+            'performed_by' => 'admin',
+            'performed_at' => new DateTimeImmutable('now', new DateTimeZone('UTC'))->format('Y-m-d H:i:sO'),
+            'ip_address'   => null,
+            'request_id'   => $this->runTag,
+        ]);
+    }
+
+    /**
+     * Insere 3 lignes temoins taggees avec le runTag pour un nettoyage sur.
+     */
+    private function seedAuditLog(): void
+    {
+        $now = new DateTimeImmutable('now', new DateTimeZone('UTC'));
+
+        $fixtures = [
+            [
+                'entity_type'  => 'core.User',
+                'entity_id'    => '999',
+                'action'       => 'update',
+                'changes'      => ['isAdmin' => ['old' => false, 'new' => true]],
+                'performed_by' => 'admin',
+                // Offsets faibles (secondes) : garantit que les 3 lignes
+                // restent parmi les plus recentes de audit_log meme quand la
+                // table contient plusieurs centaines de lignes historiques.
+                'performed_at' => $now->modify('-2 seconds'),
+            ],
+            [
+                'entity_type'  => 'core.User',
+                'entity_id'    => '999',
+                'action'       => 'update',
+                'changes'      => ['username' => ['old' => 'x', 'new' => 'y']],
+                'performed_by' => 'admin',
+                'performed_at' => $now->modify('-1 second'),
+            ],
+            [
+                'entity_type'  => 'core.User',
+                'entity_id'    => '999',
+                'action'       => 'delete',
+                'changes'      => ['username' => 'y'],
+                'performed_by' => 'admin',
+                'performed_at' => $now,
+            ],
+        ];
+
+        foreach ($fixtures as $row) {
+            $this->auditConnection->insert('audit_log', [
+                'id'           => Uuid::v7()->toRfc4122(),
+                'entity_type'  => $row['entity_type'],
+                'entity_id'    => $row['entity_id'],
+                'action'       => $row['action'],
+                'changes'      => json_encode($row['changes'], JSON_THROW_ON_ERROR),
+                'performed_by' => $row['performed_by'],
+                'performed_at' => $row['performed_at']->format('Y-m-d H:i:sO'),
+                'ip_address'   => null,
+                'request_id'   => $this->runTag,
+            ]);
+        }
+    }
+}

tests/Module/Core/Api/PermissionApiTest.php

@@ -166,16 +166,19 @@ final class PermissionApiTest extends AbstractApiTestCase
         self::assertResponseStatusCodeSame(401);
     }
 
-    public function testStandardUserCanListPermissions(): void
+    public function testStandardUserWithoutPermissionIsForbiddenOnCollection(): void
     {
-        // Le catalogue de permissions est accessible a tout utilisateur authentifie.
+        // Le catalogue de permissions est protege par `core.permissions.view` :
+        // un user authentifie sans cette permission (ni flag admin) doit
+        // recevoir un 403. Alice n'a que le role systeme "user" (zero
+        // permission attachee) — elle est le cobaye ideal pour ce test.
         $client = $this->authenticatedClient('alice', 'alice');
         $client->request('GET', '/api/permissions');
 
-        self::assertResponseIsSuccessful();
+        self::assertResponseStatusCodeSame(403);
     }
 
-    public function testStandardUserCanGetPermission(): void
+    public function testStandardUserWithoutPermissionIsForbiddenOnItem(): void
     {
         $permission = $this->getEm()->getRepository(Permission::class)
             ->findOneBy(['code' => 'test.core.users.view'])
@@ -185,6 +188,86 @@ final class PermissionApiTest extends AbstractApiTestCase
         $client = $this->authenticatedClient('alice', 'alice');
         $client->request('GET', '/api/permissions/'.$permission->getId());
 
+        self::assertResponseStatusCodeSame(403);
+    }
+
+    public function testNonAdminWithPermissionViewCanListPermissions(): void
+    {
+        // Chemin positif : un user non-admin qui porte la permission
+        // `core.permissions.view` (via un role dedie) doit recevoir 200 sur
+        // le catalogue. Couvre l'habilitation sans bypass isAdmin.
+        $creds  = $this->createUserWithPermission('core.permissions.view');
+        $client = $this->authenticatedClient($creds['username'], $creds['password']);
+        $client->request('GET', '/api/permissions');
+
+        self::assertResponseIsSuccessful();
+    }
+
+    public function testNonAdminWithUsersManageCanListPermissions(): void
+    {
+        // Bypass pragmatique : les gestionnaires d'users ont besoin du
+        // catalogue pour les drawers RBAC. Couvre la branche OR de la
+        // security expression `core.users.manage`.
+        $creds  = $this->createUserWithPermission('core.users.manage');
+        $client = $this->authenticatedClient($creds['username'], $creds['password']);
+        $client->request('GET', '/api/permissions');
+
+        self::assertResponseIsSuccessful();
+    }
+
+    public function testNonAdminWithRolesManageCanListPermissions(): void
+    {
+        // Meme logique que ci-dessus pour les gestionnaires de roles
+        // (branche OR `core.roles.manage` de la security expression).
+        $creds  = $this->createUserWithPermission('core.roles.manage');
+        $client = $this->authenticatedClient($creds['username'], $creds['password']);
+        $client->request('GET', '/api/permissions');
+
+        self::assertResponseIsSuccessful();
+    }
+
+    public function testNonAdminWithPermissionViewCanGetItem(): void
+    {
+        // Miroir item de testNonAdminWithPermissionViewCanListPermissions :
+        // la security expression OR est repliquee sur `new Get(...)` et doit
+        // donc aussi s'appliquer ici.
+        $permission = $this->getEm()->getRepository(Permission::class)
+            ->findOneBy(['code' => 'test.core.users.view'])
+        ;
+        self::assertNotNull($permission);
+
+        $creds  = $this->createUserWithPermission('core.permissions.view');
+        $client = $this->authenticatedClient($creds['username'], $creds['password']);
+        $client->request('GET', '/api/permissions/'.$permission->getId());
+
+        self::assertResponseIsSuccessful();
+    }
+
+    public function testNonAdminWithUsersManageCanGetItem(): void
+    {
+        $permission = $this->getEm()->getRepository(Permission::class)
+            ->findOneBy(['code' => 'test.core.users.view'])
+        ;
+        self::assertNotNull($permission);
+
+        $creds  = $this->createUserWithPermission('core.users.manage');
+        $client = $this->authenticatedClient($creds['username'], $creds['password']);
+        $client->request('GET', '/api/permissions/'.$permission->getId());
+
+        self::assertResponseIsSuccessful();
+    }
+
+    public function testNonAdminWithRolesManageCanGetItem(): void
+    {
+        $permission = $this->getEm()->getRepository(Permission::class)
+            ->findOneBy(['code' => 'test.core.users.view'])
+        ;
+        self::assertNotNull($permission);
+
+        $creds  = $this->createUserWithPermission('core.roles.manage');
+        $client = $this->authenticatedClient($creds['username'], $creds['password']);
+        $client->request('GET', '/api/permissions/'.$permission->getId());
+
         self::assertResponseIsSuccessful();
     }
 

tests/Module/Core/Api/UserRbacSitesApiTest.php

@@ -139,6 +139,46 @@ final class UserRbacSitesApiTest extends AbstractApiTestCase
         self::assertSame('Chatellerault', $reloaded->getCurrentSite()->getName());
     }
 
+    /**
+     * Defense-in-depth contre un bypass hypothetique de restoreAbsentCollections.
+     *
+     * API Platform rejette deja `sites: null` au denormalize (400 Bad Request,
+     * type mismatch). Le guard `is_array` dans UserRbacProcessor est une
+     * deuxieme ligne de defense si la config denormalizer change un jour.
+     *
+     * Ce test verrouille deux garanties :
+     * 1. `{"sites": null}` → 400 (pas un 500, pas un 200 silencieux)
+     * 2. La collection sites d'alice est intacte apres l'echec
+     */
+    public function testRbacPatchWithNullSitesReturns400AndDoesNotWipeSitesCollection(): void
+    {
+        $em      = $this->getEm();
+        $alice   = $em->getRepository(User::class)->findOneBy(['username' => 'alice']);
+        $aliceId = $alice->getId();
+        self::assertCount(1, $alice->getSites(), 'Pre-condition : alice doit avoir exactement 1 site');
+        $em->clear();
+
+        $client = $this->authenticatedClient('admin', 'admin');
+        $client->request('PATCH', '/api/users/'.$aliceId.'/rbac', [
+            'headers' => ['Content-Type' => 'application/merge-patch+json'],
+            'json'    => [
+                'isAdmin' => false,
+                'sites'   => null,
+            ],
+        ]);
+
+        self::assertResponseStatusCodeSame(400);
+
+        $em = $this->getEm();
+        $em->clear();
+        $reloaded = $em->getRepository(User::class)->find($aliceId);
+        self::assertCount(
+            1,
+            $reloaded->getSites(),
+            'Un payload `sites: null` rejete en 400 ne doit laisser aucune trace en DB.',
+        );
+    }
+
     public function testRbacPatchWithoutSitesFieldDoesNotChangeCurrentSite(): void
     {
         // Garde structurelle : si le payload /rbac ne contient pas le champ
@@ -166,6 +206,87 @@ final class UserRbacSitesApiTest extends AbstractApiTestCase
         $reloaded = $em->getRepository(User::class)->find($aliceId);
         self::assertNotNull($reloaded->getCurrentSite());
         self::assertSame('Chatellerault', $reloaded->getCurrentSite()->getName());
+
+        // Garde non-regression : la collection `sites` elle-meme doit etre
+        // preservee (cf. fix restoreAbsentCollections + initialize LAZY). Un
+        // PATCH /rbac sans cle `sites` ne doit en aucun cas vider la relation.
+        self::assertCount(1, $reloaded->getSites());
+        self::assertSame('Chatellerault', $reloaded->getSites()->first()->getName());
+    }
+
+    public function testRbacPatchWithoutSitesKeyDoesNotAutoSwitchCurrentSiteWhenNull(): void
+    {
+        // Scenario : alice a des sites mais currentSite=null. Un PATCH /rbac
+        // qui ne touche PAS a la clef `sites` ne doit PAS auto-selectionner
+        // silencieusement un site via ensureCurrentSiteConsistency.
+        //
+        // Sans ce garde, un payload { "isAdmin": false } pourrait, si la
+        // denormalisation marque la collection `sites` dirty a tort (ou si
+        // la logique de detection se base sur PersistentCollection::isDirty()
+        // avant restauration), declencher ensureCurrentSiteConsistency et
+        // recaler currentSite sur sites->first() — ce qui est un effet de
+        // bord indetectable par le client.
+        $em      = $this->getEm();
+        $alice   = $em->getRepository(User::class)->findOneBy(['username' => 'alice']);
+        $aliceId = $alice->getId();
+        $alice->setCurrentSite(null);
+        $em->flush();
+        $em->clear();
+
+        $client = $this->authenticatedClient('admin', 'admin');
+        $client->request('PATCH', '/api/users/'.$aliceId.'/rbac', [
+            'headers' => ['Content-Type' => 'application/merge-patch+json'],
+            'json'    => ['isAdmin' => false],
+        ]);
+
+        self::assertResponseIsSuccessful();
+
+        $em = $this->getEm();
+        $em->clear();
+        $reloaded = $em->getRepository(User::class)->find($aliceId);
+        self::assertNotNull($reloaded);
+        // currentSite doit rester null : PATCH /rbac sans clef `sites` ne doit
+        // pas muter la selection de site courant de l'user.
+        self::assertNull(
+            $reloaded->getCurrentSite(),
+            'PATCH /rbac sans clef `sites` ne doit pas auto-selectionner un site.',
+        );
+        // Les sites eux-memes doivent etre preserves.
+        self::assertCount(1, $reloaded->getSites());
+
+        $this->restoreAliceSites();
+    }
+
+    public function testRbacPatchWithoutSitesKeyDoesNotRequireSitesManagePermission(): void
+    {
+        // Scenario Codex : un user non-admin qui porte `core.users.manage`
+        // mais PAS `sites.manage` doit pouvoir PATCHer /rbac sans clef `sites`
+        // sans se faire refuser l'acces.
+        //
+        // Si sitesWereMutated se base uniquement sur PersistentCollection::isDirty()
+        // calcule avant restoreAbsentCollections, une denormalisation qui
+        // marque a tort la collection dirty lorsque la clef est absente du
+        // payload lancerait un 403 parasite. La source de verite doit etre
+        // la presence de la clef dans le payload JSON.
+        $this->skipIfSitesModuleDisabled();
+
+        $em      = $this->getEm();
+        $alice   = $em->getRepository(User::class)->findOneBy(['username' => 'alice']);
+        $aliceId = $alice->getId();
+        $em->clear();
+
+        // User jetable : core.users.manage uniquement (pas sites.manage).
+        $creds  = $this->createUserWithPermission('core.users.manage');
+        $client = $this->authenticatedClient($creds['username'], $creds['password']);
+
+        $client->request('PATCH', '/api/users/'.$aliceId.'/rbac', [
+            'headers' => ['Content-Type' => 'application/merge-patch+json'],
+            'json'    => ['isAdmin' => false],
+        ]);
+
+        // Pas de 403 : la requete ne touche pas aux sites, sites.manage n'est
+        // pas requis.
+        self::assertResponseIsSuccessful();
     }
 
     /**

tests/Module/Core/Infrastructure/ApiPlatform/State/Processor/UserRbacProcessorTest.php

@@ -21,6 +21,8 @@ use PHPUnit\Framework\TestCase;
 use ReflectionClass;
 use stdClass;
 use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\RequestStack;
 use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
 
 /**
@@ -38,6 +40,7 @@ final class UserRbacProcessorTest extends TestCase
     private MockObject&UnitOfWork $unitOfWork;
     private MockObject&Security $security;
     private AdminHeadcountGuardInterface&MockObject $adminHeadcountGuard;
+    private RequestStack $requestStack;
     private UserRbacProcessor $processor;
 
     protected function setUp(): void
@@ -48,6 +51,12 @@ final class UserRbacProcessorTest extends TestCase
         $this->security            = $this->createMock(Security::class);
         $this->adminHeadcountGuard = $this->createMock(AdminHeadcountGuardInterface::class);
 
+        // Request vide par defaut pour les tests existants : la garde
+        // anti-ecrasement (restoreAbsentCollections) no-op quand le body est ''
+        // donc elle n'interfere pas avec les assertions deja en place.
+        $this->requestStack = new RequestStack();
+        $this->requestStack->push(new Request());
+
         $this->entityManager->method('getUnitOfWork')->willReturn($this->unitOfWork);
 
         // wrapInTransaction doit executer reellement la closure pour que le
@@ -63,6 +72,7 @@ final class UserRbacProcessorTest extends TestCase
             $this->entityManager,
             $this->security,
             $this->adminHeadcountGuard,
+            $this->requestStack,
         );
     }
 

tests/Module/Core/Infrastructure/Audit/AuditLogWriterTest.php

@@ -0,0 +1,190 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Module\Core\Infrastructure\Audit;
+
+use App\Module\Core\Infrastructure\Audit\AuditLogWriter;
+use App\Module\Core\Infrastructure\Audit\RequestIdProvider;
+use Doctrine\DBAL\Connection;
+use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
+use PHPUnit\Framework\TestCase;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\Security\Core\User\InMemoryUser;
+
+/**
+ * Tests unitaires de l'AuditLogWriter.
+ *
+ * Verifie les invariants critiques :
+ *  - filtrage des cles sensibles (defense-in-depth par rapport a #[AuditIgnore]) ;
+ *  - utilisation du username courant ou "system" en CLI ;
+ *  - captation IP + request_id si requete HTTP presente ;
+ *  - generation d'un UUID v7 (tri chronologique implicite en PK).
+ *
+ * Aucune BDD : la connexion DBAL est mockee pour capturer l'insert.
+ *
+ * @internal
+ */
+#[AllowMockObjectsWithoutExpectations]
+final class AuditLogWriterTest extends TestCase
+{
+    /**
+     * @var null|array{0: string, 1: array<string, mixed>, 2: array<string, mixed>}
+     *
+     * Capture de l'appel `insert()` : [$table, $data, $types]
+     */
+    private ?array $capturedInsert = null;
+
+    private Connection $connection;
+
+    private RequestStack $requestStack;
+
+    private RequestIdProvider $requestIdProvider;
+
+    protected function setUp(): void
+    {
+        $this->capturedInsert = null;
+
+        $this->connection = $this->createMock(Connection::class);
+        $this->connection
+            ->method('insert')
+            ->willReturnCallback(function (string $table, array $data, array $types = []): int {
+                $this->capturedInsert = [$table, $data, $types];
+
+                return 1;
+            })
+        ;
+
+        $this->requestStack      = new RequestStack();
+        $this->requestIdProvider = new RequestIdProvider();
+    }
+
+    public function testLogsCreateWithAuthenticatedUser(): void
+    {
+        $security = $this->buildSecurityWithUser('alice');
+        $writer   = new AuditLogWriter($this->connection, $security, $this->requestStack, $this->requestIdProvider);
+
+        $writer->log('core.User', '42', 'create', ['username' => 'alice']);
+
+        $this->assertNotNull($this->capturedInsert);
+        [$table, $data] = $this->capturedInsert;
+        $this->assertSame('audit_log', $table);
+        $this->assertSame('core.User', $data['entity_type']);
+        $this->assertSame('42', $data['entity_id']);
+        $this->assertSame('create', $data['action']);
+        $this->assertSame(['username' => 'alice'], $data['changes']);
+        $this->assertSame('alice', $data['performed_by']);
+    }
+
+    public function testUsesSystemWhenNoAuthenticatedUser(): void
+    {
+        $security = $this->buildSecurityWithUser(null);
+        $writer   = new AuditLogWriter($this->connection, $security, $this->requestStack, $this->requestIdProvider);
+
+        $writer->log('core.User', '1', 'update', ['isAdmin' => ['old' => false, 'new' => true]]);
+
+        $this->assertSame('system', $this->capturedInsert[1]['performed_by']);
+    }
+
+    public function testStripsSensitiveKeys(): void
+    {
+        $security = $this->buildSecurityWithUser('alice');
+        $writer   = new AuditLogWriter($this->connection, $security, $this->requestStack, $this->requestIdProvider);
+
+        $writer->log('core.User', '1', 'create', [
+            'username'      => 'bob',
+            'password'      => 'topsecrethash',
+            'plainPassword' => 'clear',
+            'token'         => 'abc',
+            'secret'        => 'xyz',
+            'email'         => 'bob@example.com',
+        ]);
+
+        $changes = $this->capturedInsert[1]['changes'];
+        $this->assertArrayNotHasKey('password', $changes);
+        $this->assertArrayNotHasKey('plainPassword', $changes);
+        $this->assertArrayNotHasKey('token', $changes);
+        $this->assertArrayNotHasKey('secret', $changes);
+        $this->assertSame('bob', $changes['username']);
+        $this->assertSame('bob@example.com', $changes['email']);
+    }
+
+    public function testStripsSensitiveKeysRecursively(): void
+    {
+        // Defense-in-depth : un appelant direct peut passer un payload
+        // imbrique (ex: relations embarquees). Les cles sensibles doivent
+        // etre supprimees a tous les niveaux de profondeur.
+        $security = $this->buildSecurityWithUser('alice');
+        $writer   = new AuditLogWriter($this->connection, $security, $this->requestStack, $this->requestIdProvider);
+
+        $writer->log('core.User', '1', 'create', [
+            'username' => 'bob',
+            'profile'  => [
+                'email'    => 'bob@example.com',
+                'password' => 'leaked_in_nested',
+                'nested'   => [
+                    'token'    => 'should_be_stripped',
+                    'harmless' => 'kept',
+                ],
+            ],
+        ]);
+
+        $changes = $this->capturedInsert[1]['changes'];
+        $this->assertArrayNotHasKey('password', $changes['profile']);
+        $this->assertArrayNotHasKey('token', $changes['profile']['nested']);
+        $this->assertSame('kept', $changes['profile']['nested']['harmless']);
+        $this->assertSame('bob@example.com', $changes['profile']['email']);
+    }
+
+    public function testCapturesIpAddressWhenRequestPresent(): void
+    {
+        $request = Request::create('/api/users', 'POST');
+        $request->server->set('REMOTE_ADDR', '203.0.113.42');
+        $this->requestStack->push($request);
+
+        $security = $this->buildSecurityWithUser('alice');
+        $writer   = new AuditLogWriter($this->connection, $security, $this->requestStack, $this->requestIdProvider);
+
+        $writer->log('core.User', '1', 'create', []);
+
+        $this->assertSame('203.0.113.42', $this->capturedInsert[1]['ip_address']);
+    }
+
+    public function testIpAddressNullInCli(): void
+    {
+        $security = $this->buildSecurityWithUser(null);
+        $writer   = new AuditLogWriter($this->connection, $security, $this->requestStack, $this->requestIdProvider);
+
+        $writer->log('core.User', '1', 'create', []);
+
+        $this->assertNull($this->capturedInsert[1]['ip_address']);
+        $this->assertNull($this->capturedInsert[1]['request_id']);
+    }
+
+    public function testGeneratesUuidV7PrimaryKey(): void
+    {
+        $security = $this->buildSecurityWithUser('alice');
+        $writer   = new AuditLogWriter($this->connection, $security, $this->requestStack, $this->requestIdProvider);
+
+        $writer->log('core.User', '1', 'create', []);
+
+        $id = $this->capturedInsert[1]['id'];
+        // UUID v7 : le 13e caractere (apres les tirets) vaut "7".
+        // Format : xxxxxxxx-xxxx-7xxx-xxxx-xxxxxxxxxxxx
+        $this->assertMatchesRegularExpression(
+            '/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12}$/i',
+            $id
+        );
+    }
+
+    private function buildSecurityWithUser(?string $username): Security
+    {
+        $security = $this->createMock(Security::class);
+        $user     = null !== $username ? new InMemoryUser($username, 'pwd') : null;
+        $security->method('getUser')->willReturn($user);
+
+        return $security;
+    }
+}

tests/Module/Core/Infrastructure/Doctrine/AuditListenerTest.php

@@ -0,0 +1,423 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Module\Core\Infrastructure\Doctrine;
+
+use App\Module\Core\Domain\Entity\Permission;
+use App\Module\Core\Domain\Entity\Role;
+use App\Module\Core\Domain\Entity\User;
+use App\Module\Core\Infrastructure\Doctrine\AuditListener;
+use Doctrine\DBAL\Connection;
+use Doctrine\ORM\EntityManagerInterface;
+use ReflectionProperty;
+use stdClass;
+use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
+use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
+
+/**
+ * Tests d'integration de l'AuditListener.
+ *
+ * Contrairement aux tests unitaires du writer, on fait tourner le kernel
+ * complet pour verifier que le listener est bien cable et que les attributs
+ * #[Auditable] / #[AuditIgnore] sur User sont respectes jusqu'a l'insert
+ * final dans audit_log.
+ *
+ * Strategie de nettoyage : chaque test supprime ses fixtures dans tearDown
+ * (pas de rollback transactionnel DAMA sur ce projet).
+ *
+ * @internal
+ */
+final class AuditListenerTest extends KernelTestCase
+{
+    private EntityManagerInterface $em;
+
+    private Connection $auditConnection;
+
+    /** @var list<int> IDs de users crees par le test (nettoyage en tearDown) */
+    private array $createdUserIds = [];
+
+    /** @var list<int> IDs de roles crees par le test (nettoyage en tearDown) */
+    private array $createdRoleIds = [];
+
+    private string $testRunTag;
+
+    protected function setUp(): void
+    {
+        self::bootKernel();
+
+        /** @var EntityManagerInterface $em */
+        $em       = self::getContainer()->get('doctrine')->getManager();
+        $this->em = $em;
+
+        /** @var Connection $conn */
+        $conn                  = self::getContainer()->get('doctrine.dbal.audit_connection');
+        $this->auditConnection = $conn;
+
+        // Tag unique par run pour filtrer les lignes audit_log produites
+        // exclusivement par ce test (la table n'a ni truncate ni rollback).
+        $this->testRunTag = 'audittest'.bin2hex(random_bytes(4));
+    }
+
+    protected function tearDown(): void
+    {
+        // Suppression explicite des users crees (cascade sur user_role /
+        // user_site via les ORM mappings) + nettoyage des lignes audit
+        // correspondantes pour ne pas polluer les runs suivants.
+        if ([] !== $this->createdUserIds) {
+            foreach ($this->createdUserIds as $id) {
+                $user = $this->em->find(User::class, $id);
+                if (null !== $user) {
+                    $this->em->remove($user);
+                }
+            }
+            $this->em->flush();
+        }
+
+        if ([] !== $this->createdRoleIds) {
+            foreach ($this->createdRoleIds as $id) {
+                $role = $this->em->find(Role::class, $id);
+                if (null !== $role) {
+                    $this->em->remove($role);
+                }
+            }
+            $this->em->flush();
+            // Nettoie egalement les lignes audit de ces roles (entity_id est
+            // une colonne text, on delete en boucle pour simplifier le binding).
+            foreach ($this->createdRoleIds as $id) {
+                $this->auditConnection->executeStatement(
+                    'DELETE FROM audit_log WHERE entity_type = \'core.Role\' AND entity_id = :id',
+                    ['id' => (string) $id],
+                );
+            }
+        }
+
+        $this->auditConnection->executeStatement(
+            "DELETE FROM audit_log WHERE entity_type = 'core.User' AND changes->>'username' LIKE :tag",
+            ['tag' => $this->testRunTag.'%'],
+        );
+
+        // Libere la connexion PG : en test, le kernel reboote par test et
+        // sans close explicite, la connexion `audit` reste ouverte jusqu'au
+        // TTL Doctrine, saturant le pool sur une suite de 200+ tests.
+        $this->auditConnection->close();
+
+        parent::tearDown();
+    }
+
+    public function testLogsCreateOnUserInsertion(): void
+    {
+        $user = $this->makeUser();
+
+        $this->em->persist($user);
+        $this->em->flush();
+        $this->createdUserIds[] = $user->getId();
+
+        $rows = $this->fetchAuditRows($user->getId());
+
+        $this->assertCount(1, $rows, 'Une ligne audit attendue a la creation');
+        $row = $rows[0];
+        $this->assertSame('core.User', $row['entity_type']);
+        $this->assertSame('create', $row['action']);
+        $this->assertSame((string) $user->getId(), $row['entity_id']);
+
+        $changes = json_decode($row['changes'], true, 512, JSON_THROW_ON_ERROR);
+        $this->assertArrayHasKey('username', $changes);
+        $this->assertArrayNotHasKey('password', $changes, 'password doit etre #[AuditIgnore]');
+        $this->assertArrayNotHasKey('plainPassword', $changes, 'plainPassword doit etre #[AuditIgnore]');
+    }
+
+    public function testLogsUpdateWithDiff(): void
+    {
+        $user = $this->makeUser();
+        $this->em->persist($user);
+        $this->em->flush();
+        $this->createdUserIds[] = $user->getId();
+
+        // Reset de la baseline : on ne garde que la ligne update.
+        $this->auditConnection->executeStatement(
+            'DELETE FROM audit_log WHERE entity_id = :id AND entity_type = \'core.User\'',
+            ['id' => (string) $user->getId()],
+        );
+
+        $user->setIsAdmin(true);
+        $this->em->flush();
+
+        $rows = $this->fetchAuditRows($user->getId());
+        $this->assertCount(1, $rows);
+        $this->assertSame('update', $rows[0]['action']);
+
+        $changes = json_decode($rows[0]['changes'], true, 512, JSON_THROW_ON_ERROR);
+        $this->assertArrayHasKey('isAdmin', $changes);
+        $this->assertSame(false, $changes['isAdmin']['old']);
+        $this->assertSame(true, $changes['isAdmin']['new']);
+    }
+
+    public function testLogsDeleteSnapshot(): void
+    {
+        $user = $this->makeUser();
+        $this->em->persist($user);
+        $this->em->flush();
+        $userId = $user->getId();
+
+        $this->em->remove($user);
+        $this->em->flush();
+
+        $rows = $this->fetchAuditRows($userId);
+        // Deux lignes : la creation + la suppression.
+        $actions = array_column($rows, 'action');
+        $this->assertContains('delete', $actions);
+
+        $deleteRow = $rows[array_search('delete', $actions, true)];
+        $changes   = json_decode($deleteRow['changes'], true, 512, JSON_THROW_ON_ERROR);
+        $this->assertArrayHasKey('username', $changes);
+        $this->assertArrayNotHasKey('password', $changes);
+
+        // On nettoie a la main les lignes restantes (user deja delete).
+        $this->auditConnection->executeStatement(
+            'DELETE FROM audit_log WHERE entity_id = :id AND entity_type = \'core.User\'',
+            ['id' => (string) $userId],
+        );
+    }
+
+    /**
+     * Regression test : une entite recuperee via `getReference()` (proxy /
+     * ghost object lazy) doit etre auditee avec le FQCN canonique. Sur
+     * Doctrine ORM 3 + PHP 8.4, les lazy ghosts preservent `::class` reel
+     * — mais sous Doctrine 2 ou en cas de retour a un `__CG__\` proxy,
+     * l'audit doit toujours resoudre la classe via `ClassMetadata` et
+     * jamais aboutir a un `entity_type` de type `Proxies\__CG__\...\User`.
+     */
+    public function testLogsUpdateOnProxyEntity(): void
+    {
+        $user = $this->makeUser();
+        $this->em->persist($user);
+        $this->em->flush();
+        $userId                 = (int) $user->getId();
+        $this->createdUserIds[] = $userId;
+
+        // Detache puis recupere via getReference : sur Doctrine 2, renvoie
+        // un `Proxies\__CG__\...\User` ; sur Doctrine 3 + PHP 8.4 le ghost
+        // object reste instance de la classe reelle — dans tous les cas la
+        // resolution via ClassMetadata doit produire un audit correct.
+        $this->em->clear();
+
+        $proxy = $this->em->getReference(User::class, $userId);
+        self::assertNotNull($proxy);
+
+        // Reset de la baseline : on ne garde que la ligne update du proxy.
+        $this->auditConnection->executeStatement(
+            'DELETE FROM audit_log WHERE entity_id = :id AND entity_type = \'core.User\'',
+            ['id' => (string) $userId],
+        );
+
+        $proxy->setIsAdmin(true);
+        $this->em->flush();
+
+        $rows = $this->fetchAuditRows($userId);
+        self::assertCount(1, $rows, 'La mutation sur un proxy doit etre auditee.');
+        self::assertSame('update', $rows[0]['action']);
+        // L'entity_type doit etre le FQCN canonique, pas celui du proxy.
+        self::assertSame('core.User', $rows[0]['entity_type']);
+    }
+
+    /**
+     * Verifie que l'ajout d'une permission a un role est bien audite sous
+     * la forme `{permissions: {added: [id], removed: []}}`. Regression test
+     * pour le bug "ManyToMany collections ignorees par getEntityChangeSet".
+     */
+    public function testLogsManyToManyCollectionAddition(): void
+    {
+        $roleCode = 'audittest_'.bin2hex(random_bytes(3));
+        $role     = new Role($roleCode, 'Test role '.$roleCode);
+        $this->em->persist($role);
+        $this->em->flush();
+        $roleId                 = (int) $role->getId();
+        $this->createdRoleIds[] = $roleId;
+
+        // Reset baseline : on ne veut que le log de l'update de collection.
+        $this->auditConnection->executeStatement(
+            'DELETE FROM audit_log WHERE entity_type = \'core.Role\' AND entity_id = :id',
+            ['id' => (string) $roleId],
+        );
+
+        // Recupere une permission existante (fixtures garantissent core.users.view).
+        $permission = $this->em->getRepository(Permission::class)->findOneBy(['code' => 'core.users.view']);
+        self::assertNotNull($permission, 'Fixture core.users.view manquante.');
+
+        $role->addPermission($permission);
+        $this->em->flush();
+
+        $rows = $this->fetchRoleAuditRows($roleId);
+        self::assertCount(1, $rows, 'Une ligne update attendue pour l\'ajout de permission.');
+        self::assertSame('update', $rows[0]['action']);
+
+        $changes = json_decode($rows[0]['changes'], true, 512, JSON_THROW_ON_ERROR);
+        self::assertArrayHasKey('permissions', $changes, 'Le changeset doit contenir le champ "permissions".');
+        self::assertSame([], $changes['permissions']['removed']);
+        self::assertSame([(int) $permission->getId()], $changes['permissions']['added']);
+    }
+
+    /**
+     * Symetrique : retirer une permission d'un role est audite sous
+     * `{permissions: {added: [], removed: [id]}}`.
+     */
+    public function testLogsManyToManyCollectionRemoval(): void
+    {
+        $permission = $this->em->getRepository(Permission::class)->findOneBy(['code' => 'core.users.view']);
+        self::assertNotNull($permission);
+
+        $roleCode = 'audittest_'.bin2hex(random_bytes(3));
+        $role     = new Role($roleCode, 'Test role '.$roleCode);
+        $role->addPermission($permission);
+        $this->em->persist($role);
+        $this->em->flush();
+        $roleId                 = (int) $role->getId();
+        $this->createdRoleIds[] = $roleId;
+
+        // Reset baseline.
+        $this->auditConnection->executeStatement(
+            'DELETE FROM audit_log WHERE entity_type = \'core.Role\' AND entity_id = :id',
+            ['id' => (string) $roleId],
+        );
+
+        $role->removePermission($permission);
+        $this->em->flush();
+
+        $rows = $this->fetchRoleAuditRows($roleId);
+        self::assertCount(1, $rows);
+        $changes = json_decode($rows[0]['changes'], true, 512, JSON_THROW_ON_ERROR);
+        self::assertSame([], $changes['permissions']['added']);
+        self::assertSame([(int) $permission->getId()], $changes['permissions']['removed']);
+    }
+
+    /**
+     * Regression test : supprimer un role avec des permissions attachees doit
+     * preserver la liste des permissions dans le snapshot delete. C'etait le
+     * trou principal du fix ManyToMany initial (reviewer Codex round 2).
+     */
+    public function testDeleteSnapshotIncludesManyToManyIds(): void
+    {
+        $permission = $this->em->getRepository(Permission::class)->findOneBy(['code' => 'core.users.view']);
+        self::assertNotNull($permission);
+
+        $roleCode = 'audittest_'.bin2hex(random_bytes(3));
+        $role     = new Role($roleCode, 'Delete test '.$roleCode);
+        $role->addPermission($permission);
+        $this->em->persist($role);
+        $this->em->flush();
+        $roleId = (int) $role->getId();
+
+        $this->em->remove($role);
+        $this->em->flush();
+
+        $rows = $this->fetchRoleAuditRows($roleId);
+        // create + update (permission ajoutee) + delete attendus.
+        $actions = array_column($rows, 'action');
+        self::assertContains('delete', $actions);
+
+        $deleteRow = $rows[array_search('delete', $actions, true)];
+        $changes   = json_decode($deleteRow['changes'], true, 512, JSON_THROW_ON_ERROR);
+
+        // Le snapshot delete doit contenir la liste des IDs de permissions
+        // attachees au role au moment de la suppression.
+        self::assertArrayHasKey('permissions', $changes);
+        self::assertSame([(int) $permission->getId()], $changes['permissions']);
+
+        // Nettoyage manuel (le role est deja supprime, on ne peut plus passer par $this->em).
+        $this->auditConnection->executeStatement(
+            'DELETE FROM audit_log WHERE entity_type = \'core.Role\' AND entity_id = :id',
+            ['id' => (string) $roleId],
+        );
+    }
+
+    /**
+     * Regression : quand un flush precedent a leve une exception avant
+     * d'atteindre postFlush, `$pendingLogs` reste rempli avec des changements
+     * jamais committes. Le flush suivant doit les ecraser, pas les fusionner —
+     * sinon audit_log contient des lignes pour des evenements qui n'ont pas
+     * eu lieu en base.
+     *
+     * Reproduction : on injecte manuellement une entree orpheline dans le
+     * listener (comme si un flush precedent l'avait capturee puis avait plante),
+     * on declenche un flush valide, et on verifie que l'orpheline n'apparait
+     * jamais dans audit_log.
+     */
+    public function testOnFlushResetsStalePendingLogsFromFailedPreviousFlush(): void
+    {
+        /** @var AuditListener $listener */
+        $listener = self::getContainer()->get(AuditListener::class);
+
+        // Injecte une entree orpheline : comme si onFlush avait capture ce
+        // changement, puis que le flush avait plante avant postFlush.
+        $reflection = new ReflectionProperty($listener, 'pendingLogs');
+        $reflection->setValue($listener, [[
+            'entity'     => new stdClass(),
+            'metadata'   => null,
+            'entityType' => 'test.StaleEntity',
+            'action'     => 'create',
+            'changes'    => ['fake' => ['old' => null, 'new' => 'stale']],
+            'capturedId' => 'stale-id-'.$this->testRunTag,
+        ]]);
+
+        // Flush valide qui DOIT re-initialiser pendingLogs avant de capturer
+        // ses propres changements.
+        $user = $this->makeUser();
+        $this->em->persist($user);
+        $this->em->flush();
+        $this->createdUserIds[] = $user->getId();
+
+        $staleRows = $this->auditConnection->fetchAllAssociative(
+            'SELECT * FROM audit_log WHERE entity_type = :t',
+            ['t' => 'test.StaleEntity'],
+        );
+
+        self::assertCount(
+            0,
+            $staleRows,
+            'Une entree orpheline d\'un flush precedent ne doit pas fuiter dans audit_log.',
+        );
+
+        // Sanity : le vrai flush a quand meme bien ecrit sa propre ligne.
+        $userRows = $this->fetchAuditRows($user->getId());
+        self::assertCount(1, $userRows);
+        self::assertSame('create', $userRows[0]['action']);
+    }
+
+    /**
+     * @return list<array{id: string, entity_type: string, entity_id: string, action: string, changes: string}>
+     */
+    private function fetchAuditRows(int $userId): array
+    {
+        // @var list<array{id: string, entity_type: string, entity_id: string, action: string, changes: string}> $rows
+        return $this->auditConnection->fetchAllAssociative(
+            'SELECT id, entity_type, entity_id, action, changes FROM audit_log WHERE entity_type = :type AND entity_id = :id ORDER BY performed_at ASC',
+            ['type' => 'core.User', 'id' => (string) $userId],
+        );
+    }
+
+    private function makeUser(): User
+    {
+        /** @var UserPasswordHasherInterface $hasher */
+        $hasher = self::getContainer()->get(UserPasswordHasherInterface::class);
+
+        $user = new User();
+        $user->setUsername($this->testRunTag.'_'.bin2hex(random_bytes(2)));
+        $user->setIsAdmin(false);
+        $user->setPassword($hasher->hashPassword($user, 'testpass'));
+
+        return $user;
+    }
+
+    /**
+     * @return list<array{id: string, entity_type: string, entity_id: string, action: string, changes: string}>
+     */
+    private function fetchRoleAuditRows(int $roleId): array
+    {
+        // @var list<array{id: string, entity_type: string, entity_id: string, action: string, changes: string}> $rows
+        return $this->auditConnection->fetchAllAssociative(
+            'SELECT id, entity_type, entity_id, action, changes FROM audit_log WHERE entity_type = :type AND entity_id = :id ORDER BY performed_at ASC',
+            ['type' => 'core.Role', 'id' => (string) $roleId],
+        );
+    }
+}