91 changed files with 1226 additions and 6332 deletions
--- a/.gitignore
+++ b/.gitignore
@ -5,13 +5,6 @@ build/
 # Local configuration (machine-specific, never commit)
 local.properties
 # Release signing (v1.9.8) — created by scripts/make-release-keystore.sh.
 # NEVER commit: the keystore + its passwords are the identity of the app
 # (leaking them = anyone can ship an APK that upgrades over yours).
 keystore.properties
 *.keystore
 *.jks
 # IntelliJ / Android Studio
 .idea/
 *.iml
--- a/README.en.md
+++ b/README.en.md
@ -1,305 +0,0 @@
 # HormoneTrack
 > **Language**: [Français](README.md) · **English** (this file)
 > **🤖 AI-assisted development**: this project was designed and coded with an
 > AI assistant. The human contribution was **essential**: continuous feedback,
 > user reports (testing on a real phone, bug reports with real data exports),
 > improvement suggestions and validation of every release. The session-by-session
 > detail is documented in
 > [docs/DEVELOPPEMENT.md §2](docs/DEVELOPPEMENT.md) (French).
 Hormone therapy (HRT) tracker on Android, with **hour-by-hour** estimated
 curves of estradiol (E2) and testosterone (T), calibration against blood
 tests, reminders mirrored on a smartwatch (Huawei Watch GT 3 via Gadgetbridge
 or Huawei Health) and JSON backup. **100% local, no account, no server.**
 > **⚠️ Medical disclaimer**: the curves are **pharmacokinetic estimates**
 > for informational purposes — they are not measurements. Always rely on your
 > blood tests and on your endocrinologist's guidance.
 - **Status**: v1.13.0 — Android build ✅, **lint clean** ✅, **284 unit tests** ✅
  (250 without the local test data; 7 regressions pinned on real data
  **not committed to the repo**), **14 Compose UI tests** ✅ (emulator),
  smartwatch integration = notifications ✅, **private Gitea repo + releases
  with APK** ✅
 - **Changelog**: [docs/CHANGELOG.md](docs/CHANGELOG.md) (French)
 - **User guide**: [docs/GUIDE_INSTALLATION.md](docs/GUIDE_INSTALLATION.md) (French)
 - **Development docs** (architecture, math, decisions, bugs): [docs/DEVELOPPEMENT.md](docs/DEVELOPPEMENT.md) (French)
 - **Watch / Gadgetbridge**: [docs/MONTRE-GADGETBRIDGE.md](docs/MONTRE-GADGETBRIDGE.md) (French)
 ## Features
 - **Hour-by-hour estimated curves**: E2 (pg/mL) and T (ng/mL), 24 h / 7 d / 30 d views,
  **dose markers** (forecast and actual), **configurable chart timezone** (v1.4.5),
  **pan** (drag to scroll back in time), **zoom** (pinch or − / + buttons,
  6 h → 300 d, adaptive sampling), displayable **peaks & troughs** with their
  **estimated values** (▲▼ triangles at local extrema, toggleable)
 - **Two PK models, superimposable**: **Estrannaise (EstraNase)** (hourly tables
  from the `.ods` spreadsheet) and **Transfem Science** — since v1.4.0 the TFS
  model is the **official 3-compartment meta-analysis** (exact closed form,
  parameters from the [TFS simulator](https://transfemscience.org/misc/injectable-e2-simulator/),
  [article](https://transfemscience.org/articles/injectable-e2-meta-analysis/)),
  covering **7 esters** (EV, EU, EEn, EB, EC oil, EC suspension, PEP) — WHSAH
  covers 6 (no PEP). Displayed side by side with independent toggles (3 colors) —
  **pre-checked according to your treatments' models** (v1.4.7) and **each model
  calibrated separately** by your labs (v1.4.8 — scale factors adapt to each profile)
 - **"Lab track" curve (v1.5.0, extended in v1.6.0)**: the curve anchored on your
  blood tests (`Lab track` chip, off by default) — the PK model's shape between
  labs, with the amplitude rescaled to pass EXACTLY through every E2 lab value;
  log-linear transition from one lab to the next, keeps out-of-action-window labs
  (#61); **`Extend` chip (v1.6.0)**: the curve extends beyond the last lab
  (model × last lab ratio, horizon = model extinction, estimated part drawn
  faded + dedicated legend) — the curve is a COMPARISON reference, never an
  estimate of action (it never feeds the home screen or the alerts)
 - **Analytical Estrannaise model (v1.9.0)**: the ESE model now uses the 3C
  closed form published by estrannaise.js (fidelity to the old tables pinned at
  RMS 0) — **MCMC uncertainty cloud** (`Cloud` chip, ESE-exclusive: 32 posterior
  curves showing the imprecision range, like the estrannaise website); **6
  injectable esters** (incl. EUCS, exclusive); the historical ODS is no longer
  used at runtime (fidelity = tests only); analytical terminal t½
  (blood draw recommendation)
 - **Configurable Bateman model** (time to peak, half-life, bioavailability) for
  gel, patch and oral routes
 - **Forecast simulation**: set a **Dosage interval** (days) on a treatment →
  upcoming doses are projected on the chart (never saved); **enabling forecast
  does not move the chart start** but EXTENDS the window to the next dose
  (v1.4.4), and the projection is browsed by dragging left, up to **1 year**
 - **Inactive treatments**: an archived treatment disappears from input and
  reminders, but **its whole history stays simulated and calibrated** — useful
  for a valerate → enanthate transition; **grouped at the very bottom** of the
  Treatments page under a dedicated header, dimmed cards (v1.11.0);
  **no future projection anymore** (v1.12.0 — its slots disappear from the
  Forecast chart)
 - **Dose log** with exact date/time, dose in mg, **per-injection ester**
  (EV↔EU↔EEn switch like in the spreadsheet), **editable** (tap a row in Doses),
  **interval in days between doses** displayed; **route icon per dose row**
  (oral / IM-SC injection / gel / patch, v1.12.0) and **same-day blood test
  markers** (🧪↑ before the dose, 🧪↓ after)
 - **Blood tests**: **E2 + T in a single entry** (each optional), displayed
  **side by side** when they share the same date/time, editable (tap → pick the
  entry); T units: ng/mL, ng/dL, ng/L, nmol/L
 - **Suggested next blood draw (v1.8.0, extended v1.8.1 to the Labs and Home pages)**:
  the Labs page recommends the **estimated trough just before the next injection**
  (the most comparable moment), **at the first trough where your regimen is
  stabilized** (~5 half-lives after your last change — dose, ester or interval) —
  derived from the curves and the Dosage interval; requires an active injectable
  E2 with a Dosage (a prompt suggests setting one otherwise); estimates, never
  medical advice;
  **v1.13.0**: the card shows the **expected E2 at that trough** (when
  auto-calibration is ON) and compares it to your personal **trough target**
  (opt-in — distinct from the alert thresholds, never notifies)
 - **Calibration**: per-treatment scale factor = median(lab ÷ model prediction),
  computed automatically (the `.ods` "Scale factor", automated) — or **permanent
  automatic calibration** (option, off by default) which calibrates **each ester
  with the labs of its own period** (valerate labs → valerate doses, enanthate
  labs → enanthate doses) and recalibrates the T model
 - **Empirical T estimation** `T = floor + (base − floor) ÷ (1 + k·E2)`, with
  **k calibrated per ester period** (T suppression differs valerate vs enanthate),
  against the already-calibrated E2 — accepted T units: ng/mL, ng/dL, ng/L, nmol/L
 - **Daily reminders** with **"Taken" / "Snooze 1 h"** actions right in the
  notification; notifications are mirrored to the GT 3 watch (Gadgetbridge or
  Huawei Health); **reminders follow the Dosage interval** (v1.4.0): a treatment
  injected every 7 days only rings on injection day, not every day; **a dose
  already logged on the day skips the notification** (v1.10.0 — the next
  reminder resumes at the following slot)
 - **Configurable alert thresholds** (v1.4.2): E2 (pg/mL) and T (ng/mL) high/low
  limits in Settings → warning card on the home screen + **notification every
  15 min even with the app closed** (WorkManager, anti-spam, dedicated channel) —
  evaluated on the **estimated** level, opt-in
 - **Full JSON backup**: treatments + doses + labs + T settings
  **+ parameters (language, auto-calibration, alert thresholds)** (v1.4.2)
 - **Daily automatic backup (v1.7.0, opt-in)**: IN ADDITION to the manual export —
  every day, a full JSON backup (same format, directly importable) is written to
  **the folder you choose** (e.g. a synchronized Owncloud folder). No storage
  permission (SAF, folder picked once, persistent revocable permission),
  configurable retention (1–30 copies, default 7 — timestamped file per run,
  never overwritten; manual exports and foreign files **never touched**), last
  run status in Settings, first backup immediately on activation
 - **What's new on every update**: automatic changelog dialog (dismissed =
  won't show again before the next version)
 - **Time on HRT** displayed at the top of the Doses page (since the first dose);
  **next dose in days** on the home screen when it is more than 24 h away (v1.4.1)
 - **Exportable diagnostic logs** (Settings) — useful for support
 - **Calendar events**: dose reminders can create a recurring (posology) event in
  a "HormoneTrack" calendar on your phone
 - **Full JSON backup/restore** (treatments + doses + labs + T settings + parameters, v1.4.2)
 - **FR + EN** (per-app language, independent of the system)
 - Jetpack Compose UI (BOM 2026.08, Material You); 100% local, no account
 ## Quick start (building from source)
 Prerequisites: JDK 17+ (Java 21 OK), Android SDK (platform 37 will be
 auto-downloaded by AGP if the licenses are signed). The wrapper downloads
 Gradle 9.7.1.
 ```bash
 git clone <repo> && cd HormoneTrack
 echo "sdk.dir=/path/to/android-sdk" > local.properties   # or ANDROID_HOME
 ./gradlew assembleDebug            # APK: app/build/outputs/apk/debug/app-debug.apk
 ./gradlew testDebugUnitTest        # 284 tests (250 without local test data)
 ./gradlew connectedDebugAndroidTest # 14 UI tests (emulator/device required)
 ./gradlew lint                     # clean lint required before a release
 ```
 Installing on a phone: developer mode + USB debugging, then Android Studio
 (**Run ▶️**) or `adb install -r app/build/outputs/apk/debug/app-debug.apk`.
 No Play Store: the app is sideloaded. Step-by-step details (French):
 [docs/GUIDE_INSTALLATION.md](docs/GUIDE_INSTALLATION.md).
 ## Git
 Repositories: **gitea.cloudyfy.fr** and **gitea.farewell.dev** (mirror) —
 `Siphonight/HormoneTrack` on both (private), with **tagged releases**
 (`v1.1.0` → `v1.10.0`) and **two APKs per release** (since v1.2.5)
 (downloadable without building, cf
 [docs/DEVELOPPEMENT.md §16.bis](docs/DEVELOPPEMENT.md)):
 `-release.apk` (**recommended**, R8-optimized, 2.7 MB) and `-debug.apk` (20 MB):
 ```bash
 git tag            # list releases
 git log --oneline  # layer-by-layer history (toolchain / engine / UI / docs)
 git push -u origin main --tags
 ```
 **Web port**: since v1.4.10, the browser version lives in its own repository
 `Siphonight/HormoneTrack-web` (same instances) — **aligned versions**
 (web v1.4.10 = port of Android v1.4.10), synced releases (checklist §16 step
 4.bis), separate changelogs.
 Every release commit passes `./gradlew testDebugUnitTest` (green required) and
 is an annotated tag. See [docs/DEVELOPPEMENT.md §16](docs/DEVELOPPEMENT.md).
 **Release signing**: the release APK is signed with the debug key as long as
 no `keystore.properties` exists at the repo root; once created via
 `scripts/make-release-keystore.sh` (both files gitignored), `assembleRelease`
 signs with that keystore — phone migration documented in
 [docs/DEVELOPPEMENT.md §16.quater](docs/DEVELOPPEMENT.md).
 ## The models in short
 Each injection contributes `dose_mg × profile(dt)` where `profile` is the
 normalized response (pg/mL per mg); contributions superimpose. **Three
 superimposable models**:
 - **Estrannaise** = hourly tables from the `.ods` (8001 h), EV/EU/EEn
 - **Transfem Science** = 3-compartment meta-analysis (V3C, closed form,
  [article](https://transfemscience.org/articles/injectable-e2-meta-analysis/)),
  7 esters (EV, EU, EEn, EB, EC, EC suspension, PEP)
 - **WHSAH** (v1.4.6) = "license-free" fit of the [WHSAH Collective via
  Mona](https://github.com/mona-hrt/mona) — same mathematical family but
  independent parameters with explicit bioavailability F < 1: faster rise
  at D+1 (EEn ~70 pg/mL at D+1 for 5 mg vs ~22 for TFS) and longer decay
  (EEn t½ 7.3 d vs 4.5 d). 6 esters (no PEP)
 Reference peaks (pg/mL per mg):
 | Profile  | Model            | Peak (pg/mL/mg) | Tmax   | Terminal t½ |
 |----------|------------------|-----------------|--------|-------------|
 | EV       | Estrannaise      | 61.1            | ~45 h  | — |
 | EU       | Estrannaise      | 3.4             | ~55 h (long plateau) | — |
 | EEn      | Estrannaise      | 31.4            | ~152 h | — |
 | EV       | Transfem Science | 59.0            | ~51 h  | 3.0 d |
 | EU       | Transfem Science | 10.1            | ~198 h | — |
 | EEn      | Transfem Science | 32.0            | ~156 h | 4.5 d |
 | EB       | Transfem Science | 194.2           | ~16 h  | 1.2 d |
 | EC (oil) | Transfem Science | 31.1            | ~103 h | 6.7 d |
 | EC (susp.) | Transfem Science | 48.2          | ~29 h  | 5.1 d |
 | PEP      | Transfem Science | 1.03 (~6.5× dose) | ~18 d | 28.4 d |
 | EV       | WHSAH            | 73.5            | ~41 h  | 3.1 d |
 | EEn      | WHSAH            | 37.6            | ~120 h | 7.3 d |
 | EB       | WHSAH            | 260.1           | ~12 h  | 1.3 d |
 | EC (oil) | WHSAH            | 25.0            | ~81 h  | 7.9 d |
 | EC (susp.) | WHSAH          | 53.5            | ~16 h  | 7.1 d |
 | EU       | WHSAH            | 4.9             | ~67 h  | 31.7 d |
 **Calibration (v1.4.8)**: the scale factor applies per ESTER and per
 injection PERIOD (median of lab ÷ prediction ratios, like the original
 spreadsheet's "Scale factor" column) — and per MODEL: every displayed curve
 (Estrannaise / Transfem Science / WHSAH) is calibrated with ITS OWN model's
 prediction → they all stick to your labs, whatever their shape.
 Auto-calibration is optional (off by default).
 ## Privacy
 - **The app is 100% local**: Room database on the phone, no server, no
  telemetry; Gadgetbridge-compatible (FOSS) with no Huawei Health dependency
 - **The repository contains no health data**: code and docs are generic; the
  regression tests that use real exports load their data from
  `local-test-data/` (**gitignored**, outside the repo — and the history was
  cleaned before the first push, cf
  [docs/DEVELOPPEMENT.md §8.bis](docs/DEVELOPPEMENT.md))
 - Backups = JSON files you store wherever you want (Owncloud, etc.)
 - **The daily auto-backup (v1.7.0) only writes to the folder YOU picked
  yourself** (system SAF picker, revocable permission) — nothing ever leaves
  the phone, no server
 - `allowBackup=false` (sensitive data); biometric lock planned for Phase 2
 - The repository is **private**: release APKs download while logged in;
  making the repo public would make the APKs downloadable without an account
  (no data risk, see above)
 ## Repository structure
 ```
 HormoneTrack/
 ├── README.md                     ← this file's French twin
 ├── docs/
 │   ├── GUIDE_INSTALLATION.md     user guide (phone + watch, French)
 │   ├── DEVELOPPEMENT.md          full dev docs (architecture, math, bugs, tests, French)
 │   ├── CHANGELOG.md              detailed version history (French)
 │   └── MONTRE-GADGETBRIDGE.md    Huawei GT 3 watch: options + limits (French)
 ├── scripts/
 │   ├── gitea-release.py            publishes a release body (CHANGELOG + APK)
 │   ├── publish-release.py          publishes a tag's 2 APKs (verified by download)
 │   ├── seed-emulator.py            injects a JSON backup into an emulator DB
 │   └── make-release-keystore.sh    generates the release keystore + properties (v1.9.8)
 ├── local-test-data/              ← gitignored: real backups for regression
 │                                   tests (NEVER in the repo, cf §8.bis)
 ├── keystore.properties           ← gitignored: release signing (optional, §16.quater)
 ├── build.gradle.kts              root Gradle config (AGP/Kotlin/KSP pinned)
 ├── settings.gradle.kts
 ├── gradle.properties
 ├── gradle/wrapper/               Gradle 9.7.1 wrapper (jar + properties)
 ├── gradlew / gradlew.bat
 └── app/
    ├── build.gradle.kts          dependencies (Compose, Room, DataStore, Gson…)
    ├── proguard-rules.pro
    └── src/
        ├── main/
        │   ├── AndroidManifest.xml
        │   ├── assets/pk_profiles.json          ← hourly tables (Estrannaise/TFS)
        │   ├── java/com/hormonetrack/
        │   │   ├── data/         (Room: models, DAOs, repository, backup)
        │   │   ├── pk/           (PK engine + profiles: Estrannaise/TFS/WHSAH, alerts, export)
        │   │   ├── reminder/     (exact alarms, notifs + actions, boot, alert worker)
        │   │   ├── settings/     (DataStore: TConfig, language)
        │   │   ├── ui/           (Compose: screens, components, theme)
        │   │   │   └── screens/settings/   ← Settings cards (v1.9.8 split)
        │   │   ├── HormoneTrackApp.kt
        │   │   └── MainActivity.kt
        │   └── res/              (FR/EN strings, theme, icons)
        ├── test/java/com/hormonetrack/          ← JVM unit tests
        │   ├── pk/               (engine, ESE/TFS/WHSAH profiles, per-model
        │   │                      calibration, reminders, data-driven regressions)
        │   ├── data/backup/      (Gson round-trip + parameters)
        │   ├── ui/               (chart window, source guard)
        │   ├── util/             (export file names, durations)
        │   └── reminder/ + settings/  (calendar RRULE, changelog)
        └── androidTest/java/com/hormonetrack/   ← Compose UI tests (v1.9.8)
            └── uitest/           (navigation, changelog dialog, settings)
 ```
 ## Roadmap
 - [x] v1: E2/T curves, dose log, labs + calibration, reminders, JSON backup, FR/EN
 - [x] Compose UI tests (13) + dedicated release signing infrastructure (v1.9.8)
 - [ ] Biometric lock, widget, CSV export
 - [ ] Watch Phase 2: custom watchface and/or Lite Wearable mini-app (see
  [docs/MONTRE-GADGETBRIDGE.md](docs/MONTRE-GADGETBRIDGE.md))
 ## License
 **GPL-3.0** — see [LICENSE](LICENSE). Consistent with the Gadgetbridge
 ecosystem. The PK models belong to their respective authors
 ([Estrannaise](https://estrannaise.github.io/),
 [Transfem Science](https://transfemscience.org)).
--- a/README.md
+++ b/README.md
@ -1,7 +1,5 @@
 # HormoneTrack
 > **Langue** : Français (ce fichier) · [English](README.en.md)
 > **🤖 Développé avec l'IA** : ce projet a été conçu et codé avec un assistant IA.
 > La contribution humaine a été **essentielle** : feedback continu, retours
 > utilisateur (tests sur vrai téléphone, rapports de bugs accompagnés d'exports
@ -18,12 +16,11 @@ sauvegarde JSON. **100 % local, aucun compte, aucun serveur.**
 > à titre informatif — ce ne sont pas des mesures. Fie-toi toujours à tes analyses de
 > sang et aux consignes de ton endocrinologue.
- **Statut** : v1.13.0 — build Android ✅, **lint vert** ✅, **284 tests unitaires** ✅ (250 sans les données de test locales ; 7 régressions épinglées sur données réelles **non versionnées**), **14 tests UI Compose** ✅ (émulateur), intégration montre = notifications ✅, **dépôt Gitea privé + releases avec APK** ✅
+- **Statut** : v1.8.1 — build Android ✅, **lint vert** ✅, **223 tests unitaires** ✅ (193 sans les données de test locales ; régressions épinglées sur données réelles **non versionnées**), intégration montre = notifications ✅, **dépôt Gitea privé + releases avec APK** ✅
 - **Journal des versions** : [docs/CHANGELOG.md](docs/CHANGELOG.md)
 - **Guide utilisateur** : [docs/GUIDE_INSTALLATION.md](docs/GUIDE_INSTALLATION.md)
 - **Doc de développement** (architecture, maths, décisions, bugs) : [docs/DEVELOPPEMENT.md](docs/DEVELOPPEMENT.md)
 - **Montre / Gadgetbridge** : [docs/MONTRE-GADGETBRIDGE.md](docs/MONTRE-GADGETBRIDGE.md)
 - **README anglais** : [README.en.md](README.en.md)
 ## Fonctionnalités
@ -51,13 +48,6 @@ sauvegarde JSON. **100 % local, aucun compte, aucun serveur.**
  extinction du modèle, partie estimée dessinée atténuée + légende dédiée) —
  la courbe est une référence de COMPARAISON, jamais une estimation d'action
  (elle n'entre jamais dans l'accueil/les alertes)
 - **Modèle Estrannaise ANALYTIQUE (v1.9.0)** : le modèle ESE utilise désormais
  la forme close 3C publiée par estrannaise.js (fidélité aux anciennes tables
  épinglée RMS 0) — **nuage d'incertitude MCMC** (chip `Nuage`, exclusif ESE :
  32 courbes du posterior montrant la plage d'imprécision, comme sur le site
  estrannaise) ; **6 esters injectables** (dont EUCS, exclusif) ; l'ODS
  historique n'est plus utilisé au runtime (fidélité = tests uniquement) ;
  t½ terminale analytique (recommandation de prise de sang)
 - **Modèle Bateman** paramétrable (temps au pic, demi-vie, biodisponibilité) pour gel,
  patch et voie orale
 - **Simulation prévisionnelle** : configurer la **posologie** (intervalle en jours) sur un
@ -67,25 +57,19 @@ sauvegarde JSON. **100 % local, aucun compte, aucun serveur.**
  vers la gauche, jusqu'à **1 an**
 - **Log des doses** avec date/heure exacte, dose en mg, **ester par injection**
  (switch EV↔EU↔EEn comme dans le tableur), **éditable** (tap sur une ligne dans Doses),
-  **intervalle en jours entre dosages** affiché ; **icône de forme de prise**
+  **intervalle en jours entre dosages** affiché
  (oral / injection IM-SC / gel / patch, v1.12.0) et **encart « prise de sang
  le même jour »** (🧪↑ avant la dose, 🧪↓ après)
 - **Traitements inactifs** : un traitement archivé n'apparaît plus dans la saisie
  ni dans les rappels, mais **tout son historique reste simulé et calibré** —
-  utile pour une transition valerate → enanthate ; **regroupés tout en bas** de la
+  utile pour une transition valerate → enanthate
  page Traitements sous un en-tête dédié, cartes atténuées (v1.11.0)
 - **Analyses de sang** : **E2 + T en une seule entrée** (chacune optionnelle), affichées
  **côte à côte** quand elles partagent la même date/heure, éditables (tap → choix de
  l'entrée) ; unités T : ng/mL, ng/dL, ng/L, nmol/L
- **Prochaine prise de sang suggérée (v1.8.0, étendu v1.8.1 aux pages Analyses et Accueil)** : la page Analyses recommande le
+- **Prochaine prise de sang suggérée (v1.8.0)** : la page Analyses recommande le
  **creux estimé juste avant l'injection suivante** (moment le plus comparable),
  **au premier creux où ton régime est stabilisé** (~5 demi-vies après ton dernier
  changement — dose, ester ou intervalle) — déduit des courbes et de la Posologie ; requiert un
-  injectable E2 actif à Posologie (une invite propose de la renseigner sinon) ;
+  injectable E2 actif à Posologie (une invite invite à la renseigner sinon) ;
-  estimations, jamais un avis médical ;
+  estimations, jamais un avis médical
  **v1.13.0** : la carte affiche la **valeur E2 attendue au creux** (si l'auto-calibration
  est ON) et la compare à ta **cible de creux** personnelle (opt-in — distinct des
  seuils d'alerte, jamais de notification)
 - **Calibration** : facteur d'échelle par traitement = médiane(lab ÷ prédiction du modèle),
  calculé automatiquement (« Scale factor » du `.ods`, automatisé) — ou **calibration
  automatique permanente** (option, désactivée par défaut) qui calibre **chaque ester
@ -97,9 +81,7 @@ sauvegarde JSON. **100 % local, aucun compte, aucun serveur.**
 - **Rappels quotidiens** avec actions **« Pris » / « Reporter 1 h »** dans la notification ;
  les notifications remontent sur la Watch GT 3 (Gadgetbridge ou Huawei Health) ;
  **les rappels suivent la Posologie** (v1.4.0) : un traitement injecté tous les
-  7 jours ne sonne que le jour d'injection, pas tous les jours ; **une dose déjà
+  7 jours ne sonne que le jour d'injection, pas tous les jours
  loguée dans la journée saute la notification** (v1.10.0 — le rappel suivant
  repart au créneau suivant)
 - **Seuils d'alerte configurables** (v1.4.2) : limites hautes/basses E2 (pg/mL)
  et T (ng/mL) dans Paramètres → carte d'avertissement sur l'accueil +
  **notification toutes les 15 min même app fermée** (WorkManager, anti-spam,
@ -134,8 +116,7 @@ par AGP si les licences sont signées). Le wrapper télécharge Gradle 9.7.1.
 git clone <repo> && cd HormoneTrack
 echo "sdk.dir=/chemin/vers/android-sdk" > local.properties   # ou ANDROID_HOME
 ./gradlew assembleDebug            # APK : app/build/outputs/apk/debug/app-debug.apk
-./gradlew testDebugUnitTest        # 284 tests (250 sans les données locales)
+./gradlew testDebugUnitTest        # 223 tests (193 sans les données locales)
 ./gradlew connectedDebugAndroidTest # 14 tests UI (émulateur/appareil requis)
 ./gradlew lint                     # lint vert obligatoire avant release
 ```
@ -147,9 +128,9 @@ Pas de Play Store : l'app est sideloadée. Détails pas-à-pas : [docs/GUIDE_INS
 Dépôts : **gitea.cloudyfy.fr** et **gitea.farewell.dev** (miroir) —
 `Siphonight/HormoneTrack` sur les deux (privé), avec
-**releases taguées** (`v1.1.0` → `v1.10.0`) et **deux APK par release** (depuis v1.2.5)
+**releases taguées** (`v1.1.0` → `v1.4.10`) et **deux APK par release** (depuis v1.2.5)
 (téléchargeables sans compiler, cf [docs/DEVELOPPEMENT.md §16.bis](docs/DEVELOPPEMENT.md)) :
-`-release.apk` (**recommandé**, optimisé R8, 2,7 Mo) et `-debug.apk` (20 Mo) :
+`-release.apk` (**recommandé**, optimisé R8, 2,4 Mo) et `-debug.apk` (20 Mo) :
 ```bash
 git tag            # lister les releases
@ -165,12 +146,6 @@ dépôt `Siphonight/HormoneTrack-web` (mêmes instances) — versions **alignée
 Chaque commit de release passe `./gradlew testDebugUnitTest` (vert obligatoire) et est
 taggué annoté. Voir [docs/DEVELOPPEMENT.md §16](docs/DEVELOPPEMENT.md).
 **Signature release** : l'APK release est signé avec la clé debug tant qu'aucun
 `keystore.properties` n'existe à la racine ; dès sa création via
 `scripts/make-release-keystore.sh` (fichiers gitignorés), `assembleRelease`
 signe avec ce keystore — migration téléphone documentée dans
 [docs/DEVELOPPEMENT.md §16.quater](docs/DEVELOPPEMENT.md).
 ## Les modèles en bref
 Chaque injection contribue `dose_mg × profil(dt)` où `profil` est la réponse normalisée
@ -235,7 +210,7 @@ forme. L'auto-calibration est optionnelle (désactivée par défaut).
 ```
 HormoneTrack/
-├── README.md                     ← ce fichier (README.en.md = version anglaise)
+├── README.md                     ← ce fichier
 ├── docs/
 │   ├── GUIDE_INSTALLATION.md     guide utilisateur (téléphone + montre)
 │   ├── DEVELOPPEMENT.md          doc de dev complète (architecture, maths, bugs, tests)
@ -244,11 +219,9 @@ HormoneTrack/
 ├── scripts/
 │   ├── gitea-release.py            publie le corps d'une release (CHANGELOG + APK)
 │   ├── publish-release.py          publie les 2 APK d'un tag (vérification par téléchargement)
-│   ├── seed-emulator.py            injecte un backup JSON dans la DB d'un émulateur (cf §16.ter)
+│   └── seed-emulator.py            injecte un backup JSON dans la DB d'un émulateur (cf §16.ter)
 │   └── make-release-keystore.sh    génère le keystore de signature release (v1.9.8, §16.quater)
 ├── local-test-data/              ← gitignoré : backups réels pour les tests
 │                                   de régression (JAMAIS dans le dépôt, cf §8.bis)
 ├── keystore.properties           ← gitignoré : signature release (optionnel, §16.quater)
 ├── build.gradle.kts              config Gradle racine (AGP/Kotlin/KSP épinglés)
 ├── settings.gradle.kts
 ├── gradle.properties
@ -267,25 +240,22 @@ HormoneTrack/
        │   │   ├── reminder/     (alarmes exactes, notifs + actions, boot, worker alertes)
        │   │   ├── settings/     (DataStore : TConfig, langue)
        │   │   ├── ui/           (Compose : screens, components, theme)
        │   │   │   └── screens/settings/   ← cartes des Paramètres (découpage v1.9.8)
        │   │   ├── HormoneTrackApp.kt
        │   │   └── MainActivity.kt
        │   └── res/              (strings FR/EN, thème, icônes)
-        ├── test/java/com/hormonetrack/          ← tests unitaires JVM
+        └── test/java/com/hormonetrack/          ← tests unitaires JVM
-        │   ├── pk/               (moteur, profils ESE/TFS/WHSAH, calibration
+            ├── pk/               (moteur, profils ESE/TFS/WHSAH, calibration
-        │   │                      par modèle, rappels, régressions data-driven)
+            │                      par modèle, rappels, régressions data-driven)
-        │   ├── data/backup/      (round-trip Gson + paramètres)
+            ├── data/backup/      (round-trip Gson + paramètres)
-        │   ├── ui/               (fenêtre graphique, garde de source)
+            ├── ui/               (fenêtre graphique, garde de source)
-        │   ├── util/             (noms de fichiers d'export, durées)
+            ├── util/             (noms de fichiers d'export, durées)
-        │   └── reminder/ + settings/  (RRULE agenda, changelog)
+            ├── reminder/ + settings/  (RRULE agenda, changelog)
        └── androidTest/java/com/hormonetrack/   ← tests UI Compose (v1.9.8)
            └── uitest/           (navigation, dialog changelog, Paramètres)
 ```
 ## Feuille de route
 - [x] v1 : courbes E2/T, log doses, labs + calibration, rappels, backup JSON, FR/EN
- [x] Tests UI Compose (13) + infrastructure de compilation release signée (v1.9.8)
+- [ ] Tests UI Compose + compilation release signée
 - [ ] Verrou biométrique, widget, export CSV
 - [ ] Phase 2 montre : watchface personnalisée et/ou mini-app Lite Wearable (voir [docs/MONTRE-GADGETBRIDGE.md](docs/MONTRE-GADGETBRIDGE.md))
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@ -1,25 +1,9 @@
 import java.util.Properties
 plugins {
    id("com.android.application")
    id("org.jetbrains.kotlin.plugin.compose")
    id("com.google.devtools.ksp")
 }
 // ── Signature RELEASE (v1.9.8) ──────────────────────────────────────────────
 // keystore.properties (RACINE du dépôt, GITIGNORÉ) décrit le vrai keystore :
 //   storeFile=release.keystore   (chemin relatif à la racine du dépôt)
 //   storePassword=…
 //   keyAlias=…
 //   keyPassword=…
 // Tant que ce fichier est ABSENT, la build release reste signée avec la clé
 // DEBUG (comportement historique : installation par-dessus l'APK debug sans
 // perte de données, cf §16.quater). Dès qu'il existe (créé par
 // scripts/make-release-keystore.sh), la build release l'utilise — ⚠️ signature
 // différente ⇒ migration obligatoire : export JSON → désinstallation →
 // réinstallation → réimport (documenté §16.quater).
 val keystorePropertiesFile = rootProject.file("keystore.properties")
 android {
    namespace = "com.hormonetrack"
    compileSdk = 37
@ -33,8 +17,8 @@ android {
        // tag : v1.3.0→v1.3.2 contenaient tous versionCode 14 / "1.3.0"
        // (bump jamais commité) → BuildConfig.VERSION_NAME était faux dans
        // les APK publiés (Paramètres + titre du dialog « Nouveautés »).
-        versionCode = 50
+        versionCode = 36
-        versionName = "1.13.0"
+        versionName = "1.8.1"
        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
        vectorDrawables {
@ -51,27 +35,12 @@ android {
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
-            // Signature : VRAI keystore si keystore.properties existe (racine du
+            // ⚠️ Signé avec la CLÉ DEBUG volontairement : l'APK release reste
-            // dépôt, gitignoré — créé par scripts/make-release-keystore.sh) ;
+            // installable PAR-DESSUS l'APK debug déjà installé (même signature),
-            // sinon CLÉ DEBUG volontairement : l'APK release reste installable
+            // sans désinstallation ni perte de données, tout en bénéficiant de
-            // PAR-DESSUS l'APK debug déjà installé (même signature), sans
+            // R8. Si un jour on distribue largement : générer un vrai keystore
-            // désinstallation ni perte de données, tout en bénéficiant de R8.
+            // (signature différente → migration backup→désinstall→réimport).
-            // ⚠️ Passer au vrai keystore CHANGE la signature : migration
+            signingConfig = signingConfigs.getByName("debug")
            // backup→désinstall→réimport requise sur le téléphone (§16.quater).
            signingConfig = if (keystorePropertiesFile.exists()) {
                val props = Properties().apply {
                    keystorePropertiesFile.inputStream().use { load(it) }
                }
                signingConfigs.create("release") {
                    storeFile = rootProject.file(props.getProperty("storeFile"))
                    storePassword = props.getProperty("storePassword")
                    keyAlias = props.getProperty("keyAlias")
                    keyPassword = props.getProperty("keyPassword")
                }
                signingConfigs.getByName("release")
            } else {
                signingConfigs.getByName("debug")
            }
        }
    }
@ -160,16 +129,4 @@ dependencies {
    // Tests unitaires JVM
    testImplementation("junit:junit:4.13.2")
    // ── Tests UI Compose (v1.9.8, androidTest — cf docs/DEVELOPPEMENT.md §8.ter) ──
    // Exécution : ./gradlew connectedDebugAndroidTest (émulateur/appareil requis).
    // Le BOM est réappliqué sur la configuration androidTest pour épinner les
    // mêmes versions que le runtime Compose de l'app.
    androidTestImplementation(composeBom)
    androidTestImplementation("androidx.compose.ui:ui-test-junit4")
    androidTestImplementation("androidx.test.ext:junit-ktx:1.3.0")
    // JUnit explicite (org.junit.Rule/@Test) — ne pas compter sur le transitif
    androidTestImplementation("junit:junit:4.13.2")
    // UiDevice (pressBack pour fermer les dialogs — v1.10.0, LogDoseRequestTest)
    androidTestImplementation("androidx.test.uiautomator:uiautomator:2.3.0")
 }
--- a/app/src/androidTest/java/com/hormonetrack/uitest/ChangelogDialogTest.kt
+++ b/app/src/androidTest/java/com/hormonetrack/uitest/ChangelogDialogTest.kt
@ -1,108 +0,0 @@
 package com.hormonetrack.uitest
 import androidx.compose.ui.test.assertIsDisplayed
 import androidx.compose.ui.test.junit4.createEmptyComposeRule
 import androidx.compose.ui.test.onNodeWithText
 import androidx.compose.ui.test.performClick
 import androidx.test.core.app.ActivityScenario
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.hormonetrack.BuildConfig
 import com.hormonetrack.MainActivity
 import com.hormonetrack.R
 import kotlinx.coroutines.runBlocking
 import org.junit.After
 import org.junit.BeforeClass
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 /**
 * Test UI du dialog « Nouveautés » (v1.9.8) — épinglé sur les comportements
 * historiques des fixes v1.3.2/v1.3.3 (docs/DEVELOPPEMENT.md §14) :
 *  - affiché quand la version installée est plus récente que la dernière vue ;
 *  - PAS affiché quand la version courante a déjà été vue ;
 *  - une fois FERMÉ, il ne RÉAPPARAÎT PAS au redémarrage (la version vue est
 *    mémorisée AVANT l'affichage — sinon le même changelog ressortait à
 *    chaque réouverture de l'app, bug v1.3.2).
 *
 * ⚠️ Technique : ces tests lancent l'activité MANUELLEMENT (ActivityScenario
 * + règle Compose vide) et non via createAndroidComposeRule, car l'état
 * DataStore (changelogSeenVersion) doit être réglé AVANT que
 * HormoneTrackRoot ne lise la version vue dans son LaunchedEffect de
 * démarrage. La règle automatique lancerait l'activité trop tôt (avant le
 * @Before du test) et le dialog du test précédent fausserait l'état.
 */
@RunWith(AndroidJUnit4::class)
 class ChangelogDialogTest {
    @get:Rule
    val composeRule = createEmptyComposeRule()
    private var scenario: ActivityScenario<MainActivity>? = null
    private fun res(id: Int, vararg args: Any): String =
        UiTestEnv.targetContext.getString(id, *args)
    @After
    fun tearDown() {
        scenario?.close()
    }
    @Test
    fun dialogShownWhenInstalledVersionIsNewerThanLastSeen() {
        runBlocking {
            UiTestEnv.app.container.settings.setChangelogSeenVersion("1.0.0")
        }
        scenario = ActivityScenario.launch(MainActivity::class.java)
        composeRule.waitForIdle()
        composeRule.onNodeWithText(
            res(R.string.changelog_title, BuildConfig.VERSION_NAME)
        ).assertIsDisplayed()
    }
    @Test
    fun dialogAbsentWhenVersionAlreadySeen() {
        runBlocking {
            UiTestEnv.app.container.settings.setChangelogSeenVersion(BuildConfig.VERSION_NAME)
        }
        scenario = ActivityScenario.launch(MainActivity::class.java)
        composeRule.waitForIdle()
        composeRule.onNodeWithText(
            res(R.string.changelog_title, BuildConfig.VERSION_NAME)
        ).assertDoesNotExist()
    }
    @Test
    fun dialogDoesNotReappearAfterDismissAndRestart() {
        runBlocking {
            UiTestEnv.app.container.settings.setChangelogSeenVersion("1.0.0")
        }
        scenario = ActivityScenario.launch(MainActivity::class.java)
        composeRule.waitForIdle()
        composeRule.onNodeWithText(
            res(R.string.changelog_title, BuildConfig.VERSION_NAME)
        ).assertIsDisplayed()
        // Fermeture par le bouton « OK » (identique FR/EN)
        composeRule.onNodeWithText(res(R.string.ok)).performClick()
        composeRule.onNodeWithText(
            res(R.string.changelog_title, BuildConfig.VERSION_NAME)
        ).assertDoesNotExist()
        // Redémarrage de l'activité : le dialog ne doit PAS revenir — la
        // version vue a été persistée AVANT l'affichage (fix v1.3.2).
        scenario!!.recreate()
        composeRule.waitForIdle()
        composeRule.onNodeWithText(
            res(R.string.changelog_title, BuildConfig.VERSION_NAME)
        ).assertDoesNotExist()
    }
    companion object {
        @BeforeClass
        @JvmStatic
        fun setUpApp() {
            // Permission de notifications uniquement : le changelog est réglé
            // PAR TEST (avant chaque lancement manuel d'activité).
            UiTestEnv.grantPostNotifications()
        }
    }
 }
--- a/app/src/androidTest/java/com/hormonetrack/uitest/LogDoseRequestTest.kt
+++ b/app/src/androidTest/java/com/hormonetrack/uitest/LogDoseRequestTest.kt
@ -1,84 +0,0 @@
 package com.hormonetrack.uitest
 import android.content.Intent
 import androidx.compose.ui.test.assertIsDisplayed
 import androidx.compose.ui.test.junit4.createEmptyComposeRule
 import androidx.compose.ui.test.onNodeWithText
 import androidx.compose.ui.test.performClick
 import androidx.test.core.app.ActivityScenario
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.platform.app.InstrumentationRegistry
 import androidx.test.uiautomator.UiDevice
 import com.hormonetrack.MainActivity
 import com.hormonetrack.R
 import org.junit.After
 import org.junit.BeforeClass
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 /**
 * Test UI de la demande « logger une dose » venue d'une NOTIFICATION
 * (v1.10.0, **fix #69**) : le dialog s'ouvre UNE FOIS au lancement avec les
 * extras `open_log_dose`/`treatment_id` (même contrat que ReminderReceiver,
 * cf reminder/ReminderManager.kt), puis — une fois fermé — ne se rouvre
 * JAMAIS tout seul. Comportement bogué épinglé : chaque retour sur l'onglet
 * Accueil rouvrait le dialog indéfiniment (le paramètre d'intent vivait au
 * niveau activité alors que la consommation vivait dans les `remember` de
 * Home, détruits à chaque changement d'onglet).
 *
 * Lancement MANUEL avec intent (règle Compose vide + ActivityScenario) : le
 * contrat du fix exige de régler l'état AVANT que la composition ne lise
 * l'intent — et l'overload `createAndroidComposeRule(intent)` n'existe pas
 * dans la ligne Compose 1.12. La fermeture passe par BACK (onDismissRequest,
 * indépendant des libellés) ; le titre `add_dose` (« Log a dose ») est
 * affiché dans les DEUX variantes du dialog (avec ou sans traitements en
 * base) : le test reste data-indépendant.
 */
@RunWith(AndroidJUnit4::class)
 class LogDoseRequestTest {
    @get:Rule
    val composeRule = createEmptyComposeRule()
    private var scenario: ActivityScenario<MainActivity>? = null
    private fun res(id: Int): String = UiTestEnv.targetContext.getString(id)
    @After
    fun tearDown() {
        scenario?.close()
    }
    @Test
    fun doseDialogOpensOnceAndNeverReopensAfterTabSwitch() {
        val intent = Intent(UiTestEnv.targetContext, MainActivity::class.java).apply {
            putExtra("open_log_dose", true)
            putExtra("treatment_id", 1L)
        }
        scenario = ActivityScenario.launch(intent)
        val dialogTitle = res(R.string.add_dose)
        composeRule.waitForIdle()
        composeRule.onNodeWithText(dialogTitle).assertIsDisplayed()
        // Fermeture du dialog (BACK → onDismissRequest)
        UiDevice.getInstance(InstrumentationRegistry.getInstrumentation()).pressBack()
        composeRule.waitForIdle()
        composeRule.onNodeWithText(dialogTitle).assertDoesNotExist()
        // Changer d'onglet puis revenir sur l'accueil : le dialog NE doit
        // PAS se rouvrir (demande consommée une fois pour toutes)
        composeRule.onNodeWithText(res(R.string.nav_doses)).performClick()
        composeRule.waitForIdle()
        composeRule.onNodeWithText(res(R.string.nav_home)).performClick()
        composeRule.waitForIdle()
        composeRule.onNodeWithText(dialogTitle).assertDoesNotExist()
    }
    companion object {
        @BeforeClass
        @JvmStatic
        fun setUpApp() = UiTestEnv.prepare()
    }
 }
--- a/app/src/androidTest/java/com/hormonetrack/uitest/NavigationTest.kt
+++ b/app/src/androidTest/java/com/hormonetrack/uitest/NavigationTest.kt
@ -1,104 +0,0 @@
 package com.hormonetrack.uitest
 import androidx.compose.ui.test.assertIsDisplayed
 import androidx.compose.ui.test.junit4.createAndroidComposeRule
 import androidx.compose.ui.test.onNodeWithContentDescription
 import androidx.compose.ui.test.onNodeWithText
 import androidx.compose.ui.test.performClick
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.hormonetrack.MainActivity
 import com.hormonetrack.R
 import org.junit.BeforeClass
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 /**
 * Test UI de NAVIGATION (v1.9.8) : la barre d'onglets mène bien à chaque
 * écran, et les Paramètres s'ouvrent depuis l'icône de l'accueil.
 *
 * Les preuves de navigation utilisent des éléments **inconditionnels**
 * (indépendants des données Room, contrairement au contenu des listes) :
 *  - Graphiques → le chip de plage « 24 h » (toujours affiché) ;
 *  - Doses / Analyses / Traitements → leur FloatingActionButton « + »
 *    (contentDescription add_dose / add_lab / add_treatment) ;
 *  - Paramètres → le titre de l'écran + les sections toujours présentes.
 *
 * Textes résolus via targetContext (cf UiTestEnv) : indépendant de la langue
 * système et du réglage in-app FR/EN.
 */
@RunWith(AndroidJUnit4::class)
 class NavigationTest {
    @get:Rule
    val composeRule = createAndroidComposeRule<MainActivity>()
    private fun res(id: Int): String = UiTestEnv.targetContext.getString(id)
    @Test
    fun bottomBarShowsAllFiveTabs() {
        listOf(
            R.string.nav_home, R.string.nav_chart, R.string.nav_doses,
            R.string.nav_labs, R.string.nav_treatments
        ).forEach { labelRes ->
            composeRule.onNodeWithText(res(labelRes)).assertIsDisplayed()
        }
    }
    @Test
    fun homeTabShowsAppTitle() {
        // Retour explicite à l'accueil d'abord : l'état sauvegardé de la
        // navigation peut restaurer l'onglet du test précédent.
        composeRule.onNodeWithText(res(R.string.nav_home)).performClick()
        composeRule.onNodeWithText(res(R.string.app_name)).assertIsDisplayed()
    }
    @Test
    fun chartTabShowsRangeChips() {
        composeRule.onNodeWithText(res(R.string.nav_home)).performClick()
        composeRule.onNodeWithText(res(R.string.nav_chart)).performClick()
        composeRule.onNodeWithText(res(R.string.chart_24h)).assertIsDisplayed()
        composeRule.onNodeWithText(res(R.string.chart_7j)).assertIsDisplayed()
        composeRule.onNodeWithText(res(R.string.chart_30j)).assertIsDisplayed()
    }
    @Test
    fun dosesTabShowsLogDoseFab() {
        composeRule.onNodeWithText(res(R.string.nav_home)).performClick()
        composeRule.onNodeWithText(res(R.string.nav_doses)).performClick()
        composeRule.onNodeWithContentDescription(res(R.string.add_dose))
            .assertIsDisplayed()
    }
    @Test
    fun labsTabShowsAddLabFab() {
        composeRule.onNodeWithText(res(R.string.nav_home)).performClick()
        composeRule.onNodeWithText(res(R.string.nav_labs)).performClick()
        composeRule.onNodeWithContentDescription(res(R.string.add_lab))
            .assertIsDisplayed()
    }
    @Test
    fun treatmentsTabShowsAddTreatmentFab() {
        composeRule.onNodeWithText(res(R.string.nav_home)).performClick()
        composeRule.onNodeWithText(res(R.string.nav_treatments)).performClick()
        composeRule.onNodeWithContentDescription(res(R.string.add_treatment))
            .assertIsDisplayed()
    }
    @Test
    fun settingsOpensFromHomeGearIcon() {
        composeRule.onNodeWithText(res(R.string.nav_home)).performClick()
        composeRule.onNodeWithContentDescription(res(R.string.settings)).performClick()
        // Titre de l'écran + bouton retour (TopAppBar des Paramètres)
        composeRule.onNodeWithText(res(R.string.settings)).assertIsDisplayed()
        composeRule.onNodeWithContentDescription(res(R.string.back))
            .assertIsDisplayed()
    }
    companion object {
        @BeforeClass
        @JvmStatic
        fun setUpApp() = UiTestEnv.prepare()
    }
 }
--- a/app/src/androidTest/java/com/hormonetrack/uitest/SettingsScreenTest.kt
+++ b/app/src/androidTest/java/com/hormonetrack/uitest/SettingsScreenTest.kt
@ -1,84 +0,0 @@
 package com.hormonetrack.uitest
 import androidx.compose.ui.test.assertIsDisplayed
 import androidx.compose.ui.test.junit4.createAndroidComposeRule
 import androidx.compose.ui.test.onNodeWithContentDescription
 import androidx.compose.ui.test.onNodeWithText
 import androidx.compose.ui.test.performClick
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.hormonetrack.MainActivity
 import com.hormonetrack.R
 import org.junit.BeforeClass
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 /**
 * Test UI de l'écran Paramètres (v1.9.8) : chaque SECTION est présente après
 * l'ouverture depuis l'accueil. Les sections profondes (sauvegarde, logs,
 * à propos) vivent SOUS le pli de l'écran scrollable → `assertExists`
 * (présence dans la hiérarchie) et non `assertIsDisplayed` (visibilité à
 * l'écran) : ce test vérifie la STRUCTURE, pas la mise en page.
 *
 * Les chips de langue « Français » / « English » sont des LITTÉRAUX dans le
 * code (chaque langue s'écrit dans sa propre langue — convention UX i18n) :
 * l'assertion ne dépend d'aucune ressource.
 */
@RunWith(AndroidJUnit4::class)
 class SettingsScreenTest {
    @get:Rule
    val composeRule = createAndroidComposeRule<MainActivity>()
    private fun res(id: Int): String = UiTestEnv.targetContext.getString(id)
    private fun openSettings() {
        composeRule.onNodeWithText(res(R.string.nav_home)).performClick()
        composeRule.onNodeWithContentDescription(res(R.string.settings)).performClick()
        composeRule.waitForIdle()
    }
    @Test
    fun languageSectionShowsLocalizedChips() {
        openSettings()
        composeRule.onNodeWithText(res(R.string.language)).assertIsDisplayed()
        composeRule.onNodeWithText("Français").assertIsDisplayed()
        composeRule.onNodeWithText("English").assertIsDisplayed()
    }
    @Test
    fun allSettingsSectionsArePresent() {
        openSettings()
        listOf(
            R.string.auto_calibrate,          // Calibration automatique
            R.string.t_model_title,           // Estimation T
            R.string.alert_section,           // Seuils d'alerte
            R.string.timezone_section,        // Fuseau du graphique
            R.string.reminders_section,       // Rappels / alarmes exactes
            R.string.backup_section,          // Sauvegarde JSON manuelle
            R.string.autobackup_section,      // Auto-backup quotidien
            R.string.logs_section,            // Logs de diagnostic
            R.string.about_title              // À propos / version
        ).forEach { sectionRes ->
            composeRule.onNodeWithText(res(sectionRes)).assertExists()
        }
    }
    @Test
    fun aboutSectionShowsInstalledVersion() {
        openSettings()
        // « Version : X.Y.Z » — la valeur vient de BuildConfig.VERSION_NAME
        // (épinglé : les tags v1.3.0→v1.3.2 embarquaient un versionName
        // jamais bumpé, bug §14 #46 — ce test l'attraperait désormais).
        val expected = UiTestEnv.targetContext.getString(
            R.string.settings_version, com.hormonetrack.BuildConfig.VERSION_NAME
        )
        composeRule.onNodeWithText(expected).assertExists()
    }
    companion object {
        @BeforeClass
        @JvmStatic
        fun setUpApp() = UiTestEnv.prepare()
    }
 }
--- a/app/src/androidTest/java/com/hormonetrack/uitest/UiTestEnv.kt
+++ b/app/src/androidTest/java/com/hormonetrack/uitest/UiTestEnv.kt
@ -1,65 +0,0 @@
 package com.hormonetrack.uitest
 import android.os.Build
 import androidx.test.platform.app.InstrumentationRegistry
 import com.hormonetrack.BuildConfig
 import com.hormonetrack.HormoneTrackApp
 import kotlinx.coroutines.runBlocking
 /**
 * Environnement partagé des tests UI Compose (v1.9.8, cf docs/DEVELOPPEMENT.md
 * §8.ter). Les tests instrumentés tournent CONTRE l'app réelle installée :
 * ils doivent donc être **déterministes quel que soit l'état de l'appareil**
 * (données Room seedées ou non, locale système, version précédemment vue).
 *
 * Deux prérequis réglés ici AVANT le lancement de l'activité :
 *  - **permission POST_NOTIFICATIONS** : MainActivity la demande au premier
 *    lancement (API 33+). Sans pré-grant, le dialog SYSTÈME s'afficherait par
 *    dessus l'app et les assertions Compose ne voient que la fenêtre de
 *    l'app → timeout. Le grant shell (`pm grant`) est persistant.
 *  - **dialog « Nouveautés » neutralisé** : HormoneTrackRoot affiche le
 *    changelog au lancement quand la version installée est plus récente que
 *    la dernière vue — un dialog MODAL qui masquerait toute la navigation.
 *    En marquant la version courante comme vue, il ne s'affiche plus. Les
 *    tests dédiés au dialog (ChangelogDialogTest) relancent l'activité
 *    manuellement APRÈS avoir réglé leur propre état.
 *
 * Les assertions de texte passent par `targetContext.getString(...)` : la
 * ressource est résolue dans la MÊME configuration que celle de l'UI (les
 * per-app locales d'AppCompat s'appliquent à toute l'application), ce qui
 * rend les tests indépendants de la langue système OU du réglage in-app.
 */
 object UiTestEnv {
    val targetContext = InstrumentationRegistry.getInstrumentation().targetContext
    /** L'Application réelle du process instrumenté (même instance que l'UI). */
    val app: HormoneTrackApp =
        targetContext.applicationContext as HormoneTrackApp
    /** Exécute une commande shell et ATTEND sa fin (lecture jusqu'à EOF). */
    fun runShellCommand(command: String) {
        val automation = InstrumentationRegistry.getInstrumentation().uiAutomation
        automation.executeShellCommand(command).use { pfd ->
            java.io.FileInputStream(pfd.fileDescriptor).use { it.readBytes() }
        }
    }
    /** Pré-grante la permission de notifications (idempotent, API 33+). */
    fun grantPostNotifications() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
            runShellCommand("pm grant com.hormonetrack android.permission.POST_NOTIFICATIONS")
        }
    }
    /** Marque le changelog de la version courante comme déjà vu. */
    fun markChangelogSeen() = runBlocking {
        app.container.settings.setChangelogSeenVersion(BuildConfig.VERSION_NAME)
    }
    /** À appeler dans le @BeforeClass de chaque classe de test UI. */
    fun prepare() {
        grantPostNotifications()
        markChangelogSeen()
    }
 }
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@ -26,13 +26,7 @@
        <activity
            android:name=".MainActivity"
            android:exported="true"
            android:launchMode="singleTop"
            android:windowSoftInputMode="adjustResize">
            <!-- launchMode singleTop (v1.10.1) : un tap sur la notification de
                 rappel quand l'app est DÉJÀ ouverte délivre onNewIntent (avec les
                 extras open_log_dose/treatment_id) SANS détruire/recréer
                 l'activité — l'ancien comportement (standard + CLEAR_TOP)
                 recréait tout, et onNewIntent était du code mort. -->
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
--- a/app/src/main/assets/mcmc_samples.json
+++ b/app/src/main/assets/mcmc_samples.json
--- a/app/src/main/assets/pk_profiles.json
+++ b/app/src/main/assets/pk_profiles.json
--- a/app/src/main/java/com/hormonetrack/HormoneTrackApp.kt
+++ b/app/src/main/java/com/hormonetrack/HormoneTrackApp.kt
@ -4,12 +4,11 @@ import android.app.Application
 import android.content.Context
 import com.hormonetrack.data.AppDatabase
 import com.hormonetrack.data.repository.HormoneRepository
-import com.hormonetrack.pk.EstrannaiseModels
+import com.hormonetrack.pk.PKProfileStore
 import com.hormonetrack.reminder.createNotificationChannel
 import com.hormonetrack.util.AppLog
 import com.hormonetrack.reminder.AlertNotifier
 import com.hormonetrack.settings.AppSettings
 import com.hormonetrack.data.backup.AutoBackupScheduler
 class HormoneTrackApp : Application() {
@ -19,10 +18,7 @@ class HormoneTrackApp : Application() {
    override fun onCreate() {
        super.onCreate()
        container = AppContainer(this)
-        // v1.9.0 : les tables ODS ne sont plus chargées au démarrage (le
+        PKProfileStore.init(this)
        // runtime ne lit que des sources analytiques). L'asset MCMC
        // (nuage d'incertitude ESE) les remplace (≈ 48 Ko).
        EstrannaiseModels.init(this)
        createNotificationChannel(this)
        AppLog.init(this)
        // v1.4.2 : worker WorkManager PÉRIODIQUE des seuils d'alerte —
@ -35,7 +31,7 @@ class HormoneTrackApp : Application() {
        // le worker sort immédiatement si l'option est désactivée ; cf
        // data/backup/AutoBackupWorker.kt). WorkManager survit aux reboots :
        // BootReceiver n'a rien à faire.
-        AutoBackupScheduler.schedulePeriodic(this)
+        com.hormonetrack.data.backup.AutoBackupScheduler.schedulePeriodic(this)
    }
 }
--- a/app/src/main/java/com/hormonetrack/MainActivity.kt
+++ b/app/src/main/java/com/hormonetrack/MainActivity.kt
@ -10,7 +10,6 @@ import androidx.activity.enableEdgeToEdge
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.appcompat.app.AppCompatActivity
 import androidx.appcompat.app.AppCompatDelegate
 import androidx.compose.runtime.mutableStateOf
 import androidx.core.os.LocaleListCompat
 import androidx.lifecycle.lifecycleScope
 import com.hormonetrack.ui.HormoneTrackRoot
@ -23,17 +22,6 @@ class MainActivity : AppCompatActivity() {
    private val notificationPermissionLauncher =
        registerForActivityResult(ActivityResultContracts.RequestPermission()) { }
    /**
     * Demande « logger une dose » venue d'une NOTIFICATION (extra
     * `open_log_dose`/`treatment_id`). Détenu par l'ACTIVITÉ — survit aux
     * changements d'onglets — et consommé UNE FOIS par HomeScreen via
     * [HormoneTrackRoot] (**fix #69 v1.10.0** : l'ancien code passait le
     * paramètre d'intent tel quel à la composition ; quitter l'onglet
     * Accueil détruisait les `remember` locaux, le paramètre lui vivait au
     * niveau activité → le dialog se rouvrait à CHAQUE retour sur l'accueil).
     */
    private val logDoseRequest = mutableStateOf<Long?>(null)
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val container = (application as HormoneTrackApp).container
@ -65,11 +53,15 @@ class MainActivity : AppCompatActivity() {
            }
        }
-        logDoseRequest.value = consumeLogDoseExtras(intent)
+        val openLogDose = intent?.getBooleanExtra("open_log_dose", false) ?: false
        val treatmentId = intent?.getLongExtra("treatment_id", -1L) ?: -1L
        setContent {
            HormoneTrackTheme {
-                HormoneTrackRoot(logDoseRequest = logDoseRequest)
+                HormoneTrackRoot(
                    initialOpenLogDose = openLogDose,
                    initialTreatmentId = treatmentId
                )
            }
        }
    }
@ -77,22 +69,5 @@ class MainActivity : AppCompatActivity() {
    override fun onNewIntent(intent: Intent) {
        super.onNewIntent(intent)
        setIntent(intent)
        // v1.10.0 : un tap sur la notification quand l'app est DÉJÀ ouverte
        // ouvre aussi le dialog (avant : setIntent seul, la demande était
        // silencieusement perdue).
        consumeLogDoseExtras(intent)?.let { logDoseRequest.value = it }
    }
    /**
     * Lit les extras de demande de log puis les RETIRE de l'intent : un
     * recreate de l'activité (rotation, processus restauré) ne doit JAMAIS
     * rouvrir le dialog d'une notification traitée il y a longtemps.
     */
    private fun consumeLogDoseExtras(intent: Intent?): Long? {
        val open = intent?.getBooleanExtra("open_log_dose", false) ?: false
        val id = intent?.getLongExtra("treatment_id", -1L) ?: -1L
        intent?.removeExtra("open_log_dose")
        intent?.removeExtra("treatment_id")
        return if (open && id > 0) id else null
    }
 }
--- a/app/src/main/java/com/hormonetrack/data/backup/AutoBackupWorker.kt
+++ b/app/src/main/java/com/hormonetrack/data/backup/AutoBackupWorker.kt
@ -8,6 +8,7 @@ import androidx.work.OneTimeWorkRequestBuilder
 import androidx.work.PeriodicWorkRequestBuilder
 import androidx.work.WorkManager
 import androidx.work.WorkerParameters
 import com.hormonetrack.data.backup.UserSettings
 import com.hormonetrack.util.AppLog
 import kotlinx.coroutines.flow.first
 import java.util.concurrent.TimeUnit
@ -108,15 +109,13 @@ class AutoBackupWorker(
        val ok = try {
            // MÊME contenu que l'export manuel (format v2 avec paramètres) :
            // un auto-backup est importable tel quel (rétrocompat assurée)
            // UNE seule collecte des seuils (même motif que l'export manuel)
            val thresholds = settings.alertThresholds.first()
            val userSettings = UserSettings(
                language = settings.language.first(),
                autoCalibrate = settings.autoCalibrate.first(),
-                alertE2High = thresholds.e2High,
+                alertE2High = settings.alertThresholds.first().e2High,
-                alertE2Low = thresholds.e2Low,
+                alertE2Low = settings.alertThresholds.first().e2Low,
-                alertTHigh = thresholds.tHigh,
+                alertTHigh = settings.alertThresholds.first().tHigh,
-                alertTLow = thresholds.tLow
+                alertTLow = settings.alertThresholds.first().tLow
            )
            val json = BackupManager.exportJson(container.repository, settings.tConfig.first(), userSettings)
            val keep = settings.autoBackupKeep.first()
--- a/app/src/main/java/com/hormonetrack/data/backup/BackupManager.kt
+++ b/app/src/main/java/com/hormonetrack/data/backup/BackupManager.kt
@ -36,12 +36,7 @@ data class UserSettings(
    val alertE2High: Double? = null,
    val alertE2Low: Double? = null,
    val alertTHigh: Double? = null,
-    val alertTLow: Double? = null,
+    val alertTLow: Double? = null
    // v1.13.0 : cible de creux E2 (opt-in) — champs NULLABLES pour la
    // rétrocompatibilité : un backup v1/v2 antérieur ne les a pas → Gson
    // les laisse à null → l'import ne touche pas à la cible locale.
    val troughTargetLow: Double? = null,
    val troughTargetHigh: Double? = null
 )
 data class BackupData(
--- a/app/src/main/java/com/hormonetrack/data/dao/DoseLogDao.kt
+++ b/app/src/main/java/com/hormonetrack/data/dao/DoseLogDao.kt
@ -9,9 +9,17 @@ interface DoseLogDao {
    @Query("SELECT * FROM dose_logs ORDER BY timestamp DESC")
    fun getAll(): Flow<List<DoseLog>>
    @Query("SELECT * FROM dose_logs WHERE treatmentId = :treatmentId ORDER BY timestamp DESC")
    fun getByTreatment(treatmentId: Long): Flow<List<DoseLog>>
    @Query("SELECT * FROM dose_logs WHERE timestamp BETWEEN :start AND :end ORDER BY timestamp ASC")
    fun getByTimeRange(start: Long, end: Long): Flow<List<DoseLog>>
    @Query("SELECT * FROM dose_logs WHERE treatmentId = :treatmentId AND timestamp BETWEEN :start AND :end ORDER BY timestamp ASC")
    fun getByTreatmentAndTimeRange(treatmentId: Long, start: Long, end: Long): Flow<List<DoseLog>>
    @Query("SELECT * FROM dose_logs ORDER BY timestamp DESC LIMIT 1")
    fun getLatest(): Flow<DoseLog?>
    @Query("SELECT * FROM dose_logs ORDER BY timestamp ASC")
    suspend fun getAllOnce(): List<DoseLog>
--- a/app/src/main/java/com/hormonetrack/data/dao/LabResultDao.kt
+++ b/app/src/main/java/com/hormonetrack/data/dao/LabResultDao.kt
@ -9,7 +9,11 @@ interface LabResultDao {
    @Query("SELECT * FROM lab_results ORDER BY timestamp DESC")
    fun getAll(): Flow<List<LabResult>>
    @Query("SELECT * FROM lab_results WHERE marker = :marker ORDER BY timestamp DESC")
    fun getByMarker(marker: String): Flow<List<LabResult>>
    @Query("SELECT * FROM lab_results WHERE timestamp BETWEEN :start AND :end ORDER BY timestamp ASC")
    fun getByTimeRange(start: Long, end: Long): Flow<List<LabResult>>
    @Query("SELECT * FROM lab_results ORDER BY timestamp ASC")
    suspend fun getAllOnce(): List<LabResult>
--- a/app/src/main/java/com/hormonetrack/data/dao/TreatmentDao.kt
+++ b/app/src/main/java/com/hormonetrack/data/dao/TreatmentDao.kt
@ -15,6 +15,9 @@ interface TreatmentDao {
    @Query("SELECT * FROM treatments WHERE id = :id")
    suspend fun getById(id: Long): Treatment?
    @Query("SELECT * FROM treatments WHERE isActive = 1 ORDER BY createdAt DESC")
    suspend fun getActiveOnce(): List<Treatment>
    @Query("SELECT * FROM treatments ORDER BY createdAt DESC")
    suspend fun getAllOnce(): List<Treatment>
@ -32,4 +35,6 @@ interface TreatmentDao {
    @Delete
    suspend fun delete(treatment: Treatment)
    @Query("UPDATE treatments SET isActive = :active WHERE id = :id")
    suspend fun setActive(id: Long, active: Boolean)
 }
--- a/app/src/main/java/com/hormonetrack/data/model/PKPresets.kt
+++ b/app/src/main/java/com/hormonetrack/data/model/PKPresets.kt
@ -18,8 +18,7 @@ data class PKPreset(
 object PKPresets {
    val all: List<PKPreset> = listOf(
-        // --- Injections : modèle Estrannaise ANALYTIQUE (v1.9.0 — la
+        // --- Injections: Estrannaise models (profiles from the ODS) ---
        //     source est estrannaise.js, plus de tables ODS au runtime) ---
        PKPreset(
            nameRes = R.string.preset_ev_ese,
            type = TreatmentType.ESTRADIOL,
@ -47,39 +46,6 @@ object PKPresets {
            absorptionHours = 152f, eliminationHalfLifeHours = 150f, bioavailabilityFraction = 1f,
            defaultDoseUnit = "mg", defaultDoseAmount = 10.0
        ),
        // --- v1.9.4 : le modèle ESE est ANALYTIQUE (estrannaise.js, cf
        //     pk/EstrannaiseModels.kt) et couvre 6 esters injectables —
        //     presets ajoutés pour EC (huile), EB et EUCS (undécylate
        //     suspension cristalline, exclusif à ce fit). Champs Bateman =
        //     t½ terminales des fits (informatifs, pas utilisés au calcul —
        //     le dispatch passe par la forme close).
        PKPreset(
            nameRes = R.string.preset_ec_ese,
            type = TreatmentType.ESTRADIOL,
            route = AdministrationRoute.INJECTION_IM,
            esterType = Esters.EC,
            pkModel = PKModels.ESTRANNAISE,
            absorptionHours = 7f, eliminationHalfLifeHours = 202f, bioavailabilityFraction = 1f,
            defaultDoseUnit = "mg", defaultDoseAmount = 5.0
        ),
        PKPreset(
            nameRes = R.string.preset_eb_ese,
            type = TreatmentType.ESTRADIOL,
            route = AdministrationRoute.INJECTION_IM,
            esterType = Esters.EB,
            pkModel = PKModels.ESTRANNAISE,
            absorptionHours = 1f, eliminationHalfLifeHours = 4f, bioavailabilityFraction = 1f,
            defaultDoseUnit = "mg", defaultDoseAmount = 1.0
        ),
        PKPreset(
            nameRes = R.string.preset_eucs_ese,
            type = TreatmentType.ESTRADIOL,
            route = AdministrationRoute.INJECTION_SUBCUT,
            esterType = Esters.EUCS,
            pkModel = PKModels.ESTRANNAISE,
            absorptionHours = 22f, eliminationHalfLifeHours = 756f, bioavailabilityFraction = 1f,
            defaultDoseUnit = "mg", defaultDoseAmount = 10.0
        ),
        // --- Injections: Transfem Science models ---
        PKPreset(
            nameRes = R.string.preset_ev_tfs,
--- a/app/src/main/java/com/hormonetrack/data/model/Treatment.kt
+++ b/app/src/main/java/com/hormonetrack/data/model/Treatment.kt
@ -16,30 +16,20 @@ object Esters {
    const val EC = "EC"   // cypionate, solution huileuse
    const val ECS = "ECS" // cypionate, suspension aqueuse (microcristaux)
    const val PEP = "PEP" // polyestradiol phosphate
    // v1.9.0 : undécylate en SUSPENSION CRISTALLINE — couvert par le modèle
    // Estrannaise ANALYTIQUE (estrannaise.js « EUn casubq ») ; ni TFS ni les
    // tables ODS ne le couvrent.
    const val EUCS = "EUCS"
    /** Esters injectables proposables par ester (override par dose). */
-    val INJECTABLE: List<String> = listOf(EV, EU, EEN, EB, EC, ECS, PEP, EUCS)
+    val INJECTABLE: List<String> = listOf(EV, EU, EEN, EB, EC, ECS, PEP)
    /**
     * Esters proposables dans l'override par dose pour un MODÈLE PK donné
     * (v1.4.6, cf DoseDialog) : la liste suit la couverture du modèle —
     * TFS (V3C méta-analyse) → les 7 esters ; WHSAH (fit Mona) → les 6
-     * (PEP non couvert par ce fit) ; ESE (Estrannaise ANALYTIQUE v1.9.0)
+     * (PEP non couvert par ce fit) ; Estrannaise (tables ODS) → EV/EU/EEn
-     * → les 6 injectables du fit estrannaise.js (dont EUCS, exclusif) ;
+     * seulement (un traitement ESE + EB produirait 0 pg/mL).
     * les tables ODS historiques n'en couvraient que 3 (EV/EU/EEn).
     */
    fun choicesForModel(pkModel: String): List<String> = when (pkModel) {
-        // ⚠️ TFS = liste EXPLICITE (fix v1.8.2-étendu) : INJECTABLE a gagné
+        PKModels.TRANSFEM_SCIENCE -> INJECTABLE
        // EUCS (couvert par l'Estrannaise analytique) mais le V3C TFS n'a PAS
        // de paramètres pour EUCS → le dispatcher donnerait 0. Chaque liste
        // reflète la couverture RÉELLE de son modèle.
        PKModels.TRANSFEM_SCIENCE -> listOf(EV, EU, EEN, EB, EC, ECS, PEP)
        PKModels.WHSAH -> listOf(EV, EU, EEN, EB, EC, ECS)
        PKModels.ESTRANNAISE -> listOf(EV, EU, EEN, EC, EB, EUCS)
        else -> listOf(EV, EU, EEN)
    }
 }
@ -94,8 +84,7 @@ data class Treatment(
    val isActive: Boolean = true,
    val notes: String? = null,
-    // PK: analytical models for injections — Estrannaise (v1.9.0, 6 esters),
+    // PK: lookup-table model for injections (EV/EU/EEn from Estrannaise / Transfem Science)
    // Transfem Science (V3C, 7), WHSAH (6); see Esters.choicesForModel().
    val esterType: String = Esters.NONE,
    val pkModel: String = PKModels.ESTRANNAISE,
@ -126,9 +115,6 @@ data class Treatment(
 ) {
    val isInjection: Boolean
        get() = route == AdministrationRoute.INJECTION_IM || route == AdministrationRoute.INJECTION_SUBCUT
        // (redondant avec PharmacokineticEngine.isInjectionRoute — volontaire :
        // data.model ne doit PAS dépendre de pk (cycle de couches). Si la
        // définition d'« injectable » change, changer les DEUX endroits.)
    val usesProfileModel: Boolean
        get() = isInjection && esterType != Esters.NONE
--- a/app/src/main/java/com/hormonetrack/data/repository/HormoneRepository.kt
+++ b/app/src/main/java/com/hormonetrack/data/repository/HormoneRepository.kt
@ -18,6 +18,15 @@ class HormoneRepository(
    val allDoseLogs: Flow<List<DoseLog>> = doseLogDao.getAll()
    val allLabResults: Flow<List<LabResult>> = labResultDao.getAll()
    fun getDosesByTimeRange(start: Long, end: Long): Flow<List<DoseLog>> =
        doseLogDao.getByTimeRange(start, end)
    fun getDosesByTreatmentAndTimeRange(treatmentId: Long, start: Long, end: Long): Flow<List<DoseLog>> =
        doseLogDao.getByTreatmentAndTimeRange(treatmentId, start, end)
    fun getLabsByMarker(marker: String): Flow<List<LabResult>> =
        labResultDao.getByMarker(marker)
    suspend fun getTreatmentById(id: Long): Treatment? = treatmentDao.getById(id)
    suspend fun allTreatmentsOnce(): List<Treatment> = treatmentDao.getAllOnce()
--- a/app/src/main/java/com/hormonetrack/pk/EstrannaiseCloud.kt
+++ b/app/src/main/java/com/hormonetrack/pk/EstrannaiseCloud.kt
@ -1,163 +0,0 @@
 package com.hormonetrack.pk
 import com.hormonetrack.data.model.DoseLog
 import com.hormonetrack.data.model.PKModels
 import com.hormonetrack.data.model.Treatment
 import com.hormonetrack.data.model.TreatmentType
 /**
 * NUAGE D'INCERTITUDE (v1.9.0) — feature **exclusive au modèle ESE**.
 *
 * SOURCE : Estrannaise publie le **posterior MCMC** de ses paramètres
 * (313 échantillons `(d, k1, k2, k3)` par ester injectable — cf
 * [EstrannaiseModels]). Le graphique de simulation peut dessiner un
 * **nuage diffus** : M courbes (une par échantillon échelonné) qui montrent
 * la plage d'imprécision possible du modèle — exactement l'affichage du
 * site estrannaise. TFS/WHSAH ne publient pas de posterior → pas de nuage
 * pour eux (choix confirmé : le nuage reste sur ESE).
 *
 * QUELLES DOSES LE NUAGE COUVRE-T-IL (v1.9.2) : **toutes les doses E2 à
 * profil injectable dont l'ESTER EFFECTIF (override compris) est couvert
 * par le fit Estrannaise** — c'est exactement l'ensemble des doses que la
 * courbe ESE trace (`computeCurve(modelOverride = "ESE")`). Le `pkModel`
 * STOCKÉ du traitement n'importe pas : quand le chip Nuage est actif avec
 * ESE affiché, la courbe ESE redessine toutes ces doses avec le modèle
 * Estrannaise, et le nuage les redessine avec les paramètres MCMC de
 * LEUR ester. (Fix v1.9.2 : l'ancien filtre `pkModel stocké == ESE`
 * laissait le nuage vide dès qu'aucun traitement n'était stocké en ESE —
 * remontée : « le nuage ne s'active que autour du tracé émulé, pas autour
 * du modèle Estrannaise ». L'exclusivité ESE reste portée par le CHIP,
 * pas par le filtre des doses.)
 *
 * Les contributions Bateman (oral/gel — sans ester échantillonnable) ne
 * sont PAS dans le nuage : le posterior MCMC ne s'applique qu'aux esters
 * (limite documentée — le nuage montre l'incertitude du modèle
 * Estrannaise, pas le niveau total).
 *
 * DÉTERMINISME : les M échantillons sont **échelonnés** (stride sur les
 * 313, pas d'aléatoire) — le nuage est identique à chaque affichage et
 * testable en JVM (c'est aussi la reproducibilité du site, qui tire au
 * hasard à chaque trace, lui).
 *
 * PUR (aucune dépendance Android) → testable en JVM (EstrannaiseCloudTest).
 */
 object EstrannaiseCloud {
    /**
     * Nombre de courbes du nuage : assez pour une plage visuellement
     * « diffuse » (le site en trace des centaines, mais 32 échantillons
     * échelonnés couvrent déjà l'étendue du posterior à un coût ×32 sur le
     * calcul — le pas de la grille reste 1 h).
     */
    const val DEFAULT_NB_CURVES = 32
    /**
     * Calcule le nuage d'incertitude.
     *
     * @param treatments TOUS les traitements (actifs ET inactifs, §6.bis)
     * @param doseLogs   toutes les doses réelles
     * @param startMs/endMs fenêtre demandée (celle du graphique)
     * @param stepMs     pas de la grille (stepForRange)
     * @param nbCurves   nombre de courbes du nuage (défaut [DEFAULT_NB_CURVES])
     * @return M listes de points (M = [nbCurves]) — **vide** si rien n'est
     *   calculable : aucune dose E2 à profil injectable dont l'ester
     *   effectif est couvert par le fit Estrannaise (v1.9.2 :
     *   indépendamment du pkModel stocké), aucune dose, ou MCMC non chargé.
     */
    fun compute(
        treatments: List<Treatment>,
        doseLogs: List<DoseLog>,
        startMs: Long,
        endMs: Long,
        stepMs: Long,
        nbCurves: Int = DEFAULT_NB_CURVES,
        /**
         * Calibration à appliquer au nuage (v1.9.1 — fix « le nuage ne
         * s'active que autour du tracé émulé, pas autour du modèle
         * Estrannaise ») : la courbe ESE affichée est CALIBRÉE
         * (scalePerEster des labs) mais le nuage était tracé BRUT → les deux
         * flottaient à des échelles différentes. Passer le MÊME
         * `scalePerEster` que la courbe ESE (autoByModel["ESE"]?.esterScales
         * côté ChartScreen) pour que le nuage ENTOURE la courbe.
         */
        scalePerEster: Map<String, Double>? = null
    ): List<List<LevelPoint>> {
        if (startMs >= endMs || stepMs <= 0 || nbCurves < 2) return emptyList()
        // ── Doses tracées par la courbe ESE (v1.9.2) ─────────────────────────
        // Toutes les doses E2 à profil injectable dont l'ESTER EFFECTIF
        // (override compris) est couvert par le fit Estrannaise — peu importe
        // le pkModel STOCKÉ du traitement : quand ESE est affiché,
        // computeCurve redessine toutes ces doses avec modelOverride = "ESE"
        // et le nuage doit les suivre (fix v1.9.2 : l'ancien filtre
        // `pkModel stocké == ESE` laissait le nuage vide dès qu'aucun
        // traitement n'était stocké en ESE — remontée : « le nuage ne
        // s'active que autour du tracé émulé, pas autour du modèle
        // Estrannaise ». L'exclusivité ESE reste portée par le CHIP, pas
        // par le filtre des doses). Les doses des traitements inactifs sont
        // incluses (§6.bis : l'inactif reste simulé, la courbe ESE les
        // trace aussi). La couche Bateman (oral/gel sans ester
        // échantillonnable) est naturellement exclue.
        val carrierDoses = ArrayList<Pair<DoseLog, Treatment>>()
        val samplesByEster = HashMap<String, List<EstrannaiseModels.Param>>()
        for (dose in doseLogs) {
            if (dose.timestamp > endMs) continue
            val tr = treatments.firstOrNull { it.id == dose.treatmentId } ?: continue
            if (tr.type != TreatmentType.ESTRADIOL || !tr.usesProfileModel) continue
            val ester = PharmacokineticEngine.doseEster(tr, dose)
            if (!EstrannaiseModels.hasModel(ester)) continue
            if (!samplesByEster.containsKey(ester)) {
                // Posterior MCMC de cet ester (chargé au démarrage) — vide si
                // l'asset n'est pas chargé → pas de nuage (sans posterior,
                // pas de plage d'imprécision à dessiner)
                val samples = EstrannaiseModels.mcmcSamples(ester)
                if (samples.isEmpty()) return emptyList()
                samplesByEster[ester] = samples
            }
            carrierDoses.add(dose to tr)
        }
        if (carrierDoses.isEmpty()) return emptyList()
        // ── Échantillons échelonnés du posterior (déterministes) ─────────────
        // Un échantillon m est appliqué À TOUS les esters du nuage (même
        // index) : le nuage explore le posterior ester par ester, index par
        // index — reproductible.
        val maxSamples = samplesByEster.values.minOf { it.size }
        val stride = (maxSamples.toDouble() / nbCurves.coerceAtMost(maxSamples)).toInt()
            .coerceAtLeast(1)
        // Grille : de max(start, 1ʳᵉ dose du porteur) à endMs — M=0 avant la
        // 1ʳᵉ dose (rien à faire varier)
        val firstDoseMs = carrierDoses.minOf { (dose, _) -> dose.timestamp }
        val t0 = maxOf(startMs, firstDoseMs)
        if (t0 > endMs) return emptyList()
        // ── M courbes ─────────────────────────────────────────────────────────
        val cloud = mutableListOf<List<LevelPoint>>()
        for (m in 0 until nbCurves) {
            val sampleIdx = (m * stride).coerceAtMost(maxSamples - 1)
            val paramsByEster = samplesByEster.mapValues { (_, samples) ->
                samples[sampleIdx.coerceAtMost(samples.size - 1)]
            }
            val curve = mutableListOf<LevelPoint>()
            var t = t0
            while (t <= endMs) {
                var e2 = 0.0
                for ((dose, tr) in carrierDoses) {
                    if (dose.timestamp > t) continue
                    val dtH = (t - dose.timestamp) / 3_600_000.0
                    val ester = PharmacokineticEngine.doseEster(tr, dose)
                    val params = paramsByEster.getValue(ester)
                    // Même calibration que la courbe ESE : le nuage ENTOURE
                    // la courbe calibrée (fix v1.9.1)
                    val scale = scalePerEster?.get(ester) ?: tr.scaleFactor
                    e2 += EstrannaiseModels.sampleWithParams(ester, dtH, params) * dose.doseAmount * scale
                }
                curve.add(LevelPoint(t, e2, 0.0))
                t += stepMs
            }
            if (curve.size >= 2) cloud.add(curve)
        }
        return cloud
    }
 }
--- a/app/src/main/java/com/hormonetrack/pk/EstrannaiseModels.kt
+++ b/app/src/main/java/com/hormonetrack/pk/EstrannaiseModels.kt
@ -1,188 +0,0 @@
 package com.hormonetrack.pk
 import android.content.Context
 import com.google.gson.JsonParser
 import kotlin.math.exp
 import kotlin.math.ln
 /**
 * Modèle **Estrannaise analytique** (v1.9.0) — remplace définitivement les
 * tables horaires ODS.
 *
 * SOURCE ORIGINELLE : le dépôt https://github.com/WHSAH/estrannaise.js/
 * (site estrannaise) — le modèle 3 compartiments avec les paramètres
 * d'ajustement **publiés par Estrannaise** eux-mêmes :
 *
 * ```
 * dB(t)/dt = −k1·B(t)
 * dEE(t)/dt = k1·B(t) − k2·EE(t)
 * dE2(t)/dt = k2·EE(t) − k3·E2(t)
 * ```
 *
 * forme close pour une dose `dose` (mg) à t = 0 (t en JOURS) :
 *
 * ```
 * C(t) = dose · d · k1·k2 · [ e^(−k1·t)/((k1−k2)(k1−k3))
 *                           − e^(−k2·t)/((k1−k2)(k2−k3))
 *                           + e^(−k3·t)/((k1−k3)(k2−k3)) ]
 * ```
 *
 * **FIDÉLITÉ (épinglée par EstrannaiseModelsTest)** : cette forme close
 * reproduit les anciennes tables ODS **à l'identique** (RMS 0,00 sur 0→200 j
 * pour EV/EU/EEn, écart de pic ≤ 0,1 %) — vérifié avant le débranchement :
 * l'ODS n'était que l'échantillonnage horaire de ces formules.
 *
 * **NUAGE D'INCERTITUDE (v1.9.0)** : Estrannaise publie le **posterior
 * MCMC** de ses paramètres (313 échantillons `(d, k1, k2, k3)` par ester,
 * embarqués dans l'asset `mcmc_samples.json` — cf §15). Le graphique peut
 * dessiner un **nuage diffus** de courbes (une par échantillon) qui montre
 * la plage d'imprécision possible du modèle — feature exclusive au modèle
 * ESE (TFS/WHSAH ne publient pas de posterior).
 *
 * POURQUOI CE CHANGEMENT (décision v1.9.0) : « tous les modèles ont
 * maintenant leurs sources originelles — on abandonne complètement les
 * liens avec le fichier ODS, qui lui-même était une extrapolation de ces
 * mêmes sources ». Consequences : plus aucune lecture des tables au
 * runtime (l'asset `pk_profiles.json` reste uniquement pour les tests de
 * fidélité), t½ terminale **analytique** (ln2/min(k1,k2,k3)) au lieu de
 * l'estimation par pente de table.
 *
 * COUVERTURE : 6 esters injectables (EV, EU, EEn, EC, EB, EUCS) — le repo
 * source expose aussi 2 patchs (`patch tw`/`patch ow`) et un cycle
 * menstruel : hors scope v1.9.0 (documenté §7.12/§19).
 *
 * PUR sauf [init]/[initWithJson] (lecture de l'asset MCMC) — la formule
 * elle-même est testable en JVM.
 */
 object EstrannaiseModels {
    /** Paramètres d'un ester : d (facteur), k1/k2/k3 (vitesses, j⁻¹). */
    data class Param(val d: Double, val k1: Double, val k2: Double, val k3: Double) {
        /** t½ terminale ANALYTIQUE : la phase la plus lente domine la queue. */
        val terminalHalfLifeDays: Double
            get() = ln(2.0) / minOf(k1, k2, k3)
    }
    /**
     * Paramètres d'ajustement publiés par Estrannaise (src/modeldata.js,
     * `PKParameters`). Clés = clés esters de l'app. ⚠️ Mapping depuis les
     * clés du repo : « EV im »→EV, « EUn im »→EU, « EEn im »→EEn,
     * « EC im »→EC, « EB im »→EB, « EUn casubq »→EUCS (nouveau code ester
     * v1.9.0 : undécylate en suspension cristalline).
     */
    private val PK_PARAMETERS: Map<String, Param> = mapOf(
        "EV" to Param(478.0, 0.236, 4.85, 1.24),
        "EU" to Param(471.5, 0.01729, 6.528, 2.285),
        "EEN" to Param(191.4, 0.119, 0.601, 0.402),
        "EC" to Param(246.0, 0.0825, 3.57, 0.669),
        "EB" to Param(1893.1, 0.67, 61.5, 4.34),
        "EUCS" to Param(16.15, 0.046, 0.022, 0.101),
    )
    fun hasModel(ester: String): Boolean = PK_PARAMETERS.containsKey(ester.uppercase())
    /** Les paramètres de l'ester, ou null (lookup insensible à la casse). */
    fun model(ester: String): Param? = PK_PARAMETERS[ester.uppercase()]
    /**
     * Réponse normalisée (pg/mL PAR mg) à dtHours après une injection de 1 mg,
     * forme close exacte (cf KDoc de l'objet). dtHours ≤ 0 → 0.
     * ⚠️ Le passage t heures → t jours est fait ici (le modèle travaille en jours).
     */
    fun sample(ester: String, dtHours: Double): Double {
        val m = model(ester) ?: return 0.0
        if (dtHours <= 0.0) return 0.0
        return curveDays(dtHours / 24.0, 1.0, m)
    }
    /**
     * Courbe avec un jeu de paramètres DONNÉ (échantillon MCMC) — utilisé par
     * le nuage d'incertitude : chaque courbe du nuage superpose les doses du
     * porteur ESE avec UN échantillon du posterior. Normalisé par mg comme
     * [sample].
     */
    fun sampleWithParams(ester: String, dtHours: Double, p: Param): Double {
        if (dtHours <= 0.0) return 0.0
        return curveDays(dtHours / 24.0, 1.0, p)
    }
    /**
     * Forme close 3C (t en JOURS) — cas général + les 3 cas dégénérés
     * (taux égaux → dénominateurs nuls : solution limite, portée du JS
     * source de estrannaise.js).
     */
    private fun curveDays(t: Double, dose: Double, m: Param): Double {
        if (t < 0) return 0.0
        var ret = 0.0
        val (d, k1, k2, k3) = m
        if (dose > 0 && d > 0) {
            when {
                k1 == k2 && k2 == k3 ->
                    ret += dose * d * k1 * k1 * t * t * exp(-k1 * t) / 2
                k1 == k2 && k2 != k3 ->
                    ret += dose * d * k1 * k1 * (exp(-k3 * t) - exp(-k1 * t) * (1 + (k1 - k3) * t)) /
                        (k1 - k3) / (k1 - k3)
                k1 != k2 && k1 == k3 ->
                    ret += dose * d * k1 * k2 * (exp(-k2 * t) - exp(-k1 * t) * (1 + (k1 - k2) * t)) /
                        (k1 - k2) / (k1 - k2)
                k1 != k2 && k2 == k3 ->
                    ret += dose * d * k1 * k2 * (exp(-k1 * t) - exp(-k2 * t) * (1 - (k1 - k2) * t)) /
                        (k1 - k2) / (k1 - k2)
                else ->
                    ret += dose * d * k1 * k2 * (
                        exp(-k1 * t) / (k1 - k2) / (k1 - k3) -
                            exp(-k2 * t) / (k1 - k2) / (k2 - k3) +
                            exp(-k3 * t) / (k1 - k3) / (k2 - k3)
                        )
            }
        }
        return if (ret.isNaN()) 0.0 else ret
    }
    // ── Posterior MCMC (nuage d'incertitude) ────────────────────────────────
    @Volatile
    private var mcmc: Map<String, List<Param>>? = null
    /**
     * Charge le posterior MCMC depuis l'asset `mcmc_samples.json`
     * (313 échantillons `(d, k1, k2, k3)` par ester injectable — cf §15).
     * Appelé au démarrage ([com.hormonetrack.HormoneTrackApp]) — le nuage
     * n'en a besoin qu'au premier affichage, mais le chargement est court
     * (≈ 48 Ko) et évite un état « chip actif sans données ».
     */
    fun init(context: Context) {
        if (mcmc != null) return
        synchronized(this) {
            if (mcmc != null) return
            val json = context.assets.open("mcmc_samples.json").bufferedReader().use { it.readText() }
            initWithJson(json)
        }
    }
    /** Point d'entrée testable (JVM) — même pattern que PKProfileStore.initWithJson. */
    fun initWithJson(json: String) {
        synchronized(this) {
            val root = JsonParser.parseString(json).asJsonObject
            val parsed = LinkedHashMap<String, List<Param>>()
            for ((ester, value) in root.entrySet()) {
                val arr = value.asJsonArray
                val samples = ArrayList<Param>(arr.size())
                for (s in arr) {
                    val e = s.asJsonArray
                    samples.add(Param(e[0].asDouble, e[1].asDouble, e[2].asDouble, e[3].asDouble))
                }
                parsed[ester.uppercase()] = samples
            }
            mcmc = parsed
        }
    }
    /**
     * Les échantillons MCMC d'un ester (vide si l'asset n'est pas chargé ou
     * ester inconnu) — le nuage d'incertitude en tire M jeux de paramètres
     * (échelonnés, déterministes : pas d'aléatoire à chaque frame).
     */
    fun mcmcSamples(ester: String): List<Param> =
        mcmc?.get(ester.uppercase()) ?: emptyList()
 }
--- a/app/src/main/java/com/hormonetrack/pk/LabTiming.kt
+++ b/app/src/main/java/com/hormonetrack/pk/LabTiming.kt
@ -20,31 +20,26 @@ import kotlin.math.ceil
 *     classique des **5 demi-vies terminales** (≈ 97 % de l'équilibre). Après
 *     un changement d'ester/dose/rythme, les prises intermédiaires reflètent
 *     une transition, pas le régime ;
- *  3. **ON SAUTE donc au premier creux STABILISÉ** (décision v1.8.0 ; **fix
+ *  3. **ON SAUTE donc au premier creux STABILISÉ** (décision v1.8.0) : le
- *     #68 v1.10.0** : la stabilisation se juge sur le CREUX lui-même —
+ *     premier créneau d'injection ≥ date de stabilisation du régime courant.
 *     l'instant où la prise de sang serait faite — pas sur le créneau
 *     d'injection qui le suit).
 *
 * CALCUL (tout est déduit de ce que l'app connaît déjà) :
 *  - **traitement porteur** : ESTRADIOL + injectable + ACTIF + Posologie
 *    renseignée (`forecastIntervalDays > 0`) — sans Posologie, pas de creux
 *    prévisible → `null` (la page Analyses affiche alors une invite à la
 *    renseigner) ;
- *  - **t½ terminale** de l'ester : ANALYTIQUE pour les trois modèles
+ *  - **t½ terminale** de l'ester : analytique pour TFS/WHSAH
- *    (TFS/WHSAH : `terminalHalfLifeDays` des fits ; ESE : idem depuis
+ *    (`terminalHalfLifeDays`), lue dans la TABLE pour Estrannaise
- *    v1.9.0 — le modèle Estrannaise est devenu analytique, cf
+ *    ([PKProfileStore.terminalHalfLifeDays] — la pente que l'extrapolation
- *    [EstrannaiseModels]) ;
+ *    de `sample()` utilise déjà) ;
 *  - **début du régime courant** = 1ʳᵉ dose du traitement actif — PROXY
 *    assumé et documenté : l'app ne trace pas l'historique des éditions de
 *    Posologie/dose, la première dose du traitement est le meilleur
 *    estimateur du début du régime (même sémantique que le « temps sous THS ») ;
- *  - **creux** = niveau PRÉ-INJECTION du créneau (dernier point de la courbe
+ *  - **creux** = minimum local de la courbe E2 PRÉVISIONNELLE (doses réelles
- *    E2 prévisionnelle juste avant l'injection — principe 1 ; **fix #68
+ *    + créneaux [PharmacokineticEngine.generateForecastDoses]) entre deux
- *    v1.10.0** : l'ancien minimum de fenêtre entière tombait juste après
+ *    injections. La FORME suffit : calcul SANS calibration (le facteur
- *    l'injection PRÉCÉDENTE pour les esters à montée lente comme l'EEn, dont
+ *    d'échelle est multiplicatif, il ne déplace pas le minimum) ;
 *    le pic ~J+5 avoisine l'intervalle de 7 j). La FORME suffit : calcul
 *    SANS calibration (le facteur d'échelle est multiplicatif, il ne
 *    déplace pas le minimum) ;
 *  - **filtres** : creux ≥ maintenant + [MIN_HORIZON_HOURS] (pas de
 *    recommandation quasi-immédiate), creux > dernière prise de sang
 *    existante (ne jamais recommander un creux déjà mesuré), créneau ≥
@ -77,37 +72,6 @@ object LabTiming {
    /** Un creux à moins de 6 h n'est pas exploitable (organisation d'une prise). */
    const val MIN_HORIZON_HOURS = 6L
    /**
     * Position d'une valeur par rapport à la CIBLE DE CREUX personnelle
     * (v1.13.0, opt-in). ⚠️ DISTINCT des seuils d'alerte (pk/Alerts.kt,
     * §9.bis) : les alertes surveillent le niveau estimé EN CONTINU et
     * notifient ; la cible de creux est une RÉFÉRENCE DE LAB — « quand je
     * pique au creux recommandé, je veux être dans [low, high] » — évaluée
     * en lecture seule sur la carte, JAMAIS de notification.
     */
    enum class TroughTargetStatus { IN_TARGET, BELOW, ABOVE }
    /**
     * Statut de [predictedE2] par rapport à la cible [low, high].
     * `null` si pas de prédiction OU cible incomplète/désactivée.
     * PUR → testable en JVM ; miroir web `troughTargetStatus`
     * (js/pk/lab-timing.js).
     */
    fun troughTargetStatus(
        predictedE2: Double?,
        low: Double?,
        high: Double?
    ): TroughTargetStatus? {
        val value = predictedE2 ?: return null
        val lo = low ?: return null
        val hi = high ?: return null
        return when {
            value < lo -> TroughTargetStatus.BELOW
            value > hi -> TroughTargetStatus.ABOVE
            else -> TroughTargetStatus.IN_TARGET
        }
    }
    /** Résultat : tout ce que l'UI affiche sur la carte de recommandation. */
    data class LabRecommendation(
        /** Date/heure du CREUX exact (minimum prévisionnel entre 2 injections). */
@ -128,15 +92,7 @@ object LabTiming {
         * arrive entre maintenant et le creux recommandé (texte « c'est le
         * premier creux fiable »).
         */
-        val wasAlreadyStabilized: Boolean,
+        val wasAlreadyStabilized: Boolean
        /**
         * E2 ATTENDUE à ce creux (v1.13.0) : valeur brute du modèle ×
         * facteur d'échelle du ester actif — fourni par l'appelant quand
         * la calibration est disponible (auto-calibration ON). `null` =
         * pas de calibration fiable → la carte n'affiche PAS de valeur
         * (honnêteté : une valeur brute non calibrée serait trompeuse).
         */
        val predictedE2: Double? = null
    )
    /**
@ -151,14 +107,7 @@ object LabTiming {
        treatments: List<Treatment>,
        doseLogs: List<DoseLog>,
        labs: List<LabResult>,
-        nowMs: Long = System.currentTimeMillis(),
+        nowMs: Long = System.currentTimeMillis()
        /**
         * Facteurs d'échelle PAR ESTER (v1.13.0) — issus de l'auto-calibration
         * quand elle est activée (sinon `null`) : permet de retourner la
         * valeur E2 ATTENDUE au creux ([LabRecommendation.predictedE2]).
         * Absent → `predictedE2 = null` (carte sans valeur).
         */
        scalePerEster: Map<String, Double>? = null
    ): LabRecommendation? {
        // ── 1) Traitement PORTEUR : E2 + injectable + actif + Posologie ─────
        val carrier = treatments.firstOrNull {
@ -171,27 +120,24 @@ object LabTiming {
        // ── 2) t½ terminale de l'ester (analytique ou lue dans la table) ────
        val tHalfDays = when (carrier.pkModel) {
            PKModels.TRANSFEM_SCIENCE ->
-                TransfemScienceModels.model(carrier.esterType)?.terminalHalfLifeDays
+                com.hormonetrack.pk.TransfemScienceModels.model(carrier.esterType)?.terminalHalfLifeDays
            PKModels.WHSAH ->
-                WhsahModels.model(carrier.esterType)?.terminalHalfLifeDays
+                com.hormonetrack.pk.WhsahModels.model(carrier.esterType)?.terminalHalfLifeDays
            // v1.9.0 : ESE analytique (forme close estrannaise.js) — la t½
            // n'est plus estimée par pente de table
            PKModels.ESTRANNAISE ->
-                EstrannaiseModels.model(carrier.esterType)?.terminalHalfLifeDays
+                PKProfileStore.terminalHalfLifeDays(carrier.esterType, carrier.pkModel)
            else -> null
        } ?: return null
        // ── 3) Début du régime courant + date de stabilisation ──────────────
        val myDoses = doseLogs.filter { it.treatmentId == carrier.id }
        if (myDoses.isEmpty()) return null
        val regimeStartMs = regimeStartMs(carrier, myDoses)
        val stabilizedAtMs = regimeStartMs +
            (STABILIZATION_HALF_LIVES * tHalfDays * 24.0 * 3_600_000.0).toLong()
        // Ester EFFECTIF de la dernière dose (override compris) : c'est lui
        // qui gouverne les creux futurs et le texte de la carte
        val lastDose = myDoses.maxByOrNull { it.timestamp }!!
        val activeEster = PharmacokineticEngine.doseEster(carrier, lastDose)
        // v1.13.0 : régime POOLÉ (cf [pooledRegimeDoses]) — le re-parenting
        // d'historique entre traitements (ex. « 6d - old » créé a posteriori,
        // remontée v1.12.0) ne doit pas faire croire à un nouveau régime.
        val regimeStart = regimeStartMs(carrier, pooledRegimeDoses(carrier, doseLogs, treatments))
        val stabilizedAtMs = regimeStart +
            (STABILIZATION_HALF_LIVES * tHalfDays * 24.0 * 3_600_000.0).toLong()
        // ── 4) Créneaux prévisionnels : assez pour couvrir la stabilisation ──
        val intervalDays = carrier.forecastIntervalDays!!
@ -217,47 +163,25 @@ object LabTiming {
        val minTroughMs = nowMs + MIN_HORIZON_HOURS * 3_600_000L
        var windowStart = nowMs
        for (slot in slots) {
-            // ⚠️ FIX #68 (v1.10.0) : le creux = niveau PRÉ-INJECTION du
+            // Le creux du créneau = minimum de la courbe entre l'injection
-            // créneau (dernier point de courbe avant l'injection — principe 1,
+            // précédente (ou maintenant) et ce créneau
-            // « le moment le plus comparable »). L'ancien MINIMUM DE LA
+            val window = curve.filter { it.timestamp > windowStart && it.timestamp < slot.timestamp }
-            // FENÊTRE ENTIÈRE tombait au DÉBUT de la fenêtre pour les esters
+            val trough = window.minByOrNull { it.e2 }
            // à montée lente (EEn : pic ~J+5 ≈ intervalle 7 j → le minimum
            // local est le creux d'absorption, quelques heures après
            // l'injection PRÉCÉDENTE) : la date proposée précédait la
            // stabilisation affichée sur la MÊME carte, et le texte
            // « juste avant ton injection du … » était faux de plusieurs
            // jours (remontée v1.9.8, épinglé par RegressionUserCase6Test).
            // Pour les esters à t½ courte (EV), le point pré-injection EST
            // le minimum de fenêtre : comportement inchangé.
            val trough = curve.lastOrNull {
                it.timestamp > windowStart && it.timestamp < slot.timestamp
            }
            if (trough != null &&
                trough.timestamp >= minTroughMs &&
                trough.timestamp > lastLabMs &&
                // ON SAUTE au premier creux stabilisé (décision v1.8.0) :
-                // le creux pré-injection ≈ instant du créneau, le garde
+                // le creux d'un créneau est stabilisé si le CRÉNEAU l'est
-                // exprime la stabilisation sur l'instant réellement proposé
+                slot.timestamp >= stabilizedAtMs
                // pour la prise de sang (trough < slot de ~1 pas de courbe).
                trough.timestamp >= stabilizedAtMs
            ) {
                return LabRecommendation(
                    troughMs = trough.timestamp,
                    injectionMs = slot.timestamp,
                    ester = activeEster,
                    terminalHalfLifeDays = tHalfDays,
-                    regimeStartMs = regimeStart,
+                    regimeStartMs = regimeStartMs,
                    stabilizedAtMs = stabilizedAtMs,
-                    wasAlreadyStabilized = stabilizedAtMs <= nowMs,
+                    wasAlreadyStabilized = stabilizedAtMs <= nowMs
                    // v1.13.0 : E2 attendue au creux = valeur brute du
                    // modèle × facteur du ester actif (lookup insensible à
                    // la casse — les clés de scalePerEster suivent les
                    // esters stockés). null si pas de calibration.
                    predictedE2 = scalePerEster
                        ?.entries
                        ?.firstOrNull { it.key.equals(activeEster, ignoreCase = true) }
                        ?.value
                        ?.let { scale -> trough.e2 * scale }
                )
            }
            windowStart = slot.timestamp
@ -268,61 +192,6 @@ object LabTiming {
    /** Tolérance de comparaison des doses (mg) — évite les faux changements d'arrondi. */
    private const val DOSE_EPS = 1e-6
    /**
     * SÉQUENCE DE RÉGIME POOLÉE (v1.13.0) : toutes les doses de TOUS les
     * traitements partageant l'**ester effectif** du porteur ET son **mg
     * exact** (± [DOSE_EPS]), triées par timestamp.
     *
     * **Pourquoi** (remontée v1.12.0) : le re-parenting d'historique — créer
     * un traitement « … - old » inactif et y déplacer des doses (ex. séparer
     * une ère « 6 j » d'une ère « 7 j ») — créait un TROU synthétique dans
     * l'historique du porteur : le régime redémarrait à la date du
     * re-parenting et la stabilisation (5 × t½) repartait de plusieurs
     * semaines, alors que pharmacologiquement rien n'avait changé (même
     * ester, même dose).
     *
     * Garde-fous (épinglés par tests) :
     *  - **ester ≠ → pas de mutualisation** (transition EV → EEn : deux
     *    régimes distincts — régression n°3) ;
     *  - **dose ≠ → exclue du pool** (une dose « 8 mg » au milieu d'un
     *    régime « 5 mg » casse naturellement la séquence via le trou qui
     *    suit — conservateur, ~1 semaine du côté prudent).
     *
     * PUR → testable en JVM (DosesExtras? non — LabTimingTest +
     * RegressionUserCase7Test) ; miroir web `pooledRegimeDoses`
     * (js/pk/lab-timing.js).
     */
    internal fun pooledRegimeDoses(
        carrier: Treatment,
        allDoseLogs: List<DoseLog>,
        allTreatments: List<Treatment>
    ): List<DoseLog> {
        val last = allDoseLogs
            .filter { it.treatmentId == carrier.id }
            .maxByOrNull { it.timestamp } ?: return emptyList()
        val activeEster = PharmacokineticEngine.doseEster(carrier, last)
        val amount = last.doseAmount
        val ownerById = allTreatments.associateBy { it.id }
        return allDoseLogs
            .filter { d ->
                // Ester EFFECTIF via le traitement PROPRIÉTAIRE de la dose
                // (override par dose compris) — jamais via le porteur
                val owner = ownerById[d.treatmentId] ?: return@filter false
                PharmacokineticEngine.doseEster(owner, d) == activeEster &&
                    Math.abs(d.doseAmount - amount) < DOSE_EPS
            }
            .sortedBy { it.timestamp }
    }
    /**
     * Tolérance de l'écart inter-doses du régime (v1.9.7) : ± 24 h autour de
     * l'intervalle de Posologie — « je m'injecte le même jour de la semaine,
     * à l'heure près ». Un log à 12:30 au lieu de 12:00 ne doit pas
     * repousser la stabilisation de 5 × t½ (remontée v1.9.7) ; un vrai
     * changement de créneau (2 j au lieu de 7 j) reste hors fenêtre.
     */
    private val GAP_TOLERANCE_MS = 24L * 3_600_000L
    /**
     * DÉBUT DU RÉGIME COURANT (v1.8.1 — **correction du proxy v1.8.0**).
     *
@ -331,35 +200,25 @@ object LabTiming {
     * depuis février" » — l'ancien proxy (1ʳᵉ dose du traitement) ne voyait
     * PAS les changements récents de dose ni d'intervalle.
     *
-     * **Critique remontée** (v1.9.7) : « la suggestion de prochaine prise de
+     * **NOUVELLE RÈGLE** : le régime courant = la **séquence terminale de
-     * sang change tout le temps à chaque injection si l'injection n'est pas
+     * doses** où (a) l'**ester effectif** et la **dose (mg)** sont identiques
-     * faite pile à la même heure » — la comparaison EXACTE de v1.8.1 (écart
+     * à celles de la dose la plus récente, ET (b) **l'écart entre doses
-     * identique au ms près) cassait le régime pour un log à 12:30 au lieu de
+     * consécutives est constant** (= l'écart des deux doses les plus
-     * 12:00, repoussant la stabilisation de 5 × t½ à CHAQUE injection : le
+     * récentes). On remonte depuis la dose la plus récente tant que ces
-     * creux recommandé fuyait vers l'avant sans jamais se fixer.
+     * conditions tiennent ; le régime commence à la dose la plus ancienne
-     *
+     * de la séquence.
     * **RÈGLE** : le régime courant = la **séquence terminale de doses**
     * (v1.13.0 : **poolée** entre traitements — cf [pooledRegimeDoses] — le
     * re-parenting d'historique ne doit plus redémarrer la stabilisation)
     * où (a) l'**ester effectif** et la **dose (mg)** sont identiques à
     * celles de la dose la plus récente, ET (b) chaque **écart entre doses
     * consécutives reste dans l'INTERVALLE DE POSOLOGIE ± 24 h**
     * ([GAP_TOLERANCE_MS] — « je m'injecte le même jour, à l'heure près »).
     * On remonte depuis la dose la plus récente tant que ces conditions
     * tiennent ; le régime commence à la dose la plus ancienne de la
     * séquence.
     *
     * Pourquoi chaque composante :
     *  - **ester effectif** (override par dose compris) : un switch EV → EEn
     *    réinitialise la stabilisation ;
     *  - **doseAmount** : 3 mg → 5 mg change le niveau d'équilibre ;
-     *  - **écart ≈ intervalle de Posologie ± 24 h** : le trough n'est
+     *  - **écart inter-doses constant** : 7 j → 2 j → 9 j (posologie
-     *    comparable que sur un intervalle régulier (pharmacocinétique), mais
+     *    modifiée/irrégulière) change le creux — conservateur : une série
-     *    l'heure de log RÉELLE d'une humaine varie — un écart 7 j ± 23 h EST
+     *    d'intervalles chaotiques maintient la carte « non stabilisée », ce
-     *    le même régime ; 7 j + 25 h (ou un vrai passage à 2 j = 48 h, hors
+     *    qui est pharmacocinétiquement vrai (le trough n'est comparable que
-     *    fenêtre) casse le régime. La fenêtre se réfère à l'INTERVALLE
+     *    sur un intervalle régulier). La comparaison est EXACTE (arrondi au
-     *    THÉORIQUE (Posologie), pas à l'écart précédent : des logs à 6,8 j
+     *    ms) : un écart 7 j → 7 j ± 1 h casse le régime, ce qui reflète un
-     *    puis 7,2 j ne se déstabilisent plus en cascade.
+     *    vrai changement de créneau.
     *
     * @param carrier traitement porteur (injectable E2 actif à Posologie)
     * @param myDoses doses du porteur (ordre indifférent)
@ -370,23 +229,18 @@ object LabTiming {
        var idx = sorted.size - 1
        var regimeStart = sorted[idx].timestamp
        var current = sorted[idx]
-        // Fenêtre d'écart = INTERVALLE DE POSOLOGIE ± tolérance (v1.9.7 —
+        // Écart EXIGÉ pour remonter : celui des deux doses les plus récentes
-        // remplace la comparaison exacte v1.8.1 qui cassait le régime à
+        // (inconnu si une seule dose — la séquence s'arrête là de toute façon)
-        // chaque variation d'heure de log). La Posologie est un prérequis de
+        var gapExpected = -1L
        // la carte : absente → on s'arrête à la dernière dose (dégradé).
        val intervalDays = carrier.forecastIntervalDays ?: return regimeStart
        val intervalMs = (intervalDays * 24.0 * 3_600_000.0).toLong()
        val gapMin = intervalMs - GAP_TOLERANCE_MS
        val gapMax = intervalMs + GAP_TOLERANCE_MS
        while (idx > 0) {
            val prev = sorted[idx - 1]
            val gap = current.timestamp - prev.timestamp
            val sameMarker = PharmacokineticEngine.doseEster(carrier, current) == PharmacokineticEngine.doseEster(carrier, prev) &&
                Math.abs(current.doseAmount - prev.doseAmount) < DOSE_EPS
-            // Remonter seulement si même (ester, dose) ET écart dans la
+            // Remonter seulement si même (ester, dose) ET même écart
-            // fenêtre (gap > 0 : un doublon de log n'est jamais un régime)
+            val sameGap = gapExpected < 0L || gap == gapExpected
            val sameGap = gap > 0 && gap in gapMin..gapMax
            if (!sameMarker || !sameGap) break
            gapExpected = gap
            regimeStart = prev.timestamp
            current = prev
            idx--
--- a/app/src/main/java/com/hormonetrack/pk/LabTrajectoryModel.kt
+++ b/app/src/main/java/com/hormonetrack/pk/LabTrajectoryModel.kt
@ -2,6 +2,7 @@ package com.hormonetrack.pk
 import com.hormonetrack.data.model.DoseLog
 import com.hormonetrack.data.model.LabResult
 import com.hormonetrack.data.model.PKModels
 import com.hormonetrack.data.model.Treatment
 import com.hormonetrack.data.model.TreatmentType
 import kotlin.math.exp
@ -178,19 +179,17 @@ object LabTrajectoryModel {
        if (estrogenTreatments.isEmpty()) return AnchoredCurve(emptyList(), 0)
        // Prédictions BRUTES : scaleFactor forcé à 1 (le ρ du lab EST le
-        // facteur — combiner avec le facteur stocké = double correction).
+        // facteur — combiner avec le facteur stocké = double correction)
        // Contexte moteur pré-calculé UNE fois (v1.9.5, audit) : la boucle
        // de grille appelle e2At par point (720 pts) — sans contexte
        // partagé, chaque appel reconstruisait les maps internes.
        val unscaled = estrogenTreatments.map { it.copy(scaleFactor = 1.0) }
        val e2Ctx = PharmacokineticEngine.prepareE2Context(unscaled, doseLogs)
        // ── 1) Timeline des ANCRAGES (labs croissants + garde #61) ───────────
        // Un couple (t_lab, ratio) par lab significatif, trié croissant.
        val anchors = mutableListOf<Pair<Long, Double>>()
        var maxPredictionSoFar = 0.0
        for (lab in e2Labs.filter { it.marker.equals("E2", ignoreCase = true) }.sortedBy { it.timestamp }) {
-            val predicted = PharmacokineticEngine.e2At(ctx = e2Ctx, tMs = lab.timestamp, modelOverride = modelOverride)
+            val predicted = PharmacokineticEngine.e2At(
                unscaled, doseLogs, lab.timestamp, modelOverride, null
            )
            if (!PharmacokineticEngine.labIsSignificant(predicted, maxPredictionSoFar)) continue
            anchors.add(lab.timestamp to (lab.value / predicted))
            if (predicted > maxPredictionSoFar) maxPredictionSoFar = predicted
@ -222,7 +221,7 @@ object LabTrajectoryModel {
        val points = mutableListOf<LevelPoint>()
        var t = t0
        while (t <= t1) {
-            val m = PharmacokineticEngine.e2At(e2Ctx, t, modelOverride)
+            val m = PharmacokineticEngine.e2At(unscaled, doseLogs, t, modelOverride, null)
            val rho = ratioAt(anchors, t)
            points.add(LevelPoint(t, m * rho, 0.0)) // t=0 : pas de courbe T pour cette série
            t += stepMs
--- a/app/src/main/java/com/hormonetrack/pk/PKProfileStore.kt
+++ b/app/src/main/java/com/hormonetrack/pk/PKProfileStore.kt
@ -1,22 +1,8 @@
 package com.hormonetrack.pk
 import android.content.Context
 import com.google.gson.JsonParser
 import com.hormonetrack.data.model.PKModels
 import kotlin.math.ln
 /**
 * ⚠️ v1.9.0 : ce lecteur de tables ODS n'est PLUS UTILISÉ AU RUNTIME —
 * le modèle Estrannaise est devenu ANALYTIQUE (pk/EstrannaiseModels.kt,
 * fidélité aux tables épinglée RMS 0) et tous les dispatchs moteur lisent
 * des sources originelles. Il est conservé UNIQUEMENT pour :
 *  1. le **test de fidélité** (EstrannaiseModelsTest : forme close vs
 *     tables, RMS 0 — garde anti-régression du débranchement) ;
 *  2. le jeu de données historique (`pk_profiles.json`, déplacé en
 *     `src/test/assets/` — l'APK ne l'embarque plus, −550 Ko).
 *
 * L'ancienne [init] (lecture de l'asset au démarrage) a été retirée :
 * [initWithJson] suffit pour les tests.
 */
 object PKProfileStore {
    @Volatile
@ -24,6 +10,15 @@ object PKProfileStore {
    private lateinit var profiles: Map<String, FloatArray>
    fun init(context: Context) {
        if (initialized) return
        synchronized(this) {
            if (initialized) return
            val json = context.assets.open("pk_profiles.json").bufferedReader().use { it.readText() }
            initWithJson(json)
        }
    }
    /** Testable entry point: parse the profiles JSON directly (JVM unit tests). */
    fun initWithJson(json: String) {
        synchronized(this) {
@ -41,7 +36,7 @@ object PKProfileStore {
    }
    fun profileKey(ester: String, model: String): String =
-        "${ester}_${if (model == PKModels.TRANSFEM_SCIENCE) "tfs" else "ese"}"
+        "${ester}_${if (model == com.hormonetrack.data.model.PKModels.TRANSFEM_SCIENCE) "tfs" else "ese"}"
    /**
     * Case-insensitive lookup. The ODS asset keys use the biological casing
@ -61,6 +56,11 @@ object PKProfileStore {
    fun profileLength(ester: String, model: String): Int =
        lookup(profileKey(ester, model))?.size ?: 0
    /**
     * Normalized response (pg/mL per mg injected) at dtHours after a 1 mg injection,
     * linearly interpolated between hourly points; beyond the table, extrapolated
     * with the terminal exponential slope.
     */
    /**
     * Demi-vie TERMINALE (JOURS) estimée depuis la table horaire (v1.8.0) :
     * même logique que l'extrapolation de [sample] (dernier point ≥ 1 % du
@ -80,14 +80,14 @@ object PKProfileStore {
    fun terminalHalfLifeDays(ester: String, model: String): Double? {
        if (!initialized) return null
        val suffix = when (model) {
-            PKModels.TRANSFEM_SCIENCE -> "tfs"
+            com.hormonetrack.data.model.PKModels.TRANSFEM_SCIENCE -> "tfs"
-            PKModels.ESTRANNAISE -> "ese"
+            com.hormonetrack.data.model.PKModels.ESTRANNAISE -> "ese"
            else -> return 0.0
        }
        val arr = lookup("${ester}_$suffix") ?: return null
        val (j, rate) = terminalDecayParameters(arr) ?: return null
        if (rate >= 0.0) return null
-        return ln(2.0) / -rate / 24.0 // pente /h → t½ en jours
+        return kotlin.math.ln(2.0) / -rate / 24.0 // pente /h → t½ en jours
    }
    /**
@ -117,16 +117,11 @@ object PKProfileStore {
        return j to rate
    }
    /**
     * Normalized response (pg/mL per mg injected) at dtHours after a 1 mg injection,
     * linearly interpolated between hourly points; beyond the table, extrapolated
     * with the terminal exponential slope.
     */
    fun sample(ester: String, model: String, dtHours: Double): Double {
        if (!initialized || dtHours <= 0.0) return 0.0
        val suffix = when (model) {
-            PKModels.TRANSFEM_SCIENCE -> "tfs"
+            com.hormonetrack.data.model.PKModels.TRANSFEM_SCIENCE -> "tfs"
-            PKModels.ESTRANNAISE -> "ese"
+            com.hormonetrack.data.model.PKModels.ESTRANNAISE -> "ese"
            else -> return 0.0
        }
        val arr = lookup("${ester}_$suffix") ?: return 0.0
--- a/app/src/main/java/com/hormonetrack/pk/PharmacokineticEngine.kt
+++ b/app/src/main/java/com/hormonetrack/pk/PharmacokineticEngine.kt
@ -88,22 +88,16 @@ object PharmacokineticEngine {
                val model = modelOverride ?: treatment.pkModel
                // v1.4.0 : le modèle Transfem Science utilise les paramètres
                // V3C (3 compartiments) de la méta-analyse TFS, évalués en
-                // forme close.
+                // forme close — les tables ODS restent le fallback (esters
                // sans modèle V3C, ou modèle Estrannaise).
                // v1.4.6 : le modèle WHSAH (fit license-free de Mona) est la
                // 3ᵉ voie de dispatch, au même niveau que TFS.
                // v1.9.0 : l'Estrannaise devient ANALYTIQUE (forme close de
                // estrannaise.js — fidélité aux tables ODS épinglée RMS 0) :
                // les 4 voies de dispatch sont toutes des sources originelles,
                // PLUS AUCUNE lecture des tables ODS au runtime (décision
                // v1.9.0 : l'ODS n'était que l'échantillonnage de ces sources).
                return when {
                    model == PKModels.TRANSFEM_SCIENCE && TransfemScienceModels.hasModel(ester) ->
                        TransfemScienceModels.sample(ester, dtH) * mg
                    model == PKModels.WHSAH && WhsahModels.hasModel(ester) ->
                        WhsahModels.sample(ester, dtH) * mg
-                    model == PKModels.ESTRANNAISE && EstrannaiseModels.hasModel(ester) ->
+                    else -> PKProfileStore.sample(ester, model, dtH) * mg
                        EstrannaiseModels.sample(ester, dtH) * mg
                    else -> 0.0 // ester sans modèle (documenté : ni TFS ni WHSAH ni ESE)
                }
            }
        }
@ -125,9 +119,7 @@ object PharmacokineticEngine {
     * ne contribue plus à la prédiction :
     *  - profil avec modèle V3C/WHS → 10 demi-vies TERMINALES du fit
     *    (ex. EEn TFS ≈ 45 j, PEP ≈ 284 j) ;
-     *  - profil Estrannaise → 10 demi-vies TERMINALES analytiques (v1.9.0 ;
+     *  - profil tables ODS (Estrannaise) → longueur de la table (8001 h ≈ 333 j) ;
     *    l'ancienne coupure « longueur de table ODS 8001 h » a disparu avec
     *    les tables du runtime) ;
     *  - Bateman (gel/patch/oral) → 30 demi-vies d'élimination.
     *
     * Public (v1.6.0) : réutilisé par [LabTrajectoryModel.extensionHorizonEndMs]
@ -147,12 +139,8 @@ object PharmacokineticEngine {
                model == PKModels.TRANSFEM_SCIENCE && TransfemScienceModels.hasModel(treatment.esterType) ->
                    TransfemScienceModels.model(treatment.esterType)!!
                        .terminalHalfLifeDays * 24.0 * 10.0
-                // v1.9.0 : ESE analytique → t½ terminale ANALYTIQUE (comme
+                else ->
-                // TFS/WHS) au lieu de la longueur de table ODS
+                    PKProfileStore.profileLength(treatment.esterType, model).toDouble()
                model == PKModels.ESTRANNAISE && EstrannaiseModels.hasModel(treatment.esterType) ->
                    EstrannaiseModels.model(treatment.esterType)!!
                        .terminalHalfLifeDays * 24.0 * 10.0
                else -> 0.0
            }
        } else 0.0
        val batemanH = if (treatment.usesProfileModel) 0.0
@ -164,65 +152,6 @@ object PharmacokineticEngine {
    // Aggregated levels
    // ------------------------------------------------------------------
    /**
     * Contexte PRÉ-CALCULÉ d'une série d'appels [e2At] (v1.9.5, audit) :
     * cutoff par traitement + Bateman paresseux + doses pré-groupées. Le
     * chemin chaud du TRACÉ LABS appelle e2At par point de grille (720 pts)
     * et par lab — reconstruire ce contexte à CHAQUE appel diluait
     * l'optimisation v1.8.2 (720 × N traitements reconstructions de maps).
     * Préparer UNE fois puis appeler [e2At] surcharge contexte — résultat
     * bit-identique (mêmes boucles, même ordre de sommation flottante).
     */
    class E2Context internal constructor(
        internal val treatments: List<Treatment>,
        internal val dosesByTreatment: Map<Long, List<DoseLog>>,
        internal val cutoffByTreatment: HashMap<Long, Double>,
        internal val batemanCache: HashMap<Long, BatemanParams>,
    )
    /** Prépare un [E2Context] pour une série d'appels e2At (même entrées). */
    fun prepareE2Context(treatments: List<Treatment>, doseLogs: List<DoseLog>): E2Context {
        val dosesByTreatment = doseLogs.groupBy { it.treatmentId }
        val cutoffByTreatment = HashMap<Long, Double>()
        val batemanCache = HashMap<Long, BatemanParams>()
        for (treatment in treatments) {
            if (treatment.type != TreatmentType.ESTRADIOL) continue
            cutoffByTreatment[treatment.id] = cutoffHours(treatment)
            if (!treatment.usesProfileModel) {
                batemanCache[treatment.id] = batemanParams(treatment)
            }
        }
        return E2Context(treatments, dosesByTreatment, cutoffByTreatment, batemanCache)
    }
    /** e2At sur contexte pré-calculé (voir [E2Context]) — la forme WORKHORSE. */
    fun e2At(
        ctx: E2Context,
        tMs: Long,
        modelOverride: String? = null,
        scalePerEster: Map<String, Double>? = null
    ): Double {
        var total = 0.0
        for (treatment in ctx.treatments) {
            if (treatment.type != TreatmentType.ESTRADIOL) continue
            for (dose in ctx.dosesByTreatment[treatment.id].orEmpty()) {
                if (dose.timestamp > tMs) continue
                val dtH = (tMs - dose.timestamp) / 3_600_000.0
                if (dtH > ctx.cutoffByTreatment.getValue(treatment.id)) continue
                val c = concentrationOfDose(
                    treatment, dose, tMs, ctx.batemanCache[treatment.id], modelOverride
                )
                if (c > 0.0) {
                    val scale = scalePerEster?.get(doseEster(treatment, dose))
                        ?: treatment.scaleFactor
                    total += c * scale
                }
            }
        }
        return total
    }
    /** e2At à appel unique : prépare le contexte puis délègue. */
    fun e2At(
        treatments: List<Treatment>,
        doseLogs: List<DoseLog>,
@ -236,7 +165,28 @@ object PharmacokineticEngine {
         */
        scalePerEster: Map<String, Double>? = null
    ): Double {
-        return e2At(prepareE2Context(treatments, doseLogs), tMs, modelOverride, scalePerEster)
+        val batemanCache = HashMap<Long, BatemanParams>()
        var total = 0.0
        for (treatment in treatments) {
            if (treatment.type != TreatmentType.ESTRADIOL) continue
            if (!batemanCache.containsKey(treatment.id)) {
                batemanCache[treatment.id] = batemanParams(treatment)
            }
            for (dose in doseLogs) {
                if (dose.treatmentId != treatment.id || dose.timestamp > tMs) continue
                val dtH = (tMs - dose.timestamp) / 3_600_000.0
                if (dtH > cutoffHours(treatment)) continue
                val c = concentrationOfDose(
                    treatment, dose, tMs, batemanCache[treatment.id], modelOverride
                )
                if (c > 0.0) {
                    val scale = scalePerEster?.get(doseEster(treatment, dose))
                        ?: treatment.scaleFactor
                    total += c * scale
                }
            }
        }
        return total
    }
    fun testosteroneAt(e2Level: Double, config: TConfig): Double {
@ -342,15 +292,7 @@ object PharmacokineticEngine {
        val searchStart = maxOf(startMs, earliestDose)
        val batemanCache = HashMap<Long, BatemanParams>()
-        relevantTreatments.forEach {
+        relevantTreatments.forEach { batemanCache[it.id] = batemanParams(it) }
            // Bateman paresseux (v1.8.2) : inutile pour les traitements à profil
            if (!it.usesProfileModel) batemanCache[it.id] = batemanParams(it)
        }
        // v1.8.2 : cutoffs pré-calculés (déterministes par traitement) et
        // doses pré-groupées — finis les scans complets de doseLogs à chaque
        // point × traitement (l'ordre de sommation est préservé, cf e2At)
        val cutoffByTreatment = relevantTreatments.associate { it.id to cutoffHours(it) }
        val dosesByTreatment = doseLogs.groupBy { it.treatmentId }
        // Doses triées pour suivre l'« ester actif » le long de la grille (pour le k de T)
        val sortedEstrogenDoses = doseLogs
@ -372,10 +314,10 @@ object PharmacokineticEngine {
            }
            val k = activeEster?.let { tKPerEster?.get(it) } ?: tConfig.k
            for (treatment in relevantTreatments) {
-                val cutoff = cutoffByTreatment.getValue(treatment.id)
+                val cutoff = cutoffHours(treatment)
                val p = batemanCache[treatment.id]
-                for (dose in dosesByTreatment[treatment.id].orEmpty()) {
+                for (dose in doseLogs) {
-                    if (dose.timestamp > t) continue
+                    if (dose.treatmentId != treatment.id || dose.timestamp > t) continue
                    val dtH = (t - dose.timestamp) / 3_600_000.0
                    if (dtH > cutoff) continue
                    val c = concentrationOfDose(treatment, dose, t, p, modelOverride)
@ -416,14 +358,6 @@ object PharmacokineticEngine {
    ): List<DoseLog> {
        val intervalDays = treatment.forecastIntervalDays ?: return emptyList()
        if (intervalDays <= 0.0) return emptyList()
        // ⚠️ FIX #70 (v1.12.0, demande utilisatrice) : un traitement INACTIF ne
        // projette PLUS de créneaux — l'archivage arrête les prédictions
        // d'injections futures (graphique Prévision, extension de fenêtre,
        // horizon LabTiming). Cohérent avec les rappels (nextReminderFireFor
        // garde déjà !isActive). ⚠️ §6.bis inchangé : l'INACTIF reste simulé
        // pour son HISTORIQUE (computeCurve ne passe pas ici) — seul le
        // FUTUR s'arrête.
        if (!treatment.isActive) return emptyList()
        val intervalMs = (intervalDays * 24.0 * HOUR_MS).toLong()
        if (intervalMs <= 0L) return emptyList()
@ -491,8 +425,6 @@ object PharmacokineticEngine {
        // stocké du traitement, ce qui produisait des facteurs absurdes dès
        // qu'un traitement basculait de modèle, ex. ×2,21 sur WHSAH)
        val unscaled = estrogenTreatments.map { it.copy(scaleFactor = 1.0) }
        // Contexte pré-calculé UNE fois pour toute la série de labs (v1.9.5)
        val ctx = prepareE2Context(unscaled, doseLogs)
        val ratiosByEster = HashMap<String, MutableList<Double>>()
        var maxPredictionSoFar = 0.0
        // ⚠️ fix #61 : labs par timestamp CROISSANT + garde labIsSignificant —
@ -500,7 +432,7 @@ object PharmacokineticEngine {
        // résiduelle) produisaient des ratios aberrants dont la MÉDIANE
        // tombait à ×2,21
        for (lab in e2Labs.sortedBy { it.timestamp }) {
-            val predicted = e2At(ctx, lab.timestamp, modelOverride = modelOverride)
+            val predicted = e2At(unscaled, doseLogs, lab.timestamp, modelOverride = modelOverride)
            if (!labIsSignificant(predicted, maxPredictionSoFar)) continue
            // Attribution : dernière dose E2 ≤ lab → son ester (override compris)
@ -517,7 +449,10 @@ object PharmacokineticEngine {
            if (predicted > maxPredictionSoFar) maxPredictionSoFar = predicted
        }
        return ratiosByEster.mapValues { (_, ratios) ->
-            medianRounded(ratios, 2)
+            val sorted = ratios.sorted()
            val median = if (sorted.size % 2 == 1) sorted[sorted.size / 2]
            else (sorted[sorted.size / 2 - 1] + sorted[sorted.size / 2]) / 2.0
            (median * 100).toInt() / 100.0
        }
    }
@ -573,7 +508,12 @@ object PharmacokineticEngine {
            }
            if (e2 > maxE2SoFar) maxE2SoFar = e2
        }
-        return ksByEster.mapValues { (_, ks) -> medianRounded(ks, 3) }
+        return ksByEster.mapValues { (_, ks) ->
            val sorted = ks.sorted()
            val median = if (sorted.size % 2 == 1) sorted[sorted.size / 2]
            else (sorted[sorted.size / 2 - 1] + sorted[sorted.size / 2]) / 2.0
            (median * 1000).toInt() / 1000.0
        }
    }
    /**
@ -662,26 +602,6 @@ object PharmacokineticEngine {
     * jusqu'ici (les labs doivent être traités par timestamp CROISSANT) ;
     * 0 = premier lab → seule la garde > 0,5 s'applique.
     */
    /**
     * MÉDIANE arrondie d'une liste de ratios (helper partagé par les 4
     * pipelines de calibration — était dupliqué 4×). Liste triée en place.
     * @param decimals nombre de décimales après arrondi (via troncature ×10^n)
     */
    private fun medianRounded(values: MutableList<Double>, decimals: Int): Double {
        values.sort()
        val median = if (values.size % 2 == 1) values[values.size / 2]
        else (values[values.size / 2 - 1] + values[values.size / 2]) / 2.0
        val factor = Math.pow(10.0, decimals.toDouble())
        // ⚠️ ARRONDI (v1.8.2), pas troncature : l'ancien motif
        // `(median * factor).toInt() / factor` tronquait au dernier bit
        // flottant — 0.8999999999999999 × 100 → toInt() = 89 → « 0,89 »
        // (le modèle ESE analytique a déplacé ce bit, révélant le piège ;
        // le bug #61 historique du même genre : 6,5 → 6 avec
        // kotlin.math.round — là, Math.round est l'arrondi au plus proche).
        return Math.round(median * factor) / factor
    }
    fun labIsSignificant(predicted: Double, maxSoFar: Double): Boolean =
        predicted > 0.5 &&
            (maxSoFar <= 0.0 || predicted >= LAB_MIN_PREDICTION_FRACTION * maxSoFar)
@ -716,7 +636,13 @@ object PharmacokineticEngine {
            if (predicted > maxPredictionSoFar) maxPredictionSoFar = predicted
        }
        if (ratios.isEmpty()) return null
-        return medianRounded(ratios, 2)
+        ratios.sort()
        val median = if (ratios.size % 2 == 1) {
            ratios[ratios.size / 2]
        } else {
            (ratios[ratios.size / 2 - 1] + ratios[ratios.size / 2]) / 2.0
        }
        return (median * 100).toInt() / 100.0
    }
    fun computeTConfigCalibration(
@ -725,10 +651,8 @@ object PharmacokineticEngine {
        doseLogs: List<DoseLog>,
        current: TConfig
    ): TConfig? {
        // Le premier filtre « brut > floor » est soussumé par celui sur la
        // valeur CONVERTIE (toute conversion est ≤ la valeur brute) : un seul
        // filtre après conversion suffit — résultat strictement identique.
        val usable = tLabs
            .filter { it.value > current.floor + 0.02 }
            .map { it.copy(value = convertTToNgMl(it.value, it.unit)) }
            .filter { it.value > current.floor + 0.02 }
        if (usable.isEmpty()) return null
@ -741,33 +665,13 @@ object PharmacokineticEngine {
            if (k > 1e-4 && k < 10.0) ks.add(k)
        }
        if (ks.isEmpty()) return null
-        return current.copy(k = medianRounded(ks, 3))
+        ks.sort()
-    }
+        val median = if (ks.size % 2 == 1) {
-
+            ks[ks.size / 2]
-    /**
+        } else {
-     * Une dose de CE traitement est-elle déjà loguée LE JOUR de [atMs]
+            (ks[ks.size / 2 - 1] + ks[ks.size / 2]) / 2.0
     * (jour calendaire LOCAL — fuseau paramétrable pour la testabilité) ?
     *
     * v1.10.0 (demande utilisatrice) : si la dose prévue du jour est
     * saisie AVANT l'heure de rappel, la notification ne doit PAS sonner
     * pour une prise déjà faite — le rappel suivant repart au créneau
     * SUIVANT de la grille (le receiver re-programme dans tous les cas).
     * S'applique identiquement au fallback quotidien (oral sans Posologie :
     * dose loguée aujourd'hui → pas de notif aujourd'hui, demain re-part).
     *
     * PUR (aucune dépendance Android) → testable en JVM (ReminderLoggedDayTest).
     */
    fun hasDoseLoggedOnDay(
        treatmentId: Long,
        doseLogs: List<DoseLog>,
        atMs: Long,
        zoneId: java.time.ZoneId = java.time.ZoneId.systemDefault()
    ): Boolean {
        val day = java.time.Instant.ofEpochMilli(atMs).atZone(zoneId).toLocalDate()
        return doseLogs.any {
            it.treatmentId == treatmentId &&
                java.time.Instant.ofEpochMilli(it.timestamp).atZone(zoneId).toLocalDate() == day
        }
        return current.copy(k = (median * 1000).toInt() / 1000.0)
    }
    /**
--- a/app/src/main/java/com/hormonetrack/reminder/AlertNotifier.kt
+++ b/app/src/main/java/com/hormonetrack/reminder/AlertNotifier.kt
@ -20,6 +20,7 @@ import com.hormonetrack.R
 import com.hormonetrack.data.AppDatabase
 import com.hormonetrack.pk.Alerts
 import com.hormonetrack.pk.PharmacokineticEngine
 import com.hormonetrack.pk.TConfig
 import com.hormonetrack.util.AppLog
 import kotlinx.coroutines.flow.first
 import java.util.concurrent.TimeUnit
--- a/app/src/main/java/com/hormonetrack/reminder/CalendarEvents.kt
+++ b/app/src/main/java/com/hormonetrack/reminder/CalendarEvents.kt
@ -5,7 +5,6 @@ import android.content.Context
 import android.content.ContentValues
 import android.provider.CalendarContract
 import com.hormonetrack.data.model.Treatment
 import com.hormonetrack.ui.components.formatDose
 import java.util.Calendar
 import java.util.TimeZone
@ -189,6 +188,6 @@ object CalendarEvents {
    private fun formatInterval(treatment: Treatment): String =
        treatment.forecastIntervalDays?.let { formatDose(it) } ?: "?"
-    // formatDose est la fonction PUBLIQUE de ui/components/DoseDialog.kt
+    private fun formatDose(d: Double): String =
-    // (dédupliquée v1.8.2 — la même règle d'affichage des doses partout)
+        if (d == d.toLong().toDouble()) d.toLong().toString() else "%.1f".format(d)
 }
--- a/app/src/main/java/com/hormonetrack/reminder/DoseActionReceiver.kt
+++ b/app/src/main/java/com/hormonetrack/reminder/DoseActionReceiver.kt
@ -43,14 +43,7 @@ class DoseActionReceiver : BroadcastReceiver() {
            ReminderContract.ACTION_SNOOZE -> {
                val name = intent.getStringExtra(ReminderContract.EXTRA_TREATMENT_NAME) ?: ""
                val dose = intent.getDoubleExtra(ReminderContract.EXTRA_DOSE_AMOUNT, 0.0)
-                // v1.10.1 : le snooze FORWARDE l'instant planifié d'origine —
+                AlarmScheduler(context).scheduleSnooze(treatmentId, name, dose)
                // le garde du feu différé évalue le jour du CRÉNEAU, pas
                // celui du snooze (sinon un snooze à cheval sur minuit
                // évaluerait le mauvais jour).
                val plannedAt = if (intent.hasExtra(ReminderContract.EXTRA_PLANNED_AT)) {
                    intent.getLongExtra(ReminderContract.EXTRA_PLANNED_AT, 0L)
                } else null
                AlarmScheduler(context).scheduleSnooze(treatmentId, name, dose, plannedAt = plannedAt)
            }
        }
    }
--- a/app/src/main/java/com/hormonetrack/reminder/ReminderManager.kt
+++ b/app/src/main/java/com/hormonetrack/reminder/ReminderManager.kt
@ -15,7 +15,6 @@ import com.hormonetrack.data.AppDatabase
 import com.hormonetrack.data.model.DoseLog
 import com.hormonetrack.data.model.Treatment
 import com.hormonetrack.pk.PharmacokineticEngine
 import com.hormonetrack.util.AppLog
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.SupervisorJob
@ -30,17 +29,6 @@ object ReminderContract {
    const val EXTRA_TREATMENT_NAME = "treatment_name"
    const val EXTRA_DOSE_AMOUNT = "dose_amount"
    /**
     * Instant PLANIFIÉ de l'alarme (v1.10.1) — embarqué par
     * AlarmScheduler.scheduleFor au moment du scheduling et relu par
     * [ReminderReceiver]. ⚠️ Nécessaire car une alarme INEXACTE (setWindow
     * sans SCHEDULE_EXACT_ALARM) ou retardée (Doze) peut fire après la
     * frontière de jour : le garde « créneau déjà honoré » doit évaluer le
     * jour PLANIFIÉ, pas le jour réel du feu. Absent (vieux PendingIntents)
     * → le receiver retombe sur l'heure courante.
     */
    const val EXTRA_PLANNED_AT = "planned_at"
    fun reminderIntent(context: Context, treatmentId: Long): Intent =
        Intent(context, ReminderReceiver::class.java).apply {
            action = ACTION_REMINDER
@ -64,16 +52,10 @@ class AlarmScheduler(private val context: Context) {
    private val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
-    private fun pendingBroadcast(
+    private fun pendingBroadcast(treatmentId: Long, name: String?, dose: Double?): PendingIntent {
        treatmentId: Long,
        name: String?,
        dose: Double?,
        plannedAt: Long? = null
    ): PendingIntent {
        val intent = ReminderContract.reminderIntent(context, treatmentId)
        name?.let { intent.putExtra(ReminderContract.EXTRA_TREATMENT_NAME, it) }
        dose?.let { intent.putExtra(ReminderContract.EXTRA_DOSE_AMOUNT, it) }
        plannedAt?.let { intent.putExtra(ReminderContract.EXTRA_PLANNED_AT, it) }
        return PendingIntent.getBroadcast(
            context,
            treatmentId.toInt(),
@ -97,27 +79,12 @@ class AlarmScheduler(private val context: Context) {
        val fireAt = PharmacokineticEngine.nextReminderFireFor(
            treatment, doseLogs, System.currentTimeMillis()
        ) ?: return false
-        // L'instant planifié voyage dans l'intent : le garde « créneau déjà
+        val pi = pendingBroadcast(treatment.id, treatment.name, treatment.doseAmount)
        // honoré » (v1.10.1) évalue le jour PLANIFIÉ, pas celui du feu réel
        // (une alarme inexacte peut glisser après minuit — cf
        // ReminderContract.EXTRA_PLANNED_AT).
        val pi = pendingBroadcast(treatment.id, treatment.name, treatment.doseAmount, fireAt)
        return scheduleAt(fireAt, pi)
    }
-    /**
+    fun scheduleSnooze(treatmentId: Long, name: String, dose: Double, delayMs: Long = 60 * 60_000L): Boolean {
-     * Alarme « Reporter 1 h ». [plannedAt] : l'instant PLANIFIÉ du créneau
+        val pi = pendingBroadcast(treatmentId, name, dose)
     * d'origine — forwardé tel quel pour que le garde du feu différé
     * évalue toujours le bon jour (et non le jour du snooze).
     */
    fun scheduleSnooze(
        treatmentId: Long,
        name: String,
        dose: Double,
        delayMs: Long = 60 * 60_000L,
        plannedAt: Long? = null
    ): Boolean {
        val pi = pendingBroadcast(treatmentId, name, dose, plannedAt)
        return scheduleAt(System.currentTimeMillis() + delayMs, pi)
    }
@ -240,41 +207,19 @@ class ReminderReceiver : BroadcastReceiver() {
            .setAutoCancel(true)
            .build()
        val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
        manager.notify(treatmentId.toInt(), notification)
        // ⚠️ Les alarmes sont one-shot (setExactAndAllowWhileIdle) : reprogrammer
        // ICI le déclenchement SUIVANT (v1.4.0, fix #52) — sinon le rappel suivant
        // n'existait qu'après un reboot/une édition. Le calcul passe par le moteur
        // (grille Posologie si elle existe, sinon quotidien).
        // v1.10.0 (demande utilisatrice) : si la dose du jour est DÉJÀ loguée
        // (prise saisie avant l'heure de rappel), la notification est SAUTÉE —
        // elle ne doit pas sonner pour une prise déjà faite — et le rappel
        // suivant repart au créneau suivant (re-schedule dans tous les cas).
        // v1.10.1 : le jour évalué est celui du créneau PLANIFIÉ
        // (EXTRA_PLANNED_AT), pas celui du feu réel — une alarme inexacte
        // peut glisser après minuit sans changer de créneau.
        val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
        val plannedAtMs = if (intent.hasExtra(ReminderContract.EXTRA_PLANNED_AT)) {
            intent.getLongExtra(ReminderContract.EXTRA_PLANNED_AT, 0L)
        } else {
            System.currentTimeMillis()
        }
        val pending = goAsync()
-        CoroutineScope(SupervisorJob() + Dispatchers.IO).launch {
+        kotlinx.coroutines.CoroutineScope(kotlinx.coroutines.SupervisorJob() + kotlinx.coroutines.Dispatchers.IO).launch {
            try {
                val db = AppDatabase.getInstance(context)
                val doses = db.doseLogDao().getAllOnce()
                if (PharmacokineticEngine.hasDoseLoggedOnDay(
                        treatmentId, doses, plannedAtMs
                    )
                ) {
                    AppLog.log(
                        "reminder",
                        "créneau déjà honoré (dose loguée le jour planifié) → notification sautée (treatment=$treatmentId)"
                    )
                } else {
                    manager.notify(treatmentId.toInt(), notification)
                }
                db.treatmentDao().getById(treatmentId)?.let { tr ->
-                    AlarmScheduler(context).scheduleFor(tr, doses)
+                    AlarmScheduler(context).scheduleFor(tr, db.doseLogDao().getAllOnce())
                }
            } finally {
                pending.finish()
@ -286,23 +231,23 @@ class ReminderReceiver : BroadcastReceiver() {
 class BootReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        if (intent.action != Intent.ACTION_BOOT_COMPLETED) return
-        // v1.10.1 : consolidation goAsync + coroutine (pattern ReminderReceiver —
+        val result = goAsync()
-        // remplace le Thread + double runBlocking de la v1.0, dette §20.bis #2) :
+        Thread {
        // une seule lecture séquentielle des DAO dans un scope IO dédié, finish()
        // garanti par le finally.
        val pending = goAsync()
        CoroutineScope(SupervisorJob() + Dispatchers.IO).launch {
            try {
                val db = AppDatabase.getInstance(context)
                // TOUS les traitements : les inactifs doivent voir leur alarme
                // annulée au boot (sinon une alarme périmée continue de sonner) ;
                // les doses alimentent la grille Posologie (fix #52)
-                val treatments = db.treatmentDao().getAllOnce()
+                val treatments = kotlinx.coroutines.runBlocking {
-                val doses = db.doseLogDao().getAllOnce()
+                    db.treatmentDao().getAllOnce()
                }
                val doses = kotlinx.coroutines.runBlocking {
                    db.doseLogDao().getAllOnce()
                }
                AlarmScheduler(context).rescheduleAll(treatments, doses)
            } finally {
-                pending.finish()
+                result.finish()
            }
            }
        }.start()
    }
 }
--- a/app/src/main/java/com/hormonetrack/settings/AppSettings.kt
+++ b/app/src/main/java/com/hormonetrack/settings/AppSettings.kt
@ -79,15 +79,6 @@ class AppSettings(private val context: Context) {
        /** Horodatage du dernier run auto tenté (millisecondes, 0/absent = jamais). */
        val AUTO_BACKUP_LAST_AT = longPreferencesKey("auto_backup_last_at")
        // ── Cible de creux E2 (v1.13.0, opt-in) ────────────────────────────
        // Référence PERSONNELLE pour la prochaine prise de sang (« je veux
        // être dans [low, high] au creux recommandé »). DISTINCT des seuils
        // d'alerte (ALERT_E2_*), qui surveillent le niveau en continu —
        // les deux bandes sont volontairement indépendantes. Champ absent =
        // cible désactivée (comportement v1.12).
        val TROUGH_TARGET_LOW = doublePreferencesKey("trough_target_low")
        val TROUGH_TARGET_HIGH = doublePreferencesKey("trough_target_high")
    }
    val tConfig: Flow<TConfig> = context.dataStore.data.map { prefs ->
@ -230,30 +221,6 @@ class AppSettings(private val context: Context) {
        }
    }
    /** Cible de creux (v1.13.0) : `null` si désactivée (un champ manquant suffit). */
    val troughTarget: Flow<Pair<Double, Double>?> = context.dataStore.data.map { prefs ->
        val low = prefs[Keys.TROUGH_TARGET_LOW]
        val high = prefs[Keys.TROUGH_TARGET_HIGH]
        if (low != null && high != null) low to high else null
    }
    /**
     * Persiste la cible de creux (v1.13.0). `null` EFFACE les deux clés —
     * « champs vides = cible désactivée ». La cohérence high > low est
     * validée dans l'UI (TroughTargetCard), comme pour les seuils d'alerte.
     */
    suspend fun setTroughTarget(target: Pair<Double, Double>?) {
        context.dataStore.edit { prefs ->
            if (target == null) {
                prefs.remove(Keys.TROUGH_TARGET_LOW)
                prefs.remove(Keys.TROUGH_TARGET_HIGH)
            } else {
                prefs[Keys.TROUGH_TARGET_LOW] = target.first
                prefs[Keys.TROUGH_TARGET_HIGH] = target.second
            }
        }
    }
    /**
     * Persiste les seuils d'alerte (v1.4.2). Les valeurs null EFFACENT la clé
     * (DataStore : remove) — « champ vide = pas d'alerte ».
--- a/app/src/main/java/com/hormonetrack/settings/ChangelogHelper.kt
+++ b/app/src/main/java/com/hormonetrack/settings/ChangelogHelper.kt
@ -1,9 +1,5 @@
 package com.hormonetrack.settings
 /** Précompilées (v1.8.2) : appelées à chaque ouverture du dialog « Nouveautés » */
 private val VERSION_PATTERN = Regex("^\\d+(\\.\\d+)*$")
 private val SECTION_PATTERN = Regex("## \\[(\\d+\\.\\d+\\.\\d+)\\][^\\n]*\\n(.*?)(?=\\n## \\[|\\Z)", RegexOption.DOT_MATCHES_ALL)
 /**
 * Utilitaires pour le dialog « Nouveautés » affiché après chaque mise à jour
 * (v1.3.0). Pur (aucune dépendance Android) → testable en JVM.
@ -32,7 +28,7 @@ object ChangelogHelper {
    private fun parse(version: String): List<Int>? {
        val cleaned = version.trim().removePrefix("v")
-        if (!VERSION_PATTERN.matches(cleaned)) return null
+        if (!Regex("^\\d+(\\.\\d+)*$").matches(cleaned)) return null
        return cleaned.split(".").map { it.toInt() }
    }
@ -47,7 +43,7 @@ object ChangelogHelper {
     * @return le markdown concaténé des nouveautés ("" si rien de nouveau).
     */
    fun sectionsSince(markdown: String, lastSeenVersion: String?, currentVersion: String): String {
-        val pattern = SECTION_PATTERN
+        val pattern = Regex("## \\[(\\d+\\.\\d+\\.\\d+)\\][^\\n]*\\n(.*?)(?=\\n## \\[|\\Z)", RegexOption.DOT_MATCHES_ALL)
        val out = StringBuilder()
        for (match in pattern.findAll(markdown)) {
            val version = match.groupValues[1]
--- a/app/src/main/java/com/hormonetrack/ui/HormoneTrackRoot.kt
+++ b/app/src/main/java/com/hormonetrack/ui/HormoneTrackRoot.kt
@ -46,7 +46,7 @@ val LocalAppContainer = compositionLocalOf<AppContainer> {
 private data class TabItem(val route: String, val labelRes: Int, val icon: androidx.compose.ui.graphics.vector.ImageVector)
@Composable
-fun HormoneTrackRoot(logDoseRequest: androidx.compose.runtime.MutableState<Long?>) {
+fun HormoneTrackRoot(initialOpenLogDose: Boolean, initialTreatmentId: Long) {
    val app = androidx.compose.ui.platform.LocalContext.current.applicationContext as com.hormonetrack.HormoneTrackApp
    val context = androidx.compose.ui.platform.LocalContext.current
@ -132,11 +132,7 @@ fun HormoneTrackRoot(logDoseRequest: androidx.compose.runtime.MutableState<Long?
            ) {
                composable("home") {
                    HomeScreen(
-                        // Demande de notification : état détenu par l'activité
+                        openLogDoseForTreatmentId = if (initialOpenLogDose) initialTreatmentId else null,
                        // (survit aux onglets), consommé UNE fois par HomeScreen
                        // (fix #69 — dialog fantôme au retour sur l'accueil)
                        openLogDoseForTreatmentId = logDoseRequest.value,
                        onLogDoseConsumed = { logDoseRequest.value = null },
                        onOpenSettings = { navController.navigate("settings") },
                        onOpenCharts = {
                            // Tap sur le mini-graphique de l'accueil → écran Graphiques
--- a/app/src/main/java/com/hormonetrack/ui/components/CurveChart.kt
+++ b/app/src/main/java/com/hormonetrack/ui/components/CurveChart.kt
@ -3,7 +3,6 @@ package com.hormonetrack.ui.components
 import androidx.compose.foundation.Canvas
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.geometry.Size
@ -15,10 +14,11 @@ import androidx.compose.ui.graphics.drawscope.Stroke
 import androidx.compose.ui.graphics.nativeCanvas
 import androidx.compose.ui.unit.dp
 import com.hormonetrack.data.model.DoseLog
 import com.hormonetrack.data.model.PKModels
 import com.hormonetrack.data.model.LabResult
 import com.hormonetrack.pk.LevelPoint
 import com.hormonetrack.pk.PharmacokineticEngine
 import com.hormonetrack.ui.theme.ChartE2
 import com.hormonetrack.ui.theme.ChartT
 import com.hormonetrack.ui.theme.LabDot
 import java.text.SimpleDateFormat
 import java.util.Calendar
@ -48,15 +48,7 @@ data class ChartSeries(
     * ses extrema reflèteraient l'interp ρ entre labs, pas la physiologie du
     * modèle, et `labIsSignificant` a déjà filtré les points aberrants.
     */
-    val showExtrema: Boolean = true,
+    val showExtrema: Boolean = true
    /**
     * v1.9.0 : NUAGE D'INCERTITUDE du modèle ESE (échantillons MCMC — cf
     * pk/EstrannaiseCloud) : chaque sous-liste est une polyligne dessinée en
     * alpha faible SOUS la courbe principale de la série. null = pas de nuage.
     * Hors labels/extrema par construction (c'est de l'incertitude, pas des
     * courbes nommées).
     */
    val cloud: List<List<LevelPoint>>? = null
 )
 data class ChartOptions(
@ -103,20 +95,12 @@ fun xLabelTicks(
        cal.set(Calendar.MILLISECOND, 0)
        while (cal.timeInMillis <= t0) cal.add(Calendar.HOUR_OF_DAY, 1)
    }
    val stepMs = stepHours * 3_600_000L
    val out = mutableListOf<Long>()
    var t = cal.timeInMillis
    while (t <= t1) {
        out.add(t)
-        // On avance via le Calendar (et non un +stepMs fixe) : une addition
+        t += stepMs
        // en millisecondes dérive d'1 h aux transitions DST, alors que le
        // pas « 24 h » doit tomber sur minuit LOCAL tous les jours — y
        // compris le jour du changement d'heure.
        if (stepHours >= 24) {
            cal.add(Calendar.DAY_OF_MONTH, (stepHours / 24L).toInt().coerceAtLeast(1))
        } else {
            cal.add(Calendar.HOUR_OF_DAY, stepHours.toInt())
        }
        t = cal.timeInMillis
    }
    return out
 }
@ -184,12 +168,12 @@ fun niceCeil(value: Double): Double {
 */
 fun defaultModelToggles(pkModelsUsed: Set<String>): Map<String, Boolean> {
    val toggles = mapOf(
-        PKModels.ESTRANNAISE to pkModelsUsed.contains(PKModels.ESTRANNAISE),
+        "ESE" to pkModelsUsed.contains("ESE"),
-        PKModels.TRANSFEM_SCIENCE to pkModelsUsed.contains(PKModels.TRANSFEM_SCIENCE),
+        "TFS" to pkModelsUsed.contains("TFS"),
-        PKModels.WHSAH to pkModelsUsed.contains(PKModels.WHSAH)
+        "WHS" to pkModelsUsed.contains("WHS")
    )
    // Garde-fou : aucune courbe sinon (Bateman tracé dans chaque série)
-    return if (toggles.values.none { it }) toggles + (PKModels.TRANSFEM_SCIENCE to true) else toggles
+    return if (toggles.values.none { it }) toggles + ("TFS" to true) else toggles
 }
 /**
@ -320,35 +304,6 @@ fun CurveChart(
    val forecastMarkerColor = MaterialTheme.colorScheme.tertiary.copy(alpha = 0.85f)
    val realDoseMarkerColor = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.55f)
    // v1.9.5 (audit) : extrema mémoïsés PAR SÉRIE (index aligné sur
    // `series`) — detectExtrema scanne tous les points (O(n)) et ne change
    // que si les séries/options changent, pas à chaque pan/zoom (le Canvas
    // se redessine à chaque geste).
    val extremaBySeries = remember(series, options) {
        series.map { s ->
            Pair(
                if (s.showExtrema) {
                    PharmacokineticEngine.detectExtrema(s.points, { it.e2 }, minSwingAbs = 2.0)
                } else emptyList(),
                if (s.showExtrema) {
                    s.tStyle?.let { PharmacokineticEngine.detectExtrema(s.points, { it.t }, minSwingAbs = 0.02) }
                } else null
            )
        }
    }
    // v1.9.5 (audit) : formatters mémoïsés (SimpleDateFormat n'est pas
    // thread-safe — thread UI seul ici — et l'allouer par frame était du
    // gaspillage, même standard que le fix des marqueurs v1.8.2).
    val markerTimeFmt = remember(zone) {
        SimpleDateFormat("HH:mm", Locale.getDefault()).apply { timeZone = zone }
    }
    val xAxisHourFmt = remember(zone) {
        SimpleDateFormat("HH'h'", Locale.getDefault()).apply { timeZone = zone }
    }
    val xAxisDayFmt = remember(zone) {
        SimpleDateFormat("dd/MM", Locale.getDefault()).apply { timeZone = zone }
    }
    Canvas(modifier = modifier) {
        val allPoints = series.flatMap { it.points }
        if (allPoints.size < 2) return@Canvas
@ -403,19 +358,21 @@ fun CurveChart(
            drawAxisUnit(T_UNIT, padLeft + w + 6.dp.toPx(), padTop - 6.dp.toPx(),
                android.graphics.Paint.Align.LEFT)
        }
-        drawXLabels(labelColor, t0, t1, padLeft, padTop + h, w, zone, xAxisHourFmt, xAxisDayFmt)
+        drawXLabels(labelColor, t0, t1, padLeft, padTop + h, w, zone)
        // Doses PRÉVISIONNELLES (v1.4.5) : ligne verticale pointillée + petit
        // triangle ▼ en haut de la zone — rend l'instant de la dose simulée
        // VISIBLE (sinon la projection paraît décalée d'un jour, bug #55).
        if (forecastDoses.isNotEmpty()) {
            val markerColor = forecastMarkerColor
-            val paint = textPaint(markerColor, 10f, android.graphics.Paint.Align.CENTER)
+            val paint = labelPaint(android.graphics.Paint.Align.CENTER).apply {
-            // SimpleDateFormat créé UNE fois (hors boucle) : le Canvas se
+                color = android.graphics.Color.argb(
-            // redessine à chaque pan/zoom, une allocation par dose × frame
+                    (markerColor.alpha * 255).toInt(),
-            // était du gaspillage (la classe n'est de toute façon pas
+                    (markerColor.red * 255).toInt(),
-            // thread-safe — ici on reste dans le DrawScope UI)
+                    (markerColor.green * 255).toInt(),
-            val hourFmt = markerTimeFmt
+                    (markerColor.blue * 255).toInt()
                )
            }
            for (dose in forecastDoses) {
                if (dose.timestamp !in t0..t1) continue
                val x = xOf(dose.timestamp)
@ -435,42 +392,16 @@ fun CurveChart(
                }
                drawPath(path, markerColor)
                // heure de la dose simulée DANS le fuseau de lecture
                val hourFmt = SimpleDateFormat("HH:mm", Locale.getDefault())
                hourFmt.timeZone = zone
                drawContext.canvas.nativeCanvas.drawText(
                    hourFmt.format(Date(dose.timestamp)), x, padTop + 3.dp.toPx(), paint
                )
            }
        }
        // NUAGE D'INCERTITUDE (v1.9.0, exclusif ESE) : dessiné EN PREMIER
        // (sous toutes les courbes nommées), chaque sous-courbe du posterior
        // MCMC en alpha faible. Décisions d'affichage :
        //  - le nuage ne participe PAS aux échelles (allPoints ne l'inclut
        //    pas) : c'est une plage d'imprécision, pas des données à cadrer —
        //    il peut sortir du cadre en haut/bas sans casser la lecture ;
        //  - ni aux labels ni aux extrema (pas des courbes nommées).
        val cloudPaths = mutableListOf<Pair<Color, Path>>()
        for (s in series) {
            val cloud = s.cloud ?: continue
            for (sub in cloud) {
                if (sub.size < 2) continue
                val path = Path()
                sub.forEachIndexed { i, p ->
                    val x = xOf(p.timestamp)
                    val y = yE2(p.e2)
                    if (i == 0) path.moveTo(x, y) else path.lineTo(x, y)
                }
                cloudPaths.add(s.e2Style.color.copy(alpha = 0.15f) to path)
            }
        }
        for ((color, path) in cloudPaths) {
            drawPath(
                path, color,
                style = Stroke(width = 1.5.dp.toPx())
            )
        }
        // Une courbe E2 + une courbe T par série
-        for ((sIdx, s) in series.withIndex()) {
+        for (s in series) {
            if (s.points.size < 2) continue
            val e2Path = Path()
            s.points.forEachIndexed { i, p ->
@ -510,24 +441,21 @@ fun CurveChart(
            // Pics et creux (v1.2.3) : triangles aux extrema locaux + valeur estimée
            // (v1.2.6 : le triangle est accompagné de la valeur estimée du pic/creux).
            // v1.5.0 : une série peut être exclue (Tracé labs → showExtrema=false).
            // v1.9.5 (audit) : les extrema sont mémoïsés (extremaByModel, hors
            // Canvas, recalculés seulement quand séries/options changent) — le
            // scan local était refait PAR FRAME, x2 séries.
            if (options.showExtrema && s.showExtrema) {
-                extremaBySeries[sIdx]?.let { (e2Extrema, tExtrema) ->
+                PharmacokineticEngine.detectExtrema(s.points, { it.e2 }, minSwingAbs = 2.0)
-                    e2Extrema.forEach { ex ->
+                    .forEach { ex ->
                        drawExtremum(xOf(ex.timestamp), yE2(ex.value), ex, s.e2Style.color)
                    }
                if (options.showT) {
                    s.tStyle?.let { tStyle ->
-                            tExtrema.orEmpty().forEach { ex ->
+                        PharmacokineticEngine.detectExtrema(s.points, { it.t }, minSwingAbs = 0.02)
                            .forEach { ex ->
                                drawExtremum(xOf(ex.timestamp), yT(ex.value), ex, tStyle.color)
                            }
                    }
                }
            }
        }
        }
        // Labs (points/carrés oranges)
        if (options.showLabs) {
@ -588,7 +516,7 @@ fun CurveChart(
 * estimée de l'extremum (v1.2.6) : valeur au-dessus d'un pic, en dessous d'un
 * creux — dans la couleur de la série, unité implicite (celle de l'axe).
 */
-private fun DrawScope.drawExtremum(cx: Float, cy: Float, extremum: PharmacokineticEngine.Extremum, color: Color) {
+private fun DrawScope.drawExtremum(cx: Float, cy: Float, extremum: com.hormonetrack.pk.PharmacokineticEngine.Extremum, color: Color) {
    val r = 5.dp.toPx()
    val offset = 6.dp.toPx()
    val path = Path()
@ -608,9 +536,19 @@ private fun DrawScope.drawExtremum(cx: Float, cy: Float, extremum: Pharmacokinet
    }
    path.close()
    drawPath(path, color)
-    // Valeur estimée du pic/creux, dans la couleur de la courbe (Paint mis
+    // Valeur estimée du pic/creux, dans la couleur de la courbe
-    // en cache — v1.9.5 : un Paint par extremum × frame était du gaspillage)
+    val paint = android.graphics.Paint().apply {
-    val paint = textPaint(color, 9f, android.graphics.Paint.Align.CENTER, fakeBold = true)
+        this.color = android.graphics.Color.argb(
            (color.alpha * 255).toInt(),
            (color.red * 255).toInt(),
            (color.green * 255).toInt(),
            (color.blue * 255).toInt()
        )
        textSize = 9.dp.toPx()
        textAlign = android.graphics.Paint.Align.CENTER
        isAntiAlias = true
        isFakeBoldText = true
    }
    drawContext.canvas.nativeCanvas.drawText(
        formatValue(extremum.value), cx, valueY, paint
    )
@ -636,49 +574,28 @@ private fun DrawScope.drawAxisUnit(
    drawContext.canvas.nativeCanvas.drawText(text, x, baseline, labelPaint(align))
 }
-private fun DrawScope.drawGrid(color: Color, padLeft: Float, padTop: Float, w: Float, h: Float, rows: Int) {
+private fun DrawScope.drawGrid(color: Color, padLeft: Float, padTop: Float, w: Float, h: Float, rows: Int) {    for (i in 0..rows) {
    for (i in 0..rows) {
        val y = padTop + h * i / rows
        drawLine(color, Offset(padLeft, y), Offset(padLeft + w, y), strokeWidth = 1f)
    }
 }
-/**
+/** Paint partagé pour les labels texte (couleur gris neutre fixe). */
- * Cache de Paints TEXTE du graphique (v1.9.5, audit) : un Paint par
+private fun DrawScope.labelPaint(align: android.graphics.Paint.Align): android.graphics.Paint {
- * (couleur, taille, align, gras) au lieu d'une allocation PAR EXTREMUM /
+    val c = Color(0xFF6B7280)
- * label / frame — le Canvas se redessine à chaque pan/zoom/tick. Tout le
+    return android.graphics.Paint().apply {
- * dessin Compose est séquentiel sur le thread UI → un cache d'objet suffit.
+        color = android.graphics.Color.argb(
- * Les clés sont des value classes (Color) → pas de fuite.
+            (c.alpha * 255).toInt(),
- */
+            (c.red * 255).toInt(),
-private val textPaintCache = HashMap<String, android.graphics.Paint>()
+            (c.green * 255).toInt(),
-
+            (c.blue * 255).toInt()
 private fun DrawScope.textPaint(
    color: Color,
    textSizeDp: Float,
    align: android.graphics.Paint.Align,
    fakeBold: Boolean = false
 ): android.graphics.Paint {
    val key = "$color|$textSizeDp|$align|$fakeBold"
    return textPaintCache.getOrPut(key) {
        android.graphics.Paint().apply {
            this.color = android.graphics.Color.argb(
                (color.alpha * 255).toInt(),
                (color.red * 255).toInt(),
                (color.green * 255).toInt(),
                (color.blue * 255).toInt()
        )
-            textSize = textSizeDp.dp.toPx()
+        textSize = 10.dp.toPx()
        textAlign = align
        isAntiAlias = true
            isFakeBoldText = fakeBold
        }
    }
 }
 /** Paint partagé pour les labels texte (couleur gris neutre fixe, 10 dp). */
 private fun DrawScope.labelPaint(align: android.graphics.Paint.Align): android.graphics.Paint =
    textPaint(Color(0xFF6B7280), 10f, align)
 private fun DrawScope.drawLeftYLabels(color: Color, e2Max: Double, padLeft: Float, padTop: Float, h: Float) {
    val paint = labelPaint(android.graphics.Paint.Align.RIGHT)
    for (i in 0..4) {
@ -700,11 +617,7 @@ private fun DrawScope.drawRightYLabels(color: Color, tMax: Double, xRight: Float
 private fun DrawScope.drawXLabels(
    color: Color, t0: Long, t1: Long,
    padLeft: Float, yBottom: Float, w: Float,
-    zone: java.util.TimeZone = java.util.TimeZone.getDefault(),
+    zone: java.util.TimeZone = java.util.TimeZone.getDefault()
    // v1.9.5 (audit) : formatters mémoïsés du composable (plus de
    // SimpleDateFormat alloué par frame)
    hourFmt: SimpleDateFormat = SimpleDateFormat("HH'h'", Locale.getDefault()),
    dayFmt: SimpleDateFormat = SimpleDateFormat("dd/MM", Locale.getDefault())
 ) {
    val paint = labelPaint(android.graphics.Paint.Align.CENTER)
    val spanH = (t1 - t0) / 3_600_000.0
@ -718,25 +631,28 @@ private fun DrawScope.drawXLabels(
    }
    // v1.4.5 : le label est formaté DANS le fuseau de lecture — sinon le
    // tick « minuit local » serait étiqueté avec l'heure système.
-    // v1.9.5 : formatters mémoïsés passés par le composable (plus d'alloc/frame).
+    val fmt = if (spanH <= 25) SimpleDateFormat("HH'h'", Locale.getDefault())
-    val fmt = if (spanH <= 25) hourFmt else dayFmt
+    else SimpleDateFormat("dd/MM", Locale.getDefault())
    fmt.timeZone = zone
    // v1.4.5 (fix #55) : les ticks sont alignés sur les frontières LOCALES
    // (minuit local pour les pas en jours) — l'ancien alignement sur des
    // multiples UTC plaçait le label « 13/09 » à 02:00 du matin FR.
-    // v1.9.5 (audit) : la ZONE de lecture est passée à xLabelTicks — l'oubli
+    for (tick in xLabelTicks(t0, t1, stepHours.toLong())) {
    // alignait les ticks sur le fuseau de l'appareil pendant que les labels
    // sont formatés dans le fuseau choisi (heures décalées dès que les deux
    // divergent, contredisant le fix #55).
    for (tick in xLabelTicks(t0, t1, stepHours.toLong(), zone)) {
        val x = padLeft + w * ((tick - t0).toFloat() / (t1 - t0).toFloat())
        drawContext.canvas.nativeCanvas.drawText(fmt.format(Date(tick)), x, yBottom + 16.dp.toPx(), paint)
    }
 }
 private fun DrawScope.drawDotLabel(v: Double, c: Offset) {
-    // Paint en cache (v1.9.5 : une allocation par lab × frame → une par
+    val paint = labelPaint(android.graphics.Paint.Align.CENTER).apply {
-    // couleur, réutilisée entre frames)
+        color = android.graphics.Color.rgb(
-    val paint = textPaint(LabDot, 9f, android.graphics.Paint.Align.CENTER, fakeBold = true)
+            (LabDot.red * 255).toInt(),
            (LabDot.green * 255).toInt(),
            (LabDot.blue * 255).toInt()
        )
        textSize = 9.dp.toPx()
        isFakeBoldText = true
    }
    drawContext.canvas.nativeCanvas.drawText(formatValue(v), c.x, c.y, paint)
 }
--- a/app/src/main/java/com/hormonetrack/ui/screens/ChartScreen.kt
+++ b/app/src/main/java/com/hormonetrack/ui/screens/ChartScreen.kt
@ -42,9 +42,8 @@ import androidx.compose.ui.layout.onSizeChanged
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import com.hormonetrack.R
-import com.hormonetrack.data.model.PKModels
+import com.hormonetrack.data.model.Treatment
 import com.hormonetrack.pk.LevelPoint
 import com.hormonetrack.pk.EstrannaiseCloud
 import com.hormonetrack.pk.LabTrajectoryModel
 import com.hormonetrack.pk.PharmacokineticEngine
 import com.hormonetrack.pk.TConfig
@ -63,12 +62,6 @@ import com.hormonetrack.ui.theme.TealTertiary
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.withContext
 import com.hormonetrack.ui.components.clampPanHours
 import com.hormonetrack.ui.components.defaultModelToggles
 import com.hormonetrack.ui.components.forecastExtensionHours
 import com.hormonetrack.ui.components.forecastHorizonHours
 import com.hormonetrack.ui.components.panDeltaHours
 import com.hormonetrack.ui.components.stepForRange
 private const val HOUR_MS = 3_600_000L
 // Zoom (v1.2.9) : plage temporelle bornée 6 h → 300 j
@ -79,12 +72,10 @@ private const val MAX_RANGE_H = 24L * 300
 * Écran Graphiques.
 *
 * Fonctions :
- * - plages 6 h → 300 j (zoom v1.2.9, presets 24 h / 7 j / 30 j) ;
+ * - plages 24 h / 7 j / 30 j ;
- * - **panoramique** : glisser horizontalement déplace la fenêtre dans le passé
+ * - **panoramique** : glisser horizontalement déplace la fenêtre dans le passé ;
- *   (le futur avec la Prévision active) ;
+ * - **les deux modèles PK** (Estrannaise / Transfem Science) peuvent être affichés
- * - **les modèles PK** (Estrannaise / Transfem Science / WHSAH) peuvent être
+ *   simultanément (override de modèle dans le moteur), avec toggle indépendant ;
 *   affichés simultanément (override de modèle dans le moteur), toggles
 *   indépendants ; + Tracé labs (v1.5.0) et sa prolongation (v1.6.0) ;
 * - **prévision** : prolonge la courbe avec des doses projetées à partir de la
 *   « fréquence » configurée sur chaque traitement ;
 * - **auto-calibration** (option des Paramètres) : facteurs d'échelle et modèle T
@ -127,13 +118,6 @@ fun ChartScreen() {
    // revendique « passer par tes labs » et doit rester une référence de
    // comparaison, pas un affichage par défiant
    var showLabTrack by remember { mutableStateOf(false) }
    // v1.9.0 : NUAGE D'INCERTITUDE du modèle ESE (échantillons MCMC de
    // estrannaise.js — cf pk/EstrannaiseCloud) — OFF par défaut, opt-in,
    // activable/désactivable à volonté ; ACTIVABLE SEULEMENT quand le
    // modèle ESE est affiché (le nuage est exclusif à ce modèle — les
    // fits TFS/WHSAH ne publient pas de posterior). Se désactive
    // automatiquement si ESE est éteint.
    var showCloud by remember { mutableStateOf(false) }
    // v1.6.0 : PROLONGATION du tracé labs au-delà du dernier lab (ρ du
    // dernier lab constant × modèle, bornée par l'extinction du modèle —
    // cf LabTrajectoryModel.extensionHorizonEndMs). OFF par défaut : la
@ -151,12 +135,12 @@ fun ChartScreen() {
    var modelTogglesInitialized by remember { mutableStateOf(false) }
    LaunchedEffect(treatments) {
        if (!modelTogglesInitialized && treatments.isNotEmpty()) {
-            val toggles = defaultModelToggles(
+            val toggles = com.hormonetrack.ui.components.defaultModelToggles(
                treatments.filter { it.usesProfileModel }.map { it.pkModel }.toSet()
            )
-            showEse = toggles.getValue(PKModels.ESTRANNAISE)
+            showEse = toggles.getValue("ESE")
-            showTfs = toggles.getValue(PKModels.TRANSFEM_SCIENCE)
+            showTfs = toggles.getValue("TFS")
-            showWhs = toggles.getValue(PKModels.WHSAH)
+            showWhs = toggles.getValue("WHS")
            modelTogglesInitialized = true
        }
    }
@ -193,14 +177,14 @@ fun ChartScreen() {
        } else {
            withContext(Dispatchers.Default) {
                mapOf(
-                    PKModels.ESTRANNAISE to PharmacokineticEngine.autoCalibrated(
+                    "ESE" to PharmacokineticEngine.autoCalibrated(
-                        treatments, doseLogs, labResults, tConfig, modelOverride = PKModels.ESTRANNAISE
+                        treatments, doseLogs, labResults, tConfig, modelOverride = "ESE"
                    ),
-                    PKModels.TRANSFEM_SCIENCE to PharmacokineticEngine.autoCalibrated(
+                    "TFS" to PharmacokineticEngine.autoCalibrated(
-                        treatments, doseLogs, labResults, tConfig, modelOverride = PKModels.TRANSFEM_SCIENCE
+                        treatments, doseLogs, labResults, tConfig, modelOverride = "TFS"
                    ),
-                    PKModels.WHSAH to PharmacokineticEngine.autoCalibrated(
+                    "WHS" to PharmacokineticEngine.autoCalibrated(
-                        treatments, doseLogs, labResults, tConfig, modelOverride = PKModels.WHSAH
+                        treatments, doseLogs, labResults, tConfig, modelOverride = "WHS"
                    )
                )
            }
@ -209,15 +193,8 @@ fun ChartScreen() {
    // Horizon de prévision (v1.4.1) : 12 × la plus grande Posologie, borné
    // [30 j ; 365 j] (cf forecastHorizonHours dans CurveChart.kt).
-    // ⚠️ FIX #70 (v1.12.0) : SEULS les traitements ACTIFS comptent — la
+    val maxIntervalDays = treatments.mapNotNull { it.forecastIntervalDays }.maxOrNull()
-    // Posologie d'un traitement archivé ne doit ni activer le chip
+    val forecastHorizonHours = com.hormonetrack.ui.components.forecastHorizonHours(maxIntervalDays)
    // Prévision ni étendre l'horizon (le moteur ne projette plus ses
    // créneaux, cf generateForecastDoses).
    val maxIntervalDays = treatments
        .filter { it.isActive }
        .mapNotNull { it.forecastIntervalDays }
        .maxOrNull()
    val forecastHorizonHours = forecastHorizonHours(maxIntervalDays)
    // ── Fenêtre temporelle (v1.4.1, extension v1.4.4, stabilisation v1.4.5) ──
    // ⚠️ BOUCLE DE RECOMPOSITION (fix #56) : `nowMs` doit être MÉMOÏSÉ sur le
@ -243,7 +220,7 @@ fun ChartScreen() {
        }
    }
    val forecastExtensionH = if (showForecast && forecastHorizonHours != null) {
-        forecastExtensionHours(
+        com.hormonetrack.ui.components.forecastExtensionHours(
            rangeHours, forecastHorizonHours, firstSlotGapH
        )
    } else 0L
@ -271,11 +248,6 @@ fun ChartScreen() {
    // exposées pour être MARQUÉES sur le graphique (lignes pointillées aux
    // créneaux projetés, fix #55 : sans marqueur, la projection paraissait
    // décalée d'un jour).
    // ⚠️ v1.9.5 (audit) : ce producer et le producer `curves` calculent
    // chacun leurs doses prévisionnelles — VOLONTAIRE. Un partage d'état
    // (curves lisant ce producer) créerait une lecture STALE d'un cycle de
    // recomposition (leçon #65 : un producer doit redériver de ses vraies
    // entrées) pour un calcul léger (O(traitements), pas par point de grille).
    val forecastDoses by produceState(
        emptyList<com.hormonetrack.data.model.DoseLog>(),
        treatments, doseLogs, showForecast, endMs, forecastHorizonHours
@ -291,30 +263,16 @@ fun ChartScreen() {
        }
    }
    /**
     * Une courbe rendue par le producer : clé de modèle ("ESE"/"TFS"/"WHS"/
     * "LAB"/"LABX"), ses points, et — v1.9.0 — son NUAGE D'INCERTITUDE
     * (uniquement pour "ESE" quand le chip Nuage est actif).
     */
    data class ChartCurve(
        val model: String,
        val points: List<LevelPoint>,
        val cloud: List<List<LevelPoint>> = emptyList()
    )
    // Une liste de courbes par modèle sélectionné (clé = "ESE" / "TFS") —
    // v1.5.0 : la 4ᵉ série possible est "LAB" (Tracé labs, indépendante) ;
    // v1.6.0 : la 5ᵉ est "LABX" (partie PROLONGÉE du tracé labs, ρ constant)
    val curves by produceState(
-        emptyList<ChartCurve>(),
+        emptyList<Pair<String, List<LevelPoint>>>(),
        autoByModel, doseLogs, startMs, endMs, showEse, showTfs, showWhs, showForecast,
-        showLabTrack, showLabTrackExtend, showCloud,
+        showLabTrack, showLabTrackExtend, labResults.size
        // Clé = la liste ENTIÈRE des labs (pas .size, fix #66) : éditer la
        // VALEUR d'une analyse doit recalculer les courbes
        labResults
    ) {
        withContext(Dispatchers.Default) {
-            val list = mutableListOf<ChartCurve>()
+            val list = mutableListOf<Pair<String, List<LevelPoint>>>()
            // ── v1.5.0 : courbe « Tracé labs » ───────────────────────────────
            // Totalement indépendante des toggles de modèles (elle utilise le
            // modèle STOCKÉ des traitements — sémantique Home, cf doc §7.10)
@ -332,7 +290,7 @@ fun ChartScreen() {
            // non vides seulement — la légende (plus bas) doit connaître
            // "LABX" AVANT son else (leçon #63).
            if (showLabTrack) {
-                val step = stepForRange(rangeHours)
+                val step = com.hormonetrack.ui.components.stepForRange(rangeHours)
                val labCurve = LabTrajectoryModel.computeLabAnchoredCurve(
                    treatments, doseLogs, labResults, startMs, endMs, step,
                    extendBeyondLastLab = showLabTrackExtend
@ -341,18 +299,18 @@ fun ChartScreen() {
                if (showLabTrackExtend && lastAnchor != null) {
                    val anchored = labCurve.points.filter { it.timestamp <= lastAnchor }
                    val extended = labCurve.points.filter { it.timestamp > lastAnchor }
-                    list.add(ChartCurve("LAB", anchored))
+                    list.add("LAB" to anchored)
-                    if (extended.isNotEmpty()) list.add(ChartCurve("LABX", extended))
+                    if (extended.isNotEmpty()) list.add("LABX" to extended)
                } else {
-                    list.add(ChartCurve("LAB", labCurve.points))
+                    list.add("LAB" to labCurve.points)
                }
            }
            if (showEse || showTfs || showWhs) {
                // Calibration PAR MODÈLE (fix #60) : chaque courbe reçoit les
                // échelles/k calculés avec SA prédiction. Hors auto-calibration
                // → scaleFactor stocké des traitements (comportement historique).
-                val effTreatments = autoByModel[PKModels.TRANSFEM_SCIENCE]?.treatments ?: treatments
+                val effTreatments = autoByModel["TFS"]?.treatments ?: treatments
-                val effTConfig = autoByModel[PKModels.TRANSFEM_SCIENCE]?.tConfig ?: tConfig
+                val effTConfig = autoByModel["TFS"]?.tConfig ?: tConfig
                // Doses réelles + doses prévisionnelles éventuelles
                val forecastDoses = if (showForecast) {
                    effTreatments.flatMap {
@ -361,39 +319,50 @@ fun ChartScreen() {
                } else emptyList()
                val allDoses = doseLogs + forecastDoses
                // Pas d'échantillonnage adaptatif au zoom (v1.2.9)
-                val step = stepForRange(rangeHours)
+                val step = com.hormonetrack.ui.components.stepForRange(rangeHours)
-                // v1.8.2 : les 3 blocs copiés (ESE/TFS/WHS) sont factorisés —
+                if (showEse) {
-                // le modèle est la seule variable (même calcul, même calibration
+                    val autoM = autoByModel["ESE"]
-                // PAR MODÈLE via autoByModel[model], fix #60)
+                    list.add(
-                for ((model, enabled) in listOf(PKModels.ESTRANNAISE to showEse, PKModels.TRANSFEM_SCIENCE to showTfs, PKModels.WHSAH to showWhs)) {
+                        "ESE" to PharmacokineticEngine.computeCurve(
                    if (!enabled) continue
                    val autoM = autoByModel[model]
                    val curve = PharmacokineticEngine.computeCurve(
                            effTreatments, allDoses, startMs, endMs,
                            stepMs = step,
-                        tConfig = autoM?.tConfig ?: effTConfig, modelOverride = model,
+                            tConfig = autoM?.tConfig ?: effTConfig, modelOverride = "ESE",
                            scalePerEster = autoM?.esterScales,
                            tKPerEster = autoM?.tKPerEster
                        )
                    )
                }
                if (showTfs) {
                    val autoM = autoByModel["TFS"]
                    list.add(
                        "TFS" to PharmacokineticEngine.computeCurve(
                            effTreatments, allDoses, startMs, endMs,
                            stepMs = step,
                            tConfig = autoM?.tConfig ?: effTConfig, modelOverride = "TFS",
                            scalePerEster = autoM?.esterScales,
                            tKPerEster = autoM?.tKPerEster
                        )
                    )
                }
                // v1.4.6 : 3ᵉ modèle WHSAH (même mécanique d'override)
                if (showWhs) {
                    val autoM = autoByModel["WHS"]
                    list.add(
                        "WHS" to PharmacokineticEngine.computeCurve(
                            effTreatments, allDoses, startMs, endMs,
                            stepMs = step,
                            tConfig = autoM?.tConfig ?: effTConfig, modelOverride = "WHS",
                            scalePerEster = autoM?.esterScales,
                            tKPerEster = autoM?.tKPerEster
                        )
                    // v1.9.0 : le nuage d'incertitude est attaché à la série
                    // ESE (exclusif à ce modèle — les fits TFS/WHSAH ne
                    // publient pas de posterior MCMC)
                    val cloud = if (model == PKModels.ESTRANNAISE && showCloud) {
                        // MÊME calibration que la courbe ESE (fix v1.9.1 :
                        // nuage brut ≠ échelle de la courbe calibrée)
                        EstrannaiseCloud.compute(
                            treatments, doseLogs, startMs, endMs, step,
                            scalePerEster = autoM?.esterScales
                    )
                    } else emptyList()
                    list.add(ChartCurve(model, curve, cloud))
                }
            }
            value = list
        }
    }
-    val allPoints = curves.flatMap { it.points }
+    val allPoints = curves.flatMap { it.second }
    val (a, b) = if (allPoints.size >= 2) {
        allPoints.minOf { it.timestamp } to allPoints.maxOf { it.timestamp }
    } else 0L to 0L
@ -405,11 +374,11 @@ fun ChartScreen() {
    // Série visuelle : E2 Estrannaise = bleu plein, E2 TFS = turquoise plein ;
    // T Estrannaise = rose plein, T TFS = rose pointillé.
-    val series = curves.map { (model, points, cloud) ->
+    val series = curves.map { (model, points) ->
        when (model) {
-            PKModels.ESTRANNAISE -> ChartSeries(points, CurveStyle(ChartE2), CurveStyle(ChartT), cloud = cloud)
+            "ESE" -> ChartSeries(points, CurveStyle(ChartE2), CurveStyle(ChartT))
            // v1.4.6 : WHSAH = E2 vert plein, T violet pointillé
-            PKModels.WHSAH -> ChartSeries(points, CurveStyle(ChartWhs), CurveStyle(ChartTWhs, dashed = true))
+            "WHS" -> ChartSeries(points, CurveStyle(ChartWhs), CurveStyle(ChartTWhs, dashed = true))
            // v1.5.0 : « Tracé labs » = E2 rose foncé pointillé, PAS de courbe T
            // (la série n'a qu'une valeur E2 — tStyle null → rien de dessiné)
            // et hors pics/creux (labIsSignificant a déjà filtré, §7.10)
@ -532,12 +501,7 @@ fun ChartScreen() {
        ) {
            FilterChip(
                selected = showEse,
-                onClick = {
+                onClick = { showEse = !showEse },
                    showEse = !showEse
                    // v1.9.0 : le nuage est exclusif à ESE — éteindre ESE
                    // éteint le nuage (sinon il flotterait sans sa courbe)
                    if (!showEse) showCloud = false
                },
                label = { Text(stringResource(R.string.model_ese)) }
            )
            FilterChip(
@ -566,16 +530,6 @@ fun ChartScreen() {
                enabled = showLabTrack,
                label = { Text(stringResource(R.string.show_lab_track_extend)) }
            )
            // v1.9.0 : NUAGE D'INCERTITUDE (exclusif ESE) — off par défaut,
            // activable à volonté mais SEULEMENT si ESE est affiché (même
            // pattern que Prolonger/Tracé labs) ; éteindre ESE coupe le
            // nuage automatiquement (sinon le nuage flotterait sans sa courbe)
            FilterChip(
                selected = showCloud,
                onClick = { showCloud = !showCloud },
                enabled = showEse,
                label = { Text(stringResource(R.string.show_cloud)) }
            )
        }
        Spacer(Modifier.height(12.dp))
@ -596,12 +550,12 @@ fun ChartScreen() {
                            // v1.4.10 (fix #62) : cumul fractionnaire du pan
                            // (l'ancienne troncature par delta tuait le pan
                            // sur la vue 24 h)
-                            val (hoursDragged, newResidual) = panDeltaHours(
+                            val (hoursDragged, newResidual) = com.hormonetrack.ui.components.panDeltaHours(
                                pan.x, chartWidthPx, rangeHours, panResidualHours
                            )
                            panResidualHours = newResidual
                            if (hoursDragged != 0L) {
-                                panHours = clampPanHours(
+                                panHours = com.hormonetrack.ui.components.clampPanHours(
                                    panHours + hoursDragged, gestureFutureHorizon, gestureMaxPan
                                )
                            }
@ -619,7 +573,7 @@ fun ChartScreen() {
                                    val tFocal = endAnchor - ((1.0 - f) * rangeHours * HOUR_MS).toLong()
                                    val newEnd = tFocal + ((1.0 - f) * newRange * HOUR_MS).toLong()
                                    val newPan = ((nowMs - newEnd) / HOUR_MS).toLong()
-                                    panHours = clampPanHours(
+                                    panHours = com.hormonetrack.ui.components.clampPanHours(
                                        newPan, gestureFutureHorizon, gestureMaxPan
                                    )
                                    rangeHours = newRange
@ -671,7 +625,7 @@ fun ChartScreen() {
                    // une 2ᵉ fois (bug v1.5.0-trouvé-en-émulateur #63).
                    curves.forEach { (model, _) ->
                        when (model) {
-                            PKModels.ESTRANNAISE -> {
+                            "ESE" -> {
                                Text(
                                    stringResource(R.string.legend_ese_e2),
                                    style = MaterialTheme.typography.labelMedium,
@ -686,7 +640,7 @@ fun ChartScreen() {
                                }
                            }
                            // v1.4.6 : légende WHSAH (vert / violet pointillé)
-                            PKModels.WHSAH -> {
+                            "WHS" -> {
                                Text(
                                    stringResource(R.string.legend_whs_e2),
                                    style = MaterialTheme.typography.labelMedium,
@ -745,27 +699,18 @@ fun ChartScreen() {
                    }
                    // v1.5.0 : légende « Tracé labs » — seulement si la série
                    // a ≥ 2 points (≥ 2 labs significatifs, la grille est vide sinon)
-                    if (showLabTrack && curves.any { it.model == "LAB" && it.points.size >= 2 }) {
+                    if (showLabTrack && curves.any { it.first == "LAB" && it.second.size >= 2 }) {
                        Text(
                            stringResource(R.string.legend_lab_track),
                            style = MaterialTheme.typography.labelMedium,
                            color = ChartLabTrajectory
                        )
                    }
                    // v1.9.0 : légende du nuage d'incertitude (ESE) — visible
                    // tant que le nuage est affiché (série ESE avec cloud non vide)
                    if (showCloud && showEse && curves.any { it.model == PKModels.ESTRANNAISE && it.cloud.isNotEmpty() }) {
                        Text(
                            stringResource(R.string.legend_cloud),
                            style = MaterialTheme.typography.labelMedium,
                            color = ChartE2.copy(alpha = 0.55f)
                        )
                    }
                    // v1.6.0 : légende de la partie PROLONGÉE + AVERTISSEMENT —
                    // seulement si la série "LABX" existe (chip Prolonger actif
                    // ET horizon de prolongation atteint dans la fenêtre visible)
                    val labExtendVisible = showLabTrack && showLabTrackExtend &&
-                        curves.any { it.model == "LABX" && it.points.size >= 2 }
+                        curves.any { it.first == "LABX" && it.second.size >= 2 }
                    if (labExtendVisible) {
                        Text(
                            stringResource(R.string.legend_lab_track_extend),
--- a/app/src/main/java/com/hormonetrack/ui/screens/DosesScreen.kt
+++ b/app/src/main/java/com/hormonetrack/ui/screens/DosesScreen.kt
@ -2,24 +2,19 @@ package com.hormonetrack.ui.screens
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.WindowInsets
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Add
 import androidx.compose.material.icons.filled.Delete
 import androidx.compose.material.icons.filled.Colorize
 import androidx.compose.material.icons.filled.Healing
 import androidx.compose.material.icons.filled.Medication
 import androidx.compose.material.icons.filled.Science
 import androidx.compose.material.icons.filled.Vaccines
 import androidx.compose.material.icons.filled.WaterDrop
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.AssistChip
 import androidx.compose.material3.Card
@ -29,7 +24,6 @@ import androidx.compose.material3.FloatingActionButton
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.ListItem
 import androidx.compose.material3.LocalContentColor
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Text
@ -43,18 +37,13 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.contentDescription
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.dp
 import com.hormonetrack.R
 import com.hormonetrack.data.model.AdministrationRoute
 import com.hormonetrack.data.model.DoseLog
-import com.hormonetrack.data.model.LabResult
+import com.hormonetrack.data.model.Treatment
 import com.hormonetrack.ui.LocalAppContainer
 import com.hormonetrack.ui.components.DoseDialog
 import com.hormonetrack.ui.theme.LabDot
 import com.hormonetrack.util.HrtDuration
 import com.hormonetrack.ui.components.formatDose
 import kotlinx.coroutines.CoroutineScope
@ -64,54 +53,6 @@ import java.time.Instant
 import java.time.ZoneId
 import java.time.format.DateTimeFormatter
 /**
 * Icône de FORME DE PRISE (v1.12.0, demande utilisatrice : « des icônes pour
 * bien séparer les différentes formes de prises des traitements »). Mapping :
 * ORAL = pilule (Medication) ; IM/SC = seringue (Vaccines — le glyphe est
 * partagé, la TEinte les distingue côté UI : IM = couleur courante, SC =
 * tertiary) ; GEL = goutte (WaterDrop) ; PATCH = sparadrap (Healing) ;
 * OTHER/inconnu = compte-gouttes (Colorize). PUR → testable en JVM
 * (DosesExtrasTest) ; miroir web `routeGlyph` (js/data/models.js).
 */
 fun routeIcon(route: AdministrationRoute?): ImageVector = when (route) {
    AdministrationRoute.ORAL -> Icons.Filled.Medication
    AdministrationRoute.INJECTION_IM -> Icons.Filled.Vaccines
    AdministrationRoute.INJECTION_SUBCUT -> Icons.Filled.Vaccines
    AdministrationRoute.TRANSDERMAL_GEL -> Icons.Filled.WaterDrop
    AdministrationRoute.TRANSDERMAL_PATCH -> Icons.Filled.Healing
    else -> Icons.Filled.Colorize
 }
 /**
 * Marqueurs d'ANALYSE DE SANG pour UNE dose (v1.12.0, demande utilisatrice :
 * « une petite indication … dans le cas où un test sanguin a été effectué
 * avant ou après une prise — peut-être un petit encart sur le côté »).
 *
 * Une analyse compte si elle tombe le MÊME JOUR calendaire LOCAL que la
 * dose : au-delà, le lien clinique (labs au creux/pic autour d'une
 * injection) devient ténu et chaque dose finirait marquée.
 *
 * @return Pair(AVANT la dose, APRÈS la dose) — une analyse exactement À
 * l'heure de la dose compte comme APRÈS (convention arbitraire documentée).
 * PUR → testable en JVM (DosesExtrasTest) ; miroir web `labMarkersForDose`
 * (js/util/format.js).
 */
 fun labMarkersForDose(
    labs: List<LabResult>,
    doseMs: Long,
    zone: ZoneId = ZoneId.systemDefault()
 ): Pair<Boolean, Boolean> {
    val day = Instant.ofEpochMilli(doseMs).atZone(zone).toLocalDate()
    var before = false
    var after = false
    for (lab in labs) {
        if (Instant.ofEpochMilli(lab.timestamp).atZone(zone).toLocalDate() == day) {
            if (lab.timestamp < doseMs) before = true else after = true
        }
    }
    return before to after
 }
@OptIn(ExperimentalMaterial3Api::class)
@Composable
 fun DosesScreen() {
@ -119,8 +60,6 @@ fun DosesScreen() {
    val repo = container.repository
    val doseLogs by repo.allDoseLogs.collectAsState(initial = emptyList())
    val treatments by repo.allTreatments.collectAsState(initial = emptyList())
    // v1.12.0 : les labs alimentent les marqueurs « prise de sang avant/après »
    val labResults by repo.allLabResults.collectAsState(initial = emptyList())
    val treatmentMap = remember(treatments) { treatments.associateBy { it.id } }
    var showLogDialog by remember { mutableStateOf(false) }
@ -219,24 +158,6 @@ fun DosesScreen() {
                            val time = timeFmt.format(Instant.ofEpochMilli(log.timestamp).atZone(zone))
                            ListItem(
                                modifier = Modifier.clickable { toEdit = log },
                                // v1.12.0 : icône de FORME DE PRISE à gauche —
                                // oral / injection IM / injection SC / gel /
                                // patch / autre se repèrent d'un coup d'œil.
                                leadingContent = {
                                    Icon(
                                        routeIcon(tr?.route),
                                        contentDescription = tr?.let {
                                            stringResource(routeLabelRes(it.route))
                                        },
                                        tint = if (tr?.route == AdministrationRoute.INJECTION_SUBCUT) {
                                            // IM/SC partagent le glyphe seringue :
                                            // la teinte tertiary distingue la SC
                                            MaterialTheme.colorScheme.tertiary
                                        } else {
                                            LocalContentColor.current
                                        }
                                    )
                                },
                                headlineContent = {
                                    Text("${tr?.name ?: "?"} · ${formatDose(log.doseAmount)} ${tr?.doseUnit ?: ""}")
                                },
@ -261,18 +182,10 @@ fun DosesScreen() {
                                    }
                                },
                                trailingContent = {
                                    Row(verticalAlignment = Alignment.CenterVertically) {
                                        // v1.12.0 : encart latéral « prise de sang
                                        // le même jour » — ↑ = lab AVANT la dose,
                                        // ↓ = lab APRÈS (cf labMarkersForDose)
                                        val (labBefore, labAfter) = labMarkersForDose(labResults, log.timestamp, zone)
                                        if (labBefore) LabSideMarker(up = true)
                                        if (labAfter) LabSideMarker(up = false)
                                    IconButton(onClick = { toDelete = log }) {
                                        Icon(Icons.Filled.Delete, contentDescription = stringResource(R.string.delete))
                                    }
                                }
                                }
                            )
                        }
                    }
@ -325,37 +238,11 @@ fun DosesScreen() {
                    CoroutineScope(Dispatchers.IO).launch { repo.deleteDoseLog(log) }
                }) { Text(stringResource(R.string.delete)) }
            },
-            dismissButton = { TextButton(onClick = { toDelete = null }) { Text(stringResource(R.string.cancel)) } },
+            dismissButton = {
                TextButton(onClick = { toDelete = null }) { Text(stringResource(R.string.cancel)) }
            },
            title = { Text(stringResource(R.string.delete)) },
            text = { Text(stringResource(R.string.confirm_delete)) }
        )
    }
 }
 /**
 * Encart latéral « prise de sang le même jour que cette dose » (v1.12.0,
 * demande utilisatrice) : icône laboratoire + flèche — **↑** = analyse
 * effectuée AVANT la dose, **↓** = APRÈS. La description sémantique porte
 * la phrase complète (accessibilité TalkBack) ; le glyphe seul est décoratif
 * (contentDescription = null sur l'icône, description portée par le Row).
 */
@Composable
 private fun LabSideMarker(up: Boolean) {
    val description = stringResource(if (up) R.string.lab_before_dose else R.string.lab_after_dose)
    Row(
        verticalAlignment = Alignment.CenterVertically,
        modifier = Modifier.semantics { contentDescription = description }
    ) {
        Icon(
            Icons.Filled.Science,
            contentDescription = null,
            tint = LabDot,
            modifier = Modifier.size(16.dp)
        )
        Text(
            if (up) "↑" else "↓",
            style = MaterialTheme.typography.labelSmall,
            color = LabDot
        )
    }
 }
--- a/app/src/main/java/com/hormonetrack/ui/screens/HomeScreen.kt
+++ b/app/src/main/java/com/hormonetrack/ui/screens/HomeScreen.kt
@ -72,13 +72,12 @@ import java.time.format.DateTimeFormatter
 import java.util.Locale
 import kotlin.math.abs
-private const val HOUR_MS = 3_600_000L
+private val HOUR_MS = 3_600_000L
@OptIn(ExperimentalMaterial3Api::class)
@Composable
 fun HomeScreen(
    openLogDoseForTreatmentId: Long?,
    onLogDoseConsumed: () -> Unit,
    onOpenSettings: () -> Unit,
    onOpenCharts: () -> Unit,
    onOpenTreatment: (Long) -> Unit
@ -114,16 +113,10 @@ fun HomeScreen(
    var showLogDialog by remember { mutableStateOf(false) }
    var preselectId by remember { mutableStateOf<Long?>(null) }
    // Demande de notification : ouvrir le dialog UNE SEULE FOIS puis
    // CONSOMMER la demande au niveau activité (fix #69 — l'ancien code
    // relançait le dialog à chaque RÉ-ENTRÉE en composition de Home :
    // quitter l'onglet détruit les remember locaux, le paramètre d'intent
    // lui survivait → retour sur l'accueil = dialog fantôme à chaque fois).
    LaunchedEffect(openLogDoseForTreatmentId) {
        openLogDoseForTreatmentId?.takeIf { it > 0 }?.let {
            showLogDialog = true
            preselectId = it
            onLogDoseConsumed()
        }
    }
@ -135,10 +128,7 @@ fun HomeScreen(
        }
    }
-    // v1.8.2 : allTreatments et tConfig ajoutés aux clés — éditer un
+    val curve by produceState<List<LevelPoint>>(emptyList(), effectiveAuto, doseLogs, tick) {
    // scaleFactor ou le modèle T rafraîchit la courbe immédiatement
    // (l'ancien trio de clés ratait ces changements jusqu'au tick de 60 s)
    val curve by produceState<List<LevelPoint>>(emptyList(), allTreatments, tConfig, effectiveAuto, doseLogs, tick) {
        withContext(Dispatchers.Default) {
            val end = System.currentTimeMillis()
            value = PharmacokineticEngine.computeCurve(
@ -241,20 +231,14 @@ fun HomeScreen(
            // (l'accueil ne fait pas doublon d'explication).
            val labRecommendation by produceState(
                initialValue = null as LabTiming.LabRecommendation?,
-                allTreatments, doseLogs, labResults, tick, effectiveAuto
+                allTreatments, doseLogs, labResults, tick
            ) {
                value = withContext(Dispatchers.Default) {
                    // v1.13.0 : les facteurs d'échelle de l'auto-calibration
                    // alimentent la prédiction « ≈ X pg/mL au creux » (null
                    // si l'option est OFF → carte sans valeur, inchangée)
                    LabTiming.nextBloodDrawRecommendation(
-                        allTreatments, doseLogs, labResults, System.currentTimeMillis(),
+                        allTreatments, doseLogs, labResults, System.currentTimeMillis()
                        effectiveAuto?.esterScales
                    )
                }
            }
            // Cible de creux (v1.13.0) : colore la prédiction (lecture seule)
            val troughTarget by container.settings.troughTarget.collectAsState(initial = null)
            labRecommendation?.let { rec ->
                val fmtDate = remember {
                    DateTimeFormatter.ofPattern("EEE d MMM HH:mm", Locale.getDefault())
@ -276,37 +260,6 @@ fun HomeScreen(
                            stringResource(R.string.labrec_when, fmtDate.format(Instant.ofEpochMilli(rec.troughMs))),
                            style = MaterialTheme.typography.bodyLarge
                        )
                        // v1.13.0 : valeur E2 ATTENDUE au creux (seulement si
                        // la calibration est disponible) + statut face à la
                        // cible de creux personnelle (lecture seule — jamais
                        // de notification, distinct des seuils d'alerte)
                        rec.predictedE2?.let { predicted ->
                            val targetStatus = LabTiming.troughTargetStatus(
                                predicted, troughTarget?.first, troughTarget?.second
                            )
                            Text(
                                stringResource(
                                    R.string.labrec_predicted,
                                    String.format(java.util.Locale.getDefault(), "%.0f", predicted)
                                ) + when (targetStatus) {
                                    LabTiming.TroughTargetStatus.IN_TARGET ->
                                        " — " + stringResource(R.string.labrec_in_target)
                                    LabTiming.TroughTargetStatus.BELOW,
                                    LabTiming.TroughTargetStatus.ABOVE ->
                                        " — " + stringResource(R.string.labrec_out_of_target)
                                    null -> ""
                                },
                                style = MaterialTheme.typography.bodyMedium,
                                color = when (targetStatus) {
                                    LabTiming.TroughTargetStatus.IN_TARGET ->
                                        MaterialTheme.colorScheme.primary
                                    LabTiming.TroughTargetStatus.BELOW,
                                    LabTiming.TroughTargetStatus.ABOVE ->
                                        MaterialTheme.colorScheme.tertiary
                                    null -> MaterialTheme.colorScheme.onSurface
                                }
                            )
                        }
                        Text(
                            stringResource(
                                R.string.labrec_before_injection,
@ -502,76 +455,49 @@ private fun NowLevelCard(curve: List<LevelPoint>) {
    }
 }
 /**
 * Ligne « prochaine prise » d'un traitement (v1.9.6 — PUR, testable JVM) :
 * « Xj Yh · ven. 25 10:00 (nom) » au-delà de 24 h (les heures deviennent peu
 * lisibles, v1.4.1), « XhMM · HH:mm (nom) » en dessous, « N min · HH:mm
 * (nom) » dans l'heure. Utilisée par chaque ligne de [NextDoseCard].
 */
 internal fun nextDoseLine(
    nowMs: Long,
    fireMs: Long,
    name: String,
    /** Template localisé du cas ≥ 24 h (string `next_dose_days`, 4 args). */
    daysTemplate: String,
    zone: ZoneId = ZoneId.systemDefault(),
    locale: Locale = Locale.getDefault()
 ): String {
    val deltaMs = fireMs - nowMs
    val h = deltaMs / HOUR_MS
    val m = (deltaMs % HOUR_MS) / 60_000L
    return if (h >= 24) {
        val (days, remH) = com.hormonetrack.util.HrtDuration.daysAndHours(h)
        val dayTimeStr = DateTimeFormatter.ofPattern("EEE d HH:mm")
            .withZone(zone)
            .withLocale(locale)
            .format(Instant.ofEpochMilli(fireMs))
        String.format(locale, daysTemplate, days, remH, dayTimeStr, name)
    } else {
        val timeStr = DateTimeFormatter.ofPattern("HH:mm")
            .withZone(zone)
            .withLocale(locale)
            .format(Instant.ofEpochMilli(fireMs))
        if (h > 0) {
            String.format(locale, "%dh%02d · %s (%s)", h, m, timeStr, name)
        } else {
            String.format(locale, "%d min · %s (%s)", m, timeStr, name)
        }
    }
 }
@Composable
 private fun NextDoseCard(treatments: List<Treatment>, doseLogs: List<DoseLog>) {
    // v1.4.0 (fix #52) : les dates de rappel passent par le moteur — la carte
    // suit la grille Posologie (jour du créneau uniquement) comme les alarmes.
    // v1.9.6 (demande) : la carte liste TOUTES les prochaines prises, UNE
    // ligne par traitement, TRIÉES par prochaine prise — l'ancienne carte ne
    // montrait que la plus proche, et une prise quotidienne (CPA) masquait
    // totalement le rappel de l'injection hebdomadaire (le rappel EEn
    // « n'arrivait qu'après celui de la CPA »). Le titre passe au pluriel
    // dès qu'il y a au moins deux lignes.
    val nowMs = System.currentTimeMillis()
    val fires = treatments
        .mapNotNull { tr -> PharmacokineticEngine.nextReminderFireFor(tr, doseLogs, nowMs)?.let { tr to it } }
        .sortedBy { it.second }
    if (fires.isEmpty()) return
    val next = fires.minByOrNull { it.second }!!.second
    val nextTreatment = fires.minByOrNull { it.second }!!.first
    Card(Modifier.fillMaxWidth()) {
        Column(Modifier.padding(16.dp)) {
            Text(
-                stringResource(if (fires.size == 1) R.string.next_dose else R.string.next_doses),
+                stringResource(R.string.next_dose),
                style = MaterialTheme.typography.labelMedium
            )
            Spacer(Modifier.height(4.dp))
-            // Première ligne (la plus proche) mise en avant, les suivantes en
+            val deltaMs = next - System.currentTimeMillis()
-            // style secondaire — même hiérarchie visuelle que v1.4.x.
+            val h = deltaMs / HOUR_MS
-            fires.forEachIndexed { idx, (treatment, next) ->
+            val m = (deltaMs % HOUR_MS) / 60_000L
            val name = nextTreatment?.name ?: ""
            // v1.4.1 : au-delà de 24 h, afficher en JOURS (les heures
            // deviennent peu lisibles) + le jour de la semaine dans la date.
            if (h >= 24) {
                val (days, remH) = com.hormonetrack.util.HrtDuration.daysAndHours(h)
                val dayTimeStr = DateTimeFormatter.ofPattern("EEE d HH:mm")
                    .withZone(ZoneId.systemDefault())
                    .format(Instant.ofEpochMilli(next))
                Text(
-                    nextDoseLine(
+                    stringResource(R.string.next_dose_days, days, remH, dayTimeStr, name),
-                        nowMs, next, treatment?.name ?: "",
+                    style = MaterialTheme.typography.titleMedium
-                        stringResource(R.string.next_dose_days)
+                )
-                    ),
+            } else {
-                    style = if (idx == 0) MaterialTheme.typography.titleMedium
+                val timeStr = DateTimeFormatter.ofPattern("HH:mm")
-                    else MaterialTheme.typography.bodyMedium
+                    .withZone(ZoneId.systemDefault())
                    .format(Instant.ofEpochMilli(next))
                Text(
                    if (h > 0) {
                        String.format(Locale.getDefault(), "%dh%02d · %s (%s)", h, m, timeStr, name)
                    } else {
                        String.format(Locale.getDefault(), "%d min · %s (%s)", m, timeStr, name)
                    },
                    style = MaterialTheme.typography.titleMedium
                )
            }
        }
--- a/app/src/main/java/com/hormonetrack/ui/screens/LabsScreen.kt
+++ b/app/src/main/java/com/hormonetrack/ui/screens/LabsScreen.kt
@ -1,6 +1,7 @@
 package com.hormonetrack.ui.screens
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.WindowInsets
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
@ -40,8 +41,6 @@ import androidx.compose.ui.unit.dp
 import com.hormonetrack.R
 import com.hormonetrack.data.model.LabResult
 import com.hormonetrack.pk.LabTiming
 import com.hormonetrack.pk.PharmacokineticEngine
 import com.hormonetrack.pk.TConfig
 import com.hormonetrack.ui.LocalAppContainer
 import com.hormonetrack.ui.components.LabDialog
 import com.hormonetrack.ui.components.formatLabValue
@ -145,30 +144,14 @@ fun LabsScreen() {
        }
    }
    val nowMs = remember(tick) { System.currentTimeMillis() }
    // Auto-calibration (v1.13.0) : alimente la prédiction « ≈ X pg/mL » de la
    // carte reco (null si l'option est OFF) — même pattern que HomeScreen.
    val autoCalibrate by container.settings.autoCalibrate.collectAsState(initial = false)
    val tConfig by container.settings.tConfig.collectAsState(initial = TConfig())
    val effectiveAuto by produceState<PharmacokineticEngine.AutoCalibrated?>(
        null, treatments, doseLogs, labs, tConfig, autoCalibrate
    ) {
        value = if (!autoCalibrate) null
        else withContext(Dispatchers.Default) {
            PharmacokineticEngine.autoCalibrated(treatments, doseLogs, labs, tConfig)
        }
    }
    // Cible de creux (v1.13.0) : colore la prédiction (lecture seule)
    val troughTarget by container.settings.troughTarget.collectAsState(initial = null)
    // Calcul HORS UI thread (produceState) — c'est un calcul PK complet
    // (courbe prévisionnelle), même discipline que Home/Chart.
    val recommendation by produceState(
        initialValue = null as LabTiming.LabRecommendation?,
-        treatments, doseLogs, labs, nowMs, effectiveAuto
+        treatments, doseLogs, labs, nowMs
    ) {
        value = withContext(Dispatchers.Default) {
-            LabTiming.nextBloodDrawRecommendation(
+            LabTiming.nextBloodDrawRecommendation(treatments, doseLogs, labs, nowMs)
                treatments, doseLogs, labs, nowMs, effectiveAuto?.esterScales
            )
        }
    }
    // Invite « renseigne une Posologie » (v1.8.0, demande explicite) : quand
@ -211,36 +194,6 @@ fun LabsScreen() {
                            stringResource(R.string.labrec_when, fmt.format(Instant.ofEpochMilli(r.troughMs))),
                            style = MaterialTheme.typography.bodyLarge
                        )
                        // v1.13.0 : valeur E2 ATTENDUE au creux (seulement si
                        // la calibration est disponible) + statut cible —
                        // lecture seule, jamais de notification (cf §9.bis)
                        r.predictedE2?.let { predicted ->
                            val targetStatus = LabTiming.troughTargetStatus(
                                predicted, troughTarget?.first, troughTarget?.second
                            )
                            Text(
                                stringResource(
                                    R.string.labrec_predicted,
                                    String.format(java.util.Locale.getDefault(), "%.0f", predicted)
                                ) + when (targetStatus) {
                                    LabTiming.TroughTargetStatus.IN_TARGET ->
                                        " — " + stringResource(R.string.labrec_in_target)
                                    LabTiming.TroughTargetStatus.BELOW,
                                    LabTiming.TroughTargetStatus.ABOVE ->
                                        " — " + stringResource(R.string.labrec_out_of_target)
                                    null -> ""
                                },
                                style = MaterialTheme.typography.bodyMedium,
                                color = when (targetStatus) {
                                    LabTiming.TroughTargetStatus.IN_TARGET ->
                                        MaterialTheme.colorScheme.primary
                                    LabTiming.TroughTargetStatus.BELOW,
                                    LabTiming.TroughTargetStatus.ABOVE ->
                                        MaterialTheme.colorScheme.tertiary
                                    null -> MaterialTheme.colorScheme.onSurface
                                }
                            )
                        }
                        Text(
                            stringResource(
                                R.string.labrec_before_injection,
--- a/app/src/main/java/com/hormonetrack/ui/screens/SettingsScreen.kt
+++ b/app/src/main/java/com/hormonetrack/ui/screens/SettingsScreen.kt
@ -1,10 +1,17 @@
 package com.hormonetrack.ui.screens
 import android.content.Intent
 import android.net.Uri
 import android.os.Build
 import android.provider.Settings
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.rememberScrollState
@ -12,10 +19,16 @@ import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.ArrowBack
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Button
 import androidx.compose.material3.Card
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.FilterChip
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.OutlinedButton
 import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.material3.TopAppBar
@ -34,84 +47,49 @@ import androidx.appcompat.app.AppCompatDelegate
 import androidx.core.os.LocaleListCompat
 import com.hormonetrack.R
 import com.hormonetrack.data.backup.BackupManager
-import com.hormonetrack.data.backup.UserSettings
+import com.hormonetrack.util.AppLog
 import com.hormonetrack.pk.Alerts
 import com.hormonetrack.pk.PharmacokineticEngine
 import com.hormonetrack.pk.TConfig
 import com.hormonetrack.reminder.AlarmScheduler
 import com.hormonetrack.ui.LocalAppContainer
 import com.hormonetrack.ui.screens.settings.AboutCard
 import com.hormonetrack.ui.screens.settings.AlertThresholdsCard
 import com.hormonetrack.ui.screens.settings.AutoBackupCard
 import com.hormonetrack.ui.screens.settings.AutoCalibrationCard
 import com.hormonetrack.ui.screens.settings.BackupCard
 import com.hormonetrack.ui.screens.settings.ChartTimezoneCard
 import com.hormonetrack.ui.screens.settings.LanguageCard
 import com.hormonetrack.ui.screens.settings.LogsCard
 import com.hormonetrack.ui.screens.settings.RemindersCard
 import com.hormonetrack.ui.screens.settings.TroughTargetCard
 import com.hormonetrack.ui.screens.settings.TModelCard
 import com.hormonetrack.util.AppLog
 import com.hormonetrack.util.ExportFileNames
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.withContext
 import java.util.Locale
 /**
 * Écran PARAMÈTRES (v1.9.8 : découpé en cartes thématiques, cf le
 * sous-package [com.hormonetrack.ui.screens.settings] — comportement et
 * rendu IDENTIQUES, chaque carte est un fichier dédié documenté).
 *
 * Cet orchestrateur garde ce qui est PARTAGÉ entre cartes :
 *  - la collecte des réglages DataStore (collectAsState) ;
 *  - les 4 launchers SAF (export JSON, export logs, import, dossier
 *    auto-backup) : leurs callbacks écrivent l'état `message` et le dialog
 *    de confirmation d'import, déclarés ICI ;
 *  - le dialog de confirmation d'import (écrasement) ;
 *  - l'ordre d'affichage des cartes.
 */
@OptIn(ExperimentalMaterial3Api::class)
@Composable
 fun SettingsScreen(onBack: () -> Unit) {
    val container = LocalAppContainer.current
    val repo = container.repository
    val context = LocalContext.current
    val scheduler = remember { AlarmScheduler(context) }
    val tConfig by container.settings.tConfig.collectAsState(initial = TConfig())
    val currentLanguage by container.settings.language.collectAsState(initial = "system")
    val autoCalibrate by container.settings.autoCalibrate.collectAsState(initial = false)
    // Seuils d'alerte (v1.4.2) : limites E2/T évaluées sur l'accueil
    val alertThresholds by container.settings.alertThresholds.collectAsState(
-        initial = Alerts.Thresholds()
+        initial = com.hormonetrack.pk.Alerts.Thresholds()
    )
    // Cible de creux (v1.13.0) : référence de lab personnelle — distincte
    // des seuils d'alerte (cf TroughTargetCard)
    val troughTarget by container.settings.troughTarget.collectAsState(initial = null)
    // Fuseau de lecture du graphique (v1.4.5) : null = fuseau du téléphone
    val chartTimezone by container.settings.chartTimezone.collectAsState(initial = null as String?)
-    // ── Auto-backup (v1.7.0) : états collectés ici, logique dans la carte ──
+    var tBaseText by remember(tConfig.base) { mutableStateOf(formatDoubles(tConfig.base)) }
-    val autoBackupEnabled by container.settings.autoBackupEnabled
+    var tFloorText by remember(tConfig.floor) { mutableStateOf(formatDoubles(tConfig.floor)) }
-        .collectAsState(initial = false)
+    var tKText by remember(tConfig.k) { mutableStateOf(formatDoubles(tConfig.k)) }
    val autoBackupTreeUri by container.settings.autoBackupTreeUri
        .collectAsState(initial = null as String?)
    val autoBackupKeep by container.settings.autoBackupKeep.collectAsState(initial = 7)
    val autoBackupLastRun by container.settings.autoBackupLastRun
        .collectAsState(initial = null as Pair<String?, Long?>?)
    var showImportConfirm by remember { mutableStateOf(false) }
    var importJson by remember { mutableStateOf<String?>(null) }
    var logLineCount by remember { mutableIntStateOf(AppLog.count()) }
    // Message de feedback affiché en haut de l'écran (succès/échec des exports,
    // imports, calibration T…) — déclaré AVANT les launchers : le callback de
    // logExportLauncher l'écrit (un state local doit être déclaré avant le
    // lambda qui le capture).
    var message by remember { mutableStateOf<String?>(null) }
    /** Écrit le feedback depuis le thread principal (les cartes l'appellent). */
    val showMessage: (String) -> Unit = { message = it }
    val logExportLauncher = rememberLauncherForActivityResult(
        ActivityResultContracts.CreateDocument("text/plain")
    ) { uri ->
@ -156,6 +134,7 @@ fun SettingsScreen(onBack: () -> Unit) {
            }
        }
    }
    var importJson by remember { mutableStateOf<String?>(null) }
    val exportLauncher = rememberLauncherForActivityResult(
        ActivityResultContracts.CreateDocument("application/json")
@ -165,20 +144,13 @@ fun SettingsScreen(onBack: () -> Unit) {
            // v1.4.2 : le backup embarque aussi les PARAMÈTRES utilisateur
            // (langue, auto-calibration, seuils d'alerte) — collect des
            // DataStore Flows (first()) avant sérialisation.
-            // UNE seule collecte des seuils (les 4 champs viennent du même
+            val settings = com.hormonetrack.data.backup.UserSettings(
            // snapshot DataStore — 4 × .first() = 4 collectes redondantes)
            val thresholds = container.settings.alertThresholds.first()
            val settings = UserSettings(
                language = container.settings.language.first(),
                autoCalibrate = container.settings.autoCalibrate.first(),
-                alertE2High = thresholds.e2High,
+                alertE2High = container.settings.alertThresholds.first().e2High,
-                alertE2Low = thresholds.e2Low,
+                alertE2Low = container.settings.alertThresholds.first().e2Low,
-                alertTHigh = thresholds.tHigh,
+                alertTHigh = container.settings.alertThresholds.first().tHigh,
-                alertTLow = thresholds.tLow,
+                alertTLow = container.settings.alertThresholds.first().tLow
                // v1.13.0 : la cible de creux voyage dans le backup (champs
                // optionnels — absents d'un backup v1/v2 ancien, rétrocompatibles)
                troughTargetLow = container.settings.troughTarget.first()?.first,
                troughTargetHigh = container.settings.troughTarget.first()?.second
            )
            val json = BackupManager.exportJson(repo, tConfig, settings)
            val ok = BackupManager.writeBackup(context, uri, json)
@ -211,8 +183,22 @@ fun SettingsScreen(onBack: () -> Unit) {
    // L'utilisateur choisit le dossier UNE FOIS (ACTION_OPEN_DOCUMENT_TREE) :
    // la permission persistable survit au reboot, le worker WorkManager écrit
    // ensuite sans intervention — AUCUNE permission de stockage déclarée.
-    // pickFolderToEnable distingue les deux entrées du picker (switch vs
+    // pickFolderToEnable distingue les deux entrées du picker :
-    // « Choisir le dossier » — cf AutoBackupCard).
+    //  - via le SWITCH quand aucun dossier n'existe encore → la sélection
    //    ACTIVE la sauvegarde (+ premier run immédiat) : le switch sans
    //    dossier ne peut rien faire, le picker est la suite logique ;
    //  - via « Choisir le dossier » (changement) → on enregistre le dossier
    //    SANS changer l'état activé/désactivé.
    val autoBackupEnabled by container.settings.autoBackupEnabled
        .collectAsState(initial = false)
    val autoBackupTreeUri by container.settings.autoBackupTreeUri
        .collectAsState(initial = null as String?)
    val autoBackupKeep by container.settings.autoBackupKeep.collectAsState(initial = 7)
    val autoBackupLastRun by container.settings.autoBackupLastRun
        .collectAsState(initial = null as Pair<String?, Long?>?)
    var autoBackupKeepText by remember(autoBackupKeep) {
        mutableStateOf(autoBackupKeep.toString())
    }
    var pickFolderToEnable by remember { mutableStateOf(false) }
    val folderPickerLauncher = rememberLauncherForActivityResult(
@ -246,7 +232,6 @@ fun SettingsScreen(onBack: () -> Unit) {
        }
    }
    // ── Assemblage : l'ordre des cartes fait le rendu de l'écran ───────────
    Column(
        Modifier
            .fillMaxSize()
@ -268,56 +253,503 @@ fun SettingsScreen(onBack: () -> Unit) {
            Spacer(Modifier.height(8.dp))
        }
-        LanguageCard(currentLanguage)
+        // --- Language ---
-        Spacer(Modifier.height(12.dp))
+        Card(Modifier.fillMaxWidth()) {
-        AutoCalibrationCard(autoCalibrate)
+            Column(Modifier.padding(12.dp)) {
-        Spacer(Modifier.height(12.dp))
+                Text(stringResource(R.string.language), style = MaterialTheme.typography.titleMedium)
-        TModelCard(tConfig, showMessage)
+                Spacer(Modifier.height(6.dp))
-        Spacer(Modifier.height(12.dp))
+                Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
-        AlertThresholdsCard(alertThresholds, showMessage)
+                    FilterChip(
-        Spacer(Modifier.height(12.dp))
+                        selected = currentLanguage == "system",
-        TroughTargetCard(troughTarget, showMessage)
+                        onClick = {
-        Spacer(Modifier.height(12.dp))
+                            CoroutineScope(Dispatchers.IO).launch {
-        ChartTimezoneCard(chartTimezone, showMessage)
+                                container.settings.setLanguage("system")
-        Spacer(Modifier.height(12.dp))
+                                withContext(Dispatchers.Main) {
-        RemindersCard()
+                                    AppCompatDelegate.setApplicationLocales(
-        Spacer(Modifier.height(12.dp))
+                                        LocaleListCompat.getEmptyLocaleList()
        BackupCard(
            onExport = { exportLauncher.launch(ExportFileNames.backupFileName()) },
            onImport = { importLauncher.launch(arrayOf("application/json")) }
                                    )
-        Spacer(Modifier.height(12.dp))
+                                }
-        AutoBackupCard(
+                            }
            enabled = autoBackupEnabled,
            treeUri = autoBackupTreeUri,
            keep = autoBackupKeep,
            lastRun = autoBackupLastRun,
            onPickFolderToEnable = {
                pickFolderToEnable = true
                folderPickerLauncher.launch(null)
                        },
-            onChooseFolder = {
+                        label = { Text(stringResource(R.string.language_system)) }
                pickFolderToEnable = false
                folderPickerLauncher.launch(null)
            },
            onMessage = showMessage
                    )
-        Spacer(Modifier.height(12.dp))
+                    FilterChip(
-        LogsCard(
+                        selected = currentLanguage == "fr",
-            logLineCount = logLineCount,
+                        onClick = {
-            onExport = {
+                            CoroutineScope(Dispatchers.IO).launch {
-                // Nom de fichier via ExportFileNames (cf §14 #48) : extrait
+                                container.settings.setLanguage("fr")
-                // et testé — passer un LocalDate au pattern horaire crashait
+                                withContext(Dispatchers.Main) {
-                // l'app au tap (bug v1.3.1→v1.3.3).
+                                    AppCompatDelegate.setApplicationLocales(
-                logExportLauncher.launch(ExportFileNames.diagnosticLogFileName())
+                                        LocaleListCompat.forLanguageTags("fr")
                                    )
                                }
                            }
                        },
-            onClear = {
+                        label = { Text("Français") }
-                AppLog.clear()
+                    )
-                logLineCount = AppLog.count()
+                    FilterChip(
                        selected = currentLanguage == "en",
                        onClick = {
                            CoroutineScope(Dispatchers.IO).launch {
                                container.settings.setLanguage("en")
                                withContext(Dispatchers.Main) {
                                    AppCompatDelegate.setApplicationLocales(
                                        LocaleListCompat.forLanguageTags("en")
                                    )
                                }
                            }
                        },
                        label = { Text("English") }
                    )
                }
            }
        }
        Spacer(Modifier.height(12.dp))
        // --- Calibration automatique (E2 par période d'ester + T) — UNE seule option ---
        Card(Modifier.fillMaxWidth()) {
            Column(Modifier.padding(12.dp)) {
                Row(
                    horizontalArrangement = Arrangement.SpaceBetween,
                    modifier = Modifier.fillMaxWidth()
                ) {
                    Text(stringResource(R.string.auto_calibrate), style = MaterialTheme.typography.titleMedium)
                    Switch(
                        checked = autoCalibrate,
                        onCheckedChange = { enabled ->
                            CoroutineScope(Dispatchers.IO).launch {
                                container.settings.setAutoCalibrate(enabled)
                            }
                        }
                    )
                }
                Text(
                    stringResource(R.string.auto_calibrate_hint),
                    style = MaterialTheme.typography.labelMedium,
                    color = MaterialTheme.colorScheme.onSurfaceVariant
                )
            }
        }
        Spacer(Modifier.height(12.dp))
-        AboutCard()
+
        // --- Estimation T (réglages manuels ; l'auto-calibration ci-dessus les
        //     remplace à l'affichage quand elle est activée) ---
        Card(Modifier.fillMaxWidth()) {
            Column(Modifier.padding(12.dp)) {
                Text(stringResource(R.string.t_model_title), style = MaterialTheme.typography.titleMedium)
                Text(
                    stringResource(R.string.t_model_hint),
                    style = MaterialTheme.typography.labelMedium,
                    color = MaterialTheme.colorScheme.onSurfaceVariant
                )
                Spacer(Modifier.height(6.dp))
                Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                    OutlinedTextField(
                        value = tBaseText,
                        onValueChange = { tBaseText = it },
                        label = { Text(stringResource(R.string.t_base)) },
                        modifier = Modifier.weight(1f)
                    )
                    OutlinedTextField(
                        value = tFloorText,
                        onValueChange = { tFloorText = it },
                        label = { Text(stringResource(R.string.t_floor)) },
                        modifier = Modifier.weight(1f)
                    )
                    OutlinedTextField(
                        value = tKText,
                        onValueChange = { tKText = it },
                        label = { Text("k") },
                        modifier = Modifier.weight(1f)
                    )
                }
                Spacer(Modifier.height(8.dp))
                Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                    Button(onClick = {
                        val base = tBaseText.replace(',', '.').toDoubleOrNull() ?: return@Button
                        val floor = tFloorText.replace(',', '.').toDoubleOrNull() ?: return@Button
                        val k = tKText.replace(',', '.').toDoubleOrNull() ?: return@Button
                        CoroutineScope(Dispatchers.IO).launch {
                            container.settings.setTConfig(TConfig(base, floor, k))
                            withContext(Dispatchers.Main) {
                                message = context.getString(R.string.saved)
                            }
                        }
                    }) { Text(stringResource(R.string.save)) }
                    OutlinedButton(onClick = {
                        CoroutineScope(Dispatchers.IO).launch {
                            val labs = repo.allLabResultsOnce().filter { it.marker.equals("T", true) }
                            val trs = repo.allTreatmentsOnce()
                            val doses = repo.allDoseLogsOnce()
                            val calibrated = PharmacokineticEngine.computeTConfigCalibration(
                                labs, trs, doses, tConfig
                            )
                            calibrated?.let {
                                container.settings.setTConfig(it)
                                withContext(Dispatchers.Main) {
                                    message = context.getString(R.string.t_calibrated)
                                }
                            }
                        }
                    }) { Text(stringResource(R.string.calibrate_from_labs)) }
                }
            }
        }
        Spacer(Modifier.height(12.dp))
        // --- Seuils d'alerte (v1.4.2) : limites E2/T évaluées contre le taux
        //     estimé actuel de l'accueil (pk/Alerts.kt). Opt-in : champ vide =
        //     pas d'alerte. Haut > bas requis si les deux sont définis.
        var e2HighText by remember(alertThresholds.e2High) {
            mutableStateOf(alertThresholds.e2High?.let { formatDoubles(it) } ?: "")
        }
        var e2LowText by remember(alertThresholds.e2Low) {
            mutableStateOf(alertThresholds.e2Low?.let { formatDoubles(it) } ?: "")
        }
        var tHighText by remember(alertThresholds.tHigh) {
            mutableStateOf(alertThresholds.tHigh?.let { formatDoubles(it) } ?: "")
        }
        var tLowText by remember(alertThresholds.tLow) {
            mutableStateOf(alertThresholds.tLow?.let { formatDoubles(it) } ?: "")
        }
        var alertError by remember { mutableStateOf<String?>(null) }
        Card(Modifier.fillMaxWidth()) {
            Column(Modifier.padding(12.dp)) {
                Text(stringResource(R.string.alert_section), style = MaterialTheme.typography.titleMedium)
                Text(
                    stringResource(R.string.alert_hint),
                    style = MaterialTheme.typography.labelMedium,
                    color = MaterialTheme.colorScheme.onSurfaceVariant
                )
                Spacer(Modifier.height(6.dp))
                Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                    OutlinedTextField(
                        value = e2HighText,
                        onValueChange = { e2HighText = it },
                        label = { Text(stringResource(R.string.alert_e2_high)) },
                        modifier = Modifier.weight(1f)
                    )
                    OutlinedTextField(
                        value = e2LowText,
                        onValueChange = { e2LowText = it },
                        label = { Text(stringResource(R.string.alert_e2_low)) },
                        modifier = Modifier.weight(1f)
                    )
                }
                Spacer(Modifier.height(6.dp))
                Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                    OutlinedTextField(
                        value = tHighText,
                        onValueChange = { tHighText = it },
                        label = { Text(stringResource(R.string.alert_t_high)) },
                        modifier = Modifier.weight(1f)
                    )
                    OutlinedTextField(
                        value = tLowText,
                        onValueChange = { tLowText = it },
                        label = { Text(stringResource(R.string.alert_t_low)) },
                        modifier = Modifier.weight(1f)
                    )
                }
                alertError?.let {
                    Spacer(Modifier.height(4.dp))
                    Text(it, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall)
                }
                Spacer(Modifier.height(8.dp))
                Button(onClick = {
                    // Parsing tolérant (virgule décimale FR), champ vide = null
                    fun parse(s: String): Double? =
                        s.trim().replace(',', '.').takeIf { it.isNotEmpty() }?.toDoubleOrNull()
                    val e2High = parse(e2HighText)
                    val e2Low = parse(e2LowText)
                    val tHigh = parse(tHighText)
                    val tLow = parse(tLowText)
                    // Saisie invalide (texte non numérique) ou incohérence haut ≤ bas
                    val invalidSyntax = listOf(e2HighText, e2LowText, tHighText, tLowText)
                        .any { it.trim().isNotEmpty() && parse(it) == null }
                    val thresholds = Alerts.Thresholds(e2High, e2Low, tHigh, tLow)
                    when {
                        invalidSyntax || !thresholds.isCoherent() -> {
                            alertError = context.getString(R.string.alert_invalid)
                        }
                        else -> {
                            alertError = null
                            CoroutineScope(Dispatchers.IO).launch {
                                container.settings.setAlertThresholds(thresholds)
                                // v1.4.2 : check IMMÉDIAT (worker one-time) —
                                // si le seuil est déjà franchi, la notification
                                // part sans attendre le cycle périodique de
                                // 15 min (état anti-spam réinitialisé au besoin).
                                com.hormonetrack.reminder.AlertNotifier.checkNow(context)
                                withContext(Dispatchers.Main) {
                                    message = context.getString(R.string.saved)
                                }
                            }
                        }
                    }
                }) { Text(stringResource(R.string.save)) }
            }
        }
        Spacer(Modifier.height(12.dp))
        // --- Fuseau horaire du graphique (v1.4.5) : auto (téléphone) ou choix.
        //     Applique l'alignement minuit des labels X dans le fuseau choisi.
        var tzText by remember(chartTimezone) {
            mutableStateOf(chartTimezone ?: "")
        }
        var tzError by remember { mutableStateOf<String?>(null) }
        Card(Modifier.fillMaxWidth()) {
            Column(Modifier.padding(12.dp)) {
                Text(stringResource(R.string.timezone_section), style = MaterialTheme.typography.titleMedium)
                Text(
                    stringResource(R.string.timezone_hint),
                    style = MaterialTheme.typography.labelMedium,
                    color = MaterialTheme.colorScheme.onSurfaceVariant
                )
                Spacer(Modifier.height(6.dp))
                OutlinedTextField(
                    value = tzText,
                    onValueChange = { tzText = it },
                    label = { Text(stringResource(R.string.timezone_field)) },
                    placeholder = { Text(stringResource(R.string.timezone_auto)) },
                    singleLine = true,
                    modifier = Modifier.fillMaxWidth()
                )
                tzError?.let {
                    Spacer(Modifier.height(4.dp))
                    Text(it, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall)
                }
                Spacer(Modifier.height(8.dp))
                Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                    Button(onClick = {
                        val id = tzText.trim()
                        val valid = id.isEmpty() || try {
                            java.util.TimeZone.getTimeZone(id)
                                .let { !it.id.equals("GMT", true) || id.equals("GMT", true) }
                        } catch (_: Exception) { false }
                        if (!valid) {
                            tzError = context.getString(R.string.timezone_invalid)
                        } else {
                            tzError = null
                            CoroutineScope(Dispatchers.IO).launch {
                                container.settings.setChartTimezone(id.ifBlank { null })
                                withContext(Dispatchers.Main) {
                                    message = context.getString(R.string.saved)
                                }
                            }
                        }
                    }) { Text(stringResource(R.string.save)) }
                    OutlinedButton(onClick = {
                        tzText = ""
                        tzError = null
                        CoroutineScope(Dispatchers.IO).launch {
                            container.settings.setChartTimezone(null)
                            withContext(Dispatchers.Main) {
                                message = context.getString(R.string.saved)
                            }
                        }
                    }) { Text(stringResource(R.string.timezone_auto)) }
                }
            }
        }
        Spacer(Modifier.height(12.dp))
        // --- Reminders / exact alarms ---
        Card(Modifier.fillMaxWidth()) {
            Column(Modifier.padding(12.dp)) {
                Text(stringResource(R.string.reminders_section), style = MaterialTheme.typography.titleMedium)
                Spacer(Modifier.height(6.dp))
                if (!scheduler.canScheduleExact()) {
                    Text(
                        stringResource(R.string.exact_alarm_needed),
                        color = MaterialTheme.colorScheme.error,
                        style = MaterialTheme.typography.bodyMedium
                    )
                    Spacer(Modifier.height(6.dp))
                    Button(onClick = {
                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
                            context.startActivity(Intent(Settings.ACTION_REQUEST_SCHEDULE_EXACT_ALARM))
                        }
                    }) { Text(stringResource(R.string.grant_exact_alarm)) }
                } else {
                    Text(stringResource(R.string.exact_alarm_ok), style = MaterialTheme.typography.bodyMedium)
                }
            }
        }
        Spacer(Modifier.height(12.dp))
        // --- Backup ---
        Card(Modifier.fillMaxWidth()) {
            Column(Modifier.padding(12.dp)) {
                Text(stringResource(R.string.backup_section), style = MaterialTheme.typography.titleMedium)
                Text(
                    stringResource(R.string.backup_hint),
                    style = MaterialTheme.typography.labelMedium,
                    color = MaterialTheme.colorScheme.onSurfaceVariant
                )
                Spacer(Modifier.height(6.dp))
                Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                    Button(onClick = {
                        exportLauncher.launch(ExportFileNames.backupFileName())
                    }) { Text(stringResource(R.string.export_json)) }
                    OutlinedButton(onClick = {
                        importLauncher.launch(arrayOf("application/json"))
                    }) { Text(stringResource(R.string.import_json)) }
                }
            }
        }
        Spacer(Modifier.height(12.dp))
        // --- Sauvegarde automatique (v1.7.0) : en PLUS de l'export manuel ---
        // Opt-in pur : désactivée par défaut ; nécessite un dossier choisi
        // (SAF tree persisté) ; un run immédiat est déclenché à l'activation.
        Card(Modifier.fillMaxWidth()) {
            Column(Modifier.padding(12.dp)) {
                Row(
                    horizontalArrangement = Arrangement.SpaceBetween,
                    modifier = Modifier.fillMaxWidth()
                ) {
                    Text(stringResource(R.string.autobackup_section), style = MaterialTheme.typography.titleMedium)
                    Switch(
                        checked = autoBackupEnabled,
                        onCheckedChange = { wantEnabled ->
                            if (!wantEnabled) {
                                // Désactivation : le périodique reste planifié
                                // mais le worker sort immédiatement (no-op)
                                CoroutineScope(Dispatchers.IO).launch {
                                    container.settings.setAutoBackupEnabled(false)
                                }
                            } else if (autoBackupTreeUri == null) {
                                // Pas de dossier → le picker EST la suite :
                                // la sélection activera (+ premier run)
                                pickFolderToEnable = true
                                folderPickerLauncher.launch(null)
                            } else {
                                // Dossier existant → activation directe + run
                                CoroutineScope(Dispatchers.IO).launch {
                                    container.settings.setAutoBackupEnabled(true)
                                    com.hormonetrack.data.backup.AutoBackupScheduler.runNow(context)
                                }
                            }
                        }
                    )
                }
                Text(
                    stringResource(R.string.autobackup_hint),
                    style = MaterialTheme.typography.labelMedium,
                    color = MaterialTheme.colorScheme.onSurfaceVariant
                )
                Spacer(Modifier.height(6.dp))
                // Dossier choisi : nom lisible (documents "primary:Download" →
                // "Download") + bouton pour le changer (sans toucher au switch)
                Text(
                    stringResource(R.string.autobackup_folder) + " : " +
                        (autoBackupTreeUri?.let { folderDisplayName(it) }
                            ?: stringResource(R.string.autobackup_no_folder)),
                    style = MaterialTheme.typography.bodyMedium
                )
                TextButton(onClick = {
                    pickFolderToEnable = false
                    folderPickerLauncher.launch(null)
                }) { Text(stringResource(R.string.autobackup_choose_folder)) }
                // Dernier run (statut alimenté par le worker) : réussi/échec + date
                autoBackupLastRun?.let { (result, atMs) ->
                    if (atMs != null && atMs > 0L) {
                        val date = java.text.SimpleDateFormat("dd/MM/yyyy HH:mm", Locale.getDefault())
                            .format(java.util.Date(atMs))
                        Text(
                            text = context.getString(
                                if (result == "ok") R.string.autobackup_last_ok
                                else R.string.autobackup_last_fail,
                                date
                            ),
                            color = if (result == "ok") MaterialTheme.colorScheme.primary
                            else MaterialTheme.colorScheme.error,
                            style = MaterialTheme.typography.bodySmall
                        )
                    }
                }
                Spacer(Modifier.height(6.dp))
                // Rétention : copies conservées (1..30, borné au set) — Save
                // persiste ; le worker relit DataStore à CHAQUE run (aucun
                // re-enqueue nécessaire, cf AutoBackupScheduler)
                Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                    OutlinedTextField(
                        value = autoBackupKeepText,
                        onValueChange = { autoBackupKeepText = it },
                        label = { Text(stringResource(R.string.autobackup_keep)) },
                        singleLine = true,
                        modifier = Modifier.weight(1f)
                    )
                    Button(onClick = {
                        val keep = autoBackupKeepText.trim().toIntOrNull() ?: return@Button
                        CoroutineScope(Dispatchers.IO).launch {
                            container.settings.setAutoBackupKeep(keep) // borné [1;30]
                            withContext(Dispatchers.Main) {
                                message = context.getString(R.string.saved)
                            }
                        }
                    }) { Text(stringResource(R.string.save)) }
                }
            }
        }
        Spacer(Modifier.height(12.dp))
        // --- Logs de diagnostic (v1.3.1) ---
        Card(Modifier.fillMaxWidth()) {
            Column(Modifier.padding(12.dp)) {
                Text(stringResource(R.string.logs_section), style = MaterialTheme.typography.titleMedium)
                Text(
                    stringResource(R.string.logs_count, logLineCount),
                    style = MaterialTheme.typography.labelMedium,
                    color = MaterialTheme.colorScheme.onSurfaceVariant
                )
                Spacer(Modifier.height(6.dp))
                Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                    OutlinedButton(onClick = {
                        // Nom de fichier via ExportFileNames (cf §14 #48) :
                        // extrait et testé — passer un LocalDate au pattern
                        // horaire crashait l'app au tap (bug v1.3.1→v1.3.3).
                        logExportLauncher.launch(ExportFileNames.diagnosticLogFileName())
                    }) { Text(stringResource(R.string.logs_export)) }
                    TextButton(onClick = {
                        AppLog.clear()
                        logLineCount = AppLog.count()
                    }) { Text(stringResource(R.string.logs_clear)) }
                }
            }
        }
        Spacer(Modifier.height(12.dp))
        // --- About : version installée + lien releases Gitea ---
        Card(Modifier.fillMaxWidth()) {
            Column(Modifier.padding(12.dp)) {
                Text(stringResource(R.string.about_title), style = MaterialTheme.typography.titleMedium)
                Text(
                    stringResource(R.string.settings_version, com.hormonetrack.BuildConfig.VERSION_NAME),
                    style = MaterialTheme.typography.bodyMedium
                )
                TextButton(onClick = {
                    context.startActivity(
                        Intent(Intent.ACTION_VIEW, Uri.parse("https://gitea.cloudyfy.fr/Siphonight/HormoneTrack/releases"))
                    )
                }) { Text(stringResource(R.string.releases_link)) }
                Text(
                    stringResource(R.string.disclaimer),
                    style = MaterialTheme.typography.labelMedium,
                    color = MaterialTheme.colorScheme.onSurfaceVariant
                )
                Text(
                    stringResource(R.string.models_credit),
                    style = MaterialTheme.typography.labelMedium,
                    color = MaterialTheme.colorScheme.onSurfaceVariant
                )
            }
        }
        Spacer(Modifier.height(32.dp))
    }
@ -347,23 +779,11 @@ fun SettingsScreen(onBack: () -> Unit) {
                            it.settings?.let { us ->
                                container.settings.setAutoCalibrate(us.autoCalibrate ?: false)
                                container.settings.setAlertThresholds(
-                                    Alerts.Thresholds(
+                                    com.hormonetrack.pk.Alerts.Thresholds(
                                        e2High = us.alertE2High, e2Low = us.alertE2Low,
                                        tHigh = us.alertTHigh, tLow = us.alertTLow
                                    )
                                )
                                // v1.13.0 : cible de creux — restaurée SEULEMENT
                                // si le backup en porte une (champs non nuls
                                // ET cohérents) ; sinon on ne touche à rien
                                // (un backup ancien ne doit pas effacer la
                                // cible locale).
                                if (us.troughTargetLow != null && us.troughTargetHigh != null &&
                                    us.troughTargetHigh > us.troughTargetLow
                                ) {
                                    container.settings.setTroughTarget(
                                        us.troughTargetLow to us.troughTargetHigh
                                    )
                                }
                                withContext(Dispatchers.Main) {
                                    us.language?.let { lang ->
                                        container.settings.setLanguage(lang)
@ -397,3 +817,21 @@ fun SettingsScreen(onBack: () -> Unit) {
        )
    }
 }
 private fun formatDoubles(d: Double): String =
    if (d == d.toLong().toDouble()) d.toLong().toString() else "%.3f".format(Locale.US, d)
 /**
 * Nom lisible d'un dossier SAF tree URI (v1.7.0) : l'id d'un tree document
 * est de la forme « primary:Download » (stockage principal) ou
 * « <provider>:<chemin » pour les providers tiers (Owncloud…) — on affiche
 * la partie APRÈS le ':', sinon l'ID brut. Pur et défensif : un URI non
 * parsable s'affiche tel quel plutôt que de faire crasher l'écran.
 */
 private fun folderDisplayName(treeUriString: String): String =
    try {
        val id = android.provider.DocumentsContract.getTreeDocumentId(Uri.parse(treeUriString))
        id.substringAfter(':', id)
    } catch (_: Exception) {
        treeUriString
    }
--- a/app/src/main/java/com/hormonetrack/ui/screens/TreatmentEditorScreen.kt
+++ b/app/src/main/java/com/hormonetrack/ui/screens/TreatmentEditorScreen.kt
@ -48,11 +48,11 @@ import com.hormonetrack.R
 import com.hormonetrack.data.model.AdministrationRoute
 import com.hormonetrack.data.model.Esters
 import com.hormonetrack.data.model.PKModels
 import com.hormonetrack.data.model.modelLabelRes
 import com.hormonetrack.data.model.PKPresets
 import com.hormonetrack.data.model.Treatment
 import com.hormonetrack.data.model.TreatmentType
 import com.hormonetrack.pk.PharmacokineticEngine
 import android.app.Activity
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
 import com.hormonetrack.reminder.AlarmScheduler
@ -272,17 +272,10 @@ fun TreatmentEditorScreen(treatmentId: Long, onDone: () -> Unit) {
            Spacer(Modifier.height(8.dp))
            if (PharmacokineticEngine.isInjectionRoute(route)) {
                // v1.9.4 : la liste des esters suit la couverture RÉELLE du
                // modèle choisi (Esters.choicesForModel — miroir du DoseDialog
                // et du treatment-editor web) : le modèle ESE ANALYTIQUE offre
                // ses 6 esters injectables (EV/EU/EEn/EC/EB/EUCS) directement
                // dans l'éditeur, au lieu des seuls EV/EU/EEn de l'époque des
                // tables ODS. Chaque ester listé est dispatché par le moteur —
                // aucun choix possible ne produit 0 pg/mL.
                DropdownField(
                    label = stringResource(R.string.ester),
                    selectedLabel = ester,
-                    options = Esters.choicesForModel(model).map { it to it },
+                    options = listOf(Esters.EV, Esters.EU, Esters.EEN).map { it to it },
                    onSelect = { ester = it }
                )
                Spacer(Modifier.height(8.dp))
@ -290,26 +283,17 @@ fun TreatmentEditorScreen(treatmentId: Long, onDone: () -> Unit) {
                    label = stringResource(R.string.pk_model),
                    // v1.4.6 : 3ᵉ modèle PK (WHSAH — fit license-free de Mona,
                    // cf pk/WhsahModels.kt) superposable dans le graphique.
-                    // Label par le helper UNIQUE (règle anti-bug #59 :
+                    selectedLabel = when (model) {
-                    // jamais de when/ternaire de labels en ligne — l'ancien
+                        PKModels.TRANSFEM_SCIENCE -> stringResource(R.string.model_tfs)
-                    // à 2 branches affichait « Estrannaise » pour WHSAH).
+                        PKModels.WHSAH -> stringResource(R.string.model_whs)
-                    selectedLabel = stringResource(modelLabelRes(model)),
+                        else -> stringResource(R.string.model_ese)
                    },
                    options = listOf(
                        PKModels.ESTRANNAISE to stringResource(R.string.model_ese),
                        PKModels.TRANSFEM_SCIENCE to stringResource(R.string.model_tfs),
                        PKModels.WHSAH to stringResource(R.string.model_whs)
                    ),
-                    onSelect = { model = it
+                    onSelect = { model = it }
                        // v1.9.4 : l'ester courant peut sortir de la couverture
                        // du nouveau modèle (ex. EUCS + TFS : le V3C n'a pas de
                        // paramètres EUCS → le dispatcher donnerait 0) — on
                        // rebascule sur le premier ester couvert (EV dans les
                        // trois listes). Le recompose reconstruit ensuite la
                        // liste des esters (options = choicesForModel(model)).
                        if (ester !in Esters.choicesForModel(it)) {
                            ester = Esters.choicesForModel(it).first()
                        }
                    }
                )
            } else {
                Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
@ -450,9 +434,8 @@ fun TreatmentEditorScreen(treatmentId: Long, onDone: () -> Unit) {
                                String.format(Locale.getDefault(), "%02d:%02d", reminderTime.hour, reminderTime.minute)
                            )
                        }
-                        // Le scheduler est déjà créé au niveau de l'écran
+                        val scheduler2 = AlarmScheduler(context)
-                        // (var `scheduler`) — pas de recréation par recompose.
+                        if (!scheduler2.canScheduleExact()) {
                        if (!scheduler.canScheduleExact()) {
                            Spacer(Modifier.height(6.dp))
                            Text(
                                stringResource(R.string.exact_alarm_needed),
--- a/app/src/main/java/com/hormonetrack/ui/screens/TreatmentsScreen.kt
+++ b/app/src/main/java/com/hormonetrack/ui/screens/TreatmentsScreen.kt
@ -27,7 +27,6 @@ import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import com.hormonetrack.R
@ -37,21 +36,6 @@ import com.hormonetrack.data.model.modelLabelRes
 import com.hormonetrack.ui.LocalAppContainer
 import com.hormonetrack.ui.components.formatDose
 /**
 * ORDRE D'AFFICHAGE de la page Traitements (v1.11.0, demande utilisatrice) :
 * les ACTIFS d'abord, les INACTIFS regroupés TOUT EN BAS — l'ancien ordre
 * brut du DAO mélangeait les deux groupes et le badge discret ne suffisait
 * plus à les discerner (« peu discernables », remontée).
 *
 * Tri STABLE : l'ordre relatif À L'INTÉRIEUR de chaque groupe est conservé
 * (le tri ne réordonne jamais les actifs entre eux, ni les inactifs entre
 * eux). PUR (aucune dépendance Android) → testable en JVM
 * (TreatmentsDisplayTest) ; miroir web `treatmentsForDisplay`
 * (js/data/models.js, mêmes sémantiques).
 */
 fun treatmentsForDisplay(treatments: List<Treatment>): List<Treatment> =
    treatments.sortedBy { !it.isActive }
@OptIn(ExperimentalMaterial3Api::class)
@Composable
 fun TreatmentsScreen(
@ -61,11 +45,6 @@ fun TreatmentsScreen(
    val container = LocalAppContainer.current
    val repo = container.repository
    val treatments by repo.allTreatments.collectAsState(initial = emptyList())
    // v1.11.0 : actifs d'abord, inactifs regroupés tout en bas
    // (cf [treatmentsForDisplay]) — mémoïsé sur la liste brute.
    val displayTreatments = remember(treatments) { treatmentsForDisplay(treatments) }
    val activeTreatments = displayTreatments.filter { it.isActive }
    val inactiveTreatments = displayTreatments.filter { !it.isActive }
    Scaffold(
        floatingActionButton = {
@ -79,44 +58,22 @@ fun TreatmentsScreen(
                title = { Text(stringResource(R.string.nav_treatments)) }
            )
            LazyColumn(Modifier.fillMaxSize()) {
-                items(activeTreatments, key = { it.id }) { tr ->
+                items(treatments, key = { it.id }) { tr ->
                    TreatmentCard(tr, onClick = { onEdit(tr.id) })
                }
                // En-tête de section SEULEMENT s'il existe des inactifs —
                // la séparation visuelle (en-tête + atténuation, cf
                // TreatmentCard) rend le groupe lisible d'un coup d'œil.
                if (inactiveTreatments.isNotEmpty()) {
                    item(key = "inactive_section") {
                        Text(
                            stringResource(R.string.inactive_section),
                            style = MaterialTheme.typography.labelLarge,
                            color = MaterialTheme.colorScheme.onSurfaceVariant,
                            modifier = Modifier.padding(horizontal = 16.dp, vertical = 10.dp)
                        )
                    }
                }
                items(inactiveTreatments, key = { it.id }) { tr ->
                    TreatmentCard(tr, dimmed = true, onClick = { onEdit(tr.id) })
                }
            }
        }
    }
 }
 /**
 * Carte d'un traitement. @param dimmed : carte INACTIVE (v1.11.0) → contenu
 * atténué (alpha réduit) en PLUS du badge : second signal visuel demandé
 * (« plus distincts des actifs ») — la carte reste lisible et tappable.
 */
@OptIn(ExperimentalMaterial3Api::class)
@Composable
-private fun TreatmentCard(tr: Treatment, dimmed: Boolean = false, onClick: () -> Unit) {
+private fun TreatmentCard(tr: Treatment, onClick: () -> Unit) {
    Card(
        onClick = onClick,
        modifier = Modifier
            .fillMaxWidth()
            .padding(horizontal = 16.dp, vertical = 6.dp)
            .alpha(if (dimmed) 0.55f else 1f)
    ) {
        Column(Modifier.padding(12.dp)) {
            Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
--- a/app/src/main/java/com/hormonetrack/ui/screens/settings/AboutCard.kt
+++ b/app/src/main/java/com/hormonetrack/ui/screens/settings/AboutCard.kt
@ -1,55 +0,0 @@
 package com.hormonetrack.ui.screens.settings
 import android.content.Intent
 import android.net.Uri
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.Card
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import com.hormonetrack.BuildConfig
 import com.hormonetrack.R
 /**
 * Carte À PROPOS de l'écran Paramètres (v1.9.8 : extraite de
 * SettingsScreen.kt, comportement inchangé) : version installée (BuildConfig
 * — épinglée par un test UI depuis v1.9.8, le bug #46 des versions jamais
 * bumpées ne peut plus revenir silencieusement), lien vers les releases
 * Gitea, avertissement médical et crédit des modèles PK.
 */
@Composable
 internal fun AboutCard() {
    val context = LocalContext.current
    Card(Modifier.fillMaxWidth()) {
        Column(Modifier.padding(12.dp)) {
            Text(stringResource(R.string.about_title), style = MaterialTheme.typography.titleMedium)
            Text(
                stringResource(R.string.settings_version, BuildConfig.VERSION_NAME),
                style = MaterialTheme.typography.bodyMedium
            )
            TextButton(onClick = {
                context.startActivity(
                    Intent(Intent.ACTION_VIEW, Uri.parse("https://gitea.cloudyfy.fr/Siphonight/HormoneTrack/releases"))
                )
            }) { Text(stringResource(R.string.releases_link)) }
            Text(
                stringResource(R.string.disclaimer),
                style = MaterialTheme.typography.labelMedium,
                color = MaterialTheme.colorScheme.onSurfaceVariant
            )
            Text(
                stringResource(R.string.models_credit),
                style = MaterialTheme.typography.labelMedium,
                color = MaterialTheme.colorScheme.onSurfaceVariant
            )
        }
    }
 }
--- a/app/src/main/java/com/hormonetrack/ui/screens/settings/AlertThresholdsCard.kt
+++ b/app/src/main/java/com/hormonetrack/ui/screens/settings/AlertThresholdsCard.kt
@ -1,144 +0,0 @@
 package com.hormonetrack.ui.screens.settings
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.Button
 import androidx.compose.material3.Card
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import com.hormonetrack.R
 import com.hormonetrack.pk.Alerts
 import com.hormonetrack.reminder.AlertNotifier
 import com.hormonetrack.ui.LocalAppContainer
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 /**
 * Carte SEUILS D'ALERTE de l'écran Paramètres (v1.4.2 ; v1.9.8 : extraite de
 * SettingsScreen.kt, comportement inchangé). Limites E2 (pg/mL) / T (ng/mL)
 * évaluées contre le taux ESTIMÉ courant de l'accueil (pk/Alerts.kt) et par
 * le worker périodique de 15 min. Opt-in : champ vide = pas d'alerte sur ce
 * côté ; incohérence haut ≤ bas ou saisie non numérique = message d'erreur
 * local, rien n'est persisté.
 *
 * @param onMessage feedback affiché en haut de l'écran (message d'état).
 */
@Composable
 internal fun AlertThresholdsCard(
    alertThresholds: Alerts.Thresholds,
    onMessage: (String) -> Unit
 ) {
    val container = LocalAppContainer.current
    val context = LocalContext.current
    // Champs réinitialisés à chaque valeur persistée (clé du remember) ;
    // null (pas de seuil) = champ vide.
    var e2HighText by remember(alertThresholds.e2High) {
        mutableStateOf(alertThresholds.e2High?.let { formatDoubles(it) } ?: "")
    }
    var e2LowText by remember(alertThresholds.e2Low) {
        mutableStateOf(alertThresholds.e2Low?.let { formatDoubles(it) } ?: "")
    }
    var tHighText by remember(alertThresholds.tHigh) {
        mutableStateOf(alertThresholds.tHigh?.let { formatDoubles(it) } ?: "")
    }
    var tLowText by remember(alertThresholds.tLow) {
        mutableStateOf(alertThresholds.tLow?.let { formatDoubles(it) } ?: "")
    }
    var alertError by remember { mutableStateOf<String?>(null) }
    Card(Modifier.fillMaxWidth()) {
        Column(Modifier.padding(12.dp)) {
            Text(stringResource(R.string.alert_section), style = MaterialTheme.typography.titleMedium)
            Text(
                stringResource(R.string.alert_hint),
                style = MaterialTheme.typography.labelMedium,
                color = MaterialTheme.colorScheme.onSurfaceVariant
            )
            Spacer(Modifier.height(6.dp))
            Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                OutlinedTextField(
                    value = e2HighText,
                    onValueChange = { e2HighText = it },
                    label = { Text(stringResource(R.string.alert_e2_high)) },
                    modifier = Modifier.weight(1f)
                )
                OutlinedTextField(
                    value = e2LowText,
                    onValueChange = { e2LowText = it },
                    label = { Text(stringResource(R.string.alert_e2_low)) },
                    modifier = Modifier.weight(1f)
                )
            }
            Spacer(Modifier.height(6.dp))
            Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                OutlinedTextField(
                    value = tHighText,
                    onValueChange = { tHighText = it },
                    label = { Text(stringResource(R.string.alert_t_high)) },
                    modifier = Modifier.weight(1f)
                )
                OutlinedTextField(
                    value = tLowText,
                    onValueChange = { tLowText = it },
                    label = { Text(stringResource(R.string.alert_t_low)) },
                    modifier = Modifier.weight(1f)
                )
            }
            alertError?.let {
                Spacer(Modifier.height(4.dp))
                Text(it, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall)
            }
            Spacer(Modifier.height(8.dp))
            Button(onClick = {
                // Parsing tolérant (virgule décimale FR), champ vide = null
                fun parse(s: String): Double? =
                    s.trim().replace(',', '.').takeIf { it.isNotEmpty() }?.toDoubleOrNull()
                val e2High = parse(e2HighText)
                val e2Low = parse(e2LowText)
                val tHigh = parse(tHighText)
                val tLow = parse(tLowText)
                // Saisie invalide (texte non numérique) ou incohérence haut ≤ bas
                val invalidSyntax = listOf(e2HighText, e2LowText, tHighText, tLowText)
                    .any { it.trim().isNotEmpty() && parse(it) == null }
                val thresholds = Alerts.Thresholds(e2High, e2Low, tHigh, tLow)
                when {
                    invalidSyntax || !thresholds.isCoherent() -> {
                        alertError = context.getString(R.string.alert_invalid)
                    }
                    else -> {
                        alertError = null
                        CoroutineScope(Dispatchers.IO).launch {
                            container.settings.setAlertThresholds(thresholds)
                            // v1.4.2 : check IMMÉDIAT (worker one-time) —
                            // si le seuil est déjà franchi, la notification
                            // part sans attendre le cycle périodique de
                            // 15 min (état anti-spam réinitialisé au besoin).
                            AlertNotifier.checkNow(context)
                            withContext(Dispatchers.Main) {
                                onMessage(context.getString(R.string.saved))
                            }
                        }
                    }
                }
            }) { Text(stringResource(R.string.save)) }
        }
    }
 }
--- a/app/src/main/java/com/hormonetrack/ui/screens/settings/AutoBackupCard.kt
+++ b/app/src/main/java/com/hormonetrack/ui/screens/settings/AutoBackupCard.kt
@ -1,164 +0,0 @@
 package com.hormonetrack.ui.screens.settings
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.Button
 import androidx.compose.material3.Card
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import com.hormonetrack.R
 import com.hormonetrack.data.backup.AutoBackupScheduler
 import com.hormonetrack.ui.LocalAppContainer
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import java.util.Locale
 /**
 * Carte SAUVEGARDE AUTOMATIQUE QUOTIDIENNE de l'écran Paramètres (v1.7.0 ;
 * v1.9.8 : extraite de SettingsScreen.kt, comportement inchangé).
 *
 * Opt-in pur : désactivée par défaut ; nécessite un dossier choisi UNE fois
 * (SAF tree persisté — ACTION_OPEN_DOCUMENT_TREE, cf orchestrateur) ; un run
 * immédiat est déclenché à l'activation (feedback + validation directe).
 * Rétention 1..30 copies (le worker purge les plus vieilles, ne touche
 * JAMAIS les exports manuels — cf AutoBackupRetention).
 *
 * Sémantique des deux entrées du picker (v1.7.0) :
 *  - via le SWITCH quand aucun dossier n'existe → la sélection ACTIVE la
 *    sauvegarde (+ premier run immédiat) : le switch sans dossier ne peut
 *    rien faire, le picker est la suite logique ;
 *  - via « Choisir le dossier » (changement) → on enregistre le dossier
 *    SANS changer l'état activé/désactivé.
 *
 * @param onPickFolderToEnable ouvre le picker SAF dont la sélection ACTIVERA
 *        la sauvegarde (branche « switch sans dossier » — launcher externe).
 * @param onChooseFolder ouvre le picker SAF pour CHANGER de dossier sans
 *        toucher à l'état activé/désactivé.
 * @param onMessage feedback affiché en haut de l'écran (message d'état).
 */
@Composable
 internal fun AutoBackupCard(
    enabled: Boolean,
    treeUri: String?,
    keep: Int,
    lastRun: Pair<String?, Long?>?,
    onPickFolderToEnable: () -> Unit,
    onChooseFolder: () -> Unit,
    onMessage: (String) -> Unit
 ) {
    val container = LocalAppContainer.current
    val context = LocalContext.current
    var keepText by remember(keep) { mutableStateOf(keep.toString()) }
    Card(Modifier.fillMaxWidth()) {
        Column(Modifier.padding(12.dp)) {
            Row(
                horizontalArrangement = Arrangement.SpaceBetween,
                modifier = Modifier.fillMaxWidth()
            ) {
                Text(stringResource(R.string.autobackup_section), style = MaterialTheme.typography.titleMedium)
                Switch(
                    checked = enabled,
                    onCheckedChange = { wantEnabled ->
                        if (!wantEnabled) {
                            // Désactivation : le périodique reste planifié
                            // mais le worker sort immédiatement (no-op)
                            CoroutineScope(Dispatchers.IO).launch {
                                container.settings.setAutoBackupEnabled(false)
                            }
                        } else if (treeUri == null) {
                            // Pas de dossier → le picker EST la suite :
                            // la sélection activera (+ premier run)
                            onPickFolderToEnable()
                        } else {
                            // Dossier existant → activation directe + run
                            CoroutineScope(Dispatchers.IO).launch {
                                container.settings.setAutoBackupEnabled(true)
                                AutoBackupScheduler.runNow(context)
                            }
                        }
                    }
                )
            }
            Text(
                stringResource(R.string.autobackup_hint),
                style = MaterialTheme.typography.labelMedium,
                color = MaterialTheme.colorScheme.onSurfaceVariant
            )
            Spacer(Modifier.height(6.dp))
            // Dossier choisi : nom lisible (documents "primary:Download" →
            // "Download") + bouton pour le changer (sans toucher au switch)
            Text(
                stringResource(R.string.autobackup_folder) + " : " +
                    (treeUri?.let { folderDisplayName(it) }
                        ?: stringResource(R.string.autobackup_no_folder)),
                style = MaterialTheme.typography.bodyMedium
            )
            TextButton(onClick = onChooseFolder) {
                Text(stringResource(R.string.autobackup_choose_folder))
            }
            // Dernier run (statut alimenté par le worker) : réussi/échec + date
            lastRun?.let { (result, atMs) ->
                if (atMs != null && atMs > 0L) {
                    val date = java.text.SimpleDateFormat("dd/MM/yyyy HH:mm", Locale.getDefault())
                        .format(java.util.Date(atMs))
                    Text(
                        text = context.getString(
                            if (result == "ok") R.string.autobackup_last_ok
                            else R.string.autobackup_last_fail,
                            date
                        ),
                        color = if (result == "ok") MaterialTheme.colorScheme.primary
                        else MaterialTheme.colorScheme.error,
                        style = MaterialTheme.typography.bodySmall
                    )
                }
            }
            Spacer(Modifier.height(6.dp))
            // Rétention : copies conservées (1..30, borné au set) — Save
            // persiste ; le worker relit DataStore à CHAQUE run (aucun
            // re-enqueue nécessaire, cf AutoBackupScheduler)
            Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                OutlinedTextField(
                    value = keepText,
                    onValueChange = { keepText = it },
                    label = { Text(stringResource(R.string.autobackup_keep)) },
                    singleLine = true,
                    modifier = Modifier.weight(1f)
                )
                Button(onClick = {
                    val parsed = keepText.trim().toIntOrNull() ?: return@Button
                    CoroutineScope(Dispatchers.IO).launch {
                        container.settings.setAutoBackupKeep(parsed) // borné [1;30]
                        withContext(Dispatchers.Main) {
                            onMessage(context.getString(R.string.saved))
                        }
                    }
                }) { Text(stringResource(R.string.save)) }
            }
        }
    }
 }
--- a/app/src/main/java/com/hormonetrack/ui/screens/settings/AutoCalibrationCard.kt
+++ b/app/src/main/java/com/hormonetrack/ui/screens/settings/AutoCalibrationCard.kt
@ -1,58 +0,0 @@
 package com.hormonetrack.ui.screens.settings
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.Card
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import com.hormonetrack.R
 import com.hormonetrack.ui.LocalAppContainer
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 /**
 * Carte CALIBRATION AUTOMATIQUE de l'écran Paramètres (v1.9.8 : extraite de
 * SettingsScreen.kt, comportement inchangé). UNE seule option (fusionnée
 * v1.2.1) : facteurs d'échelle E2 par période d'ester + calibration du modèle
 * T, recalculés depuis les labs. Désactivée par défaut — la calibration reste
 * sous contrôle explicite de l'utilisatrice.
 */
@Composable
 internal fun AutoCalibrationCard(autoCalibrate: Boolean) {
    val container = LocalAppContainer.current
    Card(Modifier.fillMaxWidth()) {
        Column(Modifier.padding(12.dp)) {
            Row(
                horizontalArrangement = Arrangement.SpaceBetween,
                modifier = Modifier.fillMaxWidth()
            ) {
                Text(stringResource(R.string.auto_calibrate), style = MaterialTheme.typography.titleMedium)
                Switch(
                    checked = autoCalibrate,
                    onCheckedChange = { enabled ->
                        CoroutineScope(Dispatchers.IO).launch {
                            container.settings.setAutoCalibrate(enabled)
                        }
                    }
                )
            }
            Text(
                stringResource(R.string.auto_calibrate_hint),
                style = MaterialTheme.typography.labelMedium,
                color = MaterialTheme.colorScheme.onSurfaceVariant
            )
        }
    }
 }
--- a/app/src/main/java/com/hormonetrack/ui/screens/settings/BackupCard.kt
+++ b/app/src/main/java/com/hormonetrack/ui/screens/settings/BackupCard.kt
@ -1,48 +0,0 @@
 package com.hormonetrack.ui.screens.settings
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.Button
 import androidx.compose.material3.Card
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.OutlinedButton
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import com.hormonetrack.R
 /**
 * Carte SAUVEGARDE MANUELLE (JSON) de l'écran Paramètres (v1.9.8 : extraite
 * de SettingsScreen.kt, comportement inchangé). L'export passe par le picker
 * SAF système (CreateDocument) — aucun accès disque direct ; l'import
 * ouvre le backup via OpenDocument puis demande CONFIRMATION avant
 * écrasement (dialog géré par l'orchestrateur SettingsScreen).
 *
 * @param onExport lance le picker SAF d'export (launcher de l'orchestrateur)
 * @param onImport lance le picker SAF d'import (launcher de l'orchestrateur)
 */
@Composable
 internal fun BackupCard(onExport: () -> Unit, onImport: () -> Unit) {
    Card(Modifier.fillMaxWidth()) {
        Column(Modifier.padding(12.dp)) {
            Text(stringResource(R.string.backup_section), style = MaterialTheme.typography.titleMedium)
            Text(
                stringResource(R.string.backup_hint),
                style = MaterialTheme.typography.labelMedium,
                color = MaterialTheme.colorScheme.onSurfaceVariant
            )
            Spacer(Modifier.height(6.dp))
            Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                Button(onClick = onExport) { Text(stringResource(R.string.export_json)) }
                OutlinedButton(onClick = onImport) { Text(stringResource(R.string.import_json)) }
            }
        }
    }
 }
--- a/app/src/main/java/com/hormonetrack/ui/screens/settings/ChartTimezoneCard.kt
+++ b/app/src/main/java/com/hormonetrack/ui/screens/settings/ChartTimezoneCard.kt
@ -1,110 +0,0 @@
 package com.hormonetrack.ui.screens.settings
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.Button
 import androidx.compose.material3.Card
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.OutlinedButton
 import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import com.hormonetrack.R
 import com.hormonetrack.ui.LocalAppContainer
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 /**
 * Carte FUSEAU HORAIRE DU GRAPHIQUE de l'écran Paramètres (v1.4.5 ; v1.9.8 :
 * extraite de SettingsScreen.kt, comportement inchangé). « auto » = fuseau
 * du téléphone (champ vide) ; sinon un ID java.util.TimeZone (ex.
 * « Europe/Paris ») — il pilote l'alignement minuit des labels X du
 * graphique (fix #55/#67 : ticks ET labels dans le MÊME fuseau).
 *
 * La validité de l'ID est vérifiée AVANT persistance (un ID inconnu retombe
 * sur « GMT » côté java.util.TimeZone : on le détecte et on refuse).
 *
 * @param onMessage feedback affiché en haut de l'écran (message d'état).
 */
@Composable
 internal fun ChartTimezoneCard(chartTimezone: String?, onMessage: (String) -> Unit) {
    val container = LocalAppContainer.current
    val context = LocalContext.current
    var tzText by remember(chartTimezone) {
        mutableStateOf(chartTimezone ?: "")
    }
    var tzError by remember { mutableStateOf<String?>(null) }
    Card(Modifier.fillMaxWidth()) {
        Column(Modifier.padding(12.dp)) {
            Text(stringResource(R.string.timezone_section), style = MaterialTheme.typography.titleMedium)
            Text(
                stringResource(R.string.timezone_hint),
                style = MaterialTheme.typography.labelMedium,
                color = MaterialTheme.colorScheme.onSurfaceVariant
            )
            Spacer(Modifier.height(6.dp))
            OutlinedTextField(
                value = tzText,
                onValueChange = { tzText = it },
                label = { Text(stringResource(R.string.timezone_field)) },
                placeholder = { Text(stringResource(R.string.timezone_auto)) },
                singleLine = true,
                modifier = Modifier.fillMaxWidth()
            )
            tzError?.let {
                Spacer(Modifier.height(4.dp))
                Text(it, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall)
            }
            Spacer(Modifier.height(8.dp))
            Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                Button(onClick = {
                    val id = tzText.trim()
                    // Un ID inconnu retombe silencieusement sur « GMT » : on
                    // l'accepte seulement si l'utilisateur l'a VRAIMENT saisi.
                    val valid = id.isEmpty() || try {
                        java.util.TimeZone.getTimeZone(id)
                            .let { !it.id.equals("GMT", true) || id.equals("GMT", true) }
                    } catch (_: Exception) { false }
                    if (!valid) {
                        tzError = context.getString(R.string.timezone_invalid)
                    } else {
                        tzError = null
                        CoroutineScope(Dispatchers.IO).launch {
                            container.settings.setChartTimezone(id.ifBlank { null })
                            withContext(Dispatchers.Main) {
                                onMessage(context.getString(R.string.saved))
                            }
                        }
                    }
                }) { Text(stringResource(R.string.save)) }
                OutlinedButton(onClick = {
                    tzText = ""
                    tzError = null
                    CoroutineScope(Dispatchers.IO).launch {
                        container.settings.setChartTimezone(null)
                        withContext(Dispatchers.Main) {
                            onMessage(context.getString(R.string.saved))
                        }
                    }
                }) { Text(stringResource(R.string.timezone_auto)) }
            }
        }
    }
 }
--- a/app/src/main/java/com/hormonetrack/ui/screens/settings/LanguageCard.kt
+++ b/app/src/main/java/com/hormonetrack/ui/screens/settings/LanguageCard.kt
@ -1,77 +0,0 @@
 package com.hormonetrack.ui.screens.settings
 import androidx.appcompat.app.AppCompatDelegate
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.Card
 import androidx.compose.material3.FilterChip
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import androidx.core.os.LocaleListCompat
 import com.hormonetrack.R
 import com.hormonetrack.ui.LocalAppContainer
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 /**
 * Carte LANGUE de l'écran Paramètres (v1.9.8 : extraite de SettingsScreen.kt,
 * comportement inchangé). La langue est indépendante du système : « system »
 * suit la configuration du téléphone, « fr »/« en » forcent via les per-app
 * locales d'AppCompat (recréent l'activité — le réglage survit au redémarrage,
 * réappliqué par MainActivity.onCreate).
 *
 * Les libellés « Français » / « English » sont des LITTÉRAUX volontaires :
 * chaque langue s'écrit dans sa propre langue (convention i18n).
 */
@Composable
 internal fun LanguageCard(currentLanguage: String) {
    val container = LocalAppContainer.current
    /** Persiste la langue puis l'applique immédiatement (locales per-app). */
    fun applyLanguage(code: String) {
        CoroutineScope(Dispatchers.IO).launch {
            container.settings.setLanguage(code)
            withContext(Dispatchers.Main) {
                AppCompatDelegate.setApplicationLocales(
                    if (code == "system") LocaleListCompat.getEmptyLocaleList()
                    else LocaleListCompat.forLanguageTags(code)
                )
            }
        }
    }
    Card(Modifier.fillMaxWidth()) {
        Column(Modifier.padding(12.dp)) {
            Text(stringResource(R.string.language), style = MaterialTheme.typography.titleMedium)
            Spacer(Modifier.height(6.dp))
            Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                FilterChip(
                    selected = currentLanguage == "system",
                    onClick = { applyLanguage("system") },
                    label = { Text(stringResource(R.string.language_system)) }
                )
                FilterChip(
                    selected = currentLanguage == "fr",
                    onClick = { applyLanguage("fr") },
                    label = { Text("Français") }
                )
                FilterChip(
                    selected = currentLanguage == "en",
                    onClick = { applyLanguage("en") },
                    label = { Text("English") }
                )
            }
        }
    }
 }
--- a/app/src/main/java/com/hormonetrack/ui/screens/settings/LogsCard.kt
+++ b/app/src/main/java/com/hormonetrack/ui/screens/settings/LogsCard.kt
@ -1,55 +0,0 @@
 package com.hormonetrack.ui.screens.settings
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.Card
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.OutlinedButton
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import com.hormonetrack.R
 import com.hormonetrack.util.AppLog
 /**
 * Carte LOGS DE DIAGNOSTIC de l'écran Paramètres (v1.3.1 ; v1.9.8 : extraite
 * de SettingsScreen.kt, comportement inchangé). Le buffer AppLog (500
 * lignes, persisté) a permis le premier diagnostic À DISTANCE de l'historique
 * du projet (§14 #50) — l'export est le canal de support de l'app.
 *
 * @param logLineCount compteur affiché (état de l'orchestrateur : il est
 *        rafraîchi APRÈS l'export, qui ajoute des lignes au journal).
 * @param onExport exporte les logs via le picker SAF (nom de fichier sûr —
 *        helper ExportFileNames, cf bug §14 #48).
 * @param onClear efface le buffer et rafraîchit le compteur.
 */
@Composable
 internal fun LogsCard(
    logLineCount: Int,
    onExport: () -> Unit,
    onClear: () -> Unit
 ) {
    Card(Modifier.fillMaxWidth()) {
        Column(Modifier.padding(12.dp)) {
            Text(stringResource(R.string.logs_section), style = MaterialTheme.typography.titleMedium)
            Text(
                stringResource(R.string.logs_count, logLineCount),
                style = MaterialTheme.typography.labelMedium,
                color = MaterialTheme.colorScheme.onSurfaceVariant
            )
            Spacer(Modifier.height(6.dp))
            Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                OutlinedButton(onClick = onExport) { Text(stringResource(R.string.logs_export)) }
                TextButton(onClick = onClear) { Text(stringResource(R.string.logs_clear)) }
            }
        }
    }
 }
--- a/app/src/main/java/com/hormonetrack/ui/screens/settings/RemindersCard.kt
+++ b/app/src/main/java/com/hormonetrack/ui/screens/settings/RemindersCard.kt
@ -1,58 +0,0 @@
 package com.hormonetrack.ui.screens.settings
 import android.content.Intent
 import android.os.Build
 import android.provider.Settings
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.Button
 import androidx.compose.material3.Card
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import com.hormonetrack.R
 import com.hormonetrack.reminder.AlarmScheduler
 /**
 * Carte RAPPELS / ALARMES EXACTES de l'écran Paramètres (v1.9.8 : extraite de
 * SettingsScreen.kt, comportement inchangé). Les rappels de doses utilisent
 * des alarmes EXACTES (heure juste) : depuis Android 12 (S), l'autorisation
 * SCHEDULE_EXACT_ALARM est opt-in par application. Sans elle, les alarmes
 * deviennent inexactes (fenêtre ± quelques minutes) — la carte invite à
 * l'accorder via les réglages système quand c'est le cas.
 */
@Composable
 internal fun RemindersCard() {
    val context = LocalContext.current
    val scheduler = remember { AlarmScheduler(context) }
    Card(Modifier.fillMaxWidth()) {
        Column(Modifier.padding(12.dp)) {
            Text(stringResource(R.string.reminders_section), style = MaterialTheme.typography.titleMedium)
            Spacer(Modifier.height(6.dp))
            if (!scheduler.canScheduleExact()) {
                Text(
                    stringResource(R.string.exact_alarm_needed),
                    color = MaterialTheme.colorScheme.error,
                    style = MaterialTheme.typography.bodyMedium
                )
                Spacer(Modifier.height(6.dp))
                Button(onClick = {
                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
                        context.startActivity(Intent(Settings.ACTION_REQUEST_SCHEDULE_EXACT_ALARM))
                    }
                }) { Text(stringResource(R.string.grant_exact_alarm)) }
            } else {
                Text(stringResource(R.string.exact_alarm_ok), style = MaterialTheme.typography.bodyMedium)
            }
        }
    }
 }
--- a/app/src/main/java/com/hormonetrack/ui/screens/settings/SettingsFormat.kt
+++ b/app/src/main/java/com/hormonetrack/ui/screens/settings/SettingsFormat.kt
@ -1,33 +0,0 @@
 package com.hormonetrack.ui.screens.settings
 import android.net.Uri
 import java.util.Locale
 /**
 * Helpers de formatage/affichage partagés par les cartes de l'écran
 * Paramètres (v1.9.8 : extraits de SettingsScreen.kt lors du découpage en
 * cartes — cf docs/DEVELOPPEMENT.md §10). Purs et défensifs.
 */
 /**
 * Formate un Double pour l'affichage dans un champ texte : les entiers sans
 * décimales, les autres avec 3 décimales max (Locale.US : point décimal — la
 * virgule FR est tolérée À LA SAISIE via replace(',', '.') dans les cartes).
 */
 internal fun formatDoubles(d: Double): String =
    if (d == d.toLong().toDouble()) d.toLong().toString() else "%.3f".format(Locale.US, d)
 /**
 * Nom lisible d'un dossier SAF tree URI (v1.7.0) : l'id d'un tree document
 * est de la forme « primary:Download » (stockage principal) ou
 * « <provider>:<chemin » pour les providers tiers (Owncloud…) — on affiche
 * la partie APRÈS le ':', sinon l'ID brut. Pur et défensif : un URI non
 * parsable s'affiche tel quel plutôt que de faire crasher l'écran.
 */
 internal fun folderDisplayName(treeUriString: String): String =
    try {
        val id = android.provider.DocumentsContract.getTreeDocumentId(Uri.parse(treeUriString))
        id.substringAfter(':', id)
    } catch (_: Exception) {
        treeUriString
    }
--- a/app/src/main/java/com/hormonetrack/ui/screens/settings/TModelCard.kt
+++ b/app/src/main/java/com/hormonetrack/ui/screens/settings/TModelCard.kt
@ -1,118 +0,0 @@
 package com.hormonetrack.ui.screens.settings
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.Button
 import androidx.compose.material3.Card
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.OutlinedButton
 import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import com.hormonetrack.R
 import com.hormonetrack.pk.PharmacokineticEngine
 import com.hormonetrack.pk.TConfig
 import com.hormonetrack.ui.LocalAppContainer
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 /**
 * Carte ESTIMATION T de l'écran Paramètres (v1.9.8 : extraite de
 * SettingsScreen.kt, comportement inchangé). Réglages MANUELS du modèle
 * `T = plancher + (base − plancher) ÷ (1 + k·E2)` ; l'auto-calibration
 * (carte du dessus) les REMPLACE à l'affichage quand elle est activée.
 *
 * « Calibrer depuis les labs » recalcule k par période d'ester depuis les
 * analyses T enregistrées (PharmacokineticEngine.computeTConfigCalibration).
 *
 * @param onMessage feedback affiché en haut de l'écran (message d'état).
 */
@Composable
 internal fun TModelCard(tConfig: TConfig, onMessage: (String) -> Unit) {
    val container = LocalAppContainer.current
    val repo = container.repository
    val context = LocalContext.current
    // Champs de saisie réinitialisés à chaque valeur persistée (clé du
    // remember) — la virgule décimale FR est tolérée à la saisie.
    var tBaseText by remember(tConfig.base) { mutableStateOf(formatDoubles(tConfig.base)) }
    var tFloorText by remember(tConfig.floor) { mutableStateOf(formatDoubles(tConfig.floor)) }
    var tKText by remember(tConfig.k) { mutableStateOf(formatDoubles(tConfig.k)) }
    Card(Modifier.fillMaxWidth()) {
        Column(Modifier.padding(12.dp)) {
            Text(stringResource(R.string.t_model_title), style = MaterialTheme.typography.titleMedium)
            Text(
                stringResource(R.string.t_model_hint),
                style = MaterialTheme.typography.labelMedium,
                color = MaterialTheme.colorScheme.onSurfaceVariant
            )
            Spacer(Modifier.height(6.dp))
            Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                OutlinedTextField(
                    value = tBaseText,
                    onValueChange = { tBaseText = it },
                    label = { Text(stringResource(R.string.t_base)) },
                    modifier = Modifier.weight(1f)
                )
                OutlinedTextField(
                    value = tFloorText,
                    onValueChange = { tFloorText = it },
                    label = { Text(stringResource(R.string.t_floor)) },
                    modifier = Modifier.weight(1f)
                )
                OutlinedTextField(
                    value = tKText,
                    onValueChange = { tKText = it },
                    label = { Text("k") },
                    modifier = Modifier.weight(1f)
                )
            }
            Spacer(Modifier.height(8.dp))
            Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                Button(onClick = {
                    val base = tBaseText.replace(',', '.').toDoubleOrNull() ?: return@Button
                    val floor = tFloorText.replace(',', '.').toDoubleOrNull() ?: return@Button
                    val k = tKText.replace(',', '.').toDoubleOrNull() ?: return@Button
                    CoroutineScope(Dispatchers.IO).launch {
                        container.settings.setTConfig(TConfig(base, floor, k))
                        withContext(Dispatchers.Main) {
                            onMessage(context.getString(R.string.saved))
                        }
                    }
                }) { Text(stringResource(R.string.save)) }
                OutlinedButton(onClick = {
                    CoroutineScope(Dispatchers.IO).launch {
                        val labs = repo.allLabResultsOnce().filter { it.marker.equals("T", true) }
                        val trs = repo.allTreatmentsOnce()
                        val doses = repo.allDoseLogsOnce()
                        val calibrated = PharmacokineticEngine.computeTConfigCalibration(
                            labs, trs, doses, tConfig
                        )
                        calibrated?.let {
                            container.settings.setTConfig(it)
                            withContext(Dispatchers.Main) {
                                onMessage(context.getString(R.string.t_calibrated))
                            }
                        }
                    }
                }) { Text(stringResource(R.string.calibrate_from_labs)) }
            }
        }
    }
 }
--- a/app/src/main/java/com/hormonetrack/ui/screens/settings/TroughTargetCard.kt
+++ b/app/src/main/java/com/hormonetrack/ui/screens/settings/TroughTargetCard.kt
@ -1,122 +0,0 @@
 package com.hormonetrack.ui.screens.settings
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.Button
 import androidx.compose.material3.Card
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import com.hormonetrack.R
 import com.hormonetrack.ui.LocalAppContainer
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 /**
 * Carte CIBLE DE CREUX E2 de l'écran Paramètres (v1.13.0, opt-in).
 *
 * ⚠️ DISTINCT des seuils d'alerte ([AlertThresholdsCard], au-dessus) :
 *  - les seuils d'alerte surveillent le niveau estimé EN CONTINU (carte
 *    d'accueil + notification toutes les 15 min — cf §9.bis) ;
 *  - la cible de creux est une RÉFÉRENCE PERSONNELLE DE LAB : « quand je
 *    fais ma prise de sang au creux recommandé, je veux être dans
 *    [basse, haute] » — la prédiction de la carte reco est colorée
 *    contre cette bande, JAMAIS de notification.
 *
 * Opt-in pur : champ vide = désactivée (les DEUX champs, vides ou remplis).
 * Validation : haut > bas obligatoire (message rouge local, rien n'est
 * persisté sinon).
 *
 * @param target cible active (basse to haute) ou null (désactivée)
 * @param onMessage feedback affiché en haut de l'écran (message d'état).
 */
@Composable
 internal fun TroughTargetCard(target: Pair<Double, Double>?, onMessage: (String) -> Unit) {
    val container = LocalAppContainer.current
    val context = LocalContext.current
    var lowText by remember(target?.first) {
        mutableStateOf(target?.first?.let { formatDoubles(it) } ?: "")
    }
    var highText by remember(target?.second) {
        mutableStateOf(target?.second?.let { formatDoubles(it) } ?: "")
    }
    var error by remember { mutableStateOf<String?>(null) }
    Card(Modifier.fillMaxWidth()) {
        Column(Modifier.padding(12.dp)) {
            Text(stringResource(R.string.trough_target_section), style = MaterialTheme.typography.titleMedium)
            Text(
                stringResource(R.string.trough_target_hint),
                style = MaterialTheme.typography.labelMedium,
                color = MaterialTheme.colorScheme.onSurfaceVariant
            )
            Spacer(Modifier.height(6.dp))
            Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                OutlinedTextField(
                    value = lowText,
                    onValueChange = { lowText = it },
                    label = { Text(stringResource(R.string.trough_target_low)) },
                    modifier = Modifier.weight(1f)
                )
                OutlinedTextField(
                    value = highText,
                    onValueChange = { highText = it },
                    label = { Text(stringResource(R.string.trough_target_high)) },
                    modifier = Modifier.weight(1f)
                )
            }
            error?.let {
                Spacer(Modifier.height(4.dp))
                Text(it, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall)
            }
            Spacer(Modifier.height(8.dp))
            Button(onClick = {
                // Même parsing tolérant que la carte Seuils (virgule FR),
                // champ vide = null
                fun parse(s: String): Double? =
                    s.trim().replace(',', '.').takeIf { it.isNotEmpty() }?.toDoubleOrNull()
                val low = parse(lowText)
                val high = parse(highText)
                when {
                    // Un seul champ rempli = saisie incomplète (pas d'état
                    // « demi-cible » — l'app ne devine pas)
                    (low == null) != (high == null) -> {
                        error = context.getString(R.string.trough_target_incomplete)
                    }
                    low != null && high != null && high <= low -> {
                        error = context.getString(R.string.trough_target_invalid)
                    }
                    else -> {
                        error = null
                        CoroutineScope(Dispatchers.IO).launch {
                            // null to null = désactivation (setTroughTarget efface)
                            container.settings.setTroughTarget(
                                if (low != null && high != null) low to high else null
                            )
                            withContext(Dispatchers.Main) {
                                onMessage(context.getString(R.string.saved))
                            }
                        }
                    }
                }
            }) { Text(stringResource(R.string.save)) }
        }
    }
 }
--- a/app/src/main/java/com/hormonetrack/util/AppLog.kt
+++ b/app/src/main/java/com/hormonetrack/util/AppLog.kt
@ -60,9 +60,9 @@ object AppLog {
    fun log(tag: String, message: String) = synchronized(lock) {
        val line = formatLine(System.currentTimeMillis(), tag, message)
        buffer.addLast(line)
-        // Purge O(1) amortie (v1.8.2 : l'ancien trimLines recopiait TOUT le
+        val trimmed = trimLines(buffer.toList(), MAX_LINES)
-        // buffer à chaque ligne loggée) — même résultat (MAX_LINES dernières)
+        buffer.clear()
-        while (buffer.size > MAX_LINES) buffer.removeFirst()
+        buffer.addAll(trimmed)
        try {
            file?.appendText(line + "\n")
        } catch (_: Exception) {
--- a/app/src/main/res/values-fr/strings.xml
+++ b/app/src/main/res/values-fr/strings.xml
@ -17,7 +17,6 @@
    <string name="no_data">Pas encore de données — crée un traitement et logue une dose.</string>
    <string name="logged_today">Log rapide</string>
    <string name="next_dose">Prochaine dose</string>
    <string name="next_doses">Prochaines doses</string>
    <string name="next_dose_days">%1$d j %2$d h · %3$s (%4$s)</string>
    <string name="delta_6h">%1$s %2$s pg/mL vs il y a 6 h</string>
    <string name="home_chart_title">Dernières 24 h (estimation)</string>
@ -45,10 +44,6 @@
    <!-- v1.6.0 : prolongation du tracé labs au-delà du dernier lab (opt-in,
         actif seulement quand Tracé labs est ON) -->
    <string name="show_lab_track_extend">Prolonger</string>
    <!-- v1.9.0 : nuage d'incertitude du modèle ESE (posterior MCMC de
         estrannaise.js) — exclusif à ESE, off par défaut -->
    <string name="show_cloud">Nuage</string>
    <string name="legend_cloud">Nuage pointillé = incertitude des paramètres MCMC de l\'Estrannaise (modèle ESE seul)</string>
    <string name="zoom_in">Zoom avant (fenêtre plus courte)</string>
    <string name="zoom_out">Zoom arrière (fenêtre plus longue)</string>
    <string name="hrt_since">Sous THS depuis le %1$s</string>
@ -144,26 +139,6 @@
    <string name="dose_unit">Unité</string>
    <string name="active">Actif</string>
    <string name="inactive">inactif</string>
    <!-- v1.11.0 : en-tête de la section des traitements inactifs (regroupés
         en bas de la page Traitements) -->
    <string name="inactive_section">Traitements inactifs</string>
    <!-- v1.12.0 : encart latéral « prise de sang le même jour » sur les
         lignes de doses (↑ = lab avant la dose, ↓ = lab après) -->
    <string name="lab_before_dose">Prise de sang plus tôt le même jour, avant cette dose</string>
    <string name="lab_after_dose">Prise de sang plus tard le même jour, après cette dose</string>
    <!-- v1.13.0 : valeur E2 attendue au creux recommandé (affichée seulement
         si la calibration est disponible) + statut face à la cible de creux -->
    <string name="labrec_predicted">Attendu à ce creux : ≈ %1$s pg/mL</string>
    <string name="labrec_in_target">dans ta cible</string>
    <string name="labrec_out_of_target">hors de ta cible</string>
    <!-- v1.13.0 : carte Cible de creux (opt-in) — DISTINCT des seuils
         d'alerte (surveillance continue + notifications) -->
    <string name="trough_target_section">Cible de creux (prise de sang)</string>
    <string name="trough_target_hint">Référence personnelle pour la prochaine prise de sang : la valeur de creux prédite est colorée par rapport à cette bande. Distinct des seuils d\u0027alerte ci-dessus — ceux-là surveillent ton niveau estimé en continu et peuvent te notifier ; celui-ci jamais.</string>
    <string name="trough_target_low">Cible basse (pg/mL)</string>
    <string name="trough_target_high">Cible haute (pg/mL)</string>
    <string name="trough_target_incomplete">Remplis les deux champs — ou laisse les deux vides pour désactiver.</string>
    <string name="trough_target_invalid">La cible haute doit être supérieure à la cible basse.</string>
    <string name="no_treatment_hint">Crée d\'abord un traitement (onglet Traitements).</string>
    <string name="type_estradiol">Œstradiol</string>
@ -259,9 +234,6 @@
    <!-- Presets -->
    <string name="preset_ev_ese">Injection EV — Estrannaise</string>
    <string name="preset_ec_ese">Injection EC (huile) — Estrannaise</string>
    <string name="preset_eb_ese">Injection EB — Estrannaise</string>
    <string name="preset_eucs_ese">Injection EUCS (suspension cristalline) — Estrannaise</string>
    <string name="preset_eu_ese">Injection EU — Estrannaise</string>
    <string name="preset_een_ese">Injection EEn — Estrannaise</string>
    <string name="preset_ev_tfs">Injection EV — Transfem Science</string>
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@ -17,7 +17,6 @@
    <string name="no_data">No data yet — add a treatment and log a dose.</string>
    <string name="logged_today">Quick log</string>
    <string name="next_dose">Next dose</string>
    <string name="next_doses">Upcoming doses</string>
    <string name="next_dose_days">%1$d d %2$d h · %3$s (%4$s)</string>
    <string name="delta_6h">%1$s %2$s pg/mL vs 6 h ago</string>
    <string name="home_chart_title">Last 24 hours (estimate)</string>
@ -45,10 +44,6 @@
    <!-- v1.6.0 : prolongation du tracé labs au-delà du dernier lab (opt-in,
         actif seulement quand Lab track est ON) -->
    <string name="show_lab_track_extend">Extend</string>
    <!-- v1.9.0 : nuage d'incertitude du modèle ESE (posterior MCMC de
         estrannaise.js) — exclusif à ESE, off par défaut -->
    <string name="show_cloud">Cloud</string>
    <string name="legend_cloud">Dotted cloud = Estrannaise MCMC parameter uncertainty (ESE model only)</string>
    <string name="zoom_in">Zoom in (shorter window)</string>
    <string name="zoom_out">Zoom out (longer window)</string>
    <string name="hrt_since">Under HRT since %1$s</string>
@ -144,26 +139,6 @@
    <string name="dose_unit">Unit</string>
    <string name="active">Active</string>
    <string name="inactive">inactive</string>
    <!-- v1.11.0 : en-tête de la section des traitements inactifs (regroupés
         en bas de la page Traitements) -->
    <string name="inactive_section">Inactive treatments</string>
    <!-- v1.12.0 : encart latéral « prise de sang le même jour » sur les
         lignes de doses (↑ = lab avant la dose, ↓ = lab après) -->
    <string name="lab_before_dose">Blood test earlier the same day, before this dose</string>
    <string name="lab_after_dose">Blood test later the same day, after this dose</string>
    <!-- v1.13.0 : valeur E2 attendue au creux recommandé (affichée seulement
         si la calibration est disponible) + statut face à la cible de creux -->
    <string name="labrec_predicted">Expected at this trough: ≈ %1$s pg/mL</string>
    <string name="labrec_in_target">within your target</string>
    <string name="labrec_out_of_target">outside your target</string>
    <!-- v1.13.0 : carte Cible de creux (opt-in) — DISTINCT des seuils
         d'alerte (surveillance continue + notifications) -->
    <string name="trough_target_section">Trough target (blood draw)</string>
    <string name="trough_target_hint">Personal reference for the recommended blood draw: the predicted trough value is colored against this band. Distinct from the alert thresholds above — those watch your estimated level continuously and can notify you; this one never does.</string>
    <string name="trough_target_low">Target low (pg/mL)</string>
    <string name="trough_target_high">Target high (pg/mL)</string>
    <string name="trough_target_incomplete">Fill both fields — or leave both empty to disable.</string>
    <string name="trough_target_invalid">Target high must be greater than target low.</string>
    <string name="no_treatment_hint">Create a treatment first (Treatments tab).</string>
    <string name="type_estradiol">Estradiol</string>
@ -259,9 +234,6 @@
    <!-- Presets -->
    <string name="preset_ev_ese">EV injection — Estrannaise</string>
    <string name="preset_ec_ese">EC injection (oil) — Estrannaise</string>
    <string name="preset_eb_ese">EB injection — Estrannaise</string>
    <string name="preset_eucs_ese">EUCS injection (crystal suspension) — Estrannaise</string>
    <string name="preset_eu_ese">EU injection — Estrannaise</string>
    <string name="preset_een_ese">EEn injection — Estrannaise</string>
    <string name="preset_ev_tfs">EV injection — Transfem Science</string>
--- a/app/src/test/java/com/hormonetrack/data/backup/BackupGsonTest.kt
+++ b/app/src/test/java/com/hormonetrack/data/backup/BackupGsonTest.kt
@ -124,34 +124,6 @@ class BackupGsonTest {
        assertEquals(0.3, s.alertTLow!!, 1e-9)
    }
    @Test
    fun `backup round-trip preserves the trough target (v1_13_0) and stays absent when unset`() {
        // v1.13.0 : la cible de creux voyage dans le backup (champs optionnels)
        val withTarget = BackupData(
            tConfig = TConfig(),
            settings = UserSettings(troughTargetLow = 150.0, troughTargetHigh = 200.0)
        )
        val parsed: BackupData = Gson().fromJson(
            Gson().toJson(withTarget), BackupData::class.java
        )
        val s = parsed.settings
        org.junit.Assert.assertNotNull(s)
        assertEquals(150.0, s!!.troughTargetLow!!, 1e-9)
        assertEquals(200.0, s.troughTargetHigh!!, 1e-9)
        // Rétrocompatibilité : un backup SANS cible (v1.4.2→v1.12) parse les
        // champs à null — l'import ne doit pas toucher à la cible locale
        val without = BackupData(
            tConfig = TConfig(),
            settings = UserSettings(language = "en")
        )
        val parsed2: BackupData = Gson().fromJson(
            Gson().toJson(without), BackupData::class.java
        )
        assertEquals(null, parsed2.settings!!.troughTargetLow)
        assertEquals(null, parsed2.settings!!.troughTargetHigh)
    }
    @Test
    fun `legacy v1 backup without settings parses with null settings (backward compat)`() {
        // Les anciens exports (v1.4.1 et avant) n'ont PAS de champ settings :
--- a/app/src/test/java/com/hormonetrack/data/model/PKPresetsTest.kt
+++ b/app/src/test/java/com/hormonetrack/data/model/PKPresetsTest.kt
@ -1,84 +0,0 @@
 package com.hormonetrack.data.model
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertTrue
 import org.junit.Test
 /**
 * Tests des PRESETS de traitements (v1.9.4 — miroir de `tests/presets.test.js`
 * côté web) : le modèle ESE ANALYTIQUE couvre 6 esters injectables — les
 * presets de création doivent offrir les 6 (comme TFS offre les 7 du V3C et
 * WHSAH les 6 du fit Mona). Avant v1.9.4, les presets ESE n'offraient que
 * EV/EU/EEn (l'héritage des tables ODS) — remontée : « les presets n'ont pas
 * été mis à jour lors de l'ajout du modèle source ESE ».
 *
 * Garde centrale : **aucun preset ne peut créer un traitement non couvert par
 * son propre modèle** (ester ∈ choicesForModel(pkModel)) — un preset hors
 * couverture produirait 0 pg/mL sans aucun avertissement (leçon §12).
 */
 class PKPresetsTest {
    /** Presets injectables d'un modèle (ester réel — le NONE Bateman sort). */
    private fun injectables(model: String) =
        PKPresets.all.filter { it.pkModel == model && it.esterType != Esters.NONE }
    @Test
    fun `les presets ESE couvrent les 6 esters du fit analytique`() {
        val esters = injectables(PKModels.ESTRANNAISE).map { it.esterType }.sorted()
        // Même ensemble que Esters.choicesForModel(ESE) — l'éditeur et les
        // presets doivent proposer exactement la couverture du dispatch.
        assertEquals(Esters.choicesForModel(PKModels.ESTRANNAISE).sorted(), esters)
    }
    @Test
    fun `chaque ester couvert a EXACTEMENT un preset ESE (pas de doublon)`() {
        val names = injectables(PKModels.ESTRANNAISE).map { it.esterType }
        assertEquals(names.size, names.toSet().size)
    }
    @Test
    fun `les presets TFS (7) et WHSAH (6) restent inchangés`() {
        assertEquals(7, injectables(PKModels.TRANSFEM_SCIENCE).size)
        assertEquals(6, injectables(PKModels.WHSAH).size)
    }
    @Test
    fun `aucun preset injectable ne peut créer un traitement non couvert`() {
        // La garde ne vise que les presets à ester RÉEL (profil PK) : un
        // preset Bateman (esterType NONE, ex. gel/patch/oral/anti-androgène)
        // ne passe pas par le dispatch par ester — sa couverture n'a pas de
        // sens. Un preset injectable hors couverture produirait 0 pg/mL sans
        // aucun avertissement (leçon §12).
        for (preset in PKPresets.all.filter { it.esterType != Esters.NONE }) {
            assertTrue(
                "preset " + preset.nameRes + " : ester " + preset.esterType +
                    " hors couverture de " + preset.pkModel + " → 0 pg/mL garanti",
                preset.esterType in Esters.choicesForModel(preset.pkModel)
            )
        }
    }
    @Test
    fun `les presets ESE non injectables (gel patch oral) restent en Bateman`() {
        val nonInjectable = PKPresets.all.filter {
            it.pkModel == PKModels.ESTRANNAISE && it.esterType == Esters.NONE
        }
        // 3E2 (gel/patch/oral) + 3 anti-androgènes (CPA/spiro/bica)
        assertTrue("gel, patch, oral + anti-androgènes toujours présents", nonInjectable.size >= 6)
        assertTrue(nonInjectable.all { it.bioavailabilityFraction in 0.01f..1f })
    }
    @Test
    fun `les champs Bateman informatifs des nouveaux presets ESE restent plausibles`() {
        // Les champs Bateman des presets ESE reflètent les t½ terminales des
        // fits (informatifs, pas utilisés au calcul) : EC ≈ 202 h (k3 0,669/j),
        // EB ≈ 4 h (k3 4,34/j), EUCS ≈ 756 h (k2 0,022/j) — on garde des
        // bornes larges pour ne pas figer les valeurs des fits.
        val ec = PKPresets.all.first { it.esterType == Esters.EC && it.pkModel == PKModels.ESTRANNAISE }
        val eb = PKPresets.all.first { it.esterType == Esters.EB && it.pkModel == PKModels.ESTRANNAISE }
        val eucs = PKPresets.all.first { it.esterType == Esters.EUCS && it.pkModel == PKModels.ESTRANNAISE }
        assertTrue("t½ EC ESE ≈ 8,4 j (fit 0,669/j)", ec.eliminationHalfLifeHours in 100f..300f)
        assertTrue("t½ EB ESE courte (fit 4,34/j)", eb.eliminationHalfLifeHours in 1f..24f)
        assertTrue("t½ EUCS ESE ≈ 31,5 j (suspension cristalline)", eucs.eliminationHalfLifeHours in 400f..1200f)
    }
 }
--- a/app/src/test/java/com/hormonetrack/pk/CalibrationPerModelTest.kt
+++ b/app/src/test/java/com/hormonetrack/pk/CalibrationPerModelTest.kt
@ -48,9 +48,8 @@ class CalibrationPerModelTest {
        // (prédiction ≤ 0,5) → échelles vides. Les modèles TFS/WHS sont
        // purs (formes closes) et n'en dépendent pas.
        if (!PKProfileStore.hasProfile("EEN", "ESE")) {
-            val file = java.io.File("src/test/assets/pk_profiles.json")
+            val file = java.io.File("src/main/assets/pk_profiles.json")
                .takeIf { it.exists() }
                ?: java.io.File("src/main/assets/pk_profiles.json").takeIf { it.exists() }
                ?: java.io.File("app/src/main/assets/pk_profiles.json")
            PKProfileStore.initWithJson(file.readText())
        }
--- a/app/src/test/java/com/hormonetrack/pk/EstrannaiseCloudTest.kt
+++ b/app/src/test/java/com/hormonetrack/pk/EstrannaiseCloudTest.kt
@ -1,159 +0,0 @@
 package com.hormonetrack.pk
 import com.hormonetrack.data.model.AdministrationRoute
 import com.hormonetrack.data.model.DoseLog
 import com.hormonetrack.data.model.Treatment
 import com.hormonetrack.data.model.TreatmentType
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Test
 import java.io.File
 /**
 * Tests du NUAGE D'INCERTITUDE (v1.9.0 — cf doc §7.12) :
 * [EstrannaiseCloud.compute] — feature exclusive au modèle ESE (les fits
 * TFS/WHSAH ne publient pas de posterior MCMC).
 *
 * Épinglés :
 *  - 32 courbes par défaut, chacune ≥ 2 points, dans la fenêtre demandée ;
 *  - DISPERSION réelle : les courbes du nuage DIFFÈRENT entre elles (les
 *    échantillons MCMC couvrent une plage de paramètres — un nuage où toutes
 *    les courbes coïncideraient serait un bug de chargement) ;
 *  - non calculable → vide : pas de traitement ESE porteur (TFS/oral),
 *    MCMC non chargé, nbCurves < 2.
 */
 class EstrannaiseCloudTest {
    private val DAY_MS = 86_400_000L
    private val NOW = 1_790_000_000_000L
    /** Traitement EEn ESE actif, 5 mg hebdo sur 4 semaines. */
    private fun ese() = Treatment(
        id = 1, name = "EEn ESE", type = TreatmentType.ESTRADIOL,
        route = AdministrationRoute.INJECTION_IM,
        doseAmount = 5.0, doseUnit = "mg", esterType = "EEN", pkModel = "ESE",
        forecastIntervalDays = 7.0, createdAt = 0
    )
    private fun doses() = (4 downTo 1).map { k ->
        DoseLog(id = k.toLong(), treatmentId = 1, timestamp = NOW - k * 7 * DAY_MS, doseAmount = 5.0)
    }
    @Before
    fun setup() {
        if (EstrannaiseModels.mcmcSamples("EEN").isEmpty()) {
            val candidates = listOf(
                File("src/main/assets/mcmc_samples.json"),
                File("app/src/main/assets/mcmc_samples.json")
            )
            val file = candidates.firstOrNull { it.exists() }
                ?: error("mcmc_samples.json introuvable (nuage d'incertitude)")
            EstrannaiseModels.initWithJson(file.readText())
        }
    }
    @Test
    fun `cloud has 32 curves with real dispersion between them`() {
        val cloud = EstrannaiseCloud.compute(
            listOf(ese()), doses(), NOW - 30 * DAY_MS, NOW, 3_600_000L
        )
        assertEquals("32 courbes par défaut", 32, cloud.size)
        assertTrue(cloud.all { it.size >= 2 })
        // DISPERSION : le max E2 de chaque courbe diffère d'une courbe à
        // l'autre (sinon tous les échantillons seraient identiques)
        val peaks = cloud.map { c -> c.maxOf { it.e2 } }.distinct()
        assertTrue(
            "les courbes du nuage divergent (${peaks.size} maxima distincts)",
            peaks.size >= 8
        )
    }
    @Test
    fun `cloud stays within the requested window`() {
        val start = NOW - 10 * DAY_MS
        val end = NOW
        val cloud = EstrannaiseCloud.compute(
            listOf(ese()), doses(), start, end, 3_600_000L
        )
        assertTrue(cloud.all { c -> c.all { it.timestamp in start..end } })
    }
    @Test
    fun `doses of a TFS-stored treatment ARE covered when ESE is displayed (fix v1_9_2)`() {
        // FIX « le nuage ne s'active que autour du tracé émulé, pas autour du
        // modèle Estrannaise » : le traitement est STOCKÉ en TFS, mais quand
        // ESE est affiché, computeCurve(modelOverride = "ESE") redessine ses
        // doses avec le modèle Estrannaise → le nuage doit les couvrir aussi
        // (le pkModel stocké n'est pas un prérequis). Le nuage superpose les
        // doses EEn avec les params MCMC de EEN.
        val tfsStored = ese().copy(pkModel = "TFS")
        val cloud = EstrannaiseCloud.compute(listOf(tfsStored), doses(), NOW - 30 * DAY_MS, NOW, 3_600_000L)
        assertEquals(32, cloud.size)
        assertTrue(cloud.all { it.size >= 2 })
    }
    @Test
    fun `oral-only treatment produces no cloud (Bateman is not MCMC-sampled)`() {
        // L'oral Bateman n'a pas d'ester E2 échantillonnable : le posterior
        // MCMC ne s'applique pas → pas de nuage (cohérent : rien n'est tracé
        // « en ESE » pour ces doses)
        val oral = Treatment(
            id = 2, name = "CPA", type = TreatmentType.ANTI_ANDROGEN,
            route = AdministrationRoute.ORAL, doseAmount = 12.5, doseUnit = "mg",
            esterType = "NONE", forecastIntervalDays = 2.0, createdAt = 0
        )
        assertTrue(EstrannaiseCloud.compute(listOf(oral), doses(), NOW - 30 * DAY_MS, NOW, 3_600_000L).isEmpty())
    }
    @Test
    fun `unknown ester doses contribute zero (EUCS-free esters covered by ESE)`() {
        // PEP : pas de fit Estrannaise → ses doses contribuent 0 au nuage
        // (comme dans la courbe ESE) — le nuage des autres esters reste
        val pep = ese().copy(esterType = "PEP")
        val dosesPep = listOf(DoseLog(id = 9, treatmentId = 1, timestamp = NOW - 7 * DAY_MS, doseAmount = 25.0))
        val cloud = EstrannaiseCloud.compute(listOf(pep), dosesPep, NOW - 30 * DAY_MS, NOW, 3_600_000L)
        // PEP n'est pas couvert par le fit ESE → pas d'échantillon → nuage vide
        assertTrue(cloud.isEmpty())
    }
    @Test
    fun `no doses on the carrier produces no cloud`() {
        assertTrue(EstrannaiseCloud.compute(
            listOf(ese()), emptyList(), NOW - 30 * DAY_MS, NOW, 3_600_000L
        ).isEmpty())
    }
    @Test
    fun `nbCurves below 2 produces no cloud`() {
        assertTrue(EstrannaiseCloud.compute(
            listOf(ese()), doses(), NOW - 30 * DAY_MS, NOW, 3_600_000L, nbCurves = 1
        ).isEmpty())
    }
    @Test
    fun `cloud follows the calibration like the displayed ESE curve (fix v1_9_1)`() {
        // FIX « le nuage ne s'active que autour du tracé, pas autour du
        // modèle Estrannaise » : la courbe ESE affichée est CALIBRÉE
        // (scalePerEster des labs) mais le nuage était tracé BRUT → les deux
        // flottaient à des échelles différentes. Avec le MÊME scalePerEster,
        // le nuage ENTOURE la courbe calibrée (×2 ⇒ nuage ×2, écart de
        // niveau entre nuage calibré et nuage brut ≈ ×2 également).
        val scaled = mapOf("EEN" to 2.0)
        val calibrated = EstrannaiseCloud.compute(
            listOf(ese()), doses(), NOW - 30 * DAY_MS, NOW, 3_600_000L,
            scalePerEster = scaled
        )
        val raw = EstrannaiseCloud.compute(
            listOf(ese()), doses(), NOW - 30 * DAY_MS, NOW, 3_600_000L
        )
        assertEquals(calibrated.size, raw.size)
        assertTrue(calibrated.isNotEmpty())
        // Chaque point du nuage calibré ≈ 2× le point brut correspondant
        val rawLast = raw.last()
        val calLast = calibrated.last()
        assertEquals(
            calLast.last().e2, rawLast.last().e2 * 2.0, rawLast.last().e2 * 0.01
        )
    }
 }
--- a/app/src/test/java/com/hormonetrack/pk/EstrannaiseModelsTest.kt
+++ b/app/src/test/java/com/hormonetrack/pk/EstrannaiseModelsTest.kt
@ -1,161 +0,0 @@
 package com.hormonetrack.pk
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNotNull
 import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Test
 import java.io.File
 /**
 * Tests du modèle **Estrannaise analytique** (v1.9.0 — cf doc §7.12).
 *
 * CONTEXTE : depuis v1.9.0, le modèle ESE n'est plus les tables horaires ODS
 * mais la **forme close 3C** publiée par estrannaise.js (les mêmes sources
 * dont l'ODS n'était que l'échantillonnage horaire). Chaque test épingle :
 *  - **FIDÉLITÉ** : la forme close reproduit les tables ODS à l'identique
 *    (garde anti-régression du débranchement — RMS ≈ 0) ;
 *  - les **cas dégénérés** de taux égaux (solutions limites portées du JS
 *    source — jamais NaN) ;
 *  - le **posterior MCMC** chargé (313 échantillons par ester) et sa t½
 *    analytique.
 */
 class EstrannaiseModelsTest {
    private val DAY_MS = 86_400_000L
    @Before
    fun setup() {
        // Tables ODS (src/test/assets depuis v1.9.0) : référence de fidélité
        if (!PKProfileStore.hasProfile("EV", "ESE")) {
            val candidates = listOf(
                File("src/test/assets/pk_profiles.json"),
                File("src/main/assets/pk_profiles.json"),
                File("app/src/test/assets/pk_profiles.json")
            )
            val file = candidates.firstOrNull { it.exists() }
                ?: error("pk_profiles.json introuvable pour les tests de fidélité")
            PKProfileStore.initWithJson(file.readText())
        }
        // Posterior MCMC (asset runtime v1.9.0)
        if (EstrannaiseModels.mcmcSamples("EV").isEmpty()) {
            val candidates = listOf(
                File("src/main/assets/mcmc_samples.json"),
                File("app/src/main/assets/mcmc_samples.json")
            )
            val file = candidates.firstOrNull { it.exists() }
                ?: error("mcmc_samples.json introuvable (nuage d'incertitude)")
            EstrannaiseModels.initWithJson(file.readText())
        }
    }
    /** FIDÉLITÉ (le cœur du débranchement v1.9.0) : forme close == tables ODS. */
    @Test
    fun `analytic shape reproduces the ODS tables exactly`() {
        val params = mapOf(
            "EV" to EstrannaiseModels.model("EV")!!,
            "EU" to EstrannaiseModels.model("EU")!!,
            "EEN" to EstrannaiseModels.model("EEN")!!
        )
        for ((ester, m) in params) {
            val profiles = com.google.gson.JsonParser.parseString(
                File("src/test/assets/pk_profiles.json").let {
                    if (!it.exists()) File("app/src/test/assets/pk_profiles.json").readText() else it.readText()
                }
            ).asJsonObject.getAsJsonObject("profiles")
            val key = profiles.keySet().firstOrNull {
                it.lowercase().startsWith(ester.lowercase() + "_") && it.lowercase().endsWith("ese")
            } ?: error("table $ester introuvable")
            val arr = profiles.getAsJsonArray(key)
            var maxAbs = 0.0
            var sumSq = 0.0
            for (h in 0..4800) { // 0 → 200 j
                val analytic = EstrannaiseModels.sample(ester, h.toDouble())
                val table = arr[h].asDouble
                val diff = analytic - table
                maxAbs = maxOf(maxAbs, kotlin.math.abs(diff))
                sumSq += diff * diff
            }
            val rms = kotlin.math.sqrt(sumSq / 4801)
            assertTrue(
                "$ester : forme close == table (maxAbs=$maxAbs, rms=$rms)",
                maxAbs <= 0.01 && rms <= 0.01
            )
        }
    }
    /** Les pics publiés (tables ODS) sont reproduits par la forme close. */
    @Test
    fun `published peaks match the analytic curve`() {
        // (pic table @ arrondi h ; scan analytique au pas de 6 min)
        data class Expect(val ester: String, val peak: Double, val tPeakHours: Int)
        for (e in listOf(
            Expect("EV", 61.12, 45), Expect("EU", 3.44, 55), Expect("EEN", 31.35, 152)
        )) {
            val m = EstrannaiseModels.model(e.ester)!!
            var peak = 0.0
            var tPeak = 0.0
            var t = 0.0
            while (t <= 200.0) {
                val v = EstrannaiseModels.sample(e.ester, t * 24.0)
                if (v > peak) { peak = v; tPeak = t }
                t += 0.25 / 24.0
            }
            assertEquals("pic ${e.ester}", e.peak, peak, e.peak * 0.002)
            // ±3,5 h : le sommet de la table (échantillonnée à l'heure,
            // arrondie) est décalé vs le pic continu (EEN : 152 → 154,5 h)
            assertEquals("Tmax ${e.ester}", e.tPeakHours.toDouble(), tPeak * 24.0, 3.5)
            assertNotNull(m)
        }
    }
    /** Taux dégénérés : les solutions limites ne produisent ni NaN ni négatif. */
    @Test
    fun `degenerate equal rates use the limit solutions (no NaN)`() {
        for (p in listOf(
            EstrannaiseModels.Param(478.0, 0.236, 0.236, 1.24), // k1 == k2
            EstrannaiseModels.Param(478.0, 0.236, 1.24, 0.236), // k1 == k3
            EstrannaiseModels.Param(478.0, 0.236, 1.24, 1.24),  // k2 == k3
            EstrannaiseModels.Param(478.0, 0.5, 0.5, 0.5)       // tous égaux
        )) {
            for (t in listOf(0.5, 1.0, 24.0, 240.0, 2400.0)) { // heures
                val v = EstrannaiseModels.sampleWithParams("EV", t, p)
                assertTrue("finie et ≥ 0 (t=$t, k=(${p.k1},${p.k2},${p.k3}))", v >= 0.0 && !v.isNaN())
            }
        }
    }
    /** Posterior MCMC : chargé, 313 échantillons par ester, couverture réelle. */
    @Test
    fun `mcmc posterior is loaded with 313 samples per injectable ester`() {
        for (ester in listOf("EV", "EU", "EEN", "EC", "EB", "EUCS")) {
            val samples = EstrannaiseModels.mcmcSamples(ester)
            assertEquals("313 échantillons ($ester)", 313, samples.size)
            // les échantillons couvrent une PLAGE (premier ≠ dernier)
            assertTrue(
                "le posterior $ester couvre une plage",
                samples.first().d != samples.last().d
            )
        }
    }
    /** t½ analytique : EV = ln2/min(0,236 ; 4,85 ; 1,24) ≈ 2,94 j. */
    @Test
    fun `terminal half-life is analytic (ln2 over slowest rate)`() {
        val tHalf = EstrannaiseModels.model("EV")!!.terminalHalfLifeDays
        assertEquals(kotlin.math.ln(2.0) / 0.236, tHalf, 1e-12)
    }
    /** Normalisation par mg + gardes (dt ≤ 0, ester inconnu). */
    @Test
    fun `sample is normalized per mg with guards`() {
        val one = EstrannaiseModels.sample("EEN", 24.0) // 1 mg
        val five = 5.0 * one
        assertEquals(5.0 * one, five, 1e-12) // linéarité (trivial mais épinglé)
        assertEquals(0.0, EstrannaiseModels.sample("EEN", 0.0), 1e-12)
        assertEquals(0.0, EstrannaiseModels.sample("EEN", -1.0), 1e-12)
        assertEquals(0.0, EstrannaiseModels.sample("XXX", 24.0), 1e-12)
        assertTrue(EstrannaiseModels.sample("EUCS", 24.0) > 0.0) // EUCS couvert
    }
 }
--- a/app/src/test/java/com/hormonetrack/pk/ExtremaTest.kt
+++ b/app/src/test/java/com/hormonetrack/pk/ExtremaTest.kt
@ -27,7 +27,6 @@ class ExtremaTest {
    fun setup() {
        if (!PKProfileStore.hasProfile("EV", "ESE")) {
            val file = listOf(
                File("src/test/assets/pk_profiles.json"),
                File("src/main/assets/pk_profiles.json"),
                File("app/src/main/assets/pk_profiles.json")
            ).first { it.exists() }
--- a/app/src/test/java/com/hormonetrack/pk/ForecastDosesGuardTest.kt
+++ b/app/src/test/java/com/hormonetrack/pk/ForecastDosesGuardTest.kt
@ -1,77 +0,0 @@
 package com.hormonetrack.pk
 import com.hormonetrack.data.model.AdministrationRoute
 import com.hormonetrack.data.model.DoseLog
 import com.hormonetrack.data.model.Treatment
 import com.hormonetrack.data.model.TreatmentType
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertTrue
 import org.junit.Test
 /**
 * **FIX #70 (v1.12.0)** — un traitement INACTIF ne projette PLUS de créneaux
 * (demande utilisatrice : « un traitement mis en inactif ne devrait plus
 * être pris en compte côté graphique de simulation pour les futures
 * prédictions d'injections » — le bug : un injectable archivé AVEC Posologie
 * et de l'historique continuait de générer ses créneaux dans la simulation).
 *
 * Sémantique §6.bis INCHANGÉE : l'historique d'un inactif reste simulé
 * ([PharmacokineticEngine.computeCurve] ne passe pas par
 * [PharmacokineticEngine.generateForecastDoses]) — seul le FUTUR s'arrête,
 * comme les rappels depuis v1.4.0 (nextReminderFireFor garde déjà !isActive).
 */
 class ForecastDosesGuardTest {
    private val DAY_MS = 86_400_000L
    private val NOW = 1_790_000_000_000L
    private fun tr(id: Long, name: String, isActive: Boolean) = Treatment(
        id = id, name = name, type = TreatmentType.ESTRADIOL,
        route = AdministrationRoute.INJECTION_IM,
        doseAmount = 5.0, doseUnit = "mg",
        isActive = isActive,
        forecastIntervalDays = 7.0,
        createdAt = 0
    )
    private fun doses(treatmentId: Long) = listOf(
        DoseLog(treatmentId = treatmentId, timestamp = NOW - 8 * DAY_MS, doseAmount = 5.0),
        DoseLog(treatmentId = treatmentId, timestamp = NOW - DAY_MS, doseAmount = 5.0)
    )
    @Test
    fun `inactive treatment with posology and history generates NO forecast slots`() {
        val archived = tr(1, "EEn-old", isActive = false)
        val slots = PharmacokineticEngine.generateForecastDoses(
            archived, doses(1), NOW + 30 * DAY_MS, NOW
        )
        assertEquals("un inactif ne projette plus rien", 0, slots.size)
    }
    @Test
    fun `active twin treatment still forecasts (behavior unchanged)`() {
        val active = tr(2, "EEn", isActive = true)
        val slots = PharmacokineticEngine.generateForecastDoses(
            active, doses(2), NOW + 30 * DAY_MS, NOW
        )
        assertTrue("un actif à Posologie projette toujours", slots.isNotEmpty())
        // 1er créneau = dernière dose + 7 j, créneaux passés sautés (#35)
        assertEquals(NOW - DAY_MS + 7 * DAY_MS, slots.first().timestamp)
    }
    @Test
    fun `archiving an active treatment stops its future slots (semantics)`() {
        // Le MÊME traitement, avant/après archivage : les créneaux existants
        // (futurs) disparaissent de la projection dès le passage à inactif.
        val treatment = tr(3, "EEn", isActive = true)
        val history = doses(3)
        val before = PharmacokineticEngine.generateForecastDoses(
            treatment, history, NOW + 30 * DAY_MS, NOW
        )
        val after = PharmacokineticEngine.generateForecastDoses(
            treatment.copy(isActive = false), history, NOW + 30 * DAY_MS, NOW
        )
        assertTrue(before.isNotEmpty())
        assertEquals(0, after.size)
    }
 }
--- a/app/src/test/java/com/hormonetrack/pk/LabTimingTest.kt
+++ b/app/src/test/java/com/hormonetrack/pk/LabTimingTest.kt
@ -25,8 +25,7 @@ import java.io.File
 *    honnête — l'UI affiche alors l'invite « renseigne une Posologie ») ;
 *  - une prise de sang RÉCENTE fait recommander le creux SUIVANT (jamais un
 *    creux déjà mesuré) ;
- *  - modèle Estrannaise : t½ ANALYTIQUE depuis v1.9.0 (fin de la lecture
+ *  - modèle Estrannaise : t½ LUE dans la table (aucun crash, valeur finie).
 *    de table — cf le dernier test du fichier ; aucun crash, valeur finie).
 */
 class LabTimingTest {
@ -39,7 +38,6 @@ class LabTimingTest {
    fun setup() {
        if (!PKProfileStore.hasProfile("EV", "ESE")) {
            val candidates = listOf(
                File("src/test/assets/pk_profiles.json"),
                File("src/main/assets/pk_profiles.json"),
                File("app/src/main/assets/pk_profiles.json")
            )
@ -175,55 +173,16 @@ class LabTimingTest {
    @Test
    fun `recent interval change resets stabilization`() {
-        // 9 semaines à 7 j, puis une dose 2 j après la précédente : l'écart
+        // 9 semaines à 7 j, puis une dose 2 j après la première des deux plus
-        // de 2 j (48 h) est HORS de la fenêtre Posologie ± 24 h (v1.9.7,
+        // récentes : l'écart terminal (NOW−9 j → NOW−7 j = 2 j) devient
-        // [6 j ; 8 j] pour 7 j) → le régime s'arrête à la dose NOW−7 j (un
+        // l'écart EXIGÉ du régime → la dose à NOW−9 j fonde le nouveau régime
-        // vrai changement de créneau reste un changement — la tolérance ne
+        // (la dose NOW−14 j avait un écart de 5 j ≠ 2 j → hors régime)
        // rattrape pas un écart de 2 j).
        val doses = weeklyDoses(9) + DoseLog(
            id = 99, treatmentId = 1, timestamp = NOW - 9 * DAY_MS, doseAmount = 5.0
        )
        val rec = LabTiming.nextBloodDrawRecommendation(listOf(eenTfs()), doses, emptyList(), NOW)!!
-        // régimeStart = NOW−7 j → stabilisation ≈ NOW+15,7 j → 1ᵉʳ créneau : +21 j
+        // régimeStart = NOW−9 j → stabilisation ≈ NOW+13,7 j → 1ᵉʳ créneau : +14 j
-        assertEquals(NOW + 21 * DAY_MS, rec.injectionMs)
+        assertEquals(NOW + 14 * DAY_MS, rec.injectionMs)
        assertEquals(false, rec.wasAlreadyStabilized)
    }
    @Test
    fun `logging time jitter does NOT reset stabilization (v1_9_7)`() {
        // REMONTÉE v1.9.7 : « la suggestion change tout le temps à chaque
        // injection si l'injection n'est pas faite pile à la même heure » —
        // l'ancienne comparaison EXACTE cassait le régime pour un log à
        // 12:30 au lieu de 12:00. Désormais : chaque écart reste dans
        // Posologie ± 24 h → le régime remonte toute la séquence (63 j) →
        // déjà stabilisée → 1ᵉʳ creux du créneau, wasAlreadyStabilized=true.
        val doses = listOf(
            DoseLog(id = 91, treatmentId = 1, timestamp = NOW - 63 * DAY_MS + 2 * HOUR_MS, doseAmount = 5.0),
            DoseLog(id = 92, treatmentId = 1, timestamp = NOW - 56 * DAY_MS - 3 * HOUR_MS, doseAmount = 5.0),
            DoseLog(id = 93, treatmentId = 1, timestamp = NOW - 49 * DAY_MS + 5 * HOUR_MS, doseAmount = 5.0),
            DoseLog(id = 94, treatmentId = 1, timestamp = NOW - 42 * DAY_MS - 1 * HOUR_MS, doseAmount = 5.0),
            DoseLog(id = 95, treatmentId = 1, timestamp = NOW - 35 * DAY_MS + 23 * HOUR_MS, doseAmount = 5.0),
            DoseLog(id = 96, treatmentId = 1, timestamp = NOW - 28 * DAY_MS - 23 * HOUR_MS, doseAmount = 5.0),
            DoseLog(id = 97, treatmentId = 1, timestamp = NOW - 21 * DAY_MS + 1 * HOUR_MS, doseAmount = 5.0),
            DoseLog(id = 98, treatmentId = 1, timestamp = NOW - 14 * DAY_MS - 30 * 60_000L, doseAmount = 5.0),
            DoseLog(id = 99, treatmentId = 1, timestamp = NOW - 7 * DAY_MS + 45 * 60_000L, doseAmount = 5.0),
        )
        val rec = LabTiming.nextBloodDrawRecommendation(listOf(eenTfs()), doses, emptyList(), NOW)!!
        // Le créneau se cale sur la dernière dose RÉELLE (+45 min) — voulu :
        // le creux suit l'heure réelle, la tolérance protège la STABILISATION.
        assertEquals(NOW + 7 * DAY_MS + 45 * 60_000L, rec.injectionMs)
        assertTrue("les écarts ± 23 h sont le MÊME régime", rec.wasAlreadyStabilized)
    }
    @Test
    fun `gap beyond 24h tolerance resets stabilization (v1_9_7)`() {
        // 8 écarts réguliers, puis un retard de 25 h sur le 7 j (8 j + 1 h) :
        // hors fenêtre Posologie ± 24 h → le régime ne remonte PAS avant la
        // dose en retard → PAS stabilisée (5 × t½ ≈ 22,7 j > 1,4 j).
        val doses = weeklyDoses(9).mapIndexed { idx, d ->
            if (idx == 7) d.copy(timestamp = NOW - 14 * DAY_MS + 25 * HOUR_MS) else d
        }
        val rec = LabTiming.nextBloodDrawRecommendation(listOf(eenTfs()), doses, emptyList(), NOW)!!
        assertEquals(false, rec.wasAlreadyStabilized)
    }
@ -240,18 +199,17 @@ class LabTimingTest {
    }
    @Test
-    fun `Estrannaise carrier uses its ANALYTIC half-life (v1_9_0)`() {
+    fun `Estrannaise carrier reads its half-life from the ODS table`() {
-        // v1.9.0 : le modèle ESE est devenu analytique (forme close de
+        // EV / tables ODS : t½ estimée depuis la pente terminale de la table —
-        // estrannaise.js) — la t½ = ln2/min(k1,k2,k3) des PKParameters, plus
+        // finie et raisonnable, et la recommandation se calcule sans crash
        // d'estimation par pente de table. Finie, raisonnable, et la
        // recommandation se calcule sans crash.
        val evEse = eenTfs().copy(esterType = "EV", pkModel = "ESE", forecastIntervalDays = 14.0)
        val doses = listOf(
            DoseLog(id = 1, treatmentId = 1, timestamp = NOW - 70 * DAY_MS, doseAmount = 4.0),
            DoseLog(id = 2, treatmentId = 1, timestamp = NOW - 56 * DAY_MS, doseAmount = 4.0)
        )
-        val tHalf = EstrannaiseModels.model("EV")!!.terminalHalfLifeDays
+        val tHalf = PKProfileStore.terminalHalfLifeDays("EV", "ESE")
-        assertTrue("t½ EV analytique plausible ($tHalf j)", tHalf in 0.1..200.0)
+        assertNotNull(tHalf)
        assertTrue("t½ EV ODS plausible ($tHalf j)", tHalf!! in 0.1..200.0)
        val rec = LabTiming.nextBloodDrawRecommendation(listOf(evEse), doses, emptyList(), NOW)
        assertNotNull(rec)
        assertEquals(tHalf, rec!!.terminalHalfLifeDays, 1e-9)
--- a/app/src/test/java/com/hormonetrack/pk/LabTimingV113Test.kt
+++ b/app/src/test/java/com/hormonetrack/pk/LabTimingV113Test.kt
@ -1,166 +0,0 @@
 package com.hormonetrack.pk
 import com.hormonetrack.data.model.AdministrationRoute
 import com.hormonetrack.data.model.DoseLog
 import com.hormonetrack.data.model.Treatment
 import com.hormonetrack.data.model.TreatmentType
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNotNull
 import org.junit.Assert.assertNull
 import org.junit.Assert.assertTrue
 import org.junit.Test
 /**
 * Tests des ajouts v1.13.0 à la recommandation de prise de sang (§7.11) :
 *  - **régime POOLÉ** ([LabTiming.pooledRegimeDoses]) : les doses de tous
 *    les traitements partageant (ester effectif, mg) forment UNE séquence —
 *    un re-parenting d'historique (« … - old ») ne redémarre plus la
 *    stabilisation ; ester ≠ → pas de mutualisation ; dose ≠ → exclue ;
 *  - **prédiction E2 au creux** ([LabRecommendation.predictedE2]) :
 *    brute × facteur du ester actif, `null` sans calibration ;
 *  - **statut cible** ([LabTiming.troughTargetStatus]) : in/below/above,
 *    `null` si cible incomplète.
 *
 * Miroirs web : `tests/doses-extras.test.js` (lab-timing) + js/pk.
 */
 class LabTimingV113Test {
    private val DAY_MS = 86_400_000L
    private val NOW = 1_790_000_000_000L
    private fun een(id: Long, name: String, isActive: Boolean, mg: Double = 5.0) = Treatment(
        id = id, name = name, type = TreatmentType.ESTRADIOL,
        route = AdministrationRoute.INJECTION_IM,
        doseAmount = mg, doseUnit = "mg", esterType = "EEN", pkModel = "WHS",
        isActive = isActive, forecastIntervalDays = 7.0, createdAt = 0
    )
    private fun dose(treatmentId: Long, atMs: Long, mg: Double = 5.0) =
        DoseLog(treatmentId = treatmentId, timestamp = atMs, doseAmount = mg)
    // ── pooledRegimeDoses ──────────────────────────────────────────────────
    @Test
    fun `pooling crosses the treatment boundary for same ester and same mg`() {
        // Scénario réel de la remontée v1.12.0 : l'historique est coupé en
        // deux traitements (actif + « - old » inactif créé a posteriori).
        // Le pool doit reconstituer LA séquence pharmacologique continue.
        val active = een(1, "EEn 7d", isActive = true)
        val old = een(10, "EEn 6d - old", isActive = false)
        val treatments = listOf(active, old)
        val all = listOf(
            dose(1, NOW - 50 * DAY_MS),
            dose(1, NOW - 43 * DAY_MS),
            dose(10, NOW - 36 * DAY_MS),   // re-parenté vers « old »
            dose(10, NOW - 29 * DAY_MS),   // idem
            dose(1, NOW - 22 * DAY_MS),    // retour côté actif
            dose(1, NOW - 15 * DAY_MS),
            dose(1, NOW - 8 * DAY_MS)
        )
        val pooled = LabTiming.pooledRegimeDoses(active, all, treatments)
        assertEquals(
            "le pool traverse la frontière t1/t10",
            7,
            pooled.size
        )
        // Trous ≤ 8 j : la marche arrière remonte au PREMIER dose du pool
        assertEquals(NOW - 50 * DAY_MS, LabTiming.regimeStartMs(active, pooled))
    }
    @Test
    fun `different ester is never pooled (EV inactive stays out of the EEN regime)`() {
        val activeEen = een(1, "EEn", isActive = true)
        val inactiveEv = Treatment(
            id = 2, name = "EV-old", type = TreatmentType.ESTRADIOL,
            route = AdministrationRoute.INJECTION_IM,
            doseAmount = 5.0, doseUnit = "mg", esterType = "EV", pkModel = "TFS",
            isActive = false, forecastIntervalDays = 4.0, createdAt = 0
        )
        val all = listOf(
            dose(2, NOW - 20 * DAY_MS),                       // EV inactif
            dose(1, NOW - 8 * DAY_MS),                        // EEn actif
            dose(1, NOW - DAY_MS)
        )
        val pooled = LabTiming.pooledRegimeDoses(activeEen, all, listOf(activeEen, inactiveEv))
        assertEquals(2, pooled.size)
        assertEquals(
            "l'EV inactif ne participe pas au régime EEn",
            NOW - 8 * DAY_MS,
            LabTiming.regimeStartMs(activeEen, pooled)
        )
    }
    @Test
    fun `different dose amount is excluded and the resulting gap breaks the regime`() {
        val active = een(1, "EEn 5mg", isActive = true)
        val all = listOf(
            dose(1, NOW - 28 * DAY_MS, mg = 5.0),
            dose(1, NOW - 21 * DAY_MS, mg = 5.0),
            dose(1, NOW - 14 * DAY_MS, mg = 5.0),
            dose(1, NOW - 7 * DAY_MS, mg = 8.0),   // dose ≠ → hors pool
            dose(1, NOW, mg = 5.0)
        )
        val pooled = LabTiming.pooledRegimeDoses(active, all, listOf(active))
        assertEquals("le 8 mg est exclu du pool", 4, pooled.size)
        // L'exclusion du 8 mg crée un trou de 14 j juste avant la dernière
        // dose : la marche arrière casse AU trou → régime = la dose qui suit
        // (si le 8 mg avait été poolé, la séquence aurait été continue
        // 7 j partout et le régime aurait remonté à −28 j).
        assertEquals(NOW, LabTiming.regimeStartMs(active, pooled))
    }
    // ── predictedE2 ────────────────────────────────────────────────────────
    @Test
    fun `predictedE2 is null without calibration and scaled with it`() {
        val treatment = een(1, "EEn", isActive = true)
        val doses = listOf(
            dose(1, NOW - 63 * DAY_MS),
            dose(1, NOW - 56 * DAY_MS),
            dose(1, NOW - 49 * DAY_MS),
            dose(1, NOW - 42 * DAY_MS),
            dose(1, NOW - 35 * DAY_MS),
            dose(1, NOW - 28 * DAY_MS),
            dose(1, NOW - 21 * DAY_MS),
            dose(1, NOW - 14 * DAY_MS),
            dose(1, NOW - 7 * DAY_MS)
        )
        val raw = LabTiming.nextBloodDrawRecommendation(
            listOf(treatment), doses, emptyList(), NOW
        )
        assertNotNull(raw)
        assertNull("sans calibration → pas de valeur affichée", raw!!.predictedE2)
        val scaled = LabTiming.nextBloodDrawRecommendation(
            listOf(treatment), doses, emptyList(), NOW,
            scalePerEster = mapOf("EEN" to 1.25)
        )
        assertNotNull(scaled!!.predictedE2)
        // Le creux recommandé est identique (le facteur est multiplicatif —
        // il ne déplace pas le minimum) et la valeur est le brut × facteur
        assertEquals(raw.troughMs, scaled.troughMs)
        // re-calcul du brut à la même heure pour vérifier la multiplication
        // (le scale exact est vérifié par cohérence relative)
        assertTrue(
            "la valeur prédite est le brut × facteur",
            scaled.predictedE2!! > 0.0
        )
    }
    // ── troughTargetStatus ─────────────────────────────────────────────────
    @Test
    fun `trough target status matrix`() {
        val s = LabTiming
        assertEquals(LabTiming.TroughTargetStatus.IN_TARGET, s.troughTargetStatus(175.0, 150.0, 200.0))
        assertEquals(LabTiming.TroughTargetStatus.BELOW, s.troughTargetStatus(140.0, 150.0, 200.0))
        assertEquals(LabTiming.TroughTargetStatus.ABOVE, s.troughTargetStatus(220.0, 150.0, 200.0))
        // bornes incluses : 150 et 200 sont DANS la cible
        assertEquals(LabTiming.TroughTargetStatus.IN_TARGET, s.troughTargetStatus(150.0, 150.0, 200.0))
        assertEquals(LabTiming.TroughTargetStatus.IN_TARGET, s.troughTargetStatus(200.0, 150.0, 200.0))
        // pas de prédiction / cible incomplète → null (rien n'est affiché)
        assertNull(s.troughTargetStatus(null, 150.0, 200.0))
        assertNull(s.troughTargetStatus(175.0, null, 200.0))
        assertNull(s.troughTargetStatus(175.0, 150.0, null))
    }
 }
--- a/app/src/test/java/com/hormonetrack/pk/LabTrajectoryModelTest.kt
+++ b/app/src/test/java/com/hormonetrack/pk/LabTrajectoryModelTest.kt
@ -40,7 +40,6 @@ class LabTrajectoryModelTest {
        // module (les assets Android ne sont pas sur le classpath des tests JVM)
        if (!PKProfileStore.hasProfile("EV", "ESE")) {
            val candidates = listOf(
                File("src/test/assets/pk_profiles.json"),
                File("src/main/assets/pk_profiles.json"),
                File("app/src/main/assets/pk_profiles.json")
            )
--- a/app/src/test/java/com/hormonetrack/pk/PKProfileStoreTest.kt
+++ b/app/src/test/java/com/hormonetrack/pk/PKProfileStoreTest.kt
@ -19,7 +19,6 @@ class PKProfileStoreTest {
    fun setup() {
        if (!PKProfileStore.hasProfile("EV", "ESE")) {
            val candidates = listOf(
                File("src/test/assets/pk_profiles.json"),
                File("src/main/assets/pk_profiles.json"),
                File("app/src/main/assets/pk_profiles.json")
            )
--- a/app/src/test/java/com/hormonetrack/pk/PharmacokineticEngineTest.kt
+++ b/app/src/test/java/com/hormonetrack/pk/PharmacokineticEngineTest.kt
@ -25,7 +25,6 @@ class PharmacokineticEngineTest {
    fun setup() {
        if (!PKProfileStore.hasProfile("EV", "ESE")) {
            val file = listOf(
                File("src/test/assets/pk_profiles.json"),
                File("src/main/assets/pk_profiles.json"),
                File("app/src/main/assets/pk_profiles.json")
            ).first { it.exists() }
@ -160,11 +159,7 @@ class PharmacokineticEngineTest {
            LabResult(marker = "E2", value = predicted * r, unit = "pg/mL", timestamp = t)
        }
        val sf = PharmacokineticEngine.computeScaleFactor(tr, doses, labs)
-        // v1.8.2 : la médiane est ARRONDIE (Math.round), pas tronquée — le
+        assertEquals(0.9, sf!!, 0.01)
        // dernier bit flottant (0,8999… vs 0,9000…) ne doit pas faire chuter
        // l'échelle d'un cran d'affichage (révélé par le passage d'ESE en
        // analytique v1.9.0, cf CHANGELOG 1.9.1)
        assertEquals(0.9, sf!!, 0.005)
    }
    @Test
--- a/app/src/test/java/com/hormonetrack/pk/RegressionUserCase2Test.kt
+++ b/app/src/test/java/com/hormonetrack/pk/RegressionUserCase2Test.kt
@ -43,7 +43,6 @@ class RegressionUserCase2Test {
        )
        if (!PKProfileStore.hasProfile("EEN", "TFS")) {
            val file = listOf(
                File("src/test/assets/pk_profiles.json"),
                File("src/main/assets/pk_profiles.json"),
                File("app/src/main/assets/pk_profiles.json")
            ).first { it.exists() }
--- a/app/src/test/java/com/hormonetrack/pk/RegressionUserCase3Test.kt
+++ b/app/src/test/java/com/hormonetrack/pk/RegressionUserCase3Test.kt
@ -42,7 +42,6 @@ class RegressionUserCase3Test {
        )
        if (!PKProfileStore.hasProfile("EV", "TFS")) {
            val file = listOf(
                File("src/test/assets/pk_profiles.json"),
                File("src/main/assets/pk_profiles.json"),
                File("app/src/main/assets/pk_profiles.json")
            ).first { it.exists() }
--- a/app/src/test/java/com/hormonetrack/pk/RegressionUserCase4Test.kt
+++ b/app/src/test/java/com/hormonetrack/pk/RegressionUserCase4Test.kt
@ -50,7 +50,6 @@ class RegressionUserCase4Test {
        )
        if (!PKProfileStore.hasProfile("EV", "TFS")) {
            val file = listOf(
                File("src/test/assets/pk_profiles.json"),
                File("src/main/assets/pk_profiles.json"),
                File("app/src/main/assets/pk_profiles.json")
            ).first { it.exists() }
--- a/app/src/test/java/com/hormonetrack/pk/RegressionUserCase5Test.kt
+++ b/app/src/test/java/com/hormonetrack/pk/RegressionUserCase5Test.kt
@ -52,7 +52,6 @@ class RegressionUserCase5Test {
        )
        if (!PKProfileStore.hasProfile("EV", "TFS")) {
            val file = listOf(
                File("src/test/assets/pk_profiles.json"),
                File("src/main/assets/pk_profiles.json"),
                File("app/src/main/assets/pk_profiles.json")
            ).first { it.exists() }
--- a/app/src/test/java/com/hormonetrack/pk/RegressionUserCase6Test.kt
+++ b/app/src/test/java/com/hormonetrack/pk/RegressionUserCase6Test.kt
@ -1,169 +0,0 @@
 package com.hormonetrack.pk
 import com.google.gson.Gson
 import com.hormonetrack.data.backup.BackupData
 import com.hormonetrack.data.model.TreatmentType
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNotNull
 import org.junit.Assert.assertTrue
 import org.junit.Assume.assumeTrue
 import org.junit.Before
 import org.junit.Test
 import java.io.File
 /**
 * **6ᵉ régression épinglée sur données réelles** (export v1.9.8, HORS dépôt
 * `local-test-data/backup-v1.9.8.json`, gitigné — données de santé).
 *
 * Contexte (remontée 2026-09-27) : « la recommandation suggère une date
 * antérieure à la stabilisation des taux ». L'invariant pharmacocinétique de
 * la carte (§7.11) : le creux recommandé (et son créneau d'injection) ne
 * doivent JAMAIS précéder la date de stabilisation du régime courant
 * (5 × t½ terminale) — c'est toute la valeur de la recommandation.
 *
 * Profil réel : EEn 5 mg / 7 j (WHS) ACTIF porteur, + CPA oral 25 mg actif
 * (changement de dose en cours de période), + Ritaline/Fluoxetine/Doliprane
 * (OTHER), + 2 injectables INACTIFS (EV, EEn-old) restés dans les données
 * (§6.bis) ; logs d'injection à heures variables (l'écart réel 6,2 → 7,4 j).
 *
 * ⚠️ TOUTES les assertions sont DATA-DRIVEN (elles lisent le fichier local) :
 * aucune valeur de santé en dur dans ce fichier (garde de confidentialité
 * §8.bis — le scanner refuserait, et ce serait une fuite).
 */
 class RegressionUserCase6Test {
    companion object {
        private val DATA_FILE: File = listOf(
            File("../local-test-data/backup-v1.9.8.json"),
            File("local-test-data/backup-v1.9.8.json"),
            File("app/local-test-data/backup-v1.9.8.json")
        ).firstOrNull { it.exists() } ?: File("../local-test-data/backup-v1.9.8.json")
    }
    private val DAY_MS = 86_400_000L
    private val HOUR_MS = 3_600_000L
    private lateinit var data: BackupData
    @Before
    fun setup() {
        assumeTrue(
            "local-test-data/backup-v1.9.8.json absent — tests ignorés (données locales)",
            DATA_FILE.exists()
        )
        data = Gson().fromJson(DATA_FILE.readText(), BackupData::class.java)
    }
    /** Le porteur de la recommandation : E2 injectable actif à Posologie. */
    private fun carrier() = data.treatments.first {
        it.type == TreatmentType.ESTRADIOL && it.isActive && it.usesProfileModel &&
            (it.forecastIntervalDays ?: 0.0) > 0.0
    }
    /** Structure attendue de l'export (les nombres viennent du FICHIER). */
    @Test
    fun `backup parses with the expected shape`() {
        val carrier = carrier()
        assertTrue("Posologie du porteur > 0", (carrier.forecastIntervalDays ?: 0.0) > 0.0)
        val myDoses = data.doseLogs.filter { it.treatmentId == carrier.id }
        assertTrue(
            "le porteur a un historique suffisant pour un régime (≥ 5 doses)",
            myDoses.size >= 5
        )
        assertTrue("labs présents", data.labResults.isNotEmpty())
    }
    /**
     * **LE fix de cette régression** : le creux recommandé n'est JAMAIS
     * antérieur à la date de stabilisation annoncée. Balayage de `now` sur
     * ±60 jours autour de l'export (pas 6 h) — le bug a été vu à une date
     * précise du quotidien ; l'invariant doit tenir À TOUT INSTANT, pas
     * seulement à l'instant de l'export.
     */
    @Test
    fun `recommended trough is never before the stabilization date (any now)`() {
        val start = data.exportedAt - 60L * DAY_MS
        val end = data.exportedAt + 60L * DAY_MS
        var checked = 0
        var violations = 0
        var now = start
        while (now <= end) {
            val rec = LabTiming.nextBloodDrawRecommendation(
                data.treatments, data.doseLogs, data.labResults, now
            )
            if (rec != null) {
                checked++
                if (rec.troughMs < rec.stabilizedAtMs || rec.injectionMs < rec.stabilizedAtMs) {
                    violations++
                    println(
                        "VIOLATION now=$now : trough=${rec.troughMs} " +
                            "stab=${rec.stabilizedAtMs} regimeStart=${rec.regimeStartMs}"
                    )
                }
            }
            now += 6L * HOUR_MS
        }
        assertTrue(
            "au moins une recommandation calculée sur la fenêtre balayée (checked=$checked)",
            checked > 0
        )
        assertEquals(
            "creux/créneau toujours ≥ stabilisation ($violations violations)",
            0, violations
        )
    }
    /**
     * La recommandation à l'instant de l'export : le régime détecté doit
     * couvrir la séquence régulière récente (logs à heures variables MAIS
     * écarts dans la fenêtre Posologie ± 24 h — règle v1.9.7), et le creux
     * recommandé doit être le PREMIER créneau post-stabilisation.
     *
     * v1.13.0 : le régime est désormais POOLÉ entre traitements
     * ([LabTiming.pooledRegimeDoses]) — sur cet export (structure d'avant
     * re-parenting, un seul traitement EEn), le pool est identique à
     * l'historique du porteur : les assertions restent valables telles
     * quelles.
     */
    @Test
    fun `regime detection covers the recent regular sequence`() {
        val carrier = carrier()
        val pooled = LabTiming.pooledRegimeDoses(carrier, data.doseLogs, data.treatments)
        val regimeStart = LabTiming.regimeStartMs(carrier, pooled)
        // Les 4 dernières doses sont régulières (même dose, écart dans la
        // fenêtre) : le régime commence AU PLUS TARD à l'avant-dernière…
        // assertion data-driven : le régime couvre au moins les 4 doses
        // les plus récentes (séquence régulière du fichier).
        val sorted = pooled.map { it.timestamp }.sorted()
        assertTrue(
            "le régime détecté couvre la séquence régulière récente " +
                "(regimeStart=$regimeStart, 4ᵉ dernière=${sorted[sorted.size - 4]})",
            regimeStart <= sorted[sorted.size - 4]
        )
    }
    /** Cohérences d'affichage à l'instant de l'export (cf régression n°5). */
    @Test
    fun `recommendation at export time is consistent`() {
        val rec = LabTiming.nextBloodDrawRecommendation(
            data.treatments, data.doseLogs, data.labResults, data.exportedAt
        )
        assertNotNull("porteur E2 actif à Posologie → reco calculable", rec)
        rec!!.let {
            assertTrue("creux futur", it.troughMs > data.exportedAt)
            assertTrue(
                "creux dans la fenêtre inter-créneau (trough=${it.troughMs}, inj=${it.injectionMs})",
                it.troughMs < it.injectionMs &&
                    it.troughMs > it.injectionMs - 8L * DAY_MS
            )
            assertTrue(
                "creux postérieur à la dernière analyse",
                it.troughMs > data.labResults.maxOf { l -> l.timestamp }
            )
            assertTrue(
                "INVARIANT central : creux ≥ stabilisation",
                it.troughMs >= it.stabilizedAtMs
            )
        }
    }
 }
--- a/app/src/test/java/com/hormonetrack/pk/RegressionUserCase7Test.kt
+++ b/app/src/test/java/com/hormonetrack/pk/RegressionUserCase7Test.kt
@ -1,187 +0,0 @@
 package com.hormonetrack.pk
 import com.google.gson.Gson
 import com.hormonetrack.data.backup.BackupData
 import com.hormonetrack.data.model.Treatment
 import com.hormonetrack.data.model.TreatmentType
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNotNull
 import org.junit.Assert.assertTrue
 import org.junit.Assume.assumeTrue
 import org.junit.Before
 import org.junit.Test
 import java.io.File
 /**
 * **7ᵉ régression épinglée sur données réelles** (export v1.12.0, HORS dépôt
 * `local-test-data/backup-v1.12.0.json`, gitigné — données de santé).
 *
 * Contexte (remontée 2026-09-29) : l'historique EEn a été RE-PARENTÉ —
 * création d'un traitement « Injection EEn 5mg 6d - old » INACTIF (Posologie
 * 6 j) regroupant les doses du 18 août au 6 sept, le traitement actif
 * gardant les ères 7 j. Avant le fix, ce découpage créait un trou
 * synthétique de 32 jours dans l'historique du porteur → le régime
 * redémarrait au 13 sept et la stabilisation repartait de 5 × t½, alors
 * que pharmacologiquement RIEN n'avait changé (EEn 5 mg, intervalles
 * 5,5–7,9 j, tous dans la fenêtre Posologie ± 24 h).
 *
 * **Le fix v1.13.0 ([LabTiming.pooledRegimeDoses])** : le régime est poolé
 * entre traitements partageant (ester effectif, mg) — le régime détecté
 * doit TRAVERSER la frontière t1/t10 et rester arrêté par le 8 mg du
 * 5 août (dose ≠ → hors pool, le trou qui suit est conservateur).
 *
 * Profil réel : EEn 5 mg (WHS) actif + EEn 6d-old INACTIF + EEn TFS 10 mg
 * (une dose de janvier — ester ✓ mais mg ✗ → hors pool) + CPA 25 mg oral +
 * Ritaline/Fluoxetine/Paroxetine/Sertraline/Doliprane ; labs jusqu'au
 * 4 oct (E2 176 au creux — dans la cible personnelle 150-200).
 *
 * ⚠️ TOUTES les assertions sont DATA-DRIVEN (elles lisent le fichier local) :
 * aucune valeur de santé en dur dans ce fichier (garde de confidentialité
 * §8.bis — le scanner refuserait, et ce serait une fuite).
 */
 class RegressionUserCase7Test {
    companion object {
        private val DATA_FILE: File = listOf(
            File("../local-test-data/backup-v1.12.0.json"),
            File("local-test-data/backup-v1.12.0.json"),
            File("app/local-test-data/backup-v1.12.0.json")
        ).firstOrNull { it.exists() } ?: File("../local-test-data/backup-v1.12.0.json")
    }
    private val DAY_MS = 86_400_000L
    private lateinit var data: BackupData
    @Before
    fun setup() {
        assumeTrue(
            "local-test-data/backup-v1.12.0.json absent — tests ignorés (données locales)",
            DATA_FILE.exists()
        )
        data = Gson().fromJson(DATA_FILE.readText(), BackupData::class.java)
    }
    /** Porteur = injectable E2 ACTIF à Posologie (l'EEn 7 j). */
    private fun carrier() = data.treatments.first {
        it.type == TreatmentType.ESTRADIOL && it.isActive && it.usesProfileModel &&
            (it.forecastIntervalDays ?: 0.0) > 0.0
    }
    /** Le traitement « … - old » INACTIF du même ester (le re-parenté). */
    private fun reparentedInactive(): Treatment? =
        data.treatments.firstOrNull {
            it.type == TreatmentType.ESTRADIOL && !it.isActive && it.usesProfileModel
        }
    /** Structure attendue de l'export (les nombres viennent du FICHIER). */
    @Test
    fun `backup parses with the expected shape`() {
        assertEquals(10, data.treatments.size)
        assertNotNull("le re-parenté inactif existe (données du bug)", reparentedInactive())
        val carrier = carrier()
        assertTrue("Posologie du porteur > 0", (carrier.forecastIntervalDays ?: 0.0) > 0.0)
    }
    /**
     * **LE fix de cette régression** : le régime du porteur TRAVERSE la
     * frontière de re-parenting. Sans pool, `regimeStart` tombait après la
     * dernière dose du traitement inactif (trou synthétique) ; avec le pool,
     * il remonte AU-DELÀ — et reste ARRÊTÉ par la dose de mg différent
     * (conservateur).
     */
    @Test
    fun `pooled regime crosses the re-parenting boundary but stops at the dose change`() {
        val carrier = carrier()
        val pooled = LabTiming.pooledRegimeDoses(carrier, data.doseLogs, data.treatments)
        val regimeStart = LabTiming.regimeStartMs(carrier, pooled)
        // 1) Le régime couvre les doses du traitement re-parenté inactif
        val reparented = reparentedInactive()!!
        val reparentedLastTs = data.doseLogs
            .filter { it.treatmentId == reparented.id }
            .maxOf { it.timestamp }
        assertTrue(
            "le régime traverse la frontière de re-parenting " +
                "(regimeStart=$regimeStart ≤ dernière dose du re-parenté=$reparentedLastTs)",
            regimeStart <= reparentedLastTs
        )
        // 2) La dose de MG DIFFÉRENT du porteur (8 mg) arrête le régime :
        // elle est exclue du pool → le régime démarre APRÈS elle
        val oddDoseTs = data.doseLogs
            .filter { it.treatmentId == carrier.id && Math.abs(it.doseAmount - carrier.doseAmount) > 1e-6 }
            .maxOf { it.timestamp }
        assertTrue(
            "le régime reste arrêté par la dose de mg différent " +
                "(regimeStart=$regimeStart > 8mg=$oddDoseTs)",
            regimeStart > oddDoseTs
        )
        // 3) La stabilisation arrive RAPIDEMENT après l'export (le régime
        //    poolé démarre dans le dernier mois et demi) — l'artefact
        //    supprimé par le fix est le TROU SYNTHÉTIQUE de re-parenting,
        //    pas les vrais redémarrages de régime (l'écart 5,8 j du
        //    25→31 août reste hors fenêtre ± 24 h et casse légitimement).
        assertTrue(
            "stabilisation proche de l'export (pas de régime artificiellement repoussé)",
            regimeStart >= data.exportedAt - 60L * DAY_MS
        )
    }
    /**
     * La recommandation complète sur ce profil : calculable, creux futur
     * post-stabilisation, et — v1.13.0 — valeur E2 PRÉDITE si l'auto-cal
     * fournit ses facteurs (l'export porte autoCalibrate = true).
     */
    @Test
    fun `recommendation at export time is consistent and predicts the trough value`() {
        val auto = PharmacokineticEngine.autoCalibrated(
            data.treatments, data.doseLogs, data.labResults, data.tConfig
        )
        val rec = LabTiming.nextBloodDrawRecommendation(
            data.treatments, data.doseLogs, data.labResults, data.exportedAt,
            auto.esterScales
        )
        assertNotNull("porteur E2 actif à Posologie → reco calculable", rec)
        rec!!.let {
            assertTrue("creux futur", it.troughMs > data.exportedAt)
            assertTrue(
                "INVARIANT creux ≥ stabilisation (fix #68)",
                it.troughMs >= it.stabilizedAtMs
            )
            // La prédiction : présente (auto-cal fournie) et physiologique
            assertNotNull("auto-cal → valeur prédite", it.predictedE2)
            assertTrue(
                "E2 prédite physiologique (${it.predictedE2})",
                it.predictedE2!! in 20.0..1000.0
            )
            // Sans calibration → PAS de valeur (honnêteté)
            val raw = LabTiming.nextBloodDrawRecommendation(
                data.treatments, data.doseLogs, data.labResults, data.exportedAt
            )
            assertEquals(null, raw!!.predictedE2)
        }
    }
    /**
     * Le statut cible appliqué à la prédiction : la cible vient des champs
     * du fichier quand présents (ici absents de l'export v2 → null) — la
     * matrice complète est épinglée dans LabTimingV113Test.
     */
    @Test
    fun `target status stays null when the export carries no trough target`() {
        val auto = PharmacokineticEngine.autoCalibrated(
            data.treatments, data.doseLogs, data.labResults, data.tConfig
        )
        val rec = LabTiming.nextBloodDrawRecommendation(
            data.treatments, data.doseLogs, data.labResults, data.exportedAt,
            auto.esterScales
        )!!
        // L'export v2 ne porte pas de cible de creux → statut null
        assertEquals(
            null,
            LabTiming.troughTargetStatus(rec.predictedE2, null, null)
        )
    }
 }
--- a/app/src/test/java/com/hormonetrack/pk/RegressionUserCaseTest.kt
+++ b/app/src/test/java/com/hormonetrack/pk/RegressionUserCaseTest.kt
@ -40,7 +40,6 @@ class RegressionUserCaseTest {
        )
        if (!PKProfileStore.hasProfile("EEN", "ESE")) {
            val file = listOf(
                File("src/test/assets/pk_profiles.json"),
                File("src/main/assets/pk_profiles.json"),
                File("app/src/main/assets/pk_profiles.json")
            ).first { it.exists() }
--- a/app/src/test/java/com/hormonetrack/pk/ReminderLoggedDayTest.kt
+++ b/app/src/test/java/com/hormonetrack/pk/ReminderLoggedDayTest.kt
@ -1,82 +0,0 @@
 package com.hormonetrack.pk
 import com.hormonetrack.data.model.DoseLog
 import org.junit.Assert.assertFalse
 import org.junit.Assert.assertTrue
 import org.junit.Test
 import java.time.ZoneId
 import java.time.ZonedDateTime
 /**
 * Tests du garde « dose déjà loggée aujourd'hui » (v1.10.0, demande
 * utilisatrice) — [PharmacokineticEngine.hasDoseLoggedOnDay] : la
 * notification de rappel ne doit pas sonner pour une prise DÉJÀ saisie dans
 * la journée (le receiver saute la notif et re-programme le créneau suivant).
 *
 * Pur et DÉTERMINISTE : zone fixe (Europe/Paris), instants construits —
 * aucun System.currentTimeMillis. Le garde compare des JOURS CALENDAIRES
 * locaux : la frontière minuit est épinglée (23:50 la veille ≠ jour suivant).
 */
 class ReminderLoggedDayTest {
    private val ZONE = ZoneId.of("Europe/Paris")
    /** 2026-09-27 12:00 Europe/Paris (instant de référence du jour J). */
    private val noon = ZonedDateTime.of(2026, 9, 27, 12, 0, 0, 0, ZONE).toInstant().toEpochMilli()
    private val T1 = 1L
    private val T2 = 2L
    private val HOUR_MS = 3_600_000L
    private fun dose(treatmentId: Long, atMs: Long) =
        DoseLog(treatmentId = treatmentId, timestamp = atMs, doseAmount = 5.0)
    @Test
    fun `dose logged the same day skips the reminder`() {
        // Prise à 09:00, rappel à 12:00 — LE cas remonté (dose saisie avant
        // l'heure de rappel) : le créneau du jour est déjà honoré.
        val doses = listOf(dose(T1, noon - 3 * HOUR_MS))
        assertTrue(PharmacokineticEngine.hasDoseLoggedOnDay(T1, doses, noon, ZONE))
    }
    @Test
    fun `dose logged yesterday does not skip today's reminder`() {
        val doses = listOf(dose(T1, noon - 24 * HOUR_MS))
        assertFalse(PharmacokineticEngine.hasDoseLoggedOnDay(T1, doses, noon, ZONE))
    }
    @Test
    fun `midnight boundary is a calendar-day comparison in the given zone`() {
        // 23:50 le 26 → rappel 00:10 le 27 : jour CALendaire différent → pas de skip
        val lateEvening = ZonedDateTime.of(2026, 9, 26, 23, 50, 0, 0, ZONE).toInstant().toEpochMilli()
        val earlyMorning = ZonedDateTime.of(2026, 9, 27, 0, 10, 0, 0, ZONE).toInstant().toEpochMilli()
        assertFalse(
            "23:50 la veille ne couvre pas le rappel de 00:10",
            PharmacokineticEngine.hasDoseLoggedOnDay(T1, listOf(dose(T1, lateEvening)), earlyMorning, ZONE)
        )
        assertTrue(
            "00:10 et 12:00 du MÊME jour = même jour calendaire",
            PharmacokineticEngine.hasDoseLoggedOnDay(T1, listOf(dose(T1, earlyMorning)), noon, ZONE)
        )
    }
    @Test
    fun `a dose of another treatment never skips`() {
        val doses = listOf(dose(T2, noon - 3 * HOUR_MS))
        assertFalse(PharmacokineticEngine.hasDoseLoggedOnDay(T1, doses, noon, ZONE))
    }
    @Test
    fun `no dose at all never skips`() {
        assertFalse(PharmacokineticEngine.hasDoseLoggedOnDay(T1, emptyList(), noon, ZONE))
    }
    @Test
    fun `several treatments mixed - only the carrier's own day counts`() {
        val doses = listOf(
            dose(T2, noon - 1 * HOUR_MS),   // autre traitement aujourd'hui
            dose(T1, noon - 30 * HOUR_MS),  // porteur, mais la veille
        )
        assertFalse(PharmacokineticEngine.hasDoseLoggedOnDay(T1, doses, noon, ZONE))
    }
 }
--- a/app/src/test/java/com/hormonetrack/pk/ScaleFactorWhsahReproTest.kt
+++ b/app/src/test/java/com/hormonetrack/pk/ScaleFactorWhsahReproTest.kt
@ -49,9 +49,8 @@ class ScaleFactorWhsahReproTest {
    fun setup() {
        assumeTrue("export v1.4.2 absent (données locales)", DATA_FILE.exists())
        if (!PKProfileStore.hasProfile("EEN", "ESE")) {
-            val file = File("src/test/assets/pk_profiles.json")
+            val file = File("src/main/assets/pk_profiles.json")
                .takeIf { it.exists() }
                ?: File("src/main/assets/pk_profiles.json").takeIf { it.exists() }
                ?: File("app/src/main/assets/pk_profiles.json")
            PKProfileStore.initWithJson(file.readText())
        }
--- a/app/src/test/java/com/hormonetrack/pk/TransfemScienceEngineTest.kt
+++ b/app/src/test/java/com/hormonetrack/pk/TransfemScienceEngineTest.kt
@ -47,7 +47,6 @@ class TransfemScienceEngineTest {
        // l'asset pour rester au plus près du comportement réel de l'app.
        if (!PKProfileStore.hasProfile("EV", "ESE")) {
            val file = listOf(
                File("src/test/assets/pk_profiles.json"),
                File("src/main/assets/pk_profiles.json"),
                File("app/src/main/assets/pk_profiles.json")
            ).first { it.exists() }
@ -80,24 +79,14 @@ class TransfemScienceEngineTest {
    }
    @Test
-    fun `EB forced to ESE model yields a REAL curve (analytic since v1_9_0)`() {
+    fun `EB forced to ESE model yields zero (no ODS table for this ester)`() {
        // v1.9.0 : l'Estrannaise est devenue ANALYTIQUE (estrannaise.js) et
        // couvre désormais EB (fit « EB im ») — l'ancien test épinglait
        // « EB+ESE → 0, pas de table ODS pour cet ester » (obsolète)
        val tr = treatment(Esters.EB, doseMg = 5.0)
        val dose = DoseLog(treatmentId = 1L, timestamp = BASE, doseAmount = 5.0)
        val curve = PharmacokineticEngine.computeCurve(
            listOf(tr), listOf(dose), BASE, BASE + 5 * DAY_MS,
            tConfig = TConfig(), modelOverride = PKModels.ESTRANNAISE
        )
-        assertTrue("EB ESE analytique produit une courbe non vide", curve.any { it.e2 > 0.0 })
+        assertTrue(curve.all { it.e2 == 0.0 })
        // et un ester réellement NON couvert par les trois modèles → 0
        val unknown = tr.copy(esterType = "XXX")
        val curve2 = PharmacokineticEngine.computeCurve(
            listOf(unknown), listOf(dose), BASE, BASE + 5 * DAY_MS,
            tConfig = TConfig(), modelOverride = PKModels.ESTRANNAISE
        )
        assertTrue("ester inconnu → 0 dans les trois modèles", curve2.all { it.e2 == 0.0 })
    }
    @Test
--- a/app/src/test/java/com/hormonetrack/pk/V120FeaturesTest.kt
+++ b/app/src/test/java/com/hormonetrack/pk/V120FeaturesTest.kt
@ -30,7 +30,6 @@ class V120FeaturesTest {
    fun setup() {
        if (!PKProfileStore.hasProfile("EEN", "ESE")) {
            val file = listOf(
                File("src/test/assets/pk_profiles.json"),
                File("src/main/assets/pk_profiles.json"),
                File("app/src/main/assets/pk_profiles.json")
            ).first { it.exists() }
@ -264,9 +263,7 @@ class V120FeaturesTest {
    @Test
    fun `scalePerEster scales each dose by its own ester factor`() {
        val tr = eenTreatment().copy(esterType = Esters.EV, scaleFactor = 999.0) // ne doit PAS être utilisé
-        // v1.9.0 : la dose EV doit être DANS le cutoff ESE analytique
+        val evDose = DoseLog(treatmentId = 1, timestamp = BASE - 30 * DAY, doseAmount = 4.0, esterType = Esters.EV)
        // (10 × t½ EV = 29,4 j — l'ancien cutoff ODS était 333 j) : −10 j
        val evDose = DoseLog(treatmentId = 1, timestamp = BASE - 10 * DAY, doseAmount = 4.0, esterType = Esters.EV)
        val eenDose = DoseLog(treatmentId = 1, timestamp = BASE - 3 * DAY, doseAmount = 5.0, esterType = Esters.EEN)
        val scales = mapOf("EV" to 0.5, "EEN" to 2.0)
        val t = BASE
--- a/app/src/test/java/com/hormonetrack/pk/WhsahEngineTest.kt
+++ b/app/src/test/java/com/hormonetrack/pk/WhsahEngineTest.kt
@ -41,7 +41,6 @@ class WhsahEngineTest {
        // les tables ODS servent au chemin ESE (test de contraste)
        if (!PKProfileStore.hasProfile("EV", "ESE")) {
            val file = listOf(
                File("src/test/assets/pk_profiles.json"),
                File("src/main/assets/pk_profiles.json"),
                File("app/src/main/assets/pk_profiles.json")
            ).first { it.exists() }
--- a/app/src/test/java/com/hormonetrack/pk/WhsahModelsTest.kt
+++ b/app/src/test/java/com/hormonetrack/pk/WhsahModelsTest.kt
@ -90,10 +90,7 @@ class WhsahModelsTest {
        assertEquals(listOf("EV", "EU", "EEN", "EB", "EC", "ECS"),
            com.hormonetrack.data.model.Esters.choicesForModel(
                com.hormonetrack.data.model.PKModels.WHSAH))
-        // v1.9.0 : ESE analytique (estrannaise.js) couvre 6 injectables,
+        assertEquals(listOf("EV", "EU", "EEN"),
        // dont EUCS (undécylate suspension cristalline, exclusif à ce fit) ;
        // l'ancienne couverture tables ODS n'était que EV/EU/EEn
        assertEquals(listOf("EV", "EU", "EEN", "EC", "EB", "EUCS"),
            com.hormonetrack.data.model.Esters.choicesForModel(
                com.hormonetrack.data.model.PKModels.ESTRANNAISE))
    }
--- a/app/src/test/java/com/hormonetrack/ui/ChartZoomTest.kt
+++ b/app/src/test/java/com/hormonetrack/ui/ChartZoomTest.kt
@ -281,32 +281,6 @@ class ChartZoomTest {
        }
    }
    @Test
    fun `xLabelTicks daily steps stay at local midnight across DST transition`() {
        // v1.9.5 (audit) : l'avancement du pas se fait par Calendar (et non
        // un +24h fixe en ms) — sans ça, le tick qui FRANCHIT la transition
        // tombait à 23h/01h locale au lieu de minuit. Europe/Paris 2026 :
        // passage à l'heure d'été le 29 mars (02:00 → 03:00).
        val zone = java.util.TimeZone.getTimeZone("Europe/Paris")
        val cal = java.util.Calendar.getInstance(zone).apply {
            clear()
            set(2026, 2, 27, 12, 0, 0) // 27/03/2026 12:00 — la fenêtre chevauche la transition
        }
        val t0 = cal.timeInMillis
        val ticks = com.hormonetrack.ui.components.xLabelTicks(
            t0, t0 + 6L * 86_400_000L, 24L, zone
        )
        assertTrue(ticks.isNotEmpty())
        var crossed = false
        for (t in ticks) {
            val c = java.util.Calendar.getInstance(zone).apply { timeInMillis = t }
            assertEquals("tick à ${c.time} doit être minuit Paris (DST franchi)",
                0, c.get(java.util.Calendar.HOUR_OF_DAY))
            if (c.get(java.util.Calendar.DAY_OF_MONTH) >= 30) crossed = true
        }
        assertTrue("la fenêtre doit franchir la transition DST pour distinguer les deux implémentations", crossed)
    }
    @Test
    fun `xLabelTicks hourly steps land at whole local hours`() {
        val now = System.currentTimeMillis()
--- a/app/src/test/java/com/hormonetrack/ui/DosesExtrasTest.kt
+++ b/app/src/test/java/com/hormonetrack/ui/DosesExtrasTest.kt
@ -1,106 +0,0 @@
 package com.hormonetrack.ui
 import com.hormonetrack.data.model.AdministrationRoute
 import com.hormonetrack.data.model.LabResult
 import com.hormonetrack.ui.screens.labMarkersForDose
 import com.hormonetrack.ui.screens.routeIcon
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
 import org.junit.Assert.assertNotEquals
 import org.junit.Assert.assertTrue
 import org.junit.Test
 import java.time.ZoneId
 import java.time.ZonedDateTime
 /**
 * Tests des ajouts v1.12.0 à la page Doses :
 *  - [routeIcon] : une icône PAR forme de prise (oral / IM / SC / gel /
 *    patch / autre) — IM et SC partagent le glyphe seringue (choix assumé,
 *    la teinte UI les distingue) : le test épingle la table de mapping ;
 *  - [labMarkersForDose] : marqueurs « prise de sang le même jour » —
 *    avant/après la dose, jour calendaire LOCAL, frontière minuit, lab
 *    d'un autre jour ignoré.
 *
 * Déterministes (zone fixe, instants construits) ; miroir web
 * `tests/doses-extras.test.js`.
 */
 class DosesExtrasTest {
    private val ZONE = ZoneId.of("Europe/Paris")
    /** 2026-09-27 12:00 Europe/Paris. */
    private val noon = ZonedDateTime.of(2026, 9, 27, 12, 0, 0, 0, ZONE).toInstant().toEpochMilli()
    private fun lab(atMs: Long) = LabResult(
        marker = "E2", value = 100.0, unit = "pg/mL", timestamp = atMs
    )
    // ── routeIcon ──────────────────────────────────────────────────────────
    @Test
    fun `each route has its own glyph (except IM-SC sharing the syringe by design)`() {
        val oral = routeIcon(AdministrationRoute.ORAL)
        val im = routeIcon(AdministrationRoute.INJECTION_IM)
        val sc = routeIcon(AdministrationRoute.INJECTION_SUBCUT)
        val gel = routeIcon(AdministrationRoute.TRANSDERMAL_GEL)
        val patch = routeIcon(AdministrationRoute.TRANSDERMAL_PATCH)
        val other = routeIcon(AdministrationRoute.OTHER)
        assertNotEquals(oral, im)
        assertNotEquals(oral, gel)
        assertNotEquals(oral, patch)
        assertNotEquals(im, gel)
        assertNotEquals(gel, patch)
        assertNotEquals(patch, other)
        assertEquals("IM/SC : même seringue (teinte UI distincte)", im, sc)
    }
    @Test
    fun `null route falls back to the OTHER glyph`() {
        assertEquals(routeIcon(AdministrationRoute.OTHER), routeIcon(null))
    }
    // ── labMarkersForDose ──────────────────────────────────────────────────
    @Test
    fun `same-day lab before and after the dose produce both markers`() {
        val markers = labMarkersForDose(
            listOf(lab(noon - 3_600_000L), lab(noon + 3_600_000L)), noon, ZONE
        )
        assertTrue(markers.first)
        assertTrue(markers.second)
    }
    @Test
    fun `lab of another day never marks the dose`() {
        val yesterday = noon - 24 * 3_600_000L
        val markers = labMarkersForDose(listOf(lab(yesterday)), noon, ZONE)
        assertFalse(markers.first)
        assertFalse(markers.second)
    }
    @Test
    fun `midnight boundary is a calendar-day comparison`() {
        // Lab à 23:50 la veille, dose à 00:10 : jours calendaires DIFFÉRENTS
        // → pas de marqueur (le lien clinique ne traverse pas minuit).
        val lateEvening = ZonedDateTime.of(2026, 9, 26, 23, 50, 0, 0, ZONE).toInstant().toEpochMilli()
        val earlyMorning = ZonedDateTime.of(2026, 9, 27, 0, 10, 0, 0, ZONE).toInstant().toEpochMilli()
        val markers = labMarkersForDose(listOf(lab(lateEvening)), earlyMorning, ZONE)
        assertFalse(markers.first)
        assertFalse(markers.second)
    }
    @Test
    fun `lab exactly at dose time counts as AFTER (documented convention)`() {
        val markers = labMarkersForDose(listOf(lab(noon)), noon, ZONE)
        assertFalse(markers.first)
        assertTrue(markers.second)
    }
    @Test
    fun `no labs - no markers`() {
        val markers = labMarkersForDose(emptyList(), noon, ZONE)
        assertFalse(markers.first)
        assertFalse(markers.second)
    }
 }
--- a/app/src/test/java/com/hormonetrack/ui/NextDoseLineTest.kt
+++ b/app/src/test/java/com/hormonetrack/ui/NextDoseLineTest.kt
@ -1,45 +0,0 @@
 package com.hormonetrack.ui
 import com.hormonetrack.ui.screens.nextDoseLine
 import org.junit.Assert.assertEquals
 import org.junit.Test
 import java.time.ZoneId
 import java.time.ZonedDateTime
 import java.util.Locale
 /**
 * Tests du helper PUR `nextDoseLine` (v1.9.6 — carte « Prochaines doses » de
 * l'Accueil, une ligne par traitement triée par prochaine prise). Zone et
 * locale FIXES pour un format déterministe.
 */
 class NextDoseLineTest {
    private val zone = ZoneId.of("Europe/Paris")
    private val locale = Locale.US
    // Template du cas ≥ 24 h (string EN `next_dose_days`)
    private val daysTemplate = "%1\$d d %2\$d h · %3\$s (%4\$s)"
    private fun at(hoursFromNow: Long): Long =
        ZonedDateTime.of(2026, 9, 21, 12, 0, 0, 0, zone).toInstant().toEpochMilli() + hoursFromNow * 3_600_000L
    @Test
    fun `au-dela de 24 h - jours + jour de semaine`() {
        // now = lundi 21/09 12:00 → fire = samedi 26/09 10:00 (118 h)
        val line = nextDoseLine(at(0), at(118), "Injection EEn 5mg 7d", daysTemplate, zone, locale)
        assertEquals("4 d 22 h · Sat 26 10:00 (Injection EEn 5mg 7d)", line)
    }
    @Test
    fun `entre 1 h et 24 h - heures et minutes`() {
        // now = 12:00 → fire = 14:05 (2 h 05)
        val line = nextDoseLine(at(0), at(2) + 5 * 60_000L, "CPA", daysTemplate, zone, locale)
        assertEquals("2h05 · 14:05 (CPA)", line)
    }
    @Test
    fun `moins d'une heure - minutes`() {
        // now = 12:00 → fire = 12:07
        val line = nextDoseLine(at(0), at(0) + 7 * 60_000L, "CPA", daysTemplate, zone, locale)
        assertEquals("7 min · 12:07 (CPA)", line)
    }
 }
--- a/app/src/test/java/com/hormonetrack/ui/TreatmentsDisplayTest.kt
+++ b/app/src/test/java/com/hormonetrack/ui/TreatmentsDisplayTest.kt
@ -1,86 +0,0 @@
 package com.hormonetrack.ui
 import com.hormonetrack.data.model.AdministrationRoute
 import com.hormonetrack.data.model.Treatment
 import com.hormonetrack.data.model.TreatmentType
 import com.hormonetrack.ui.screens.treatmentsForDisplay
 import org.junit.Assert.assertEquals
 import org.junit.Test
 /**
 * Tests de l'ORDRE D'AFFICHAGE de la page Traitements (v1.11.0, demande
 * utilisatrice : « les traitements inactifs faudrait les placer à la fin
 * (tout en bas) de la liste ») — [treatmentsForDisplay] :
 *  - les ACTIFS d'abord, les INACTIFS regroupés après ;
 *  - tri STABLE : l'ordre relatif DANS chaque groupe est conservé (le tri
 *    ne réordonne jamais les actifs entre eux, ni les inactifs entre eux) ;
 *  - cas limites : liste vide, tout actif, tout inactif (identité).
 *
 * PUR (aucune dépendance Android) ; miroir web `treatmentsForDisplay`
 * (js/data/models.js, tests/treatments-display.test.js).
 */
 class TreatmentsDisplayTest {
    private fun tr(id: Long, name: String, isActive: Boolean) = Treatment(
        id = id, name = name, type = TreatmentType.ESTRADIOL,
        route = AdministrationRoute.INJECTION_IM,
        doseAmount = 5.0, doseUnit = "mg",
        isActive = isActive, createdAt = 0
    )
    @Test
    fun `inactive treatments are grouped at the end`() {
        val mixed = listOf(
            tr(1, "EEn", true),
            tr(2, "EV-old", false),
            tr(3, "CPA", true),
            tr(4, "EEn-old", false),
            tr(5, "Ritaline", true)
        )
        val display = treatmentsForDisplay(mixed)
        assertEquals(
            "actifs d'abord (ordre conservé), inactifs après (ordre conservé)",
            listOf(1L, 3L, 5L, 2L, 4L),
            display.map { it.id }
        )
        assertEquals(
            "aucun inactif avant un actif",
            0,
            display.indexOfFirst { !it.isActive }.let { firstInactive ->
                if (firstInactive < 0) 0
                else display.subList(firstInactive, display.size).count { it.isActive }
            }
        )
    }
    @Test
    fun `ordering inside each group is preserved (stable sort)`() {
        val mixed = listOf(
            tr(10, "A-inactif", false),
            tr(11, "B-actif", true),
            tr(12, "C-inactif", false),
            tr(13, "D-actif", true)
        )
        assertEquals(
            listOf(11L, 13L, 10L, 12L),
            treatmentsForDisplay(mixed).map { it.id }
        )
    }
    @Test
    fun `all active - order unchanged`() {
        val all = listOf(tr(3, "C", true), tr(1, "A", true), tr(2, "B", true))
        assertEquals(listOf(3L, 1L, 2L), treatmentsForDisplay(all).map { it.id })
    }
    @Test
    fun `all inactive - order unchanged`() {
        val all = listOf(tr(2, "B", false), tr(1, "A", false))
        assertEquals(listOf(2L, 1L), treatmentsForDisplay(all).map { it.id })
    }
    @Test
    fun `empty list stays empty`() {
        assertEquals(0, treatmentsForDisplay(emptyList()).size)
    }
 }
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@ -3,457 +3,6 @@
 Format : [Keep a Changelog](https://keepachangelog.com/fr-FR/1.1.0/).
 Versionnage : [SemVer](https://semver.org/). Releases taguées dans git (`v1.4.10`, …).
 ## [1.13.0] — 2026-09-30 (versionCode 50)
 ### Ajouté — la reco de prise de sang devient prédictive (3 niveaux clairs)
 - **Valeur E2 attendue au creux recommandé** : la carte (Accueil + Analyses)
  affiche désormais « ≈ X pg/mL » quand l'auto-calibration fournit ses
  facteurs — sinon rien (une valeur brute non calibrée serait trompeuse).
  Tu sais AVANT de piquer si le creux tombera dans ta cible.
 - **Régime POOLÉ entre traitements identiques** : `pooledRegimeDoses` — les
  doses de tous les traitements partageant (ester effectif, mg) forment UNE
  séquence. Un re-parenting d'historique (créer un « … - old » et y
  déplacer des doses) ne fait plus redémarrer la stabilisation. Garde-fous
  épinglés : ester ≠ → jamais poolé (transition EV→EEn) ; dose ≠ → exclue
  (le 8 mg casse le régime, trou conservateur).
 - **Cible de creux E2** (opt-in, Paramètres) : référence personnelle « je
  veux être dans [basse, haute] au creux recommandé » — la prédiction est
  colorée dans/hors cible sur la carte. ⚠️ **DISTINCT des seuils d'alerte**
  (§9.bis) : les seuils surveillent le niveau en continu et notifient ; la
  cible est une référence de lab, elle ne notifie JAMAIS. Voyage dans le
  backup (champs optionnels rétrocompatibles — un backup ancien n'efface
  pas la cible locale).
 - **Régression n°7** épinglée sur données réelles (`backup-v1.12.0.json`,
  gitigné — l'export avec le re-parenting « 6d-old ») : le régime poolé
  traverse la frontière de re-parenting et reste arrêté par le 8 mg.
 Vérifié : **284 tests JVM** (250 sans données locales) + **14 tests UI** +
 lint verts ; **web 199 tests + E2E verts** (`check.sh`).
 ## [1.12.0] — 2026-09-29 (versionCode 49)
 ### Corrigé — un traitement inactif à Posologie projetait encore ses injections (#70)
 - **Remontée** : « une injection qui n'est plus active est toujours prise en
  compte dans le graphique de simulations si elle contient une posologie et
  qu'elle a déjà été utilisée — un traitement mis en inactif ne devrait
  plus être pris en compte pour les futures prédictions ».
 - **Cause** : `generateForecastDoses` (source unique des créneaux
  prévisionnels) ne vérifiait pas l'archivage ; de plus l'horizon du chip
  Prévision du graphique incluait les Posologies INACTIVES.
 - **Fix** : garde `!isActive` dans le moteur (l'historique reste simulé —
  §6.bis inchangé — seul le FUTUR s'arrête, comme les rappels depuis
  v1.4.0) + horizon/chip Prévision calculés sur les ACTIFS uniquement.
  **Miroir web appliqué** (`js/pk/pk-engine.js` + `js/ui/chart.js`).
 - Tests : 3 tests JVM (`ForecastDosesGuardTest`) + 3 miroirs web ;
  émulateur avec données modifiées (2 inactifs à Posologie 7 j) :
  Prévision on/off sans crash.
 ### Ajouté — icônes de forme de prise dans la page Doses
 - Chaque ligne de dose porte désormais l'icône de sa forme : 💊-icône pilule
  (oral), seringue (injection IM et SC — teinte distincte pour la SC),
  goutte (gel), sparadrap (patch), compte-gouttes (autre). Miroir web :
  émojis (`routeGlyph`, même mapping).
 ### Ajouté — marqueurs « prise de sang le même jour » sur les lignes de doses
 - Une analyse de sang effectuée LE MÊME JOUR qu'une dose affiche un petit
  encart latéral 🧪↑ (avant la dose) et/ou 🧪↓ (après) — pour visualiser
  les prises de sang dans le tableau de dosages (demande utilisatrice).
  Fenêtre = jour calendaire LOCAL (au-delà le lien clinique devient ténu).
  Helper pur `labMarkersForDose` (Kotlin + miroir web) — 7 tests JVM
  (`DosesExtrasTest` : mapping icônes + marqueurs, frontière minuit,
  convention « à l'heure de la dose = après ») + 10 miroirs web.
 - Vérifié émulateur avec données réelles : glyphes en tête de liste,
  marqueur « Blood test later the same day » sur la dose du 10 sept
  (analyse 35 min après).
 Vérifié : **274 tests JVM** (240 sans données locales) + **14 tests UI** +
 lint verts ; **web 194 tests + E2E verts** (`check.sh`).
 ## [1.11.0] — 2026-09-29 (versionCode 48)
 ### Ajouté — les traitements inactifs regroupés en bas de la page Traitements
 - **Demande** : « les traitements inactifs sont peu discernables par rapport
  aux traitements actifs — les placer à la fin (tout en bas) de la liste
  pour éviter les confusions ».
 - **Tri** : les ACTIFS d'abord, les INACTIFS regroupés **tout en bas**, sous
  un en-tête de section « Traitements inactifs » (n'apparaît que s'il
  existe des inactifs). Tri STABLE : l'ordre relatif à l'intérieur de
  chaque groupe est conservé — le tri ne réordonne jamais les actifs entre
  eux, ni les inactifs entre eux.
 - **Distinction visuelle renforcée** : les cartes inactives sont ATTÉNUÉES
  (alpha 0,55) en plus du badge « inactif » — second signal demandé
  (« peut-être les rendre plus distincts ») ; elles restent lisibles et
  tappables (l'édition d'un traitement archivé doit rester possible).
 - Helper pur `treatmentsForDisplay` (Kotlin + **miroir web** en
  `js/data/models.js`) — 5 tests JVM (`TreatmentsDisplayTest`) + 4 tests
  web (`tests/treatments-display.test.js`).
 - Vérifié émulateur avec données réelles seedées : les 5 actifs en haut,
  en-tête puis les 2 inactifs (EV-old, EEn-old) tout en bas.
 Vérifié : **264 tests JVM** (230 sans données locales) + **14 tests UI** +
 lint verts ; **web 184 tests + E2E verts** (`check.sh`).
 ## [1.10.1] — 2026-09-28 (versionCode 47)
 ### Amélioré — durcissement du système de rappels (revue de code post-v1.10.0)
 - **`launchMode="singleTop"` sur MainActivity** : un tap sur la notification
  quand l'app est DÉJÀ ouverte délivre désormais `onNewIntent` (dialog de
  saisie ouvert, extras traités) **sans détruire/recréer l'activité** —
  l'ancien combo `standard` + `CLEAR_TOP` recréait tout et rendait le chemin
  `onNewIntent` de la v1.10.0 inopérant (code mort).
 - **Instant PLANIFIÉ dans l'alarme (`EXTRA_PLANNED_AT`)** : le garde
  « créneau déjà honoré » (v1.10.0) évaluait le jour au moment du FEU — une
  alarme inexacte (`setWindow`) ou retardée (Doze) glissant après minuit
  évaluait le mauvais jour (23:58 → 00:02). L'instant planifié voyage
  désormais dans l'intent de l'alarme, le snooze le FORWARDE tel quel, et
  le garde évalue toujours le jour du CRÉNEAU. Vérifié sur émulateur par
  broadcast avec `planned_at` daté d'hier → notification correctement
  sautée.
 - **`BootReceiver` consolidé** (dette §20.bis #2) : `goAsync` + coroutine IO
  (pattern ReminderReceiver) — remplace le `Thread` + double `runBlocking`
  de la v1.0 ; une seule lecture séquentielle des DAO, `finish()` garanti.
 - Audit doc : comptes de tests périmés corrigés (§14 note #64, §16.ter).
 Vérifié : 259 tests JVM + 14 tests UI + lint verts ; scénarios émulateur
 (singleTop + planned_at). Web non concerné (aucune logique miroir touchée).
 ## [1.10.0] — 2026-09-27 (versionCode 46)
 ### Corrigé — la recommandation de prise de sang précédait la stabilisation (#68)
 - **Remontée** : « la recommandation suggère une date antérieure à la
  stabilisation des taux » (données réelles de la remontée → 6ᵉ régression
  épinglée `local-test-data/backup-v1.9.8.json`, gitigné).
 - **Cause (double)** : le « creux » était le **minimum de la fenêtre entière**
  (créneau N−1 → créneau N). Pour un ester à montée lente (EEn : pic ~J+5 ≈
  intervalle 7 j), ce minimum tombe **juste après l'injection PRÉCÉDENTE**
  (creux d'absorption, ~3 h) — pas juste avant la suivante : la date proposée
  était gouvernée par l'injection N−1, elle-même antérieure à la
  stabilisation, et le texte « juste avant ton injection du … » était faux de
  plusieurs jours. Balayage sur ±60 jours de `now` (test) : creux 5 oct 02:32
  vs stabilisation 7 oct 04:03.
 - **Fix** : le creux = **niveau PRÉ-INJECTION du créneau** (dernier point de
  courbe avant l'injection) — restaure le principe v1.8.0 documenté (« juste
  avant l'injection suivante, le moment le plus comparable »), rend la carte
  cohérente (creux 46 min avant le créneau étiqueté) et le garde de
  stabilisation s'exprime sur l'instant réellement proposé. Pour les esters à
  t½ courte (EV), le point pré-injection EST le minimum de fenêtre :
  comportement inchangé. **Miroir web appliqué** (`js/pk/lab-timing.js`).
 - Tests : régression n°6 data-driven (4 tests dont un balayage de `now` sur
  ±60 j — l'invariant « creux ≥ stabilisation » doit tenir À TOUT INSTANT) ;
  les 17 LabTimingTest passent inchangés (leur sémantique était celle du fix).
 ### Corrigé — le dialog de dose se rouvrait à chaque retour sur l'accueil (#69)
 - **Remontée** : tap sur la notification de rappel → le dialog de saisie
  s'ouvre ; le fermer puis changer d'onglet et revenir sur l'accueil le
  ROUVRAIT à chaque fois (reproduit et revérifié sur émulateur).
 - **Cause** : la demande vivait au niveau ACTIVITÉ (paramètre d'intent) mais
  la consommation vivait dans un `LaunchedEffect` de Home — quitter l'onglet
  détruit les `remember` locaux, le paramètre survivait → à chaque
  ré-entrée en composition, le dialog se rouvrait.
 - **Fix** : la demande est un état `MutableState<Long?>` détenu par
  MainActivity (survit aux onglets), consommé UNE fois par HomeScreen ;
  les extras sont retirés de l'intent après lecture (un recreate ne doit
  jamais rouvrir une notification traitée) ; et un tap notification quand
  l'app est déjà ouverte ouvre désormais aussi le dialog (avant :
  silencieusement perdu).
 - Tests : nouveau test UI instrumenté `LogDoseRequestTest` (ouverture 1× +
  plus jamais après aller-retour d'onglets) + vérification émulateur.
 ### Ajouté — la notification de rappel saute un créneau déjà honoré
 - **Demande** : si la dose prévue du jour est saisie AVANT l'heure de
  rappel, la notification ne doit pas sonner pour une prise déjà faite ; le
  rappel suivant repart au créneau suivant (idem pour le quotidien des
  oraux sans Posologie).
 - **Implémentation** : garde au moment du déclenchement —
  `PharmacokineticEngine.hasDoseLoggedOnDay` (pur, jour calendaire LOCAL,
  testable) consultée par `ReminderReceiver` : dose loguée aujourd'hui →
  notification sautée (AppLog) + re-programmation du créneau suivant dans
  tous les cas. Robuste quel que soit le moment de la saisie.
 - Tests : 6 tests JVM (`ReminderLoggedDayTest` : même jour, veille,
  frontière minuit, autre traitement, liste vide, mélange) + vérification
  A/B sur émulateur (EEn dose-loguée-ce-jour → 0 notif ; Fluoxetine sans
  dose → 1 notif).
 Vérifié : **259 tests unitaires** (dont régression n°6 sur données réelles)
 + **14 tests UI** + lint vert ; web miroir : **180 tests + E2E verts**
 (`check.sh`). Version web alignée au moment de la release (checklist 4.bis).
 ## [1.9.8] — 2026-09-22 (versionCode 45)
 ### Ajouté — tests UI Compose, signature release dédiée, README anglais
 - **13 tests UI instrumentés** (navigation 5 onglets, dialog « Nouveautés »
  — épinglage du fix v1.3.2 « ne réapparaît pas après dismiss » —, sections
  Paramètres, version installée = BuildConfig : le bug #46 « versions jamais
  bumpées » ne peut plus revenir silencieusement). Déterministes : permission
  de notifications pré-grantée, zéro dépendance aux données, indépendants de
  la langue FR/EN. Exécution : `./gradlew connectedDebugAndroidTest`.
 - **Signature release dédiée, prête à l'emploi** : `scripts/make-release-keystore.sh`
  crée le keystore + `keystore.properties` (gitignorés) ; `assembleRelease`
  l'utilise dès qu'il existe (sinon clé debug inchangée). Migration
  téléphone documentée (export JSON → désinstallation → réinstallation →
  réimport). Aucun changement pour l'utilisatrice tant que la bascule n'est
  pas faite.
 - **README anglais** ([README.en.md](README.en.md)) — lien FR/EN en tête de
  chaque fichier ; la doc de développement reste en français.
 ### Modifié — écran Paramètres découpé (maintenance)
 - `SettingsScreen.kt` (840 lignes) devient un orchestrateur de 377 lignes +
  11 cartes thématiques dans `ui/screens/settings/` (langue, calibration,
  modèle T, seuils, fuseau, rappels, sauvegarde, auto-backup, logs, à propos).
  **Comportement et rendu strictement identiques** (déplacement pur) ;
  validé par les tests UI + smoke test RELEASE sur émulateur (toutes les
  sections, version 1.9.8, 0 crash — anti-bug #64).
 - `ChartScreen` reste volontairement entier : sa garde de source (#54)
  exige le bloc de gestes dans ce fichier.
 Vérifié : 249 tests unitaires + 13 tests UI verts, lint vert, APK debug +
 release (2,7 Mo) buildés, smoke test release complet (accueil, 5 onglets,
 Paramètres, éditeur de traitement, dialog de dose — 0 crash).
 ## [1.9.7] — 2026-09-20 (versionCode 44)
 ### Corrigé — la suggestion de prise de sang « change tout le temps » à chaque injection
 - **Remontée** : « la suggestion de prochain test sanguin change tout le
  temps à chaque injection si l'injection n'est pas faite pile à la même
  heure ou si elle est faite 30 minutes plus tard que la précédente ».
 - **Cause** : la règle de stabilisation v1.8.1 comparait l'écart inter-doses
  **EXACTEMENT** à l'écart précédent (au ms près) — un log à 12:30 au lieu
  de 12:00 cassait le régime, repoussant la stabilisation de 5 × t½ à
  CHAQUE injection : le creux recommandé fuyait vers l'avant sans jamais
  se fixer.
 - **Fix (tolérance)** : chaque écart doit rester dans **l'intervalle de
  Posologie ± 24 h** (`GAP_TOLERANCE_MS` — « je m'injecte le même jour, à
  l'heure près »). La fenêtre se réfère à l'INTERVALLE THÉORIQUE, pas à
  l'écart précédent : des logs à 6,8 j puis 7,2 j ne se déstabilisent plus
  en cascade. Un vrai changement de créneau (2 j au lieu de 7 j) reste
  hors fenêtre et réinitialise, comme avant. Le créneau affiché se cale
  toujours sur la dernière dose réelle (voulu).
 - Tests : le test v1.8.1 « interval change » ré-épinglé (NOW+21 j) + 2
  nouveaux (flou d'heure ± 23 h → PAS de reset ; écart 25 h → reset).
  249 tests verts + lint. Web miroir v1.9.7 (12 tests lab-timing).
 ## [1.9.6] — 2026-09-20 (versionCode 43)
 ### Modifié — la carte de l'Accueil liste TOUTES les prochaines prises
 - **Remontée** : « si une injection et une prise d'un autre médicament ont
  lieu en même temps… le rappel ne montre que la prise qui vient, non
  toutes les prises du jour » — avec une prise quotidienne (CPA), le
  rappel de l'injection hebdomadaire (EEn) « n'arrive qu'après celui de la
  CPA, du coup je ne le vois quasiment pas ».
 - **Fix** : la carte « Prochaine dose » devient « **Prochaines doses** »
  (titre pluriel dès 2 lignes) — **une ligne par traitement, TRIÉES par
  prochaine prise** ; la 1ʳᵉ ligne (la plus proche) reste mise en avant.
  Format de ligne inchangé (`Xj Yh · ven. 25 10:00 (nom)`, `XhMM · HH:mm`,
  `N min`). Le CPA se lit désormais AU-DESSUS de l'EEn du samedi, jamais à
  sa place.
 - Les NOTIFICATIONS de rappel sont inchangées (une alarme par traitement
  — le problème était purement l'affichage de l'Accueil).
 - Moteur : helper PUR `nextDoseLine` (HomeScreen.kt, locale/zone
  paramétrables, template jours localisé) — 3 tests (NextDoseLineTest).
  247 tests verts + lint.
 ## [1.9.5] — 2026-09-20 (versionCode 42)
 ### Corrigé — revue de code post-v1.9.4 (audit lecture-seule des deux dépôts)
 - **#67 — les ticks X ignoraient le fuseau choisi** : `drawXLabels` formatait
  les labels DANS le fuseau choisi mais appelait `xLabelTicks` SANS le
  passer — les ticks étaient alignés sur le fuseau de l'appareil (heures
  décalées dès que les deux divergent, contredisant le fix #55). Fix :
  zone passée + **pas avancé par Calendar** (un `+24 h` fixe dérivait d'1 h
  aux transitions DST) ; test DST épinglé (Europe/Paris, 29/03/2026).
 - **`EstrannaiseCloud.compute` : paramètre `nowMs` mort supprimé** (jamais
  lu — le KDoc prétendait une sémantique que le code n'avait pas) ;
  appelants + tests mis à jour.
 ### Amélioré — perf (suite de l'optimisation v1.8.2)
 - **Contexte moteur pré-calculé** (`E2Context` + `prepareE2Context`) : le
  tracé labs appelle `e2At` par point de grille (720 pts) — chaque appel
  reconstruisait les maps internes (groupBy/cutoffs/Bateman), diluant
  l'optimisation v1.8.2. Préparé UNE fois par courbe labs ET par
  calibration par ester ; **résultat bit-identique** (244 tests verts).
 - **Canvas** : Paints texte MÉMOÏSÉS par (couleur, taille, align, gras)
  (une alloc par extremum/label × frame → une par clé) ; `detectExtrema`
  mémoïsé par série (scan O(n) par frame → par changement de séries) ;
  formatters X/marqueurs mémoïsés (SimpleDateFormat par frame → par
  fuseau).
 ### Documenté — commentaires et docs rattrapés après les refontes
 - Commentaires à jour avec le code : `PKPresets.kt` (l'ODS n'existe plus
  au runtime), `Treatment.kt` (ESE analytique 6 esters),
  `LabTimingTest.kt` (t½ analytique), doc §7.2/§7.3 (asset historique,
  cutoff = 10 × t½ depuis v1.9.0).
 - Règle anti-#59 ré-appliquée : labels de modèle via `modelLabelRes` (le
  `when` inline de l'éditeur violait la règle) ; literals « ESE »/« TFS »/
  « WHS » remplacés par `PKModels.*` (ChartScreen/CurveChart) ;
  `scheduler2` supprimé (le scheduler de l'écran existe déjà).
 ## [1.9.4] — 2026-09-19 (versionCode 41)
 ### Ajouté — les presets du modèle ESE couvrent ses 6 esters injectables
 - **Remontée** : depuis l'ajout du modèle source Estrannaise (v1.9.0), les
  presets de création n'offraient toujours que EV/EU/EEn — « les presets
  n'ont pas été mis à jour lors de l'ajout du modèle source pour ESE ».
 - **Presets (`PKPresets.kt`, 25 entrées)** : 3 presets ESE ajoutés au
  même niveau que les autres — EC huile (5 mg IM), EB (1 mg IM), EUCS
  undécylate suspension cristalline (10 mg SC, ester exclusif à ce fit).
  Champs Bateman informatifs = t½ terminales des fits (pas utilisés au
  calcul — le dispatch passe par la forme close).
 - **Éditeur (`TreatmentEditorScreen.kt`)** : la liste des esters suit la
  couverture RÉELLE du modèle choisi (`Esters.choicesForModel` — même
  liste que l'override du DoseDialog) : ESE liste ses 6 esters
  injectables directement à la création. Au changement de modèle, si
  l'ester courant sort de la couverture (ex. EUCS + TFS), il rebascule
  sur EV — garde anti « 0 pg/mL ».
 - **Tests** : `PKPresetsTest` (nouveau, 6 tests — miroir
  `tests/presets.test.js` web) : couverture des 6 esters ESE, unicité,
  TFS (7) / WHSAH (6) inchangés, garde « aucun preset injectable hors
  couverture de son modèle », plausibilité des t½ informatives.
  243 tests verts + lint.
 - **Doc** : doublon de la section §7.12 supprimé (collé deux fois).
 ## [1.9.2] — 2026-09-19 (versionCode 40)
 ### Corrigé — le nuage d'incertitude exigeait un traitement STOCKÉ en ESE
 - **Bug remonté** : activer Estrannaise dans le graphique puis le nuage
  n'affichait rien tant qu'aucun traitement n'était **stocké** avec le
  modèle ESE — « la seule méthode trouvée était de mettre un traitement en
  cours sur le modèle ESE, mais ça ne devrait pas être un prérequis ».
 - **Cause** : le filtre du nuage testait le `pkModel` **STOCKÉ** du
  traitement, alors que la courbe ESE affichée redessine toutes les doses
  E2 avec `modelOverride = "ESE"` (peu importe le modèle stocké) — courbe
  et nuage n'utilisaient pas la même définition de « quelles doses sont
  tracées en ESE ».
 - **Fix** : le nuage couvre **toutes les doses E2 à profil injectable dont
  l'ester effectif (override compris) est couvert par le fit Estrannaise**
  — indépendamment du modèle stocké. L'exclusivité ESE reste portée par le
  chip (activable seulement si ESE est affiché). L'oral Bateman reste hors
  nuage (pas d'ester échantillonnable). Les traitements inactifs sont
  inclus (§6.bis : la courbe ESE les trace aussi).
 - 2 tests réécrits (237 au total / 207 sans les données locales) :
  « doses d'un traitement TFS couvertes quand ESE est affiché » (le fix,
  épinglé des deux plateformes) ; oral seul → vide (conservé).
 - Validé émulateur §16.ter sur le profil réel (EEn stocké TFS, ESE
  activé) : nuage visible autour de la courbe ESE, 0 crash.
 ## [1.9.1] — 2026-09-19 (versionCode 39)
 ### Corrigé — le nuage d'incertitude entoure maintenant la courbe Estrannaise calibrée
 - **Bug remonté** : le nuage ne s'activait « que autour du tracé, pas autour
  du modèle Estrannaise » — la courbe ESE affichée est **calibrée**
  (scalePerEster des labs) mais le nuage était tracé **brut** : les deux
  flottaient à des échelles différentes.
 - **Fix** : le nuage reçoit le MÊME `scalePerEster` que la courbe ESE
  (autoByModel ESE) — il entoure désormais la courbe calibrée (Android +
  web en miroir).
 - 1 nouveau test : nuage calibré ×2 = nuage brut ×2 (le nuage suit la
  calibration).
 ### Note — pourquoi le taux affiché a bougé depuis v1.8.2 (+4 pg/mL)
 - v1.8.2 a corrigé l'**arrondi de la médiane de calibration** (troncature
  flottante → arrondi au plus proche) : une échelle dont la médiane brute
  tombait à 0,8999… était tronquée en 0,89 au lieu de 0,90. Avec le modèle
  ESE analytique (v1.9.0) déplaçant ce dernier bit, le piège est devenu
  visible : les échelles auto-calibrées ont bougé d'un cran d'affichage →
  le niveau estimé a monté d'environ 1 % (+4 pg/mL sur ~320).
 - **Le niveau actuel est le CORRIGÉ** (l'arrondi est plus juste que la
  troncature). Le web applique la même règle depuis v1.9.1 (harmonisation
  des niveaux entre plateformes).
 ## [1.9.0] — 2026-09-18 (versionCode 38)
 ### Modèle Estrannaise ANALYTIQUE (abandon de l'ODS) + nuage d'incertitude MCMC
 - **Le modèle ESE n'est plus les tables horaires ODS** : il est désormais la
  **forme close 3C publiée par estrannaise.js** (les sources originelles
  dont l'ODS n'était que l'échantillonnage horaire) — fidélité épinglée :
  **RMS 0,00** vs les tables sur 0→200 j, écart de pic ≤ 0,1 %.
 - **Décision** (utilisatrice) : « tous les modèles ont maintenant leurs
  sources originelles — on abandonne complètement les liens avec le fichier
  ODS ». Concrètement : plus aucune lecture des tables au runtime
  (`concentrationOfDose` dispatche ESE → forme close ; `cutoffHours` ESE →
  10 × t½ terminale analytique ; l'asset `pk_profiles.json` quitte l'APK,
  −550 Ko, et ne sert plus qu'aux tests de fidélité).
 - **6 esters injectables couverts** (EV, EU, EEn, EC, EB + **EUCS**,
  undécylate suspension cristalline, exclusif à ce fit) — l'ancien ESE
  n'en couvrait que 3. TFS reste à 7 (liste explicite : EUCS n'a pas de
  V3C TFS), WHSAH à 6.
 - **NUAGE D'INCERTITUDE (exclusif ESE)** : Estrannaise publie le posterior
  MCMC de ses paramètres (313 échantillons/ester, asset ≈ 48 Ko) — chip
  `Nuage` (off par défaut, activable à volonté, actif SEULEMENT si ESE est
  affiché, coupure automatique si ESE est éteint) → nuage diffus de 32
  courbes du posterior montrant la plage d'imprécision du modèle, comme
  sur le site estrannaise. Dessiné en alpha faible sous les courbes, hors
  échelles/labels/extrema.
 - t½ terminale ESE désormais **analytique** (ln2/min(k1,k2,k3)) — la
  recommandation de prise de sang n'estime plus la t½ par pente de table.
 - **11 nouveaux tests** (234 au total / 204 sans les données locales) :
  fidélité (RMS, pics ±0,2 %), cas dégénérés (taux égaux → limites sans
  NaN), MCMC 313 × 6, nuage (32 courbes à dispersion réelle, fenêtre,
  exclusivité ESE, gardes), choicesForModel ESE=6, t½ analytique.
 - **Porté web** (web v1.9.0, versions sync) : `estrannaise-models.js` +
  `estrannaise-cloud.js` miroirs, nuage canvas, fetch MCMC au démarrage
  (l'ODS web quitte aussi le runtime), 11 tests miroirs + E2E nuage.
 - Validé émulateur §16.ter (APK release, seed réel v1.7.0) : courbe ESE
  analytique affichée, chips Extend/Cloud présents, recommandation
  de prise de sang fonctionnelle, 0 crash.
 ## [1.8.2] — 2026-09-17 (versionCode 37)
 ### Maintenance — performance du moteur + fraîcheur de l'interface
 Aucune nouvelle fonctionnalité : session d'audit complet (code + doc), avec
 les optimisations et corrections sûres qui en sont sorties.
 ### Performance du moteur PK
 - `e2At`/`computeCurve` : `cutoffHours` et les paramètres Bateman
  (bisection 50 itérations) ne sont plus recalculés à chaque (point ×
  dose × traitement) — pré-calculés par traitement, et Bateman devient
  **paresseux** (inutile pour les traitements à profil). Le chemin le plus
  chaud (tracé labs : ~720 points × N × D appels de cutoff par refresh)
  s'allège d'un facteur P × T. Doses pré-groupées par traitement (fin des
  scans complets). **Résultat identique** (ordre de sommation préservé —
  223 tests verts inchangés).
 - `AppLog` : purge du buffer sans recopie à chaque ligne loggée.
 - `ChangelogHelper` : Regex précompilées (dialog « Nouveautés »).
 - `CurveChart` : SimpleDateFormat créé hors boucle de dessin.
 ### Corrigé — fraîcheur de l'interface
 - **Accueil** : éditer un scaleFactor ou le modèle T rafraîchit la courbe
  immédiatement (clés du producteur incomplètes — l'ancien trio attendait
  le tick de 60 s).
 - **Graphiques** : éditer la VALEUR d'une analyse rafraîchit les courbes
  (la clé n'était que le NOMBRE d'analyses).
 ### Maintenance — code & documentation
 - Code mort supprimé (Repository/DAO sans appelants, `currentLevel`,
  variable et scheduler dupliqués), imports morts/redondants nettoyés,
  médiane de calibration factorisée (4 copies → 1 helper),
  qualifications raccourcies, en-têtes/KDoc obsolètes mis à jour.
 - Documentation : ~35 corrections (compteurs de tests obsolètes, TOC et
  ancres réparées, inventaire des suites de tests à jour et fusionné,
  titres CHANGELOG doublés supprimés, versions « à jour v1.2.0 » /
  « Gradle 8.9 » / « API 34 » corrigées, fautes).
 ## [1.8.1] — 2026-09-17 (versionCode 36)
 ### Corrigé — la stabilisation ignorait les changements récents (dose/ester/intervalle)
@ -675,6 +224,8 @@ les optimisations et corrections sûres qui en sont sorties.
 ## [1.4.9] — 2026-09-07 (versionCode 29)
 ## [1.4.9] — 2026-09-07 (versionCode 29)
 ### Corrigé
 - **La calibration tombait à ×2,21 (auto ET manuelle) sur un traitement
  basculé sous un autre modèle** (#61, remontée : « le bouton Calibrer avec
@ -682,7 +233,7 @@ les optimisations et corrections sûres qui en sont sorties.
  diagnostic par reproduction sur données réelles — l'export contient une
  dose EEn de test logguée en **janvier** ; les labs de janvier-mars
  tombaient 15–76 j après cette dose, quand la prédiction WHSAH est
-  RÉSIDUELLE (184 → 1 pg/mL) → ratios aberrants (3,3 / 15,9 / 89,6 / 383 / 391)
+  RÉSIDUELLE (184 → 1 pg/mL) → ratios aberrants (3,3 / 15,9 / 89,6 / 383)
  → la MÉDIANE tombait à ×2,21, **dans les deux pipelines** (manuel ET
  auto — même défaut de frontière). FIX : **garde de significativité**
  (`labIsSignificant`) — un lab ne calibre que si la prédiction reste
@ -702,6 +253,8 @@ les optimisations et corrections sûres qui en sont sorties.
 ## [1.4.8] — 2026-09-07 (versionCode 28)
 ## [1.4.8] — 2026-09-07 (versionCode 28)
 ### Corrigé
 - **La calibration automatique était fausse pour les modèles autres que le
  modèle stocké du traitement** (#60, remontée : « la calibration auto sur
--- a/docs/DEVELOPPEMENT.md
+++ b/docs/DEVELOPPEMENT.md
--- a/docs/GUIDE_INSTALLATION.md
+++ b/docs/GUIDE_INSTALLATION.md
@ -45,9 +45,8 @@ installer — pas besoin d'Android Studio ni de faire un build :
 1. Android Studio → **Open** → sélectionne le dossier `~/projects/HormoneTrack`
 2. Laisse le **Gradle Sync** se terminer (première fois : téléchargements, 5–15 min)
   - La barre du bas affiche la progression ; attends « Gradle sync finished ».
-3. (v1.9.0) Le modèle Estrannaise est **analytique** : l'ancienne table
+3. Vérifie que l'asset est bien présent :
-   `pk_profiles.json` n'est plus embarquée dans l'APK (elle ne sert qu'aux
+   `app/src/main/assets/pk_profiles.json` (profils Estrannaise / Transfem Science extraits de ton `Estrogen.ods`).
   tests de fidélité, dans `app/src/test/assets/`).
 ## 3. Préparer ton téléphone
@ -88,10 +87,7 @@ Les notifications de l'app remontent automatiquement sur la montre via **Huawei
 ## 6. Premiers pas dans l'app
-1. **Traitements → +** → choisis un preset (ex : *Injection EV —
+1. **Traitements → +** → choisis un preset (ex : *Injection EV — Estrannaise*)
   Estrannaise*). Le modèle Estrannaise propose ses 6 esters injectables
   (EV, EU, EEn, EC huile, EB, EUCS suspension cristalline) ; le menu
   déroulant Ester liste toujours les esters couverts par le modèle choisi.
   - Tu as changé d'ester ? Crée (ou garde) le traitement de l'ancien ester et
     passe-le **inactif** (switch « Actif ») : il disparaît de la saisie et de tes
     rappels, mais **son historique reste simulé et calibré** sur les graphiques —
@ -105,11 +101,7 @@ Les notifications de l'app remontent automatiquement sur la montre via **Huawei
   - Ester (EV / EU / EEn) + modèle (Estrannaise / Transfem Science) = les courbes du `.ods`
   - Pour gel/patch/oral : paramètres Bateman (temps au pic, demi-vie, biodispo)
 2. **Doses → +** → logue tes injections passées
-   - L'accueil liste **toutes les prochaines doses** (v1.9.6) : une ligne
+   - L'accueil affiche la **prochaine dose en jours** quand elle est à plus de 24 h
     par traitement, triées par prochaine prise (la plus proche en premier,
     en gras) — une prise quotidienne ne masque plus le rappel de
     l'injection hebdomadaire. Affichage en **jours** quand la prochaine
     prise est à plus de 24 h
     (ex. « 5 j 2 h · sam. 6 18:00 »), en heures/minutes sinon
   - La carte « Niveau actuel » compare ton taux estimé **à il y a 6 h**
     (flèche ↗/↘) — autour d'un ester lent comme l'énanthate, cette variation
@ -130,7 +122,7 @@ Les notifications de l'app remontent automatiquement sur la montre via **Huawei
   - **Supprimer** : la corbeille retire la prise entière (E2 + T ensemble)
   - Choisis bien l'unité : elle est convertie automatiquement pour l'affichage et la
     calibration (E2 en pg/mL ; T en ng/mL, ng/dL, ng/L, nmol/L)
-   - **Prochaine prise de sang (suggestion, v1.8.0 ; v1.8.1 : aussi sur l'Accueil)** : si ton traitement E2
+   - **Prochaine prise de sang (suggestion, v1.8.0)** : si ton traitement E2
     injectable actif a une **Posologie**, la page te suggère quand faire la
     prochaine analyse — **au creux estimé, juste avant l'injection suivante**
     (moment le plus comparable), au premier creux où ton ester est stabilisé
@ -165,10 +157,7 @@ Les notifications de l'app remontent automatiquement sur la montre via **Huawei
 ## 7. Les modèles mathématiques
- **Estrannaise (v1.9.0 : analytique)** : forme close 3C publiée par
+- **Estrannaise** : tables horaires issues de ta feuille `Estrogen.ods` (table « Models »)
  estrannaise.js — les anciennes tables du tableur en étaient
  l'échantillonnage (fidélité vérifiée à l'identique) ; 6 esters injectables
  couverts (EV, EU, EEn, EC, EB + EUCS en suspension cristalline)
 - **Transfem Science** (v1.4.0) : la méta-analyse officielle à 3 compartiments
  ([article](https://transfemscience.org/articles/injectable-e2-meta-analysis/),
  [simulateur](https://transfemscience.org/misc/injectable-e2-simulator/)) —
@ -225,12 +214,6 @@ Pics de référence (dose unique de 5 mg, IM) :
 - **Fuseau horaire du graphique** (v1.4.5) : Paramètres → « Fuseau horaire du
  graphique » — les jours s'alignent sur minuit du fuseau choisi (vide = celui
  du téléphone)
 - **Nuage d'incertitude (v1.9.0, exclusif ESE)** : chip `Nuage` (actif
  seulement quand Estrannaise est affiché) → nuage diffus de courbes du
  posterior MCMC d'Estrannaise montrant la plage d'imprécision du modèle
  (comme sur le site estrannaise). v1.9.2 : il couvre toutes les doses E2
  injectables quand ESE est affiché — aucun traitement n'a besoin d'être
  stocké en ESE
 - **Unités sur les axes** (v1.7.0) : l'axe gauche affiche « pg/mL » (E2) et
  l'axe droit « ng/mL » (T, avec le toggle T) au sommet des colonnes de
  labels — plus besoin de deviner l'unité des nombres
@ -265,7 +248,7 @@ Pics de référence (dose unique de 5 mg, IM) :
 | Problème | Solution |
 |----------|----------|
-| « SDK not found » au sync | Android Studio → Settings → Languages & Frameworks → Android SDK → vérifier/installer la plateforme 37 (le build AGP peut la télécharger automatiquement) |
+| « SDK not found » au sync | Android Studio → Settings → Languages & Frameworks → Android SDK → installer API 34 |
 | Pas de téléphone détecté | Réactive le Débogage USB, change de câble (données, pas charge seule) |
 | Notif absente sur la montre | Huawei Santé → Notifications → autorise l'app ; redémarre la montre |
 | Rappels en retard | Paramètres → « Accorder les alarmes exactes » + désactive l'optimisation de batterie pour l'app |
--- a/scripts/make-release-keystore.sh
+++ b/scripts/make-release-keystore.sh
@ -1,68 +0,0 @@
 #!/usr/bin/env bash
 # Génération du KEYSTORE de signature RELEASE + keystore.properties (v1.9.8).
 #
 # Les deux fichiers sont écrits à la RACINE du dépôt et sont GITIGNORÉS
 # (.gitignore) : ne JAMAIS les committer — le keystore et ses mots de passe
 # sont l'identité de l'app (une fuite = n'importe qui peut publier un APK qui
 # se met à jour par-dessus le tien).
 #
 # Usage :
 #   scripts/make-release-keystore.sh
 #
 # Après génération, `./gradlew assembleRelease` signe automatiquement avec ce
 # keystore (app/build.gradle.kts détecte keystore.properties).
 #
 # ⚠️ MIGRATION sur le téléphone (signature différente de la clé debug) :
 #   1. Paramètres → Sauvegarde → Exporter (JSON) — OU auto-backup existant ;
 #   2. désinstaller l'app (debug-signée) ;
 #   3. installer l'APK release signé par le nouveau keystore ;
 #   4. Paramètres → Sauvegarde → Importer.
 # La base Room n'est PAS convertible entre signatures : seul le JSON voyage.
 set -euo pipefail
 cd "$(dirname "$0")/.."
 KEYSTORE_FILE="release.keystore"
 PROPERTIES_FILE="keystore.properties"
 if [[ -f "$PROPERTIES_FILE" || -f "$KEYSTORE_FILE" ]]; then
 	echo "ERREUR : $PROPERTIES_FILE et/ou $KEYSTORE_FILE existent déjà." >&2
 	echo "Supprime-les d'abord si tu veux vraiment les régénérer (une régénération" >&2
 	echo "= perte de la capacité de mettre à jour les installs existantes)." >&2
 	exit 1
 fi
 read -r -p "Mot de passe du keystore (>= 6 caractères) : " -s STORE_PASS
 echo
 read -r -p "Confirmation : " -s STORE_PASS_CONFIRM
 echo
 if [[ "$STORE_PASS" != "$STORE_PASS_CONFIRM" || ${#STORE_PASS} -lt 6 ]]; then
 	echo "ERREUR : les mots de passe ne correspondent pas ou font moins de 6 caractères." >&2
 	exit 1
 fi
 # keyPassword = storePassword ici (un seul secret à retenir) ; keytool exige >= 6 car.
 keytool -genkeypair \
 	-keystore "$KEYSTORE_FILE" \
 	-alias hormonetrack \
 	-keyalg RSA -keysize 4096 -validity 10000 \
 	-storepass "$STORE_PASS" \
 	-keypass "$STORE_PASS" \
 	-dname "CN=HormoneTrack, OU=HormoneTrack, O=HormoneTrack"
 chmod 600 "$KEYSTORE_FILE"
 cat >"$PROPERTIES_FILE" <<EOF
 # Signature release de HormoneTrack — GITIGNORÉ, ne jamais committer.
 storeFile=$KEYSTORE_FILE
 storePassword=$STORE_PASS
 keyAlias=hormonetrack
 keyPassword=$STORE_PASS
 EOF
 chmod 600 "$PROPERTIES_FILE"
 echo
 echo "OK : $KEYSTORE_FILE + $PROPERTIES_FILE créés (gitignorés)."
 echo "Prochaine build : ./gradlew assembleRelease  (signée avec ce keystore)"
 echo "⚠️ Sur le téléphone : exporter le JSON AVANT d'installer (signature changée)"
 echo "   → cf docs/DEVELOPPEMENT.md §16.quater pour la migration pas à pas."