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

Cinquième vague. Inclut les 3 renderers de la famille
``taxonomy``, ``worst_lines`` et ``pipeline_dag``.

Migrations effectuées
---------------------
| Source legacy | Destination canonique |
|-------------------------------------------------|------------------------------------------------------|
| ``report/taxonomy_intra_doc_render.py`` (148) | ``reports_v2/html/renderers/taxonomy_intra_doc.py`` |
| ``report/taxonomy_cooccurrence_render.py`` (161)| ``reports_v2/html/renderers/taxonomy_cooccurrence.py``|
| ``report/worst_lines_render.py`` (164) | ``reports_v2/html/renderers/worst_lines.py`` |
| ``report/taxonomy_comparison_render.py`` (233) | ``reports_v2/html/renderers/taxonomy_comparison.py`` |
| ``report/pipeline_dag_render.py`` (314) | ``reports_v2/html/renderers/pipeline_dag.py`` |

Total : ~1020 lignes relocalisées. 5 nouveaux shims minimaux.

Adaptations transverses
-----------------------
- ``reports_v2/html/renderers/worst_lines.py`` :
- import ``WorstLineEntry`` redirigé vers
``picarones.evaluation.metrics.worst_lines``
- import ``compute_char_diff`` redirigé vers
``picarones.evaluation`` (au lieu de
``picarones.core.diff_utils``, rejeté par la règle
layer-dependencies sur ``reports_v2``).

Cumul Phase 5.C (batches 1-5) : 25 renderers migrés. Reste
3 renderers : ``levers`` (284 l), ``pipeline_render`` (707 l),
``philological_render`` (595 l). Au total ~1586 LOC pour le
batch 6 (XXL + restants).

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

https://claude.ai/code/session_011XQZNitg1rCgia8ZD1a2hP

docs/migration/legacy-retirement-plan.md

@@ -694,11 +694,9 @@ architecture vérifiée.
 - Batch 2 ✅ (cf. ci-dessous) — 5 renderers (45-165 LOC).
 - Batch 3 ✅ (cf. ci-dessous) — 5 renderers (173-222 LOC).
 - Batch 4 ✅ (cf. ci-dessous) — 5 renderers (188-321 LOC).
