sprint88: A.I.8 vue HTML "Déficit projeté de robustesse" (clôture bout-en-bout)

Le module 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

picarones/report/robustness_projection_render.py produit deux
tableaux :
- Résumé par moteur : déficit total avec gradient vert→orange→rouge,
n types, pire dégradation, trié par déficit décroissant.
- 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.

13 clés i18n FR/EN. 12 tests dans
test_sprint88_robustness_projection_html.py couvrant rendu, calcul
automatique de l'agrégation, tri, formatage, gestion None,
anti-injection, FR + EN, bout-en-bout avec project_robustness_on_corpus
+ aggregate_projection_per_engine, complétude i18n 13 clés.

A.I.8 livrée bout-en-bout (calcul Sprint 81 + vue HTML Sprint 88).

Tests : 2899 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 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)
+  calculait la projection des courbes de dégradation
+  synthétique sur les caractéristiques d'image réelles ; ce
+  sprint livre la **vue HTML** correspondante.  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` :
+  `build_robustness_projection_html(projection, aggregated,
+  labels)` produit deux tableaux :
+
+  1. **Résumé par moteur** — déficit total attendu (gradient
+     vert → orange → rouge sur ±5 pts de CER), nombre de types
+     de dégradation é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` n'est pas fourni, calculé automatiquement
+  depuis la projection.  Adaptive : `""` si la projection est
+  vide.  Anti-injection systématique sur nom de moteur et type
+  de dégradation.  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` couvrant rendu
+  vide/None, rendu complet, calcul automatique de
+  l'agrégation, tri par déficit décroissant, formatage de la
+  cellule « pire dégradation », gestion d'un déficit None
+  (cellule —), anti-injection nom moteur + type dégradation,
+  rendu en français + anglais, **bout-en-bout** avec le
+  pipeline réel `project_robustness_on_corpus` +
+  `aggregate_projection_per_engine`, complétude i18n 13 clés.
+  **Verrou levé** : 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 — A.I.8 livrée bout-en-bout
+  (calcul Sprint 81 + vue HTML Sprint 88).
+
 - **Sprint 87 — A.II.2 : delta Flesch câblé bout-en-bout
   (couche calcul Sprint 52 + runner + vue HTML).**  Le module
   `picarones/core/readability.py` (Sprint 52) calculait le

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). |
+| 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). |
 | 85 | **Sprint 54 du plan d'évolution 2026 — A.II.5b : précision sur séquences numériques (couche de calcul + registre typé)**. Pour un économiste-historien, un éditeur de chartes ou un archiviste, la fidélité aux séquences numériques est un proxy direct de la qualité éditoriale — un OCR qui rate « 1789 » dans une charte révolutionnaire ou « f. 12v » dans une cote d'archives produit un corpus inutilisable, même avec un CER global respectable. Nouveau module `picarones/core/numerical_sequences.py` couvrant **5 catégories** : (1) **dates arabes** années 4 chiffres dans la plage [1000-2099], (2) **numéraux romains** délégués à `roman_numerals.detect_roman_numerals` Sprint 60, (3) **foliotation** (`f.`, `fol.`, `p.`, `pp.`, `n°`) avec suffixe `r`/`v` préservé (recto/verso = information distincte non interchangeable côté valeur), (4) **montants** Ancien Régime (`livres/l.`, `sols/s.`, `deniers/d.`) et modernes (`£`, `€`, `₣`, `écus`, `florins`, `francs`), (5) **années régnales** (`an III`, `l'an V`, `an de grâce 1450`). `compute_numerical_sequence_metrics(reference, hypothesis)` classe chaque GT en `strict_preserved` (forme exacte) / `value_preserved` (`XIV` ↔ `14` accepté ; **mais pas** `f. 12r` ↔ `f. 12v`) / `lost`. Multiplicité respectée. Retourne `{global_strict_score, global_value_score, n_total, per_category{n_total, strict, value, strict_score, value_score, lost_items}}`. `numerical_sequence_strict_score` et `numerical_sequence_value_score` enregistrés dans le registre typé Sprint 34 pour `(TEXT, TEXT)`. Limites documentées : regex conservatrices (« mil cinq cens » non détecté comme année), pas de cross-category match (`MDCLXVIII` GT et `1668` hyp sont catégorisés séparément). +27 tests dans `test_sprint85_numerical_sequences.py` couvrant détecteurs individuels, scénarios identité/perte totale/GT vide/recto-verso non interchangeables/multiplicité, **2 cas réalistes** (charte XVIIIᵉ siècle préservée vs registre paroissial où l'OCR modernise XVIII→18 mais préserve l'année 1750 et la foliation), intégration registre 4 cas. **Verrou levé** : un bench d'archive numérique peut classer ses moteurs sur la dimension *« mes dates et cotes seront-elles fiables ? »*, qui complète la **recherchabilité fuzzy** (Sprint 84) pour livrer **A.II.5 en couche de calcul intégrale**. Reste pour clôturer A.II.5 bout-en-bout : câblage runner + colonne HTML « Recherchabilité » + table HTML séquences numériques. |
@@ -305,7 +306,7 @@ au template `_narrative_summary.html` (placé entre `_header.html` et `_critical
 ## Contexte développement
 
 - **Environnement** : GitHub Codespaces (`/workspaces/Picarones`), Python 3.12
-- **Tests** : 2887 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 — robustesse projetée sur corpus réel ; Sprint 82 = A.I.9 — section « 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 (Levenshtein ≤ 2, registre typé) ; Sprint 85 = A.II.5b — précision séquences numériques (5 catégories, registre typé) ; Sprint 86 = A.II.5 livrée bout-en-bout — câblage runner adaptive + vues HTML « Recherchabilité fuzzy » et « Précision sur séquences numériques » ; **Sprint 87 = A.II.2 (delta Flesch) câblé bout-en-bout — runner adaptive + vue HTML « Lisibilité »**)
+- **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**)
 - **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/report/i18n/en.json

@@ -303,5 +303,18 @@
   "readability_delta_median": "Median Δ",
   "readability_over_norm_rate": "% over-normalised",
   "readability_under_norm_count": "Under-normalised docs",
-  "readability_docs": "Docs"
+  "readability_docs": "Docs",
+  "robproj_title": "Projected robustness deficit on the real corpus",
+  "robproj_note": "Projection of synthetic degradation curves onto real image characteristics. The total deficit assumes independence of degradations — a useful diagnostic approximation, not a verdict.",
+  "robproj_summary": "Per-engine summary",
+  "robproj_detail": "Detail per (engine × degradation) pair",
+  "robproj_engine": "Engine",
+  "robproj_total": "Total deficit (CER pts)",
+  "robproj_n_types": "Types evaluated",
+  "robproj_worst": "Worst degradation",
+  "robproj_deg_type": "Degradation",
+  "robproj_n_docs": "Docs",
+  "robproj_n_with_data": "Docs with data",
+  "robproj_deficit": "Projected ΔCER (pts)",
+  "robproj_above": "Docs ≥ critical threshold"
 }

picarones/report/i18n/fr.json

@@ -303,5 +303,18 @@
   "readability_delta_median": "Δ médian",
   "readability_over_norm_rate": "% over-normalisé",
   "readability_under_norm_count": "Docs under-normalisés",
-  "readability_docs": "Docs"
+  "readability_docs": "Docs",
+  "robproj_title": "Déficit projeté de robustesse sur le corpus réel",
+  "robproj_note": "Projection des courbes de dégradation synthétique sur les caractéristiques d'image réelles. Le déficit total suppose l'indépendance des dégradations — approximation utile pour le diagnostic, pas un verdict.",
+  "robproj_summary": "Résumé par moteur",
+  "robproj_detail": "Détail par couple (moteur × dégradation)",
+  "robproj_engine": "Moteur",
+  "robproj_total": "Déficit total (pts CER)",
+  "robproj_n_types": "Types évalués",
+  "robproj_worst": "Pire dégradation",
+  "robproj_deg_type": "Dégradation",
+  "robproj_n_docs": "Docs",
+  "robproj_n_with_data": "Docs avec data",
+  "robproj_deficit": "Δ CER projeté (pts)",
+  "robproj_above": "Docs ≥ seuil critique"
 }

picarones/report/robustness_projection_render.py

@@ -0,0 +1,268 @@
+"""Rendu HTML « Déficit projeté de robustesse » — Sprint 88
+(A.I.8 vue HTML).
+
+Suite directe ``picarones/core/robustness_projection.py``
+(Sprint 81).  Pattern identique aux autres rendus : server-
+side, pas de JS, anti-injection systématique.
+
+Note d'intégration
+------------------
+La robustesse synthétique (``picarones.core.robustness``) est
+exécutée par la CLI ``picarones robustness`` indépendamment du
+benchmark principal.  Pour produire la vue de projection,
+l'utilisateur compose :
+
+.. code-block:: python
+
+    from picarones.core.robustness import analyze_robustness
+    from picarones.core.robustness_projection import (
+        project_robustness_on_corpus,
+        aggregate_projection_per_engine,
+    )
+    from picarones.report.robustness_projection_render import (
+        build_robustness_projection_html,
+    )
+
+    rob = analyze_robustness(corpus, [engine])         # Sprint 8
+    projection = project_robustness_on_corpus(
+        rob.curves,
+        [doc.image_quality.as_dict() for doc in benchmark.docs],
+    )                                                   # Sprint 81
+    aggregated = aggregate_projection_per_engine(projection)
+    html = build_robustness_projection_html(
+        projection, aggregated, labels,
+    )
+
+Vue
+---
+1. **Tableau résumé par moteur** : déficit total attendu,
+   nombre de types de dégradation, pire dégradation.
+2. **Tableau détaillé par couple (moteur × dégradation)** :
+   docs, docs avec data, déficit, % docs au-dessus du seuil
+   critique.
+
+Les cellules « déficit » sont colorées par gradient vert
+(faible) → orange → rouge (≥ 5 points de CER projetés).
+
+Adaptive : ``""`` si la projection est vide (aucune courbe ou
+aucun document avec qualité).
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+
+def _color_for_deficit(deficit: float) -> str:
+    """Vert (≈0) → orange (~3 pts) → rouge (≥ 5 pts)."""
+    f = max(0.0, min(1.0, abs(deficit) / 0.05))
+    if f < 0.5:
+        # vert → orange
+        t = f / 0.5
+        r = int(167 + (235 - 167) * t)
+        g = int(240 + (180 - 240) * t)
+        b = int(167 + (60 - 167) * t)
+    else:
+        # orange → rouge
+        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}"
+
+
+def _build_summary_table(
+    aggregated: dict,
+    labels: dict[str, str],
+) -> str:
+    if not aggregated:
+        return ""
+    h_engine = labels.get("robproj_engine", "Moteur")
+    h_total = labels.get("robproj_total", "Déficit total (pts CER)")
+    h_n_types = labels.get("robproj_n_types", "Types évalués")
+    h_worst = labels.get("robproj_worst", "Pire dégradation")
+    parts = [
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.9rem;margin-bottom:.8rem">',
+        '<thead><tr>',
+    ]
+    for col in (h_engine, h_total, h_n_types, h_worst):
+        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>")
+    # Tri par déficit décroissant
+    rows = sorted(
+        aggregated.items(),
+        key=lambda kv: -float(
+            kv[1].get("total_expected_deficit") or 0.0
+        ),
+    )
+    for engine, info in rows:
+        deficit = float(info.get("total_expected_deficit") or 0.0)
+        n_types = int(info.get("n_degradation_types") or 0)
+        worst_type = info.get("worst_degradation_type")
+        worst_deficit = info.get("worst_degradation_deficit")
+        color = _color_for_deficit(deficit)
+        worst_str = (
+            f"{_e(str(worst_type))} ({worst_deficit * 100:+.1f})"
+            if worst_type and isinstance(worst_deficit, (int, float))
+            else "—"
+        )
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.4rem .6rem">{_e(str(engine))}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'background:{color};font-family:monospace;font-weight:600">'
+            f'{deficit * 100:+.2f}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{n_types}</td>'
+            f'<td style="padding:.4rem .6rem">{worst_str}</td>'
+            f'</tr>'
+        )
+    parts.append("</tbody></table>")
+    return "".join(parts)
+
+
+def _build_detail_table(
+    projection: dict,
+    labels: dict[str, str],
+) -> str:
+    if not projection:
+        return ""
+    h_engine = labels.get("robproj_engine", "Moteur")
+    h_deg_type = labels.get("robproj_deg_type", "Dégradation")
+    h_n_docs = labels.get("robproj_n_docs", "Docs")
+    h_n_with_data = labels.get("robproj_n_with_data", "Docs avec data")
+    h_deficit = labels.get("robproj_deficit", "Δ CER projeté (pts)")
+    h_above = labels.get("robproj_above", "Docs ≥ seuil critique")
+    parts = [
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.9rem">',
+        '<thead><tr>',
+    ]
+    for col in (h_engine, h_deg_type, h_n_docs,
+                h_n_with_data, h_deficit, h_above):
+        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>")
+    # Tri stable : par moteur puis type de dégradation
+    for engine in sorted(projection):
+        per_type = projection[engine] or {}
+        for deg_type in sorted(per_type):
+            entry = per_type[deg_type] or {}
+            n_docs = int(entry.get("n_docs") or 0)
+            n_with_data = int(entry.get("n_docs_with_data") or 0)
+            deficit = entry.get("deficit_vs_baseline")
+            n_above = int(entry.get("n_docs_above_critical") or 0)
+            if isinstance(deficit, (int, float)):
+                color = _color_for_deficit(float(deficit))
+                deficit_str = f"{float(deficit) * 100:+.2f}"
+                deficit_cell = (
+                    f'<td style="padding:.4rem .6rem;text-align:right;'
+                    f'background:{color};font-family:monospace">'
+                    f'{deficit_str}</td>'
+                )
+            else:
+                deficit_cell = (
+                    '<td style="padding:.4rem .6rem;text-align:right;'
+                    'opacity:.4">—</td>'
+                )
+            parts.append(
+                f'<tr>'
+                f'<td style="padding:.4rem .6rem">{_e(str(engine))}</td>'
+                f'<td style="padding:.4rem .6rem">{_e(str(deg_type))}</td>'
+                f'<td style="padding:.4rem .6rem;text-align:right;'
+                f'font-family:monospace">{n_docs}</td>'
+                f'<td style="padding:.4rem .6rem;text-align:right;'
+                f'font-family:monospace">{n_with_data}</td>'
+                f'{deficit_cell}'
+                f'<td style="padding:.4rem .6rem;text-align:right;'
+                f'font-family:monospace">{n_above}</td>'
+                f'</tr>'
+            )
+    parts.append("</tbody></table>")
+    return "".join(parts)
+
+
+def build_robustness_projection_html(
+    projection: Optional[dict],
+    aggregated: Optional[dict] = None,
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit la vue HTML « Déficit projeté de robustesse ».
+
+    Parameters
+    ----------
+    projection:
+        Sortie de ``project_robustness_on_corpus`` (Sprint 81),
+        forme ``{engine: {deg_type: {...}}}``.  Si ``None`` ou
+        vide, retourne ``""``.
+    aggregated:
+        Sortie de ``aggregate_projection_per_engine`` (Sprint
+        81). Si ``None``, sera calculé à partir de
+        ``projection``.
+    labels:
+        Dict i18n.  Clés sous le préfixe ``robproj_*``.
+
+    Returns
+    -------
+    str
+        Section HTML, ou ``""`` si projection vide.
+    """
+    if not projection:
+        return ""
+    if aggregated is None:
+        from picarones.core.robustness_projection import (
+            aggregate_projection_per_engine,
+        )
+        aggregated = aggregate_projection_per_engine(projection)
+    labels = labels or {}
+    title = labels.get(
+        "robproj_title",
+        "Déficit projeté de robustesse sur le corpus réel",
+    )
+    note = labels.get(
+        "robproj_note",
+        "Projection des courbes de dégradation synthétique sur "
+        "les caractéristiques d'image réelles. Le déficit total "
+        "suppose l'indépendance des dégradations — c'est une "
+        "approximation utile pour le diagnostic, pas un verdict.",
+    )
+    summary_table = _build_summary_table(aggregated or {}, labels)
+    detail_table = _build_detail_table(projection, labels)
+    if not summary_table and not detail_table:
+        return ""
+    h_summary = labels.get("robproj_summary", "Résumé par moteur")
+    h_detail = labels.get(
+        "robproj_detail", "Détail par couple (moteur × dégradation)",
+    )
+    parts = [
+        '<section class="robproj-section" style="margin:1.5rem 0">',
+        f'<h3 style="margin:0 0 .3rem 0">{_e(title)}</h3>',
+        f'<div style="font-size:.85rem;opacity:.75;margin-bottom:.7rem">'
+        f'{_e(note)}</div>',
+    ]
+    if summary_table:
+        parts.append(
+            f'<div style="font-weight:600;margin:.4rem 0 .3rem 0">'
+            f'{_e(h_summary)}</div>'
+        )
+        parts.append(summary_table)
+    if detail_table:
+        parts.append(
+            f'<div style="font-weight:600;margin:.6rem 0 .3rem 0">'
+            f'{_e(h_detail)}</div>'
+        )
+        parts.append(detail_table)
+    parts.append('</section>')
+    return "".join(parts)
+
+
+__all__ = ["build_robustness_projection_html"]

tests/test_sprint88_robustness_projection_html.py

@@ -0,0 +1,231 @@
+"""Tests Sprint 88 — A.I.8 vue HTML : déficit projeté de robustesse.
+
+Couvre :
+
+1. ``build_robustness_projection_html`` :
+   - vide / None → ``""``
+   - rendu complet (résumé + détail)
+   - calcul automatique de ``aggregated`` si non fourni
+   - tri par déficit décroissant
+   - colonne « pire dégradation » formatée
+   - cellules colorées selon l'amplitude du déficit
+2. Anti-injection sur nom de moteur + type de dégradation.
+3. Bout-en-bout : intégration avec
+   ``project_robustness_on_corpus`` + ``aggregate_projection_per_engine``.
+4. Complétude i18n FR/EN.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from picarones.core.robustness_projection import (
+    aggregate_projection_per_engine,
+    project_robustness_on_corpus,
+)
+from picarones.report.robustness_projection_render import (
+    build_robustness_projection_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"))
+
+
+def _curve(engine: str, deg: str) -> dict:
+    return {
+        "engine_name": engine,
+        "degradation_type": deg,
+        "levels": [0, 5, 10, 20],
+        "cer_values": [0.05, 0.10, 0.20, 0.50],
+        "critical_threshold_level": 10,
+        "cer_threshold": 0.20,
+    }
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 1. build_robustness_projection_html
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestRender:
+    def test_none_returns_empty(self) -> None:
+        assert build_robustness_projection_html(None) == ""
+
+    def test_empty_returns_empty(self) -> None:
+        assert build_robustness_projection_html({}) == ""
+
+    def test_renders_summary_and_detail(self) -> None:
+        projection = {
+            "tess": {
+                "noise": {
+                    "n_docs": 50, "n_docs_with_data": 48,
+                    "expected_cer_mean": 0.18, "baseline_cer": 0.05,
+                    "deficit_vs_baseline": 0.13,
+                    "n_docs_above_critical": 12,
+                    "critical_threshold_cer": 0.20,
+                },
+            },
+        }
+        labels = _load_labels("fr")
+        html = build_robustness_projection_html(projection, labels=labels)
+        assert "<table" in html
+        assert "tess" in html
+        assert "noise" in html
+        # Déficit total = 0.13 → 13.00 pts
+        assert "+13.00" in html
+        # Le summary contient le worst type
+        assert "Pire dégradation" in html
+        assert "Détail" in html
+
+    def test_auto_computes_aggregate(self) -> None:
+        # Ne fournit que projection → aggregated calculé depuis
+        projection = {
+            "tess": {
+                "noise": {
+                    "n_docs": 10, "n_docs_with_data": 10,
+                    "deficit_vs_baseline": 0.05,
+                    "n_docs_above_critical": 0,
+                },
+            },
+        }
+        html = build_robustness_projection_html(
+            projection, labels=_load_labels("fr"),
+        )
+        # Total = 0.05 = 5.00 points
+        assert "+5.00" in html
+
+    def test_sorted_by_deficit_descending(self) -> None:
+        projection = {
+            "low": {
+                "noise": {
+                    "n_docs": 1, "n_docs_with_data": 1,
+                    "deficit_vs_baseline": 0.01,
+                    "n_docs_above_critical": 0,
+                },
+            },
+            "high": {
+                "noise": {
+                    "n_docs": 1, "n_docs_with_data": 1,
+                    "deficit_vs_baseline": 0.10,
+                    "n_docs_above_critical": 1,
+                },
+            },
+        }
+        html = build_robustness_projection_html(
+            projection, labels=_load_labels("fr"),
+        )
+        # « high » apparaît avant « low » dans le résumé
+        assert html.index("high") < html.index("low")
+
+    def test_anti_injection_engine(self) -> None:
+        projection = {
+            "<script>alert(1)</script>": {
+                "noise": {
+                    "n_docs": 1, "n_docs_with_data": 1,
+                    "deficit_vs_baseline": 0.05,
+                    "n_docs_above_critical": 0,
+                },
+            },
+        }
+        html = build_robustness_projection_html(
+            projection, labels=_load_labels("fr"),
+        )
+        assert "<script>alert" not in html
+        assert "&lt;script&gt;" in html
+
+    def test_anti_injection_deg_type(self) -> None:
+        projection = {
+            "tess": {
+                "<img/>": {
+                    "n_docs": 1, "n_docs_with_data": 1,
+                    "deficit_vs_baseline": 0.05,
+                    "n_docs_above_critical": 0,
+                },
+            },
+        }
+        html = build_robustness_projection_html(
+            projection, labels=_load_labels("fr"),
+        )
+        assert "<img/>" not in html
+        assert "&lt;img" in html
+
+    def test_handles_missing_deficit(self) -> None:
+        projection = {
+            "tess": {
+                "noise": {
+                    "n_docs": 5, "n_docs_with_data": 5,
+                    "deficit_vs_baseline": None,
+                    "n_docs_above_critical": 0,
+                },
+            },
+        }
+        html = build_robustness_projection_html(
+            projection, labels=_load_labels("fr"),
+        )
+        assert "—" in html  # Cellule déficit vide
+
+    def test_renders_in_english(self) -> None:
+        projection = {
+            "tess": {
+                "noise": {
+                    "n_docs": 1, "n_docs_with_data": 1,
+                    "deficit_vs_baseline": 0.05,
+                    "n_docs_above_critical": 0,
+                },
+            },
+        }
+        html = build_robustness_projection_html(
+            projection, labels=_load_labels("en"),
+        )
+        assert "Projected robustness deficit" in html
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 2. Bout-en-bout (Sprint 81 + Sprint 88)
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestEndToEnd:
+    def test_full_pipeline_renders(self) -> None:
+        curves = [_curve("tess", "noise"), _curve("pero", "noise")]
+        qualities = [
+            {"noise_level": 7.5}, {"noise_level": 5}, {"noise_level": 15},
+        ]
+        projection = project_robustness_on_corpus(curves, qualities)
+        aggregated = aggregate_projection_per_engine(projection)
+        html = build_robustness_projection_html(
+            projection, aggregated, _load_labels("fr"),
+        )
+        assert "<table" in html
+        # Les deux moteurs apparaissent
+        assert "tess" in html
+        assert "pero" in html
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 3. Complétude i18n
+# ──────────────────────────────────────────────────────────────────────────
+
+
+_KEYS = {
+    "robproj_title", "robproj_note", "robproj_summary", "robproj_detail",
+    "robproj_engine", "robproj_total", "robproj_n_types", "robproj_worst",
+    "robproj_deg_type", "robproj_n_docs", "robproj_n_with_data",
+    "robproj_deficit", "robproj_above",
+}
+
+
+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()