sprint46: A.III stratification — vue HTML + détecteur narratif (clôture A.III)

Suite directe du Sprint 45 (couche backend). La vue stratifiée est
désormais rendue dans le rapport et un détecteur signale
automatiquement les corpus hétérogènes.

Nouveau picarones/report/stratification_render.py
- build_stratified_ranking_html : un <details> natif (collapsible
sans JS) par strate avec tableau moteur × (médiane, moyenne, docs).
Cellule médiane colorée par gradient vert (faible CER) → rouge
(élevé). Premier <details> ouvert par défaut. Bandeau
d'avertissement en tête si corpus_homogeneity fourni.
- Rendu strictement server-side, pas de JavaScript, déterministe.
- Anti-injection : noms de moteurs et de strates passés à html.escape.

Câblage rapport
- _build_report_data expose available_strata, stratified_ranking,
corpus_homogeneity au top-level.
- ReportGenerator.generate calcule le bloc HTML et le passe au
template view_ranking.html qui l'insère après le tableau principal
uniquement si stratification disponible.

Détecteur narratif
- Nouveau FactType.STRATIFICATION_RECOMMENDED (priority 45 — entre
STRATUM_WINNER 40 et STRATUM_COLLAPSE 50).
- detect_stratification_recommended lit corpus_homogeneity et émet
un Fact quand le gap inter-strate du leader dépasse 5 points
(HIGH au-delà de 10 points, MEDIUM sinon).
- Templates FR/EN sans nombres en dur (vérifié).
- L'arbitre marque {GLOBAL_LEADER_CER, STRATIFICATION_RECOMMENDED}
comme paire complémentaire (les deux phrases peuvent cohabiter).
- _FALLBACK_TYPE_ORDER mis à jour pour insérer STRATIFICATION_RECOMMENDED
à sa position canonique (après STRATUM_WINNER).

i18n : +8 clés FR/EN pour la vue stratifiée
(stratification_caption, stratification_description, *_label,
stratification_gap_summary).

Tests : +38 dans test_sprint46_stratification_html.py couvrant le
rendu (un <details> par strate, métriques, premier ouvert), le
bandeau d'hétérogénéité, le masquage adaptatif (4 cas),
l'anti-injection (engine et stratum avec balises HTML), les seuils
du détecteur (4 cas), la traçabilité anti-hallucination FR + EN,
l'absence de chiffres en dur dans les templates, l'intégration
ReportGenerator FR + EN, et la complétude i18n.
Suite complète : 1826 → 1864 passed, 2 skipped, 0 failed.

A.III (stratification) clôturée bout-en-bout : couche backend
(Sprint 45) + vue HTML + détecteur narratif (Sprint 46).

CHANGELOG.md