-- Batch 5 (les 2 restants + plus gros) : ``calibration``,
-  ``worst_lines``, ``levers``, ``taxonomy_*`` (3 fichiers),
-  ``pipeline_dag``.
-- Batch 6 (les XXL) : ``pipeline_render`` (707 l),
-  ``philological_render`` (595 l).
+- 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).
 - Phase 5.D : 5 vues (``views/*.py``).
 - Phase 5.E : ``generator.py``, ``comparison.py``,
   ``snapshot.py``, ``report_data/``, templates Jinja2.
@@ -812,6 +810,49 @@ architecture vérifiée.
 et ``philological_render`` (595 l) — les XXL — auront leur propre
 batch dédié.
 
+#### Phase 5.C.batch5 — Lot 5 : 5 renderers moyens-gros (2026-05)
+
+Cinquième vague.  Inclut les 3 renderers de la famille
+``taxonomy``, ``worst_lines`` et ``pipeline_dag``.  Restera ensuite
+batch 6 (XXL + ``levers``) et la migration des 5 vues
+(``views/*.py``).
+
+**Migrations effectuées** :
+
+| Source legacy                                   | Destination canonique                                |
+|-------------------------------------------------|------------------------------------------------------|
+| ``report/taxonomy_intra_doc_render.py`` (148)   | ``reports_v2/html/renderers/taxonomy_intra_doc.py``  |
+| ``report/taxonomy_cooccurrence_render.py`` (161)| ``reports_v2/html/renderers/taxonomy_cooccurrence.py``|
+| ``report/worst_lines_render.py`` (164)          | ``reports_v2/html/renderers/worst_lines.py``         |
+| ``report/taxonomy_comparison_render.py`` (233)  | ``reports_v2/html/renderers/taxonomy_comparison.py`` |
+| ``report/pipeline_dag_render.py`` (314)         | ``reports_v2/html/renderers/pipeline_dag.py``        |
+
+Total : ~1020 lignes relocalisées.
+
+**Adaptations transverses** :
+
+- ``reports_v2/html/renderers/worst_lines.py`` :
+  - import ``WorstLineEntry`` redirigé vers
+    ``picarones.evaluation.metrics.worst_lines``
+  - import ``compute_char_diff`` redirigé vers
+    ``picarones.evaluation`` (au lieu de ``picarones.core.diff_utils``,
+    rejeté par la règle layer-dependencies sur ``reports_v2``).
+
+**Cumul Phase 5.C** (batches 1+2+3+4+5) : 20 + 5 = **25 renderers
+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 6 — Pipelines OCR+LLM (`pipelines/`)
 
 **Modules** : `pipelines/base.OCRLLMPipeline` (3 modes), `pipelines/

picarones/report/generator.py

@@ -316,10 +316,10 @@ class ReportGenerator:
         from picarones.reports_v2.html.renderers.rare_token_recall import (
             build_rare_token_recall_html,
         )
-        from picarones.report.taxonomy_cooccurrence_render import (
+        from picarones.reports_v2.html.renderers.taxonomy_cooccurrence import (
             build_taxonomy_cooccurrence_html,
         )
-        from picarones.report.taxonomy_intra_doc_render import (
+        from picarones.reports_v2.html.renderers.taxonomy_intra_doc import (
             build_taxonomy_intra_doc_html,
         )
 

picarones/report/pipeline_dag_render.py

@@ -1,314 +1,18 @@
-"""Visualisation DAG d'un pipeline composé — Sprint 95 (B.4).
+"""``picarones.report.pipeline_dag_render`` — shim re-export (déprécié, suppression 2.0).
 
-Sprint 95 — B.4 du plan d'évolution 2026.
-
-Outil d'inspection, pas de construction
----------------------------------------
-Le YAML reste source de vérité.  Cette vue **affiche** le
-graphe orienté de la pipeline pour permettre l'inspection et
-le debug d'un benchmark d'axe B (Sprint 63+) — elle ne
-construit rien, ne supporte pas le drag-and-drop, n'exporte
-aucun JSON modifiable.
-
-Pattern identique aux autres rendus : SVG **server-side**,
-pas de JS, anti-injection systématique.
-
-Vue
----
-Layout horizontal de gauche à droite :
-
-- Chaque **nœud** est un rectangle annoté du nom du module et
-  de ses types d'entrée/sortie.
-- Chaque **arête** porte une étiquette : type d'artefact +
-  métrique principale + valeur, avec un code couleur
-  vert/jaune/rouge selon le seuil sur la valeur.
-
-Adaptive : ``""`` si moins d'un nœud.
-
-Note d'intégration
-------------------
-Module pur — l'utilisateur compose les structures simples
-``nodes`` et ``edges`` depuis sa ``PipelineSpec`` (Sprint 63)
-et son ``PipelineBenchmarkResult`` (Sprint 64) :
-
-.. code-block:: python
-
-    from picarones.report.pipeline_dag_render import build_pipeline_dag_html
-
-    nodes = [
-        {"name": s.name, "input_types": [t.value for t in s.module.input_types],
-         "output_types": [t.value for t in s.module.output_types]}
-        for s in spec.steps
-    ]
-    edges = []
-    for prev, curr in zip(spec.steps, spec.steps[1:]):
-        agg = bench.aggregate_for_step(curr.name)
-        for art_type, metrics in (agg.junction_metrics or {}).items():
-            for metric_name, value in metrics.items():
-                edges.append({
-                    "from": prev.name, "to": curr.name,
-                    "artifact_type": art_type, "metric_name": metric_name,
-                    "metric_value": value.get("mean"),
-                })
-    html = build_pipeline_dag_html(nodes, edges, labels)
+Canonique : :mod:`picarones.reports_v2.html.renderers.pipeline_dag`.
+Phase 5.C du retrait du legacy.
 """
 
 from __future__ import annotations
 
-from html import escape as _e
-from typing import Optional
-
-
-# Seuils par défaut sur les métriques d'erreur (CER-like, lower is better).
-_DEFAULT_THRESHOLDS = (0.05, 0.15)  # vert ≤ 0.05, jaune ≤ 0.15, rouge > 0.15
-
-
-def _classify_metric(
-    value: Optional[float],
-    thresholds: tuple[float, float],
-    higher_is_better: bool,
-) -> str:
-    """Retourne ``"green"``, ``"yellow"``, ``"red"`` ou ``"none"``."""
-    if value is None:
-        return "none"
-    try:
-        v = float(value)
-    except (TypeError, ValueError):
-        return "none"
-    low, high = thresholds
-    if higher_is_better:
-        # Inversion : haut = bon
-        if v >= 1.0 - low:
-            return "green"
-        if v >= 1.0 - high:
-            return "yellow"
-        return "red"
-    if v <= low:
-        return "green"
-    if v <= high:
-        return "yellow"
-    return "red"
-
-
-# Sprint A7 (m-5) — palette Okabe-Ito daltonien-friendly importée
-# depuis le module canonique ``picarones.report.colors``. Avant
-# A7, les hex étaient hardcodés (rouge/vert classiques, problème
-# pour la deutéranopie) ; maintenant cohérent avec _cer_color et
-# difficulty_color.
-from picarones.reports_v2._helpers.colors import COLOR_GREEN, COLOR_RED, COLOR_YELLOW
-
-_QUALITY_COLORS = {
-    "green":  COLOR_GREEN,    # Okabe-Ito blue (substitut sémantique « bon »)
-    "yellow": COLOR_YELLOW,   # Okabe-Ito yellow
-    "red":    COLOR_RED,      # Okabe-Ito vermillion (substitut sémantique « mauvais »)
-    "none":   "#6b7280",
-}
-
-
-def _format_value(value: Optional[float]) -> str:
-    if value is None:
-        return "—"
-    try:
-        v = float(value)
-    except (TypeError, ValueError):
-        return "—"
-    if abs(v) < 1.0:
-        return f"{v * 100:.1f}%"
-    return f"{v:.2f}"
-
-
-def build_pipeline_dag_html(
-    nodes: Optional[list[dict]],
-    labels: Optional[dict[str, str]] = None,
-    edges: Optional[list[dict]] = None,
-    *,
-    thresholds: tuple[float, float] = _DEFAULT_THRESHOLDS,
-    higher_is_better: bool = False,
-) -> str:
-    """Construit la vue HTML « Pipeline DAG ».
-
-    Parameters
-    ----------
-    nodes:
-        Liste de dicts ``{"name", "input_types"?, "output_types"?}``
-        dans l'ordre topologique.  Si vide ou ``None``, retourne
-        ``""``.
-    labels:
-        Dict i18n.  Clés sous le préfixe ``dag_*``.
-    edges:
-        Liste de dicts ``{"from", "to", "artifact_type"?,
-        "metric_name"?, "metric_value"?}``.  Optionnel —
-        auto-déduit séquentiel sinon.
-    thresholds:
-        ``(seuil_vert, seuil_jaune)`` sur la valeur de métrique.
-        Défaut ``(0.05, 0.15)`` — convention CER.
-    higher_is_better:
-        Si ``True``, la sémantique est inversée (1 = meilleur).
-    """
-    nodes = list(nodes or [])
-    if not nodes:
-        return ""
-    edges = list(edges or [])
-    labels = labels or {}
-    title = labels.get("dag_title", "Pipeline DAG")
-    note = labels.get(
-        "dag_note",
-        "Graphe orienté du pipeline composé. Chaque arête porte "
-        "le type d'artefact transmis et la métrique calculée à "
-        "la jonction. Code couleur vert/orange/rouge selon le "
-        "seuil. Outil d'inspection — le YAML reste source de "
-        "vérité.",
-    )
-    # Layout horizontal régulier
-    n = len(nodes)
-    box_width = 160
-    box_height = 70
-    h_gap = 110          # espace horizontal entre nœuds
-    margin = 30
-    svg_width = margin * 2 + n * box_width + (n - 1) * h_gap
-    svg_height = box_height + margin * 2 + 60  # +60 pour étiquettes arêtes
-    centre_y = margin + box_height / 2 + 30  # offset pour étiquette de tête
-
-    # Index des nœuds par name pour récupérer la position
-    node_x: dict[str, float] = {}
-    parts: list[str] = [
-        '<section class="dag-section" style="margin:1rem 0">',
-        f'<h3 style="margin:0 0 .3rem 0">{_e(title)}</h3>',
-        f'<div style="font-size:.85rem;opacity:.75;margin-bottom:.5rem">'
-        f'{_e(note)}</div>',
-        f'<svg viewBox="0 0 {svg_width} {svg_height}" '
-        f'role="img" aria-label="{_e(title)}" '
-        'xmlns="http://www.w3.org/2000/svg" '
-        'style="max-width:100%;height:auto;'
-        'font-family:system-ui,sans-serif;font-size:12px">',
-        # Définition d'une flèche
-        '<defs>'
-        '<marker id="arrow" viewBox="0 0 10 10" refX="9" refY="5" '
-        'markerWidth="6" markerHeight="6" orient="auto-start-reverse">'
-        '<path d="M0,0 L10,5 L0,10 z" fill="#374151"/>'
-        '</marker>'
-        '</defs>',
-    ]
-
-    # Étape 1 : nœuds
-    for i, node in enumerate(nodes):
-        name = str(node.get("name") or f"step_{i}")
-        x = margin + i * (box_width + h_gap)
-        y = margin + 30
-        node_x[name] = x + box_width
-        in_types = ", ".join(node.get("input_types") or [])
-        out_types = ", ".join(node.get("output_types") or [])
-        parts.append(
-            f'<rect x="{x}" y="{y}" width="{box_width}" '
-            f'height="{box_height}" rx="6" fill="#f3f4f6" '
-            f'stroke="#374151" stroke-width="1.5"/>'
-        )
-        parts.append(
-            f'<text x="{x + box_width / 2}" y="{y + 22}" '
-            f'text-anchor="middle" font-weight="600" '
-            f'fill="#111827">{_e(name)}</text>'
-        )
-        if in_types:
-            parts.append(
-                f'<text x="{x + box_width / 2}" y="{y + 40}" '
-                f'text-anchor="middle" fill="#4b5563" '
-                f'font-size="10">in: {_e(in_types)}</text>'
-            )
-        if out_types:
-            parts.append(
-                f'<text x="{x + box_width / 2}" y="{y + 56}" '
-                f'text-anchor="middle" fill="#4b5563" '
-                f'font-size="10">out: {_e(out_types)}</text>'
-            )
-
-    # Étape 2 : arêtes (mappées sur paires séquentielles si pas de
-    # "from"/"to" explicites — voir nodes par défaut)
-    auto_edges: list[dict] = []
-    if not edges:
-        for prev, curr in zip(nodes, nodes[1:]):
-            auto_edges.append({
-                "from": prev.get("name"),
-                "to": curr.get("name"),
-            })
-    else:
-        auto_edges = edges
-
-    for edge in auto_edges:
-        src = str(edge.get("from") or "")
-        dst = str(edge.get("to") or "")
-        if not src or not dst:
-            continue
-        # Position : du bord droit du src au bord gauche du dst
-        # Heuristique : on prend la position du nœud src dans la
-        # liste pour calculer x1, et celle de dst pour x2.
-        try:
-            i_src = next(
-                i for i, n_ in enumerate(nodes)
-                if n_.get("name") == src
-            )
-            i_dst = next(
-                i for i, n_ in enumerate(nodes)
-                if n_.get("name") == dst
-            )
-        except StopIteration:
-            continue
-        x1 = margin + i_src * (box_width + h_gap) + box_width
-        x2 = margin + i_dst * (box_width + h_gap)
-        y = centre_y
-        # Classe la métrique pour le code couleur
-        value = edge.get("metric_value")
-        try:
-            value_f = float(value) if value is not None else None
-        except (TypeError, ValueError):
-            value_f = None
-        cls = _classify_metric(value_f, thresholds, higher_is_better)
-        color = _QUALITY_COLORS[cls]
-        # Trace la flèche
-        parts.append(
-            f'<line x1="{x1}" y1="{y}" x2="{x2}" y2="{y}" '
-            f'stroke="{color}" stroke-width="2" '
-            f'marker-end="url(#arrow)"/>'
-        )
-        # Étiquette : type + métrique : valeur
-        artifact_type = edge.get("artifact_type") or ""
-        metric_name = edge.get("metric_name") or ""
-        value_str = _format_value(value_f)
-        label_lines: list[str] = []
-        if artifact_type:
-            label_lines.append(str(artifact_type))
-        if metric_name:
-            label_lines.append(f"{metric_name}: {value_str}")
-        if label_lines:
-            label_x = (x1 + x2) / 2
-            for k, line in enumerate(label_lines):
-                parts.append(
-                    f'<text x="{label_x}" y="{y - 8 - k * 12}" '
-                    f'text-anchor="middle" fill="{color}" '
-                    f'font-size="10" font-weight="600">'
-                    f'{_e(line)}</text>'
-                )
-    parts.append("</svg>")
-
-    # Légende
-    h_legend = labels.get("dag_legend", "Lecture")
-    legend_green = labels.get("dag_legend_green", "qualité élevée")
-    legend_yellow = labels.get("dag_legend_yellow", "qualité moyenne")
-    legend_red = labels.get("dag_legend_red", "qualité faible")
-    parts.append(
-        '<div style="font-size:.8rem;opacity:.75;margin-top:.4rem">'
-        f'<strong>{_e(h_legend)} :</strong> '
-        f'<span style="color:{_QUALITY_COLORS["green"]};'
-        f'font-weight:600">●</span> {_e(legend_green)} '
-        f'(≤ {thresholds[0] * 100:.0f}%) '
-        f'<span style="color:{_QUALITY_COLORS["yellow"]};'
-        f'font-weight:600">●</span> {_e(legend_yellow)} '
-        f'(≤ {thresholds[1] * 100:.0f}%) '
-        f'<span style="color:{_QUALITY_COLORS["red"]};'
-        f'font-weight:600">●</span> {_e(legend_red)}'
-        '</div>'
-    )
-    parts.append("</section>")
-    return "".join(parts)
+import warnings
 
+from picarones.reports_v2.html.renderers.pipeline_dag import *  # noqa: F401, F403
 
-__all__ = ["build_pipeline_dag_html"]
+warnings.warn(
+    "picarones.report.pipeline_dag_render is deprecated and will be removed in 2.0.  "
+    "Import from picarones.reports_v2.html.renderers.pipeline_dag instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)

picarones/report/taxonomy_comparison_render.py

@@ -1,233 +1,18 @@
-"""Rendu HTML du diagramme miroir taxonomique — Sprint 77.
+"""``picarones.report.taxonomy_comparison_render`` — shim re-export (déprécié, suppression 2.0).
 
-A.I.4 chantier 3 du plan d'évolution 2026.
-
-Suite directe ``picarones/core/taxonomy_comparison.py``.  Pattern
-identique aux autres rendus (Sprints 41/43/62/67/72/74/75/76) :
-**server-side**, pas de JavaScript, anti-injection systématique.
-
-Diagramme miroir
-----------------
-Une ligne par classe taxonomique, divisée en deux barres
-horizontales :
-
-- À **gauche** : barre du moteur A (orientée vers la gauche, du
-  centre vers le bord).
-- À **droite** : barre du moteur B (orientée vers la droite).
-- Couleur de la classe selon ``recoverability`` :
-
-  - vert (#5fa860) : ``recoverable``
-  - orange (#e0a050) : ``difficult``
-  - rouge (#d8553b) : ``irrecoverable``
-
-Lecture immédiate : un moteur dont les barres tirent vers la
-**gauche** sur du vert (case_error, ligature_error) et un moteur
-qui tire à droite sur du rouge (lacuna) — la décision éditoriale
-est évidente même si les CER globaux sont identiques.
+Canonique : :mod:`picarones.reports_v2.html.renderers.taxonomy_comparison`.
+Phase 5.C du retrait du legacy.
 """
 
 from __future__ import annotations
 
-from html import escape as _e
-from typing import Optional
-
-
-_RECOVERABILITY_COLORS = {
-    "recoverable":   "#5fa860",
-    "difficult":     "#e0a050",
-    "irrecoverable": "#d8553b",
-}
-
-
-def _build_mirror_chart_svg(
-    data: dict,
-    *,
-    bar_max_width: int = 200,
-    row_height: int = 22,
-    label_width: int = 140,
-    margin_top: int = 50,
-    margin_bottom: int = 20,
-) -> str:
-    """Construit le diagramme miroir SVG."""
-    classes = data["classes"]
-    prop_a = data["proportions_a"]
-    prop_b = data["proportions_b"]
-    recov = data["recoverability"]
-    engine_a = data["engine_a"]
-    engine_b = data["engine_b"]
-
-    n_rows = len(classes)
-    if n_rows == 0:
-        return ""
-
-    # Échelle : on normalise à la valeur max de toutes les
-    # proportions (pour que la classe la plus présente atteigne
-    # bar_max_width).
-    max_prop = max(
-        max(prop_a.values(), default=0.0),
-        max(prop_b.values(), default=0.0),
-    )
-    if max_prop <= 0:
-        max_prop = 1.0  # évite division par zéro (cas dégénéré)
-
-    width = label_width + 2 * bar_max_width + 40
-    height = margin_top + n_rows * row_height + margin_bottom
-    center = width // 2
-
-    parts = [
-        f'<svg xmlns="http://www.w3.org/2000/svg" '
-        f'width="{width}" height="{height}" '
-        f'viewBox="0 0 {width} {height}" '
-        f'role="img" aria-label="Diagramme miroir taxonomique">',
-        # En-têtes des deux moteurs
-        f'<text x="{center - bar_max_width // 2}" y="20" '
-        f'font-size="13" font-weight="600" fill="#333" '
-        f'text-anchor="middle">{_e(engine_a)}</text>',
-        f'<text x="{center + bar_max_width // 2}" y="20" '
-        f'font-size="13" font-weight="600" fill="#333" '
-        f'text-anchor="middle">{_e(engine_b)}</text>',
-        # Ligne centrale
-        f'<line x1="{center}" y1="{margin_top - 4}" '
-        f'x2="{center}" y2="{height - margin_bottom + 4}" '
-        f'stroke="#999" stroke-width="1"/>',
-    ]
-
-    # Barres
-    for i, cls in enumerate(classes):
-        y = margin_top + i * row_height
-        level = recov.get(cls, "difficult")
-        color = _RECOVERABILITY_COLORS.get(level, "#888")
-        # Étiquette de classe au centre
-        parts.append(
-            f'<text x="{center}" y="{y + row_height // 2 + 4}" '
-            f'font-size="11" fill="#222" text-anchor="middle" '
-            f'font-family="monospace">{_e(cls)}</text>'
-        )
-        # Barre A (gauche)
-        a_width = (prop_a.get(cls, 0.0) / max_prop) * bar_max_width
-        if a_width > 0:
-            x_a = center - label_width // 2 - a_width
-            parts.append(
-                f'<rect x="{x_a:.1f}" y="{y + 3}" '
-                f'width="{a_width:.1f}" height="{row_height - 6}" '
-                f'fill="{color}" stroke="#666" stroke-width="0.5" '
-                f'opacity="0.85"/>'
-            )
-            # Valeur en %
-            parts.append(
-                f'<text x="{x_a - 3:.1f}" y="{y + row_height // 2 + 4}" '
-                f'font-size="10" fill="#444" text-anchor="end">'
-                f'{prop_a.get(cls, 0.0) * 100:.1f}%</text>'
-            )
-        # Barre B (droite)
-        b_width = (prop_b.get(cls, 0.0) / max_prop) * bar_max_width
-        if b_width > 0:
-            x_b = center + label_width // 2
-            parts.append(
-                f'<rect x="{x_b:.1f}" y="{y + 3}" '
-                f'width="{b_width:.1f}" height="{row_height - 6}" '
-                f'fill="{color}" stroke="#666" stroke-width="0.5" '
-                f'opacity="0.85"/>'
-            )
-            parts.append(
-                f'<text x="{x_b + b_width + 3:.1f}" '
-                f'y="{y + row_height // 2 + 4}" '
-                f'font-size="10" fill="#444" text-anchor="start">'
-                f'{prop_b.get(cls, 0.0) * 100:.1f}%</text>'
-            )
-    parts.append("</svg>")
-    return "".join(parts)
-
-
-def _build_recoverability_summary_html(
-    data: dict, labels: dict,
-) -> str:
-    """Encart résumé par catégorie de récupérabilité (3 lignes)."""
-    totals = data.get("totals_by_recoverability") or {}
-    if not totals:
-        return ""
-    label_recov = labels.get("taxocomp_recoverable", "Récupérable")
-    label_diff = labels.get("taxocomp_difficult", "Difficile")
-    label_irrec = labels.get("taxocomp_irrecoverable", "Irrécupérable")
-    rows = [
-        ("recoverable", label_recov),
-        ("difficult", label_diff),
-        ("irrecoverable", label_irrec),
-    ]
-    parts = [
-        '<table style="border-collapse:collapse;font-size:.85rem;'
-        'margin-top:.5rem">',
-        '<thead><tr>',
-        '<th scope=\"col\" style="padding:.2rem .5rem;text-align:left;'
-        'border-bottom:1px solid #ccc">'
-        f'{_e(labels.get("taxocomp_level_label", "Catégorie"))}</th>',
-        '<th scope=\"col\" style="padding:.2rem .5rem;text-align:right;'
-        'border-bottom:1px solid #ccc">'
-        f'{_e(_e(data["engine_a"]))}</th>',
-        '<th scope=\"col\" style="padding:.2rem .5rem;text-align:right;'
-        'border-bottom:1px solid #ccc">'
-        f'{_e(_e(data["engine_b"]))}</th>',
-        '</tr></thead><tbody>',
-    ]
-    for level, label in rows:
-        cell = totals.get(level, {"a": 0.0, "b": 0.0})
-        color = _RECOVERABILITY_COLORS.get(level, "#888")
-        parts.append(
-            f'<tr>'
-            f'<td style="padding:.2rem .5rem">'
-            f'<span style="display:inline-block;width:10px;height:10px;'
-            f'background:{color};margin-right:.4rem;border-radius:2px"></span>'
-            f'{_e(label)}</td>'
-            f'<td style="padding:.2rem .5rem;text-align:right;'
-            f'font-family:monospace">{cell["a"] * 100:.1f}%</td>'
-            f'<td style="padding:.2rem .5rem;text-align:right;'
-            f'font-family:monospace">{cell["b"] * 100:.1f}%</td>'
-            f'</tr>'
-        )
-    parts.append("</tbody></table>")
-    return "".join(parts)
-
-
-def build_taxonomy_comparison_html(
-    data: Optional[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Construit le bloc HTML de comparaison taxonomique entre 2 moteurs.
-
-    Retourne ``""`` si ``data is None`` ou aucune classe.
-    """
-    if not data:
-        return ""
-    classes = data.get("classes") or []
-    if not classes:
-        return ""
-    labels = labels or {}
-    title_template = labels.get(
-        "taxocomp_title", "Profil taxonomique : {engine_a} vs {engine_b}",
-    )
-    title = title_template.format(
-        engine_a=data["engine_a"], engine_b=data["engine_b"],
-    )
-    note = labels.get(
-        "taxocomp_note",
-        "Diagramme miroir des proportions d'erreurs par classe. "
-        "Couleur selon récupérabilité éditoriale (vert = corrigeable, "
-        "rouge = irrécupérable). À CER global égal, un moteur dont les "
-        "erreurs sont majoritairement vertes est préférable pour une "
-        "édition critique.",
-    )
-    parts = [
-        '<div class="taxocomp" 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>',
-        _build_mirror_chart_svg(data),
-        _build_recoverability_summary_html(data, labels),
-        "</div>",
-    ]
-    return "".join(parts)
+import warnings
 
+from picarones.reports_v2.html.renderers.taxonomy_comparison import *  # noqa: F401, F403
 
-__all__ = [
-    "build_taxonomy_comparison_html",
-]
+warnings.warn(
+    "picarones.report.taxonomy_comparison_render is deprecated and will be removed in 2.0.  "
+    "Import from picarones.reports_v2.html.renderers.taxonomy_comparison instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)

picarones/report/taxonomy_cooccurrence_render.py

@@ -1,161 +1,18 @@
-"""Rendu HTML de la heatmap de co-occurrence taxonomique — Sprint 75.
+"""``picarones.report.taxonomy_cooccurrence_render`` — shim re-export (déprécié, suppression 2.0).
 
-A.I.4 chantier 1 du plan d'évolution 2026.
-
-Suite directe ``picarones/core/taxonomy_cooccurrence.py``.  Pattern
-identique aux autres rendus (Sprints 41/43/62/67/72/74) :
-**server-side**, pas de JavaScript, anti-injection systématique.
-
-Sortie typique
---------------
-- ``build_taxonomy_cooccurrence_html(data, labels)`` produit un
-  bloc complet : titre + note d'usage + heatmap SVG + table des
-  paires les plus co-occurrentes.
-- ``""`` retourné si ``data is None`` ou si la matrice est vide
-  (rapport adaptatif).
+Canonique : :mod:`picarones.reports_v2.html.renderers.taxonomy_cooccurrence`.
+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 (
-    GRADIENT_TARGET_BLUE,
-    build_grid_svg,
-    color_single_gradient,
-    text_color_for_bg,
-)
-
-
-def _build_jaccard_heatmap_svg(
-    classes: list[str],
-    matrix: dict[str, dict[str, float]],
-    *,
-    cell_size: int = 36,
-    label_left: int = 130,
-    label_top: int = 80,
-) -> str:
-    """Heatmap Jaccard de co-occurrence taxonomique.
-
-    Délègue à :func:`build_grid_svg` ; reste un wrapper local qui
-    encapsule les conventions spécifiques à la matrice symétrique
-    (valeur affichée seulement si > 0,05, étiquettes rotées).
-    """
-    if not classes:
-        return ""
-
-    def cell_value(i: int, j: int) -> float:
-        return matrix.get(classes[i], {}).get(classes[j], 0.0)
-
-    return build_grid_svg(
-        n_rows=len(classes),
-        n_cols=len(classes),
-        row_label_fn=lambda i: classes[i],
-        col_label_fn=lambda j: classes[j],
-        cell_color_fn=lambda i, j: color_single_gradient(
-            cell_value(i, j), end_rgb=GRADIENT_TARGET_BLUE,
-        ),
-        cell_text_fn=lambda i, j: (
-            f"{cell_value(i, j):.2f}" if cell_value(i, j) > 0.05 else None
-        ),
-        cell_text_color_fn=lambda i, j: text_color_for_bg(cell_value(i, j)),
-        cell_w=cell_size,
-        cell_h=cell_size,
-        label_left=label_left,
-        label_top=label_top,
-        rotate_col_labels=True,
-        aria_label="Heatmap Jaccard co-occurrence taxonomique",
-    )
+import warnings
 
+from picarones.reports_v2.html.renderers.taxonomy_cooccurrence import *  # noqa: F401, F403
 
-def _build_top_pairs_table(
-    top_pairs: list,
-    labels: dict,
-) -> str:
-    """Construit la table HTML des paires les plus co-occurrentes."""
-    if not top_pairs:
-        return ""
-    pair_label = labels.get("taxocooc_pair_label", "Paire")
-    jaccard_label = labels.get("taxocooc_jaccard_label", "Jaccard")
-
-    parts = [
-        '<table style="border-collapse:collapse;font-size:.85rem;'
-        'margin-top:.5rem">',
-        '<thead><tr>',
-        f'<th scope=\"col\" style="padding:.3rem .5rem;text-align:left;'
-        f'border-bottom:1px solid #ccc;font-weight:600">'
-        f'{_e(pair_label)}</th>',
-        f'<th scope=\"col\" style="padding:.3rem .5rem;text-align:right;'
-        f'border-bottom:1px solid #ccc;font-weight:600">'
-        f'{_e(jaccard_label)}</th>',
-        '</tr></thead><tbody>',
-    ]
-    for ca, cb, j in top_pairs:
-        parts.append(
-            f'<tr>'
-            f'<td style="padding:.2rem .5rem">'
-            f'<code>{_e(ca)}</code> ↔ <code>{_e(cb)}</code></td>'
-            f'<td style="padding:.2rem .5rem;text-align:right;'
-            f'font-family:monospace;'
-            f'background:{color_single_gradient(j, end_rgb=GRADIENT_TARGET_BLUE)};'
-            f'color:{text_color_for_bg(j)}">{j:.2f}</td>'
-            f'</tr>'
-        )
-    parts.append("</tbody></table>")
-    return "".join(parts)
-
-
-def build_taxonomy_cooccurrence_html(
-    data: Optional[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Construit le bloc HTML complet de co-occurrence taxonomique.
-
-    Retourne ``""`` si ``data is None`` ou matrice vide.
-    """
-    if not data:
-        return ""
-    classes = data.get("classes") or []
-    matrix = data.get("cooccurrence_matrix") or {}
-    if not classes or not matrix:
-        return ""
-    labels = labels or {}
-    title = labels.get(
-        "taxocooc_title",
-        "Co-occurrence des classes d'erreur",
-    )
-    note = labels.get(
-        "taxocooc_note",
-        "Indice de Jaccard au niveau document : 1,00 = ces deux classes "
-        "apparaissent toujours ensemble ; 0,00 = jamais. Lecture par paires "
-        "co-occurrentes ci-dessous.",
-    )
-    n_docs = data.get("n_documents", 0)
-    n_docs_label_template = labels.get(
-        "taxocooc_n_docs", "Calculé sur {n_docs} documents.",
-    )
-    n_docs_phrase = n_docs_label_template.format(n_docs=n_docs)
-
-    svg = _build_jaccard_heatmap_svg(classes, matrix)
-    top_table = _build_top_pairs_table(
-        data.get("top_pairs") or [], labels,
-    )
-
-    parts = [
-        '<div class="taxocooc" 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>',
-        f'<div style="font-size:.8rem;opacity:.7;margin-bottom:.5rem">'
-        f'{_e(n_docs_phrase)}</div>',
-        svg,
-        top_table,
-        "</div>",
-    ]
-    return "".join(parts)
-
-
-__all__ = [
-    "build_taxonomy_cooccurrence_html",
-]
+warnings.warn(
+    "picarones.report.taxonomy_cooccurrence_render is deprecated and will be removed in 2.0.  "
+    "Import from picarones.reports_v2.html.renderers.taxonomy_cooccurrence instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)

picarones/report/taxonomy_intra_doc_render.py

@@ -1,148 +1,18 @@
-"""Rendu HTML de la heatmap class × position — Sprint 76.
+"""``picarones.report.taxonomy_intra_doc_render`` — shim re-export (déprécié, suppression 2.0).
 
-A.I.4 chantier 2 du plan d'évolution 2026.
-
-Suite directe ``picarones/core/taxonomy_intra_doc.py``.  Pattern
-identique aux autres rendus (Sprints 41/43/62/67/72/74/75) :
-**server-side**, pas de JavaScript, anti-injection systématique.
-
-Sortie typique
---------------
-Une grille N_classes × N_bins où chaque cellule indique la densité
-d'erreurs de cette classe à cette position dans le document.
-Lecture immédiate : « ligature_error concentré dans la première
-tranche → erreur de marge ; visual_confusion uniformément réparti
-→ erreur de scribe ».
-
-Adaptive : si ``data is None`` ou si toutes les classes ont 0
-erreur, retourne ``""``.
+Canonique : :mod:`picarones.reports_v2.html.renderers.taxonomy_intra_doc`.
+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 (
-    GRADIENT_TARGET_ORANGE,
-    build_grid_svg,
-    color_single_gradient,
-    text_color_for_bg,
-)
-
-
-def _build_position_heatmap_svg(
-    classes_with_errors: list[str],
-    per_class: dict[str, list[int]],
-    n_bins: int,
-    *,
-    cell_w: int = 36,
-    cell_h: int = 26,
-    label_left: int = 150,
-    label_top: int = 30,
-) -> str:
-    """Heatmap class taxonomique × position (densité relative par classe).
-
-    Délègue à :func:`build_grid_svg` ; reste un wrapper local qui
-    encapsule la normalisation par classe (densité relative au max
-    observé sur la ligne).
-    """
-    if not classes_with_errors:
-        return ""
-
-    # Pré-calcule densité et count par cellule pour éviter les boucles
-    # imbriquées dans les callbacks.
-    grid: list[list[tuple[int, float]]] = []
-    for cls in classes_with_errors:
-        counts = per_class.get(cls, [0] * n_bins)
-        max_count = max(counts) if counts else 0
-        row: list[tuple[int, float]] = []
-        for j in range(n_bins):
-            count = counts[j] if j < len(counts) else 0
-            density = (count / max_count) if max_count > 0 else 0.0
-            row.append((count, density))
-        grid.append(row)
+import warnings
 
-    return build_grid_svg(
-        n_rows=len(classes_with_errors),
-        n_cols=n_bins,
-        row_label_fn=lambda i: classes_with_errors[i],
-        col_label_fn=lambda j: str(j + 1),
-        cell_color_fn=lambda i, j: color_single_gradient(
-            grid[i][j][1], end_rgb=GRADIENT_TARGET_ORANGE,
-        ),
-        cell_text_fn=lambda i, j: (
-            str(grid[i][j][0]) if grid[i][j][0] > 0 else None
-        ),
-        cell_text_color_fn=lambda i, j: text_color_for_bg(grid[i][j][1]),
-        cell_w=cell_w,
-        cell_h=cell_h,
-        label_left=label_left,
-        label_top=label_top,
-        aria_label="Heatmap class taxonomique × position",
-        x_axis_title="Position dans le document (1 = début)",
-    )
+from picarones.reports_v2.html.renderers.taxonomy_intra_doc import *  # noqa: F401, F403
 
-
-def build_taxonomy_intra_doc_html(
-    data: Optional[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Construit le bloc HTML complet de la heatmap intra-document.
-
-    Retourne ``""`` si ``data is None`` ou aucune erreur.
-    """
-    if not data:
-        return ""
-    n_bins = data.get("n_bins", 0)
-    per_class = data.get("per_class") or {}
-    total_errors = data.get("total_errors", 0)
-    if total_errors == 0 or n_bins <= 0:
-        return ""
-    # Filtre : uniquement les classes ayant au moins une erreur
-    classes_with_errors = [
-        cls for cls, counts in per_class.items()
-        if isinstance(counts, list) and sum(counts) > 0
-    ]
-    if not classes_with_errors:
-        return ""
-
-    labels = labels or {}
-    title = labels.get(
-        "intradoc_title",
-        "Évolution intra-document des classes d'erreur",
-    )
-    note = labels.get(
-        "intradoc_note",
-        "Heatmap class × position : densité relative par classe "
-        "(plus foncé = concentré). Une classe concentrée dans la "
-        "première colonne suggère une erreur de marge ; "
-        "une distribution uniforme suggère une erreur de scribe.",
-    )
-    n_words_gt = data.get("n_words_gt", 0)
-    n_words_template = labels.get(
-        "intradoc_n_words",
-        "Calculé sur {n_words_gt} mots GT, répartis en {n_bins} tranches.",
-    )
-    n_words_phrase = n_words_template.format(
-        n_words_gt=n_words_gt, n_bins=n_bins,
-    )
-
-    svg = _build_position_heatmap_svg(classes_with_errors, per_class, n_bins)
-
-    parts = [
-        '<div class="intradoc" 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>',
-        f'<div style="font-size:.8rem;opacity:.7;margin-bottom:.5rem">'
-        f'{_e(n_words_phrase)}</div>',
-        svg,
-        "</div>",
-    ]
-    return "".join(parts)
-
-
-__all__ = [
-    "build_taxonomy_intra_doc_html",
-]
+warnings.warn(
+    "picarones.report.taxonomy_intra_doc_render is deprecated and will be removed in 2.0.  "
+    "Import from picarones.reports_v2.html.renderers.taxonomy_intra_doc instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)

picarones/report/views/advanced_taxonomy.py

@@ -136,7 +136,7 @@ def build_advanced_taxonomy_view_html(
         pair = _select_two_engines_for_comparison(engines_summary)
         if pair is not None:
             from picarones.measurements.taxonomy_comparison import compare_taxonomies
-            from picarones.report.taxonomy_comparison_render import (
+            from picarones.reports_v2.html.renderers.taxonomy_comparison import (
                 build_taxonomy_comparison_html,
             )
             engine_a, engine_b = pair
@@ -163,7 +163,7 @@ def build_advanced_taxonomy_view_html(
     # Sous-section 2 : co-occurrence (opt-in)
     if cooccurrence:
         try:
-            from picarones.report.taxonomy_cooccurrence_render import (
+            from picarones.reports_v2.html.renderers.taxonomy_cooccurrence import (
                 build_taxonomy_cooccurrence_html,
             )
             html = build_taxonomy_cooccurrence_html(cooccurrence, labels=labels)
@@ -183,7 +183,7 @@ def build_advanced_taxonomy_view_html(
     # Sous-section 3 : intra-document (opt-in)
     if intra_doc:
         try:
-            from picarones.report.taxonomy_intra_doc_render import (
+            from picarones.reports_v2.html.renderers.taxonomy_intra_doc import (
                 build_taxonomy_intra_doc_html,
             )
             html = build_taxonomy_intra_doc_html(intra_doc, labels=labels)

picarones/report/views/diagnostics.py

@@ -206,7 +206,7 @@ def build_diagnostics_view_html(
     if benchmark is not None:
         try:
             from picarones.measurements.worst_lines import extract_worst_lines
-            from picarones.report.worst_lines_render import (
+            from picarones.reports_v2.html.renderers.worst_lines import (
                 build_worst_lines_table_html,
             )
             entries = extract_worst_lines(benchmark, top_n=20)

picarones/report/views/pipeline.py

@@ -124,7 +124,7 @@ def build_pipeline_view_html(
     # Sous-section 2 : DAG visualization
     if dag_nodes:
         try:
-            from picarones.report.pipeline_dag_render import (
+            from picarones.reports_v2.html.renderers.pipeline_dag import (
                 build_pipeline_dag_html,
             )
             html = build_pipeline_dag_html(

picarones/report/worst_lines_render.py

@@ -1,164 +1,18 @@
-"""Rendu HTML de la vue « Worst lines globale » — Sprint 72.
+"""``picarones.report.worst_lines_render`` — shim re-export (déprécié, suppression 2.0).
 
-Suite directe de ``picarones/core/worst_lines.py`` (extraction
-transversale).  Pattern identique aux Sprints 41/43/62/67 : rendu
-**server-side**, pas de JavaScript, anti-injection systématique
-via ``html.escape``.
-
-Vue distincte du tableau gallery existant
------------------------------------------
-La galerie OCR (vue ``view_gallery.html``) liste les documents
-les plus problématiques.  Cette vue va plus fin : elle liste les
-**lignes individuelles** les plus problématiques, transversalement
-à tous les documents et moteurs.  Complémentaire, pas redondante.
+Canonique : :mod:`picarones.reports_v2.html.renderers.worst_lines`.
+Phase 5.C du retrait du legacy.
 """
 
 from __future__ import annotations
 
-from html import escape as _e
-from typing import Optional
-
-from picarones.measurements.worst_lines import WorstLineEntry
-from picarones.core.diff_utils import compute_char_diff
-from picarones.reports_v2._helpers.render_helpers import color_traffic_light
-
-
-def _bg_for_cer(cer: float) -> str:
-    """Beige clair sous le seuil catastrophique (0.30), gradient
-    jaune → rouge au-delà.
-
-    Le seuil dur à 0.30 préserve la sémantique « toléré jusqu'à 30 %
-    pour un manuscrit difficile ». Au-delà, on entre en zone visible
-    avec :func:`color_traffic_light` (low_is_good).
-    """
-    f = max(0.0, min(1.0, cer))
-    if f < 0.3:
-        return "#fff8dc"
-    return color_traffic_light(f, low_is_good=True, scale_min=0.3, scale_max=1.0)
-
-
-def _render_diff_inline(reference: str, hypothesis: str) -> str:
-    """Rendu HTML inline d'un diff caractère par caractère.
-
-    - ``equal``   → texte normal
-    - ``delete``  → fond rouge clair, barré (manquait dans hyp)
-    - ``insert``  → fond vert clair (ajouté par hyp)
-    - ``replace`` → fond rouge clair barré + fond vert clair pour
-      la nouvelle valeur (côte à côte)
-    """
-    if not reference and not hypothesis:
-        return '<span style="opacity:.5">∅</span>'
-    ops = compute_char_diff(reference or "", hypothesis or "")
-    parts: list[str] = []
-    for op in ops:
-        kind = op["op"]
-        if kind == "equal":
-            parts.append(_e(op["text"]))
-        elif kind == "delete":
-            parts.append(
-                f'<span style="background:#fdd;text-decoration:line-through">'
-                f'{_e(op["text"])}</span>'
-            )
-        elif kind == "insert":
-            parts.append(
-                f'<span style="background:#dfd">{_e(op["text"])}</span>'
-            )
-        elif kind == "replace":
-            parts.append(
-                f'<span style="background:#fdd;text-decoration:line-through">'
-                f'{_e(op["old"])}</span>'
-                f'<span style="background:#dfd">{_e(op["new"])}</span>'
-            )
-    return "".join(parts)
-
-
-def build_worst_lines_table_html(
-    entries: list[WorstLineEntry],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Construit le tableau HTML des worst lines.
-
-    Retourne ``""`` si la liste est vide.  Adaptive : si aucune
-    entrée n'a de ``script_type``, la colonne strate est omise.
-    """
-    if not entries:
-        return ""
-    labels = labels or {}
-    title = labels.get("worst_lines_title", "Lignes les plus problématiques")
-    note = labels.get(
-        "worst_lines_note",
-        "Top-N lignes du corpus classées par CER ligne décroissant. "
-        "Diff caractère par caractère : rouge barré = manquant dans "
-        "l'OCR, vert = ajouté par l'OCR.",
-    )
-    rank_label = labels.get("worst_lines_rank_label", "Rang")
-    cer_label = labels.get("worst_lines_cer_label", "CER")
-    engine_label = labels.get("worst_lines_engine_label", "Moteur")
-    doc_label = labels.get("worst_lines_doc_label", "Document")
-    line_label = labels.get("worst_lines_line_label", "Ligne #")
-    strata_label = labels.get("worst_lines_strata_label", "Strate")
-    diff_label = labels.get("worst_lines_diff_label", "GT → OCR (diff)")
-
-    has_strata = any(e.script_type for e in entries)
-
-    parts = [
-        '<div class="worst-lines" style="margin:1rem 0">',
-        f'<div style="font-weight:600;margin-bottom:.4rem">{_e(title)}</div>',
-        f'<div style="font-size:.8rem;opacity:.75;margin-bottom:.5rem">'
-        f'{_e(note)}</div>',
-        '<table style="border-collapse:collapse;width:100%;'
-        'font-size:.85rem">',
-        '<thead><tr>',
-    ]
-    cols = [rank_label, cer_label, engine_label, doc_label, line_label]
-    if has_strata:
-        cols.append(strata_label)
-    cols.append(diff_label)
-    for col in cols:
-        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 entry in entries:
-        cer_color = _bg_for_cer(entry.cer)
-        parts.append("<tr>")
-        parts.append(
-            f'<td style="padding:.3rem .5rem;text-align:right;'
-            f'font-weight:600">{entry.rank}</td>'
-        )
-        parts.append(
-            f'<td style="padding:.3rem .5rem;text-align:right;'
-            f'background:{cer_color};font-family:monospace">'
-            f'{entry.cer * 100:.1f}%</td>'
-        )
-        parts.append(
-            f'<td style="padding:.3rem .5rem">{_e(entry.engine_name)}</td>'
-        )
-        parts.append(
-            f'<td style="padding:.3rem .5rem;font-family:monospace;'
-            f'font-size:.8rem">{_e(entry.doc_id)}</td>'
-        )
-        parts.append(
-            f'<td style="padding:.3rem .5rem;text-align:right">'
-            f'{entry.line_index}</td>'
-        )
-        if has_strata:
-            parts.append(
-                f'<td style="padding:.3rem .5rem;font-size:.8rem">'
-                f'{_e(entry.script_type or "—")}</td>'
-            )
-        parts.append(
-            f'<td style="padding:.3rem .5rem;font-family:monospace;'
-            f'font-size:.85rem">'
-            f'{_render_diff_inline(entry.gt_line, entry.hyp_line)}</td>'
-        )
-        parts.append("</tr>")
-    parts.append("</tbody></table></div>")
-    return "".join(parts)
+import warnings
 
+from picarones.reports_v2.html.renderers.worst_lines import *  # noqa: F401, F403
 
-__all__ = [
-    "build_worst_lines_table_html",
-]
+warnings.warn(
+    "picarones.report.worst_lines_render is deprecated and will be removed in 2.0.  "
+    "Import from picarones.reports_v2.html.renderers.worst_lines instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)

picarones/reports_v2/html/renderers/pipeline_dag.py

@@ -0,0 +1,320 @@
+"""Visualisation DAG d'un pipeline composé — Sprint 95 (B.4).
+
+Phase 5.C — module relocalisé depuis
+``picarones.report.pipeline_dag_render`` vers
+``picarones.reports_v2.html.renderers.pipeline_dag``.  Le chemin
+legacy reste disponible via un shim avec ``DeprecationWarning`` ;
+suppression prévue en 2.0.
+
+Sprint 95 — B.4 du plan d'évolution 2026.
+
+Outil d'inspection, pas de construction
+---------------------------------------
+Le YAML reste source de vérité.  Cette vue **affiche** le
+graphe orienté de la pipeline pour permettre l'inspection et
+le debug d'un benchmark d'axe B (Sprint 63+) — elle ne
+construit rien, ne supporte pas le drag-and-drop, n'exporte
+aucun JSON modifiable.
+
+Pattern identique aux autres rendus : SVG **server-side**,
+pas de JS, anti-injection systématique.
+
+Vue
+---
+Layout horizontal de gauche à droite :
+
+- Chaque **nœud** est un rectangle annoté du nom du module et
+  de ses types d'entrée/sortie.
+- Chaque **arête** porte une étiquette : type d'artefact +
+  métrique principale + valeur, avec un code couleur
+  vert/jaune/rouge selon le seuil sur la valeur.
+
+Adaptive : ``""`` si moins d'un nœud.
+
+Note d'intégration
+------------------
+Module pur — l'utilisateur compose les structures simples
+``nodes`` et ``edges`` depuis sa ``PipelineSpec`` (Sprint 63)
+et son ``PipelineBenchmarkResult`` (Sprint 64) :
+
+.. code-block:: python
+
+    from picarones.reports_v2.html.renderers.pipeline_dag import build_pipeline_dag_html
+
+    nodes = [
+        {"name": s.name, "input_types": [t.value for t in s.module.input_types],
+         "output_types": [t.value for t in s.module.output_types]}
+        for s in spec.steps
+    ]
+    edges = []
+    for prev, curr in zip(spec.steps, spec.steps[1:]):
+        agg = bench.aggregate_for_step(curr.name)
+        for art_type, metrics in (agg.junction_metrics or {}).items():
+            for metric_name, value in metrics.items():
+                edges.append({
+                    "from": prev.name, "to": curr.name,
+                    "artifact_type": art_type, "metric_name": metric_name,
+                    "metric_value": value.get("mean"),
+                })
+    html = build_pipeline_dag_html(nodes, edges, labels)
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+
+# Seuils par défaut sur les métriques d'erreur (CER-like, lower is better).
+_DEFAULT_THRESHOLDS = (0.05, 0.15)  # vert ≤ 0.05, jaune ≤ 0.15, rouge > 0.15
+
+
+def _classify_metric(
+    value: Optional[float],
+    thresholds: tuple[float, float],
+    higher_is_better: bool,
+) -> str:
+    """Retourne ``"green"``, ``"yellow"``, ``"red"`` ou ``"none"``."""
+    if value is None:
+        return "none"
+    try:
+        v = float(value)
+    except (TypeError, ValueError):
+        return "none"
+    low, high = thresholds
+    if higher_is_better:
+        # Inversion : haut = bon
+        if v >= 1.0 - low:
+            return "green"
+        if v >= 1.0 - high:
+            return "yellow"
+        return "red"
+    if v <= low:
+        return "green"
+    if v <= high:
+        return "yellow"
+    return "red"
+
+
+# Sprint A7 (m-5) — palette Okabe-Ito daltonien-friendly importée
+# depuis le module canonique ``picarones.report.colors``. Avant
+# A7, les hex étaient hardcodés (rouge/vert classiques, problème
+# pour la deutéranopie) ; maintenant cohérent avec _cer_color et
+# difficulty_color.
+from picarones.reports_v2._helpers.colors import COLOR_GREEN, COLOR_RED, COLOR_YELLOW
+
+_QUALITY_COLORS = {
+    "green":  COLOR_GREEN,    # Okabe-Ito blue (substitut sémantique « bon »)
+    "yellow": COLOR_YELLOW,   # Okabe-Ito yellow
+    "red":    COLOR_RED,      # Okabe-Ito vermillion (substitut sémantique « mauvais »)
+    "none":   "#6b7280",
+}
+
+
+def _format_value(value: Optional[float]) -> str:
+    if value is None:
+        return "—"
+    try:
+        v = float(value)
+    except (TypeError, ValueError):
+        return "—"
+    if abs(v) < 1.0:
+        return f"{v * 100:.1f}%"
+    return f"{v:.2f}"
+
+
+def build_pipeline_dag_html(
+    nodes: Optional[list[dict]],
+    labels: Optional[dict[str, str]] = None,
+    edges: Optional[list[dict]] = None,
+    *,
+    thresholds: tuple[float, float] = _DEFAULT_THRESHOLDS,
+    higher_is_better: bool = False,
+) -> str:
+    """Construit la vue HTML « Pipeline DAG ».
+
+    Parameters
+    ----------
+    nodes:
+        Liste de dicts ``{"name", "input_types"?, "output_types"?}``
+        dans l'ordre topologique.  Si vide ou ``None``, retourne
+        ``""``.
+    labels:
+        Dict i18n.  Clés sous le préfixe ``dag_*``.
+    edges:
+        Liste de dicts ``{"from", "to", "artifact_type"?,
+        "metric_name"?, "metric_value"?}``.  Optionnel —
+        auto-déduit séquentiel sinon.
+    thresholds:
+        ``(seuil_vert, seuil_jaune)`` sur la valeur de métrique.
+        Défaut ``(0.05, 0.15)`` — convention CER.
+    higher_is_better:
+        Si ``True``, la sémantique est inversée (1 = meilleur).
+    """
+    nodes = list(nodes or [])
+    if not nodes:
+        return ""
+    edges = list(edges or [])
+    labels = labels or {}
+    title = labels.get("dag_title", "Pipeline DAG")
+    note = labels.get(
+        "dag_note",
+        "Graphe orienté du pipeline composé. Chaque arête porte "
+        "le type d'artefact transmis et la métrique calculée à "
+        "la jonction. Code couleur vert/orange/rouge selon le "
+        "seuil. Outil d'inspection — le YAML reste source de "
+        "vérité.",
+    )
+    # Layout horizontal régulier
+    n = len(nodes)
+    box_width = 160
+    box_height = 70
+    h_gap = 110          # espace horizontal entre nœuds
+    margin = 30
+    svg_width = margin * 2 + n * box_width + (n - 1) * h_gap
+    svg_height = box_height + margin * 2 + 60  # +60 pour étiquettes arêtes
+    centre_y = margin + box_height / 2 + 30  # offset pour étiquette de tête
+
+    # Index des nœuds par name pour récupérer la position
+    node_x: dict[str, float] = {}
+    parts: list[str] = [
+        '<section class="dag-section" style="margin:1rem 0">',
+        f'<h3 style="margin:0 0 .3rem 0">{_e(title)}</h3>',
+        f'<div style="font-size:.85rem;opacity:.75;margin-bottom:.5rem">'
+        f'{_e(note)}</div>',
+        f'<svg viewBox="0 0 {svg_width} {svg_height}" '
+        f'role="img" aria-label="{_e(title)}" '
+        'xmlns="http://www.w3.org/2000/svg" '
+        'style="max-width:100%;height:auto;'
+        'font-family:system-ui,sans-serif;font-size:12px">',
+        # Définition d'une flèche
+        '<defs>'
+        '<marker id="arrow" viewBox="0 0 10 10" refX="9" refY="5" '
+        'markerWidth="6" markerHeight="6" orient="auto-start-reverse">'
+        '<path d="M0,0 L10,5 L0,10 z" fill="#374151"/>'
+        '</marker>'
+        '</defs>',
+    ]
+
+    # Étape 1 : nœuds
+    for i, node in enumerate(nodes):
+        name = str(node.get("name") or f"step_{i}")
+        x = margin + i * (box_width + h_gap)
+        y = margin + 30
+        node_x[name] = x + box_width
+        in_types = ", ".join(node.get("input_types") or [])
+        out_types = ", ".join(node.get("output_types") or [])
+        parts.append(
+            f'<rect x="{x}" y="{y}" width="{box_width}" '
+            f'height="{box_height}" rx="6" fill="#f3f4f6" '
+            f'stroke="#374151" stroke-width="1.5"/>'
+        )
+        parts.append(
+            f'<text x="{x + box_width / 2}" y="{y + 22}" '
+            f'text-anchor="middle" font-weight="600" '
+            f'fill="#111827">{_e(name)}</text>'
+        )
+        if in_types:
+            parts.append(
+                f'<text x="{x + box_width / 2}" y="{y + 40}" '
+                f'text-anchor="middle" fill="#4b5563" '
+                f'font-size="10">in: {_e(in_types)}</text>'
+            )
+        if out_types:
+            parts.append(
+                f'<text x="{x + box_width / 2}" y="{y + 56}" '
+                f'text-anchor="middle" fill="#4b5563" '
+                f'font-size="10">out: {_e(out_types)}</text>'
+            )
+
+    # Étape 2 : arêtes (mappées sur paires séquentielles si pas de
+    # "from"/"to" explicites — voir nodes par défaut)
+    auto_edges: list[dict] = []
+    if not edges:
+        for prev, curr in zip(nodes, nodes[1:]):
+            auto_edges.append({
+                "from": prev.get("name"),
+                "to": curr.get("name"),
+            })
+    else:
+        auto_edges = edges
+
+    for edge in auto_edges:
+        src = str(edge.get("from") or "")
+        dst = str(edge.get("to") or "")
+        if not src or not dst:
+            continue
+        # Position : du bord droit du src au bord gauche du dst
+        # Heuristique : on prend la position du nœud src dans la
+        # liste pour calculer x1, et celle de dst pour x2.
+        try:
+            i_src = next(
+                i for i, n_ in enumerate(nodes)
+                if n_.get("name") == src
+            )
+            i_dst = next(
+                i for i, n_ in enumerate(nodes)
+                if n_.get("name") == dst
+            )
+        except StopIteration:
+            continue
+        x1 = margin + i_src * (box_width + h_gap) + box_width
+        x2 = margin + i_dst * (box_width + h_gap)
+        y = centre_y
+        # Classe la métrique pour le code couleur
+        value = edge.get("metric_value")
+        try:
+            value_f = float(value) if value is not None else None
+        except (TypeError, ValueError):
+            value_f = None
+        cls = _classify_metric(value_f, thresholds, higher_is_better)
+        color = _QUALITY_COLORS[cls]
+        # Trace la flèche
+        parts.append(
+            f'<line x1="{x1}" y1="{y}" x2="{x2}" y2="{y}" '
+            f'stroke="{color}" stroke-width="2" '
+            f'marker-end="url(#arrow)"/>'
+        )
+        # Étiquette : type + métrique : valeur
+        artifact_type = edge.get("artifact_type") or ""
+        metric_name = edge.get("metric_name") or ""
+        value_str = _format_value(value_f)
+        label_lines: list[str] = []
+        if artifact_type:
+            label_lines.append(str(artifact_type))
+        if metric_name:
+            label_lines.append(f"{metric_name}: {value_str}")
+        if label_lines:
+            label_x = (x1 + x2) / 2
+            for k, line in enumerate(label_lines):
+                parts.append(
+                    f'<text x="{label_x}" y="{y - 8 - k * 12}" '
+                    f'text-anchor="middle" fill="{color}" '
+                    f'font-size="10" font-weight="600">'
+                    f'{_e(line)}</text>'
+                )
+    parts.append("</svg>")
+
+    # Légende
+    h_legend = labels.get("dag_legend", "Lecture")
+    legend_green = labels.get("dag_legend_green", "qualité élevée")
+    legend_yellow = labels.get("dag_legend_yellow", "qualité moyenne")
+    legend_red = labels.get("dag_legend_red", "qualité faible")
+    parts.append(
+        '<div style="font-size:.8rem;opacity:.75;margin-top:.4rem">'
+        f'<strong>{_e(h_legend)} :</strong> '
+        f'<span style="color:{_QUALITY_COLORS["green"]};'
+        f'font-weight:600">●</span> {_e(legend_green)} '
+        f'(≤ {thresholds[0] * 100:.0f}%) '
+        f'<span style="color:{_QUALITY_COLORS["yellow"]};'
+        f'font-weight:600">●</span> {_e(legend_yellow)} '
+        f'(≤ {thresholds[1] * 100:.0f}%) '
+        f'<span style="color:{_QUALITY_COLORS["red"]};'
+        f'font-weight:600">●</span> {_e(legend_red)}'
+        '</div>'
+    )
+    parts.append("</section>")
+    return "".join(parts)
+
+
+__all__ = ["build_pipeline_dag_html"]

picarones/reports_v2/html/renderers/taxonomy_comparison.py

@@ -0,0 +1,239 @@
+"""Rendu HTML du diagramme miroir taxonomique — Sprint 77.
+
+Phase 5.C — module relocalisé depuis
+``picarones.report.taxonomy_comparison_render`` vers
+``picarones.reports_v2.html.renderers.taxonomy_comparison``.
+Le chemin legacy reste disponible via un shim avec
+``DeprecationWarning`` ; suppression prévue en 2.0.
+
+A.I.4 chantier 3 du plan d'évolution 2026.
+
+Suite directe ``picarones/core/taxonomy_comparison.py``.  Pattern
+identique aux autres rendus (Sprints 41/43/62/67/72/74/75/76) :
+**server-side**, pas de JavaScript, anti-injection systématique.
+
+Diagramme miroir
+----------------
+Une ligne par classe taxonomique, divisée en deux barres
+horizontales :
+
+- À **gauche** : barre du moteur A (orientée vers la gauche, du
+  centre vers le bord).
+- À **droite** : barre du moteur B (orientée vers la droite).
+- Couleur de la classe selon ``recoverability`` :
+
+  - vert (#5fa860) : ``recoverable``
+  - orange (#e0a050) : ``difficult``
+  - rouge (#d8553b) : ``irrecoverable``
+
+Lecture immédiate : un moteur dont les barres tirent vers la
+**gauche** sur du vert (case_error, ligature_error) et un moteur
+qui tire à droite sur du rouge (lacuna) — la décision éditoriale
+est évidente même si les CER globaux sont identiques.
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+
+_RECOVERABILITY_COLORS = {
+    "recoverable":   "#5fa860",
+    "difficult":     "#e0a050",
+    "irrecoverable": "#d8553b",
+}
+
+
+def _build_mirror_chart_svg(
+    data: dict,
+    *,
+    bar_max_width: int = 200,
+    row_height: int = 22,
+    label_width: int = 140,
+    margin_top: int = 50,
+    margin_bottom: int = 20,
+) -> str:
+    """Construit le diagramme miroir SVG."""
+    classes = data["classes"]
+    prop_a = data["proportions_a"]
+    prop_b = data["proportions_b"]
+    recov = data["recoverability"]
+    engine_a = data["engine_a"]
+    engine_b = data["engine_b"]
+
+    n_rows = len(classes)
+    if n_rows == 0:
+        return ""
+
+    # Échelle : on normalise à la valeur max de toutes les
+    # proportions (pour que la classe la plus présente atteigne
+    # bar_max_width).
+    max_prop = max(
+        max(prop_a.values(), default=0.0),
+        max(prop_b.values(), default=0.0),
+    )
+    if max_prop <= 0:
+        max_prop = 1.0  # évite division par zéro (cas dégénéré)
+
+    width = label_width + 2 * bar_max_width + 40
+    height = margin_top + n_rows * row_height + margin_bottom
+    center = width // 2
+
+    parts = [
+        f'<svg xmlns="http://www.w3.org/2000/svg" '
+        f'width="{width}" height="{height}" '
+        f'viewBox="0 0 {width} {height}" '
+        f'role="img" aria-label="Diagramme miroir taxonomique">',
+        # En-têtes des deux moteurs
+        f'<text x="{center - bar_max_width // 2}" y="20" '
+        f'font-size="13" font-weight="600" fill="#333" '
+        f'text-anchor="middle">{_e(engine_a)}</text>',
+        f'<text x="{center + bar_max_width // 2}" y="20" '
+        f'font-size="13" font-weight="600" fill="#333" '
+        f'text-anchor="middle">{_e(engine_b)}</text>',
+        # Ligne centrale
+        f'<line x1="{center}" y1="{margin_top - 4}" '
+        f'x2="{center}" y2="{height - margin_bottom + 4}" '
+        f'stroke="#999" stroke-width="1"/>',
+    ]
+
+    # Barres
+    for i, cls in enumerate(classes):
+        y = margin_top + i * row_height
+        level = recov.get(cls, "difficult")
+        color = _RECOVERABILITY_COLORS.get(level, "#888")
+        # Étiquette de classe au centre
+        parts.append(
+            f'<text x="{center}" y="{y + row_height // 2 + 4}" '
+            f'font-size="11" fill="#222" text-anchor="middle" '
+            f'font-family="monospace">{_e(cls)}</text>'
+        )
+        # Barre A (gauche)
+        a_width = (prop_a.get(cls, 0.0) / max_prop) * bar_max_width
+        if a_width > 0:
+            x_a = center - label_width // 2 - a_width
+            parts.append(
+                f'<rect x="{x_a:.1f}" y="{y + 3}" '
+                f'width="{a_width:.1f}" height="{row_height - 6}" '
+                f'fill="{color}" stroke="#666" stroke-width="0.5" '
+                f'opacity="0.85"/>'
+            )
+            # Valeur en %
+            parts.append(
+                f'<text x="{x_a - 3:.1f}" y="{y + row_height // 2 + 4}" '
+                f'font-size="10" fill="#444" text-anchor="end">'
+                f'{prop_a.get(cls, 0.0) * 100:.1f}%</text>'
+            )
+        # Barre B (droite)
+        b_width = (prop_b.get(cls, 0.0) / max_prop) * bar_max_width
+        if b_width > 0:
+            x_b = center + label_width // 2
+            parts.append(
+                f'<rect x="{x_b:.1f}" y="{y + 3}" '
+                f'width="{b_width:.1f}" height="{row_height - 6}" '
+                f'fill="{color}" stroke="#666" stroke-width="0.5" '
+                f'opacity="0.85"/>'
+            )
+            parts.append(
+                f'<text x="{x_b + b_width + 3:.1f}" '
+                f'y="{y + row_height // 2 + 4}" '
+                f'font-size="10" fill="#444" text-anchor="start">'
+                f'{prop_b.get(cls, 0.0) * 100:.1f}%</text>'
+            )
+    parts.append("</svg>")
+    return "".join(parts)
+
+
+def _build_recoverability_summary_html(
+    data: dict, labels: dict,
+) -> str:
+    """Encart résumé par catégorie de récupérabilité (3 lignes)."""
+    totals = data.get("totals_by_recoverability") or {}
+    if not totals:
+        return ""
+    label_recov = labels.get("taxocomp_recoverable", "Récupérable")
+    label_diff = labels.get("taxocomp_difficult", "Difficile")
+    label_irrec = labels.get("taxocomp_irrecoverable", "Irrécupérable")
+    rows = [
+        ("recoverable", label_recov),
+        ("difficult", label_diff),
+        ("irrecoverable", label_irrec),
+    ]
+    parts = [
+        '<table style="border-collapse:collapse;font-size:.85rem;'
+        'margin-top:.5rem">',
+        '<thead><tr>',
+        '<th scope=\"col\" style="padding:.2rem .5rem;text-align:left;'
+        'border-bottom:1px solid #ccc">'
+        f'{_e(labels.get("taxocomp_level_label", "Catégorie"))}</th>',
+        '<th scope=\"col\" style="padding:.2rem .5rem;text-align:right;'
+        'border-bottom:1px solid #ccc">'
+        f'{_e(_e(data["engine_a"]))}</th>',
+        '<th scope=\"col\" style="padding:.2rem .5rem;text-align:right;'
+        'border-bottom:1px solid #ccc">'
+        f'{_e(_e(data["engine_b"]))}</th>',
+        '</tr></thead><tbody>',
+    ]
+    for level, label in rows:
+        cell = totals.get(level, {"a": 0.0, "b": 0.0})
+        color = _RECOVERABILITY_COLORS.get(level, "#888")
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.2rem .5rem">'
+            f'<span style="display:inline-block;width:10px;height:10px;'
+            f'background:{color};margin-right:.4rem;border-radius:2px"></span>'
+            f'{_e(label)}</td>'
+            f'<td style="padding:.2rem .5rem;text-align:right;'
+            f'font-family:monospace">{cell["a"] * 100:.1f}%</td>'
+            f'<td style="padding:.2rem .5rem;text-align:right;'
+            f'font-family:monospace">{cell["b"] * 100:.1f}%</td>'
+            f'</tr>'
+        )
+    parts.append("</tbody></table>")
+    return "".join(parts)
+
+
+def build_taxonomy_comparison_html(
+    data: Optional[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit le bloc HTML de comparaison taxonomique entre 2 moteurs.
+
+    Retourne ``""`` si ``data is None`` ou aucune classe.
+    """
+    if not data:
+        return ""
+    classes = data.get("classes") or []
+    if not classes:
+        return ""
+    labels = labels or {}
+    title_template = labels.get(
+        "taxocomp_title", "Profil taxonomique : {engine_a} vs {engine_b}",
+    )
+    title = title_template.format(
+        engine_a=data["engine_a"], engine_b=data["engine_b"],
+    )
+    note = labels.get(
+        "taxocomp_note",
+        "Diagramme miroir des proportions d'erreurs par classe. "
+        "Couleur selon récupérabilité éditoriale (vert = corrigeable, "
+        "rouge = irrécupérable). À CER global égal, un moteur dont les "
+        "erreurs sont majoritairement vertes est préférable pour une "
+        "édition critique.",
+    )
+    parts = [
+        '<div class="taxocomp" 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>',
+        _build_mirror_chart_svg(data),
+        _build_recoverability_summary_html(data, labels),
+        "</div>",
+    ]
+    return "".join(parts)
+
+
+__all__ = [
+    "build_taxonomy_comparison_html",
+]

picarones/reports_v2/html/renderers/taxonomy_cooccurrence.py

@@ -0,0 +1,167 @@
+"""Rendu HTML de la heatmap de co-occurrence taxonomique — Sprint 75.
+
+Phase 5.C — module relocalisé depuis
+``picarones.report.taxonomy_cooccurrence_render`` vers
+``picarones.reports_v2.html.renderers.taxonomy_cooccurrence``.
+Le chemin legacy reste disponible via un shim avec
+``DeprecationWarning`` ; suppression prévue en 2.0.
+
+A.I.4 chantier 1 du plan d'évolution 2026.
+
+Suite directe ``picarones/core/taxonomy_cooccurrence.py``.  Pattern
+identique aux autres rendus (Sprints 41/43/62/67/72/74) :
+**server-side**, pas de JavaScript, anti-injection systématique.
+
+Sortie typique
+--------------
+- ``build_taxonomy_cooccurrence_html(data, labels)`` produit un
+  bloc complet : titre + note d'usage + heatmap SVG + table des
+  paires les plus co-occurrentes.
+- ``""`` retourné si ``data is None`` ou si la matrice est vide
+  (rapport adaptatif).
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+from picarones.reports_v2._helpers.render_helpers import (
+    GRADIENT_TARGET_BLUE,
+    build_grid_svg,
+    color_single_gradient,
+    text_color_for_bg,
+)
+
+
+def _build_jaccard_heatmap_svg(
+    classes: list[str],
+    matrix: dict[str, dict[str, float]],
+    *,
+    cell_size: int = 36,
+    label_left: int = 130,
+    label_top: int = 80,
+) -> str:
+    """Heatmap Jaccard de co-occurrence taxonomique.
+
+    Délègue à :func:`build_grid_svg` ; reste un wrapper local qui
+    encapsule les conventions spécifiques à la matrice symétrique
+    (valeur affichée seulement si > 0,05, étiquettes rotées).
+    """
+    if not classes:
+        return ""
+
+    def cell_value(i: int, j: int) -> float:
+        return matrix.get(classes[i], {}).get(classes[j], 0.0)
+
+    return build_grid_svg(
+        n_rows=len(classes),
+        n_cols=len(classes),
+        row_label_fn=lambda i: classes[i],
+        col_label_fn=lambda j: classes[j],
+        cell_color_fn=lambda i, j: color_single_gradient(
+            cell_value(i, j), end_rgb=GRADIENT_TARGET_BLUE,
+        ),
+        cell_text_fn=lambda i, j: (
+            f"{cell_value(i, j):.2f}" if cell_value(i, j) > 0.05 else None
+        ),
+        cell_text_color_fn=lambda i, j: text_color_for_bg(cell_value(i, j)),
+        cell_w=cell_size,
+        cell_h=cell_size,
+        label_left=label_left,
+        label_top=label_top,
+        rotate_col_labels=True,
+        aria_label="Heatmap Jaccard co-occurrence taxonomique",
+    )
+
+
+def _build_top_pairs_table(
+    top_pairs: list,
+    labels: dict,
+) -> str:
+    """Construit la table HTML des paires les plus co-occurrentes."""
+    if not top_pairs:
+        return ""
+    pair_label = labels.get("taxocooc_pair_label", "Paire")
+    jaccard_label = labels.get("taxocooc_jaccard_label", "Jaccard")
+
+    parts = [
+        '<table style="border-collapse:collapse;font-size:.85rem;'
+        'margin-top:.5rem">',
+        '<thead><tr>',
+        f'<th scope=\"col\" style="padding:.3rem .5rem;text-align:left;'
+        f'border-bottom:1px solid #ccc;font-weight:600">'
+        f'{_e(pair_label)}</th>',
+        f'<th scope=\"col\" style="padding:.3rem .5rem;text-align:right;'
+        f'border-bottom:1px solid #ccc;font-weight:600">'
+        f'{_e(jaccard_label)}</th>',
+        '</tr></thead><tbody>',
+    ]
+    for ca, cb, j in top_pairs:
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.2rem .5rem">'
+            f'<code>{_e(ca)}</code> ↔ <code>{_e(cb)}</code></td>'
+            f'<td style="padding:.2rem .5rem;text-align:right;'
+            f'font-family:monospace;'
+            f'background:{color_single_gradient(j, end_rgb=GRADIENT_TARGET_BLUE)};'
+            f'color:{text_color_for_bg(j)}">{j:.2f}</td>'
+            f'</tr>'
+        )
+    parts.append("</tbody></table>")
+    return "".join(parts)
+
+
+def build_taxonomy_cooccurrence_html(
+    data: Optional[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit le bloc HTML complet de co-occurrence taxonomique.
+
+    Retourne ``""`` si ``data is None`` ou matrice vide.
+    """
+    if not data:
+        return ""
+    classes = data.get("classes") or []
+    matrix = data.get("cooccurrence_matrix") or {}
+    if not classes or not matrix:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "taxocooc_title",
+        "Co-occurrence des classes d'erreur",
+    )
+    note = labels.get(
+        "taxocooc_note",
+        "Indice de Jaccard au niveau document : 1,00 = ces deux classes "
+        "apparaissent toujours ensemble ; 0,00 = jamais. Lecture par paires "
+        "co-occurrentes ci-dessous.",
+    )
+    n_docs = data.get("n_documents", 0)
+    n_docs_label_template = labels.get(
+        "taxocooc_n_docs", "Calculé sur {n_docs} documents.",
+    )
+    n_docs_phrase = n_docs_label_template.format(n_docs=n_docs)
+
+    svg = _build_jaccard_heatmap_svg(classes, matrix)
+    top_table = _build_top_pairs_table(
+        data.get("top_pairs") or [], labels,
+    )
+
+    parts = [
+        '<div class="taxocooc" 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>',
+        f'<div style="font-size:.8rem;opacity:.7;margin-bottom:.5rem">'
+        f'{_e(n_docs_phrase)}</div>',
+        svg,
+        top_table,
+        "</div>",
+    ]
+    return "".join(parts)
+
+
+__all__ = [
+    "build_taxonomy_cooccurrence_html",
+]

picarones/reports_v2/html/renderers/taxonomy_intra_doc.py

@@ -0,0 +1,154 @@
+"""Rendu HTML de la heatmap class × position — Sprint 76.
+
+Phase 5.C — module relocalisé depuis
+``picarones.report.taxonomy_intra_doc_render`` vers
+``picarones.reports_v2.html.renderers.taxonomy_intra_doc``.  Le chemin
+legacy reste disponible via un shim avec ``DeprecationWarning`` ;
+suppression prévue en 2.0.
+
+A.I.4 chantier 2 du plan d'évolution 2026.
+
+Suite directe ``picarones/core/taxonomy_intra_doc.py``.  Pattern
+identique aux autres rendus (Sprints 41/43/62/67/72/74/75) :
+**server-side**, pas de JavaScript, anti-injection systématique.
+
+Sortie typique
+--------------
+Une grille N_classes × N_bins où chaque cellule indique la densité
+d'erreurs de cette classe à cette position dans le document.
+Lecture immédiate : « ligature_error concentré dans la première
+tranche → erreur de marge ; visual_confusion uniformément réparti
+→ erreur de scribe ».
+
+Adaptive : si ``data is None`` ou si toutes les classes ont 0
+erreur, retourne ``""``.
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+from picarones.reports_v2._helpers.render_helpers import (
+    GRADIENT_TARGET_ORANGE,
+    build_grid_svg,
+    color_single_gradient,
+    text_color_for_bg,
+)
+
+
+def _build_position_heatmap_svg(
+    classes_with_errors: list[str],
+    per_class: dict[str, list[int]],
+    n_bins: int,
+    *,
+    cell_w: int = 36,
+    cell_h: int = 26,
+    label_left: int = 150,
+    label_top: int = 30,
+) -> str:
+    """Heatmap class taxonomique × position (densité relative par classe).
+
+    Délègue à :func:`build_grid_svg` ; reste un wrapper local qui
+    encapsule la normalisation par classe (densité relative au max
+    observé sur la ligne).
+    """
+    if not classes_with_errors:
+        return ""
+
+    # Pré-calcule densité et count par cellule pour éviter les boucles
+    # imbriquées dans les callbacks.
+    grid: list[list[tuple[int, float]]] = []
+    for cls in classes_with_errors:
+        counts = per_class.get(cls, [0] * n_bins)
+        max_count = max(counts) if counts else 0
+        row: list[tuple[int, float]] = []
+        for j in range(n_bins):
+            count = counts[j] if j < len(counts) else 0
+            density = (count / max_count) if max_count > 0 else 0.0
+            row.append((count, density))
+        grid.append(row)
+
+    return build_grid_svg(
+        n_rows=len(classes_with_errors),
+        n_cols=n_bins,
+        row_label_fn=lambda i: classes_with_errors[i],
+        col_label_fn=lambda j: str(j + 1),
+        cell_color_fn=lambda i, j: color_single_gradient(
+            grid[i][j][1], end_rgb=GRADIENT_TARGET_ORANGE,
+        ),
+        cell_text_fn=lambda i, j: (
+            str(grid[i][j][0]) if grid[i][j][0] > 0 else None
+        ),
+        cell_text_color_fn=lambda i, j: text_color_for_bg(grid[i][j][1]),
+        cell_w=cell_w,
+        cell_h=cell_h,
+        label_left=label_left,
+        label_top=label_top,
+        aria_label="Heatmap class taxonomique × position",
+        x_axis_title="Position dans le document (1 = début)",
+    )
+
+
+def build_taxonomy_intra_doc_html(
+    data: Optional[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit le bloc HTML complet de la heatmap intra-document.
+
+    Retourne ``""`` si ``data is None`` ou aucune erreur.
+    """
+    if not data:
+        return ""
+    n_bins = data.get("n_bins", 0)
+    per_class = data.get("per_class") or {}
+    total_errors = data.get("total_errors", 0)
+    if total_errors == 0 or n_bins <= 0:
+        return ""
+    # Filtre : uniquement les classes ayant au moins une erreur
+    classes_with_errors = [
+        cls for cls, counts in per_class.items()
+        if isinstance(counts, list) and sum(counts) > 0
+    ]
+    if not classes_with_errors:
+        return ""
+
+    labels = labels or {}
+    title = labels.get(
+        "intradoc_title",
+        "Évolution intra-document des classes d'erreur",
+    )
+    note = labels.get(
+        "intradoc_note",
+        "Heatmap class × position : densité relative par classe "
+        "(plus foncé = concentré). Une classe concentrée dans la "
+        "première colonne suggère une erreur de marge ; "
+        "une distribution uniforme suggère une erreur de scribe.",
+    )
+    n_words_gt = data.get("n_words_gt", 0)
+    n_words_template = labels.get(
+        "intradoc_n_words",
+        "Calculé sur {n_words_gt} mots GT, répartis en {n_bins} tranches.",
+    )
+    n_words_phrase = n_words_template.format(
+        n_words_gt=n_words_gt, n_bins=n_bins,
+    )
+
+    svg = _build_position_heatmap_svg(classes_with_errors, per_class, n_bins)
+
+    parts = [
+        '<div class="intradoc" 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>',
+        f'<div style="font-size:.8rem;opacity:.7;margin-bottom:.5rem">'
+        f'{_e(n_words_phrase)}</div>',
+        svg,
+        "</div>",
+    ]
+    return "".join(parts)
+
+
+__all__ = [
+    "build_taxonomy_intra_doc_html",
+]

picarones/reports_v2/html/renderers/worst_lines.py

@@ -0,0 +1,170 @@
+"""Rendu HTML de la vue « Worst lines globale » — Sprint 72.
+
+Phase 5.C — module relocalisé depuis
+``picarones.report.worst_lines_render`` vers
+``picarones.reports_v2.html.renderers.worst_lines``.  Le chemin
+legacy reste disponible via un shim avec ``DeprecationWarning`` ;
+suppression prévue en 2.0.
+
+Suite directe de ``picarones/core/worst_lines.py`` (extraction
+transversale).  Pattern identique aux Sprints 41/43/62/67 : rendu
+**server-side**, pas de JavaScript, anti-injection systématique
+via ``html.escape``.
+
+Vue distincte du tableau gallery existant
+-----------------------------------------
+La galerie OCR (vue ``view_gallery.html``) liste les documents
+les plus problématiques.  Cette vue va plus fin : elle liste les
+**lignes individuelles** les plus problématiques, transversalement
+à tous les documents et moteurs.  Complémentaire, pas redondante.
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+from picarones.evaluation.metrics.worst_lines import WorstLineEntry
+from picarones.evaluation import compute_char_diff
+from picarones.reports_v2._helpers.render_helpers import color_traffic_light
+
+
+def _bg_for_cer(cer: float) -> str:
+    """Beige clair sous le seuil catastrophique (0.30), gradient
+    jaune → rouge au-delà.
+
+    Le seuil dur à 0.30 préserve la sémantique « toléré jusqu'à 30 %
+    pour un manuscrit difficile ». Au-delà, on entre en zone visible
+    avec :func:`color_traffic_light` (low_is_good).
+    """
+    f = max(0.0, min(1.0, cer))
+    if f < 0.3:
+        return "#fff8dc"
+    return color_traffic_light(f, low_is_good=True, scale_min=0.3, scale_max=1.0)
+
+
+def _render_diff_inline(reference: str, hypothesis: str) -> str:
+    """Rendu HTML inline d'un diff caractère par caractère.
+
+    - ``equal``   → texte normal
+    - ``delete``  → fond rouge clair, barré (manquait dans hyp)
+    - ``insert``  → fond vert clair (ajouté par hyp)
+    - ``replace`` → fond rouge clair barré + fond vert clair pour
+      la nouvelle valeur (côte à côte)
+    """
+    if not reference and not hypothesis:
+        return '<span style="opacity:.5">∅</span>'
+    ops = compute_char_diff(reference or "", hypothesis or "")
+    parts: list[str] = []
+    for op in ops:
+        kind = op["op"]
+        if kind == "equal":
+            parts.append(_e(op["text"]))
+        elif kind == "delete":
+            parts.append(
+                f'<span style="background:#fdd;text-decoration:line-through">'
+                f'{_e(op["text"])}</span>'
+            )
+        elif kind == "insert":
+            parts.append(
+                f'<span style="background:#dfd">{_e(op["text"])}</span>'
+            )
+        elif kind == "replace":
+            parts.append(
+                f'<span style="background:#fdd;text-decoration:line-through">'
+                f'{_e(op["old"])}</span>'
+                f'<span style="background:#dfd">{_e(op["new"])}</span>'
+            )
+    return "".join(parts)
+
+
+def build_worst_lines_table_html(
+    entries: list[WorstLineEntry],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit le tableau HTML des worst lines.
+
+    Retourne ``""`` si la liste est vide.  Adaptive : si aucune
+    entrée n'a de ``script_type``, la colonne strate est omise.
+    """
+    if not entries:
+        return ""
+    labels = labels or {}
+    title = labels.get("worst_lines_title", "Lignes les plus problématiques")
+    note = labels.get(
+        "worst_lines_note",
+        "Top-N lignes du corpus classées par CER ligne décroissant. "
+        "Diff caractère par caractère : rouge barré = manquant dans "
+        "l'OCR, vert = ajouté par l'OCR.",
+    )
+    rank_label = labels.get("worst_lines_rank_label", "Rang")
+    cer_label = labels.get("worst_lines_cer_label", "CER")
+    engine_label = labels.get("worst_lines_engine_label", "Moteur")
+    doc_label = labels.get("worst_lines_doc_label", "Document")
+    line_label = labels.get("worst_lines_line_label", "Ligne #")
+    strata_label = labels.get("worst_lines_strata_label", "Strate")
+    diff_label = labels.get("worst_lines_diff_label", "GT → OCR (diff)")
+
+    has_strata = any(e.script_type for e in entries)
+
+    parts = [
+        '<div class="worst-lines" style="margin:1rem 0">',
+        f'<div style="font-weight:600;margin-bottom:.4rem">{_e(title)}</div>',
+        f'<div style="font-size:.8rem;opacity:.75;margin-bottom:.5rem">'
+        f'{_e(note)}</div>',
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.85rem">',
+        '<thead><tr>',
+    ]
+    cols = [rank_label, cer_label, engine_label, doc_label, line_label]
+    if has_strata:
+        cols.append(strata_label)
+    cols.append(diff_label)
+    for col in cols:
+        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 entry in entries:
+        cer_color = _bg_for_cer(entry.cer)
+        parts.append("<tr>")
+        parts.append(
+            f'<td style="padding:.3rem .5rem;text-align:right;'
+            f'font-weight:600">{entry.rank}</td>'
+        )
+        parts.append(
+            f'<td style="padding:.3rem .5rem;text-align:right;'
+            f'background:{cer_color};font-family:monospace">'
+            f'{entry.cer * 100:.1f}%</td>'
+        )
+        parts.append(
+            f'<td style="padding:.3rem .5rem">{_e(entry.engine_name)}</td>'
+        )
+        parts.append(
+            f'<td style="padding:.3rem .5rem;font-family:monospace;'
+            f'font-size:.8rem">{_e(entry.doc_id)}</td>'
+        )
+        parts.append(
+            f'<td style="padding:.3rem .5rem;text-align:right">'
+            f'{entry.line_index}</td>'
+        )
+        if has_strata:
+            parts.append(
+                f'<td style="padding:.3rem .5rem;font-size:.8rem">'
+                f'{_e(entry.script_type or "—")}</td>'
+            )
+        parts.append(
+            f'<td style="padding:.3rem .5rem;font-family:monospace;'
+            f'font-size:.85rem">'
+            f'{_render_diff_inline(entry.gt_line, entry.hyp_line)}</td>'
+        )
+        parts.append("</tr>")
+    parts.append("</tbody></table></div>")
+    return "".join(parts)
+
+
+__all__ = [
+    "build_worst_lines_table_html",
+]

tests/report/test_extra_metrics.py

@@ -97,7 +97,7 @@ class TestTaxonomyCooccurrence:
             assert r == results[0]
 
     def test_compatible_with_renderer(self, sample_benchmark) -> None:
-        from picarones.report.taxonomy_cooccurrence_render import (
+        from picarones.reports_v2.html.renderers.taxonomy_cooccurrence import (
             build_taxonomy_cooccurrence_html,
         )
         result = compute_taxonomy_cooccurrence_section(sample_benchmark)
@@ -138,7 +138,7 @@ class TestTaxonomyIntraDoc:
             assert key in result, f"clé {key!r} manquante (renderer la requiert)"
 
     def test_renders_html_when_signal_present(self, sample_benchmark) -> None:
-        from picarones.report.taxonomy_intra_doc_render import (
+        from picarones.reports_v2.html.renderers.taxonomy_intra_doc import (
             build_taxonomy_intra_doc_html,
         )
         result = compute_taxonomy_intra_doc_section(sample_benchmark)

tests/report/test_sprint72_worst_lines.py

@@ -28,7 +28,7 @@ from dataclasses import dataclass, field
 from typing import Any
 
 from picarones.measurements.worst_lines import WorstLineEntry, extract_worst_lines
-from picarones.report.worst_lines_render import build_worst_lines_table_html
+from picarones.reports_v2.html.renderers.worst_lines import build_worst_lines_table_html
 
 
 # ──────────────────────────────────────────────────────────────────────────

tests/report/test_sprint75_taxonomy_cooccurrence.py

@@ -29,7 +29,7 @@ import pytest
 from picarones.measurements.taxonomy_cooccurrence import (
     compute_taxonomy_cooccurrence,
 )
-from picarones.report.taxonomy_cooccurrence_render import (
+from picarones.reports_v2.html.renderers.taxonomy_cooccurrence import (
     build_taxonomy_cooccurrence_html,
 )
 

tests/report/test_sprint76_taxonomy_intra_doc.py

@@ -29,7 +29,7 @@ import pytest
 from picarones.measurements.taxonomy_intra_doc import (
     compute_taxonomy_position_heatmap,
 )
-from picarones.report.taxonomy_intra_doc_render import (
+from picarones.reports_v2.html.renderers.taxonomy_intra_doc import (
     build_taxonomy_intra_doc_html,
 )
 

tests/report/test_sprint77_taxonomy_comparison.py

@@ -27,7 +27,7 @@ from picarones.measurements.taxonomy_comparison import (
     RECOVERABILITY,
     compare_taxonomies,
 )
-from picarones.report.taxonomy_comparison_render import (
+from picarones.reports_v2.html.renderers.taxonomy_comparison import (
     build_taxonomy_comparison_html,
 )
 

tests/report/test_sprint95_pipeline_dag.py

@@ -21,7 +21,7 @@ from __future__ import annotations
 import json
 from pathlib import Path
 
-from picarones.report.pipeline_dag_render import build_pipeline_dag_html
+from picarones.reports_v2.html.renderers.pipeline_dag import build_pipeline_dag_html
 
 
 def _load_labels(lang: str) -> dict: