sprint74: encart HTML « Ce corpus est-il habituel ? » (A.I.3 chantier 1)

Suite directe Sprint 73 — clôture A.I.3. Vue HTML server-side
(pas de JS) qui place la difficulté du corpus courant dans la
distribution des corpus précédents stockés en SQLite (Sprint 8).

- Nouveau module picarones/report/baseline_render.py :
- build_corpus_difficulty_baseline_html : phrase factuelle +
boxplot SVG avec phrase template auto-sélectionnée selon
harder_than_usual/easier_than_usual/usual.
- _build_difficulty_boxplot_svg server-side : moustache min→max,
boîte Q1→Q3, médiane, point courant coloré adaptive (bleu si
facile, rouge si difficile, vert sinon), étiquettes
numériques, accessible (role/aria-label).
- _quantiles méthode inclusive gère N=0/1.
- Adaptive : "" si percentile_data None, boxplot omis si pas
d'historical_values.
- +4 clés i18n FR/EN avec templates Python.
- +20 tests dans test_sprint74_baseline_html.py.

A.I.3 livré bout-en-bout (Sprint 73 calc + narrative + Sprint 74
vue HTML).

Tests : 2589 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 74 — A.I.3 chantier 1 : encart « Ce corpus est-il
+  habituel ? » (clôture A.I.3).**  Suite directe Sprint 73
+  (couche calcul + détecteur narratif).  Ce sprint livre le
+  rendu HTML de l'encart qui place la difficulté du corpus
+  courant dans la distribution des corpus précédents stockés
+  en SQLite (Sprint 8) — phrase factuelle + mini-boxplot SVG.
+  - Nouveau module `picarones/report/baseline_render.py` :
+    - ``build_corpus_difficulty_baseline_html(percentile_data,
+      historical_values, labels)`` produit l'encart complet
+      (titre + phrase factuelle + boxplot SVG si valeurs
+      fournies).  Phrase template auto-sélectionnée selon les
+      flags ``harder_than_usual`` / ``easier_than_usual`` /
+      « usual » du percentile_data.
+    - ``_build_difficulty_boxplot_svg(historical_values,
+      current, width, height)`` construit un boxplot horizontal
+      SVG **server-side** (pas de JavaScript) avec :
+      - moustache min → max (ligne grise)
+      - boîte Q1 → Q3 (rectangle gris clair)
+      - médiane (trait noir épais)
+      - point courant (cercle coloré)
+    - **Couleur du point courant adaptive** :
+      - bleu (#3b87d8) si current < Q1 (corpus plus facile que
+        d'habitude)
+      - rouge (#d8553b) si current > Q3 (plus difficile)
+      - vert (#5fa860) sinon (habituel)
+    - Étiquettes numériques min / max / current visibles (fonts
+      explicites).
+    - SVG accessible : ``role="img"`` + ``aria-label``.
+    - Adaptive : retourne ``""`` si ``percentile_data is None``
+      (rapport adaptatif).  Si ``historical_values`` vide /
+      ``None``, seule la phrase factuelle est rendue (le boxplot
+      est omis silencieusement).
+  - Helper interne ``_quantiles(values)`` calcule
+    (min, Q1, median, Q3, max) avec méthode inclusive — gère le
+    cas N=0 et N=1.
+  - +4 clés i18n FR/EN (``baseline_corpus_title``,
+    ``baseline_corpus_harder``, ``baseline_corpus_easier``,
+    ``baseline_corpus_usual``).  Templates Python avec
+    placeholders ``{current:.2f}``, ``{percentile:.0f}``,
+    ``{n_runs}``.
+  - +20 tests dans `test_sprint74_baseline_html.py` :
+    - ``_quantiles`` (3 cas — simple, vide, single)
+    - SVG (8 cas — bien formé, vide, couleurs harder/easier/usual,
+      box+moustaches+cercle, dégénéré tous identiques, current
+      hors range historique)
+    - HTML (6 cas — None, harder/easier/usual, SVG omis sans
+      values, SVG présent avec values)
+    - anti-injection sur label i18n
+    - complétude i18n FR + EN
+  - **Verrou levé** : un benchmark BnF avec un historique SQLite
+    chargé peut désormais générer en tête de rapport un encart
+    qui dit *« ce corpus est plus difficile que la moyenne — au
+    88ᵉ percentile des 47 corpus précédents »* avec un boxplot
+    qui le visualise.  L'A.I.3 est livré bout-en-bout (Sprint 73
+    couche calcul + détecteur, Sprint 74 vue HTML).
+
 - **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

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). |
+| 74 | **Sprint 43 du plan d'évolution 2026 — A.I.3 chantier 1 : encart HTML « Ce corpus est-il habituel ? » (clôture A.I.3)**. Suite directe Sprint 73 (couche calcul + détecteur narratif). Nouveau module `picarones/report/baseline_render.py` : `build_corpus_difficulty_baseline_html(percentile_data, historical_values, labels)` produit phrase factuelle + boxplot SVG, phrase template auto-sélectionnée selon harder_than_usual/easier_than_usual/usual flags. `_build_difficulty_boxplot_svg` server-side avec moustache min→max, boîte Q1→Q3, médiane, point courant **coloré adaptive** (bleu si <Q1 plus facile, rouge si >Q3 plus difficile, vert sinon habituel), étiquettes numériques, accessible (role/aria-label). Helper `_quantiles` méthode inclusive gère N=0/1. Adaptive : `""` si percentile_data None, boxplot omis si historical_values vide. +4 clés i18n FR/EN avec templates Python `{current:.2f}/{percentile:.0f}/{n_runs}`. +20 tests (quantiles 3 cas, SVG 8 cas dont couleurs/dégénéré, HTML 6 cas, anti-injection, complétude i18n). **Verrou levé** : un bench avec historique SQLite chargé voit en tête de rapport « ce corpus est plus difficile que la moyenne — au 88ᵉ percentile des 47 corpus précédents » avec boxplot. **A.I.3 livré bout-en-bout** (Sprint 73 calc+narrative + Sprint 74 vue HTML). |
 | 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). |
@@ -291,7 +292,7 @@ au template `_narrative_summary.html` (placé entre `_header.html` et `_critical
 ## Contexte développement
 
 - **Environnement** : GitHub Codespaces (`/workspaces/Picarones`), Python 3.12
-- **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**)
+- **Tests** : 2589 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 ; **Sprints 73-74 = A.I.3 livré bout-en-bout — détecteur narratif engine_off_baseline + encart HTML « Ce corpus est-il habituel ? » avec boxplot SVG**)
 - **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/report/baseline_render.py

@@ -0,0 +1,238 @@
+"""Rendu de l'encart « Ce corpus est-il habituel ? » — Sprint 74.
+
+A.I.3 chantier 1 du plan d'évolution 2026.
+
+Suite directe Sprint 73 (couche calcul + détecteur narratif).  Ce
+sprint livre le rendu HTML qui place la difficulté du corpus
+courant dans la distribution des corpus précédents stockés en
+SQLite (Sprint 8) — un mini-boxplot horizontal en SVG avec un
+point pour la position du corpus courant, accompagné d'une phrase
+factuelle.
+
+Pattern identique aux autres rendus (Sprints 41/43/62/67/72) :
+**server-side**, pas de JavaScript, anti-injection systématique
+via ``html.escape``.
+
+Sortie typique
+--------------
+Un encart court (~80px de haut) à insérer en tête du rapport,
+sous la synthèse factuelle :
+
+    Difficulté observée 0,62 — au 88ᵉ percentile des 47 corpus
+    précédents de votre institution. Ce corpus est plus difficile
+    que la moyenne.
+
+    [boxplot SVG horizontal avec point courant coloré]
+
+Si moins de ``min_runs`` runs historiques ont une difficulté
+enregistrée, ``compute_corpus_difficulty_percentile`` retourne
+``None`` et le rendu retourne ``""`` (rapport adaptatif).
+"""
+
+from __future__ import annotations
+
+import statistics
+from html import escape as _e
+from typing import Optional
+
+
+def _quantiles(values: list[float]) -> tuple[float, float, float, float, float]:
+    """Retourne (min, Q1, median, Q3, max)."""
+    if not values:
+        return (0.0, 0.0, 0.0, 0.0, 0.0)
+    sorted_v = sorted(values)
+    n = len(sorted_v)
+    if n == 1:
+        v = sorted_v[0]
+        return (v, v, v, v, v)
+    median = statistics.median(sorted_v)
+    # Calcul des quartiles avec interpolation linéaire (méthode
+    # « inclusive » : Q1 = médiane de la moitié inférieure
+    # incluant la médiane si N impair).
+    half = n // 2
+    if n % 2 == 0:
+        lower = sorted_v[:half]
+        upper = sorted_v[half:]
+    else:
+        lower = sorted_v[: half + 1]
+        upper = sorted_v[half:]
+    q1 = statistics.median(lower)
+    q3 = statistics.median(upper)
+    return (sorted_v[0], q1, median, q3, sorted_v[-1])
+
+
+def _build_difficulty_boxplot_svg(
+    historical_values: list[float],
+    current: float,
+    *,
+    width: int = 480,
+    height: int = 80,
+) -> str:
+    """Construit un boxplot horizontal SVG avec point courant.
+
+    Le SVG est autonome (pas de CSS externe) et utilise des
+    coordonnées explicites — sûr à intégrer dans n'importe quel
+    document HTML.
+    """
+    if not historical_values:
+        return ""
+    min_v, q1, median, q3, max_v = _quantiles(historical_values)
+    # Borne du domaine : on inclut le point courant pour qu'il soit
+    # visible même s'il dépasse les valeurs historiques.
+    domain_min = min(min_v, current)
+    domain_max = max(max_v, current)
+    if domain_max == domain_min:
+        # Cas dégénéré : tous les points superposés
+        domain_min -= 0.01
+        domain_max += 0.01
+
+    margin_x = 30
+    margin_y = 10
+    plot_w = width - 2 * margin_x
+    plot_h = height - 2 * margin_y - 14  # 14px pour le label
+    cy = margin_y + plot_h // 2
+    box_top = cy - plot_h // 4
+    box_bottom = cy + plot_h // 4
+    whisker_top = cy - plot_h // 6
+    whisker_bottom = cy + plot_h // 6
+
+    def x(v: float) -> float:
+        return margin_x + (v - domain_min) / (domain_max - domain_min) * plot_w
+
+    # Le point courant : couleur selon position
+    if current < q1:
+        point_color = "#3b87d8"  # bleu — plus facile que d'habitude
+    elif current > q3:
+        point_color = "#d8553b"  # rouge — plus difficile
+    else:
+        point_color = "#5fa860"  # vert — habituel
+
+    parts = [
+        f'<svg xmlns="http://www.w3.org/2000/svg" '
+        f'width="{width}" height="{height}" viewBox="0 0 {width} {height}" '
+        f'role="img" aria-label="Distribution de difficulté historique">',
+        # Ligne de moustache (min → max)
+        f'<line x1="{x(min_v):.1f}" y1="{cy}" x2="{x(max_v):.1f}" '
+        f'y2="{cy}" stroke="#999" stroke-width="1"/>',
+        # Moustache verticale gauche (min)
+        f'<line x1="{x(min_v):.1f}" y1="{whisker_top}" '
+        f'x2="{x(min_v):.1f}" y2="{whisker_bottom}" '
+        f'stroke="#999" stroke-width="1"/>',
+        # Moustache verticale droite (max)
+        f'<line x1="{x(max_v):.1f}" y1="{whisker_top}" '
+        f'x2="{x(max_v):.1f}" y2="{whisker_bottom}" '
+        f'stroke="#999" stroke-width="1"/>',
+        # Boîte Q1 → Q3
+        f'<rect x="{x(q1):.1f}" y="{box_top}" '
+        f'width="{x(q3) - x(q1):.1f}" height="{box_bottom - box_top}" '
+        f'fill="#e8e8e8" stroke="#666" stroke-width="1"/>',
+        # Médiane
+        f'<line x1="{x(median):.1f}" y1="{box_top}" '
+        f'x2="{x(median):.1f}" y2="{box_bottom}" '
+        f'stroke="#333" stroke-width="2"/>',
+        # Point courant (cercle plus grand que les autres marqueurs)
+        f'<circle cx="{x(current):.1f}" cy="{cy}" r="6" '
+        f'fill="{point_color}" stroke="#000" stroke-width="1"/>',
+        # Étiquettes min / max
+        f'<text x="{x(min_v):.1f}" y="{height - 2}" '
+        f'font-size="10" fill="#666" text-anchor="middle">'
+        f'{min_v:.2f}</text>',
+        f'<text x="{x(max_v):.1f}" y="{height - 2}" '
+        f'font-size="10" fill="#666" text-anchor="middle">'
+        f'{max_v:.2f}</text>',
+        # Étiquette du point courant
+        f'<text x="{x(current):.1f}" y="{margin_y + 8}" '
+        f'font-size="11" fill="{point_color}" '
+        f'text-anchor="middle" font-weight="600">'
+        f'{current:.2f}</text>',
+        "</svg>",
+    ]
+    return "".join(parts)
+
+
+def build_corpus_difficulty_baseline_html(
+    percentile_data: Optional[dict],
+    historical_values: Optional[list[float]] = None,
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit l'encart « Ce corpus est-il habituel ? ».
+
+    Parameters
+    ----------
+    percentile_data:
+        Sortie de
+        ``picarones.core.baseline_comparison.compute_corpus_difficulty_percentile``.
+        Si ``None``, retourne ``""`` (rapport adaptatif —
+        historique trop court ou difficulté absente).
+    historical_values:
+        Liste des difficultés historiques pour le boxplot.  Si
+        ``None`` ou vide, le boxplot est omis et seule la phrase
+        factuelle apparaît.
+    labels:
+        Map i18n.
+
+    Returns
+    -------
+    str
+        HTML de l'encart, ou ``""`` si rien à afficher.
+    """
+    if not percentile_data:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "baseline_corpus_title", "Ce corpus est-il habituel ?",
+    )
+    template_harder = labels.get(
+        "baseline_corpus_harder",
+        "Difficulté observée {current:.2f} — au {percentile:.0f}ᵉ "
+        "percentile des {n_runs} corpus précédents de votre institution. "
+        "Ce corpus est plus difficile que la moyenne.",
+    )
+    template_easier = labels.get(
+        "baseline_corpus_easier",
+        "Difficulté observée {current:.2f} — au {percentile:.0f}ᵉ "
+        "percentile des {n_runs} corpus précédents. Ce corpus est "
+        "plus facile que la moyenne.",
+    )
+    template_usual = labels.get(
+        "baseline_corpus_usual",
+        "Difficulté observée {current:.2f} — au {percentile:.0f}ᵉ "
+        "percentile des {n_runs} corpus précédents. Ce corpus est "
+        "dans la moyenne.",
+    )
+
+    current = float(percentile_data.get("current_difficulty", 0.0))
+    percentile = float(percentile_data.get("percentile", 0.0))
+    n_runs = int(percentile_data.get("n_runs", 0))
+    if percentile_data.get("harder_than_usual"):
+        phrase_template = template_harder
+    elif percentile_data.get("easier_than_usual"):
+        phrase_template = template_easier
+    else:
+        phrase_template = template_usual
+    phrase = phrase_template.format(
+        current=current, percentile=percentile, n_runs=n_runs,
+    )
+
+    svg = ""
+    if historical_values:
+        svg = _build_difficulty_boxplot_svg(
+            list(historical_values), current,
+        )
+
+    parts = [
+        '<div class="baseline-corpus" '
+        'style="margin:1rem 0;padding:.75rem;'
+        'background:var(--bg-secondary,#f7f7f7);border-radius:6px">',
+        f'<div style="font-weight:600;margin-bottom:.4rem">{_e(title)}</div>',
+        f'<div style="font-size:.9rem;margin-bottom:.5rem">{_e(phrase)}</div>',
+    ]
+    if svg:
+        parts.append(svg)
+    parts.append("</div>")
+    return "".join(parts)
+
+
+__all__ = [
+    "build_corpus_difficulty_baseline_html",
+]

picarones/report/i18n/en.json

@@ -238,5 +238,9 @@
   "pipeline_gain_title": "Gain vs {baseline} on {label}",
   "pipeline_gain_absolute_label": "Absolute gain",
   "pipeline_gain_relative_label": "Relative gain",
-  "pipeline_baseline_marker": "(baseline)"
+  "pipeline_baseline_marker": "(baseline)",
+  "baseline_corpus_title": "Is this corpus typical?",
+  "baseline_corpus_harder": "Difficulty observed {current:.2f} — at the {percentile:.0f}th percentile of the {n_runs} previous corpora of your institution. This corpus is harder than usual.",
+  "baseline_corpus_easier": "Difficulty observed {current:.2f} — at the {percentile:.0f}th percentile of the {n_runs} previous corpora. This corpus is easier than usual.",
+  "baseline_corpus_usual": "Difficulty observed {current:.2f} — at the {percentile:.0f}th percentile of the {n_runs} previous corpora. This corpus is in the average."
 }

picarones/report/i18n/fr.json

@@ -238,5 +238,9 @@
   "pipeline_gain_title": "Gain vs {baseline} sur {label}",
   "pipeline_gain_absolute_label": "Gain absolu",
   "pipeline_gain_relative_label": "Gain relatif",
-  "pipeline_baseline_marker": "(référence)"
+  "pipeline_baseline_marker": "(référence)",
+  "baseline_corpus_title": "Ce corpus est-il habituel ?",
+  "baseline_corpus_harder": "Difficulté observée {current:.2f} — au {percentile:.0f}ᵉ percentile des {n_runs} corpus précédents de votre institution. Ce corpus est plus difficile que la moyenne.",
+  "baseline_corpus_easier": "Difficulté observée {current:.2f} — au {percentile:.0f}ᵉ percentile des {n_runs} corpus précédents. Ce corpus est plus facile que la moyenne.",
+  "baseline_corpus_usual": "Difficulté observée {current:.2f} — au {percentile:.0f}ᵉ percentile des {n_runs} corpus précédents. Ce corpus est dans la moyenne."
 }

tests/test_sprint74_baseline_html.py

@@ -0,0 +1,235 @@
+"""Tests Sprint 74 — A.I.3 chantier 1 : encart « Ce corpus est-il habituel ? ».
+
+Couvre :
+
+1. ``build_corpus_difficulty_baseline_html`` :
+   - Phrase factuelle rendue (harder / easier / usual)
+   - Chaîne vide si ``percentile_data is None``
+   - SVG omis si ``historical_values`` vide / None
+   - SVG rendu si valeurs fournies
+2. SVG :
+   - Bien formé (``<svg ...>...</svg>``)
+   - Point courant placé au bon endroit (couleur selon position)
+   - Boîte Q1-Q3, médiane, moustaches min-max
+3. Anti-injection : labels i18n contenant ``<script>`` échappés.
+4. Complétude i18n : nouvelles clés ``baseline_corpus_*`` présentes
+   en FR et EN.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from picarones.report.baseline_render import (
+    _build_difficulty_boxplot_svg,
+    _quantiles,
+    build_corpus_difficulty_baseline_html,
+)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 1. _quantiles
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestQuantiles:
+    def test_simple(self) -> None:
+        v = [1.0, 2.0, 3.0, 4.0, 5.0]
+        mn, q1, med, q3, mx = _quantiles(v)
+        assert mn == 1.0
+        assert mx == 5.0
+        assert med == 3.0
+
+    def test_empty(self) -> None:
+        assert _quantiles([]) == (0.0, 0.0, 0.0, 0.0, 0.0)
+
+    def test_single(self) -> None:
+        assert _quantiles([0.5]) == (0.5, 0.5, 0.5, 0.5, 0.5)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 2. SVG boxplot
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestSvg:
+    def test_well_formed(self) -> None:
+        svg = _build_difficulty_boxplot_svg(
+            [0.1, 0.2, 0.3, 0.4, 0.5], current=0.35,
+        )
+        assert svg.startswith('<svg')
+        assert svg.endswith('</svg>')
+        assert 'xmlns="http://www.w3.org/2000/svg"' in svg
+
+    def test_empty_returns_empty(self) -> None:
+        assert _build_difficulty_boxplot_svg([], current=0.5) == ""
+
+    def test_point_color_harder(self) -> None:
+        # current > Q3 → rouge
+        svg = _build_difficulty_boxplot_svg(
+            [0.1, 0.2, 0.3, 0.4, 0.5], current=0.95,
+        )
+        assert "#d8553b" in svg
+
+    def test_point_color_easier(self) -> None:
+        # current < Q1 → bleu
+        svg = _build_difficulty_boxplot_svg(
+            [0.3, 0.4, 0.5, 0.6, 0.7], current=0.1,
+        )
+        assert "#3b87d8" in svg
+
+    def test_point_color_usual(self) -> None:
+        # current entre Q1 et Q3 → vert
+        svg = _build_difficulty_boxplot_svg(
+            [0.1, 0.2, 0.3, 0.4, 0.5], current=0.3,
+        )
+        assert "#5fa860" in svg
+
+    def test_contains_box_and_whiskers(self) -> None:
+        svg = _build_difficulty_boxplot_svg(
+            [0.1, 0.2, 0.3, 0.4, 0.5], current=0.3,
+        )
+        # Au moins un rect (boîte) et plusieurs lignes (moustaches)
+        assert "<rect" in svg
+        assert "<line" in svg
+        # Cercle pour le point courant
+        assert "<circle" in svg
+
+    def test_degenerate_all_same(self) -> None:
+        # Toutes les valeurs identiques : ne doit pas crasher
+        svg = _build_difficulty_boxplot_svg(
+            [0.5, 0.5, 0.5], current=0.5,
+        )
+        assert svg.startswith('<svg')
+
+    def test_current_outside_historical_range(self) -> None:
+        # Le point courant peut dépasser les valeurs historiques
+        svg = _build_difficulty_boxplot_svg(
+            [0.1, 0.2, 0.3], current=0.99,
+        )
+        assert svg.startswith('<svg')
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 3. build_corpus_difficulty_baseline_html
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestBuildHtml:
+    def test_returns_empty_when_no_data(self) -> None:
+        assert build_corpus_difficulty_baseline_html(None) == ""
+
+    def test_renders_phrase_harder(self) -> None:
+        data = {
+            "current_difficulty": 0.62,
+            "percentile": 88.0,
+            "n_runs": 47,
+            "median_historical": 0.40,
+            "harder_than_usual": True,
+            "easier_than_usual": False,
+        }
+        html = build_corpus_difficulty_baseline_html(data)
+        assert "0.62" in html
+        assert "88" in html
+        assert "47" in html
+        assert "plus difficile" in html
+
+    def test_renders_phrase_easier(self) -> None:
+        data = {
+            "current_difficulty": 0.10,
+            "percentile": 12.0,
+            "n_runs": 30,
+            "median_historical": 0.40,
+            "harder_than_usual": False,
+            "easier_than_usual": True,
+        }
+        html = build_corpus_difficulty_baseline_html(data)
+        assert "plus facile" in html
+
+    def test_renders_phrase_usual(self) -> None:
+        data = {
+            "current_difficulty": 0.40,
+            "percentile": 50.0,
+            "n_runs": 20,
+            "median_historical": 0.40,
+            "harder_than_usual": False,
+            "easier_than_usual": False,
+        }
+        html = build_corpus_difficulty_baseline_html(data)
+        assert "dans la moyenne" in html
+
+    def test_svg_omitted_when_no_history_values(self) -> None:
+        data = {
+            "current_difficulty": 0.40,
+            "percentile": 50.0,
+            "n_runs": 20,
+            "median_historical": 0.40,
+            "harder_than_usual": False,
+            "easier_than_usual": False,
+        }
+        html = build_corpus_difficulty_baseline_html(data)
+        assert "<svg" not in html
+
+    def test_svg_present_when_history_provided(self) -> None:
+        data = {
+            "current_difficulty": 0.62,
+            "percentile": 88.0,
+            "n_runs": 5,
+            "median_historical": 0.30,
+            "harder_than_usual": True,
+            "easier_than_usual": False,
+        }
+        html = build_corpus_difficulty_baseline_html(
+            data, historical_values=[0.1, 0.2, 0.3, 0.4, 0.5],
+        )
+        assert "<svg" in html
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 4. Anti-injection
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestAntiInjection:
+    def test_label_via_i18n_escaped(self) -> None:
+        data = {
+            "current_difficulty": 0.40, "percentile": 50.0,
+            "n_runs": 20, "median_historical": 0.40,
+            "harder_than_usual": False, "easier_than_usual": False,
+        }
+        labels = {"baseline_corpus_title": "<b>Hack</b>"}
+        html = build_corpus_difficulty_baseline_html(data, labels=labels)
+        assert "<b>Hack</b>" not in html
+        assert "&lt;b&gt;Hack&lt;/b&gt;" in html
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 5. Complétude i18n
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestI18nCompleteness:
+    def _load(self, lang: str) -> dict:
+        path = (
+            Path(__file__).parent.parent
+            / "picarones" / "report" / "i18n" / f"{lang}.json"
+        )
+        return json.loads(path.read_text(encoding="utf-8"))
+
+    def test_all_keys_present_fr(self) -> None:
+        d = self._load("fr")
+        for key in (
+            "baseline_corpus_title",
+            "baseline_corpus_harder",
+            "baseline_corpus_easier",
+            "baseline_corpus_usual",
+        ):
+            assert key in d, f"manque clé FR : {key}"
+
+    def test_all_keys_present_en(self) -> None:
+        d_fr = self._load("fr")
+        d_en = self._load("en")
+        for key in d_fr:
+            if key.startswith("baseline_corpus_"):
+                assert key in d_en, f"manque clé EN : {key}"