Sprint 5 du plan rapport — modélisation coût + vue Pareto qualité/coût

Sprint 5 et fin de la phase 0 du plan rapport. Vue compromis honnête
entre qualité (CER), coût €, vitesse et empreinte carbone optionnelle.

Modélisation coût (`picarones/core/pricing.py` + `data/pricing.yaml`) :

- Table indicative `pricing.yaml` avec OCR locaux (tesseract, pero_ocr,
kraken, calamari), APIs OCR cloud (mistral_ocr, google_vision,
azure_doc_intel), et LLMs courants (gpt-4o, gpt-4o-mini, claude
sonnet/haiku, mistral-large, ministral-3b, pixtral). Chaque entrée
porte type, prix par 1000 pages, source URL, date, kWh/1000 pages.
Avertissement explicite sur le vieillissement des prix.
- `EngineCost` dataclass : champs calculés (cost_per_1k_pages_eur,
co2_per_1k_pages_g) + assumptions textuelles affichées sous le graphique.
- `estimate_cost(...)` :
- cloud → prix de la table.
- local → temps mesuré (priorité) ou indicatif × taux horaire (CPU
par défaut 0,08 €/h, GPU 1,20 €/h, paramétrables).
- pipeline OCR+LLM → lookup prioritaire sur le LLM (qui domine le coût).
- inconnu → type "unknown" avec hypothèse "aucune entrée".
- `build_costs_for_benchmark(engines, durations)` annote toute la liste.

Algorithme Pareto (`statistics.py`) :

- `compute_pareto_front(points, objectives, name_key, minimize)` — N
dimensions, mix min/max, points avec valeurs manquantes ignorés.
- Utilisé sur 3 paires : (CER, coût €), (CER, vitesse), (CER, CO₂).

Vue HTML :

- Nouvelle carte `pareto-card` dans `view_analyses.html` (bord vert).
- Toolbar 3 boutons : "Coût € / 1000 pages" (défaut), "Vitesse (s/page)",
"Carbone (g CO₂)" — ce dernier étiqueté ⚗ "expérimental".
- Canvas Chart.js scatter avec axe X log pour le coût, linéaire sinon.
Front Pareto en vert (rayon 8 px), dominés en gris (rayon 6 px).
Tooltip : nom du moteur + CER + valeur de l'axe X choisi.
- Note méthodologique sous le graphique + bloc `<details>` "Hypothèses
détaillées par moteur" listant prix, type, lien vers la source de prix
daté, et chaque assumption récoltée par `estimate_cost`.
- CSS dédié (`.pareto-card`, `.pareto-toolbar`, `.pareto-toggle.active`,
`.pareto-experimental` avec ⚗).

Détecteurs narratifs activés :

- `detect_pareto_alternative` : émet un Fact HIGH si le front Pareto
contient un moteur autre que le leader CER ET strictement moins cher,
avec ratio d'économie. Templates FR/EN ajoutés.
- `detect_cost_outlier` : flag les moteurs au coût ≥ 5× la médiane qui ne
sont PAS sur le front (donc dominés). Importance MEDIUM. Templates ajoutés.

Tous les 12 types de Fact sont désormais opérationnels.

i18n : 9 nouvelles clés FR/EN (`h_pareto`, `pareto_axis_*`, `pareto_note`,
`pareto_assumptions_summary`, `pareto_front_label`, `pareto_dominated_label`,
`pareto_empty`).

Packaging : `data/*.yaml` ajouté à `package-data` et `MANIFEST.in`.

Tests (`test_sprint20_pareto_pricing.py`) — 28 :

- Pricing : chargement table, missing file, cloud vs local, override
taux horaire, mesure dépasse indicatif, pipeline → LLM, unknown,
carbone calculé.
- Pareto : front trivial, vide, point unique, valeurs manquantes
ignorées, 3 dimensions, min/max mixés, longueur de minimize validée.
- Détecteurs : pareto_alternative émis si alt cheaper, vide si front =
{leader} seul, cost_outlier flag les chers dominés mais pas ceux du
front.
- Intégration : section Pareto présente, JSON contient `pareto.cost/speed/co2`,
synthèse cite l'alternative, YAML présent dans le package, locale EN.
- Anti-hallucination : chaque nombre rendu dans la phrase pareto_alternative
vient bien du payload du Fact.

Suite complète : 1202 passed, 2 skipped (vs 1174 avant). Zéro régression.

Exemple sur la démo (8 docs, 3 moteurs + pipelines) :

• Sur ce corpus de 8 documents, pero_ocr obtient le CER moyen le plus
bas (0.13 %).
• Les moteurs pero_ocr, tesseract → gpt-4o, gpt-4o-vision (zero-shot),
tesseract ne sont pas statistiquement distinguables (Friedman-Nemenyi,
α = 0.05, n = 8 documents, CD = 2.157).
• À coût sensiblement inférieur, tesseract offre un compromis intéressant
(1.42 % de CER pour 0.06 €/1000 pages, contre 0.13 % / 0.57 € pour
pero_ocr, soit ×9.6 moins cher).

Phase 0 du plan rapport : terminée à ce sprint. Prochaines étapes
possibles : Sprint 6 (glossaire contextuel + panneau personnalisation),
Sprint 7 (études de cas + validation externe), puis Phase 1 (GT-free).

https://claude.ai/code/session_0162FdNNJyNvBuYzkgtsr9VB

CLAUDE.md

@@ -194,6 +194,7 @@ AZURE_DOC_INTEL_KEY=...
 | 17 | **Sprint 2 du plan rapport** : refactor de `generator.py` (3690 → 617 lignes) via Jinja2. Le monolithe `_HTML_TEMPLATE` est découpé en 10 fichiers externes dans `picarones/report/templates/` (base + 5 vues + header/footer + CSS + JS). L'i18n `i18n.py` (dict Python 101 clés) migré vers `picarones/report/i18n/{fr,en}.json` chargés à l'import. Ajout de 16 tests de non-régression (structure, déterminisme, i18n, garde-fous contre balises dupliquées). |
 | 18 | **Sprint 3 du plan rapport** : test de Friedman multi-moteurs + post-hoc Nemenyi + Critical Difference Diagram (Demšar 2006). Nouveau module `core/statistics.py` : `friedman_test`, `nemenyi_posthoc`, `build_critical_difference_svg` avec table Nemenyi (k=2 à 50, α=0,05 et 0,01), fallback pur Python (Wilson-Hilferty pour chi²), support scipy optionnel (extra `stats`). Partial `_critical_difference.html` inséré en tête du rapport, SVG rendu server-side (pas de JS), i18n FR/EN pour les aides. Détecteur narratif `detect_statistical_tie` activé (lit `nemenyi.tied_groups`). 41 tests ajoutés (cas canoniques, dégénérés, SVG, intégration rapport). |
 | 19 | **Sprint 4 du plan rapport** : moteur narratif complet + synthèse factuelle en tête. 9 détecteurs implémentés (global_leader_cer, significant_gap, stratum_winner/collapse, error_profile_outlier, llm_hallucination_flag, robustness_fragile, speed_winner, confidence_warning). Arbitre (`arbiter.py`) avec tri par importance, non-redondance, suppression des contradictions Wilcoxon/Nemenyi. Renderer (`renderer.py`) lit templates YAML `core/narrative/templates/{fr,en}.yaml` (10 templates par langue) et rend par `str.format_map` déterministe. Nouveau partial `_narrative_summary.html` placé en tête du rapport (entre header et CDD). Garde-fou anti-hallucination testé : chaque nombre rendu est traçable au payload du Fact associé. 32 tests (détecteurs unitaires, arbitre, renderer, E2E, traçabilité, intégration HTML). `pareto_alternative` et `cost_outlier` restent stubs pour Sprint 5. |
+| 20 | **Sprint 5 du plan rapport** : modélisation coût + vue Pareto. Nouveau module `core/pricing.py` (`EngineCost`, `estimate_cost`, `build_costs_for_benchmark`) lit la table indicative `picarones/data/pricing.yaml` (OCR locaux + APIs cloud + LLM). Nouvel algo `compute_pareto_front` dans `statistics.py`, multi-objectifs (min/max), N dimensions. Vue Chart.js dans `view_analyses.html` avec front Pareto en surbrillance et 3 toggles d'axe : coût € / vitesse / carbone (dernier étiqueté ⚗ expérimental). Détecteurs `pareto_alternative` et `cost_outlier` activés. Templates FR/EN ajoutés. Bloc "hypothèses détaillées" replié sous le graphique avec liens vers les sources de prix. 28 tests (pricing local vs cloud, override taux horaire, pareto canonique/dégénéré/3D, détecteurs, intégration HTML). |
 
 ---
 
@@ -219,12 +220,12 @@ parse la synthèse rendue et vérifie que chaque nombre est traçable au payload
 (via `_numbers_in_payload`) augmenté d'une liste blanche limitative de constantes
 de template (`95`, `100`).
 
-**Détecteurs activés dans le registre par défaut (Sprint 19)** :
+**Détecteurs activés dans le registre par défaut (Sprint 20)** — les 12 sont opérationnels :
 - Sprint 3 : `statistical_tie`
 - Sprint 4 : `global_leader_cer`, `significant_gap`, `stratum_winner`, `stratum_collapse`,
   `error_profile_outlier`, `llm_hallucination_flag`, `robustness_fragile`,
   `speed_winner`, `confidence_warning`
-- Sprint 5 : `pareto_alternative`, `cost_outlier` — stubs (retournent `[]`)
+- Sprint 5 : `pareto_alternative`, `cost_outlier`
 
 **Règle anti-contradiction** (arbitre) : si `SIGNIFICANT_GAP` (Wilcoxon non corrigé)
 et `STATISTICAL_TIE` (Nemenyi corrigé) concernent les mêmes moteurs, Nemenyi
@@ -240,7 +241,7 @@ au template `_narrative_summary.html` (placé entre `_header.html` et `_critical
 ## Contexte développement
 
 - **Environnement** : GitHub Codespaces (`/workspaces/Picarones`), Python 3.12
-- **Tests** : 1174 passed, 2 skipped (Sprint 19)
+- **Tests** : 1202 passed, 2 skipped (Sprint 20)
 - **Branche active** : `claude/review-picarones-benchmarks-E3J42`
 - **Transcript de la conversation de développement** :
   `/mnt/transcripts/2026-03-11-14-01-41-picarones-ocr-bench-project.txt`

MANIFEST.in

@@ -8,3 +8,4 @@ recursive-include picarones *.json *.yaml *.yml
 recursive-include picarones/report/templates *.j2 *.html *.css *.js
 recursive-include picarones/report/i18n *.json
 recursive-include picarones/core/narrative/templates *.yaml
+recursive-include picarones/data *.yaml

picarones/core/narrative/detectors.py

@@ -162,8 +162,63 @@ def detect_significant_gap(benchmark_data: dict) -> list[Fact]:
 
 
 def detect_pareto_alternative(benchmark_data: dict) -> list[Fact]:
-    """Moteur Pareto-dominant différent du leader CER. Sprint 5."""
-    return []
+    """Moteur Pareto-dominant différent du leader CER.
+
+    Lit ``benchmark_data["pareto"]["cost"]`` (Sprint 19) et émet un Fact si
+    la frontière contient un moteur autre que le leader CER, pour souligner
+    l'existence d'un compromis coût/qualité intéressant.
+    """
+    pareto = (benchmark_data.get("pareto") or {}).get("cost") or {}
+    front = pareto.get("front") or []
+    points = pareto.get("points") or []
+    if len(front) < 2:
+        return []
+
+    ranking = benchmark_data.get("ranking") or []
+    if not ranking:
+        return []
+    leader = ranking[0].get("engine")
+
+    # Le moteur le moins cher sur le front (hors leader)
+    alt: Optional[dict] = None
+    for p in points:
+        if p.get("engine") == leader:
+            continue
+        if p.get("engine") not in front:
+            continue
+        if alt is None or float(p.get("cost") or 0.0) < float(alt.get("cost") or 0.0):
+            alt = p
+    if alt is None:
+        return []
+
+    leader_point = next((p for p in points if p.get("engine") == leader), None)
+    if leader_point is None:
+        return []
+
+    alt_cer = float(alt.get("cer") or 0.0)
+    alt_cost = float(alt.get("cost") or 0.0)
+    leader_cer = float(leader_point.get("cer") or 0.0)
+    leader_cost = float(leader_point.get("cost") or 0.0)
+    if alt_cost >= leader_cost or alt_cost <= 0:
+        return []  # pas réellement moins cher — pas intéressant à remonter
+
+    return [Fact(
+        type=FactType.PARETO_ALTERNATIVE,
+        importance=FactImportance.HIGH,
+        payload={
+            "engine": alt["engine"],
+            "leader": leader,
+            "cer": round(alt_cer, 4),
+            "cer_pct": round(alt_cer * 100, 2),
+            "cost": round(alt_cost, 2),
+            "leader_cer": round(leader_cer, 4),
+            "leader_cer_pct": round(leader_cer * 100, 2),
+            "leader_cost": round(leader_cost, 2),
+            "cost_saving_ratio": round(leader_cost / alt_cost, 1) if alt_cost > 0 else None,
+            "delta_cer_pct": round((alt_cer - leader_cer) * 100, 2),
+        },
+        engines_involved=(alt["engine"],),
+    )]
 
 
 def _stratum_cer_by_engine(benchmark_data: dict) -> dict[str, dict[str, list[float]]]:
@@ -430,8 +485,44 @@ def detect_robustness_fragile(benchmark_data: dict) -> list[Fact]:
 
 
 def detect_cost_outlier(benchmark_data: dict) -> list[Fact]:
-    """Moteur au ratio coût/qualité très défavorable. Sprint 5."""
-    return []
+    """Moteur dont le coût est très disproportionné par rapport à son apport.
+
+    Flag un moteur dont le coût ≥ 5× la médiane ET qui n'est pas sur le
+    front Pareto (donc dominé par moins cher OU meilleur CER).
+    """
+    pareto = (benchmark_data.get("pareto") or {}).get("cost") or {}
+    points = pareto.get("points") or []
+    front = set(pareto.get("front") or [])
+    if len(points) < 3:
+        return []
+
+    costs = [float(p["cost"]) for p in points if p.get("cost") is not None]
+    if not costs:
+        return []
+    median_cost = _stats.median(costs)
+    if median_cost <= 0:
+        return []
+
+    facts: list[Fact] = []
+    for p in points:
+        c = float(p.get("cost") or 0.0)
+        if c < 5.0 * median_cost:
+            continue
+        if p["engine"] in front:
+            continue  # sur le front → coût justifié par une qualité unique
+        facts.append(Fact(
+            type=FactType.COST_OUTLIER,
+            importance=FactImportance.MEDIUM,
+            payload={
+                "engine": p["engine"],
+                "cost": round(c, 2),
+                "median_cost": round(median_cost, 2),
+                "ratio_to_median": round(c / median_cost, 1),
+                "cer_pct": round(float(p.get("cer") or 0.0) * 100, 2),
+            },
+            engines_involved=(p["engine"],),
+        ))
+    return facts
 
 
 def _mean_duration_per_engine(benchmark_data: dict) -> dict[str, float]:

picarones/core/narrative/templates/en.yaml

@@ -44,3 +44,12 @@ speed_winner: >-
 confidence_warning: >-
   Ranking is fragile: the 95 % confidence interval of {engine} spans
   {ci_width_pct} CER points, compared with a gap of {gap_to_runner_up_pct} points to the runner-up.
+
+pareto_alternative: >-
+  At much lower cost, {engine} offers an interesting trade-off ({cer_pct} %
+  CER for {cost} €/1000 pages, vs {leader_cer_pct} % / {leader_cost} € for
+  {leader}, i.e. ×{cost_saving_ratio} cheaper).
+
+cost_outlier: >-
+  Disproportionate cost for {engine} ({cost} €/1000 pages, ×{ratio_to_median}
+  the median) without a compensating quality advantage (CER {cer_pct} %).

picarones/core/narrative/templates/fr.yaml

@@ -48,3 +48,12 @@ speed_winner: >-
 confidence_warning: >-
   Classement fragile : l'intervalle de confiance à 95 % de {engine} s'étend
   sur {ci_width_pct} points de CER, à comparer à l'écart de {gap_to_runner_up_pct} points avec le second.
+
+pareto_alternative: >-
+  À coût sensiblement inférieur, {engine} offre un compromis intéressant
+  ({cer_pct} % de CER pour {cost} €/1000 pages, contre {leader_cer_pct} % /
+  {leader_cost} € pour {leader}, soit ×{cost_saving_ratio} moins cher).
+
+cost_outlier: >-
+  Coût disproportionné pour {engine} ({cost} €/1000 pages, ×{ratio_to_median}
+  la médiane) sans avantage de qualité compensatoire (CER {cer_pct} %).

picarones/core/pricing.py

@@ -0,0 +1,309 @@
+"""Modélisation des coûts — APIs cloud et temps d'inférence local.
+
+Sert uniquement à la vue Pareto coût/qualité du rapport (Sprint 5).
+Les prix sont indicatifs et vieillissent vite : voir ``picarones/data/pricing.yaml``
+pour les hypothèses, dates et URLs de référence.
+
+Conventions
+-----------
+- Unité monétaire : EUR (conversion indicative depuis USD quand applicable).
+- Coût exprimé par **1 000 pages** traitées.
+- Coût local = temps moyen d'inférence × taux horaire (paramétrable).
+- Empreinte carbone optionnelle : kWh × intensité g CO₂/kWh du réseau
+  d'exécution (mix France bas carbone par défaut pour le local,
+  moyenne cloud hyperscaler pour les APIs).
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_PRICING_PATH = Path(__file__).parent.parent / "data" / "pricing.yaml"
+
+
+@dataclass(frozen=True)
+class PricingDefaults:
+    """Valeurs par défaut du fichier de prix (section ``meta``)."""
+
+    last_updated: Optional[str] = None
+    currency: str = "EUR"
+    hourly_rate_local_cpu_eur: float = 0.08
+    hourly_rate_local_gpu_eur: float = 1.20
+    grid_intensity_local: float = 58.0
+    grid_intensity_cloud: float = 380.0
+
+
+@dataclass
+class EngineCost:
+    """Coût estimé d'un moteur sur 1 000 pages, avec traçabilité des hypothèses.
+
+    La représentation est immuable après construction : une fois que l'utilisateur
+    a choisi un taux horaire local, toutes les instances partagent cette
+    hypothèse par injection explicite dans ``build_costs_for_benchmark``.
+    """
+
+    engine_key: str
+    """Nom ou modèle servant de clé dans la table (ex. ``"gpt-4o"``, ``"tesseract"``)."""
+
+    type: str  # "local" | "cloud_api" | "unknown"
+
+    cost_per_1k_pages_eur: Optional[float] = None
+    """Coût par 1 000 pages en euros. ``None`` si les données sont insuffisantes."""
+
+    currency: str = "EUR"
+
+    # Source / date
+    pricing_source_url: Optional[str] = None
+    pricing_date: Optional[str] = None
+
+    # Pour les APIs cloud : prix brut
+    api_price_per_1k_pages: Optional[float] = None
+
+    # Pour le local : temps d'inférence et taux horaire utilisés
+    local_mean_seconds_per_page: Optional[float] = None
+    hourly_rate_eur: Optional[float] = None
+
+    # Empreinte carbone (estimation — étiquetée "expérimentale" dans le rapport)
+    kwh_per_1k_pages: Optional[float] = None
+    grid_intensity_g_co2_per_kwh: Optional[float] = None
+    co2_per_1k_pages_g: Optional[float] = None
+
+    notes: Optional[str] = None
+
+    assumptions: list[str] = field(default_factory=list)
+    """Liste d'hypothèses textuelles à afficher sous le graphique."""
+
+    def as_dict(self) -> dict:
+        return {
+            "engine_key": self.engine_key,
+            "type": self.type,
+            "cost_per_1k_pages_eur": self.cost_per_1k_pages_eur,
+            "currency": self.currency,
+            "pricing_source_url": self.pricing_source_url,
+            "pricing_date": self.pricing_date,
+            "api_price_per_1k_pages": self.api_price_per_1k_pages,
+            "local_mean_seconds_per_page": self.local_mean_seconds_per_page,
+            "hourly_rate_eur": self.hourly_rate_eur,
+            "kwh_per_1k_pages": self.kwh_per_1k_pages,
+            "grid_intensity_g_co2_per_kwh": self.grid_intensity_g_co2_per_kwh,
+            "co2_per_1k_pages_g": self.co2_per_1k_pages_g,
+            "notes": self.notes,
+            "assumptions": list(self.assumptions),
+        }
+
+
+def load_pricing_database(path: Optional[Path] = None) -> tuple[PricingDefaults, dict]:
+    """Charge la table de prix YAML.
+
+    Retourne ``(defaults, engines_table)`` où ``engines_table`` est un dict
+    ``{engine_key: raw_entry}``.
+    """
+    path = Path(path) if path else _DEFAULT_PRICING_PATH
+    if not path.exists():
+        logger.warning("[pricing] fichier %s introuvable", path)
+        return PricingDefaults(), {}
+    try:
+        with path.open(encoding="utf-8") as fh:
+            data = yaml.safe_load(fh) or {}
+    except yaml.YAMLError as e:
+        logger.warning("[pricing] échec parsing %s : %s", path, e)
+        return PricingDefaults(), {}
+
+    meta = data.get("meta", {}) or {}
+    defaults = PricingDefaults(
+        last_updated=meta.get("last_updated"),
+        currency=meta.get("currency", "EUR"),
+        hourly_rate_local_cpu_eur=float(meta.get("default_hourly_rate_local_cpu_eur", 0.08)),
+        hourly_rate_local_gpu_eur=float(meta.get("default_hourly_rate_local_gpu_eur", 1.20)),
+        grid_intensity_local=float(meta.get("default_grid_intensity_g_co2_per_kwh", 58.0)),
+        grid_intensity_cloud=float(meta.get("cloud_grid_intensity_g_co2_per_kwh", 380.0)),
+    )
+    engines_table = data.get("engines", {}) or {}
+    return defaults, engines_table
+
+
+def _match_key(engine_name: str, llm_model: Optional[str], table: dict) -> Optional[str]:
+    """Cherche la meilleure clé pour ce moteur dans la table.
+
+    Stratégie : d'abord le nom du modèle LLM (pour les pipelines), puis le
+    nom OCR, puis un match partiel (substring) comme filet de sécurité.
+    """
+    candidates = [llm_model, engine_name]
+    for c in candidates:
+        if c and c in table:
+            return c
+    # Matching partiel — utile pour "tesseract → gpt-4o" ou "gpt-4o-vision"
+    for c in candidates:
+        if not c:
+            continue
+        for key in table:
+            if key in c:
+                return key
+    return None
+
+
+def estimate_cost(
+    engine_name: str,
+    *,
+    llm_model: Optional[str] = None,
+    is_pipeline: bool = False,
+    measured_seconds_per_page: Optional[float] = None,
+    table: Optional[dict] = None,
+    defaults: Optional[PricingDefaults] = None,
+    hourly_rate_override_eur: Optional[float] = None,
+) -> EngineCost:
+    """Calcule le ``EngineCost`` pour un moteur donné.
+
+    Parameters
+    ----------
+    engine_name:
+        Nom public du moteur (ex. ``"tesseract"``, ``"tesseract → gpt-4o"``).
+    llm_model:
+        Si pipeline OCR+LLM, le modèle LLM utilisé — prioritaire pour la
+        lookup car c'est lui qui domine le coût.
+    is_pipeline:
+        Indique un pipeline OCR+LLM (change la sémantique de lookup).
+    measured_seconds_per_page:
+        Temps moyen observé sur le benchmark courant. Remplace la valeur
+        indicative de la table si fournie (plus fiable).
+    table, defaults:
+        Overrides pour tests ou usage institutionnel.
+    hourly_rate_override_eur:
+        Taux horaire à utiliser pour le calcul local (sinon valeur table
+        ou défaut).
+    """
+    if table is None or defaults is None:
+        _defaults, _table = load_pricing_database()
+        defaults = defaults or _defaults
+        table = table or _table
+
+    key = _match_key(engine_name, llm_model if is_pipeline else None, table)
+    if key is None:
+        return EngineCost(
+            engine_key=engine_name,
+            type="unknown",
+            assumptions=["Aucune entrée dans la table de prix pour ce moteur."],
+        )
+
+    entry = table[key]
+    etype = str(entry.get("type", "unknown"))
+    notes = entry.get("notes")
+    assumptions: list[str] = []
+    currency = defaults.currency
+
+    cost_eur: Optional[float] = None
+    api_price: Optional[float] = None
+    local_seconds = measured_seconds_per_page
+    hourly_rate = None
+
+    if etype == "cloud_api":
+        api_price = entry.get("api_price_per_1k_pages")
+        if api_price is not None:
+            cost_eur = float(api_price)
+            assumptions.append(
+                f"Prix API indicatif : {cost_eur:.2f} €/1000 pages "
+                f"(source : {entry.get('pricing_source_url', '—')}, {entry.get('pricing_date', 'date inconnue')})."
+            )
+    elif etype == "local":
+        indicative_seconds = entry.get("local_mean_seconds_per_page")
+        if local_seconds is None and indicative_seconds is not None:
+            local_seconds = float(indicative_seconds)
+            assumptions.append(
+                f"Temps d'inférence indicatif : {local_seconds:.1f} s/page (non mesuré sur ce benchmark)."
+            )
+        elif local_seconds is not None:
+            assumptions.append(
+                f"Temps d'inférence mesuré : {local_seconds:.1f} s/page (moyenne sur le corpus)."
+            )
+
+        hourly_rate = (
+            hourly_rate_override_eur
+            if hourly_rate_override_eur is not None
+            else entry.get("hourly_rate_override_eur")
+        )
+        if hourly_rate is None:
+            # Heuristique : si l'entrée précise un override GPU, sinon CPU
+            hourly_rate = (
+                defaults.hourly_rate_local_gpu_eur
+                if "gpu" in str(notes or "").lower()
+                else defaults.hourly_rate_local_cpu_eur
+            )
+        hourly_rate = float(hourly_rate)
+
+        if local_seconds is not None and hourly_rate is not None:
+            cost_eur = (local_seconds / 3600.0) * hourly_rate * 1000.0
+            assumptions.append(
+                f"Taux horaire appliqué : {hourly_rate:.2f} €/h "
+                f"(défaut {'GPU' if hourly_rate >= 0.5 else 'CPU'})."
+            )
+
+    # Empreinte carbone optionnelle
+    kwh_1k = entry.get("kwh_per_1k_pages")
+    grid = (
+        entry.get("grid_intensity_g_co2_per_kwh")
+        or (defaults.grid_intensity_cloud if etype == "cloud_api" else defaults.grid_intensity_local)
+    )
+    co2_g = None
+    if kwh_1k is not None and grid is not None:
+        co2_g = float(kwh_1k) * float(grid)
+
+    return EngineCost(
+        engine_key=key,
+        type=etype,
+        cost_per_1k_pages_eur=cost_eur,
+        currency=currency,
+        pricing_source_url=entry.get("pricing_source_url"),
+        pricing_date=entry.get("pricing_date"),
+        api_price_per_1k_pages=api_price,
+        local_mean_seconds_per_page=local_seconds,
+        hourly_rate_eur=hourly_rate,
+        kwh_per_1k_pages=float(kwh_1k) if kwh_1k is not None else None,
+        grid_intensity_g_co2_per_kwh=float(grid) if grid is not None else None,
+        co2_per_1k_pages_g=co2_g,
+        notes=notes,
+        assumptions=assumptions,
+    )
+
+
+def build_costs_for_benchmark(
+    engines_summary: list[dict],
+    durations_by_engine: dict[str, float],
+    *,
+    hourly_rate_local_eur: Optional[float] = None,
+    pricing_path: Optional[Path] = None,
+) -> dict[str, dict]:
+    """Calcule le coût de chaque moteur d'un benchmark.
+
+    Returns
+    -------
+    dict ``{engine_name: EngineCost.as_dict()}``.
+    """
+    defaults, table = load_pricing_database(pricing_path)
+    out: dict[str, dict] = {}
+    for e in engines_summary:
+        name = e.get("name")
+        if not name:
+            continue
+        measured = durations_by_engine.get(name)
+        llm_model = None
+        pipeline_info = e.get("pipeline_info") or {}
+        if pipeline_info:
+            llm_model = pipeline_info.get("llm_model")
+        cost = estimate_cost(
+            engine_name=name,
+            llm_model=llm_model,
+            is_pipeline=bool(e.get("is_pipeline")),
+            measured_seconds_per_page=measured,
+            table=table,
+            defaults=defaults,
+            hourly_rate_override_eur=hourly_rate_local_eur,
+        )
+        out[name] = cost.as_dict()
+    return out

picarones/core/statistics.py

@@ -8,6 +8,7 @@ Fonctions fournies
 - friedman_test(engine_cer_map)        : Friedman (k moteurs, n documents)       [Sprint 17]
 - nemenyi_posthoc(engine_cer_map)      : post-hoc Nemenyi avec critical distance [Sprint 17]
 - build_critical_difference_svg(...)   : rendu SVG du CDD (Demšar 2006)          [Sprint 17]
+- compute_pareto_front(points, ...)    : frontière de Pareto multi-objectifs     [Sprint 19]
 - cluster_errors(...)                  : regroupement des patterns d'erreurs
 - compute_correlation_matrix(...)      : matrice de corrélation des métriques
 - compute_reliability_curve(...)       : courbe CER vs. % docs les plus faciles
@@ -757,6 +758,85 @@ def _svg_escape(text: str) -> str:
                 .replace("'", "'"))
 
 
+# ---------------------------------------------------------------------------
+# Frontière de Pareto (Sprint 19)
+# ---------------------------------------------------------------------------
+
+def compute_pareto_front(
+    points: list[dict],
+    objectives: tuple[str, ...] = ("cer", "cost"),
+    name_key: str = "engine",
+    minimize: Optional[tuple[bool, ...]] = None,
+) -> list[str]:
+    """Calcule la frontière de Pareto sur ``len(objectives)`` dimensions.
+
+    Un point ``p`` est Pareto-dominant si aucun autre point n'a, pour TOUS
+    les objectifs, une valeur au moins aussi bonne ET au moins une valeur
+    strictement meilleure.
+
+    Parameters
+    ----------
+    points:
+        Liste de dicts. Chaque dict doit contenir ``name_key`` et toutes les
+        clés de ``objectives``. Les points dont une valeur d'objectif est
+        ``None`` sont ignorés (pas de comparaison possible).
+    objectives:
+        Clés des objectifs à minimiser/maximiser.
+    name_key:
+        Clé identifiant le point (par défaut ``"engine"``).
+    minimize:
+        Pour chaque objectif, ``True`` = minimiser (ex. CER, coût),
+        ``False`` = maximiser (ex. ancrage). Doit avoir la même longueur
+        que ``objectives``.
+
+    Returns
+    -------
+    Liste des ``name`` des points sur le front Pareto, ordre stable depuis
+    ``points``.
+    """
+    if minimize is None:
+        minimize = tuple(True for _ in objectives)
+    if len(minimize) != len(objectives):
+        raise ValueError("`minimize` doit avoir la même longueur que `objectives`")
+
+    valid = []
+    for p in points:
+        try:
+            vals = tuple(float(p[k]) for k in objectives)
+        except (KeyError, TypeError, ValueError):
+            continue
+        valid.append((p[name_key], vals))
+
+    front: list[str] = []
+    for name_a, vals_a in valid:
+        dominated = False
+        for name_b, vals_b in valid:
+            if name_a == name_b:
+                continue
+            # B domine A si B est ≥ aussi bon partout ET strictement meilleur quelque part
+            better_or_equal_everywhere = True
+            strictly_better_somewhere = False
+            for va, vb, mini in zip(vals_a, vals_b, minimize):
+                if mini:
+                    if vb > va:
+                        better_or_equal_everywhere = False
+                        break
+                    if vb < va:
+                        strictly_better_somewhere = True
+                else:  # maximiser
+                    if vb < va:
+                        better_or_equal_everywhere = False
+                        break
+                    if vb > va:
+                        strictly_better_somewhere = True
+            if better_or_equal_everywhere and strictly_better_somewhere:
+                dominated = True
+                break
+        if not dominated:
+            front.append(name_a)
+    return front
+
+
 # ---------------------------------------------------------------------------
 # Clustering des patterns d'erreurs
 # ---------------------------------------------------------------------------

picarones/data/pricing.yaml

@@ -0,0 +1,136 @@
+# Base de prix indicative des moteurs OCR/HTR et des LLM utilisés dans les
+# pipelines OCR+LLM. Sert uniquement à la vue Pareto coût/qualité du rapport.
+#
+# AVERTISSEMENT
+# -------------
+# Ces prix sont des estimations datées et vieillissent vite. Ils sont donnés
+# à titre indicatif et ne remplacent pas une négociation commerciale ou un
+# relevé sur facture. Toute institution menant un benchmark avec un budget
+# réel doit surcharger ces valeurs via ``ReportGenerator(..., pricing=...)``.
+#
+# CONVENTIONS
+# -----------
+# - Unité monétaire : EUR (conversion indicative depuis USD quand applicable)
+# - Prix exprimé par 1000 pages traitées (1 page = 1 document moyen patrimonial,
+#   environ 1 500 caractères ou ~2 000 tokens LLM).
+# - kWh par 1000 pages : estimation énergétique pour le calcul carbone optionnel.
+# - Intensité carbone du réseau (g CO2 / kWh) : dépend du mix électrique de la
+#   région où le moteur est exécuté (France ≈ 58, US moyen ≈ 400, Irlande ≈ 350).
+#
+# CATÉGORIES
+# ----------
+# - ``type: local`` : moteur open-source tournant sur machine de l'utilisateur.
+#   Coût effectif = temps d'inférence × taux horaire paramétré.
+# - ``type: cloud_api`` : service facturé à la page ou au token.
+
+meta:
+  last_updated: "2026-04-01"
+  currency: EUR
+  default_hourly_rate_local_cpu_eur: 0.08  # machine locale amortie
+  default_hourly_rate_local_gpu_eur: 1.20  # g4dn.xlarge ou équivalent
+  default_grid_intensity_g_co2_per_kwh: 58  # France 2025 (mix bas carbone)
+  cloud_grid_intensity_g_co2_per_kwh: 380    # moyenne cloud hyperscalers
+
+engines:
+  # ── OCR classiques locaux ─────────────────────────────────────────
+  tesseract:
+    type: local
+    local_mean_seconds_per_page: 2.0
+    kwh_per_1k_pages: 0.012
+    notes: "Open-source, CPU uniquement. Rapide mais moins précis sur écriture manuscrite."
+
+  pero_ocr:
+    type: local
+    local_mean_seconds_per_page: 18.0
+    kwh_per_1k_pages: 0.300
+    hourly_rate_override_eur: 1.20  # GPU
+    notes: "HTR deep learning, GPU recommandé. Best-in-class sur documents historiques."
+
+  kraken:
+    type: local
+    local_mean_seconds_per_page: 8.0
+    kwh_per_1k_pages: 0.150
+    hourly_rate_override_eur: 1.20
+    notes: "HTR open-source, GPU recommandé. Modèles pré-entraînés via HTR-United."
+
+  calamari:
+    type: local
+    local_mean_seconds_per_page: 6.0
+    kwh_per_1k_pages: 0.100
+    hourly_rate_override_eur: 1.20
+
+  # ── APIs OCR cloud ────────────────────────────────────────────────
+  mistral_ocr:
+    type: cloud_api
+    api_price_per_1k_pages: 0.90  # ≈ 0.001 USD / page, endpoint /v1/ocr dédié
+    pricing_source_url: "https://mistral.ai/pricing"
+    pricing_date: "2026-01"
+    kwh_per_1k_pages: 0.120
+    notes: "Endpoint /v1/ocr dédié (pas chat/completions)."
+
+  google_vision:
+    type: cloud_api
+    api_price_per_1k_pages: 1.40  # Document Text Detection, 1-1000 = $1.50/1k
+    pricing_source_url: "https://cloud.google.com/vision/pricing"
+    pricing_date: "2026-01"
+    kwh_per_1k_pages: 0.120
+
+  azure_doc_intel:
+    type: cloud_api
+    api_price_per_1k_pages: 9.50  # Read S1 tier
+    pricing_source_url: "https://azure.microsoft.com/pricing/details/ai-document-intelligence/"
+    pricing_date: "2026-01"
+    kwh_per_1k_pages: 0.120
+
+  # ── LLM pour pipelines OCR+LLM ────────────────────────────────────
+  # Estimation par page : prompt ~500 tokens + réponse ~1500 tokens = 2k tokens.
+  # Les VLM consomment en plus des tokens image (~1k tokens pour une page A4).
+  "gpt-4o":
+    type: cloud_api
+    api_price_per_1k_pages: 7.50  # approx 2.5k tokens text + 1k image
+    pricing_source_url: "https://openai.com/api/pricing/"
+    pricing_date: "2026-01"
+    kwh_per_1k_pages: 0.200
+
+  "gpt-4o-mini":
+    type: cloud_api
+    api_price_per_1k_pages: 0.45
+    pricing_source_url: "https://openai.com/api/pricing/"
+    pricing_date: "2026-01"
+    kwh_per_1k_pages: 0.060
+
+  "claude-sonnet-4-6":
+    type: cloud_api
+    api_price_per_1k_pages: 6.00
+    pricing_source_url: "https://www.anthropic.com/pricing"
+    pricing_date: "2026-01"
+    kwh_per_1k_pages: 0.180
+
+  "claude-haiku-4-5":
+    type: cloud_api
+    api_price_per_1k_pages: 0.80
+    pricing_source_url: "https://www.anthropic.com/pricing"
+    pricing_date: "2026-01"
+    kwh_per_1k_pages: 0.070
+
+  "mistral-large-latest":
+    type: cloud_api
+    api_price_per_1k_pages: 2.40
+    pricing_source_url: "https://mistral.ai/pricing"
+    pricing_date: "2026-01"
+    kwh_per_1k_pages: 0.150
+
+  "ministral-3b-latest":
+    type: cloud_api
+    api_price_per_1k_pages: 0.08
+    pricing_source_url: "https://mistral.ai/pricing"
+    pricing_date: "2026-01"
+    kwh_per_1k_pages: 0.040
+    notes: "Text-only, ne supporte pas le mode multimodal."
+
+  "pixtral-large-latest":
+    type: cloud_api
+    api_price_per_1k_pages: 3.00
+    pricing_source_url: "https://mistral.ai/pricing"
+    pricing_date: "2026-01"
+    kwh_per_1k_pages: 0.170

picarones/report/generator.py

@@ -47,7 +47,9 @@ from picarones.core.statistics import (
     friedman_test,
     nemenyi_posthoc,
     build_critical_difference_svg,
+    compute_pareto_front,
 )
+from picarones.core.pricing import build_costs_for_benchmark, load_pricing_database
 from picarones.core.difficulty import compute_all_difficulties, difficulty_label
 
 
@@ -439,6 +441,88 @@ def _build_report_data(benchmark: BenchmarkResult, images_b64: dict[str, str]) -
                 "is_pipeline": report.is_pipeline,
             })
 
+    # ── Sprint 19 — Coûts et frontière de Pareto ────────────────────────
+    # Durée moyenne mesurée par moteur sur le benchmark courant (sec/page)
+    durations_by_engine: dict[str, float] = {}
+    for report in benchmark.engine_reports:
+        durs = [dr.duration_seconds for dr in report.document_results
+                if dr.duration_seconds is not None]
+        if durs:
+            durations_by_engine[report.engine_name] = sum(durs) / len(durs)
+
+    pricing_defaults, _ = load_pricing_database()
+    costs_by_engine = build_costs_for_benchmark(
+        engines_summary, durations_by_engine,
+    )
+    # Annoter chaque résumé moteur avec son coût et sa durée
+    for entry in engines_summary:
+        name = entry["name"]
+        entry["mean_duration_seconds"] = round(durations_by_engine.get(name, 0.0), 4) \
+            if name in durations_by_engine else None
+        entry["cost"] = costs_by_engine.get(name)
+
+    # Front Pareto sur (CER moyen, coût €/1000 pages) — moteurs avec les deux dispos
+    pareto_points = []
+    for entry in engines_summary:
+        cer = entry.get("cer")
+        cost = (entry.get("cost") or {}).get("cost_per_1k_pages_eur")
+        if cer is None or cost is None:
+            continue
+        pareto_points.append({"engine": entry["name"], "cer": cer, "cost": cost})
+    pareto_front_engines = compute_pareto_front(
+        pareto_points, objectives=("cer", "cost"),
+    )
+
+    # Front Pareto secondaire (CER, vitesse) pour le toggle "vitesse"
+    pareto_speed_points = []
+    for entry in engines_summary:
+        cer = entry.get("cer")
+        dur = entry.get("mean_duration_seconds")
+        if cer is None or dur is None:
+            continue
+        pareto_speed_points.append({"engine": entry["name"], "cer": cer, "dur": dur})
+    pareto_front_speed = compute_pareto_front(
+        pareto_speed_points, objectives=("cer", "dur"),
+    )
+
+    # Front Pareto carbone (CER, g CO2 / 1000 pages) — étiqueté expérimental
+    pareto_co2_points = []
+    for entry in engines_summary:
+        cer = entry.get("cer")
+        co2 = (entry.get("cost") or {}).get("co2_per_1k_pages_g")
+        if cer is None or co2 is None:
+            continue
+        pareto_co2_points.append({"engine": entry["name"], "cer": cer, "co2": co2})
+    pareto_front_co2 = compute_pareto_front(
+        pareto_co2_points, objectives=("cer", "co2"),
+    )
+
+    pareto_data = {
+        "cost": {
+            "points": pareto_points,
+            "front": pareto_front_engines,
+            "axis_label": "Coût (€ / 1000 pages)",
+        },
+        "speed": {
+            "points": pareto_speed_points,
+            "front": pareto_front_speed,
+            "axis_label": "Temps moyen (s / page)",
+        },
+        "co2": {
+            "points": pareto_co2_points,
+            "front": pareto_front_co2,
+            "axis_label": "Empreinte carbone (g CO₂ / 1000 pages, expérimental)",
+        },
+        "pricing_meta": {
+            "last_updated": pricing_defaults.last_updated,
+            "currency": pricing_defaults.currency,
+            "hourly_rate_local_cpu_eur": pricing_defaults.hourly_rate_local_cpu_eur,
+            "hourly_rate_local_gpu_eur": pricing_defaults.hourly_rate_local_gpu_eur,
+            "grid_intensity_local": pricing_defaults.grid_intensity_local,
+            "grid_intensity_cloud": pricing_defaults.grid_intensity_cloud,
+        },
+    }
+
     # Scatter 2 : ratio longueur vs score d'ancrage (moteurs)
     ratio_vs_anchor = []
     for report in benchmark.engine_reports:
@@ -478,6 +562,8 @@ def _build_report_data(benchmark: BenchmarkResult, images_b64: dict[str, str]) -
         # Sprint 10
         "gini_vs_cer": gini_vs_cer,
         "ratio_vs_anchor": ratio_vs_anchor,
+        # Sprint 19 — vue Pareto coût/qualité avec variantes d'axe
+        "pareto": pareto_data,
     }
 
 

picarones/report/i18n/en.json

@@ -65,6 +65,7 @@
   "h_image": "Original Image",
   "h_line_metrics": "Error Distribution by Line",
   "h_pairwise": "Wilcoxon Tests — pairwise comparisons",
+  "h_pareto": "Quality / cost trade-off",
   "h_quality_cer": "Image Quality ↔ CER (scatter plot)",
   "h_radar": "Engine Profile (radar)",
   "h_ranking": "Engine Ranking",
@@ -90,6 +91,14 @@
   "no_line_metrics": "No line metrics available.",
   "no_scatter": "Data not available.",
   "pairwise_note": "Wilcoxon signed-rank test (non-parametric). Threshold α = 0.05.",
+  "pareto_assumptions_summary": "Detailed assumptions per engine",
+  "pareto_axis_co2": "Carbon (g CO₂)",
+  "pareto_axis_cost": "Cost € / 1000 pages",
+  "pareto_axis_speed": "Speed (s / page)",
+  "pareto_dominated_label": "Dominated",
+  "pareto_empty": "Not enough data for this view.",
+  "pareto_front_label": "Pareto front",
+  "pareto_note": "Engines on the Pareto front (highlighted) are those for which no other engine offers simultaneously a better CER AND a better cost. Prices are indicative (internal table, dated). Carbon mode is experimental.",
   "percentile_title": "CER PERCENTILES",
   "proportion_col": "Proportion",
   "quality_cer_note": "Each point = one document. X-axis = image quality score [0–1]. Y-axis = CER. Negative correlation expected.",

picarones/report/i18n/fr.json

@@ -65,6 +65,7 @@
   "h_image": "Image originale",
   "h_line_metrics": "Distribution des erreurs par ligne",
   "h_pairwise": "Tests de Wilcoxon — comparaisons par paires",
+  "h_pareto": "Compromis qualité / coût",
   "h_quality_cer": "Qualité image ↔ CER (scatter plot)",
   "h_radar": "Profil des moteurs (radar)",
   "h_ranking": "Classement des moteurs",
@@ -90,6 +91,14 @@
   "no_line_metrics": "Aucune métrique de ligne disponible.",
   "no_scatter": "Données non disponibles.",
   "pairwise_note": "Test signé-rangé de Wilcoxon (non-paramétrique). Seuil α = 0.05.",
+  "pareto_assumptions_summary": "Hypothèses détaillées par moteur",
+  "pareto_axis_co2": "Carbone (g CO₂)",
+  "pareto_axis_cost": "Coût € / 1000 pages",
+  "pareto_axis_speed": "Vitesse (s / page)",
+  "pareto_dominated_label": "Dominés",
+  "pareto_empty": "Données insuffisantes pour cette vue.",
+  "pareto_front_label": "Front Pareto",
+  "pareto_note": "Les moteurs sur la frontière de Pareto (en évidence) sont ceux pour lesquels aucun autre moteur n'offre simultanément un meilleur CER ET un meilleur coût. Prix indicatifs (table interne, datée). Le mode carbone est expérimental.",
   "percentile_title": "PERCENTILES CER",
   "proportion_col": "Proportion",
   "quality_cer_note": "Chaque point = un document. Axe X = score qualité image [0–1]. Axe Y = CER. Corrélation négative attendue.",

picarones/report/templates/_app.js

@@ -1704,6 +1704,122 @@ function toggleCDDHelp() {
   el.hidden = !el.hidden;
 }
 
+// ── Sprint 19 — Vue Pareto coût/qualité ─────────────────────────
+let _paretoChart = null;
+let _paretoAxis = 'cost';
+
+function setParetoAxis(axis) {
+  _paretoAxis = axis;
+  document.querySelectorAll('.pareto-toggle').forEach(btn => {
+    btn.classList.toggle('active', btn.dataset.axis === axis);
+  });
+  renderParetoChart();
+  renderParetoAssumptions();
+}
+
+function _paretoAxisConfig(axis) {
+  const pareto = (DATA.pareto || {})[axis] || {};
+  const xKey = axis === 'cost' ? 'cost' : (axis === 'speed' ? 'dur' : 'co2');
+  const xLabel = pareto.axis_label ||
+    (I18N['pareto_axis_' + axis] || axis);
+  return { pareto, xKey, xLabel };
+}
+
+function renderParetoChart() {
+  const canvas = document.getElementById('pareto-chart');
+  if (!canvas || !window.Chart || !DATA.pareto) return;
+
+  const { pareto, xKey, xLabel } = _paretoAxisConfig(_paretoAxis);
+  const points = pareto.points || [];
+  const frontNames = new Set(pareto.front || []);
+
+  if (_paretoChart) { _paretoChart.destroy(); _paretoChart = null; }
+  if (points.length === 0) {
+    const ctx = canvas.getContext('2d');
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    ctx.fillStyle = '#64748b';
+    ctx.font = '13px system-ui, sans-serif';
+    ctx.fillText(I18N.pareto_empty || 'Données insuffisantes pour cette vue.', 10, 30);
+    return;
+  }
+
+  const frontPts = points.filter(p => frontNames.has(p.engine));
+  const otherPts = points.filter(p => !frontNames.has(p.engine));
+
+  _paretoChart = new Chart(canvas.getContext('2d'), {
+    type: 'scatter',
+    data: {
+      datasets: [
+        {
+          label: I18N.pareto_front_label || 'Front Pareto',
+          data: frontPts.map(p => ({ x: p[xKey], y: p.cer * 100, engine: p.engine })),
+          backgroundColor: '#16a34a',
+          borderColor: '#166534',
+          pointRadius: 8,
+          pointHoverRadius: 10,
+        },
+        {
+          label: I18N.pareto_dominated_label || 'Dominés',
+          data: otherPts.map(p => ({ x: p[xKey], y: p.cer * 100, engine: p.engine })),
+          backgroundColor: '#94a3b8',
+          borderColor: '#64748b',
+          pointRadius: 6,
+          pointHoverRadius: 8,
+        },
+      ],
+    },
+    options: {
+      responsive: true,
+      maintainAspectRatio: false,
+      plugins: {
+        legend: { position: 'bottom' },
+        tooltip: {
+          callbacks: {
+            label: ctx => {
+              const p = ctx.raw;
+              return p.engine + ' — CER ' + p.y.toFixed(2) + ' %, ' +
+                     xLabel + ' : ' + p.x.toFixed(2);
+            },
+          },
+        },
+      },
+      scales: {
+        x: {
+          type: _paretoAxis === 'cost' ? 'logarithmic' : 'linear',
+          title: { display: true, text: xLabel },
+        },
+        y: {
+          title: { display: true, text: I18N.col_cer || 'CER (%)' },
+          ticks: { callback: v => v + ' %' },
+        },
+      },
+    },
+  });
+}
+
+function renderParetoAssumptions() {
+  const ul = document.getElementById('pareto-assumptions-list');
+  if (!ul) return;
+  ul.innerHTML = '';
+  (DATA.engines || []).forEach(e => {
+    const c = e.cost || {};
+    const parts = [];
+    if (c.cost_per_1k_pages_eur != null) {
+      parts.push((c.cost_per_1k_pages_eur).toFixed(2) + ' €/1000 pages');
+    }
+    if (c.type) parts.push(c.type);
+    if (c.pricing_source_url) {
+      parts.push('<a href="' + c.pricing_source_url + '" target="_blank" rel="noopener">' +
+                 (c.pricing_date || 'source') + '</a>');
+    }
+    const assumptions = (c.assumptions || []).join(' ');
+    const li = document.createElement('li');
+    li.innerHTML = '<strong>' + e.name + '</strong> — ' + parts.join(' · ') +
+                   (assumptions ? ' <em>' + assumptions + '</em>' : '');
+    ul.appendChild(li);
+  });
+}
+
 // ── Sprint 7 — Mode présentation ────────────────────────────────
 let presentMode = false;
 function togglePresentMode() {
@@ -2071,6 +2187,8 @@ function init() {
   renderRobustMetrics();
   renderGallery();
   buildDocList();
+  renderParetoChart();
+  renderParetoAssumptions();
 
   // Restaurer l'état depuis l'URL
   const { view, params } = readURLState();

picarones/report/templates/_styles.css

@@ -669,3 +669,56 @@ body.present-mode .cdd-help { display: none !important; }
 .synth-list li::marker { color: #2563eb; }
 
 body.present-mode .synth-hint { display: none; }
+
+/* ── Sprint 19 — Vue Pareto coût/qualité ────────────────────── */
+.pareto-card {
+  border-left: 4px solid #16a34a;
+}
+.pareto-toolbar {
+  display: flex; gap: .5rem; flex-wrap: wrap;
+  margin: .5rem 0 .75rem;
+}
+.pareto-toggle {
+  border: 1px solid var(--border, #e2e8f0);
+  background: #fff;
+  padding: .35rem .75rem;
+  border-radius: 6px;
+  font-size: .82rem;
+  cursor: pointer;
+  color: var(--text, #0f172a);
+}
+.pareto-toggle:hover { background: #f1f5f9; }
+.pareto-toggle.active {
+  background: #16a34a; color: #fff; border-color: #166534;
+}
+.pareto-toggle.pareto-experimental::after {
+  content: " ⚗";
+  color: #f59e0b;
+  margin-left: .15rem;
+}
+.chart-canvas-wrap {
+  position: relative;
+  height: 360px;
+}
+.pareto-note {
+  font-size: .75rem;
+  color: var(--text-muted, #64748b);
+  font-style: italic;
+  margin-top: .5rem;
+  line-height: 1.4;
+}
+.pareto-assumptions {
+  margin-top: .5rem;
+  font-size: .78rem;
+  color: var(--text, #0f172a);
+}
+.pareto-assumptions summary {
+  cursor: pointer;
+  font-weight: 600;
+  color: var(--text-muted, #64748b);
+}
+.pareto-assumptions ul {
+  margin: .4rem 0 0;
+  padding-left: 1.1rem;
+}
+.pareto-assumptions li { margin: .2rem 0; line-height: 1.4; }

picarones/report/templates/view_analyses.html

@@ -125,6 +125,31 @@
       </div>
     </div>
 
+    <!-- Sprint 19 — Vue Pareto coût/qualité ────────────────────────── -->
+    <div class="chart-card pareto-card" style="grid-column:1/-1">
+      <h3 data-i18n="h_pareto">Compromis qualité / coût</h3>
+      <div class="pareto-toolbar">
+        <button class="pareto-toggle active" data-axis="cost" onclick="setParetoAxis('cost')"
+                data-i18n="pareto_axis_cost">Coût € / 1000 pages</button>
+        <button class="pareto-toggle" data-axis="speed" onclick="setParetoAxis('speed')"
+                data-i18n="pareto_axis_speed">Vitesse (s / page)</button>
+        <button class="pareto-toggle pareto-experimental" data-axis="co2"
+                onclick="setParetoAxis('co2')" data-i18n="pareto_axis_co2"
+                title="Estimation expérimentale">Carbone (g CO₂)</button>
+      </div>
+      <div class="chart-canvas-wrap"><canvas id="pareto-chart"></canvas></div>
+      <div id="pareto-method-note" class="pareto-note" data-i18n="pareto_note">
+        Les moteurs sur la frontière de Pareto (en évidence) sont ceux pour
+        lesquels aucun autre moteur n'offre simultanément un meilleur CER ET
+        un meilleur coût. Prix indicatifs (table interne, datée). Le mode
+        carbone est expérimental.
+      </div>
+      <details class="pareto-assumptions">
+        <summary data-i18n="pareto_assumptions_summary">Hypothèses détaillées par moteur</summary>
+        <ul id="pareto-assumptions-list"></ul>
+      </details>
+    </div>
+
     <!-- Sprint 7 — Matrice de corrélation -->
     <div class="chart-card technical" style="grid-column:1/-1">
       <h3 data-i18n="h_correlation">Matrice de corrélation entre métriques</h3>

pyproject.toml

@@ -87,6 +87,7 @@ picarones = [
     "report/templates/*.js",
     "report/i18n/*.json",
     "core/narrative/templates/*.yaml",
+    "data/*.yaml",
 ]
 
 [tool.pytest.ini_options]

tests/test_sprint20_pareto_pricing.py

@@ -0,0 +1,371 @@
+"""Tests Sprint 20 — modélisation coût + vue Pareto.
+
+Sprint 5 du plan rapport. Couvre :
+  1. `pricing.py` : chargement de la table, estimation locale vs cloud.
+  2. `compute_pareto_front` : cas canoniques + dégénérés.
+  3. Intégration `_build_report_data` : coût annoté, front calculé, JSON ok.
+  4. Détecteurs narratifs `pareto_alternative` et `cost_outlier`.
+  5. Rendu HTML : section Pareto, toggles axes, notes méthodologiques.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import pytest
+
+from picarones.core.narrative import build_synthesis
+from picarones.core.narrative.detectors import (
+    detect_cost_outlier,
+    detect_pareto_alternative,
+)
+from picarones.core.narrative.facts import FactType
+from picarones.core.pricing import (
+    EngineCost,
+    build_costs_for_benchmark,
+    estimate_cost,
+    load_pricing_database,
+)
+from picarones.core.statistics import compute_pareto_front
+
+
+# ---------------------------------------------------------------------------
+# 1. Pricing
+# ---------------------------------------------------------------------------
+
+class TestLoadPricingDatabase:
+    def test_default_file_loads(self):
+        defaults, table = load_pricing_database()
+        assert defaults.currency == "EUR"
+        assert defaults.last_updated  # doit être rempli
+        assert "tesseract" in table
+        assert "gpt-4o" in table
+        assert "google_vision" in table
+
+    def test_missing_file_returns_empty(self, tmp_path):
+        missing = tmp_path / "nope.yaml"
+        defaults, table = load_pricing_database(missing)
+        assert table == {}
+        assert defaults.currency == "EUR"  # fallback
+
+
+class TestEstimateCost:
+    def test_cloud_api_uses_listed_price(self):
+        cost = estimate_cost("google_vision")
+        assert cost.type == "cloud_api"
+        assert cost.cost_per_1k_pages_eur > 0
+        assert cost.pricing_source_url is not None
+        assert cost.api_price_per_1k_pages == cost.cost_per_1k_pages_eur
+
+    def test_local_engine_uses_seconds_times_rate(self):
+        cost = estimate_cost("tesseract")
+        assert cost.type == "local"
+        # 2s/page × 1000 pages / 3600 × 0.08 €/h ≈ 0.044 €
+        assert cost.cost_per_1k_pages_eur == pytest.approx(0.044, abs=0.01)
+        assert "Temps d'inférence" in " ".join(cost.assumptions)
+
+    def test_measured_seconds_override_indicative(self):
+        cost = estimate_cost("tesseract", measured_seconds_per_page=10.0)
+        # Rate = 0.08 €/h → 10 × 1000 / 3600 × 0.08 ≈ 0.22 €
+        assert cost.cost_per_1k_pages_eur == pytest.approx(0.222, abs=0.01)
+        assert "mesuré" in " ".join(cost.assumptions)
+
+    def test_pipeline_prefers_llm_model(self):
+        cost = estimate_cost(
+            engine_name="tesseract → gpt-4o",
+            llm_model="gpt-4o",
+            is_pipeline=True,
+        )
+        assert cost.engine_key == "gpt-4o"
+        assert cost.type == "cloud_api"
+
+    def test_unknown_engine_returns_unknown_type(self):
+        cost = estimate_cost("totally-not-a-real-engine")
+        assert cost.type == "unknown"
+        assert cost.cost_per_1k_pages_eur is None
+        assert "Aucune entrée" in " ".join(cost.assumptions)
+
+    def test_hourly_rate_override(self):
+        cheap = estimate_cost("tesseract", hourly_rate_override_eur=0.01)
+        expensive = estimate_cost("tesseract", hourly_rate_override_eur=10.0)
+        assert expensive.cost_per_1k_pages_eur > cheap.cost_per_1k_pages_eur
+
+    def test_carbon_estimate_computed(self):
+        cost = estimate_cost("gpt-4o")
+        assert cost.co2_per_1k_pages_g is not None
+        assert cost.co2_per_1k_pages_g > 0
+        # kWh × grid intensity → positive et cohérent
+        expected = cost.kwh_per_1k_pages * cost.grid_intensity_g_co2_per_kwh
+        assert cost.co2_per_1k_pages_g == pytest.approx(expected)
+
+
+class TestBuildCostsForBenchmark:
+    def test_annotates_all_engines(self):
+        engines = [
+            {"name": "tesseract", "is_pipeline": False, "pipeline_info": {}},
+            {"name": "pipeline", "is_pipeline": True,
+             "pipeline_info": {"llm_model": "gpt-4o"}},
+        ]
+        durations = {"tesseract": 1.5, "pipeline": 12.0}
+        costs = build_costs_for_benchmark(engines, durations)
+        assert "tesseract" in costs
+        assert "pipeline" in costs
+        assert costs["tesseract"]["type"] == "local"
+        assert costs["pipeline"]["type"] == "cloud_api"
+
+
+# ---------------------------------------------------------------------------
+# 2. Pareto
+# ---------------------------------------------------------------------------
+
+class TestComputeParetoFront:
+    def test_trivial_front(self):
+        points = [
+            {"engine": "A", "cer": 0.05, "cost": 1.0},  # meilleur CER
+            {"engine": "B", "cer": 0.10, "cost": 0.1},  # meilleur coût
+            {"engine": "C", "cer": 0.08, "cost": 2.0},  # dominé par A
+        ]
+        front = compute_pareto_front(points)
+        assert set(front) == {"A", "B"}
+
+    def test_empty_input(self):
+        assert compute_pareto_front([]) == []
+
+    def test_single_point_is_its_own_front(self):
+        assert compute_pareto_front([{"engine": "X", "cer": 0.1, "cost": 1.0}]) == ["X"]
+
+    def test_skips_points_with_missing_values(self):
+        points = [
+            {"engine": "A", "cer": 0.05, "cost": 1.0},
+            {"engine": "B", "cost": 0.5},  # pas de cer
+            {"engine": "C", "cer": 0.10},  # pas de cost
+        ]
+        front = compute_pareto_front(points)
+        assert front == ["A"]
+
+    def test_three_dimensional_front(self):
+        # 3 objectifs à minimiser — vérifie que le détecteur marche à k>2
+        points = [
+            {"name": "A", "a": 1, "b": 10, "c": 100},  # meilleur en a
+            {"name": "B", "a": 10, "b": 1, "c": 100},  # meilleur en b
+            {"name": "C", "a": 10, "b": 10, "c": 1},   # meilleur en c
+            {"name": "D", "a": 20, "b": 20, "c": 200}, # dominé partout
+        ]
+        front = compute_pareto_front(
+            points, objectives=("a", "b", "c"), name_key="name",
+        )
+        assert set(front) == {"A", "B", "C"}
+        assert "D" not in front
+
+    def test_mixed_min_max(self):
+        # Minimiser CER, maximiser ancrage
+        points = [
+            {"engine": "A", "cer": 0.05, "anchor": 0.95},  # meilleur partout
+            {"engine": "B", "cer": 0.10, "anchor": 0.85},  # dominé
+            {"engine": "C", "cer": 0.08, "anchor": 0.99},  # meilleur anchor
+        ]
+        front = compute_pareto_front(
+            points,
+            objectives=("cer", "anchor"),
+            minimize=(True, False),
+        )
+        assert set(front) == {"A", "C"}
+
+    def test_minimize_length_mismatch_raises(self):
+        with pytest.raises(ValueError):
+            compute_pareto_front([{"engine": "A", "cer": 0.1, "cost": 1.0}],
+                                 objectives=("cer", "cost"),
+                                 minimize=(True,))
+
+
+# ---------------------------------------------------------------------------
+# 3. Détecteurs narratifs Pareto / cost
+# ---------------------------------------------------------------------------
+
+def _pareto_data(cost_points, front=None, speed_points=None, co2_points=None):
+    return {
+        "ranking": [{"engine": p["engine"], "mean_cer": p["cer"],
+                     "documents": 10, "failed": 0} for p in cost_points],
+        "pareto": {
+            "cost": {"points": cost_points, "front": front or [p["engine"] for p in cost_points]},
+            "speed": {"points": speed_points or [], "front": []},
+            "co2": {"points": co2_points or [], "front": []},
+        },
+    }
+
+
+class TestDetectParetoAlternative:
+    def test_emits_when_alt_is_cheaper(self):
+        data = _pareto_data(
+            [
+                {"engine": "best", "cer": 0.02, "cost": 5.0},
+                {"engine": "cheap", "cer": 0.04, "cost": 0.1},
+                {"engine": "dominated", "cer": 0.05, "cost": 3.0},
+            ],
+            front=["best", "cheap"],
+        )
+        # Forcer "best" comme leader
+        data["ranking"] = [
+            {"engine": "best", "mean_cer": 0.02, "documents": 10, "failed": 0},
+            {"engine": "cheap", "mean_cer": 0.04, "documents": 10, "failed": 0},
+            {"engine": "dominated", "mean_cer": 0.05, "documents": 10, "failed": 0},
+        ]
+        facts = detect_pareto_alternative(data)
+        assert len(facts) == 1
+        assert facts[0].payload["engine"] == "cheap"
+        assert facts[0].payload["leader"] == "best"
+        assert facts[0].payload["cost_saving_ratio"] >= 10
+
+    def test_empty_when_front_has_only_leader(self):
+        data = _pareto_data(
+            [{"engine": "best", "cer": 0.02, "cost": 5.0}],
+            front=["best"],
+        )
+        assert detect_pareto_alternative(data) == []
+
+    def test_empty_when_no_pareto_section(self):
+        assert detect_pareto_alternative({}) == []
+
+
+class TestDetectCostOutlier:
+    def test_flags_expensive_dominated_engine(self):
+        data = _pareto_data(
+            [
+                {"engine": "cheap", "cer": 0.05, "cost": 0.1},
+                {"engine": "normal", "cer": 0.08, "cost": 1.0},
+                {"engine": "expensive_bad", "cer": 0.15, "cost": 20.0},
+            ],
+            front=["cheap"],
+        )
+        facts = detect_cost_outlier(data)
+        assert any(f.payload["engine"] == "expensive_bad" for f in facts)
+
+    def test_does_not_flag_expensive_on_front(self):
+        # Un moteur cher mais sur le front = coût justifié par qualité unique
+        data = _pareto_data(
+            [
+                {"engine": "cheap", "cer": 0.30, "cost": 0.1},
+                {"engine": "normal", "cer": 0.15, "cost": 1.0},
+                {"engine": "expensive_best", "cer": 0.02, "cost": 20.0},
+            ],
+            front=["cheap", "expensive_best"],
+        )
+        facts = detect_cost_outlier(data)
+        names = {f.payload["engine"] for f in facts}
+        assert "expensive_best" not in names
+
+
+# ---------------------------------------------------------------------------
+# 4. Intégration rapport HTML
+# ---------------------------------------------------------------------------
+
+@pytest.fixture(scope="module")
+def benchmark_result():
+    from picarones import fixtures
+    return fixtures.generate_sample_benchmark(n_docs=8)
+
+
+class TestReportIntegration:
+    def test_report_contains_pareto_card(self, benchmark_result, tmp_path):
+        from picarones.report.generator import ReportGenerator
+        out = tmp_path / "report.html"
+        ReportGenerator(benchmark_result).generate(out)
+        html = out.read_text(encoding="utf-8")
+        assert 'class="chart-card pareto-card"' in html
+        assert 'id="pareto-chart"' in html
+        assert 'setParetoAxis(\'cost\')' in html
+        assert 'setParetoAxis(\'speed\')' in html
+        assert 'setParetoAxis(\'co2\')' in html
+        assert "pareto-experimental" in html  # étiquette expérimental
+
+    def test_report_json_contains_pareto_data(self, benchmark_result):
+        from picarones.report.generator import _build_report_data
+        data = _build_report_data(benchmark_result, images_b64={})
+        pareto = data.get("pareto", {})
+        assert "cost" in pareto
+        assert "speed" in pareto
+        assert "co2" in pareto
+        assert "pricing_meta" in pareto
+        # Les moteurs doivent porter leur champ cost
+        for e in data["engines"]:
+            assert "cost" in e, f"Moteur {e.get('name')} sans champ cost"
+
+    def test_synthesis_may_include_pareto_sentence(self, benchmark_result, tmp_path):
+        # Sur la fixture de démo, pero_ocr + tesseract sont sur le front → la
+        # synthèse doit remonter une alternative moins chère
+        from picarones.report.generator import ReportGenerator
+        out = tmp_path / "report.html"
+        ReportGenerator(benchmark_result).generate(out)
+        html = out.read_text(encoding="utf-8")
+        m = re.search(r'<ul class="synth-list">(.*?)</ul>', html, re.DOTALL)
+        assert m
+        ul_content = m.group(1)
+        # On n'exige pas "compromis" en dur (dépend de l'i18n) — simplement
+        # qu'un moteur et "€" apparaissent (signe que pareto_alternative a tiré)
+        assert "€" in ul_content or "pero_ocr" in ul_content
+
+    def test_pricing_yaml_is_packaged(self):
+        """Garde-fou : le YAML doit être accessible depuis le package."""
+        from picarones.core.pricing import _DEFAULT_PRICING_PATH
+        assert Path(_DEFAULT_PRICING_PATH).exists()
+
+    def test_english_locale_renders_pareto_labels(self, benchmark_result, tmp_path):
+        from picarones.report.generator import ReportGenerator
+        out = tmp_path / "report_en.html"
+        ReportGenerator(benchmark_result, lang="en").generate(out)
+        html = out.read_text(encoding="utf-8")
+        assert 'data-i18n="h_pareto"' in html
+        assert 'data-i18n="pareto_axis_cost"' in html
+
+
+# ---------------------------------------------------------------------------
+# 5. Traçabilité des nombres (anti-hallucination pour les 2 nouveaux templates)
+# ---------------------------------------------------------------------------
+
+class TestAntiHallucinationOnPareto:
+    def test_pareto_alternative_numbers_traceable(self):
+        data = _pareto_data(
+            [
+                {"engine": "A", "cer": 0.02, "cost": 5.0},
+                {"engine": "B", "cer": 0.04, "cost": 0.25},
+            ],
+            front=["A", "B"],
+        )
+        data["ranking"] = [
+            {"engine": "A", "mean_cer": 0.02, "documents": 10, "failed": 0},
+            {"engine": "B", "mean_cer": 0.04, "documents": 10, "failed": 0},
+        ]
+        # Autres infos requises par build_synthesis
+        data.setdefault("meta", {"document_count": 10})
+        data.setdefault("engines", [
+            {"name": "A", "cer": 0.02},
+            {"name": "B", "cer": 0.04},
+        ])
+        data.setdefault("statistics", {
+            "pairwise_wilcoxon": [], "bootstrap_cis": [],
+            "friedman": {}, "nemenyi": {"tied_groups": [], "mean_ranks": {}},
+        })
+        data.setdefault("documents", [])
+
+        result = build_synthesis(data, "fr")
+        # Chercher la phrase pareto
+        pareto_sentences = [s for s in result["sentences"] if "compromis" in s or "€" in s]
+        assert pareto_sentences
+        # Les nombres principaux doivent venir du payload : 4 (cer_pct=4), 0.25 (cost),
+        # 2 (leader_cer_pct=2), 5 (leader_cost), 20 (ratio=5/0.25)
+        facts_by_type = {f["type"]: f for f in result["facts"]}
+        assert FactType.PARETO_ALTERNATIVE.value in facts_by_type
+        payload = facts_by_type[FactType.PARETO_ALTERNATIVE.value]["payload"]
+        sentence = pareto_sentences[0]
+        for k in ("cost", "leader_cost", "cer_pct", "leader_cer_pct", "cost_saving_ratio"):
+            val = payload.get(k)
+            if val is None:
+                continue
+            # Au moins une représentation du nombre doit apparaître
+            variants = {str(val), str(float(val)), f"{float(val):.1f}", f"{float(val):.2f}"}
+            if val == int(val):
+                variants.add(str(int(val)))
+            assert any(v in sentence for v in variants), (
+                f"Valeur {k}={val} absente de la phrase : {sentence!r}"
+            )