feat(migration): Phase 5.C batch 6 — levers + philological vers reports_v2/html/

Sixième vague. Migre le plus gros renderer non-bloqué
(``philological``, 527 LOC) et ``levers`` (249 LOC).

Migrations effectuées
---------------------
| Source legacy | Destination canonique |
|---------------------------------------------|------------------------------------------------------|
| ``report/levers_render.py`` (249) | ``reports_v2/html/renderers/levers.py`` |
| ``report/philological_render.py`` (527) | ``reports_v2/html/renderers/philological.py`` |

Total : ~776 lignes relocalisées.

Adaptations transverses
-----------------------
- ``test_sprint82_levers.py`` : monkeypatch sur ``_FORMATTERS``
pointe désormais vers le module canonique
``picarones.reports_v2.html.renderers.levers``.
- ``test_file_budgets.py`` : entrée
``report/philological_render.py`` retirée, remplacée par
``reports_v2/html/renderers/philological.py``.

Cumul Phase 5.C (batches 1-6) : 27 / 29 renderers migrés
(~5232 lignes). 2 renderers restants pour batch 7 :
``pipeline_render`` (707 l) et ``numerical_sequences_render`` (149 l).
Pré-requis batch 7 : migration de ``measurements/pipeline_benchmark``,
``measurements/pipeline_comparison``, ``measurements/numerical_sequences``,
``measurements/roman_numerals`` vers ``evaluation/metrics/``.

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

https://claude.ai/code/session_011XQZNitg1rCgia8ZD1a2hP

docs/migration/legacy-retirement-plan.md

@@ -695,8 +695,13 @@ architecture vérifiée.
 - Batch 3 ✅ (cf. ci-dessous) — 5 renderers (173-222 LOC).
 - Batch 4 ✅ (cf. ci-dessous) — 5 renderers (188-321 LOC).
 - Batch 5 ✅ (cf. ci-dessous) — 5 renderers (148-314 LOC).
