sprint77: taxonomie comparative côte-à-côte (A.I.4 chantier 3, clôture A.I.4)

Troisième et dernier chantier d'A.I.4. Le détecteur
error_profile_outlier (Sprint 19) signale qu'un moteur a un profil
taxonomique éloigné de ses concurrents, mais sans visualisation.
Ce sprint répond à « deux moteurs ont le même CER global, mais
lequel fait des erreurs plus récupérables ? ».

- Nouveau module picarones/core/taxonomy_comparison.py :
- compare_taxonomies(engine_a, counts_a, engine_b, counts_b)
normalise en proportions, deltas signés, agrège par
récupérabilité éditoriale (recoverable/difficult/irrecoverable).
- Constante RECOVERABILITY exportée.
- Nouveau module picarones/report/taxonomy_comparison_render.py :
- build_taxonomy_comparison_html : titre + note + diagramme
miroir SVG + tableau résumé.
- Mirror chart : ligne par classe, barres horizontales A à
gauche / B à droite, étiquettes au centre, % à côté, couleur
selon récupérabilité (vert/orange/rouge), échelle normalisée.
- Tableau récupérabilité 3×2 avec pastilles colorées.
- Adaptive : "" si data None ou pas de classes.
- Choix éditorial assumé : la classification est un guide
pragmatique, pas un verdict imposé.
- +6 clés i18n FR/EN.
- +18 tests dans test_sprint77_taxonomy_comparison.py.

A.I.4 livré bout-en-bout (Sprints 75-77).

Tests : 2645 passed, 2 skipped, 0 failed.

https://claude.ai/code/session_01RusTQYcSfXqTsbFNvwmCV7

CHANGELOG.md

