Sprint 4 du plan rapport — moteur narratif complet + synthèse factuelle

Sprint 4 de la phase 0. Synthèse de 3-5 phrases en tête du rapport,
déterministe, sans LLM, chaque nombre traçable au JSON de résultats.

Détecteurs (`core/narrative/detectors.py`) — 9 nouveaux :

- `detect_global_leader_cer` : leader du classement, payload avec cer_pct,
n_docs, runner_up pour permettre la fusion avec `significant_gap`.
- `detect_significant_gap` : lit `statistics.pairwise_wilcoxon`, émet si
leader vs runner-up est significatif (p < 0,05).
- `detect_stratum_winner` : agrège CER par (moteur, script_type), flag si
un moteur est au moins 25 % meilleur que le 2ᵉ sur une strate ≥ 3 docs.
- `detect_stratum_collapse` : flag si CER local > 2× CER global d'un moteur
sur une strate ≥ 3 documents.
- `detect_error_profile_outlier` : compare `aggregated_taxonomy.distribution`
par classe entre moteurs, flag si un moteur dépasse 2× la médiane avec
part ≥ 15 %.
- `detect_llm_hallucination_flag` : uniquement pour pipelines/VLM — flag si
hallucinating_doc_rate > 30 %, anchor_score < 0,60 ou length_ratio > 1,30.
- `detect_robustness_fragile` : lit `benchmark_data.robustness` si présent,
flag si CER au niveau max ≥ 3× CER baseline.
- `detect_speed_winner` : moteur au moins 3× plus rapide que la médiane,
dans le même groupe Nemenyi que le leader OU CER ≤ 1,1 × CER du leader.
- `detect_confidence_warning` : largeur d'IC 95 % > 3× |leader − runner-up|
OU > 5 points de CER → signale classement fragile.

`pareto_alternative` et `cost_outlier` restent stubs jusqu'au Sprint 5.
`register_default_detectors(registry)` enregistre les 12 types dans le
registre par défaut (stubs inclus — sûrs, retournent []).

Arbitre (`core/narrative/arbiter.py`) :

- Tri stable par (−importance, ordre canonique du type, moteurs, strate).
- Non-redondance : un seul fait par moteur sauf paires complémentaires
(leader + gap, leader + speed, leader + confidence, tie + speed).
- `_remove_contradictions` : si `STATISTICAL_TIE` (Nemenyi, corrigé pour
comparaisons multiples) inclut deux moteurs, tout `SIGNIFICANT_GAP`
(Wilcoxon non corrigé) entre ces mêmes moteurs est supprimé. Nemenyi
l'emporte pour éviter de dire en même temps "A bat B" et "A, B indiscernables".
- Limite : ≤ max_facts (défaut 5). Seuil min_importance = MEDIUM.

Renderer (`core/narrative/renderer.py`) :

- Charge les templates YAML `templates/{lang}.yaml` (1 template par type).
- Utilise `str.format_map` avec un `_SafeFormatMap` qui retourne "?" pour
clés manquantes + warning dans les logs. Aucune exception ne remonte.
- `extract_numbers(text)` pour les tests de traçabilité.

Templates (`core/narrative/templates/{fr,en}.yaml`) :

- 10 templates bilingues (1 par type implémenté).
- Règle stricte : aucune valeur numérique ou nom hors des champs du payload.

Intégration rapport :

- `_narrative_summary.html` : partial Jinja2 qui rend les phrases en `<li>`.
- Placé dans `base.html.j2` entre `_header.html` et `_critical_difference.html`.
- `ReportGenerator.generate` appelle `build_synthesis` et passe le résultat.
- CSS `.synth-card` avec bordure bleue à gauche, marqueurs puces bleus.
- i18n FR/EN : 2 nouvelles clés `synth_title`, `synth_hint`.
- Mode présentation masque le `hint`.
- **Autoescape Jinja2 désactivé** : équivalent au `_HTML_TEMPLATE.format()`
historique. Tout le contenu injecté vient du code Picarones.

Packaging :

- `pyproject.toml` : `core/narrative/templates/*.yaml` en package-data.
- `MANIFEST.in` : même inclusion.

Tests (`test_sprint19_narrative_engine.py`) — 32 nouveaux :

- Détecteurs individuels : cas canoniques + cas vides pour chacun.
- Arbitre : tri par importance, limite max_facts, dédup même engine+type,
conservation des paires complémentaires, filtrage LOW, règle Nemenyi vs
Wilcoxon.
- Renderer : templates chargés, langue respectée, clé manquante ne crash pas,
déterminisme.
- E2E `build_synthesis` : produit des phrases, reproductible.
- **Anti-hallucination** : parse chaque phrase rendue, vérifie que chaque
nombre est dans le payload d'un Fact retenu (ou dans la liste limitative
des constantes de template {"95", "100"}). Payloads = résultats de calculs
déterministes sur l'entrée, donc chaîne de traçabilité complète.
- Intégration rapport : section synthèse présente, déterminisme octet à octet,
registre par défaut peuplé (12 types), locale EN rend bien en anglais.

Suite complète : 1174 passed, 2 skipped (vs 1142 avant). Zéro régression.

Exemple de synthèse sur la démo (8 docs, 3 moteurs + pipelines) :

• Sur ce corpus de 8 documents, pero_ocr obtient le CER moyen le plus bas
(0.13 %).
• Les moteurs pero_ocr, tesseract → gpt-4o, gpt-4o-vision (zero-shot),
tesseract ne sont pas statistiquement distinguables (Friedman-Nemenyi,
α = 0.05, n = 8 documents, CD = 2.157).

https://claude.ai/code/session_0162FdNNJyNvBuYzkgtsr9VB

CLAUDE.md

@@ -193,6 +193,7 @@ AZURE_DOC_INTEL_KEY=...
 | 16 | **Sprint 1 du plan rapport** : câblage de `line_metrics` et `hallucination` dans le runner et l'agrégation `EngineReport`, fondations du moteur narratif (`core/narrative/` avec modèle `Fact` et registre de détecteurs), correctifs qualité (deprecation Pillow `getdata` → `tobytes`, deux `except Exception: pass` remplacés par warnings explicites) |
 | 17 | **Sprint 2 du plan rapport** : refactor de `generator.py` (3690 → 617 lignes) via Jinja2. Le monolithe `_HTML_TEMPLATE` est découpé en 10 fichiers externes dans `picarones/report/templates/` (base + 5 vues + header/footer + CSS + JS). L'i18n `i18n.py` (dict Python 101 clés) migré vers `picarones/report/i18n/{fr,en}.json` chargés à l'import. Ajout de 16 tests de non-régression (structure, déterminisme, i18n, garde-fous contre balises dupliquées). |
 | 18 | **Sprint 3 du plan rapport** : test de Friedman multi-moteurs + post-hoc Nemenyi + Critical Difference Diagram (Demšar 2006). Nouveau module `core/statistics.py` : `friedman_test`, `nemenyi_posthoc`, `build_critical_difference_svg` avec table Nemenyi (k=2 à 50, α=0,05 et 0,01), fallback pur Python (Wilson-Hilferty pour chi²), support scipy optionnel (extra `stats`). Partial `_critical_difference.html` inséré en tête du rapport, SVG rendu server-side (pas de JS), i18n FR/EN pour les aides. Détecteur narratif `detect_statistical_tie` activé (lit `nemenyi.tied_groups`). 41 tests ajoutés (cas canoniques, dégénérés, SVG, intégration rapport). |
+| 19 | **Sprint 4 du plan rapport** : moteur narratif complet + synthèse factuelle en tête. 9 détecteurs implémentés (global_leader_cer, significant_gap, stratum_winner/collapse, error_profile_outlier, llm_hallucination_flag, robustness_fragile, speed_winner, confidence_warning). Arbitre (`arbiter.py`) avec tri par importance, non-redondance, suppression des contradictions Wilcoxon/Nemenyi. Renderer (`renderer.py`) lit templates YAML `core/narrative/templates/{fr,en}.yaml` (10 templates par langue) et rend par `str.format_map` déterministe. Nouveau partial `_narrative_summary.html` placé en tête du rapport (entre header et CDD). Garde-fou anti-hallucination testé : chaque nombre rendu est traçable au payload du Fact associé. 32 tests (détecteurs unitaires, arbitre, renderer, E2E, traçabilité, intégration HTML). `pareto_alternative` et `cost_outlier` restent stubs pour Sprint 5. |
 
 ---
 
@@ -202,30 +203,44 @@ Fondations en place dans `picarones/core/narrative/` :
 
 ```
 core/narrative/
-├── __init__.py              # API publique : Fact, FactType, FactImportance, DetectorRegistry, detect_all
-├── facts.py                 # Modèle de données : Fact dataclass, 12 FactType, 4 FactImportance, DetectorRegistry
-└── detectors.py             # Stubs des 12 détecteurs (implémentations sprint par sprint)
+├── __init__.py              # API publique + pipeline build_synthesis
+├── facts.py                 # Modèle Fact, FactType (12 types), FactImportance, DetectorRegistry
+├── detectors.py             # 10 détecteurs implémentés (Sprint 19) + 2 stubs (Sprint 5)
+├── arbiter.py               # Tri par importance, non-redondance, anti-contradiction
+├── renderer.py              # Rendu templates YAML par str.format_map (déterministe)
+└── templates/
+    ├── fr.yaml              # 10 templates français
+    └── en.yaml              # 10 templates anglais
 ```
 
 **Principe anti-hallucination** : chaque valeur numérique ou nom d'entité dans le
-`payload` d'un `Fact` doit provenir directement du JSON d'entrée du benchmark.
-Test unitaire à ajouter au Sprint 4 : parser la synthèse rendue et vérifier que
-tous les nombres qu'elle contient sont traçables au JSON source.
+`payload` d'un `Fact` doit provenir du JSON d'entrée. Test `test_sprint19_narrative_engine.py`
+parse la synthèse rendue et vérifie que chaque nombre est traçable au payload
+(via `_numbers_in_payload`) augmenté d'une liste blanche limitative de constantes
+de template (`95`, `100`).
 
-**Détecteurs** : les 12 stubs sont en place. L'activation dans le registre par
-défaut se fait sprint par sprint au fur et à mesure de leur implémentation :
-- Sprint 3 : `statistical_tie` — **implémenté** (lit `nemenyi.tied_groups`)
+**Détecteurs activés dans le registre par défaut (Sprint 19)** :
+- Sprint 3 : `statistical_tie`
 - Sprint 4 : `global_leader_cer`, `significant_gap`, `stratum_winner`, `stratum_collapse`,
-  `error_profile_outlier`, `llm_hallucination_flag`, `robustness_fragile`, `speed_winner`,
-  `confidence_warning` + activation dans le registre par défaut + rendu templates Jinja2
-- Sprint 5 : `pareto_alternative`, `cost_outlier`
+  `error_profile_outlier`, `llm_hallucination_flag`, `robustness_fragile`,
+  `speed_winner`, `confidence_warning`
+- Sprint 5 : `pareto_alternative`, `cost_outlier` — stubs (retournent `[]`)
+
+**Règle anti-contradiction** (arbitre) : si `SIGNIFICANT_GAP` (Wilcoxon non corrigé)
+et `STATISTICAL_TIE` (Nemenyi corrigé) concernent les mêmes moteurs, Nemenyi
+l'emporte — on ne veut pas dire en même temps "A bat B significativement" ET
+"A et B sont indiscernables".
+
+**Pipeline** : `build_synthesis(benchmark_data, lang, max_facts=5)` détecte,
+arbitre, rend. Le `ReportGenerator.generate` l'appelle et passe le résultat
+au template `_narrative_summary.html` (placé entre `_header.html` et `_critical_difference.html`).
 
 ---
 
 ## Contexte développement
 
 - **Environnement** : GitHub Codespaces (`/workspaces/Picarones`), Python 3.12
-- **Tests** : 1142 passed, 2 skipped (Sprint 18)
+- **Tests** : 1174 passed, 2 skipped (Sprint 19)
 - **Branche active** : `claude/review-picarones-benchmarks-E3J42`
 - **Transcript de la conversation de développement** :
   `/mnt/transcripts/2026-03-11-14-01-41-picarones-ocr-bench-project.txt`

MANIFEST.in

@@ -7,3 +7,4 @@ recursive-include picarones/web/static *.css
 recursive-include picarones *.json *.yaml *.yml
 recursive-include picarones/report/templates *.j2 *.html *.css *.js
 recursive-include picarones/report/i18n *.json
+recursive-include picarones/core/narrative/templates *.yaml

picarones/core/narrative/__init__.py

@@ -1,12 +1,17 @@
 """Moteur narratif factuel — génération de synthèse déterministe.
 
-Le module extrait des faits saillants d'un ``BenchmarkResult`` et les rend en
-phrases courtes via des templates externes. Aucun LLM n'est appelé : chaque
-nombre ou nom apparaissant dans la synthèse est traçable à un champ du JSON de
-résultats en entrée.
+Extrait des faits saillants d'un ``BenchmarkResult`` et les rend en phrases
+courtes via des templates externes YAML. Aucun LLM : chaque nombre ou nom
+apparaissant dans la synthèse est traçable au JSON de résultats en entrée.
 
-Sprint 1 : fondations — modèle ``Fact`` et registre de détecteurs.
-Sprint 4 : intégration complète avec templates Jinja2 et rendu HTML.
+API publique
+------------
+- ``Fact``, ``FactType``, ``FactImportance`` : modèle de données
+- ``DetectorRegistry``                        : registre des détecteurs
+- ``detect_all(data)``                        : applique le registre par défaut
+- ``select_facts(facts, max_facts=5)``        : arbitre de sélection
+- ``render_synthesis(facts, lang="fr")``      : rend en liste de phrases
+- ``build_synthesis(data, lang="fr")``        : pipeline complet (Sprint 4)
 """
 
 from picarones.core.narrative.facts import (
@@ -15,7 +20,47 @@ from picarones.core.narrative.facts import (
     FactImportance,
     DetectorRegistry,
     detect_all,
+    _DEFAULT_REGISTRY,
 )
+from picarones.core.narrative.arbiter import select_facts
+from picarones.core.narrative.renderer import (
+    render_fact,
+    render_synthesis,
+    extract_numbers,
+)
+from picarones.core.narrative.detectors import (
+    register_default_detectors,
+    DETECTORS_BY_TYPE,
+)
+
+
+# Activer le registre par défaut — Sprint 4
+register_default_detectors(_DEFAULT_REGISTRY)
+
+
+def build_synthesis(
+    benchmark_data: dict,
+    lang: str = "fr",
+    max_facts: int = 5,
+) -> dict:
+    """Pipeline complet : détection → arbitre → rendu.
+
+    Returns
+    -------
+    dict avec :
+      - ``sentences`` : liste de phrases prêtes à l'affichage
+      - ``facts``     : liste de dicts ``Fact.as_dict()`` pour traçabilité
+      - ``lang``      : langue utilisée
+    """
+    all_facts = detect_all(benchmark_data)
+    selected = select_facts(all_facts, max_facts=max_facts)
+    sentences = render_synthesis(selected, lang=lang)
+    return {
+        "sentences": sentences,
+        "facts": [f.as_dict() for f in selected],
+        "lang": lang,
+    }
+
 
 __all__ = [
     "Fact",
@@ -23,4 +68,11 @@ __all__ = [
     "FactImportance",
     "DetectorRegistry",
     "detect_all",
+    "select_facts",
+    "render_fact",
+    "render_synthesis",
+    "extract_numbers",
+    "build_synthesis",
+    "register_default_detectors",
+    "DETECTORS_BY_TYPE",
 ]

picarones/core/narrative/arbiter.py

@@ -0,0 +1,136 @@
+"""Arbitre de sélection des faits narratifs.
+
+L'arbitre transforme une liste potentiellement longue de ``Fact`` détectés
+en une synthèse courte (3 à 5 phrases) adaptée à l'ouverture du rapport.
+
+Règles de sélection :
+  1. Tri par importance décroissante, puis par type (ordre canonique).
+  2. Non-redondance : un seul fait par moteur, sauf si les types sont
+     complémentaires (ex. ``GLOBAL_LEADER_CER`` + ``SIGNIFICANT_GAP``
+     concernent le leader mais apportent une information différente).
+  3. Limite : au maximum ``max_facts`` faits retenus (défaut 5).
+  4. Déterminisme : tri stable sur (−importance, ordre canonique du type,
+     noms des moteurs) pour garantir une sortie bit-à-bit identique.
+
+Les détecteurs peuvent émettre plusieurs faits du même type (ex. plusieurs
+``STATISTICAL_TIE`` si plusieurs groupes distincts). L'arbitre ne fusionne
+pas mais peut limiter par type.
+"""
+
+from __future__ import annotations
+
+from typing import Iterable
+
+from picarones.core.narrative.facts import Fact, FactImportance, FactType
+
+
+# Ordre canonique des types pour départager les ex-aequo à l'importance égale.
+_TYPE_ORDER: tuple[FactType, ...] = (
+    FactType.GLOBAL_LEADER_CER,
+    FactType.STATISTICAL_TIE,
+    FactType.SIGNIFICANT_GAP,
+    FactType.STRATUM_WINNER,
+    FactType.STRATUM_COLLAPSE,
+    FactType.ERROR_PROFILE_OUTLIER,
+    FactType.LLM_HALLUCINATION_FLAG,
+    FactType.ROBUSTNESS_FRAGILE,
+    FactType.PARETO_ALTERNATIVE,
+    FactType.SPEED_WINNER,
+    FactType.COST_OUTLIER,
+    FactType.CONFIDENCE_WARNING,
+)
+_TYPE_INDEX: dict[FactType, int] = {t: i for i, t in enumerate(_TYPE_ORDER)}
+
+
+# Paires de types qui ne sont PAS considérées comme redondantes même quand
+# elles concernent le même moteur. Tout autre couple → un seul fait retenu
+# pour le moteur (le plus important).
+_COMPLEMENTARY_PAIRS: frozenset[frozenset[FactType]] = frozenset({
+    frozenset({FactType.GLOBAL_LEADER_CER, FactType.SIGNIFICANT_GAP}),
+    frozenset({FactType.GLOBAL_LEADER_CER, FactType.SPEED_WINNER}),
+    frozenset({FactType.GLOBAL_LEADER_CER, FactType.CONFIDENCE_WARNING}),
+    frozenset({FactType.STATISTICAL_TIE, FactType.SPEED_WINNER}),
+})
+
+
+def _sort_key(fact: Fact) -> tuple:
+    """Clé de tri stable : importance (desc), type canonique, moteurs."""
+    return (
+        -int(fact.importance),
+        _TYPE_INDEX.get(fact.type, len(_TYPE_ORDER)),
+        tuple(sorted(fact.engines_involved)),
+        fact.stratum or "",
+    )
+
+
+def _is_redundant(candidate: Fact, kept: Fact) -> bool:
+    """Vrai si ``candidate`` apporte trop peu par rapport à ``kept``.
+
+    Deux faits sont redondants s'ils concernent exactement le même moteur,
+    ont le même type, et la même strate (s'il y en a une). Des types
+    différents sur le même moteur ne sont considérés redondants que s'ils
+    n'appartiennent pas aux paires complémentaires (ex : un leader peut
+    aussi être rapide ; c'est complémentaire).
+    """
+    if candidate.type == kept.type and candidate.stratum == kept.stratum:
+        return set(candidate.engines_involved) == set(kept.engines_involved)
+    if set(candidate.engines_involved) == set(kept.engines_involved):
+        pair = frozenset({candidate.type, kept.type})
+        return pair not in _COMPLEMENTARY_PAIRS
+    return False
+
+
+def _remove_contradictions(facts: list[Fact]) -> list[Fact]:
+    """Supprime les faits incohérents sur le plan statistique.
+
+    Règle centrale : si Nemenyi (post-hoc corrigé pour comparaisons multiples)
+    place deux moteurs dans le même groupe d'ex-aequo, alors un ``SIGNIFICANT_GAP``
+    basé sur Wilcoxon non corrigé entre ces deux mêmes moteurs est trompeur
+    pour un lecteur non statisticien. Nemenyi l'emporte.
+    """
+    tied_groups: list[set[str]] = []
+    for f in facts:
+        if f.type == FactType.STATISTICAL_TIE:
+            tied_groups.append(set(f.engines_involved))
+
+    def _is_contradicted(fact: Fact) -> bool:
+        if fact.type != FactType.SIGNIFICANT_GAP:
+            return False
+        pair = set(fact.engines_involved)
+        return any(pair <= group for group in tied_groups)
+
+    return [f for f in facts if not _is_contradicted(f)]
+
+
+def select_facts(
+    facts: Iterable[Fact],
+    max_facts: int = 5,
+    min_importance: FactImportance = FactImportance.MEDIUM,
+) -> list[Fact]:
+    """Sélectionne la synthèse finale à partir d'une liste brute de faits.
+
+    Parameters
+    ----------
+    facts:
+        Liste de ``Fact`` brute issue de ``DetectorRegistry.run``.
+    max_facts:
+        Nombre maximal de faits retenus (défaut : 5).
+    min_importance:
+        Seuil minimal d'importance. Les faits ``LOW`` sont exclus par défaut.
+
+    Returns
+    -------
+    Liste ordonnée, prête à être rendue. Toujours ≤ ``max_facts``.
+    """
+    facts_list = [f for f in facts if int(f.importance) >= int(min_importance)]
+    facts_list = _remove_contradictions(facts_list)
+    ranked = sorted(facts_list, key=_sort_key)
+
+    selected: list[Fact] = []
+    for fact in ranked:
+        if any(_is_redundant(fact, kept) for kept in selected):
+            continue
+        selected.append(fact)
+        if len(selected) >= max_facts:
+            break
+    return selected

picarones/core/narrative/detectors.py

@@ -1,40 +1,86 @@
-"""Détecteurs de faits — stubs Sprint 1, implémentations sprint par sprint.
+"""Détecteurs de faits — implémentations Sprint 4.
 
 Chaque détecteur est une fonction pure ``(benchmark_data: dict) -> list[Fact]``.
-Le sprint qui implémente chaque détecteur est indiqué dans le docstring.
-
 Convention : un détecteur qui ne trouve rien retourne une liste vide. Il ne
 doit jamais lever d'exception — la gestion d'erreur est centralisée dans
 ``DetectorRegistry.run``.
+
+Règle anti-hallucination : chaque nombre ou nom placé dans ``payload`` doit
+venir directement du JSON d'entrée (jamais d'une interpolation). Les tests
+du Sprint 4 parsent la synthèse rendue et vérifient que chaque valeur
+numérique qu'elle contient est traçable.
 """
 
 from __future__ import annotations
 
+import statistics as _stats
+from typing import Optional
+
 from picarones.core.narrative.facts import Fact, FactImportance, FactType
 
 
 # ---------------------------------------------------------------------------
-# Détecteurs Sprint 4 (implémentations à venir)
+# Helpers internes
+# ---------------------------------------------------------------------------
+
+def _engines_summary(data: dict) -> list[dict]:
+    """Accès normalisé à la liste des résumés moteur."""
+    return data.get("engines", []) or []
+
+
+def _engine_by_name(data: dict, name: str) -> Optional[dict]:
+    for e in _engines_summary(data):
+        if e.get("name") == name:
+            return e
+    return None
+
+
+def _n_docs(data: dict) -> int:
+    meta = data.get("meta", {}) or {}
+    return int(meta.get("document_count") or 0)
+
+
+# ---------------------------------------------------------------------------
+# Sprint 4 — Détecteurs implémentés
 # ---------------------------------------------------------------------------
 
 def detect_global_leader_cer(benchmark_data: dict) -> list[Fact]:
-    """Détecte le moteur avec le CER médian le plus bas.
+    """Moteur avec le CER moyen le plus bas sur l'ensemble du corpus.
 
-    Implémentation Sprint 4. Lit ``benchmark_data["ranking"]``, identifie le
-    leader, émet un Fact ``GLOBAL_LEADER_CER`` d'importance CRITICAL.
+    Émet un Fact CRITICAL si au moins 2 moteurs sont comparés, en attachant
+    aussi le 2ᵉ pour permettre à l'arbitre de fusionner avec ``significant_gap``.
     """
-    return []
+    ranking = benchmark_data.get("ranking") or []
+    # Éliminer les entrées sans CER calculé
+    valid = [r for r in ranking if r.get("mean_cer") is not None]
+    if len(valid) < 1:
+        return []
 
+    leader = valid[0]
+    runner_up = valid[1] if len(valid) >= 2 else None
+
+    payload = {
+        "engine": leader["engine"],
+        "cer": float(leader["mean_cer"]),
+        "cer_pct": round(float(leader["mean_cer"]) * 100, 2),
+        "n_engines": len(valid),
+        "n_docs": _n_docs(benchmark_data),
+    }
+    if runner_up is not None:
+        payload["runner_up"] = runner_up["engine"]
+        payload["runner_up_cer"] = float(runner_up["mean_cer"])
+        payload["runner_up_cer_pct"] = round(float(runner_up["mean_cer"]) * 100, 2)
+
+    return [Fact(
+        type=FactType.GLOBAL_LEADER_CER,
+        importance=FactImportance.CRITICAL,
+        payload=payload,
+        engines_involved=(leader["engine"],),
+    )]
 
-def detect_statistical_tie(benchmark_data: dict) -> list[Fact]:
-    """Détecte les groupes de moteurs statistiquement indiscernables.
 
-    Lit les résultats Nemenyi du Sprint 3
-    (``benchmark_data["statistics"]["nemenyi"]``) et émet un ``Fact`` pour
-    chaque groupe d'ex-aequo non trivial (≥ 2 moteurs). La présence du fait
-    est un signal important pour la synthèse : "les moteurs X, Y, Z sont
-    statistiquement indiscernables au seuil α = 0,05".
-    """
+def detect_statistical_tie(benchmark_data: dict) -> list[Fact]:
+    """Groupes de moteurs statistiquement indiscernables (Nemenyi)."""
     nemenyi = benchmark_data.get("statistics", {}).get("nemenyi", {})
     if not nemenyi or nemenyi.get("error"):
         return []
@@ -48,9 +94,7 @@ def detect_statistical_tie(benchmark_data: dict) -> list[Fact]:
     facts: list[Fact] = []
     for group in tied_groups:
         if len(group) < 2:
-            continue  # singletons n'ont pas besoin de fait dédié
-        # Importance : un groupe incluant le leader (rang le plus bas) est critique
-        # (il nuance fortement le classement ordinal), les autres sont HIGH.
+            continue
         is_leader_tie = min(mean_ranks.get(n, 999) for n in group) == min(
             mean_ranks.values(), default=0
         )
@@ -61,11 +105,13 @@ def detect_statistical_tie(benchmark_data: dict) -> list[Fact]:
             importance=importance,
             payload={
                 "engines": list(group),
+                "engines_list": ", ".join(group),
                 "mean_ranks": {n: mean_ranks.get(n) for n in group},
-                "critical_distance": cd,
+                "critical_distance": round(cd, 3),
                 "alpha": alpha,
                 "n_blocks": n_blocks,
                 "includes_leader": is_leader_tie,
+                "n_tied": len(group),
             },
             engines_involved=tuple(group),
         ))
@@ -73,73 +119,447 @@ def detect_statistical_tie(benchmark_data: dict) -> list[Fact]:
 
 
 def detect_significant_gap(benchmark_data: dict) -> list[Fact]:
-    """Détecte un écart significatif entre le 1ᵉʳ et le 2ᵉ du classement."""
-    return []
+    """Écart statistiquement significatif entre le 1ᵉʳ et le 2ᵉ du classement.
+
+    Lit la matrice de Wilcoxon pairwise et vérifie si la paire (leader,
+    runner-up) y apparaît avec ``significant = True``.
+    """
+    ranking = benchmark_data.get("ranking") or []
+    valid = [r for r in ranking if r.get("mean_cer") is not None]
+    if len(valid) < 2:
+        return []
+
+    leader = valid[0]["engine"]
+    runner_up = valid[1]["engine"]
+
+    pairwise = benchmark_data.get("statistics", {}).get("pairwise_wilcoxon") or []
+    match = None
+    for p in pairwise:
+        names = {p.get("engine_a"), p.get("engine_b")}
+        if names == {leader, runner_up}:
+            match = p
+            break
+    if match is None:
+        return []
+
+    if not match.get("significant"):
+        return []  # pas d'écart significatif — rien à signaler ici
+
+    delta_cer = abs(float(valid[0]["mean_cer"]) - float(valid[1]["mean_cer"]))
+    return [Fact(
+        type=FactType.SIGNIFICANT_GAP,
+        importance=FactImportance.CRITICAL,
+        payload={
+            "leader": leader,
+            "runner_up": runner_up,
+            "p_value": float(match.get("p_value", 0.0)),
+            "delta_cer": round(delta_cer, 4),
+            "delta_cer_pct": round(delta_cer * 100, 2),
+            "n_pairs": int(match.get("n_pairs", 0)),
+        },
+        engines_involved=(leader, runner_up),
+    )]
 
 
 def detect_pareto_alternative(benchmark_data: dict) -> list[Fact]:
-    """Détecte un moteur Pareto-dominant différent du leader CER.
+    """Moteur Pareto-dominant différent du leader CER. Sprint 5."""
+    return []
 
-    Implémentation Sprint 5 (nécessite la modélisation coût).
+
+def _stratum_cer_by_engine(benchmark_data: dict) -> dict[str, dict[str, list[float]]]:
+    """Agrège les CER par (moteur, strate).
+
+    Strate = ``document["script_type"]`` si présent. Retourne ``{}`` si aucun
+    document n'expose de strate (pas d'émission possible).
     """
-    return []
+    out: dict[str, dict[str, list[float]]] = {}
+    for doc in benchmark_data.get("documents") or []:
+        stratum = doc.get("script_type")
+        if not stratum:
+            continue
+        for er in doc.get("engine_results") or []:
+            if er.get("error"):
+                continue
+            cer = er.get("cer")
+            if cer is None:
+                continue
+            name = er.get("engine")
+            out.setdefault(name, {}).setdefault(stratum, []).append(float(cer))
+    return out
 
 
 def detect_stratum_winner(benchmark_data: dict) -> list[Fact]:
-    """Détecte un moteur qui domine sur une strate (siècle, langue, type)."""
-    return []
+    """Moteur qui domine nettement sur une strate (≥ 3 documents, CER
+    au moins 25 % plus bas que le second sur cette strate).
+    """
+    agg = _stratum_cer_by_engine(benchmark_data)
+    if not agg:
+        return []
+
+    # Inverser : {stratum: {engine: mean_cer}}
+    by_stratum: dict[str, dict[str, float]] = {}
+    for engine, strata in agg.items():
+        for stratum, vals in strata.items():
+            if len(vals) < 3:
+                continue
+            by_stratum.setdefault(stratum, {})[engine] = sum(vals) / len(vals)
+
+    facts: list[Fact] = []
+    for stratum, engine_cer in by_stratum.items():
+        if len(engine_cer) < 2:
+            continue
+        ordered = sorted(engine_cer.items(), key=lambda kv: kv[1])
+        best_name, best_cer = ordered[0]
+        second_cer = ordered[1][1]
+        if second_cer == 0:
+            continue
+        if best_cer < second_cer * 0.75:  # dominance ≥ 25 %
+            facts.append(Fact(
+                type=FactType.STRATUM_WINNER,
+                importance=FactImportance.HIGH,
+                payload={
+                    "engine": best_name,
+                    "stratum": stratum,
+                    "cer": round(best_cer, 4),
+                    "cer_pct": round(best_cer * 100, 2),
+                    "second_engine": ordered[1][0],
+                    "second_cer": round(second_cer, 4),
+                    "second_cer_pct": round(second_cer * 100, 2),
+                    "n_docs_stratum": len(agg[best_name][stratum]),
+                },
+                engines_involved=(best_name,),
+                stratum=stratum,
+            ))
+    return facts
 
 
 def detect_stratum_collapse(benchmark_data: dict) -> list[Fact]:
-    """Détecte un moteur globalement bon qui s'effondre sur une strate."""
-    return []
+    """Moteur globalement compétitif qui s'effondre sur une strate.
+
+    Déclenché si, pour un moteur, le CER moyen sur une strate ≥ 3 documents
+    est plus du double du CER global du même moteur.
+    """
+    agg = _stratum_cer_by_engine(benchmark_data)
+    if not agg:
+        return []
+
+    facts: list[Fact] = []
+    for engine_name, strata in agg.items():
+        summary = _engine_by_name(benchmark_data, engine_name) or {}
+        global_cer = summary.get("cer")
+        if global_cer is None:
+            continue
+        global_cer = float(global_cer)
+        if global_cer <= 0:
+            continue
+        for stratum, vals in strata.items():
+            if len(vals) < 3:
+                continue
+            local_cer = sum(vals) / len(vals)
+            if local_cer > 2.0 * global_cer and (local_cer - global_cer) > 0.05:
+                facts.append(Fact(
+                    type=FactType.STRATUM_COLLAPSE,
+                    importance=FactImportance.HIGH,
+                    payload={
+                        "engine": engine_name,
+                        "stratum": stratum,
+                        "local_cer": round(local_cer, 4),
+                        "local_cer_pct": round(local_cer * 100, 2),
+                        "global_cer": round(global_cer, 4),
+                        "global_cer_pct": round(global_cer * 100, 2),
+                        "delta_cer_pct": round((local_cer - global_cer) * 100, 2),
+                        "n_docs_stratum": len(vals),
+                    },
+                    engines_involved=(engine_name,),
+                    stratum=stratum,
+                ))
+    return facts
 
 
 def detect_error_profile_outlier(benchmark_data: dict) -> list[Fact]:
