sprint72: vue HTML Worst lines globale (A.I.1 chantier 1, clôture A.I.1)

Suite directe Sprint 71 — la métrique rare-token recall est livrée,
ce sprint livre la vue HTML qui transcende les documents pour exposer
les lignes individuelles les plus mal transcrites du corpus.

- Nouveau module picarones/core/worst_lines.py :
- 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, filtre, 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 (suppose BenchmarkResult non-compacté).
- Lignes CER=0 ignorées.
- Nouveau module picarones/report/worst_lines_render.py :
- build_worst_lines_table_html avec colonnes Rang/CER (gradient
jaune→rouge)/Moteur/Doc/Ligne#/[Strate adaptive]/Diff GT→OCR.
- Diff caractère par caractère via diff_utils.compute_char_diff
(réutilisation Sprint 5).
- Anti-injection systématique. Retourne "" si vide.
- +25 tests dans test_sprint72_worst_lines.py.

Tests : 2548 passed, 2 skipped, 0 failed.

https://claude.ai/code/session_01RusTQYcSfXqTsbFNvwmCV7

CHANGELOG.md

@@ -16,6 +16,50 @@ La numérotation de version suit [Semantic Versioning](https://semver.org/lang/f
 
 ### Ajouté
 
+- **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)
+  et la vue HTML qui expose les lignes individuelles les plus mal
+  transcrites du corpus.  Ce sprint livre la vue.
+  - 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 documents, filtre par moteur et par strate
+      (Sprint 45 ``doc_strata``), trie par CER décroissant, retourne
+      les ``top_n`` premières avec rang 1-based.
+    - Récupération des textes GT/hyp par re-split du
+      ``DocumentResult.ground_truth`` / ``hypothesis`` à l'index de
+      ligne (cf. limite : suppose un ``BenchmarkResult``
+      non-compacté).
+    - Lignes avec ``cer == 0.0`` ignorées (pas dans le worst).
+  - Nouveau module `picarones/report/worst_lines_render.py` :
+    - ``build_worst_lines_table_html(entries, labels)`` : tableau
+      HTML server-side avec colonnes Rang / CER (cellule colorée
+      gradient jaune→rouge) / Moteur / Document / Ligne # /
+      [Strate] / Diff GT→OCR.  Colonne strate **adaptive**
+      (omise si aucune entry n'a de ``script_type``).
+    - Diff caractère par caractère via
+      ``diff_utils.compute_char_diff`` (réutilisation Sprint 5),
+      rendu inline avec rouge clair barré pour suppressions et vert
+      clair pour insertions.
+    - Anti-injection systématique sur engine_name, doc_id, GT/hyp
+      lines, labels i18n.
+    - Retourne ``""`` si la liste est vide (rapport adaptatif).
+  - +25 tests dans `test_sprint72_worst_lines.py` :
+    extraction (top_n, tri par CER décroissant, rang 1-based,
+    top_n=0, lignes CER=0 ignorées) ; filtres (par moteur, par
+    strate, valeurs inconnues) ; cas limites (pas de line_metrics,
+    benchmark vide, sans doc_strata, hyp plus courte que GT) ;
+    rendu (tableau, colonnes attendues, strate adaptive, cellule
+    CER colorée, diff rendu, % affiché) ; anti-injection
+    (engine_name, doc_id, GT line, label i18n).
+  - **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 précisément.
+
 - **Sprint 71 — A.I.1 chantier 2 : rare-token recall (couche
   de calcul, démarrage de la résolution des critiques
   structurelles A.I).**  Premier sprint du chantier A.I qui

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). |
+| 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é. |
 | 69 | **Sprint 38 du plan d'évolution 2026 — Étape 4 / axe B : documentation utilisateur « Écrire un module pour le banc d'essai de pipelines »**. Premier guide pédagogique dédié à l'axe B. Nouveau document `docs/user/writing-a-pipeline-module.md` couvrant bout-en-bout : TL;DR avec exemple `MyCorrector` minimal, contrat `BaseModule` (tableau des champs + liste des `ArtifactType`), 3 exemples mockés explicitement étiquetés « pédagogique » (correcteur LLM TEXT→TEXT, reconstructeur TEXT→ALTO, classifieur TEXT→ENTITIES), orchestration mono-doc/corpus/comparaison/DAG branchant avec snippets exécutables (Sprints 63-66), génération de rapport HTML autonome (Sprints 67-68), bonnes pratiques (discipline des types, erreurs gracieuses, **pas de seuils éditoriaux dans votre module**), anti-patterns FAQ (« pourquoi pas de correcteur LLM intégré ? »…), tableau de référence rapide des sprints axe B. +34 tests anti-régression dans `test_sprint69_user_doc.py` (7 sections principales, 15 concepts API mentionnés, philosophie « banc d'essai pas atelier » + « aucun module métier » présente, références aux 6 sprints axe B + phase 0, ≥ 5 blocs Python + imports valides). **Verrou levé** : la barrière d'entrée pour un utilisateur tiers passe de « lire le code source des 6 sprints » à « lire un guide d'une page avec snippets copier-coller ». |
@@ -289,7 +290,7 @@ au template `_narrative_summary.html` (placé entre `_header.html` et `_critical
 ## Contexte développement
 
 - **Environnement** : GitHub Codespaces (`/workspaces/Picarones`), Python 3.12
-- **Tests** : 2523 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 ; **Sprint 71 = démarrage A.I (critiques structurelles) — rare-token recall (A.I.1 chantier 2)**)
+- **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)**)
 - **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/worst_lines.py

@@ -0,0 +1,199 @@
+"""Extraction transversale des « Worst lines » du corpus — Sprint 72.
+
+Sprint 72 — A.I.1 chantier 1 du plan d'évolution 2026.
+
+Pourquoi ce module
+------------------
+Le percentile p95 du CER ligne (calculé par ``line_metrics.py``,
+Sprint 10) est un nombre abstrait : *« 5 % de mes lignes ont un
+CER > 0,42 »*.  Le chercheur veut **voir** ces lignes : leur
+texte, leur diff, leur document parent, pour comprendre ce qui
+casse.
+
+Ce module fournit la requête transversale qui collecte, depuis un
+``BenchmarkResult``, les **N lignes les plus mal transcrites de
+tout le corpus**, classées par CER ligne.  Filtrable par moteur
+et par strate.
+
+Limite documentée
+-----------------
+``DocumentResult.line_metrics`` ne stocke que les CER par ligne,
+**pas le texte des lignes**.  Pour récupérer les textes GT/hyp
+on resplitte ``ground_truth`` et ``hypothesis`` du
+``DocumentResult`` à l'index de la ligne.  Cette logique
+**suppose un BenchmarkResult non-compacté** — après ``compact()``
+les textes sont tronqués à 200 caractères et les lignes au-delà
+de cette troncature ne sont plus accessibles.  En pratique on
+extrait les worst lines **avant** la sérialisation/compactage.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class WorstLineEntry:
+    """Une ligne du corpus identifiée comme mal transcrite.
+
+    Champs
+    ------
+    rank:
+        Position dans le classement (1-based, 1 = pire CER).
+    cer:
+        CER de la ligne ∈ [0, 1].
+    engine_name:
+        Nom du moteur ayant produit cette hypothèse.
+    doc_id:
+        Identifiant du document parent.
+    line_index:
+        Index 0-based de la ligne dans le document GT.
+    gt_line:
+        Texte de la ligne dans la GT.
+    hyp_line:
+        Texte correspondant dans l'hypothèse (peut être ``""``
+        si l'OCR a sauté la ligne).
+    script_type:
+        Strate du document si disponible (``script_type``
+        capturé par le runner pour la stratification A.III).
+    """
+
+    rank: int
+    cer: float
+    engine_name: str
+    doc_id: str
+    line_index: int
+    gt_line: str
+    hyp_line: str
+    script_type: Optional[str] = None
+
+
+def _split_lines(text: Optional[str]) -> list[str]:
+    """Splitte un texte en lignes (cohérent avec ``line_metrics``).
+
+    Supporte les fins de ligne ``\\n``, ``\\r\\n``, ``\\r``.  Les
+    lignes vides sont préservées.  Retourne une liste vide si le
+    texte est None ou vide.
+    """
+    if not text:
+        return []
+    # ``splitlines`` gère \r\n et \r correctement
+    return text.splitlines()
+
+
+def _line_at(text: Optional[str], index: int) -> str:
+    """Retourne la ligne à l'index demandé, ou ``""`` si l'index
+    est hors borne (cas où l'OCR a moins de lignes que la GT)."""
+    lines = _split_lines(text)
+    if 0 <= index < len(lines):
+        return lines[index]
+    return ""
+
+
+def extract_worst_lines(
+    benchmark,
+    *,
+    top_n: int = 20,
+    engine_filter: Optional[str] = None,
+    script_type_filter: Optional[str] = None,
+) -> list[WorstLineEntry]:
+    """Extrait les ``top_n`` lignes les plus mal transcrites du
+    corpus, transversalement à tous les moteurs et documents.
+
+    Parameters
+    ----------
+    benchmark:
+        ``BenchmarkResult`` non-compacté (cf. limite ci-dessus).
+        L'objet doit exposer ``engine_reports`` (liste de
+        ``EngineReport``) et optionnellement ``doc_strata``
+        (map ``{doc_id: script_type}``, Sprint 45).
+    top_n:
+        Nombre de lignes à retourner.  Défaut : 20.
+    engine_filter:
+        Si fourni, n'inclut que les lignes produites par ce moteur
+        (match exact sur ``engine_name``).
+    script_type_filter:
+        Si fourni, n'inclut que les lignes des documents de cette
+        strate (nécessite ``benchmark.doc_strata``).
+
+    Returns
+    -------
+    list[WorstLineEntry]
+        Liste triée par CER décroissant (pire en premier),
+        rang 1-based attribué après tri.  Vide si aucune ligne
+        exploitable.
+    """
+    if top_n <= 0:
+        return []
+
+    doc_strata = getattr(benchmark, "doc_strata", None) or {}
+    candidates: list[tuple[float, str, str, int, str, str, Optional[str]]] = []
+
+    for engine_report in getattr(benchmark, "engine_reports", []):
+        engine_name = engine_report.engine_name
+        if engine_filter is not None and engine_name != engine_filter:
+            continue
+        for dr in engine_report.document_results:
+            line_metrics = getattr(dr, "line_metrics", None)
+            if not line_metrics:
+                continue
+            cer_per_line = line_metrics.get("cer_per_line") if isinstance(
+                line_metrics, dict,
+            ) else getattr(line_metrics, "cer_per_line", None)
+            if not cer_per_line:
+                continue
+            doc_id = dr.doc_id
+            doc_strata_value = doc_strata.get(doc_id)
+            if (
+                script_type_filter is not None
+                and doc_strata_value != script_type_filter
+            ):
+                continue
+            for idx, cer in enumerate(cer_per_line):
+                if cer <= 0.0:
+                    continue
+                gt_line = _line_at(dr.ground_truth, idx)
+                hyp_line = _line_at(dr.hypothesis, idx)
+                if not gt_line and not hyp_line:
+                    continue
+                candidates.append((
+                    float(cer), engine_name, doc_id, idx,
+                    gt_line, hyp_line, doc_strata_value,
+                ))
+
+    if not candidates:
+        return []
+
+    # Tri par CER décroissant ; en cas d'égalité, ordre stable
+    # (engine, doc_id, line_index) pour reproductibilité.
+    candidates.sort(
+        key=lambda c: (-c[0], c[1], c[2], c[3]),
+    )
+    selected = candidates[:top_n]
+
+    return [
+        WorstLineEntry(
+            rank=i + 1,
+            cer=cer,
+            engine_name=engine,
+            doc_id=doc_id,
+            line_index=line_index,
+            gt_line=gt_line,
+            hyp_line=hyp_line,
+            script_type=script_type,
+        )
+        for i, (
+            cer, engine, doc_id, line_index,
+            gt_line, hyp_line, script_type,
+        ) in enumerate(selected)
+    ]
+
+
+__all__ = [
+    "WorstLineEntry",
+    "extract_worst_lines",
+]

picarones/report/worst_lines_render.py

@@ -0,0 +1,163 @@
+"""Rendu HTML de la vue « Worst lines globale » — Sprint 72.
+
+Suite directe de ``picarones/core/worst_lines.py`` (extraction
+transversale).  Pattern identique aux Sprints 41/43/62/67 : rendu
+**server-side**, pas de JavaScript, anti-injection systématique
+via ``html.escape``.
+
+Vue distincte du tableau gallery existant
+-----------------------------------------
+La galerie OCR (vue ``view_gallery.html``) liste les documents
+les plus problématiques.  Cette vue va plus fin : elle liste les
+**lignes individuelles** les plus problématiques, transversalement
+à tous les documents et moteurs.  Complémentaire, pas redondante.
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+from picarones.core.worst_lines import WorstLineEntry
+from picarones.report.diff_utils import compute_char_diff
+
+
+def _color_for_cer(cer: float) -> str:
+    """Gradient jaune → rouge : 0,3 jaune, 1,0 rouge profond."""
+    f = max(0.0, min(1.0, cer))
+    # Au-delà de 0,3 (seuil catastrophique courant), gradient
+    # jaune → rouge. En dessous, beige clair.
+    if f < 0.3:
+        return "#fff8dc"
+    ratio = (f - 0.3) / 0.7
+    r = int(240 + (200 - 240) * ratio)
+    g = int(220 + (60 - 220) * ratio)
+    b = int(120 + (60 - 120) * ratio)
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+def _render_diff_inline(reference: str, hypothesis: str) -> str:
+    """Rendu HTML inline d'un diff caractère par caractère.
+
+    - ``equal``   → texte normal
+    - ``delete``  → fond rouge clair, barré (manquait dans hyp)
+    - ``insert``  → fond vert clair (ajouté par hyp)
+    - ``replace`` → fond rouge clair barré + fond vert clair pour
+      la nouvelle valeur (côte à côte)
+    """
+    if not reference and not hypothesis:
+        return '<span style="opacity:.5">∅</span>'
+    ops = compute_char_diff(reference or "", hypothesis or "")
+    parts: list[str] = []
+    for op in ops:
+        kind = op["op"]
+        if kind == "equal":
+            parts.append(_e(op["text"]))
+        elif kind == "delete":
+            parts.append(
+                f'<span style="background:#fdd;text-decoration:line-through">'
+                f'{_e(op["text"])}</span>'
+            )
+        elif kind == "insert":
+            parts.append(
+                f'<span style="background:#dfd">{_e(op["text"])}</span>'
+            )
+        elif kind == "replace":
+            parts.append(
+                f'<span style="background:#fdd;text-decoration:line-through">'
+                f'{_e(op["old"])}</span>'
+                f'<span style="background:#dfd">{_e(op["new"])}</span>'
+            )
+    return "".join(parts)
+
+
+def build_worst_lines_table_html(
+    entries: list[WorstLineEntry],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit le tableau HTML des worst lines.
+
+    Retourne ``""`` si la liste est vide.  Adaptive : si aucune
+    entrée n'a de ``script_type``, la colonne strate est omise.
+    """
+    if not entries:
+        return ""
+    labels = labels or {}
+    title = labels.get("worst_lines_title", "Lignes les plus problématiques")
+    note = labels.get(
+        "worst_lines_note",
+        "Top-N lignes du corpus classées par CER ligne décroissant. "
+        "Diff caractère par caractère : rouge barré = manquant dans "
+        "l'OCR, vert = ajouté par l'OCR.",
+    )
+    rank_label = labels.get("worst_lines_rank_label", "Rang")
+    cer_label = labels.get("worst_lines_cer_label", "CER")
+    engine_label = labels.get("worst_lines_engine_label", "Moteur")
+    doc_label = labels.get("worst_lines_doc_label", "Document")
+    line_label = labels.get("worst_lines_line_label", "Ligne #")
+    strata_label = labels.get("worst_lines_strata_label", "Strate")
+    diff_label = labels.get("worst_lines_diff_label", "GT → OCR (diff)")
+
+    has_strata = any(e.script_type for e in entries)
+
+    parts = [
+        '<div class="worst-lines" style="margin:1rem 0">',
+        f'<div style="font-weight:600;margin-bottom:.4rem">{_e(title)}</div>',
+        f'<div style="font-size:.8rem;opacity:.75;margin-bottom:.5rem">'
+        f'{_e(note)}</div>',
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.85rem">',
+        '<thead><tr>',
+    ]
+    cols = [rank_label, cer_label, engine_label, doc_label, line_label]
+    if has_strata:
+        cols.append(strata_label)
+    cols.append(diff_label)
+    for col in cols:
+        parts.append(
+            f'<th style="padding:.3rem .5rem;text-align:left;'
+            f'border-bottom:1px solid #ccc;font-weight:600">'
+            f'{_e(col)}</th>'
+        )
+    parts.append("</tr></thead><tbody>")
+    for entry in entries:
+        cer_color = _color_for_cer(entry.cer)
+        parts.append("<tr>")
+        parts.append(
+            f'<td style="padding:.3rem .5rem;text-align:right;'
+            f'font-weight:600">{entry.rank}</td>'
+        )
+        parts.append(
+            f'<td style="padding:.3rem .5rem;text-align:right;'
+            f'background:{cer_color};font-family:monospace">'
+            f'{entry.cer * 100:.1f}%</td>'
+        )
+        parts.append(
+            f'<td style="padding:.3rem .5rem">{_e(entry.engine_name)}</td>'
+        )
+        parts.append(
+            f'<td style="padding:.3rem .5rem;font-family:monospace;'
+            f'font-size:.8rem">{_e(entry.doc_id)}</td>'
+        )
+        parts.append(
+            f'<td style="padding:.3rem .5rem;text-align:right">'
+            f'{entry.line_index}</td>'
+        )
+        if has_strata:
+            parts.append(
+                f'<td style="padding:.3rem .5rem;font-size:.8rem">'
+                f'{_e(entry.script_type or "—")}</td>'
+            )
+        parts.append(
+            f'<td style="padding:.3rem .5rem;font-family:monospace;'
+            f'font-size:.85rem">'
+            f'{_render_diff_inline(entry.gt_line, entry.hyp_line)}</td>'
+        )
+        parts.append("</tr>")
+    parts.append("</tbody></table></div>")
+    return "".join(parts)
+
+
+__all__ = [
+    "build_worst_lines_table_html",
+]

tests/test_sprint72_worst_lines.py

@@ -0,0 +1,322 @@
+"""Tests Sprint 72 — A.I.1 chantier 1 : vue « Worst lines globale ».
+
+Couvre :
+
+1. ``extract_worst_lines`` :
+   - Top-N respecté, tri par CER décroissant
+   - Filtre par moteur
+   - Filtre par strate (``script_type``)
+   - Lignes avec CER == 0 ignorées
+   - DocumentResult sans ``line_metrics`` ignoré
+   - Index de ligne hors borne → texte vide mais entrée incluse
+     si au moins l'un des deux côtés a du texte
+   - top_n=0 → liste vide
+2. ``WorstLineEntry`` : rang attribué après tri (1-based).
+3. ``build_worst_lines_table_html`` :
+   - Tableau rendu avec colonnes attendues
+   - Chaîne vide si entries vide
+   - Colonne strate omise si aucune entry n'a script_type
+   - Cellule CER colorée
+   - Diff GT/hyp rendu (rouge barré + vert)
+4. Anti-injection : nom moteur, doc_id, ligne GT/hyp avec
+   ``<script>`` correctement échappés.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from picarones.core.worst_lines import WorstLineEntry, extract_worst_lines
+from picarones.report.worst_lines_render import build_worst_lines_table_html
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Mocks pour BenchmarkResult / EngineReport / DocumentResult
+# ──────────────────────────────────────────────────────────────────────────
+# On évite les vrais dataclasses du runner (lourds, dépendances) pour
+# garder les tests focalisés sur la logique d'extraction.
+
+
+@dataclass
+class _DocResult:
+    doc_id: str
+    ground_truth: str
+    hypothesis: str
+    line_metrics: dict[str, Any] | None = None
+
+
+@dataclass
+class _EngineReport:
+    engine_name: str
+    document_results: list[_DocResult] = field(default_factory=list)
+
+
+@dataclass
+class _Benchmark:
+    engine_reports: list[_EngineReport] = field(default_factory=list)
+    doc_strata: dict[str, str] | None = None
+
+
+def _make_benchmark() -> _Benchmark:
+    """Construit un benchmark de test : 2 moteurs × 3 docs."""
+    bench = _Benchmark(doc_strata={"d0": "imprime", "d1": "manuscrit", "d2": "manuscrit"})
+    for engine_name, cer_offsets in (("tess", 0.0), ("pero", 0.1)):
+        docs = []
+        for doc_id, gt, hyp, cer_lines in (
+            ("d0", "ligne0\nligne1\nligne2", "ligne0\nlignE1\nligne2",
+             [0.0, 0.2, 0.0]),
+            ("d1", "abc\ndef\nghi", "abc\nXXX\nghi",
+             [0.0, 1.0, 0.0]),
+            ("d2", "alpha\nbeta\ngamma", "alpha\nbeta\nXXXXX",
+             [0.0, 0.0, 0.7]),
+        ):
+            docs.append(_DocResult(
+                doc_id=doc_id,
+                ground_truth=gt,
+                hypothesis=hyp,
+                line_metrics={
+                    "cer_per_line": [c + cer_offsets for c in cer_lines],
+                },
+            ))
+        bench.engine_reports.append(
+            _EngineReport(engine_name=engine_name, document_results=docs),
+        )
+    return bench
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 1. extract_worst_lines
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestExtractBasic:
+    def test_top_n_respected(self) -> None:
+        bench = _make_benchmark()
+        out = extract_worst_lines(bench, top_n=3)
+        assert len(out) == 3
+
+    def test_sorted_by_cer_desc(self) -> None:
+        bench = _make_benchmark()
+        out = extract_worst_lines(bench, top_n=20)
+        cers = [e.cer for e in out]
+        assert cers == sorted(cers, reverse=True)
+
+    def test_rank_is_1_based(self) -> None:
+        bench = _make_benchmark()
+        out = extract_worst_lines(bench, top_n=5)
+        ranks = [e.rank for e in out]
+        assert ranks == list(range(1, len(out) + 1))
+
+    def test_top_n_zero_returns_empty(self) -> None:
+        bench = _make_benchmark()
+        assert extract_worst_lines(bench, top_n=0) == []
+
+    def test_lines_with_zero_cer_ignored(self) -> None:
+        bench = _make_benchmark()
+        out = extract_worst_lines(bench, top_n=100)
+        for entry in out:
+            assert entry.cer > 0.0
+
+
+class TestFilters:
+    def test_engine_filter(self) -> None:
+        bench = _make_benchmark()
+        out = extract_worst_lines(bench, top_n=20, engine_filter="pero")
+        assert all(e.engine_name == "pero" for e in out)
+        assert len(out) > 0
+
+    def test_engine_filter_unknown_engine(self) -> None:
+        bench = _make_benchmark()
+        out = extract_worst_lines(
+            bench, top_n=20, engine_filter="non_existing",
+        )
+        assert out == []
+
+    def test_strata_filter(self) -> None:
+        bench = _make_benchmark()
+        out = extract_worst_lines(
+            bench, top_n=20, script_type_filter="manuscrit",
+        )
+        assert all(e.script_type == "manuscrit" for e in out)
+        assert len(out) > 0
+
+    def test_strata_filter_unknown_strata(self) -> None:
+        bench = _make_benchmark()
+        out = extract_worst_lines(
+            bench, top_n=20, script_type_filter="non_existing",
+        )
+        assert out == []
+
+
+class TestEdgeCases:
+    def test_no_line_metrics(self) -> None:
+        bench = _Benchmark(engine_reports=[
+            _EngineReport(engine_name="x", document_results=[
+                _DocResult(doc_id="d", ground_truth="x", hypothesis="x",
+                           line_metrics=None),
+            ]),
+        ])
+        assert extract_worst_lines(bench) == []
+
+    def test_empty_engine_reports(self) -> None:
+        bench = _Benchmark()
+        assert extract_worst_lines(bench) == []
+
+    def test_no_doc_strata_attribute(self) -> None:
+        # benchmark sans attribut doc_strata → pas de filtre strata
+        # mais l'extraction fonctionne
+        bench = _Benchmark(engine_reports=[
+            _EngineReport(engine_name="x", document_results=[
+                _DocResult(
+                    doc_id="d", ground_truth="abc", hypothesis="aXc",
+                    line_metrics={"cer_per_line": [0.5]},
+                ),
+            ]),
+        ])
+        out = extract_worst_lines(bench, top_n=5)
+        assert len(out) == 1
+        assert out[0].script_type is None
+
+    def test_hyp_shorter_than_gt(self) -> None:
+        # Hyp a moins de lignes que GT — ligne en trop dans GT
+        # est récupérée avec hyp_line=""
+        bench = _Benchmark(engine_reports=[
+            _EngineReport(engine_name="x", document_results=[
+                _DocResult(
+                    doc_id="d", ground_truth="abc\ndef\nghi",
+                    hypothesis="abc",  # 1 ligne seulement
+                    line_metrics={"cer_per_line": [0.0, 1.0, 1.0]},
+                ),
+            ]),
+        ])
+        out = extract_worst_lines(bench, top_n=5)
+        assert len(out) == 2  # lignes 1 et 2 avec CER = 1.0
+        for entry in out:
+            assert entry.hyp_line == ""
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 2. build_worst_lines_table_html
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestRender:
+    def _sample_entries(self) -> list[WorstLineEntry]:
+        return [
+            WorstLineEntry(
+                rank=1, cer=0.95, engine_name="tess", doc_id="d1",
+                line_index=2, gt_line="bonjour le monde",
+                hyp_line="bnjour 1e mnde", script_type="imprime",
+            ),
+            WorstLineEntry(
+                rank=2, cer=0.42, engine_name="pero", doc_id="d3",
+                line_index=0, gt_line="hello world",
+                hyp_line="hello wOrld", script_type="manuscrit",
+            ),
+        ]
+
+    def test_renders_table(self) -> None:
+        html = build_worst_lines_table_html(self._sample_entries())
+        assert "<table" in html
+        assert "tess" in html
+        assert "pero" in html
+        assert "d1" in html
+        assert "d3" in html
+
+    def test_empty_returns_empty(self) -> None:
+        assert build_worst_lines_table_html([]) == ""
+
+    def test_columns_present(self) -> None:
+        html = build_worst_lines_table_html(self._sample_entries())
+        for col in ("Rang", "CER", "Moteur", "Document", "Ligne"):
+            assert col in html
+
+    def test_strata_column_when_present(self) -> None:
+        html = build_worst_lines_table_html(self._sample_entries())
+        assert "Strate" in html
+        assert "imprime" in html
+        assert "manuscrit" in html
+
+    def test_strata_column_omitted_when_absent(self) -> None:
+        entries = [
+            WorstLineEntry(
+                rank=1, cer=0.5, engine_name="t", doc_id="d", line_index=0,
+                gt_line="abc", hyp_line="aXc", script_type=None,
+            ),
+        ]
+        html = build_worst_lines_table_html(entries)
+        assert "Strate" not in html
+
+    def test_cer_cell_colored(self) -> None:
+        html = build_worst_lines_table_html(self._sample_entries())
+        assert "background:#" in html
+
+    def test_diff_rendered(self) -> None:
+        html = build_worst_lines_table_html(self._sample_entries())
+        # Diff inline : couleurs rouge clair pour suppressions, vert pour insertions
+        assert "#fdd" in html
+        assert "#dfd" in html
+
+    def test_cer_displayed_as_percent(self) -> None:
+        html = build_worst_lines_table_html(self._sample_entries())
+        assert "95.0%" in html
+        assert "42.0%" in html
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 3. Anti-injection
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestAntiInjection:
+    def test_engine_name_escaped(self) -> None:
+        entries = [
+            WorstLineEntry(
+                rank=1, cer=0.5, engine_name="<script>alert(1)</script>",
+                doc_id="d", line_index=0,
+                gt_line="abc", hyp_line="aXc",
+            ),
+        ]
+        html = build_worst_lines_table_html(entries)
+        assert "<script>" not in html
+        assert "&lt;script&gt;" in html
+
+    def test_doc_id_escaped(self) -> None:
+        entries = [
+            WorstLineEntry(
+                rank=1, cer=0.5, engine_name="t",
+                doc_id="<img src=x>", line_index=0,
+                gt_line="abc", hyp_line="aXc",
+            ),
+        ]
+        html = build_worst_lines_table_html(entries)
+        assert "<img src=x>" not in html
+        assert "&lt;img" in html
+
+    def test_gt_line_escaped(self) -> None:
+        entries = [
+            WorstLineEntry(
+                rank=1, cer=0.5, engine_name="t", doc_id="d", line_index=0,
+                gt_line="<b>HACK</b>", hyp_line="bonjour",
+            ),
+        ]
+        html = build_worst_lines_table_html(entries)
+        # La balise brute ne doit pas être présente.  Le diff
+        # caractère-par-caractère peut splitter ``<b>`` en chunks
+        # séparés mais chaque chunk est échappé.
+        assert "<b>HACK</b>" not in html
+        assert "&lt;" in html
+        assert "&gt;" in html
+
+    def test_label_via_i18n_escaped(self) -> None:
+        entries = [
+            WorstLineEntry(
+                rank=1, cer=0.5, engine_name="t", doc_id="d", line_index=0,
+                gt_line="abc", hyp_line="aXc",
+            ),
+        ]
+        labels = {"worst_lines_title": "<b>X</b>"}
+        html = build_worst_lines_table_html(entries, labels=labels)
+        assert "<b>X</b>" not in html
+        assert "&lt;b&gt;" in html