@@ -16,6 +16,47 @@ La numérotation de version suit [Semantic Versioning](https://semver.org/lang/f
 
 ### Ajouté
 
+- **Sprint 46 — A.III stratification par `script_type` : vue HTML +
+  détecteur narratif (clôture A.III)**. Suite directe du Sprint 45
+  (couche backend). La vue stratifiée est désormais rendue dans le
+  rapport et un détecteur signale automatiquement les corpus
+  hétérogènes.
+  - Nouveau module `picarones/report/stratification_render.py` :
+    `build_stratified_ranking_html` rend un `<details>` natif
+    (collapsible sans JS) par strate avec tableau moteur × (médiane,
+    moyenne, docs). Cellule médiane colorée par gradient vert (faible
+    CER) → rouge (élevé). Premier `<details>` ouvert par défaut pour
+    donner le contexte. Bandeau d'avertissement en tête si
+    `corpus_homogeneity` fourni (écart inter-strate du leader).
+  - `_build_report_data` expose `available_strata`,
+    `stratified_ranking`, `corpus_homogeneity` au top-level. Le bloc
+    HTML est passé au template `view_ranking.html` qui l'insère après
+    le tableau principal **uniquement si stratification disponible**
+    (rapport adaptatif).
+  - Nouveau `FactType.STRATIFICATION_RECOMMENDED` (priority 45,
+    importance MEDIUM ou HIGH selon le gap) avec détecteur
+    `detect_stratification_recommended` qui lit `corpus_homogeneity`
+    et émet un Fact quand le gap inter-strate du leader dépasse
+    5 points de CER (HIGH au-delà de 10 points). Templates FR/EN
+    sans nombres en dur.
+  - L'arbitre marque la paire `{GLOBAL_LEADER_CER,
+    STRATIFICATION_RECOMMENDED}` comme **complémentaire** : la
+    recommandation peut cohabiter avec la phrase du leader pour
+    nuancer.
+  - +8 clés i18n FR/EN pour la vue stratifiée
+    (`stratification_caption`, `stratification_description`,
+    `stratification_*_label`, `stratification_gap_summary`).
+  - Anti-injection HTML via `html.escape` sur les noms de moteurs et
+    les noms de strates.
+  - +38 tests dans `test_sprint46_stratification_html.py` couvrant
+    le rendu (un `<details>` par strate, métriques visibles, premier
+    ouvert), le bandeau d'hétérogénéité, le masquage adaptatif (4
+    cas), l'anti-injection (engine et stratum avec balises HTML),
+    les seuils du détecteur (4 cas), la traçabilité
+    anti-hallucination FR + EN, l'absence de chiffres en dur dans
+    les templates, l'intégration `ReportGenerator` FR + EN, et la
+    complétude i18n.
+
 - **Sprint 45 — A.III stratification par `script_type` : couche
   d'agrégation backend.** Première brique de la « plus haute valeur
   ajoutée transversale » du plan d'évolution. Le rapport peut
@@ -438,17 +479,16 @@ La numérotation de version suit [Semantic Versioning](https://semver.org/lang/f
 
 ### Tests
 
-- 1478 → 1826 tests (+17 Sprint 32, +23 Sprint 33, +21 Sprint 34,
+- 1478 → 1864 tests (+17 Sprint 32, +23 Sprint 33, +21 Sprint 34,
   +27 Sprint 35, +22 Sprint 36, +42 Sprint 37, +19 Sprint 38,
   +32 Sprint 39, +16 Sprint 40, +38 Sprint 41, +17 Sprint 42,
-  +43 Sprint 43, +15 Sprint 44, +16 Sprint 45). Aucune régression.
-  **Phase 0 close ; Étape 2 du plan d'évolution : inter-moteurs
-  (A.II.1.c), NER (A.II.1.a) et calibration (A.II.1.b) livrés
-  bout-en-bout calcul → runner → HTML ; A.I.2 médiane par défaut
-  livré (Sprint 44) ; A.III stratification — couche backend livrée
-  (Sprint 45), vue HTML à venir. Reste l'adaptation effective des
-  engines pour exposer leurs confidences natives (un sprint par
-  adapter).**
+  +43 Sprint 43, +15 Sprint 44, +16 Sprint 45, +38 Sprint 46).
+  Aucune régression. **Phase 0 close ; Étape 2 du plan d'évolution :
+  inter-moteurs (A.II.1.c), NER (A.II.1.a), calibration (A.II.1.b)
+  et stratification (A.III) livrés bout-en-bout calcul → runner →
+  HTML ; A.I.2 médiane par défaut livré (Sprint 44). Reste
+  l'adaptation effective des engines pour exposer leurs confidences
+  natives (un sprint par adapter).**
 
 ---
 

CLAUDE.md

@@ -207,6 +207,7 @@ AZURE_DOC_INTEL_KEY=...
 | 33 | **Sprint 2 du plan d'évolution 2026 — Phase 0.2 : interface module générique**. Nouveau module `picarones/core/modules.py` avec l'enum `ArtifactType` (IMAGE, TEXT, ALTO, PAGE, ENTITIES, READING_ORDER) et la classe abstraite `BaseModule` qui déclare `input_types`/`output_types`, `execution_mode` (`"io"`/`"cpu"`), une méthode `process(dict[ArtifactType, Any]) → dict[ArtifactType, Any]`, et des helpers `validate_inputs`/`validate_outputs`. `BaseOCREngine` (`picarones/engines/base.py`) hérite désormais de `BaseModule` avec `input_types=(IMAGE,)` et `output_types=(TEXT,)` ; sa nouvelle méthode `process` wrappe l'API historique `run()`. Aucun adaptateur OCR existant n'est touché — `test_engines.py` passe à 20/20 sans modification. +23 tests dans `test_sprint33_module_interface.py` (contrat, validation, MockModule TEXT→ALTO démonstratif comme demandé par le plan, délégation `BaseOCREngine.process → run`, cohérence ArtifactType/GTLevel). **Verrou levé** : un même runner peut maintenant exécuter un OCR (image→texte), un mappeur VLM→ALTO, un rewriter ALTO→ALTO, un module NER (texte→entités), etc. — fondation directe pour l'axe B du plan. |
 | 34 | **Sprint 3 du plan d'évolution 2026 — Phase 0.3 : registre typé de métriques (clôture Phase 0)**. Nouveaux modules `picarones/core/metric_registry.py` (`MetricSpec`, `@register_metric`, `select_metrics`, `compute_at_junction`) et `picarones/core/builtin_metrics.py` qui enregistre `cer`, `wer`, `mer`, `wil` sur `(TEXT, TEXT)` plus un stub `text_preservation_after_reconstruction` sur `(TEXT, ALTO)` comme preuve de concept de jonction hétérogène. **Approche strictement additive** : ni `metrics.py` ni `compute_metrics` ne sont modifiés, le rapport HTML reste identique octet par octet. La sélection par signature de types est exacte (pas de coercion). +21 tests dans `test_sprint34_metric_registry.py`, dont une parité numérique CER/WER/MER/WIL avec `compute_metrics` legacy à 1e-9 près sur 4 paires de textes. **Verrou levé** : le runner d'une pipeline composée peut maintenant calculer automatiquement la métrique adéquate à chaque jonction de son DAG selon les types d'artefacts produits/attendus — fondation directe pour la métrique d'absorption d'erreur (acte B.3) et toutes les métriques structurelles à venir (Layout F1, reading order F1, NER). |
 | 35 | **Sprint 4 du plan d'évolution 2026 — Étape 2 / axe A : métriques inter-moteurs (couche de calcul)**. Nouveau module `picarones/core/inter_engine.py` qui répond à deux questions distinctes mais liées : *(a) à quel point les moteurs font-ils des erreurs de natures différentes ?* via `kl_divergence`, `jensen_shannon_divergence` (symétrique, bornée `[0, 1]`), et `taxonomy_divergence_matrix` qui construit la matrice triangulaire inter-moteurs ; *(b) quel CER serait atteignable si on combinait les moteurs ?* via `oracle_token_recall` (proxy bag-of-words, borne supérieure du recall atteignable), `complementarity_gap` (oracle vs meilleur moteur seul, gap absolu/relatif), et `pairwise_disagreement_rate`. Fonctions pures, sans I/O ni intégration runner — la couche de calcul est livrée indépendamment, le câblage narratif (`ENSEMBLE_OPPORTUNITY`) et HTML (matrice de divergence, badge oracle) suit au Sprint 36. +27 tests couvrant les invariants mathématiques (KL ≥ 0, KL(p,p) = 0, JS symétrique et bornée, oracle ≥ best_single, multiplicité respectée), les cas concrets (deux moteurs spécialisés sortent comme candidats ensemble, complémentarité parfaite atteint oracle = 1), et les garde-fous (référence vide, hypothèses vides, métrique inconnue). |
+| 46 | **Sprint 15 du plan d'évolution 2026 — Étape 2 / axe A.III : vue HTML stratifiée + détecteur narratif (clôture A.III)**. Suite directe du Sprint 45 (couche backend). Nouveau module `picarones/report/stratification_render.py` : `build_stratified_ranking_html` rend un `<details>` natif (collapsible sans JS) par strate avec tableau moteur × (médiane, moyenne, docs), cellule médiane colorée par gradient vert→rouge, premier `<details>` ouvert par défaut, bandeau d'avertissement en tête si `corpus_homogeneity` fourni. `_build_report_data` expose `available_strata`/`stratified_ranking`/`corpus_homogeneity` au top-level ; `view_ranking.html` insère le bloc après le tableau principal **uniquement si stratification disponible**. Nouveau `FactType.STRATIFICATION_RECOMMENDED` (priority 45, importance MEDIUM ou HIGH selon le gap) + détecteur `detect_stratification_recommended` (seuil 5 points / 10 points de CER inter-strate). Templates FR/EN sans nombres en dur. L'arbitre marque la paire `{GLOBAL_LEADER_CER, STRATIFICATION_RECOMMENDED}` comme complémentaire. +8 clés i18n FR/EN. Anti-injection HTML via `html.escape`. +38 tests dans `test_sprint46_stratification_html.py`. **Verrou levé** : A.III (stratification) est désormais livré bout-en-bout — couche backend (Sprint 45) + vue HTML + détecteur narratif (Sprint 46) ; le lecteur du rapport voit immédiatement quand le corpus est hétérogène et est invité à consulter la vue stratifiée. |
 | 45 | **Sprint 14 du plan d'évolution 2026 — Étape 2 / axe A.III : stratification par `script_type` (couche backend)**. Première brique de la « plus haute valeur ajoutée transversale » du plan. `BenchmarkResult.doc_strata: Optional[dict[str, str]]` ajouté (map `{doc_id: script_type}` capturée par le runner avant `compact()` qui efface `image_quality`). Trois nouvelles méthodes : `available_strata()` (liste triée des strates distinctes, ignore les vides) ; `stratified_ranking()` qui retourne `{stratum: [ranking_entry]}` avec mean/median CER recalculés par strate, tri par médiane (Sprint 44), inclut les moteurs absents d'une strate sous forme d'entrée dégénérée (mean/median = None) ; `corpus_homogeneity()` qui pour le moteur leader global retourne l'écart inter-strate de la médiane CER et la paire min/max — base du futur avertissement « ce corpus est hétérogène ». `as_dict()` expose les nouveaux champs quand renseignés (rétrocompat stricte sinon). +16 tests dans `test_sprint45_stratification.py` couvrant champ, available_strata, stratified_ranking (1 entrée/moteur/strate, métriques per-strate, tri par médiane, moteurs absents), corpus_homogeneity, sérialisation, et un **test propriété réaliste** : le leader global peut perdre sur une strate (Tesseract domine globalement mais Pero gagne sur le manuscrit). **Verrou levé** : la couche d'agrégation par strate est en place ; la vue HTML stratifiée + toggle UI viendront dans un sprint dédié, et un détecteur narratif `STRATIFICATION_RECOMMENDED` peut maintenant lire `corpus_homogeneity()` pour suggérer la vue stratifiée. |
 | 44 | **Sprint 13 du plan d'évolution 2026 — Étape 2 / axe A.I.2 : tri par médiane par défaut + détecteur d'asymétrie**. Réponse à la critique structurelle 2 du plan : sur les corpus patrimoniaux, la moyenne est tirée par quelques documents catastrophiques et masque les performances réelles. `EngineReport.median_cer` ajouté (lit `aggregated_metrics["cer"]["median"]`). `BenchmarkResult.ranking()` inclut désormais `median_cer` dans chaque entrée et **trie par médiane CER croissante par défaut** (fallback sur `mean_cer` si médiane absente). Nouveau `FactType.MEDIAN_MEAN_GAP_WARNING` + détecteur `detect_median_mean_gap_warning` (priority 140) : émet un Fact quand `\|mean - median\| / median > 30 %` pour le moteur leader, importance HIGH si gap relatif ≥ 100 % (sinon MEDIUM). Garde-fou : ne déclenche pas si médiane nulle. Templates FR/EN sans nombres en dur (vérifié). L'arbitre marque la paire `{GLOBAL_LEADER_CER, MEDIAN_MEAN_GAP_WARNING}` comme **complémentaire** : les deux phrases peuvent coexister dans la synthèse pour nuancer le leader. +15 tests dans `test_sprint44_median_default.py` (propriété, tri sur cas asymétrique réaliste, fallback, déclenchement détecteur sur 4 cas dégénérés, importance, traçabilité anti-hallucination FR + EN, intégration build_synthesis). **Verrou levé** : la critique « le rapport classe sur la moyenne alors que les distributions patrimoniales sont asymétriques » est résolue ; le lecteur voit immédiatement le moteur le plus représentatif et est averti quand l'écart médiane/moyenne est suspect. |
 | 43 | **Sprint 12 du plan d'évolution 2026 — Étape 2 / axe A.II.1.b : vue HTML calibration (clôture A.II.1.b côté rapport)**. Nouveau module `picarones/report/calibration_render.py` : `build_calibration_summary_html` rend un tableau résumé (ECE, MCE, accuracy moyenne, confidence moyenne, n_predictions, doc_count) avec cellule ECE colorée par gradient vert (bien calibré) → rouge (mal calibré) ; `build_reliability_diagram_svg` rend un SVG par moteur avec barres d'accuracy par bin, ligne reliant les points `(avg_confidence, accuracy)`, diagonale en pointillé pour la calibration parfaite, axes annotés (graduations 0/0.5/1) ; `build_reliability_diagrams_grid_html` génère une grille auto-fit (un SVG par moteur ayant `aggregated_calibration`). Rendu strictement server-side, pas de JS, déterministe. `_build_report_data` expose `aggregated_calibration` par moteur ; `ReportGenerator.generate` calcule les blocs et les passe à `view_analyses.html` qui les affiche **uniquement si ≥ 1 moteur a un `aggregated_calibration`** (rapport adaptatif). Anti-injection HTML via `html.escape`. +13 clés i18n FR/EN. +43 tests dans `test_sprint43_calibration_html.py` couvrant le rendu (résumé, SVG, grille), le masquage adaptatif, l'anti-injection, l'intégration FR + EN, la complétude i18n. **Verrou levé** : A.II.1.b (calibration) est désormais visible bout-en-bout dans le rapport — il manque uniquement l'adaptation effective des engines pour exposer leurs confidences natives (un sprint par adapter : Tesseract `image_to_data`, Pero `PageLayout`, Mistral `confidence`, Google Vision `Word.confidence`, Azure DI). |
@@ -263,7 +264,7 @@ au template `_narrative_summary.html` (placé entre `_header.html` et `_critical
 ## Contexte développement
 
 - **Environnement** : GitHub Codespaces (`/workspaces/Picarones`), Python 3.12
-- **Tests** : 1826 passed, 2 skipped (Sprints 32-34 = Phase 0 close ; Sprints 35-37 = inter-moteurs livrés bout-en-bout ; Sprints 38+40+41 = NER livré bout-en-bout ; Sprints 39+42+43 = calibration livrée bout-en-bout côté rapport ; Sprint 44 = médiane par défaut ; Sprint 45 = stratification couche backend)
+- **Tests** : 1864 passed, 2 skipped (Sprints 32-34 = Phase 0 close ; Sprints 35-37 = inter-moteurs livrés bout-en-bout ; Sprints 38+40+41 = NER livré bout-en-bout ; Sprints 39+42+43 = calibration livrée bout-en-bout côté rapport ; Sprint 44 = médiane par défaut ; Sprints 45+46 = stratification A.III livrée bout-en-bout)
 - **Plan d'évolution actif** : [`docs/roadmap/evolution-2026.md`](docs/roadmap/evolution-2026.md)
 - **Branche active** : `claude/analyze-project-evolution-KOA56`
 - **Transcript de la conversation de développement** :

picarones/core/narrative/arbiter.py

@@ -55,6 +55,10 @@ _FALLBACK_TYPE_ORDER: tuple[FactType, ...] = (
     FactType.STATISTICAL_TIE,
     FactType.SIGNIFICANT_GAP,
     FactType.STRATUM_WINNER,
+    # Sprint 46 — priority 45, juste après STRATUM_WINNER (40),
+    # avant STRATUM_COLLAPSE (50). La recommandation de stratification
+    # nuance directement les autres faits par strate.
+    FactType.STRATIFICATION_RECOMMENDED,
     FactType.STRATUM_COLLAPSE,
     FactType.ERROR_PROFILE_OUTLIER,
     FactType.LLM_HALLUCINATION_FLAG,
@@ -90,6 +94,10 @@ _COMPLEMENTARY_PAIRS: frozenset[frozenset[FactType]] = frozenset({
     # Sprint 44 — l'avertissement d'asymétrie nuance le leader
     # plutôt que de le doubler : on veut les deux phrases ensemble.
     frozenset({FactType.GLOBAL_LEADER_CER, FactType.MEDIAN_MEAN_GAP_WARNING}),
+    # Sprint 46 — la recommandation de stratification est un méta-conseil
+    # qui s'ajoute au leader sans le contredire ; les deux peuvent
+    # cohabiter même quand ils concernent le même moteur.
+    frozenset({FactType.GLOBAL_LEADER_CER, FactType.STRATIFICATION_RECOMMENDED}),
 })
 
 

picarones/core/narrative/detectors.py

@@ -776,6 +776,70 @@ def detect_median_mean_gap_warning(benchmark_data: dict) -> list[Fact]:
     )]
 
 
+# ---------------------------------------------------------------------------
+# Détecteur Sprint 46 — stratification recommandée (corpus hétérogène)
+# ---------------------------------------------------------------------------
+
+@register_detector(
+    FactType.STRATIFICATION_RECOMMENDED,
+    priority=45,  # juste après STRATUM_WINNER (40), avant STRATUM_COLLAPSE (50)
+    importance=FactImportance.HIGH,
+)
+def detect_stratification_recommended(benchmark_data: dict) -> list[Fact]:
+    """Avertit quand le corpus est hétérogène et que la vue stratifiée
+    apporte un éclairage qualitativement différent du classement global.
+
+    Critère : ``corpus_homogeneity.max_inter_strata_gap > 5 points`` de
+    CER médian sur le moteur leader.  Au-delà de 10 points, importance
+    ``HIGH`` (situation très hétérogène où le seul classement global
+    serait trompeur).
+
+    Lit ``benchmark_data["corpus_homogeneity"]`` exposé par
+    ``BenchmarkResult.as_dict()`` (Sprint 45).
+    """
+    homog = benchmark_data.get("corpus_homogeneity")
+    if not homog:
+        return []
+
+    gap = homog.get("max_inter_strata_gap")
+    if gap is None:
+        return []
+
+    gap = float(gap)
+    if gap < 0.05:
+        return []  # 5 points de CER : seuil de pertinence éditoriale
+
+    leader = str(homog.get("leader") or "")
+    n_strata = int(homog.get("n_strata") or 0)
+    pair = homog.get("leader_max_gap_strata") or ["", ""]
+    if len(pair) < 2:
+        return []
+    min_strat, max_strat = str(pair[0]), str(pair[1])
+
+    leader_per_stratum = homog.get("leader_per_stratum_median") or {}
+    min_med = float(leader_per_stratum.get(min_strat, 0.0))
+    max_med = float(leader_per_stratum.get(max_strat, 0.0))
+
+    importance = (
+        FactImportance.HIGH if gap >= 0.10 else FactImportance.MEDIUM
+    )
+
+    return [Fact(
+        type=FactType.STRATIFICATION_RECOMMENDED,
+        importance=importance,
+        payload={
+            "leader": leader,
+            "n_strata": n_strata,
+            "gap_pct": round(gap * 100, 1),
+            "min_stratum": min_strat,
+            "max_stratum": max_strat,
+            "min_stratum_cer_pct": round(min_med * 100, 2),
+            "max_stratum_cer_pct": round(max_med * 100, 2),
+        },
+        engines_involved=(leader,) if leader else (),
+    )]
+
+
 # ---------------------------------------------------------------------------
 # Détecteur Sprint 36 — opportunité d'ensemble (complémentarité)
 # ---------------------------------------------------------------------------

picarones/core/narrative/facts.py

@@ -70,6 +70,12 @@ class FactType(str, Enum):
     et masque les performances réelles. La médiane (utilisée pour le tri
     par défaut depuis Sprint 44) est plus représentative."""
 
+    STRATIFICATION_RECOMMENDED = "stratification_recommended"
+    """Le corpus est hétérogène du point de vue script_type : le moteur
+    leader varie fortement selon la strate. Le lecteur doit consulter
+    la vue stratifiée plutôt que de se fier au seul classement global
+    (Sprint 46)."""
+
 
 class FactImportance(int, Enum):
     """Score d'importance d'un fait — décide l'ordre et la sélection."""

picarones/core/narrative/templates/en.yaml

@@ -68,3 +68,11 @@ median_mean_gap_warning: >-
   {relative_gap_pct} %). The mean is pulled by a few catastrophic
   documents — the median (now used for default ranking) is more
   representative.
+
+stratification_recommended: >-
+  Heterogeneous corpus ({n_strata} strata): {leader} performs very
+  differently depending on document type — median CER
+  {min_stratum_cer_pct} % on "{min_stratum}" vs
+  {max_stratum_cer_pct} % on "{max_stratum}", a gap of {gap_pct}
+  points. The global ranking hides this disparity; consult the
+  stratified view.

picarones/core/narrative/templates/fr.yaml

@@ -72,3 +72,11 @@ median_mean_gap_warning: >-
   {relative_gap_pct} %). La moyenne est tirée par quelques documents
   catastrophiques — la médiane (utilisée pour le tri par défaut) est
   plus représentative.
+
+stratification_recommended: >-
+  Corpus hétérogène ({n_strata} strates) : {leader} performe très
+  différemment selon le type de document — médiane CER
+  {min_stratum_cer_pct} % sur « {min_stratum} » contre
+  {max_stratum_cer_pct} % sur « {max_stratum} », soit {gap_pct} points
+  d'écart. Le classement global masque cette disparité ; consulter la
+  vue stratifiée.

picarones/report/generator.py

@@ -572,6 +572,10 @@ def _build_report_data(benchmark: BenchmarkResult, images_b64: dict[str, str]) -
         # Sprint 36 — analyse inter-moteurs (divergence taxonomique +
         # complémentarité / oracle).  ``None`` si moins de 2 moteurs.
         "inter_engine_analysis": benchmark.inter_engine_analysis,
+        # Sprint 45-46 — stratification par script_type
+        "available_strata": benchmark.available_strata(),
+        "stratified_ranking": benchmark.stratified_ranking() or None,
+        "corpus_homogeneity": benchmark.corpus_homogeneity(),
     }
 
 
@@ -757,6 +761,18 @@ class ReportGenerator:
             labels=labels,
         )
 
+        # Sprint 46 — section stratifiée (tableau par strate). Vide si
+        # aucune strate disponible.
+        from picarones.report.stratification_render import (
+            build_stratified_ranking_html,
+        )
+        stratified_ranking_html = build_stratified_ranking_html(
+            report_data.get("stratified_ranking"),
+            report_data.get("available_strata"),
+            report_data.get("corpus_homogeneity"),
+            labels=labels,
+        )
+
         env = _build_jinja_env()
         template = env.get_template("base.html.j2")
         html = template.render(
@@ -776,6 +792,7 @@ class ReportGenerator:
             ner_per_category_html=ner_per_category_html,
             calibration_summary_html=calibration_summary_html,
             reliability_diagrams_html=reliability_diagrams_html,
+            stratified_ranking_html=stratified_ranking_html,
         )
 
         output_path.write_text(html, encoding="utf-8")

picarones/report/i18n/en.json

@@ -75,6 +75,14 @@
   "h_characters": "Character Analysis",
   "h_clusters": "Frequent Error Clusters",
   "h_correlation": "Metric Correlation Matrix",
+  "stratification_caption": "Ranking by stratum (script_type)",
+  "stratification_description": "The global table ranks engines across the whole corpus. When the corpus is heterogeneous, some engines dominate on one document type and fail on another — the stratified view reveals this.",
+  "stratification_median_label": "Median CER",
+  "stratification_mean_label": "Mean CER",
+  "stratification_docs_label": "Documents",
+  "stratification_no_data_label": "—",
+  "stratification_n_docs_label": "documents",
+  "stratification_gap_summary": "Leader {leader} inter-stratum gap: {gap_pct} median CER points (between \"{min_stratum}\" and \"{max_stratum}\").",
   "h_calibration": "Engine calibration",
   "calibration_note": "ECE (Expected Calibration Error): weighted mean of |confidence − accuracy| gaps per bin. The lower the ECE, the more honest the engine is about its reliability — the diagonal in the diagram is perfect calibration. A high ECE means you cannot rely on confidence scores to focus human proofreading.",
   "calibration_summary_caption": "Engine calibration (ECE, MCE)",

picarones/report/i18n/fr.json

@@ -75,6 +75,14 @@
   "h_characters": "Analyse des caractères",
   "h_clusters": "Clustering des patterns d'erreurs",
   "h_correlation": "Matrice de corrélation entre métriques",
+  "stratification_caption": "Classement par strate (script_type)",
+  "stratification_description": "Le tableau global classe sur l'ensemble du corpus. Quand le corpus est hétérogène, certains moteurs dominent sur un type de document et perdent sur un autre — la vue stratifiée le révèle.",
+  "stratification_median_label": "Médiane CER",
+  "stratification_mean_label": "Moyenne CER",
+  "stratification_docs_label": "Documents",
+  "stratification_no_data_label": "—",
+  "stratification_n_docs_label": "documents",
+  "stratification_gap_summary": "Écart inter-strate du leader {leader} : {gap_pct} points de CER médian (entre « {min_stratum} » et « {max_stratum} »).",
   "h_calibration": "Calibration des moteurs",
   "calibration_note": "ECE (Expected Calibration Error) : moyenne pondérée des écarts |confiance − précision| par bin. Plus l'ECE est bas, plus le moteur est honnête sur sa fiabilité — la diagonale du diagramme représente la calibration parfaite. Un ECE élevé signale qu'on ne peut pas se fier au score de confiance pour cibler la relecture humaine.",
   "calibration_summary_caption": "Calibration des moteurs (ECE, MCE)",

picarones/report/stratification_render.py

@@ -0,0 +1,202 @@
+"""Rendu HTML server-side de la vue stratifiée par script_type (Sprint 46).
+
+Suite directe du Sprint 45 (couche backend). Affiche le classement
+moteur par strate sous forme de tableaux pliables (HTML ``<details>``,
+pas de JavaScript).
+
+- ``build_stratified_ranking_html`` — un ``<details>`` par strate avec
+  tableau ``moteur, médiane, moyenne, docs``. Cellule médiane colorée
+  par gradient vert (faible CER) → rouge (CER élevé).
+
+Principe : cohérent avec ``inter_engine_render``, ``ner_render`` et
+``calibration_render`` — server-side, déterministe, pas de JS.
+Masquage adaptatif : la fonction retourne ``""`` si aucune strate
+n'est disponible (``available_strata`` vide).
+
+Anti-injection : tous les noms de moteurs et de strates sont passés
+à ``html.escape``.
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+
+def _color_for_cer(cer: float) -> str:
+    """Gradient vert (faible CER) → rouge (CER élevé), saturé à 0.30."""
+    f = max(0.0, min(1.0, cer / 0.30))
+    if f <= 0.5:
+        ratio = f / 0.5
+        r = int(130 + (240 - 130) * ratio)
+        g = int(200 + (220 - 200) * ratio)
+        b = int(130 + (130 - 130) * ratio)
+    else:
+        ratio = (f - 0.5) / 0.5
+        r = int(240 + (220 - 240) * ratio)
+        g = int(220 + (100 - 220) * ratio)
+        b = int(130 + (100 - 130) * ratio)
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+def _format_cer(cer: Optional[float]) -> str:
+    if cer is None:
+        return "—"
+    return f"{cer * 100:.2f} %"
+
+
+def build_stratified_ranking_html(
+    stratified_ranking: Optional[dict],
+    available_strata: Optional[list],
+    homogeneity: Optional[dict] = None,
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit la section HTML stratifiée.
+
+    Parameters
+    ----------
+    stratified_ranking:
+        ``{stratum: [ranking_entry, …]}`` produit par
+        ``BenchmarkResult.stratified_ranking()``.
+    available_strata:
+        Liste triée des strates (``BenchmarkResult.available_strata()``).
+    homogeneity:
+        Dict produit par ``BenchmarkResult.corpus_homogeneity()`` si
+        disponible — sert à afficher l'écart inter-strate du leader
+        en tête de section.
+    labels:
+        i18n.  Fallback FR si manquantes.
+
+    Returns
+    -------
+    str
+        HTML ``<div>...</div>`` ou ``""`` si stratification absente.
+    """
+    if not stratified_ranking or not available_strata:
+        return ""
+
+    labels = labels or {}
+    caption = labels.get(
+        "stratification_caption",
+        "Classement par strate (script_type)",
+    )
+    description = labels.get(
+        "stratification_description",
+        "Le tableau global classe sur l'ensemble du corpus. Quand le "
+        "corpus est hétérogène, certains moteurs dominent sur un type "
+        "de document et perdent sur un autre — la vue stratifiée le "
+        "révèle.",
+    )
+    engine_label = labels.get("col_engine", "Moteur")
+    median_label = labels.get("stratification_median_label", "Médiane CER")
+    mean_label = labels.get("stratification_mean_label", "Moyenne CER")
+    docs_label = labels.get("stratification_docs_label", "Documents")
+    no_data = labels.get("stratification_no_data_label", "—")
+    n_docs_in_stratum_label = labels.get(
+        "stratification_n_docs_label", "documents",
+    )
+
+    parts: list[str] = []
+    parts.append('<div class="stratified-ranking" style="margin-top:1.2rem">')
+    parts.append(
+        f'<h3 style="margin:0 0 .3rem 0">{_e(caption)}</h3>'
+    )
+    parts.append(
+        f'<div style="font-size:.78rem;color:var(--text-muted);'
+        f'margin-bottom:.6rem">{_e(description)}</div>'
+    )
+
+    # Bandeau d'hétérogénéité si disponible
+    if homogeneity and homogeneity.get("max_inter_strata_gap") is not None:
+        gap = float(homogeneity["max_inter_strata_gap"])
+        leader = str(homogeneity.get("leader") or "")
+        min_strat, max_strat = homogeneity.get(
+            "leader_max_gap_strata", ["", ""]
+        )
+        gap_template = labels.get(
+            "stratification_gap_summary",
+            "Écart inter-strate du leader {leader} : {gap_pct} points "
+            "de CER médian (entre « {min_stratum} » et « {max_stratum} »).",
+        )
+        gap_text = gap_template.format(
+            leader=leader,
+            gap_pct=f"{gap * 100:.1f}",
+            min_stratum=min_strat,
+            max_stratum=max_strat,
+        )
+        # gap_text contient déjà des données utilisateur — on n'échappe pas
+        # le template lui-même (i18n connue), mais on n'injecte pas non plus
+        # de markup. _e() est appliqué aux variables via format() côté template.
+        parts.append(
+            f'<div style="font-size:.82rem;background:#fff8e1;'
+            f'border-left:3px solid #f9a825;padding:.4rem .6rem;'
+            f'margin-bottom:.6rem">⚠ {_e(gap_text)}</div>'
+        )
+
+    # Une ``<details>`` par strate (premier ouvert pour donner le contexte)
+    for i, stratum in enumerate(available_strata):
+        entries = stratified_ranking.get(stratum) or []
+        n_docs_total = max((int(e.get("documents") or 0) for e in entries), default=0)
+        open_attr = " open" if i == 0 else ""
+        parts.append(
+            f'<details class="stratum-block"{open_attr} '
+            f'style="margin-bottom:.4rem;border:1px solid var(--border);'
+            f'border-radius:6px;padding:.4rem .6rem">'
+        )
+        parts.append(
+            f'<summary style="cursor:pointer;font-weight:600">'
+            f'{_e(stratum)} '
+            f'<span style="font-weight:400;color:var(--text-muted);'
+            f'font-size:.85rem">({n_docs_total} {_e(n_docs_in_stratum_label)})</span>'
+            f'</summary>'
+        )
+        parts.append(
+            '<table style="border-collapse:collapse;font-size:.85rem;'
+            'margin-top:.4rem;width:100%">'
+        )
+        parts.append("<thead><tr>")
+        for hdr in (engine_label, median_label, mean_label, docs_label):
+            parts.append(
+                f'<th style="padding:.3rem .5rem;text-align:left;'
+                f'border-bottom:1px solid var(--border);font-weight:600">'
+                f'{_e(hdr)}</th>'
+            )
+        parts.append("</tr></thead><tbody>")
+        for entry in entries:
+            engine = str(entry.get("engine", ""))
+            median = entry.get("median_cer")
+            mean = entry.get("mean_cer")
+            n_docs = int(entry.get("documents") or 0)
+            bg = _color_for_cer(float(median)) if median is not None else "#f4f4f4"
+            parts.append("<tr>")
+            parts.append(
+                f'<td style="padding:.3rem .5rem;font-weight:600">'
+                f'{_e(engine)}</td>'
+            )
+            parts.append(
+                f'<td style="padding:.3rem .5rem;background:{bg};'
+                f'font-variant-numeric:tabular-nums">'
+                f'{_e(_format_cer(median)) if median is not None else _e(no_data)}'
+                f'</td>'
+            )
+            parts.append(
+                f'<td style="padding:.3rem .5rem;'
+                f'font-variant-numeric:tabular-nums">'
+                f'{_e(_format_cer(mean)) if mean is not None else _e(no_data)}'
+                f'</td>'
+            )
+            parts.append(
+                f'<td style="padding:.3rem .5rem;'
+                f'font-variant-numeric:tabular-nums">{n_docs}</td>'
+            )
+            parts.append("</tr>")
+        parts.append("</tbody></table>")
+        parts.append("</details>")
+
+    parts.append("</div>")
+    return "".join(parts)
+
+
+__all__ = [
+    "build_stratified_ranking_html",
+]

picarones/report/templates/view_ranking.html

@@ -43,6 +43,12 @@
         <span class="legend-dot" style="background:#dc2626"></span>&gt; 30 %
       </div>
     </div>
+
+    <!-- Sprint 46 — vue stratifiée par script_type (rapport adaptatif :
+         section omise quand aucune strate n'est disponible) -->
+    {% if stratified_ranking_html %}
+    {{ stratified_ranking_html }}
+    {% endif %}
   </div>
 
   <!-- ── Métriques robustes ────────────────────────────────────── -->

tests/test_sprint46_stratification_html.py

@@ -0,0 +1,366 @@
+"""Tests Sprint 46 — vue HTML stratifiée + détecteur narratif.
+
+Couvre :
+
+1. ``build_stratified_ranking_html`` rend un ``<details>`` par strate
+   avec tableau moteur × (médiane, moyenne, docs).
+2. Bandeau d'hétérogénéité affiché si ``corpus_homogeneity`` fourni.
+3. **Masquage adaptatif** : retourne ``""`` si pas de strates.
+4. **Anti-injection** : noms de strates et de moteurs avec balises
+   HTML sont échappés.
+5. **Détecteur ``STRATIFICATION_RECOMMENDED``** :
+   - se déclenche au-delà de 5 points d'écart inter-strate
+   - importance HIGH au-delà de 10 points, MEDIUM sinon
+   - ne se déclenche pas sans corpus_homogeneity
+6. **Anti-hallucination** : chaque nombre rendu est dans le payload.
+7. **Intégration ReportGenerator** : la section apparaît dans
+   ``view_ranking`` quand ``doc_strata`` est peuplé.
+8. **i18n FR/EN** : clés présentes pour la vue + le template narratif.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+import pytest
+
+from picarones.core.metrics import MetricsResult
+from picarones.core.narrative.detectors import detect_stratification_recommended
+from picarones.core.narrative.facts import FactImportance, FactType
+from picarones.core.narrative.renderer import extract_numbers, render_fact
+from picarones.core.results import DocumentResult
+from picarones.report.generator import ReportGenerator
+from picarones.report.stratification_render import build_stratified_ranking_html
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Helpers
+# ──────────────────────────────────────────────────────────────────────────
+
+
+_SAMPLE_STRAT = {
+    "gothique": [
+        {"engine": "pero", "median_cer": 0.05, "mean_cer": 0.07, "documents": 10},
+        {"engine": "tess", "median_cer": 0.20, "mean_cer": 0.22, "documents": 10},
+    ],
+    "imprimé": [
+        {"engine": "tess", "median_cer": 0.02, "mean_cer": 0.03, "documents": 10},
+        {"engine": "pero", "median_cer": 0.05, "mean_cer": 0.06, "documents": 10},
+    ],
+}
+_SAMPLE_STRATA = ["gothique", "imprimé"]
+_SAMPLE_HOMOG = {
+    "leader": "tess",
+    "n_strata": 2,
+    "max_inter_strata_gap": 0.18,
+    "leader_max_gap_strata": ["imprimé", "gothique"],
+    "leader_per_stratum_median": {"imprimé": 0.02, "gothique": 0.20},
+}
+
+
+def _make_dr(doc_id: str, cer: float) -> DocumentResult:
+    return DocumentResult(
+        doc_id=doc_id, image_path=f"/tmp/{doc_id}.png",
+        ground_truth="x", hypothesis="x",
+        metrics=MetricsResult(
+            cer=cer, cer_nfc=cer, cer_caseless=cer,
+            wer=cer, wer_normalized=cer, mer=cer, wil=cer,
+            reference_length=1, hypothesis_length=1,
+        ),
+        duration_seconds=0.1,
+    )
+
+
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 1-2. build_stratified_ranking_html
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestRendering:
+    def test_renders_one_details_per_stratum(self) -> None:
+        html = build_stratified_ranking_html(
+            _SAMPLE_STRAT, _SAMPLE_STRATA, _SAMPLE_HOMOG,
+        )
+        assert html.count("<details") == 2
+        # Premier ouvert
+        assert "<details" in html and " open" in html
+
+    def test_includes_engine_metrics(self) -> None:
+        html = build_stratified_ranking_html(
+            _SAMPLE_STRAT, _SAMPLE_STRATA, _SAMPLE_HOMOG,
+        )
+        # Médianes en pourcentage
+        assert "5.00 %" in html   # pero gothique
+        assert "20.00 %" in html  # tess gothique
+        assert "2.00 %" in html   # tess imprimé
+
+    def test_homogeneity_banner_present(self) -> None:
+        html = build_stratified_ranking_html(
+            _SAMPLE_STRAT, _SAMPLE_STRATA, _SAMPLE_HOMOG,
+        )
+        # Le bandeau d'avertissement doit apparaître
+        assert "tess" in html
+        assert "18.0" in html
+
+    def test_no_homogeneity_no_banner(self) -> None:
+        html = build_stratified_ranking_html(
+            _SAMPLE_STRAT, _SAMPLE_STRATA, homogeneity=None,
+        )
+        # Pas de bandeau jaune
+        assert "#fff8e1" not in html
+
+    def test_uses_i18n_labels(self) -> None:
+        labels = {
+            "stratification_caption": "CUSTOM_CAPTION",
+            "stratification_median_label": "MED",
+            "stratification_mean_label": "MEAN",
+        }
+        html = build_stratified_ranking_html(
+            _SAMPLE_STRAT, _SAMPLE_STRATA, None, labels=labels,
+        )
+        assert "CUSTOM_CAPTION" in html
+        assert "MED" in html
+        assert "MEAN" in html
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 3. Masquage adaptatif
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestAdaptiveMasking:
+    def test_empty_when_no_stratified_ranking(self) -> None:
+        assert build_stratified_ranking_html(None, ["S1"]) == ""
+        assert build_stratified_ranking_html({}, ["S1"]) == ""
+
+    def test_empty_when_no_available_strata(self) -> None:
+        assert build_stratified_ranking_html(_SAMPLE_STRAT, None) == ""
+        assert build_stratified_ranking_html(_SAMPLE_STRAT, []) == ""
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 4. Anti-injection
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestAntiInjection:
+    def test_engine_name_escaped(self) -> None:
+        bad_strat = {
+            "S1": [
+                {"engine": "<script>alert(1)</script>",
+                 "median_cer": 0.1, "mean_cer": 0.1, "documents": 1},
+            ],
+        }
+        html = build_stratified_ranking_html(bad_strat, ["S1"])
+        assert "<script>" not in html
+        assert "&lt;script&gt;" in html
+
+    def test_stratum_name_escaped(self) -> None:
+        bad_strat = {
+            "<img src=x>": [
+                {"engine": "a", "median_cer": 0.1,
+                 "mean_cer": 0.1, "documents": 1},
+            ],
+        }
+        html = build_stratified_ranking_html(bad_strat, ["<img src=x>"])
+        assert "<img src=x>" not in html
+        assert "&lt;img" in html
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 5. Détecteur STRATIFICATION_RECOMMENDED
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def _data(gap: float, **overrides) -> dict:
+    homog = {
+        "leader": "tess", "n_strata": 2,
+        "max_inter_strata_gap": gap,
+        "leader_max_gap_strata": ["S1", "S2"],
+        "leader_per_stratum_median": {"S1": 0.02, "S2": 0.02 + gap},
+    }
+    homog.update(overrides)
+    return {"corpus_homogeneity": homog}
+
+
+class TestStratificationDetector:
+    def test_no_fact_below_threshold(self) -> None:
+        # 4 points → en dessous du seuil 5 points
+        assert detect_stratification_recommended(_data(0.04)) == []
+
+    def test_emits_fact_above_threshold(self) -> None:
+        facts = detect_stratification_recommended(_data(0.07))
+        assert len(facts) == 1
+        assert facts[0].type is FactType.STRATIFICATION_RECOMMENDED
+
+    def test_medium_below_10pts(self) -> None:
+        facts = detect_stratification_recommended(_data(0.07))
+        assert facts[0].importance is FactImportance.MEDIUM
+
+    def test_high_above_10pts(self) -> None:
+        facts = detect_stratification_recommended(_data(0.18))
+        assert facts[0].importance is FactImportance.HIGH
+
+    def test_no_homogeneity_no_fact(self) -> None:
+        assert detect_stratification_recommended({}) == []
+        assert detect_stratification_recommended({"corpus_homogeneity": None}) == []
+
+    def test_payload_carries_strata_and_cers(self) -> None:
+        facts = detect_stratification_recommended(_data(0.18))
+        p = facts[0].payload
+        assert p["leader"] == "tess"
+        assert p["n_strata"] == 2
+        assert p["min_stratum"] == "S1"
+        assert p["max_stratum"] == "S2"
+        assert p["gap_pct"] == 18.0
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 6. Anti-hallucination
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestTraceability:
+    @pytest.mark.parametrize("lang", ["fr", "en"])
+    def test_every_rendered_number_is_in_payload(self, lang: str) -> None:
+        # On utilise des noms de strates sans chiffres (la traçabilité
+        # exige que tout chiffre rendu vienne du payload, mais les
+        # noms de strates côté GT peuvent légitimement contenir des
+        # chiffres ; pour le test on isole les nombres "métriques").
+        data = {"corpus_homogeneity": {
+            "leader": "tess", "n_strata": 2,
+            "max_inter_strata_gap": 0.18,
+            "leader_max_gap_strata": ["impr", "goth"],
+            "leader_per_stratum_median": {"impr": 0.02, "goth": 0.20},
+        }}
+        facts = detect_stratification_recommended(data)
+        sentence = render_fact(facts[0], lang)
+
+        payload_nums: set[str] = set()
+        for v in facts[0].payload.values():
+            if isinstance(v, (int, float)):
+                payload_nums.add(str(v))
+                if isinstance(v, float) and v.is_integer():
+                    payload_nums.add(str(int(v)))
+            elif isinstance(v, str):
+                # Capture aussi les chiffres présents dans les chaînes
+                # du payload (ex. noms de strates contenant un nombre)
+                for match in re.findall(r"\d+(?:[.,]\d+)?", v):
+                    payload_nums.add(match.replace(",", "."))
+
+        for num in extract_numbers(sentence):
+            normalized = num.replace(",", ".")
+            assert normalized in payload_nums, (
+                f"Nombre {normalized!r} non traçable au payload "
+                f"{facts[0].payload!r}"
+            )
+
+    def test_template_has_no_hardcoded_numbers(self) -> None:
+        from picarones.core.narrative.renderer import _load_templates
+        for lang in ("fr", "en"):
+            tpl = _load_templates(lang).get("stratification_recommended", "")
+            assert tpl, f"Template absent pour {lang}"
+            cleaned = re.sub(r"\{[^}]+\}", "", tpl)
+            digits = re.findall(r"\d", cleaned)
+            assert not digits, f"Template {lang} contient des chiffres en dur : {digits}"
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 7. Intégration ReportGenerator
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestReportIntegration:
+    def test_section_absent_without_strata(self, tmp_path: Path) -> None:
+        from picarones.fixtures import generate_sample_benchmark
+        bench = generate_sample_benchmark()
+        bench.doc_strata = None  # force absence
+        out = tmp_path / "report.html"
+        ReportGenerator(bench).generate(out)
+        html = out.read_text(encoding="utf-8")
+        assert "stratified-ranking" not in html
+
+    def test_section_present_with_strata(self, tmp_path: Path) -> None:
+        from picarones.fixtures import generate_sample_benchmark
+        bench = generate_sample_benchmark()
+        # La fixture peuple image_quality.script_type ; on extrait
+        # manuellement comme le ferait le runner.
+        strata_map: dict[str, str] = {}
+        for r in bench.engine_reports:
+            for dr in r.document_results:
+                if dr.image_quality and dr.image_quality.get("script_type"):
+                    strata_map.setdefault(dr.doc_id, dr.image_quality["script_type"])
+        bench.doc_strata = strata_map
+
+        out = tmp_path / "report.html"
+        ReportGenerator(bench).generate(out)
+        html = out.read_text(encoding="utf-8")
+        assert "stratified-ranking" in html
+        # Au moins un <details> rendu
+        assert "<details" in html
+
+    def test_french_locale_uses_french_labels(self, tmp_path: Path) -> None:
+        from picarones.fixtures import generate_sample_benchmark
+        bench = generate_sample_benchmark()
+        strata_map = {}
+        for r in bench.engine_reports:
+            for dr in r.document_results:
+                if dr.image_quality and dr.image_quality.get("script_type"):
+                    strata_map.setdefault(dr.doc_id, dr.image_quality["script_type"])
+        bench.doc_strata = strata_map
+
+        out = tmp_path / "report_fr.html"
+        ReportGenerator(bench, lang="fr").generate(out)
+        html = out.read_text(encoding="utf-8")
+        assert "Classement par strate" in html
+        assert "Médiane CER" in html
+
+    def test_english_locale_uses_english_labels(self, tmp_path: Path) -> None:
+        from picarones.fixtures import generate_sample_benchmark
+        bench = generate_sample_benchmark()
+        strata_map = {}
+        for r in bench.engine_reports:
+            for dr in r.document_results:
+                if dr.image_quality and dr.image_quality.get("script_type"):
+                    strata_map.setdefault(dr.doc_id, dr.image_quality["script_type"])
+        bench.doc_strata = strata_map
+
+        out = tmp_path / "report_en.html"
+        ReportGenerator(bench, lang="en").generate(out)
+        html = out.read_text(encoding="utf-8")
+        assert "Ranking by stratum" in html
+        assert "Median CER" in html
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 8. i18n FR/EN
+# ──────────────────────────────────────────────────────────────────────────
+
+
+REQUIRED_KEYS = (
+    "stratification_caption",
+    "stratification_description",
+    "stratification_median_label",
+    "stratification_mean_label",
+    "stratification_docs_label",
+    "stratification_no_data_label",
+    "stratification_n_docs_label",
+    "stratification_gap_summary",
+)
+
+
+class TestI18NCompleteness:
+    @pytest.mark.parametrize("lang", ["fr", "en"])
+    @pytest.mark.parametrize("key", REQUIRED_KEYS)
+    def test_key_present(self, lang: str, key: str) -> None:
+        path = (
+            Path(__file__).parent.parent
+            / "picarones" / "report" / "i18n" / f"{lang}.json"
+        )
+        data = json.loads(path.read_text(encoding="utf-8"))
+        assert key in data, f"Clé {key!r} manquante dans {lang}.json"
+        assert data[key].strip(), f"Clé {key!r} vide dans {lang}.json"