docs(rtt) : add design spec and implementation plan for custom deficit

chore(rtt) : align TS week DTO with isFlatRecovery field
docs(rtt) : custom contract deficit now reduces the balance
2026-06-09 10:21:25 +02:00 · 2026-06-09 10:20:59 +02:00 · 2026-06-09 10:15:38 +02:00 · 2026-06-09 10:13:21 +02:00 · 2026-06-09 10:08:33 +02:00 · 2026-06-09 10:07:55 +02:00
38 changed files with 2408 additions and 131 deletions
@@ -33,12 +33,14 @@
 - Contract nature (per period): CDI, CDD, INTERIM
 - **Agence d'intérim** (`InterimAgency` entity, table `interim_agencies`): optionnelle sur `EmployeeContractPeriod` quand nature = INTERIM. Pas de CRUD UI — gérée en BDD. API lecture seule `GET /interim_agencies`. Affichée "Intérim (NomAgence)" sur la liste employés et l'historique contrat.
 - 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).
- **É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.
+- **É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.
+- **É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
 - Absences with `countAsWorkedHours=true`: credit minutes (TIME) or nothing (PRESENCE)
 - Driver periods (`isDriver=true` on `EmployeeContractPeriod`): separate screen `/driver-hours`, uses `dayHoursMinutes`/`nightHoursMinutes` + meal/overnight flags on `WorkHour`
+- **Panier de nuit (PN) — conducteurs exclus** : le panier de nuit (règle nuit > jour OU nuit ≥ 4h) **ne s'applique qu'aux non-conducteurs**. Un jour conducteur ne crédite jamais de PN, ni sur la vue semaine (`WorkHourWeeklySummaryProvider`, garde `!$isDateDriver`) ni sur le récap salaire (`SalaryRecapPrintProvider`, bloc `if ($isDriver)` sans incrément). Les conducteurs ont leurs propres primes (PDJ/repas/nuitée).

 ## Fériés
 - Source : API gouv via `PublicHolidayService` (cache 30j)
@@ -63,12 +65,15 @@
 ## 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.
 - **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
 - Driver contracts: RTT uses `dayHoursMinutes + nightHoursMinutes + workshopHoursMinutes` instead of morning/afternoon/evening time ranges
 - FORFAIT weekend/holiday bonus: each weekend or public holiday day worked gives bonus leave (full day if morning+afternoon, 0.5 if only one). Added to acquired days, no cap. PRESENCE mode only.
 - **FORFAIT — jours de présence et N-1** : les congés posés et imputés sur le stock N-1 ne décrémentent **pas** les jours de présence affichés (`presenceDaysByMonth` et `presenceDaysToToday`). Implémenté dans `EmployeeLeaveSummaryProvider::computePresenceDaysByMonth` via un budget N-1 (= `previousYearTakenDays`) consommé chronologiquement avant comptage des absences. Pour les non-forfait, ce budget vaut toujours 0 → comportement inchangé.
+  - **Récap salaire (export PDF mensuel)** : même règle appliquée dans `SalaryRecapPrintProvider` — un congé forfait imputé N-1 n'est ni affiché en colonne congés ni soustrait, et compte comme jour de présence. Le budget N-1 vient de `EmployeeLeaveSummaryProvider::resolvePreviousYearTakenDays()` (méthode publique mutualisée, qui reproduit `provide()` : phase courante + recalcul jours payés, donc **même budget que la fiche employé**). Comme l'export est mensuel, les congés sont chargés depuis le 1er janvier (`findForPrint(yearStart, to)`) et le budget consommé chronologiquement par `splitForfaitCongesByN1()`. Non-forfait ou budget N-1 = 0 → `countAbsencesByCode(['C'])` inchangé.
+  - **Colonne « Heures payés » scindée 25 %/50 %** : en-tête fusionné (`colspan=2`) + deux sous-colonnes `25%`/`50%` dans le template `salary-recap/print.html.twig`. Données : `paid25Hours` = `base25Minutes`, `paid50Hours` = `base50Minutes` (bases seules, **hors bonus** — total inchangé vs l'ancienne colonne unique). `buildRttPaymentMap` renvoie `['m25','m50']` par employé. Le tableau a désormais 20 colonnes (`colspan` des lignes site/vide ajusté).
 - **Jours de présence — borne début de contrat** : `presenceDaysByMonth`/`presenceDaysToToday` sont calculés à partir de `resolveEarliestContractStartWithinRange` (début de contrat dans l'exercice), pas du début d'exercice brut. Évite de compter comme « présents » les jours ouvrés antérieurs à l'embauche pour une entrée en cours d'exercice (ex. CDD : Dylan passait de 43,5 à 246 sans la borne). Sans effet pour un employé présent depuis avant l'exercice ni pour le forfait (déjà capé au début de phase).

 ## Onglet Congés (fiche employé)
@@ -85,6 +90,21 @@
 - Sur un exercice passé, le bouton **+ Payer les RTT** est désactivé (pas de paiement rétroactif).
 - Doc : `doc/rtt-tab.md`.

+## Rollover RTT (cron `app:rtt:rollover`)
+- Bascule le **1er juin** (idempotente) : crée la ligne `employee_rtt_balances` du nouvel exercice (`targetYear`) pour chaque employé éligible (ni INTERIM, ni PRESENCE).
+- **Report = solde de clôture de l'exercice N-1**, pas seulement l'acquis : `report_ouverture(N-1) + acquis(N-1) − RTT payés(N-1)`. C'est exactement le **disponible** affiché par `EmployeeRttSummaryProvider` (`carry + currentYearRecovery − totalPaid`). Le report stocké pour N reprend donc le disponible de fin N-1 ; le report déjà présent en début d'année n'est jamais perdu, et les heures payées ne sont pas re-créditées.
+- Service mutualisé : `App\Service\Rtt\RttClosingBalanceService` (méthode `computeClosingBalance` + `fold` pur testable). `fold` garantit `somme(tranches) = report + acquis − payés` ; la cascade des semaines déficitaires draine la tranche 50% avant la 25%, et la récup non bucketisée (CUSTOM 1h=1h, arrondis) atterrit en `base25` pour que la somme égale le total.
+- Options : `--force` (hors 01/06) ; `--recompute` (recalcule/écrase les lignes existantes au lieu de les sauter ; **ne touche jamais** une ligne verrouillée `is_locked`). Reprise d'une bascule erronée : `app:rtt:rollover --force --recompute`.
+- ⚠️ Bug historique : la 1ʳᵉ version ne reportait que `acquis(N-1)` (report d'ouverture perdu, paiements non déduits). Corrigé via `RttClosingBalanceService`.
+- **Fallback provider** : quand aucune ligne `employee_rtt_balances` n'existe pour l'exercice affiché (avant la bascule), `EmployeeRttSummaryProvider::resolveCarry` calcule le report en direct via `RttClosingBalanceService::computeClosingBalance($year-1)` (et non plus `computeTotalRecoveryForExercise`) — le disponible reste donc correct (report d'ouverture + acquis − payés) même sans ligne stockée.
+- Doc : `doc/rtt-rollover.md`.
+
+## Paiement RTT rétroactif (exercice précédent) — Option B
+- Le paiement RTT est autorisé sur : l'**exercice courant**, l'**exercice immédiatement précédent** (N-1), ou le dernier exercice d'une phase clôturée. Garde back : `EmployeeRttPaymentProcessor::assertYearAllowedForPayment`. Garde front : `RttTab.vue` `isPayDisabled` (bouton actif sur `selectedYear === currentYear - 1`).
+- **Cohérence du report** : un paiement sur N-1 modifie la clôture de N-1 = ouverture de N. Le processor **recalcule automatiquement** la ligne `employee_rtt_balances` de l'exercice courant (`computeClosingBalance(N-1)`) dans une **transaction** (le `flush` du paiement le rend visible au recalcul). Pas de double comptage.
+- **Verrou** : si le report de l'exercice courant est `is_locked`, le paiement rétroactif est **refusé** (`assertReportNotLocked`) — la RH doit déverrouiller d'abord.
+- Portée limitée à N-1 (chaîne de recalcul = 1 étape). Si la ligne courante n'existe pas encore, le fallback provider couvre l'affichage (cf. ci-dessus).
+
 ## Vue contrat (sélecteur de phase)
 - Picker `Vue contrat` en haut de la fiche employé (`pages/employees/[id].vue`). Caché si l'employé n'a qu'une phase.
 - Phase = groupe d'`EmployeeContractPeriod` consécutifs partageant la signature `(contract.type, weeklyHours, isDriver)`. Résolu par `App\Service\Contracts\EmployeeContractPhaseResolver`.
@@ -1,2 +1,2 @@
 parameters:
-    app.version: '0.1.103'
+    app.version: '0.1.107'
@@ -61,6 +61,9 @@ Documents complementaires:
 - Libellé nature de contrat (CDI/CDD/Intérim) affiché sous le nom:
  - résolu à la date filtrée (période de contrat couvrant ce jour), pas à aujourd'hui
  - masqué si aucun contrat à cette date (cas rarissime en vue jour puisque l'employé est alors déjà filtré)
+- **Vue Jour (Heures) — contrat à la date affichée** : le mode de suivi (saisie d'heures vs cases de présence), le libellé de contrat et la logique de sauvegarde sont résolus selon la période de contrat valable à la date filtrée (champs `trackingMode`/`weeklyHours`/`contractType`/`contractName` portés par `WorkHourDayContext`, alimentés par `EmployeeContractResolver::resolveForEmployeeAndDate`), et non selon le contrat courant de l'employé. Un salarié passé 39h/35h → Forfait conserve donc la saisie d'heures sur ses dates antérieures à la bascule, et bascule en cases de présence à partir de la date de passage en forfait. La vue Semaine était déjà résolue par date.
+- **Exports heures annuelles (par salarié et tous salariés)** : affichent **tous les jours sous contrat**, même vides ou non saisis, jusqu'à la date du jour ; seuls les jours hors contrat (avant embauche, après départ, suspension) sont omis. Les samedis et dimanches sont grisés (gris foncé), les jours fériés en bleu.
+- **Récap salaire (export PDF mensuel)** : seuls les salariés ayant un contrat couvrant tout ou partie du mois imprimé apparaissent (filtre `hasContractInRange`). Un salarié dont le contrat est terminé avant le mois (ex. parti en février) n'est pas listé sur le récap des mois suivants.

 ## 4) Absences

@@ -123,6 +126,11 @@ Documents complementaires:
  - contrats >= 39h: de 39h à 43h
 - Tranche 50%:
  - au-delà de 43h
+- Embauche/fin de contrat en milieu de semaine (calcul RTT — `RttRecoveryComputationService`):
+  - les seuils sont proratisés aux jours réellement contractés de la semaine (les jours hors contrat ne comptent pas)
+  - le seuil de départ du 25% **et** le plafond 25%/50% sont décalés ensemble ; la bande 25% garde sa largeur réglementaire (4h pour un 39h, 8h pour un 35h)
+  - une semaine d'embauche peut ainsi ouvrir à la fois du 25% et du 50% (ex. CDD 39h embauché le jeudi, 22h travaillées → 4h à 25% + 3h à 50%)
+  - note: la synthèse de l'écran Heures (vue semaine) n'applique pas cette proratisation (calcul distinct dans `WorkHourWeeklySummaryProvider`)
 - Date de début RTT (`RTT_START_DATE` dans `.env`):
  - les semaines dont la fin est antérieure à cette date sont ignorées dans le calcul de récupération
  - permet d'éviter les déficits fictifs avant la mise en service du logiciel
@@ -160,7 +168,7 @@ Documents complementaires:
 - Validation: même logique que les heures classiques (`isValid`, `isSiteValid`, bulk)
 - Vue semaine:
  - jour/nuit/atelier par jour + indicateurs repas/dîner/nuitée
-  - panier de nuit (PN): affiché par jour si (nightMinutes > dayMinutes) OU (nightMinutes >= 240, soit au moins 4h de travail entre 21h et 6h), et total hebdo dans la colonne Jour/Nuit sem.
+  - panier de nuit (PN): **ne s'applique pas aux conducteurs** (ils disposent de leurs propres primes repas/nuitée). Aucun PN n'est crédité sur un jour conducteur, ni sur la vue semaine conducteurs ni sur le récap salaire. La règle PN (nuit > jour OU nuit ≥ 4h) ne concerne que les non-conducteurs.
  - totaux hebdo: jour, nuit, atelier, total, compteurs petit déj/déjeuner/dîner/nuitée
  - les conducteurs utilisent `dayHoursMinutes + nightHoursMinutes + workshopHoursMinutes` pour le calcul RTT (au lieu des créneaux morning/afternoon/evening)
 - Le flag `isDriver` est sur `EmployeeContractPeriod` (un employé peut changer de statut chauffeur selon la période)
@@ -261,6 +269,7 @@ Seuls les employés dont au moins une période de contrat intersecte la période
        - pris: basé sur toutes les absences (demi-journées incluses)
        - restants = acquis - pris (borné à 0)
        - paiement congés N-1: saisie RH via `PATCH /employees/{id}/paid-leave-days` (body: `paidLeaveDays`, `year`). Stocké dans `employee_leave_balances.paid_leave_days`. Les jours payés réduisent le stock N-1 **avant** l'attribution des jours pris : `disponible_N-1 = max(0, acquis_N-1 - payés)`, puis `pris_N-1 = min(disponible_N-1, total_pris)`, surplus pris basculé sur N. Reste à prendre N-1 = `max(0, disponible_N-1 - pris_N-1)`. Uniquement pour les contrats forfait.
+        - jours de présence et récap salaire: pour un forfait, les jours de congé imputés sur le stock N-1 (`previousYearTakenDays`) **ne réduisent pas** les jours de présence et **ne s'affichent pas** comme congés. Sur l'export Récap salaire (mensuel), le budget N-1 est consommé chronologiquement depuis le 1er janvier ; les jours couverts deviennent des jours de présence, les jours au-delà restent affichés en congés. Le budget est le même que la fiche employé (jours payés déduits du stock N-1 d'abord).
      - report annuel:
        - le reliquat (`restants`) de l'exercice précédent est reporté dans les acquis de l'exercice courant
        - pour `CDI`/`CDD` non forfait: report séparé jours + samedis
@@ -79,15 +79,30 @@ Commande quotidienne (cron) idempotente.
  - le `01/06`: calcule et persiste le report pour chaque employe eligible
  - les autres jours: sortie sans action
 - option manuelle: `--force` pour executer hors date metier (reprise/correction)
+- option manuelle: `--recompute` pour recalculer et **ecraser** les lignes existantes au lieu de les sauter (reprise apres correction). Les lignes verrouillees (`is_locked = true`, validees RH) ne sont jamais ecrasees.

 Date d'effet:
 - au `1er juin` (meme date que le rollover conges non forfait)

 Traitement par employe:
 1. verifier l'eligibilite (ni INTERIM, ni suivi PRESENCE)
-2. verifier qu'aucune ligne n'existe deja pour `(employee, targetYear)` (idempotence)
-3. calculer la somme des minutes de recuperation de l'exercice N-1
-4. creer la ligne du nouvel exercice avec ce total en `opening_minutes`
+2. en mode normal: si une ligne existe deja pour `(employee, targetYear)`, la sauter (idempotence). En mode `--recompute`: la recalculer, sauf si elle est verrouillee.
+3. calculer le **solde de cloture** de l'exercice N-1 (= disponible affiche en fin d'exercice) :
+   `report d'ouverture N-1  +  acquis N-1  −  RTT payes N-1`
+   - le **report d'ouverture N-1** vient de la ligne `employee_rtt_balances` de l'exercice N-1 (import go-live ou rollover precedent) ; a defaut, calcul dynamique des acquis de N-2.
+   - l'**acquis N-1** = somme des minutes de recuperation hebdomadaires de l'exercice N-1.
+   - les **RTT payes N-1** (`employee_rtt_payments`) sont deduits.
+4. creer (ou mettre a jour) la ligne du nouvel exercice avec ce solde, reparti sur les 4 tranches `opening_base25/bonus25/base50/bonus50`.
+
+> 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

@@ -16,6 +16,17 @@ 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.
+
 ## Sélecteur d'année

 Position : sous la table, à l'intérieur de la zone scrollable, à gauche.
@@ -34,9 +45,18 @@ Comportement :

 ## Verrouillage des éditions sur exercices passés

-Quand `selectedYear !== currentYear` (consultation d'un exercice antérieur), le bouton **+ Payer les RTT** est désactivé. Justification : un paiement rétroactif sur un exercice clos décalerait les soldes courants et le report N-1 calculé.
+Quand `selectedYear !== currentYear` (consultation d'un exercice antérieur), le bouton **+ Payer les RTT** est désactivé — **sauf sur l'exercice immédiatement précédent** (`selectedYear === currentYear - 1`), où le paiement rétroactif est autorisé (Option B).

-La consultation reste possible, l'édition non.
+La consultation des exercices plus anciens reste possible, l'édition non.
+
+### Paiement rétroactif sur l'exercice précédent (Option B)
+
+Un paiement enregistré sur l'exercice N-1 modifie sa clôture, donc le **report d'ouverture de l'exercice courant N**. Pour éviter tout décalage / double comptage :
+
+- garde back `EmployeeRttPaymentProcessor::assertYearAllowedForPayment` : accepte courant, **N-1**, ou dernier exercice d'une phase clôturée ;
+- après enregistrement, le processor **recalcule automatiquement** la ligne `employee_rtt_balances` de l'exercice courant via `RttClosingBalanceService::computeClosingBalance(N-1)`, dans une **transaction** (le `flush` du paiement le rend visible au recalcul) ;
+- si le report de l'exercice courant est **verrouillé** (`is_locked`), le paiement est **refusé** (`assertReportNotLocked`) : la RH doit déverrouiller d'abord ;
+- portée volontairement limitée à N-1 (chaîne de recalcul = 1 étape). Si la ligne courante n'existe pas encore, l'affichage reste correct grâce au fallback de `EmployeeRttSummaryProvider::resolveCarry` (calcul dynamique de la clôture N-1).

 ## Sélecteur de phase de contrat

@@ -0,0 +1,307 @@
+# Vue Jour — contrat résolu à la date affichée — 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:** Faire que l'écran Heures — vue Jour affiche/sauvegarde la saisie d'heures (TIME) vs cases de présence (PRESENCE) et le libellé de contrat selon le contrat valable **à la date affichée**, et non le contrat courant de l'employé.
+
+**Architecture:** Le provider backend `WorkHourDayContextProvider` résout déjà le contrat à la date demandée. On expose 4 champs de contrat supplémentaires sur la ligne du jour (`DayContextRow`), on les reflète dans le DTO TS, puis le composable `useHoursPage` lit ces champs par date (fallback sur `employee.contract` si pas de ligne du jour). `handleSave` en hérite automatiquement.
+
+**Tech Stack:** Symfony / API Platform (PHP 8.4, PHPUnit) côté backend ; Nuxt 4 / Vue 3 / TypeScript côté frontend.
+
+Spec : `docs/superpowers/specs/2026-06-01-day-view-per-date-tracking-mode-design.md`
+
+---
+
+## File Structure
+
+- `src/Dto/WorkHours/DayContextRow.php` — DTO ligne du jour : +4 champs.
+- `src/State/WorkHourDayContextProvider.php` — peuple les 4 champs depuis le contrat du jour.
+- `tests/State/WorkHourDayContextProviderTest.php` — test de résolution par date.
+- `frontend/services/dto/work-hour.ts` — type `WorkHourDayContextRow` : +4 champs.
+- `frontend/composables/useHoursPage.ts` — helpers résolus par date.
+- `doc/` + `frontend/data/documentation-content.ts` + `CLAUDE.md` — documentation.
+
+---
+
+### Task 1: Backend — exposer le contrat du jour sur `DayContextRow`
+
+**Files:**
+- Modify: `src/Dto/WorkHours/DayContextRow.php`
+- Modify: `src/State/WorkHourDayContextProvider.php:60-71`
+- Test: `tests/State/WorkHourDayContextProviderTest.php`
+
+- [ ] **Step 1: Écrire le test en échec**
+
+Ajouter cette méthode dans `tests/State/WorkHourDayContextProviderTest.php` (après `testBuildsRowsWithAbsenceCredits`). Elle vérifie que la ligne porte le contrat **à la date demandée** pour un employé 39h→Forfait. On remplace le resolver stub par un callback dépendant de la date.
+
+```php
+public function testRowCarriesContractAtRequestedDate(): void
+{
+    $user = new User();
+
+    $timeContract = new Contract()
+        ->setName('Contrat')
+        ->setTrackingMode(Contract::TRACKING_TIME)
+        ->setWeeklyHours(39)
+    ;
+    $forfaitContract = new Contract()
+        ->setName('Forfait')
+        ->setTrackingMode(Contract::TRACKING_PRESENCE)
+        ->setWeeklyHours(null)
+    ;
+    $employee = new Employee()
+        ->setFirstName('Jean')
+        ->setLastName('Test')
+        ->setContract($forfaitContract)
+    ;
+    $this->setEntityId($employee, 1);
+
+    // Resolver renvoie le contrat 39h avant 2026-03-01, le forfait à partir de cette date.
+    $resolver = $this->createStub(EmployeeContractResolver::class);
+    $resolver->method('resolveForEmployeeAndDate')->willReturnCallback(
+        static fn (Employee $e, \DateTimeImmutable $d): ?Contract =>
+            $d < new \DateTimeImmutable('2026-03-01') ? $timeContract : $forfaitContract
+    );
+    $resolver->method('resolveNatureForEmployeeAndDate')->willReturn(ContractNature::CDI);
+
+    $this->requestStack->push(new Request(query: ['workDate' => '2026-02-16']));
+    $this->security->method('getUser')->willReturn($user);
+    $this->employeeRepository->method('findScoped')->with($user)->willReturn([$employee]);
+    $this->absenceRepository->method('findByDateAndEmployees')->willReturn([]);
+
+    $provider = new WorkHourDayContextProvider(
+        $this->security,
+        $this->requestStack,
+        $this->employeeRepository,
+        $this->absenceRepository,
+        $this->formationRepository,
+        $resolver,
+        new AbsenceSegmentsResolver(),
+        new WorkedHoursCreditPolicy($this->buildResolverStub(), new DailyReferenceMinutesResolver()),
+        $this->buildHolidayResolver(),
+    );
+
+    $row = $provider->provide(new Get())->rows[0];
+
+    self::assertSame('TIME', $row['trackingMode']);
+    self::assertSame(39, $row['weeklyHours']);
+    self::assertSame('39H', $row['contractType']);
+    self::assertSame('Contrat', $row['contractName']);
+}
+```
+
+- [ ] **Step 2: Lancer le test, vérifier l'échec**
+
+Run: `make test`
+Expected: FAIL — `Undefined array key "trackingMode"` (le DTO ne porte pas encore le champ).
+
+- [ ] **Step 3: Ajouter les 4 champs au DTO**
+
+Dans `src/Dto/WorkHours/DayContextRow.php`, ajouter au constructeur après `public ?string $contractNature = null,` :
+
+```php
+        public ?string $trackingMode = null,
+        public ?int $weeklyHours = null,
+        public ?string $contractType = null,
+        public ?string $contractName = null,
+```
+
+Mettre à jour le PHPDoc de `toArray()` (ajouter les 4 clés après `contractNature:?string`) :
+
+```php
+     *     contractNature:?string,
+     *     trackingMode:?string,
+     *     weeklyHours:?int,
+     *     contractType:?string,
+     *     contractName:?string
+```
+
+Et le corps de `toArray()`, après `'contractNature' => $this->contractNature,` :
+
+```php
+            'trackingMode'          => $this->trackingMode,
+            'weeklyHours'           => $this->weeklyHours,
+            'contractType'          => $this->contractType,
+            'contractName'          => $this->contractName,
+```
+
+- [ ] **Step 4: Peupler les champs dans le provider**
+
+Dans `src/State/WorkHourDayContextProvider.php`, dans l'appel `new DayContextRow(...)` (lignes 65-71), ajouter après `contractNature: $contractNature,` :
+
+```php
+                trackingMode: $contract?->getTrackingMode(),
+                weeklyHours: $contract?->getWeeklyHours(),
+                contractType: $contract?->getType()->value,
+                contractName: $contract?->getName(),
+```
+
+- [ ] **Step 5: Lancer le test, vérifier le succès**
+
+Run: `make test`
+Expected: PASS (le nouveau test et les 150 autres ; le test legacy `EmployeeRttSummaryProviderTest::testNoQueryParamsKeepsLegacyYearDefaulting` peut rester rouge — pré-existant, dépendant de la date, hors périmètre).
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add src/Dto/WorkHours/DayContextRow.php src/State/WorkHourDayContextProvider.php tests/State/WorkHourDayContextProviderTest.php
+git commit -m "[#SIRH] Vue jour: exposer le contrat du jour sur DayContextRow"
+```
+
+---
+
+### Task 2: Frontend — lire le contrat par date dans la vue Jour
+
+**Files:**
+- Modify: `frontend/services/dto/work-hour.ts:103-118`
+- Modify: `frontend/composables/useHoursPage.ts`
+
+- [ ] **Step 1: Refléter les 4 champs dans le DTO TS**
+
+Dans `frontend/services/dto/work-hour.ts`, type `WorkHourDayContextRow`, ajouter après `contractNature?: ...` (ligne 117) :
+
+```typescript
+  trackingMode?: TrackingMode | null
+  weeklyHours?: number | null
+  contractType?: string | null
+  contractName?: string | null
+```
+
+(`TrackingMode` est déjà importé dans ce fichier — utilisé ligne 73.)
+
+- [ ] **Step 2: Ajouter un résolveur de contrat par date dans le composable**
+
+Dans `frontend/composables/useHoursPage.ts`, juste avant `const isPresenceTracking` (ligne 353), insérer :
+
+```typescript
+  // Résout le contrat à la date affichée (ligne du jour), avec repli sur le contrat courant.
+  const resolveDayContract = (employee: Employee) => {
+    const dayRow = dayContextByEmployeeId.value.get(employee.id)
+    if (dayRow?.hasContractAtDate) {
+      return {
+        trackingMode: dayRow.trackingMode ?? null,
+        weeklyHours: dayRow.weeklyHours ?? null,
+        type: dayRow.contractType ?? null,
+        name: dayRow.contractName ?? ''
+      }
+    }
+    return {
+      trackingMode: employee.contract?.trackingMode ?? null,
+      weeklyHours: employee.contract?.weeklyHours ?? null,
+      type: employee.contract?.type ?? null,
+      name: employee.contract?.name ?? ''
+    }
+  }
+```
+
+- [ ] **Step 3: Brancher les helpers sur le contrat du jour**
+
+Toujours dans `frontend/composables/useHoursPage.ts`, remplacer les définitions actuelles (lignes 353-358 et 367-377).
+
+Remplacer :
+
+```typescript
+  const isPresenceTracking = (employee: Employee) => employee.contract?.trackingMode === TRACKING_MODES.PRESENCE
+  const isTimeTracking = (employee: Employee) => !isPresenceTracking(employee)
+  const is4hContract = (employeeId: number) => {
+    const employee = employees.value.find((e) => e.id === employeeId)
+    return employee?.contract?.weeklyHours === 4
+  }
+```
+
+par :
+
+```typescript
+  const isPresenceTracking = (employee: Employee) => resolveDayContract(employee).trackingMode === TRACKING_MODES.PRESENCE
+  const isTimeTracking = (employee: Employee) => !isPresenceTracking(employee)
+  const is4hContract = (employeeId: number) => {
+    const employee = employees.value.find((e) => e.id === employeeId)
+    return employee ? resolveDayContract(employee).weeklyHours === 4 : false
+  }
+```
+
+Remplacer :
+
+```typescript
+  const contractLabel = (employee: Employee) => {
+    const contract = employee.contract
+    if (!contract) return '-'
+    if (contract.type === CONTRACT_TYPES.INTERIM) {
+      return contract.name
+    }
+    if (contract.weeklyHours !== null && contract.weeklyHours !== undefined && contract.trackingMode === TRACKING_MODES.TIME) {
+      return `${contract.weeklyHours}h`
+    }
+    return contract.name
+  }
+```
+
+par :
+
+```typescript
+  const contractLabel = (employee: Employee) => {
+    const contract = resolveDayContract(employee)
+    if (!contract.type && !contract.name) return '-'
+    if (contract.type === CONTRACT_TYPES.INTERIM) {
+      return contract.name
+    }
+    if (contract.weeklyHours !== null && contract.weeklyHours !== undefined && contract.trackingMode === TRACKING_MODES.TIME) {
+      return `${contract.weeklyHours}h`
+    }
+    return contract.name
+  }
+```
+
+- [ ] **Step 4: Vérification statique de lecture**
+
+Relire le diff : `resolveDayContract` est défini après `dayContextByEmployeeId` (ligne 201) et `employees` — donc disponible. `isPresenceTracking` reste de signature `(employee: Employee)` ⇒ aucun appelant à modifier (`HoursDayView.vue`, `handleSave` ligne 1073 inchangés). `CONTRACT_TYPES`/`TRACKING_MODES` déjà importés (ligne 8).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add frontend/services/dto/work-hour.ts frontend/composables/useHoursPage.ts
+git commit -m "[#SIRH] Vue jour: saisie/présence et libellé résolus à la date affichée"
+```
+
+---
+
+### Task 3: Documentation
+
+**Files:**
+- Modify: `doc/functional-rules.md`
+- Modify: `frontend/data/documentation-content.ts`
+- Modify: `CLAUDE.md`
+
+- [ ] **Step 1: Doc fonctionnelle**
+
+Il n'existe pas de doc dédiée « Heures » dans `doc/` ; ajouter le paragraphe suivant dans `doc/functional-rules.md` (section traitant des écrans Heures / du contrat, ou en fin de fichier sous un titre `## Vue Jour — contrat à la date affichée`) :
+
+> **Vue Jour (Heures) — contrat à la date affichée** : le mode de suivi (saisie d'heures vs cases de présence), le libellé de contrat et la logique de sauvegarde sont résolus selon la période de contrat valable à la date filtrée (champs `trackingMode`/`weeklyHours`/`contractType`/`contractName` portés par `WorkHourDayContext`), et non selon le contrat courant de l'employé. Un salarié passé 39h/35h → Forfait conserve donc la saisie d'heures sur ses dates antérieures à la bascule, et bascule en cases de présence à partir de la date de passage en forfait.
+
+- [ ] **Step 2: Doc in-app**
+
+Dans `frontend/data/documentation-content.ts`, repérer la section/article de l'écran « Heures » (`grep -n "Heures" frontend/data/documentation-content.ts`) et ajouter un bloc texte :
+
+> Sur la vue Jour, l'affichage (saisie d'heures ou présence) et le libellé de contrat correspondent au contrat de l'employé à la date consultée. Si un salarié a changé de type de contrat (ex. passage en forfait), les jours antérieurs restent affichés selon l'ancien contrat.
+
+- [ ] **Step 3: CLAUDE.md**
+
+Dans `CLAUDE.md`, section « Écrans Heures / Heures Conducteurs (vue jour) », compléter la puce existante sur `contractNature` par une phrase :
+
+> Idem pour le **mode de suivi 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). Le composable lit `resolveDayContract()` (`useHoursPage.ts`), ce qui pilote aussi `handleSave` (heures vs présence par date).
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add doc/ frontend/data/documentation-content.ts CLAUDE.md
+git commit -m "docs: vue jour contrat à la date affichée (doc + in-app + CLAUDE.md)"
+```
+
+---
+
+## Vérification finale (manuelle, par l'utilisateur)
+
+- Sur la fiche d'un salarié passé 39h/35h → Forfait, écran Heures vue Jour :
+  - naviguer une date **avant** la bascule → champs de saisie d'heures, libellé `39h`/`35h` ;
+  - naviguer une date **après** la bascule → cases de présence, libellé `Forfait` ;
+  - éditer puis enregistrer une date avant la bascule → les heures sont conservées (pas de flags présence).
@@ -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. ✓
@@ -0,0 +1,88 @@
+# Vue Jour (Heures) — résolution du contrat à la date affichée
+
+Date : 2026-06-01
+
+## Problème
+
+Sur l'écran **Heures — vue Jour** (`HoursDayView`), l'affichage saisie d'heures (TIME)
+vs cases de présence (PRESENCE), ainsi que le libellé de contrat entre parenthèses,
+sont résolus à partir de `employee.contract` — c'est-à-dire le **contrat courant**
+de l'employé (résolu à aujourd'hui), pas le contrat valable à la date affichée.
+
+Conséquence pour un salarié passé d'un contrat 39h/35h (TIME) à un Forfait (PRESENCE) :
+- toutes les dates **passées** s'affichent en cases de présence alors qu'elles
+  relevaient d'un contrat en heures ;
+- pire, `handleSave` (`useHoursPage.ts:1073`) se base sur le même test : éditer
+  une date passée écrit des **flags de présence** au lieu des heures et écrase la saisie.
+
+La **vue Semaine** est déjà correcte : elle résout le `trackingMode` par date côté
+backend via `WeeklySummaryRow.trackingMode`. Le périmètre de ce correctif est donc
+la **vue Jour uniquement**.
+
+## Principe
+
+Le provider backend `WorkHourDayContextProvider::provide()` résout **déjà** le contrat
+à la date affichée (`EmployeeContractResolver::resolveForEmployeeAndDate`) et expose
+déjà `contractNature` par date sur chaque ligne. Il suffit :
+
+1. d'exposer sur la ligne du jour les champs de contrat manquants ;
+2. de faire lire ces champs au frontend (au lieu de `employee.contract`).
+
+L'ensemble de la ligne (toggle saisie/présence + libellé 39h/Forfait + logique 4h)
+devient ainsi cohérent avec le contrat valable à la date affichée.
+
+## Changements
+
+### Backend
+
+1. **`src/Dto/WorkHours/DayContextRow.php`** — ajouter 4 champs au constructeur et à
+   `toArray()` (+ mettre à jour le PHPDoc du retour de `toArray()`) :
+   - `trackingMode: ?string`
+   - `weeklyHours: ?int`
+   - `contractType: ?string`
+   - `contractName: ?string`
+
+2. **`src/State/WorkHourDayContextProvider.php`** — peupler ces champs depuis le
+   `$contract` déjà résolu (lignes 60-71) :
+   - `trackingMode` = `$contract?->getTrackingMode()`
+   - `weeklyHours` = `$contract?->getWeeklyHours()`
+   - `contractType` = `$contract?->getType()->value`
+   - `contractName` = `$contract?->getName()`
+   - tous `null` si pas de contrat à la date (cohérent avec `hasContractAtDate`).
+
+### Frontend
+
+3. **`frontend/services/dto/work-hour.ts`** — refléter les 4 champs sur
+   `WorkHourDayContextRow`.
+
+4. **`frontend/composables/useHoursPage.ts`** — `isPresenceTracking`, `isTimeTracking`,
+   `contractLabel`, `is4hContract` lisent le `dayContextByEmployeeId.get(employeeId)`
+   (résolu par date), avec **fallback** sur `employee.contract` si aucune ligne du jour
+   n'existe. Cela corrige automatiquement `handleSave` (ligne 1073), qui s'appuie sur
+   `isPresenceTracking`.
+
+   Les signatures actuelles prennent un `Employee` ; on conserve la signature et on
+   utilise `employee.id` en interne pour récupérer la ligne du jour.
+
+## Hors périmètre
+
+- Vue Semaine (déjà par date).
+- Heures Conducteurs (toujours en mode TIME, pas de toggle).
+- Processor de sauvegarde backend : inchangé — le frontend enverra déjà la bonne
+  forme (heures vs présence) par date.
+
+## Tests / vérification
+
+- **Test backend** (`WorkHourDayContextProvider`) : pour un employé avec historique
+  39h → Forfait, la ligne renvoyée porte `trackingMode=TIME`/`weeklyHours=39`/
+  `contractType` non-forfait sur une date **avant** la bascule, et
+  `trackingMode=PRESENCE`/`contractType=FORFAIT` sur une date **après**.
+- **Vérification manuelle** : naviguer une date avant et après la bascule sur la fiche
+  du salarié → champs d'heures puis cases de présence, libellé cohérent.
+
+## Documentation (règle obligatoire)
+
+- `doc/` : section vue Jour — résolution du contrat (mode + libellé) à la date affichée.
+- `frontend/data/documentation-content.ts` : note utilisateur correspondante.
+- `CLAUDE.md` : préciser que la vue Jour résout `trackingMode`/libellé **à la date
+  filtrée** (au même titre que `contractNature` déjà documenté).
@@ -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`.
@@ -313,8 +313,16 @@ const isLastExerciseOfPhase = computed(() => {
  return props.selectedYear === endYear
 })

+// Retroactive payment is allowed on the immediately previous exercise (Option B):
+// the backend recomputes the next exercise's report so the carry stays correct.
+const isPreviousExercise = computed(() =>
+  props.selectedYear !== null
+  && props.currentYear !== null
+  && props.selectedYear === props.currentYear - 1
+)
+
 const isPayDisabled = computed(() =>
-  isHistoricalYear.value && !isLastExerciseOfPhase.value
+  isHistoricalYear.value && !isLastExerciseOfPhase.value && !isPreviousExercise.value
 )

 const handleYearChange = (event: Event) => {
@@ -350,11 +350,30 @@ export const useHoursPage = () => {
    updatedAt: null
  })

-  const isPresenceTracking = (employee: Employee) => employee.contract?.trackingMode === TRACKING_MODES.PRESENCE
+  // Résout le contrat à la date affichée (ligne du jour), avec repli sur le contrat courant.
+  const resolveDayContract = (employee: Employee) => {
+    const dayRow = dayContextByEmployeeId.value.get(employee.id)
+    if (dayRow?.hasContractAtDate) {
+      return {
+        trackingMode: dayRow.trackingMode ?? null,
+        weeklyHours: dayRow.weeklyHours ?? null,
+        type: dayRow.contractType ?? null,
+        name: dayRow.contractName ?? ''
+      }
+    }
+    return {
+      trackingMode: employee.contract?.trackingMode ?? null,
+      weeklyHours: employee.contract?.weeklyHours ?? null,
+      type: employee.contract?.type ?? null,
+      name: employee.contract?.name ?? ''
+    }
+  }
+
+  const isPresenceTracking = (employee: Employee) => resolveDayContract(employee).trackingMode === TRACKING_MODES.PRESENCE
  const isTimeTracking = (employee: Employee) => !isPresenceTracking(employee)
  const is4hContract = (employeeId: number) => {
    const employee = employees.value.find((e) => e.id === employeeId)
-    return employee?.contract?.weeklyHours === 4
+    return employee ? resolveDayContract(employee).weeklyHours === 4 : false
  }
  const isRowLocked = (employeeId: number) => {
    const row = rows.value[employeeId]
@@ -365,8 +384,8 @@ export const useHoursPage = () => {
  }

  const contractLabel = (employee: Employee) => {
-    const contract = employee.contract
-    if (!contract) return '-'
+    const contract = resolveDayContract(employee)
+    if (!contract.type && !contract.name) return '-'
    if (contract.type === CONTRACT_TYPES.INTERIM) {
      return contract.name
    }
@@ -29,6 +29,7 @@ export const documentationSections: DocSection[] = [
          { type: 'list', content: 'Boutons "Hier" / "Aujourd\'hui" / "Demain" pour naviguer rapidement\nSélecteur de date pour choisir une date spécifique\nFiltrage par site si vous avez accès à plusieurs sites' },
          { type: 'paragraph', content: 'Seuls les employés ayant un contrat actif à la date sélectionnée sont affichés.' },
          { type: 'note', content: 'Sous le nom de l\'employé, la nature du contrat (CDI / CDD / Intérim) affichée correspond à la période couvrant la date filtrée, et non à aujourd\'hui.' },
+          { type: 'paragraph', content: 'Sur la vue Jour, l\'affichage (saisie d\'heures ou cases de présence) et le libellé de contrat correspondent au contrat de l\'employé à la date consultée. Si un salarié a changé de type de contrat (par exemple un passage en forfait), les jours antérieurs à ce changement restent affichés selon l\'ancien contrat.' },
        ],
      },
      {
@@ -363,8 +364,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: '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: '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. 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.' },
        ],
      },
      {
@@ -373,7 +374,7 @@ export const documentationSections: DocSection[] = [
        requiredLevel: 'admin',
        blocks: [
          { type: 'paragraph', content: 'La vue semaine conducteurs affiche des colonnes spécifiques.' },
-          { type: 'list', content: 'Totaux jour / nuit / atelier par jour et par semaine\nPanier de nuit (PN) : affiché quand heures nuit > heures jour OU nuit ≥ 4h\nCompteurs hebdomadaires : petit déjeuner, déjeuner, dîner, nuitée\nRTT calculé sur jour + nuit + atelier (au lieu des créneaux classiques)' },
+          { type: 'list', content: 'Totaux jour / nuit / atelier par jour et par semaine\nPanier de nuit (PN) : ne s\'applique pas aux conducteurs (ils ont leurs propres primes repas/nuitée)\nCompteurs hebdomadaires : petit déjeuner, déjeuner, dîner, nuitée\nRTT calculé sur jour + nuit + atelier (au lieu des créneaux classiques)' },
        ],
      },
    ],
@@ -512,6 +513,7 @@ export const documentationSections: DocSection[] = [
        blocks: [
          { type: 'paragraph', content: 'Le RTT correspond aux heures supplémentaires accumulées, converties en temps de récupération. L\'exercice RTT va du 1er juin (N-1) au 31 mai (N).' },
          { type: 'paragraph', content: 'L\'onglet RTT sur la fiche employé affiche le détail hebdomadaire regroupé par mois, avec un compteur global en heures (1 jour = 7h = 420 minutes).' },
+          { type: 'note', content: 'Pour un contrat débutant en milieu de semaine, le calcul RTT proratise les seuils d\'heures supplémentaires aux jours réellement contractés : le seuil de départ du +25 % et le plafond séparant le +25 % du +50 % sont décalés ensemble (la bande +25 % garde sa largeur : 4h pour un 39h, 8h pour un 35h). Une semaine d\'embauche peut donc générer à la fois des heures à 25 % et à 50 %.' },
        ],
      },
      {
@@ -521,7 +523,9 @@ export const documentationSections: DocSection[] = [
        blocks: [
          { type: 'list', content: 'Report N-1 : solde de l\'exercice précédent\nAcquis : cumul des heures supplémentaires de l\'exercice en cours\nDisponible : report + acquis − payé\nPayé : RTT convertis en salaire (soustraits du disponible)' },
          { 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.' },
        ],
      },
      {
@@ -531,6 +535,8 @@ export const documentationSections: DocSection[] = [
        blocks: [
          { type: 'paragraph', content: 'L\'administrateur RH peut enregistrer un paiement RTT depuis l\'onglet RTT de la fiche employé.' },
          { type: 'list', content: 'Saisie : mois, nombre de minutes, taux (25% ou 50%)\nPlusieurs paiements possibles par mois\nLes heures payées sont soustraites du solde disponible' },
+          { type: 'paragraph', content: 'Le paiement est possible sur l\'exercice courant et sur l\'exercice immédiatement précédent (paiement rétroactif, ex. des RTT de mai réglés après la bascule du 1er juin).' },
+          { type: 'note', content: 'Un paiement saisi sur l\'exercice précédent recalcule automatiquement le « Report N-1 » de l\'exercice courant : aucun double comptage. Si ce report a déjà été verrouillé (validé), le paiement rétroactif est refusé — déverrouillez-le d\'abord.' },
        ],
      },
      {
@@ -619,7 +625,9 @@ export const documentationSections: DocSection[] = [
        requiredLevel: 'admin',
        blocks: [
          { type: 'paragraph', content: 'Génère un PDF A4 paysage avec le détail mensuel pour la paie.' },
-          { 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, 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: '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.' },
        ],
      },
      {
@@ -637,7 +645,7 @@ export const documentationSections: DocSection[] = [
        requiredLevel: 'admin',
        blocks: [
          { type: 'paragraph', content: 'Génère un PDF par employé avec le détail jour par jour de ses heures sur une année.' },
-          { type: 'list', content: 'Accessible depuis la fiche employé (bouton imprimante)\nChoix de l\'année civile (janvier à décembre)\nColonnes adaptées au mode de suivi (TIME, PRESENCE, conducteur)\nSections séparées en cas de changement de contrat en cours d\'année\nLes jours fériés apparaissent toujours (ligne bleue) avec la mention « Férié : {nom} » dans la colonne Absence ; le total reprend les heures contractuelles créditées (hors Forfait)' },
+          { type: 'list', content: 'Accessible depuis la fiche employé (bouton imprimante)\nChoix de l\'année civile (janvier à décembre)\nColonnes adaptées au mode de suivi (TIME, PRESENCE, conducteur)\nSections séparées en cas de changement de contrat en cours d\'année\nTous les jours sous contrat sont affichés, même vides ou non saisis (jusqu\'à la date du jour) ; seuls les jours hors contrat (avant embauche, après départ) sont omis\nLes samedis et dimanches sont grisés (gris foncé), les jours fériés en bleu avec « Férié : {nom} »' },
        ],
      },
    ],
@@ -10,6 +10,7 @@ export type EmployeeRttWeekSummary = {
  bonus50Minutes: number
  totalMinutes: number
  cumulativeBalanceMinutes: number
+  isFlatRecovery: boolean
 }

 export type RttMonthPayment = {
@@ -115,6 +115,10 @@ export type WorkHourDayContextRow = {
  formationLabel?: string | null
  virtualHolidayMinutes?: number
  contractNature?: 'CDI' | 'CDD' | 'INTERIM' | null
+  trackingMode?: TrackingMode | null
+  weeklyHours?: number | null
+  contractType?: ContractType | null
+  contractName?: string | null
 }

 export type WorkHourDayContext = {
@@ -25,13 +25,23 @@ final class WorkHourDayContext
    /**
     * @var list<array{
     *     employeeId:int,
+     *     hasContractAtDate:bool,
     *     absenceLabel:?string,
     *     absenceColor:?string,
     *     absenceHalf:?string,
     *     absentMorning:bool,
     *     absentAfternoon:bool,
     *     creditedMinutes:int,
-     *     creditedPresenceUnits:float
+     *     creditedPresenceUnits:float,
+     *     isDriverContract:bool,
+     *     hasFormation:bool,
+     *     formationLabel:?string,
+     *     virtualHolidayMinutes:int,
+     *     contractNature:?string,
+     *     trackingMode:?string,
+     *     weeklyHours:?int,
+     *     contractType:?string,
+     *     contractName:?string
     * }>
     */
    public array $rows = [];
@@ -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,
            );
        }

@@ -10,7 +10,7 @@ use App\Enum\ContractType;
 use App\Enum\TrackingMode;
 use App\Repository\EmployeeRepository;
 use App\Repository\EmployeeRttBalanceRepository;
-use App\Service\Rtt\RttRecoveryComputationService;
+use App\Service\Rtt\RttClosingBalanceService;
 use DateTimeImmutable;
 use Doctrine\ORM\EntityManagerInterface;
 use Psr\Log\LoggerInterface;
@@ -32,7 +32,7 @@ final class RttRolloverCommand extends Command
    public function __construct(
        private readonly EmployeeRepository $employeeRepository,
        private readonly EmployeeRttBalanceRepository $rttBalanceRepository,
-        private readonly RttRecoveryComputationService $rttRecoveryService,
+        private readonly RttClosingBalanceService $rttClosingService,
        private readonly EntityManagerInterface $entityManager,
        #[Autowire(service: 'monolog.logger.cron')]
        private readonly LoggerInterface $logger,
@@ -48,15 +48,22 @@ final class RttRolloverCommand extends Command
            InputOption::VALUE_NONE,
            'Run rollover regardless of business date (manual recovery mode).'
        );
+        $this->addOption(
+            'recompute',
+            null,
+            InputOption::VALUE_NONE,
+            'Recompute and overwrite existing (non-locked) balances instead of skipping them.'
+        );
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
-        $io    = new SymfonyStyle($input, $output);
-        $today = new DateTimeImmutable('today');
-        $force = (bool) $input->getOption('force');
+        $io        = new SymfonyStyle($input, $output);
+        $today     = new DateTimeImmutable('today');
+        $force     = (bool) $input->getOption('force');
+        $recompute = (bool) $input->getOption('recompute');

-        $this->logger->info('app:rtt:rollover started.', ['date' => $today->format('Y-m-d'), 'force' => $force]);
+        $this->logger->info('app:rtt:rollover started.', ['date' => $today->format('Y-m-d'), 'force' => $force, 'recompute' => $recompute]);

        if (!$force && '06-01' !== $today->format('m-d')) {
            $message = 'No RTT rollover today: business date is not 01/06.';
@@ -68,6 +75,7 @@ final class RttRolloverCommand extends Command

        $targetYear = $this->resolveTargetYear($today);
        $created    = 0;
+        $updated    = 0;
        $skipped    = 0;

        foreach ($this->employeeRepository->findAll() as $employee) {
@@ -83,36 +91,53 @@ final class RttRolloverCommand extends Command
            }

            $existing = $this->rttBalanceRepository->findOneByEmployeeAndYear($employee, $targetYear);
-            if (null !== $existing) {
+            if (null !== $existing && !$recompute) {
                $this->logger->info('Employee skipped: balance already exists.', ['employeeId' => $employee->getId(), 'year' => $targetYear]);
                ++$skipped;

                continue;
            }
+            if (null !== $existing && $existing->isLocked()) {
+                // Never overwrite a balance an RH user has validated/frozen.
+                $this->logger->info('Employee skipped: balance is locked.', ['employeeId' => $employee->getId(), 'year' => $targetYear]);
+                ++$skipped;
+
+                continue;
+            }

            try {
                $previousYear = $targetYear - 1;
-                $carry        = $this->rttRecoveryService->computeTotalRecoveryForExercise($employee, $previousYear);
+                // Closing of the previous exercise = opening report + earned − paid.
+                $closing = $this->rttClosingService->computeClosingBalance($employee, $previousYear);
            } catch (Throwable $e) {
-                $this->logger->error('Error computing carry for employee.', ['employeeId' => $employee->getId(), 'error' => $e->getMessage()]);
+                $this->logger->error('Error computing closing balance for employee.', ['employeeId' => $employee->getId(), 'error' => $e->getMessage()]);
                ++$skipped;

                continue;
            }

-            $balance = new EmployeeRttBalance()
+            $balance = $existing ?? new EmployeeRttBalance()
                ->setEmployee($employee)
                ->setYear($targetYear)
-                ->setOpeningBase25Minutes($carry->base25Minutes)
-                ->setOpeningBonus25Minutes($carry->bonus25Minutes)
-                ->setOpeningBase50Minutes($carry->base50Minutes)
-                ->setOpeningBonus50Minutes($carry->bonus50Minutes)
                ->setIsLocked(false)
            ;

-            $this->entityManager->persist($balance);
-            $this->logger->info('Balance created.', ['employeeId' => $employee->getId(), 'year' => $targetYear, 'carryMinutes' => $carry->totalMinutes]);
-            ++$created;
+            $balance
+                ->setOpeningBase25Minutes($closing->base25Minutes)
+                ->setOpeningBonus25Minutes($closing->bonus25Minutes)
+                ->setOpeningBase50Minutes($closing->base50Minutes)
+                ->setOpeningBonus50Minutes($closing->bonus50Minutes)
+            ;
+
+            if (null === $existing) {
+                $this->entityManager->persist($balance);
+                $this->logger->info('Balance created.', ['employeeId' => $employee->getId(), 'year' => $targetYear, 'carryMinutes' => $closing->totalMinutes]);
+                ++$created;
+            } else {
+                $balance->touch();
+                $this->logger->info('Balance recomputed.', ['employeeId' => $employee->getId(), 'year' => $targetYear, 'carryMinutes' => $closing->totalMinutes]);
+                ++$updated;
+            }
        }

        try {
@@ -124,7 +149,7 @@ final class RttRolloverCommand extends Command
            return Command::FAILURE;
        }

-        $message = sprintf('RTT rollover done: %d created, %d skipped.', $created, $skipped);
+        $message = sprintf('RTT rollover done: %d created, %d recomputed, %d skipped.', $created, $updated, $skipped);
        $this->logger->info($message);
        $io->success($message);

@@ -18,5 +18,6 @@ final class EmployeeRttWeekSummary
        public int $bonus50Minutes = 0,
        public int $totalMinutes = 0,
        public int $cumulativeBalanceMinutes = 0,
+        public bool $isFlatRecovery = false,
    ) {}
 }
@@ -17,5 +17,6 @@ final class WeekRecoveryDetail
        public int $bonus50Minutes = 0,
        public int $totalMinutes = 0,
        public array $dailyMinutes = [],
+        public bool $isFlatRecovery = false,
    ) {}
 }
@@ -21,6 +21,10 @@ final class DayContextRow
        public ?string $formationLabel = null,
        public int $virtualHolidayMinutes = 0,
        public ?string $contractNature = null,
+        public ?string $trackingMode = null,
+        public ?int $weeklyHours = null,
+        public ?string $contractType = null,
+        public ?string $contractName = null,
    ) {}

    public function setFormation(string $label): void
@@ -79,7 +83,11 @@ final class DayContextRow
     *     hasFormation:bool,
     *     formationLabel:?string,
     *     virtualHolidayMinutes:int,
-     *     contractNature:?string
+     *     contractNature:?string,
+     *     trackingMode:?string,
+     *     weeklyHours:?int,
+     *     contractType:?string,
+     *     contractName:?string
     * }
     */
    public function toArray(): array
@@ -99,6 +107,10 @@ final class DayContextRow
            'formationLabel'        => $this->formationLabel,
            'virtualHolidayMinutes' => $this->virtualHolidayMinutes,
            'contractNature'        => $this->contractNature,
+            'trackingMode'          => $this->trackingMode,
+            'weeklyHours'           => $this->weeklyHours,
+            'contractType'          => $this->contractType,
+            'contractName'          => $this->contractName,
        ];
    }

@@ -0,0 +1,164 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service\Rtt;
+
+use App\Dto\Rtt\WeekRecoveryDetail;
+use App\Entity\Employee;
+use App\Repository\EmployeeRttBalanceRepository;
+use App\Repository\EmployeeRttPaymentRepository;
+use App\State\EmployeeRttSummaryProvider;
+
+/**
+ * Computes the closing RTT balance of an exercise — the amount that must become the
+ * opening report of the next exercise.
+ *
+ * Closing = opening report (N) + net earned (N) − RTT paid (N).
+ *
+ * This mirrors the "disponible" exposed by {@see EmployeeRttSummaryProvider}
+ * (carry + currentYearRecovery − totalPaid), so the report carried to N+1 always equals
+ * the balance the RTT tab displayed for N. The previous rollover only took the earned
+ * minutes and dropped both the incoming report and the payments.
+ */
+final readonly class RttClosingBalanceService
+{
+    public function __construct(
+        private RttRecoveryComputationService $recoveryService,
+        private EmployeeRttBalanceRepository $balanceRepository,
+        private EmployeeRttPaymentRepository $paymentRepository,
+    ) {}
+
+    public function computeClosingBalance(Employee $employee, int $exerciseYear): WeekRecoveryDetail
+    {
+        [$from, $to] = $this->recoveryService->resolveExerciseBounds($exerciseYear);
+        $weeks       = $this->recoveryService->buildWeeksForExercise($from, $to);
+        $weekRanges  = array_map(
+            static fn (array $week): array => [
+                'weekNumber' => (int) $week['weekNumber'],
+                'start'      => $week['start'],
+                'end'        => $week['end'],
+            ],
+            $weeks
+        );
+
+        // The exercise is fully closed at rollover time, so count every week up to its end.
+        $byWeek = $this->recoveryService->computeRecoveryByWeek($employee, $weekRanges, $from, $to, $to);
+
+        $orderedDetails = [];
+        foreach ($weekRanges as $week) {
+            $key              = $week['start']->format('Y-m-d');
+            $orderedDetails[] = $byWeek[$key] ?? new WeekRecoveryDetail();
+        }
+
+        $opening  = $this->resolveOpeningReport($employee, $exerciseYear);
+        $payments = $this->sumPayments($employee, $exerciseYear);
+
+        return $this->fold($opening, $orderedDetails, $payments);
+    }
+
+    /**
+     * Pure accumulation of the closing balance per bucket.
+     *
+     * Guarantees `sum(buckets) === opening.total + Σ week.total − payments.total`,
+     * i.e. the carried report matches the displayed disponible regardless of how the
+     * deficit cascade or the custom-recovery remainder is distributed across buckets.
+     *
+     * @param list<WeekRecoveryDetail> $weeks chronological order
+     */
+    public function fold(WeekRecoveryDetail $opening, array $weeks, WeekRecoveryDetail $payments): WeekRecoveryDetail
+    {
+        $b25  = $opening->base25Minutes;
+        $bo25 = $opening->bonus25Minutes;
+        $b50  = $opening->base50Minutes;
+        $bo50 = $opening->bonus50Minutes;
+
+        foreach ($weeks as $week) {
+            if ($week->totalMinutes >= 0) {
+                $b25 += $week->base25Minutes;
+                $bo25 += $week->bonus25Minutes;
+                $b50 += $week->base50Minutes;
+                $bo50 += $week->bonus50Minutes;
+
+                // Recovery not attributed to any 25/50 bucket (CUSTOM 1h=1h, rounding):
+                // park it in the plain 25%-base bucket so the bucket sum keeps the total.
+                $remainder = $week->totalMinutes
+                    - ($week->base25Minutes + $week->bonus25Minutes + $week->base50Minutes + $week->bonus50Minutes);
+                $b25 += $remainder;
+
+                continue;
+            }
+
+            // Deficit week: drain the 50%-tier before the 25%-tier (mirrors
+            // EmployeeRttSummaryProvider's cumulative cascade).
+            $deficit          = -$week->totalMinutes;
+            [$b50, $deficit]  = $this->consume($b50, $deficit);
+            [$bo50, $deficit] = $this->consume($bo50, $deficit);
+            [$b25, $deficit]  = $this->consume($b25, $deficit);
+            $bo25 -= $deficit; // leftover may push the balance negative, as on screen
+        }
+
+        $b25 -= $payments->base25Minutes;
+        $bo25 -= $payments->bonus25Minutes;
+        $b50 -= $payments->base50Minutes;
+        $bo50 -= $payments->bonus50Minutes;
+
+        return new WeekRecoveryDetail(
+            base25Minutes: $b25,
+            bonus25Minutes: $bo25,
+            base50Minutes: $b50,
+            bonus50Minutes: $bo50,
+            totalMinutes: $b25 + $bo25 + $b50 + $bo50,
+        );
+    }
+
+    /**
+     * The opening report of $year: the stored balance row when present, else the
+     * dynamic fallback (earned in $year-1). Same resolution as
+     * EmployeeRttSummaryProvider::resolveCarry.
+     */
+    private function resolveOpeningReport(Employee $employee, int $year): WeekRecoveryDetail
+    {
+        $balance = $this->balanceRepository->findOneByEmployeeAndYear($employee, $year);
+        if (null !== $balance) {
+            return new WeekRecoveryDetail(
+                base25Minutes: $balance->getOpeningBase25Minutes(),
+                bonus25Minutes: $balance->getOpeningBonus25Minutes(),
+                base50Minutes: $balance->getOpeningBase50Minutes(),
+                bonus50Minutes: $balance->getOpeningBonus50Minutes(),
+                totalMinutes: $balance->getTotalOpeningMinutes(),
+            );
+        }
+
+        return $this->recoveryService->computeTotalRecoveryForExercise($employee, $year - 1);
+    }
+
+    private function sumPayments(Employee $employee, int $year): WeekRecoveryDetail
+    {
+        $b25 = $bo25 = $b50 = $bo50 = 0;
+        foreach ($this->paymentRepository->findByEmployeeAndYear($employee, $year) as $payment) {
+            $b25 += $payment->getBase25Minutes();
+            $bo25 += $payment->getBonus25Minutes();
+            $b50 += $payment->getBase50Minutes();
+            $bo50 += $payment->getBonus50Minutes();
+        }
+
+        return new WeekRecoveryDetail(
+            base25Minutes: $b25,
+            bonus25Minutes: $bo25,
+            base50Minutes: $b50,
+            bonus50Minutes: $bo50,
+            totalMinutes: $b25 + $bo25 + $b50 + $bo50,
+        );
+    }
+
+    /**
+     * @return array{int, int} [remaining bucket, remaining deficit]
+     */
+    private function consume(int $bucket, int $deficit): array
+    {
+        $take = min($deficit, max(0, $bucket));
+
+        return [$bucket - $take, $deficit - $take];
+    }
+}
@@ -235,38 +235,80 @@ 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 %.
+            $overtime50StartMinutes     = $overtime25StartMinutes + $this->resolveOvertime25BandWidthMinutes($weekAnchorContract);
            $weeklyOvertimeTotalMinutes = $isWeekPresenceTracking
                ? 0
                : $weeklyTotalMinutes - $overtimeReferenceMinutes;

-            $base25  = ($isWeekPresenceTracking || $disableOvertimeBonuses || $isCustomContract) ? 0 : max(0, min($weeklyTotalMinutes, 43 * 60) - $overtime25StartMinutes);
-            $bonus25 = ($isWeekPresenceTracking || $disableOvertimeBonuses || $isCustomContract) ? 0 : (int) round($base25 * 0.25);
-            $base50  = ($isWeekPresenceTracking || $disableOvertimeBonuses || $isCustomContract) ? 0 : max(0, $weeklyTotalMinutes - 43 * 60);
-            $bonus50 = ($isWeekPresenceTracking || $disableOvertimeBonuses || $isCustomContract) ? 0 : (int) round($base50 * 0.5);
+            [$rawBase25, $rawBase50] = $this->computeOvertimeBaseMinutes($weeklyTotalMinutes, $overtime25StartMinutes, $overtime50StartMinutes);

-            if ($isWeekPresenceTracking || $disableOvertimeBonuses) {
-                $totalMinutes = 0;
-            } elseif ($isCustomContract) {
-                $totalMinutes = max(0, $weeklyOvertimeTotalMinutes);
-            } else {
-                $totalMinutes = $weeklyOvertimeTotalMinutes + $bonus25 + $bonus50;
-            }
-
-            $results[$weekKey] = new WeekRecoveryDetail(
-                overtimeMinutes: $weeklyOvertimeTotalMinutes,
-                base25Minutes: $base25,
-                bonus25Minutes: $bonus25,
-                base50Minutes: $base50,
-                bonus50Minutes: $bonus50,
-                totalMinutes: $totalMinutes,
-                dailyMinutes: $dailyWorkedMinutes,
+            $results[$weekKey] = $this->buildWeekRecoveryDetail(
+                $isWeekPresenceTracking,
+                $disableOvertimeBonuses,
+                $isCustomContract,
+                $weeklyOvertimeTotalMinutes,
+                $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;
@@ -452,18 +494,31 @@ final readonly class RttRecoveryComputationService
        return $total;
    }

-    private function computeOvertime25BonusMinutes(int $weeklyTotalMinutes, int $startMinutes): int
+    /**
+     * Largeur (en minutes) de la tranche +25 % pour le contrat d'ancrage de la semaine :
+     * 4h pour un 39h (39→43), 8h pour un 35h (35→43). Ajoutée au seuil de départ proraté
+     * pour obtenir le plafond 25 %/50 %.
+     */
+    private function resolveOvertime25BandWidthMinutes(?Contract $contract): int
    {
-        $trancheMinutes = max(0, min($weeklyTotalMinutes, 43 * 60) - $startMinutes);
+        $hours      = $contract?->getWeeklyHours();
+        $startHours = (null !== $hours && $hours >= 39) ? 39 : 35;

-        return (int) round($trancheMinutes * 0.25);
+        return (43 - $startHours) * 60;
    }

-    private function computeOvertime50BonusMinutes(int $weeklyTotalMinutes): int
+    /**
+     * Répartit les heures supplémentaires hebdomadaires entre les bases 25 % et 50 %.
+     * La tranche 25 % court du seuil de départ au plafond ; au-delà du plafond, c'est du 50 %.
+     *
+     * @return array{int, int} [base25Minutes, base50Minutes]
+     */
+    private function computeOvertimeBaseMinutes(int $weeklyTotalMinutes, int $overtime25StartMinutes, int $overtime50StartMinutes): array
    {
-        $trancheMinutes = max(0, $weeklyTotalMinutes - (43 * 60));
+        $base25 = max(0, min($weeklyTotalMinutes, $overtime50StartMinutes) - $overtime25StartMinutes);
+        $base50 = max(0, $weeklyTotalMinutes - $overtime50StartMinutes);

-        return (int) round($trancheMinutes * 0.5);
+        return [$base25, $base50];
    }

    private function hasDisabledOvertimeBonuses(?Contract $contract, ContractNature $contractNature): bool
@@ -264,10 +264,9 @@ class YearlyHoursExportBuilder
            $isoDay       = (int) new DateTimeImmutable($date)->format('N');
            $isWeekend    = $isoDay >= 6;

-            if (!$hasData && !$isWeekend && !$isHoliday) {
-                continue;
-            }
-
+            // Tous les jours contractés sont affichés, même vides ou non saisis (lignes
+            // « manquantes » signalées par la RH). Seuls les jours hors contrat (avant
+            // embauche, après départ, suspension) sont omis.
            if (!$hasData && null === $contract) {
                continue;
            }
@@ -411,6 +411,35 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
        return null !== $balance ? $balance->getPaidLeaveDays() : 0.0;
    }

+    /**
+     * Budget N-1 = nombre de jours de congé pris imputés sur le stock de l'année précédente,
+     * pour l'exercice de l'année donnée. Reproduit exactement la dérivation de provide()
+     * (phase courante + recalcul avec les jours payés) afin que les consommateurs externes
+     * (ex. récap salaire) voient le même budget que la fiche employé. 0 si non supporté.
+     */
+    public function resolvePreviousYearTakenDays(Employee $employee, int $year): float
+    {
+        $phase = $this->resolveCurrentPhase($employee);
+        if (null === $phase) {
+            return 0.0;
+        }
+
+        $summary = $this->computeYearSummary($employee, $year, 0.0, null, $phase);
+        if (null === $summary) {
+            return 0.0;
+        }
+
+        $paidLeaveDays = $this->resolvePaidLeaveDays($employee, $summary['ruleCode'], $year);
+        if ($paidLeaveDays > 0.0) {
+            $summary = $this->computeYearSummary($employee, $year, $paidLeaveDays, null, $phase);
+            if (null === $summary) {
+                return 0.0;
+            }
+        }
+
+        return (float) $summary['previousYearTakenDays'];
+    }
+
    private function resolveEffectivePeriodStart(
        Employee $employee,
        DateTimeImmutable $from,
@@ -8,12 +8,15 @@ use ApiPlatform\Metadata\Operation;
 use ApiPlatform\State\ProcessorInterface;
 use App\ApiResource\EmployeeRttPaymentInput;
 use App\Entity\Employee;
+use App\Entity\EmployeeRttBalance;
 use App\Entity\EmployeeRttPayment;
 use App\Repository\EmployeeRepository;
+use App\Repository\EmployeeRttBalanceRepository;
 use App\Repository\EmployeeRttPaymentRepository;
 use App\Service\AuditLogger;
 use App\Service\Contracts\EmployeeContractPhaseResolver;
 use App\Service\Exercise\ExerciseYearResolver;
+use App\Service\Rtt\RttClosingBalanceService;
 use Doctrine\ORM\EntityManagerInterface;
 use Psr\Clock\ClockInterface;
 use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
@@ -24,11 +27,13 @@ final readonly class EmployeeRttPaymentProcessor implements ProcessorInterface
    public function __construct(
        private EmployeeRepository $employeeRepository,
        private EmployeeRttPaymentRepository $rttPaymentRepository,
+        private EmployeeRttBalanceRepository $rttBalanceRepository,
        private EntityManagerInterface $entityManager,
        private AuditLogger $auditLogger,
        private EmployeeContractPhaseResolver $phaseResolver,
        private ClockInterface $clock,
        private ExerciseYearResolver $exerciseYearResolver,
+        private RttClosingBalanceService $rttClosingService,
    ) {}

    public function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): EmployeeRttPaymentInput
@@ -51,10 +56,20 @@ final readonly class EmployeeRttPaymentProcessor implements ProcessorInterface
            throw new UnprocessableEntityHttpException('month must be between 1 and 12.');
        }

-        $year = $data->year ?? $this->resolveCurrentExerciseYear();
+        $year                = $data->year ?? $this->resolveCurrentExerciseYear();
+        $currentExerciseYear = $this->resolveCurrentExerciseYear();

        $this->assertYearAllowedForPayment($employee, $year);

+        // Option B — retroactive payment on the previous exercise: the next exercise's
+        // opening report (a frozen snapshot) must be recomputed so the carry stays correct.
+        // Refuse upfront if that report has been locked (validated) by RH.
+        $downstreamBalance = null;
+        if ($year === $currentExerciseYear - 1) {
+            $downstreamBalance = $this->rttBalanceRepository->findOneByEmployeeAndYear($employee, $currentExerciseYear);
+            $this->assertReportNotLocked($downstreamBalance);
+        }
+
        $payment = $this->rttPaymentRepository->findOneByEmployeeYearMonth($employee, $year, $data->month);

        if (null === $payment) {
@@ -81,7 +96,24 @@ final readonly class EmployeeRttPaymentProcessor implements ProcessorInterface
            ['new' => ['month' => $data->month, 'year' => $year, 'base25' => $data->base25Minutes, 'bonus25' => $data->bonus25Minutes, 'base50' => $data->base50Minutes, 'bonus50' => $data->bonus50Minutes]],
        );

-        $this->entityManager->flush();
+        // Persist the payment and, atomically, refresh the next exercise's opening report.
+        // The flush inside the transaction makes the new payment visible to the closing
+        // recomputation (same DB connection), so the carry reflects it.
+        $this->entityManager->wrapInTransaction(function () use ($employee, $year, $downstreamBalance): void {
+            $this->entityManager->flush();
+
+            if (null !== $downstreamBalance) {
+                $closing = $this->rttClosingService->computeClosingBalance($employee, $year);
+                $downstreamBalance
+                    ->setOpeningBase25Minutes($closing->base25Minutes)
+                    ->setOpeningBonus25Minutes($closing->bonus25Minutes)
+                    ->setOpeningBase50Minutes($closing->base50Minutes)
+                    ->setOpeningBonus50Minutes($closing->bonus50Minutes)
+                    ->touch()
+                ;
+                $this->entityManager->flush();
+            }
+        });

        $data->year = $year;

@@ -94,14 +126,15 @@ final readonly class EmployeeRttPaymentProcessor implements ProcessorInterface
    }

    /**
-     * Allow payment when the requested exercise is either the current one
-     * or the last exercise of a closed contract phase (the one containing
-     * the phase end date). Reject any other exercise (past or future).
+     * Allow payment when the requested exercise is the current one, the
+     * immediately previous one (retroactive payment — Option B), or the last
+     * exercise of a closed contract phase (the one containing the phase end
+     * date). Reject any other exercise (older past or future).
     */
    private function assertYearAllowedForPayment(Employee $employee, int $year): void
    {
        $currentExerciseYear = $this->resolveCurrentExerciseYear();
-        if ($year === $currentExerciseYear) {
+        if ($year === $currentExerciseYear || $year === $currentExerciseYear - 1) {
            return;
        }

@@ -116,7 +149,21 @@ final readonly class EmployeeRttPaymentProcessor implements ProcessorInterface
        }

        throw new UnprocessableEntityHttpException(
-            'RTT payment is only allowed on the current exercise or the last exercise of a closed contract phase.'
+            'RTT payment is only allowed on the current exercise, the previous one, or the last exercise of a closed contract phase.'
        );
    }
+
+    /**
+     * Refuse a retroactive payment when the next exercise's opening report has
+     * been locked (validated) by RH: recomputing it would either be impossible
+     * or silently desync the carry. A missing report (null) never blocks.
+     */
+    private function assertReportNotLocked(?EmployeeRttBalance $downstreamBalance): void
+    {
+        if (null !== $downstreamBalance && $downstreamBalance->isLocked()) {
+            throw new UnprocessableEntityHttpException(
+                'Impossible : le report RTT de l\'exercice suivant est verrouillé. Déverrouillez-le pour saisir un paiement rétroactif.'
+            );
+        }
+    }
 }
@@ -20,6 +20,7 @@ use App\Repository\WorkHourRepository;
 use App\Security\EmployeeScopeService;
 use App\Service\Contracts\EmployeeContractPhaseResolver;
 use App\Service\Exercise\ExerciseYearResolver;
+use App\Service\Rtt\RttClosingBalanceService;
 use App\Service\Rtt\RttRecoveryComputationService;
 use DateTimeImmutable;
 use Symfony\Bundle\SecurityBundle\Security;
@@ -43,6 +44,7 @@ final readonly class EmployeeRttSummaryProvider implements ProviderInterface
        private WorkHourRepository $workHourRepository,
        private EmployeeContractPhaseResolver $phaseResolver,
        private ExerciseYearResolver $exerciseYearResolver,
+        private RttClosingBalanceService $rttClosingService,
        string $rttStartDate = '',
    ) {
        $this->rttStartDate = '' !== $rttStartDate ? $rttStartDate : null;
@@ -140,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%)
-        $cumulative50 = $carry->base50Minutes + $carry->bonus50Minutes;
-        $cumulative25 = $carry->base25Minutes + $carry->bonus25Minutes;
-
-        foreach ($summary->weeks as $i => $week) {
-            if ($week->totalMinutes >= 0) {
-                $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,
-                );
-            }
-        }
+        // 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,
+        );

        $payments     = $this->rttPaymentRepository->findByEmployeeAndYear($employee, $year);
        $monthBuckets = [];
