sprint89: A.II.8b score de spécialisation inter-moteurs (calcul + HTML)

La matrice de divergence taxonomique (Sprint 35) répondait à
"à quel point ces moteurs se trompent-ils différemment ?".
Ce sprint transforme cette information en un score lisible
et un top-N des paires les plus spécialisées.

Le module ne recommande PAS d'ensemble — observation factuelle.

picarones/core/specialization.py :
- compute_specialization_score : délégué à JS divergence Sprint 35.
- classify_specialization : similar < 0.10, distinct 0.10-0.30,
highly_specialized ≥ 0.30 (seuils éditoriaux surchargeables).
- compute_specialization_matrix : symétrique + max_pair.
- top_specialized_pairs : tri décroissant, n cap, min_score filter.

picarones/report/specialization_render.py : tableau
Moteur A × Moteur B × Score (gradient blanc → bleu profond)
× Lecture (libellé i18n). Adaptive : "" si < 2 moteurs.

Câblage generator : lit aggregated_taxonomy de chaque moteur,
construit la map {engine: counts}. Insertion view_analyses.html.

9 clés i18n FR/EN. 24 tests dans test_sprint89_specialization.py
couvrant symétrie + bornes [0,1], classify 5 cas dont custom,
matrice diagonale 0 + max_pair, top_pairs tri/n/min_score/None,
rendu adaptive + anti-injection + FR/EN, complétude i18n 9 clés.

Tests : 2923 passed, 2 skipped.

https://claude.ai/code/session_01RusTQYcSfXqTsbFNvwmCV7

CHANGELOG.md

@@ -16,6 +16,50 @@ La numérotation de version suit [Semantic Versioning](https://semver.org/lang/f
 
 ### Ajouté
 
+- **Sprint 89 — A.II.8b : score de spécialisation inter-moteurs
+  (couche calcul + vue HTML).**  La matrice de divergence
+  taxonomique (Sprint 35) répondait à *« à quel point ces
+  moteurs se trompent-ils différemment ? »* ; ce sprint
+  transforme cette information en un score lisible et un
+  **top-N des paires les plus spécialisées**, qui répond
+  directement à la question *« quels moteurs sont des candidats
+  pour un voting ensemble ? »*.  Le module **ne recommande
+  pas** d'ensemble — il livre l'observation factuelle et
+  laisse le chercheur arbitrer.  Nouveau module
+  `picarones/core/specialization.py` :
+  `compute_specialization_score(taxonomy_a, taxonomy_b)`
+  retourne un score normalisé ∈ [0, 1] (délégué à
+  `inter_engine.jensen_shannon_divergence` Sprint 35, pas de
+  double calcul) ;
+  `classify_specialization(score, thresholds=DEFAULT_THRESHOLDS)`
+  classe en `similar` (< 0,10) / `distinct` (0,10–0,30) /
+  `highly_specialized` (≥ 0,30) — seuils éditoriaux pas
+  verdict, surchargeables ;
+  `compute_specialization_matrix(taxonomies)` retourne une
+  matrice symétrique avec `max_pair` ;
+  `top_specialized_pairs(matrix, n=5, min_score=0)` retourne
+  les paires triées par score décroissant avec leur catégorie.
+  Nouveau module `picarones/report/specialization_render.py` :
+  `build_specialization_html(taxonomies, labels, top_n=5)`
+  rend un tableau Moteur A × Moteur B × Score (gradient blanc
+  → bleu profond) × Lecture (libellé i18n).  Adaptive : `""`
+  si moins de 2 moteurs avec taxonomie.  Anti-injection.
+  Câblage générator : lit les `aggregated_taxonomy` exposés
+  sur les moteurs (Sprint 5/runner historique), construit la
+  map `{engine: counts}` et passe au renderer.  Insertion dans
+  `view_analyses.html` derrière la lisibilité.  +9 clés i18n
+  FR/EN (`specialization_*`).  +24 tests dans
+  `test_sprint89_specialization.py` (score symétrique +
+  identité 0 + disjoint 1 + bornes [0,1], classify 5 cas dont
+  custom thresholds, matrice diagonale 0 + symétrique +
+  max_pair correctement identifié, top_pairs tri/n/min_score/
+  None, rendu adaptive + anti-injection + FR/EN, complétude
+  i18n 9 clés).  **Verrou levé** : un benchmark BnF avec ≥ 2
+  moteurs voit immédiatement *« tess et pero ont une
+  spécialisation forte (0,489) — ils font des erreurs de
+  natures différentes »* — observation factuelle, le
+  chercheur arbitre.
+
 - **Sprint 88 — A.I.8 vue HTML : déficit projeté de robustesse
   (clôture A.I.8 bout-en-bout).**  Le module
   `picarones/core/robustness_projection.py` (Sprint 81)

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). |
+| 89 | **Sprint 58 du plan d'évolution 2026 — A.II.8b : score de spécialisation inter-moteurs (couche calcul + vue HTML)**. La matrice de divergence taxonomique (Sprint 35) répondait à *« à quel point ces moteurs se trompent-ils différemment ? »* ; ce sprint transforme cette information en un score lisible et un **top-N des paires les plus spécialisées**, qui répond directement à la question *« quels moteurs sont des candidats pour un voting ensemble ? »*. Le module **ne recommande pas** d'ensemble — observation factuelle, le chercheur arbitre. Nouveau module `picarones/core/specialization.py` : `compute_specialization_score(taxonomy_a, taxonomy_b)` retourne un score normalisé ∈ [0, 1] (délégué à `inter_engine.jensen_shannon_divergence` Sprint 35, pas de double calcul) ; `classify_specialization(score)` classe en `similar` (< 0,10) / `distinct` (0,10–0,30) / `highly_specialized` (≥ 0,30) — seuils éditoriaux pas verdict, surchargeables ; `compute_specialization_matrix(taxonomies)` retourne matrice symétrique avec `max_pair` ; `top_specialized_pairs(matrix, n=5, min_score=0)` retourne paires triées par score décroissant + catégorie. Nouveau module `picarones/report/specialization_render.py` : `build_specialization_html` rend tableau Moteur A × Moteur B × Score (gradient blanc → bleu profond) × Lecture (libellé i18n). Adaptive : `""` si < 2 moteurs avec taxonomie. Anti-injection. Câblage générator : lit `aggregated_taxonomy` exposés sur les moteurs (Sprint 5/runner historique), construit map `{engine: counts}`. Insertion `view_analyses.html` derrière la lisibilité. +9 clés i18n FR/EN (`specialization_*`). +24 tests dans `test_sprint89_specialization.py` (score symétrique + identité 0 + disjoint 1 + bornes [0,1], classify 5 cas dont custom thresholds, matrice diagonale 0 + symétrique + max_pair correctement identifié, top_pairs tri/n/min_score/None, rendu adaptive + anti-injection + FR/EN, complétude i18n 9 clés). **Verrou levé** : un benchmark BnF avec ≥ 2 moteurs voit immédiatement *« tess et pero ont une spécialisation forte (0,489) — ils font des erreurs de natures différentes »* — observation factuelle. |
 | 88 | **Sprint 57 du plan d'évolution 2026 — A.I.8 vue HTML : déficit projeté de robustesse (clôture A.I.8 bout-en-bout)**. Le module `picarones/core/robustness_projection.py` (Sprint 81) calculait la projection des courbes de dégradation synthétique sur les caractéristiques d'image réelles ; ce sprint livre la **vue HTML**. La robustesse étant un workflow CLI séparé (`picarones robustness`) et non intégré au benchmark principal, ce sprint livre un **module de rendu pur** que l'utilisateur compose lui-même (`analyze_robustness` → `project_robustness_on_corpus` → `aggregate_projection_per_engine` → `build_robustness_projection_html`). Nouveau module `picarones/report/robustness_projection_render.py` : **deux tableaux** — (1) **Résumé par moteur** (déficit total avec gradient vert→orange→rouge sur ±5 pts, n types évalués, pire dégradation avec sa contribution, trié par déficit décroissant) ; (2) **Détail (moteur × dégradation)** (docs, docs avec data, déficit projeté coloré, docs au-dessus du seuil critique). Si `aggregated` non fourni, calculé automatiquement. Adaptive : `""` si projection vide. Anti-injection systématique. Note explicite que la sommation suppose l'indépendance des dégradations *« approximation utile pour le diagnostic, pas un verdict »*. +13 clés i18n FR/EN (`robproj_*`). +12 tests dans `test_sprint88_robustness_projection_html.py` (rendu vide/None, rendu complet, calcul automatique de l'agrégation, tri par déficit décroissant, formatage « pire dégradation », gestion déficit None → cellule —, anti-injection nom moteur + type dégradation, rendu FR + EN, **bout-en-bout** avec le pipeline réel `project_robustness_on_corpus` + `aggregate_projection_per_engine`, complétude i18n 13 clés). **Verrou levé** : A.I.8 livrée bout-en-bout (calcul Sprint 81 + vue HTML Sprint 88) — un benchmark BnF qui veut savoir *« mon corpus de notaires XVIIᵉ siècle est-il à risque face à mon moteur OCR ? »* obtient un tableau lisible directement intégrable dans le rapport. |
 | 87 | **Sprint 56 du plan d'évolution 2026 — A.II.2 (delta Flesch) câblé bout-en-bout : runner adaptive + vue HTML « Lisibilité »**. Le module `picarones/core/readability.py` (Sprint 52) calculait le delta Flesch *« over-normalisation par LLM »* — ce sprint le remonte automatiquement dans le rapport. Helper `picarones/core/readability_runner.py` : `compute_readability_metrics(reference, hypothesis, lang)` avec **adaptive masking ≥ 5 mots GT** (Flesch instable sur très courts textes) ; `aggregate_readability_metrics` retourne `{lang, n_docs, n_docs_with_delta, delta_mean/median/min/max, n_over_normalized, n_under_normalized, over_normalized_rate}` — over-norm défini à Δ > +5 (LLM modernise un texte ancien), under-norm à Δ < -5 (dégradation OCR brutale). `DocumentResult.readability_metrics` + `EngineReport.aggregated_readability` (sérialisation conditionnelle, libérés par `compact`). Câblage runner : langue lue depuis `corpus.metadata.get("language", "fr")`, fallback fr avec warning si valeur non `fr`/`en`, paramètre `corpus_lang` propagé jusqu'aux workers IO et CPU (workers acceptent 7 ou 8 args en mode legacy pour rétrocompat). Erreur isolée par try/except + warning. Module de rendu `picarones/report/readability_render.py` : tableau résumé moteur × {Δ moyen coloré (vert au centre, orange si over-norm, bleu si under-norm), Δ médian, % over-normalisés, docs under-normalisés, docs} ; saturation à ±15 points. Insertion dans `view_analyses.html` derrière les blocs A.II.5. Anti-injection systématique. +8 clés i18n FR/EN. +20 tests dans `test_sprint87_readability_html.py` (adaptive masking GT < 5 mots, langue fr/en, hypothèse vide → flesch_delta None mais flesch_reference conservé, agrégation moyenne + over-norm rate, sérialisation `DocumentResult`/`EngineReport`, `compact`, masquage adaptatif HTML, rendu FR + EN, anti-injection, complétude i18n 8 clés). **Verrou levé** : le rapport remonte désormais *« GPT-4o : Δ moyen +11,5, 85 % des docs over-normalisés »* directement dans la vue Analyses — métrique critique pour repérer les VLM hallucinant du français moderne sur du français médiéval. Reste pour A.II.2 bout-en-bout : `reading_order_f1` et `layout_f1` (Sprints 53-54), qui requièrent un moteur produisant PAGE/ALTO et seront câblés via les pipelines composées (axe B). |
 | 86 | **Sprint 55 du plan d'évolution 2026 — A.II.5 : câblage runner adaptive + vues HTML (clôture A.II.5 bout-en-bout)**. Suite directe Sprints 84+85 — la couche de calcul livrait deux modules pour le mode plein-texte patrimonial, ce sprint les remonte automatiquement dans le rapport. Deux helpers `picarones/core/searchability_runner.py` et `picarones/core/numerical_sequences_runner.py` calculent les métriques par document avec **adaptive masking** (rien n'apparaît pour un doc sans GT exploitable) et agrègent corpus-wide en *micro*-rappel pour searchability et somme par catégorie pour les séquences numériques. `DocumentResult` gagne `searchability_metrics` + `numerical_sequence_metrics` ; `EngineReport` gagne `aggregated_searchability` + `aggregated_numerical_sequences` (sérialisation conditionnelle, libérés par `compact`). Le runner historique calcule les deux inconditionnellement (coût négligeable face à l'OCR), erreur isolée par try/except + warning explicite, rétrocompat stricte. Deux modules de rendu `picarones/report/searchability_render.py` (tableau résumé moteur × {rappel coloré rouge→jaune→vert, retrouvés/total, docs}) et `picarones/report/numerical_sequences_render.py` (tableau moteur × catégorie {year/roman/foliation/currency/regnal} avec **adaptive masking par catégorie** — une catégorie sans signal est omise pour tous les moteurs ; chaque cellule affiche le score strict en gradient + la valeur entre parenthèses + n). Insertion dans `view_analyses.html` derrière le profil philologique, `chart-card` pleine largeur conditionné. Anti-injection systématique. +15 clés i18n FR/EN (`search_*`, `numseq_*`). +25 tests dans `test_sprint86_aii5_html.py` (adaptive masking helpers, agrégation micro-rappel, somme par catégorie, sérialisation `DocumentResult`/`EngineReport`, `compact` qui efface, masquage adaptatif HTML, rendu FR + EN, anti-injection sur nom moteur, complétude i18n 15 clés). **Verrou levé** : un benchmark BnF voit désormais sur la vue Analyses *« Recherchabilité fuzzy : tess 95,2 %, pero 87,8 % »* + le tableau séquences numériques détaillé par catégorie — A.II.5 livrée bout-en-bout (calcul Sprints 84-85, runner et HTML Sprint 86). |
@@ -306,7 +307,7 @@ au template `_narrative_summary.html` (placé entre `_header.html` et `_critical
 ## Contexte développement
 
 - **Environnement** : GitHub Codespaces (`/workspaces/Picarones`), Python 3.12
-- **Tests** : 2899 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 ; Sprint 78 = A.I.5 couche calcul ; Sprint 79 = A.I.6 couche calcul ; Sprint 80 = A.I.7 ; Sprint 81 = A.I.8 couche calcul ; Sprint 82 = A.I.9 — « Leviers d'amélioration » bout-en-bout ; Sprint 83 = A.II.4 — métriques de fiabilité (IAA Cohen κ + Krippendorff α + stabilité multi-runs, couche calcul) ; Sprint 84 = A.II.5a — recherchabilité fuzzy ; Sprint 85 = A.II.5b — précision séquences numériques ; Sprint 86 = A.II.5 bout-en-bout (câblage runner + vues HTML) ; Sprint 87 = A.II.2 (delta Flesch) câblé bout-en-bout ; **Sprint 88 = A.I.8 — vue HTML « Déficit projeté de robustesse » bout-en-bout**)
+- **Tests** : 2923 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 ; Sprint 78 = A.I.5 couche calcul ; Sprint 79 = A.I.6 couche calcul ; Sprint 80 = A.I.7 ; Sprint 81 = A.I.8 couche calcul ; Sprint 82 = A.I.9 — « Leviers d'amélioration » bout-en-bout ; Sprint 83 = A.II.4 — métriques de fiabilité (IAA Cohen κ + Krippendorff α + stabilité multi-runs, couche calcul) ; Sprint 84 = A.II.5a — recherchabilité fuzzy ; Sprint 85 = A.II.5b — précision séquences numériques ; Sprint 86 = A.II.5 bout-en-bout (câblage runner + vues HTML) ; Sprint 87 = A.II.2 (delta Flesch) câblé bout-en-bout ; Sprint 88 = A.I.8 — vue HTML « Déficit projeté de robustesse » bout-en-bout ; **Sprint 89 = A.II.8b — score de spécialisation inter-moteurs (couche calcul + vue HTML « Top paires spécialisées »)**)
 - **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/specialization.py

@@ -0,0 +1,187 @@
+"""Score de spécialisation inter-moteurs — Sprint 89 (A.II.8b).
+
+Sprint 89 — A.II.8b du plan d'évolution 2026.
+
+Pourquoi ce module
+------------------
+La matrice de divergence taxonomique (Sprint 35
+``inter_engine.taxonomy_divergence_matrix``) répond à *« à quel
+point ces moteurs se trompent-ils différemment ? »*.  Ce
+sprint la transforme en un **score de spécialisation** lisible
+et complète la lecture par :
+
+- une **classification** discrète (similar / distinct /
+  highly_specialized) que le chercheur peut consommer sans
+  avoir à interpréter une distance ;
+- un **top-N des paires** les plus spécialisées, qui répond
+  directement à la question *« quels moteurs sont les meilleurs
+  candidats pour un voting ensemble ? »*.
+
+Ce module **ne recommande pas** de pipeline d'ensemble — il
+fournit l'observation factuelle et laisse le chercheur arbitrer.
+
+Convention de score
+-------------------
+On utilise la **Jensen-Shannon divergence** déjà calculée par
+``inter_engine.jensen_shannon_divergence`` : elle est
+symétrique, bornée dans [0, 1], et son interprétation est
+intuitive :
+
+- ≈ 0 → profils taxonomiques identiques
+- 1 → distributions totalement disjointes
+
+Dépendances
+-----------
+S'appuie strictement sur ``picarones.core.inter_engine`` (Sprint
+35) — pas de double calcul, pas de logique nouvelle de
+divergence.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from picarones.core.inter_engine import jensen_shannon_divergence
+
+logger = logging.getLogger(__name__)
+
+
+# Seuils par convention éditoriale.  La roadmap ne fixe rien :
+# ces seuils sont des **guides de lecture**, pas des verdicts.
+# Le chercheur peut les surcharger via ``classify_specialization``.
+DEFAULT_THRESHOLDS = (
+    ("similar", 0.10),
+    ("distinct", 0.30),
+    ("highly_specialized", 1.01),  # tout score ≥ 0.30
+)
+
+
+def compute_specialization_score(
+    taxonomy_a: dict[str, float],
+    taxonomy_b: dict[str, float],
+) -> float:
+    """Score de spécialisation entre deux moteurs ∈ [0, 1].
+
+    0 = mêmes erreurs, 1 = erreurs totalement disjointes.
+    Délègue à ``jensen_shannon_divergence`` (Sprint 35).
+    """
+    return jensen_shannon_divergence(taxonomy_a, taxonomy_b)
+
+
+def classify_specialization(
+    score: float,
+    thresholds: Optional[tuple[tuple[str, float], ...]] = None,
+) -> str:
+    """Classe le score en catégorie discrète.
+
+    Convention :
+    - score < 0.10 → ``similar``
+    - 0.10 ≤ score < 0.30 → ``distinct``
+    - score ≥ 0.30 → ``highly_specialized``
+
+    L'utilisateur peut passer ses propres ``thresholds`` (liste
+    triée par valeur croissante de tuples ``(label, max_score)``).
+    """
+    rules = thresholds or DEFAULT_THRESHOLDS
+    for label, max_score in rules:
+        if score < max_score:
+            return label
+    # Garde-fou : si aucun seuil ne match, dernière catégorie
+    return rules[-1][0]
+
+
+def compute_specialization_matrix(
+    taxonomies: dict[str, dict[str, float]],
+) -> Optional[dict]:
+    """Matrice de spécialisation symétrique entre tous les moteurs.
+
+    Parameters
+    ----------
+    taxonomies:
+        Map ``{engine_name: {error_class: count_or_proportion}}``.
+
+    Returns
+    -------
+    dict | None
+        ``{
+            "engines": list[str],
+            "matrix": list[list[float]],       # carrée, symétrique
+            "n_pairs": int,                     # paires distinctes
+            "max_score": float,
+            "max_pair": (str, str) | None,
+        }`` ; ``None`` si moins de 2 moteurs.
+    """
+    if not taxonomies or len(taxonomies) < 2:
+        return None
+    engines = sorted(taxonomies.keys())
+    n = len(engines)
+    matrix = [[0.0] * n for _ in range(n)]
+    n_pairs = 0
+    max_score = 0.0
+    max_pair: Optional[tuple[str, str]] = None
+    for i in range(n):
+        for j in range(i + 1, n):
+            score = compute_specialization_score(
+                taxonomies[engines[i]], taxonomies[engines[j]],
+            )
+            matrix[i][j] = score
+            matrix[j][i] = score
+            n_pairs += 1
+            if score > max_score:
+                max_score = score
+                max_pair = (engines[i], engines[j])
+    return {
+        "engines": engines,
+        "matrix": matrix,
+        "n_pairs": n_pairs,
+        "max_score": max_score,
+        "max_pair": max_pair,
+    }
+
+
+def top_specialized_pairs(
+    matrix_data: Optional[dict],
+    n: int = 5,
+    *,
+    min_score: float = 0.0,
+) -> list[dict]:
+    """Top-N paires de moteurs triées par score décroissant.
+
+    Returns
+    -------
+    list[dict]
+        Une liste de ``{
+            "engine_a": str, "engine_b": str,
+            "score": float, "category": str,
+        }`` triée par score décroissant.  Liste vide si
+        ``matrix_data`` est ``None`` ou que toutes les paires
+        sont sous ``min_score``.
+    """
+    if not matrix_data:
+        return []
+    engines = matrix_data["engines"]
+    matrix = matrix_data["matrix"]
+    pairs: list[dict] = []
+    for i, engine_a in enumerate(engines):
+        for j in range(i + 1, len(engines)):
+            score = matrix[i][j]
+            if score < min_score:
+                continue
+            pairs.append({
+                "engine_a": engine_a,
+                "engine_b": engines[j],
+                "score": score,
+                "category": classify_specialization(score),
+            })
+    pairs.sort(key=lambda p: -p["score"])
+    return pairs[:n]
+
+
+__all__ = [
+    "DEFAULT_THRESHOLDS",
+    "compute_specialization_score",
+    "classify_specialization",
+    "compute_specialization_matrix",
+    "top_specialized_pairs",
+]

picarones/report/generator.py

@@ -819,6 +819,28 @@ class ReportGenerator:
             report_data.get("engines", []), labels=labels,
         )
 
+        # Sprint 89 — A.II.8b : spécialisation inter-moteurs.
+        # Adaptive : "" si moins de 2 moteurs avec taxonomie.
+        from picarones.report.specialization_render import (
+            build_specialization_html,
+        )
+        # Construit une map {engine: counts} depuis les
+        # ``aggregated_taxonomy`` ; un moteur sans taxonomie
+        # est exclu.
+        _taxos: dict = {}
+        for eng in report_data.get("engines", []):
+            tax = eng.get("aggregated_taxonomy")
+            if isinstance(tax, dict):
+                counts = tax.get("counts") if "counts" in tax else tax
+                if isinstance(counts, dict) and counts:
+                    _taxos[eng.get("name", "?")] = {
+                        k: float(v) for k, v in counts.items()
+                        if isinstance(v, (int, float))
+                    }
+        specialization_html = build_specialization_html(
+            _taxos, labels=labels,
+        )
+
         env = _build_jinja_env()
         template = env.get_template("base.html.j2")
         html = template.render(
@@ -843,6 +865,7 @@ class ReportGenerator:
             searchability_html=searchability_html,
             numerical_sequences_html=numerical_sequences_html,
             readability_html=readability_html,
+            specialization_html=specialization_html,
         )
 
         output_path.write_text(html, encoding="utf-8")

picarones/report/i18n/en.json

@@ -316,5 +316,14 @@
   "robproj_n_docs": "Docs",
   "robproj_n_with_data": "Docs with data",
   "robproj_deficit": "Projected ΔCER (pts)",
-  "robproj_above": "Docs ≥ critical threshold"
+  "robproj_above": "Docs ≥ critical threshold",
+  "specialization_title": "Inter-engine specialisation",
+  "specialization_note": "Jensen-Shannon divergence between the taxonomic profiles of each pair of engines (0 = identical profiles, 1 = fully disjoint). A highly specialised pair signals error categories of different natures — it is for the researcher to act on it, not for the tool to prescribe an ensemble.",
+  "specialization_engine_a": "Engine A",
+  "specialization_engine_b": "Engine B",
+  "specialization_score": "Score",
+  "specialization_category": "Reading",
+  "specialization_cat_similar": "Similar profiles",
+  "specialization_cat_distinct": "Distinct profiles",
+  "specialization_cat_highly_specialized": "Highly specialised"
 }

picarones/report/i18n/fr.json

@@ -316,5 +316,14 @@
   "robproj_n_docs": "Docs",
   "robproj_n_with_data": "Docs avec data",
   "robproj_deficit": "Δ CER projeté (pts)",
-  "robproj_above": "Docs ≥ seuil critique"
+  "robproj_above": "Docs ≥ seuil critique",
+  "specialization_title": "Spécialisation inter-moteurs",
+  "specialization_note": "Score de divergence Jensen-Shannon entre les profils taxonomiques de chaque paire de moteurs (0 = profils identiques, 1 = totalement disjoints). Une paire très spécialisée signale des erreurs de natures différentes — c'est au chercheur d'en tirer parti, pas à l'outil de prescrire un ensemble.",
+  "specialization_engine_a": "Moteur A",
+  "specialization_engine_b": "Moteur B",
+  "specialization_score": "Score",
+  "specialization_category": "Lecture",
+  "specialization_cat_similar": "Profils similaires",
+  "specialization_cat_distinct": "Profils distincts",
+  "specialization_cat_highly_specialized": "Forte spécialisation"
 }

picarones/report/specialization_render.py

@@ -0,0 +1,118 @@
+"""Rendu HTML « Spécialisation inter-moteurs » — Sprint 89
+(A.II.8b).
+
+Suite directe ``picarones/core/specialization.py``.  Vue
+**factuelle** sans recommandation : on liste les paires de
+moteurs les plus spécialisées, le chercheur arbitre.
+
+Pattern identique aux autres rendus : server-side, pas de JS,
+anti-injection systématique.
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+from picarones.core.specialization import (
+    compute_specialization_matrix,
+    top_specialized_pairs,
+)
+
+
+def _color_for_score(score: float) -> str:
+    """Gradient blanc → bleu profond."""
+    f = max(0.0, min(1.0, score))
+    r = int(255 + (50 - 255) * f)
+    g = int(255 + (110 - 255) * f)
+    b = int(255 + (180 - 255) * f)
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+def _category_label(cat: str, labels: dict[str, str]) -> str:
+    return labels.get(f"specialization_cat_{cat}", cat)
+
+
+def build_specialization_html(
+    taxonomies: Optional[dict[str, dict[str, float]]],
+    labels: Optional[dict[str, str]] = None,
+    *,
+    top_n: int = 5,
+) -> str:
+    """Construit la vue HTML de spécialisation inter-moteurs.
+
+    Parameters
+    ----------
+    taxonomies:
+        Map ``{engine: {error_class: count}}``.  Si ``None`` ou
+        moins de 2 moteurs, retourne ``""``.
+    labels:
+        Dict i18n.  Clés sous le préfixe ``specialization_*``.
+    top_n:
+        Nombre de paires à afficher (défaut 5).
+    """
+    if not taxonomies or len(taxonomies) < 2:
+        return ""
+    matrix_data = compute_specialization_matrix(taxonomies)
+    if not matrix_data:
+        return ""
+    pairs = top_specialized_pairs(matrix_data, n=top_n)
+    if not pairs:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "specialization_title", "Spécialisation inter-moteurs",
+    )
+    note = labels.get(
+        "specialization_note",
+        "Score de divergence Jensen-Shannon entre les profils "
+        "taxonomiques de chaque paire de moteurs (0 = profils "
+        "identiques, 1 = totalement disjoints). Une paire très "
+        "spécialisée signale des erreurs de natures différentes "
+        "— c'est au chercheur d'en tirer parti, pas à l'outil "
+        "de prescrire un ensemble.",
+    )
+    h_a = labels.get("specialization_engine_a", "Moteur A")
+    h_b = labels.get("specialization_engine_b", "Moteur B")
+    h_score = labels.get("specialization_score", "Score")
+    h_cat = labels.get("specialization_category", "Lecture")
+
+    parts = [
+        '<section class="specialization-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>',
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.9rem">',
+        '<thead><tr>',
+    ]
+    for col in (h_a, h_b, h_score, h_cat):
+        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 pair in pairs:
+        score = float(pair.get("score") or 0.0)
+        cat = pair.get("category") or "?"
+        color = _color_for_score(score)
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.4rem .6rem">'
+            f'{_e(str(pair.get("engine_a", "?")))}</td>'
+            f'<td style="padding:.4rem .6rem">'
+            f'{_e(str(pair.get("engine_b", "?")))}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'background:{color};font-family:monospace;font-weight:600">'
+            f'{score:.3f}</td>'
+            f'<td style="padding:.4rem .6rem">'
+            f'{_e(_category_label(cat, labels))}</td>'
+            f'</tr>'
+        )
+    parts.append("</tbody></table></section>")
+    return "".join(parts)
+
+
+__all__ = ["build_specialization_html"]

picarones/report/templates/view_analyses.html

@@ -231,6 +231,14 @@
     </div>
     {% endif %}
 
+    <!-- Sprint 89 — A.II.8b : spécialisation inter-moteurs.
+         Adaptive : n'apparaît que si ≥ 2 moteurs avec taxonomie. -->
+    {% if specialization_html %}
+    <div class="chart-card" style="grid-column:1/-1">
+      {{ specialization_html }}
+    </div>
+    {% endif %}
+
     <!-- Sprint 37 — Analyse inter-moteurs (divergence taxonomique + oracle gap) -->
     {% if divergence_matrix_html or oracle_gap_html %}
     <div class="chart-card" style="grid-column:1/-1">

tests/test_sprint89_specialization.py

@@ -0,0 +1,233 @@
+"""Tests Sprint 89 — A.II.8b : spécialisation inter-moteurs.
+
+Couvre :
+
+1. ``compute_specialization_score`` : symétrie, plage [0, 1].
+2. ``classify_specialization`` : seuils par défaut + custom.
+3. ``compute_specialization_matrix`` : structure, symétrie, max_pair.
+4. ``top_specialized_pairs`` : tri, n, min_score.
+5. Vue HTML : adaptive, anti-injection, FR + EN.
+6. Complétude i18n FR/EN.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from picarones.core.specialization import (
+    DEFAULT_THRESHOLDS,
+    classify_specialization,
+    compute_specialization_matrix,
+    compute_specialization_score,
+    top_specialized_pairs,
+)
+from picarones.report.specialization_render import (
+    build_specialization_html,
+)
+
+
+def _load_labels(lang: str) -> dict:
+    p = (
+        Path(__file__).parent.parent
+        / "picarones" / "report" / "i18n" / f"{lang}.json"
+    )
+    return json.loads(p.read_text(encoding="utf-8"))
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 1. compute_specialization_score
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestScore:
+    def test_identical_profiles_zero(self) -> None:
+        tax = {"a": 50, "b": 50}
+        assert compute_specialization_score(tax, tax) < 0.001
+
+    def test_disjoint_profiles_one(self) -> None:
+        tax_a = {"a": 100}
+        tax_b = {"b": 100}
+        assert compute_specialization_score(tax_a, tax_b) > 0.95
+
+    def test_symmetric(self) -> None:
+        a = {"x": 70, "y": 30}
+        b = {"x": 20, "y": 80}
+        s_ab = compute_specialization_score(a, b)
+        s_ba = compute_specialization_score(b, a)
+        assert abs(s_ab - s_ba) < 1e-9
+
+    def test_bounded_zero_one(self) -> None:
+        a = {"x": 1, "y": 0, "z": 0}
+        b = {"x": 0, "y": 0, "z": 1}
+        score = compute_specialization_score(a, b)
+        assert 0.0 <= score <= 1.0
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 2. classify_specialization
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestClassify:
+    def test_below_similar_threshold(self) -> None:
+        assert classify_specialization(0.05) == "similar"
+
+    def test_distinct_band(self) -> None:
+        assert classify_specialization(0.20) == "distinct"
+
+    def test_highly_specialized_above(self) -> None:
+        assert classify_specialization(0.50) == "highly_specialized"
+
+    def test_custom_thresholds(self) -> None:
+        custom = (("low", 0.5), ("high", 1.01))
+        assert classify_specialization(0.30, custom) == "low"
+        assert classify_specialization(0.80, custom) == "high"
+
+    def test_default_thresholds_exposed(self) -> None:
+        assert isinstance(DEFAULT_THRESHOLDS, tuple)
+        assert len(DEFAULT_THRESHOLDS) >= 2
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 3. compute_specialization_matrix
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestMatrix:
+    def test_returns_none_when_lt_two(self) -> None:
+        assert compute_specialization_matrix({}) is None
+        assert compute_specialization_matrix({"a": {"x": 1}}) is None
+
+    def test_diagonal_zero(self) -> None:
+        tax = {
+            "a": {"x": 1, "y": 0},
+            "b": {"x": 0, "y": 1},
+        }
+        m = compute_specialization_matrix(tax)
+        for i in range(len(m["engines"])):
+            assert m["matrix"][i][i] == 0.0
+
+    def test_symmetric(self) -> None:
+        tax = {
+            "a": {"x": 1, "y": 0},
+            "b": {"x": 0, "y": 1},
+            "c": {"x": 1, "y": 1},
+        }
+        m = compute_specialization_matrix(tax)
+        n = len(m["engines"])
+        for i in range(n):
+            for j in range(n):
+                assert m["matrix"][i][j] == m["matrix"][j][i]
+
+    def test_max_pair_identifies_most_specialized(self) -> None:
+        # A vs B totalement disjoints, C similaire à A.
+        tax = {
+            "a": {"x": 100, "y": 0},
+            "b": {"x": 0, "y": 100},
+            "c": {"x": 95, "y": 5},
+        }
+        m = compute_specialization_matrix(tax)
+        # La paire la plus spécialisée doit être (a, b)
+        assert set(m["max_pair"]) == {"a", "b"}
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 4. top_specialized_pairs
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestTop:
+    def _matrix(self) -> dict:
+        return compute_specialization_matrix({
+            "a": {"x": 100, "y": 0},
+            "b": {"x": 0, "y": 100},
+            "c": {"x": 95, "y": 5},
+        })
+
+    def test_sorted_descending(self) -> None:
+        pairs = top_specialized_pairs(self._matrix(), n=10)
+        scores = [p["score"] for p in pairs]
+        assert scores == sorted(scores, reverse=True)
+
+    def test_caps_at_n(self) -> None:
+        pairs = top_specialized_pairs(self._matrix(), n=1)
+        assert len(pairs) == 1
+
+    def test_min_score_filter(self) -> None:
+        pairs = top_specialized_pairs(
+            self._matrix(), n=10, min_score=0.99,
+        )
+        # Seules les paires (a,b) et éventuellement (b,c) au-dessus
+        assert all(p["score"] >= 0.99 for p in pairs)
+
+    def test_none_input_returns_empty(self) -> None:
+        assert top_specialized_pairs(None) == []
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 5. Vue HTML
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestRender:
+    def test_empty_returns_empty(self) -> None:
+        assert build_specialization_html(None) == ""
+        assert build_specialization_html({}) == ""
+
+    def test_single_engine_returns_empty(self) -> None:
+        assert build_specialization_html({"a": {"x": 1}}) == ""
+
+    def test_renders_table(self) -> None:
+        tax = {
+            "tess": {"visual_confusion": 80, "lacuna": 20},
+            "pero": {"visual_confusion": 5, "lacuna": 95},
+        }
+        html = build_specialization_html(tax, _load_labels("fr"))
+        assert "<table" in html
+        assert "tess" in html
+        assert "pero" in html
+        # Catégorie traduite
+        assert "Forte spécialisation" in html
+
+    def test_anti_injection(self) -> None:
+        tax = {
+            "<script>alert(1)</script>": {"x": 100},
+            "pero": {"y": 100},
+        }
+        html = build_specialization_html(tax, _load_labels("fr"))
+        assert "<script>alert" not in html
+        assert "&lt;script&gt;" in html
+
+    def test_renders_in_english(self) -> None:
+        tax = {
+            "a": {"x": 100, "y": 0},
+            "b": {"x": 0, "y": 100},
+        }
+        html = build_specialization_html(tax, _load_labels("en"))
+        assert "Inter-engine specialisation" in html
+        assert "Highly specialised" in html
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 6. Complétude i18n
+# ──────────────────────────────────────────────────────────────────────────
+
+
+_KEYS = {
+    "specialization_title", "specialization_note",
+    "specialization_engine_a", "specialization_engine_b",
+    "specialization_score", "specialization_category",
+    "specialization_cat_similar", "specialization_cat_distinct",
+    "specialization_cat_highly_specialized",
+}
+
+
+class TestI18n:
+    def test_fr(self) -> None:
+        d = _load_labels("fr")
+        assert not _KEYS - d.keys()
+
+    def test_en(self) -> None:
+        d = _load_labels("en")
+        assert not _KEYS - d.keys()