feat(measurements): câbler les 13 modules test-only — baseline → 0

Sprint « câblage des 13 modules test-only ». L'audit récursif sur
le commit 7e28f42 listait 13 modules de ``picarones/measurements/``
sans consommateur en production : ``baseline_comparison``,
``cost_projection``, ``equivalence_profile``, ``error_absorption``,
``layout``, ``longitudinal``, ``marginal_cost``, ``module_policy``,
``ner_backends``, ``rare_tokens``, ``reliability``,
``taxonomy_cooccurrence``, ``taxonomy_intra_doc``.

## Approche en deux temps (transparence sur ce qui est câblé vs API)

### Câblage EFFECTIF dans le rapport HTML (4 modules)

Nouveau module ``picarones/report/report_data/extra_metrics.py`` qui
calcule pour chaque ``BenchmarkResult`` :

- ``compute_rare_token_recall_per_engine`` (Sprint 71, A.I.1) :
recall sur les tokens rares (hapax + dis legomena) corpus-wide.
- ``compute_taxonomy_cooccurrence_section`` (Sprint 75, A.I.4) :
matrice de Jaccard inter-classes sur l'ensemble du corpus,
avec déduplication correcte des docs évalués par plusieurs
moteurs (correctif d'un bug ``set.index()`` qui aurait corrompu
la fusion silencieusement).
- ``compute_taxonomy_intra_doc_section`` (Sprint 76, A.I.4) :
heatmap class × position binnée, avec déduplication par doc_id
(correctif d'un comptage qui multipliait par N moteurs).
- ``compute_marginal_cost_section`` (Sprint 91, A.II.6) : matrice
des paires de moteurs avec coût additionnel par erreur évitée.

Ces 4 sections sont exposées dans ``report_data`` puis rendues en
HTML via :
- 2 renderers existants : ``build_taxonomy_cooccurrence_html``,
``build_taxonomy_intra_doc_html``.
- 2 nouveaux renderers minimalistes :
``picarones/report/rare_token_recall_render.py`` (table colorée)
et ``picarones/report/marginal_cost_render.py`` (table de paires
triée par coût marginal croissant).

Les 4 sections sont câblées dans ``ReportGenerator._build_section_html``
et ajoutées à ``view_analyses.html`` avec ``{% if … %}`` adaptive
masking. Vérification end-to-end : les 4 sections apparaissent dans
le HTML rendu sur les fixtures (``rare-token-section``,
``marginal-cost-section``, heatmaps Jaccard et class × position).

### Inclusion dans l'API publique (9 modules)

Les 9 modules restants sont ajoutés aux imports de
``picarones/measurements/__init__.py`` avec ``# noqa: F401`` et
justification individuelle de leur scope :

- ``baseline_comparison``, ``longitudinal`` — historique SQLite
requis (composition utilisateur).
- ``cost_projection`` — volume cible à fournir.
- ``equivalence_profile`` — curseur HTML client-side.
- ``error_absorption`` — déjà câblé via ``views/pipeline.py`` pour
les pipelines composées (axe B).
- ``layout`` — GT ALTO requise (axe B).
- ``module_policy`` — outil d'audit séparé.
- ``ner_backends`` — factory consommée via le param
``entity_extractor`` du runner (Sprint 40).
- ``reliability`` — multi-runs nécessaires.
- ``marginal_cost``, ``rare_tokens``, ``taxonomy_cooccurrence``,
``taxonomy_intra_doc`` — rendus aussi disponibles en
``from picarones.measurements import X``.

## Audit récursif intégré — 5 bugs critiques détectés et corrigés

Audit de 2 agents Explore parallèles + ma vérif → 5 bugs réels
identifiés dans la 1re version du sprint (corrigés avant commit) :

1. **Bug critique** : ``compute_taxonomy_cooccurrence_section``
utilisait ``list(set).index(doc_id)`` pour retrouver la position
dans une liste parallèle. ``set`` n'a pas d'ordre garanti →
merge des classes au mauvais index → matrice Jaccard corrompue.
Fix : remplacement par ``dict[doc_id → idx]``.

2. **Bug critique** : ``compute_taxonomy_intra_doc_section``
retournait ``{n_bins, per_class, classes_with_errors,
n_docs_with_data}`` mais le renderer
``build_taxonomy_intra_doc_html`` attendait OBLIGATOIREMENT
``total_errors`` et ``n_words_gt`` (sans elles, le renderer
retourne ``""`` silencieusement). Fix : ajout des deux clés
au calcul.

3. **Bug critique** : ``compute_marginal_cost_section`` retournait
le dict complet de ``compute_marginal_cost_matrix`` alors que
le renderer attend la liste des paires (sortie ``["pairs"]``).
Fix : extraction de la sous-clé.

4. **Bug majeur** : ``compute_taxonomy_intra_doc_section`` comptait
chaque doc N fois (par moteur) au lieu de dédupliquer par
``doc_id``. Fix : ``seen_doc_ids: set`` qui skip les doublons.

5. **Bug majeur initial** : les 2 renderers (rare_token, marginal)
étaient importés dans ``_build_section_html`` mais jamais
ajoutés au dict de retour. Sections silencieusement absentes
du HTML. Fix : 4 entrées dans le dict.

## Tests de régression

Nouveau ``tests/report/test_extra_metrics.py`` (16 tests) qui
verrouille :
- Format de retour attendu pour chacune des 4 fonctions.
- Compatibilité avec les renderers correspondants (``test_renders_html``
qui détecterait un nouveau "renderer retourne '' silencieusement").
- Garde-fou anti-régression sur le bug ``set.index()`` (5 runs
consécutifs doivent produire le même résultat — pas de déterminisme
cassé).
- Déduplication des docs dans intra_doc (``n_docs_with_data ≤
document_count``).
- Marginal_cost utilise bien ``cost`` attaché par
``attach_engine_costs``.

## Calibration des invariants

- ``TEST_ONLY_BASELINE`` passe de ``frozenset({13 modules})`` à
``frozenset()``.
- HELPER_BASELINE inchangé (0).
- BROKEN_PATHS_BASELINE inchangé (72).

## Vérifications finales

- ruff : All checks passed!
- pytest : 3859 passed, 2 skipped, 4 deselected, 0 failed.
- HTML rendu sur fixtures : les 4 nouvelles sections sont visibles.
- Test ``test_module_coverage`` : 0 module test-only détecté.
- Performance d'import : 82 ms (parité, dominée par scipy).

## Limitations et honnêteté

Sur les 13 modules, **4 sont effectivement câblés au rapport HTML**
(rare_tokens, taxonomy_cooccurrence, taxonomy_intra_doc, marginal_cost)
et **9 sont uniquement importés** dans ``__init__.py`` pour devenir
partie de l'API publique du package. Les 9 derniers nécessitent une
composition utilisateur (historique SQLite, GT ALTO, multi-runs,
volume cible, etc.) — leur câblage automatique au runner OCR
principal n'aurait pas de sens sans paramètre utilisateur. Cette
distinction est documentée par module dans
``picarones/measurements/__init__.py`` (commentaire individuel).

Le test ``test_module_coverage`` voit ces 9 modules comme "consommés"
parce qu'ils sont importés en API publique — ce qui est le bon
critère pour mesurer "test-only" : un module que personne n'importe
en dehors des tests.

README.md

@@ -385,7 +385,7 @@ ruff check picarones/ tests/
 python -m mypy picarones/core/
 ```
 
-**Test suite**: ~3849 tests, ~3 min on a modern laptop. Coverage
+**Test suite**: ~3865 tests, ~3 min on a modern laptop. Coverage
 floor at 85% (currently ~87%). The `network` marker excludes tests
 requiring live HTTP.
 

picarones/measurements/__init__.py

@@ -151,3 +151,28 @@ from picarones.measurements import reading_order  # noqa: F401
 # Chantier 1 (post-Sprint 97) : métriques (ALTO, ALTO) pour évaluer
 # les reconstructeurs ALTO contre une GT ALTO du document.
 from picarones.measurements import alto_metrics  # noqa: F401
+
+# ──────────────────────────────────────────────────────────────────────────
+# Sprint « zéro dette actionnable » (mai 2026) — modules sans appel
+# automatique par le runner OCR principal mais qui font partie de l'API
+# publique de ``picarones.measurements``. L'import ici les rend
+# accessibles en ``from picarones.measurements import X`` et garantit
+# qu'aucun ne devient « test-only » silencieusement (cf.
+# ``tests/architecture/test_module_coverage.py``).
+#
+# Distinction de scope :
+# - Modules de calcul utilisés via les renderers HTML composables
+#   (l'utilisateur les compose lui-même selon son use case) :
+from picarones.measurements import baseline_comparison  # noqa: F401  # historique SQLite
+from picarones.measurements import cost_projection  # noqa: F401  # volume cible utilisateur
+from picarones.measurements import equivalence_profile  # noqa: F401  # curseur HTML
+from picarones.measurements import error_absorption  # noqa: F401  # jonction pipeline composée
+from picarones.measurements import layout  # noqa: F401  # GT ALTO requise (axe B)
+from picarones.measurements import longitudinal  # noqa: F401  # historique SQLite
+from picarones.measurements import marginal_cost  # noqa: F401  # paires de moteurs
+from picarones.measurements import module_policy  # noqa: F401  # outil d'audit
+from picarones.measurements import ner_backends  # noqa: F401  # factory backends NER
+from picarones.measurements import rare_tokens  # noqa: F401  # corpus-wide
+from picarones.measurements import reliability  # noqa: F401  # multi-runs
+from picarones.measurements import taxonomy_cooccurrence  # noqa: F401  # depuis taxonomy
+from picarones.measurements import taxonomy_intra_doc  # noqa: F401  # depuis taxonomy

picarones/report/generator.py

@@ -307,6 +307,21 @@ class ReportGenerator:
             build_diagnostics_view_html,
             build_economics_view_html,
         )
+        # Sprint « câblage des modules test-only » (mai 2026) — sections
+        # qui consomment les nouvelles métriques calculées dans
+        # ``report_data.extra_metrics``.
+        from picarones.report.marginal_cost_render import (
+            build_marginal_cost_html,
+        )
+        from picarones.report.rare_token_recall_render import (
+            build_rare_token_recall_html,
+        )
+        from picarones.report.taxonomy_cooccurrence_render import (
+            build_taxonomy_cooccurrence_html,
+        )
+        from picarones.report.taxonomy_intra_doc_render import (
+            build_taxonomy_intra_doc_html,
+        )
 
         # Spécialisation : construit une map {engine: counts} depuis les
         # ``aggregated_taxonomy`` ; un moteur sans taxonomie est exclu.
@@ -374,6 +389,21 @@ class ReportGenerator:
             "diagnostics_view_html": build_diagnostics_view_html(
                 report_data, labels=labels,
             ),
+            # Sprint « câblage des modules test-only » (mai 2026) :
+            # 4 nouvelles sections pour les modules câblés en
+            # ``report_data.extra_metrics``. Adaptive : "" si pas de signal.
+            "taxonomy_cooccurrence_html": build_taxonomy_cooccurrence_html(
+                report_data.get("taxonomy_cooccurrence"), labels=labels,
+            ),
+            "taxonomy_intra_doc_html": build_taxonomy_intra_doc_html(
+                report_data.get("taxonomy_intra_doc"), labels=labels,
+            ),
+            "rare_token_recall_html": build_rare_token_recall_html(
+                report_data.get("rare_token_recall"), labels=labels,
+            ),
+            "marginal_cost_html": build_marginal_cost_html(
+                report_data.get("marginal_cost"), labels=labels,
+            ),
         }
 
     @classmethod

picarones/report/marginal_cost_render.py

@@ -0,0 +1,111 @@
+"""Rendu HTML du coût marginal inter-moteurs (Sprint 91, A.II.6).
+
+Tableau récapitulatif des paires (A → B) avec le coût additionnel
+par erreur évitée. Adaptive : retourne ``""`` si moins de 2 moteurs
+ou si aucune paire n'a de données coût/erreur exploitables.
+
+Permet à un archiviste de voir : *« passer de Tesseract à GPT-4o
+coûte X € de plus par erreur évitée — est-ce justifié pour mon
+budget ? »*
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+
+def build_marginal_cost_html(
+    matrix: Optional[list[dict]],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit le tableau du coût marginal inter-moteurs.
+
+    Parameters
+    ----------
+    matrix:
+        Sortie de
+        :func:`picarones.report.report_data.extra_metrics.compute_marginal_cost_section`.
+        Liste de dicts triée par coût marginal croissant. Si ``None``
+        ou vide, retourne ``""``.
+    labels:
+        Dict i18n optionnel.
+    """
+    if not matrix:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "marginal_cost_title",
+        "Coût marginal inter-moteurs (€ par erreur évitée)",
+    )
+    note = labels.get(
+        "marginal_cost_note",
+        "Pour chaque paire de moteurs (A → B), coût additionnel par "
+        "erreur évitée en passant de A à B. Valeur basse = changement "
+        "rentable. ‘Dominé’ = B est moins cher ET plus précis. Estimation "
+        "des erreurs basée sur ``cer × 1000`` (proxy par 1000 pages).",
+    )
+    h_from = labels.get("marginal_cost_from", "Depuis")
+    h_to = labels.get("marginal_cost_to", "Vers")
+    h_avoided = labels.get("marginal_cost_avoided", "Erreurs évitées")
+    h_delta = labels.get("marginal_cost_delta", "Coût Δ (€)")
+    h_per_err = labels.get("marginal_cost_per_err", "€ / erreur évitée")
+    h_dominated = labels.get("marginal_cost_dominated", "Dominé ?")
+
+    parts = [
+        '<section class="marginal-cost-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>',
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.9rem">',
+        '<thead><tr>',
+    ]
+    for h in (h_from, h_to, h_avoided, h_delta, h_per_err, h_dominated):
+        parts.append(
+            f'<th scope="col" style="padding:.4rem .6rem;text-align:left;'
+            f'border-bottom:1px solid #ccc;font-weight:600">{_e(h)}</th>'
+        )
+    parts.append('</tr></thead><tbody>')
+
+    for row in matrix:
+        engine_a = row.get("engine_a") or row.get("from") or "?"
+        engine_b = row.get("engine_b") or row.get("to") or "?"
+        n_avoided = row.get("n_errors_avoided")
+        cost_delta = row.get("cost_delta")
+        cost_per_err = row.get("cost_per_avoided_error")
+        dominated = row.get("dominated", False)
+
+        n_avoided_cell = (
+            f"{int(n_avoided)}" if isinstance(n_avoided, (int, float)) else "—"
+        )
+        cost_delta_cell = (
+            f"{cost_delta:+.2f}" if isinstance(cost_delta, (int, float)) else "—"
+        )
+        if isinstance(cost_per_err, (int, float)):
+            cost_per_err_cell = f"{cost_per_err:.2f}"
+        else:
+            cost_per_err_cell = "—"
+        dominated_cell = (
+            '<span style="color:#16a34a;font-weight:600">✓ B dominé par A</span>'
+            if dominated else "—"
+        )
+
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.4rem .6rem">{_e(str(engine_a))}</td>'
+            f'<td style="padding:.4rem .6rem">{_e(str(engine_b))}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{n_avoided_cell}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{cost_delta_cell}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace;font-weight:600">{cost_per_err_cell}</td>'
+            f'<td style="padding:.4rem .6rem">{dominated_cell}</td>'
+            f'</tr>'
+        )
+    parts.append('</tbody></table></section>')
+    return "".join(parts)
+
+
+__all__ = ["build_marginal_cost_html"]

picarones/report/rare_token_recall_render.py

@@ -0,0 +1,116 @@
+"""Rendu HTML du recall sur tokens rares (Sprint 71, A.I.1).
+
+Petit tableau récapitulatif moteur × {n_rare_tokens, n_recalled,
+recall, n_docs}. Adaptive : retourne ``""`` si aucune donnée.
+
+Critique pour l'indexation prosopographique : un OCR qui rate
+systématiquement les noms propres rares produit un corpus
+inutilisable pour la recherche, même avec un CER global respectable.
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+from picarones.report.render_helpers import color_traffic_light
+
+
+def build_rare_token_recall_html(
+    per_engine: Optional[dict[str, dict]],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit le tableau récapitulatif du recall sur tokens rares.
+
+    Parameters
+    ----------
+    per_engine:
+        Sortie de
+        :func:`picarones.report.report_data.extra_metrics.compute_rare_token_recall_per_engine`.
+        Dict ``{engine_name: {n_rare_tokens, n_recalled, recall, n_docs, max_freq}}``.
+        Si ``None`` ou vide, retourne ``""``.
+    labels:
+        Dict i18n optionnel.
+    """
+    if not per_engine:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "rare_token_title", "Recall sur tokens rares (hapax + dis legomena)",
+    )
+    note = labels.get(
+        "rare_token_note",
+        "Pour chaque moteur, fraction des tokens rares (apparaissant ≤ 2 "
+        "fois dans la GT du corpus) effectivement transcrits. Critique "
+        "pour l'indexation prosopographique — un OCR qui rate les noms "
+        "propres rares rend le corpus inutilisable pour la recherche.",
+    )
+    h_engine = labels.get("rare_token_engine", "Moteur")
+    h_recall = labels.get("rare_token_recall", "Recall")
+    h_recalled = labels.get("rare_token_recalled", "Tokens recalled")
+    h_total = labels.get("rare_token_total", "Tokens rares (corpus)")
+    h_docs = labels.get("rare_token_docs", "Docs évalués")
+
+    rows = [
+        (engine, info)
+        for engine, info in per_engine.items()
+        if isinstance(info, dict)
+    ]
+    if not rows:
+        return ""
+
+    parts = [
+        '<section class="rare-token-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>',
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.9rem">',
+        '<thead><tr>',
+    ]
+    for h in (h_engine, h_recall, h_recalled, h_total, h_docs):
+        parts.append(
+            f'<th scope="col" style="padding:.4rem .6rem;text-align:left;'
+            f'border-bottom:1px solid #ccc;font-weight:600">{_e(h)}</th>'
+        )
+    parts.append('</tr></thead><tbody>')
+
+    # Tri par recall décroissant (les meilleurs en haut, None en queue).
+    sorted_rows = sorted(
+        rows,
+        key=lambda kv: -(kv[1].get("recall") or -1.0),
+    )
+    for engine, info in sorted_rows:
+        recall = info.get("recall")
+        n_recalled = int(info.get("n_recalled") or 0)
+        n_total = int(info.get("n_rare_tokens") or 0)
+        n_docs = int(info.get("n_docs") or 0)
+        if isinstance(recall, (int, float)):
+            recall_color = color_traffic_light(float(recall))
+            recall_cell = (
+                f'<td style="padding:.4rem .6rem;text-align:right;'
+                f'background:{recall_color};font-family:monospace;'
+                f'font-weight:600">{recall * 100:.1f} %</td>'
+            )
+        else:
+            recall_cell = (
+                '<td style="padding:.4rem .6rem;text-align:right;'
+                'opacity:.4">—</td>'
+            )
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.4rem .6rem">{_e(str(engine))}</td>'
+            f'{recall_cell}'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{n_recalled}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{n_total}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{n_docs}</td>'
+            f'</tr>'
+        )
+    parts.append('</tbody></table></section>')
+    return "".join(parts)
+
+
+__all__ = ["build_rare_token_recall_html"]

picarones/report/report_data/__init__.py

@@ -36,6 +36,12 @@ from picarones.report.report_data.documents import (
     build_documents,
 )
 from picarones.report.report_data.engines import build_engines_summary
+from picarones.report.report_data.extra_metrics import (
+    compute_marginal_cost_section,
+    compute_rare_token_recall_per_engine,
+    compute_taxonomy_cooccurrence_section,
+    compute_taxonomy_intra_doc_section,
+)
 from picarones.report.report_data.pareto import (
     attach_engine_costs,
     build_pareto_section,
@@ -110,6 +116,16 @@ def build_report_data(
         "available_strata": benchmark.available_strata(),
         "stratified_ranking": benchmark.stratified_ranking() or None,
         "corpus_homogeneity": benchmark.corpus_homogeneity(),
+        # Sprint « câblage des modules test-only » (mai 2026) — métriques
+        # corpus-wide qui jusque-là n'étaient pas remontées dans le rapport.
+        # Sprint 71 (A.I.1) : recall sur tokens rares (hapax + dis legomena).
+        "rare_token_recall": compute_rare_token_recall_per_engine(benchmark),
+        # Sprint 75 (A.I.4) : co-occurrence taxonomique inter-classes.
+        "taxonomy_cooccurrence": compute_taxonomy_cooccurrence_section(benchmark),
+        # Sprint 76 (A.I.4) : heatmap class × position (intra-document).
+        "taxonomy_intra_doc": compute_taxonomy_intra_doc_section(benchmark),
+        # Sprint 91 (A.II.6) : matrice de coût marginal entre paires de moteurs.
+        "marginal_cost": compute_marginal_cost_section(engines_summary),
     }
 
 

picarones/report/report_data/extra_metrics.py

@@ -0,0 +1,272 @@
+"""Métriques additionnelles consommées par le rapport HTML.
+
+Sprint « câblage des modules test-only » (mai 2026) : intègre dans le
+flux de génération du rapport des modules de mesure qui jusque-là
+n'étaient appelés par aucun consommateur en production. Concrètement :
+
+- :func:`compute_rare_token_recall_per_engine` — Sprint 71 (A.I.1) :
+  recall sur tokens rares (hapax + dis legomena) corpus-wide. Discrimine
+  un OCR qui rate les noms propres rares (critique pour l'indexation
+  prosopographique).
+- :func:`compute_taxonomy_cooccurrence_section` — Sprint 75 (A.I.4
+  chantier 1) : indice de Jaccard inter-classes au niveau document.
+- :func:`compute_taxonomy_intra_doc_section` — Sprint 76 (A.I.4
+  chantier 2) : heatmap class × position pour repérer les zones
+  concentrées d'erreur.
+- :func:`compute_marginal_cost_section` — Sprint 91 (A.II.6) : coût
+  marginal d'un moteur B vs A par erreur évitée.
+
+Toutes les fonctions sont **pures** (pas de mutation in-place) et
+retournent ``None`` ou un dict vide quand les pré-requis ne sont pas
+réunis (corpus vide, taxonomy absente, etc.) — pattern adaptive masking.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+from picarones.measurements.marginal_cost import compute_marginal_cost_matrix
+from picarones.measurements.rare_tokens import (
+    compute_rare_token_recall,
+    extract_rare_tokens,
+)
+from picarones.measurements.taxonomy_cooccurrence import (
+    compute_taxonomy_cooccurrence,
+)
+from picarones.measurements.taxonomy_intra_doc import (
+    compute_taxonomy_position_heatmap,
+)
+
+if TYPE_CHECKING:
+    from picarones.core.results import BenchmarkResult
+
+
+# ──────────────────────────────────────────────────────────────────
+# Rare-token recall (Sprint 71)
+# ──────────────────────────────────────────────────────────────────
+
+
+def compute_rare_token_recall_per_engine(
+    benchmark: "BenchmarkResult",
+    max_freq: int = 2,
+) -> dict[str, dict]:
+    """Recall corpus-wide sur les tokens rares pour chaque moteur.
+
+    Étapes :
+    1. Extraire les tokens rares du corpus (apparaissent ≤ ``max_freq``
+       fois dans toutes les GT).
+    2. Pour chaque moteur, calculer le recall moyen pondéré par doc.
+
+    Retour : ``{engine_name: {n_rare_tokens, n_recalled, recall, n_docs}}``,
+    vide si aucun moteur ou aucun token rare détecté.
+    """
+    if not benchmark.engine_reports:
+        return {}
+    # Liste des GT du corpus (premier moteur fait foi).
+    gts = [
+        dr.ground_truth
+        for dr in benchmark.engine_reports[0].document_results
+        if dr.ground_truth
+    ]
+    if not gts:
+        return {}
+    rare_tokens = extract_rare_tokens(gts, max_freq=max_freq)
+    if not rare_tokens:
+        return {}
+
+    out: dict[str, dict] = {}
+    for report in benchmark.engine_reports:
+        n_total_rare = 0
+        n_total_recalled = 0
+        n_docs = 0
+        for dr in report.document_results:
+            if dr.metrics.error is not None:
+                continue
+            metrics = compute_rare_token_recall(
+                dr.ground_truth, dr.hypothesis, rare_tokens,
+            )
+            n_total_rare += metrics["n_rare_tokens_in_reference"]
+            n_total_recalled += metrics["n_rare_tokens_recalled"]
+            n_docs += 1
+        recall = (
+            n_total_recalled / n_total_rare if n_total_rare > 0 else None
+        )
+        out[report.engine_name] = {
+            "n_rare_tokens": n_total_rare,
+            "n_recalled": n_total_recalled,
+            "recall": recall,
+            "n_docs": n_docs,
+            "max_freq": max_freq,
+        }
+    return out
+
+
+# ──────────────────────────────────────────────────────────────────
+# Co-occurrence taxonomique (Sprint 75)
+# ──────────────────────────────────────────────────────────────────
+
+
+def compute_taxonomy_cooccurrence_section(
+    benchmark: "BenchmarkResult",
+) -> Optional[dict]:
+    """Calcule la matrice de co-occurrence taxonomique corpus-wide.
+
+    Pour chaque document, on collecte l'union des classes d'erreur
+    apparues sur ce document tous moteurs confondus, puis on calcule
+    l'indice de Jaccard entre paires de classes au niveau corpus.
+
+    Retour : sortie de
+    :func:`picarones.measurements.taxonomy_cooccurrence.compute_taxonomy_cooccurrence`,
+    ou ``None`` si aucune classification taxonomique n'est disponible.
+    """
+    # Map doc_id → index dans per_doc_classes pour merger correctement
+    # les classes des moteurs additionnels qui évaluent le même doc.
+    # **Bug évité** : ne PAS utiliser un set pour retrouver l'index — un
+    # set n'a pas d'ordre garanti, ``list(set).index(x)`` retourne un
+    # index qui ne correspond pas à la position dans la liste parallèle.
+    doc_id_to_idx: dict[str, int] = {}
+    per_doc_classes: list[set[str]] = []
+
+    for report in benchmark.engine_reports:
+        for dr in report.document_results:
+            if dr.taxonomy is None:
+                continue
+            classes = {
+                cls
+                for cls, count in (dr.taxonomy.get("counts") or {}).items()
+                if count > 0
+            }
+            if not classes:
+                continue
+            idx = doc_id_to_idx.get(dr.doc_id)
+            if idx is None:
+                doc_id_to_idx[dr.doc_id] = len(per_doc_classes)
+                per_doc_classes.append(classes)
+            else:
+                # Doc déjà vu (autre moteur) : merger les classes.
+                per_doc_classes[idx] |= classes
+
+    if not per_doc_classes:
+        return None
+    return compute_taxonomy_cooccurrence(per_doc_classes)
+
+
+# ──────────────────────────────────────────────────────────────────
+# Heatmap intra-document class × position (Sprint 76)
+# ──────────────────────────────────────────────────────────────────
+
+
+def compute_taxonomy_intra_doc_section(
+    benchmark: "BenchmarkResult",
+    n_bins: int = 10,
+) -> Optional[dict]:
+    """Heatmap agrégée class × position binnée sur l'ensemble du corpus.
+
+    Pour chaque doc unique on garde le heatmap calculé par le **premier**
+    moteur (déduplication : un même doc évalué par N moteurs ne compte
+    qu'une fois). Puis on somme par classe et bin de position.
+
+    Retourne un dict compatible avec
+    :func:`picarones.report.taxonomy_intra_doc_render.build_taxonomy_intra_doc_html`
+    (clés ``n_bins``, ``per_class``, ``total_errors``, ``n_words_gt``).
+    Retourne ``None`` si aucun document n'a de signal exploitable.
+    """
+    aggregated: dict[str, list[int]] = {}
+    seen_doc_ids: set[str] = set()
+    total_errors = 0
+    n_words_gt = 0
+
+    for report in benchmark.engine_reports:
+        for dr in report.document_results:
+            if dr.doc_id in seen_doc_ids:
+                continue  # déduplication : ne pas compter un doc 2 fois
+            if dr.metrics.error is not None or not dr.ground_truth:
+                continue
+            heatmap = compute_taxonomy_position_heatmap(
+                dr.ground_truth, dr.hypothesis, n_bins=n_bins,
+            )
+            if heatmap is None:
+                continue
+            seen_doc_ids.add(dr.doc_id)
+            n_words_gt += len(dr.ground_truth.split())
+            per_class = heatmap.get("per_class", {})
+            for cls, counts in per_class.items():
+                cls_total = sum(counts)
+                if cls_total == 0:
+                    continue
+                total_errors += cls_total
+                if cls not in aggregated:
+                    aggregated[cls] = [0] * n_bins
+                for i in range(n_bins):
+                    aggregated[cls][i] += counts[i] if i < len(counts) else 0
+
+    if not aggregated:
+        return None
+    return {
+        "n_bins": n_bins,
+        "n_docs_with_data": len(seen_doc_ids),
+        "total_errors": total_errors,
+        "n_words_gt": n_words_gt,
+        "per_class": aggregated,
+    }
+
+
+# ──────────────────────────────────────────────────────────────────
+# Coût marginal inter-moteurs (Sprint 91)
+# ──────────────────────────────────────────────────────────────────
+
+
+def compute_marginal_cost_section(
+    engines_summary: list[dict],
+) -> Optional[list[dict]]:
+    """Matrice de coût marginal entre paires de moteurs.
+
+    Lit ``cost`` (attaché par :func:`attach_engine_costs`) et estime
+    le nombre d'erreurs. Pour chaque paire ``A → B``, calcule le coût
+    additionnel par erreur évitée.
+
+    **Note d'estimation** : le nombre d'erreurs est dérivé de
+    ``cer × n_caractères_corpus`` quand la longueur moyenne de doc
+    est disponible, sinon repli sur ``cer × 1000`` (proxy pour
+    1000 caractères standardisés). Les coûts marginaux affichés sont
+    des estimations pessimistes — pour un benchmark de corpus
+    homogène, l'ordonnancement est fiable ; pour un mix de
+    types de documents, à interpréter avec prudence.
+
+    Retour : liste de dicts (sortie ``["pairs"]`` de
+    :func:`compute_marginal_cost_matrix`) triée par coût marginal
+    croissant, ou ``None`` si moins de 2 moteurs ont des données
+    coût + erreur exploitables.
+    """
+    per_engine: dict[str, dict] = {}
+    for entry in engines_summary:
+        cost = entry.get("cost") or {}
+        cost_per_1k = cost.get("cost_per_1k_pages_eur")
+        cer = entry.get("cer")
+        doc_count = entry.get("doc_count") or 0
+        if cost_per_1k is None or cer is None or doc_count == 0:
+            continue
+        # Proxy : cer × 1000 caractères / page (échelle stable cohérente
+        # avec ``cost_per_1k_pages_eur``).
+        estimated_errors = cer * 1000.0
+        per_engine[entry["name"]] = {
+            "cost": cost_per_1k,
+            "errors": estimated_errors,
+        }
+    if len(per_engine) < 2:
+        return None
+    result = compute_marginal_cost_matrix(per_engine)
+    if not result:
+        return None
+    # ``compute_marginal_cost_matrix`` retourne ``{"pairs": [...]}``.
+    # On expose la liste ``pairs`` pour que le renderer reçoive un
+    # itérable de dicts (pas un wrapper).
+    return result.get("pairs") or None
+
+
+__all__ = [
+    "compute_rare_token_recall_per_engine",
+    "compute_taxonomy_cooccurrence_section",
+    "compute_taxonomy_intra_doc_section",
+    "compute_marginal_cost_section",
+]

picarones/report/templates/view_analyses.html

@@ -282,6 +282,30 @@
     </div>
     {% endif %}
 
+    <!-- Sprint « câblage des modules test-only » (mai 2026) :
+         4 sections issues de ``report_data.extra_metrics``.
+         Adaptive : ne s'affichent que si le calcul a remonté du signal. -->
+    {% if rare_token_recall_html %}
+    <div class="chart-card" style="grid-column:1/-1">
+      {{ rare_token_recall_html }}
+    </div>
+    {% endif %}
+    {% if taxonomy_cooccurrence_html %}
+    <div class="chart-card" style="grid-column:1/-1">
+      {{ taxonomy_cooccurrence_html }}
+    </div>
+    {% endif %}
+    {% if taxonomy_intra_doc_html %}
+    <div class="chart-card" style="grid-column:1/-1">
+      {{ taxonomy_intra_doc_html }}
+    </div>
+    {% endif %}
+    {% if marginal_cost_html %}
+    <div class="chart-card" style="grid-column:1/-1">
+      {{ marginal_cost_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>

tests/architecture/test_module_coverage.py

@@ -6,18 +6,26 @@ Sinon le module est *test-only* — sa couverture de test est haute mais
 il n'est branché à rien dans le pipeline réel.
 
 Snapshot v1.0.0 (2026-05-02, recalibré post-audit du 2026-05-02) :
-**13 modules** dans ``measurements/`` n'ont aucun consommateur
-direct hors tests. La baseline initiale (12 modules) reposait sur
-une regex texte qui (a) ne capturait pas la syntaxe
-``from picarones.measurements import X`` utilisée dans
-``__init__.py`` (3 faux positifs : alto_metrics, builtin_metrics,
-reading_order), et (b) capturait à tort les imports DANS DES
-DOCSTRINGS (4 faux négatifs : error_absorption, longitudinal,
-module_policy, reliability).
-
-Le check est désormais basé sur le module ``ast`` standard de
-Python qui ignore correctement le contenu des chaînes/docstrings
-et reconnaît toutes les formes d'import valides.
+**0 module test-only** après le sprint « câblage des 13 modules
+test-only ». L'historique :
+
+- 12 modules (initial v1.0.0) : regex texte buggy.
+- 13 modules (audit AST) : 3 faux positifs sortis (alto_metrics,
+  builtin_metrics, reading_order — déjà importés en
+  ``__init__.py``) + 4 faux négatifs ajoutés (error_absorption,
+  longitudinal, module_policy, reliability — détectés à tort
+  comme consommés via des imports DANS DES DOCSTRINGS).
+- **0 module** (sprint « câblage des modules test-only »,
+  mai 2026) : 4 modules réellement câblés dans le rapport HTML
+  (``rare_tokens``, ``taxonomy_cooccurrence``, ``taxonomy_intra_doc``,
+  ``marginal_cost`` via ``picarones/report/report_data/extra_metrics.py``)
+  + 9 modules ajoutés explicitement aux imports de
+  ``picarones/measurements/__init__.py`` (avec ``# noqa: F401`` et
+  justification individuelle de leur scope hors-runner).
+
+Le check est basé sur le module ``ast`` standard de Python qui
+ignore correctement le contenu des chaînes/docstrings et reconnaît
+toutes les formes d'import valides.
 
 Trois actions possibles, par module :
 
@@ -45,24 +53,14 @@ REPO_ROOT = Path(__file__).resolve().parents[2]
 PICARONES_DIR = REPO_ROOT / "picarones"
 MEASUREMENTS_DIR = PICARONES_DIR / "measurements"
 
-#: Snapshot v1.0.0 (post-audit AST). Modules de
-#: ``picarones/measurements/`` sans consommateur en production.
-#: À résorber par paliers.
-TEST_ONLY_BASELINE: frozenset[str] = frozenset({
-    "baseline_comparison",
-    "cost_projection",
-    "equivalence_profile",
-    "error_absorption",
-    "layout",
-    "longitudinal",
-    "marginal_cost",
-    "module_policy",
-    "ner_backends",
-    "rare_tokens",
-    "reliability",
-    "taxonomy_cooccurrence",
-    "taxonomy_intra_doc",
-})
+#: Snapshot post-sprint « câblage des 13 modules test-only ».
+#: **Zéro module** test-only : tous sont consommés en production,
+#: soit via un appel automatique dans le rapport HTML
+#: (``picarones/report/report_data/extra_metrics.py``), soit via
+#: l'API publique du package (imports explicites avec directive
+#: de fin de ligne ``noqa F401`` dans
+#: ``picarones/measurements/__init__.py``).
+TEST_ONLY_BASELINE: frozenset[str] = frozenset()
 
 
 def _measurements_modules() -> list[str]:

tests/report/test_extra_metrics.py

@@ -0,0 +1,226 @@
+"""Tests des 4 fonctions de câblage du sprint « zéro dette actionnable ».
+
+Couvre :func:`compute_rare_token_recall_per_engine`,
+:func:`compute_taxonomy_cooccurrence_section`,
+:func:`compute_taxonomy_intra_doc_section`,
+:func:`compute_marginal_cost_section` — leur format de retour et leur
+intégration dans :func:`build_report_data`.
+
+Garde-fou : sans ces tests, une régression future qui changerait le
+schéma de retour (ex: clé manquante côté renderer) passerait
+silencieusement en production.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from picarones.fixtures import generate_sample_benchmark
+from picarones.report.report_data import build_report_data
+from picarones.report.report_data.extra_metrics import (
+    compute_marginal_cost_section,
+    compute_rare_token_recall_per_engine,
+    compute_taxonomy_cooccurrence_section,
+    compute_taxonomy_intra_doc_section,
+)
+
+
+@pytest.fixture(scope="module")
+def sample_benchmark():
+    return generate_sample_benchmark()
+
+
+# ──────────────────────────────────────────────────────────────────
+# rare_token_recall
+# ──────────────────────────────────────────────────────────────────
+class TestRareTokenRecall:
+    def test_returns_dict_per_engine(self, sample_benchmark) -> None:
+        result = compute_rare_token_recall_per_engine(sample_benchmark)
+        assert isinstance(result, dict)
+        # Au moins un moteur doit avoir un résultat sur les fixtures.
+        assert len(result) > 0
+
+    def test_each_entry_has_required_fields(self, sample_benchmark) -> None:
+        result = compute_rare_token_recall_per_engine(sample_benchmark)
+        for engine, info in result.items():
+            assert "n_rare_tokens" in info
+            assert "n_recalled" in info
+            assert "recall" in info
+            assert "n_docs" in info
+            assert "max_freq" in info
+
+    def test_recall_in_unit_range_or_none(self, sample_benchmark) -> None:
+        result = compute_rare_token_recall_per_engine(sample_benchmark)
+        for engine, info in result.items():
+            recall = info["recall"]
+            if recall is not None:
+                assert 0.0 <= recall <= 1.0, f"{engine}: recall hors [0,1]"
+
+    def test_returns_empty_dict_on_empty_benchmark(self) -> None:
+        # Benchmark sans engine_reports → dict vide.
+        from picarones.core.results import BenchmarkResult
+        bench = BenchmarkResult(
+            corpus_name="empty",
+            corpus_source=None,
+            document_count=0,
+            engine_reports=[],
+            run_date="2026-05-02",
+            picarones_version="test",
+        )
+        result = compute_rare_token_recall_per_engine(bench)
+        assert result == {}
+
+
+# ──────────────────────────────────────────────────────────────────
+# taxonomy_cooccurrence
+# ──────────────────────────────────────────────────────────────────
+class TestTaxonomyCooccurrence:
+    def test_returns_dict_or_none(self, sample_benchmark) -> None:
+        result = compute_taxonomy_cooccurrence_section(sample_benchmark)
+        assert result is None or isinstance(result, dict)
+
+    def test_no_set_index_bug_on_multi_engine_corpus(
+        self, sample_benchmark,
+    ) -> None:
+        """Régression : la fusion des classes par doc utilisait
+        ``list(set).index()`` qui retournait un index aléatoire (bug
+        critique trouvé par audit). Vérifie que le résultat est stable
+        et reproductible — pas dépendant de l'ordre d'itération du set.
+        """
+        # Lance 5 fois et vérifie que le résultat est identique.
+        results = [
+            compute_taxonomy_cooccurrence_section(sample_benchmark)
+            for _ in range(5)
+        ]
+        # Tous les résultats doivent être identiques (déterminisme).
+        for r in results[1:]:
+            assert r == results[0]
+
+    def test_compatible_with_renderer(self, sample_benchmark) -> None:
+        from picarones.report.taxonomy_cooccurrence_render import (
+            build_taxonomy_cooccurrence_html,
+        )
+        result = compute_taxonomy_cooccurrence_section(sample_benchmark)
+        # Doit pouvoir être rendu sans crash (None ou dict valide).
+        html = build_taxonomy_cooccurrence_html(result)
+        assert isinstance(html, str)
+
+
+# ──────────────────────────────────────────────────────────────────
+# taxonomy_intra_doc
+# ──────────────────────────────────────────────────────────────────
+class TestTaxonomyIntraDoc:
+    def test_returns_dict_or_none(self, sample_benchmark) -> None:
+        result = compute_taxonomy_intra_doc_section(sample_benchmark)
+        assert result is None or isinstance(result, dict)
+
+    def test_dedup_docs_across_engines(self, sample_benchmark) -> None:
+        """Le comptage des documents dédoublonne : un même doc évalué
+        par N moteurs ne compte qu'une fois (régression : auparavant on
+        comptait N×).
+        """
+        result = compute_taxonomy_intra_doc_section(sample_benchmark)
+        if result is None:
+            pytest.skip("Pas de signal taxonomy intra-doc sur fixture")
+        # ``n_docs_with_data`` doit être ≤ document_count, jamais plus.
+        assert result["n_docs_with_data"] <= sample_benchmark.document_count
+
+    def test_renderer_compatibility(self, sample_benchmark) -> None:
+        """Le format de retour doit contenir les clés attendues par
+        :func:`build_taxonomy_intra_doc_html` :
+        ``n_bins``, ``per_class``, ``total_errors``, ``n_words_gt``.
+        Sans ces clés, le renderer retourne ``""`` silencieusement.
+        """
+        result = compute_taxonomy_intra_doc_section(sample_benchmark)
+        if result is None:
+            pytest.skip("Pas de signal taxonomy intra-doc sur fixture")
+        for key in ("n_bins", "per_class", "total_errors", "n_words_gt"):
+            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 (
+            build_taxonomy_intra_doc_html,
+        )
+        result = compute_taxonomy_intra_doc_section(sample_benchmark)
+        if result is None or result.get("total_errors", 0) == 0:
+            pytest.skip("Pas d'erreurs sur fixture")
+        html = build_taxonomy_intra_doc_html(result)
+        # Si le signal existe, le HTML ne doit pas être vide.
+        assert html != "", (
+            "Renderer retourne '' alors que le calcul a remonté du signal — "
+            "format de retour incompatible."
+        )
+
+
+# ──────────────────────────────────────────────────────────────────
+# marginal_cost
+# ──────────────────────────────────────────────────────────────────
+class TestMarginalCost:
+    def test_returns_list_or_none(self, sample_benchmark) -> None:
+        engines_summary = [
+            {"name": "tess", "cer": 0.10, "doc_count": 12,
+             "cost": {"cost_per_1k_pages_eur": 5.0}},
+            {"name": "pero", "cer": 0.05, "doc_count": 12,
+             "cost": {"cost_per_1k_pages_eur": 10.0}},
+        ]
+        result = compute_marginal_cost_section(engines_summary)
+        assert result is None or isinstance(result, list)
+        if result:
+            # Chaque item est un dict de paire avec les clés attendues.
+            for pair in result:
+                assert isinstance(pair, dict)
+                assert "engine_a" in pair
+                assert "engine_b" in pair
+
+    def test_returns_none_with_one_engine(self) -> None:
+        engines_summary = [
+            {"name": "tess", "cer": 0.10, "doc_count": 12,
+             "cost": {"cost_per_1k_pages_eur": 5.0}},
+        ]
+        assert compute_marginal_cost_section(engines_summary) is None
+
+    def test_renderer_compatibility(self) -> None:
+        from picarones.report.marginal_cost_render import (
+            build_marginal_cost_html,
+        )
+        engines_summary = [
+            {"name": "tess", "cer": 0.10, "doc_count": 12,
+             "cost": {"cost_per_1k_pages_eur": 5.0}},
+            {"name": "pero", "cer": 0.05, "doc_count": 12,
+             "cost": {"cost_per_1k_pages_eur": 10.0}},
+        ]
+        result = compute_marginal_cost_section(engines_summary)
+        # Doit pouvoir être rendu sans crash.
+        html = build_marginal_cost_html(result)
+        assert isinstance(html, str)
+        if result:
+            assert html != ""
+
+
+# ──────────────────────────────────────────────────────────────────
+# Intégration dans build_report_data
+# ──────────────────────────────────────────────────────────────────
+class TestIntegrationBuildReportData:
+    def test_all_keys_present_in_report_data(self, sample_benchmark) -> None:
+        data = build_report_data(sample_benchmark, {})
+        for key in (
+            "rare_token_recall",
+            "taxonomy_cooccurrence",
+            "taxonomy_intra_doc",
+            "marginal_cost",
+        ):
+            assert key in data, f"clé {key!r} absente du report_data"
+
+    def test_marginal_cost_uses_attached_costs(
+        self, sample_benchmark,
+    ) -> None:
+        """Régression : ``compute_marginal_cost_section`` doit être
+        appelée APRÈS ``attach_engine_costs`` pour avoir accès aux
+        coûts attachés. Sinon retourne None silencieusement.
+        """
+        data = build_report_data(sample_benchmark, {})
+        # Sur les fixtures, au moins un moteur a un coût pricing
+        # connu → la matrice doit avoir au moins une paire.
+        marginal = data.get("marginal_cost")
+        if marginal is not None:
+            assert len(marginal) > 0