feat(sprint-D.1.b): engine_to_pipeline_spec + build_adapter_resolver

Sprint D.1.b du plan v2.0 — deuxième brique de l'adapter de
compatibilité ``run_benchmark_via_service``. Pose le mapping
``BaseOCREngine`` → ``PipelineSpec`` et le adapter resolver qui
permettra à ``BenchmarkService`` de consommer des engines legacy.

Helpers ajoutés
---------------
- ``engine_to_pipeline_spec(engine)`` — produit la spec adaptée :
- **OCR seul** (``is_pipeline=False``) → spec mono-step
``IMAGE → RAW_TEXT`` avec ``adapter_name=engine.name``.
- **OCRLLMPipeline** (``is_pipeline=True``) → spec composée via
``make_ocr_llm_pipeline_spec`` (commit f894bf0) avec mode +
sous-OCR + LLM ; le ``prompt_template`` est passé en
``llm_params``.

- ``build_adapter_resolver(engines)`` — construit un
``Callable[[str], Any]`` consommable par ``PipelineExecutor`` :
- Pour un OCR simple : enregistre
``LegacyOCREngineExecutor(engine)`` sous ``engine.name``.
- Pour un ``OCRLLMPipeline`` : enregistre les deux
sous-composants (``ocr_engine`` wrappé + ``llm_adapter`` qui
est déjà un ``StepExecutor`` natif depuis Sprint A14-S44).
Le pipeline lui-même n'est pas enregistré directement —
sa spec référence ses sous-steps par leur ``adapter_name``.
- Lève ``PicaronesError`` si deux engines partagent le même
``name`` avec des instances différentes (collision).
- Lève ``KeyError`` à l'appel pour un nom inconnu.

Helpers privés
--------------
- ``_ocr_only_to_spec`` (mono-step IMAGE → RAW_TEXT).
- ``_ocr_llm_pipeline_to_spec`` (3 modes via le builder).
- ``_llm_adapter_name`` (format ``provider:model`` cohérent avec
Sprint B).
- ``_safe_pipeline_name`` (sanitise pour ``PipelineSpec.name``).

Architecture
------------
``test_layer_imports_are_legal[layer-app]`` : la couche ``app/``
ne peut pas importer ``picarones.pipelines.base`` (legacy).
``_ocr_llm_pipeline_to_spec`` consomme donc un
``OCRLLMPipeline`` exclusivement par **duck typing**
(``is_pipeline``, ``ocr_engine``, ``llm_adapter``, ``mode``,
``prompt_template``). Pas d'import direct.

``test_file_budgets`` : entrée ajoutée pour
``picarones/app/services/_legacy_runner_adapter.py`` (budget 575,
actuel 498). Module transitoire qui sera supprimé en D.6 avec
``measurements/runner/``.

Tests
-----
``tests/app/test_sprint_d_legacy_runner_adapter.py`` étendu de
13 nouveaux tests (29 au total) :

- ``TestEngineToPipelineSpec`` (5 tests) :
- OCR seul produit 1 step (``IMAGE`` → ``RAW_TEXT``).
- ``initial_inputs`` est ``(IMAGE,)``.
- Le nom de la spec est sanitisé (caractères safe).
- ``OCRLLMPipeline`` text_only produit 2 steps (OCR + LLM).
- ``OCRLLMPipeline`` zero_shot produit 1 step (VLM).

- ``TestBuildAdapterResolver`` (5 tests) :
- Engine simple résout son nom.
- Nom inconnu → ``KeyError``.
- Plusieurs engines coexistent.
- Collision de noms → ``PicaronesError``.
- Pipeline enregistre ses sous-composants (pas le pipeline lui-même).

- ``TestEngineSpecResolverIntegration`` (3 tests) :
- Tous les ``adapter_name`` de la spec produite par
``engine_to_pipeline_spec`` sont résolus par
``build_adapter_resolver([engine])``.

Bilan
-----
- ``pytest tests/`` : 4788 passed (+15), 0 failed.
- ``ruff check`` : clean.
- 1 module étendu (262 → 498 LOC), 1 test étendu (16 → 29 tests).

Sprint D.1.c — prochaine étape
-------------------------------
Conversion ``RunResult`` (rewrite) → ``BenchmarkResult`` (legacy).
Mapping :
- ``RunDocumentResult.pipeline_results`` × ``EvaluationView`` →
``EngineReport.document_results``.
- Calcul des métriques CER/WER via ``TextView`` rewrite.
- Reconstitution de ``EngineReport.aggregated_metrics`` et
``pipeline_info``.

https://claude.ai/code/session_011XQZNitg1rCgia8ZD1a2hP

CLAUDE.md

@@ -123,7 +123,7 @@ picarones/
 
 ## État des tests et bugs historiques
 
-`pytest tests/` → **4810 passed, 12 skipped, 8 deselected, 0 failed**
+`pytest tests/` → **4820 passed, 12 skipped, 8 deselected, 0 failed**
 (post-S59).  Les deselected sont les markers `live` (5 tests d'intégration
 contre vraie API/binaire) + `network` (3 tests qui hit le réseau réel),
 opt-in en local via `pytest -m live` ou `pytest -m network`.  Le
@@ -253,7 +253,7 @@ Résumé express :
 
 1. `git branch --show-current` → `claude/repo-analysis-cukvm`.
 2. `git status` → working tree clean.
-3. `pytest tests/ -q --no-header --tb=line` → 4810 passed.
+3. `pytest tests/ -q --no-header --tb=line` → 4820 passed.
 4. `git log -1 --format=%B` → décrit la prochaine sub-phase.
 
 **Règles d'architecture critiques** (apprises à la dure) :
@@ -341,7 +341,7 @@ détecte, arbitre, rend.
 ## Contexte développement
 
 - **Environnement** : GitHub Codespaces, Python 3.11+
-- **Tests** : `pytest tests/ -q` → 4810 passed, 12 skipped, 24
+- **Tests** : `pytest tests/ -q` → 4820 passed, 12 skipped, 24
   deselected, 0 failed (au moment de la pause de session).
 - **Plan d'évolution actif** : [`docs/roadmap/evolution-2026.md`](docs/roadmap/evolution-2026.md).
 - **Plan retrait du legacy (maître)** : [`docs/migration/legacy-retirement-plan.md`](docs/migration/legacy-retirement-plan.md).

README.md

