feat(sprint-C.1): découple runner.orchestration de OCRLLMPipeline

Sprint C.1 du plan v2.0 — préparation à la suppression du sous-package
``picarones/pipelines/`` (Sprint D). Le runner legacy reposait sur un
``isinstance(engine, OCRLLMPipeline)`` pour ajouter les
``pipeline_steps`` et le ``prompt_template`` à la metadata du
benchmark. Cette dépendance directe du runner vers
``picarones.pipelines`` est remplacée par un mécanisme polymorphe.

Modifications
-------------
- ``adapters/legacy_engines/base.py::BaseOCREngine`` : nouvel attribut
de classe ``is_pipeline: bool = False`` — un OCR seul n'est pas un
pipeline composé.
- ``pipelines/base.py::OCRLLMPipeline`` :
- Surcharge ``is_pipeline = True`` (marqueur polymorphe).
- Expose deux properties publiques :
- ``pipeline_steps_info`` (substitut public à
``_build_steps_info()``).
- ``prompt_template`` (substitut public à
``_prompt_template``).
L'API privée historique reste disponible pour ne pas casser les
callers internes encore en place ; elle disparaîtra avec
``OCRLLMPipeline`` en Sprint D.
- ``measurements/runner/orchestration.py`` :
- ``isinstance(engine, OCRLLMPipeline)`` →
``getattr(engine, "is_pipeline", False)``.
- ``engine._build_steps_info()`` → ``engine.pipeline_steps_info``.
- ``engine._prompt_template`` → ``engine.prompt_template``.
- Suppression de l'import paresseux ``from picarones.pipelines.base
import OCRLLMPipeline`` dans le runner.

Conséquences
------------
- Le sous-package ``picarones/measurements/runner/`` ne dépend plus
de ``picarones/pipelines/``. Une suite de tests sans
``picarones.pipelines`` installé pourra utiliser le runner legacy
sur des OCR seuls.
- Le runner reste compatible avec ``OCRLLMPipeline`` (qui a
``is_pipeline=True`` et expose les properties publiques) — pas de
régression sur les benchmarks OCR+LLM.
- Sprint D pourra supprimer ``picarones/pipelines/`` en une seule
passe sans toucher au runner.

Callers restants de ``OCRLLMPipeline`` (sortie de session) :

- ``picarones/web/benchmark_utils.py:131`` : instancie directement
``OCRLLMPipeline``. Migration possible quand le runner accepte
des ``PipelineSpec`` directement (Sprint D — runner →
``BenchmarkService``).
- ``picarones/pipelines/_executor_runner.py`` : helper interne
Sprint B, supprimé avec la classe en Sprint D.
- Les tests Sprint 3 et Sprint 15 instancient ``OCRLLMPipeline``
directement — réécrits en Sprint D.

Bilan
-----
- ``pytest tests/`` : 4758 passed, 0 failed.
- ``ruff check`` : clean.
- 3 fichiers modifiés (~25 lignes).
- 1 import legacy supprimé du runner.

https://claude.ai/code/session_011XQZNitg1rCgia8ZD1a2hP

picarones/adapters/legacy_engines/base.py

@@ -118,6 +118,13 @@ class BaseOCREngine(BaseModule):
     execution_mode: str = "io"
     """``"io"`` pour ThreadPoolExecutor (défaut), ``"cpu"`` pour ProcessPoolExecutor."""
 
+    #: ``True`` ssi l'engine est un pipeline composé (OCR+LLM ou VLM).
+    #: Sprint C du plan v2.0 : remplace le check legacy
+    #: ``isinstance(engine, OCRLLMPipeline)`` par un attribut polymorphe.
+    #: Les sous-classes "pipeline composé" (``OCRLLMPipeline``, et tout
+    #: futur composite) surchargent à ``True``.
+    is_pipeline: bool = False
+
     def __init__(self, config: Optional[dict] = None) -> None:
         self.config: dict = config or {}
         # Cache du dernier ``EngineResult`` produit par ``run()`` —

picarones/measurements/runner/orchestration.py

@@ -516,13 +516,13 @@ def _build_pipeline_info(engine: BaseOCREngine, doc_results: list[DocumentResult
         "llm_provider": meta.get("llm_provider"),
     }
 
-    try:
-        from picarones.pipelines.base import OCRLLMPipeline
-        if isinstance(engine, OCRLLMPipeline):
-            info["pipeline_steps"] = engine._build_steps_info()
-            info["prompt_template"] = engine._prompt_template
-    except ImportError:
-        pass
+    # Sprint C du plan v2.0 : duck typing via ``is_pipeline`` au lieu
+    # de ``isinstance(engine, OCRLLMPipeline)``.  Découple le runner
+    # legacy de la classe ``OCRLLMPipeline`` — préparation à la
+    # suppression du sous-package ``picarones.pipelines/`` (Sprint D).
+    if getattr(engine, "is_pipeline", False):
+        info["pipeline_steps"] = engine.pipeline_steps_info
+        info["prompt_template"] = engine.prompt_template
 
     over_norm_results = [
         dr.pipeline_metadata.get("over_normalization")

picarones/pipelines/base.py

@@ -130,6 +130,12 @@ class OCRLLMPipeline(BaseOCREngine):
     # Interface BaseOCREngine
     # ------------------------------------------------------------------
 
+    #: Sprint C du plan v2.0 : marqueur polymorphe que le runner
+    #: utilise pour ajouter ``pipeline_steps`` + ``prompt_template``
+    #: aux ``EngineReport.pipeline_info`` sans avoir à connaître le
+    #: type concret ``OCRLLMPipeline``.
+    is_pipeline: bool = True
+
     @property
     def name(self) -> str:
         return self._name
@@ -138,6 +144,21 @@ class OCRLLMPipeline(BaseOCREngine):
         ocr_v = self.ocr_engine._safe_version() if self.ocr_engine else "—"
         return f"ocr={ocr_v}; llm={self.llm_adapter.model}"
 
+    @property
+    def pipeline_steps_info(self) -> list[dict]:
+        """Description structurée des étapes (Sprint C — API publique).
+
+        Substitut public à ``_build_steps_info()`` pour les callers
+        externes (notamment le runner) qui ont besoin de connaître la
+        composition de la pipeline pour la metadata du rapport.
+        """
+        return self._build_steps_info()
+
+    @property
+    def prompt_template(self) -> str:
+        """Template de prompt courant (Sprint C — API publique)."""
+        return self._prompt_template
+
     def _run_llm_step(
         self, image_path: Path, ocr_text: str,
     ) -> tuple[str, Optional[str]]: