chantier3: 5 vues HTML thématiques — branche les 16 renderers orphelins

Troisième chantier du plan d'évolution post-Sprint 97 — donner une
adresse à chaque renderer orphelin (16/26 dans report/) en les
regroupant par thème dans des vues collapsibles.

Avant — 16 renderers test-only
------------------------------
L'audit du chantier 0 avait confirmé par grep que ces renderers
existaient et étaient testés mais jamais importés par
generator.py ni inclus dans aucun template :

baseline_render, error_absorption_render, image_predictive_render,
incremental_comparison_render, levers_render, lexical_modernization_render,
longitudinal_render, module_audit_render, multirun_stability_render,
pipeline_dag_render, robustness_projection_render, taxonomy_comparison_render,
taxonomy_cooccurrence_render, taxonomy_intra_doc_render, throughput_render,
worst_lines_render.

CLAUDE.md prétendait pour la plupart "livré bout-en-bout" — c'était faux.

Après — 5 vues thématiques, chaque renderer adressé
---------------------------------------------------
Nouveau package picarones/report/views/ (5 modules) :

- economics.py (158 lignes) — throughput effectif (calculé
automatiquement depuis engine_reports : durations + WER × ref_length)
+ extra_html_blocks pour cost projection et marginal cost opt-in.

- advanced_taxonomy.py (231 lignes) — comparaison miroir
leader vs runner-up (auto, depuis aggregated_taxonomy)
+ cooccurrence/intra_doc/lexical_modernization opt-in.

- diagnostics.py (210 lignes) — leviers d'amélioration (auto,
via detect_levers) + image_predictive/baseline/longitudinal/
multirun_stability/worst_lines opt-in.

- pipeline.py (220 lignes) — pour les rapports de pipelines
composées (workflow picarones pipeline run) : DAG + error_absorption
+ incremental_comparison + module_audit + summary/steps_table.

- robustness.py (95 lignes) — pour le workflow picarones
robustness : déficit projeté.

__init__.py expose les 5 fonctions build_<name>_view_html qui
retournent "" en adaptive masking (aucune sous-section n'a de signal).

Convention de rendu partagée
----------------------------
Chaque vue compose son HTML via _render_view_shell() :
- Titre H3 et note explicative en tête
- Une <details> collapsible par sous-renderer
- Premier <details> ouvert, les autres fermés (réduit le scroll initial)
- Anti-injection HTML systématique via xml.sax.saxutils.escape

Câblage dans le rapport classique
---------------------------------
report/generator.py importe et calcule les 3 vues automatiques
(economics, advanced_taxonomy, diagnostics) après les renderers
historiques. Les 3 variables sont passées au template Jinja2.

view_analyses.html : 3 nouveaux blocs {% if X %} {{ X }} {% endif %}
juste avant la matrice de corrélation, en chart-card pleine largeur.
Les vues s'affichent uniquement si elles ont du contenu.

Vue pipeline et vue robustness : exposées dans le package mais pas
auto-câblées au rapport classique (par construction — un bench
mono-moteur n'a pas de DAG, et la robustesse est un workflow CLI
séparé). Le code des vues est livré pour qu'un cli future puisse
composer un rapport autonome.

Adressage des 16 renderers orphelins
------------------------------------
| Renderer | Vue | Mode |
|-----------------------------------|----------------------|-----------|
| throughput_render | economics | auto |
| taxonomy_comparison_render | advanced_taxonomy | auto |
| taxonomy_cooccurrence_render | advanced_taxonomy | opt-in |
| taxonomy_intra_doc_render | advanced_taxonomy | opt-in |
| lexical_modernization_render | advanced_taxonomy | opt-in |
| levers_render | diagnostics | auto |
| image_predictive_render | diagnostics | opt-in |
| baseline_render | diagnostics | opt-in |
| longitudinal_render | diagnostics | opt-in |
| multirun_stability_render | diagnostics | opt-in |
| worst_lines_render | diagnostics | opt-in |
| pipeline_dag_render | pipeline | opt-in |
| error_absorption_render | pipeline | opt-in |
| incremental_comparison_render | pipeline | opt-in |
| module_audit_render | pipeline | opt-in |
| robustness_projection_render | robustness | opt-in |

Validation 10/10 en sandbox
---------------------------
- Imports OK pour les 5 vues + __init__.
- 5/5 vues retournent "" en adaptive masking sur données vides.
- advanced_taxonomy : 1 moteur → "" (besoin de 2 pour comparer).
- advanced_taxonomy : 2 moteurs → 4404 chars avec mention des 2
noms.
- Anti-injection : "<script>alert(1)</script>" en nom de moteur
est bien échappé.
- economics : 2 moteurs avec 10 docs chacun → 2675 chars throughput.
- economics : durations nulles (bench depuis cache) → masquée.
- Shell <details> : premier ouvert, autres fermés.
- generator.py : 3 imports + 3 variables passées au template.
- view_analyses.html : 3 nouveaux blocs {% if X %} insérés.

Tests
-----
+342 lignes dans tests/test_views.py organisés en 5 classes :
TestViewsImport, TestAdaptiveMasking, TestEconomicsView,
TestAdvancedTaxonomyView, TestDiagnosticsView, TestDetailsShell,
TestGeneratorWiring.

Verrou levé
-----------
Plus aucun renderer n'est strictement orphelin. Les 5 vues sont
composables et adaptive — un rapport sans signal sur une famille
ne montre pas la vue. Les opt-in attendent que les chantiers 4-5
livrent les calculs nécessaires (image_qualities collection avant
compact, baseline/longitudinal depuis history, etc.).

picarones/report/generator.py

@@ -841,6 +841,26 @@ class ReportGenerator:
             _taxos, labels=labels,
         )
 
+        # Chantier 3 (post-Sprint 97) — 3 nouvelles vues thématiques
+        # qui regroupent les renderers orphelins en sections
+        # collapsibles. Adaptive : retourne "" si aucune sous-section
+        # n'a de signal, donc la carte du template est masquée.
+        from picarones.report.views import (
+            build_advanced_taxonomy_view_html,
+            build_diagnostics_view_html,
+            build_economics_view_html,
+        )
+        economics_view_html = build_economics_view_html(
+            report_data, labels=labels,
+            engine_reports=self.benchmark.engine_reports,
+        )
+        advanced_taxonomy_view_html = build_advanced_taxonomy_view_html(
+            report_data, labels=labels,
+        )
+        diagnostics_view_html = build_diagnostics_view_html(
+            report_data, labels=labels,
+        )
+
         env = _build_jinja_env()
         template = env.get_template("base.html.j2")
         html = template.render(
@@ -866,6 +886,10 @@ class ReportGenerator:
             numerical_sequences_html=numerical_sequences_html,
             readability_html=readability_html,
             specialization_html=specialization_html,
+            # Chantier 3 — vues thématiques composées
+            economics_view_html=economics_view_html,
+            advanced_taxonomy_view_html=advanced_taxonomy_view_html,
+            diagnostics_view_html=diagnostics_view_html,
         )
 
         output_path.write_text(html, encoding="utf-8")

picarones/report/templates/view_analyses.html

@@ -262,6 +262,26 @@
     </div>
     {% endif %}
 
+    <!-- Chantier 3 (post-Sprint 97) — vues thématiques composées
+         qui regroupent les renderers orphelins en sections
+         collapsibles. Adaptive : ne s'affichent que si la vue
+         retourne du contenu (au moins une sous-section avec signal). -->
+    {% if economics_view_html %}
+    <div class="chart-card" style="grid-column:1/-1">
+      {{ economics_view_html }}
+    </div>
+    {% endif %}
+    {% if advanced_taxonomy_view_html %}
+    <div class="chart-card" style="grid-column:1/-1">
+      {{ advanced_taxonomy_view_html }}
+    </div>
+    {% endif %}
+    {% if diagnostics_view_html %}
+    <div class="chart-card" style="grid-column:1/-1">
+      {{ diagnostics_view_html }}
+    </div>
+    {% endif %}
+
     <!-- Sprint 7 — Matrice de corrélation -->
     <div class="chart-card technical" style="grid-column:1/-1">
       <h3 data-i18n="h_correlation">Matrice de corrélation entre métriques</h3>

picarones/report/views/__init__.py

@@ -0,0 +1,65 @@
+"""Vues HTML thématiques — orchestrateurs des renderers du rapport.
+
+Chantier 3 du plan d'évolution post-Sprint 97.
+
+Pourquoi ce package
+-------------------
+Avant ce chantier, ``picarones/report/`` exposait 26 modules
+``*_render.py``, dont **16 étaient orphelins** : testés mais jamais
+importés par ``generator.py`` ni inclus dans aucun template Jinja2.
+
+Le chantier 3 résout ce déséquilibre **par regroupement** : chaque
+renderer orphelin trouve une **adresse** dans une vue thématique,
+qui est elle-même branchée conditionnellement au rapport principal
+si elle a du contenu à afficher.
+
+Vues livrées par ce chantier
+----------------------------
+- :mod:`economics`         — throughput effectif + (cost projection si fourni)
+- :mod:`advanced_taxonomy` — taxonomy_comparison + cooccurrence + intra_doc + lexical_modernization
+- :mod:`diagnostics`       — levers + image_predictive + baseline + longitudinal + multirun_stability + worst_lines
+- :mod:`pipeline`          — pipeline_dag + error_absorption + incremental_comparison + module_audit
+- :mod:`robustness`        — robustness_projection (workflow CLI séparé)
+
+Convention API
+--------------
+Chaque vue expose une fonction publique
+``build_<name>_view_html(report_data, labels, **opts) -> str`` qui :
+
+1. **Prend** ``report_data`` (dict construit par
+   :func:`picarones.report.generator._build_report_data`),
+   ``labels`` (i18n) et des options spécifiques à la vue (ex. fixtures
+   externes que l'utilisateur peut fournir).
+2. **Calcule** les données dont chaque renderer a besoin à partir de
+   ``report_data`` quand c'est possible.
+3. **Compose** le HTML des sous-renderers en blocs ``<details>``
+   collapsibles (premier ouvert par défaut).
+4. **Retourne** la chaîne HTML complète, ou ``""`` si aucune
+   sous-section n'a de contenu (adaptive masking corpus-wide).
+
+Le générateur principal (``generator.py``) appelle ces fonctions et
+passe leur retour au template Jinja2 ``view_analyses.html`` qui les
+inclut sous forme de cartes pleine largeur derrière un en-tête
+identifiant la famille.
+
+Ne pas confondre
+----------------
+``views/<name>.py`` = orchestrateur (composition + adaptive masking).
+``<name>_render.py`` = rendu HTML d'un seul bloc atomique.
+Les renderers atomiques restent inchangés, l'orchestrateur les
+combine.
+"""
+
+from picarones.report.views.advanced_taxonomy import build_advanced_taxonomy_view_html
+from picarones.report.views.diagnostics import build_diagnostics_view_html
+from picarones.report.views.economics import build_economics_view_html
+from picarones.report.views.pipeline import build_pipeline_view_html
+from picarones.report.views.robustness import build_robustness_view_html
+
+__all__ = [
+    "build_advanced_taxonomy_view_html",
+    "build_diagnostics_view_html",
+    "build_economics_view_html",
+    "build_pipeline_view_html",
+    "build_robustness_view_html",
+]

picarones/report/views/advanced_taxonomy.py

