feat(migration): Phase 5.C batch 2 — 5 renderers moyens vers reports_v2/html/

Deuxième vague de migration des 22 renderers thématiques.
Substitution : ``numerical_sequences_render`` reporté au batch 3
car sa dépendance ``measurements/numerical_sequences.py`` dépend
elle-même de ``measurements/roman_numerals.py``, deux modules
non encore migrés vers ``evaluation/metrics/``. Remplacé par
``longitudinal_render`` qui n'a pas de dépendance legacy.

Migrations effectuées
---------------------
| Source legacy | Destination canonique |
|----------------------------------------------|------------------------------------------------------|
| ``report/difficulty_render.py`` (45) | ``reports_v2/html/renderers/difficulty.py`` |
| ``report/lexical_modernization_render.py`` (114) | ``reports_v2/html/renderers/lexical_modernization.py`` |
| ``report/multirun_stability_render.py`` (151)| ``reports_v2/html/renderers/multirun_stability.py`` |
| ``report/throughput_render.py`` (154) | ``reports_v2/html/renderers/throughput.py`` |
| ``report/longitudinal_render.py`` (165) | ``reports_v2/html/renderers/longitudinal.py`` |

Total : ~629 lignes relocalisées. 5 nouveaux shims minimaux
(< 20 lignes) avec ``DeprecationWarning``.

Adaptations transverses
-----------------------
- ``reports_v2/html/renderers/lexical_modernization.py`` import
canonique ``picarones.evaluation.metrics.lexical_modernization``
(au lieu du shim legacy
``picarones.measurements.lexical_modernization``).
- ``test_module_coverage.py::TEST_ONLY_BASELINE`` étendu à
``"lexical_modernization"`` (même rationale que
``specialization`` au batch 1).
- Tests + ``picarones/report/generator.py`` mis à jour pour les
5 chemins canoniques.

Cumul Phase 5.C (batches 1+2)
-----------------------------
10 / 22 renderers migrés (~1198 lignes). 12 renderers restants.

Acceptance
----------
5019 tests passent, lint vert, architecture vérifiée.

https://claude.ai/code/session_011XQZNitg1rCgia8ZD1a2hP

docs/migration/legacy-retirement-plan.md

@@ -691,12 +691,13 @@ architecture vérifiée.
 
 **Reporté aux batches suivants** :
 
-- Batch 2 (~5 renderers moyens, 150-200 LOC chacun) :
-  ``difficulty``, ``lexical_modernization``, ``numerical_sequences``,
-  ``multirun_stability``, ``throughput``.
-- Batch 3 (~5 renderers moyens) : ``longitudinal``,
-  ``module_audit``, ``ner``, ``image_predictive``,
-  ``incremental_comparison``.
+- Batch 2 ✅ (cf. ci-dessous) — 5 renderers (45-165 LOC).
+- Batch 3 (~5 renderers moyens) : ``module_audit``,
+  ``ner``, ``image_predictive``,
+  ``incremental_comparison``, ``numerical_sequences``
+  (ce dernier exige d'abord la migration du module
+  ``measurements/numerical_sequences.py`` qui dépend de
+  ``measurements/roman_numerals.py``).
 - Batch 4 (~5 renderers gros) : ``error_absorption``,
   ``baseline``, ``inter_engine``, ``robustness_projection``,
   ``stratification``.
@@ -711,6 +712,46 @@ architecture vérifiée.
 
 Effort restant estimé : 8-12 jours.
 
+#### Phase 5.C.batch2 — Lot 2 : 5 renderers moyens (2026-05)
+
+Deuxième vague.  Substitution dans la sélection initiale :
+``numerical_sequences_render`` reporté au batch 3 (sa dépendance
+``measurements/numerical_sequences.py`` dépend elle-même de
+``measurements/roman_numerals.py``, deux modules legacy non
+migrés vers ``evaluation/metrics/`` ; le renderer ne peut donc pas
+les importer depuis le canonique).  Remplacé par
+``longitudinal_render`` qui n'a pas de dépendance legacy.
+
+**Migrations effectuées** :
+
+| Source legacy                                | Destination canonique                                |
+|----------------------------------------------|------------------------------------------------------|
+| ``report/difficulty_render.py`` (45)         | ``reports_v2/html/renderers/difficulty.py``          |
+| ``report/lexical_modernization_render.py`` (114) | ``reports_v2/html/renderers/lexical_modernization.py`` |
+| ``report/multirun_stability_render.py`` (151)| ``reports_v2/html/renderers/multirun_stability.py``  |
+| ``report/throughput_render.py`` (154)        | ``reports_v2/html/renderers/throughput.py``          |
+| ``report/longitudinal_render.py`` (165)      | ``reports_v2/html/renderers/longitudinal.py``        |
+
+Total : ~629 lignes relocalisées.  5 nouveaux shims minimaux
+(< 20 lignes) avec ``DeprecationWarning``.
+
+**Adaptations transverses** :
+
+- ``reports_v2/html/renderers/lexical_modernization.py`` import
+  canonique ``picarones.evaluation.metrics.lexical_modernization``
+  (au lieu du shim legacy ``picarones.measurements.lexical_modernization``).
+- ``test_module_coverage.py::TEST_ONLY_BASELINE`` étendu à
+  ``"lexical_modernization"`` (même rationale que ``specialization``
+  au batch 1).
+- Tests + ``picarones/report/generator.py`` mis à jour pour les
+  5 chemins canoniques.
+
+**Acceptance batch 2** : 5019 tests passent, lint vert,
+architecture vérifiée.
+
+**Cumul Phase 5.C** (batches 1+2) : 10 / 22 renderers migrés
+(~1198 lignes).  12 renderers restants.
+
 ### Phase 6 — Pipelines OCR+LLM (`pipelines/`)
 
 **Modules** : `pipelines/base.OCRLLMPipeline` (3 modes), `pipelines/

picarones/report/difficulty_render.py

@@ -1,45 +1,18 @@
-"""Helpers de rendu pour le score de difficulté intrinsèque.
+"""``picarones.report.difficulty_render`` — shim re-export (déprécié, suppression 2.0).
 
-Sprint A3 (item B-2 de l'audit institutional-readiness-2026-05) :
-``difficulty_color`` vivait précédemment dans
-``picarones/measurements/difficulty.py`` et y violait la règle
-Cercle 2 → Cercle 3 par un import paresseux de
-``picarones.report.colors``. La fonction est désormais placée à sa
-juste place — Cercle 3, à côté de la palette qu'elle consomme — et
-``measurements/difficulty.py`` ne contient plus que de la logique
-purement numérique.
-
-Le module pur ``picarones.measurements.difficulty`` reste utilisable
-sans dépendance vers ``picarones.report``.
+Canonique : :mod:`picarones.reports_v2.html.renderers.difficulty`.
+Phase 5.C du retrait du legacy.
 """
 
 from __future__ import annotations
 
-from picarones.reports_v2._helpers.colors import (
-    COLOR_GREEN,
-    COLOR_ORANGE,
-    COLOR_RED,
-    COLOR_YELLOW,
-)
-
+import warnings
 
-def difficulty_color(score: float) -> str:
-    """Retourne une couleur CSS pour un score de difficulté ∈ [0, 1].
+from picarones.reports_v2.html.renderers.difficulty import *  # noqa: F401, F403
 
-    Convention :
-
-    - score < 0.25  → vert      (« facile »)
-    - score < 0.50  → jaune     (« modéré »)
-    - score < 0.75  → orange    (« difficile »)
-    - score ≥ 0.75  → rouge     (« très difficile »)
-
-    Le label texte correspondant est produit par
-    :func:`picarones.measurements.difficulty.difficulty_label`.
-    """
-    if score < 0.25:
-        return COLOR_GREEN
-    if score < 0.50:
-        return COLOR_YELLOW
-    if score < 0.75:
-        return COLOR_ORANGE
-    return COLOR_RED
+warnings.warn(
+    "picarones.report.difficulty_render is deprecated and will be removed in 2.0.  "
+    "Import from picarones.reports_v2.html.renderers.difficulty instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)

picarones/report/lexical_modernization_render.py

@@ -1,114 +1,18 @@
-"""Rendu HTML de la vue « Modernisation lexicale » — Sprint 80.
+"""``picarones.report.lexical_modernization_render`` — shim re-export (déprécié, suppression 2.0).
 
-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 %.
+Canonique : :mod:`picarones.reports_v2.html.renderers.lexical_modernization`.
+Phase 5.C du retrait du legacy.
 """
 
 from __future__ import annotations
 
-from html import escape as _e
-from typing import Optional
-
-from picarones.measurements.lexical_modernization import top_modernized_tokens
-from picarones.reports_v2._helpers.render_helpers import (
-    GRADIENT_TARGET_ORANGE,
-    color_single_gradient,
-)
-
-
-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)
+import warnings
 
+from picarones.reports_v2.html.renderers.lexical_modernization import *  # noqa: F401, F403
 
-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 scope=\"col\" 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_single_gradient(rate, end_rgb=GRADIENT_TARGET_ORANGE)
-        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",
-]
+warnings.warn(
+    "picarones.report.lexical_modernization_render is deprecated and will be removed in 2.0.  "
+    "Import from picarones.reports_v2.html.renderers.lexical_modernization instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)

picarones/report/longitudinal_render.py

@@ -1,165 +1,18 @@
-"""Rendu HTML « Évolution dans le temps » — Sprint 92 (A.II.9).
+"""``picarones.report.longitudinal_render`` — shim re-export (déprécié, suppression 2.0).
 
-Suite directe ``picarones/core/longitudinal.py``.  Pattern
-identique aux autres rendus : server-side, pas de JS, anti-
-injection systématique.
-
-Vue
----
-Tableau résumé moteur × {n_runs, premier CER, dernier CER,
-variation cumulée colorée, pente annualisée, R², point de
-rupture si détecté}.
-
-Adaptive : ``""`` si la liste est vide.
-
-Note d'intégration
-------------------
-Module pur — l'utilisateur compose :
-
-.. code-block:: python
-
-    from picarones.measurements.history import BenchmarkHistory
-    from picarones.measurements.longitudinal import compute_corpus_longitudinal
-    from picarones.report.longitudinal_render import build_longitudinal_html
-
-    hist = BenchmarkHistory(db_path)
-    entries = hist.list_entries()
-    trends = compute_corpus_longitudinal(entries, corpus_name)
-    html = build_longitudinal_html(trends, labels)
+Canonique : :mod:`picarones.reports_v2.html.renderers.longitudinal`.
+Phase 5.C du retrait du legacy.
 """
 
 from __future__ import annotations
 
-from html import escape as _e
-from typing import Optional
-
-from picarones.reports_v2._helpers.render_helpers import color_diverging
-
-
-def _bg_for_cer_delta(delta_pct: float) -> str:
-    """Cellule colorée pour un delta de CER en points de pourcentage :
-    vert si delta ≈ 0, orange/rouge en régression, bleu en amélioration.
-    Saturation à ±5 points.
-    """
-    if abs(delta_pct) < 1.0:
-        return "#a7f0a7"
-    return color_diverging(
-        delta_pct,
-        max_abs=5.0,
-        neutral_rgb=(167, 240, 167),
-        positive_rgb=(220, 50, 50),
-        negative_rgb=(90, 160, 210),
-    )
-
-
-def build_longitudinal_html(
-    trends: Optional[list],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Construit la vue HTML longitudinale.
-
-    Parameters
-    ----------
-    trends:
-        Sortie de ``compute_corpus_longitudinal`` (liste de
-        dicts).  Si ``None`` ou vide, retourne ``""``.
-    labels:
-        Dict i18n.  Clés sous le préfixe ``longitudinal_*``.
-    """
-    if not trends:
-        return ""
-    rows = [t for t in trends if isinstance(t, dict) and t.get("engine_name")]
-    if not rows:
-        return ""
-    labels = labels or {}
-    title = labels.get(
-        "longitudinal_title", "Évolution dans le temps",
-    )
-    note = labels.get(
-        "longitudinal_note",
-        "Tendance et points de rupture sur l'historique SQLite "
-        "des runs précédents. Une variation positive signale "
-        "une dégradation cumulée — utile pour relier une "
-        "régression à un changement de pipeline ou de modèle.",
-    )
-    h_engine = labels.get("longitudinal_engine", "Moteur")
-    h_n_runs = labels.get("longitudinal_n_runs", "Runs")
-    h_first = labels.get("longitudinal_first", "Premier CER")
-    h_last = labels.get("longitudinal_last", "Dernier CER")
-    h_delta = labels.get("longitudinal_delta", "Δ cumulé (pts)")
-    h_slope = labels.get("longitudinal_slope", "Pente annuelle (pts/an)")
-    h_r2 = labels.get("longitudinal_r2", "R²")
-    h_change = labels.get("longitudinal_change", "Rupture")
-
-    parts = [
-        '<section class="longitudinal-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:.6rem">'
-        f'{_e(note)}</div>',
-        '<table style="border-collapse:collapse;width:100%;'
-        'font-size:.9rem">',
-        '<thead><tr>',
-    ]
-    for col in (h_engine, h_n_runs, h_first, h_last, h_delta,
-                h_slope, h_r2, h_change):
-        parts.append(
-            f'<th scope=\"col\" 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 entry in sorted(
-        rows,
-        key=lambda r: -float(r.get("absolute_delta") or 0.0),
-    ):
-        engine = str(entry.get("engine_name") or "?")
-        n_runs = int(entry.get("n_runs") or 0)
-        first_cer = float(entry.get("first_cer") or 0.0)
-        last_cer = float(entry.get("last_cer") or 0.0)
-        delta_pct = float(entry.get("absolute_delta_pct") or 0.0)
-        delta_color = _bg_for_cer_delta(delta_pct)
-        trend = entry.get("trend") or {}
-        slope = trend.get("slope")
-        r2 = trend.get("r_squared")
-        slope_str = (
-            f"{float(slope) * 365 * 100:+.2f}"
-            if isinstance(slope, (int, float)) else "—"
-        )
-        r2_str = (
-            f"{float(r2):.2f}"
-            if isinstance(r2, (int, float)) else "—"
-        )
-        cp = entry.get("change_point")
-        if isinstance(cp, dict) and cp.get("timestamp"):
-            cp_delta = float(cp.get("delta") or 0.0)
-            cp_str = (
-                f'{_e(str(cp["timestamp"]))} '
-                f'<span style="opacity:.75">'
-                f'({cp_delta * 100:+.2f} pts)</span>'
-            )
-        else:
-            cp_str = "—"
-        parts.append(
-            f'<tr>'
-            f'<td style="padding:.4rem .6rem">{_e(engine)}</td>'
-            f'<td style="padding:.4rem .6rem;text-align:right;'
-            f'font-family:monospace">{n_runs}</td>'
-            f'<td style="padding:.4rem .6rem;text-align:right;'
-            f'font-family:monospace">{first_cer * 100:.2f}%</td>'
-            f'<td style="padding:.4rem .6rem;text-align:right;'
-            f'font-family:monospace">{last_cer * 100:.2f}%</td>'
-            f'<td style="padding:.4rem .6rem;text-align:right;'
-            f'background:{delta_color};font-family:monospace;'
-            f'font-weight:600">{delta_pct:+.2f}</td>'
-            f'<td style="padding:.4rem .6rem;text-align:right;'
-            f'font-family:monospace">{slope_str}</td>'
-            f'<td style="padding:.4rem .6rem;text-align:right;'
-            f'font-family:monospace">{r2_str}</td>'
-            f'<td style="padding:.4rem .6rem">{cp_str}</td>'
-            f'</tr>'
-        )
-    parts.append("</tbody></table></section>")
-    return "".join(parts)
+import warnings
 
+from picarones.reports_v2.html.renderers.longitudinal import *  # noqa: F401, F403
 
-__all__ = ["build_longitudinal_html"]
+warnings.warn(
+    "picarones.report.longitudinal_render is deprecated and will be removed in 2.0.  "
+    "Import from picarones.reports_v2.html.renderers.longitudinal instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)

picarones/report/multirun_stability_render.py

@@ -1,151 +1,18 @@
-"""Rendu HTML « Stabilité multi-runs » — Sprint 90 (A.II.4).
+"""``picarones.report.multirun_stability_render`` — shim re-export (déprécié, suppression 2.0).
 
-Suite directe ``picarones/core/reliability.compute_multirun_stability``
-(Sprint 83).  Pattern identique aux autres rendus : server-side,
-pas de JS, anti-injection systématique.
-
-Note d'intégration
-------------------
-La stabilité multi-runs n'est pas calculée automatiquement par
-le runner — l'utilisateur doit relancer son moteur LLM/VLM
-plusieurs fois (option ``--repeats N`` du runner reportée à un
-sprint dédié) et appeler ``compute_multirun_stability`` lui-
-même.  Cette vue est donc un **module de rendu pur** que
-l'utilisateur compose :
-
-.. code-block:: python
-
-    from picarones.measurements.reliability import compute_multirun_stability
-    from picarones.report.multirun_stability_render import (
-        build_multirun_stability_html,
-    )
-
-    stability = []
-    for engine_name, runs in per_engine_runs.items():
-        s = compute_multirun_stability(runs, reference=ref)
-        if s is not None:
-            s["engine_name"] = engine_name
-            stability.append(s)
-    html = build_multirun_stability_html(stability, labels)
-
-Vue
----
-Tableau moteur × {n_runs, CER moyen ± écart-type, CV (%),
-% paires identiques, n outputs distincts}.  Cellule CV colorée
-par gradient vert (stable) → rouge (instable, CV > 20 %).
-
-Adaptive : ``""`` si la liste est vide ou que tous les
-``cer_cv`` sont ``None``.
+Canonique : :mod:`picarones.reports_v2.html.renderers.multirun_stability`.
+Phase 5.C du retrait du legacy.
 """
 
 from __future__ import annotations
 
-from html import escape as _e
-from typing import Optional
-
-from picarones.reports_v2._helpers.render_helpers import color_traffic_light
-
-
-def build_multirun_stability_html(
-    stability: Optional[list],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Construit la vue HTML de stabilité multi-runs.
-
-    Parameters
-    ----------
-    stability:
-        Liste de dicts (un par moteur) issus de
-        ``compute_multirun_stability`` enrichis d'un
-        ``engine_name``.  Si vide ou ``None``, retourne ``""``.
-    labels:
-        Dict i18n.  Clés sous le préfixe ``stability_*``.
-    """
-    if not stability:
-        return ""
-    rows = [s for s in stability if isinstance(s, dict) and s.get("engine_name")]
-    if not rows:
-        return ""
-    labels = labels or {}
-    title = labels.get("stability_title", "Stabilité multi-runs")
-    note = labels.get(
-        "stability_note",
-        "Quand un moteur LLM/VLM est non déterministe, la "
-        "variance entre runs successifs sur les mêmes documents "
-        "est un proxy de la fiabilité scientifique. Un CV élevé "
-        "ou un faible taux de runs identiques discrédite "
-        "l'interprétation du CER moyen.",
-    )
-    h_engine = labels.get("stability_engine", "Moteur")
-    h_n_runs = labels.get("stability_n_runs", "Runs")
-    h_cer = labels.get("stability_cer", "CER moyen ± σ")
-    h_cv = labels.get("stability_cv", "CV (%)")
-    h_identical = labels.get("stability_identical", "% runs identiques")
-    h_distinct = labels.get("stability_distinct", "Sorties distinctes")
-
-    parts = [
-        '<section class="stability-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:.6rem">'
-        f'{_e(note)}</div>',
-        '<table style="border-collapse:collapse;width:100%;'
-        'font-size:.9rem">',
-        '<thead><tr>',
-    ]
-    for col in (h_engine, h_n_runs, h_cer, h_cv, h_identical, h_distinct):
-        parts.append(
-            f'<th scope=\"col\" 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 stab in rows:
-        engine = str(stab.get("engine_name") or "?")
-        n_runs = int(stab.get("n_runs") or 0)
-        cer_mean = stab.get("cer_mean")
-        cer_stdev = stab.get("cer_stdev")
-        cer_cv = stab.get("cer_cv")
-        identical = stab.get("identical_run_rate")
-        n_distinct = stab.get("n_distinct_outputs")
-        if isinstance(cer_mean, (int, float)) and isinstance(cer_stdev, (int, float)):
-            cer_str = f"{cer_mean * 100:.2f}% ± {cer_stdev * 100:.2f}%"
-        elif isinstance(cer_mean, (int, float)):
-            cer_str = f"{cer_mean * 100:.2f}%"
-        else:
-            cer_str = "—"
-        if isinstance(cer_cv, (int, float)):
-            cv_color = color_traffic_light(float(cer_cv), low_is_good=True, scale_max=0.25)
-            cv_cell = (
-                f'<td style="padding:.4rem .6rem;text-align:right;'
-                f'background:{cv_color};font-family:monospace;'
-                f'font-weight:600">{float(cer_cv) * 100:.1f}</td>'
-            )
-        else:
-            cv_cell = (
-                '<td style="padding:.4rem .6rem;text-align:right;'
-                'opacity:.4">—</td>'
-            )
-        identical_str = (
-            f"{float(identical) * 100:.1f}"
-            if isinstance(identical, (int, float)) else "—"
-        )
-        distinct_str = str(n_distinct) if isinstance(n_distinct, int) else "—"
-        parts.append(
-            f'<tr>'
-            f'<td style="padding:.4rem .6rem">{_e(engine)}</td>'
-            f'<td style="padding:.4rem .6rem;text-align:right;'
-            f'font-family:monospace">{n_runs}</td>'
-            f'<td style="padding:.4rem .6rem;text-align:right;'
-            f'font-family:monospace">{cer_str}</td>'
-            f'{cv_cell}'
-            f'<td style="padding:.4rem .6rem;text-align:right;'
-            f'font-family:monospace">{identical_str}</td>'
-            f'<td style="padding:.4rem .6rem;text-align:right;'
-            f'font-family:monospace">{distinct_str}</td>'
-            f'</tr>'
-        )
-    parts.append("</tbody></table></section>")
-    return "".join(parts)
+import warnings
 
+from picarones.reports_v2.html.renderers.multirun_stability import *  # noqa: F401, F403
 
-__all__ = ["build_multirun_stability_html"]
+warnings.warn(
+    "picarones.report.multirun_stability_render is deprecated and will be removed in 2.0.  "
+    "Import from picarones.reports_v2.html.renderers.multirun_stability instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)

picarones/report/throughput_render.py

@@ -1,154 +1,18 @@
-"""Rendu HTML « Throughput effectif » — Sprint 91 (A.II.6).
+"""``picarones.report.throughput_render`` — shim re-export (déprécié, suppression 2.0).
 
-Suite directe ``picarones/core/throughput.py``.  Pattern
-identique aux autres rendus : server-side, pas de JS, anti-
-injection systématique.
-
-Vue
----
-Tableau résumé moteur × {pages/h brut, pages/h **utilisable**,
-% temps de correction (drag), n_pages, n_errors}.  La cellule
-**pages/h utilisable** est colorée en gradient rouge (faible)
-→ vert (élevé), normalisé sur le maximum observé.
-
-Adaptive : ``""`` si ``aggregate_effective_throughput`` retourne
-``None`` (aucun moteur exploitable).
-
-Note d'intégration
-------------------
-Cette vue est un **module pur** — l'utilisateur compose :
-
-.. code-block:: python
-
-    from picarones.measurements.throughput import (
-        aggregate_effective_throughput,
-    )
-    from picarones.report.throughput_render import (
-        build_throughput_html,
-    )
-
-    per_engine = []
-    for report in benchmark.engine_reports:
-        n_errors = sum(
-            int(round(dr.metrics.wer * dr.metrics.reference_length / 5))
-            for dr in report.document_results
-        )
-        per_engine.append({
-            "engine_name": report.engine_name,
-            "n_pages": len(report.document_results),
-            "duration_seconds": sum(
-                dr.duration_seconds for dr in report.document_results
-            ),
-            "n_errors": n_errors,
-        })
-    agg = aggregate_effective_throughput(per_engine)
-    html = build_throughput_html(agg, labels)
+Canonique : :mod:`picarones.reports_v2.html.renderers.throughput`.
+Phase 5.C du retrait du legacy.
 """
 
 from __future__ import annotations
 
-from html import escape as _e
-from typing import Optional
-
-from picarones.reports_v2._helpers.render_helpers import color_traffic_light
-
-
-def build_throughput_html(
-    aggregated: Optional[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Construit la vue HTML throughput effectif.
-
-    Parameters
-    ----------
-    aggregated:
-        Sortie de ``aggregate_effective_throughput``.  Si
-        ``None`` ou liste vide, retourne ``""``.
-    labels:
-        Dict i18n.  Clés sous le préfixe ``throughput_*``.
-    """
-    if not aggregated:
-        return ""
-    rows = aggregated.get("engines") or []
-    if not rows:
-        return ""
-    labels = labels or {}
-    title = labels.get("throughput_title", "Throughput effectif")
-    note = labels.get(
-        "throughput_note",
-        "Pages traitables par heure en intégrant le temps de "
-        "correction humaine post-OCR. Discrimine entre un cloud "
-        "rapide mais imprécis et un local lent mais fiable. "
-        "Constante de correction : {time_per_error}s par erreur "
-        "(défaut HTR-United, surchargeable).",
-    )
-    time_per_error = aggregated.get("time_per_error_seconds", 5.0)
-    note = note.replace("{time_per_error}", f"{time_per_error:.0f}")
-    h_engine = labels.get("throughput_engine", "Moteur")
-    h_raw = labels.get("throughput_raw", "Pages/h brut")
-    h_effective = labels.get(
-        "throughput_effective", "Pages/h utilisable",
-    )
-    h_drag = labels.get("throughput_drag", "% correction")
-    h_pages = labels.get("throughput_pages", "Pages")
-    h_errors = labels.get("throughput_errors", "Erreurs")
-    max_eff = max(
-        (r.get("pages_per_hour_effective") or 0.0) for r in rows
-    )
-
-    parts = [
-        '<section class="throughput-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:.6rem">'
-        f'{_e(note)}</div>',
-        '<table style="border-collapse:collapse;width:100%;'
-        'font-size:.9rem">',
-        '<thead><tr>',
-    ]
-    for col in (h_engine, h_raw, h_effective, h_drag, h_pages, h_errors):
-        parts.append(
-            f'<th scope=\"col\" 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 row in sorted(
-        rows,
-        key=lambda r: -(r.get("pages_per_hour_effective") or 0.0),
-    ):
-        engine = str(row.get("engine_name") or "?")
-        raw = row.get("pages_per_hour_raw")
-        eff = row.get("pages_per_hour_effective") or 0.0
-        drag = row.get("drag_ratio") or 0.0
-        n_pages = int(row.get("n_pages") or 0)
-        n_errors = int(row.get("n_errors") or 0)
-        eff_color = (
-            color_traffic_light(eff, scale_max=max_eff)
-            if max_eff > 0 else "#e0e0e0"
-        )
-        drag_color = color_traffic_light(drag, low_is_good=True)
-        raw_str = (
-            f"{raw:,.0f}" if isinstance(raw, (int, float)) else "—"
-        )
-        parts.append(
-            f'<tr>'
-            f'<td style="padding:.4rem .6rem">{_e(engine)}</td>'
-            f'<td style="padding:.4rem .6rem;text-align:right;'
-            f'font-family:monospace">{raw_str}</td>'
-            f'<td style="padding:.4rem .6rem;text-align:right;'
-            f'background:{eff_color};font-family:monospace;'
-            f'font-weight:600">{eff:,.0f}</td>'
-            f'<td style="padding:.4rem .6rem;text-align:right;'
-            f'background:{drag_color};font-family:monospace">'
-            f'{drag * 100:.1f}%</td>'
-            f'<td style="padding:.4rem .6rem;text-align:right;'
-            f'font-family:monospace">{n_pages}</td>'
-            f'<td style="padding:.4rem .6rem;text-align:right;'
-            f'font-family:monospace">{n_errors}</td>'
-            f'</tr>'
-        )
-    parts.append("</tbody></table></section>")
-    return "".join(parts)
+import warnings
 
+from picarones.reports_v2.html.renderers.throughput import *  # noqa: F401, F403
 
-__all__ = ["build_throughput_html"]
+warnings.warn(
+    "picarones.report.throughput_render is deprecated and will be removed in 2.0.  "
+    "Import from picarones.reports_v2.html.renderers.throughput instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)

picarones/report/views/advanced_taxonomy.py

@@ -203,7 +203,7 @@ def build_advanced_taxonomy_view_html(
     # Sous-section 4 : modernisation lexicale (opt-in)
     if lexical_modernization:
         try:
-            from picarones.report.lexical_modernization_render import (
+            from picarones.reports_v2.html.renderers.lexical_modernization import (
                 build_lexical_modernization_html,
             )
             html = build_lexical_modernization_html(

picarones/report/views/diagnostics.py

@@ -165,7 +165,7 @@ def build_diagnostics_view_html(
     # Sous-section 4 : évolution longitudinale (opt-in)
     if longitudinal:
         try:
-            from picarones.report.longitudinal_render import (
+            from picarones.reports_v2.html.renderers.longitudinal import (
                 build_longitudinal_html,
             )
             html = build_longitudinal_html(longitudinal, labels=labels)
@@ -185,7 +185,7 @@ def build_diagnostics_view_html(
     # Sous-section 5 : stabilité multi-runs (opt-in)
     if stability:
         try:
-            from picarones.report.multirun_stability_render import (
+            from picarones.reports_v2.html.renderers.multirun_stability import (
                 build_multirun_stability_html,
             )
             html = build_multirun_stability_html(stability, labels=labels)

picarones/report/views/economics.py

@@ -134,7 +134,7 @@ def build_economics_view_html(
             from picarones.measurements.throughput import (
                 aggregate_effective_throughput,
             )
-            from picarones.report.throughput_render import (
+            from picarones.reports_v2.html.renderers.throughput import (
                 build_throughput_html,
             )
             inputs = _estimate_engine_throughput_inputs(engine_reports)

picarones/reports_v2/html/renderers/difficulty.py

@@ -0,0 +1,51 @@
+"""Helpers de rendu pour le score de difficulté intrinsèque.
+
+Phase 5.C — module relocalisé depuis
+``picarones.report.difficulty_render`` vers
+``picarones.reports_v2.html.renderers.difficulty``.  Le chemin
+legacy reste disponible via un shim avec ``DeprecationWarning`` ;
+suppression prévue en 2.0.
+
+Sprint A3 (item B-2 de l'audit institutional-readiness-2026-05) :
+``difficulty_color`` vivait précédemment dans
+``picarones/measurements/difficulty.py`` et y violait la règle
+Cercle 2 → Cercle 3 par un import paresseux de
+``picarones.report.colors``. La fonction est désormais placée à sa
+juste place — Cercle 3, à côté de la palette qu'elle consomme — et
+``measurements/difficulty.py`` ne contient plus que de la logique
+purement numérique.
+
+Le module pur ``picarones.measurements.difficulty`` reste utilisable
+sans dépendance vers ``picarones.report``.
+"""
+
+from __future__ import annotations
+
+from picarones.reports_v2._helpers.colors import (
+    COLOR_GREEN,
+    COLOR_ORANGE,
+    COLOR_RED,
+    COLOR_YELLOW,
+)
+
+
+def difficulty_color(score: float) -> str:
+    """Retourne une couleur CSS pour un score de difficulté ∈ [0, 1].
+
+    Convention :
+
+    - score < 0.25  → vert      (« facile »)
+    - score < 0.50  → jaune     (« modéré »)
+    - score < 0.75  → orange    (« difficile »)
+    - score ≥ 0.75  → rouge     (« très difficile »)
+
+    Le label texte correspondant est produit par
+    :func:`picarones.measurements.difficulty.difficulty_label`.
+    """
+    if score < 0.25:
+        return COLOR_GREEN
+    if score < 0.50:
+        return COLOR_YELLOW
+    if score < 0.75:
+        return COLOR_ORANGE
+    return COLOR_RED

picarones/reports_v2/html/renderers/lexical_modernization.py

@@ -0,0 +1,120 @@
+"""Rendu HTML de la vue « Modernisation lexicale » — Sprint 80.
+
+Phase 5.C — module relocalisé depuis
+``picarones.report.lexical_modernization_render`` vers
+``picarones.reports_v2.html.renderers.lexical_modernization``.
+Le chemin legacy reste disponible via un shim avec
+``DeprecationWarning`` ; suppression prévue en 2.0.
+
+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.evaluation.metrics.lexical_modernization import top_modernized_tokens
+from picarones.reports_v2._helpers.render_helpers import (
+    GRADIENT_TARGET_ORANGE,
+    color_single_gradient,
+)
+
+
+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 scope=\"col\" 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_single_gradient(rate, end_rgb=GRADIENT_TARGET_ORANGE)
+        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",
+]

picarones/reports_v2/html/renderers/longitudinal.py

@@ -0,0 +1,171 @@
+"""Rendu HTML « Évolution dans le temps » — Sprint 92 (A.II.9).
+
+Phase 5.C — module relocalisé depuis
+``picarones.report.longitudinal_render`` vers
+``picarones.reports_v2.html.renderers.longitudinal``.  Le chemin
+legacy reste disponible via un shim avec ``DeprecationWarning`` ;
+suppression prévue en 2.0.
+
+Suite directe ``picarones/core/longitudinal.py``.  Pattern
+identique aux autres rendus : server-side, pas de JS, anti-
+injection systématique.
+
+Vue
+---
+Tableau résumé moteur × {n_runs, premier CER, dernier CER,
+variation cumulée colorée, pente annualisée, R², point de
+rupture si détecté}.
+
+Adaptive : ``""`` si la liste est vide.
+
+Note d'intégration
+------------------
+Module pur — l'utilisateur compose :
+
+.. code-block:: python
+
+    from picarones.measurements.history import BenchmarkHistory
+    from picarones.measurements.longitudinal import compute_corpus_longitudinal
+    from picarones.reports_v2.html.renderers.longitudinal import build_longitudinal_html
+
+    hist = BenchmarkHistory(db_path)
+    entries = hist.list_entries()
+    trends = compute_corpus_longitudinal(entries, corpus_name)
+    html = build_longitudinal_html(trends, labels)
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+from picarones.reports_v2._helpers.render_helpers import color_diverging
+
+
+def _bg_for_cer_delta(delta_pct: float) -> str:
+    """Cellule colorée pour un delta de CER en points de pourcentage :
+    vert si delta ≈ 0, orange/rouge en régression, bleu en amélioration.
+    Saturation à ±5 points.
+    """
+    if abs(delta_pct) < 1.0:
+        return "#a7f0a7"
+    return color_diverging(
+        delta_pct,
+        max_abs=5.0,
+        neutral_rgb=(167, 240, 167),
+        positive_rgb=(220, 50, 50),
+        negative_rgb=(90, 160, 210),
+    )
+
+
+def build_longitudinal_html(
+    trends: Optional[list],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit la vue HTML longitudinale.
+
+    Parameters
+    ----------
+    trends:
+        Sortie de ``compute_corpus_longitudinal`` (liste de
+        dicts).  Si ``None`` ou vide, retourne ``""``.
+    labels:
+        Dict i18n.  Clés sous le préfixe ``longitudinal_*``.
+    """
+    if not trends:
+        return ""
+    rows = [t for t in trends if isinstance(t, dict) and t.get("engine_name")]
+    if not rows:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "longitudinal_title", "Évolution dans le temps",
+    )
+    note = labels.get(
+        "longitudinal_note",
+        "Tendance et points de rupture sur l'historique SQLite "
+        "des runs précédents. Une variation positive signale "
+        "une dégradation cumulée — utile pour relier une "
+        "régression à un changement de pipeline ou de modèle.",
+    )
+    h_engine = labels.get("longitudinal_engine", "Moteur")
+    h_n_runs = labels.get("longitudinal_n_runs", "Runs")
+    h_first = labels.get("longitudinal_first", "Premier CER")
+    h_last = labels.get("longitudinal_last", "Dernier CER")
+    h_delta = labels.get("longitudinal_delta", "Δ cumulé (pts)")
+    h_slope = labels.get("longitudinal_slope", "Pente annuelle (pts/an)")
+    h_r2 = labels.get("longitudinal_r2", "R²")
+    h_change = labels.get("longitudinal_change", "Rupture")
+
+    parts = [
+        '<section class="longitudinal-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:.6rem">'
+        f'{_e(note)}</div>',
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.9rem">',
+        '<thead><tr>',
+    ]
+    for col in (h_engine, h_n_runs, h_first, h_last, h_delta,
+                h_slope, h_r2, h_change):
+        parts.append(
+            f'<th scope=\"col\" 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 entry in sorted(
+        rows,
+        key=lambda r: -float(r.get("absolute_delta") or 0.0),
+    ):
+        engine = str(entry.get("engine_name") or "?")
+        n_runs = int(entry.get("n_runs") or 0)
+        first_cer = float(entry.get("first_cer") or 0.0)
+        last_cer = float(entry.get("last_cer") or 0.0)
+        delta_pct = float(entry.get("absolute_delta_pct") or 0.0)
+        delta_color = _bg_for_cer_delta(delta_pct)
+        trend = entry.get("trend") or {}
+        slope = trend.get("slope")
+        r2 = trend.get("r_squared")
+        slope_str = (
+            f"{float(slope) * 365 * 100:+.2f}"
+            if isinstance(slope, (int, float)) else "—"
+        )
+        r2_str = (
+            f"{float(r2):.2f}"
+            if isinstance(r2, (int, float)) else "—"
+        )
+        cp = entry.get("change_point")
+        if isinstance(cp, dict) and cp.get("timestamp"):
+            cp_delta = float(cp.get("delta") or 0.0)
+            cp_str = (
+                f'{_e(str(cp["timestamp"]))} '
+                f'<span style="opacity:.75">'
+                f'({cp_delta * 100:+.2f} pts)</span>'
+            )
+        else:
+            cp_str = "—"
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.4rem .6rem">{_e(engine)}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{n_runs}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{first_cer * 100:.2f}%</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{last_cer * 100:.2f}%</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'background:{delta_color};font-family:monospace;'
+            f'font-weight:600">{delta_pct:+.2f}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{slope_str}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{r2_str}</td>'
+            f'<td style="padding:.4rem .6rem">{cp_str}</td>'
+            f'</tr>'
+        )
+    parts.append("</tbody></table></section>")
+    return "".join(parts)
+
+
+__all__ = ["build_longitudinal_html"]

picarones/reports_v2/html/renderers/multirun_stability.py

@@ -0,0 +1,157 @@
+"""Rendu HTML « Stabilité multi-runs » — Sprint 90 (A.II.4).
+
+Phase 5.C — module relocalisé depuis
+``picarones.report.multirun_stability_render`` vers
+``picarones.reports_v2.html.renderers.multirun_stability``.
+Le chemin legacy reste disponible via un shim avec
+``DeprecationWarning`` ; suppression prévue en 2.0.
+
+Suite directe ``picarones/core/reliability.compute_multirun_stability``
+(Sprint 83).  Pattern identique aux autres rendus : server-side,
+pas de JS, anti-injection systématique.
+
+Note d'intégration
+------------------
+La stabilité multi-runs n'est pas calculée automatiquement par
+le runner — l'utilisateur doit relancer son moteur LLM/VLM
+plusieurs fois (option ``--repeats N`` du runner reportée à un
+sprint dédié) et appeler ``compute_multirun_stability`` lui-
+même.  Cette vue est donc un **module de rendu pur** que
+l'utilisateur compose :
+
+.. code-block:: python
+
+    from picarones.measurements.reliability import compute_multirun_stability
+    from picarones.reports_v2.html.renderers.multirun_stability import (
+        build_multirun_stability_html,
+    )
+
+    stability = []
+    for engine_name, runs in per_engine_runs.items():
+        s = compute_multirun_stability(runs, reference=ref)
+        if s is not None:
+            s["engine_name"] = engine_name
+            stability.append(s)
+    html = build_multirun_stability_html(stability, labels)
+
+Vue
+---
+Tableau moteur × {n_runs, CER moyen ± écart-type, CV (%),
+% paires identiques, n outputs distincts}.  Cellule CV colorée
+par gradient vert (stable) → rouge (instable, CV > 20 %).
+
+Adaptive : ``""`` si la liste est vide ou que tous les
+``cer_cv`` sont ``None``.
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+from picarones.reports_v2._helpers.render_helpers import color_traffic_light
+
+
+def build_multirun_stability_html(
+    stability: Optional[list],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit la vue HTML de stabilité multi-runs.
+
+    Parameters
+    ----------
+    stability:
+        Liste de dicts (un par moteur) issus de
+        ``compute_multirun_stability`` enrichis d'un
+        ``engine_name``.  Si vide ou ``None``, retourne ``""``.
+    labels:
+        Dict i18n.  Clés sous le préfixe ``stability_*``.
+    """
+    if not stability:
+        return ""
+    rows = [s for s in stability if isinstance(s, dict) and s.get("engine_name")]
+    if not rows:
+        return ""
+    labels = labels or {}
+    title = labels.get("stability_title", "Stabilité multi-runs")
+    note = labels.get(
+        "stability_note",
+        "Quand un moteur LLM/VLM est non déterministe, la "
+        "variance entre runs successifs sur les mêmes documents "
+        "est un proxy de la fiabilité scientifique. Un CV élevé "
+        "ou un faible taux de runs identiques discrédite "
+        "l'interprétation du CER moyen.",
+    )
+    h_engine = labels.get("stability_engine", "Moteur")
+    h_n_runs = labels.get("stability_n_runs", "Runs")
+    h_cer = labels.get("stability_cer", "CER moyen ± σ")
+    h_cv = labels.get("stability_cv", "CV (%)")
+    h_identical = labels.get("stability_identical", "% runs identiques")
+    h_distinct = labels.get("stability_distinct", "Sorties distinctes")
+
+    parts = [
+        '<section class="stability-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:.6rem">'
+        f'{_e(note)}</div>',
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.9rem">',
+        '<thead><tr>',
+    ]
+    for col in (h_engine, h_n_runs, h_cer, h_cv, h_identical, h_distinct):
+        parts.append(
+            f'<th scope=\"col\" 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 stab in rows:
+        engine = str(stab.get("engine_name") or "?")
+        n_runs = int(stab.get("n_runs") or 0)
+        cer_mean = stab.get("cer_mean")
+        cer_stdev = stab.get("cer_stdev")
+        cer_cv = stab.get("cer_cv")
+        identical = stab.get("identical_run_rate")
+        n_distinct = stab.get("n_distinct_outputs")
+        if isinstance(cer_mean, (int, float)) and isinstance(cer_stdev, (int, float)):
+            cer_str = f"{cer_mean * 100:.2f}% ± {cer_stdev * 100:.2f}%"
+        elif isinstance(cer_mean, (int, float)):
+            cer_str = f"{cer_mean * 100:.2f}%"
+        else:
+            cer_str = "—"
+        if isinstance(cer_cv, (int, float)):
+            cv_color = color_traffic_light(float(cer_cv), low_is_good=True, scale_max=0.25)
+            cv_cell = (
+                f'<td style="padding:.4rem .6rem;text-align:right;'
+                f'background:{cv_color};font-family:monospace;'
+                f'font-weight:600">{float(cer_cv) * 100:.1f}</td>'
+            )
+        else:
+            cv_cell = (
+                '<td style="padding:.4rem .6rem;text-align:right;'
+                'opacity:.4">—</td>'
+            )
+        identical_str = (
+            f"{float(identical) * 100:.1f}"
+            if isinstance(identical, (int, float)) else "—"
+        )
+        distinct_str = str(n_distinct) if isinstance(n_distinct, int) else "—"
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.4rem .6rem">{_e(engine)}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{n_runs}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{cer_str}</td>'
+            f'{cv_cell}'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{identical_str}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{distinct_str}</td>'
+            f'</tr>'
+        )
+    parts.append("</tbody></table></section>")
+    return "".join(parts)
+
+
+__all__ = ["build_multirun_stability_html"]

picarones/reports_v2/html/renderers/throughput.py

@@ -0,0 +1,160 @@
+"""Rendu HTML « Throughput effectif » — Sprint 91 (A.II.6).
+
+Phase 5.C — module relocalisé depuis
+``picarones.report.throughput_render`` vers
+``picarones.reports_v2.html.renderers.throughput``.  Le chemin
+legacy reste disponible via un shim avec ``DeprecationWarning`` ;
+suppression prévue en 2.0.
+
+Suite directe ``picarones/core/throughput.py``.  Pattern
+identique aux autres rendus : server-side, pas de JS, anti-
+injection systématique.
+
+Vue
+---
+Tableau résumé moteur × {pages/h brut, pages/h **utilisable**,
+% temps de correction (drag), n_pages, n_errors}.  La cellule
+**pages/h utilisable** est colorée en gradient rouge (faible)
+→ vert (élevé), normalisé sur le maximum observé.
+
+Adaptive : ``""`` si ``aggregate_effective_throughput`` retourne
+``None`` (aucun moteur exploitable).
+
+Note d'intégration
+------------------
+Cette vue est un **module pur** — l'utilisateur compose :
+
+.. code-block:: python
+
+    from picarones.measurements.throughput import (
+        aggregate_effective_throughput,
+    )
+    from picarones.reports_v2.html.renderers.throughput import (
+        build_throughput_html,
+    )
+
+    per_engine = []
+    for report in benchmark.engine_reports:
+        n_errors = sum(
+            int(round(dr.metrics.wer * dr.metrics.reference_length / 5))
+            for dr in report.document_results
+        )
+        per_engine.append({
+            "engine_name": report.engine_name,
+            "n_pages": len(report.document_results),
+            "duration_seconds": sum(
+                dr.duration_seconds for dr in report.document_results
+            ),
+            "n_errors": n_errors,
+        })
+    agg = aggregate_effective_throughput(per_engine)
+    html = build_throughput_html(agg, labels)
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+from picarones.reports_v2._helpers.render_helpers import color_traffic_light
+
+
+def build_throughput_html(
+    aggregated: Optional[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit la vue HTML throughput effectif.
+
+    Parameters
+    ----------
+    aggregated:
+        Sortie de ``aggregate_effective_throughput``.  Si
+        ``None`` ou liste vide, retourne ``""``.
+    labels:
+        Dict i18n.  Clés sous le préfixe ``throughput_*``.
+    """
+    if not aggregated:
+        return ""
+    rows = aggregated.get("engines") or []
+    if not rows:
+        return ""
+    labels = labels or {}
+    title = labels.get("throughput_title", "Throughput effectif")
+    note = labels.get(
+        "throughput_note",
+        "Pages traitables par heure en intégrant le temps de "
+        "correction humaine post-OCR. Discrimine entre un cloud "
+        "rapide mais imprécis et un local lent mais fiable. "
+        "Constante de correction : {time_per_error}s par erreur "
+        "(défaut HTR-United, surchargeable).",
+    )
+    time_per_error = aggregated.get("time_per_error_seconds", 5.0)
+    note = note.replace("{time_per_error}", f"{time_per_error:.0f}")
+    h_engine = labels.get("throughput_engine", "Moteur")
+    h_raw = labels.get("throughput_raw", "Pages/h brut")
+    h_effective = labels.get(
+        "throughput_effective", "Pages/h utilisable",
+    )
+    h_drag = labels.get("throughput_drag", "% correction")
+    h_pages = labels.get("throughput_pages", "Pages")
+    h_errors = labels.get("throughput_errors", "Erreurs")
+    max_eff = max(
+        (r.get("pages_per_hour_effective") or 0.0) for r in rows
+    )
+
+    parts = [
+        '<section class="throughput-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:.6rem">'
+        f'{_e(note)}</div>',
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.9rem">',
+        '<thead><tr>',
+    ]
+    for col in (h_engine, h_raw, h_effective, h_drag, h_pages, h_errors):
+        parts.append(
+            f'<th scope=\"col\" 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 row in sorted(
+        rows,
+        key=lambda r: -(r.get("pages_per_hour_effective") or 0.0),
+    ):
+        engine = str(row.get("engine_name") or "?")
+        raw = row.get("pages_per_hour_raw")
+        eff = row.get("pages_per_hour_effective") or 0.0
+        drag = row.get("drag_ratio") or 0.0
+        n_pages = int(row.get("n_pages") or 0)
+        n_errors = int(row.get("n_errors") or 0)
+        eff_color = (
+            color_traffic_light(eff, scale_max=max_eff)
+            if max_eff > 0 else "#e0e0e0"
+        )
+        drag_color = color_traffic_light(drag, low_is_good=True)
+        raw_str = (
+            f"{raw:,.0f}" if isinstance(raw, (int, float)) else "—"
+        )
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.4rem .6rem">{_e(engine)}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{raw_str}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'background:{eff_color};font-family:monospace;'
+            f'font-weight:600">{eff:,.0f}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'background:{drag_color};font-family:monospace">'
+            f'{drag * 100:.1f}%</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{n_pages}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{n_errors}</td>'
+            f'</tr>'
+        )
+    parts.append("</tbody></table></section>")
+    return "".join(parts)
+
+
+__all__ = ["build_throughput_html"]

tests/architecture/test_module_coverage.py

@@ -61,17 +61,17 @@ MEASUREMENTS_DIR = PICARONES_DIR / "measurements"
 #: de fin de ligne ``noqa F401`` dans
 #: ``picarones/measurements/__init__.py``).
 TEST_ONLY_BASELINE: frozenset[str] = frozenset({
-    # Phase 5.C : ``measurements/specialization.py`` est un shim
-    # vers ``evaluation/metrics/specialization``.  Son unique
-    # consommateur production (le renderer
-    # ``report/specialization_render.py``) a été migré vers
-    # ``reports_v2/html/renderers/specialization.py`` qui importe
-    # le canonique directement (la règle layer-dependencies
-    # interdit d'importer le shim depuis ``reports_v2/``).  Tant
-    # que des tests ou un caller externe utilisent le chemin
-    # legacy, le shim reste en place ; l'entrée ici est retirée
-    # au plus tard à la version 2.0 quand le shim disparaîtra.
+    # Phase 5.C : modules ``measurements/X.py`` qui sont des shims
+    # vers ``evaluation/metrics/X``.  Leur unique consommateur
+    # production (le renderer ``report/X_render.py``) a été migré
+    # vers ``reports_v2/html/renderers/X.py`` qui importe le
+    # canonique directement (la règle layer-dependencies interdit
+    # d'importer un shim depuis ``reports_v2/``).  Tant que des
+    # tests ou un caller externe utilisent le chemin legacy, le
+    # shim reste en place ; les entrées ici sont retirées au plus
+    # tard à la version 2.0 quand les shims disparaîtront.
     "specialization",
+    "lexical_modernization",
 })
 
 

tests/report/test_sprint80_lexical_modernization.py

@@ -32,7 +32,7 @@ from picarones.measurements.lexical_modernization import (
     compute_lexical_modernization,
     top_modernized_tokens,
 )
-from picarones.report.lexical_modernization_render import (
+from picarones.reports_v2.html.renderers.lexical_modernization import (
     build_lexical_modernization_html,
 )
 

tests/report/test_sprint90_engine_unstable.py

@@ -24,7 +24,7 @@ from pathlib import Path
 from picarones.measurements.narrative import build_synthesis
 from picarones.measurements.narrative.detectors import detect_engine_unstable
 from picarones.core.facts import FactImportance, FactType
-from picarones.report.multirun_stability_render import (
+from picarones.reports_v2.html.renderers.multirun_stability import (
     build_multirun_stability_html,
 )
 

tests/report/test_sprint91_throughput.py

@@ -28,7 +28,7 @@ from picarones.measurements.throughput import (
     aggregate_effective_throughput,
     compute_effective_throughput,
 )
-from picarones.report.throughput_render import build_throughput_html
+from picarones.reports_v2.html.renderers.throughput import build_throughput_html
 
 
 def _load_labels(lang: str) -> dict:

tests/report/test_sprint92_longitudinal.py

@@ -33,7 +33,7 @@ from picarones.measurements.longitudinal import (
 from picarones.measurements.narrative import build_synthesis
 from picarones.measurements.narrative.detectors import detect_regression_in_history
 from picarones.core.facts import FactImportance, FactType
-from picarones.report.longitudinal_render import build_longitudinal_html
+from picarones.reports_v2.html.renderers.longitudinal import build_longitudinal_html
 
 
 def _load_labels(lang: str) -> dict: