sprint80: sur-normalisation lexicale (A.I.7 couche calcul + HTML)

Le détecteur llm_hallucination_flag (Sprint 19) signale via un
score agrégé mais ne dit pas QUOI corriger dans le prompt. Ce
sprint produit une table de fréquences détaillée par token GT.

- Nouveau module picarones/core/lexical_modernization.py :
- compute_lexical_modernization(reference, hypothesis, stop_list,
case_sensitive) aligne mot-à-mot via difflib et accumule par
token GT {n_total, n_modernized, rate_modernized, variants}.
- aggregate_lexical_modernization corpus-wide.
- top_modernized_tokens(n=20, min_total=1) tri descendant rate
avec filtre anecdotiques.
- Stop-list paramétrable (par défaut vide).
- Suppression GT → variant ∅.
- Nouveau module picarones/report/lexical_modernization_render.py :
- build_lexical_modernization_html : tableau 4 colonnes (forme
GT, variantes top-3, n GT, % gradient blanc→orange).
- Adaptive : "" si data None ou aucun modernisé.
- +6 clés i18n FR/EN.
- +20 tests dans test_sprint80_lexical_modernization.py.

Verrou levé : « maistre → maître modernisé dans 100 % des cas »
permet d'ajuster le prompt — info exploitable au lieu d'un score
agrégé abstrait.

Tests : 2699 passed, 2 skipped, 0 failed.

https://claude.ai/code/session_01RusTQYcSfXqTsbFNvwmCV7

CHANGELOG.md

@@ -16,6 +16,49 @@ La numérotation de version suit [Semantic Versioning](https://semver.org/lang/f
 
 ### Ajouté
 
+- **Sprint 80 — A.I.7 : sur-normalisation lexicale en vue
+  analytique dédiée (couche calcul + table HTML).**  Le détecteur
+  ``llm_hallucination_flag`` (Sprint 19) signale qu'un moteur
+  sur-normalise via un score agrégé.  Mais ce score ne dit rien
+  sur **quoi** corriger dans le prompt.  Ce sprint produit une
+  **table de fréquences détaillée** par token GT.
+  - Nouveau module `picarones/core/lexical_modernization.py` :
+    - ``compute_lexical_modernization(reference, hypothesis,
+      stop_list, case_sensitive)`` aligne mot-à-mot via
+      ``difflib.SequenceMatcher`` et accumule par token GT :
+      ``{n_total, n_modernized, rate_modernized, variants}``.
+    - ``aggregate_lexical_modernization(per_doc_results)`` somme
+      les compteurs corpus-wide.
+    - ``top_modernized_tokens(data, n=20, min_total=1)`` retourne
+      les N tokens GT les plus modernisés (tri décroissant par
+      taux, tie-break par n_total).  Filtre les anecdotiques
+      via ``min_total``.
+    - Stop-list paramétrable (tokens GT à ignorer même s'ils
+      sont modifiés) — par défaut vide, le module ne devine pas
+      ce qui est « moderne ».
+    - Cas particuliers : token GT supprimé → variant ``∅``.
+  - Nouveau module `picarones/report/lexical_modernization_render.py` :
+    - ``build_lexical_modernization_html(data, labels, top_n,
+      min_total)`` produit un tableau HTML 4 colonnes (forme
+      historique GT, variantes OCR, n GT, % modernisé).
+    - Cellule ``% modernisé`` colorée en gradient blanc → orange.
+    - Compactage des variants : top 3 affichés + ``+N`` pour le
+      reste.
+    - Adaptive : ``""`` si ``data is None`` ou aucun token
+      modernisé.
+  - +6 clés i18n FR/EN (``lexmod_*``).
+  - +20 tests dans `test_sprint80_lexical_modernization.py` :
+    couche calcul (9 cas — systématique, préservé, partiel,
+    multi-variants, stop-list, casse, suppression, vide, None) ;
+    agrégation (2 cas) ; top (2 cas — tri, min_total) ; rendu
+    (5 cas — None, no_modernization, table, %, anti-injection) ;
+    complétude i18n FR + EN.
+  - **Verrou levé** : le chercheur peut désormais lire « maistre
+    → maître modernisé dans 100 % des cas » et ajuster son prompt
+    en conséquence pour préserver l'orthographe historique.
+    L'information est exploitable au lieu d'un score agrégé
+    abstrait.
+
 - **Sprint 79 — A.I.6 : projection de coût en volume cible
   (couche de calcul).**  La vue Pareto (Sprint 20) trace CER vs
   coût mais le coût est par unité (1 000 pages).  Pour décider

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). |
+| 80 | **Sprint 49 du plan d'évolution 2026 — A.I.7 : sur-normalisation lexicale (couche calcul + table HTML)**. Le détecteur `llm_hallucination_flag` (Sprint 19) signale via un score agrégé mais ne dit pas **quoi** corriger dans le prompt. Nouveau module `picarones/core/lexical_modernization.py` : `compute_lexical_modernization(reference, hypothesis, stop_list, case_sensitive)` aligne mot-à-mot via `difflib.SequenceMatcher` et accumule par token GT `{n_total, n_modernized, rate_modernized, variants}` ; `aggregate_lexical_modernization` somme corpus-wide ; `top_modernized_tokens(data, n=20, min_total=1)` retourne les N tokens GT les plus modernisés (tri décroissant par taux, tie-break par n_total, filtre anecdotiques via min_total). Stop-list paramétrable (par défaut vide). Suppression GT → variant ∅. Nouveau module `picarones/report/lexical_modernization_render.py` : `build_lexical_modernization_html(data, labels, top_n, min_total)` tableau 4 colonnes (forme GT, variantes OCR top-3, n GT, % modernisé gradient blanc→orange). Adaptive : "" si data None ou aucun modernisé. +6 clés i18n FR/EN. +20 tests (calcul 9 cas dont systématique/préservé/partiel/multi-variants/stop-list/casse/suppression/vide, agrégation 2 cas, top 2 cas, rendu 5 cas dont anti-injection, complétude i18n). **Verrou levé** : le chercheur lit « maistre → maître modernisé dans 100 % des cas » et ajuste son prompt — info exploitable au lieu d'un score agrégé. |
 | 79 | **Sprint 48 du plan d'évolution 2026 — A.I.6 : projection de coût en volume cible (couche de calcul)**. La vue Pareto (Sprint 20) trace CER vs coût mais le coût est par unité (1 000 pages) ; payer 50 € de plus sur 50 pages est trivial, sur 5 millions ça change tout. Nouveau module `picarones/core/cost_projection.py` : `ProjectedCost(engine_key, target_pages, cost_total_eur, co2_total_g, cost_per_1k_pages_eur, co2_per_1k_pages_g, type)`, `project_cost_total/co2_total` linéaire en pages avec `None` si données insuffisantes ou target<0, `project_engine` retourne le ProjectedCost complet, `project_all_engines(engine_costs, target_pages)` projette N moteurs (ValueError si target<0, moteurs sans données conservés avec cost_total=None), `cost_gap_table(projections, baseline)` retourne `{engine: {total, delta_abs, delta_rel}}` vs baseline (KeyError si baseline inconnue, delta_rel=None si baseline=0). +17 tests (calcul 5 cas, CO₂ 2 cas, engine 2 cas, all_engines 3 cas, gap_table 4 cas, **cas réaliste BnF 80 000 pages BMS** Tesseract=3.20€/Pero=0€/Mistral=280€/GPT-4o=600€). **Verrou levé** : couche calcul prête pour câbler le panneau « Avancé » avec champ « Volume cible » qui recalcule Pareto et table coût en valeur totale projetée. UX HTML suivra. |
 | 78 | **Sprint 47 du plan d'évolution 2026 — A.I.5 : équivalences diplomatiques en curseur fin (couche de calcul)**. Les profils `DIPLOMATIC_*` de `normalization.py` appliquent un bloc entier ; un éditeur peut vouloir nuancer (« je tolère ſ→s mais pas u→v »). Nouveau module `picarones/core/equivalence_profile.py` : dataclass `EquivalenceRule(name, source, target, description, profile_tag)`, catalogue `BUILTIN_EQUIVALENCES` dérivé automatiquement des 4 profils intégrés avec 15 règles canoniques nommées (`longs_s`, `u_eq_v`, `i_eq_j`, `ae_ligature`, `thorn_th`, `vv_eq_w`, etc.), `list_equivalences_by_profile`, `apply_selected_equivalences(text, selected_names)` (règles inconnues ignorées + warning, texte vide → ""), `compute_cer_with_equivalences(reference, hypothesis, selected_names)` qui applique les deux côtés puis renvoie CER. Aucune modification de normalization.py — purement additif. +17 tests (catalogue 4 cas, liste 3 cas, apply 6 cas dont sélectif/exclu/multi/inconnue, compute_cer 4 cas dont application bilatérale). **Verrou levé** : la couche calcul est prête pour câbler le panneau « Avancé » du rapport avec cases à cocher granulaires et recalcul JS client. UX (URL state + debounce) suivra dans un sprint dédié. |
 | 77 | **Sprint 46 du plan d'évolution 2026 — A.I.4 chantier 3 : taxonomie comparative côte-à-côte (clôture A.I.4)**. Troisième chantier d'A.I.4. Répond à « deux moteurs ont le même CER global, mais lequel fait des erreurs plus récupérables ? ». Nouveau module `picarones/core/taxonomy_comparison.py` : `compare_taxonomies(engine_a, counts_a, engine_b, counts_b)` normalise en proportions, calcule deltas signés, agrège par niveau de **récupérabilité éditoriale** (recoverable: case/ligature/abbreviation ; difficult: diacritic/visual/hapax ; irrecoverable: lacuna/oov/segmentation). Constante `RECOVERABILITY` exportée. Retourne None si vide. Nouveau module `picarones/report/taxonomy_comparison_render.py` : `build_taxonomy_comparison_html` produit titre + note + diagramme miroir SVG + tableau résumé par catégorie. `_build_mirror_chart_svg` server-side : ligne par classe, barres horizontales A à gauche / B à droite, étiquette au centre, %, couleur selon récupérabilité (vert/orange/rouge), échelle normalisée. `_build_recoverability_summary_html` : tableau 3×2 avec pastilles colorées. Adaptive : "" si None ou pas de classes. +6 clés i18n FR/EN. +18 tests (calcul 7 cas dont sanité RECOVERABILITY couvre ERROR_CLASSES, rendu 7 cas, anti-injection, i18n). **Choix éditorial assumé** : classification recoverable/difficult/irrecoverable est un guide pragmatique, pas un verdict — note explicative dit « à CER égal, un moteur dont les erreurs sont majoritairement vertes est préférable pour une édition critique ». **A.I.4 livré bout-en-bout** (Sprints 75-77). |
@@ -297,7 +298,7 @@ au template `_narrative_summary.html` (placé entre `_header.html` et `_critical
 ## Contexte développement
 
 - **Environnement** : GitHub Codespaces (`/workspaces/Picarones`), Python 3.12
-- **Tests** : 2679 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 — projection de coût sur volume cible**)
+- **Tests** : 2699 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 — sur-normalisation lexicale couche calcul + table HTML**)
 - **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/lexical_modernization.py

@@ -0,0 +1,263 @@
+"""Détection de la sur-normalisation lexicale par les LLM/VLM —
+Sprint 80 (A.I.7).
+
+Sprint 80 — A.I.7 du plan d'évolution 2026.
+
+Pourquoi ce module
+------------------
+Le détecteur ``llm_hallucination_flag`` (Sprint 19) signale qu'un
+moteur sur-normalise (« 0,05 % »).  Mais ce score agrégé ne dit
+rien sur **quoi** corriger dans le prompt.  Ce module produit
+une **table de fréquences détaillée** :
+
++----------------------+--------------------+------+----------+
+| Forme historique GT  | Forme modernisée   | n GT | % modern |
++======================+====================+======+==========+
+| maistre              | maître             |   47 |     85 % |
+| nostre               | nostre             |   92 |      8 % |
+| veoir                | voir               |   23 |    100 % |
++----------------------+--------------------+------+----------+
+
+Lecture immédiate : *« le LLM modernise systématiquement
+maistre → maître ; pour préserver l'orthographe historique, ajouter
+au prompt "ne pas moderniser maistre, nostre, veoir" »*.
+
+Méthode
+-------
+Alignement mot-à-mot via ``difflib.SequenceMatcher``.  Chaque
+``replace`` ou ``equal`` produit une paire ``(gt_token,
+hyp_token)``.  On accumule pour chaque ``gt_token`` :
+
+- ``n_total`` : nombre d'occurrences du token dans la GT
+- ``n_modernized`` : nombre d'occurrences où ``hyp_token != gt_token``
+- ``variants`` : dict des hyp_tokens observés avec leur count
+
+Stop-list
+---------
+L'utilisateur peut passer ``stop_list`` (ensemble de tokens GT à
+ignorer).  Par défaut, vide — le module ne tente pas de deviner ce
+qui est « moderne » ou « historique », c'est au chercheur de
+fournir le filtre adapté à son corpus.
+
+Sortie
+------
+``compute_lexical_modernization`` retourne une structure adaptée
+au rendu HTML.  ``aggregate_lexical_modernization`` agrège
+plusieurs documents.
+
+Limites documentées
+-------------------
+- Tokenisation au niveau mot (split sur espace) — cohérent avec
+  ``taxonomy.py`` et autres modules.  Pas de stemming ni de
+  lemmatisation.
+- La métrique mesure la **réécriture lexicale** ; elle n'attrape
+  pas les modernisations infra-mot (perte du s long ſ qui se
+  fond dans la même forme).  Pour ça, voir ``early_modern_typography``
+  (Sprint 58) et ``equivalence_profile`` (Sprint 78).
+"""
+
+from __future__ import annotations
+
+import difflib
+import logging
+from typing import Iterable, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def _split_words(text: Optional[str]) -> list[str]:
+    """Tokenisation simple par split sur whitespace."""
+    if not text:
+        return []
+    return text.split()
+
+
+def compute_lexical_modernization(
+    reference: Optional[str],
+    hypothesis: Optional[str],
+    *,
+    stop_list: Optional[Iterable[str]] = None,
+    case_sensitive: bool = False,
+) -> dict:
+    """Calcule le tableau de modernisation lexicale pour un document.
+
+    Returns
+    -------
+    dict
+        ``{
+            "n_gt_tokens": int,
+            "tokens": {
+                gt_token: {
+                    "n_total": int,
+                    "n_modernized": int,
+                    "rate_modernized": float,  # ∈ [0, 1]
+                    "variants": {hyp_token: count, ...},
+                },
+                ...
+            },
+        }``
+        Si ``reference`` est vide → ``tokens == {}``.
+    """
+    ref_tokens = _split_words(reference)
+    hyp_tokens = _split_words(hypothesis)
+    if not ref_tokens:
+        return {"n_gt_tokens": 0, "tokens": {}}
+
+    if not case_sensitive:
+        ref_for_match = [t.lower() for t in ref_tokens]
+        hyp_for_match = [t.lower() for t in hyp_tokens]
+    else:
+        ref_for_match = ref_tokens
+        hyp_for_match = hyp_tokens
+
+    stop = frozenset(
+        (t.lower() if not case_sensitive else t)
+        for t in (stop_list or [])
+    )
+
+    # On accumule par gt_token (forme display = forme originale,
+    # match key = forme casée selon ``case_sensitive``).
+    tokens_data: dict[str, dict] = {}
+
+    matcher = difflib.SequenceMatcher(
+        None, ref_for_match, hyp_for_match, autojunk=False,
+    )
+    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+        if tag == "equal":
+            for k in range(i2 - i1):
+                gt_orig = ref_tokens[i1 + k]
+                gt_match = ref_for_match[i1 + k]
+                if gt_match in stop:
+                    continue
+                slot = tokens_data.setdefault(
+                    gt_orig,
+                    {"n_total": 0, "n_modernized": 0, "variants": {}},
+                )
+                slot["n_total"] += 1
+        elif tag == "replace":
+            # Apparier 1-à-1 quand possible
+            paired = min(i2 - i1, j2 - j1)
+            for k in range(paired):
+                gt_orig = ref_tokens[i1 + k]
+                gt_match = ref_for_match[i1 + k]
+                if gt_match in stop:
+                    continue
+                hyp_orig = hyp_tokens[j1 + k]
+                slot = tokens_data.setdefault(
+                    gt_orig,
+                    {"n_total": 0, "n_modernized": 0, "variants": {}},
+                )
+                slot["n_total"] += 1
+                slot["n_modernized"] += 1
+                slot["variants"][hyp_orig] = slot["variants"].get(hyp_orig, 0) + 1
+            # Si plus de gt que de hyp, le reste des gt_tokens est
+            # « perdu » — on les compte comme totaux mais pas comme
+            # modernisés (on ne sait pas en quoi).
+            for k in range(paired, i2 - i1):
+                gt_orig = ref_tokens[i1 + k]
+                gt_match = ref_for_match[i1 + k]
+                if gt_match in stop:
+                    continue
+                slot = tokens_data.setdefault(
+                    gt_orig,
+                    {"n_total": 0, "n_modernized": 0, "variants": {}},
+                )
+                slot["n_total"] += 1
+                slot["n_modernized"] += 1
+                slot["variants"]["∅"] = slot["variants"].get("∅", 0) + 1
+        elif tag == "delete":
+            # gt présent, pas en hyp → modernisation par
+            # suppression (ou perte pure)
+            for k in range(i2 - i1):
+                gt_orig = ref_tokens[i1 + k]
+                gt_match = ref_for_match[i1 + k]
+                if gt_match in stop:
+                    continue
+                slot = tokens_data.setdefault(
+                    gt_orig,
+                    {"n_total": 0, "n_modernized": 0, "variants": {}},
+                )
+                slot["n_total"] += 1
+                slot["n_modernized"] += 1
+                slot["variants"]["∅"] = slot["variants"].get("∅", 0) + 1
+
+    # Calcul du taux par token
+    for slot in tokens_data.values():
+        total = slot["n_total"]
+        slot["rate_modernized"] = (
+            slot["n_modernized"] / total if total > 0 else 0.0
+        )
+
+    return {
+        "n_gt_tokens": len(ref_tokens),
+        "tokens": tokens_data,
+    }
+
+
+def aggregate_lexical_modernization(
+    per_doc_results: Iterable[dict],
+) -> dict:
+    """Agrège des ``compute_lexical_modernization`` per-doc.
+
+    Renvoie la structure agrégée corpus-wide avec la même forme
+    que ``compute_lexical_modernization``.
+    """
+    agg_tokens: dict[str, dict] = {}
+    n_gt_total = 0
+    for doc_result in per_doc_results:
+        if not doc_result:
+            continue
+        n_gt_total += doc_result.get("n_gt_tokens", 0)
+        for gt, data in (doc_result.get("tokens") or {}).items():
+            slot = agg_tokens.setdefault(
+                gt, {"n_total": 0, "n_modernized": 0, "variants": {}},
+            )
+            slot["n_total"] += data.get("n_total", 0)
+            slot["n_modernized"] += data.get("n_modernized", 0)
+            for hyp_t, count in (data.get("variants") or {}).items():
+                slot["variants"][hyp_t] = slot["variants"].get(hyp_t, 0) + count
+
+    for slot in agg_tokens.values():
+        total = slot["n_total"]
+        slot["rate_modernized"] = (
+            slot["n_modernized"] / total if total > 0 else 0.0
+        )
+    return {
+        "n_gt_tokens": n_gt_total,
+        "tokens": agg_tokens,
+    }
+
+
+def top_modernized_tokens(
+    data: dict,
+    *,
+    n: int = 20,
+    min_total: int = 1,
+) -> list[tuple[str, dict]]:
+    """Top-N tokens GT par taux de modernisation.
+
+    Filtre les tokens dont ``n_total < min_total`` (anecdotiques).
+    Tri par ``rate_modernized`` décroissant, tie-break par
+    ``n_total`` décroissant.
+    """
+    tokens = data.get("tokens") or {}
+    candidates = [
+        (gt, slot) for gt, slot in tokens.items()
+        if slot.get("n_total", 0) >= min_total
+        and slot.get("n_modernized", 0) > 0
+    ]
+    candidates.sort(
+        key=lambda pair: (
+            -pair[1].get("rate_modernized", 0.0),
+            -pair[1].get("n_total", 0),
+            pair[0],
+        ),
+    )
+    return candidates[:n]
+
+
+__all__ = [
+    "compute_lexical_modernization",
+    "aggregate_lexical_modernization",
+    "top_modernized_tokens",
+]

picarones/report/i18n/en.json

@@ -256,5 +256,11 @@
   "taxocomp_level_label": "Category",
   "taxocomp_recoverable": "Recoverable",
   "taxocomp_difficult": "Difficult",
-  "taxocomp_irrecoverable": "Irrecoverable"
+  "taxocomp_irrecoverable": "Irrecoverable",
+  "lexmod_title": "Lexical modernization (top tokens)",
+  "lexmod_note": "GT tokens that the engine rewrites most often. Reading: « maistre → maître modernized in 85 % of cases » tells you what to fix in the prompt to preserve historical spelling.",
+  "lexmod_gt_label": "Historical GT form",
+  "lexmod_hyp_label": "OCR variants",
+  "lexmod_n_label": "n GT",
+  "lexmod_rate_label": "% modernized"
 }

picarones/report/i18n/fr.json

@@ -256,5 +256,11 @@
   "taxocomp_level_label": "Catégorie",
   "taxocomp_recoverable": "Récupérable",
   "taxocomp_difficult": "Difficile",
-  "taxocomp_irrecoverable": "Irrécupérable"
+  "taxocomp_irrecoverable": "Irrécupérable",
+  "lexmod_title": "Modernisation lexicale (top tokens)",
+  "lexmod_note": "Tokens GT que le moteur réécrit le plus souvent. Lecture : « maistre → maître modernisé dans 85 % des cas » indique de quoi corriger dans le prompt pour préserver l'orthographe historique.",
+  "lexmod_gt_label": "Forme historique GT",
+  "lexmod_hyp_label": "Variantes OCR",
+  "lexmod_n_label": "n GT",
+  "lexmod_rate_label": "% modernisé"
 }

picarones/report/lexical_modernization_render.py

@@ -0,0 +1,119 @@
+"""Rendu HTML de la vue « Modernisation lexicale » — Sprint 80.
+
+A.I.7 du plan d'évolution 2026.
+
+Suite directe ``picarones/core/lexical_modernization.py``.
+Pattern identique aux autres rendus (Sprints 41/43/62/67/72/74/75/76/77) :
+**server-side**, pas de JavaScript, anti-injection systématique.
+
+Vue
+---
+Tableau trié par taux de modernisation décroissant : forme
+historique GT → forme(s) modernisée(s), occurrences GT, %.
+Couleur de cellule pour le %.
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+from picarones.core.lexical_modernization import top_modernized_tokens
+
+
+def _color_for_rate(rate: float) -> str:
+    """Gradient blanc → orange profond pour rate ∈ [0, 1]."""
+    f = max(0.0, min(1.0, rate))
+    r = int(255 + (194 - 255) * f)
+    g = int(255 + (65 - 255) * f)
+    b = int(255 + (12 - 255) * f)
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+def _format_variants(variants: dict, max_show: int = 3) -> str:
+    """Liste compacte des variants modernisés."""
+    items = sorted(variants.items(), key=lambda kv: -kv[1])
+    shown = items[:max_show]
+    rest = len(items) - max_show
+    parts = [
+        f"{_e(form)} ({count})"
+        for form, count in shown
+    ]
+    if rest > 0:
+        parts.append(f"+{rest}")
+    return ", ".join(parts)
+
+
+def build_lexical_modernization_html(
+    data: Optional[dict],
+    labels: Optional[dict[str, str]] = None,
+    *,
+    top_n: int = 20,
+    min_total: int = 1,
+) -> str:
+    """Construit la table HTML de modernisation lexicale.
+
+    Retourne ``""`` si ``data is None`` ou si aucun token modernisé.
+    """
+    if not data:
+        return ""
+    rows = top_modernized_tokens(data, n=top_n, min_total=min_total)
+    if not rows:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "lexmod_title", "Modernisation lexicale (top tokens)",
+    )
+    note = labels.get(
+        "lexmod_note",
+        "Tokens GT que le moteur réécrit le plus souvent. "
+        "Lecture : « maistre → maître modernisé dans 85 % des cas » "
+        "indique de quoi corriger dans le prompt pour préserver "
+        "l'orthographe historique.",
+    )
+    gt_label = labels.get("lexmod_gt_label", "Forme historique GT")
+    hyp_label = labels.get("lexmod_hyp_label", "Variantes OCR")
+    n_label = labels.get("lexmod_n_label", "n GT")
+    rate_label = labels.get("lexmod_rate_label", "% modernisé")
+
+    parts = [
+        '<div class="lexmod" style="margin:1rem 0">',
+        f'<div style="font-weight:600;margin-bottom:.4rem">{_e(title)}</div>',
+        f'<div style="font-size:.85rem;opacity:.75;margin-bottom:.5rem">'
+        f'{_e(note)}</div>',
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.85rem">',
+        '<thead><tr>',
+    ]
+    for col in (gt_label, hyp_label, n_label, rate_label):
+        parts.append(
+            f'<th style="padding:.3rem .5rem;text-align:left;'
+            f'border-bottom:1px solid #ccc;font-weight:600">'
+            f'{_e(col)}</th>'
+        )
+    parts.append("</tr></thead><tbody>")
+    for gt_token, slot in rows:
+        rate = slot.get("rate_modernized", 0.0)
+        n_total = slot.get("n_total", 0)
+        variants_str = _format_variants(slot.get("variants") or {})
+        rate_color = _color_for_rate(rate)
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.3rem .5rem;font-family:monospace">'
+            f'{_e(gt_token)}</td>'
+            f'<td style="padding:.3rem .5rem;font-size:.85rem">'
+            f'{variants_str}</td>'
+            f'<td style="padding:.3rem .5rem;text-align:right;'
+            f'font-family:monospace">{n_total}</td>'
+            f'<td style="padding:.3rem .5rem;text-align:right;'
+            f'background:{rate_color};font-family:monospace">'
+            f'{rate * 100:.0f}%</td>'
+            f'</tr>'
+        )
+    parts.append("</tbody></table></div>")
+    return "".join(parts)
+
+
+__all__ = [
+    "build_lexical_modernization_html",
+]

tests/test_sprint80_lexical_modernization.py

@@ -0,0 +1,242 @@
+"""Tests Sprint 80 — A.I.7 : sur-normalisation lexicale.
+
+Couvre :
+
+1. ``compute_lexical_modernization`` :
+   - Token GT modernisé systématiquement → 100 %
+   - Token GT préservé → 0 %
+   - Plusieurs variantes hyp pour un même gt
+   - Stop-list filtre les tokens
+   - Casse insensible par défaut
+   - Token GT supprimé (lacuna) → modernisé vers ∅
+   - GT vide → tokens vide
+2. ``aggregate_lexical_modernization`` :
+   - Somme correcte sur N docs
+3. ``top_modernized_tokens`` :
+   - Tri décroissant par rate
+   - ``min_total`` filtre les anecdotiques
+   - Tokens à 0 % exclus
+4. Rendu HTML :
+   - Tableau, ``""`` si data None ou aucun modernisé
+   - Anti-injection
+5. Complétude i18n FR/EN.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from picarones.core.lexical_modernization import (
+    aggregate_lexical_modernization,
+    compute_lexical_modernization,
+    top_modernized_tokens,
+)
+from picarones.report.lexical_modernization_render import (
+    build_lexical_modernization_html,
+)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 1. compute_lexical_modernization
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestCompute:
+    def test_systematic_modernization(self) -> None:
+        gt = "maistre maistre maistre"
+        hyp = "maître maître maître"
+        result = compute_lexical_modernization(gt, hyp)
+        slot = result["tokens"]["maistre"]
+        assert slot["n_total"] == 3
+        assert slot["n_modernized"] == 3
+        assert slot["rate_modernized"] == 1.0
+        assert slot["variants"] == {"maître": 3}
+
+    def test_preserved_token(self) -> None:
+        gt = "nostre nostre"
+        hyp = "nostre nostre"
+        result = compute_lexical_modernization(gt, hyp)
+        slot = result["tokens"]["nostre"]
+        assert slot["n_total"] == 2
+        assert slot["n_modernized"] == 0
+        assert slot["rate_modernized"] == 0.0
+
+    def test_partial_modernization(self) -> None:
+        gt = "maistre maistre maistre maistre"
+        hyp = "maître maistre maître maître"
+        result = compute_lexical_modernization(gt, hyp)
+        slot = result["tokens"]["maistre"]
+        assert slot["n_total"] == 4
+        assert slot["n_modernized"] == 3
+        assert slot["rate_modernized"] == 0.75
+
+    def test_multiple_variants(self) -> None:
+        gt = "veoir veoir veoir"
+        hyp = "voir voyr voir"
+        result = compute_lexical_modernization(gt, hyp)
+        slot = result["tokens"]["veoir"]
+        assert slot["n_total"] == 3
+        assert slot["n_modernized"] == 3
+        assert slot["variants"] == {"voir": 2, "voyr": 1}
+
+    def test_stop_list_filter(self) -> None:
+        gt = "maistre le veoir"
+        hyp = "maître la voir"
+        result = compute_lexical_modernization(
+            gt, hyp, stop_list=["le"],
+        )
+        # « le » filtré, mais maistre et veoir présents
+        assert "le" not in result["tokens"]
+        assert "maistre" in result["tokens"]
+        assert "veoir" in result["tokens"]
+
+    def test_case_insensitive_default(self) -> None:
+        gt = "Maistre maistre"
+        hyp = "Maître maître"
+        result = compute_lexical_modernization(gt, hyp)
+        # Les deux formes sont distinctes en sortie display mais
+        # appariées correctement en match
+        assert result["tokens"]["Maistre"]["n_modernized"] == 1
+        assert result["tokens"]["maistre"]["n_modernized"] == 1
+
+    def test_deletion_counted_as_modernized(self) -> None:
+        gt = "maistre veoir"
+        hyp = "maître"  # veoir manque
+        result = compute_lexical_modernization(gt, hyp)
+        # veoir → ∅ compté comme modernisé
+        slot = result["tokens"]["veoir"]
+        assert slot["n_modernized"] == 1
+        assert "∅" in slot["variants"]
+
+    def test_empty_gt(self) -> None:
+        result = compute_lexical_modernization("", "anything")
+        assert result["tokens"] == {}
+        assert result["n_gt_tokens"] == 0
+
+    def test_none_inputs(self) -> None:
+        result = compute_lexical_modernization(None, None)
+        assert result["tokens"] == {}
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 2. aggregate
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestAggregate:
+    def test_sum_across_docs(self) -> None:
+        d1 = compute_lexical_modernization(
+            "maistre maistre", "maître maître",
+        )
+        d2 = compute_lexical_modernization(
+            "maistre", "maître",
+        )
+        agg = aggregate_lexical_modernization([d1, d2])
+        assert agg["tokens"]["maistre"]["n_total"] == 3
+        assert agg["tokens"]["maistre"]["n_modernized"] == 3
+        assert agg["tokens"]["maistre"]["rate_modernized"] == 1.0
+
+    def test_empty_iterable(self) -> None:
+        agg = aggregate_lexical_modernization([])
+        assert agg["tokens"] == {}
+        assert agg["n_gt_tokens"] == 0
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 3. top_modernized_tokens
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestTop:
+    def test_sorted_by_rate_desc(self) -> None:
+        gt = "a a b b c c d d"
+        hyp = "x x y b z c d d"
+        # a: 100% (2/2 modernisé), b: 50%, c: 50%, d: 0%
+        result = compute_lexical_modernization(gt, hyp)
+        top = top_modernized_tokens(result, n=10)
+        # a en premier
+        assert top[0][0] == "a"
+        # d exclu (0%)
+        names = [t[0] for t in top]
+        assert "d" not in names
+
+    def test_min_total_filter(self) -> None:
+        gt = "rare maistre maistre maistre"
+        hyp = "moderne maître maître maître"
+        result = compute_lexical_modernization(gt, hyp)
+        # Avec min_total=2 : rare (1) exclu, maistre (3) conservé
+        top = top_modernized_tokens(result, min_total=2)
+        names = [t[0] for t in top]
+        assert "rare" not in names
+        assert "maistre" in names
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 4. Rendu HTML
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestRender:
+    def test_returns_empty_when_none(self) -> None:
+        assert build_lexical_modernization_html(None) == ""
+
+    def test_returns_empty_when_no_modernizations(self) -> None:
+        result = compute_lexical_modernization("a b c", "a b c")
+        # Aucun modernisé
+        assert build_lexical_modernization_html(result) == ""
+
+    def test_renders_table(self) -> None:
+        result = compute_lexical_modernization(
+            "maistre veoir", "maître voir",
+        )
+        html = build_lexical_modernization_html(result)
+        assert "<table" in html
+        assert "maistre" in html
+        assert "maître" in html
+
+    def test_rate_displayed_as_percent(self) -> None:
+        result = compute_lexical_modernization(
+            "maistre maistre maistre maistre",
+            "maître maistre maître maître",
+        )
+        html = build_lexical_modernization_html(result)
+        # 75% présent
+        assert "75%" in html
+
+    def test_anti_injection_token(self) -> None:
+        gt = "<script>alert(1)</script> normal"
+        hyp = "MODERNIZED normal"
+        result = compute_lexical_modernization(gt, hyp)
+        html = build_lexical_modernization_html(result)
+        assert "<script>alert" not in html
+        assert "&lt;script&gt;" in html
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 5. Complétude i18n
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestI18nCompleteness:
+    def _load(self, lang: str) -> dict:
+        path = (
+            Path(__file__).parent.parent
+            / "picarones" / "report" / "i18n" / f"{lang}.json"
+        )
+        return json.loads(path.read_text(encoding="utf-8"))
+
+    def test_all_keys_fr(self) -> None:
+        d = self._load("fr")
+        for key in (
+            "lexmod_title", "lexmod_note", "lexmod_gt_label",
+            "lexmod_hyp_label", "lexmod_n_label", "lexmod_rate_label",
+        ):
+            assert key in d, f"manque clé FR : {key}"
+
+    def test_all_keys_en(self) -> None:
+        d_fr = self._load("fr")
+        d_en = self._load("en")
+        for key in d_fr:
+            if key.startswith("lexmod_"):
+                assert key in d_en, f"manque clé EN : {key}"