sprint53: A.II.2.1 Reading order F1 ICDAR 2015 — couche de calcul

Suite du Sprint 52 dans l'axe A.II.2 (métriques structurelles).
Sur un manuscrit glosé ou un journal multi-colonnes, un moteur peut
avoir un excellent CER caractère et un ordre de lecture
catastrophique — le résultat est inutilisable pour la recherche
plein texte ou la reconstitution narrative.

Métrique standard ICDAR 2015 (Antonacopoulos et al.) : pour chaque
paire (a, b) où a précède strictement b dans la GT, on vérifie si
a précède aussi b dans l'hypothèse. F1 = harmonic mean de
precision/recall.

Nouveau picarones/core/reading_order.py
- compute_reading_order_metrics(ref_order, hyp_order) retourne
precision/recall/F1 + détails complets : TP, FP, FN, paires
totales, régions communes vs ref_only vs hyp_only.
- reading_order_f1 : raccourci pour récupérer juste le F1.
- Conventions :
- Doublons : première occurrence retenue (cohérent ICDAR, IDs
uniques).
- Vide ou None : F1 = 0 (pas de récompense gratuite).
- Single region : 0 paire → F1 = 0 (convention de bord).
- Format directement compatible avec ReadingOrderGT.region_order
du Sprint 32.

reading_order_f1 enregistré dans le registre typé Sprint 34 pour
la jonction (READING_ORDER, READING_ORDER) — appelable via
compute_at_junction comme les autres métriques.

Tests : +16 dans test_sprint53_reading_order.py couvrant :
- canoniques : identique → F1=1, inversé → F1=0, permutation
locale (b↔c → 5/6), insertion (TP préservés + FP), suppression
- dégénérés : vide bilatéral, vide unilatéral (FP ou FN),
single region, None, doublons (première occurrence)
- comptages : régions communes/ref_only/hyp_only séparés,
n_pairs cohérent avec C(n, 2)
- intégration registre typé : sélection (READING_ORDER,
READING_ORDER), compute_at_junction, équivalence shortcut/full
Suite complète : 1962 → 1978 passed, 2 skipped, 0 failed.

Stratégie de découpage cohérente avec NER (Sprint 38), calibration
(Sprint 39), Flesch (Sprint 52) : couche de calcul pure d'abord,
câblage runner + HTML aux sprints suivants. Reste pour A.II.2 :
A.II.2.2 Layout F1 par type de région.

CHANGELOG.md

@@ -16,6 +16,31 @@ La numérotation de version suit [Semantic Versioning](https://semver.org/lang/f
 
 ### Ajouté
 
+- **Sprint 53 — A.II.2.1 Reading order F1 (ICDAR 2015) : couche de
+  calcul.** Suite du Sprint 52 dans l'axe A.II.2 (métriques
+  structurelles).  Sur un manuscrit glosé ou un journal multi-colonnes,
+  un moteur peut avoir un excellent CER caractère et un ordre de
+  lecture catastrophique — le CER seul ne capture pas cette
+  dimension.
+  - Nouveau module `picarones/core/reading_order.py` :
+    - ``compute_reading_order_metrics(ref_order, hyp_order)`` :
+      pour chaque paire ``(a, b)`` où ``a`` précède ``b`` dans la GT,
+      vérifie si ``a`` précède aussi ``b`` dans l'hypothèse.  Retourne
+      precision/recall/F1 + détails (TP/FP/FN, paires totales, régions
+      communes vs disjointes).
+    - ``reading_order_f1`` : raccourci qui retourne juste le F1.
+  - Conventions : doublons traités à la première occurrence,
+    séquences ``None``/vides → F1 = 0 (pas de récompense gratuite),
+    séquence à 1 région → 0 paire émise → F1 = 0 (convention de bord).
+  - Format compatible avec ``ReadingOrderGT.region_order`` du
+    Sprint 32 — l'utilisateur fournit directement la liste d'IDs.
+  - ``reading_order_f1`` enregistré dans le registre typé Sprint 34
+    pour la jonction ``(READING_ORDER, READING_ORDER)``.
+  - +16 tests dans `test_sprint53_reading_order.py` (cas canoniques :
+    identique → F1=1, inversé → F1=0, permutation locale, insertion,
+    suppression ; cas dégénérés : vide, single region, doublons,
+    None ; comptages détaillés ; intégration registre typé).
+
 - **Sprint 52 — A.II.2.3 Différence Flesch : couche de calcul
   (démarrage de l'Étape 3 / axe A — métriques structurelles).**
   Stratégie identique aux Sprints 35/38/39 (couche pure d'abord,
@@ -659,20 +684,16 @@ La numérotation de version suit [Semantic Versioning](https://semver.org/lang/f
 
 ### Tests
 
-- 1478 → 1962 tests (+17 Sprint 32, +23 Sprint 33, +21 Sprint 34,
+- 1478 → 1978 tests (+17 Sprint 32, +23 Sprint 33, +21 Sprint 34,
   +27 Sprint 35, +22 Sprint 36, +42 Sprint 37, +19 Sprint 38,
   +32 Sprint 39, +16 Sprint 40, +38 Sprint 41, +17 Sprint 42,
   +43 Sprint 43, +15 Sprint 44, +16 Sprint 45, +38 Sprint 46,
   +9 Sprint 47, +14 Sprint 48, +17 Sprint 49, +17 Sprint 50,
-  +16 Sprint 51, +25 Sprint 52). Aucune régression. **Phase 0
-  close ; Étape 2 du plan d'évolution intégralement livrée :**
-  inter-moteurs (A.II.1.c), NER (A.II.1.a), calibration (A.II.1.b)
-  et stratification (A.III) livrés bout-en-bout calcul → runner →
-  HTML ; A.I.2 médiane par défaut livré (Sprint 44) ; les 5
-  adapters OCR (Tesseract, Pero, Mistral, Google Vision, Azure DI)
-  exposent désormais leurs `token_confidences` natifs.
-  **Étape 3 démarrée :** Flesch (A.II.2.3) couche de calcul livrée
-  (Sprint 52).
+  +16 Sprint 51, +25 Sprint 52, +16 Sprint 53). Aucune régression.
+  **Phase 0 close ; Étape 2 du plan d'évolution intégralement
+  livrée ; Étape 3 démarrée :** Flesch (A.II.2.3, Sprint 52) et
+  Reading order F1 ICDAR 2015 (A.II.2.1, Sprint 53) couches de
+  calcul livrées.
 
 ---
 

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). |
+| 53 | **Sprint 22 du plan d'évolution 2026 — Étape 3 / axe A.II.2.1 : Reading order F1 ICDAR 2015 (couche de calcul)**. Métrique standard d'Antonacopoulos et al. : sur un manuscrit glosé ou un journal multi-colonnes, un moteur peut avoir un excellent CER caractère et un ordre de lecture catastrophique. Le module `picarones/core/reading_order.py` expose `compute_reading_order_metrics(ref_order, hyp_order)` qui calcule, pour chaque paire `(a, b)` où `a` précède `b` dans la GT, si `a` précède aussi `b` dans l'hypothèse — retourne precision/recall/F1 + détails (TP/FP/FN, régions communes vs disjointes). Conventions : doublons traités à la première occurrence, vide/None → F1 = 0 (pas de récompense gratuite), single region → 0 paire émise. Format compatible direct avec `ReadingOrderGT.region_order` du Sprint 32. `reading_order_f1` enregistré dans le registre typé Sprint 34 pour la jonction `(READING_ORDER, READING_ORDER)`. +16 tests dans `test_sprint53_reading_order.py` (canoniques : identique→1, inversé→0, permutation locale, insertion, suppression ; dégénérés : vide, single, doublons, None ; comptages ; registre). **Verrou levé** : un benchmark dont le corpus a une GT `reading_order` peut désormais classer les moteurs sur leur fidélité à l'ordre de lecture des régions ALTO/PAGE — métrique critique pour les manuscrits glosés et les journaux multi-colonnes. |
 | 52 | **Sprint 21 du plan d'évolution 2026 — Étape 3 / axe A.II.2.3 : différence de score Flesch (couche de calcul)**. Premier sprint de l'Étape 3 (métriques structurelles), démarré après la clôture de l'Étape 2. Nouveau module `picarones/core/readability.py` : `count_syllables_word` (heuristique groupes de voyelles + diacritiques FR/EN), `count_words`/`count_sentences`, `flesch_score(text, lang)` avec coefficients FR (Kandel-Moles 1958) et EN (Flesch 1948), score borné `[0, 100]`. `flesch_delta(reference, hypothesis, lang)` retourne `Flesch(OCR) - Flesch(GT)` — **positif = signal d'over-normalisation LLM**. **Aucun alignement caractère/mot requis** : la métrique reste calculable même quand l'OCR est très dégradé, ce qui en fait l'outil le plus fiable pour repérer les VLM/LLM hallucinant du texte moderne plausible mais déconnecté de la GT. `flesch_delta_fr` et `flesch_delta_en` enregistrés dans le registre typé Sprint 34 pour la jonction `(TEXT, TEXT)`. +25 tests dans `test_sprint52_readability.py` (compteurs avec cas limites, score borné, FR/EN cohérents, **cas réaliste de modernisation LLM → delta > 10 pts**, intégration registre typé). **Verrou levé** : les détecteurs narratifs futurs peuvent maintenant signaler automatiquement une over-normalisation par LLM via le delta Flesch, sans dépendre de l'alignement OCR/GT (métrique robuste aux pires cas). |
 | 51 | **Sprint 20 du plan d'évolution 2026 — Étape 2 / adaptation engines : Azure DI expose `Word.confidence` (clôture de l'adaptation engines)**. Suite directe des Sprints 47-50. La réponse Azure expose `analyzeResult.pages[].words[]` avec `content` et `confidence` ∈ [0, 1]. Refactor : `_run_ocr_with_result(image_path) → (text, analyze_result_dict)` centralise les deux chemins (SDK `azure-ai-documentintelligence` et REST direct via `urllib` avec polling Azure asynchrone). `_sdk_result_to_dict` convertit l'objet SDK en dict normalisé identique au REST. `_extract_token_confidences_from_result` parcourt `pages[].words[]`, filtre les confidences None/négatives et contenus vides. Texte préservé octet par octet (extraction depuis `pages[].lines[]`). Flag `expose_confidences: false`. API appelée une seule fois. +16 tests dans `test_sprint51_azure_confidences.py` (extraction multi-pages, filtrage 4 cas, cas dégénérés 4 cas, conversion SDK → dict, surcharge `run()` avec mock, échec API, intégration runner). **Verrou levé** : tous les 5 adapters OCR (Tesseract, Pero OCR, Mistral OCR, Google Vision, Azure DI) exposent désormais leurs `token_confidences` natifs — l'utilisateur obtient automatiquement ECE/MCE/reliability dans le rapport quel que soit le moteur. **L'Étape 2 du plan d'évolution 2026 est intégralement livrée bout-en-bout.** |
 | 50 | **Sprint 19 du plan d'évolution 2026 — Étape 2 / adaptation engines : Google Vision expose `Word.confidence`**. Suite directe des Sprints 47-49. ``DOCUMENT_TEXT_DETECTION`` expose ``Word.confidence`` au niveau mot sur ``page > block > paragraph > word``. Refactor : `_run_ocr_with_full_annotation(image_path) → (text, full_dict)` centralise les deux chemins (SDK `google-cloud-vision` et REST via `urllib`). `_sdk_full_text_to_dict` convertit le proto SDK en dict normalisé identique au REST pour traitement uniforme. `_extract_token_confidences_from_full_text` parcourt la hiérarchie et reconstruit chaque mot par concaténation des `word.symbols[i].text`. Confidence ∈ [0, 1] (format runner Sprint 42 direct). Filtrage cohérent (conf None/négative, mots vides ignorés). `TEXT_DETECTION` (mode court) → `token_confidences = None`. Flag `expose_confidences: false`. API appelée une seule fois. +17 tests dans `test_sprint50_google_vision_confidences.py` (reconstruction depuis symbols, multi-pages/blocks, filtrage 5 cas, conversion SDK → dict, surcharge `run()` avec mock, REST avec urllib mocké, intégration runner). **Verrou levé** : un benchmark Google Vision en mode `DOCUMENT_TEXT_DETECTION` produit automatiquement ECE/MCE/reliability dans le rapport. Reste Azure DI à adapter. |
@@ -270,7 +271,7 @@ au template `_narrative_summary.html` (placé entre `_header.html` et `_critical
 ## Contexte développement
 
 - **Environnement** : GitHub Codespaces (`/workspaces/Picarones`), Python 3.12
-- **Tests** : 1962 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 — Tesseract, Pero OCR, Mistral OCR, Google Vision et Azure DI — exposent leurs confidences natives ; **Étape 2 close** ; Sprint 52 = Flesch couche de calcul (démarrage Étape 3 / axe A.II.2))
+- **Tests** : 1978 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-53 = Flesch + Reading order F1 ICDAR couches de calcul (Étape 3 / axe A.II.2 démarrée))
 - **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/reading_order.py

@@ -0,0 +1,196 @@
+"""Reading order F1 (ICDAR 2015, Antonacopoulos) — Sprint 53.
+
+Sprint 53 — A.II.2.1 du plan d'évolution 2026.
+
+Pourquoi ce module
+------------------
+Sur un manuscrit glosé, un journal multi-colonnes ou un registre
+paroissial complexe, le **classement des moteurs en CER** peut être
+trompeur : un moteur peut avoir un excellent CER caractère et un
+**ordre de lecture catastrophique**.  Le résultat est inutilisable
+pour la recherche plein texte (Elastic, Solr) ou pour reconstituer
+une narration linéaire.
+
+La métrique standard est définie par Antonacopoulos et al. dans
+ICDAR 2015 — F1 sur les **paires d'ordre relatif** entre régions
+ALTO/PAGE.  Pour chaque paire ``(a, b)`` telle que ``a`` précède
+``b`` dans la GT :
+
+- **TP** si ``a`` précède aussi ``b`` dans l'hypothèse,
+- **FN** si la paire est manquante (régions absentes ou ordre
+  inversé) côté hypothèse,
+- **FP** si une paire ``(a, b)`` apparaît dans l'hypothèse alors que
+  la GT n'a pas cet ordre (régions hallucinées ou inversion).
+
+Le F1 est la moyenne harmonique des deux.
+
+Stratégie de découpage
+----------------------
+Cohérent avec NER (Sprint 38), calibration (Sprint 39), Flesch
+(Sprint 52) : couche de calcul pure d'abord.  L'utilisateur fournit
+deux listes ordonnées d'IDs de régions (typiquement extraites de
+ALTO/PAGE par un parser amont).  Le câblage runner et la vue HTML
+suivent dans des sprints dédiés.
+
+Compatible directement avec ``ReadingOrderGT`` du Sprint 32 :
+``ReadingOrderGT.region_order`` est exactement le format attendu.
+
+Convention sur les régions
+--------------------------
+- Les IDs sont des chaînes (``"r_1"``, ``"region_main"``, etc.).
+- Les **doublons** sont ignorés au calcul des paires ordonnées
+  (chaque ID compte une fois par séquence).
+- Une région présente dans la GT mais absente de l'hypothèse
+  contribue aux paires FN.
+- Une région présente dans l'hypothèse mais absente de la GT
+  contribue aux paires FP.
+- Si une séquence a < 2 régions distinctes, aucune paire n'est
+  émise — le F1 retourne ``0.0`` ou ``1.0`` selon que les deux
+  séquences soient identiques.
+"""
+
+from __future__ import annotations
+
+import logging
+from itertools import combinations
+from typing import Iterable
+
+from picarones.core.metric_registry import register_metric
+from picarones.core.modules import ArtifactType
+
+logger = logging.getLogger(__name__)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Helpers
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def _ordered_pairs(sequence: list[str]) -> set[tuple[str, str]]:
+    """Retourne l'ensemble des paires ``(a, b)`` telles que ``a``
+    précède strictement ``b`` dans ``sequence``.
+
+    Doublons : chaque ID est traité une seule fois (première occurrence
+    dans la séquence).  Cohérent avec ICDAR 2015 où les régions ont
+    des IDs uniques.
+    """
+    seen: list[str] = []
+    seen_set: set[str] = set()
+    for r in sequence:
+        if r not in seen_set:
+            seen.append(r)
+            seen_set.add(r)
+    return set(combinations(seen, 2))
+
+
+def _normalize_input(value: Iterable[str] | None) -> list[str]:
+    """Coerce une entrée en list[str], en filtrant les valeurs vides."""
+    if value is None:
+        return []
+    return [str(v) for v in value if v is not None and str(v).strip()]
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Métrique principale
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def compute_reading_order_metrics(
+    reference_order: Iterable[str] | None,
+    hypothesis_order: Iterable[str] | None,
+) -> dict:
+    """Calcule precision / recall / F1 sur l'ordre relatif des régions.
+
+    Parameters
+    ----------
+    reference_order:
+        Séquence ordonnée d'IDs de régions issue de la GT (typiquement
+        ``ReadingOrderGT.region_order`` du Sprint 32).
+    hypothesis_order:
+        Séquence ordonnée d'IDs de régions produite par un moteur
+        OCR/HTR ou un reconstructeur ALTO.
+
+    Returns
+    -------
+    dict
+        ``{"precision", "recall", "f1", "true_positives",
+        "false_positives", "false_negatives", "n_ref_pairs",
+        "n_hyp_pairs", "common_regions", "ref_only_regions",
+        "hyp_only_regions"}``.
+
+    Comportements aux bornes
+    ------------------------
+    - Deux s��quences identiques (mêmes régions, même ordre) → F1 = 1.0.
+    - Ordre strictement inversé → F1 = 0.0 (toutes les paires
+      relatives sont fausses).
+    - Une séquence vide vs une séquence non vide → F1 = 0.0.
+    - Deux séquences vides → F1 = 0.0 et tous les compteurs à 0
+      (convention : on ne récompense pas l'absence).
+    """
+    ref = _normalize_input(reference_order)
+    hyp = _normalize_input(hypothesis_order)
+
+    ref_pairs = _ordered_pairs(ref)
+    hyp_pairs = _ordered_pairs(hyp)
+
+    tp = len(ref_pairs & hyp_pairs)
+    fn = len(ref_pairs - hyp_pairs)
+    fp = len(hyp_pairs - ref_pairs)
+
+    precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0
+    recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0
+    f1 = (
+        2 * precision * recall / (precision + recall)
+        if (precision + recall) > 0
+        else 0.0
+    )
+
+    ref_set = set(ref)
+    hyp_set = set(hyp)
+    return {
+        "precision": precision,
+        "recall": recall,
+        "f1": f1,
+        "true_positives": tp,
+        "false_positives": fp,
+        "false_negatives": fn,
+        "n_ref_pairs": len(ref_pairs),
+        "n_hyp_pairs": len(hyp_pairs),
+        "common_regions": sorted(ref_set & hyp_set),
+        "ref_only_regions": sorted(ref_set - hyp_set),
+        "hyp_only_regions": sorted(hyp_set - ref_set),
+    }
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Enregistrement dans le registre typé (Sprint 34)
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@register_metric(
+    name="reading_order_f1",
+    input_types=(ArtifactType.READING_ORDER, ArtifactType.READING_ORDER),
+    description=(
+        "F1 sur l'ordre relatif des régions ALTO/PAGE (ICDAR 2015, "
+        "Antonacopoulos). Pour chaque paire (a,b) où a précède b dans "
+        "la GT, vérifie que a précède aussi b dans l'hypothèse."
+    ),
+    higher_is_better=True,
+    tags={"structure", "icdar", "alto", "page"},
+)
+def reading_order_f1(
+    reference: Iterable[str] | None,
+    hypothesis: Iterable[str] | None,
+) -> float:
+    """Raccourci : retourne uniquement le F1 global.
+
+    Pour les détails par paire (TP/FP/FN, régions communes, etc.),
+    appeler ``compute_reading_order_metrics`` directement.
+    """
+    return compute_reading_order_metrics(reference, hypothesis)["f1"]
+
+
+__all__ = [
+    "compute_reading_order_metrics",
+    "reading_order_f1",
+]

tests/test_sprint53_reading_order.py

@@ -0,0 +1,207 @@
+"""Tests Sprint 53 — Reading order F1 (ICDAR 2015).
+
+Couvre :
+
+1. **Cas canoniques** :
+   - Séquences identiques → F1 = 1.0
+   - Séquences strictement inversées → F1 = 0.0
+   - Permutation locale → F1 calculé sur les paires conservées
+   - Insertion d'une région → F1 = recall × precision sur paires
+2. **Cas dégénérés** :
+   - Une séquence vide → F1 = 0
+   - Deux séquences vides → F1 = 0
+   - Une seule région → pas de paire, F1 = 0
+   - Doublons dans une séquence → traitement déterministe
+3. **Comptages détaillés** :
+   - TP, FP, FN cohérents
+   - common/ref_only/hyp_only correctement séparés
+4. **Intégration registre typé** :
+   - ``reading_order_f1`` est sélectionné pour la jonction
+     ``(READING_ORDER, READING_ORDER)``
+   - Le shortcut retourne la même valeur que
+     ``compute_reading_order_metrics["f1"]``
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from picarones.core.metric_registry import compute_at_junction, select_metrics
+from picarones.core.modules import ArtifactType
+from picarones.core.reading_order import (
+    compute_reading_order_metrics,
+    reading_order_f1,
+)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 1. Cas canoniques
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestCanonicalCases:
+    def test_identical_sequences_f1_one(self) -> None:
+        m = compute_reading_order_metrics(
+            ["r1", "r2", "r3", "r4"],
+            ["r1", "r2", "r3", "r4"],
+        )
+        assert m["f1"] == pytest.approx(1.0)
+        assert m["precision"] == pytest.approx(1.0)
+        assert m["recall"] == pytest.approx(1.0)
+        assert m["false_positives"] == 0
+        assert m["false_negatives"] == 0
+
+    def test_strictly_reversed_f1_zero(self) -> None:
+        m = compute_reading_order_metrics(
+            ["a", "b", "c"],
+            ["c", "b", "a"],
+        )
+        # Les 3 paires (a,b), (a,c), (b,c) sont toutes inversées
+        # côté hypothèse → 0 TP, 3 FN, 3 FP, F1 = 0
+        assert m["f1"] == 0.0
+        assert m["true_positives"] == 0
+        assert m["false_positives"] == 3
+        assert m["false_negatives"] == 3
+
+    def test_local_permutation(self) -> None:
+        # GT : a, b, c, d → 6 paires.  Échange interne b↔c → 5 paires
+        # préservées (toutes sauf b-c qui devient c-b).
+        m = compute_reading_order_metrics(
+            ["a", "b", "c", "d"],
+            ["a", "c", "b", "d"],
+        )
+        assert m["true_positives"] == 5
+        assert m["false_negatives"] == 1
+        assert m["false_positives"] == 1
+        assert m["f1"] == pytest.approx(5 / 6)
+
+    def test_insertion_preserves_existing_pairs(self) -> None:
+        # GT : a, b, c → 3 paires.  Hypothèse insère X au milieu :
+        # a, X, b, c → 6 paires (a-X, a-b, a-c, X-b, X-c, b-c).
+        # 3 TP (paires GT préservées) + 3 FP (paires inventées avec X).
+        m = compute_reading_order_metrics(
+            ["a", "b", "c"],
+            ["a", "X", "b", "c"],
+        )
+        assert m["true_positives"] == 3
+        assert m["false_negatives"] == 0
+        assert m["false_positives"] == 3
+        # Recall = 1, precision = 0.5, F1 = 2/3
+        assert m["recall"] == pytest.approx(1.0)
+        assert m["precision"] == pytest.approx(0.5)
+        assert m["f1"] == pytest.approx(2 / 3)
+
+    def test_deletion_preserves_remaining_pairs(self) -> None:
+        # GT : a, b, c → 3 paires.  Hypothèse supprime b : a, c → 1 paire.
+        m = compute_reading_order_metrics(
+            ["a", "b", "c"],
+            ["a", "c"],
+        )
+        # TP = 1 (paire a-c), FN = 2 (a-b, b-c manquent côté hyp)
+        assert m["true_positives"] == 1
+        assert m["false_negatives"] == 2
+        assert m["false_positives"] == 0
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 2. Cas dégénérés
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestDegenerateCases:
+    def test_both_empty(self) -> None:
+        m = compute_reading_order_metrics([], [])
+        # Convention : pas de récompense gratuite
+        assert m["f1"] == 0.0
+        assert m["true_positives"] == 0
+
+    def test_only_reference_empty(self) -> None:
+        m = compute_reading_order_metrics([], ["a", "b"])
+        assert m["f1"] == 0.0
+        # TP = 0 par construction
+        assert m["true_positives"] == 0
+        # 1 paire FP côté hypothèse
+        assert m["false_positives"] == 1
+
+    def test_only_hypothesis_empty(self) -> None:
+        m = compute_reading_order_metrics(["a", "b"], [])
+        assert m["f1"] == 0.0
+        # 1 FN côté GT
+        assert m["false_negatives"] == 1
+
+    def test_single_region(self) -> None:
+        # Pas de paire possible avec une seule région
+        m = compute_reading_order_metrics(["a"], ["a"])
+        assert m["n_ref_pairs"] == 0
+        assert m["n_hyp_pairs"] == 0
+        assert m["f1"] == 0.0  # convention de bord (pas de paire à matcher)
+
+    def test_none_inputs(self) -> None:
+        m = compute_reading_order_metrics(None, None)
+        assert m["f1"] == 0.0
+
+    def test_duplicates_treated_first_occurrence(self) -> None:
+        # GT : a, b, a, c → on garde "a, b, c" (première occurrence)
+        # → 3 paires.  Hypothèse : a, b, c → 3 paires.  F1 = 1.
+        m = compute_reading_order_metrics(
+            ["a", "b", "a", "c"],
+            ["a", "b", "c"],
+        )
+        assert m["f1"] == pytest.approx(1.0)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 3. Comptages détaillés
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestDetailedCounts:
+    def test_common_and_disjoint_regions(self) -> None:
+        m = compute_reading_order_metrics(
+            ["a", "b", "c"],
+            ["b", "c", "d"],
+        )
+        assert m["common_regions"] == ["b", "c"]
+        assert m["ref_only_regions"] == ["a"]
+        assert m["hyp_only_regions"] == ["d"]
+
+    def test_n_pairs_consistent(self) -> None:
+        m = compute_reading_order_metrics(
+            ["a", "b", "c", "d"],
+            ["e", "f"],
+        )
+        # GT : C(4, 2) = 6 paires
+        assert m["n_ref_pairs"] == 6
+        # Hyp : C(2, 2) = 1 paire
+        assert m["n_hyp_pairs"] == 1
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 4. Intégration registre typé
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestRegistryIntegration:
+    def test_metric_registered_for_reading_order_pair(self) -> None:
+        # Force l'import qui peuple le registre
+        import picarones.core.reading_order  # noqa: F401
+
+        selected = select_metrics(
+            (ArtifactType.READING_ORDER, ArtifactType.READING_ORDER),
+        )
+        names = {spec.name for spec in selected}
+        assert "reading_order_f1" in names
+
+    def test_compute_at_junction_returns_f1(self) -> None:
+        out = compute_at_junction(
+            ["a", "b", "c"],
+            ["a", "b", "c"],
+            (ArtifactType.READING_ORDER, ArtifactType.READING_ORDER),
+        )
+        assert out["reading_order_f1"] == pytest.approx(1.0)
+
+    def test_shortcut_matches_full_call(self) -> None:
+        ref = ["r1", "r2", "r3", "r4"]
+        hyp = ["r1", "r3", "r2", "r4"]
+        full = compute_reading_order_metrics(ref, hyp)
+        assert reading_order_f1(ref, hyp) == pytest.approx(full["f1"])