-    """Détecte un profil taxonomique atypique.
+    """Moteur au profil taxonomique atypique.
 
-    Utilise ``engine_reports[*].aggregated_taxonomy`` pour comparer la
-    distribution des 9 classes entre moteurs.
+    Émet un Fact si, pour un moteur et une classe d'erreur, la part relative
+    est au moins 2× plus élevée que la médiane des autres moteurs (et > 15 %
+    du total pour éviter les strates marginales).
     """
-    return []
+    engines = _engines_summary(benchmark_data)
+    # {engine: {class_name: proportion}}
+    profiles: dict[str, dict[str, float]] = {}
+    for e in engines:
+        tax = e.get("aggregated_taxonomy") or {}
+        distribution = tax.get("distribution") or tax.get("proportions") or {}
+        if not distribution:
+            continue
+        profiles[e["name"]] = {k: float(v) for k, v in distribution.items()}
+    if len(profiles) < 2:
+        return []
+
+    # Collecter toutes les classes rencontrées
+    all_classes: set[str] = set()
+    for p in profiles.values():
+        all_classes.update(p.keys())
+
+    facts: list[Fact] = []
+    for cls in all_classes:
+        values = [(name, p.get(cls, 0.0)) for name, p in profiles.items()]
+        props = [v for _, v in values]
+        if not props:
+            continue
+        median_prop = _stats.median(props)
+        for name, v in values:
+            if v < 0.15:  # trop marginal pour être notable
+                continue
+            if median_prop <= 0:
+                continue
+            if v >= 2.0 * median_prop:
+                facts.append(Fact(
+                    type=FactType.ERROR_PROFILE_OUTLIER,
+                    importance=FactImportance.HIGH,
+                    payload={
+                        "engine": name,
+                        "error_class": cls,
+                        "proportion": round(v, 4),
+                        "proportion_pct": round(v * 100, 1),
+                        "median_proportion": round(median_prop, 4),
+                        "median_proportion_pct": round(median_prop * 100, 1),
+                        "ratio_to_median": round(v / median_prop, 2) if median_prop else None,
+                    },
+                    engines_involved=(name,),
+                ))
+    return facts
 
 
 def detect_llm_hallucination_flag(benchmark_data: dict) -> list[Fact]:
-    """Détecte un LLM au taux d'hallucination anormalement élevé.
+    """LLM/VLM au taux d'hallucination notablement élevé.
 
-    Activé par le Sprint 1 (câblage ``aggregated_hallucination``). Lit
-    ``engine_reports[*].aggregated_hallucination.hallucinating_doc_rate`` et
-    émet un Fact si un moteur dépasse significativement la médiane.
-    Implémentation complète Sprint 4.
+    Déclenché si ``hallucinating_doc_rate`` > 30 % OU ``anchor_score_mean`` < 0,6
+    pour un moteur dont le champ ``is_pipeline`` ou ``is_vlm`` est ``True``.
     """
-    return []
+    facts: list[Fact] = []
+    for e in _engines_summary(benchmark_data):
+        agg = e.get("aggregated_hallucination") or {}
+        if not agg:
+            continue
+        rate = agg.get("hallucinating_doc_rate")
+        anchor = agg.get("anchor_score_mean")
+        length_ratio = agg.get("length_ratio_mean")
+        # Signal seulement si c'est un pipeline LLM ou un VLM
+        is_llm = bool(e.get("is_pipeline")) or bool(e.get("is_vlm"))
+        if not is_llm:
+            continue
+
+        flagged = False
+        reasons = []
+        if rate is not None and float(rate) > 0.30:
+            flagged = True
+            reasons.append("taux de documents hallucinés")
+        if anchor is not None and float(anchor) < 0.60:
+            flagged = True
+            reasons.append("ancrage faible")
+        if length_ratio is not None and float(length_ratio) > 1.30:
+            flagged = True
+            reasons.append("sortie anormalement longue")
+        if not flagged:
+            continue
+
+        facts.append(Fact(
+            type=FactType.LLM_HALLUCINATION_FLAG,
+            importance=FactImportance.HIGH,
+            payload={
+                "engine": e["name"],
+                "hallucinating_rate": round(float(rate or 0.0), 4),
+                "hallucinating_rate_pct": round(float(rate or 0.0) * 100, 1),
+                "anchor_score": round(float(anchor), 3) if anchor is not None else None,
+                "length_ratio": round(float(length_ratio), 3) if length_ratio is not None else None,
+                "reasons": reasons,
+                "reasons_list": ", ".join(reasons),
+            },
+            engines_involved=(e["name"],),
+        ))
+    return facts
 
 
 def detect_robustness_fragile(benchmark_data: dict) -> list[Fact]:
-    """Détecte un moteur qui dégrade fortement au-dessus d'un seuil de bruit."""
-    return []
+    """Moteur qui dégrade fortement au-dessus d'un seuil de bruit/flou.
 
+    Activé si les données de robustesse sont embarquées dans
+    ``benchmark_data["robustness"]`` (hors scope du benchmark classique,
+    produit par ``picarones robustness`` et injecté optionnellement).
+    """
+    robustness = benchmark_data.get("robustness")
+    if not robustness:
+        return []
 
-def detect_cost_outlier(benchmark_data: dict) -> list[Fact]:
-    """Détecte un moteur au ratio coût/qualité très défavorable.
+    facts: list[Fact] = []
+    curves = robustness.get("curves") or robustness.get("engines") or []
+    # Structure attendue : [{engine, degradation_type, points: [{level, cer}]}]
+    # Flag : CER à niveau max > 3× CER au niveau min.
+    for entry in curves:
+        engine = entry.get("engine")
+        dtype = entry.get("degradation_type")
+        points = entry.get("points") or []
+        if not engine or not points or len(points) < 2:
+            continue
+        try:
+            sorted_pts = sorted(points, key=lambda p: float(p["level"]))
+        except (KeyError, TypeError, ValueError):
+            continue
+        first, last = sorted_pts[0], sorted_pts[-1]
+        c0 = float(first.get("cer") or 0.0)
+        c1 = float(last.get("cer") or 0.0)
+        if c0 <= 0.01:  # éviter division par quasi-zéro
+            continue
+        if c1 >= 3.0 * c0 and c1 > 0.15:
+            facts.append(Fact(
+                type=FactType.ROBUSTNESS_FRAGILE,
+                importance=FactImportance.HIGH,
+                payload={
+                    "engine": engine,
+                    "degradation": dtype,
+                    "cer_baseline": round(c0, 4),
+                    "cer_baseline_pct": round(c0 * 100, 1),
+                    "cer_degraded": round(c1, 4),
+                    "cer_degraded_pct": round(c1 * 100, 1),
+                    "ratio": round(c1 / c0, 1),
+                    "level_max": float(last.get("level") or 0),
+                },
+                engines_involved=(engine,),
+            ))
+    return facts
 
-    Implémentation Sprint 5.
-    """
+
+def detect_cost_outlier(benchmark_data: dict) -> list[Fact]:
+    """Moteur au ratio coût/qualité très défavorable. Sprint 5."""
     return []
 
 
+def _mean_duration_per_engine(benchmark_data: dict) -> dict[str, float]:
+    """Durée moyenne d'exécution par moteur (en secondes par document)."""
+    durations: dict[str, list[float]] = {}
+    for doc in benchmark_data.get("documents") or []:
+        for er in doc.get("engine_results") or []:
+            d = er.get("duration")
+            if d is None:
+                continue
+            durations.setdefault(er["engine"], []).append(float(d))
+    return {k: sum(v) / len(v) for k, v in durations.items() if v}
+
+
 def detect_speed_winner(benchmark_data: dict) -> list[Fact]:
-    """Détecte un moteur significativement plus rapide pour qualité comparable."""
-    return []
+    """Moteur significativement plus rapide pour une qualité comparable.
+
+    Déclenché si un moteur est au moins 3× plus rapide que la médiane ET que
+    son CER n'est pas significativement pire (dans le même groupe Nemenyi que
+    le leader OU CER ≤ 1,1 × CER du leader).
+    """
+    durations = _mean_duration_per_engine(benchmark_data)
+    if len(durations) < 2:
+        return []
+
+    values = list(durations.values())
+    median_dur = _stats.median(values)
+    if median_dur <= 0:
+        return []
+
+    ranking = benchmark_data.get("ranking") or []
+    valid = [r for r in ranking if r.get("mean_cer") is not None]
+    if not valid:
+        return []
+    leader_cer = float(valid[0]["mean_cer"])
+    quality_ceiling = max(0.01, leader_cer * 1.10)
+
+    tied_groups = benchmark_data.get("statistics", {}).get("nemenyi", {}).get("tied_groups") or []
+    leader_group: set[str] = set()
+    for g in tied_groups:
+        if valid[0]["engine"] in g:
+            leader_group = set(g)
+            break
+
+    facts: list[Fact] = []
+    candidates = sorted(durations.items(), key=lambda kv: kv[1])
+    for engine, dur in candidates:
+        if dur * 3.0 > median_dur:
+            break  # les suivants sont encore plus lents
+        summary = _engine_by_name(benchmark_data, engine) or {}
+        engine_cer = summary.get("cer")
+        if engine_cer is None:
+            continue
+        acceptable_quality = (
+            engine in leader_group or float(engine_cer) <= quality_ceiling
+        )
+        if not acceptable_quality:
+            continue
+        facts.append(Fact(
+            type=FactType.SPEED_WINNER,
+            importance=FactImportance.MEDIUM,
+            payload={
+                "engine": engine,
+                "mean_duration": round(dur, 3),
+                "median_duration": round(median_dur, 3),
+                "speedup": round(median_dur / dur, 1) if dur > 0 else None,
+                "cer": round(float(engine_cer), 4),
+                "cer_pct": round(float(engine_cer) * 100, 2),
+            },
+            engines_involved=(engine,),
+        ))
+    return facts[:1]  # seulement le plus rapide — éviter le bruit
 
 
 def detect_confidence_warning(benchmark_data: dict) -> list[Fact]:
-    """Détecte un intervalle de confiance très large → classement peu fiable."""
-    return []
+    """Intervalle de confiance large → classement peu fiable.
+
+    Déclenché si, pour le leader ou le runner-up, la largeur de l'IC 95 %
+    est plus du triple de l'écart |leader − runner-up| OU > 5 points de CER.
+    """
+    stats = benchmark_data.get("statistics", {}) or {}
+    cis = stats.get("bootstrap_cis") or []
+    if len(cis) < 2:
+        return []
+
+    ranking = benchmark_data.get("ranking") or []
+    valid = [r for r in ranking if r.get("mean_cer") is not None]
+    if len(valid) < 2:
+        return []
+
+    by_name = {c["engine"]: c for c in cis if "engine" in c}
+    leader = valid[0]["engine"]
+    runner_up = valid[1]["engine"]
+    leader_ci = by_name.get(leader)
+    runner_ci = by_name.get(runner_up)
+    if not leader_ci or not runner_ci:
+        return []
+
+    gap = abs(float(valid[0]["mean_cer"]) - float(valid[1]["mean_cer"]))
+    facts: list[Fact] = []
+    for engine_name, ci in ((leader, leader_ci), (runner_up, runner_ci)):
+        lo = float(ci.get("ci_lower") or 0.0)
+        hi = float(ci.get("ci_upper") or 0.0)
+        width = hi - lo
+        wide_vs_gap = gap > 0 and width > 3.0 * gap
+        wide_absolute = width > 0.05
+        if wide_vs_gap or wide_absolute:
+            facts.append(Fact(
+                type=FactType.CONFIDENCE_WARNING,
+                importance=FactImportance.MEDIUM,
+                payload={
+                    "engine": engine_name,
+                    "ci_lower": round(lo, 4),
+                    "ci_upper": round(hi, 4),
+                    "ci_width": round(width, 4),
+                    "ci_width_pct": round(width * 100, 2),
+                    "mean_cer": round(float(ci.get("mean") or 0.0), 4),
+                    "mean_cer_pct": round(float(ci.get("mean") or 0.0) * 100, 2),
+                    "gap_to_runner_up_pct": round(gap * 100, 2),
+                },
+                engines_involved=(engine_name,),
+            ))
+            break  # un seul avertissement suffit
+    return facts
 
 
 # ---------------------------------------------------------------------------
-# Enregistrement par défaut — à activer sprint par sprint
+# Enregistrement par défaut — activé au Sprint 4
 # ---------------------------------------------------------------------------
 
 DETECTORS_BY_TYPE = {
@@ -156,7 +576,14 @@ DETECTORS_BY_TYPE = {
     FactType.SPEED_WINNER: detect_speed_winner,
     FactType.CONFIDENCE_WARNING: detect_confidence_warning,
 }
-"""Table de correspondance ``FactType → détecteur``. L'enregistrement effectif
-dans le registre par défaut sera activé au Sprint 4 quand les implémentations
-seront prêtes. Pour Sprint 1, garder le registre par défaut vide évite que des
-stubs polluent la synthèse."""
+
+
+def register_default_detectors(registry) -> None:
+    """Enregistre les détecteurs du Sprint 4 dans un ``DetectorRegistry``.
+
+    Les types ``PARETO_ALTERNATIVE`` et ``COST_OUTLIER`` restent des stubs
+    jusqu'au Sprint 5 : les enregistrer maintenant ne fait rien de visible
+    (liste vide toujours retournée), ce qui est sûr et simplifie le parcours.
+    """
+    for fact_type, fn in DETECTORS_BY_TYPE.items():
+        registry.register(fact_type, fn)

picarones/core/narrative/renderer.py

@@ -0,0 +1,105 @@
+"""Rendu des faits narratifs en texte lisible.
+
+Les templates sont chargés depuis ``templates/{lang}.yaml`` au premier accès.
+Le rendu utilise ``str.format_map`` sur le ``payload`` du ``Fact``. Aucun LLM,
+aucune génération : la sortie est la concaténation de templates remplis avec
+des valeurs venant strictement du JSON d'entrée.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from pathlib import Path
+from typing import Iterable
+
+import yaml
+
+from picarones.core.narrative.facts import Fact, FactType
+
+logger = logging.getLogger(__name__)
+
+_TEMPLATES_DIR = Path(__file__).parent / "templates"
+_TEMPLATES_CACHE: dict[str, dict[str, str]] = {}
+
+
+def _load_templates(lang: str) -> dict[str, str]:
+    """Charge et met en cache les templates de la langue demandée.
+
+    Fallback : si la langue n'existe pas, retourne les templates FR. Si FR
+    est également absent (incident d'installation), retourne un dict vide.
+    """
+    if lang in _TEMPLATES_CACHE:
+        return _TEMPLATES_CACHE[lang]
+
+    path = _TEMPLATES_DIR / f"{lang}.yaml"
+    if not path.exists():
+        if lang != "fr":
+            return _load_templates("fr")
+        _TEMPLATES_CACHE[lang] = {}
+        return _TEMPLATES_CACHE[lang]
+
+    try:
+        with path.open(encoding="utf-8") as fh:
+            data = yaml.safe_load(fh) or {}
+        if not isinstance(data, dict):
+            logger.warning("[narrative] %s n'est pas un dict YAML — ignoré", path)
+            _TEMPLATES_CACHE[lang] = {}
+        else:
+            _TEMPLATES_CACHE[lang] = {str(k): str(v).strip() for k, v in data.items()}
+    except yaml.YAMLError as e:
+        logger.warning("[narrative] échec parsing %s : %s", path, e)
+        _TEMPLATES_CACHE[lang] = {}
+
+    return _TEMPLATES_CACHE[lang]
+
+
+class _SafeFormatMap(dict):
+    """Dict qui retourne ``'?'`` pour les clés manquantes dans un template.
+
+    Évite qu'un détecteur mal documenté fasse crasher le rendu. En pratique
+    les tests couvrent les clés attendues, mais la robustesse prévaut.
+    """
+
+    def __missing__(self, key: str) -> str:
+        logger.warning("[narrative] clé manquante dans payload : %r", key)
+        return "?"
+
+
+def render_fact(fact: Fact, lang: str = "fr") -> str:
+    """Rend un Fact en une phrase selon la langue.
+
+    Retourne ``""`` si le template est absent pour ce type.
+    """
+    templates = _load_templates(lang)
+    tpl = templates.get(fact.type.value)
+    if not tpl:
+        return ""
+
+    try:
+        return tpl.format_map(_SafeFormatMap(fact.payload))
+    except (ValueError, KeyError) as e:
+        logger.warning(
+            "[narrative] rendu impossible pour %s : %s", fact.type.value, e,
+        )
+        return ""
+
+
+def render_synthesis(facts: Iterable[Fact], lang: str = "fr") -> list[str]:
+    """Rend une liste de Fact en liste de phrases (ordre préservé)."""
+    out: list[str] = []
+    for fact in facts:
+        phrase = render_fact(fact, lang)
+        phrase = re.sub(r"\s+", " ", phrase).strip()
+        if phrase:
+            out.append(phrase)
+    return out
+
+
+def extract_numbers(text: str) -> list[str]:
+    """Extrait les nombres (décimaux ou entiers) présents dans une phrase.
+
+    Utilisé par le test de traçabilité : chaque nombre remonté en synthèse
+    doit être présent dans le JSON d'entrée.
+    """
+    return re.findall(r"\d+(?:[.,]\d+)?", text)

picarones/core/narrative/templates/en.yaml

@@ -0,0 +1,46 @@
+# Narrative rendering templates — English.
+# Anti-hallucination rule: never introduce a number or entity name that is not
+# already in the Fact ``payload``. Tests verify traceability of every number
+# appearing in the rendered synthesis.
+
+global_leader_cer: >-
+  On this corpus of {n_docs} documents, {engine} achieves the lowest mean CER
+  ({cer_pct} %).
+
+statistical_tie: >-
+  Engines {engines_list} are not statistically distinguishable
+  (Friedman-Nemenyi, α = {alpha}, n = {n_blocks} documents, CD = {critical_distance}).
+
+significant_gap: >-
+  The gap between {leader} and {runner_up} is statistically significant
+  (Wilcoxon, p = {p_value:.4f}, Δ CER = {delta_cer_pct} points over {n_pairs} pairs).
+
+stratum_winner: >-
+  On stratum "{stratum}" ({n_docs_stratum} documents), {engine} clearly
+  dominates with a CER of {cer_pct} % vs. {second_cer_pct} % for {second_engine}.
+
+stratum_collapse: >-
+  {engine} is globally competitive ({global_cer_pct} %) but collapses on
+  stratum "{stratum}" ({local_cer_pct} % over {n_docs_stratum} documents,
+  i.e. {delta_cer_pct} points above its own average).
+
+error_profile_outlier: >-
+  {engine} has an atypical error profile: {proportion_pct} % of errors fall
+  into class "{error_class}", vs. a median of {median_proportion_pct} % across
+  other engines (×{ratio_to_median} the median).
+
+llm_hallucination_flag: >-
+  Hallucination signal on {engine} ({reasons_list}) —
+  {hallucinating_rate_pct} % of documents above alert thresholds.
+
+robustness_fragile: >-
+  {engine} is fragile under "{degradation}" degradation: its CER rises from
+  {cer_baseline_pct} % to {cer_degraded_pct} % at maximum level (×{ratio}).
+
+speed_winner: >-
+  {engine} is the fastest ({mean_duration} s/doc, ×{speedup} faster than the
+  median) for comparable quality (CER {cer_pct} %).
+
+confidence_warning: >-
+  Ranking is fragile: the 95 % confidence interval of {engine} spans
+  {ci_width_pct} CER points, compared with a gap of {gap_to_runner_up_pct} points to the runner-up.

picarones/core/narrative/templates/fr.yaml

@@ -0,0 +1,50 @@
+# Templates de rendu narratif — français.
+#
+# Chaque clé correspond à une valeur de ``FactType``. La valeur est un template
+# Python ``.format()`` qui consomme les champs du ``Fact.payload``.
+#
+# Règle anti-hallucination : n'introduire aucune valeur numérique ou nom
+# d'entité qui ne soit pas dans le ``payload``. Les tests parsent la synthèse
+# rendue et vérifient la traçabilité.
+
+global_leader_cer: >-
+  Sur ce corpus de {n_docs} documents, {engine} obtient le CER moyen le plus
+  bas ({cer_pct} %).
+
+statistical_tie: >-
+  Les moteurs {engines_list} ne sont pas statistiquement distinguables
+  (Friedman-Nemenyi, α = {alpha}, n = {n_blocks} documents, CD = {critical_distance}).
+
+significant_gap: >-
+  L'écart entre {leader} et {runner_up} est statistiquement significatif
+  (Wilcoxon, p = {p_value:.4f}, Δ CER = {delta_cer_pct} points sur {n_pairs} paires).
+
+stratum_winner: >-
+  Sur la strate « {stratum} » ({n_docs_stratum} documents), {engine} domine
+  nettement avec un CER de {cer_pct} % contre {second_cer_pct} % pour {second_engine}.
+
+stratum_collapse: >-
+  {engine} est globalement compétitif ({global_cer_pct} %) mais s'effondre sur
+  la strate « {stratum} » ({local_cer_pct} % sur {n_docs_stratum} documents,
+  soit {delta_cer_pct} points au-dessus de sa moyenne).
+
+error_profile_outlier: >-
+  Le profil d'erreurs de {engine} est atypique : {proportion_pct} % de la
+  classe « {error_class} », contre une médiane de {median_proportion_pct} %
+  sur les autres moteurs (ratio ×{ratio_to_median}).
+
+llm_hallucination_flag: >-
+  Signal d'hallucination sur {engine} ({reasons_list}) —
+  {hallucinating_rate_pct} % de documents au-dessus des seuils d'alerte.
+
+robustness_fragile: >-
+  {engine} est fragile à la dégradation « {degradation} » : son CER passe de
+  {cer_baseline_pct} % à {cer_degraded_pct} % au niveau maximal (ratio ×{ratio}).
+
+speed_winner: >-
+  {engine} est le plus rapide ({mean_duration} s / doc, ×{speedup} plus vite
+  que la médiane) pour un CER comparable ({cer_pct} %).
+
+confidence_warning: >-
+  Classement fragile : l'intervalle de confiance à 95 % de {engine} s'étend
+  sur {ci_width_pct} points de CER, à comparer à l'écart de {gap_to_runner_up_pct} points avec le second.

picarones/report/generator.py

@@ -495,14 +495,16 @@ _TEMPLATES_DIR = Path(__file__).parent / "templates"
 def _build_jinja_env():
     """Construit l'Environment Jinja2 pour le rapport.
 
-    Import différé : jinja2 est une dépendance runtime depuis le Sprint 16,
-    mais le différer évite un coût d'import si le module est chargé sans
-    qu'aucun rapport ne soit effectivement généré.
+    Autoescape désactivé : le comportement est équivalent à celui du
+    ``_HTML_TEMPLATE.format()`` historique. Les variables injectées
+    (JSON embarqué, SVG généré, synthèse narrative issue de templates
+    internes) sont toutes produites par le code Picarones et ne nécessitent
+    pas d'échappement HTML.
     """
-    from jinja2 import Environment, FileSystemLoader, select_autoescape
+    from jinja2 import Environment, FileSystemLoader
     env = Environment(
         loader=FileSystemLoader(str(_TEMPLATES_DIR)),
-        autoescape=select_autoescape(disabled_extensions=("j2", "html", "css", "js")),
+        autoescape=False,
         keep_trailing_newline=True,
     )
     return env
@@ -584,6 +586,10 @@ class ReportGenerator:
             report_data.get("statistics", {}).get("nemenyi", {}),
         )
 
+        # Sprint 18 — synthèse factuelle narrative (déterministe, sans LLM)
+        from picarones.core.narrative import build_synthesis
+        synthesis = build_synthesis(report_data, lang=self.lang)
+
         env = _build_jinja_env()
         template = env.get_template("base.html.j2")
         html = template.render(
@@ -595,6 +601,7 @@ class ReportGenerator:
             chartjs_inline=chartjs_js,
             critical_difference_svg=cdd_svg,
             friedman=report_data.get("statistics", {}).get("friedman", {}),
+            synthesis=synthesis,
         )
 
         output_path.write_text(html, encoding="utf-8")

picarones/report/i18n/en.json

@@ -97,6 +97,8 @@
   "ratio_anchor_note": "X-axis = trigram anchor score [0–1]. Y-axis = output/GT length ratio. ⚠️ Zone: anchor < 0.5 or ratio > 1.2 → probable hallucinations.",
   "ratio_anchor_subtitle": "— VLM hallucinations",
   "reliability_note": "For the X% easiest documents (sorted by ascending CER), what is the cumulative mean CER? A low curve = engine performing well even on easy documents.",
+  "synth_hint": "Generated mechanically from results — no LLM, reproducible.",
+  "synth_title": "Factual summary",
   "tab_analyses": "Analyses",
   "tab_characters": "Characters",
   "tab_document": "Document",

picarones/report/i18n/fr.json

@@ -97,6 +97,8 @@
   "ratio_anchor_note": "Axe X = score d'ancrage trigrammes [0–1]. Axe Y = ratio longueur sortie/GT. Zone ⚠️ : ancrage < 0.5 ou ratio > 1.2 → hallucinations probables.",
   "ratio_anchor_subtitle": "— hallucinations VLM",
   "reliability_note": "Pour les X% documents les plus faciles (triés par CER croissant), quel est le CER moyen cumulé ? Une courbe basse = moteur performant même sur les documents faciles.",
+  "synth_hint": "Générée mécaniquement depuis les résultats — aucun LLM, reproductible.",
+  "synth_title": "Synthèse factuelle",
   "tab_analyses": "Analyses",
   "tab_characters": "Caractères",
   "tab_document": "Document",

picarones/report/templates/_narrative_summary.html

@@ -0,0 +1,16 @@
+<!-- ── Synthèse factuelle (Sprint 18) ─────────────────────────────── -->
+{% if synthesis and synthesis.sentences %}
+<section class="synth-card" aria-labelledby="synth-title">
+  <header class="synth-header">
+    <h2 id="synth-title" data-i18n="synth_title">Synthèse factuelle</h2>
+    <span class="synth-hint" data-i18n="synth_hint">
+      Générée mécaniquement depuis les résultats — aucun LLM, reproductible.
+    </span>
+  </header>
+  <ul class="synth-list">
+    {% for sentence in synthesis.sentences %}
+    <li>{{ sentence }}</li>
+    {% endfor %}
+  </ul>
+</section>
+{% endif %}

picarones/report/templates/_styles.css

@@ -632,3 +632,40 @@ body.present-mode nav .meta { display: none; }
 
 body.present-mode .cdd-info-btn,
 body.present-mode .cdd-help { display: none !important; }
+
+/* ── Sprint 18 — Synthèse factuelle narrative ──────────────────── */
+.synth-card {
+  background: var(--panel, #fff);
+  border: 1px solid var(--border, #e2e8f0);
+  border-left: 4px solid #2563eb;
+  border-radius: 8px;
+  padding: 1rem 1.5rem 1.25rem;
+  margin: 1rem 1.5rem 0;
+}
+.synth-header {
+  display: flex; align-items: baseline; gap: .75rem;
+  margin-bottom: .5rem;
+  flex-wrap: wrap;
+}
+.synth-header h2 {
+  margin: 0;
+  font-size: 1rem;
+  font-weight: 600;
+  color: var(--text, #0f172a);
+}
+.synth-hint {
+  font-size: .75rem;
+  color: var(--text-muted, #64748b);
+  font-style: italic;
+}
+.synth-list {
+  margin: 0;
+  padding-left: 1.25rem;
+  line-height: 1.5;
+  font-size: .92rem;
+  color: var(--text, #0f172a);
+}
+.synth-list li { margin: .25rem 0; }
+.synth-list li::marker { color: #2563eb; }
+
+body.present-mode .synth-hint { display: none; }

picarones/report/templates/base.html.j2

@@ -17,6 +17,8 @@
 
 {% include '_header.html' %}
 
+{% include '_narrative_summary.html' %}
+
 {% include '_critical_difference.html' %}
 
 {% include 'view_ranking.html' %}

pyproject.toml

@@ -86,6 +86,7 @@ picarones = [
     "report/templates/*.css",
     "report/templates/*.js",
     "report/i18n/*.json",
+    "core/narrative/templates/*.yaml",
 ]
 
 [tool.pytest.ini_options]

tests/test_sprint19_narrative_engine.py

@@ -0,0 +1,597 @@
+"""Tests Sprint 19 — Moteur narratif complet (détecteurs + arbitre + rendu).
+
+Sprint 4 du plan rapport. Couvre :
+  1. Les 9 détecteurs implémentés (scénarios canoniques + cas vides).
+  2. L'arbitre : tri par importance, non-redondance, contradiction Nemenyi/Wilcoxon.
+  3. Le renderer : chargement des templates YAML, déterminisme.
+  4. Le garde-fou anti-hallucination : tout nombre rendu existe dans le JSON.
+  5. L'intégration au rapport HTML (section synthèse, reproductibilité).
+"""
+
+from __future__ import annotations
+
+import hashlib
+import re
+
+import pytest
+
+from picarones.core.narrative import (
+    DetectorRegistry,
+    Fact,
+    FactImportance,
+    FactType,
+    build_synthesis,
+    detect_all,
+    extract_numbers,
+    register_default_detectors,
+    render_fact,
+    render_synthesis,
+    select_facts,
+)
+from picarones.core.narrative.detectors import (
+    detect_confidence_warning,
+    detect_error_profile_outlier,
+    detect_global_leader_cer,
+    detect_llm_hallucination_flag,
+    detect_robustness_fragile,
+    detect_significant_gap,
+    detect_speed_winner,
+    detect_statistical_tie,
+    detect_stratum_collapse,
+    detect_stratum_winner,
+)
+
+
+# ---------------------------------------------------------------------------
+# Fixtures — données de benchmark minimales et contrôlées
+# ---------------------------------------------------------------------------
+
+def _minimal_data(**overrides) -> dict:
+    base = {
+        "meta": {"document_count": 10},
+        "ranking": [
+            {"engine": "A", "mean_cer": 0.05, "mean_wer": 0.15, "documents": 10, "failed": 0},
+            {"engine": "B", "mean_cer": 0.12, "mean_wer": 0.25, "documents": 10, "failed": 0},
+            {"engine": "C", "mean_cer": 0.30, "mean_wer": 0.50, "documents": 10, "failed": 0},
+        ],
+        "engines": [
+            {"name": "A", "cer": 0.05, "wer": 0.15, "is_pipeline": False, "is_vlm": False},
+            {"name": "B", "cer": 0.12, "wer": 0.25, "is_pipeline": False, "is_vlm": False},
+            {"name": "C", "cer": 0.30, "wer": 0.50, "is_pipeline": False, "is_vlm": False},
+        ],
+        "documents": [],
+        "statistics": {
+            "pairwise_wilcoxon": [],
+            "bootstrap_cis": [],
+            "friedman": {},
+            "nemenyi": {"tied_groups": [], "mean_ranks": {}, "critical_distance": 0.0},
+        },
+    }
+    base.update(overrides)
+    return base
+
+
+# ---------------------------------------------------------------------------
+# Détecteurs individuels
+# ---------------------------------------------------------------------------
+
+class TestGlobalLeaderCer:
+    def test_emits_fact_with_cer_pct_and_n_docs(self):
+        facts = detect_global_leader_cer(_minimal_data())
+        assert len(facts) == 1
+        f = facts[0]
+        assert f.type == FactType.GLOBAL_LEADER_CER
+        assert f.importance == FactImportance.CRITICAL
+        assert f.payload["engine"] == "A"
+        assert f.payload["cer_pct"] == 5.0
+        assert f.payload["n_docs"] == 10
+        assert f.payload["runner_up"] == "B"
+
+    def test_empty_when_no_ranking(self):
+        assert detect_global_leader_cer(_minimal_data(ranking=[])) == []
+
+
+class TestSignificantGap:
+    def test_emits_when_leader_vs_runnerup_is_significant(self):
+        data = _minimal_data(statistics={
+            "pairwise_wilcoxon": [
+                {"engine_a": "A", "engine_b": "B", "p_value": 0.002,
+                 "significant": True, "n_pairs": 10},
+            ],
+            "bootstrap_cis": [], "friedman": {},
+            "nemenyi": {"tied_groups": [], "mean_ranks": {}},
+        })
+        facts = detect_significant_gap(data)
+        assert len(facts) == 1
+        assert facts[0].payload["leader"] == "A"
+        assert facts[0].payload["runner_up"] == "B"
+        assert facts[0].payload["p_value"] == pytest.approx(0.002)
+
+    def test_empty_when_not_significant(self):
+        data = _minimal_data(statistics={
+            "pairwise_wilcoxon": [
+                {"engine_a": "A", "engine_b": "B", "p_value": 0.4,
+                 "significant": False, "n_pairs": 10},
+            ],
+            "bootstrap_cis": [], "friedman": {},
+            "nemenyi": {"tied_groups": [], "mean_ranks": {}},
+        })
+        assert detect_significant_gap(data) == []
+
+
+class TestStatisticalTie:
+    def test_emits_for_each_tied_group(self):
+        data = _minimal_data(statistics={
+            "pairwise_wilcoxon": [],
+            "bootstrap_cis": [],
+            "friedman": {},
+            "nemenyi": {
+                "tied_groups": [["A", "B"], ["C"]],
+                "mean_ranks": {"A": 1.2, "B": 1.5, "C": 3.0},
+                "critical_distance": 0.8,
+                "alpha": 0.05,
+                "n_blocks": 10,
+            },
+        })
+        facts = detect_statistical_tie(data)
+        assert len(facts) == 1
+        assert set(facts[0].engines_involved) == {"A", "B"}
+        assert facts[0].payload["includes_leader"] is True
+
+
+class TestErrorProfileOutlier:
+    def test_flags_engine_with_atypical_profile(self):
+        engines = [
+            {"name": "A", "aggregated_taxonomy": {"distribution": {"visual_confusion": 0.50, "abbreviation_error": 0.10}}},
+            {"name": "B", "aggregated_taxonomy": {"distribution": {"visual_confusion": 0.20, "abbreviation_error": 0.10}}},
+            {"name": "C", "aggregated_taxonomy": {"distribution": {"visual_confusion": 0.15, "abbreviation_error": 0.10}}},
+        ]
+        data = _minimal_data(engines=engines)
+        facts = detect_error_profile_outlier(data)
+        flagged = [f for f in facts if f.payload["engine"] == "A"]
+        assert flagged
+        assert flagged[0].payload["error_class"] == "visual_confusion"
+
+    def test_empty_when_no_taxonomy(self):
+        assert detect_error_profile_outlier(_minimal_data()) == []
+
+
+class TestLlmHallucinationFlag:
+    def test_flags_pipeline_with_high_rate(self):
+        engines = [
+            {"name": "tesseract", "aggregated_hallucination": {"hallucinating_doc_rate": 0.05},
+             "is_pipeline": False, "is_vlm": False},
+            {"name": "gpt-4o", "aggregated_hallucination": {
+                "hallucinating_doc_rate": 0.45, "anchor_score_mean": 0.55, "length_ratio_mean": 1.4},
+             "is_pipeline": True, "is_vlm": True},
+        ]
+        data = _minimal_data(engines=engines)
+        facts = detect_llm_hallucination_flag(data)
+        assert len(facts) == 1
+        assert facts[0].payload["engine"] == "gpt-4o"
+        assert facts[0].payload["hallucinating_rate_pct"] == 45.0
+
+    def test_ignores_non_llm_engines(self):
+        engines = [
+            {"name": "tesseract", "aggregated_hallucination": {"hallucinating_doc_rate": 0.9},
+             "is_pipeline": False, "is_vlm": False},
+        ]
+        data = _minimal_data(engines=engines)
+        assert detect_llm_hallucination_flag(data) == []
+
+
+class TestStratumDetectors:
+    def _docs_with_strata(self):
+        # 6 docs — 3 en "gothique", 3 en "humaniste"
+        # Engine A est super bon en humaniste, moyen en gothique
+        # Engine B est moyen partout
+        docs = []
+        for i in range(3):
+            docs.append({
+                "doc_id": f"goth{i}",
+                "script_type": "gothique",
+                "engine_results": [
+                    {"engine": "A", "cer": 0.12, "error": None},
+                    {"engine": "B", "cer": 0.15, "error": None},
+                ],
+            })
+        for i in range(3):
+            docs.append({
+                "doc_id": f"hum{i}",
+                "script_type": "humaniste",
+                "engine_results": [
+                    {"engine": "A", "cer": 0.02, "error": None},
+                    {"engine": "B", "cer": 0.10, "error": None},
+                ],
+            })
+        return docs
+
+    def test_stratum_winner_detected(self):
+        docs = self._docs_with_strata()
+        engines = [{"name": "A", "cer": 0.07}, {"name": "B", "cer": 0.12}]
+        data = _minimal_data(documents=docs, engines=engines)
+        facts = detect_stratum_winner(data)
+        humanist = [f for f in facts if f.stratum == "humaniste"]
+        assert humanist
+        assert humanist[0].payload["engine"] == "A"
+
+    def test_stratum_collapse_detected(self):
+        # Engine A globalement bon (0.05) mais s'effondre sur "cursive" (0.30)
+        docs = []
+        for i in range(5):
+            docs.append({
+                "doc_id": f"good{i}",
+                "script_type": "textualis",
+                "engine_results": [{"engine": "A", "cer": 0.04, "error": None}],
+            })
+        for i in range(3):
+            docs.append({
+                "doc_id": f"bad{i}",
+                "script_type": "cursive",
+                "engine_results": [{"engine": "A", "cer": 0.30, "error": None}],
+            })
+        engines = [{"name": "A", "cer": 0.10}]
+        data = _minimal_data(documents=docs, engines=engines)
+        facts = detect_stratum_collapse(data)
+        assert any(f.stratum == "cursive" for f in facts)
+
+
+class TestSpeedWinner:
+    def test_detects_fast_engine_with_comparable_quality(self):
+        # "fast" est 50× plus rapide ET n'est qu'à 6 % de CER en plus du leader
+        # (dans la marge de tolérance de qualité du détecteur).
+        docs = []
+        for i in range(5):
+            docs.append({
+                "doc_id": f"d{i}",
+                "engine_results": [
+                    {"engine": "fast", "cer": 0.053, "error": None, "duration": 0.1},
+                    {"engine": "slow", "cer": 0.050, "error": None, "duration": 5.0},
+                ],
+            })
+        engines = [{"name": "fast", "cer": 0.053}, {"name": "slow", "cer": 0.050}]
+        ranking = [
+            {"engine": "slow", "mean_cer": 0.050, "documents": 5, "failed": 0},
+            {"engine": "fast", "mean_cer": 0.053, "documents": 5, "failed": 0},
+        ]
+        data = _minimal_data(documents=docs, engines=engines, ranking=ranking)
+        facts = detect_speed_winner(data)
+        assert facts, "speed_winner devrait détecter un moteur 50× plus rapide"
+        assert facts[0].payload["engine"] == "fast"
+        assert facts[0].payload["speedup"] >= 3.0
+
+    def test_ignores_fast_engine_with_bad_quality(self):
+        # "fast" est rapide mais a un CER 3× celui du leader — pas un speed winner
+        docs = [{
+            "doc_id": f"d{i}",
+            "engine_results": [
+                {"engine": "fast", "cer": 0.15, "error": None, "duration": 0.1},
+                {"engine": "slow", "cer": 0.05, "error": None, "duration": 5.0},
+            ],
+        } for i in range(5)]
+        engines = [{"name": "fast", "cer": 0.15}, {"name": "slow", "cer": 0.05}]
+        ranking = [
+            {"engine": "slow", "mean_cer": 0.05, "documents": 5, "failed": 0},
+            {"engine": "fast", "mean_cer": 0.15, "documents": 5, "failed": 0},
+        ]
+        data = _minimal_data(documents=docs, engines=engines, ranking=ranking)
+        assert detect_speed_winner(data) == []
+
+
+class TestConfidenceWarning:
+    def test_wide_ci_triggers_warning(self):
+        cis = [
+            {"engine": "A", "mean": 0.05, "ci_lower": 0.01, "ci_upper": 0.25},
+            {"engine": "B", "mean": 0.12, "ci_lower": 0.08, "ci_upper": 0.16},
+        ]
+        data = _minimal_data(statistics={
+            "pairwise_wilcoxon": [], "bootstrap_cis": cis,
+            "friedman": {}, "nemenyi": {"tied_groups": [], "mean_ranks": {}},
+        })
+        facts = detect_confidence_warning(data)
+        assert len(facts) == 1
+        assert facts[0].payload["engine"] == "A"
+
+
+class TestRobustnessFragile:
+    def test_detects_collapse_under_high_degradation(self):
+        data = _minimal_data(robustness={
+            "curves": [
+                {"engine": "X", "degradation_type": "noise", "points": [
+                    {"level": 0, "cer": 0.05},
+                    {"level": 80, "cer": 0.40},
+                ]},
+                {"engine": "Y", "degradation_type": "noise", "points": [
+                    {"level": 0, "cer": 0.05},
+                    {"level": 80, "cer": 0.08},
+                ]},
+            ],
+        })
+        facts = detect_robustness_fragile(data)
+        names = {f.payload["engine"] for f in facts}
+        assert "X" in names
+        assert "Y" not in names
+
+
+# ---------------------------------------------------------------------------
+# Arbitre
+# ---------------------------------------------------------------------------
+
+class TestArbiter:
+    def _fact(self, t, imp=FactImportance.HIGH, engines=("A",), stratum=None, payload=None):
+        return Fact(type=t, importance=imp, payload=payload or {},
+                    engines_involved=tuple(engines), stratum=stratum)
+
+    def test_sort_by_importance_descending(self):
+        f1 = self._fact(FactType.SPEED_WINNER, imp=FactImportance.MEDIUM)
+        f2 = self._fact(FactType.GLOBAL_LEADER_CER, imp=FactImportance.CRITICAL, engines=("B",))
+        selected = select_facts([f1, f2])
+        assert selected[0].type == FactType.GLOBAL_LEADER_CER
+
+    def test_max_facts_limit(self):
+        facts = [self._fact(FactType.ERROR_PROFILE_OUTLIER, engines=(f"E{i}",)) for i in range(10)]
+        selected = select_facts(facts, max_facts=3)
+        assert len(selected) == 3
+
+    def test_deduplicates_same_engine_same_type(self):
+        f1 = self._fact(FactType.ERROR_PROFILE_OUTLIER, engines=("A",), payload={"x": 1})
+        f2 = self._fact(FactType.ERROR_PROFILE_OUTLIER, engines=("A",), payload={"x": 2})
+        selected = select_facts([f1, f2])
+        assert len(selected) == 1
+
+    def test_keeps_complementary_facts_for_same_engine(self):
+        leader = self._fact(FactType.GLOBAL_LEADER_CER, imp=FactImportance.CRITICAL, engines=("A",))
+        gap = self._fact(FactType.SIGNIFICANT_GAP, imp=FactImportance.CRITICAL, engines=("A", "B"))
+        selected = select_facts([leader, gap])
+        # Les deux doivent survivre (paire complémentaire)
+        types = {f.type for f in selected}
+        assert FactType.GLOBAL_LEADER_CER in types
+        assert FactType.SIGNIFICANT_GAP in types
+
+    def test_low_importance_filtered(self):
+        low = Fact(type=FactType.SPEED_WINNER, importance=FactImportance.LOW,
+                   payload={}, engines_involved=("A",))
+        high = self._fact(FactType.GLOBAL_LEADER_CER, imp=FactImportance.CRITICAL, engines=("A",))
+        selected = select_facts([low, high])
+        assert all(f.importance >= FactImportance.MEDIUM for f in selected)
+
+    def test_nemenyi_tie_suppresses_contradicting_wilcoxon_gap(self):
+        # Si A et B sont dans le même groupe Nemenyi, on ne doit pas afficher
+        # un SIGNIFICANT_GAP entre A et B en plus.
+        tie = self._fact(FactType.STATISTICAL_TIE, imp=FactImportance.CRITICAL,
+                         engines=("A", "B", "C"))
+        gap = self._fact(FactType.SIGNIFICANT_GAP, imp=FactImportance.CRITICAL,
+                         engines=("A", "B"))
+        selected = select_facts([tie, gap])
+        types = {f.type for f in selected}
+        assert FactType.STATISTICAL_TIE in types
+        assert FactType.SIGNIFICANT_GAP not in types
+
+
+# ---------------------------------------------------------------------------
+# Rendu et déterminisme
+# ---------------------------------------------------------------------------
+
+class TestRenderer:
+    def test_render_fact_with_known_template(self):
+        f = Fact(
+            type=FactType.GLOBAL_LEADER_CER,
+            importance=FactImportance.CRITICAL,
+            payload={"engine": "testseract", "cer_pct": 4.2, "n_docs": 50,
+                     "cer": 0.042, "n_engines": 3},
+            engines_involved=("testseract",),
+        )
+        text = render_fact(f, "fr")
+        assert "testseract" in text
+        assert "4.2" in text
+        assert "50" in text
+
+    def test_render_respects_language(self):
+        f = Fact(
+            type=FactType.GLOBAL_LEADER_CER,
+            importance=FactImportance.CRITICAL,
+            payload={"engine": "X", "cer_pct": 1.0, "n_docs": 10,
+                     "cer": 0.01, "n_engines": 2},
+        )
+        fr = render_fact(f, "fr")
+        en = render_fact(f, "en")
+        assert fr != en
+        assert "Sur ce corpus" in fr
+        assert "On this corpus" in en
+
+    def test_render_missing_key_does_not_crash(self):
+        # Payload incomplet volontairement
+        f = Fact(
+            type=FactType.GLOBAL_LEADER_CER,
+            importance=FactImportance.CRITICAL,
+            payload={"engine": "only_name"},
+        )
+        text = render_fact(f)
+        # Doit renvoyer une phrase non vide, même si certains placeholders sont manquants
+        assert "only_name" in text
+
+    def test_render_synthesis_deterministic(self):
+        facts = [
+            Fact(type=FactType.GLOBAL_LEADER_CER, importance=FactImportance.CRITICAL,
+                 payload={"engine": "A", "cer_pct": 3.1, "n_docs": 20,
+                          "cer": 0.031, "n_engines": 2},
+                 engines_involved=("A",)),
+        ]
+        s1 = render_synthesis(facts, "fr")
+        s2 = render_synthesis(facts, "fr")
+        assert s1 == s2
+
+
+class TestBuildSynthesisE2E:
+    def test_full_pipeline_produces_sentences(self):
+        data = _minimal_data(statistics={
+            "pairwise_wilcoxon": [
+                {"engine_a": "A", "engine_b": "B", "p_value": 0.01,
+                 "significant": True, "n_pairs": 10},
+            ],
+            "bootstrap_cis": [
+                {"engine": "A", "mean": 0.05, "ci_lower": 0.04, "ci_upper": 0.06},
+                {"engine": "B", "mean": 0.12, "ci_lower": 0.11, "ci_upper": 0.13},
+            ],
+            "friedman": {},
+            "nemenyi": {"tied_groups": [["A"], ["B"], ["C"]],
+                        "mean_ranks": {"A": 1.0, "B": 2.0, "C": 3.0},
+                        "critical_distance": 0.5},
+        })
+        result = build_synthesis(data, "fr")
+        assert "sentences" in result
+        assert "facts" in result
+        assert len(result["sentences"]) >= 1
+        # Au moins la mention du leader
+        assert any("A" in s for s in result["sentences"])
+
+    def test_pipeline_deterministic_across_calls(self):
+        data = _minimal_data()
+        s1 = build_synthesis(data, "fr")
+        s2 = build_synthesis(data, "fr")
+        assert s1 == s2
+
+
+# ---------------------------------------------------------------------------
+# Garde-fou anti-hallucination : traçabilité des nombres
+# ---------------------------------------------------------------------------
+
+def _numbers_in_payload(payload: dict) -> set[str]:
+    """Collecte tous les nombres d'un payload de Fact sous formes multiples.
+
+    Inclut les représentations usuelles produites par ``str.format`` :
+    ``5``, ``5.0``, ``5.00``, ``5.000``, etc., pour tolérer les formats
+    ``{x}`` et ``{x:.2f}`` dans les templates.
+    """
+    out: set[str] = set()
+
+    def _add_variants(v):
+        try:
+            f = float(v)
+        except (TypeError, ValueError):
+            return
+        out.add(str(v))
+        out.add(str(f))
+        if f == int(f):
+            out.add(str(int(f)))
+        for dec in (1, 2, 3, 4):
+            out.add(f"{f:.{dec}f}")
+
+    def _walk(x):
+        if isinstance(x, dict):
+            for v in x.values():
+                _walk(v)
+        elif isinstance(x, (list, tuple)):
+            for v in x:
+                _walk(v)
+        elif isinstance(x, bool):
+            return
+        elif isinstance(x, (int, float)):
+            _add_variants(x)
+        elif isinstance(x, str):
+            for n in re.findall(r"\d+(?:\.\d+)?", x):
+                _add_variants(n)
+
+    _walk(payload)
+    return out
+
+
+# Constantes littérales autorisées dans les templates (non traçables au
+# payload car ce sont des éléments typographiques — seuil 95 % correspondant
+# à α = 0,05, etc.). Ajouter ici rend la règle explicite.
+_TEMPLATE_CONSTANTS = {"95", "100"}
+
+
+class TestAntiHallucinationTraceability:
+    """Chaque nombre dans la synthèse doit venir du payload d'un Fact
+    (lui-même traçable au JSON d'entrée par construction des détecteurs)
+    ou appartenir à la liste limitative des constantes de template.
+    """
+
+    def test_every_number_in_synthesis_is_traceable(self):
+        data = _minimal_data(statistics={
+            "pairwise_wilcoxon": [
+                {"engine_a": "A", "engine_b": "B", "p_value": 0.0123,
+                 "significant": True, "n_pairs": 10},
+            ],
+            "bootstrap_cis": [
+                {"engine": "A", "mean": 0.05, "ci_lower": 0.01, "ci_upper": 0.25},
+                {"engine": "B", "mean": 0.12, "ci_lower": 0.11, "ci_upper": 0.13},
+            ],
+            "friedman": {"statistic": 5.2, "p_value": 0.07, "significant": False},
+            "nemenyi": {
+                "tied_groups": [["A", "B"]],
+                "mean_ranks": {"A": 1.3, "B": 1.7, "C": 3.0},
+                "critical_distance": 0.856,
+                "alpha": 0.05,
+                "n_blocks": 10,
+            },
+        })
+        result = build_synthesis(data, "fr")
+        # Concaténer tous les payloads des Facts retenus
+        allowed = set(_TEMPLATE_CONSTANTS)
+        for f in result["facts"]:
+            allowed |= _numbers_in_payload(f.get("payload", {}))
+
+        unknown = []
+        for sentence in result["sentences"]:
+            for num in extract_numbers(sentence):
+                num_norm = num.replace(",", ".")
+                if num_norm not in allowed:
+                    unknown.append((num, sentence))
+        assert not unknown, f"Nombres non traçables : {unknown}"
+
+
+# ---------------------------------------------------------------------------
+# Intégration au rapport HTML
+# ---------------------------------------------------------------------------
+
+@pytest.fixture(scope="module")
+def benchmark_result():
+    from picarones import fixtures
+    return fixtures.generate_sample_benchmark(n_docs=8)
+
+
+class TestReportIntegration:
+    def test_report_contains_synthesis_section(self, benchmark_result, tmp_path):
+        from picarones.report.generator import ReportGenerator
+        out = tmp_path / "report.html"
+        ReportGenerator(benchmark_result).generate(out)
+        html = out.read_text(encoding="utf-8")
+        assert 'class="synth-card"' in html
+        assert 'id="synth-title"' in html
+        # Au moins une phrase rendue
+        assert re.search(r'<ul class="synth-list">\s*<li>', html)
+
+    def test_report_synthesis_is_deterministic(self, benchmark_result, tmp_path):
+        from picarones.report.generator import ReportGenerator
+        out1 = tmp_path / "r1.html"
+        out2 = tmp_path / "r2.html"
+        ReportGenerator(benchmark_result).generate(out1)
+        ReportGenerator(benchmark_result).generate(out2)
+        # Extraire la section synth et comparer
+        h1 = out1.read_text(encoding="utf-8")
+        h2 = out2.read_text(encoding="utf-8")
+        s1 = re.search(r'<section class="synth-card".*?</section>', h1, re.DOTALL)
+        s2 = re.search(r'<section class="synth-card".*?</section>', h2, re.DOTALL)
+        assert s1 and s2
+        assert hashlib.sha256(s1.group().encode()).hexdigest() == \
+               hashlib.sha256(s2.group().encode()).hexdigest()
+
+    def test_default_registry_has_all_types_registered(self):
+        from picarones.core.narrative import _DEFAULT_REGISTRY
+        registered = set(_DEFAULT_REGISTRY.registered_types())
+        # Tous les 12 types doivent être enregistrés (même ceux encore stubs)
+        assert len(registered) == 12
+
+    def test_english_locale_produces_english_sentences(self, benchmark_result, tmp_path):
+        from picarones.report.generator import ReportGenerator
+        out = tmp_path / "report_en.html"
+        ReportGenerator(benchmark_result, lang="en").generate(out)
+        html = out.read_text(encoding="utf-8")
+        m = re.search(r'<ul class="synth-list">(.*?)</ul>', html, re.DOTALL)
+        assert m
+        ul_content = m.group(1)
+        # Soit "On this corpus" (leader) soit "Engines" (tie) soit "The gap"
+        assert any(marker in ul_content for marker in
+                   ("On this corpus", "Engines ", "The gap", "statistically"))