sprint61: câblage runner des 6 modules philologiques (Sprints 55-60)

Les six modules philologiques sont désormais calculés automatiquement
par le runner pour chaque document et agrégés par moteur, sans option
à activer.

- Nouveau module picarones/core/philological_runner.py :
- compute_philological_metrics(reference, hypothesis) : calcul
des 6 modules avec adaptive masking (un module n'apparaît que
si la GT a du signal exploitable).
- aggregate_philological_metrics(per_doc) : agrégation des
compteurs bruts + recalcul des scores globaux + préservation
des structures per_block/per_abbreviation/per_char/per_category/
per_status agrégées.
- Nouveaux champs DocumentResult.philological_metrics et
EngineReport.aggregated_philological (Optional[dict], sérialisés
conditionnellement, libérés par compact).
- Câblage runner : calcul inconditionnel (coût O(N), négligeable),
erreur d'un module n'arrête pas les autres + warning explicite.
- Rétrocompat stricte : aucun paramètre ajouté, comportement
existant inchangé sur les corpus sans signal philologique.
- +24 tests dans test_sprint61_philological_runner.py.

Tests : 2316 passed, 2 skipped, 0 failed.

https://claude.ai/code/session_01RusTQYcSfXqTsbFNvwmCV7

CHANGELOG.md

@@ -16,6 +16,55 @@ La numérotation de version suit [Semantic Versioning](https://semver.org/lang/f
 
 ### Ajouté
 
+- **Sprint 61 — Câblage backend des métriques philologiques au
+  runner (Sprints 55-60).**  Suite directe Sprints 55-60 — les six
+  modules philologiques (unicode_blocks, abbreviations, mufi,
+  early_modern, modern_archives, roman_numerals) sont désormais
+  calculés automatiquement par le runner pour chaque document et
+  agrégés par moteur, **sans aucune option à activer**.
+  - Nouveau module `picarones/core/philological_runner.py` :
+    - ``compute_philological_metrics(reference, hypothesis)``
+      calcule les six modules et retourne un dict avec une clé par
+      module ayant du **signal exploitable** dans la GT
+      (``n_markers_reference > 0``, ``n_mufi_chars_reference > 0``,
+      au moins un caractère hors Basic Latin pour unicode_blocks,
+      etc.).  Retourne ``None`` si aucun module n'a de signal.
+    - ``aggregate_philological_metrics(per_doc_list)`` agrège les
+      compteurs bruts par module (somme), recalcule les scores
+      globaux à partir des sommes (accuracy, coverage, strict,
+      expansion, value, preservation), et préserve les structures
+      ``per_block`` / ``per_abbreviation`` / ``per_char`` /
+      ``per_category`` / ``per_status`` agrégées.
+    - **Adaptive masking** : un module n'apparaît dans le résultat
+      que si au moins un document a eu du signal pour lui — les
+      rapports restent lisibles sur les corpus sans marqueur
+      philologique pertinent (typique des fonds XXIᵉ propres).
+  - Nouveaux champs sur ``DocumentResult.philological_metrics`` et
+    ``EngineReport.aggregated_philological`` (``Optional[dict]``,
+    ``None`` par défaut, sérialisés conditionnellement par
+    ``as_dict``, libérés par ``compact``).
+  - Câblage dans ``runner._compute_document_result`` : le calcul
+    est inconditionnel (coût O(N) sur le texte, négligeable face à
+    l'OCR) et l'erreur d'un module individuel ne propage pas — on
+    omet le module et on logue un warning explicite (jamais
+    ``except: pass`` selon les règles CLAUDE.md).
+  - Câblage dans ``run_benchmark`` : agrégation par moteur
+    appelée juste après les autres agrégations Sprint 5/10/40/42.
+  - **Rétrocompat stricte** : aucun paramètre ajouté, aucun
+    comportement existant modifié ; un benchmark sans signal
+    philologique voit ses ``philological_metrics`` à ``None`` (pas
+    de champ dans le JSON de sortie).
+  - +24 tests dans `test_sprint61_philological_runner.py` (champs
+    par défaut, sérialisation conditionnelle, libération par
+    compact, calcul adaptive sur 6 cas de figure — médiéval,
+    imprimé ancien, moderne, numéral romain, diacritiques,
+    ASCII pur —, agrégation : sommes correctes, recalcul des scores
+    globaux, per_category modern_archives, intégration runner
+    end-to-end avec mock ``EngineResult``).
+  - **Verrou levé** : les six modules philologiques sont désormais
+    visibles dans le pipeline standard de bench ; il manque
+    uniquement la vue HTML dédiée (Sprint 62 à venir).
+
 - **Sprint 60 — Numéraux romains transversaux : couche de calcul
   (clôture extension philologique par période).**  Suite directe
   Sprints 56-59.  Les numéraux romains traversent les trois

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). |
+| 61 | **Sprint 30 du plan d'évolution 2026 — Étape 3 / câblage backend des métriques philologiques au runner (Sprints 55-60)**. Suite directe Sprints 55-60. Les six modules philologiques sont désormais calculés automatiquement par le runner pour chaque document et agrégés par moteur, sans aucune option à activer. Nouveau module `picarones/core/philological_runner.py` : `compute_philological_metrics(reference, hypothesis)` calcule les six modules avec **adaptive masking** (un module n'apparaît que si la GT a du signal exploitable : `n_markers_reference > 0`, `n_mufi_chars_reference > 0`, au moins un caractère hors Basic Latin pour unicode_blocks…) ; `aggregate_philological_metrics(per_doc_list)` agrège les compteurs bruts par module (somme), recalcule les scores globaux, et préserve les structures `per_block`/`per_abbreviation`/`per_char`/`per_category`/`per_status` agrégées. Nouveaux champs `DocumentResult.philological_metrics` et `EngineReport.aggregated_philological` (`Optional[dict]`, sérialisés conditionnellement, libérés par `compact`). Câblage runner : calcul inconditionnel (coût O(N) sur texte, négligeable face à l'OCR), erreur d'un module individuel n'arrête pas les autres + warning explicite. Rétrocompat stricte : aucun paramètre ajouté, comportement existant inchangé, un benchmark sans signal philologique n'a aucun champ ajouté au JSON. +24 tests dans `test_sprint61_philological_runner.py` (champs, sérialisation/compact, calcul adaptive sur 6 cas — médiéval/imprimé/moderne/romain/diacritiques/ASCII pur, agrégation des compteurs et recalcul des scores globaux, intégration runner end-to-end avec mock). **Verrou levé** : les six modules philologiques sont désormais visibles dans le pipeline standard de bench, il manque la vue HTML dédiée (Sprint 62). |
 | 60 | **Sprint 29 du plan d'évolution 2026 — Étape 3 / extension philologique transversale : numéraux romains (couche de calcul, clôture extension par période)**. Suite directe Sprints 56-59. Les numéraux romains traversent les trois périodes patrimoniales — médiéval (minuscules + j final `mcclxxxij`=1282), imprimé ancien (`Tome IV`), moderne (`Louis XIV`, `MCMXIV`). Module `picarones/core/roman_numerals.py` : `roman_to_int` parsing tolérant casse + j médiéval avec validation stricte des paires soustractives canoniques (IV, IX, XL, XC, CD, CM seulement — rejette `ICI`, `IL`, `VV`, `IIIII`), forme additive médiévale `IIII` acceptée, `int_to_roman` canonique, `detect_roman_numerals(text, min_length=1)` avec filtre paramétrable contre les single-letter ambigus (`I` pronom). `compute_roman_numeral_metrics` classifie chaque numéral GT en **5 statuts ordonnés par priorité** : `strict_preserved` (forme exacte), `case_changed` (valeur OK casse différente), `j_dropped` (j médiéval normalisé en i), `converted_to_arabic` (XIV→14), `lost`. Retourne `per_status`, `per_numeral`, `lost_numerals`, `global_strict_score`, `global_value_score` (toute forme préservant la valeur). `roman_numeral_strict_score` et `roman_numeral_value_score` enregistrés dans le registre typé Sprint 34 pour `(TEXT, TEXT)`. **Choix éditorial assumé identique aux Sprints 58-59** : pas de classification automatique — le chercheur lit `per_status` et juge la convention. +93 tests (parsing paramétrée standard + minuscules + j médiéval, formes invalides rejetées, aller-retour, détection avec min_length et frontière de mot anti-`VIVE`, **rejet du faux positif `ICI`**, 5 statuts individuellement, priorité strict>arabic, **3 cas réalistes par période** — charte médiévale, imprimé ancien, souverain moderne —, comptage exhaustif somme des per_status = total, dégénérés, raccourcis, intégration registre). **Verrou levé** : l'extension philologique transversale est intégralement livrée — un benchmark sur n'importe quel fonds patrimonial européen peut désormais classer les moteurs sur leur traitement des numéraux romains, indépendamment de la période. |
 | 59 | **Sprint 28 du plan d'évolution 2026 — Étape 3 / extension philologique aux périodes contemporaines : marqueurs et abréviations des archives modernes XIXᵉ-XXᵉ (couche de calcul)**. Suite directe Sprints 56-58. Sur les fonds modernes BnF (état civil, recensements, presse, monographies, archives militaires, annuaires) la typographie historique a disparu mais subsiste un riche système d'abréviations contemporaines. Module `picarones/core/modern_archives.py` avec **9 catégories** : `civility_titles` (Mme, Mlle, Mgr, Dr, Pr, Me, M., R.P., S.M., S.A.R., S.E., S.S.), `ordinals` (1ᵉʳ, 1ʳᵉ, 2ᵈ, 2ᵉ, Vᵉ, XIᵉ-XXᵉ avec exposants Unicode), `currency` (₶, ₣, ƒ, £ + l./s./d. d'Ancien Régime), `administrative` (arr., dép., cant., com., reg., prov.), `civil_status` (°, †, ✶, ⚭, ép., vve), `typographic_punctuation` (« », —, –, …, ’, ‘), `latin_abbr_modern` (e.g., i.e., etc., cf., ibid., op. cit., ad lib., N.B.), `bibliographic` (vol., t., p., pp., n°, fasc., éd., ms., f., r°, v°), `address` (bd, av., r., pl., imp., fbg). `get_category`, `get_expansions`, `detect_modern_markers` avec **stratégie greedy plus-long-gagne** (S.A.R. avant S.A.) et **frontières de mot adaptées** au type de marqueur (espace/ponctuation pour `M.`/`arr.`, `\b` standard pour `Mme`/`bd`, match littéral pour les Unicode `₶`/`†`/`«`). `compute_modern_archives_metrics` retourne deux scores par catégorie (pattern Sprint 56) : `strict_score` (forme abrégée préservée) et `expansion_score` (abrégée OU développée présente, casse-insensible) ; `missed_markers` distingue **pertes pures** (`expansion_preserved=False`) et **modernisations** (`expansion_preserved=True`). `modern_archives_strict_score` et `modern_archives_expansion_score` enregistrés dans le registre typé Sprint 34 pour `(TEXT, TEXT)`. **Choix éditorial assumé** : pas de classification automatique « diplomatique »/« modernisant » — c'est un outil de recherche, le chercheur lit les chiffres bruts et conclut lui-même. +75 tests (catégorisation 33 marqueurs ×9 catégories, détection par catégorie ×9, greedy plus-long-gagne, frontière de mot anti-faux-positifs, scénarios standards diplo/mod/erreur, breakdown per_category, **5 cas réalistes** clé — citation biblio, état civil, adresse, protocole royal, monnaie Ancien Régime, ponctuation typo —, dégénérés, comptage exhaustif, sanité tables, raccourcis, intégration registre). **Verrou levé** : l'extension philologique couvre désormais **trois périodes principales** des fonds patrimoniaux européens — médiéval (Sprints 56-57), imprimé ancien XVIᵉ-XVIIIᵉ (Sprint 58), archives modernes XIXᵉ-XXᵉ (ce sprint). |
 | 58 | **Sprint 27 du plan d'évolution 2026 — Étape 3 / extension philologique : marqueurs typographiques de l'imprimé ancien XVIᵉ-XVIIIᵉ (couche de calcul)**. Première extension du volet philologique aux périodes post-médiévales. Les Sprints 56-57 sont orientés médiéval scribal ; ce sprint cible les **éditeurs d'imprimés anciens** pour qui les marqueurs caractéristiques sont **typographiques** (composition imprimée) et non scribaux. Module `picarones/core/early_modern_typography.py` : 5 catégories de marqueurs (`ligatures` ff fi fl ffi ffl ſt st, `long_s` ſ, `dotless_i` ı, `ampersand` &, `nasal_tildes` ã Ã ñ Ñ õ Õ ũ Ũ ẽ Ẽ ĩ Ĩ pré-composés + séquences `voyelle + U+0303`). `get_category(char)` classe en catégorie ou None ; `detect_markers(text)` retourne `[(index, marker, category)]` reconnaissant à la fois les caractères pré-composés et les séquences combinantes ; `compute_early_modern_metrics(ref, hyp)` aligne via `difflib.SequenceMatcher` et retourne `global_preservation` + `per_category[name]={total,preserved,preservation}` + `missed_markers`. `early_modern_preservation` enregistré dans le registre typé Sprint 34 pour `(TEXT, TEXT)`. **Le breakdown par catégorie discrimine la convention typographique** : un moteur diplomatique préserve toutes les catégories ; un moteur modernisant ſ→s, fi→fi, ı→i, ã→a préserve typiquement uniquement & ; un moteur mixte panache. +38 tests dans `test_sprint58_early_modern.py` (catégorisation paramétrée 18 caractères, détection 5 catégories + tilde combinant + ordre, **trois scénarios standards** discriminés à 1.0 / 0.2 / 0.4, dégénérés, missed_markers, preserved+missed=total, sets disjoints, raccourci, intégration registre). **Verrou levé** : un benchmark sur des imprimés anciens peut désormais classer les moteurs sur leur convention typographique éditoriale — symétrique à ce que le Sprint 56 fait pour les manuscrits médiévaux. |
@@ -278,7 +279,7 @@ au template `_narrative_summary.html` (placé entre `_header.html` et `_critical
 ## Contexte développement
 
 - **Environnement** : GitHub Codespaces (`/workspaces/Picarones`), Python 3.12
-- **Tests** : 2292 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-57 = axe A.II.3 (philologique) médiéval intégralement livré côté calcul ; Sprint 58 = imprimé ancien XVIᵉ-XVIIIᵉ ; Sprint 59 = archives modernes XIXᵉ-XXᵉ ; Sprint 60 = numéraux romains transversaux — **extension philologique livrée pour les trois périodes principales et la dimension transversale numérale**)
+- **Tests** : 2316 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-60 = extension philologique sur trois périodes + numéraux romains transversaux côté calcul ; Sprint 61 = câblage backend des 6 modules philologiques au runner avec adaptive masking)
 - **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/philological_runner.py

@@ -0,0 +1,363 @@
+"""Helpers de câblage des métriques philologiques (Sprints 55-60) au runner.
+
+Sprint 61 — câblage backend des 6 modules philologiques :
+
+- ``unicode_blocks``    (Sprint 55)
+- ``abbreviations``     (Sprint 56)
+- ``mufi``              (Sprint 57)
+- ``early_modern``      (Sprint 58)
+- ``modern_archives``   (Sprint 59)
+- ``roman_numerals``    (Sprint 60)
+
+Principe « adaptive »
+----------------------
+Un module n'est inclus dans le résultat que si la **GT contient du
+signal exploitable** pour ce module.  Cette logique évite de polluer
+les rapports sur les corpus sans marqueurs philologiques (typique
+sur des données XXIᵉ ou des transcriptions modernes propres).
+
+Coût
+----
+Les 6 calculs sont O(N) sur la longueur du texte ; le surcoût total
+par document est négligeable face à un appel OCR.  L'activation est
+donc **automatique** (pas d'opt-in), contrairement aux backends NER
+ou calibration qui exigent une dépendance externe ou des données
+spécifiques.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from picarones.core.abbreviations import compute_abbreviation_metrics
+from picarones.core.early_modern_typography import compute_early_modern_metrics
+from picarones.core.modern_archives import compute_modern_archives_metrics
+from picarones.core.mufi import compute_mufi_coverage
+from picarones.core.roman_numerals import compute_roman_numeral_metrics
+from picarones.core.unicode_blocks import compute_unicode_block_accuracy
+
+logger = logging.getLogger(__name__)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Critères « le module a-t-il du signal sur ce document ? »
+# ──────────────────────────────────────────────────────────────────────────
+#
+# Pour chaque module, on définit un prédicat sur le résultat : si vrai,
+# le module est inclus ; sinon, il est omis pour ne pas alourdir le
+# rapport.
+
+def _has_unicode_signal(result: dict) -> bool:
+    # Le module retourne toujours du signal dès que GT non-vide ; on
+    # n'inclut que si la GT a au moins un caractère **hors Basic
+    # Latin** (sinon le breakdown se réduit à 100 % Basic Latin et
+    # n'apporte rien au lecteur).
+    per_block = result.get("per_block", {})
+    for block, stats in per_block.items():
+        if block == "Basic Latin":
+            continue
+        if stats.get("total", 0) > 0:
+            return True
+    return False
+
+
+def _has_abbreviation_signal(result: dict) -> bool:
+    return result.get("n_abbreviations_in_reference", 0) > 0
+
+
+def _has_mufi_signal(result: dict) -> bool:
+    return result.get("n_mufi_chars_reference", 0) > 0
+
+
+def _has_early_modern_signal(result: dict) -> bool:
+    return result.get("n_markers_reference", 0) > 0
+
+
+def _has_modern_archives_signal(result: dict) -> bool:
+    return result.get("n_markers_reference", 0) > 0
+
+
+def _has_roman_numeral_signal(result: dict) -> bool:
+    return result.get("n_numerals_reference", 0) > 0
+
+
+# Ordre fixé pour la reproductibilité des sorties.
+_PHILOLOGICAL_MODULES: tuple[
+    tuple[str, callable, callable], ...
+] = (
+    ("unicode_blocks",  compute_unicode_block_accuracy, _has_unicode_signal),
+    ("abbreviations",   compute_abbreviation_metrics,   _has_abbreviation_signal),
+    ("mufi",            compute_mufi_coverage,          _has_mufi_signal),
+    ("early_modern",    compute_early_modern_metrics,   _has_early_modern_signal),
+    ("modern_archives", compute_modern_archives_metrics, _has_modern_archives_signal),
+    ("roman_numerals",  compute_roman_numeral_metrics,  _has_roman_numeral_signal),
+)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Calcul par document
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def compute_philological_metrics(
+    reference: Optional[str],
+    hypothesis: Optional[str],
+) -> Optional[dict]:
+    """Calcule les 6 métriques philologiques pour un document.
+
+    Retourne un dict avec une clé par module ayant du signal, ou
+    ``None`` si aucun module n'en a (corpus sans marqueur
+    philologique pertinent).
+
+    En cas d'erreur dans un module individuel, le module est
+    silencieusement omis et un warning est émis (les autres modules
+    restent calculés).
+    """
+    ref = reference or ""
+    if not ref:
+        return None
+    out: dict = {}
+    for name, compute_fn, has_signal_fn in _PHILOLOGICAL_MODULES:
+        try:
+            result = compute_fn(ref, hypothesis or "")
+        except Exception as exc:  # pragma: no cover — défense en profondeur
+            logger.warning(
+                "[philological_runner] module %s a échoué : %s", name, exc,
+            )
+            continue
+        if has_signal_fn(result):
+            out[name] = result
+    return out if out else None
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Agrégation corpus-wide par moteur
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def _aggregate_unicode(per_doc: list[dict]) -> dict:
+    total_correct = 0
+    total_chars = 0
+    per_block: dict[str, dict[str, int]] = {}
+    for d in per_doc:
+        for block, stats in d.get("per_block", {}).items():
+            slot = per_block.setdefault(block, {"correct": 0, "total": 0})
+            slot["correct"] += stats.get("correct", 0)
+            slot["total"] += stats.get("total", 0)
+            total_correct += stats.get("correct", 0)
+            total_chars += stats.get("total", 0)
+    out_per_block = {
+        block: {
+            "correct": slot["correct"],
+            "total": slot["total"],
+            "accuracy": (
+                slot["correct"] / slot["total"] if slot["total"] > 0 else 0.0
+            ),
+        }
+        for block, slot in sorted(per_block.items())
+    }
+    return {
+        "global_accuracy": total_correct / total_chars if total_chars > 0 else 0.0,
+        "n_chars_total": total_chars,
+        "n_chars_correct": total_correct,
+        "per_block": out_per_block,
+        "doc_count": len(per_doc),
+    }
+
+
+def _aggregate_abbreviations(per_doc: list[dict]) -> dict:
+    n_total = 0
+    n_strict = 0
+    n_expansion = 0
+    per_abbr: dict[str, dict[str, int]] = {}
+    for d in per_doc:
+        n_total += d.get("n_abbreviations_in_reference", 0)
+        n_strict += d.get("n_strict_preserved", 0)
+        n_expansion += d.get("n_expansion_preserved", 0)
+        for entry in d.get("per_abbreviation", []):
+            slot = per_abbr.setdefault(
+                entry["abbr"],
+                {"total": 0, "strict": 0, "expansion": 0},
+            )
+            slot["total"] += 1
+            if entry.get("strict_preserved"):
+                slot["strict"] += 1
+            if entry.get("expansion_preserved"):
+                slot["expansion"] += 1
+    return {
+        "n_abbreviations_in_reference": n_total,
+        "n_strict_preserved": n_strict,
+        "n_expansion_preserved": n_expansion,
+        "global_strict_score": n_strict / n_total if n_total > 0 else 0.0,
+        "global_expansion_score": n_expansion / n_total if n_total > 0 else 0.0,
+        "per_abbreviation": {
+            abbr: {
+                "n_total": slot["total"],
+                "n_strict": slot["strict"],
+                "n_expansion": slot["expansion"],
+                "strict_score": slot["strict"] / slot["total"],
+                "expansion_score": slot["expansion"] / slot["total"],
+            }
+            for abbr, slot in sorted(per_abbr.items())
+        },
+        "doc_count": len(per_doc),
+    }
+
+
+def _aggregate_mufi(per_doc: list[dict]) -> dict:
+    n_total = 0
+    n_preserved = 0
+    per_char: dict[str, dict[str, int]] = {}
+    for d in per_doc:
+        n_total += d.get("n_mufi_chars_reference", 0)
+        n_preserved += d.get("n_mufi_chars_preserved", 0)
+        for ch, stats in d.get("per_char", {}).items():
+            slot = per_char.setdefault(ch, {"total": 0, "preserved": 0})
+            slot["total"] += stats.get("total", 0)
+            slot["preserved"] += stats.get("preserved", 0)
+    return {
+        "n_mufi_chars_reference": n_total,
+        "n_mufi_chars_preserved": n_preserved,
+        "coverage": n_preserved / n_total if n_total > 0 else 0.0,
+        "per_char": {
+            ch: {
+                "total": slot["total"],
+                "preserved": slot["preserved"],
+                "coverage": slot["preserved"] / slot["total"],
+            }
+            for ch, slot in sorted(per_char.items())
+        },
+        "doc_count": len(per_doc),
+    }
+
+
+def _aggregate_early_modern(per_doc: list[dict]) -> dict:
+    n_total = 0
+    n_preserved = 0
+    per_cat: dict[str, dict[str, int]] = {}
+    for d in per_doc:
+        n_total += d.get("n_markers_reference", 0)
+        n_preserved += d.get("n_markers_preserved", 0)
+        for cat, stats in d.get("per_category", {}).items():
+            slot = per_cat.setdefault(cat, {"total": 0, "preserved": 0})
+            slot["total"] += stats.get("total", 0)
+            slot["preserved"] += stats.get("preserved", 0)
+    return {
+        "n_markers_reference": n_total,
+        "n_markers_preserved": n_preserved,
+        "global_preservation": n_preserved / n_total if n_total > 0 else 0.0,
+        "per_category": {
+            cat: {
+                "total": slot["total"],
+                "preserved": slot["preserved"],
+                "preservation": slot["preserved"] / slot["total"],
+            }
+            for cat, slot in sorted(per_cat.items())
+        },
+        "doc_count": len(per_doc),
+    }
+
+
+def _aggregate_modern_archives(per_doc: list[dict]) -> dict:
+    n_total = 0
+    n_strict = 0
+    n_expansion = 0
+    per_cat: dict[str, dict[str, int]] = {}
+    for d in per_doc:
+        n_total += d.get("n_markers_reference", 0)
+        n_strict += d.get("n_strict_preserved", 0)
+        n_expansion += d.get("n_expansion_preserved", 0)
+        for cat, stats in d.get("per_category", {}).items():
+            slot = per_cat.setdefault(
+                cat, {"total": 0, "strict": 0, "expansion": 0},
+            )
+            slot["total"] += stats.get("n_total", 0)
+            slot["strict"] += stats.get("n_strict_preserved", 0)
+            slot["expansion"] += stats.get("n_expansion_preserved", 0)
+    return {
+        "n_markers_reference": n_total,
+        "n_strict_preserved": n_strict,
+        "n_expansion_preserved": n_expansion,
+        "global_strict_score": n_strict / n_total if n_total > 0 else 0.0,
+        "global_expansion_score": n_expansion / n_total if n_total > 0 else 0.0,
+        "per_category": {
+            cat: {
+                "n_total": slot["total"],
+                "n_strict_preserved": slot["strict"],
+                "n_expansion_preserved": slot["expansion"],
+                "strict_score": slot["strict"] / slot["total"],
+                "expansion_score": slot["expansion"] / slot["total"],
+            }
+            for cat, slot in sorted(per_cat.items())
+        },
+        "doc_count": len(per_doc),
+    }
+
+
+def _aggregate_roman_numerals(per_doc: list[dict]) -> dict:
+    from picarones.core.roman_numerals import ALL_STATUSES, VALUE_PRESERVING_STATUSES
+
+    n_total = 0
+    per_status: dict[str, int] = {s: 0 for s in ALL_STATUSES}
+    for d in per_doc:
+        n_total += d.get("n_numerals_reference", 0)
+        for status, count in d.get("per_status", {}).items():
+            per_status[status] = per_status.get(status, 0) + count
+    n_strict = per_status.get("strict_preserved", 0)
+    n_value = sum(per_status.get(s, 0) for s in VALUE_PRESERVING_STATUSES)
+    return {
+        "n_numerals_reference": n_total,
+        "n_strict_preserved": n_strict,
+        "n_value_preserved": n_value,
+        "global_strict_score": n_strict / n_total if n_total > 0 else 0.0,
+        "global_value_score": n_value / n_total if n_total > 0 else 0.0,
+        "per_status": per_status,
+        "doc_count": len(per_doc),
+    }
+
+
+_AGGREGATORS = {
+    "unicode_blocks":   _aggregate_unicode,
+    "abbreviations":    _aggregate_abbreviations,
+    "mufi":             _aggregate_mufi,
+    "early_modern":     _aggregate_early_modern,
+    "modern_archives":  _aggregate_modern_archives,
+    "roman_numerals":   _aggregate_roman_numerals,
+}
+
+
+def aggregate_philological_metrics(
+    doc_metrics: list[Optional[dict]],
+) -> Optional[dict]:
+    """Agrège les ``philological_metrics`` per-document en un dict
+    corpus-wide par module.
+
+    Pour chaque module, on agrège uniquement les documents qui ont
+    eu du signal pour ce module.  Si aucun module n'a été calculé
+    sur aucun document, retourne ``None``.
+    """
+    by_module: dict[str, list[dict]] = {}
+    for doc in doc_metrics:
+        if not doc:
+            continue
+        for module, payload in doc.items():
+            by_module.setdefault(module, []).append(payload)
+    if not by_module:
+        return None
+    out: dict = {}
+    for module, payloads in by_module.items():
+        aggregator = _AGGREGATORS.get(module)
+        if aggregator is None:  # pragma: no cover
+            logger.warning(
+                "[philological_runner] aucun agrégateur pour %s", module,
+            )
+            continue
+        out[module] = aggregator(payloads)
+    return out if out else None
+
+
+__all__ = [
+    "compute_philological_metrics",
+    "aggregate_philological_metrics",
+]

picarones/core/results.py

@@ -70,6 +70,26 @@ class DocumentResult:
     Présent uniquement si le moteur a fourni des ``token_confidences``
     sur l'``EngineResult``.
     """
+    # Sprint 61 — métriques philologiques (Sprints 55-60) calculées
+    # automatiquement.  Présent uniquement si au moins un module a
+    # détecté du signal dans la GT.
+    philological_metrics: Optional[dict] = None
+    """Métriques philologiques (Sprints 55-60).
+
+    Dict avec une clé par module en présence de signal :
+
+    - ``unicode_blocks``    : Sprint 55, retour de ``compute_unicode_block_accuracy``
+    - ``abbreviations``     : Sprint 56, retour de ``compute_abbreviation_metrics``
+    - ``mufi``              : Sprint 57, retour de ``compute_mufi_coverage``
+    - ``early_modern``      : Sprint 58, retour de ``compute_early_modern_metrics``
+    - ``modern_archives``   : Sprint 59, retour de ``compute_modern_archives_metrics``
+    - ``roman_numerals``    : Sprint 60, retour de ``compute_roman_numeral_metrics``
+
+    Un module n'est inclus que si la GT contient du signal exploitable
+    (n_markers_reference > 0, n_mufi_chars_reference > 0, etc.).
+    Cette logique adaptative permet de garder les rapports lisibles
+    sur les corpus sans marqueurs philologiques.
+    """
 
     def as_dict(self) -> dict:
         d = {
@@ -103,6 +123,8 @@ class DocumentResult:
             d["ner_metrics"] = self.ner_metrics
         if self.calibration_metrics is not None:
             d["calibration_metrics"] = self.calibration_metrics
+        if self.philological_metrics is not None:
+            d["philological_metrics"] = self.philological_metrics
         return d
 
     def compact(self) -> None:
@@ -130,6 +152,7 @@ class DocumentResult:
         self.hallucination_metrics = None
         self.ner_metrics = None
         self.calibration_metrics = None
+        self.philological_metrics = None
 
 
 @dataclass
@@ -173,6 +196,16 @@ class EngineReport:
     micro recalculé à partir des sommes par bin.  ``None`` si aucun
     document n'avait de ``calibration_metrics`` (cas par défaut tant que
     les engines n'exposent pas ``token_confidences``)."""
+    # Sprint 61
+    aggregated_philological: Optional[dict] = None
+    """Métriques philologiques agrégées sur le corpus (Sprints 55-60).
+
+    Dict avec une clé par module ayant du signal sur au moins un
+    document.  Pour chaque module, l'agrégation somme les compteurs
+    bruts (n_total, n_preserved, etc.) et recalcule les scores
+    globaux ; les structures per_category/per_block/per_status sont
+    également agrégées.  ``None`` si aucun document n'a porté de
+    ``philological_metrics``."""
 
     def __post_init__(self) -> None:
         if not self.aggregated_metrics and self.document_results:
@@ -249,6 +282,8 @@ class EngineReport:
             d["aggregated_ner"] = self.aggregated_ner
         if self.aggregated_calibration is not None:
             d["aggregated_calibration"] = self.aggregated_calibration
+        if self.aggregated_philological is not None:
+            d["aggregated_philological"] = self.aggregated_philological
         return d
 
 

picarones/core/runner.py

@@ -285,6 +285,19 @@ def _compute_document_result(
     except Exception as e:
         _logger.warning("[image_quality] fonctionnalité dégradée : %s", e)
 
+    # Sprint 61 — métriques philologiques (Sprints 55-60).  Calcul
+    # automatique : O(N) sur le texte, coût négligeable.  Le helper
+    # gère lui-même l'« adaptive masking » : un module n'est inclus
+    # que si la GT a du signal pour lui.
+    philological_data: Optional[dict] = None
+    try:
+        from picarones.core.philological_runner import compute_philological_metrics
+        philological_data = compute_philological_metrics(
+            ground_truth, ocr_result.text,
+        )
+    except Exception as e:
+        _logger.warning("[philological] fonctionnalité dégradée : %s", e)
+
     return DocumentResult(
         doc_id=doc_id,
         image_path=image_path,
@@ -303,6 +316,7 @@ def _compute_document_result(
         line_metrics=line_metrics_data,
         hallucination_metrics=hallucination_data,
         calibration_metrics=calibration_data,
+        philological_metrics=philological_data,
     )
 
 
@@ -714,6 +728,13 @@ def run_benchmark(
         agg_line_metrics = _aggregate_line_metrics(document_results)
         agg_hallucination = _aggregate_hallucination(document_results)
         agg_calibration = _aggregate_calibration(document_results)
+        # Sprint 61 — agrégation philologique (modules Sprints 55-60).
+        from picarones.core.philological_runner import (
+            aggregate_philological_metrics,
+        )
+        agg_philological = aggregate_philological_metrics(
+            [dr.philological_metrics for dr in document_results],
+        )
 
         report = EngineReport(
             engine_name=engine.name,
@@ -729,6 +750,7 @@ def run_benchmark(
             aggregated_line_metrics=agg_line_metrics,
             aggregated_hallucination=agg_hallucination,
             aggregated_calibration=agg_calibration,
+            aggregated_philological=agg_philological,
         )
         engine_reports.append(report)
         logger.info(

tests/test_sprint61_philological_runner.py

@@ -0,0 +1,303 @@
+"""Tests Sprint 61 — câblage backend des métriques philologiques.
+
+Couvre :
+
+1. Champs ``DocumentResult.philological_metrics`` et
+   ``EngineReport.aggregated_philological`` posés.
+2. Sérialisation conditionnelle dans ``as_dict``.
+3. Libération par ``compact``.
+4. ``compute_philological_metrics`` :
+   - GT médiéval déclenche abbreviations + mufi
+   - GT imprimé ancien déclenche early_modern
+   - GT moderne déclenche modern_archives
+   - GT avec numéraux romains déclenche roman_numerals
+   - GT avec caractères hors Basic Latin déclenche unicode_blocks
+   - GT en ASCII pur sans marqueur → ``None``
+   - GT vide / None → ``None``
+5. ``aggregate_philological_metrics`` :
+   - Somme correcte des compteurs par module
+   - Recalcul correct des scores globaux
+   - Doc count cohérent
+   - Aucun document avec signal → ``None``
+6. Intégration runner end-to-end via fixture mock.
+"""
+
+from __future__ import annotations
+
+from picarones.core.philological_runner import (
+    aggregate_philological_metrics,
+    compute_philological_metrics,
+)
+from picarones.core.results import DocumentResult, EngineReport
+from picarones.core.metrics import MetricsResult
+
+
+def _make_doc(
+    doc_id: str = "d1",
+    gt: str = "",
+    hyp: str = "",
+    philological: dict | None = None,
+) -> DocumentResult:
+    """Helper : construit un DocumentResult minimal pour les tests."""
+    return DocumentResult(
+        doc_id=doc_id,
+        image_path=f"/tmp/{doc_id}.png",
+        ground_truth=gt,
+        hypothesis=hyp,
+        metrics=MetricsResult(
+            cer=0.0, cer_nfc=0.0, cer_caseless=0.0,
+            wer=0.0, wer_normalized=0.0, mer=0.0, wil=0.0,
+            reference_length=len(gt), hypothesis_length=len(hyp),
+        ),
+        duration_seconds=0.1,
+        philological_metrics=philological,
+    )
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 1. Champs posés sur DocumentResult / EngineReport
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestFields:
+    def test_document_result_default_none(self) -> None:
+        dr = _make_doc()
+        assert dr.philological_metrics is None
+
+    def test_document_result_accepts_dict(self) -> None:
+        dr = _make_doc(philological={"mufi": {"coverage": 0.9}})
+        assert dr.philological_metrics == {"mufi": {"coverage": 0.9}}
+
+    def test_engine_report_default_none(self) -> None:
+        report = EngineReport(
+            engine_name="test", engine_version="1.0",
+            engine_config={}, document_results=[],
+        )
+        assert report.aggregated_philological is None
+
+    def test_engine_report_accepts_dict(self) -> None:
+        report = EngineReport(
+            engine_name="test", engine_version="1.0",
+            engine_config={}, document_results=[],
+            aggregated_philological={"mufi": {"coverage": 0.9}},
+        )
+        assert report.aggregated_philological == {"mufi": {"coverage": 0.9}}
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 2. Sérialisation as_dict
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestSerialization:
+    def test_as_dict_omits_none(self) -> None:
+        dr = _make_doc()
+        d = dr.as_dict()
+        assert "philological_metrics" not in d
+
+    def test_as_dict_includes_when_present(self) -> None:
+        dr = _make_doc(philological={"mufi": {"coverage": 1.0}})
+        d = dr.as_dict()
+        assert d["philological_metrics"] == {"mufi": {"coverage": 1.0}}
+
+    def test_engine_report_as_dict_omits_none(self) -> None:
+        report = EngineReport(
+            engine_name="t", engine_version="1", engine_config={},
+            document_results=[],
+        )
+        assert "aggregated_philological" not in report.as_dict()
+
+    def test_engine_report_as_dict_includes_when_present(self) -> None:
+        report = EngineReport(
+            engine_name="t", engine_version="1", engine_config={},
+            document_results=[],
+            aggregated_philological={"mufi": {"coverage": 0.5}},
+        )
+        d = report.as_dict()
+        assert d["aggregated_philological"] == {"mufi": {"coverage": 0.5}}
+
+
+# ─────────────────────────────────────────────────────────────���────────────
+# 3. Libération par compact()
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestCompact:
+    def test_compact_clears_philological(self) -> None:
+        dr = _make_doc(philological={"mufi": {"coverage": 1.0}})
+        dr.compact()
+        assert dr.philological_metrics is None
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 4. compute_philological_metrics — adaptive masking
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestComputeAdaptive:
+    def test_medieval_triggers_abbreviations_and_mufi(self) -> None:
+        gt = "fait en lan ꝑ regem þæt"
+        m = compute_philological_metrics(gt, gt)
+        assert m is not None
+        assert "abbreviations" in m
+        assert "mufi" in m
+
+    def test_early_modern_triggers_typography(self) -> None:
+        gt = "le ſerpent finement & ã"
+        m = compute_philological_metrics(gt, gt)
+        assert m is not None
+        assert "early_modern" in m
+
+    def test_modern_archives_triggers_module(self) -> None:
+        gt = "Mme Dupont au bd Voltaire vol. II"
+        m = compute_philological_metrics(gt, gt)
+        assert m is not None
+        assert "modern_archives" in m
+
+    def test_roman_numerals_triggers_module(self) -> None:
+        gt = "Louis XIV mourut en MDCCXV"
+        m = compute_philological_metrics(gt, gt)
+        assert m is not None
+        assert "roman_numerals" in m
+
+    def test_unicode_blocks_triggered_only_outside_basic_latin(self) -> None:
+        # ASCII pur sans marqueur → unicode_blocks omis (Basic Latin
+        # uniquement, breakdown trivial).
+        m = compute_philological_metrics("hello world", "hello world")
+        assert m is None
+
+    def test_unicode_blocks_triggered_with_diacritics(self) -> None:
+        # Du Latin Extended → unicode_blocks inclus
+        gt = "café à é ô"
+        m = compute_philological_metrics(gt, gt)
+        assert m is not None
+        assert "unicode_blocks" in m
+
+    def test_empty_returns_none(self) -> None:
+        assert compute_philological_metrics("", "") is None
+        assert compute_philological_metrics(None, None) is None
+
+    def test_no_signal_returns_none(self) -> None:
+        # Pure Basic Latin sans aucun marqueur philologique
+        m = compute_philological_metrics("hello", "hello")
+        assert m is None
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 5. aggregate_philological_metrics
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestAggregation:
+    def test_no_data_returns_none(self) -> None:
+        assert aggregate_philological_metrics([]) is None
+        assert aggregate_philological_metrics([None, None]) is None
+
+    def test_aggregates_only_present_modules(self) -> None:
+        # Doc 1 a mufi+abbr, Doc 2 a juste roman_numerals
+        d1 = compute_philological_metrics("ꝑ ꝓ ꝗ", "per pro qui")
+        d2 = compute_philological_metrics("Louis XIV", "Louis 14")
+        agg = aggregate_philological_metrics([d1, d2])
+        assert agg is not None
+        # mufi présent (Doc1 le déclenchait avec ꝑ/ꝓ/ꝗ qui sont MUFI)
+        assert "abbreviations" in agg
+        assert "roman_numerals" in agg
+        # doc_count par module
+        assert agg["abbreviations"]["doc_count"] == 1
+        assert agg["roman_numerals"]["doc_count"] == 1
+
+    def test_aggregation_sums_counters(self) -> None:
+        # 3 docs avec MUFI : "þæt ꝑ" = 3 caractères MUFI (þ, æ, ꝑ)
+        gt = "þæt ꝑ"
+        per_doc = [compute_philological_metrics(gt, gt) for _ in range(3)]
+        agg = aggregate_philological_metrics(per_doc)
+        assert agg is not None
+        assert "mufi" in agg
+        # 3 caractères × 3 docs = 9
+        assert agg["mufi"]["n_mufi_chars_reference"] == 9
+        assert agg["mufi"]["n_mufi_chars_preserved"] == 9
+        assert agg["mufi"]["coverage"] == 1.0
+        assert agg["mufi"]["doc_count"] == 3
+
+    def test_aggregation_recomputes_global_score(self) -> None:
+        # Doc1 préserve 100%, Doc2 préserve 0% → moyenne pondérée
+        d1 = compute_philological_metrics("XIV", "XIV")
+        d2 = compute_philological_metrics("V", "perdu")
+        agg = aggregate_philological_metrics([d1, d2])
+        roman = agg["roman_numerals"]
+        # Doc1 : 1 strict_preserved (XIV)
+        # Doc2 : 1 lost (V)
+        # Total : 2 numéraux, 1 strict → 0.5
+        assert roman["n_numerals_reference"] == 2
+        assert roman["global_strict_score"] == 0.5
+
+    def test_per_category_aggregation_modern_archives(self) -> None:
+        # Deux docs avec modern_archives sur catégories différentes
+        d1 = compute_philological_metrics("Mme bd", "Mme bd")
+        d2 = compute_philological_metrics("vol. p.", "vol. p.")
+        agg = aggregate_philological_metrics([d1, d2])
+        per_cat = agg["modern_archives"]["per_category"]
+        # Doc1 : civility_titles + address ; Doc2 : bibliographic
+        assert "civility_titles" in per_cat
+        assert "address" in per_cat
+        assert "bibliographic" in per_cat
+        for cat in per_cat.values():
+            assert cat["strict_score"] == 1.0
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 6. Intégration end-to-end (mock léger sur le runner)
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestRunnerIntegration:
+    """Vérifie que ``_compute_document_result`` attache bien les
+    ``philological_metrics`` quand la GT a du signal."""
+
+    def test_runner_attaches_philological(self, tmp_path) -> None:
+        from picarones.core.runner import _compute_document_result
+        from picarones.engines.base import EngineResult
+
+        # Créer une image fictive (le module image_quality échouera
+        # gracieusement, ce qui est OK pour le test).
+        img = tmp_path / "doc.png"
+        img.write_bytes(b"")  # vide ; on ignore le résultat image_quality
+
+        gt = "ꝑ regem mcclxxxij"
+        ocr_result = EngineResult(
+            engine_name="mock", image_path=str(img),
+            text=gt, duration_seconds=0.1, error=None,
+        )
+        dr = _compute_document_result(
+            doc_id="d1",
+            image_path=str(img),
+            ground_truth=gt,
+            ocr_result=ocr_result,
+            char_exclude=None,
+        )
+        assert dr.philological_metrics is not None
+        assert "abbreviations" in dr.philological_metrics
+        assert "roman_numerals" in dr.philological_metrics
+
+    def test_runner_omits_philological_on_plain_text(self, tmp_path) -> None:
+        from picarones.core.runner import _compute_document_result
+        from picarones.engines.base import EngineResult
+
+        img = tmp_path / "doc.png"
+        img.write_bytes(b"")
+
+        # Texte ASCII pur sans marqueur philologique
+        gt = "hello world without any markers"
+        ocr_result = EngineResult(
+            engine_name="mock", image_path=str(img),
+            text=gt, duration_seconds=0.1, error=None,
+        )
+        dr = _compute_document_result(
+            doc_id="d1",
+            image_path=str(img),
+            ground_truth=gt,
+            ocr_result=ocr_result,
+            char_exclude=None,
+        )
+        assert dr.philological_metrics is None
+