@@ -16,6 +16,64 @@ La numérotation de version suit [Semantic Versioning](https://semver.org/lang/f
 
 ### Ajouté
 
+- **Sprint 77 — A.I.4 chantier 3 : taxonomie comparative
+  côte-à-côte (clôture A.I.4).**  Troisième et dernier chantier
+  d'A.I.4.  Le détecteur ``error_profile_outlier`` (Sprint 19)
+  signale qu'un moteur a un profil taxonomique éloigné de ses
+  concurrents, mais sans visualisation.  Ce sprint répond à
+  *« deux moteurs ont le même CER global, mais lequel fait des
+  erreurs plus récupérables ? »*.
+  - Nouveau module `picarones/core/taxonomy_comparison.py` :
+    - ``compare_taxonomies(engine_a, counts_a, engine_b, counts_b)``
+      normalise les comptes en proportions (somme = 1), calcule
+      les ``deltas`` signés (b - a) par classe, et agrège par
+      niveau de **récupérabilité éditoriale** :
+
+      - ``recoverable``   : case_error, ligature_error,
+        abbreviation_error (corrigeables par post-processing
+        trivial)
+      - ``difficult``     : diacritic_error, visual_confusion,
+        hapax (effort modéré requis)
+      - ``irrecoverable`` : lacuna, oov_character,
+        segmentation_error (impossibles sans relire l'image)
+    - Constante ``RECOVERABILITY`` exportée pour utilisation
+      externe.
+    - Retourne ``None`` si les deux moteurs ont 0 erreur chacun.
+  - Nouveau module `picarones/report/taxonomy_comparison_render.py` :
+    - ``build_taxonomy_comparison_html(data, labels)`` produit
+      titre + note d'usage + diagramme miroir SVG + tableau
+      résumé par catégorie.
+    - ``_build_mirror_chart_svg`` server-side : une ligne par
+      classe, deux barres horizontales (A à gauche, B à droite),
+      étiquette de classe au centre, valeurs en %.  Couleur de
+      la barre selon ``recoverability`` (vert / orange / rouge).
+      Échelle normalisée à la proportion max pour visibilité
+      uniforme.
+    - ``_build_recoverability_summary_html`` : tableau 3 lignes
+      (Récupérable / Difficile / Irrécupérable) × 2 colonnes
+      (engine A / engine B) avec pastille colorée et %.
+    - Adaptive : ``""`` si ``data is None`` ou pas de classes.
+    - Anti-injection systématique sur noms de moteurs et labels
+      i18n.  Accessible : ``role="img"`` + ``aria-label``.
+  - +6 clés i18n FR/EN (``taxocomp_*``) avec template Python
+    ``{engine_a}/{engine_b}``.
+  - +18 tests dans `test_sprint77_taxonomy_comparison.py` :
+    couche calcul (7 cas — proportions, deltas signés,
+    récupérabilité, vide, classe unique chez un moteur, totaux,
+    sanité ``RECOVERABILITY`` couvre toutes ``ERROR_CLASSES``),
+    rendu (7 cas — None, SVG, noms moteurs, labels classes,
+    résumé récupérabilité, % affichés, codes couleur), anti-
+    injection (nom moteur + label i18n), complétude i18n FR + EN.
+  - **Choix éditorial assumé** : la classification
+    ``recoverable``/``difficult``/``irrecoverable`` est un
+    **guide pragmatique pour le chercheur**, pas un verdict
+    imposé.  La note explicative dit textuellement « à CER égal,
+    un moteur dont les erreurs sont majoritairement vertes est
+    préférable pour une édition critique » — c'est au chercheur
+    de juger selon ses besoins.
+  - **A.I.4 livré bout-en-bout** : co-occurrence (Sprint 75) +
+    intra-document (Sprint 76) + comparatif (Sprint 77).
+
 - **Sprint 76 — A.I.4 chantier 2 : évolution intra-document
   des classes taxonomiques (couche calcul + heatmap SVG).**
   Deuxième des trois chantiers d'A.I.4.  ``line_metrics.py``

CLAUDE.md

@@ -207,6 +207,7 @@ AZURE_DOC_INTEL_KEY=...
 | 33 | **Sprint 2 du plan d'évolution 2026 — Phase 0.2 : interface module générique**. Nouveau module `picarones/core/modules.py` avec l'enum `ArtifactType` (IMAGE, TEXT, ALTO, PAGE, ENTITIES, READING_ORDER) et la classe abstraite `BaseModule` qui déclare `input_types`/`output_types`, `execution_mode` (`"io"`/`"cpu"`), une méthode `process(dict[ArtifactType, Any]) → dict[ArtifactType, Any]`, et des helpers `validate_inputs`/`validate_outputs`. `BaseOCREngine` (`picarones/engines/base.py`) hérite désormais de `BaseModule` avec `input_types=(IMAGE,)` et `output_types=(TEXT,)` ; sa nouvelle méthode `process` wrappe l'API historique `run()`. Aucun adaptateur OCR existant n'est touché — `test_engines.py` passe à 20/20 sans modification. +23 tests dans `test_sprint33_module_interface.py` (contrat, validation, MockModule TEXT→ALTO démonstratif comme demandé par le plan, délégation `BaseOCREngine.process → run`, cohérence ArtifactType/GTLevel). **Verrou levé** : un même runner peut maintenant exécuter un OCR (image→texte), un mappeur VLM→ALTO, un rewriter ALTO→ALTO, un module NER (texte→entités), etc. — fondation directe pour l'axe B du plan. |
 | 34 | **Sprint 3 du plan d'évolution 2026 — Phase 0.3 : registre typé de métriques (clôture Phase 0)**. Nouveaux modules `picarones/core/metric_registry.py` (`MetricSpec`, `@register_metric`, `select_metrics`, `compute_at_junction`) et `picarones/core/builtin_metrics.py` qui enregistre `cer`, `wer`, `mer`, `wil` sur `(TEXT, TEXT)` plus un stub `text_preservation_after_reconstruction` sur `(TEXT, ALTO)` comme preuve de concept de jonction hétérogène. **Approche strictement additive** : ni `metrics.py` ni `compute_metrics` ne sont modifiés, le rapport HTML reste identique octet par octet. La sélection par signature de types est exacte (pas de coercion). +21 tests dans `test_sprint34_metric_registry.py`, dont une parité numérique CER/WER/MER/WIL avec `compute_metrics` legacy à 1e-9 près sur 4 paires de textes. **Verrou levé** : le runner d'une pipeline composée peut maintenant calculer automatiquement la métrique adéquate à chaque jonction de son DAG selon les types d'artefacts produits/attendus — fondation directe pour la métrique d'absorption d'erreur (acte B.3) et toutes les métriques structurelles à venir (Layout F1, reading order F1, NER). |
 | 35 | **Sprint 4 du plan d'évolution 2026 — Étape 2 / axe A : métriques inter-moteurs (couche de calcul)**. Nouveau module `picarones/core/inter_engine.py` qui répond à deux questions distinctes mais liées : *(a) à quel point les moteurs font-ils des erreurs de natures différentes ?* via `kl_divergence`, `jensen_shannon_divergence` (symétrique, bornée `[0, 1]`), et `taxonomy_divergence_matrix` qui construit la matrice triangulaire inter-moteurs ; *(b) quel CER serait atteignable si on combinait les moteurs ?* via `oracle_token_recall` (proxy bag-of-words, borne supérieure du recall atteignable), `complementarity_gap` (oracle vs meilleur moteur seul, gap absolu/relatif), et `pairwise_disagreement_rate`. Fonctions pures, sans I/O ni intégration runner — la couche de calcul est livrée indépendamment, le câblage narratif (`ENSEMBLE_OPPORTUNITY`) et HTML (matrice de divergence, badge oracle) suit au Sprint 36. +27 tests couvrant les invariants mathématiques (KL ≥ 0, KL(p,p) = 0, JS symétrique et bornée, oracle ≥ best_single, multiplicité respectée), les cas concrets (deux moteurs spécialisés sortent comme candidats ensemble, complémentarité parfaite atteint oracle = 1), et les garde-fous (référence vide, hypothèses vides, métrique inconnue). |
+| 77 | **Sprint 46 du plan d'évolution 2026 — A.I.4 chantier 3 : taxonomie comparative côte-à-côte (clôture A.I.4)**. Troisième chantier d'A.I.4. Répond à « deux moteurs ont le même CER global, mais lequel fait des erreurs plus récupérables ? ». Nouveau module `picarones/core/taxonomy_comparison.py` : `compare_taxonomies(engine_a, counts_a, engine_b, counts_b)` normalise en proportions, calcule deltas signés, agrège par niveau de **récupérabilité éditoriale** (recoverable: case/ligature/abbreviation ; difficult: diacritic/visual/hapax ; irrecoverable: lacuna/oov/segmentation). Constante `RECOVERABILITY` exportée. Retourne None si vide. Nouveau module `picarones/report/taxonomy_comparison_render.py` : `build_taxonomy_comparison_html` produit titre + note + diagramme miroir SVG + tableau résumé par catégorie. `_build_mirror_chart_svg` server-side : ligne par classe, barres horizontales A à gauche / B à droite, étiquette au centre, %, couleur selon récupérabilité (vert/orange/rouge), échelle normalisée. `_build_recoverability_summary_html` : tableau 3×2 avec pastilles colorées. Adaptive : "" si None ou pas de classes. +6 clés i18n FR/EN. +18 tests (calcul 7 cas dont sanité RECOVERABILITY couvre ERROR_CLASSES, rendu 7 cas, anti-injection, i18n). **Choix éditorial assumé** : classification recoverable/difficult/irrecoverable est un guide pragmatique, pas un verdict — note explicative dit « à CER égal, un moteur dont les erreurs sont majoritairement vertes est préférable pour une édition critique ». **A.I.4 livré bout-en-bout** (Sprints 75-77). |
 | 76 | **Sprint 45 du plan d'évolution 2026 — A.I.4 chantier 2 : évolution intra-document des classes taxonomiques (couche calcul + heatmap SVG)**. `line_metrics.py` (Sprint 10) avait déjà heatmap CER×position ; ce sprint l'étend à toutes les classes taxonomiques. Nouveau module `picarones/core/taxonomy_intra_doc.py` : `compute_taxonomy_position_heatmap(reference, hypothesis, n_bins=10)` calcule par classe le compte par tranche de position, réutilise classification mot-à-mot Sprint 5 en gardant `i1` (position GT) et binnifiant via `floor(i1/n_gt*n_bins)`. `_classify_word_pair` variante pure. `_bin_for_position` clip 0..n_bins-1. `ValueError` si n_bins≤0, `None` si GT vide. Nouveau module `picarones/report/taxonomy_intra_doc_render.py` : `build_taxonomy_intra_doc_html` produit heatmap SVG class×position avec gradient blanc→orange profond, densité relative au max de chaque classe (met en évidence les positions concentrées), filtrage classes avec ≥1 erreur, étiquettes positions/classes, accessible. Adaptive : `""` si None/no_errors/aucune classe avec erreurs. +3 clés i18n FR/EN. +16 tests (calcul 8 cas dont identité/début/fin/uniforme/breakdown, rendu 5 cas, anti-injection, complétude i18n). **Verrou levé** : un chercheur voit où chaque type d'erreur apparaît — distingue erreurs de marge (concentrées) vs scribe (uniformes). |
 | 75 | **Sprint 44 du plan d'évolution 2026 — A.I.4 chantier 1 : co-occurrence taxonomique (couche calcul + heatmap SVG)**. Premier des 3 chantiers d'A.I.4. Répond à « quelles classes d'erreur tendent à apparaître ensemble ? » — utile pour stratifier *a posteriori*. Nouveau module `picarones/core/taxonomy_cooccurrence.py` : `compute_taxonomy_cooccurrence(per_doc_classes, min_doc_count=1, top_n_pairs=10)` calcule l'indice de Jaccard entre paires de classes au niveau document (présence binaire), symétrique, diagonale=1.0, filtrage classes anecdotiques via min_doc_count, top_pairs triées Jaccard décroissant. Retourne None si vide. Nouveau module `picarones/report/taxonomy_cooccurrence_render.py` : `build_taxonomy_cooccurrence_html` produit titre + note + heatmap SVG + table top_pairs. `_build_heatmap_svg` server-side avec cellules colorées blanc→bleu profond, valeur affichée si >0.05, étiquettes rotées -45° en haut/normales à gauche, accessible (role/aria-label). Adaptive : "" si None ou matrice vide. +5 clés i18n FR/EN. +22 tests (calcul 11 cas dont toujours/jamais ensemble, diagonale, symétrie, chevauchement partiel, min_doc_count, top_pairs triées, none doc skipped ; rendu 7 cas ; anti-injection ; complétude i18n). **Verrou levé** : un chercheur voit d'un coup d'œil quelles classes d'erreur sont corrélées dans son corpus. |
 | 74 | **Sprint 43 du plan d'évolution 2026 — A.I.3 chantier 1 : encart HTML « Ce corpus est-il habituel ? » (clôture A.I.3)**. Suite directe Sprint 73 (couche calcul + détecteur narratif). Nouveau module `picarones/report/baseline_render.py` : `build_corpus_difficulty_baseline_html(percentile_data, historical_values, labels)` produit phrase factuelle + boxplot SVG, phrase template auto-sélectionnée selon harder_than_usual/easier_than_usual/usual flags. `_build_difficulty_boxplot_svg` server-side avec moustache min→max, boîte Q1→Q3, médiane, point courant **coloré adaptive** (bleu si <Q1 plus facile, rouge si >Q3 plus difficile, vert sinon habituel), étiquettes numériques, accessible (role/aria-label). Helper `_quantiles` méthode inclusive gère N=0/1. Adaptive : `""` si percentile_data None, boxplot omis si historical_values vide. +4 clés i18n FR/EN avec templates Python `{current:.2f}/{percentile:.0f}/{n_runs}`. +20 tests (quantiles 3 cas, SVG 8 cas dont couleurs/dégénéré, HTML 6 cas, anti-injection, complétude i18n). **Verrou levé** : un bench avec historique SQLite chargé voit en tête de rapport « ce corpus est plus difficile que la moyenne — au 88ᵉ percentile des 47 corpus précédents » avec boxplot. **A.I.3 livré bout-en-bout** (Sprint 73 calc+narrative + Sprint 74 vue HTML). |
@@ -294,7 +295,7 @@ au template `_narrative_summary.html` (placé entre `_header.html` et `_critical
 ## Contexte développement
 
 - **Environnement** : GitHub Codespaces (`/workspaces/Picarones`), Python 3.12
-- **Tests** : 2627 passed, 2 skipped (Sprints 32-34 = Phase 0 close ; Sprints 35-37 = inter-moteurs livrés bout-en-bout ; Sprints 38+40+41 = NER livré bout-en-bout ; Sprints 39+42+43 = calibration livrée bout-en-bout côté rapport ; Sprint 44 = médiane par défaut ; Sprints 45+46 = stratification A.III livrée bout-en-bout ; Sprints 47-51 = les 5 adapters OCR exposent leurs confidences natives ; **Étape 2 close** ; Sprints 52-54 = axe A.II.2 (métriques structurelles) couches de calcul intégralement livrées ; Sprints 55-62 = extension philologique livrée bout-en-bout sur trois périodes + numéraux romains transversaux + câblage runner adaptive + vue HTML « Profil philologique » ; Sprints 63-70 = axe B livré bout-en-bout ; Sprints 71-72 = A.I.1 livré bout-en-bout ; Sprints 73-74 = A.I.3 livré bout-en-bout ; **Sprints 75-76 = A.I.4 chantiers 1+2 — co-occurrence Jaccard + heatmap intra-document class×position**)
+- **Tests** : 2645 passed, 2 skipped (Sprints 32-34 = Phase 0 close ; Sprints 35-37 = inter-moteurs livrés bout-en-bout ; Sprints 38+40+41 = NER livré bout-en-bout ; Sprints 39+42+43 = calibration livrée bout-en-bout côté rapport ; Sprint 44 = médiane par défaut ; Sprints 45+46 = stratification A.III livrée bout-en-bout ; Sprints 47-51 = les 5 adapters OCR exposent leurs confidences natives ; **Étape 2 close** ; Sprints 52-54 = axe A.II.2 (métriques structurelles) couches de calcul intégralement livrées ; Sprints 55-62 = extension philologique livrée bout-en-bout sur trois périodes + numéraux romains transversaux + câblage runner adaptive + vue HTML « Profil philologique » ; Sprints 63-70 = axe B livré bout-en-bout ; Sprints 71-72 = A.I.1 livré bout-en-bout ; Sprints 73-74 = A.I.3 livré bout-en-bout ; **Sprints 75-77 = A.I.4 livré bout-en-bout — co-occurrence Jaccard + heatmap intra-document class×position + diagramme miroir comparatif inter-moteurs**)
 - **Plan d'évolution actif** : [`docs/roadmap/evolution-2026.md`](docs/roadmap/evolution-2026.md)
 - **Branche active** : `claude/analyze-project-evolution-KOA56`
 - **Transcript de la conversation de développement** :

picarones/core/taxonomy_comparison.py

@@ -0,0 +1,161 @@
+"""Taxonomie comparative entre deux moteurs — Sprint 77 (A.I.4 chantier 3).
+
+Sprint 77 — A.I.4 chantier 3 du plan d'évolution 2026 (clôture A.I.4).
+
+Pourquoi ce module
+------------------
+Le détecteur narratif ``error_profile_outlier`` (Sprint 19) signale
+qu'un moteur a un profil taxonomique éloigné de ses concurrents,
+mais le rapport n'expose pas cette différence visuellement.  Ce
+sprint répond à *« deux moteurs ont le même CER global, mais lequel
+fait des erreurs plus récupérables ? »*.
+
+Lecture concrète
+----------------
+- Moteur A : 80 % d'erreurs ``case_error`` → toutes corrigeables
+  par un post-processing trivial (récupérables).
+- Moteur B : 80 % d'erreurs ``lacuna`` (mots manquants) →
+  irrécupérables sans relire l'image.
+
+À CER égal, A est massivement préférable pour un workflow
+d'édition critique.  Cette vue rend la différence visible.
+
+Catégorisation des classes
+--------------------------
+On annote chaque classe d'erreur d'un degré de **récupérabilité**
+(critère éditorial pragmatique, pas verdict imposé) :
+
+- ``recoverable`` : récupérable par post-processing trivial
+  (case_error, ligature_error, abbreviation_error)
+- ``difficult`` : récupérable au prix d'un effort
+  (diacritic_error, visual_confusion, hapax)
+- ``irrecoverable`` : impossible à corriger sans l'image
+  (lacuna, oov_character, segmentation_error)
+
+L'utilisateur consulte ces catégories comme un guide, pas un
+verdict — c'est lui qui juge selon ses besoins éditoriaux.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+# Classification éditoriale.  Documentée dans la docstring.
+RECOVERABILITY: dict[str, str] = {
+    "case_error":         "recoverable",
+    "ligature_error":     "recoverable",
+    "abbreviation_error": "recoverable",
+    "diacritic_error":    "difficult",
+    "visual_confusion":   "difficult",
+    "hapax":              "difficult",
+    "lacuna":             "irrecoverable",
+    "oov_character":      "irrecoverable",
+    "segmentation_error": "irrecoverable",
+}
+
+
+def _normalize_counts(counts: dict[str, int]) -> dict[str, float]:
+    """Convertit un dict de comptes en proportions [0, 1]."""
+    total = sum(counts.values())
+    if total <= 0:
+        return {k: 0.0 for k in counts}
+    return {k: v / total for k, v in counts.items()}
+
+
+def compare_taxonomies(
+    engine_a_name: str,
+    engine_a_counts: dict[str, int],
+    engine_b_name: str,
+    engine_b_counts: dict[str, int],
+) -> Optional[dict]:
+    """Compare deux profils taxonomiques.
+
+    Parameters
+    ----------
+    engine_a_name, engine_b_name:
+        Noms d'identification des moteurs (utilisés dans le rendu).
+    engine_a_counts, engine_b_counts:
+        Maps ``{class_name: count}`` produites par
+        ``aggregate_taxonomy``.
+
+    Returns
+    -------
+    Optional[dict]
+        ``{
+            "engine_a": str, "engine_b": str,
+            "total_a": int, "total_b": int,
+            "classes": list[str],     # classes apparaissant chez A ou B
+            "proportions_a": dict[str, float],
+            "proportions_b": dict[str, float],
+            "deltas": dict[str, float],   # prop_b - prop_a (signé)
+            "recoverability": dict[str, str],  # mapping class → niveau
+            "totals_by_recoverability": {
+                "recoverable":   {"a": float, "b": float},
+                "difficult":     {"a": float, "b": float},
+                "irrecoverable": {"a": float, "b": float},
+            },
+        }``
+        Ou ``None`` si les deux moteurs ont 0 erreur chacun.
+    """
+    if engine_a_name == engine_b_name:
+        # On accepte des comparaisons même si les noms sont
+        # identiques (cas tests), mais on émet un warning.
+        logger.warning(
+            "[taxonomy_comparison] engine_a et engine_b ont le même nom : %s",
+            engine_a_name,
+        )
+
+    total_a = sum(engine_a_counts.values()) if engine_a_counts else 0
+    total_b = sum(engine_b_counts.values()) if engine_b_counts else 0
+    if total_a == 0 and total_b == 0:
+        return None
+
+    classes = sorted(set(engine_a_counts) | set(engine_b_counts))
+    if not classes:
+        return None
+
+    prop_a = _normalize_counts(
+        {c: engine_a_counts.get(c, 0) for c in classes},
+    )
+    prop_b = _normalize_counts(
+        {c: engine_b_counts.get(c, 0) for c in classes},
+    )
+    deltas = {c: prop_b[c] - prop_a[c] for c in classes}
+
+    # Agrégat par récupérabilité (utile pour la lecture rapide)
+    totals_recov: dict[str, dict[str, float]] = {
+        "recoverable":   {"a": 0.0, "b": 0.0},
+        "difficult":     {"a": 0.0, "b": 0.0},
+        "irrecoverable": {"a": 0.0, "b": 0.0},
+    }
+    for cls in classes:
+        level = RECOVERABILITY.get(cls, "difficult")
+        if level not in totals_recov:
+            level = "difficult"
+        totals_recov[level]["a"] += prop_a[cls]
+        totals_recov[level]["b"] += prop_b[cls]
+
+    return {
+        "engine_a": engine_a_name,
+        "engine_b": engine_b_name,
+        "total_a": total_a,
+        "total_b": total_b,
+        "classes": classes,
+        "proportions_a": prop_a,
+        "proportions_b": prop_b,
+        "deltas": deltas,
+        "recoverability": {
+            cls: RECOVERABILITY.get(cls, "difficult") for cls in classes
+        },
+        "totals_by_recoverability": totals_recov,
+    }
+
+
+__all__ = [
+    "RECOVERABILITY",
+    "compare_taxonomies",
+]

picarones/report/i18n/en.json

@@ -250,5 +250,11 @@
   "taxocooc_jaccard_label": "Jaccard",
   "intradoc_title": "Intra-document evolution of error classes",
   "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."
+  "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_level_label": "Category",
+  "taxocomp_recoverable": "Recoverable",
+  "taxocomp_difficult": "Difficult",
+  "taxocomp_irrecoverable": "Irrecoverable"
 }

picarones/report/i18n/fr.json

@@ -250,5 +250,11 @@
   "taxocooc_jaccard_label": "Jaccard",
   "intradoc_title": "Évolution intra-document des classes d'erreur",
   "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."
+  "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_level_label": "Catégorie",
+  "taxocomp_recoverable": "Récupérable",
+  "taxocomp_difficult": "Difficile",
+  "taxocomp_irrecoverable": "Irrécupérable"
 }

picarones/report/taxonomy_comparison_render.py

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

tests/test_sprint77_taxonomy_comparison.py

@@ -0,0 +1,215 @@
+"""Tests Sprint 77 — A.I.4 chantier 3 : taxonomie comparative.
+
+Couvre :
+
+1. ``compare_taxonomies`` :
+   - Proportions correctement normalisées (somme = 1)
+   - Deltas signés (b - a)
+   - Catégorisation par récupérabilité
+   - Cas dégénéré : deux comptes vides → None
+   - Classes apparaissant chez un seul moteur
+   - Totaux par récupérabilité
+2. Rendu HTML :
+   - Diagramme miroir SVG bien formé
+   - Tableau récupérabilité présent
+   - "" si data None
+   - "" si classes vides
+3. Anti-injection : noms moteurs avec ``<script>``.
+4. Complétude i18n FR/EN.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from picarones.core.taxonomy_comparison import (
+    RECOVERABILITY,
+    compare_taxonomies,
+)
+from picarones.report.taxonomy_comparison_render import (
+    build_taxonomy_comparison_html,
+)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 1. compare_taxonomies
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestCompare:
+    def test_proportions_sum_to_one(self) -> None:
+        result = compare_taxonomies(
+            "A", {"case_error": 8, "lacuna": 2},
+            "B", {"case_error": 1, "lacuna": 9},
+        )
+        assert result is not None
+        assert sum(result["proportions_a"].values()) == 1.0
+        assert sum(result["proportions_b"].values()) == 1.0
+
+    def test_deltas_signed(self) -> None:
+        result = compare_taxonomies(
+            "A", {"case_error": 8, "lacuna": 2},
+            "B", {"case_error": 2, "lacuna": 8},
+        )
+        # B a plus de lacuna, moins de case_error
+        assert result["deltas"]["lacuna"] > 0
+        assert result["deltas"]["case_error"] < 0
+
+    def test_recoverability_categorization(self) -> None:
+        result = compare_taxonomies(
+            "A", {"case_error": 10},   # 100% recoverable
+            "B", {"lacuna": 10},       # 100% irrecoverable
+        )
+        totals = result["totals_by_recoverability"]
+        assert totals["recoverable"]["a"] == 1.0
+        assert totals["irrecoverable"]["b"] == 1.0
+        assert totals["recoverable"]["b"] == 0.0
+        assert totals["irrecoverable"]["a"] == 0.0
+
+    def test_returns_none_when_both_empty(self) -> None:
+        assert compare_taxonomies("A", {}, "B", {}) is None
+        assert compare_taxonomies("A", {"case_error": 0}, "B", {}) is None
+
+    def test_class_in_only_one_engine(self) -> None:
+        result = compare_taxonomies(
+            "A", {"case_error": 5},
+            "B", {"lacuna": 5, "case_error": 5},
+        )
+        # case_error présent chez les deux
+        assert result["proportions_a"]["case_error"] == 1.0
+        assert result["proportions_a"]["lacuna"] == 0.0
+        assert result["proportions_b"]["lacuna"] == 0.5
+
+    def test_totals_a_and_b_correct(self) -> None:
+        result = compare_taxonomies(
+            "A", {"case_error": 7, "lacuna": 3},
+            "B", {"case_error": 2, "lacuna": 8},
+        )
+        assert result["total_a"] == 10
+        assert result["total_b"] == 10
+
+    def test_recoverability_constant_complete(self) -> None:
+        # Sanité : RECOVERABILITY couvre toutes les classes du module
+        from picarones.core.taxonomy import ERROR_CLASSES
+        for cls in ERROR_CLASSES:
+            assert cls in RECOVERABILITY
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 2. Rendu HTML
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestRender:
+    def test_returns_empty_when_none(self) -> None:
+        assert build_taxonomy_comparison_html(None) == ""
+
+    def test_renders_svg(self) -> None:
+        data = compare_taxonomies(
+            "Tesseract", {"case_error": 8, "lacuna": 2},
+            "Pero", {"case_error": 2, "lacuna": 8},
+        )
+        html = build_taxonomy_comparison_html(data)
+        assert "<svg" in html
+        assert "</svg>" in html
+
+    def test_engine_names_displayed(self) -> None:
+        data = compare_taxonomies(
+            "Tesseract", {"case_error": 5},
+            "Pero", {"lacuna": 5},
+        )
+        html = build_taxonomy_comparison_html(data)
+        assert "Tesseract" in html
+        assert "Pero" in html
+
+    def test_class_labels_present(self) -> None:
+        data = compare_taxonomies(
+            "A", {"case_error": 5},
+            "B", {"lacuna": 5},
+        )
+        html = build_taxonomy_comparison_html(data)
+        assert "case_error" in html
+        assert "lacuna" in html
+
+    def test_recoverability_summary_present(self) -> None:
+        data = compare_taxonomies(
+            "A", {"case_error": 5},
+            "B", {"lacuna": 5},
+        )
+        html = build_taxonomy_comparison_html(data)
+        assert "Récupérable" in html
+        assert "Irrécupérable" in html
+
+    def test_proportions_displayed(self) -> None:
+        data = compare_taxonomies(
+            "A", {"case_error": 8, "lacuna": 2},
+            "B", {"case_error": 2, "lacuna": 8},
+        )
+        html = build_taxonomy_comparison_html(data)
+        # 80.0% présent dans le SVG (proportion case_error de A)
+        assert "80.0%" in html
+
+    def test_color_codes_present(self) -> None:
+        data = compare_taxonomies(
+            "A", {"case_error": 5},  # recoverable → vert
+            "B", {"lacuna": 5},      # irrecoverable → rouge
+        )
+        html = build_taxonomy_comparison_html(data)
+        assert "#5fa860" in html  # vert
+        assert "#d8553b" in html  # rouge
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 3. Anti-injection
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestAntiInjection:
+    def test_engine_name_escaped(self) -> None:
+        data = compare_taxonomies(
+            "<script>alert(1)</script>", {"case_error": 5},
+            "Pero", {"lacuna": 5},
+        )
+        html = build_taxonomy_comparison_html(data)
+        assert "<script>alert" not in html
+        assert "&lt;script&gt;" in html
+
+    def test_label_via_i18n_escaped(self) -> None:
+        data = compare_taxonomies(
+            "A", {"case_error": 5}, "B", {"lacuna": 5},
+        )
+        labels = {"taxocomp_recoverable": "<b>Hack</b>"}
+        html = build_taxonomy_comparison_html(data, labels=labels)
+        assert "<b>Hack</b>" not in html
+        assert "&lt;b&gt;Hack&lt;/b&gt;" in html
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 4. Complétude i18n
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestI18nCompleteness:
+    def _load(self, lang: str) -> dict:
+        path = (
+            Path(__file__).parent.parent
+            / "picarones" / "report" / "i18n" / f"{lang}.json"
+        )
+        return json.loads(path.read_text(encoding="utf-8"))
+
+    def test_all_keys_fr(self) -> None:
+        d = self._load("fr")
+        for key in (
+            "taxocomp_title", "taxocomp_note", "taxocomp_level_label",
+            "taxocomp_recoverable", "taxocomp_difficult",
+            "taxocomp_irrecoverable",
+        ):
+            assert key in d, f"manque clé FR : {key}"
+
+    def test_all_keys_en(self) -> None:
+        d_fr = self._load("fr")
+        d_en = self._load("en")
+        for key in d_fr:
+            if key.startswith("taxocomp_"):
+                assert key in d_en, f"manque clé EN : {key}"