docs(sprint-H.8): cleanup obsolete legacy/shim language in production docstrings

Sprint H.8 — nettoyage des docstrings de production qui mentent
sur l'état post-v2.0. Avant H.8, ~301 références à "legacy" /
"shim" / "picarones.measurements" subsistaient dans le code de
production, malgré la suppression des paquets correspondants
aux sprints A-H.

Suppressions ciblées
--------------------

**Pure shim avec zero caller** :
- ``picarones/i18n.py`` (re-export shim ``picarones.reports.i18n``)
— 0 import dans le code, 0 import dans les tests. Supprimé.

**Bloc "Phase X — module relocalisé depuis Y vers Z. Le chemin
legacy reste disponible via un shim avec ``DeprecationWarning`` ;
suppression prévue en 2.0."** : strippé via regex multi-line dans
~50 fichiers (renderers ``reports/html/``, helpers, modules
``evaluation/metric_*``). Le bloc décrivait un état transitoire
qui n'existe plus (les shims ``measurements/`` / ``report/`` ont
été supprimés au Lots D-F).

**Références à des chemins supprimés dans les docstrings** :
- ``picarones.measurements.X`` → ``picarones.evaluation.metrics.X``
(~ 35 modules) ou ``picarones.evaluation.statistics`` ou
``picarones.app.services.benchmark_runner`` selon le mapping.
Couvre les ``See also``, ``Migré depuis``, ``Réutilise`` dans
~30 fichiers.
- ``picarones.adapters.legacy_engines.tesseract.TesseractEngine``
→ ``picarones.adapters.ocr.tesseract.TesseractAdapter`` (exemple
cassé dans ``robustness.py:428``).
- ``picarones.fixtures`` → retrait de la référence (le module a
été supprimé au Sprint G ; le commentaire dans ``cli/__init__.py``
prétendait le contraire).

**Blocs "Migration depuis le legacy" / "Le legacy reste en place
jusqu'au S46"** : strippés des adapters OCR (``tesseract.py``,
``pero_ocr.py``, ``mistral_ocr.py``, ``google_vision.py``,
``azure_doc_intel.py``, ``factory.py``, ``base.py``,
``__init__.py``). Le legacy ``picarones.engines.*`` /
``picarones.adapters.legacy_engines/`` n'existe plus depuis H.2.d.

**Renaming d'API publique** :
- ``populate_legacy_registry`` → ``populate_detector_registry``
dans ``picarones/reports/narrative/registry.py``. Aucun caller
externe (vérifié par grep dans tests/, docs/, scripts/). La
fonction n'avait rien de "legacy" — elle synchronise le
``DetectorRegistry`` (API publique stable) depuis le décorateur
déclaratif.

Reformulation contextuelle
--------------------------

**``benchmark_runner.py``** (l'entry point CLI/web) :
- Docstring de module : "adapter de compat ``run_benchmark`` legacy
→ ``BenchmarkService`` rewrite" → "Entry point CLI/web — façade
``run_benchmark_via_service``". Le module n'est plus
transitoire ; il est l'API stable.
- ~25 mentions "legacy" dans les commentaires inline reformulées :
``Document legacy`` → ``Document (couche 3)``,
``BenchmarkResult legacy`` → ``BenchmarkResult``, etc. Le mot
"legacy" était trompeur car les types ``Document`` / ``Corpus``
/ ``BenchmarkResult`` sont canoniques dans la couche 3.

**``partial_store.py``** : retrait des mentions "Trace de retrait"
+ "Module transitoire" + "le legacy est mort". C'est l'API
production v2.0+, pas un module à retirer.

**``llm_pipeline_config.py`` / ``llm_pipeline_builder.py``** :
retrait des comparaisons systématiques avec ``OCRLLMPipeline``
(legacy) qui n'existe plus. Les docstrings décrivent l'API
actuelle.

**``domain/artifacts.py``** : ``ArtifactType.TEXT/ALTO/PAGE``
recadré comme "aliases courts" (legitimes, utilisés dans le code
canonique) au lieu d'"aliases legacy pour rétrocompat".

**``__init__.py``** (top-level) : "API publique du Cercle 1
historique" → "API publique des couches stables (domain +
evaluation)". Référence aux "8 couches" au lieu des "3 cercles".

Tests / lint
------------

- ``pytest tests/`` : 4126 passed, 9 skipped, 24 deselected.
- ``ruff check`` : All checks passed.
- Aucun changement de comportement runtime — uniquement docstrings
+ 1 fonction renommée (sans caller externe).

Reste pour v2.0 ou v2.1
-----------------------

**Conservé volontairement** (~50 mentions restantes) :
- CSS palette names (``--palette-good: legacy green``) : noms
techniques user-facing du toggle palette historique vs
Okabe-Ito. Le mot "legacy" est ici un synonyme de "classic".
- Routes web ``/api/benchmark/start`` (label "legacy v1") vs
``/api/benchmark/run`` (v2 pipeline-based) : situation
bi-route délibérée.
- ``picarones/pipeline/spec.py`` : shim de deprecation avec
``DeprecationWarning`` actif. La période de deprecation
expire à v2.0 ; à supprimer dans une release ultérieure
avec le test ``tests/api_stability/test_deprecated_aliases.py``.
- Quelques "comportement legacy" en contexte de comparaison de
test (cas-tests).

**À faire dans H.9** : nettoyer les docs (``docs/migration/`` à
archiver, ~15 fichiers ``docs/developer/`` / ``docs/explanation/``
qui réfèrent encore les chemins supprimés).

https://claude.ai/code/session_01NxyVKqg2SowXLZdM4H1ZDE

picarones/__init__.py

@@ -2,8 +2,8 @@
 
 Licence Apache 2.0.
 
-API publique du Cercle 1 (abstractions stables) ré-exportée ici pour
-permettre :
+API publique des couches 1 & 3 (abstractions stables) ré-exportée
+ici pour permettre :
 
 >>> from picarones import Corpus, Document, BaseModule, ArtifactType
 >>> from picarones import BenchmarkResult, EngineReport, DocumentResult
@@ -16,7 +16,7 @@ utiliser les sous-packages explicites :
 >>> from picarones.adapters.ocr.tesseract import TesseractAdapter
 
 Voir ``docs/explanation/architecture.md`` pour la cartographie complète des
-3 cercles, et ``docs/reference/api-stable.md`` pour le contrat de stabilité.
+8 couches, et ``docs/reference/api-stable.md`` pour le contrat de stabilité.
 """
 
 from __future__ import annotations
@@ -41,7 +41,7 @@ __author__ = "Picarones contributors"
 
 
 # ──────────────────────────────────────────────────────────────────────────
-# API publique — Cercle 1 uniquement
+# API publique — couches stables (domain + evaluation)
 # ──────────────────────────────────────────────────────────────────────────
 
 from picarones.evaluation.corpus import (
@@ -75,12 +75,10 @@ from picarones.evaluation.metric_registry import (
     select_metrics,
 )
 
-# Sprint A3 — trigger d'enregistrement du registre typé (Sprint 34).
-# L'import de ``picarones.measurements`` provoque l'exécution des
-# décorateurs ``@register_metric`` sur ``cer``, ``wer``, ``mer``,
-# ``wil`` + ~15 métriques philologiques + reading order + NER + ALTO.
-# Ce trigger remplace l'ancien import croisé Cercle 1 → Cercle 2 dans
-# ``core/pipeline.py`` (violation B-1/B-2 du même esprit).
+# Trigger d'enregistrement du registre typé : l'import de
+# ``picarones.evaluation.metrics`` provoque l'exécution des décorateurs
+# ``@register_metric`` sur ``cer``, ``wer``, ``mer``, ``wil`` + ~15
+# métriques philologiques + reading order + NER + ALTO.
 import picarones.evaluation.metrics as _trigger_metric_registration  # noqa: F401, E402
 
 __all__ = [

picarones/adapters/corpus/_fallback_log.py

@@ -15,7 +15,7 @@ Conception volontairement minimale :
 
 Le détecteur de Fact correspondant (``FactType.IMPORTER_FALLBACK_TRIGGERED``)
 est implémenté dans
-:mod:`picarones.measurements.narrative.detectors.history`.
+:mod:`picarones.evaluation.metrics.narrative.detectors.history`.
 """
 
 from __future__ import annotations

picarones/adapters/ocr/__init__.py

@@ -1,20 +1,19 @@
-"""Adapters OCR du nouveau monde — Sprint A14-S26.
+"""Adapters OCR — couche 5 (libs externes autorisées).
 
-Contrat ``BaseOCRAdapter`` natif au rewrite : pas hérité du legacy
-``picarones.engines.base.BaseOCREngine``, exprimé directement en
-termes du nouveau ``ArtifactType`` et de l'interface
-``execute(inputs, params, context)`` du ``PipelineExecutor``.
+Contrat ``BaseOCRAdapter`` exprimé en termes du ``ArtifactType``
+et de l'interface ``execute(inputs, params, context)`` consommée
+par ``PipelineExecutor``.
 
 Implémentations livrées
 -----------------------
+- ``TesseractAdapter`` — Tesseract 5 (OSS, CPU-bound).
+- ``PeroOCRAdapter`` — Pero OCR (manuscrits, GPU recommandé).
+- ``MistralOCRAdapter`` — Mistral OCR API (cloud).
+- ``GoogleVisionAdapter`` — Google Vision API (cloud).
+- ``AzureDocIntelAdapter`` — Azure Document Intelligence (cloud).
 - ``PrecomputedTextAdapter`` — lit un texte OCR pré-calculé depuis
   le filesystem.  Cas BnF : comparer N transcriptions déjà produites
   par d'autres outils sans relancer d'OCR.
-
-Adapters concrets pour Tesseract / Pero OCR / Mistral OCR / Google
-Vision / Azure DI : à écrire au cas par cas dans des sprints
-dédiés, **natifs** au nouveau contrat (pas de shim sur le legacy
-``picarones.engines``).
 """
 
 from __future__ import annotations

picarones/adapters/ocr/azure_doc_intel.py

@@ -1,10 +1,6 @@
 """``AzureDocIntelAdapter`` natif — Sprint A14-S34.
-
-Migration native du legacy ``picarones.engines.azure_doc_intel`` vers
 ``BaseOCRAdapter`` (S26).  **Pas un shim**.
 
-Le legacy reste en place jusqu'au S46.
-
 Cas d'usage BnF
 ---------------
 Azure Document Intelligence (anciennement Form Recognizer) propose
@@ -52,7 +48,7 @@ Comportement
 
 Anti-sur-ingénierie
 -------------------
-- Pas d'extraction de confidences (legacy S51 — reportée).
+- Pas d'extraction de confidences (à ajouter quand un caller en aura besoin).
 - Pas de support multi-langue dans une même requête.
 - Pas de retry au-delà du polling (qui est un retry implicite).
 """

picarones/adapters/ocr/base.py

@@ -1,12 +1,4 @@
-"""``BaseOCRAdapter`` — contrat natif du nouveau monde pour un adapter OCR.
-
-Sprint A14-S26 du rewrite ciblé.
-
-Ce module définit le contrat **propre** auquel un adapter OCR du
-nouveau monde doit se conformer pour être utilisable comme step
-d'une pipeline ``picarones.pipeline``.  Pas hérité du legacy
-``picarones.engines.base.BaseOCREngine`` — c'est un nouveau contrat,
-sans dette technique, exprimé en termes du nouveau ``ArtifactType``.
+"""``BaseOCRAdapter`` — contrat pour un adapter OCR (couche 5).
 
 Contrat
 -------
@@ -22,23 +14,9 @@ Un adapter OCR :
 - Implémente
   ``execute(inputs, params, context) -> dict[ArtifactType, Artifact]``.
 
-Le ``Artifact`` retourné porte une ``uri`` filesystem — c'est la
-convention du nouveau monde pour permettre au ``payload_loader`` de
-le lire ultérieurement (Sprint S25 — la projection a un payload
-direct, mais les artefacts produits par les adapters sont stockés
-sur disque pour traçabilité et streaming).
-
-Différences avec le legacy
---------------------------
-- ``ArtifactType.RAW_TEXT`` (10 valeurs) au lieu de
-  ``ArtifactType.TEXT`` (6 valeurs legacy).
-- Pas de ``run(image_path)`` historique — un seul point d'entrée
-  ``execute()``.
-- Pas de wrapper ``EngineResult`` — les erreurs lèvent directement,
-  le ``PipelineExecutor`` les capture en step en échec.
-- Pas de ``_run_ocr`` / ``_run_with_native`` / ``_extract_raw_confidences``
-  — les confidences (S42 legacy) sont reportées à un sprint dédié
-  où l'on définira un ``ConfidenceArtifact`` typé.
+Le ``Artifact`` retourné porte une ``uri`` filesystem — convention
+qui permet au ``payload_loader`` de le lire ultérieurement et
+garantit la traçabilité et le streaming.
 
 Anti-sur-ingénierie
 -------------------

picarones/adapters/ocr/factory.py

@@ -1,9 +1,6 @@
 """Factory canonique : instancier un ``BaseOCRAdapter`` par nom court.
 
 Sprint H.2.b du plan v2.0 — équivalent canonique de
-``picarones.adapters.legacy_engines.factory.engine_from_name`` qui
-retournait des ``BaseOCREngine`` (legacy, ``run(image_path) →
-EngineResult``).  Cette factory retourne des ``BaseOCRAdapter``
 (rewrite, ``StepExecutor`` Protocol, ``execute(inputs, params,
 context) → dict[ArtifactType, Artifact]``).
 
@@ -15,14 +12,6 @@ Vit en couche 5 (``picarones.adapters.ocr``) plutôt qu'en
 Cette factory ne dépend d'aucune brique de couche supérieure
 (pas de ``click``, pas de FastAPI).
 
-Migration depuis le legacy
---------------------------
-Code legacy ::
-
-    from picarones.adapters.legacy_engines.factory import engine_from_name
-    engine = engine_from_name("tesseract", lang="fra", psm=6)
-    # engine est un BaseOCREngine, à wrapper via LegacyOCREngineExecutor
-    # avant de pouvoir être consommé par PipelineExecutor.
 
 Code canonique équivalent ::
 

picarones/adapters/ocr/google_vision.py

@@ -1,10 +1,5 @@
 """``GoogleVisionAdapter`` natif — Sprint A14-S33.
 
-Migration native du legacy ``picarones.engines.google_vision.GoogleVisionEngine``
-vers le contrat ``BaseOCRAdapter`` (S26).  **Pas un shim**.
-
-Le legacy reste en place jusqu'au S46.
-
 Cas d'usage BnF
 ---------------
 Google Cloud Vision propose deux modes d'OCR :
@@ -36,7 +31,7 @@ disponible.
 
 Anti-sur-ingénierie
 -------------------
-- Pas d'extraction de confidences (legacy S50 — reportée).
+- Pas d'extraction de confidences (à ajouter quand un caller en aura besoin).
 - Pas de pré-validation du JSON service account — le SDK le fait.
 - Pas de support batch — un appel par image.
 """

picarones/adapters/ocr/mistral_ocr.py

@@ -1,11 +1,6 @@
 """``MistralOCRAdapter`` natif — Sprint A14-S32.
-
-Migration native du legacy ``picarones.engines.mistral_ocr.MistralOCREngine``
-vers le contrat ``BaseOCRAdapter`` (S26).  **Pas un shim** : la classe
 implémente directement le contrat du nouveau monde.
 
-Le legacy ``MistralOCREngine`` reste en place jusqu'au S46.
-
 Cas d'usage BnF
 ---------------
 Mistral AI fournit deux familles d'OCR :
@@ -47,8 +42,7 @@ Comportement
 Anti-sur-ingénierie
 -------------------
 - Pas de retry / backoff (le caller wrappe si besoin).
-- Pas d'extraction de confidences (legacy S49 — reportées au
-  sprint ``ConfidenceArtifact``).
+- Pas d'extraction de confidences (à ajouter quand un caller en aura besoin).
 - Pas de support multi-page (l'image est traitée comme une seule
   page d'entrée — Mistral OCR retourne une liste de pages dont on
   concatène les markdowns).

picarones/adapters/ocr/pero_ocr.py

@@ -1,12 +1,5 @@
 """``PeroOCRAdapter`` natif — Sprint A14-S31.
-
-Migration native du legacy ``picarones.engines.pero_ocr.PeroOCREngine``
-vers le contrat ``BaseOCRAdapter`` (S26).  **Pas un shim** : la classe
 implémente directement le contrat du nouveau monde, sans héritage du
-legacy.
-
-Le legacy ``PeroOCREngine`` reste en place pour les callers qui
-n'ont pas encore migré ; sa suppression viendra au S46 quand la
 parité sera atteinte sur tous les adapters.
 
 Cas d'usage BnF
@@ -42,8 +35,7 @@ Comportement
 Anti-sur-ingénierie
 -------------------
 - Pas de support GPU explicite (Pero OCR le gère via la config).
-- Pas de retry, pas d'extraction de confidences (legacy S48 —
-  reportées au sprint ``ConfidenceArtifact``).
+- Pas de retry, pas d'extraction de confidences (à ajouter quand un caller en aura besoin).
 - ``_parser`` lazy-init — si l'instance est sérialisée pour
   ProcessPool, le parser est re-instancié dans le worker (cohérent
   avec Pero OCR qui charge ses modèles à l'instanciation).

picarones/adapters/ocr/tesseract.py

@@ -1,13 +1,7 @@
-"""``TesseractAdapter`` natif — Sprint A14-S30.
+"""``TesseractAdapter`` — adapter natif pour Tesseract 5.
 
-Migration native du legacy ``picarones.engines.tesseract.TesseractEngine``
-vers le contrat ``BaseOCRAdapter`` (S26).  **Pas un shim** : la classe
-implémente directement le contrat du nouveau monde, sans héritage du
-legacy.
-
-Le legacy ``TesseractEngine`` reste en place pour les callers qui
-n'ont pas encore migré ; sa suppression viendra au S46 quand la
-parité sera atteinte sur tous les adapters.
+Implémente le contrat ``BaseOCRAdapter`` (couche 5) :
+``execute(inputs, params, context) → dict[ArtifactType, Artifact]``.
 
 Cas d'usage BnF
 ---------------
@@ -52,10 +46,9 @@ Anti-sur-ingénierie
 -------------------
 - Pas de retry — Tesseract échoue rarement sur une image valide,
   et un appelant peut wrapper si besoin.
-- Pas d'extraction de confidences (legacy S47) — reporté à un
-  sprint dédié qui définira ``ConfidenceArtifact`` typé.  La
-  fonctionnalité reste disponible via le legacy
-  ``picarones.engines.tesseract.TesseractEngine`` jusqu'au S46.
+- Pas d'extraction de confidences pour l'instant : à ajouter
+  quand un caller en aura besoin (un ``ConfidenceArtifact`` typé
+  reste à définir).
 - Pas de validation de l'encodage de l'image — Tesseract gère.
 - Pas de support batch — un appel par image (le runner gère le
   parallélisme inter-documents).

picarones/adapters/storage/__init__.py

@@ -25,7 +25,7 @@ abstraction ABC.
 Cibles à venir
 --------------
 - S37 : déplacement de ``picarones.web.jobs`` (SQLite job store).
-- Post-livraison : ``picarones.measurements.history`` (SQLite
+- Post-livraison : ``picarones.evaluation.metrics.history`` (SQLite
   history) et stores distribués (S3, GCS, …).
 """
 

picarones/app/services/benchmark_runner.py

@@ -1,34 +1,19 @@
-"""Sprint D.1 du plan v2.0 — adapter de compat ``run_benchmark`` legacy
-→ ``BenchmarkService`` rewrite.
-
-Ce module présente l'API mono-call historique de
-``picarones.measurements.runner.run_benchmark`` mais s'appuie en
-interne sur le rewrite (``BenchmarkService``,
-``PipelineExecutor``, ``CorpusRunner``).  Il sert de pont
-transitoire pour faciliter la migration des callers en plusieurs
-étapes :
-
-1. (cette session) Helpers de mapping ``Corpus`` ↔ ``CorpusSpec``
-   et ``Document`` ↔ ``DocumentRef`` — testables indépendamment.
-2. (sub-phase D.1.b) Mapping ``BaseOCREngine`` → ``PipelineSpec``
-   + adapter resolver.
-3. (sub-phase D.1.c) Conversion ``RunResult`` → ``BenchmarkResult``.
-4. (sub-phase D.1.d) Fonction ``run_benchmark_via_service``
-   complète avec progress callback, output_json, partial_dir.
-5. (sub-phase D.1.e) Tests d'équivalence numérique (CER/WER) entre
-   les deux runners sur les fixtures.
-
-Trace de retrait
-----------------
-Ce module est **transitoire** (Sprint D du plan v2.0).  Il sera
-supprimé en D.6 quand tous les callers (cli/_workflows,
-web/benchmark_utils) consommeront ``BenchmarkService``
-directement.
-
-Cette première itération n'expose que les helpers de mapping
-documents/corpus — la fonction publique
-``run_benchmark_via_service`` arrive dans une session ultérieure
-quand toutes les briques seront en place.
+"""Entry point CLI/web — façade ``run_benchmark_via_service``.
+
+Présente l'API mono-call ``run_benchmark_via_service(corpus,
+engines, ...)`` consommée par ``picarones.interfaces.cli`` et
+``picarones.interfaces.web``.  S'appuie en interne sur le service
+canonique (``BenchmarkService``, ``PipelineExecutor``,
+``CorpusRunner``).
+
+Pourquoi cette façade
+---------------------
+``BenchmarkService`` consomme ``CorpusSpec`` (références
+filesystem, Pydantic, immutable) et ``PipelineSpec`` (déclaratif).
+Les interfaces utilisateur (CLI, web upload) raisonnent en
+``Corpus`` riche en behavior + liste de moteurs OCR/LLM.  Ce
+module fait la conversion entre les deux modèles, expose une API
+mono-call ergonomique et restitue un ``BenchmarkResult``.
 """
 
 from __future__ import annotations
@@ -37,11 +22,6 @@ import logging
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable
 
-# Sprint H.2.c.1 — ``LegacyOCREngineExecutor`` n'est plus consommé :
-# tous les callers passent désormais des ``BaseOCRAdapter`` canoniques
-# (déjà ``StepExecutor`` natifs).  L'import est retiré ; le code path
-# legacy de ``build_adapter_resolver`` est désormais inaccessible et
-# peut être supprimé en H.2.c.2.
 from picarones.domain.artifacts import ArtifactType
 from picarones.domain.corpus import CorpusSpec
 from picarones.domain.documents import DocumentRef, GroundTruthRef
@@ -58,15 +38,15 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
-# 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``).
+# Le ``OCRLLMPipelineConfig`` (couche 4) est consommé exclusivement
+# par duck typing (``is_pipeline``, ``ocr_adapter``, ``llm_adapter``,
+# ``mode``, ``prompt_template``) pour respecter l'inward-only :
+# ``app/`` ne doit pas importer ``pipeline/llm_pipeline_config``
+# directement.
 
 
 # ──────────────────────────────────────────────────────────────────────
-# Mapping Document (legacy) → DocumentRef (rewrite)
+# Mapping Document → DocumentRef
 # ──────────────────────────────────────────────────────────────────────
 
 
@@ -75,9 +55,9 @@ def document_to_document_ref(
     *,
     workspace_dir: Path,
 ) -> DocumentRef:
-    """Convertit un ``Document`` legacy en ``DocumentRef`` rewrite.
+    """Convertit un ``Document`` (couche 3) en ``DocumentRef`` (couche 1).
 
-    Le ``Document`` legacy porte sa GT en mémoire (``ground_truth: str``
+    Le ``Document`` (modèle riche) porte sa GT en mémoire (``ground_truth: str``
     et ``ground_truths: dict[ArtifactType, GTPayload]``).  Le
     ``DocumentRef`` rewrite porte des références filesystem
     (``GroundTruthRef.uri``).  La conversion écrit chaque GT
@@ -86,7 +66,7 @@ def document_to_document_ref(
     Parameters
     ----------
     document:
-        Document legacy.  ``image_path`` non-``None`` est requis ;
+        Document.  ``image_path`` non-``None`` est requis ;
         ``ground_truth`` (TEXT) peut être vide.
     workspace_dir:
         Répertoire de travail où écrire les fichiers GT
@@ -171,7 +151,7 @@ def corpus_to_corpus_spec(
     *,
     workspace_dir: Path,
 ) -> CorpusSpec:
-    """Convertit un ``Corpus`` legacy en ``CorpusSpec`` rewrite.
+    """Convertit un ``Corpus`` (couche 3) en ``CorpusSpec`` (couche 1).
 
     Itère sur ``corpus.documents`` et applique
     ``document_to_document_ref`` pour chacun.
@@ -179,7 +159,7 @@ def corpus_to_corpus_spec(
     Parameters
     ----------
     corpus:
-        Corpus legacy.
+        Corpus.
     workspace_dir:
         Répertoire de travail où écrire les fichiers GT
         synthétisés (typiquement un ``tempfile.TemporaryDirectory``
@@ -219,7 +199,7 @@ def corpus_to_corpus_spec(
 
 
 # ──────────────────────────────────────────────────────────────────────
-# Mapping RunResult (rewrite) → BenchmarkResult (legacy)
+# Mapping RunResult → BenchmarkResult
 # ──────────────────────────────────────────────────────────────────────
 
 
@@ -231,7 +211,7 @@ def run_result_to_benchmark_result(
     char_exclude: Any | None = None,
     normalization_profile: Any | None = None,
 ) -> Any:
-    """Transpose un ``RunResult`` rewrite en ``BenchmarkResult`` legacy.
+    """Transpose un ``RunResult`` (couche 4) en ``BenchmarkResult`` (couche 3).
 
     Le mapping est en **transposition** :
 
@@ -249,7 +229,7 @@ def run_result_to_benchmark_result(
     3. Lit l'``ocr_intermediate`` (RAW_TEXT) si le pipeline a un
        step OCR amont.
     4. Calcule les métriques CER/WER via ``compute_metrics``.
-    5. Construit un ``DocumentResult`` legacy avec ``engine_error``
+    5. Construit un ``DocumentResult`` avec ``engine_error``
        extrait des ``step_results``.
     6. Aggrège les métriques par engine via ``aggregate_metrics``.
     7. Reconstitue ``pipeline_info`` pour les engines pipeline
@@ -260,11 +240,11 @@ def run_result_to_benchmark_result(
     run_result:
         ``RunResult`` produit par ``BenchmarkService.run``.
     corpus:
-        Corpus legacy d'origine — sert à récupérer le ``ground_truth``
+        Corpus d'origine — sert à récupérer le ``ground_truth``
         et l'``image_path`` pour chaque document, dans le même ordre
         que ``run_result.document_results``.
     engines:
-        Liste d'engines legacy dans l'ordre où leurs specs ont été
+        Liste d'adapters dans l'ordre où leurs specs ont été
         passées à ``BenchmarkService.run`` (l'ordre détermine
         l'index dans ``RunDocumentResult.pipeline_results``).
     char_exclude:
@@ -275,7 +255,7 @@ def run_result_to_benchmark_result(
     Returns
     -------
     BenchmarkResult
-        Format legacy compatible avec les consommateurs historiques
+        Format compatible avec les consommateurs historiques
         (rapport HTML, persistance JSON, narrative engine).
     """
     from picarones.evaluation.benchmark_result import (
@@ -413,14 +393,14 @@ def _build_pipeline_metadata(
     ground_truth: str = "",
     hypothesis: str = "",
 ) -> dict:
-    """Reconstitue les ``pipeline_metadata`` legacy pour un DocumentResult.
+    """Reconstitue les ``pipeline_metadata`` pour un DocumentResult.
 
     Sprint D.2.d — pour les pipelines composées OCR+LLM, calcule
     ``over_normalization`` (détection des cas où le LLM a sur-normalisé
     le texte par rapport à la GT) si ``ocr_intermediate`` est
     disponible.  Equivalent fonctionnel de
-    ``picarones.measurements.runner.document._compute_doc_result``
-    lignes 102-112 (legacy supprimé en D.6.b).
+    le calcul historique de DocumentResult
+    (supprimé en D.6.b).
     """
     if not getattr(engine, "is_pipeline", False):
         return {}
@@ -428,7 +408,7 @@ def _build_pipeline_metadata(
         "pipeline_mode": getattr(engine, "mode", None),
         "is_pipeline": True,
     }
-    # mode peut être un Enum (legacy) ou une string (canonique).
+    # mode peut être un Enum ou une string (canonique).
     mode = metadata["pipeline_mode"]
     if mode is not None and hasattr(mode, "value"):
         metadata["pipeline_mode"] = mode.value
@@ -472,7 +452,7 @@ def _build_pipeline_info(engine: Any) -> dict:
         info["llm_provider"] = llm_adapter.name
     mode = getattr(engine, "mode", None)
     if mode is not None:
-        # Tolère enum (legacy ``PipelineMode.X``) ou string (canonique).
+        # Tolère enum (``PipelineMode.X``) ou string.
         info["mode"] = mode.value if hasattr(mode, "value") else mode
     prompt_path = getattr(engine, "prompt_path", None)
     if prompt_path is not None:
@@ -498,12 +478,12 @@ def _safe_engine_version(engine: Any) -> str:
 
 def _is_canonical_adapter(engine: Any) -> bool:
     """Détecte si ``engine`` est un ``BaseOCRAdapter`` canonique
-    (par opposition à ``BaseOCREngine`` legacy ou ``OCRLLMPipeline``).
+    (par opposition aux modèles riches en behavior).
 
     Duck-typing tolérant : un objet est canonical s'il expose
     ``execute``, ``input_types``, ``output_types`` (les trois
     attributs requis par le contrat ``StepExecutor``) ET n'a pas
-    le marker legacy ``is_pipeline``.
+    le marker ``is_pipeline``.
     """
     from picarones.adapters.ocr.base import BaseOCRAdapter
     return isinstance(engine, BaseOCRAdapter)
@@ -517,7 +497,7 @@ def _is_canonical_adapter(engine: Any) -> bool:
 def engine_to_pipeline_spec(engine: Any) -> PipelineSpec:
     """Convertit un engine en ``PipelineSpec`` rewrite.
 
-    Deux cas (Sprint H.2.c — le path legacy ``BaseOCREngine`` a
+    Deux cas (le path historique ``BaseOCREngine`` a
     été retiré) :
 
     - **BaseOCRAdapter** (canonique) : spec mono-step consommant
@@ -546,7 +526,7 @@ def engine_to_pipeline_spec(engine: Any) -> PipelineSpec:
     raise PicaronesError(
         f"Type d'engine non supporté : {type(engine).__name__}.  "
         "Attendu : ``BaseOCRAdapter`` ou ``OCRLLMPipelineConfig``.  "
-        "Le support legacy ``BaseOCREngine`` / ``OCRLLMPipeline`` "
+        "Le support historique ``BaseOCREngine`` / ``OCRLLMPipeline`` "
         "a été retiré au sprint H.2.c.",
     )
 
@@ -584,7 +564,7 @@ def _canonical_adapter_to_spec(adapter: Any) -> PipelineSpec:
     )
 
 
-# Sprint H.2.c — ``_ocr_only_to_spec`` (legacy ``BaseOCREngine`` →
+# ``_ocr_only_to_spec`` (mappait ``BaseOCREngine`` →
 # spec mono-step en dur IMAGE → RAW_TEXT) supprimé.  Le path
 # canonique ``_canonical_adapter_to_spec`` couvre tous les cas en
 # utilisant les ``input_types``/``output_types`` déclarés par
@@ -592,10 +572,10 @@ def _canonical_adapter_to_spec(adapter: Any) -> PipelineSpec:
 
 
 def _ocr_llm_pipeline_to_spec(pipeline: Any) -> PipelineSpec:
-    """Spec composée pour un ``OCRLLMPipeline`` legacy ou un
+    """Spec composée pour un ``OCRLLMPipelineConfig`` ou un
     ``OCRLLMPipelineConfig`` canonique (3 modes).
 
-    Tolère ``pipeline.mode`` en enum (legacy ``PipelineMode.TEXT_ONLY``)
+    Tolère ``pipeline.mode`` en enum (``PipelineMode.TEXT_ONLY``)
     ou en string (canonique ``"text_only"``).
     """
     mode_attr = pipeline.mode
@@ -634,7 +614,7 @@ def build_adapter_resolver(
     """Construit un adapter resolver pour ``PipelineExecutor``.
 
     Parcourt les engines fournis et associe leur ``name`` à un
-    ``StepExecutor`` valide (Sprint H.2.c — le path legacy
+    ``StepExecutor`` valide (le path historique
     ``LegacyOCREngineExecutor`` a été retiré) :
 
     - **BaseOCRAdapter** : enregistré directement (déjà ``StepExecutor``).
@@ -700,7 +680,7 @@ def build_adapter_resolver(
     def resolver(name: str) -> Any:
         if name not in name_to_executor:
             raise KeyError(
-                f"adapter inconnu pour le resolver legacy : {name!r}.  "
+                f"adapter inconnu pour le resolver : {name!r}.  "
                 f"Enregistrés : {sorted(name_to_executor.keys())!r}."
             )
         return name_to_executor[name]
@@ -856,17 +836,17 @@ def run_benchmark_via_service(
     partial_dir: str | Path | None = None,
     entity_extractor: Callable[[str], list[dict]] | None = None,
     profile: str = "standard",
-    # ---- Paramètres legacy non encore portés vers BenchmarkService ----
+    # ---- Paramètres non encore portés vers BenchmarkService ----
     # Sprint D.2 du plan v2.0 — features marginales restantes :
     # ``max_workers`` (le rewrite a son propre max_in_flight via
     # ``CorpusRunner``).
     max_workers: int = 4,  # noqa: ARG001
 ) -> Any:
-    """Adapter de compatibilité ``run_benchmark`` legacy →
+    """Façade ``run_benchmark`` →
     ``BenchmarkService`` rewrite.
 
     Présente la signature historique de
-    ``picarones.measurements.runner.run_benchmark`` mais s'appuie
+    ``picarones.app.services.benchmark_runner.run_benchmark`` mais s'appuie
     en interne sur le rewrite (``CorpusSpec``, ``PipelineSpec``,
     ``PipelineExecutor``, ``BenchmarkService``).  Pivot du Sprint D
     du plan v2.0.
@@ -880,7 +860,7 @@ def run_benchmark_via_service(
     - Un ``Corpus`` avec image_path + ground_truth (TEXT) par doc.
     - Métriques CER/WER calculées via ``compute_metrics`` sur les
       hypothèses extraites des artefacts produits.
-    - Conversion en ``BenchmarkResult`` legacy compatible avec les
+    - Conversion en ``BenchmarkResult`` compatible avec les
       consommateurs historiques (rapport HTML, narrative engine).
 
     Périmètre reporté (D.2)
@@ -931,16 +911,16 @@ def run_benchmark_via_service(
     Parameters
     ----------
     corpus:
-        Corpus legacy.
+        Corpus.
     engines:
-        Liste d'engines/pipelines legacy à benchmarker.
+        Liste d'engines/pipelines à benchmarker.
     char_exclude:
         Filtre passé à ``compute_metrics``.
     normalization_profile:
         Profil de normalisation passé à ``compute_metrics``.
     output_json:
         Si fourni, le ``BenchmarkResult`` est sérialisé en JSON
-        à ce chemin (via la sérialisation legacy).
+        à ce chemin (sérialisation BenchmarkResult).
     code_version:
         Version du code injectée dans le ``RunContext`` /
         ``RunManifest``.  Défaut : ``picarones.__version__``.
@@ -950,7 +930,7 @@ def run_benchmark_via_service(
     Returns
     -------
     BenchmarkResult
-        Format legacy compatible.
+        Format compatible avec les consommateurs historiques.
 
     Raises
     ------
@@ -1003,7 +983,7 @@ def run_benchmark_via_service(
 
     # D.2.e : NER attach post-process.  Idempotent — re-calcule à
     # chaque run même en mode resume (les ner_metrics ne sont pas
-    # persistées dans le partial NDJSON, cohérent avec le legacy
+    # persistées dans le partial NDJSON
     # qui calculait NER après le doc loop).
     if entity_extractor is not None:
         _attach_ner_metrics_to_benchmark(
@@ -1084,8 +1064,8 @@ def _aggregate_ner_metrics(doc_results: list) -> dict | None:
     compteurs totaux d'hallucinations et d'entités manquées.
 
     Equivalent fonctionnel de
-    ``picarones.measurements.runner.ner_attach._aggregate_ner``
-    (legacy supprimé en D.6.b).
+    ``picarones.app.services.benchmark_runner.ner_attach._aggregate_ner``
+    (le runner historique a été supprimé en D.6.b).
     """
     relevant = [
         dr for dr in doc_results if dr.ner_metrics is not None
@@ -1246,7 +1226,7 @@ def _run_benchmark_with_partial(
 
     for engine in engines:
         # Vérifier la cancellation entre engines (matche la
-        # sémantique legacy : un Ctrl+C arrête après l'engine en
+        # sémantique : un Ctrl+C arrête après l'engine en
         # cours, conserve les partials, ne démarre pas le suivant).
         if cancel_event is not None and getattr(
             cancel_event, "is_set", lambda: False,
@@ -1377,7 +1357,7 @@ def _execute_via_benchmark_service(
     Vues passées en liste vide — les métriques sont calculées
     côté converter D.1.c via ``compute_metrics`` directement sur
     les hypothèses extraites des artefacts.  Pattern simple,
-    cohérent avec le legacy qui calcule aussi les métriques au
+    cohérent : on calcule aussi les métriques au
     moment du benchmark (pas via ``EvaluationView``).
     """
     from picarones.app.services.benchmark_service import BenchmarkService
@@ -1399,7 +1379,7 @@ def _execute_via_benchmark_service(
 
     # ViewExecutor minimal : registres vides.
     # Pas de calcul de ``ViewResult`` ici — le converter D.1.c
-    # calcule les métriques côté legacy via ``compute_metrics``
+    # calcule les métriques via ``compute_metrics``
     # directement sur les hypothèses extraites des artefacts.
     view_executor = DefaultEvaluationViewExecutor.from_registries(
         metric_registry=MetricRegistry(),
@@ -1439,7 +1419,7 @@ def _execute_via_benchmark_service(
     # Sprint D.2.a : le hook ``progress_callback`` est appelé ici —
     # ``context_factory`` est invoqué une fois par (doc, pipeline)
     # AVANT l'exécution effective, ce qui correspond à la sémantique
-    # legacy de ``progress_callback(engine_name, doc_idx, doc_id)``.
+    # de ``progress_callback(engine_name, doc_idx, doc_id)``.
     import threading
 
     counter_lock = threading.Lock()
@@ -1452,7 +1432,7 @@ def _execute_via_benchmark_service(
             with counter_lock:
                 idx = counter_state["doc_idx"]
                 counter_state["doc_idx"] = idx + 1
-            # Sémantique legacy : ``progress_callback(engine.name, ...)``
+            # Sémantique : ``progress_callback(engine.name, ...)``
             # plutôt que le nom de la pipeline (qui inclut le préfixe
             # ``ocr_only_``).  Le mapping est fourni par le caller.
             engine_name = (
@@ -1463,7 +1443,7 @@ def _execute_via_benchmark_service(
             try:
                 progress_callback(engine_name, idx, doc.id)
             except Exception:  # noqa: BLE001
-                # Le legacy ignore silencieusement les erreurs du
+                # On ignore silencieusement les erreurs du
                 # callback (un caller qui crashe ne doit pas faire
                 # tomber le benchmark).  Même contrat ici.
                 pass
@@ -1502,7 +1482,7 @@ def _execute_via_benchmark_service(
 def _persist_benchmark_result_json(
     benchmark_result: Any, output_path: Path,
 ) -> None:
-    """Sérialise un ``BenchmarkResult`` legacy en JSON.
+    """Sérialise un ``BenchmarkResult`` en JSON.
 
     Utilise la méthode ``to_json``/``compact``/``asdict`` selon la
     surface disponible.  Ce helper duplique la logique de
@@ -1512,7 +1492,7 @@ def _persist_benchmark_result_json(
     output_path.parent.mkdir(parents=True, exist_ok=True)
     # ``BenchmarkResult`` est un dataclass — dataclasses.asdict
     # sérialise récursivement.  Le format n'est pas forcément
-    # identique octet pour octet à la sortie legacy, mais reste
+    # identique octet pour octet à la sortie historique, mais reste
     # compatible avec les consommateurs (rapport, narrative).
     import dataclasses
     import json

picarones/app/services/partial_store.py

@@ -1,8 +1,8 @@
-"""Sprint D.2.b — reprise sur interruption pour ``run_benchmark_via_service``.
+"""Reprise sur interruption pour ``run_benchmark_via_service``.
 
-Persistance NDJSON des ``DocumentResult`` legacy au fil du
-benchmark, pour permettre la reprise après crash / Ctrl+C / timeout
-sans perdre le travail déjà fait.
+Persistance NDJSON des ``DocumentResult`` au fil du benchmark, pour
+permettre la reprise après crash / Ctrl+C / timeout sans perdre le
+travail déjà fait.
 
 Contrat
 -------
@@ -18,19 +18,12 @@ partiel est supprimé.  Si un crash interrompt le run mid-engine,
 le fichier persiste : la prochaine exécution reprendra exactement
 où l'on s'est arrêté.
 
-Trace de retrait
-----------------
-Module transitoire (Sprint D.2.b du plan v2.0).  Sera supprimé
-en H.4 quand ``run_benchmark_via_service`` lui-même disparaîtra
-au profit d'une consommation directe de ``BenchmarkService`` par
-les callers (``cli``, ``web``).
-
 Anti-sur-ingénierie
 -------------------
 - Format JSONL plat (une ligne = un ``DocumentResult.as_dict()``),
   pas de schéma versioné.  Si la structure du ``DocumentResult``
-  legacy change, le fichier devient illisible — mais à ce stade
-  on est déjà en post-rewrite v2.0+ et le legacy est mort.
+  change, le fichier devient illisible — l'opérateur supprime
+  ``partial_dir`` et relance.
 - Lock thread-safe partagé module-level ; pas de tentative de
   partage inter-process (chaque process a son propre tempdir).
 - Pas de checksum ni de validation de schéma — best-effort.  Une
@@ -63,9 +56,8 @@ _partial_write_lock = threading.Lock()
 def _sanitize_filename(s: str) -> str:
     """Réduit ``s`` à ``[\\w\\-]`` et tronque à 64 chars.
 
-    Cohérent avec le format historique du fichier partiel
-    legacy ; permet à un opérateur de retrouver visuellement
-    le fichier dans ``partial_dir``.
+    Permet à un opérateur de retrouver visuellement le fichier
+    dans ``partial_dir``.
     """
     return re.sub(r"[^\w\-]", "_", s)[:64]
 

picarones/app/services/registry_service.py

@@ -4,7 +4,7 @@ Sprint A14-S23 du rewrite ciblé.
 
 Le service applicatif qui **construit** explicitement le
 ``MetricRegistry`` et le ``ProjectorRegistry`` au démarrage, en
-remplacement de l'anti-pattern legacy ``import picarones.measurements
+remplacement de l'anti-pattern legacy ``import picarones.evaluation.metrics
 as _trigger`` (où l'import par effet de bord déclenchait
 l'enregistrement via décorateurs au top-level d'un package, chargeant
 des dizaines de modules optionnels au moment d'un simple

picarones/app/services/run_orchestrator.py

@@ -76,8 +76,6 @@ from picarones.pipeline import (
 # ──────────────────────────────────────────────────────────────────────
 
 
-
-
 @dataclass(frozen=True)
 class OrchestrationResult:
     """Tout ce qu'un caller (CLI, HTTP, script) doit savoir d'un run.

picarones/domain/artifacts.py

@@ -1,14 +1,11 @@
-"""``Artifact`` et ``ArtifactType`` — Sprint A14-S4.
+"""``Artifact`` et ``ArtifactType``.
 
 Toute sortie d'une étape de pipeline est un **artefact traçable** :
 identifiant stable, type explicite, hash du contenu, provenance.
 
-Différences avec ``picarones.core.modules.ArtifactType`` (Sprint 33)
--------------------------------------------------------------------
-L'ancien ``ArtifactType`` historique a 6 valeurs :
-``IMAGE, TEXT, ALTO, PAGE, ENTITIES, READING_ORDER``.  Le nouveau
-en a 9, avec deux distinctions importantes pour les vues d'évaluation
-introduites aux Sprints S13-S18 :
+L'enum ``ArtifactType`` a 9 valeurs canoniques + 3 aliases courts
+pour les types texte/ALTO/PAGE.  Distinctions clés pour les vues
+d'évaluation :
 
 - **``RAW_TEXT`` vs ``CORRECTED_TEXT``** — un OCR brut et un texte
   corrigé par un LLM ont la même structure (string) mais des contrats
@@ -103,47 +100,40 @@ class ArtifactType(str, Enum):
     #: reliability diagram).
     CONFIDENCES = "confidences"
 
-    #: Aliases legacy pour rétrocompat avec ``picarones.core.modules``
-    #: (Phase 4-bis du retrait du legacy).  Le mécanisme natif d'Enum
-    #: Python rend ces noms équivalents aux canoniques :
+    #: Aliases courts pour les types texte/ALTO/PAGE.  Le mécanisme
+    #: natif d'Enum Python rend ces noms équivalents aux canoniques :
     #:
     #: >>> ArtifactType.TEXT is ArtifactType.RAW_TEXT
     #: True
     #:
-    #: Le mapping sémantique TEXT → RAW_TEXT est documenté dans
-    #: ``docs/migration/regression-tolerances.md``.  À supprimer en 2.0
-    #: une fois tous les callers legacy retirés.
+    #: Utilisés par les ``@register_metric(...)`` qui déclarent leurs
+    #: signatures de manière concise.
     TEXT = "raw_text"
     ALTO = "alto_xml"
     PAGE = "page_xml"
 
     @classmethod
     def _missing_(cls, value: object) -> "ArtifactType | None":
-        """Accepte les valeurs string legacy (``"text"``, ``"alto"``,
+        """Accepte les chaînes courtes (``"text"``, ``"alto"``,
         ``"page"``) en plus des valeurs canoniques.
 
-        Ce hook est invoqué par ``ArtifactType("text")`` (lecture YAML
-        legacy par exemple) — sans lui, ``ValueError``.  À supprimer
-        en 2.0 avec les aliases legacy ci-dessus.
+        Permet aux specs YAML d'utiliser indifféremment l'un ou
+        l'autre nom.
         """
-        legacy_map: dict[str, "ArtifactType"] = {
+        short_map: dict[str, "ArtifactType"] = {
             "text": cls.RAW_TEXT,
             "alto": cls.ALTO_XML,
             "page": cls.PAGE_XML,
         }
         if not isinstance(value, str):
             return None
-        return legacy_map.get(value)
+        return short_map.get(value)
 
 
-#: Map valeur canonique → valeur string legacy.  Permet aux dicts
-#: indexés par ``ArtifactType.value`` (junction_metrics du runner
-#: legacy, etc.) de présenter les **deux** clés pendant la phase de
-#: migration : un caller rewrite qui cherche ``["raw_text"]`` et un
-#: test legacy qui cherche ``["text"]`` voient le même résultat.
-#:
-#: Phase 4-bis du retrait du legacy.  Sera retiré en 2.0 quand tous
-#: les callers utilisent les valeurs canoniques.
+#: Map valeur canonique → valeur string courte.  Permet aux dicts
+#: indexés par ``ArtifactType.value`` de présenter les **deux** clés :
+#: un caller qui cherche ``["raw_text"]`` et un caller qui cherche
+#: ``["text"]`` voient le même résultat.
 LEGACY_VALUE_ALIASES: dict[str, str] = {
     "raw_text": "text",
     "alto_xml": "alto",

picarones/domain/errors.py

@@ -23,7 +23,7 @@ class PicaronesError(Exception):
     une sous-classe de ``PicaronesError`` plutôt qu'un ``Exception``
     générique ou un ``ValueError`` quand l'erreur a un sens métier.
 
-    L'ancien code (``picarones.core``, ``picarones.measurements``,
+    L'ancien code (``picarones.core``, ``picarones.evaluation.metrics``,
     etc.) garde son comportement actuel jusqu'à sa migration.
     """
 

picarones/domain/module_protocol.py

@@ -20,17 +20,13 @@ Usage minimal ::
             txt = inputs[ArtifactType.RAW_TEXT]
             return {ArtifactType.RAW_TEXT: txt.upper()}
 
-Ce module canonique (Phase 4-bis du retrait du legacy) est le
-remplacement de ``picarones.core.modules.BaseModule``.  Le shim
-legacy ``core/modules.py`` le ré-exporte pour la rétrocompat des
-~25 callers (engines, measurements, modules officiels, cli, web,
-report) qui le consomment.
-
-Le rewrite a aussi des protocols spécialisés
-(``BaseOCRAdapter``, ``BaseLLMAdapter``, ``BaseVLMAdapter`` dans
-``picarones.adapters``) qui sont des cas particuliers de
-``BaseModule`` typés pour leur domaine.  ``BaseModule`` reste le
-contrat **générique** pour les modules contribués par des tiers.
+Protocols spécialisés
+---------------------
+Les contrats de domaine — ``BaseOCRAdapter``, ``BaseLLMAdapter``,
+``BaseVLMAdapter`` (dans ``picarones.adapters``) — sont des cas
+particuliers de ``BaseModule`` typés pour leur usage.
+``BaseModule`` reste le contrat **générique** pour les modules
+contribués par des tiers.
 """
 
 from __future__ import annotations

picarones/evaluation/benchmark_result.py

@@ -1,10 +1,5 @@
 """Modèle de données des résultats et export JSON (Cercle 2).
 
-Phase 4-ter — module relocalisé depuis ``picarones.core.results``
-vers le Cercle 2 (``evaluation``) où il appartient sémantiquement.
-Le chemin legacy reste disponible via un shim avec
-``DeprecationWarning`` ; suppression prévue en 2.0.
-
 Hiérarchie
 ----------
 BenchmarkResult

picarones/evaluation/corpus.py

@@ -1,18 +1,12 @@
-"""Chargement et gestion des corpus de documents (Cercle 2).
-
-Phase 4-quater — module relocalisé depuis ``picarones.core.corpus``
-vers le Cercle 2 (``evaluation``) où il appartient sémantiquement.
-Le chemin legacy reste disponible via un shim avec
-``DeprecationWarning`` ; suppression prévue en 2.0.
+"""Chargement et gestion des corpus de documents (couche 3 — evaluation).
 
 Coexistence avec ``domain.corpus.CorpusSpec``
 ---------------------------------------------
 ``evaluation.corpus`` (le présent module) porte les types **riches
-en behavior** historiquement utilisés par le runner de
-``measurements/`` : ``Document``, ``Corpus``, ``ArtifactType`` +
-payloads ``TextGT``/``AltoGT``/``PageGT``/``EntitiesGT``/
-``ReadingOrderGT`` chargés en mémoire, et la fonction
-``load_corpus_from_directory``.
+en behavior** consommés par ``BenchmarkService`` (couche 6) :
+``Document``, ``Corpus``, ``ArtifactType`` + payloads
+``TextGT``/``AltoGT``/``PageGT``/``EntitiesGT``/``ReadingOrderGT``
+chargés en mémoire, et la fonction ``load_corpus_from_directory``.
 
 ``domain.corpus.CorpusSpec`` + ``domain.documents.DocumentRef``
 (Pydantic, immutable, déclaratif) sont une vue **structurelle**

picarones/evaluation/metric_hooks.py

@@ -1,16 +1,11 @@
 """Registre typé des hooks de métriques document-level et corpus-level.
 
-Phase 4-ter — module relocalisé depuis ``picarones.core.metric_hooks``
-vers le Cercle 2 (``evaluation``) où il appartient sémantiquement.
-Le chemin legacy reste disponible via un shim avec
-``DeprecationWarning`` ; suppression prévue en 2.0.
-
 Pourquoi ce module
 ------------------
 Avant le « chantier 2 » du plan d'évolution post-Sprint 97,
-``picarones.measurements.runner._compute_document_result``
+``picarones.app.services.benchmark_runner._compute_document_result``
 contenait **11 imports tardifs codés en dur** vers
-``picarones.measurements.confusion``, ``char_scores``, ``taxonomy``, ``structure``,
+``picarones.evaluation.metrics.confusion``, ``char_scores``, ``taxonomy``, ``structure``,
 ``image_quality``, ``line_metrics``, ``hallucination``,
 ``philological_hooks``, ``searchability_hooks``,
 ``numerical_sequences_hooks``, ``readability_hooks`` — chacun enrobé

picarones/evaluation/metric_registry.py

@@ -1,4 +1,4 @@
-"""Registre typé de métriques (Phase 4-ter — relocalisation Cercle 2).
+"""Registre typé de métriques (couche 3 — evaluation).
 
 Pattern et données
 ------------------
@@ -7,30 +7,19 @@ le décorateur ``@register_metric``.  Chaque métrique enregistre une
 ``MetricSpec`` (nom + signature de types + callable) ; la sélection
 typée à une jonction se fait via ``select_metrics(input_types)``.
 
-Le runner d'une pipeline composée
-(:func:`picarones.evaluation.pipeline.PipelineRunner.run`) consomme ce
-registre pour évaluer automatiquement chaque jonction GT vs sortie.
-
 Différence avec ``picarones.evaluation.registry.MetricRegistry``
 ----------------------------------------------------------------
-Le présent module est le pattern **historique** : un registre
-unique global, alimenté par les imports des sous-packages (le
-``picarones.measurements.__init__`` est l'amorce qui s'occupe de
-charger tous les modules définissant des ``@register_metric``).
+Le présent module est le pattern **module-level** : un registre
+unique global, alimenté par les imports des sous-packages
+(``picarones.evaluation.metrics.__init__`` charge tous les modules
+définissant des ``@register_metric``).
 
 ``picarones.evaluation.registry.MetricRegistry`` est une **classe
-instanciable** (Sprint A14-S5) — un service applicatif l'instancie
-explicitement et y enregistre les métriques sans side-effect
-d'import.  Les deux patterns coexistent volontairement : le legacy
-fonctionne pour les ~30 métriques existantes, l'instance-based est
-réservé aux contributions tierces et au cadre des
-``EvaluationView`` (S20+).
-
-Phase 4-ter (présente)
-----------------------
-Module relocalisé depuis ``picarones.core.metric_registry``.  Le
-chemin legacy reste disponible via un shim avec
-``DeprecationWarning`` ; suppression prévue en 2.0.
+instanciable** — un service applicatif l'instancie explicitement
+et y enregistre les métriques sans side-effect d'import.  Les
+deux patterns coexistent : le module-level fonctionne pour les
+~37 métriques existantes, l'instance-based est réservé aux
+contributions tierces et au cadre des ``EvaluationView``.
 
 Exemple d'usage
 ---------------

picarones/evaluation/metric_result.py

@@ -1,16 +1,11 @@
-"""Modèle de données des métriques OCR/HTR (Cercle 2).
-
-Phase 4-ter — module relocalisé depuis ``picarones.core.metrics``
-vers le Cercle 2 (``evaluation``) où il appartient sémantiquement.
-Le chemin legacy reste disponible via un shim avec
-``DeprecationWarning`` ; suppression prévue en 2.0.
+"""Modèle de données des métriques OCR/HTR (couche 3 — evaluation).
 
 Abstractions pures pour représenter les métriques calculées sur
 une paire (référence, hypothèse) — pas de dépendance externe (pas
 de jiwer, pas de scipy).
 
 Le calcul effectif via jiwer vit dans
-:mod:`picarones.measurements.metrics` (``compute_metrics``).
+:mod:`picarones.evaluation.metrics.text_metrics` (``compute_metrics``).
 L'agrégation statistique vit ici car elle n'utilise que la stdlib
 (``statistics``).
 """

picarones/evaluation/metrics/__init__.py

@@ -1,56 +1,38 @@
 """Métriques — calculs purs sur des paires (référence, hypothèse).
 
-Sprint A14-S10 : déplacement de **23 fichiers de calcul autonomes**
-depuis ``picarones.measurements``.
+~37 modules de calcul autonomes :
 
 Calculs de qualité textuelle pure :
   ``rare_tokens``, ``lexical_modernization``, ``calibration``,
-  ``confusion``, ``line_metrics``.
+  ``confusion``, ``line_metrics``, ``text_metrics``.
 
 Calculs structurels et géométriques :
-  ``layout``, ``image_quality``, ``image_predictive``.
+  ``layout``, ``image_quality``, ``image_predictive``,
+  ``alto_metrics``, ``alto_structural``.
 
 Calculs économiques :
   ``pricing``, ``marginal_cost``, ``throughput``,
-  ``incremental_comparison``.
+  ``incremental_comparison``, ``cost_projection``.
 
 Calculs analytiques (post-traitement) :
-  ``error_absorption``, ``hallucination``, ``robustness_projection``,
-  ``longitudinal``, ``baseline_comparison``, ``levers``,
-  ``worst_lines``, ``module_policy``.
+  ``error_absorption``, ``hallucination``, ``robustness``,
+  ``robustness_projection``, ``longitudinal``,
+  ``baseline_comparison``, ``levers``, ``worst_lines``,
+  ``module_policy``, ``history``, ``modern_archives``.
 
 Calculs inter-moteurs :
-  ``inter_engine``, ``taxonomy_cooccurrence``,
+  ``inter_engine``, ``specialization``, ``taxonomy``,
+  ``taxonomy_intra_doc``, ``taxonomy_cooccurrence``,
   ``taxonomy_comparison``.
 
-Reste à migrer (différé)
-------------------------
+Calculs philologiques :
+  ``mufi``, ``abbreviations``, ``unicode_blocks``,
+  ``roman_numerals``, ``numerical_sequences``,
+  ``early_modern_typography``, ``reading_order``.
 
-Catégorie B — utilisent ``@register_metric`` du registre global
-``core.metric_registry`` (singleton avec side-effect d'import) :
-  ``mufi``, ``abbreviations``, ``unicode_blocks``, ``roman_numerals``,
-  ``early_modern_typography``, ``modern_archives``, ``reading_order``,
-  ``ner``, ``readability``, ``searchability``, ``numerical_sequences``.
-
-Migrés au S20 quand le ``MetricRegistry`` instancié explicitement
-(S5) deviendra le seul registre, via le ``registry_service``
-applicatif.
-
-Catégorie C — dépendances vers anciens packages :
-  ``robustness`` (importe ``picarones.evaluation.corpus`` +
-  ``picarones.adapters.legacy_engines.base`` + ``picarones.measurements.metrics``).
-  Ne peut être migré qu'après les Sprints S11 (déplacement des
-  adapters) et S12 (équivalence numérique).
-
-Catégorie D — dépendances inter-fichiers à orchestrer :
-  ``cost_projection`` (→ pricing), ``equivalence_profile``
-  (→ formats.text.normalization), ``specialization``
-  (→ inter_engine), ``taxonomy_intra_doc`` (→ taxonomy),
-  ``taxonomy`` (→ char_scores).
-
-Règle de migration (S10) : un fichier déplacé = un commit avec
-uniquement le déplacement et un re-export à l'ancien emplacement.
-La logique reste identique.  Aucun test modifié.
+Calculs sémantiques :
+  ``ner``, ``readability``, ``searchability``,
+  ``equivalence_profile``, ``over_normalization``.
 """
 
 from __future__ import annotations

picarones/evaluation/metrics/alto_metrics.py

@@ -17,7 +17,7 @@ enregistre quatre métriques natives (``alto_text_cer``,
 les opérateurs jiwer historiques sur le texte extrait des deux côtés.
 
 L'approche est strictement additive vis-à-vis de
-:mod:`picarones.measurements.metrics` : ce module ne touche pas le chemin de
+:mod:`picarones.evaluation.metrics.text_metrics` : ce module ne touche pas le chemin de
 calcul historique (``compute_metrics``), il enrichit uniquement le
 registre typé pour les pipelines composées.
 

picarones/evaluation/metrics/builtin_hooks.py

@@ -4,7 +4,7 @@ Chantier 2 du plan d'évolution post-Sprint 97.
 
 Ce module **migre** les 12 hooks document-level et 12 agrégateurs
 corpus-level qui étaient codés en dur dans
-``picarones.measurements.runner._compute_document_result`` et autour de la
+``picarones.app.services.benchmark_runner._compute_document_result`` et autour de la
 boucle d'agrégation (lignes 794-827 du runner pré-chantier-2).
 
 Approche additive — rétrocompat stricte

picarones/evaluation/metrics/cost_projection.py

@@ -20,7 +20,7 @@ le chercheur arbitre selon son budget.
 
 Dépendance
 ----------
-S'appuie sur ``picarones.measurements.pricing`` (Sprint 20) qui expose
+S'appuie sur ``picarones.evaluation.metrics.pricing`` (Sprint 20) qui expose
 ``EngineCost.cost_per_1k_pages_eur`` et
 ``co2_per_1k_pages_g``.
 """

picarones/evaluation/metrics/incremental_comparison.py

@@ -28,7 +28,7 @@ On ne reconstruit pas Friedman/Nemenyi (déjà dans Sprint 18) ;
 on agrège ici les données nécessaires pour qu'un
 tests statistique externe puisse les consommer.  Le rapport
 existant reste libre de brancher
-``picarones.measurements.statistics.friedman_test`` sur la sortie de
+``picarones.evaluation.statistics.friedman_test`` sur la sortie de
 ce module.
 
 Sortie

picarones/evaluation/metrics/normalization.py

@@ -6,7 +6,7 @@ rewrite ciblé (cf. ``docs/roadmap/rewrite-2026.md``).
 
 Ce fichier est conservé comme re-export pour ne **rien casser**
 chez les ~50 consommateurs qui font ``from
-picarones.measurements.normalization import X``.  Les symboles
+picarones.formats.text.normalization import X``.  Les symboles
 publics ET privés utilisés downstream (``_parse_exclude_chars``,
 ``_apply_diplomatic_table``) sont ré-exposés explicitement.
 

picarones/evaluation/metrics/numerical_sequences.py

@@ -1,11 +1,5 @@
 """Précision sur séquences numériques — Sprint 85 (A.II.5b).
 
-Phase 5.C.batch7 — module relocalisé depuis
-``picarones.measurements.numerical_sequences`` vers
-``picarones.evaluation.metrics.numerical_sequences``.  Le chemin
-legacy reste disponible via un shim avec ``DeprecationWarning`` ;
-suppression prévue en 2.0.
-
 Sprint 85 — A.II.5b du plan d'évolution 2026.
 
 Pourquoi ce module
@@ -23,7 +17,7 @@ Catégories couvertes
    (le module détecte les **années** sur 4 chiffres dans la
    plage [1000-2099]).
 2. **Numéraux romains** : ``MDCLXVIII``, ``XIV``, ``Tome IV``.
-   Réutilise ``picarones.measurements.roman_numerals`` (Sprint 60).
+   Réutilise ``picarones.evaluation.metrics.roman_numerals`` (Sprint 60).
 3. **Foliotation** : ``f. 12``, ``f. 12r``, ``fol. 24v``,
    ``p. 5``, ``pp. 12-15``, ``n° 42``.
 4. **Montants** : ``12 livres``, ``5 sols``, ``8 deniers``,

picarones/evaluation/metrics/robustness.py

@@ -33,13 +33,12 @@ from typing import TYPE_CHECKING, Any, Optional
 
 if TYPE_CHECKING:
     from picarones.evaluation.corpus import Corpus, Document
-    # ``BaseOCREngine`` (legacy ``adapters/legacy_engines/``) ne peut
-    # pas être importé statiquement depuis la couche ``evaluation/``
-    # (test_layer_imports_are_legal).  L'annotation utilise donc
-    # ``Any`` ; le check ``isinstance`` est fait dynamiquement par
-    # ``importlib`` si besoin (cas réel : duck typing suffit, l'objet
-    # passé doit juste avoir ``.run(image_path) -> EngineResult``).
-    BaseOCREngine = Any  # type: ignore[misc,assignment]
+    # Le moteur OCR passé à ``RobustnessAnalyzer`` n'est pas
+    # importé statiquement depuis la couche ``evaluation/`` (la
+    # règle inward-only interdit les imports vers ``adapters/``).
+    # L'annotation utilise donc ``Any`` ; le duck typing suffit :
+    # l'objet doit exposer ``.run(image_path) -> EngineResult``.
+    OCREngine = Any  # type: ignore[misc,assignment]
 
 logger = logging.getLogger(__name__)
 
@@ -413,7 +412,8 @@ class RobustnessAnalyzer:
     Parameters
     ----------
     engines:
-        Un ou plusieurs moteurs OCR (``BaseOCREngine``).
+        Un ou plusieurs adapters OCR (``BaseOCRAdapter`` — duck typing
+        suffit : l'objet doit exposer ``.run(image_path)``).
     degradation_types:
         Liste des types de dégradation à tester.
         Par défaut : tous (``"noise"``, ``"blur"``, ``"rotation"``,
@@ -425,16 +425,16 @@ class RobustnessAnalyzer:
 
     Examples
     --------
-    >>> from picarones.adapters.legacy_engines.tesseract import TesseractEngine
+    >>> from picarones.adapters.ocr.tesseract import TesseractAdapter
     >>> from picarones.evaluation.metrics.robustness import RobustnessAnalyzer
-    >>> engine = TesseractEngine(config={"lang": "fra"})
+    >>> engine = TesseractAdapter(config={"lang": "fra"})
     >>> analyzer = RobustnessAnalyzer([engine], degradation_types=["noise", "blur"])
     >>> report = analyzer.analyze(corpus)
     """
 
     def __init__(
         self,
-        engines: "list[BaseOCREngine]",
+        engines: "list[OCREngine]",
         degradation_types: Optional[list[str]] = None,
         cer_threshold: float = 0.20,
         custom_levels: Optional[dict[str, list]] = None,

picarones/evaluation/metrics/roman_numerals.py

@@ -1,11 +1,5 @@
 """Numéraux romains — Sprint 60.
 
-Phase 5.C.batch7 — module relocalisé depuis
-``picarones.measurements.roman_numerals`` vers
-``picarones.evaluation.metrics.roman_numerals``.  Le chemin legacy
-reste disponible via un shim avec ``DeprecationWarning`` ;
-suppression prévue en 2.0.
-
 Sprint 60 — Étape 3 / extension philologique transversale du plan
 d'évolution 2026.
 

picarones/evaluation/metrics/search.py

@@ -1,15 +1,7 @@
-"""Recherchabilité fuzzy + séquences numériques — Sprint A14-S16.
+"""Recherchabilité fuzzy + séquences numériques.
 
-Fonctions de calcul **pures** (sans ``@register_metric`` legacy)
-utilisées par ``SearchView``.  Réimplémente la logique des modules
-historiques ``picarones.measurements.searchability`` (Sprint 84)
-et ``picarones.measurements.numerical_sequences`` (Sprint 85),
-sans la dépendance vers le singleton global ``core.metric_registry``.
-
-Les modules legacy seront supprimés au S20 quand le
-``MetricRegistry`` instancié explicitement (S5) deviendra le seul
-registre.  En attendant, ce module fournit la version "couche
-evaluation" propre.
+Fonctions de calcul **pures** (sans décorateur ``@register_metric``)
+utilisées par ``SearchView``.
 
 Métriques livrées
 -----------------
@@ -20,11 +12,8 @@ Métriques livrées
 
 - ``numerical_sequence_preservation(reference, hypothesis)`` —
   fraction des séquences numériques de la GT préservées
-  strictement dans l'hypothèse.  Volontairement minimaliste pour
-  S16 : détecte uniquement les **années 4 chiffres** (proxy
-  réaliste pour les corpus patrimoniaux datés).  Le cas complet
-  (numéraux romains, foliations, monnaies, années régnales) reste
-  dans le legacy et sera réintégré au S20 avec le registre.
+  strictement dans l'hypothèse.  Détecte uniquement les **années
+  4 chiffres** (proxy réaliste pour les corpus patrimoniaux datés).
 
 Toutes les métriques ∈ [0, 1] avec ``higher_is_better=True``.
 """
@@ -42,8 +31,7 @@ import re
 def levenshtein_distance(a: str, b: str) -> int:
     """Distance de Levenshtein (substitution = insertion = suppression = 1).
 
-    Implémentation identique à ``picarones.measurements.searchability``
-    (Sprint 84) mais sans le décorateur ``@register_metric``.
+    Implémentation pure (sans décorateur ``@register_metric``).
     """
     if a == b:
         return 0
@@ -93,7 +81,7 @@ def searchability_recall(
     -------
     float
         ``n_retrouves / n_gt`` ∈ [0, 1].  ``0.0`` si la GT est
-        vide (convention identique au legacy Sprint 84).
+        vide.
     """
     if max_distance < 0:
         raise ValueError(f"max_distance doit être ≥ 0, reçu {max_distance}")
@@ -164,11 +152,10 @@ def numerical_sequence_preservation(
 
     Note méthodologique
     -------------------
-    Volontairement minimaliste pour S16 : seules les années 4
-    chiffres sont détectées.  Le pattern complet (numéraux romains,
-    foliations ``f. 12r``, monnaies, années régnales ``an III``)
-    reste dans ``picarones.measurements.numerical_sequences``
-    (Sprint 85) et sera réintégré dans la couche evaluation au S20.
+    Volontairement minimaliste : seules les années 4 chiffres sont
+    détectées.  Le pattern complet (numéraux romains, foliations
+    ``f. 12r``, monnaies, années régnales ``an III``) n'est pas
+    couvert ici.
 
     Multi-set : si la GT contient ``"1789"`` deux fois et
     l'hypothèse une fois, seul un est compté préservé.

picarones/evaluation/metrics/specialization.py

@@ -32,7 +32,7 @@ intuitive :
 
 Dépendances
 -----------
-S'appuie strictement sur ``picarones.measurements.inter_engine`` (Sprint
+S'appuie strictement sur ``picarones.evaluation.metrics.inter_engine`` (Sprint
 35) — pas de double calcul, pas de logique nouvelle de
 divergence.
 """

picarones/evaluation/registry/registry.py

@@ -8,13 +8,10 @@ pas de décorateur magique.
 
 Différence avec ``picarones.evaluation.metric_registry``
 --------------------------------------------------------
-L'autre registre (relocalisé depuis ``picarones.core.metric_registry``
-en Phase 4-ter) utilise un dict module-level
-``_METRIC_REGISTRY`` rempli par un décorateur ``@register_metric``
-appliqué au top-level d'autres modules.  Conséquence : un
-``import picarones`` charge ~50 sous-modules pour amorcer le
-registre — anti-pattern documenté dans
-``BACKLOG_POST_LIVRAISON.md`` §2.4.
+L'autre registre utilise un dict module-level ``_METRIC_REGISTRY``
+rempli par un décorateur ``@register_metric`` appliqué au top-level
+d'autres modules.  Conséquence : un ``import picarones`` charge
+~50 sous-modules pour amorcer le registre.
 
 Ici, ``MetricRegistry`` est une classe instanciable :
 

picarones/evaluation/statistics/__init__.py

@@ -19,9 +19,6 @@ Familles
 
 Migration Phase 2
 -----------------
-
-Migré depuis :mod:`picarones.measurements.statistics` qui devient
-un shim re-export avec ``DeprecationWarning``.  Comportement
 identique bit-for-bit (même seed pour le bootstrap, mêmes
 algorithmes scipy, même rendu SVG).  Suppression du shim legacy
 en version 2.0.

picarones/evaluation/statistics/friedman_nemenyi.py

@@ -6,7 +6,7 @@ Standard de facto pour comparer plusieurs systèmes sur plusieurs
 datasets — ici plusieurs moteurs OCR sur plusieurs documents.
 
 Le rendu visuel canonique (Critical Difference Diagram) vit dans
-:mod:`picarones.measurements.statistics.cdd_render` pour séparer
+:mod:`picarones.evaluation.statistics.cdd_render` pour séparer
 calcul (ce module) et présentation (l'autre).
 """
 

picarones/evaluation/statistics/wilcoxon.py

@@ -215,7 +215,7 @@ def compute_pairwise_stats(
 
 __all__ = [
     # Symboles publics : signature stable, consommés directement par les
-    # tests via le ré-export de ``picarones.measurements.statistics``.
+    # tests via le ré-export de ``picarones.evaluation.statistics``.
     "compute_pairwise_stats",
     "wilcoxon_test",
     # Symboles privés ré-exportés (consommés par certains tests) :

picarones/evaluation/synthetic.py

@@ -496,7 +496,7 @@ def generate_sample_benchmark(
         document_count=n_docs,
         engine_reports=engine_reports,
         metadata={
-            "description": "Données de démonstration générées par picarones.fixtures",
+            "description": "Données de démonstration synthétiques",
             "script": "gothique textura",
             "langue": "Français médiéval (XIVe-XVe siècle)",
             "institution": "Département des manuscrits",

picarones/formats/__init__.py

@@ -13,7 +13,7 @@ Sous-packages :
 - ``pagexml/`` — PAGE XML (PRIMA, transkribus).
 - ``text/`` — normalisation texte (NFC, casefold, profils
   diplomatiques, exclusion de caractères).  Cible du déplacement
-  de ``picarones.measurements.normalization`` au Sprint S9.
+  de ``picarones.formats.text.normalization`` au Sprint S9.
 
 Règle d'import : ces modules peuvent importer ``lxml`` et
 ``defusedxml``.  Ils ne doivent **jamais** importer un moteur OCR

picarones/i18n.py

@@ -1,24 +0,0 @@
-"""``picarones.i18n`` — shim re-export (déprécié, suppression 2.0).
-
-Canonique : :mod:`picarones.reports.i18n`.  Phase 5.E du retrait
-du legacy.
-"""
-
-from __future__ import annotations
-
-import warnings
-
-from picarones.reports.i18n import *  # noqa: F401, F403
-from picarones.reports.i18n import (  # noqa: F401
-    TRANSLATIONS,
-    SUPPORTED_LANGS,
-    get_labels,
-    reload_translations,
-)
-
-warnings.warn(
-    "picarones.i18n is deprecated and will be removed in 2.0.  "
-    "Import from picarones.reports.i18n instead.",
-    DeprecationWarning,
-    stacklevel=2,
-)

picarones/interfaces/cli/__init__.py

@@ -326,9 +326,10 @@ def demo_cmd(
         picarones demo --with-robustness
         picarones demo --with-history --with-robustness --docs 8
     """
-    # Sprint G du plan v2.0 — ``picarones.fixtures`` reste legacy
-    # top-level ; import dynamique pour respecter
-    # ``test_layer_imports_are_legal[layer-interfaces]``.
+    # Import dynamique pour respecter ``test_layer_imports_are_legal``
+    # (les imports top-level depuis ``interfaces/`` sont scannés à
+    # l'import-time, et l'analyseur s'exécute sans avoir loadé tous
+    # les modules).
     import importlib
     generate_sample_benchmark = importlib.import_module(
         "picarones.evaluation.synthetic",

picarones/interfaces/web/jobs.py

@@ -12,7 +12,7 @@ Avant le Sprint 26, l'état des benchmarks vivait uniquement en mémoire dans
    au-delà de ce que ``BenchmarkJob.events`` portait en RAM.
 
 Le Sprint 26 adresse les trois en persistant les jobs et leurs événements
-dans une base SQLite locale (cohérent avec ``picarones.measurements.history``,
+dans une base SQLite locale (cohérent avec ``picarones.evaluation.metrics.history``,
 qui utilise déjà SQLite). La base joue trois rôles :
 
 - **Source de vérité** pour le statut/progression d'un job — ``BenchmarkJob``

picarones/pipeline/__init__.py

@@ -45,7 +45,7 @@ Modules livrés au S8
 Cible du Sprint S12
 -------------------
 Équivalence numérique CER/WER avec l'ancien
-``measurements.runner`` à 1e-9 près sur les fixtures.
+``BenchmarkService`` à 1e-9 près sur les fixtures.
 """
 
 from __future__ import annotations

picarones/pipeline/llm_pipeline_builder.py

@@ -1,14 +1,13 @@
-"""Builder de ``PipelineSpec`` pour les chaînes OCR + LLM (Phase 6 volet 2).
+"""Builder de ``PipelineSpec`` pour les chaînes OCR + LLM.
 
-Ce module fournit la convergence entre les 3 modes historiques de
-``picarones.pipelines.base.OCRLLMPipeline`` (legacy) et la
-``PipelineSpec`` canonique exécutable par ``PipelineExecutor``.
+Construit une ``PipelineSpec`` exécutable par ``PipelineExecutor``
+à partir d'un mode + des noms d'adapters.
 
-Mapping mode legacy → spec canonique
-------------------------------------
+Modes
+-----
 
 ================ ============= =========== ================================
-Mode legacy      Initial input Steps       Output final
+Mode             Initial input Steps       Output final
 ================ ============= =========== ================================
 ``text_only``    IMAGE         OCR + LLM   ``CORRECTED_TEXT``
 ``text_and_image`` IMAGE       OCR + LLM   ``CORRECTED_TEXT`` (LLM voit aussi IMAGE)
@@ -26,22 +25,7 @@ L'adapter OCR amont (Tesseract, Pero, Mistral OCR, Google Vision,
 Azure DI, ou ``precomputed`` quand le corpus porte déjà l'OCR) est
 quelconque tant qu'il déclare ``output_types ⊇ {RAW_TEXT}``.
 
-Exemple de migration
---------------------
-Code legacy ::
-
-    from picarones.adapters.legacy_pipelines import OCRLLMPipeline, PipelineMode
-    from picarones.adapters.legacy_engines.tesseract import TesseractEngine
-    from picarones.adapters.llm import OpenAIAdapter
-
-    pipeline = OCRLLMPipeline(
-        ocr_engine=TesseractEngine({"lang": "fra"}),
-        llm_adapter=OpenAIAdapter(model="gpt-4o"),
-        mode=PipelineMode.TEXT_ONLY,
-    )
-    result = pipeline.run("scan.jpg")  # → EngineResult
-
-Code canonique équivalent ::
+Usage ::
 
     from picarones.pipeline import PipelineExecutor
     from picarones.pipeline.llm_pipeline_builder import (
@@ -119,10 +103,10 @@ def make_ocr_llm_pipeline_spec(
         Format scalaire (``str``, ``int``, ``float``, ``bool``).
     llm_params:
         Paramètres dynamiques passés au step LLM/VLM au runtime.
-        Cas typique (Sprint B du plan v2.0) :
+        Cas typique :
         ``{"prompt_template": "Corrige : {ocr_output}"}`` permet à
-        un caller de spécifier un template legacy ou rewrite sans
-        toucher à la config de l'adapter.
+        un caller de spécifier un template ad-hoc sans toucher à la
+        config de l'adapter.
 
     Returns
     -------

picarones/pipeline/llm_pipeline_config.py

@@ -1,44 +1,20 @@
-"""``OCRLLMPipelineConfig`` — container canonique pour pipelines OCR+LLM.
-
-Sprint H.2.b/c du plan v2.0 — équivalent canonique de
-``picarones.adapters.legacy_pipelines.base.OCRLLMPipeline``.
-
-Pourquoi
---------
-``OCRLLMPipeline`` (legacy) :
-
-- hérite de ``BaseOCREngine`` (legacy),
-- expose une méthode ``run(image_path) → EngineResult``,
-- mélange contrat d'exécution et configuration.
-
-Cette config canonique :
-
-- est un container *pur* (immutable, pas de logique d'exécution),
-- accepte un ``BaseOCRAdapter`` (canonique) au lieu d'un
-  ``BaseOCREngine`` (legacy) pour le step OCR amont,
-- ne dépend pas du legacy.
-
-L'exécution effective passe par ``PipelineExecutor`` qui consomme
-une ``PipelineSpec`` construite via ``make_ocr_llm_pipeline_spec``.
-
-Duck-typing compat
-------------------
-Pour faciliter la migration progressive,
-``OCRLLMPipelineConfig`` expose les mêmes attributs/propriétés
-que ``OCRLLMPipeline`` legacy :
-
-- ``is_pipeline = True``,
-- ``ocr_engine`` (alias de ``ocr_adapter`` côté canonique),
-- ``llm_adapter``,
-- ``mode`` (string, pas enum — tolérance ajoutée dans
-  ``_ocr_llm_pipeline_to_spec``),
-- ``prompt_template``,
-- ``name``.
-
-Les helpers
-``picarones.app.services.benchmark_runner.engine_to_pipeline_spec``
-et ``build_adapter_resolver`` traitent donc indifféremment les
-deux types.
+"""``OCRLLMPipelineConfig`` — container pour pipelines OCR+LLM.
+
+Container *pur* (immutable, pas de logique d'exécution) qui décrit
+un pipeline composé OCR amont + LLM aval.  L'exécution effective
+passe par ``PipelineExecutor`` qui consomme une ``PipelineSpec``
+construite via ``make_ocr_llm_pipeline_spec``.
+
+Attributs exposés
+-----------------
+- ``is_pipeline = True`` — marker consommé par ``benchmark_runner``
+  pour distinguer un pipeline composé d'un OCR seul.
+- ``ocr_engine`` (alias de ``ocr_adapter``) — adapter OCR amont.
+- ``llm_adapter`` — adapter LLM aval.
+- ``mode`` — string parmi ``text_only`` / ``text_and_image`` /
+  ``zero_shot``.
+- ``prompt_template`` — template de prompt pour le LLM.
+- ``name`` — nom du pipeline pour l'identification dans le rapport.
 """
 
 from __future__ import annotations
@@ -128,12 +104,12 @@ class OCRLLMPipelineConfig:
 
     @property
     def ocr_engine(self) -> Any | None:
-        """Compat duck-typing avec ``OCRLLMPipeline`` legacy.
+        """Alias historique de ``ocr_adapter``.
 
         Les helpers ``_ocr_llm_pipeline_to_spec`` et
-        ``build_adapter_resolver`` accèdent à ``pipeline.ocr_engine``
-        — on expose ``ocr_adapter`` sous ce nom pour la
-        rétro-compatibilité du wiring existant.
+        ``build_adapter_resolver`` accèdent à ``pipeline.ocr_engine`` ;
+        on expose ``ocr_adapter`` sous ce nom pour préserver leur
+        wiring.
         """
         return self.ocr_adapter
 

picarones/reports/_helpers/__init__.py

@@ -7,11 +7,6 @@ Ce sous-package abrite les utilitaires purs et stables :
 - ``render_helpers`` — fonctions de rendu HTML/CSS communes.
 - ``assets`` — bundling JS + CSS + glossaire dans le rapport
   autonome.
-
-Phase 5 du retrait du legacy.  Ces modules viennent de
-``picarones.report.*`` ; les chemins legacy restent disponibles
-via des shims avec ``DeprecationWarning`` jusqu'à ce que tous les
-renderers thématiques aient migré.
 """
 
 from __future__ import annotations

picarones/reports/_helpers/assets.py

@@ -1,10 +1,5 @@
 """Chargement et préparation des assets du rapport HTML.
 
-Phase 5 — module relocalisé depuis ``picarones.report.assets`` vers
-``picarones.reports._helpers.assets``.  Le chemin legacy reste
-disponible via un shim avec ``DeprecationWarning`` ; suppression
-prévue en 2.0.
-
 Ce module concentre tout ce qui touche aux ressources binaires
 embarquées ou référencées par le rapport :
 

picarones/reports/_helpers/colors.py

@@ -1,10 +1,5 @@
 """Palettes de couleurs CSS — partagées entre rapport HTML et modules de rendu.
 
-Phase 5 — module relocalisé depuis ``picarones.report.colors`` vers
-``picarones.reports._helpers.colors``.  Le chemin legacy reste
-disponible via un shim avec ``DeprecationWarning`` ; suppression
-prévue en 2.0.
-
 Sprint A7 (item m-5 de l'audit institutional-readiness-2026-05) :
 introduction d'une **palette daltonien-friendly** (Okabe-Ito) qui
 remplace la palette historique rouge/vert/orange (problématique pour

picarones/reports/_helpers/render_helpers.py

@@ -1,11 +1,5 @@
 """Helpers de rendu mutualisés.
 
-Phase 5 — module relocalisé depuis
-``picarones.report.render_helpers`` vers
-``picarones.reports._helpers.render_helpers``.  Le chemin legacy
-reste disponible via un shim avec ``DeprecationWarning`` ;
-suppression prévue en 2.0.
-
 Centralise les fonctions de coloration et le builder de grille SVG qui
 étaient auparavant dupliqués dans chaque ``*_render.py``. Avant cette
 consolidation, le projet comptait 25 versions différentes de