sprint73: détecteur narratif engine_off_baseline (A.I.3 chantier 2)

L'historique SQLite (Sprint 8) existait mais aucun détecteur
narratif ne le lisait. Ce sprint répond à « comment ce moteur se
comporte-t-il sur ce corpus, par rapport à ses runs précédents
de mon institution ? ».

- Nouveau module picarones/core/baseline_comparison.py :
- compute_engine_baseline(history, engine, corpus, current_cer,
current_run_id, min_runs=5, threshold=0.20) avec filtre
apple-to-apple par moteur×corpus, exclusion run courant,
n_runs/mean/median/absolute/relative_delta/off_baseline.
- compute_corpus_difficulty_percentile place la difficulté
courante dans la distribution historique, flags
harder/easier_than_usual (P75/P25).
- Nouveau FactType.ENGINE_OFF_BASELINE dans narrative/facts.py.
- Nouveau détecteur detect_engine_off_baseline (priority 150) :
émet 1 Fact par moteur off_baseline, importance HIGH si
|delta|≥50% sinon MEDIUM, garde-fous (silent si pas de data,
relative=None, off=False).
- Templates FR/EN dans narrative/templates/.
- Mise à jour _FALLBACK_TYPE_ORDER dans arbiter.py.
- +21 tests : couche calcul (9 cas), percentile (4 cas),
détecteur (6 cas), traçabilité anti-hallucination FR+EN.

Tests : 2569 passed, 2 skipped, 0 failed.

https://claude.ai/code/session_01RusTQYcSfXqTsbFNvwmCV7

CHANGELOG.md

@@ -16,6 +16,62 @@ La numérotation de version suit [Semantic Versioning](https://semver.org/lang/f
 
 ### Ajouté
 
+- **Sprint 73 — A.I.3 chantier 2 : détecteur narratif
+  ``engine_off_baseline`` (couche calcul + narrative).**  L'historique
+  SQLite (Sprint 8) existait depuis longtemps mais aucun détecteur
+  narratif ne le lisait.  Ce sprint répond à *« comment ce moteur
+  se comporte-t-il sur ce corpus, par rapport à ses runs précédents
+  de mon institution ? »*.  L'encart HTML « Ce corpus est-il
+  habituel ? » (chantier 1 d'A.I.3, boxplot SVG) suit Sprint 74.
+  - Nouveau module `picarones/core/baseline_comparison.py` :
+    - ``compute_engine_baseline(history, engine_name, corpus_name,
+      current_cer, *, current_run_id, min_runs=5,
+      relative_delta_threshold=0.20)`` retourne un dict avec
+      ``cer_current``, ``cer_historical_mean``,
+      ``cer_historical_median``, ``n_runs``, ``absolute_delta``,
+      ``relative_delta``, ``off_baseline``.  Filtre par moteur ×
+      corpus (apple-to-apple), exclut le run courant si fourni,
+      ignore les CER négatifs / None, retourne ``None`` si moins
+      de ``min_runs`` runs historiques.
+    - ``compute_corpus_difficulty_percentile(history,
+      current_difficulty, *, min_runs=5)`` place la difficulté du
+      corpus courant dans la distribution historique (lit
+      ``HistoryEntry.metadata["difficulty"]``).  Retourne
+      ``percentile``, ``median_historical``, flags
+      ``harder_than_usual`` (P75+) et ``easier_than_usual`` (P25-).
+  - Nouveau ``FactType.ENGINE_OFF_BASELINE`` dans
+    ``narrative/facts.py``.
+  - Nouveau détecteur ``detect_engine_off_baseline`` dans
+    ``narrative/detectors.py`` (priority 150) :
+    - Lit ``benchmark_data["baseline_comparisons"]`` (liste de
+      dicts produits par ``compute_engine_baseline``).
+    - Émet 1 Fact par moteur off_baseline.
+    - Importance ``HIGH`` si ``|relative_delta| ≥ 50 %``,
+      ``MEDIUM`` sinon.
+    - Garde-fous : silencieux si ``baseline_comparisons`` absent
+      ou vide, si ``relative_delta`` est ``None`` (baseline = 0
+      non calculable), si ``off_baseline=False``.
+  - Nouveaux templates FR/EN dans
+    ``narrative/templates/{fr,en}.yaml``.  Phrase factuelle type :
+    *« tess a obtenu 5,2 % CER ici, vs 4,1 % en moyenne sur les
+    12 runs précédents… »*.
+  - +21 tests dans `test_sprint73_baseline_comparison.py` :
+    - couche calcul (off_baseline_higher, within_baseline,
+      min_runs filter, custom_min_runs, current_run_excluded,
+      filter par engine+corpus, CER None ignorés, baseline=0 →
+      relative None, current_cer invalide)
+    - difficulty_percentile (calcul, harder/easier, min_runs)
+    - détecteur (silent sans data, silent off=False, silent
+      relative=None, fact émis, importance HIGH si ≥50%, multiple
+      moteurs)
+    - **traçabilité anti-hallucination** FR + EN : chaque nombre
+      dans le texte rendu est traçable au payload.
+  - **Verrou levé** : un benchmark BnF qui pousse ses résultats
+    dans l'historique SQLite et qui passe ``baseline_comparisons``
+    au moteur narratif voit automatiquement, dans la synthèse en
+    tête de rapport, *« ce moteur a un CER inhabituel sur ce
+    corpus par rapport à vos 12 runs précédents »*.
+
 - **Sprint 72 — A.I.1 chantier 1 : vue « Worst lines globale »
   (clôture A.I.1).**  Suite directe Sprint 71 : la roadmap A.I.1
   comporte deux chantiers — la métrique rare-token recall (livrée)

CLAUDE.md

@@ -207,6 +207,7 @@ AZURE_DOC_INTEL_KEY=...
 | 33 | **Sprint 2 du plan d'évolution 2026 — Phase 0.2 : interface module générique**. Nouveau module `picarones/core/modules.py` avec l'enum `ArtifactType` (IMAGE, TEXT, ALTO, PAGE, ENTITIES, READING_ORDER) et la classe abstraite `BaseModule` qui déclare `input_types`/`output_types`, `execution_mode` (`"io"`/`"cpu"`), une méthode `process(dict[ArtifactType, Any]) → dict[ArtifactType, Any]`, et des helpers `validate_inputs`/`validate_outputs`. `BaseOCREngine` (`picarones/engines/base.py`) hérite désormais de `BaseModule` avec `input_types=(IMAGE,)` et `output_types=(TEXT,)` ; sa nouvelle méthode `process` wrappe l'API historique `run()`. Aucun adaptateur OCR existant n'est touché — `test_engines.py` passe à 20/20 sans modification. +23 tests dans `test_sprint33_module_interface.py` (contrat, validation, MockModule TEXT→ALTO démonstratif comme demandé par le plan, délégation `BaseOCREngine.process → run`, cohérence ArtifactType/GTLevel). **Verrou levé** : un même runner peut maintenant exécuter un OCR (image→texte), un mappeur VLM→ALTO, un rewriter ALTO→ALTO, un module NER (texte→entités), etc. — fondation directe pour l'axe B du plan. |
 | 34 | **Sprint 3 du plan d'évolution 2026 — Phase 0.3 : registre typé de métriques (clôture Phase 0)**. Nouveaux modules `picarones/core/metric_registry.py` (`MetricSpec`, `@register_metric`, `select_metrics`, `compute_at_junction`) et `picarones/core/builtin_metrics.py` qui enregistre `cer`, `wer`, `mer`, `wil` sur `(TEXT, TEXT)` plus un stub `text_preservation_after_reconstruction` sur `(TEXT, ALTO)` comme preuve de concept de jonction hétérogène. **Approche strictement additive** : ni `metrics.py` ni `compute_metrics` ne sont modifiés, le rapport HTML reste identique octet par octet. La sélection par signature de types est exacte (pas de coercion). +21 tests dans `test_sprint34_metric_registry.py`, dont une parité numérique CER/WER/MER/WIL avec `compute_metrics` legacy à 1e-9 près sur 4 paires de textes. **Verrou levé** : le runner d'une pipeline composée peut maintenant calculer automatiquement la métrique adéquate à chaque jonction de son DAG selon les types d'artefacts produits/attendus — fondation directe pour la métrique d'absorption d'erreur (acte B.3) et toutes les métriques structurelles à venir (Layout F1, reading order F1, NER). |
 | 35 | **Sprint 4 du plan d'évolution 2026 — Étape 2 / axe A : métriques inter-moteurs (couche de calcul)**. Nouveau module `picarones/core/inter_engine.py` qui répond à deux questions distinctes mais liées : *(a) à quel point les moteurs font-ils des erreurs de natures différentes ?* via `kl_divergence`, `jensen_shannon_divergence` (symétrique, bornée `[0, 1]`), et `taxonomy_divergence_matrix` qui construit la matrice triangulaire inter-moteurs ; *(b) quel CER serait atteignable si on combinait les moteurs ?* via `oracle_token_recall` (proxy bag-of-words, borne supérieure du recall atteignable), `complementarity_gap` (oracle vs meilleur moteur seul, gap absolu/relatif), et `pairwise_disagreement_rate`. Fonctions pures, sans I/O ni intégration runner — la couche de calcul est livrée indépendamment, le câblage narratif (`ENSEMBLE_OPPORTUNITY`) et HTML (matrice de divergence, badge oracle) suit au Sprint 36. +27 tests couvrant les invariants mathématiques (KL ≥ 0, KL(p,p) = 0, JS symétrique et bornée, oracle ≥ best_single, multiplicité respectée), les cas concrets (deux moteurs spécialisés sortent comme candidats ensemble, complémentarité parfaite atteint oracle = 1), et les garde-fous (référence vide, hypothèses vides, métrique inconnue). |
+| 73 | **Sprint 42 du plan d'évolution 2026 — A.I.3 chantier 2 : détecteur narratif `engine_off_baseline` (couche calcul + narrative)**. L'historique SQLite (Sprint 8) existait mais aucun détecteur narratif ne le lisait. Répond à « comment ce moteur se comporte-t-il sur ce corpus par rapport à ses runs précédents de mon institution ? ». L'encart HTML « Ce corpus est-il habituel ? » (chantier 1, boxplot SVG) suit Sprint 74. Nouveau module `picarones/core/baseline_comparison.py` : `compute_engine_baseline(history, engine_name, corpus_name, current_cer, current_run_id, min_runs=5, relative_delta_threshold=0.20)` filtre apple-to-apple par moteur×corpus, exclut le run courant si fourni, retourne dict avec cer_current/historical_mean/median, n_runs, absolute_delta, relative_delta, off_baseline ; `compute_corpus_difficulty_percentile` place la difficulté courante dans la distribution historique (lit metadata.difficulty), flags harder/easier_than_usual (P75/P25). Nouveau `FactType.ENGINE_OFF_BASELINE` + détecteur `detect_engine_off_baseline` (priority 150) qui émet 1 Fact par moteur off_baseline, importance HIGH si |delta|≥50% sinon MEDIUM, silencieux si baseline_comparisons absent/vide ou relative_delta=None. Templates FR/EN. +21 tests : couche calcul (9 cas dont min_runs/current_run_id/baseline=0/CER None), percentile (4 cas), détecteur (6 cas), **traçabilité anti-hallucination FR+EN** (chaque nombre rendu traçable au payload). **Verrou levé** : un bench BnF qui pousse ses résultats dans l'historique voit dans la synthèse « ce moteur a un CER inhabituel sur ce corpus par rapport à vos 12 runs précédents ». |
 | 72 | **Sprint 41 du plan d'évolution 2026 — A.I.1 chantier 1 : vue HTML « Worst lines globale » (clôture A.I.1)**. Suite directe Sprint 71 — la métrique rare-token recall est livrée, ce sprint livre la vue qui transcende les documents pour exposer les lignes individuelles les plus mal transcrites du corpus. Nouveau module `picarones/core/worst_lines.py` : dataclass `WorstLineEntry(rank, cer, engine_name, doc_id, line_index, gt_line, hyp_line, script_type)`, `extract_worst_lines(benchmark, top_n=20, engine_filter, script_type_filter)` collecte transversalement à tous les moteurs et docs, filtre par moteur et par strate (Sprint 45 doc_strata), trie par CER décroissant, retourne top_n avec rang 1-based. Récupère les textes GT/hyp par re-split du DocumentResult à l'index de ligne (limite : suppose BenchmarkResult non-compacté). Lignes CER=0 ignorées. Nouveau module `picarones/report/worst_lines_render.py` : `build_worst_lines_table_html(entries, labels)` server-side avec colonnes Rang/CER (gradient jaune→rouge)/Moteur/Doc/Ligne#/[Strate]/Diff GT→OCR. Colonne strate **adaptive** (omise si aucune entry n'en a). Diff caractère par caractère via `diff_utils.compute_char_diff` (Sprint 5), rouge barré pour suppressions, vert pour insertions. Anti-injection systématique. Retourne `""` si vide. +25 tests (extraction 5 cas, filtres 4 cas, edge cases 4 cas — pas de line_metrics, vide, sans doc_strata, hyp plus courte —, rendu 8 cas, anti-injection 4 cas). **Verrou levé** : un chercheur qui voit `5% de mes lignes ont un CER > 0.42` dans le rapport peut désormais voir **quelles** lignes — diff inline, document parent, ligne#, moteur — pour comprendre ce qui casse. |
 | 71 | **Sprint 40 du plan d'évolution 2026 — A.I.1 chantier 2 : rare-token recall (couche de calcul, démarrage de la résolution des critiques structurelles A.I)**. Premier sprint A.I qui s'attaque à la critique « la granularité ne s'arrête plus à la page ». Mesure le rappel sur les tokens rares (hapax + dis legomena, défaut `max_freq=2`) — répond à *« ce moteur préserve-t-il les noms propres rares qui m'intéressent pour l'indexation prosopographique ? »*. Nouveau module `picarones/core/rare_tokens.py` : `tokenize` Unicode-aware (contractions `L'an`/`d’une`, composés `peut-être`, apostrophe typographique `’` U+2019), `frequency_distribution(documents, case_sensitive)` → `{token: count}` corpus-wide, `extract_rare_tokens(documents, max_freq=2)` → `frozenset`, `compute_rare_token_recall(reference, hypothesis, rare_tokens)` retourne `{n_rare_tokens_in_reference, n_rare_tokens_recalled, recall, missed_tokens}` avec alignement bag-of-tokens multiplicitaire. **Pas d'enregistrement registre typé** (la métrique exige un 3ᵉ argument set des rares, calculé corpus-wide). +28 tests (tokenisation 8 cas, frequency 4 cas, extraction 4 cas, recall 10 cas avec multiplicité/casse/dégénérés, raccourci, **test propriété cas réaliste registre état civil** prouvant que rare-token recall discrimine plus que CER quand l'OCR rate les noms propres). **Verrou levé** : un bench BnF qui veut savoir « ce moteur préserve-t-il bien les noms de famille ? » a maintenant la métrique adaptée. Vue HTML « Worst lines + tokens rares manqués » suit Sprint 72 (chantier 1 d'A.I.1). |
 | 70 | **Sprint 39 du plan d'évolution 2026 — Étape 4 / axe B : CLI pour piloter les pipelines composées sans Python**. Permet de spécifier une pipeline ou une comparaison de N pipelines dans un YAML déclaratif et de les exécuter via la CLI, sans écrire de Python. Nouveau module `picarones/core/pipeline_spec_loader.py` : `load_pipeline_spec_from_yaml/dict` parse YAML → `PipelineSpec` (steps avec dotted path module, args kwargs, inputs_from optionnel pour DAG branchant), `load_comparison_specs_from_yaml` retourne `(specs, extras)` pour comparaison. Import dynamique via `importlib`, validation stricte que la classe hérite de `BaseModule`. Exception `PipelineSpecLoadError` avec messages explicites pour 8 cas d'erreur. Nouveau sous-groupe CLI `picarones pipeline` : `run <spec.yaml> --corpus <dir>` (avec --output-json/--output-html/--lang) et `compare <specs.yaml> --corpus <dir>` (avec --output-html/--baseline). Le CLI lit `rankings` du YAML pour configurer la vue HTML comparative. **Aucun module métier ajouté** : le YAML référence des classes tierces que l'utilisateur a installées. +27 tests (resolve_class 5 cas, load_from_dict 9 cas, load_from_yaml 3 cas, load_comparison 2, CLI run 2, CLI compare 2, CLI help 3). **Verrou levé** : workflow BnF type — `picarones pipeline run my_pipeline.yaml --corpus ./scans --output-html rapport.html` — sans ingénieur Python dans la boucle. Spec versionnable en git pour la reproductibilité. |
@@ -290,7 +291,7 @@ au template `_narrative_summary.html` (placé entre `_header.html` et `_critical
 ## Contexte développement
 
 - **Environnement** : GitHub Codespaces (`/workspaces/Picarones`), Python 3.12
-- **Tests** : 2548 passed, 2 skipped (Sprints 32-34 = Phase 0 close ; Sprints 35-37 = inter-moteurs livrés bout-en-bout ; Sprints 38+40+41 = NER livré bout-en-bout ; Sprints 39+42+43 = calibration livrée bout-en-bout côté rapport ; Sprint 44 = médiane par défaut ; Sprints 45+46 = stratification A.III livrée bout-en-bout ; Sprints 47-51 = les 5 adapters OCR exposent leurs confidences natives ; **Étape 2 close** ; Sprints 52-54 = axe A.II.2 (métriques structurelles) couches de calcul intégralement livrées ; Sprints 55-62 = extension philologique livrée bout-en-bout sur trois périodes + numéraux romains transversaux + câblage runner adaptive + vue HTML « Profil philologique » ; Sprints 63-70 = axe B livré bout-en-bout ; **Sprints 71-72 = A.I.1 livré bout-en-bout — rare-token recall (chantier 2) + vue HTML Worst lines globale (chantier 1)**)
+- **Tests** : 2569 passed, 2 skipped (Sprints 32-34 = Phase 0 close ; Sprints 35-37 = inter-moteurs livrés bout-en-bout ; Sprints 38+40+41 = NER livré bout-en-bout ; Sprints 39+42+43 = calibration livrée bout-en-bout côté rapport ; Sprint 44 = médiane par défaut ; Sprints 45+46 = stratification A.III livrée bout-en-bout ; Sprints 47-51 = les 5 adapters OCR exposent leurs confidences natives ; **Étape 2 close** ; Sprints 52-54 = axe A.II.2 (métriques structurelles) couches de calcul intégralement livrées ; Sprints 55-62 = extension philologique livrée bout-en-bout sur trois périodes + numéraux romains transversaux + câblage runner adaptive + vue HTML « Profil philologique » ; Sprints 63-70 = axe B livré bout-en-bout ; Sprints 71-72 = A.I.1 livré bout-en-bout — rare-token recall + vue HTML Worst lines globale ; **Sprint 73 = A.I.3 chantier 2 — détecteur narratif engine_off_baseline alimenté par l'historique SQLite**)
 - **Plan d'évolution actif** : [`docs/roadmap/evolution-2026.md`](docs/roadmap/evolution-2026.md)
 - **Branche active** : `claude/analyze-project-evolution-KOA56`
 - **Transcript de la conversation de développement** :

picarones/core/baseline_comparison.py

@@ -0,0 +1,229 @@
+"""Comparaison à la baseline historique — Sprint 73 (A.I.3).
+
+Sprint 73 — chantier 2 d'A.I.3 du plan d'évolution 2026.
+
+Pourquoi ce module
+------------------
+L'historique SQLite (``picarones/core/history.py``, Sprint 8)
+existe mais aucun détecteur narratif ne le lit.  Ce module fournit
+la couche de calcul qui répond à *« comment ce moteur se
+comporte-t-il sur ce corpus, **par rapport à ses runs précédents
+de mon institution** ? »*.
+
+Sortie typique
+--------------
+Un dict par moteur :
+
+.. code-block:: python
+
+    {
+        "engine_name": "tesseract",
+        "cer_current": 0.052,
+        "cer_historical_mean": 0.041,
+        "cer_historical_median": 0.040,
+        "n_runs": 12,
+        "absolute_delta": 0.011,
+        "relative_delta": 0.268,        # +26,8 % vs moyenne
+        "off_baseline": True,
+    }
+
+Le détecteur narratif ``engine_off_baseline`` (Sprint 73)
+consomme cette structure pour émettre des Facts.
+
+Garde-fous
+----------
+- ``min_runs`` (défaut 5) : si l'historique pour le moteur×corpus
+  contient moins de runs, on retourne ``None`` plutôt que de
+  comparer à un échantillon trop petit.
+- ``corpus_name`` est utilisé pour ne comparer qu'aux runs **du
+  même corpus** (sinon on compare des pommes et des oranges :
+  registres paroissiaux vs imprimés modernes).
+- Le run courant lui-même n'est pas inclus dans la baseline (on
+  passe le ``current_run_id`` à exclure).
+"""
+
+from __future__ import annotations
+
+import logging
+import statistics
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+def compute_engine_baseline(
+    history,
+    engine_name: str,
+    corpus_name: str,
+    current_cer: float,
+    *,
+    current_run_id: Optional[str] = None,
+    min_runs: int = 5,
+    relative_delta_threshold: float = 0.20,
+) -> Optional[dict]:
+    """Compare le CER courant d'un moteur à sa moyenne historique
+    sur le **même corpus**.
+
+    Parameters
+    ----------
+    history:
+        Instance de ``BenchmarkHistory`` (ou compatible : doit
+        exposer une méthode ``query(engine, corpus, limit)``
+        retournant une liste d'``HistoryEntry`` avec attribut
+        ``cer_mean`` et ``run_id``).
+    engine_name:
+        Nom du moteur dont on calcule la baseline.
+    corpus_name:
+        Nom du corpus — limite la comparaison aux runs antérieurs
+        sur ce même corpus.
+    current_cer:
+        CER moyen observé dans le run courant.
+    current_run_id:
+        Si fourni, le run portant cet identifiant est exclu de la
+        baseline (utile quand le run courant est déjà enregistré
+        dans l'historique avant d'appeler ce calcul).
+    min_runs:
+        Nombre minimum de runs historiques pour que la
+        comparaison soit considérée fiable.  Sous ce seuil, on
+        retourne ``None``.
+    relative_delta_threshold:
+        Seuil au-delà duquel ``off_baseline`` vaut ``True``
+        (défaut : 0,20 = 20 % d'écart relatif).
+
+    Returns
+    -------
+    Optional[dict]
+        ``None`` si :
+        - moins de ``min_runs`` runs historiques disponibles
+        - ``current_cer`` est ``None`` ou négatif
+        - tous les CER historiques sont ``None``
+
+        Sinon, dict avec les champs documentés dans le module.
+    """
+    if current_cer is None or current_cer < 0:
+        return None
+    try:
+        entries = history.query(
+            engine=engine_name, corpus=corpus_name, limit=1000,
+        )
+    except Exception as exc:  # pragma: no cover — défense
+        logger.warning(
+            "[baseline_comparison] query history a levé : %s", exc,
+        )
+        return None
+
+    historical_cers: list[float] = []
+    for entry in entries:
+        if current_run_id is not None and entry.run_id == current_run_id:
+            continue
+        cer = entry.cer_mean
+        if cer is None or cer < 0:
+            continue
+        historical_cers.append(float(cer))
+
+    if len(historical_cers) < min_runs:
+        return None
+
+    mean = statistics.fmean(historical_cers)
+    median = statistics.median(historical_cers)
+    absolute_delta = current_cer - mean
+    if mean > 0:
+        relative_delta = absolute_delta / mean
+    elif current_cer == 0:
+        relative_delta = 0.0
+    else:
+        # Baseline à 0 mais CER courant > 0 : écart infini —
+        # convention : on signale comme off_baseline avec
+        # relative_delta = None.
+        relative_delta = None
+
+    off_baseline = (
+        relative_delta is not None
+        and abs(relative_delta) > relative_delta_threshold
+    )
+
+    return {
+        "engine_name": engine_name,
+        "corpus_name": corpus_name,
+        "cer_current": float(current_cer),
+        "cer_historical_mean": mean,
+        "cer_historical_median": median,
+        "n_runs": len(historical_cers),
+        "absolute_delta": absolute_delta,
+        "relative_delta": relative_delta,
+        "off_baseline": off_baseline,
+    }
+
+
+def compute_corpus_difficulty_percentile(
+    history,
+    current_difficulty: float,
+    *,
+    min_runs: int = 5,
+) -> Optional[dict]:
+    """Place la difficulté du corpus courant dans la distribution
+    des difficultés historiques.
+
+    Lit les difficultés stockées dans ``HistoryEntry.metadata``
+    sous la clé ``difficulty`` (convention de
+    ``picarones/core/difficulty.py``).
+
+    Returns
+    -------
+    Optional[dict]
+        ``{
+            "current_difficulty": float,
+            "percentile": float,            # 0..100
+            "n_runs": int,
+            "median_historical": float,
+            "harder_than_usual": bool,      # percentile > 75
+            "easier_than_usual": bool,      # percentile < 25
+        }``
+        ou ``None`` si moins de ``min_runs`` runs historiques ont
+        une difficulté enregistrée.
+    """
+    if current_difficulty is None:
+        return None
+    try:
+        entries = history.query(limit=1000)
+    except Exception as exc:  # pragma: no cover
+        logger.warning(
+            "[baseline_comparison] query history a levé : %s", exc,
+        )
+        return None
+
+    historical_difficulties: list[float] = []
+    for entry in entries:
+        diff = entry.metadata.get("difficulty") if entry.metadata else None
+        if diff is None:
+            continue
+        try:
+            historical_difficulties.append(float(diff))
+        except (TypeError, ValueError):
+            continue
+
+    if len(historical_difficulties) < min_runs:
+        return None
+
+    sorted_diff = sorted(historical_difficulties)
+    n = len(sorted_diff)
+    # Percentile = % de corpus historiques de difficulté ≤
+    # current_difficulty.  Convention courante (P_i = i/n × 100).
+    n_below = sum(1 for d in sorted_diff if d <= current_difficulty)
+    percentile = (n_below / n) * 100.0
+    median = statistics.median(sorted_diff)
+
+    return {
+        "current_difficulty": float(current_difficulty),
+        "percentile": percentile,
+        "n_runs": n,
+        "median_historical": median,
+        "harder_than_usual": percentile > 75.0,
+        "easier_than_usual": percentile < 25.0,
+    }
+
+
+__all__ = [
+    "compute_engine_baseline",
+    "compute_corpus_difficulty_percentile",
+]

picarones/core/narrative/arbiter.py

@@ -69,6 +69,10 @@ _FALLBACK_TYPE_ORDER: tuple[FactType, ...] = (
     FactType.CONFIDENCE_WARNING,
     FactType.ENSEMBLE_OPPORTUNITY,
     FactType.MEDIAN_MEAN_GAP_WARNING,
+    # Sprint 73 — priority 150, après MEDIAN_MEAN_GAP_WARNING (140).
+    # Le détecteur off-baseline donne le contexte historique, qui
+    # vient en fin de synthèse comme « note ».
+    FactType.ENGINE_OFF_BASELINE,
 )
 
 

picarones/core/narrative/detectors.py

@@ -840,6 +840,73 @@ def detect_stratification_recommended(benchmark_data: dict) -> list[Fact]:
     )]
 
 
+# ---------------------------------------------------------------------------
+# Détecteur Sprint 73 — moteur hors baseline historique (A.I.3)
+# ---------------------------------------------------------------------------
+
+@register_detector(
+    FactType.ENGINE_OFF_BASELINE,
+    priority=150,
+    importance=FactImportance.MEDIUM,
+)
+def detect_engine_off_baseline(benchmark_data: dict) -> list[Fact]:
+    """Émet un Fact pour chaque moteur dont le CER courant s'écarte
+    significativement de sa moyenne historique sur le **même corpus**.
+
+    Lit ``benchmark_data["baseline_comparisons"]`` (liste de dicts
+    produits par ``compute_engine_baseline`` du module
+    ``baseline_comparison`` Sprint 73).  Si la clé est absente ou
+    vide, le détecteur reste silencieux — typiquement le cas quand
+    aucun historique SQLite n'a été chargé.
+
+    Garde-fous :
+
+    - Si ``n_runs < 5`` (déjà filtré par ``compute_engine_baseline``
+      qui retourne ``None`` dans ce cas).
+    - Si ``relative_delta`` n'est pas calculable (baseline = 0).
+    - Importance ``HIGH`` si ``|relative_delta| ≥ 50 %``, sinon
+      ``MEDIUM``.
+    """
+    comparisons = benchmark_data.get("baseline_comparisons") or []
+    if not isinstance(comparisons, (list, tuple)):
+        return []
+    facts: list[Fact] = []
+    for comp in comparisons:
+        if not isinstance(comp, dict):
+            continue
+        if not comp.get("off_baseline"):
+            continue
+        rel = comp.get("relative_delta")
+        if rel is None:
+            continue
+        engine = comp.get("engine_name")
+        cer_current = comp.get("cer_current")
+        cer_hist_mean = comp.get("cer_historical_mean")
+        n_runs = comp.get("n_runs")
+        if engine is None or cer_current is None or cer_hist_mean is None:
+            continue
+        importance = (
+            FactImportance.HIGH if abs(float(rel)) >= 0.50
+            else FactImportance.MEDIUM
+        )
+        facts.append(Fact(
+            type=FactType.ENGINE_OFF_BASELINE,
+            importance=importance,
+            payload={
+                "engine": engine,
+                "cer_current_pct": round(float(cer_current) * 100, 2),
+                "cer_historical_mean_pct": round(
+                    float(cer_hist_mean) * 100, 2,
+                ),
+                "n_runs": int(n_runs or 0),
+                "relative_delta_pct": round(float(rel) * 100, 1),
+                "direction": "higher" if float(rel) > 0 else "lower",
+            },
+            engines_involved=(engine,),
+        ))
+    return facts
+
+
 # ---------------------------------------------------------------------------
 # Détecteur Sprint 36 — opportunité d'ensemble (complémentarité)
 # ---------------------------------------------------------------------------

picarones/core/narrative/facts.py

@@ -76,6 +76,13 @@ class FactType(str, Enum):
     la vue stratifiée plutôt que de se fier au seul classement global
     (Sprint 46)."""
 
+    ENGINE_OFF_BASELINE = "engine_off_baseline"
+    """Le CER courant d'un moteur s'écarte significativement de sa
+    moyenne historique sur le même corpus (lue depuis l'historique
+    SQLite, Sprint 8). Lit ``BenchmarkHistory`` via le module
+    ``baseline_comparison`` (Sprint 73). Garde-fous : ≥ 5 runs
+    historiques même corpus + |delta_relatif| > 20 %."""
+
 
 class FactImportance(int, Enum):
     """Score d'importance d'un fait — décide l'ordre et la sélection."""

picarones/core/narrative/templates/en.yaml

@@ -76,3 +76,9 @@ stratification_recommended: >-
   {max_stratum_cer_pct} % on "{max_stratum}", a gap of {gap_pct}
   points. The global ranking hides this disparity; consult the
   stratified view.
+
+engine_off_baseline: >-
+  {engine} achieved {cer_current_pct} % CER here, vs {cer_historical_mean_pct} %
+  on average over the last {n_runs} runs of your institution on this
+  same corpus (relative delta {relative_delta_pct} %). This corpus is
+  harder for it than usual.

picarones/core/narrative/templates/fr.yaml

@@ -80,3 +80,9 @@ stratification_recommended: >-
   {max_stratum_cer_pct} % sur « {max_stratum} », soit {gap_pct} points
   d'écart. Le classement global masque cette disparité ; consulter la
   vue stratifiée.
+
+engine_off_baseline: >-
+  {engine} a obtenu {cer_current_pct} % CER ici, vs {cer_historical_mean_pct} %
+  en moyenne sur les {n_runs} runs précédents de votre institution sur
+  ce même corpus (écart relatif {relative_delta_pct} %). Ce corpus lui
+  est plus difficile que d'habitude.

tests/test_sprint73_baseline_comparison.py

@@ -0,0 +1,363 @@
+"""Tests Sprint 73 — A.I.3 : détecteur ``engine_off_baseline``.
+
+Couvre :
+
+1. ``compute_engine_baseline`` :
+   - Cas standard : ≥ min_runs, écart > seuil → off_baseline=True
+   - Écart faible → off_baseline=False
+   - Moins de min_runs → ``None``
+   - Baseline = 0 → ``relative_delta = None`` (et off si CER > 0)
+   - ``current_run_id`` exclu de la baseline
+   - Filtre par engine + corpus respecté
+   - CER historiques None ignorés
+2. ``compute_corpus_difficulty_percentile`` :
+   - Calcul de percentile correct
+   - ``harder_than_usual`` au-dessus de P75
+   - ``easier_than_usual`` en-dessous de P25
+   - Moins de min_runs → ``None``
+3. Détecteur ``detect_engine_off_baseline`` :
+   - Silencieux si pas de ``baseline_comparisons``
+   - Émet 1 Fact par moteur off_baseline
+   - Importance HIGH si |delta| ≥ 50 %, MEDIUM sinon
+   - Payload contient les nombres exacts pour traçabilité
+4. Rendu narratif : chaque nombre rendu est traçable au payload
+   (anti-hallucination, FR + EN).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+import pytest
+
+from picarones.core.baseline_comparison import (
+    compute_corpus_difficulty_percentile,
+    compute_engine_baseline,
+)
+from picarones.core.narrative.detectors import detect_engine_off_baseline
+from picarones.core.narrative.facts import FactImportance, FactType
+from picarones.core.narrative.renderer import render_fact
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Mock BenchmarkHistory
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@dataclass
+class _Entry:
+    run_id: str
+    engine_name: str
+    corpus_name: str
+    cer_mean: Optional[float]
+    metadata: dict = field(default_factory=dict)
+
+
+class _MockHistory:
+    def __init__(self, entries: list[_Entry]) -> None:
+        self._entries = entries
+
+    def query(
+        self,
+        engine: Optional[str] = None,
+        corpus: Optional[str] = None,
+        since: Optional[str] = None,
+        limit: int = 100,
+    ) -> list[Any]:
+        out = []
+        for e in self._entries:
+            if engine and e.engine_name != engine:
+                continue
+            if corpus and e.corpus_name != corpus:
+                continue
+            out.append(e)
+        return out[:limit]
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 1. compute_engine_baseline
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestEngineBaseline:
+    def test_off_baseline_higher(self) -> None:
+        # 10 runs historiques à 4 % CER, run courant à 5,2 % → +30 %
+        history = _MockHistory([
+            _Entry(f"r{i}", "tess", "corpus_A", 0.04)
+            for i in range(10)
+        ])
+        result = compute_engine_baseline(
+            history, "tess", "corpus_A", current_cer=0.052,
+        )
+        assert result is not None
+        assert result["n_runs"] == 10
+        assert result["cer_current"] == 0.052
+        assert result["cer_historical_mean"] == pytest.approx(0.04)
+        assert result["absolute_delta"] == pytest.approx(0.012)
+        assert result["relative_delta"] == pytest.approx(0.30)
+        assert result["off_baseline"] is True
+
+    def test_within_baseline(self) -> None:
+        history = _MockHistory([
+            _Entry(f"r{i}", "tess", "c", 0.04)
+            for i in range(10)
+        ])
+        # Run courant à 4,1 % → écart 2,5 %, sous le seuil 20 %
+        result = compute_engine_baseline(
+            history, "tess", "c", current_cer=0.041,
+        )
+        assert result is not None
+        assert result["off_baseline"] is False
+
+    def test_min_runs_filter(self) -> None:
+        # Seulement 4 runs → sous le min_runs=5
+        history = _MockHistory([
+            _Entry(f"r{i}", "tess", "c", 0.04) for i in range(4)
+        ])
+        assert compute_engine_baseline(
+            history, "tess", "c", current_cer=0.05,
+        ) is None
+
+    def test_custom_min_runs(self) -> None:
+        history = _MockHistory([
+            _Entry(f"r{i}", "tess", "c", 0.04) for i in range(3)
+        ])
+        # min_runs=2 → assez
+        result = compute_engine_baseline(
+            history, "tess", "c", current_cer=0.05, min_runs=2,
+        )
+        assert result is not None
+        assert result["n_runs"] == 3
+
+    def test_current_run_excluded(self) -> None:
+        history = _MockHistory([
+            _Entry("current", "tess", "c", 0.20),  # run courant déjà loggé
+            *[_Entry(f"r{i}", "tess", "c", 0.04) for i in range(5)],
+        ])
+        result = compute_engine_baseline(
+            history, "tess", "c", current_cer=0.05,
+            current_run_id="current",
+        )
+        assert result is not None
+        # Le 0,20 ne doit pas tirer la moyenne historique
+        assert result["n_runs"] == 5
+        assert result["cer_historical_mean"] == pytest.approx(0.04)
+
+    def test_filter_by_engine_and_corpus(self) -> None:
+        history = _MockHistory([
+            *[_Entry(f"r{i}", "tess", "corpus_A", 0.04) for i in range(5)],
+            # Mêmes runs sur autre corpus — ne doivent pas compter
+            *[_Entry(f"o{i}", "tess", "corpus_B", 0.20) for i in range(5)],
+            # Autre moteur, même corpus — ne doivent pas compter
+            *[_Entry(f"p{i}", "pero", "corpus_A", 0.99) for i in range(5)],
+        ])
+        result = compute_engine_baseline(
+            history, "tess", "corpus_A", current_cer=0.05,
+        )
+        assert result is not None
+        assert result["n_runs"] == 5
+        assert result["cer_historical_mean"] == pytest.approx(0.04)
+
+    def test_cer_none_ignored(self) -> None:
+        history = _MockHistory([
+            _Entry("r1", "tess", "c", None),
+            _Entry("r2", "tess", "c", -0.5),  # négatif → ignoré
+            *[_Entry(f"r{i}", "tess", "c", 0.04) for i in range(3, 8)],
+        ])
+        result = compute_engine_baseline(
+            history, "tess", "c", current_cer=0.05,
+        )
+        assert result is not None
+        assert result["n_runs"] == 5
+
+    def test_baseline_zero_returns_none_relative(self) -> None:
+        history = _MockHistory([
+            _Entry(f"r{i}", "tess", "c", 0.0) for i in range(5)
+        ])
+        result = compute_engine_baseline(
+            history, "tess", "c", current_cer=0.05,
+        )
+        assert result is not None
+        assert result["relative_delta"] is None
+        assert result["off_baseline"] is False  # not calculable
+
+    def test_invalid_current_cer(self) -> None:
+        history = _MockHistory([
+            _Entry(f"r{i}", "tess", "c", 0.04) for i in range(5)
+        ])
+        assert compute_engine_baseline(
+            history, "tess", "c", current_cer=None,  # type: ignore
+        ) is None
+        assert compute_engine_baseline(
+            history, "tess", "c", current_cer=-0.1,
+        ) is None
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 2. compute_corpus_difficulty_percentile
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestCorpusDifficultyPercentile:
+    def test_percentile_calculation(self) -> None:
+        history = _MockHistory([
+            _Entry(f"r{i}", "x", "c", 0.04, metadata={"difficulty": d})
+            for i, d in enumerate([0.1, 0.2, 0.3, 0.4, 0.5])
+        ])
+        result = compute_corpus_difficulty_percentile(history, 0.45)
+        assert result is not None
+        # 4 sur 5 valeurs ≤ 0.45 → P80
+        assert result["percentile"] == pytest.approx(80.0)
+        assert result["n_runs"] == 5
+
+    def test_harder_than_usual(self) -> None:
+        history = _MockHistory([
+            _Entry(f"r{i}", "x", "c", 0.04, metadata={"difficulty": 0.1 * i})
+            for i in range(1, 11)  # 10 valeurs : 0.1 .. 1.0
+        ])
+        # 0.95 → percentile 90 → harder
+        result = compute_corpus_difficulty_percentile(history, 0.95)
+        assert result is not None
+        assert result["harder_than_usual"] is True
+        assert result["easier_than_usual"] is False
+
+    def test_easier_than_usual(self) -> None:
+        history = _MockHistory([
+            _Entry(f"r{i}", "x", "c", 0.04, metadata={"difficulty": 0.1 * i})
+            for i in range(1, 11)
+        ])
+        result = compute_corpus_difficulty_percentile(history, 0.05)
+        assert result is not None
+        assert result["easier_than_usual"] is True
+        assert result["harder_than_usual"] is False
+
+    def test_min_runs_filter(self) -> None:
+        history = _MockHistory([
+            _Entry("r1", "x", "c", 0.04, metadata={"difficulty": 0.5}),
+        ])
+        assert compute_corpus_difficulty_percentile(history, 0.5) is None
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 3. Détecteur narratif
+# ────────────��─────────────────────────────────────────────────────────────
+
+
+class TestDetector:
+    def test_silent_without_baseline_data(self) -> None:
+        assert detect_engine_off_baseline({}) == []
+        assert detect_engine_off_baseline(
+            {"baseline_comparisons": []},
+        ) == []
+
+    def test_silent_when_off_baseline_false(self) -> None:
+        facts = detect_engine_off_baseline({
+            "baseline_comparisons": [
+                {
+                    "engine_name": "t", "cer_current": 0.04,
+                    "cer_historical_mean": 0.04, "n_runs": 10,
+                    "relative_delta": 0.0, "off_baseline": False,
+                },
+            ],
+        })
+        assert facts == []
+
+    def test_silent_when_relative_delta_none(self) -> None:
+        # Baseline = 0 → relative None → on s'abstient
+        facts = detect_engine_off_baseline({
+            "baseline_comparisons": [
+                {
+                    "engine_name": "t", "cer_current": 0.05,
+                    "cer_historical_mean": 0.0, "n_runs": 10,
+                    "relative_delta": None, "off_baseline": True,
+                },
+            ],
+        })
+        assert facts == []
+
+    def test_emits_fact_for_off_baseline(self) -> None:
+        facts = detect_engine_off_baseline({
+            "baseline_comparisons": [
+                {
+                    "engine_name": "tess", "cer_current": 0.052,
+                    "cer_historical_mean": 0.041, "n_runs": 12,
+                    "relative_delta": 0.268, "off_baseline": True,
+                },
+            ],
+        })
+        assert len(facts) == 1
+        f = facts[0]
+        assert f.type == FactType.ENGINE_OFF_BASELINE
+        assert f.importance == FactImportance.MEDIUM
+        assert f.payload["engine"] == "tess"
+        assert f.payload["cer_current_pct"] == 5.2
+        assert f.payload["cer_historical_mean_pct"] == 4.1
+        assert f.payload["n_runs"] == 12
+        assert f.payload["relative_delta_pct"] == 26.8
+        assert f.payload["direction"] == "higher"
+        assert f.engines_involved == ("tess",)
+
+    def test_high_importance_above_50pct(self) -> None:
+        facts = detect_engine_off_baseline({
+            "baseline_comparisons": [
+                {
+                    "engine_name": "x", "cer_current": 0.08,
+                    "cer_historical_mean": 0.04, "n_runs": 10,
+                    "relative_delta": 1.0, "off_baseline": True,
+                },
+            ],
+        })
+        assert facts[0].importance == FactImportance.HIGH
+
+    def test_multiple_engines(self) -> None:
+        facts = detect_engine_off_baseline({
+            "baseline_comparisons": [
+                {
+                    "engine_name": "tess", "cer_current": 0.05,
+                    "cer_historical_mean": 0.04, "n_runs": 10,
+                    "relative_delta": 0.25, "off_baseline": True,
+                },
+                {
+                    "engine_name": "pero", "cer_current": 0.03,
+                    "cer_historical_mean": 0.04, "n_runs": 10,
+                    "relative_delta": -0.25, "off_baseline": True,
+                },
+            ],
+        })
+        assert len(facts) == 2
+        assert facts[1].payload["direction"] == "lower"
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 4. Traçabilité anti-hallucination
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestTraceability:
+    @pytest.mark.parametrize("lang", ["fr", "en"])
+    def test_each_number_in_rendered_text_is_in_payload(
+        self, lang: str,
+    ) -> None:
+        import re
+        facts = detect_engine_off_baseline({
+            "baseline_comparisons": [
+                {
+                    "engine_name": "tess", "cer_current": 0.052,
+                    "cer_historical_mean": 0.041, "n_runs": 12,
+                    "relative_delta": 0.268, "off_baseline": True,
+                },
+            ],
+        })
+        text = render_fact(facts[0], lang=lang)
+        assert text  # non vide
+        # Chaque nombre dans le texte doit venir du payload (ou d'une
+        # constante de template — ici aucune)
+        payload_nums = {
+            "5.2", "4.1", "12", "26.8",
+        }
+        rendered_nums = set(re.findall(r"\d+\.?\d*", text))
+        for num in rendered_nums:
+            assert num in payload_nums, (
+                f"nombre rendu {num!r} non traçable au payload"
+            )