sprint47: Tesseract — exposition des token_confidences natifs

Premier des engines adaptés au câblage calibration du Sprint 42.
L'utilisateur qui benchmarke avec Tesseract obtient désormais
automatiquement ECE/MCE et reliability diagram dans le rapport, sans
configuration supplémentaire.

TesseractEngine.run() surchargé
- Appelle image_to_string pour le texte (rétrocompat octet par octet)
ET image_to_data pour les confidences mot par mot.
- Retourne EngineResult avec token_confidences = [{"token": str,
"confidence": float}, ...] (confidence ∈ [0, 100], le runner
Sprint 42 normalise en [0, 1]).
- Helper _extract_token_confidences séparé du chemin OCR principal :
si image_to_data lève, l'OCR continue normalement et
token_confidences = None (warning explicite, pas except: pass).
- Filtrage à la source : non-mots Tesseract (conf = -1), tokens
vides, longueurs incompatibles → ignorés.
- Nouveau paramètre config expose_confidences: false pour désactiver
le second appel Tesseract (économie d'un appel par image).

Coût additionnel : un appel image_to_data par image. Le texte
d'image_to_string n'est jamais reconstruit depuis image_to_data —
préservation stricte du comportement historique.

Tests : +9 dans test_sprint47_tesseract_confidences.py couvrant (avec
mock pytesseract) :
- exposition des token_confidences quand pytesseract présent
- préservation octet par octet du texte (rétrocompat)
- flag expose_confidences=False désactive le second appel
- fallback gracieux quand image_to_data lève (warning + None)
- échec d'image_to_string : OCR.error renseigné, pas de tentative
d'extraction
- filtrage des non-mots (conf = -1) et tokens vides
- format inattendu (longueurs incompatibles) → None
- intégration bout-en-bout avec _compute_document_result :
calibration_metrics calculée correctement
- pytesseract absent → None sans crash
Suite complète : 1864 → 1873 passed, 2 skipped, 0 failed.

Reste à adapter Pero, Mistral OCR, Google Vision et Azure DI sur le
même pattern.

CHANGELOG.md

@@ -16,6 +16,38 @@ La numérotation de version suit [Semantic Versioning](https://semver.org/lang/f
 
 ### Ajouté
 
+- **Sprint 47 — Adapter Tesseract : exposition des `token_confidences`
+  natifs.** Premier des engines adaptés au câblage calibration
+  (Sprint 42). L'utilisateur qui benchmarke avec Tesseract obtient
+  désormais automatiquement ECE/MCE et reliability diagram dans le
+  rapport, sans configuration supplémentaire.
+  - `TesseractEngine.run()` est surchargé : appelle `image_to_string`
+    pour le texte (rétrocompat octet par octet) **et** `image_to_data`
+    pour les confidences mot par mot, retourne un `EngineResult` avec
+    `token_confidences = [{"token": str, "confidence": float}, …]`
+    (confidence ∈ [0, 100], le runner Sprint 42 normalise en [0, 1]).
+  - Helper `_extract_token_confidences()` séparé du chemin OCR
+    principal : si `image_to_data` lève, l'OCR continue normalement
+    et `token_confidences = None` (warning explicite, pas
+    `except: pass`).
+  - Filtrage à la source : non-mots Tesseract (conf = -1), tokens
+    vides, longueurs incompatibles → ignorés.
+  - Nouveau paramètre config `expose_confidences: false` pour
+    désactiver le second appel Tesseract (économie d'un appel par
+    image en cas de besoin).
+  - Coût additionnel : un appel `image_to_data` par image. Le texte
+    de `image_to_string` n'est jamais reconstruit depuis
+    `image_to_data` — préservation stricte du comportement
+    historique.
+  - +9 tests dans `test_sprint47_tesseract_confidences.py` couvrant
+    l'exposition des confidences (avec mock pytesseract), la
+    préservation octet par octet du texte, le flag
+    `expose_confidences=False`, le fallback gracieux quand
+    `image_to_data` lève (warning + `None`), le filtrage des
+    non-mots/longueurs incompatibles, l'intégration bout-en-bout
+    avec le runner (`calibration_metrics` calculé), et le cas
+    pytesseract absent.
+
 - **Sprint 46 — A.III stratification par `script_type` : vue HTML +
   détecteur narratif (clôture A.III)**. Suite directe du Sprint 45
   (couche backend). La vue stratifiée est désormais rendue dans le
@@ -479,16 +511,18 @@ La numérotation de version suit [Semantic Versioning](https://semver.org/lang/f
 
 ### Tests
 
-- 1478 → 1864 tests (+17 Sprint 32, +23 Sprint 33, +21 Sprint 34,
+- 1478 → 1873 tests (+17 Sprint 32, +23 Sprint 33, +21 Sprint 34,
   +27 Sprint 35, +22 Sprint 36, +42 Sprint 37, +19 Sprint 38,
   +32 Sprint 39, +16 Sprint 40, +38 Sprint 41, +17 Sprint 42,
-  +43 Sprint 43, +15 Sprint 44, +16 Sprint 45, +38 Sprint 46).
-  Aucune régression. **Phase 0 close ; Étape 2 du plan d'évolution :
-  inter-moteurs (A.II.1.c), NER (A.II.1.a), calibration (A.II.1.b)
-  et stratification (A.III) livrés bout-en-bout calcul → runner →
-  HTML ; A.I.2 médiane par défaut livré (Sprint 44). Reste
-  l'adaptation effective des engines pour exposer leurs confidences
-  natives (un sprint par adapter).**
+  +43 Sprint 43, +15 Sprint 44, +16 Sprint 45, +38 Sprint 46,
+  +9 Sprint 47). Aucune régression. **Phase 0 close ; Étape 2 du
+  plan d'évolution : inter-moteurs (A.II.1.c), NER (A.II.1.a),
+  calibration (A.II.1.b) et stratification (A.III) livrés
+  bout-en-bout calcul → runner → HTML ; A.I.2 médiane par défaut
+  livré (Sprint 44) ; Tesseract adapté pour exposer ses
+  `token_confidences` natifs (Sprint 47, première brique de
+  l'adaptation engines). Reste à adapter Pero, Mistral OCR, Google
+  Vision et Azure DI (un sprint par adapter).**
 
 ---
 

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). |
+| 47 | **Sprint 16 du plan d'évolution 2026 — Étape 2 / adaptation engines : Tesseract expose ses `token_confidences` natifs**. Premier des engines adaptés au câblage calibration du Sprint 42. `TesseractEngine.run()` est surchargé : appelle `image_to_string` pour le texte (rétrocompat octet par octet) **et** `image_to_data` pour les confidences mot par mot, retourne un `EngineResult` avec `token_confidences = [{"token": str, "confidence": float}, …]` (confidence ∈ [0, 100], le runner Sprint 42 normalise en [0, 1]). Helper `_extract_token_confidences` séparé : si `image_to_data` lève, l'OCR continue et `token_confidences = None` (warning explicite). Filtrage à la source des non-mots Tesseract (conf = -1), tokens vides, longueurs incompatibles. Nouveau paramètre config `expose_confidences: false` pour désactiver le second appel. Coût additionnel : un appel `image_to_data` par image — le texte d'`image_to_string` n'est jamais reconstruit depuis `image_to_data` (préservation stricte du comportement historique). +9 tests dans `test_sprint47_tesseract_confidences.py` (mock pytesseract, exposition, rétrocompat texte, flag `expose_confidences=False`, fallback gracieux, filtrage, intégration runner). **Verrou levé** : un benchmark Tesseract produit désormais automatiquement ECE/MCE/reliability diagram dans le rapport, sans configuration. Reste Pero, Mistral OCR, Google Vision, Azure DI à adapter. |
 | 46 | **Sprint 15 du plan d'évolution 2026 — Étape 2 / axe A.III : vue HTML stratifiée + détecteur narratif (clôture A.III)**. Suite directe du Sprint 45 (couche backend). Nouveau module `picarones/report/stratification_render.py` : `build_stratified_ranking_html` rend un `<details>` natif (collapsible sans JS) par strate avec tableau moteur × (médiane, moyenne, docs), cellule médiane colorée par gradient vert→rouge, premier `<details>` ouvert par défaut, bandeau d'avertissement en tête si `corpus_homogeneity` fourni. `_build_report_data` expose `available_strata`/`stratified_ranking`/`corpus_homogeneity` au top-level ; `view_ranking.html` insère le bloc après le tableau principal **uniquement si stratification disponible**. Nouveau `FactType.STRATIFICATION_RECOMMENDED` (priority 45, importance MEDIUM ou HIGH selon le gap) + détecteur `detect_stratification_recommended` (seuil 5 points / 10 points de CER inter-strate). Templates FR/EN sans nombres en dur. L'arbitre marque la paire `{GLOBAL_LEADER_CER, STRATIFICATION_RECOMMENDED}` comme complémentaire. +8 clés i18n FR/EN. Anti-injection HTML via `html.escape`. +38 tests dans `test_sprint46_stratification_html.py`. **Verrou levé** : A.III (stratification) est désormais livré bout-en-bout — couche backend (Sprint 45) + vue HTML + détecteur narratif (Sprint 46) ; le lecteur du rapport voit immédiatement quand le corpus est hétérogène et est invité à consulter la vue stratifiée. |
 | 45 | **Sprint 14 du plan d'évolution 2026 — Étape 2 / axe A.III : stratification par `script_type` (couche backend)**. Première brique de la « plus haute valeur ajoutée transversale » du plan. `BenchmarkResult.doc_strata: Optional[dict[str, str]]` ajouté (map `{doc_id: script_type}` capturée par le runner avant `compact()` qui efface `image_quality`). Trois nouvelles méthodes : `available_strata()` (liste triée des strates distinctes, ignore les vides) ; `stratified_ranking()` qui retourne `{stratum: [ranking_entry]}` avec mean/median CER recalculés par strate, tri par médiane (Sprint 44), inclut les moteurs absents d'une strate sous forme d'entrée dégénérée (mean/median = None) ; `corpus_homogeneity()` qui pour le moteur leader global retourne l'écart inter-strate de la médiane CER et la paire min/max — base du futur avertissement « ce corpus est hétérogène ». `as_dict()` expose les nouveaux champs quand renseignés (rétrocompat stricte sinon). +16 tests dans `test_sprint45_stratification.py` couvrant champ, available_strata, stratified_ranking (1 entrée/moteur/strate, métriques per-strate, tri par médiane, moteurs absents), corpus_homogeneity, sérialisation, et un **test propriété réaliste** : le leader global peut perdre sur une strate (Tesseract domine globalement mais Pero gagne sur le manuscrit). **Verrou levé** : la couche d'agrégation par strate est en place ; la vue HTML stratifiée + toggle UI viendront dans un sprint dédié, et un détecteur narratif `STRATIFICATION_RECOMMENDED` peut maintenant lire `corpus_homogeneity()` pour suggérer la vue stratifiée. |
 | 44 | **Sprint 13 du plan d'évolution 2026 — Étape 2 / axe A.I.2 : tri par médiane par défaut + détecteur d'asymétrie**. Réponse à la critique structurelle 2 du plan : sur les corpus patrimoniaux, la moyenne est tirée par quelques documents catastrophiques et masque les performances réelles. `EngineReport.median_cer` ajouté (lit `aggregated_metrics["cer"]["median"]`). `BenchmarkResult.ranking()` inclut désormais `median_cer` dans chaque entrée et **trie par médiane CER croissante par défaut** (fallback sur `mean_cer` si médiane absente). Nouveau `FactType.MEDIAN_MEAN_GAP_WARNING` + détecteur `detect_median_mean_gap_warning` (priority 140) : émet un Fact quand `\|mean - median\| / median > 30 %` pour le moteur leader, importance HIGH si gap relatif ≥ 100 % (sinon MEDIUM). Garde-fou : ne déclenche pas si médiane nulle. Templates FR/EN sans nombres en dur (vérifié). L'arbitre marque la paire `{GLOBAL_LEADER_CER, MEDIAN_MEAN_GAP_WARNING}` comme **complémentaire** : les deux phrases peuvent coexister dans la synthèse pour nuancer le leader. +15 tests dans `test_sprint44_median_default.py` (propriété, tri sur cas asymétrique réaliste, fallback, déclenchement détecteur sur 4 cas dégénérés, importance, traçabilité anti-hallucination FR + EN, intégration build_synthesis). **Verrou levé** : la critique « le rapport classe sur la moyenne alors que les distributions patrimoniales sont asymétriques » est résolue ; le lecteur voit immédiatement le moteur le plus représentatif et est averti quand l'écart médiane/moyenne est suspect. |
@@ -264,7 +265,7 @@ au template `_narrative_summary.html` (placé entre `_header.html` et `_critical
 ## Contexte développement
 
 - **Environnement** : GitHub Codespaces (`/workspaces/Picarones`), Python 3.12
-- **Tests** : 1864 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)
+- **Tests** : 1873 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 ; Sprint 47 = Tesseract adapté pour confidences natives)
 - **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/engines/tesseract.py

@@ -2,10 +2,12 @@
 
 from __future__ import annotations
 
+import logging
+import time
 from pathlib import Path
-from typing import Optional
+from typing import Any, Optional
 
-from picarones.engines.base import BaseOCREngine
+from picarones.engines.base import BaseOCREngine, EngineResult
 
 try:
     import pytesseract
@@ -16,6 +18,9 @@ except ImportError:
     _PYTESSERACT_AVAILABLE = False
 
 
+logger = logging.getLogger(__name__)
+
+
 # Correspondance des valeurs PSM acceptées en argument YAML/CLI
 _PSM_LABELS = {
     0: "Orientation and script detection only",
@@ -47,7 +52,23 @@ class TesseractEngine(BaseOCREngine):
     psm: 6             # Page Segmentation Mode (0-13)
     oem: 3             # OCR Engine Mode (0=legacy, 3=LSTM, 3=default)
     tesseract_cmd: tesseract  # chemin vers l'exécutable si non standard
+    expose_confidences: true  # défaut ; mettre à false pour économiser
+                              # un appel image_to_data par document
     ```
+
+    Sprint 47 — exposition des token_confidences
+    --------------------------------------------
+    L'adapter appelle ``image_to_data`` en parallèle de
+    ``image_to_string`` pour produire ``EngineResult.token_confidences``
+    (liste de ``{"token": str, "confidence": float}``).  Le runner
+    Sprint 42 calcule alors automatiquement la calibration ECE/MCE.
+
+    Le texte ``EngineResult.text`` reste **strictement identique** à
+    celui produit par ``image_to_string`` (pas de reconstruction depuis
+    ``image_to_data``) — rétrocompatibilité octet par octet.
+
+    Le coût supplémentaire est d'un second appel Tesseract par image.
+    Pour le désactiver : ``expose_confidences: false`` dans la config.
     """
 
     execution_mode = "cpu"
@@ -61,6 +82,17 @@ class TesseractEngine(BaseOCREngine):
             raise RuntimeError("pytesseract n'est pas installé.")
         return pytesseract.get_tesseract_version().vstring
 
+    def _tesseract_args(self) -> tuple[str, str]:
+        """Retourne ``(lang, custom_config)`` selon la config courante.
+
+        Centralisé pour rester cohérent entre ``_run_ocr`` et
+        ``_extract_token_confidences``.
+        """
+        lang = self.config.get("lang", "fra")
+        psm = int(self.config.get("psm", 6))
+        oem = int(self.config.get("oem", 3))
+        return lang, f"--oem {oem} --psm {psm}"
+
     def _run_ocr(self, image_path: Path) -> str:
         if not _PYTESSERACT_AVAILABLE:
             raise RuntimeError(
@@ -73,16 +105,107 @@ class TesseractEngine(BaseOCREngine):
         if tesseract_cmd:
             pytesseract.pytesseract.tesseract_cmd = tesseract_cmd
 
-        lang = self.config.get("lang", "fra")
-        psm = int(self.config.get("psm", 6))
-        oem = int(self.config.get("oem", 3))
-
-        custom_config = f"--oem {oem} --psm {psm}"
+        lang, custom_config = self._tesseract_args()
 
         image = Image.open(image_path)
         text: str = pytesseract.image_to_string(image, lang=lang, config=custom_config)
         return text.strip()
 
+    def _extract_token_confidences(
+        self, image_path: Path,
+    ) -> Optional[list[dict[str, Any]]]:
+        """Extrait les confidences mot par mot via ``image_to_data``.
+
+        Retourne ``None`` quand pytesseract n'est pas disponible OU si
+        l'extraction échoue (best-effort — on ne casse pas l'OCR si
+        seule la calibration est indisponible).
+
+        Format de sortie compatible Sprint 42 : liste de dicts
+        ``{"token": str, "confidence": float}`` avec confidence ∈
+        [0, 100] (Tesseract).  Les non-mots (conf = -1) et tokens
+        vides sont ignorés.
+        """
+        if not _PYTESSERACT_AVAILABLE:
+            return None
+        if not self.config.get("expose_confidences", True):
+            return None
+
+        try:
+            tesseract_cmd = self.config.get("tesseract_cmd")
+            if tesseract_cmd:
+                pytesseract.pytesseract.tesseract_cmd = tesseract_cmd
+
+            lang, custom_config = self._tesseract_args()
+            image = Image.open(image_path)
+            data = pytesseract.image_to_data(
+                image,
+                lang=lang,
+                config=custom_config,
+                output_type=pytesseract.Output.DICT,
+            )
+        except Exception as exc:  # noqa: BLE001
+            logger.warning(
+                "[tesseract] extraction des token_confidences dégradée : %s",
+                exc,
+            )
+            return None
+
+        texts = data.get("text") or []
+        confs = data.get("conf") or []
+        if not texts or len(texts) != len(confs):
+            return None
+
+        out: list[dict[str, Any]] = []
+        for tok_text, conf in zip(texts, confs):
+            tok_text = (tok_text or "").strip()
+            if not tok_text:
+                continue
+            try:
+                conf_val = float(conf)
+            except (TypeError, ValueError):
+                continue
+            # Tesseract met -1 pour les segments non-mots ; le runner
+            # Sprint 42 les filtre aussi mais on les écarte ici pour
+            # éviter le bruit dans les diagnostics.
+            if conf_val < 0:
+                continue
+            out.append({"token": tok_text, "confidence": conf_val})
+        return out or None
+
+    def run(self, image_path: str | Path) -> EngineResult:
+        """Exécute Tesseract et expose les ``token_confidences`` natifs
+        (via ``image_to_data``) en plus du texte.
+
+        Surcharge du ``BaseOCREngine.run()`` (Sprint 33) qui ne
+        mettait pas de confidences.  On garde la mesure du temps et la
+        gestion des erreurs.  Si l'extraction des confidences échoue,
+        on retourne quand même le texte avec ``token_confidences =
+        None`` — le runner saute simplement le calcul de calibration
+        sur ce document.
+        """
+        image_path = Path(image_path)
+        start = time.perf_counter()
+        text = ""
+        error: Optional[str] = None
+        token_confidences: Optional[list[dict[str, Any]]] = None
+        try:
+            text = self._run_ocr(image_path)
+        except Exception as exc:  # noqa: BLE001
+            error = str(exc)
+        else:
+            # On n'extrait les confidences que si l'OCR de base a réussi
+            token_confidences = self._extract_token_confidences(image_path)
+        duration = time.perf_counter() - start
+        return EngineResult(
+            engine_name=self.name,
+            image_path=str(image_path),
+            text=text,
+            duration_seconds=round(duration, 4),
+            error=error,
+            metadata={"engine_version": self._safe_version()},
+            token_confidences=token_confidences,
+        )
+
     @classmethod
     def from_config(cls, config: Optional[dict] = None) -> "TesseractEngine":
         return cls(config=config or {})

tests/test_sprint47_tesseract_confidences.py

@@ -0,0 +1,293 @@
+"""Tests Sprint 47 — adaptation Tesseract pour exposer token_confidences.
+
+Couvre :
+
+1. ``run()`` retourne ``EngineResult.token_confidences`` non-vide
+   quand pytesseract est disponible et qu'``image_to_data`` produit
+   des confidences.
+2. Le ``text`` retourné reste **strictement identique** à ce que
+   produit ``image_to_string`` (rétrocompat octet par octet —
+   l'extraction des confidences n'altère jamais le texte).
+3. ``expose_confidences=False`` désactive l'extraction (économie
+   d'un appel Tesseract par image).
+4. Si ``image_to_data`` lève, l'OCR continue : ``text`` retourné,
+   ``token_confidences = None``, warning loggé.
+5. Les non-mots (conf = -1) et tokens vides sont filtrés.
+6. Les confidences passent le runner Sprint 42 et alimentent
+   ``DocumentResult.calibration_metrics``.
+7. Si pytesseract n'est pas installé, ``token_confidences = None``
+   sans crash (fallback gracieux).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+import picarones.engines.tesseract as tesseract_module
+from picarones.engines.tesseract import TesseractEngine
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Mocks
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class _MockPytesseract:
+    """Mock minimal de pytesseract qui simule une réponse réaliste."""
+
+    class Output:
+        DICT = "DICT"
+
+    class pytesseract:  # noqa: N801 (imite le namespace réel)
+        tesseract_cmd: str = "tesseract"
+
+    def __init__(
+        self,
+        text: str = "Bonjour le monde",
+        data: dict | None = None,
+        raise_on_data: bool = False,
+        raise_on_string: bool = False,
+    ) -> None:
+        self._text = text
+        self._data = data or {
+            "text": ["Bonjour", "le", "monde"],
+            "conf": [95.5, 88.0, 91.3],
+        }
+        self.raise_on_data = raise_on_data
+        self.raise_on_string = raise_on_string
+
+    def image_to_string(self, image, lang=None, config=None) -> str:
+        if self.raise_on_string:
+            raise RuntimeError("simulated OCR failure")
+        return self._text
+
+    def image_to_data(self, image, lang=None, config=None, output_type=None) -> dict:
+        if self.raise_on_data:
+            raise RuntimeError("simulated image_to_data failure")
+        return self._data
+
+    def get_tesseract_version(self):
+        class _V:
+            vstring = "5.0.0-mock"
+        return _V()
+
+
+class _MockImage:
+    @staticmethod
+    def open(path):
+        return object()  # placeholder
+
+
+@pytest.fixture
+def patched_tesseract(monkeypatch: pytest.MonkeyPatch) -> _MockPytesseract:
+    """Patche le module pour utiliser le mock."""
+    mock = _MockPytesseract()
+    monkeypatch.setattr(tesseract_module, "pytesseract", mock)
+    monkeypatch.setattr(tesseract_module, "Image", _MockImage)
+    monkeypatch.setattr(tesseract_module, "_PYTESSERACT_AVAILABLE", True)
+    return mock
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 1-2. run() expose token_confidences sans modifier le texte
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestRunExposesConfidences:
+    def test_run_returns_token_confidences(
+        self, patched_tesseract: _MockPytesseract, tmp_path: Path,
+    ) -> None:
+        img = tmp_path / "p.png"
+        img.write_bytes(b"x")
+        engine = TesseractEngine()
+        result = engine.run(img)
+
+        assert result.token_confidences is not None
+        assert len(result.token_confidences) == 3
+        assert result.token_confidences[0] == {
+            "token": "Bonjour", "confidence": pytest.approx(95.5),
+        }
+
+    def test_text_matches_image_to_string(
+        self, patched_tesseract: _MockPytesseract, tmp_path: Path,
+    ) -> None:
+        """Le texte de l'EngineResult doit être strictement celui de
+        image_to_string, pas une reconstruction depuis image_to_data."""
+        img = tmp_path / "p.png"
+        img.write_bytes(b"x")
+        engine = TesseractEngine()
+        result = engine.run(img)
+
+        assert result.text == "Bonjour le monde"
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 3. expose_confidences=False désactive
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestExposeConfidencesFlag:
+    def test_disabled_returns_no_confidences(
+        self, patched_tesseract: _MockPytesseract, tmp_path: Path,
+    ) -> None:
+        img = tmp_path / "p.png"
+        img.write_bytes(b"x")
+        engine = TesseractEngine(config={"expose_confidences": False})
+        result = engine.run(img)
+
+        assert result.text == "Bonjour le monde"
+        assert result.token_confidences is None
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 4. image_to_data échoue → fallback gracieux
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestExtractionFailureFallback:
+    def test_image_to_data_failure_returns_none_confidences(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path,
+        caplog: pytest.LogCaptureFixture,
+    ) -> None:
+        mock = _MockPytesseract(raise_on_data=True)
+        monkeypatch.setattr(tesseract_module, "pytesseract", mock)
+        monkeypatch.setattr(tesseract_module, "Image", _MockImage)
+        monkeypatch.setattr(tesseract_module, "_PYTESSERACT_AVAILABLE", True)
+
+        img = tmp_path / "p.png"
+        img.write_bytes(b"x")
+        engine = TesseractEngine()
+        with caplog.at_level("WARNING", logger="picarones.engines.tesseract"):
+            result = engine.run(img)
+
+        # OCR a réussi sur le texte
+        assert result.text == "Bonjour le monde"
+        assert result.error is None
+        # Mais les confidences sont None
+        assert result.token_confidences is None
+        # Et un warning explicite a été émis
+        assert any("token_confidences" in rec.message for rec in caplog.records)
+
+    def test_image_to_string_failure_keeps_error(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path,
+    ) -> None:
+        """Si l'OCR principal lève, on n'essaie même pas d'extraire les
+        confidences (cohérent avec le contrat de BaseOCREngine.run)."""
+        mock = _MockPytesseract(raise_on_string=True)
+        monkeypatch.setattr(tesseract_module, "pytesseract", mock)
+        monkeypatch.setattr(tesseract_module, "Image", _MockImage)
+        monkeypatch.setattr(tesseract_module, "_PYTESSERACT_AVAILABLE", True)
+
+        img = tmp_path / "p.png"
+        img.write_bytes(b"x")
+        engine = TesseractEngine()
+        result = engine.run(img)
+
+        assert result.error == "simulated OCR failure"
+        assert result.text == ""
+        assert result.token_confidences is None
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 5. Filtrage des non-mots et tokens vides
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestTokenFiltering:
+    def test_negative_conf_filtered(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path,
+    ) -> None:
+        mock = _MockPytesseract(
+            text="Bonjour monde",
+            data={
+                "text": ["Bonjour", "", "monde", "."],
+                "conf": [95.0, -1.0, 88.0, -1.0],
+            },
+        )
+        monkeypatch.setattr(tesseract_module, "pytesseract", mock)
+        monkeypatch.setattr(tesseract_module, "Image", _MockImage)
+        monkeypatch.setattr(tesseract_module, "_PYTESSERACT_AVAILABLE", True)
+
+        img = tmp_path / "p.png"
+        img.write_bytes(b"x")
+        engine = TesseractEngine()
+        result = engine.run(img)
+
+        assert result.token_confidences is not None
+        # Seuls "Bonjour" et "monde" sont retenus (conf > 0 et token non vide)
+        tokens = [tc["token"] for tc in result.token_confidences]
+        assert tokens == ["Bonjour", "monde"]
+
+    def test_mismatched_lengths_returns_none(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path,
+    ) -> None:
+        # text et conf de longueurs différentes → format inattendu
+        mock = _MockPytesseract(
+            text="Bonjour",
+            data={"text": ["Bonjour", "le"], "conf": [95.0]},
+        )
+        monkeypatch.setattr(tesseract_module, "pytesseract", mock)
+        monkeypatch.setattr(tesseract_module, "Image", _MockImage)
+        monkeypatch.setattr(tesseract_module, "_PYTESSERACT_AVAILABLE", True)
+
+        img = tmp_path / "p.png"
+        img.write_bytes(b"x")
+        engine = TesseractEngine()
+        result = engine.run(img)
+
+        assert result.token_confidences is None
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 6. Bout-en-bout avec le runner : calibration_metrics calculée
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestEndToEndWithRunner:
+    def test_runner_picks_up_confidences_and_computes_calibration(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path,
+    ) -> None:
+        from picarones.core.runner import _compute_document_result
+        from picarones.engines.base import EngineResult
+
+        # Simulation : on appelle directement _compute_document_result
+        # avec un EngineResult mocké qui porte des confidences. On
+        # vérifie que la calibration_metrics est bien attachée.
+        ocr = EngineResult(
+            engine_name="tess",
+            image_path="/tmp/x.png",
+            text="alpha beta gamma",
+            duration_seconds=0.1,
+            token_confidences=[
+                {"token": "alpha", "confidence": 95.0},
+                {"token": "beta",  "confidence": 95.0},
+                {"token": "gamma", "confidence": 95.0},
+            ],
+        )
+        dr = _compute_document_result(
+            doc_id="d1", image_path="/tmp/x.png",
+            ground_truth="alpha beta gamma",
+            ocr_result=ocr, char_exclude=None,
+        )
+        assert dr.calibration_metrics is not None
+        # 3 tokens, tous corrects → accuracy = 1, conf = 0.95
+        assert dr.calibration_metrics["overall_accuracy"] == 1.0
+        assert dr.calibration_metrics["overall_confidence"] == pytest.approx(0.95)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 7. pytesseract absent → fallback gracieux
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestPytesseractAbsent:
+    def test_extraction_returns_none_without_pytesseract(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path,
+    ) -> None:
+        monkeypatch.setattr(tesseract_module, "_PYTESSERACT_AVAILABLE", False)
+
+        engine = TesseractEngine()
+        result = engine._extract_token_confidences(tmp_path / "p.png")
+        assert result is None