sprint82: section "Leviers d'amélioration" (A.I.9 bout-en-bout)

Le moteur narratif Sprint 19 décrit ce qui s'est passé ; ce sprint
identifie sur quelle dimension un effort éditorial pourrait porter,
purement factuel jamais prescriptif.

- picarones/core/levers.py : dataclass Lever + LeverImportance
+ registre via @register_lever + 5 détecteurs
(dominant_recoverable_class, pareto_concentration,
complementarity_observation, lexical_modernization_observation,
robustness_projection_observation).
- picarones/report/levers_render.py : cards server-side, anti-injection,
adaptive masking, garde-fou anti-hallucination identique au moteur
narratif (chaque chiffre rendu provient du payload).
- 18 clés i18n FR/EN (levers_*).
- 40 tests : modèle, 5 détecteurs individuels, pipeline,
rendu HTML, anti-hallucination FR+EN, complétude i18n.

Tests : 2761 passed, 2 skipped.

https://claude.ai/code/session_01RusTQYcSfXqTsbFNvwmCV7

CHANGELOG.md

@@ -16,6 +16,44 @@ La numérotation de version suit [Semantic Versioning](https://semver.org/lang/f
 
 ### Ajouté
 
+- **Sprint 82 — A.I.9 : section « Leviers d'amélioration »
+  (couche calcul + cards HTML).**  Le moteur narratif
+  (Sprint 19) émet des `Fact` qui décrivent **ce qui s'est
+  passé** dans le benchmark.  Ce sprint répond à une question
+  complémentaire : *« sur quelle dimension le bénéfice attendu
+  d'une amélioration serait-il le plus visible ? »*.  Approche
+  strictement **non-prescriptive** : aucune recommandation
+  *« faites X »*, uniquement des **observations factuelles**
+  agrégées depuis les modules d'analyse (Sprints 75-81).
+  Nouveau module `picarones/core/levers.py` : dataclass
+  ``Lever(type, importance, payload, engines_involved)``,
+  ``LeverImportance`` (HIGH/MEDIUM/LOW), registre via
+  décorateur ``@register_lever``, helper ``detect_levers`` qui
+  trie par importance décroissante.  **5 détecteurs livrés** :
+  ``dominant_recoverable_class`` (≥30 % d'erreurs récupérables
+  selon la catégorisation Sprint 77), ``pareto_concentration``
+  (top-20 % docs ≥50 % du CER cumulé), ``complementarity_observation``
+  (factuel sur ``inter_engine_analysis.complementarity_gap``,
+  Sprint 35), ``lexical_modernization_observation`` (top-3
+  tokens GT systématiquement modernisés, Sprint 80),
+  ``robustness_projection_observation`` (déficit projeté ≥2
+  points de CER, Sprint 81).  Nouveau module
+  `picarones/report/levers_render.py` : ``build_levers_section_html``
+  rend des **cards** server-side avec étiquette i18n + phrase
+  factuelle + détail compact + niveau d'importance coloré.
+  Adaptive masking : ``""`` si aucun levier exploitable.
+  Anti-injection systématique via ``html.escape``.  Garde-fou
+  anti-hallucination identique au moteur narratif : chaque
+  chiffre rendu est dans le ``payload`` du levier.  +18 clés
+  i18n FR/EN (``levers_*``).  +40 tests dans
+  `test_sprint82_levers.py` (modèle 3, dominant 6, pareto 5,
+  complementarity 4, lexical 4, robustness 4, pipeline 3,
+  rendu 6, anti-hallucination FR+EN 3, complétude i18n 2).
+  **Verrou levé** : le rapport ne se contente plus de décrire
+  *ce qui est* — il propose une lecture compacte des
+  **dimensions où un effort éditorial pourrait porter**, sans
+  jamais imposer un verdict.
+
 - **Sprint 81 — A.I.8 : robustesse synthétique projetée sur le
   corpus réel (couche de calcul).**  Le module
   ``picarones/core/robustness.py`` (Sprint 8) génère des courbes

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). |
+| 82 | **Sprint 51 du plan d'évolution 2026 — A.I.9 : section « Leviers d'amélioration » (couche calcul + cards HTML)**. Le moteur narratif Sprint 19 dit *ce qui s'est passé* ; ce sprint dit *sur quelle dimension un effort éditorial pourrait porter* — purement factuel, jamais prescriptif. Nouveau module `picarones/core/levers.py` : dataclass `Lever(type, importance, payload, engines_involved)`, `LeverImportance` (HIGH=70/MEDIUM=40/LOW=10), registre via décorateur `@register_lever` (parallèle au registre narratif), `detect_levers(benchmark_data)` trie par importance décroissante. **5 détecteurs** : `dominant_recoverable_class` (≥30 % d'erreurs récupérables Sprint 77, HIGH si ≥50 %, top-3 classes), `pareto_concentration` (top-20 % des docs ≥50 % du CER cumulé sur le moteur leader, HIGH si ≥75 %), `complementarity_observation` (factuel sur `inter_engine_analysis.complementarity_gap` Sprint 35, HIGH si rel_gap ≥50 %), `lexical_modernization_observation` (top-3 tokens GT systématiquement modernisés Sprint 80, min_total=3, min_rate=0.50, HIGH si max_rate ≥90 %), `robustness_projection_observation` (déficit projeté ≥2 points de CER Sprint 81, HIGH si ≥5 points, sorted desc). Nouveau module `picarones/report/levers_render.py` : `build_levers_section_html` rend des **cards** server-side (étiquette i18n + phrase factuelle + détail compact + niveau d'importance coloré bleu/orange). Adaptive : `""` si aucun levier exploitable. Anti-injection systématique. Garde-fou anti-hallucination identique au moteur narratif : chaque chiffre rendu est dans le `payload` (test prouve la traçabilité FR+EN sur 3 leviers). +18 clés i18n FR/EN. +40 tests (modèle 3, dominant_recoverable 6, pareto 5, complementarity 4, lexical 4, robustness 4, pipeline 3, rendu 6, anti-hallucination 3, complétude i18n 2). **Verrou levé** : le rapport propose une lecture compacte des dimensions actionnables sans imposer de verdict — *« 65 % des erreurs de Tesseract sont récupérables », « 12 % des docs concentrent 78 % du CER », « top tokens modernisés : maistre, nostre, veoir »* — le chercheur juge selon son workflow. |
 | 81 | **Sprint 50 du plan d'évolution 2026 — A.I.8 : robustesse synthétique projetée sur corpus réel (couche calcul)**. `robustness.py` (Sprint 8) génère des courbes CER vs dégradation synthétique ; `image_quality.py` mesure le bruit/flou réels. Ce sprint projette les caractéristiques réelles sur les courbes pour estimer le déficit attendu. Nouveau module `picarones/core/robustness_projection.py` : `_interpolate_cer(levels, cer_values, target_level)` interpolation linéaire avec clip aux bornes (pas d'extrapolation hasardeuse), filtre cer None ; `_extract_quality_value(quality_dict, degradation_type, custom_mapping)` extrait depuis ImageQualityResult (mapping default noise→noise_level, blur→blur_score, etc.) ; `project_robustness_on_corpus(curves, image_qualities)` retourne `{engine: {deg_type: {n_docs, n_docs_with_data, expected_cer_mean/median, baseline_cer, deficit_vs_baseline, n_docs_above_critical, critical_threshold}}}` ; `aggregate_projection_per_engine` somme les déficits par moteur et identifie le worst_degradation_type (hypothèse d'indépendance documentée). +22 tests (interpolation 7 cas, extraction 4 cas, projection 7 cas, agrégation 4 cas). **Verrou levé** : un bench BnF lit « 30 % de vos documents ont un bruit où Tesseract perd 8 points — déficit attendu 2,4 points » — la courbe de robustesse n'est plus déconnectée du corpus réel. |
 | 80 | **Sprint 49 du plan d'évolution 2026 — A.I.7 : sur-normalisation lexicale (couche calcul + table HTML)**. Le détecteur `llm_hallucination_flag` (Sprint 19) signale via un score agrégé mais ne dit pas **quoi** corriger dans le prompt. Nouveau module `picarones/core/lexical_modernization.py` : `compute_lexical_modernization(reference, hypothesis, stop_list, case_sensitive)` aligne mot-à-mot via `difflib.SequenceMatcher` et accumule par token GT `{n_total, n_modernized, rate_modernized, variants}` ; `aggregate_lexical_modernization` somme corpus-wide ; `top_modernized_tokens(data, n=20, min_total=1)` retourne les N tokens GT les plus modernisés (tri décroissant par taux, tie-break par n_total, filtre anecdotiques via min_total). Stop-list paramétrable (par défaut vide). Suppression GT → variant ∅. Nouveau module `picarones/report/lexical_modernization_render.py` : `build_lexical_modernization_html(data, labels, top_n, min_total)` tableau 4 colonnes (forme GT, variantes OCR top-3, n GT, % modernisé gradient blanc→orange). Adaptive : "" si data None ou aucun modernisé. +6 clés i18n FR/EN. +20 tests (calcul 9 cas dont systématique/préservé/partiel/multi-variants/stop-list/casse/suppression/vide, agrégation 2 cas, top 2 cas, rendu 5 cas dont anti-injection, complétude i18n). **Verrou levé** : le chercheur lit « maistre → maître modernisé dans 100 % des cas » et ajuste son prompt — info exploitable au lieu d'un score agrégé. |
 | 79 | **Sprint 48 du plan d'évolution 2026 — A.I.6 : projection de coût en volume cible (couche de calcul)**. La vue Pareto (Sprint 20) trace CER vs coût mais le coût est par unité (1 000 pages) ; payer 50 € de plus sur 50 pages est trivial, sur 5 millions ça change tout. Nouveau module `picarones/core/cost_projection.py` : `ProjectedCost(engine_key, target_pages, cost_total_eur, co2_total_g, cost_per_1k_pages_eur, co2_per_1k_pages_g, type)`, `project_cost_total/co2_total` linéaire en pages avec `None` si données insuffisantes ou target<0, `project_engine` retourne le ProjectedCost complet, `project_all_engines(engine_costs, target_pages)` projette N moteurs (ValueError si target<0, moteurs sans données conservés avec cost_total=None), `cost_gap_table(projections, baseline)` retourne `{engine: {total, delta_abs, delta_rel}}` vs baseline (KeyError si baseline inconnue, delta_rel=None si baseline=0). +17 tests (calcul 5 cas, CO₂ 2 cas, engine 2 cas, all_engines 3 cas, gap_table 4 cas, **cas réaliste BnF 80 000 pages BMS** Tesseract=3.20€/Pero=0€/Mistral=280€/GPT-4o=600€). **Verrou levé** : couche calcul prête pour câbler le panneau « Avancé » avec champ « Volume cible » qui recalcule Pareto et table coût en valeur totale projetée. UX HTML suivra. |
@@ -299,7 +300,7 @@ au template `_narrative_summary.html` (placé entre `_header.html` et `_critical
 ## Contexte développement
 
 - **Environnement** : GitHub Codespaces (`/workspaces/Picarones`), Python 3.12
-- **Tests** : 2721 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 ; Sprints 47-51 = les 5 adapters OCR exposent leurs confidences natives ; **Étape 2 close** ; Sprints 52-54 = axe A.II.2 (métriques structurelles) couches de calcul intégralement livrées ; Sprints 55-62 = extension philologique livrée bout-en-bout sur trois périodes + numéraux romains transversaux + câblage runner adaptive + vue HTML « Profil philologique » ; Sprints 63-70 = axe B livré bout-en-bout ; Sprints 71-72 = A.I.1 livré bout-en-bout ; Sprints 73-74 = A.I.3 livré bout-en-bout ; Sprints 75-77 = A.I.4 livré bout-en-bout ; Sprint 78 = A.I.5 couche calcul ; Sprint 79 = A.I.6 couche calcul ; Sprint 80 = A.I.7 ; **Sprint 81 = A.I.8 — robustesse projetée sur corpus réel**)
+- **Tests** : 2761 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 ; Sprints 47-51 = les 5 adapters OCR exposent leurs confidences natives ; **Étape 2 close** ; Sprints 52-54 = axe A.II.2 (métriques structurelles) couches de calcul intégralement livrées ; Sprints 55-62 = extension philologique livrée bout-en-bout sur trois périodes + numéraux romains transversaux + câblage runner adaptive + vue HTML « Profil philologique » ; Sprints 63-70 = axe B livré bout-en-bout ; Sprints 71-72 = A.I.1 livré bout-en-bout ; Sprints 73-74 = A.I.3 livré bout-en-bout ; Sprints 75-77 = A.I.4 livré bout-en-bout ; Sprint 78 = A.I.5 couche calcul ; Sprint 79 = A.I.6 couche calcul ; Sprint 80 = A.I.7 ; Sprint 81 = A.I.8 — robustesse projetée sur corpus réel ; **Sprint 82 = A.I.9 — section « Leviers d'amélioration » 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/levers.py

@@ -0,0 +1,561 @@
+"""Section « Leviers d'amélioration » — Sprint 82 (A.I.9).
+
+Sprint 82 — A.I.9 du plan d'évolution 2026.
+
+Pourquoi ce module
+------------------
+Le moteur narratif (Sprint 19) émet des `Fact` qui décrivent **ce
+qui s'est passé** dans le benchmark : qui gagne, qui s'effondre,
+qui est fragile.  Ce sprint répond à une question
+complémentaire : **sur quelle dimension le bénéfice attendu d'une
+amélioration serait-il le plus visible ?**
+
+Pas de prescription
+-------------------
+Picarones est un **outil de recherche**, pas un atelier de
+production.  Le module ne dit jamais *« faites X »* ni
+*« utilisez le moteur Y »* ; il agrège des **observations
+factuelles** déjà calculées dans d'autres modules (Sprints 75-81)
+et les présente comme un récapitulatif compact en bas du rapport.
+Le chercheur lit, juge et arbitre.
+
+Exemples de leviers émis
+------------------------
+- *« 65 % des erreurs de Tesseract sont de classe récupérable
+  (case_error, ligature_error, abbreviation_error) — un
+  post-processing trivial absorberait une partie. »*
+- *« 12 % de vos documents concentrent 78 % du CER total
+  (Pareto-CER). »*
+- *« Le déficit projeté du moteur le plus fragile sur le corpus
+  réel est de 4,2 points de CER (Sprint 81). »*
+- *« Le top-3 des tokens GT systématiquement modernisés est
+  maistre, nostre, veoir (Sprint 80). »*
+
+Structure
+---------
+Module parallèle au registre narratif Sprint 19 : `Lever` est la
+dataclass équivalente à `Fact`, `LeverImportance` reprend la
+sémantique de `FactImportance`, `@register_lever` indexe les
+détecteurs.  Garde-fou anti-hallucination identique : chaque
+nombre rendu doit être présent dans le `payload` du `Lever`.
+
+Les détecteurs lisent **uniquement** des structures déjà
+construites par le pipeline du benchmark — ils ne calculent rien
+de nouveau, ils synthétisent.  C'est pourquoi le module est
+résolument optionnel : si un benchmark n'expose pas
+`taxonomy_aggregated`, `inter_engine_analysis`, `corpus_difficulty`,
+`lexical_modernization` ou `robustness_projection`, le détecteur
+correspondant retourne tout simplement `[]`.
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+from dataclasses import dataclass
+from enum import Enum
+from typing import Callable
+
+logger = logging.getLogger(__name__)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Modèle
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class LeverType(str, Enum):
+    """Types de leviers détectés."""
+
+    DOMINANT_RECOVERABLE_CLASS = "dominant_recoverable_class"
+    """Une part importante des erreurs d'un moteur est dans des classes
+    catégorisées « récupérables » (Sprint 77)."""
+
+    PARETO_CONCENTRATION = "pareto_concentration"
+    """Une fraction minoritaire de documents concentre une fraction
+    majoritaire du CER total — l'inspection ciblée est rentable."""
+
+    COMPLEMENTARITY_OBSERVATION = "complementarity_observation"
+    """Le `complementarity_gap` (Sprint 35) entre l'oracle et le
+    meilleur moteur seul est non négligeable — observation factuelle,
+    aucune recommandation d'ensemble."""
+
+    LEXICAL_MODERNIZATION_OBSERVATION = "lexical_modernization_observation"
+    """Top-N des tokens GT systématiquement modernisés (Sprint 80)."""
+
+    ROBUSTNESS_PROJECTION_OBSERVATION = "robustness_projection_observation"
+    """Déficit projeté global le plus important pour un moteur sur
+    le corpus réel (Sprint 81)."""
+
+
+class LeverImportance(int, Enum):
+    """Importance éditoriale d'un levier."""
+
+    HIGH = 70
+    MEDIUM = 40
+    LOW = 10
+
+
+@dataclass
+class Lever:
+    """Observation factuelle synthétisable en encart « Leviers ».
+
+    Attributes
+    ----------
+    type:
+        Le type de levier (voir `LeverType`).
+    importance:
+        Score qui décide l'ordre d'affichage.
+    payload:
+        Données brutes — **tout chiffre rendu dans le HTML doit
+        provenir d'ici**, jamais d'un calcul du renderer.
+    engines_involved:
+        Noms des moteurs concernés (peut être vide pour un levier
+        corpus-wide).
+    """
+
+    type: LeverType
+    importance: LeverImportance
+    payload: dict
+    engines_involved: tuple[str, ...] = ()
+
+    def as_dict(self) -> dict:
+        return {
+            "type": self.type.value,
+            "importance": int(self.importance),
+            "payload": self.payload,
+            "engines_involved": list(self.engines_involved),
+        }
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Registre
+# ──────────────────────────────────────────────────────────────────────────
+
+
+LeverDetectorFn = Callable[[dict], list[Lever]]
+
+
+@dataclass(frozen=True)
+class LeverDetectorEntry:
+    lever_type: LeverType
+    fn: LeverDetectorFn
+    priority: int
+
+
+_LEVER_REGISTRY: dict[LeverType, LeverDetectorEntry] = {}
+_LEVER_REGISTRY_LOCK = threading.Lock()
+
+
+def register_lever(
+    lever_type: LeverType,
+    *,
+    priority: int,
+) -> Callable[[LeverDetectorFn], LeverDetectorFn]:
+    """Décorateur : enregistre un détecteur de levier.
+
+    Une seule fonction par type — réenregistrer lève `ValueError`.
+    """
+    def _decorator(fn: LeverDetectorFn) -> LeverDetectorFn:
+        with _LEVER_REGISTRY_LOCK:
+            if lever_type in _LEVER_REGISTRY:
+                raise ValueError(
+                    f"Détecteur déjà enregistré pour {lever_type.value!r} : "
+                    f"{_LEVER_REGISTRY[lever_type].fn.__name__}."
+                )
+            _LEVER_REGISTRY[lever_type] = LeverDetectorEntry(
+                lever_type=lever_type, fn=fn, priority=int(priority),
+            )
+        return fn
+    return _decorator
+
+
+def unregister_lever(lever_type: LeverType) -> None:
+    with _LEVER_REGISTRY_LOCK:
+        _LEVER_REGISTRY.pop(lever_type, None)
+
+
+def iter_lever_detectors() -> list[LeverDetectorEntry]:
+    with _LEVER_REGISTRY_LOCK:
+        entries = list(_LEVER_REGISTRY.values())
+    entries.sort(key=lambda e: e.priority)
+    return entries
+
+
+def detect_levers(benchmark_data: dict) -> list[Lever]:
+    """Applique tous les détecteurs enregistrés et trie par importance
+    décroissante puis priorité d'enregistrement croissante."""
+    levers: list[Lever] = []
+    for entry in iter_lever_detectors():
+        try:
+            result = entry.fn(benchmark_data)
+        except Exception as e:
+            logger.warning(
+                "[levers.detector.%s] fonctionnalité dégradée : %s",
+                entry.lever_type.value, e,
+            )
+            continue
+        if result:
+            levers.extend(result)
+    # Tri stable : importance décroissante d'abord
+    levers.sort(key=lambda lv: -int(lv.importance))
+    return levers
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Détecteurs
+# ──────────────────────────────────────────────────────────────────────────
+
+
+# Catégorisation reprise du Sprint 77 (taxonomy_comparison.py).
+# Volontairement dupliquée ici pour ne pas introduire d'import
+# circulaire — la sémantique est gelée.
+_RECOVERABILITY: dict[str, str] = {
+    "case_error":         "recoverable",
+    "ligature_error":     "recoverable",
+    "abbreviation_error": "recoverable",
+    "diacritic_error":    "difficult",
+    "visual_confusion":   "difficult",
+    "hapax":              "difficult",
+    "lacuna":             "irrecoverable",
+    "oov_character":      "irrecoverable",
+    "segmentation_error": "irrecoverable",
+}
+
+
+@register_lever(LeverType.DOMINANT_RECOVERABLE_CLASS, priority=10)
+def detect_dominant_recoverable_class(
+    benchmark_data: dict,
+    *,
+    threshold: float = 0.30,
+) -> list[Lever]:
+    """Émet un levier si ≥ `threshold` des erreurs d'un moteur sont
+    classifiées récupérables (catégorisation Sprint 77).
+
+    Lit `benchmark_data["engines"][i]["aggregated_taxonomy"]` —
+    structure produite par le runner historique. Si absent, retourne
+    [].
+    """
+    engines = benchmark_data.get("engines") or []
+    out: list[Lever] = []
+    for engine in engines:
+        taxonomy = engine.get("aggregated_taxonomy")
+        if not taxonomy:
+            continue
+        # `taxonomy` peut être {class_name: int} ou un dict avec une
+        # sous-clé "counts" — on accepte les deux conventions.
+        counts = taxonomy.get("counts") if isinstance(taxonomy, dict) and "counts" in taxonomy else taxonomy
+        if not isinstance(counts, dict) or not counts:
+            continue
+        try:
+            int_counts = {k: int(v) for k, v in counts.items() if isinstance(v, (int, float))}
+        except (TypeError, ValueError):
+            continue
+        total = sum(int_counts.values())
+        if total <= 0:
+            continue
+        recoverable_total = sum(
+            v for k, v in int_counts.items()
+            if _RECOVERABILITY.get(k) == "recoverable"
+        )
+        share = recoverable_total / total
+        if share < threshold:
+            continue
+        # Classes récupérables non vides triées par count décroissant
+        breakdown = sorted(
+            (
+                (k, v) for k, v in int_counts.items()
+                if _RECOVERABILITY.get(k) == "recoverable" and v > 0
+            ),
+            key=lambda kv: -kv[1],
+        )
+        importance = (
+            LeverImportance.HIGH if share >= 0.50 else LeverImportance.MEDIUM
+        )
+        out.append(Lever(
+            type=LeverType.DOMINANT_RECOVERABLE_CLASS,
+            importance=importance,
+            payload={
+                "engine": engine.get("name") or "?",
+                "share_recoverable": share,
+                "share_recoverable_pct": round(share * 100, 1),
+                "n_recoverable": recoverable_total,
+                "n_total_errors": total,
+                "top_classes": [
+                    {"class": k, "count": v} for k, v in breakdown[:3]
+                ],
+            },
+            engines_involved=(engine.get("name") or "?",),
+        ))
+    return out
+
+
+@register_lever(LeverType.PARETO_CONCENTRATION, priority=20)
+def detect_pareto_concentration(
+    benchmark_data: dict,
+    *,
+    top_share: float = 0.20,
+    cer_share_threshold: float = 0.50,
+) -> list[Lever]:
+    """Émet un levier si une fraction minoritaire de documents
+    (`top_share`) concentre plus de `cer_share_threshold` du CER
+    total cumulé sur le moteur leader.
+
+    Lit `benchmark_data["per_doc_cer"][engine_name]` ou tente de
+    reconstruire depuis `benchmark_data["engines"][...]["per_doc"]`.
+    Si rien d'exploitable, retourne [].
+    """
+    ranking = benchmark_data.get("ranking") or []
+    if not ranking:
+        return []
+    leader = ranking[0]
+    leader_name = leader.get("engine")
+    if not leader_name:
+        return []
+
+    per_doc_cer: list[float] = []
+    # Voie 1 : structure plate "per_doc_cer"
+    flat = benchmark_data.get("per_doc_cer") or {}
+    if isinstance(flat, dict) and leader_name in flat and isinstance(flat[leader_name], list):
+        per_doc_cer = [float(x) for x in flat[leader_name] if isinstance(x, (int, float))]
+    else:
+        # Voie 2 : engine.per_doc liste de dicts {cer: float}
+        for engine in benchmark_data.get("engines") or []:
+            if engine.get("name") != leader_name:
+                continue
+            per_doc = engine.get("per_doc") or []
+            for entry in per_doc:
+                if isinstance(entry, dict) and isinstance(entry.get("cer"), (int, float)):
+                    per_doc_cer.append(float(entry["cer"]))
+            break
+
+    if not per_doc_cer:
+        return []
+    total_cer = sum(per_doc_cer)
+    if total_cer <= 0:
+        return []
+
+    sorted_cer = sorted(per_doc_cer, reverse=True)
+    n = len(sorted_cer)
+    n_top = max(1, int(round(top_share * n)))
+    top_cer_sum = sum(sorted_cer[:n_top])
+    share_of_total = top_cer_sum / total_cer
+    if share_of_total < cer_share_threshold:
+        return []
+    importance = (
+        LeverImportance.HIGH if share_of_total >= 0.75
+        else LeverImportance.MEDIUM
+    )
+    return [Lever(
+        type=LeverType.PARETO_CONCENTRATION,
+        importance=importance,
+        payload={
+            "engine": leader_name,
+            "n_docs": n,
+            "n_docs_top": n_top,
+            "top_share_pct": round((n_top / n) * 100, 1),
+            "cer_share_of_total": share_of_total,
+            "cer_share_pct": round(share_of_total * 100, 1),
+        },
+        engines_involved=(leader_name,),
+    )]
+
+
+@register_lever(LeverType.COMPLEMENTARITY_OBSERVATION, priority=30)
+def detect_complementarity_observation(
+    benchmark_data: dict,
+    *,
+    min_relative_gap: float = 0.20,
+) -> list[Lever]:
+    """Reformule factuellement le `complementarity_gap` (Sprint 35).
+
+    Lit `benchmark_data["inter_engine_analysis"]`. Garde-fou : ne
+    déclenche que si `relative_gap` ≥ `min_relative_gap`. **Aucune
+    recommandation d'ensemble** — le levier dit factuellement
+    « X points séparent l'oracle du meilleur moteur », c'est tout.
+    """
+    inter = benchmark_data.get("inter_engine_analysis") or {}
+    cgap = inter.get("complementarity_gap") or {}
+    relative_gap = cgap.get("relative_gap")
+    absolute_gap = cgap.get("absolute_gap")
+    if relative_gap is None or absolute_gap is None:
+        return []
+    try:
+        rg = float(relative_gap)
+        ag = float(absolute_gap)
+    except (TypeError, ValueError):
+        return []
+    if rg < min_relative_gap:
+        return []
+    importance = (
+        LeverImportance.HIGH if rg >= 0.50 else LeverImportance.MEDIUM
+    )
+    payload: dict = {
+        "absolute_gap": ag,
+        "absolute_gap_pct": round(ag * 100, 1),
+        "relative_gap": rg,
+        "relative_gap_pct": round(rg * 100, 1),
+    }
+    best_engine = cgap.get("best_engine") or inter.get("best_engine")
+    best_recall = cgap.get("best_recall") or inter.get("best_engine_recall")
+    oracle_recall = cgap.get("oracle_recall") or inter.get("oracle_recall")
+    engines_involved: tuple[str, ...] = ()
+    if best_engine:
+        payload["best_engine"] = str(best_engine)
+        engines_involved = (str(best_engine),)
+    if isinstance(best_recall, (int, float)):
+        payload["best_recall"] = float(best_recall)
+    if isinstance(oracle_recall, (int, float)):
+        payload["oracle_recall"] = float(oracle_recall)
+    return [Lever(
+        type=LeverType.COMPLEMENTARITY_OBSERVATION,
+        importance=importance,
+        payload=payload,
+        engines_involved=engines_involved,
+    )]
+
+
+@register_lever(LeverType.LEXICAL_MODERNIZATION_OBSERVATION, priority=40)
+def detect_lexical_modernization_observation(
+    benchmark_data: dict,
+    *,
+    top_n: int = 3,
+    min_total: int = 3,
+    min_rate: float = 0.50,
+) -> list[Lever]:
+    """Pour chaque moteur disposant de `lexical_modernization`,
+    émet un levier listant les `top_n` tokens GT les plus modernisés.
+
+    Lit `benchmark_data["engines"][i]["lexical_modernization"]` qui
+    suit la forme produite par `compute_lexical_modernization` du
+    Sprint 80 (`{"n_gt_tokens": int, "tokens": dict}`).
+    """
+    out: list[Lever] = []
+    for engine in benchmark_data.get("engines") or []:
+        data = engine.get("lexical_modernization")
+        if not isinstance(data, dict):
+            continue
+        tokens = data.get("tokens") or {}
+        if not isinstance(tokens, dict) or not tokens:
+            continue
+        candidates: list[tuple[str, dict]] = []
+        for gt_token, slot in tokens.items():
+            if not isinstance(slot, dict):
+                continue
+            n_total = slot.get("n_total")
+            rate = slot.get("rate_modernized")
+            if not isinstance(n_total, (int, float)) or not isinstance(rate, (int, float)):
+                continue
+            if int(n_total) < min_total:
+                continue
+            if float(rate) < min_rate:
+                continue
+            candidates.append((gt_token, dict(slot)))
+        if not candidates:
+            continue
+        candidates.sort(
+            key=lambda kv: (-float(kv[1].get("rate_modernized", 0.0)),
+                            -int(kv[1].get("n_total", 0)),
+                            kv[0]),
+        )
+        top = candidates[:top_n]
+        engine_name = engine.get("name") or "?"
+        max_rate = max(float(slot.get("rate_modernized", 0.0)) for _, slot in top)
+        importance = (
+            LeverImportance.HIGH if max_rate >= 0.90 else LeverImportance.MEDIUM
+        )
+        out.append(Lever(
+            type=LeverType.LEXICAL_MODERNIZATION_OBSERVATION,
+            importance=importance,
+            payload={
+                "engine": engine_name,
+                "top_tokens": [
+                    {
+                        "gt_token": gt,
+                        "n_total": int(slot.get("n_total", 0)),
+                        "rate_modernized": float(slot.get("rate_modernized", 0.0)),
+                        "rate_modernized_pct": round(
+                            float(slot.get("rate_modernized", 0.0)) * 100, 1,
+                        ),
+                    }
+                    for gt, slot in top
+                ],
+            },
+            engines_involved=(engine_name,),
+        ))
+    return out
+
+
+@register_lever(LeverType.ROBUSTNESS_PROJECTION_OBSERVATION, priority=50)
+def detect_robustness_projection_observation(
+    benchmark_data: dict,
+    *,
+    min_total_deficit: float = 0.02,
+) -> list[Lever]:
+    """Lit l'agrégation par moteur de la projection de robustesse
+    (Sprint 81). Émet le levier pour le moteur dont
+    `total_expected_deficit` est ≥ `min_total_deficit` (par défaut
+    2 points de CER).
+
+    Lit `benchmark_data["robustness_projection_aggregated"]` —
+    structure produite par `aggregate_projection_per_engine`.
+    """
+    agg = benchmark_data.get("robustness_projection_aggregated") or {}
+    if not isinstance(agg, dict) or not agg:
+        return []
+    out: list[Lever] = []
+    for engine_name, info in agg.items():
+        if not isinstance(info, dict):
+            continue
+        total_deficit = info.get("total_expected_deficit")
+        worst_type = info.get("worst_degradation_type")
+        worst_deficit = info.get("worst_degradation_deficit")
+        if not isinstance(total_deficit, (int, float)):
+            continue
+        if float(total_deficit) < min_total_deficit:
+            continue
+        importance = (
+            LeverImportance.HIGH if float(total_deficit) >= 0.05
+            else LeverImportance.MEDIUM
+        )
+        payload: dict = {
+            "engine": engine_name,
+            "total_expected_deficit": float(total_deficit),
+            "total_expected_deficit_pct": round(float(total_deficit) * 100, 1),
+            "n_degradation_types": int(info.get("n_degradation_types") or 0),
+        }
+        if isinstance(worst_type, str):
+            payload["worst_degradation_type"] = worst_type
+        if isinstance(worst_deficit, (int, float)):
+            payload["worst_degradation_deficit"] = float(worst_deficit)
+            payload["worst_degradation_deficit_pct"] = round(
+                float(worst_deficit) * 100, 1,
+            )
+        out.append(Lever(
+            type=LeverType.ROBUSTNESS_PROJECTION_OBSERVATION,
+            importance=importance,
+            payload=payload,
+            engines_involved=(engine_name,),
+        ))
+    # Tri par déficit décroissant pour stabilité d'affichage.
+    out.sort(
+        key=lambda lv: -float(lv.payload.get("total_expected_deficit") or 0.0),
+    )
+    return out
+
+
+__all__ = [
+    "Lever",
+    "LeverImportance",
+    "LeverType",
+    "LeverDetectorEntry",
+    "register_lever",
+    "unregister_lever",
+    "iter_lever_detectors",
+    "detect_levers",
+    "detect_dominant_recoverable_class",
+    "detect_pareto_concentration",
+    "detect_complementarity_observation",
+    "detect_lexical_modernization_observation",
+    "detect_robustness_projection_observation",
+]

picarones/report/i18n/en.json

@@ -262,5 +262,23 @@
   "lexmod_gt_label": "Historical GT form",
   "lexmod_hyp_label": "OCR variants",
   "lexmod_n_label": "n GT",
-  "lexmod_rate_label": "% modernized"
+  "lexmod_rate_label": "% modernized",
+  "levers_title": "Improvement leverages",
+  "levers_note": "Factual observations synthesized from the analysis modules. No prescription imposed — the researcher decides what is actionable for their workflow.",
+  "levers_top_classes": "Main classes:",
+  "levers_importance_high": "Important",
+  "levers_importance_medium": "Notable",
+  "levers_importance_low": "Minor",
+  "levers_label_dominant_recoverable_class": "Mostly recoverable error classes",
+  "levers_label_pareto_concentration": "CER Pareto concentration",
+  "levers_label_complementarity_observation": "Inter-engine complementarity",
+  "levers_label_lexical_modernization_observation": "Systematic lexical modernization",
+  "levers_label_robustness_projection_observation": "Projected deficit on the real corpus",
+  "levers_dominant_recoverable_phrase": "{pct}% of {engine}'s errors ({n_recov}/{n_total}) are classified as recoverable (case_error, ligature_error, abbreviation_error).",
+  "levers_pareto_phrase": "On {engine}, {n_top} documents ({top_pct}% of the corpus) concentrate {cer_pct}% of the cumulative CER (out of {n_total} documents).",
+  "levers_complementarity_phrase": "The bag-of-words oracle achieves a recall {abs_pct} points higher (+{rel_pct}% relative) than the best single engine.",
+  "levers_complementarity_phrase_with_engine": "The bag-of-words oracle achieves a recall {abs_pct} points higher (+{rel_pct}% relative) than the best single engine ({best_engine}).",
+  "levers_lexical_phrase": "Top GT tokens systematically modernized by {engine}: {items}.",
+  "levers_robustness_phrase": "Projected deficit of {engine} on the real corpus: {deficit_pct} CER points cumulated over {n_types} degradations.",
+  "levers_robustness_phrase_with_worst": "Projected deficit of {engine} on the real corpus: {deficit_pct} CER points cumulated over {n_types} degradations — worst degradation: {worst_type} ({worst_pct} points)."
 }

picarones/report/i18n/fr.json

@@ -262,5 +262,23 @@
   "lexmod_gt_label": "Forme historique GT",
   "lexmod_hyp_label": "Variantes OCR",
   "lexmod_n_label": "n GT",
-  "lexmod_rate_label": "% modernisé"
+  "lexmod_rate_label": "% modernisé",
+  "levers_title": "Leviers d'amélioration",
+  "levers_note": "Observations factuelles synthétisées depuis les modules d'analyse. Aucune recommandation imposée — c'est au chercheur de juger ce qui est exploitable selon son workflow.",
+  "levers_top_classes": "Principales classes :",
+  "levers_importance_high": "Important",
+  "levers_importance_medium": "À noter",
+  "levers_importance_low": "Mineur",
+  "levers_label_dominant_recoverable_class": "Erreurs majoritairement récupérables",
+  "levers_label_pareto_concentration": "Concentration Pareto du CER",
+  "levers_label_complementarity_observation": "Complémentarité inter-moteurs",
+  "levers_label_lexical_modernization_observation": "Modernisation lexicale systématique",
+  "levers_label_robustness_projection_observation": "Déficit projeté sur le corpus réel",
+  "levers_dominant_recoverable_phrase": "{pct}% des erreurs de {engine} ({n_recov}/{n_total}) sont classifiées récupérables (case_error, ligature_error, abbreviation_error).",
+  "levers_pareto_phrase": "Sur {engine}, {n_top} documents ({top_pct}% du corpus) concentrent {cer_pct}% du CER cumulé (sur {n_total} documents au total).",
+  "levers_complementarity_phrase": "L'oracle bag-of-words atteint un rappel supérieur de {abs_pct} points (+{rel_pct}% relatif) à celui du meilleur moteur seul.",
+  "levers_complementarity_phrase_with_engine": "L'oracle bag-of-words atteint un rappel supérieur de {abs_pct} points (+{rel_pct}% relatif) à celui du meilleur moteur seul ({best_engine}).",
+  "levers_lexical_phrase": "Top tokens GT systématiquement modernisés par {engine} : {items}.",
+  "levers_robustness_phrase": "Déficit projeté de {engine} sur le corpus réel : {deficit_pct} points de CER cumulés sur {n_types} dégradations.",
+  "levers_robustness_phrase_with_worst": "Déficit projeté de {engine} sur le corpus réel : {deficit_pct} points de CER cumulés sur {n_types} dégradations — pire dégradation : {worst_type} ({worst_pct} points)."
 }

picarones/report/levers_render.py

@@ -0,0 +1,276 @@
+"""Rendu HTML de la section « Leviers d'amélioration » — Sprint 82.
+
+A.I.9 du plan d'évolution 2026.
+
+Suite directe ``picarones/core/levers.py``.  Pattern identique aux
+autres rendus (Sprints 41/43/62/67/72/74/75/76/77/80) : **server-
+side**, pas de JavaScript, anti-injection systématique.
+
+Vue
+---
+Une section composée de **cards** : une par levier, triée par
+importance décroissante.  Chaque card affiche :
+
+- une *étiquette* (libellé i18n du type de levier) ;
+- une *phrase factuelle* qui réutilise les chiffres du
+  ``payload`` (anti-hallucination : aucun chiffre n'est calculé
+  dans le rendu) ;
+- éventuellement un **détail compact** (top-N tokens, top-3
+  classes, etc.) ;
+- une *note* d'importance : HIGH / MEDIUM / LOW.
+
+Aucune classification automatique « bon » / « mauvais » et aucune
+recommandation : la phrase est purement descriptive.
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Iterable, Optional
+
+
+def _lever_label(lever_type: str, labels: dict[str, str]) -> str:
+    return labels.get(f"levers_label_{lever_type}", lever_type)
+
+
+def _format_dominant_recoverable(payload: dict, labels: dict[str, str]) -> str:
+    engine = _e(str(payload.get("engine", "?")))
+    pct = payload.get("share_recoverable_pct")
+    n_recov = payload.get("n_recoverable")
+    n_total = payload.get("n_total_errors")
+    template = labels.get(
+        "levers_dominant_recoverable_phrase",
+        "{pct}% des erreurs de {engine} ({n_recov}/{n_total}) sont "
+        "classifiées récupérables (case_error, ligature_error, "
+        "abbreviation_error).",
+    )
+    sentence = template.format(
+        engine=engine,
+        pct=pct,
+        n_recov=n_recov,
+        n_total=n_total,
+    )
+    top_classes = payload.get("top_classes") or []
+    if top_classes:
+        breakdown = ", ".join(
+            f"{_e(str(c.get('class', '?')))} ({c.get('count', 0)})"
+            for c in top_classes
+        )
+        detail_label = labels.get("levers_top_classes", "Principales :")
+        sentence += (
+            f' <span style="opacity:.8">— {_e(detail_label)} '
+            f'{breakdown}</span>'
+        )
+    return sentence
+
+
+def _format_pareto_concentration(payload: dict, labels: dict[str, str]) -> str:
+    engine = _e(str(payload.get("engine", "?")))
+    n_top = payload.get("n_docs_top")
+    n_total = payload.get("n_docs")
+    top_pct = payload.get("top_share_pct")
+    cer_pct = payload.get("cer_share_pct")
+    template = labels.get(
+        "levers_pareto_phrase",
+        "Sur {engine}, {n_top} documents ({top_pct}% du corpus) "
+        "concentrent {cer_pct}% du CER cumulé "
+        "(sur {n_total} documents au total).",
+    )
+    return template.format(
+        engine=engine,
+        n_top=n_top,
+        n_total=n_total,
+        top_pct=top_pct,
+        cer_pct=cer_pct,
+    )
+
+
+def _format_complementarity(payload: dict, labels: dict[str, str]) -> str:
+    abs_pct = payload.get("absolute_gap_pct")
+    rel_pct = payload.get("relative_gap_pct")
+    best_engine = payload.get("best_engine")
+    if best_engine:
+        template = labels.get(
+            "levers_complementarity_phrase_with_engine",
+            "L'oracle bag-of-words atteint un rappel supérieur de "
+            "{abs_pct} points (+{rel_pct}% relatif) à celui du meilleur "
+            "moteur seul ({best_engine}).",
+        )
+        return template.format(
+            abs_pct=abs_pct,
+            rel_pct=rel_pct,
+            best_engine=_e(str(best_engine)),
+        )
+    template = labels.get(
+        "levers_complementarity_phrase",
+        "L'oracle bag-of-words atteint un rappel supérieur de "
+        "{abs_pct} points (+{rel_pct}% relatif) à celui du meilleur "
+        "moteur seul.",
+    )
+    return template.format(abs_pct=abs_pct, rel_pct=rel_pct)
+
+
+def _format_lexical_modernization(payload: dict, labels: dict[str, str]) -> str:
+    engine = _e(str(payload.get("engine", "?")))
+    top_tokens = payload.get("top_tokens") or []
+    if not top_tokens:
+        return ""
+    items = ", ".join(
+        f"{_e(str(t.get('gt_token', '?')))} "
+        f"({t.get('rate_modernized_pct', 0)}%, "
+        f"n={t.get('n_total', 0)})"
+        for t in top_tokens
+    )
+    template = labels.get(
+        "levers_lexical_phrase",
+        "Top tokens GT systématiquement modernisés par {engine} : {items}.",
+    )
+    return template.format(engine=engine, items=items)
+
+
+def _format_robustness_projection(payload: dict, labels: dict[str, str]) -> str:
+    engine = _e(str(payload.get("engine", "?")))
+    deficit_pct = payload.get("total_expected_deficit_pct")
+    n_types = payload.get("n_degradation_types", 0)
+    worst_type = payload.get("worst_degradation_type")
+    worst_pct = payload.get("worst_degradation_deficit_pct")
+    if worst_type and worst_pct is not None:
+        template = labels.get(
+            "levers_robustness_phrase_with_worst",
+            "Déficit projeté de {engine} sur le corpus réel : "
+            "{deficit_pct} points de CER cumulés sur {n_types} "
+            "dégradations — pire dégradation : {worst_type} "
+            "({worst_pct} points).",
+        )
+        return template.format(
+            engine=engine,
+            deficit_pct=deficit_pct,
+            n_types=n_types,
+            worst_type=_e(str(worst_type)),
+            worst_pct=worst_pct,
+        )
+    template = labels.get(
+        "levers_robustness_phrase",
+        "Déficit projeté de {engine} sur le corpus réel : "
+        "{deficit_pct} points de CER cumulés sur {n_types} dégradations.",
+    )
+    return template.format(
+        engine=engine, deficit_pct=deficit_pct, n_types=n_types,
+    )
+
+
+_FORMATTERS = {
+    "dominant_recoverable_class": _format_dominant_recoverable,
+    "pareto_concentration": _format_pareto_concentration,
+    "complementarity_observation": _format_complementarity,
+    "lexical_modernization_observation": _format_lexical_modernization,
+    "robustness_projection_observation": _format_robustness_projection,
+}
+
+
+def _importance_label(importance: int, labels: dict[str, str]) -> str:
+    if importance >= 70:
+        return labels.get("levers_importance_high", "Important")
+    if importance >= 40:
+        return labels.get("levers_importance_medium", "À noter")
+    return labels.get("levers_importance_low", "Mineur")
+
+
+def _importance_color(importance: int) -> str:
+    if importance >= 70:
+        return "#c2410c"  # orange profond
+    if importance >= 40:
+        return "#0369a1"  # bleu
+    return "#6b7280"      # gris
+
+
+def build_levers_section_html(
+    levers: Iterable,
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit la section HTML des leviers.
+
+    Parameters
+    ----------
+    levers:
+        Itérable de ``Lever`` (ou de dicts avec ``type``,
+        ``importance``, ``payload``).
+    labels:
+        Dict i18n. Clés attendues sous le préfixe ``levers_``.
+
+    Returns
+    -------
+    str
+        Section HTML, ou ``""`` si aucun levier exploitable.
+    """
+    labels = labels or {}
+    cards: list[str] = []
+    for lever in levers:
+        # Accepter Lever ou dict
+        if hasattr(lever, "as_dict"):
+            data = lever.as_dict()
+        elif isinstance(lever, dict):
+            data = lever
+        else:
+            continue
+        lv_type = data.get("type")
+        importance = int(data.get("importance") or 0)
+        payload = data.get("payload") or {}
+        if not lv_type:
+            continue
+        formatter = _FORMATTERS.get(lv_type)
+        if formatter is None:
+            continue
+        try:
+            sentence = formatter(payload, labels)
+        except Exception:
+            continue
+        if not sentence:
+            continue
+        type_label = _lever_label(lv_type, labels)
+        imp_label = _importance_label(importance, labels)
+        imp_color = _importance_color(importance)
+        cards.append(
+            '<div class="lever-card" style="border:1px solid #e5e7eb;'
+            'border-left:4px solid ' + imp_color + ';'
+            'border-radius:.4rem;padding:.7rem .9rem;'
+            'margin:.5rem 0;background:#fafafa">'
+            f'<div style="display:flex;justify-content:space-between;'
+            f'align-items:center;margin-bottom:.3rem;font-size:.8rem">'
+            f'<span style="font-weight:600;text-transform:uppercase;'
+            f'letter-spacing:.5px;color:#374151">'
+            f'{_e(type_label)}</span>'
+            f'<span style="color:{imp_color};font-weight:600">'
+            f'{_e(imp_label)}</span>'
+            f'</div>'
+            f'<div style="font-size:.95rem;line-height:1.45">'
+            f'{sentence}</div>'
+            '</div>'
+        )
+
+    if not cards:
+        return ""
+
+    title = labels.get("levers_title", "Leviers d'amélioration")
+    note = labels.get(
+        "levers_note",
+        "Observations factuelles synthétisées depuis les modules "
+        "d'analyse. Aucune recommandation imposée — c'est au "
+        "chercheur de juger ce qui est exploitable selon son "
+        "workflow.",
+    )
+
+    parts = [
+        '<section class="levers-section" style="margin:1.5rem 0">',
+        f'<h3 style="margin:0 0 .3rem 0">{_e(title)}</h3>',
+        f'<div style="font-size:.85rem;opacity:.75;margin-bottom:.6rem">'
+        f'{_e(note)}</div>',
+    ]
+    parts.extend(cards)
+    parts.append('</section>')
+    return "".join(parts)
+
+
+__all__ = [
+    "build_levers_section_html",
+]

tests/test_sprint82_levers.py

@@ -0,0 +1,575 @@
+"""Tests Sprint 82 — A.I.9 : section « Leviers d'amélioration ».
+
+Couvre :
+
+1. Modèle ``Lever`` + registre.
+2. Les 5 détecteurs : ``dominant_recoverable_class``,
+   ``pareto_concentration``, ``complementarity_observation``,
+   ``lexical_modernization_observation``,
+   ``robustness_projection_observation``.
+3. Pipeline ``detect_levers`` (ordre, robustesse aux exceptions).
+4. Rendu HTML : cards, anti-injection, masquage adaptatif.
+5. Anti-hallucination : chaque chiffre rendu est dans le payload.
+6. Complétude i18n FR/EN.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+from picarones.core.levers import (
+    Lever,
+    LeverImportance,
+    LeverType,
+    detect_complementarity_observation,
+    detect_dominant_recoverable_class,
+    detect_levers,
+    detect_lexical_modernization_observation,
+    detect_pareto_concentration,
+    detect_robustness_projection_observation,
+    iter_lever_detectors,
+)
+from picarones.report.levers_render import build_levers_section_html
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 1. Modèle + registre
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestModel:
+    def test_lever_as_dict(self) -> None:
+        lv = Lever(
+            type=LeverType.DOMINANT_RECOVERABLE_CLASS,
+            importance=LeverImportance.HIGH,
+            payload={"engine": "t", "share_recoverable_pct": 65.0},
+            engines_involved=("t",),
+        )
+        d = lv.as_dict()
+        assert d["type"] == "dominant_recoverable_class"
+        assert d["importance"] == 70
+        assert d["engines_involved"] == ["t"]
+
+    def test_registry_contains_five_detectors(self) -> None:
+        types = {e.lever_type for e in iter_lever_detectors()}
+        assert LeverType.DOMINANT_RECOVERABLE_CLASS in types
+        assert LeverType.PARETO_CONCENTRATION in types
+        assert LeverType.COMPLEMENTARITY_OBSERVATION in types
+        assert LeverType.LEXICAL_MODERNIZATION_OBSERVATION in types
+        assert LeverType.ROBUSTNESS_PROJECTION_OBSERVATION in types
+
+    def test_registry_priority_sorted(self) -> None:
+        priorities = [e.priority for e in iter_lever_detectors()]
+        assert priorities == sorted(priorities)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 2. Détecteur dominant_recoverable_class
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestDominantRecoverable:
+    def test_emits_when_share_above_threshold(self) -> None:
+        data = {"engines": [{
+            "name": "t",
+            "aggregated_taxonomy": {
+                "case_error": 30,
+                "ligature_error": 10,
+                "abbreviation_error": 25,  # 65 récupérables
+                "lacuna": 20,
+                "diacritic_error": 15,
+            },
+        }]}
+        levers = detect_dominant_recoverable_class(data)
+        assert len(levers) == 1
+        lv = levers[0]
+        assert lv.payload["engine"] == "t"
+        assert lv.payload["n_recoverable"] == 65
+        assert lv.payload["n_total_errors"] == 100
+        assert lv.payload["share_recoverable_pct"] == 65.0
+        assert lv.importance == LeverImportance.HIGH
+
+    def test_silent_when_below_threshold(self) -> None:
+        data = {"engines": [{
+            "name": "t",
+            "aggregated_taxonomy": {"lacuna": 80, "case_error": 20},
+        }]}
+        assert detect_dominant_recoverable_class(data) == []
+
+    def test_silent_when_no_taxonomy(self) -> None:
+        data = {"engines": [{"name": "t"}]}
+        assert detect_dominant_recoverable_class(data) == []
+
+    def test_top_classes_sorted_descending(self) -> None:
+        data = {"engines": [{
+            "name": "t",
+            "aggregated_taxonomy": {
+                "case_error": 50,
+                "ligature_error": 5,
+                "abbreviation_error": 30,
+            },
+        }]}
+        lv = detect_dominant_recoverable_class(data)[0]
+        names = [c["class"] for c in lv.payload["top_classes"]]
+        assert names == ["case_error", "abbreviation_error", "ligature_error"]
+
+    def test_accepts_counts_subdict(self) -> None:
+        data = {"engines": [{
+            "name": "t",
+            "aggregated_taxonomy": {"counts": {"case_error": 60, "lacuna": 40}},
+        }]}
+        levers = detect_dominant_recoverable_class(data)
+        assert len(levers) == 1
+        assert levers[0].payload["n_recoverable"] == 60
+
+    def test_medium_when_share_in_30_50(self) -> None:
+        data = {"engines": [{
+            "name": "t",
+            "aggregated_taxonomy": {"case_error": 35, "lacuna": 65},
+        }]}
+        lv = detect_dominant_recoverable_class(data)[0]
+        assert lv.importance == LeverImportance.MEDIUM
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 3. Détecteur pareto_concentration
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestParetoConcentration:
+    def test_concentrated_corpus(self) -> None:
+        # 10 docs : 2 catastrophiques (CER 0.8), 8 OK (CER 0.05) → 80 %
+        # du CER total est concentré sur 20 % des docs.
+        data = {
+            "ranking": [{"engine": "t", "mean_cer": 0.20}],
+            "per_doc_cer": {"t": [0.8, 0.8] + [0.05] * 8},
+        }
+        levers = detect_pareto_concentration(data)
+        assert len(levers) == 1
+        p = levers[0].payload
+        assert p["n_docs"] == 10
+        assert p["n_docs_top"] == 2
+        assert p["cer_share_pct"] >= 70
+
+    def test_uniform_corpus_silent(self) -> None:
+        data = {
+            "ranking": [{"engine": "t", "mean_cer": 0.10}],
+            "per_doc_cer": {"t": [0.10] * 10},
+        }
+        assert detect_pareto_concentration(data) == []
+
+    def test_reads_engine_per_doc(self) -> None:
+        data = {
+            "ranking": [{"engine": "t", "mean_cer": 0.20}],
+            "engines": [{
+                "name": "t",
+                "per_doc": [
+                    {"cer": 0.9}, {"cer": 0.9},
+                    {"cer": 0.05}, {"cer": 0.05}, {"cer": 0.05},
+                    {"cer": 0.05}, {"cer": 0.05}, {"cer": 0.05},
+                    {"cer": 0.05}, {"cer": 0.05},
+                ],
+            }],
+        }
+        levers = detect_pareto_concentration(data)
+        assert len(levers) == 1
+
+    def test_no_ranking_silent(self) -> None:
+        assert detect_pareto_concentration({}) == []
+
+    def test_no_per_doc_silent(self) -> None:
+        data = {"ranking": [{"engine": "t", "mean_cer": 0.10}]}
+        assert detect_pareto_concentration(data) == []
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 4. Détecteur complementarity_observation
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestComplementarity:
+    def test_emits_when_relative_gap_above_threshold(self) -> None:
+        data = {"inter_engine_analysis": {
+            "complementarity_gap": {
+                "absolute_gap": 0.10,
+                "relative_gap": 0.30,
+                "best_engine": "t",
+                "best_recall": 0.70,
+                "oracle_recall": 0.80,
+            },
+        }}
+        levers = detect_complementarity_observation(data)
+        assert len(levers) == 1
+        p = levers[0].payload
+        assert p["best_engine"] == "t"
+        assert p["absolute_gap_pct"] == 10.0
+        assert p["relative_gap_pct"] == 30.0
+
+    def test_silent_when_below_threshold(self) -> None:
+        data = {"inter_engine_analysis": {
+            "complementarity_gap": {"absolute_gap": 0.02, "relative_gap": 0.05},
+        }}
+        assert detect_complementarity_observation(data) == []
+
+    def test_silent_when_no_data(self) -> None:
+        assert detect_complementarity_observation({}) == []
+
+    def test_high_when_relative_gap_above_50(self) -> None:
+        data = {"inter_engine_analysis": {
+            "complementarity_gap": {"absolute_gap": 0.30, "relative_gap": 0.60},
+        }}
+        lv = detect_complementarity_observation(data)[0]
+        assert lv.importance == LeverImportance.HIGH
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 5. Détecteur lexical_modernization_observation
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestLexicalModernization:
+    def test_emits_top_three(self) -> None:
+        data = {"engines": [{
+            "name": "gpt4o",
+            "lexical_modernization": {
+                "n_gt_tokens": 50,
+                "tokens": {
+                    "maistre": {"n_total": 10, "n_modernized": 10,
+                                "rate_modernized": 1.0,
+                                "variants": {"maître": 10}},
+                    "veoir": {"n_total": 5, "n_modernized": 5,
+                              "rate_modernized": 1.0,
+                              "variants": {"voir": 5}},
+                    "nostre": {"n_total": 8, "n_modernized": 6,
+                               "rate_modernized": 0.75,
+                               "variants": {"notre": 6}},
+                    "ami": {"n_total": 3, "n_modernized": 0,
+                            "rate_modernized": 0.0, "variants": {}},
+                },
+            },
+        }]}
+        levers = detect_lexical_modernization_observation(data)
+        assert len(levers) == 1
+        top = levers[0].payload["top_tokens"]
+        gt_tokens = [t["gt_token"] for t in top]
+        # Tri par rate desc, puis n_total desc → maistre, veoir, nostre
+        assert gt_tokens == ["maistre", "veoir", "nostre"]
+        assert levers[0].importance == LeverImportance.HIGH
+
+    def test_silent_when_no_tokens_above_min_rate(self) -> None:
+        data = {"engines": [{
+            "name": "t",
+            "lexical_modernization": {
+                "tokens": {"a": {"n_total": 10, "n_modernized": 1,
+                                 "rate_modernized": 0.10, "variants": {}}},
+            },
+        }]}
+        assert detect_lexical_modernization_observation(data) == []
+
+    def test_silent_when_n_total_below_min(self) -> None:
+        data = {"engines": [{
+            "name": "t",
+            "lexical_modernization": {
+                "tokens": {"a": {"n_total": 1, "n_modernized": 1,
+                                 "rate_modernized": 1.0, "variants": {}}},
+            },
+        }]}
+        assert detect_lexical_modernization_observation(data) == []
+
+    def test_silent_when_no_lexical_field(self) -> None:
+        data = {"engines": [{"name": "t"}]}
+        assert detect_lexical_modernization_observation(data) == []
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 6. Détecteur robustness_projection_observation
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestRobustnessProjection:
+    def test_emits_when_deficit_above_threshold(self) -> None:
+        data = {"robustness_projection_aggregated": {
+            "tess": {
+                "total_expected_deficit": 0.06,
+                "n_degradation_types": 2,
+                "worst_degradation_type": "noise",
+                "worst_degradation_deficit": 0.04,
+            },
+        }}
+        levers = detect_robustness_projection_observation(data)
+        assert len(levers) == 1
+        p = levers[0].payload
+        assert p["engine"] == "tess"
+        assert p["total_expected_deficit_pct"] == 6.0
+        assert p["worst_degradation_type"] == "noise"
+        assert levers[0].importance == LeverImportance.HIGH
+
+    def test_silent_when_deficit_too_low(self) -> None:
+        data = {"robustness_projection_aggregated": {
+            "tess": {"total_expected_deficit": 0.005},
+        }}
+        assert detect_robustness_projection_observation(data) == []
+
+    def test_silent_when_no_data(self) -> None:
+        assert detect_robustness_projection_observation({}) == []
+
+    def test_sorted_by_deficit_descending(self) -> None:
+        data = {"robustness_projection_aggregated": {
+            "a": {"total_expected_deficit": 0.03,
+                  "n_degradation_types": 1},
+            "b": {"total_expected_deficit": 0.08,
+                  "n_degradation_types": 2},
+        }}
+        levers = detect_robustness_projection_observation(data)
+        assert [lv.payload["engine"] for lv in levers] == ["b", "a"]
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 7. Pipeline detect_levers
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestDetectLevers:
+    def test_aggregates_multiple_types(self) -> None:
+        data = {
+            "engines": [{
+                "name": "t",
+                "aggregated_taxonomy": {"case_error": 60, "lacuna": 40},
+            }],
+            "robustness_projection_aggregated": {
+                "t": {"total_expected_deficit": 0.07,
+                      "n_degradation_types": 2},
+            },
+        }
+        levers = detect_levers(data)
+        types = [lv.type for lv in levers]
+        assert LeverType.DOMINANT_RECOVERABLE_CLASS in types
+        assert LeverType.ROBUSTNESS_PROJECTION_OBSERVATION in types
+
+    def test_sorted_by_importance_desc(self) -> None:
+        # HIGH (robustness 7%) avant MEDIUM (recoverable 35%)
+        data = {
+            "engines": [{
+                "name": "t",
+                "aggregated_taxonomy": {"case_error": 35, "lacuna": 65},
+            }],
+            "robustness_projection_aggregated": {
+                "t": {"total_expected_deficit": 0.07,
+                      "n_degradation_types": 2},
+            },
+        }
+        levers = detect_levers(data)
+        importances = [int(lv.importance) for lv in levers]
+        assert importances == sorted(importances, reverse=True)
+
+    def test_empty_input_returns_empty(self) -> None:
+        assert detect_levers({}) == []
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 8. Rendu HTML
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def _load_labels(lang: str) -> dict:
+    p = (
+        Path(__file__).parent.parent
+        / "picarones" / "report" / "i18n" / f"{lang}.json"
+    )
+    return json.loads(p.read_text(encoding="utf-8"))
+
+
+class TestRender:
+    def test_empty_returns_empty(self) -> None:
+        assert build_levers_section_html([]) == ""
+
+    def test_card_per_lever(self) -> None:
+        levers = [
+            Lever(
+                type=LeverType.DOMINANT_RECOVERABLE_CLASS,
+                importance=LeverImportance.HIGH,
+                payload={"engine": "t", "share_recoverable_pct": 65.0,
+                         "n_recoverable": 65, "n_total_errors": 100,
+                         "top_classes": [{"class": "case_error", "count": 50}]},
+            ),
+        ]
+        labels = _load_labels("fr")
+        html = build_levers_section_html(levers, labels)
+        assert "lever-card" in html
+        assert "65" in html
+        assert "case_error" in html
+        assert "Important" in html
+
+    def test_anti_injection(self) -> None:
+        levers = [
+            Lever(
+                type=LeverType.DOMINANT_RECOVERABLE_CLASS,
+                importance=LeverImportance.HIGH,
+                payload={"engine": "<script>alert(1)</script>",
+                         "share_recoverable_pct": 60.0,
+                         "n_recoverable": 60, "n_total_errors": 100,
+                         "top_classes": []},
+            ),
+        ]
+        html = build_levers_section_html(levers, _load_labels("fr"))
+        assert "<script>alert" not in html
+        assert "&lt;script&gt;" in html
+
+    def test_unknown_type_skipped(self) -> None:
+        # Lever-like dict avec type inconnu → ignoré
+        bad = {"type": "unknown_type", "importance": 70, "payload": {}}
+        html = build_levers_section_html([bad], _load_labels("fr"))
+        assert html == ""
+
+    def test_accepts_dict_input(self) -> None:
+        d = {
+            "type": "complementarity_observation",
+            "importance": 40,
+            "payload": {"absolute_gap_pct": 12.0, "relative_gap_pct": 25.0,
+                        "absolute_gap": 0.12, "relative_gap": 0.25},
+        }
+        html = build_levers_section_html([d], _load_labels("fr"))
+        assert "12" in html and "25" in html
+
+    def test_renders_in_english(self) -> None:
+        levers = [
+            Lever(
+                type=LeverType.PARETO_CONCENTRATION,
+                importance=LeverImportance.HIGH,
+                payload={"engine": "t", "n_docs": 10, "n_docs_top": 2,
+                         "top_share_pct": 20.0,
+                         "cer_share_of_total": 0.78,
+                         "cer_share_pct": 78.0},
+            ),
+        ]
+        html = build_levers_section_html(levers, _load_labels("en"))
+        assert "Improvement leverages" in html
+        assert "78" in html
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 9. Anti-hallucination : chaque chiffre rendu provient du payload
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def _numbers_in(s: str) -> set[str]:
+    """Extrait les nombres du HTML rendu visible.
+
+    On retire :
+    - les styles inline ;
+    - les entités HTML (``&#x27;`` ne contient pas le chiffre 27) ;
+    - les balises elles-mêmes (``<h3>`` ne contient pas le chiffre 3).
+    """
+    s_clean = re.sub(r'style="[^"]*"', "", s)
+    s_clean = re.sub(r"&#x?[0-9a-fA-F]+;", "", s_clean)
+    s_clean = re.sub(r"<[^>]+>", " ", s_clean)
+    return set(re.findall(r"\d+(?:\.\d+)?", s_clean))
+
+
+def _payload_numbers(payload: dict) -> set[str]:
+    out: set[str] = set()
+    def _walk(v):
+        if isinstance(v, (int, float)):
+            out.add(str(v))
+            # Aussi forme entière "65" si 65.0
+            if isinstance(v, float) and v.is_integer():
+                out.add(str(int(v)))
+        elif isinstance(v, dict):
+            for vv in v.values():
+                _walk(vv)
+        elif isinstance(v, list):
+            for vv in v:
+                _walk(vv)
+    _walk(payload)
+    return out
+
+
+class TestAntiHallucination:
+    def test_dominant_numbers_traceable_fr(self) -> None:
+        lv = Lever(
+            type=LeverType.DOMINANT_RECOVERABLE_CLASS,
+            importance=LeverImportance.HIGH,
+            payload={"engine": "tess", "share_recoverable_pct": 65.0,
+                     "n_recoverable": 65, "n_total_errors": 100,
+                     "top_classes": [{"class": "case_error", "count": 50}]},
+        )
+        html = build_levers_section_html([lv], _load_labels("fr"))
+        rendered = _numbers_in(html)
+        allowed = _payload_numbers(lv.payload)
+        # Tout chiffre du HTML doit être dans le payload
+        assert rendered.issubset(allowed), (
+            f"non traçable : {rendered - allowed}"
+        )
+
+    def test_pareto_numbers_traceable_en(self) -> None:
+        lv = Lever(
+            type=LeverType.PARETO_CONCENTRATION,
+            importance=LeverImportance.HIGH,
+            payload={"engine": "tess", "n_docs": 47, "n_docs_top": 9,
+                     "top_share_pct": 19.1,
+                     "cer_share_of_total": 0.81,
+                     "cer_share_pct": 80.7},
+        )
+        html = build_levers_section_html([lv], _load_labels("en"))
+        rendered = _numbers_in(html)
+        allowed = _payload_numbers(lv.payload)
+        assert rendered.issubset(allowed), (
+            f"non traçable : {rendered - allowed}"
+        )
+
+    def test_robustness_numbers_traceable_fr(self) -> None:
+        lv = Lever(
+            type=LeverType.ROBUSTNESS_PROJECTION_OBSERVATION,
+            importance=LeverImportance.HIGH,
+            payload={"engine": "tess", "total_expected_deficit": 0.058,
+                     "total_expected_deficit_pct": 5.8,
+                     "n_degradation_types": 3,
+                     "worst_degradation_type": "noise",
+                     "worst_degradation_deficit": 0.041,
+                     "worst_degradation_deficit_pct": 4.1},
+        )
+        html = build_levers_section_html([lv], _load_labels("fr"))
+        rendered = _numbers_in(html)
+        allowed = _payload_numbers(lv.payload)
+        assert rendered.issubset(allowed), (
+            f"non traçable : {rendered - allowed}"
+        )
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 10. Complétude i18n
+# ──────────────────────────────────────────────────────────────────────────
+
+
+_LEVERS_KEYS = {
+    "levers_title", "levers_note",
+    "levers_top_classes",
+    "levers_importance_high", "levers_importance_medium",
+    "levers_importance_low",
+    "levers_label_dominant_recoverable_class",
+    "levers_label_pareto_concentration",
+    "levers_label_complementarity_observation",
+    "levers_label_lexical_modernization_observation",
+    "levers_label_robustness_projection_observation",
+    "levers_dominant_recoverable_phrase",
+    "levers_pareto_phrase",
+    "levers_complementarity_phrase",
+    "levers_complementarity_phrase_with_engine",
+    "levers_lexical_phrase",
+    "levers_robustness_phrase",
+    "levers_robustness_phrase_with_worst",
+}
+
+
+class TestI18nCompleteness:
+    def test_fr_has_all_keys(self) -> None:
+        d = _load_labels("fr")
+        missing = _LEVERS_KEYS - d.keys()
+        assert not missing, f"manque FR : {missing}"
+
+    def test_en_has_all_keys(self) -> None:
+        d = _load_labels("en")
+        missing = _LEVERS_KEYS - d.keys()
+        assert not missing, f"manque EN : {missing}"