-- Batch 6 (XXL + restants) : ``pipeline_render`` (707 l),
-  ``philological_render`` (595 l), ``levers`` (284 l).
+- Batch 6 ✅ (cf. ci-dessous) — 2 renderers (``levers``, ``philological``).
+- Batch 7 (final) : ``pipeline_render`` (707 l) +
+  ``numerical_sequences_render`` (149 l).
+  Pré-requis : migration de ``measurements/pipeline_benchmark``,
+  ``measurements/pipeline_comparison``,
+  ``measurements/numerical_sequences``,
+  ``measurements/roman_numerals`` vers ``evaluation/metrics/``.
 - Phase 5.D : 5 vues (``views/*.py``).
 - Phase 5.E : ``generator.py``, ``comparison.py``,
   ``snapshot.py``, ``report_data/``, templates Jinja2.
@@ -843,15 +848,43 @@ migrés**, soit l'intégralité moins ``pipeline_render`` et
 ``philological_render`` (XXL) et ``levers`` (oublié dans le plan
 initial).  Reste batch 6 (3 renderers) puis Phase 5.D (5 vues).
 
-Wait — le compte exact : 22 originaux moins ``pipeline_render``,
-``philological_render`` et ``levers`` = 19 attendus.  Or on en a
-migré 20 + 5 = 25 dans 5 batches.  Vérification : on a fait
-batch 1 (5) + batch 2 (5) + batch 3 (5) + batch 4 (5) + batch 5 (5)
-= 25.  Le plan initial listait 22 renderers ; en pratique le
-``report/`` en contient ~28 (cf. ``ls report/*_render.py``) — la
-liste du plan était incomplète.  L'inventaire exact restant :
-``levers_render.py`` + ``pipeline_render.py`` +
-``philological_render.py`` à finir (3 renderers, ~1586 LOC).
+#### Phase 5.C.batch6 — Lot 6 : levers + philological (2026-05)
+
+Sixième vague.  Inclut le plus gros renderer non-bloqué
+(``philological``, 527 LOC) et ``levers`` (249 LOC).
+``pipeline_render`` (707 l) reporté à un batch 7 dédié car il
+dépend de ``measurements/pipeline_benchmark`` et
+``measurements/pipeline_comparison`` non encore migrés vers
+``evaluation/`` (rejetés par layer-dependencies).
+``numerical_sequences_render`` (149 l) reporté pour la même
+raison (dépendance vers ``measurements/numerical_sequences``
+qui dépend de ``measurements/roman_numerals``).
+
+**Migrations effectuées** :
+
+| Source legacy                               | Destination canonique                                |
+|---------------------------------------------|------------------------------------------------------|
+| ``report/levers_render.py`` (249)           | ``reports_v2/html/renderers/levers.py``              |
+| ``report/philological_render.py`` (527)     | ``reports_v2/html/renderers/philological.py``        |
+
+Total : ~776 lignes relocalisées.
+
+**Adaptations transverses** :
+
+- ``test_sprint82_levers.py`` : monkeypatch sur `_FORMATTERS`
+  pointe désormais vers le module canonique
+  ``picarones.reports_v2.html.renderers.levers``.
+- ``test_file_budgets.py`` : entrée
+  ``report/philological_render.py`` retirée, remplacée par
+  ``reports_v2/html/renderers/philological.py`` (budget
+  inchangé à 700).
+
+**Cumul Phase 5.C** (batches 1-6) : 27 / 29 renderers migrés
+(~5232 lignes).  2 renderers restants pour batch 7 :
+``pipeline_render`` (707) et ``numerical_sequences_render`` (149).
+
+**Acceptance batch 6** : 5019 tests passent, lint vert,
+architecture vérifiée.
 
 ### Phase 6 — Pipelines OCR+LLM (`pipelines/`)
 

picarones/report/generator.py

@@ -283,7 +283,7 @@ class ReportGenerator:
             build_stratified_ranking_html,
         )
         # Sprint 62 — profil philologique (6 sections adaptive).
-        from picarones.report.philological_render import (
+        from picarones.reports_v2.html.renderers.philological import (
             build_philological_profile_html,
         )
         # Sprint 86 — A.II.5 : recherchabilité fuzzy + séquences numériques.

picarones/report/levers_render.py

@@ -1,284 +1,18 @@
-"""Rendu HTML de la section « Leviers d'amélioration » — Sprint 82.
+"""``picarones.report.levers_render`` — shim re-export (déprécié, suppression 2.0).
 
-A.I.9 du plan d'évolution 2026.
-
-Suite directe ``picarones/core/levers.py``.  Pattern identique aux
-autres rendus (Sprints 41/43/62/67/72/74/75/76/77/80) : **server-
-side**, pas de JavaScript, anti-injection systématique.
-
-Vue
----
-Une section composée de **cards** : une par levier, triée par
-importance décroissante.  Chaque card affiche :
-
-- une *étiquette* (libellé i18n du type de levier) ;
-- une *phrase factuelle* qui réutilise les chiffres du
-  ``payload`` (anti-hallucination : aucun chiffre n'est calculé
-  dans le rendu) ;
-- éventuellement un **détail compact** (top-N tokens, top-3
-  classes, etc.) ;
-- une *note* d'importance : HIGH / MEDIUM / LOW.
-
-Aucune classification automatique « bon » / « mauvais » et aucune
-recommandation : la phrase est purement descriptive.
+Canonique : :mod:`picarones.reports_v2.html.renderers.levers`.
+Phase 5.C du retrait du legacy.
 """
 
 from __future__ import annotations
 
-import logging
-from html import escape as _e
-from typing import Iterable, Optional
-
-logger = logging.getLogger(__name__)
-
-
-def _lever_label(lever_type: str, labels: dict[str, str]) -> str:
-    return labels.get(f"levers_label_{lever_type}", lever_type)
-
-
-def _format_dominant_recoverable(payload: dict, labels: dict[str, str]) -> str:
-    engine = _e(str(payload.get("engine", "?")))
-    pct = payload.get("share_recoverable_pct")
-    n_recov = payload.get("n_recoverable")
-    n_total = payload.get("n_total_errors")
-    template = labels.get(
-        "levers_dominant_recoverable_phrase",
-        "{pct}% des erreurs de {engine} ({n_recov}/{n_total}) sont "
-        "classifiées récupérables (case_error, ligature_error, "
-        "abbreviation_error).",
-    )
-    sentence = template.format(
-        engine=engine,
-        pct=pct,
-        n_recov=n_recov,
-        n_total=n_total,
-    )
-    top_classes = payload.get("top_classes") or []
-    if top_classes:
-        breakdown = ", ".join(
-            f"{_e(str(c.get('class', '?')))} ({c.get('count', 0)})"
-            for c in top_classes
-        )
-        detail_label = labels.get("levers_top_classes", "Principales :")
-        sentence += (
-            f' <span style="opacity:.8">— {_e(detail_label)} '
-            f'{breakdown}</span>'
-        )
-    return sentence
-
-
-def _format_pareto_concentration(payload: dict, labels: dict[str, str]) -> str:
-    engine = _e(str(payload.get("engine", "?")))
-    n_top = payload.get("n_docs_top")
-    n_total = payload.get("n_docs")
-    top_pct = payload.get("top_share_pct")
-    cer_pct = payload.get("cer_share_pct")
-    template = labels.get(
-        "levers_pareto_phrase",
-        "Sur {engine}, {n_top} documents ({top_pct}% du corpus) "
-        "concentrent {cer_pct}% du CER cumulé "
-        "(sur {n_total} documents au total).",
-    )
-    return template.format(
-        engine=engine,
-        n_top=n_top,
-        n_total=n_total,
-        top_pct=top_pct,
-        cer_pct=cer_pct,
-    )
-
-
-def _format_complementarity(payload: dict, labels: dict[str, str]) -> str:
-    abs_pct = payload.get("absolute_gap_pct")
-    rel_pct = payload.get("relative_gap_pct")
-    best_engine = payload.get("best_engine")
-    if best_engine:
-        template = labels.get(
-            "levers_complementarity_phrase_with_engine",
-            "L'oracle bag-of-words atteint un rappel supérieur de "
-            "{abs_pct} points (+{rel_pct}% relatif) à celui du meilleur "
-            "moteur seul ({best_engine}).",
-        )
-        return template.format(
-            abs_pct=abs_pct,
-            rel_pct=rel_pct,
-            best_engine=_e(str(best_engine)),
-        )
-    template = labels.get(
-        "levers_complementarity_phrase",
-        "L'oracle bag-of-words atteint un rappel supérieur de "
-        "{abs_pct} points (+{rel_pct}% relatif) à celui du meilleur "
-        "moteur seul.",
-    )
-    return template.format(abs_pct=abs_pct, rel_pct=rel_pct)
-
-
-def _format_lexical_modernization(payload: dict, labels: dict[str, str]) -> str:
-    engine = _e(str(payload.get("engine", "?")))
-    top_tokens = payload.get("top_tokens") or []
-    if not top_tokens:
-        return ""
-    items = ", ".join(
-        f"{_e(str(t.get('gt_token', '?')))} "
-        f"({t.get('rate_modernized_pct', 0)}%, "
-        f"n={t.get('n_total', 0)})"
-        for t in top_tokens
-    )
-    template = labels.get(
-        "levers_lexical_phrase",
-        "Top tokens GT systématiquement modernisés par {engine} : {items}.",
-    )
-    return template.format(engine=engine, items=items)
-
-
-def _format_robustness_projection(payload: dict, labels: dict[str, str]) -> str:
-    engine = _e(str(payload.get("engine", "?")))
-    deficit_pct = payload.get("total_expected_deficit_pct")
-    n_types = payload.get("n_degradation_types", 0)
-    worst_type = payload.get("worst_degradation_type")
-    worst_pct = payload.get("worst_degradation_deficit_pct")
-    if worst_type and worst_pct is not None:
-        template = labels.get(
-            "levers_robustness_phrase_with_worst",
-            "Déficit projeté de {engine} sur le corpus réel : "
-            "{deficit_pct} points de CER cumulés sur {n_types} "
-            "dégradations — pire dégradation : {worst_type} "
-            "({worst_pct} points).",
-        )
-        return template.format(
-            engine=engine,
-            deficit_pct=deficit_pct,
-            n_types=n_types,
-            worst_type=_e(str(worst_type)),
-            worst_pct=worst_pct,
-        )
-    template = labels.get(
-        "levers_robustness_phrase",
-        "Déficit projeté de {engine} sur le corpus réel : "
-        "{deficit_pct} points de CER cumulés sur {n_types} dégradations.",
-    )
-    return template.format(
-        engine=engine, deficit_pct=deficit_pct, n_types=n_types,
-    )
-
-
-_FORMATTERS = {
-    "dominant_recoverable_class": _format_dominant_recoverable,
-    "pareto_concentration": _format_pareto_concentration,
-    "complementarity_observation": _format_complementarity,
-    "lexical_modernization_observation": _format_lexical_modernization,
-    "robustness_projection_observation": _format_robustness_projection,
-}
-
-
-def _importance_label(importance: int, labels: dict[str, str]) -> str:
-    if importance >= 70:
-        return labels.get("levers_importance_high", "Important")
-    if importance >= 40:
-        return labels.get("levers_importance_medium", "À noter")
-    return labels.get("levers_importance_low", "Mineur")
-
-
-def _importance_color(importance: int) -> str:
-    if importance >= 70:
-        return "#c2410c"  # orange profond
-    if importance >= 40:
-        return "#0369a1"  # bleu
-    return "#6b7280"      # gris
-
-
-def build_levers_section_html(
-    levers: Iterable,
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Construit la section HTML des leviers.
-
-    Parameters
-    ----------
-    levers:
-        Itérable de ``Lever`` (ou de dicts avec ``type``,
-        ``importance``, ``payload``).
-    labels:
-        Dict i18n. Clés attendues sous le préfixe ``levers_``.
-
-    Returns
-    -------
-    str
-        Section HTML, ou ``""`` si aucun levier exploitable.
-    """
-    labels = labels or {}
-    cards: list[str] = []
-    for lever in levers:
-        # Accepter Lever ou dict
-        if hasattr(lever, "as_dict"):
-            data = lever.as_dict()
-        elif isinstance(lever, dict):
-            data = lever
-        else:
-            continue
-        lv_type = data.get("type")
-        importance = int(data.get("importance") or 0)
-        payload = data.get("payload") or {}
-        if not lv_type:
-            continue
-        formatter = _FORMATTERS.get(lv_type)
-        if formatter is None:
-            continue
-        try:
-            sentence = formatter(payload, labels)
-        except Exception as exc:  # noqa: BLE001 — un formatter cassé ne doit pas casser la section
-            logger.warning(
-                "[levers_render] formatter %r a échoué sur payload=%r : %s — "
-                "ce levier sera omis du rapport",
-                lv_type, payload, exc,
-            )
-            continue
-        if not sentence:
-            continue
-        type_label = _lever_label(lv_type, labels)
-        imp_label = _importance_label(importance, labels)
-        imp_color = _importance_color(importance)
-        cards.append(
-            '<div class="lever-card" style="border:1px solid #e5e7eb;'
-            'border-left:4px solid ' + imp_color + ';'
-            'border-radius:.4rem;padding:.7rem .9rem;'
-            'margin:.5rem 0;background:#fafafa">'
-            f'<div style="display:flex;justify-content:space-between;'
-            f'align-items:center;margin-bottom:.3rem;font-size:.8rem">'
-            f'<span style="font-weight:600;text-transform:uppercase;'
-            f'letter-spacing:.5px;color:#374151">'
-            f'{_e(type_label)}</span>'
-            f'<span style="color:{imp_color};font-weight:600">'
-            f'{_e(imp_label)}</span>'
-            f'</div>'
-            f'<div style="font-size:.95rem;line-height:1.45">'
-            f'{sentence}</div>'
-            '</div>'
-        )
-
-    if not cards:
-        return ""
-
-    title = labels.get("levers_title", "Leviers d'amélioration")
-    note = labels.get(
-        "levers_note",
-        "Observations factuelles synthétisées depuis les modules "
-        "d'analyse. Aucune recommandation imposée — c'est au "
-        "chercheur de juger ce qui est exploitable selon son "
-        "workflow.",
-    )
-
-    parts = [
-        '<section class="levers-section" style="margin:1.5rem 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>',
-    ]
-    parts.extend(cards)
-    parts.append('</section>')
-    return "".join(parts)
+import warnings
 
+from picarones.reports_v2.html.renderers.levers import *  # noqa: F401, F403
 
-__all__ = [
-    "build_levers_section_html",
-]
+warnings.warn(
+    "picarones.report.levers_render is deprecated and will be removed in 2.0.  "
+    "Import from picarones.reports_v2.html.renderers.levers instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)

picarones/report/philological_render.py

@@ -1,595 +1,18 @@
-"""Rendu HTML server-side du profil philologique (Sprint 62).
+"""``picarones.report.philological_render`` — shim re-export (déprécié, suppression 2.0).
 
-Suite directe Sprint 61 (câblage backend) — produit les blocs HTML
-qui exposent les six modules philologiques (Sprints 55-60) dans le
-rapport :
-
-- ``unicode_blocks``    (Sprint 55) — précision par bloc Unicode
-- ``abbreviations``     (Sprint 56) — score strict + expansion par
-                                       abréviation médiévale Capelli
-- ``mufi``              (Sprint 57) — couverture MUFI globale + par
-                                       caractère
-- ``early_modern``      (Sprint 58) — préservation des marqueurs
-                                       typographiques imprimé ancien
-- ``modern_archives``   (Sprint 59) — strict + expansion par
-                                       catégorie d'archive moderne
-- ``roman_numerals``    (Sprint 60) — breakdown 5 statuts de
-                                       restitution
-
-Principe identique aux Sprints 41 (NER) et 43 (calibration) :
-
-- Rendu **server-side**, pas de JavaScript, déterministe.
-- Section adaptive : si aucun moteur n'a de signal pour un module
-  donné, la sous-section est silencieusement omise.
-- Si **aucun module** n'a de signal sur l'ensemble des moteurs,
-  ``build_philological_profile_html`` retourne une chaîne vide et
-  le bloc complet n'apparaît pas dans la vue analyses.
-- **Aucune classification automatique** : on affiche les chiffres
-  bruts par catégorie/bloc/statut, le chercheur juge lui-même la
-  convention adoptée.
-- Anti-injection : tous les noms de moteurs, catégories, statuts,
-  caractères passent par ``html.escape`` avant insertion.
+Canonique : :mod:`picarones.reports_v2.html.renderers.philological`.
+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
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Helpers de coloration
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def _engines_with_module(
-    engines_summary: list[dict], module: str,
-) -> list[dict]:
-    """Filtre les moteurs ayant des données pour le module donné."""
-    out: list[dict] = []
-    for eng in engines_summary:
-        agg = eng.get("aggregated_philological") or {}
-        if module in agg and agg[module]:
-            out.append(eng)
-    return out
-
-
-def _score_cell(score: Optional[float], extra: str = "") -> str:
-    """Rend une cellule colorée.  ``None`` → cellule grise « — »."""
-    if score is None:
-        return (
-            '<td style="padding:.3rem .5rem;text-align:center;'
-            'background:#f0f0f0;color:#999">—</td>'
-        )
-    color = color_traffic_light(score)
-    text = f"{score * 100:.1f}%"
-    if extra:
-        text += f" <span style=\"opacity:.6;font-size:.85em\">({_e(extra)})</span>"
-    return (
-        f'<td style="padding:.3rem .5rem;text-align:center;'
-        f'background:{color}">{text}</td>'
-    )
-
-
-def _table_header(
-    columns: list[str], engine_label: str,
-) -> str:
-    """Construit l'entête d'un tableau moteur × colonnes."""
-    parts = [
-        '<thead><tr>',
-        f'<th scope=\"col\" style="padding:.3rem .5rem;text-align:left;'
-        f'border-bottom:1px solid var(--border);font-weight:600">'
-        f'{_e(engine_label)}</th>',
-    ]
-    for col in columns:
-        parts.append(
-            f'<th scope=\"col\" style="padding:.3rem .5rem;text-align:center;'
-            f'border-bottom:1px solid var(--border);font-weight:600">'
-            f'{_e(col)}</th>'
-        )
-    parts.append('</tr></thead>')
-    return "".join(parts)
-
-
-def _engine_label_cell(name: str) -> str:
-    return (
-        f'<td style="padding:.3rem .5rem;font-weight:500;'
-        f'border-bottom:1px solid var(--border-light)">{_e(name)}</td>'
-    )
-
-
-def _section_open(title: str, note: str = "") -> str:
-    parts = [
-        '<div class="philological-section" '
-        'style="margin:1rem 0;padding:.75rem;'
-        'background:var(--bg-secondary);border-radius:6px">',
-        f'<div style="font-weight:600;margin-bottom:.4rem">{_e(title)}</div>',
-    ]
-    if note:
-        parts.append(
-            f'<div style="font-size:.8rem;opacity:.75;margin-bottom:.5rem">'
-            f'{_e(note)}</div>'
-        )
-    return "".join(parts)
-
-
-def _section_close() -> str:
-    return "</div>"
-
-
-def _table_open() -> str:
-    return (
-        '<table style="border-collapse:collapse;width:100%;'
-        'font-size:.85rem">'
-    )
-
-
-def _table_close() -> str:
-    return "</table>"
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Sprint 55 — Précision par bloc Unicode
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def build_unicode_blocks_section(
-    engines_summary: list[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    relevant = _engines_with_module(engines_summary, "unicode_blocks")
-    if not relevant:
-        return ""
-    labels = labels or {}
-    title = labels.get(
-        "philo_unicode_blocks_title", "Précision par bloc Unicode",
-    )
-    note = labels.get(
-        "philo_unicode_blocks_note",
-        "Pourcentage de caractères correctement restitués par bloc "
-        "Unicode rencontré dans la GT (hors Basic Latin).",
-    )
-    engine_label = labels.get("philo_engine_label", "Moteur")
-    global_label = labels.get("philo_global_label", "Global")
-
-    # Collecte tous les blocs présents (hors Basic Latin déjà filtré
-    # par adaptive masking, mais on défilte ici si Basic Latin
-    # apparaît malgré tout chez certains moteurs).
-    all_blocks: set[str] = set()
-    for eng in relevant:
-        per_block = eng["aggregated_philological"]["unicode_blocks"].get(
-            "per_block", {},
-        )
-        for block in per_block:
-            if block != "Basic Latin":
-                all_blocks.add(block)
-    blocks = sorted(all_blocks)
-    if not blocks:
-        return ""
-
-    parts = [_section_open(title, note), _table_open()]
-    parts.append(_table_header([global_label] + blocks, engine_label))
-    parts.append("<tbody>")
-    for eng in relevant:
-        agg = eng["aggregated_philological"]["unicode_blocks"]
-        global_acc = agg.get("global_accuracy", 0.0)
-        n_chars = agg.get("n_chars_total", 0)
-        parts.append("<tr>")
-        parts.append(_engine_label_cell(eng["name"]))
-        parts.append(_score_cell(global_acc, extra=f"n={n_chars}"))
-        per_block = agg.get("per_block", {})
-        for block in blocks:
-            stats = per_block.get(block)
-            if stats and stats.get("total", 0) > 0:
-                parts.append(_score_cell(
-                    stats["accuracy"], extra=f"n={stats['total']}",
-                ))
-            else:
-                parts.append(_score_cell(None))
-        parts.append("</tr>")
-    parts.append("</tbody>")
-    parts.append(_table_close())
-    parts.append(_section_close())
-    return "".join(parts)
-
-
-# (sections suivantes définies plus loin)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Sprint 56 — Abréviations Capelli médiévales
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def build_abbreviations_section(
-    engines_summary: list[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    relevant = _engines_with_module(engines_summary, "abbreviations")
-    if not relevant:
-        return ""
-    labels = labels or {}
-    title = labels.get(
-        "philo_abbreviations_title",
-        "Abréviations médiévales (Capelli)",
-    )
-    note = labels.get(
-        "philo_abbreviations_note",
-        "Strict = forme abrégée (ꝑ, ꝓ, ⁊…) préservée telle quelle ; "
-        "Expansion = abrégée OU forme développée (per, pro, et…) "
-        "présente. Le ratio strict/expansion par moteur indique la "
-        "convention adoptée (diplomatique / modernisante).",
-    )
-    engine_label = labels.get("philo_engine_label", "Moteur")
-    strict_label = labels.get("philo_strict_label", "Strict")
-    expansion_label = labels.get("philo_expansion_label", "Expansion")
-    n_label = labels.get("philo_n_total_label", "n total")
-
-    parts = [_section_open(title, note), _table_open()]
-    parts.append(_table_header(
-        [strict_label, expansion_label, n_label], engine_label,
-    ))
-    parts.append("<tbody>")
-    for eng in relevant:
-        agg = eng["aggregated_philological"]["abbreviations"]
-        parts.append("<tr>")
-        parts.append(_engine_label_cell(eng["name"]))
-        parts.append(_score_cell(agg.get("global_strict_score", 0.0)))
-        parts.append(_score_cell(agg.get("global_expansion_score", 0.0)))
-        parts.append(
-            f'<td style="padding:.3rem .5rem;text-align:center">'
-            f'{agg.get("n_abbreviations_in_reference", 0)}</td>'
-        )
-        parts.append("</tr>")
-    parts.append("</tbody>")
-    parts.append(_table_close())
-    parts.append(_section_close())
-    return "".join(parts)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Sprint 57 — Couverture MUFI
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def build_mufi_section(
-    engines_summary: list[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    relevant = _engines_with_module(engines_summary, "mufi")
-    if not relevant:
-        return ""
-    labels = labels or {}
-    title = labels.get(
-        "philo_mufi_title",
-        "Couverture MUFI (Medieval Unicode Font Initiative)",
-    )
-    note = labels.get(
-        "philo_mufi_note",
-        "Taux de caractères MUFI de la GT (þ, ð, ƿ, ſ, æ, lettres "
-        "PUA…) correctement restitués dans l'OCR. Critère éditorial "
-        "central pour les médiévistes.",
-    )
-    engine_label = labels.get("philo_engine_label", "Moteur")
-    coverage_label = labels.get("philo_mufi_coverage_label", "Couverture")
-    n_label = labels.get("philo_n_total_label", "n total")
-
-    parts = [_section_open(title, note), _table_open()]
-    parts.append(_table_header(
-        [coverage_label, n_label], engine_label,
-    ))
-    parts.append("<tbody>")
-    for eng in relevant:
-        agg = eng["aggregated_philological"]["mufi"]
-        parts.append("<tr>")
-        parts.append(_engine_label_cell(eng["name"]))
-        parts.append(_score_cell(agg.get("coverage", 0.0)))
-        parts.append(
-            f'<td style="padding:.3rem .5rem;text-align:center">'
-            f'{agg.get("n_mufi_chars_reference", 0)}</td>'
-        )
-        parts.append("</tr>")
-    parts.append("</tbody>")
-    parts.append(_table_close())
-    parts.append(_section_close())
-    return "".join(parts)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Sprint 58 — Marqueurs typographiques imprimé ancien (heatmap)
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def build_early_modern_section(
-    engines_summary: list[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    relevant = _engines_with_module(engines_summary, "early_modern")
-    if not relevant:
-        return ""
-    labels = labels or {}
-    title = labels.get(
-        "philo_early_modern_title",
-        "Marqueurs typographiques imprimé ancien (XVIᵉ-XVIIIᵉ)",
-    )
-    note = labels.get(
-        "philo_early_modern_note",
-        "Préservation des ligatures (fi fl ff), s long (ſ), i sans "
-        "point (ı), esperluette (&) et tildes nasaux (ã õ ñ). "
-        "Une ligne par moteur, une colonne par catégorie.",
-    )
-    engine_label = labels.get("philo_engine_label", "Moteur")
-    global_label = labels.get("philo_global_label", "Global")
-
-    all_cats: set[str] = set()
-    for eng in relevant:
-        all_cats.update(
-            eng["aggregated_philological"]["early_modern"]
-            .get("per_category", {}).keys(),
-        )
-    cats = sorted(all_cats)
-    if not cats:
-        return ""
-
-    parts = [_section_open(title, note), _table_open()]
-    parts.append(_table_header([global_label] + cats, engine_label))
-    parts.append("<tbody>")
-    for eng in relevant:
-        agg = eng["aggregated_philological"]["early_modern"]
-        n_total = agg.get("n_markers_reference", 0)
-        parts.append("<tr>")
-        parts.append(_engine_label_cell(eng["name"]))
-        parts.append(_score_cell(
-            agg.get("global_preservation", 0.0), extra=f"n={n_total}",
-        ))
-        per_cat = agg.get("per_category", {})
-        for cat in cats:
-            stats = per_cat.get(cat)
-            if stats and stats.get("total", 0) > 0:
-                parts.append(_score_cell(
-                    stats["preservation"], extra=f"n={stats['total']}",
-                ))
-            else:
-                parts.append(_score_cell(None))
-        parts.append("</tr>")
-    parts.append("</tbody>")
-    parts.append(_table_close())
-    parts.append(_section_close())
-    return "".join(parts)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Sprint 59 — Archives modernes : strict + expansion par catégorie
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def build_modern_archives_section(
-    engines_summary: list[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    relevant = _engines_with_module(engines_summary, "modern_archives")
-    if not relevant:
-        return ""
-    labels = labels or {}
-    title = labels.get(
-        "philo_modern_archives_title",
-        "Abréviations des archives modernes (XIXᵉ-XXᵉ)",
-    )
-    note = labels.get(
-        "philo_modern_archives_note",
-        "Strict = abrégé préservé (Mme, S.A.R., bd, vol., …) ; "
-        "Expansion = abrégé OU forme développée. Affiché par "
-        "catégorie : civilité, ordinaux, monnaie, administratif, "
-        "état civil, ponctuation typo, latin, biblio, adresse.",
-    )
-    engine_label = labels.get("philo_engine_label", "Moteur")
-    global_label = labels.get("philo_global_label", "Global")
-    strict_label = labels.get("philo_strict_label", "Strict")
-    expansion_label = labels.get("philo_expansion_label", "Expansion")
-
-    all_cats: set[str] = set()
-    for eng in relevant:
-        all_cats.update(
-            eng["aggregated_philological"]["modern_archives"]
-            .get("per_category", {}).keys(),
-        )
-    cats = sorted(all_cats)
-
-    parts = [_section_open(title, note)]
-    parts.append(
-        '<table style="border-collapse:collapse;width:100%;'
-        'font-size:.85rem">'
-    )
-    parts.append("<thead><tr>")
-    parts.append(
-        f'<th scope=\"col\" rowspan="2" style="padding:.3rem .5rem;text-align:left;'
-        f'border-bottom:1px solid var(--border);font-weight:600">'
-        f'{_e(engine_label)}</th>'
-    )
-    parts.append(
-        f'<th scope=\"col\" colspan="2" style="padding:.3rem .5rem;text-align:center;'
-        f'border-bottom:1px solid var(--border);font-weight:600">'
-        f'{_e(global_label)}</th>'
-    )
-    for cat in cats:
-        parts.append(
-            f'<th scope=\"col\" colspan="2" style="padding:.3rem .5rem;text-align:center;'
-            f'border-bottom:1px solid var(--border);font-weight:600">'
-            f'{_e(cat)}</th>'
-        )
-    parts.append("</tr><tr>")
-    for _ in range(1 + len(cats)):
-        parts.append(
-            f'<th scope=\"col\" style="padding:.2rem .4rem;text-align:center;'
-            f'font-size:.75rem;font-weight:500;opacity:.7">'
-            f'{_e(strict_label)}</th>'
-        )
-        parts.append(
-            f'<th scope=\"col\" style="padding:.2rem .4rem;text-align:center;'
-            f'font-size:.75rem;font-weight:500;opacity:.7">'
-            f'{_e(expansion_label)}</th>'
-        )
-    parts.append("</tr></thead>")
-    parts.append("<tbody>")
-    for eng in relevant:
-        agg = eng["aggregated_philological"]["modern_archives"]
-        parts.append("<tr>")
-        parts.append(_engine_label_cell(eng["name"]))
-        parts.append(_score_cell(agg.get("global_strict_score", 0.0)))
-        parts.append(_score_cell(agg.get("global_expansion_score", 0.0)))
-        per_cat = agg.get("per_category", {})
-        for cat in cats:
-            stats = per_cat.get(cat)
-            if stats and stats.get("n_total", 0) > 0:
-                parts.append(_score_cell(
-                    stats["strict_score"],
-                    extra=f"n={stats['n_total']}",
-                ))
-                parts.append(_score_cell(stats["expansion_score"]))
-            else:
-                parts.append(_score_cell(None))
-                parts.append(_score_cell(None))
-        parts.append("</tr>")
-    parts.append("</tbody>")
-    parts.append(_table_close())
-    parts.append(_section_close())
-    return "".join(parts)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Sprint 60 — Numéraux romains : breakdown 5 statuts
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def build_roman_numerals_section(
-    engines_summary: list[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    relevant = _engines_with_module(engines_summary, "roman_numerals")
-    if not relevant:
-        return ""
-    labels = labels or {}
-    title = labels.get(
-        "philo_roman_numerals_title",
-        "Numéraux romains : restitution par statut",
-    )
-    note = labels.get(
-        "philo_roman_numerals_note",
-        "Pour chaque numéral romain de la GT, statut de restitution : "
-        "strict (forme exacte), case_changed (casse modifiée), "
-        "j_dropped (j médiéval normalisé), converted_to_arabic, lost. "
-        "Le breakdown indique la convention : majoritaire strict → "
-        "diplomatique ; majoritaire arabic → modernisation profonde.",
-    )
-    engine_label = labels.get("philo_engine_label", "Moteur")
-    n_label = labels.get("philo_n_total_label", "n total")
-
-    statuses = (
-        "strict_preserved", "case_changed", "j_dropped",
-        "converted_to_arabic", "lost",
-    )
-    status_labels = {
-        s: labels.get(f"philo_roman_status_{s}", s) for s in statuses
-    }
-
-    parts = [_section_open(title, note), _table_open()]
-    parts.append(_table_header(
-        [n_label] + [status_labels[s] for s in statuses],
-        engine_label,
-    ))
-    parts.append("<tbody>")
-    for eng in relevant:
-        agg = eng["aggregated_philological"]["roman_numerals"]
-        n_total = agg.get("n_numerals_reference", 0)
-        per_status = agg.get("per_status", {})
-        parts.append("<tr>")
-        parts.append(_engine_label_cell(eng["name"]))
-        parts.append(
-            f'<td style="padding:.3rem .5rem;text-align:center">'
-            f'{n_total}</td>'
-        )
-        for status in statuses:
-            count = per_status.get(status, 0)
-            if n_total > 0:
-                ratio = count / n_total
-                # Pour « lost » on inverse la couleur (un haut taux
-                # de perte est mauvais).  Pour les autres on garde
-                # la sémantique « plus c'est haut, plus l'OCR a
-                # adopté ce statut ».
-                color = (
-                    color_traffic_light(1.0 - ratio) if status == "lost"
-                    else color_traffic_light(ratio)
-                )
-                parts.append(
-                    f'<td style="padding:.3rem .5rem;text-align:center;'
-                    f'background:{color}">{count} '
-                    f'<span style="opacity:.6;font-size:.85em">'
-                    f'({ratio * 100:.0f}%)</span></td>'
-                )
-            else:
-                parts.append(_score_cell(None))
-        parts.append("</tr>")
-    parts.append("</tbody>")
-    parts.append(_table_close())
-    parts.append(_section_close())
-    return "".join(parts)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Agrégateur principal
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def build_philological_profile_html(
-    engines_summary: list[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Assemble les six sections en un bloc unique.
-
-    Retourne ``""`` si aucune section n'a de contenu (c.-à-d.
-    aucun moteur n'a de signal philologique sur le corpus).
-    """
-    sections = [
-        build_unicode_blocks_section(engines_summary, labels),
-        build_abbreviations_section(engines_summary, labels),
-        build_mufi_section(engines_summary, labels),
-        build_early_modern_section(engines_summary, labels),
-        build_modern_archives_section(engines_summary, labels),
-        build_roman_numerals_section(engines_summary, labels),
-    ]
-    non_empty = [s for s in sections if s]
-    if not non_empty:
-        return ""
-    labels = labels or {}
-    main_title = labels.get(
-        "philo_profile_title", "Profil philologique",
-    )
-    main_note = labels.get(
-        "philo_profile_note",
-        "Données brutes par catégorie de marqueur philologique. "
-        "L'outil ne classifie pas la convention adoptée par chaque "
-        "moteur — c'est au chercheur de lire les chiffres et de "
-        "conclure selon ses critères éditoriaux.",
-    )
-    parts = [
-        '<div class="philological-profile">',
-        f'<h3 style="margin-top:0">{_e(main_title)}</h3>',
-        f'<p style="font-size:.85rem;opacity:.8;margin-bottom:.5rem">'
-        f'{_e(main_note)}</p>',
-    ]
-    parts.extend(non_empty)
-    parts.append("</div>")
-    return "".join(parts)
+import warnings
 
+from picarones.reports_v2.html.renderers.philological import *  # noqa: F401, F403
 
-__all__ = [
-    "build_philological_profile_html",
-    "build_unicode_blocks_section",
-    "build_abbreviations_section",
-    "build_mufi_section",
-    "build_early_modern_section",
-    "build_modern_archives_section",
-    "build_roman_numerals_section",
-]
+warnings.warn(
+    "picarones.report.philological_render is deprecated and will be removed in 2.0.  "
+    "Import from picarones.reports_v2.html.renderers.philological instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)

picarones/report/views/diagnostics.py

@@ -103,7 +103,7 @@ def build_diagnostics_view_html(
     # Sous-section 1 : leviers (calculés automatiquement)
     try:
         from picarones.measurements.levers import detect_levers
-        from picarones.report.levers_render import build_levers_section_html
+        from picarones.reports_v2.html.renderers.levers import build_levers_section_html
         levers = detect_levers(report_data)
         html = build_levers_section_html(levers, labels=labels)
         if html:

picarones/reports_v2/html/renderers/levers.py

@@ -0,0 +1,290 @@
+"""Rendu HTML de la section « Leviers d'amélioration » — Sprint 82.
+
+Phase 5.C — module relocalisé depuis
+``picarones.report.levers_render`` vers
+``picarones.reports_v2.html.renderers.levers``.  Le chemin legacy
+reste disponible via un shim avec ``DeprecationWarning`` ;
+suppression prévue en 2.0.
+
+A.I.9 du plan d'évolution 2026.
+
+Suite directe ``picarones/core/levers.py``.  Pattern identique aux
+autres rendus (Sprints 41/43/62/67/72/74/75/76/77/80) : **server-
+side**, pas de JavaScript, anti-injection systématique.
+
+Vue
+---
+Une section composée de **cards** : une par levier, triée par
+importance décroissante.  Chaque card affiche :
+
+- une *étiquette* (libellé i18n du type de levier) ;
+- une *phrase factuelle* qui réutilise les chiffres du
+  ``payload`` (anti-hallucination : aucun chiffre n'est calculé
+  dans le rendu) ;
+- éventuellement un **détail compact** (top-N tokens, top-3
+  classes, etc.) ;
+- une *note* d'importance : HIGH / MEDIUM / LOW.
+
+Aucune classification automatique « bon » / « mauvais » et aucune
+recommandation : la phrase est purement descriptive.
+"""
+
+from __future__ import annotations
+
+import logging
+from html import escape as _e
+from typing import Iterable, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def _lever_label(lever_type: str, labels: dict[str, str]) -> str:
+    return labels.get(f"levers_label_{lever_type}", lever_type)
+
+
+def _format_dominant_recoverable(payload: dict, labels: dict[str, str]) -> str:
+    engine = _e(str(payload.get("engine", "?")))
+    pct = payload.get("share_recoverable_pct")
+    n_recov = payload.get("n_recoverable")
+    n_total = payload.get("n_total_errors")
+    template = labels.get(
+        "levers_dominant_recoverable_phrase",
+        "{pct}% des erreurs de {engine} ({n_recov}/{n_total}) sont "
+        "classifiées récupérables (case_error, ligature_error, "
+        "abbreviation_error).",
+    )
+    sentence = template.format(
+        engine=engine,
+        pct=pct,
+        n_recov=n_recov,
+        n_total=n_total,
+    )
+    top_classes = payload.get("top_classes") or []
+    if top_classes:
+        breakdown = ", ".join(
+            f"{_e(str(c.get('class', '?')))} ({c.get('count', 0)})"
+            for c in top_classes
+        )
+        detail_label = labels.get("levers_top_classes", "Principales :")
+        sentence += (
+            f' <span style="opacity:.8">— {_e(detail_label)} '
+            f'{breakdown}</span>'
+        )
+    return sentence
+
+
+def _format_pareto_concentration(payload: dict, labels: dict[str, str]) -> str:
+    engine = _e(str(payload.get("engine", "?")))
+    n_top = payload.get("n_docs_top")
+    n_total = payload.get("n_docs")
+    top_pct = payload.get("top_share_pct")
+    cer_pct = payload.get("cer_share_pct")
+    template = labels.get(
+        "levers_pareto_phrase",
+        "Sur {engine}, {n_top} documents ({top_pct}% du corpus) "
+        "concentrent {cer_pct}% du CER cumulé "
+        "(sur {n_total} documents au total).",
+    )
+    return template.format(
+        engine=engine,
+        n_top=n_top,
+        n_total=n_total,
+        top_pct=top_pct,
+        cer_pct=cer_pct,
+    )
+
+
+def _format_complementarity(payload: dict, labels: dict[str, str]) -> str:
+    abs_pct = payload.get("absolute_gap_pct")
+    rel_pct = payload.get("relative_gap_pct")
+    best_engine = payload.get("best_engine")
+    if best_engine:
+        template = labels.get(
+            "levers_complementarity_phrase_with_engine",
+            "L'oracle bag-of-words atteint un rappel supérieur de "
+            "{abs_pct} points (+{rel_pct}% relatif) à celui du meilleur "
+            "moteur seul ({best_engine}).",
+        )
+        return template.format(
+            abs_pct=abs_pct,
+            rel_pct=rel_pct,
+            best_engine=_e(str(best_engine)),
+        )
+    template = labels.get(
+        "levers_complementarity_phrase",
+        "L'oracle bag-of-words atteint un rappel supérieur de "
+        "{abs_pct} points (+{rel_pct}% relatif) à celui du meilleur "
+        "moteur seul.",
+    )
+    return template.format(abs_pct=abs_pct, rel_pct=rel_pct)
+
+
+def _format_lexical_modernization(payload: dict, labels: dict[str, str]) -> str:
+    engine = _e(str(payload.get("engine", "?")))
+    top_tokens = payload.get("top_tokens") or []
+    if not top_tokens:
+        return ""
+    items = ", ".join(
+        f"{_e(str(t.get('gt_token', '?')))} "
+        f"({t.get('rate_modernized_pct', 0)}%, "
+        f"n={t.get('n_total', 0)})"
+        for t in top_tokens
+    )
+    template = labels.get(
+        "levers_lexical_phrase",
+        "Top tokens GT systématiquement modernisés par {engine} : {items}.",
+    )
+    return template.format(engine=engine, items=items)
+
+
+def _format_robustness_projection(payload: dict, labels: dict[str, str]) -> str:
+    engine = _e(str(payload.get("engine", "?")))
+    deficit_pct = payload.get("total_expected_deficit_pct")
+    n_types = payload.get("n_degradation_types", 0)
+    worst_type = payload.get("worst_degradation_type")
+    worst_pct = payload.get("worst_degradation_deficit_pct")
+    if worst_type and worst_pct is not None:
+        template = labels.get(
+            "levers_robustness_phrase_with_worst",
+            "Déficit projeté de {engine} sur le corpus réel : "
+            "{deficit_pct} points de CER cumulés sur {n_types} "
+            "dégradations — pire dégradation : {worst_type} "
+            "({worst_pct} points).",
+        )
+        return template.format(
+            engine=engine,
+            deficit_pct=deficit_pct,
+            n_types=n_types,
+            worst_type=_e(str(worst_type)),
+            worst_pct=worst_pct,
+        )
+    template = labels.get(
+        "levers_robustness_phrase",
+        "Déficit projeté de {engine} sur le corpus réel : "
+        "{deficit_pct} points de CER cumulés sur {n_types} dégradations.",
+    )
+    return template.format(
+        engine=engine, deficit_pct=deficit_pct, n_types=n_types,
+    )
+
+
+_FORMATTERS = {
+    "dominant_recoverable_class": _format_dominant_recoverable,
+    "pareto_concentration": _format_pareto_concentration,
+    "complementarity_observation": _format_complementarity,
+    "lexical_modernization_observation": _format_lexical_modernization,
+    "robustness_projection_observation": _format_robustness_projection,
+}
+
+
+def _importance_label(importance: int, labels: dict[str, str]) -> str:
+    if importance >= 70:
+        return labels.get("levers_importance_high", "Important")
+    if importance >= 40:
+        return labels.get("levers_importance_medium", "À noter")
+    return labels.get("levers_importance_low", "Mineur")
+
+
+def _importance_color(importance: int) -> str:
+    if importance >= 70:
+        return "#c2410c"  # orange profond
+    if importance >= 40:
+        return "#0369a1"  # bleu
+    return "#6b7280"      # gris
+
+
+def build_levers_section_html(
+    levers: Iterable,
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit la section HTML des leviers.
+
+    Parameters
+    ----------
+    levers:
+        Itérable de ``Lever`` (ou de dicts avec ``type``,
+        ``importance``, ``payload``).
+    labels:
+        Dict i18n. Clés attendues sous le préfixe ``levers_``.
+
+    Returns
+    -------
+    str
+        Section HTML, ou ``""`` si aucun levier exploitable.
+    """
+    labels = labels or {}
+    cards: list[str] = []
+    for lever in levers:
+        # Accepter Lever ou dict
+        if hasattr(lever, "as_dict"):
+            data = lever.as_dict()
+        elif isinstance(lever, dict):
+            data = lever
+        else:
+            continue
+        lv_type = data.get("type")
+        importance = int(data.get("importance") or 0)
+        payload = data.get("payload") or {}
+        if not lv_type:
+            continue
+        formatter = _FORMATTERS.get(lv_type)
+        if formatter is None:
+            continue
+        try:
+            sentence = formatter(payload, labels)
+        except Exception as exc:  # noqa: BLE001 — un formatter cassé ne doit pas casser la section
+            logger.warning(
+                "[levers_render] formatter %r a échoué sur payload=%r : %s — "
+                "ce levier sera omis du rapport",
+                lv_type, payload, exc,
+            )
+            continue
+        if not sentence:
+            continue
+        type_label = _lever_label(lv_type, labels)
+        imp_label = _importance_label(importance, labels)
+        imp_color = _importance_color(importance)
+        cards.append(
+            '<div class="lever-card" style="border:1px solid #e5e7eb;'
+            'border-left:4px solid ' + imp_color + ';'
+            'border-radius:.4rem;padding:.7rem .9rem;'
+            'margin:.5rem 0;background:#fafafa">'
+            f'<div style="display:flex;justify-content:space-between;'
+            f'align-items:center;margin-bottom:.3rem;font-size:.8rem">'
+            f'<span style="font-weight:600;text-transform:uppercase;'
+            f'letter-spacing:.5px;color:#374151">'
+            f'{_e(type_label)}</span>'
+            f'<span style="color:{imp_color};font-weight:600">'
+            f'{_e(imp_label)}</span>'
+            f'</div>'
+            f'<div style="font-size:.95rem;line-height:1.45">'
+            f'{sentence}</div>'
+            '</div>'
+        )
+
+    if not cards:
+        return ""
+
+    title = labels.get("levers_title", "Leviers d'amélioration")
+    note = labels.get(
+        "levers_note",
+        "Observations factuelles synthétisées depuis les modules "
+        "d'analyse. Aucune recommandation imposée — c'est au "
+        "chercheur de juger ce qui est exploitable selon son "
+        "workflow.",
+    )
+
+    parts = [
+        '<section class="levers-section" style="margin:1.5rem 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>',
+    ]
+    parts.extend(cards)
+    parts.append('</section>')
+    return "".join(parts)
+
+
+__all__ = [
+    "build_levers_section_html",
+]

picarones/reports_v2/html/renderers/philological.py

@@ -0,0 +1,601 @@
+"""Rendu HTML server-side du profil philologique (Sprint 62).
+
+Phase 5.C — module relocalisé depuis
+``picarones.report.philological_render`` vers
+``picarones.reports_v2.html.renderers.philological``.  Le chemin
+legacy reste disponible via un shim avec ``DeprecationWarning`` ;
+suppression prévue en 2.0.
+
+Suite directe Sprint 61 (câblage backend) — produit les blocs HTML
+qui exposent les six modules philologiques (Sprints 55-60) dans le
+rapport :
+
+- ``unicode_blocks``    (Sprint 55) — précision par bloc Unicode
+- ``abbreviations``     (Sprint 56) — score strict + expansion par
+                                       abréviation médiévale Capelli
+- ``mufi``              (Sprint 57) — couverture MUFI globale + par
+                                       caractère
+- ``early_modern``      (Sprint 58) — préservation des marqueurs
+                                       typographiques imprimé ancien
+- ``modern_archives``   (Sprint 59) — strict + expansion par
+                                       catégorie d'archive moderne
+- ``roman_numerals``    (Sprint 60) — breakdown 5 statuts de
+                                       restitution
+
+Principe identique aux Sprints 41 (NER) et 43 (calibration) :
+
+- Rendu **server-side**, pas de JavaScript, déterministe.
+- Section adaptive : si aucun moteur n'a de signal pour un module
+  donné, la sous-section est silencieusement omise.
+- Si **aucun module** n'a de signal sur l'ensemble des moteurs,
+  ``build_philological_profile_html`` retourne une chaîne vide et
+  le bloc complet n'apparaît pas dans la vue analyses.
+- **Aucune classification automatique** : on affiche les chiffres
+  bruts par catégorie/bloc/statut, le chercheur juge lui-même la
+  convention adoptée.
+- Anti-injection : tous les noms de moteurs, catégories, statuts,
+  caractères passent par ``html.escape`` avant insertion.
+"""
+
+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
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Helpers de coloration
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def _engines_with_module(
+    engines_summary: list[dict], module: str,
+) -> list[dict]:
+    """Filtre les moteurs ayant des données pour le module donné."""
+    out: list[dict] = []
+    for eng in engines_summary:
+        agg = eng.get("aggregated_philological") or {}
+        if module in agg and agg[module]:
+            out.append(eng)
+    return out
+
+
+def _score_cell(score: Optional[float], extra: str = "") -> str:
+    """Rend une cellule colorée.  ``None`` → cellule grise « — »."""
+    if score is None:
+        return (
+            '<td style="padding:.3rem .5rem;text-align:center;'
+            'background:#f0f0f0;color:#999">—</td>'
+        )
+    color = color_traffic_light(score)
+    text = f"{score * 100:.1f}%"
+    if extra:
+        text += f" <span style=\"opacity:.6;font-size:.85em\">({_e(extra)})</span>"
+    return (
+        f'<td style="padding:.3rem .5rem;text-align:center;'
+        f'background:{color}">{text}</td>'
+    )
+
+
+def _table_header(
+    columns: list[str], engine_label: str,
+) -> str:
+    """Construit l'entête d'un tableau moteur × colonnes."""
+    parts = [
+        '<thead><tr>',
+        f'<th scope=\"col\" style="padding:.3rem .5rem;text-align:left;'
+        f'border-bottom:1px solid var(--border);font-weight:600">'
+        f'{_e(engine_label)}</th>',
+    ]
+    for col in columns:
+        parts.append(
+            f'<th scope=\"col\" style="padding:.3rem .5rem;text-align:center;'
+            f'border-bottom:1px solid var(--border);font-weight:600">'
+            f'{_e(col)}</th>'
+        )
+    parts.append('</tr></thead>')
+    return "".join(parts)
+
+
+def _engine_label_cell(name: str) -> str:
+    return (
+        f'<td style="padding:.3rem .5rem;font-weight:500;'
+        f'border-bottom:1px solid var(--border-light)">{_e(name)}</td>'
+    )
+
+
+def _section_open(title: str, note: str = "") -> str:
+    parts = [
+        '<div class="philological-section" '
+        'style="margin:1rem 0;padding:.75rem;'
+        'background:var(--bg-secondary);border-radius:6px">',
+        f'<div style="font-weight:600;margin-bottom:.4rem">{_e(title)}</div>',
+    ]
+    if note:
+        parts.append(
+            f'<div style="font-size:.8rem;opacity:.75;margin-bottom:.5rem">'
+            f'{_e(note)}</div>'
+        )
+    return "".join(parts)
+
+
+def _section_close() -> str:
+    return "</div>"
+
+
+def _table_open() -> str:
+    return (
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.85rem">'
+    )
+
+
+def _table_close() -> str:
+    return "</table>"
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Sprint 55 — Précision par bloc Unicode
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def build_unicode_blocks_section(
+    engines_summary: list[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    relevant = _engines_with_module(engines_summary, "unicode_blocks")
+    if not relevant:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "philo_unicode_blocks_title", "Précision par bloc Unicode",
+    )
+    note = labels.get(
+        "philo_unicode_blocks_note",
+        "Pourcentage de caractères correctement restitués par bloc "
+        "Unicode rencontré dans la GT (hors Basic Latin).",
+    )
+    engine_label = labels.get("philo_engine_label", "Moteur")
+    global_label = labels.get("philo_global_label", "Global")
+
+    # Collecte tous les blocs présents (hors Basic Latin déjà filtré
+    # par adaptive masking, mais on défilte ici si Basic Latin
+    # apparaît malgré tout chez certains moteurs).
+    all_blocks: set[str] = set()
+    for eng in relevant:
+        per_block = eng["aggregated_philological"]["unicode_blocks"].get(
+            "per_block", {},
+        )
+        for block in per_block:
+            if block != "Basic Latin":
+                all_blocks.add(block)
+    blocks = sorted(all_blocks)
+    if not blocks:
+        return ""
+
+    parts = [_section_open(title, note), _table_open()]
+    parts.append(_table_header([global_label] + blocks, engine_label))
+    parts.append("<tbody>")
+    for eng in relevant:
+        agg = eng["aggregated_philological"]["unicode_blocks"]
+        global_acc = agg.get("global_accuracy", 0.0)
+        n_chars = agg.get("n_chars_total", 0)
+        parts.append("<tr>")
+        parts.append(_engine_label_cell(eng["name"]))
+        parts.append(_score_cell(global_acc, extra=f"n={n_chars}"))
+        per_block = agg.get("per_block", {})
+        for block in blocks:
+            stats = per_block.get(block)
+            if stats and stats.get("total", 0) > 0:
+                parts.append(_score_cell(
+                    stats["accuracy"], extra=f"n={stats['total']}",
+                ))
+            else:
+                parts.append(_score_cell(None))
+        parts.append("</tr>")
+    parts.append("</tbody>")
+    parts.append(_table_close())
+    parts.append(_section_close())
+    return "".join(parts)
+
+
+# (sections suivantes définies plus loin)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Sprint 56 — Abréviations Capelli médiévales
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def build_abbreviations_section(
+    engines_summary: list[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    relevant = _engines_with_module(engines_summary, "abbreviations")
+    if not relevant:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "philo_abbreviations_title",
+        "Abréviations médiévales (Capelli)",
+    )
+    note = labels.get(
+        "philo_abbreviations_note",
+        "Strict = forme abrégée (ꝑ, ꝓ, ⁊…) préservée telle quelle ; "
+        "Expansion = abrégée OU forme développée (per, pro, et…) "
+        "présente. Le ratio strict/expansion par moteur indique la "
+        "convention adoptée (diplomatique / modernisante).",
+    )
+    engine_label = labels.get("philo_engine_label", "Moteur")
+    strict_label = labels.get("philo_strict_label", "Strict")
+    expansion_label = labels.get("philo_expansion_label", "Expansion")
+    n_label = labels.get("philo_n_total_label", "n total")
+
+    parts = [_section_open(title, note), _table_open()]
+    parts.append(_table_header(
+        [strict_label, expansion_label, n_label], engine_label,
+    ))
+    parts.append("<tbody>")
+    for eng in relevant:
+        agg = eng["aggregated_philological"]["abbreviations"]
+        parts.append("<tr>")
+        parts.append(_engine_label_cell(eng["name"]))
+        parts.append(_score_cell(agg.get("global_strict_score", 0.0)))
+        parts.append(_score_cell(agg.get("global_expansion_score", 0.0)))
+        parts.append(
+            f'<td style="padding:.3rem .5rem;text-align:center">'
+            f'{agg.get("n_abbreviations_in_reference", 0)}</td>'
+        )
+        parts.append("</tr>")
+    parts.append("</tbody>")
+    parts.append(_table_close())
+    parts.append(_section_close())
+    return "".join(parts)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Sprint 57 — Couverture MUFI
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def build_mufi_section(
+    engines_summary: list[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    relevant = _engines_with_module(engines_summary, "mufi")
+    if not relevant:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "philo_mufi_title",
+        "Couverture MUFI (Medieval Unicode Font Initiative)",
+    )
+    note = labels.get(
+        "philo_mufi_note",
+        "Taux de caractères MUFI de la GT (þ, ð, ƿ, ſ, æ, lettres "
+        "PUA…) correctement restitués dans l'OCR. Critère éditorial "
+        "central pour les médiévistes.",
+    )
+    engine_label = labels.get("philo_engine_label", "Moteur")
+    coverage_label = labels.get("philo_mufi_coverage_label", "Couverture")
+    n_label = labels.get("philo_n_total_label", "n total")
+
+    parts = [_section_open(title, note), _table_open()]
+    parts.append(_table_header(
+        [coverage_label, n_label], engine_label,
+    ))
+    parts.append("<tbody>")
+    for eng in relevant:
+        agg = eng["aggregated_philological"]["mufi"]
+        parts.append("<tr>")
+        parts.append(_engine_label_cell(eng["name"]))
+        parts.append(_score_cell(agg.get("coverage", 0.0)))
+        parts.append(
+            f'<td style="padding:.3rem .5rem;text-align:center">'
+            f'{agg.get("n_mufi_chars_reference", 0)}</td>'
+        )
+        parts.append("</tr>")
+    parts.append("</tbody>")
+    parts.append(_table_close())
+    parts.append(_section_close())
+    return "".join(parts)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Sprint 58 — Marqueurs typographiques imprimé ancien (heatmap)
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def build_early_modern_section(
+    engines_summary: list[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    relevant = _engines_with_module(engines_summary, "early_modern")
+    if not relevant:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "philo_early_modern_title",
+        "Marqueurs typographiques imprimé ancien (XVIᵉ-XVIIIᵉ)",
+    )
+    note = labels.get(
+        "philo_early_modern_note",
+        "Préservation des ligatures (fi fl ff), s long (ſ), i sans "
+        "point (ı), esperluette (&) et tildes nasaux (ã õ ñ). "
+        "Une ligne par moteur, une colonne par catégorie.",
+    )
+    engine_label = labels.get("philo_engine_label", "Moteur")
+    global_label = labels.get("philo_global_label", "Global")
+
+    all_cats: set[str] = set()
+    for eng in relevant:
+        all_cats.update(
+            eng["aggregated_philological"]["early_modern"]
+            .get("per_category", {}).keys(),
+        )
+    cats = sorted(all_cats)
+    if not cats:
+        return ""
+
+    parts = [_section_open(title, note), _table_open()]
+    parts.append(_table_header([global_label] + cats, engine_label))
+    parts.append("<tbody>")
+    for eng in relevant:
+        agg = eng["aggregated_philological"]["early_modern"]
+        n_total = agg.get("n_markers_reference", 0)
+        parts.append("<tr>")
+        parts.append(_engine_label_cell(eng["name"]))
+        parts.append(_score_cell(
+            agg.get("global_preservation", 0.0), extra=f"n={n_total}",
+        ))
+        per_cat = agg.get("per_category", {})
+        for cat in cats:
+            stats = per_cat.get(cat)
+            if stats and stats.get("total", 0) > 0:
+                parts.append(_score_cell(
+                    stats["preservation"], extra=f"n={stats['total']}",
+                ))
+            else:
+                parts.append(_score_cell(None))
+        parts.append("</tr>")
+    parts.append("</tbody>")
+    parts.append(_table_close())
+    parts.append(_section_close())
+    return "".join(parts)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Sprint 59 — Archives modernes : strict + expansion par catégorie
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def build_modern_archives_section(
+    engines_summary: list[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    relevant = _engines_with_module(engines_summary, "modern_archives")
+    if not relevant:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "philo_modern_archives_title",
+        "Abréviations des archives modernes (XIXᵉ-XXᵉ)",
+    )
+    note = labels.get(
+        "philo_modern_archives_note",
+        "Strict = abrégé préservé (Mme, S.A.R., bd, vol., …) ; "
+        "Expansion = abrégé OU forme développée. Affiché par "
+        "catégorie : civilité, ordinaux, monnaie, administratif, "
+        "état civil, ponctuation typo, latin, biblio, adresse.",
+    )
+    engine_label = labels.get("philo_engine_label", "Moteur")
+    global_label = labels.get("philo_global_label", "Global")
+    strict_label = labels.get("philo_strict_label", "Strict")
+    expansion_label = labels.get("philo_expansion_label", "Expansion")
+
+    all_cats: set[str] = set()
+    for eng in relevant:
+        all_cats.update(
+            eng["aggregated_philological"]["modern_archives"]
+            .get("per_category", {}).keys(),
+        )
+    cats = sorted(all_cats)
+
+    parts = [_section_open(title, note)]
+    parts.append(
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.85rem">'
+    )
+    parts.append("<thead><tr>")
+    parts.append(
+        f'<th scope=\"col\" rowspan="2" style="padding:.3rem .5rem;text-align:left;'
+        f'border-bottom:1px solid var(--border);font-weight:600">'
+        f'{_e(engine_label)}</th>'
+    )
+    parts.append(
+        f'<th scope=\"col\" colspan="2" style="padding:.3rem .5rem;text-align:center;'
+        f'border-bottom:1px solid var(--border);font-weight:600">'
+        f'{_e(global_label)}</th>'
+    )
+    for cat in cats:
+        parts.append(
+            f'<th scope=\"col\" colspan="2" style="padding:.3rem .5rem;text-align:center;'
+            f'border-bottom:1px solid var(--border);font-weight:600">'
+            f'{_e(cat)}</th>'
+        )
+    parts.append("</tr><tr>")
+    for _ in range(1 + len(cats)):
+        parts.append(
+            f'<th scope=\"col\" style="padding:.2rem .4rem;text-align:center;'
+            f'font-size:.75rem;font-weight:500;opacity:.7">'
+            f'{_e(strict_label)}</th>'
+        )
+        parts.append(
+            f'<th scope=\"col\" style="padding:.2rem .4rem;text-align:center;'
+            f'font-size:.75rem;font-weight:500;opacity:.7">'
+            f'{_e(expansion_label)}</th>'
+        )
+    parts.append("</tr></thead>")
+    parts.append("<tbody>")
+    for eng in relevant:
+        agg = eng["aggregated_philological"]["modern_archives"]
+        parts.append("<tr>")
+        parts.append(_engine_label_cell(eng["name"]))
+        parts.append(_score_cell(agg.get("global_strict_score", 0.0)))
+        parts.append(_score_cell(agg.get("global_expansion_score", 0.0)))
+        per_cat = agg.get("per_category", {})
+        for cat in cats:
+            stats = per_cat.get(cat)
+            if stats and stats.get("n_total", 0) > 0:
+                parts.append(_score_cell(
+                    stats["strict_score"],
+                    extra=f"n={stats['n_total']}",
+                ))
+                parts.append(_score_cell(stats["expansion_score"]))
+            else:
+                parts.append(_score_cell(None))
+                parts.append(_score_cell(None))
+        parts.append("</tr>")
+    parts.append("</tbody>")
+    parts.append(_table_close())
+    parts.append(_section_close())
+    return "".join(parts)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Sprint 60 — Numéraux romains : breakdown 5 statuts
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def build_roman_numerals_section(
+    engines_summary: list[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    relevant = _engines_with_module(engines_summary, "roman_numerals")
+    if not relevant:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "philo_roman_numerals_title",
+        "Numéraux romains : restitution par statut",
+    )
+    note = labels.get(
+        "philo_roman_numerals_note",
+        "Pour chaque numéral romain de la GT, statut de restitution : "
+        "strict (forme exacte), case_changed (casse modifiée), "
+        "j_dropped (j médiéval normalisé), converted_to_arabic, lost. "
+        "Le breakdown indique la convention : majoritaire strict → "
+        "diplomatique ; majoritaire arabic → modernisation profonde.",
+    )
+    engine_label = labels.get("philo_engine_label", "Moteur")
+    n_label = labels.get("philo_n_total_label", "n total")
+
+    statuses = (
+        "strict_preserved", "case_changed", "j_dropped",
+        "converted_to_arabic", "lost",
+    )
+    status_labels = {
+        s: labels.get(f"philo_roman_status_{s}", s) for s in statuses
+    }
+
+    parts = [_section_open(title, note), _table_open()]
+    parts.append(_table_header(
+        [n_label] + [status_labels[s] for s in statuses],
+        engine_label,
+    ))
+    parts.append("<tbody>")
+    for eng in relevant:
+        agg = eng["aggregated_philological"]["roman_numerals"]
+        n_total = agg.get("n_numerals_reference", 0)
+        per_status = agg.get("per_status", {})
+        parts.append("<tr>")
+        parts.append(_engine_label_cell(eng["name"]))
+        parts.append(
+            f'<td style="padding:.3rem .5rem;text-align:center">'
+            f'{n_total}</td>'
+        )
+        for status in statuses:
+            count = per_status.get(status, 0)
+            if n_total > 0:
+                ratio = count / n_total
+                # Pour « lost » on inverse la couleur (un haut taux
+                # de perte est mauvais).  Pour les autres on garde
+                # la sémantique « plus c'est haut, plus l'OCR a
+                # adopté ce statut ».
+                color = (
+                    color_traffic_light(1.0 - ratio) if status == "lost"
+                    else color_traffic_light(ratio)
+                )
+                parts.append(
+                    f'<td style="padding:.3rem .5rem;text-align:center;'
+                    f'background:{color}">{count} '
+                    f'<span style="opacity:.6;font-size:.85em">'
+                    f'({ratio * 100:.0f}%)</span></td>'
+                )
+            else:
+                parts.append(_score_cell(None))
+        parts.append("</tr>")
+    parts.append("</tbody>")
+    parts.append(_table_close())
+    parts.append(_section_close())
+    return "".join(parts)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Agrégateur principal
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def build_philological_profile_html(
+    engines_summary: list[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Assemble les six sections en un bloc unique.
+
+    Retourne ``""`` si aucune section n'a de contenu (c.-à-d.
+    aucun moteur n'a de signal philologique sur le corpus).
+    """
+    sections = [
+        build_unicode_blocks_section(engines_summary, labels),
+        build_abbreviations_section(engines_summary, labels),
+        build_mufi_section(engines_summary, labels),
+        build_early_modern_section(engines_summary, labels),
+        build_modern_archives_section(engines_summary, labels),
+        build_roman_numerals_section(engines_summary, labels),
+    ]
+    non_empty = [s for s in sections if s]
+    if not non_empty:
+        return ""
+    labels = labels or {}
+    main_title = labels.get(
+        "philo_profile_title", "Profil philologique",
+    )
+    main_note = labels.get(
+        "philo_profile_note",
+        "Données brutes par catégorie de marqueur philologique. "
+        "L'outil ne classifie pas la convention adoptée par chaque "
+        "moteur — c'est au chercheur de lire les chiffres et de "
+        "conclure selon ses critères éditoriaux.",
+    )
+    parts = [
+        '<div class="philological-profile">',
+        f'<h3 style="margin-top:0">{_e(main_title)}</h3>',
+        f'<p style="font-size:.85rem;opacity:.8;margin-bottom:.5rem">'
+        f'{_e(main_note)}</p>',
+    ]
+    parts.extend(non_empty)
+    parts.append("</div>")
+    return "".join(parts)
+
+
+__all__ = [
+    "build_philological_profile_html",
+    "build_unicode_blocks_section",
+    "build_abbreviations_section",
+    "build_mufi_section",
+    "build_early_modern_section",
+    "build_modern_archives_section",
+    "build_roman_numerals_section",
+]

tests/architecture/test_file_budgets.py

@@ -58,7 +58,10 @@ FILE_BUDGETS: dict[str, int] = {
     # même budget pour la même raison historique (modèles
     # BenchmarkResult/EngineReport/DocumentResult).
     "picarones/evaluation/benchmark_result.py": 750,      # actuel 702
-    "picarones/report/philological_render.py": 700,       # actuel 595 (rétréci)
+    # Phase 5.C : ``report/philological_render.py`` est désormais
+    # un shim (≤ 25 l).  Le contenu canonique vit dans
+    # ``reports_v2/html/renderers/philological.py``.
+    "picarones/reports_v2/html/renderers/philological.py": 700,  # actuel 601
     "picarones/measurements/history.py": 725,             # actuel 615
     "picarones/measurements/modern_archives.py": 700,     # actuel 599
     "picarones/measurements/builtin_hooks.py": 700,       # actuel 590

tests/report/test_sprint62_philological_html.py

@@ -22,7 +22,7 @@ from __future__ import annotations
 import json
 from pathlib import Path
 
-from picarones.report.philological_render import (
+from picarones.reports_v2.html.renderers.philological import (
     build_abbreviations_section,
     build_early_modern_section,
     build_modern_archives_section,

tests/report/test_sprint82_levers.py

@@ -31,7 +31,7 @@ from picarones.measurements.levers import (
     detect_robustness_projection_observation,
     iter_lever_detectors,
 )
-from picarones.report.levers_render import build_levers_section_html
+from picarones.reports_v2.html.renderers.levers import build_levers_section_html
 
 
 # ──────────────────────────────────────────────────────────────────────────
@@ -435,7 +435,7 @@ class TestRender:
         """
         import logging
 
-        from picarones.report import levers_render
+        from picarones.reports_v2.html.renderers import levers as levers_render
 
         # Patche un des formatters pour qu'il lève une exception
         original = levers_render._FORMATTERS.copy()
@@ -453,7 +453,10 @@ class TestRender:
             "importance": 40,
             "payload": {"foo": "bar"},
         }
-        with caplog.at_level(logging.WARNING, logger="picarones.report.levers_render"):
+        with caplog.at_level(
+            logging.WARNING,
+            logger="picarones.reports_v2.html.renderers.levers",
+        ):
             html = build_levers_section_html([d], _load_labels("fr"))
 
         # 1. Le levier cassé est omis (HTML ne le contient pas).