sprint86: A.II.5 bout-en-bout — câblage runner + vues HTML

Suite directe Sprints 84+85 : la couche calcul livrait deux modules
pour le mode plein-texte patrimonial, ce sprint les remonte
automatiquement dans le rapport.

Helpers runner avec adaptive masking :
- picarones/core/searchability_runner.py
- picarones/core/numerical_sequences_runner.py

Champs DocumentResult.searchability_metrics et
DocumentResult.numerical_sequence_metrics + agrégés sur EngineReport
(sérialisation conditionnelle, libérés par compact).

Câblage runner.py : calcul inconditionnel (coût négligeable),
erreur isolée par try/except + warning explicite, rétrocompat
stricte (aucun champ ajouté quand le corpus est sans signal).

Modules de rendu :
- picarones/report/searchability_render.py : tableau résumé
moteur × {rappel coloré, retrouvés/total, docs}.
- picarones/report/numerical_sequences_render.py : tableau
moteur × catégorie avec adaptive masking par catégorie ;
cellules score strict + valeur en parenthèses + n.

Insertion dans view_analyses.html derrière le profil philologique,
chart-card pleine largeur conditionné.

15 clés i18n FR/EN. 25 tests dans test_sprint86_aii5_html.py
couvrant adaptive masking, agrégation, sérialisation, compact,
rendu FR + EN, anti-injection, complétude i18n.

A.II.5 livrée bout-en-bout (calcul Sprints 84-85, runner et HTML
Sprint 86).

Tests : 2867 passed, 2 skipped.

https://claude.ai/code/session_01RusTQYcSfXqTsbFNvwmCV7

CHANGELOG.md

@@ -16,6 +16,53 @@ La numérotation de version suit [Semantic Versioning](https://semver.org/lang/f
 
 ### Ajouté
 
+- **Sprint 86 — A.II.5 : câblage runner + vues HTML (clôture
+  bout-en-bout).**  Suite directe Sprints 84 et 85 — la couche
+  de calcul livrait deux modules pour le mode plein-texte
+  patrimonial, ce sprint les remonte automatiquement dans le
+  rapport.  Deux nouveaux helpers
+  `picarones/core/searchability_runner.py` et
+  `picarones/core/numerical_sequences_runner.py` qui calculent
+  les métriques par document avec **adaptive masking** (rien
+  n'apparaît pour un doc sans GT exploitable) et agrègent
+  corpus-wide en *micro*-rappel pour la searchability et en
+  somme de compteurs par catégorie pour les séquences
+  numériques.  `DocumentResult` gagne `searchability_metrics`
+  et `numerical_sequence_metrics` ; `EngineReport` gagne
+  `aggregated_searchability` et `aggregated_numerical_sequences`
+  (sérialisation conditionnelle dans `as_dict`, libérés par
+  `compact`).  Le runner historique calcule désormais les deux
+  inconditionnellement (coût négligeable face à l'OCR), erreur
+  d'un module isolée par try/except + warning explicite,
+  rétrocompat stricte (aucun champ ajouté au JSON quand le
+  corpus est sans signal).  Deux nouveaux modules de rendu
+  `picarones/report/searchability_render.py` et
+  `picarones/report/numerical_sequences_render.py` :
+  `build_searchability_summary_html` produit un tableau résumé
+  moteur × (rappel coloré gradient rouge → jaune → vert,
+  retrouvés/total, docs) ;
+  `build_numerical_sequences_html` produit un tableau moteur ×
+  catégorie (year/roman/foliation/currency/regnal) avec
+  **adaptive masking par catégorie** (une catégorie sans signal
+  est omise pour tous les moteurs) ; chaque cellule affiche le
+  score strict (gradient) + la valeur entre parenthèses + le
+  n.  Insertion dans `view_analyses.html` derrière le profil
+  philologique, `chart-card` pleine largeur conditionné.
+  Anti-injection systématique (`html.escape`).  +15 nouvelles
+  clés i18n FR/EN (`search_*`, `numseq_*`).  +25 tests dans
+  `test_sprint86_aii5_html.py` couvrant adaptive masking sur
+  les helpers, agrégation micro-rappel, somme par catégorie,
+  sérialisation `DocumentResult`/`EngineReport`,
+  `compact` qui efface bien les champs, masquage adaptatif HTML
+  (vide quand sans signal, omission de catégories), rendu en
+  FR + EN, anti-injection sur nom de moteur, complétude i18n
+  sur 15 clés.  **Verrou levé** : un benchmark BnF voit
+  désormais sur la vue Analyses *« Recherchabilité fuzzy :
+  tess 95,2 %, pero 87,8 % »* + le tableau séquences
+  numériques détaillé par catégorie — A.II.5 est livrée
+  bout-en-bout en couche calcul (Sprints 84-85), runner et
+  HTML (Sprint 86).
+
 - **Sprint 85 — A.II.5b : précision sur séquences numériques
   (couche de calcul + registre typé).**  Pour un économiste-
   historien, un éditeur de chartes ou un archiviste, la

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). |
+| 86 | **Sprint 55 du plan d'évolution 2026 — A.II.5 : câblage runner adaptive + vues HTML (clôture A.II.5 bout-en-bout)**. Suite directe Sprints 84+85 — la couche de calcul livrait deux modules pour le mode plein-texte patrimonial, ce sprint les remonte automatiquement dans le rapport. Deux helpers `picarones/core/searchability_runner.py` et `picarones/core/numerical_sequences_runner.py` calculent les métriques par document avec **adaptive masking** (rien n'apparaît pour un doc sans GT exploitable) et agrègent corpus-wide en *micro*-rappel pour searchability et somme par catégorie pour les séquences numériques. `DocumentResult` gagne `searchability_metrics` + `numerical_sequence_metrics` ; `EngineReport` gagne `aggregated_searchability` + `aggregated_numerical_sequences` (sérialisation conditionnelle, libérés par `compact`). Le runner historique calcule les deux inconditionnellement (coût négligeable face à l'OCR), erreur isolée par try/except + warning explicite, rétrocompat stricte. Deux modules de rendu `picarones/report/searchability_render.py` (tableau résumé moteur × {rappel coloré rouge→jaune→vert, retrouvés/total, docs}) et `picarones/report/numerical_sequences_render.py` (tableau moteur × catégorie {year/roman/foliation/currency/regnal} avec **adaptive masking par catégorie** — une catégorie sans signal est omise pour tous les moteurs ; chaque cellule affiche le score strict en gradient + la valeur entre parenthèses + n). Insertion dans `view_analyses.html` derrière le profil philologique, `chart-card` pleine largeur conditionné. Anti-injection systématique. +15 clés i18n FR/EN (`search_*`, `numseq_*`). +25 tests dans `test_sprint86_aii5_html.py` (adaptive masking helpers, agrégation micro-rappel, somme par catégorie, sérialisation `DocumentResult`/`EngineReport`, `compact` qui efface, masquage adaptatif HTML, rendu FR + EN, anti-injection sur nom moteur, complétude i18n 15 clés). **Verrou levé** : un benchmark BnF voit désormais sur la vue Analyses *« Recherchabilité fuzzy : tess 95,2 %, pero 87,8 % »* + le tableau séquences numériques détaillé par catégorie — A.II.5 livrée bout-en-bout (calcul Sprints 84-85, runner et HTML Sprint 86). |
 | 85 | **Sprint 54 du plan d'évolution 2026 — A.II.5b : précision sur séquences numériques (couche de calcul + registre typé)**. Pour un économiste-historien, un éditeur de chartes ou un archiviste, la fidélité aux séquences numériques est un proxy direct de la qualité éditoriale — un OCR qui rate « 1789 » dans une charte révolutionnaire ou « f. 12v » dans une cote d'archives produit un corpus inutilisable, même avec un CER global respectable. Nouveau module `picarones/core/numerical_sequences.py` couvrant **5 catégories** : (1) **dates arabes** années 4 chiffres dans la plage [1000-2099], (2) **numéraux romains** délégués à `roman_numerals.detect_roman_numerals` Sprint 60, (3) **foliotation** (`f.`, `fol.`, `p.`, `pp.`, `n°`) avec suffixe `r`/`v` préservé (recto/verso = information distincte non interchangeable côté valeur), (4) **montants** Ancien Régime (`livres/l.`, `sols/s.`, `deniers/d.`) et modernes (`£`, `€`, `₣`, `écus`, `florins`, `francs`), (5) **années régnales** (`an III`, `l'an V`, `an de grâce 1450`). `compute_numerical_sequence_metrics(reference, hypothesis)` classe chaque GT en `strict_preserved` (forme exacte) / `value_preserved` (`XIV` ↔ `14` accepté ; **mais pas** `f. 12r` ↔ `f. 12v`) / `lost`. Multiplicité respectée. Retourne `{global_strict_score, global_value_score, n_total, per_category{n_total, strict, value, strict_score, value_score, lost_items}}`. `numerical_sequence_strict_score` et `numerical_sequence_value_score` enregistrés dans le registre typé Sprint 34 pour `(TEXT, TEXT)`. Limites documentées : regex conservatrices (« mil cinq cens » non détecté comme année), pas de cross-category match (`MDCLXVIII` GT et `1668` hyp sont catégorisés séparément). +27 tests dans `test_sprint85_numerical_sequences.py` couvrant détecteurs individuels, scénarios identité/perte totale/GT vide/recto-verso non interchangeables/multiplicité, **2 cas réalistes** (charte XVIIIᵉ siècle préservée vs registre paroissial où l'OCR modernise XVIII→18 mais préserve l'année 1750 et la foliation), intégration registre 4 cas. **Verrou levé** : un bench d'archive numérique peut classer ses moteurs sur la dimension *« mes dates et cotes seront-elles fiables ? »*, qui complète la **recherchabilité fuzzy** (Sprint 84) pour livrer **A.II.5 en couche de calcul intégrale**. Reste pour clôturer A.II.5 bout-en-bout : câblage runner + colonne HTML « Recherchabilité » + table HTML séquences numériques. |
 | 84 | **Sprint 53 du plan d'évolution 2026 — A.II.5a : recherchabilité fuzzy (couche de calcul + registre typé)**. Le CER mesure les erreurs caractère par caractère ; pour la recherche plein-texte (Elastic, Solr, full-text Gallica), la question réelle est *« combien de mots GT sont retrouvables à orthographe approchée près ? »*. Un CER de 8 % peut donner 95 % de findability si les erreurs sont sur des caractères non significatifs ; à l'inverse 4 % distribué sur tous les noms propres rend le corpus inutilisable pour l'indexation prosopographique. Nouveau module `picarones/core/searchability.py` : `levenshtein_distance(a, b)` DP O(|a|·|b|) mémoire O(min(|a|,|b|)) ; `compute_searchability(reference, hypothesis, max_distance=2, case_sensitive=False)` aligne par multi-set (un token hyp utilisé une seule fois, comme `rare_token_recall` Sprint 71), retourne `{n_gt_tokens, n_searchable, recall, missed_tokens, max_distance}` avec `recall=None` quand n_gt=0 (différencie GT vide de zéro match), court-circuit longueur (Levenshtein ≥ |Δlen|) et arrêt précoce sur match exact ; `searchability_recall_metric` enregistré dans le registre typé Sprint 34 pour `(TEXT, TEXT)` (convention float : 0.0 si GT vide pour cohérence runner). Défaut `max_distance=2` aligné sur Elastic `fuzziness: AUTO`. Limites documentées : tokenisation par split whitespace, Levenshtein non pondéré, pas de sémantique. +28 tests (Levenshtein 9 cas standards dont kitten classique, computation 13 cas dont identité/disjoint/GT vide/hypothèse vide/max_distance=0|2|large/casse/multiplicité/missed_tokens préserve casse GT/ValueError max_distance<0, **2 cas réalistes opposés** Charles→Charlemagne non retrouvé vs maistre→maitre retrouvé, intégration registre 4 cas dont `compute_at_junction`). **Verrou levé** : un bench BnF d'archive numérique peut désormais classer ses moteurs sur la dimension *« mes corpus seront-ils retrouvables après OCRisation ? »* — proxy direct de la valeur d'usage. |
 | 83 | **Sprint 52 du plan d'évolution 2026 — A.II.4 : métriques de fiabilité (couche de calcul, démarrage Étape 4 post-A.I)**. Une publication scientifique qui rapporte un CER LLM sans stabilité est méthodologiquement faible ; un benchmark qui ignore le plafond humain crée des classements faussement optimistes. Nouveau module `picarones/core/reliability.py` couvrant deux familles : (1) **IAA caractère** — `cohen_kappa(annotations_a, annotations_b)` retourne κ standard avec convention 1.0/0.0 documentée pour `pe=1` indéfini, garde-fous sur tailles/vide ; `krippendorff_alpha(units)` mode nominal généralisé à N annotateurs avec missing values (cellules None autorisées), formule `1 - D_o / D_e` sur paires sans remise, `None` si single label corpus-wide ou aucune unité ≥2 valides ; `_aligned_char_pairs(text_a, text_b)` aligne via `SequenceMatcher` sur opcodes `equal` et `replace` (insert/delete sans alignement bilatéral), `compute_iaa(transcription_a, transcription_b)` retourne `{n_aligned_chars, cohen_kappa, krippendorff_alpha, agreement_rate}`. (2) **Stabilité multi-runs** — `compute_multirun_stability(runs, reference=None)` mesure `pairwise_disagreement_mean/max` (Jaccard token-level), `identical_run_rate`, `n_distinct_outputs` ; si reference fournie, calcule `cer_per_run`, `cer_mean`, `cer_stdev`, `cer_cv` (None si mean=0 pour éviter division par zéro). Retourne None si <2 runs. Pure couche de calcul : pas d'extension du loader pour multi-GT, pas d'option runner `--repeats N`, pas de détecteur narratif `engine_unstable` — reportés à des sprints dédiés. +26 tests dans `test_sprint83_reliability.py` (cohen_kappa 6 cas dont accord parfait/désaccord pire que hasard κ=-1/un seul label, krippendorff 5 cas dont missing/single label corpus-wide, compute_iaa 5 cas dont empty/one-empty, multirun 6 cas dont reference parfaite et CV indéfini, _aligned_char_pairs 4 cas). **Verrou levé** : le rapport pourra demain afficher *« CER de Pero 4,2 % approche le plafond inter-paléographes κ=0,89 »* et signaler les pipelines LLM dont la variance dépasse un seuil. |
@@ -303,7 +304,7 @@ au template `_narrative_summary.html` (placé entre `_header.html` et `_critical
 ## Contexte développement
 
 - **Environnement** : GitHub Codespaces (`/workspaces/Picarones`), Python 3.12
-- **Tests** : 2842 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 ; Sprints 73-74 = A.I.3 livré bout-en-bout ; Sprints 75-77 = A.I.4 livré bout-en-bout ; Sprint 78 = A.I.5 couche calcul ; Sprint 79 = A.I.6 couche calcul ; Sprint 80 = A.I.7 ; Sprint 81 = A.I.8 — robustesse projetée sur corpus réel ; Sprint 82 = A.I.9 — section « Leviers d'amélioration » bout-en-bout ; Sprint 83 = A.II.4 — métriques de fiabilité (IAA Cohen κ + Krippendorff α + stabilité multi-runs, couche calcul) ; Sprint 84 = A.II.5a — recherchabilité fuzzy (Levenshtein ≤ 2, registre typé) ; **Sprint 85 = A.II.5b — précision séquences numériques (5 catégories, registre typé)**)
+- **Tests** : 2867 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 ; Sprints 73-74 = A.I.3 livré bout-en-bout ; Sprints 75-77 = A.I.4 livré bout-en-bout ; Sprint 78 = A.I.5 couche calcul ; Sprint 79 = A.I.6 couche calcul ; Sprint 80 = A.I.7 ; Sprint 81 = A.I.8 — robustesse projetée sur corpus réel ; Sprint 82 = A.I.9 — section « Leviers d'amélioration �� bout-en-bout ; Sprint 83 = A.II.4 — métriques de fiabilité (IAA Cohen κ + Krippendorff α + stabilité multi-runs, couche calcul) ; Sprint 84 = A.II.5a — recherchabilité fuzzy (Levenshtein ≤ 2, registre typé) ; Sprint 85 = A.II.5b — précision séquences numériques (5 catégories, registre typé) ; **Sprint 86 = A.II.5 livrée bout-en-bout — câblage runner adaptive + vues HTML « Recherchabilité fuzzy » et « Précision sur séquences numériques »**)
 - **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/numerical_sequences_runner.py

@@ -0,0 +1,102 @@
+"""Câblage runner des séquences numériques (Sprint 86).
+
+Sprint 86 — A.II.5b (vue HTML + câblage runner).
+
+Le module ``picarones/core/numerical_sequences.py`` (Sprint 85)
+a livré la couche de calcul.  Ce helper prépare la donnée
+adaptative pour le runner et agrège les compteurs par moteur.
+
+Adaptive masking
+----------------
+On ne stocke le résultat que si la GT contient au moins une
+séquence numérique détectée — sinon le module n'apparaît pas
+dans le rapport.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Iterable, Optional
+
+from picarones.core.numerical_sequences import (
+    CATEGORIES,
+    compute_numerical_sequence_metrics,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def compute_numerical_sequence_metrics_adaptive(
+    reference: Optional[str],
+    hypothesis: Optional[str],
+) -> Optional[dict]:
+    """Calcule les métriques séquences numériques avec masquage
+    adaptatif : retourne ``None`` si la GT n'en contient
+    aucune."""
+    if not reference:
+        return None
+    result = compute_numerical_sequence_metrics(reference, hypothesis or "")
+    if (result.get("n_total") or 0) == 0:
+        return None
+    return result
+
+
+def aggregate_numerical_sequence_metrics(
+    per_doc: Iterable[Optional[dict]],
+) -> Optional[dict]:
+    """Agrège par moteur : somme les compteurs par catégorie et
+    recalcule les scores globaux et per-category.
+
+    Format de sortie identique à ``compute_numerical_sequence_metrics``
+    pour faciliter le rendu HTML symétrique.
+    """
+    docs = [d for d in per_doc if d]
+    if not docs:
+        return None
+    total_n = 0
+    total_strict = 0
+    total_value = 0
+    per_cat: dict[str, dict] = {}
+    for cat in CATEGORIES:
+        per_cat[cat] = {
+            "n_total": 0,
+            "strict": 0,
+            "value": 0,
+            "lost_items": [],
+        }
+    for d in docs:
+        for cat in CATEGORIES:
+            cat_data = (d.get("per_category") or {}).get(cat) or {}
+            per_cat[cat]["n_total"] += int(cat_data.get("n_total") or 0)
+            per_cat[cat]["strict"] += int(cat_data.get("strict") or 0)
+            per_cat[cat]["value"] += int(cat_data.get("value") or 0)
+            per_cat[cat]["lost_items"].extend(
+                cat_data.get("lost_items") or [],
+            )
+        total_n += int(d.get("n_total") or 0)
+    # Recalcul des scores
+    for cat, slot in per_cat.items():
+        n = slot["n_total"]
+        slot["strict_score"] = slot["strict"] / n if n else 0.0
+        slot["value_score"] = slot["value"] / n if n else 0.0
+        # Cap des lost_items à 50 par catégorie
+        slot["lost_items"] = slot["lost_items"][:50]
+        total_strict += slot["strict"]
+        total_value += slot["value"]
+    return {
+        "n_docs": len(docs),
+        "n_total": total_n,
+        "global_strict_score": (
+            total_strict / total_n if total_n else 0.0
+        ),
+        "global_value_score": (
+            total_value / total_n if total_n else 0.0
+        ),
+        "per_category": per_cat,
+    }
+
+
+__all__ = [
+    "compute_numerical_sequence_metrics_adaptive",
+    "aggregate_numerical_sequence_metrics",
+]

picarones/core/results.py

@@ -90,6 +90,25 @@ class DocumentResult:
     Cette logique adaptative permet de garder les rapports lisibles
     sur les corpus sans marqueurs philologiques.
     """
+    # Sprint 86 — recherchabilité fuzzy (Sprint 84) calculée
+    # automatiquement avec adaptive masking.
+    searchability_metrics: Optional[dict] = None
+    """Recherchabilité fuzzy (Sprint 84+86).
+
+    Format : retour de ``compute_searchability`` ({n_gt_tokens,
+    n_searchable, recall, missed_tokens, max_distance}). Présent
+    uniquement si la GT contient au moins un token.
+    """
+    # Sprint 86 — précision sur séquences numériques (Sprint 85)
+    # calculée automatiquement avec adaptive masking.
+    numerical_sequence_metrics: Optional[dict] = None
+    """Précision sur séquences numériques (Sprint 85+86).
+
+    Format : retour de ``compute_numerical_sequence_metrics``
+    (global_strict_score, global_value_score, n_total,
+    per_category). Présent uniquement si la GT contient au
+    moins une séquence détectée.
+    """
 
     def as_dict(self) -> dict:
         d = {
@@ -125,6 +144,10 @@ class DocumentResult:
             d["calibration_metrics"] = self.calibration_metrics
         if self.philological_metrics is not None:
             d["philological_metrics"] = self.philological_metrics
+        if self.searchability_metrics is not None:
+            d["searchability_metrics"] = self.searchability_metrics
+        if self.numerical_sequence_metrics is not None:
+            d["numerical_sequence_metrics"] = self.numerical_sequence_metrics
         return d
 
     def compact(self) -> None:
@@ -153,6 +176,8 @@ class DocumentResult:
         self.ner_metrics = None
         self.calibration_metrics = None
         self.philological_metrics = None
+        self.searchability_metrics = None
+        self.numerical_sequence_metrics = None
 
 
 @dataclass
@@ -206,6 +231,21 @@ class EngineReport:
     globaux ; les structures per_category/per_block/per_status sont
     également agrégées.  ``None`` si aucun document n'a porté de
     ``philological_metrics``."""
+    # Sprint 86
+    aggregated_searchability: Optional[dict] = None
+    """Recherchabilité fuzzy agrégée corpus-wide (Sprint 84+86).
+
+    Format ``{n_docs, n_gt_tokens, n_searchable, recall,
+    missed_tokens_sample, max_distance}``. ``None`` si aucun
+    document n'a porté de ``searchability_metrics``."""
+    aggregated_numerical_sequences: Optional[dict] = None
+    """Précision sur séquences numériques agrégée (Sprint 85+86).
+
+    Format identique à ``compute_numerical_sequence_metrics`` :
+    global_strict_score, global_value_score, n_total,
+    per_category{n_total, strict, value, strict_score,
+    value_score, lost_items}. ``None`` si aucun document n'avait
+    de séquence numérique exploitable."""
 
     def __post_init__(self) -> None:
         if not self.aggregated_metrics and self.document_results:
@@ -284,6 +324,12 @@ class EngineReport:
             d["aggregated_calibration"] = self.aggregated_calibration
         if self.aggregated_philological is not None:
             d["aggregated_philological"] = self.aggregated_philological
+        if self.aggregated_searchability is not None:
+            d["aggregated_searchability"] = self.aggregated_searchability
+        if self.aggregated_numerical_sequences is not None:
+            d["aggregated_numerical_sequences"] = (
+                self.aggregated_numerical_sequences
+            )
         return d
 
 

picarones/core/runner.py

@@ -298,6 +298,35 @@ def _compute_document_result(
     except Exception as e:
         _logger.warning("[philological] fonctionnalité dégradée : %s", e)
 
+    # Sprint 86 — recherchabilité fuzzy (Sprint 84) avec adaptive
+    # masking. Coût O(N_gt × N_hyp × len_max), négligeable sur les
+    # tailles de documents typiques.
+    searchability_data: Optional[dict] = None
+    try:
+        from picarones.core.searchability_runner import (
+            compute_searchability_metrics,
+        )
+        searchability_data = compute_searchability_metrics(
+            ground_truth, ocr_result.text,
+        )
+    except Exception as e:
+        _logger.warning("[searchability] fonctionnalité dégradée : %s", e)
+
+    # Sprint 86 — précision sur séquences numériques (Sprint 85)
+    # avec adaptive masking.
+    numerical_sequence_data: Optional[dict] = None
+    try:
+        from picarones.core.numerical_sequences_runner import (
+            compute_numerical_sequence_metrics_adaptive,
+        )
+        numerical_sequence_data = compute_numerical_sequence_metrics_adaptive(
+            ground_truth, ocr_result.text,
+        )
+    except Exception as e:
+        _logger.warning(
+            "[numerical_sequences] fonctionnalité dégradée : %s", e,
+        )
+
     return DocumentResult(
         doc_id=doc_id,
         image_path=image_path,
@@ -317,6 +346,8 @@ def _compute_document_result(
         hallucination_metrics=hallucination_data,
         calibration_metrics=calibration_data,
         philological_metrics=philological_data,
+        searchability_metrics=searchability_data,
+        numerical_sequence_metrics=numerical_sequence_data,
     )
 
 
@@ -735,6 +766,19 @@ def run_benchmark(
         agg_philological = aggregate_philological_metrics(
             [dr.philological_metrics for dr in document_results],
         )
+        # Sprint 86 — agrégation A.II.5
+        from picarones.core.searchability_runner import (
+            aggregate_searchability_metrics,
+        )
+        from picarones.core.numerical_sequences_runner import (
+            aggregate_numerical_sequence_metrics,
+        )
+        agg_searchability = aggregate_searchability_metrics(
+            [dr.searchability_metrics for dr in document_results],
+        )
+        agg_numerical_sequences = aggregate_numerical_sequence_metrics(
+            [dr.numerical_sequence_metrics for dr in document_results],
+        )
 
         report = EngineReport(
             engine_name=engine.name,
@@ -751,6 +795,8 @@ def run_benchmark(
             aggregated_hallucination=agg_hallucination,
             aggregated_calibration=agg_calibration,
             aggregated_philological=agg_philological,
+            aggregated_searchability=agg_searchability,
+            aggregated_numerical_sequences=agg_numerical_sequences,
         )
         engine_reports.append(report)
         logger.info(

picarones/core/searchability_runner.py

@@ -0,0 +1,81 @@
+"""Câblage runner de la recherchabilité (Sprint 86).
+
+Sprint 86 — A.II.5a (vue HTML + câblage runner).
+
+Le module ``picarones/core/searchability.py`` (Sprint 84) a livré
+la couche de calcul.  Ce helper prépare la donnée pour le runner
+historique et l'agrégation par moteur.
+
+Adaptive masking
+----------------
+Comme pour les modules philologiques (Sprint 61), on ne calcule
+le rappel que si la GT contient au moins un token —  pas de
+calcul vide qui produirait du bruit dans le rapport.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Iterable, Optional
+
+from picarones.core.searchability import (
+    _split_words,
+    compute_searchability,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def compute_searchability_metrics(
+    reference: Optional[str],
+    hypothesis: Optional[str],
+    *,
+    max_distance: int = 2,
+) -> Optional[dict]:
+    """Recherchabilité d'un document (adaptive).
+
+    Retourne ``None`` si la GT est vide ou ne contient aucun
+    token — ce qui déclenche l'adaptive masking côté HTML.
+    """
+    if not reference or not _split_words(reference):
+        return None
+    return compute_searchability(
+        reference, hypothesis or "", max_distance=max_distance,
+    )
+
+
+def aggregate_searchability_metrics(
+    per_doc: Iterable[Optional[dict]],
+) -> Optional[dict]:
+    """Agrège les métriques par-doc en un score corpus-wide.
+
+    Convention : on somme les ``n_gt_tokens`` et ``n_searchable``
+    et on recalcule un rappel **micro** (cohérent avec ECE/MCE
+    Sprint 39 et NER Sprint 38).
+    """
+    docs = [d for d in per_doc if d]
+    if not docs:
+        return None
+    n_gt = sum(int(d.get("n_gt_tokens") or 0) for d in docs)
+    n_search = sum(int(d.get("n_searchable") or 0) for d in docs)
+    if n_gt == 0:
+        return None
+    # On garde l'union des missed_tokens (capped pour ne pas
+    # exploser le JSON sur de gros corpus)
+    missed: list[str] = []
+    for d in docs:
+        missed.extend(d.get("missed_tokens") or [])
+    return {
+        "n_docs": len(docs),
+        "n_gt_tokens": n_gt,
+        "n_searchable": n_search,
+        "recall": n_search / n_gt,
+        "missed_tokens_sample": missed[:50],
+        "max_distance": docs[0].get("max_distance", 2),
+    }
+
+
+__all__ = [
+    "compute_searchability_metrics",
+    "aggregate_searchability_metrics",
+]

picarones/report/generator.py

@@ -199,6 +199,12 @@ def _build_report_data(benchmark: BenchmarkResult, images_b64: dict[str, str]) -
             # Sprint 62 — profil philologique agrégé (None si aucun
             # signal philologique sur le corpus pour ce moteur)
             "aggregated_philological": report.aggregated_philological,
+            # Sprint 86 — A.II.5 (recherchabilité fuzzy + séquences
+            # numériques). None si aucun document n'a de signal.
+            "aggregated_searchability": report.aggregated_searchability,
+            "aggregated_numerical_sequences": (
+                report.aggregated_numerical_sequences
+            ),
             "is_vlm": report.pipeline_info.get("is_vlm", False) if report.pipeline_info else False,
         }
         engines_summary.append(entry)
@@ -787,6 +793,21 @@ class ReportGenerator:
             labels=labels,
         )
 
+        # Sprint 86 — A.II.5 : recherchabilité fuzzy +
+        # séquences numériques. Adaptive : "" si aucun signal.
+        from picarones.report.searchability_render import (
+            build_searchability_summary_html,
+        )
+        from picarones.report.numerical_sequences_render import (
+            build_numerical_sequences_html,
+        )
+        searchability_html = build_searchability_summary_html(
+            report_data.get("engines", []), labels=labels,
+        )
+        numerical_sequences_html = build_numerical_sequences_html(
+            report_data.get("engines", []), labels=labels,
+        )
+
         env = _build_jinja_env()
         template = env.get_template("base.html.j2")
         html = template.render(
@@ -808,6 +829,8 @@ class ReportGenerator:
             reliability_diagrams_html=reliability_diagrams_html,
             stratified_ranking_html=stratified_ranking_html,
             philological_profile_html=philological_profile_html,
+            searchability_html=searchability_html,
+            numerical_sequences_html=numerical_sequences_html,
         )
 
         output_path.write_text(html, encoding="utf-8")

picarones/report/i18n/en.json

@@ -280,5 +280,20 @@
   "levers_complementarity_phrase_with_engine": "The bag-of-words oracle achieves a recall {abs_pct} points higher (+{rel_pct}% relative) than the best single engine ({best_engine}).",
   "levers_lexical_phrase": "Top GT tokens systematically modernized by {engine}: {items}.",
   "levers_robustness_phrase": "Projected deficit of {engine} on the real corpus: {deficit_pct} CER points cumulated over {n_types} degradations.",
-  "levers_robustness_phrase_with_worst": "Projected deficit of {engine} on the real corpus: {deficit_pct} CER points cumulated over {n_types} degradations — worst degradation: {worst_type} ({worst_pct} points)."
+  "levers_robustness_phrase_with_worst": "Projected deficit of {engine} on the real corpus: {deficit_pct} CER points cumulated over {n_types} degradations — worst degradation: {worst_type} ({worst_pct} points).",
+  "search_title": "Fuzzy searchability",
+  "search_note": "Fraction of GT tokens recovered in the OCR output within Levenshtein distance ≤ 2 — direct proxy of full-text search quality (Elastic, Solr, Gallica).",
+  "search_engine": "Engine",
+  "search_recall": "Recall",
+  "search_count": "Recovered tokens / total",
+  "search_docs": "Docs",
+  "numseq_title": "Numerical-sequence precision",
+  "numseq_note": "Strict score (form preserved) — the value in parentheses is the score on the value (XIV ↔ 14 accepted). Foliation: recto/verso are not interchangeable.",
+  "numseq_engine": "Engine",
+  "numseq_global": "Global",
+  "numseq_cat_year": "Year",
+  "numseq_cat_roman": "Roman",
+  "numseq_cat_foliation": "Foliation",
+  "numseq_cat_currency": "Amount",
+  "numseq_cat_regnal": "Regnal"
 }

picarones/report/i18n/fr.json

@@ -280,5 +280,20 @@
   "levers_complementarity_phrase_with_engine": "L'oracle bag-of-words atteint un rappel supérieur de {abs_pct} points (+{rel_pct}% relatif) à celui du meilleur moteur seul ({best_engine}).",
   "levers_lexical_phrase": "Top tokens GT systématiquement modernisés par {engine} : {items}.",
   "levers_robustness_phrase": "Déficit projeté de {engine} sur le corpus réel : {deficit_pct} points de CER cumulés sur {n_types} dégradations.",
-  "levers_robustness_phrase_with_worst": "Déficit projeté de {engine} sur le corpus réel : {deficit_pct} points de CER cumulés sur {n_types} dégradations — pire dégradation : {worst_type} ({worst_pct} points)."
+  "levers_robustness_phrase_with_worst": "Déficit projeté de {engine} sur le corpus réel : {deficit_pct} points de CER cumulés sur {n_types} dégradations — pire dégradation : {worst_type} ({worst_pct} points).",
+  "search_title": "Recherchabilité fuzzy",
+  "search_note": "Proportion de tokens GT retrouvés dans la sortie OCR à distance de Levenshtein ≤ 2 — proxy direct de la qualité pour la recherche plein-texte (Elastic, Solr, Gallica).",
+  "search_engine": "Moteur",
+  "search_recall": "Rappel",
+  "search_count": "Tokens retrouvés / total",
+  "search_docs": "Docs",
+  "numseq_title": "Précision sur séquences numériques",
+  "numseq_note": "Score strict (forme préservée) — la valeur entre parenthèses est le score sur la valeur (XIV ↔ 14 accepté). Foliotation : recto/verso non interchangeables.",
+  "numseq_engine": "Moteur",
+  "numseq_global": "Global",
+  "numseq_cat_year": "Année",
+  "numseq_cat_roman": "Romain",
+  "numseq_cat_foliation": "Foliation",
+  "numseq_cat_currency": "Montant",
+  "numseq_cat_regnal": "Régnal"
 }

picarones/report/numerical_sequences_render.py

@@ -0,0 +1,164 @@
+"""Rendu HTML « Précision sur séquences numériques » — Sprint 86.
+
+Suite directe ``picarones/core/numerical_sequences.py``
+(Sprint 85) + câblage runner Sprint 86.
+
+Pattern identique aux autres rendus : server-side, pas de JS,
+anti-injection systématique.
+
+Vue
+---
+Tableau moteur × catégorie (year / roman / foliation / currency
+/ regnal) × score strict ; une ligne par moteur, une cellule
+colorée par cellule.  Une seconde ligne donne le score ``value``
+(en plus petit).  Catégorie omise si **aucun** moteur n'a de
+GT exploitable pour elle.
+
+Adaptative : ``""`` si aucun moteur n'a de
+``aggregated_numerical_sequences``.
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+from picarones.core.numerical_sequences import CATEGORIES
+
+
+def _color_for_score(score: float) -> str:
+    """Gradient rouge → jaune → vert."""
+    f = max(0.0, min(1.0, score))
+    if f < 0.5:
+        t = f / 0.5
+        r = 235
+        g = int(70 + (200 - 70) * t)
+        b = 70
+    else:
+        t = (f - 0.5) / 0.5
+        r = int(235 + (60 - 235) * t)
+        g = int(200 + (160 - 200) * t)
+        b = int(70 + (90 - 70) * t)
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+def _category_columns_with_signal(rows: list[dict]) -> list[str]:
+    """Ne garde que les catégories où ≥ 1 moteur a un n_total > 0."""
+    visible: list[str] = []
+    for cat in CATEGORIES:
+        for r in rows:
+            agg = r.get("aggregated_numerical_sequences") or {}
+            cat_data = (agg.get("per_category") or {}).get(cat) or {}
+            if (cat_data.get("n_total") or 0) > 0:
+                visible.append(cat)
+                break
+    return visible
+
+
+def build_numerical_sequences_html(
+    engines: list[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit la section HTML séquences numériques.
+
+    Returns
+    -------
+    str
+        ``""`` si aucun moteur n'a de signal.
+    """
+    rows = [
+        e for e in engines
+        if isinstance(e.get("aggregated_numerical_sequences"), dict)
+    ]
+    if not rows:
+        return ""
+    visible_cats = _category_columns_with_signal(rows)
+    if not visible_cats:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "numseq_title", "Précision sur séquences numériques",
+    )
+    note = labels.get(
+        "numseq_note",
+        "Score strict (forme préservée) — la valeur entre "
+        "parenthèses est le score sur la valeur (XIV ↔ 14 "
+        "accepté). Foliotation : recto/verso non interchangeables.",
+    )
+    col_engine = labels.get("numseq_engine", "Moteur")
+    col_global = labels.get("numseq_global", "Global")
+    cat_label = {
+        "year": labels.get("numseq_cat_year", "Année"),
+        "roman": labels.get("numseq_cat_roman", "Romain"),
+        "foliation": labels.get("numseq_cat_foliation", "Foliation"),
+        "currency": labels.get("numseq_cat_currency", "Montant"),
+        "regnal": labels.get("numseq_cat_regnal", "Régnal"),
+    }
+
+    parts = [
+        '<div class="numseq-section" style="margin:1rem 0">',
+        f'<h3 style="margin:0 0 .3rem 0">{_e(title)}</h3>',
+        f'<div style="font-size:.85rem;opacity:.75;margin-bottom:.5rem">'
+        f'{_e(note)}</div>',
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.9rem">',
+        '<thead><tr>',
+        f'<th style="padding:.4rem .6rem;text-align:left;'
+        f'border-bottom:1px solid #ccc;font-weight:600">'
+        f'{_e(col_engine)}</th>',
+        f'<th style="padding:.4rem .6rem;text-align:right;'
+        f'border-bottom:1px solid #ccc;font-weight:600">'
+        f'{_e(col_global)}</th>',
+    ]
+    for cat in visible_cats:
+        parts.append(
+            f'<th style="padding:.4rem .6rem;text-align:right;'
+            f'border-bottom:1px solid #ccc;font-weight:600">'
+            f'{_e(cat_label.get(cat, cat))}</th>'
+        )
+    parts.append("</tr></thead><tbody>")
+
+    for engine in rows:
+        agg = engine["aggregated_numerical_sequences"]
+        name = engine.get("name") or "?"
+        per_cat = agg.get("per_category") or {}
+        global_strict = float(agg.get("global_strict_score") or 0.0)
+        global_value = float(agg.get("global_value_score") or 0.0)
+        n_total = int(agg.get("n_total") or 0)
+        global_color = _color_for_score(global_strict)
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.4rem .6rem">{_e(str(name))}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'background:{global_color};font-family:monospace;'
+            f'font-weight:600">'
+            f'{global_strict * 100:.1f}%'
+            f'<span style="font-size:.75rem;font-weight:400;'
+            f'opacity:.75"> ({global_value * 100:.0f}%, '
+            f'n={n_total})</span></td>'
+        )
+        for cat in visible_cats:
+            cat_data = per_cat.get(cat) or {}
+            n = int(cat_data.get("n_total") or 0)
+            if n == 0:
+                parts.append(
+                    '<td style="padding:.4rem .6rem;text-align:right;'
+                    'opacity:.4">—</td>'
+                )
+                continue
+            strict = float(cat_data.get("strict_score") or 0.0)
+            value = float(cat_data.get("value_score") or 0.0)
+            color = _color_for_score(strict)
+            parts.append(
+                f'<td style="padding:.4rem .6rem;text-align:right;'
+                f'background:{color};font-family:monospace">'
+                f'{strict * 100:.0f}%'
+                f'<span style="font-size:.75rem;opacity:.75"> '
+                f'({value * 100:.0f}%, n={n})</span></td>'
+            )
+        parts.append("</tr>")
+    parts.append("</tbody></table></div>")
+    return "".join(parts)
+
+
+__all__ = ["build_numerical_sequences_html"]

picarones/report/searchability_render.py

@@ -0,0 +1,119 @@
+"""Rendu HTML « Recherchabilité fuzzy » — Sprint 86 (A.II.5a HTML).
+
+Suite directe ``picarones/core/searchability.py`` (Sprint 84) +
+câblage runner (Sprint 86).
+
+Pattern identique aux autres rendus (Sprints 41/43/62/67/72) :
+**server-side**, pas de JavaScript, anti-injection systématique.
+
+Vue
+---
+Tableau résumé : moteur × (rappel, n_searchable / n_gt_tokens,
+docs).  Cellule rappel colorée par gradient rouge → vert.
+Adaptative : ``""`` si aucun moteur n'a de
+``aggregated_searchability``.
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+
+def _color_for_recall(recall: float) -> str:
+    """Gradient rouge → jaune → vert pour rappel ∈ [0, 1]."""
+    f = max(0.0, min(1.0, recall))
+    if f < 0.5:
+        # rouge → jaune
+        t = f / 0.5
+        r = 235
+        g = int(70 + (200 - 70) * t)
+        b = 70
+    else:
+        # jaune → vert
+        t = (f - 0.5) / 0.5
+        r = int(235 + (60 - 235) * t)
+        g = int(200 + (160 - 200) * t)
+        b = int(70 + (90 - 70) * t)
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+def build_searchability_summary_html(
+    engines: list[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit la table HTML de recherchabilité.
+
+    Parameters
+    ----------
+    engines:
+        Liste de dicts moteur ; chacun peut avoir
+        ``aggregated_searchability``.
+    labels:
+        Dict i18n, clés ``search_*``.
+
+    Returns
+    -------
+    str
+        ``""`` si aucun moteur n'a de signal.
+    """
+    rows = [
+        e for e in engines
+        if isinstance(e.get("aggregated_searchability"), dict)
+    ]
+    if not rows:
+        return ""
+    labels = labels or {}
+    title = labels.get("search_title", "Recherchabilité fuzzy")
+    note = labels.get(
+        "search_note",
+        "Proportion de tokens GT retrouvés dans la sortie OCR à "
+        "distance de Levenshtein ≤ 2 — proxy direct de la "
+        "qualité pour la recherche plein-texte (Elastic, Solr).",
+    )
+    col_engine = labels.get("search_engine", "Moteur")
+    col_recall = labels.get("search_recall", "Rappel")
+    col_count = labels.get("search_count", "Tokens retrouvés / total")
+    col_docs = labels.get("search_docs", "Docs")
+
+    parts = [
+        '<div class="searchability-section" style="margin:1rem 0">',
+        f'<h3 style="margin:0 0 .3rem 0">{_e(title)}</h3>',
+        f'<div style="font-size:.85rem;opacity:.75;margin-bottom:.5rem">'
+        f'{_e(note)}</div>',
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.9rem">',
+        '<thead><tr>',
+    ]
+    for col in (col_engine, col_recall, col_count, col_docs):
+        parts.append(
+            f'<th style="padding:.4rem .6rem;text-align:left;'
+            f'border-bottom:1px solid #ccc;font-weight:600">'
+            f'{_e(col)}</th>'
+        )
+    parts.append("</tr></thead><tbody>")
+    for engine in rows:
+        agg = engine["aggregated_searchability"]
+        name = engine.get("name") or "?"
+        recall = float(agg.get("recall") or 0.0)
+        n_search = int(agg.get("n_searchable") or 0)
+        n_total = int(agg.get("n_gt_tokens") or 0)
+        n_docs = int(agg.get("n_docs") or 0)
+        color = _color_for_recall(recall)
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.4rem .6rem">{_e(str(name))}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'background:{color};font-family:monospace;font-weight:600">'
+            f'{recall * 100:.1f}%</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{n_search} / {n_total}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{n_docs}</td>'
+            f'</tr>'
+        )
+    parts.append("</tbody></table></div>")
+    return "".join(parts)
+
+
+__all__ = ["build_searchability_summary_html"]

picarones/report/templates/view_analyses.html

@@ -209,6 +209,20 @@
     </div>
     {% endif %}
 
+    <!-- Sprint 86 — A.II.5 : recherchabilité fuzzy + précision sur
+         séquences numériques. Adaptive : n'apparaît que si au moins
+         un moteur a du signal. -->
+    {% if searchability_html %}
+    <div class="chart-card" style="grid-column:1/-1">
+      {{ searchability_html }}
+    </div>
+    {% endif %}
+    {% if numerical_sequences_html %}
+    <div class="chart-card" style="grid-column:1/-1">
+      {{ numerical_sequences_html }}
+    </div>
+    {% endif %}
+
     <!-- Sprint 37 — Analyse inter-moteurs (divergence taxonomique + oracle gap) -->
     {% if divergence_matrix_html or oracle_gap_html %}
     <div class="chart-card" style="grid-column:1/-1">

tests/test_sprint86_aii5_html.py

@@ -0,0 +1,367 @@
+"""Tests Sprint 86 — A.II.5 bout-en-bout : helpers runner +
+rendu HTML.
+
+Couvre :
+
+1. ``compute_searchability_metrics`` adaptive masking.
+2. ``aggregate_searchability_metrics`` micro-recall.
+3. ``compute_numerical_sequence_metrics_adaptive`` masking.
+4. ``aggregate_numerical_sequence_metrics`` somme par catégorie.
+5. Champs ``DocumentResult.searchability_metrics`` et
+   ``EngineReport.aggregated_searchability``.
+6. Rendu HTML adaptive + anti-injection.
+7. Complétude i18n FR/EN.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from picarones.core.numerical_sequences_runner import (
+    aggregate_numerical_sequence_metrics,
+    compute_numerical_sequence_metrics_adaptive,
+)
+from picarones.core.metrics import MetricsResult
+from picarones.core.results import DocumentResult, EngineReport
+
+
+def _stub_metrics() -> MetricsResult:
+    return 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=0, hypothesis_length=0,
+    )
+from picarones.core.searchability_runner import (
+    aggregate_searchability_metrics,
+    compute_searchability_metrics,
+)
+from picarones.report.numerical_sequences_render import (
+    build_numerical_sequences_html,
+)
+from picarones.report.searchability_render import (
+    build_searchability_summary_html,
+)
+
+
+def _load_labels(lang: str) -> dict:
+    p = (
+        Path(__file__).parent.parent
+        / "picarones" / "report" / "i18n" / f"{lang}.json"
+    )
+    return json.loads(p.read_text(encoding="utf-8"))
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 1. Helpers searchability
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestSearchabilityRunner:
+    def test_empty_gt_returns_none(self) -> None:
+        assert compute_searchability_metrics("", "anything") is None
+
+    def test_normal(self) -> None:
+        r = compute_searchability_metrics("le roi", "le roy")
+        assert r is not None
+        assert r["recall"] == 1.0
+        assert r["n_gt_tokens"] == 2
+
+    def test_aggregate_micro_recall(self) -> None:
+        d1 = {"n_gt_tokens": 10, "n_searchable": 9, "missed_tokens": ["x"]}
+        d2 = {"n_gt_tokens": 20, "n_searchable": 15, "missed_tokens": ["y"]}
+        agg = aggregate_searchability_metrics([d1, d2])
+        assert agg is not None
+        assert agg["n_gt_tokens"] == 30
+        assert agg["n_searchable"] == 24
+        assert agg["recall"] == 24 / 30
+        assert agg["n_docs"] == 2
+
+    def test_aggregate_empty(self) -> None:
+        assert aggregate_searchability_metrics([None, None]) is None
+        assert aggregate_searchability_metrics([]) is None
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 2. Helpers numerical sequences
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestNumericalSequencesRunner:
+    def test_no_signal_returns_none(self) -> None:
+        # GT sans aucune séquence numérique
+        assert compute_numerical_sequence_metrics_adaptive(
+            "lorem ipsum dolor", "sit amet",
+        ) is None
+
+    def test_signal_present(self) -> None:
+        r = compute_numerical_sequence_metrics_adaptive(
+            "an III, 1789", "an III, 1789",
+        )
+        assert r is not None
+        assert r["n_total"] >= 1
+
+    def test_aggregate_sums_per_category(self) -> None:
+        d1 = {
+            "n_total": 3,
+            "global_strict_score": 1.0,
+            "global_value_score": 1.0,
+            "per_category": {
+                "year": {"n_total": 2, "strict": 2, "value": 2,
+                         "strict_score": 1.0, "value_score": 1.0,
+                         "lost_items": []},
+                "roman": {"n_total": 1, "strict": 1, "value": 1,
+                          "strict_score": 1.0, "value_score": 1.0,
+                          "lost_items": []},
+                "foliation": {"n_total": 0, "strict": 0, "value": 0,
+                              "strict_score": 0.0, "value_score": 0.0,
+                              "lost_items": []},
+                "currency": {"n_total": 0, "strict": 0, "value": 0,
+                             "strict_score": 0.0, "value_score": 0.0,
+                             "lost_items": []},
+                "regnal": {"n_total": 0, "strict": 0, "value": 0,
+                           "strict_score": 0.0, "value_score": 0.0,
+                           "lost_items": []},
+            },
+        }
+        d2 = {
+            "n_total": 4,
+            "global_strict_score": 0.5,
+            "global_value_score": 0.5,
+            "per_category": {
+                "year": {"n_total": 4, "strict": 2, "value": 2,
+                         "strict_score": 0.5, "value_score": 0.5,
+                         "lost_items": ["1500", "1600"]},
+                "roman": {"n_total": 0, "strict": 0, "value": 0,
+                          "strict_score": 0.0, "value_score": 0.0,
+                          "lost_items": []},
+                "foliation": {"n_total": 0, "strict": 0, "value": 0,
+                              "strict_score": 0.0, "value_score": 0.0,
+                              "lost_items": []},
+                "currency": {"n_total": 0, "strict": 0, "value": 0,
+                             "strict_score": 0.0, "value_score": 0.0,
+                             "lost_items": []},
+                "regnal": {"n_total": 0, "strict": 0, "value": 0,
+                           "strict_score": 0.0, "value_score": 0.0,
+                           "lost_items": []},
+            },
+        }
+        agg = aggregate_numerical_sequence_metrics([d1, d2])
+        assert agg["n_total"] == 7
+        assert agg["per_category"]["year"]["n_total"] == 6
+        assert agg["per_category"]["year"]["strict"] == 4
+        assert agg["per_category"]["year"]["strict_score"] == 4 / 6
+        # global = (2+1 + 2) / 7 = 5/7
+        assert agg["global_strict_score"] == 5 / 7
+
+    def test_aggregate_empty(self) -> None:
+        assert aggregate_numerical_sequence_metrics([None]) is None
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 3. Champs results.py
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestResultsFields:
+    def test_document_result_serializes_searchability(self) -> None:
+        dr = DocumentResult(
+            doc_id="doc1", image_path="x.png",
+            ground_truth="hello", hypothesis="helo",
+            metrics=_stub_metrics(), duration_seconds=1.0,
+            searchability_metrics={"recall": 0.9},
+            numerical_sequence_metrics={"n_total": 1},
+        )
+        d = dr.as_dict()
+        assert d["searchability_metrics"] == {"recall": 0.9}
+        assert d["numerical_sequence_metrics"] == {"n_total": 1}
+
+    def test_document_result_omits_when_none(self) -> None:
+        dr = DocumentResult(
+            doc_id="doc1", image_path="x.png",
+            ground_truth="hello", hypothesis="helo",
+            metrics=_stub_metrics(), duration_seconds=1.0,
+        )
+        d = dr.as_dict()
+        assert "searchability_metrics" not in d
+        assert "numerical_sequence_metrics" not in d
+
+    def test_compact_clears_fields(self) -> None:
+        dr = DocumentResult(
+            doc_id="doc1", image_path="x.png",
+            ground_truth="hello", hypothesis="helo",
+            metrics=_stub_metrics(), duration_seconds=1.0,
+            searchability_metrics={"recall": 0.9},
+            numerical_sequence_metrics={"n_total": 1},
+        )
+        dr.compact()
+        assert dr.searchability_metrics is None
+        assert dr.numerical_sequence_metrics is None
+
+    def test_engine_report_serializes_aggregates(self) -> None:
+        er = EngineReport(
+            engine_name="t", engine_version="0",
+            engine_config={},
+            document_results=[],
+            pipeline_info=None,
+            aggregated_searchability={"recall": 0.85},
+            aggregated_numerical_sequences={"global_strict_score": 0.9},
+        )
+        d = er.as_dict()
+        assert d["aggregated_searchability"]["recall"] == 0.85
+        assert d["aggregated_numerical_sequences"]["global_strict_score"] == 0.9
+
+    def test_engine_report_omits_when_none(self) -> None:
+        er = EngineReport(
+            engine_name="t", engine_version="0",
+            engine_config={},
+            document_results=[],
+            pipeline_info=None,
+        )
+        d = er.as_dict()
+        assert "aggregated_searchability" not in d
+        assert "aggregated_numerical_sequences" not in d
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 4. Rendu HTML
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestSearchabilityHtml:
+    def test_empty_returns_empty(self) -> None:
+        assert build_searchability_summary_html([]) == ""
+
+    def test_no_signal_returns_empty(self) -> None:
+        engines = [{"name": "t"}]  # pas de aggregated_searchability
+        assert build_searchability_summary_html(engines) == ""
+
+    def test_renders_table_with_recall(self) -> None:
+        engines = [{
+            "name": "tess",
+            "aggregated_searchability": {
+                "recall": 0.92, "n_searchable": 92,
+                "n_gt_tokens": 100, "n_docs": 5,
+            },
+        }]
+        html = build_searchability_summary_html(
+            engines, _load_labels("fr"),
+        )
+        assert "<table" in html
+        assert "92.0%" in html
+        assert "92 / 100" in html
+        assert "tess" in html
+
+    def test_anti_injection(self) -> None:
+        engines = [{
+            "name": "<script>alert(1)</script>",
+            "aggregated_searchability": {
+                "recall": 0.5, "n_searchable": 5, "n_gt_tokens": 10,
+                "n_docs": 1,
+            },
+        }]
+        html = build_searchability_summary_html(
+            engines, _load_labels("fr"),
+        )
+        assert "<script>alert" not in html
+        assert "&lt;script&gt;" in html
+
+    def test_renders_in_english(self) -> None:
+        engines = [{
+            "name": "tess",
+            "aggregated_searchability": {
+                "recall": 0.95, "n_searchable": 95,
+                "n_gt_tokens": 100, "n_docs": 5,
+            },
+        }]
+        html = build_searchability_summary_html(
+            engines, _load_labels("en"),
+        )
+        assert "Fuzzy searchability" in html
+
+
+class TestNumericalSequencesHtml:
+    def _engine(self, name="tess", **kwargs) -> dict:
+        per_cat_default = {
+            cat: {"n_total": 0, "strict": 0, "value": 0,
+                  "strict_score": 0.0, "value_score": 0.0,
+                  "lost_items": []}
+            for cat in ("year", "roman", "foliation", "currency", "regnal")
+        }
+        per_cat_default.update(kwargs.get("per_cat_overrides", {}))
+        return {
+            "name": name,
+            "aggregated_numerical_sequences": {
+                "global_strict_score": kwargs.get("strict", 0.5),
+                "global_value_score": kwargs.get("value", 0.5),
+                "n_total": kwargs.get("n_total", 1),
+                "n_docs": 1,
+                "per_category": per_cat_default,
+            },
+        }
+
+    def test_empty_returns_empty(self) -> None:
+        assert build_numerical_sequences_html([]) == ""
+
+    def test_no_signal_returns_empty(self) -> None:
+        engines = [{"name": "t"}]
+        assert build_numerical_sequences_html(engines) == ""
+
+    def test_omits_categories_without_signal(self) -> None:
+        # Seul 'year' a du signal
+        e = self._engine(per_cat_overrides={
+            "year": {"n_total": 5, "strict": 5, "value": 5,
+                     "strict_score": 1.0, "value_score": 1.0,
+                     "lost_items": []},
+        })
+        html = build_numerical_sequences_html([e], _load_labels("fr"))
+        assert "Année" in html
+        # Romain absent puisqu'aucun n_total > 0
+        assert "Romain" not in html
+
+    def test_renders_per_category_score(self) -> None:
+        e = self._engine(strict=0.8, value=0.9, n_total=20,
+                         per_cat_overrides={
+            "year": {"n_total": 10, "strict": 8, "value": 9,
+                     "strict_score": 0.8, "value_score": 0.9,
+                     "lost_items": []},
+        })
+        html = build_numerical_sequences_html([e], _load_labels("fr"))
+        assert "80%" in html  # year strict score
+        assert "n=20" in html or "n=10" in html
+
+    def test_anti_injection(self) -> None:
+        e = self._engine(name="<img/>", per_cat_overrides={
+            "year": {"n_total": 1, "strict": 1, "value": 1,
+                     "strict_score": 1.0, "value_score": 1.0,
+                     "lost_items": []},
+        })
+        html = build_numerical_sequences_html([e], _load_labels("fr"))
+        assert "<img/>" not in html
+        assert "&lt;img" in html
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 5. Complétude i18n
+# ──────────────────────────────────────────────────────────────────────────
+
+
+_KEYS = {
+    "search_title", "search_note", "search_engine", "search_recall",
+    "search_count", "search_docs",
+    "numseq_title", "numseq_note", "numseq_engine", "numseq_global",
+    "numseq_cat_year", "numseq_cat_roman", "numseq_cat_foliation",
+    "numseq_cat_currency", "numseq_cat_regnal",
+}
+
+
+class TestI18nCompleteness:
+    def test_fr_has_all(self) -> None:
+        d = _load_labels("fr")
+        missing = _KEYS - d.keys()
+        assert not missing, f"manque FR : {missing}"
+
+    def test_en_has_all(self) -> None:
+        d = _load_labels("en")
+        missing = _KEYS - d.keys()
+        assert not missing, f"manque EN : {missing}"