@@ -231,8 +210,12 @@ final readonly class EmployeeRttSummaryProvider implements ProviderInterface
            ];
        }

+        // No stored report row yet (before the 1st-June rollover materialises it):
+        // compute the previous exercise's full closing (opening + earned − paid) so the
+        // carry already reflects retroactive payments and the incoming report — matching
+        // what the rollover would persist. Falling back to earned-only would drop both.
        return [
-            $this->rttRecoveryService->computeTotalRecoveryForExercise($employee, $year - 1),
+            $this->rttClosingService->computeClosingBalance($employee, $year - 1),
            5,
        ];
    }
@@ -350,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.
@@ -387,6 +418,7 @@ final readonly class EmployeeRttSummaryProvider implements ProviderInterface
                    base50Minutes: $detail->base50Minutes,
                    bonus50Minutes: $detail->bonus50Minutes,
                    totalMinutes: $detail->totalMinutes,
+                    isFlatRecovery: $detail->isFlatRecovery,
                );

                continue;
@@ -427,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,
                );
            }
        }
@@ -19,6 +19,7 @@ use App\Repository\ObservationRepository;
 use App\Repository\WorkHourRepository;
 use App\Service\Contracts\EmployeeContractResolver;
 use App\Service\PublicHolidayServiceInterface;
+use App\Service\WorkHours\AbsenceSegmentsResolver;
 use DateInterval;
 use DateTimeImmutable;
 use Dompdf\Dompdf;
@@ -42,6 +43,8 @@ class SalaryRecapPrintProvider implements ProviderInterface
        private ObservationRepository $observationRepository,
        private EmployeeContractResolver $contractResolver,
        private PublicHolidayServiceInterface $publicHolidayService,
+        private EmployeeLeaveSummaryProvider $leaveSummaryProvider,
+        private AbsenceSegmentsResolver $absenceSegmentsResolver,
    ) {}

    public function provide(Operation $operation, array $uriVariables = [], array $context = []): Response
@@ -59,12 +62,25 @@ class SalaryRecapPrintProvider implements ProviderInterface
        $from = DateTimeImmutable::createFromFormat('Y-m-d', $month.'-01');
        $to   = $from->modify('last day of this month');

-        $employees = $this->employeeRepository->findForPrintBySiteIds([]);
+        // N'inclure que les employés ayant un contrat couvrant tout ou partie du mois.
+        // Sans ce filtre, un salarié dont le contrat est terminé (ex. parti en février)
+        // apparaît à tort sur le récap des mois suivants.
+        $employees = array_values(array_filter(
+            $this->employeeRepository->findForPrintBySiteIds([]),
+            fn (Employee $employee): bool => $this->hasContractInRange($employee, $from, $to)
+        ));
        $workHours = $this->workHourRepository->findByDateRangeAndEmployees($from, $to, $employees);
        $absences  = $this->absenceRepository->findForPrint($from, $to, $employees);

        $year        = (int) $from->format('Y');
        $monthNumber = (int) $from->format('n');
