chore: bump version to v0.1.114

## Résumé
Nouvel export PDF **Contingent heures de nuit** dans le drawer Export de la liste employés.

- PDF **A4 paysage** : lignes = employés (groupés par site, triés displayOrder/nom/prénom), colonnes = 12 mois civils, chaque mois avec 2 sous-colonnes **H.nuit** et **N.jours**.
- Heures de nuit = minutes dans la fenêtre **21h→6h** via un service partagé `NightHoursCalculator` (mutualisé avec `WorkHourWeeklySummaryProvider` et `YearlyHoursExportBuilder` — duplication supprimée, sans changement de comportement).
- **Conducteurs inclus** via `WorkHour.nightHoursMinutes`. Statut conducteur résolu par date.
- **N.jours** = nb de jours où les minutes de nuit ≥ 240 (4h). Aucun crédit absence/férié.
- Périmètre via `EmployeeRepository::findScoped` (admin → tous, chef de site → ses sites), endpoint `GET /night-hours-contingent/print?year=YYYY` (`ROLE_USER`).
- Sélecteur d'année (année civile). Colonne Nom calibrée, séparateurs de mois épais.

## Composants
- Service `NightHoursCalculator`, builder `NightContingentExportBuilder`, DTO `NightContingentRow`
- Provider `NightHoursContingentPrintProvider` + opération API `NightHoursContingentPrint`
- Gabarit `templates/night-hours-contingent/print.html.twig`
- Option frontend dans `frontend/pages/employees/index.vue`
- Docs : `doc/functional-rules.md`, `CLAUDE.md`, `frontend/data/documentation-content.ts`

## Tests
- Nouveaux tests unitaires : `NightHoursCalculatorTest` (fenêtre 21h→6h, passage minuit, bornes), `NightContingentExportBuilderTest` (agrégation mensuelle, règle ≥4h=1j, conducteur, cas sans heures)
- Suite complète : **208 tests OK**
- Rendu PDF validé visuellement (Twig→Dompdf)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

CLAUDE.md

@@ -35,7 +35,8 @@
 - Employee contract history: `employee_contract_periods`, resolved by `EmployeeContractResolver`
 - **Écrans Heures / Heures Conducteurs (vue jour)** : le libellé nature (CDI/CDD/Intérim) sous le nom de l'employé est résolu **à la date filtrée** via `WorkHourDayContext.contractNature` (alimenté par `EmployeeContractResolver::resolveNatureForEmployeeAndDate`), pas via `Employee.currentContractNature` (qui est résolu à aujourd'hui). Idem pour le **mode de suivi (TIME/PRESENCE), les heures hebdo et le libellé de contrat** sur la vue Jour : résolus à la date filtrée via `WorkHourDayContext` (`trackingMode`/`weeklyHours`/`contractType`/`contractName`, peuplés depuis `EmployeeContractResolver::resolveForEmployeeAndDate`), pas via `employee.contract` (résolu à aujourd'hui). Côté front, `resolveDayContract()` (`useHoursPage.ts`) pilote l'affichage et `handleSave` (heures vs présence par date).
 - **Exports heures annuelles** (par salarié `EmployeeYearlyHoursPrintProvider` + tous `EmployeeYearlyHoursBulkPrintProvider`, via `YearlyHoursExportBuilder`) : **tous les jours sous contrat sont affichés**, même vides ou non saisis (jusqu'à aujourd'hui). Seuls les jours hors contrat sont omis (`buildSegments` : un seul filtre `!$hasData && null === $contract`). Ne pas réintroduire de saut des jours de semaine vides. Samedis/dimanches grisés (`#c0c0c0`) dans les templates `employee-yearly-hours/print*.html.twig`. NB : l'export *tous employés* sur l'année peut dépasser `memory_limit=256M` (Dompdf) — limitation pré-existante, voir avec l'infra si besoin.
-- **Export heures vue Jour** (`WorkHourDayExportProvider`, endpoint `GET /work-hours/day-export?workDate=&siteIds=`, `ROLE_ADMIN`) : bouton « Exporter » à droite du titre « Heures », **visible uniquement en vue Jour** (`v-if="isAdmin && viewMode === 'day'"`, masqué en vue Semaine). PDF A4 portrait d'**une seule journée**, **regroupé par site**, colonnes de la vue Jour **sans « Valider »** (colonne **Total en gras**). Mêmes employés que l'écran : non-conducteurs, sous contrat à la date, sites cochés (lignes vides incluses). Calcul des cellules mutualisé via `YearlyHoursExportBuilder::buildDayRowsForEmployees` (Jour/Nuit/Total incluent crédit absence + crédit virtuel férié). Colonne **Statut = code** du type d'absence (`AbsenceType::getCode`, ex. `AT`) sur sa couleur de fond ; férié sans absence → nom du férié sur `#b3e5fc`. Chaque row porte `statut` (code), `statutLabel` (libellé, pour la légende) et `statutColor`. **Légende** sous le tableau (carré coloré contenant le code + libellé à droite), construite côté provider à partir des codes présents (hors férié, dédupliquée par code, triée). Gabarit `templates/work-hour-day-export/print.html.twig`.
+- **Export heures vue Jour** (`WorkHourDayExportProvider`, endpoint `GET /work-hours/day-export?workDate=&siteIds=`, `ROLE_USER`) : bouton « Exporter » à droite du titre « Heures », **visible uniquement en vue Jour** (`v-if="(isAdmin || isSiteManager) && viewMode === 'day'"`, masqué en vue Semaine et pour `ROLE_SELF`). **Accessible aux admins ET aux chefs de site** : le périmètre est résolu côté backend via `EmployeeRepository::findScoped($user)` (admin → tous les sites, chef de site → ses sites uniquement, cf. `EmployeeScopeService`), donc un `siteIds` hors périmètre est ignoré ; le drawer front ne propose que les sites visibles (`sites` dérivé des employés scopés). PDF A4 portrait d'**une seule journée**, **regroupé par site**, colonnes de la vue Jour **sans « Valider »** (colonne **Total en gras**). Mêmes employés que l'écran : non-conducteurs, sous contrat à la date, sites cochés et dans le périmètre (lignes vides incluses). **Tri intra-site identique au calendrier** : `displayOrder` (ordre manuel), puis nom, puis prénom (cf. `compareEmployeesInSite` front). Calcul des cellules mutualisé via `YearlyHoursExportBuilder::buildDayRowsForEmployees` (Jour/Nuit/Total incluent crédit absence + crédit virtuel férié). Colonne **Statut = code** du type d'absence (`AbsenceType::getCode`, ex. `AT`) sur sa couleur de fond ; férié sans absence → nom du férié sur `#b3e5fc`. Chaque row porte `statut` (code), `statutLabel` (libellé, pour la légende) et `statutColor`. **Légende** sous le tableau (carré coloré contenant le code + libellé à droite), construite côté provider à partir des codes présents (hors férié, dédupliquée par code, triée). Gabarit `templates/work-hour-day-export/print.html.twig`.
+- **Export Contingent heures de nuit** (`NightHoursContingentPrintProvider`, endpoint `GET /night-hours-contingent/print?year=YYYY`, `ROLE_USER`) : option « Contingent H.nuit » du drawer Export de la liste employés. PDF **A4 paysage**, lignes = employés **groupés par site** et triés `displayOrder`/nom/prénom (comme le day-export), colonnes = 12 mois civils, chacun avec 2 sous-colonnes **H.nuit** et **N.jours**. Heures de nuit = minutes dans la fenêtre **21h→6h** via le service partagé `App\Service\WorkHours\NightHoursCalculator` (source unique mutualisée avec `WorkHourWeeklySummaryProvider`, `YearlyHoursExportBuilder`, `RttRecoveryComputationService` et `SalaryRecapPrintProvider`). Conducteurs inclus via `WorkHour.nightHoursMinutes`. **N.jours** = nb de jours où minutes de nuit ≥ 240 (4h). **Aucun crédit** absence/férié. Agrégation : `App\Service\WorkHours\NightContingentExportBuilder`. Gabarit `templates/night-hours-contingent/print.html.twig`.
 - **Écran Calendrier** : un employé est affiché uniquement si au moins une de ses périodes de contrat (`employee.contractHistory`) intersecte le mois affiché (`[1er ; dernier jour]`). Filtre côté frontend dans `visibleEmployees` (`pages/calendar.vue`). **L'impression PDF des absences applique le même filtre** côté backend (`AbsencePrintProvider::hasContractInRange` sur la période `[from, to]`) : un salarié parti en avril n'apparaît pas sur une impression de mai. **Le récap salaire applique le même filtre** (`SalaryRecapPrintProvider::hasContractInRange` sur le mois imprimé) : un salarié sans contrat sur le mois (ex. parti en février) n'apparaît pas sur le récap de juin.
 - **Planning jours travaillés** (`EmployeeContractPeriod.workDaysHours` : JSON `{iso_day: minutes}`) : obligatoire pour tout contrat TIME **hors 35h/39h/INTERIM** (ex. 4h, 25h, 28h). Somme = `weeklyHours × 60`. Utilisé par `HolidayVirtualHoursResolver` (crédit férié) et `WorkedHoursCreditPolicy` (crédit absence) pour ne créditer que les jours effectivement travaillés. Validation : `EmployeeContractPeriodValidator::assertWorkDaysHours`.
 - Absences: stored per day (auto-split), AM/PM/full day, clear corresponding hour slots
@@ -66,7 +67,8 @@
 ## Overtime Rules
 - Contracts <= 35h: +25% from 35h to 43h, +50% beyond
 - Contracts >= 39h: +25% from 39h to 43h, +50% beyond
-- CUSTOM contracts (weeklyHours ≠ 35 and ≠ 39, not INTERIM/FORFAIT): reference = actual contractual hours, no 25%/50% bonuses (1h overtime = 1h recovery), deficit doesn't impact balance
+- CUSTOM contracts (weeklyHours ≠ 35 and ≠ 39, not INTERIM/FORFAIT): reference = actual contractual hours, no 25%/50% bonuses (1h overtime = 1h recovery). **Le déficit (heures travaillées < heures contractuelles) réduit le cumul RTT 1:1** (peut devenir négatif, reporté à l'exercice suivant). Implémenté via `WeekRecoveryDetail::isFlatRecovery` / `EmployeeRttWeekSummary::isFlatRecovery` : ces semaines portent leur récup/déficit signé dans `totalMinutes` (`RttRecoveryComputationService::buildWeekRecoveryDetail`) et `EmployeeRttSummaryProvider::applyDeficitCascade` **ne draine pas** les tranches 25/50 pour elles (colonnes 25%/50% restent à 0). Le `RttClosingBalanceService::fold` reporte le déficit en N+1.
+  - **Jour de solidarité (Lundi de Pentecôte) — CUSTOM < 35h** : le jour est neutralisé et chargé d'un déficit forfaitaire `7/35 × weeklyHours` = **12 min par heure hebdo** (4h→48 min, 25h→5h, 28h→5h36), retranché du cumul RTT (signé, reporté N+1, ne draine pas les tranches 25/50 qui restent à 0). Net = exactement −prorata quel que soit ce qui est posé ce jour-là (RTT, heures, vide) → pas de double comptage avec le RTT que la RH pose aussi sur ce jour. Hors périmètre : 35h/39h/Forfait/Intérim et CUSTOM ≥ 35h (inchangés ; la RH y pose un RTT qui draine ~7h). Date via `App\Service\Rtt\SolidarityDayResolver` (computus, indépendant d'`EXCLUDED_PUBLIC_HOLIDAYS`). Appliqué dans `RttRecoveryComputationService::{resolveSolidarityDatesInRange, computeSolidarityDeficitAdjustment}`.
 - **Ancre de semaine (type de contrat)** : le type/nature de contrat d'une semaine RTT est résolu sur le **premier jour contracté** de la semaine, pas sur le lundi (`RttRecoveryComputationService::resolveWeekAnchorDate`). Sinon une semaine d'embauche en milieu de semaine (lundi hors contrat) serait classée CUSTOM → bonus 25%/50% désactivés à tort. Ex. CDD 39h embauché le jeudi : la semaine reste 39h, le seuil 25% est proraté aux jours contractés (`computeWeeklyOvertime25StartMinutes`), donc les heures au-delà ouvrent bien le +25%.
   - **Plafond 25%/50% proraté (mi-semaine)** : le plafond séparant 25% et 50% n'est **pas** codé en dur à 43h mais vaut `seuil_départ_proraté + largeur_bande_25%` (`RttRecoveryComputationService::{resolveOvertime25BandWidthMinutes, computeOvertimeBaseMinutes}`). Largeur = 43h − base (4h pour un 39h, 8h pour un 35h). Pour une semaine pleine le plafond redonne 43h (aucune régression) ; pour une embauche mi-semaine il se décale avec le départ, ouvrant la tranche 50%. Témoin Dylan (CDD 39h embauché jeudi, 22h) : 4h à 25% + 3h à 50%. **Hors périmètre** : l'écran Heures (`WorkHourWeeklySummaryProvider`) n'a pas cette proratisation (calcul dupliqué, laissé tel quel par décision métier).
 - INTERIM: no overtime bonuses, no recovery time
@@ -125,7 +127,7 @@
 ## Récap. congés (écran)
 - Accès via sidebar `Récap. congés`, conditionné au flag `User.hasLeaveRecapAccess` (défaut `false`) — activé au create/edit user. Le flag s'applique à tous les profils, y compris admin.
 - Scope : `ROLE_ADMIN` → tous les employés, `ROLE_USER` (chef de site) → employés de ses sites, `ROLE_SELF` → sa ligne
-- Cutoff temporel : fin de la semaine S-2 (dimanche 23:59:59). Formule : `dimanche(lundi_semaine_courante − 14j)`. Pas de gate `isValid`.
+- Cutoff temporel : fin de la semaine S-1 (dimanche 23:59:59). Formule : `dimanche(lundi_semaine_courante − 7j)`. Pas de gate `isValid`.
 - Helper : `App\Util\LeaveRecapCutoff::resolveCutoff()`
 - Colonnes : Nom, Prénom, Contrat, CP N-1 restant, CP N, Samedis, RTT — identiques au PDF
 - Service partagé : `LeaveRecapRowBuilder` consommé par `LeaveRecapPrintProvider` (as-of today) et `EmployeeLeaveRecapProvider` (as-of cutoff)

config/version.yaml

@@ -1,2 +1,2 @@
 parameters:
-    app.version: '0.1.109'
+    app.version: '0.1.114'

doc/functional-rules.md

@@ -140,7 +140,20 @@ Documents complementaires:
 - Contrats CUSTOM (heures hebdo ≠ 35h et ≠ 39h, hors INTERIM/FORFAIT):
   - référence heures sup = heures contractuelles réelles (ex: 4h → référence 4h)
   - pas de bonus 25% ni 50% : 1 heure sup = 1 heure de récupération
-  - le déficit (travail < contrat) ne génère pas de récup mais n'impacte pas le solde
+  - le déficit (travail < contrat) réduit le cumul RTT 1:1 (peut devenir négatif, reporté N+1)
+
+### Jour de solidarité (contrats CUSTOM < 35h)
+
+Le Lundi de Pentecôte (jour de solidarité) impose une contribution proratisée aux temps
+partiels < 35h. La RH pose un RTT sur ce jour pour tous les salariés ; pour les contrats
+standard (35h/39h) cela draine ~7h du cumul RTT (comportement inchangé). Pour les CUSTOM
+< 35h, poser un RTT entier n'a pas de sens : le logiciel **neutralise** le jour (quel que
+soit ce qui y est saisi) et applique un déficit forfaitaire `7/35 × heuresHebdo`
+(= 12 min par heure hebdo : 4h → 48 min, 28h → 5h36). Ce déficit réduit le cumul RTT
+(peut le rendre négatif, reporté à l'exercice suivant) et se cumule avec les autres
+déficits/surplus de la semaine. Date calculée par computus (Pâques + 50 jours),
+indépendante de la liste `EXCLUDED_PUBLIC_HOLIDAYS`.
+
 - Nature `INTERIM`:
   - pas de bonus 25%
   - pas de bonus 50%
@@ -361,14 +374,31 @@ Seuls les employés dont au moins une période de contrat intersecte la période
   - `ROLE_ADMIN` : tous les employés
   - `ROLE_USER` (chef de site) : employés des sites autorisés (`UserSiteRole`)
   - `ROLE_SELF` : uniquement son employé lié
-- **Cutoff temporel** : le récap est figé à la fin de la semaine S-2 (dimanche 23:59:59)
+- **Cutoff temporel** : le récap est figé à la fin de la semaine S-1 (dimanche 23:59:59)
-  - Formule : `cutoffDate = dimanche(lundi_semaine_courante − 14 jours)`
+  - Formule : `cutoffDate = dimanche(lundi_semaine_courante − 7 jours)`
-  - Exemple : mardi 14/04/2026 (S16) → dimanche 05/04/2026 (fin S14)
+  - Exemple : mardi 14/04/2026 (S16) → dimanche 12/04/2026 (fin S15)
   - `isValid` n'entre PAS en compte : cutoff purement temporel
   - Les heures et absences postérieures au cutoff sont ignorées dans les calculs
 - Colonnes identiques au PDF (voir §10)
 - Détails techniques : voir `doc/leave-recap-screen.md`
 
+## Export Contingent heures de nuit
+
+- Accès : drawer « Export » de la liste employés, type « Contingent H.nuit ».
+  Endpoint `GET /night-hours-contingent/print?year=YYYY`, `ROLE_USER`.
+- Périmètre : `EmployeeRepository::findScoped($user)` (admin → tous, chef de
+  site → ses sites). Employés ayant ≥ 1 contrat sur l'année civile uniquement.
+- PDF A4 **paysage** : lignes = employés (groupés par site, triés displayOrder
+  puis nom/prénom), colonnes = 12 mois (Janv→Déc), chaque mois avec 2 sous-
+  colonnes « H.nuit » et « N.jours ».
+- Heures de nuit : minutes travaillées dans la fenêtre **21h→6h**
+  (`NightHoursCalculator`, identique au reste de l'app). Conducteurs inclus :
+  champ manuel `WorkHour.nightHoursMinutes`.
+- « N.jours » : un jour compte 1 dès que ses minutes de nuit ≥ 240 (4h).
+- Aucun crédit absence/férié : seules les heures réellement travaillées comptent.
+- Services : `App\State\NightHoursContingentPrintProvider` +
+  `App\Service\WorkHours\NightContingentExportBuilder`.
+
 ## 11) Récapitulatif Salaire (PDF mensuel)
 
 - Accessible depuis la page Employés via le bouton "Récap. Salaire" (réservé `ROLE_ADMIN`)

doc/hours-day-export.md

@@ -1,17 +1,24 @@
 # Export PDF des heures — vue Jour
 
-Bouton **Exporter** à droite du titre « Heures », visible **uniquement pour les
+Bouton **Exporter** à droite du titre « Heures », visible pour les **administrateurs**
-administrateurs** (`ROLE_ADMIN`) et **uniquement en vue Jour** (masqué en vue Semaine).
+(`ROLE_ADMIN`) **et les chefs de site** (`ROLE_USER`), **uniquement en vue Jour** (masqué
+en vue Semaine, masqué pour les profils employé `ROLE_SELF`).
+
+## Périmètre
+- **Administrateur** : peut exporter tous les sites.
+- **Chef de site** : ne voit dans le drawer que **ses sites** et ne peut exporter que
+  ceux-ci. Le périmètre est appliqué côté backend (`EmployeeRepository::findScoped`) — un
+  `siteIds` forcé hors de son périmètre est ignoré, aucune donnée d'un autre site ne fuit.
 
 ## Comportement
 - Ouvre un drawer : un champ **date** (préremplit la date affichée) et des **cases à
-  cocher des sites** (présélectionnées sur le filtre courant).
+  cocher des sites** (limitées au périmètre de l'utilisateur).
 - Génère un **PDF A4 portrait** d'une seule journée, **regroupé par site**.
 
 ## Données
 - Mêmes employés que la vue Jour : **non-conducteurs**, **sous contrat** à la date
-  choisie, des sites cochés. Les employés sous contrat sans saisie apparaissent (lignes
+  choisie, des sites cochés et **dans le périmètre de l'utilisateur**. Les employés sous
-  vides).
+  contrat sans saisie apparaissent (lignes vides).
 - Colonnes : Nom · Statut · Début matin · Fin matin · Début après-midi · Fin après-midi ·
   Début soir · Fin soir · Jour · Nuit · **Total** (en gras). **Pas de colonne « Valider ».**
 - Colonne **Statut** : affiche le **code** du type d'absence (ex. `AT`), pas le libellé,
@@ -23,8 +30,9 @@ administrateurs** (`ROLE_ADMIN`) et **uniquement en vue Jour** (masqué en vue S
   de couleur contenant le code et le libellé du type à droite. Triée par code, dédupliquée.
 
 ## Technique
-- Endpoint : `GET /work-hours/day-export?workDate=YYYY-MM-DD&siteIds=1,2,3` (`ROLE_ADMIN`).
+- Endpoint : `GET /work-hours/day-export?workDate=YYYY-MM-DD&siteIds=1,2,3` (`ROLE_USER`).
-- Provider : `App\State\WorkHourDayExportProvider`.
+- Provider : `App\State\WorkHourDayExportProvider` — résout le périmètre via
+  `EmployeeRepository::findScoped($user)` (admin → tous, chef de site → ses sites).
 - Calcul des cellules : `YearlyHoursExportBuilder::buildDayRowsForEmployees` (source
   unique de vérité, partagée avec les exports annuels).
 - Gabarit : `templates/work-hour-day-export/print.html.twig`.

doc/leave-recap-screen.md

@@ -2,14 +2,14 @@
 
 ## Objet
 
-Vue tableau des soldes de congés par employé, figée à un cutoff temporel (fin de semaine S-2).
+Vue tableau des soldes de congés par employé, figée à un cutoff temporel (fin de semaine S-1).
 Complémentaire à l'export PDF admin : mêmes colonnes, accès étendu aux employés et chefs de site.
 
 ## Cutoff
 
-La formule est : `cutoffDate = dimanche de (lundi de la semaine courante − 14 jours)`.
+La formule est : `cutoffDate = dimanche de (lundi de la semaine courante − 7 jours)`.
 
-Exemple : mardi 14/04/2026 (S16) → **dimanche 05/04/2026 23:59:59** (fin S14).
+Exemple : mardi 14/04/2026 (S16) → **dimanche 12/04/2026 23:59:59** (fin S15).
 
 Le cutoff est purement temporel : l'état `isValid` des heures n'entre pas en compte. Les heures
 et absences postérieures au cutoff sont ignorées dans le calcul des soldes.

doc/rtt-rollover.md

@@ -96,6 +96,12 @@ Traitement par employe:
 
 > Regle clef : le report d'un exercice a l'autre reprend exactement le **disponible** affiche sur l'onglet RTT (cf. `EmployeeRttSummaryProvider`). Le report deja present au debut de l'exercice precedent n'est jamais perdu, et les heures deja payees ne sont pas re-creditees. Service mutualise : `App\Service\Rtt\RttClosingBalanceService`.
 
+> Contrats CUSTOM : le solde de clôture intègre désormais les **déficits** hebdomadaires
+> (semaines travaillées sous les heures contractuelles), via `RttClosingBalanceService::fold`
+> qui gère les totaux négatifs. La clôture (donc le report d'ouverture N+1) peut être négative.
+> Après une mise à jour de cette règle, rejouer `app:rtt:rollover --force --recompute` pour
+> recalculer les lignes `employee_rtt_balances` non verrouillées calculées avec l'ancienne règle.
+
 > Bug historique corrige : la version initiale ne reportait que `acquis N-1` (ni report d'ouverture, ni deduction des paiements), ce qui faisait disparaitre le solde de depart. Pour corriger des lignes deja creees a tort, relancer avec `--force --recompute`.
 
 ## 7) Donnees a fournir au go-live

doc/rtt-tab.md

@@ -16,6 +16,25 @@ L'onglet est **masqué pour les contrats FORFAIT** (filtre `showRttTab` dans `us
 
 Toujours **Juin (Y-1) → Mai (Y)**. Le champ `EmployeeRttSummary.year` correspond à `Y` (année de fin d'exercice) ; ex. `year=2026` = `01/06/2025 → 31/05/2026`.
 
+## Règle de calcul — contrats CUSTOM (4h, 25h…)
+
+Pour un contrat CUSTOM, la récupération est **plate** (1h sup = 1h récup, sans bonus 25 %/50 %).
+Depuis 2026-06, une semaine **travaillée sous les heures contractuelles** produit un **déficit
+signé** dans la colonne « Heure » qui **réduit le « Total » et le « Cumul »** (1h manquante =
+-1h). Les colonnes Base/25 %/50 % restent à **0** (pas de tranches pour ces contrats). Le cumul
+peut devenir négatif ; il est reporté à l'exercice suivant.
+
+Techniquement : `WeekRecoveryDetail::isFlatRecovery` marque ces semaines ;
+`EmployeeRttSummaryProvider::applyDeficitCascade` les exclut du drainage des tranches 25/50.
+
+#### Jour de solidarité (CUSTOM < 35h)
+
+Sur la semaine du Lundi de Pentecôte, un contrat CUSTOM < 35h porte un déficit
+forfaitaire de `7/35 × heuresHebdo` (12 min/h hebdo, ex. 4h → −0h48) dans les colonnes
+Heure / Total / Cumul (25 %/50 % restent à 0). Le montant est fixe et inconditionnel :
+il ne dépend pas des heures saisies ni du RTT que la RH pose ce jour-là. Les contrats
+35h/39h ne sont pas concernés ici (leur RTT posé draine le cumul normalement).
+
 ## Sélecteur d'année
 
 Position : sous la table, à l'intérieur de la zone scrollable, à gauche.

docs/superpowers/plans/2026-06-09-rtt-custom-deficit.md

@@ -0,0 +1,608 @@
+# RTT — Déficit pris en compte pour les contrats CUSTOM — Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Pour les contrats CUSTOM (4h, 25h…), une semaine travaillée sous les heures contractuelles doit réduire le cumul RTT (déficit compté), avec un affichage propre (colonnes 25%/50% à 0).
+
+**Architecture:** On retire l'écrêtage `max(0, …)` du total hebdo CUSTOM dans `RttRecoveryComputationService` (le déficit signé circule dans `totalMinutes`) et on marque ces semaines `isFlatRecovery = true`. Ce drapeau désactive la cascade de drainage 25/50 dans `EmployeeRttSummaryProvider`, de sorte que le déficit n'impacte que les colonnes Heure/Total/Cumul. Le `RttClosingBalanceService::fold` gère déjà les totaux négatifs (report N+1 cohérent).
+
+**Tech Stack:** Symfony, API Platform, Doctrine ORM, PHPUnit. Frontend Nuxt/Vue (aucun changement de code, docs uniquement).
+
+**Spec:** `docs/superpowers/specs/2026-06-09-rtt-custom-deficit-design.md`
+
+---
+
+### Task 1: Ajouter le drapeau `isFlatRecovery` aux DTOs
+
+**Files:**
+- Modify: `src/Dto/Rtt/WeekRecoveryDetail.php`
+- Modify: `src/Dto/Rtt/EmployeeRttWeekSummary.php`
+
+Ces deux DTOs sont de simples porteurs de données ; ils sont couverts par les tests des tâches 3 et 4. Pas de test dédié.
+
+- [ ] **Step 1: Ajouter le champ à `WeekRecoveryDetail`**
+
+Dans `src/Dto/Rtt/WeekRecoveryDetail.php`, ajouter un dernier paramètre au constructeur (après `$dailyMinutes`) :
+
+```php
+    /**
+     * @param array<string, int> $dailyMinutes date (Y-m-d) => worked minutes
+     */
+    public function __construct(
+        public int $overtimeMinutes = 0,
+        public int $base25Minutes = 0,
+        public int $bonus25Minutes = 0,
+        public int $base50Minutes = 0,
+        public int $bonus50Minutes = 0,
+        public int $totalMinutes = 0,
+        public array $dailyMinutes = [],
+        public bool $isFlatRecovery = false,
+    ) {}
+```
+
+- [ ] **Step 2: Ajouter le champ à `EmployeeRttWeekSummary`**
+
+Dans `src/Dto/Rtt/EmployeeRttWeekSummary.php`, ajouter un dernier paramètre au constructeur (après `$cumulativeBalanceMinutes`) :
+
+```php
+    public function __construct(
+        public int $month,
+        public int $weekNumber,
+        public string $weekStart,
+        public string $weekEnd,
+        public int $overtimeMinutes = 0,
+        public int $base25Minutes = 0,
+        public int $bonus25Minutes = 0,
+        public int $base50Minutes = 0,
+        public int $bonus50Minutes = 0,
+        public int $totalMinutes = 0,
+        public int $cumulativeBalanceMinutes = 0,
+        public bool $isFlatRecovery = false,
+    ) {}
+```
+
+- [ ] **Step 3: Vérifier que rien n'est cassé (DTO à valeur par défaut)**
+
+Run: `make test`
+Expected: PASS (aucun appel existant ne casse — le nouveau paramètre a une valeur par défaut).
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/Dto/Rtt/WeekRecoveryDetail.php src/Dto/Rtt/EmployeeRttWeekSummary.php
+git commit -m "feat(rtt): add isFlatRecovery flag to recovery DTOs"
+```
+
+---
+
+### Task 2: Test de clôture — déficit CUSTOM diminue le report (aucun code à changer)
+
+**Files:**
+- Test: `tests/Service/Rtt/RttClosingBalanceServiceTest.php`
+
+`RttClosingBalanceService::fold` gère déjà les `totalMinutes` négatifs. On ajoute un test explicite « déficit CUSTOM » pour verrouiller le comportement.
+
+- [ ] **Step 1: Écrire le test**
+
+Ajouter cette méthode dans `tests/Service/Rtt/RttClosingBalanceServiceTest.php` (après `testCustomRecoveryWithoutBucketsStillCountsInTotal`) :
+
+```php
+    public function testCustomDeficitWeekReducesClosingBalance(): void
+    {
+        // CUSTOM (4h) : une semaine de récup +3h puis une semaine déficitaire -1h
+        // (toutes deux sans tranches 25/50). Le déficit doit réduire la clôture.
+        $recovery = new WeekRecoveryDetail(totalMinutes: 180, isFlatRecovery: true);   // +3h
+        $deficit  = new WeekRecoveryDetail(totalMinutes: -60, isFlatRecovery: true);   // -1h
+
+        $closing = $this->service()->fold(new WeekRecoveryDetail(), [$recovery, $deficit], $this->payments());
+
+        // 3h - 1h = 2h reportées, et la somme des buckets égale toujours le total.
+        self::assertSame(120, $closing->totalMinutes);
+        self::assertSame(
+            120,
+            $closing->base25Minutes + $closing->bonus25Minutes + $closing->base50Minutes + $closing->bonus50Minutes,
+        );
+    }
+```
+
+- [ ] **Step 2: Lancer le test**
+
+Run: `docker exec php-sirh-fpm sh -c 'cd /var/www/html && vendor/bin/phpunit tests/Service/Rtt/RttClosingBalanceServiceTest.php --filter testCustomDeficitWeekReducesClosingBalance'`
+Expected: PASS (le `fold` gère déjà les totaux négatifs).
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add tests/Service/Rtt/RttClosingBalanceServiceTest.php
+git commit -m "test(rtt): custom deficit week reduces closing balance"
+```
+
+---
+
+### Task 3: `RttRecoveryComputationService` — récup plate signée pour CUSTOM
+
+**Files:**
+- Modify: `src/Service/Rtt/RttRecoveryComputationService.php` (`computeRecoveryByWeek` lignes ~243-270, + nouvelle méthode privée)
+- Test: `tests/Service/Rtt/RttRecoveryComputationServiceTest.php`
+
+On extrait la construction du `WeekRecoveryDetail` dans une méthode pure `buildWeekRecoveryDetail`, testable par réflexion (style existant du fichier de test), et on y applique le changement CUSTOM.
+
+- [ ] **Step 1: Écrire les tests (méthode pure)**
+
+Ajouter dans `tests/Service/Rtt/RttRecoveryComputationServiceTest.php` (le fichier instancie déjà le service via `newInstanceWithoutConstructor` et possède le helper `invokePrivate`) :
+
+```php
+    public function testBuildWeekDetailCustomDeficitKeepsSignedTotalAndFlatFlag(): void
+    {
+        $service = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+
+        // CUSTOM, semaine sous les heures : overtime -120 (worked 2h sur réf 4h).
+        $detail = $this->invokePrivate(
+            $service,
+            'buildWeekRecoveryDetail',
+            false, // isPresence
+            false, // disableBonuses
+            true,  // isCustom
+            -120,  // overtimeTotalMinutes
+            0,     // rawBase25
+            0,     // rawBase50
+            [],    // dailyMinutes
+        );
+
+        self::assertSame(-120, $detail->totalMinutes);
+        self::assertTrue($detail->isFlatRecovery);
+        self::assertSame(0, $detail->base25Minutes);
+        self::assertSame(0, $detail->base50Minutes);
+    }
+
+    public function testBuildWeekDetailCustomPositiveIsFlatOneToOne(): void
+    {
+        $service = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+
+        $detail = $this->invokePrivate($service, 'buildWeekRecoveryDetail', false, false, true, 180, 0, 0, []);
+
+        self::assertSame(180, $detail->totalMinutes); // 1h = 1h
+        self::assertTrue($detail->isFlatRecovery);
+    }
+
+    public function testBuildWeekDetailStandardKeepsBucketsAndBonuses(): void
+    {
+        $service = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+
+        // 39h : overtime 300, base25 240, base50 60.
+        $detail = $this->invokePrivate($service, 'buildWeekRecoveryDetail', false, false, false, 300, 240, 60, []);
+
+        self::assertFalse($detail->isFlatRecovery);
+        self::assertSame(240, $detail->base25Minutes);
+        self::assertSame(60, $detail->bonus25Minutes);  // round(240 * 0.25)
+        self::assertSame(60, $detail->base50Minutes);
+        self::assertSame(30, $detail->bonus50Minutes);  // round(60 * 0.5)
+        self::assertSame(300 + 60 + 30, $detail->totalMinutes);
+    }
+```
+
+- [ ] **Step 2: Lancer les tests pour vérifier qu'ils échouent**
+
+Run: `docker exec php-sirh-fpm sh -c 'cd /var/www/html && vendor/bin/phpunit tests/Service/Rtt/RttRecoveryComputationServiceTest.php --filter testBuildWeekDetail'`
+Expected: FAIL — `buildWeekRecoveryDetail` n'existe pas encore (ReflectionException / method does not exist).
+
+- [ ] **Step 3: Ajouter la méthode privée `buildWeekRecoveryDetail`**
+
+Dans `src/Service/Rtt/RttRecoveryComputationService.php`, ajouter cette méthode (par ex. juste après `computeRecoveryByWeek`, avant `computeMetrics`) :
+
+```php
+    /**
+     * Assemble le détail de récupération d'une semaine à partir des drapeaux résolus et
+     * des bandes d'heures sup brutes.
+     *
+     * - PRESENCE / INTERIM (bonus désactivés) : aucune récupération.
+     * - CUSTOM : récupération plate 1h = 1h, sans tranches 25/50 ; l'heure sup signée EST
+     *   le total, donc une semaine travaillée sous les heures contractuelles produit un
+     *   total négatif (déficit qui réduit le solde). Marquée isFlatRecovery pour que le
+     *   provider ne draine pas les tranches 25/50.
+     * - Standard 35h/39h : heures sup + bonus 25 %/50 %.
+     *
+     * @param array<string, int> $dailyMinutes
+     */
+    private function buildWeekRecoveryDetail(
+        bool $isPresence,
+        bool $disableBonuses,
+        bool $isCustom,
+        int $overtimeTotalMinutes,
+        int $rawBase25,
+        int $rawBase50,
+        array $dailyMinutes,
+    ): WeekRecoveryDetail {
+        $noBands = $isPresence || $disableBonuses || $isCustom;
+
+        $base25  = $noBands ? 0 : $rawBase25;
+        $bonus25 = $noBands ? 0 : (int) round($base25 * 0.25);
+        $base50  = $noBands ? 0 : $rawBase50;
+        $bonus50 = $noBands ? 0 : (int) round($base50 * 0.5);
+
+        if ($isPresence || $disableBonuses) {
+            $totalMinutes = 0;
+        } elseif ($isCustom) {
+            $totalMinutes = $overtimeTotalMinutes; // signé : le déficit réduit le solde
+        } else {
+            $totalMinutes = $overtimeTotalMinutes + $bonus25 + $bonus50;
+        }
+
+        return new WeekRecoveryDetail(
+            overtimeMinutes: $overtimeTotalMinutes,
+            base25Minutes: $base25,
+            bonus25Minutes: $bonus25,
+            base50Minutes: $base50,
+            bonus50Minutes: $bonus50,
+            totalMinutes: $totalMinutes,
+            dailyMinutes: $dailyMinutes,
+            isFlatRecovery: $isCustom,
+        );
+    }
+```
+
+- [ ] **Step 4: Brancher l'appelant sur la nouvelle méthode**
+
+Dans `computeRecoveryByWeek`, remplacer le bloc existant (depuis `[$rawBase25, $rawBase50] = …` jusqu'à la fin du `new WeekRecoveryDetail(...)` qui assigne `$results[$weekKey]`) par :
+
+```php
+            [$rawBase25, $rawBase50] = $this->computeOvertimeBaseMinutes($weeklyTotalMinutes, $overtime25StartMinutes, $overtime50StartMinutes);
+
+            $results[$weekKey] = $this->buildWeekRecoveryDetail(
+                $isWeekPresenceTracking,
+                $disableOvertimeBonuses,
+                $isCustomContract,
+                $weeklyOvertimeTotalMinutes,
+                $rawBase25,
+                $rawBase50,
+                $dailyWorkedMinutes,
+            );
+```
+
+(Conserver les lignes précédentes qui calculent `$weeklyOvertimeTotalMinutes`, `$overtime25StartMinutes`, `$overtime50StartMinutes`.)
+
+- [ ] **Step 5: Lancer les tests pour vérifier qu'ils passent**
+
+Run: `docker exec php-sirh-fpm sh -c 'cd /var/www/html && vendor/bin/phpunit tests/Service/Rtt/RttRecoveryComputationServiceTest.php'`
+Expected: PASS (nouveaux tests + tests existants des helpers).
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add src/Service/Rtt/RttRecoveryComputationService.php tests/Service/Rtt/RttRecoveryComputationServiceTest.php
+git commit -m "feat(rtt): custom contract deficit counts as signed recovery (1h=1h, no bands)"
+```
+
+---
+
+### Task 4: `EmployeeRttSummaryProvider` — sauter la cascade pour les semaines plates
+
+**Files:**
+- Modify: `src/State/EmployeeRttSummaryProvider.php` (cascade lignes ~145-174 → méthode extraite ; `buildWeekSummaries` lignes ~385-396 et ~425-436)
+- Test: `tests/State/EmployeeRttSummaryProviderTest.php`
+
+- [ ] **Step 1: Écrire les tests (méthode pure `applyDeficitCascade`)**
+
+Ajouter dans `tests/State/EmployeeRttSummaryProviderTest.php`. Le fichier importe déjà `EmployeeRttSummaryProvider`, `ReflectionClass`, et possède `invokePrivate` / `buildProvider`. Ajouter d'abord ce petit helper de fabrication en bas de la classe (si un helper équivalent n'existe pas déjà) :
+
+```php
+    private function weekSummary(int $totalMinutes, bool $isFlat, int $base25 = 0, int $base50 = 0): \App\Dto\Rtt\EmployeeRttWeekSummary
+    {
+        return new \App\Dto\Rtt\EmployeeRttWeekSummary(
+            month: 6,
+            weekNumber: 1,
+            weekStart: '2026-06-01',
+            weekEnd: '2026-06-07',
+            overtimeMinutes: $totalMinutes,
+            base25Minutes: $base25,
+            base50Minutes: $base50,
+            totalMinutes: $totalMinutes,
+            isFlatRecovery: $isFlat,
+        );
+    }
+```
+
+Puis les tests :
+
+```php
+    public function testFlatDeficitWeekIsNotDrainedFromTiers(): void
+    {
+        $provider = $this->buildProvider([]);
+
+        // Semaine CUSTOM déficitaire (-120), aucune tranche accumulée.
+        $weeks  = [$this->weekSummary(-120, true)];
+        $result = $this->invokePrivate($provider, 'applyDeficitCascade', $weeks, 0, 0);
+
+        // Buckets restent à 0 ; le total négatif est conservé (le cumul est calculé ailleurs).
+        self::assertSame(0, $result[0]->base25Minutes);
+        self::assertSame(0, $result[0]->base50Minutes);
+        self::assertSame(-120, $result[0]->totalMinutes);
+        self::assertTrue($result[0]->isFlatRecovery);
+    }
+
+    public function testStandardDeficitWeekDrainsFiftyThenTwentyFive(): void
+    {
+        $provider = $this->buildProvider([]);
+
+        // Semaine 35h/39h déficitaire (-100), avec 60 en 50% et 120 en 25% accumulés.
+        $weeks  = [$this->weekSummary(-100, false)];
+        $result = $this->invokePrivate($provider, 'applyDeficitCascade', $weeks, 120, 60);
+
+        self::assertSame(-60, $result[0]->base50Minutes); // 60 drainés du 50%
+        self::assertSame(-40, $result[0]->base25Minutes); // 40 restants drainés du 25%
+        self::assertSame(-100, $result[0]->totalMinutes);
+    }
+
+    public function testFlatPositiveWeekIsUntouched(): void
+    {
+        $provider = $this->buildProvider([]);
+
+        $weeks  = [$this->weekSummary(180, true)];
+        $result = $this->invokePrivate($provider, 'applyDeficitCascade', $weeks, 0, 0);
+
+        self::assertSame(180, $result[0]->totalMinutes);
+        self::assertSame(0, $result[0]->base25Minutes);
+    }
+```
+
+NB : si `invokePrivate` n'accepte pas d'arguments variadiques dans ce fichier, vérifier sa signature en haut du fichier de test et adapter (l'autre fichier de test du dépôt l'utilise déjà avec des arguments).
+
+- [ ] **Step 2: Lancer les tests pour vérifier qu'ils échouent**
+
+Run: `docker exec php-sirh-fpm sh -c 'cd /var/www/html && vendor/bin/phpunit tests/State/EmployeeRttSummaryProviderTest.php --filter Deficit'`
+Expected: FAIL — `applyDeficitCascade` n'existe pas encore.
+
+- [ ] **Step 3: Extraire la cascade en méthode privée**
+
+Dans `src/State/EmployeeRttSummaryProvider.php`, ajouter cette méthode privée (par ex. juste avant `buildWeekSummaries`) :
+
+```php
+    /**
+     * Distribue les semaines déficitaires sur les tranches 25/50 accumulées (50 % d'abord,
+     * puis 25 %), en réécrivant les buckets affichés de chaque semaine déficitaire avec les
+     * montants négatifs drainés.
+     *
+     * Les semaines à récupération plate (CUSTOM 1h = 1h) sont ignorées : elles n'ont pas de
+     * tranches 25/50, donc leur déficit ne réduit que le cumul courant (calculé ensuite à
+     * partir de totalMinutes) et les colonnes 25/50 restent à 0.
+     *
+     * @param list<EmployeeRttWeekSummary> $weeks
+     *
+     * @return list<EmployeeRttWeekSummary>
+     */
+    private function applyDeficitCascade(array $weeks, int $cumulative25, int $cumulative50): array
+    {
+        foreach ($weeks as $i => $week) {
+            if ($week->totalMinutes >= 0 || $week->isFlatRecovery) {
+                $cumulative50 += $week->base50Minutes + $week->bonus50Minutes;
+                $cumulative25 += $week->base25Minutes + $week->bonus25Minutes;
+
+                continue;
+            }
+
+            $deficit = -$week->totalMinutes;
+            $from50  = min($deficit, max(0, $cumulative50));
+            $from25  = $deficit - $from50;
+
+            $cumulative50 -= $from50;
+            $cumulative25 -= $from25;
+
+            $weeks[$i] = new EmployeeRttWeekSummary(
+                month: $week->month,
+                weekNumber: $week->weekNumber,
+                weekStart: $week->weekStart,
+                weekEnd: $week->weekEnd,
+                overtimeMinutes: $week->overtimeMinutes,
+                base25Minutes: $from25 > 0 ? -$from25 : 0,
+                bonus25Minutes: 0,
+                base50Minutes: $from50 > 0 ? -$from50 : 0,
+                bonus50Minutes: 0,
+                totalMinutes: $week->totalMinutes,
+                isFlatRecovery: $week->isFlatRecovery,
+            );
+        }
+
+        return $weeks;
+    }
+```
+
+- [ ] **Step 4: Brancher `provide()` sur la méthode extraite**
+
+Dans `provide()`, remplacer le bloc commentaire + boucle (depuis `// Post-process: distribute deficit weeks across cumulative balance (50% first, then 25%)` et la déclaration de `$cumulative50`/`$cumulative25` jusqu'à la fin du `foreach ($summary->weeks as $i => $week) { … }`) par :
+
+```php
+        // Post-process: distribute deficit weeks across cumulative balance (50% first, then 25%).
+        // Flat-recovery (CUSTOM) weeks are skipped — their deficit only reduces the running cumul.
+        $summary->weeks = $this->applyDeficitCascade(
+            $summary->weeks,
+            $carry->base25Minutes + $carry->bonus25Minutes,
+            $carry->base50Minutes + $carry->bonus50Minutes,
+        );
+```
+
+- [ ] **Step 5: Propager `isFlatRecovery` dans `buildWeekSummaries`**
+
+Dans `buildWeekSummaries`, ajouter `isFlatRecovery: $detail->isFlatRecovery,` comme dernier argument des DEUX appels `new EmployeeRttWeekSummary(...)` :
+- le cas mono-mois (`if ($startMonth === $endMonth)`, après `totalMinutes: $detail->totalMinutes,`)
+- le cas semaine à cheval (boucle `foreach ([$startMonth, $endMonth] …`, après `totalMinutes: (int) round($detail->totalMinutes * $ratio),`)
+
+- [ ] **Step 6: Lancer les tests**
+
+Run: `docker exec php-sirh-fpm sh -c 'cd /var/www/html && vendor/bin/phpunit tests/State/EmployeeRttSummaryProviderTest.php'`
+Expected: PASS (nouveaux tests + tests existants du provider).
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add src/State/EmployeeRttSummaryProvider.php tests/State/EmployeeRttSummaryProviderTest.php
+git commit -m "feat(rtt): skip 25/50 deficit cascade for flat (custom) recovery weeks"
+```
+
+---
+
+### Task 5: `DumpVerificationSnapshotCommand` — refléter le drapeau
+
+**Files:**
+- Modify: `src/Command/DumpVerificationSnapshotCommand.php` (`distributeDeficits` ligne ~689 ; build des week summaries lignes ~628-639 et ~664-675)
+
+Ce command duplique la logique du provider pour produire les snapshots de vérification. Sans mise à jour, les snapshots « after » seraient faux pour les semaines CUSTOM.
+
+- [ ] **Step 1: Propager `isFlatRecovery` dans les week summaries dupliquées**
+
+Ajouter `isFlatRecovery: $detail->isFlatRecovery,` comme dernier argument des deux appels `new EmployeeRttWeekSummary(...)` (cas mono-mois ligne ~638 après `totalMinutes: $detail->totalMinutes,`, et cas à cheval ligne ~674 après `totalMinutes: (int) round($detail->totalMinutes * $ratio),`).
+
+- [ ] **Step 2: Sauter la cascade pour les semaines plates dans `distributeDeficits`**
+
+Modifier la condition de la boucle :
+
+```php
+            if ($week->totalMinutes >= 0 || $week->isFlatRecovery) {
+```
+
+et ajouter `isFlatRecovery: $week->isFlatRecovery,` comme dernier argument du `new EmployeeRttWeekSummary(...)` de reconstruction (après `totalMinutes: $week->totalMinutes,`).
+
+- [ ] **Step 3: Vérifier la compilation (lint)**
+
+Run: `docker exec php-sirh-fpm sh -c 'cd /var/www/html && php -l src/Command/DumpVerificationSnapshotCommand.php'`
+Expected: `No syntax errors detected`.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/Command/DumpVerificationSnapshotCommand.php
+git commit -m "chore(rtt): mirror flat-recovery cascade skip in verification snapshot command"
+```
+
+---
+
+### Task 6: Documentation (obligatoire — même intervention)
+
+**Files:**
+- Modify: `CLAUDE.md` (ligne ~68)
+- Modify: `frontend/data/documentation-content.ts` (lignes ~367-368 et section RTT ~520)
+- Modify: `doc/rtt-tab.md`
+- Modify: `doc/rtt-rollover.md`
+
+- [ ] **Step 1: `CLAUDE.md`**
+
+Remplacer la ligne :
+
+```
+- CUSTOM contracts (weeklyHours ≠ 35 and ≠ 39, not INTERIM/FORFAIT): reference = actual contractual hours, no 25%/50% bonuses (1h overtime = 1h recovery), deficit doesn't impact balance
+```
+
+par :
+
+```
+- CUSTOM contracts (weeklyHours ≠ 35 and ≠ 39, not INTERIM/FORFAIT): reference = actual contractual hours, no 25%/50% bonuses (1h overtime = 1h recovery). **Le déficit (heures travaillées < heures contractuelles) réduit le cumul RTT 1:1** (peut devenir négatif, reporté à l'exercice suivant). Implémenté via `WeekRecoveryDetail::isFlatRecovery` / `EmployeeRttWeekSummary::isFlatRecovery` : ces semaines portent leur récup/déficit signé dans `totalMinutes` (`RttRecoveryComputationService::buildWeekRecoveryDetail`) et `EmployeeRttSummaryProvider::applyDeficitCascade` **ne draine pas** les tranches 25/50 pour elles (colonnes 25%/50% restent à 0). Le `RttClosingBalanceService::fold` reporte le déficit en N+1.
+```
+
+- [ ] **Step 2: In-app docs — règles d'heures sup (ligne ~367)**
+
+Dans `frontend/data/documentation-content.ts`, remplacer le contenu de la liste ligne ~367 :
+
+```
+Contrats CUSTOM (4h, 25h, etc.) : 1h supplémentaire = 1h de récupération, pas de bonus
+```
+
+par :
+
+```
+Contrats CUSTOM (4h, 25h, etc.) : 1h supplémentaire = 1h de récupération, pas de bonus. Une semaine sous les heures contractuelles réduit le cumul RTT (1h manquante = -1h), sans passer par les tranches 25/50
+```
+
+- [ ] **Step 3: In-app docs — note déficit (ligne ~368)**
+
+Remplacer le contenu de la note ligne ~368 :
+
+```
+En cas de déficit hebdomadaire (heures travaillées < heures contrat), le déficit est déduit du cumul RTT : d'abord des heures à 50%, puis des heures à 25%.
+```
+
+par :
+
+```
+En cas de déficit hebdomadaire (heures travaillées < heures contrat), le déficit est déduit du cumul RTT. Pour un 35h/39h, il est puisé d'abord dans les heures à 50%, puis à 25%. Pour un contrat CUSTOM (4h, etc.), il réduit directement le cumul (pas de tranches 25/50) ; le cumul peut devenir négatif et est reporté à l'exercice suivant.
+```
+
+- [ ] **Step 4: In-app docs — section RTT « Compteurs » (ajout d'une note)**
+
+Dans l'article `rtt-compteurs` (id `'rtt-compteurs'`, vers la ligne ~520), ajouter une note à la fin du tableau `blocks` (après le dernier `paragraph`) :
+
+```javascript
+          { type: 'note', content: 'Contrats CUSTOM (ex. 4h) : une semaine travaillée sous les heures contractuelles génère un déficit qui réduit le cumul RTT (1h manquante = -1h), sans tranches 25/50. Le cumul peut devenir négatif et est reporté à l\'exercice suivant.' },
+```
+
+- [ ] **Step 5: `doc/rtt-tab.md` — ajouter une sous-section règle CUSTOM**
+
+Après la section « Période affichée » (avant « Sélecteur d'année »), insérer :
+
+```markdown
+## Règle de calcul — contrats CUSTOM (4h, 25h…)
+
+Pour un contrat CUSTOM, la récupération est **plate** (1h sup = 1h récup, sans bonus 25 %/50 %).
+Depuis 2026-06, une semaine **travaillée sous les heures contractuelles** produit un **déficit
+signé** dans la colonne « Heure » qui **réduit le « Total » et le « Cumul »** (1h manquante =
+-1h). Les colonnes Base/25 %/50 % restent à **0** (pas de tranches pour ces contrats). Le cumul
+peut devenir négatif ; il est reporté à l'exercice suivant.
+
+Techniquement : `WeekRecoveryDetail::isFlatRecovery` marque ces semaines ;
+`EmployeeRttSummaryProvider::applyDeficitCascade` les exclut du drainage des tranches 25/50.
+```
+
+- [ ] **Step 6: `doc/rtt-rollover.md` — préciser que le déficit CUSTOM est reporté**
+
+Sous le point 3 (« calculer le solde de clôture… ») / la « Règle clef » (ligne ~97), ajouter :
+
+```markdown
+> Contrats CUSTOM : le solde de clôture intègre désormais les **déficits** hebdomadaires
+> (semaines travaillées sous les heures contractuelles), via `RttClosingBalanceService::fold`
+> qui gère les totaux négatifs. La clôture (donc le report d'ouverture N+1) peut être négative.
+> Après une mise à jour de cette règle, rejouer `app:rtt:rollover --force --recompute` pour
+> recalculer les lignes `employee_rtt_balances` non verrouillées calculées avec l'ancienne règle.
+```
+
+- [ ] **Step 7: Build frontend (vérifier que le TS compile)**
+
+Run: `docker exec php-sirh-fpm true` (no-op) puis localement : ne PAS lancer `npm run build` (préférence utilisateur). Vérifier visuellement que les chaînes ajoutées échappent bien les apostrophes (`\'`).
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add CLAUDE.md frontend/data/documentation-content.ts doc/rtt-tab.md doc/rtt-rollover.md
+git commit -m "docs(rtt): custom contract deficit now reduces the balance"
+```
+
+---
+
+### Task 7: Vérification métier sur données prod + suite complète
+
+**Files:** aucun (vérification).
+
+- [ ] **Step 1: Lancer toute la suite de tests**
+
+Run: `make test`
+Expected: PASS (aucune régression).
+
+- [ ] **Step 2: Vérifier Ewa / Nadia via le snapshot de vérification (ou requête API)**
+
+Générer un snapshot « after » et confirmer que pour Ewa (id 31, exercice 2027) la semaine 23 affiche : Heure −2h, Total −2h, Cumul −2h, colonnes 25/50 = 0 ; et que Nadia (id 22) reste cohérente.
+
+Run (exemple, adapter à la signature réelle du command) :
+`docker exec php-sirh-fpm sh -c 'cd /var/www/html && php bin/console app:dump-verification-snapshot --help'`
+
+Comparer `docs/verifications/` (before) et le nouveau snapshot.
+
+- [ ] **Step 3: Note de déploiement**
+
+Consigner dans la PR : après déploiement, exécuter
+`php bin/console app:rtt:rollover --force --recompute`
+pour rafraîchir les reports stockés (lignes non verrouillées) calculés avec l'ancienne règle (déficit = 0).
+
+---
+
+## Self-Review
+
+- **Spec coverage** : (1) déficit signé CUSTOM → Task 3 ; (2) cumul réduit + cascade non drainée → Task 4 ; (3) report N+1 → Task 2 (fold déjà OK) + note rollover Task 6/7 ; (4) affichage propre (frontend inchangé) → couvert par buckets 0 ; (5) command de vérification → Task 5 ; (6) docs → Task 6. ✓
+- **Placeholders** : aucun — code complet à chaque étape.
+- **Cohérence des types** : `isFlatRecovery` (bool) ajouté de façon identique aux 2 DTOs ; `buildWeekRecoveryDetail` et `applyDeficitCascade` ont des signatures fixes utilisées de manière cohérente entre tâches et tests. ✓

docs/superpowers/plans/2026-06-11-rtt-solidarity-day-deficit.md

@@ -0,0 +1,522 @@
+# RTT — Déficit jour de solidarité (CUSTOM < 35h) — Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Sur le Lundi de Pentecôte, retrancher au cumul RTT des contrats CUSTOM < 35h un déficit forfaitaire de `7/35 × heuresHebdo` (= 12 min/heure hebdo), net et inconditionnel, sans rien changer aux autres contrats.
+
+**Architecture :** Un service pur `SolidarityDayResolver` calcule le Lundi de Pentecôte par computus (Pâques + 50 j). `RttRecoveryComputationService::computeRecoveryByWeek` (calcul partagé : onglet RTT, clôture/rollover, commande de vérification) neutralise le jour de solidarité pour les CUSTOM < 35h et applique le prorata, en le faisant transiter par `totalMinutes` via le mécanisme `isFlatRecovery` existant (reporté en N+1, ne draine pas les tranches 25/50).
+
+**Tech Stack :** PHP 8.4, Symfony, PHPUnit. Tests purs via `ReflectionClass::newInstanceWithoutConstructor` (pattern existant dans `RttRecoveryComputationServiceTest`).
+
+**Spec :** `docs/superpowers/specs/2026-06-11-rtt-solidarity-day-deficit-design.md`
+
+---
+
+## File Structure
+
+- **Create** `src/Service/Rtt/SolidarityDayResolver.php` — service pur, computus de Pâques + Lundi de Pentecôte. Responsabilité unique : donner la date du jour de solidarité d'une année.
+- **Create** `tests/Service/Rtt/SolidarityDayResolverTest.php` — tests des dates 2024/2025/2026.
+- **Modify** `src/Service/Rtt/RttRecoveryComputationService.php` — injecter `SolidarityDayResolver` ; ajouter `resolveSolidarityDatesInRange()` + `computeSolidarityDeficitAdjustment()` ; appliquer dans `computeRecoveryByWeek()`.
+- **Modify** `tests/Service/Rtt/RttRecoveryComputationServiceTest.php` — tests réflexion de `computeSolidarityDeficitAdjustment()`.
+- **Modify (docs)** `CLAUDE.md`, `frontend/data/documentation-content.ts`, `doc/rtt-tab.md`, `doc/functional-rules.md`.
+- **Inchangé** : `config/services.yaml` (autowiring : `SolidarityDayResolver` est un service autowireable, et `RttRecoveryComputationService` n'override que `$rttStartDate` — les autres args s'autowirent), `DumpVerificationSnapshotCommand.php` (consomme `WeekRecoveryDetail.totalMinutes`, hérite du déficit), `RttTab.vue`, migrations.
+
+---
+
+## Task 1: SolidarityDayResolver (computus Pâques + Pentecôte)
+
+**Files:**
+- Create: `src/Service/Rtt/SolidarityDayResolver.php`
+- Test: `tests/Service/Rtt/SolidarityDayResolverTest.php`
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/Service/Rtt/SolidarityDayResolverTest.php`:
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Service\Rtt;
+
+use App\Service\Rtt\SolidarityDayResolver;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @internal
+ */
+final class SolidarityDayResolverTest extends TestCase
+{
+    /**
+     * Lundi de Pentecôte = dimanche de Pâques + 50 jours.
+     * 2024 : Pâques 31/03 → 20/05 ; 2025 : Pâques 20/04 → 09/06 ; 2026 : Pâques 05/04 → 25/05.
+     *
+     * @dataProvider pentecostCases
+     */
+    public function testPentecostMonday(int $year, string $expected): void
+    {
+        $resolver = new SolidarityDayResolver();
+
+        self::assertSame($expected, $resolver->pentecostMonday($year)->format('Y-m-d'));
+    }
+
+    /**
+     * @return iterable<string, array{int, string}>
+     */
+    public static function pentecostCases(): iterable
+    {
+        yield '2024' => [2024, '2024-05-20'];
+        yield '2025' => [2025, '2025-06-09'];
+        yield '2026' => [2026, '2026-05-25'];
+    }
+}
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `make test` (or `docker exec php-sirh-fpm php bin/phpunit tests/Service/Rtt/SolidarityDayResolverTest.php`)
+Expected: FAIL — `Class "App\Service\Rtt\SolidarityDayResolver" not found`.
+
+- [ ] **Step 3: Write the implementation**
+
+Create `src/Service/Rtt/SolidarityDayResolver.php`:
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service\Rtt;
+
+use DateTimeImmutable;
+
+/**
+ * Résout le jour de solidarité (Lundi de Pentecôte) d'une année.
+ *
+ * Pur et déterministe : Pâques via l'algorithme de Meeus/Jones/Butcher (calendrier
+ * grégorien), sans dépendance à l'extension calendar ni au réseau. Lundi de Pentecôte
+ * = dimanche de Pâques + 50 jours.
+ */
+final class SolidarityDayResolver
+{
+    public function pentecostMonday(int $year): DateTimeImmutable
+    {
+        return $this->easterSunday($year)->modify('+50 days');
+    }
+
+    private function easterSunday(int $year): DateTimeImmutable
+    {
+        $a = $year % 19;
+        $b = intdiv($year, 100);
+        $c = $year % 100;
+        $d = intdiv($b, 4);
+        $e = $b % 4;
+        $f = intdiv($b + 8, 25);
+        $g = intdiv($b - $f + 1, 3);
+        $h = (19 * $a + $b - $d - $g + 15) % 30;
+        $i = intdiv($c, 4);
+        $k = $c % 4;
+        $l = (32 + 2 * $e + 2 * $i - $h - $k) % 7;
+        $m = intdiv($a + 11 * $h + 22 * $l, 451);
+
+        $month = intdiv($h + $l - 7 * $m + 114, 31);
+        $day   = (($h + $l - 7 * $m + 114) % 31) + 1;
+
+        return new DateTimeImmutable(sprintf('%04d-%02d-%02d', $year, $month, $day));
+    }
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `make test`
+Expected: PASS (3 nouveaux tests verts, le reste de la suite inchangé).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/Service/Rtt/SolidarityDayResolver.php tests/Service/Rtt/SolidarityDayResolverTest.php
+git commit -m "feat(rtt) : add SolidarityDayResolver (Pentecost Monday via computus)"
+```
+
+---
+
+## Task 2: Déficit solidarité dans RttRecoveryComputationService
+
+**Files:**
+- Modify: `src/Service/Rtt/RttRecoveryComputationService.php`
+- Test: `tests/Service/Rtt/RttRecoveryComputationServiceTest.php`
+
+Le helper `computeSolidarityDeficitAdjustment()` est **pur** (n'utilise que `ContractType::resolve` et les getters de `Contract`) → testable via `newInstanceWithoutConstructor` comme les autres helpers du fichier. Il renvoie le **delta** à ajouter à `weeklyOvertimeTotalMinutes`.
+
+Rappel arithmétique (Ewa, 4h, lundi, `expected = workDaysHours[lundi] = 120`, `prorata = round(4×12) = 48`) :
+- RTT posé / jour vide (`worked = 0`) → delta `(120−0)−48 = +72` ; appliqué au naturel `−120` ⇒ semaine **−48 min**.
+- travaillé normalement (`worked = 120`) → delta `(120−120)−48 = −48` ; naturel `0` ⇒ **−48 min**.
+- travaillé en plus (`worked = 240`) → delta `(120−240)−48 = −168` ; naturel `+120` ⇒ **−48 min**.
+
+- [ ] **Step 1: Write the failing test (pure helper)**
+
+Add these methods to `tests/Service/Rtt/RttRecoveryComputationServiceTest.php` (before the `invokePrivate` helper). Note `use` additions at top: `use App\Enum\TrackingMode;` (already imports `App\Entity\Contract`).
+
+```php
+    private static function customContract(int $weeklyHours): Contract
+    {
+        return new Contract()
+            ->setName('Temps partiel')
+            ->setTrackingMode(TrackingMode::TIME)
+            ->setWeeklyHours($weeklyHours)
+        ;
+    }
+
+    /**
+     * CUSTOM 4h, jour de solidarité non travaillé (RTT posé ou vide) : delta = (attendu − 0) − prorata.
+     * attendu lundi = workDaysHours = 120 ; prorata = round(4×12) = 48 ; delta = 120 − 48 = 72.
+     * (Combiné au naturel −120 de la semaine, donne −48 min.)
+     */
+    public function testSolidarityAdjustmentCustomNotWorkedNeutralisesToProrata(): void
+    {
+        $service = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+
+        $delta = $this->invokePrivate(
+            $service,
+            'computeSolidarityDeficitAdjustment',
+            self::customContract(4),
+            120, // expectedMinutes (workDaysHours du lundi)
+            0,   // workedMinutes (RTT posé / vide)
+        );
+
+        self::assertSame(72, $delta);
+    }
+
+    /**
+     * CUSTOM 4h, jour de solidarité travaillé normalement (120) : delta = (120 − 120) − 48 = −48.
+     */
+    public function testSolidarityAdjustmentCustomWorkedNormallyChargesProrata(): void
+    {
+        $service = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+
+        $delta = $this->invokePrivate($service, 'computeSolidarityDeficitAdjustment', self::customContract(4), 120, 120);
+
+        self::assertSame(-48, $delta);
+    }
+
+    /**
+     * CUSTOM 4h, jour de solidarité travaillé en plus (240) : delta = (120 − 240) − 48 = −168.
+     * Le surplus du jour de solidarité n'est PAS crédité (jour neutralisé, net forcé à −prorata).
+     */
+    public function testSolidarityAdjustmentCustomWorkedExtraStillNetsProrata(): void
+    {
+        $service = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+
+        $delta = $this->invokePrivate($service, 'computeSolidarityDeficitAdjustment', self::customContract(4), 120, 240);
+
+        self::assertSame(-168, $delta);
+    }
+
+    /**
+     * CUSTOM 28h : prorata = round(28×12) = 336 (5h36). worked 0, expected 336 → delta 0.
+     */
+    public function testSolidarityAdjustmentCustom28hUsesProrata(): void
+    {
+        $service = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+
+        $delta = $this->invokePrivate($service, 'computeSolidarityDeficitAdjustment', self::customContract(28), 336, 0);
+
+        self::assertSame(0, $delta);
+    }
+
+    /**
+     * CUSTOM ≥ 35h (36h) : hors périmètre → delta 0.
+     */
+    public function testSolidarityAdjustmentCustom36hOutOfScope(): void
+    {
+        $service = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+
+        $delta = $this->invokePrivate($service, 'computeSolidarityDeficitAdjustment', self::customContract(36), 999, 0);
+
+        self::assertSame(0, $delta);
+    }
+
+    /**
+     * 35h : type H35 (pas CUSTOM) → delta 0 (comportement inchangé, RTT posé fait foi).
+     */
+    public function testSolidarityAdjustment35hOutOfScope(): void
+    {
+        $service  = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+        $contract = new Contract()->setName('35h')->setTrackingMode(TrackingMode::TIME)->setWeeklyHours(35);
+
+        $delta = $this->invokePrivate($service, 'computeSolidarityDeficitAdjustment', $contract, 420, 0);
+
+        self::assertSame(0, $delta);
+    }
+
+    /**
+     * Aucun contrat ce jour-là (salarié parti / pas encore embauché) → delta 0.
+     */
+    public function testSolidarityAdjustmentNoContractIsZero(): void
+    {
+        $service = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+
+        $delta = $this->invokePrivate($service, 'computeSolidarityDeficitAdjustment', null, 0, 0);
+
+        self::assertSame(0, $delta);
+    }
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `make test`
+Expected: FAIL — `computeSolidarityDeficitAdjustment` n'existe pas (réflexion : `Method ... does not exist`).
+
+- [ ] **Step 3: Add the constructor dependency**
+
+In `src/Service/Rtt/RttRecoveryComputationService.php`, add `SolidarityDayResolver` to the constructor (BEFORE the defaulted `$rttStartDate`, sinon erreur « param non-défaut après défaut »). `SolidarityDayResolver` est dans le même namespace `App\Service\Rtt` → aucun `use` à ajouter.
+
+```php
+    public function __construct(
+        private WorkHourRepository $workHourRepository,
+        private AbsenceRepository $absenceRepository,
+        private AbsenceSegmentsResolver $absenceSegmentsResolver,
+        private WorkedHoursCreditPolicy $workedHoursCreditPolicy,
+        private EmployeeContractResolver $contractResolver,
+        private DailyReferenceMinutesResolver $dailyReferenceResolver,
+        private HolidayVirtualHoursResolver $holidayVirtualHoursResolver,
+        private SolidarityDayResolver $solidarityDayResolver,
+        string $rttStartDate = '',
+    ) {
+        $this->rttStartDate = '' !== $rttStartDate ? new DateTimeImmutable($rttStartDate) : null;
+    }
+```
+
+- [ ] **Step 4: Add the two private methods**
+
+In the same file, add these methods (e.g. just after `resolveWeekAnchorDate`, alongside the other private helpers):
+
+```php
+    /**
+     * Lundi(s) de Pentecôte (jour de solidarité) inclus dans [from, to]. Un exercice
+     * Juin N-1 → Mai N couvre les années civiles N-1 et N ; on retient les dates dans la fenêtre.
+     *
+     * @return list<string> dates au format 'Y-m-d'
+     */
+    private function resolveSolidarityDatesInRange(DateTimeImmutable $from, DateTimeImmutable $to): array
+    {
+        $dates     = [];
+        $firstYear = (int) $from->format('Y');
+        $lastYear  = (int) $to->format('Y');
+
+        for ($year = $firstYear; $year <= $lastYear; ++$year) {
+            $candidate = $this->solidarityDayResolver->pentecostMonday($year);
+            if ($candidate >= $from && $candidate <= $to) {
+                $dates[] = $candidate->format('Y-m-d');
+            }
+        }
+
+        return $dates;
+    }
+
+    /**
+     * Déficit forfaitaire du jour de solidarité pour les contrats CUSTOM < 35h.
+     *
+     * Le jour est neutralisé puis chargé du prorata légal : on remplace la valeur réelle
+     * du jour ($workedMinutes : RTT posé, heures saisies, vide, ou crédit férié virtuel)
+     * par l'attendu contractuel du jour ($expectedMinutes = workDaysHours), puis on
+     * retranche le prorata = 7h/35h × heuresHebdo = 12 min par heure hebdo. Sur une
+     * semaine par ailleurs normale, le net vaut exactement −prorata. Renvoie le delta à
+     * ajouter à weeklyOvertimeTotalMinutes (0 hors périmètre : non-CUSTOM ou ≥ 35h).
+     */
+    private function computeSolidarityDeficitAdjustment(
+        ?Contract $contractAtSolidarity,
+        int $expectedMinutes,
+        int $workedMinutes,
+    ): int {
+        $weeklyHours = $contractAtSolidarity?->getWeeklyHours();
+        $type        = ContractType::resolve(
+            $contractAtSolidarity?->getName(),
+            $contractAtSolidarity?->getTrackingMode(),
+            $weeklyHours,
+        );
+
+        if (ContractType::CUSTOM !== $type || null === $weeklyHours || $weeklyHours >= 35) {
+            return 0;
+        }
+
+        $prorata = (int) round($weeklyHours * 12);
+
+        return ($expectedMinutes - $workedMinutes) - $prorata;
+    }
+```
+
+- [ ] **Step 5: Wire it into `computeRecoveryByWeek`**
+
+(a) Just before the weeks loop, after `$results = [];` (≈ line 165), resolve the solidarity dates once:
+
+```php
+        $results         = [];
+        $solidarityDates = $this->resolveSolidarityDatesInRange($periodFrom, $periodTo);
+```
+
+(b) Inside the week loop, immediately after `$weeklyOvertimeTotalMinutes = ...` is computed (the `$isWeekPresenceTracking ? 0 : $weeklyTotalMinutes - $overtimeReferenceMinutes;` assignment, ≈ line 243-245) and BEFORE the `[$rawBase25, $rawBase50] = ...` line, insert:
+
+```php
+            foreach ($solidarityDates as $solidarityDate) {
+                // isset ⇒ le jour de solidarité fait partie du sommage de CETTE semaine
+                // (donc ≤ limitDate et ≥ rttStartDate). Sinon : jour futur ou hors service → pas de déficit.
+                if (!isset($dailyWorkedMinutes[$solidarityDate])) {
+                    continue;
+                }
+
+                $contractAtSolidarity = $employeeContractsByDate[$solidarityDate] ?? null;
+                $solidarityIsoDay     = (int) new DateTimeImmutable($solidarityDate)->format('N');
+                // Attendu RÉEL du jour (planning workDaysHours), pas la répartition uniforme :
+                // c'est ce qui rend la neutralisation correcte (cf. spec).
+                $solidarityExpected = $this->dailyReferenceResolver->resolve(
+                    $contractAtSolidarity?->getWeeklyHours(),
+                    $solidarityIsoDay,
+                    $workDaysByDate[$employeeId][$solidarityDate] ?? null,
+                );
+
+                $weeklyOvertimeTotalMinutes += $this->computeSolidarityDeficitAdjustment(
+                    $contractAtSolidarity,
+                    $solidarityExpected,
+                    $dailyWorkedMinutes[$solidarityDate],
+                );
+            }
+```
+
+- [ ] **Step 6: Run tests to verify they pass**
+
+Run: `make test`
+Expected: PASS — les 7 nouveaux tests verts, toute la suite verte (le pre-commit relance aussi la suite complète).
+
+- [ ] **Step 7: Verify the service container still builds (autowiring)**
+
+Run: `docker exec php-sirh-fpm php bin/console debug:container App\\Service\\Rtt\\RttRecoveryComputationService 2>&1 | tail -20`
+Expected: le service est listé, sans erreur d'argument non résolu (`SolidarityDayResolver` autowiré). Si erreur d'autowiring : ajouter explicitement l'argument dans `config/services.yaml` sous `RttRecoveryComputationService` — mais normalement inutile.
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add src/Service/Rtt/RttRecoveryComputationService.php tests/Service/Rtt/RttRecoveryComputationServiceTest.php
+git commit -m "feat(rtt) : solidarity-day deficit for CUSTOM <35h contracts"
+```
+
+---
+
+## Task 3: Vérification sur données de production
+
+**Files:** aucun fichier de code. Génère des snapshots « after » et compare.
+
+Contexte : le workflow before/after existe déjà (`docs/verifications/` = avant, `docs/verifications-after/` = après). La commande `app:verification:snapshot` rend la vue onglet RTT par mois.
+
+- [ ] **Step 1: Generate the "after" snapshot for the witnesses + a control**
+
+Ewa (id 31, CUSTOM 4h), Nadia (id 22, CUSTOM 4h), et un témoin 35h ou 39h (choisir un id présent — vérifier en base) pour prouver la non-régression.
+
+Run:
+```bash
+docker exec php-sirh-fpm php bin/console app:verification:snapshot 31 22 --rtt-year=2026 --output-dir=docs/verifications-after
+```
+Expected: génère les fichiers Markdown sans erreur.
+
+- [ ] **Step 2: Inspect Ewa's solidarity week (S22, semaine du 25/05/2026)**
+
+Ouvrir le snapshot d'Ewa (`docs/verifications-after/…`) et vérifier :
+- Semaine du 2026-05-25 : **Heure** et **Total** = −0h48 (−48 min), **Cumul** réduit de 48 min.
+- Colonnes 25 % / 50 % = 0 sur cette semaine.
+- La semaine du 2026-06-01 (lundi 1er juin) conserve son −2h existant, distinct.
+
+Si l'écart ne vaut pas −48 min : NE PAS « ajuster jusqu'à ce que ça passe ». Relire `computeSolidarityDeficitAdjustment` et la valeur `expectedMinutes` (doit valoir `workDaysHours[lundi]`, ex. 120) — un écart signale un bug réel (utiliser systematic-debugging).
+
+- [ ] **Step 3: Confirm non-regression for a standard contract**
+
+Snapshot d'un employé 35h/39h ayant un RTT posé sur le 25/05/2026 : la semaine doit être **inchangée** vs `docs/verifications/` (le déficit solidarité ne s'applique pas, le RTT posé garde son effet).
+
+- [ ] **Step 4: Commit the after-snapshots (regression baseline)**
+
+```bash
+git add docs/verifications-after
+git commit -m "test(rtt) : after-snapshot proving solidarity deficit on Ewa/Nadia S22"
+```
+
+---
+
+## Task 4: Documentation (règle projet obligatoire)
+
+**Files:**
+- Modify: `CLAUDE.md`
+- Modify: `doc/functional-rules.md`
+- Modify: `doc/rtt-tab.md`
+- Modify: `frontend/data/documentation-content.ts`
+
+- [ ] **Step 1: CLAUDE.md — section Overtime Rules**
+
+Sous la puce CUSTOM existante (« CUSTOM contracts … Le déficit … réduit le cumul RTT 1:1 »), ajouter une sous-puce :
+
+```markdown
+  - **Jour de solidarité (Lundi de Pentecôte) — CUSTOM < 35h** : le jour est neutralisé et chargé d'un déficit forfaitaire `7/35 × weeklyHours` = **12 min par heure hebdo** (4h→48 min, 25h→5h, 28h→5h36), retranché du cumul RTT (signé, reporté N+1, ne draine pas les tranches 25/50). Net = exactement −prorata quel que soit ce qui est posé ce jour-là (RTT, heures, vide) → pas de double comptage avec le RTT que la RH pose aussi sur ce jour. Hors périmètre : 35h/39h/Forfait/Intérim et CUSTOM ≥ 35h (inchangés ; la RH pose un RTT qui draine ~7h). Date via `App\Service\Rtt\SolidarityDayResolver` (computus, indépendant d'`EXCLUDED_PUBLIC_HOLIDAYS`). Appliqué dans `RttRecoveryComputationService::{resolveSolidarityDatesInRange, computeSolidarityDeficitAdjustment}`.
+```
+
+- [ ] **Step 2: doc/functional-rules.md**
+
+Dans la section RTT / heures supplémentaires (près des règles CUSTOM), ajouter un paragraphe :
+
+```markdown
+### Jour de solidarité (contrats CUSTOM < 35h)
+
+Le Lundi de Pentecôte (jour de solidarité) impose une contribution proratisée aux temps
+partiels < 35h. La RH pose un RTT sur ce jour pour tous les salariés ; pour les contrats
+standard (35h/39h) cela draine ~7h du cumul RTT (comportement inchangé). Pour les CUSTOM
+< 35h, poser un RTT entier n'a pas de sens : le logiciel **neutralise** le jour (quel que
+soit ce qui y est saisi) et applique un déficit forfaitaire `7/35 × heuresHebdo`
+(= 12 min par heure hebdo : 4h → 48 min, 28h → 5h36). Ce déficit réduit le cumul RTT
+(peut le rendre négatif, reporté à l'exercice suivant) et se cumule avec les autres
+déficits/surplus de la semaine. Date calculée par computus (Pâques + 50 jours),
+indépendante de la liste `EXCLUDED_PUBLIC_HOLIDAYS`.
+```
+
+- [ ] **Step 3: doc/rtt-tab.md**
+
+Dans la section « Règle de calcul — contrats CUSTOM », ajouter un sous-bloc :
+
+```markdown
+#### Jour de solidarité (CUSTOM < 35h)
+
+Sur la semaine du Lundi de Pentecôte, un contrat CUSTOM < 35h porte un déficit
+forfaitaire de `7/35 × heuresHebdo` (12 min/h hebdo, ex. 4h → −0h48) dans les colonnes
+Heure / Total / Cumul (25 %/50 % restent à 0). Le montant est fixe et inconditionnel :
+il ne dépend pas des heures saisies ni du RTT que la RH pose ce jour-là. Les contrats
+35h/39h ne sont pas concernés ici (leur RTT posé draine le cumul normalement).
+```
+
+- [ ] **Step 4: frontend/data/documentation-content.ts**
+
+Repérer l'article RTT pour les contrats partiels / CUSTOM (recherche `CUSTOM` ou `rtt-compteurs`). Ajouter un bloc de texte (échapper les apostrophes `\'`) décrivant la règle :
+
+```
+Jour de solidarité : pour un contrat de moins de 35h, le Lundi de Pentecôte applique un
+déficit fixe proportionnel (7/35 des heures hebdo, soit 12 minutes par heure
+hebdomadaire : 4h → 48 min). Ce déficit réduit le cumul RTT, peu importe ce qui est saisi
+ce jour-là.
+```
+
+Respecter la structure `DocBlock` existante (même type de bloc que les paragraphes voisins).
+
+- [ ] **Step 5: Run the suite and commit**
+
+Run: `make test`
+Expected: PASS (les docs ne cassent rien ; la suite reste verte).
+
+```bash
+git add CLAUDE.md doc/functional-rules.md doc/rtt-tab.md frontend/data/documentation-content.ts
+git commit -m "docs(rtt) : document solidarity-day deficit for CUSTOM <35h"
+```
+
+---
+
+## Self-review (rempli pendant la rédaction)
+
+- **Couverture spec** : SolidarityDayResolver (T1) ✓ ; injection + neutralisation + prorata dans computeRecoveryByWeek (T2) ✓ ; périmètre CUSTOM < 35h + garde ≥ 35h (T2, `computeSolidarityDeficitAdjustment`) ✓ ; robustesse limitDate/rttStartDate via `isset($dailyWorkedMinutes)` (T2 step 5) ✓ ; contrat lu au jour de solidarité (T2 step 5) ✓ ; propagation clôture/rollover/snapshot via totalMinutes (inchangé, vérifié T3) ✓ ; cas limites (T2 tests + T3) ✓ ; docs (T4) ✓.
+- **Pas de placeholder** : tout le code est fourni.
+- **Cohérence des noms** : `pentecostMonday`, `resolveSolidarityDatesInRange`, `computeSolidarityDeficitAdjustment`, `$solidarityDayResolver`, `$dailyReferenceResolver`, `$workDaysByDate`, `$employeeId`, `$dailyWorkedMinutes`, `$employeeContractsByDate` — alignés avec le code existant de `computeRecoveryByWeek`.

docs/superpowers/specs/2026-06-09-rtt-custom-deficit-design.md

@@ -0,0 +1,118 @@
+# Déficit RTT pris en compte pour les contrats CUSTOM (4h, etc.)
+
+Date : 2026-06-09
+Branche : `feature/SIRH-36-corriger-le-calcule-des-rtt-des-contrat-4h`
+
+## Contexte & problème
+
+Les salariées avec un contrat 4h (type CUSTOM : `weeklyHours` ≠ 35/39, non INTERIM/FORFAIT,
+mode TIME) voient, dans l'onglet RTT, des semaines travaillées **en dessous** de leurs heures
+contractuelles afficher un déficit dans la colonne « Heure » (ex. Ewa S23 : −2h) **sans aucun
+effet** : « Total » = 0 et « Cumul » = 0.
+
+Cause : `RttRecoveryComputationService::computeRecoveryByWeek` écrête le total hebdo des CUSTOM
+avec `totalMinutes = max(0, $weeklyOvertimeTotalMinutes)`. Le déficit est donc supprimé. C'est
+le comportement métier documenté jusqu'ici (« CUSTOM : le déficit n'impacte pas le solde »).
+
+Décision métier (validée avec le client) : **le déficit doit être pris en compte et réduire le
+cumul**, comme pour les 35h/39h, avec un affichage propre dans l'onglet RTT.
+
+## Décisions validées
+
+1. **Le cumul peut devenir négatif** (identique aux 35h/39h, comportement déjà assumé dans le
+   code — cf. `RttClosingBalanceService::fold` ligne 98 « leftover may push the balance
+   negative, as on screen »). Le négatif est reporté à l'exercice suivant.
+2. **Déficit visible** en colonnes « Heure » + « Total » + « Cumul ». Les colonnes 25%/50%
+   restent à **0** pour un contrat CUSTOM (un 4h n'a pas de bonus, donc pas de tranches).
+
+## Principe technique
+
+Retirer l'écrêtage `max(0, …)` pour les semaines CUSTOM : le déficit (négatif) circule dans
+`WeekRecoveryDetail::totalMinutes` et réduit le cumul. La seule spécificité CUSTOM reste :
+récupération 1h = 1h, sans bonus 25/50.
+
+### Le point délicat : ne pas drainer les tranches 25/50
+
+Pour un 35h/39h, une semaine déficitaire **draine** les tranches 25/50 accumulées via la cascade
+de `EmployeeRttSummaryProvider` (lignes 149-174) et de `RttClosingBalanceService::fold` (lignes
+92-99), ce qui affiche des valeurs négatives en « Total 25% / 50% ».
+
+Pour un CUSTOM, la récup n'est jamais bucketisée (elle vit uniquement dans `totalMinutes`). La
+cascade ne doit donc **pas** s'appliquer aux semaines CUSTOM, sinon le déficit apparaîtrait en
+négatif dans « Total 25% » (affichage sale, et incohérent avec les récups positives qui, elles,
+n'y figurent pas).
+
+Solution : un drapeau **`isFlatRecovery`** (récupération plate 1:1, sans tranches) porté par la
+semaine, qui désactive la cascade dans le provider.
+
+## Changements
+
+### Backend
+
+1. **`src/Dto/Rtt/WeekRecoveryDetail.php`** : ajout `public bool $isFlatRecovery = false`.
+2. **`src/Dto/Rtt/EmployeeRttWeekSummary.php`** : ajout `public bool $isFlatRecovery = false`.
+3. **`src/Service/Rtt/RttRecoveryComputationService.php`**
+   (`computeRecoveryByWeek`, branche `$isCustomContract`) :
+   - `totalMinutes = $weeklyOvertimeTotalMinutes` (signé — plus de `max(0, …)`).
+   - `isFlatRecovery: true` sur le `WeekRecoveryDetail` retourné.
+   - Les buckets `base25/bonus25/base50/bonus50` restent à 0 (inchangé).
+   - Cas non-CUSTOM et PRESENCE/INTERIM inchangés (`isFlatRecovery` reste `false`).
+4. **`src/State/EmployeeRttSummaryProvider.php`**
+   - `buildWeekSummaries` : propager `isFlatRecovery` du `WeekRecoveryDetail` vers
+     l'`EmployeeRttWeekSummary` — dans le cas mono-mois **et** dans le cas semaine à cheval sur
+     deux mois (les deux instances héritent du drapeau).
+   - Cascade déficit (ligne 150) : condition devient
+     `if ($week->totalMinutes >= 0 || $week->isFlatRecovery)`. Pour une semaine CUSTOM
+     déficitaire, on ne draine pas : les buckets restent 0, `cumulativeBalanceMinutes`
+     (déjà basé sur `totalMinutes`, ligne 197) intègre le déficit.
+   - Dans la reconstruction de la branche `else` (semaine déficitaire normale), conserver
+     explicitement `isFlatRecovery: $week->isFlatRecovery` (toujours `false` à ce point, mais
+     explicite pour la clarté).
+5. **`src/Command/DumpVerificationSnapshotCommand.php`** : ce command duplique la cascade du
+   provider (lignes ~695-716). Mettre à jour la condition de cascade pour respecter
+   `isFlatRecovery`, et propager le drapeau dans sa reconstruction des week summaries, afin que
+   les snapshots before/after restent fidèles à l'app.
+
+### Aucun changement
+
+- **`src/Service/Rtt/RttClosingBalanceService.php`** : `fold` gère déjà `totalMinutes` négatif
+  (branche déficit lignes 92-99) et le remainder CUSTOM (lignes 83-87). Le report N+1 intègre
+  donc automatiquement le déficit. Pas de modification.
+- **`frontend/components/employees/RttTab.vue`** : aucun. Les sous-colonnes Base/25%/50% sont
+  déjà écrêtées à 0 sur les semaines déficitaires (`totalMinutes >= 0 ? … : 0`). Avec buckets =
+  0 côté back, « Total 25%/50% » = 0, et « Heure »/« Total »/« Cumul » affichent le déficit.
+- **Pas de migration** : aucun changement de schéma.
+
+## Effets de bord (assumés, cohérents)
+
+- **Récap congés** (`LeaveRecapRowBuilder::…` via `computeTotalRecoveryForExercise`) : la valeur
+  RTT reflètera aussi les déficits et peut devenir négative. Cohérent avec la décision.
+- **Rollover / report** : la clôture d'exercice (`computeClosingBalance`) intègre désormais les
+  déficits. Les lignes `employee_rtt_balances` déjà stockées (calculées avec l'ancienne logique,
+  déficit = 0) doivent être rafraîchies après déploiement :
+  `php bin/console app:rtt:rollover --force --recompute` (ne touche pas les lignes
+  `is_locked`). Ex. Ewa : clôture 2026 passe de 0 à −2h, donc report d'ouverture 2027 = −2h.
+- **Carry / Report row** : pour un CUSTOM, le report reste stocké/affiché dans la tranche
+  `base25` (convention pré-existante du `fold`, remainder parking) — comportement inchangé, hors
+  périmètre.
+
+## Tests (TDD)
+
+- **`tests/Service/Rtt/RttClosingBalanceServiceTest.php`** : nouveau cas — un `WeekRecoveryDetail`
+  CUSTOM **déficitaire** (`totalMinutes` négatif) diminue bien la clôture (somme = report +
+  Σ semaines − payés, négatif inclus).
+- **`tests/State/EmployeeRttSummaryProviderTest.php`** : semaine CUSTOM déficitaire
+  (`isFlatRecovery = true`, `totalMinutes < 0`) → buckets 25/50 restent 0, `cumulativeBalance`
+  réduit du déficit (pas de drainage des tranches). Vérifier aussi qu'une semaine 35h/39h
+  déficitaire continue de drainer (non-régression).
+- **`tests/Service/Rtt/RttRecoveryComputationServiceTest.php`** : si réalisable en intégration —
+  contrat CUSTOM, semaine travaillée sous les heures → `totalMinutes` négatif et
+  `isFlatRecovery = true`.
+
+## Documentation (obligatoire, même intervention)
+
+- `doc/rtt-rollover.md` et/ou `doc/rtt-tab.md` : mettre à jour la règle CUSTOM (déficit
+  désormais compté).
+- `frontend/data/documentation-content.ts` : section RTT — déficit des contrats CUSTOM.
+- `CLAUDE.md` : section « Overtime Rules » — corriger « deficit doesn't impact balance » pour les
+  CUSTOM ; documenter `isFlatRecovery`.

docs/superpowers/specs/2026-06-11-night-hours-contingent-export-design.md

@@ -0,0 +1,132 @@
+# Export « Contingent H.nuit »
+
+Date : 2026-06-11
+Statut : validé (design)
+
+## Objectif
+
+Ajouter un nouvel export PDF sur la **liste des employés** : un tableau du
+contingent d'heures de nuit, employés en lignes, mois en colonnes. Chaque mois
+porte deux sous-colonnes : **Total H.nuit** (heures travaillées de nuit) et
+**Total N.jours** (nombre de nuits où ≥ 4h ont été travaillées de nuit).
+
+## Décisions cadrées
+
+- **Période** : année civile Janvier → Décembre, choisie via un sélecteur d'année
+  dans le drawer (réutilise `exportYearOptions`).
+- **Fenêtre de nuit** : 21h → 6h — on **réutilise le calcul existant** de l'app
+  (constante `[0,360]` + `[1260,1440]` minutes, projection J+1 pour les shifts
+  traversant minuit). NB : la demande initiale mentionnait 21h-5h ; arbitré sur
+  21h→6h pour rester cohérent avec le reste de l'application.
+- **Règle « 1 jour »** : un jour compte 1 dans « N.jours » dès que les minutes de
+  nuit du jour ≥ 240 (4h).
+- **Conducteurs** : inclus. Leurs minutes de nuit = champ manuel
+  `WorkHour.nightHoursMinutes` (pas de fenêtre horaire — total saisi). La règle
+  ≥ 240 min = 1 jour s'applique aussi.
+- **Non-conducteurs** : minutes de nuit calculées depuis les plages
+  matin/après-midi/soir via la fenêtre 21h→6h.
+- **Pas de crédit** absence/férié : on ne compte que les heures de nuit
+  réellement travaillées (pas de crédit virtuel férié ni crédit absence).
+- **Pas de colonne « Total annuel »** (hors périmètre pour l'instant).
+- **Mise en page** : A4 **paysage**.
+- **Groupement / tri** : par site, identique au day-export et au calendrier —
+  sites triés par `displayOrder` puis nom ; employés triés par `displayOrder`,
+  puis nom, puis prénom.
+
+## Architecture
+
+### Frontend
+
+`frontend/pages/employees/index.vue` (drawer Export existant) :
+- Ajouter une option `{ label: 'Contingent H.nuit', value: 'night-contingent' }`
+  dans `exportTypeOptions`.
+- Quand `exportChoice === 'night-contingent'` : afficher le sélecteur d'année
+  (réutiliser le `MalioSelect` année déjà utilisé par `yearly-hours`).
+- `isExportValid` : valide si une année est choisie.
+- `handleExportValidate` : `await printPdf('/night-hours-contingent/print?year=' + exportYear)`.
+
+Aucun sélecteur de site (cohérent avec les autres exports de ce drawer — le
+périmètre vient du back via `findScoped`).
+
+### Backend
+
+**Endpoint** : `GET /night-hours-contingent/print?year=YYYY`
+- Operation API Platform custom (Provider, output PDF `Response`), `ROLE_USER`.
+- `year` : entier validé 2000-2100, défaut = année courante.
+
+**Provider** `App\State\NightHoursContingentPrintProvider`
+1. Auth + parse `year`.
+2. `employees = employeeRepository->findScoped($user)` (périmètre admin / chef de site).
+3. Garder les employés ayant ≥ 1 période de contrat intersectant
+   `[YYYY-01-01 ; YYYY-12-31]` (helper `hasContractInRange`, même esprit que
+   `AbsencePrintProvider`/`SalaryRecapPrintProvider`).
+4. Grouper par site ; trier sites par `displayOrder` puis nom ; trier employés
+   intra-site par `displayOrder`, nom, prénom.
+5. Construire les lignes via `NightContingentExportBuilder`.
+6. Rendre `templates/night-hours-contingent/print.html.twig` → Dompdf (paysage).
+
+**Builder** `App\Service\WorkHours\NightContingentExportBuilder`
+- `buildRows(list<Employee> $employees, int $year): list<NightContingentRow>`
+- Pour chaque employé : charge ses `WorkHour` de l'année (1 requête par lot ou
+  par employé selon le repo existant), répartit par mois (1..12).
+- Par jour : `nightMinutes = NightHoursCalculator::nightMinutesForWorkHour($wh, $isDriverThatDay)`.
+  - Driver ce jour-là → `nightHoursMinutes ?? 0`.
+  - Non-driver → somme des `nightIntervalMinutes` sur les 3 plages.
+- Agrégats par mois : `nightMinutesTotal += nightMinutes` ;
+  `if (nightMinutes >= 240) nightDays += 1`.
+- Retour DTO : `{ employeeId, employeeName, isDriver, months: [{nightMinutes, nightDays} × 12] }`.
+
+> Le statut driver est résolu **par date** (un employé peut changer de nature de
+> contrat dans l'année), via le mécanisme existant (`EmployeeContractResolver` /
+> période de contrat couvrant la date du `WorkHour`). On suit l'approche déjà en
+> place dans les providers heures pour résoudre `isDriver` à la date.
+
+**Service partagé** `App\Service\WorkHours\NightHoursCalculator`
+- Extrait la logique 21h→6h aujourd'hui **dupliquée** dans
+  `WorkHourWeeklySummaryProvider::nightIntervalMinutes/computeMetrics` et
+  `YearlyHoursExportBuilder::nightIntervalMinutes/computeMetrics`.
+- Méthodes :
+  - `nightIntervalMinutes(?string $from, ?string $to): int` (fenêtres
+    `[0,360]` + `[1260,1440]`, projection J+1).
+  - `nightMinutesFromRanges(WorkHour $wh): int` (somme sur les 3 plages).
+  - `nightMinutesForWorkHour(WorkHour $wh, bool $isDriver): int`
+    (driver → `nightHoursMinutes ?? 0`, sinon `nightMinutesFromRanges`).
+- `WorkHourWeeklySummaryProvider` et `YearlyHoursExportBuilder` délèguent à ce
+  service pour la partie nuit (résultats identiques garantis ; les tests
+  existants couvrent la non-régression).
+
+### Template
+
+`templates/night-hours-contingent/print.html.twig`
+- A4 paysage.
+- En-tête : « Contingent heures de nuit — {{ year }} », date d'export.
+- Colonnes : `Nom` + 12 groupes de mois, chacun deux sous-colonnes
+  `H.nuit` / `N.jours`.
+- Lignes d'en-tête de site colorées (couleur site), comme le day-export.
+- `H.nuit` formaté `12h30` (helper minutes → HH h MM), `N.jours` entier.
+- Mois sans données → `0h00` / `0` (ou vide selon rendu — défaut 0).
+
+## Tests
+
+- `NightHoursCalculatorTest` : fenêtre 21h→6h, shift traversant minuit
+  (21:00→05:00 = 8h nuit), plage de jour pur (0 nuit), plages nulles.
+- `NightContingentExportBuilderTest` : agrégation mensuelle, règle ≥4h=1 jour
+  (3h59 → 0 jour, 4h → 1 jour), conducteur via `nightHoursMinutes`, employé
+  multi-mois.
+- Non-régression : `make test` (les tests existants de
+  `WorkHourWeeklySummaryProvider` / `YearlyHoursExportBuilder` valident le
+  refactor du service partagé).
+
+## Documentation à mettre à jour (même intervention)
+
+- `doc/functional-rules.md` : nouvelle section export contingent nuit.
+- `CLAUDE.md` : entrée sous une rubrique export.
+- `frontend/data/documentation-content.ts` : article utilisateur (niveau admin/
+  chef de site).
+
+## Hors périmètre
+
+- Colonne total annuel.
+- Sélecteur de site dans le drawer.
+- Export depuis un autre écran que la liste employés.
+- Changement de la fenêtre de nuit ailleurs dans l'app (reste 21h→6h partout).

docs/superpowers/specs/2026-06-11-rtt-solidarity-day-deficit-design.md

@@ -0,0 +1,170 @@
+# Design — Déficit « jour de solidarité » pour les contrats CUSTOM < 35h
+
+Date : 2026-06-11
+Branche : `feature/SIRH-36-corriger-le-calcule-des-rtt-des-contrat-4h`
+Statut : validé (brainstorming)
+
+## Contexte
+
+Le jour de solidarité (Lundi de Pentecôte) impose à chaque salarié une contribution
+de travail non rémunérée : 7h/an pour un temps plein (35h), proratisée pour les temps
+partiels. La RH matérialise cette contribution en **posant une absence de type RTT**
+sur le Lundi de Pentecôte pour **tous** les salariés, y compris les contrats < 35h.
+
+Pour les contrats standard (35h/39h), poser un RTT d'une journée draine ~7h du cumul RTT
+accumulé — ce qui correspond exactement à l'obligation. Ce comportement **fonctionne
+déjà et ne doit pas changer**.
+
+Pour les contrats **CUSTOM < 35h** (ex. 4h, 25h, 28h — `weeklyHours ≠ 35 et ≠ 39`,
+mode TIME), poser une absence RTT (type `R`, `countAsWorkedHours = false`) produit un
+déficit égal au **créneau travaillé du jour** (ex. Ewa, 4h, travaille 2h le lundi →
+−2h), et non au prorata légal attendu (`7/35 × 4h = 48 min`). Le montant naturel dépend
+du planning du jour, pas de l'obligation. C'est le bug à corriger.
+
+## Règle métier validée
+
+- **Périmètre** : contrats **CUSTOM avec `weeklyHours < 35`** uniquement. 35h, 39h,
+  Forfait, Intérim, et CUSTOM ≥ 35h : aucun changement.
+- **Date** : Lundi de Pentecôte (= Pâques + 50 jours), calculé par computus, indépendant
+  de l'env `EXCLUDED_PUBLIC_HOLIDAYS` (qui n'est plus la source de vérité).
+- **Montant** : `prorata = round(weeklyHours × 12)` minutes (7h/35h × 60 = 12 min par
+  heure hebdo). Ex. 4h → 48 min, 25h → 5h00, 28h → 5h36.
+- **Net forfaitaire et inconditionnel** : au net, le jour de solidarité vaut **exactement
+  `−prorata`** dans le cumul RTT, quel que soit ce qui est posé ce jour-là (absence RTT,
+  heures travaillées, ou rien). On **neutralise** l'effet naturel du jour puis on applique
+  le forfait. Garantit l'absence de double comptage avec le RTT posé par la RH, et reste
+  correct même si la RH oublie de poser le RTT.
+- **Cumul** : le déficit se cumule avec tout autre déficit/surplus de la même semaine,
+  réduit le cumul RTT (peut le rendre négatif), et est reporté à l'exercice suivant.
+
+## Architecture
+
+### Point d'injection unique
+
+Tout passe par `App\Service\Rtt\RttRecoveryComputationService::computeRecoveryByWeek`,
+le calcul **partagé** consommé par :
+- `EmployeeRttSummaryProvider` (onglet RTT),
+- `computeTotalRecoveryForExercise` → `RttClosingBalanceService` (clôture / rollover),
+- `DumpVerificationSnapshotCommand` (commande de vérification).
+
+En posant le déficit dans `totalMinutes` / `overtimeMinutes` à cet endroit, il se propage
+partout sans duplication. Le drapeau `isFlatRecovery` (déjà existant pour les CUSTOM)
+reste `true` → le provider ne draine pas les tranches 25/50 et le fold reporte le déficit
+en N+1.
+
+### Nouveau service pur : `SolidarityDayResolver`
+
+```
+final class SolidarityDayResolver
+{
+    // Lundi de Pentecôte = dimanche de Pâques + 50 jours.
+    public function pentecostMonday(int $year): DateTimeImmutable;
+
+    // Easter via l'algorithme de Meeus/Jones/Butcher (calendrier grégorien),
+    // sans dépendance à l'extension calendar PHP.
+    private function easterSunday(int $year): DateTimeImmutable;
+}
+```
+
+Pur, déterministe, aucune dépendance réseau (le chemin de calcul RTT n'a aujourd'hui
+aucune dépendance HTTP — on le préserve). Trivial à tester unitairement.
+
+### Modification de `computeRecoveryByWeek`
+
+Le service reçoit `SolidarityDayResolver` par injection. Avant la boucle des semaines, on
+résout les Lundi de Pentecôte des années civiles couvertes par `[periodFrom, periodTo]`
+(exercice Juin N-1 → Mai N → années N-1 et N) et on retient ceux dans la fenêtre.
+
+Dans la boucle, après le calcul de `weeklyOvertimeTotalMinutes` et **uniquement** quand
+un jour de solidarité `S` tombe dans la semaine **et** a été inclus dans le sommage
+(`isset($dailyWorkedMinutes[S])`, donc `S ≤ limitDate` et `S ≥ rttStartDate`) :
+
+```
+$contractAtS = $employeeContractsByDate[$S] ?? null;
+$weeklyHours = $contractAtS?->getWeeklyHours();
+$typeAtS     = ContractType::resolve($contractAtS?->getName(), $contractAtS?->getTrackingMode(), $weeklyHours);
+
+if (ContractType::CUSTOM === $typeAtS && null !== $weeklyHours && $weeklyHours < 35) {
+    $isoDayS      = (int) (new DateTimeImmutable($S))->format('N');
+    $workDaysForS = $workDaysByDate[$employeeId][$S] ?? null;       // {iso_day: minutes}
+    // Heures contractuelles RÉELLES du jour (planning workDaysHours), PAS la
+    // répartition uniforme weeklyHours/5 — c'est ce qui rend le net = -prorata.
+    $expectedS    = $this->dailyReferenceResolver->resolve($weeklyHours, $isoDayS, $workDaysForS);
+    $workedS      = $dailyWorkedMinutes[$S];                         // déjà calculé dans la boucle des jours
+    $prorata      = (int) round($weeklyHours * 12);
+
+    // 1) faire compter le jour comme s'il était travaillé normalement (annule la
+    //    valeur réelle du jour, quelle qu'elle soit : RTT posé, heures, vide, crédit
+    //    férié virtuel) ; 2) appliquer le forfait solidarité.
+    $weeklyOvertimeTotalMinutes += ($expectedS - $workedS) - $prorata;
+}
+```
+
+Puis `buildWeekRecoveryDetail(...)` est appelé tel quel : pour un CUSTOM,
+`totalMinutes = overtimeMinutes = weeklyOvertimeTotalMinutes` (signé), bandes 25/50 = 0,
+`isFlatRecovery = true`.
+
+> **Pourquoi `workDaysHours` et pas la référence hebdo CUSTOM** : la référence CUSTOM
+> (`computeWeeklyCustomReferenceMinutes`) répartit `weeklyHours` uniformément sur les 5
+> jours ouvrés (`weeklyHours/5`), sans tenir compte du planning réel. Neutraliser le jour
+> avec cette valeur uniforme (48 min pour le lundi d'Ewa) laisserait le manque des autres
+> jours → −2h au lieu de −48 min. En neutralisant avec l'attendu RÉEL du jour
+> (`workDaysHours[lundi] = 120 min`), le terme `(attendu − travaillé)` ramène la semaine à
+> son net « normal » (0 pour une semaine pleine), puis le forfait applique exactement
+> −prorata. `DailyReferenceMinutesResolver::resolve(weeklyHours, isoDay, workDaysMinutes)`
+> renvoie déjà cet attendu réel quand `workDaysMinutes` est fourni (obligatoire pour tout
+> CUSTOM < 35h). Fallback uniforme si absent.
+>
+> **Robustesse `EXCLUDED` / férié** : `(attendu − travaillé)` annule n'importe quelle
+> valeur de `$workedS`, y compris un éventuel crédit férié virtuel si le Lundi de Pentecôte
+> cessait d'être exclu. Le résultat ne dépend donc pas de l'état d'`EXCLUDED_PUBLIC_HOLIDAYS`.
+
+## Cas limites
+
+| Cas | Comportement |
+|-----|--------------|
+| Jour de solidarité futur (`> limitDate`) | Pas de déficit (semaine/jour non sommés). Appliqué une fois le jour passé. |
+| Jour de solidarité avant `rttStartDate` | Pas de déficit (semaine zéro-ée en amont). |
+| Changement de contrat dans la semaine | Contrat lu **au jour de solidarité**, pas à l'ancre de semaine. |
+| Salarié non contracté ce jour-là | `contractAtS = null` → pas de déficit. |
+| CUSTOM ≥ 35h (36–38h) | Hors périmètre → pas de déficit. |
+| 35h/39h avec RTT posé | Inchangé (drainage ~7h via la cascade existante). |
+| Autre déficit/surplus la même semaine | Le forfait s'y cumule. |
+
+## Tests
+
+### `SolidarityDayResolverTest`
+- Pentecôte 2024 = 20 mai 2024 ; 2025 = 9 juin 2025 ; 2026 = 25 mai 2026.
+- (optionnel) Pâques pivot : 2025 = 20 avril.
+
+### `RttRecoveryComputationServiceTest` (ajouts)
+- CUSTOM 4h, RTT posé sur le jour de solidarité → semaine = −48 min, `isFlatRecovery = true`,
+  base/bonus 25/50 = 0.
+- CUSTOM 4h, heures travaillées ce jour-là → semaine = −48 min (net forcé).
+- CUSTOM 4h, rien de posé → semaine = −48 min.
+- CUSTOM 4h avec un autre jour vide la même semaine → −48 min + l'autre déficit (cumul).
+- CUSTOM 36h → 0 (hors périmètre).
+- 35h avec RTT posé sur le jour de solidarité → inchangé (déficit plein, drainage tranches).
+- Jour de solidarité au-delà de `limitDate` → 0.
+- `computeTotalRecoveryForExercise` : le déficit solidarité se retrouve dans le total
+  d'exercice (→ clôture/report N+1).
+
+### Vérification données prod
+- Ewa (id 31, 4h, Lun+Jeu) : semaine du 25 mai 2026 (S22) = −48 min ; le −2h de la S23
+  (lundi 1er juin non saisi) reste distinct et inchangé.
+
+## Hors scope / inchangé
+
+- Front `RttTab.vue` : déjà propre (clamp des sous-colonnes 25/50 à 0 pour les semaines
+  déficitaires) → aucun changement.
+- Migrations : aucune.
+- `EXCLUDED_PUBLIC_HOLIDAYS`, `HolidayVirtualHoursResolver`, traitement des autres fériés :
+  inchangés.
+- Comportement des contrats 35h/39h/Forfait/Intérim sur le jour de solidarité : inchangé.
+
+## Documentation à mettre à jour (règle projet)
+
+- `CLAUDE.md` — section Overtime Rules / contrats CUSTOM : ajouter la règle du jour de
+  solidarité (prorata 12 min/h, net forcé, périmètre < 35h).
+- `frontend/data/documentation-content.ts` — doc in-app RTT.
+- `doc/rtt-tab.md` et/ou `doc/functional-rules.md` — règle métier détaillée.

frontend/components/hours/HoursDayExportDrawer.vue

@@ -23,6 +23,7 @@
                     groupClass="w-full mt-2"
                     label="Sites"
                     display-select-all
+                    display-tag
                 />
             </div>
 
@@ -49,7 +50,6 @@ const props = defineProps<{
     modelValue: boolean
     sites: Site[]
     initialDate: string
-    initialSiteIds: number[]
     isLoading?: boolean
 }>()
 
@@ -64,7 +64,7 @@ const drawerOpen = computed({
 })
 
 const selectedDate = ref(props.initialDate)
-const selectedSites = ref<number[]>([...props.initialSiteIds])
+const selectedSites = ref<number[]>([])
 
 const siteOptions = computed(() =>
     props.sites.map((site) => ({ label: site.name, value: site.id }))
@@ -80,7 +80,7 @@ watch(
     (isOpen) => {
         if (isOpen) {
             selectedDate.value = props.initialDate
-            selectedSites.value = [...props.initialSiteIds]
+            selectedSites.value = []
         }
     }
 )

frontend/data/documentation-content.ts

@@ -84,9 +84,10 @@ export const documentationSections: DocSection[] = [
       {
         id: 'export-heures-jour',
         title: 'Exporter les heures (PDF par jour)',
-        requiredLevel: 'admin',
+        requiredLevel: 'site_manager',
         blocks: [
           { type: 'paragraph', content: 'Le bouton « Exporter », à droite du titre « Heures » (visible uniquement en vue Jour), ouvre un panneau permettant de générer un PDF des heures d\'une journée. Choisissez la date et les sites concernés.' },
+          { type: 'paragraph', content: 'Les administrateurs peuvent exporter tous les sites. Un chef de site ne voit dans le panneau que ses propres sites et n\'exporte que ceux-ci.' },
           { type: 'paragraph', content: 'Le PDF est organisé par site et reprend les colonnes de la vue Jour (nom, statut, horaires matin/après-midi/soir, jour, nuit, total en gras), sans la colonne de validation. Les employés sous contrat ce jour-là apparaissent même sans saisie.' },
           { type: 'paragraph', content: 'La colonne Statut affiche le code du type d\'absence (ex. « AT ») sur sa couleur. Une légende sous le tableau associe chaque code présent à son libellé.' },
         ],
@@ -374,8 +375,8 @@ export const documentationSections: DocSection[] = [
         requiredLevel: 'admin',
         blocks: [
           { type: 'paragraph', content: 'Les règles de calcul des heures supplémentaires dépendent du type de contrat.' },
-          { type: 'list', content: 'Contrats ≤ 35h : +25% de 35h à 43h, +50% au-delà de 43h\nContrats ≥ 39h : +25% de 39h à 43h, +50% au-delà de 43h\nContrats CUSTOM (4h, 25h, etc.) : 1h supplémentaire = 1h de récupération, pas de bonus\nINTERIM : aucune récupération, aucun bonus' },
+          { type: 'list', content: 'Contrats ≤ 35h : +25% de 35h à 43h, +50% au-delà de 43h\nContrats ≥ 39h : +25% de 39h à 43h, +50% au-delà de 43h\nContrats CUSTOM (4h, 25h, etc.) : 1h supplémentaire = 1h de récupération, pas de bonus. Une semaine sous les heures contractuelles réduit le cumul RTT (1h manquante = -1h), sans passer par les tranches 25/50\nINTERIM : aucune récupération, aucun bonus' },
-          { type: 'note', content: 'En cas de déficit hebdomadaire (heures travaillées < heures contrat), le déficit est déduit du cumul RTT : d\'abord des heures à 50%, puis des heures à 25%.' },
+          { type: 'note', content: 'En cas de déficit hebdomadaire (heures travaillées < heures contrat), le déficit est déduit du cumul RTT. Pour un 35h/39h, il est puisé d\'abord dans les heures à 50%, puis à 25%. Pour un contrat CUSTOM (4h, etc.), il réduit directement le cumul (pas de tranches 25/50) ; le cumul peut devenir négatif et est reporté à l\'exercice suivant.' },
         ],
       },
       {
@@ -504,7 +505,7 @@ export const documentationSections: DocSection[] = [
         blocks: [
           { type: 'paragraph', content: 'L\'écran "Récap. congés" affiche un tableau figé des soldes de congés et RTT par employé. Il est accessible via la sidebar lorsque l\'accès a été activé sur le compte utilisateur.' },
           { type: 'list', content: 'Employé : voit uniquement sa propre ligne\nChef de site : voit les employés des sites qui lui sont rattachés\nAdmin : voit tous les employés, groupés par site' },
-          { type: 'note', content: 'Le récap est arrêté à la fin de la semaine S-2 (dimanche). Exemple : un mardi en S16, les soldes sont calculés jusqu\'au dimanche de la S14 inclus. Les heures et absences postérieures ne sont pas comptées.' },
+          { type: 'note', content: 'Le récap est arrêté à la fin de la semaine S-1 (dimanche). Exemple : un mardi en S16, les soldes sont calculés jusqu\'au dimanche de la S15 inclus. Les heures et absences postérieures ne sont pas comptées.' },
           { type: 'paragraph', content: 'Les colonnes affichées sont identiques à l\'export PDF admin (Nom, Prénom, Contrat, CP N-1 restant, CP N, Samedis, RTT). L\'accès à cet écran est géré par un flag sur l\'utilisateur, activé depuis le drawer de création/édition d\'un utilisateur par un admin.' },
         ],
       },
@@ -535,6 +536,8 @@ export const documentationSections: DocSection[] = [
           { type: 'note', content: 'Les contrats INTERIM et le mode PRESENCE n\'accumulent pas de RTT (affiché à 0).' },
           { type: 'note', content: 'Au passage à l\'exercice suivant (1er juin), le « Report N-1 » du nouvel exercice reprend exactement le « Disponible » de fin d\'exercice précédent, c\'est-à-dire report précédent + acquis − RTT payés. Le report déjà présent en début d\'année n\'est donc jamais perdu.' },
           { type: 'paragraph', content: 'La colonne "Cumul" affiche le solde RTT à la fin de chaque semaine : Report N-1 + somme des heures hebdomadaires jusqu\'à la semaine concernée − paiements RTT des mois précédents. Un paiement enregistré sur le mois M n\'est déduit qu\'à partir des semaines du mois M+1. Permet la comparaison ligne à ligne avec un suivi RH externe (Excel).' },
+          { type: 'note', content: 'Contrats CUSTOM (ex. 4h) : une semaine travaillée sous les heures contractuelles génère un déficit qui réduit le cumul RTT (1h manquante = -1h), sans tranches 25/50. Le cumul peut devenir négatif et est reporté à l\'exercice suivant.' },
+          { type: 'paragraph', content: 'Jour de solidarité : pour un contrat de moins de 35h, le Lundi de Pentecôte applique un déficit fixe proportionnel (7/35 des heures hebdomadaires, soit 12 minutes par heure : 4h donne 48 min). Ce déficit réduit le cumul RTT, quel que soit ce qui est saisi ce jour-là.' },
         ],
       },
       {
@@ -637,6 +640,7 @@ export const documentationSections: DocSection[] = [
           { type: 'list', content: 'Sélecteur de mois (défaut = mois courant)\nDonnées groupées par site\nColonnes : nom, base contrat, jours de présence cadre, heures de nuit, panier de nuit, heures RTT payées (en-tête fusionné scindé en deux sous-colonnes 25 % et 50 %), congés (nombre + dates), maladie/AT (nombre + dates), primes conducteur (PDJ, repas, nuitée, samedi), observations\nColonne « Repas » chauffeur : somme déjeuner + dîner sur le mois (un jour avec les deux compte 2 repas)' },
           { type: 'note', content: 'Seuls les salariés ayant un contrat couvrant tout ou partie du mois apparaissent : un salarié dont le contrat est terminé (ex. parti en février) n\'est pas listé sur le récap des mois suivants.' },
           { type: 'note', content: 'Forfait : un congé imputé sur le stock de l\'année précédente (N-1) n\'apparaît pas dans la colonne congés et compte comme un jour de présence. Le budget N-1 est consommé dans l\'ordre chronologique depuis janvier, de façon cohérente avec la fiche employé (les jours payés réduisent le stock N-1 d\'abord). Au-delà du budget N-1, les congés s\'affichent normalement.' },
+          { type: 'note', content: 'Export « Contingent H.nuit » : depuis la liste des employés, bouton Export → « Contingent H.nuit » + année. Génère un PDF A4 paysage avec une ligne par employé (groupés par site) et une colonne par mois, chacune avec le total d\'heures de nuit (travail entre 21h et 6h) et le nombre de nuits (jours où au moins 4h ont été travaillées de nuit). Les conducteurs utilisent leurs heures de nuit saisies.' },
         ],
       },
       {

frontend/pages/employees/index.vue

@@ -230,6 +230,16 @@
                     />
                 </template>
 
+                <div v-else-if="exportChoice === 'night-contingent'">
+                    <MalioSelect
+                        :model-value="exportYear"
+                        :options="exportYearOptions"
+                        label="Année *"
+                        min-width=""
+                        @update:model-value="(v) => { if (v !== null) exportYear = Number(v) }"
+                    />
+                </div>
+
                 <div class="flex justify-center pt-2">
                     <MalioButton
                         label="Valider"
@@ -264,7 +274,7 @@ const isDrawerOpen = ref(false)
 const isSubmitting = ref(false)
 const isLoading = ref(false)
 const isExportDrawerOpen = ref(false)
-const exportChoice = ref<'leave-recap' | 'salary-recap' | 'yearly-hours' | ''>('')
+const exportChoice = ref<'leave-recap' | 'salary-recap' | 'yearly-hours' | 'night-contingent' | ''>('')
 const exportYear = ref<number>(new Date().getFullYear())
 const exportMonth = ref<number | ''>(new Date().getMonth() + 1)
 const exportSalaryMonth = ref<string>(`${new Date().getFullYear()}-${String(new Date().getMonth() + 1).padStart(2, '0')}`)
@@ -272,7 +282,8 @@ const exportSalaryMonth = ref<string>(`${new Date().getFullYear()}-${String(new
 const exportTypeOptions = [
     { label: 'Récap. congés', value: 'leave-recap' },
     { label: 'Récap. salaire', value: 'salary-recap' },
-    { label: 'Heures annuelles', value: 'yearly-hours' }
+    { label: 'Heures annuelles', value: 'yearly-hours' },
+    { label: 'Contingent H.nuit', value: 'night-contingent' }
 ]
 const exportYearOptions = computed(() => {
     const current = new Date().getFullYear()
@@ -301,11 +312,14 @@ const isExportValid = computed(() => {
     if (exportChoice.value === 'yearly-hours') {
         return exportYear.value > 0 && exportMonth.value !== ''
     }
+    if (exportChoice.value === 'night-contingent') {
+        return exportYear.value > 0
+    }
     return true
 })
 
 const onExportChoiceChange = (value: string | number | null) => {
-    exportChoice.value = (value === null ? '' : String(value)) as 'leave-recap' | 'salary-recap' | 'yearly-hours' | ''
+    exportChoice.value = (value === null ? '' : String(value)) as 'leave-recap' | 'salary-recap' | 'yearly-hours' | 'night-contingent' | ''
 }
 const { printPdf } = usePdfPrinter()
 const sitesInitialized = ref(false)
@@ -618,6 +632,8 @@ const handleExportValidate = async () => {
         await printPdf(`/salary-recap/print?month=${exportSalaryMonth.value}`)
     } else if (choice === 'yearly-hours') {
         await printPdf(`/yearly-hours/print-all?year=${exportYear.value}&month=${exportMonth.value}`)
+    } else if (choice === 'night-contingent') {
+        await printPdf(`/night-hours-contingent/print?year=${exportYear.value}`)
     }
 }
 

frontend/pages/hours.vue

@@ -3,7 +3,7 @@
         <div class="flex flex-wrap items-center justify-between gap-4">
             <h1 class="text-2xl font-bold text-primary-500 lg:text-4xl">Heures</h1>
             <MalioButton
-                v-if="isAdmin && viewMode === 'day'"
+                v-if="(isAdmin || isSiteManager) && viewMode === 'day'"
                 label="Export"
                 variant="secondary"
                 icon-name="mdi:download"
@@ -16,7 +16,6 @@
             v-model="isExportDrawerOpen"
             :sites="sites"
             :initial-date="selectedDate"
-            :initial-site-ids="selectedSiteIds"
             :is-loading="isExporting"
             @submit="handleExport"
         />

frontend/services/dto/employee-rtt-summary.ts

@@ -10,6 +10,7 @@ export type EmployeeRttWeekSummary = {
   bonus50Minutes: number
   totalMinutes: number
   cumulativeBalanceMinutes: number
+  isFlatRecovery: boolean
 }
 
 export type RttMonthPayment = {

src/ApiResource/NightHoursContingentPrint.php

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\ApiResource;
+
+use ApiPlatform\Metadata\ApiResource;
+use ApiPlatform\Metadata\Get;
+use ApiPlatform\Metadata\QueryParameter;
+use App\State\NightHoursContingentPrintProvider;
+
+#[ApiResource(
+    operations: [
+        new Get(
+            uriTemplate: '/night-hours-contingent/print',
+            provider: NightHoursContingentPrintProvider::class,
+            parameters: [
+                new QueryParameter(key: 'year', required: true),
+            ],
+            security: "is_granted('ROLE_USER')"
+        ),
+    ]
+)]
+final class NightHoursContingentPrint {}

src/ApiResource/WorkHourDayExport.php

@@ -18,7 +18,7 @@ use App\State\WorkHourDayExportProvider;
                 new QueryParameter(key: 'workDate', required: true),
                 new QueryParameter(key: 'siteIds', required: true),
             ],
-            security: "is_granted('ROLE_ADMIN')"
+            security: "is_granted('ROLE_USER')"
         ),
     ]
 )]

src/Command/DumpVerificationSnapshotCommand.php

@@ -636,6 +636,7 @@ final class DumpVerificationSnapshotCommand extends Command
                     base50Minutes: $detail->base50Minutes,
                     bonus50Minutes: $detail->bonus50Minutes,
                     totalMinutes: $detail->totalMinutes,
+                    isFlatRecovery: $detail->isFlatRecovery,
                 );
 
                 continue;
@@ -672,6 +673,7 @@ final class DumpVerificationSnapshotCommand extends Command
                     base50Minutes: (int) round($detail->base50Minutes * $ratio),
                     bonus50Minutes: (int) round($detail->bonus50Minutes * $ratio),
                     totalMinutes: (int) round($detail->totalMinutes * $ratio),
+                    isFlatRecovery: $detail->isFlatRecovery,
                 );
             }
         }
@@ -692,7 +694,7 @@ final class DumpVerificationSnapshotCommand extends Command
         $cumulative25 = $carry->base25Minutes + $carry->bonus25Minutes;
 
         foreach ($weeks as $i => $week) {
-            if ($week->totalMinutes >= 0) {
+            if ($week->totalMinutes >= 0 || $week->isFlatRecovery) {
                 $cumulative50 += $week->base50Minutes + $week->bonus50Minutes;
                 $cumulative25 += $week->base25Minutes + $week->bonus25Minutes;
 
@@ -714,6 +716,7 @@ final class DumpVerificationSnapshotCommand extends Command
                 base50Minutes: $from50 > 0 ? -$from50 : 0,
                 bonus50Minutes: 0,
                 totalMinutes: $week->totalMinutes,
+                isFlatRecovery: $week->isFlatRecovery,
             );
         }
 

src/Dto/Rtt/EmployeeRttWeekSummary.php

@@ -18,5 +18,6 @@ final class EmployeeRttWeekSummary
         public int $bonus50Minutes = 0,
         public int $totalMinutes = 0,
         public int $cumulativeBalanceMinutes = 0,
+        public bool $isFlatRecovery = false,
     ) {}
 }

src/Dto/Rtt/WeekRecoveryDetail.php

@@ -17,5 +17,6 @@ final class WeekRecoveryDetail
         public int $bonus50Minutes = 0,
         public int $totalMinutes = 0,
         public array $dailyMinutes = [],
+        public bool $isFlatRecovery = false,
     ) {}
 }

src/Dto/WorkHours/NightContingentRow.php

@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Dto\WorkHours;
+
+final class NightContingentRow
+{
+    /**
+     * @param array<int, array{nightMinutes: int, nightDays: int}> $months clé 1..12
+     */
+    public function __construct(
+        public readonly int $employeeId,
+        public readonly string $employeeName,
+        public readonly array $months,
+    ) {}
+}

src/Service/Rtt/RttRecoveryComputationService.php

@@ -18,6 +18,7 @@ use App\Service\Contracts\EmployeeContractResolver;
 use App\Service\WorkHours\AbsenceSegmentsResolver;
 use App\Service\WorkHours\DailyReferenceMinutesResolver;
 use App\Service\WorkHours\HolidayVirtualHoursResolver;
+use App\Service\WorkHours\NightHoursCalculator;
 use App\Service\WorkHours\WorkedHoursCreditPolicy;
 use DateTimeImmutable;
 
@@ -33,6 +34,8 @@ final readonly class RttRecoveryComputationService
         private EmployeeContractResolver $contractResolver,
         private DailyReferenceMinutesResolver $dailyReferenceResolver,
         private HolidayVirtualHoursResolver $holidayVirtualHoursResolver,
+        private SolidarityDayResolver $solidarityDayResolver,
+        private NightHoursCalculator $nightHoursCalculator,
         string $rttStartDate = '',
     ) {
         $this->rttStartDate = '' !== $rttStartDate ? new DateTimeImmutable($rttStartDate) : null;
@@ -162,7 +165,8 @@ final readonly class RttRecoveryComputationService
             }
         }
 
-        $results = [];
+        $results         = [];
+        $solidarityDates = $this->resolveSolidarityDatesInRange($periodFrom, $periodTo);
         foreach ($weeks as $week) {
             $weekStart      = $week['start'];
             $weekEnd        = $week['end'];
@@ -235,7 +239,7 @@ final readonly class RttRecoveryComputationService
             $overtimeReferenceMinutes = $isCustomContract
                 ? $this->computeWeeklyCustomReferenceMinutes($weekDays, $employeeContractsByDate)
                 : $this->computeWeeklyOvertimeReferenceMinutes($weekDays, $employeeContractsByDate);
-            $overtime25StartMinutes     = $this->computeWeeklyOvertime25StartMinutes($weekDays, $employeeContractsByDate);
+            $overtime25StartMinutes = $this->computeWeeklyOvertime25StartMinutes($weekDays, $employeeContractsByDate);
             // Plafond séparant 25 %/50 % : seuil de départ proraté + largeur de la bande +25 %
             // (4h pour un 39h, 8h pour un 35h). Il se décale ainsi avec une embauche en milieu
             // de semaine au lieu de rester bloqué à 43h, ce qui ouvre la tranche 50 %.
@@ -244,35 +248,96 @@ final readonly class RttRecoveryComputationService
                 ? 0
                 : $weeklyTotalMinutes - $overtimeReferenceMinutes;
 
-            [$rawBase25, $rawBase50] = $this->computeOvertimeBaseMinutes($weeklyTotalMinutes, $overtime25StartMinutes, $overtime50StartMinutes);
+            foreach ($solidarityDates as $solidarityDate) {
+                // isset ⇒ le jour de solidarité fait partie du sommage de CETTE semaine
+                // (donc ≤ limitDate et ≥ rttStartDate). Sinon : jour futur ou hors service → pas de déficit.
+                if (!isset($dailyWorkedMinutes[$solidarityDate])) {
+                    continue;
+                }
 
-            $base25  = ($isWeekPresenceTracking || $disableOvertimeBonuses || $isCustomContract) ? 0 : $rawBase25;
+                $contractAtSolidarity = $employeeContractsByDate[$solidarityDate] ?? null;
-            $bonus25 = ($isWeekPresenceTracking || $disableOvertimeBonuses || $isCustomContract) ? 0 : (int) round($base25 * 0.25);
+                // Le Lundi de Pentecôte est toujours un lundi (ISO 1), mais on le dérive pour rester explicite.
-            $base50  = ($isWeekPresenceTracking || $disableOvertimeBonuses || $isCustomContract) ? 0 : $rawBase50;
+                $solidarityIsoDay = (int) new DateTimeImmutable($solidarityDate)->format('N');
-            $bonus50 = ($isWeekPresenceTracking || $disableOvertimeBonuses || $isCustomContract) ? 0 : (int) round($base50 * 0.5);
+                // Attendu RÉEL du jour (planning workDaysHours), pas la répartition uniforme :
+                // c'est ce qui rend la neutralisation correcte (cf. spec).
+                $solidarityExpected = $this->dailyReferenceResolver->resolve(
+                    $contractAtSolidarity?->getWeeklyHours(),
+                    $solidarityIsoDay,
+                    $workDaysByDate[$employeeId][$solidarityDate] ?? null,
+                );
 
-            if ($isWeekPresenceTracking || $disableOvertimeBonuses) {
+                $weeklyOvertimeTotalMinutes += $this->computeSolidarityDeficitAdjustment(
-                $totalMinutes = 0;
+                    $contractAtSolidarity,
-            } elseif ($isCustomContract) {
+                    $solidarityExpected,
-                $totalMinutes = max(0, $weeklyOvertimeTotalMinutes);
+                    $dailyWorkedMinutes[$solidarityDate],
-            } else {
+                );
-                $totalMinutes = $weeklyOvertimeTotalMinutes + $bonus25 + $bonus50;
             }
 
-            $results[$weekKey] = new WeekRecoveryDetail(
+            [$rawBase25, $rawBase50] = $this->computeOvertimeBaseMinutes($weeklyTotalMinutes, $overtime25StartMinutes, $overtime50StartMinutes);
-                overtimeMinutes: $weeklyOvertimeTotalMinutes,
+
-                base25Minutes: $base25,
+            $results[$weekKey] = $this->buildWeekRecoveryDetail(
-                bonus25Minutes: $bonus25,
+                $isWeekPresenceTracking,
-                base50Minutes: $base50,
+                $disableOvertimeBonuses,
-                bonus50Minutes: $bonus50,
+                $isCustomContract,
-                totalMinutes: $totalMinutes,
+                $weeklyOvertimeTotalMinutes,
-                dailyMinutes: $dailyWorkedMinutes,
+                $rawBase25,
+                $rawBase50,
+                $dailyWorkedMinutes,
             );
         }
 
         return $results;
     }
 
+    /**
+     * Assemble le détail de récupération d'une semaine à partir des drapeaux résolus et
+     * des bandes d'heures sup brutes.
+     *
+     * - PRESENCE / INTERIM (bonus désactivés) : aucune récupération.
+     * - CUSTOM : récupération plate 1h = 1h, sans tranches 25/50 ; l'heure sup signée EST
+     *   le total, donc une semaine travaillée sous les heures contractuelles produit un
+     *   total négatif (déficit qui réduit le solde). Marquée isFlatRecovery pour que le
+     *   provider ne draine pas les tranches 25/50.
+     * - Standard 35h/39h : heures sup + bonus 25 %/50 %.
+     *
+     * @param array<string, int> $dailyMinutes
+     */
+    private function buildWeekRecoveryDetail(
+        bool $isPresence,
+        bool $disableBonuses,
+        bool $isCustom,
+        int $overtimeTotalMinutes,
+        int $rawBase25,
+        int $rawBase50,
+        array $dailyMinutes,
+    ): WeekRecoveryDetail {
+        $noBands = $isPresence || $disableBonuses || $isCustom;
+
+        $base25  = $noBands ? 0 : $rawBase25;
+        $bonus25 = $noBands ? 0 : (int) round($base25 * 0.25);
+        $base50  = $noBands ? 0 : $rawBase50;
+        $bonus50 = $noBands ? 0 : (int) round($base50 * 0.5);
+
+        if ($isPresence || $disableBonuses) {
+            $totalMinutes = 0;
+        } elseif ($isCustom) {
+            $totalMinutes = $overtimeTotalMinutes; // signé : le déficit réduit le solde
+        } else {
+            $totalMinutes = $overtimeTotalMinutes + $bonus25 + $bonus50;
+        }
+
+        return new WeekRecoveryDetail(
+            overtimeMinutes: $overtimeTotalMinutes,
+            base25Minutes: $base25,
+            bonus25Minutes: $bonus25,
+            base50Minutes: $base50,
+            bonus50Minutes: $bonus50,
+            totalMinutes: $totalMinutes,
+            dailyMinutes: $dailyMinutes,
+            isFlatRecovery: $isCustom,
+        );
+    }
+
     private function computeMetrics(WorkHour $workHour): WorkMetrics
     {
         $driverDay      = $workHour->getDayHoursMinutes() ?? 0;
@@ -296,13 +361,12 @@ final readonly class RttRecoveryComputationService
         ];
 
         $totalMinutes = 0;
-        $nightMinutes = 0;
         foreach ($ranges as [$from, $to]) {
             $totalMinutes += $this->intervalMinutes($from, $to);
-            $nightMinutes += $this->nightIntervalMinutes($from, $to);
         }
 
-        $dayMinutes = max(0, $totalMinutes - $nightMinutes);
+        $nightMinutes = $this->nightHoursCalculator->nightMinutesFromRanges($workHour);
+        $dayMinutes   = max(0, $totalMinutes - $nightMinutes);
 
         return new WorkMetrics(
             dayMinutes: $dayMinutes,
@@ -348,35 +412,6 @@ final readonly class RttRecoveryComputationService
         return max(0, $end - $start);
     }
 
-    private function nightIntervalMinutes(?string $from, ?string $to): int
-    {
-        $interval = $this->resolveInterval($from, $to);
-        if (null === $interval) {
-            return 0;
-        }
-
-        [$start, $end] = $interval;
-        $windows       = [[0, 360], [1260, 1440]];
-        $total         = 0;
-
-        for ($dayOffset = 0; $dayOffset <= 1; ++$dayOffset) {
-            $shift = $dayOffset * 1440;
-            foreach ($windows as [$windowStart, $windowEnd]) {
-                $total += $this->overlap($start, $end, $windowStart + $shift, $windowEnd + $shift);
-            }
-        }
-
-        return $total;
-    }
-
-    private function overlap(int $startA, int $endA, int $startB, int $endB): int
-    {
-        $start = max($startA, $startB);
-        $end   = min($endA, $endB);
-
-        return max(0, $end - $start);
-    }
-
     /**
      * @param list<string>             $days
      * @param array<string, ?Contract> $contractsByDate
@@ -415,6 +450,59 @@ final readonly class RttRecoveryComputationService
         return $weekDays[0];
     }
 
+    /**
+     * Lundi(s) de Pentecôte (jour de solidarité) inclus dans [from, to]. Un exercice
+     * Juin N-1 → Mai N couvre les années civiles N-1 et N ; on retient les dates dans la fenêtre.
+     *
+     * @return list<string> dates au format 'Y-m-d'
+     */
+    private function resolveSolidarityDatesInRange(DateTimeImmutable $from, DateTimeImmutable $to): array
+    {
+        $dates     = [];
+        $firstYear = (int) $from->format('Y');
+        $lastYear  = (int) $to->format('Y');
+
+        for ($year = $firstYear; $year <= $lastYear; ++$year) {
+            $candidate = $this->solidarityDayResolver->pentecostMonday($year);
+            if ($candidate >= $from && $candidate <= $to) {
+                $dates[] = $candidate->format('Y-m-d');
+            }
+        }
+
+        return $dates;
+    }
+
+    /**
+     * Déficit forfaitaire du jour de solidarité pour les contrats CUSTOM < 35h.
+     *
+     * Le jour est neutralisé puis chargé du prorata légal : on remplace la valeur réelle
+     * du jour ($workedMinutes : RTT posé, heures saisies, vide, ou crédit férié virtuel)
+     * par l'attendu contractuel du jour ($expectedMinutes = workDaysHours), puis on
+     * retranche le prorata = 7h/35h × heuresHebdo = 12 min par heure hebdo. Sur une
+     * semaine par ailleurs normale, le net vaut exactement −prorata. Renvoie le delta à
+     * ajouter à weeklyOvertimeTotalMinutes (0 hors périmètre : non-CUSTOM ou ≥ 35h).
+     */
+    private function computeSolidarityDeficitAdjustment(
+        ?Contract $contractAtSolidarity,
+        int $expectedMinutes,
+        int $workedMinutes,
+    ): int {
+        $weeklyHours = $contractAtSolidarity?->getWeeklyHours();
+        $type        = ContractType::resolve(
+            $contractAtSolidarity?->getName(),
+            $contractAtSolidarity?->getTrackingMode(),
+            $weeklyHours,
+        );
+
+        if (ContractType::CUSTOM !== $type || null === $weeklyHours || $weeklyHours >= 35) {
+            return 0;
+        }
+
+        $prorata = (int) round($weeklyHours * 12);
+
+        return ($expectedMinutes - $workedMinutes) - $prorata;
+    }
+
     /**
      * @param list<string>             $days
      * @param array<string, ?Contract> $contractsByDate

src/Service/Rtt/SolidarityDayResolver.php

@@ -0,0 +1,43 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service\Rtt;
+
+use DateTimeImmutable;
+
+/**
+ * Résout le jour de solidarité (Lundi de Pentecôte) d'une année.
+ *
+ * Pur et déterministe : Pâques via l'algorithme de Meeus/Jones/Butcher (calendrier
+ * grégorien), sans dépendance à l'extension calendar ni au réseau. Lundi de Pentecôte
+ * = dimanche de Pâques + 50 jours.
+ */
+final class SolidarityDayResolver
+{
+    public function pentecostMonday(int $year): DateTimeImmutable
+    {
+        return $this->easterSunday($year)->modify('+50 days');
+    }
+
+    private function easterSunday(int $year): DateTimeImmutable
+    {
+        $a = $year % 19;
+        $b = intdiv($year, 100);
+        $c = $year % 100;
+        $d = intdiv($b, 4);
+        $e = $b % 4;
+        $f = intdiv($b + 8, 25);
+        $g = intdiv($b - $f + 1, 3);
+        $h = (19 * $a + $b - $d - $g + 15) % 30;
+        $i = intdiv($c, 4);
+        $k = $c % 4;
+        $l = (32 + 2 * $e + 2 * $i - $h - $k) % 7;
+        $m = intdiv($a + 11 * $h + 22 * $l, 451);
+
+        $month = intdiv($h + $l - 7 * $m + 114, 31);
+        $day   = (($h + $l - 7 * $m + 114) % 31) + 1;
+
+        return new DateTimeImmutable(sprintf('%04d-%02d-%02d', $year, $month, $day));
+    }
+}

src/Service/WorkHours/NightContingentExportBuilder.php

@@ -0,0 +1,95 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service\WorkHours;
+
+use App\Dto\WorkHours\NightContingentRow;
+use App\Entity\Employee;
+use App\Repository\Contract\WorkHourReadRepositoryInterface;
+use App\Service\Contracts\EmployeeContractResolver;
+use DateTimeImmutable;
+
+/**
+ * Construit, par employe, les totaux mensuels d'heures de nuit et le nombre de
+ * nuits travaillees (>= 4h de nuit dans la journee). Fenetre 21h->6h via
+ * NightHoursCalculator. Conducteurs : minutes saisies (nightHoursMinutes).
+ * Aucun credit absence/ferie : seules les heures reellement travaillees comptent.
+ */
+final readonly class NightContingentExportBuilder
+{
+    private const int NIGHT_DAY_THRESHOLD_MINUTES = 240;
+
+    public function __construct(
+        private WorkHourReadRepositoryInterface $workHourRepository,
+        private EmployeeContractResolver $contractResolver,
+        private NightHoursCalculator $nightHoursCalculator,
+    ) {}
+
+    /**
+     * @param list<Employee> $employees
+     *
+     * @return list<NightContingentRow>
+     */
+    public function buildRows(array $employees, int $year): array
+    {
+        $from = new DateTimeImmutable(sprintf('%d-01-01', $year));
+        $to   = new DateTimeImmutable(sprintf('%d-12-31', $year));
+
+        $workHours = $this->workHourRepository->findByDateRangeAndEmployees($from, $to, $employees);
+
+        $byEmployee = [];
+        foreach ($workHours as $wh) {
+            $employeeId = $wh->getEmployee()?->getId();
+            if (null === $employeeId) {
+                continue;
+            }
+            $byEmployee[$employeeId][] = $wh;
+        }
+
+        $days = [];
+        foreach ($workHours as $wh) {
+            $days[$wh->getWorkDate()->format('Y-m-d')] = true;
+        }
+        $days = array_keys($days);
+
+        $driverMap = $this->contractResolver->resolveIsDriverForEmployeesAndDays($employees, $days);
+
+        $rows = [];
+        foreach ($employees as $employee) {
+            $employeeId = $employee->getId();
+            if (null === $employeeId) {
+                continue;
+            }
+
+            $months = [];
+            for ($m = 1; $m <= 12; ++$m) {
+                $months[$m] = ['nightMinutes' => 0, 'nightDays' => 0];
+            }
+
+            foreach ($byEmployee[$employeeId] ?? [] as $wh) {
+                $date     = DateTimeImmutable::createFromInterface($wh->getWorkDate());
+                $ymd      = $date->format('Y-m-d');
+                $isDriver = $driverMap[$employeeId][$ymd] ?? false;
+                $nightMin = $this->nightHoursCalculator->nightMinutesForWorkHour($wh, $isDriver);
+                if ($nightMin <= 0) {
+                    continue;
+                }
+
+                $month = (int) $date->format('n');
+                $months[$month]['nightMinutes'] += $nightMin;
+                if ($nightMin >= self::NIGHT_DAY_THRESHOLD_MINUTES) {
+                    ++$months[$month]['nightDays'];
+                }
+            }
+
+            $rows[] = new NightContingentRow(
+                employeeId: $employeeId,
+                employeeName: trim($employee->getLastName().' '.$employee->getFirstName()),
+                months: $months,
+            );
+        }
+
+        return $rows;
+    }
+}

src/Service/WorkHours/NightHoursCalculator.php

@@ -0,0 +1,102 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service\WorkHours;
+
+use App\Entity\WorkHour;
+
+/**
+ * Calcul des minutes travaillees de nuit (fenetre 21h->6h).
+ *
+ * Fenetres en minutes depuis 00:00 : [0,360] (00:00-06:00) et [1260,1440]
+ * (21:00-24:00). On projette sur J+1 pour les shifts qui traversent minuit.
+ * Source de verite unique partagee par les ecrans Heures et les exports.
+ */
+final readonly class NightHoursCalculator
+{
+    /**
+     * Minutes de nuit d'un WorkHour. Conducteurs : champ manuel nightHoursMinutes.
+     * Non-conducteurs : somme calculee depuis les plages matin/apres-midi/soir.
+     */
+    public function nightMinutesForWorkHour(WorkHour $workHour, bool $isDriver): int
+    {
+        if ($isDriver) {
+            return $workHour->getNightHoursMinutes() ?? 0;
+        }
+
+        return $this->nightMinutesFromRanges($workHour);
+    }
+
+    public function nightMinutesFromRanges(WorkHour $workHour): int
+    {
+        $ranges = [
+            [$workHour->getMorningFrom(), $workHour->getMorningTo()],
+            [$workHour->getAfternoonFrom(), $workHour->getAfternoonTo()],
+            [$workHour->getEveningFrom(), $workHour->getEveningTo()],
+        ];
+
+        $total = 0;
+        foreach ($ranges as [$from, $to]) {
+            $total += $this->nightIntervalMinutes($from, $to);
+        }
+
+        return $total;
+    }
+
+    public function nightIntervalMinutes(?string $from, ?string $to): int
+    {
+        $interval = $this->resolveInterval($from, $to);
+        if (null === $interval) {
+            return 0;
+        }
+
+        [$start, $end] = $interval;
+        $windows       = [[0, 360], [1260, 1440]];
+        $total         = 0;
+
+        for ($dayOffset = 0; $dayOffset <= 1; ++$dayOffset) {
+            $shift = $dayOffset * 1440;
+            foreach ($windows as [$windowStart, $windowEnd]) {
+                $total += $this->overlap($start, $end, $windowStart + $shift, $windowEnd + $shift);
+            }
+        }
+
+        return $total;
+    }
+
+    /**
+     * @return null|array{int, int}
+     */
+    private function resolveInterval(?string $from, ?string $to): ?array
+    {
+        $fromMinutes = $this->toMinutes($from);
+        $toMinutes   = $this->toMinutes($to);
+        if (null === $fromMinutes || null === $toMinutes) {
+            return null;
+        }
+
+        $end = $toMinutes <= $fromMinutes ? $toMinutes + 1440 : $toMinutes;
+
+        return [$fromMinutes, $end];
+    }
+
+    private function toMinutes(?string $time): ?int
+    {
+        if (null === $time || '' === $time) {
+            return null;
+        }
+
+        [$hours, $minutes] = array_map('intval', explode(':', $time));
+
+        return ($hours * 60) + $minutes;
+    }
+
+    private function overlap(int $startA, int $endA, int $startB, int $endB): int
+    {
+        $start = max($startA, $startB);
+        $end   = min($endA, $endB);
+
+        return max(0, $end - $start);
+    }
+}

src/Service/WorkHours/YearlyHoursExportBuilder.php

@@ -29,6 +29,7 @@ class YearlyHoursExportBuilder
         private WorkedHoursCreditPolicy $workedHoursCreditPolicy,
         private PublicHolidayServiceInterface $publicHolidayService,
         private HolidayVirtualHoursResolver $holidayVirtualHoursResolver,
+        private NightHoursCalculator $nightHoursCalculator,
     ) {}
 
     /**
@@ -541,14 +542,12 @@ class YearlyHoursExportBuilder
         ];
 
         $totalMinutes = 0;
-        $nightMinutes = 0;
-
         foreach ($ranges as [$from, $to]) {
             $totalMinutes += $this->intervalMinutes($from, $to);
-            $nightMinutes += $this->nightIntervalMinutes($from, $to);
         }
 
-        $dayMinutes = max(0, $totalMinutes - $nightMinutes);
+        $nightMinutes = $this->nightHoursCalculator->nightMinutesFromRanges($workHour);
+        $dayMinutes   = max(0, $totalMinutes - $nightMinutes);
 
         return new WorkMetrics(
             dayMinutes: $dayMinutes,
@@ -596,35 +595,6 @@ class YearlyHoursExportBuilder
         return max(0, $end - $start);
     }
 
-    private function nightIntervalMinutes(?string $from, ?string $to): int
-    {
-        $interval = $this->resolveInterval($from, $to);
-        if (null === $interval) {
-            return 0;
-        }
-
-        [$start, $end] = $interval;
-        $windows       = [[0, 360], [1260, 1440]];
-        $total         = 0;
-
-        for ($dayOffset = 0; $dayOffset <= 1; ++$dayOffset) {
-            $shift = $dayOffset * 1440;
-            foreach ($windows as [$windowStart, $windowEnd]) {
-                $total += $this->overlap($start, $end, $windowStart + $shift, $windowEnd + $shift);
-            }
-        }
-
-        return $total;
-    }
-
-    private function overlap(int $startA, int $endA, int $startB, int $endB): int
-    {
-        $start = max($startA, $startB);
-        $end   = min($endA, $endB);
-
-        return max(0, $end - $start);
-    }
-
     private function formatMinutes(int $minutes): string
     {
         if (0 === $minutes) {

src/State/EmployeeRttSummaryProvider.php

@@ -142,36 +142,13 @@ final readonly class EmployeeRttSummaryProvider implements ProviderInterface
         $summary->rttStartDate = $this->rttStartDate;
         $summary->weeks        = $this->buildWeekSummaries($weekRanges, $currentByWeekStart, $periodFrom, $periodTo);
 
-        // Post-process: distribute deficit weeks across cumulative balance (50% first, then 25%)
+        // Post-process: distribute deficit weeks across cumulative balance (50% first, then 25%).
-        $cumulative50 = $carry->base50Minutes + $carry->bonus50Minutes;
+        // Flat-recovery (CUSTOM) weeks are skipped — their deficit only reduces the running cumul.
-        $cumulative25 = $carry->base25Minutes + $carry->bonus25Minutes;
+        $summary->weeks = $this->applyDeficitCascade(
-
+            $summary->weeks,
-        foreach ($summary->weeks as $i => $week) {
+            $carry->base25Minutes + $carry->bonus25Minutes,
-            if ($week->totalMinutes >= 0) {
+            $carry->base50Minutes + $carry->bonus50Minutes,
-                $cumulative50 += $week->base50Minutes + $week->bonus50Minutes;
+        );
-                $cumulative25 += $week->base25Minutes + $week->bonus25Minutes;
-            } else {
-                $deficit = -$week->totalMinutes;
-                $from50  = min($deficit, max(0, $cumulative50));
-                $from25  = $deficit - $from50;
-
-                $cumulative50 -= $from50;
-                $cumulative25 -= $from25;
-
-                $summary->weeks[$i] = new EmployeeRttWeekSummary(
-                    month: $week->month,
-                    weekNumber: $week->weekNumber,
-                    weekStart: $week->weekStart,
-                    weekEnd: $week->weekEnd,
-                    overtimeMinutes: $week->overtimeMinutes,
-                    base25Minutes: $from25 > 0 ? -$from25 : 0,
-                    bonus25Minutes: 0,
-                    base50Minutes: $from50 > 0 ? -$from50 : 0,
-                    bonus50Minutes: 0,
-                    totalMinutes: $week->totalMinutes,
-                );
-            }
-        }
 
         $payments     = $this->rttPaymentRepository->findByEmployeeAndYear($employee, $year);
         $monthBuckets = [];
@@ -356,6 +333,54 @@ final readonly class EmployeeRttSummaryProvider implements ProviderInterface
         return $weekEnd;
     }
 
+    /**
+     * Distribue les semaines déficitaires sur les tranches 25/50 accumulées (50 % d'abord,
+     * puis 25 %), en réécrivant les buckets affichés de chaque semaine déficitaire avec les
+     * montants négatifs drainés.
+     *
+     * Les semaines à récupération plate (CUSTOM 1h = 1h) sont ignorées : elles n'ont pas de
+     * tranches 25/50, donc leur déficit ne réduit que le cumul courant (calculé ensuite à
+     * partir de totalMinutes) et les colonnes 25/50 restent à 0.
+     *
+     * @param list<EmployeeRttWeekSummary> $weeks
+     *
+     * @return list<EmployeeRttWeekSummary>
+     */
+    private function applyDeficitCascade(array $weeks, int $cumulative25, int $cumulative50): array
+    {
+        foreach ($weeks as $i => $week) {
+            if ($week->totalMinutes >= 0 || $week->isFlatRecovery) {
+                $cumulative50 += $week->base50Minutes + $week->bonus50Minutes;
+                $cumulative25 += $week->base25Minutes + $week->bonus25Minutes;
+
+                continue;
+            }
+
+            $deficit = -$week->totalMinutes;
+            $from50  = min($deficit, max(0, $cumulative50));
+            $from25  = $deficit - $from50;
+
+            $cumulative50 -= $from50;
+            $cumulative25 -= $from25;
+
+            $weeks[$i] = new EmployeeRttWeekSummary(
+                month: $week->month,
+                weekNumber: $week->weekNumber,
+                weekStart: $week->weekStart,
+                weekEnd: $week->weekEnd,
+                overtimeMinutes: $week->overtimeMinutes,
+                base25Minutes: $from25 > 0 ? -$from25 : 0,
+                bonus25Minutes: 0,
+                base50Minutes: $from50 > 0 ? -$from50 : 0,
+                bonus50Minutes: 0,
+                totalMinutes: $week->totalMinutes,
+                isFlatRecovery: $week->isFlatRecovery,
+            );
+        }
+
+        return $weeks;
+    }
+
     /**
      * Build week summaries, splitting weeks that span two months into two entries
      * with values distributed proportionally based on daily worked minutes.
@@ -393,6 +418,7 @@ final readonly class EmployeeRttSummaryProvider implements ProviderInterface
                     base50Minutes: $detail->base50Minutes,
                     bonus50Minutes: $detail->bonus50Minutes,
                     totalMinutes: $detail->totalMinutes,
+                    isFlatRecovery: $detail->isFlatRecovery,
                 );
 
                 continue;
@@ -433,6 +459,7 @@ final readonly class EmployeeRttSummaryProvider implements ProviderInterface
                     base50Minutes: (int) round($detail->base50Minutes * $ratio),
                     bonus50Minutes: (int) round($detail->bonus50Minutes * $ratio),
                     totalMinutes: (int) round($detail->totalMinutes * $ratio),
+                    isFlatRecovery: $detail->isFlatRecovery,
                 );
             }
         }

src/State/NightHoursContingentPrintProvider.php

@@ -0,0 +1,154 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\State;
+
+use ApiPlatform\Metadata\Operation;
+use ApiPlatform\State\ProviderInterface;
+use App\Entity\Employee;
+use App\Entity\User;
+use App\Repository\EmployeeRepository;
+use App\Service\WorkHours\NightContingentExportBuilder;
+use DateTimeImmutable;
+use Dompdf\Dompdf;
+use Dompdf\Options;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
+use Symfony\Component\HttpKernel\Exception\UnprocessableEntityHttpException;
+use Twig\Environment;
+
+class NightHoursContingentPrintProvider implements ProviderInterface
+{
+    public function __construct(
+        private Environment $twig,
+        private readonly RequestStack $requestStack,
+        private EmployeeRepository $employeeRepository,
+        private NightContingentExportBuilder $exportBuilder,
+        private readonly Security $security,
+    ) {}
+
+    public function provide(Operation $operation, array $uriVariables = [], array $context = []): Response
+    {
+        $user = $this->security->getUser();
+        if (!$user instanceof User) {
+            throw new AccessDeniedHttpException('Authentication required.');
+        }
+
+        $request = $this->requestStack->getCurrentRequest();
+        if (!$request) {
+            return new Response('Missing request.', Response::HTTP_BAD_REQUEST);
+        }
+
+        $year = (int) $request->query->get('year', (string) (int) new DateTimeImmutable('now')->format('Y'));
+        if ($year < 2000 || $year > 2100) {
+            throw new UnprocessableEntityHttpException('year must be between 2000 and 2100.');
+        }
+
+        $from = new DateTimeImmutable(sprintf('%d-01-01', $year));
+        $to   = new DateTimeImmutable(sprintf('%d-12-31', $year));
+
+        // Perimetre selon le profil : admin -> tous, chef de site -> ses sites.
+        $employees = $this->employeeRepository->findScoped($user);
+
+        // Regroupement par site (ordre displayOrder), employes avec contrat sur l'annee.
+        $bySite   = [];
+        $siteMeta = [];
+        foreach ($employees as $employee) {
+            if (!$this->hasContractInRange($employee, $from, $to)) {
+                continue;
+            }
+            $site = $employee->getSite();
+            if (null === $site) {
+                continue;
+            }
+            $siteId            = $site->getId();
+            $bySite[$siteId][] = $employee;
+            $siteMeta[$siteId] ??= [
+                'name'  => $site->getName(),
+                'order' => $site->getDisplayOrder(),
+                'color' => $site->getColor(),
+            ];
+        }
+
+        uasort($siteMeta, static function (array $a, array $b): int {
+            return [$a['order'], $a['name']] <=> [$b['order'], $b['name']];
+        });
+
+        $groups = [];
+        foreach ($siteMeta as $siteId => $meta) {
+            $siteEmployees = $bySite[$siteId];
+            // Meme tri que le calendrier : displayOrder, puis nom, puis prenom.
+            usort($siteEmployees, static function (Employee $a, Employee $b): int {
+                return [$a->getDisplayOrder(), $a->getLastName(), $a->getFirstName()]
+                    <=> [$b->getDisplayOrder(), $b->getLastName(), $b->getFirstName()];
+            });
+
+            $rows = $this->exportBuilder->buildRows($siteEmployees, $year);
+
+            $renderRows = [];
+            foreach ($rows as $row) {
+                $cells = [];
+                for ($m = 1; $m <= 12; ++$m) {
+                    $cells[] = [
+                        'hours' => $this->formatMinutes($row->months[$m]['nightMinutes']),
+                        'days'  => $row->months[$m]['nightDays'],
+                    ];
+                }
+                $renderRows[] = [
+                    'employeeName' => $row->employeeName,
+                    'cells'        => $cells,
+                ];
+            }
+
+            $groups[] = ['siteName' => $meta['name'], 'siteColor' => $meta['color'], 'rows' => $renderRows];
+        }
+
+        $options = new Options();
+        $options->set('isRemoteEnabled', true);
+        $dompdf = new Dompdf($options);
+
+        $html = $this->twig->render('night-hours-contingent/print.html.twig', [
+            'groups'     => $groups,
+            'year'       => $year,
+            'exportedAt' => new DateTimeImmutable('now')->format('d/m/Y H:i'),
+        ]);
+
+        $dompdf->loadHtml($html);
+        $dompdf->setPaper('A4', 'landscape');
+        $dompdf->render();
+
+        $filename = sprintf('contingent_heures_nuit_%d.pdf', $year);
+
+        return new Response($dompdf->output(), Response::HTTP_OK, [
+            'Content-Type'        => 'application/pdf',
+            'Content-Disposition' => sprintf('attachment; filename="%s"', $filename),
+        ]);
+    }
+
+    private function hasContractInRange(Employee $employee, DateTimeImmutable $from, DateTimeImmutable $to): bool
+    {
+        $fromDay = $from->format('Y-m-d');
+        $toDay   = $to->format('Y-m-d');
+
+        foreach ($employee->getContractPeriods() as $period) {
+            $start = $period->getStartDate()->format('Y-m-d');
+            $end   = $period->getEndDate()?->format('Y-m-d');
+            if ($start <= $toDay && (null === $end || $end >= $fromDay)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function formatMinutes(int $minutes): string
+    {
+        $h = intdiv($minutes, 60);
+        $m = $minutes % 60;
+
+        return sprintf('%dh%02d', $h, $m);
+    }
+}

src/State/SalaryRecapPrintProvider.php

@@ -20,6 +20,7 @@ use App\Repository\WorkHourRepository;
 use App\Service\Contracts\EmployeeContractResolver;
 use App\Service\PublicHolidayServiceInterface;
 use App\Service\WorkHours\AbsenceSegmentsResolver;
+use App\Service\WorkHours\NightHoursCalculator;
 use DateInterval;
 use DateTimeImmutable;
 use Dompdf\Dompdf;
@@ -45,6 +46,7 @@ class SalaryRecapPrintProvider implements ProviderInterface
         private PublicHolidayServiceInterface $publicHolidayService,
         private EmployeeLeaveSummaryProvider $leaveSummaryProvider,
         private AbsenceSegmentsResolver $absenceSegmentsResolver,
+        private NightHoursCalculator $nightHoursCalculator,
     ) {}
 
     public function provide(Operation $operation, array $uriVariables = [], array $context = []): Response
@@ -78,10 +80,10 @@ class SalaryRecapPrintProvider implements ProviderInterface
         // Congés depuis le début de l'exercice forfait (année civile) jusqu'à la fin du mois :
         // nécessaires pour consommer chronologiquement le budget N-1 d'un forfait (un congé
         // imputé N-1 ne doit ni s'afficher ni manquer en présence sur le récap).
-        $yearStart    = new DateTimeImmutable(sprintf('%d-01-01', $year));
+        $yearStart     = new DateTimeImmutable(sprintf('%d-01-01', $year));
-        $ytdAbsences  = $this->absenceRepository->findForPrint($yearStart, $to, $employees);
+        $ytdAbsences   = $this->absenceRepository->findForPrint($yearStart, $to, $employees);
         $ytdAbsenceMap = $this->buildAbsenceMap($ytdAbsences);
-        $rttPayments = $this->rttPaymentRepository->findByYearAndMonth($year, $monthNumber);
+        $rttPayments   = $this->rttPaymentRepository->findByYearAndMonth($year, $monthNumber);
 
         $bonuses      = $this->bonusRepository->findByMonth($from, $to);
         $mileages     = $this->mileageAllowanceRepository->findByMonth($from, $to);
@@ -472,7 +474,7 @@ class SalaryRecapPrintProvider implements ProviderInterface
                 $ytdAbsences,
                 static fn (Absence $a): bool => 'C' === $a->getType()?->getCode()
             ));
-            $split = $this->splitForfaitCongesByN1($ytdConges, $n1Budget, $monthFrom, $monthTo);
+            $split  = $this->splitForfaitCongesByN1($ytdConges, $n1Budget, $monthFrom, $monthTo);
             $conges = ['count' => $split['count'], 'dates' => $split['dates']];
             $presenceDays += $split['n1PresenceDays'];
         } else {
@@ -524,14 +526,13 @@ class SalaryRecapPrintProvider implements ProviderInterface
         ];
 
         $totalMinutes = 0;
-        $nightMinutes = 0;
 
         foreach ($ranges as [$from, $to]) {
             $totalMinutes += $this->intervalMinutes($from, $to);
-            $nightMinutes += $this->nightIntervalMinutes($from, $to);
         }
 
-        $dayMinutes = max(0, $totalMinutes - $nightMinutes);
+        $nightMinutes = $this->nightHoursCalculator->nightMinutesFromRanges($workHour);
+        $dayMinutes   = max(0, $totalMinutes - $nightMinutes);
 
         return [
             'nightMinutes' => $nightMinutes,
@@ -578,27 +579,6 @@ class SalaryRecapPrintProvider implements ProviderInterface
         return max(0, $end - $start);
     }
 
-    private function nightIntervalMinutes(?string $from, ?string $to): int
-    {
-        $interval = $this->resolveInterval($from, $to);
-        if (null === $interval) {
-            return 0;
-        }
-
-        [$start, $end] = $interval;
-        $windows       = [[0, 360], [1260, 1440]];
-        $total         = 0;
-
-        for ($dayOffset = 0; $dayOffset <= 1; ++$dayOffset) {
-            $shift = $dayOffset * 1440;
-            foreach ($windows as [$windowStart, $windowEnd]) {
-                $total += $this->overlap($start, $end, $windowStart + $shift, $windowEnd + $shift);
-            }
-        }
-
-        return $total;
-    }
-
     /**
      * Calcule les minutes qui débordent après minuit (> 1440) pour les créneaux d'un WorkHour.
      * Ex: créneau soir 21:00-05:00 → interval [1260, 1740] → overflow = 1740-1440 = 300 min (5h).
@@ -630,14 +610,6 @@ class SalaryRecapPrintProvider implements ProviderInterface
         return $overflow;
     }
 
-    private function overlap(int $startA, int $endA, int $startB, int $endB): int
-    {
-        $start = max($startA, $startB);
-        $end   = min($endA, $endB);
-
-        return max(0, $end - $start);
-    }
-
     /**
      * Répartit les congés ('C') d'un forfait entre N-1 (budget consommé chronologiquement,
      * non affiché et compté en présence) et N (affiché en congé). Seuls les jours tombant
@@ -677,7 +649,7 @@ class SalaryRecapPrintProvider implements ProviderInterface
 
                 $covered = 0.0;
                 if ($remaining > 0.0) {
-                    $covered    = min($remaining, $amount);
+                    $covered = min($remaining, $amount);
                     $remaining -= $covered;
                 }
                 $displayed = $amount - $covered;

src/State/WorkHourDayExportProvider.php

@@ -6,13 +6,16 @@ namespace App\State;
 
 use ApiPlatform\Metadata\Operation;
 use ApiPlatform\State\ProviderInterface;
+use App\Entity\User;
 use App\Repository\EmployeeRepository;
 use App\Service\WorkHours\YearlyHoursExportBuilder;
 use DateTimeImmutable;
 use Dompdf\Dompdf;
 use Dompdf\Options;
+use Symfony\Bundle\SecurityBundle\Security;
 use Symfony\Component\HttpFoundation\RequestStack;
 use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
 use Symfony\Component\HttpKernel\Exception\UnprocessableEntityHttpException;
 use Twig\Environment;
 
@@ -23,10 +26,16 @@ class WorkHourDayExportProvider implements ProviderInterface
         private readonly RequestStack $requestStack,
         private EmployeeRepository $employeeRepository,
         private YearlyHoursExportBuilder $exportBuilder,
+        private readonly Security $security,
     ) {}
 
     public function provide(Operation $operation, array $uriVariables = [], array $context = []): Response
     {
+        $user = $this->security->getUser();
+        if (!$user instanceof User) {
+            throw new AccessDeniedHttpException('Authentication required.');
+        }
+
         $request = $this->requestStack->getCurrentRequest();
         if (!$request) {
             return new Response('Missing request.', Response::HTTP_BAD_REQUEST);
@@ -47,8 +56,9 @@ class WorkHourDayExportProvider implements ProviderInterface
             throw new UnprocessableEntityHttpException('siteIds is required.');
         }
 
-        // Feature réservée admin : on charge tous les employés puis on filtre.
+        // Périmètre selon le profil : admin → tous, chef de site → ses sites uniquement.
-        $employees = $this->employeeRepository->findAll();
+        // Les siteIds demandés ne peuvent donc pas déborder du scope de l'utilisateur.
+        $employees = $this->employeeRepository->findScoped($user);
 
         // Regroupement par site (ordre displayOrder), non-conducteurs uniquement.
         $bySite   = [];
@@ -78,7 +88,11 @@ class WorkHourDayExportProvider implements ProviderInterface
         $legend = [];
         foreach ($siteMeta as $siteId => $meta) {
             $siteEmployees = $bySite[$siteId];
-            usort($siteEmployees, static fn ($a, $b) => ($a->getLastName() ?? '') <=> ($b->getLastName() ?? ''));
+            // Même tri que le calendrier : ordre manuel (displayOrder) puis nom, puis prénom.
+            usort($siteEmployees, static function ($a, $b): int {
+                return [$a->getDisplayOrder(), $a->getLastName(), $a->getFirstName()]
+                    <=> [$b->getDisplayOrder(), $b->getLastName(), $b->getFirstName()];
+            });
 
             $rows = $this->exportBuilder->buildDayRowsForEmployees($siteEmployees, $date);
             if ([] === $rows) {

src/State/WorkHourWeeklySummaryProvider.php

@@ -28,6 +28,7 @@ use App\Service\PublicHolidayServiceInterface;
 use App\Service\WorkHours\AbsenceSegmentsResolver;
 use App\Service\WorkHours\DailyReferenceMinutesResolver;
 use App\Service\WorkHours\HolidayVirtualHoursResolver;
+use App\Service\WorkHours\NightHoursCalculator;
 use App\Service\WorkHours\WorkedHoursCreditPolicy;
 use DateTimeImmutable;
 use Symfony\Bundle\SecurityBundle\Security;
@@ -51,6 +52,7 @@ final readonly class WorkHourWeeklySummaryProvider implements ProviderInterface
         private HolidayVirtualHoursResolver $holidayVirtualHoursResolver,
         private PublicHolidayServiceInterface $publicHolidayService,
         private EmployeeWeekCommentRepository $weekCommentRepository,
+        private NightHoursCalculator $nightHoursCalculator,
     ) {}
 
     public function provide(Operation $operation, array $uriVariables = [], array $context = []): WorkHourWeeklySummary
@@ -433,14 +435,12 @@ final readonly class WorkHourWeeklySummaryProvider implements ProviderInterface
         ];
 
         $totalMinutes = 0;
-        $nightMinutes = 0;
-
         foreach ($ranges as [$from, $to]) {
             $totalMinutes += $this->intervalMinutes($from, $to);
-            $nightMinutes += $this->nightIntervalMinutes($from, $to);
         }
 
-        $dayMinutes = max(0, $totalMinutes - $nightMinutes);
+        $nightMinutes = $this->nightHoursCalculator->nightMinutesFromRanges($workHour);
+        $dayMinutes   = max(0, $totalMinutes - $nightMinutes);
 
         return new WorkMetrics(
             dayMinutes: $dayMinutes,
@@ -489,37 +489,6 @@ final readonly class WorkHourWeeklySummaryProvider implements ProviderInterface
         return max(0, $end - $start);
     }
 
-    private function nightIntervalMinutes(?string $from, ?string $to): int
-    {
-        $interval = $this->resolveInterval($from, $to);
-        if (null === $interval) {
-            return 0;
-        }
-
-        [$start, $end] = $interval;
-        // Fenêtres de nuit: 00:00-06:00 et 21:00-24:00.
-        $windows = [[0, 360], [1260, 1440]];
-        $total   = 0;
-
-        // On projette aussi sur J+1 pour couvrir les shifts qui traversent minuit.
-        for ($dayOffset = 0; $dayOffset <= 1; ++$dayOffset) {
-            $shift = $dayOffset * 1440;
-            foreach ($windows as [$windowStart, $windowEnd]) {
-                $total += $this->overlap($start, $end, $windowStart + $shift, $windowEnd + $shift);
-            }
-        }
-
-        return $total;
-    }
-
-    private function overlap(int $startA, int $endA, int $startB, int $endB): int
-    {
-        $start = max($startA, $startB);
-        $end   = min($endA, $endB);
-
-        return max(0, $end - $start);
-    }
-
     /**
      * @param array<string, ?Contract> $contractsByDate
      */

src/Util/LeaveRecapCutoff.php

@@ -7,16 +7,16 @@ namespace App\Util;
 use DateTimeImmutable;
 
 /**
- * Leave recap cutoff rule: as-of end of ISO week S-2 (Sunday 23:59:59).
+ * Leave recap cutoff rule: as-of end of ISO week S-1 (Sunday 23:59:59).
  *
- * Example: Tuesday 2026-04-14 (S16) → Sunday 2026-04-05 23:59:59 (end of S14).
+ * Example: Tuesday 2026-04-14 (S16) → Sunday 2026-04-12 23:59:59 (end of S15).
  */
 final class LeaveRecapCutoff
 {
     public static function resolveCutoff(DateTimeImmutable $today): DateTimeImmutable
     {
         $currentWeekMonday = $today->modify('monday this week')->setTime(0, 0);
-        $cutoffWeekMonday  = $currentWeekMonday->modify('-14 days');
+        $cutoffWeekMonday  = $currentWeekMonday->modify('-7 days');
 
         return $cutoffWeekMonday->modify('+6 days')->setTime(23, 59, 59);
     }

templates/night-hours-contingent/print.html.twig

@@ -0,0 +1,60 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="utf-8">
+    <style>
+        @page { margin: 16px; }
+        body { font-family: DejaVu Sans, sans-serif; font-size: 10px; color: #000; }
+        h1 { font-size: 15px; margin: 0 0 2px; }
+        .meta { font-size: 9px; color: #555; margin-bottom: 8px; }
+        table { width: 100%; border-collapse: collapse; }
+        th, td { border: 1px solid #999; padding: 2px 1px; text-align: center; }
+        th { background: #d9d9d9; }
+        td.name, th.name { text-align: left; width: 145px; padding-left: 4px; padding-right: 6px; }
+        .sub { font-size: 9px; }
+        td.data, th.data { width: 34px; font-size: 9px; }
+        tr.site-title td { text-align: left; font-weight: bold; }
+        td.hours { white-space: nowrap; }
+        td.month-start, th.month-start { border-left: 2.5px solid #333; }
+    </style>
+</head>
+<body>
+    <h1>Contingent heures de nuit — {{ year }}</h1>
+    <div class="meta">Édité le {{ exportedAt }}</div>
+
+    {% set months = ['Janv', 'Févr', 'Mars', 'Avr', 'Mai', 'Juin', 'Juil', 'Août', 'Sept', 'Oct', 'Nov', 'Déc'] %}
+
+    <table>
+        <thead>
+            <tr>
+                <th class="name" rowspan="2">Nom</th>
+                {% for m in months %}
+                    <th class="month-start" colspan="2">{{ m }}</th>
+                {% endfor %}
+            </tr>
+            <tr>
+                {% for m in months %}
+                    <th class="sub data month-start">H.nuit</th>
+                    <th class="sub data">N.jours</th>
+                {% endfor %}
+            </tr>
+        </thead>
+        <tbody>
+            {% for group in groups %}
+                <tr class="site-title">
+                    <td colspan="25" style="background: {{ group.siteColor|default('#eee') }}">{{ group.siteName }}</td>
+                </tr>
+                {% for row in group.rows %}
+                    <tr>
+                        <td class="name">{{ row.employeeName }}</td>
+                        {% for cell in row.cells %}
+                            <td class="hours data month-start">{{ cell.hours }}</td>
+                            <td class="data">{{ cell.days }}</td>
+                        {% endfor %}
+                    </tr>
+                {% endfor %}
+            {% endfor %}
+        </tbody>
+    </table>
+</body>
+</html>

tests/Service/Rtt/RttClosingBalanceServiceTest.php

@@ -80,6 +80,23 @@ final class RttClosingBalanceServiceTest extends TestCase
         );
     }
 
+    public function testCustomDeficitWeekReducesClosingBalance(): void
+    {
+        // CUSTOM (4h) : une semaine de récup +3h puis une semaine déficitaire -1h
+        // (toutes deux sans tranches 25/50). Le déficit doit réduire la clôture.
+        $recovery = new WeekRecoveryDetail(totalMinutes: 180, isFlatRecovery: true);   // +3h
+        $deficit  = new WeekRecoveryDetail(totalMinutes: -60, isFlatRecovery: true);   // -1h
+
+        $closing = $this->service()->fold(new WeekRecoveryDetail(), [$recovery, $deficit], $this->payments());
+
+        // 3h - 1h = 2h reportées, et la somme des buckets égale toujours le total.
+        self::assertSame(120, $closing->totalMinutes);
+        self::assertSame(
+            120,
+            $closing->base25Minutes + $closing->bonus25Minutes + $closing->base50Minutes + $closing->bonus50Minutes,
+        );
+    }
+
     public function testBucketSumAlwaysEqualsTotalInvariant(): void
     {
         $opening = new WeekRecoveryDetail(base25Minutes: 200, bonus25Minutes: 50, base50Minutes: 100, bonus50Minutes: 50, totalMinutes: 400);

tests/Service/Rtt/RttRecoveryComputationServiceTest.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace App\Tests\Service\Rtt;
 
 use App\Entity\Contract;
+use App\Enum\TrackingMode;
 use App\Service\Rtt\RttRecoveryComputationService;
 use PHPUnit\Framework\TestCase;
 use ReflectionClass;
@@ -113,6 +114,159 @@ final class RttRecoveryComputationServiceTest extends TestCase
         self::assertSame(3 * 60, $base50);
     }
 
+    public function testBuildWeekDetailCustomDeficitKeepsSignedTotalAndFlatFlag(): void
+    {
+        $service = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+
+        // CUSTOM, semaine sous les heures : overtime -120 (worked 2h sur réf 4h).
+        $detail = $this->invokePrivate(
+            $service,
+            'buildWeekRecoveryDetail',
+            false, // isPresence
+            false, // disableBonuses
+            true,  // isCustom
+            -120,  // overtimeTotalMinutes
+            0,     // rawBase25
+            0,     // rawBase50
+            [],    // dailyMinutes
+        );
+
+        self::assertSame(-120, $detail->totalMinutes);
+        self::assertTrue($detail->isFlatRecovery);
+        self::assertSame(0, $detail->base25Minutes);
+        self::assertSame(0, $detail->base50Minutes);
+    }
+
+    public function testBuildWeekDetailCustomPositiveIsFlatOneToOne(): void
+    {
+        $service = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+
+        $detail = $this->invokePrivate($service, 'buildWeekRecoveryDetail', false, false, true, 180, 0, 0, []);
+
+        self::assertSame(180, $detail->totalMinutes); // 1h = 1h
+        self::assertTrue($detail->isFlatRecovery);
+    }
+
+    public function testBuildWeekDetailStandardKeepsBucketsAndBonuses(): void
+    {
+        $service = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+
+        // 39h : overtime 300, base25 240, base50 60.
+        $detail = $this->invokePrivate($service, 'buildWeekRecoveryDetail', false, false, false, 300, 240, 60, []);
+
+        self::assertFalse($detail->isFlatRecovery);
+        self::assertSame(240, $detail->base25Minutes);
+        self::assertSame(60, $detail->bonus25Minutes);  // round(240 * 0.25)
+        self::assertSame(60, $detail->base50Minutes);
+        self::assertSame(30, $detail->bonus50Minutes);  // round(60 * 0.5)
+        self::assertSame(300 + 60 + 30, $detail->totalMinutes);
+    }
+
+    /**
+     * CUSTOM 4h, jour de solidarité non travaillé (RTT posé ou vide) : delta = (attendu − 0) − prorata.
+     * attendu lundi = workDaysHours = 120 ; prorata = round(4×12) = 48 ; delta = 120 − 48 = 72.
+     * (Combiné au naturel −120 de la semaine, donne −48 min.).
+     */
+    public function testSolidarityAdjustmentCustomNotWorkedNeutralisesToProrata(): void
+    {
+        $service = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+
+        $delta = $this->invokePrivate(
+            $service,
+            'computeSolidarityDeficitAdjustment',
+            self::customContract(4),
+            120, // expectedMinutes (workDaysHours du lundi)
+            0,   // workedMinutes (RTT posé / vide)
+        );
+
+        self::assertSame(72, $delta);
+    }
+
+    /**
+     * CUSTOM 4h, jour de solidarité travaillé normalement (120) : delta = (120 − 120) − 48 = −48.
+     */
+    public function testSolidarityAdjustmentCustomWorkedNormallyChargesProrata(): void
+    {
+        $service = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+
+        $delta = $this->invokePrivate($service, 'computeSolidarityDeficitAdjustment', self::customContract(4), 120, 120);
+
+        self::assertSame(-48, $delta);
+    }
+
+    /**
+     * CUSTOM 4h, jour de solidarité travaillé en plus (240) : delta = (120 − 240) − 48 = −168.
+     * Le surplus du jour de solidarité n'est PAS crédité (jour neutralisé, net forcé à −prorata).
+     */
+    public function testSolidarityAdjustmentCustomWorkedExtraStillNetsProrata(): void
+    {
+        $service = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+
+        $delta = $this->invokePrivate($service, 'computeSolidarityDeficitAdjustment', self::customContract(4), 120, 240);
+
+        self::assertSame(-168, $delta);
+    }
+
+    /**
+     * CUSTOM 28h : prorata = round(28×12) = 336 (5h36). worked 0, expected 336 → delta 0.
+     * Le delta est nul ici par coïncidence du fallback uniforme (expected = prorata) ; avec un vrai
+     * workDaysHours où la valeur du lundi diffère, expected ≠ prorata et le delta serait non nul.
+     */
+    public function testSolidarityAdjustmentCustom28hUsesProrata(): void
+    {
+        $service = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+
+        $delta = $this->invokePrivate($service, 'computeSolidarityDeficitAdjustment', self::customContract(28), 336, 0);
+
+        self::assertSame(0, $delta);
+    }
+
+    /**
+     * CUSTOM ≥ 35h (36h) : hors périmètre → delta 0.
+     */
+    public function testSolidarityAdjustmentCustom36hOutOfScope(): void
+    {
+        $service = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+
+        $delta = $this->invokePrivate($service, 'computeSolidarityDeficitAdjustment', self::customContract(36), 999, 0);
+
+        self::assertSame(0, $delta);
+    }
+
+    /**
+     * 35h : type H35 (pas CUSTOM) → delta 0 (comportement inchangé, RTT posé fait foi).
+     */
+    public function testSolidarityAdjustment35hOutOfScope(): void
+    {
+        $service  = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+        $contract = new Contract()->setName('35h')->setTrackingMode(TrackingMode::TIME)->setWeeklyHours(35);
+
+        $delta = $this->invokePrivate($service, 'computeSolidarityDeficitAdjustment', $contract, 420, 0);
+
+        self::assertSame(0, $delta);
+    }
+
+    /**
+     * Aucun contrat ce jour-là (salarié parti / pas encore embauché) → delta 0.
+     */
+    public function testSolidarityAdjustmentNoContractIsZero(): void
+    {
+        $service = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+
+        $delta = $this->invokePrivate($service, 'computeSolidarityDeficitAdjustment', null, 0, 0);
+
+        self::assertSame(0, $delta);
+    }
+
+    private static function customContract(int $weeklyHours): Contract
+    {
+        return new Contract()
+            ->setName('Temps partiel')
+            ->setTrackingMode(TrackingMode::TIME)
+            ->setWeeklyHours($weeklyHours)
+        ;
+    }
+
     private function invokePrivate(object $obj, string $method, mixed ...$args): mixed
     {
         return new ReflectionClass($obj::class)->getMethod($method)->invoke($obj, ...$args);

tests/Service/Rtt/SolidarityDayResolverTest.php

@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Service\Rtt;
+
+use App\Service\Rtt\SolidarityDayResolver;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @internal
+ */
+final class SolidarityDayResolverTest extends TestCase
+{
+    /**
+     * Lundi de Pentecôte = dimanche de Pâques + 50 jours.
+     * 2024 : Pâques 31/03 → 20/05 ; 2025 : Pâques 20/04 → 09/06 ; 2026 : Pâques 05/04 → 25/05.
+     */
+    #[DataProvider('pentecostCases')]
+    public function testPentecostMonday(int $year, string $expected): void
+    {
+        $resolver = new SolidarityDayResolver();
+
+        self::assertSame($expected, $resolver->pentecostMonday($year)->format('Y-m-d'));
+    }
+
+    /**
+     * @return iterable<string, array{int, string}>
+     */
+    public static function pentecostCases(): iterable
+    {
+        yield '2024' => [2024, '2024-05-20'];
+
+        yield '2025' => [2025, '2025-06-09'];
+
+        yield '2026' => [2026, '2026-05-25'];
+
+        // Century-boundary year: Easter 2000-04-23 → Whit Monday 2000-06-12
+        // (verified with: easter_date(2000) → date('+50 days'))
+        yield '2000' => [2000, '2000-06-12'];
+
+        // Late-April Easter (2011-04-24) → Whit Monday 2011-06-13
+        // (verified with: easter_date(2011) → date('+50 days'))
+        yield '2011' => [2011, '2011-06-13'];
+
+        // Easter on April 25 — exercises the computus corrective $m branch:
+        // Easter 2038-04-25 → Whit Monday 2038-06-14
+        // (verified with: easter_date(2038) → date('+50 days'))
+        yield '2038' => [2038, '2038-06-14'];
+    }
+
+    /**
+     * The returned date must always be a Monday (ISO weekday = 1).
+     * Verified for 2025 as a representative case.
+     */
+    public function testPentecostMondayIsAMonday(): void
+    {
+        $resolver = new SolidarityDayResolver();
+
+        self::assertSame('1', $resolver->pentecostMonday(2025)->format('N'));
+    }
+}

tests/Service/WorkHours/NightContingentExportBuilderTest.php

@@ -0,0 +1,123 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Service\WorkHours;
+
+use App\Entity\Employee;
+use App\Entity\WorkHour;
+use App\Repository\Contract\WorkHourReadRepositoryInterface;
+use App\Service\Contracts\EmployeeContractResolver;
+use App\Service\WorkHours\NightContingentExportBuilder;
+use App\Service\WorkHours\NightHoursCalculator;
+use DateTimeImmutable;
+use PHPUnit\Framework\TestCase;
+use ReflectionProperty;
+
+/**
+ * @internal
+ */
+final class NightContingentExportBuilderTest extends TestCase
+{
+    public function testAggregatesNightMinutesAndDaysPerMonth(): void
+    {
+        $employee = $this->makeEmployee(1, 'Dupont', 'Jean');
+
+        // Janvier : un jour 4h de nuit (>=240 -> 1 jour) + un jour 3h59 (<240 -> 0 jour).
+        $whFull = new WorkHour()->setEmployee($employee)
+            ->setWorkDate(new DateTimeImmutable('2026-01-10'))
+            ->setEveningFrom('21:00')->setEveningTo('01:00')   // 240 min nuit
+        ;
+        $whShort = new WorkHour()->setEmployee($employee)
+            ->setWorkDate(new DateTimeImmutable('2026-01-11'))
+            ->setEveningFrom('21:00')->setEveningTo('00:59')   // 239 min nuit
+        ;
+
+        $workHourRepo = $this->createStub(WorkHourReadRepositoryInterface::class);
+        $workHourRepo->method('findByDateRangeAndEmployees')->willReturn([$whFull, $whShort]);
+
+        $contractResolver = $this->createStub(EmployeeContractResolver::class);
+        $contractResolver->method('resolveIsDriverForEmployeesAndDays')->willReturn([
+            1 => ['2026-01-10' => false, '2026-01-11' => false],
+        ]);
+
+        $builder = new NightContingentExportBuilder(
+            $workHourRepo,
+            $contractResolver,
+            new NightHoursCalculator(),
+        );
+
+        $rows = $builder->buildRows([$employee], 2026);
+
+        self::assertCount(1, $rows);
+        self::assertSame(479, $rows[0]->months[1]['nightMinutes']); // 240 + 239
+        self::assertSame(1, $rows[0]->months[1]['nightDays']);      // seul le jour >=240
+        self::assertSame(0, $rows[0]->months[2]['nightMinutes']);   // fevrier vide
+        self::assertSame(0, $rows[0]->months[2]['nightDays']);
+    }
+
+    public function testDriverUsesManualNightMinutes(): void
+    {
+        $employee = $this->makeEmployee(2, 'Martin', 'Paul');
+
+        $wh = new WorkHour()->setEmployee($employee)
+            ->setWorkDate(new DateTimeImmutable('2026-03-05'))
+            ->setNightHoursMinutes(300)
+            ->setMorningFrom('08:00')->setMorningTo('12:00') // ignore (driver)
+        ;
+
+        $workHourRepo = $this->createStub(WorkHourReadRepositoryInterface::class);
+        $workHourRepo->method('findByDateRangeAndEmployees')->willReturn([$wh]);
+
+        $contractResolver = $this->createStub(EmployeeContractResolver::class);
+        $contractResolver->method('resolveIsDriverForEmployeesAndDays')->willReturn([
+            2 => ['2026-03-05' => true],
+        ]);
+
+        $builder = new NightContingentExportBuilder(
+            $workHourRepo,
+            $contractResolver,
+            new NightHoursCalculator(),
+        );
+
+        $rows = $builder->buildRows([$employee], 2026);
+
+        self::assertSame(300, $rows[0]->months[3]['nightMinutes']);
+        self::assertSame(1, $rows[0]->months[3]['nightDays']); // 300 >= 240
+    }
+
+    public function testEmployeeWithoutWorkHoursYieldsAllZeroMonths(): void
+    {
+        $employee = $this->makeEmployee(3, 'Durand', 'Marie');
+
+        $workHourRepo = $this->createStub(WorkHourReadRepositoryInterface::class);
+        $workHourRepo->method('findByDateRangeAndEmployees')->willReturn([]);
+
+        $contractResolver = $this->createStub(EmployeeContractResolver::class);
+        $contractResolver->method('resolveIsDriverForEmployeesAndDays')->willReturn([]);
+
+        $builder = new NightContingentExportBuilder(
+            $workHourRepo,
+            $contractResolver,
+            new NightHoursCalculator(),
+        );
+
+        $rows = $builder->buildRows([$employee], 2026);
+
+        self::assertCount(1, $rows);
+        for ($m = 1; $m <= 12; ++$m) {
+            self::assertSame(0, $rows[0]->months[$m]['nightMinutes']);
+            self::assertSame(0, $rows[0]->months[$m]['nightDays']);
+        }
+    }
+
+    private function makeEmployee(int $id, string $last, string $first): Employee
+    {
+        $employee = new Employee();
+        $employee->setLastName($last)->setFirstName($first);
+        $ref = new ReflectionProperty(Employee::class, 'id');
+        $ref->setValue($employee, $id);
+
+        return $employee;
+    }
+}

tests/Service/WorkHours/NightHoursCalculatorTest.php

@@ -0,0 +1,80 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Service\WorkHours;
+
+use App\Entity\WorkHour;
+use App\Service\WorkHours\NightHoursCalculator;
+use DateTimeImmutable;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @internal
+ */
+final class NightHoursCalculatorTest extends TestCase
+{
+    public function testNullRangeReturnsZero(): void
+    {
+        $calc = new NightHoursCalculator();
+        self::assertSame(0, $calc->nightIntervalMinutes(null, null));
+        self::assertSame(0, $calc->nightIntervalMinutes('08:00', null));
+        self::assertSame(0, $calc->nightIntervalMinutes(null, '17:00'));
+    }
+
+    public function testPureDayRangeHasNoNight(): void
+    {
+        $calc = new NightHoursCalculator();
+        // 08:00 -> 17:00 : entierement hors fenetres nuit (00:00-06:00, 21:00-24:00).
+        self::assertSame(0, $calc->nightIntervalMinutes('08:00', '17:00'));
+    }
+
+    public function testWindowBoundariesAreRightExclusive(): void
+    {
+        $calc = new NightHoursCalculator();
+        // 06:00 -> 21:00 : pile entre les deux fenetres de nuit, 0 min.
+        self::assertSame(0, $calc->nightIntervalMinutes('06:00', '21:00'));
+        // 22:00 -> 06:00 : 22-24 (120) + 00-06 (360) = 480, borne 06:00 exclue.
+        self::assertSame(480, $calc->nightIntervalMinutes('22:00', '06:00'));
+    }
+
+    public function testEveningWindowCounts(): void
+    {
+        $calc = new NightHoursCalculator();
+        // 21:00 -> 24:00 = 180 min de nuit.
+        self::assertSame(180, $calc->nightIntervalMinutes('21:00', '00:00'));
+    }
+
+    public function testShiftCrossingMidnightCountsBothWindows(): void
+    {
+        $calc = new NightHoursCalculator();
+        // 21:00 -> 05:00 : 21-24 (180) + 00-05 (300) = 480 min.
+        self::assertSame(480, $calc->nightIntervalMinutes('21:00', '05:00'));
+    }
+
+    public function testNightMinutesForWorkHourDriverUsesManualField(): void
+    {
+        $calc = new NightHoursCalculator();
+        $wh   = new WorkHour();
+        $wh->setWorkDate(new DateTimeImmutable('2026-01-15'))
+            ->setDayHoursMinutes(300)
+            ->setNightHoursMinutes(250)
+            ->setMorningFrom('08:00')->setMorningTo('12:00')
+        ;
+
+        // Driver -> champ manuel nightHoursMinutes, plages ignorees.
+        self::assertSame(250, $calc->nightMinutesForWorkHour($wh, true));
+    }
+
+    public function testNightMinutesForWorkHourNonDriverSumsRanges(): void
+    {
+        $calc = new NightHoursCalculator();
+        $wh   = new WorkHour();
+        $wh->setWorkDate(new DateTimeImmutable('2026-01-15'))
+            ->setMorningFrom('22:00')->setMorningTo('00:00')   // 120 min nuit
+            ->setEveningFrom('04:00')->setEveningTo('06:00')  // 120 min nuit
+        ;
+
+        self::assertSame(240, $calc->nightMinutesForWorkHour($wh, false));
+    }
+}

tests/Service/WorkHours/YearlyHoursDayRowsTest.php

@@ -14,6 +14,7 @@ use App\Service\PublicHolidayServiceInterface;
 use App\Service\WorkHours\AbsenceSegmentsResolver;
 use App\Service\WorkHours\DailyReferenceMinutesResolver;
 use App\Service\WorkHours\HolidayVirtualHoursResolver;
+use App\Service\WorkHours\NightHoursCalculator;
 use App\Service\WorkHours\WorkedHoursCreditPolicy;
 use App\Service\WorkHours\YearlyHoursExportBuilder;
 use DateTimeImmutable;
@@ -87,6 +88,7 @@ final class YearlyHoursDayRowsTest extends TestCase
             new WorkedHoursCreditPolicy($contractResolver, new DailyReferenceMinutesResolver()),
             $holidayService,
             $virtualResolver,
+            new NightHoursCalculator(),
         );
 
         $rows = $builder->buildDayRowsForEmployees([$withContract, $noContract], $date);

tests/State/EmployeeRttSummaryProviderTest.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace App\Tests\State;
 
 use App\Dto\Contracts\ContractPhase;
+use App\Dto\Rtt\EmployeeRttWeekSummary;
 use App\Entity\Contract;
 use App\Entity\Employee;
 use App\Entity\EmployeeContractPeriod;
@@ -201,6 +202,45 @@ final class EmployeeRttSummaryProviderTest extends TestCase
         self::assertSame(2030, $year);
     }
 
+    public function testFlatDeficitWeekIsNotDrainedFromTiers(): void
+    {
+        $provider = $this->buildProvider([]);
+
+        // Semaine CUSTOM déficitaire (-120), aucune tranche accumulée.
+        $weeks  = [$this->weekSummary(-120, true)];
+        $result = $this->invokePrivate($provider, 'applyDeficitCascade', $weeks, 0, 0);
+
+        // Buckets restent à 0 ; le total négatif est conservé (le cumul est calculé ailleurs).
+        self::assertSame(0, $result[0]->base25Minutes);
+        self::assertSame(0, $result[0]->base50Minutes);
+        self::assertSame(-120, $result[0]->totalMinutes);
+        self::assertTrue($result[0]->isFlatRecovery);
+    }
+
+    public function testStandardDeficitWeekDrainsFiftyThenTwentyFive(): void
+    {
+        $provider = $this->buildProvider([]);
+
+        // Semaine 35h/39h déficitaire (-100), avec 60 en 50% et 120 en 25% accumulés.
+        $weeks  = [$this->weekSummary(-100, false)];
+        $result = $this->invokePrivate($provider, 'applyDeficitCascade', $weeks, 120, 60);
+
+        self::assertSame(-60, $result[0]->base50Minutes); // 60 drainés du 50%
+        self::assertSame(-40, $result[0]->base25Minutes); // 40 restants drainés du 25%
+        self::assertSame(-100, $result[0]->totalMinutes);
+    }
+
+    public function testFlatPositiveWeekIsUntouched(): void
+    {
+        $provider = $this->buildProvider([]);
+
+        $weeks  = [$this->weekSummary(180, true)];
+        $result = $this->invokePrivate($provider, 'applyDeficitCascade', $weeks, 0, 0);
+
+        self::assertSame(180, $result[0]->totalMinutes);
+        self::assertSame(0, $result[0]->base25Minutes);
+    }
+
     // -----------------------------------------------------------------------
     // Test harness helpers.
     // -----------------------------------------------------------------------
@@ -247,6 +287,21 @@ final class EmployeeRttSummaryProviderTest extends TestCase
         return $employee;
     }
 
+    private function weekSummary(int $totalMinutes, bool $isFlat, int $base25 = 0, int $base50 = 0): EmployeeRttWeekSummary
+    {
+        return new EmployeeRttWeekSummary(
+            month: 6,
+            weekNumber: 1,
+            weekStart: '2026-06-01',
+            weekEnd: '2026-06-07',
+            overtimeMinutes: $totalMinutes,
+            base25Minutes: $base25,
+            base50Minutes: $base50,
+            totalMinutes: $totalMinutes,
+            isFlatRecovery: $isFlat,
+        );
+    }
+
     /**
      * Build an uninitialized provider with a RequestStack pre-loaded with the given query.
      *
@@ -256,7 +311,7 @@ final class EmployeeRttSummaryProviderTest extends TestCase
      * only setting the properties that the tested private methods actually read:
      * `requestStack` and `phaseResolver`.
      *
-     * @param array<string, string> $request query parameters (year, phaseId, ...)
+     * @param array<string, string> $request
      */
     private function buildProvider(array $request = []): EmployeeRttSummaryProvider
     {

tests/State/WorkHourWeeklySummaryProviderTest.php

@@ -21,6 +21,7 @@ use App\Service\PublicHolidayServiceInterface;
 use App\Service\WorkHours\AbsenceSegmentsResolver;
 use App\Service\WorkHours\DailyReferenceMinutesResolver;
 use App\Service\WorkHours\HolidayVirtualHoursResolver;
+use App\Service\WorkHours\NightHoursCalculator;
 use App\Service\WorkHours\WorkedHoursCreditPolicy;
 use App\State\WorkHourWeeklySummaryProvider;
 use DateTime;
@@ -69,6 +70,7 @@ final class WorkHourWeeklySummaryProviderTest extends TestCase
             $this->buildHolidayResolver(),
             $this->buildHolidayService(),
             $this->buildWeekCommentRepoStub(),
+            new NightHoursCalculator(),
         );
 
         $this->expectException(AccessDeniedHttpException::class);
@@ -133,6 +135,7 @@ final class WorkHourWeeklySummaryProviderTest extends TestCase
             $this->buildHolidayResolver(),
             $this->buildHolidayService(),
             $this->buildWeekCommentRepoStub(),
+            new NightHoursCalculator(),
         );
 
         $result = $provider->provide(new Get());

tests/Util/LeaveRecapCutoffTest.php

@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Util;
+
+use App\Util\LeaveRecapCutoff;
+use DateTimeImmutable;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Cutoff rule: end of ISO week S-1 (previous week's Sunday 23:59:59).
+ *
+ * @internal
+ */
+final class LeaveRecapCutoffTest extends TestCase
+{
+    public function testCutoffIsPreviousWeekSunday(): void
+    {
+        // Tuesday 2026-04-14 (S16) → Sunday 2026-04-12 23:59:59 (end of S15).
+        $cutoff = LeaveRecapCutoff::resolveCutoff(new DateTimeImmutable('2026-04-14'));
+
+        self::assertSame('2026-04-12 23:59:59', $cutoff->format('Y-m-d H:i:s'));
+    }
+
+    public function testCutoffFromMondayPointsToPreviousSunday(): void
+    {
+        // Monday 2026-06-08 → previous Sunday 2026-06-07 23:59:59.
+        $cutoff = LeaveRecapCutoff::resolveCutoff(new DateTimeImmutable('2026-06-08'));
+
+        self::assertSame('2026-06-07 23:59:59', $cutoff->format('Y-m-d H:i:s'));
+    }
+
+    public function testCutoffFromSundayPointsToPreviousSunday(): void
+    {
+        // Sunday 2026-06-14 (still in current ISO week) → previous Sunday 2026-06-07.
+        $cutoff = LeaveRecapCutoff::resolveCutoff(new DateTimeImmutable('2026-06-14'));
+
+        self::assertSame('2026-06-07 23:59:59', $cutoff->format('Y-m-d H:i:s'));
+    }
+
+    public function testCutoffIsAlwaysASundayExactlyOneWeekBeforeCurrentWeek(): void
+    {
+        // Today 2026-06-11 (Thursday) → end of S-1 = Sunday 2026-06-07.
+        $cutoff = LeaveRecapCutoff::resolveCutoff(new DateTimeImmutable('2026-06-11'));
+
+        self::assertSame('Sunday', $cutoff->format('l'));
+        self::assertSame('2026-06-07 23:59:59', $cutoff->format('Y-m-d H:i:s'));
+    }
+}