@@ -395,7 +395,7 @@ ruff check picarones/ tests/
 python -m mypy picarones/core/
 ```
 
-**Test suite**: ~4810 tests, ~3 min on a modern laptop. Coverage
+**Test suite**: ~4820 tests, ~3 min on a modern laptop. Coverage
 floor at 85% (currently ~87%). The `network` marker excludes tests
 requiring live HTTP. A handful of tests depend on optional engines
 (`pero-ocr`, `pytesseract`) and are skipped/fail gracefully when

picarones/app/services/_legacy_runner_adapter.py

@@ -34,16 +34,32 @@ quand toutes les briques seront en place.
 from __future__ import annotations
 
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Callable
 
+from picarones.adapters.legacy_engines._step_executor import (
+    LegacyOCREngineExecutor,
+)
 from picarones.domain.artifacts import ArtifactType
 from picarones.domain.corpus import CorpusSpec
 from picarones.domain.documents import DocumentRef, GroundTruthRef
 from picarones.domain.errors import PicaronesError
+from picarones.domain.pipeline_spec import (
+    INITIAL_STEP_ID,
+    PipelineSpec,
+    PipelineStep,
+)
+from picarones.pipeline.llm_pipeline_builder import make_ocr_llm_pipeline_spec
 
 if TYPE_CHECKING:
+    from picarones.adapters.legacy_engines.base import BaseOCREngine
     from picarones.evaluation.corpus import Corpus, Document
 
+# Pas d'import direct de ``picarones.pipelines.base.OCRLLMPipeline`` ici —
+# l'invariant architectural ``test_layer_imports_are_legal[layer-app]``
+# interdit à ``app/`` de dépendre du legacy.  On consomme un
+# ``OCRLLMPipeline`` exclusivement par duck typing (``is_pipeline``,
+# ``ocr_engine``, ``llm_adapter``, ``mode``, ``prompt_template``).
+
 
 # ──────────────────────────────────────────────────────────────────────
 # Mapping Document (legacy) → DocumentRef (rewrite)
@@ -198,11 +214,191 @@ def corpus_to_corpus_spec(
     )
 
 
+# ──────────────────────────────────────────────────────────────────────
+# Mapping BaseOCREngine → PipelineSpec
+# ──────────────────────────────────────────────────────────────────────
+
+
+def engine_to_pipeline_spec(engine: "BaseOCREngine") -> PipelineSpec:
+    """Convertit un ``BaseOCREngine`` legacy en ``PipelineSpec`` rewrite.
+
+    Deux cas :
+
+    - **OCRLLMPipeline** (``engine.is_pipeline = True``) : la spec
+      composée est construite via ``make_ocr_llm_pipeline_spec``
+      avec le mode (``text_only`` / ``text_and_image`` /
+      ``zero_shot``), l'OCR amont (s'il existe), le LLM, et le
+      template de prompt en ``llm_params``.
+    - **OCR seul** : spec mono-step (IMAGE → RAW_TEXT).  Le step
+      référencera ``engine.name`` ; le caller l'enregistre dans
+      l'adapter resolver via un ``LegacyOCREngineExecutor(engine)``.
+
+    Parameters
+    ----------
+    engine:
+        Instance d'un sous-classe de ``BaseOCREngine`` (Tesseract,
+        Pero, Mistral OCR, Google Vision, Azure DI) ou un
+        ``OCRLLMPipeline``.
+
+    Returns
+    -------
+    PipelineSpec
+        Spec immutable consommable par ``BenchmarkService``.
+    """
+    if getattr(engine, "is_pipeline", False):
+        return _ocr_llm_pipeline_to_spec(engine)
+    return _ocr_only_to_spec(engine)
+
+
+def _ocr_only_to_spec(engine: "BaseOCREngine") -> PipelineSpec:
+    """Spec mono-step : un OCR simple consommant IMAGE et produisant RAW_TEXT."""
+    name = engine.name
+    safe_name = _safe_pipeline_name(name)
+    return PipelineSpec(
+        name=f"ocr_only_{safe_name}",
+        description=f"OCR step seul ({name}) — IMAGE → RAW_TEXT.",
+        initial_inputs=(ArtifactType.IMAGE,),
+        steps=(
+            PipelineStep(
+                id="ocr",
+                kind="ocr",
+                adapter_name=name,
+                input_types=(ArtifactType.IMAGE,),
+                output_types=(ArtifactType.RAW_TEXT,),
+                inputs_from={ArtifactType.IMAGE: INITIAL_STEP_ID},
+            ),
+        ),
+    )
+
+
+def _ocr_llm_pipeline_to_spec(pipeline: Any) -> PipelineSpec:
+    """Spec composée pour un ``OCRLLMPipeline`` (3 modes)."""
+    mode = pipeline.mode.value
+    llm_name = _llm_adapter_name(pipeline.llm_adapter)
+    llm_params: dict[str, str | int | float | bool] = {
+        "prompt_template": pipeline.prompt_template,
+    }
+    if mode == "zero_shot":
+        return make_ocr_llm_pipeline_spec(
+            mode="zero_shot",
+            llm_adapter_name=llm_name,
+            llm_params=llm_params,
+        )
+    if pipeline.ocr_engine is None:
+        raise PicaronesError(
+            f"OCRLLMPipeline mode {mode!r} requiert un ocr_engine — "
+            "valeur None inattendue.",
+        )
+    return make_ocr_llm_pipeline_spec(
+        mode=mode,
+        ocr_adapter_name=pipeline.ocr_engine.name,
+        llm_adapter_name=llm_name,
+        llm_params=llm_params,
+    )
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Adapter resolver
+# ──────────────────────────────────────────────────────────────────────
+
+
+def build_adapter_resolver(
+    engines: list["BaseOCREngine"],
+) -> Callable[[str], Any]:
+    """Construit un adapter resolver pour ``PipelineExecutor``.
+
+    Parcourt les engines fournis et associe leur ``name`` à un
+    ``StepExecutor`` valide :
+
+    - **OCR simple** (``BaseOCREngine``) → wrapped via
+      ``LegacyOCREngineExecutor`` (qui satisfait le contrat
+      ``StepExecutor``).
+    - **OCRLLMPipeline** → enregistre les deux sous-composants :
+      ``ocr_engine`` (wrapped) et ``llm_adapter`` (déjà
+      ``StepExecutor`` natif depuis Sprint A14-S44).  Le pipeline
+      lui-même n'est pas enregistré directement — sa spec
+      référence ses sous-steps par leur ``adapter_name``.
+
+    Le resolver retourné lève ``KeyError`` si un nom inconnu est
+    demandé.
+
+    Parameters
+    ----------
+    engines:
+        Liste d'engines/pipelines legacy à enregistrer.
+
+    Returns
+    -------
+    Callable[[str], Any]
+        Fonction ``resolver(name) -> step_executor``.
+
+    Raises
+    ------
+    PicaronesError
+        Si deux engines partagent le même ``name`` (collision).
+    """
+    name_to_executor: dict[str, Any] = {}
+
+    def _register(name: str, executor: Any) -> None:
+        existing = name_to_executor.get(name)
+        if existing is not None and existing is not executor:
+            raise PicaronesError(
+                f"Adapter resolver : nom {name!r} enregistré "
+                "deux fois avec des instances différentes — "
+                "collision impossible à résoudre.",
+            )
+        name_to_executor[name] = executor
+
+    for engine in engines:
+        if getattr(engine, "is_pipeline", False):
+            # OCRLLMPipeline : enregistrer ocr + llm sous-jacents.
+            ocr_engine = getattr(engine, "ocr_engine", None)
+            llm_adapter = getattr(engine, "llm_adapter", None)
+            if ocr_engine is not None:
+                _register(ocr_engine.name, LegacyOCREngineExecutor(ocr_engine))
+            if llm_adapter is not None:
+                _register(_llm_adapter_name(llm_adapter), llm_adapter)
+        else:
+            _register(engine.name, LegacyOCREngineExecutor(engine))
+
+    def resolver(name: str) -> Any:
+        if name not in name_to_executor:
+            raise KeyError(
+                f"adapter inconnu pour le resolver legacy : {name!r}.  "
+                f"Enregistrés : {sorted(name_to_executor.keys())!r}."
+            )
+        return name_to_executor[name]
+
+    return resolver
+
+
 # ──────────────────────────────────────────────────────────────────────
 # Helpers privés
 # ──────────────────────────────────────────────────────────────────────
 
 
+def _llm_adapter_name(llm_adapter: Any) -> str:
+    """Identifiant ``provider:model`` stable pour un adapter LLM/VLM.
+
+    Convention identique à celle utilisée par
+    ``picarones.pipelines._executor_runner`` (Sprint B) — les
+    adapter resolvers internes attendent ce format.
+    """
+    return f"{llm_adapter.name}:{llm_adapter.model}"
+
+
+def _safe_pipeline_name(name: str) -> str:
+    """Convertit un ``engine.name`` quelconque en suffixe identifiant
+    valide pour ``PipelineSpec.name`` (alphanum + ``_-``)."""
+    out: list[str] = []
+    for ch in name:
+        if ch.isalnum() or ch in "_-":
+            out.append(ch)
+        else:
+            out.append("_")
+    return "".join(out).strip("_") or "engine"
+
+
 def _safe_doc_id(doc_id: str) -> str:
     """Coerce un ``Document.doc_id`` vers le regex de ``DocumentRef.id``.
 
@@ -297,4 +493,6 @@ def _payload_to_text(level: ArtifactType, payload: object) -> str:
 __all__ = [
     "document_to_document_ref",
     "corpus_to_corpus_spec",
+    "engine_to_pipeline_spec",
+    "build_adapter_resolver",
 ]

tests/app/test_sprint_d_legacy_runner_adapter.py

@@ -17,12 +17,20 @@ from pathlib import Path
 
 import pytest
 
+from picarones.adapters.legacy_engines._step_executor import (
+    LegacyOCREngineExecutor,
+)
+from picarones.adapters.legacy_engines.base import BaseOCREngine
+from picarones.adapters.llm.base import BaseLLMAdapter
 from picarones.app.services._legacy_runner_adapter import (
+    build_adapter_resolver,
     corpus_to_corpus_spec,
     document_to_document_ref,
+    engine_to_pipeline_spec,
 )
 from picarones.domain.artifacts import ArtifactType
 from picarones.domain.errors import PicaronesError
+from picarones.domain.pipeline_spec import INITIAL_STEP_ID
 from picarones.evaluation.corpus import (
     AltoGT,
     Corpus,
@@ -34,6 +42,43 @@ from picarones.evaluation.corpus import (
 )
 
 
+# ──────────────────────────────────────────────────────────────────────
+# Mocks réutilisés pour D.1.b
+# ──────────────────────────────────────────────────────────────────────
+
+
+class _MockOCR(BaseOCREngine):
+    def __init__(self, name: str = "mock_ocr") -> None:
+        super().__init__(config={})
+        self._name = name
+
+    @property
+    def name(self) -> str:  # type: ignore[override]
+        return self._name
+
+    def version(self) -> str:
+        return "1.0"
+
+    def _run_ocr(self, image_path):
+        return "ocr text"
+
+
+class _MockLLM(BaseLLMAdapter):
+    def __init__(self, model: str = "mock-1") -> None:
+        super().__init__(model=model, config={})
+
+    @property
+    def name(self) -> str:
+        return "mock_llm"
+
+    @property
+    def default_model(self) -> str:
+        return "mock-1"
+
+    def _call(self, prompt, image_b64=None):
+        return "corrected"
+
+
 # ──────────────────────────────────────────────────────────────────────
 # document_to_document_ref
 # ──────────────────────────────────────────────────────────────────────
@@ -312,3 +357,172 @@ class TestCorpusToCorpusSpec:
         corpus = Corpus(name="dup", documents=docs)
         with pytest.raises(CorpusSpecError, match="dupliqu"):
             corpus_to_corpus_spec(corpus, workspace_dir=tmp_path)
+
+
+# ──────────────────────────────────────────────────────────────────────
+# engine_to_pipeline_spec
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestEngineToPipelineSpec:
+    def test_ocr_only_produces_single_step_spec(self) -> None:
+        ocr = _MockOCR(name="my_ocr")
+        spec = engine_to_pipeline_spec(ocr)
+        assert len(spec.steps) == 1
+        step = spec.steps[0]
+        assert step.id == "ocr"
+        assert step.kind == "ocr"
+        assert step.adapter_name == "my_ocr"
+        assert ArtifactType.IMAGE in step.input_types
+        assert ArtifactType.RAW_TEXT in step.output_types
+        assert step.inputs_from[ArtifactType.IMAGE] == INITIAL_STEP_ID
+
+    def test_ocr_only_initial_inputs_is_image(self) -> None:
+        ocr = _MockOCR()
+        spec = engine_to_pipeline_spec(ocr)
+        assert spec.initial_inputs == (ArtifactType.IMAGE,)
+
+    def test_ocr_only_name_is_safe(self) -> None:
+        """Un engine.name avec caractères spéciaux donne quand même un
+        spec.name conforme."""
+        ocr = _MockOCR(name="weird name (v2)")
+        spec = engine_to_pipeline_spec(ocr)
+        # Le nom de la spec ne doit contenir que des chars autorisés.
+        for ch in spec.name:
+            assert ch.isalnum() or ch in "_-"
+
+    def test_ocr_llm_pipeline_text_only(self) -> None:
+        from picarones.pipelines.base import OCRLLMPipeline, PipelineMode
+
+        ocr = _MockOCR(name="upstream_ocr")
+        llm = _MockLLM(model="mock-1")
+        pipeline = OCRLLMPipeline(
+            ocr_engine=ocr,
+            llm_adapter=llm,
+            mode=PipelineMode.TEXT_ONLY,
+        )
+        spec = engine_to_pipeline_spec(pipeline)
+        # Spec composée : 2 steps (OCR + LLM).
+        assert len(spec.steps) == 2
+        assert spec.steps[0].adapter_name == "upstream_ocr"
+        assert spec.steps[1].adapter_name == "mock_llm:mock-1"
+        # Le step LLM hérite du prompt template via params.
+        assert "prompt_template" in spec.steps[1].params
+
+    def test_ocr_llm_pipeline_zero_shot_no_ocr_step(self) -> None:
+        from picarones.pipelines.base import OCRLLMPipeline, PipelineMode
+
+        llm = _MockLLM(model="vlm-1")
+        pipeline = OCRLLMPipeline(
+            llm_adapter=llm,
+            mode=PipelineMode.ZERO_SHOT,
+        )
+        spec = engine_to_pipeline_spec(pipeline)
+        # Un seul step (VLM).
+        assert len(spec.steps) == 1
+        assert spec.steps[0].adapter_name == "mock_llm:vlm-1"
+        assert ArtifactType.RAW_TEXT in spec.steps[0].output_types
+
+
+# ──────────────────────────────────────────────────────────────────────
+# build_adapter_resolver
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestBuildAdapterResolver:
+    def test_single_ocr_engine_registered(self) -> None:
+        ocr = _MockOCR(name="my_ocr")
+        resolver = build_adapter_resolver([ocr])
+        step = resolver("my_ocr")
+        assert isinstance(step, LegacyOCREngineExecutor)
+
+    def test_unknown_name_raises_keyerror(self) -> None:
+        ocr = _MockOCR()
+        resolver = build_adapter_resolver([ocr])
+        with pytest.raises(KeyError, match="adapter inconnu"):
+            resolver("unknown_engine")
+
+    def test_multiple_engines_registered(self) -> None:
+        ocr_a = _MockOCR(name="engine_a")
+        ocr_b = _MockOCR(name="engine_b")
+        resolver = build_adapter_resolver([ocr_a, ocr_b])
+        step_a = resolver("engine_a")
+        step_b = resolver("engine_b")
+        assert isinstance(step_a, LegacyOCREngineExecutor)
+        assert isinstance(step_b, LegacyOCREngineExecutor)
+
+    def test_collision_on_same_name_raises(self) -> None:
+        """Deux engines avec le même name → PicaronesError (le resolver
+        ne peut pas distinguer les deux instances)."""
+        ocr_a = _MockOCR(name="dup")
+        ocr_b = _MockOCR(name="dup")  # même name, instance différente
+        with pytest.raises(PicaronesError, match="enregistré"):
+            build_adapter_resolver([ocr_a, ocr_b])
+
+    def test_pipeline_registers_subcomponents(self) -> None:
+        """Pour un OCRLLMPipeline, le resolver enregistre l'OCR
+        sous-jacent (wrappé) et le LLM (qui est déjà StepExecutor),
+        pas le pipeline lui-même."""
+        from picarones.pipelines.base import OCRLLMPipeline, PipelineMode
+
+        ocr = _MockOCR(name="inner_ocr")
+        llm = _MockLLM(model="mock-1")
+        pipeline = OCRLLMPipeline(
+            ocr_engine=ocr,
+            llm_adapter=llm,
+            mode=PipelineMode.TEXT_ONLY,
+        )
+        resolver = build_adapter_resolver([pipeline])
+        # Les sous-composants sont disponibles…
+        assert isinstance(resolver("inner_ocr"), LegacyOCREngineExecutor)
+        assert resolver("mock_llm:mock-1") is llm
+        # …mais pas le pipeline lui-même par son nom (le resolver
+        # référence par adapter_name dans la spec, pas par engine).
+        with pytest.raises(KeyError):
+            resolver(pipeline.name)
+
+    def test_zero_shot_pipeline_only_registers_llm(self) -> None:
+        """En zero_shot, ocr_engine=None → seul le LLM est enregistré."""
+        from picarones.pipelines.base import OCRLLMPipeline, PipelineMode
+
+        llm = _MockLLM(model="vlm-1")
+        pipeline = OCRLLMPipeline(
+            llm_adapter=llm,
+            mode=PipelineMode.ZERO_SHOT,
+        )
+        resolver = build_adapter_resolver([pipeline])
+        assert resolver("mock_llm:vlm-1") is llm
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Intégration : engine_to_pipeline_spec + build_adapter_resolver
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestEngineSpecResolverIntegration:
+    def test_spec_adapter_names_resolve(self) -> None:
+        """Tous les ``adapter_name`` de la spec produite par
+        ``engine_to_pipeline_spec`` doivent être résolvables par
+        ``build_adapter_resolver([engine])``."""
+        ocr = _MockOCR(name="resolved_ocr")
+        spec = engine_to_pipeline_spec(ocr)
+        resolver = build_adapter_resolver([ocr])
+        for step in spec.steps:
+            executor = resolver(step.adapter_name)
+            assert executor is not None
+
+    def test_pipeline_spec_resolvers_all_steps(self) -> None:
+        from picarones.pipelines.base import OCRLLMPipeline, PipelineMode
+
+        ocr = _MockOCR(name="upstream")
+        llm = _MockLLM(model="mock-1")
+        pipeline = OCRLLMPipeline(
+            ocr_engine=ocr,
+            llm_adapter=llm,
+            mode=PipelineMode.TEXT_AND_IMAGE,
+        )
+        spec = engine_to_pipeline_spec(pipeline)
+        resolver = build_adapter_resolver([pipeline])
+        # Les 2 steps (OCR + LLM) doivent pouvoir être résolus.
+        for step in spec.steps:
+            assert resolver(step.adapter_name) is not None

tests/architecture/test_file_budgets.py

@@ -38,6 +38,10 @@ FILE_BUDGETS: dict[str, int] = {
     # Sera supprimé en Sprint C-D quand les callers consommeront des
     # PipelineSpec directement.
     "picarones/pipelines/_executor_runner.py": 470,  # actuel 410
+    # Sprint D.1 (plan v2.0) — adapter de compat run_benchmark legacy
+    # → BenchmarkService rewrite.  Module transitoire qui sera
+    # supprimé en D.6 avec measurements/runner/.
+    "picarones/app/services/_legacy_runner_adapter.py": 575,  # actuel 498
     # --- God-modules : budget actuel + 15 % de marge.
     # Le rétrécissement sera l'objet d'un sprint de refactor dédié.
     # statistics.py (1128 lignes) a été éclaté en sous-package