+
+        // 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));
+        $ytdAbsences  = $this->absenceRepository->findForPrint($yearStart, $to, $employees);
+        $ytdAbsenceMap = $this->buildAbsenceMap($ytdAbsences);
        $rttPayments = $this->rttPaymentRepository->findByYearAndMonth($year, $monthNumber);

        $bonuses      = $this->bonusRepository->findByMonth($from, $to);
@@ -83,7 +99,7 @@ class SalaryRecapPrintProvider implements ProviderInterface
        $mileageMap     = $this->buildMileageMap($mileages);
        $observationMap = $this->buildObservationMap($observations);

-        $siteGroups = $this->aggregateBySite($employees, $days, $contractMap, $driverMap, $workHourMap, $absenceMap, $rttPaymentMap, $bonusMap, $mileageMap, $observationMap, $holidayMap);
+        $siteGroups = $this->aggregateBySite($employees, $days, $contractMap, $driverMap, $workHourMap, $absenceMap, $rttPaymentMap, $bonusMap, $mileageMap, $observationMap, $holidayMap, $ytdAbsenceMap, $year, $from, $to);

        $options = new Options();
        $options->set('isRemoteEnabled', true);
@@ -110,6 +126,22 @@ class SalaryRecapPrintProvider implements ProviderInterface
        ]);
    }

