feat(adapters): Phase B5 — TesseractAdapter expose ALTO XML natif

Phase B5 du chantier Option B (mai 2026). Tesseract sait nativement
produire un ALTO 4 via ``pytesseract.image_to_alto_xml`` ; cette
capacité est désormais exposable via le flag ``expose_alto`` du
TesseractAdapter.

**Premier adapter du repo à produire un Artifact ALTO_XML** — débloque
la valeur métier AltoView. Combiné avec l'infra B0-B4
(RunOrchestrator + ViewExecutor), un benchmark Tesseract avec
``expose_alto=True`` produit désormais des métriques ALTO documentaires
(``alto_validity``, ``alto_text_cer``, ``alto_text_wer``, etc.) en
plus du CER/WER plat.

picarones/adapters/ocr/tesseract.py
- ``ArtifactType.ALTO_XML`` ajouté au ``output_types`` (set maximal).
Le YAML PipelineSpec décide quels types sont effectivement
consommés.
- Nouveau kwarg constructeur ``expose_alto: bool = False``
(compat ascendante : pipelines existants intacts).
- Nouvelle méthode ``_extract_and_persist_alto`` :
* Appelle ``pytesseract.image_to_alto_xml(image, lang, config)``
avec les mêmes paramètres OCR que ``image_to_string``.
* Normalise bytes/str (selon version pytesseract).
* Validation structurelle via ``safe_parse_xml`` —
ALTO mal formé → warning + None retourné, OCR RAW_TEXT reste
valide.
* Persiste ``<stem>.<name>.alto.xml`` à côté du fichier texte
(cohérent avec le pattern ``write_confidences_sidecar``).
* Best-effort total : toute défaillance (Tesseract crash,
sortie vide, XML invalide, OS error) est dégradée en warning.

tests/adapters/ocr/test_tesseract_alto.py (nouveau, 11 tests + 1 live)
- TestExposeAltoFlag (4) : flag par défaut off, peut être activé,
ALTO_XML dans output_types maximal, RAW_TEXT/CONFIDENCES toujours
présents.
- TestExecuteNoAlto (1) : sans flag, ``image_to_alto_xml`` jamais
invoqué (pas de coût Tesseract additionnel).
- TestExecuteAltoEnabled (6) : ALTO produit, lang/config propagés,
crash tolérance, sortie vide skippée, XML mal formé rejeté,
str/bytes normalisés.
- TestExecuteAltoLive (@pytest .mark.live) : invocation Tesseract
réelle, validation que ``parse_alto`` accepte la sortie.
Skipped sans le binaire (-m live opt-in).

tests/adapters/ocr/test_sprint_a14_s30_tesseract_adapter.py
- ``test_output_types`` mis à jour pour le nouveau set maximal
(RAW_TEXT, CONFIDENCES, ALTO_XML).

Tesseract devient le premier adapter de la chaîne à produire un
ALTO ; les adapters cloud (Mistral OCR, Google Vision, Azure DI) et
Pero/Kraken/Calamari pourront suivre le même pattern dans des phases
ultérieures.

picarones/adapters/ocr/tesseract.py

@@ -105,12 +105,20 @@ class TesseractAdapter(BaseOCRAdapter):
     #: ``PipelineSpec`` choisit ceux qui sont effectivement consommés
     #: par les étapes en aval ; l'executor filtre la sortie de
     #: ``execute()`` sur ``step.output_types``.  Si l'utilisateur
-    #: désactive ``expose_confidences``, le YAML doit déclarer
-    #: ``output_types: [raw_text]`` (sinon la jonction sera vue par
-    #: l'aval comme manquant son input ``confidences``).
-    output_types = frozenset(
-        {ArtifactType.RAW_TEXT, ArtifactType.CONFIDENCES},
-    )
+    #: désactive ``expose_confidences`` ou ``expose_alto``, le YAML
+    #: doit déclarer ``output_types: [raw_text]`` (sinon la jonction
+    #: sera vue par l'aval comme manquant son input ``confidences`` /
+    #: ``alto_xml``).
+    #:
+    #: Phase B5 (mai 2026) — ``ALTO_XML`` ajouté au set maximal pour
+    #: permettre la production d'un ALTO natif via
+    #: ``pytesseract.image_to_alto_xml``.  Activé via le flag
+    #: ``expose_alto`` (off par défaut, compat ascendante).
+    output_types = frozenset({
+        ArtifactType.RAW_TEXT,
+        ArtifactType.CONFIDENCES,
+        ArtifactType.ALTO_XML,
+    })
     execution_mode = "cpu"
 
     def __init__(
@@ -122,6 +130,7 @@ class TesseractAdapter(BaseOCRAdapter):
         oem: int = 3,
         tesseract_cmd: str | None = None,
         expose_confidences: bool = True,
+        expose_alto: bool = False,
     ) -> None:
         if not name or not name.strip():
             raise OCRAdapterError(
@@ -155,6 +164,7 @@ class TesseractAdapter(BaseOCRAdapter):
         self._oem = oem
         self._tesseract_cmd = tesseract_cmd
         self._expose_confidences = expose_confidences
+        self._expose_alto = expose_alto
 
     @property
     def name(self) -> str:
@@ -164,6 +174,10 @@ class TesseractAdapter(BaseOCRAdapter):
     def expose_confidences(self) -> bool:
         return self._expose_confidences
 
+    @property
+    def expose_alto(self) -> bool:
+        return self._expose_alto
+
     @property
     def lang(self) -> str:
         return self._lang
@@ -278,6 +292,30 @@ class TesseractAdapter(BaseOCRAdapter):
             if confidences_artifact is not None:
                 outputs[ArtifactType.CONFIDENCES] = confidences_artifact
 
+        # Phase B5 — production ALTO XML natif (best-effort).
+        # Tesseract sait nativement produire un ALTO 4 via
+        # ``pytesseract.image_to_alto_xml``.  Désactivé par défaut
+        # (compat ascendante : les pipelines existants ne s'attendent
+        # pas à un artefact ALTO_XML).  Activer via le constructeur :
+        #
+        #     TesseractAdapter(expose_alto=True)
+        #
+        # ou en YAML (PipelineSpec) :
+        #
+        #     adapter_kwargs: {expose_alto: true}
+        #     output_types: [raw_text, alto_xml]
+        if self._expose_alto:
+            alto_artifact = self._extract_and_persist_alto(
+                image_path=image_path,
+                text_path=text_path,
+                pytesseract_module=pytesseract,
+                pil_image_class=Image,
+                custom_config=custom_config,
+                document_id=context.document_id,
+            )
+            if alto_artifact is not None:
+                outputs[ArtifactType.ALTO_XML] = alto_artifact
+
         return outputs
 
     def _extract_and_persist_confidences(
@@ -334,5 +372,108 @@ class TesseractAdapter(BaseOCRAdapter):
             extractor="tesseract",
         )
 
+    def _extract_and_persist_alto(
+        self,
+        *,
+        image_path: Path,
+        text_path: Path,
+        pytesseract_module,
+        pil_image_class,
+        custom_config: str,
+        document_id: str,
+    ) -> Artifact | None:
+        """Phase B5 — appelle ``image_to_alto_xml`` puis écrit
+        ``<stem>.<name>.alto.xml`` à côté du fichier texte.
+
+        Retourne l'``Artifact ALTO_XML`` ou ``None`` si l'extraction
+        échoue ou si la sortie n'est pas un ALTO valide (warning
+        loggé, OCR reste valide via ``RAW_TEXT``).
+
+        Validation
+        ----------
+        L'ALTO produit est passé par ``safe_parse_xml`` (résistance
+        XXE/billion-laughs) puis par ``parse_alto`` (vérifie qu'on a
+        bien au moins une page + un bloc de texte).  Si la
+        validation échoue, on log et on retourne ``None`` plutôt
+        que de produire un artefact corrompu en aval.
+        """
+        import logging
+        logger = logging.getLogger(__name__)
+
+        # Sortie attendue : str (ALTO XML 4).
+        try:
+            with pil_image_class.open(image_path) as image:
+                alto_xml = pytesseract_module.image_to_alto_xml(
+                    image,
+                    lang=self._lang,
+                    config=custom_config,
+                )
+        except Exception as exc:  # noqa: BLE001 — best-effort
+            logger.warning(
+                "[%s] image_to_alto_xml indisponible (%s) — ALTO "
+                "sauté pour ce document.", self._name, exc,
+            )
+            return None
+
+        # ``image_to_alto_xml`` retourne ``bytes`` selon la version de
+        # pytesseract.  On normalise vers une string UTF-8.
+        if isinstance(alto_xml, bytes):
+            try:
+                alto_xml = alto_xml.decode("utf-8")
+            except UnicodeDecodeError as exc:
+                logger.warning(
+                    "[%s] ALTO Tesseract non-UTF-8 (%s) — ALTO sauté.",
+                    self._name, exc,
+                )
+                return None
+
+        if not alto_xml or not alto_xml.strip():
+            logger.warning(
+                "[%s] ALTO Tesseract vide — ALTO sauté.", self._name,
+            )
+            return None
+
+        # Validation structurelle minimale (résistance XXE +
+        # confirmation que c'est bien un ALTO parsable).
+        # ``safe_parse_xml`` est volontairement tolérante : elle
+        # retourne ``None`` au lieu de lever sur les XML invalides.
+        # Pour rejeter proprement un ALTO mal formé, on traite ``None``
+        # comme un échec de validation.
+        try:
+            from picarones.formats._xml_utils import safe_parse_xml
+            parsed = safe_parse_xml(alto_xml.encode("utf-8"))
+        except Exception as exc:  # noqa: BLE001 — XML mal formé
+            logger.warning(
+                "[%s] ALTO Tesseract mal formé (%s) — ALTO sauté.",
+                self._name, exc,
+            )
+            return None
+        if parsed is None:
+            logger.warning(
+                "[%s] ALTO Tesseract non-parsable (safe_parse_xml a "
+                "retourné None) — ALTO sauté.", self._name,
+            )
+            return None
+
+        # Persistance à côté du fichier texte (cohérent avec
+        # ``write_confidences_sidecar`` : ``<stem>.<name>.alto.xml``).
+        alto_path = text_path.with_suffix(".alto.xml")
+        try:
+            alto_path.write_text(alto_xml, encoding="utf-8")
+        except OSError as exc:
+            logger.warning(
+                "[%s] ALTO non persisté (%s) — ALTO sauté.",
+                self._name, exc,
+            )
+            return None
+
+        return Artifact(
+            id=f"{document_id}:{self._name}:alto_xml",
+            document_id=document_id,
+            type=ArtifactType.ALTO_XML,
+            produced_by_step="ocr",
+            uri=str(alto_path),
+        )
+
 
 __all__ = ["TesseractAdapter"]

tests/adapters/ocr/test_sprint_a14_s30_tesseract_adapter.py

@@ -129,12 +129,18 @@ class TestTesseractAdapterContract:
 
     def test_output_types(self) -> None:
         """``output_types`` est l'ensemble maximal produit (constante de
-        classe).  Si ``expose_confidences=False``, l'execute() omet
-        CONFIDENCES du dict — le YAML ``PipelineSpec`` doit alors
-        déclarer seulement ``[raw_text]`` pour cohérence.
+        classe).  Si ``expose_confidences=False`` ou ``expose_alto=False``,
+        l'execute() omet le type correspondant — le YAML
+        ``PipelineSpec`` doit alors déclarer seulement les types
+        effectivement consommés pour cohérence.
+
+        Phase B5 (mai 2026) — ``ALTO_XML`` ajouté au set maximal pour
+        permettre la production d'un ALTO natif via
+        ``image_to_alto_xml`` (opt-in via ``expose_alto=True``).
         """
         assert TesseractAdapter.output_types == frozenset(
-            {ArtifactType.RAW_TEXT, ArtifactType.CONFIDENCES},
+            {ArtifactType.RAW_TEXT, ArtifactType.CONFIDENCES,
+             ArtifactType.ALTO_XML},
         )
 
     def test_execution_mode_is_cpu(self) -> None:

tests/adapters/ocr/test_tesseract_alto.py

@@ -0,0 +1,392 @@
+"""Phase B5 — production native ALTO XML par ``TesseractAdapter``.
+
+Tesseract sait nativement produire un ALTO 4 via
+``pytesseract.image_to_alto_xml``.  Ce test vérifie que :
+
+1. Le flag ``expose_alto`` (off par défaut, compat ascendante) ajoute
+   un ``Artifact ALTO_XML`` à la sortie d'``execute()``.
+2. La sortie est validée structurellement (XML bien formé) avant
+   d'être promue en artefact.
+3. Les défaillances (Tesseract qui plante, sortie vide, XML mal
+   formé) sont absorbées en warning sans casser l'OCR ``RAW_TEXT``.
+4. Un test ``@pytest.mark.live`` invoque le vrai binaire
+   ``tesseract`` et vérifie que l'ALTO produit est valide.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from picarones.adapters.ocr import TesseractAdapter
+from picarones.domain.artifacts import Artifact, ArtifactType
+from picarones.pipeline.types import RunContext
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Helpers
+# ──────────────────────────────────────────────────────────────────────
+
+
+_PNG_HEADER = b"\x89PNG\r\n\x1a\n"
+
+
+_ALTO_VALID = """<?xml version="1.0" encoding="UTF-8"?>
+<alto xmlns="http://www.loc.gov/standards/alto/ns-v4#">
+  <Layout>
+    <Page ID="page_1" PHYSICAL_IMG_NR="1" WIDTH="1000" HEIGHT="1500">
+      <PrintSpace ID="ps_1">
+        <TextBlock ID="block_1">
+          <TextLine ID="line_1">
+            <String ID="word_1" CONTENT="Bonjour"
+                    HPOS="100" VPOS="100" WIDTH="80" HEIGHT="20"/>
+            <String ID="word_2" CONTENT="monde"
+                    HPOS="200" VPOS="100" WIDTH="60" HEIGHT="20"/>
+          </TextLine>
+        </TextBlock>
+      </PrintSpace>
+    </Page>
+  </Layout>
+</alto>
+"""
+
+
+def _make_image_artifact(uri: str) -> Artifact:
+    return Artifact(
+        id="d1:initial:image",
+        document_id="d1",
+        type=ArtifactType.IMAGE,
+        uri=uri,
+    )
+
+
+def _make_context() -> RunContext:
+    return RunContext(
+        document_id="d1",
+        code_version="1.0.0",
+        pipeline_name="test",
+    )
+
+
+def _create_dummy_image(tmp_path: Path) -> Path:
+    path = tmp_path / "page.png"
+    path.write_bytes(_PNG_HEADER)
+    return path
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Constructeur
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestExposeAltoFlag:
+    def test_default_off(self) -> None:
+        """Compat ascendante : ``expose_alto`` est désactivé par défaut.
+
+        Les pipelines existants qui consomment ``RAW_TEXT`` /
+        ``CONFIDENCES`` ne reçoivent aucun nouvel artefact non
+        sollicité.
+        """
+        adapter = TesseractAdapter()
+        assert adapter.expose_alto is False
+
+    def test_can_be_enabled(self) -> None:
+        adapter = TesseractAdapter(expose_alto=True)
+        assert adapter.expose_alto is True
+
+    def test_alto_xml_in_class_output_types(self) -> None:
+        """Phase B5 — ``ALTO_XML`` est dans le set maximal de
+        l'adapter (le YAML ``output_types`` du step décide quels
+        types l'aval consomme).
+        """
+        assert ArtifactType.ALTO_XML in TesseractAdapter.output_types
+
+    def test_default_output_still_includes_raw_text(self) -> None:
+        """Pas de régression : ``RAW_TEXT`` et ``CONFIDENCES`` restent
+        dans le set maximal."""
+        assert ArtifactType.RAW_TEXT in TesseractAdapter.output_types
+        assert ArtifactType.CONFIDENCES in TesseractAdapter.output_types
+
+
+# ──────────────────────────────────────────────────────────────────────
+# execute() — pas de production ALTO si expose_alto=False
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestExecuteNoAlto:
+    @patch("PIL.Image.open")
+    @patch("pytesseract.image_to_string")
+    @patch("pytesseract.image_to_alto_xml")
+    def test_alto_function_not_called_by_default(
+        self,
+        mock_image_to_alto: MagicMock,
+        mock_image_to_string: MagicMock,
+        mock_image_open: MagicMock,
+        tmp_path: Path,
+    ) -> None:
+        """Sans ``expose_alto``, ``pytesseract.image_to_alto_xml``
+        n'est jamais invoqué — pas de coût Tesseract additionnel."""
+        mock_image_to_string.return_value = "Bonjour le monde"
+        mock_image_open.return_value.__enter__.return_value = MagicMock()
+        adapter = TesseractAdapter(
+            expose_alto=False, expose_confidences=False,
+        )
+        image_path = _create_dummy_image(tmp_path)
+
+        result = adapter.execute(
+            inputs={ArtifactType.IMAGE: _make_image_artifact(str(image_path))},
+            params={}, context=_make_context(),
+        )
+
+        # ALTO absent du résultat.
+        assert ArtifactType.ALTO_XML not in result
+        # ``image_to_alto_xml`` jamais invoqué.
+        mock_image_to_alto.assert_not_called()
+
+
+# ──────────────────────────────────────────────────────────────────────
+# execute() — production ALTO quand expose_alto=True
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestExecuteAltoEnabled:
+    @patch("PIL.Image.open")
+    @patch("pytesseract.image_to_string")
+    @patch("pytesseract.image_to_alto_xml")
+    def test_alto_artifact_produced(
+        self,
+        mock_image_to_alto: MagicMock,
+        mock_image_to_string: MagicMock,
+        mock_image_open: MagicMock,
+        tmp_path: Path,
+    ) -> None:
+        """Avec ``expose_alto=True``, un ``Artifact ALTO_XML`` est
+        produit en plus du ``RAW_TEXT``."""
+        mock_image_to_string.return_value = "Bonjour monde"
+        mock_image_to_alto.return_value = _ALTO_VALID.encode("utf-8")
+        mock_image_open.return_value.__enter__.return_value = MagicMock()
+
+        adapter = TesseractAdapter(
+            expose_alto=True, expose_confidences=False,
+        )
+        image_path = _create_dummy_image(tmp_path)
+
+        result = adapter.execute(
+            inputs={ArtifactType.IMAGE: _make_image_artifact(str(image_path))},
+            params={}, context=_make_context(),
+        )
+
+        assert ArtifactType.ALTO_XML in result
+        alto_artifact = result[ArtifactType.ALTO_XML]
+        assert alto_artifact.type == ArtifactType.ALTO_XML
+        assert alto_artifact.uri is not None
+        # Le fichier ALTO existe et contient l'XML retourné par Tesseract.
+        alto_path = Path(alto_artifact.uri)
+        assert alto_path.exists()
+        assert alto_path.suffix == ".xml"
+        assert "alto" in alto_path.name.lower()
+        assert "Bonjour" in alto_path.read_text(encoding="utf-8")
+
+    @patch("PIL.Image.open")
+    @patch("pytesseract.image_to_string")
+    @patch("pytesseract.image_to_alto_xml")
+    def test_alto_called_with_correct_lang_and_config(
+        self,
+        mock_image_to_alto: MagicMock,
+        mock_image_to_string: MagicMock,
+        mock_image_open: MagicMock,
+        tmp_path: Path,
+    ) -> None:
+        """``image_to_alto_xml`` reçoit les mêmes ``lang``/``config``
+        que ``image_to_string`` — cohérence des paramètres OCR."""
+        mock_image_to_string.return_value = "x"
+        mock_image_to_alto.return_value = _ALTO_VALID.encode("utf-8")
+        mock_image_open.return_value.__enter__.return_value = MagicMock()
+
+        adapter = TesseractAdapter(
+            lang="lat", psm=4, oem=1,
+            expose_alto=True, expose_confidences=False,
+        )
+        image_path = _create_dummy_image(tmp_path)
+        adapter.execute(
+            inputs={ArtifactType.IMAGE: _make_image_artifact(str(image_path))},
+            params={}, context=_make_context(),
+        )
+
+        # Vérification que image_to_alto_xml a été invoqué avec
+        # la bonne langue et la bonne config.
+        assert mock_image_to_alto.call_count == 1
+        kwargs = mock_image_to_alto.call_args.kwargs
+        assert kwargs["lang"] == "lat"
+        assert kwargs["config"] == "--oem 1 --psm 4"
+
+    @patch("PIL.Image.open")
+    @patch("pytesseract.image_to_string")
+    @patch("pytesseract.image_to_alto_xml")
+    def test_alto_failure_does_not_break_raw_text(
+        self,
+        mock_image_to_alto: MagicMock,
+        mock_image_to_string: MagicMock,
+        mock_image_open: MagicMock,
+        tmp_path: Path,
+    ) -> None:
+        """Si ``image_to_alto_xml`` lève une exception, l'OCR
+        ``RAW_TEXT`` reste valide — l'ALTO est juste sauté avec
+        un warning loggé.
+        """
+        mock_image_to_string.return_value = "Bonjour"
+        mock_image_to_alto.side_effect = RuntimeError("Tesseract ALTO crash")
+        mock_image_open.return_value.__enter__.return_value = MagicMock()
+
+        adapter = TesseractAdapter(
+            expose_alto=True, expose_confidences=False,
+        )
+        image_path = _create_dummy_image(tmp_path)
+        result = adapter.execute(
+            inputs={ArtifactType.IMAGE: _make_image_artifact(str(image_path))},
+            params={}, context=_make_context(),
+        )
+
+        # RAW_TEXT toujours présent.
+        assert ArtifactType.RAW_TEXT in result
+        # ALTO absent (best-effort skip).
+        assert ArtifactType.ALTO_XML not in result
+
+    @patch("PIL.Image.open")
+    @patch("pytesseract.image_to_string")
+    @patch("pytesseract.image_to_alto_xml")
+    def test_alto_empty_output_skipped(
+        self,
+        mock_image_to_alto: MagicMock,
+        mock_image_to_string: MagicMock,
+        mock_image_open: MagicMock,
+        tmp_path: Path,
+    ) -> None:
+        """Un ALTO vide ou que des espaces n'est pas promu en artefact."""
+        mock_image_to_string.return_value = "x"
+        mock_image_to_alto.return_value = b""
+        mock_image_open.return_value.__enter__.return_value = MagicMock()
+
+        adapter = TesseractAdapter(
+            expose_alto=True, expose_confidences=False,
+        )
+        image_path = _create_dummy_image(tmp_path)
+        result = adapter.execute(
+            inputs={ArtifactType.IMAGE: _make_image_artifact(str(image_path))},
+            params={}, context=_make_context(),
+        )
+
+        assert ArtifactType.ALTO_XML not in result
+
+    @patch("PIL.Image.open")
+    @patch("pytesseract.image_to_string")
+    @patch("pytesseract.image_to_alto_xml")
+    def test_alto_malformed_xml_skipped(
+        self,
+        mock_image_to_alto: MagicMock,
+        mock_image_to_string: MagicMock,
+        mock_image_open: MagicMock,
+        tmp_path: Path,
+    ) -> None:
+        """Un ALTO mal formé (balise non fermée, etc.) n'est pas promu
+        en artefact — la validation ``safe_parse_xml`` rejette."""
+        mock_image_to_string.return_value = "x"
+        # XML invalide : pas de balise root fermante.
+        mock_image_to_alto.return_value = b"<alto><Page></alto>"
+        mock_image_open.return_value.__enter__.return_value = MagicMock()
+
+        adapter = TesseractAdapter(
+            expose_alto=True, expose_confidences=False,
+        )
+        image_path = _create_dummy_image(tmp_path)
+        result = adapter.execute(
+            inputs={ArtifactType.IMAGE: _make_image_artifact(str(image_path))},
+            params={}, context=_make_context(),
+        )
+
+        assert ArtifactType.ALTO_XML not in result
+
+    @patch("PIL.Image.open")
+    @patch("pytesseract.image_to_string")
+    @patch("pytesseract.image_to_alto_xml")
+    def test_alto_string_output_normalized(
+        self,
+        mock_image_to_alto: MagicMock,
+        mock_image_to_string: MagicMock,
+        mock_image_open: MagicMock,
+        tmp_path: Path,
+    ) -> None:
+        """``pytesseract.image_to_alto_xml`` peut retourner un ``str``
+        au lieu de ``bytes`` selon la version — l'adapter doit gérer
+        les deux types."""
+        mock_image_to_string.return_value = "x"
+        mock_image_to_alto.return_value = _ALTO_VALID  # str, pas bytes
+        mock_image_open.return_value.__enter__.return_value = MagicMock()
+
+        adapter = TesseractAdapter(
+            expose_alto=True, expose_confidences=False,
+        )
+        image_path = _create_dummy_image(tmp_path)
+        result = adapter.execute(
+            inputs={ArtifactType.IMAGE: _make_image_artifact(str(image_path))},
+            params={}, context=_make_context(),
+        )
+
+        assert ArtifactType.ALTO_XML in result
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Test live — vraie exécution Tesseract
+# ──────────────────────────────────────────────────────────────────────
+
+
+@pytest.mark.live
+class TestExecuteAltoLive:
+    """Tests qui invoquent le vrai binaire ``tesseract``.
+
+    Activés uniquement avec ``pytest -m live``.  Skipped sans le
+    binaire (vérifié au fixture).
+    """
+
+    @pytest.fixture
+    def real_image(self, tmp_path: Path) -> Path:
+        """Crée une image PNG avec du texte rendu via Pillow.
+
+        Tesseract devrait être capable de transcrire ce texte.
+        """
+        from PIL import Image, ImageDraw
+
+        img = Image.new("RGB", (300, 80), color=(255, 255, 255))
+        d = ImageDraw.Draw(img)
+        d.text((10, 30), "Bonjour", fill=(0, 0, 0))
+        path = tmp_path / "live_page.png"
+        img.save(path)
+        return path
+
+    def test_real_tesseract_produces_valid_alto(
+        self, real_image: Path, tmp_path: Path,
+    ) -> None:
+        """Vrai Tesseract → ALTO XML structurellement valide."""
+        from picarones.formats.alto.parser import parse_alto
+
+        adapter = TesseractAdapter(
+            lang="eng", psm=7,
+            expose_alto=True, expose_confidences=False,
+        )
+
+        result = adapter.execute(
+            inputs={ArtifactType.IMAGE: _make_image_artifact(str(real_image))},
+            params={}, context=_make_context(),
+        )
+
+        assert ArtifactType.ALTO_XML in result, (
+            "Tesseract n'a pas produit d'ALTO — vérifier l'installation "
+            "tesseract + pytesseract."
+        )
+        alto_path = Path(result[ArtifactType.ALTO_XML].uri)
+        assert alto_path.exists()
+        # Le parser ALTO de Picarones doit accepter la sortie Tesseract.
+        parsed = parse_alto(alto_path.read_text(encoding="utf-8"))
+        assert parsed is not None