phaseA: extras/ pour modules Cercle 3 + hygiène anti-verdict

Première phase de la refonte en 3 cercles concentriques :

Cercle 1 (noyau invariant) ⊂ Cercle 2 (officiels) ⊂ Cercle 3 (plugins)

Cette phase A se concentre exclusivement sur l'extraction du Cercle 3
(modules niche, gouvernance préventive, renderers correspondants).
Les phases B (historical), C (importers), E (séparation core/measurements)
et D (doc API stable) suivront — voir docs/architecture-cercles.md.

Fichiers déplacés vers picarones/extras/ (8 modules, ~1700 lignes)
-------------------------------------------------------------------

extras/academic/ (modules sans cas d'usage prod direct) :
- taxonomy_intra_doc.py (heatmap classe×position, question rare)
- taxonomy_cooccurrence.py (matrice Jaccard inter-classes, académique)
- image_predictive.py (poids combinés éditoriaux arbitraires)

extras/governance/ (gouvernance préventive) :
- module_policy.py (manifest+audit modules tiers — inutile
tant qu'il n'y a pas 5+ modules contribués)

extras/render/ (renderers correspondants) :
- taxonomy_intra_doc_render.py
- taxonomy_cooccurrence_render.py
- image_predictive_render.py
- module_audit_render.py

Rétrocompatibilité absolue
--------------------------
Pour chaque module déplacé, un fichier-shim de 16 lignes reste à
l'ancien emplacement (``picarones/core/X.py`` ou
``picarones/report/X.py``) et ré-exporte les noms publics depuis le
nouveau chemin. Les imports historiques :

from picarones.core.taxonomy_intra_doc import compute_taxonomy_position_heatmap
from picarones.report.module_audit_render import build_module_audit_html

continuent à fonctionner sans modification. L'identité est préservée
(``shim.X is extras.X``) — pas de duplication de logique.

Hygiène anti-verdict (5 phrases reformulées)
---------------------------------------------
Le projet revendique « facts not verdicts »
(docs/user/reading-a-report.md). Quelques phrases prescriptives
s'étaient glissées :

- Template ``stratum_winner`` : « domine nettement » → factuel
« obtient le CER le plus bas (X% contre Y%) »
- Template ``confidence_warning`` : « Classement fragile » →
« Incertitude statistique élevée »
- i18n ``gini_cer_ideal`` : « idéal : bas-gauche » → « lecture :
bas-gauche »
- i18n ``gini_cer_note`` : « moteur idéal a CER bas ET Gini bas » →
« Un moteur dans la zone bas-gauche combine CER bas ET Gini
bas. Le choix selon ce graphe dépend du workflow visé. »
- i18n ``taxocomp_note`` : « préférable pour une édition critique »
→ « tend à produire des erreurs plus facilement corrigées en
édition critique »

Versions FR + EN cohérentes.

Document de cartographie
------------------------
docs/architecture-cercles.md (250 lignes) :
- Description des 3 cercles + leurs critères.
- Liste exhaustive des modules de chaque cercle.
- Tests concrets pour décider Cercle 1 vs 2 vs 3.
- Disclaimer : cartographie évolutive via RFC.

Validation 7/7 en sandbox
-------------------------
- 12 imports historiques (Cercle 3 via shims).
- 8 imports nouveaux chemins (extras/ direct).
- Identité shim → nouveau chemin préservée (test ``is``).
- Vue advanced_taxonomy du chantier 3 fonctionne avec données opt-in
``intra_doc`` provenant désormais de extras/academic/.
- 5 phrases reformulées détectées dans les fichiers (anti-régression).
- docs/architecture-cercles.md présent et complet.
- 8 shims minces (16 lignes chacun, pas de logique métier).

Tests
-----
+250 lignes dans tests/test_phaseA_migration.py organisés en 7 classes :
TestRetrocompatHistoricalImports, TestNewExtrasImports,
TestIdentityThroughShim, TestChantier3ViewsStillWork,
TestAntiVerdictHygiene, TestArchitectureCerclesDoc, TestOriginalsAreShims.

Verrou levé
-----------
Le Cercle 3 a une localisation physique distincte du cœur. Les modules
qui ne servent pas la question centrale du produit (« peut-on déployer
ce moteur en prod ? ») sont visiblement séparés. La discipline
architecturale devient enforceable par revue de PR (« ce module va
dans extras/ ? »).

Phases suivantes (option 2 — validation entre chaque)
-----------------------------------------------------
- Phase B : extras/historical/ (8 modules philologiques + renderers)
- Phase C : extras/importers/ (5 importers + statut experimental)
- Phase E : core/ → core/ (15 modules) + measurements/ (~30 modules)
- Phase D : docs/api-stable.md + test_public_api.py + version 2.0

docs/architecture-cercles.md

@@ -0,0 +1,206 @@
+# Architecture en 3 cercles — chantier de refonte post-chantier 6
+
+Ce document **fige la cartographie** de chaque module Picarones dans son
+cercle d'appartenance. Il sert de référence stable pour les
+contributions futures : avant d'ajouter un module, consulter ce
+document pour identifier dans quel cercle il doit aller.
+
+## Principe — 3 cercles concentriques
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  Cercle 3 — Plugins (extras/)                               │
+│  ┌─────────────────────────────────────────────────────┐    │
+│  │  Cercle 2 — Modules officiels                       │    │
+│  │  ┌──────────────────────────────────────────┐       │    │
+│  │  │  Cercle 1 — Noyau invariant (core/)      │       │    │
+│  │  │  API publique stable, ~15 modules        │       │    │
+│  │  └──────────────────────────────────────────┘       │    │
+│  │  Adapters, mesures, rapport, CLI, web               │    │
+│  │  ~30 modules métriques + ~15 adapters/UI            │    │
+│  └─────────────────────────────────────────────────────┘    │
+│  Modules niche, gouvernance préventive, importers exotiques │
+│  Distribués via extras pip ou packages séparés à terme      │
+└─────────────────────────────────────────────────────────────┘
+```
+
+Plus on s'éloigne du cœur, plus c'est optionnel et plus c'est facile
+à supprimer/remplacer/externaliser.
+
+## Cercle 1 — Noyau invariant
+
+**Critères** : ce qui définit *ce qu'est* Picarones. API publique
+stable. Ne casse pas entre versions mineures.
+
+**Localisation** : `picarones/core/` (après phase E) — strictement
+~15 modules.
+
+**Contenu** :
+
+| Module | Rôle |
+|---|---|
+| `corpus.py` | Document, Corpus, GTLevel multi-niveaux |
+| `modules.py` | BaseModule, ArtifactType (contrat unique pour modules tiers) |
+| `results.py` | BenchmarkResult, EngineReport, DocumentResult |
+| `metrics.py` | CER/WER/MER/WIL via jiwer (métriques de base) |
+| `runner.py` | Orchestrateur (parallélisation, reprise, timeout) |
+| `pipeline_runner.py` | Banc d'essai mono-doc des pipelines composées |
+| `pipeline_benchmark.py` | Orchestration corpus-wide |
+| `pipeline_comparison.py` | Comparaison de N pipelines |
+| `pipeline_spec_loader.py` | Chargement YAML déclaratif |
+| `metric_registry.py` | Registre typé `(input_type, output_type) → metric` |
+| `metric_hooks.py` | Profils + registre de hooks document/corpus |
+| `builtin_metrics.py` | CER/WER/MER/WIL enregistrés sur registre typé |
+| `alto_metrics.py` | Métriques `(ALTO, ALTO)` (chantier 1) |
+
+**Discipline** :
+- Toute modification non rétrocompatible exige une **RFC** et bump majeur.
+- Test `test_public_api.py` (à créer en phase D) qui échoue si un nom disparaît.
+- Aucun import direct depuis `extras/` ou de modules optionnels.
+
+## Cercle 2 — Modules officiels
+
+**Critères** : maintenu par les mainteneurs Picarones, livré par
+défaut, mais peut techniquement vivre ailleurs (un fork peut le
+remplacer par un équivalent).
+
+**Localisation** :
+- `picarones/measurements/` (après phase E) — métriques au-delà du CER de base.
+- `picarones/engines/` — adapters OCR.
+- `picarones/llm/` — adapters LLM.
+- `picarones/modules/` — modules `BaseModule` de référence (chantier 1).
+- `picarones/report/` — génération HTML.
+- `picarones/cli/` — interface CLI.
+- `picarones/web/` — interface web FastAPI.
+- `picarones/pipelines/` — pipelines OCR+LLM legacy (à statuer en phase D).
+
+**Métriques officielles** (futur `picarones/measurements/`) :
+
+| Catégorie | Modules |
+|---|---|
+| Texte | `confusion`, `char_scores`, `taxonomy`, `structure`, `taxonomy_comparison` |
+| Lignes | `line_metrics`, `hallucination` |
+| Fiabilité | `calibration`, `reliability`, `robustness`, `robustness_projection` |
+| Structure ALTO/PAGE | `reading_order`, `layout`, `error_absorption` |
+| Recherche | `searchability`, `numerical_sequences`, `rare_tokens` |
+| Lisibilité | `readability` (Flesch), `specialization` |
+| Inter-moteurs | `inter_engine`, `worst_lines` |
+| Économie | `throughput`, `cost_projection`, `marginal_cost`, `pricing` |
+| Comparaison | `incremental_comparison` |
+| Narrative | `narrative/` (engine + 6 familles de détecteurs) |
+| Hooks | `builtin_hooks` |
+| Contexte corpus | `history`, `difficulty`, `image_quality`, `normalization` |
+| Statistiques | `statistics` |
+| Levers | `levers` |
+
+**Discipline** :
+- Modification libre sans RFC.
+- Nouveau module doit s'enregistrer via `@register_metric` ou
+  `@register_document_metric` plutôt qu'imports directs depuis `runner.py`.
+- Couvre les 4 axes du produit : viabilité prod, hallucinations VLM,
+  pipelines composées, projection coût/vitesse.
+
+## Cercle 3 — Plugins
+
+**Critères** : ne sert pas tout le monde, peut être désactivé sans
+amputer le produit principal.
+
+**Localisation** : `picarones/extras/` (sous-package interne pour
+l'instant ; packages PyPI séparés possibles à terme).
+
+**Sous-packages** :
+
+### `extras/academic/` — modules techniques sans cas d'usage prod
+
+| Module | Pourquoi en plugin |
+|---|---|
+| `taxonomy_intra_doc.py` | Heatmap classe×position. Question rare, peu actionnable |
+| `taxonomy_cooccurrence.py` | Jaccard inter-classes. Académique, info rare |
+| `image_predictive.py` | Score combiné avec poids éditoriaux arbitraires |
+
+### `extras/governance/` — gouvernance préventive
+
+| Module | Pourquoi en plugin |
+|---|---|
+| `module_policy.py` | Manifest + audit pour modules contribués externes. Inutile tant qu'il n'y a pas 5+ modules tiers réels |
+
+### `extras/historical/` — métriques philologiques (phase B)
+
+| Module | Public spécifique |
+|---|---|
+| `unicode_blocks.py` | Tous périodes |
+| `abbreviations.py` | Médiéval (Capelli) |
+| `mufi.py` | Médiéval (PUA) |
+| `early_modern_typography.py` | XVIᵉ-XVIIIᵉ siècles |
+| `modern_archives.py` | XIXᵉ-XXᵉ siècles |
+| `roman_numerals.py` | Toutes périodes |
+| `lexical_modernization.py` | Édition critique |
+| `philological_runner.py` | Orchestration des 6 modules ci-dessus |
+
+### `extras/importers/` — imports externes (phase C)
+
+| Module | Statut |
+|---|---|
+| `_http.py` | Helpers HTTP partagés (chantier 4) |
+| `iiif.py` | Maintenu |
+| `htr_united.py` | Maintenu |
+| `gallica.py` | Maintenu |
+| `huggingface.py` | Expérimental (à finir ou marqué unstable) |
+| `escriptorium.py` | Expérimental (à finir ou marqué unstable) |
+
+### `extras/render/` — renderers correspondants
+
+Renderers atomiques pour les modules `extras/`. Importés
+conditionnellement par les vues thématiques du chantier 3 (qui sont
+elles-mêmes dans `report/views/`, donc Cercle 2).
+
+## Distinguer un module Cercle 1 vs Cercle 2
+
+Test concret : si on supprime ce module, est-ce que la phrase
+*« Picarones est un banc d'essai pour pipelines OCR/HTR/VLM »* reste
+vraie ?
+
+- **Oui** → Cercle 2 (le produit existe sans ce module).
+- **Non** → Cercle 1 (le module participe à la définition même).
+
+Exemple :
+- Sans `corpus.py` : impossible de charger un corpus → Cercle 1.
+- Sans `confusion.py` : on a toujours un bench fonctionnel sans
+  matrice de confusion → Cercle 2.
+- Sans `taxonomy_intra_doc.py` : on a toujours un bench complet et
+  utile → Cercle 3.
+
+## Distinguer un module Cercle 2 vs Cercle 3
+
+Test concret : ce module sert-il à répondre à la question
+*« peut-on déployer ce moteur en prod sur ce corpus dans nos
+contraintes ? »* — soit en mesurant un risque (hallucinations,
+stabilité), soit en projetant un coût (throughput, pricing), soit
+en évaluant la qualité (CER, calibration, structure) ?
+
+- **Oui** → Cercle 2.
+- **Non** → Cercle 3.
+
+Exemple :
+- `hallucination.py` : mesure un risque pour la prod VLM → Cercle 2.
+- `throughput.py` : projette un coût opérationnel → Cercle 2.
+- `taxonomy_intra_doc.py` : décrit une distribution sans implication
+  de décision → Cercle 3.
+
+## Disclaimer
+
+Cette cartographie est **une décision produit**, pas une vérité
+absolue. Elle peut évoluer si les usages réels d'institutions
+révèlent qu'un module Cercle 3 est en fait essentiel, ou
+inversement.
+
+Toute remise en cause doit passer par une RFC documentée, pas par
+une PR silencieuse.
+
+## Voir aussi
+
+- [`docs/architecture.md`](architecture.md) — vue d'ensemble post-chantiers 1-6.
+- [`docs/profiles.md`](profiles.md) — profils de calcul (chantier 2).
+- [`docs/views.md`](views.md) — vues HTML du rapport.
+- [`docs/cli-workflows.md`](cli-workflows.md) — commandes CLI.
+- `docs/api-stable.md` — *à créer en phase D* — engagement API publique du Cercle 1.

picarones/core/image_predictive.py

@@ -1,283 +1,20 @@
-"""Métriques d'image prédictives — Sprint 93 (A.II.7).
+"""Alias rétrocompat — module déplacé dans :mod:`picarones.extras.academic.image_predictive`.
 
-Sprint 93 — A.II.7 du plan d'évolution 2026.
+Phase A du chantier de refonte en 3 cercles (architecture-cercles.md).
+Le contenu vit désormais dans son cercle 3 ``extras/``. Cet alias
+permet aux imports historiques (``from picarones.core.image_predictive
+import ...``) de continuer à fonctionner sans modification.
 
-Pourquoi ce module
-------------------
-``image_quality`` (Sprint 5) mesure des features d'image
-indépendamment ; ce module **les combine** pour produire deux
-indicateurs corpus-level :
-
-1. **Score de complexité paléographique** ∈ [0, 1].  Combine
-   bruit, faible netteté, faible contraste et rotation en un
-   indicateur unique de la difficulté intrinsèque pour un OCR.
-   0 = document trivial, 1 = document extrême.  Permet
-   d'expliquer une partie du CER observé.
-
-2. **Score d'homogénéité du corpus** ∈ [0, 1].  Variance des
-   features entre documents.  0 = corpus uniforme (la moyenne
-   globale du benchmark est fiable), 1 = corpus hétérogène
-   (la moyenne ment, il faut stratifier).  Couplé au détecteur
-   ``stratification_recommended`` (Sprint 46) qui agit sur
-   ``script_type``.
-
-Pondérations
-------------
-La roadmap propose une combinaison **pondérée** sans fixer les
-poids — on adopte une convention éditoriale documentée :
-
-- ``noise_level``        : poids 0.30 (bruit franc → CER ↑)
-- ``1 - sharpness_score`` : poids 0.30 (flou → CER ↑)
-- ``1 - contrast_score``  : poids 0.20 (faible contraste → CER ↑)
-- ``|rotation_degrees|/30``  : poids 0.20 (rotation > 30° = pire)
-
-Les poids somment à 1.  L'utilisateur peut surcharger via
-``weights={...}``.
-
-Pas de prédiction CER absolue
------------------------------
-On ne prétend **pas** prédire une valeur CER en pourcentage —
-ça demanderait un modèle entraîné par moteur, ce que la
-philosophie banc d'essai exclut.  On fournit un score relatif
-qui se corrèle au CER observé pour une **lecture
-diagnostique** : *« le document A est ~3× plus complexe que le
-document B, ce qui est cohérent avec le CER observé. »*
+Voir :doc:`docs/architecture-cercles.md` pour la justification du
+classement de ce module au Cercle 3.
 """
 
-from __future__ import annotations
-
-import logging
-import math
-import statistics
-from typing import Iterable, Optional
-
-logger = logging.getLogger(__name__)
-
-
-# Poids éditoriaux par défaut.
-DEFAULT_COMPLEXITY_WEIGHTS = {
-    "noise_level": 0.30,
-    "blur": 0.30,           # 1 - sharpness_score
-    "low_contrast": 0.20,   # 1 - contrast_score
-    "rotation": 0.20,       # |rotation_degrees| / 30
-}
-
-
-# Plage de saturation pour la rotation.  Au-delà de 30°, on
-# considère que c'est aussi pire que pire.
-_ROTATION_SATURATION_DEG = 30.0
-
-
-def _clip01(x: float) -> float:
-    return max(0.0, min(1.0, x))
-
-
-def _extract_feature(
-    quality: dict, key: str, default: float = 0.0,
-) -> float:
-    val = quality.get(key, default)
-    if val is None:
-        return default
-    try:
-        return float(val)
-    except (TypeError, ValueError):
-        return default
-
-
-def compute_paleographic_complexity(
-    quality: dict,
-    *,
-    weights: Optional[dict[str, float]] = None,
-) -> Optional[dict]:
-    """Score de complexité paléographique d'une image.
-
-    Parameters
-    ----------
-    quality:
-        Dict ``ImageQualityResult.as_dict()`` ou compatible.
-        Champs lus : ``noise_level``, ``sharpness_score``,
-        ``contrast_score``, ``rotation_degrees``.
-    weights:
-        Poids surchargeant les défauts.  Doit contenir les
-        4 clés ``noise_level``, ``blur``, ``low_contrast``,
-        ``rotation``.  Les poids sont normalisés (somme = 1).
-
-    Returns
-    -------
-    dict | None
-        ``{
-            "score": float,                 # ∈ [0, 1]
-            "components": {
-                "noise": float, "blur": float,
-                "low_contrast": float, "rotation": float,
-            },
-            "weights_used": dict,
-        }`` ou ``None`` si ``quality`` est falsy.
-    """
-    if not quality:
-        return None
-    w = dict(DEFAULT_COMPLEXITY_WEIGHTS)
-    if weights:
-        for k in w:
-            if k in weights:
-                w[k] = float(weights[k])
-    total = sum(w.values())
-    if total <= 0:
-        return None
-    w = {k: v / total for k, v in w.items()}
-    noise = _clip01(_extract_feature(quality, "noise_level"))
-    sharpness = _clip01(_extract_feature(quality, "sharpness_score"))
-    contrast = _clip01(_extract_feature(quality, "contrast_score"))
-    rotation_deg = abs(_extract_feature(quality, "rotation_degrees"))
-    blur = 1.0 - sharpness
-    low_contrast = 1.0 - contrast
-    rotation = _clip01(rotation_deg / _ROTATION_SATURATION_DEG)
-    score = (
-        w["noise_level"] * noise
-        + w["blur"] * blur
-        + w["low_contrast"] * low_contrast
-        + w["rotation"] * rotation
-    )
-    return {
-        "score": _clip01(score),
-        "components": {
-            "noise": noise,
-            "blur": blur,
-            "low_contrast": low_contrast,
-            "rotation": rotation,
-        },
-        "weights_used": w,
-    }
-
-
-def compute_corpus_homogeneity(
-    image_qualities: Iterable[dict],
-) -> Optional[dict]:
-    """Score d'homogénéité du corpus ∈ [0, 1].
-
-    0 = corpus uniforme (faible variance entre documents),
-    1 = corpus hétérogène.
-
-    Méthode : pour chaque feature dans ``noise_level``,
-    ``sharpness_score``, ``contrast_score``, ``rotation_degrees``,
-    on calcule l'écart-type *normalisé* sur les documents (par
-    une plage de référence), puis on prend la moyenne des 4.
-
-    Plages de normalisation :
-    - ``noise_level``, ``sharpness_score``, ``contrast_score``
-      ∈ [0, 1] → écart-type / 0.5 (max théorique de l'écart-type
-      d'une distribution sur [0,1]) borné à 1.
-    - ``rotation_degrees`` → écart-type / 10°.
-
-    Parameters
-    ----------
-    image_qualities:
-        Itérable de dicts ``ImageQualityResult.as_dict()``.
-
-    Returns
-    -------
-    dict | None
-        ``{
-            "score": float,                 # ∈ [0, 1]
-            "n_docs": int,
-            "per_feature": {
-                feature: {"mean": float, "stdev": float,
-                          "normalised": float},
-            },
-        }`` ou ``None`` si moins de 2 documents.
-    """
-    docs = [q for q in image_qualities if q]
-    if len(docs) < 2:
-        return None
-    features = (
-        ("noise_level", 0.5),
-        ("sharpness_score", 0.5),
-        ("contrast_score", 0.5),
-        ("rotation_degrees", 10.0),
-    )
-    per_feature: dict[str, dict] = {}
-    norm_stdevs: list[float] = []
-    for key, divisor in features:
-        values = [
-            _extract_feature(q, key)
-            for q in docs
-        ]
-        if not values:
-            continue
-        mean = statistics.fmean(values)
-        try:
-            stdev = statistics.stdev(values) if len(values) >= 2 else 0.0
-        except statistics.StatisticsError:
-            stdev = 0.0
-        normalised = _clip01(stdev / divisor) if divisor > 0 else 0.0
-        per_feature[key] = {
-            "mean": mean,
-            "stdev": stdev,
-            "normalised": normalised,
-        }
-        norm_stdevs.append(normalised)
-    if not norm_stdevs:
-        return None
-    score = statistics.fmean(norm_stdevs)
-    return {
-        "score": _clip01(score),
-        "n_docs": len(docs),
-        "per_feature": per_feature,
-    }
-
-
-def aggregate_corpus_predictive(
-    image_qualities: Iterable[dict],
-    *,
-    weights: Optional[dict[str, float]] = None,
-) -> Optional[dict]:
-    """Synthèse corpus-wide : complexité moyenne + homogénéité.
-
-    Returns
-    -------
-    dict | None
-        ``{
-            "n_docs": int,
-            "complexity_mean": float,
-            "complexity_median": float,
-            "complexity_min": float,
-            "complexity_max": float,
-            "complexity_stdev": float,
-            "homogeneity": dict,            # sortie de
-                                            # compute_corpus_homogeneity
-        }`` ou ``None`` si moins d'un document.
-    """
-    docs = [q for q in image_qualities if q]
-    if not docs:
-        return None
-    scores: list[float] = []
-    for q in docs:
-        result = compute_paleographic_complexity(q, weights=weights)
-        if result is not None:
-            scores.append(float(result["score"]))
-    if not scores:
-        return None
-    homogeneity = compute_corpus_homogeneity(docs)
-    return {
-        "n_docs": len(docs),
-        "complexity_mean": statistics.fmean(scores),
-        "complexity_median": statistics.median(scores),
-        "complexity_min": min(scores),
-        "complexity_max": max(scores),
-        "complexity_stdev": (
-            statistics.stdev(scores) if len(scores) >= 2 else 0.0
-        ),
-        "homogeneity": homogeneity,
-    }
-
-
-__all__ = [
-    "DEFAULT_COMPLEXITY_WEIGHTS",
-    "compute_paleographic_complexity",
-    "compute_corpus_homogeneity",
-    "aggregate_corpus_predictive",
-]
-
+from picarones.extras.academic.image_predictive import *  # noqa: F401, F403
 
-# Évite warning import inutilisé
-_ = math
+# Réexport explicite des éventuels noms privés ou modules accédés
+# directement par leur attribut (rare mais possible). Pour la plupart
+# des modules, l'``import *`` ci-dessus suffit.
+import picarones.extras.academic.image_predictive as _module
+__all__ = getattr(_module, "__all__", [
+    name for name in dir(_module) if not name.startswith("_")
+])

picarones/core/module_policy.py

@@ -1,333 +1,20 @@
-"""Politique de modules contribués — Sprint 97 (B.6).
+"""Alias rétrocompat — module déplacé dans :mod:`picarones.extras.governance.module_policy`.
 
-Sprint 97 — B.6 du plan d'évolution 2026.
+Phase A du chantier de refonte en 3 cercles (architecture-cercles.md).
+Le contenu vit désormais dans son cercle 3 ``extras/``. Cet alias
+permet aux imports historiques (``from picarones.core.module_policy
+import ...``) de continuer à fonctionner sans modification.
 
-Pourquoi ce module
-------------------
-Avant d'ouvrir Picarones aux contributions externes (axe B —
-modules tiers que l'utilisateur amène), il faut un cadre de
-qualité explicite : *« un module qui ne passe pas l'audit
-n'est pas exécutable. »*
-
-Ce module fournit l'**enveloppe d'audit** :
-
-- ``ModuleManifest`` — métadonnées obligatoires (auteur,
-  licence, version, citation, contrat d'entrée/sortie typé).
-- ``validate_manifest(manifest)`` — vérifie que tous les champs
-  obligatoires sont présents et bien formés.
-- ``audit_module(module_class_or_instance, manifest)`` —
-  vérifie en plus que la classe respecte le contrat ``BaseModule``
-  et que ``input_types``/``output_types`` correspondent au
-  manifeste.
-- ``AuditResult`` — verdict structuré ``passed/failed`` + liste
-  des checks détaillés.
-
-Stratégie d'ouverture
----------------------
-Phase fermée actuelle : modules officiels uniquement,
-contributions via PR sur le repo principal.  Phase ouverte
-future : une fois 5–6 modules officiels stables, ouverture via
-``entry_points`` sur PyPI (``picarones-module-X``).  Ce module
-prépare la phase ouverte sans la déclencher : tout module
-externe devra fournir un ``ModuleManifest`` valide pour être
-exécuté.
-
-Pas de SPDX validator
----------------------
-On vérifie la présence et la non-vacuité des champs licence ;
-on ne valide pas la conformité SPDX du nom (``MIT`` vs
-``mit-license`` vs ``MIT License``).  Le chercheur reste
-responsable du choix de licence ; l'outil documente, il ne
-juge pas.
+Voir :doc:`docs/architecture-cercles.md` pour la justification du
+classement de ce module au Cercle 3.
 """
 
-from __future__ import annotations
-
-import logging
-from dataclasses import dataclass, field
-from typing import Any, Optional
-
-logger = logging.getLogger(__name__)
-
-
-# Champs obligatoires d'un ManifestModule (texte non-vide).
-_REQUIRED_TEXT_FIELDS = (
-    "name", "version", "author", "license",
-    "description",
-)
-
-
-@dataclass
-class ModuleManifest:
-    """Métadonnées d'un module contribué.
-
-    Attributes
-    ----------
-    name:
-        Identifiant unique du module (ex. ``"my-llm-correcteur"``).
-    version:
-        Version sémantique (ex. ``"1.2.0"``).
-    author:
-        Auteur ou institution responsable.
-    license:
-        Identifiant de licence (SPDX recommandé, non validé).
-    description:
-        Description courte (≤ 1 phrase).
-    input_types:
-        Liste des types d'entrée (chaînes).  Doit correspondre
-        à ``module.input_types`` (Sprint 33).
-    output_types:
-        Liste des types de sortie.  Doit correspondre à
-        ``module.output_types``.
-    citation:
-        Citation académique (BibTeX, DOI, ou texte libre).
-        Optionnel.
-    homepage:
-        URL du dépôt ou de la page projet. Optionnel.
-    picarones_min_version:
-        Version minimale de Picarones requise. Optionnel.
-    extra:
-        Métadonnées libres (clé → valeur).
-    """
-
-    name: str
-    version: str
-    author: str
-    license: str
-    description: str
-    input_types: list[str] = field(default_factory=list)
-    output_types: list[str] = field(default_factory=list)
-    citation: Optional[str] = None
-    homepage: Optional[str] = None
-    picarones_min_version: Optional[str] = None
-    extra: dict = field(default_factory=dict)
-
-    def as_dict(self) -> dict:
-        return {
-            "name": self.name,
-            "version": self.version,
-            "author": self.author,
-            "license": self.license,
-            "description": self.description,
-            "input_types": list(self.input_types),
-            "output_types": list(self.output_types),
-            "citation": self.citation,
-            "homepage": self.homepage,
-            "picarones_min_version": self.picarones_min_version,
-            "extra": dict(self.extra),
-        }
-
-
-@dataclass
-class AuditCheck:
-    """Un check individuel de l'audit."""
-
-    name: str
-    passed: bool
-    detail: Optional[str] = None
-
-    def as_dict(self) -> dict:
-        return {
-            "name": self.name,
-            "passed": self.passed,
-            "detail": self.detail,
-        }
-
-
-@dataclass
-class AuditResult:
-    """Résultat global d'un audit de module."""
-
-    module_name: str
-    passed: bool
-    checks: list[AuditCheck] = field(default_factory=list)
-
-    @property
-    def n_passed(self) -> int:
-        return sum(1 for c in self.checks if c.passed)
-
-    @property
-    def n_failed(self) -> int:
-        return sum(1 for c in self.checks if not c.passed)
-
-    def as_dict(self) -> dict:
-        return {
-            "module_name": self.module_name,
-            "passed": self.passed,
-            "n_passed": self.n_passed,
-            "n_failed": self.n_failed,
-            "checks": [c.as_dict() for c in self.checks],
-        }
-
-
-def validate_manifest(manifest: ModuleManifest) -> list[AuditCheck]:
-    """Vérifie qu'un manifest est complet et bien formé.
-
-    Returns
-    -------
-    list[AuditCheck]
-        Un check par champ obligatoire + un check pour
-        ``input_types``/``output_types`` non vides.
-    """
-    checks: list[AuditCheck] = []
-    for field_name in _REQUIRED_TEXT_FIELDS:
-        value = getattr(manifest, field_name, None)
-        ok = isinstance(value, str) and bool(value.strip())
-        checks.append(AuditCheck(
-            name=f"manifest.{field_name}",
-            passed=ok,
-            detail=None if ok else f"champ '{field_name}' vide ou absent",
-        ))
-    # input_types / output_types : au moins une entrée chacun
-    in_ok = (
-        isinstance(manifest.input_types, list)
-        and len(manifest.input_types) > 0
-        and all(
-            isinstance(t, str) and t for t in manifest.input_types
-        )
-    )
-    checks.append(AuditCheck(
-        name="manifest.input_types",
-        passed=in_ok,
-        detail=None if in_ok else "input_types vide ou non-string",
-    ))
-    out_ok = (
-        isinstance(manifest.output_types, list)
-        and len(manifest.output_types) > 0
-        and all(
-            isinstance(t, str) and t for t in manifest.output_types
-        )
-    )
-    checks.append(AuditCheck(
-        name="manifest.output_types",
-        passed=out_ok,
-        detail=None if out_ok else "output_types vide ou non-string",
-    ))
-    return checks
-
-
-def _is_base_module(cls: Any) -> bool:
-    """Best-effort : vérifie que cls hérite de BaseModule.
-
-    On ne **pas** importer ``BaseModule`` au top-level pour
-    éviter les cycles : on inspecte la chaîne de classes par
-    leur nom.
-    """
-    try:
-        for base in cls.__mro__:
-            if base.__name__ == "BaseModule":
-                return True
-    except AttributeError:
-        return False
-    return False
-
-
-def audit_module(
-    module_class_or_instance: Any,
-    manifest: ModuleManifest,
-) -> AuditResult:
-    """Audite un module contribué : interface + manifest.
-
-    Parameters
-    ----------
-    module_class_or_instance:
-        Soit la classe ``BaseModule`` (Sprint 33), soit une
-        instance.
-    manifest:
-        ``ModuleManifest`` correspondant au module.
-
-    Returns
-    -------
-    AuditResult
-        ``passed=True`` ssi tous les checks passent.
-    """
-    checks = validate_manifest(manifest)
-
-    # Check : héritage de BaseModule
-    cls = (
-        type(module_class_or_instance)
-        if not isinstance(module_class_or_instance, type)
-        else module_class_or_instance
-    )
-    inherits_base = _is_base_module(cls)
-    checks.append(AuditCheck(
-        name="module.inherits_base_module",
-        passed=inherits_base,
-        detail=(
-            None if inherits_base
-            else "la classe n'hérite pas de picarones.core.modules.BaseModule"
-        ),
-    ))
-
-    # Check : input_types / output_types correspondent
-    declared_in: list[str] = []
-    declared_out: list[str] = []
-    try:
-        instance = (
-            module_class_or_instance
-            if not isinstance(module_class_or_instance, type)
-            else None
-        )
-        attr_in = getattr(cls, "input_types", None)
-        attr_out = getattr(cls, "output_types", None)
-        if instance is not None:
-            attr_in = getattr(instance, "input_types", attr_in)
-            attr_out = getattr(instance, "output_types", attr_out)
-        if attr_in is not None:
-            declared_in = [
-                getattr(t, "value", str(t)) for t in attr_in
-            ]
-        if attr_out is not None:
-            declared_out = [
-                getattr(t, "value", str(t)) for t in attr_out
-            ]
-    except Exception:  # noqa: BLE001
-        pass
-    # Comparaison case-insensitive : on accepte "TEXT" ou "text"
-    # côté manifest, le contrat sémantique est le même.
-    declared_in_lower = sorted(t.lower() for t in declared_in)
-    declared_out_lower = sorted(t.lower() for t in declared_out)
-    manifest_in_lower = sorted(t.lower() for t in manifest.input_types)
-    manifest_out_lower = sorted(t.lower() for t in manifest.output_types)
-    in_match = declared_in_lower == manifest_in_lower
-    checks.append(AuditCheck(
-        name="module.input_types_match_manifest",
-        passed=in_match,
-        detail=(
-            None if in_match
-            else f"déclaré {declared_in} vs manifest {manifest.input_types}"
-        ),
-    ))
-    out_match = declared_out_lower == manifest_out_lower
-    checks.append(AuditCheck(
-        name="module.output_types_match_manifest",
-        passed=out_match,
-        detail=(
-            None if out_match
-            else f"déclaré {declared_out} vs manifest {manifest.output_types}"
-        ),
-    ))
-
-    # Check : process callable
-    has_process = callable(getattr(cls, "process", None))
-    checks.append(AuditCheck(
-        name="module.has_process",
-        passed=has_process,
-        detail=None if has_process else "méthode process() absente",
-    ))
-
-    passed = all(c.passed for c in checks)
-    return AuditResult(
-        module_name=manifest.name,
-        passed=passed,
-        checks=checks,
-    )
-
+from picarones.extras.governance.module_policy import *  # noqa: F401, F403
 
-__all__ = [
-    "ModuleManifest",
-    "AuditCheck",
-    "AuditResult",
-    "validate_manifest",
-    "audit_module",
-]
+# Réexport explicite des éventuels noms privés ou modules accédés
+# directement par leur attribut (rare mais possible). Pour la plupart
+# des modules, l'``import *`` ci-dessus suffit.
+import picarones.extras.governance.module_policy as _module
+__all__ = getattr(_module, "__all__", [
+    name for name in dir(_module) if not name.startswith("_")
+])

picarones/core/narrative/templates/en.yaml

@@ -16,8 +16,8 @@ significant_gap: >-
   (Wilcoxon, p = {p_value:.4f}, Δ CER = {delta_cer_pct} points over {n_pairs} pairs).
 
 stratum_winner: >-
-  On stratum "{stratum}" ({n_docs_stratum} documents), {engine} clearly
-  dominates with a CER of {cer_pct} % vs. {second_cer_pct} % for {second_engine}.
+  On stratum "{stratum}" ({n_docs_stratum} documents), {engine} achieves
+  the lowest CER ({cer_pct} % vs. {second_cer_pct} % for {second_engine}).
 
 stratum_collapse: >-
   {engine} is globally competitive ({global_cer_pct} %) but collapses on
@@ -42,8 +42,9 @@ speed_winner: >-
   median) for comparable quality (CER {cer_pct} %).
 
 confidence_warning: >-
-  Ranking is fragile: the {confidence_level} % confidence interval of {engine} spans
-  {ci_width_pct} CER points, compared with a gap of {gap_to_runner_up_pct} points to the runner-up.
+  High statistical uncertainty: the {confidence_level} % confidence interval of
+  {engine} spans {ci_width_pct} CER points, compared with a gap of
+  {gap_to_runner_up_pct} points to the runner-up.
 
 pareto_alternative: >-
   At much lower cost, {engine} offers an interesting trade-off ({cer_pct} %

picarones/core/narrative/templates/fr.yaml

@@ -20,8 +20,9 @@ significant_gap: >-
   (Wilcoxon, p = {p_value:.4f}, Δ CER = {delta_cer_pct} points sur {n_pairs} paires).
 
 stratum_winner: >-
-  Sur la strate « {stratum} » ({n_docs_stratum} documents), {engine} domine
-  nettement avec un CER de {cer_pct} % contre {second_cer_pct} % pour {second_engine}.
+  Sur la strate « {stratum} » ({n_docs_stratum} documents), {engine}
+  obtient le CER le plus bas ({cer_pct} % contre {second_cer_pct} %
+  pour {second_engine}).
 
 stratum_collapse: >-
   {engine} est globalement compétitif ({global_cer_pct} %) mais s'effondre sur
@@ -46,8 +47,9 @@ speed_winner: >-
   que la médiane) pour un CER comparable ({cer_pct} %).
 
 confidence_warning: >-
-  Classement fragile : l'intervalle de confiance à {confidence_level} % de {engine} s'étend
-  sur {ci_width_pct} points de CER, à comparer à l'écart de {gap_to_runner_up_pct} points avec le second.
+  Incertitude statistique élevée : l'intervalle de confiance à {confidence_level} %
+  de {engine} s'étend sur {ci_width_pct} points de CER, à comparer à l'écart de
+  {gap_to_runner_up_pct} points avec le second.
 
 pareto_alternative: >-
   À coût sensiblement inférieur, {engine} offre un compromis intéressant

picarones/core/taxonomy_cooccurrence.py

@@ -1,150 +1,20 @@
-"""Co-occurrence des classes taxonomiques d'erreur — Sprint 75 (A.I.4 chantier 1).
+"""Alias rétrocompat — module déplacé dans :mod:`picarones.extras.academic.taxonomy_cooccurrence`.
 
-Sprint 75 — A.I.4 chantier 1 du plan d'évolution 2026.
+Phase A du chantier de refonte en 3 cercles (architecture-cercles.md).
+Le contenu vit désormais dans son cercle 3 ``extras/``. Cet alias
+permet aux imports historiques (``from picarones.core.taxonomy_cooccurrence
+import ...``) de continuer à fonctionner sans modification.
 
-Pourquoi ce module
-------------------
-La taxonomie d'erreurs (10 classes, ``picarones/core/taxonomy.py``)
-est calculée par document mais le rapport actuel ne montre qu'un
-seul histogramme global.  La roadmap A.I.4 demande trois lectures
-plus fines de cette taxonomie ; ce sprint livre la première :
-**co-occurrence**.
-
-Si ``ligature_error`` et ``abbreviation_error`` co-occurrent
-toujours dans les mêmes documents, c'est un signal de scribe
-particulier — utile pour stratifier le corpus *a posteriori*
-(qu'est-ce qui caractérise les documents difficiles ?).
-
-Mesure
-------
-Indice de **Jaccard** entre paires de classes au niveau
-**document** :
-
-.. math::
-
-   J(A, B) = \\frac{|D_A \\cap D_B|}{|D_A \\cup D_B|}
-
-où ``D_X`` est l'ensemble des documents qui contiennent au moins
-une erreur de classe ``X``.
-
-- ``J(A, B) = 1`` : A et B apparaissent toujours ensemble (et
-  jamais l'un sans l'autre).
-- ``J(A, B) = 0`` : A et B ne co-occurrent jamais.
-- ``J(A, B) = 0,5`` : A et B partagent la moitié de leur union.
-
-Stratégie de découpage
-----------------------
-Couche de calcul pure d'abord (pattern Sprint 35, 38, 52-58).
-Le rendu HTML (heatmap SVG) est livré dans le même sprint pour
-boucler la dimension ; les chantiers 2 et 3 d'A.I.4 (évolution
-intra-document, taxonomie comparative) suivent.
+Voir :doc:`docs/architecture-cercles.md` pour la justification du
+classement de ce module au Cercle 3.
 """
 
-from __future__ import annotations
-
-import logging
-from typing import Iterable, Optional
-
-logger = logging.getLogger(__name__)
-
-
-def compute_taxonomy_cooccurrence(
-    per_doc_classes: Iterable[Iterable[str]],
-    *,
-    min_doc_count: int = 1,
-    top_n_pairs: int = 10,
-) -> Optional[dict]:
-    """Calcule la matrice de Jaccard inter-classes au niveau document.
-
-    Parameters
-    ----------
-    per_doc_classes:
-        Itérable de docs, chaque doc étant un itérable de noms de
-        classes taxonomiques détectées (set, list, tuple…).
-        Les doublons à l'intérieur d'un doc sont ignorés (présence
-        binaire au niveau doc).
-    min_doc_count:
-        Nombre minimum de documents dans lesquels une classe doit
-        apparaître pour figurer dans la matrice (défaut 1).
-        Permet d'écarter les classes anecdotiques.
-    top_n_pairs:
-        Nombre de paires retournées dans ``top_pairs`` (triées par
-        Jaccard décroissant).  Défaut 10.
-
-    Returns
-    -------
-    Optional[dict]
-        ``{
-            "classes": list[str],          # triées alpha
-            "n_documents": int,
-            "doc_count": dict[str, int],   # nb docs par classe
-            "cooccurrence_matrix": dict[str, dict[str, float]],
-                # symétrique, diagonale = 1.0 (sauf classe vide)
-            "top_pairs": list[tuple[str, str, float]],
-                # paires les plus co-occurrentes (Jaccard désc.)
-        }``
-        ou ``None`` si aucune classe ne dépasse ``min_doc_count``
-        ou si l'itérable est vide.
-    """
-    docs: list[frozenset[str]] = []
-    for doc_classes in per_doc_classes:
-        if doc_classes is None:
-            continue
-        cleaned = frozenset(c for c in doc_classes if c)
-        docs.append(cleaned)
-    if not docs:
-        return None
-
-    # Comptage par classe
-    doc_count: dict[str, int] = {}
-    for doc in docs:
-        for cls in doc:
-            doc_count[cls] = doc_count.get(cls, 0) + 1
-
-    # Filtrage min_doc_count
-    classes = sorted(
-        c for c, n in doc_count.items() if n >= min_doc_count
-    )
-    if not classes:
-        return None
-
-    # Matrice de Jaccard
-    matrix: dict[str, dict[str, float]] = {
-        c: {} for c in classes
-    }
-    for i, ca in enumerate(classes):
-        docs_a = {idx for idx, d in enumerate(docs) if ca in d}
-        for cb in classes[i:]:
-            if ca == cb:
-                # Diagonale : Jaccard(X, X) = 1 si X est présent
-                matrix[ca][cb] = 1.0 if docs_a else 0.0
-                continue
-            docs_b = {idx for idx, d in enumerate(docs) if cb in d}
-            inter = len(docs_a & docs_b)
-            union = len(docs_a | docs_b)
-            jaccard = inter / union if union > 0 else 0.0
-            matrix[ca][cb] = jaccard
-            matrix[cb][ca] = jaccard  # symétrique
-
-    # Top paires (hors diagonale)
-    pairs: list[tuple[str, str, float]] = []
-    for i, ca in enumerate(classes):
-        for cb in classes[i + 1:]:
-            j = matrix[ca][cb]
-            if j > 0:
-                pairs.append((ca, cb, j))
-    pairs.sort(key=lambda p: (-p[2], p[0], p[1]))
-    top_pairs = pairs[:top_n_pairs]
-
-    return {
-        "classes": classes,
-        "n_documents": len(docs),
-        "doc_count": doc_count,
-        "cooccurrence_matrix": matrix,
-        "top_pairs": top_pairs,
-    }
-
+from picarones.extras.academic.taxonomy_cooccurrence import *  # noqa: F401, F403
 
-__all__ = [
-    "compute_taxonomy_cooccurrence",
-]
+# Réexport explicite des éventuels noms privés ou modules accédés
+# directement par leur attribut (rare mais possible). Pour la plupart
+# des modules, l'``import *`` ci-dessus suffit.
+import picarones.extras.academic.taxonomy_cooccurrence as _module
+__all__ = getattr(_module, "__all__", [
+    name for name in dir(_module) if not name.startswith("_")
+])

picarones/core/taxonomy_intra_doc.py

@@ -1,202 +1,20 @@
-"""Évolution intra-document des classes taxonomiques — Sprint 76 (A.I.4 chantier 2).
+"""Alias rétrocompat — module déplacé dans :mod:`picarones.extras.academic.taxonomy_intra_doc`.
 
-Sprint 76 — A.I.4 chantier 2 du plan d'évolution 2026.
+Phase A du chantier de refonte en 3 cercles (architecture-cercles.md).
+Le contenu vit désormais dans son cercle 3 ``extras/``. Cet alias
+permet aux imports historiques (``from picarones.core.taxonomy_intra_doc
+import ...``) de continuer à fonctionner sans modification.
 
-Pourquoi ce module
-------------------
-La taxonomie d'erreurs (10 classes, ``picarones/core/taxonomy.py``)
-est calculée par document mais agrégée en un seul histogramme
-global.  ``line_metrics.py`` (Sprint 10) a déjà une heatmap de
-**CER par tranche de position** dans le document.  Ce sprint
-**étend cette heatmap à toutes les classes taxonomiques** : où
-dans le document apparaît tel type d'erreur ?
-
-Lecture concrète : si ``ligature_error`` est concentré dans la
-première tranche, c'est une erreur de **marge** (haut de page) ;
-si réparti uniformément, c'est une erreur de **scribe**.
-
-Implémentation
---------------
-On refait la classification mot-à-mot (cohérent avec
-``classify_errors``) en gardant la position du mot GT
-(``i1`` dans la diff word-level).  Chaque erreur est binnifiée
-selon sa position dans le document (``bin = floor(i1 / n_gt_words *
-n_bins)``).
-
-Sortie
-------
-``compute_taxonomy_position_heatmap(reference, hypothesis,
-n_bins=10)`` retourne un dict ``{class_name: list[float]}`` où
-chaque liste a ``n_bins`` valeurs représentant le **compte**
-d'erreurs de cette classe dans la tranche correspondante.
-
-Stratégie de découpage
-----------------------
-Couche de calcul + rendu HTML bout-en-bout, comme Sprint 75.
+Voir :doc:`docs/architecture-cercles.md` pour la justification du
+classement de ce module au Cercle 3.
 """
 
-from __future__ import annotations
-
-import difflib
-import logging
-import unicodedata
-from typing import Optional
-
-from picarones.core.taxonomy import (
-    ERROR_CLASSES,
-    _is_abbreviation_error,
-    _is_diacritic_error,
-    _is_ligature_error,
-    _is_oov_word,
-    _is_visual_confusion,
-)
-
-logger = logging.getLogger(__name__)
-
-
-def _classify_word_pair(gt_word: str, hyp_word: str) -> str:
-    """Retourne la classe taxonomique d'une erreur mot-à-mot.
-
-    Reproduit la logique de ``taxonomy._classify_word_error`` sans
-    modifier ses compteurs internes — utile pour avoir
-    ``(position, class)`` paire.
-    """
-    if gt_word.casefold() == hyp_word.casefold() and gt_word != hyp_word:
-        return "case_error"
-    gt_norm = unicodedata.normalize("NFC", gt_word)
-    hyp_norm = unicodedata.normalize("NFC", hyp_word)
-    if _is_ligature_error(gt_norm, hyp_norm):
-        return "ligature_error"
-    if _is_abbreviation_error(gt_norm, hyp_norm):
-        return "abbreviation_error"
-    if _is_diacritic_error(gt_norm, hyp_norm):
-        return "diacritic_error"
-    if _is_visual_confusion(gt_norm, hyp_norm):
-        return "visual_confusion"
-    if _is_oov_word(hyp_word):
-        return "oov_character"
-    return "hapax"
-
-
-def _bin_for_position(position: int, total: int, n_bins: int) -> int:
-    """Retourne l'index de bin pour une position (0-based) sur un
-    total de mots GT.  Garde-fou sur les bornes : si position == total
-    (peut arriver pour insert en fin de doc), on clip au dernier bin.
-    """
-    if total <= 0 or n_bins <= 0:
-        return 0
-    bin_idx = int((position / total) * n_bins)
-    if bin_idx >= n_bins:
-        bin_idx = n_bins - 1
-    if bin_idx < 0:
-        bin_idx = 0
-    return bin_idx
-
-
-def compute_taxonomy_position_heatmap(
-    reference: Optional[str],
-    hypothesis: Optional[str],
-    *,
-    n_bins: int = 10,
-) -> Optional[dict]:
-    """Calcule la heatmap class × position pour un document.
-
-    Parameters
-    ----------
-    reference:
-        Texte GT du document.
-    hypothesis:
-        Texte produit par l'OCR.
-    n_bins:
-        Nombre de tranches de position (défaut 10, cohérent avec
-        ``line_metrics.heatmap``).
-
-    Returns
-    -------
-    Optional[dict]
-        ``{
-            "n_bins": int,
-            "n_words_gt": int,           # nb mots GT
-            "total_errors": int,         # somme sur toutes classes
-            "per_class": {
-                class_name: list[int],  # n_bins valeurs (compte par bin)
-            },
-            "totals_per_bin": list[int], # nb total d'erreurs par bin
-        }``
-        Ou ``None`` si la GT est vide.
-    """
-    if n_bins <= 0:
-        raise ValueError("n_bins doit être > 0")
-    ref = reference or ""
-    hyp = hypothesis or ""
-    gt_words = ref.split()
-    hyp_words = hyp.split()
-    n_gt = len(gt_words)
-    if n_gt == 0:
-        return None
-
-    per_class: dict[str, list[int]] = {
-        cls: [0] * n_bins for cls in ERROR_CLASSES
-    }
-    totals_per_bin: list[int] = [0] * n_bins
-    total_errors = 0
-
-    matcher = difflib.SequenceMatcher(
-        None, gt_words, hyp_words, autojunk=False,
-    )
-    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
-        if tag == "equal":
-            continue
-        if tag == "delete":
-            for offset in range(i2 - i1):
-                position = i1 + offset
-                bin_idx = _bin_for_position(position, n_gt, n_bins)
-                per_class["lacuna"][bin_idx] += 1
-                totals_per_bin[bin_idx] += 1
-                total_errors += 1
-        elif tag == "insert":
-            # L'insert n'a pas de position GT propre : on attribue
-            # à la tranche de la position d'insertion (i1).
-            for w in hyp_words[j1:j2]:
-                if not _is_oov_word(w):
-                    continue
-                position = min(i1, n_gt - 1)
-                bin_idx = _bin_for_position(position, n_gt, n_bins)
-                per_class["oov_character"][bin_idx] += 1
-                totals_per_bin[bin_idx] += 1
-                total_errors += 1
-        elif tag == "replace":
-            gt_seg = gt_words[i1:i2]
-            hyp_seg = hyp_words[j1:j2]
-            if len(hyp_seg) != len(gt_seg):
-                # Segmentation : compte par diff de longueur
-                n_seg = abs(len(gt_seg) - len(hyp_seg))
-                bin_idx = _bin_for_position(i1, n_gt, n_bins)
-                per_class["segmentation_error"][bin_idx] += n_seg
-                totals_per_bin[bin_idx] += n_seg
-                total_errors += n_seg
-            else:
-                for offset, (gt_w, hyp_w) in enumerate(
-                    zip(gt_seg, hyp_seg),
-                ):
-                    if gt_w == hyp_w:
-                        continue
-                    position = i1 + offset
-                    bin_idx = _bin_for_position(position, n_gt, n_bins)
-                    cls = _classify_word_pair(gt_w, hyp_w)
-                    per_class[cls][bin_idx] += 1
-                    totals_per_bin[bin_idx] += 1
-                    total_errors += 1
-
-    return {
-        "n_bins": n_bins,
-        "n_words_gt": n_gt,
-        "total_errors": total_errors,
-        "per_class": per_class,
-        "totals_per_bin": totals_per_bin,
-    }
-
+from picarones.extras.academic.taxonomy_intra_doc import *  # noqa: F401, F403
 
-__all__ = [
-    "compute_taxonomy_position_heatmap",
-]
+# Réexport explicite des éventuels noms privés ou modules accédés
+# directement par leur attribut (rare mais possible). Pour la plupart
+# des modules, l'``import *`` ci-dessus suffit.
+import picarones.extras.academic.taxonomy_intra_doc as _module
+__all__ = getattr(_module, "__all__", [
+    name for name in dir(_module) if not name.startswith("_")
+])

picarones/extras/__init__.py

@@ -0,0 +1,23 @@
+"""Plugins Picarones — Cercle 3 de l'architecture.
+
+Modules optionnels, niche, ou préventifs qui ne servent pas
+directement la question centrale du produit (« peut-on déployer ce
+moteur en prod sur ce corpus ? »). Ils sont **séparables** : leur
+absence ne casse pas le bench standard.
+
+À terme, certains de ces sous-packages pourront être distribués comme
+packages PyPI séparés (``picarones-historical``, ``picarones-importers``).
+Pour l'instant ils vivent comme sous-packages internes pour limiter le
+churn.
+
+Convention de rétrocompat
+-------------------------
+Pour chaque module déplacé depuis ``picarones/core/`` ou
+``picarones/report/`` vers ``picarones/extras/``, un fichier-shim est
+laissé à l'ancien emplacement qui réexporte les noms publics. Les
+imports historiques (``from picarones.core.taxonomy_intra_doc import
+...``) continuent à fonctionner sans modification.
+
+Voir :doc:`docs/architecture-cercles.md` pour la cartographie complète
+et les critères d'assignation au Cercle 3.
+"""

picarones/extras/academic/__init__.py

@@ -0,0 +1,18 @@
+"""Modules techniques sans cas d'usage prod direct.
+
+Ces 3 modules calculent des distributions intéressantes pour la
+recherche académique mais ne participent pas à la décision
+*« peut-on déployer ce moteur en prod ? »*.
+
+Modules
+-------
+- :mod:`taxonomy_intra_doc`   — heatmap classe×position intra-document.
+- :mod:`taxonomy_cooccurrence` — matrice Jaccard inter-classes au niveau document.
+- :mod:`image_predictive`     — score de complexité paléographique (poids éditoriaux).
+
+Rétrocompat
+-----------
+Les imports historiques ``from picarones.core.taxonomy_intra_doc import
+...`` continuent à fonctionner via des fichiers-shims laissés à
+l'ancien emplacement.
+"""

picarones/extras/academic/image_predictive.py

@@ -0,0 +1,283 @@
+"""Métriques d'image prédictives — Sprint 93 (A.II.7).
+
+Sprint 93 — A.II.7 du plan d'évolution 2026.
+
+Pourquoi ce module
+------------------
+``image_quality`` (Sprint 5) mesure des features d'image
+indépendamment ; ce module **les combine** pour produire deux
+indicateurs corpus-level :
+
+1. **Score de complexité paléographique** ∈ [0, 1].  Combine
+   bruit, faible netteté, faible contraste et rotation en un
+   indicateur unique de la difficulté intrinsèque pour un OCR.
+   0 = document trivial, 1 = document extrême.  Permet
+   d'expliquer une partie du CER observé.
+
+2. **Score d'homogénéité du corpus** ∈ [0, 1].  Variance des
+   features entre documents.  0 = corpus uniforme (la moyenne
+   globale du benchmark est fiable), 1 = corpus hétérogène
+   (la moyenne ment, il faut stratifier).  Couplé au détecteur
+   ``stratification_recommended`` (Sprint 46) qui agit sur
+   ``script_type``.
+
+Pondérations
+------------
+La roadmap propose une combinaison **pondérée** sans fixer les
+poids — on adopte une convention éditoriale documentée :
+
+- ``noise_level``        : poids 0.30 (bruit franc → CER ↑)
+- ``1 - sharpness_score`` : poids 0.30 (flou → CER ↑)
+- ``1 - contrast_score``  : poids 0.20 (faible contraste → CER ↑)
+- ``|rotation_degrees|/30``  : poids 0.20 (rotation > 30° = pire)
+
+Les poids somment à 1.  L'utilisateur peut surcharger via
+``weights={...}``.
+
+Pas de prédiction CER absolue
+-----------------------------
+On ne prétend **pas** prédire une valeur CER en pourcentage —
+ça demanderait un modèle entraîné par moteur, ce que la
+philosophie banc d'essai exclut.  On fournit un score relatif
+qui se corrèle au CER observé pour une **lecture
+diagnostique** : *« le document A est ~3× plus complexe que le
+document B, ce qui est cohérent avec le CER observé. »*
+"""
+
+from __future__ import annotations
+
+import logging
+import math
+import statistics
+from typing import Iterable, Optional
+
+logger = logging.getLogger(__name__)
+
+
+# Poids éditoriaux par défaut.
+DEFAULT_COMPLEXITY_WEIGHTS = {
+    "noise_level": 0.30,
+    "blur": 0.30,           # 1 - sharpness_score
+    "low_contrast": 0.20,   # 1 - contrast_score
+    "rotation": 0.20,       # |rotation_degrees| / 30
+}
+
+
+# Plage de saturation pour la rotation.  Au-delà de 30°, on
+# considère que c'est aussi pire que pire.
+_ROTATION_SATURATION_DEG = 30.0
+
+
+def _clip01(x: float) -> float:
+    return max(0.0, min(1.0, x))
+
+
+def _extract_feature(
+    quality: dict, key: str, default: float = 0.0,
+) -> float:
+    val = quality.get(key, default)
+    if val is None:
+        return default
+    try:
+        return float(val)
+    except (TypeError, ValueError):
+        return default
+
+
+def compute_paleographic_complexity(
+    quality: dict,
+    *,
+    weights: Optional[dict[str, float]] = None,
+) -> Optional[dict]:
+    """Score de complexité paléographique d'une image.
+
+    Parameters
+    ----------
+    quality:
+        Dict ``ImageQualityResult.as_dict()`` ou compatible.
+        Champs lus : ``noise_level``, ``sharpness_score``,
+        ``contrast_score``, ``rotation_degrees``.
+    weights:
+        Poids surchargeant les défauts.  Doit contenir les
+        4 clés ``noise_level``, ``blur``, ``low_contrast``,
+        ``rotation``.  Les poids sont normalisés (somme = 1).
+
+    Returns
+    -------
+    dict | None
+        ``{
+            "score": float,                 # ∈ [0, 1]
+            "components": {
+                "noise": float, "blur": float,
+                "low_contrast": float, "rotation": float,
+            },
+            "weights_used": dict,
+        }`` ou ``None`` si ``quality`` est falsy.
+    """
+    if not quality:
+        return None
+    w = dict(DEFAULT_COMPLEXITY_WEIGHTS)
+    if weights:
+        for k in w:
+            if k in weights:
+                w[k] = float(weights[k])
+    total = sum(w.values())
+    if total <= 0:
+        return None
+    w = {k: v / total for k, v in w.items()}
+    noise = _clip01(_extract_feature(quality, "noise_level"))
+    sharpness = _clip01(_extract_feature(quality, "sharpness_score"))
+    contrast = _clip01(_extract_feature(quality, "contrast_score"))
+    rotation_deg = abs(_extract_feature(quality, "rotation_degrees"))
+    blur = 1.0 - sharpness
+    low_contrast = 1.0 - contrast
+    rotation = _clip01(rotation_deg / _ROTATION_SATURATION_DEG)
+    score = (
+        w["noise_level"] * noise
+        + w["blur"] * blur
+        + w["low_contrast"] * low_contrast
+        + w["rotation"] * rotation
+    )
+    return {
+        "score": _clip01(score),
+        "components": {
+            "noise": noise,
+            "blur": blur,
+            "low_contrast": low_contrast,
+            "rotation": rotation,
+        },
+        "weights_used": w,
+    }
+
+
+def compute_corpus_homogeneity(
+    image_qualities: Iterable[dict],
+) -> Optional[dict]:
+    """Score d'homogénéité du corpus ∈ [0, 1].
+
+    0 = corpus uniforme (faible variance entre documents),
+    1 = corpus hétérogène.
+
+    Méthode : pour chaque feature dans ``noise_level``,
+    ``sharpness_score``, ``contrast_score``, ``rotation_degrees``,
+    on calcule l'écart-type *normalisé* sur les documents (par
+    une plage de référence), puis on prend la moyenne des 4.
+
+    Plages de normalisation :
+    - ``noise_level``, ``sharpness_score``, ``contrast_score``
+      ∈ [0, 1] → écart-type / 0.5 (max théorique de l'écart-type
+      d'une distribution sur [0,1]) borné à 1.
+    - ``rotation_degrees`` → écart-type / 10°.
+
+    Parameters
+    ----------
+    image_qualities:
+        Itérable de dicts ``ImageQualityResult.as_dict()``.
+
+    Returns
+    -------
+    dict | None
+        ``{
+            "score": float,                 # ∈ [0, 1]
+            "n_docs": int,
+            "per_feature": {
+                feature: {"mean": float, "stdev": float,
+                          "normalised": float},
+            },
+        }`` ou ``None`` si moins de 2 documents.
+    """
+    docs = [q for q in image_qualities if q]
+    if len(docs) < 2:
+        return None
+    features = (
+        ("noise_level", 0.5),
+        ("sharpness_score", 0.5),
+        ("contrast_score", 0.5),
+        ("rotation_degrees", 10.0),
+    )
+    per_feature: dict[str, dict] = {}
+    norm_stdevs: list[float] = []
+    for key, divisor in features:
+        values = [
+            _extract_feature(q, key)
+            for q in docs
+        ]
+        if not values:
+            continue
+        mean = statistics.fmean(values)
+        try:
+            stdev = statistics.stdev(values) if len(values) >= 2 else 0.0
+        except statistics.StatisticsError:
+            stdev = 0.0
+        normalised = _clip01(stdev / divisor) if divisor > 0 else 0.0
+        per_feature[key] = {
+            "mean": mean,
+            "stdev": stdev,
+            "normalised": normalised,
+        }
+        norm_stdevs.append(normalised)
+    if not norm_stdevs:
+        return None
+    score = statistics.fmean(norm_stdevs)
+    return {
+        "score": _clip01(score),
+        "n_docs": len(docs),
+        "per_feature": per_feature,
+    }
+
+
+def aggregate_corpus_predictive(
+    image_qualities: Iterable[dict],
+    *,
+    weights: Optional[dict[str, float]] = None,
+) -> Optional[dict]:
+    """Synthèse corpus-wide : complexité moyenne + homogénéité.
+
+    Returns
+    -------
+    dict | None
+        ``{
+            "n_docs": int,
+            "complexity_mean": float,
+            "complexity_median": float,
+            "complexity_min": float,
+            "complexity_max": float,
+            "complexity_stdev": float,
+            "homogeneity": dict,            # sortie de
+                                            # compute_corpus_homogeneity
+        }`` ou ``None`` si moins d'un document.
+    """
+    docs = [q for q in image_qualities if q]
+    if not docs:
+        return None
+    scores: list[float] = []
+    for q in docs:
+        result = compute_paleographic_complexity(q, weights=weights)
+        if result is not None:
+            scores.append(float(result["score"]))
+    if not scores:
+        return None
+    homogeneity = compute_corpus_homogeneity(docs)
+    return {
+        "n_docs": len(docs),
+        "complexity_mean": statistics.fmean(scores),
+        "complexity_median": statistics.median(scores),
+        "complexity_min": min(scores),
+        "complexity_max": max(scores),
+        "complexity_stdev": (
+            statistics.stdev(scores) if len(scores) >= 2 else 0.0
+        ),
+        "homogeneity": homogeneity,
+    }
+
+
+__all__ = [
+    "DEFAULT_COMPLEXITY_WEIGHTS",
+    "compute_paleographic_complexity",
+    "compute_corpus_homogeneity",
+    "aggregate_corpus_predictive",
+]
+
+
+# Évite warning import inutilisé
+_ = math

picarones/extras/academic/taxonomy_cooccurrence.py

@@ -0,0 +1,150 @@
+"""Co-occurrence des classes taxonomiques d'erreur — Sprint 75 (A.I.4 chantier 1).
+
+Sprint 75 — A.I.4 chantier 1 du plan d'évolution 2026.
+
+Pourquoi ce module
+------------------
+La taxonomie d'erreurs (10 classes, ``picarones/core/taxonomy.py``)
+est calculée par document mais le rapport actuel ne montre qu'un
+seul histogramme global.  La roadmap A.I.4 demande trois lectures
+plus fines de cette taxonomie ; ce sprint livre la première :
+**co-occurrence**.
+
+Si ``ligature_error`` et ``abbreviation_error`` co-occurrent
+toujours dans les mêmes documents, c'est un signal de scribe
+particulier — utile pour stratifier le corpus *a posteriori*
+(qu'est-ce qui caractérise les documents difficiles ?).
+
+Mesure
+------
+Indice de **Jaccard** entre paires de classes au niveau
+**document** :
+
+.. math::
+
+   J(A, B) = \\frac{|D_A \\cap D_B|}{|D_A \\cup D_B|}
+
+où ``D_X`` est l'ensemble des documents qui contiennent au moins
+une erreur de classe ``X``.
+
+- ``J(A, B) = 1`` : A et B apparaissent toujours ensemble (et
+  jamais l'un sans l'autre).
+- ``J(A, B) = 0`` : A et B ne co-occurrent jamais.
+- ``J(A, B) = 0,5`` : A et B partagent la moitié de leur union.
+
+Stratégie de découpage
+----------------------
+Couche de calcul pure d'abord (pattern Sprint 35, 38, 52-58).
+Le rendu HTML (heatmap SVG) est livré dans le même sprint pour
+boucler la dimension ; les chantiers 2 et 3 d'A.I.4 (évolution
+intra-document, taxonomie comparative) suivent.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Iterable, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def compute_taxonomy_cooccurrence(
+    per_doc_classes: Iterable[Iterable[str]],
+    *,
+    min_doc_count: int = 1,
+    top_n_pairs: int = 10,
+) -> Optional[dict]:
+    """Calcule la matrice de Jaccard inter-classes au niveau document.
+
+    Parameters
+    ----------
+    per_doc_classes:
+        Itérable de docs, chaque doc étant un itérable de noms de
+        classes taxonomiques détectées (set, list, tuple…).
+        Les doublons à l'intérieur d'un doc sont ignorés (présence
+        binaire au niveau doc).
+    min_doc_count:
+        Nombre minimum de documents dans lesquels une classe doit
+        apparaître pour figurer dans la matrice (défaut 1).
+        Permet d'écarter les classes anecdotiques.
+    top_n_pairs:
+        Nombre de paires retournées dans ``top_pairs`` (triées par
+        Jaccard décroissant).  Défaut 10.
+
+    Returns
+    -------
+    Optional[dict]
+        ``{
+            "classes": list[str],          # triées alpha
+            "n_documents": int,
+            "doc_count": dict[str, int],   # nb docs par classe
+            "cooccurrence_matrix": dict[str, dict[str, float]],
+                # symétrique, diagonale = 1.0 (sauf classe vide)
+            "top_pairs": list[tuple[str, str, float]],
+                # paires les plus co-occurrentes (Jaccard désc.)
+        }``
+        ou ``None`` si aucune classe ne dépasse ``min_doc_count``
+        ou si l'itérable est vide.
+    """
+    docs: list[frozenset[str]] = []
+    for doc_classes in per_doc_classes:
+        if doc_classes is None:
+            continue
+        cleaned = frozenset(c for c in doc_classes if c)
+        docs.append(cleaned)
+    if not docs:
+        return None
+
+    # Comptage par classe
+    doc_count: dict[str, int] = {}
+    for doc in docs:
+        for cls in doc:
+            doc_count[cls] = doc_count.get(cls, 0) + 1
+
+    # Filtrage min_doc_count
+    classes = sorted(
+        c for c, n in doc_count.items() if n >= min_doc_count
+    )
+    if not classes:
+        return None
+
+    # Matrice de Jaccard
+    matrix: dict[str, dict[str, float]] = {
+        c: {} for c in classes
+    }
+    for i, ca in enumerate(classes):
+        docs_a = {idx for idx, d in enumerate(docs) if ca in d}
+        for cb in classes[i:]:
+            if ca == cb:
+                # Diagonale : Jaccard(X, X) = 1 si X est présent
+                matrix[ca][cb] = 1.0 if docs_a else 0.0
+                continue
+            docs_b = {idx for idx, d in enumerate(docs) if cb in d}
+            inter = len(docs_a & docs_b)
+            union = len(docs_a | docs_b)
+            jaccard = inter / union if union > 0 else 0.0
+            matrix[ca][cb] = jaccard
+            matrix[cb][ca] = jaccard  # symétrique
+
+    # Top paires (hors diagonale)
+    pairs: list[tuple[str, str, float]] = []
+    for i, ca in enumerate(classes):
+        for cb in classes[i + 1:]:
+            j = matrix[ca][cb]
+            if j > 0:
+                pairs.append((ca, cb, j))
+    pairs.sort(key=lambda p: (-p[2], p[0], p[1]))
+    top_pairs = pairs[:top_n_pairs]
+
+    return {
+        "classes": classes,
+        "n_documents": len(docs),
+        "doc_count": doc_count,
+        "cooccurrence_matrix": matrix,
+        "top_pairs": top_pairs,
+    }
+
+
+__all__ = [
+    "compute_taxonomy_cooccurrence",
+]

picarones/extras/academic/taxonomy_intra_doc.py

@@ -0,0 +1,202 @@
+"""Évolution intra-document des classes taxonomiques — Sprint 76 (A.I.4 chantier 2).
+
+Sprint 76 — A.I.4 chantier 2 du plan d'évolution 2026.
+
+Pourquoi ce module
+------------------
+La taxonomie d'erreurs (10 classes, ``picarones/core/taxonomy.py``)
+est calculée par document mais agrégée en un seul histogramme
+global.  ``line_metrics.py`` (Sprint 10) a déjà une heatmap de
+**CER par tranche de position** dans le document.  Ce sprint
+**étend cette heatmap à toutes les classes taxonomiques** : où
+dans le document apparaît tel type d'erreur ?
+
+Lecture concrète : si ``ligature_error`` est concentré dans la
+première tranche, c'est une erreur de **marge** (haut de page) ;
+si réparti uniformément, c'est une erreur de **scribe**.
+
+Implémentation
+--------------
+On refait la classification mot-à-mot (cohérent avec
+``classify_errors``) en gardant la position du mot GT
+(``i1`` dans la diff word-level).  Chaque erreur est binnifiée
+selon sa position dans le document (``bin = floor(i1 / n_gt_words *
+n_bins)``).
+
+Sortie
+------
+``compute_taxonomy_position_heatmap(reference, hypothesis,
+n_bins=10)`` retourne un dict ``{class_name: list[float]}`` où
+chaque liste a ``n_bins`` valeurs représentant le **compte**
+d'erreurs de cette classe dans la tranche correspondante.
+
+Stratégie de découpage
+----------------------
+Couche de calcul + rendu HTML bout-en-bout, comme Sprint 75.
+"""
+
+from __future__ import annotations
+
+import difflib
+import logging
+import unicodedata
+from typing import Optional
+
+from picarones.core.taxonomy import (
+    ERROR_CLASSES,
+    _is_abbreviation_error,
+    _is_diacritic_error,
+    _is_ligature_error,
+    _is_oov_word,
+    _is_visual_confusion,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def _classify_word_pair(gt_word: str, hyp_word: str) -> str:
+    """Retourne la classe taxonomique d'une erreur mot-à-mot.
+
+    Reproduit la logique de ``taxonomy._classify_word_error`` sans
+    modifier ses compteurs internes — utile pour avoir
+    ``(position, class)`` paire.
+    """
+    if gt_word.casefold() == hyp_word.casefold() and gt_word != hyp_word:
+        return "case_error"
+    gt_norm = unicodedata.normalize("NFC", gt_word)
+    hyp_norm = unicodedata.normalize("NFC", hyp_word)
+    if _is_ligature_error(gt_norm, hyp_norm):
+        return "ligature_error"
+    if _is_abbreviation_error(gt_norm, hyp_norm):
+        return "abbreviation_error"
+    if _is_diacritic_error(gt_norm, hyp_norm):
+        return "diacritic_error"
+    if _is_visual_confusion(gt_norm, hyp_norm):
+        return "visual_confusion"
+    if _is_oov_word(hyp_word):
+        return "oov_character"
+    return "hapax"
+
+
+def _bin_for_position(position: int, total: int, n_bins: int) -> int:
+    """Retourne l'index de bin pour une position (0-based) sur un
+    total de mots GT.  Garde-fou sur les bornes : si position == total
+    (peut arriver pour insert en fin de doc), on clip au dernier bin.
+    """
+    if total <= 0 or n_bins <= 0:
+        return 0
+    bin_idx = int((position / total) * n_bins)
+    if bin_idx >= n_bins:
+        bin_idx = n_bins - 1
+    if bin_idx < 0:
+        bin_idx = 0
+    return bin_idx
+
+
+def compute_taxonomy_position_heatmap(
+    reference: Optional[str],
+    hypothesis: Optional[str],
+    *,
+    n_bins: int = 10,
+) -> Optional[dict]:
+    """Calcule la heatmap class × position pour un document.
+
+    Parameters
+    ----------
+    reference:
+        Texte GT du document.
+    hypothesis:
+        Texte produit par l'OCR.
+    n_bins:
+        Nombre de tranches de position (défaut 10, cohérent avec
+        ``line_metrics.heatmap``).
+
+    Returns
+    -------
+    Optional[dict]
+        ``{
+            "n_bins": int,
+            "n_words_gt": int,           # nb mots GT
+            "total_errors": int,         # somme sur toutes classes
+            "per_class": {
+                class_name: list[int],  # n_bins valeurs (compte par bin)
+            },
+            "totals_per_bin": list[int], # nb total d'erreurs par bin
+        }``
+        Ou ``None`` si la GT est vide.
+    """
+    if n_bins <= 0:
+        raise ValueError("n_bins doit être > 0")
+    ref = reference or ""
+    hyp = hypothesis or ""
+    gt_words = ref.split()
+    hyp_words = hyp.split()
+    n_gt = len(gt_words)
+    if n_gt == 0:
+        return None
+
+    per_class: dict[str, list[int]] = {
+        cls: [0] * n_bins for cls in ERROR_CLASSES
+    }
+    totals_per_bin: list[int] = [0] * n_bins
+    total_errors = 0
+
+    matcher = difflib.SequenceMatcher(
+        None, gt_words, hyp_words, autojunk=False,
+    )
+    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+        if tag == "equal":
+            continue
+        if tag == "delete":
+            for offset in range(i2 - i1):
+                position = i1 + offset
+                bin_idx = _bin_for_position(position, n_gt, n_bins)
+                per_class["lacuna"][bin_idx] += 1
+                totals_per_bin[bin_idx] += 1
+                total_errors += 1
+        elif tag == "insert":
+            # L'insert n'a pas de position GT propre : on attribue
+            # à la tranche de la position d'insertion (i1).
+            for w in hyp_words[j1:j2]:
+                if not _is_oov_word(w):
+                    continue
+                position = min(i1, n_gt - 1)
+                bin_idx = _bin_for_position(position, n_gt, n_bins)
+                per_class["oov_character"][bin_idx] += 1
+                totals_per_bin[bin_idx] += 1
+                total_errors += 1
+        elif tag == "replace":
+            gt_seg = gt_words[i1:i2]
+            hyp_seg = hyp_words[j1:j2]
+            if len(hyp_seg) != len(gt_seg):
+                # Segmentation : compte par diff de longueur
+                n_seg = abs(len(gt_seg) - len(hyp_seg))
+                bin_idx = _bin_for_position(i1, n_gt, n_bins)
+                per_class["segmentation_error"][bin_idx] += n_seg
+                totals_per_bin[bin_idx] += n_seg
+                total_errors += n_seg
+            else:
+                for offset, (gt_w, hyp_w) in enumerate(
+                    zip(gt_seg, hyp_seg),
+                ):
+                    if gt_w == hyp_w:
+                        continue
+                    position = i1 + offset
+                    bin_idx = _bin_for_position(position, n_gt, n_bins)
+                    cls = _classify_word_pair(gt_w, hyp_w)
+                    per_class[cls][bin_idx] += 1
+                    totals_per_bin[bin_idx] += 1
+                    total_errors += 1
+
+    return {
+        "n_bins": n_bins,
+        "n_words_gt": n_gt,
+        "total_errors": total_errors,
+        "per_class": per_class,
+        "totals_per_bin": totals_per_bin,
+    }
+
+
+__all__ = [
+    "compute_taxonomy_position_heatmap",
+]

picarones/extras/governance/__init__.py

@@ -0,0 +1,8 @@
+"""Gouvernance préventive pour modules contribués externes.
+
+Aujourd'hui Picarones n'a pas encore de modules tiers contribués par
+des utilisateurs externes. Le module ``module_policy`` ici est livré
+en avance pour préparer la phase d'ouverture (lointaine).
+
+Sera réintégré au Cercle 2 si/quand 5+ modules tiers sont publiés.
+"""

picarones/extras/governance/module_policy.py

@@ -0,0 +1,333 @@
+"""Politique de modules contribués — Sprint 97 (B.6).
+
+Sprint 97 — B.6 du plan d'évolution 2026.
+
+Pourquoi ce module
+------------------
+Avant d'ouvrir Picarones aux contributions externes (axe B —
+modules tiers que l'utilisateur amène), il faut un cadre de
+qualité explicite : *« un module qui ne passe pas l'audit
+n'est pas exécutable. »*
+
+Ce module fournit l'**enveloppe d'audit** :
+
+- ``ModuleManifest`` — métadonnées obligatoires (auteur,
+  licence, version, citation, contrat d'entrée/sortie typé).
+- ``validate_manifest(manifest)`` — vérifie que tous les champs
+  obligatoires sont présents et bien formés.
+- ``audit_module(module_class_or_instance, manifest)`` —
+  vérifie en plus que la classe respecte le contrat ``BaseModule``
+  et que ``input_types``/``output_types`` correspondent au
+  manifeste.
+- ``AuditResult`` — verdict structuré ``passed/failed`` + liste
+  des checks détaillés.
+
+Stratégie d'ouverture
+---------------------
+Phase fermée actuelle : modules officiels uniquement,
+contributions via PR sur le repo principal.  Phase ouverte
+future : une fois 5–6 modules officiels stables, ouverture via
+``entry_points`` sur PyPI (``picarones-module-X``).  Ce module
+prépare la phase ouverte sans la déclencher : tout module
+externe devra fournir un ``ModuleManifest`` valide pour être
+exécuté.
+
+Pas de SPDX validator
+---------------------
+On vérifie la présence et la non-vacuité des champs licence ;
+on ne valide pas la conformité SPDX du nom (``MIT`` vs
+``mit-license`` vs ``MIT License``).  Le chercheur reste
+responsable du choix de licence ; l'outil documente, il ne
+juge pas.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+# Champs obligatoires d'un ManifestModule (texte non-vide).
+_REQUIRED_TEXT_FIELDS = (
+    "name", "version", "author", "license",
+    "description",
+)
+
+
+@dataclass
+class ModuleManifest:
+    """Métadonnées d'un module contribué.
+
+    Attributes
+    ----------
+    name:
+        Identifiant unique du module (ex. ``"my-llm-correcteur"``).
+    version:
+        Version sémantique (ex. ``"1.2.0"``).
+    author:
+        Auteur ou institution responsable.
+    license:
+        Identifiant de licence (SPDX recommandé, non validé).
+    description:
+        Description courte (≤ 1 phrase).
+    input_types:
+        Liste des types d'entrée (chaînes).  Doit correspondre
+        à ``module.input_types`` (Sprint 33).
+    output_types:
+        Liste des types de sortie.  Doit correspondre à
+        ``module.output_types``.
+    citation:
+        Citation académique (BibTeX, DOI, ou texte libre).
+        Optionnel.
+    homepage:
+        URL du dépôt ou de la page projet. Optionnel.
+    picarones_min_version:
+        Version minimale de Picarones requise. Optionnel.
+    extra:
+        Métadonnées libres (clé → valeur).
+    """
+
+    name: str
+    version: str
+    author: str
+    license: str
+    description: str
+    input_types: list[str] = field(default_factory=list)
+    output_types: list[str] = field(default_factory=list)
+    citation: Optional[str] = None
+    homepage: Optional[str] = None
+    picarones_min_version: Optional[str] = None
+    extra: dict = field(default_factory=dict)
+
+    def as_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "version": self.version,
+            "author": self.author,
+            "license": self.license,
+            "description": self.description,
+            "input_types": list(self.input_types),
+            "output_types": list(self.output_types),
+            "citation": self.citation,
+            "homepage": self.homepage,
+            "picarones_min_version": self.picarones_min_version,
+            "extra": dict(self.extra),
+        }
+
+
+@dataclass
+class AuditCheck:
+    """Un check individuel de l'audit."""
+
+    name: str
+    passed: bool
+    detail: Optional[str] = None
+
+    def as_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "passed": self.passed,
+            "detail": self.detail,
+        }
+
+
+@dataclass
+class AuditResult:
+    """Résultat global d'un audit de module."""
+
+    module_name: str
+    passed: bool
+    checks: list[AuditCheck] = field(default_factory=list)
+
+    @property
+    def n_passed(self) -> int:
+        return sum(1 for c in self.checks if c.passed)
+
+    @property
+    def n_failed(self) -> int:
+        return sum(1 for c in self.checks if not c.passed)
+
+    def as_dict(self) -> dict:
+        return {
+            "module_name": self.module_name,
+            "passed": self.passed,
+            "n_passed": self.n_passed,
+            "n_failed": self.n_failed,
+            "checks": [c.as_dict() for c in self.checks],
+        }
+
+
+def validate_manifest(manifest: ModuleManifest) -> list[AuditCheck]:
+    """Vérifie qu'un manifest est complet et bien formé.
+
+    Returns
+    -------
+    list[AuditCheck]
+        Un check par champ obligatoire + un check pour
+        ``input_types``/``output_types`` non vides.
+    """
+    checks: list[AuditCheck] = []
+    for field_name in _REQUIRED_TEXT_FIELDS:
+        value = getattr(manifest, field_name, None)
+        ok = isinstance(value, str) and bool(value.strip())
+        checks.append(AuditCheck(
+            name=f"manifest.{field_name}",
+            passed=ok,
+            detail=None if ok else f"champ '{field_name}' vide ou absent",
+        ))
+    # input_types / output_types : au moins une entrée chacun
+    in_ok = (
+        isinstance(manifest.input_types, list)
+        and len(manifest.input_types) > 0
+        and all(
+            isinstance(t, str) and t for t in manifest.input_types
+        )
+    )
+    checks.append(AuditCheck(
+        name="manifest.input_types",
+        passed=in_ok,
+        detail=None if in_ok else "input_types vide ou non-string",
+    ))
+    out_ok = (
+        isinstance(manifest.output_types, list)
+        and len(manifest.output_types) > 0
+        and all(
+            isinstance(t, str) and t for t in manifest.output_types
+        )
+    )
+    checks.append(AuditCheck(
+        name="manifest.output_types",
+        passed=out_ok,
+        detail=None if out_ok else "output_types vide ou non-string",
+    ))
+    return checks
+
+
+def _is_base_module(cls: Any) -> bool:
+    """Best-effort : vérifie que cls hérite de BaseModule.
+
+    On ne **pas** importer ``BaseModule`` au top-level pour
+    éviter les cycles : on inspecte la chaîne de classes par
+    leur nom.
+    """
+    try:
+        for base in cls.__mro__:
+            if base.__name__ == "BaseModule":
+                return True
+    except AttributeError:
+        return False
+    return False
+
+
+def audit_module(
+    module_class_or_instance: Any,
+    manifest: ModuleManifest,
+) -> AuditResult:
+    """Audite un module contribué : interface + manifest.
+
+    Parameters
+    ----------
+    module_class_or_instance:
+        Soit la classe ``BaseModule`` (Sprint 33), soit une
+        instance.
+    manifest:
+        ``ModuleManifest`` correspondant au module.
+
+    Returns
+    -------
+    AuditResult
+        ``passed=True`` ssi tous les checks passent.
+    """
+    checks = validate_manifest(manifest)
+
+    # Check : héritage de BaseModule
+    cls = (
+        type(module_class_or_instance)
+        if not isinstance(module_class_or_instance, type)
+        else module_class_or_instance
+    )
+    inherits_base = _is_base_module(cls)
+    checks.append(AuditCheck(
+        name="module.inherits_base_module",
+        passed=inherits_base,
+        detail=(
+            None if inherits_base
+            else "la classe n'hérite pas de picarones.core.modules.BaseModule"
+        ),
+    ))
+
+    # Check : input_types / output_types correspondent
+    declared_in: list[str] = []
+    declared_out: list[str] = []
+    try:
+        instance = (
+            module_class_or_instance
+            if not isinstance(module_class_or_instance, type)
+            else None
+        )
+        attr_in = getattr(cls, "input_types", None)
+        attr_out = getattr(cls, "output_types", None)
+        if instance is not None:
+            attr_in = getattr(instance, "input_types", attr_in)
+            attr_out = getattr(instance, "output_types", attr_out)
+        if attr_in is not None:
+            declared_in = [
+                getattr(t, "value", str(t)) for t in attr_in
+            ]
+        if attr_out is not None:
+            declared_out = [
+                getattr(t, "value", str(t)) for t in attr_out
+            ]
+    except Exception:  # noqa: BLE001
+        pass
+    # Comparaison case-insensitive : on accepte "TEXT" ou "text"
+    # côté manifest, le contrat sémantique est le même.
+    declared_in_lower = sorted(t.lower() for t in declared_in)
+    declared_out_lower = sorted(t.lower() for t in declared_out)
+    manifest_in_lower = sorted(t.lower() for t in manifest.input_types)
+    manifest_out_lower = sorted(t.lower() for t in manifest.output_types)
+    in_match = declared_in_lower == manifest_in_lower
+    checks.append(AuditCheck(
+        name="module.input_types_match_manifest",
+        passed=in_match,
+        detail=(
+            None if in_match
+            else f"déclaré {declared_in} vs manifest {manifest.input_types}"
+        ),
+    ))
+    out_match = declared_out_lower == manifest_out_lower
+    checks.append(AuditCheck(
+        name="module.output_types_match_manifest",
+        passed=out_match,
+        detail=(
+            None if out_match
+            else f"déclaré {declared_out} vs manifest {manifest.output_types}"
+        ),
+    ))
+
+    # Check : process callable
+    has_process = callable(getattr(cls, "process", None))
+    checks.append(AuditCheck(
+        name="module.has_process",
+        passed=has_process,
+        detail=None if has_process else "méthode process() absente",
+    ))
+
+    passed = all(c.passed for c in checks)
+    return AuditResult(
+        module_name=manifest.name,
+        passed=passed,
+        checks=checks,
+    )
+
+
+__all__ = [
+    "ModuleManifest",
+    "AuditCheck",
+    "AuditResult",
+    "validate_manifest",
+    "audit_module",
+]

picarones/extras/render/__init__.py

@@ -0,0 +1,13 @@
+"""Renderers atomiques pour les modules ``extras/``.
+
+Importés conditionnellement par les vues thématiques du chantier 3
+(``picarones.report.views.advanced_taxonomy``, etc.) qui restent
+dans le Cercle 2. Si les modules ``extras/academic/`` ou
+``extras/governance/`` sont absents, ces renderers ne sont pas
+sollicités et la vue masque la sous-section.
+
+Rétrocompat
+-----------
+Imports historiques ``from picarones.report.taxonomy_intra_doc_render
+import ...`` continuent à fonctionner via des fichiers-shims.
+"""

picarones/extras/render/image_predictive_render.py

@@ -0,0 +1,221 @@
+"""Rendu HTML « Profil d'image du corpus » — Sprint 93 (A.II.7).
+
+Suite directe ``picarones/core/image_predictive.py``.  Pattern
+identique aux autres rendus : server-side, pas de JS, anti-
+injection systématique.
+
+Vue
+---
+Deux blocs dans une section unique :
+
+1. **Complexité paléographique** : moyenne, médiane, min, max,
+   écart-type sur l'ensemble du corpus.
+2. **Homogénéité du corpus** : score combiné + détail par
+   feature (mean, stdev, contribution normalisée).
+
+Adaptive : ``""`` si pas de données.
+
+Note d'intégration
+------------------
+Module pur — l'utilisateur compose :
+
+.. code-block:: python
+
+    from picarones.core.image_predictive import aggregate_corpus_predictive
+    from picarones.report.image_predictive_render import (
+        build_image_predictive_html,
+    )
+
+    qualities = [doc.image_quality.as_dict() for doc in benchmark.docs]
+    agg = aggregate_corpus_predictive(qualities)
+    html = build_image_predictive_html(agg, labels)
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+
+def _color_for_score(score: float) -> str:
+    """Vert (faible) → orange → rouge (élevé)."""
+    f = max(0.0, min(1.0, score))
+    if f < 0.5:
+        t = f / 0.5
+        r = int(167 + (235 - 167) * t)
+        g = int(240 + (180 - 240) * t)
+        b = int(167 + (60 - 167) * t)
+    else:
+        t = (f - 0.5) / 0.5
+        r = int(235 + (220 - 235) * t)
+        g = int(180 + (50 - 180) * t)
+        b = int(60 + (50 - 60) * t)
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+_FEATURE_LABEL_KEYS = {
+    "noise_level": "imgpred_feat_noise",
+    "sharpness_score": "imgpred_feat_sharpness",
+    "contrast_score": "imgpred_feat_contrast",
+    "rotation_degrees": "imgpred_feat_rotation",
+}
+
+
+def _render_complexity_block(
+    aggregated: dict, labels: dict[str, str],
+) -> str:
+    h_complex = labels.get(
+        "imgpred_complexity", "Complexité paléographique",
+    )
+    h_mean = labels.get("imgpred_mean", "Moyenne")
+    h_median = labels.get("imgpred_median", "Médiane")
+    h_min = labels.get("imgpred_min", "Min")
+    h_max = labels.get("imgpred_max", "Max")
+    h_stdev = labels.get("imgpred_stdev", "Écart-type")
+    h_docs = labels.get("imgpred_docs", "Docs")
+    mean = float(aggregated.get("complexity_mean") or 0.0)
+    median = float(aggregated.get("complexity_median") or 0.0)
+    mn = float(aggregated.get("complexity_min") or 0.0)
+    mx = float(aggregated.get("complexity_max") or 0.0)
+    sd = float(aggregated.get("complexity_stdev") or 0.0)
+    n_docs = int(aggregated.get("n_docs") or 0)
+    color_mean = _color_for_score(mean)
+    return (
+        f'<div style="font-weight:600;margin:.4rem 0 .3rem 0">'
+        f'{_e(h_complex)}</div>'
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.9rem;margin-bottom:.8rem">'
+        f'<thead><tr>'
+        f'<th style="padding:.4rem .6rem;text-align:right;'
+        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_mean)}</th>'
+        f'<th style="padding:.4rem .6rem;text-align:right;'
+        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_median)}</th>'
+        f'<th style="padding:.4rem .6rem;text-align:right;'
+        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_min)}</th>'
+        f'<th style="padding:.4rem .6rem;text-align:right;'
+        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_max)}</th>'
+        f'<th style="padding:.4rem .6rem;text-align:right;'
+        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_stdev)}</th>'
+        f'<th style="padding:.4rem .6rem;text-align:right;'
+        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_docs)}</th>'
+        f'</tr></thead>'
+        f'<tbody><tr>'
+        f'<td style="padding:.4rem .6rem;text-align:right;'
+        f'background:{color_mean};font-family:monospace;font-weight:600">'
+        f'{mean:.3f}</td>'
+        f'<td style="padding:.4rem .6rem;text-align:right;'
+        f'font-family:monospace">{median:.3f}</td>'
+        f'<td style="padding:.4rem .6rem;text-align:right;'
+        f'font-family:monospace">{mn:.3f}</td>'
+        f'<td style="padding:.4rem .6rem;text-align:right;'
+        f'font-family:monospace">{mx:.3f}</td>'
+        f'<td style="padding:.4rem .6rem;text-align:right;'
+        f'font-family:monospace">{sd:.3f}</td>'
+        f'<td style="padding:.4rem .6rem;text-align:right;'
+        f'font-family:monospace">{n_docs}</td>'
+        f'</tr></tbody></table>'
+    )
+
+
+def _render_homogeneity_block(
+    homogeneity: dict, labels: dict[str, str],
+) -> str:
+    h_homo = labels.get(
+        "imgpred_homogeneity", "Homogénéité du corpus",
+    )
+    h_feat = labels.get("imgpred_feature", "Feature")
+    h_mean = labels.get("imgpred_feat_mean", "Moyenne")
+    h_stdev = labels.get("imgpred_feat_stdev", "Écart-type")
+    h_norm = labels.get(
+        "imgpred_feat_norm", "Contribution normalisée",
+    )
+    score = float(homogeneity.get("score") or 0.0)
+    color = _color_for_score(score)
+    parts = [
+        f'<div style="font-weight:600;margin:.4rem 0 .3rem 0">'
+        f'{_e(h_homo)} : '
+        f'<span style="background:{color};padding:.1rem .4rem;'
+        f'border-radius:.3rem;font-family:monospace">{score:.3f}</span>'
+        f'</div>',
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.9rem">',
+        '<thead><tr>',
+    ]
+    for col in (h_feat, h_mean, h_stdev, h_norm):
+        parts.append(
+            f'<th style="padding:.4rem .6rem;text-align:left;'
+            f'border-bottom:1px solid #ccc;font-weight:600">'
+            f'{_e(col)}</th>'
+        )
+    parts.append("</tr></thead><tbody>")
+    per_feat = homogeneity.get("per_feature") or {}
+    for key, label_key in _FEATURE_LABEL_KEYS.items():
+        if key not in per_feat:
+            continue
+        slot = per_feat[key]
+        feat_label = labels.get(label_key, key)
+        feat_mean = float(slot.get("mean") or 0.0)
+        feat_stdev = float(slot.get("stdev") or 0.0)
+        feat_norm = float(slot.get("normalised") or 0.0)
+        norm_color = _color_for_score(feat_norm)
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.4rem .6rem">{_e(feat_label)}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{feat_mean:.3f}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{feat_stdev:.3f}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'background:{norm_color};font-family:monospace">'
+            f'{feat_norm:.3f}</td>'
+            f'</tr>'
+        )
+    parts.append("</tbody></table>")
+    return "".join(parts)
+
+
+def build_image_predictive_html(
+    aggregated: Optional[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit la vue HTML « Profil d'image du corpus ».
+
+    Parameters
+    ----------
+    aggregated:
+        Sortie de ``aggregate_corpus_predictive``.  Si ``None``
+        ou ``n_docs == 0``, retourne ``""``.
+    labels:
+        Dict i18n.  Clés sous le préfixe ``imgpred_*``.
+    """
+    if not aggregated:
+        return ""
+    if not aggregated.get("n_docs"):
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "imgpred_title", "Profil d'image du corpus",
+    )
+    note = labels.get(
+        "imgpred_note",
+        "Score de complexité paléographique combinant bruit, "
+        "flou, faible contraste et rotation. Le score "
+        "d'homogénéité signale si la moyenne globale est fiable "
+        "(corpus uniforme) ou trompeuse (corpus hétérogène — "
+        "voir alors la vue stratifiée).",
+    )
+    parts = [
+        '<section class="imgpred-section" style="margin:1rem 0">',
+        f'<h3 style="margin:0 0 .3rem 0">{_e(title)}</h3>',
+        f'<div style="font-size:.85rem;opacity:.75;margin-bottom:.6rem">'
+        f'{_e(note)}</div>',
+    ]
+    parts.append(_render_complexity_block(aggregated, labels))
+    homo = aggregated.get("homogeneity")
+    if isinstance(homo, dict):
+        parts.append(_render_homogeneity_block(homo, labels))
+    parts.append("</section>")
+    return "".join(parts)
+
+
+__all__ = ["build_image_predictive_html"]

picarones/extras/render/module_audit_render.py

@@ -0,0 +1,173 @@
+"""Rendu HTML « Modules audités » — Sprint 97 (B.6).
+
+Suite directe ``picarones/core/module_policy.py``.  Pattern
+identique aux autres rendus : server-side, pas de JS, anti-
+injection systématique.
+
+Vue
+---
+Tableau récapitulatif des modules utilisés dans une pipeline
+composée, chacun avec :
+
+- Statut d'audit (✓ vert si tous les checks passent, ✗ rouge
+  sinon, avec compte des échecs) ;
+- Métadonnées : version, auteur, licence ;
+- Citation académique si fournie ;
+- Lien vers la homepage si fourni.
+
+Adaptive : ``""`` si la liste est vide.
+
+Note d'intégration
+------------------
+Module pur — l'utilisateur compose la liste depuis sa
+``PipelineSpec`` augmentée des ``ModuleManifest`` :
+
+.. code-block:: python
+
+    from picarones.core.module_policy import audit_module
+    from picarones.report.module_audit_render import build_module_audit_html
+
+    audits = []
+    for step in pipeline.steps:
+        manifest = step.module.manifest  # convention applicative
+        result = audit_module(step.module, manifest)
+        audits.append({
+            "manifest": manifest.as_dict(),
+            "audit": result.as_dict(),
+        })
+    html = build_module_audit_html(audits, labels)
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+
+def _passed_badge(passed: bool, n_failed: int, label_pass: str,
+                  label_fail: str) -> str:
+    if passed:
+        return (
+            f'<span style="color:#16a34a;font-weight:700">'
+            f'✓ {_e(label_pass)}</span>'
+        )
+    return (
+        f'<span style="color:#dc2626;font-weight:700">'
+        f'✗ {_e(label_fail)} ({n_failed})</span>'
+    )
+
+
+def build_module_audit_html(
+    audits: Optional[list],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit la vue HTML « Modules audités ».
+
+    Parameters
+    ----------
+    audits:
+        Liste de dicts ``{"manifest": ManifestDict, "audit":
+        AuditResultDict}``.  Si vide ou ``None``, retourne ``""``.
+    labels:
+        Dict i18n.  Clés sous le préfixe ``audit_*``.
+    """
+    if not audits:
+        return ""
+    rows = [
+        a for a in audits
+        if isinstance(a, dict)
+        and isinstance(a.get("manifest"), dict)
+        and isinstance(a.get("audit"), dict)
+    ]
+    if not rows:
+        return ""
+    labels = labels or {}
+    title = labels.get("audit_title", "Modules audités")
+    note = labels.get(
+        "audit_note",
+        "Récapitulatif des modules utilisés dans la pipeline "
+        "composée. Un module qui ne passe pas l'audit n'est "
+        "pas exécutable. Métadonnées issues du manifest fourni "
+        "par le contributeur (auteur, licence, citation).",
+    )
+    label_pass = labels.get("audit_pass", "audit OK")
+    label_fail = labels.get("audit_fail", "checks échoués")
+    h_module = labels.get("audit_module", "Module")
+    h_status = labels.get("audit_status", "Audit")
+    h_version = labels.get("audit_version", "Version")
+    h_author = labels.get("audit_author", "Auteur")
+    h_license = labels.get("audit_license", "Licence")
+    h_io = labels.get("audit_io", "Entrée → sortie")
+    h_citation = labels.get("audit_citation", "Citation")
+    h_homepage = labels.get("audit_homepage", "Page projet")
+
+    parts = [
+        '<section class="audit-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 col in (h_module, h_status, h_version, h_author,
+                h_license, h_io, h_citation, h_homepage):
+        parts.append(
+            f'<th style="padding:.4rem .6rem;text-align:left;'
+            f'border-bottom:1px solid #ccc;font-weight:600">'
+            f'{_e(col)}</th>'
+        )
+    parts.append("</tr></thead><tbody>")
+
+    for entry in rows:
+        manifest = entry["manifest"]
+        audit = entry["audit"]
+        name = str(manifest.get("name") or "?")
+        version = str(manifest.get("version") or "—")
+        author = str(manifest.get("author") or "—")
+        license_ = str(manifest.get("license") or "—")
+        in_types = ", ".join(manifest.get("input_types") or []) or "—"
+        out_types = ", ".join(manifest.get("output_types") or []) or "—"
+        citation = manifest.get("citation") or ""
+        homepage = manifest.get("homepage") or ""
+        passed = bool(audit.get("passed"))
+        n_failed = int(audit.get("n_failed") or 0)
+        status_cell = _passed_badge(
+            passed, n_failed, label_pass, label_fail,
+        )
+        # Citation : tronqué si trop long
+        citation_str = str(citation)[:120]
+        if len(str(citation)) > 120:
+            citation_str += "…"
+        citation_cell = (
+            _e(citation_str) if citation_str.strip() else "—"
+        )
+        # Homepage : on n'auto-link **pas** (anti-injection +
+        # honnêteté : l'URL peut pointer ailleurs).  On affiche
+        # le texte échappé tel quel.
+        homepage_cell = (
+            _e(str(homepage))[:80] + ("…" if len(str(homepage)) > 80 else "")
+        ) if str(homepage).strip() else "—"
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.4rem .6rem;font-family:monospace">'
+            f'{_e(name)}</td>'
+            f'<td style="padding:.4rem .6rem">{status_cell}</td>'
+            f'<td style="padding:.4rem .6rem;font-family:monospace">'
+            f'{_e(version)}</td>'
+            f'<td style="padding:.4rem .6rem">{_e(author)}</td>'
+            f'<td style="padding:.4rem .6rem;font-family:monospace">'
+            f'{_e(license_)}</td>'
+            f'<td style="padding:.4rem .6rem;font-family:monospace;'
+            f'font-size:.8rem">{_e(in_types)} → {_e(out_types)}</td>'
+            f'<td style="padding:.4rem .6rem;font-size:.8rem;'
+            f'opacity:.85">{citation_cell}</td>'
+            f'<td style="padding:.4rem .6rem;font-family:monospace;'
+            f'font-size:.8rem">{homepage_cell}</td>'
+            f'</tr>'
+        )
+    parts.append("</tbody></table></section>")
+    return "".join(parts)
+
+
+__all__ = ["build_module_audit_html"]

picarones/extras/render/taxonomy_cooccurrence_render.py

@@ -0,0 +1,199 @@
+"""Rendu HTML de la heatmap de co-occurrence taxonomique — Sprint 75.
+
+A.I.4 chantier 1 du plan d'évolution 2026.
+
+Suite directe ``picarones/core/taxonomy_cooccurrence.py``.  Pattern
+identique aux autres rendus (Sprints 41/43/62/67/72/74) :
+**server-side**, pas de JavaScript, anti-injection systématique.
+
+Sortie typique
+--------------
+- ``build_taxonomy_cooccurrence_html(data, labels)`` produit un
+  bloc complet : titre + note d'usage + heatmap SVG + table des
+  paires les plus co-occurrentes.
+- ``""`` retourné si ``data is None`` ou si la matrice est vide
+  (rapport adaptatif).
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+
+def _color_for_jaccard(j: float) -> str:
+    """Gradient blanc → bleu profond pour Jaccard ∈ [0, 1].
+
+    Interpolation entre #ffffff (j=0) et #1e3a8a (j=1).
+    """
+    f = max(0.0, min(1.0, j))
+    r = int(255 + (30 - 255) * f)
+    g = int(255 + (58 - 255) * f)
+    b = int(255 + (138 - 255) * f)
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+def _text_color_for_bg(j: float) -> str:
+    """Texte blanc si fond foncé, noir sinon (lisibilité)."""
+    return "#fff" if j > 0.55 else "#222"
+
+
+def _build_heatmap_svg(
+    classes: list[str],
+    matrix: dict[str, dict[str, float]],
+    *,
+    cell_size: int = 36,
+    label_left: int = 130,
+    label_top: int = 80,
+) -> str:
+    """Construit la heatmap SVG.
+
+    Cellule = carré coloré ``_color_for_jaccard``, valeur Jaccard
+    affichée en chiffres si > 0,05.  Étiquettes des classes en
+    colonne (haut) et en ligne (gauche).
+    """
+    n = len(classes)
+    if n == 0:
+        return ""
+    width = label_left + n * cell_size + 10
+    height = label_top + n * cell_size + 10
+
+    parts = [
+        f'<svg xmlns="http://www.w3.org/2000/svg" '
+        f'width="{width}" height="{height}" '
+        f'viewBox="0 0 {width} {height}" '
+        f'role="img" aria-label="Heatmap Jaccard co-occurrence taxonomique">',
+    ]
+    # Étiquettes de colonnes (rotées -45°)
+    for j, cls in enumerate(classes):
+        cx = label_left + j * cell_size + cell_size // 2
+        cy = label_top - 6
+        parts.append(
+            f'<text x="{cx}" y="{cy}" '
+            f'transform="rotate(-45 {cx} {cy})" '
+            f'font-size="11" fill="#333" text-anchor="start">'
+            f'{_e(cls)}</text>'
+        )
+    # Étiquettes de lignes
+    for i, cls in enumerate(classes):
+        rx = label_left - 6
+        ry = label_top + i * cell_size + cell_size // 2 + 4
+        parts.append(
+            f'<text x="{rx}" y="{ry}" '
+            f'font-size="11" fill="#333" text-anchor="end">'
+            f'{_e(cls)}</text>'
+        )
+    # Cellules
+    for i, ca in enumerate(classes):
+        for j, cb in enumerate(classes):
+            value = matrix.get(ca, {}).get(cb, 0.0)
+            x = label_left + j * cell_size
+            y = label_top + i * cell_size
+            color = _color_for_jaccard(value)
+            text_color = _text_color_for_bg(value)
+            parts.append(
+                f'<rect x="{x}" y="{y}" '
+                f'width="{cell_size}" height="{cell_size}" '
+                f'fill="{color}" stroke="#ddd" stroke-width="0.5"/>'
+            )
+            if value > 0.05:
+                parts.append(
+                    f'<text x="{x + cell_size // 2}" '
+                    f'y="{y + cell_size // 2 + 4}" '
+                    f'font-size="10" fill="{text_color}" '
+                    f'text-anchor="middle">'
+                    f'{value:.2f}</text>'
+                )
+    parts.append("</svg>")
+    return "".join(parts)
+
+
+def _build_top_pairs_table(
+    top_pairs: list,
+    labels: dict,
+) -> str:
+    """Construit la table HTML des paires les plus co-occurrentes."""
+    if not top_pairs:
+        return ""
+    pair_label = labels.get("taxocooc_pair_label", "Paire")
+    jaccard_label = labels.get("taxocooc_jaccard_label", "Jaccard")
+
+    parts = [
+        '<table style="border-collapse:collapse;font-size:.85rem;'
+        'margin-top:.5rem">',
+        '<thead><tr>',
+        f'<th style="padding:.3rem .5rem;text-align:left;'
+        f'border-bottom:1px solid #ccc;font-weight:600">'
+        f'{_e(pair_label)}</th>',
+        f'<th style="padding:.3rem .5rem;text-align:right;'
+        f'border-bottom:1px solid #ccc;font-weight:600">'
+        f'{_e(jaccard_label)}</th>',
+        '</tr></thead><tbody>',
+    ]
+    for ca, cb, j in top_pairs:
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.2rem .5rem">'
+            f'<code>{_e(ca)}</code> ↔ <code>{_e(cb)}</code></td>'
+            f'<td style="padding:.2rem .5rem;text-align:right;'
+            f'font-family:monospace;background:{_color_for_jaccard(j)};'
+            f'color:{_text_color_for_bg(j)}">{j:.2f}</td>'
+            f'</tr>'
+        )
+    parts.append("</tbody></table>")
+    return "".join(parts)
+
+
+def build_taxonomy_cooccurrence_html(
+    data: Optional[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit le bloc HTML complet de co-occurrence taxonomique.
+
+    Retourne ``""`` si ``data is None`` ou matrice vide.
+    """
+    if not data:
+        return ""
+    classes = data.get("classes") or []
+    matrix = data.get("cooccurrence_matrix") or {}
+    if not classes or not matrix:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "taxocooc_title",
+        "Co-occurrence des classes d'erreur",
+    )
+    note = labels.get(
+        "taxocooc_note",
+        "Indice de Jaccard au niveau document : 1,00 = ces deux classes "
+        "apparaissent toujours ensemble ; 0,00 = jamais. Lecture par paires "
+        "co-occurrentes ci-dessous.",
+    )
+    n_docs = data.get("n_documents", 0)
+    n_docs_label_template = labels.get(
+        "taxocooc_n_docs", "Calculé sur {n_docs} documents.",
+    )
+    n_docs_phrase = n_docs_label_template.format(n_docs=n_docs)
+
+    svg = _build_heatmap_svg(classes, matrix)
+    top_table = _build_top_pairs_table(
+        data.get("top_pairs") or [], labels,
+    )
+
+    parts = [
+        '<div class="taxocooc" style="margin:1rem 0">',
+        f'<div style="font-weight:600;margin-bottom:.4rem">{_e(title)}</div>',
+        f'<div style="font-size:.85rem;opacity:.75;margin-bottom:.5rem">'
+        f'{_e(note)}</div>',
+        f'<div style="font-size:.8rem;opacity:.7;margin-bottom:.5rem">'
+        f'{_e(n_docs_phrase)}</div>',
+        svg,
+        top_table,
+        "</div>",
+    ]
+    return "".join(parts)
+
+
+__all__ = [
+    "build_taxonomy_cooccurrence_html",
+]

picarones/extras/render/taxonomy_intra_doc_render.py

@@ -0,0 +1,182 @@
+"""Rendu HTML de la heatmap class × position — Sprint 76.
+
+A.I.4 chantier 2 du plan d'évolution 2026.
+
+Suite directe ``picarones/core/taxonomy_intra_doc.py``.  Pattern
+identique aux autres rendus (Sprints 41/43/62/67/72/74/75) :
+**server-side**, pas de JavaScript, anti-injection systématique.
+
+Sortie typique
+--------------
+Une grille N_classes × N_bins où chaque cellule indique la densité
+d'erreurs de cette classe à cette position dans le document.
+Lecture immédiate : « ligature_error concentré dans la première
+tranche → erreur de marge ; visual_confusion uniformément réparti
+→ erreur de scribe ».
+
+Adaptive : si ``data is None`` ou si toutes les classes ont 0
+erreur, retourne ``""``.
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+
+def _color_for_density(density: float) -> str:
+    """Gradient blanc → orange profond pour densité ∈ [0, 1].
+
+    Interpolation entre #ffffff (0) et #c2410c (1).
+    """
+    f = max(0.0, min(1.0, density))
+    r = int(255 + (194 - 255) * f)
+    g = int(255 + (65 - 255) * f)
+    b = int(255 + (12 - 255) * f)
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+def _text_color_for_bg(density: float) -> str:
+    return "#fff" if density > 0.55 else "#222"
+
+
+def _build_heatmap_svg(
+    classes_with_errors: list[str],
+    per_class: dict[str, list[int]],
+    n_bins: int,
+    *,
+    cell_w: int = 36,
+    cell_h: int = 26,
+    label_left: int = 150,
+    label_top: int = 30,
+) -> str:
+    """Construit la heatmap SVG class × position."""
+    n_rows = len(classes_with_errors)
+    if n_rows == 0:
+        return ""
+    width = label_left + n_bins * cell_w + 10
+    height = label_top + n_rows * cell_h + 30  # +30 pour étiquette X
+
+    # Normalisation : pour chaque classe, densité relative au max
+    # de cette classe (mise en évidence des positions concentrées).
+    parts = [
+        f'<svg xmlns="http://www.w3.org/2000/svg" '
+        f'width="{width}" height="{height}" '
+        f'viewBox="0 0 {width} {height}" '
+        f'role="img" aria-label="Heatmap class taxonomique × position">',
+    ]
+    # Étiquettes des colonnes (positions)
+    for j in range(n_bins):
+        cx = label_left + j * cell_w + cell_w // 2
+        cy = label_top - 6
+        parts.append(
+            f'<text x="{cx}" y="{cy}" '
+            f'font-size="10" fill="#666" text-anchor="middle">'
+            f'{j + 1}</text>'
+        )
+    # Cellules
+    for i, cls in enumerate(classes_with_errors):
+        # Étiquette de ligne (classe)
+        rx = label_left - 6
+        ry = label_top + i * cell_h + cell_h // 2 + 4
+        parts.append(
+            f'<text x="{rx}" y="{ry}" '
+            f'font-size="11" fill="#333" text-anchor="end">'
+            f'{_e(cls)}</text>'
+        )
+        counts = per_class.get(cls, [0] * n_bins)
+        max_count = max(counts) if counts else 0
+        for j in range(n_bins):
+            x = label_left + j * cell_w
+            y = label_top + i * cell_h
+            count = counts[j] if j < len(counts) else 0
+            density = (count / max_count) if max_count > 0 else 0.0
+            color = _color_for_density(density)
+            text_color = _text_color_for_bg(density)
+            parts.append(
+                f'<rect x="{x}" y="{y}" '
+                f'width="{cell_w}" height="{cell_h}" '
+                f'fill="{color}" stroke="#ddd" stroke-width="0.5"/>'
+            )
+            if count > 0:
+                parts.append(
+                    f'<text x="{x + cell_w // 2}" '
+                    f'y="{y + cell_h // 2 + 4}" '
+                    f'font-size="10" fill="{text_color}" '
+                    f'text-anchor="middle">{count}</text>'
+                )
+    # Étiquette axe X en bas
+    cx_axis = label_left + (n_bins * cell_w) // 2
+    cy_axis = height - 6
+    parts.append(
+        f'<text x="{cx_axis}" y="{cy_axis}" '
+        f'font-size="11" fill="#666" text-anchor="middle" '
+        f'font-style="italic">'
+        f'Position dans le document (1 = début)</text>'
+    )
+    parts.append("</svg>")
+    return "".join(parts)
+
+
+def build_taxonomy_intra_doc_html(
+    data: Optional[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit le bloc HTML complet de la heatmap intra-document.
+
+    Retourne ``""`` si ``data is None`` ou aucune erreur.
+    """
+    if not data:
+        return ""
+    n_bins = data.get("n_bins", 0)
+    per_class = data.get("per_class") or {}
+    total_errors = data.get("total_errors", 0)
+    if total_errors == 0 or n_bins <= 0:
+        return ""
+    # Filtre : uniquement les classes ayant au moins une erreur
+    classes_with_errors = [
+        cls for cls, counts in per_class.items()
+        if isinstance(counts, list) and sum(counts) > 0
+    ]
+    if not classes_with_errors:
+        return ""
+
+    labels = labels or {}
+    title = labels.get(
+        "intradoc_title",
+        "Évolution intra-document des classes d'erreur",
+    )
+    note = labels.get(
+        "intradoc_note",
+        "Heatmap class × position : densité relative par classe "
+        "(plus foncé = concentré). Une classe concentrée dans la "
+        "première colonne suggère une erreur de marge ; "
+        "une distribution uniforme suggère une erreur de scribe.",
+    )
+    n_words_gt = data.get("n_words_gt", 0)
+    n_words_template = labels.get(
+        "intradoc_n_words",
+        "Calculé sur {n_words_gt} mots GT, répartis en {n_bins} tranches.",
+    )
+    n_words_phrase = n_words_template.format(
+        n_words_gt=n_words_gt, n_bins=n_bins,
+    )
+
+    svg = _build_heatmap_svg(classes_with_errors, per_class, n_bins)
+
+    parts = [
+        '<div class="intradoc" style="margin:1rem 0">',
+        f'<div style="font-weight:600;margin-bottom:.4rem">{_e(title)}</div>',
+        f'<div style="font-size:.85rem;opacity:.75;margin-bottom:.5rem">'
+        f'{_e(note)}</div>',
+        f'<div style="font-size:.8rem;opacity:.7;margin-bottom:.5rem">'
+        f'{_e(n_words_phrase)}</div>',
+        svg,
+        "</div>",
+    ]
+    return "".join(parts)
+
+
+__all__ = [
+    "build_taxonomy_intra_doc_html",
+]

picarones/report/i18n/en.json

@@ -60,8 +60,8 @@
   "gallery_sort_difficulty": "Difficulty",
   "gallery_sort_id": "Identifier",
   "gallery_sort_label": "Sort by:",
-  "gini_cer_ideal": "— ideal: bottom-left",
-  "gini_cer_note": "X-axis = mean CER, Y-axis = Gini coefficient. An ideal engine has low CER AND low Gini (rare, uniform errors).",
+  "gini_cer_ideal": "— reading: bottom-left",
+  "gini_cer_note": "X-axis = mean CER, Y-axis = Gini coefficient. An engine in the bottom-left area combines low CER AND low Gini (rare, uniformly distributed errors). The right choice depends on the target workflow.",
   "glossary_definition": "Definition",
   "glossary_empty": "No entry for this term.",
   "glossary_limits": "Limits",
@@ -252,7 +252,7 @@
   "intradoc_note": "Heatmap class × position: relative density per class (darker = concentrated). A class concentrated in the first column suggests a margin error; a uniform distribution suggests a scribe error.",
   "intradoc_n_words": "Computed on {n_words_gt} GT words, split into {n_bins} bins.",
   "taxocomp_title": "Taxonomic profile: {engine_a} vs {engine_b}",
-  "taxocomp_note": "Mirror chart of error proportions per class. Color by editorial recoverability (green = correctable, red = irrecoverable). At equal global CER, an engine whose errors are mostly green is preferable for a critical edition.",
+  "taxocomp_note": "Mirror chart of error proportions per class. Color by editorial recoverability (green = correctable, red = irrecoverable). At equal global CER, an engine whose errors are mostly green tends to produce errors more easily corrected in a critical edition workflow.",
   "taxocomp_level_label": "Category",
   "taxocomp_recoverable": "Recoverable",
   "taxocomp_difficult": "Difficult",

picarones/report/i18n/fr.json

@@ -60,8 +60,8 @@
   "gallery_sort_difficulty": "Difficulté",
   "gallery_sort_id": "Identifiant",
   "gallery_sort_label": "Trier par :",
-  "gini_cer_ideal": "— idéal : bas-gauche",
-  "gini_cer_note": "Axe X = CER moyen, Axe Y = coefficient de Gini. Un moteur idéal a CER bas ET Gini bas (erreurs rares et uniformes).",
+  "gini_cer_ideal": "— lecture : bas-gauche",
+  "gini_cer_note": "Axe X = CER moyen, Axe Y = coefficient de Gini. Un moteur dans la zone bas-gauche combine CER bas ET Gini bas (erreurs rares et uniformément réparties). Le choix selon ce graphe dépend du workflow visé.",
   "glossary_definition": "Définition",
   "glossary_empty": "Aucune entrée pour ce terme.",
   "glossary_limits": "Limites",
@@ -252,7 +252,7 @@
   "intradoc_note": "Heatmap class × position : densité relative par classe (plus foncé = concentré). Une classe concentrée dans la première colonne suggère une erreur de marge ; une distribution uniforme suggère une erreur de scribe.",
   "intradoc_n_words": "Calculé sur {n_words_gt} mots GT, répartis en {n_bins} tranches.",
   "taxocomp_title": "Profil taxonomique : {engine_a} vs {engine_b}",
-  "taxocomp_note": "Diagramme miroir des proportions d'erreurs par classe. Couleur selon récupérabilité éditoriale (vert = corrigeable, rouge = irrécupérable). À CER global égal, un moteur dont les erreurs sont majoritairement vertes est préférable pour une édition critique.",
+  "taxocomp_note": "Diagramme miroir des proportions d'erreurs par classe. Couleur selon récupérabilité éditoriale (vert = corrigeable, rouge = irrécupérable). À CER global égal, un moteur dont les erreurs sont majoritairement vertes tend à produire des erreurs plus facilement corrigées en édition critique.",
   "taxocomp_level_label": "Catégorie",
   "taxocomp_recoverable": "Récupérable",
   "taxocomp_difficult": "Difficile",

picarones/report/image_predictive_render.py

@@ -1,221 +1,20 @@
-"""Rendu HTML « Profil d'image du corpus » — Sprint 93 (A.II.7).
+"""Alias rétrocompat — module déplacé dans :mod:`picarones.extras.render.image_predictive_render`.
 
-Suite directe ``picarones/core/image_predictive.py``.  Pattern
-identique aux autres rendus : server-side, pas de JS, anti-
-injection systématique.
+Phase A du chantier de refonte en 3 cercles (architecture-cercles.md).
+Le contenu vit désormais dans son cercle 3 ``extras/``. Cet alias
+permet aux imports historiques (``from picarones.report.image_predictive_render
+import ...``) de continuer à fonctionner sans modification.
 
-Vue
----
-Deux blocs dans une section unique :
-
-1. **Complexité paléographique** : moyenne, médiane, min, max,
-   écart-type sur l'ensemble du corpus.
-2. **Homogénéité du corpus** : score combiné + détail par
-   feature (mean, stdev, contribution normalisée).
-
-Adaptive : ``""`` si pas de données.
-
-Note d'intégration
-------------------
-Module pur — l'utilisateur compose :
-
-.. code-block:: python
-
-    from picarones.core.image_predictive import aggregate_corpus_predictive
-    from picarones.report.image_predictive_render import (
-        build_image_predictive_html,
-    )
-
-    qualities = [doc.image_quality.as_dict() for doc in benchmark.docs]
-    agg = aggregate_corpus_predictive(qualities)
-    html = build_image_predictive_html(agg, labels)
+Voir :doc:`docs/architecture-cercles.md` pour la justification du
+classement de ce module au Cercle 3.
 """
 
-from __future__ import annotations
-
-from html import escape as _e
-from typing import Optional
-
-
-def _color_for_score(score: float) -> str:
-    """Vert (faible) → orange → rouge (élevé)."""
-    f = max(0.0, min(1.0, score))
-    if f < 0.5:
-        t = f / 0.5
-        r = int(167 + (235 - 167) * t)
-        g = int(240 + (180 - 240) * t)
-        b = int(167 + (60 - 167) * t)
-    else:
-        t = (f - 0.5) / 0.5
-        r = int(235 + (220 - 235) * t)
-        g = int(180 + (50 - 180) * t)
-        b = int(60 + (50 - 60) * t)
-    return f"#{r:02x}{g:02x}{b:02x}"
-
-
-_FEATURE_LABEL_KEYS = {
-    "noise_level": "imgpred_feat_noise",
-    "sharpness_score": "imgpred_feat_sharpness",
-    "contrast_score": "imgpred_feat_contrast",
-    "rotation_degrees": "imgpred_feat_rotation",
-}
-
-
-def _render_complexity_block(
-    aggregated: dict, labels: dict[str, str],
-) -> str:
-    h_complex = labels.get(
-        "imgpred_complexity", "Complexité paléographique",
-    )
-    h_mean = labels.get("imgpred_mean", "Moyenne")
-    h_median = labels.get("imgpred_median", "Médiane")
-    h_min = labels.get("imgpred_min", "Min")
-    h_max = labels.get("imgpred_max", "Max")
-    h_stdev = labels.get("imgpred_stdev", "Écart-type")
-    h_docs = labels.get("imgpred_docs", "Docs")
-    mean = float(aggregated.get("complexity_mean") or 0.0)
-    median = float(aggregated.get("complexity_median") or 0.0)
-    mn = float(aggregated.get("complexity_min") or 0.0)
-    mx = float(aggregated.get("complexity_max") or 0.0)
-    sd = float(aggregated.get("complexity_stdev") or 0.0)
-    n_docs = int(aggregated.get("n_docs") or 0)
-    color_mean = _color_for_score(mean)
-    return (
-        f'<div style="font-weight:600;margin:.4rem 0 .3rem 0">'
-        f'{_e(h_complex)}</div>'
-        '<table style="border-collapse:collapse;width:100%;'
-        'font-size:.9rem;margin-bottom:.8rem">'
-        f'<thead><tr>'
-        f'<th style="padding:.4rem .6rem;text-align:right;'
-        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_mean)}</th>'
-        f'<th style="padding:.4rem .6rem;text-align:right;'
-        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_median)}</th>'
-        f'<th style="padding:.4rem .6rem;text-align:right;'
-        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_min)}</th>'
-        f'<th style="padding:.4rem .6rem;text-align:right;'
-        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_max)}</th>'
-        f'<th style="padding:.4rem .6rem;text-align:right;'
-        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_stdev)}</th>'
-        f'<th style="padding:.4rem .6rem;text-align:right;'
-        f'border-bottom:1px solid #ccc;font-weight:600">{_e(h_docs)}</th>'
-        f'</tr></thead>'
-        f'<tbody><tr>'
-        f'<td style="padding:.4rem .6rem;text-align:right;'
-        f'background:{color_mean};font-family:monospace;font-weight:600">'
-        f'{mean:.3f}</td>'
-        f'<td style="padding:.4rem .6rem;text-align:right;'
-        f'font-family:monospace">{median:.3f}</td>'
-        f'<td style="padding:.4rem .6rem;text-align:right;'
-        f'font-family:monospace">{mn:.3f}</td>'
-        f'<td style="padding:.4rem .6rem;text-align:right;'
-        f'font-family:monospace">{mx:.3f}</td>'
-        f'<td style="padding:.4rem .6rem;text-align:right;'
-        f'font-family:monospace">{sd:.3f}</td>'
-        f'<td style="padding:.4rem .6rem;text-align:right;'
-        f'font-family:monospace">{n_docs}</td>'
-        f'</tr></tbody></table>'
-    )
-
-
-def _render_homogeneity_block(
-    homogeneity: dict, labels: dict[str, str],
-) -> str:
-    h_homo = labels.get(
-        "imgpred_homogeneity", "Homogénéité du corpus",
-    )
-    h_feat = labels.get("imgpred_feature", "Feature")
-    h_mean = labels.get("imgpred_feat_mean", "Moyenne")
-    h_stdev = labels.get("imgpred_feat_stdev", "Écart-type")
-    h_norm = labels.get(
-        "imgpred_feat_norm", "Contribution normalisée",
-    )
-    score = float(homogeneity.get("score") or 0.0)
-    color = _color_for_score(score)
-    parts = [
-        f'<div style="font-weight:600;margin:.4rem 0 .3rem 0">'
-        f'{_e(h_homo)} : '
-        f'<span style="background:{color};padding:.1rem .4rem;'
-        f'border-radius:.3rem;font-family:monospace">{score:.3f}</span>'
-        f'</div>',
-        '<table style="border-collapse:collapse;width:100%;'
-        'font-size:.9rem">',
-        '<thead><tr>',
-    ]
-    for col in (h_feat, h_mean, h_stdev, h_norm):
-        parts.append(
-            f'<th style="padding:.4rem .6rem;text-align:left;'
-            f'border-bottom:1px solid #ccc;font-weight:600">'
-            f'{_e(col)}</th>'
-        )
-    parts.append("</tr></thead><tbody>")
-    per_feat = homogeneity.get("per_feature") or {}
-    for key, label_key in _FEATURE_LABEL_KEYS.items():
-        if key not in per_feat:
-            continue
-        slot = per_feat[key]
-        feat_label = labels.get(label_key, key)
-        feat_mean = float(slot.get("mean") or 0.0)
-        feat_stdev = float(slot.get("stdev") or 0.0)
-        feat_norm = float(slot.get("normalised") or 0.0)
-        norm_color = _color_for_score(feat_norm)
-        parts.append(
-            f'<tr>'
-            f'<td style="padding:.4rem .6rem">{_e(feat_label)}</td>'
-            f'<td style="padding:.4rem .6rem;text-align:right;'
-            f'font-family:monospace">{feat_mean:.3f}</td>'
-            f'<td style="padding:.4rem .6rem;text-align:right;'
-            f'font-family:monospace">{feat_stdev:.3f}</td>'
-            f'<td style="padding:.4rem .6rem;text-align:right;'
-            f'background:{norm_color};font-family:monospace">'
-            f'{feat_norm:.3f}</td>'
-            f'</tr>'
-        )
-    parts.append("</tbody></table>")
-    return "".join(parts)
-
-
-def build_image_predictive_html(
-    aggregated: Optional[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Construit la vue HTML « Profil d'image du corpus ».
-
-    Parameters
-    ----------
-    aggregated:
-        Sortie de ``aggregate_corpus_predictive``.  Si ``None``
-        ou ``n_docs == 0``, retourne ``""``.
-    labels:
-        Dict i18n.  Clés sous le préfixe ``imgpred_*``.
-    """
-    if not aggregated:
-        return ""
-    if not aggregated.get("n_docs"):
-        return ""
-    labels = labels or {}
-    title = labels.get(
-        "imgpred_title", "Profil d'image du corpus",
-    )
-    note = labels.get(
-        "imgpred_note",
-        "Score de complexité paléographique combinant bruit, "
-        "flou, faible contraste et rotation. Le score "
-        "d'homogénéité signale si la moyenne globale est fiable "
-        "(corpus uniforme) ou trompeuse (corpus hétérogène — "
-        "voir alors la vue stratifiée).",
-    )
-    parts = [
-        '<section class="imgpred-section" style="margin:1rem 0">',
-        f'<h3 style="margin:0 0 .3rem 0">{_e(title)}</h3>',
-        f'<div style="font-size:.85rem;opacity:.75;margin-bottom:.6rem">'
-        f'{_e(note)}</div>',
-    ]
-    parts.append(_render_complexity_block(aggregated, labels))
-    homo = aggregated.get("homogeneity")
-    if isinstance(homo, dict):
-        parts.append(_render_homogeneity_block(homo, labels))
-    parts.append("</section>")
-    return "".join(parts)
-
+from picarones.extras.render.image_predictive_render import *  # noqa: F401, F403
 
-__all__ = ["build_image_predictive_html"]
+# Réexport explicite des éventuels noms privés ou modules accédés
+# directement par leur attribut (rare mais possible). Pour la plupart
+# des modules, l'``import *`` ci-dessus suffit.
+import picarones.extras.render.image_predictive_render as _module
+__all__ = getattr(_module, "__all__", [
+    name for name in dir(_module) if not name.startswith("_")
+])

picarones/report/module_audit_render.py

@@ -1,173 +1,20 @@
-"""Rendu HTML « Modules audités » — Sprint 97 (B.6).
+"""Alias rétrocompat — module déplacé dans :mod:`picarones.extras.render.module_audit_render`.
 
-Suite directe ``picarones/core/module_policy.py``.  Pattern
-identique aux autres rendus : server-side, pas de JS, anti-
-injection systématique.
+Phase A du chantier de refonte en 3 cercles (architecture-cercles.md).
+Le contenu vit désormais dans son cercle 3 ``extras/``. Cet alias
+permet aux imports historiques (``from picarones.report.module_audit_render
+import ...``) de continuer à fonctionner sans modification.
 
-Vue
----
-Tableau récapitulatif des modules utilisés dans une pipeline
-composée, chacun avec :
-
-- Statut d'audit (✓ vert si tous les checks passent, ✗ rouge
-  sinon, avec compte des échecs) ;
-- Métadonnées : version, auteur, licence ;
-- Citation académique si fournie ;
-- Lien vers la homepage si fourni.
-
-Adaptive : ``""`` si la liste est vide.
-
-Note d'intégration
-------------------
-Module pur — l'utilisateur compose la liste depuis sa
-``PipelineSpec`` augmentée des ``ModuleManifest`` :
-
-.. code-block:: python
-
-    from picarones.core.module_policy import audit_module
-    from picarones.report.module_audit_render import build_module_audit_html
-
-    audits = []
-    for step in pipeline.steps:
-        manifest = step.module.manifest  # convention applicative
-        result = audit_module(step.module, manifest)
-        audits.append({
-            "manifest": manifest.as_dict(),
-            "audit": result.as_dict(),
-        })
-    html = build_module_audit_html(audits, labels)
+Voir :doc:`docs/architecture-cercles.md` pour la justification du
+classement de ce module au Cercle 3.
 """
 
-from __future__ import annotations
-
-from html import escape as _e
-from typing import Optional
-
-
-def _passed_badge(passed: bool, n_failed: int, label_pass: str,
-                  label_fail: str) -> str:
-    if passed:
-        return (
-            f'<span style="color:#16a34a;font-weight:700">'
-            f'✓ {_e(label_pass)}</span>'
-        )
-    return (
-        f'<span style="color:#dc2626;font-weight:700">'
-        f'✗ {_e(label_fail)} ({n_failed})</span>'
-    )
-
-
-def build_module_audit_html(
-    audits: Optional[list],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Construit la vue HTML « Modules audités ».
-
-    Parameters
-    ----------
-    audits:
-        Liste de dicts ``{"manifest": ManifestDict, "audit":
-        AuditResultDict}``.  Si vide ou ``None``, retourne ``""``.
-    labels:
-        Dict i18n.  Clés sous le préfixe ``audit_*``.
-    """
-    if not audits:
-        return ""
-    rows = [
-        a for a in audits
-        if isinstance(a, dict)
-        and isinstance(a.get("manifest"), dict)
-        and isinstance(a.get("audit"), dict)
-    ]
-    if not rows:
-        return ""
-    labels = labels or {}
-    title = labels.get("audit_title", "Modules audités")
-    note = labels.get(
-        "audit_note",
-        "Récapitulatif des modules utilisés dans la pipeline "
-        "composée. Un module qui ne passe pas l'audit n'est "
-        "pas exécutable. Métadonnées issues du manifest fourni "
-        "par le contributeur (auteur, licence, citation).",
-    )
-    label_pass = labels.get("audit_pass", "audit OK")
-    label_fail = labels.get("audit_fail", "checks échoués")
-    h_module = labels.get("audit_module", "Module")
-    h_status = labels.get("audit_status", "Audit")
-    h_version = labels.get("audit_version", "Version")
-    h_author = labels.get("audit_author", "Auteur")
-    h_license = labels.get("audit_license", "Licence")
-    h_io = labels.get("audit_io", "Entrée → sortie")
-    h_citation = labels.get("audit_citation", "Citation")
-    h_homepage = labels.get("audit_homepage", "Page projet")
-
-    parts = [
-        '<section class="audit-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 col in (h_module, h_status, h_version, h_author,
-                h_license, h_io, h_citation, h_homepage):
-        parts.append(
-            f'<th style="padding:.4rem .6rem;text-align:left;'
-            f'border-bottom:1px solid #ccc;font-weight:600">'
-            f'{_e(col)}</th>'
-        )
-    parts.append("</tr></thead><tbody>")
-
-    for entry in rows:
-        manifest = entry["manifest"]
-        audit = entry["audit"]
-        name = str(manifest.get("name") or "?")
-        version = str(manifest.get("version") or "—")
-        author = str(manifest.get("author") or "—")
-        license_ = str(manifest.get("license") or "—")
-        in_types = ", ".join(manifest.get("input_types") or []) or "—"
-        out_types = ", ".join(manifest.get("output_types") or []) or "—"
-        citation = manifest.get("citation") or ""
-        homepage = manifest.get("homepage") or ""
-        passed = bool(audit.get("passed"))
-        n_failed = int(audit.get("n_failed") or 0)
-        status_cell = _passed_badge(
-            passed, n_failed, label_pass, label_fail,
-        )
-        # Citation : tronqué si trop long
-        citation_str = str(citation)[:120]
-        if len(str(citation)) > 120:
-            citation_str += "…"
-        citation_cell = (
-            _e(citation_str) if citation_str.strip() else "—"
-        )
-        # Homepage : on n'auto-link **pas** (anti-injection +
-        # honnêteté : l'URL peut pointer ailleurs).  On affiche
-        # le texte échappé tel quel.
-        homepage_cell = (
-            _e(str(homepage))[:80] + ("…" if len(str(homepage)) > 80 else "")
-        ) if str(homepage).strip() else "—"
-        parts.append(
-            f'<tr>'
-            f'<td style="padding:.4rem .6rem;font-family:monospace">'
-            f'{_e(name)}</td>'
-            f'<td style="padding:.4rem .6rem">{status_cell}</td>'
-            f'<td style="padding:.4rem .6rem;font-family:monospace">'
-            f'{_e(version)}</td>'
-            f'<td style="padding:.4rem .6rem">{_e(author)}</td>'
-            f'<td style="padding:.4rem .6rem;font-family:monospace">'
-            f'{_e(license_)}</td>'
-            f'<td style="padding:.4rem .6rem;font-family:monospace;'
-            f'font-size:.8rem">{_e(in_types)} → {_e(out_types)}</td>'
-            f'<td style="padding:.4rem .6rem;font-size:.8rem;'
-            f'opacity:.85">{citation_cell}</td>'
-            f'<td style="padding:.4rem .6rem;font-family:monospace;'
-            f'font-size:.8rem">{homepage_cell}</td>'
-            f'</tr>'
-        )
-    parts.append("</tbody></table></section>")
-    return "".join(parts)
-
+from picarones.extras.render.module_audit_render import *  # noqa: F401, F403
 
-__all__ = ["build_module_audit_html"]
+# Réexport explicite des éventuels noms privés ou modules accédés
+# directement par leur attribut (rare mais possible). Pour la plupart
+# des modules, l'``import *`` ci-dessus suffit.
+import picarones.extras.render.module_audit_render as _module
+__all__ = getattr(_module, "__all__", [
+    name for name in dir(_module) if not name.startswith("_")
+])

picarones/report/taxonomy_cooccurrence_render.py

@@ -1,199 +1,20 @@
-"""Rendu HTML de la heatmap de co-occurrence taxonomique — Sprint 75.
+"""Alias rétrocompat — module déplacé dans :mod:`picarones.extras.render.taxonomy_cooccurrence_render`.
 
-A.I.4 chantier 1 du plan d'évolution 2026.
+Phase A du chantier de refonte en 3 cercles (architecture-cercles.md).
+Le contenu vit désormais dans son cercle 3 ``extras/``. Cet alias
+permet aux imports historiques (``from picarones.report.taxonomy_cooccurrence_render
+import ...``) de continuer à fonctionner sans modification.
 
-Suite directe ``picarones/core/taxonomy_cooccurrence.py``.  Pattern
-identique aux autres rendus (Sprints 41/43/62/67/72/74) :
-**server-side**, pas de JavaScript, anti-injection systématique.
-
-Sortie typique
---------------
-- ``build_taxonomy_cooccurrence_html(data, labels)`` produit un
-  bloc complet : titre + note d'usage + heatmap SVG + table des
-  paires les plus co-occurrentes.
-- ``""`` retourné si ``data is None`` ou si la matrice est vide
-  (rapport adaptatif).
+Voir :doc:`docs/architecture-cercles.md` pour la justification du
+classement de ce module au Cercle 3.
 """
 
-from __future__ import annotations
-
-from html import escape as _e
-from typing import Optional
-
-
-def _color_for_jaccard(j: float) -> str:
-    """Gradient blanc → bleu profond pour Jaccard ∈ [0, 1].
-
-    Interpolation entre #ffffff (j=0) et #1e3a8a (j=1).
-    """
-    f = max(0.0, min(1.0, j))
-    r = int(255 + (30 - 255) * f)
-    g = int(255 + (58 - 255) * f)
-    b = int(255 + (138 - 255) * f)
-    return f"#{r:02x}{g:02x}{b:02x}"
-
-
-def _text_color_for_bg(j: float) -> str:
-    """Texte blanc si fond foncé, noir sinon (lisibilité)."""
-    return "#fff" if j > 0.55 else "#222"
-
-
-def _build_heatmap_svg(
-    classes: list[str],
-    matrix: dict[str, dict[str, float]],
-    *,
-    cell_size: int = 36,
-    label_left: int = 130,
-    label_top: int = 80,
-) -> str:
-    """Construit la heatmap SVG.
-
-    Cellule = carré coloré ``_color_for_jaccard``, valeur Jaccard
-    affichée en chiffres si > 0,05.  Étiquettes des classes en
-    colonne (haut) et en ligne (gauche).
-    """
-    n = len(classes)
-    if n == 0:
-        return ""
-    width = label_left + n * cell_size + 10
-    height = label_top + n * cell_size + 10
-
-    parts = [
-        f'<svg xmlns="http://www.w3.org/2000/svg" '
-        f'width="{width}" height="{height}" '
-        f'viewBox="0 0 {width} {height}" '
-        f'role="img" aria-label="Heatmap Jaccard co-occurrence taxonomique">',
-    ]
-    # Étiquettes de colonnes (rotées -45°)
-    for j, cls in enumerate(classes):
-        cx = label_left + j * cell_size + cell_size // 2
-        cy = label_top - 6
-        parts.append(
-            f'<text x="{cx}" y="{cy}" '
-            f'transform="rotate(-45 {cx} {cy})" '
-            f'font-size="11" fill="#333" text-anchor="start">'
-            f'{_e(cls)}</text>'
-        )
-    # Étiquettes de lignes
-    for i, cls in enumerate(classes):
-        rx = label_left - 6
-        ry = label_top + i * cell_size + cell_size // 2 + 4
-        parts.append(
-            f'<text x="{rx}" y="{ry}" '
-            f'font-size="11" fill="#333" text-anchor="end">'
-            f'{_e(cls)}</text>'
-        )
-    # Cellules
-    for i, ca in enumerate(classes):
-        for j, cb in enumerate(classes):
-            value = matrix.get(ca, {}).get(cb, 0.0)
-            x = label_left + j * cell_size
-            y = label_top + i * cell_size
-            color = _color_for_jaccard(value)
-            text_color = _text_color_for_bg(value)
-            parts.append(
-                f'<rect x="{x}" y="{y}" '
-                f'width="{cell_size}" height="{cell_size}" '
-                f'fill="{color}" stroke="#ddd" stroke-width="0.5"/>'
-            )
-            if value > 0.05:
-                parts.append(
-                    f'<text x="{x + cell_size // 2}" '
-                    f'y="{y + cell_size // 2 + 4}" '
-                    f'font-size="10" fill="{text_color}" '
-                    f'text-anchor="middle">'
-                    f'{value:.2f}</text>'
-                )
-    parts.append("</svg>")
-    return "".join(parts)
-
-
-def _build_top_pairs_table(
-    top_pairs: list,
-    labels: dict,
-) -> str:
-    """Construit la table HTML des paires les plus co-occurrentes."""
-    if not top_pairs:
-        return ""
-    pair_label = labels.get("taxocooc_pair_label", "Paire")
-    jaccard_label = labels.get("taxocooc_jaccard_label", "Jaccard")
-
-    parts = [
-        '<table style="border-collapse:collapse;font-size:.85rem;'
-        'margin-top:.5rem">',
-        '<thead><tr>',
-        f'<th style="padding:.3rem .5rem;text-align:left;'
-        f'border-bottom:1px solid #ccc;font-weight:600">'
-        f'{_e(pair_label)}</th>',
-        f'<th style="padding:.3rem .5rem;text-align:right;'
-        f'border-bottom:1px solid #ccc;font-weight:600">'
-        f'{_e(jaccard_label)}</th>',
-        '</tr></thead><tbody>',
-    ]
-    for ca, cb, j in top_pairs:
-        parts.append(
-            f'<tr>'
-            f'<td style="padding:.2rem .5rem">'
-            f'<code>{_e(ca)}</code> ↔ <code>{_e(cb)}</code></td>'
-            f'<td style="padding:.2rem .5rem;text-align:right;'
-            f'font-family:monospace;background:{_color_for_jaccard(j)};'
-            f'color:{_text_color_for_bg(j)}">{j:.2f}</td>'
-            f'</tr>'
-        )
-    parts.append("</tbody></table>")
-    return "".join(parts)
-
-
-def build_taxonomy_cooccurrence_html(
-    data: Optional[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Construit le bloc HTML complet de co-occurrence taxonomique.
-
-    Retourne ``""`` si ``data is None`` ou matrice vide.
-    """
-    if not data:
-        return ""
-    classes = data.get("classes") or []
-    matrix = data.get("cooccurrence_matrix") or {}
-    if not classes or not matrix:
-        return ""
-    labels = labels or {}
-    title = labels.get(
-        "taxocooc_title",
-        "Co-occurrence des classes d'erreur",
-    )
-    note = labels.get(
-        "taxocooc_note",
-        "Indice de Jaccard au niveau document : 1,00 = ces deux classes "
-        "apparaissent toujours ensemble ; 0,00 = jamais. Lecture par paires "
-        "co-occurrentes ci-dessous.",
-    )
-    n_docs = data.get("n_documents", 0)
-    n_docs_label_template = labels.get(
-        "taxocooc_n_docs", "Calculé sur {n_docs} documents.",
-    )
-    n_docs_phrase = n_docs_label_template.format(n_docs=n_docs)
-
-    svg = _build_heatmap_svg(classes, matrix)
-    top_table = _build_top_pairs_table(
-        data.get("top_pairs") or [], labels,
-    )
-
-    parts = [
-        '<div class="taxocooc" style="margin:1rem 0">',
-        f'<div style="font-weight:600;margin-bottom:.4rem">{_e(title)}</div>',
-        f'<div style="font-size:.85rem;opacity:.75;margin-bottom:.5rem">'
-        f'{_e(note)}</div>',
-        f'<div style="font-size:.8rem;opacity:.7;margin-bottom:.5rem">'
-        f'{_e(n_docs_phrase)}</div>',
-        svg,
-        top_table,
-        "</div>",
-    ]
-    return "".join(parts)
-
+from picarones.extras.render.taxonomy_cooccurrence_render import *  # noqa: F401, F403
 
-__all__ = [
-    "build_taxonomy_cooccurrence_html",
-]
+# Réexport explicite des éventuels noms privés ou modules accédés
+# directement par leur attribut (rare mais possible). Pour la plupart
+# des modules, l'``import *`` ci-dessus suffit.
+import picarones.extras.render.taxonomy_cooccurrence_render as _module
+__all__ = getattr(_module, "__all__", [
+    name for name in dir(_module) if not name.startswith("_")
+])

picarones/report/taxonomy_intra_doc_render.py

@@ -1,182 +1,20 @@
-"""Rendu HTML de la heatmap class × position — Sprint 76.
+"""Alias rétrocompat — module déplacé dans :mod:`picarones.extras.render.taxonomy_intra_doc_render`.
 
-A.I.4 chantier 2 du plan d'évolution 2026.
+Phase A du chantier de refonte en 3 cercles (architecture-cercles.md).
+Le contenu vit désormais dans son cercle 3 ``extras/``. Cet alias
+permet aux imports historiques (``from picarones.report.taxonomy_intra_doc_render
+import ...``) de continuer à fonctionner sans modification.
 
-Suite directe ``picarones/core/taxonomy_intra_doc.py``.  Pattern
-identique aux autres rendus (Sprints 41/43/62/67/72/74/75) :
-**server-side**, pas de JavaScript, anti-injection systématique.
-
-Sortie typique
---------------
-Une grille N_classes × N_bins où chaque cellule indique la densité
-d'erreurs de cette classe à cette position dans le document.
-Lecture immédiate : « ligature_error concentré dans la première
-tranche → erreur de marge ; visual_confusion uniformément réparti
-→ erreur de scribe ».
-
-Adaptive : si ``data is None`` ou si toutes les classes ont 0
-erreur, retourne ``""``.
+Voir :doc:`docs/architecture-cercles.md` pour la justification du
+classement de ce module au Cercle 3.
 """
 
-from __future__ import annotations
-
-from html import escape as _e
-from typing import Optional
-
-
-def _color_for_density(density: float) -> str:
-    """Gradient blanc → orange profond pour densité ∈ [0, 1].
-
-    Interpolation entre #ffffff (0) et #c2410c (1).
-    """
-    f = max(0.0, min(1.0, density))
-    r = int(255 + (194 - 255) * f)
-    g = int(255 + (65 - 255) * f)
-    b = int(255 + (12 - 255) * f)
-    return f"#{r:02x}{g:02x}{b:02x}"
-
-
-def _text_color_for_bg(density: float) -> str:
-    return "#fff" if density > 0.55 else "#222"
-
-
-def _build_heatmap_svg(
-    classes_with_errors: list[str],
-    per_class: dict[str, list[int]],
-    n_bins: int,
-    *,
-    cell_w: int = 36,
-    cell_h: int = 26,
-    label_left: int = 150,
-    label_top: int = 30,
-) -> str:
-    """Construit la heatmap SVG class × position."""
-    n_rows = len(classes_with_errors)
-    if n_rows == 0:
-        return ""
-    width = label_left + n_bins * cell_w + 10
-    height = label_top + n_rows * cell_h + 30  # +30 pour étiquette X
-
-    # Normalisation : pour chaque classe, densité relative au max
-    # de cette classe (mise en évidence des positions concentrées).
-    parts = [
-        f'<svg xmlns="http://www.w3.org/2000/svg" '
-        f'width="{width}" height="{height}" '
-        f'viewBox="0 0 {width} {height}" '
-        f'role="img" aria-label="Heatmap class taxonomique × position">',
-    ]
-    # Étiquettes des colonnes (positions)
-    for j in range(n_bins):
-        cx = label_left + j * cell_w + cell_w // 2
-        cy = label_top - 6
-        parts.append(
-            f'<text x="{cx}" y="{cy}" '
-            f'font-size="10" fill="#666" text-anchor="middle">'
-            f'{j + 1}</text>'
-        )
-    # Cellules
-    for i, cls in enumerate(classes_with_errors):
-        # Étiquette de ligne (classe)
-        rx = label_left - 6
-        ry = label_top + i * cell_h + cell_h // 2 + 4
-        parts.append(
-            f'<text x="{rx}" y="{ry}" '
-            f'font-size="11" fill="#333" text-anchor="end">'
-            f'{_e(cls)}</text>'
-        )
-        counts = per_class.get(cls, [0] * n_bins)
-        max_count = max(counts) if counts else 0
-        for j in range(n_bins):
-            x = label_left + j * cell_w
-            y = label_top + i * cell_h
-            count = counts[j] if j < len(counts) else 0
-            density = (count / max_count) if max_count > 0 else 0.0
-            color = _color_for_density(density)
-            text_color = _text_color_for_bg(density)
-            parts.append(
-                f'<rect x="{x}" y="{y}" '
-                f'width="{cell_w}" height="{cell_h}" '
-                f'fill="{color}" stroke="#ddd" stroke-width="0.5"/>'
-            )
-            if count > 0:
-                parts.append(
-                    f'<text x="{x + cell_w // 2}" '
-                    f'y="{y + cell_h // 2 + 4}" '
-                    f'font-size="10" fill="{text_color}" '
-                    f'text-anchor="middle">{count}</text>'
-                )
-    # Étiquette axe X en bas
-    cx_axis = label_left + (n_bins * cell_w) // 2
-    cy_axis = height - 6
-    parts.append(
-        f'<text x="{cx_axis}" y="{cy_axis}" '
-        f'font-size="11" fill="#666" text-anchor="middle" '
-        f'font-style="italic">'
-        f'Position dans le document (1 = début)</text>'
-    )
-    parts.append("</svg>")
-    return "".join(parts)
-
-
-def build_taxonomy_intra_doc_html(
-    data: Optional[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Construit le bloc HTML complet de la heatmap intra-document.
-
-    Retourne ``""`` si ``data is None`` ou aucune erreur.
-    """
-    if not data:
-        return ""
-    n_bins = data.get("n_bins", 0)
-    per_class = data.get("per_class") or {}
-    total_errors = data.get("total_errors", 0)
-    if total_errors == 0 or n_bins <= 0:
-        return ""
-    # Filtre : uniquement les classes ayant au moins une erreur
-    classes_with_errors = [
-        cls for cls, counts in per_class.items()
-        if isinstance(counts, list) and sum(counts) > 0
-    ]
-    if not classes_with_errors:
-        return ""
-
-    labels = labels or {}
-    title = labels.get(
-        "intradoc_title",
-        "Évolution intra-document des classes d'erreur",
-    )
-    note = labels.get(
-        "intradoc_note",
-        "Heatmap class × position : densité relative par classe "
-        "(plus foncé = concentré). Une classe concentrée dans la "
-        "première colonne suggère une erreur de marge ; "
-        "une distribution uniforme suggère une erreur de scribe.",
-    )
-    n_words_gt = data.get("n_words_gt", 0)
-    n_words_template = labels.get(
-        "intradoc_n_words",
-        "Calculé sur {n_words_gt} mots GT, répartis en {n_bins} tranches.",
-    )
-    n_words_phrase = n_words_template.format(
-        n_words_gt=n_words_gt, n_bins=n_bins,
-    )
-
-    svg = _build_heatmap_svg(classes_with_errors, per_class, n_bins)
-
-    parts = [
-        '<div class="intradoc" style="margin:1rem 0">',
-        f'<div style="font-weight:600;margin-bottom:.4rem">{_e(title)}</div>',
-        f'<div style="font-size:.85rem;opacity:.75;margin-bottom:.5rem">'
-        f'{_e(note)}</div>',
-        f'<div style="font-size:.8rem;opacity:.7;margin-bottom:.5rem">'
-        f'{_e(n_words_phrase)}</div>',
-        svg,
-        "</div>",
-    ]
-    return "".join(parts)
-
+from picarones.extras.render.taxonomy_intra_doc_render import *  # noqa: F401, F403
 
-__all__ = [
-    "build_taxonomy_intra_doc_html",
-]
+# Réexport explicite des éventuels noms privés ou modules accédés
+# directement par leur attribut (rare mais possible). Pour la plupart
+# des modules, l'``import *`` ci-dessus suffit.
+import picarones.extras.render.taxonomy_intra_doc_render as _module
+__all__ = getattr(_module, "__all__", [
+    name for name in dir(_module) if not name.startswith("_")
+])

tests/test_phaseA_migration.py

@@ -0,0 +1,318 @@
+"""Tests de la phase A — refonte en 3 cercles (post-chantier 6).
+
+Couvre :
+
+- 4 modules `core/` déplacés vers `extras/academic/` ou
+  `extras/governance/` avec shims rétrocompat.
+- 4 renderers `report/` déplacés vers `extras/render/` avec shims.
+- Identité préservée : ``shim.X is new_location.X`` (pas de duplication
+  ni de redéfinition).
+- Hygiène anti-verdict : 5 phrases reformulées dans les templates
+  narratifs et l'i18n du rapport.
+- Document `docs/architecture-cercles.md` présent et complet.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 1. Modules déplacés vers extras/ — rétrocompat des imports historiques
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestRetrocompatHistoricalImports:
+    """Les imports `from picarones.core.X` doivent continuer à fonctionner
+    après le déplacement vers `picarones.extras.*`."""
+
+    @pytest.mark.parametrize("module_path, attribute", [
+        ("picarones.core.taxonomy_intra_doc", "compute_taxonomy_position_heatmap"),
+        ("picarones.core.taxonomy_cooccurrence", "compute_taxonomy_cooccurrence"),
+        ("picarones.core.image_predictive", "compute_paleographic_complexity"),
+        ("picarones.core.image_predictive", "compute_corpus_homogeneity"),
+        ("picarones.core.image_predictive", "aggregate_corpus_predictive"),
+        ("picarones.core.module_policy", "ModuleManifest"),
+        ("picarones.core.module_policy", "validate_manifest"),
+        ("picarones.core.module_policy", "audit_module"),
+    ])
+    def test_core_alias_still_works(self, module_path: str, attribute: str):
+        import importlib
+        mod = importlib.import_module(module_path)
+        assert hasattr(mod, attribute), (
+            f"{module_path}.{attribute} a disparu après la phase A — "
+            "le shim rétrocompat est cassé"
+        )
+
+    @pytest.mark.parametrize("module_path, attribute", [
+        ("picarones.report.taxonomy_intra_doc_render", "build_taxonomy_intra_doc_html"),
+        ("picarones.report.taxonomy_cooccurrence_render", "build_taxonomy_cooccurrence_html"),
+        ("picarones.report.image_predictive_render", "build_image_predictive_html"),
+        ("picarones.report.module_audit_render", "build_module_audit_html"),
+    ])
+    def test_report_alias_still_works(self, module_path: str, attribute: str):
+        import importlib
+        mod = importlib.import_module(module_path)
+        assert hasattr(mod, attribute)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 2. Modules accessibles via leur nouveau chemin extras/
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestNewExtrasImports:
+    @pytest.mark.parametrize("new_path, attribute", [
+        ("picarones.extras.academic.taxonomy_intra_doc", "compute_taxonomy_position_heatmap"),
+        ("picarones.extras.academic.taxonomy_cooccurrence", "compute_taxonomy_cooccurrence"),
+        ("picarones.extras.academic.image_predictive", "aggregate_corpus_predictive"),
+        ("picarones.extras.governance.module_policy", "ModuleManifest"),
+        ("picarones.extras.render.taxonomy_intra_doc_render", "build_taxonomy_intra_doc_html"),
+        ("picarones.extras.render.taxonomy_cooccurrence_render", "build_taxonomy_cooccurrence_html"),
+        ("picarones.extras.render.image_predictive_render", "build_image_predictive_html"),
+        ("picarones.extras.render.module_audit_render", "build_module_audit_html"),
+    ])
+    def test_extras_path_works(self, new_path: str, attribute: str):
+        import importlib
+        mod = importlib.import_module(new_path)
+        assert hasattr(mod, attribute)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 3. Identité préservée — pas de redéfinition par le shim
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestIdentityThroughShim:
+    """Le shim doit réexporter la fonction du nouveau chemin, pas la
+    redéfinir. Sinon une métrique serait calculée différemment selon
+    le chemin d'import."""
+
+    def test_taxonomy_intra_doc_identity(self):
+        from picarones.core.taxonomy_intra_doc import (
+            compute_taxonomy_position_heatmap as via_old,
+        )
+        from picarones.extras.academic.taxonomy_intra_doc import (
+            compute_taxonomy_position_heatmap as via_new,
+        )
+        assert via_old is via_new
+
+    def test_image_predictive_identity(self):
+        from picarones.core.image_predictive import (
+            aggregate_corpus_predictive as via_old,
+        )
+        from picarones.extras.academic.image_predictive import (
+            aggregate_corpus_predictive as via_new,
+        )
+        assert via_old is via_new
+
+    def test_module_policy_identity(self):
+        from picarones.core.module_policy import ModuleManifest as via_old
+        from picarones.extras.governance.module_policy import (
+            ModuleManifest as via_new,
+        )
+        assert via_old is via_new
+
+    def test_renderer_identity(self):
+        from picarones.report.taxonomy_intra_doc_render import (
+            build_taxonomy_intra_doc_html as via_old,
+        )
+        from picarones.extras.render.taxonomy_intra_doc_render import (
+            build_taxonomy_intra_doc_html as via_new,
+        )
+        assert via_old is via_new
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 4. Vues du chantier 3 — toujours fonctionnelles
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestChantier3ViewsStillWork:
+    """Les 5 vues du chantier 3 importent (sous-section opt-in) les
+    modules déplacés. Vérifier qu'elles tournent encore après la
+    migration."""
+
+    def test_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)
+
+    def test_advanced_taxonomy_with_intra_doc_data(self):
+        """La vue advanced_taxonomy accepte des données opt-in
+        ``intra_doc`` dont le calcul vient désormais de
+        ``picarones.extras.academic``."""
+        from picarones.extras.academic.taxonomy_intra_doc import (
+            compute_taxonomy_position_heatmap,
+        )
+        from picarones.report.views import build_advanced_taxonomy_view_html
+
+        # Calcul d'une heatmap minimaliste
+        result = compute_taxonomy_position_heatmap(
+            "abc def ghi", "abx def ghi", n_bins=3,
+        )
+        # La vue doit pouvoir composer sans crasher quand on lui passe
+        # ces données opt-in
+        report_data = {"engines": [
+            {"name": "tess", "cer": 0.05,
+             "aggregated_taxonomy": {"class_distribution": {"x": 5}}},
+            {"name": "pero", "cer": 0.08,
+             "aggregated_taxonomy": {"class_distribution": {"x": 8}}},
+        ]}
+        html = build_advanced_taxonomy_view_html(
+            report_data, {}, intra_doc=result,
+        )
+        # Pas de crash + au moins du contenu (comparison + intra_doc)
+        assert isinstance(html, str)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 5. Hygiène anti-verdict — phrases reformulées
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestAntiVerdictHygiene:
+    """Les 5 phrases identifiées comme prescriptives ont été reformulées
+    factuellement. Tests anti-régression."""
+
+    @pytest.fixture
+    def fr_templates(self) -> str:
+        path = (Path(__file__).parent.parent
+                / "picarones" / "core" / "narrative" / "templates" / "fr.yaml")
+        return path.read_text(encoding="utf-8")
+
+    @pytest.fixture
+    def en_templates(self) -> str:
+        path = (Path(__file__).parent.parent
+                / "picarones" / "core" / "narrative" / "templates" / "en.yaml")
+        return path.read_text(encoding="utf-8")
+
+    @pytest.fixture
+    def fr_i18n(self) -> str:
+        path = (Path(__file__).parent.parent
+                / "picarones" / "report" / "i18n" / "fr.json")
+        return path.read_text(encoding="utf-8")
+
+    @pytest.fixture
+    def en_i18n(self) -> str:
+        path = (Path(__file__).parent.parent
+                / "picarones" / "report" / "i18n" / "en.json")
+        return path.read_text(encoding="utf-8")
+
+    def test_stratum_winner_no_dominate(self, fr_templates, en_templates):
+        """`stratum_winner` ne dit plus « domine nettement » /
+        « clearly dominates ». Phrasage factuel attendu."""
+        assert "domine\n  nettement" not in fr_templates
+        assert "domine nettement" not in fr_templates
+        assert "clearly\n  dominates" not in en_templates
+        assert "clearly dominates" not in en_templates
+        # Confirmation présence du nouveau phrasage factuel
+        assert "le CER le plus bas" in fr_templates
+        assert "the lowest CER" in en_templates
+
+    def test_confidence_warning_no_fragile(self, fr_templates, en_templates):
+        """`confidence_warning` ne dit plus « fragile » mais
+        « incertitude statistique élevée »."""
+        assert "Classement fragile" not in fr_templates
+        assert "Ranking is fragile" not in en_templates
+        assert "Incertitude statistique" in fr_templates
+        assert "High statistical uncertainty" in en_templates
+
+    def test_gini_no_ideal(self, fr_i18n, en_i18n):
+        """`gini_cer_ideal` et `gini_cer_note` n'utilisent plus
+        « idéal » / « ideal » mais « lecture » / « reading »."""
+        assert "\"gini_cer_ideal\": \"— idéal" not in fr_i18n
+        assert "\"gini_cer_ideal\": \"— ideal" not in en_i18n
+        # Confirmer le nouveau phrasage
+        assert "lecture : bas-gauche" in fr_i18n
+        assert "reading: bottom-left" in en_i18n
+
+    def test_taxocomp_no_preferable(self, fr_i18n, en_i18n):
+        """`taxocomp_note` ne dit plus « préférable » / « preferable »."""
+        assert "préférable pour une édition critique" not in fr_i18n
+        assert "preferable for a critical edition" not in en_i18n
+        # Phrasage factuel
+        assert "tend à produire des erreurs plus facilement" in fr_i18n
+        assert "tends to produce errors more easily" in en_i18n
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 6. Document docs/architecture-cercles.md présent et complet
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestArchitectureCerclesDoc:
+    @pytest.fixture
+    def doc(self) -> str:
+        path = (Path(__file__).parent.parent / "docs" / "architecture-cercles.md")
+        return path.read_text(encoding="utf-8")
+
+    def test_doc_exists(self, doc):
+        assert len(doc) > 1000
+
+    def test_doc_describes_three_circles(self, doc):
+        assert "Cercle 1" in doc
+        assert "Cercle 2" in doc
+        assert "Cercle 3" in doc
+        assert "Noyau invariant" in doc or "noyau invariant" in doc
+        assert "Plugins" in doc or "plugins" in doc
+
+    def test_doc_assigns_specific_modules(self, doc):
+        """Le document doit lister explicitement les modules de chaque cercle."""
+        # Cercle 1 — quelques noms
+        for name in ["corpus.py", "modules.py", "runner.py",
+                     "metric_registry.py", "alto_metrics.py"]:
+            assert name in doc, f"{name} doit être listé dans le doc"
+        # Cercle 3 — modules déplacés en phase A
+        for name in ["taxonomy_intra_doc", "image_predictive",
+                     "module_policy"]:
+            assert name in doc, f"{name} doit être listé dans le doc"
+
+    def test_doc_mentions_extras_path(self, doc):
+        """Le doc explique que les Cercle 3 vivent dans `extras/`."""
+        assert "extras/academic" in doc
+        assert "extras/governance" in doc
+        assert "extras/render" in doc
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 7. Modules originaux ne contiennent plus de logique métier
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestOriginalsAreShims:
+    """Vérifie que les fichiers laissés à l'ancien emplacement sont
+    bien des shims minces, pas des copies de la logique."""
+
+    @pytest.mark.parametrize("path", [
+        "picarones/core/taxonomy_intra_doc.py",
+        "picarones/core/taxonomy_cooccurrence.py",
+        "picarones/core/image_predictive.py",
+        "picarones/core/module_policy.py",
+        "picarones/report/taxonomy_intra_doc_render.py",
+        "picarones/report/taxonomy_cooccurrence_render.py",
+        "picarones/report/image_predictive_render.py",
+        "picarones/report/module_audit_render.py",
+    ])
+    def test_is_thin_shim(self, path):
+        repo_root = Path(__file__).parent.parent
+        content = (repo_root / path).read_text(encoding="utf-8")
+        # Un shim < 30 lignes (juste docstring + 2 imports + __all__)
+        n_lines = len([line for line in content.splitlines() if line.strip()])
+        assert n_lines < 30, (
+            f"{path} fait {n_lines} lignes — devrait être un shim mince "
+            "(import + réexport, pas de logique métier)"
+        )
+        # Doit contenir l'indication du déplacement
+        assert "déplacé" in content or "extras" in content