+    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;
+    }
+
    /**
     * @return list<string>
     */
@@ -164,6 +196,9 @@ class SalaryRecapPrintProvider implements ProviderInterface
    /**
     * @return array<int, int>
     */
+    /**
+     * @return array<int, array{m25: int, m50: int}>
+     */
    private function buildRttPaymentMap(array $rttPayments): array
    {
        $map = [];
@@ -172,7 +207,9 @@ class SalaryRecapPrintProvider implements ProviderInterface
            if (!$employeeId) {
                continue;
            }
-            $map[$employeeId] = ($map[$employeeId] ?? 0) + $payment->getBase25Minutes() + $payment->getBase50Minutes();
+            $map[$employeeId] ??= ['m25' => 0, 'm50' => 0];
+            $map[$employeeId]['m25'] += $payment->getBase25Minutes();
+            $map[$employeeId]['m50'] += $payment->getBase50Minutes();
        }

        return $map;
@@ -264,6 +301,10 @@ class SalaryRecapPrintProvider implements ProviderInterface
        array $mileageMap,
        array $observationMap,
        array $holidayMap,
+        array $ytdAbsenceMap,
+        int $year,
+        DateTimeImmutable $monthFrom,
+        DateTimeImmutable $monthTo,
    ): array {
        $siteGroups = [];

@@ -281,11 +322,15 @@ class SalaryRecapPrintProvider implements ProviderInterface
                $driverMap[$employeeId] ?? [],
                $workHourMap[$employeeId] ?? [],
                $absenceMap[$employeeId] ?? [],
-                $rttPaymentMap[$employeeId] ?? 0,
+                $rttPaymentMap[$employeeId] ?? ['m25' => 0, 'm50' => 0],
                $bonusMap[$employeeId] ?? 0.0,
                $mileageMap[$employeeId] ?? 0.0,
                $observationMap[$employeeId] ?? '',
                $holidayMap,
+                $ytdAbsenceMap[$employeeId] ?? [],
+                $year,
+                $monthFrom,
+                $monthTo,
            );

            if (!isset($siteGroups[$siteId])) {
@@ -310,11 +355,15 @@ class SalaryRecapPrintProvider implements ProviderInterface
        array $driverByDate,
        array $workHoursByDate,
        array $absences,
-        int $rttPaidMinutes,
+        array $rttPaid,
        float $bonusAmount,
        float $mileageKm,
        string $observation,
        array $holidayMap,
+        array $ytdAbsences,
+        int $year,
+        DateTimeImmutable $monthFrom,
+        DateTimeImmutable $monthTo,
    ): array {
        $contractName        = null;
        $presenceDays        = 0.0;
@@ -356,9 +405,8 @@ class SalaryRecapPrintProvider implements ProviderInterface
                $dayMin      = $wh->getDayHoursMinutes() ?? 0;
                $nightMin    = $wh->getNightHoursMinutes() ?? 0;
                $workshopMin = $wh->getWorkshopHoursMinutes() ?? 0;
-                if (($nightMin > $dayMin && $nightMin > 0) || $nightMin >= 240) {
-                    ++$nightBasketCount;
-                }
+                // Le panier de nuit ne s'applique pas aux conducteurs (primes repas/nuitée
+                // dédiées). Aucun panier de nuit crédité ici.

                if ($wh->getHasBreakfast()) {
                    ++$driverBreakfast;
@@ -415,11 +463,26 @@ class SalaryRecapPrintProvider implements ProviderInterface
            }
        }

-        $conges  = $this->countAbsencesByCode($absences, ['C']);
+        // Forfait : un congé imputé sur le stock N-1 ne doit pas s'afficher dans le récap
+        // et doit compter comme jour de présence. On consomme le budget N-1 chronologiquement
+        // sur tous les congés de l'exercice (année civile) jusqu'à la fin du mois imprimé.
+        $n1Budget = $isForfait ? $this->leaveSummaryProvider->resolvePreviousYearTakenDays($employee, $year) : 0.0;
+        if ($isForfait && $n1Budget > 0.0) {
+            $ytdConges = array_values(array_filter(
+                $ytdAbsences,
+                static fn (Absence $a): bool => 'C' === $a->getType()?->getCode()
+            ));
+            $split = $this->splitForfaitCongesByN1($ytdConges, $n1Budget, $monthFrom, $monthTo);
+            $conges = ['count' => $split['count'], 'dates' => $split['dates']];
+            $presenceDays += $split['n1PresenceDays'];
+        } else {
+            $conges = $this->countAbsencesByCode($absences, ['C']);
+        }
        $maladie = $this->countAbsencesByCode($absences, ['M', 'AT']);

        $nightHours   = round($nightMinutesTotal / 60, 2);
-        $paidHours    = round($rttPaidMinutes / 60, 2);
+        $paid25Hours  = round(($rttPaid['m25'] ?? 0) / 60, 2);
+        $paid50Hours  = round(($rttPaid['m50'] ?? 0) / 60, 2);
        $sundayHours  = round($sundayMinutesTotal / 60, 2);
        $holidayHours = round($holidayMinutesTotal / 60, 2);

@@ -431,7 +494,8 @@ class SalaryRecapPrintProvider implements ProviderInterface
            'mileageKm'        => $mileageKm,
            'nightHours'       => $nightHours,
            'nightBasketCount' => $nightBasketCount,
-            'paidHours'        => $paidHours,
+            'paid25Hours'      => $paid25Hours,
+            'paid50Hours'      => $paid50Hours,
            'sundayHours'      => $sundayHours,
            'holidayHours'     => $holidayHours,
            'bonusAmount'      => $bonusAmount,
@@ -574,6 +638,73 @@ class SalaryRecapPrintProvider implements ProviderInterface
        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
+     * dans le mois imprimé alimentent le retour ; les congés des mois antérieurs ne servent
+     * qu'à consommer le budget N-1.
+     *
+     * @param list<Absence> $ytdConges congés depuis le début d'exercice jusqu'à la fin du mois
+     *
+     * @return array{count: float, dates: string, n1PresenceDays: float}
+     */
+    private function splitForfaitCongesByN1(
+        array $ytdConges,
+        float $n1Budget,
+        DateTimeImmutable $monthFrom,
+        DateTimeImmutable $monthTo
+    ): array {
+        usort($ytdConges, static fn (Absence $a, Absence $b): int => $a->getStartDate() <=> $b->getStartDate());
+
+        $remaining      = $n1Budget;
+        $count          = 0.0;
+        $n1PresenceDays = 0.0;
+        $dayKeys        = [];
+
+        foreach ($ytdConges as $absence) {
+            $start = DateTimeImmutable::createFromInterface($absence->getStartDate())->setTime(0, 0);
+            $end   = DateTimeImmutable::createFromInterface($absence->getEndDate())->setTime(0, 0);
+
+            for ($day = $start; $day <= $end; $day = $day->modify('+1 day')) {
+                if ((int) $day->format('N') >= 6) {
+                    continue; // week-ends ignorés
+                }
+                [$am, $pm] = $this->absenceSegmentsResolver->resolveForDate($absence, $day->format('Y-m-d'));
+                $amount    = ($am ? 0.5 : 0.0) + ($pm ? 0.5 : 0.0);
+                if ($amount <= 0.0) {
+                    continue;
+                }
+
+                $covered = 0.0;
+                if ($remaining > 0.0) {
+                    $covered    = min($remaining, $amount);
+                    $remaining -= $covered;
+                }
+                $displayed = $amount - $covered;
+
+                // Seul le mois imprimé alimente le récap ; les mois antérieurs ne font que consommer.
+                if ($day < $monthFrom || $day > $monthTo) {
+                    continue;
+                }
+
+                $n1PresenceDays += $covered;
+                if ($displayed > 0.0) {
+                    $count += $displayed;
+                    $dayKeys[] = $day->format('Y-m-d');
+                }
+            }
+        }
+
+        sort($dayKeys);
+        $dayKeys = array_unique($dayKeys);
+
+        return [
+            'count'          => $count,
+            'dates'          => implode(', ', $this->mergeDaysIntoPeriods($dayKeys)),
+            'n1PresenceDays' => $n1PresenceDays,
+        ];
+    }
+
    /**
     * @param list<Absence> $absences
     * @param list<string>  $codes
@@ -68,6 +68,10 @@ final readonly class WorkHourDayContextProvider implements ProviderInterface
                isDriverContract: $this->contractResolver->resolveIsDriverForEmployeeAndDate($employee, $workDate),
                virtualHolidayMinutes: $this->holidayVirtualHoursResolver->resolveVirtualCredit($contract, $workDate, false, $workDaysMinutes),
                contractNature: $contractNature,
+                trackingMode: $contract?->getTrackingMode(),
+                weeklyHours: $contract?->getWeeklyHours(),
+                contractType: $contract?->getType()->value,
+                contractName: $contract?->getName(),
            );
        }

@@ -286,7 +286,10 @@ final readonly class WorkHourWeeklySummaryProvider implements ProviderInterface
                    $present          = min(1.0, $morning + $afternoon + $creditedPresence);
                }

-                $hasNightBasket = ($nightMinutes > $dayMinutes && $nightMinutes > 0) || $nightMinutes >= 240;
+                // Le panier de nuit ne s'applique pas aux conducteurs (ils ont leurs propres
+                // primes repas/nuitée). Réservé aux non-conducteurs.
+                $hasNightBasket = !$isDateDriver
+                    && (($nightMinutes > $dayMinutes && $nightMinutes > 0) || $nightMinutes >= 240);
                if ($hasNightBasket) {
                    ++$weeklyNightBasketCount;
                }
@@ -81,7 +81,7 @@
        td.time { text-align: center; }
        td.presence { text-align: center; }
        td.total { text-align: center; font-weight: bold; }
-        tr.weekend td { background: #f3f3f3; color: #555; }
+        tr.weekend td { background: #c0c0c0; color: #333; }
        tr.weekend td.date { color: #333; }
        tr.holiday td { background: #e1f5fe; }

@@ -70,7 +70,7 @@
        td.time { text-align: center; }
        td.presence { text-align: center; }
        td.total { text-align: center; font-weight: bold; }
-        tr.weekend td { background: #f3f3f3; color: #555; }
+        tr.weekend td { background: #c0c0c0; color: #333; }
        tr.weekend td.date { color: #333; }
        tr.holiday td { background: #e1f5fe; }

@@ -117,7 +117,7 @@
            <th rowspan="2" style="width: 8mm;">Frais<br>Kms</th>
            <th rowspan="2" style="width: 8mm;">Heures<br>de<br>nuit</th>
            <th rowspan="2" style="width: 8mm;">Panier<br>de<br>nuit</th>
-            <th rowspan="2" style="width: 10mm;">Heures<br>payés</th>
+            <th colspan="2" style="width: 14mm;">Heures<br>payés</th>
            <th rowspan="2" style="width: 8mm;">Heures<br>férié</th>
            <th rowspan="2" style="width: 8mm;">Heures<br>dim.</th>
            <th rowspan="2" style="width: 8mm;">Prime</th>
@@ -127,6 +127,8 @@
            <th rowspan="2" style="width: 20mm;">Observations</th>
        </tr>
        <tr>
+            <th style="width: 7mm;">25%</th>
+            <th style="width: 7mm;">50%</th>
            <th style="width: 8mm;">Nbre</th>
            <th style="width: 22mm;">Date</th>
            <th style="width: 8mm;">Nbre</th>
@@ -141,7 +143,7 @@
    {% for siteId, group in siteGroups %}
        {% set siteColor = group.color ?? '#B3E5FC' %}
        <tr class="site-header">
-            <td style="background: {{ siteColor }}; text-align: left;" colspan="19">
+            <td style="background: {{ siteColor }}; text-align: left;" colspan="20">
                {{ group.name }}
            </td>
        </tr>
@@ -153,7 +155,8 @@
                <td class="num">{{ row.mileageKm > 0 ? row.mileageKm : '' }}</td>
                <td class="num">{{ row.nightHours > 0 ? row.nightHours : '' }}</td>
                <td class="num">{{ row.nightBasketCount > 0 ? row.nightBasketCount : '' }}</td>
-                <td class="num">{{ row.paidHours > 0 ? row.paidHours : '' }}</td>
+                <td class="num">{{ row.paid25Hours > 0 ? row.paid25Hours : '' }}</td>
+                <td class="num">{{ row.paid50Hours > 0 ? row.paid50Hours : '' }}</td>
                <td class="num">{{ row.holidayHours > 0 ? row.holidayHours : '' }}</td>
                <td class="num">{{ row.sundayHours > 0 ? row.sundayHours : '' }}</td>
                <td class="num">{{ row.bonusAmount > 0 ? row.bonusAmount ~ ' €' : '' }}</td>
@@ -169,7 +172,7 @@
            </tr>
        {% else %}
            <tr>
-                <td colspan="19">Aucun employé.</td>
+                <td colspan="20">Aucun employé.</td>
            </tr>
        {% endfor %}
    {% endfor %}
@@ -0,0 +1,132 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Service\Rtt;
+
+use App\Dto\Rtt\WeekRecoveryDetail;
+use App\Service\Rtt\RttClosingBalanceService;
+use PHPUnit\Framework\TestCase;
+use ReflectionClass;
+
+/**
+ * The service constructor takes final-class collaborators (repositories,
+ * RttRecoveryComputationService) that PHPUnit cannot double. The fold logic is
+ * pure (no $this dependency), so it is exercised via newInstanceWithoutConstructor.
+ *
+ * Invariant under test: the bucket sum of the closing balance ALWAYS equals
+ *   opening_report + net_earned - paid
+ * which is exactly the "disponible" the RTT tab shows for that exercise — so the
+ * report carried to the next exercise matches the displayed balance.
+ *
+ * @internal
+ */
+final class RttClosingBalanceServiceTest extends TestCase
+{
+    public function testOpeningReportIsCarriedForwardOnTopOfEarned(): void
+    {
+        // Regression for the reported bug: the previous exercise's opening report
+        // (e.g. go-live import or unused carry) must be included, not dropped.
+        $opening = new WeekRecoveryDetail(base25Minutes: 600, totalMinutes: 600); // 10h report
+        $week    = new WeekRecoveryDetail(base25Minutes: 240, bonus25Minutes: 60, totalMinutes: 300); // +5h earned
+
+        $closing = $this->service()->fold($opening, [$week], $this->payments());
+
+        // 10h report + 5h earned = 15h carried (NOT 5h).
+        self::assertSame(900, $closing->totalMinutes);
+        self::assertSame(600 + 240, $closing->base25Minutes);
+        self::assertSame(60, $closing->bonus25Minutes);
+    }
+
+    public function testPaymentsAreDeductedFromClosing(): void
+    {
+        $opening = new WeekRecoveryDetail(base25Minutes: 600, totalMinutes: 600);
+        $week    = new WeekRecoveryDetail(base25Minutes: 240, bonus25Minutes: 60, totalMinutes: 300);
+
+        // 7h paid out of the 25% base bucket.
+        $closing = $this->service()->fold($opening, [$week], $this->payments(b25: 420));
+
+        self::assertSame(900 - 420, $closing->totalMinutes);
+        self::assertSame(600 + 240 - 420, $closing->base25Minutes);
+    }
+
+    public function testDeficitWeekConsumesFiftyTierBeforeTwentyFiveTier(): void
+    {
+        // Opening: 60min in 50%-base, 120min in 25%-base.
+        $opening = new WeekRecoveryDetail(base25Minutes: 120, base50Minutes: 60, totalMinutes: 180);
+        // Deficit week of 100min (worked less than reference): buckets 0, negative total.
+        $deficit = new WeekRecoveryDetail(totalMinutes: -100);
+
+        $closing = $this->service()->fold($opening, [$deficit], $this->payments());
+
+        // 50%-base absorbs 60 first, the remaining 40 hits the 25%-base.
+        self::assertSame(0, $closing->base50Minutes);
+        self::assertSame(80, $closing->base25Minutes);
+        self::assertSame(80, $closing->totalMinutes);
+    }
+
+    public function testCustomRecoveryWithoutBucketsStillCountsInTotal(): void
+    {
+        // CUSTOM contract: positive total recovery (1h=1h) but every 25/50 bucket is 0.
+        $custom = new WeekRecoveryDetail(totalMinutes: 180); // 3h plain recovery
+
+        $closing = $this->service()->fold(new WeekRecoveryDetail(), [$custom], $this->payments());
+
+        // The 3h must survive into the carried report (sum of buckets == total).
+        self::assertSame(180, $closing->totalMinutes);
+        self::assertSame(
+            180,
+            $closing->base25Minutes + $closing->bonus25Minutes + $closing->base50Minutes + $closing->bonus50Minutes,
+        );
+    }
+
+    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);
+        $weeks   = [
+            new WeekRecoveryDetail(base25Minutes: 240, bonus25Minutes: 60, totalMinutes: 300),
+            new WeekRecoveryDetail(totalMinutes: -500),  // deeper deficit than tiers hold
+            new WeekRecoveryDetail(totalMinutes: 90),    // custom-style recovery
+        ];
+
+        $closing = $this->service()->fold($opening, $weeks, $this->payments(b25: 120, b50: 30));
+
+        $bucketSum = $closing->base25Minutes + $closing->bonus25Minutes + $closing->base50Minutes + $closing->bonus50Minutes;
+        self::assertSame($closing->totalMinutes, $bucketSum);
+        // opening 400 + earned (300 - 500 + 90 = -110) - paid 150 = 140
+        self::assertSame(140, $closing->totalMinutes);
+    }
+
+    private function service(): RttClosingBalanceService
+    {
+        return new ReflectionClass(RttClosingBalanceService::class)->newInstanceWithoutConstructor();
+    }
+
+    private function payments(int $b25 = 0, int $bo25 = 0, int $b50 = 0, int $bo50 = 0): WeekRecoveryDetail
+    {
+        return new WeekRecoveryDetail(
+            base25Minutes: $b25,
+            bonus25Minutes: $bo25,
+            base50Minutes: $b50,
+            bonus50Minutes: $bo50,
+            totalMinutes: $b25 + $bo25 + $b50 + $bo50,
+        );
+    }
+}
@@ -67,6 +67,100 @@ final class RttRecoveryComputationServiceTest extends TestCase
        self::assertSame('2026-03-16', $anchor);
    }

+    public function testResolveOvertime25BandWidthIs4hForH39(): void
+    {
+        $service  = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+        $contract = new Contract()->setWeeklyHours(39);
+
+        self::assertSame(4 * 60, $this->invokePrivate($service, 'resolveOvertime25BandWidthMinutes', $contract));
+    }
+
+    public function testResolveOvertime25BandWidthIs8hForH35(): void
+    {
+        $service  = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+        $contract = new Contract()->setWeeklyHours(35);
+
+        self::assertSame(8 * 60, $this->invokePrivate($service, 'resolveOvertime25BandWidthMinutes', $contract));
+    }
+
+    /**
+     * Dylan Chaboisson, semaine 12 : embauché le jeudi sur un contrat 39h.
+     * Total travaillé 22h (1320 min), départ 25 % proraté aux jours contractés = 15h (900 min),
+     * plafond 25 %/50 % = 15h + bande 4h = 19h (1140 min). Le plafond se décale avec
+     * l'embauche au lieu de rester bloqué à 43h, ouvrant la tranche 50 %.
+     */
+    public function testMidWeekHireSplitsOvertimeAcross25And50(): void
+    {
+        $service = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+
+        [$base25, $base50] = $this->invokePrivate($service, 'computeOvertimeBaseMinutes', 1320, 900, 1140);
+
+        self::assertSame(4 * 60, $base25);
+        self::assertSame(3 * 60, $base50);
+    }
+
+    /**
+     * Régression : semaine pleine 39h (départ 39h, plafond 43h), 46h travaillées →
+     * 4h à 25 % (39→43) et 3h à 50 % (43→46), comportement inchangé.
+     */
+    public function testFullWeekOvertimeSplitUnchanged(): void
+    {
+        $service = new ReflectionClass(RttRecoveryComputationService::class)->newInstanceWithoutConstructor();
+
+        [$base25, $base50] = $this->invokePrivate($service, 'computeOvertimeBaseMinutes', 2760, 2340, 2580);
+
+        self::assertSame(4 * 60, $base25);
+        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);
+    }
+
    private function invokePrivate(object $obj, string $method, mixed ...$args): mixed
    {
        return new ReflectionClass($obj::class)->getMethod($method)->invoke($obj, ...$args);
@@ -7,6 +7,7 @@ namespace App\Tests\State;
 use App\Entity\Contract;
 use App\Entity\Employee;
 use App\Entity\EmployeeContractPeriod;
+use App\Entity\EmployeeRttBalance;
 use App\Enum\ContractNature;
 use App\Enum\TrackingMode;
 use App\Service\Contracts\EmployeeContractPhaseResolver;
@@ -74,6 +75,54 @@ final class EmployeeRttPaymentProcessorTest extends TestCase
        $this->invokePrivate($processor, 'assertYearAllowedForPayment', $employee, 2030);
    }

+    public function testPaymentAllowedOnPreviousExercise(): void
+    {
+        // Today = 2026-05-19 → current exercise = 2026. Retroactive payment on the
+        // immediately previous exercise (2025) is now allowed (Option B).
+        $employee  = $this->buildEmployeeWithTransition('2020-06-01', '2026-04-30', '2026-05-01');
+        $processor = $this->buildProcessorWithClock(new DateTimeImmutable('2026-05-19'));
+
+        $this->invokePrivate($processor, 'assertYearAllowedForPayment', $employee, 2025);
+
+        // No exception → previous exercise accepted.
+        self::assertTrue(true);
+    }
+
+    public function testPaymentStillRejectedTwoExercisesBack(): void
+    {
+        // 2024 is two exercises before current (2026) and not a closed-phase end → still rejected.
+        $employee  = $this->buildEmployeeWithTransition('2020-06-01', '2026-04-30', '2026-05-01');
+        $processor = $this->buildProcessorWithClock(new DateTimeImmutable('2026-05-19'));
+
+        $this->expectException(UnprocessableEntityHttpException::class);
+        $this->invokePrivate($processor, 'assertYearAllowedForPayment', $employee, 2024);
+    }
+
+    public function testRetroactivePaymentRefusedWhenDownstreamReportLocked(): void
+    {
+        $processor = $this->buildProcessorWithClock(new DateTimeImmutable('2026-05-19'));
+
+        $locked = new EmployeeRttBalance();
+        $locked->setIsLocked(true);
+
+        $this->expectException(UnprocessableEntityHttpException::class);
+        $this->invokePrivate($processor, 'assertReportNotLocked', $locked);
+    }
+
+    public function testRetroactivePaymentAllowedWhenDownstreamReportMissingOrUnlocked(): void
+    {
+        $processor = $this->buildProcessorWithClock(new DateTimeImmutable('2026-05-19'));
+
+        $unlocked = new EmployeeRttBalance();
+        $unlocked->setIsLocked(false);
+
+        // Neither a missing (null) nor an unlocked downstream report must block payment.
+        $this->invokePrivate($processor, 'assertReportNotLocked', null);
+        $this->invokePrivate($processor, 'assertReportNotLocked', $unlocked);
+
+        self::assertTrue(true);
+    }
+
    // -----------------------------------------------------------------------
    // Test harness helpers.
    // -----------------------------------------------------------------------
@@ -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;
@@ -156,8 +157,11 @@ final class EmployeeRttSummaryProviderTest extends TestCase
        $provider = $this->buildProvider([]);
        $year     = $this->invokePrivate($provider, 'resolveYear', $currentPhase);

-        // Today is 2026-05-19 → current RTT exercise (Juin N-1 → Mai N) = 2026.
-        self::assertSame(2026, $year);
+        // No params → current RTT exercise (Juin N-1 → Mai N). Derive the expectation
+        // from today so the test is not pinned to a single calendar date.
+        $today    = new DateTimeImmutable('today');
+        $expected = (int) $today->format('n') >= 6 ? (int) $today->format('Y') + 1 : (int) $today->format('Y');
+        self::assertSame($expected, $year);
    }

    public function testInvalidYearFormatReturns422(): void
@@ -198,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.
    // -----------------------------------------------------------------------
@@ -244,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.
     *
@@ -253,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
    {
@@ -0,0 +1,145 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\State;
+
+use App\Entity\Absence;
+use App\Entity\Employee;
+use App\Entity\EmployeeContractPeriod;
+use App\Enum\HalfDay;
+use App\Service\WorkHours\AbsenceSegmentsResolver;
+use App\State\SalaryRecapPrintProvider;
+use DateTime;
+use DateTimeImmutable;
+use PHPUnit\Framework\TestCase;
+use ReflectionClass;
+use ReflectionProperty;
+
+/**
+ * Forfait N-1 split for the salary recap. The provider's collaborators are final classes
+ * PHPUnit cannot double, so the pure split helper is exercised via reflection, with a real
+ * AbsenceSegmentsResolver (no deps) injected into the uninitialized property.
+ *
+ * @internal
+ */
+final class SalaryRecapPrintProviderTest extends TestCase
+{
+    public function testN1BudgetPartiallyCoversADayAndOverflowsToN(): void
+    {
+        // Budget N-1 = 2.5 j ; 3 congés pleins (1 j) lun/mar/mer de janvier.
+        // 1.0 + 1.0 + 0.5 consommés en N-1 → reste 0.5 j affiché en congé (le mercredi).
+        $conges = [
+            $this->buildConge('2026-01-05'),
+            $this->buildConge('2026-01-06'),
+            $this->buildConge('2026-01-07'),
+        ];
+
+        $result = $this->split($conges, 2.5, '2026-01-01', '2026-01-31');
+
+        self::assertSame(2.5, $result['n1PresenceDays']);
+        self::assertSame(0.5, $result['count']);
+        self::assertSame('07/01', $result['dates']);
+    }
+
+    public function testN1BudgetConsumedInPriorMonthLeavesCurrentMonthFullyDisplayed(): void
+    {
+        // Budget 1 j, consommé par le congé de janvier. Récap de février → le congé de février
+        // est entièrement imputé N (affiché, 0 présence N-1 dans le mois).
+        $conges = [
+            $this->buildConge('2026-01-12'),
+            $this->buildConge('2026-02-09'),
+        ];
+
+        $result = $this->split($conges, 1.0, '2026-02-01', '2026-02-28');
+
+        self::assertSame(0.0, $result['n1PresenceDays']);
+        self::assertSame(1.0, $result['count']);
+        self::assertSame('09/02', $result['dates']);
+    }
+
+    public function testZeroBudgetDisplaysAllCongesInMonth(): void
+    {
+        $conges = [$this->buildConge('2026-03-03')];
+
+        $result = $this->split($conges, 0.0, '2026-03-01', '2026-03-31');
+
+        self::assertSame(0.0, $result['n1PresenceDays']);
+        self::assertSame(1.0, $result['count']);
+        self::assertSame('03/03', $result['dates']);
+    }
+
+    public function testTerminatedContractExcludedFromMonth(): void
+    {
+        // Marine : contrat terminé le 26/02 → absente du récap de juin.
+        $employee = $this->buildEmployeeWithPeriod('2025-02-10', '2026-02-26');
+
+        self::assertFalse($this->hasInRange($employee, '2026-06-01', '2026-06-30'));
+    }
+
+    public function testOngoingContractIncluded(): void
+    {
+        $employee = $this->buildEmployeeWithPeriod('2025-01-01', null);
+
+        self::assertTrue($this->hasInRange($employee, '2026-06-01', '2026-06-30'));
+    }
+
+    public function testContractEndingOnFromDayIncluded(): void
+    {
+        $employee = $this->buildEmployeeWithPeriod('2025-01-01', '2026-06-01');
+
+        self::assertTrue($this->hasInRange($employee, '2026-06-01', '2026-06-30'));
+    }
+
+    public function testNoPeriodsExcluded(): void
+    {
+        self::assertFalse($this->hasInRange(new Employee(), '2026-06-01', '2026-06-30'));
+    }
+
+    private function hasInRange(Employee $employee, string $from, string $to): bool
+    {
+        $provider = new ReflectionClass(SalaryRecapPrintProvider::class)->newInstanceWithoutConstructor();
+
+        return new ReflectionClass($provider::class)
+            ->getMethod('hasContractInRange')
+            ->invoke($provider, $employee, new DateTimeImmutable($from), new DateTimeImmutable($to));
+    }
+
+    private function buildEmployeeWithPeriod(string $start, ?string $end): Employee
+    {
+        $employee = new Employee();
+        $period   = new EmployeeContractPeriod();
+        $period->setEmployee($employee);
+        $period->setStartDate(new DateTimeImmutable($start));
+        $period->setEndDate(null !== $end ? new DateTimeImmutable($end) : null);
+        $employee->getContractPeriods()->add($period);
+
+        return $employee;
+    }
+
+    /**
+     * @param list<Absence> $conges
+     *
+     * @return array{count: float, dates: string, n1PresenceDays: float}
+     */
+    private function split(array $conges, float $budget, string $from, string $to): array
+    {
+        $provider = new ReflectionClass(SalaryRecapPrintProvider::class)->newInstanceWithoutConstructor();
+        new ReflectionProperty(SalaryRecapPrintProvider::class, 'absenceSegmentsResolver')
+            ->setValue($provider, new AbsenceSegmentsResolver());
+
+        return new ReflectionClass($provider::class)
+            ->getMethod('splitForfaitCongesByN1')
+            ->invoke($provider, $conges, $budget, new DateTimeImmutable($from), new DateTimeImmutable($to));
+    }
+
+    private function buildConge(string $date): Absence
+    {
+        return new Absence()
+            ->setStartDate(new DateTime($date))
+            ->setEndDate(new DateTime($date))
+            ->setStartHalf(HalfDay::AM)
+            ->setEndHalf(HalfDay::PM)
+        ;
+    }
+}
@@ -126,6 +126,60 @@ final class WorkHourDayContextProviderTest extends TestCase
        self::assertSame(210, $result->rows[0]['creditedMinutes']);
    }

+    public function testRowCarriesContractAtRequestedDate(): void
+    {
+        $user = new User();
+
+        $timeContract = new Contract()
+            ->setName('Contrat')
+            ->setTrackingMode(Contract::TRACKING_TIME)
+            ->setWeeklyHours(39)
+        ;
+        $forfaitContract = new Contract()
+            ->setName('Forfait')
+            ->setTrackingMode(Contract::TRACKING_PRESENCE)
+            ->setWeeklyHours(null)
+        ;
+        $employee = new Employee()
+            ->setFirstName('Jean')
+            ->setLastName('Test')
+            ->setContract($forfaitContract)
+        ;
+        $this->setEntityId($employee, 1);
+
+        // Resolver renvoie le contrat 39h avant 2026-03-01, le forfait à partir de cette date.
+        $resolver = $this->createStub(EmployeeContractResolver::class);
+        $resolver->method('resolveForEmployeeAndDate')->willReturnCallback(
+            static fn (Employee $e, \DateTimeImmutable $d): ?Contract =>
+                $d < new \DateTimeImmutable('2026-03-01') ? $timeContract : $forfaitContract
+        );
+        $resolver->method('resolveNatureForEmployeeAndDate')->willReturn(ContractNature::CDI);
+
+        $this->requestStack->push(new Request(query: ['workDate' => '2026-02-16']));
+        $this->security->method('getUser')->willReturn($user);
+        $this->employeeRepository->method('findScoped')->with($user)->willReturn([$employee]);
+        $this->absenceRepository->method('findByDateAndEmployees')->willReturn([]);
+
+        $provider = new WorkHourDayContextProvider(
+            $this->security,
+            $this->requestStack,
+            $this->employeeRepository,
+            $this->absenceRepository,
+            $this->formationRepository,
+            $resolver,
+            new AbsenceSegmentsResolver(),
+            new WorkedHoursCreditPolicy($this->buildResolverStub(), new DailyReferenceMinutesResolver()),
+            $this->buildHolidayResolver(),
+        );
+
+        $row = $provider->provide(new Get())->rows[0];
+
+        self::assertSame('TIME', $row['trackingMode']);
+        self::assertSame(39, $row['weeklyHours']);
+        self::assertSame('39H', $row['contractType']);
+        self::assertSame('Contrat', $row['contractName']);
+    }
+
    private function buildEmployee(int $id, string $trackingMode, ?int $weeklyHours): Employee
    {
        $contract = new Contract()
Author	SHA1	Message	Date
tristan	54286ecfa4	docs(rtt) : add design spec and implementation plan for custom deficit	2026-06-09 10:21:25 +02:00
tristan	ffa4a5c9d2	chore(rtt) : align TS week DTO with isFlatRecovery field	2026-06-09 10:20:59 +02:00
tristan	f9b3edcf08	docs(rtt) : custom contract deficit now reduces the balance Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-09 10:15:38 +02:00
tristan	f14723c234	chore(rtt) : fix test docblock placement and restore alignment	2026-06-09 10:13:21 +02:00
tristan	0ff055ec76	chore(rtt) : mirror flat-recovery cascade skip in verification snapshot command	2026-06-09 10:08:33 +02:00
tristan	8a0eb40616	feat(rtt) : skip 25/50 deficit cascade for flat (custom) recovery weeks	2026-06-09 10:07:55 +02:00
tristan	fa3861b122	feat(rtt) : custom contract deficit counts as signed recovery (1h=1h, no bands)	2026-06-09 10:06:23 +02:00
tristan	f344eb536c	test(rtt) : custom deficit week reduces closing balance	2026-06-09 10:05:26 +02:00
tristan	294e3c3a25	feat(rtt) : add isFlatRecovery flag to recovery DTOs	2026-06-09 10:05:05 +02:00
gitea-actions	2745f4e476	chore: bump version to v0.1.107 Auto Tag Develop / tag (push) Successful in 5s Details Build & Push Docker Image / build (push) Successful in 34s Details	2026-06-08 13:27:41 +00:00
tristan	1edb8d956f	feat(rtt) : paiement RTT rétroactif sur l'exercice précédent (#23 ) Auto Tag Develop / tag (push) Successful in 7s Details ## Besoin RH Pouvoir saisir un paiement RTT sur l'exercice précédent (ex. RTT de mai réglés après la bascule du 1er juin). ## Implémentation (Option B) - Paiement autorisé sur l'exercice courant + l'exercice immédiatement précédent (N-1). - Après saisie sur N-1, le report d'ouverture de l'exercice courant est recalculé automatiquement (computeClosingBalance) dans une transaction → aucun double comptage. - Refus si ce report est verrouillé (is_locked) : la RH le déverrouille d'abord. - Fallback EmployeeRttSummaryProvider::resolveCarry aligné sur computeClosingBalance : disponible correct même sans ligne stockée. - Front : bouton « + Payer les RTT » actif sur l'exercice précédent. - Docs : CLAUDE.md, doc/rtt-tab.md, documentation-content.ts. ## Vérification - ✅ 172 tests OK, cs-fixer OK, conteneur compile. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Reviewed-on: #23 Co-authored-by: tristan <tristan@yuno.malio.fr> Co-committed-by: tristan <tristan@yuno.malio.fr>	2026-06-08 13:27:34 +00:00
gitea-actions	c01e1f89a7	chore: bump version to v0.1.106 Auto Tag Develop / tag (push) Successful in 6s Details Build & Push Docker Image / build (push) Successful in 34s Details	2026-06-08 08:56:27 +00:00
tristan	ac8a36eb4f	[#SIRH-34] fix RTT bascule ne fonctionne pas (#22 ) Auto Tag Develop / tag (push) Successful in 7s Details La bascule app:rtt:rollover ne reprenait que les RTT acquis de l'exercice qui se terminait : le report d'ouverture déjà présent était perdu et les paiements n'étaient pas déduits. Le nouveau report reprend le solde de clôture = report d'ouverture(N-1) + acquis(N-1) − RTT payés(N-1), soit le "Disponible" affiché par EmployeeRttSummaryProvider. - nouveau RttClosingBalanceService (fold pur testé : invariant somme tranches = disponible, cascade déficit 50% avant 25%, récup CUSTOM non perdue) - RttRolloverCommand branché dessus + option --recompute (écrase les lignes existantes non verrouillées, pour reprise d'une bascule erronée) - test date-sensible EmployeeRttSummaryProviderTest rendu robuste - docs: doc/rtt-rollover.md, CLAUDE.md, documentation-content.ts Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> \| Numéro du ticket \| Titre du ticket \| \|------------------\|-----------------\| \| \| \| ## Description de la PR ## Modification du .env ## Check list - [ ] Pas de régression - [ ] TU/TI/TF rédigée - [ ] TU/TI/TF OK - [ ] CHANGELOG modifié Reviewed-on: #22 Co-authored-by: tristan <tristan@yuno.malio.fr> Co-committed-by: tristan <tristan@yuno.malio.fr>	2026-06-08 08:56:19 +00:00
gitea-actions	3bf48164d2	chore: bump version to v0.1.105 Auto Tag Develop / tag (push) Successful in 6s Details Build & Push Docker Image / build (push) Successful in 53s Details	2026-06-08 08:18:50 +00:00
tristan	516ba45794	Merge remote-tracking branch 'origin/develop' into develop Auto Tag Develop / tag (push) Successful in 7s Details	2026-06-08 10:18:41 +02:00
gitea-actions	97557ae284	chore: bump version to v0.1.104 Auto Tag Develop / tag (push) Successful in 7s Details Build & Push Docker Image / build (push) Successful in 1m2s Details	2026-06-02 06:26:50 +00:00
tristan	a41bd632cf	Retour RH: vue jour par date, RTT mi-semaine, récap salaire & exports, panier de nuit (#21 ) Auto Tag Develop / tag (push) Successful in 11s Details ## Correctifs RH (branche fix/retour-rh) ### Vue Jour (Heures) - Mode saisie/présence, libellé de contrat et sauvegarde résolus à la date affichée (et non au contrat courant). Corrige les salariés passés 39h/35h → Forfait. ### RTT — heures supplémentaires - Proratisation du plafond 25%/50% pour les embauches en milieu de semaine (la bande +25% se décale au lieu de rester bloquée à 43h). Témoin Dylan : 4h à 25% + 3h à 50%. ### Récap salaire (PDF mensuel) - Forfait : congés imputés N-1 non affichés et comptés en présence. - Colonne « Heures payés » scindée 25% / 50% (en-tête fusionné). - Exclusion des salariés sans contrat sur le mois (ex. Marine, contrat terminé). ### Exports heures annuelles (par salarié + tous) - Tous les jours sous contrat affichés, même vides/non saisis (corrige les lignes manquantes). - Samedis/dimanches en gris plus foncé. ### Panier de nuit - Ne s'applique pas aux conducteurs (vue semaine + récap salaire). ## Tests - 11 tests ajoutés. Suite verte hors un test legacy pré-existant dépendant de la date (`EmployeeRttSummaryProviderTest::testNoQueryParamsKeepsLegacyYearDefaulting`, non modifié par cette branche). ## À noter (hors scope) - L'export heures annuelles tous salariés peut dépasser `memory_limit=256M` (Dompdf) — limitation pré-existante, non corrigée ici. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Reviewed-on: #21 Co-authored-by: tristan <tristan@yuno.malio.fr> Co-committed-by: tristan <tristan@yuno.malio.fr>	2026-06-02 06:26:40 +00:00
tristan	387cff2293	docs: spec vue jour résolution contrat à la date affichée Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-01 21:37:26 +02:00