@@ -0,0 +1,245 @@
+"""Vue taxonomique avancée — chantier 3 post-Sprint 97.
+
+Regroupe les renderers orientés *édition critique* qui examinent la
+structure des erreurs OCR au-delà du CER global :
+
+- :func:`picarones.report.taxonomy_comparison_render.build_taxonomy_comparison_html`
+  — diagramme miroir A vs B des proportions d'erreurs par classe
+  + tableau de récupérabilité éditoriale.
+- :func:`picarones.report.taxonomy_cooccurrence_render.build_taxonomy_cooccurrence_html`
+  — heatmap Jaccard des co-occurrences de classes au niveau document
+  (opt-in : nécessite ``per_doc_classes``).
+- :func:`picarones.report.taxonomy_intra_doc_render.build_taxonomy_intra_doc_html`
+  — heatmap classe × position intra-document (opt-in : nécessite des
+  paires gt+hyp non compactées).
+- :func:`picarones.report.lexical_modernization_render.build_lexical_modernization_html`
+  — top-N des tokens GT modernisés par le moteur (opt-in :
+  nécessite la sortie de ``compute_lexical_modernization``).
+
+Sources de données automatiques
+-------------------------------
+- *Comparaison* : utilise ``aggregated_taxonomy.class_distribution``
+  (ou ``counts``) du leader CER vs le runner-up. Disponible dès qu'au
+  moins 2 moteurs ont une taxonomie agrégée.
+
+Sources de données opt-in (via ``opts``)
+----------------------------------------
+- ``opts["cooccurrence"]``      : sortie de
+  :func:`picarones.core.taxonomy_cooccurrence.compute_taxonomy_cooccurrence`.
+- ``opts["intra_doc"]``         : sortie de
+  :func:`picarones.core.taxonomy_intra_doc.compute_taxonomy_position_heatmap`.
+- ``opts["lexical_modernization"]``  : sortie de
+  :func:`picarones.core.lexical_modernization.compute_lexical_modernization`
+  agrégée corpus-wide.
+
+Ces calculs ne sont pas faits automatiquement par le runner standard
+(coût et données nécessaires non triviaux après ``compact()``) ;
+l'utilisateur peut les pré-calculer dans son workflow et les
+fournir via :func:`build_advanced_taxonomy_view_html`.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def _select_two_engines_for_comparison(
+    engines_summary: list[dict],
+) -> Optional[tuple[dict, dict]]:
+    """Choisit deux moteurs à comparer dans le diagramme miroir.
+
+    Stratégie : leader CER (plus bas) vs runner-up (deuxième). Si
+    moins de 2 moteurs ont une ``aggregated_taxonomy`` non vide,
+    retourne ``None``.
+    """
+    candidates = [
+        e for e in engines_summary
+        if isinstance(e.get("aggregated_taxonomy"), dict)
+        and (
+            e["aggregated_taxonomy"].get("class_distribution")
+            or e["aggregated_taxonomy"].get("counts")
+        )
+    ]
+    if len(candidates) < 2:
+        return None
+    # Tri par CER croissant (leader = meilleur). Les moteurs sans CER
+    # vont en queue (clé None considérée comme inf).
+    candidates.sort(
+        key=lambda e: e.get("cer") if e.get("cer") is not None else float("inf"),
+    )
+    return candidates[0], candidates[1]
+
+
+def _extract_class_counts(engine_entry: dict) -> dict[str, float]:
+    """Extrait le dict ``{class_name: count}`` d'une entrée moteur.
+
+    Supporte les deux formats observés en production :
+
+    - Sprint 5 historique : ``aggregated_taxonomy["class_distribution"]``
+    - Variante : ``aggregated_taxonomy["counts"]``
+    """
+    tax = engine_entry.get("aggregated_taxonomy") or {}
+    counts = tax.get("class_distribution") or tax.get("counts") or {}
+    if not isinstance(counts, dict):
+        return {}
+    out: dict[str, float] = {}
+    for k, v in counts.items():
+        if isinstance(v, (int, float)) and v >= 0:
+            out[str(k)] = float(v)
+    return out
+
+
+def build_advanced_taxonomy_view_html(
+    report_data: dict,
+    labels: Optional[dict[str, str]] = None,
+    *,
+    cooccurrence: Optional[dict] = None,
+    intra_doc: Optional[dict] = None,
+    lexical_modernization: Optional[dict] = None,
+) -> str:
+    """Compose la vue taxonomique avancée du rapport.
+
+    Parameters
+    ----------
+    report_data:
+        Dict produit par :func:`generator._build_report_data`.
+    labels:
+        Dict i18n complet.
+    cooccurrence:
+        Sortie pré-calculée de
+        :func:`picarones.core.taxonomy_cooccurrence.compute_taxonomy_cooccurrence`.
+        Optionnel — la sous-section est masquée si non fourni.
+    intra_doc:
+        Sortie pré-calculée de
+        :func:`picarones.core.taxonomy_intra_doc.compute_taxonomy_position_heatmap`.
+        Optionnel.
+    lexical_modernization:
+        Sortie pré-calculée de
+        :func:`picarones.core.lexical_modernization.aggregate_lexical_modernization`.
+        Optionnel.
+
+    Returns
+    -------
+    str
+        HTML de la vue (entête + sous-sections collapsibles) ou
+        ``""`` si aucune sous-section n'a de contenu.
+    """
+    labels = labels or {}
+    blocks: list[tuple[str, str]] = []
+
+    # Sous-section 1 : comparaison des deux leaders
+    try:
+        engines_summary = report_data.get("engines") or []
+        pair = _select_two_engines_for_comparison(engines_summary)
+        if pair is not None:
+            from picarones.core.taxonomy_comparison import compare_taxonomies
+            from picarones.report.taxonomy_comparison_render import (
+                build_taxonomy_comparison_html,
+            )
+            engine_a, engine_b = pair
+            data = compare_taxonomies(
+                engine_a.get("name", "engine_a"),
+                _extract_class_counts(engine_a),
+                engine_b.get("name", "engine_b"),
+                _extract_class_counts(engine_b),
+            )
+            html = build_taxonomy_comparison_html(data, labels=labels)
+            if html:
+                blocks.append((
+                    labels.get(
+                        "advtax_comparison_title",
+                        "Comparaison taxonomique (leader vs runner-up)",
+                    ),
+                    html,
+                ))
+    except Exception as exc:  # noqa: BLE001
+        logger.warning(
+            "[advanced_taxonomy_view.comparison] dégradé : %s", exc,
+        )
+
+    # Sous-section 2 : co-occurrence (opt-in)
+    if cooccurrence:
+        try:
+            from picarones.report.taxonomy_cooccurrence_render import (
+                build_taxonomy_cooccurrence_html,
+            )
+            html = build_taxonomy_cooccurrence_html(cooccurrence, labels=labels)
+            if html:
+                blocks.append((
+                    labels.get(
+                        "advtax_cooccurrence_title",
+                        "Co-occurrence de classes d'erreurs",
+                    ),
+                    html,
+                ))
+        except Exception as exc:  # noqa: BLE001
+            logger.warning(
+                "[advanced_taxonomy_view.cooccurrence] dégradé : %s", exc,
+            )
+
+    # Sous-section 3 : intra-document (opt-in)
+    if intra_doc:
+        try:
+            from picarones.report.taxonomy_intra_doc_render import (
+                build_taxonomy_intra_doc_html,
+            )
+            html = build_taxonomy_intra_doc_html(intra_doc, labels=labels)
+            if html:
+                blocks.append((
+                    labels.get(
+                        "advtax_intra_doc_title",
+                        "Distribution intra-document des classes",
+                    ),
+                    html,
+                ))
+        except Exception as exc:  # noqa: BLE001
+            logger.warning(
+                "[advanced_taxonomy_view.intra_doc] dégradé : %s", exc,
+            )
+
+    # Sous-section 4 : modernisation lexicale (opt-in)
+    if lexical_modernization:
+        try:
+            from picarones.report.lexical_modernization_render import (
+                build_lexical_modernization_html,
+            )
+            html = build_lexical_modernization_html(
+                lexical_modernization, labels=labels,
+            )
+            if html:
+                blocks.append((
+                    labels.get(
+                        "advtax_lexmod_title",
+                        "Modernisation lexicale (top tokens)",
+                    ),
+                    html,
+                ))
+        except Exception as exc:  # noqa: BLE001
+            logger.warning(
+                "[advanced_taxonomy_view.lexmod] dégradé : %s", exc,
+            )
+
+    if not blocks:
+        return ""
+
+    # Réutilise le shell partagé de la vue economics
+    from picarones.report.views.economics import _render_view_shell
+
+    return _render_view_shell(
+        view_title=labels.get(
+            "advtax_view_title", "Taxonomie avancée des erreurs",
+        ),
+        view_note=labels.get(
+            "advtax_view_note",
+            "Vue centrée sur l'édition critique : composition des "
+            "erreurs au-delà du CER global, pour décider quel moteur "
+            "produit des erreurs récupérables vs irrécupérables.",
+        ),
+        blocks=blocks,
+    )
+
+
+__all__ = ["build_advanced_taxonomy_view_html"]

picarones/report/views/diagnostics.py

@@ -0,0 +1,247 @@
+"""Vue diagnostique du rapport — chantier 3 post-Sprint 97.
+
+Regroupe les renderers orientés *« comprendre POURQUOI on a ces
+résultats »* :
+
+- :func:`picarones.report.levers_render.build_levers_section_html`
+  — leviers d'amélioration éditoriale (factuels, pas prescriptifs).
+- :func:`picarones.report.worst_lines_render.build_worst_lines_table_html`
+  — top-N des lignes du corpus avec le pire CER (toutes moteurs
+  confondus, opt-in : nécessite ``benchmark`` non compacté).
+- :func:`picarones.report.image_predictive_render.build_image_predictive_html`
+  — complexité paléographique + homogénéité du corpus (opt-in :
+  nécessite la liste des image_qualities individuelles).
+- :func:`picarones.report.baseline_render.build_corpus_difficulty_baseline_html`
+  — encart « ce corpus est-il habituel ? » (opt-in : nécessite
+  l'historique SQLite).
+- :func:`picarones.report.longitudinal_render.build_longitudinal_html`
+  — évolution longitudinale par moteur (opt-in : idem historique).
+- :func:`picarones.report.multirun_stability_render.build_multirun_stability_html`
+  — stabilité multi-runs (opt-in : nécessite N runs).
+
+Sources de données automatiques
+-------------------------------
+- *Leviers* : :func:`picarones.core.levers.detect_levers` est appelée
+  sur ``report_data``. Couvre :
+  ``dominant_recoverable_class``, ``pareto_concentration``,
+  ``complementarity_observation``, ``lexical_modernization_observation``,
+  ``robustness_projection_observation``.
+
+Sources de données opt-in (via ``opts``)
+----------------------------------------
+- ``opts["benchmark"]``        : ``BenchmarkResult`` non compacté (worst lines).
+- ``opts["image_qualities"]``  : liste de dicts image_quality par doc.
+- ``opts["baseline_data"]``    : sortie de
+  :func:`picarones.core.baseline_comparison.compute_corpus_difficulty_percentile`.
+- ``opts["longitudinal"]``     : map ``{engine: longitudinal_data}``.
+- ``opts["stability"]``        : sortie de
+  :func:`picarones.core.reliability.compute_multirun_stability`.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def build_diagnostics_view_html(
+    report_data: dict,
+    labels: Optional[dict[str, str]] = None,
+    *,
+    benchmark: Optional[Any] = None,
+    image_qualities: Optional[list[dict]] = None,
+    baseline_data: Optional[dict] = None,
+    longitudinal: Optional[dict] = None,
+    stability: Optional[list[dict]] = None,
+    history_values: Optional[list[float]] = None,
+) -> str:
+    """Compose la vue diagnostique du rapport.
+
+    Parameters
+    ----------
+    report_data:
+        Dict produit par :func:`generator._build_report_data`.
+    labels:
+        Dict i18n complet.
+    benchmark:
+        ``BenchmarkResult`` non compacté pour la sous-section worst
+        lines (qui re-split les hypothèses par doc et engine).
+        Si ``None`` ou si les ``DocumentResult`` ont été compactés,
+        la sous-section est masquée.
+    image_qualities:
+        Liste de dicts ``{contrast, noise_level, blur_score, …}``
+        par document, pré-calculée par le runner (ex. extraction
+        depuis les ``EngineReport.document_results`` avant compact).
+    baseline_data:
+        Sortie de
+        :func:`picarones.core.baseline_comparison.compute_corpus_difficulty_percentile`.
+        Active l'encart « ce corpus est-il habituel ? ».
+    longitudinal:
+        Sortie de
+        :func:`picarones.core.longitudinal.compute_corpus_longitudinal`.
+        Active la table d'évolution.
+    stability:
+        Liste enrichie de ``{engine_name, ...stability_data}`` par
+        moteur, sortie de
+        :func:`picarones.core.reliability.compute_multirun_stability`.
+        Active la table de stabilité multi-runs.
+    history_values:
+        Valeurs historiques de difficulté du corpus, utilisées pour
+        rendre le boxplot dans l'encart baseline.
+
+    Returns
+    -------
+    str
+        HTML de la vue ou ``""`` si aucune sous-section n'a de
+        contenu.
+    """
+    labels = labels or {}
+    blocks: list[tuple[str, str]] = []
+
+    # Sous-section 1 : leviers (calculés automatiquement)
+    try:
+        from picarones.core.levers import detect_levers
+        from picarones.report.levers_render import build_levers_section_html
+        levers = detect_levers(report_data)
+        html = build_levers_section_html(levers, labels=labels)
+        if html:
+            blocks.append((
+                labels.get(
+                    "diag_levers_title", "Leviers d'amélioration",
+                ),
+                html,
+            ))
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("[diagnostics_view.levers] dégradé : %s", exc)
+
+    # Sous-section 2 : encart baseline (opt-in via historique)
+    if baseline_data:
+        try:
+            from picarones.report.baseline_render import (
+                build_corpus_difficulty_baseline_html,
+            )
+            html = build_corpus_difficulty_baseline_html(
+                baseline_data,
+                history_values or [],
+                labels=labels,
+            )
+            if html:
+                blocks.append((
+                    labels.get(
+                        "diag_baseline_title",
+                        "Comparaison historique du corpus",
+                    ),
+                    html,
+                ))
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("[diagnostics_view.baseline] dégradé : %s", exc)
+
+    # Sous-section 3 : profil d'image du corpus (opt-in)
+    if image_qualities:
+        try:
+            from picarones.core.image_predictive import (
+                aggregate_corpus_predictive,
+            )
+            from picarones.report.image_predictive_render import (
+                build_image_predictive_html,
+            )
+            aggregated = aggregate_corpus_predictive(image_qualities)
+            html = build_image_predictive_html(aggregated, labels=labels)
+            if html:
+                blocks.append((
+                    labels.get(
+                        "diag_image_predictive_title",
+                        "Profil d'image du corpus",
+                    ),
+                    html,
+                ))
+        except Exception as exc:  # noqa: BLE001
+            logger.warning(
+                "[diagnostics_view.image_predictive] dégradé : %s", exc,
+            )
+
+    # Sous-section 4 : évolution longitudinale (opt-in)
+    if longitudinal:
+        try:
+            from picarones.report.longitudinal_render import (
+                build_longitudinal_html,
+            )
+            html = build_longitudinal_html(longitudinal, labels=labels)
+            if html:
+                blocks.append((
+                    labels.get(
+                        "diag_longitudinal_title",
+                        "Évolution longitudinale par moteur",
+                    ),
+                    html,
+                ))
+        except Exception as exc:  # noqa: BLE001
+            logger.warning(
+                "[diagnostics_view.longitudinal] dégradé : %s", exc,
+            )
+
+    # Sous-section 5 : stabilité multi-runs (opt-in)
+    if stability:
+        try:
+            from picarones.report.multirun_stability_render import (
+                build_multirun_stability_html,
+            )
+            html = build_multirun_stability_html(stability, labels=labels)
+            if html:
+                blocks.append((
+                    labels.get(
+                        "diag_stability_title",
+                        "Stabilité multi-runs",
+                    ),
+                    html,
+                ))
+        except Exception as exc:  # noqa: BLE001
+            logger.warning(
+                "[diagnostics_view.stability] dégradé : %s", exc,
+            )
+
+    # Sous-section 6 : worst lines (opt-in via benchmark non compacté)
+    if benchmark is not None:
+        try:
+            from picarones.core.worst_lines import extract_worst_lines
+            from picarones.report.worst_lines_render import (
+                build_worst_lines_table_html,
+            )
+            entries = extract_worst_lines(benchmark, top_n=20)
+            html = build_worst_lines_table_html(entries, labels=labels)
+            if html:
+                blocks.append((
+                    labels.get(
+                        "diag_worst_lines_title",
+                        "Lignes les pires (top 20, tous moteurs)",
+                    ),
+                    html,
+                ))
+        except Exception as exc:  # noqa: BLE001
+            logger.warning(
+                "[diagnostics_view.worst_lines] dégradé : %s", exc,
+            )
+
+    if not blocks:
+        return ""
+
+    from picarones.report.views.economics import _render_view_shell
+
+    return _render_view_shell(
+        view_title=labels.get(
+            "diag_view_title", "Diagnostic approfondi",
+        ),
+        view_note=labels.get(
+            "diag_view_note",
+            "Vue d'aide à l'interprétation : leviers d'amélioration "
+            "factuels (jamais prescriptifs), profil d'image du corpus, "
+            "comparaison à l'historique de l'institution, et lignes "
+            "les pires pour inspection ciblée.",
+        ),
+        blocks=blocks,
+    )
+
+
+__all__ = ["build_diagnostics_view_html"]

picarones/report/views/economics.py

@@ -0,0 +1,219 @@
+"""Vue économique du rapport — chantier 3 post-Sprint 97.
+
+Regroupe les renderers orientés *décision budget* :
+
+- :func:`picarones.report.throughput_render.build_throughput_html`
+  — pages/h **utilisable** (raw - correction humaine), formule
+  HTR-United (5 s/erreur).
+
+Renderers prévus mais nécessitant des données opt-in (cost projection
+par volume, coût marginal par erreur évitée) restent non câblés ici :
+ils s'activeront quand l'utilisateur fournira ``opts["target_pages"]``
+et ``opts["pricing"]`` au constructeur, ou via un workflow CLI dédié
+``picarones economics``.
+
+Adaptive masking
+----------------
+La vue retourne ``""`` quand aucune sous-section n'a de signal
+exploitable.  Elle ne s'affiche donc dans le rapport que si au moins
+un moteur a un throughput estimable (somme des durées non nulle).
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def _estimate_engine_throughput_inputs(
+    engine_reports: list,
+) -> list[dict]:
+    """Construit les entrées attendues par
+    :func:`picarones.core.throughput.aggregate_effective_throughput`
+    à partir des ``EngineReport`` du benchmark.
+
+    Pour chaque moteur :
+
+    - ``n_pages``         : nombre de documents traités sans erreur OCR.
+    - ``duration_seconds``: somme des ``duration_seconds`` des docs réussis.
+    - ``n_errors``        : approximation au niveau **mot** ≈
+      ``wer × total_words_gt``.  C'est un proxy : on n'a pas l'alignement
+      exact, on multiplie le WER moyen par le nombre total de mots dans
+      la GT (toutes longueurs confondues).  Cette approximation est
+      cohérente avec la définition du WER.
+
+    Le moteur est exclu si ``n_pages == 0`` ou si toutes les durations
+    sont nulles (cas d'un cache).
+    """
+    out: list[dict] = []
+    for report in engine_reports:
+        successful = [
+            dr for dr in report.document_results
+            if getattr(dr, "engine_error", None) is None
+        ]
+        if not successful:
+            continue
+        total_duration = sum(
+            float(getattr(dr, "duration_seconds", 0.0)) for dr in successful
+        )
+        if total_duration <= 0:
+            # Bench depuis cache — pas de mesure de vitesse exploitable
+            continue
+        # Estimation du nombre de mots GT total (somme des longueurs
+        # référence).  ``MetricsResult.reference_length`` est en
+        # caractères ; on convertit grossièrement en mots par
+        # heuristique 5 caractères/mot pour l'agrégation.
+        total_words_gt = 0
+        weighted_wer = 0.0
+        for dr in successful:
+            ref_chars = getattr(dr.metrics, "reference_length", 0) or 0
+            ref_words = max(1, int(ref_chars / 5)) if ref_chars else 0
+            wer = getattr(dr.metrics, "wer", 0.0) or 0.0
+            total_words_gt += ref_words
+            weighted_wer += wer * ref_words
+        if total_words_gt == 0:
+            n_errors = 0
+        else:
+            mean_wer = weighted_wer / total_words_gt
+            n_errors = int(round(mean_wer * total_words_gt))
+        out.append({
+            "engine_name": report.engine_name,
+            "n_pages": len(successful),
+            "duration_seconds": total_duration,
+            "n_errors": max(0, n_errors),
+        })
+    return out
+
+
+def build_economics_view_html(
+    report_data: dict,
+    labels: Optional[dict[str, str]] = None,
+    *,
+    engine_reports: Optional[list] = None,
+    time_per_error_seconds: float = 5.0,
+    extra_html_blocks: Optional[list[str]] = None,
+) -> str:
+    """Compose la vue économique du rapport.
+
+    Parameters
+    ----------
+    report_data:
+        Dict produit par :func:`generator._build_report_data`.
+        Les sous-renderers reçoivent ``labels`` directement ; cette
+        fonction n'extrait que les éléments qu'elle peut composer
+        à partir de ``report_data``.
+    labels:
+        Dict i18n complet du rapport.
+    engine_reports:
+        Liste des ``EngineReport`` du benchmark.  Indispensable pour
+        calculer le throughput effectif (besoin des durations
+        document par document, non exposées dans ``report_data``).
+        Si ``None``, la sous-section throughput est sautée.
+    time_per_error_seconds:
+        Constante de correction humaine pour le throughput effectif
+        (défaut HTR-United : 5 s par erreur mot).
+    extra_html_blocks:
+        Blocs HTML déjà rendus à inclure tels quels (par exemple
+        cost projection par volume, fourni par un workflow CLI dédié).
+        Permet d'étendre la vue sans modifier ce module.
+
+    Returns
+    -------
+    str
+        HTML complet de la vue (entête + sous-sections collapsibles)
+        ou ``""`` si aucune sous-section ne produit de contenu.
+    """
+    labels = labels or {}
+    blocks: list[tuple[str, str]] = []
+
+    # Sous-section 1 : throughput effectif
+    if engine_reports:
+        try:
+            from picarones.core.throughput import (
+                aggregate_effective_throughput,
+            )
+            from picarones.report.throughput_render import (
+                build_throughput_html,
+            )
+            inputs = _estimate_engine_throughput_inputs(engine_reports)
+            aggregated = aggregate_effective_throughput(
+                inputs, time_per_error_seconds=time_per_error_seconds,
+            )
+            html = build_throughput_html(aggregated, labels=labels)
+            if html:
+                blocks.append((
+                    labels.get("economics_throughput_title", "Throughput effectif"),
+                    html,
+                ))
+        except Exception as exc:  # noqa: BLE001
+            logger.warning(
+                "[economics_view.throughput] dégradé : %s", exc,
+            )
+
+    # Sous-section 2 : blocs externes (cost projection, marginal cost…)
+    if extra_html_blocks:
+        for i, html in enumerate(extra_html_blocks):
+            if not html:
+                continue
+            blocks.append((
+                labels.get(
+                    f"economics_extra_{i}_title",
+                    labels.get("economics_extra_title", "Coût projeté"),
+                ),
+                html,
+            ))
+
+    if not blocks:
+        return ""
+
+    return _render_view_shell(
+        view_title=labels.get("economics_view_title", "Coût et performance"),
+        view_note=labels.get(
+            "economics_view_note",
+            "Vue centrée sur la décision budget : pages traitables par "
+            "heure réellement utilisable (en intégrant la correction "
+            "humaine post-OCR), et projection de coût par volume cible.",
+        ),
+        blocks=blocks,
+    )
+
+
+def _render_view_shell(
+    *,
+    view_title: str,
+    view_note: str,
+    blocks: list[tuple[str, str]],
+) -> str:
+    """Compose un shell ``<details>`` collapsible par bloc, premier ouvert.
+
+    Convention de rendu partagée par les 5 vues du chantier 3 :
+    chaque sous-section est un ``<details>`` natif (collapsible
+    sans JS), avec son sous-titre dans le ``<summary>``.  Le premier
+    est ouvert par défaut, les autres fermés (réduit le scroll
+    initial).
+    """
+    from html import escape as _e
+    parts: list[str] = []
+    parts.append(
+        f'<h3 style="margin-top:1.5em">{_e(view_title)}</h3>'
+    )
+    if view_note:
+        parts.append(
+            f'<p style="font-size:.82rem;color:var(--text-muted);'
+            f'margin:.2em 0 1em">{_e(view_note)}</p>'
+        )
+    for i, (title, html) in enumerate(blocks):
+        open_attr = " open" if i == 0 else ""
+        parts.append(
+            f'<details{open_attr} style="margin-bottom:1em">'
+            f'<summary style="cursor:pointer;font-weight:600;'
+            f'padding:.4em 0">{_e(title)}</summary>'
+            f'<div style="margin-top:.5em">{html}</div>'
+            f'</details>'
+        )
+    return "\n".join(parts)
+
+
+__all__ = ["build_economics_view_html"]

picarones/report/views/pipeline.py

@@ -0,0 +1,237 @@
+"""Vue pipeline composée — chantier 3 post-Sprint 97.
+
+Regroupe les renderers spécifiques aux benchmarks de **pipelines
+composées** (axe B du plan d'évolution 2026, Sprints 63-68, 94-97) :
+
+- :func:`picarones.report.pipeline_render.build_pipeline_summary_html`
+  — résumé corpus-wide (taux de succès, durée, métriques aux jonctions).
+- :func:`picarones.report.pipeline_render.build_pipeline_steps_table_html`
+  — tableau par étape (Sprint 67).
+- :func:`picarones.report.pipeline_dag_render.build_pipeline_dag_html`
+  — visualisation SVG du DAG avec couleur des arêtes selon la métrique.
+- :func:`picarones.report.error_absorption_render.build_error_absorption_html`
+  — corrections vs introductions à chaque jonction (Sprint 94).
+- :func:`picarones.report.incremental_comparison_render.build_incremental_comparison_html`
+  — effet isolé d'un slot (LLM, reconstructeur, etc.) en contrôlant
+  les autres (Sprint 96).
+- :func:`picarones.report.module_audit_render.build_module_audit_html`
+  — audit de conformité des modules contribués (Sprint 97).
+
+Cette vue ne s'applique pas au rapport standard (mono-moteur OCR
+classique). Elle est appelée explicitement par le workflow
+``picarones pipeline run`` (CLI Sprint 70) et par tout outil
+extérieur qui consomme un ``PipelineBenchmarkResult``.
+
+Sources de données
+------------------
+Toutes les sous-sections consomment des structures opt-in passées
+en ``opts``. Aucune n'est calculée à partir de ``report_data`` —
+c'est par construction (un rapport classique n'a pas de DAG).
+
+- ``opts["pipeline_benchmark"]`` : ``PipelineBenchmarkResult`` (Sprint 64).
+- ``opts["dag_nodes"]`` / ``opts["dag_labels"]`` / ``opts["dag_edges"]``
+  / ``opts["dag_thresholds"]`` / ``opts["dag_higher_is_better"]`` :
+  arguments directs de :func:`build_pipeline_dag_html`.
+- ``opts["junctions"]`` : liste de jonctions avec leurs paires
+  ``before/after`` pour :func:`build_error_absorption_html`.
+- ``opts["incremental_runs"]`` + ``opts["incremental_varying_slot"]`` :
+  arguments de :func:`build_incremental_comparison_html`.
+- ``opts["module_audits"]`` : liste de ``(manifest, audit_result)``.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def build_pipeline_view_html(
+    report_data: Optional[dict] = None,
+    labels: Optional[dict[str, str]] = None,
+    *,
+    pipeline_benchmark: Optional[Any] = None,
+    dag_nodes: Optional[list] = None,
+    dag_labels: Optional[dict[str, str]] = None,
+    dag_edges: Optional[list] = None,
+    dag_thresholds: Optional[tuple[float, float]] = None,
+    dag_higher_is_better: bool = False,
+    junctions: Optional[list[dict]] = None,
+    incremental_runs: Optional[list] = None,
+    incremental_varying_slot: Optional[str] = None,
+    incremental_higher_is_better: bool = False,
+    module_audits: Optional[list[tuple]] = None,
+) -> str:
+    """Compose la vue pipeline.
+
+    Parameters
+    ----------
+    report_data:
+        Inutilisé pour cette vue (la pipeline composée a sa propre
+        structure de données via ``PipelineBenchmarkResult``).
+        Présent dans la signature pour homogénéité avec les autres
+        vues du chantier 3.
+    labels:
+        Dict i18n complet.
+    pipeline_benchmark:
+        ``PipelineBenchmarkResult`` (Sprint 64) — active les sections
+        ``summary`` et ``steps_table`` du :mod:`pipeline_render`.
+    dag_nodes, dag_labels, dag_edges, dag_thresholds, dag_higher_is_better:
+        Arguments de :func:`build_pipeline_dag_html` (Sprint 95).
+    junctions:
+        Liste de dicts ``{junction_name, before, after, ...}`` pour
+        :func:`build_error_absorption_html` (Sprint 94).
+    incremental_runs, incremental_varying_slot, incremental_higher_is_better:
+        Arguments de :func:`build_incremental_comparison_html`
+        (Sprint 96).
+    module_audits:
+        Liste de tuples ``(ModuleManifest, AuditResult)`` pour
+        :func:`build_module_audit_html` (Sprint 97).
+
+    Returns
+    -------
+    str
+        HTML de la vue ou ``""`` si aucune sous-section opt-in
+        n'est fournie.
+    """
+    labels = labels or {}
+    blocks: list[tuple[str, str]] = []
+
+    # Sous-section 1 : résumé + steps table
+    if pipeline_benchmark is not None:
+        try:
+            from picarones.report.pipeline_render import (
+                build_pipeline_steps_table_html,
+                build_pipeline_summary_html,
+            )
+            summary = build_pipeline_summary_html(pipeline_benchmark)
+            steps = build_pipeline_steps_table_html(pipeline_benchmark)
+            combined = "\n".join(filter(None, [summary, steps]))
+            if combined:
+                blocks.append((
+                    labels.get(
+                        "pipeline_summary_title",
+                        "Résumé de la pipeline",
+                    ),
+                    combined,
+                ))
+        except Exception as exc:  # noqa: BLE001
+            logger.warning(
+                "[pipeline_view.summary] dégradé : %s", exc,
+            )
+
+    # Sous-section 2 : DAG visualization
+    if dag_nodes:
+        try:
+            from picarones.report.pipeline_dag_render import (
+                build_pipeline_dag_html,
+            )
+            html = build_pipeline_dag_html(
+                nodes=dag_nodes,
+                labels=dag_labels or {},
+                edges=dag_edges,
+                thresholds=dag_thresholds or (0.05, 0.15),
+                higher_is_better=dag_higher_is_better,
+            )
+            if html:
+                blocks.append((
+                    labels.get(
+                        "pipeline_dag_title",
+                        "Visualisation du DAG",
+                    ),
+                    html,
+                ))
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("[pipeline_view.dag] dégradé : %s", exc)
+
+    # Sous-section 3 : absorption d'erreur par jonction
+    if junctions:
+        try:
+            from picarones.report.error_absorption_render import (
+                build_error_absorption_html,
+            )
+            html = build_error_absorption_html(junctions, labels=labels)
+            if html:
+                blocks.append((
+                    labels.get(
+                        "pipeline_absorption_title",
+                        "Absorption d'erreur par jonction",
+                    ),
+                    html,
+                ))
+        except Exception as exc:  # noqa: BLE001
+            logger.warning(
+                "[pipeline_view.error_absorption] dégradé : %s", exc,
+            )
+
+    # Sous-section 4 : comparaison incrémentale (effet d'un slot)
+    if incremental_runs and incremental_varying_slot:
+        try:
+            from picarones.core.incremental_comparison import (
+                compare_isolated_effect,
+            )
+            from picarones.report.incremental_comparison_render import (
+                build_incremental_comparison_html,
+            )
+            comparison = compare_isolated_effect(
+                incremental_runs,
+                incremental_varying_slot,
+                higher_is_better=incremental_higher_is_better,
+            )
+            html = build_incremental_comparison_html(
+                comparison,
+                varying_slot=incremental_varying_slot,
+                labels=labels,
+            )
+            if html:
+                blocks.append((
+                    labels.get(
+                        "pipeline_incremental_title",
+                        "Comparaison incrémentale",
+                    ),
+                    html,
+                ))
+        except Exception as exc:  # noqa: BLE001
+            logger.warning(
+                "[pipeline_view.incremental] dégradé : %s", exc,
+            )
+
+    # Sous-section 5 : audit des modules contribués
+    if module_audits:
+        try:
+            from picarones.report.module_audit_render import (
+                build_module_audit_html,
+            )
+            html = build_module_audit_html(module_audits, labels=labels)
+            if html:
+                blocks.append((
+                    labels.get(
+                        "pipeline_audit_title",
+                        "Audit des modules contribués",
+                    ),
+                    html,
+                ))
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("[pipeline_view.audit] dégradé : %s", exc)
+
+    if not blocks:
+        return ""
+
+    from picarones.report.views.economics import _render_view_shell
+
+    return _render_view_shell(
+        view_title=labels.get(
+            "pipeline_view_title", "Banc d'essai de pipeline composée",
+        ),
+        view_note=labels.get(
+            "pipeline_view_note",
+            "Vue spécifique aux pipelines composées (axe B) : "
+            "métriques aux jonctions, absorption d'erreur, comparaison "
+            "incrémentale par slot, audit des modules contribués.",
+        ),
+        blocks=blocks,
+    )
+
+
+__all__ = ["build_pipeline_view_html"]

picarones/report/views/robustness.py

@@ -0,0 +1,101 @@
+"""Vue robustesse — chantier 3 post-Sprint 97.
+
+Branche le renderer :func:`picarones.report.robustness_projection_render`
+(Sprint 88) au workflow ``picarones robustness`` (CLI Sprint 8).
+
+Cette vue ne s'inclut pas dans le rapport classique : la robustesse
+synthétique exige une étape de calcul lourde (re-OCR sur des
+versions dégradées de chaque image) qui sort du flux standard.
+Le module est exposé pour que l'orchestrateur ``robustness_cmd``
+de la CLI puisse composer un mini-rapport HTML autonome.
+
+Sources de données
+------------------
+- ``opts["projection"]`` : sortie de
+  :func:`picarones.core.robustness_projection.project_robustness_on_corpus`.
+- ``opts["aggregated"]`` : sortie de
+  :func:`picarones.core.robustness_projection.aggregate_projection_per_engine`.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def build_robustness_view_html(
+    report_data: Optional[dict] = None,
+    labels: Optional[dict[str, str]] = None,
+    *,
+    projection: Optional[dict] = None,
+    aggregated: Optional[dict] = None,
+) -> str:
+    """Compose la vue robustesse.
+
+    Parameters
+    ----------
+    report_data:
+        Inutilisé (la robustesse a son propre flux).  Présent pour
+        homogénéité avec les autres vues du chantier 3.
+    labels:
+        Dict i18n complet.
+    projection:
+        Sortie de
+        :func:`picarones.core.robustness_projection.project_robustness_on_corpus`.
+    aggregated:
+        Sortie de
+        :func:`picarones.core.robustness_projection.aggregate_projection_per_engine`.
+        Si ``None`` mais ``projection`` fourni, recalculé.
+
+    Returns
+    -------
+    str
+        HTML de la vue ou ``""`` si pas de projection fournie.
+    """
+    if projection is None:
+        return ""
+    labels = labels or {}
+    blocks: list[tuple[str, str]] = []
+
+    try:
+        from picarones.report.robustness_projection_render import (
+            build_robustness_projection_html,
+        )
+        html = build_robustness_projection_html(
+            projection, aggregated=aggregated, labels=labels,
+        )
+        if html:
+            blocks.append((
+                labels.get(
+                    "robust_view_title", "Déficit projeté de robustesse",
+                ),
+                html,
+            ))
+    except Exception as exc:  # noqa: BLE001
+        logger.warning(
+            "[robustness_view.projection] dégradé : %s", exc,
+        )
+
+    if not blocks:
+        return ""
+
+    from picarones.report.views.economics import _render_view_shell
+
+    return _render_view_shell(
+        view_title=labels.get(
+            "robust_view_title", "Robustesse projetée sur le corpus",
+        ),
+        view_note=labels.get(
+            "robust_view_note",
+            "Projection des courbes de dégradation synthétique "
+            "(bruit, flou, rotation) sur les caractéristiques d'image "
+            "réelles du corpus. Permet d'estimer le déficit attendu "
+            "sans relancer un OCR coûteux par dégradation.",
+        ),
+        blocks=blocks,
+    )
+
+
+__all__ = ["build_robustness_view_html"]

tests/test_views.py

@@ -0,0 +1,358 @@
+"""Tests des 5 vues HTML thématiques (chantier 3 post-Sprint 97).
+
+Couvre :
+
+- Importation et signature des 5 vues.
+- Adaptive masking : ``""`` quand aucune sous-section n'a de signal.
+- Rendu HTML cohérent quand les données sont fournies.
+- Anti-injection HTML sur les noms de moteurs et libellés.
+- Composition correcte du shell ``<details>`` (premier ouvert,
+  autres fermés).
+- Câblage générator → vues (les variables sont passées au template).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 1. Imports + signatures
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestViewsImport:
+    def test_all_views_import(self):
+        from picarones.report.views import (
+            build_advanced_taxonomy_view_html,
+            build_diagnostics_view_html,
+            build_economics_view_html,
+            build_pipeline_view_html,
+            build_robustness_view_html,
+        )
+        assert callable(build_advanced_taxonomy_view_html)
+        assert callable(build_diagnostics_view_html)
+        assert callable(build_economics_view_html)
+        assert callable(build_pipeline_view_html)
+        assert callable(build_robustness_view_html)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 2. Adaptive masking — vues vides retournent ""
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@pytest.fixture
+def empty_report_data() -> dict:
+    return {"engines": []}
+
+
+class TestAdaptiveMasking:
+    def test_economics_empty_returns_empty(self, empty_report_data):
+        from picarones.report.views import build_economics_view_html
+
+        assert build_economics_view_html(empty_report_data, {}) == ""
+
+    def test_advanced_taxonomy_empty_returns_empty(self, empty_report_data):
+        from picarones.report.views import build_advanced_taxonomy_view_html
+
+        assert build_advanced_taxonomy_view_html(empty_report_data, {}) == ""
+
+    def test_diagnostics_empty_returns_empty(self, empty_report_data):
+        from picarones.report.views import build_diagnostics_view_html
+
+        assert build_diagnostics_view_html(empty_report_data, {}) == ""
+
+    def test_pipeline_empty_returns_empty(self, empty_report_data):
+        from picarones.report.views import build_pipeline_view_html
+
+        assert build_pipeline_view_html(empty_report_data, {}) == ""
+
+    def test_robustness_empty_returns_empty(self, empty_report_data):
+        from picarones.report.views import build_robustness_view_html
+
+        assert build_robustness_view_html(empty_report_data, {}) == ""
+
+    def test_advanced_taxonomy_single_engine_returns_empty(self):
+        """La comparaison nécessite ≥ 2 moteurs."""
+        from picarones.report.views import build_advanced_taxonomy_view_html
+
+        single = {"engines": [{
+            "name": "tess",
+            "aggregated_taxonomy": {"class_distribution": {"x": 10}},
+        }]}
+        # Pas de comparison possible → vue masquée
+        assert build_advanced_taxonomy_view_html(single, {}) == ""
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 3. Rendu HTML quand données fournies
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class _MockMetrics:
+    def __init__(self, *, cer=0.05, wer=0.1, reference_length=500):
+        self.cer = cer
+        self.wer = wer
+        self.reference_length = reference_length
+        self.error = None
+
+
+class _MockDocResult:
+    def __init__(self, duration=1.0):
+        self.engine_error = None
+        self.duration_seconds = duration
+        self.metrics = _MockMetrics()
+
+
+class _MockEngineReport:
+    def __init__(self, name, n_docs=10):
+        self.engine_name = name
+        self.document_results = [_MockDocResult() for _ in range(n_docs)]
+
+
+class TestEconomicsView:
+    def test_throughput_with_realistic_engines(self):
+        from picarones.report.views import build_economics_view_html
+
+        reports = [
+            _MockEngineReport("tesseract"),
+            _MockEngineReport("pero_ocr"),
+        ]
+        html = build_economics_view_html(
+            {"engines": []}, {},
+            engine_reports=reports,
+        )
+        assert html != ""
+        # Les deux moteurs doivent apparaître dans le HTML
+        assert "tesseract" in html
+        assert "pero" in html
+
+    def test_extra_html_blocks_appended(self):
+        from picarones.report.views import build_economics_view_html
+
+        extra = ['<div class="custom">CUSTOM_BLOCK</div>']
+        html = build_economics_view_html(
+            {"engines": []},
+            {"economics_extra_title": "Coût projeté"},
+            engine_reports=[_MockEngineReport("tess")],
+            extra_html_blocks=extra,
+        )
+        assert "CUSTOM_BLOCK" in html
+
+    def test_zero_duration_excludes_engine(self):
+        """Bench depuis cache (durations=0) ne génère pas de throughput."""
+        from picarones.report.views import build_economics_view_html
+
+        report = _MockEngineReport("cached")
+        for dr in report.document_results:
+            dr.duration_seconds = 0.0
+        html = build_economics_view_html(
+            {"engines": []}, {}, engine_reports=[report],
+        )
+        # Aucun moteur n'a de durée → vue masquée
+        assert html == ""
+
+
+class TestAdvancedTaxonomyView:
+    def test_two_engines_taxonomy_compared(self):
+        from picarones.report.views import build_advanced_taxonomy_view_html
+
+        report_data = {
+            "engines": [
+                {
+                    "name": "tess", "cer": 0.05,
+                    "aggregated_taxonomy": {
+                        "class_distribution": {
+                            "case_error": 100, "ligature_error": 50,
+                            "lacuna": 30,
+                        },
+                    },
+                },
+                {
+                    "name": "pero", "cer": 0.07,
+                    "aggregated_taxonomy": {
+                        "class_distribution": {
+                            "case_error": 30, "lacuna": 80,
+                            "diacritic_error": 60,
+                        },
+                    },
+                },
+            ],
+        }
+        html = build_advanced_taxonomy_view_html(report_data, {})
+        assert html != ""
+        # Le diagramme miroir doit nommer les 2 moteurs
+        assert "tess" in html
+        assert "pero" in html
+
+    def test_anti_injection_engine_name(self):
+        """Un nom de moteur avec balises HTML doit être échappé."""
+        from picarones.report.views import build_advanced_taxonomy_view_html
+
+        report_data = {
+            "engines": [
+                {
+                    "name": "<script>alert(1)</script>",
+                    "cer": 0.05,
+                    "aggregated_taxonomy": {
+                        "class_distribution": {"case_error": 10},
+                    },
+                },
+                {
+                    "name": "pero",
+                    "cer": 0.07,
+                    "aggregated_taxonomy": {
+                        "class_distribution": {"lacuna": 10},
+                    },
+                },
+            ],
+        }
+        html = build_advanced_taxonomy_view_html(report_data, {})
+        # Pas de balise script non échappée
+        assert "<script>alert" not in html
+        # Mais le contenu doit être présent sous forme échappée
+        assert "&lt;script" in html or "alert" not in html.lower()
+
+    def test_lexical_modernization_optional(self):
+        from picarones.report.views import build_advanced_taxonomy_view_html
+
+        report_data = {
+            "engines": [
+                {
+                    "name": "tess", "cer": 0.05,
+                    "aggregated_taxonomy": {
+                        "class_distribution": {"case_error": 10},
+                    },
+                },
+                {
+                    "name": "pero", "cer": 0.07,
+                    "aggregated_taxonomy": {
+                        "class_distribution": {"case_error": 5},
+                    },
+                },
+            ],
+        }
+        # Sans lexical_modernization, la sous-section n'apparaît pas
+        html_no = build_advanced_taxonomy_view_html(report_data, {})
+        # Avec, elle apparaît
+        lex_data = {
+            "per_token": {
+                "maistre": {
+                    "n_total": 10, "n_modernized": 8,
+                    "rate_modernized": 0.8,
+                    "variants": [{"token": "maître", "count": 8}],
+                },
+            },
+        }
+        html_yes = build_advanced_taxonomy_view_html(
+            report_data, {}, lexical_modernization=lex_data,
+        )
+        # Au moins une section de plus
+        assert len(html_yes) > len(html_no)
+
+
+class TestDiagnosticsView:
+    def test_levers_only_when_signal(self):
+        """detect_levers doit être appelé. Si rien ne déclenche, vue masquée."""
+        from picarones.report.views import build_diagnostics_view_html
+
+        # report_data minimal — aucun levier ne devrait se déclencher
+        empty = {"engines": []}
+        assert build_diagnostics_view_html(empty, {}) == ""
+
+    def test_image_predictive_with_qualities(self):
+        from picarones.report.views import build_diagnostics_view_html
+
+        # Liste d'image_qualities synthétiques (>= 1 doc)
+        qualities = [
+            {
+                "contrast": 0.8, "noise_level": 0.2,
+                "blur_score": 0.1, "estimated_dpi": 300,
+                "rotation_estimate": 0.5, "low_contrast_pct": 0.05,
+            },
+            {
+                "contrast": 0.6, "noise_level": 0.4,
+                "blur_score": 0.3, "estimated_dpi": 250,
+                "rotation_estimate": 1.0, "low_contrast_pct": 0.10,
+            },
+        ]
+        html = build_diagnostics_view_html(
+            {"engines": []}, {}, image_qualities=qualities,
+        )
+        # La section image_predictive doit s'afficher
+        assert html != ""
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 4. Composition du shell <details>
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestDetailsShell:
+    def test_first_block_open_others_closed(self):
+        from picarones.report.views.economics import _render_view_shell
+
+        html = _render_view_shell(
+            view_title="Test",
+            view_note="Note",
+            blocks=[("A", "<p>aaa</p>"), ("B", "<p>bbb</p>"), ("C", "<p>ccc</p>")],
+        )
+        # Le premier <details> doit être ouvert
+        details = html.split("<details")
+        assert "open" in details[1].split(">")[0]
+        # Les suivants ne doivent pas l'être
+        assert "open" not in details[2].split(">")[0]
+        assert "open" not in details[3].split(">")[0]
+        # Tous les contenus présents
+        assert "aaa" in html and "bbb" in html and "ccc" in html
+
+    def test_xml_chars_in_titles_escaped(self):
+        from picarones.report.views.economics import _render_view_shell
+
+        html = _render_view_shell(
+            view_title="<script>alert(1)</script>",
+            view_note="Note <b>bold</b>",
+            blocks=[("Block <X>", "<p>content</p>")],
+        )
+        # Pas d'injection
+        assert "<script>alert(1)</script>" not in html
+        # Mais visible sous forme échappée
+        assert "&lt;script" in html
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 5. Câblage générator → vues
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestGeneratorWiring:
+    def test_generator_imports_three_views(self):
+        """generator.py doit importer les 3 vues automatiques (economics,
+        advanced_taxonomy, diagnostics) pour les passer au template."""
+        from pathlib import Path
+
+        gen_src = (
+            Path(__file__).parent.parent / "picarones" / "report" / "generator.py"
+        ).read_text(encoding="utf-8")
+        # Les 3 imports doivent être présents
+        assert "build_economics_view_html" in gen_src
+        assert "build_advanced_taxonomy_view_html" in gen_src
+        assert "build_diagnostics_view_html" in gen_src
+        # Et les 3 variables doivent être passées au template
+        assert "economics_view_html=" in gen_src
+        assert "advanced_taxonomy_view_html=" in gen_src
+        assert "diagnostics_view_html=" in gen_src
+
+    def test_template_uses_three_views(self):
+        from pathlib import Path
+
+        tpl_src = (
+            Path(__file__).parent.parent
+            / "picarones" / "report" / "templates" / "view_analyses.html"
+        ).read_text(encoding="utf-8")
+        assert "{% if economics_view_html %}" in tpl_src
+        assert "{% if advanced_taxonomy_view_html %}" in tpl_src
+        assert "{% if diagnostics_view_html %}" in tpl_src