sprint23: intégrité anti-hallucination du moteur narratif

Le test Sprint 19 ``test_every_number_in_synthesis_is_traceable``
tolérait une whitelist ``{"95", "100"}`` de littéraux non-traçables au
payload des Fact. Cette whitelist est maintenant vide ; tout nombre
apparaissant dans la synthèse rendue doit venir du payload d'un Fact
détecté, sans exception.

Changements
-----------

- ``CONFIDENCE_WARNING`` propage ``confidence_level=95`` dans son
payload ; les templates FR/EN référencent ``{confidence_level} %``
au lieu d'écrire "95 %" en dur.
- ``PARETO_ALTERNATIVE`` et ``COST_OUTLIER`` propagent
``cost_unit_pages=1000`` ; les templates FR/EN référencent
``€/{cost_unit_pages} pages`` au lieu de "/1000 pages".
- ``select_facts(facts, type_order=...)`` accepte désormais une
surcharge de l'ordre canonique des types (politique éditoriale).
L'ancienne constante ``_TYPE_ORDER`` reste exportée comme alias de
``DEFAULT_TYPE_ORDER`` pour rétro-compatibilité.

Tests (+14, soit 1256 passing au total)
---------------------------------------

- ``tests/test_sprint23_anti_hallucination.py`` :
* payloads exposent les nouveaux champs (3 tests)
* templates FR/EN ne contiennent plus 95/1000 en dur (4 tests)
* pipeline complet rend sans placeholder non substitué et reste
traçable avec whitelist vide (4 tests)
* stabilité du bootstrap entre seeds — borne ±0,5 pp à n_iter=1000
pour 20 documents (2 tests). Si ce test échoue à l'avenir,
passer ``n_iter=5000``.
* ``select_facts`` respecte un ``type_order`` custom (3 tests).

- ``tests/test_sprint19_narrative_engine.py`` :
``_TEMPLATE_CONSTANTS = frozenset()``.

Documentation
-------------

``docs/developer/narrative-engine.md`` gagne une section "Politique
éditoriale" qui documente l'ordre par défaut, ses hypothèses
implicites, et la procédure de surcharge via ``type_order``.

https://claude.ai/code/session_01L4RGWMrAajn5ZEFgTKjA5P

docs/developer/narrative-engine.md

@@ -161,3 +161,90 @@ Si la synthèse ne contient pas votre fait, vérifiez :
    par défaut de l'arbitre.
 3. Que votre type n'est pas en collision avec un autre déjà retenu pour
    le même moteur (cf. `_is_redundant`).
+
+---
+
+## Politique éditoriale (Sprint 23)
+
+L'arbitre départage les faits d'**égale importance** par un ordre canonique
+des types : c'est un choix éditorial qui répond à la question *« quand A et
+B sont aussi importants l'un que l'autre, lequel parle en premier ? »*.
+
+L'ordre par défaut est défini dans `arbiter.py` sous le nom
+`DEFAULT_TYPE_ORDER` :
+
+```python
+DEFAULT_TYPE_ORDER = (
+    FactType.GLOBAL_LEADER_CER,      # 1. Qui gagne globalement
+    FactType.STATISTICAL_TIE,        # 2. Y a-t-il un ex-aequo
+    FactType.SIGNIFICANT_GAP,        # 3. À quel point l'écart est solide
+    FactType.STRATUM_WINNER,         # 4. Qui domine sur quel sous-corpus
+    FactType.STRATUM_COLLAPSE,       # 5. Qui s'effondre sur quoi
+    FactType.ERROR_PROFILE_OUTLIER,  # 6. Qui se trompe différemment
+    FactType.LLM_HALLUCINATION_FLAG, # 7. Hallucinations VLM
+    FactType.ROBUSTNESS_FRAGILE,     # 8. Sensibilité aux dégradations
+    FactType.PARETO_ALTERNATIVE,     # 9. Y a-t-il un compromis coût/qualité
+    FactType.SPEED_WINNER,           # 10. Vitesse
+    FactType.COST_OUTLIER,           # 11. Coût aberrant
+    FactType.CONFIDENCE_WARNING,     # 12. Mise en garde sur la fiabilité
+)
+```
+
+**Hypothèse implicite** : un lecteur d'institution patrimoniale veut
+d'abord savoir *qui gagne* puis *à quel point cette victoire est solide*,
+avant de découvrir des considérations de coût ou de vitesse. Une équipe
+DevOps cherchant à industrialiser une chaîne aurait probablement l'ordre
+inverse — vitesse et coût d'abord, qualité ensuite.
+
+### Surcharger l'ordre sans patcher le code
+
+Depuis le Sprint 23, `select_facts` accepte un argument optionnel
+`type_order` :
+
+```python
+from picarones.core.narrative import build_synthesis
+from picarones.core.narrative.arbiter import select_facts, DEFAULT_TYPE_ORDER
+from picarones.core.narrative.facts import FactType
+
+# Réordonnancement : on remonte vitesse et coût avant qualité.
+custom = (
+    FactType.SPEED_WINNER,
+    FactType.COST_OUTLIER,
+    FactType.PARETO_ALTERNATIVE,
+    FactType.GLOBAL_LEADER_CER,
+    # ... compléter avec les autres types ; ceux qui manquent sont
+    #     relégués à la fin sans crash.
+)
+
+facts = detect_all(benchmark_data)
+selected = select_facts(facts, max_facts=5, type_order=custom)
+```
+
+Cas d'usage typiques :
+
+- **Atelier MOOC** : promouvoir `STRATUM_COLLAPSE` et
+  `ERROR_PROFILE_OUTLIER` en tête pour mettre l'accent sur la lecture
+  diagnostique des erreurs.
+- **Comité technique** : promouvoir `CONFIDENCE_WARNING` en tête pour
+  forcer la discussion sur la fiabilité avant les classements.
+- **Évaluation budgétaire** : promouvoir `COST_OUTLIER` et
+  `PARETO_ALTERNATIVE` en tête.
+
+### Règle anti-hallucination renforcée (Sprint 23)
+
+Avant le Sprint 23, le test de traçabilité des nombres tolérait deux
+littéraux non-traçables au payload (`95` pour le seuil de l'IC, `100`
+comme tolérance numérique). Cette whitelist est désormais vide :
+
+- Le seuil de confiance est propagé via `confidence_level` dans le
+  payload des `Fact` de type `CONFIDENCE_WARNING`.
+- L'unité du coût (`/1000 pages`) est propagée via `cost_unit_pages`
+  dans `PARETO_ALTERNATIVE` et `COST_OUTLIER`.
+
+**Si vous ajoutez un détecteur dont le template référence un nombre
+constant** (ex. *« seuil α = 0,05 »*), vous devez **systématiquement**
+le mettre dans le `payload`. Le test
+`test_sprint19_narrative_engine.py::test_every_number_in_synthesis_is_traceable`
+plus le test
+`test_sprint23_anti_hallucination.py::TestTemplatesNoHardcodedLiterals`
+échoueront sinon.

picarones/core/narrative/arbiter.py

@@ -19,13 +19,19 @@ pas mais peut limiter par type.
 
 from __future__ import annotations
 
-from typing import Iterable
+from typing import Iterable, Sequence
 
 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, ...] = (
+#
+# Politique éditoriale (Sprint 23) — exposée et documentée :
+# voir ``docs/developer/narrative-engine.md`` § Editorial policy.
+# L'ordre encode quels faits sont remontés en priorité quand plusieurs ont
+# la même ``FactImportance`` ; il peut être surchargé via le paramètre
+# ``type_order`` de ``select_facts`` sans patcher le code.
+DEFAULT_TYPE_ORDER: tuple[FactType, ...] = (
     FactType.GLOBAL_LEADER_CER,
     FactType.STATISTICAL_TIE,
     FactType.SIGNIFICANT_GAP,
@@ -39,7 +45,10 @@ _TYPE_ORDER: tuple[FactType, ...] = (
     FactType.COST_OUTLIER,
     FactType.CONFIDENCE_WARNING,
 )
-_TYPE_INDEX: dict[FactType, int] = {t: i for i, t in enumerate(_TYPE_ORDER)}
+# Alias rétro-compatible — l'ancien nom privé reste exporté pour
+# les tests et le code utilisateur qui s'y appuyaient.
+_TYPE_ORDER = DEFAULT_TYPE_ORDER
+_TYPE_INDEX: dict[FactType, int] = {t: i for i, t in enumerate(DEFAULT_TYPE_ORDER)}
 
 
 # Paires de types qui ne sont PAS considérées comme redondantes même quand
@@ -53,11 +62,11 @@ _COMPLEMENTARY_PAIRS: frozenset[frozenset[FactType]] = frozenset({
 })
 
 
-def _sort_key(fact: Fact) -> tuple:
+def _sort_key(fact: Fact, type_index: dict[FactType, int]) -> tuple:
     """Clé de tri stable : importance (desc), type canonique, moteurs."""
     return (
         -int(fact.importance),
-        _TYPE_INDEX.get(fact.type, len(_TYPE_ORDER)),
+        type_index.get(fact.type, len(type_index)),
         tuple(sorted(fact.engines_involved)),
         fact.stratum or "",
     )
@@ -106,6 +115,7 @@ def select_facts(
     facts: Iterable[Fact],
     max_facts: int = 5,
     min_importance: FactImportance = FactImportance.MEDIUM,
+    type_order: Sequence[FactType] | None = None,
 ) -> list[Fact]:
     """Sélectionne la synthèse finale à partir d'une liste brute de faits.
 
@@ -117,14 +127,24 @@ def select_facts(
         Nombre maximal de faits retenus (défaut : 5).
     min_importance:
         Seuil minimal d'importance. Les faits ``LOW`` sont exclus par défaut.
+    type_order:
+        Surcharge optionnelle de l'ordre canonique des types pour départager
+        les faits d'égale importance. ``None`` (défaut) utilise
+        ``DEFAULT_TYPE_ORDER``. Une institution peut passer son propre ordre
+        sans patcher le code — voir ``docs/developer/narrative-engine.md``.
 
     Returns
     -------
     Liste ordonnée, prête à être rendue. Toujours ≤ ``max_facts``.
     """
+    if type_order is None:
+        type_index = _TYPE_INDEX
+    else:
+        type_index = {t: i for i, t in enumerate(type_order)}
+
     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)
+    ranked = sorted(facts_list, key=lambda f: _sort_key(f, type_index))
 
     selected: list[Fact] = []
     for fact in ranked:

picarones/core/narrative/detectors.py

@@ -216,6 +216,9 @@ def detect_pareto_alternative(benchmark_data: dict) -> list[Fact]:
             "leader_cost": round(leader_cost, 2),
             "cost_saving_ratio": round(leader_cost / alt_cost, 1) if alt_cost > 0 else None,
             "delta_cer_pct": round((alt_cer - leader_cer) * 100, 2),
+            # Unité du coût — propagée pour traçabilité (le template ne
+            # hardcode plus "1000 pages").
+            "cost_unit_pages": 1000,
         },
         engines_involved=(alt["engine"],),
     )]
@@ -519,6 +522,7 @@ def detect_cost_outlier(benchmark_data: dict) -> list[Fact]:
                 "median_cost": round(median_cost, 2),
                 "ratio_to_median": round(c / median_cost, 1),
                 "cer_pct": round(float(p.get("cer") or 0.0) * 100, 2),
+                "cost_unit_pages": 1000,
             },
             engines_involved=(p["engine"],),
         ))
@@ -642,6 +646,9 @@ def detect_confidence_warning(benchmark_data: dict) -> list[Fact]:
                     "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),
+                    # Niveau de confiance des bornes — propagé pour traçabilité
+                    # anti-hallucination (le template ne hardcode plus "95 %").
+                    "confidence_level": 95,
                 },
                 engines_involved=(engine_name,),
             ))

picarones/core/narrative/templates/en.yaml

@@ -42,14 +42,14 @@ speed_winner: >-
   median) for comparable quality (CER {cer_pct} %).
 
 confidence_warning: >-
-  Ranking is fragile: the 95 % confidence interval of {engine} spans
+  Ranking is fragile: the {confidence_level} % 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.
 
 pareto_alternative: >-
   At much lower cost, {engine} offers an interesting trade-off ({cer_pct} %
-  CER for {cost} €/1000 pages, vs {leader_cer_pct} % / {leader_cost} € for
+  CER for {cost} €/{cost_unit_pages} pages, vs {leader_cer_pct} % / {leader_cost} € for
   {leader}, i.e. ×{cost_saving_ratio} cheaper).
 
 cost_outlier: >-
-  Disproportionate cost for {engine} ({cost} €/1000 pages, ×{ratio_to_median}
+  Disproportionate cost for {engine} ({cost} €/{cost_unit_pages} pages, ×{ratio_to_median}
   the median) without a compensating quality advantage (CER {cer_pct} %).

picarones/core/narrative/templates/fr.yaml

@@ -46,14 +46,14 @@ speed_winner: >-
   que la médiane) pour un CER comparable ({cer_pct} %).
 
 confidence_warning: >-
-  Classement fragile : l'intervalle de confiance à 95 % de {engine} s'étend
+  Classement fragile : l'intervalle de confiance à {confidence_level} % de {engine} s'étend
   sur {ci_width_pct} points de CER, à comparer à l'écart de {gap_to_runner_up_pct} points avec le second.
 
 pareto_alternative: >-
   À coût sensiblement inférieur, {engine} offre un compromis intéressant
-  ({cer_pct} % de CER pour {cost} €/1000 pages, contre {leader_cer_pct} % /
+  ({cer_pct} % de CER pour {cost} €/{cost_unit_pages} pages, contre {leader_cer_pct} % /
   {leader_cost} € pour {leader}, soit ×{cost_saving_ratio} moins cher).
 
 cost_outlier: >-
-  Coût disproportionné pour {engine} ({cost} €/1000 pages, ×{ratio_to_median}
+  Coût disproportionné pour {engine} ({cost} €/{cost_unit_pages} pages, ×{ratio_to_median}
   la médiane) sans avantage de qualité compensatoire (CER {cer_pct} %).

tests/test_sprint19_narrative_engine.py

@@ -493,10 +493,13 @@ def _numbers_in_payload(payload: dict) -> set[str]:
     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"}
+# Sprint 23 : whitelist vidée. Tout nombre rendu dans la synthèse doit
+# venir du payload d'un Fact. Le seuil de confiance (95) est désormais
+# propagé via ``confidence_level`` dans le payload de
+# ``FactType.CONFIDENCE_WARNING`` et l'unité du coût (1000 pages) via
+# ``cost_unit_pages`` dans ``PARETO_ALTERNATIVE`` / ``COST_OUTLIER``.
+# Aucun littéral hors-payload n'est plus autorisé.
+_TEMPLATE_CONSTANTS: frozenset[str] = frozenset()
 
 
 class TestAntiHallucinationTraceability:

tests/test_sprint23_anti_hallucination.py

@@ -0,0 +1,275 @@
+"""Tests Sprint 23 — intégrité anti-hallucination du moteur narratif.
+
+Le Sprint 23 ferme le trou méthodologique laissé par le Sprint 19 : le test
+de traçabilité des nombres dans la synthèse rendue tolérait une whitelist
+``{"95", "100"}`` de littéraux non-traçables au payload. Cette whitelist
+est désormais vide ; toute valeur numérique apparaissant dans la synthèse
+doit provenir du ``Fact.payload`` d'un détecteur.
+
+Ce module vérifie quatre choses :
+
+1. Les payloads des détecteurs concernés (``CONFIDENCE_WARNING``,
+   ``PARETO_ALTERNATIVE``, ``COST_OUTLIER``) exposent bien les nouveaux
+   champs (``confidence_level``, ``cost_unit_pages``).
+2. Les templates FR/EN ne contiennent plus les littéraux ``95`` ni ``1000``
+   en dehors d'un placeholder ``{...}``.
+3. Le test de traçabilité reste vert avec une whitelist vide.
+4. La stabilité du bootstrap est testée : deux seeds produisent des bornes
+   d'IC à ±0,5 pp pour ``n=20`` documents — garantit que l'IC affiché
+   dans le rapport est représentatif (sinon il faudrait passer
+   ``n_iter=5000``).
+5. Le pipeline narratif EN bout-en-bout produit des phrases anglaises
+   bien formées (pas de placeholder non substitué) sur fixtures réalistes.
+6. ``select_facts`` accepte un ``type_order`` custom et le respecte.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import pytest
+
+from picarones.core.narrative import (
+    Fact,
+    FactImportance,
+    FactType,
+    build_synthesis,
+    select_facts,
+)
+from picarones.core.narrative.arbiter import DEFAULT_TYPE_ORDER
+from picarones.core.statistics import bootstrap_ci
+
+ROOT = Path(__file__).parent.parent
+TEMPLATES_DIR = ROOT / "picarones" / "core" / "narrative" / "templates"
+
+
+# ---------------------------------------------------------------------------
+# Fixtures locales — minimum viable pour faire émettre chaque détecteur
+# ---------------------------------------------------------------------------
+
+def _full_data() -> dict:
+    """Données qui déclenchent ``CONFIDENCE_WARNING`` (IC large) et le Pareto."""
+    return {
+        "ranking": [
+            {"engine": "A", "mean_cer": 0.05, "wer": 0.10},
+            {"engine": "B", "mean_cer": 0.06, "wer": 0.12},
+            {"engine": "C", "mean_cer": 0.20, "wer": 0.30},
+        ],
+        "n_documents": 20,
+        "statistics": {
+            "bootstrap_cis": [
+                # IC large pour A → confidence_warning
+                {"engine": "A", "mean": 0.05, "ci_lower": 0.01, "ci_upper": 0.15},
+                {"engine": "B", "mean": 0.06, "ci_lower": 0.05, "ci_upper": 0.07},
+                {"engine": "C", "mean": 0.20, "ci_lower": 0.18, "ci_upper": 0.22},
+            ],
+        },
+        "pareto": {
+            "cost": {
+                "front": ["A", "B"],
+                "points": [
+                    {"engine": "A", "cer": 0.05, "cost": 50.0},
+                    {"engine": "B", "cer": 0.06, "cost": 5.0},  # alternative pas chère
+                    {"engine": "C", "cer": 0.20, "cost": 300.0},  # cost outlier
+                ],
+            },
+        },
+    }
+
+
+# ---------------------------------------------------------------------------
+# 1. Payloads exposent les nouveaux champs
+# ---------------------------------------------------------------------------
+
+class TestPayloadsCarryFormerlyHardcodedConstants:
+    def test_confidence_warning_payload_carries_confidence_level(self):
+        from picarones.core.narrative.detectors import detect_confidence_warning
+
+        facts = detect_confidence_warning(_full_data())
+        assert facts, "fixture devrait déclencher au moins un confidence_warning"
+        for f in facts:
+            assert f.payload.get("confidence_level") == 95, (
+                "Le seuil 95 doit être propagé dans le payload "
+                "(plus de littéral hardcodé dans le template)."
+            )
+
+    def test_pareto_alternative_payload_carries_cost_unit(self):
+        from picarones.core.narrative.detectors import detect_pareto_alternative
+
+        facts = detect_pareto_alternative(_full_data())
+        assert facts, "fixture devrait déclencher au moins un pareto_alternative"
+        for f in facts:
+            assert f.payload.get("cost_unit_pages") == 1000
+
+    def test_cost_outlier_payload_carries_cost_unit(self):
+        from picarones.core.narrative.detectors import detect_cost_outlier
+
+        facts = detect_cost_outlier(_full_data())
+        assert facts, "fixture devrait déclencher au moins un cost_outlier"
+        for f in facts:
+            assert f.payload.get("cost_unit_pages") == 1000
+
+
+# ---------------------------------------------------------------------------
+# 2. Les templates ne hardcodent plus les littéraux 95 et 1000
+# ---------------------------------------------------------------------------
+
+# Toute occurrence d'un nombre HORS d'un placeholder ``{...}`` est
+# considérée comme un littéral hardcodé. On scanne en remplaçant d'abord
+# tous les placeholders par un marqueur neutre.
+_PLACEHOLDER_RE = re.compile(r"\{[^{}]+\}")
+_NUMBER_RE = re.compile(r"\b\d+\b")
+
+
+def _strip_placeholders(template: str) -> str:
+    return _PLACEHOLDER_RE.sub("PLACEHOLDER", template)
+
+
+@pytest.mark.parametrize("lang", ["fr", "en"])
+class TestTemplatesNoHardcodedLiterals:
+    def test_no_hardcoded_95(self, lang):
+        import yaml
+
+        path = TEMPLATES_DIR / f"{lang}.yaml"
+        templates = yaml.safe_load(path.read_text(encoding="utf-8"))
+        for key, tpl in templates.items():
+            stripped = _strip_placeholders(tpl)
+            numbers = _NUMBER_RE.findall(stripped)
+            assert "95" not in numbers, (
+                f"Template {lang}/{key} contient encore le littéral 95 ; "
+                "doit utiliser {confidence_level}."
+            )
+            assert "1000" not in numbers, (
+                f"Template {lang}/{key} contient encore le littéral 1000 ; "
+                "doit utiliser {cost_unit_pages}."
+            )
+
+
+# ---------------------------------------------------------------------------
+# 3. Pipeline complet produit une synthèse traçable, whitelist vide
+# ---------------------------------------------------------------------------
+
+class TestEndToEndWithEmptyWhitelist:
+    @pytest.mark.parametrize("lang", ["fr", "en"])
+    def test_synthesis_renders_without_unsubstituted_placeholders(self, lang):
+        result = build_synthesis(_full_data(), lang)
+        for sentence in result["sentences"]:
+            assert "{" not in sentence and "}" not in sentence, (
+                f"Placeholder non substitué dans la synthèse {lang} : {sentence!r}"
+            )
+
+    @pytest.mark.parametrize("lang", ["fr", "en"])
+    def test_every_number_traceable_with_empty_whitelist(self, lang):
+        from picarones.core.narrative import extract_numbers
+
+        from tests.test_sprint19_narrative_engine import _numbers_in_payload
+
+        result = build_synthesis(_full_data(), lang)
+        allowed: set[str] = set()
+        for f in result["facts"]:
+            allowed |= _numbers_in_payload(f.get("payload", {}))
+
+        unknown: list[tuple[str, str]] = []
+        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"[{lang}] Nombres non traçables au payload : {unknown}"
+        )
+
+
+# ---------------------------------------------------------------------------
+# 4. Stabilité du bootstrap entre seeds
+# ---------------------------------------------------------------------------
+
+class TestBootstrapStabilityAcrossSeeds:
+    """Vérifie que ``bootstrap_ci`` à n_iter=1000 est suffisamment stable.
+
+    Pour 20 documents avec un CER moyen ~5 %, l'écart entre deux seeds sur
+    chacune des bornes (lower, upper) doit rester inférieur à 0,5 point de
+    pourcentage de CER (= 0.005 en absolu). Si ce test échoue à l'avenir,
+    cela signifie qu'il faut passer à ``n_iter=5000`` pour fiabiliser
+    l'IC affiché dans le rapport.
+    """
+
+    def test_bootstrap_stable_for_typical_cer_distribution(self):
+        # 20 valeurs de CER autour de 5 % — distribution réaliste.
+        values = [
+            0.02, 0.03, 0.04, 0.04, 0.045, 0.05, 0.05, 0.05, 0.055, 0.055,
+            0.06, 0.06, 0.06, 0.065, 0.07, 0.07, 0.075, 0.08, 0.085, 0.10,
+        ]
+        lo1, hi1 = bootstrap_ci(values, n_iter=1000, seed=42)
+        lo2, hi2 = bootstrap_ci(values, n_iter=1000, seed=7)
+        assert abs(lo1 - lo2) < 0.005, (
+            f"Borne basse instable entre seeds (Δ = {abs(lo1 - lo2):.4f}) ; "
+            "envisager n_iter=5000."
+        )
+        assert abs(hi1 - hi2) < 0.005, (
+            f"Borne haute instable entre seeds (Δ = {abs(hi1 - hi2):.4f}) ; "
+            "envisager n_iter=5000."
+        )
+
+    def test_bootstrap_strictly_deterministic_same_seed(self):
+        values = [0.01, 0.05, 0.1, 0.2]
+        a = bootstrap_ci(values, n_iter=1000, seed=42)
+        b = bootstrap_ci(values, n_iter=1000, seed=42)
+        assert a == b, "Bootstrap doit être bit-à-bit reproductible sur seed identique."
+
+
+# ---------------------------------------------------------------------------
+# 5. select_facts respecte un type_order custom
+# ---------------------------------------------------------------------------
+
+class TestSelectFactsCustomTypeOrder:
+    def _make_facts(self) -> list[Fact]:
+        return [
+            Fact(
+                type=FactType.GLOBAL_LEADER_CER,
+                importance=FactImportance.HIGH,
+                payload={"engine": "A"},
+                engines_involved=("A",),
+            ),
+            Fact(
+                type=FactType.SPEED_WINNER,
+                importance=FactImportance.HIGH,
+                payload={"engine": "B"},
+                engines_involved=("B",),
+            ),
+            Fact(
+                type=FactType.PARETO_ALTERNATIVE,
+                importance=FactImportance.HIGH,
+                payload={"engine": "C"},
+                engines_involved=("C",),
+            ),
+        ]
+
+    def test_default_order_puts_global_leader_first(self):
+        selected = select_facts(self._make_facts(), max_facts=3)
+        assert selected[0].type == FactType.GLOBAL_LEADER_CER
+
+    def test_custom_order_promotes_speed_winner(self):
+        custom = (
+            FactType.SPEED_WINNER,
+            FactType.GLOBAL_LEADER_CER,
+            FactType.PARETO_ALTERNATIVE,
+        ) + tuple(t for t in DEFAULT_TYPE_ORDER if t not in {
+            FactType.SPEED_WINNER,
+            FactType.GLOBAL_LEADER_CER,
+            FactType.PARETO_ALTERNATIVE,
+        })
+        selected = select_facts(self._make_facts(), max_facts=3, type_order=custom)
+        assert selected[0].type == FactType.SPEED_WINNER, (
+            "Avec un type_order custom plaçant SPEED_WINNER en premier, "
+            "il doit ressortir avant GLOBAL_LEADER_CER à importance égale."
+        )
+
+    def test_unknown_types_in_custom_order_fall_to_end(self):
+        # Un type_order réduit (ne mentionne que GLOBAL_LEADER_CER) ; les autres
+        # types sont relégués à la fin sans crash.
+        custom = (FactType.GLOBAL_LEADER_CER,)
+        selected = select_facts(self._make_facts(), max_facts=3, type_order=custom)
+        assert selected[0].type == FactType.GLOBAL_LEADER_CER
+        assert len(selected) == 3