diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000000000000000000000000000000000000..f17f26d520a67f4294aea96c5c2e15ea4d92dbe5
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,8 @@
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.pdf filter=lfs diff=lfs merge=lfs -text
+*.woff2 filter=lfs diff=lfs merge=lfs -text
+*.woff filter=lfs diff=lfs merge=lfs -text
+*.otf filter=lfs diff=lfs merge=lfs -text
+*.ttf filter=lfs diff=lfs merge=lfs -text
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..51b06bb4ef3ba5048ba7942db274ea55171d2482
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,90 @@
+# Image **moteur** Cinoc pour un Hugging Face Space (SDK: docker).
+#
+# ≠ la vitrine lecture seule (deploy/Dockerfile{,.space}) : celle-ci **bake un vrai
+# moteur OCR gratuit** (Tesseract 5 + langues fra/lat/eng) pour qu'un visiteur du
+# Space public lance un run Tesseract **sans clé ni installation**. Les moteurs
+# cloud et les plugins tiers restent *gated* (mode public, fail-closed côté appli).
+#
+# Contexte de build « racine plate » (Dockerfile / requirements.txt / pyproject.toml
+# / cinoc / reports TOUS à la racine) — assemblé par .github/workflows/deploy-space.yml,
+# comme Dockerfile.space.
+FROM python:3.11-slim
+
+# ── Dépendances système : Tesseract 5 + langues + libs image (Pillow) ──────────
+# Les langues sont baquées (pas téléchargées au runtime) : un Space free-tier n'a
+# pas d'accès réseau garanti au démarrage, et le déterminisme exige une version de
+# binaire figée. ``fra`` est le besoin patrimonial central ; ``lat`` (latin) et
+# ``eng`` complètent. Pas de pin de version exacte (Debian point-release rebump
+# fréquemment ``5.3.0-2`` → ``+deb12u1`` → casse le build) : la repro repose sur la
+# capture de ``tesseract --version`` dans ``RunManifest.system_binaries_lock``.
+RUN apt-get update -o Acquire::Retries=3 \
+    && apt-get install -y --no-install-recommends -o Acquire::Retries=3 \
+        tesseract-ocr \
+        tesseract-ocr-fra \
+        tesseract-ocr-lat \
+        tesseract-ocr-eng \
+        libtiff6 \
+        libjpeg62-turbo \
+        libpng16-16 \
+        libwebp7 \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# ── Variables d'exécution ──────────────────────────────────────────────────────
+# TESSDATA_PREFIX : emplacement Debian bookworm des modèles Tesseract 5.
+ENV TESSDATA_PREFIX=/usr/share/tesseract-ocr/5/tessdata
+# OMP_THREAD_LIMIT=1 : OBLIGATOIRE sur free-tier 2 vCPU. Tesseract LSTM (oem 3)
+# parallélise via OpenMP ; non borné sur un CPU partagé il **deadlock** (incident
+# documenté côté Picarones, 2026-05-16) — l'OCR gèle et chaque document timeoute.
+# Mono-thread par appel = plus rapide ET déterministe ici.
+ENV OMP_THREAD_LIMIT=1
+# Mode public (verrou *fail-closed*) **non forcé** : par défaut l'instance exécute
+# ses moteurs (cloud compris) avec la clé de l'opérateur — pas de 403. Qui expose
+# un Space **public** et veut protéger sa clé d'un visiteur pose lui-même
+# CINOC_PUBLIC_MODE=true (alors seul le socle gratuit tesseract s'exécute).
+ENV PYTHONUNBUFFERED=1
+
+# ── Smoke-test du binaire au BUILD (fail-fast) ─────────────────────────────────
+# Un Tesseract cassé OU figé doit casser le BUILD (le Space garde l'image
+# précédente fonctionnelle), pas déployer une image qui gèle en silence :
+#   (a) le binaire charge ses libs et expose la langue ``fra`` (sinon build refusé) ;
+#   (b) une reconnaissance réelle sur une image générée se TERMINE sous 30 s — un
+#       timeout (rc 124) = deadlock OpenMP / libs incohérentes → build refusé.
+RUN set -eu; \
+    timeout 30 tesseract --version; \
+    timeout 30 tesseract --list-langs 2>&1 | grep -qx fra; \
+    printf 'P1\n16 16\n' > /tmp/smoke.pbm; \
+    i=0; while [ "$i" -lt 16 ]; do \
+        printf '1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0\n' >> /tmp/smoke.pbm; \
+        i=$((i + 1)); \
+    done; \
+    rc=0; \
+    timeout 30 tesseract /tmp/smoke.pbm - -l fra --psm 6 >/dev/null 2>&1 || rc=$?; \
+    rm -f /tmp/smoke.pbm; \
+    if [ "$rc" = 124 ]; then \
+        echo "FATAL: tesseract a gelé (timeout) — build refusé, libs incohérentes." >&2; \
+        exit 1; \
+    fi
+
+# ── Utilisateur non-root (sécurité d'un service exposé) ────────────────────────
+RUN useradd --create-home --uid 1000 cinoc
+WORKDIR /home/cinoc/app
+
+# ── Dépendances Python d'abord (cache de couche) ───────────────────────────────
+# requirements.txt fige le cœur + l'extra [serve] + pytesseract (wrapper du binaire).
+COPY requirements.txt ./requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# ── Code + paquet (sans deps : tout est déjà figé ci-dessus) ───────────────────
+COPY pyproject.toml README.md ./
+COPY cinoc ./cinoc
+RUN pip install --no-cache-dir --no-deps .
+
+# ── Rapports bakés (lecture seule) — dossier toujours présent ──────────────────
+COPY reports ./reports
+ENV CINOC_REPORTS_DIR=/home/cinoc/app/reports
+
+USER cinoc
+EXPOSE 7860
+# 0.0.0.0 attendu en conteneur (le réseau est géré par la plateforme).
+CMD ["cinoc", "serve", "--host", "0.0.0.0", "--port", "7860"]
diff --git a/README.md b/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..584fbe6c9aa845ca3c7f4a2fc2d09605fbb70be1
--- /dev/null
+++ b/README.md
@@ -0,0 +1,52 @@
+---
+title: Cinoc — banc d'essai OCR/HTR/VLM
+emoji: 📜
+colorFrom: indigo
+colorTo: gray
+sdk: docker
+app_port: 7860
+pinned: false
+license: apache-2.0
+---
+
+# Cinoc — banc d'essai OCR/HTR/VLM
+
+Banc d'essai **déterministe** de pipelines de transcription (OCR / HTR / VLM).
+Ce Space **exécute un vrai OCR Tesseract gratuitement** — **sans clé ni
+installation** : déposez un corpus, lancez Tesseract, obtenez un rapport CER/WER/MER
+réel. Il sert aussi des rapports `RunResult` pré-calculés, rendus en HTML autonome.
+
+- `/` — liste des rapports disponibles
+- `/library` — préparer un corpus (upload ZIP)
+- `/benchmark` — lancer un run **Tesseract** (gratuit, local) sur un corpus
+- `/reports/<nom>` — un rapport rendu en HTML
+- `/health` — sonde de vivacité
+
+**Par défaut, l'instance exécute ses moteurs avec la clé de son opérateur** —
+aucun blocage. Sans clé posée, seul le **socle gratuit** tourne (Tesseract, aucun
+secret, aucun appel facturé) ; dès qu'une clé est présente (`MISTRAL_API_KEY`,
+`OPENAI_API_KEY`…), les moteurs **cloud** (OCR→LLM, VLM) s'exécutent normalement.
+
+## Utiliser un moteur cloud (Mistral, OpenAI…)
+
+1. **Secret** : `MISTRAL_API_KEY` = votre clé (Settings → Variables and secrets).
+   Le SDK `mistralai` est déjà dans `requirements.txt`. Redéployez.
+2. C'est tout : le menu déroulant « Modèle » du Banc d'essai se remplit directement
+   depuis l'API Mistral (`models.list`) et les prompts sont éditables par concurrent.
+
+> 🔴 **Sécurité** : sur un Space **public**, la clé que vous posez est dépensable par
+> n'importe quel visiteur. Rendez le Space **Private** (Settings → Visibility →
+> Private) si vous y posez une clé facturée, **ou** activez le verrou ci-dessous.
+
+## Verrou « mode public » — opt-in, pour protéger une clé sur un Space public
+
+Si vous tenez à exposer un Space **public** *tout en* gardant une clé posée sans
+qu'un visiteur puisse la dépenser, activez le verrou **fail-closed** : variable
+`CINOC_PUBLIC_MODE` = `true` (Settings → Variables and secrets). Alors seul le
+**socle gratuit** (Tesseract) s'exécute ; les moteurs **cloud**, les **imports
+distants** (IIIF/Gallica/…) et les **plugins tiers** sont **refusés** (`403`). Le
+verrou est **désactivé par défaut** : ne le posez que si ce scénario est le vôtre.
+
+> Ce fichier est l'en-tête de configuration du Space Hugging Face (`sdk: docker`).
+> Au déploiement, il devient le `README.md` racine du dépôt du Space ; le
+> `Dockerfile` et `requirements.txt` vivent dans `deploy/`.
diff --git a/cinoc/_version.py b/cinoc/_version.py
new file mode 100644
index 0000000000000000000000000000000000000000..b8e5f34a9b90665b36c92166910e9da5b283f040
--- /dev/null
+++ b/cinoc/_version.py
@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.1.dev1+g7ca8e2eab'
+__version_tuple__ = version_tuple = (0, 1, 1, 'dev1', 'g7ca8e2eab')
+
+__commit_id__ = commit_id = 'g7ca8e2eab'
diff --git a/cinoc/adapters/ANALYSE_COUCHE_5.md b/cinoc/adapters/ANALYSE_COUCHE_5.md
new file mode 100644
index 0000000000000000000000000000000000000000..e093a4c77c44c18dcbe3120a5ecf0130b993903f
--- /dev/null
+++ b/cinoc/adapters/ANALYSE_COUCHE_5.md
@@ -0,0 +1,271 @@
+# ANALYSE_COUCHE_5.md — `adapters/` (Picarones → Cinoc)
+
+> **Type** : session d'ANALYSE (ne code rien). Guide de portage **durable**.
+> **Couche** : 5 = `adapters` (cf. `CLAUDE.md` §3 : `domain(1) ← formats(2) ← evaluation(3) ← pipeline(4) ← adapters(5) ← app(6) ← reports(7) ← interfaces(8)`).
+> **Source gelée** : `../Picarones/picarones/adapters/` — **41 fichiers, 9 682 LOC** (mesuré).
+> **Cible** : `cinoc/adapters/`.
+> **Couches amont mergées dont on dépend** : `domain` (mergée), `formats` (mergée), `evaluation` (plan acté `MIGRATION_COUCHE_3.md`), `pipeline` (à venir — porte le **contrat de module**).
+> **Partie 1 = durable** (source figée). **Partie 2 = périssable** (« à confirmer à la tranche »).
+
+---
+
+## 0. Drapeaux à lever AVANT toute construction (lire en premier)
+
+| # | Drapeau | Statut | Action |
+|---|---|---|---|
+| **F-0** | La consigne d'analyse disait « Couche4 », le titre/ livrable disent « couche 5 ». | Coquille. `CLAUDE.md` §3 + `PROMPT_ANALYSE_COUCHE.md` confirment **couche 5 = `adapters`**. | Aucun conflit. Analysé = `adapters`. |
+| **F-1** | `CLAUDE.md` D1 décrit le legacy comme « double contrat **`BaseOCRAdapter`→`BaseModule`** ». **Le code gelé ne contient PAS cet héritage.** | `base.py:58` = `class BaseOCRAdapter(ABC)` ; `llm/base.py:202` = `class BaseLLMAdapter(ABC)` ; **aucun n'hérite de `BaseModule`**. Le vrai contrat runtime est **`StepExecutor`** (`pipeline/protocols.py:42`, `execute(...)`). `BaseModule` (`domain/module_protocol.py`, `process(...)`) est **vestigial** : sa docstring `:24-27` *prétend* (à tort) que les adapters en sont des cas particuliers ; ses seuls usages sont un ré-export dans `__init__` + `evaluation/metrics/module_policy.py` (lui-même classé « mort » par `MIGRATION_COUCHE_3.md` §11). | **Ne PAS s'arrêter** : la *décision* D1 (un seul `Protocol` en couche 4, `BaseModule` supprimé) reste **correcte et même renforcée** — Picarones a déjà ce `Protocol` unique (`StepExecutor`). Seule la *caractérisation factuelle* de la source est à corriger : il s'agit d'un contrat **vestigial parallèle** (`BaseModule.process`), pas d'un emballage. Documenté §1.2. |
+| **F-2** | `CLAUDE.md` §8.8 dit « 8+8+8 adapters LLM/VLM ». | Réalité : **8 OCR + 4 LLM + 4 VLM**. | Direction (« → minimal/starter ») valide ; chiffres rectifiés §1.1. |
+| **F-3** | `_fallback_log.py` n'a qu'un consommateur final : le **détecteur narratif** `IMPORTER_FALLBACK_TRIGGERED`. | Or le **moteur narratif est SUPPRIMÉ** (`CLAUDE.md` §6, D2). | ⇒ « pas de consommateur = supprimé ». Verdict **SUPPRIMER** (remplacé par `logger.warning`). §1.3-corpus. |
+
+Aucun de ces points ne contredit une couche **mergée** ni une décision actée → analyse poursuivie.
+
+---
+
+# PARTIE 1 — ANALYSE DE LA SOURCE PICARONES (durable)
+
+## 1.1 Inventaire exact (41 fichiers / 9 682 LOC)
+
+| Sous-paquet | Fichiers | LOC | Rôle vérifié |
+|---|---|---|---|
+| **`/` (utils racine)** | 6 | **866** | I/O atomique, retry, http(x), downscale image, résolution de chemins. Mutualisés OCR+LLM. |
+| **`ocr/`** | 12 | **3 206** | Contrat `BaseOCRAdapter` + factory + 8 moteurs + sidecar confidences. |
+| **`corpus/`** | 8 | **3 045** | Importeurs de corpus patrimoniaux (IIIF, Gallica, eScriptorium, HTR-United, HuggingFace) + http urllib anti-SSRF + journal fallback. |
+| **`llm/`** | 6 | **1 208** | Post-correction texte (`RAW_TEXT → CORRECTED_TEXT`). Base + 4 providers. |
+| **`storage/`** | 3 | **964** | `ArtifactStore` (cache fichier) + `JobStore` (SQLite jobs web). |
+| **`vlm/`** | 6 | **393** | Transcription `IMAGE → RAW_TEXT` zéro-OCR. Base + 4 manifestes de composition. |
+
+Libs externes (toutes confinées à `adapters/`, conforme `CLAUDE.md` §3) : `pytesseract`+`PIL` (tesseract), `kraken`, `calamari-ocr`+TF, `pero-ocr`+torch, `google-cloud-vision`, `azure-ai-documentintelligence`, `mistralai`, `openai`, `anthropic`, `httpx` (ollama — **dép. cœur**, pas un extra), `datasets` (hf), `yaml`/`tqdm` (corpus). Le **noyau de contrat** (`ocr/base.py`, `factory.py`, `confidences.py`, `llm/base.py`, `vlm/base.py`, utils racine) n'importe **aucune** lib tierce sauf `httpx`/`PIL`.
+
+## 1.2 Le contrat réel (la couture décisive `domain↔pipeline↔adapters`)
+
+**Trois contrats coexistent ; un seul est vivant côté runtime.**
+
+| Contrat | Lieu | Forme | Statut réel |
+|---|---|---|---|
+| `BaseModule` | `domain/module_protocol.py:39` | `process(inputs)→outputs`, types `tuple`, **aucun** concern d'exécution | **Vestigial.** Aucun adapter ne l'hérite ni ne l'implémente. Consommateurs : ré-export `__init__` + `module_policy.py` (mort). |
+| **`StepExecutor`** | `pipeline/protocols.py:42` | `name`,`input_types`/`output_types` (`frozenset`), **`execute(inputs, params, context: RunContext, control: RunControl) → dict[ArtifactType, Artifact]`** | **Contrat vivant.** Porte deadline (`context.deadline`) + annulation (`control`). Satisfait par **duck-typing** (jamais hérité). |
+| `BaseOCRAdapter` / `BaseLLMAdapter` / `BaseVLMAdapter` | `adapters/{ocr,llm,vlm}/base.py` | ABC d'**implémentation** (défauts `input_types`/`output_types`, helpers, `name`/`execute` abstraits) | Ce sont des **mixins d'implémentation**, **pas** un second contrat. `BaseVLMAdapter(BaseLLMAdapter)` ; les deux autres `(ABC)`. |
+
+**Résolution `adapter_name → executor`** : pas de registre. `build_adapter_resolver(engines)` (`app/services/_benchmark_adapter_resolver.py:215`) construit un `dict[str, StepExecutor]` à partir d'**instances** d'engines fabriquées en amont, et lève `PicaronesError` sur collision de `name` à configs distinctes. La factory `ocr_adapter_from_name` (`ocr/factory.py:64`) est une **cascade `if/elif` codée en dur** (anti-OCP). **Aucune découverte de plugins entry-points** (`registry_service.py:39` le dit explicitement). Seule extensibilité « tierce » : `adapter_class: dotted.path` dans le YAML `run_spec` (`app/schemas/run_spec.py:32-62`), classe importable dans le venv.
+
+> ⚠️ **Conséquence pour Cinoc** : le `Protocol` de module que `CLAUDE.md` D1 veut construire en **couche 4** ≈ **`StepExecutor` déjà existant**. Les adapters l'implémentent **directement**. `BaseModule` est **supprimé sans perte**. *(`version` manque dans `StepExecutor`/`BaseOCRAdapter` → à **ajouter** pour la repro `RunManifest`, cf. §2.1.)*
+
+## 1.3 Verdicts fichier par fichier — **PROVISOIRE — à confirmer au build**
+
+Légende verdict : **G**=garder · **M**=modifier · **C**=changer de couche · **S**=supprimer · **I**=incrémental (porter à la tranche qui le consomme, pas avant).
+
+### Utils racine (`adapters/*.py`)
+
+| Fichier | LOC | Rôle vérifié | Consommateurs réels (hors tests) | Bugs / dette | Verdict |
+|---|---|---|---|---|---|
+| `__init__.py` | 28 | Docstring de paquet, `__all__=[]`. | 0 (imports par chemin complet). | — | **G** (mince) |
+| `_atomic_io.py` | 151 | `atomic_write_text` (tmp+`fsync`+`os.replace`). | `atomic_write_text` : **11 adapters**. | `atomic_write_bytes` = **0 conso** (mort). Corps dupliqué text/bytes. | **M** : garder `atomic_write_text`, **S** `atomic_write_bytes`. **`storage/` doit l'utiliser** (cf. infra). |
+| `_httpx_helpers.py` | 213 | Client httpx deadline-aware + cancel cross-thread (`make_httpx_client`, `translate_or_reraise`). | **1** (`llm/ollama_adapter`). | Détection « close » par **heuristique de message** (`:179-190`) fragile. Couple `adapters→pipeline.run_control`. | **G+M** (revoir l'heuristique ; unifier la trad. d'erreur). |
+| `_image.py` | 87 | Downscale image base64 (`PIL` lazy, dégradable). | **3** (ollama/openai/mistral LLM). | Bloc d'appel `if max_edge>0: downscale` **copié 3×** chez les callers. | **G** (factoriser l'appel dans la base LLM). |
+| `_retry.py` | 274 | Retry exponentiel + `Retry-After` + jitter, deadline-aware (`call_with_retry`, `is_retryable`, `compute_retry_wait`). | `call_with_retry` : **3 OCR cloud** ; primitives : `llm/base.py`. | **Bug** : jitter `×[1.0,1.5)` appliqué **après** le plafond → `DEFAULT_MAX_WAIT` (120 s) dépassé jusqu'à **180 s** (`:138-139`). `retry_after_seconds`/`DEFAULT_MAX_WAIT` exportés sans conso externe. **Boucle ré-implémentée** dans `llm/base.py:384-429` ET `corpus/_http.download_url`. | **M** : corriger le jitter ; **unifier les 3 implémentations** ; resserrer l'API publique. |
+| `output_paths.py` | 113 | `resolve_output_path` (segment par pipeline anti-collision). | **9 adapters**. | `context: Any` (duck-typing `RunContext`) → dégrade en silence si attribut absent. | **G**. |
+
+### `ocr/`
+
+| Fichier | LOC | Rôle / sortie | Consommateurs réels | Bugs / dette | Verdict |
+|---|---|---|---|---|---|
+| `__init__.py` | 48 | Façade ; ré-exporte les 8 adapters + base + factory. | traversé par `llm_pipeline_config`. | **Import eager** des 8 classes (sûr car les modules n'importent pas la lib lourde au top-level) mais court-circuite la robustesse lazy de la factory. | **M** (mince ; aligner sur le registre). |
+| `base.py` | 189 | `BaseOCRAdapter(ABC)` + `OCRAdapterError`. **`effective_output_types`** = sous-ensemble **garanti** (vs maximal). | 8 adapters + resolver + factory + cli + robustness. | **Pas d'attribut `version`** (repro). `control` jamais honoré (cf. dette §1.4). | **M** : = mixin d'impl ; **ajouter `version`** ; garder `effective_output_types`. Contrat = `Protocol` couche 4. |
+| `factory.py` | 194 | `ocr_adapter_from_name(name) → BaseOCRAdapter`. | cli + web + `__init__`. | **Cascade `if/elif`** (anti-OCP) ; alias incohérents (`calamari_ocr`→`calamari`, pas de court `kraken`) ; `_SUPPORTED`/`_ALIASES` divergent à la main ; message Azure cite `azure-ai-formrecognizer` ≠ SDK réel. | **C→app** : remplacer par **registre + entry-points** (`CLAUDE.md` §3 : registre = app/adapters, découverte = app). |
+| `confidences.py` | 164 | Sidecar JSON de confidences. `ConfidenceToken`=TypedDict `{text, confidence∈[0,1]}`, **niveau mot**, normalisation Tesseract 0-100→0-1. | **1** (tesseract). Artefact `CONFIDENCES` lu par `evaluation/calibration`. | `model_version:null` toujours sérialisé ; entrée `list[dict]` non typée. | **G+M** : logique en adapters ; **promouvoir `ConfidenceToken`→`domain`** quand la calibration est consommée (backlog domain `CLAUDE.md`). |
+| `precomputed.py` | 221 | **Starter.** Lit `<stem>.<label>.txt`. `IMAGE→RAW_TEXT`. 0 dép externe. | factory + builders. | Nommage `name` = `precomputed_<label>` (`_`) ≠ doc factory (`:`). `control` inutilisé ; double I/O policy `empty`. | **G** (starter) ; corriger nommage. |
+| `tesseract.py` | 548 | **Starter.** `pytesseract` (binaire). `RAW_TEXT` (+`CONFIDENCES`/`ALTO_XML` **opt-in** via `effective_output_types`). | factory + cli + web. | >400 LOC. `control` inutilisé (timeout subprocess compense). | **G** (starter) ; **trim/split <400**. |
+| `kraken.py` | 237 | HTR ML local (torch). `RAW_TEXT`. Extra `[kraken]`. | factory + web. | Deadline **ignorée** (inférence non interruptible) ; API Kraken 4.x fragile vs 5.x. | **G+I** (incrémental). |
+| `calamari.py` | 253 | OCR ligne (TF). `RAW_TEXT`. Extra `[calamari]`. | factory + web. | Parsing résultat fragile (`getattr(...,"sentence","")`) ; deadline ignorée. | **G+I**. |
+| `pero_ocr.py` | 226 | HTR ML local (torch, PAGE aplati). `RAW_TEXT`. | factory + web. | Docstring tronquée (`:1-3`) ; deadline ignorée ; ordre `page_size=(h,w)` à vérifier. | **G+I**. |
+| `google_vision.py` | 330 | Cloud (SDK **ou** REST/urllib). `RAW_TEXT`. | factory + web. | SDK path ignore la deadline ; motif HTTP dupliqué (cf. azure/mistral). | **G+I**. |
+| `azure_doc_intel.py` | 425 | Cloud async + polling (SDK ou REST). `RAW_TEXT`. | factory + web. | >400. **Meilleure gestion deadline** (REST) ; SDK path l'ignore. Backoff maison. | **G+I** ; trim<400. |
+| `mistral_ocr.py` | 371 | `/v1/ocr` (urllib) **ou** chat/vision (SDK). `RAW_TEXT`. | factory + web. | SDK chat ignore deadline. **Importe `adapters.llm.base.normalize_llm_content`** (couplage cross-famille). | **G+I** ; sortir `normalize_*` en helper partagé. |
+
+### `llm/` + `vlm/`
+
+| Fichier | LOC | Rôle / contrat | Consommateurs réels | Bugs / dette | Verdict |
+|---|---|---|---|---|---|
+| `llm/__init__.py` | 16 | Docstring cadrage. | 0. | — | **G**. |
+| `llm/base.py` | 582 | **Cœur.** `BaseLLMAdapter(ABC)`. **Double API** : `complete(prompt, image_b64, *, deadline, control)→LLMResult` (appel + retry) **et** `execute(...)` (orchestration fichier→complete→fichier). `RAW_TEXT→CORRECTED_TEXT`. | pipeline (llm_config/builder) + VLM + `mistral_ocr` (helper). | >400. `LLMResult.tokens_used` **jamais peuplé** (`:194` vs `:396`) → coût non remonté. `except Exception`(`:401`) intentionnel+tracé. | **M** : **split <400** (helpers / `LLMResult` / base / orchestration) ; **peupler ou supprimer `tokens_used`**. |
+| `llm/openai_adapter.py` | 123 | **Starter.** SDK `openai`, extra `[llm]`, `temperature=0`. | web factory. | `del control` (SDK non câblé, documenté). | **G** (starter). |
+| `llm/ollama_adapter.py` | 160 | **Starter.** httpx brut (**dép. cœur**), **seul à câbler `control`** (cancel cross-thread). | web factory. | `except (TimeoutException, HTTPError): pass` (`:131-132`) — re-raise délégué, à mieux commenter. | **G** (starter). |
+| `llm/anthropic_adapter.py` | 129 | Idem motif, extra `[llm]`. | web factory. | `del control`. | **G+I**. |
+| `llm/mistral_adapter.py` | 198 | Idem + table `_TEXT_ONLY_MODELS` (dégradé multimodal). | web factory. | Logs verbeux ; instance client par appel. | **G+I**. |
+| `vlm/__init__.py` | 42 | Façade ré-export. | 0 (hors tests). | — | **G+I**. |
+| `vlm/base.py` | 245 | `BaseVLMAdapter(BaseLLMAdapter)` : `IMAGE→RAW_TEXT`, override `execute` + prompts ; **garde-fou MRO** (`__init_subclass__`). | 0 instanciateur (2 docs). | — | **G+I** (porter à la tranche `zero_shot`). Conserver le garde MRO. |
+| `vlm/openai_vlm.py` | 22 | `(BaseVLMAdapter, OpenAIAdapter)` + `name`. | **0**. | — | **I/S** : ~90 % hérité, **0 conso** → ne **pas** porter spéculativement (porter à la tranche zero_shot). |
+| `vlm/anthropic_vlm.py` | 32 | idem. | **0**. | — | **I/S** idem. |
+| `vlm/mistral_vlm.py` | 26 | idem + `default_model=pixtral`. | **0**. | — | **I/S** idem. |
+| `vlm/ollama_vlm.py` | 26 | idem + `default_model=llava`. | **0**. | — | **I/S** idem. |
+
+### `corpus/`
+
+| Fichier | LOC | Source / sortie | Consommateurs réels | Bugs / dette | Verdict |
+|---|---|---|---|---|---|
+| `__init__.py` | 24 | Docstring « nommer/localiser (image, GT) » ; `__all__=[]`. | 0. | — | **G** (mince). |
+| `_http.py` | 270 | urllib + **anti-SSRF** (`validate_http_url`, blocage IP réservées, revalidation redirects) + retry deadline-aware. | iiif, gallica, escriptorium. | `install_opener` = **effet de bord global au process** (`:159`). Boucle retry ≈ `_retry`. | **G+M** : brique sécurité réutilisable (invariant `CLAUDE.md`) ; retirer l'`install_opener` global ; unifier le retry. |
+| `_fallback_log.py` | 98 | Journal mémoire des dégradations d'importeur. | `consume`←app `_benchmark_converter` → **détecteur narratif**. `record`←htr_united/hf. | Seul débouché = narratif. | **S** (narratif supprimé `CLAUDE.md` §6 → plus de consommateur ; remplacer par `logger.warning`). |
+| `iiif.py` | 567 | Manifeste IIIF v2/v3 → **`Corpus`**. | CLI (`import iiif`) + web + gallica. | >400. **Fuite de fichiers temp** si `output_dir=None` (`NamedTemporaryFile(delete=False)`, `:465`). `tqdm` lazy. | **G+I+M** : trim<400 ; corriger la fuite temp. Référence du contrat « → Corpus ». |
+| `gallica.py` | 563 | SRU+IIIF+OCR brut BnF → **`Corpus`** (délègue à `IIIFImporter`). | web seulement. | >400. **Bug latent** `selected_indices[i]+1` (additionne `IIIFCanvas`+int, `:415`). `_fetch_url` force `retries=1`. Beaucoup de surface morte (`search_gallica`, `get_metadata`…). | **M+I** : corriger le bug ; **S** des fonctions sans conso ; trim<400. |
+| `escriptorium.py` | 571 | API REST eScriptorium → **`Corpus`** + écriture distante (export couche OCR). | web (`import_document` seul). | >400. **BUG dur** `Corpus(source=...)` (champ = `source_path`, `:450`) → `TypeError` au 1ᵉʳ appel réel, **masqué par les mocks**. `image_path:str` ≠ domain `Path`. ~40 % surface API morte. | **M+I** : corriger le bug ; **S** `export_benchmark_as_layer`/`list_*`/`connect_*` (0 conso) ; trim<400. |
+| `htr_united.py` | 488 | Catalogue HTR-United (GitHub) → **dict-manifeste** (pas `Corpus`) + GT extraits (sans images). | web. | >400. **Pas de `_http`** (ni anti-SSRF ni retry). `except (URLError, Exception)`. ZIP **chargé entier en RAM**. `_DEMO_CATALOGUE`=**113 LOC de données fabriquées** dans le code. | **M+I** : sortie unifiée `Corpus` ; **données démo → `data/` (S du code)** ; passer par `_http` ; borner le download. |
+| `huggingface.py` | 464 | HF Hub (lib `datasets`) → **dict-manifeste** + paires `.jpg`/`.gt.txt`. | web. | >400. **Monkey-patch au load** (`_patch_dataset_replace_source`, `:456`). `except (ImportError, Exception): return 0` **muet** (lib absente indistinguable de dataset cassé). GT orphelin si `image.save` échoue. `_REFERENCE_DATASETS`=**109 LOC** en dur. Docstring annonce des fonctions inexistantes. | **M+I** : sortie unifiée `Corpus` ; extra `[hf]` + message clair ; supprimer le monkey-patch ; données → `data/`. |
+
+### `storage/`
+
+| Fichier | LOC | Backend / type | Consommateurs réels | Bugs / dette | Verdict |
+|---|---|---|---|---|---|
+| `__init__.py` | 58 | Façade ré-export. Docstring annonce 2 cibles **non livrées** (migration `web/jobs`, rapatriement history SQLite). | — | — | **G**. |
+| `artifact_store.py` | 417 | **Filesystem** (`index.jsonl` + `artifacts/<key>.json` + `payloads/<key>.bin`) indexé par `ArtifactKey.hash_hex()`. Expose `StoredArtifact{key, artifact, payload}`. | **0 direct** : consommé via le **Protocol `ArtifactCachePort`** (`pipeline/cache_protocol.py`) injecté dans l'executor (inversion de dépendance). | >400. **`put` non atomique** (3 écritures sous simple `Lock`) ; **pas de `fsync`** (réimplémente un écriture inférieure au lieu d'utiliser `_atomic_io`) ; **path-traversal non gardé** (`f"{key}.json"`) ; index non borné ; pas de concurrence multi-process. | **G+M** : **utiliser `_atomic_io`** ; **valider la clé / `validated_path`** (invariant `CLAUDE.md`) ; implémente un **port défini en couche 4**. Tranche *cache*. |
+| `job_store.py` | 489 | **SQLite** (table `jobs`, WAL, `schema_version`). `JobRecord`, `JobStore`. États `pending→running→{complete\|error\|cancelled\|interrupted}`. | **1** : `app/services/job_runner.py`. | >400. **Doublon** : un **2ᵉ `JobStore` legacy** vit en `interfaces/web/jobs.py:103` et c'est **lui** que l'app web tournante câble (`state.py:138`). `LIMIT` interpolé (neutralisé par `int()`). Pas de validation des transitions. | **G+M** : **UN seul** job store (celui-ci) ; **S** le doublon legacy (couche 8, hors périmètre mais à acter) — ⚠️ mais le canonical **n'a ni `job_events` ni reprise SSE `Last-Event-ID`** (assumé `job_store.py:48-54`), capacités que porte le legacy `web/jobs.py` **et dont dépend le stream SSE du web** (cf. `ANALYSE_COUCHE_8` §0/§1.3 D-γ) → **réabsorber l'événementiel AVANT** de supprimer le legacy ; valider les transitions. Tranche *web/async*. |
+
+`StoredArtifact` : **non-candidat domain confirmé** (`domain/artifact_key.py:22-24` : « infrastructures, pas des types purs » ; le pipeline le touche via Protocol, pas en direct). Reste en `adapters/storage`.
+
+## 1.4 Dette transverse vérifiée (durable)
+
+| # | Dette | Preuve | Portée |
+|---|---|---|---|
+| **D-A** | **`control: RunControl` jamais honoré** : tous les `execute()` OCR + LLM/VLM cloud le reçoivent mais **n'appellent jamais** `register_cancel_handle`. **Seul `ollama_adapter` câble l'annulation** (via `_httpx_helpers`). | `base.py:82-86` documente le contrat ; aucun adapter ne l'honore sauf ollama. | Gap d'annulation cross-thread généralisé. |
+| **D-B** | **Deadline asymétrique** : Tesseract (timeout subprocess) + Azure-REST (polling clampé) la respectent ; **tous les paths SDK** (Azure SDK, Google SDK, Mistral chat) l'ignorent (limite SDK) ; kraken/calamari/pero l'ignorent totalement. | `azure_doc_intel.py:366-379` (bon) vs `:261` (SDK ignore) ; `mistral_ocr.py:310-316`. | Un run ML local/SDK peut dépasser le budget en silence. |
+| **D-C** | **Retry implémenté 3×** : `_retry.call_with_retry`, `llm/base.py:384-429` (inline), `corpus/_http.download_url`. | grep. | Triple maintenance du même algorithme. |
+| **D-D** | **Deux piles HTTP** dans la même couche : `httpx` (`_httpx_helpers`+`_retry`, pour OCR/LLM cloud) vs `urllib` (`corpus/_http`, anti-SSRF, pour importeurs). Aucune ne réutilise l'autre. | grep : `corpus/*` n'importe jamais `_retry`/`_httpx_helpers`. | Scission lib/menace **assumée** mais coûteuse. |
+| **D-E** | **`__init__` à effet de bord** : `corpus/_http.py:159` fait `install_opener` **global** au process à l'import. | `:153-161`. | Viole l'esprit « `__init__` minces, aucun effet de bord » (`CLAUDE.md` §7). |
+| **D-F** | **Fracture du contrat de sortie corpus** : iiif/gallica/escriptorium → `Corpus` ; **htr_united/huggingface → `dict`-manifeste** + effets disque. 3/5 écrivent des fichiers. | tableaux §1.3-corpus. | Pas de contrat unique d'ingestion. |
+| **D-G** | **Code mort / surface non câblée** : `atomic_write_bytes` ; exports `_retry` sans conso ; ~40 % d'`escriptorium.py` ; commodités `gallica`/`hf` ; `JobRecord.is_terminal/is_live` ; `_MIGRATIONS` vide. | greps agents. | « pas de consommateur = supprimé ». |
+| **D-H** | **Données fabriquées dans le code** : `_DEMO_CATALOGUE` (113 LOC) + `_REFERENCE_DATASETS` (109 LOC) = ~220 LOC de fausses données servies en repli. | `htr_united.py:44`, `huggingface.py`. | Risque d'afficher du faux contenu ; doit être de la **donnée** (`data/`) ou supprimé. |
+| **D-I** | **Bugs latents masqués par les mocks** : `escriptorium Corpus(source=...)` (`:450`) ; `gallica selected_indices[i]+1` (`:415`). | lecture code + tests mockés. | Régression garantie au 1ᵉʳ appel réel → à corriger au portage. |
+| **D-J** | **`execution_mode` : déjà retiré** (« mensonge structurel », commit `5e13c0d`, mai 2026 — attribut décoratif jamais lu par le runner thread-only). 0 occurrence prod ; garde-fou de test anti-résurrection. | git show. | **Leçon** : ne **jamais** réintroduire d'attribut « au cas où » non câblé. |
+
+---
+
+# PARTIE 2 — RÉORGANISATION CIBLE Cinoc (périssable — « à confirmer à la tranche »)
+
+> Conforme `CLAUDE.md` : **deux axes**, **tranches verticales** (jamais « finir la couche de haut en bas »), **budgets <400 LOC**, **rupture nette zéro shim**, **narrative supprimé**, **« pas de consommateur = supprimé »**. La couche 5 se **remplit par tranches** (chaque adapter naît avec le pipeline qui le consomme), pas en bloc.
+
+## 2.1 Enveloppe (axe 1 — dimensionnée plein-scope, mais **définie en couche 4**)
+
+Le **contrat de module exécutable** n'est **pas** un livrable de la couche 5 : il vit en **couche 4** (`pipeline`, cf. `CLAUDE.md` D1). La couche 5 ne fait que **l'implémenter**. À acter quand on conçoit la couche 4 (rappelé ici car il façonne tous les adapters) :
+
+- **`Protocol` unique** ≈ `StepExecutor` de Picarones : `name`, **`version`** (➕ vs Picarones, repro `RunManifest`), `input_types`/`output_types` (`frozenset[ArtifactType]`), `execute(inputs, params, context, control) → dict`.
+- **`BaseModule` supprimé** (vestigial). Les ABC `Base*Adapter` deviennent de **simples mixins d'implémentation** (défauts + helpers + `_write_text_artifact()`), **pas** un contrat.
+- **`effective_output_types`** (garanti ⊂ maximal) **conservé** — sinon `missing_output` casse les steps quand un extra opt-in (Tesseract `CONFIDENCES`/`ALTO_XML`) n'est pas produit.
+- **Trancher la dette d'annulation `control`** (D-A/D-B) : soit honorer `control` partout où l'opération est annulable, soit assumer explicitement « best-effort deadline » (documenté, testé). Ne pas traîner un paramètre non câblé.
+
+**Registre + découverte (couche `app`, cf. `CLAUDE.md` §3)** : remplacer la cascade `if/elif` + les factories CLI/web dispersées par **un registre type-driven `adapter_name → factory`** + **découverte entry-points `cinoc.modules`** + `register()` local. **Seul point d'extension tiers = les briques de pipeline** (OCR/HTR/VLM/post-correction/segmentation/ordre de lecture/NER). **Corpus, métriques, sections, stores = first-party, non pluggables.**
+
+## 2.2 Surface (axe 2 — incrémentale, par tranches)
+
+**Starter pack** (le strict nécessaire au squelette ambulant) :
+
+| Brique | Fichiers source | Extra | Tranche |
+|---|---|---|---|
+| `precomputed` (OCR 0 dép) | `ocr/precomputed.py` | — | **squelette texte** (corpus pré-calculé → CER) |
+| `tesseract` (OCR binaire) | `ocr/tesseract.py` + `confidences.py` | binaire système | tôt (1ᵉʳ vrai moteur) |
+| `openai` + `ollama` (LLM) | `llm/base.py` + `openai_adapter.py` + `ollama_adapter.py` | `[llm]` (openai) ; `httpx`=cœur (ollama) | tranche OCR+LLM `text_only` |
+| utils racine | `_atomic_io`(text), `_retry`(corrigé+unifié), `output_paths`, `_image`, `_httpx_helpers` | — | portés **en bloc** avec le starter |
+
+**Incrémental (porter à la tranche qui le consomme)** : anthropic/mistral (LLM) ; kraken/calamari/pero/google/azure/mistral_ocr (OCR — extras dédiés) ; **VLM** (tranche `zero_shot` — ~90 % gratuit une fois le LLM porté, **0 conso aujourd'hui → ne pas porter avant**) ; importeurs corpus (un par un) ; `artifact_store` (tranche *cache*) ; `job_store` (tranche *web/async*) ; **store longitudinal *tidy*** (tranche *longitudinal*, **rapatrié** de `evaluation/metrics/history.py` → `adapters/storage`, cf. `MIGRATION_COUCHE_3.md` §8).
+
+## 2.3 Arborescence cible proposée (à confirmer)
+
+```
+cinoc/adapters/
+├── _atomic_io.py        atomic_write_text (+fsync)         [G, -atomic_write_bytes]
+├── _retry.py            retry unifié, jitter corrigé       [M, unifie les 3]
+├── _http.py             transport + anti-SSRF + retry      [fusion _httpx_helpers + corpus/_http ?]
+├── _image.py            downscale (PIL lazy)               [G]
+├── output_paths.py      resolve_output_path                [G]
+├── ocr/                 base(mixin)+precomputed+tesseract  [starter] ; reste incrémental
+│   └── confidences.py   (ConfidenceToken→domain à terme)
+├── llm/                 base+openai+ollama [starter] ; anthropic/mistral incrémental
+├── vlm/                 base+manifestes — tranche zero_shot uniquement
+├── corpus/              importeurs first-party, sortie UNIQUE = Corpus, 1 par tranche
+│                        [_fallback_log SUPPRIMÉ ; données démo → data/]
+└── storage/             artifact_store + job_store (UNIQUE) + history tidy (rapatrié)
+```
+*Note* : la **factory/registre** ne vit **pas** ici mais en `app/` (résolution `adapter_name`) ; la couche 5 ne fait qu'exposer des classes implémentant le `Protocol` couche 4.
+
+## 2.4 Application des 5 garde-fous
+
+- **Rupture nette / zéro shim** : un seul `JobStore` (S le legacy `web/jobs.py`) ; un seul contrat de sortie corpus (`Corpus`, S les dict-manifestes) ; pas de `BaseModule` ; une seule pile HTTP si possible (D-D).
+- **Budgets <400** : `llm/base.py`(582), `escriptorium`(571), `iiif`(567), `gallica`(563), `tesseract`(548), `job_store`(489), `htr_united`(488), `huggingface`(464), `azure`(425), `artifact_store`(417) **dépassent**. La plupart **rétrécissent** après retrait du code mort (D-G), des données démo (D-H) et dédup du boilerplate (`_write_text_artifact`, retry, HTTP). Sinon split ou entrée justifiée `test_file_budgets`.
+- **Pas de consommateur = supprimé** : `atomic_write_bytes`, `_fallback_log`, surface morte d'escriptorium/gallica/hf, exports `_retry` inutiles, VLM concrets tant que `zero_shot` n'existe pas.
+- **Tests d'archi jour 1** : whitelist `adapters/` = `domain` + `pipeline` + `formats` (+ `evaluation` pour le type `Corpus` chargé, **à expliciter** — Picarones le tolérait par wildcard) ; `no-side-effect-import` (tue le `install_opener` global D-E) ; `no-broad-except` (htr/hf `except Exception`) ; `file-budgets`.
+- **Feature entière + élaguée** : chaque adapter porté **avec** sa correction de bug (D-I), son extra optionnel, son message clair d'absence de dép, sans annotation de sprint.
+
+## 2.5 Libs cibles & arbitrages (périssable — « à confirmer à la tranche »)
+
+> Rappel : la minceur de la couche vient surtout de l'**élagage** (code mort, données démo, dédup), **pas** de l'ajout de libs. Une lib ne paie que si elle **retire plus de code que le wrapper qu'elle impose**. Contreparties transverses à toute dép : **supply-chain** (cf. `fastapi==0.136.3` / `MAL-2026-4750` exclue dans le `pyproject` Picarones ; `pip-audit` à tenir), **reproductibilité** (`dependencies_lock` du `RunManifest` → **épingler serré**), **code tiers in-process** (entry-points).
+
+| Lib / appel | Verdict | Raison / condition |
+|---|---|---|
+| `httpx` (transport REST unique) | ✅ **conditionnel** | Pour le REST à **auth simple** (ollama, mistral `/v1/ocr`, HF, eScriptorium, htr_united, openai-compatible). Unifie les 2 piles HTTP (D-D), corrige la deadline (D-B). **Garder le SDK** pour Google/Azure (auth JWT service-account / AD lourde). Anti-SSRF toujours à coder (transport dédié, **sans `install_opener` global** — D-E). |
+| Drop dual SDK/REST cloud | ✅ **conditionnel** | Seulement où le SDK n'offre ni timeout-par-appel ni annulation **et** l'auth est simple. Pas systématique. |
+| `huggingface_hub` | ✅ **extra `[hf]`** | Remplace le REST urllib maison de `huggingface.py` (pagination tronquée, `except` muet, monkey-patch — D-G). Lib lourde/mouvante → confinée à l'extra, épinglée. |
+| `importlib.metadata.entry_points` (stdlib) | ✅ **gaté** | Outil du point d'extension `cinoc.modules`. **Désactiver la découverte en mode public** (in-process = sécurité, `CLAUDE.md` §3) ; capter la **version** du plugin pour le `RunManifest`. |
+| `pydantic` v2 | ✅ **configs** / ❌ **par-token** | OK pour les **configs d'adapter** (petites, 1×, aligne le repo). **Pas** pour `ConfidenceToken` (milliers/page → coût de validation, cf. `MIGRATION_COUCHE_2.md` G-D) : `TypedDict`/`dataclass(slots=True)`, valider une fois à la frontière. |
+| `tenacity` (retry) | ❌ **garder maison** | Le retry doit être deadline/cancel-aware (`clamp_to_remaining`, `RunControl`), honorer `Retry-After`, et **testable déterministe** (horloge injectable). Tenacity impose un wrapper custom qui annule le gain. `_retry.py` maison (bug jitter corrigé) reste plus aligné. |
+| anti-SSRF · parseur IIIF · subprocess Tesseract | ❌ **garder maison** | Pas de lib mainstream fiable (SSRF, IIIF) ; le subprocess `pytesseract` est **ce qui honore la deadline** pour Tesseract — un binding C-API (`tesserocr`) la perdrait. |
+| ORM (SQLAlchemy) · async (`anyio`) | ❌ | `sqlite3` brut suffit (2 tables) ; runner **thread-only** acté (retrait `execution_mode`, D-J) → async = rupture injustifiée. |
+
+**Cible LOC** (rappel, périssable) : enveloppe + starter pack utile ≈ **3 700 LOC** ; parité complète nettoyée ≈ **6 500–7 000 LOC** (vs **9 682** Picarones, ≈ **−30 %**). La couche se remplit par tranches — elle n'a jamais besoin de revoir les 9,7k. *(Détail des leviers de coupe : §1.4 + §2.4.)*
+
+---
+
+# PARTIE 3 — RISQUES DE TRANSFERT & DETTES (avec détection)
+
+| Risque | Détail | Comment détecter / désamorcer |
+|---|---|---|
+| **R-1 Contrat couche 4 manquant** | La couche 5 ne peut être portée **qu'après** le `Protocol` de module (couche 4) + `RunContext`/`RunControl`/`Deadline`. | Construire d'abord la tranche pipeline minimale ; un adapter starter (`precomputed`) sert de **premier client** du `Protocol`. |
+| **R-2 `version` absent** | Picarones n'a pas d'attribut `version` sur les adapters → repro `RunManifest` incomplète. | Test : `RunManifest` doit capter `name+version` de chaque step ; refuser un module sans `version`. |
+| **R-3 Annulation/deadline (D-A/D-B)** | `control` non câblé partout sauf ollama ; deadline ignorée par SDK/ML local. | Test d'annulation : lancer un step long, déclencher `control.cancel()`, vérifier l'arrêt < N s. Décider par adapter : annulable ou « best-effort » documenté. |
+| **R-4 `ConfidenceToken`** | TypedDict local mot-niveau, échelle [0,1], normalisation Tesseract. À promouvoir en `domain` **quand** la métrique calibration le consomme. | Ne pas figer la forme avant le consommateur (backlog domain). Test de normalisation 0-100→0-1 + rejet <0/>100. |
+| **R-5 Sortie corpus non uniforme (D-F)** | Choisir **`Corpus`** comme sortie unique ; pousser l'**orchestration disque** (download→write→manifest) en **service `app`**, garder en couche 5 le **transport + parsing schéma**. | Test : tout importeur retourne un `Corpus` valide (pas de `dict`). Séparer « localiser » (adapter) de « matérialiser » (app). |
+| **R-6 Sécurité (anti-SSRF + chemins)** | `corpus/_http` porte l'anti-SSRF ; `artifact_store`/eScriptorium ne valident pas les chemins/URL. Invariant `CLAUDE.md` : `validated_path()` + URL contrôlée. | Test : URL loopback/IP réservée rejetée ; clé d'artefact `../` rejetée ; pas d'`install_opener` global (no-side-effect-import). |
+| **R-7 Bugs latents (D-I)** | ✅ **entièrement clos**. `Corpus(source=)` eScriptorium (sortie `CorpusSpec`, `source` ∈ `metadata` → `TypeError` impossible). `selected_indices[i]+1` Gallica : mapping vue↔`f{n}` direct (position 1-based = numéro de vue), **aucune indirection** portée. Les deux prouvés non-mockés (`test_escriptorium_local_server.py`, `test_gallica_local_server.py`). | **Test d'intégration non-mocké** : loopback réel (`http.server`) par source — préféré au `live` quand la source exige auth/instance privée. |
+| **R-8 Dérive de budget** | Fichiers riches >400. | `test_file_budgets` actif dès le 1ᵉʳ commit d'adapters ; budgets honnêtes, pas de gonflement silencieux. |
+| **R-9 Couplage cross-famille** | `mistral_ocr` importe `llm.base.normalize_llm_content`. | Extraire la normalisation de contenu LLM en helper neutre partagé ; test d'archi sur les imports inter-sous-paquets. |
+| **R-10 Deux JobStores** | Le legacy `interfaces/web/jobs.py` est celui réellement câblé. | Au portage : un seul store (`adapters/storage`), l'app web le consomme ; supprimer le legacy ; test qu'aucun `JobStore` ne vit hors `adapters/storage`. **⚠️ Le canonical doit d'abord réabsorber la table d'événements + la reprise `Last-Event-ID`** (absentes aujourd'hui), sinon le **stream SSE régresse** (cf. `ANALYSE_COUCHE_8` §0). |
+| **R-11 Données démo en dur (D-H)** | ~220 LOC de faux catalogues. | Les sortir en `data/*.yaml` **ou** supprimer ; un repli démo ne doit jamais se faire passer pour de la vraie donnée (champ `is_demo` explicite). |
+| **R-12 Numérique non rétro-compatible** | Comme la couche 2 (`MIGRATION_COUCHE_2.md` MIG-2) : Cinoc change normalisation/contrats → **toute « validation » par égalité de chiffres avec Picarones est invalide**. | Goldens **refaits**, pas hérités. |
+
+---
+
+## Résumé pour la session de CONSTRUCTION (3-5 points)
+
+1. **Le « double contrat » à tuer n'est pas un héritage** : Picarones a déjà **un** contrat runtime unique = `StepExecutor` (`pipeline/protocols.py`, `execute(inputs, params, context, control)`), que les adapters implémentent par duck-typing. `BaseModule` est **vestigial** (à supprimer sans perte). ⇒ Le `Protocol` couche 4 de Cinoc ≈ `StepExecutor` **+ un attribut `version`** ; les `Base*Adapter` deviennent de simples **mixins d'implémentation**.
+2. **Construire par tranches, starter pack d'abord** : `precomputed` + `tesseract`(+`confidences`) + `openai`+`ollama`, avec les utils racine (`_atomic_io`/`_retry` corrigé/`output_paths`/`_image`/`_httpx_helpers`) portés **en bloc**. Tout le reste (kraken/calamari/pero/cloud OCR, anthropic/mistral, **VLM**, importeurs, stores) est **incrémental — porté à la tranche qui le consomme**, jamais d'avance. **VLM = 0 consommateur aujourd'hui → ne pas porter avant la tranche `zero_shot`.**
+3. **Dettes à corriger AU portage (pas après)** : annulation `control` non câblée (D-A) + deadline asymétrique (D-B) à trancher ; **3 implémentations de retry à unifier** + bug jitter>plafond ; **bugs latents** `Corpus(source=)`/Gallica masqués par les mocks ; `artifact_store` doit utiliser `_atomic_io`+`fsync` et **valider les chemins** ; **un seul `JobStore`**.
+4. **Élagage discipliné** : **SUPPRIMER** `_fallback_log` (son seul débouché, le narratif, est supprimé), `atomic_write_bytes`, la surface morte (escriptorium/gallica/hf), `execution_mode` (déjà parti) ; **sortir** les ~220 LOC de données démo en `data/` ; **sortie corpus unique = `Corpus`** (fin des dict-manifestes). Registre/découverte = **couche `app`** (entry-points `cinoc.modules`), **seul point d'extension tiers = les briques de pipeline**.
+5. **Placement & dépendances** : les importeurs de corpus restent **first-party en couche 5** (transport + parsing → `Corpus`), l'**orchestration disque** remonte en service `app` ; le **store SQLite longitudinal/tidy** est **rapatrié** de `evaluation/` vers `adapters/storage` (cf. `MIGRATION_COUCHE_3.md`). Whitelist d'archi `adapters/` à **expliciter** (inclut `evaluation` pour le type `Corpus` chargé).
+
+## DoD vivante (couche 5) — **autorité de détail** ; le `MIGRATION_PLAN.md` indexe
+
+> **T8 (D-066)** : tous les modules du socle renvoient `StepOutput` ; les adapters LLM/VLM remontent `tokens_in/out` (OpenAI/Mistral `usage.prompt/completion_tokens`, Anthropic `usage.input/output_tokens`, Ollama `prompt_eval_count`/`eval_count`) via `LLMCompletion` — un seul point de logique (`_base.run_llm_step`).
+
+> **T12 (D-070)** : tesseract publie l'artefact `CONFIDENCES` (sidecar JSON de `ConfidenceToken`, `image_to_data` conf÷100, best-effort → sidecar vide + warning). Preuves : `tests/adapters/test_tesseract.py`.
+
+> **T14 (D-072)** : `+ ocr/kraken.py` (HTR, extra `[kraken]`, `model` requis, RAW_TEXT+CONFIDENCES) `+ ocr/mistral_ocr.py` (cloud à la page, kind `mistral_ocr`). Preuves : `tests/adapters/test_kraken.py` · `test_mistral_ocr.py`.
+
+> Tri-état : `[x]` fait **+ preuve** · `[ ]` à faire · `[~]` différé/réserve + raison.
+> Maj dans le **même commit** que le code. **Statut : ✅ T3 complet** — `precomputed` + `tesseract` + **`openai`** + **`ollama`** (LLM post-correction) verts, annulation câblée (D-A clos) **+ `mistral`** (post-correction cloud, extra `[mistral]`, secret `MISTRAL_API_KEY`) ; stores/VLM **par tranches**. **+ T5 `layout/`** : `precomputed` (source LAYOUT + recognizer région), `assembler` (`AltoAssembler`), **`crop`** (`crop_region` PIL — découpe réelle des blocs du pipeline hybride seg→OCR ; `PIL` ajouté à la whitelist archi `adapters`). — *preuves : `tests/adapters/layout/test_crop.py`, `…/test_alto_assembler.py`, `tests/pipeline/test_hybrid_real_bnl.py` (live)*. **+ T7 `corpus/`** : 1ᵉʳ importeur **IIIF** — `_http` (transport `httpx` durci anti-SSRF : http(s) seul, rejet userinfo + IP non publiques, redirections re-validées, taille plafonnée, **aucun `install_opener` global** ; **anti-DNS-rebinding fermé** D-051 : résolution unique → IP validées **épinglées** via `network_backend` `httpcore` custom (`_PinnedBackend`), URL/`Host`/SNI/cert TLS inchangés, ré-épinglage par redirection — `httpcore` whitelisté en archi adapters + extras ; **`download` en flux disque** D-052 : `.part` au fil de l'eau + `os.replace` atomique + cap `IMAGE_MAX_BYTES`, aucun fichier partiel ; `download` accepte `headers` — média eScriptorium **même-hôte** seul porte le jeton) + `iiif` (parser manifeste v2/v3 → `IIIFImage`, **images seules**, pur) ; matérialisation disque → **`CorpusSpec`** en `app/corpus_import.py` (R-5 : localiser ≠ matérialiser). Sortie **unique `CorpusSpec`** (fin des dict-manifestes). — *preuves : `tests/adapters/corpus/{test_iiif_parse,test_http_ssrf,test_iiif_local_server}.py` (transport réel loopback), `…/test_iiif_live.py` (distant, opt-in), `tests/app/test_corpus_import.py`*. **+ eScriptorium** (porteur de **GT** → corpus **scorable**) : `escriptorium.py` (auth token, pagination `next`, `extract_gt_text` couche transcription, pur ; `_http.fetch_json` gagne `headers`) + `import_escriptorium_corpus` (image + `.gt.txt` → `GroundTruthRef` RAW_TEXT). **R-7/D-I fermé** : pas de `Corpus(source=)` (la sortie est `CorpusSpec`, `source` ∈ `metadata`) — prouvé **non-mocké** (test loopback : auth header + pagination 2 pages + GT lignes/`content`). — *preuves : `tests/adapters/corpus/{test_escriptorium_parse,test_escriptorium_local_server}.py`, `tests/app/test_corpus_import_escriptorium.py`*. **+ Gallica** : `gallica.py` (`normalize_ark` + `manifest_url` **IIIF `/iiif/`** + `fetch_ocr_text` via **ALTO** `RequestDigitalElement` + `alto_to_text` ; `_http.fetch_bytes` ajouté pour parser l'ALTO en octets) — **images réutilisent `IIIFImporter`**, OCR = **référence étiquetée** : type domaine `REFERENCE_TEXT` (D-053, ≠ GT manuelle) + `gt_source=gallica_ocr` — non scoré par défaut, vue référence dédiée (opt-in). **2 bugs prod corrigés (D-058, révélés par la capture réelle)** : URL manifeste `/iiif/` manquant (→ 403, masqué par les mocks) ; `texteBrut` ALTCHA-gated → bascule ALTO (rupture nette, `texteBrut`/`_looks_like_html` supprimés). **R-7 clos** : mapping vue *i* ↔ `f{i}` lu dans l'URL d'image (`/f{n}/`), **sans indirection**, prouvé non-mocké sur **vraies pages Gallica** (`tests/fixtures/gallica_alto/`, *Pourceaugnac*). — *preuves : `tests/adapters/corpus/{test_gallica_parse,test_gallica_alto,test_gallica_local_server}.py`, `tests/app/test_corpus_import_gallica.py`*. **+ HTR-United & HuggingFace** (**découverte**, pas matérialisation) : `htr_united.py` (`fetch_catalogue` YAML via `_http.fetch_text` + `parse_catalogue` pur + recherche + **repli démo `is_demo`** ; `yaml` ajouté à la whitelist adapters) ; `huggingface.py` (`search_reference` socle intégré + `HuggingFaceCatalogue.search` API publique **best-effort** via `_http.fetch_json`, `source` ∈ {reference, api}). **+ import HF matérialisant** (D-054, Lot D) : `stream_pages` (convention Cinoc `image`+`ground_truth`, lib `datasets` en extra `[huggingface]`, `streaming=True`, `Image(decode=False)` → octets sans PIL, `loader` injectable) → `app.import_hf_corpus` (GT `RAW_TEXT` réelle) + endpoint `/api/corpus/import/huggingface` (CSRF, gate public 403, non-conforme 422, extra absent 409). **Importeurs cœur complets.** — *preuves : `tests/adapters/corpus/{test_htr_united,test_htr_united_local_server,test_huggingface,test_huggingface_local_server}.py`*. **+ T7 `storage/history_store.py`** : `HistoryStore` SQLite **longitudinal** — `add(HistoryRecord…)` (idempotent, PK `(run_id,pipeline,view,metric)`), `history(pipeline,view,metric)` (chronologique), `regressions(view,metric, threshold, higher_is_better)` (2 derniers runs, direction-aware). Persistance **pure de lignes primitives** (n'importe pas `RunResult`) ; 1 connexion/opération (thread-safe). — *preuves : `tests/adapters/storage/test_history_store.py` (vrai SQLite : round-trip, idempotence, persistance inter-instances, régression/seuil/sens)*
+
+**Enveloppe :**
+- [x] `precomputed` implémente le `Module` Protocol (couche 4) **directement**, avec `name`/`version`. — *preuve : `tests/adapters/test_precomputed.py` (`isinstance(.., Module)` ; lecture `<stem>.<label>.txt` → `RAW_TEXT` + `content_hash` ; UTF-8 strict ; annulation)*
+- [x] **1ᵉʳ vrai moteur : `tesseract`** (implémente `Module` directement ; `lang` anti-injection, timeout borné par la deadline, écrit dans le **workspace** ; pytesseract = **extra**, invocation **mockable** → CI sans binaire). — *preuve : `test_tesseract` (mock + validations + workspace + annulation) ; `test_live` opt-in*
+- [x] **2ᵉ famille de module : LLM post-correction** (`openai`, mode `text_only`) — `RAW_TEXT → CORRECTED_TEXT` ; SDK extra, invocation **mockable** (CI sans clé) ; **pipeline multi-étapes OCR→LLM** prouvé (`CORRECTED_TEXT` **non vide**, bug historique). — *preuve : `test_openai` + `test_llm_pipeline`*
+- [x] **2ᵉ LLM (généralisation prouvée) : `ollama`** — *même* contrat que `openai`, sortie `CORRECTED_TEXT`, **aucun cas particulier** ; transport `httpx` = **extra**, `_invoke_ollama` **mockable** (CI sans serveur). **Référence d'annulation câblée** : `_invoke_ollama` enregistre `client.close` via `RunControl.register_cancel_handle` → `trigger_cancel` ferme la connexion en vol ; « annulation vs panne » tranchée en sondant `is_cancelled` (`_fail_or_cancel`, **fiable** — remplace l'heuristique de message fragile, **D-A clos**). — *preuve : `test_ollama` (conformité Module + mock + workspace + annulation + `_fail_or_cancel` cancel/panne) ; mécanisme `register_cancel_handle` : `test_run_control` (fire-on-cancel · immédiat-si-déjà-annulé · once · ordre)*
+- [~] VLM/`zero_shot` (0 conso) · `Base*Adapter` mixins · confidences/ALTO · `unregister`/déduplication des handles (accumulation bénigne, runs bornés) : **différés**.
+
+**Garde-fous :**
+- [x] `layer_dependencies` (whitelist `adapters` explicitée : domain+pipeline+formats) · `no_side_effect_imports` · `no_broad_except` · `file_budgets`. — *preuve : `test_adapters_imports_are_allowed` + suite archi verte.* `[~]` `install_opener` global (D-E) : tué à la tranche HTTP.
+
+**Validation par tranche :** `MIGRATION_PLAN.md` §3 — starter pack via `Module` (T1-T3) · **1 seul `JobStore` avec SSE/`job_events` réabsorbés** (T4, cf. §0/D-γ) · bugs latents `Corpus(source=)`/`selected_indices+1` corrigés + test `live` (T7).
+
+- [~] **Différé** : kraken/calamari/pero/cloud OCR, anthropic/mistral, **VLM (0 conso → pas avant `zero_shot`)**, importeurs (1/tranche, sortie unique `Corpus`), stores. **Supprimer** `_fallback_log` + données démo en dur (→`data/`).
+
+---
+
+*Tous les verdicts de la Partie 1 sont marqués **PROVISOIRE — à confirmer au build** : le contact du code corrige souvent l'analyse.*
diff --git a/cinoc/adapters/__init__.py b/cinoc/adapters/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..44bd596fd190c6c0194465be08a6a2ea792cd697
--- /dev/null
+++ b/cinoc/adapters/__init__.py
@@ -0,0 +1,9 @@
+"""Couche 5 — ``adapters`` : modules concrets (starter pack).
+
+Chaque adapter implémente directement le ``Module`` Protocol (couche 4). Les
+dépendances lourdes (SDK LLM, moteurs OCR) sont des extras optionnels, importés
+dans le module qui les utilise — jamais ici. ``__init__`` mince, sans effet de
+bord.
+"""
+
+from __future__ import annotations
diff --git a/cinoc/adapters/_resilience.py b/cinoc/adapters/_resilience.py
new file mode 100644
index 0000000000000000000000000000000000000000..3450a4a0ebf6d12b90b3d12c0f9a50004720c28f
--- /dev/null
+++ b/cinoc/adapters/_resilience.py
@@ -0,0 +1,170 @@
+"""Résilience des appels réseau (couche 5, adapters) : cap de concurrence + retry.
+
+Deux mécanismes, **par défaut, sans configuration**, pour qu'un run depuis l'UI
+web (n'importe qui) ne sature pas une API instable :
+
+- **Cap de concurrence par fournisseur** (``network_slot``) : un sémaphore borné
+  *par fournisseur* (Mistral, OpenAI… chacun le sien) → au plus N appels réseau
+  simultanés, quel que soit le nombre de threads du runner. C'est le fix
+  structurel du pool global partagé (Pero local + LLM réseau dans un même run).
+- **Retry borné** (``call_resilient``) : sur 429/5xx, attend ``Retry-After`` si le
+  serveur l'indique, sinon un backoff exponentiel borné + gigue, puis recommence.
+
+Stdlib pure (aucune dépendance). **Déterminisme (invariant §12)** : ces mécanismes
+ne changent que le *timing*, jamais la valeur renvoyée → le ``RunResult`` reste
+byte-identique. ``N`` = ``CINOC_NETWORK_CONCURRENCY`` (défaut 3, plancher 1).
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import random
+import threading
+import time
+from collections.abc import Callable
+from contextlib import AbstractContextManager
+from typing import TypeVar
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T")
+
+#: Plafond par défaut d'appels réseau concurrents **par fournisseur** (anti-429).
+_DEFAULT_LIMIT = 3
+_LIMIT_ENV = "CINOC_NETWORK_CONCURRENCY"
+#: Politique de retry : tentatives + backoff exponentiel borné (secondes).
+_DEFAULT_ATTEMPTS = 5
+_BASE_BACKOFF = 1.0
+_MAX_BACKOFF = 30.0
+#: Statuts HTTP retentés : 429 (rate limit) + 5xx transitoires (instabilité).
+_RETRYABLE_STATUS = frozenset({429, 500, 502, 503, 504})
+
+#: Registre process-global des sémaphores, créés paresseusement (aucun effet de
+#: bord à l'import). Protégé par un verrou : ``network_slot`` est thread-safe.
+_SEMAPHORES: dict[str, threading.BoundedSemaphore] = {}
+_REGISTRY_LOCK = threading.Lock()
+
+
+def _network_limit() -> int:
+    """Plafond effectif depuis l'environnement (défaut ``_DEFAULT_LIMIT``)."""
+    raw = os.environ.get(_LIMIT_ENV)
+    if raw is None:
+        return _DEFAULT_LIMIT
+    try:
+        value = int(raw)
+    except ValueError:
+        logger.warning(
+            "[resilience] %s=%r invalide (entier attendu) — défaut %d.",
+            _LIMIT_ENV,
+            raw,
+            _DEFAULT_LIMIT,
+        )
+        return _DEFAULT_LIMIT
+    return max(1, value)
+
+
+def network_slot(provider: str) -> AbstractContextManager[bool]:
+    """Sémaphore borné **du fournisseur** : ``with network_slot("mistral"): …``.
+
+    Au plus ``_network_limit()`` détenteurs simultanés par fournisseur. Chaque
+    fournisseur a son quota propre (un run OpenAI + Mistral ne les fait pas se
+    partager le budget). Le plafond est figé à la première création du fournisseur
+    (lecture d'environnement unique, déterministe pour la durée du process)."""
+    with _REGISTRY_LOCK:
+        sem = _SEMAPHORES.get(provider)
+        if sem is None:
+            sem = threading.BoundedSemaphore(_network_limit())
+            _SEMAPHORES[provider] = sem
+    return sem
+
+
+def _default_jitter() -> float:
+    return random.uniform(0.0, 1.0)
+
+
+def _backoff(attempt: int, jitter: Callable[[], float]) -> float:
+    """Backoff exponentiel borné + gigue (désynchronise les threads concurrents)."""
+    return min(_MAX_BACKOFF, _BASE_BACKOFF * (2.0**attempt)) + jitter()
+
+
+def http_is_retryable(exc: BaseException) -> bool:
+    """Vrai si l'exception SDK porte un statut HTTP transitoire (429/5xx).
+
+    Duck-typing assumé : les SDK httpx (mistralai/openai/anthropic) exposent
+    ``status_code``. Une erreur sans statut (réseau coupé, bug local) n'est **pas**
+    retentée — on ne masque pas un vrai défaut."""
+    return getattr(exc, "status_code", None) in _RETRYABLE_STATUS
+
+
+def http_retry_after(exc: BaseException) -> float | None:
+    """Délai ``Retry-After`` (secondes, borné) si le serveur l'indique, sinon ``None``.
+
+    Sonde l'en-tête sur ``exc.response.headers`` puis ``exc.headers`` ; tolère
+    toute absence/forme invalide (→ ``None`` → l'appelant calcule un backoff)."""
+    for holder in (getattr(exc, "response", None), exc):
+        headers = getattr(holder, "headers", None)
+        if headers is None or not hasattr(headers, "get"):
+            continue
+        raw = headers.get("retry-after")
+        if raw is None:
+            continue
+        try:
+            seconds = float(raw)
+        except (TypeError, ValueError):
+            continue
+        if seconds >= 0:
+            return min(_MAX_BACKOFF, seconds)
+    return None
+
+
+def call_resilient(
+    provider: str,
+    fn: Callable[[], T],
+    *,
+    is_retryable: Callable[[BaseException], bool] = http_is_retryable,
+    retry_after: Callable[[BaseException], float | None] = http_retry_after,
+    attempts: int = _DEFAULT_ATTEMPTS,
+    sleep: Callable[[float], None] = time.sleep,
+    jitter: Callable[[], float] = _default_jitter,
+) -> T:
+    """Exécute ``fn`` sous le quota du fournisseur, avec retry borné sur 429/5xx.
+
+    Acquiert ``network_slot(provider)`` **par tentative** (relâché pendant
+    l'attente → on ne gèle pas un quota en dormant). Sur erreur retentable et tant
+    qu'il reste des tentatives : attend ``Retry-After`` si fourni, sinon un backoff
+    exponentiel borné + gigue, puis recommence. Sinon l'exception remonte
+    (l'appelant la traduit en ``AdapterStepError`` → unité isolée par le runner).
+    ``sleep``/``jitter`` injectables (tests déterministes). **Ne change que le
+    *timing*, jamais la valeur renvoyée.**"""
+    for attempt in range(attempts):
+        delay = 0.0
+        with network_slot(provider):
+            try:
+                return fn()
+            except Exception as exc:
+                if not is_retryable(exc) or attempt == attempts - 1:
+                    raise
+                after = retry_after(exc)
+                delay = after if after is not None else _backoff(attempt, jitter)
+                logger.warning(
+                    "[resilience] %s : tentative %d/%d échouée (%s) — "
+                    "nouvelle tentative dans %.1f s.",
+                    provider,
+                    attempt + 1,
+                    attempts,
+                    type(exc).__name__,
+                    delay,
+                )
+        sleep(delay)  # hors du créneau : on ne retient pas le quota en dormant
+    raise AssertionError(  # pragma: no cover — la boucle retourne ou relance avant
+        "call_resilient : boucle épuisée sans issue"
+    )
+
+
+__all__ = [
+    "call_resilient",
+    "http_is_retryable",
+    "http_retry_after",
+    "network_slot",
+]
diff --git a/cinoc/adapters/_workspace.py b/cinoc/adapters/_workspace.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae6dc97f15f21d62ee0af3eb9872b34de8686dbb
--- /dev/null
+++ b/cinoc/adapters/_workspace.py
@@ -0,0 +1,31 @@
+"""Chemins de sortie dans le workspace (couche 5, partagé par les écrivains).
+
+Les adapters qui **produisent** un artefact (OCR, post-correction LLM) y déposent
+un fichier. Le ``stem`` dérivé du ``document_id`` est **injectif** et sans
+séparateur de chemin : encodage type URL (``quote``), **réversible** donc
+injectif, qui neutralise ``/`` (→ ``%2F``) et l'octet nul (→ ``%00``). Deux ids
+distincts ne peuvent jamais produire le même nom de fichier (et donc s'écraser) —
+y compris les cas limites ``a/_b`` vs ``a_/b`` qu'un simple échappement maison
+collisionnerait. Les ids courants (alphanumériques) restent lisibles.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from urllib.parse import quote
+
+
+def safe_document_stem(document_id: str) -> str:
+    """``document_id`` → composant de nom de fichier **injectif** et sans ``/``."""
+    return quote(document_id, safe="")
+
+
+def workspace_artifact_path(
+    workspace_uri: str, document_id: str, label: str, suffix: str
+) -> Path:
+    """Chemin ``<workspace>/<stem>.<label>.<suffix>`` (``stem`` injectif)."""
+    stem = safe_document_stem(document_id)
+    return Path(workspace_uri) / f"{stem}.{label}.{suffix}"
+
+
+__all__ = ["safe_document_stem", "workspace_artifact_path"]
diff --git a/cinoc/adapters/corpus/__init__.py b/cinoc/adapters/corpus/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b6521af040cd9b4a2370e612de847b6e096449ac
--- /dev/null
+++ b/cinoc/adapters/corpus/__init__.py
@@ -0,0 +1,39 @@
+"""Importeurs de corpus first-party (couche 5).
+
+Chaque importeur **localise** des ressources (transport + parsing de schéma) et
+retourne un type neutre ; la **matérialisation disque → ``CorpusSpec``** vit en
+couche ``app``. Module mince, aucun effet de bord à l'import.
+"""
+
+from __future__ import annotations
+
+from cinoc.adapters.corpus.escriptorium import (
+    EScriptoriumImporter,
+    EScriptoriumPage,
+)
+from cinoc.adapters.corpus.gallica import GallicaImporter, normalize_ark
+from cinoc.adapters.corpus.htr_united import (
+    HTRUnitedCatalogue,
+    HTRUnitedEntry,
+    fetch_catalogue,
+)
+from cinoc.adapters.corpus.huggingface import (
+    HuggingFaceCatalogue,
+    HuggingFaceDataset,
+)
+from cinoc.adapters.corpus.iiif import IIIFImage, IIIFImporter, parse_manifest
+
+__all__ = [
+    "EScriptoriumImporter",
+    "EScriptoriumPage",
+    "GallicaImporter",
+    "HTRUnitedCatalogue",
+    "HTRUnitedEntry",
+    "HuggingFaceCatalogue",
+    "HuggingFaceDataset",
+    "IIIFImage",
+    "IIIFImporter",
+    "fetch_catalogue",
+    "normalize_ark",
+    "parse_manifest",
+]
diff --git a/cinoc/adapters/corpus/_http.py b/cinoc/adapters/corpus/_http.py
new file mode 100644
index 0000000000000000000000000000000000000000..2656be2d8978f15ff8f5c0a024db5f47340fe104
--- /dev/null
+++ b/cinoc/adapters/corpus/_http.py
@@ -0,0 +1,360 @@
+"""Transport HTTP **durci anti-SSRF** pour les importeurs de corpus (couche 5).
+
+Un importeur va chercher des ressources à une URL **fournie par l'utilisateur** :
+le risque est qu'on serve de proxy vers le réseau interne (SSRF) ou qu'on télécharge
+sans borne (DoS mémoire/disque). Défenses, toutes testées :
+
+- **schéma** ``http``/``https`` seuls (pas de ``file://``, ``gopher://``…) ;
+- **pas de userinfo** dans l'URL ;
+- **résolution DNS validée** : *toutes* les IP résolues doivent être **publiques**
+  (rejet loopback / privé / link-local / réservé / multicast / non-spécifié) ;
+- **redirections re-validées** à chaque saut (une 30x ne peut pas pointer vers
+  l'interne) ; nombre de sauts borné ;
+- **taille plafonnée** au fil de l'eau (on ne fait pas confiance à
+  ``Content-Length``).
+
+**DNS-rebinding fermé — épinglage d'IP.** ``assert_public_url`` résout l'hôte
+**une seule fois**, valide **toutes** les IP, et **retourne** ces IP. La
+connexion vise alors directement l'IP **épinglée** (transport ``httpx`` à
+``network_backend`` custom, cf. :class:`_PinnedBackend`) : il n'y a **pas de
+seconde résolution** que pourrait détourner un DNS hostile. Le nom d'hôte de
+l'URL reste inchangé, donc le ``Host`` envoyé, le **SNI** et la vérification du
+certificat TLS portent toujours sur le vrai hôte (aucun override fragile) —
+seule la cible TCP est figée. L'épinglage est ré-appliqué **à chaque saut** de
+redirection. Le **gate « mode public » (403)** côté interface reste la première
+barrière (les imports distants y sont refusés) ; l'épinglage est la défense en
+profondeur, désormais étanche.
+
+Auth & redirections : les en-têtes (jeton) ne suivent **pas** un changement
+d'hôte (cf. ``_stream_validated``). Une seule pile HTTP (``httpx`` + son moteur
+``httpcore``) ; **aucun état global** (pas d'``install_opener``).
+"""
+
+from __future__ import annotations
+
+import contextlib
+import ipaddress
+import json
+import os
+import socket
+import typing
+from collections.abc import Iterator
+from pathlib import Path
+from urllib.parse import urlsplit
+
+import httpcore
+import httpx
+
+from cinoc.domain.errors import CinocError
+
+#: Plafonds (généreux mais bornés — un Space gratuit n'est pas un entrepôt).
+MANIFEST_MAX_BYTES = 16 * 1024 * 1024
+IMAGE_MAX_BYTES = 50 * 1024 * 1024
+DEFAULT_TIMEOUT = 30.0
+_MAX_REDIRECTS = 5
+_ALLOWED_SCHEMES = frozenset({"http", "https"})
+
+
+class CorpusHttpError(CinocError):
+    """Échec de transport d'un importeur de corpus."""
+
+
+class SsrfError(CorpusHttpError):
+    """L'URL cible une ressource interdite (schéma, userinfo ou IP non publique)."""
+
+
+class HttpFetchError(CorpusHttpError):
+    """La requête a échoué (statut, redirection cassée, dépassement de taille)."""
+
+
+def _is_public(ip: ipaddress.IPv4Address | ipaddress.IPv6Address) -> bool:
+    return not (
+        ip.is_private
+        or ip.is_loopback
+        or ip.is_link_local
+        or ip.is_reserved
+        or ip.is_multicast
+        or ip.is_unspecified
+    )
+
+
+def assert_public_url(url: str) -> tuple[str, ...]:
+    """Valide ``url`` et **retourne les IP publiques** vers lesquelles épingler.
+
+    Résout l'hôte **une seule fois** et exige que **toutes** les IP retournées
+    soient publiques : un nom qui résout (même partiellement) vers l'interne est
+    rejeté (``SsrfError``). Les IP validées sont retournées pour que l'appelant
+    **épingle** la connexion dessus (anti-DNS-rebinding) — pas de seconde
+    résolution. Pour une IP littérale, retourne cette IP (aucun DNS réel).
+    """
+    parts = urlsplit(url)
+    if parts.scheme not in _ALLOWED_SCHEMES:
+        raise SsrfError(f"schéma non autorisé : {parts.scheme!r} (http/https seuls).")
+    if parts.username or parts.password:
+        raise SsrfError("userinfo interdit dans l'URL.")
+    host = parts.hostname
+    if not host:
+        raise SsrfError("URL sans hôte.")
+    port = parts.port or (443 if parts.scheme == "https" else 80)
+    try:
+        infos = socket.getaddrinfo(host, port, proto=socket.IPPROTO_TCP)
+    except OSError as exc:
+        raise SsrfError(f"résolution DNS impossible pour {host!r} : {exc}.") from exc
+    pins: list[str] = []
+    for info in infos:
+        addr = str(info[4][0])  # sockaddr[0] = adresse textuelle (IPv4/IPv6)
+        if not _is_public(ipaddress.ip_address(addr)):
+            raise SsrfError(
+                f"hôte {host!r} résout vers une IP non publique ({addr})."
+            )
+        if addr not in pins:
+            pins.append(addr)
+    return tuple(pins)
+
+
+class _PinnedBackend(httpcore.SyncBackend):
+    """Épingle la cible TCP sur des IP **pré-validées** (anti-DNS-rebinding).
+
+    ``httpcore`` appelle ``connect_tcp(host, port)`` avec le **nom d'hôte** de
+    l'origine ; on substitue les IP déjà résolues+validées, sans repasser par le
+    DNS. Le nom d'hôte de l'URL restant inchangé, le SNI et la vérification du
+    certificat TLS (pilotés par ``httpcore`` depuis l'origin) portent toujours
+    sur le **vrai hôte** — donc aucun override fragile. On essaie les IP dans
+    l'ordre (comme ``socket.create_connection`` le ferait), préservant le
+    repli multi-adresses.
+    """
+
+    def __init__(self, ips: tuple[str, ...]) -> None:
+        super().__init__()
+        self._ips = ips
+
+    def connect_tcp(
+        self,
+        host: str,
+        port: int,
+        timeout: float | None = None,
+        local_address: str | None = None,
+        socket_options: typing.Any = None,
+    ) -> httpcore.NetworkStream:
+        last_exc: httpcore.ConnectError | None = None
+        for ip in self._ips:
+            try:
+                return super().connect_tcp(
+                    ip,
+                    port,
+                    timeout=timeout,
+                    local_address=local_address,
+                    socket_options=socket_options,
+                )
+            except httpcore.ConnectError as exc:
+                last_exc = exc
+        assert last_exc is not None  # _ips est non vide (cf. _make_client)
+        raise last_exc
+
+
+def _pinned_transport(ips: tuple[str, ...]) -> httpx.HTTPTransport:
+    """Transport ``httpx`` dont le backend réseau épingle ``ips``.
+
+    ``httpx`` n'expose pas ``network_backend`` ; on le pose sur le pool interne
+    (seul point d'injection). Le ``isinstance`` fait échouer **bruyamment** si
+    une future version de ``httpx`` change la forme du pool, plutôt que de
+    contourner silencieusement l'épinglage.
+    """
+    transport = httpx.HTTPTransport()
+    pool = transport._pool
+    if not isinstance(pool, httpcore.ConnectionPool):  # pragma: no cover
+        transport.close()
+        raise CorpusHttpError("épinglage IP indisponible : transport httpx inattendu.")
+    pool._network_backend = _PinnedBackend(ips)
+    return transport
+
+
+def _make_client(pins: tuple[str, ...] | None, timeout: float) -> httpx.Client:
+    """Client mono-saut. ``pins`` vide/None → résolution httpx normale.
+
+    Le cas ``None`` n'arrive qu'en test (``assert_public_url`` neutralisé en
+    no-op pour viser le loopback) ; en production il est toujours non vide.
+    """
+    if not pins:
+        return httpx.Client(timeout=timeout, follow_redirects=False)
+    return httpx.Client(
+        transport=_pinned_transport(pins), timeout=timeout, follow_redirects=False
+    )
+
+
+@contextlib.contextmanager
+def _stream_validated(
+    url: str, *, timeout: float, headers: dict[str, str] | None = None
+) -> Iterator[httpx.Response]:
+    """GET en streaming, **épinglé à l'IP validée** et re-validé à chaque saut.
+
+    Chaque saut (origine + redirections, bornées) : résout+valide une fois via
+    ``assert_public_url``, épingle la connexion sur l'IP retournée, puis envoie.
+    Les en-têtes fournis (ex. ``Authorization: Token …``) ne sont **jamais**
+    propagés vers un **hôte différent** de l'origine (fuite de credentials sur
+    redirection). Un client ``httpx`` distinct est créé par saut (épinglage
+    propre à l'IP du saut) ; tous sont fermés à la sortie du contexte.
+    """
+    origin_host = urlsplit(url).hostname
+    current = url
+    with contextlib.ExitStack() as stack:
+        for _ in range(_MAX_REDIRECTS + 1):
+            pins = assert_public_url(current)
+            # Auth conservée seulement tant qu'on reste sur l'hôte d'origine.
+            hop_headers = headers if urlsplit(current).hostname == origin_host else None
+            client = stack.enter_context(_make_client(pins, timeout))
+            request = client.build_request("GET", current, headers=hop_headers)
+            response = client.send(request, stream=True)
+            if response.is_redirect:
+                location = response.headers.get("location", "")
+                response.close()
+                if not location:
+                    raise HttpFetchError(
+                        f"redirection sans 'Location' depuis {current!r}."
+                    )
+                current = str(request.url.join(location))
+                continue
+            try:
+                yield response
+            finally:
+                response.close()
+            return
+        raise HttpFetchError(f"trop de redirections (> {_MAX_REDIRECTS}) pour {url!r}.")
+
+
+def _read_capped(response: httpx.Response, max_bytes: int) -> bytes:
+    chunks: list[bytes] = []
+    total = 0
+    for chunk in response.iter_bytes():
+        total += len(chunk)
+        if total > max_bytes:
+            raise HttpFetchError(f"réponse dépasse le plafond de {max_bytes} octets.")
+        chunks.append(chunk)
+    return b"".join(chunks)
+
+
+def fetch_json(
+    url: str,
+    *,
+    timeout: float = DEFAULT_TIMEOUT,
+    headers: dict[str, str] | None = None,
+) -> object:
+    """Récupère et parse un JSON ; anti-SSRF + plafond ``MANIFEST_MAX_BYTES``.
+
+    ``headers`` permet l'authentification d'API (ex. ``Authorization: Token …``) ;
+    il n'est jamais journalisé (les messages d'erreur ne portent que l'URL).
+    """
+    try:
+        with _stream_validated(url, timeout=timeout, headers=headers) as response:
+            response.raise_for_status()
+            raw = _read_capped(response, MANIFEST_MAX_BYTES)
+    except httpx.HTTPStatusError as exc:
+        raise HttpFetchError(
+            f"statut HTTP {exc.response.status_code} sur {url!r}."
+        ) from exc
+    except httpx.HTTPError as exc:
+        raise HttpFetchError(f"échec de transport sur {url!r} : {exc}.") from exc
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError as exc:
+        raise HttpFetchError(f"réponse non-JSON depuis {url!r} : {exc}.") from exc
+
+
+def download(
+    url: str,
+    dest: Path,
+    *,
+    timeout: float = DEFAULT_TIMEOUT,
+    headers: dict[str, str] | None = None,
+) -> None:
+    """Télécharge ``url`` vers ``dest`` en **flux disque** ; anti-SSRF + plafond.
+
+    Écrit au fil de l'eau dans un fichier ``.part`` voisin (jamais tout le corps
+    en RAM), plafonne à ``IMAGE_MAX_BYTES``, puis **renomme atomiquement**
+    (``os.replace``) vers ``dest``. À la moindre erreur (statut, dépassement de
+    plafond, I/O, annulation), le ``.part`` est supprimé : **aucun fichier
+    partiel** n'est laissé derrière, et ``dest`` n'apparaît qu'une fois complet.
+
+    ``headers`` (ex. ``Authorization``) n'est transmis qu'à l'hôte d'origine —
+    ``_stream_validated`` le retire sur une redirection cross-hôte (cf. D-050).
+    """
+    part = dest.with_name(dest.name + ".part")
+    try:
+        with _stream_validated(url, timeout=timeout, headers=headers) as response:
+            try:
+                response.raise_for_status()
+            except httpx.HTTPStatusError as exc:
+                raise HttpFetchError(
+                    f"statut HTTP {exc.response.status_code} sur {url!r}."
+                ) from exc
+            total = 0
+            with part.open("wb") as handle:
+                for chunk in response.iter_bytes():
+                    total += len(chunk)
+                    if total > IMAGE_MAX_BYTES:
+                        raise HttpFetchError(
+                            f"réponse dépasse le plafond de {IMAGE_MAX_BYTES} octets."
+                        )
+                    handle.write(chunk)
+        os.replace(part, dest)
+    except BaseException:
+        part.unlink(missing_ok=True)
+        raise
+
+
+def fetch_bytes(
+    url: str,
+    *,
+    timeout: float = DEFAULT_TIMEOUT,
+    headers: dict[str, str] | None = None,
+) -> bytes:
+    """Récupère un corps **binaire** en mémoire ; anti-SSRF + plafond manifeste.
+
+    Pour les ressources qui doivent être parsées depuis des **octets** (ex. ALTO
+    Gallica : lxml refuse un ``str`` portant une déclaration d'encodage XML).
+    """
+    try:
+        with _stream_validated(url, timeout=timeout, headers=headers) as response:
+            response.raise_for_status()
+            return _read_capped(response, MANIFEST_MAX_BYTES)
+    except httpx.HTTPStatusError as exc:
+        raise HttpFetchError(
+            f"statut HTTP {exc.response.status_code} sur {url!r}."
+        ) from exc
+    except httpx.HTTPError as exc:
+        # Échec de transport (connexion/timeout/protocole) : on l'enveloppe en
+        # HttpFetchError pour que les appelants n'aient qu'un type réseau à gérer
+        # (jamais une exception httpx brute qui échapperait au repli).
+        raise HttpFetchError(f"échec de transport sur {url!r} : {exc}.") from exc
+
+
+def fetch_text(
+    url: str,
+    *,
+    timeout: float = DEFAULT_TIMEOUT,
+    headers: dict[str, str] | None = None,
+) -> str:
+    """Récupère un corps **texte** (UTF-8, erreurs remplacées) ; anti-SSRF + plafond.
+
+    Pour les endpoints qui ne servent pas du JSON (ex. catalogue HTR-United).
+    """
+    # Accept #15 : un corps distant peut contenir des octets non-UTF-8 isolés ;
+    # `errors="replace"` insère U+FFFD plutôt que d'échouer sur une donnée mal
+    # encodée (le contenu reste exploitable, pas une GT manuelle).
+    return fetch_bytes(url, timeout=timeout, headers=headers).decode(
+        "utf-8", errors="replace"
+    )
+
+
+__all__ = [
+    "CorpusHttpError",
+    "HttpFetchError",
+    "IMAGE_MAX_BYTES",
+    "MANIFEST_MAX_BYTES",
+    "SsrfError",
+    "assert_public_url",
+    "download",
+    "fetch_bytes",
+    "fetch_json",
+    "fetch_text",
+]
diff --git a/cinoc/adapters/corpus/escriptorium.py b/cinoc/adapters/corpus/escriptorium.py
new file mode 100644
index 0000000000000000000000000000000000000000..643dd6e242e8edbef26ae3a41656b6b1505444e2
--- /dev/null
+++ b/cinoc/adapters/corpus/escriptorium.py
@@ -0,0 +1,185 @@
+"""Importeur de corpus **eScriptorium** (API REST) — couche 5.
+
+Rôle : **localiser** les pages d'un document eScriptorium (auth par token →
+liste paginée des *parts* + leur transcription) et retourner un type neutre. La
+**matérialisation disque** (download image + écriture GT → ``CorpusSpec``) vit en
+couche ``app`` (``app/corpus_import.py``).
+
+Contrairement à IIIF, eScriptorium porte une **vérité-terrain** (la couche de
+transcription choisie) → le corpus importé est **scorable** (CER/WER).
+
+API consommée (lecture seule) :
+
+- ``GET /api/documents/{pk}/parts/``                       → pages (paginé) ;
+- ``GET /api/documents/{pk}/parts/{pk}/transcriptions/``   → transcriptions.
+
+Dette de la source **non reprise** : l'export distant de couche OCR, le listing
+projets/connexion (surface morte ~40 %), et surtout le bug latent
+``Corpus(source=…)`` — ici la sortie est un ``CorpusSpec`` (``source`` va dans
+``metadata``), structurellement à l'abri.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import Any
+from urllib.parse import urljoin, urlsplit
+
+from cinoc.adapters.corpus._http import DEFAULT_TIMEOUT, HttpFetchError, fetch_json
+
+logger = logging.getLogger(__name__)
+
+#: Couche de transcription par défaut (libellé eScriptorium usuel pour la GT).
+DEFAULT_LAYER = "manual"
+#: Borne de pagination (un document = au plus quelques milliers de pages).
+_MAX_PAGES = 10_000
+
+
+@dataclass(frozen=True)
+class EScriptoriumPage:
+    """Une page (*part*) : son URL d'image absolue + son texte GT (peut être vide)."""
+
+    pk: int
+    image_url: str
+    gt_text: str
+    title: str
+
+
+def _image_uri(item: dict[str, Any], base_url: str) -> str:
+    """Extrait l'URL d'image d'une *part* (champ ``image`` : str ou objet)."""
+    img = item.get("image")
+    if isinstance(img, dict):
+        img = img.get("uri") or img.get("url") or ""
+    if not isinstance(img, str) or not img:
+        return ""
+    return urljoin(base_url, img)
+
+
+def _layer_name(transcription: dict[str, Any]) -> str:
+    nested = transcription.get("transcription")
+    if isinstance(nested, dict):
+        return str(nested.get("name", ""))
+    return str(transcription.get("name", ""))
+
+
+def extract_gt_text(transcriptions: list[dict[str, Any]], layer: str) -> str:
+    """Texte GT de la couche ``layer`` (lignes jointes, ou ``content``). Pur.
+
+    ``layer`` vide → première transcription rencontrée. Renvoie ``""`` si la
+    couche demandée est absente.
+    """
+    for transcription in transcriptions:
+        if layer and _layer_name(transcription) != layer:
+            continue
+        lines = transcription.get("lines") or []
+        if lines:
+            return "\n".join(
+                str(line.get("content", ""))
+                for line in lines
+                if isinstance(line, dict) and line.get("content")
+            )
+        return str(transcription.get("content", "") or "")
+    return ""
+
+
+class EScriptoriumImporter:
+    """Localise les pages d'un document eScriptorium (auth + API, **sans disque**)."""
+
+    name = "escriptorium"
+
+    def __init__(
+        self,
+        base_url: str,
+        token: str,
+        *,
+        layer: str = DEFAULT_LAYER,
+        timeout: float = DEFAULT_TIMEOUT,
+    ) -> None:
+        self._base_url = base_url.rstrip("/")
+        self._token = token
+        self._layer = layer
+        self._timeout = timeout
+
+    def _headers(self) -> dict[str, str]:
+        # Le token n'est jamais journalisé (cf. _http : erreurs sans en-têtes).
+        return {"Authorization": f"Token {self._token}", "Accept": "application/json"}
+
+    def _get(self, url: str) -> dict[str, Any]:
+        data = fetch_json(url, timeout=self._timeout, headers=self._headers())
+        if not isinstance(data, dict):
+            raise HttpFetchError(
+                f"réponse eScriptorium inattendue (objet JSON attendu) : {url!r}."
+            )
+        return data
+
+    def _paginate(self, path: str) -> list[dict[str, Any]]:
+        """Suit les liens ``next`` jusqu'à épuisement, **sans quitter l'hôte**.
+
+        Le ``next`` est contrôlé par le serveur : on **n'envoie jamais le jeton**
+        vers un hôte différent de ``base_url`` (un ``next`` cross-hôte est ignoré).
+        """
+        base_host = urlsplit(self._base_url).hostname
+        results: list[dict[str, Any]] = []
+        url: str | None = f"{self._base_url}/api/{path.lstrip('/')}"
+        for _ in range(_MAX_PAGES):
+            if not url:
+                break
+            data = self._get(url)
+            page = data.get("results")
+            results.extend(page if isinstance(page, list) else [])
+            nxt = data.get("next")
+            if not (isinstance(nxt, str) and nxt):
+                break
+            if urlsplit(nxt).hostname != base_host:
+                logger.warning(
+                    "[escriptorium] lien 'next' hors hôte ignoré (pas de jeton "
+                    "envoyé à un tiers) : %s",
+                    nxt,
+                )
+                break
+            url = nxt
+        return results
+
+    def _transcriptions(self, doc_pk: int, part_pk: int) -> list[dict[str, Any]]:
+        url = f"{self._base_url}/api/documents/{doc_pk}/parts/{part_pk}/transcriptions/"
+        data = fetch_json(url, timeout=self._timeout, headers=self._headers())
+        if isinstance(data, list):
+            return [t for t in data if isinstance(t, dict)]
+        if isinstance(data, dict):
+            page = data.get("results")
+            if isinstance(page, list):
+                return [t for t in page if isinstance(t, dict)]
+        return []
+
+    def fetch_pages(self, doc_pk: int) -> tuple[EScriptoriumPage, ...]:
+        pages: list[EScriptoriumPage] = []
+        for item in self._paginate(f"documents/{doc_pk}/parts/"):
+            pk = item.get("pk")
+            if not isinstance(pk, int):
+                # Accept #14 : une *part* sans pk entier (schéma inattendu) est
+                # ignorée — on ne devine pas un identifiant. Avertir, pas planter.
+                logger.warning(
+                    "[escriptorium] part sans 'pk' entier ignorée (doc %s) : %r",
+                    doc_pk,
+                    item.get("pk"),
+                )
+                continue
+            transcriptions = self._transcriptions(doc_pk, pk)
+            pages.append(
+                EScriptoriumPage(
+                    pk=pk,
+                    image_url=_image_uri(item, self._base_url),
+                    gt_text=extract_gt_text(transcriptions, self._layer),
+                    title=str(item.get("title", "") or f"part {pk}"),
+                )
+            )
+        return tuple(pages)
+
+
+__all__ = [
+    "DEFAULT_LAYER",
+    "EScriptoriumImporter",
+    "EScriptoriumPage",
+    "extract_gt_text",
+]
diff --git a/cinoc/adapters/corpus/gallica.py b/cinoc/adapters/corpus/gallica.py
new file mode 100644
index 0000000000000000000000000000000000000000..9bb0434bfae07dc816edf27c75fdf8b50152640f
--- /dev/null
+++ b/cinoc/adapters/corpus/gallica.py
@@ -0,0 +1,160 @@
+"""Importeur de corpus **Gallica** (BnF) — couche 5.
+
+Gallica expose ses images via un **manifeste IIIF** (réutilisé tel quel par
+``IIIFImporter``) et son OCR par page via l'endpoint **ALTO** officiel
+``RequestDigitalElement``. Cet adapter ne porte que la logique propre à Gallica :
+normalisation de l'**ARK**, URL du manifeste IIIF, et récupération de l'OCR d'une
+page (ALTO → texte en ordre de lecture).
+
+Choix : **ALTO** plutôt que ``texteBrut``. L'endpoint ``f{n}.texteBrut`` est
+désormais protégé par un challenge anti-bot (ALTCHA) en accès automatisé, donc
+inutilisable en import ; ``RequestDigitalElement?...&E=ALTO`` reste accessible et
+plus riche (on en extrait le texte via le parseur ALTO de la couche 2).
+
+Bug latent de la source **corrigé** : la numérotation page→OCR ne passe plus par
+une indirection ``selected_indices[i]+1`` (source d'un décalage) — c'est la
+**vue Gallica** lue dans l'URL d'image IIIF (``/f{n}/``) qui *est* le ``Deb`` de
+la requête ALTO. Le mapping est fait par le service ``app`` et prouvé par test.
+
+⚠️ L'OCR Gallica **n'est pas une vérité-terrain manuelle** : c'est la transcription
+automatique de la BnF, utilisable comme *référence* (baseline) à condition de
+l'étiqueter (``gt_source=gallica_ocr`` dans les métadonnées du corpus).
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from urllib.parse import urlencode
+
+from cinoc.adapters.corpus._http import DEFAULT_TIMEOUT, HttpFetchError, fetch_bytes
+from cinoc.domain.errors import CinocError, FormatError
+from cinoc.formats.alto import (
+    AltoBlock,
+    AltoComposedBlock,
+    AltoDocument,
+    AltoTextBlock,
+    parse_alto,
+)
+
+logger = logging.getLogger(__name__)
+
+#: Hôte Gallica de production (surchargeable pour les tests transport).
+GALLICA_BASE = "https://gallica.bnf.fr"
+
+#: ARK normalisé : ``naID/identifiant`` (ex. ``12148/btv1b8453561w``).
+_ARK_RE = re.compile(r"^[0-9]+/[A-Za-z0-9_.\-]+$")
+
+#: Numéro de **vue** Gallica dans une URL d'image IIIF (``…/ark:/12148/X/f3/…``).
+_VUE_RE = re.compile(r"/f(\d+)/")
+
+
+class GallicaArkError(CinocError):
+    """ARK Gallica malformé."""
+
+
+def normalize_ark(ark: str) -> str:
+    """Normalise un ARK (``ark:/12148/x`` | ``12148/x`` → ``12148/x``). Pur."""
+    value = ark.strip()
+    if value.startswith("ark:/"):
+        value = value[len("ark:/"):]
+    value = value.strip("/")
+    if not _ARK_RE.match(value):
+        raise GallicaArkError(
+            f"ARK invalide : {ark!r}. Forme attendue 'naID/identifiant' "
+            "(ex. '12148/btv1b8453561w')."
+        )
+    return value
+
+
+def vue_number(image_url: str) -> int | None:
+    """Numéro de vue Gallica extrait d'une URL d'image (``/f{n}/``), sinon ``None``.
+
+    C'est la source **autoritaire** pour apparier une image à son OCR : se fier à
+    la position dans la liste d'images est faux dès qu'un canvas sans image est
+    sauté par le parseur IIIF (décalage de page).
+    """
+    match = _VUE_RE.search(image_url)
+    return int(match.group(1)) if match else None
+
+
+def _block_lines(blocks: tuple[AltoBlock, ...], out: list[str]) -> None:
+    """Aplatit les ``<TextBlock>`` (récursif sur les ``<ComposedBlock>``) en lignes."""
+    for block in blocks:
+        if isinstance(block, AltoTextBlock):
+            for line in block.lines:
+                text = " ".join(s.content for s in line.strings if s.content)
+                if text:
+                    out.append(text)
+        elif isinstance(block, AltoComposedBlock):
+            _block_lines(block.blocks, out)
+
+
+def alto_to_text(document: AltoDocument) -> str:
+    """Texte d'un ALTO en **ordre de lecture** : lignes (``String/@CONTENT``) jointes.
+
+    Pas de dé-césure (le ``texteBrut`` historique n'en faisait pas non plus) : on
+    rend le contenu brut, ligne par ligne.
+    """
+    lines: list[str] = []
+    for page in document.pages:
+        _block_lines(page.blocks, lines)
+    return "\n".join(lines)
+
+
+class GallicaImporter:
+    """Localise un document Gallica : URL de manifeste IIIF + OCR ALTO par page."""
+
+    name = "gallica"
+
+    def __init__(
+        self,
+        ark: str,
+        *,
+        base_url: str = GALLICA_BASE,
+        timeout: float = DEFAULT_TIMEOUT,
+    ) -> None:
+        self.ark = normalize_ark(ark)
+        self._base_url = base_url.rstrip("/")
+        self._timeout = timeout
+
+    @property
+    def _identifier(self) -> str:
+        """Identifiant de la numérisation (ARK sans le naID) — param ``O`` de l'ALTO."""
+        return self.ark.split("/", 1)[1]
+
+    @property
+    def manifest_url(self) -> str:
+        return f"{self._base_url}/iiif/ark:/{self.ark}/manifest.json"
+
+    def alto_url(self, page: int) -> str:
+        """URL ALTO officielle d'une vue (``RequestDigitalElement``)."""
+        query = urlencode({"O": self._identifier, "E": "ALTO", "Deb": page})
+        return f"{self._base_url}/RequestDigitalElement?{query}"
+
+    def fetch_ocr_text(self, page: int) -> str:
+        """OCR d'une vue (1-based) via ALTO → texte. ``""`` si absent ou illisible."""
+        try:
+            data = fetch_bytes(self.alto_url(page), timeout=self._timeout)
+        except HttpFetchError as exc:
+            logger.warning(
+                "[gallica] ALTO indisponible pour %s f%d : %s", self.ark, page, exc
+            )
+            return ""
+        try:
+            return alto_to_text(parse_alto(data))
+        except FormatError as exc:  # ALTO malformé ou XML invalide
+            logger.warning(
+                "[gallica] ALTO illisible pour %s f%d : %s", self.ark, page, exc
+            )
+            return ""
+
+
+__all__ = [
+    "GALLICA_BASE",
+    "GallicaArkError",
+    "GallicaImporter",
+    "alto_to_text",
+    "normalize_ark",
+    "vue_number",
+]
diff --git a/cinoc/adapters/corpus/htr_united.py b/cinoc/adapters/corpus/htr_united.py
new file mode 100644
index 0000000000000000000000000000000000000000..b2b26c63dee987351d06e47bfa41195af30a2ebc
--- /dev/null
+++ b/cinoc/adapters/corpus/htr_united.py
@@ -0,0 +1,176 @@
+"""Catalogue **HTR-United** (découverte de corpus GT) — couche 5.
+
+HTR-United publie un index communautaire de corpus de vérité-terrain HTR/OCR sous
+forme d'un fichier YAML versionné sur GitHub. Cet adapter **découvre** (télécharge
+l'index + recherche), il ne **matérialise pas** un corpus (les entrées pointent
+vers des dépôts ALTO/PAGE — matérialisation = incrémentale, ultérieure).
+
+Repli **hors-ligne** assumé : si l'index distant est injoignable ou illisible, on
+sert un **socle de démonstration** intégré (petit, pas un dump) avec
+``source="demo"`` / ``is_demo=True`` — l'appelant sait que ce n'est pas le
+catalogue à jour (alimente la future UI de sélection de corpus).
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+import yaml
+
+from cinoc.adapters.corpus._http import DEFAULT_TIMEOUT, CorpusHttpError, fetch_text
+
+logger = logging.getLogger(__name__)
+
+#: Index communautaire (YAML brut sur GitHub).
+CATALOGUE_URL = (
+    "https://raw.githubusercontent.com/HTR-United/htr-united/master/htr-united.yml"
+)
+
+
+@dataclass(frozen=True)
+class HTRUnitedEntry:
+    """Une entrée du catalogue (métadonnées de découverte, pas le corpus)."""
+
+    id: str
+    title: str
+    url: str
+    description: str
+    languages: tuple[str, ...]
+
+
+#: Socle de démonstration minimal (corpus HTR-United réels) — repli hors-ligne.
+_DEMO_ENTRIES: tuple[HTRUnitedEntry, ...] = (
+    HTRUnitedEntry(
+        id="cremma-medieval",
+        title="CREMMA Medieval",
+        url="https://github.com/HTR-United/cremma-medieval",
+        description="Manuscrits médiévaux français et latins.",
+        languages=("fr", "la"),
+    ),
+    HTRUnitedEntry(
+        id="lectaurep-repertoires",
+        title="LECTAUREP Répertoires",
+        url="https://github.com/HTR-United/lectaurep-repertoires",
+        description="Répertoires de notaires manuscrits (XIXe-XXe).",
+        languages=("fr",),
+    ),
+    HTRUnitedEntry(
+        id="caroline-minuscule",
+        title="Caroline Minuscule",
+        url="https://github.com/HTR-United/CemmaCarolineMinuscule",
+        description="Minuscule caroline latine.",
+        languages=("la",),
+    ),
+)
+
+
+def _as_languages(raw: object) -> tuple[str, ...]:
+    """Normalise un champ langue (str, liste de str, ou liste de dicts)."""
+    if isinstance(raw, str):
+        return (raw,)
+    if isinstance(raw, list):
+        out: list[str] = []
+        for item in raw:
+            if isinstance(item, str):
+                out.append(item)
+            elif isinstance(item, dict):
+                value = item.get("iso") or item.get("lang") or item.get("label")
+                if value:
+                    out.append(str(value))
+        return tuple(out)
+    return ()
+
+
+def _entry_from_dict(item: dict[str, object]) -> HTRUnitedEntry | None:
+    url = str(item.get("url", "") or "")
+    title = str(item.get("title", "") or "")
+    if not url and not title:
+        return None
+    entry_id = str(item.get("id") or "") or url.rstrip("/").rsplit("/", 1)[-1] or title
+    return HTRUnitedEntry(
+        id=entry_id,
+        title=title or entry_id,
+        url=url,
+        description=str(item.get("description", "") or ""),
+        languages=_as_languages(item.get("language")),
+    )
+
+
+def parse_catalogue(raw_yaml: str) -> tuple[HTRUnitedEntry, ...]:
+    """Parse l'index YAML HTR-United → entrées. Pur (tolérant au schéma)."""
+    data = yaml.safe_load(raw_yaml)
+    if isinstance(data, dict):
+        for key in ("data", "projects", "catalog", "catalogue"):
+            if isinstance(data.get(key), list):
+                data = data[key]
+                break
+    if not isinstance(data, list):
+        return ()
+    entries = [
+        _entry_from_dict(item) for item in data if isinstance(item, dict)
+    ]
+    return tuple(e for e in entries if e is not None)
+
+
+@dataclass(frozen=True)
+class HTRUnitedCatalogue:
+    """Index HTR-United chargé, avec sa provenance (``remote`` | ``demo``)."""
+
+    entries: tuple[HTRUnitedEntry, ...]
+    source: str
+
+    @property
+    def is_demo(self) -> bool:
+        return self.source == "demo"
+
+    @classmethod
+    def from_demo(cls) -> HTRUnitedCatalogue:
+        return cls(entries=_DEMO_ENTRIES, source="demo")
+
+    def search(
+        self, query: str = "", language: str | None = None
+    ) -> tuple[HTRUnitedEntry, ...]:
+        results = self.entries
+        if query:
+            q = query.lower()
+            results = tuple(
+                e
+                for e in results
+                if q in e.title.lower()
+                or q in e.description.lower()
+                or q in e.id.lower()
+                or any(q in lg.lower() for lg in e.languages)
+            )
+        if language:
+            lang = language.lower()
+            results = tuple(
+                e for e in results if any(lang in lg.lower() for lg in e.languages)
+            )
+        return results
+
+
+def fetch_catalogue(
+    *, catalogue_url: str = CATALOGUE_URL, timeout: float = DEFAULT_TIMEOUT
+) -> HTRUnitedCatalogue:
+    """Télécharge l'index HTR-United ; **repli démo** si indisponible/illisible."""
+    try:
+        raw = fetch_text(catalogue_url, timeout=timeout)
+        entries = parse_catalogue(raw)
+    except (CorpusHttpError, yaml.YAMLError) as exc:
+        logger.warning(
+            "[htr_united] index distant indisponible (%s) — repli démo : %s",
+            catalogue_url,
+            exc,
+        )
+        return HTRUnitedCatalogue.from_demo()
+    return HTRUnitedCatalogue(entries=entries, source="remote")
+
+
+__all__ = [
+    "CATALOGUE_URL",
+    "HTRUnitedCatalogue",
+    "HTRUnitedEntry",
+    "fetch_catalogue",
+    "parse_catalogue",
+]
diff --git a/cinoc/adapters/corpus/huggingface.py b/cinoc/adapters/corpus/huggingface.py
new file mode 100644
index 0000000000000000000000000000000000000000..58dbd09a8d1b20e821ddefcf409f4b5c2f0b5ced
--- /dev/null
+++ b/cinoc/adapters/corpus/huggingface.py
@@ -0,0 +1,487 @@
+"""Découverte de datasets HTR/OCR sur **HuggingFace Hub** — couche 5.
+
+Recherche (découverte), pas matérialisation : on liste des datasets candidats
+(socle de **référence** intégré + API publique du Hub). Le téléchargement effectif
+d'un dataset (lib ``datasets``, dépendance lourde) est un extra **ultérieur**
+(`cinoc[huggingface]`), hors de cette tranche.
+
+L'appel API est **best-effort** : s'il échoue, on renvoie le socle de référence
+(``source="reference"``) en journalisant — l'utilisateur n'est jamais bloqué, et
+sait d'où vient chaque résultat (``source`` : ``reference`` | ``api``).
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable, Iterable, Iterator
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+from urllib.parse import urlencode
+
+from cinoc.adapters.corpus._http import (
+    DEFAULT_TIMEOUT,
+    IMAGE_MAX_BYTES,
+    CorpusHttpError,
+    fetch_json,
+)
+from cinoc.domain.errors import CinocError
+
+logger = logging.getLogger(__name__)
+
+HF_API_BASE = "https://huggingface.co/api"
+
+#: Tag de convention apposé aux datasets **curés Cinoc** (carte HF) : il rend un
+#: dataset de référence **découvrable** sur un compte sans coller son ``repo_id``.
+#: Émis par ``app.dataset_standardize`` (front-matter), filtré par ``discover_curated``.
+CURATED_DATASET_TAG = "cinoc-corpus"
+
+#: Convention Cinoc (cf. ``docs/corpus_huggingface.md``) : un dataset importable
+#: porte **au minimum** une colonne image et une colonne vérité-terrain. La
+#: segmentation est une extension *future* (non requise ici).
+CINOC_IMAGE_COLUMN = "image"
+CINOC_GT_COLUMN = "ground_truth"
+
+#: Extensions image reconnues (sinon ``.jpg`` par défaut) pour nommer le fichier.
+_IMAGE_EXTS = frozenset({".png", ".jpg", ".jpeg", ".tif", ".tiff", ".jp2", ".webp"})
+
+
+@dataclass(frozen=True)
+class HuggingFaceDataset:
+    """Un dataset candidat (métadonnées de découverte)."""
+
+    dataset_id: str
+    title: str
+    description: str
+    languages: tuple[str, ...]
+    downloads: int
+    source: str  # "reference" | "api"
+
+    @property
+    def hf_url(self) -> str:
+        return f"https://huggingface.co/datasets/{self.dataset_id}"
+
+
+@dataclass(frozen=True)
+class CuratedDatasetRef:
+    """Un dataset **curé Cinoc** découvert sur un compte HF (tag de convention).
+
+    Métadonnées d'affichage **et** d'import en un clic : ``repo_id`` (+ ``revision``
+    si l'API la fournit, pour épingler la repro) alimentent directement
+    ``import_curated_hf_corpus``."""
+
+    repo_id: str
+    title: str
+    revision: str | None
+    last_modified: str
+
+
+def _ref(
+    dataset_id: str, title: str, desc: str, langs: tuple[str, ...], dl: int
+) -> HuggingFaceDataset:
+    return HuggingFaceDataset(
+        dataset_id=dataset_id,
+        title=title,
+        description=desc,
+        languages=langs,
+        downloads=dl,
+        source="reference",
+    )
+
+
+#: Socle de référence minimal (datasets HTR/OCR patrimoniaux connus).
+_REFERENCE_DATASETS: tuple[HuggingFaceDataset, ...] = (
+    _ref(
+        "Teklia/NorHand", "NorHand", "Écriture manuscrite norvégienne.", ("no",), 1200
+    ),
+    _ref(
+        "Teklia/IAM-line",
+        "IAM (lignes)",
+        "Référence anglaise manuscrite.",
+        ("en",),
+        8400,
+    ),
+    _ref(
+        "bnf/gallica-presse-xix",
+        "Gallica Presse XIXe",
+        "Journaux numérisés XIXe (OCR + images).",
+        ("fr",),
+        15200,
+    ),
+)
+
+
+def _matches(ds: HuggingFaceDataset, query: str, language: str | None) -> bool:
+    if query:
+        q = query.lower()
+        if not (
+            q in ds.title.lower()
+            or q in ds.description.lower()
+            or q in ds.dataset_id.lower()
+            or any(q in lg.lower() for lg in ds.languages)
+        ):
+            return False
+    if language and not any(language.lower() in lg.lower() for lg in ds.languages):
+        return False
+    return True
+
+
+def search_reference(
+    query: str = "", language: str | None = None
+) -> tuple[HuggingFaceDataset, ...]:
+    """Filtre le socle de référence intégré. Pur (sans réseau)."""
+    return tuple(ds for ds in _REFERENCE_DATASETS if _matches(ds, query, language))
+
+
+def _parse_api(payload: object) -> tuple[HuggingFaceDataset, ...]:
+    """Mappe la réponse de l'API HF (liste de dicts) → datasets. Pur."""
+    if not isinstance(payload, list):
+        return ()
+    out: list[HuggingFaceDataset] = []
+    for item in payload:
+        if not isinstance(item, dict):
+            continue
+        dataset_id = str(item.get("id", "") or "")
+        if not dataset_id:
+            continue
+        downloads = item.get("downloads", 0)
+        out.append(
+            HuggingFaceDataset(
+                dataset_id=dataset_id,
+                title=dataset_id,
+                description="",
+                languages=(),
+                downloads=int(downloads) if isinstance(downloads, int) else 0,
+                source="api",
+            )
+        )
+    return tuple(out)
+
+
+class HuggingFaceCatalogue:
+    """Recherche de datasets : socle de référence + API publique (best-effort)."""
+
+    name = "huggingface"
+
+    def __init__(
+        self, *, api_base: str = HF_API_BASE, timeout: float = DEFAULT_TIMEOUT
+    ) -> None:
+        self._api_base = api_base.rstrip("/")
+        self._timeout = timeout
+
+    def _fetch_api(
+        self, query: str, language: str | None, limit: int
+    ) -> tuple[HuggingFaceDataset, ...]:
+        params: dict[str, str] = {
+            "task_categories": "image-to-text",
+            "limit": str(min(limit, 50)),
+        }
+        if query:
+            params["search"] = query
+        if language:
+            params["language"] = language
+        url = f"{self._api_base}/datasets?{urlencode(params)}"
+        return _parse_api(fetch_json(url, timeout=self._timeout))
+
+    def search(
+        self,
+        query: str = "",
+        language: str | None = None,
+        *,
+        limit: int = 20,
+        use_reference: bool = True,
+        include_api: bool = True,
+    ) -> tuple[HuggingFaceDataset, ...]:
+        results: list[HuggingFaceDataset] = []
+        if use_reference:
+            results.extend(search_reference(query, language))
+        if include_api:
+            seen = {ds.dataset_id for ds in results}
+            try:
+                for ds in self._fetch_api(query, language, limit):
+                    if ds.dataset_id not in seen:
+                        results.append(ds)
+                        seen.add(ds.dataset_id)
+            except CorpusHttpError as exc:
+                logger.warning(
+                    "[huggingface] recherche API indisponible — socle de référence "
+                    "seul : %s",
+                    exc,
+                )
+        # Accept #9 : socle de référence d'abord, API ensuite, puis troncature
+        # finale à `limit` — la référence (curée) prime sur l'API si l'union
+        # dépasse. Choix de découverte (display), pas de classement par score.
+        return tuple(results[:limit])
+
+
+class HuggingFaceConventionError(CinocError):
+    """Le dataset ne respecte pas la **convention Cinoc** (colonnes attendues)."""
+
+
+class HuggingFaceUnavailableError(CinocError):
+    """La lib ``datasets`` (extra ``[huggingface]``) n'est pas installée."""
+
+
+@dataclass(frozen=True)
+class HFPage:
+    """Une page **streamée** : octets image encodés + extension + texte GT.
+
+    Type neutre à la frontière adapter→app : l'image est livrée en **octets**
+    (jamais un objet PIL) pour que la matérialisation disque (couche 6) n'ait
+    aucune dépendance image.
+    """
+
+    image_bytes: bytes
+    image_ext: str
+    gt_text: str
+
+
+#: Charge un dataset en streaming → itérable de lignes. Injectable (test).
+HFLoader = Callable[[str, str], Iterable[object]]
+
+
+def _default_loader(dataset_id: str, split: str) -> Iterable[object]:
+    """Charge le dataset HF **en streaming** (jamais de snapshot local complet).
+
+    Import **paresseux** de ``datasets`` (extra ``[huggingface]``) : sans l'extra,
+    lève ``HuggingFaceUnavailableError`` (message actionnable). Les images sont
+    castées en ``Image(decode=False)`` → octets bruts (pas de décodage PIL).
+    """
+    try:
+        from datasets import Image, load_dataset  # type: ignore[import-not-found]
+    except ImportError as exc:
+        raise HuggingFaceUnavailableError(
+            "import HuggingFace indisponible : installer 'cinoc[huggingface]' "
+            "(lib 'datasets')."
+        ) from exc
+    dataset = load_dataset(dataset_id, split=split, streaming=True)
+    features = getattr(dataset, "features", None) or {}
+    if CINOC_IMAGE_COLUMN in features:
+        dataset = dataset.cast_column(CINOC_IMAGE_COLUMN, Image(decode=False))
+    return dataset  # type: ignore[no-any-return]
+
+
+def _ext_from_path(path: object) -> str:
+    if isinstance(path, str) and path:
+        suffix = PurePosixPath(path).suffix.lower()
+        if suffix in _IMAGE_EXTS:
+            return suffix
+    return ".jpg"
+
+
+def _extract_image(value: object) -> tuple[bytes, str]:
+    """Octets image + extension depuis une cellule ``image`` (``decode=False``)."""
+    if isinstance(value, dict):
+        raw = value.get("bytes")
+        if isinstance(raw, bytes) and raw:
+            return raw, _ext_from_path(value.get("path"))
+    raise HuggingFaceConventionError(
+        f"colonne {CINOC_IMAGE_COLUMN!r} : octets image absents (le dataset "
+        "doit stocker l'image en octets ; cf. convention Cinoc)."
+    )
+
+
+def _validate_columns(row: dict[str, object]) -> None:
+    missing = [c for c in (CINOC_IMAGE_COLUMN, CINOC_GT_COLUMN) if c not in row]
+    if missing:
+        raise HuggingFaceConventionError(
+            f"dataset non conforme à la convention Cinoc : colonnes manquantes "
+            f"{missing} (attendu : {CINOC_IMAGE_COLUMN!r} + {CINOC_GT_COLUMN!r})."
+        )
+
+
+def stream_pages(
+    dataset_id: str,
+    *,
+    split: str = "train",
+    limit: int | None = None,
+    loader: HFLoader | None = None,
+) -> Iterator[HFPage]:
+    """Streame les pages d'un dataset HF conforme à la **convention Cinoc**.
+
+    Page-par-page (``streaming=True`` côté ``datasets``) : on ne télécharge jamais
+    le snapshot complet ; ``limit`` borne le nombre de pages lues. La conformité
+    (colonnes ``image`` + ``ground_truth``) est validée sur la **1ʳᵉ ligne**. Une
+    image dépassant ``IMAGE_MAX_BYTES`` est **ignorée** (avertie), pas fatale.
+
+    ``loader`` (``(dataset_id, split) → itérable de lignes``) est injectable pour
+    tester sans la lib ``datasets`` ; défaut = streaming réel.
+    """
+    load = loader or _default_loader
+    validated = False
+    count = 0
+    for row in load(dataset_id, split):
+        if not isinstance(row, dict):
+            continue
+        if not validated:
+            _validate_columns(row)
+            validated = True
+        image_bytes, ext = _extract_image(row[CINOC_IMAGE_COLUMN])
+        if len(image_bytes) > IMAGE_MAX_BYTES:
+            logger.warning(
+                "[huggingface] image > %d octets ignorée (dataset %s).",
+                IMAGE_MAX_BYTES,
+                dataset_id,
+            )
+            continue
+        gt_value = row.get(CINOC_GT_COLUMN)
+        gt_text = gt_value if isinstance(gt_value, str) else ""
+        yield HFPage(image_bytes=image_bytes, image_ext=ext, gt_text=gt_text)
+        count += 1
+        if limit is not None and count >= limit:
+            return
+
+
+#: Récupère un JSON depuis une URL. Injectable → ``discover_curated`` se teste
+#: sans réseau (le défaut tape l'API HF via ``fetch_json``).
+CuratedFetcher = Callable[[str], object]
+
+
+def _parse_curated(payload: object, *, tag: str) -> tuple[CuratedDatasetRef, ...]:
+    """Réponse ``/api/datasets`` (liste de dicts) → datasets curés. Pure.
+
+    Re-filtre **défensivement** sur le tag (si la liste porte ``tags``) : on ne
+    présente que de vrais layouts Cinoc, jamais un dataset quelconque du compte."""
+    if not isinstance(payload, list):
+        return ()
+    out: list[CuratedDatasetRef] = []
+    for item in payload:
+        if not isinstance(item, dict):
+            continue
+        repo_id = str(item.get("id", "") or "")
+        if not repo_id:
+            continue
+        tags = item.get("tags")
+        if isinstance(tags, list) and tag not in tags:
+            continue
+        sha = item.get("sha")
+        out.append(
+            CuratedDatasetRef(
+                repo_id=repo_id,
+                title=str(item.get("id", repo_id)),
+                revision=str(sha) if isinstance(sha, str) and sha else None,
+                last_modified=str(item.get("lastModified", "") or ""),
+            )
+        )
+    return tuple(out)
+
+
+def whoami(
+    token: str,
+    *,
+    api_base: str = HF_API_BASE,
+    timeout: float = DEFAULT_TIMEOUT,
+    fetcher: Callable[[str], object] | None = None,
+) -> str | None:
+    """Handle du compte HF derrière un ``token`` (``/api/whoami-v2``). Best-effort.
+
+    Sert à faire **apparaître automatiquement** les datasets curés de l'opérateur
+    sans qu'il colle son identifiant : on résout son handle depuis sa clé. Échec
+    réseau / token invalide → ``None`` (repli sur ``CINOC_HF_AUTHOR`` ou l'import
+    manuel). Le token n'est jamais journalisé (cf. ``_http``)."""
+    if not token:
+        return None
+    get = fetcher or (
+        lambda url: fetch_json(
+            url, timeout=timeout, headers={"Authorization": f"Bearer {token}"}
+        )
+    )
+    try:
+        payload = get(f"{api_base.rstrip('/')}/whoami-v2")
+    except CorpusHttpError as exc:
+        logger.warning("[huggingface] whoami indisponible : %s", exc)
+        return None
+    if isinstance(payload, dict):
+        name = payload.get("name")
+        if isinstance(name, str) and name.strip():
+            return name.strip()
+    return None
+
+
+def discover_curated(
+    author: str,
+    *,
+    tag: str = CURATED_DATASET_TAG,
+    api_base: str = HF_API_BASE,
+    timeout: float = DEFAULT_TIMEOUT,
+    fetcher: CuratedFetcher | None = None,
+) -> tuple[CuratedDatasetRef, ...]:
+    """Liste les datasets **curés Cinoc** d'un compte HF (``author`` + ``tag``).
+
+    Best-effort : API injoignable → ``()`` en journalisant (l'UI retombe sur
+    l'import manuel par ``repo_id``, jamais un blocage). C'est ce qui fait
+    « apparaître » un dataset publié sans coller son identifiant : on filtre le
+    compte par le tag de convention."""
+    if not author:
+        return ()
+    get = fetcher or (lambda url: fetch_json(url, timeout=timeout))
+    params = {"author": author, "filter": tag, "full": "true", "limit": "100"}
+    url = f"{api_base.rstrip('/')}/datasets?{urlencode(params)}"
+    try:
+        payload = get(url)
+    except CorpusHttpError as exc:
+        logger.warning(
+            "[huggingface] découverte curée indisponible (compte %s) : %s",
+            author,
+            exc,
+        )
+        return ()
+    return _parse_curated(payload, tag=tag)
+
+
+def snapshot_curated_layout(
+    repo_id: str, dest: Path, revision: str | None
+) -> Path:  # pragma: no cover -- réseau réel (test 'live')
+    """Snapshot **partiel** d'un dataset curé Cinoc publié sur HF.
+
+    Ne rapatrie que ``corpus.json`` + ``ground_truth/`` (scorables en local) ; les
+    images restent des **références distantes** : le dataset embarque un layout
+    **IIIF statique** (Image API 3 level0, cf. ``app.dataset_standardize``) servi
+    par la racine ``resolve`` HF épinglée à la révision — l'URL est donc un lien
+    ``huggingface.co`` dont le chemin suit la syntaxe IIIF. Le rapport les affiche
+    (saveur « liens », D-094) et l'orchestrateur les **matérialise au run** (fetch
+    durci) pour les moteurs. ``huggingface_hub`` (extra ``[huggingface]``) est
+    importé paresseusement → sans l'extra, ``HuggingFaceUnavailableError``
+    actionnable ; dépôt/révision injoignable → ``CorpusHttpError`` (→ 422 web).
+    """
+    try:
+        from huggingface_hub import snapshot_download  # type: ignore[import-not-found]
+        from huggingface_hub.utils import (  # type: ignore[import-not-found]
+            HfHubHTTPError,
+        )
+    except ImportError as exc:
+        raise HuggingFaceUnavailableError(
+            "import curé HF indisponible : installer 'cinoc[huggingface]' "
+            "(lib 'huggingface_hub')."
+        ) from exc
+    try:
+        local = snapshot_download(
+            repo_id,
+            repo_type="dataset",
+            revision=revision,
+            allow_patterns=["corpus.json", "ground_truth/*"],
+            local_dir=str(dest),
+        )
+    except HfHubHTTPError as exc:
+        raise CorpusHttpError(
+            f"dataset curé HF {repo_id!r} injoignable : {exc}"
+        ) from exc
+    return Path(local)
+
+
+__all__ = [
+    "HF_API_BASE",
+    "CINOC_GT_COLUMN",
+    "CINOC_IMAGE_COLUMN",
+    "CURATED_DATASET_TAG",
+    "CuratedDatasetRef",
+    "HFPage",
+    "HuggingFaceCatalogue",
+    "HuggingFaceConventionError",
+    "HuggingFaceDataset",
+    "HuggingFaceUnavailableError",
+    "discover_curated",
+    "search_reference",
+    "snapshot_curated_layout",
+    "stream_pages",
+    "whoami",
+]
diff --git a/cinoc/adapters/corpus/iiif.py b/cinoc/adapters/corpus/iiif.py
new file mode 100644
index 0000000000000000000000000000000000000000..b8e40a696a32d0a619445726fab818f6cc047401
--- /dev/null
+++ b/cinoc/adapters/corpus/iiif.py
@@ -0,0 +1,137 @@
+"""Importeur de corpus **IIIF** (Presentation API v2 & v3) — couche 5.
+
+Rôle : **localiser** les pages d'un manifeste (parsing du schéma → URLs d'image).
+La **matérialisation disque** (téléchargement → ``CorpusSpec``) vit en couche
+``app`` (``app/corpus_import.py``) : un adapter parle protocole, pas filesystem.
+
+Périmètre : **images seules**. Un manifeste IIIF porte des pages numérisées, pas
+de transcription ; le corpus importé est donc sans vérité-terrain (OCR exécutable,
+métriques non applicables tant qu'une GT n'est pas appariée). C'est un choix
+assumé de la tranche, pas un manque.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from cinoc.adapters.corpus._http import DEFAULT_TIMEOUT, HttpFetchError, fetch_json
+
+
+@dataclass(frozen=True)
+class IIIFImage:
+    """Une page du manifeste : son URL d'image + un label lisible."""
+
+    image_url: str
+    label: str
+
+
+def _extract_label(raw: object) -> str:
+    """Aplati les formats de label IIIF (str, liste, map de langue v3)."""
+    if isinstance(raw, str):
+        return raw
+    if isinstance(raw, list) and raw:
+        return _extract_label(raw[0])
+    if isinstance(raw, dict):
+        for lang in ("fr", "en", "none", "@value"):
+            val = raw.get(lang)
+            if val:
+                return str(val[0]) if isinstance(val, list) and val else str(val)
+        for val in raw.values():
+            return _extract_label(val)
+    return str(raw) if raw else ""
+
+
+def _service_image_url(service: object) -> str:
+    """Construit ``{service}/full/max/0/default.jpg`` depuis un service Image API."""
+    if isinstance(service, list):
+        service = service[0] if service else {}
+    if not isinstance(service, dict):
+        return ""
+    svc_id = service.get("@id") or service.get("id") or ""
+    if not isinstance(svc_id, str) or not svc_id:
+        return ""
+    return f"{svc_id.rstrip('/')}/full/max/0/default.jpg"
+
+
+def _image_url_v2(canvas: dict[str, Any]) -> str:
+    images = canvas.get("images") or []
+    if not images or not isinstance(images[0], dict):
+        return ""
+    resource = images[0].get("resource", {})
+    if not isinstance(resource, dict):
+        return ""
+    direct = resource.get("@id", "")
+    if isinstance(direct, str) and direct and not direct.endswith("/info.json"):
+        return direct
+    return _service_image_url(resource.get("service", {}))
+
+
+def _image_url_v3(canvas: dict[str, Any]) -> str:
+    for annotation_page in canvas.get("items") or []:
+        for annotation in annotation_page.get("items") or []:
+            body = annotation.get("body", {})
+            if isinstance(body, list):
+                body = body[0] if body else {}
+            if not isinstance(body, dict):
+                continue
+            url = body.get("id") or body.get("@id") or ""
+            if isinstance(url, str) and url and body.get("type") == "Image":
+                return url
+            service_url = _service_image_url(body.get("service", []))
+            if service_url:
+                return service_url
+            if isinstance(url, str) and url:
+                return url
+    return ""
+
+
+def _detect_version(manifest: dict[str, Any]) -> int:
+    context = manifest.get("@context", "")
+    contexts = context if isinstance(context, list) else [context]
+    if any(isinstance(c, str) and "presentation/3" in c for c in contexts):
+        return 3
+    if manifest.get("type") == "Manifest" and "items" in manifest:
+        return 3
+    return 2
+
+
+def parse_manifest(manifest: dict[str, Any]) -> tuple[IIIFImage, ...]:
+    """Parse un manifeste IIIF (v2/v3 auto-détecté) → pages avec image. Pur."""
+    if _detect_version(manifest) == 3:
+        canvases = manifest.get("items") or []
+        extract = _image_url_v3
+    else:
+        sequences = manifest.get("sequences") or []
+        canvases = sequences[0].get("canvases", []) if sequences else []
+        extract = _image_url_v2
+    images: list[IIIFImage] = []
+    for i, canvas in enumerate(canvases, start=1):
+        if not isinstance(canvas, dict):
+            continue
+        url = extract(canvas)
+        if not url:
+            continue
+        label = _extract_label(canvas.get("label", f"canvas_{i}")) or f"canvas_{i}"
+        images.append(IIIFImage(image_url=url, label=label))
+    return tuple(images)
+
+
+class IIIFImporter:
+    """Localise les pages d'un manifeste IIIF (fetch + parse, **sans disque**)."""
+
+    name = "iiif"
+
+    def __init__(self, *, timeout: float = DEFAULT_TIMEOUT) -> None:
+        self._timeout = timeout
+
+    def fetch_images(self, manifest_url: str) -> tuple[IIIFImage, ...]:
+        manifest = fetch_json(manifest_url, timeout=self._timeout)
+        if not isinstance(manifest, dict):
+            raise HttpFetchError(
+                f"manifeste IIIF {manifest_url!r} : objet JSON attendu."
+            )
+        return parse_manifest(manifest)
+
+
+__all__ = ["IIIFImage", "IIIFImporter", "parse_manifest"]
diff --git a/cinoc/adapters/images.py b/cinoc/adapters/images.py
new file mode 100644
index 0000000000000000000000000000000000000000..280e5a65dc8a74469ce623c9847d423b962ec78a
--- /dev/null
+++ b/cinoc/adapters/images.py
@@ -0,0 +1,130 @@
+"""Vignettes du rapport : image → dérivé JPEG redimensionné (couche 5, adapter).
+
+Le redimensionnement utilise **Pillow** (interdit en ``reports`` — couche 7) ; il
+vit donc ici. Deux saveurs partagent le **même cœur** ``_render_jpeg`` :
+
+- ``thumbnail_data_uri`` → **data-URI** embarqué dans le HTML (saveur fichier
+  unique) ; les octets ne touchent jamais le ``RunResult``.
+- ``thumbnail_to_file`` → écrit le dérivé dans un dossier d'assets et renvoie un
+  **href relatif** (saveur dossier : HTML léger à liens relatifs).
+
+**Dégradé gracieux** : si Pillow n'est pas installé (extra ``[images]``), si le
+fichier manque ou est illisible → ``None`` (le rapport retombe sur l'aperçu
+synthétique). Aucune exception large.
+"""
+
+from __future__ import annotations
+
+import base64
+import io
+import logging
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+def _render_jpeg(source: str | Path, max_px: int) -> bytes | None:
+    """Octets JPEG d'une image locale redimensionnée ; ``None`` si indisponible.
+
+    Cœur partagé des deux saveurs (data-URI / fichier) : redimensionne pour que le
+    plus grand côté ≤ ``max_px`` (jamais agrandi), convertit en RGB, encode JPEG.
+    ``None`` (avec ``logger.warning``) si Pillow absent, fichier introuvable, ou
+    image illisible — le rendu reste fonctionnel (aperçu synthétique)."""
+    path = Path(source)
+    if not path.is_file():
+        return None
+    try:
+        from PIL import Image, UnidentifiedImageError
+    except ImportError as exc:
+        logger.warning(
+            "[images] Pillow indisponible (%s) — vignettes omises, aperçu "
+            "synthétique. Installer l'extra ``[images]``.",
+            exc,
+        )
+        return None
+    try:
+        with Image.open(path) as opened:
+            rgb = opened.convert("RGB")
+            rgb.thumbnail((max_px, max_px))
+            buffer = io.BytesIO()
+            rgb.save(buffer, format="JPEG", quality=82, optimize=True)
+    except (UnidentifiedImageError, OSError) as exc:
+        logger.warning("[images] image illisible %s : %s — vignette omise.", path, exc)
+        return None
+    return buffer.getvalue()
+
+
+def thumbnail_data_uri(source: str | Path, *, max_px: int = 280) -> str | None:
+    """Vignette JPEG **data-URI** d'une image locale ; ``None`` si indisponible.
+
+    Saveur fichier unique : les octets sont inlinés dans le HTML. ``None`` si le
+    dérivé n'a pu être produit (Pillow absent, fichier manquant/illisible)."""
+    raw = _render_jpeg(source, max_px)
+    if raw is None:
+        return None
+    payload = base64.b64encode(raw).decode("ascii")
+    return f"data:image/jpeg;base64,{payload}"
+
+
+def thumbnail_to_file(
+    source: str | Path, dest_dir: str | Path, stem: str, *, max_px: int = 280
+) -> str | None:
+    """Écrit la vignette JPEG dans ``dest_dir/<stem>.jpg`` ; renvoie un href relatif.
+
+    Saveur dossier : le dérivé est **un fichier sur disque** (pas inliné), le HTML
+    n'en porte qu'une **référence relative**. L'href renvoyé est relatif au
+    **parent** de ``dest_dir`` (``f"{dest_dir.name}/{stem}.jpg"``, séparateur ``/``
+    portable) : l'appelant garantit que le HTML est un voisin de ``dest_dir`` (cf.
+    ``app.report_images.write_report_bundle``). ``None`` si le dérivé n'a pu être
+    produit (dégradé gracieux, aucun fichier écrit, aucun dossier créé)."""
+    raw = _render_jpeg(source, max_px)
+    if raw is None:
+        return None
+    folder = Path(dest_dir)
+    folder.mkdir(parents=True, exist_ok=True)
+    (folder / f"{stem}.jpg").write_bytes(raw)
+    return f"{folder.name}/{stem}.jpg"
+
+
+def iiif_derivative(
+    source: str | Path, dest_path: str | Path, *, width: int
+) -> tuple[int, int] | None:
+    """Écrit un dérivé JPEG de **largeur exacte** ``width`` (jamais agrandi) à
+    ``dest_path`` ; renvoie ``(largeur, hauteur)`` réels, ou ``None`` (dégradé).
+
+    Variante **largeur-fixe** de ``_render_jpeg`` (qui borne le plus grand côté) :
+    une taille IIIF Image API ``full/{w},/`` exige une largeur exacte, pas un
+    cadrage. Convertit en RGB, ré-échantillonne (Lanczos), crée les dossiers
+    parents. ``None`` (avec ``logger.warning``) si Pillow absent, fichier
+    introuvable ou image illisible — l'outil appelant décide d'échouer ou non."""
+    path = Path(source)
+    if not path.is_file():
+        logger.warning("[images] image introuvable %s — dérivé IIIF omis.", path)
+        return None
+    try:
+        from PIL import Image, UnidentifiedImageError
+    except ImportError as exc:
+        logger.warning(
+            "[images] Pillow indisponible (%s) — dérivé IIIF omis. Extra ``[images]``.",
+            exc,
+        )
+        return None
+    try:
+        with Image.open(path) as opened:
+            rgb = opened.convert("RGB")
+            orig_w, orig_h = rgb.size
+            target_w = min(width, orig_w)  # jamais agrandi
+            target_h = max(1, round(orig_h * target_w / orig_w))
+            resized = rgb.resize((target_w, target_h), Image.Resampling.LANCZOS)
+            dest = Path(dest_path)
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            resized.save(dest, format="JPEG", quality=82, optimize=True)
+    except (UnidentifiedImageError, OSError) as exc:
+        logger.warning(
+            "[images] image illisible %s : %s — dérivé IIIF omis.", path, exc
+        )
+        return None
+    return (target_w, target_h)
+
+
+__all__ = ["thumbnail_data_uri", "thumbnail_to_file", "iiif_derivative"]
diff --git a/cinoc/adapters/layout/__init__.py b/cinoc/adapters/layout/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a73e347f8abfee43a6def91f423ecbe87a4828be
--- /dev/null
+++ b/cinoc/adapters/layout/__init__.py
@@ -0,0 +1,3 @@
+"""Adapters de mise en page (couche 5) — socle ``precomputed``."""
+
+from __future__ import annotations
diff --git a/cinoc/adapters/layout/_base.py b/cinoc/adapters/layout/_base.py
new file mode 100644
index 0000000000000000000000000000000000000000..cfb82a473b481d584947be732cd7467c04cf086e
--- /dev/null
+++ b/cinoc/adapters/layout/_base.py
@@ -0,0 +1,114 @@
+"""Contrat **partagé** des segmenteurs de mise en page (couche 5).
+
+Tout segmenteur (PP-DocLayout maison, segmenteur distant HF, futurs) produit la
+même forme : un détecteur rend des **régions brutes** (``LayoutDetection``), qu'on
+convertit en ``CanonicalLayout`` neutre (``to_canonical_layout``) puis qu'on
+sérialise en artefact ``LAYOUT`` (``layout_step_output``, la *queue* d'``execute``).
+
+Ces pièces sont **agnostiques du moteur** : elles vivaient dans ``pp_doclayout``
+(le segmenteur maison), ce qui forçait le segmenteur distant à importer un module
+PaddleX-spécifique pour les réutiliser. Extraites ici, les deux adapters en
+dépendent sans se coupler l'un à l'autre.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from cinoc.adapters._workspace import workspace_artifact_path
+from cinoc.domain.artifacts import Artifact, ArtifactType, compute_content_hash
+from cinoc.domain.errors import AdapterStepError
+from cinoc.domain.layout import BBox, CanonicalLayout, Geometry, LayoutPage, Region
+from cinoc.pipeline.types import RunContext, StepOutput
+
+
+@dataclass(frozen=True)
+class DetectedRegion:
+    """Une région détectée : étiquette, boîte (pixels) et score de confiance."""
+
+    label: str
+    x: int
+    y: int
+    width: int
+    height: int
+    score: float
+
+
+@dataclass(frozen=True)
+class LayoutDetection:
+    """Sortie brute d'un détecteur : dimensions de page + régions détectées."""
+
+    page_width: int
+    page_height: int
+    regions: tuple[DetectedRegion, ...]
+
+
+#: Détecteur **injectable** : chemin image → détection. Le défaut (PaddleX, appel
+#: distant…) est résolu paresseusement à l'exécution ; les tests injectent un faux.
+DetectorFn = Callable[[str], LayoutDetection]
+
+
+def to_canonical_layout(
+    detection: LayoutDetection, *, min_score: float
+) -> CanonicalLayout:
+    """Détections → ``CanonicalLayout`` (1 page, régions **sans lignes**).
+
+    Filtre au seuil de score, **trie** par position (haut→bas puis gauche→droite)
+    pour un ordre de lecture **déterministe** indépendant de l'ordre de détection,
+    et numérote les régions ``r1..rN``. Le ``label`` du modèle devient le
+    ``region_type`` neutre (``None`` si vide).
+    """
+    kept = [r for r in detection.regions if r.score >= min_score]
+    ordered = sorted(kept, key=lambda r: (r.y, r.x))
+    regions = tuple(
+        Region(
+            id=f"r{index + 1}",
+            region_type=r.label or None,
+            geometry=Geometry(
+                bbox=BBox(x=r.x, y=r.y, width=r.width, height=r.height)
+            ),
+        )
+        for index, r in enumerate(ordered)
+    )
+    page = LayoutPage(
+        width=detection.page_width or None,
+        height=detection.page_height or None,
+        regions=regions,
+        reading_order=tuple(region.id for region in regions),
+    )
+    return CanonicalLayout(pages=(page,))
+
+
+def layout_step_output(
+    layout: CanonicalLayout, context: RunContext, name: str
+) -> StepOutput:
+    """Sérialise un ``CanonicalLayout`` → artefact ``LAYOUT`` (tail d'``execute``
+    partagé par tous les segmenteurs : PP-DocLayout, segmenteur distant…)."""
+    if context.workspace_uri is None:
+        raise AdapterStepError(f"{name} : workspace requis (RunContext.workspace_uri).")
+    payload = layout.model_dump_json().encode("utf-8")
+    output_path = workspace_artifact_path(
+        context.workspace_uri, context.document_id, name, "layout.json"
+    )
+    output_path.write_bytes(payload)
+    return StepOutput(
+        artifacts={
+            ArtifactType.LAYOUT: Artifact(
+                id=f"{context.document_id}:{name}:layout",
+                document_id=context.document_id,
+                type=ArtifactType.LAYOUT,
+                uri=str(output_path),
+                content_hash=compute_content_hash(payload),
+            )
+        }
+    )
+
+
+__all__ = [
+    "DetectedRegion",
+    "DetectorFn",
+    "LayoutDetection",
+    "layout_step_output",
+    "to_canonical_layout",
+]
diff --git a/cinoc/adapters/layout/assembler.py b/cinoc/adapters/layout/assembler.py
new file mode 100644
index 0000000000000000000000000000000000000000..62fdfb8737b72bd51a97a5737f20959397ba9529
--- /dev/null
+++ b/cinoc/adapters/layout/assembler.py
@@ -0,0 +1,89 @@
+"""``AltoAssembler`` — assemblage ``LAYOUT → ALTO_XML`` (couche 5).
+
+Troisième étage du pipeline de segmentation (``CLAUDE.md`` §3 : *assemblage
+LAYOUT → ALTO_XML*). C'est un **constructeur d'ALTO** au sens du même `Module`
+Protocol que les autres briques : il prend un ``CanonicalLayout`` **rempli**
+(sortie du fan-out, sérialisé JSON) et émet de l'ALTO 4 déterministe
+(``layout_to_alto`` + ``write_alto`` octet-stable).
+
+L'assembleur vit en couche 5 (et non `pipeline`) parce qu'il dépend de `formats`
+(`write_alto`) — un import légal pour un adapter, interdit à `pipeline`.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from cinoc.domain.artifacts import Artifact, ArtifactType, compute_content_hash
+from cinoc.domain.errors import AdapterStepError
+from cinoc.domain.layout import CanonicalLayout
+from cinoc.formats.alto import write_alto
+from cinoc.formats.alto.layout_map import layout_to_alto
+from cinoc.pipeline.protocols import ParamValue
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import RunContext, StepOutput
+
+_VERSION = "1.0"
+
+
+class AltoAssembler:
+    """Assemble un ``LAYOUT`` rempli en ``ALTO_XML`` (ALTO 4, déterministe)."""
+
+    @property
+    def name(self) -> str:
+        return "alto_assembler"
+
+    @property
+    def version(self) -> str:
+        return _VERSION
+
+    @property
+    def input_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.LAYOUT})
+
+    @property
+    def output_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.ALTO_XML})
+
+    def execute(
+        self,
+        inputs: dict[ArtifactType, Artifact],
+        params: dict[str, ParamValue],
+        context: RunContext,
+        control: RunControl,
+    ) -> StepOutput:
+        control.raise_if_cancelled()
+        layout_art = inputs.get(ArtifactType.LAYOUT)
+        if layout_art is None or layout_art.uri is None:
+            raise AdapterStepError(
+                f"{self.name} : artefact LAYOUT manquant ou sans URI."
+            )
+        layout_path = Path(layout_art.uri)
+        try:
+            layout = CanonicalLayout.model_validate_json(layout_path.read_bytes())
+        except (OSError, ValueError) as exc:
+            raise AdapterStepError(
+                f"{self.name} : LAYOUT illisible ({layout_path.name!r}) : {exc}"
+            ) from exc
+        payload = write_alto(layout_to_alto(layout))
+        out_dir = (
+            Path(context.workspace_uri)
+            if context.workspace_uri
+            else layout_path.parent
+        )
+        out_path = out_dir / f"{context.document_id.replace('/', '_')}.alto.xml"
+        out_path.write_bytes(payload)
+        return StepOutput(
+            artifacts={
+                ArtifactType.ALTO_XML: Artifact(
+                    id=f"{context.document_id}:{self.name}:alto_xml",
+                    document_id=context.document_id,
+                    type=ArtifactType.ALTO_XML,
+                    uri=str(out_path),
+                    content_hash=compute_content_hash(payload),
+                )
+            }
+        )
+
+
+__all__ = ["AltoAssembler"]
diff --git a/cinoc/adapters/layout/crop.py b/cinoc/adapters/layout/crop.py
new file mode 100644
index 0000000000000000000000000000000000000000..e0bc77fc307d644a21b6625bcf2f6a7ae936e67a
--- /dev/null
+++ b/cinoc/adapters/layout/crop.py
@@ -0,0 +1,72 @@
+"""``crop_region`` — découpe l'image d'un bloc pour l'OCR par région (couche 5).
+
+Brique du pipeline **hybride** « segmentation externe → OCR des blocs » : le
+fan-out (couche 4) fournit une **boîte relative** ``(x0, y0, x1, y1) ∈ [0, 1]``
+(la couche 4 a déjà neutralisé les unités, ALTO ``mm10`` vs pixels) ; ici on
+ouvre l'image, on convertit en pixels et on découpe — le crop réel vit en
+couche 5 car il dépend de ``PIL`` (interdit à ``pipeline``).
+
+``Pillow`` est un extra optionnel, importé **paresseusement** : importer ce
+module n'exige pas la lib, seule l'exécution.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from urllib.parse import quote
+
+from cinoc.domain.artifacts import Artifact, ArtifactType, compute_content_hash
+from cinoc.domain.errors import AdapterStepError
+from cinoc.pipeline.types import RunContext
+
+_RelBox = tuple[float, float, float, float]
+
+
+def crop_region(
+    page_image: Artifact, rel_bbox: _RelBox, region_id: str, context: RunContext
+) -> Artifact:
+    """Découpe ``rel_bbox`` (relatif) de l'image page → artefact ``IMAGE`` du bloc."""
+    if page_image.uri is None:
+        raise AdapterStepError("crop_region : image page sans URI.")
+    if context.workspace_uri is None:
+        raise AdapterStepError("crop_region : workspace requis pour écrire le crop.")
+    try:
+        from PIL import Image  # type: ignore[import-not-found]
+    except ImportError as exc:
+        raise AdapterStepError(
+            "crop_region : Pillow non installé (pip install 'cinoc[tesseract]')."
+        ) from exc
+    try:
+        with Image.open(page_image.uri) as image:
+            width, height = image.size
+            box = (
+                max(0, min(width, round(rel_bbox[0] * width))),
+                max(0, min(height, round(rel_bbox[1] * height))),
+                max(0, min(width, round(rel_bbox[2] * width))),
+                max(0, min(height, round(rel_bbox[3] * height))),
+            )
+            if box[2] <= box[0] or box[3] <= box[1]:
+                raise AdapterStepError(
+                    f"crop_region : boîte vide pour la région {region_id!r}."
+                )
+            crop = image.crop(box)
+            stem = quote(region_id, safe="")
+            out_path = Path(context.workspace_uri) / (
+                f"{quote(context.document_id, safe='')}.{stem}.crop.png"
+            )
+            crop.save(out_path)
+    except OSError as exc:
+        raise AdapterStepError(
+            f"crop_region : image illisible ({page_image.uri!r}) : {exc}"
+        ) from exc
+    return Artifact(
+        id=f"{context.document_id}:crop:{region_id}",
+        document_id=context.document_id,
+        type=ArtifactType.IMAGE,
+        uri=str(out_path),
+        content_hash=compute_content_hash(out_path.read_bytes()),
+        region_id=region_id,
+    )
+
+
+__all__ = ["crop_region"]
diff --git a/cinoc/adapters/layout/pp_doclayout.py b/cinoc/adapters/layout/pp_doclayout.py
new file mode 100644
index 0000000000000000000000000000000000000000..781bf2b4802b25cb2db4a1c8e01fc4c62cf1eef1
--- /dev/null
+++ b/cinoc/adapters/layout/pp_doclayout.py
@@ -0,0 +1,147 @@
+"""``PPDocLayoutSegmenter`` — segmenteur de mise en page réel (PP-DocLayout).
+
+Détecte les **régions** d'une page (titre, paragraphe, figure, tableau…) et émet
+un ``LAYOUT`` (``CanonicalLayout`` à régions **sans lignes** — la reconnaissance
+les remplit ensuite, cf. fan-out couche 4). Implémente le ``Module`` Protocol
+**directement**, comme les autres adapters.
+
+Module **maison du socle** (≠ plugin tiers découvert) : enregistré par
+``register_default_modules`` → disponible **même en mode public** sur le Space
+(contrairement aux plugins via entry-points, fail-closed). Son SDK (PaddleX,
+Apache-2.0) est un **extra optionnel** (``cinoc[segment]``), importé
+**paresseusement** : importer ce module n'exige ni la lib ni les poids — seule
+l'exécution les requiert.
+
+Le détecteur est **injectable** (``detector=``) : la conversion détections →
+``CanonicalLayout`` se teste sans SDK ni poids (CI), le vrai modèle reste un test
+``live``/``slow`` opt-in. Déterminisme (§12) : à modèle + poids + params figés et
+seuil de score fixe, la sortie est stable ; l'ordre de lecture est **trié**
+(haut→bas puis gauche→droite), indépendant de l'ordre de détection.
+"""
+
+from __future__ import annotations
+
+from cinoc.adapters.layout._base import (
+    DetectedRegion,
+    DetectorFn,
+    LayoutDetection,
+    layout_step_output,
+    to_canonical_layout,
+)
+from cinoc.domain.artifacts import Artifact, ArtifactType
+from cinoc.domain.errors import AdapterStepError
+from cinoc.pipeline.protocols import ParamValue
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import RunContext, StepOutput
+
+_VERSION = "1.0"
+_DEFAULT_MIN_SCORE = 0.5
+
+
+#: Modèle PP-DocLayout par défaut. La variante **légère** ``PP-DocLayout-S``
+#: (poids ~10× plus petits) est bakable dans l'image Space pour **tester
+#: l'option** sans peser sur le free-tier ; ``-L`` reste le défaut qualité.
+#: Surchargé par ``CINOC_PPDOCLAYOUT_MODEL`` (lu par le builder) ou ``model=``.
+_DEFAULT_MODEL = "PP-DocLayout-L"
+
+
+def _detect_with_paddle(  # pragma: no cover -- SDK + poids requis (test 'live')
+    image_path: str, model: str = _DEFAULT_MODEL
+) -> LayoutDetection:
+    """Détecte la mise en page via **PaddleX PP-DocLayout**. Isolé → mockable.
+
+    SDK absent → ``AdapterStepError`` explicite (l'extra ``[segment]`` manque) ;
+    le module reste listable, il ne plante pas à l'import. Le corps qui exécute le
+    modèle n'est exercé que par un test ``live`` (SDK + poids installés). ``model``
+    choisit la variante (``-L`` qualité / ``-S`` légère)."""
+    try:
+        from paddlex import create_model  # type: ignore[import-not-found]
+    except ImportError as exc:
+        raise AdapterStepError(
+            "pp_doclayout : PaddleX non installé "
+            "(pip install 'cinoc[segment]' + poids PP-DocLayout)."
+        ) from exc
+    results = list(create_model(model).predict(image_path, batch_size=1))
+    if not results:
+        return LayoutDetection(page_width=0, page_height=0, regions=())
+    boxes = results[0].get("boxes", [])
+    regions = tuple(
+        DetectedRegion(
+            label=str(box.get("label", "")),
+            x=int(box["coordinate"][0]),
+            y=int(box["coordinate"][1]),
+            width=int(box["coordinate"][2]) - int(box["coordinate"][0]),
+            height=int(box["coordinate"][3]) - int(box["coordinate"][1]),
+            score=float(box.get("score", 0.0)),
+        )
+        for box in boxes
+    )
+    shape = results[0].get("input_img_shape") or (0, 0)
+    return LayoutDetection(
+        page_width=int(shape[1]), page_height=int(shape[0]), regions=regions
+    )
+
+
+class PPDocLayoutSegmenter:
+    """Segmenteur PP-DocLayout : ``IMAGE → LAYOUT`` (régions sans lignes)."""
+
+    def __init__(
+        self,
+        *,
+        model: str = _DEFAULT_MODEL,
+        min_score: float = _DEFAULT_MIN_SCORE,
+        detector: DetectorFn | None = None,
+    ) -> None:
+        if not 0.0 <= min_score <= 1.0:
+            raise AdapterStepError(
+                f"PPDocLayoutSegmenter : min_score ∈ [0, 1], reçu {min_score}."
+            )
+        self._model = model
+        self._min_score = min_score
+        self._detector = detector
+
+    @property
+    def name(self) -> str:
+        return "pp_doclayout"
+
+    @property
+    def version(self) -> str:
+        return _VERSION
+
+    @property
+    def input_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.IMAGE})
+
+    @property
+    def output_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.LAYOUT})
+
+    def _detect(self, image_path: str) -> LayoutDetection:
+        if self._detector is not None:
+            return self._detector(image_path)
+        return _detect_with_paddle(image_path, self._model)
+
+    def execute(
+        self,
+        inputs: dict[ArtifactType, Artifact],
+        params: dict[str, ParamValue],
+        context: RunContext,
+        control: RunControl,
+    ) -> StepOutput:
+        control.raise_if_cancelled()
+        image = inputs.get(ArtifactType.IMAGE)
+        if image is None or image.uri is None:
+            raise AdapterStepError(
+                f"{self.name} : artefact IMAGE manquant ou sans URI."
+            )
+        if context.workspace_uri is None:
+            raise AdapterStepError(
+                f"{self.name} : workspace requis (RunContext.workspace_uri)."
+            )
+        layout = to_canonical_layout(
+            self._detect(image.uri), min_score=self._min_score
+        )
+        return layout_step_output(layout, context, self.name)
+
+
+__all__ = ["PPDocLayoutSegmenter"]
diff --git a/cinoc/adapters/layout/precomputed.py b/cinoc/adapters/layout/precomputed.py
new file mode 100644
index 0000000000000000000000000000000000000000..28423e47735953c49d8b2b834e522981a4dcba36
--- /dev/null
+++ b/cinoc/adapters/layout/precomputed.py
@@ -0,0 +1,178 @@
+"""Socle ``precomputed`` de la tranche segmentation (couche 5, 0 dép, 0 réseau).
+
+Deux briques, **même ``Module`` Protocol** que les autres adapters, qui font
+tourner le squelette segmentation **sans segmenteur ni OCR réels** :
+
+- ``PrecomputedLayoutSource`` : ``IMAGE → LAYOUT`` — rejoue une mise en page
+  pré-calculée (régions seules) depuis ``<stem>.layout.json``.
+- ``PrecomputedRegionRecognizer`` : ``IMAGE → RAW_TEXT`` — rejoue le texte d'**une
+  région** (clé = ``Artifact.region_id`` de l'IMAGE d'entrée) depuis
+  ``<stem>.<label>.regions.json`` (``{region_id: texte}``). Appelé **une fois par
+  région** par le fan-out (couche 4) ; aucun découpage d'image réel (la donnée
+  est figée).
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from cinoc.domain.artifacts import Artifact, ArtifactType, compute_content_hash
+from cinoc.domain.errors import AdapterStepError
+from cinoc.domain.layout import CanonicalLayout
+from cinoc.pipeline.protocols import ParamValue
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import RunContext, StepOutput
+
+_VERSION = "1.0"
+
+
+def _require_image(inputs: dict[ArtifactType, Artifact], who: str) -> Path:
+    image = inputs.get(ArtifactType.IMAGE)
+    if image is None or image.uri is None:
+        raise AdapterStepError(f"{who} : artefact IMAGE manquant ou sans URI.")
+    return Path(image.uri)
+
+
+class PrecomputedLayoutSource:
+    """Rejoue une mise en page pré-calculée (``<stem>.layout.json``)."""
+
+    @property
+    def name(self) -> str:
+        return "precomputed_layout"
+
+    @property
+    def version(self) -> str:
+        return _VERSION
+
+    @property
+    def input_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.IMAGE})
+
+    @property
+    def output_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.LAYOUT})
+
+    def execute(
+        self,
+        inputs: dict[ArtifactType, Artifact],
+        params: dict[str, ParamValue],
+        context: RunContext,
+        control: RunControl,
+    ) -> StepOutput:
+        control.raise_if_cancelled()
+        image_path = _require_image(inputs, self.name)
+        layout_path = image_path.parent / f"{image_path.stem}.layout.json"
+        if not layout_path.is_file():
+            raise AdapterStepError(
+                f"{self.name} : mise en page pré-calculée introuvable — "
+                f"{layout_path.name!r} attendu près de {image_path.name!r}."
+            )
+        data = layout_path.read_bytes()
+        try:
+            CanonicalLayout.model_validate_json(data)
+        except ValueError as exc:
+            raise AdapterStepError(
+                f"{self.name} : {layout_path.name!r} n'est pas un "
+                f"CanonicalLayout valide : {exc}"
+            ) from exc
+        return StepOutput(
+            artifacts={
+                ArtifactType.LAYOUT: Artifact(
+                    id=f"{context.document_id}:{self.name}:layout",
+                    document_id=context.document_id,
+                    type=ArtifactType.LAYOUT,
+                    uri=str(layout_path),
+                    content_hash=compute_content_hash(data),
+                )
+            }
+        )
+
+
+class PrecomputedRegionRecognizer:
+    """Rejoue le texte d'une région (``<stem>.<label>.regions.json``)."""
+
+    def __init__(self, *, source_label: str) -> None:
+        if not source_label or not all(
+            c.isalnum() or c in "_-" for c in source_label
+        ):
+            raise AdapterStepError(
+                f"PrecomputedRegionRecognizer : source_label invalide "
+                f"{source_label!r} (alphanumérique + _ - uniquement)."
+            )
+        self._label = source_label
+
+    @property
+    def name(self) -> str:
+        return f"precomputed_region:{self._label}"
+
+    @property
+    def version(self) -> str:
+        return _VERSION
+
+    @property
+    def input_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.IMAGE})
+
+    @property
+    def output_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.RAW_TEXT})
+
+    def execute(
+        self,
+        inputs: dict[ArtifactType, Artifact],
+        params: dict[str, ParamValue],
+        context: RunContext,
+        control: RunControl,
+    ) -> StepOutput:
+        control.raise_if_cancelled()
+        image = inputs[ArtifactType.IMAGE]
+        if image.region_id is None:
+            raise AdapterStepError(
+                f"{self.name} : IMAGE sans region_id — la reconnaissance par "
+                "région attend une entrée déjà cadrée par le fan-out."
+            )
+        image_path = _require_image(inputs, self.name)
+        regions_path = (
+            image_path.parent / f"{image_path.stem}.{self._label}.regions.json"
+        )
+        if not regions_path.is_file():
+            raise AdapterStepError(
+                f"{self.name} : textes par région introuvables — "
+                f"{regions_path.name!r} attendu près de {image_path.name!r}."
+            )
+        try:
+            mapping = json.loads(regions_path.read_bytes())
+        except ValueError as exc:
+            raise AdapterStepError(
+                f"{self.name} : {regions_path.name!r} JSON invalide : {exc}"
+            ) from exc
+        if not isinstance(mapping, dict) or image.region_id not in mapping:
+            raise AdapterStepError(
+                f"{self.name} : région {image.region_id!r} absente de "
+                f"{regions_path.name!r}."
+            )
+        text = str(mapping[image.region_id])
+        out_dir = (
+            Path(context.workspace_uri)
+            if context.workspace_uri
+            else image_path.parent
+        )
+        out_path = out_dir / f"{image_path.stem}.{self._label}.{image.region_id}.txt"
+        payload = text.encode("utf-8")
+        out_path.write_bytes(payload)
+        return StepOutput(
+            artifacts={
+                ArtifactType.RAW_TEXT: Artifact(
+                    id=f"{context.document_id}:{self.name}:{image.region_id}:raw_text",
+                    document_id=context.document_id,
+                    type=ArtifactType.RAW_TEXT,
+                    uri=str(out_path),
+                    content_hash=compute_content_hash(payload),
+                    region_id=image.region_id,
+                )
+            }
+        )
+
+
+__all__ = ["PrecomputedLayoutSource", "PrecomputedRegionRecognizer"]
diff --git a/cinoc/adapters/layout/remote.py b/cinoc/adapters/layout/remote.py
new file mode 100644
index 0000000000000000000000000000000000000000..e8d27015a12037bc37a0893ebce6d34a01296bb4
--- /dev/null
+++ b/cinoc/adapters/layout/remote.py
@@ -0,0 +1,194 @@
+"""``RemoteSegmenter`` — segmenteur de mise en page **par appel distant**.
+
+Au lieu d'embarquer un modèle lourd (poids dans l'image), ce module **délègue** la
+détection de régions à un modèle hébergé ailleurs : un *Inference Endpoint* HF, un
+Space-modèle, ou tout service exposant l'API **object-detection** de Hugging Face.
+Cinoc **orchestre**, le modèle **tourne à distance** — le Space reste léger (pas de
+poids, pas d'inférence CPU locale).
+
+C'est l'incarnation « distante » du point d'extension unique de Cinoc : il
+implémente le **même ``Module`` Protocol** que ``PPDocLayoutSegmenter`` (et que les
+plugins tiers), donc il apparaît comme **segmenteur sélectionnable** avant un run.
+On change de modèle en changeant l'``endpoint`` — sans rien réinstaller.
+
+Schéma de réponse attendu = sortie **object-detection** HF :
+``[{"label": str, "score": float, "box": {"xmin","ymin","xmax","ymax"}}, …]``.
+
+Le détecteur est **injectable** (``detector=``) : la conversion détections →
+``CanonicalLayout`` se teste sans réseau ; le vrai appel HTTP (``httpx`` + garde
+**anti-SSRF** ``assert_public_url``) n'est exercé qu'en test ``live``. ``httpx`` est
+un extra optionnel (``cinoc[serve]``/``[google]``…), importé paresseusement.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from cinoc.adapters.corpus._http import SsrfError, assert_public_url
+from cinoc.adapters.layout._base import (
+    DetectedRegion,
+    DetectorFn,
+    LayoutDetection,
+    layout_step_output,
+    to_canonical_layout,
+)
+from cinoc.domain.artifacts import Artifact, ArtifactType
+from cinoc.domain.errors import AdapterStepError
+from cinoc.pipeline.protocols import ParamValue
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import RunContext, StepOutput
+
+_VERSION = "1.0"
+_DEFAULT_MIN_SCORE = 0.5
+_DEFAULT_TIMEOUT = 60.0
+
+
+def parse_hf_detections(
+    payload: object, *, page_width: int, page_height: int
+) -> LayoutDetection:
+    """Réponse object-detection HF → ``LayoutDetection`` (tolérante aux entrées
+    mal formées : les boîtes invalides sont ignorées, jamais une exception)."""
+    if not isinstance(payload, list):
+        raise AdapterStepError(
+            "remote_segmenter : réponse inattendue (liste de détections attendue)."
+        )
+    regions: list[DetectedRegion] = []
+    for item in payload:
+        if not isinstance(item, dict):
+            continue
+        box = item.get("box")
+        if not isinstance(box, dict):
+            continue
+        try:
+            x0, y0 = int(box["xmin"]), int(box["ymin"])
+            x1, y1 = int(box["xmax"]), int(box["ymax"])
+        except (KeyError, TypeError, ValueError):
+            continue
+        regions.append(
+            DetectedRegion(
+                label=str(item.get("label", "")),
+                x=x0,
+                y=y0,
+                width=max(0, x1 - x0),
+                height=max(0, y1 - y0),
+                score=float(item.get("score", 0.0)),
+            )
+        )
+    return LayoutDetection(
+        page_width=page_width, page_height=page_height, regions=tuple(regions)
+    )
+
+
+def _image_dims(image_path: str) -> tuple[int, int]:
+    """Dimensions ``(largeur, hauteur)`` de l'image ; ``(0, 0)`` si indisponible
+    (Pillow absent / illisible) — la conversion gère les dimensions nulles."""
+    try:
+        from PIL import Image, UnidentifiedImageError
+    except ImportError:
+        return (0, 0)
+    try:
+        with Image.open(image_path) as opened:
+            return (int(opened.width), int(opened.height))
+    except (UnidentifiedImageError, OSError):
+        return (0, 0)
+
+
+class RemoteSegmenter:
+    """Segmenteur ``IMAGE → LAYOUT`` délégué à un endpoint object-detection."""
+
+    def __init__(
+        self,
+        *,
+        endpoint: str,
+        token: str | None = None,
+        min_score: float = _DEFAULT_MIN_SCORE,
+        timeout: float = _DEFAULT_TIMEOUT,
+        detector: DetectorFn | None = None,
+    ) -> None:
+        if not endpoint:
+            raise AdapterStepError("remote_segmenter : 'endpoint' requis.")
+        if not 0.0 <= min_score <= 1.0:
+            raise AdapterStepError(
+                f"remote_segmenter : min_score ∈ [0, 1], reçu {min_score}."
+            )
+        self._endpoint = endpoint
+        self._token = token
+        self._min_score = min_score
+        self._timeout = timeout
+        self._detector = detector
+
+    @property
+    def name(self) -> str:
+        return "remote_segmenter"
+
+    @property
+    def version(self) -> str:
+        return _VERSION
+
+    @property
+    def input_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.IMAGE})
+
+    @property
+    def output_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.LAYOUT})
+
+    def _detect(self, image_path: str) -> LayoutDetection:
+        if self._detector is not None:
+            return self._detector(image_path)
+        return self._remote_detect(image_path)
+
+    def _remote_detect(  # pragma: no cover -- réseau réel (test 'live')
+        self, image_path: str
+    ) -> LayoutDetection:
+        try:
+            assert_public_url(self._endpoint)
+        except SsrfError as exc:
+            raise AdapterStepError(
+                f"remote_segmenter : endpoint refusé (anti-SSRF) : {exc}"
+            ) from exc
+        try:
+            import httpx
+        except ImportError as exc:
+            raise AdapterStepError(
+                "remote_segmenter : httpx absent (extra réseau requis)."
+            ) from exc
+        headers = {"Content-Type": "application/octet-stream"}
+        if self._token:
+            headers["Authorization"] = f"Bearer {self._token}"
+        try:
+            with httpx.Client(timeout=self._timeout) as client:
+                response = client.post(
+                    self._endpoint,
+                    content=Path(image_path).read_bytes(),
+                    headers=headers,
+                )
+                response.raise_for_status()
+                payload = response.json()
+        except httpx.HTTPError as exc:
+            raise AdapterStepError(
+                f"remote_segmenter : appel à l'endpoint échoué : {exc}"
+            ) from exc
+        width, height = _image_dims(image_path)
+        return parse_hf_detections(payload, page_width=width, page_height=height)
+
+    def execute(
+        self,
+        inputs: dict[ArtifactType, Artifact],
+        params: dict[str, ParamValue],
+        context: RunContext,
+        control: RunControl,
+    ) -> StepOutput:
+        control.raise_if_cancelled()
+        image = inputs.get(ArtifactType.IMAGE)
+        if image is None or image.uri is None:
+            raise AdapterStepError(
+                f"{self.name} : artefact IMAGE manquant ou sans URI."
+            )
+        layout = to_canonical_layout(
+            self._detect(image.uri), min_score=self._min_score
+        )
+        return layout_step_output(layout, context, self.name)
+
+
+__all__ = ["RemoteSegmenter", "parse_hf_detections"]
diff --git a/cinoc/adapters/layout/to_text.py b/cinoc/adapters/layout/to_text.py
new file mode 100644
index 0000000000000000000000000000000000000000..b244a05466ff5836141b94fa69a4d63b2d96bf00
--- /dev/null
+++ b/cinoc/adapters/layout/to_text.py
@@ -0,0 +1,106 @@
+"""``LayoutToTextExtractor`` — ``LAYOUT rempli → RAW_TEXT`` (couche 5).
+
+Quatrième étage **optionnel** d'un pipeline hybride : une fois les régions
+reconnues (fan-out → ``CanonicalLayout`` rempli), on aplatit le texte dans
+**l'ordre de lecture** pour le rendre **scorable** comme n'importe quelle sortie
+``RAW_TEXT`` (CER/WER à la page). C'est ce qui permet à un run « segmenteur →
+reconnaissance par bloc » d'être un **concurrent du Banc d'essai** comparé à un
+OCR à plat, et plus seulement un ALTO produit dans son coin.
+
+Déterministe : ordre = ``reading_order`` de la page (repli sur l'ordre déclaré),
+lignes d'une région jointes par ``\\n``, régions par ``\\n``, pages par ``\\n``.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from cinoc.domain.artifacts import Artifact, ArtifactType, compute_content_hash
+from cinoc.domain.errors import AdapterStepError
+from cinoc.domain.layout import CanonicalLayout, LayoutPage
+from cinoc.pipeline.protocols import ParamValue
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import RunContext, StepOutput
+
+_VERSION = "1.0"
+
+
+def _page_text(page: LayoutPage) -> str:
+    """Texte d'une page, régions dans l'ordre de lecture (repli ordre déclaré)."""
+    by_id = {region.id: region for region in page.regions}
+    ordered = [by_id[rid] for rid in page.reading_order if rid in by_id]
+    seen = {region.id for region in ordered}
+    ordered.extend(region for region in page.regions if region.id not in seen)
+    blocks: list[str] = []
+    for region in ordered:
+        lines = "\n".join(line.text for line in region.lines if line.text)
+        if lines:
+            blocks.append(lines)
+    return "\n".join(blocks)
+
+
+class LayoutToTextExtractor:
+    """Aplatit un ``LAYOUT`` rempli en ``RAW_TEXT`` (ordre de lecture, déterministe)."""
+
+    def __init__(self, label: str) -> None:
+        self._label = label
+
+    @property
+    def name(self) -> str:
+        return f"layout_to_text:{self._label}"
+
+    @property
+    def version(self) -> str:
+        return _VERSION
+
+    @property
+    def input_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.LAYOUT})
+
+    @property
+    def output_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.RAW_TEXT})
+
+    def execute(
+        self,
+        inputs: dict[ArtifactType, Artifact],
+        params: dict[str, ParamValue],
+        context: RunContext,
+        control: RunControl,
+    ) -> StepOutput:
+        control.raise_if_cancelled()
+        layout_art = inputs.get(ArtifactType.LAYOUT)
+        if layout_art is None or layout_art.uri is None:
+            raise AdapterStepError(
+                f"{self.name} : artefact LAYOUT manquant ou sans URI."
+            )
+        layout_path = Path(layout_art.uri)
+        try:
+            layout = CanonicalLayout.model_validate_json(layout_path.read_bytes())
+        except (OSError, ValueError) as exc:
+            raise AdapterStepError(
+                f"{self.name} : LAYOUT illisible ({layout_path.name!r}) : {exc}"
+            ) from exc
+        text = "\n".join(_page_text(page) for page in layout.pages)
+        payload = text.encode("utf-8")
+        out_dir = (
+            Path(context.workspace_uri)
+            if context.workspace_uri
+            else layout_path.parent
+        )
+        out_path = out_dir / f"{context.document_id.replace('/', '_')}.layout.txt"
+        out_path.write_bytes(payload)
+        return StepOutput(
+            artifacts={
+                ArtifactType.RAW_TEXT: Artifact(
+                    id=f"{context.document_id}:{self.name}:raw_text",
+                    document_id=context.document_id,
+                    type=ArtifactType.RAW_TEXT,
+                    uri=str(out_path),
+                    content_hash=compute_content_hash(payload),
+                )
+            }
+        )
+
+
+__all__ = ["LayoutToTextExtractor"]
diff --git a/cinoc/adapters/llm/__init__.py b/cinoc/adapters/llm/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c072246f87a7b6ddf4004cc2b9caba242d3badb
--- /dev/null
+++ b/cinoc/adapters/llm/__init__.py
@@ -0,0 +1,15 @@
+"""Adapters LLM/VLM (couche 5) — post-correction texte/image + transcription VLM.
+
+Modes par adapter (``PipelineMode``) : ``text_only`` (tous), ``text_and_image``
+et ``zero_shot`` (openai, mistral, anthropic — vision). ``ollama`` reste
+``text_only`` (socle local minimal).
+"""
+
+from __future__ import annotations
+
+from cinoc.adapters.llm.anthropic import AnthropicAdapter
+from cinoc.adapters.llm.mistral import MistralAdapter
+from cinoc.adapters.llm.ollama import OllamaAdapter
+from cinoc.adapters.llm.openai import OpenAIAdapter
+
+__all__ = ["AnthropicAdapter", "MistralAdapter", "OllamaAdapter", "OpenAIAdapter"]
diff --git a/cinoc/adapters/llm/_base.py b/cinoc/adapters/llm/_base.py
new file mode 100644
index 0000000000000000000000000000000000000000..26e8c0de697df1b07c899d06e1d73ea60b9f1fce
--- /dev/null
+++ b/cinoc/adapters/llm/_base.py
@@ -0,0 +1,285 @@
+"""Helpers partagés des adapters LLM/VLM (post-correction + transcription).
+
+Les adapters concrets (openai, anthropic, mistral, ollama) implémentent le
+``Module`` Protocol et ne fournissent que leurs **appels réseau** (isolés,
+mockables). Toute la logique commune — choix des entrées/sorties selon le
+**mode**, chargement du texte OCR et/ou de l'image, écriture de l'artefact —
+vit **ici**, dans ``run_llm_step`` : un seul endroit, aucun mode dupliqué par
+fournisseur (anti « 8+8+8 », cf. CLAUDE.md §8.8).
+
+Modes (``PipelineMode``, source de vérité unique en ``domain``) :
+
+- ``text_only``      — ``RAW_TEXT`` → ``CORRECTED_TEXT`` (le LLM ne voit pas l'image).
+- ``text_and_image`` — ``{RAW_TEXT, IMAGE}`` → ``CORRECTED_TEXT`` (le VLM voit l'image).
+- ``zero_shot``      — ``IMAGE`` → ``RAW_TEXT`` (transcription directe, sans OCR amont).
+"""
+
+from __future__ import annotations
+
+from base64 import b64encode
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any, NamedTuple, cast
+
+from cinoc.adapters._workspace import workspace_artifact_path
+from cinoc.domain.artifacts import Artifact, ArtifactType, compute_content_hash
+from cinoc.domain.errors import AdapterStepError
+from cinoc.domain.pipeline import PipelineMode
+from cinoc.domain.usage import ResourceUsage
+from cinoc.formats.text import read_plaintext
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import RunContext, StepOutput
+
+#: Prompt de post-correction (modes ``text_only`` / ``text_and_image``) ;
+#: ``{ocr_text}`` est substitué par le texte OCR amont.
+DEFAULT_CORRECTION_PROMPT = (
+    "Tu es un correcteur de transcriptions OCR de documents patrimoniaux. "
+    "Corrige uniquement les erreurs manifestes de reconnaissance, sans "
+    "reformuler ni moderniser l'orthographe historique. Réponds par le seul "
+    "texte corrigé.\n\n{ocr_text}"
+)
+
+#: Prompt de transcription directe (mode ``zero_shot`` : le VLM lit l'image).
+DEFAULT_TRANSCRIPTION_PROMPT = (
+    "Transcris fidèlement le texte de cette image de document patrimonial. "
+    "Conserve l'orthographe historique et la ponctuation d'origine. N'ajoute "
+    "aucun commentaire : réponds par le seul texte transcrit."
+)
+
+#: Extension de fichier → media type (sous-ensemble image courant).
+_MEDIA_TYPES = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+    ".gif": "image/gif",
+    ".tif": "image/tiff",
+    ".tiff": "image/tiff",
+}
+
+class LLMCompletion(NamedTuple):
+    """Réponse d'un fournisseur : texte + jetons consommés (si exposés)."""
+
+    text: str
+    tokens_in: int | None = None
+    tokens_out: int | None = None
+
+
+#: Appel d'un LLM texte : ``prompt → réponse`` (fournisseur + modèle capturés).
+TextInvoke = Callable[[str], LLMCompletion]
+#: Appel d'un VLM : ``prompt, media_type, image_b64 → réponse``.
+VisionInvoke = Callable[[str, str, str], LLMCompletion]
+
+
+def usage_tokens(value: Any) -> int | None:
+    """Coercition prudente d'un compteur de jetons SDK (``None`` si absent)."""
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        return None
+    return value
+
+
+def normalize_llm_content(raw: Any) -> str:
+    """Aplati une réponse LLM (``str`` ou liste de blocs) en chaîne."""
+    if raw is None:
+        return ""
+    if isinstance(raw, str):
+        return raw
+    if isinstance(raw, list):
+        parts: list[str] = []
+        for chunk in raw:
+            if isinstance(chunk, str):
+                parts.append(chunk)
+            elif isinstance(chunk, dict) and isinstance(chunk.get("text"), str):
+                parts.append(chunk["text"])
+            else:
+                text = getattr(chunk, "text", None)
+                if isinstance(text, str):
+                    parts.append(text)
+        return "".join(parts)
+    return str(raw)
+
+
+def validate_llm_label(label: str, adapter: str) -> str:
+    """Valide un label d'adapter LLM (alphanum + ``_ -``) et le renvoie.
+
+    Le label compose le ``name`` du module (``<kind>:<label>``) ; le restreindre
+    garde les noms de modules sûrs et stables (provenance ``RunManifest``).
+    """
+    if not label or not all(c.isalnum() or c in "_-" for c in label):
+        raise AdapterStepError(
+            f"{adapter} : label invalide {label!r} (alphanum + _ -)."
+        )
+    return label
+
+
+def validate_role(role: str, adapter: str, supported: frozenset[str]) -> PipelineMode:
+    """Valide un mode d'adapter contre ceux que le fournisseur supporte."""
+    if role not in supported:
+        raise AdapterStepError(
+            f"{adapter} : mode {role!r} non supporté "
+            f"(modes : {', '.join(sorted(supported))})."
+        )
+    return cast(PipelineMode, role)
+
+
+def llm_input_types(role: PipelineMode) -> frozenset[ArtifactType]:
+    """Types d'entrée requis par le ``role`` (mode du pipeline)."""
+    if role == "text_only":
+        return frozenset({ArtifactType.RAW_TEXT})
+    if role == "text_and_image":
+        return frozenset({ArtifactType.RAW_TEXT, ArtifactType.IMAGE})
+    return frozenset({ArtifactType.IMAGE})  # zero_shot
+
+
+def llm_output_type(role: PipelineMode) -> ArtifactType:
+    """Type produit : ``RAW_TEXT`` en transcription, sinon ``CORRECTED_TEXT``."""
+    return (
+        ArtifactType.RAW_TEXT
+        if role == "zero_shot"
+        else ArtifactType.CORRECTED_TEXT
+    )
+
+
+def default_prompt_for_role(role: PipelineMode) -> str:
+    """Prompt par défaut adapté au mode (transcription vs correction)."""
+    return (
+        DEFAULT_TRANSCRIPTION_PROMPT
+        if role == "zero_shot"
+        else DEFAULT_CORRECTION_PROMPT
+    )
+
+
+def build_prompt(template: str, ocr_text: str) -> str:
+    return template.replace("{ocr_text}", ocr_text)
+
+
+def load_ocr_text(inputs: dict[ArtifactType, Artifact], adapter_name: str) -> str:
+    artifact = inputs.get(ArtifactType.RAW_TEXT)
+    if artifact is None or artifact.uri is None:
+        raise AdapterStepError(
+            f"{adapter_name} : input RAW_TEXT manquant ou sans URI."
+        )
+    return read_plaintext(Path(artifact.uri).read_bytes())
+
+
+def load_image_b64(
+    inputs: dict[ArtifactType, Artifact], adapter_name: str
+) -> tuple[str, str]:
+    """Charge l'``IMAGE`` d'entrée → ``(media_type, base64)`` pour un VLM."""
+    artifact = inputs.get(ArtifactType.IMAGE)
+    if artifact is None or artifact.uri is None:
+        raise AdapterStepError(
+            f"{adapter_name} : input IMAGE manquant ou sans URI."
+        )
+    path = Path(artifact.uri)
+    media_type = _MEDIA_TYPES.get(path.suffix.lower(), "image/png")
+    return media_type, b64encode(path.read_bytes()).decode("ascii")
+
+
+def write_text_artifact(
+    workspace_uri: str,
+    document_id: str,
+    label: str,
+    adapter_name: str,
+    text: str,
+    *,
+    output_type: ArtifactType,
+) -> dict[ArtifactType, Artifact]:
+    """Écrit ``text`` dans le workspace → artefact du type produit par le mode."""
+    is_corrected = output_type == ArtifactType.CORRECTED_TEXT
+    suffix = "corrected.txt" if is_corrected else "raw.txt"
+    output_path = workspace_artifact_path(
+        workspace_uri, document_id, label, suffix
+    )
+    output_path.write_text(text, encoding="utf-8")
+    return {
+        output_type: Artifact(
+            id=f"{document_id}:{adapter_name}:{output_type.value}",
+            document_id=document_id,
+            type=output_type,
+            uri=str(output_path),
+            content_hash=compute_content_hash(text.encode("utf-8")),
+        )
+    }
+
+
+def run_llm_step(
+    *,
+    role: PipelineMode,
+    label: str,
+    name: str,
+    prompt: str,
+    inputs: dict[ArtifactType, Artifact],
+    context: RunContext,
+    control: RunControl,
+    text_invoke: TextInvoke,
+    vision_invoke: VisionInvoke | None,
+) -> StepOutput:
+    """Exécute une étape LLM/VLM selon le ``role`` — logique de mode unique.
+
+    Aiguille sur le mode : charge les bonnes entrées (texte et/ou image), appelle
+    l'invocation fournisseur idoine, écrit l'artefact du bon type. ``zero_shot``
+    et ``text_and_image`` exigent ``vision_invoke`` (un fournisseur texte-seul,
+    ex. ollama, passe ``None`` → ces modes sont refusés proprement). Les jetons
+    exposés par le fournisseur remontent dans ``StepOutput.usage``.
+    """
+    control.raise_if_cancelled()
+    if context.workspace_uri is None:
+        raise AdapterStepError(
+            f"{name} : workspace requis (RunContext.workspace_uri)."
+        )
+    if role == "zero_shot":
+        if vision_invoke is None:
+            raise AdapterStepError(f"{name} : mode zero_shot requiert un VLM (vision).")
+        media_type, image_b64 = load_image_b64(inputs, name)
+        completion = vision_invoke(prompt, media_type, image_b64)
+    elif role == "text_and_image":
+        if vision_invoke is None:
+            raise AdapterStepError(
+                f"{name} : mode text_and_image requiert un VLM (vision)."
+            )
+        ocr_text = load_ocr_text(inputs, name)
+        media_type, image_b64 = load_image_b64(inputs, name)
+        completion = vision_invoke(
+            build_prompt(prompt, ocr_text), media_type, image_b64
+        )
+    else:  # text_only
+        ocr_text = load_ocr_text(inputs, name)
+        completion = text_invoke(build_prompt(prompt, ocr_text))
+    artifacts = write_text_artifact(
+        context.workspace_uri,
+        context.document_id,
+        label,
+        name,
+        completion.text,
+        output_type=llm_output_type(role),
+    )
+    usage = (
+        ResourceUsage(
+            tokens_in=completion.tokens_in, tokens_out=completion.tokens_out
+        )
+        if completion.tokens_in is not None or completion.tokens_out is not None
+        else None
+    )
+    return StepOutput(artifacts=artifacts, usage=usage)
+
+
+__all__ = [
+    "DEFAULT_CORRECTION_PROMPT",
+    "DEFAULT_TRANSCRIPTION_PROMPT",
+    "LLMCompletion",
+    "TextInvoke",
+    "VisionInvoke",
+    "build_prompt",
+    "default_prompt_for_role",
+    "llm_input_types",
+    "llm_output_type",
+    "load_image_b64",
+    "load_ocr_text",
+    "normalize_llm_content",
+    "run_llm_step",
+    "usage_tokens",
+    "validate_llm_label",
+    "validate_role",
+    "write_text_artifact",
+]
diff --git a/cinoc/adapters/llm/anthropic.py b/cinoc/adapters/llm/anthropic.py
new file mode 100644
index 0000000000000000000000000000000000000000..4aae19a79ef29cc70580f213eab9df2343e801ad
--- /dev/null
+++ b/cinoc/adapters/llm/anthropic.py
@@ -0,0 +1,193 @@
+"""``AnthropicAdapter`` — post-correction LLM **et** transcription VLM (Claude).
+
+Implémente le ``Module`` Protocol, trois modes (``PipelineMode``) selon le rôle :
+``text_only`` (texte → corrigé), ``text_and_image`` (Claude vision : image +
+texte → corrigé), ``zero_shot`` (Claude vision : image → texte). Clé
+``ANTHROPIC_API_KEY`` ; SDK ``anthropic`` = **extra** importé paresseusement dans
+``_invoke_anthropic`` / ``_invoke_anthropic_vision`` (isolés → **mockables**, CI
+sans clé ni réseau). La ``Deadline`` borne l'appel.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from cinoc.adapters._resilience import call_resilient
+from cinoc.adapters.llm._base import (
+    LLMCompletion,
+    default_prompt_for_role,
+    llm_input_types,
+    llm_output_type,
+    normalize_llm_content,
+    run_llm_step,
+    usage_tokens,
+    validate_llm_label,
+    validate_role,
+)
+from cinoc.domain.artifacts import Artifact, ArtifactType
+from cinoc.domain.deadline import Deadline
+from cinoc.domain.errors import AdapterStepError
+from cinoc.domain.pipeline import PipelineMode
+from cinoc.pipeline.protocols import ParamValue
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import RunContext, StepOutput
+
+_VERSION = "1.0"
+_DEFAULT_MODEL = "claude-haiku-4-5-20251001"
+_MAX_TOKENS = 4096
+_SUPPORTED: frozenset[str] = frozenset({"text_only", "text_and_image", "zero_shot"})
+
+
+def _completion_from_message(response: Any) -> LLMCompletion:
+    """Réponse SDK ``messages.create`` → ``LLMCompletion`` (texte + jetons).
+
+    **Pur** (aucun réseau, aucun SDK) → la cartographie usage→jetons
+    (``input_tokens``/``output_tokens``, **noms propres à Claude**) est **testable
+    sur cassette** (étape 2d) ; le client live (``# pragma: no cover``) ne le
+    permettrait pas. Jetons → économie (coût cloud réel).
+    """
+    usage = getattr(response, "usage", None)
+    return LLMCompletion(
+        normalize_llm_content(getattr(response, "content", None)),
+        usage_tokens(getattr(usage, "input_tokens", None)),
+        usage_tokens(getattr(usage, "output_tokens", None)),
+    )
+
+
+def _anthropic_client(  # pragma: no cover -- réseau + clé API (cf. 'live')
+    model: str, content: object, deadline: Deadline
+) -> LLMCompletion:
+    """Appel ``messages.create`` partagé (texte ou multimodal)."""
+    import os
+
+    api_key = os.environ.get("ANTHROPIC_API_KEY")
+    if not api_key:
+        raise AdapterStepError("anthropic : ANTHROPIC_API_KEY manquante.")
+    try:
+        from anthropic import (  # type: ignore[import-not-found]
+            Anthropic,
+            AnthropicError,
+        )
+    except ImportError as exc:
+        raise AdapterStepError(
+            "anthropic : SDK non installé (pip install 'cinoc[anthropic]')."
+        ) from exc
+    client_kwargs: dict[str, object] = {"api_key": api_key}
+    timeout = deadline.as_sdk_timeout()
+    if timeout is not None:
+        client_kwargs["timeout"] = timeout
+    try:
+        # SDK anthropic typé strictement ; dicts valides à l'exécution (tests live).
+        client = Anthropic(**client_kwargs)  # type: ignore[arg-type]
+
+        def _create() -> Any:
+            return client.messages.create(
+                model=model,
+                max_tokens=_MAX_TOKENS,
+                messages=[{"role": "user", "content": content}],  # type: ignore[typeddict-item]
+            )
+
+        # Cap de concurrence (≤ N appels Anthropic simultanés) + retry borné sur
+        # 429/5xx (Retry-After respecté) — par défaut, sans configuration UI.
+        response = call_resilient("anthropic", _create)
+    except AnthropicError as exc:
+        raise AdapterStepError(
+            f"anthropic a échoué ({model}) : {type(exc).__name__}: {exc}"
+        ) from exc
+    return _completion_from_message(response)
+
+
+def _invoke_anthropic(  # pragma: no cover -- réseau + clé API (cf. marqueur 'live')
+    *, model: str, prompt: str, deadline: Deadline
+) -> LLMCompletion:
+    return _anthropic_client(model, prompt, deadline)
+
+
+def _invoke_anthropic_vision(  # pragma: no cover -- réseau + clé API (cf. 'live')
+    *, model: str, prompt: str, media_type: str, image_b64: str, deadline: Deadline
+) -> LLMCompletion:
+    content = [
+        {"type": "text", "text": prompt},
+        {
+            "type": "image",
+            "source": {
+                "type": "base64",
+                "media_type": media_type,
+                "data": image_b64,
+            },
+        },
+    ]
+    return _anthropic_client(model, content, deadline)
+
+
+class AnthropicAdapter:
+    """Adapter Anthropic multi-mode (post-correction texte/image, transcription)."""
+
+    def __init__(
+        self,
+        *,
+        label: str,
+        model: str = _DEFAULT_MODEL,
+        role: str = "text_only",
+        prompt: str | None = None,
+    ) -> None:
+        self._label = validate_llm_label(label, "AnthropicAdapter")
+        self._model = model
+        self._role: PipelineMode = validate_role(role, "AnthropicAdapter", _SUPPORTED)
+        self._prompt = (
+            prompt if prompt is not None else default_prompt_for_role(self._role)
+        )
+
+    @property
+    def name(self) -> str:
+        return f"anthropic:{self._label}"
+
+    @property
+    def version(self) -> str:
+        return _VERSION
+
+    @property
+    def input_types(self) -> frozenset[ArtifactType]:
+        return llm_input_types(self._role)
+
+    @property
+    def output_types(self) -> frozenset[ArtifactType]:
+        return frozenset({llm_output_type(self._role)})
+
+    def execute(
+        self,
+        inputs: dict[ArtifactType, Artifact],
+        params: dict[str, ParamValue],
+        context: RunContext,
+        control: RunControl,
+    ) -> StepOutput:
+        def text_invoke(prompt: str) -> LLMCompletion:
+            return _invoke_anthropic(
+                model=self._model, prompt=prompt, deadline=context.deadline
+            )
+
+        def vision_invoke(
+            prompt: str, media_type: str, image_b64: str
+        ) -> LLMCompletion:
+            return _invoke_anthropic_vision(
+                model=self._model,
+                prompt=prompt,
+                media_type=media_type,
+                image_b64=image_b64,
+                deadline=context.deadline,
+            )
+
+        return run_llm_step(
+            role=self._role,
+            label=self._label,
+            name=self.name,
+            prompt=self._prompt,
+            inputs=inputs,
+            context=context,
+            control=control,
+            text_invoke=text_invoke,
+            vision_invoke=vision_invoke,
+        )
+
+
+__all__ = ["AnthropicAdapter"]
diff --git a/cinoc/adapters/llm/mistral.py b/cinoc/adapters/llm/mistral.py
new file mode 100644
index 0000000000000000000000000000000000000000..a314534717e0660f19def6f6268e0915853d08ac
--- /dev/null
+++ b/cinoc/adapters/llm/mistral.py
@@ -0,0 +1,221 @@
+"""``MistralAdapter`` — post-correction LLM **et** transcription VLM (API Mistral).
+
+Implémente le ``Module`` Protocol, trois modes (``PipelineMode``) selon le rôle :
+``text_only`` (texte → corrigé), ``text_and_image`` (Pixtral : image + texte →
+corrigé), ``zero_shot`` (Pixtral : image → texte). Clé ``MISTRAL_API_KEY`` ; SDK
+``mistralai`` = **extra** importé paresseusement dans ``_invoke_mistral`` /
+``_invoke_mistral_vision`` (isolés → **mockables**, CI sans clé ni réseau).
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from cinoc.adapters._resilience import call_resilient
+from cinoc.adapters.llm._base import (
+    LLMCompletion,
+    default_prompt_for_role,
+    llm_input_types,
+    llm_output_type,
+    normalize_llm_content,
+    run_llm_step,
+    usage_tokens,
+    validate_llm_label,
+    validate_role,
+)
+from cinoc.domain.artifacts import Artifact, ArtifactType
+from cinoc.domain.deadline import Deadline
+from cinoc.domain.errors import AdapterStepError
+from cinoc.domain.pipeline import PipelineMode
+from cinoc.pipeline.protocols import ParamValue
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import RunContext, StepOutput
+
+logger = logging.getLogger(__name__)
+
+_VERSION = "1.0"
+_DEFAULT_MODEL = "mistral-small-latest"
+_SUPPORTED: frozenset[str] = frozenset({"text_only", "text_and_image", "zero_shot"})
+
+
+def _completion_from_chat(response: Any) -> LLMCompletion:
+    """Réponse SDK ``chat.complete`` → ``LLMCompletion`` (texte + jetons).
+
+    **Pur** (aucun réseau, aucun SDK) → la cartographie usage→jetons
+    (``prompt_tokens``/``completion_tokens``) est **testable sur cassette** (étape
+    2d) ; le client live (``# pragma: no cover``) ne le permettrait pas. Jetons →
+    économie (coût cloud réel).
+    """
+    usage = getattr(response, "usage", None)
+    tokens_in = usage_tokens(getattr(usage, "prompt_tokens", None))
+    tokens_out = usage_tokens(getattr(usage, "completion_tokens", None))
+    choices = getattr(response, "choices", None)
+    if not choices:
+        return LLMCompletion("", tokens_in, tokens_out)
+    return LLMCompletion(
+        normalize_llm_content(choices[0].message.content), tokens_in, tokens_out
+    )
+
+
+def _mistral_client(  # pragma: no cover -- réseau + clé API (cf. marqueur 'live')
+    model: str, content: object, deadline: Deadline
+) -> LLMCompletion:
+    """Appel ``chat.complete`` partagé (texte ou multimodal)."""
+    import os
+
+    api_key = os.environ.get("MISTRAL_API_KEY")
+    if not api_key:
+        raise AdapterStepError("mistral : MISTRAL_API_KEY manquante.")
+    try:
+        from mistralai import Mistral  # type: ignore[import-not-found]
+    except ImportError as exc:
+        raise AdapterStepError(
+            "mistral : SDK non installé (pip install 'cinoc[mistral]')."
+        ) from exc
+    client_kwargs: dict[str, object] = {"api_key": api_key}
+    timeout = deadline.as_sdk_timeout()
+    if timeout is not None:
+        client_kwargs["timeout_ms"] = int(timeout * 1000)
+    try:
+        # Le SDK mistralai 1.x type strictement ses kwargs/messages ; on lui
+        # passe des dicts valides à l'exécution (cf. tests live). ``ignore`` ciblé.
+        client = Mistral(**client_kwargs)  # type: ignore[arg-type]
+
+        def _complete() -> Any:
+            return client.chat.complete(
+                model=model,
+                messages=[{"role": "user", "content": content}],  # type: ignore[arg-type]
+                temperature=0.0,
+            )
+
+        # Cap de concurrence (≤ N appels Mistral simultanés) + retry borné sur
+        # 429/5xx (Retry-After respecté) — par défaut, sans configuration UI.
+        response = call_resilient("mistral", _complete)
+    except Exception as exc:  # le SDK lève des erreurs HTTP/SDK variées
+        raise AdapterStepError(
+            f"mistral a échoué ({model}) : {type(exc).__name__}: {exc}"
+        ) from exc
+    return _completion_from_chat(response)
+
+
+def _invoke_mistral(  # pragma: no cover -- réseau + clé API (cf. marqueur 'live')
+    *, model: str, prompt: str, deadline: Deadline
+) -> LLMCompletion:
+    return _mistral_client(model, prompt, deadline)
+
+
+def _invoke_mistral_vision(  # pragma: no cover -- réseau + clé API (cf. 'live')
+    *, model: str, prompt: str, media_type: str, image_b64: str, deadline: Deadline
+) -> LLMCompletion:
+    content = [
+        {"type": "text", "text": prompt},
+        {"type": "image_url", "image_url": f"data:{media_type};base64,{image_b64}"},
+    ]
+    return _mistral_client(model, content, deadline)
+
+
+class MistralAdapter:
+    """Adapter Mistral multi-mode (post-correction texte/image, transcription VLM)."""
+
+    def __init__(
+        self,
+        *,
+        label: str,
+        model: str = _DEFAULT_MODEL,
+        role: str = "text_only",
+        prompt: str | None = None,
+    ) -> None:
+        self._label = validate_llm_label(label, "MistralAdapter")
+        self._model = model
+        self._role: PipelineMode = validate_role(role, "MistralAdapter", _SUPPORTED)
+        self._prompt = (
+            prompt if prompt is not None else default_prompt_for_role(self._role)
+        )
+
+    @property
+    def name(self) -> str:
+        return f"mistral:{self._label}"
+
+    @property
+    def version(self) -> str:
+        return _VERSION
+
+    @property
+    def input_types(self) -> frozenset[ArtifactType]:
+        return llm_input_types(self._role)
+
+    @property
+    def output_types(self) -> frozenset[ArtifactType]:
+        return frozenset({llm_output_type(self._role)})
+
+    def execute(
+        self,
+        inputs: dict[ArtifactType, Artifact],
+        params: dict[str, ParamValue],
+        context: RunContext,
+        control: RunControl,
+    ) -> StepOutput:
+        def text_invoke(prompt: str) -> LLMCompletion:
+            return _invoke_mistral(
+                model=self._model, prompt=prompt, deadline=context.deadline
+            )
+
+        def vision_invoke(
+            prompt: str, media_type: str, image_b64: str
+        ) -> LLMCompletion:
+            return _invoke_mistral_vision(
+                model=self._model,
+                prompt=prompt,
+                media_type=media_type,
+                image_b64=image_b64,
+                deadline=context.deadline,
+            )
+
+        return run_llm_step(
+            role=self._role,
+            label=self._label,
+            name=self.name,
+            prompt=self._prompt,
+            inputs=inputs,
+            context=context,
+            control=control,
+            text_invoke=text_invoke,
+            vision_invoke=vision_invoke,
+        )
+
+
+def list_mistral_models(*, timeout: float = 5.0) -> tuple[str, ...]:
+    """IDs des modèles disponibles pour la clé Mistral courante (``models.list``).
+
+    **Best-effort, commodité d'UI** : ``MISTRAL_API_KEY`` absente, SDK absent ou
+    erreur réseau → ``()`` (l'interface retombe sur la saisie libre). Rien de
+    hardcodé : la liste vient **directement de l'API Mistral**.
+    """
+    import os
+
+    api_key = os.environ.get("MISTRAL_API_KEY")
+    if not api_key:
+        return ()
+    try:
+        from mistralai import Mistral  # type: ignore[import-not-found]
+    except ImportError:
+        return ()
+    try:
+        client = Mistral(api_key=api_key, timeout_ms=int(timeout * 1000))
+        response = client.models.list()
+    except Exception as exc:  # noqa: BLE001 — voir rationale ci-dessous
+        # Catch-all **assumé** : commodité d'UI qui ne doit jamais casser la
+        # page du composeur. Le SDK mistralai **enveloppe** ses erreurs HTTP
+        # (auth/429/5xx) dans ses propres types + propage des erreurs httpx pour
+        # le transport ; narrower au seul ``httpx.HTTPError`` (comme ollama, qui
+        # appelle httpx en direct) laisserait fuir une erreur SDK et casserait la
+        # page. On trace (§7) et on retombe sur la saisie libre.
+        logger.warning("[mistral] liste des modèles indisponible : %s", exc)
+        return ()
+    data = getattr(response, "data", None) or ()
+    ids = [m.id for m in data if isinstance(getattr(m, "id", None), str)]
+    return tuple(sorted(set(ids)))
+
+
+__all__ = ["MistralAdapter", "list_mistral_models"]
diff --git a/cinoc/adapters/llm/ollama.py b/cinoc/adapters/llm/ollama.py
new file mode 100644
index 0000000000000000000000000000000000000000..facec0322d21f113a58ba1aceb92b8d9aed50fa5
--- /dev/null
+++ b/cinoc/adapters/llm/ollama.py
@@ -0,0 +1,195 @@
+"""``OllamaAdapter`` — post-correction LLM via un serveur ollama local.
+
+Deuxième famille LLM : prouve que le ``Module`` Protocol **généralise au-delà
+d'openai** — même contrat ``RAW_TEXT`` → ``CORRECTED_TEXT``, sortie identique,
+aucun cas particulier. Transport ``httpx`` (extra), importé paresseusement et
+**isolé** dans ``_invoke_ollama`` (→ mockable, CI sans serveur).
+
+C'est l'**implémentation de référence de l'annulation câblée** : ``_invoke_ollama``
+enregistre ``client.close`` via ``RunControl.register_cancel_handle`` ; un
+``trigger_cancel`` ferme la connexion et **interrompt la requête en vol**. La
+distinction « annulation vs vraie panne réseau » se fait en sondant
+``is_cancelled`` (``_fail_or_cancel``) — pas par une heuristique de message
+fragile (dette de l'implémentation source, corrigée au portage).
+"""
+
+from __future__ import annotations
+
+from typing import NoReturn
+
+from cinoc.adapters.llm._base import (
+    DEFAULT_CORRECTION_PROMPT,
+    LLMCompletion,
+    normalize_llm_content,
+    run_llm_step,
+    usage_tokens,
+    validate_llm_label,
+)
+from cinoc.domain.artifacts import Artifact, ArtifactType
+from cinoc.domain.deadline import Deadline
+from cinoc.domain.errors import AdapterStepError
+from cinoc.pipeline.protocols import ParamValue
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import RunContext, StepOutput
+
+_VERSION = "1.0"
+_DEFAULT_MODEL = "llama3"
+_DEFAULT_HOST = "http://localhost:11434"
+
+
+def _fail_or_cancel(control: RunControl, model: str, exc: Exception) -> NoReturn:
+    """Traduit un échec d'appel ollama.
+
+    Si l'annulation a été déclenchée, le ``client.close`` enregistré a fait
+    échouer la requête en vol : on lève alors ``RunCancelledError`` (via
+    ``raise_if_cancelled``). Sinon c'est une vraie panne → ``AdapterStepError``.
+    Sonder ``is_cancelled`` est **fiable**, là où l'implémentation source
+    devinait par le message d'exception (heuristique fragile, D-A).
+    """
+    control.raise_if_cancelled()
+    raise AdapterStepError(f"ollama a échoué ({model}) : {exc}") from exc
+
+
+def _invoke_ollama(  # pragma: no cover -- réseau (serveur ollama ; cf. marqueur 'live')
+    *,
+    model: str,
+    prompt: str,
+    host: str,
+    deadline: Deadline,
+    control: RunControl,
+) -> LLMCompletion:
+    try:
+        import httpx  # type: ignore[import-not-found]
+    except ImportError as exc:
+        raise AdapterStepError(
+            "ollama : httpx non installé (pip install 'cinoc[ollama]')."
+        ) from exc
+    payload = {
+        "model": model,
+        "messages": [{"role": "user", "content": prompt}],
+        "stream": False,
+    }
+    client = httpx.Client(timeout=deadline.as_sdk_timeout())
+    # Annulation câblée : fermer le client interrompt la requête en vol.
+    control.register_cancel_handle(client.close)
+    try:
+        # **/api/chat** (et non /api/generate) : applique le gabarit de chat du
+        # modèle. Indispensable pour les modèles *instruct* (ex. churro), qui
+        # échouent sur /api/generate (complétion brute). C'est l'endpoint
+        # qu'utilise ``ollama run``.
+        response = client.post(f"{host}/api/chat", json=payload)
+        response.raise_for_status()
+        data = response.json()
+    except httpx.HTTPError as exc:
+        _fail_or_cancel(control, model, exc)
+    finally:
+        client.close()
+    # Ollama peut renvoyer une **erreur en HTTP 200** (modèle introuvable sous ce
+    # nom, mémoire insuffisante…) : ``raise_for_status`` ne la voit pas. On la
+    # remonte explicitement, sinon la « correction » serait un texte vide silencieux.
+    if isinstance(data, dict) and data.get("error"):
+        raise AdapterStepError(f"ollama a échoué ({model}) : {data['error']}")
+    message = data.get("message") if isinstance(data, dict) else None
+    content = message.get("content") if isinstance(message, dict) else None
+    # /api/chat expose la consommation : prompt_eval_count / eval_count.
+    counts = data if isinstance(data, dict) else {}
+    return LLMCompletion(
+        normalize_llm_content(content),
+        usage_tokens(counts.get("prompt_eval_count")),
+        usage_tokens(counts.get("eval_count")),
+    )
+
+
+def list_installed_models(
+    host: str = _DEFAULT_HOST, *, timeout: float = 3.0
+) -> tuple[str, ...]:
+    """Noms des modèles installés sur le serveur ollama (``GET /api/tags``).
+
+    **Best-effort, commodité d'UI** : serveur injoignable, ``httpx`` absent ou
+    réponse inattendue → ``()`` (l'interface retombe alors sur la saisie libre).
+    Aucune exception propagée. Le ``name`` renvoyé est le **tag exact** servable à
+    ``/api/generate`` (ex. ``gemma3:1b`` ou ``hf.co/…/churro-3B-GGUF:Q4_K_M``).
+    """
+    try:
+        import httpx  # type: ignore[import-not-found]
+    except ImportError:
+        return ()
+    try:
+        with httpx.Client(timeout=timeout) as client:
+            response = client.get(f"{host}/api/tags")
+            response.raise_for_status()
+            data = response.json()
+    except (httpx.HTTPError, ValueError):
+        return ()
+    models = data.get("models") if isinstance(data, dict) else None
+    if not isinstance(models, list):
+        return ()
+    return tuple(
+        m["name"]
+        for m in models
+        if isinstance(m, dict) and isinstance(m.get("name"), str)
+    )
+
+
+class OllamaAdapter:
+    """Post-correction LLM, serveur ollama local : ``RAW_TEXT`` → ``CORRECTED_TEXT``."""
+
+    def __init__(
+        self,
+        *,
+        label: str,
+        model: str = _DEFAULT_MODEL,
+        host: str = _DEFAULT_HOST,
+        prompt: str = DEFAULT_CORRECTION_PROMPT,
+    ) -> None:
+        self._label = validate_llm_label(label, "OllamaAdapter")
+        self._model = model
+        self._host = host
+        self._prompt = prompt
+
+    @property
+    def name(self) -> str:
+        return f"ollama:{self._label}"
+
+    @property
+    def version(self) -> str:
+        return _VERSION
+
+    @property
+    def input_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.RAW_TEXT})
+
+    @property
+    def output_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.CORRECTED_TEXT})
+
+    def execute(
+        self,
+        inputs: dict[ArtifactType, Artifact],
+        params: dict[str, ParamValue],
+        context: RunContext,
+        control: RunControl,
+    ) -> StepOutput:
+        def text_invoke(prompt: str) -> LLMCompletion:
+            return _invoke_ollama(
+                model=self._model,
+                prompt=prompt,
+                host=self._host,
+                deadline=context.deadline,
+                control=control,
+            )
+
+        return run_llm_step(
+            role="text_only",
+            label=self._label,
+            name=self.name,
+            prompt=self._prompt,
+            inputs=inputs,
+            context=context,
+            control=control,
+            text_invoke=text_invoke,
+            vision_invoke=None,
+        )
+
+
+__all__ = ["OllamaAdapter"]
diff --git a/cinoc/adapters/llm/openai.py b/cinoc/adapters/llm/openai.py
new file mode 100644
index 0000000000000000000000000000000000000000..04c3baea99015711af5b5f8ca2e1ddfac21c0f46
--- /dev/null
+++ b/cinoc/adapters/llm/openai.py
@@ -0,0 +1,188 @@
+"""``OpenAIAdapter`` — post-correction LLM **et** transcription VLM (API OpenAI).
+
+Implémente le ``Module`` Protocol. Trois modes (``PipelineMode``) selon le rôle
+passé à la construction : ``text_only`` (``RAW_TEXT`` → ``CORRECTED_TEXT``),
+``text_and_image`` (image + texte → corrigé), ``zero_shot`` (image → texte). La
+clé vient de ``OPENAI_API_KEY`` ; le SDK ``openai`` est un **extra** importé
+paresseusement dans ``_invoke_openai`` / ``_invoke_openai_vision`` (isolés →
+**mockables**, CI sans clé ni réseau). La ``Deadline`` borne l'appel.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from cinoc.adapters._resilience import call_resilient
+from cinoc.adapters.llm._base import (
+    LLMCompletion,
+    default_prompt_for_role,
+    llm_input_types,
+    llm_output_type,
+    normalize_llm_content,
+    run_llm_step,
+    usage_tokens,
+    validate_llm_label,
+    validate_role,
+)
+from cinoc.domain.artifacts import Artifact, ArtifactType
+from cinoc.domain.deadline import Deadline
+from cinoc.domain.errors import AdapterStepError
+from cinoc.domain.pipeline import PipelineMode
+from cinoc.pipeline.protocols import ParamValue
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import RunContext, StepOutput
+
+_VERSION = "1.0"
+_DEFAULT_MODEL = "gpt-4o-mini"
+_SUPPORTED: frozenset[str] = frozenset({"text_only", "text_and_image", "zero_shot"})
+
+
+def _completion_from_chat(response: Any) -> LLMCompletion:
+    """Réponse SDK ``chat.completions`` → ``LLMCompletion`` (texte + jetons).
+
+    **Pur** (aucun réseau, aucun import SDK) → la cartographie usage→jetons
+    (``prompt_tokens``/``completion_tokens``) est **testable sur une réponse de
+    cassette**, ce que le client live (``# pragma: no cover``) ne permet pas. Les
+    jetons alimentent l'économie (coût réel par modèle).
+    """
+    usage = getattr(response, "usage", None)
+    tokens_in = usage_tokens(getattr(usage, "prompt_tokens", None))
+    tokens_out = usage_tokens(getattr(usage, "completion_tokens", None))
+    choices = getattr(response, "choices", None)
+    if not choices:
+        return LLMCompletion("", tokens_in, tokens_out)
+    return LLMCompletion(
+        normalize_llm_content(choices[0].message.content), tokens_in, tokens_out
+    )
+
+
+def _openai_client(  # pragma: no cover -- réseau + clé API (cf. marqueur 'live')
+    model: str, messages: list[dict[str, object]], deadline: Deadline
+) -> LLMCompletion:
+    """Appel ``chat.completions`` partagé (texte ou multimodal)."""
+    import os
+
+    api_key = os.environ.get("OPENAI_API_KEY")
+    if not api_key:
+        raise AdapterStepError("openai : OPENAI_API_KEY manquante.")
+    try:
+        from openai import OpenAI, OpenAIError  # type: ignore[import-not-found]
+    except ImportError as exc:
+        raise AdapterStepError(
+            "openai : SDK non installé (pip install 'cinoc[openai]')."
+        ) from exc
+    kwargs: dict[str, object] = {
+        "model": model,
+        "messages": messages,
+        "temperature": 0.0,
+    }
+    timeout = deadline.as_sdk_timeout()
+    if timeout is not None:
+        kwargs["timeout"] = timeout
+    try:
+        # SDK openai typé strictement ; kwargs valides à l'exécution (tests live).
+        client = OpenAI(api_key=api_key)
+
+        def _create() -> Any:
+            return client.chat.completions.create(**kwargs)  # type: ignore[call-overload]
+
+        # Cap de concurrence (≤ N appels OpenAI simultanés) + retry borné sur
+        # 429/5xx (Retry-After respecté) — par défaut, sans configuration UI.
+        response = call_resilient("openai", _create)
+    except OpenAIError as exc:
+        raise AdapterStepError(
+            f"openai a échoué ({model}) : {type(exc).__name__}: {exc}"
+        ) from exc
+    return _completion_from_chat(response)
+
+
+def _invoke_openai(  # pragma: no cover -- réseau + clé API (cf. marqueur 'live')
+    *, model: str, prompt: str, deadline: Deadline
+) -> LLMCompletion:
+    return _openai_client(model, [{"role": "user", "content": prompt}], deadline)
+
+
+def _invoke_openai_vision(  # pragma: no cover -- réseau + clé API (cf. marqueur 'live')
+    *, model: str, prompt: str, media_type: str, image_b64: str, deadline: Deadline
+) -> LLMCompletion:
+    content = [
+        {"type": "text", "text": prompt},
+        {
+            "type": "image_url",
+            "image_url": {"url": f"data:{media_type};base64,{image_b64}"},
+        },
+    ]
+    return _openai_client(model, [{"role": "user", "content": content}], deadline)
+
+
+class OpenAIAdapter:
+    """Adapter OpenAI multi-mode (post-correction texte/image, transcription VLM)."""
+
+    def __init__(
+        self,
+        *,
+        label: str,
+        model: str = _DEFAULT_MODEL,
+        role: str = "text_only",
+        prompt: str | None = None,
+    ) -> None:
+        self._label = validate_llm_label(label, "OpenAIAdapter")
+        self._model = model
+        self._role: PipelineMode = validate_role(role, "OpenAIAdapter", _SUPPORTED)
+        self._prompt = (
+            prompt if prompt is not None else default_prompt_for_role(self._role)
+        )
+
+    @property
+    def name(self) -> str:
+        return f"openai:{self._label}"
+
+    @property
+    def version(self) -> str:
+        return _VERSION
+
+    @property
+    def input_types(self) -> frozenset[ArtifactType]:
+        return llm_input_types(self._role)
+
+    @property
+    def output_types(self) -> frozenset[ArtifactType]:
+        return frozenset({llm_output_type(self._role)})
+
+    def execute(
+        self,
+        inputs: dict[ArtifactType, Artifact],
+        params: dict[str, ParamValue],
+        context: RunContext,
+        control: RunControl,
+    ) -> StepOutput:
+        def text_invoke(prompt: str) -> LLMCompletion:
+            return _invoke_openai(
+                model=self._model, prompt=prompt, deadline=context.deadline
+            )
+
+        def vision_invoke(
+            prompt: str, media_type: str, image_b64: str
+        ) -> LLMCompletion:
+            return _invoke_openai_vision(
+                model=self._model,
+                prompt=prompt,
+                media_type=media_type,
+                image_b64=image_b64,
+                deadline=context.deadline,
+            )
+
+        return run_llm_step(
+            role=self._role,
+            label=self._label,
+            name=self.name,
+            prompt=self._prompt,
+            inputs=inputs,
+            context=context,
+            control=control,
+            text_invoke=text_invoke,
+            vision_invoke=vision_invoke,
+        )
+
+
+__all__ = ["OpenAIAdapter"]
diff --git a/cinoc/adapters/ner/__init__.py b/cinoc/adapters/ner/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb17871c626cee065771c83e754a5a3adec5ee69
--- /dev/null
+++ b/cinoc/adapters/ner/__init__.py
@@ -0,0 +1 @@
+"""Adapters NER : extraction d'entités nommées (couche 5)."""
diff --git a/cinoc/adapters/ner/spacy_extractor.py b/cinoc/adapters/ner/spacy_extractor.py
new file mode 100644
index 0000000000000000000000000000000000000000..2de0f121c94d09b2b45c5100e7d88aef82781972
--- /dev/null
+++ b/cinoc/adapters/ner/spacy_extractor.py
@@ -0,0 +1,204 @@
+"""``SpacyNerExtractor`` — extraction d'entités nommées via spaCy (couche 5).
+
+Brique de pipeline ``RAW_TEXT|CORRECTED_TEXT → ENTITIES`` (la NER est une étape
+explicite, CLAUDE.md §3). Implémente le ``Module`` Protocol **directement**. Le
+SDK ``spacy`` + le **modèle** sont un extra optionnel (``cinoc[ner]`` + ``python
+-m spacy download <modèle>``), importés paresseusement.
+
+**Anti-silence (réparation R14 amont, bug du modèle source).** Si spaCy ou le
+modèle manque, l'adapter **lève** ``AdapterStepError`` avec le message
+d'installation — il ne renvoie **jamais** ``[]`` (le défaut de la source : un
+benchmark qui « réussit » avec un rappel 0 sans message). L'orchestrateur isole
+alors ce (concurrent × document) ; le document reste simplement non scoré.
+
+L'artefact ``ENTITIES`` embarque **le texte d'entrée** (``{"text", "entities"}``)
+— c'est lui qui rend la reprojection R14 auto-suffisante côté évaluation.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+from cinoc.adapters._workspace import workspace_artifact_path
+from cinoc.domain.artifacts import Artifact, ArtifactType, compute_content_hash
+from cinoc.domain.errors import AdapterStepError
+from cinoc.pipeline.protocols import ParamValue
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import RunContext, StepOutput
+
+logger = logging.getLogger(__name__)
+
+_VERSION = "1.0"
+
+#: Normalisation des labels spaCy vers les conventions courtes HIPE/CoNLL.
+_DEFAULT_LABEL_MAPPING: dict[str, str] = {
+    "PERSON": "PER",
+    "PER": "PER",
+    "LOC": "LOC",
+    "GPE": "LOC",
+    "ORG": "ORG",
+    "DATE": "DATE",
+    "TIME": "DATE",
+    "MISC": "MISC",
+}
+
+#: Texte d'entrée accepté : sortie OCR brute **ou** corrigée par un LLM.
+_INPUT_TYPES = frozenset({ArtifactType.RAW_TEXT, ArtifactType.CORRECTED_TEXT})
+
+
+class SpacyNerExtractor:
+    """NER spaCy : ``RAW_TEXT|CORRECTED_TEXT`` → ``ENTITIES`` (fail-closed)."""
+
+    def __init__(
+        self,
+        *,
+        label: str,
+        model: str = "fr_core_news_sm",
+        loader: Any | None = None,
+    ) -> None:
+        if not label or not all(c.isalnum() or c in "_-" for c in label):
+            raise AdapterStepError(f"ner : label invalide {label!r}.")
+        self._label = label
+        self._model = model
+        #: Injectable en test : ``(model_name) -> nlp`` ; défaut = ``spacy.load``.
+        self._loader = loader
+        self._nlp: Any | None = None
+        self._model_version: str | None = None
+
+    @property
+    def name(self) -> str:
+        return f"ner:{self._label}"
+
+    @property
+    def version(self) -> str:
+        return _VERSION
+
+    @property
+    def input_types(self) -> frozenset[ArtifactType]:
+        return _INPUT_TYPES
+
+    @property
+    def output_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.ENTITIES})
+
+    def system_binaries(self) -> dict[str, str]:
+        """Versions spaCy + modèle **si déjà chargés** (reproductibilité).
+
+        Best-effort sans effet de bord : ne déclenche aucun chargement — renvoie
+        ``{}`` tant que le modèle n'a pas tourné. Fusionné au ``RunManifest`` par
+        l'orchestrateur (duck-typing, comme le binaire tesseract).
+        """
+        if self._nlp is None:
+            return {}
+        out: dict[str, str] = {}
+        if self._model_version is not None:
+            out[f"spacy_model:{self._model}"] = self._model_version
+        try:
+            import spacy  # type: ignore[import-not-found]
+
+            out["spacy"] = str(spacy.__version__)
+        except ImportError:
+            pass
+        return out
+
+    def _load(self) -> Any:
+        """Charge le modèle (idempotent). Fail-closed : lève si SDK/modèle absent."""
+        if self._nlp is not None:
+            return self._nlp
+        if self._loader is not None:
+            self._nlp = self._loader(self._model)
+            self._model_version = self._probe_model_version(self._nlp)
+            return self._nlp
+        try:
+            import spacy  # type: ignore[import-not-found]
+        except ImportError as exc:
+            raise AdapterStepError(
+                "ner : spaCy non installé — `pip install 'cinoc[ner]'`."
+            ) from exc
+        try:
+            self._nlp = spacy.load(self._model)
+        except OSError as exc:
+            raise AdapterStepError(
+                f"ner : modèle spaCy {self._model!r} introuvable — "
+                f"`python -m spacy download {self._model}`."
+            ) from exc
+        self._model_version = self._probe_model_version(self._nlp)
+        return self._nlp
+
+    @staticmethod
+    def _probe_model_version(nlp: Any) -> str | None:
+        meta = getattr(nlp, "meta", None)
+        if isinstance(meta, dict):
+            version = meta.get("version")
+            return str(version) if version is not None else None
+        return None
+
+    def _extract(self, text: str) -> list[dict[str, object]]:
+        nlp = self._load()
+        doc = nlp(text)
+        entities: list[dict[str, object]] = []
+        for ent in doc.ents:
+            label = _DEFAULT_LABEL_MAPPING.get(ent.label_, ent.label_)
+            entities.append(
+                {
+                    "label": label,
+                    "start": int(ent.start_char),
+                    "end": int(ent.end_char),
+                    "text": ent.text,
+                }
+            )
+        return entities
+
+    def execute(
+        self,
+        inputs: dict[ArtifactType, Artifact],
+        params: dict[str, ParamValue],
+        context: RunContext,
+        control: RunControl,
+    ) -> StepOutput:
+        control.raise_if_cancelled()
+        source = inputs.get(ArtifactType.CORRECTED_TEXT) or inputs.get(
+            ArtifactType.RAW_TEXT
+        )
+        if source is None or source.uri is None:
+            raise AdapterStepError(
+                f"{self.name} : artefact texte (RAW_TEXT/CORRECTED_TEXT) manquant."
+            )
+        if context.workspace_uri is None:
+            raise AdapterStepError(f"{self.name} : workspace requis.")
+        text = _read_text(source.uri, self.name)
+        entities = self._extract(text)
+        payload = json.dumps(
+            {"text": text, "entities": entities}, ensure_ascii=False
+        ).encode("utf-8")
+        out_path = workspace_artifact_path(
+            context.workspace_uri, context.document_id, self._label, "entities.json"
+        )
+        out_path.write_bytes(payload)
+        return StepOutput(
+            artifacts={
+                ArtifactType.ENTITIES: Artifact(
+                    id=f"{context.document_id}:{self.name}:entities",
+                    document_id=context.document_id,
+                    type=ArtifactType.ENTITIES,
+                    uri=str(out_path),
+                    content_hash=compute_content_hash(payload),
+                )
+            }
+        )
+
+
+def _read_text(uri: str, name: str) -> str:
+    from pathlib import Path
+
+    try:
+        return Path(uri).read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError) as exc:
+        raise AdapterStepError(
+            f"{name} : texte d'entrée illisible {uri!r} : {exc}"
+        ) from exc
+
+
+__all__ = ["SpacyNerExtractor"]
diff --git a/cinoc/adapters/ocr/__init__.py b/cinoc/adapters/ocr/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e8718f622c2ee289b283497508f5e3b95118332a
--- /dev/null
+++ b/cinoc/adapters/ocr/__init__.py
@@ -0,0 +1,8 @@
+"""Modules OCR/HTR (couche 5)."""
+
+from __future__ import annotations
+
+from cinoc.adapters.ocr.precomputed import PrecomputedTextAdapter
+from cinoc.adapters.ocr.tesseract import TesseractAdapter
+
+__all__ = ["PrecomputedTextAdapter", "TesseractAdapter"]
diff --git a/cinoc/adapters/ocr/_base.py b/cinoc/adapters/ocr/_base.py
new file mode 100644
index 0000000000000000000000000000000000000000..0442ea7a5534a49e6e8f7758a4006fe4dfb2d19c
--- /dev/null
+++ b/cinoc/adapters/ocr/_base.py
@@ -0,0 +1,64 @@
+"""Squelette commun des adapters OCR « image → un seul RAW_TEXT » (couche 5).
+
+Le même ``execute()`` était recopié dans chaque adapter OCR mono-sortie : sonde
+d'annulation, garde IMAGE, garde workspace, écriture du ``.txt`` dans le workspace,
+construction de l'artefact ``RAW_TEXT`` (id ``{doc}:{name}:raw_text`` + hash du
+texte). On le mutualise ici (miroir de ``llm/_base``) ; le **détail moteur** (params,
+clé API, deadline) reste dans chaque adapter, porté par la closure ``recognize``.
+
+N'est PAS pour les adapters multi-sorties (``tesseract`` : RAW_TEXT + CONFIDENCES
++ ALTO optionnel) — eux gardent leur ``execute()`` propre. Contrat de l'artefact
+``RAW_TEXT`` figé par ``tests/adapters/test_ocr_artifact_contract_anchor``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+
+from cinoc.adapters._workspace import workspace_artifact_path
+from cinoc.domain.artifacts import Artifact, ArtifactType, compute_content_hash
+from cinoc.domain.errors import AdapterStepError
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import RunContext, StepOutput
+
+
+def run_image_to_text(
+    *,
+    name: str,
+    label: str,
+    inputs: Mapping[ArtifactType, Artifact],
+    context: RunContext,
+    control: RunControl,
+    recognize: Callable[[str], str],
+) -> StepOutput:
+    """Exécute un OCR image → ``RAW_TEXT`` unique, gardes + persistance mutualisées.
+
+    ``recognize(image_uri) -> texte`` porte la reconnaissance réelle (et ses gardes
+    propres : clé API, modèle…). Ordre identique à l'ancien code par adapter :
+    annulation → IMAGE → workspace → ``recognize`` → écriture ``.txt`` → artefact.
+    """
+    control.raise_if_cancelled()
+    image = inputs.get(ArtifactType.IMAGE)
+    if image is None or image.uri is None:
+        raise AdapterStepError(f"{name} : artefact IMAGE manquant ou sans URI.")
+    if context.workspace_uri is None:
+        raise AdapterStepError(f"{name} : workspace requis.")
+    text = recognize(image.uri)
+    output_path = workspace_artifact_path(
+        context.workspace_uri, context.document_id, label, "txt"
+    )
+    output_path.write_text(text, encoding="utf-8")
+    return StepOutput(
+        artifacts={
+            ArtifactType.RAW_TEXT: Artifact(
+                id=f"{context.document_id}:{name}:raw_text",
+                document_id=context.document_id,
+                type=ArtifactType.RAW_TEXT,
+                uri=str(output_path),
+                content_hash=compute_content_hash(text.encode("utf-8")),
+            )
+        }
+    )
+
+
+__all__ = ["run_image_to_text"]
diff --git a/cinoc/adapters/ocr/azure_di.py b/cinoc/adapters/ocr/azure_di.py
new file mode 100644
index 0000000000000000000000000000000000000000..2ee938de46b40c8c2ded329af959ce3942402407
--- /dev/null
+++ b/cinoc/adapters/ocr/azure_di.py
@@ -0,0 +1,223 @@
+"""``AzureDocIntelAdapter`` — OCR cloud (Azure AI Document Intelligence, modèle Read).
+
+Moteur cloud **first-party**. API **REST** (``httpx``) plutôt que le SDK
+``azure-ai-documentintelligence`` (lourd, auth credential) : transport léger,
+**testable par cassette HTTP**. Auth par **clé d'abonnement**
+(``AZURE_DOC_INTEL_KEY``) + endpoint de la ressource (``AZURE_DOC_INTEL_ENDPOINT``).
+Implémente le ``Module`` Protocol **directement** ; ``httpx`` est l'extra
+``cinoc[azure]``, importé **paresseusement** (mockable, CI sans clé ni réseau).
+
+Flux **asynchrone** propre à Azure DI (fidèlement modélisé) : ``POST …:analyze``
+renvoie ``202`` + un en-tête ``Operation-Location`` ; on **sonde** cette URL
+(GET) jusqu'à ``status == "succeeded"`` (ou ``failed``/délai). Sortie :
+``analyzeResult.content`` du modèle ``prebuilt-read`` — le texte complet d'une page.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from base64 import b64encode
+from collections.abc import Callable
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from cinoc.adapters.ocr._base import run_image_to_text
+from cinoc.domain.artifacts import Artifact, ArtifactType
+from cinoc.domain.deadline import Deadline
+from cinoc.domain.errors import AdapterStepError
+from cinoc.pipeline.protocols import ParamValue
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import RunContext, StepOutput
+
+if TYPE_CHECKING:  # annotations seules — pas d'import httpx au chargement du module
+    import httpx
+
+_VERSION = "1.0"
+_MODEL = "prebuilt-read"
+_API_VERSION = "2024-11-30"
+_ANALYZE_PATH = f"/documentintelligence/documentModels/{_MODEL}:analyze"
+_KEY_HEADER = "Ocp-Apim-Subscription-Key"
+_ENDPOINT_ENV = "AZURE_DOC_INTEL_ENDPOINT"
+_KEY_ENV = "AZURE_DOC_INTEL_KEY"
+#: Borne dure du *polling* (en plus de la ``Deadline``) — évite la boucle infinie
+#: si le service reste indéfiniment ``running`` sous une deadline infinie.
+_MAX_POLLS = 60
+
+
+def _extract_text(data: object) -> str:
+    """Texte complet de ``analyzeResult.content`` ; page vide → ``""``."""
+    if not isinstance(data, dict):
+        raise AdapterStepError("azure_di : réponse JSON inattendue (objet).")
+    result = data.get("analyzeResult")
+    if not isinstance(result, dict):
+        raise AdapterStepError("azure_di : 'analyzeResult' absent de la réponse.")
+    content = result.get("content")
+    return str(content).strip() if content else ""
+
+
+def _invoke_azure_di(
+    *,
+    endpoint: str,
+    image_path: str,
+    deadline: Deadline,
+    key: str,
+    transport: httpx.BaseTransport | None = None,
+    poll_interval: float = 1.0,
+    sleep: Callable[[float], None] = time.sleep,
+) -> str:
+    """Analyse l'image (POST → sonde l'``Operation-Location``) et renvoie le texte.
+
+    ``endpoint`` vient de la **configuration opérateur** (env), pas de
+    l'utilisateur → endpoint de confiance, pas de durcissement anti-SSRF (≠
+    importeurs de corpus). La clé est en **en-tête** (jamais journalisée : les
+    messages d'erreur ne portent que le statut). ``transport``/``sleep`` injectés
+    → cassette **et** sonde déterministes en test (aucune attente réelle).
+    """
+    try:
+        import httpx
+    except ImportError as exc:
+        raise AdapterStepError(
+            "azure_di : httpx non installé (pip install 'cinoc[azure]')."
+        ) from exc
+    content = b64encode(Path(image_path).read_bytes()).decode("ascii")
+    analyze_url = endpoint.rstrip("/") + _ANALYZE_PATH
+    with httpx.Client(
+        timeout=deadline.as_sdk_timeout(), transport=transport
+    ) as client:
+        operation_url = _submit_analysis(
+            client, analyze_url=analyze_url, key=key, content=content
+        )
+        return _poll_result(
+            client,
+            operation_url=operation_url,
+            key=key,
+            deadline=deadline,
+            poll_interval=poll_interval,
+            sleep=sleep,
+        )
+
+
+def _submit_analysis(
+    client: httpx.Client, *, analyze_url: str, key: str, content: str
+) -> str:
+    """POST l'analyse ; renvoie l'URL ``Operation-Location`` à sonder."""
+    import httpx
+
+    headers = {_KEY_HEADER: key, "Content-Type": "application/json"}
+    try:
+        response = client.post(
+            analyze_url,
+            params={"api-version": _API_VERSION},
+            headers=headers,
+            json={"base64Source": content},
+        )
+        response.raise_for_status()
+    except httpx.HTTPStatusError as exc:
+        raise AdapterStepError(
+            f"azure_di : statut HTTP {exc.response.status_code} (soumission)."
+        ) from exc
+    except httpx.HTTPError as exc:
+        raise AdapterStepError(
+            f"azure_di : échec de transport (soumission) : {type(exc).__name__}."
+        ) from exc
+    operation_url = response.headers.get("operation-location")
+    if not operation_url:
+        raise AdapterStepError("azure_di : réponse sans en-tête Operation-Location.")
+    return str(operation_url)
+
+
+def _poll_result(
+    client: httpx.Client,
+    *,
+    operation_url: str,
+    key: str,
+    deadline: Deadline,
+    poll_interval: float,
+    sleep: Callable[[float], None],
+) -> str:
+    """Sonde l'``Operation-Location`` jusqu'à un état terminal (ou délai)."""
+    import httpx
+
+    for _ in range(_MAX_POLLS):
+        try:
+            response = client.get(operation_url, headers={_KEY_HEADER: key})
+            response.raise_for_status()
+            data = response.json()
+        except httpx.HTTPStatusError as exc:
+            raise AdapterStepError(
+                f"azure_di : statut HTTP {exc.response.status_code} (sonde)."
+            ) from exc
+        except httpx.HTTPError as exc:
+            raise AdapterStepError(
+                f"azure_di : échec de transport (sonde) : {type(exc).__name__}."
+            ) from exc
+        status = (
+            str(data.get("status", "")).lower() if isinstance(data, dict) else ""
+        )
+        if status == "succeeded":
+            return _extract_text(data)
+        if status == "failed":
+            raise AdapterStepError("azure_di : analyse échouée (status 'failed').")
+        if deadline.is_expired():
+            break
+        sleep(poll_interval)
+    raise AdapterStepError("azure_di : analyse non terminée (délai de sonde dépassé).")
+
+
+class AzureDocIntelAdapter:
+    """OCR cloud Azure DI : ``IMAGE`` → ``RAW_TEXT`` (texte ``prebuilt-read``)."""
+
+    def __init__(self, *, label: str) -> None:
+        if not label or not all(c.isalnum() or c in "_-" for c in label):
+            raise AdapterStepError(f"azure_di : label invalide {label!r}.")
+        self._label = label
+
+    @property
+    def name(self) -> str:
+        return f"azure_di:{self._label}"
+
+    @property
+    def version(self) -> str:
+        return _VERSION
+
+    @property
+    def input_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.IMAGE})
+
+    @property
+    def output_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.RAW_TEXT})
+
+    def execute(
+        self,
+        inputs: dict[ArtifactType, Artifact],
+        params: dict[str, ParamValue],
+        context: RunContext,
+        control: RunControl,
+    ) -> StepOutput:
+        def recognize(image_uri: str) -> str:
+            endpoint = os.environ.get(_ENDPOINT_ENV)
+            key = os.environ.get(_KEY_ENV)
+            if not endpoint:
+                raise AdapterStepError(f"{self.name} : {_ENDPOINT_ENV} manquant.")
+            if not key:
+                raise AdapterStepError(f"{self.name} : {_KEY_ENV} manquante.")
+            return _invoke_azure_di(
+                endpoint=endpoint,
+                image_path=image_uri,
+                deadline=context.deadline,
+                key=key,
+            )
+
+        return run_image_to_text(
+            name=self.name,
+            label=self._label,
+            inputs=inputs,
+            context=context,
+            control=control,
+            recognize=recognize,
+        )
+
+
+__all__ = ["AzureDocIntelAdapter"]
diff --git a/cinoc/adapters/ocr/calamari.py b/cinoc/adapters/ocr/calamari.py
new file mode 100644
index 0000000000000000000000000000000000000000..598e00c68b1a5bc333539e59ba7788ff91dda2fc
--- /dev/null
+++ b/cinoc/adapters/ocr/calamari.py
@@ -0,0 +1,106 @@
+"""``CalamariAdapter`` — moteur OCR réel (calamari-ocr, reconnaissance de lignes).
+
+Local et sans clé. Implémente le ``Module`` Protocol **directement** — même
+contrat que le socle, livré in-tree (pas de discrimination socle/plugin). La lib
+``calamari_ocr`` est un **extra optionnel** (``cinoc[calamari]``), importée
+**paresseusement** dans ``_invoke_calamari`` : importer ce module ne requiert rien ;
+seule l'exécution exige la lib + un **modèle** (``model`` = checkpoint, obligatoire).
+
+Calamari reconnaît une **ligne** par image : utilisé seul sur une page, il traite
+l'image comme une ligne unique ; son usage naturel est en **recognizer par
+région** dans le pipeline de segmentation (fan-out par bloc). Sortie : ``RAW_TEXT``.
+
+**Non déployé au Space** (dép lourde TensorFlow, free-tier) : listé « indisponible »
+sans l'extra, comme Kraken/PERO.
+"""
+
+from __future__ import annotations
+
+from cinoc.adapters.ocr._base import run_image_to_text
+from cinoc.domain.artifacts import Artifact, ArtifactType
+from cinoc.domain.errors import AdapterStepError
+from cinoc.pipeline.protocols import ParamValue
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import RunContext, StepOutput
+
+_VERSION = "1.0"
+
+
+def _invoke_calamari(  # pragma: no cover -- lib + modèle requis (cf. 'live')
+    *, image_path: str, model_path: str
+) -> str:
+    """Reconnaissance Calamari de l'image (ligne) → texte prédit."""
+    try:
+        import numpy as np  # type: ignore[import-not-found]
+        from calamari_ocr.ocr.predict.predictor import (  # type: ignore[import-not-found]
+            Predictor,
+            PredictorParams,
+        )
+        from PIL import Image  # type: ignore[import-not-found]
+    except ImportError as exc:
+        raise AdapterStepError(
+            "calamari : lib non installée (pip install 'cinoc[calamari]')."
+        ) from exc
+    try:
+        predictor = Predictor.from_checkpoint(
+            params=PredictorParams(), checkpoint=model_path
+        )
+    except (OSError, ValueError, RuntimeError) as exc:  # loader calamari
+        raise AdapterStepError(
+            f"calamari : modèle illisible {model_path!r} : {exc}"
+        ) from exc
+    image = np.array(Image.open(image_path).convert("L"))
+    predictions = predictor.predict_raw([image])
+    texts = [str(prediction.sentence) for prediction in predictions]
+    return " ".join(texts).strip()
+
+
+class CalamariAdapter:
+    """OCR Calamari : ``IMAGE`` → ``RAW_TEXT`` (texte de la ligne reconnue)."""
+
+    def __init__(self, *, label: str, model: str) -> None:
+        if not label or not all(c.isalnum() or c in "_-" for c in label):
+            raise AdapterStepError(f"calamari : label invalide {label!r}.")
+        if not model:
+            raise AdapterStepError(
+                "calamari : paramètre 'model' (checkpoint) requis."
+            )
+        self._label = label
+        self._model = model
+
+    @property
+    def name(self) -> str:
+        return f"calamari:{self._label}"
+
+    @property
+    def version(self) -> str:
+        return _VERSION
+
+    @property
+    def input_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.IMAGE})
+
+    @property
+    def output_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.RAW_TEXT})
+
+    def execute(
+        self,
+        inputs: dict[ArtifactType, Artifact],
+        params: dict[str, ParamValue],
+        context: RunContext,
+        control: RunControl,
+    ) -> StepOutput:
+        return run_image_to_text(
+            name=self.name,
+            label=self._label,
+            inputs=inputs,
+            context=context,
+            control=control,
+            recognize=lambda image_uri: _invoke_calamari(
+                image_path=image_uri, model_path=self._model
+            ),
+        )
+
+
+__all__ = ["CalamariAdapter"]
diff --git a/cinoc/adapters/ocr/google_vision.py b/cinoc/adapters/ocr/google_vision.py
new file mode 100644
index 0000000000000000000000000000000000000000..ebf00f3221893f3bedca71ec50b96cb6455847f3
--- /dev/null
+++ b/cinoc/adapters/ocr/google_vision.py
@@ -0,0 +1,157 @@
+"""``GoogleVisionAdapter`` — OCR cloud (Google Cloud Vision REST), facturé à l'image.
+
+Moteur cloud **first-party**. On vise l'**API REST** (``httpx``) plutôt que le SDK
+``google-cloud-vision`` (gRPC + auth ADC service-account, lourd et difficile à
+rejouer) : transport léger, **testable par cassette HTTP**, auth par **clé d'API**
+(``GOOGLE_VISION_API_KEY``). Implémente le ``Module`` Protocol **directement** ;
+``httpx`` est l'extra ``cinoc[google]``, importé **paresseusement** dans
+``_invoke_google_vision`` (mockable, CI sans clé ni réseau).
+
+Sortie : ``fullTextAnnotation.text`` de ``DOCUMENT_TEXT_DETECTION`` — le texte
+dense d'une page (le bon mode pour des documents, ≠ ``TEXT_DETECTION`` épars).
+"""
+
+from __future__ import annotations
+
+import os
+from base64 import b64encode
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from cinoc.adapters.ocr._base import run_image_to_text
+from cinoc.domain.artifacts import Artifact, ArtifactType
+from cinoc.domain.deadline import Deadline
+from cinoc.domain.errors import AdapterStepError
+from cinoc.pipeline.protocols import ParamValue
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import RunContext, StepOutput
+
+if TYPE_CHECKING:  # annotations seules — pas d'import httpx au chargement du module
+    import httpx
+
+_VERSION = "1.0"
+_ENDPOINT = "https://vision.googleapis.com/v1/images:annotate"
+_API_KEY_ENV = "GOOGLE_VISION_API_KEY"
+_FEATURE = "DOCUMENT_TEXT_DETECTION"
+
+
+def _extract_text(payload: object) -> str:
+    """Texte de la 1ʳᵉ réponse Vision ; erreur par image → ``AdapterStepError``.
+
+    Forme : ``{"responses": [{"fullTextAnnotation": {"text": …}}]}`` (ou
+    ``{"error": {"message": …}}`` pour un échec par image). Aucun texte détecté
+    (page blanche) → ``""`` — un résultat valide, pas une erreur.
+    """
+    if not isinstance(payload, dict):
+        raise AdapterStepError("google_vision : réponse JSON inattendue (objet).")
+    responses = payload.get("responses")
+    if not isinstance(responses, list) or not responses:
+        raise AdapterStepError("google_vision : réponse sans 'responses'.")
+    first = responses[0]
+    if not isinstance(first, dict):
+        raise AdapterStepError("google_vision : 'responses[0]' inattendu.")
+    error = first.get("error")
+    if isinstance(error, dict) and error:
+        message = error.get("message", "erreur sans message")
+        raise AdapterStepError(f"google_vision : erreur API : {message}")
+    annotation = first.get("fullTextAnnotation")
+    if isinstance(annotation, dict):
+        text = annotation.get("text")
+        return str(text).strip() if text else ""
+    return ""
+
+
+def _invoke_google_vision(
+    *,
+    image_path: str,
+    deadline: Deadline,
+    api_key: str,
+    transport: httpx.BaseTransport | None = None,
+) -> str:
+    """POST l'image à Vision et renvoie le texte. ``transport`` injecté → cassette.
+
+    Endpoint **fixe et de confiance** (Google) : pas de durcissement anti-SSRF (≠
+    importeurs de corpus, dont l'URL vient de l'utilisateur). La clé d'API est en
+    *query string* (jamais journalisée : les messages d'erreur ne portent que le
+    statut). ``httpx`` paresseux : importer ce module n'exige pas l'extra.
+    """
+    try:
+        import httpx
+    except ImportError as exc:
+        raise AdapterStepError(
+            "google_vision : httpx non installé (pip install 'cinoc[google]')."
+        ) from exc
+    content = b64encode(Path(image_path).read_bytes()).decode("ascii")
+    body = {
+        "requests": [
+            {"image": {"content": content}, "features": [{"type": _FEATURE}]}
+        ]
+    }
+    try:
+        with httpx.Client(
+            timeout=deadline.as_sdk_timeout(), transport=transport
+        ) as client:
+            response = client.post(_ENDPOINT, params={"key": api_key}, json=body)
+            response.raise_for_status()
+            data = response.json()
+    except httpx.HTTPStatusError as exc:
+        raise AdapterStepError(
+            f"google_vision : statut HTTP {exc.response.status_code}."
+        ) from exc
+    except httpx.HTTPError as exc:
+        raise AdapterStepError(
+            f"google_vision : échec de transport : {type(exc).__name__}."
+        ) from exc
+    return _extract_text(data)
+
+
+class GoogleVisionAdapter:
+    """OCR cloud Google Vision : ``IMAGE`` → ``RAW_TEXT`` (texte dense de la page)."""
+
+    def __init__(self, *, label: str) -> None:
+        if not label or not all(c.isalnum() or c in "_-" for c in label):
+            raise AdapterStepError(f"google_vision : label invalide {label!r}.")
+        self._label = label
+
+    @property
+    def name(self) -> str:
+        return f"google_vision:{self._label}"
+
+    @property
+    def version(self) -> str:
+        return _VERSION
+
+    @property
+    def input_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.IMAGE})
+
+    @property
+    def output_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.RAW_TEXT})
+
+    def execute(
+        self,
+        inputs: dict[ArtifactType, Artifact],
+        params: dict[str, ParamValue],
+        context: RunContext,
+        control: RunControl,
+    ) -> StepOutput:
+        def recognize(image_uri: str) -> str:
+            api_key = os.environ.get(_API_KEY_ENV)
+            if not api_key:
+                raise AdapterStepError(f"{self.name} : {_API_KEY_ENV} manquante.")
+            return _invoke_google_vision(
+                image_path=image_uri, deadline=context.deadline, api_key=api_key
+            )
+
+        return run_image_to_text(
+            name=self.name,
+            label=self._label,
+            inputs=inputs,
+            context=context,
+            control=control,
+            recognize=recognize,
+        )
+
+
+__all__ = ["GoogleVisionAdapter"]
diff --git a/cinoc/adapters/ocr/kraken.py b/cinoc/adapters/ocr/kraken.py
new file mode 100644
index 0000000000000000000000000000000000000000..ffdad841838e63d961b4dd74280e670ccd024cf1
--- /dev/null
+++ b/cinoc/adapters/ocr/kraken.py
@@ -0,0 +1,166 @@
+"""``KrakenAdapter`` — moteur HTR réel (kraken, le moteur d'eScriptorium).
+
+Implémente le ``Module`` Protocol directement. Couvre le **manuscrit** (HTR),
+là où tesseract couvre l'imprimé. Le SDK ``kraken`` est un **extra optionnel**
+(``cinoc[kraken]``), importé paresseusement dans ``_invoke_kraken`` — importer
+ce module ne requiert rien ; seule l'exécution exige SDK + **modèle** (.mlmodel,
+paramètre ``model`` obligatoire : pas de modèle par défaut embarqué).
+
+Sorties : ``RAW_TEXT`` (lignes reconnues, ordre de lecture kraken) +
+``CONFIDENCES`` (un jeton par mot, confiance = moyenne des confiances de
+caractères du mot — best-effort, sidecar vide en dégradé).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+
+from cinoc.adapters._workspace import workspace_artifact_path
+from cinoc.domain.artifacts import Artifact, ArtifactType, compute_content_hash
+from cinoc.domain.confidence import ConfidenceToken
+from cinoc.domain.errors import AdapterStepError
+from cinoc.pipeline.protocols import ParamValue
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import RunContext, StepOutput
+
+logger = logging.getLogger(__name__)
+
+_VERSION = "1.0"
+
+
+def tokens_from_lines(
+    lines: list[tuple[str, list[float]]],
+) -> list[ConfidenceToken]:
+    """Jetons mot+confiance depuis (texte de ligne, confiances par caractère).
+
+    La confiance d'un mot = moyenne des confiances de ses caractères (bornée
+    [0,1]) ; un mot sans couverture de confiance est ignoré.
+    """
+    tokens: list[ConfidenceToken] = []
+    for text, confidences in lines:
+        cursor = 0
+        for word in text.split():
+            start = text.find(word, cursor)
+            if start < 0:
+                continue
+            cursor = start + len(word)
+            window = confidences[start : start + len(word)]
+            if not window:
+                continue
+            value = max(0.0, min(sum(window) / len(window), 1.0))
+            tokens.append(ConfidenceToken(text=word, confidence=value))
+    return tokens
+
+
+def _invoke_kraken(  # pragma: no cover -- SDK + modèle requis (cf. 'live')
+    *, image_path: str, model_path: str
+) -> list[tuple[str, list[float]]]:
+    """Segmentation + reconnaissance kraken → (texte, confiances/char) par ligne."""
+    try:
+        from kraken import (  # type: ignore[import-not-found]
+            binarization,
+            pageseg,
+            rpred,
+        )
+        from kraken.lib import models  # type: ignore[import-not-found]
+        from PIL import Image  # type: ignore[import-not-found]
+    except ImportError as exc:
+        raise AdapterStepError(
+            "kraken : SDK non installé (pip install 'cinoc[kraken]')."
+        ) from exc
+    try:
+        model = models.load_any(model_path)
+    except (OSError, ValueError, RuntimeError) as exc:  # loader kraken
+        raise AdapterStepError(
+            f"kraken : modèle illisible {model_path!r} : {exc}"
+        ) from exc
+    image = Image.open(image_path)
+    binarized = binarization.nlbin(image)
+    segmentation = pageseg.segment(binarized)
+    out: list[tuple[str, list[float]]] = []
+    for record in rpred.rpred(model, binarized, segmentation):
+        out.append((str(record), [float(c) for c in record.confidences]))
+    return out
+
+
+class KrakenAdapter:
+    """HTR kraken : ``IMAGE`` → ``RAW_TEXT`` + ``CONFIDENCES``."""
+
+    def __init__(self, *, label: str, model: str) -> None:
+        if not label or not all(c.isalnum() or c in "_-" for c in label):
+            raise AdapterStepError(f"kraken : label invalide {label!r}.")
+        if not model:
+            raise AdapterStepError(
+                "kraken : paramètre 'model' (chemin .mlmodel) requis."
+            )
+        self._label = label
+        self._model = model
+
+    @property
+    def name(self) -> str:
+        return f"kraken:{self._label}"
+
+    @property
+    def version(self) -> str:
+        return _VERSION
+
+    @property
+    def input_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.IMAGE})
+
+    @property
+    def output_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.RAW_TEXT, ArtifactType.CONFIDENCES})
+
+    def execute(
+        self,
+        inputs: dict[ArtifactType, Artifact],
+        params: dict[str, ParamValue],
+        context: RunContext,
+        control: RunControl,
+    ) -> StepOutput:
+        control.raise_if_cancelled()
+        image = inputs.get(ArtifactType.IMAGE)
+        if image is None or image.uri is None:
+            raise AdapterStepError(
+                f"{self.name} : artefact IMAGE manquant ou sans URI."
+            )
+        if context.workspace_uri is None:
+            raise AdapterStepError(f"{self.name} : workspace requis.")
+        lines = _invoke_kraken(image_path=image.uri, model_path=self._model)
+        text = "\n".join(line for line, _ in lines)
+        tokens = tokens_from_lines(lines)
+        text_path = workspace_artifact_path(
+            context.workspace_uri, context.document_id, self._label, "txt"
+        )
+        text_path.write_text(text, encoding="utf-8")
+        sidecar = json.dumps(
+            [token.model_dump() for token in tokens], ensure_ascii=False
+        ).encode("utf-8")
+        sidecar_path = workspace_artifact_path(
+            context.workspace_uri, context.document_id, self._label,
+            "confidences.json",
+        )
+        sidecar_path.write_bytes(sidecar)
+        return StepOutput(
+            artifacts={
+                ArtifactType.RAW_TEXT: Artifact(
+                    id=f"{context.document_id}:{self.name}:raw_text",
+                    document_id=context.document_id,
+                    type=ArtifactType.RAW_TEXT,
+                    uri=str(text_path),
+                    content_hash=compute_content_hash(text.encode("utf-8")),
+                ),
+                ArtifactType.CONFIDENCES: Artifact(
+                    id=f"{context.document_id}:{self.name}:confidences",
+                    document_id=context.document_id,
+                    type=ArtifactType.CONFIDENCES,
+                    uri=str(sidecar_path),
+                    content_hash=compute_content_hash(sidecar),
+                ),
+            }
+        )
+
+
+__all__ = ["KrakenAdapter", "tokens_from_lines"]
diff --git a/cinoc/adapters/ocr/mistral_ocr.py b/cinoc/adapters/ocr/mistral_ocr.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c6ab422873810a3c3a56b5d8c9415a0c7d959b6
--- /dev/null
+++ b/cinoc/adapters/ocr/mistral_ocr.py
@@ -0,0 +1,113 @@
+"""``MistralOCRAdapter`` — OCR cloud (API Mistral OCR), facturé à la page.
+
+Premier moteur **payant à la page** du socle : donne un sens réel à l'axe
+coût du Pareto (économie T10, tarif ``cloud_page_kinds``). Implémente le
+``Module`` Protocol ; SDK ``mistralai`` = extra (``cinoc[mistral]``), importé
+paresseusement dans ``_invoke_mistral_ocr`` (mockable, CI sans clé ni réseau).
+Clé ``MISTRAL_API_KEY``. Sortie : le texte (markdown) des pages, concaténé.
+"""
+
+from __future__ import annotations
+
+from base64 import b64encode
+from pathlib import Path
+
+from cinoc.adapters.ocr._base import run_image_to_text
+from cinoc.domain.artifacts import Artifact, ArtifactType
+from cinoc.domain.deadline import Deadline
+from cinoc.domain.errors import AdapterStepError
+from cinoc.pipeline.protocols import ParamValue
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import RunContext, StepOutput
+
+_VERSION = "1.0"
+_DEFAULT_MODEL = "mistral-ocr-latest"
+_MEDIA = {".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg",
+          ".webp": "image/webp", ".tif": "image/tiff", ".tiff": "image/tiff"}
+
+
+def _invoke_mistral_ocr(  # pragma: no cover -- réseau + clé API (cf. 'live')
+    *, model: str, image_path: str, deadline: Deadline
+) -> str:
+    import os
+
+    api_key = os.environ.get("MISTRAL_API_KEY")
+    if not api_key:
+        raise AdapterStepError("mistral_ocr : MISTRAL_API_KEY manquante.")
+    try:
+        from mistralai import Mistral  # type: ignore[import-not-found]
+    except ImportError as exc:
+        raise AdapterStepError(
+            "mistral_ocr : SDK non installé (pip install 'cinoc[mistral]')."
+        ) from exc
+    path = Path(image_path)
+    media = _MEDIA.get(path.suffix.lower(), "image/png")
+    image_b64 = b64encode(path.read_bytes()).decode("ascii")
+    client_kwargs: dict[str, object] = {"api_key": api_key}
+    timeout = deadline.as_sdk_timeout()
+    if timeout is not None:
+        client_kwargs["timeout_ms"] = int(timeout * 1000)
+    try:
+        client = Mistral(**client_kwargs)  # type: ignore[arg-type]
+        response = client.ocr.process(
+            model=model,
+            document={
+                "type": "image_url",
+                "image_url": f"data:{media};base64,{image_b64}",
+            },
+        )
+    except Exception as exc:  # le SDK lève des erreurs HTTP/SDK variées
+        raise AdapterStepError(
+            f"mistral_ocr a échoué ({model}) : {type(exc).__name__}: {exc}"
+        ) from exc
+    pages = getattr(response, "pages", None) or []
+    return "\n\n".join(
+        str(getattr(page, "markdown", "") or "") for page in pages
+    ).strip()
+
+
+class MistralOCRAdapter:
+    """OCR cloud Mistral : ``IMAGE`` → ``RAW_TEXT`` (markdown des pages)."""
+
+    def __init__(self, *, label: str, model: str = _DEFAULT_MODEL) -> None:
+        if not label or not all(c.isalnum() or c in "_-" for c in label):
+            raise AdapterStepError(f"mistral_ocr : label invalide {label!r}.")
+        self._label = label
+        self._model = model
+
+    @property
+    def name(self) -> str:
+        return f"mistral_ocr:{self._label}"
+
+    @property
+    def version(self) -> str:
+        return _VERSION
+
+    @property
+    def input_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.IMAGE})
+
+    @property
+    def output_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.RAW_TEXT})
+
+    def execute(
+        self,
+        inputs: dict[ArtifactType, Artifact],
+        params: dict[str, ParamValue],
+        context: RunContext,
+        control: RunControl,
+    ) -> StepOutput:
+        return run_image_to_text(
+            name=self.name,
+            label=self._label,
+            inputs=inputs,
+            context=context,
+            control=control,
+            recognize=lambda image_uri: _invoke_mistral_ocr(
+                model=self._model, image_path=image_uri, deadline=context.deadline
+            ),
+        )
+
+
+__all__ = ["MistralOCRAdapter"]
diff --git a/cinoc/adapters/ocr/pero.py b/cinoc/adapters/ocr/pero.py
new file mode 100644
index 0000000000000000000000000000000000000000..38724dd69a015814091783f71c471a7fb022474f
--- /dev/null
+++ b/cinoc/adapters/ocr/pero.py
@@ -0,0 +1,114 @@
+"""``PeroAdapter`` — moteur OCR/HTR réel (pero-ocr).
+
+Local et sans clé : couvre l'imprimé ancien et le manuscrit via les modèles PERO,
+là où tesseract couvre l'imprimé moderne. Implémente le ``Module`` Protocol
+**directement** — même contrat que le socle, livré in-tree (décision : pas de
+discrimination socle/plugin ; seule la livraison diffère). La lib ``pero_ocr`` est
+un **extra optionnel** (``cinoc[pero]``), importée **paresseusement** dans
+``_invoke_pero`` : importer ce module ne requiert rien ; seule l'exécution exige la
+lib + un **modèle** (``model`` = chemin du fichier de config PERO, obligatoire —
+pas de modèle embarqué). Sortie : ``RAW_TEXT`` (lignes reconnues, ordre PERO).
+
+**Non déployé au Space** (dép lourde, free-tier) : listé « indisponible » sans
+l'extra, comme Kraken — pas d'exécution cloud, pas de clé.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from cinoc.adapters.ocr._base import run_image_to_text
+from cinoc.domain.artifacts import Artifact, ArtifactType
+from cinoc.domain.errors import AdapterStepError
+from cinoc.pipeline.protocols import ParamValue
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import RunContext, StepOutput
+
+_VERSION = "1.0"
+
+
+def _invoke_pero(  # pragma: no cover -- lib + modèle requis (cf. 'live')
+    *, image_path: str, config_path: str
+) -> str:
+    """Mise en page + reconnaissance PERO → texte (lignes jointes, ordre PERO)."""
+    try:
+        import configparser
+
+        import cv2  # type: ignore[import-not-found]
+        from pero_ocr.document_ocr.layout import (  # type: ignore[import-not-found]
+            PageLayout,
+        )
+        from pero_ocr.document_ocr.page_parser import (  # type: ignore[import-not-found]
+            PageParser,
+        )
+    except ImportError as exc:
+        raise AdapterStepError(
+            "pero : lib non installée (pip install 'cinoc[pero]')."
+        ) from exc
+    config = configparser.ConfigParser()
+    if not config.read(config_path):
+        raise AdapterStepError(f"pero : config illisible {config_path!r}.")
+    image = cv2.imread(image_path)
+    if image is None:
+        raise AdapterStepError(f"pero : image illisible {image_path!r}.")
+    parser = PageParser(config, config_path=str(Path(config_path).parent))
+    layout = PageLayout(id="page", page_size=(image.shape[0], image.shape[1]))
+    layout = parser.process_page(image, layout)
+    lines = [
+        str(line.transcription)
+        for region in layout.regions
+        for line in region.lines
+        if line.transcription
+    ]
+    return "\n".join(lines).strip()
+
+
+class PeroAdapter:
+    """OCR/HTR PERO : ``IMAGE`` → ``RAW_TEXT`` (lignes reconnues)."""
+
+    def __init__(self, *, label: str, model: str) -> None:
+        if not label or not all(c.isalnum() or c in "_-" for c in label):
+            raise AdapterStepError(f"pero : label invalide {label!r}.")
+        if not model:
+            raise AdapterStepError(
+                "pero : paramètre 'model' (chemin de config PERO) requis."
+            )
+        self._label = label
+        self._model = model
+
+    @property
+    def name(self) -> str:
+        return f"pero:{self._label}"
+
+    @property
+    def version(self) -> str:
+        return _VERSION
+
+    @property
+    def input_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.IMAGE})
+
+    @property
+    def output_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.RAW_TEXT})
+
+    def execute(
+        self,
+        inputs: dict[ArtifactType, Artifact],
+        params: dict[str, ParamValue],
+        context: RunContext,
+        control: RunControl,
+    ) -> StepOutput:
+        return run_image_to_text(
+            name=self.name,
+            label=self._label,
+            inputs=inputs,
+            context=context,
+            control=control,
+            recognize=lambda image_uri: _invoke_pero(
+                image_path=image_uri, config_path=self._model
+            ),
+        )
+
+
+__all__ = ["PeroAdapter"]
diff --git a/cinoc/adapters/ocr/precomputed.py b/cinoc/adapters/ocr/precomputed.py
new file mode 100644
index 0000000000000000000000000000000000000000..843c3f257528041a89c62b4e01e23fd54455ee46
--- /dev/null
+++ b/cinoc/adapters/ocr/precomputed.py
@@ -0,0 +1,91 @@
+"""``PrecomputedTextAdapter`` — rejoue un texte OCR pré-calculé depuis le disque.
+
+Module à **zéro dépendance et zéro réseau** : il lit ``<stem>.<source_label>.txt``
+à côté de l'image et renvoie un ``RAW_TEXT``. Brique du *starter pack* — il fait
+tourner le squelette ambulant (``cinoc demo``) et les tests déterministes sans
+moteur réel. Implémente le ``Module`` Protocol (couche 4) **directement**.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from cinoc.domain.artifacts import Artifact, ArtifactType, compute_content_hash
+from cinoc.domain.errors import AdapterStepError
+from cinoc.pipeline.protocols import ParamValue
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import RunContext, StepOutput
+
+_VERSION = "1.0"
+
+
+class PrecomputedTextAdapter:
+    """Lit un texte OCR pré-calculé (``<stem>.<label>.txt`` près de l'image)."""
+
+    def __init__(self, *, source_label: str) -> None:
+        if not source_label or not all(
+            c.isalnum() or c in "_-" for c in source_label
+        ):
+            raise AdapterStepError(
+                f"PrecomputedTextAdapter : source_label invalide "
+                f"{source_label!r} (alphanumérique + _ - uniquement)."
+            )
+        self._label = source_label
+
+    @property
+    def name(self) -> str:
+        return f"precomputed:{self._label}"
+
+    @property
+    def version(self) -> str:
+        return _VERSION
+
+    @property
+    def input_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.IMAGE})
+
+    @property
+    def output_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.RAW_TEXT})
+
+    def execute(
+        self,
+        inputs: dict[ArtifactType, Artifact],
+        params: dict[str, ParamValue],
+        context: RunContext,
+        control: RunControl,
+    ) -> StepOutput:
+        control.raise_if_cancelled()
+        image = inputs.get(ArtifactType.IMAGE)
+        if image is None or image.uri is None:
+            raise AdapterStepError(
+                f"{self.name} : artefact IMAGE manquant ou sans URI."
+            )
+        image_path = Path(image.uri)
+        text_path = image_path.parent / f"{image_path.stem}.{self._label}.txt"
+        if not text_path.is_file():
+            raise AdapterStepError(
+                f"{self.name} : texte pré-calculé introuvable — "
+                f"{text_path.name!r} attendu près de {image_path.name!r}."
+            )
+        data = text_path.read_bytes()
+        try:
+            data.decode("utf-8")
+        except UnicodeDecodeError as exc:
+            raise AdapterStepError(
+                f"{self.name} : {text_path.name!r} n'est pas en UTF-8 : {exc}"
+            ) from exc
+        return StepOutput(
+            artifacts={
+                ArtifactType.RAW_TEXT: Artifact(
+                    id=f"{context.document_id}:{self.name}:raw_text",
+                    document_id=context.document_id,
+                    type=ArtifactType.RAW_TEXT,
+                    uri=str(text_path),
+                    content_hash=compute_content_hash(data),
+                )
+            }
+        )
+
+
+__all__ = ["PrecomputedTextAdapter"]
diff --git a/cinoc/adapters/ocr/tesseract.py b/cinoc/adapters/ocr/tesseract.py
new file mode 100644
index 0000000000000000000000000000000000000000..52e1f24b3c672cde920641bf89424d091adb0c9b
--- /dev/null
+++ b/cinoc/adapters/ocr/tesseract.py
@@ -0,0 +1,332 @@
+"""``TesseractAdapter`` — moteur OCR réel (Tesseract 5 via ``pytesseract``).
+
+Implémente le ``Module`` Protocol (couche 4) **directement**. L'OCR a lieu dans
+le binaire C ``tesseract`` lancé en sous-processus (le thread relâche le GIL).
+``pytesseract`` est un **extra optionnel** (``cinoc[tesseract]``), importé
+**paresseusement** dans ``_invoke_tesseract`` : importer ce module ne requiert ni
+la lib ni le binaire — seule l'exécution les exige.
+
+Sécurité : ``lang`` est validé (anti-injection ligne de commande) ; ``timeout``
+est borné par la ``Deadline`` (un sous-processus figé ne doit pas geler le run).
+Les **confidences** par mot (TSV natif, 0-100 → [0,1]) sont écrites en
+sidecar JSON (``ConfidenceToken``) et publiées comme artefact ``CONFIDENCES``
+— best-effort : un échec d'extraction dégrade en sidecar vide, jamais en
+panne de l'OCR.
+
+**ALTO natif** (``alto=True``) : Tesseract émet en plus un artefact
+``ALTO_XML`` (géométrie + texte par mot, ``image_to_alto_xml``) — la forme
+ré-importable dans un outil de relecture (eScriptorium, Transkribus). Contrairement
+aux confidences, l'ALTO est ici le **livrable demandé** : un échec d'émission lève
+(``AdapterStepError``), il ne dégrade pas en silence.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+import subprocess
+from collections.abc import Callable
+
+from cinoc.adapters._workspace import workspace_artifact_path
+from cinoc.domain.artifacts import Artifact, ArtifactType, compute_content_hash
+from cinoc.domain.confidence import ConfidenceToken
+from cinoc.domain.errors import AdapterStepError
+from cinoc.pipeline.protocols import ParamValue
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import RunContext, StepOutput
+
+logger = logging.getLogger(__name__)
+
+_VERSION = "1.0"
+_DEFAULT_TIMEOUT = 120.0
+
+#: Codes langue Tesseract : ISO 639-3 (≥3 lettres ASCII), combinables par ``+``
+#: (``fra+lat``). ``lang`` finit sur la ligne de commande tesseract → on refuse
+#: tout caractère interprétable comme flag/séparateur (anti-injection).
+_LANG_RE = re.compile(r"^[a-zA-Z]{3,}(?:\+[a-zA-Z]{3,})*$")
+
+#: Lanceur de sous-processus, injectable → version sondable en test sans binaire.
+BinaryRunner = Callable[..., "subprocess.CompletedProcess[str]"]
+
+
+def tesseract_binary_version(*, run: BinaryRunner = subprocess.run) -> str | None:
+    """Version du binaire ``tesseract`` (1ʳᵉ ligne de ``tesseract --version``).
+
+    **Best-effort, jamais bloquant** : binaire absent, timeout, ou sortie illisible
+    → ``None`` (jamais une panne). Sert la **reproductibilité** (``RunManifest`` §12) :
+    deux runs ne sont comparables qu'à version de binaire égale — la version
+    d'*adapter* (``_VERSION``) ne dit rien du Tesseract réellement installé.
+    ``run`` est injecté → la sonde est déterministe en test, sans le binaire.
+
+    Tesseract émet sa bannière tantôt sur ``stdout`` tantôt sur ``stderr`` selon le
+    build → on lit les deux et garde la 1ʳᵉ ligne non vide (ex. ``tesseract 5.3.0``).
+    """
+    try:
+        completed = run(
+            ["tesseract", "--version"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+            check=False,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    lines = ((completed.stdout or "") + "\n" + (completed.stderr or "")).splitlines()
+    for line in lines:
+        if line.strip():
+            return line.strip()
+    return None
+
+
+def _invoke_tesseract(  # pragma: no cover -- binaire requis (cf. marqueur 'live')
+    *, image_path: str, lang: str, psm: int, oem: int, timeout: float
+) -> str:
+    """Lance tesseract et renvoie le texte. **Isolé → mockable** (CI sans binaire)."""
+    try:
+        import pytesseract  # type: ignore[import-not-found, import-untyped]
+    except ImportError as exc:
+        raise AdapterStepError(
+            "tesseract : pytesseract non installé "
+            "(pip install 'cinoc[tesseract]' + binaire tesseract)."
+        ) from exc
+    config = f"--oem {oem} --psm {psm}"
+    try:
+        text = pytesseract.image_to_string(
+            image_path, lang=lang, config=config, timeout=timeout
+        )
+    except (
+        pytesseract.TesseractNotFoundError,
+        pytesseract.TesseractError,
+        RuntimeError,
+    ) as exc:
+        raise AdapterStepError(
+            f"tesseract a échoué sur {image_path!r} : {type(exc).__name__}: {exc}"
+        ) from exc
+    return str(text).strip()
+
+
+def _invoke_tesseract_alto(  # pragma: no cover -- binaire requis ('live')
+    *, image_path: str, lang: str, psm: int, oem: int, timeout: float
+) -> bytes:
+    """ALTO XML natif via ``image_to_alto_xml`` (géométrie + texte par mot).
+
+    Renvoie les octets XML bruts (déjà conformes ALTO) — destinés à la
+    ré-importation dans un outil de relecture. Une panne du binaire lève
+    ``AdapterStepError`` : l'ALTO est le livrable demandé, pas un extra dégradable.
+    """
+    try:
+        import pytesseract  # type: ignore[import-not-found, import-untyped]
+    except ImportError as exc:
+        raise AdapterStepError(
+            "tesseract : pytesseract non installé "
+            "(pip install 'cinoc[tesseract]' + binaire tesseract)."
+        ) from exc
+    try:
+        xml = pytesseract.image_to_alto_xml(
+            image_path, lang=lang, config=f"--oem {oem} --psm {psm}", timeout=timeout
+        )
+    except (
+        pytesseract.TesseractNotFoundError,
+        pytesseract.TesseractError,
+        RuntimeError,
+    ) as exc:
+        raise AdapterStepError(
+            f"tesseract ALTO a échoué sur {image_path!r} : "
+            f"{type(exc).__name__}: {exc}"
+        ) from exc
+    return bytes(xml)
+
+
+def _invoke_tesseract_confidences(  # pragma: no cover -- binaire requis ('live')
+    *, image_path: str, lang: str, psm: int, oem: int, timeout: float
+) -> list[ConfidenceToken]:
+    """Confidences par mot via ``image_to_data`` (TSV natif, conf 0-100)."""
+    import pytesseract  # type: ignore[import-not-found]
+
+    data = pytesseract.image_to_data(
+        image_path,
+        lang=lang,
+        config=f"--psm {psm} --oem {oem}",
+        timeout=timeout,
+        output_type=pytesseract.Output.DICT,
+    )
+    tokens: list[ConfidenceToken] = []
+    for word, conf in zip(data["text"], data["conf"], strict=False):
+        if not isinstance(word, str) or not word.strip():
+            continue
+        value = float(conf)
+        if value < 0:  # -1 : entrée non textuelle du TSV
+            continue
+        tokens.append(
+            ConfidenceToken(text=word.strip(), confidence=min(value / 100.0, 1.0))
+        )
+    return tokens
+
+
+class TesseractAdapter:
+    """OCR Tesseract 5 ; écrit le texte dans le workspace, renvoie un ``RAW_TEXT``."""
+
+    def __init__(
+        self,
+        *,
+        label: str,
+        lang: str = "fra",
+        psm: int = 6,
+        oem: int = 3,
+        alto: bool = False,
+    ) -> None:
+        if not label or not all(c.isalnum() or c in "_-" for c in label):
+            raise AdapterStepError(
+                f"TesseractAdapter : label invalide {label!r} "
+                "(alphanumérique + _ - uniquement)."
+            )
+        if not _LANG_RE.fullmatch(lang):
+            raise AdapterStepError(
+                f"TesseractAdapter : lang invalide {lang!r} "
+                "(ISO 639-3, combinable par '+' : ex. 'fra+lat')."
+            )
+        if not 0 <= psm <= 13:
+            raise AdapterStepError(f"TesseractAdapter : psm ∈ [0, 13], reçu {psm}.")
+        if not 0 <= oem <= 3:
+            raise AdapterStepError(f"TesseractAdapter : oem ∈ [0, 3], reçu {oem}.")
+        self._label = label
+        self._lang = lang
+        self._psm = psm
+        self._oem = oem
+        #: Émet en plus un artefact ``ALTO_XML`` (ré-import eScriptorium/Transkribus).
+        self._alto = alto
+
+    @property
+    def name(self) -> str:
+        return f"tesseract:{self._label}"
+
+    @property
+    def version(self) -> str:
+        return _VERSION
+
+    def system_binaries(self) -> dict[str, str]:
+        """Version du **binaire externe** pour le ``RunManifest`` (reproductibilité).
+
+        Hook de **provenance optionnel** (hors ``Module`` Protocol, qui reste le
+        contrat d'exécution unique) : l'orchestrateur l'appelle par *duck-typing*
+        sur les modules qui l'exposent et fusionne le résultat dans
+        ``system_binaries_lock``. Best-effort : binaire absent → ``{}``.
+        """
+        version = tesseract_binary_version()
+        return {"tesseract": version} if version is not None else {}
+
+    @property
+    def input_types(self) -> frozenset[ArtifactType]:
+        return frozenset({ArtifactType.IMAGE})
+
+    @property
+    def output_types(self) -> frozenset[ArtifactType]:
+        types = {ArtifactType.RAW_TEXT, ArtifactType.CONFIDENCES}
+        if self._alto:
+            types.add(ArtifactType.ALTO_XML)
+        return frozenset(types)
+
+    def execute(
+        self,
+        inputs: dict[ArtifactType, Artifact],
+        params: dict[str, ParamValue],
+        context: RunContext,
+        control: RunControl,
+    ) -> StepOutput:
+        control.raise_if_cancelled()
+        image = inputs.get(ArtifactType.IMAGE)
+        if image is None or image.uri is None:
+            raise AdapterStepError(
+                f"{self.name} : artefact IMAGE manquant ou sans URI."
+            )
+        if context.workspace_uri is None:
+            raise AdapterStepError(
+                f"{self.name} : workspace requis (RunContext.workspace_uri)."
+            )
+        timeout = max(0.001, context.deadline.clamp_to_remaining(_DEFAULT_TIMEOUT))
+        text = _invoke_tesseract(
+            image_path=image.uri,
+            lang=self._lang,
+            psm=self._psm,
+            oem=self._oem,
+            timeout=timeout,
+        )
+        output_path = workspace_artifact_path(
+            context.workspace_uri, context.document_id, self._label, "txt"
+        )
+        output_path.write_text(text, encoding="utf-8")
+        # Confidences best-effort : un échec d'extraction ne doit pas faire
+        # échouer un OCR réussi — sidecar vide + avertissement.
+        try:
+            tokens = _invoke_tesseract_confidences(
+                image_path=image.uri,
+                lang=self._lang,
+                psm=self._psm,
+                oem=self._oem,
+                timeout=timeout,
+            )
+        except (
+            AdapterStepError,
+            ImportError,
+            RuntimeError,
+            ValueError,
+            OSError,
+        ) as exc:
+            logger.warning(
+                "[tesseract] confidences dégradées (sidecar vide) : %s", exc
+            )
+            tokens = []
+        sidecar = json.dumps(
+            [token.model_dump() for token in tokens], ensure_ascii=False
+        ).encode("utf-8")
+        sidecar_path = workspace_artifact_path(
+            context.workspace_uri,
+            context.document_id,
+            self._label,
+            "confidences.json",
+        )
+        sidecar_path.write_bytes(sidecar)
+        artifacts: dict[ArtifactType, Artifact] = {
+            ArtifactType.RAW_TEXT: Artifact(
+                id=f"{context.document_id}:{self.name}:raw_text",
+                document_id=context.document_id,
+                type=ArtifactType.RAW_TEXT,
+                uri=str(output_path),
+                content_hash=compute_content_hash(text.encode("utf-8")),
+            ),
+            ArtifactType.CONFIDENCES: Artifact(
+                id=f"{context.document_id}:{self.name}:confidences",
+                document_id=context.document_id,
+                type=ArtifactType.CONFIDENCES,
+                uri=str(sidecar_path),
+                content_hash=compute_content_hash(sidecar),
+            ),
+        }
+        if self._alto:
+            # ALTO demandé → livrable : un échec lève (≠ confidences best-effort).
+            alto_bytes = _invoke_tesseract_alto(
+                image_path=image.uri,
+                lang=self._lang,
+                psm=self._psm,
+                oem=self._oem,
+                timeout=timeout,
+            )
+            alto_path = workspace_artifact_path(
+                context.workspace_uri,
+                context.document_id,
+                self._label,
+                "alto.xml",
+            )
+            alto_path.write_bytes(alto_bytes)
+            artifacts[ArtifactType.ALTO_XML] = Artifact(
+                id=f"{context.document_id}:{self.name}:alto_xml",
+                document_id=context.document_id,
+                type=ArtifactType.ALTO_XML,
+                uri=str(alto_path),
+                content_hash=compute_content_hash(alto_bytes),
+            )
+        return StepOutput(artifacts=artifacts)
+
+
+__all__ = ["TesseractAdapter", "tesseract_binary_version"]
diff --git a/cinoc/adapters/storage/__init__.py b/cinoc/adapters/storage/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ab8843eb51d7d431a4282a47bbb7c599baf0685
--- /dev/null
+++ b/cinoc/adapters/storage/__init__.py
@@ -0,0 +1,24 @@
+"""Stockage (couche 5) : état des jobs de run lancés via le web/CLI long.
+
+En mémoire par choix : suffit au lanceur mono-worker du Space. Le journal
+d'événements du ``JobStore`` porte la reprise SSE ``Last-Event-ID`` (réserve
+R-10 d'ANALYSE_COUCHE_5, levée).
+"""
+
+from __future__ import annotations
+
+from cinoc.adapters.storage.history_store import (
+    HistoryRecord,
+    HistoryStore,
+    Regression,
+)
+from cinoc.adapters.storage.job_store import Job, JobState, JobStore
+
+__all__ = [
+    "HistoryRecord",
+    "HistoryStore",
+    "Job",
+    "JobState",
+    "JobStore",
+    "Regression",
+]
diff --git a/cinoc/adapters/storage/history_store.py b/cinoc/adapters/storage/history_store.py
new file mode 100644
index 0000000000000000000000000000000000000000..e427e840566f5835032ab8c5cbb3df8c4682ea39
--- /dev/null
+++ b/cinoc/adapters/storage/history_store.py
@@ -0,0 +1,191 @@
+"""``HistoryStore`` — historique **longitudinal** des runs, en SQLite (couche 5).
+
+Persiste, run après run, la **valeur agrégée de chaque métrique** par pipeline et
+par vue, pour suivre l'évolution dans le temps (tendance) et **détecter les
+régressions** (un moteur dont le CER se dégrade d'un run au suivant).
+
+Le store ne connaît **que des enregistrements primitifs** (``HistoryRecord``) : il
+n'importe pas ``RunResult`` (couche 3) — c'est la couche ``app`` qui aplatit un
+``RunResult`` en enregistrements (``app/history.py``). Persistance pure, réutilisable
+et testable avec de la donnée simple.
+
+Concurrence : **une connexion par opération** (``sqlite3.connect`` est bon marché),
+donc aucun partage de connexion entre threads. Ré-enregistrer un même run est
+**idempotent** (clé primaire ``(run_id, pipeline, view, metric)``).
+"""
+
+from __future__ import annotations
+
+import sqlite3
+from collections.abc import Iterable
+from contextlib import closing
+from dataclasses import dataclass
+from pathlib import Path
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS run_metrics (
+    run_id       TEXT NOT NULL,
+    completed_at TEXT NOT NULL,
+    corpus_name  TEXT NOT NULL,
+    code_version TEXT NOT NULL,
+    pipeline     TEXT NOT NULL,
+    view         TEXT NOT NULL,
+    metric       TEXT NOT NULL,
+    value        REAL NOT NULL,
+    PRIMARY KEY (run_id, pipeline, view, metric)
+);
+CREATE INDEX IF NOT EXISTS idx_run_metrics_lookup
+    ON run_metrics (view, metric, pipeline, completed_at);
+"""
+
+_COLUMNS = (
+    "run_id, completed_at, corpus_name, code_version, pipeline, view, metric, value"
+)
+
+
+@dataclass(frozen=True)
+class HistoryRecord:
+    """Une valeur de métrique agrégée pour un run (ligne d'historique)."""
+
+    run_id: str
+    completed_at: str  # ISO 8601 (UTC) — triable lexicographiquement
+    corpus_name: str
+    code_version: str
+    pipeline: str
+    view: str
+    metric: str
+    value: float
+
+
+@dataclass(frozen=True)
+class Regression:
+    """Dégradation d'un pipeline entre ses deux runs les plus récents."""
+
+    pipeline: str
+    view: str
+    metric: str
+    previous_run_id: str
+    latest_run_id: str
+    previous: float
+    latest: float
+    delta: float  # latest - previous (signé)
+
+
+class HistoryStore:
+    """Historique longitudinal sur un fichier SQLite."""
+
+    def __init__(self, db_path: str | Path) -> None:
+        # **Initialisation paresseuse** : on ne touche pas au filesystem ici.
+        # ``create_app`` peut instancier le store avec un chemin par défaut
+        # (``/data`` sur un Space) non writable au moment de la construction ;
+        # le dossier + le schéma sont créés à la **première** opération réelle.
+        self._path = Path(db_path)
+
+    def _connect(self) -> sqlite3.Connection:
+        """Ouvre une connexion, créant dossier + schéma au besoin (idempotent)."""
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        conn = sqlite3.connect(self._path)
+        conn.executescript(_SCHEMA)
+        return conn
+
+    def add(self, records: Iterable[HistoryRecord]) -> int:
+        """Enregistre des lignes (``INSERT OR REPLACE``) ; renvoie le compte."""
+        rows = [
+            (
+                r.run_id,
+                r.completed_at,
+                r.corpus_name,
+                r.code_version,
+                r.pipeline,
+                r.view,
+                r.metric,
+                r.value,
+            )
+            for r in records
+        ]
+        if not rows:
+            return 0
+        with closing(self._connect()) as conn:
+            conn.executemany(
+                f"INSERT OR REPLACE INTO run_metrics ({_COLUMNS}) "
+                "VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+                rows,
+            )
+            conn.commit()
+        return len(rows)
+
+    def history(
+        self, pipeline: str, view: str, metric: str
+    ) -> tuple[HistoryRecord, ...]:
+        """Suite chronologique (croissante) d'une métrique pour un pipeline/vue."""
+        with closing(self._connect()) as conn:
+            cur = conn.execute(
+                f"SELECT {_COLUMNS} FROM run_metrics "
+                "WHERE pipeline = ? AND view = ? AND metric = ? "
+                "ORDER BY completed_at, run_id",  # run_id = bris d'égalité déterministe
+                (pipeline, view, metric),
+            )
+            return tuple(HistoryRecord(*row) for row in cur.fetchall())
+
+    def all_records(self, *, limit: int = 1000) -> tuple[HistoryRecord, ...]:
+        """Lignes les plus récentes d'abord, **bornées** (pour la vue Historique)."""
+        with closing(self._connect()) as conn:
+            cur = conn.execute(
+                f"SELECT {_COLUMNS} FROM run_metrics "
+                "ORDER BY completed_at DESC, run_id, pipeline, view, metric "
+                "LIMIT ?",
+                (limit,),
+            )
+            return tuple(HistoryRecord(*row) for row in cur.fetchall())
+
+    def regressions(
+        self,
+        view: str,
+        metric: str,
+        *,
+        threshold: float = 0.0,
+        higher_is_better: bool = False,
+    ) -> tuple[Regression, ...]:
+        """Pipelines dont la métrique s'est dégradée entre les 2 derniers runs.
+
+        ``higher_is_better=False`` (défaut, CER/WER) : régression = la valeur a
+        **augmenté** de plus de ``threshold``. ``True`` inverse le sens.
+        """
+        with closing(self._connect()) as conn:
+            cur = conn.execute(
+                "SELECT pipeline, completed_at, value, run_id FROM run_metrics "
+                "WHERE view = ? AND metric = ? "
+                "ORDER BY pipeline, completed_at, run_id",  # bris d'égalité stable
+                (view, metric),
+            )
+            rows = cur.fetchall()
+
+        by_pipeline: dict[str, list[tuple[str, float, str]]] = {}
+        for pipeline, completed_at, value, run_id in rows:
+            by_pipeline.setdefault(pipeline, []).append((completed_at, value, run_id))
+
+        out: list[Regression] = []
+        for pipeline, series in by_pipeline.items():
+            if len(series) < 2:
+                continue
+            _, prev_value, prev_run = series[-2]
+            _, last_value, last_run = series[-1]
+            delta = last_value - prev_value
+            worse = -delta if higher_is_better else delta
+            if worse > threshold:
+                out.append(
+                    Regression(
+                        pipeline=pipeline,
+                        view=view,
+                        metric=metric,
+                        previous_run_id=prev_run,
+                        latest_run_id=last_run,
+                        previous=prev_value,
+                        latest=last_value,
+                        delta=delta,
+                    )
+                )
+        return tuple(out)
+
+
+__all__ = ["HistoryRecord", "HistoryStore", "Regression"]
diff --git a/cinoc/adapters/storage/job_store.py b/cinoc/adapters/storage/job_store.py
new file mode 100644
index 0000000000000000000000000000000000000000..3c8f09fd955eb34bacfc27ea17e0116596186e92
--- /dev/null
+++ b/cinoc/adapters/storage/job_store.py
@@ -0,0 +1,159 @@
+"""``JobStore`` — état des jobs de run, **en mémoire et thread-safe** (couche 5).
+
+Un job = une exécution asynchrone d'un ``RunSpec`` (lancée par le ``JobRunner``,
+couche 6). Le store ne *fait* rien : il garde l'état observable (la machine à
+états ci-dessous) pour que le web le restitue et qu'un ``cancel`` soit traçable.
+
+Concurrence : un seul verrou protège le dict ; ``Job`` est **immuable** (pydantic
+``frozen``), donc un lecteur (requête HTTP) reçoit un instantané cohérent sans
+risque de course avec le worker qui le remplace sous verrou.
+
+Chaque transition est aussi **journalisée** (``_history``) : un instantané ``Job``
+par changement d'état, indexé par un id monotone (1-based). C'est la matière
+première du **flux SSE** + de la reprise ``Last-Event-ID`` (couche 8) — rejouable
+même après la fin du job.
+"""
+
+from __future__ import annotations
+
+import threading
+import uuid
+from enum import StrEnum
+
+from pydantic import BaseModel, ConfigDict
+
+from cinoc.domain.errors import CinocError
+from cinoc.domain.run import utcnow
+
+
+class JobState(StrEnum):
+    """États d'un job. Terminaux : ``DONE``, ``FAILED``, ``CANCELLED``."""
+
+    PENDING = "pending"
+    RUNNING = "running"
+    DONE = "done"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+    @property
+    def is_terminal(self) -> bool:
+        return self in _TERMINAL
+
+
+_TERMINAL = frozenset({JobState.DONE, JobState.FAILED, JobState.CANCELLED})
+
+
+class JobError(CinocError):
+    """Job introuvable."""
+
+
+class Job(BaseModel):
+    """Instantané immuable de l'état d'un job."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    id: str
+    state: JobState
+    created_at: str
+    updated_at: str
+    #: Stem du ``RunResult`` JSON écrit quand ``state == DONE`` (sinon ``None``).
+    report_name: str | None = None
+    #: Message d'erreur quand ``state == FAILED`` (sinon ``None``).
+    error: str | None = None
+    #: URL distante du rapport publié si la persistance est active, sinon ``None``.
+    published_url: str | None = None
+    #: Progression : unités (document × concurrent) traitées / total. ``0/0`` =
+    #: inconnu (job pas encore démarré). Alimente la barre de progression (SSE).
+    done: int = 0
+    total: int = 0
+
+
+class JobStore:
+    """Dictionnaire thread-safe ``job_id → Job`` (instantanés immuables)."""
+
+    def __init__(self) -> None:
+        self._jobs: dict[str, Job] = {}
+        self._history: dict[str, list[Job]] = {}
+        self._lock = threading.Lock()
+
+    def create(self) -> Job:
+        """Crée un job ``PENDING`` (id généré) et le renvoie."""
+        now = utcnow().isoformat()
+        job = Job(id=uuid.uuid4().hex, state=JobState.PENDING, created_at=now,
+                  updated_at=now)
+        with self._lock:
+            self._jobs[job.id] = job
+            self._history[job.id] = [job]
+        return job
+
+    def get(self, job_id: str) -> Job | None:
+        with self._lock:
+            return self._jobs.get(job_id)
+
+    def all_jobs(self) -> tuple[Job, ...]:
+        """Tous les jobs, du plus récent au plus ancien."""
+        with self._lock:
+            jobs = tuple(self._jobs.values())
+        return tuple(sorted(jobs, key=lambda j: j.created_at, reverse=True))
+
+    def update(
+        self,
+        job_id: str,
+        *,
+        state: JobState,
+        report_name: str | None = None,
+        error: str | None = None,
+        published_url: str | None = None,
+    ) -> Job:
+        """Remplace l'instantané du job (sous verrou). Lève si inconnu."""
+        with self._lock:
+            current = self._jobs.get(job_id)
+            if current is None:
+                raise JobError(f"job {job_id!r} introuvable.")
+            updated = current.model_copy(
+                update={
+                    "state": state,
+                    "report_name": report_name,
+                    "error": error,
+                    "published_url": published_url,
+                    "updated_at": utcnow().isoformat(),
+                }
+            )
+            self._jobs[job_id] = updated
+            self._history[job_id].append(updated)
+        return updated
+
+    def progress(self, job_id: str, done: int, total: int) -> Job:
+        """Met à jour la progression (``done``/``total``) **sans changer l'état**.
+
+        Ajoute un instantané au journal → un **événement SSE** (de type ``running``)
+        par unité traitée, que l'UI consomme pour la barre de progression. Les
+        autres champs (état, rapport…) sont préservés (``model_copy`` ciblé).
+        """
+        with self._lock:
+            current = self._jobs.get(job_id)
+            if current is None:
+                raise JobError(f"job {job_id!r} introuvable.")
+            updated = current.model_copy(
+                update={
+                    "done": done,
+                    "total": total,
+                    "updated_at": utcnow().isoformat(),
+                }
+            )
+            self._jobs[job_id] = updated
+            self._history[job_id].append(updated)
+        return updated
+
+    def history_since(self, job_id: str, after_id: int) -> list[tuple[int, Job]]:
+        """Instantanés (``event_id``, ``Job``) du journal **après** ``after_id``.
+
+        ``event_id`` est la position 1-based dans le journal du job → c'est l'id
+        d'événement SSE (``Last-Event-ID``). Job inconnu → liste vide.
+        """
+        with self._lock:
+            history = list(self._history.get(job_id, ()))
+        return [(i, job) for i, job in enumerate(history, start=1) if i > after_id]
+
+
+__all__ = ["Job", "JobError", "JobState", "JobStore"]
diff --git a/cinoc/adapters/storage/publisher.py b/cinoc/adapters/storage/publisher.py
new file mode 100644
index 0000000000000000000000000000000000000000..269372f0176e1f5e2e59ab10da0bacb284d46fa4
--- /dev/null
+++ b/cinoc/adapters/storage/publisher.py
@@ -0,0 +1,147 @@
+"""Publication d'un ``RunResult`` vers un dépôt distant (persistance).
+
+Le disque d'un HF Space est **éphémère** : un run calculé est perdu au
+redémarrage. Ce module **pousse** le ``RunResult`` JSON vers un dépôt GitHub
+(API *contents*) après chaque run réussi, ce qui le rend **durable** et alimente
+la vitrine publique.
+
+Sécurité & opt-in :
+
+- **Désactivé par défaut.** Sans dépôt **et** jeton (secrets), on renvoie un
+  ``NoopPublisher`` : aucune sortie réseau. La vitrine read-only (sans secret)
+  reste donc inerte.
+- Le **jeton vient d'un secret** (``CINOC_PUBLISH_TOKEN``) et n'est **jamais
+  journalisé** (il ne vit que dans l'en-tête ``Authorization``).
+- Aucune dépendance ajoutée : l'appel HTTP réel utilise ``urllib`` (stdlib),
+  importé et exécuté seulement à la publication (chemin *live*, hors CI).
+
+La construction de la requête (:func:`build_put_request`) est **pure** et
+testée ; seul l'envoi réseau est non couvert.
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import logging
+import os
+from collections.abc import Callable
+from pathlib import Path
+from typing import NamedTuple, Protocol
+from urllib.parse import quote
+
+from pydantic import BaseModel, ConfigDict
+
+logger = logging.getLogger(__name__)
+
+_API = "https://api.github.com"
+
+
+class PublishTarget(BaseModel):
+    """Cible de publication (dépôt GitHub) — résolue depuis les secrets."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    repo: str  # "owner/name"
+    token: str
+    branch: str = "main"
+    subdir: str = "reports"
+
+
+class PutRequest(NamedTuple):
+    """Requête HTTP prête à envoyer (pure, testable sans réseau)."""
+
+    url: str
+    headers: dict[str, str]
+    body: bytes
+
+
+class ResultPublisher(Protocol):
+    """Publie un ``RunResult`` ; renvoie l'URL distante, ou ``None`` si inactif."""
+
+    def publish(self, name: str, run_result_path: Path) -> str | None: ...
+
+
+class NoopPublisher:
+    """Publisher inactif (aucun secret configuré) : ne fait rien."""
+
+    def publish(self, name: str, run_result_path: Path) -> str | None:
+        return None
+
+
+def build_put_request(target: PublishTarget, name: str, content: bytes) -> PutRequest:
+    """Construit la requête *PUT contents* GitHub pour ``<subdir>/<name>.json``."""
+    path = quote(f"{target.subdir}/{name}.json", safe="/")
+    body = json.dumps(
+        {
+            "message": f"cinoc: publie le rapport {name}",
+            "content": base64.b64encode(content).decode("ascii"),
+            "branch": target.branch,
+        }
+    ).encode("utf-8")
+    headers = {
+        "Authorization": f"Bearer {target.token}",
+        "Accept": "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+        "Content-Type": "application/json",
+    }
+    return PutRequest(f"{_API}/repos/{target.repo}/contents/{path}", headers, body)
+
+
+class GitHubPublisher:
+    """Pousse le ``RunResult`` JSON vers un dépôt GitHub (API *contents*)."""
+
+    def __init__(self, target: PublishTarget) -> None:
+        self._target = target
+
+    def publish(self, name: str, run_result_path: Path) -> str | None:
+        content = run_result_path.read_bytes()
+        request = build_put_request(self._target, name, content)
+        return self._send(request)
+
+    def _send(self, request: PutRequest) -> str | None:  # pragma: no cover (réseau)
+        import urllib.request
+
+        req = urllib.request.Request(
+            request.url, data=request.body, headers=request.headers, method="PUT"
+        )
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            payload = json.loads(resp.read().decode("utf-8"))
+        content = payload.get("content") or {}
+        return content.get("html_url")
+
+
+def resolve_publish_target(
+    get_env: Callable[[str], str | None] = os.environ.get,
+) -> PublishTarget | None:
+    """Cible depuis les secrets, ou ``None`` si dépôt **ou** jeton manquant."""
+    repo = (get_env("CINOC_PUBLISH_REPO") or "").strip()
+    token = (get_env("CINOC_PUBLISH_TOKEN") or "").strip()
+    if not repo or "/" not in repo or not token:
+        return None
+    return PublishTarget(
+        repo=repo,
+        token=token,
+        branch=(get_env("CINOC_PUBLISH_BRANCH") or "main").strip(),
+        subdir=(get_env("CINOC_PUBLISH_DIR") or "reports").strip(),
+    )
+
+
+def resolve_publisher(
+    get_env: Callable[[str], str | None] = os.environ.get,
+) -> ResultPublisher:
+    """``GitHubPublisher`` si configuré (secrets), sinon ``NoopPublisher``."""
+    target = resolve_publish_target(get_env)
+    return GitHubPublisher(target) if target is not None else NoopPublisher()
+
+
+__all__ = [
+    "GitHubPublisher",
+    "NoopPublisher",
+    "PublishTarget",
+    "PutRequest",
+    "ResultPublisher",
+    "build_put_request",
+    "resolve_publish_target",
+    "resolve_publisher",
+]
diff --git a/cinoc/app/ANALYSE_COUCHE_6.md b/cinoc/app/ANALYSE_COUCHE_6.md
new file mode 100644
index 0000000000000000000000000000000000000000..0aafc4ccad18f9cc37d47cc9eaf2cd3869c67b44
--- /dev/null
+++ b/cinoc/app/ANALYSE_COUCHE_6.md
@@ -0,0 +1,263 @@
+# ANALYSE_COUCHE_6.md — `app` (Picarones → Cinoc)
+
+> **Type** : session d'ANALYSE (guide de portage durable). **Aucun code Cinoc écrit.**
+> **Couche 6 = `app`** (orchestration applicative) dans
+> `domain(1) ← formats(2) ← evaluation(3) ← pipeline(4) ← adapters(5) ← app(6) ← reports(7) ← interfaces(8)`.
+> **Source figée** : `Picarones/picarones/app/` — **27 fichiers, 6 648 LOC**.
+> **Méthode** : 4 sous-agents d'exploration en parallèle (un par cluster), synthèse + recoupement
+> personnel des points décisifs dans le code (couplages inter-couches, sécurité, code mort, shim).
+> **Deux natures de savoir** (CLAUDE.md §9) : **Partie 1** = analyse source (durable) ;
+> **Partie 2** = réorg cible (périssable, « à confirmer à la tranche »). Verdicts **PROVISOIRES**.
+
+---
+
+## PARTIE 0 — Vérification anti-contradiction (obligatoire)
+
+Aucune conclusion ne contredit `CLAUDE.md` ni une couche mergée (domain ✅, formats ✅ ; evaluation = plan). Au contraire, l'analyse **confirme** trois décisions déjà actées ailleurs :
+
+| Décision actée (où) | Confirmé dans le code Picarones |
+|---|---|
+| `RunSpec`/`StepSpec` → `domain`, **séparés du loader YAML** (backlog domain ; couche 1 §9) | `run_spec.py` mêle effectivement type déclaratif + loader YAML + résolution dotted-path → split nécessaire |
+| `_benchmark_*` : double format `BenchmarkResult↔RunResult` supprimé + calcul rapatrié en `evaluation/runner` (CLAUDE.md §8.1 ; couche 3 §6,§11,§12-4) | `_benchmark_converter` calcule (compute_metrics, hooks, aggregate) ; `_benchmark_ner` calcule du NER ; les deux vivent à tort en `app/` |
+| Persistance / store → `adapters/storage` (couche 3 §8) | `benchmark_service.persist()` écrit du JSONL ; `job_runner` parle à `adapters.storage.JobStore` |
+| Registre + factory + **découverte entry-points en `app`** (CLAUDE.md §3) | `registry_service.bootstrap_default_registries()` + `resolve_adapter_class()` + `_resolve_entity_extractor()` = les **germes** (mais enregistrement codé en dur, **pas** d'entry-points) |
+
+**Nuance importante à ne pas violer** (CLAUDE.md §3) : le **seul** point d'extension tiers = les **briques de pipeline**. Métriques, projecteurs, importeurs restent **internes**. Or `registry_service` mélange aujourd'hui registre de **métriques** (interne) et résolution d'**adapters** (extensible) — à scinder en cible.
+
+---
+
+# PARTIE 1 — ANALYSE DE LA SOURCE PICARONES (durable)
+
+## 1.1 Inventaire par cluster (27 fichiers / 6 648 LOC)
+
+| Cluster | Fichiers | LOC | Rôle global vérifié |
+|---|---|---|---|
+| **A. Colonne vertébrale + API** | `__init__.py`(27), `results.py`(24), `services/__init__.py`(96), `schemas/__init__.py`(49), `schemas/run_spec.py`(559) | **755** | Headers de paquet, façades de re-export, DTO YAML + loader |
+| **B. Shim double-format `_benchmark_*`** | `_benchmark_adapter_resolver.py`(313), `_benchmark_conversions.py`(255), `_benchmark_converter.py`(236), `_benchmark_helpers.py`(266), `_benchmark_ner.py`(189), `_benchmark_persistence.py`(55), `benchmark_service.py`(407) | **1 721** | Conversion `RunResult`↔`BenchmarkResult` (legacy) + calcul de métriques mal placé + runner v2 |
+| **C. Orchestration / jobs / reprise** | `run_orchestrator.py`(500), `run_orchestrator_execution.py`(310), `run_orchestrator_helpers/{__init__(55),builders(241),factories(119),legacy(308),loaders(43)}`, `_orchestrator_partial.py`(256), `job_runner.py`(267), `partial_store.py`(360) | **2 459** | `RunOrchestrator`, exécution asynchrone, reprise partielle (fingerprint SHA-256) |
+| **D. Services transverses** | `path_security.py`(454), `corpus_service.py`(541), `registry_service.py`(327), `python_helpers.py`(277), `dependencies.py`(114) | **1 713** | Sécurité chemins (invariant §12), import ZIP corpus, bootstrap registres, bridge Python, capture deps |
+
+**5 fichiers > 400 LOC** (budget Cinoc) : `run_spec`(559), `corpus_service`(541), `run_orchestrator`(500), `path_security`(454), `benchmark_service`(407).
+
+## 1.2 Couplages inter-couches & consommateurs réels
+
+**`app/` importe** (orientation **respectée** : que des couches internes ; **jamais** `reports/` ni `interfaces/`) :
+
+| Vers | Symboles principaux | Cluster qui couple |
+|---|---|---|
+| `domain` | errors, artifacts (ArtifactType/Artifact), corpus (CorpusSpec), documents (DocumentRef/GroundTruthRef), pipeline_spec, evaluation_spec, run_manifest | tous |
+| `evaluation` | **benchmark_result, metric_hooks, metric_result, metrics.{text,ner,over_normalization,search,alto_structural}, views, projectors, registry, corpus** | **B** (calcul/shim) + **D** (registry_service) |
+| `pipeline` | runner.CorpusRunner, types.{PipelineResult,RunContext}, run_result.RunResult, llm_pipeline_builder | B, C |
+| `formats` | alto.parser.parse_alto, text.normalization.get_builtin_profile | C (loaders), legacy |
+| `adapters` | storage.JobStore, ocr.base.BaseOCRAdapter, corpus._fallback_log | B, C |
+
+**Qui consomme `app/`** (grep hors `tests/`) — seulement **2 frontières** (sain) :
+
+| Consommateur | Importe | Usage |
+|---|---|---|
+| `picarones/__init__.py` (API top-level) | `RunSpec`, `RunSpecLoadError`, `load_run_spec_from_yaml`, `RunOrchestrator`, `OrchestrationResult`, `prepare_preset_args`, `run_result_to_benchmark_result` | API publique + ⚠️ auto-déclenche `register_default_metrics()` à l'import (effet de bord) |
+| `interfaces/cli/_workflows.py` | `RunOrchestrator`, `prepare_preset_args`, `run_result_to_benchmark_result` | `prepare → execute_preset → convertir en BenchmarkResult` |
+| `interfaces/web/{benchmark_utils,_path_helpers,security_paths}.py` | `path_security.*`, `RunOrchestrator`, `prepare_preset_args`, `run_result_to_benchmark_result` | endpoints `/api/benchmark/start`, sandbox chemins |
+
+> **Pattern consommateur clé** : CLI et web font tous deux
+> `RunResult → run_result_to_benchmark_result() → BenchmarkResult` **parce que les renderers
+> (couche 7) consomment `BenchmarkResult`, pas `RunResult`**. C'est la racine du double format.
+> En Cinoc (format unique `RunResult`, reports le lit direct) **cette conversion disparaît entièrement**.
+
+## 1.3 La dette centrale : double format de sortie + god-module éclaté
+
+- Picarones produit **deux** formats : `RunResult` (couche 4, `pipeline/run_result.py`) **et** `BenchmarkResult` (couche 3, `evaluation/benchmark_result.py`). Le cluster B est presque entièrement le **pont** entre les deux.
+- Historique vérifié : un god-module **`benchmark_runner.py` (~1 700 LOC)** a été éclaté en `_benchmark_*` lors d'une « Phase 6 audit code-quality ». **`benchmark_runner.py` n'existe plus** — toutes les docstrings qui le citent (≈ 15 fichiers) sont **périmées**. Idem `report_service.py` (cité, inexistant).
+- Réconciliation du « ~1 570 LOC de shim » (CLAUDE.md §8.1) : shim strict ≈ `_benchmark_converter`(236) + `_benchmark_helpers`(266) + `_benchmark_persistence`(55) + ~½ `_benchmark_conversions`(255) + ~½ `_benchmark_adapter_resolver`(313) ≈ **950–1 000 LOC**, + le pont `run_orchestrator_helpers/legacy.py`(308) + le mort `partial_store.py`(360, legacy) → **~1 600 LOC de code legacy/shim/double-format** au total. ✅ cohérent.
+
+## 1.4 Code mort & doc morte confirmés (recoupés dans le code)
+
+| Élément | Preuve | Note |
+|---|---|---|
+| **`partial_store.py` : `_load_partial`, `_save_partial_line`, `_delete_partial`, `partial_path_for_engine`** | **0 consommateur hors-tests** ; servaient `run_benchmark_via_service` | ⚠️ ~½ du fichier est **mort** depuis la suppression de cette fonction |
+| **`run_benchmark_via_service`** | **aucun `def`** dans `picarones/` ; ne subsistent que docstrings/commentaires (dont l'avis de dépréciation de `__init__.py`) | fonction **supprimée** mais « fantôme » partout en prose |
+| Réfs à **`benchmark_runner.py`** (~15 fichiers) | `find` → inexistant | doc morte (god-module éclaté) |
+| Réfs à **`_benchmark_execution.py`** (factories/builders) | inexistant | pattern copié-commenté, pas importé |
+| Réf à **`report_service.py`** (`services/__init__` docstring) | inexistant | doc morte |
+| `run_orchestrator._build_pipelines`/`_load_corpus` (staticmethods l.472-494) | wrappers qui ne délèguent qu'aux fonctions globales | conservés **pour un test** uniquement |
+
+## 1.5 Bugs / fragilités notables (vérifiés)
+
+| Fichier | Problème | Gravité |
+|---|---|---|
+| `run_orchestrator.py` | `progress_callback`/`cancel_event` **acceptés mais ignorés** sur le chemin `bench.run()` (consommés seulement si `partial_dir`) — le caller croit son callback branché | moyen (silencieux) |
+| `run_orchestrator_execution.py` | appelle `BenchmarkService._evaluate_document_in_views()` (**privée**) pour recalculer les vues des docs repris | fragile (couplage privé) |
+| `factories.py` | `counter_state` (lock+dict) partagé par closure ; OK seulement si chaque run a une factory fraîche | risque multithread |
+| `partial_store.py` / `_orchestrator_partial.py` | fingerprint = path+size+mtime (pas de hash de contenu) → ne détecte pas une modif d'image à id constant | acceptable (documenté) |
+| `run_spec.py` | 9 champs « Phase B » (`char_exclude`, `normalization_profile`, `partial_dir`, `entity_extractor`, `profile`, `output_json`, `timeout_seconds_per_doc`, `max_in_flight`, `poll_interval_seconds`) **validés mais à demi-consommés** (migration B1→B2.x inachevée) | dette de migration |
+| `python_helpers.py` | `_dummy_pipeline_yaml()` = pipeline **bidon** juste pour satisfaire `RunSpec.pipelines (min_len=1)` en mode preset ; `adapter_kwargs` vide → `RunManifest` non reproductible sans le code Python | hack |
+| `picarones/__init__.py` | `register_default_metrics()` **auto-déclenché à l'import** | anti-pattern (interdit Cinoc §7) |
+
+## 1.6 Verdicts par fichier — **PROVISOIRES — à confirmer au build**
+
+> Légende : **GARDER** (concept à reporter ~tel quel) · **MODIFIER** (concept gardé, forme à revoir/dégonfler/splitter) · **DÉPLACER** (change de couche) · **SUPPRIMER**.
+> Le verdict décrit l'intention **pour le port Cinoc** ; les faits (rôle/conso) sont, eux, durables.
+
+### Cluster A — colonne vertébrale (755 LOC)
+| Fichier | LOC | Rôle réel vérifié | Verdict PROVISOIRE + raison |
+|---|---|---|---|
+| `__init__.py` | 27 | header paquet, `__all__` vide, sans effet de bord | **GARDER** — réécrire docstring, purger « 6 P0 du S1 » |
+| `results.py` | 24 | **shim** re-export `RunResult/RunDocumentResult/ReportRenderer` ← `pipeline/run_result` | **SUPPRIMER** — en Cinoc `RunResult` vit en `evaluation/result.py`, reports le lit direct (zéro shim §5.1) |
+| `services/__init__.py` | 96 | façade re-export (dont le converter `run_result_to_benchmark_result`) | **MODIFIER** — `__init__` mince §7 ; ne pas ré-exporter de shim |
+| `schemas/__init__.py` | 49 | façade re-export `run_spec` | **MODIFIER/fusionner** avec le split ci-dessous |
+| `schemas/run_spec.py` | 559 | `RunSpec`/`StepSpec`/`PipelineSpecYaml` (DTO YAML, 7 validators) + `load_run_spec_from_yaml` + `resolve_adapter_class` (importlib dotted-path) + `CANONICAL_VIEW_NAMES` | **DÉPLACER (split)** — type déclaratif `RunSpec`/`StepSpec` → **`domain`** (backlog confirmé) ; **loader YAML + `resolve_adapter_class`** → restent **`app`** ; **purger les 9 champs Phase B** (implémenter pour de vrai ou retirer) ; budget <400 |
+
+### Cluster B — shim double-format (1 721 LOC)
+| Fichier | LOC | Rôle réel vérifié | Verdict PROVISOIRE + raison |
+|---|---|---|---|
+| `benchmark_service.py` | 407 | **runner v2 propre** : orchestre `CorpusRunner`(4) + `view_executor`(3), assemble `RunResult`, persiste JSONL ; 0 import `_benchmark_*` | **MODIFIER (split)** — *pas « garder tel quel »* : assemblage `RunResult` + éval vues → **`evaluation/runner`** (3) ; persistance JSONL → **`adapters/storage`** (5) ; il ne reste en `app` qu'une coquille d'orchestration mince |
+| `_benchmark_converter.py` | 236 | cœur du shim `RunResult→BenchmarkResult` ; **calcule** CER/WER + hooks + agrégation | **SUPPRIMER** — double format éliminé ; le calcul est déjà en `evaluation/`, juste appelé d'ici |
+| `_benchmark_helpers.py` | 266 | extracteurs de texte + fingerprint pour le converter | **SUPPRIMER** — récupérer au plus 1-2 extracteurs `Artifact→texte` utiles → `pipeline`/`evaluation` |
+| `_benchmark_persistence.py` | 55 | `asdict(BenchmarkResult)→JSON` | **SUPPRIMER** — pas de `BenchmarkResult` ; persistance `RunResult` → `adapters/storage` |
+| `_benchmark_ner.py` | 189 | **calcule** NER (`compute_ner_metrics`) puis l'attache au `BenchmarkResult` | **DÉPLACER → `evaluation`** — le NER est une métrique (couche 3) |
+| `_benchmark_conversions.py` | 255 | `Corpus`(3, chargé) → `CorpusSpec`(1, déclaratif) + `Document→DocumentRef` ; `_safe_doc_id` (normalisation) | **MODIFIER** — pont qui dépend du modèle corpus Cinoc (à confirmer) ; **garder la normalisation `doc_id`** (utile, réutilisée par NER + corpus_service) |
+| `_benchmark_adapter_resolver.py` | 313 | `engine(BaseOCRAdapter / OCRLLMPipelineConfig) → PipelineSpec` + `build_adapter_resolver` (`name→StepExecutor`) | **MODIFIER** — le **resolver `name→executor` = germe du registre/factory** (garder, → registre `app`) ; la conversion `engine→spec` legacy disparaît (en Cinoc on déclare `PipelineSpec` direct) |
+
+### Cluster C — orchestration / jobs / reprise (2 459 LOC)
+| Fichier | LOC | Rôle réel vérifié | Verdict PROVISOIRE + raison |
+|---|---|---|---|
+| `run_orchestrator.py` | 500 | `RunOrchestrator.execute()` **et** `execute_preset()` → `OrchestrationResult` ; orchestre vraiment (corpus→registres→pipelines→service) | **MODIFIER** — concept d'orchestrateur `app` à **garder** ; dégonfler : fusionner `execute`/`execute_preset` (le 2ᵉ existe pour les engines en mémoire legacy), retirer la persistance `output_json` legacy + les callbacks « acceptés-ignorés » ; budget <400 |
+| `run_orchestrator_execution.py` | 310 | `execute_with_partial()` (reprise par pipeline) ; recalcule les vues via méthode **privée** du service | **MODIFIER/différer** — feature réelle mais couplage fragile ; à reconcevoir proprement **à la tranche reprise** (≠ MVP) |
+| `run_orchestrator_helpers/__init__.py` | 55 | re-export pour préserver l'API historique | **SUPPRIMER** — pas d'API historique à préserver (zéro shim) |
+| `…/builders.py` | 241 | `_load_corpus`/`_build_pipelines`/`_build_views`/`_build_benchmark_service` | **MODIFIER** — helpers d'assemblage à **garder** mais replier dans l'orchestrateur/registre |
+| `…/factories.py` | 119 | `_default_gt_factory`/`_default_inputs_factory`/`_make_context_factory` (closure progress, thread-safe) | **GARDER (concept)** — frontière « doc → artefacts » + `RunContext` par doc |
+| `…/legacy.py` | 308 | pont `BenchmarkResult` : `_PipelineEngineProxy`, `_resolve_entity_extractor` (dotted-path→callable NER), `_persist_legacy_benchmark_json` | **SUPPRIMER** — `BenchmarkResult` disparu ; **garder le concept** `_resolve_entity_extractor` = résolution de module tiers (→ entry-points `app`) |
+| `…/loaders.py` | 43 | `_filesystem_payload_loader` (disque→payload ALTO/texte) + `_kwargs_signature` | **GARDER (concept)** — chargement payload = I/O (`app` ou `adapters/storage`) |
+| `_orchestrator_partial.py` | 256 | reprise **par pipeline** (fingerprint, load/append/delete/filter) ; système **vivant** | **MODIFIER** — devenir le **seul** mécanisme de reprise (différer à sa tranche) |
+| `job_runner.py` | 267 | `JobRunner` thread daemon + `JobStore` ; annulation **best-effort non branchée** | **GARDER (concept)** pour `serve` — mais brancher une vraie annulation via `Deadline`/`RunControl` (couche 4, invariant §12) ; couple à `adapters/storage` |
+| `partial_store.py` | 360 | reprise **par engine** (legacy) ; **~½ mort** ; seuls `compute_run_fingerprint`+`_partial_path` vivants | **SUPPRIMER** — garder seulement le **concept fingerprint**, fusionné dans le mécanisme partial unique |
+
+### Cluster D — services transverses (1 713 LOC)
+| Fichier | LOC | Rôle réel vérifié | Verdict PROVISOIRE + raison |
+|---|---|---|---|
+| `path_security.py` | 454 | **invariant §12** : `validated_path` (resolve+`is_relative_to`), `WorkspaceManager` (sandbox/session, anti-symlink post-mkdir), `safe_report_name`, `validated_prompt_filename` | **GARDER** — porter **fidèlement** (→ package `security/` §8.5) ; dédupliquer `prompt_filename`/`report_name`, moderniser (`is_relative_to` natif 3.11), splitter <400 |
+| `corpus_service.py` | 541 | import ZIP sandboxé (anti zip-bomb/traversal/symlink) + appariement image/GT (`.gt.alto.xml`…) → `CorpusSpec` | **GARDER/DÉPLACER ?** — défenses à garder ; place à confirmer (`app` vs `adapters/corpus` qui porte déjà IIIF/Gallica/…) ; splitter <400 (extraction · catalogage · appariement) |
+| `registry_service.py` | 327 | `bootstrap_default_registries()` (boucle **codée en dur** sur métriques+projecteurs), `RegistriesBundle` ; **pas** d'entry-points | **MODIFIER (scinder)** — registre **métriques/projecteurs** = interne (couche 3) ; registre **modules de pipeline** + **découverte entry-points** (`cinoc.modules`) + `register()` = couche `app` (CLAUDE.md §3) |
+| `python_helpers.py` | 277 | `prepare_preset_args`/`PresetArgs` : bridge engines-en-mémoire→`RunSpec` ; `_dummy_pipeline_yaml` (hack) | **SUPPRIMER/reconcevoir** — existe pour les objets engine legacy ; en Cinoc on déclare `PipelineSpec` direct ; si une API Python est voulue, la rebâtir proprement |
+| `dependencies.py` | 114 | `capture_dependencies_lock` + `capture_system_binaries_lock` → `RunManifest` (reproductibilité §12) ; pur, stateless | **GARDER** — invariant repro ; étendre la table binaires au-delà de Tesseract (starter pack) ; place `app` vs `adapters` à confirmer |
+
+---
+
+# PARTIE 2 — RÉORGANISATION CIBLE Cinoc (périssable — à confirmer à la tranche)
+
+> ⚠️ Périssable. Le contact du code amont (evaluation/pipeline/adapters non encore mergés) corrigera ces formes.
+> **On ne construit PAS la couche `app` de haut en bas** : elle **apparaît par tranches verticales**, au fur et à mesure que `interfaces` en a besoin.
+
+## 2.1 Rôle d'`app` en Cinoc = **coquille mince** (les deux axes, CLAUDE.md §2)
+
+`app` orchestre, **ne calcule jamais** (« l'app appelle, ne calcule plus »). Elle :
+1. charge/valide une spec (`RunSpec`) et résout les modules par nom ;
+2. appelle `pipeline`(4) puis `evaluation`(3) ; l'assemblage de `RunResult` est fait **par `evaluation`** ;
+3. délègue la persistance à `adapters/storage`(5) et le rendu à `reports`(7, via callable injecté) ;
+4. applique les invariants transverses : **sécurité chemins** (§12), **reproductibilité** (deps/binaires → `RunManifest`), **annulation/timeout** (`Deadline`/`RunControl`).
+
+| Axe | Contenu `app` | Quand |
+|---|---|---|
+| **Enveloppe (plein-scope, maintenant)** | contrat d'orchestration ; **registre de modules + factory + découverte entry-points** (`cinoc.modules`) + `register()` ; `RunSpec` (en `domain`) + loader YAML (en `app`) ; sécurité chemins | conçu d'office |
+| **Surface (incrémentale, élaguée)** | quels workflows CLI (`run/report/compare/demo/serve`), quels importeurs branchés, le job-runner web, la reprise partielle | une tranche à la fois |
+
+## 2.2 Où va chaque concept Picarones (table de transfert)
+
+| Concept Picarones (app) | Destination Cinoc | Note |
+|---|---|---|
+| `RunSpec`/`StepSpec` (déclaratif) | **`domain`** (couche 1) | frère de `PipelineSpec`/`EvaluationSpec` ; backlog confirmé |
+| `load_run_spec_from_yaml` + `resolve_adapter_class` | **`app`** (loader/résolution = I/O + import dynamique) | « séparer du loader YAML » |
+| `RunOrchestrator` (mince) + builders/factories | **`app`** | un seul `execute`, pas de `execute_preset` |
+| assemblage `RunResult` + éval vues (`benchmark_service`) | **`evaluation/runner`** (couche 3) | RunResult = sortie d'évaluation |
+| persistance JSONL / store longitudinal | **`adapters/storage`** (couche 5) | tidy store (couche 3 §8) |
+| `_benchmark_ner` (calcul NER) | **`evaluation/metrics`** (couche 3) | NER = métrique |
+| `path_security` | **`app/security/`** (package, §8.5) | invariant §12, port fidèle |
+| `corpus_service` (import ZIP + appariement) | **`app`** ou **`adapters/corpus`** | à confirmer (adapters/corpus porte déjà les importeurs) |
+| `dependencies` (capture deps/binaires) | **`app`** (ou `adapters`) | reproductibilité |
+| `registry_service` (modules de pipeline) | **`app`** (+ entry-points) | seul point d'extension tiers |
+| `job_runner` | **`app`** | pour `serve` ; annulation réelle via `RunControl` |
+| `_orchestrator_partial` (reprise) | **`app`** (1 seul système) | à la tranche reprise |
+| `results.py`, `legacy.py`, `_benchmark_{converter,helpers,persistence}`, `partial_store` (mort), `python_helpers` (preset), `…helpers/__init__` re-export | **SUPPRIMÉ** | shim/double-format/legacy/mort |
+
+## 2.3 Esquisse d'arborescence cible (à confirmer)
+
+```
+cinoc/app/
+├── __init__.py            mince, zéro effet de bord (pas de register_* auto)
+├── orchestrator.py        RunOrchestrator unique → appelle pipeline + evaluation, assemble via eval
+├── spec_loader.py         load_run_spec_from_yaml + resolve dotted-path/entry-point (RunSpec vit en domain)
+├── modules/               registre + factory + découverte entry-points (cinoc.modules) + register()
+├── security/              validated_path, WorkspaceManager, safe_* (invariant §12)
+├── corpus_import.py       (?) import ZIP + appariement image/GT → CorpusSpec  [ou adapters/corpus]
+├── reproducibility.py     (?) capture deps + binaires → RunManifest            [ou adapters]
+└── jobs.py                JobRunner (serve) + annulation coopérative
+```
+*(Tous < 400 LOC ; `corpus_import`/`reproducibility` peut-être en `adapters` — décidé à la tranche.)*
+
+## 2.4 Apparition par tranches (≠ couche complète)
+
+| Tranche (cf. couche 3 §15) | Ce que `app` matérialise alors |
+|---|---|
+| **1. Squelette `demo`** (corpus pré-calculé → CER → RunResult → HTML → CLI) | orchestrateur **minimal** + registre de modules (1 module `precomputed`) + `RunSpec` minimal. Prouve que la coquille tient. |
+| **2. Épaississement texte** (`run`, profils, `compare`) | loader YAML complet, sécurité chemins, capture repro, plus de modules au registre |
+| **3. `serve`** | `JobRunner` + sandbox session + annulation |
+| **4. reprise partielle** | mécanisme partial unique (fingerprint), si justifié par un consommateur réel |
+
+---
+
+# PARTIE 3 — RISQUES DE TRANSFERT & DETTES (comment détecter / désamorcer)
+
+| # | Risque / dette | Détection | Désamorçage |
+|---|---|---|---|
+| **R1** | **Réintroduire le double format** en gardant un `BenchmarkResult` ou un converter « le temps de migrer » | test `no-legacy-imports` (interdire `benchmark_result`, `run_result_to_benchmark_result`) ; 1 seul type de sortie | tout consommateur lit `RunResult` direct ; **reports + web + compare migrés en bloc** (couche 3 §12-4 : ~30 conso) |
+| **R2** | **Calcul qui reste en `app`** (NER, hooks, agrégation) | `test_layer_dependencies` : `app` n'importe **pas** `evaluation/metrics*` pour calculer ; revue « app appelle, ne calcule pas » | NER/hooks/agrégation → `evaluation/runner` |
+| **R3** | **Mélanger registre interne (métriques) et registre extensible (modules)** → ouvrir une prise de trop | revue : entry-points `cinoc.modules` **uniquement** pour briques de pipeline (CLAUDE.md §3) | deux registres distincts ; métriques/projecteurs non pluggables |
+| **R4** | **Sécurité chemins affaiblie au portage** (path-traversal/symlink/zip-bomb) | tests obligatoires : `..`, chemin absolu, symlink, zip-bomb, octet nul **doivent échouer** ; `validated_path` partout | porter `path_security` + `corpus_service._extract_safely` **fidèlement**, tester d'abord |
+| **R5** | **Champs de spec à demi-câblés** (les 9 « Phase B ») recopiés tels quels | revue : tout champ `RunSpec` a un consommateur réel en CI (« pas de conso = supprimé ») | n'ajouter un champ que quand sa tranche le consomme |
+| **R6** | **Reproductibilité perdue** (mode preset Picarones perdait `adapter_kwargs`) | golden `RunManifest` byte-stable ; test : run reproductible **depuis le manifest seul** | pas de chemin « engines en mémoire » ; toute brique déclare `version` (§3) |
+| **R7** | **Annulation/timeout fantômes** (Picarones : callbacks acceptés-ignorés, cancel best-effort) | test : un `Deadline` dépassé **interrompt** ; annulation observable | brancher `Deadline`/`RunControl` (couche 4) dès `job_runner` |
+| **R8** | **Doc/commentaires périmés recopiés** (`benchmark_runner.py`, `report_service.py`, `run_benchmark_via_service`, sprints S/A/Phase) | grep anti-narration ; `test_no_legacy_imports` | « garder le pourquoi, jeter la datation » (couche 2 MIG-3) |
+| **R9** | **Code mort transféré** (½ `partial_store`, staticmethods test-only, `_dummy_pipeline_yaml`) | couverture CI ; « pas de conso = supprimé » | ne pas porter ; reprise = 1 seul système |
+| **R10** | **Budgets explosés** (5 fichiers >400) | `test_file_budgets` strict | splitter dès l'écriture (orchestrateur / sécurité / corpus) |
+| **R11** | **Effet de bord à l'import** (`register_default_metrics()` auto) | `test_no_side_effect_imports` | enregistrement **explicite, idempotent, testable** (§7) |
+
+---
+
+## Résumé pour la future session de CONSTRUCTION (3–5 points)
+
+1. **`app` = coquille d'orchestration mince qui NE CALCULE PAS.** Elle appelle `pipeline`(4) puis `evaluation`(3) ; l'assemblage de `RunResult` se fait **dans `evaluation/runner`**, la persistance dans **`adapters/storage`**. Le seul « gros » runner sain de Picarones (`benchmark_service.py`) se **scinde** entre ces couches — ce n'est pas un « garder tel quel ».
+2. **Tout le cluster `_benchmark_*` + `results.py` + `legacy.py` + ½ `partial_store` + `python_helpers`(preset) = SUPPRIMÉ** : c'est le double format `BenchmarkResult↔RunResult` (+ un god-module éclaté, + une fonction `run_benchmark_via_service` déjà morte qui laisse du code orphelin). En Cinoc, `RunResult` est unique et **les reports le lisent direct** → la conversion n'existe plus. Le **NER** part en `evaluation` (c'est une métrique).
+3. **Deux germes d'enveloppe à concevoir plein-scope, sans les remplir** : (a) `RunSpec`/`StepSpec` **en `domain`** + loader YAML/résolution **en `app`** (split « séparer du loader ») ; (b) **registre de modules de pipeline + factory + découverte entry-points** (`cinoc.modules`) — **uniquement** pour les briques de pipeline, jamais les métriques/importeurs.
+4. **Invariants à porter fidèlement et à tester EN PREMIER** : sécurité chemins (`validated_path`/`WorkspaceManager`/anti zip-bomb-traversal-symlink, §12), reproductibilité (`dependencies` → `RunManifest`), annulation coopérative (`Deadline`/`RunControl` — Picarones ne la branche pas vraiment, à corriger).
+5. **Ne pas bâtir `app` en bloc** : elle naît par tranches. Tranche 1 (`demo`) = orchestrateur minimal + registre (1 module `precomputed`) + `RunSpec` minimal — juste assez pour prouver que la coquille tient. Budgets <400, zéro shim, zéro effet de bord à l'import, zéro champ de spec sans consommateur.
+
+## DoD vivante (couche 6) — **autorité de détail** ; le `MIGRATION_PLAN.md` indexe
+
+> **T8 (D-066)** : l'orchestrateur collecte un `DocumentUsage` par (pipeline × document) réussi et le passe à `evaluate_run` → `RunResult.usage` trié (déterministe). Preuve : `tests/app/test_orchestrator.py::test_run_result_carries_sorted_usage`.
+
+> **T14 (D-072)** : builders `kraken`/`mistral_ocr` + sondes `engine_statuses` (SDK/clé) + `_OCR_ENGINES` étendu — matrice CLI/web alignée. Preuves : `tests/app/test_module_registry.py` · `test_engines.py`.
+
+> **T15 (D-073)** : `+ resume.py` (`ResumeStore` + `unit_key`) — cache d'exécution par empreinte, branché à l'orchestrateur (`resume_store=`) et à la CLI (`run --resume-dir`) ; évaluation toujours recalculée. Preuves : `tests/app/test_resume.py`.
+
+> Tri-état : `[x]` fait **+ preuve** · `[ ]` à faire · `[~]` différé/réserve + raison.
+> Maj dans le **même commit** que le code. **Statut : ✅ T2** — orchestrateur (+ **workspace** par run) + registre/factory + `RunSpec` + **loader YAML** + **sécurité chemins** verts. **+ T6 découverte entry-points** : `discover_plugins` (groupe `cinoc.modules`, builder tiers enregistré comme le socle ; **fail-closed mode public** ; câblé CLI + web). **Prouvé de bout en bout** : loader injecté + **vrai `EntryPoint`** (résolution dotted-path) + **paquet réellement pip-installé auto-découvert** (`importlib.metadata`, test `slow` isolé). — *preuves : `tests/app/test_plugin_discovery.py`, `tests/app/test_plugin_install.py` + plugins de réf. `tests/fixtures/sample_segmenter_plugin.py` & `…/sample_plugin_pkg/`*. **+ T7 `history.py`** : trait d'union `RunResult`→`HistoryStore` — `records_from_run` aplatit les agrégats par pipeline/vue en `HistoryRecord` (métriques `None` écartées), `record_run` persiste. La connaissance de la forme `RunResult` vit **ici** (couche 6), pas dans le store (couche 5 = persistance pure). — *preuves : `tests/app/test_history.py`*. **Câblage auto livré (S6, D-046)** : `JobRunner` prend un `history_store` optionnel et appelle `record_run` après chaque run terminé (best-effort, comme `publish`) → **différé D-042 levé** ; `create_app` instancie un `HistoryStore` sous `catalog_dir`. — *preuves : `tests/app/test_history_recording.py`*. Différé : reprise partielle, deps-lock (hors CI).
+
+**Enveloppe :**
+- [x] `app` = **coquille mince qui NE CALCULE PAS** (appelle pipeline puis `evaluate_run` ; l'assemblage métrique vit en `evaluation`). — *preuve : `test_app_imports_are_allowed` ; l'orchestrateur délègue, n'importe aucune `evaluation.metrics*`*
+- [x] **Registre + factory** (`name→Module` via builder enregistré, convention `<kind>:<label>`) — socle en dur, **seul** point d'extension. — *preuve : `test_module_registry` (build `precomputed` ; kind inconnu ; kwargs incohérents)*
+- [ ] Découverte **entry-points `cinoc.modules`** + `register()` tiers. — *T6*
+- [x] `RunSpec` → `domain` (compose `PipelineSpec` **directement**, sans `StepSpec` — D-010) ; orchestrateur assemble `RunManifest` (`adapter_kwargs` capturés). — *preuve : `test_run_spec` + `test_orchestrator`*
+- [x] **loader YAML** (`RunSpec.model_validate`, `extra="forbid"`) + **sécurité chemins** (`validated_path` : rejet `..`/absolu-hors-base/octet-nul/symlink, §12 ; **GT `must_exist=True`** → erreur typée au chargement, pas d'`OSError` opaque en run) — **pas** de `resolve_adapter_class` (le registre résout `name→Module`, D-010). — *preuve : `test_loader` (+ GT manquante rejetée) + `test_security`*
+- [x] **Isolation des workspaces par pipeline** (sous-dossier dédié) : deux pipelines partageant un `adapter_name` **écrivain** (ex. `openai:gpt`) n'écrasent plus mutuellement leur sortie → zéro contamination inter-pipelines. — *preuve : `test_orchestrator::test_pipelines_sharing_a_writer_do_not_contaminate`* — **corrigé à l'audit T3.**
+- [x] **`RunManifest.module_versions`** : version déclarée de chaque module exécuté capturée (R-2). — *preuve : `test_orchestrator::test_manifest_captures_module_versions`.* `[~]` deps/binaires lock (`dependencies_lock`/`system_binaries_lock`, dont version **binaire** tesseract) : capture live, **différée** (hors CI).
+
+**Garde-fous :**
+- [x] `no_side_effect_imports` (**pas de `register_default_*()` auto** ni singleton module-level ; `register_default_modules`/`metrics` explicites) · `file_budgets` · `layer_dependencies`. — *preuve : suite archi verte*
+
+**Validation par tranche :** `MIGRATION_PLAN.md` §3 — orchestrateur minimal + registre 1 module + `RunSpec` minimal (T1) · sécurité chemins testée d'abord + repro (T2) · entry-points + plugin (T6).
+
+- [~] **Supprimé** : tout `_benchmark_*` (double format) · `results.py`/`legacy.py` (shim) · ½ `partial_store` mort · `python_helpers` (preset). **Différé** : reprise partielle (1 seul mécanisme, à sa tranche).
+
+---
+
+*(Tous les verdicts ci-dessus sont **PROVISOIRES — à confirmer au build** ; le contact du code amont non encore mergé prévaut.)*
diff --git a/cinoc/app/__init__.py b/cinoc/app/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..067743443564aae0c82f068ba837aa6b97f4de07
--- /dev/null
+++ b/cinoc/app/__init__.py
@@ -0,0 +1,34 @@
+"""Couche 6 — ``app`` : orchestration + registre de modules (coquille mince).
+
+``app`` câble les couches internes et **ne calcule pas** : il appelle pipeline
+puis evaluation. ``__init__`` mince, sans effet de bord.
+"""
+
+from __future__ import annotations
+
+from cinoc.app.loader import RunSpecError, load_run_spec
+from cinoc.app.modules.registry import (
+    ModuleRegistry,
+    ModuleResolutionError,
+    register_default_modules,
+)
+from cinoc.app.orchestrator import OrchestrationError, run
+from cinoc.app.results import RunResultError, dump_run_result, load_run_result
+from cinoc.app.security import PathSecurityError, validated_path
+from cinoc.app.versioning import resolve_code_version
+
+__all__ = [
+    "ModuleRegistry",
+    "ModuleResolutionError",
+    "OrchestrationError",
+    "PathSecurityError",
+    "RunResultError",
+    "RunSpecError",
+    "dump_run_result",
+    "load_run_result",
+    "load_run_spec",
+    "register_default_modules",
+    "resolve_code_version",
+    "run",
+    "validated_path",
+]
diff --git a/cinoc/app/alto_store.py b/cinoc/app/alto_store.py
new file mode 100644
index 0000000000000000000000000000000000000000..25803def231173567ab190bea4ee7f75dc39ad87
--- /dev/null
+++ b/cinoc/app/alto_store.py
@@ -0,0 +1,72 @@
+"""Persistance des exports **ALTO XML** d'un run (couche 6).
+
+Un run avec ``Competitor.alto`` produit un artefact ``ALTO_XML`` par document que
+le ``RunResult`` (métriques scalaires) **ne porte pas** et que le workspace
+temporaire du run **détruit** à la fin. Ce store le **persiste**, indexé par
+``run_id``, pour qu'un endpoint web le restitue en archive ZIP — la forme
+ré-importable dans un outil de relecture (eScriptorium, Transkribus).
+
+Un seul chemin : le sink du ``JobRunner`` y dépose les ALTO produits ; le routeur
+des rapports les rezippe à la demande. Pas de second format, pas de cache pré-écrit.
+"""
+
+from __future__ import annotations
+
+import io
+import threading
+import zipfile
+from pathlib import Path
+
+from cinoc.app.security import PathSecurityError, safe_stem, validated_path
+
+
+class AltoStore:
+    """Registre disque des exports ALTO (``base_dir/<run>/<entrée>.alto.xml``)."""
+
+    def __init__(self, base_dir: Path) -> None:
+        self._base = base_dir
+        self._lock = threading.Lock()
+
+    def save(
+        self, run_id: str, document_id: str, pipeline_name: str, xml: bytes
+    ) -> None:
+        """Persiste un ALTO XML pour ``(run_id, pipeline_name, document_id)``."""
+        with self._lock:
+            folder = self._base / safe_stem(run_id)
+            folder.mkdir(parents=True, exist_ok=True)
+            stem = safe_stem(f"{pipeline_name}::{document_id}")
+            (folder / f"{stem}.alto.xml").write_bytes(xml)
+
+    def has(self, run_id: str) -> bool:
+        """``True`` si au moins un ALTO est persisté pour ce run."""
+        folder = self._folder(run_id)
+        if folder is None or not folder.is_dir():
+            return False
+        return any(folder.glob("*.alto.xml"))
+
+    def archive(self, run_id: str) -> bytes | None:
+        """Archive ZIP **déterministe** (entrées triées) des ALTO du run, ou ``None``.
+
+        ``None`` si aucun ALTO n'est persisté (run sans export) → le routeur répond
+        ``404``. Les octets XML ne sont jamais altérés (ré-import fidèle)."""
+        folder = self._folder(run_id)
+        if folder is None or not folder.is_dir():
+            return None
+        files = sorted(folder.glob("*.alto.xml"))
+        if not files:
+            return None
+        buffer = io.BytesIO()
+        with zipfile.ZipFile(buffer, "w", zipfile.ZIP_DEFLATED) as archive:
+            for path in files:
+                archive.writestr(path.name, path.read_bytes())
+        return buffer.getvalue()
+
+    def _folder(self, run_id: str) -> Path | None:
+        """Dossier du run, **chemin validé** (anti path-traversal sur le run_id URL)."""
+        try:
+            return validated_path(safe_stem(run_id), self._base)
+        except PathSecurityError:
+            return None
+
+
+__all__ = ["AltoStore"]
diff --git a/cinoc/app/corpus_import.py b/cinoc/app/corpus_import.py
new file mode 100644
index 0000000000000000000000000000000000000000..88d71fb6200aeb1e45e6d148c69d3beb1d235e0b
--- /dev/null
+++ b/cinoc/app/corpus_import.py
@@ -0,0 +1,449 @@
+"""Matérialisation d'un corpus IIIF en ``CorpusSpec`` (couche 6).
+
+Sépare **localiser** (l'adapter ``IIIFImporter`` parle IIIF) de **matérialiser**
+(ici : télécharger les images sous ``dest`` validé, fabriquer le ``CorpusSpec``).
+Sortie **unique** : un ``CorpusSpec`` (jamais un dict-manifeste), prêt pour un run.
+
+Images seules → ``DocumentRef`` sans vérité-terrain : le corpus est OCR-able mais
+non scoré tant qu'une GT n'est pas appariée (cf. ``adapters/corpus/iiif.py``).
+
+``importer`` et ``download`` sont **injectables** → le chemin de matérialisation
+se teste sans réseau ; le test ``live`` couvre le vrai fetch IIIF.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from collections.abc import Callable, Iterator
+from pathlib import Path
+from typing import Protocol
+from urllib.parse import urlsplit
+
+from cinoc.adapters.corpus import _http
+from cinoc.adapters.corpus.escriptorium import DEFAULT_LAYER, EScriptoriumImporter
+from cinoc.adapters.corpus.gallica import GALLICA_BASE, GallicaImporter, vue_number
+from cinoc.adapters.corpus.huggingface import (
+    HFPage,
+    snapshot_curated_layout,
+    stream_pages,
+)
+from cinoc.adapters.corpus.iiif import IIIFImage, IIIFImporter
+from cinoc.app.security import PathSecurityError, validated_path
+from cinoc.domain.artifacts import ArtifactType
+from cinoc.domain.corpus import CorpusSpec
+from cinoc.domain.documents import DocumentRef, GroundTruthRef
+from cinoc.domain.errors import CinocError
+
+logger = logging.getLogger(__name__)
+
+#: Extensions d'image reconnues pour nommer le fichier téléchargé.
+_IMAGE_EXT = frozenset({".png", ".jpg", ".jpeg", ".tif", ".tiff", ".jp2"})
+_DEFAULT_EXT = ".jpg"
+
+ImageFetcher = Callable[[str], "tuple[IIIFImage, ...]"]
+OcrFetcher = Callable[[int], str]
+#: Streame les pages d'un dataset HF conforme. Injectable (test sans ``datasets``).
+HFStreamer = Callable[..., "Iterator[HFPage]"]
+
+
+class Downloader(Protocol):
+    """Télécharge ``url`` vers ``dest`` ; ``headers`` optionnels (auth même-hôte)."""
+
+    def __call__(
+        self, url: str, dest: Path, *, headers: dict[str, str] | None = None
+    ) -> None: ...
+
+
+class CorpusImportError(CinocError):
+    """L'import d'un corpus distant n'a produit aucune page exploitable."""
+
+
+def _image_ext(image_url: str) -> str:
+    suffix = Path(urlsplit(image_url).path).suffix.lower()
+    return suffix if suffix in _IMAGE_EXT else _DEFAULT_EXT
+
+
+def _download_image(
+    fetch_bytes: Downloader,
+    image_url: str,
+    doc_id: str,
+    dest_dir: Path,
+    *,
+    headers: dict[str, str] | None = None,
+) -> str:
+    """Télécharge une image sous ``dest_dir`` (chemin validé) ; renvoie l'URI local.
+
+    ``headers`` (ex. ``Authorization``) n'est fourni que pour un média **même-hôte**
+    (cf. ``import_escriptorium_corpus``) ; les imports publics (IIIF/Gallica)
+    passent ``None``.
+    """
+    target = validated_path(f"{doc_id}{_image_ext(image_url)}", dest_dir)
+    fetch_bytes(image_url, target, headers=headers)
+    return str(target)
+
+
+def import_iiif_corpus(
+    manifest_url: str,
+    dest: str | Path,
+    *,
+    name: str,
+    limit: int | None = None,
+    importer: IIIFImporter | None = None,
+    download: Downloader | None = None,
+) -> CorpusSpec:
+    """Importe un manifeste IIIF → images téléchargées sous ``dest`` → ``CorpusSpec``.
+
+    ``limit`` borne le nombre de pages (les premières). ``dest`` est créé au besoin ;
+    chaque fichier passe par ``validated_path`` (anti-traversal).
+    """
+    fetch_images: ImageFetcher = (importer or IIIFImporter()).fetch_images
+    fetch_bytes: Downloader = download or _http.download
+    dest_dir = Path(dest)
+    dest_dir.mkdir(parents=True, exist_ok=True)
+
+    images = fetch_images(manifest_url)
+    if limit is not None:
+        images = images[:limit]
+    if not images:
+        raise CorpusImportError(
+            f"aucune image exploitable dans le manifeste {manifest_url!r}."
+        )
+
+    documents: list[DocumentRef] = []
+    for index, image in enumerate(images, start=1):
+        doc_id = f"page_{index:04d}"
+        image_uri = _download_image(fetch_bytes, image.image_url, doc_id, dest_dir)
+        documents.append(
+            DocumentRef(id=doc_id, image_uri=image_uri, ground_truths=())
+        )
+
+    return CorpusSpec(
+        name=name,
+        documents=tuple(documents),
+        metadata={"source": "iiif", "manifest_url": manifest_url},
+    )
+
+
+def import_escriptorium_corpus(
+    base_url: str,
+    token: str,
+    doc_pk: int,
+    dest: str | Path,
+    *,
+    name: str | None = None,
+    layer: str = DEFAULT_LAYER,
+    limit: int | None = None,
+    importer: EScriptoriumImporter | None = None,
+    download: Downloader | None = None,
+) -> CorpusSpec:
+    """Importe un document eScriptorium → corpus **scorable** sous ``dest``.
+
+    Pour chaque page : télécharge l'image et écrit le texte de la couche ``layer``
+    comme vérité-terrain (``.gt.txt`` → ``GroundTruthRef`` ``RAW_TEXT``). Une page
+    sans texte reste image-seule ; une page sans image est ignorée (avertie).
+
+    Média gardé : le jeton ``Authorization`` n'est joint au download que si le
+    média est **sur le même hôte** que ``base_url`` (règle host de D-050). Un média
+    servi par un autre hôte (CDN tiers) est téléchargé **sans jeton** — on ne livre
+    pas le credential à un tiers (un média gardé y répondra 401, sans fuite).
+    """
+    imp = importer or EScriptoriumImporter(base_url, token, layer=layer)
+    fetch_bytes: Downloader = download or _http.download
+    base_host = urlsplit(base_url).hostname
+    media_auth = {"Authorization": f"Token {token}"}
+    dest_dir = Path(dest)
+    dest_dir.mkdir(parents=True, exist_ok=True)
+
+    pages = imp.fetch_pages(doc_pk)
+    if limit is not None:
+        pages = pages[:limit]
+
+    documents: list[DocumentRef] = []
+    for page in pages:
+        if not page.image_url:
+            logger.warning("[escriptorium] part %s sans image — ignorée.", page.pk)
+            continue
+        doc_id = f"part_{page.pk:05d}"
+        same_host = urlsplit(page.image_url).hostname == base_host
+        headers = media_auth if same_host else None
+        if not same_host:
+            logger.warning(
+                "[escriptorium] média part %s hors hôte (%s) — téléchargé sans "
+                "jeton (pas de fuite vers un tiers).",
+                page.pk,
+                urlsplit(page.image_url).hostname,
+            )
+        image_uri = _download_image(
+            fetch_bytes, page.image_url, doc_id, dest_dir, headers=headers
+        )
+        ground_truths: tuple[GroundTruthRef, ...] = ()
+        if page.gt_text.strip():
+            gt_target = validated_path(f"{doc_id}.gt.txt", dest_dir)
+            gt_target.write_text(page.gt_text, encoding="utf-8")
+            ground_truths = (
+                GroundTruthRef(type=ArtifactType.RAW_TEXT, uri=str(gt_target)),
+            )
+        documents.append(
+            DocumentRef(id=doc_id, image_uri=image_uri, ground_truths=ground_truths)
+        )
+
+    if not documents:
+        raise CorpusImportError(
+            f"document eScriptorium {doc_pk} : aucune page avec image exploitable."
+        )
+    return CorpusSpec(
+        name=name or f"escriptorium-{doc_pk}",
+        documents=tuple(documents),
+        metadata={
+            "source": "escriptorium",
+            "base_url": base_url.rstrip("/"),
+            "doc_pk": str(doc_pk),
+            "layer": layer,
+        },
+    )
+
+
+def import_gallica_corpus(
+    ark: str,
+    dest: str | Path,
+    *,
+    base_url: str = GALLICA_BASE,
+    name: str | None = None,
+    limit: int | None = None,
+    include_ocr: bool = True,
+    image_importer: IIIFImporter | None = None,
+    download: Downloader | None = None,
+    fetch_ocr: OcrFetcher | None = None,
+) -> CorpusSpec:
+    """Importe un document Gallica (ARK) → images (via IIIF) + OCR Gallica optionnel.
+
+    Les images viennent du **manifeste IIIF** Gallica ; si ``include_ocr``, l'OCR
+    brut de chaque vue (``texteBrut``) est écrit comme **référence étiquetée** :
+    type domaine ``REFERENCE_TEXT`` (≠ vérité-terrain manuelle) + métadonnée
+    ``gt_source=gallica_ocr``. Une vue d'évaluation par défaut **ne le score pas**
+    comme une GT ; seule une vue *référence* dédiée (opt-in) le compare.
+
+    Le numéro de vue est **lu dans l'URL de l'image** (``/f{n}/``), pas déduit de la
+    position : un canvas sans image sauté par le parseur IIIF décalerait sinon tout
+    l'OCR (le bug ``selected_indices+1`` réintroduit). Position 1-based = repli si
+    l'URL ne porte pas de ``/f{n}/``.
+    """
+    gallica = GallicaImporter(ark, base_url=base_url)
+    fetch_bytes: Downloader = download or _http.download
+    ocr_of: OcrFetcher = fetch_ocr or gallica.fetch_ocr_text
+    dest_dir = Path(dest)
+    dest_dir.mkdir(parents=True, exist_ok=True)
+
+    images = (image_importer or IIIFImporter()).fetch_images(gallica.manifest_url)
+    if limit is not None:
+        images = images[:limit]
+    if not images:
+        raise CorpusImportError(f"aucune image pour l'ARK Gallica {gallica.ark!r}.")
+
+    documents: list[DocumentRef] = []
+    has_ocr_gt = False
+    for position, image in enumerate(images, start=1):
+        vue = vue_number(image.image_url) or position
+        doc_id = f"f{vue:04d}"
+        image_uri = _download_image(fetch_bytes, image.image_url, doc_id, dest_dir)
+        ground_truths: tuple[GroundTruthRef, ...] = ()
+        if include_ocr:
+            text = ocr_of(vue)
+            if text.strip():
+                gt_target = validated_path(f"{doc_id}.gallica_ocr.txt", dest_dir)
+                gt_target.write_text(text, encoding="utf-8")
+                ground_truths = (
+                    GroundTruthRef(
+                        type=ArtifactType.REFERENCE_TEXT, uri=str(gt_target)
+                    ),
+                )
+                has_ocr_gt = True
+        documents.append(
+            DocumentRef(id=doc_id, image_uri=image_uri, ground_truths=ground_truths)
+        )
+
+    metadata = {
+        "source": "gallica",
+        "ark": gallica.ark,
+        "manifest_url": gallica.manifest_url,
+    }
+    if has_ocr_gt:
+        metadata["gt_source"] = "gallica_ocr"
+    return CorpusSpec(
+        name=name or f"gallica-{gallica.ark.split('/')[-1]}",
+        documents=tuple(documents),
+        metadata=metadata,
+    )
+
+
+def import_hf_corpus(
+    dataset_id: str,
+    dest: str | Path,
+    *,
+    name: str | None = None,
+    split: str = "train",
+    limit: int | None = None,
+    stream: HFStreamer | None = None,
+) -> CorpusSpec:
+    """Importe un dataset **HuggingFace** (convention Cinoc) → ``CorpusSpec`` scorable.
+
+    Streamé **page-par-page** (jamais de snapshot complet) : chaque page écrit son
+    image et son texte de vérité-terrain. La GT d'un dataset Cinoc curé est une
+    **vraie GT** (``GroundTruthRef`` ``RAW_TEXT``), pas une référence OCR. ``limit``
+    borne le nombre de pages. ``stream`` est injectable (test sans ``datasets``).
+    """
+    pages = (stream or stream_pages)(dataset_id, split=split, limit=limit)
+    dest_dir = Path(dest)
+    dest_dir.mkdir(parents=True, exist_ok=True)
+
+    documents: list[DocumentRef] = []
+    for index, page in enumerate(pages, start=1):
+        doc_id = f"page_{index:04d}"
+        target = validated_path(f"{doc_id}{page.image_ext}", dest_dir)
+        target.write_bytes(page.image_bytes)
+        ground_truths: tuple[GroundTruthRef, ...] = ()
+        if page.gt_text.strip():
+            gt_target = validated_path(f"{doc_id}.gt.txt", dest_dir)
+            gt_target.write_text(page.gt_text, encoding="utf-8")
+            ground_truths = (
+                GroundTruthRef(type=ArtifactType.RAW_TEXT, uri=str(gt_target)),
+            )
+        documents.append(
+            DocumentRef(id=doc_id, image_uri=str(target), ground_truths=ground_truths)
+        )
+
+    if not documents:
+        raise CorpusImportError(
+            f"dataset HuggingFace {dataset_id!r} (split {split!r}) : aucune page."
+        )
+    return CorpusSpec(
+        name=name or f"hf-{dataset_id.replace('/', '-')}",
+        documents=tuple(documents),
+        metadata={"source": "huggingface", "dataset_id": dataset_id, "split": split},
+    )
+
+
+def _curated_entry(entry: object, root: Path, base_url: str | None) -> DocumentRef:
+    """Une entrée ``corpus.json`` → ``DocumentRef`` (image = référence, GT = vraie).
+
+    Image : ``base_url`` + chemin relatif si fourni — le chemin est un dérivé
+    **IIIF statique** du layout (``iiif/<id>/full/…``), et ``base_url`` la racine
+    ``resolve`` HF épinglée (ou un serveur IIIF d'institution) ; sinon chemin
+    local du dérivé medium. La référence est matérialisée **au run** par
+    l'orchestrateur. GT : ``RAW_TEXT`` sur le ``.gt.txt`` local. Chemins relatifs
+    durcis (``validated_path`` rejette ``..``) — un dataset tiers hostile ne peut
+    pas pointer hors du layout."""
+    if not isinstance(entry, dict):
+        raise CorpusImportError(f"entrée corpus.json invalide : {entry!r}")
+    try:
+        doc_id, image_rel, gt_rel = entry["id"], entry["image"], entry["ground_truth"]
+    except (KeyError, TypeError) as exc:
+        raise CorpusImportError(f"entrée corpus.json incomplète : {entry!r}") from exc
+    try:
+        gt_path = validated_path(str(gt_rel), root)  # rejette le path-traversal
+        image_local = validated_path(str(image_rel), root)  # idem + valide la forme
+    except PathSecurityError as exc:
+        raise CorpusImportError(f"chemin non sûr dans corpus.json : {exc}") from exc
+    image_uri = (
+        f"{base_url.rstrip('/')}/{str(image_rel).lstrip('/')}"
+        if base_url
+        else str(image_local)
+    )
+    stratum = entry.get("stratum")
+    return DocumentRef(
+        id=str(doc_id),
+        image_uri=image_uri,
+        ground_truths=(GroundTruthRef(type=ArtifactType.RAW_TEXT, uri=str(gt_path)),),
+        metadata={"stratum": str(stratum)} if stratum else {},
+    )
+
+
+def import_curated_corpus(
+    layout_dir: str | Path,
+    *,
+    base_url: str | None = None,
+    revision: str | None = None,
+    name: str | None = None,
+) -> CorpusSpec:
+    """Importe un **layout dataset canonique Cinoc** → ``CorpusSpec`` scorable.
+
+    Variante **par référence** de ``import_hf_corpus`` (même sortie, pas un format
+    parallèle) : produit par ``app.dataset_standardize`` ou snapshot d'un dataset
+    HF publié. L'image est une **référence** (``base_url`` + dérivé IIIF statique
+    du layout — en pratique une URL ``resolve`` HF épinglée ; sinon chemin local
+    du dérivé medium), matérialisée au run par l'orchestrateur ; la GT est une
+    **vraie GT** ``RAW_TEXT``. ``base_url`` + ``revision`` (SHA HF) →
+    reproductibilité pinnée (``RunManifest``).
+    """
+    root = Path(layout_dir)
+    manifest_path = root / "corpus.json"
+    if not manifest_path.is_file():
+        raise CorpusImportError(f"layout curé sans corpus.json : {root}")
+    try:
+        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise CorpusImportError(f"corpus.json illisible ({root}) : {exc}") from exc
+    entries = manifest.get("documents") if isinstance(manifest, dict) else None
+    if not isinstance(entries, list) or not entries:
+        raise CorpusImportError(f"corpus.json sans documents : {root}")
+
+    documents = tuple(_curated_entry(e, root, base_url) for e in entries)
+    corpus_meta: dict[str, str] = {"source": "curated"}
+    if revision:
+        corpus_meta["revision"] = revision
+    licenses = manifest.get("license")
+    if isinstance(licenses, dict):
+        for key, value in licenses.items():
+            corpus_meta[f"license_{key}"] = str(value)
+    return CorpusSpec(
+        name=name or str(manifest.get("name") or root.name),
+        documents=documents,
+        metadata=corpus_meta,
+    )
+
+
+#: Télécharge un layout curé HF → dossier local (au moins ``corpus.json`` + GT).
+#: Injectable → l'import distant se teste sans réseau ni ``huggingface_hub``.
+CuratedFetcher = Callable[[str, Path, "str | None"], Path]
+
+
+def _hf_resolve_base(repo_id: str, revision: str | None) -> str:
+    """Racine ``resolve`` d'un dataset HF, épinglée à ``revision`` (sinon ``main``)."""
+    return f"https://huggingface.co/datasets/{repo_id}/resolve/{revision or 'main'}"
+
+
+def import_curated_hf_corpus(
+    repo_id: str,
+    dest: str | Path,
+    *,
+    revision: str | None = None,
+    name: str | None = None,
+    fetch: CuratedFetcher | None = None,
+) -> CorpusSpec:
+    """Importe un **dataset curé Cinoc publié sur HF** → ``CorpusSpec`` scorable.
+
+    Variante **distante** de ``import_curated_corpus`` : télécharge **uniquement**
+    le manifeste + la GT (les images restent des références IIIF HF, épinglées à
+    ``revision``), puis délègue à l'importeur local. Un corpus de référence publié
+    devient ainsi sélectionnable au Banc d'essai en quelques secondes, sans
+    rapatrier les images. ``fetch`` est injectable (test sans réseau).
+    """
+    layout_dir = (fetch or snapshot_curated_layout)(repo_id, Path(dest), revision)
+    return import_curated_corpus(
+        layout_dir,
+        base_url=_hf_resolve_base(repo_id, revision),
+        revision=revision,
+        name=name,
+    )
+
+
+__all__ = [
+    "CorpusImportError",
+    "import_curated_corpus",
+    "import_curated_hf_corpus",
+    "import_escriptorium_corpus",
+    "import_gallica_corpus",
+    "import_hf_corpus",
+    "import_iiif_corpus",
+]
diff --git a/cinoc/app/corpus_upload.py b/cinoc/app/corpus_upload.py
new file mode 100644
index 0000000000000000000000000000000000000000..1243f6bf0201c05303ae19e3d171d66d8bb1bbf9
--- /dev/null
+++ b/cinoc/app/corpus_upload.py
@@ -0,0 +1,288 @@
+"""Ingestion **sûre** d'un corpus depuis une archive ZIP (couche 6).
+
+Le concept central est la **sécurité d'ingestion** : une archive
+vient de l'extérieur, on la traite en supposant qu'elle est hostile.
+
+Défenses (toutes testées) :
+
+- **anti-traversal** : on **aplatit au basename** (aucun sous-dossier conservé)
+  et on repasse chaque nom par ``validated_path`` (défense en profondeur) ;
+- **anti-zip-bomb** : la taille **réellement décompressée** est plafonnée par
+  fichier *et* au total (on ne fait pas confiance au ``file_size`` du header) ;
+- **quotas** : taille de l'archive, nombre d'entrées, taille par fichier ;
+- **dédup** : un basename en double est refusé ;
+- **liste blanche d'extensions** + **signature** des images (magic bytes) ;
+- **noms** restreints à un charset sûr (→ ``DocumentRef.id`` valide).
+
+Sortie : une ``CorpusSpec`` (images appariées à leur vérité-terrain ``.txt`` par
+radical) matérialisée sous ``dest`` — prête pour un run.
+"""
+
+from __future__ import annotations
+
+import io
+import re
+import shutil
+import threading
+import uuid
+import zipfile
+from collections.abc import Callable
+from pathlib import Path
+
+from pydantic import ValidationError
+
+from cinoc.app.security import validated_path
+from cinoc.domain.artifacts import ArtifactType
+from cinoc.domain.corpus import CorpusSpec
+from cinoc.domain.documents import DocumentRef, GroundTruthRef
+from cinoc.domain.errors import CinocError, CorpusSpecError, FormatError
+from cinoc.evaluation.projectors import layout_to_text
+from cinoc.formats.alto import parse_alto
+from cinoc.formats.alto.layout_map import alto_to_layout
+from cinoc.formats.pagexml import parse_pagexml
+from cinoc.formats.pagexml.layout_map import page_to_layout
+
+#: Quotas (généreux mais bornés) — un Space gratuit n'est pas un entrepôt.
+MAX_ZIP_BYTES = 25 * 1024 * 1024
+MAX_TOTAL_UNCOMPRESSED = 200 * 1024 * 1024
+MAX_FILE_BYTES = 25 * 1024 * 1024
+MAX_ENTRIES = 1000
+
+_IMAGE_EXT = frozenset({".png", ".jpg", ".jpeg", ".tif", ".tiff"})
+_GT_EXT = frozenset({".txt"})
+#: Vérité-terrain au format mise-en-page : ALTO 4.x ou PAGE XML. Convertie en
+#: texte d'ordre de lecture à l'ingestion (cf. ``_xml_to_text``).
+_GT_XML_EXT = frozenset({".xml"})
+_IMAGE_MAGIC = (b"\x89PNG\r\n\x1a\n", b"\xff\xd8\xff", b"II*\x00", b"MM\x00*")
+#: Basename sûr → garantit un ``DocumentRef.id`` valide (pas d'espace/accent/slash).
+_SAFE_NAME = re.compile(r"^[A-Za-z0-9_.\-]+$")
+
+
+class CorpusUploadError(CinocError):
+    """Archive rejetée (non sûre, hors quota, vide, ou mal formée)."""
+
+
+def extract_corpus_zip(data: bytes, dest: Path, *, name: str) -> CorpusSpec:
+    """Valide et extrait ``data`` (ZIP) sous ``dest`` → ``CorpusSpec``."""
+    if len(data) > MAX_ZIP_BYTES:
+        raise CorpusUploadError("archive trop volumineuse.")
+    try:
+        archive = zipfile.ZipFile(io.BytesIO(data))
+    except zipfile.BadZipFile as exc:
+        raise CorpusUploadError("archive ZIP invalide.") from exc
+
+    entries = [
+        info
+        for info in archive.infolist()
+        if not info.is_dir() and not _is_macos_metadata(info.filename)
+    ]
+    if not entries:
+        raise CorpusUploadError("archive vide.")
+    if len(entries) > MAX_ENTRIES:
+        raise CorpusUploadError(f"trop d'entrées (> {MAX_ENTRIES}).")
+
+    dest.mkdir(parents=True, exist_ok=True)
+    written: dict[str, Path] = {}
+    total = 0
+    for info in entries:
+        base = _safe_basename(info.filename)
+        ext = Path(base).suffix.lower()
+        if ext not in _IMAGE_EXT and ext not in _GT_EXT and ext not in _GT_XML_EXT:
+            raise CorpusUploadError(f"extension non autorisée : {base!r}.")
+        if base in written:
+            raise CorpusUploadError(f"doublon de nom : {base!r}.")
+        payload = _read_capped(archive, info)
+        total += len(payload)
+        if total > MAX_TOTAL_UNCOMPRESSED:
+            raise CorpusUploadError("archive trop volumineuse décompressée (bombe ?).")
+        if ext in _IMAGE_EXT and not payload.startswith(_IMAGE_MAGIC):
+            raise CorpusUploadError(f"image non reconnue : {base!r}.")
+        target = validated_path(base, dest)  # défense en profondeur
+        target.write_bytes(payload)
+        written[base] = target
+
+    # Les radicaux d'image deviennent des `DocumentRef.id` et le nom de fichier
+    # devient le nom de corpus : deux images de même radical (`a.png`+`a.jpg`),
+    # un radical invalide (`..`) ou un nom trop long font lever le `domain`
+    # (`CorpusSpecError` / `ValidationError`). On les **traduit** en rejet propre
+    # (→ 422), jamais en 500 : une archive « sûre mais bancale » reste une entrée.
+    try:
+        documents = _pair_documents(written)
+        if not documents:
+            raise CorpusUploadError("aucune image dans l'archive.")
+        return CorpusSpec(name=name, documents=documents)
+    except (CorpusSpecError, ValidationError) as exc:
+        raise CorpusUploadError(f"corpus invalide : {exc}") from exc
+
+
+def _is_macos_metadata(name: str) -> bool:
+    """Entrées parasites des ZIP créés sous macOS, à ignorer silencieusement.
+
+    AppleDouble (``._fichier`` — fork de ressources, jamais une vraie image) et
+    le dossier ``__MACOSX/``. Les filtrer évite un rejet « image non reconnue »
+    sur des sidecars que l'utilisateur n'a jamais voulu déposer.
+    """
+    parts = name.split("/")
+    return "__MACOSX" in parts or parts[-1].startswith("._")
+
+
+def _safe_basename(raw_name: str) -> str:
+    """Basename validé : pas de traversal, charset sûr (→ id de document valide)."""
+    if raw_name.startswith("/") or "\\" in raw_name or ".." in Path(raw_name).parts:
+        raise CorpusUploadError(f"entrée non sûre : {raw_name!r}.")
+    base = Path(raw_name).name
+    if not base or not _SAFE_NAME.match(base):
+        raise CorpusUploadError(f"nom de fichier non sûr : {raw_name!r}.")
+    return base
+
+
+def _read_capped(archive: zipfile.ZipFile, info: zipfile.ZipInfo) -> bytes:
+    """Lit l'entrée avec un **plafond dur** (indépendant du ``file_size`` annoncé)."""
+    with archive.open(info) as src:
+        payload = src.read(MAX_FILE_BYTES + 1)
+    if len(payload) > MAX_FILE_BYTES:
+        raise CorpusUploadError(f"fichier trop volumineux : {info.filename!r}.")
+    return payload
+
+
+def _pair_documents(written: dict[str, Path]) -> tuple[DocumentRef, ...]:
+    """Apparie chaque image à sa vérité-terrain par radical (``_ground_truth_for``)."""
+    documents: list[DocumentRef] = []
+    for base, path in sorted(written.items()):
+        if Path(base).suffix.lower() not in _IMAGE_EXT:
+            continue
+        stem = Path(base).stem
+        documents.append(
+            DocumentRef(
+                id=stem,
+                image_uri=str(path),
+                ground_truths=_ground_truth_for(stem, written),
+            )
+        )
+    return tuple(documents)
+
+
+def _ground_truth_for(
+    stem: str, written: dict[str, Path]
+) -> tuple[GroundTruthRef, ...]:
+    """Vérité-terrain ``RAW_TEXT`` d'un radical, par priorité de format.
+
+    1. ``.txt`` manuel (``<rad>.gt.txt`` puis ``<rad>.txt``) — chemin direct.
+    2. À défaut, ALTO/PAGE (``<rad>.gt.xml`` puis ``<rad>.xml``) : texte d'ordre
+       de lecture extrait par ``layout_to_text`` (la **projection même** du
+       scoring), matérialisé en ``<rad>.gt.txt`` dérivé → le GT reste un
+       ``RAW_TEXT``, un seul chemin d'évaluation, déterministe.
+    3. Sinon ``()`` : le run reste exécutable, simplement non scoré.
+    """
+    txt = next((c for c in (f"{stem}.gt.txt", f"{stem}.txt") if c in written), None)
+    if txt is not None:
+        return (GroundTruthRef(type=ArtifactType.RAW_TEXT, uri=str(written[txt])),)
+    xml = next((c for c in (f"{stem}.gt.xml", f"{stem}.xml") if c in written), None)
+    if xml is None:
+        return ()
+    derived = written[xml].with_name(f"{stem}.gt.txt")
+    derived.write_text(_xml_to_text(written[xml]), encoding="utf-8")
+    return (GroundTruthRef(type=ArtifactType.RAW_TEXT, uri=str(derived)),)
+
+
+def _xml_to_text(path: Path) -> str:
+    """Texte d'ordre de lecture d'une vérité-terrain ALTO/PAGE.
+
+    ALTO ou PAGE selon le marqueur de racine (même heuristique que l'évaluation).
+    Le parse passe par la couche 2 (``safe_parse_xml`` durci : pas de XXE/DTD).
+    Parse en échec ou texte vide → rejet propre (``CorpusUploadError`` → 422),
+    jamais un 500.
+    """
+    data = path.read_bytes()
+    head = data[:4096].lower()
+    is_page = b"pcgts" in head or b"pagecontent" in head
+    try:
+        layout = (
+            page_to_layout(parse_pagexml(data))
+            if is_page
+            else alto_to_layout(parse_alto(data))
+        )
+    except (ValueError, FormatError) as exc:
+        kind = "PAGE" if is_page else "ALTO"
+        raise CorpusUploadError(
+            f"vérité-terrain {kind} illisible : {path.name!r} ({exc})."
+        ) from exc
+    text = layout_to_text(layout, {})
+    if not isinstance(text, str) or not text.strip():
+        raise CorpusUploadError(
+            f"vérité-terrain XML sans texte exploitable : {path.name!r}."
+        )
+    return text
+
+
+class CorpusStore:
+    """Registre **en mémoire** des corpus uploadés (id → ``CorpusSpec`` + dossier).
+
+    Le contenu vit sous ``base_dir`` (éphémère sur HF — acceptable : ce sont des
+    **entrées** de travail ; les *résultats* sont, eux, publiés vers un dépôt distant).
+    """
+
+    def __init__(self, base_dir: Path) -> None:
+        self._base = base_dir
+        self._corpora: dict[str, CorpusSpec] = {}
+        self._lock = threading.Lock()
+
+    def save(self, name: str, data: bytes) -> tuple[str, CorpusSpec]:
+        """Extrait l'archive dans un dossier neuf et enregistre la ``CorpusSpec``."""
+        corpus_id = uuid.uuid4().hex
+        spec = extract_corpus_zip(data, self._base / corpus_id, name=name or corpus_id)
+        with self._lock:
+            self._corpora[corpus_id] = spec
+        return corpus_id, spec
+
+    def materialize(
+        self, builder: Callable[[Path], CorpusSpec]
+    ) -> tuple[str, CorpusSpec]:
+        """Enregistre un corpus **construit** dans un dossier neuf sous ``base_dir``.
+
+        ``builder`` reçoit le dossier de destination et renvoie la ``CorpusSpec``
+        matérialisée — agnostique de la source (importeurs IIIF/eScriptorium/
+        Gallica…). Le store reste un **registre** : il alloue l'id et le dossier,
+        sans connaître le format d'entrée.
+
+        **Atomicité (F3)** : si ``builder`` échoue en cours de route (réseau,
+        source non conforme, annulation), le dossier **partiellement** matérialisé
+        est nettoyé — pas de corpus à demi importé laissé sous ``base_dir``, et
+        rien n'est enregistré.
+        """
+        corpus_id = uuid.uuid4().hex
+        dest = self._base / corpus_id
+        try:
+            spec = builder(dest)
+        except BaseException:
+            shutil.rmtree(dest, ignore_errors=True)
+            raise
+        with self._lock:
+            self._corpora[corpus_id] = spec
+        return corpus_id, spec
+
+    def get(self, corpus_id: str) -> CorpusSpec | None:
+        with self._lock:
+            return self._corpora.get(corpus_id)
+
+    def list_corpora(self) -> list[tuple[str, CorpusSpec]]:
+        """Corpus enregistrés ``(id, spec)``, triés par nom puis id (ordre stable)."""
+        with self._lock:
+            items = list(self._corpora.items())
+        return sorted(items, key=lambda kv: (kv[1].name, kv[0]))
+
+    def delete(self, corpus_id: str) -> bool:
+        """Supprime un corpus (registre **et** dossier). Vrai s'il existait."""
+        with self._lock:
+            existed = self._corpora.pop(corpus_id, None) is not None
+        if existed:
+            shutil.rmtree(self._base / corpus_id, ignore_errors=True)
+        return existed
+
+
+__all__ = [
+    "MAX_ZIP_BYTES",
+    "CorpusStore",
+    "CorpusUploadError",
+    "extract_corpus_zip",
+]
diff --git a/cinoc/app/data_dir.py b/cinoc/app/data_dir.py
new file mode 100644
index 0000000000000000000000000000000000000000..71782b7046d5ed8957d7fa874211991e84266dce
--- /dev/null
+++ b/cinoc/app/data_dir.py
@@ -0,0 +1,51 @@
+"""Résolution du dossier de **données inscriptible** (couche 6).
+
+Distinct du dossier des rapports *bakés* (livrés dans l'image d'un Space, donc
+appartenant à root et **non inscriptibles** par l'utilisateur non-root qui sert
+l'app). L'historique longitudinal et le puits des rapports de run y vivent —
+**jamais** dans le dossier baké, sous peine d'``OperationalError`` / d'échec
+d'écriture (cause des *Internal Server Error* sur Hugging Face).
+
+Ordre de résolution : argument explicite › ``CINOC_DATA_DIR`` › ``/data``
+(montage de stockage persistant Hugging Face, s'il est inscriptible) › dossier
+temporaire neuf. Le dernier recours est **toujours inscriptible** : on ne
+démarre jamais sur un emplacement qui fera planter la première écriture.
+"""
+
+from __future__ import annotations
+
+import os
+import tempfile
+from pathlib import Path
+
+#: Surcharge explicite de l'emplacement de données.
+DATA_DIR_ENV = "CINOC_DATA_DIR"
+
+#: Montage du stockage persistant d'un Space HF (présent si l'option est activée).
+_PERSISTENT_MOUNT = Path("/data")
+
+
+def _is_writable_dir(path: Path) -> bool:
+    return path.is_dir() and os.access(path, os.W_OK)
+
+
+def resolve_data_dir(data_dir: Path | str | None = None) -> Path:
+    """Renvoie un dossier de données **inscriptible**, créé au besoin.
+
+    Argument explicite > ``CINOC_DATA_DIR`` > ``/data`` (si inscriptible) >
+    dossier temporaire. Éphémère en dernier recours (la persistance durable est
+    obtenue en pointant ``CINOC_DATA_DIR`` / ``/data`` sur un volume stable).
+    """
+    if data_dir is not None:
+        chosen = Path(data_dir)
+    elif env := os.environ.get(DATA_DIR_ENV):
+        chosen = Path(env)
+    elif _is_writable_dir(_PERSISTENT_MOUNT):
+        chosen = _PERSISTENT_MOUNT / "cinoc"
+    else:
+        chosen = Path(tempfile.mkdtemp(prefix="cinoc-data-"))
+    chosen.mkdir(parents=True, exist_ok=True)
+    return chosen
+
+
+__all__ = ["DATA_DIR_ENV", "resolve_data_dir"]
diff --git a/cinoc/app/dataset_standardize.py b/cinoc/app/dataset_standardize.py
new file mode 100644
index 0000000000000000000000000000000000000000..31f7ea8534642e6555783bbfafce488b2f3fdf0b
--- /dev/null
+++ b/cinoc/app/dataset_standardize.py
@@ -0,0 +1,247 @@
+"""Standardise un corpus brut (images + PAGE XML) en **layout dataset canonique
+Cinoc**, prêt à publier sur Hugging Face (couche 6, outil de build déterministe).
+
+Le layout assemble des **standards existants** (≠ norme inventée) :
+
+```
+<out>/
+├── README.md                       carte HF (front-matter YAML + attribution)
+├── corpus.json                     mapping mince → types domain (documents + strates)
+├── ground_truth/<id>.gt.txt        vérité-terrain texte (RAW_TEXT, pour le scoring)
+├── ground_truth/<id>.page.xml      PAGE XML source (verbatim)
+└── iiif/<id>/
+    ├── info.json                   IIIF Image API 3, profile level0 (statique)
+    └── full/{max,1600,,400,}/0/default.jpg
+```
+
+Réutilise ``formats.pagexml`` (lecture GT) et ``adapters.images`` (dérivés). La
+**publication** (upload ``huggingface_hub``, token write) est hors couche : un
+script déclenché à la main (l'environnement de build n'a pas le secret).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+from cinoc.adapters.corpus.huggingface import CURATED_DATASET_TAG
+from cinoc.adapters.images import iiif_derivative
+from cinoc.domain.errors import CinocError
+from cinoc.formats.pagexml import parse_pagexml
+from cinoc.formats.pagexml.types import PagePage, PageRegion
+
+logger = logging.getLogger(__name__)
+
+#: Largeurs des dérivés IIIF (vignette galerie + medium drill-in). Pas de
+#: deep-zoom (décision rapport) → deux tailles suffisent, plus l'original ``max``.
+THUMBNAIL_WIDTH = 400
+MEDIUM_WIDTH = 1600
+_IIIF_IMAGE_CONTEXT = "http://iiif.io/api/image/3/context.json"
+#: caractères autorisés dans un ``DocumentRef.id`` (cf. domain) — on s'y conforme.
+_SAFE_ID = set("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_.-")
+
+
+class DatasetStandardizeError(CinocError):
+    """Échec de standardisation d'un corpus brut en layout dataset."""
+
+
+@dataclass(frozen=True)
+class StandardizeConfig:
+    """Paramètres de curation d'un corpus (métadonnées + droits + strate)."""
+
+    name: str
+    stratum: str
+    language: str
+    transcription_license: str  # slug HF, ex. "cc-by-nc-sa-4.0"
+    image_rights: str  # ex. "Public Domain Mark (SLUB Dresden)"
+    attribution: str
+    #: préfixe URL du dataset publié (résout l'``id`` IIIF) ; finalisé au publish.
+    base_url: str = ""
+
+
+def _doc_id(stem: str) -> str:
+    """Identifiant de document sûr (cf. ``DocumentRef``) dérivé d'un nom de page.
+
+    Les noms SLUB portent une espace (``Mscr.Dresd.K80 177``) → underscore. Tout
+    autre caractère hors charset ``DocumentRef`` est rejeté (pas de mapping muet)."""
+    candidate = stem.strip().replace(" ", "_")
+    if not candidate or any(c not in _SAFE_ID for c in candidate):
+        raise DatasetStandardizeError(
+            f"nom de page non convertible en id de document : {stem!r}"
+        )
+    return candidate
+
+
+def _region_lines(region: PageRegion) -> list[str]:
+    """Lignes de texte d'une région (récursif sur sous-régions ; texte seul)."""
+    lines: list[str] = []
+    if region.kind == "text":
+        lines.extend(line.text for line in region.text_lines)
+        for sub in region.regions:
+            lines.extend(_region_lines(sub))
+    return lines
+
+
+def _page_text(page: PagePage) -> str:
+    """Vérité-terrain texte d'une page : lignes jointes par ``\\n`` (ordre du XML)."""
+    lines: list[str] = []
+    for region in page.regions:
+        lines.extend(_region_lines(region))
+    return "\n".join(lines).strip()
+
+
+def _write_json(path: Path, payload: object) -> None:
+    """Écrit du JSON déterministe (clés triées, UTF-8 lisible, newline final)."""
+    path.write_text(
+        json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+
+
+def _iiif_info(doc_id: str, width: int, height: int, sizes: list[dict[str, int]],
+               base_url: str) -> dict[str, object]:
+    """Document ``info.json`` IIIF Image API 3.0, ``profile`` level0 (statique)."""
+    rel = f"iiif/{doc_id}"
+    service_id = f"{base_url.rstrip('/')}/{rel}" if base_url else rel
+    return {
+        "@context": _IIIF_IMAGE_CONTEXT,
+        "id": service_id,
+        "type": "ImageService3",
+        "protocol": "http://iiif.io/api/image",
+        "profile": "level0",
+        "width": width,
+        "height": height,
+        "sizes": sizes,
+        "preferredFormats": ["jpg"],
+    }
+
+
+def _standardize_page(
+    xml_path: Path, jpg_path: Path, out_dir: Path, config: StandardizeConfig
+) -> dict[str, str]:
+    """Traite une page : GT + dérivés IIIF + info.json → entrée ``corpus.json``."""
+    doc_id = _doc_id(xml_path.stem)
+    document = parse_pagexml(xml_path.read_bytes())
+    if not document.pages:
+        raise DatasetStandardizeError(f"PAGE sans page : {xml_path.name}")
+    page = document.pages[0]
+    if page.image_width is None or page.image_height is None:
+        raise DatasetStandardizeError(
+            f"PAGE sans dimensions image : {xml_path.name} (requis pour info.json)"
+        )
+
+    gt_dir = out_dir / "ground_truth"
+    gt_dir.mkdir(parents=True, exist_ok=True)
+    (gt_dir / f"{doc_id}.gt.txt").write_text(_page_text(page), encoding="utf-8")
+    shutil.copyfile(xml_path, gt_dir / f"{doc_id}.page.xml")
+
+    svc = out_dir / "iiif" / doc_id
+    max_dest = svc / "full" / "max" / "0" / "default.jpg"
+    max_dest.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copyfile(jpg_path, max_dest)
+
+    sizes: list[dict[str, int]] = []
+    for width in (THUMBNAIL_WIDTH, MEDIUM_WIDTH):
+        dest = svc / "full" / f"{width}," / "0" / "default.jpg"
+        produced = iiif_derivative(jpg_path, dest, width=width)
+        if produced is None:
+            raise DatasetStandardizeError(
+                f"dérivé IIIF {width}px impossible pour {jpg_path.name} "
+                "(Pillow requis : installer l'extra ``[images]``)"
+            )
+        sizes.append({"width": produced[0], "height": produced[1]})
+    _write_json(
+        svc / "info.json",
+        _iiif_info(doc_id, page.image_width, page.image_height, sizes, config.base_url),
+    )
+
+    return {
+        "id": doc_id,
+        "image": f"iiif/{doc_id}/full/{MEDIUM_WIDTH},/0/default.jpg",
+        "thumbnail": f"iiif/{doc_id}/full/{THUMBNAIL_WIDTH},/0/default.jpg",
+        "ground_truth": f"ground_truth/{doc_id}.gt.txt",
+        "page_xml": f"ground_truth/{doc_id}.page.xml",
+        "stratum": config.stratum,
+    }
+
+
+def _dataset_card(config: StandardizeConfig, n_docs: int) -> str:
+    """Carte HF : front-matter YAML (license/langue/tags) + provenance + droits."""
+    return (
+        "---\n"
+        f"license: {config.transcription_license}\n"
+        "language:\n"
+        f"- {config.language}\n"
+        f"pretty_name: {config.name}\n"
+        "tags:\n"
+        "- htr\n- ocr\n- handwritten-text-recognition\n- ground-truth\n- iiif\n"
+        # Tag de convention : rend le dataset **découvrable** par Cinoc sur le
+        # compte (``discover_curated``) sans coller son ``repo_id``.
+        f"- {CURATED_DATASET_TAG}\n"
+        "---\n\n"
+        f"# {config.name}\n\n"
+        f"{n_docs} pages de vérité-terrain, standardisées pour Cinoc "
+        "(IIIF statique + PAGE XML + texte).\n\n"
+        f"- **Transcription** : {config.transcription_license}\n"
+        f"- **Images** : {config.image_rights}\n"
+        f"- **Strate** : `{config.stratum}`\n"
+        f"- **Attribution** : {config.attribution}\n\n"
+        "Layout : `corpus.json` (mapping documents), `ground_truth/` (`.gt.txt` "
+        "+ `.page.xml`), `iiif/<id>/` (Image API 3, level0 statique).\n"
+    )
+
+
+def standardize_corpus(
+    raw_dir: str | Path, out_dir: str | Path, config: StandardizeConfig
+) -> Path:
+    """Standardise ``raw_dir`` (sous-dossiers ``page/`` + ``jpg/``) → ``out_dir``.
+
+    Apparie chaque ``page/<nom>.xml`` (hors ``METS.xml``) à ``jpg/<nom>.jpg``,
+    produit GT + dérivés IIIF + ``info.json``, puis ``corpus.json`` (mapping →
+    domain) et ``README.md`` (carte HF). Déterministe. Renvoie ``out_dir``."""
+    raw = Path(raw_dir)
+    page_dir, jpg_dir = raw / "page", raw / "jpg"
+    if not page_dir.is_dir() or not jpg_dir.is_dir():
+        raise DatasetStandardizeError(
+            f"layout brut attendu : {raw}/page/ + {raw}/jpg/ (introuvables)"
+        )
+    xml_files = sorted(
+        p for p in page_dir.glob("*.xml") if p.name.lower() != "mets.xml"
+    )
+    if not xml_files:
+        raise DatasetStandardizeError(f"aucune page PAGE dans {page_dir}")
+
+    out = Path(out_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    documents: list[dict[str, str]] = []
+    for xml_path in xml_files:
+        jpg_path = jpg_dir / f"{xml_path.stem}.jpg"
+        if not jpg_path.is_file():
+            raise DatasetStandardizeError(
+                f"image absente pour {xml_path.name} : {jpg_path.name} attendu"
+            )
+        documents.append(_standardize_page(xml_path, jpg_path, out, config))
+
+    _write_json(
+        out / "corpus.json",
+        {
+            "name": config.name,
+            "license": {
+                "transcription": config.transcription_license,
+                "images": config.image_rights,
+            },
+            "attribution": config.attribution,
+            "documents": documents,
+        },
+    )
+    (out / "README.md").write_text(
+        _dataset_card(config, len(documents)), encoding="utf-8"
+    )
+    logger.info("[dataset] %d pages standardisées → %s", len(documents), out)
+    return out
+
+
+__all__ = ["StandardizeConfig", "DatasetStandardizeError", "standardize_corpus"]
diff --git a/cinoc/app/demo.py b/cinoc/app/demo.py
new file mode 100644
index 0000000000000000000000000000000000000000..f93be06148d00bc658a234f7db43f3fb6c7f8245
--- /dev/null
+++ b/cinoc/app/demo.py
@@ -0,0 +1,168 @@
+"""Mini-corpus de démonstration **déterministe** (couche 6, ``app``).
+
+Le même corpus pré-calculé sert la commande CLI ``demo`` **et** le lanceur web
+(walking skeleton) : un run réel, sans moteur externe (``precomputed``),
+qui produit un ``RunResult`` reproductible. Construire le ``RunSpec`` est un acte
+de **planification de run** → couche ``app`` (les feuilles de transport ``cli`` /
+``web`` délèguent ici, jamais l'inverse — cf. ``test_interfaces_thin``).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+
+from cinoc.domain.artifacts import ArtifactType
+from cinoc.domain.corpus import CorpusSpec
+from cinoc.domain.documents import DocumentRef, GroundTruthRef
+from cinoc.domain.evaluation import EvaluationSpec, EvaluationView
+from cinoc.domain.pipeline import PipelineSpec, PipelineStep
+from cinoc.domain.run_spec import RunSpec
+from cinoc.evaluation.archaic import DEFAULT_ARCHAIC_LIST, resolve_archaic_list
+
+DEMO_ENGINES = ("tesseract", "pero")
+
+#: Mini-corpus déterministe : (id, vérité-terrain, {moteur: sortie pré-calculée}).
+#: ``(doc_id, strate, vérité-terrain, {moteur: sortie})``. Deux strates pour
+#: démontrer la composition / le CER par strate (forme optionnelle, P0/U5′).
+_DEMO_DOCS: tuple[tuple[str, str, str, dict[str, str]], ...] = (
+    (
+        "folio_001",
+        "manuscrit médiéval",
+        "Icy commence le prologue",
+        {
+            "tesseract": "Icy commence le prologve",
+            "pero": "Icy commence le prologue",
+        },
+    ),
+    (
+        "folio_002",
+        "manuscrit médiéval",
+        "maistre Jehan Froissart",
+        {
+            "tesseract": "maistre Jehan Froissart",
+            "pero": "maistre Jehan Froiſſart",
+        },
+    ),
+    (
+        "folio_003",
+        "manuscrit médiéval",
+        "les croniques de France",
+        {
+            "tesseract": "les croniques de France",
+            "pero": "les croniques de France",
+        },
+    ),
+    (
+        "imprime_001",
+        "imprimé ancien",
+        "DE L'IMPRIMERIE DE PIERRE LE ROUGE",
+        {
+            "tesseract": "DE L'IMPRIMERIE DE PIERRE LE ROVGE",
+            "pero": "DE L'IMPRIMERIE DE PIERRE LE ROUGE",
+        },
+    ),
+    (
+        "imprime_002",
+        "imprimé ancien",
+        "Imprimé à Paris l'an mil cinq cens",
+        {
+            "tesseract": "Imprime a Paris l'an mil cinq cens",
+            "pero": "Imprimé à Paris l'an mil cinq cens",
+        },
+    ),
+)
+
+# ``air`` figure ici car le mini-corpus exerce un vrai cas : ``pero`` rend
+# « Froiſſart » (ſ long) là où la GT écrit « Froissart » → archaïsme **inséré**.
+_TEXT_VIEW = EvaluationView(
+    name="text",
+    candidate_types=frozenset({ArtifactType.RAW_TEXT}),
+    metric_names=("cer", "cer_diplo", "wer", "mer", "air"),
+)
+
+#: Même corpus, sous équivalence orthographique du français médiéval (ſ=s, u=v,
+#: i=j…) appliquée des deux côtés : les « erreurs » purement graphiques tombent.
+_DIPLOMATIC_VIEW = EvaluationView(
+    name="francais_medieval",
+    candidate_types=frozenset({ArtifactType.RAW_TEXT}),
+    metric_names=("cer", "wer", "mer"),
+    normalization_profile="medieval_french",
+)
+
+
+def write_demo_corpus(root: Path) -> CorpusSpec:
+    """Matérialise le mini-corpus dans ``root`` et renvoie sa ``CorpusSpec``."""
+    documents: list[DocumentRef] = []
+    for doc_id, stratum, ground_truth, engine_texts in _DEMO_DOCS:
+        (root / f"{doc_id}.gt.txt").write_text(ground_truth, encoding="utf-8")
+        for label, text in engine_texts.items():
+            (root / f"{doc_id}.{label}.txt").write_text(text, encoding="utf-8")
+        documents.append(
+            DocumentRef(
+                id=doc_id,
+                image_uri=str(root / f"{doc_id}.png"),
+                ground_truths=(
+                    GroundTruthRef(
+                        type=ArtifactType.RAW_TEXT,
+                        uri=str(root / f"{doc_id}.gt.txt"),
+                    ),
+                ),
+                metadata={"stratum": stratum},
+            )
+        )
+    return CorpusSpec(name="demo", documents=tuple(documents))
+
+
+def demo_run_spec(corpus: CorpusSpec, *, run_id: str = "demo") -> RunSpec:
+    """``RunSpec`` de démonstration : un pipeline ``precomputed`` par moteur."""
+    pipelines = tuple(
+        PipelineSpec(
+            name=label,
+            initial_inputs=(ArtifactType.IMAGE,),
+            steps=(
+                PipelineStep(
+                    id="ocr",
+                    kind="ocr",
+                    adapter_name=f"precomputed:{label}",
+                    input_types=(ArtifactType.IMAGE,),
+                    output_types=(ArtifactType.RAW_TEXT,),
+                ),
+            ),
+        )
+        for label in DEMO_ENGINES
+    )
+    adapter_kwargs = {
+        f"precomputed:{label}": {"source_label": label} for label in DEMO_ENGINES
+    }
+    archaic = resolve_archaic_list(DEFAULT_ARCHAIC_LIST)
+    return RunSpec(
+        corpus=corpus,
+        pipelines=pipelines,
+        evaluation=EvaluationSpec(views=(_TEXT_VIEW, _DIPLOMATIC_VIEW)),
+        adapter_kwargs=adapter_kwargs,
+        run_id=run_id,
+        metadata={
+            "archaic_list": archaic.name,
+            "archaic_list_hash": archaic.list_hash,
+        },
+    )
+
+
+def demo_spec_builder(run_id: str = "demo") -> Callable[[Path], RunSpec]:
+    """Builder de spec de la **démonstration** : matérialise le mini-corpus dans
+    le workspace fourni, puis construit le ``RunSpec`` précalculé (``precomputed``).
+    """
+
+    def build(workspace: Path) -> RunSpec:
+        return demo_run_spec(write_demo_corpus(workspace), run_id=run_id)
+
+    return build
+
+
+__all__ = [
+    "DEMO_ENGINES",
+    "demo_run_spec",
+    "demo_spec_builder",
+    "write_demo_corpus",
+]
diff --git a/cinoc/app/engines.py b/cinoc/app/engines.py
new file mode 100644
index 0000000000000000000000000000000000000000..d954a265242a5f7e0cb3f75ea8b5be37c8a55bd7
--- /dev/null
+++ b/cinoc/app/engines.py
@@ -0,0 +1,325 @@
+"""Détection runtime de **disponibilité des moteurs** (couche 6).
+
+Alimente l'onglet « Moteurs » : pour chaque kind du socle, dit s'il est
+**utilisable ici et maintenant** et *pourquoi pas* le cas échéant. Les sondes
+sont **bon marché et sans effet de bord** — on ne lance aucun moteur, on ne
+touche pas le réseau : présence d'un binaire (``shutil.which``), d'un SDK
+(``importlib.util.find_spec``, **sans importer**), d'une clé d'API (env). Un
+moteur cloud est dispo dès que **SDK + clé** sont là (« clé posée → ça marche »),
+sans masquage par mode public — la sécurité d'un Space exposé tient à sa visibilité.
+
+Sondes **injectables** → la détection est déterministe en test, indépendante de
+l'environnement de CI (où tesseract peut être présent ou non).
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import os
+import shutil
+from collections.abc import Callable
+
+from pydantic import BaseModel, ConfigDict
+
+BinaryProbe = Callable[[str], str | None]
+ModuleProbe = Callable[[str], bool]
+EnvProbe = Callable[[str], str | None]
+
+
+class EngineStatus(BaseModel):
+    """État d'un moteur du socle pour l'onglet « Moteurs »."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    kind: str
+    label: str
+    available: bool
+    detail: str
+
+
+#: Fournit l'état courant des moteurs (capturé par ``create_app`` avec le mode).
+#: Source unique du contrat ; les routeurs (couche 8) l'importent — pas de copie.
+StatusProvider = Callable[[], tuple[EngineStatus, ...]]
+
+#: **Socle first-party gratuit** exécutable sur une instance **publique** (Space).
+#: Seuls ces kinds tournent en mode public : ils sont **gratuits, sans clé et
+#: locaux** (aucun secret exposé, aucun appel cloud facturé). Tout le reste —
+#: moteurs cloud (clé), HTR lourds, et a fortiori les **plugins tiers** — reste
+#: *gated* (``403``, fail-closed) : un kind ajouté plus tard est refusé par défaut
+#: tant qu'il n'est pas explicitement inscrit ici. ``precomputed`` est le moteur de
+#: **démonstration** (jamais un concurrent OCR câblé) ; ``tesseract`` est le seul
+#: moteur réel offert au visiteur du Space public.
+PUBLIC_ENGINE_KINDS: frozenset[str] = frozenset({"precomputed", "tesseract"})
+
+
+def _module_present(name: str) -> bool:
+    try:
+        return importlib.util.find_spec(name) is not None
+    except (ImportError, ValueError):  # parent absent / nom dégénéré
+        return False
+
+
+def engine_statuses(
+    *,
+    has_binary: BinaryProbe = shutil.which,
+    has_module: ModuleProbe = _module_present,
+    get_env: EnvProbe = os.environ.get,
+) -> tuple[EngineStatus, ...]:
+    """État de chaque moteur du socle (ordre stable), selon les sondes fournies.
+
+    Un moteur cloud (OpenAI/Anthropic/Mistral) est disponible **dès que son SDK et
+    sa clé sont présents** — indépendamment du mode public (« clé posée → ça
+    marche »). La protection d'un Space exposé relève de sa **visibilité** (privé)
+    et de la présence/absence de la clé, pas d'un masquage côté appli.
+    """
+    return (
+        EngineStatus(
+            kind="precomputed",
+            label="Pré-calculé",
+            available=True,
+            detail="intégré (aucune dépendance)",
+        ),
+        _tesseract_status(has_binary, has_module),
+        _kraken_status(has_module),
+        _pero_status(has_module),
+        _calamari_status(has_module),
+        _mistral_ocr_status(has_module, get_env),
+        _google_vision_status(has_module, get_env),
+        _azure_di_status(has_module, get_env),
+        _openai_status(has_module, get_env),
+        _anthropic_status(has_module, get_env),
+        _mistral_status(has_module, get_env),
+        _ollama_status(has_module),
+    )
+
+
+def _tesseract_status(has_binary: BinaryProbe, has_module: ModuleProbe) -> EngineStatus:
+    if has_binary("tesseract") is None:
+        detail, ok = "binaire « tesseract » introuvable", False
+    elif not has_module("pytesseract"):
+        detail, ok = "pytesseract non installé (extra [tesseract])", False
+    else:
+        detail, ok = "prêt (binaire + pytesseract)", True
+    return EngineStatus(
+        kind="tesseract", label="Tesseract", available=ok, detail=detail
+    )
+
+
+def _kraken_status(has_module: ModuleProbe) -> EngineStatus:
+    if not has_module("kraken"):
+        detail, ok = "SDK kraken non installé (extra [kraken])", False
+    else:
+        detail, ok = "prêt (SDK ; fournir un modèle .mlmodel au lancement)", True
+    return EngineStatus(
+        kind="kraken", label="Kraken (HTR)", available=ok, detail=detail
+    )
+
+
+def _pero_status(has_module: ModuleProbe) -> EngineStatus:
+    if not has_module("pero_ocr"):
+        detail, ok = "lib pero_ocr non installée (extra [pero])", False
+    else:
+        detail, ok = "prêt (lib ; fournir un modèle PERO au lancement)", True
+    return EngineStatus(kind="pero", label="PERO", available=ok, detail=detail)
+
+
+def _calamari_status(has_module: ModuleProbe) -> EngineStatus:
+    if not has_module("calamari_ocr"):
+        detail, ok = "lib calamari_ocr non installée (extra [calamari])", False
+    else:
+        detail, ok = "prêt (lib ; fournir un checkpoint au lancement)", True
+    return EngineStatus(kind="calamari", label="Calamari", available=ok, detail=detail)
+
+
+def _mistral_ocr_status(has_module: ModuleProbe, get_env: EnvProbe) -> EngineStatus:
+    if not has_module("mistralai"):
+        detail, ok = "SDK mistralai non installé (extra [mistral])", False
+    elif not get_env("MISTRAL_API_KEY"):
+        detail, ok = "clé MISTRAL_API_KEY absente", False
+    else:
+        detail, ok = "prêt (SDK + clé)", True
+    return EngineStatus(
+        kind="mistral_ocr", label="Mistral OCR", available=ok, detail=detail
+    )
+
+
+def _google_vision_status(has_module: ModuleProbe, get_env: EnvProbe) -> EngineStatus:
+    if not has_module("httpx"):
+        detail, ok = "httpx non installé (extra [google])", False
+    elif not get_env("GOOGLE_VISION_API_KEY"):
+        detail, ok = "clé GOOGLE_VISION_API_KEY absente", False
+    else:
+        detail, ok = "prêt (REST + clé)", True
+    return EngineStatus(
+        kind="google_vision", label="Google Vision", available=ok, detail=detail
+    )
+
+
+def _azure_di_status(has_module: ModuleProbe, get_env: EnvProbe) -> EngineStatus:
+    if not has_module("httpx"):
+        detail, ok = "httpx non installé (extra [azure])", False
+    elif not get_env("AZURE_DOC_INTEL_ENDPOINT"):
+        detail, ok = "endpoint AZURE_DOC_INTEL_ENDPOINT absent", False
+    elif not get_env("AZURE_DOC_INTEL_KEY"):
+        detail, ok = "clé AZURE_DOC_INTEL_KEY absente", False
+    else:
+        detail, ok = "prêt (REST + endpoint + clé)", True
+    return EngineStatus(
+        kind="azure_di",
+        label="Azure Document Intelligence",
+        available=ok,
+        detail=detail,
+    )
+
+
+def _openai_status(has_module: ModuleProbe, get_env: EnvProbe) -> EngineStatus:
+    if not has_module("openai"):
+        detail, ok = "SDK openai non installé (extra [openai])", False
+    elif not get_env("OPENAI_API_KEY"):
+        detail, ok = "clé OPENAI_API_KEY absente", False
+    else:
+        detail, ok = "prêt (SDK + clé)", True
+    return EngineStatus(kind="openai", label="OpenAI", available=ok, detail=detail)
+
+
+def _anthropic_status(has_module: ModuleProbe, get_env: EnvProbe) -> EngineStatus:
+    if not has_module("anthropic"):
+        detail, ok = "SDK anthropic non installé (extra [anthropic])", False
+    elif not get_env("ANTHROPIC_API_KEY"):
+        detail, ok = "clé ANTHROPIC_API_KEY absente", False
+    else:
+        detail, ok = "prêt (SDK + clé)", True
+    return EngineStatus(
+        kind="anthropic", label="Anthropic", available=ok, detail=detail
+    )
+
+
+def _mistral_status(has_module: ModuleProbe, get_env: EnvProbe) -> EngineStatus:
+    if not has_module("mistralai"):
+        detail, ok = "SDK mistralai non installé (extra [mistral])", False
+    elif not get_env("MISTRAL_API_KEY"):
+        detail, ok = "clé MISTRAL_API_KEY absente", False
+    else:
+        detail, ok = "prêt (SDK + clé)", True
+    return EngineStatus(kind="mistral", label="Mistral", available=ok, detail=detail)
+
+
+def _ollama_status(has_module: ModuleProbe) -> EngineStatus:
+    if not has_module("httpx"):
+        detail, ok = "httpx non installé", False
+    else:
+        detail, ok = "serveur local attendu (non sondé)", True
+    return EngineStatus(kind="ollama", label="Ollama", available=ok, detail=detail)
+
+
+def ner_status(*, has_module: ModuleProbe = _module_present) -> EngineStatus:
+    """Disponibilité de l'**étape NER** (extra ``[ner]``, spaCy).
+
+    Catégorie **distincte** des moteurs de transcription : la NER est une brique
+    de post-traitement (``texte → ENTITIES``), pas un moteur — elle n'apparaît
+    pas dans le ``<select>`` moteur. **Jamais masquée en mode public** : spaCy est
+    une lib **locale** first-party (pas de clé, pas d'appel cloud), comme
+    ``tesseract``. Le modèle spaCy lui-même est résolu à l'exécution (un modèle
+    absent → erreur d'étape claire, fail-closed)."""
+    if has_module("spacy"):
+        detail, ok = "prêt (spaCy installé)", True
+    else:
+        detail, ok = "spaCy non installé (extra [ner])", False
+    return EngineStatus(kind="ner", label="NER (spaCy)", available=ok, detail=detail)
+
+
+def segmenter_statuses(
+    *, has_module: ModuleProbe = _module_present
+) -> tuple[EngineStatus, ...]:
+    """Disponibilité des **segmenteurs** de mise en page du socle.
+
+    Catégorie **distincte** des moteurs de transcription : un segmenteur produit
+    un ``LAYOUT`` (géométrie), pas du texte — il n'apparaît donc pas dans le
+    ``<select>`` moteur du lanceur OCR. **Jamais masqué en mode public** : un
+    segmenteur du socle tourne en **local** (PaddleX) ou **délègue** à un endpoint
+    distant (``remote_segmenter``) → pas de surface filesystem cloud à masquer.
+
+    Deux segmenteurs maison :
+
+    - ``pp_doclayout`` — modèle **local** PP-DocLayout (extra ``[segment]`` +
+      poids) ;
+    - ``remote_segmenter`` — **délégué** à un endpoint object-detection HF
+      (``httpx``), le modèle tourne à distance : on change de modèle en
+      changeant l'``endpoint``, rien à installer ni à baker.
+    """
+    if has_module("paddlex"):
+        paddle_detail, paddle_ok = "prêt (PaddleX installé)", True
+    else:
+        paddle_detail, paddle_ok = "PaddleX non installé (extra [segment])", False
+    if has_module("httpx"):
+        remote_detail, remote_ok = "prêt (endpoint distant à fournir)", True
+    else:
+        remote_detail, remote_ok = "httpx non installé", False
+    return (
+        EngineStatus(
+            kind="pp_doclayout",
+            label="PP-DocLayout",
+            available=paddle_ok,
+            detail=paddle_detail,
+        ),
+        EngineStatus(
+            kind="remote_segmenter",
+            label="Segmenteur distant (HF)",
+            available=remote_ok,
+            detail=remote_detail,
+        ),
+    )
+
+
+def installed_ollama_models() -> tuple[str, ...]:
+    """Modèles **réellement installés** sur le serveur ollama local (commodité UI).
+
+    Best-effort : serveur injoignable / extra absent → ``()`` (l'UI retombe sur la
+    saisie libre). Sert à proposer un **menu déroulant** des modèles disponibles
+    au lieu d'une saisie à l'aveugle. Import local : ne charge ``httpx`` que si on
+    interroge réellement le serveur.
+    """
+    from cinoc.adapters.llm.ollama import list_installed_models
+
+    return list_installed_models()
+
+
+def installed_mistral_models() -> tuple[str, ...]:
+    """Modèles Mistral disponibles pour la clé courante (menu déroulant, UI).
+
+    Best-effort : clé/SDK absent → ``()`` (saisie libre). Rien de hardcodé : la
+    liste vient de l'API Mistral. Import local (ne charge le SDK qu'au besoin).
+    """
+    from cinoc.adapters.llm.mistral import list_mistral_models
+
+    return list_mistral_models()
+
+
+def normalization_profiles() -> tuple[str, ...]:
+    """Noms des profils de normalisation, lus **dynamiquement** (jamais une
+    liste statique — un profil ajouté en couche 2 apparaît ici sans câblage)."""
+    from cinoc.formats.text.normalization import NORMALIZATION_PROFILES
+
+    return tuple(sorted(NORMALIZATION_PROFILES))
+
+
+def curated_prompts() -> tuple[str, ...]:
+    """Noms des **prompts curés** (``cinoc.prompts``), lus **dynamiquement**.
+
+    Comme les profils de normalisation : un prompt ``.txt`` ajouté au paquet
+    apparaît ici (et au formulaire) sans câblage. Import local (zéro effet de bord)."""
+    from cinoc.prompts import available_prompts
+
+    return available_prompts()
+
+
+__all__ = [
+    "normalization_profiles",
+    "curated_prompts",
+    "EngineStatus",
+    "PUBLIC_ENGINE_KINDS",
+    "StatusProvider",
+    "engine_statuses",
+    "ner_status",
+    "segmenter_statuses",
+]
diff --git a/cinoc/app/hipe_export.py b/cinoc/app/hipe_export.py
new file mode 100644
index 0000000000000000000000000000000000000000..2337323bf859b98a86c4ed2c283e183b827be1f4
--- /dev/null
+++ b/cinoc/app/hipe_export.py
@@ -0,0 +1,115 @@
+"""Export **JSONL HIPE-OCRepair** d'un run (couche 6 — SPEC_HIPE §7.4).
+
+Le format d'entrée du scorer/leaderboard porte les **textes** (GT, OCR brut,
+sortie corrigée — §4.8), pas les scores : l'export a donc besoin du corpus et
+des ``pipeline_outputs``, que seule l'app détient. Il se branche sur le seam
+``artifact_sink`` de l'orchestrateur (les URI des artefacts sont encore
+lisibles), sans second chemin d'exécution.
+
+Un fichier par pipeline (le format = une sortie système par enregistrement) :
+``out.jsonl`` pour un run mono-pipeline, ``out-<pipeline>.jsonl`` sinon.
+Sémantique des sorties manquantes (R-1.8, alignée scorer §4.6) : sortie absente
+→ chaîne vide (erreur maximale) + warning — jamais d'exclusion silencieuse.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from pathlib import Path
+
+from cinoc.app.orchestrator import ArtifactSink, PipelineOutputs
+from cinoc.domain.artifacts import ArtifactType
+from cinoc.domain.corpus import CorpusSpec
+from cinoc.domain.run import RunManifest
+from cinoc.evaluation.representations import load_representation
+
+logger = logging.getLogger(__name__)
+
+
+def _slug(name: str) -> str:
+    return re.sub(r"[^\w.-]+", "_", name)
+
+
+def _text_of(
+    outputs: PipelineOutputs, pipeline: str, document_id: str, kind: ArtifactType
+) -> str | None:
+    artifact = outputs.get(pipeline, {}).get(document_id, {}).get(kind)
+    if artifact is None or artifact.uri is None:
+        return None
+    return str(load_representation(artifact.uri, kind))
+
+
+def write_hipe_jsonl(
+    path: Path, corpus: CorpusSpec, outputs: PipelineOutputs
+) -> list[Path]:
+    """Écrit les enregistrements HIPE (§4.8) ; renvoie les fichiers produits.
+
+    GT = la vérité-terrain ``RAW_TEXT`` du document (sans GT texte → document
+    sauté avec warning : le scorer ne peut rien en faire). ``ocr_hypothesis`` =
+    l'étage brut ; ``ocr_postcorrection_output`` = l'étage corrigé, ou le brut
+    pour un pipeline mono-étage (la sortie système est alors l'OCR lui-même).
+    """
+    written: list[Path] = []
+    pipelines = list(outputs)
+    for pipeline in pipelines:
+        target = (
+            path
+            if len(pipelines) == 1
+            else path.with_name(f"{path.stem}-{_slug(pipeline)}{path.suffix}")
+        )
+        lines: list[str] = []
+        for document in corpus.documents:
+            gt_ref = document.gt_for(ArtifactType.RAW_TEXT)
+            if gt_ref is None:
+                logger.warning(
+                    "[hipe_export] %s : pas de GT texte — document sauté.",
+                    document.id,
+                )
+                continue
+            ground_truth = str(load_representation(gt_ref.uri, ArtifactType.RAW_TEXT))
+            raw = _text_of(outputs, pipeline, document.id, ArtifactType.RAW_TEXT)
+            corrected = _text_of(
+                outputs, pipeline, document.id, ArtifactType.CORRECTED_TEXT
+            )
+            if raw is None:
+                # R-1.8 : sortie manquante = chaîne vide (erreur maximale).
+                logger.warning(
+                    "[hipe_export] %s · %s : sortie absente — scorée vide (R-1.8).",
+                    pipeline,
+                    document.id,
+                )
+                raw = ""
+            system = corrected if corrected is not None else raw
+            lines.append(
+                json.dumps(
+                    {
+                        "document_metadata": {
+                            "document_id": document.id,
+                            "primary_dataset_name": corpus.name,
+                        },
+                        "ground_truth": {"transcription_unit": ground_truth},
+                        "ocr_hypothesis": {"transcription_unit": raw},
+                        "ocr_postcorrection_output": {"transcription_unit": system},
+                    },
+                    ensure_ascii=False,
+                    sort_keys=True,
+                )
+            )
+        target.write_text("\n".join(lines) + "\n", encoding="utf-8")
+        written.append(target)
+        logger.info("[hipe_export] %d enregistrements → %s", len(lines), target)
+    return written
+
+
+def hipe_jsonl_sink(path: Path, corpus: CorpusSpec) -> ArtifactSink:
+    """Sink d'orchestrateur : écrit le JSONL avant le nettoyage du workspace."""
+
+    def sink(outputs: PipelineOutputs, manifest: RunManifest) -> None:
+        write_hipe_jsonl(path, corpus, outputs)
+
+    return sink
+
+
+__all__ = ["hipe_jsonl_sink", "write_hipe_jsonl"]
diff --git a/cinoc/app/history.py b/cinoc/app/history.py
new file mode 100644
index 0000000000000000000000000000000000000000..20c46085e3259477a597d92da99e8ebd20141bac
--- /dev/null
+++ b/cinoc/app/history.py
@@ -0,0 +1,108 @@
+"""Historique longitudinal : enregistrement d'un run + lecture analysée (couche 6).
+
+Trait d'union entre le ``RunResult`` (couche 3, agrégats par pipeline/vue) et le
+``HistoryStore`` (couche 5, qui ne connaît que des lignes primitives). C'est ici —
+et pas dans le store — que vit la connaissance de la forme du ``RunResult`` :
+le store reste une persistance pure, réutilisable.
+
+Dans l'autre sens, ``series_insight`` analyse une série d'enregistrements :
+conversion des horodatages ISO (stricte — ligne illisible journalisée puis
+écartée, jamais un skip muet) puis tendance OLS + test de rupture de Pettitt
+(``evaluation.longitudinal``). Consommé par la page ``/history``.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Sequence
+from dataclasses import dataclass
+from datetime import UTC, datetime
+
+from cinoc.adapters.storage.history_store import HistoryRecord, HistoryStore
+from cinoc.evaluation.longitudinal import (
+    PettittResult,
+    TrendResult,
+    linear_trend,
+    pettitt,
+)
+from cinoc.evaluation.result import RunResult
+
+logger = logging.getLogger(__name__)
+
+
+def records_from_run(run_result: RunResult) -> tuple[HistoryRecord, ...]:
+    """Aplatit un ``RunResult`` en lignes d'historique (métriques applicables)."""
+    manifest = run_result.manifest
+    completed_at = manifest.completed_at.isoformat()
+    records: list[HistoryRecord] = []
+    for pipeline in run_result.pipelines:
+        for score in pipeline.aggregate:
+            if score.value is None:
+                continue
+            records.append(
+                HistoryRecord(
+                    run_id=manifest.run_id,
+                    completed_at=completed_at,
+                    corpus_name=manifest.corpus_name,
+                    code_version=manifest.code_version,
+                    pipeline=pipeline.pipeline,
+                    view=pipeline.view,
+                    metric=score.metric,
+                    value=score.value,
+                )
+            )
+    return tuple(records)
+
+
+def record_run(store: HistoryStore, run_result: RunResult) -> int:
+    """Persiste les agrégats d'un run dans l'historique ; renvoie le compte."""
+    return store.add(records_from_run(run_result))
+
+
+@dataclass(frozen=True)
+class SeriesInsight:
+    """Tendance + rupture d'une série (pipeline, vue, métrique) d'historique.
+
+    ``rupture_run_id`` = le **premier run du nouveau régime**, renseigné
+    seulement quand la rupture est significative (p ≤ α) — sinon il n'y a
+    rien à pointer, quelle que soit l'ampleur du delta.
+    """
+
+    trend: TrendResult | None
+    rupture: PettittResult | None
+    rupture_run_id: str | None
+
+
+def series_insight(records: Sequence[HistoryRecord]) -> SeriesInsight:
+    """Analyse une série d'enregistrements (tendance OLS + rupture Pettitt).
+
+    Les horodatages naïfs sont supposés UTC (le store n'écrit que de
+    l'ISO 8601 conscient du fuseau ; la normalisation couvre les données
+    importées) ; un horodatage illisible écarte sa ligne **avec warning**.
+    """
+    rows: list[tuple[datetime, str, float]] = []
+    for record in records:
+        try:
+            stamp = datetime.fromisoformat(record.completed_at)
+        except ValueError:
+            logger.warning(
+                "[history] horodatage illisible ignoré : %r (run %s)",
+                record.completed_at,
+                record.run_id,
+            )
+            continue
+        if stamp.tzinfo is None:
+            stamp = stamp.replace(tzinfo=UTC)
+        rows.append((stamp, record.run_id, record.value))
+    rows.sort(key=lambda row: (row[0], row[1]))
+    trend = linear_trend([(stamp, value) for stamp, _, value in rows])
+    rupture = pettitt([value for _, _, value in rows])
+    rupture_run_id = (
+        rows[rupture.boundary][1]
+        if rupture is not None and rupture.significant
+        else None
+    )
+    return SeriesInsight(trend=trend, rupture=rupture, rupture_run_id=rupture_run_id)
+
+
+__all__ = ["SeriesInsight", "record_run", "records_from_run", "series_insight"]
diff --git a/cinoc/app/jobs.py b/cinoc/app/jobs.py
new file mode 100644
index 0000000000000000000000000000000000000000..13d0484c501f341e10f59bc614b31b6a86ce713f
--- /dev/null
+++ b/cinoc/app/jobs.py
@@ -0,0 +1,259 @@
+"""``JobRunner`` — exécute un run **en arrière-plan**, annulable (couche 6).
+
+Le lanceur de fond : on lance ``orchestrator.run`` dans un
+thread *daemon*, on suit son état dans le ``JobStore`` (couche 5), et on câble
+l'**annulation coopérative** via ``RunControl`` (couche 4) — un ``cancel`` HTTP
+déclenche le signal que l'exécuteur sonde entre deux étapes.
+
+Le corpus est matérialisé par un *builder* dans un workspace temporaire **propre
+au job**, vivant le temps du run puis nettoyé : le run lit ses fichiers avant la
+fin. Le ``RunResult`` est écrit en JSON dans ``reports_dir`` → il apparaît
+aussitôt dans la vitrine read-only existante (preuve de bout en bout).
+
+La progression fine est diffusée via le journal du ``JobStore`` (SSE côté web).
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+from collections.abc import Callable, Mapping
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+from cinoc.adapters.storage.history_store import HistoryStore
+from cinoc.adapters.storage.job_store import JobState, JobStore
+from cinoc.adapters.storage.publisher import NoopPublisher, ResultPublisher
+from cinoc.app.alto_store import AltoStore
+from cinoc.app.history import record_run
+from cinoc.app.modules.registry import ModuleRegistry
+from cinoc.app.orchestrator import PipelineOutputs
+from cinoc.app.orchestrator import run as run_orchestrator
+from cinoc.app.results import dump_run_result
+from cinoc.app.segmentation import SegmentationStore
+from cinoc.domain.artifacts import Artifact, ArtifactType
+from cinoc.domain.errors import CinocError, RunCancelledError
+from cinoc.domain.layout import CanonicalLayout
+from cinoc.domain.run import RunManifest
+from cinoc.domain.run_spec import RunSpec
+from cinoc.evaluation.result import RunResult
+from cinoc.pipeline.run_control import RunControl
+
+logger = logging.getLogger(__name__)
+
+#: Construit le ``RunSpec`` d'un job en matérialisant son corpus dans le
+#: workspace fourni (vivant le temps du run).
+SpecBuilder = Callable[[Path], RunSpec]
+
+
+class JobRunner:
+    """Lance et suit des runs asynchrones, écrivant leurs ``RunResult``."""
+
+    def __init__(
+        self,
+        *,
+        store: JobStore,
+        registry: ModuleRegistry,
+        reports_dir: Path,
+        code_version: str,
+        publisher: ResultPublisher | None = None,
+        history_store: HistoryStore | None = None,
+        segmentation_store: SegmentationStore | None = None,
+        alto_store: AltoStore | None = None,
+    ) -> None:
+        self._store = store
+        self._registry = registry
+        self._reports_dir = reports_dir
+        self._code_version = code_version
+        #: Persistance : pousse le RunResult vers un dépôt distant. Inactif
+        #: par défaut (``NoopPublisher``) → aucun effet réseau sans secret.
+        self._publisher = publisher if publisher is not None else NoopPublisher()
+        #: Historique longitudinal : enregistre les agrégats de chaque run
+        #: terminé. ``None`` → pas de suivi (rétro-compatible).
+        self._history = history_store
+        #: Segmentation : persiste les ``LAYOUT`` produits (aperçu du lanceur).
+        #: ``None`` → pas de persistance de mise en page (rétro-compatible).
+        self._segmentation = segmentation_store
+        #: Export ALTO : persiste les ``ALTO_XML`` produits (téléchargeables par
+        #: run). ``None`` → pas d'export ALTO (rétro-compatible).
+        self._alto = alto_store
+        self._controls: dict[str, RunControl] = {}
+        self._threads: dict[str, threading.Thread] = {}
+        self._lock = threading.Lock()
+
+    @property
+    def store(self) -> JobStore:
+        """Le ``JobStore`` lu par le web pour restituer l'état des jobs."""
+        return self._store
+
+    def launch(self, build_spec: SpecBuilder) -> str:
+        """Crée un job, démarre son thread, renvoie son identifiant."""
+        job = self._store.create()
+        control = RunControl()
+        thread = threading.Thread(
+            target=self._execute,
+            args=(job.id, build_spec, control),
+            name=f"cinoc-job-{job.id[:8]}",
+            daemon=True,
+        )
+        with self._lock:
+            self._controls[job.id] = control
+            self._threads[job.id] = thread
+        thread.start()
+        return job.id
+
+    def cancel(self, job_id: str) -> bool:
+        """Demande l'annulation coopérative du job. ``False`` si inconnu/fini."""
+        with self._lock:
+            control = self._controls.get(job_id)
+        job = self._store.get(job_id)
+        if control is None or job is None or job.state.is_terminal:
+            return False
+        control.trigger_cancel()
+        return True
+
+    def join(self, job_id: str, timeout: float = 10.0) -> bool:
+        """Attend la fin du thread du job (usage tests). ``True`` si terminé."""
+        with self._lock:
+            thread = self._threads.get(job_id)
+        if thread is None:
+            return False
+        thread.join(timeout)
+        return not thread.is_alive()
+
+    def _execute(
+        self, job_id: str, build_spec: SpecBuilder, control: RunControl
+    ) -> None:
+        self._store.update(job_id, state=JobState.RUNNING)
+        try:
+            with TemporaryDirectory(prefix="cinoc-job-") as workspace:
+                spec = build_spec(Path(workspace))
+
+                def _on_progress(done: int, total: int) -> None:
+                    self._store.progress(job_id, done, total)
+
+                result = run_orchestrator(
+                    spec,
+                    registry=self._registry,
+                    code_version=self._code_version,
+                    control=control,
+                    artifact_sink=self._persist_artifacts,
+                    on_progress=_on_progress,
+                )
+                self._reports_dir.mkdir(parents=True, exist_ok=True)
+                run_id = result.manifest.run_id
+                result_path = self._reports_dir / f"{run_id}.json"
+                dump_run_result(result, result_path)
+                published_url = self._publish_safe(run_id, result_path)
+                self._record_safe(result)
+        except RunCancelledError:
+            self._store.update(job_id, state=JobState.CANCELLED)
+        except CinocError as exc:
+            logger.warning("[jobs] run %s échoué : %s", job_id, exc)
+            self._store.update(job_id, state=JobState.FAILED, error=str(exc))
+        except Exception as exc:
+            # Catch-all **intentionnel** (vérifié Lot G) : un thread worker ne doit
+            # jamais mourir en silence — toute erreur inattendue du run est tracée
+            # et le job passe FAILED (jamais bloqué en RUNNING).
+            logger.warning("[jobs] run %s erreur inattendue : %s", job_id, exc)
+            self._store.update(job_id, state=JobState.FAILED, error=str(exc))
+        else:
+            self._store.update(
+                job_id,
+                state=JobState.DONE,
+                report_name=run_id,
+                published_url=published_url,
+            )
+
+    def _persist_artifacts(
+        self, outputs: PipelineOutputs, manifest: RunManifest
+    ) -> None:
+        """Sink des artefacts durables (best-effort) : ``LAYOUT`` (→ segmentation)
+        et ``ALTO_XML`` (→ export téléchargeable). Un seul exécuteur : ces artefacts
+        sont produits par le run et le workspace temporaire les détruit — on les
+        capte ici avant nettoyage. Sans store dédié, ou run sans l'artefact → no-op.
+        Un échec n'abat pas le run (son ``RunResult`` est l'output)."""
+        for pipeline_name, per_document in outputs.items():
+            for document_id, artifacts in per_document.items():
+                self._persist_layout(pipeline_name, document_id, artifacts)
+                self._persist_alto(
+                    manifest.run_id, pipeline_name, document_id, artifacts
+                )
+
+    def _persist_layout(
+        self,
+        pipeline_name: str,
+        document_id: str,
+        artifacts: Mapping[ArtifactType, Artifact],
+    ) -> None:
+        """Persiste un ``LAYOUT`` produit dans le ``SegmentationStore`` (viz)."""
+        if self._segmentation is None:
+            return
+        layout_art = artifacts.get(ArtifactType.LAYOUT)
+        if layout_art is None or layout_art.uri is None:
+            return
+        try:
+            layout = CanonicalLayout.model_validate_json(
+                Path(layout_art.uri).read_bytes()
+            )
+            self._segmentation.save(layout)
+        except (OSError, ValueError) as exc:
+            logger.warning(
+                "[jobs] persistance LAYOUT (%s/%s) échouée : %s",
+                pipeline_name, document_id, exc,
+            )
+
+    def _persist_alto(
+        self,
+        run_id: str,
+        pipeline_name: str,
+        document_id: str,
+        artifacts: Mapping[ArtifactType, Artifact],
+    ) -> None:
+        """Persiste un ``ALTO_XML`` produit dans l'``AltoStore`` (export par run)."""
+        if self._alto is None:
+            return
+        alto_art = artifacts.get(ArtifactType.ALTO_XML)
+        if alto_art is None or alto_art.uri is None:
+            return
+        try:
+            self._alto.save(
+                run_id, document_id, pipeline_name, Path(alto_art.uri).read_bytes()
+            )
+        except OSError as exc:
+            logger.warning(
+                "[jobs] persistance ALTO (%s/%s) échouée : %s",
+                pipeline_name, document_id, exc,
+            )
+
+    def _record_safe(self, result: RunResult) -> None:
+        """Enregistre le run dans l'historique (best-effort) : un échec d'écriture
+        ne fait **pas** échouer le run — son résultat est déjà écrit et publié."""
+        if self._history is None:
+            return
+        try:
+            record_run(self._history, result)
+        except Exception as exc:
+            # Catch-all **intentionnel** (vérifié Lot G) : l'historique est un
+            # effet secondaire. Le narrower laisserait une erreur inattendue
+            # remonter au catch-all worker et marquer FAILED un run pourtant
+            # **réussi** (RunResult déjà écrit + publié). On trace, on n'échoue pas.
+            logger.warning(
+                "[jobs] historique de %s échoué : %s", result.manifest.run_id, exc
+            )
+
+    def _publish_safe(self, run_id: str, result_path: Path) -> str | None:
+        """Publie le résultat (best-effort) : un échec réseau ne fait PAS échouer
+        le run — le résultat local est déjà écrit."""
+        try:
+            return self._publisher.publish(run_id, result_path)
+        except Exception as exc:
+            # Catch-all **intentionnel** (vérifié Lot G) : `publish` est un effet
+            # secondaire au comportement variable (réseau, dépôt distant, impls
+            # tierces). Une publication ratée ne doit jamais faire échouer un run
+            # réussi (résultat local déjà écrit). On trace, on renvoie None.
+            logger.warning("[jobs] publication de %s échouée : %s", run_id, exc)
+            return None
+
+
+__all__ = ["JobRunner", "SpecBuilder"]
diff --git a/cinoc/app/loader.py b/cinoc/app/loader.py
new file mode 100644
index 0000000000000000000000000000000000000000..381eb96bab28e59f8eeb3b9db7d688848bd42d0c
--- /dev/null
+++ b/cinoc/app/loader.py
@@ -0,0 +1,79 @@
+"""Loader YAML → ``RunSpec`` (couche 6).
+
+Un run est décrit par un fichier YAML, **validé** par Pydantic
+(``RunSpec.model_validate`` — ``extra="forbid"`` rejette les clés inconnues),
+puis dont les **chemins sont sécurisés** (``validated_path``, relatifs au dossier
+du fichier ou à ``base_dir``). **Aucune résolution de classe d'adapter** ici : le
+registre résout ``adapter_name → Module`` au runtime (journal D-010) — donc pas
+d'import de chemin pointé arbitraire.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+from pydantic import ValidationError
+
+from cinoc.app.security import validated_path
+from cinoc.domain.documents import DocumentRef
+from cinoc.domain.errors import CinocError
+from cinoc.domain.run_spec import RunSpec
+
+
+class RunSpecError(CinocError):
+    """Le fichier de run est illisible ou ne décrit pas un ``RunSpec`` valide."""
+
+
+def load_run_spec(
+    path: str | Path, *, base_dir: str | Path | None = None
+) -> RunSpec:
+    """Charge un ``RunSpec`` depuis un YAML, chemins sécurisés sous ``base_dir``."""
+    yaml_path = Path(path)
+    base = Path(base_dir) if base_dir is not None else yaml_path.parent
+    try:
+        raw = yaml.safe_load(yaml_path.read_text(encoding="utf-8"))
+    except (OSError, yaml.YAMLError) as exc:
+        raise RunSpecError(f"YAML illisible : {exc}.") from exc
+    if not isinstance(raw, dict):
+        raise RunSpecError("YAML : un objet est attendu à la racine.")
+    try:
+        spec = RunSpec.model_validate(raw)
+    except ValidationError as exc:
+        raise RunSpecError(f"RunSpec invalide : {exc}.") from exc
+    return _secure_paths(spec, base)
+
+
+def _secure_paths(spec: RunSpec, base: Path) -> RunSpec:
+    documents = tuple(_secure_document(doc, base) for doc in spec.corpus.documents)
+    corpus = spec.corpus.model_copy(update={"documents": documents})
+    return spec.model_copy(update={"corpus": corpus})
+
+
+def _secure_document(document: DocumentRef, base: Path) -> DocumentRef:
+    # Une image **distante** (corpus curé : référence http/https épinglée) passe
+    # telle quelle — l'orchestrateur la matérialise au run via le fetch durci
+    # (anti-SSRF + plafond). ``validated_path`` ne garde que les chemins locaux.
+    raw_image = document.image_uri
+    if raw_image is not None and raw_image.startswith(("http://", "https://")):
+        image_uri: str | None = raw_image
+    else:
+        image_uri = (
+            str(validated_path(raw_image, base)) if raw_image is not None else None
+        )
+    # La vérité-terrain est lue par l'évaluation : exiger son existence dès le
+    # chargement donne une erreur claire (RunSpecError) au lieu d'un OSError
+    # opaque en plein run. L'image, elle, n'est pas exigée ici — certains modules
+    # (precomputed) ne la lisent pas, et tesseract signale clairement son absence.
+    ground_truths = tuple(
+        truth.model_copy(
+            update={"uri": str(validated_path(truth.uri, base, must_exist=True))}
+        )
+        for truth in document.ground_truths
+    )
+    return document.model_copy(
+        update={"image_uri": image_uri, "ground_truths": ground_truths}
+    )
+
+
+__all__ = ["RunSpecError", "load_run_spec"]
diff --git a/cinoc/app/models.py b/cinoc/app/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ccd3c132e64d7c8ff69976b0a03f0534778c5d0
--- /dev/null
+++ b/cinoc/app/models.py
@@ -0,0 +1,50 @@
+"""Catalogue **canonique** de modèles par fournisseur LLM/VLM (couche 6) — pour l'UI.
+
+Liste curée des modèles d'un fournisseur avec leur **capacité vision** (utile aux
+modes ``zero_shot``/``text_and_image`` qui exigent un VLM). Alimente
+``/api/models/{provider}`` → le formulaire suggère les modèles ; le champ ``model``
+reste **libre** (un modèle hors liste est accepté). Concern **distinct** de
+``pricing.json`` (coût) — on ne couple pas. Les modèles **réellement installés**
+ollama/mistral ont leur propre canal *live* (``installed_*_models``).
+
+Étendre la liste = modifier ``_CANONICAL`` **ici** (source unique des suggestions).
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict
+
+
+class ModelInfo(BaseModel):
+    """Un modèle suggéré : son nom + s'il accepte une image (vision)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    name: str
+    vision: bool
+
+
+#: Modèles canoniques par fournisseur (nom, vision). Curé.
+_CANONICAL: dict[str, tuple[tuple[str, bool], ...]] = {
+    "openai": (("gpt-4o-mini", True), ("gpt-4o", True)),
+    "anthropic": (
+        ("claude-haiku-4-5-20251001", True),
+        ("claude-sonnet-4-6", True),
+    ),
+    "mistral": (
+        ("mistral-small-latest", False),
+        ("mistral-large-latest", False),
+        ("pixtral-12b-latest", True),
+    ),
+}
+
+
+def provider_models(provider: str) -> tuple[ModelInfo, ...]:
+    """Modèles canoniques du ``provider`` ; **vide** si inconnu (fallback gracieux)."""
+    return tuple(
+        ModelInfo(name=name, vision=vision)
+        for name, vision in _CANONICAL.get(provider, ())
+    )
+
+
+__all__ = ["ModelInfo", "provider_models"]
diff --git a/cinoc/app/modules/__init__.py b/cinoc/app/modules/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4c39ca0d8b066a99a3b37fa2860aeaa9c304603c
--- /dev/null
+++ b/cinoc/app/modules/__init__.py
@@ -0,0 +1,18 @@
+"""Registre + factory de modules (couche 6)."""
+
+from __future__ import annotations
+
+from cinoc.app.modules.discovery import ENTRY_POINT_GROUP, discover_plugins
+from cinoc.app.modules.registry import (
+    ModuleRegistry,
+    ModuleResolutionError,
+    register_default_modules,
+)
+
+__all__ = [
+    "ENTRY_POINT_GROUP",
+    "ModuleRegistry",
+    "ModuleResolutionError",
+    "discover_plugins",
+    "register_default_modules",
+]
diff --git a/cinoc/app/modules/discovery.py b/cinoc/app/modules/discovery.py
new file mode 100644
index 0000000000000000000000000000000000000000..a6953c940a66ba28a9b1f9106ef76a3c21746d0e
--- /dev/null
+++ b/cinoc/app/modules/discovery.py
@@ -0,0 +1,94 @@
+"""Découverte de modules de pipeline **tiers** via entry-points (couche 6).
+
+Le **seul** point d'extension tiers du produit (CLAUDE.md §3) : un paquet pip
+déclare ::
+
+    [project.entry-points."cinoc.modules"]
+    yolo_seg = "mon_paquet.seg:build_yolo"
+
+Chaque entrée nomme un ``kind`` (``yolo_seg``) et charge un ``ModuleBuilder``
+(``build_yolo``), enregistré dans le ``ModuleRegistry`` runtime — **exactement**
+comme le socle (``register_default_modules``), même ``Module`` Protocol, seule la
+source diffère. Un YOLO de segmentation se branche ainsi **sans forker** : c'est
+un ``Module`` ``IMAGE → LAYOUT`` que le fan-out consomme comme les autres.
+
+**Sécurité** : le code tiers s'exécute **in-process**. En **mode public** la
+découverte est **désactivée (fail-closed)** — jamais de chargement de code
+arbitraire sur un serveur exposé. Un plugin défectueux est **journalisé et
+ignoré**, il n'abat pas le démarrage.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable, Iterable
+from typing import Protocol
+
+from cinoc.app.modules.registry import ModuleRegistry
+
+logger = logging.getLogger(__name__)
+
+#: Groupe d'entry-points scanné pour les modules de pipeline tiers.
+ENTRY_POINT_GROUP = "cinoc.modules"
+
+
+class _EntryPoint(Protocol):
+    """Forme minimale consommée d'un entry-point (``importlib.metadata``)."""
+
+    @property
+    def name(self) -> str: ...
+
+    def load(self) -> object: ...
+
+
+#: Fournit les entry-points du groupe — injectable pour les tests.
+EntryPointsLoader = Callable[[], Iterable[_EntryPoint]]
+
+
+def _default_entry_points() -> Iterable[_EntryPoint]:
+    from importlib.metadata import entry_points
+
+    return entry_points(group=ENTRY_POINT_GROUP)
+
+
+def discover_plugins(
+    registry: ModuleRegistry,
+    *,
+    enabled: bool,
+    entry_points_loader: EntryPointsLoader | None = None,
+) -> tuple[str, ...]:
+    """Enregistre les builders tiers du groupe ``cinoc.modules`` dans ``registry``.
+
+    Renvoie les ``kind`` découverts (ordre de découverte). ``enabled=False``
+    (mode public) → aucune découverte. Un entry-point qui échoue à charger, ou
+    qui ne fournit pas un builder appelable, est **journalisé et sauté**.
+    """
+    if not enabled:
+        logger.info("[plugins] découverte désactivée (mode public, fail-closed)")
+        return ()
+    loader = entry_points_loader or _default_entry_points
+    discovered: list[str] = []
+    for entry_point in loader():
+        try:
+            builder = entry_point.load()
+        except Exception as exc:  # le code tiers peut lever n'importe quoi
+            logger.warning(
+                "[plugins] entry-point %r : chargement échoué, ignoré : %s",
+                entry_point.name,
+                exc,
+            )
+            continue
+        if not callable(builder):
+            logger.warning(
+                "[plugins] entry-point %r : %r n'est pas un builder appelable, ignoré",
+                entry_point.name,
+                type(builder).__name__,
+            )
+            continue
+        registry.register_builder(entry_point.name, builder)
+        discovered.append(entry_point.name)
+        logger.info("[plugins] module tiers enregistré : %r", entry_point.name)
+    return tuple(discovered)
+
+
+__all__ = ["ENTRY_POINT_GROUP", "EntryPointsLoader", "discover_plugins"]
diff --git a/cinoc/app/modules/registry.py b/cinoc/app/modules/registry.py
new file mode 100644
index 0000000000000000000000000000000000000000..dc6413cc6fd9bd04b068edd163916c9e3a2f1055
--- /dev/null
+++ b/cinoc/app/modules/registry.py
@@ -0,0 +1,347 @@
+"""Registre + factory de modules (couche 6).
+
+Résout un ``adapter_name`` (convention ``<kind>:<label>``) vers une instance de
+``Module`` (couche 4) en appelant un **builder** enregistré pour le ``kind``.
+C'est le **seul** point d'extension du produit : le socle est enregistré
+**en dur** (``register_default_modules``) ; la **découverte de plugins tiers**
+(entry-points ``cinoc.modules``, cf. ``app.modules.discovery``) — même résolution
+``name → Module``, source différente.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+
+from cinoc.domain.errors import CinocError
+from cinoc.pipeline.protocols import Module, ParamValue
+
+#: Construit une instance de module depuis ses kwargs de construction.
+ModuleBuilder = Callable[[Mapping[str, ParamValue]], Module]
+
+
+class ModuleResolutionError(CinocError):
+    """``kind`` inconnu, kwargs invalides, ou nom construit incohérent."""
+
+
+class ModuleRegistry:
+    """Associe un ``kind`` à un builder, et construit les modules d'un run."""
+
+    def __init__(self) -> None:
+        self._builders: dict[str, ModuleBuilder] = {}
+
+    def register_builder(self, kind: str, builder: ModuleBuilder) -> None:
+        """Enregistre (ou remplace) le builder d'un ``kind``. Idempotent."""
+        self._builders[kind] = builder
+
+    def kinds(self) -> tuple[str, ...]:
+        return tuple(sorted(self._builders))
+
+    def build(self, adapter_name: str, kwargs: Mapping[str, ParamValue]) -> Module:
+        """Construit le module ``adapter_name`` (``kind`` = avant le ``:``)."""
+        kind = adapter_name.split(":", 1)[0]
+        builder = self._builders.get(kind)
+        if builder is None:
+            raise ModuleResolutionError(
+                f"aucun builder pour le kind {kind!r} (module {adapter_name!r})."
+            )
+        module = builder(kwargs)
+        if module.name != adapter_name:
+            raise ModuleResolutionError(
+                f"module construit {module.name!r} ≠ nom déclaré "
+                f"{adapter_name!r} (kwargs incohérents ?)."
+            )
+        return module
+
+
+def _build_precomputed(kwargs: Mapping[str, ParamValue]) -> Module:
+    label = kwargs.get("source_label")
+    if not isinstance(label, str):
+        raise ModuleResolutionError(
+            "precomputed : 'source_label' (str) requis dans adapter_kwargs."
+        )
+    from cinoc.adapters.ocr.precomputed import PrecomputedTextAdapter
+
+    return PrecomputedTextAdapter(source_label=label)
+
+
+def _build_kraken(kwargs: Mapping[str, ParamValue]) -> Module:
+    label = kwargs.get("label")
+    model = kwargs.get("model")
+    if not isinstance(label, str):
+        raise ModuleResolutionError(
+            "kraken : 'label' (str) requis dans adapter_kwargs."
+        )
+    if not isinstance(model, str) or not model:
+        raise ModuleResolutionError(
+            "kraken : 'model' (chemin .mlmodel) requis dans adapter_kwargs."
+        )
+    from cinoc.adapters.ocr.kraken import KrakenAdapter
+
+    return KrakenAdapter(label=label, model=model)
+
+
+def _build_mistral_ocr(kwargs: Mapping[str, ParamValue]) -> Module:
+    label = kwargs.get("label")
+    if not isinstance(label, str):
+        raise ModuleResolutionError(
+            "mistral_ocr : 'label' (str) requis dans adapter_kwargs."
+        )
+    from cinoc.adapters.ocr.mistral_ocr import MistralOCRAdapter
+
+    return MistralOCRAdapter(
+        label=label, model=str(kwargs.get("model", "mistral-ocr-latest"))
+    )
+
+
+def _build_pero(kwargs: Mapping[str, ParamValue]) -> Module:
+    label = kwargs.get("label")
+    model = kwargs.get("model")
+    if not isinstance(label, str):
+        raise ModuleResolutionError("pero : 'label' (str) requis dans adapter_kwargs.")
+    if not isinstance(model, str) or not model:
+        raise ModuleResolutionError(
+            "pero : 'model' (chemin de config PERO) requis dans adapter_kwargs."
+        )
+    from cinoc.adapters.ocr.pero import PeroAdapter
+
+    return PeroAdapter(label=label, model=model)
+
+
+def _build_calamari(kwargs: Mapping[str, ParamValue]) -> Module:
+    label = kwargs.get("label")
+    model = kwargs.get("model")
+    if not isinstance(label, str):
+        raise ModuleResolutionError(
+            "calamari : 'label' (str) requis dans adapter_kwargs."
+        )
+    if not isinstance(model, str) or not model:
+        raise ModuleResolutionError(
+            "calamari : 'model' (checkpoint) requis dans adapter_kwargs."
+        )
+    from cinoc.adapters.ocr.calamari import CalamariAdapter
+
+    return CalamariAdapter(label=label, model=model)
+
+
+def _build_google_vision(kwargs: Mapping[str, ParamValue]) -> Module:
+    label = kwargs.get("label")
+    if not isinstance(label, str):
+        raise ModuleResolutionError(
+            "google_vision : 'label' (str) requis dans adapter_kwargs."
+        )
+    from cinoc.adapters.ocr.google_vision import GoogleVisionAdapter
+
+    # `lang` (passé par le planificateur à tout moteur OCR) est ignoré : Vision
+    # détecte la langue en `DOCUMENT_TEXT_DETECTION` (pas de hint fragile à mapper).
+    return GoogleVisionAdapter(label=label)
+
+
+def _build_azure_di(kwargs: Mapping[str, ParamValue]) -> Module:
+    label = kwargs.get("label")
+    if not isinstance(label, str):
+        raise ModuleResolutionError(
+            "azure_di : 'label' (str) requis dans adapter_kwargs."
+        )
+    from cinoc.adapters.ocr.azure_di import AzureDocIntelAdapter
+
+    # `lang` (passé par le planificateur à tout moteur OCR) ignoré : le modèle
+    # `prebuilt-read` détecte la langue (pas de paramètre de langue à mapper).
+    return AzureDocIntelAdapter(label=label)
+
+
+def _build_tesseract(kwargs: Mapping[str, ParamValue]) -> Module:
+    label = kwargs.get("label")
+    if not isinstance(label, str):
+        raise ModuleResolutionError(
+            "tesseract : 'label' (str) requis dans adapter_kwargs."
+        )
+    from cinoc.adapters.ocr.tesseract import TesseractAdapter
+
+    return TesseractAdapter(
+        label=label,
+        lang=str(kwargs.get("lang", "fra")),
+        psm=int(kwargs.get("psm", 6)),
+        oem=int(kwargs.get("oem", 3)),
+        alto=bool(kwargs.get("alto", False)),
+    )
+
+
+def _build_openai(kwargs: Mapping[str, ParamValue]) -> Module:
+    label = kwargs.get("label")
+    if not isinstance(label, str):
+        raise ModuleResolutionError(
+            "openai : 'label' (str) requis dans adapter_kwargs."
+        )
+    from cinoc.adapters.llm.openai import OpenAIAdapter
+
+    prompt = kwargs.get("prompt")
+    return OpenAIAdapter(
+        label=label,
+        model=str(kwargs.get("model", "gpt-4o-mini")),
+        role=str(kwargs.get("role", "text_only")),
+        prompt=prompt if isinstance(prompt, str) else None,
+    )
+
+
+def _build_ollama(kwargs: Mapping[str, ParamValue]) -> Module:
+    label = kwargs.get("label")
+    if not isinstance(label, str):
+        raise ModuleResolutionError(
+            "ollama : 'label' (str) requis dans adapter_kwargs."
+        )
+    from cinoc.adapters.llm.ollama import OllamaAdapter
+
+    prompt = kwargs.get("prompt")
+    extra = {"prompt": prompt} if isinstance(prompt, str) else {}
+    return OllamaAdapter(
+        label=label,
+        model=str(kwargs.get("model", "llama3")),
+        host=str(kwargs.get("host", "http://localhost:11434")),
+        **extra,
+    )
+
+
+def _build_mistral(kwargs: Mapping[str, ParamValue]) -> Module:
+    label = kwargs.get("label")
+    if not isinstance(label, str):
+        raise ModuleResolutionError(
+            "mistral : 'label' (str) requis dans adapter_kwargs."
+        )
+    from cinoc.adapters.llm.mistral import MistralAdapter
+
+    prompt = kwargs.get("prompt")
+    return MistralAdapter(
+        label=label,
+        model=str(kwargs.get("model", "mistral-small-latest")),
+        role=str(kwargs.get("role", "text_only")),
+        prompt=prompt if isinstance(prompt, str) else None,
+    )
+
+
+def _build_anthropic(kwargs: Mapping[str, ParamValue]) -> Module:
+    label = kwargs.get("label")
+    if not isinstance(label, str):
+        raise ModuleResolutionError(
+            "anthropic : 'label' (str) requis dans adapter_kwargs."
+        )
+    from cinoc.adapters.llm.anthropic import AnthropicAdapter
+
+    prompt = kwargs.get("prompt")
+    return AnthropicAdapter(
+        label=label,
+        model=str(kwargs.get("model", "claude-haiku-4-5-20251001")),
+        role=str(kwargs.get("role", "text_only")),
+        prompt=prompt if isinstance(prompt, str) else None,
+    )
+
+
+def _build_precomputed_layout(kwargs: Mapping[str, ParamValue]) -> Module:
+    from cinoc.adapters.layout.precomputed import PrecomputedLayoutSource
+
+    return PrecomputedLayoutSource()
+
+
+def _build_pp_doclayout(kwargs: Mapping[str, ParamValue]) -> Module:
+    import os
+
+    from cinoc.adapters.layout.pp_doclayout import PPDocLayoutSegmenter
+
+    # Variante du modèle : kwarg explicite > env (l'image Space bake la variante
+    # légère via ``CINOC_PPDOCLAYOUT_MODEL=PP-DocLayout-S``) > défaut (-L qualité).
+    model = kwargs.get("model")
+    if not isinstance(model, str) or not model:
+        model = os.environ.get("CINOC_PPDOCLAYOUT_MODEL", "PP-DocLayout-L")
+    return PPDocLayoutSegmenter(model=model)
+
+
+def _build_remote_segmenter(kwargs: Mapping[str, ParamValue]) -> Module:
+    endpoint = kwargs.get("endpoint")
+    if not isinstance(endpoint, str) or not endpoint:
+        raise ModuleResolutionError(
+            "remote_segmenter : 'endpoint' (str) requis dans adapter_kwargs."
+        )
+    from cinoc.adapters.layout.remote import RemoteSegmenter
+
+    token = kwargs.get("token")
+    min_score = kwargs.get("min_score")
+    return RemoteSegmenter(
+        endpoint=endpoint,
+        token=token if isinstance(token, str) else None,
+        min_score=float(min_score) if isinstance(min_score, (int, float)) else 0.5,
+    )
+
+
+def _build_precomputed_region(kwargs: Mapping[str, ParamValue]) -> Module:
+    label = kwargs.get("source_label")
+    if not isinstance(label, str):
+        raise ModuleResolutionError(
+            "precomputed_region : 'source_label' (str) requis dans adapter_kwargs."
+        )
+    from cinoc.adapters.layout.precomputed import PrecomputedRegionRecognizer
+
+    return PrecomputedRegionRecognizer(source_label=label)
+
+
+def _build_alto_assembler(kwargs: Mapping[str, ParamValue]) -> Module:
+    from cinoc.adapters.layout.assembler import AltoAssembler
+
+    return AltoAssembler()
+
+
+def _build_layout_to_text(kwargs: Mapping[str, ParamValue]) -> Module:
+    label = kwargs.get("label")
+    if not isinstance(label, str):
+        raise ModuleResolutionError(
+            "layout_to_text : 'label' (str) requis dans adapter_kwargs."
+        )
+    from cinoc.adapters.layout.to_text import LayoutToTextExtractor
+
+    return LayoutToTextExtractor(label=label)
+
+
+def _build_ner(kwargs: Mapping[str, ParamValue]) -> Module:
+    label = kwargs.get("label")
+    if not isinstance(label, str):
+        raise ModuleResolutionError("ner : 'label' (str) requis dans adapter_kwargs.")
+    from cinoc.adapters.ner.spacy_extractor import SpacyNerExtractor
+
+    return SpacyNerExtractor(
+        label=label, model=str(kwargs.get("model", "fr_core_news_sm"))
+    )
+
+
+def register_default_modules(registry: ModuleRegistry) -> None:
+    """Enregistre le socle (starter pack). Aucun effet de bord à l'import."""
+    registry.register_builder("precomputed", _build_precomputed)
+    registry.register_builder("tesseract", _build_tesseract)
+    registry.register_builder("kraken", _build_kraken)
+    registry.register_builder("pero", _build_pero)
+    registry.register_builder("calamari", _build_calamari)
+    registry.register_builder("mistral_ocr", _build_mistral_ocr)
+    registry.register_builder("google_vision", _build_google_vision)
+    registry.register_builder("azure_di", _build_azure_di)
+    registry.register_builder("openai", _build_openai)
+    registry.register_builder("ollama", _build_ollama)
+    registry.register_builder("mistral", _build_mistral)
+    registry.register_builder("anthropic", _build_anthropic)
+    # Segmenteurs réels (étape IMAGE → LAYOUT), composables dès aujourd'hui.
+    registry.register_builder("pp_doclayout", _build_pp_doclayout)
+    registry.register_builder("remote_segmenter", _build_remote_segmenter)
+    registry.register_builder("ner", _build_ner)
+    # --- Enveloppe T5 : pipeline hybride seg → reconnaissance par région → ALTO ---
+    # Ces 3 briques (``Module`` Protocol) sont composées par
+    # ``run_planning.plan_hybrid_run`` (finition T5 livrée) : segmentation →
+    # reconnaissance par région (fanout, couche 4) → assemblage ALTO. Consommateur
+    # vérifié de bout en bout par ``tests/pipeline/test_t5_envelope.py``.
+    registry.register_builder("precomputed_layout", _build_precomputed_layout)
+    registry.register_builder("precomputed_region", _build_precomputed_region)
+    registry.register_builder("alto_assembler", _build_alto_assembler)
+    registry.register_builder("layout_to_text", _build_layout_to_text)
+
+
+__all__ = [
+    "ModuleBuilder",
+    "ModuleRegistry",
+    "ModuleResolutionError",
+    "register_default_modules",
+]
diff --git a/cinoc/app/normalization_preview.py b/cinoc/app/normalization_preview.py
new file mode 100644
index 0000000000000000000000000000000000000000..1e66c51dee3535a3384c4cd6b6df51fbed9c6131
--- /dev/null
+++ b/cinoc/app/normalization_preview.py
@@ -0,0 +1,46 @@
+"""Aperçu de normalisation (couche 6) — applique un profil à un échantillon.
+
+Sert le formulaire (``POST /api/normalization/preview``) : résout soit un profil
+**nommé** (socle couche 2), soit une **config YAML custom** (parsée à la volée,
+**jamais persistée**), et renvoie l'échantillon normalisé. La config custom est
+validée par Pydantic (clés inconnues interdites) ; toute config/erreur YAML remonte
+une ``NormalizationPreviewError`` typée (que la couche 8 traduit en ``422``).
+"""
+
+from __future__ import annotations
+
+import yaml
+from pydantic import ValidationError
+
+from cinoc.domain.errors import CinocError
+from cinoc.formats.text import NORMALIZATION_PROFILES
+from cinoc.formats.text.normalization import NormalizationProfile
+
+
+class NormalizationPreviewError(CinocError):
+    """Profil nommé inconnu, ou config YAML custom invalide."""
+
+
+def _resolve(profile: str | None, config: str | None) -> NormalizationProfile:
+    """Config custom (prioritaire) > profil nommé > erreur (jamais un défaut muet)."""
+    if config:
+        try:
+            return NormalizationProfile.from_yaml_text(config)
+        except (yaml.YAMLError, ValidationError, ValueError) as exc:
+            raise NormalizationPreviewError(f"config invalide : {exc}") from exc
+    if profile:
+        resolved = NORMALIZATION_PROFILES.get(profile)
+        if resolved is None:
+            raise NormalizationPreviewError(f"profil inconnu : {profile!r}.")
+        return resolved
+    raise NormalizationPreviewError("aperçu : un profil OU une config est requis.")
+
+
+def preview_normalization(
+    sample: str, *, profile: str | None = None, config: str | None = None
+) -> str:
+    """Renvoie ``sample`` normalisé par le profil résolu (nommé ou custom)."""
+    return _resolve(profile, config).normalize(sample)
+
+
+__all__ = ["NormalizationPreviewError", "preview_normalization"]
diff --git a/cinoc/app/orchestrator.py b/cinoc/app/orchestrator.py
new file mode 100644
index 0000000000000000000000000000000000000000..ce864417ec6dd8e5aca64b489a39e2f63dc252fb
--- /dev/null
+++ b/cinoc/app/orchestrator.py
@@ -0,0 +1,446 @@
+"""Orchestrateur de run (couche 6) — **coquille mince qui ne calcule pas**.
+
+Câble les couches internes : construit les modules (registre), fait tourner
+l'exécuteur (couche 4) par document, passe les artefacts au runner d'évaluation
+(couche 3), assemble le ``RunResult`` + le ``RunManifest``. Il **n'évalue rien
+lui-même** (l'assemblage métrique vit en ``evaluation``) et **n'exécute aucun
+moteur** (les modules le font).
+
+Exécution **parallèle** des unités ``(pipeline × document)`` sur un pool de
+threads borné (gros corpus) : chaque unité est indépendante (sous-dossier
+workspace par pipeline + fichiers nommés par ``document_id`` → aucune collision).
+Le **déterminisme** est garanti par construction : l'exécution est concurrente,
+mais l'assemblage du ``RunResult`` se fait **dans l'ordre du spec**, pas dans
+l'ordre d'achèvement → sortie byte-identique au séquentiel (``max_workers=1``).
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+import threading
+from collections.abc import Callable, Mapping
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime
+from pathlib import Path, PurePosixPath
+from tempfile import TemporaryDirectory
+from urllib.parse import urlsplit
+
+from cinoc.adapters.corpus._http import CorpusHttpError, download
+from cinoc.adapters.layout.crop import crop_region
+from cinoc.app.modules.registry import ModuleRegistry
+from cinoc.app.resume import ResumeStore, unit_key
+from cinoc.app.security import safe_stem
+from cinoc.domain.artifacts import Artifact, ArtifactType
+from cinoc.domain.deadline import Deadline
+from cinoc.domain.documents import DocumentRef
+from cinoc.domain.errors import AdapterStepError, CinocError, RunCancelledError
+from cinoc.domain.pipeline import PipelineSpec
+from cinoc.domain.run import RunManifest, utcnow
+from cinoc.domain.run_spec import RunSpec
+from cinoc.domain.usage import ResourceUsage
+from cinoc.evaluation.archaic import resolve_archaic_list
+from cinoc.evaluation.metrics.archaic import make_air_metric, make_hcpr_metric
+from cinoc.evaluation.registry import MetricRegistry, register_default_metrics
+from cinoc.evaluation.result import DocumentUsage, RunResult
+from cinoc.evaluation.runner import evaluate_run
+from cinoc.pipeline.executor import PipelineExecutor, PipelineStepError
+from cinoc.pipeline.protocols import Module
+from cinoc.pipeline.run_control import RunControl
+
+logger = logging.getLogger(__name__)
+
+
+class OrchestrationError(CinocError):
+    """Run impossible à exécuter (document sans image, etc.)."""
+
+
+#: Sorties d'un run, indexées ``pipeline → document → type → artefact``.
+PipelineOutputs = Mapping[str, Mapping[str, Mapping[ArtifactType, Artifact]]]
+#: Sink optionnel d'artefacts : reçoit les sorties **avant** le nettoyage du
+#: workspace (les URI sont encore lisibles). La couche 6 (app) le fournit ;
+#: l'orchestrateur l'invoque sans rien connaître de sa cible (un store, etc.).
+ArtifactSink = Callable[[PipelineOutputs, RunManifest], None]
+#: Callback de progression : ``(unités traitées, total)``. Émis après chaque
+#: document (succès **ou** échec isolé). Une unité = un (concurrent × document).
+ProgressCallback = Callable[[int, int], None]
+
+
+#: Variable d'environnement (ops) : nombre de threads d'exécution par défaut.
+_WORKERS_ENV = "CINOC_MAX_WORKERS"
+
+
+def _resolve_workers(max_workers: int | None, n_pending: int) -> int:
+    """Nombre de threads effectif : argument > ``CINOC_MAX_WORKERS`` > CPU.
+
+    Borné à ``[1, n_pending]`` — inutile de dépasser le nombre d'unités à exécuter.
+    Une valeur invalide d'environnement est ignorée (dégradé sur le défaut CPU).
+    """
+    chosen = max_workers
+    if chosen is None:
+        raw = os.environ.get(_WORKERS_ENV)
+        if raw is not None:
+            try:
+                chosen = int(raw)
+            except ValueError:
+                logger.warning(
+                    "[orchestrator] %s=%r ignoré (entier attendu).", _WORKERS_ENV, raw
+                )
+    if chosen is None or chosen < 1:
+        chosen = os.cpu_count() or 1
+    return max(1, min(chosen, n_pending))
+
+
+class _ProgressCounter:
+    """Compteur d'unités traitées, thread-safe (pool d'exécution concurrent)."""
+
+    def __init__(self, total: int, callback: ProgressCallback | None) -> None:
+        self._total = total
+        self._callback = callback
+        self._done = 0
+        self._lock = threading.Lock()
+
+    def tick(self) -> None:
+        if self._callback is None:
+            return
+        with self._lock:
+            self._done += 1
+            done = self._done
+        self._callback(done, self._total)
+
+
+def run(
+    spec: RunSpec,
+    *,
+    registry: ModuleRegistry,
+    code_version: str,
+    deadline: Deadline | None = None,
+    control: RunControl | None = None,
+    artifact_sink: ArtifactSink | None = None,
+    on_progress: ProgressCallback | None = None,
+    resume_store: ResumeStore | None = None,
+    max_workers: int | None = None,
+) -> RunResult:
+    """Exécute ``spec`` et renvoie le ``RunResult`` (manifeste + métriques).
+
+    ``control`` (optionnel) porte l'**annulation coopérative** de bout en bout :
+    le worker d'un job (``JobRunner``, couche 6) le déclenche, l'exécuteur le
+    sonde avant chaque étape. Absent → un ``RunControl`` neutre est utilisé.
+
+    ``artifact_sink`` (optionnel) reçoit les artefacts produits **avant** le
+    nettoyage du workspace (URI encore lisibles) : c'est par lui qu'un LAYOUT
+    produit est persisté (ex. ``SegmentationStore``) sans que l'orchestrateur
+    connaisse la destination, et sans second chemin d'exécution.
+
+    ``resume_store`` (optionnel) : cache d'**exécution** adressé par empreinte
+    (``app.resume``) — une unité (pipeline × document) déjà produite à
+    l'identique est rechargée au lieu d'être ré-exécutée ; l'évaluation, elle,
+    est toujours recalculée. Accédé **uniquement en thread principal** (chargement
+    avant le pool, persistance après) → aucune contrainte de concurrence sur lui.
+
+    ``max_workers`` (optionnel) : taille du pool de threads d'exécution. ``None``
+    → ``CINOC_MAX_WORKERS`` puis ``os.cpu_count()``. ``1`` = séquentiel strict
+    (référence de déterminisme). Les unités sont indépendantes ; l'assemblage
+    final est **ordonné par le spec**, donc le résultat ne dépend pas du nombre de
+    threads.
+    """
+    started_at = utcnow()
+    needed = sorted(
+        {step.adapter_name for pipeline in spec.pipelines for step in pipeline.steps}
+    )
+    modules = {
+        name: registry.build(name, spec.adapter_kwargs.get(name, {}))
+        for name in needed
+    }
+    executor = PipelineExecutor(code_version)
+    metric_registry = MetricRegistry()
+    register_default_metrics(metric_registry)
+    _bind_archaic_metrics(metric_registry, spec)
+
+    documents = spec.corpus.documents
+    total_units = len(spec.pipelines) * len(documents)
+    progress = _ProgressCounter(total_units, on_progress)
+    with TemporaryDirectory(prefix="cinoc-run-") as workspace:
+        # Un sous-dossier de workspace **par pipeline** : deux pipelines qui
+        # partagent un `adapter_name` écriraient sinon le même fichier de sortie.
+        # Au sein d'un pipeline, chaque document écrit un fichier nommé par son id
+        # (`workspace_artifact_path`, stem injectif) → deux documents concurrents
+        # ne se marchent jamais dessus, l'exécution parallèle est sûre.
+        workspaces: dict[str, Path] = {}
+        for index, pipeline in enumerate(spec.pipelines):
+            pipeline_workspace = Path(workspace) / f"pipeline{index}"
+            pipeline_workspace.mkdir()
+            workspaces[pipeline.name] = pipeline_workspace
+
+        # 0) Images **référence** (corpus curé) : matérialisées en local une fois
+        #    par document — les moteurs lisent un fichier, jamais une URL ; la
+        #    spec d'origine (→ RunResult/rapport) garde la référence épinglée.
+        documents, unreachable = _materialize_remote_images(
+            documents, Path(workspace) / "images"
+        )
+
+        # 1) Reprise (thread principal) : les unités déjà produites à l'identique
+        #    sont rechargées ; les autres sont mises en file d'exécution.
+        results: dict[tuple[str, str], dict[ArtifactType, Artifact]] = {}
+        usage_by_unit: dict[tuple[str, str], ResourceUsage] = {}
+        pending: list[tuple[PipelineSpec, DocumentRef, str | None]] = []
+        for pipeline in spec.pipelines:
+            for document in documents:
+                if document.id in unreachable:
+                    # Image distante injoignable : unité échouée (comme un échec
+                    # d'adapter isolé), le reste du corpus tourne normalement.
+                    results[(pipeline.name, document.id)] = {}
+                    progress.tick()
+                    continue
+                key = (
+                    unit_key(
+                        code_version=code_version,
+                        pipeline=pipeline,
+                        adapter_kwargs=spec.adapter_kwargs,
+                        document=document,
+                    )
+                    if resume_store is not None
+                    else None
+                )
+                cached = resume_store.load(key) if resume_store and key else None
+                if cached is not None:
+                    artifacts, cached_usage = cached
+                    results[(pipeline.name, document.id)] = dict(artifacts)
+                    usage_by_unit[(pipeline.name, document.id)] = cached_usage
+                    progress.tick()
+                else:
+                    pending.append((pipeline, document, key))
+
+        # 2) Exécution **parallèle** des unités non-cachées. OCR (sous-processus)
+        #    et LLM/cloud (I/O HTTP) libèrent le GIL → les threads donnent un
+        #    speedup réel sans sérialiser les artefacts. Un échec isolé d'unité
+        #    (`AdapterStepError`/`PipelineStepError`) n'abat pas le banc ; seule
+        #    l'annulation (`RunCancelledError`) arrête tout le run.
+        saves: list[tuple[str, Mapping[ArtifactType, Artifact], ResourceUsage]] = []
+        if pending:
+            workers = _resolve_workers(max_workers, len(pending))
+            with ThreadPoolExecutor(max_workers=workers) as pool:
+                future_to_unit = {
+                    pool.submit(
+                        executor.execute_document,
+                        pipeline,
+                        modules,
+                        _initial_inputs(document),
+                        document_id=document.id,
+                        deadline=deadline,
+                        control=control,
+                        workspace_uri=str(workspaces[pipeline.name]),
+                        # Découpe réelle des blocs pour les étapes ``fanout`` du
+                        # pipeline hybride (seg → OCR par région). Inerte hors
+                        # fan-out ; PIL importé paresseusement (seul le crop l'exige).
+                        cropper=crop_region,
+                    ): (pipeline, document, key)
+                    for pipeline, document, key in pending
+                }
+                try:
+                    for future in as_completed(future_to_unit):
+                        pipeline, document, key = future_to_unit[future]
+                        unit = (pipeline.name, document.id)
+                        try:
+                            execution = future.result()
+                        except (AdapterStepError, PipelineStepError) as exc:
+                            logger.warning(
+                                "[orchestrator] concurrent %r · document %r "
+                                "échoué : %s",
+                                pipeline.name,
+                                document.id,
+                                exc,
+                            )
+                            results[unit] = {}
+                            progress.tick()
+                            continue
+                        results[unit] = dict(execution.artifacts)
+                        usage_by_unit[unit] = execution.usage
+                        if key is not None:
+                            saves.append((key, execution.artifacts, execution.usage))
+                        progress.tick()
+                except RunCancelledError:
+                    # Annulation coopérative : on cesse de planifier (les unités
+                    # non démarrées sont annulées) et on propage — le run s'arrête.
+                    pool.shutdown(wait=False, cancel_futures=True)
+                    raise
+
+        # 3) Reprise : persistance des unités exécutées (thread principal, post-pool).
+        if resume_store is not None:
+            for saved_key, saved_artifacts, saved_usage in saves:
+                resume_store.save(saved_key, saved_artifacts, saved_usage)
+
+        # 4) Assemblage **déterministe** : ordre du spec, indépendant de l'ordre
+        #    d'achèvement des threads → `RunResult` byte-identique au séquentiel.
+        pipeline_outputs: dict[str, dict[str, dict[ArtifactType, Artifact]]] = {}
+        usage_records: list[DocumentUsage] = []
+        for pipeline in spec.pipelines:
+            per_document: dict[str, dict[ArtifactType, Artifact]] = {}
+            for document in documents:
+                unit = (pipeline.name, document.id)
+                per_document[document.id] = results[unit]
+                if unit in usage_by_unit:
+                    usage_records.append(
+                        DocumentUsage(
+                            document_id=document.id,
+                            pipeline=pipeline.name,
+                            usage=usage_by_unit[unit],
+                        )
+                    )
+            pipeline_outputs[pipeline.name] = per_document
+
+        completed_at = utcnow()
+        manifest = _manifest(
+            spec,
+            modules,
+            code_version,
+            started_at,
+            completed_at,
+            system_binaries=_collect_system_binaries(modules),
+        )
+        # Sink avant la sortie du ``with`` : les URI des artefacts (LAYOUT…)
+        # pointent encore dans le workspace vivant. Best-effort côté appelant.
+        if artifact_sink is not None:
+            artifact_sink(pipeline_outputs, manifest)
+        return evaluate_run(
+            corpus=spec.corpus,
+            evaluation=spec.evaluation,
+            pipeline_outputs=pipeline_outputs,
+            registry=metric_registry,
+            manifest=manifest,
+            usage=tuple(usage_records),
+        )
+
+
+def _bind_archaic_metrics(registry: MetricRegistry, spec: RunSpec) -> None:
+    """Relie ``air``/``hcpr`` à la liste archaïque du run (``metadata``).
+
+    ``air`` est déjà au registre (liste par défaut) ; on le **relie** à la liste
+    effective (no-op si défaut), et on **enregistre ``hcpr``** seulement si une vue
+    le demande (liste configurée au plan — cf. ``run_planning``). Les deux côtés
+    lisent la **même** ``metadata["archaic_list"]`` → ils s'accordent.
+    """
+    resolved = resolve_archaic_list(spec.metadata.get("archaic_list"))
+    registry.register_document_metric(make_air_metric(resolved.chars))
+    wants_hcpr = any("hcpr" in view.metric_names for view in spec.evaluation.views)
+    if wants_hcpr:
+        registry.register_document_metric(make_hcpr_metric(resolved.chars))
+
+
+#: Schémas d'une image **référence** (corpus curé HF/IIIF) à matérialiser au run.
+_REMOTE_SCHEMES = ("http://", "https://")
+#: Suffixe de fichier image plausible (dérivé de l'URL) ; sinon repli ``.img``
+#: (PIL/tesseract sniffent le contenu, l'extension n'est qu'un confort).
+_SAFE_SUFFIX = re.compile(r"\.[A-Za-z0-9]{1,8}$")
+
+
+def _materialize_remote_images(
+    documents: tuple[DocumentRef, ...], images_dir: Path
+) -> tuple[tuple[DocumentRef, ...], frozenset[str]]:
+    """Télécharge les images **distantes** du corpus dans le workspace du run.
+
+    Un corpus **curé** (HF/IIIF) porte des images en *référence* (URL épinglée),
+    pas en octets : les moteurs, eux, lisent un **fichier local**. On matérialise
+    donc chaque image distante **une fois par document** via le fetch durci
+    (anti-SSRF, plafond ``IMAGE_MAX_BYTES``, écriture atomique) — ce qui rend
+    aussi la **reprise** opérante (``unit_key`` hache les octets). La copie vit
+    dans le workspace temporaire (nettoyé en fin de run) ; la **spec d'origine
+    n'est pas réécrite** → le ``RunResult``/rapport garde l'URL de référence.
+
+    Renvoie ``(documents exécutables, ids irrécupérables)`` : une image
+    injoignable n'abat pas le banc (philosophie « échec isolé d'unité ») — ses
+    unités sont marquées échouées, le reste du corpus tourne.
+    """
+    localized: list[DocumentRef] = []
+    failed: set[str] = set()
+    for document in documents:
+        uri = document.image_uri
+        if uri is None or not uri.startswith(_REMOTE_SCHEMES):
+            localized.append(document)
+            continue
+        images_dir.mkdir(parents=True, exist_ok=True)
+        suffix = PurePosixPath(urlsplit(uri).path).suffix
+        if not _SAFE_SUFFIX.fullmatch(suffix):
+            suffix = ".img"
+        dest = images_dir / safe_stem(document.id, suffix=suffix)
+        try:
+            download(uri, dest)
+        except CorpusHttpError as exc:
+            logger.warning(
+                "[orchestrator] image distante irrécupérable (document %r) : %s",
+                document.id,
+                exc,
+            )
+            failed.add(document.id)
+            localized.append(document)
+            continue
+        localized.append(document.model_copy(update={"image_uri": str(dest)}))
+    return tuple(localized), frozenset(failed)
+
+
+def _initial_inputs(document: DocumentRef) -> dict[ArtifactType, Artifact]:
+    if document.image_uri is None:
+        raise OrchestrationError(
+            f"document {document.id!r} : image_uri requis (axe image→texte)."
+        )
+    return {
+        ArtifactType.IMAGE: Artifact(
+            id=f"{document.id}:initial:image",
+            document_id=document.id,
+            type=ArtifactType.IMAGE,
+            uri=document.image_uri,
+        )
+    }
+
+
+def _collect_system_binaries(modules: Mapping[str, Module]) -> dict[str, str]:
+    """Versions des **binaires externes** des modules exécutés (reproductibilité).
+
+    Un module qui enveloppe un binaire système (ex. tesseract) expose
+    ``system_binaries() -> dict[str, str]`` ; on le détecte par **duck-typing**
+    (hors ``Module`` Protocol — le contrat d'exécution reste unique) et on fusionne.
+    Le hook est best-effort côté module (binaire absent → ``{}``) → pas de garde
+    ici, pas de panne. Seuls les modules réellement construits sont sondés.
+    """
+    binaries: dict[str, str] = {}
+    for module in modules.values():
+        probe = getattr(module, "system_binaries", None)
+        if callable(probe):
+            binaries.update(probe())
+    return binaries
+
+
+def _manifest(
+    spec: RunSpec,
+    modules: Mapping[str, Module],
+    code_version: str,
+    started_at: datetime,
+    completed_at: datetime,
+    *,
+    system_binaries: dict[str, str],
+) -> RunManifest:
+    names = sorted(modules)
+    return RunManifest(
+        run_id=spec.run_id or f"run-{started_at.strftime('%Y%m%dT%H%M%S')}",
+        corpus_name=spec.corpus.name,
+        n_documents=len(spec.corpus.documents),
+        pipeline_specs=spec.pipelines,
+        adapter_kwargs={
+            name: dict(spec.adapter_kwargs.get(name, {})) for name in names
+        },
+        # Reproductibilité (R-2) : la version de chaque module exécuté entre dans
+        # l'empreinte. `module_versions` = version d'*adapter* ; la version du
+        # *binaire* externe (ex. tesseract) est captée à l'exécution dans
+        # `system_binaries_lock` via le hook `system_binaries()` (duck-typing).
+        module_versions={name: modules[name].version for name in names},
+        system_binaries_lock=system_binaries,
+        view_specs=spec.evaluation.views,
+        code_version=code_version,
+        started_at=started_at,
+        completed_at=completed_at,
+        metadata=spec.metadata,
+    )
+
+
+__all__ = ["ArtifactSink", "OrchestrationError", "PipelineOutputs", "run"]
diff --git a/cinoc/app/report_images.py b/cinoc/app/report_images.py
new file mode 100644
index 0000000000000000000000000000000000000000..e68e7faf207f3ad7299f41f0d12f21a9d95b2396
--- /dev/null
+++ b/cinoc/app/report_images.py
@@ -0,0 +1,238 @@
+"""Vignettes du rapport — orchestration (couche 6).
+
+Résout les **références** image du ``RunResult`` (``RunDocumentResult.image_ref``)
+en intrants de rendu, via l'adapter (couche 5, Pillow). Deux **saveurs** partagent
+la même sélection (pires-CER d'abord, déterministe) et ne diffèrent que par la
+façon de produire le href :
+
+- **embedded** (``build_thumbnails``/``build_facsimiles``) → data-URI inliné,
+  **plafonné** (borne le poids du rapport autonome) ; les octets ne touchent
+  jamais le résultat.
+- **sidecar / dossier** (``build_sidecar_*`` + ``write_report_bundle``) → dérivés
+  écrits dans ``report-assets/``, hrefs **relatifs** ; **caps relâchés** (les
+  octets sont sur disque, plus dans le HTML).
+
+Dégradé gracieux partout : ``{}`` si rien n'est résoluble (pas d'image, pas de
+Pillow) ; aucune exception large.
+"""
+
+from __future__ import annotations
+
+import io
+import tempfile
+import zipfile
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Protocol
+
+from cinoc.adapters.images import thumbnail_data_uri, thumbnail_to_file
+from cinoc.app.security import safe_stem
+from cinoc.evaluation.result import RunResult
+
+#: Plafond par défaut de documents vignettés (borne le poids du rapport autonome).
+_DEFAULT_MAX_DOCS = 300
+#: Fac-similés medium (détail) : plus grands → plafond plus serré.
+_FACSIMILE_MAX_PX = 1100
+_FACSIMILE_MAX_DOCS = 60
+#: Variante de stem des fac-similés (medium) : évite la collision avec la vignette
+#: du même document dans le même ``report-assets/``.
+_FACSIMILE_SUFFIX = "-fac"
+
+
+class ReportHtmlRenderer(Protocol):
+    """Forme du renderer HTML injecté dans ``write_report_bundle`` (couche 7).
+
+    ``app`` (couche 6) **n'importe pas** ``reports`` (couche 7) : le renderer est
+    fourni par l'appelant (couche 8). Correspond à ``ReportRenderer.render``."""
+
+    def __call__(
+        self,
+        result: RunResult,
+        *,
+        title: str,
+        lang: str,
+        images: Mapping[str, str],
+        facsimiles: Mapping[str, str],
+    ) -> str: ...
+
+
+def _worst_first_doc_ids(result: RunResult) -> list[str]:
+    """``document_id`` ordonnés par CER décroissant (pires-d'abord), déterministe."""
+    worst: dict[str, float] = {}
+    for d in result.documents:
+        cer = next((s.value for s in d.scores if s.metric == "cer"), None)
+        if cer is not None:
+            worst[d.document_id] = max(worst.get(d.document_id, 0.0), cer)
+    ordered = sorted(worst, key=lambda doc: (-worst[doc], doc))
+    # Documents sans CER : ajoutés en fin, ordre d'apparition stable.
+    for d in result.documents:
+        if d.document_id not in worst and d.document_id not in ordered:
+            ordered.append(d.document_id)
+    return ordered
+
+
+def _ordered_refs(
+    result: RunResult, *, max_docs: int | None
+) -> list[tuple[str, str]]:
+    """``[(document_id, image_ref)]`` pires-d'abord, plafonné (``None`` = sans cap).
+
+    Partage la sélection entre saveurs : un document → sa première référence ; tri
+    pires-CER d'abord (déterministe) ; troncature au plafond si demandé."""
+    refs: dict[str, str] = {}
+    for d in result.documents:
+        if d.image_ref and d.document_id not in refs:
+            refs[d.document_id] = d.image_ref
+    if not refs:
+        return []
+    selected = [doc for doc in _worst_first_doc_ids(result) if doc in refs]
+    if max_docs is not None:
+        selected = selected[:max_docs]
+    return [(doc_id, refs[doc_id]) for doc_id in selected]
+
+
+def build_thumbnails(
+    result: RunResult, *, max_px: int = 280, max_docs: int = _DEFAULT_MAX_DOCS
+) -> dict[str, str]:
+    """``{document_id: data-URI}`` des vignettes résolues (plafonné, pires-d'abord)."""
+    out: dict[str, str] = {}
+    for doc_id, ref in _ordered_refs(result, max_docs=max_docs):
+        uri = thumbnail_data_uri(ref, max_px=max_px)
+        if uri is not None:
+            out[doc_id] = uri
+    return out
+
+
+def build_facsimiles(
+    result: RunResult,
+    *,
+    max_px: int = _FACSIMILE_MAX_PX,
+    max_docs: int = _FACSIMILE_MAX_DOCS,
+) -> dict[str, str]:
+    """``{document_id: data-URI}`` des **fac-similés medium** (détail document).
+
+    Même résolution que ``build_thumbnails`` mais plus grands et plus plafonnés
+    (le détail montre une image, pas une grille)."""
+    return build_thumbnails(result, max_px=max_px, max_docs=max_docs)
+
+
+def _build_sidecar(
+    result: RunResult,
+    assets_dir: Path,
+    *,
+    max_px: int,
+    suffix: str,
+    max_docs: int | None,
+) -> dict[str, str]:
+    """``{document_id: href relatif}`` ; écrit un dérivé JPEG par document image.
+
+    Les deux saveurs (vignette / fac-similé) ne diffèrent que par ``max_px`` et
+    ``suffix`` — la résolution (``thumbnail_to_file``) est la même, appelée
+    directement (pas d'indirection ``resolve``)."""
+    out: dict[str, str] = {}
+    for doc_id, ref in _ordered_refs(result, max_docs=max_docs):
+        stem = safe_stem(doc_id, suffix=suffix, fallback="doc")
+        href = thumbnail_to_file(ref, assets_dir, stem, max_px=max_px)
+        if href is not None:
+            out[doc_id] = href
+    return out
+
+
+def build_sidecar_thumbnails(
+    result: RunResult,
+    assets_dir: str | Path,
+    *,
+    max_px: int = 280,
+    max_docs: int | None = None,
+) -> dict[str, str]:
+    """``{document_id: href relatif}`` ; écrit les vignettes dans ``assets_dir``.
+
+    Saveur dossier : **caps relâchés** par défaut (``max_docs=None`` → tous les
+    documents avec image) puisque les octets vivent sur disque, pas dans le HTML."""
+    return _build_sidecar(
+        result,
+        Path(assets_dir),
+        max_px=max_px,
+        suffix="",
+        max_docs=max_docs,
+    )
+
+
+def build_sidecar_facsimiles(
+    result: RunResult,
+    assets_dir: str | Path,
+    *,
+    max_px: int = _FACSIMILE_MAX_PX,
+    max_docs: int | None = None,
+) -> dict[str, str]:
+    """``{document_id: href}`` des **fac-similés** écrits dans ``assets_dir``."""
+    return _build_sidecar(
+        result,
+        Path(assets_dir),
+        max_px=max_px,
+        suffix=_FACSIMILE_SUFFIX,
+        max_docs=max_docs,
+    )
+
+
+def write_report_bundle(
+    result: RunResult,
+    out_dir: str | Path,
+    *,
+    render: ReportHtmlRenderer,
+    title: str = "Cinoc — rapport",
+    lang: str = "fr",
+) -> Path:
+    """Écrit un **bundle dossier** : ``out_dir/report.html`` + ``report-assets/``.
+
+    Saveur dossier : les images réelles sont des dérivés JPEG dans
+    ``out_dir/report-assets/`` ; ``report.html`` ne porte que des **hrefs
+    relatifs** (HTML léger, hors-ligne). Le ``render`` (couche 7) est **injecté**
+    par l'appelant — ``app`` n'importe pas ``reports``. Renvoie le chemin du
+    ``report.html`` écrit. Sans Pillow : aucun asset, le HTML retombe sur l'aperçu
+    synthétique (dégradé gracieux, pas de crash)."""
+    out = Path(out_dir)
+    assets = out / "report-assets"
+    images = build_sidecar_thumbnails(result, assets)
+    facsimiles = build_sidecar_facsimiles(result, assets)
+    html = render(result, title=title, lang=lang, images=images, facsimiles=facsimiles)
+    out.mkdir(parents=True, exist_ok=True)
+    report = out / "report.html"
+    report.write_text(html, encoding="utf-8")
+    return report
+
+
+def build_report_zip(
+    result: RunResult,
+    *,
+    render: ReportHtmlRenderer,
+    title: str = "Cinoc — rapport",
+    lang: str = "fr",
+) -> bytes:
+    """Bundle dossier **en mémoire** : un ZIP de ``report.html`` + ``report-assets/``.
+
+    Même saveur dossier que :func:`write_report_bundle` (images réelles, hrefs
+    relatifs, hors-ligne) mais empaquetée en octets ZIP — la forme téléchargeable
+    depuis le web (le navigateur reçoit *un* fichier, l'utilisateur déballe un
+    dossier). Le ``render`` (couche 7) est **injecté** (``app`` n'importe pas
+    ``reports``). Déterministe : entrées triées. Dégradé gracieux sans Pillow
+    (HTML + aperçu synthétique, aucun asset)."""
+    with tempfile.TemporaryDirectory() as tmp:
+        write_report_bundle(result, tmp, render=render, title=title, lang=lang)
+        buffer = io.BytesIO()
+        root = Path(tmp)
+        with zipfile.ZipFile(buffer, "w", zipfile.ZIP_DEFLATED) as archive:
+            for path in sorted(root.rglob("*")):
+                if path.is_file():
+                    archive.write(path, path.relative_to(root).as_posix())
+        return buffer.getvalue()
+
+
+__all__ = [
+    "ReportHtmlRenderer",
+    "build_facsimiles",
+    "build_report_zip",
+    "build_sidecar_facsimiles",
+    "build_sidecar_thumbnails",
+    "build_thumbnails",
+    "write_report_bundle",
+]
diff --git a/cinoc/app/results.py b/cinoc/app/results.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ad731217456b105bd7c552c94d61dc7817805c9
--- /dev/null
+++ b/cinoc/app/results.py
@@ -0,0 +1,36 @@
+"""Entrées/sorties JSON d'un ``RunResult`` (couche 6).
+
+Sérialisation déterministe (Pydantic) pour **sauver** un run et le **comparer**
+plus tard (``cinoc compare``). Aucun calcul ici — juste le round-trip.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from pydantic import ValidationError
+
+from cinoc.domain.errors import CinocError
+from cinoc.evaluation.result import RunResult
+
+
+class RunResultError(CinocError):
+    """Un fichier de résultat est illisible ou n'est pas un ``RunResult`` valide."""
+
+
+def dump_run_result(result: RunResult, path: str | Path) -> None:
+    """Écrit le ``RunResult`` en JSON (déterministe)."""
+    Path(path).write_text(result.model_dump_json(indent=2), encoding="utf-8")
+
+
+def load_run_result(path: str | Path) -> RunResult:
+    """Charge un ``RunResult`` depuis un fichier JSON."""
+    try:
+        return RunResult.model_validate_json(
+            Path(path).read_text(encoding="utf-8")
+        )
+    except (OSError, ValidationError) as exc:
+        raise RunResultError(f"RunResult illisible : {exc}.") from exc
+
+
+__all__ = ["RunResultError", "dump_run_result", "load_run_result"]
diff --git a/cinoc/app/resume.py b/cinoc/app/resume.py
new file mode 100644
index 0000000000000000000000000000000000000000..9184e71aac82346696fd0a88daafbd71d098e78a
--- /dev/null
+++ b/cinoc/app/resume.py
@@ -0,0 +1,127 @@
+"""Reprise d'exécution : cache adressé par empreinte (couche 6).
+
+Un run interrompu ou relancé ne ré-exécute pas les (pipeline × document) déjà
+produits : les artefacts sont **persistés** sous une clé d'unité SHA-256 et
+rechargés à l'identique. Périmètre strict : seule l'**exécution** est mise en
+cache — l'**évaluation est toujours recalculée** (changer la vérité-terrain ou
+les métriques re-note sans re-OCRiser ; aucun score n'est jamais en cache).
+
+Clé d'unité = SHA-256 d'un JSON canonique : version de code + spec du pipeline
++ ``adapter_kwargs`` des modules du pipeline + identité du **contenu** de
+l'image (taille + SHA-256 des octets — pas de mtime, déterministe entre
+machines). Tout changement (paramètre, code, image) invalide la clé : pas de
+journal d'invalidation, l'adressage par contenu suffit (≠ la source, qui
+journalisait en NDJSON).
+
+L'``usage`` mesuré au run d'origine est restauré avec les artefacts (les
+ressources réellement consommées pour produire le résultat — un coût de
+re-lecture de cache serait un mensonge économique).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import shutil
+from collections.abc import Mapping
+from hashlib import sha256
+from pathlib import Path
+
+from pydantic import ValidationError
+
+from cinoc.domain.artifacts import Artifact, ArtifactType, compute_content_hash
+from cinoc.domain.documents import DocumentRef
+from cinoc.domain.pipeline import PipelineSpec
+from cinoc.domain.usage import ResourceUsage
+
+logger = logging.getLogger(__name__)
+
+
+def unit_key(
+    *,
+    code_version: str,
+    pipeline: PipelineSpec,
+    adapter_kwargs: Mapping[str, Mapping[str, object]],
+    document: DocumentRef,
+) -> str | None:
+    """Empreinte d'une unité d'exécution ; ``None`` si l'image est illisible."""
+    if document.image_uri is None:
+        return None
+    try:
+        image_bytes = Path(document.image_uri).read_bytes()
+    except OSError:
+        return None
+    relevant_kwargs = {
+        step.adapter_name: dict(adapter_kwargs.get(step.adapter_name, {}))
+        for step in pipeline.steps
+    }
+    payload = json.dumps(
+        {
+            "code_version": code_version,
+            "pipeline": pipeline.model_dump(mode="json"),
+            "adapter_kwargs": relevant_kwargs,
+            "document_id": document.id,
+            "image_size": len(image_bytes),
+            "image_sha256": compute_content_hash(image_bytes),
+        },
+        sort_keys=True,
+        ensure_ascii=False,
+    )
+    return sha256(payload.encode("utf-8")).hexdigest()
+
+
+class ResumeStore:
+    """Cache disque des sorties d'exécution, adressé par clé d'unité."""
+
+    def __init__(self, base_dir: Path) -> None:
+        self._base = base_dir
+        self._base.mkdir(parents=True, exist_ok=True)
+
+    def load(
+        self, key: str
+    ) -> tuple[dict[ArtifactType, Artifact], ResourceUsage] | None:
+        """Artefacts + usage d'une unité, ou ``None`` (absent/corrompu)."""
+        index = self._base / key / "index.json"
+        try:
+            data = json.loads(index.read_bytes())
+            artifacts = {
+                ArtifactType(type_name): Artifact.model_validate(entry)
+                for type_name, entry in data["artifacts"].items()
+            }
+            usage = ResourceUsage.model_validate(data["usage"])
+        except (OSError, ValueError, KeyError, ValidationError):
+            return None
+        for artifact in artifacts.values():
+            if artifact.uri is not None and not Path(artifact.uri).is_file():
+                return None  # entrée incomplète → ré-exécution
+        return artifacts, usage
+
+    def save(
+        self,
+        key: str,
+        artifacts: Mapping[ArtifactType, Artifact],
+        usage: ResourceUsage,
+    ) -> None:
+        """Persiste fichiers + index ; best-effort (un échec n'abat pas le run)."""
+        unit_dir = self._base / key
+        try:
+            unit_dir.mkdir(parents=True, exist_ok=True)
+            stored: dict[str, dict[str, object]] = {}
+            for artifact_type, artifact in artifacts.items():
+                entry = artifact
+                if artifact.uri is not None and Path(artifact.uri).is_file():
+                    suffix = Path(artifact.uri).suffix
+                    destination = unit_dir / f"{artifact_type.value}{suffix}"
+                    shutil.copyfile(artifact.uri, destination)
+                    entry = artifact.model_copy(update={"uri": str(destination)})
+                stored[artifact_type.value] = entry.model_dump(mode="json")
+            payload = {"artifacts": stored, "usage": usage.model_dump(mode="json")}
+            (unit_dir / "index.json").write_text(
+                json.dumps(payload, ensure_ascii=False, sort_keys=True),
+                encoding="utf-8",
+            )
+        except OSError as exc:
+            logger.warning("[resume] persistance dégradée (unité %s) : %s", key, exc)
+
+
+__all__ = ["ResumeStore", "unit_key"]
diff --git a/cinoc/app/run_planning.py b/cinoc/app/run_planning.py
new file mode 100644
index 0000000000000000000000000000000000000000..1b3bbf1ab369ea9cd08c305b7f6476f56b21393a
--- /dev/null
+++ b/cinoc/app/run_planning.py
@@ -0,0 +1,727 @@
+"""Planification d'un run : (concurrents, corpus) → ``RunSpec`` (couche 6).
+
+Construire une spec d'exécution est de l'**orchestration**, pas du transport :
+les routeurs (couche 8) délèguent ici et ne fabriquent **aucun** ``RunSpec``
+eux-mêmes. Le dispatch est **exhaustif** — un moteur/mode non câblé est refusé
+explicitement (``RunPlanningError``), jamais redirigé en silence vers un autre
+moteur (anti-régression du défaut « ``mistral`` → tesseract »).
+
+Un **benchmark** compare N **concurrents** sur le **même corpus**, en **un seul
+run** : ``plan_benchmark_run`` assemble N ``PipelineSpec`` dans **un**
+``RunSpec`` (l'orchestrateur les exécute toutes et calcule le cross-engine). Un
+concurrent porte un **mode** :
+
+- ``None``           — OCR seul (ex. tesseract) → ``RAW_TEXT`` ;
+- ``text_only``      — OCR → LLM (post-correction texte) → ``CORRECTED_TEXT`` ;
+- ``text_and_image`` — OCR → VLM (image + texte) → ``CORRECTED_TEXT`` ;
+- ``zero_shot``      — VLM seul (image → texte), sans OCR amont → ``RAW_TEXT``.
+
+La segmentation (``IMAGE → LAYOUT``, sans score texte) reste un run **à part**
+(``plan_segmentation_run``), pas un concurrent de benchmark.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from cinoc.app.engines import EngineStatus
+from cinoc.domain.artifacts import ArtifactType
+from cinoc.domain.corpus import CorpusSpec
+from cinoc.domain.errors import CinocError
+from cinoc.domain.evaluation import EvaluationSpec, EvaluationView
+from cinoc.domain.pipeline import (
+    INITIAL_STEP_ID,
+    PipelineMode,
+    PipelineSpec,
+    PipelineStep,
+)
+from cinoc.domain.projection import ProjectionSpec
+from cinoc.domain.run_spec import RunSpec
+from cinoc.evaluation.archaic import resolve_archaic_list
+from cinoc.formats.text import NORMALIZATION_PROFILES
+from cinoc.prompts import PromptError, load_prompt
+
+#: Moteurs OCR câblés pour un run réel (amont d'une chaîne ou OCR seul).
+_OCR_ENGINES = frozenset(
+    {
+        "tesseract", "kraken", "pero", "calamari",
+        "mistral_ocr", "google_vision", "azure_di",
+    }
+)
+#: Fournisseurs de post-correction LLM (mode ``text_only``).
+_LLM_ENGINES = frozenset({"openai", "anthropic", "mistral", "ollama"})
+#: Fournisseurs **vision** (modes ``text_and_image`` et ``zero_shot``).
+_VLM_ENGINES = frozenset({"openai", "anthropic", "mistral"})
+
+
+class RunPlanningError(CinocError):
+    """Moteur/mode non câblé pour un run, ou incohérence concurrent⇄corpus."""
+
+
+class Competitor(BaseModel):
+    """Un concurrent de benchmark = un pipeline à exécuter (couche 6).
+
+    ``engine`` est le moteur OCR (modes ``None``/``text_*``) **ou** le
+    fournisseur VLM (mode ``zero_shot``) **ou**, quand ``segmenter`` est posé, le
+    **reconnaisseur par bloc** d'un pipeline **hybride** (segmenteur → bloc →
+    texte). ``llm`` nomme le fournisseur de post-correction des modes ``text_*``.
+    Validé exhaustivement à la planification (jamais de retombée muette).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    engine: str = Field(min_length=1, max_length=64)
+    mode: PipelineMode | None = None
+    #: Pipeline **hybride** : segmenteur de mise en page en tête (``pp_doclayout`` /
+    #: ``remote_segmenter``). Posé ⇒ ``engine`` est le reconnaisseur **par bloc**
+    #: (OCR réel ou VLM zero-shot), scoré comme du texte à la page. ``None`` ⇒
+    #: pipeline à plat (OCR / chaîne / VLM), comportement historique.
+    segmenter: str | None = Field(default=None, max_length=64)
+    #: Endpoint object-detection HF (requis si ``segmenter == "remote_segmenter"``).
+    segmenter_endpoint: str | None = Field(default=None, max_length=2048)
+    #: Jeton d'auth de l'endpoint de segmentation distant (optionnel).
+    segmenter_token: str | None = Field(default=None, max_length=512)
+    llm: str | None = Field(default=None, max_length=64)
+    model: str | None = Field(default=None, max_length=128)
+    lang: str = Field(default="fra", max_length=64)
+    #: Prompt de post-correction/transcription (modes LLM/VLM). ``None`` → prompt
+    #: par défaut du rôle (``default_prompt_for_role``). Exposé à l'UI (texte libre).
+    prompt: str | None = Field(default=None, max_length=8000)
+    #: Nom d'un **prompt curé** (``cinoc.prompts``) à utiliser à la place du défaut.
+    #: Mutuellement exclusif avec ``prompt`` (libre). Résolu au plan en son texte.
+    prompt_name: str | None = Field(default=None, max_length=128)
+    #: Active une **étape NER terminale** (``texte → ENTITIES``) après l'OCR/LLM —
+    #: scorée par la vue *entités nommées* si le corpus porte une GT ``ENTITIES``.
+    #: Brique optionnelle (extra ``[ner]``, spaCy) ; ``False`` par défaut.
+    ner: bool = False
+    #: Modèle spaCy de l'étape NER (défaut ``fr_core_news_sm``). Ignoré si
+    #: ``ner`` est ``False``.
+    ner_model: str | None = Field(default=None, max_length=128)
+    #: Demande l'export **ALTO XML** (géométrie + texte par mot) de l'étape OCR —
+    #: la forme ré-importable dans un outil de relecture (eScriptorium, Transkribus).
+    #: Réservé à ``tesseract`` (seul moteur du socle à émettre de l'ALTO natif) ;
+    #: demandé avec un autre moteur → ``RunPlanningError``. ``False`` par défaut.
+    alto: bool = False
+
+
+#: Types de candidat scorés par toute vue benchmark : ``RAW_TEXT`` (OCR/zero-shot)
+#: **et** ``CORRECTED_TEXT`` (OCR→LLM) — la précédence du runner évalue la sortie
+#: la plus aboutie de chaque pipeline (cf. evaluation).
+_CANDIDATES = frozenset({ArtifactType.RAW_TEXT, ArtifactType.CORRECTED_TEXT})
+
+#: **Profils de métriques** : bundles curés de colonnes scalaires pour la vue
+#: ``text`` (classement par défaut du rapport). Chaque nom ne référence que des
+#: métriques **enregistrées** pour la signature ``(RAW_TEXT, RAW_TEXT)`` — un nom
+#: non enregistré ferait lever le runner (couche 3 ; verrouillé par test). Changer
+#: de profil n'allège **que** les colonnes de classement : les *collecteurs*
+#: (taxonomy, structured_data, NER…) restent indépendants de ``metric_names``, la
+#: donnée n'est jamais perdue. ``standard`` est le défaut **historique**
+#: (byte-identique à l'ancienne vue par défaut).
+DEFAULT_METRIC_PROFILE = "standard"
+METRIC_PROFILES: dict[str, tuple[str, ...]] = {
+    # ``cmer`` = MER caractère **borné [0,1]** (robuste aux modèles génératifs qui
+    # font dépasser le CER ; cf. metrics/conformity) — calculé sur RAW_TEXT comme
+    # CER, donc exposé d'office au socle (≠ réservé HIPE). Groupé « caractère ».
+    "standard": (
+        "cer", "cmer", "char_accuracy", "word_accuracy", "fca", "wer", "mer",
+        "bow_precision", "bow_recall", "bow_f1",
+        "searchability", "hallucination", "air",
+    ),
+    "essentiel": ("cer", "wer", "mer"),
+    "philologie": ("cer", "cer_diplo", "mer", "diacritic_err", "mufi_err", "air"),
+}
+
+
+def _ocr_view(
+    normalization: str | None,
+    char_exclude: str | None,
+    *,
+    with_hcpr: bool = False,
+    base_metrics: tuple[str, ...] = METRIC_PROFILES[DEFAULT_METRIC_PROFILE],
+) -> EvaluationView:
+    # ``base_metrics`` vient du **profil de métriques** choisi (défaut
+    # ``standard``). ``air`` (apport net d'archaïsmes) y est d'office (Q4) ;
+    # ``hcpr`` (préservation) n'est **ajouté** que sur une liste **explicitement**
+    # configurée — sinon il doublonnerait ``mufi_err`` sur tout corpus médiéval.
+    # ``numseq_strict``/``numseq_value`` restent **hors** des profils (D-130) :
+    # adaptatifs (``None`` sans séquences) → colonnes vides « — » sur tout corpus
+    # sans dates/folios/montants. Ils restent **enregistrés** (utilisables par une
+    # vue custom qui voudrait classer dessus), et la **section `structured_data`
+    # reste affichée** quand des séquences existent (le collecteur l'observe
+    # indépendamment de ``metric_names``) — la donnée n'est pas perdue, seul le
+    # classement scalaire par défaut s'allège.
+    metric_names = base_metrics
+    if with_hcpr:
+        metric_names = (*metric_names, "hcpr")
+    return EvaluationView(
+        name="text",
+        candidate_types=_CANDIDATES,
+        metric_names=metric_names,
+        normalization_profile=normalization,
+        char_exclude=char_exclude,
+    )
+
+
+def _layout_view() -> EvaluationView:
+    """Vue **structure / mise en page** : note les sorties ``LAYOUT``
+    (segmentation) par **Region-F1** (`region_detection`) + **CER par région**
+    (`region_cer`), sans projection — les métriques prennent le
+    ``CanonicalLayout`` directement. Normalisation/`char_exclude` N/A (géométrie
+    + texte par région). N'est ajoutée que si le corpus porte une GT ``LAYOUT``."""
+    return EvaluationView(
+        name="structure (mise en page)",
+        candidate_types=frozenset({ArtifactType.LAYOUT}),
+        metric_names=("region_detection", "region_cer"),
+    )
+
+
+def _ner_view() -> EvaluationView:
+    """Vue **entités nommées (NER)** : note les sorties ``ENTITIES`` (étape NER)
+    par ``ner_f1`` contre la GT ``ENTITIES``, sans projection (jonction
+    ``(ENTITIES, ENTITIES)``). Normalisation/`char_exclude` N/A (comparaison
+    d'entités, pas de texte). N'est ajoutée que si le corpus porte une GT
+    ``ENTITIES`` (sinon la section NER resterait orpheline)."""
+    return EvaluationView(
+        name="entités nommées (NER)",
+        candidate_types=frozenset({ArtifactType.ENTITIES}),
+        metric_names=("ner_f1",),
+    )
+
+
+def _reference_view(
+    normalization: str | None, char_exclude: str | None
+) -> EvaluationView:
+    """Vue **référence OCR** (opt-in) : compare le candidat à une référence
+    ``REFERENCE_TEXT`` (ex. OCR Gallica) via une projection identité. Le **nom de
+    la vue porte l'avertissement** : ce n'est PAS une vérité-terrain manuelle, le
+    score mesure l'accord avec un autre OCR."""
+    return EvaluationView(
+        name="référence OCR (pas une vérité-terrain manuelle)",
+        candidate_types=_CANDIDATES,
+        projections_by_source_type={
+            ArtifactType.REFERENCE_TEXT: ProjectionSpec(
+                source_type=ArtifactType.REFERENCE_TEXT,
+                target_type=ArtifactType.RAW_TEXT,
+                projector_name="identity_text",
+            )
+        },
+        metric_names=("cer", "wer", "mer"),
+        ignored_dimensions=("exactitude (la référence est elle-même un OCR)",),
+        normalization_profile=normalization,
+        char_exclude=char_exclude,
+    )
+
+
+def _views_for_corpus(
+    corpus: CorpusSpec,
+    normalization: str | None = None,
+    char_exclude: str | None = None,
+    *,
+    with_hcpr: bool = False,
+    base_metrics: tuple[str, ...] = METRIC_PROFILES[DEFAULT_METRIC_PROFILE],
+) -> tuple[EvaluationView, ...]:
+    """Vues à évaluer selon les **types de GT présents**, sous ``normalization``.
+
+    GT manuelle ``RAW_TEXT`` → vue ``text`` ; référence ``REFERENCE_TEXT`` (OCR
+    Gallica) → vue *référence* distincte. Un corpus sans GT → vue ``text`` par
+    défaut (le run reste exécutable, simplement non scoré). ``char_exclude``
+    filtre des caractères des deux côtés (GT/hyp) avant le calcul (runner couche 3).
+    ``with_hcpr`` ajoute la colonne ``hcpr`` à la vue ``text`` (liste archaïque
+    configurée). ``base_metrics`` = colonnes scalaires du **profil de métriques**
+    choisi (n'affecte que la vue ``text``, pas la vue *référence* fixe).
+    """
+    gt_types = {gt.type for doc in corpus.documents for gt in doc.ground_truths}
+    views: list[EvaluationView] = []
+    if ArtifactType.RAW_TEXT in gt_types:
+        views.append(
+            _ocr_view(
+                normalization, char_exclude,
+                with_hcpr=with_hcpr, base_metrics=base_metrics,
+            )
+        )
+    if ArtifactType.REFERENCE_TEXT in gt_types:
+        views.append(_reference_view(normalization, char_exclude))
+    if ArtifactType.LAYOUT in gt_types:
+        views.append(_layout_view())
+    if ArtifactType.ENTITIES in gt_types:
+        views.append(_ner_view())
+    if not views:
+        views.append(
+            _ocr_view(
+                normalization, char_exclude,
+                with_hcpr=with_hcpr, base_metrics=base_metrics,
+            )
+        )
+    return tuple(views)
+
+
+def _resolve_metric_profile(name: str | None) -> tuple[str, ...]:
+    """Colonnes scalaires d'un profil nommé (défaut : ``standard``).
+
+    Un nom inconnu → ``RunPlanningError`` (jamais un défaut muet ; le routeur le
+    remonte en 422), comme pour un profil de normalisation inconnu.
+    """
+    if name is None:
+        return METRIC_PROFILES[DEFAULT_METRIC_PROFILE]
+    try:
+        return METRIC_PROFILES[name]
+    except KeyError:
+        raise RunPlanningError(
+            f"profil de métriques inconnu : {name!r}."
+        ) from None
+
+
+def _resolve_prompt(comp: Competitor) -> str | None:
+    """Texte du prompt : libre (prioritaire) > curé (par nom) > défaut du rôle.
+
+    ``prompt`` (texte libre saisi) et ``prompt_name`` (prompt curé) sont
+    **mutuellement exclusifs** : les fournir tous deux est une erreur de plan
+    (jamais un choix silencieux). Un nom curé inconnu → ``RunPlanningError`` (422).
+    """
+    if comp.prompt and comp.prompt_name:
+        raise RunPlanningError(
+            "prompt : choisir un prompt libre OU un prompt curé, pas les deux."
+        )
+    if comp.prompt:
+        return comp.prompt
+    if comp.prompt_name:
+        try:
+            return load_prompt(comp.prompt_name)
+        except PromptError as exc:
+            raise RunPlanningError(str(exc)) from exc
+    return None
+
+
+def _llm_kwargs(
+    label: str, comp: Competitor, role: PipelineMode
+) -> dict[str, str | int | float | bool]:
+    kwargs: dict[str, str | int | float | bool] = {"label": label, "role": role}
+    if comp.model:
+        kwargs["model"] = comp.model
+    prompt = _resolve_prompt(comp)
+    if prompt:
+        kwargs["prompt"] = prompt
+    return kwargs
+
+
+#: Modèle spaCy par défaut de l'étape NER (français — cohérent avec le défaut
+#: historique du builder ``ner``). Surchargé par ``Competitor.ner_model``.
+_NER_DEFAULT_MODEL = "fr_core_news_sm"
+
+
+def _ner_step(suffix: str, text_type: ArtifactType, from_id: str) -> PipelineStep:
+    """Étape NER **terminale** : ``text → ENTITIES`` (branchée sur la sortie texte
+    la plus aboutie du pipeline — ``RAW_TEXT`` en OCR/zero-shot, ``CORRECTED_TEXT``
+    en chaîne LLM/VLM)."""
+    return PipelineStep(
+        id="ner",
+        kind="ner",
+        adapter_name=f"ner:{suffix}",
+        input_types=(text_type,),
+        output_types=(ArtifactType.ENTITIES,),
+        inputs_from={text_type: from_id},
+    )
+
+
+def _ner_kwargs(
+    suffix: str, comp: Competitor
+) -> dict[str, str | int | float | bool]:
+    return {"label": suffix, "model": comp.ner_model or _NER_DEFAULT_MODEL}
+
+
+def _hybrid_reco_kwargs(
+    comp: Competitor, suffix: str
+) -> tuple[str, dict[str, str | int | float | bool]]:
+    """``(adapter_name, kwargs)`` du reconnaisseur **par bloc** d'un hybride.
+
+    OCR réel → ``IMAGE → RAW_TEXT`` (``lang``/``model``) ; VLM → même contrat en
+    rôle ``zero_shot`` (transcription par bloc, prompt curé/libre optionnel).
+    """
+    name = f"{comp.engine}:{suffix}"
+    if comp.engine in _VLM_ENGINES:
+        kwargs: dict[str, str | int | float | bool] = {
+            "label": suffix,
+            "role": "zero_shot",
+        }
+        prompt = _resolve_prompt(comp)
+        if prompt:
+            kwargs["prompt"] = prompt
+    else:
+        kwargs = {"label": suffix, "lang": comp.lang}
+    if comp.model:
+        kwargs["model"] = comp.model
+    return name, kwargs
+
+
+def _hybrid_competitor(
+    comp: Competitor, suffix: str
+) -> tuple[PipelineSpec, dict[str, dict[str, str | int | float | bool]]]:
+    """Pipeline **hybride** d'un concurrent : segmenteur → reconnaissance par bloc
+    (fan-out, image découpée) → aplatissement texte (scoré CER/WER à la page) — et,
+    si ``alto``, assemblage ALTO XML téléchargeable. C'est « segmentation puis OCR/
+    VLM » jugé **côte à côte** avec un pipeline à plat, dans le même run."""
+    from cinoc.app.structure_planning import SEGMENTER_KINDS  # cycle → import local
+
+    if comp.segmenter not in SEGMENTER_KINDS:
+        raise RunPlanningError(
+            f"hybride : segmenteur non câblé : {comp.segmenter!r} "
+            f"(attendu l'un de {sorted(SEGMENTER_KINDS)})."
+        )
+    if comp.engine not in (_OCR_ENGINES | _VLM_ENGINES):
+        raise RunPlanningError(
+            f"hybride : reconnaisseur par bloc non câblé : {comp.engine!r}."
+        )
+    if comp.mode is not None:
+        raise RunPlanningError("hybride : aucun mode (le pipeline est seg → bloc).")
+    if comp.llm:
+        raise RunPlanningError("hybride : pas de LLM séparé (reconnaissance par bloc).")
+    recognizer, reco_kwargs = _hybrid_reco_kwargs(comp, suffix)
+    text_name = f"layout_to_text:{suffix}"
+    kwargs: dict[str, dict[str, str | int | float | bool]] = {
+        recognizer: reco_kwargs,
+        text_name: {"label": suffix},
+    }
+    steps: list[PipelineStep] = [
+        PipelineStep(
+            id="segment",
+            kind="segmentation",
+            adapter_name=comp.segmenter,
+            input_types=(ArtifactType.IMAGE,),
+            output_types=(ArtifactType.LAYOUT,),
+        ),
+        PipelineStep(
+            id="recognize",
+            kind="recognition",
+            adapter_name=recognizer,
+            input_types=(ArtifactType.LAYOUT, ArtifactType.IMAGE),
+            output_types=(ArtifactType.LAYOUT,),
+            inputs_from={ArtifactType.LAYOUT: "segment"},
+            fanout=True,
+            crop=True,
+        ),
+        PipelineStep(
+            id="text",
+            kind="extraction",
+            adapter_name=text_name,
+            input_types=(ArtifactType.LAYOUT,),
+            output_types=(ArtifactType.RAW_TEXT,),
+            inputs_from={ArtifactType.LAYOUT: "recognize"},
+        ),
+    ]
+    if comp.segmenter == "remote_segmenter":
+        if not comp.segmenter_endpoint:
+            raise RunPlanningError(
+                "hybride : 'segmenter_endpoint' requis pour remote_segmenter."
+            )
+        seg_kwargs: dict[str, str | int | float | bool] = {
+            "endpoint": comp.segmenter_endpoint
+        }
+        if comp.segmenter_token:
+            seg_kwargs["token"] = comp.segmenter_token
+        kwargs[comp.segmenter] = seg_kwargs
+    if comp.alto:
+        steps.append(
+            PipelineStep(
+                id="assemble",
+                kind="assembly",
+                adapter_name="alto_assembler",
+                input_types=(ArtifactType.LAYOUT,),
+                output_types=(ArtifactType.ALTO_XML,),
+                inputs_from={ArtifactType.LAYOUT: "recognize"},
+            )
+        )
+    if comp.ner:
+        steps.append(_ner_step(suffix, ArtifactType.RAW_TEXT, "text"))
+        kwargs[f"ner:{suffix}"] = _ner_kwargs(suffix, comp)
+    pipeline = PipelineSpec(
+        name=f"{comp.segmenter}→{comp.engine}",
+        initial_inputs=(ArtifactType.IMAGE,),
+        steps=tuple(steps),
+    )
+    return pipeline, kwargs
+
+
+def _pipeline_for_competitor(
+    comp: Competitor, index: int,
+) -> tuple[PipelineSpec, dict[str, dict[str, str | int | float | bool]]]:
+    """Construit le ``PipelineSpec`` + ``adapter_kwargs`` d'**un** concurrent.
+
+    Labels d'adapter suffixés par l'index (``c0``, ``c1``…) : chaque concurrent a
+    ses propres instances de modules — pas de collision entre concurrents.
+    """
+    suffix = f"c{index}"
+    # Pipeline **hybride** (segmenteur posé) : branche dédiée AVANT le dispatch à
+    # plat — ALTO y est produit par l'assembleur (pas réservé à tesseract).
+    if comp.segmenter is not None:
+        return _hybrid_competitor(comp, suffix)
+    # ALTO natif : réservé à tesseract (seul moteur du socle qui l'émet). Refusé
+    # AVANT le dispatch de mode → message clair, jamais un export muet ignoré.
+    if comp.alto and comp.engine != "tesseract":
+        raise RunPlanningError(
+            f"export ALTO : réservé à tesseract, pas à {comp.engine!r}."
+        )
+    # Types de sortie de l'étape OCR tesseract : ``RAW_TEXT`` + ``ALTO_XML`` si export.
+    ocr_outputs: tuple[ArtifactType, ...] = (
+        (ArtifactType.RAW_TEXT, ArtifactType.ALTO_XML)
+        if comp.alto
+        else (ArtifactType.RAW_TEXT,)
+    )
+    if comp.mode is None:
+        if comp.engine not in _OCR_ENGINES:
+            raise RunPlanningError(f"OCR seul : moteur non câblé : {comp.engine!r}.")
+        if comp.llm:
+            raise RunPlanningError("OCR seul : aucun LLM attendu.")
+        name = f"{comp.engine}:{suffix}"
+        step = PipelineStep(
+            id="ocr",
+            kind="ocr",
+            adapter_name=name,
+            input_types=(ArtifactType.IMAGE,),
+            output_types=ocr_outputs,
+        )
+        steps: list[PipelineStep] = [step]
+        ocr_kwargs: dict[str, dict[str, str | int | float | bool]] = {
+            name: {"label": suffix, "lang": comp.lang}
+        }
+        if comp.alto:
+            ocr_kwargs[name]["alto"] = True
+        # En OCR seul, ``model`` est le **modèle du moteur** (chemin .mlmodel
+        # kraken, config PERO, checkpoint Calamari, nom Mistral OCR) — requis par
+        # ces moteurs. Tesseract/Google/Azure ignorent ce kwarg. (En chaîne,
+        # ``model`` désigne le LLM aval, cf. ``_llm_kwargs``.)
+        if comp.model:
+            ocr_kwargs[name]["model"] = comp.model
+        if comp.ner:
+            steps.append(_ner_step(suffix, ArtifactType.RAW_TEXT, "ocr"))
+            ocr_kwargs[f"ner:{suffix}"] = _ner_kwargs(suffix, comp)
+        pipeline = PipelineSpec(
+            name=comp.engine,
+            initial_inputs=(ArtifactType.IMAGE,),
+            steps=tuple(steps),
+        )
+        return pipeline, ocr_kwargs
+
+    if comp.mode == "zero_shot":
+        if comp.engine not in _VLM_ENGINES:
+            raise RunPlanningError(
+                f"zero_shot : {comp.engine!r} n'a pas de VLM (vision)."
+            )
+        if comp.llm:
+            raise RunPlanningError(
+                "zero_shot : pas de LLM séparé (le moteur EST le VLM)."
+            )
+        name = f"{comp.engine}:{suffix}"
+        step = PipelineStep(
+            id="vlm",
+            kind="transcription",
+            adapter_name=name,
+            input_types=(ArtifactType.IMAGE,),
+            output_types=(ArtifactType.RAW_TEXT,),
+        )
+        vlm_steps: list[PipelineStep] = [step]
+        vlm_kwargs: dict[str, dict[str, str | int | float | bool]] = {
+            name: _llm_kwargs(suffix, comp, "zero_shot")
+        }
+        if comp.ner:
+            vlm_steps.append(_ner_step(suffix, ArtifactType.RAW_TEXT, "vlm"))
+            vlm_kwargs[f"ner:{suffix}"] = _ner_kwargs(suffix, comp)
+        pipeline = PipelineSpec(
+            name=f"{comp.engine} (zero-shot)",
+            initial_inputs=(ArtifactType.IMAGE,),
+            steps=tuple(vlm_steps),
+        )
+        return pipeline, vlm_kwargs
+
+    # text_only / text_and_image : OCR amont → LLM/VLM.
+    if comp.engine not in _OCR_ENGINES:
+        raise RunPlanningError(
+            f"{comp.mode} : moteur OCR amont non câblé : {comp.engine!r}."
+        )
+    if not comp.llm:
+        raise RunPlanningError(f"{comp.mode} : un fournisseur LLM est requis.")
+    allowed = _LLM_ENGINES if comp.mode == "text_only" else _VLM_ENGINES
+    if comp.llm not in allowed:
+        raise RunPlanningError(
+            f"{comp.mode} : fournisseur {comp.llm!r} indisponible pour ce mode."
+        )
+    ocr_name = f"{comp.engine}:{suffix}"
+    llm_name = f"{comp.llm}:{suffix}"
+    ocr_step = PipelineStep(
+        id="ocr",
+        kind="ocr",
+        adapter_name=ocr_name,
+        input_types=(ArtifactType.IMAGE,),
+        output_types=ocr_outputs,
+    )
+    llm_inputs: tuple[ArtifactType, ...]
+    inputs_from: dict[ArtifactType, str]
+    if comp.mode == "text_only":
+        llm_inputs = (ArtifactType.RAW_TEXT,)
+        inputs_from = {ArtifactType.RAW_TEXT: "ocr"}
+    else:  # text_and_image — le VLM reçoit l'image initiale ET le texte OCR.
+        llm_inputs = (ArtifactType.RAW_TEXT, ArtifactType.IMAGE)
+        inputs_from = {
+            ArtifactType.RAW_TEXT: "ocr",
+            ArtifactType.IMAGE: INITIAL_STEP_ID,
+        }
+    llm_step = PipelineStep(
+        id="llm",
+        kind="post_correction",
+        adapter_name=llm_name,
+        input_types=llm_inputs,
+        output_types=(ArtifactType.CORRECTED_TEXT,),
+        inputs_from=inputs_from,
+    )
+    chain_steps: list[PipelineStep] = [ocr_step, llm_step]
+    kwargs: dict[str, dict[str, str | int | float | bool]] = {
+        ocr_name: {"label": suffix, "lang": comp.lang},
+        llm_name: _llm_kwargs(suffix, comp, comp.mode),
+    }
+    if comp.alto:
+        kwargs[ocr_name]["alto"] = True
+    if comp.ner:
+        chain_steps.append(_ner_step(suffix, ArtifactType.CORRECTED_TEXT, "llm"))
+        kwargs[f"ner:{suffix}"] = _ner_kwargs(suffix, comp)
+    pipeline = PipelineSpec(
+        name=f"{comp.engine}→{comp.llm}",
+        initial_inputs=(ArtifactType.IMAGE,),
+        steps=tuple(chain_steps),
+    )
+    return pipeline, kwargs
+
+
+def plan_benchmark_run(
+    competitors: tuple[Competitor, ...],
+    corpus: CorpusSpec | None,
+    run_id: str,
+    *,
+    normalization: str | None = None,
+    char_exclude: str | None = None,
+    archaic_list: str | None = None,
+    metric_profile: str | None = None,
+) -> Callable[[Path], RunSpec]:
+    """Builder de spec d'un **benchmark** : N concurrents → un ``RunSpec``.
+
+    Exhaustif : tout moteur/mode non câblé est refusé (``RunPlanningError``).
+    Les noms de pipeline sont rendus **uniques** (suffixe ``#n`` en cas de
+    doublon) pour ne pas se piétiner dans les sorties indexées par nom.
+
+    ``archaic_list`` (nom d'une liste curée, cf. ``ARCHAIC_LISTS``) **active
+    ``hcpr``** (préservation des archaïsmes) et **relie ``air``/``hcpr`` à cette
+    liste** ; sans lui, seul ``air`` reste actif sur la liste par défaut. Le nom
+    et l'empreinte de la liste effective entrent au ``RunManifest.metadata``
+    (reproductibilité) ; un nom inconnu est refusé (``RunPlanningError``).
+
+    ``metric_profile`` (nom d'un :data:`METRIC_PROFILES`) choisit le **bundle de
+    colonnes scalaires** de la vue ``text`` (défaut ``standard``, byte-identique à
+    l'historique) ; un nom inconnu est refusé (``RunPlanningError`` → 422). Il
+    n'affecte **que** le classement par défaut — les collecteurs restent intacts.
+    """
+    if not competitors:
+        raise RunPlanningError("benchmark : au moins un concurrent requis.")
+    if corpus is None:
+        raise RunPlanningError("benchmark : corpus requis.")
+    if normalization is not None and normalization not in NORMALIZATION_PROFILES:
+        raise RunPlanningError(
+            f"profil de normalisation inconnu : {normalization!r}."
+        )
+    base_metrics = _resolve_metric_profile(metric_profile)
+    try:
+        resolved = resolve_archaic_list(archaic_list)
+    except CinocError as exc:
+        raise RunPlanningError(str(exc)) from exc
+    pipelines: list[PipelineSpec] = []
+    adapter_kwargs: dict[str, dict[str, str | int | float | bool]] = {}
+    seen: dict[str, int] = {}
+    for index, comp in enumerate(competitors):
+        pipeline, kwargs = _pipeline_for_competitor(comp, index)
+        if pipeline.name in seen:
+            seen[pipeline.name] += 1
+            pipeline = pipeline.model_copy(
+                update={"name": f"{pipeline.name} #{seen[pipeline.name]}"}
+            )
+        else:
+            seen[pipeline.name] = 1
+        pipelines.append(pipeline)
+        adapter_kwargs.update(kwargs)
+    spec = RunSpec(
+        corpus=corpus,
+        pipelines=tuple(pipelines),
+        evaluation=EvaluationSpec(
+            views=_views_for_corpus(
+                corpus, normalization, char_exclude,
+                with_hcpr=archaic_list is not None,
+                base_metrics=base_metrics,
+            )
+        ),
+        adapter_kwargs=adapter_kwargs,
+        run_id=run_id,
+        metadata={
+            "archaic_list": resolved.name,
+            "archaic_list_hash": resolved.list_hash,
+        },
+    )
+    return lambda _ws: spec
+
+
+def benchmark_engine_catalog(
+    statuses: tuple[EngineStatus, ...],
+) -> dict[str, list[dict[str, object]]]:
+    """Moteurs proposables au composeur, **par rôle** (``ocr``/``llm``/``vlm``).
+
+    Source unique des rôles : les mêmes ensembles que ``plan_benchmark_run``
+    accepte (anti-vide — on n'offre jamais une option sans branche serveur). Un
+    moteur indisponible **reste listé** (grisé côté UI) : son backend existe, il
+    manque seulement une clé/un binaire.
+    """
+    by_kind = {status.kind: status for status in statuses}
+
+    def role(kinds: frozenset[str]) -> list[dict[str, object]]:
+        entries: list[dict[str, object]] = []
+        for kind in sorted(kinds):
+            status = by_kind.get(kind)
+            if status is not None:
+                entries.append(
+                    {
+                        "kind": kind,
+                        "label": status.label,
+                        "available": status.available,
+                    }
+                )
+        return entries
+
+    return {
+        "ocr": role(_OCR_ENGINES),
+        "llm": role(_LLM_ENGINES),
+        "vlm": role(_VLM_ENGINES),
+    }
+
+
+def metric_profile_catalog() -> tuple[dict[str, object], ...]:
+    """Profils de métriques proposables au lanceur — **source unique** de l'UI.
+
+    ``standard`` (défaut) d'abord, puis les autres triés (ordre déterministe).
+    Chaque entrée porte la liste **ordonnée** de ses métriques : le formulaire
+    s'en sert pour un libellé self-documenté (les noms de métriques sont neutres
+    en langue, pas d'i18n par profil). Anti-vide : on n'offre jamais une option
+    sans branche serveur — chaque nom est résolu par ``_resolve_metric_profile``.
+    """
+    others = sorted(name for name in METRIC_PROFILES if name != DEFAULT_METRIC_PROFILE)
+    return tuple(
+        {"name": name, "metrics": list(METRIC_PROFILES[name])}
+        for name in (DEFAULT_METRIC_PROFILE, *others)
+    )
+
+
+__all__ = [
+    "DEFAULT_METRIC_PROFILE",
+    "METRIC_PROFILES",
+    "Competitor",
+    "RunPlanningError",
+    "benchmark_engine_catalog",
+    "metric_profile_catalog",
+    "plan_benchmark_run",
+]
diff --git a/cinoc/app/security.py b/cinoc/app/security.py
new file mode 100644
index 0000000000000000000000000000000000000000..d18550fa78113d01d00107bfb18f26f8e47fa0aa
--- /dev/null
+++ b/cinoc/app/security.py
@@ -0,0 +1,69 @@
+"""Sécurité des chemins (couche 6) — invariant produit §12.
+
+``validated_path`` est le **garde-fou central** contre la traversée de
+répertoires : tout chemin venant d'une entrée utilisateur (corpus, sortie) passe
+par lui. La couche 8 (web) réutilisera ce **même** helper — la sécurité chemin
+n'est pas un détail web.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from pathlib import Path
+
+from cinoc.domain.errors import CinocError
+
+
+class PathSecurityError(CinocError):
+    """Un chemin utilisateur sort de la zone autorisée (path traversal)."""
+
+
+def safe_stem(value: str, *, suffix: str = "", fallback: str = "x") -> str:
+    """Composant de chemin **sûr** dérivé d'une chaîne (anti path-traversal).
+
+    Slug lisible (caractères sûrs sur tous les OS : ``A-Za-z0-9._-``) + empreinte
+    SHA-256 courte de la valeur **brute** → jamais de collision même si deux
+    valeurs se réduisent au même slug. ``suffix`` distingue des variantes (vignette
+    vs fac-similé) ; ``fallback`` remplace un slug vide (valeur tout-symboles).
+
+    Source unique du « nom de fichier sûr » (invariant produit §12) — réutilisée
+    par ``alto_store`` et ``report_images``.
+    """
+    cleaned = re.sub(r"[^A-Za-z0-9._-]+", "-", value).strip("-") or fallback
+    digest = hashlib.sha256(value.encode("utf-8")).hexdigest()[:8]
+    return f"{cleaned}-{digest}{suffix}"
+
+
+def validated_path(user_path: str, base: Path, *, must_exist: bool = False) -> Path:
+    """Résout ``user_path`` (sous ``base``) et garantit qu'il y reste confiné.
+
+    ``Path.resolve()`` écrase ``..``, les liens symboliques et le relatif ; on
+    vérifie ensuite que le résultat est bien sous ``base``. Un chemin absolu
+    n'est accepté que s'il tombe lui-même sous ``base``.
+    """
+    if not user_path or not user_path.strip():
+        raise PathSecurityError("chemin vide.")
+    if "\x00" in user_path:
+        raise PathSecurityError("chemin contient un octet nul.")
+    base_resolved = base.expanduser().resolve()
+    candidate = Path(user_path)
+    # ``target`` est toujours absolu (candidat absolu, sinon préfixé par ``base``
+    # déjà résolu) → pas de ``~`` en tête : aucun ``expanduser`` à refaire ici.
+    target = candidate if candidate.is_absolute() else base_resolved / candidate
+    try:
+        resolved = target.resolve()
+    except (OSError, RuntimeError) as exc:
+        raise PathSecurityError(
+            f"chemin invalide : {user_path!r} ({exc})."
+        ) from exc
+    if not resolved.is_relative_to(base_resolved):
+        raise PathSecurityError(
+            f"chemin hors de la zone autorisée : {user_path!r}."
+        )
+    if must_exist and not resolved.exists():
+        raise PathSecurityError(f"chemin inexistant : {user_path!r}.")
+    return resolved
+
+
+__all__ = ["PathSecurityError", "safe_stem", "validated_path"]
diff --git a/cinoc/app/segmentation.py b/cinoc/app/segmentation.py
new file mode 100644
index 0000000000000000000000000000000000000000..9c0a42a5de1973618505f8463d2d01e5aee0d915
--- /dev/null
+++ b/cinoc/app/segmentation.py
@@ -0,0 +1,157 @@
+"""Persistance + démo de **segmentation** (couche 6) pour la vitrine.
+
+Un run de segmentation produit un ``CanonicalLayout`` (géométrie des régions) que
+le ``RunResult`` (métriques scalaires) **ne porte pas** et que le workspace
+temporaire du run **détruit**. Ce store le **persiste** (layout JSON + image
+source optionnelle) pour qu'une vue web le relise et le visualise.
+
+Squelette : un layout de **démo** déterministe alimente toute
+l'enveloppe de visualisation. La Tranche 2 (vrai segmenteur) écrira son
+``CanonicalLayout`` produit **via le même** ``save`` — l'infra ne bouge pas.
+"""
+
+from __future__ import annotations
+
+import struct
+import threading
+import uuid
+import zlib
+from pathlib import Path
+
+from cinoc.app.security import PathSecurityError, validated_path
+from cinoc.domain.layout import BBox, CanonicalLayout, Geometry, LayoutPage, Region
+
+_LAYOUT_FILE = "layout.json"
+_IMAGE_STEM = "page"
+
+#: Dimensions de la page de démo (image **et** layout partagent ces côtes).
+_DEMO_W = 520
+_DEMO_H = 520
+#: Fond parchemin clair (les boîtes SVG se lisent par-dessus).
+_DEMO_RGB = (245, 243, 238)
+
+
+def demo_layout() -> CanonicalLayout:
+    """Layout de démonstration **déterministe** : une page, 3 régions étiquetées."""
+    regions = (
+        Region(
+            id="r1", region_type="title",
+            geometry=Geometry(bbox=BBox(x=40, y=30, width=440, height=70)),
+        ),
+        Region(
+            id="r2", region_type="paragraph",
+            geometry=Geometry(bbox=BBox(x=40, y=130, width=210, height=350)),
+        ),
+        Region(
+            id="r3", region_type="figure",
+            geometry=Geometry(bbox=BBox(x=270, y=130, width=210, height=350)),
+        ),
+    )
+    return CanonicalLayout(
+        pages=(
+            LayoutPage(
+                width=_DEMO_W, height=_DEMO_H, regions=regions,
+                reading_order=("r1", "r2", "r3"),
+            ),
+        )
+    )
+
+
+def demo_page_image() -> bytes:
+    """Image PNG **déterministe** de la page de démo (fond parchemin uni).
+
+    Donne un fond raster à l'``<image>`` du SVG et **exerce** réellement la
+    persistance + l'endpoint image (≠ infra dormante). Encodée à la main via la
+    stdlib (``zlib``/``struct``) — pas de PIL en couche 6 ; mêmes octets à chaque
+    appel (invariant §12 : déterminisme).
+    """
+
+    def _chunk(tag: bytes, data: bytes) -> bytes:
+        crc = zlib.crc32(tag + data) & 0xFFFFFFFF
+        return struct.pack(">I", len(data)) + tag + data + struct.pack(">I", crc)
+
+    ihdr = struct.pack(">IIBBBBB", _DEMO_W, _DEMO_H, 8, 2, 0, 0, 0)  # 8-bit RGB
+    row = b"\x00" + bytes(_DEMO_RGB) * _DEMO_W  # filtre 0 (None) + pixels
+    idat = zlib.compress(row * _DEMO_H, 9)
+    return b"".join(
+        (
+            b"\x89PNG\r\n\x1a\n",
+            _chunk(b"IHDR", ihdr),
+            _chunk(b"IDAT", idat),
+            _chunk(b"IEND", b""),
+        )
+    )
+
+
+class SegmentationStore:
+    """Registre disque des layouts de segmentation (id → dossier sous ``base_dir``)."""
+
+    def __init__(self, base_dir: Path) -> None:
+        self._base = base_dir
+        self._lock = threading.Lock()
+
+    def save(
+        self,
+        layout: CanonicalLayout,
+        *,
+        image_ext: str | None = None,
+        image_bytes: bytes | None = None,
+    ) -> str:
+        """Persiste un layout (+ image source optionnelle) ; renvoie son id."""
+        seg_id = uuid.uuid4().hex
+        with self._lock:
+            folder = self._base / seg_id
+            folder.mkdir(parents=True, exist_ok=True)
+            (folder / _LAYOUT_FILE).write_text(
+                layout.model_dump_json(), encoding="utf-8"
+            )
+            if image_bytes is not None and image_ext:
+                (folder / f"{_IMAGE_STEM}{image_ext}").write_bytes(image_bytes)
+        return seg_id
+
+    def get_layout(self, seg_id: str) -> CanonicalLayout | None:
+        """Relit le ``CanonicalLayout`` persisté, ou ``None`` (absent/invalide)."""
+        folder = self._folder(seg_id)
+        if folder is None:
+            return None
+        path = folder / _LAYOUT_FILE
+        if not path.exists():
+            return None
+        return CanonicalLayout.model_validate_json(path.read_text(encoding="utf-8"))
+
+    def latest(self) -> str | None:
+        """Id du layout le plus récemment écrit (mtime), ou ``None`` si vide.
+
+        Consommé par l'aperçu du lanceur (``GET /api/segmentation/preview``) : un
+        **run réel** persisté par le sink est plus récent que la graine de démo →
+        il s'affiche automatiquement. (Un sélecteur multi-runs est ultérieur.)
+        """
+        if not self._base.is_dir():
+            return None
+        folders = [
+            child
+            for child in self._base.iterdir()
+            if child.is_dir() and (child / _LAYOUT_FILE).is_file()
+        ]
+        if not folders:
+            return None
+        return max(folders, key=lambda child: child.stat().st_mtime).name
+
+    def image_path(self, seg_id: str) -> Path | None:
+        """Chemin de l'image source persistée (``None`` si aucune)."""
+        folder = self._folder(seg_id)
+        if folder is None:
+            return None
+        for path in sorted(folder.glob(f"{_IMAGE_STEM}.*")):
+            return path
+        return None
+
+    def _folder(self, seg_id: str) -> Path | None:
+        """Dossier du layout, **chemin validé** (anti path-traversal sur l'id URL)."""
+        try:
+            return validated_path(seg_id, self._base)
+        except PathSecurityError:
+            return None
+
+
+__all__ = ["SegmentationStore", "demo_layout", "demo_page_image"]
diff --git a/cinoc/app/structure_planning.py b/cinoc/app/structure_planning.py
new file mode 100644
index 0000000000000000000000000000000000000000..cbf11a989ea46d481f2845fd87fe8d10ceb604fc
--- /dev/null
+++ b/cinoc/app/structure_planning.py
@@ -0,0 +1,325 @@
+"""Planification d'un run de **structure** : segmentation + hybride (couche 6).
+
+Sœur de ``run_planning`` (qui planifie les **benchmarks** texte). On isole ici
+la planification *structure* — segmentation seule (``IMAGE → LAYOUT``) et pipeline
+**hybride** (seg → reconnaissance par région → assemblage ALTO) — extraite de
+``run_planning`` quand son seuil de découpe a été atteint (surface T5). Même
+couche, même contrat : (choix UI/CLI) → ``RunSpec``. Les routeurs (couche 8) y
+délèguent et ne fabriquent **aucun** ``RunSpec`` eux-mêmes.
+
+Le slot de reconnaissance **par région** accepte tout moteur ``IMAGE → RAW_TEXT``
+(le bloc découpé est OCRisé/transcrit puis réinjecté dans le ``LAYOUT``) : tout
+OCR réel **ou** un VLM en transcription ``zero_shot`` — c'est exactement « un VLM
+derrière une segmentation ».
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+
+from cinoc.app.engines import EngineStatus
+from cinoc.app.run_planning import (
+    _OCR_ENGINES,
+    _VLM_ENGINES,
+    RunPlanningError,
+)
+from cinoc.domain.artifacts import ArtifactType
+from cinoc.domain.corpus import CorpusSpec
+from cinoc.domain.evaluation import EvaluationSpec
+from cinoc.domain.pipeline import PipelineSpec, PipelineStep
+from cinoc.domain.run_spec import RunSpec
+
+#: Segmenteur de mise en page du socle **par défaut** — **source unique** du
+#: *kind* (consommé par la planification du run de segmentation ET par le gate
+#: du routeur).
+SEGMENTER_KIND = "pp_doclayout"
+
+#: Segmenteurs du socle proposables au lanceur. ``pp_doclayout`` tourne en local
+#: (poids) ; ``remote_segmenter`` **délègue** à un endpoint object-detection HF
+#: (le modèle tourne à distance — on change de modèle en changeant l'endpoint).
+SEGMENTER_KINDS = ("pp_doclayout", "remote_segmenter")
+
+
+def _segmentation_spec(
+    corpus: CorpusSpec,
+    run_id: str,
+    *,
+    segmenter: str,
+    adapter_kwargs: dict[str, dict[str, str | int | float | bool]],
+) -> RunSpec:
+    """Pipeline de segmentation à 1 étape : ``segmenter`` (IMAGE→LAYOUT).
+
+    Aucune vue d'évaluation : un run de segmentation produit de la **géométrie**
+    (captée par le sink), pas une métrique scalaire. Le ``RunResult`` reste
+    l'output formel du run ; les régions se visualisent via l'aperçu du lanceur
+    (``GET /api/segmentation/preview``).
+
+    ``adapter_kwargs`` porte les paramètres de construction du module choisi
+    (ex. ``endpoint``/``token`` du segmenteur distant) → factory + ``RunManifest``.
+    """
+    step = PipelineStep(
+        id="seg",
+        kind="layout",
+        adapter_name=segmenter,
+        input_types=(ArtifactType.IMAGE,),
+        output_types=(ArtifactType.LAYOUT,),
+    )
+    return RunSpec(
+        corpus=corpus,
+        pipelines=(
+            PipelineSpec(
+                name=segmenter,
+                initial_inputs=(ArtifactType.IMAGE,),
+                steps=(step,),
+            ),
+        ),
+        evaluation=EvaluationSpec(views=()),
+        adapter_kwargs=adapter_kwargs,
+        run_id=run_id,
+    )
+
+
+def plan_segmentation_run(
+    corpus: CorpusSpec,
+    run_id: str,
+    *,
+    segmenter: str = SEGMENTER_KIND,
+    endpoint: str | None = None,
+    token: str | None = None,
+) -> Callable[[Path], RunSpec]:
+    """Builder de spec d'un run de **segmentation**.
+
+    ``segmenter`` choisit le module (``pp_doclayout`` local ou ``remote_segmenter``
+    distant). Pour ``remote_segmenter``, ``endpoint`` est **requis** (la cible
+    object-detection) ; ``token`` est optionnel (auth de l'endpoint).
+    """
+    if segmenter not in SEGMENTER_KINDS:
+        raise RunPlanningError(f"segmenteur inconnu : {segmenter!r}.")
+    adapter_kwargs: dict[str, dict[str, str | int | float | bool]] = {}
+    if segmenter == "remote_segmenter":
+        if not endpoint:
+            raise RunPlanningError(
+                "remote_segmenter : 'endpoint' requis (cible object-detection)."
+            )
+        kwargs: dict[str, str | int | float | bool] = {"endpoint": endpoint}
+        if token:
+            kwargs["token"] = token
+        adapter_kwargs[segmenter] = kwargs
+    return lambda _ws: _segmentation_spec(
+        corpus, run_id, segmenter=segmenter, adapter_kwargs=adapter_kwargs
+    )
+
+
+#: Segmenteurs valides en tête d'un run hybride (réels + précalculé pour la démo).
+_HYBRID_SEGMENTERS = frozenset(SEGMENTER_KINDS) | {"precomputed_layout"}
+#: Reconnaisseurs **par région** câblés : tout moteur ``IMAGE → RAW_TEXT`` convient
+#: au slot de fan-out (le bloc découpé est OCRisé/transcrit puis réinjecté). Donc
+#: l'ensemble des OCR réels (dont ``mistral_ocr``, ``google_vision``, ``azure_di``)
+#: **et** les VLM en transcription **zero-shot** par bloc — c'est exactement « un
+#: VLM derrière une segmentation ». ``precomputed_region`` reste le mode démo/CI.
+_HYBRID_OCR = _OCR_ENGINES | {"precomputed_region"}
+_HYBRID_VLM = _VLM_ENGINES
+_HYBRID_RECOGNIZERS = _HYBRID_OCR | _HYBRID_VLM
+
+_HybridKwargs = dict[str, dict[str, str | int | float | bool]]
+
+
+def _hybrid_recognizer(
+    ocr: str,
+    *,
+    label: str,
+    source_label: str | None,
+    lang: str = "fra",
+    model: str | None = None,
+    prompt: str | None = None,
+) -> tuple[str, dict[str, str | int | float | bool]]:
+    """``(adapter_name, kwargs)`` du reconnaisseur **par région** selon le moteur.
+
+    OCR réel → ``IMAGE → RAW_TEXT`` (``lang``/``model`` selon le moteur) ; VLM →
+    même contrat en rôle ``zero_shot`` (transcription par bloc, prompt optionnel).
+    """
+    if ocr == "precomputed_region":
+        if not source_label:
+            raise RunPlanningError(
+                "plan_hybrid_run : 'source_label' requis pour precomputed_region."
+            )
+        return f"precomputed_region:{source_label}", {"source_label": source_label}
+    if ocr in _HYBRID_VLM:
+        kwargs: dict[str, str | int | float | bool] = {
+            "label": label,
+            "role": "zero_shot",
+        }
+        if model:
+            kwargs["model"] = model
+        if prompt:
+            kwargs["prompt"] = prompt
+        return f"{ocr}:{label}", kwargs
+    if ocr in _OCR_ENGINES:
+        ocr_kwargs: dict[str, str | int | float | bool] = {
+            "label": label,
+            "lang": lang,
+        }
+        if model:
+            ocr_kwargs["model"] = model
+        return f"{ocr}:{label}", ocr_kwargs
+    raise RunPlanningError(
+        f"plan_hybrid_run : reconnaisseur par région inconnu {ocr!r} "
+        f"(attendu l'un de {sorted(_HYBRID_RECOGNIZERS)})."
+    )
+
+
+def hybrid_recognizer_catalog(
+    statuses: tuple[EngineStatus, ...],
+) -> list[dict[str, object]]:
+    """Reconnaisseurs proposables au panneau hybride (OCR réels + VLM zero-shot).
+
+    Source **unique** de ce qu'offre l'UI et de ce que ``plan_hybrid_run`` accepte
+    (anti-vide). Un moteur indisponible reste listé (grisé) ; ``vlm`` marque la
+    transcription par bloc. ``precomputed_region`` (démo) n'y figure pas.
+    """
+    by_kind = {s.kind: s for s in statuses}
+    out: list[dict[str, object]] = []
+    for vlm, kinds in ((False, sorted(_OCR_ENGINES)), (True, sorted(_HYBRID_VLM))):
+        for kind in kinds:
+            status = by_kind.get(kind)
+            if status is not None:
+                out.append(
+                    {
+                        "kind": kind,
+                        "label": status.label,
+                        "available": status.available,
+                        "vlm": vlm,
+                    }
+                )
+    return out
+
+
+def _hybrid_spec(
+    corpus: CorpusSpec,
+    run_id: str,
+    *,
+    segmenter: str,
+    recognizer: str,
+    crop: bool,
+    adapter_kwargs: _HybridKwargs,
+) -> RunSpec:
+    """Pipeline **hybride** à 3 étages en **une** ``PipelineSpec`` :
+
+    1. ``segmenter`` : ``IMAGE → LAYOUT`` (régions seules — ``pp_doclayout`` réel,
+       ``remote_segmenter`` distant, ou ``precomputed_layout`` pour la démo) ;
+    2. ``recognizer`` : reconnaissance **par région** (``fanout=True`` → l'exécuteur
+       boucle sur les régions, **découpe** chaque bloc via le cropper de couche 5
+       et l'OCR par bloc, couche 4) → ``LAYOUT`` rempli ;
+    3. ``alto_assembler`` : ``LAYOUT`` rempli → ``ALTO_XML`` (déterministe).
+    """
+    steps = (
+        PipelineStep(
+            id="segment",
+            kind="segmentation",
+            adapter_name=segmenter,
+            input_types=(ArtifactType.IMAGE,),
+            output_types=(ArtifactType.LAYOUT,),
+        ),
+        PipelineStep(
+            id="recognize",
+            kind="recognition",
+            adapter_name=recognizer,
+            input_types=(ArtifactType.LAYOUT, ArtifactType.IMAGE),
+            output_types=(ArtifactType.LAYOUT,),
+            inputs_from={ArtifactType.LAYOUT: "segment"},
+            fanout=True,
+            crop=crop,
+        ),
+        PipelineStep(
+            id="assemble",
+            kind="assembly",
+            adapter_name="alto_assembler",
+            input_types=(ArtifactType.LAYOUT,),
+            output_types=(ArtifactType.ALTO_XML,),
+            inputs_from={ArtifactType.LAYOUT: "recognize"},
+        ),
+    )
+    return RunSpec(
+        corpus=corpus,
+        pipelines=(
+            PipelineSpec(
+                name="hybrid", initial_inputs=(ArtifactType.IMAGE,), steps=steps
+            ),
+        ),
+        # Pas de vue : un run hybride **produit** l'ALTO (géométrie + texte) ;
+        # le scoring d'une métrique de structure est un épaississement (F-3b),
+        # soumis à la preuve d'informativité (réflexe T7) avant câblage.
+        evaluation=EvaluationSpec(views=()),
+        adapter_kwargs=adapter_kwargs,
+        run_id=run_id,
+    )
+
+
+def plan_hybrid_run(
+    corpus: CorpusSpec,
+    run_id: str,
+    *,
+    segmenter: str = "pp_doclayout",
+    ocr: str = "tesseract",
+    label: str = "hybrid",
+    source_label: str | None = None,
+    endpoint: str | None = None,
+    token: str | None = None,
+    lang: str = "fra",
+    model: str | None = None,
+    prompt: str | None = None,
+) -> Callable[[Path], RunSpec]:
+    """Builder de spec d'un run **hybride** seg → reconnaissance par région → ALTO.
+
+    Compose un segmenteur (``pp_doclayout`` réel par défaut, ``remote_segmenter``,
+    ou ``precomputed_layout`` démo) + un reconnaisseur **par région** (tout OCR réel
+    — ``tesseract`` par défaut, ``mistral_ocr``… — **ou** un VLM en ``zero_shot``)
+    + ``alto_assembler`` en une ``PipelineSpec`` à fan-out. L'exécuteur découpe
+    chaque bloc (cropper couche 5) et le reconnaît. ``remote_segmenter`` exige
+    ``endpoint`` ; ``precomputed_region`` exige ``source_label`` (démo). ``model``/
+    ``prompt`` ciblent le reconnaisseur (modèle du moteur, prompt VLM).
+    """
+    if segmenter not in _HYBRID_SEGMENTERS:
+        raise RunPlanningError(
+            f"plan_hybrid_run : segmenteur inconnu {segmenter!r} "
+            f"(attendu l'un de {sorted(_HYBRID_SEGMENTERS)})."
+        )
+    recognizer, reco_kwargs = _hybrid_recognizer(
+        ocr,
+        label=label,
+        source_label=source_label,
+        lang=lang,
+        model=model,
+        prompt=prompt,
+    )
+    # OCR réel par bloc → découpe l'image ; ``precomputed_region`` lit un texte
+    # figé par ``region_id`` (page entière, aucun pixel) → pas de crop.
+    crop = ocr != "precomputed_region"
+    adapter_kwargs: _HybridKwargs = {recognizer: reco_kwargs}
+    if segmenter == "remote_segmenter":
+        if not endpoint:
+            raise RunPlanningError(
+                "remote_segmenter : 'endpoint' requis (cible object-detection)."
+            )
+        seg_kwargs: dict[str, str | int | float | bool] = {"endpoint": endpoint}
+        if token:
+            seg_kwargs["token"] = token
+        adapter_kwargs[segmenter] = seg_kwargs
+    return lambda _ws: _hybrid_spec(
+        corpus,
+        run_id,
+        segmenter=segmenter,
+        recognizer=recognizer,
+        crop=crop,
+        adapter_kwargs=adapter_kwargs,
+    )
+
+
+__all__ = [
+    "SEGMENTER_KIND",
+    "SEGMENTER_KINDS",
+    "hybrid_recognizer_catalog",
+    "plan_hybrid_run",
+    "plan_segmentation_run",
+]
diff --git a/cinoc/app/transcription.py b/cinoc/app/transcription.py
new file mode 100644
index 0000000000000000000000000000000000000000..7e4f0617ba5517fe9efc486fdaf628c5eba69a9d
--- /dev/null
+++ b/cinoc/app/transcription.py
@@ -0,0 +1,107 @@
+"""Transcription hybride locale : images → run hybride → fichiers ALTO (couche 6).
+
+Le run **hybride** (segmentation → OCR par région → assemblage ALTO) part
+d'**images sans vérité-terrain** et produit un ALTO par page. Ce module fournit
+les deux bouts que le transport (CLI / web) câble autour de ``plan_hybrid_run`` :
+
+- ``corpus_from_images`` : un dossier d'images → ``CorpusSpec`` (1 image = 1
+  document, id dérivé du nom de fichier, **aucune GT**) ;
+- ``write_alto_files`` : copie chaque ``ALTO_XML`` produit vers
+  ``<out>/<doc>.alto.xml``. Branché en **sink d'orchestrateur** par l'appelant
+  (CLI / web) → écrit **avant** le nettoyage du workspace (URIs encore lisibles,
+  même mécanisme que le sink de segmentation).
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+import shutil
+from pathlib import Path
+
+from cinoc.app.orchestrator import PipelineOutputs
+from cinoc.domain.artifacts import ArtifactType
+from cinoc.domain.corpus import CorpusSpec
+from cinoc.domain.documents import DocumentRef
+from cinoc.domain.errors import CinocError
+
+logger = logging.getLogger(__name__)
+
+#: Extensions d'image reconnues dans un dossier de transcription.
+_IMAGE_EXT = frozenset({".png", ".jpg", ".jpeg", ".tif", ".tiff", ".jp2"})
+
+
+class TranscriptionError(CinocError):
+    """Entrée de transcription invalide (dossier introuvable, sans image…)."""
+
+
+def _doc_id(stem: str, taken: set[str]) -> str:
+    """``stem`` → identifiant de document **valide et unique** (``_DOC_ID_RE``).
+
+    Réduit aux caractères sûrs (accents/espaces → ``_``) pour rester lisible ;
+    une collision (deux radicaux qui se réduisent au même) est désambiguïsée par
+    un suffixe ``-N`` plutôt que par un hash (le nom de fichier de sortie reste
+    lisible)."""
+    base = re.sub(r"[^A-Za-z0-9_.\-]+", "_", stem).strip("_.-") or "doc"
+    candidate = base
+    index = 2
+    while candidate in taken:
+        candidate = f"{base}-{index}"
+        index += 1
+    taken.add(candidate)
+    return candidate
+
+
+def corpus_from_images(
+    directory: str | Path, *, name: str | None = None
+) -> CorpusSpec:
+    """``CorpusSpec`` d'un dossier d'images locales (1 image = 1 document, sans GT).
+
+    Images triées par nom (déterminisme) ; l'id de document dérive du radical du
+    fichier. Dossier introuvable ou sans image reconnue → ``TranscriptionError``.
+    """
+    folder = Path(directory)
+    if not folder.is_dir():
+        raise TranscriptionError(f"dossier d'images introuvable : {folder}")
+    paths = sorted(
+        p
+        for p in folder.iterdir()
+        if p.is_file() and p.suffix.lower() in _IMAGE_EXT
+    )
+    if not paths:
+        raise TranscriptionError(
+            f"aucune image reconnue dans {folder} "
+            f"(extensions : {sorted(_IMAGE_EXT)})."
+        )
+    taken: set[str] = set()
+    documents = tuple(
+        DocumentRef(
+            id=_doc_id(p.stem, taken),
+            image_uri=str(p.resolve()),
+            ground_truths=(),
+        )
+        for p in paths
+    )
+    return CorpusSpec(name=name or folder.name, documents=documents)
+
+
+def write_alto_files(out_dir: Path, outputs: PipelineOutputs) -> list[Path]:
+    """Écrit un ALTO par document portant un ``ALTO_XML``. Retourne les chemins.
+
+    Nom de sortie ``<doc>.alto.xml`` (``/`` → ``_`` ; les ``id`` de document sont
+    déjà sans ``..`` ni absolu, garanti par ``DocumentRef``)."""
+    out_dir.mkdir(parents=True, exist_ok=True)
+    written: list[Path] = []
+    for by_document in outputs.values():
+        for document_id, artifacts in by_document.items():
+            artifact = artifacts.get(ArtifactType.ALTO_XML)
+            if artifact is None or artifact.uri is None:
+                continue
+            target = out_dir / f"{document_id.replace('/', '_')}.alto.xml"
+            shutil.copyfile(artifact.uri, target)
+            written.append(target)
+            logger.info("[transcription] %s → %s", document_id, target)
+    return sorted(written)
+
+
+__all__ = ["TranscriptionError", "corpus_from_images", "write_alto_files"]
diff --git a/cinoc/app/versioning.py b/cinoc/app/versioning.py
new file mode 100644
index 0000000000000000000000000000000000000000..f118cfb164c621090a31255da30b5d82b9570e25
--- /dev/null
+++ b/cinoc/app/versioning.py
@@ -0,0 +1,24 @@
+"""Résolution de la version de code estampillée dans les runs (couche 6).
+
+Source unique : la version du paquet installé, sinon le fallback ``domain``
+(``FALLBACK_VERSION``). Centralisé ici car la version entre dans la **provenance**
+(`RunManifest`) — un concern d'``app`` — et était auparavant recopiée dans
+plusieurs interfaces (CLI, web).
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+
+from cinoc.domain._version_fallback import FALLBACK_VERSION
+
+
+def resolve_code_version() -> str:
+    """Version du paquet ``cinoc`` installé, ou le fallback ``domain``."""
+    try:
+        return version("cinoc")
+    except PackageNotFoundError:  # pragma: no cover (paquet non installé)
+        return FALLBACK_VERSION
+
+
+__all__ = ["resolve_code_version"]
diff --git a/cinoc/domain/MIGRATION_COUCHE_1.md b/cinoc/domain/MIGRATION_COUCHE_1.md
new file mode 100644
index 0000000000000000000000000000000000000000..cdda29dff08d0b0c3c8360d2c376943c1ec4b7c7
--- /dev/null
+++ b/cinoc/domain/MIGRATION_COUCHE_1.md
@@ -0,0 +1,208 @@
+# Plan de migration — Couche 1 (`domain/`) : Picarones → Cinoc
+
+> **Statut** : plan validé, prêt à exécuter.
+> **Périmètre** : uniquement la couche 1 (`domain/`). Les 7 autres couches feront l'objet de plans dédiés.
+> **Source** : `Picarones/picarones/domain/` (15 fichiers, 2 401 LOC).
+> **Cible** : `Cinoc/cinoc/domain/` (13 fichiers après décisions : `facts.py`
+> et `module_protocol.py` non migrés en `domain`). Le contrat de module
+> exécutable n'est **pas perdu** : il est construit en couche 4 (`pipeline`),
+> voir D1.
+
+---
+
+## 1. Objectif
+
+La couche `domain` est le **cœur typé** du système : elle ne contient que des
+définitions de données (le « vocabulaire » du produit), sans aucune logique
+métier, sans I/O, sans dépendance à un moteur externe. Elle n'importe que la
+bibliothèque standard Python, `pydantic` et `pydantic_core`.
+
+C'est la couche la plus saine de Picarones (~91 % à recopier tel quel). Ce plan
+acte les suppressions décidées et liste, fichier par fichier, ce qui est porté,
+nettoyé ou abandonné.
+
+---
+
+## 2. Décisions actées (ce qui change par rapport à Picarones)
+
+| # | Décision | Conséquence concrète |
+|---|----------|----------------------|
+| **D1** | **`BaseModule` : contrat unique de module, construit en couche 4 (pas en `domain`)** | L'extensibilité tierce est une exigence d'enveloppe → on construit **un seul contrat de module exécutable (`Protocol`)** implémenté directement (≠ le double contrat `BaseOCRAdapter`→`BaseModule` de Picarones). **Mais il vit en `pipeline` (couche 4)**, pas en `domain` : sa méthode `execute()` porte des concerns d'exécution (deadline, annulation via `RunControl`, couche 4) — un `Protocol` en `domain` qui les référencerait violerait le sens des dépendances. Donc `module_protocol.py` n'est **pas** recréé en `domain`. La couche 1 ne garde que le **déclaratif** : `PipelineStep` (qui nomme l'`adapter_name` + `input_types`/`output_types`) et `ArtifactType` suffisent à décrire un module dans une spec. Registre + découverte entry-points = couche `app`. |
+| **D2** | **Supprimer entièrement le moteur narratif** | `facts.py` **non migré**. Cinoc n'aura pas de synthèse en prose : le rapport affichera les chiffres et tableaux bruts. Supprime aussi, en aval, toute la couche 7 `reports/narrative/` (hors périmètre de ce plan, mais acté). |
+| **D3** | Purger le legacy résiduel des fichiers conservés | Voir §4 : `LEGACY_VALUE_ALIASES`, shim `pipeline_names` du `RunManifest`. |
+| **D4** | Renommer la racine d'erreurs | `PicaronesError` → `CinocError` (et toute la hiérarchie reste). |
+| **D5** | Nettoyer les commentaires historiques | Supprimer toutes les annotations de sprint (`S4`, `A14-S29`, `Phase 7.1`…) et les références au fichier inexistant `BACKLOG_POST_LIVRAISON.md`. |
+| **D6** | Convention de nommage | Préférer `pipelines_involved` à `engines_involved` (le champ d'origine disparaît avec `facts`). |
+| **D7** | `ArtifactType.LAYOUT` (type structurel unique) | Segmentation et structure transcrite = un seul type. Pas de `REGIONS` séparé : une segmentation est un `CanonicalLayout` à régions sans lignes. `CanonicalLayout` → `domain`, matérialisé à la **tranche segmentation** (pas en couche 2 : anti-spéculatif — cf. `formats/MIGRATION_COUCHE_2.md`, L10). |
+| **D8** | **Ajouter `region_id` optionnel sur `Artifact`** | Permet de représenter « un artefact texte rattaché à une région ». Socle du fan-out par bloc (modèle b, **retenu**) : métriques par bloc + routage par type de bloc. `None` = artefact au niveau page. |
+| **D9** | **Rapatrier `RunCancelledError` dans `errors.py`** | Seule erreur transverse mal placée (était en `pipeline/run_control.py`), sœur de `DeadlineExceeded`. Voir §4.3. Les autres types « domain » repérés ailleurs (`ProjectionReport`, `RunSpec`, `ConfidenceToken`) sont **différés** à la migration de leur couche propriétaire (backlog domain dans `CLAUDE.md`) — pas créés maintenant (anti-spéculatif). |
+
+---
+
+## 3. Inventaire source → cible
+
+15 fichiers Picarones → **13 fichiers Cinoc** (`facts.py` et `module_protocol.py`
+non migrés en `domain`). Les seuls ajouts de la couche 1 liés à la structure
+sont `ArtifactType.LAYOUT` et `Artifact.region_id` (dans `artifacts.py`).
+
+| # | Picarones (`domain/`) | → Cinoc (`domain/`) | Décision | Transformation |
+|---|------------------------|----------------------|----------|----------------|
+| 1 | `__init__.py` | `__init__.py` | **KEEP** | Retirer exports de `facts` et `module_protocol` ; supprimer annotations sprint |
+| 2 | `_version_fallback.py` | `_version_fallback.py` | **KEEP** | `FALLBACK_VERSION = "0.1.0"` ; mettre à jour la docstring |
+| 3 | `artifacts.py` | `artifacts.py` | **KEEP + purge + étendre** | Supprimer `LEGACY_VALUE_ALIASES` + les 3 alias `TEXT/ALTO/PAGE` (garder `_missing_()`) ; **ajouter `ArtifactType.LAYOUT` (D7) et le champ `region_id` (D8)** |
+| 4 | `artifact_key.py` | `artifact_key.py` | **KEEP** | Recopier tel quel (purge réfs sprint) |
+| 5 | `corpus.py` | `corpus.py` | **KEEP** | Supprimer réf. `BACKLOG_POST_LIVRAISON.md` + note « S10 » |
+| 6 | `documents.py` | `documents.py` | **KEEP** | Recopier tel quel (conserver la défense path-traversal) |
+| 7 | `provenance.py` | `provenance.py` | **KEEP** | Recopier (purge réfs sprint). À **réellement câbler** côté executor (couche 4) : 0 consommateur dans Picarones (provenance dormante) |
+| 8 | `projection_spec.py` | `projection.py` *(renommé)* | **KEEP** | Recopier tel quel |
+| 9 | `errors.py` | `errors.py` | **KEEP + rename + D9** | `PicaronesError` → `CinocError` ; purger note legacy `core` ; **ajouter `RunCancelledError`** (rapatriée de `pipeline/run_control.py`) |
+| 10 | `pipeline_spec.py` | `pipeline.py` *(renommé)* | **KEEP** | Recopier tel quel (purge réfs sprint) |
+| 11 | `evaluation_spec.py` | `evaluation.py` *(renommé)* | **KEEP** | Recopier ; purger réf. backlog + mention `compute_metrics (legacy)` |
+| 12 | `module_protocol.py` | — | **DROP de `domain` (D1)** | Non migré en `domain`. Le contrat de module exécutable (`Protocol`) est construit en couche 4 (`pipeline`) — voir D1 |
+| 13 | `run_manifest.py` | `run.py` *(renommé)* | **KEEP + purge** | Supprimer `pipeline_names` (computed_field) ET `_accept_legacy_pipeline_names` (~67 LOC de shim) |
+| 14 | `facts.py` | — | **DROP (D2)** | Non migré |
+| 15 | `deadline.py` | `deadline.py` | **KEEP** | Recopier tel quel (type exemplaire) |
+
+> **Renommages (actés)** : `projection_spec.py`→`projection.py`,
+> `pipeline_spec.py`→`pipeline.py`, `evaluation_spec.py`→`evaluation.py`,
+> `run_manifest.py`→`run.py`. Nom = concept ; les suffixes `_spec`/`_manifest`
+> étaient des béquilles de migration. `domain.pipeline` et `domain.evaluation`
+> partagent le nom des couches `pipeline/`/`evaluation/` mais en sont distincts
+> par le chemin d'import.
+
+---
+
+## 4. Détail des transformations par fichier
+
+### 4.1 `artifacts.py` — purge des alias legacy
+- **Conserver** : `ArtifactType` (10 valeurs canoniques), `compute_content_hash`, la classe `Artifact` (frozen, validators id/hash), `_missing_()` (accepte `"text"`/`"alto"`/`"page"` dans les YAML).
+- **Supprimer** : le dict `LEGACY_VALUE_ALIASES` + le bloc de commentaire `expand_legacy_keys` (lignes ~133-150). Unique consommateur = `module_policy.py` (couche 3), lui-même destiné à être réécrit.
+- **Supprimer** : les 3 attributs alias `TEXT`/`ALTO`/`PAGE` de l'enum. Migrer les call-sites vers les noms canoniques (`RAW_TEXT`/`ALTO_XML`/`PAGE_XML`). *(Hors couche 1 — à traiter quand on portera les couches consommatrices.)*
+
+### 4.2 `run.py` (ex-`run_manifest.py`) — suppression du shim
+- **Conserver** : tous les champs reproductibilité (`run_id`, `corpus_name`, `n_documents`, `pipeline_specs`, `adapter_kwargs`, `view_specs`, `code_version`, `started_at/completed_at`, `dependencies_lock`, `system_binaries_lock`, `metadata`), `duration_seconds`, `utcnow()`.
+- **Supprimer** : le `computed_field` `pipeline_names` (lignes ~129-139) et le `model_validator` `_accept_legacy_pipeline_names` (lignes ~141-196). Pur shim de compatibilité JSON, sans consommateur une fois l'ancien `reports/html/render.py` abandonné.
+
+### 4.3 `errors.py` — renommage de la racine + 1 rapatriement (D9)
+- `PicaronesError` → **`CinocError`**. Conserver toutes les sous-classes : `ArtifactValidationError`, `ProjectionError`, `CorpusSpecError`, `AdapterStepError`, `DeadlineExceeded`.
+- **Ajouter `RunCancelledError` (D9)** — rapatriée de `pipeline/run_control.py`. C'est une **erreur transverse** (levée par le runner, rattrapée ailleurs), sœur de `DeadlineExceeded` qui est déjà en domain. Forme triviale et stable → le seul type « venu d'une autre couche » qui s'intègre proprement dès la couche 1. *(L'objet `RunControl` lui-même reste en couche 4 : threading + état mutable.)*
+- Conserver intégralement la docstring de `DeadlineExceeded` (elle porte un vrai contrat de comportement pour les adapters).
+- Supprimer la note historique sur `picarones.core` (lignes ~26-30).
+
+### 4.4 Fichiers recopiés sans changement fonctionnel
+`artifact_key.py`, `documents.py`, `provenance.py`, `projection.py`,
+`pipeline.py`, `evaluation.py`, `corpus.py`, `deadline.py`, `_version_fallback.py`.
+Seules transformations : retrait des annotations de sprint et des références au
+backlog inexistant. **Aucune logique ne change.**
+
+### 4.5 `__init__.py` — agrégateur
+- Retirer des imports/`__all__` tout ce qui vient de `facts` (`Fact`, `FactType`, `FactImportance`, `DetectorFn`, `DetectorRegistry`, `detect_all`) **et** de `module_protocol` (`BaseModule`).
+- **Exporter** `ArtifactType.LAYOUT` (le `region_id` est un champ d'`Artifact`, déjà exporté).
+- Adapter les chemins d'import aux fichiers renommés.
+- Conserver la note expliquant pourquoi `RunResult` n'est PAS dans `domain` (il agrège des couches externes).
+
+### 4.6 `module_protocol.py` — NON migré en `domain` (contrat déplacé en couche 4)
+- Le contrat de module **n'est pas perdu**, mais il **ne vit pas en `domain`** :
+  sa méthode `execute()` a besoin de la deadline et de l'annulation
+  (`RunControl`, couche 4). Un `Protocol` en couche 1 qui les référencerait
+  importerait vers l'extérieur → interdit.
+- **Décision** : construire **un seul `Protocol` de module exécutable en couche 4
+  (`pipeline`)** — `name`, `version` (reproductibilité), `input_types`,
+  `output_types`, `execute(inputs, params, contexte d'exécution) → outputs`.
+  Implémenté **directement** par chaque module (≠ double contrat de Picarones).
+- **Au niveau couche 1**, rien à faire : `PipelineStep` (déclare `adapter_name`
+  + `input_types`/`output_types`) et `ArtifactType` suffisent à **décrire** un
+  module dans une spec. Registre + découverte entry-points = couche `app`.
+- ⚠️ À traiter dans le **plan de la couche 4**, pas ici.
+
+### 4.7 `artifacts.py` — extensions structure (D7/D8)
+- `ArtifactType.LAYOUT` : type structurel unique (pas de `REGIONS` séparé).
+- `region_id: str | None` sur `Artifact` : rattachement d'un artefact à une
+  région ; `None` = niveau page.
+- La classe `CanonicalLayout` (et ses parties) n'est **pas** créée en couche 1 :
+  décidée en `domain`, matérialisée à la **tranche segmentation** (pas en couche 2 ;
+  backlog domain dans `CLAUDE.md`).
+
+---
+
+## 5. Renommages transverses (à propager dans tout Cinoc)
+
+| Picarones | Cinoc | Portée |
+|-----------|--------|--------|
+| `PicaronesError` | `CinocError` | Toute la base de code |
+| `picarones.domain.*` | `cinoc.domain.*` | Tous les imports |
+| `engines_involved` | `pipelines_involved` | Convention (le champ disparaît avec `facts`, mais la règle reste) |
+| `code_version="1.0.0"` (placeholder de test) | constante de fixture unique, nommée et documentée à un seul endroit | Tests |
+
+---
+
+## 6. Ordre d'exécution
+
+1. **Squelette** : créer `cinoc/domain/` (fait — ce dossier).
+2. **Fichiers sans dépendance interne d'abord** (ordre topologique des imports) :
+   `errors.py` → `_version_fallback.py` → `artifacts.py` → `provenance.py`
+   → `artifact_key.py` → `documents.py` → `corpus.py` → `projection.py`
+   → `evaluation.py` → `pipeline.py` → `deadline.py` → `run.py`.
+3. **`__init__.py`** en dernier (il agrège tout).
+4. **Tests** (voir §7) écrits en parallèle de chaque fichier.
+5. **Vérification** : `mypy --strict cinoc/domain/`, `ruff check`, `pytest tests/domain tests/architecture`.
+
+---
+
+## 7. Tests indispensables (couche 1)
+
+### Domain
+- Validateurs Pydantic : `doc_id` rejette `..` et chemins absolus ; `PipelineStep.id` unique et alphanumérique ; `PipelineMode` est un `Literal` strict (rejette toute autre valeur).
+- Hash déterministe : `ArtifactKey.hash_hex()` stable et reproductible ; `Artifact.content_hash` validé hex 64 chars ; `hash_hex()` retourne `None` si un input manque.
+- `Deadline` : monotonic, `remaining_seconds` jamais négatif, sérialisation cross-process (`to_dict`/`from_dict`/pickle), immutabilité.
+- `RunManifest` : round-trip JSON byte-stable **sans** le shim `pipeline_names`.
+- `CinocError` : la hiérarchie attrape bien toutes les sous-classes.
+
+### Architecture (à activer dès maintenant)
+- `test_layer_dependencies` : `domain` n'importe que stdlib + `pydantic` + `pydantic_core`.
+- `test_no_legacy_imports` : aucun import de `picarones`, aucun symbole `Fact*`/`BaseModule`.
+- `test_single_version_source` : `FALLBACK_VERSION` == `pyproject.toml [tool.setuptools_scm]`.
+- `test_no_broad_except` : pas de `except Exception: pass`.
+- `test_no_side_effect_imports` : les `__init__.py` ne déclenchent aucun effet de bord.
+
+---
+
+## 8. DoD vivante (couche 1) — **autorité de détail** ; le `MIGRATION_PLAN.md` indexe
+
+> **T8 (D-066)** : `+ usage.py` — `ResourceUsage` (durée wall-clock + jetons, `merged_with` somme `None`-tolérante) ; vocabulaire transversal consommé par la couche 4 (`StepOutput`) et la couche 3 (`RunResult.usage`). Preuve : `tests/evaluation/test_result.py::test_usage_channel_round_trips`.
+
+> **T12 (D-070)** : `+ confidence.py` — `ConfidenceToken` (mot + confiance [0,1]), schéma du payload `CONFIDENCES`, créé avec son 1ᵉʳ consommateur (calibration couche 3). Backlog domain : dernière entrée cochée.
+
+> Tri-état : `[x]` fait **+ preuve** · `[ ]` à faire · `[~]` différé/réserve + raison.
+> Mise à jour dans le **même commit** que le code (règle d'or anti-dérive).
+> **Statut couche 1 : ✅ vert** (vérifié 2026-05-31).
+
+- [x] 13 fichiers dans `cinoc/domain/` ; `facts.py`/`module_protocol.py` **non** migrés. — *preuve : `ls cinoc/domain` ; `test_no_legacy_imports` (tokens `Fact`/`BaseModule` absents)*
+- [x] `ArtifactType.LAYOUT` et `Artifact.region_id` présents. — *preuve : `cinoc/domain/artifacts.py:55,138`*
+- [x] Contrat de module **reporté à la couche 4** (pas un livrable couche 1). — *preuve : `module_protocol.py` absent de `domain/`*
+- [x] Aucune occurrence de `PicaronesError`/`BaseModule`/`Fact`/`LEGACY_VALUE_ALIASES`/`pipeline_names`/`BACKLOG_POST_LIVRAISON`. — *preuve : `tests/architecture/test_no_legacy_imports.py` vert*
+- [x] Aucune annotation de sprint résiduelle. — *preuve : `grep -rE "Sprint|Phase [0-9]" cinoc/domain` vide*
+- [x] `mypy --strict` vert sur `domain`. — *preuve : `mypy --strict -p cinoc.domain` → Success*
+- [x] `ruff check` vert. — *preuve : `ruff check cinoc/` → All checks passed*
+- [x] Tests domain + architecture verts. — *preuve : `pytest` 163 passed / 95 % cov*
+- [x] Import sans effet de bord. — *preuve : `tests/architecture/test_no_side_effect_imports.py` vert*
+- [~] **Réserve partiellement levée (T1)** : `MetricSpec`/`EvaluationView`/`EvaluationSpec` ont un consommateur (registre + runner couche 3) → **confirmés, gardés**. `ProjectionSpec` reste **sans consommateur** → différé à T2 (projections). — *cf. journal D-009.*
+- [~] **Différé-par-design** : backlog domain (`RunSpec`/`ProjectionReport`/`ConfidenceToken`), `CanonicalLayout`. — *anti-spéculatif : créés à la tranche de leur 1ᵉʳ consommateur (§9).*
+
+---
+
+## 9. Risques & points ouverts
+
+- **Suppression des alias `TEXT/ALTO/PAGE`** : touche ~25 call-sites hors couche 1.
+  La couche 1 peut être migrée sans attendre ; les call-sites seront corrigés
+  lors du portage des couches consommatrices.
+- **`RunSpec`** : vit aujourd'hui en couche 6 (`app/schemas/`). L'architecture cible
+  le rapatrie dans `domain` (frère de `PipelineSpec`/`EvaluationSpec`). **Hors
+  périmètre de ce plan** — à créer au moment de la couche 6, en séparant du loader YAML.
+- **Backlog domain** : `ProjectionReport` (couche 3), `RunSpec` (couche 6),
+  `ConfidenceToken` (différable) sont des types qui appartiennent à `domain` mais
+  ne sont **pas** créés ici (anti-spéculatif : pas de consommateur en couche 1).
+  Liste et critère d'appartenance dans `CLAUDE.md`.
+- **`RunContext`** : ne PAS le placer en `domain`. Il fait paire avec `RunControl`
+  (threading, couche 4) et c'est l'argument de `execute()` → **couche 4**. Noté
+  ici pour éviter une future tentation de rapatriement.
diff --git a/cinoc/domain/__init__.py b/cinoc/domain/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1342e4aaaa653160ba328ec1ed10c5bd01203a27
--- /dev/null
+++ b/cinoc/domain/__init__.py
@@ -0,0 +1,82 @@
+"""Couche 1 — Domain.
+
+Types purs et abstractions du modèle métier de Cinoc. Ce cercle
+n'importe que la stdlib, ``pydantic`` et ``pydantic_core``. Il ne dépend
+d'aucun moteur OCR, d'aucune métrique calculée, d'aucun rendu, d'aucune
+couche réseau.
+
+Règle d'or : si tu hésites à mettre quelque chose ici, c'est qu'il ne
+devrait pas y être. Le domain ne fait presque rien — il décrit.
+
+Note : ``RunResult`` / ``RunDocumentResult`` ne sont PAS ici — ils
+agrègent des objets de couches plus externes (``evaluation``,
+``pipeline``). Le domain ne décrit que des contrats.
+"""
+
+from __future__ import annotations
+
+from cinoc.domain.artifacts import Artifact, ArtifactType, compute_content_hash
+from cinoc.domain.confidence import ConfidenceToken
+from cinoc.domain.corpus import CorpusSpec
+from cinoc.domain.deadline import Deadline
+from cinoc.domain.documents import DocumentRef, GroundTruthRef
+from cinoc.domain.errors import (
+    AdapterStepError,
+    ArtifactValidationError,
+    CinocError,
+    CorpusSpecError,
+    DeadlineExceeded,
+    ProjectionError,
+    RunCancelledError,
+)
+from cinoc.domain.evaluation import EvaluationSpec, EvaluationView, MetricSpec
+from cinoc.domain.pipeline import (
+    INITIAL_STEP_ID,
+    PipelineMode,
+    PipelineSpec,
+    PipelineStep,
+)
+from cinoc.domain.projection import ProjectionSpec
+from cinoc.domain.provenance import ProvenanceRecord
+from cinoc.domain.run import RunManifest, utcnow
+from cinoc.domain.usage import ResourceUsage
+
+__all__ = [
+    # Artifacts
+    "Artifact",
+    "ArtifactType",
+    "compute_content_hash",
+    # Corpus + documents
+    "CorpusSpec",
+    "DocumentRef",
+    "GroundTruthRef",
+    # Timeout
+    "Deadline",
+    # Provenance
+    "ProvenanceRecord",
+    # Errors
+    "CinocError",
+    "ArtifactValidationError",
+    "ProjectionError",
+    "CorpusSpecError",
+    "AdapterStepError",
+    "DeadlineExceeded",
+    "RunCancelledError",
+    # Evaluation contracts
+    "MetricSpec",
+    "EvaluationView",
+    "EvaluationSpec",
+    "ProjectionSpec",
+    # Pipeline spec
+    "PipelineSpec",
+    "PipelineStep",
+    "PipelineMode",
+    "INITIAL_STEP_ID",
+    # Run manifest
+    "RunManifest",
+    "utcnow",
+    # Ressources mesurées
+    "ResourceUsage",
+    # Confidences moteur
+    "ConfidenceToken",
+]
diff --git a/cinoc/domain/_version_fallback.py b/cinoc/domain/_version_fallback.py
new file mode 100644
index 0000000000000000000000000000000000000000..c01d4a87ae00db0befbe87017cde97d408d36365
--- /dev/null
+++ b/cinoc/domain/_version_fallback.py
@@ -0,0 +1,18 @@
+"""Source unique du fallback de version.
+
+Vit dans la couche ``domain`` pour être importable depuis n'importe
+quelle couche sans violer le sens des dépendances. Volontairement
+minimal : aucun import, aucune logique.
+
+``FALLBACK_VERSION`` est utilisé uniquement quand les deux sources
+canoniques sont absentes :
+
+1. ``cinoc/_version.py`` (généré au build par setuptools_scm) ;
+2. ``importlib.metadata.version("cinoc")`` (paquet installé via pip).
+
+Cohérence avec ``pyproject.toml`` : la valeur ci-dessous DOIT être
+identique à ``[tool.setuptools_scm] fallback_version``. Vérifié par
+``tests/architecture/test_single_version_source.py``.
+"""
+
+FALLBACK_VERSION = "0.1.0"
diff --git a/cinoc/domain/artifacts.py b/cinoc/domain/artifacts.py
new file mode 100644
index 0000000000000000000000000000000000000000..153ccab2c6962cb57bedabd470a27d875e0de970
--- /dev/null
+++ b/cinoc/domain/artifacts.py
@@ -0,0 +1,183 @@
+"""``Artifact`` et ``ArtifactType``.
+
+Toute sortie d'une étape de pipeline est un artefact traçable :
+identifiant stable, type explicite, hash du contenu, provenance.
+
+Distinctions clés pour les vues d'évaluation :
+
+- ``RAW_TEXT`` vs ``CORRECTED_TEXT`` — même structure (string), contrats
+  différents : seul le second a été modifié par un modèle après l'OCR.
+- ``LAYOUT`` vs ``CANONICAL_DOCUMENT`` — ``LAYOUT`` porte la structure
+  spatiale neutre (régions/lignes/mots/géométrie, payload
+  ``CanonicalLayout``) ; ``CANONICAL_DOCUMENT`` est un contenu textuel
+  riche sans coordonnées (markdown/JSON de VLM).
+"""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from enum import StrEnum
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+
+class ArtifactType(StrEnum):
+    """Type d'un artefact produit ou consommé par une étape de pipeline.
+
+    Convention : ``UPPER_SNAKE_CASE`` pour le nom Python,
+    ``lower_snake_case`` pour la valeur sérialisée (YAML de pipeline,
+    exports JSON).
+    """
+
+    #: Image source (PNG, TIFF, JPEG). Entrée typique d'un OCR.
+    IMAGE = "image"
+
+    #: Texte brut produit par un OCR (avant correction LLM).
+    RAW_TEXT = "raw_text"
+
+    #: Texte corrigé par un LLM ou un module de post-correction.
+    CORRECTED_TEXT = "corrected_text"
+
+    #: Texte de **référence** (ex. OCR pré-existant fourni par une source :
+    #: ``texteBrut`` Gallica) — **distinct d'une vérité-terrain manuelle**. Sert
+    #: de référence de comparaison *étiquetée* : un score contre un
+    #: ``REFERENCE_TEXT`` mesure l'**accord avec un autre OCR**, pas l'exactitude.
+    #: N'est jamais résolu par une vue d'évaluation par défaut (opt-in explicite
+    #: via une projection ``reference_text → raw_text``).
+    REFERENCE_TEXT = "reference_text"
+
+    #: ALTO XML 4.x (lignes, mots, coordonnées, ordre de lecture).
+    ALTO_XML = "alto_xml"
+
+    #: PAGE XML (PRIMA / Transkribus).
+    PAGE_XML = "page_xml"
+
+    #: Représentation canonique textuelle riche sans coordonnées (sortie
+    #: VLM : markdown, JSON canonique).
+    CANONICAL_DOCUMENT = "canonical_document"
+
+    #: Structure de mise en page neutre (ALTO/PAGE unifiés) : pages,
+    #: régions, lignes, mots, géométrie. Payload = ``CanonicalLayout``.
+    #: Une sortie de segmentation est un ``LAYOUT`` à régions sans lignes.
+    LAYOUT = "layout"
+
+    #: Liste d'entités nommées (PER, LOC, ORG, DATE, MISC…).
+    ENTITIES = "entities"
+
+    #: Liste ordonnée d'IDs de régions définissant l'ordre de lecture.
+    READING_ORDER = "reading_order"
+
+    #: Alignement entre deux artefacts (ex. ``RAW_TEXT`` → ``CORRECTED_TEXT``).
+    ALIGNMENT = "alignment"
+
+    #: Confidences OCR au niveau token (sidecar JSON).
+    CONFIDENCES = "confidences"
+
+    @classmethod
+    def _missing_(cls, value: object) -> ArtifactType | None:
+        """Accepte les chaînes courtes ``"text"``/``"alto"``/``"page"`` en
+        plus des valeurs canoniques (commodité pour les specs YAML)."""
+        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 short_map.get(value)
+
+
+def compute_content_hash(payload: bytes) -> str:
+    """SHA-256 hex (64 chars) d'un payload binaire.
+
+    Helper exposé au domain pour que les adapters calculent un hash
+    compatible avec ``Artifact.content_hash``.
+    """
+    return hashlib.sha256(payload).hexdigest()
+
+
+# Identifiant stable et filesystem-safe (utilisable comme nom de fichier
+# dans un store) sans format trop restrictif.
+_ID_RE = re.compile(r"^[A-Za-z0-9_.\-:/]+$")
+
+
+class Artifact(BaseModel):
+    """Une sortie traçable d'une étape de pipeline.
+
+    Immuable (``frozen=True``) : pour « modifier » un artefact, une étape
+    en produit un nouveau. Sérialisation déterministe
+    (``model_dump_json()`` stable) — indispensable pour le cache.
+
+    Attributs
+    ---------
+    id:
+        Identifiant unique dans le contexte d'un run. Convention :
+        ``"<doc_id>:<step>:<type>"`` (le caller est libre tant que c'est
+        unique et matche ``_ID_RE``).
+    document_id:
+        ``DocumentRef.id`` du document auquel l'artefact appartient.
+    type:
+        Type de l'artefact.
+    uri:
+        Chemin/URI vers le contenu. ``None`` si stocké inline.
+    content_hash:
+        SHA-256 hex (64 chars). ``None`` seulement pour les artefacts
+        initiaux fournis par l'utilisateur ; immuable une fois calculé.
+    produced_by_step:
+        Nom de l'étape qui a produit l'artefact. ``None`` pour les
+        artefacts initiaux.
+    region_id:
+        Identifiant de la région d'origine quand l'artefact est rattaché
+        à un bloc (fan-out par bloc). ``None`` = artefact au niveau page.
+    provenance:
+        ``ProvenanceRecord`` (``code_version`` + ``parameters_hash``).
+        ``None`` pour les artefacts initiaux.
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    id: str = Field(min_length=1, max_length=512)
+    document_id: str = Field(min_length=1, max_length=256)
+    type: ArtifactType
+    uri: str | None = Field(default=None, max_length=2048)
+    content_hash: str | None = Field(default=None, min_length=64, max_length=64)
+    produced_by_step: str | None = Field(default=None, max_length=256)
+    region_id: str | None = Field(default=None, max_length=256)
+    provenance: ProvenanceRecord | None = Field(default=None)
+
+    @field_validator("id", "document_id")
+    @classmethod
+    def _validate_filesystem_safe_id(cls, v: str) -> str:
+        if not _ID_RE.match(v):
+            from cinoc.domain.errors import ArtifactValidationError
+
+            raise ArtifactValidationError(
+                f"id invalide : {v!r}. Doit matcher {_ID_RE.pattern!r} "
+                "(alphanum + ``_.-:/``)."
+            )
+        return v
+
+    @field_validator("content_hash")
+    @classmethod
+    def _validate_hex_hash(cls, v: str | None) -> str | None:
+        if v is None:
+            return v
+        try:
+            int(v, 16)
+        except ValueError:
+            from cinoc.domain.errors import ArtifactValidationError
+
+            raise ArtifactValidationError(
+                f"content_hash doit être hex SHA-256 64 chars : {v!r}"
+            ) from None
+        return v.lower()
+
+
+# Forward reference pour ``provenance``.
+from cinoc.domain.provenance import ProvenanceRecord  # noqa: E402
+
+Artifact.model_rebuild()
+
+
+__all__ = ["Artifact", "ArtifactType", "compute_content_hash"]
diff --git a/cinoc/domain/confidence.py b/cinoc/domain/confidence.py
new file mode 100644
index 0000000000000000000000000000000000000000..05cf2ccfcfeb3fe6ebbf0010ec17075f077f4fc2
--- /dev/null
+++ b/cinoc/domain/confidence.py
@@ -0,0 +1,23 @@
+"""``ConfidenceToken`` — schéma du payload ``CONFIDENCES`` (couche 1).
+
+Un jeton de confiance = un mot produit par le moteur + son auto-estimation de
+fiabilité dans [0, 1]. Sérialisé en sidecar JSON (liste de jetons) à côté du
+texte brut ; consommé par la calibration (couche 3). Type créé **avec** son
+premier consommateur (déclencheur du backlog domain atteint).
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ConfidenceToken(BaseModel):
+    """Mot reconnu + confiance déclarée par le moteur (0 = nulle, 1 = sûre)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    text: str = Field(min_length=1, max_length=256)
+    confidence: float = Field(ge=0, le=1)
+
+
+__all__ = ["ConfidenceToken"]
diff --git a/cinoc/domain/corpus.py b/cinoc/domain/corpus.py
new file mode 100644
index 0000000000000000000000000000000000000000..a8831c07637b6ca10d73c13f442e1008d29c7fb6
--- /dev/null
+++ b/cinoc/domain/corpus.py
@@ -0,0 +1,68 @@
+"""``CorpusSpec`` — description immuable et déclarative d'un corpus.
+
+Construit par un adapter de corpus, consommé par les services
+applicatifs et le pipeline. Minimaliste : il décrit la structure (liste
+de documents + métadonnées). Le chargement, le parsing et la détection
+des patterns de nommage GT vivent ailleurs.
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+from cinoc.domain.documents import DocumentRef
+
+
+class CorpusSpec(BaseModel):
+    """Description immuable d'un corpus à benchmarker.
+
+    Ne contient pas la racine du filesystem : les URIs des documents sont
+    résolubles sans contexte, ce qui permet à un service de réécrire les
+    chemins (sandbox, cache) sans muter le ``CorpusSpec``.
+
+    Attributs
+    ---------
+    name:
+        Nom court (rapports, cache, logs).
+    documents:
+        Liste ordonnée des ``DocumentRef`` ; ids uniques.
+    metadata:
+        Dictionnaire libre de contexte (``language``, ``period``,
+        ``source``…). Pas de validation stricte sur les clés.
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    name: str = Field(min_length=1, max_length=128)
+    documents: tuple[DocumentRef, ...] = Field(default_factory=tuple)
+    metadata: dict[str, str] = Field(default_factory=dict)
+
+    @field_validator("documents")
+    @classmethod
+    def _validate_unique_doc_ids(
+        cls, v: tuple[DocumentRef, ...],
+    ) -> tuple[DocumentRef, ...]:
+        seen: set[str] = set()
+        for doc in v:
+            if doc.id in seen:
+                from cinoc.domain.errors import CorpusSpecError
+
+                raise CorpusSpecError(
+                    f"document id dupliqué : {doc.id!r}. Les id de DocumentRef "
+                    "doivent être uniques au sein d'un CorpusSpec."
+                )
+            seen.add(doc.id)
+        return v
+
+    def __len__(self) -> int:
+        return len(self.documents)
+
+    def doc_by_id(self, doc_id: str) -> DocumentRef | None:
+        """Retourne le ``DocumentRef`` correspondant ou ``None``."""
+        for doc in self.documents:
+            if doc.id == doc_id:
+                return doc
+        return None
+
+
+__all__ = ["CorpusSpec"]
diff --git a/cinoc/domain/deadline.py b/cinoc/domain/deadline.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ce55332cc8786899ebf5d8b04a1d20a80824309
--- /dev/null
+++ b/cinoc/domain/deadline.py
@@ -0,0 +1,227 @@
+"""``Deadline`` — type valeur représentant une échéance d'opération.
+
+Contrat de timeout propagé aux adapters via le contexte d'exécution.
+Permet à chaque adapter de respecter coopérativement un budget temps par
+document (passage du timeout au SDK, check entre opérations bloquantes,
+levée de ``DeadlineExceeded`` à expiration).
+
+Une ``Deadline`` est soit infinie (aucune contrainte), soit finie avec
+une expiration absolue dans l'horloge monotonic du process courant.
+L'horloge monotonic ne recule jamais mais a une origine privée au
+process : la sérialisation convertit donc vers ``remaining_seconds`` au
+moment du transfert, et une nouvelle ``Deadline`` est reconstruite
+relativement à l'horloge du process receveur.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from pydantic import GetCoreSchemaHandler
+from pydantic_core import core_schema
+
+from cinoc.domain.errors import CinocError
+
+
+class Deadline:
+    """Type valeur immuable représentant une échéance d'opération."""
+
+    _expires_at_monotonic: float | None
+    __slots__ = ("_expires_at_monotonic",)
+
+    def __init__(self, expires_at_monotonic: float | None) -> None:
+        if expires_at_monotonic is not None and not isinstance(
+            expires_at_monotonic, (int, float),
+        ):
+            raise CinocError(
+                "Deadline : expires_at_monotonic doit être float ou None, "
+                f"reçu {type(expires_at_monotonic).__name__}",
+            )
+        object.__setattr__(
+            self,
+            "_expires_at_monotonic",
+            float(expires_at_monotonic)
+            if expires_at_monotonic is not None
+            else None,
+        )
+
+    # ── Constructeurs ────────────────────────────────────────────────
+
+    @classmethod
+    def infinite(cls) -> Deadline:
+        """Pas d'échéance — ``remaining_seconds()`` → ``None``,
+        ``is_expired()`` → ``False``."""
+        return cls(expires_at_monotonic=None)
+
+    @classmethod
+    def in_seconds(cls, budget: float) -> Deadline:
+        """Échéance dans ``budget`` secondes (> 0) à partir de maintenant."""
+        if not isinstance(budget, (int, float)):
+            raise CinocError(
+                "Deadline.in_seconds : budget doit être numérique, "
+                f"reçu {type(budget).__name__}",
+            )
+        if budget <= 0:
+            raise CinocError(
+                f"Deadline.in_seconds : budget doit être > 0 (reçu {budget}). "
+                "Pour une deadline déjà expirée en test, utiliser "
+                "``Deadline.at_monotonic(0.0)``.",
+            )
+        return cls(expires_at_monotonic=time.monotonic() + float(budget))
+
+    @classmethod
+    def at_monotonic(cls, expires_at: float) -> Deadline:
+        """Échéance à l'instant monotonic absolu ``expires_at`` (surtout
+        utile en tests : ``at_monotonic(0.0)`` = déjà expirée)."""
+        return cls(expires_at_monotonic=expires_at)
+
+    # ── Interrogation ────────────────────────────────────────────────
+
+    @property
+    def is_infinite(self) -> bool:
+        return self._expires_at_monotonic is None
+
+    def remaining_seconds(self) -> float | None:
+        """Secondes restantes, ou ``None`` si infinie. Jamais négatif."""
+        if self._expires_at_monotonic is None:
+            return None
+        return max(0.0, self._expires_at_monotonic - time.monotonic())
+
+    def is_expired(self) -> bool:
+        if self._expires_at_monotonic is None:
+            return False
+        return time.monotonic() >= self._expires_at_monotonic
+
+    def as_sdk_timeout(self) -> float | None:
+        """Valeur à passer à un SDK comme ``timeout=`` (= ``remaining_seconds``)."""
+        return self.remaining_seconds()
+
+    def clamp_to_remaining(self, seconds: float) -> float:
+        """Retourne ``min(seconds, remaining_seconds())``.
+
+        Si infinie, retourne ``seconds`` tel quel. Utile pour borner le
+        backoff d'un retry qui ne doit pas dépasser le budget restant.
+        """
+        if seconds < 0:
+            raise CinocError(
+                f"Deadline.clamp_to_remaining : seconds doit être >= 0 "
+                f"(reçu {seconds})",
+            )
+        if self._expires_at_monotonic is None:
+            return seconds
+        remaining = self.remaining_seconds()
+        assert remaining is not None
+        return min(seconds, remaining)
+
+    # ── Sérialisation cross-process ──────────────────────────────────
+    #
+    # ``expires_at_monotonic`` n'a aucun sens dans un autre process. On
+    # sérialise via ``remaining_seconds`` (transposable) ; à la réception,
+    # on reconstruit relativement à l'horloge du process receveur.
+
+    def to_dict(self) -> dict[str, float | None]:
+        """Forme sérialisable JSON / IPC : ``{"remaining_seconds": …}``.
+        ``None`` = infinie."""
+        return {"remaining_seconds": self.remaining_seconds()}
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Deadline:
+        """Reconstruit une ``Deadline`` depuis sa forme sérialisée."""
+        if not isinstance(data, dict):
+            raise CinocError(
+                f"Deadline.from_dict : data doit être un dict, "
+                f"reçu {type(data).__name__}",
+            )
+        if "remaining_seconds" not in data:
+            raise CinocError(
+                "Deadline.from_dict : clé 'remaining_seconds' manquante.",
+            )
+        r = data["remaining_seconds"]
+        if r is None:
+            return cls.infinite()
+        if not isinstance(r, (int, float)):
+            raise CinocError(
+                "Deadline.from_dict : remaining_seconds doit être numérique "
+                f"ou None, reçu {type(r).__name__}",
+            )
+        if r <= 0:
+            # Reçue déjà expirée côté émetteur → on reconstruit expirée.
+            return cls.at_monotonic(time.monotonic())
+        return cls.in_seconds(float(r))
+
+    def __getstate__(self) -> dict[str, float | None]:
+        return self.to_dict()
+
+    def __setstate__(self, state: dict[str, float | None]) -> None:
+        r = state.get("remaining_seconds")
+        if r is None:
+            object.__setattr__(self, "_expires_at_monotonic", None)
+        elif r <= 0:
+            object.__setattr__(self, "_expires_at_monotonic", time.monotonic())
+        else:
+            object.__setattr__(
+                self, "_expires_at_monotonic", time.monotonic() + float(r),
+            )
+
+    # ── Dunder — immutabilité, égalité, repr ─────────────────────────
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        raise AttributeError(
+            f"Deadline est immuable — impossible d'assigner {name!r}",
+        )
+
+    def __delattr__(self, name: str) -> None:
+        raise AttributeError(
+            f"Deadline est immuable — impossible de supprimer {name!r}",
+        )
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Deadline):
+            return NotImplemented
+        # Égalité stricte sur l'instant d'expiration : deux
+        # ``in_seconds(60)`` créées à des instants différents ne sont PAS
+        # égales (l'égalité sur ``remaining_seconds`` serait instable).
+        return self._expires_at_monotonic == other._expires_at_monotonic
+
+    def __hash__(self) -> int:
+        return hash(self._expires_at_monotonic)
+
+    def __repr__(self) -> str:
+        if self._expires_at_monotonic is None:
+            return "Deadline.infinite()"
+        remaining = self.remaining_seconds()
+        if remaining is None or remaining <= 0.0:
+            return "Deadline(expired)"
+        return f"Deadline(remaining={remaining:.3f}s)"
+
+    # ── Compat Pydantic (utilisable comme type de champ) ─────────────
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls,
+        source_type: Any,  # noqa: ARG003
+        handler: GetCoreSchemaHandler,  # noqa: ARG003
+    ) -> core_schema.CoreSchema:
+        """Validation : instance ``Deadline`` (pass-through) ou dict
+        ``{"remaining_seconds": …}``. Sérialisation : ``to_dict()``."""
+
+        def _validate(value: Any) -> Deadline:
+            if isinstance(value, cls):
+                return value
+            if isinstance(value, dict):
+                return cls.from_dict(value)
+            raise ValueError(
+                "Deadline : impossible de valider une valeur de type "
+                f"{type(value).__name__} (attendu Deadline ou dict).",
+            )
+
+        return core_schema.no_info_plain_validator_function(
+            _validate,
+            serialization=core_schema.plain_serializer_function_ser_schema(
+                lambda d: d.to_dict(),
+            ),
+        )
+
+
+__all__ = ["Deadline"]
diff --git a/cinoc/domain/documents.py b/cinoc/domain/documents.py
new file mode 100644
index 0000000000000000000000000000000000000000..f9d7f40fc053a558c4788cc8071b91076baafb95
--- /dev/null
+++ b/cinoc/domain/documents.py
@@ -0,0 +1,114 @@
+"""``DocumentRef`` et ``GroundTruthRef``.
+
+Référence à un document du corpus + ses vérités terrain multi-niveaux.
+Ne porte pas le contenu : juste les chemins/URIs et les types. Le contenu
+est chargé à la demande par les adapters de format.
+"""
+
+from __future__ import annotations
+
+import re
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+from cinoc.domain.artifacts import ArtifactType
+
+# Identifiant de document : alphanum + ``_.-/`` (les ``/`` permettent les
+# hiérarchies type ``volA/folio_001``). Pas d'espaces, pas de caractères
+# de contrôle.
+_DOC_ID_RE = re.compile(r"^[A-Za-z0-9_.\-/]+$")
+
+
+class GroundTruthRef(BaseModel):
+    """Pointeur vers une vérité terrain pour un niveau donné.
+
+    Distinct du contenu : on charge le fichier à la demande via l'adapter
+    de format approprié.
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    type: ArtifactType
+    uri: str = Field(min_length=1, max_length=2048)
+
+
+class DocumentRef(BaseModel):
+    """Référence immuable à un document du corpus.
+
+    Attributs
+    ---------
+    id:
+        Identifiant unique dans le corpus (nom de fichier sans extension,
+        ou chemin relatif ``volA/folio_001``).
+    image_uri:
+        Chemin vers l'image source. ``None`` pour les documents purement
+        textuels.
+    ground_truths:
+        Vérités terrain disponibles, une par niveau (type unique).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    id: str = Field(min_length=1, max_length=256)
+    image_uri: str | None = Field(default=None, max_length=2048)
+    ground_truths: tuple[GroundTruthRef, ...] = Field(default_factory=tuple)
+    #: Métadonnées libres par document (analogue documentaire de
+    #: ``CorpusSpec.metadata``). Clé conventionnelle ``"stratum"`` = strate du
+    #: document (genre/période/écriture), si la source la fournit. Optionnel :
+    #: les consommateurs (composition, filtres, CER/strate) ne s'affichent que
+    #: si présent. Renseigné par les importeurs/corpus, jamais figé.
+    metadata: dict[str, str] = Field(default_factory=dict)
+
+    @field_validator("id")
+    @classmethod
+    def _validate_doc_id(cls, v: str) -> str:
+        if not _DOC_ID_RE.match(v):
+            from cinoc.domain.errors import CorpusSpecError
+
+            raise CorpusSpecError(
+                f"document id invalide : {v!r}. Doit matcher {_DOC_ID_RE.pattern!r}."
+            )
+        # Défense en profondeur path-traversal : un segment ``..`` ou un
+        # chemin absolu permettrait d'écrire hors workspace via la
+        # résolution de chemin en aval (``Path(root) / id`` est réinitialisé
+        # par un id absolu). Un doc_id légitime est toujours relatif.
+        if v.startswith("/") or ".." in v.split("/"):
+            from cinoc.domain.errors import CorpusSpecError
+
+            raise CorpusSpecError(
+                f"document id non relatif ou avec segment '..' : {v!r}. "
+                "Path traversal rejeté."
+            )
+        return v
+
+    @field_validator("ground_truths")
+    @classmethod
+    def _validate_unique_gt_types(
+        cls, v: tuple[GroundTruthRef, ...],
+    ) -> tuple[GroundTruthRef, ...]:
+        seen: set[ArtifactType] = set()
+        for gt in v:
+            if gt.type in seen:
+                from cinoc.domain.errors import CorpusSpecError
+
+                raise CorpusSpecError(
+                    f"GT dupliquée pour le type {gt.type.value!r}. "
+                    "Un document ne peut avoir qu'une seule GT par niveau."
+                )
+            seen.add(gt.type)
+        return v
+
+    def gt_for(self, artifact_type: ArtifactType) -> GroundTruthRef | None:
+        """Retourne la GT du niveau demandé, ou ``None``."""
+        for gt in self.ground_truths:
+            if gt.type == artifact_type:
+                return gt
+        return None
+
+    @property
+    def available_gt_types(self) -> tuple[ArtifactType, ...]:
+        """Niveaux de GT disponibles, dans l'ordre d'insertion."""
+        return tuple(gt.type for gt in self.ground_truths)
+
+
+__all__ = ["DocumentRef", "GroundTruthRef"]
diff --git a/cinoc/domain/errors.py b/cinoc/domain/errors.py
new file mode 100644
index 0000000000000000000000000000000000000000..2f3eb75e2e4cbbe260393f5a9d8f5dc16e7b810b
--- /dev/null
+++ b/cinoc/domain/errors.py
@@ -0,0 +1,94 @@
+"""Exceptions du domaine.
+
+Hiérarchie centrée sur ``CinocError`` : un caller peut attraper toute
+erreur métier Cinoc avec un seul ``except``.
+
+Règle : ne jamais attraper ``CinocError`` dans le code métier sans la
+re-lever — c'est le rôle de la couche transport (``app`` puis
+``interfaces``) de mapper ces erreurs vers HTTP 4xx / sortie CLI.
+
+Hiérarchie volontairement plate : on ajoute une sous-classe quand un
+caller a besoin de discriminer.
+"""
+
+from __future__ import annotations
+
+
+class CinocError(Exception):
+    """Racine de la hiérarchie d'erreurs métier de Cinoc."""
+
+
+class ArtifactValidationError(CinocError):
+    """Un artefact ne respecte pas les invariants de son type."""
+
+
+class ProjectionError(CinocError):
+    """Un projecteur ne peut pas convertir l'artefact source.
+
+    Le caller doit propager cette erreur dans le rapport de projection
+    plutôt que de l'absorber silencieusement.
+    """
+
+
+class CorpusSpecError(CinocError):
+    """Le ``CorpusSpec`` est mal formé (id dupliqués, GT incohérente…)."""
+
+
+class AdapterStepError(CinocError):
+    """Racine commune des erreurs d'adapter (OCR / LLM / VLM).
+
+    Permet à un caller (typiquement l'executor) d'attraper « toute
+    erreur d'adapter » sans connaître la sous-classe spécifique.
+    """
+
+
+class DeadlineExceeded(AdapterStepError):
+    """Un adapter a détecté l'expiration de la ``Deadline`` reçue.
+
+    Levée par un adapter qui respecte coopérativement la deadline
+    propagée. Distincte des autres ``AdapterStepError`` pour permettre au
+    runner de distinguer un timeout coopératif d'un échec fonctionnel.
+
+    Un adapter doit lever ``DeadlineExceeded`` quand :
+
+    - sa boucle interne détecte ``context.deadline.is_expired()`` avant
+      d'avoir fini ;
+    - son SDK lève un ``TimeoutError`` parce qu'on lui a passé
+      ``context.deadline.as_sdk_timeout()`` qui s'est déclenché
+      (l'adapter wrap et re-lève en ``DeadlineExceeded``).
+
+    Un adapter ne doit PAS lever ``DeadlineExceeded`` pour un timeout SDK
+    non lié à la deadline, ni pour une expiration côté serveur (504) →
+    ``AdapterStepError`` standard.
+    """
+
+
+class RunCancelledError(CinocError):
+    """Levée quand une cancellation coopérative a été signalée.
+
+    Distincte de ``DeadlineExceeded`` : la cancellation est un signal
+    explicite du caller (utilisateur, deadline globale du run), pas une
+    expiration de la deadline du document en cours.
+    """
+
+
+class FormatError(CinocError):
+    """Racine des erreurs de lecture/écriture d'un format documentaire.
+
+    Permet à un caller (chargeur de corpus, projecteur) d'attraper « toute
+    erreur de format » sans connaître le format précis. Les sous-classes
+    spécifiques (``AltoParseError``, ``PageParseError``) vivent dans leur
+    module de format (couche 2).
+    """
+
+
+__all__ = [
+    "CinocError",
+    "ArtifactValidationError",
+    "ProjectionError",
+    "CorpusSpecError",
+    "AdapterStepError",
+    "DeadlineExceeded",
+    "RunCancelledError",
+    "FormatError",
+]
diff --git a/cinoc/domain/evaluation.py b/cinoc/domain/evaluation.py
new file mode 100644
index 0000000000000000000000000000000000000000..d178b03ed45bb9b8d19ba6518c93708965ac397b
--- /dev/null
+++ b/cinoc/domain/evaluation.py
@@ -0,0 +1,111 @@
+"""``MetricSpec``, ``EvaluationView``, ``EvaluationSpec``.
+
+Comparer des pipelines hétérogènes en projetant leurs sorties vers une
+vue d'évaluation explicite. On ne compare jamais directement un OCR brut
+et une sortie ALTO reconstruite : on compare leur projection dans une vue
+commune, et le rapport explicite ce que la vue ignore.
+
+- ``MetricSpec`` — déclare une métrique (nom + signature de types).
+  **Purement déclaratif** : pas de callable. L'association nom → fonction
+  se fait dans le registre runtime (couche evaluation), pas ici.
+- ``EvaluationView`` — déclare une vue (candidats + projection + métriques
+  + dimensions ignorées).
+- ``EvaluationSpec`` — container de N vues.
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from cinoc.domain.artifacts import ArtifactType
+from cinoc.domain.projection import ProjectionSpec
+
+
+class MetricSpec(BaseModel):
+    """Description déclarative d'une métrique enregistrable.
+
+    Attributs
+    ---------
+    name:
+        Identifiant unique dans un registre.
+    input_types:
+        Tuple ``(reference_type, hypothesis_type)`` ; le registre
+        sélectionne les métriques applicables à une jonction par cette
+        signature.
+    higher_is_better:
+        ``True`` pour les métriques de qualité (F1, recall), ``False``
+        pour les métriques d'erreur (CER, WER).
+    tags:
+        Étiquettes libres pour grouper (``"text"``, ``"structure"``…).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    name: str = Field(min_length=1, max_length=128)
+    input_types: tuple[ArtifactType, ArtifactType]
+    description: str = ""
+    higher_is_better: bool = False
+    tags: frozenset[str] = Field(default_factory=frozenset)
+
+
+class EvaluationView(BaseModel):
+    """Une vue d'évaluation = une lentille pour comparer des pipelines.
+
+    Répond à : « lequel des pipelines produit la meilleure sortie sous cet
+    angle ? » Un pipeline ne produisant aucun artefact dans
+    ``candidate_types`` est omis explicitement (pas de score factice).
+
+    ``projection`` s'applique à tous les candidats ;
+    ``projections_by_source_type`` permet une projection conditionnelle
+    par type source. ``char_exclude`` filtre des caractères APRÈS
+    ``normalization_profile``. ``ignored_dimensions`` est affiché pour
+    signaler ce que la comparaison ne dit pas.
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    name: str = Field(min_length=1, max_length=128)
+    description: str = ""
+    candidate_types: frozenset[ArtifactType] = Field(...)
+    projection: ProjectionSpec | None = None
+    projections_by_source_type: dict[ArtifactType, ProjectionSpec] = Field(
+        default_factory=dict,
+    )
+    normalization_profile: str | None = Field(default=None, max_length=128)
+    char_exclude: str | None = Field(default=None, max_length=512)
+    metric_names: tuple[str, ...] = Field(default_factory=tuple)
+    ignored_dimensions: tuple[str, ...] = Field(default_factory=tuple)
+    warnings: tuple[str, ...] = Field(default_factory=tuple)
+
+    def accepts(self, artifact_type: ArtifactType) -> bool:
+        """Vrai si cette vue peut consommer un artefact du type donné."""
+        return artifact_type in self.candidate_types
+
+    def projection_for(
+        self, source_type: ArtifactType,
+    ) -> ProjectionSpec | None:
+        """Projection à appliquer pour un artefact source donné.
+
+        1. ``projections_by_source_type[source_type]`` si présent ;
+        2. ``projection`` si son ``source_type`` matche ;
+        3. ``None`` (artefact comparé tel quel).
+        """
+        if source_type in self.projections_by_source_type:
+            return self.projections_by_source_type[source_type]
+        if (
+            self.projection is not None
+            and self.projection.source_type == source_type
+        ):
+            return self.projection
+        return None
+
+
+class EvaluationSpec(BaseModel):
+    """Container de N ``EvaluationView`` qu'un benchmark applique."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    views: tuple[EvaluationView, ...] = Field(default_factory=tuple)
+
+
+__all__ = ["MetricSpec", "EvaluationView", "EvaluationSpec"]
diff --git a/cinoc/domain/layout.py b/cinoc/domain/layout.py
new file mode 100644
index 0000000000000000000000000000000000000000..efc7719421223af015ecb8b33bba53e25412d84a
--- /dev/null
+++ b/cinoc/domain/layout.py
@@ -0,0 +1,124 @@
+"""``CanonicalLayout`` — modèle de mise en page **neutre** (ALTO/PAGE unifiés).
+
+Payload de ``ArtifactType.LAYOUT``. Type **pivot** (axe 1, enveloppe) :
+dimensionné pour représenter *fidèlement* ALTO **et** PAGE — mots, géométrie
+(bbox + polygone), baseline, confiance, régions imbriquées, ordre de lecture —
+même si la tranche segmentation **ne remplit d'abord** que régions → lignes →
+texte (le reste arrive avec les mappers `alto/page → layout`, différés).
+
+Géométrie en `domain` (et non en `formats`) : un point/une boîte neutres sont du
+**vocabulaire transversal**, pas une spécificité de format. ``Point`` y est le
+même alias structurel que ``formats._geometry.Point`` (``tuple[int, int]``) — une
+coïncidence de forme, **pas** un shim (aucune conversion).
+
+Convention de coordonnées : pixels entiers, origine haut-gauche, *y* vers le bas
+(image). Valeurs négatives tolérées (une région peut déborder la page). La
+réconciliation d'unités/résolution est une affaire de couche 3.
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+_FROZEN = ConfigDict(frozen=True, extra="forbid")
+
+#: Point image : ``(x, y)`` en pixels entiers (origine haut-gauche).
+Point = tuple[int, int]
+
+
+class BBox(BaseModel):
+    """Boîte englobante axis-aligned (pixels)."""
+
+    model_config = _FROZEN
+    x: int
+    y: int
+    width: int
+    height: int
+
+
+class Geometry(BaseModel):
+    """Géométrie d'un élément : boîte et/ou polygone (au moins l'un)."""
+
+    model_config = _FROZEN
+    bbox: BBox | None = None
+    polygon: tuple[Point, ...] = ()
+
+
+class Word(BaseModel):
+    """Mot (granularité ALTO ``<String>`` ; absent de PAGE → tuple vide)."""
+
+    model_config = _FROZEN
+    text: str
+    geometry: Geometry | None = None
+    confidence: float | None = None
+
+
+class Line(BaseModel):
+    """Ligne de texte. ``text`` est le contenu reconnu ; ``words`` l'affine."""
+
+    model_config = _FROZEN
+    id: str | None = None
+    text: str = ""
+    geometry: Geometry | None = None
+    baseline: tuple[Point, ...] = ()
+    words: tuple[Word, ...] = ()
+    confidence: float | None = None
+
+
+class Region(BaseModel):
+    """Région de page (bloc). ``region_type`` = label neutre libre
+    (``"text"``/``"image"``/``"table"``…). ``regions`` porte l'imbrication
+    (ALTO ``ComposedBlock`` / PAGE régions imbriquées).
+
+    Une sortie de **segmentation** est une région **sans lignes** (``lines=()``) ;
+    la **reconnaissance** la remplit. C'est ce qui distingue « niveau structure
+    présent » de « niveau texte présent » (cf. métriques par bloc).
+    """
+
+    model_config = _FROZEN
+    id: str = Field(min_length=1, max_length=256)
+    region_type: str | None = Field(default=None, max_length=64)
+    geometry: Geometry | None = None
+    lines: tuple[Line, ...] = ()
+    regions: tuple[Region, ...] = ()
+
+
+class LayoutPage(BaseModel):
+    """Page : dimensions, régions de premier niveau, ordre de lecture.
+
+    ``reading_order`` = liste **plate** d'``id`` de région (parcours profondeur
+    d'abord côté PAGE) ; vide → ordre des ``regions``.
+    """
+
+    model_config = _FROZEN
+    width: int | None = None
+    height: int | None = None
+    regions: tuple[Region, ...] = ()
+    reading_order: tuple[str, ...] = ()
+
+
+class CanonicalLayout(BaseModel):
+    """Document de mise en page neutre : une ou plusieurs pages.
+
+    Le squelette segmentation remplit **une** page ; le multi-page est réservé
+    pour la fidélité ALTO/PAGE (documents multi-pages).
+    """
+
+    model_config = _FROZEN
+    pages: tuple[LayoutPage, ...] = ()
+
+
+Region.model_rebuild()
+LayoutPage.model_rebuild()
+CanonicalLayout.model_rebuild()
+
+__all__ = [
+    "BBox",
+    "CanonicalLayout",
+    "Geometry",
+    "Line",
+    "LayoutPage",
+    "Point",
+    "Region",
+    "Word",
+]
diff --git a/cinoc/domain/pipeline.py b/cinoc/domain/pipeline.py
new file mode 100644
index 0000000000000000000000000000000000000000..852560c54e01a0076ee19d01de6c6966660466f7
--- /dev/null
+++ b/cinoc/domain/pipeline.py
@@ -0,0 +1,146 @@
+"""``PipelineStep``, ``PipelineSpec``, ``PipelineMode``.
+
+Description purement déclarative d'un DAG de transformation documentaire.
+Sérialisable YAML, validable sans instancier les modules concrets.
+
+``PipelineStep`` ne porte qu'un ``adapter_name`` (str) ; le mapping
+nom → instance est maintenu par un service applicatif et résolu au moment
+de l'exécution, pas de la spec. Bénéfice : le YAML est versionnable
+indépendamment de l'environnement Python, et la validation s'exécute sans
+instancier aucun module.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+
+from cinoc.domain.artifacts import ArtifactType
+
+# Identifiant d'étape : alphanum + ``_-``. Nom court lisible dans les logs
+# et le rapport.
+_STEP_ID_RE = re.compile(r"^[A-Za-z0-9_\-]+$")
+
+#: Modes canoniques d'un pipeline OCR+LLM (source de vérité unique).
+#:
+#: - ``text_only`` — l'OCR amont produit un texte, le LLM le corrige sans
+#:   voir l'image.
+#: - ``text_and_image`` — le VLM corrige le texte en s'appuyant sur l'image.
+#: - ``zero_shot`` — pas d'OCR amont ; un VLM transcrit l'image directement.
+PipelineMode = Literal["text_only", "text_and_image", "zero_shot"]
+
+#: Sentinel pour ``inputs_from`` désignant les artefacts initiaux fournis
+#: au runner (typiquement ``IMAGE``).
+INITIAL_STEP_ID = "__initial__"
+
+
+class PipelineStep(BaseModel):
+    """Une étape déclarative dans un DAG de pipeline.
+
+    Attributs
+    ---------
+    id:
+        Identifiant unique dans la pipeline (alphanum + ``_-``).
+    kind:
+        Catégorie informationnelle (``"ocr"``, ``"segmentation"``,
+        ``"post_correction"``…). Label libre en ``snake_case``.
+    adapter_name:
+        Nom de l'adapter dans le registre runtime. Convention
+        ``"<provider>:<engine_or_model>"``.
+    params:
+        Paramètres passés à l'adapter (chaque adapter valide les siens).
+    input_types / output_types:
+        Types consommés / produits, validés contre les étapes voisines.
+    inputs_from:
+        DAG branchant : pour chaque type d'entrée, l'étape source.
+        ``"__initial__"`` désigne les entrées initiales du runner. Dict
+        vide → version la plus récente de chaque type.
+    fanout:
+        Si vrai, l'``adapter_name`` (un *reconnaisseur* de région) est exécuté
+        **une fois par région** du ``LAYOUT`` d'entrée, et ses sorties sont
+        réassemblées en un ``LAYOUT`` rempli (orchestration couche 4). Exige
+        ``LAYOUT`` + ``IMAGE`` en entrée et ``LAYOUT`` en sortie.
+    crop:
+        N'a de sens que sur une étape ``fanout``. Si vrai, chaque bloc est
+        **découpé** de l'image (OCR réel par région) ; sinon l'image page entière
+        est passée au reconnaisseur avec son ``region_id`` (cas ``precomputed`` :
+        la donnée par région est figée, aucun pixel n'est lu). Déclaratif : le
+        *planner* sait, selon le reconnaisseur choisi, s'il faut découper.
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    id: str = Field(min_length=1, max_length=128)
+    kind: str = Field(min_length=1, max_length=64)
+    adapter_name: str = Field(min_length=1, max_length=256)
+    params: dict[str, str | int | float | bool] = Field(default_factory=dict)
+    input_types: tuple[ArtifactType, ...] = Field(default_factory=tuple)
+    output_types: tuple[ArtifactType, ...] = Field(default_factory=tuple)
+    inputs_from: dict[ArtifactType, str] = Field(default_factory=dict)
+    fanout: bool = False
+    crop: bool = False
+
+    @model_validator(mode="after")
+    def _check_fanout_contract(self) -> PipelineStep:
+        if self.fanout:
+            from cinoc.domain.errors import CinocError
+
+            needed = {ArtifactType.LAYOUT, ArtifactType.IMAGE}
+            if not needed.issubset(self.input_types):
+                raise CinocError(
+                    f"step {self.id!r} : fanout=True exige LAYOUT et IMAGE en "
+                    f"input_types (reçu {[t.value for t in self.input_types]})."
+                )
+            if ArtifactType.LAYOUT not in self.output_types:
+                raise CinocError(
+                    f"step {self.id!r} : fanout=True exige LAYOUT en output_types."
+                )
+        return self
+
+    @field_validator("id")
+    @classmethod
+    def _validate_step_id(cls, v: str) -> str:
+        if not _STEP_ID_RE.match(v):
+            from cinoc.domain.errors import CinocError
+
+            raise CinocError(
+                f"step id invalide : {v!r}. Doit matcher {_STEP_ID_RE.pattern!r} "
+                "(alphanum + _-)."
+            )
+        if v == INITIAL_STEP_ID:
+            from cinoc.domain.errors import CinocError
+
+            raise CinocError(
+                f"step id réservé : {INITIAL_STEP_ID!r} désigne les entrées "
+                "initiales du runner."
+            )
+        return v
+
+
+class PipelineSpec(BaseModel):
+    """DAG déclaratif d'une pipeline composée.
+
+    Sérialisable via ``model_dump()`` + ``yaml.safe_dump``, chargeable via
+    ``model_validate(yaml.safe_load(text))``.
+
+    ``steps`` est ordonné par dépendance topologique : si ``s2`` dépend de
+    ``s1``, alors ``s1`` apparaît avant ``s2``.
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    name: str = Field(min_length=1, max_length=128)
+    description: str = ""
+    initial_inputs: tuple[ArtifactType, ...] = Field(default_factory=tuple)
+    steps: tuple[PipelineStep, ...] = Field(default_factory=tuple)
+
+    def step_by_id(self, step_id: str) -> PipelineStep | None:
+        for s in self.steps:
+            if s.id == step_id:
+                return s
+        return None
+
+
+__all__ = ["PipelineMode", "PipelineSpec", "PipelineStep", "INITIAL_STEP_ID"]
diff --git a/cinoc/domain/projection.py b/cinoc/domain/projection.py
new file mode 100644
index 0000000000000000000000000000000000000000..360f30fef53e7d460e260bac07198f3166f8e909
--- /dev/null
+++ b/cinoc/domain/projection.py
@@ -0,0 +1,44 @@
+"""``ProjectionSpec`` — déclaration d'une projection entre types d'artefacts.
+
+Documente la conversion d'un type vers un autre (ex. ``ALTO_XML`` →
+``RAW_TEXT``). Ne contient pas la logique du projecteur (qui vit en
+``evaluation/projectors``) : permet à une vue de référencer une
+projection par nom dans un YAML, sans coupler à une implémentation.
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from cinoc.domain.artifacts import ArtifactType
+
+
+class ProjectionSpec(BaseModel):
+    """Spec déclarative d'une projection entre deux types d'artefacts.
+
+    Attributs
+    ---------
+    source_type / target_type:
+        Types en entrée / sortie du projecteur. Peuvent être identiques
+        (projection identité).
+    projector_name:
+        Identifiant du projecteur dans le registre runtime. Convention :
+        ``"<source>_to_<target>"`` (ex. ``"alto_to_text"``).
+    params:
+        Paramètres passés au projecteur (validés par lui-même).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    source_type: ArtifactType
+    target_type: ArtifactType
+    projector_name: str = Field(min_length=1, max_length=128)
+    params: dict[str, str | int | float | bool] = Field(default_factory=dict)
+
+    @property
+    def is_identity(self) -> bool:
+        """Vrai si ``source_type == target_type``."""
+        return self.source_type == self.target_type
+
+
+__all__ = ["ProjectionSpec"]
diff --git a/cinoc/domain/provenance.py b/cinoc/domain/provenance.py
new file mode 100644
index 0000000000000000000000000000000000000000..7502b46eb8667fd5c1023af23d176d5352c0c37e
--- /dev/null
+++ b/cinoc/domain/provenance.py
@@ -0,0 +1,52 @@
+"""Provenance d'un artefact.
+
+Empreinte minimale attachée à chaque ``Artifact`` produit par une étape
+de pipeline. Permet la reproductibilité : même corpus + même
+``code_version`` + même ``parameters_hash`` = mêmes artefacts à hash près.
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ProvenanceRecord(BaseModel):
+    """Empreinte de production d'un artefact.
+
+    Immuable : pour modifier une provenance, on crée un nouvel artefact.
+
+    Attributs
+    ---------
+    timestamp:
+        Date/heure UTC de production (défaut : maintenant).
+    code_version:
+        Version du code qui a produit l'artefact. Str opaque.
+    parameters_hash:
+        Hash SHA-256 hex des paramètres de l'étape. ``None`` autorisé
+        pour les artefacts initiaux (image fournie, GT lue).
+    """
+
+    model_config = ConfigDict(frozen=True)
+
+    timestamp: datetime = Field(
+        default_factory=lambda: datetime.now(tz=UTC),
+    )
+    code_version: str
+    parameters_hash: str | None = None
+
+    def is_compatible_with(self, other: ProvenanceRecord) -> bool:
+        """Deux artefacts produits par le même contexte de calcul.
+
+        Le timestamp n'entre pas dans la comparaison — seule la
+        combinaison ``(code_version, parameters_hash)`` détermine la
+        compatibilité de cache.
+        """
+        return (
+            self.code_version == other.code_version
+            and self.parameters_hash == other.parameters_hash
+        )
+
+
+__all__ = ["ProvenanceRecord"]
diff --git a/cinoc/domain/run.py b/cinoc/domain/run.py
new file mode 100644
index 0000000000000000000000000000000000000000..310b8b3eeedf1aa0fe93e3706921831209470d36
--- /dev/null
+++ b/cinoc/domain/run.py
@@ -0,0 +1,83 @@
+"""``RunManifest`` — empreinte immuable d'un run de benchmark.
+
+Source de vérité d'un run : quoi (corpus + pipelines + vues), avec quelle
+version du code, quand, et avec quelles dépendances. Sérialisé en
+``run_manifest.json`` ; combiné aux JSONL de résultats, il permet de
+reconstituer un run sans objets Python live.
+
+Garantie de reproductibilité : à ``code_version`` + ``pipeline_specs`` +
+``view_specs`` + ``dependencies_lock`` + ``system_binaries_lock``
+identiques, ré-exécuter donne les mêmes résultats (au déterminisme près
+des adapters externes).
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from cinoc.domain.evaluation import EvaluationView
+from cinoc.domain.pipeline import PipelineSpec
+
+
+class RunManifest(BaseModel):
+    """Empreinte immuable d'un run de benchmark.
+
+    ``started_at`` / ``completed_at`` capturent le wall-clock du run mais
+    n'entrent pas dans les comparaisons de reproductibilité.
+
+    Attributs
+    ---------
+    run_id:
+        Identifiant unique, filesystem-safe.
+    corpus_name / n_documents:
+        Corpus traité.
+    pipeline_specs:
+        Specs complètes des pipelines (steps, params, inputs_from…),
+        incluses intégralement pour reproductibilité.
+    adapter_kwargs:
+        ``{adapter_name: kwargs}`` capturés. Les valeurs sensibles
+        (api_key) n'y figurent pas — elles viennent de l'environnement.
+    view_specs:
+        Vues d'évaluation appliquées.
+    code_version:
+        Version du code.
+    dependencies_lock / system_binaries_lock:
+        Snapshots ``{paquet: version}`` et ``{binaire: version}`` —
+        indispensables à la reproductibilité.
+    module_versions:
+        ``{adapter_name: module.version}`` — version déclarée de chaque
+        module exécuté (R-2). La version *binaire* d'un moteur externe
+        (tesseract…) relève de ``system_binaries_lock`` (capture live).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    run_id: str = Field(min_length=1, max_length=256)
+    corpus_name: str = Field(min_length=1, max_length=128)
+    n_documents: int = Field(ge=0)
+    pipeline_specs: tuple[PipelineSpec, ...] = Field(default_factory=tuple)
+    adapter_kwargs: dict[str, dict[str, Any]] = Field(default_factory=dict)
+    view_specs: tuple[EvaluationView, ...] = Field(default_factory=tuple)
+    code_version: str = Field(min_length=1, max_length=128)
+    started_at: datetime
+    completed_at: datetime
+    dependencies_lock: dict[str, str] = Field(default_factory=dict)
+    system_binaries_lock: dict[str, str] = Field(default_factory=dict)
+    module_versions: dict[str, str] = Field(default_factory=dict)
+    metadata: dict[str, str] = Field(default_factory=dict)
+
+    @property
+    def duration_seconds(self) -> float:
+        """Durée wall-clock du run en secondes."""
+        return (self.completed_at - self.started_at).total_seconds()
+
+
+def utcnow() -> datetime:
+    """Timestamp UTC (utile pour les fixtures)."""
+    return datetime.now(tz=UTC)
+
+
+__all__ = ["RunManifest", "utcnow"]
diff --git a/cinoc/domain/run_spec.py b/cinoc/domain/run_spec.py
new file mode 100644
index 0000000000000000000000000000000000000000..494fea2f50e84acd13120cf7bdd0a8314d31538d
--- /dev/null
+++ b/cinoc/domain/run_spec.py
@@ -0,0 +1,37 @@
+"""``RunSpec`` — description déclarative complète d'un run.
+
+Compose les types déclaratifs du domaine (corpus + pipelines + vues) en **une**
+entrée auto-suffisante : un run est entièrement décrit par son ``RunSpec`` (+ le
+``code_version``). **Pas de ``StepSpec`` distinct** — ``PipelineStep`` (déjà en
+domain) est l'étape déclarative ; en introduire un second serait une 2ᵉ
+représentation de pipeline (la dette qu'on abandonne, cf. journal D-010).
+
+``adapter_kwargs`` (``adapter_name → kwargs de construction``) alimente la
+factory de modules **et** le ``RunManifest`` (reproductibilité).
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from cinoc.domain.corpus import CorpusSpec
+from cinoc.domain.evaluation import EvaluationSpec
+from cinoc.domain.pipeline import PipelineSpec
+
+
+class RunSpec(BaseModel):
+    """Ce qu'il faut exécuter : corpus, pipelines candidats, vues d'évaluation."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    corpus: CorpusSpec
+    pipelines: tuple[PipelineSpec, ...] = Field(min_length=1)
+    evaluation: EvaluationSpec
+    adapter_kwargs: dict[str, dict[str, str | int | float | bool]] = Field(
+        default_factory=dict
+    )
+    run_id: str | None = Field(default=None, max_length=256)
+    metadata: dict[str, str] = Field(default_factory=dict)
+
+
+__all__ = ["RunSpec"]
diff --git a/cinoc/domain/usage.py b/cinoc/domain/usage.py
new file mode 100644
index 0000000000000000000000000000000000000000..746ac457baa472b7f7b3e2d7b2c8aef7dbfbe712
--- /dev/null
+++ b/cinoc/domain/usage.py
@@ -0,0 +1,52 @@
+"""``ResourceUsage`` — consommation mesurée d'une exécution (couche 1).
+
+Vocabulaire transversal : la couche 4 (exécuteur) mesure la durée et collecte
+les jetons remontés par les modules LLM/VLM ; la couche 3 (``RunResult``) porte
+l'agrégat par (pipeline × document). Les durées sont du **wall-clock** : comme
+les horodatages du ``RunManifest``, elles sont une mesure d'environnement,
+exclues de l'identité des artefacts (déterminisme — voir ``ProvenanceRecord``).
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+def _add(a: int | None, b: int | None) -> int | None:
+    if a is None and b is None:
+        return None
+    return (a or 0) + (b or 0)
+
+
+class ResourceUsage(BaseModel):
+    """Durée et jetons consommés. ``None`` = non mesuré / non applicable."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    #: Durée wall-clock en secondes (mesurée par l'exécuteur, jamais par le
+    #: module — source unique).
+    duration_seconds: float | None = Field(default=None, ge=0)
+    #: Jetons d'entrée/sortie d'un appel LLM/VLM (remontés par l'adapter quand
+    #: le fournisseur les expose ; ``None`` pour un moteur non facturé au jeton).
+    tokens_in: int | None = Field(default=None, ge=0)
+    tokens_out: int | None = Field(default=None, ge=0)
+
+    def merged_with(self, other: ResourceUsage | None) -> ResourceUsage:
+        """Somme champ à champ (``None``-tolérante) — agrégation par document."""
+        if other is None:
+            return self
+        duration: float | None
+        if self.duration_seconds is None and other.duration_seconds is None:
+            duration = None
+        else:
+            duration = (self.duration_seconds or 0.0) + (
+                other.duration_seconds or 0.0
+            )
+        return ResourceUsage(
+            duration_seconds=duration,
+            tokens_in=_add(self.tokens_in, other.tokens_in),
+            tokens_out=_add(self.tokens_out, other.tokens_out),
+        )
+
+
+__all__ = ["ResourceUsage"]
diff --git a/cinoc/evaluation/ANALYSE_ETAPE_4.md b/cinoc/evaluation/ANALYSE_ETAPE_4.md
new file mode 100644
index 0000000000000000000000000000000000000000..6a927adea564d72e8aa02d063de0c84aa9d1ce2a
--- /dev/null
+++ b/cinoc/evaluation/ANALYSE_ETAPE_4.md
@@ -0,0 +1,486 @@
+# ANALYSE Étape 4 — familles de métriques restantes (4a→4f)
+
+> **Session d'ANALYSE** (CLAUDE.md §9) — aucun code produit. Guide de portage
+> pour les tranches de construction de l'**Étape 4 de `PLAN_FIN_MIGRATION.md`**.
+> - **Partie 1 (analyse source Picarones)** : **durable** — Picarones est gelé,
+>   ces faits ne périment pas. Tout est **vérifié dans le code** (`fichier:ligne`,
+>   chemins relatifs à `../Picarones/picarones/`).
+> - **Partie 2 (cible Cinoc)** : **périssable**, chaque verdict est
+>   **PROVISOIRE — à confirmer au build**. Le contact du code prévaut.
+>
+> Lu avant rédaction : `CLAUDE.md` (entier), `PLAN_FIN_MIGRATION.md` §Étape 4,
+> `cinoc/evaluation/MIGRATION_COUCHE_3.md`, `MIGRATION_PLAN.md` (roll-up +
+> D-066→D-093), code mergé (`result.py`, `analysis.py`, `metric.py`, `runner.py`,
+> `metrics/*`, `reports/sections/*`, glossaire).
+>
+> **Amendé le 2026-06-11 (réconciliation HIPE — arbitrage « plan A »)** : la
+> famille **4g — bilan de correction & conformité HIPE**
+> ([`SPEC_HIPE.md`](../../SPEC_HIPE.md) v1.2) s'insère dans l'Étape 4 **avant la
+> 1.0** ; `over_normalization` (4c) et `error_absorption` (4e) y sont déplacés ;
+> `readability` (4a) est abandonné ; 4b gagne `hcpr`/`air` ; NER gagne la
+> réparation R14. Détail : §0 (C9-C10), bloc « Arbitrages actés », §4g, §Ordre.
+> `PLAN_FIN_MIGRATION.md` n'est pas modifié ici — réconciliation au 1ᵉʳ commit 4g
+> (rituel roll-up + journal D-0xx).
+>
+> **Vérifié contre `main` post D-094→D-114 (même jour)** : aucune contradiction —
+> `evaluation/metrics/` et `formats/text/` intacts, décisions UI/rapport
+> orthogonales, pas de collision de `kind` (un 6ᵉ payload `document_texts` est
+> arrivé, D-113). Renommage : **l'Étape 4 s'appelle désormais P2** (« ex-étape
+> 4 », D-109 — parallélisable après P0, qui est livrée). Mises à jour induites :
+> folds → strates (arbitrage n°7) ; **synergie P3** : le schéma GT du dataset
+> curé (D-109) se conçoit en lisant CE guide (entités `.gt.entities.json` pour
+> 4f, layout, strates, images pour 4d).
+
+---
+
+## 0. Corrections au plan — faits vérifiés qui contredisent une croyance écrite
+
+À lire en premier : la table Étape 4 et le prompt de session portent quelques
+croyances périmées ou imprécises. **Aucune ne renverse une décision actée**, mais
+les tranches doivent travailler sur les faits ci-dessous, pas sur la légende.
+
+| # | Croyance écrite | Fait vérifié | Preuve |
+|---|---|---|---|
+| C1 | 4e : « alignement ligne-à-ligne par `split('\n')` réputé fragile, à fiabiliser » | **Déjà fiabilisé à la source** (audit F15) : lignes alignées par `Levenshtein.opcodes` sur les listes de lignes AVANT le CER par ligne ; ligne GT supprimée → CER 1.0 ; lignes hyp en trop ignorées. Limite résiduelle : fusion/scission de lignes approximée (1 substitution + 1 délétion). | `metrics/line_metrics.py:191-205` |
+| C2 | « `incremental_comparison.py` = raffinement change-point » (prompt de session) | **Faux** : c'est une **comparaison d'effet isolé par slot de pipeline** (type Latin square, pensée pour 180 pipelines = 5 OCR × 3 × 4 × 3). Aucun rapport avec le change-point. Absent de la table « Verdict métrique-par-métrique » du plan (ni gardé ni abandonné). | `metrics/incremental_comparison.py:1-30` |
+| C3 | « `image_predictive` = stub sans implémentation » (PLAN_FIN_MIGRATION §Abandons #2) | **Pas un stub** : implémentation complète d'une pondération **éditoriale** (0.30·bruit + 0.30·(1−netteté) + 0.20·(1−contraste) + 0.20·|rot|/30) → « complexité paléographique » + « homogénéité corpus ». La docstring assume : « Pas de prédiction CER absolue ». **L'abandon reste justifié**, motif corrigé : aucune info nouvelle vs `image_quality` (simple re-pondération), nom mensonger, moitié « homogénéité » couplée au détecteur narratif `stratification_recommended` (supprimé). | `metrics/image_predictive.py:1-40` ; consommateurs : CLI `diagnose` (`interfaces/cli/_workflows.py:650`) + `reports/html/views/diagnostics.py:144-151` |
+| C4 | 4c inclut `equivalence_profile` dans la famille unifiée | **Mort en production** : zéro consommateur hors tests (seules mentions = docstrings). Converge avec `MIGRATION_COUCHE_3.md` §11 qui le classait déjà « morts ». Sa fonction (CER sous équivalences choisies) est couverte côté Cinoc par les profils de normalisation couche 2 + preview YAML custom (D-089). → **abandon recommandé**, cf. §4c. | grep complet : seuls hits = docstring `lexical_modernization.py:56` + doc `metrics/__init__.py:35` |
+| C5 | « roman compté deux fois » situé vaguement (le prompt suggérait `early_modern_typography`) | Le doublon est **`numerical_sequences` (catégorie `roman`, `min_length=2`) × `philological_hooks` (module `roman_numerals`, 5 statuts, `min_length=1` par défaut)**. `early_modern_typography.py` ne touche **pas** aux romains (zéro hit). Aggravant : les deux comptages utilisent des `min_length` **différents** → deux sections du même rapport peuvent donner des comptes différents pour le même texte. | `metrics/numerical_sequences.py:163` (`min_length=2`) ; `metrics/philological_hooks.py:94` (appel sans `min_length` → défaut 1, `roman_numerals.py:322`) |
+| C6 | — (non documenté au plan) | **Bug de clés fantômes #1 (NER)** : l'agrégateur écrit `total_hallucinated`/`total_missed`, le renderer lit `hallucinated_total`/`missed_total` → zéros affichés en silence ; le test du renderer fixture les clés fantômes (couverture mensongère). | `app/services/_benchmark_ner.py:180-181` vs `reports/html/renderers/ner.py:92-93` |
+| C7 | — (non documenté au plan) | **Bug de clés fantômes #2 (over_normalization)** : le hook produit `{score, total_correct_ocr_words, over_normalized_count}`, le renderer lit `{modernization_rate, preserved_archaic_count, lost_archaic_count}` → la vue rend des zéros. | `metrics/over_normalization.py:76-82` vs `reports/html/renderers/over_normalization.py:69,85-86` |
+| C8 | 4d : « `robustness.py` à la racine d'`evaluation/` » | Vit en réalité dans `metrics/robustness.py` (581 LOC). Le re-OCR n'importe **pas** d'adapter : moteur **injecté** par duck typing (`OCREngine = Any`), déclenché par la CLI dédiée `picarones robustness`. | `metrics/robustness.py:40,340-376` ; `interfaces/cli/_robustness.py:23-191` |
+| C9 *(2026-06-11)* | v1 de ce guide : « le matching NER est solide » | L'algorithme d'appariement est correct en interne, mais l'IoU compare des spans de **deux systèmes de coordonnées différents** : entités or = offsets sur le texte **GT**, entités hypothèse = offsets sur le texte **OCR** (`entity_extractor(dr.hypothesis)`), et `ner.py` n'utilise jamais le champ `text` pour apparier. Toute insertion/délétion amont décale les offsets aval → une entité **parfaitement transcrite** est comptée « manquée + hallucinée » dès que le drift dépasse sa longueur. Le F1 mesure en partie le profil ins/del du moteur, pas la préservation des entités. → réparation **R14** (4f). | `app/services/_benchmark_ner.py:92-97` ; `evaluation/metrics/ner.py:122-175` |
+| C10 *(2026-06-11)* | docstring source : searchability suit « la convention Elastic `fuzziness: AUTO` » | Le code applique distance ≤ 2 **uniforme à toutes les longueurs** (l'AUTO d'Elastic réserve 2 aux mots ≥ 6 : 0 si < 3, 1 si 3-5) — Cinoc a hérité du 2 plat (`_SEARCH_MAX_DISTANCE = 2`) + appariement glouton « premier non utilisé ». Effet plafond sur les mots courts (≤ 4 caractères : quasi toujours « retrouvables ») → différences entre moteurs écrasées. Durcissement **pré-1.0** acté (SPEC_HIPE §10). | `cinoc/evaluation/metrics/diagnostics.py:26,45-61` |
+
+> **Leçon transverse C6/C7** : les deux bugs « clés fantômes » sont
+> l'impossibilité structurelle que Cinoc élimine **par construction** — payloads
+> Pydantic `frozen, extra="forbid"` typés, sections qui lisent les **champs** du
+> payload (pas des clés de dict). C'est l'argument de fond du canal `analyses`.
+
+---
+
+# PARTIE 1 — ANALYSE SOURCE PICARONES (durable)
+
+## Mécanique d'enregistrement commune (contexte pour toutes les familles)
+
+Picarones empile 3 mécanismes (la « fragmentation » dénoncée par le plan) :
+
+1. **Registre typé** `@register_metric(name=…)` (`metric_registry`) — scalaires
+   par jonction `(TEXT, TEXT)` / `(ENTITIES, ENTITIES)`.
+2. **Hooks runner** `@register_document_metric(attribute=…)` /
+   `@register_corpus_aggregator(attribute=…)` (`metric_hooks`, câblés dans
+   `metrics/builtin_hooks.py`) — résultats **dict** posés comme attributs de
+   `DocumentResult` / `EngineReport`, activés par profils
+   (`_STANDARD_PROFILES = standard, philological, diagnostics, full`).
+3. **Appel direct hors runner** — la couche `reports/html/{data,views,renderers}`
+   ou la CLI calcule elle-même (rare_tokens, inter_engine, worst_lines,
+   longitudinal, robustness…). C'est l'anti-pattern « data-layer qui ré-agrège »
+   (CLAUDE.md §8.3).
+
+Cinoc remplace tout par : **scalaires** = `DocumentMetric` (`Observation`) dans
+le registre type-driven ; **non-scalaire** = collecteur/fonction d'analyse →
+payload `RunResult.analyses` ; **rapport** = section qui lit. Aucun hook.
+
+---
+
+## 4a — Données structurées & lisibilité
+
+### Fichiers et verdicts
+
+| Fichier (LOC) | Rôle vérifié | Verdict (PROVISOIRE — à confirmer au build) |
+|---|---|---|
+| `metrics/numerical_sequences.py` (424) | Détecte 5 catégories de séquences en GT et vérifie leur restitution : années arabes, romains (délégué), foliotation, montants, années régnales. 2 scores par catégorie + globaux : **strict** (forme exacte) / **value** (équivalent numérique). | **GARDER** — 🔶 retirer la catégorie `roman` (résolution doublon C5, propriété transférée à 4b) ; le régnal continue d'utiliser `roman_to_int` comme **helper** (pas un comptage). |
+| `metrics/numerical_sequences_hooks.py` (102) | Adaptatif (GT sans séquence → `None`) + agrégateur corpus (recalcule les scores micro, cap `lost_items` à 50/catégorie). | **SUPPRIMER** (plomberie hooks) — la logique adaptative/micro passe dans la métrique + le payload Cinoc. |
+| `metrics/readability.py` (252) | Flesch [0,100] borné + **delta** GT↔hyp ; syllabes = groupes de voyelles consécutives (`aeiouyàâäéèêëîïôöùûüÿæœ`), mot sans voyelle = 1 ; phrases = split `[.!?…]`, min 1. | **NE PAS PORTER** — arbitré 2026-06-11 (cf. §Abandons) : construct hors domaine de validité sur de l'OCR à ponctuation abîmée (le compte de phrases s'effondre → deltas parasites) ; ce qu'il détecte est mesuré directement par `lexical_modernization`/4g.2/`hcpr`-`air`. L'analyse des formules ci-dessous reste documentée (durable). |
+| `metrics/readability_hooks.py` (114) | Adaptatif (≥ 5 mots GT, `_MIN_WORDS_FOR_FLESCH = 5`) ; agrégat mean/median/min/max + comptage over/under-normalisés au seuil **±5**. | **SUPPRIMER** (plomberie) — seuils ±5 et minimum 5 mots repris dans la cible. |
+| `metrics/roman_numerals.py` (480) | Parser/validateur romain complet : normalisation casse + `j` médiéval final (`ij`→`II`), parsing soustractif strict, rejet des formes absurdes (`IIIII`, `VV`, paires soustractives illégales) ; détection regex `\b[IVXLCDMivxlcdmj]+\b` + validation ; classification en **5 statuts** (`strict_preserved`, `case_changed`, `j_dropped`, `converted_to_arabic`, `lost` ; `VALUE_PRESERVING = les 4 premiers`). 480 LOC justifiées (validation anti-faux-positifs + j médiéval). | **GARDER** (le parser) — **propriété transférée à la famille 4b** (un seul comptage). |
+
+### Formules & constantes décisives (vérifiées)
+
+- **Années arabes** : `\b(1[0-9]{3}|20[0-9]{2})\b` (bornes 1000–2099, frontière de mot).
+- **Foliotation** : `\b(?:fol\.?|f\.|pp\.|p\.|n\.°|n°)\s*(\d+(?:\s*-\s*\d+)?)\s*([rvRV])?` ;
+  clé normalisée `{nums}{r|v}` — **r/v non interchangeables** (recto/verso).
+- **Montants** : nombres + unité dans `livres?|sols?|deniers?|écus?|florins?|francs?|l\.|s\.|d\.|£|€|₣`
+  (insensible casse), unité canonisée par table interne.
+- **Régnal** : `\b(?:l['']\s*)?an\s+(?:de\s+(?:grâce|la\s+R[eé]publique)\s+)?([IVXLCDMivxlcdm]+|\d{1,4})\b` ;
+  valeur via `roman_to_int` ou `int`.
+- **Scores** : `strict_score = n_strict/n_total`, `value_score = n_value/n_total`
+  ∈ [0,1] ; **`None` si `n_total == 0`** (« Classe B » — document non applicable,
+  exclu de l'agrégat, jamais un 0 silencieux).
+- **Flesch** (`readability.py:64-67`) :
+  `score = clamp(base − k_mots·(W/P) − k_syll·(S/W), 0, 100)` avec
+  **FR = (207.0, 1.015, 73.6)** (Kandel-Moles 1958) et
+  **EN = (206.835, 1.015, 84.6)** (Flesch 1948).
+  `flesch_delta = score(hyp) − score(ref)` ∈ [−100, +100].
+  Lecture : Δ > +5 = sur-normalisation (lissage LLM) ; Δ < −5 = dégradation OCR.
+
+### Enregistrement & consommateurs (hors tests)
+
+- Scalaires registre : `numerical_sequence_strict_score`/`_value_score`
+  (`numerical_sequences.py:389-416`), `flesch_delta_fr`/`_en`
+  (`readability.py:215-242`), `roman_numeral_strict_score`/`_value_score`
+  (`roman_numerals.py:432-462`).
+- Hooks : `builtin_hooks.py:265-283` (doc) + `:564-587` (corpus), attributs
+  `numerical_sequence_metrics`/`aggregated_numerical_sequences`,
+  `readability_metrics`/`aggregated_readability`.
+- Renderers : `reports/html/renderers/numerical_sequences.py` (table moteur ×
+  5 catégories, intégrée à la vue diagnostics composite
+  `engines_diagnostics.py:130-137`) ; `renderers/readability.py` — **legacy
+  seulement** (template `view_analyses.html`, hors vue composite) ;
+  `renderers/philological.py:473-544` (section romaine 5 statuts).
+- Aucun export CSV/CLI dédié.
+
+### Bugs/silences/fragilités source
+
+- Doublon roman + `min_length` divergent (C5).
+- Faux positifs assumés : formes verbales rares non couvertes (« mil cinq
+  cens ») ; regex volontairement conservatrices (c'est le bon biais : la
+  précision prime sur le rappel pour une métrique de restitution).
+- Aucun non-déterminisme. Divisions par zéro protégées partout.
+
+---
+
+## 4b — Philologie étendue
+
+### Fichiers et verdicts
+
+| Fichier (LOC) | Rôle vérifié | Verdict (PROVISOIRE) |
+|---|---|---|
+| `metrics/abbreviations.py` (352) | Abréviations scribales médiévales (Capelli/MUFI) : table de **12 signes** → expansions (`ꝑ→per/par`, `ꝓ→pro`, `ꝗ→qui`, `ꝙ→quia`, `ꝯ→us/con`, `⁊→et`, `ꝝ→rum`, `ꝫ→et`, `ꝭ→is`, `p̃→par/per`, `q̃→que/qui`, `ñ→an/en`). Détection NFD (lettre + U+0303 ou caractère dédié). 2 scores : **strict** (forme abrégée présente verbatim) / **expansion** (abrégée OU développée). | **GARDER** — 🔶 table → donnée (YAML package-data) ; durcir la recherche d'expansion (frontière de mot seulement si ≤ 2 lettres → `per` matche dans « permettre », imprécision documentée à corriger). |
+| `metrics/early_modern_typography.py` (345) | Marqueurs typographiques de l'imprimé ancien, **5 catégories** : `ligatures` (fffiflffifflſtst), `long_s` (ſ), `dotless_i` (ı), `ampersand` (&), `nasal_tildes` (ãñõũẽĩ + décomposés). **Sémantique positionnelle** : marqueur « préservé » si toutes ses positions GT tombent dans un opcode `equal` de `Levenshtein.opcodes(ref, hyp)` (cohérent CER, audit F4/F14). | **GARDER** — tables → donnée ; conserver la sémantique positionnelle (≠ containment). |
+| `metrics/modern_archives.py` (601) | Abréviations/marqueurs des archives XIXᵉ-XXᵉ : **9 catégories, ~73 entrées** (civilités `Mme/Mgr/S.A.R.…`, ordinaux exposants `1ᵉʳ/XIXᵉ…`, monnaies `₶/₣/ƒ/£/l./s./d.`, administratif `arr./dép.…`, état civil `°/†/✶/⚭/ép./vve`, ponctuation typographique `«»—–…''`, latin moderne `e.g./i.e./etc./cf./ibid.…`, bibliographique `vol./t./p./n°/r°/v°…`, adresse `bd/av./r.…`). Frontières regex différenciées (alphabétique vs point final vs Unicode pur, `:268-269`), greedy « plus long gagne » sans chevauchement. Scores strict/expansion par catégorie + globaux. | **GARDER** — 🔶 **les 9 tables (≈ 60 % du fichier) sortent en donnée YAML** (résout le budget : 601 LOC → moteur ≈ 200) ; sémantique containment strict/expansion conservée. |
+| `metrics/philological_hooks.py` (363) | Orchestrateur « adaptatif » des **6 modules** philologiques (`unicode_blocks`, `abbreviations`, `mufi`, `early_modern`, `modern_archives`, `roman_numerals`) : calcule chacun, ne retient que ceux dont la GT porte du signal (`n_*_reference > 0`), agrège par module au corpus. ⚠️ `try/except Exception` par module (warning puis continue, `:122-128`). | **SUPPRIMER** (plomberie hooks) — l'adaptativité (`None` sans signal) passe dans chaque métrique ; l'agrégation dans le collecteur/payload. NB : `unicode_blocks` et `mufi` sont **déjà couverts** côté Cinoc (`mufi_err`, `diacritic_err`, `cer_diplo`) — ne pas re-porter. |
+
+### Formules (pattern commun vérifié)
+
+```
+strict_score    = n_strict_preserved    / n_total_in_reference   ∈ [0,1] ; None si n_total = 0
+expansion_score = n_expansion_preserved / n_total_in_reference   (strict OU développé)
+préservation positionnelle (early_modern) : positions GT ⊆ opcodes "equal"
+agrégat corpus = micro (Σ numérateurs / Σ dénominateurs), pas moyenne de taux
+```
+
+Deux **sémantiques de préservation distinctes à conserver telles quelles** :
+- *positionnelle* (early_modern) — le caractère doit être à sa place ;
+- *containment* (abbreviations, modern_archives) — la forme (ou son expansion)
+  existe quelque part dans l'hypothèse (insensible casse pour les expansions).
+
+### Le doublon roman, précisément (réparation 🔶 centrale)
+
+- Comptage 1 : `numerical_sequences._detect_romans_with_values` →
+  `detect_roman_numerals(text, min_length=2)` ; lentille **valeur** (strict/value),
+  affiché dans la table « séquences numériques ».
+- Comptage 2 : `philological_hooks` → `compute_roman_numeral_metrics(ref, hyp)`
+  (défaut `min_length=1`) ; lentille **restitution** (5 statuts), affiché dans la
+  section philologique.
+- Conséquences : même entité comptée deux fois, **avec des assiettes différentes**
+  (un `I` isolé compte côté philologique, pas côté séquences) ; deux renderers.
+- Perte si on n'en garde qu'un : la lentille 5 statuts **subsume** strict/value
+  (`strict = strict_preserved` ; `value = n_total − lost`) — **rien n'est perdu
+  en gardant la lentille philologique seule** et en dérivant les deux scores.
+
+---
+
+## 4c — Fidélité textuelle
+
+### Fichiers et verdicts
+
+| Fichier (LOC) | Rôle vérifié | Verdict (PROVISOIRE) |
+|---|---|---|
+| `metrics/rare_tokens.py` (257) | Rappel des **tokens rares du corpus** (fréquence GT ≤ `max_freq=2` : hapax + dis legomena) ; tokenisation `\w+(?:[''\-]\w+)*` ; comptage **multiset** (`recall = Σ min(count_ref, count_hyp) / Σ count_ref` sur les rares) ; `None` si aucun rare. **ORPHELIN du runner** : calculé en couche reports (`reports/html/data/extra_metrics.py:50-102`) avec pré-passe fréquences faite là-bas — il n'y a **pas** de mécanique de pré-passe dans le runner Picarones (la note `MIGRATION_COUCHE_3.md` §13 « pré-passe stats corpus → DocContext » décrit la cible, pas la source). | **GARDER** (le calcul) — 🔶 rapatrier en couche 3 via **collecteur** (cf. Partie 2). |
+| `metrics/lexical_modernization.py` (263) | Table de **modernisation lexicale par token GT** : alignement mot-à-mot `difflib.SequenceMatcher(autojunk=False)`, tags equal/replace/delete (replace apparié 1-à-1, délétion → variante `"∅"`) ; par token : `n_total`, `n_modernized`, `rate_modernized`, `variants{hyp: count}` ; `top_modernized_tokens` pour le tri. **ORPHELIN** : pas de hook ; consommé par la vue optionnelle `advanced_taxonomy` + le registre `levers` (tous deux non portés). | **GARDER** (le calcul, diagnostic précieux pour les pipelines LLM) — 🔶 même collecteur que rare_tokens. |
+| `metrics/over_normalization.py` (235) | **Pipelines OCR→LLM uniquement** : aligne OCR→GT et LLM→GT (`rapidfuzz.Levenshtein.opcodes`, audit F18) ; pour chaque mot GT **correct côté OCR**, si le LLM l'a changé → sur-normalisé. `score = over_normalized / total_correct_ocr_words` ∈ [0,1] ; passages exemples capés à 20. Enregistré agrégateur corpus (`builtin_hooks.py:211-215`), alimenté par le runner via `pipeline_metadata` (`app/services/_benchmark_helpers.py:113-127`). **Bug C7** : renderer lit des clés fantômes. | **GARDER** — 🔶 réparer C7 par construction (payload typé) ; nécessite l'accès aux **deux étages** (RAW_TEXT et CORRECTED_TEXT). |
+| `metrics/equivalence_profile.py` (199) | Catalogue de **15 règles d'équivalence nommées** (ſ→s, u=v, i=j, æ, œ, þ→th, ð→th, ȝ→y, &→et, ỹ→yn, ꝑ→per, ꝓ→pro, ꝗ→que, y=i, vv→w) + `apply_selected_equivalences` (remplacements séquentiels, ordre = ordre catalogue) + `compute_cer_with_equivalences`. **MORT** (C4). | **SUPPRIMER / NE PAS PORTER** — divergence assumée avec la table 4c (cf. §Abandons). La fonctionnalité = profil de normalisation custom, déjà couverte (couche 2 + D-089). |
+| `metrics/searchability_hooks.py` (81) | Wrapper hook de `searchability.py` (Levenshtein ≤ 2, multiset). | **SUPPRIMER** — `searchability` est **déjà livré** dans Cinoc (T11). Seule différence : la source expose aussi `missed_tokens` (liste) — sans consommateur prévu côté Cinoc, ne pas porter (« pas de consommateur = supprimé »). |
+
+### La « fragmentation » 4c, factuellement
+
+| Module | Enregistrement source | Calculé par | Rendu |
+|---|---|---|---|
+| rare_tokens | aucun | couche reports (`extra_metrics.py`) | renderer dédié |
+| lexical_modernization | aucun | tests/synthetic + vue optionnelle | renderer dédié |
+| over_normalization | agrégateur corpus | runner (helpers `_benchmark_*`) | renderer **cassé** (C7) |
+| equivalence_profile | aucun | personne | aucun |
+| searchability | registre + hook (double chemin) | runner | renderer dédié |
+
+Cinq modules, cinq câblages différents, un bug d'affichage, un mort — c'est le
+🔶 « câblage homogène » du plan.
+
+---
+
+## 4d — Robustesse & qualité image
+
+### Fichiers et verdicts
+
+| Fichier (LOC) | Rôle vérifié | Verdict (PROVISOIRE) |
+|---|---|---|
+| `metrics/robustness.py` (581) | Courbes CER vs niveaux de dégradation **réels** (re-OCR). Dégradations PIL (`degrade_image_bytes`) : **noise** σ∈[0,5,15,30,50,80] (gaussien par pixel, **`random.Random(0)` — seed fixe**, `:128`), **blur** r∈[0,1,2,3,5,8] (GaussianBlur), **rotation** ∈[0,1,2,5,10,20]° (`rotate(-level, expand=False, fillcolor=(245,240,232))`), **resolution** ∈[1.0,0.75,0.5,0.33,0.25,0.1] (NEAREST down+up), **binarization** seuils [0=Otsu,64,96,128,160,192]. `RobustnessAnalyzer(engines, cer_threshold=0.20).analyze(corpus, max_docs=10)` → `DegradationCurve{levels, labels, cer_values, critical_threshold_level}` ; niveau critique = premier niveau où CER > 0.20. Moteur **injecté** (duck typing `OCREngine = Any`, `:40`) — pas d'import adapters. Coût défaut : 10 docs × 6 niveaux × 5 types = **300 appels moteur**. Déclenchement : CLI dédiée `picarones robustness` (`--max-docs`, `--cer-threshold`, `--degradations`, `--demo`). | **GARDER** — 🔶 exécution re-OCR **hors couche 3** (orchestrateur), opt-in + bornée (déjà le cas à la source : CLI séparée + `max_docs`) ; dégradations pures + assemblage de courbes restent couche 3. |
+| `metrics/robustness_projection.py` (287) | Projette les courbes synthétiques sur la qualité **mesurée** des images du corpus : interpolation **linéaire** entre niveaux (`:111`), mapping qualité→niveau par défaut (`noise→noise_level`, `blur→blur_score`, `rotation→rotation_angle`, `resolution→resolution_score`), déficit attendu = `expected_mean − baseline`. **Assume l'indépendance des dégradations** (note `:254-256`). | **SUPPRIMER / NE PAS PORTER** — absent de la ligne 4d du plan et de la table des gardées ; science faible (interpolation linéaire de courbes synthétiques × hypothèse d'indépendance) ; cf. §Abandons. |
+| `metrics/image_quality.py` (408) | Mesures réelles par image : **netteté** = `min(1, variance_laplacien_3×3 / 500.0)` (`:161`) ; **bruit** = `min(1, MAD_gradients / 30.0)` (`:261`) ; **rotation** estimée par projections horizontales ±5°, pas 1° (NumPy seul) ; **contraste** Michelson sur percentiles 5/95. Composite : `quality = 0.40·netteté + 0.30·contraste + 0.20·(1−bruit) + 0.10·max(0, 1−|rot|/10)` (`:329-332`). Tiers : good ≥ 0.7. Double chemin NumPy+PIL → PIL seul → `error` champ (image illisible exclue proprement). Constantes **empiriques non sourcées** (500, 30, poids). | **GARDER** — 🔶 documenter chaque constante comme convention éditoriale (valeur + lecture) dans la docstring ; pas de fallback « mock » (le `generate_mock_quality_scores` sert la démo Picarones, ne pas porter). |
+| `metrics/image_predictive.py` (283) | Cf. **C3** : combinaison pondérée des features d'`image_quality` (« complexité paléographique ») + hétérogénéité inter-docs (« homogénéité »). | **SUPPRIMER / NE PAS PORTER** — abandon confirmé (motif corrigé en C3). |
+
+Déterminisme source : bruit seedé `Random(0)`, démo seedée 42, mock seedé
+`hash(doc_id)` — rien à réparer, tout à **préserver**.
+
+---
+
+## 4e — Inter-moteurs & lignes
+
+### Fichiers et verdicts
+
+| Fichier (LOC) | Rôle vérifié | Verdict (PROVISOIRE) |
+|---|---|---|
+| `metrics/inter_engine.py` (484) | (1) **Divergence taxonomique** entre moteurs : JS-divergence en **bits** (`log2`), lissage ε=1e-12, `M=(P+Q)/2`, clampée [0,1] (`:100-113`), sur les **distributions de classes d'erreurs** (taxonomy) ; matrice paire-à-paire + `max_pair`. (2) **Complémentarité** : `oracle_token_recall` **multiset bag-of-words** = `Σ_token max_moteur(min(count_GT, count_hyp)) / Σ count_GT` (`:195-210`) — borne **supérieure optimiste** documentée (ignore l'ordre) ; `complementarity_gap` = `{oracle_recall, best_single_recall, best_engine, absolute_gap, relative_gap = abs_gap / max(1−best, 1e-12)}` ; `per_doc` capé à 50. ⚠️ conventions : GT vide → recall **1.0** (`:201`) ; distributions non validées (somme ≈ 1 supposée). Pas de hook : appelé par le renderer + le détecteur narratif `ensemble_opportunity` (supprimé). | **GARDER** — 🔶 GT vide → `None` (pas 1.0) ; réutiliser les comptages taxonomy **déjà collectés** par Cinoc (zéro recalcul). |
+| `metrics/error_absorption.py` (276) | Gain net d'une jonction OCR→LLM, **multiset** : `_missing_tokens(ref, hyp) = Counter(ref) − Counter(hyp)` par token ; corrigées = `max(0, manquants_avant − manquants_après)`, introduites = inverse, conservées = min ; `correction_rate = n_corrected/n_errors_before` (None si 0), `introduction_rate` idem, `net_improvement = n_corrected − n_introduced` (peut être < 0) ; échantillons de tokens capés à 50 ; `case_sensitive=False` par défaut (⚠️ masque les erreurs de casse). Pas de hook (renderer + vue pipeline). | **GARDER** — 🔶 partage l'extraction « deux étages » avec `over_normalization` (4c) ; trancher la casse via la normalisation de la vue (pas un flag interne). |
+| `metrics/line_metrics.py` (305) | Distribution du CER **par ligne** : alignement **fiabilisé** (C1) ; percentiles p50/p75/p90/p95/p99 (interpolation linéaire) ; **Gini** `G = (2·Σ(i+1)·xᵢ)/(n·Σxᵢ) − (n+1)/n` ∈ [0,1] ; `catastrophic_rate` par seuils **défaut [0.30, 0.50, 1.00]** (`:171-172`) ; heatmap positionnelle 10 bins ; CER ligne plafonné à 1.0. Hook doc+corpus (`builtin_hooks.py:191-199, 401-417`). | **GARDER** — porter l'alignement F15 **tel quel** (il est la version fiable) ; documenter la limite fusion/scission. |
+| `metrics/worst_lines.py` (199) | Top-N transversal des pires lignes (re-split des textes du `BenchmarkResult`, fragile après `compact()`). | **SUPPRIMER / NE PAS PORTER** — **déjà couvert** par Cinoc (`DiagnosticsPayload.worst_lines`, T11/D-069, collecté au fil du scoring avec extraits verbatim — design supérieur). |
+| `metrics/longitudinal.py` (373) | Sur l'historique : (1) **tendance OLS** (pente/intercept/R² sur CER vs temps ordinal-jours ; `R²=1.0` si tous CER égaux — convention contre-intuitive documentée) ; (2) **« change-point »** = balayage de l'index maximisant `|mean_after − mean_before|` avec `min_segment_size=3` (`:221-233`) — **pas un CUSUM ni un vrai Pettitt** (aucune statistique de test, aucune p-value : le max-diff « détecte » toujours quelque chose, seul un seuil Δ ≥ 0.01 filtre). Parsing timestamps multi-formats, silencieux si invalide. | **GARDER** (OLS) — 🔶 remplacer le max-diff par un **vrai test de rupture** (cf. Partie 2). |
+| `metrics/incremental_comparison.py` (253) | Cf. **C2** : effet isolé d'un slot (groupes à slots fixes, rangs moyens ex-aequo partagés, best/worst par moyenne). Consommé par la vue pipeline. | **SUPPRIMER / NE PAS PORTER** — hors liste des gardées ; exige des métadonnées « slots » que l'enveloppe Cinoc ne porte pas (pipeline = nom) ; cas d'usage 180-pipelines inexistant. Cf. §Abandons. |
+
+---
+
+## 4f — NER
+
+### Fichiers et verdicts
+
+| Fichier (LOC) | Rôle vérifié | Verdict (PROVISOIRE) |
+|---|---|---|
+| `metrics/ner.py` (309) | **Calcul pur, zéro dépendance** : `Entity(label, start, end, text)` (offsets caractères sur le texte GT niveau TEXT ; `text` informatif, jamais utilisé pour matcher). **Appariement** : IoU de spans = `inter/union` (`:122-130`) ; labels comparés **casefold** (`:153`) ; **greedy déterministe** trié `(−score, ref_idx, hyp_idx)`, chaque entité appariée une fois ; seuil **IoU ≥ 0.5** (défaut, `:203`). P/R/F1 protégés div-0 ; **global = micro** (TP/FP/FN agrégés), **par catégorie** = même formule sur les compteurs de la catégorie. Manquées = GT non appariées (FN listées) ; hallucinées = hyp non appariées (FP listées). Scalaire `ner_f1` enregistré jonction `(ENTITIES, ENTITIES)`. | **MODIFIER** 🔶 — algorithme d'appariement sain, mais **défaut de validité C9** : IoU sur des offsets de deux textes différents (GT vs hypothèse) → invalide dès que l'amont insère/supprime. Réparation **R14** obligatoire au portage. |
+| `metrics/ner_backends.py` (227) | `SpacyEntityExtractor(model_name="fr_core_news_sm")` : lazy-load idempotent ; **spaCy absent → warning + désactivé ; modèle absent (OSError) → warning + désactivé ; `__call__` → `[]`** (`:140-176`) — le benchmark continue avec des hypothèses vides → **scores faux (recall 0) sans message utilisateur** : LE silence à tuer. Profils : `fr/fr_lg/en/en_lg/multilingual=xx_ent_wiki_sm/hipe`. **Version du modèle spaCy non tracée** (reproductibilité cassée). Protocol `EntityExtractor` (extensible). | **DÉPLACER → `adapters/ner/`** (spaCy = SDK, hors whitelist effective couche 3) — 🔶 fail-closed + version tracée (cf. Partie 2). |
+
+**Vérité-terrain** (`evaluation/corpus.py`) : sidecar **`.gt.entities.json`**
+(`GT_SUFFIXES[ENTITIES]`, `:187-191`), format `{"entities": [...]}` **ou** liste
+nue ; entité = `{"label", "start", "end", "text"?}` (offsets caractères) ; format
+invalide → warning + skip.
+
+**Découplage source** : la NER ne passe **pas** par le pipeline — c'est un
+post-traitement `attach_ner_metrics_to_benchmark` déclenché si
+`--entity-extractor DOTTED_PATH` (CLI seulement, jamais exposé au web), qui mute
+le `BenchmarkResult` après coup. Plus le bug C6 (clés fantômes) et le test
+circulaire du renderer.
+
+---
+
+# PARTIE 2 — RÉORGANISATION CIBLE Cinoc (périssable, PROVISOIRE — à confirmer au build)
+
+## Arbitrages actés (2026-06-11 — « plan A », SPEC_HIPE v1.2)
+
+1. **Plan A** : la famille **4g** (conformité HIPE + bilan de correction) livre
+   **avant la 1.0**, intégrée à l'Étape 4 — la 1.0 revendique la conformité.
+2. **Architecture 4g** : implémentation **in-tree** ; `hipe-ocrepair-scorer`
+   épinglé en **dépendance de test** (oracle golden 1e-9, job CI 3.12) — jamais en
+   runtime (Python ≥ 3.12 vs matrice 3.11, `np.random.seed` global, validation
+   circulaire). Pattern maison déjà amorti (jiwer = oracle de parité, `text.py:8-9`).
+3. **`readability`/Flesch : abandonné** (retiré de 4a — cf. §Abandons).
+4. **`searchability` : durci avant 1.0** — échelle Elastic AUTO (0 édition < 3
+   caractères · 1 pour 3-5 · 2 pour ≥ 6) ; les valeurs baisseront vs runs passés,
+   raison de plus pour le faire pré-gel.
+5. **`hallucination` : décision différée-avec-critères, exécutée à 4g.2** (avant
+   1.0) : sur 2-3 runs réels (OCR seul · OCR+LLM modernisant · zero-shot),
+   (a) le trigramme flagge-t-il un document que (`char_ins_ratio` + part
+   d'éditions groupées) ne flagge pas ? (b) faux positifs sur GT diplomatique +
+   LLM modernisant ? Aucun signal unique → retrait de la clé ; sinon conservation
+   avec caveat documenté.
+6. **Liste `C` (hcpr/air) : une seule liste, archaïque uniquement** — accents
+   modernes exclus (perte = `diacritic_err`, vérifié `diacritics.py:50-58` ;
+   deux directions visibles en classe taxonomy `diacritic`). **Q4 actée
+   (2026-06-11)** : défaut = **`archaic_core`** trans-langue
+   (`ſ ꝛ ⁊ ꝑ ꝓ ꝗ ꝙ ꝯ ꝝ ꝫ ꝭ þ ð ȝ` + `aͤ oͤ uͤ`) ; **œ æ ß ç exclus du défaut**
+   (langue-relatifs — « cœur » est du français moderne → faux positifs `air`) ;
+   **`air` actif par défaut**, **`hcpr` visible seulement avec liste configurée**
+   (anti-colonne-jumelle de `mufi_err`) ; listes nommées en package-data +
+   override par run, nom + hash au manifeste et au rapport.
+7. **Différés d'enveloppe** *(amendé post-P0, D-110/D-111)* : la stabilité
+   inter-répliques (R-2.7) **reste différée** (aucune notion de réplique dans
+   `RunResult`). Les **folds (R-2.4)**, eux, ont désormais leur canal :
+   `DocumentRef.metadata["stratum"]` → `RunDocumentResult.stratum` (P0) — les
+   folds HIPE se mappent sur les **strates** ; ne reste différée que la
+   mécanique d'agrégation/pondération par strate (consommateur « CER par
+   strate » prévu par D-109), à réévaluer à sa tranche.
+
+## Rappel des coutures d'enveloppe disponibles (rien à modifier, tout existe)
+
+| Besoin d'une famille | Couture existante (mergée) |
+|---|---|
+| Scalaire par-document | `DocumentMetric` + `Observation(value, weight)` ; `None` = N/A ; micro-agrégat automatique (`runner._aggregate`) |
+| Non-scalaire | payload Pydantic `frozen, extra="forbid"` dans `analysis.py`, membre de l'union `AnalysisPayload` (discriminée `kind`) + `Analysis(scope, view, …)` |
+| Collecte au fil du scoring (zéro relecture) | pattern `DiagnosticsCollector`/`TaxonomyCollector` : `observe(pipeline, ref, hyp)` pendant la passe 1, `build(view)` après (`runner.py:90-149`) |
+| Accès aux **deux étages** d'un pipeline (RAW_TEXT *et* CORRECTED_TEXT) | pattern `calibration_analysis(view, corpus, pipeline_outputs)` : fonction d'analyse qui lit `pipeline_outputs` directement (`runner.py:144-146`) |
+| Nouveau type d'artefact GT | `ArtifactType.ENTITIES` existe (`domain/artifacts.py:66`) ; loader à étendre dans `representations.load_representation` |
+| Version d'un module externe | `RunManifest.module_versions` (T6) — un Module déclare sa version |
+| Section de rapport | `Protocol Section` (`render(RunResult, ctx) → Html|None`), modèle = `sections/taxonomy.py` |
+| Glossaire | entrée FR/EN par métrique **réellement calculée** (D-093 ; mécanisme = panneau `<dialog>` du chrome depuis D-099). ⚠️ D-114 : la **prose des sections** reste FR (i18n = passe unique post-P2) |
+| Strate par document (folds, CER par strate) | `DocumentRef.metadata["stratum"]` → `RunDocumentResult.stratum` (P0, D-110/D-111) |
+| Comparer des profils de normalisation | système de **vues** existant : une vue par profil, un payload croise (les « deltas » 4g.1 = différences entre vues, zéro mécanique nouvelle) |
+| Export nécessitant les **textes** (pas les scores) | couche **app** (seule à détenir corpus + `pipeline_outputs`) — ex. JSONL HIPE |
+
+**Conventions transverses à toutes les tranches** (héritées des tranches T8-T13) :
+payload + calcul + section + tests **dans le même commit** ; valeurs de tests
+**dérivées à la main ou référence externe** (jamais Picarones comme oracle) ;
+échantillons/listes dans les payloads **capés** (la source cape à 20/50 — garder
+des caps explicites) ; tris déterministes ; clés de métriques **courtes**
+(style `cer`, `mufi_err`) et **définitives à la 1ʳᵉ release** (contrat dur).
+
+---
+
+## Cible 4a — `structured_data`
+
+| Aspect | Cible (PROVISOIRE) |
+|---|---|
+| **Scalaires** | `numseq_strict`, `numseq_value` — `Observation(value=score_global, weight=n_total)` ; `None` si GT sans séquence. *(`flesch_delta_*` : **abandonné** — arbitrage n°3, cf. §Abandons.)* |
+| **Catégories** | **4** : `year`, `foliation`, `currency`, `regnal` — **`roman` retiré** (propriété 4b, cf. réparation R1) ; `regnal` garde `roman_to_int` en helper. |
+| **Payload** | `StructuredDataPayload(kind="structured_data", per pipeline : per_category{n_total, n_strict, n_value, strict_score, value_score, lost_items[:cap]})`. Cap `lost_items` repris (50 → à confirmer). |
+| **Section** | `reports/sections/structured_data.py` (table moteur × catégorie + bloc lisibilité — reprendre la lecture trafic-light/divergente de la source en jetons de charte). |
+| **Données/packaging** | Regex + table de canonisation des devises = constantes du module (sourcées en docstring). |
+| **Tests (valeurs main)** | Chaque regex : un positif/un négatif par catégorie (« 1515 » oui, « 0999 » non ; « f. 12r » ≠ « f. 12v » ; « an III » = 3) ; adaptatif : GT sans séquence → `None`. |
+| **Glossaire** | + `numseq_strict`, `numseq_value` (FR/EN). |
+| **Budget** | 1 module `metrics/structured_data.py` (détecteurs + 2 scalaires) ≈ 300 LOC + payload + section ≈ 150 — sous budget sans découpage. |
+
+## Cible 4b — `philology` (dé-fragmentée)
+
+| Aspect | Cible (PROVISOIRE) |
+|---|---|
+| **Architecture** | **Un moteur de préservation de marqueurs** + **tables en donnée** : `evaluation/data/markers_{abbreviations,early_modern,modern_archives}.yaml` (package-data) chargées par un loader unique. Deux stratégies de matching déclarées par table : `positional` (early_modern — opcodes equal) et `containment` (abbr/archives — strict verbatim + expansion à frontière de mot). Roman = détecteur dédié (parser porté de `roman_numerals.py`, 5 statuts). |
+| **Scalaires** | `abbr_strict`, `abbr_expansion`, `early_modern_pres`, `archives_strict`, `archives_expansion`, `roman_strict`, `roman_value` — tous `Observation(value, weight=n_total_GT)`, `None` si GT sans signal (adaptatif). Noms courts **à figer à la tranche**. |
+| **+ `hcpr` / `air`** *(SPEC_HIPE §9, arbitrage n°6 — **Q4 actée 2026-06-11**)* | `hcpr` = taux de préservation d'une **liste configurable de caractères archaïques** (généralisation paramétrable de `diacritic_err`/`mufi_err` — si factorisation en moteur commun, parité bit-à-bit exigée par test) ; **`air` = l'apport net** (Levchenko 2025) : taux d'occurrences de la liste dans la sortie **absentes de la GT** — détecte la sur-historicisation. **Une seule liste, archaïque uniquement** — défaut **`archaic_core`** trans-langue : `ſ ꝛ ⁊ ꝑ ꝓ ꝗ ꝙ ꝯ ꝝ ꝫ ꝭ þ ð ȝ` + `aͤ oͤ uͤ` ; **œ æ ß ç et accents modernes exclus du défaut** (langue-relatifs : « cœur » moderne → faux positif `air` ; perte = `diacritic_err` ; deux directions = classe taxonomy). **`air` actif par défaut** (`None` si la sortie ne porte aucun caractère de la liste) ; **`hcpr` visible seulement avec liste configurée** (anti-colonne-jumelle de `mufi_err`). Listes nommées en package-data (`archaic_core`, `archaic_de`, `archaic_fr_medieval`…) + override par run ; **nom + hash au manifeste/rapport**. Calculés sur vue `raw`/diplomatique ; pour les pipelines 2 étages, aussi sur l'étage brut (distinguer ce que le correcteur a perdu/inséré de ce que l'OCR avait déjà fait). Reste au build : dénominateur exact d'`air`. |
+| **Payload** | `PhilologyPayload(kind="philology", per pipeline : par module {n_total, n_preserved(/strict/expansion), per_category{…}, missed[:cap], et pour roman per_status{5}})`. |
+| **Section** | `reports/sections/philology.py` — **nouvelle** (il n'existe pas de section philologie aujourd'hui ; « étend la section philologie » du plan = étend l'offre philologique, la section naît ici). Les scalaires existants `mufi_err`/`cer_diplo`/`diacritic_err` restent où ils sont (by_engine) — la section 4b affiche les breakdowns. |
+| **Réparations 🔶** | **R1 — roman compté une fois** : le comptage vit en 4b (5 statuts), `numseq` perd sa catégorie roman ; les scores strict/value sont **dérivés** des statuts (`strict = strict_preserved`, `value = n_total − lost`) — aucune perte. **R2 — `min_length=2` partout** (l'assiette `min_length=1` de la source compte `I`/`M` isolés). **R3 — expansion à frontière de mot pour TOUTES les longueurs** (la source ne borne que ≤ 2 lettres → `per` matche « permettre »). **R4 — pas de `try/except Exception` orchestrateur** (interdit par garde-fou) : chaque module est une métrique/un collecteur propre. |
+| **Tests** | Tables : round-trip YAML + comptage d'entrées ; matching positionnel : cas main avec une substitution qui détruit un seul ſ ; containment : `ꝑ` strict vs « per » développé vs « permettre » (doit échouer après R3) ; roman : `ij→II` (j_dropped), `XIV→14` (converted), `IL` rejeté, dérivation strict/value depuis per_status. |
+| **Glossaire** | + 9 entrées (les scalaires ci-dessus + `hcpr`/`air`). |
+| **Budget** | moteur ≈ 250 LOC + roman ≈ 250 + payload/section ≈ 200 + 3 YAML — le YAML résout le cas `modern_archives` (601 → données). |
+
+## Cible 4c — `textual_fidelity` (unifiée)
+
+| Aspect | Cible (PROVISOIRE) |
+|---|---|
+| **Architecture** | **Un collecteur** `TextualFidelityCollector` (pattern Diagnostics) : `observe(pipeline, ref, hyp)` pendant la passe 1 ; à `build()` : (1) fréquences corpus depuis les réfs collectées → tokens rares (`max_freq=2`) → recall multiset par pipeline (+ échantillon `missed`) ; (2) table de modernisation lexicale (difflib, top-N tokens, variantes, `"∅"`). Résout proprement la « pré-passe corpus » : tout est calculé **après** la passe, sur les représentations déjà normalisées — zéro relecture, zéro mécanique nouvelle dans le runner. (3) *Sur-normalisation* : **déplacée en 4g.2** (bilan de correction, `SPEC_HIPE.md` §8) avec `error_absorption` — l'extraction avant/après (RAW_TEXT/CORRECTED_TEXT depuis `pipeline_outputs`, pattern calibration) vit en 4g, une fois, pour toutes les mesures. |
+| **Scalaires** | Aucun en v1 (toutes les sorties sont des structures corpus-niveau ; un scalaire par-doc `rare_token_recall` exigerait le set rare avant la passe 1 — y revenir seulement si l'historique/le classement en a besoin). |
+| **Payload** | `TextualFidelityPayload(kind="textual_fidelity", per pipeline : rare_tokens{n_rare_ref, n_recalled, recall, missed[:cap]}, modernization{top_tokens[:cap]{token, n_total, n_modernized, rate, variants}})`. *(`over_normalization` : déplacé en 4g.2 — `CorrectionPayload`.)* |
+| **Section** | `reports/sections/textual_fidelity.py`. |
+| **Réparations 🔶** | **R6 — câblage homogène** : un seul canal (collecteur), plus de calcul en couche rapport. *(R5 — bug C7 — et R7 — casse — suivent `over_normalization`/`error_absorption` en 4g.2.)* |
+| **Abandons dans la famille** | `equivalence_profile` (C4 — mort + couvert par couche 2/D-089) ; `searchability_hooks` (déjà livré T11 ; `missed_tokens` sans consommateur). **Divergence assumée avec la lettre de la table 4c — à valider au lancement de la tranche.** |
+| **Tests** | rare : corpus 3 docs calculé main (hapax/dis, multiplicité min()) ; modernization : « nostre→notre » + délétion `∅`. |
+| **Glossaire** | + `rare_token_recall` (entrée descriptive même sans scalaire si la section l'affiche — règle D-093). |
+
+## Cible 4d — `robustness` + `image_quality`
+
+> **⚠️ Mis à jour au build.** **`image_quality` livré (4d.1, D-128).**
+> **`robustness` ABANDONNÉ (4d.2, D-129)** — renversement assumé du verdict
+> « GARDER » ci-dessous (ce guide l'autorise, cf. §Abandons) : dégradations
+> *synthétiques* de validité douteuse, coût re-OCR disproportionné, seule feature
+> à traîner la couche 6 + la tension CLI §8.4 ; la résilience *réelle* relève des
+> **strates du dataset P3**. → **P2 terminée.** Détail : `MIGRATION_PLAN.md` D-129.
+
+| Aspect | Cible (PROVISOIRE) |
+|---|---|
+| **Placement** | Dégradations = **fonctions pures seedées** (`Random(0)` conservé) — candidates `evaluation/robustness.py` (PIL whitelisté) pour la partie maths/courbes ; la **ré-exécution** des moteurs sur images dégradées vit **couche 6** (orchestrateur, réutilise les Modules existants — jamais d'import moteur en couche 3, la source l'avait déjà compris via l'injection). |
+| **Opt-in & borne** | Pas de re-OCR implicite : option de `cinoc run` (ex. `--robustness noise,blur --robustness-docs 5`) plutôt qu'une commande dédiée (CLAUDE.md §8.4 fige la liste des commandes — à arbitrer à la tranche si une commande est plus honnête). Borne dure docs × niveaux × types documentée (défaut source : 10×6×5 = 300 exécutions). Compatible cache T15 (`resume`) : les images dégradées sont du contenu → adressage par empreinte fonctionne tel quel. |
+| **Payload** | `RobustnessPayload(kind="robustness", cer_threshold, per pipeline × degradation_type : {levels, labels, cer_values(None-toléré), critical_level})` + `ImageQualityPayload(kind="image_quality", per document : {sharpness, noise, contrast, rotation_degrees, quality_score, tier}, agrégats{mean_*, distribution good/medium/poor})` — **scope corpus** (les features d'image ne dépendent pas du pipeline : ne PAS les modéliser en `MetricScore`). |
+| **Sections** | `reports/sections/robustness.py` (courbes en tables/data-bars — pas de JS) ; bloc qualité image (même section ou dédiée — trancher au build). |
+| **Réparations 🔶** | **R8 — constantes documentées** : 500 (variance laplacienne), 30 (MAD bruit), poids 0.40/0.30/0.20/0.10, ±10° — conventions éditoriales **sourcées en docstring** avec leur lecture (pas de fausse autorité scientifique). **R9 — pas de mock** : `generate_mock_quality_scores`/`generate_demo_robustness_report` ne sont pas portés (la démo Cinoc est octet-stable sans canaux environnementaux — précédent D-068). |
+| **Abandons dans la famille** | `image_predictive` (C3) ; `robustness_projection` (hors plan, indépendance supposée). |
+| **Whitelist archi** | + `PIL` (+ `numpy` si chemin rapide retenu — le fallback PIL-seul de la source permet de différer numpy) dans `test_layer_dependencies` **à cette tranche** (MIGRATION_COUCHE_3 §14). |
+| **Tests** | dégradations : bytes→bytes déterministes (hash stable, seed) ; Otsu sur image bimodale synthétique main ; qualité : image générée (aplat vs damier) → bornes attendues ; courbe : moteur factice à CER scripté → niveau critique main ; **aucun re-OCR réel hors marker `live`**. |
+| **Glossaire** | + `robustness` (niveau critique), `quality_score` (si affichés). |
+
+## Cible 4e — `inter_engine` + `lines` + longitudinal raffiné
+
+| Aspect | Cible (PROVISOIRE) |
+|---|---|
+| **inter_engine** | Fonction d'analyse inter-moteurs (scope corpus) : oracle/complémentarité depuis les représentations (collecteur léger ou réutilisation du `DiagnosticsCollector` qui détient déjà ref/hyp par pipeline — à trancher) ; divergence JS calculée sur les **comptages taxonomy déjà collectés** (`TaxonomyCollector` — zéro recalcul, formule log2 + ε=1e-12 + clamp [0,1] reprise). Payload `InterEnginePayload(kind="inter_engine", complementarity{oracle_recall, best_single_recall, best_engine, absolute_gap, relative_gap, per_engine_recall}, taxonomy_divergence{matrix, max_pair})`. Section : **étendre `cross_engine`** (lecture seule). 🔶 **R10 — GT vide → `None`** (pas 1.0) ; documenter « borne supérieure bag-of-words » dans la section (anti-surinterprétation). |
+| **error_absorption** | **DÉPLACÉ → 4g.2** (bilan de correction, `SPEC_HIPE.md` §8) : intégré au `CorrectionPayload` — multiset GT-fondé (corrigées/introduites/conservées), complémentaire de CCR (GT-libre) et d'`over_normalization` (positionnel GT-fondé), sur l'extraction avant/après unique. |
+| **lines** | Collecteur (mêmes textes normalisés que diagnostics — ⚠️ vérifier à la tranche que le profil de normalisation de la vue **préserve `\n`**, sinon prendre la représentation brute) : alignement F15 porté tel quel, percentiles p50-p99, Gini, `catastrophic_rate` seuils [0.30, 0.50, 1.00], heatmap 10 bins. Payload `LinesPayload(kind="lines", per pipeline : {percentiles, gini, catastrophic_rate, heatmap, line_count, mean_cer})`. Section `lines` (ou bloc de diagnostics). **`worst_lines` non porté** (couvert T11). |
+| **longitudinal** | **Pas un payload `RunResult`** (c'est du multi-runs) : fonctions pures `evaluation/longitudinal.py` consommées par `app/history` (store tidy T7) → page `/history` + CLI `history`. OLS porté tel quel (conventions documentées : R²=1 si série constante). 🔶 **R11 — vrai test de rupture (Pettitt 1979)** à la place du max-diff : `U_t = Σ_{i≤t} Σ_{j>t} sgn(x_j − x_i)`, `K = max|U_t|`, `p ≈ 2·exp(−6K²/(n³+n²))` ; rupture signalée à `argmax|U_t|` **si p ≤ 0.05** (sinon « pas de rupture » — le max-diff, lui, « trouvait » toujours). Stdlib pur, déterministe, valeurs de test dérivées à la main + recoupées contre une implémentation publiée. |
+| **Abandon** | `incremental_comparison` (C2). |
+| **Glossaire** | + `oracle_gap`/`js_divergence` (si affichés), `gini` (lignes), `change_point` (page history si glossaire la couvre — sinon hors périmètre glossaire rapport). |
+
+## Cible 4f — NER
+
+| Aspect | Cible (PROVISOIRE) |
+|---|---|
+| **Extraction = brique de pipeline** (≠ post-traitement source) | `adapters/ner/spacy_extractor.py` : **Module Protocol** `RAW_TEXT|CORRECTED_TEXT → ENTITIES` (la NER est explicitement listée parmi les briques de pipeline, CLAUDE.md §3). Lazy import spaCy, paramètre `model` (défaut `fr_core_news_sm`), **version spaCy + nom/version du modèle → `RunManifest.module_versions`** (répare la reproductibilité, gratuit via l'enveloppe T6). Extra **`[ner] = ["spacy"]`** dans `pyproject.toml` (modèle téléchargé à part, comme les poids kraken — documenté). |
+| **Fail-closed anti-silence** | (1) **Au plan** : demander un étage NER sans extra/modèle → `RunPlanningError` 422 « installer `cinoc[ner]` + `python -m spacy download <modèle>` » — jamais un run qui « réussit » avec `[]` (le silence source). (2) Sonde `engine_statuses` : extracteur listé, indisponible proprement sans extra (pattern kraken/pero). (3) GT entités présente mais NER non demandée → la métrique est simplement non applicable (`None`), pas un silence : l'utilisateur n'a rien demandé. |
+| **GT & loader** | Sidecar **`.gt.entities.json`** (convention source reprise) → `GroundTruthRef(type=ENTITIES)` ; `representations.load_representation(uri, ENTITIES)` parse `{"entities": [...]}` ou liste nue, champs `{label, start, end, text?}` ; format invalide → erreur typée (pas un skip muet). |
+| **Métrique & payload** | `metrics/ner.py` : matching IoU 0.5 greedy `(−score, ref_idx, hyp_idx)` + labels casefold, porté (algorithme inchangé) **après R14** — spans hypothèse reprojetés en coordonnées GT. Scalaire **`ner_f1`** (micro global, `Observation(value=f1, weight=n_entités_GT)`, `None` si GT sans entité) — jonction `(ENTITIES, ENTITIES)` que le registre type-driven accepte sans modification. Payload `NerPayload(kind="ner", iou_threshold, per pipeline : {precision, recall, f1, per_category{label: PRF+support}, missed[:cap], hallucinated[:cap]})`. Section `reports/sections/ner.py`. |
+| **Réparations 🔶** | **R12 — bug C6 tué par construction** (payload typé). **R13 — pas de test circulaire** : valeurs PRF dérivées à la main (3 entités GT, 1 décalée IoU 0.6, 1 label différent, 1 hallucinée). **R14 — remap des offsets (C9)** : avant l'IoU, aligner hypothèse→GT au caractère (`rapidfuzz` opcodes — la mécanique d'`early_modern`) et reprojeter les spans hypothèse en coordonnées GT ; sans R14, le F1 mesure le profil ins/del de l'amont, pas la préservation des entités. Test dédié : insertion amont de 30 caractères → l'entité aval parfaitement transcrite reste TP. |
+| **Glossaire** | + `ner_f1` (FR/EN). |
+| **Hors périmètre** | Profil `hipe` (HuggingFace, jamais branché à la source) et backends multiples : un seul extracteur de référence ; le seam Module couvre les tiers. |
+
+---
+
+## Cible 4g — bilan de correction & conformité HIPE (nouvelle famille — [`SPEC_HIPE.md`](../../SPEC_HIPE.md))
+
+| Aspect | Cible (PROVISOIRE) |
+|---|---|
+| **4g.1 — profils (couche 2)** | `hipe` (copie exacte de `norm()` : lowercase, ß→ss ꝛ→r œ→oe æ→ae aͤ→ä oͤ→ö uͤ→ü, césures DTA, non-`\w`→espace, compactage) + `heritage` (lowercase + ponctuation + espaces, **sans** mappings historiques) — 12 → 14 profils (donnée) ; vérifier au build si `heritage` se compose depuis `caseless`/`no_punctuation`. |
+| **4g.1 — scalaire** | `cmer` (MER caractère = (S+D+I)/(H+S+D+I)) — comptes via `rapidfuzz.editops` (la plein-matrice maison serait trop chère au caractère) ; `Observation(weight=H+S+D+I)` → micro natif, macro depuis les par-doc. `mer` existant ≡ wMER : **mapping de nom à la frontière** (section/export), jamais de clé jumelle au registre. |
+| **4g.1 — payload + section** | `ConformityPayload(kind="hipe")` : par pipeline {cmer/wmer micro+macro, `delta_norm = cmer_raw − cmer_hipe`, `delta_heritage = cmer_heritage − cmer_hipe`} — les deltas = **différences entre vues** (raw/hipe/heritage), zéro mécanique nouvelle ; section conformité lecture seule, profil mentionné sur chaque nombre. |
+| **4g.1 — export** | adaptateur **JSONL HIPE en couche app** (le JSONL porte les TEXTES GT/raw/system, pas les scores → corpus + `pipeline_outputs` requis) ; `cinoc run --hipe-jsonl` ; c'est lui qui sert le leaderboard — le scorer runtime n'est pas nécessaire à l'interop. |
+| **4g.1 — sémantique « absent »** | R-1.8 : dans cette famille, sortie absente → matérialisée `""` (erreur max) + warning ; partout ailleurs `None` = N/A — **double convention documentée**, docs dégénérés inclus au golden. |
+| **4g.1 — golden** | `hipe-ocrepair-scorer==0.9.9` épinglé en extra `dev` (oracle de test, jamais runtime — arbitrage n°2) ; golden 1e-9 (scores ponctuels) sur job CI **3.12**, `skipif` explicite ailleurs ; property tests (CER ≥ cMER ; triplet Σ=1 ; pref = improvement−regression ; CCR=0 ⟺ system ≡ raw) + sensibilité Unicode (œ/oe, ſ/s, aͤ, césures) ; IC = bootstrap maison T9 (conformité = scores ponctuels). |
+| **4g.2 — payload correction** | `CorrectionPayload(kind="correction")` par pipeline 2 étages : triplet {improvement, regression, no_change} + `catastrophic_rate` (seuil 0.10 conf.) · `pref`/`pcis` (+ `pcis_median` + comptage \|pcis\|>1) · `ccr`/`change_ratio`/`length_ratio` + drapeau `overedited` (> 2.0) · `char_ins_ratio` + `hallucination_heavy` (> 0.10) — dérivés des comptes cmer, pas un 3ᵉ alignement ; n'altère pas `ins_rate`/`del_rate` (niveau mot, cousins documentés) · **absorption** (ex-4e) · **over_normalization** (ex-4c) · éditions consécutives (médiane, max, part > 20) · échantillons capés. Pipeline mono-étage → payload absent avec mention, jamais un zéro muet. |
+| **4g.2 — mécanique** | **Une** extraction avant/après (RAW_TEXT/CORRECTED_TEXT depuis `pipeline_outputs`, pattern `calibration_analysis`) partagée par toutes les mesures. |
+| **4g.2 — procédure `hallucination`** | exécutée ici (arbitrage n°5) — décision retrait/conservation **avant la 1.0**. |
+| **4g.2 — worst-pages** | extension du `DiagnosticsPayload` existant (T11) : tri par `delta_cmer` / `ccr` — consommateur déjà livré, ne pas recréer. Synergie : le payload `document_texts` (D-113) porte déjà les textes complets des pires documents — le diff pleine page des régressions 4g.2 le réutilise tel quel. |
+| **Glossaire** | + `cmer`, `pref_score`, `pcis`, `ccr` (+ entrées correction affichées) ; une phrase documente la différence cer/cmer. |
+| **Budget** | 4g.1 ≈ profils (donnée) + cmer (~60 LOC) + payload/section (~250) + export (~150) ; 4g.2 ≈ payload (~300) + section (~150) — sous budgets. |
+
+## Ordre de tranches recommandé (PROVISOIRE — révisé 2026-06-11, plan A ; = ordre interne de **P2**, ex-Étape 4)
+
+Chaque tranche = métriques + payload + section + glossaire + tests, **livrée
+entièrement** (une sous-étape par session de construction). Contraintes **dures** :
+4g.1 → 4g.2 (le triplet consomme `cmer` par-doc) · 4g.1 avant 4b (profil
+`heritage`) · 4a avant/avec 4b (transfert roman) · 4d en dernier (orchestration).
+Le reste est de la préférence.
+
+| # | Tranche | Pourquoi à cette place |
+|---|---|---|
+| 1 | **4g.1** conformité HIPE (profils `hipe`/`heritage` · `cmer` · `ConformityPayload` + section · export JSONL · golden) | La valeur la plus haute : répare la comparaison la plus trompeuse du produit (VLM à CER > 100 %), pose les profils que 4b consomme, et porte l'argument de conformité de la 1.0 (plan A). Pas besoin d'« échauffement » : les patterns payload/section/scalaire-adaptatif sont déjà établis (6 payloads livrés, `mufi_err`). |
+| 2 | **4g.2** bilan de correction (triplet · pcis+médiane · catastrophic · CCR/change/length · char_ins_ratio · absorption · over_normalization · éditions consécutives) | Consomme `cmer` (4g.1) ; absorbe les modules déplacés de 4c/4e ; **exécute la procédure `hallucination`** (décision avant 1.0). |
+| 3 | **4a** `structured_data` (sans readability) | Petite, indépendante ; avant 4b (transfert de propriété du roman — entre les deux tranches, le roman n'est compté nulle part : acceptable et court). |
+| 4 | **4b** `philology` (+ `hcpr`/`air`) | Consomme le profil `heritage` (4g.1) ; possède le roman ; introduit les tables YAML package-data. |
+| 5 | **4c réduit** `textual_fidelity` (rare_tokens + lexical_modernization) | Collecteur corpus ; plus de dépendance avant/après (partie en 4g). |
+| 6 | **4e réduit** `inter_engine` + `lines` + longitudinal/Pettitt (± `cev_jsd` si sa section est prête) | Réutilise les comptages taxonomy (JSD) ; Pettitt indépendant ; scindable 4e.1/4e.2/4e.3 si une session sature. |
+| 7 | **4f** NER (avec R14) | Verticale autonome (adapter + extra `[ner]` + loader + métrique + section) ; permutable sans risque. |
+| 8 | **4d** robustness + image_quality | **La plus lourde hors couche 3** : whitelist `evaluation/` PIL(/numpy) — Pillow est déjà une dépendance du projet (extra `[images]`, D-111) —, orchestration re-OCR couche 6, surface CLI à arbitrer. La garder pour la fin évite de bloquer les familles purement couche 3 derrière des décisions d'orchestration. Ses dégradations servent aussi de sonde de contamination (SPEC_HIPE Annexe C). |
+
+---
+
+## Risques de transfert & dettes à surveiller
+
+| Risque | Où il frappe | Comment le détecter/le prévenir |
+|---|---|---|
+| **Clés fantômes** (C6/C7) | toute section | Tué par construction (payload Pydantic + section lisant des champs). Test : la section rend des valeurs non nulles sur un payload witness. |
+| **Silence NER** (`[]` muet) | 4f | Fail-closed au plan (422) ; test « extra absent + étage NER demandé → erreur avec message install » ; jamais de skip silencieux dans le loader ENTITIES. |
+| **Réimport de la fragmentation** | 4c, 4e | Garde-fou existant : pas de hooks, un seul canal (`analyses`). Revue : aucun calcul dans `reports/` (grep `evaluation.` import-only). |
+| **Double comptage roman réintroduit** | 4a/4b | Test croisé : un texte avec `XIV` → compté en philology, **absent** du payload structured_data ; `min_length=2` unique. |
+| **Alignements bag-of-words surinterprétés** | 4e (oracle), 4g.2 (absorption), 4c (rare) | Bornes documentées dans payload/section (« borne supérieure, ordre ignoré ») ; convention GT vide → `None` (R10). |
+| **Lignes vs normalisation** | 4e lines | Vérifier à la tranche que la normalisation de vue préserve `\n` ; sinon représentation dédiée. Test : profil agressif + texte multi-lignes → line_count attendu. |
+| **Non-déterminisme** | 4d (bruit), 4f (modèle spaCy) | Seed `Random(0)` porté + test hash stable des bytes dégradés ; version modèle dans `RunManifest.module_versions` + assertion dans le test adapter. |
+| **Coût re-OCR non borné** | 4d | Opt-in + borne docs×niveaux×types dans la signature, testée (run sans flag → zéro exécution supplémentaire). |
+| **Constantes magiques re-copiées sans source** | 4d, 4a, 4g | Chaque constante éditoriale (500, 30, poids, 0.20, [0.30/0.50/1.00], IoU 0.5, max_freq 2, seuils 0.10/2.0, caps 20/50) listée en docstring avec sa lecture — la revue refuse une constante nue. |
+| **Tests circulaires** (le travers du renderer NER source) | toutes | Règle §5.8b déjà en vigueur : valeurs attendues dérivées à la main / référence publiée (jiwer, Pettitt 1979, scorer HIPE épinglé comme oracle *exécuté* — jamais comme source des attendus *écrits*), jamais la sortie de Picarones rejouée. |
+| **Budget fichiers** | 4b, 4d | Tables → YAML (4b) ; si un module dépasse 600 LOC malgré tout → entrée justifiée `test_file_budgets` à la tranche, pas après. |
+| **Clés de métriques bâclées** | toutes | Les noms courts proposés ici sont **PROVISOIRES** ; la tranche les fige **définitivement** (contrat dur rapports/JS/CSV/historique) — les choisir en début de tranche, pas en fin. |
+| **`norm()` HIPE copiée inexactement** | 4g.1 | La pièce la plus sensible (sémantique `\w` Unicode, ordre des mappings, césures DTA) : golden 1e-9 épinglé (job CI 3.12, `skipif` explicite ailleurs — jamais un faux vert) + tests de sensibilité Unicode + docs dégénérés dans le golden. |
+| **Double convention « absent »** (HIPE : vide = erreur max ; Cinoc : `None` = N/A) | 4g | La famille conformité matérialise l'absence en `""` + warning (R-1.8) ; partout ailleurs `None` reste `None` ; les deux documentées côte à côte — sinon les chiffres de conformité divergent du scorer sur run incomplet. |
+| **Hygiène de clés pré-1.0 oubliée** | transverse | 3 décisions AVANT le gel des clés : `hallucination` (procédure à 4g.2), `searchability` (échelle AUTO — les valeurs baisseront vs runs passés, à faire pré-1.0 précisément), `flesch` (abandonné, journal D-0xx au 1ᵉʳ commit concerné). |
+| **Surface 4g qui enfle** | 4g.2+ | Items T2 de la spec (`cev_jsd`, stabilité, folds) livrés **seulement avec leur consommateur** ; stabilité = différé d'enveloppe ; folds = canal strate livré (P0/D-110), seule la mécanique d'agrégation reste différée. |
+
+## Abandons recommandés (à acter au lancement des tranches concernées)
+
+| Module | Statut plan | Recommandation & motif |
+|---|---|---|
+| `image_predictive.py` | déjà abandonné (§Abandons #2) | **Confirmer**, motif corrigé (C3) : pas un stub mais une re-pondération sans pouvoir prédictif ni info nouvelle. |
+| `robustness_projection.py` | absent du plan | **Abandonner** : interpolation linéaire de courbes synthétiques sur qualité mesurée + hypothèse d'indépendance — chaîne spéculative ; aucun manque si 4d livre courbes + qualité séparément. |
+| `equivalence_profile.py` | listé en 4c **mais** déjà « mort » dans MIGRATION_COUCHE_3 §11 | **Abandonner** (C4) : zéro consommateur ; fonctionnalité couverte par profils couche 2 + preview YAML custom (D-089). **Divergence avec la lettre de la table 4c — à valider explicitement.** |
+| `incremental_comparison.py` | absent de la table des gardées | **Abandonner** (C2) : exige des métadonnées « slots » hors enveloppe ; cas 180-pipelines inexistant ; réintroductible si un consommateur réel surgit (l'enveloppe `analyses` l'accueillerait). |
+| `worst_lines.py` | non listé (couvert) | **Ne pas porter** : `DiagnosticsPayload.worst_lines` (T11) fait mieux (collecte au scoring, extraits verbatim, pas de re-split fragile). |
+| `searchability_hooks.py` | non listé (couvert) | **Ne pas porter** : `searchability` livré (T11) ; `missed_tokens` sans consommateur. |
+| `ner_backends.py` profil `hipe` + multi-backends | — | **Ne pas porter** : un extracteur de référence suffit ; le seam Module couvre les tiers. |
+| `readability.py` (Flesch delta) | listé ✅ en 4a au plan | **Abandonner** (arbitré 2026-06-11, plan A) : construct hors domaine de validité — la segmentation en phrases s'effondre sur ponctuation OCR abîmée (deltas parasites) ; ce qu'il détecte (lissage/modernisation LLM) est mesuré directement par `lexical_modernization`, le bilan de correction 4g.2 et `hcpr`/`air`. **Réversible sans perte** (formules publiées — aucune deadline de gel). Amendement de la table 4a du plan, à acter au journal D-0xx au build. |
+
+> Le gel de Picarones ferme la fenêtre : ces abandons sont proposés **en
+> connaissance de cause** (chacun a été lu, pas présumé). Si une tranche les
+> renverse, le journal D-0xx documente pourquoi.
diff --git a/cinoc/evaluation/MIGRATION_COUCHE_3.md b/cinoc/evaluation/MIGRATION_COUCHE_3.md
new file mode 100644
index 0000000000000000000000000000000000000000..e1daf4ee28b25b320f8d14b63b46eddf05be40ef
--- /dev/null
+++ b/cinoc/evaluation/MIGRATION_COUCHE_3.md
@@ -0,0 +1,352 @@
+# Plan de migration — Couche 3 (`evaluation/`) : Picarones → Cinoc
+
+> Statut : **plan acté**, implémentation à venir. Lecture seule du code Picarones.
+> Ce document fige les **contrats transverses** (enveloppe) ; le **remplissage**
+> suit des tranches verticales (cf. §2). Aligné sur `CLAUDE.md` (deux axes,
+> tranches, narrative supprimé, `CanonicalLayout` différé).
+
+---
+
+## 1. Objectif & périmètre
+
+La couche 3 calcule des **métriques** sur les sorties des pipelines (OCR/HTR/VLM,
+OCR+LLM) face à une vérité-terrain, et produit un **`RunResult`** sérialisable +
+les données du rapport. **Migration complète** (pas un MVP réduit) : on conserve
+toutes les vraies métriques ; on ne supprime que le **mort / doublon / mal placé**.
+
+Dépend des couches mergées : **domain** (`ArtifactType` dont `LAYOUT`, `Artifact`,
+`EvaluationView`/`MetricSpec`/`EvaluationSpec`, `RunManifest`, `Corpus`/`Document`)
+et **formats** (ALTO/PAGE riches, `_geometry`, `text/normalization`).
+
+Ne fait **ni I/O, ni rendu, ni exécution de moteur** : ce qui violerait ça sort
+vers `adapters/` / `reports/` / `pipeline/`.
+
+---
+
+## 2. Principe directeur — deux axes, tranches verticales
+
+Rappel `CLAUDE.md` §2/§4. **Deux axes strictement séparés** :
+
+| Axe | Quand | Ici |
+|---|---|---|
+| **Enveloppe** (contrats, types pivots, points d'extension) | **Dimensionnée plein-scope, maintenant** | registre type-driven, `RunResult`, deux formes de métriques, `Protocol Section` du rapport, slot `ArtifactType.LAYOUT` |
+| **Surface** (métriques, sections, importeurs) | **Incrémentale, minimale, élaguée** | une métrique/section à la fois, dans un budget |
+
+**Tranches verticales** (≠ « finir la couche 3 horizontalement ») : couches 1-2
+faites horizontalement (stables) ; couche 3+ par **squelettes ambulants** fins de
+pleine profondeur. La **première tranche** prouve que l'enveloppe tient avant d'y
+verser des features.
+
+**Cas particulier du rapport (cadre vs contenu)** : le **cadre** conceptuel
+(`Protocol Section` unique, consommation directe du `RunResult`, un seul format)
+est conçu **plein-scope dès maintenant** ; le **contenu** (nombre de sections,
+visualisations) grossit **au rythme des métriques** qui l'alimentent. Construire
+toutes les sections d'avance = bâtir du rapport **en avance sur ses données** =
+l'accrétion qui a alourdi Picarones. Le HTML basique du squelette **n'est pas
+jetable** : c'est la première section vraie, sur le cadre définitif.
+
+---
+
+## 3. Noyau verrouillé (enveloppe, plein-scope maintenant)
+
+1. **Registre unique type-driven.** Suppression des 4 systèmes parallèles de
+   Picarones (hooks `①`, registre module-level `③`, `@register_lever` `④`) ;
+   reste le **registre instanciable** (`②`), sélection **100 % par `input_types`**.
+2. **Deux formes de métriques** : **par-document** `(ref, hyp)` et **inter-moteurs**
+   `(EngineReports)`. Agrégation par-moteur **générique** (scalaires) +
+   **agrégateur custom co-localisé pour les structs** (dict — pas un cas rare).
+3. **`DocContext` / `CrossEngineContext`** : sac d'entrées **extensible** par forme.
+4. **Fiche + fonction co-localisées** ; **décorateur pur** (construit un `Metric`,
+   ne mute aucun global) + **collecte explicite par sous-paquet**.
+5. **Sécurité scientifique obligatoire** (dette C) : `safe_ratio`/`safe_mean`
+   (rendent `None` sur vide) ; agrégation **exclut `None`** + **expose le *support***.
+6. **`scipy` en dépendance dure** (Wilcoxon/Friedman/OLS validés).
+7. **`shapely` confiné** (`evaluation/geometry.py`), invoqué **seulement pour les
+   polygones**, **dégradable** (`backend="shapely"` → repli bbox + warning).
+   **Ajouté avec la tranche structure** (§10), pas maintenant.
+8. **Persistance** : `schema_version` sur le **document `RunResult`** (rapport/compare)
+   + **store longitudinal en lignes *tidy*** (additif). Complémentaires (§8).
+9. **Déterminisme bit-à-bit** ; **clés de sortie stables** (renommer un fichier =
+   libre ; renommer une clé de métrique = interdit, contrat dur avec rapports/JS).
+
+---
+
+## 4. Première tranche = squelette ambulant (axe texte)
+
+Le premier pas n'est **pas** le `CanonicalLayout` — c'est un **squelette fin de
+pleine profondeur** sur l'axe texte (`CLAUDE.md` §4) :
+
+```
+corpus pré-calculé (texte) → 1 CER → RunResult → HTML basique (1 section) → CLI `demo`
+```
+
+Il **exerce l'enveloppe complète** (registre, `RunResult`, runner, `Protocol Section`)
+avec **une seule métrique scalaire** (CER). Aucun `CanonicalLayout`, aucun shapely,
+aucune structure. Objectif : prouver que les contrats s'emboîtent de bout en bout.
+Puis on **épaissit l'axe texte** (WER/MER, profils, stats scipy, cross_engine,
+compare) avant d'ouvrir l'axe structure.
+
+---
+
+## 5. Le registre (contrat — enveloppe)
+
+- **`domain/evaluation.py:MetricSpec`** = contrat de type **minimal** (`name`,
+  `input_types`, `description`, `higher_is_better`) — déjà présent.
+- **La couche 3 enrichit** (métadonnées opérationnelles, hors domain) : `level`/forme,
+  `profiles`, `tags`, `requires`, `backend`, `unit`, `cost_hint`, `spec_version` —
+  **chacune avec un lecteur nommé**. Co-localisée avec la fonction.
+- **Signatures** : `fn(ctx: DocContext) -> …` et `fn(ctx: CrossEngineContext) -> …`.
+  Séparation **garantie par les signatures**, pas par une police AST.
+- **Profils** (`profiles.py`) : liste nommée **ou** sélecteur de tags simple
+  (`rapide`, `avancé`, …). Pas d'algèbre. Vocabulaire de tags petit et validé.
+
+---
+
+## 6. Le runner (deux passes)
+
+`evaluation/runner.py` (+ logique de calcul **rapatriée** de `app/services/_benchmark_*` —
+l'app *appelle*, ne *calcule* plus) :
+1. **Par-document** : `select(input_types)` → `DocumentMetric` sur `DocContext` ;
+   `None` = non applicable (skip).
+2. **Agrégation par-moteur** : générique (scalaires) + **custom (structs)** ;
+   `None` exclu ; **support** calculé.
+3. **Inter-moteurs** : `CrossEngineMetric` sur `CrossEngineContext` → **écrit dans `RunResult`**.
+
+---
+
+## 7. Défenses (sécurité scientifique, dette C)
+
+Couches : `input_types` (gratuit) · `safe_*` (vide → `None`) · préconditions
+`requires` (le runner saute) · **test générique** d'entrées dégénérées · **golden**
+sur fixtures réelles **ALTO + PAGE + texte** · agrégation `None`-exclu + support ·
+revue. Risque **présent dès l'axe texte** (ratios sur vide) → `safe_*` jour 1 ;
+amplifié à l'axe structure (mélange ALTO/PAGE).
+
+---
+
+## 8. Résultat & persistance
+
+- **`evaluation/result.py:RunResult`** (ex-`benchmark_result`, dégonflé) = contrat
+  de sortie unique, **dimensionné plein-scope** (porte taxonomy/NER/structure dès
+  sa conception, même si la 1ʳᵉ tranche n'écrit qu'un CER), avec **`schema_version`** + upcaster.
+- **cross_engine écrit dans le `RunResult`** ; le rapport ne fait que lire.
+- **Store longitudinal *tidy*** (lignes `(run, moteur, métrique, valeur, spec_version)`),
+  en `adapters/storage` (I/O hors couche 3). Ajout de métrique = additif.
+- **Réconciliation note couche 2** : « le jeu de champs fait foi » = même esprit que
+  le tidy pour les **ajouts** ; `schema_version` couvre les **changements structurels**
+  du document. Ne pas laisser « pas de version » déborder sur le document `RunResult`.
+- **Rapport interactif (what-if) — QUESTION OUVERTE, à trancher à sa tranche (tardive)** :
+  un rapport **filtrable** (ex. « exclure les docs hallucinés » → recalculer les agrégats)
+  est une feature **tardive, sans consommateur aujourd'hui** → on **ne fige pas son mécanisme
+  ici** (`CLAUDE.md` §9 : ne pas figer une forme avant son consommateur). Constat utile :
+  `RunResult` **porte déjà les résultats par-doc** (`RunDocumentResult`) → **aucun changement
+  d'enveloppe forcé maintenant**. Deux mécanismes à départager **à la tranche** :
+  **(a, recommandé)** le **runner pré-calcule** les agrégats des états what-if pertinents
+  (p. ex. via des `EvaluationView` dédiées) → le rapport **sélectionne**, ne calcule jamais
+  (invariant « le rapport ne recalcule jamais » respecté à la lettre ; marche pour générique
+  *et* custom) ; **(b)** ré-agrégation côté client sur les valeurs par-doc (continu, mais 2ᵉ
+  implémentation à golden-tester, limitée aux agrégateurs simples). *(Soulevé par
+  `reports/ANALYSE_COUCHE_7.md` §2.7 ; décision au build, pas ici.)*
+
+---
+
+## 9. Le rapport — cadre plein-scope, contenu incrémental
+
+- **Cadre (maintenant)** : un **`Protocol Section` typé unique**, consommant le
+  `RunResult` **directement** (pas de data-layer qui ré-agrège — anti-pattern
+  Picarones), un seul format, budgets.
+- **Contenu (incrémental)** : 1 section au squelette (overview/engines/CER) ;
+  on **ajoute des sections à côté** au rythme des métriques (documents, crosses,
+  structure…). Jamais de section en avance sur sa donnée.
+- **Pas de `reports/narrative/`** (supprimé, `CLAUDE.md` §6) : chiffres et tableaux
+  bruts, aucune prose générée.
+- **Interactivité (what-if) = sélection, jamais re-mesure** (cf. §8, **question ouverte**) :
+  si un rapport filtrable est construit (tranche tardive), il **sélectionne** une vue/projection
+  ou ré-agrège un sous-ensemble — **jamais** une re-mesure côté client ; l'**inférentiel**
+  (Wilcoxon/IC) reste gelé sur le corpus complet. **Mécanisme tranché à sa tranche**
+  (candidat = projections pré-calculées par le runner).
+
+---
+
+## 10. `CanonicalLayout` & axe structure — ENVELOPPE, matérialisés à la 1ʳᵉ tranche structure
+
+**Différé, par discipline** (`CLAUDE.md` §3/§6) — *pas le premier pas*.
+
+- **Réservé maintenant (enveloppe)** : `ArtifactType.LAYOUT` existe + `region_id`
+  optionnel sur `Artifact`. Le registre (générique sur les types) et le `RunResult`
+  (générique sur les métriques) **accueillent déjà** une métrique `(LAYOUT, LAYOUT)`
+  dès que des artefacts `LAYOUT` existeront — **sans** connaître les champs du type.
+- **Matérialisé plus tard** : le **type concret** `CanonicalLayout` (en `domain`)
+  + les **mappers** `alto/page → layout` (formats) + le projecteur `layout → text`
+  + les **métriques structurelles** (`region_detection`, `line_detection`,
+  `reading_order`, `geometry_coverage`) + **shapely** — tout ça naît à la
+  **première tranche *structure***.
+- **Déclencheur = la première tranche structure**, qui peut être l'**évaluation
+  structurelle** (couche 3 : mappers + métriques, sur des sorties ALTO/PAGE de
+  n'importe quel pipeline) **ou** la **segmentation** (couche 4), selon laquelle on
+  construit en premier. Le type **vit en `domain`** dans les deux cas ; « couche 4 »
+  est un raccourci pour « la tranche où son premier consommateur apparaît ».
+- **Pourquoi pas maintenant** : un type sans consommateur = code mort + champs figés
+  **avant** son consommateur = spéculatif (garde-fou *« pas de consommateur =
+  supprimé »*). Le différer est **plus sûr**, pas moins.
+
+**Esquisse cible** (à *confirmer* avec le consommateur, **ne pas figer maintenant**) :
+sur-ensemble fidèle des types couche 2 — `Geometry{bbox?, polygon?, baseline?}`,
+`Word` optionnel (+ hyphénation), `Line{text, words?, geometry?}`,
+`Region{region_type?, kind(text|generic), regions(imbrication)}`, `ReadingOrder`
+**en arbre** (mappe le PAGE ; ALTO = groupe plat = ordre des blocs), `LayoutPage`,
+`CanonicalLayout{pages, source_format}` + `has_word_level`. **Bonne nouvelle couche 2** :
+l'ALTO de Cinoc porte déjà `baseline` + `block_type` → métriques structurelles
+applicables sur ALTO aussi (pas systématiquement `None`).
+
+---
+
+## 11. Inventaire source → cible (Picarones `evaluation/`, 93 fichiers)
+
+**Supprimés** — 4 registres + plomberie (`metric_hooks`, `builtin_hooks`,
+`builtin_metrics`, `metric_registry`, 4×`*_hooks`), doublon (`search`), morts
+(`equivalence_profile`, `alto_metrics`, `cost_projection`, `ner_backends`,
+`difficulty`, `module_policy`), `normalization` (consolidé en `formats/text`),
+**`levers`** (4ᵉ registre, synthèse type-narrative → **abandonné**, narrative supprimé).
+⚠️ Supprimer une métrique n'est pas local : nettoyer ses références côté reports/JS/CSV
+(ex. clé `difficulty_score`).
+
+**Changés de couche** — `history` (SQLite) → `adapters/storage` ; `cdd_render` (SVG),
+`worst_lines` → `reports` ; ré-exécution moteur de `robustness` → `pipeline`.
+
+**Modifiés** — renommages (`benchmark_result`→`result`, `evaluation_engine`→`runner`,
+`_diff_utils`→`diff`), splits >400 LOC (`modern_archives`, `roman_numerals`,
+`numerical_sequences`, `inter_engine`), structure réécrite sur `LAYOUT`
+(`layout`→`region_detection`, `reading_order`, `alto_structural`→`geometry_coverage`),
+dédoublonnage (`searchability` absorbe `search`), `reliability`→`multirun_stability`.
+
+**Gardés** — noyau métier (CER/WER, philologie, inter-moteurs, économie, image,
+longitudinal) ; **clés de sortie inchangées**.
+
+**Nouveaux** — `profiles.py`, `metrics/_helpers.py` (`safe_*`) [axe texte] ;
+`geometry.py`, `structure/region_detection.py`, `structure/line_detection.py`,
+`projectors/layout.py`, `gt_types.py` [tranche structure].
+
+**Organisation cible** : `metrics/{text, philology/, structure/, cross_engine/,
+economics/, image/, longitudinal/}`, `statistics/`, `views/`, `projectors/`.
+
+---
+
+## 12. Risques de transfert Picarones → Cinoc
+
+1. `reading_order` sans source (Picarones) → **résolu couche 2** (arbre `ReadingOrder`
+   côté PAGE ; ALTO = ordre de bloc → groupe plat dans le mapper).
+2. **Agrégateurs custom** (confusion/taxonomie/calibration) — pas des moyennes (§6).
+3. **Clés de sortie = contrat dur** avec reports/JS/compare.
+4. `benchmark_result`→`RunResult` : ~30 consommateurs — beaucoup meurent (shim,
+   workflows), migrer reports + web + compare **en bloc**.
+5. Consolidation `normalization` : **sans danger** (l'eval n'en définissait aucun).
+
+---
+
+## 13. Explicitement laissé au codage (sous test)
+
+Intérieur des métriques ; contenu des profils + vocabulaire de tags ; liste des
+métriques structurelles PAGE-natives ; découpes des fichiers >400 LOC ; coutures
+(pré-passe stats corpus → `DocContext` pour `rare_tokens` ; alimentation historique
+→ longitudinal/`baseline_comparison`) ; champs concrets du `CanonicalLayout` (§10).
+
+---
+
+## 14. Tests & budgets
+
+- **Architecture** : étendre la whitelist `evaluation/` (**+scipy** ; **+rapidfuzz**
+  (T7) ; **+numpy/PIL** (4d.1 — numpy maths garanti via scipy, PIL décodage extra
+  `[images]`) ; **+shapely/jiwer au fil des tranches qui les introduisent**) ;
+  `no-side-effect-import` (décorateur = valeur pure) ; `file-budgets`.
+- **Golden** : `RunResult` canonique ; **ALTO+PAGE+texte** à la tranche structure ;
+  déterminisme bit-à-bit.
+- **Sécurité** : test générique d'entrées dégénérées ; CER/WER vs `jiwer` ;
+  round-trip de fidélité format→`LAYOUT` (à la tranche structure).
+
+---
+
+## 15. Ordre d'implémentation (tranches verticales)
+
+1. **Squelette texte** : corpus pré-calculé → CER → `RunResult` (plein-scope) →
+   HTML basique (1 section, cadre `Protocol Section`) → CLI `demo`. Registre +
+   `DocContext` + `runner` (1 métrique) + `safe_*`.
+2. **Épaissir l'axe texte** : WER/MER + portage du noyau texte (clés stables),
+   `profiles`, statistiques (**scipy**), `cross_engine` (écriture `RunResult`), `compare`.
+3. **Tranche structure** : `CanonicalLayout` (domain) + mappers `alto/page→layout`
+   + projecteur `layout→text` + **shapely**/`geometry.py` + `region_detection`/
+   `line_detection`/`reading_order`/`geometry_coverage` + golden ALTO/PAGE.
+4. **Store longitudinal *tidy*** (via `adapters/storage`) + reste des métriques
+   (philologie, économie, image, longitudinal) — une par une, en budget.
+
+---
+
+## DoD vivante (couche 3) — **autorité de détail** ; le `MIGRATION_PLAN.md` indexe
+
+> Tri-état : `[x]` fait **+ preuve** · `[ ]` à faire · `[~]` différé/réserve + raison.
+> Maj dans le **même commit** que le code. **Statut : ✅ T2** — `RunResult` plein-scope + registre type-driven + runner verts ; **CER/WER/MER** (parité jiwer) + profils de normalisation + stats `scipy` + `cross_engine` **livrés**. **+ T5 structure** : `region_cer` `(LAYOUT,LAYOUT)` + **`region_detection`** (F1 IoU de boîte, coords relatives — neutralise mm10/px ; **sans shapely**) + loader `LAYOUT` (JSON/ALTO/PAGE) + **projecteur `layout_to_text`** avec **exécution `ProjectionSpec`** dans le runner (un LAYOUT noté par les métriques texte ; réserve §9 `ProjectionSpec` levée ; vrai benchmark BNL ABBYY-vs-Tesseract en test `live`, F1 détection 0.35@0.5). — *preuves : `tests/evaluation/test_projection.py`, `…/test_projection_real_bnl.py`, `…/test_region_detection.py`*. **+ T7 philologie `mufi_err`** (`metrics/philology.py`) : taux d'erreur sur les caractères MUFI/médiévaux (PUA + Latin Extended-D + `ſ`/`þ`/ligatures), même alignement `rapidfuzz` que `diacritic_err`, `None` si la réf n'en porte aucun ; ajouté au socle → registre = `cer, cer_diplo, del_rate, diacritic_err, ins_rate, mer, mufi_err, region_cer, region_detection, wer`. — *preuves : `tests/evaluation/test_metrics_philology.py`, `…/test_registry.py`*. Reste : IoU polygonal exact (shapely, si consommateur) ; familles riches (NER/taxonomy) additives.
+>
+> **T8 (D-066)** : `RunResult` **v2** — `+ usage: tuple[DocumentUsage, ...]` (ressources par pipeline × document, triées, hors vues) ; `schema_version=2`, un JSON v1 sans `usage` se recharge. Le **contrat « analyses »** (canal unique typé pour le non-scalaire, 3 règles dures) est gravé dans la docstring de `result.py` ; le champ est **né en T9** avec `inference` (D-067). Preuves : `tests/evaluation/test_result.py::{test_usage_channel_round_trips,test_v1_payload_without_usage_still_loads}`.
+>
+> **T9 (D-067)** : `+ inference.py` (Nemenyi post-hoc + bootstrap percentile, stdlib pur, plancher partagé `MIN_SUPPORT`) `+ analysis.py` (canal E2 : `Analysis` + `InferencePayload`) ; le runner produit une analyse par (vue × métrique) applicable, sur les mêmes séries que `significance_p`. Parité numérique prouvée contre la source Picarones. Preuves : `tests/evaluation/test_inference.py` · `test_runner.py::test_inference_analyses_through_evaluate_run`.
+>
+> **T10 (D-068)** : `+ economics.py` + `pricing.json` (donnée datée packagée) — coût machine+jetons depuis les mesures E1, débit effectif, coût marginal, `pareto_front` ; payload `economics` = 2ᵉ membre de l'union `analyses` (discriminateur `kind` activé). Tests **dérivés à la main** (règle PLAN_PARITE §5.8b). Preuves : `tests/evaluation/test_economics.py`.
+>
+> **T11 (D-069)** : `+ metrics/diagnostics.py` (`searchability`, `hallucination` — registre = 12 métriques, vue `text` par défaut enrichie) `+ diagnostics.py` (collecteur branché au scoring : confusions, pires lignes, documents difficiles → 3ᵉ payload `analyses`). Preuves : `tests/evaluation/test_diagnostics.py`.
+>
+> **T12 (D-070)** : `+ calibration.py` — ECE/MCE (Guo 2017) + bins depuis les sidecars `CONFIDENCES` ; payload `calibration` = 4ᵉ membre de l'union. ECE/MCE en payload, pas en scalaire (la calibration qualifie, ne classe pas). Preuves : `tests/evaluation/test_calibration.py` (dérivés à la main).
+>
+> **T13 (D-071)** : `+ taxonomy.py` — 8 classes par règles pures (priorité segmentation→case→diacritic→ligature→visual→résiduel), 5ᵉ payload `analyses` ; classes à données externes élaguées (hapax/oov/abréviations). Preuves : `tests/evaluation/test_taxonomy.py`.
+>
+> **4g.1 (D-115)** : conformité HIPE (SPEC_HIPE) — profils `hipe`/`heritage` (couche 2, levier `non_word_to_space`) · `+ metrics/conformity.py` (**`cmer`** = MER caractère via `rapidfuzz.editops`, micro natif par `Observation(weight=H+S+D+I)`) · `+ conformity.py` (**post-passe cross-vues** : lit les résultats des vues raw/hipe/heritage déjà calculés — zéro re-scoring) → **7ᵉ payload `hipe`** (micro/macro §4.1 + `delta_norm`/`delta_heritage` + `n_missing` exposé) · section `conformity` (noms du scorer à la frontière ; `mer` ≡ wMER, pas de clé jumelle) · export JSONL via `artifact_sink` (`cinoc run --hipe-jsonl`, R-1.8 : sortie absente → `""` + warning) · glossaire `cmer` FR/EN. Oracle : parité **comptes jiwer** à chaque CI + golden vendoré skip-gaté (extra dédié `hipe-oracle`, Python ≥ 3.12). `[~]` réserves : fixture golden à vendorer · matérialisation R-1.8 dans les métriques → 4g.2. Preuves : `tests/formats/text/test_hipe_profiles.py` · `tests/evaluation/{test_metrics_conformity,test_conformity,test_hipe_golden}.py` · `tests/reports/test_conformity_section.py` · `tests/app/test_hipe_export.py`.
+>
+> **4g.2 (D-116)** : bilan de correction — `prepare_text` extrait vers `representations` (une seule définition « préparé comme au scoring ») · `+ correction.py` : analyse **par vue** des pipelines **2 étages** (une extraction GT/brut/corrigé) → **8ᵉ payload `correction`** : triplet de non-régression (égalités strictes) + `pref` + catastrophique (Δ > 0.10) · pcis §4.2 (clamp à q_brut nul, macro + médiane + \|pcis\|>1) · CCR/change_ratio/length_ratio + `overedited` · `char_ins_ratio` + `hallucination_heavy` · **absorption** multiset (ex-4e) · **sur-normalisation** positionnelle (ex-4c — tue le bug de clés fantômes C7 par construction) · éditions consécutives (R-2.6) · pires régressions ; seuils portés par le payload. **R-1.8 levée** : étage absent matérialisé vide + warning + `n_missing_*` (la réserve 4g.1). Section `correction`. Mono-étage → payload absent (≠ zéro muet). `[~]` réserve : **procédure `hallucination`** — machinerie complète, exécution sur runs réels avant 1.0 (critères a/b, SPEC §8). Preuves : `tests/evaluation/test_correction.py` (témoin entièrement dérivé à la main) · `tests/reports/test_correction_section.py`.
+>
+> **4a (D-117)** : données structurées — `+ metrics/structured_data.py` (détecteurs conservateurs : années 1000-2099, foliotation recto/verso **distincts**, montants, régnal — *roman* → 4b, helper `_roman_to_int` minimal absorbé à 4b) · scalaires **`numseq_strict`/`numseq_value`** (lentilles forme exacte / équivalence, multiset, `value ≥ strict`, adaptatifs `None` sans signal), registre = 15 métriques (**retirés de la vue par défaut → opt-in, D-130** : adaptatifs = colonnes vides sur corpus sans séquences ; la section `structured_data` reste, elle, affichée car le collecteur est indépendant de `metric_names`) · `+ structured_data.py` (collecteur, pattern taxonomy) → **9ᵉ payload `structured_data`** (pipeline × catégorie présente, formes perdues cap 12) · section `structured_data` · glossaire FR/EN. **`readability`/Flesch abandonné — acté** (D-117 ; couvert par 4g.2 + `hcpr`/`air`). Preuves : `tests/evaluation/{test_metrics_structured_data,test_structured_data}.py` (valeurs main : « fol. 3r »→« fol 3r » = valeur sans forme) · `tests/reports/test_structured_data_section.py`.
+>
+> **4b.1 (D-118)** : philologie/abréviations — `+ markers.py` (moteur containment+expansion **multiset**, réutilisable par famille ; table Capelli/MUFI **11 signes** en constante, `ñ` exclu, combinants NFC) ; `MarkerCollector` (pattern taxonomy) → **10ᵉ payload `philology`** (pipeline × famille × signe : strict/expansion). **Réparation R3** : développements en **mot entier** (`\b…\b`, toutes longueurs — `per` ≠ « permettre »). **Payload-only** (pas de scalaire registre : éviterait une colonne `None` sur corpus modernes ; la section adaptative est le consommateur). Section `philology` (nouvelle). `[~]` ouvert : familles early_modern (positionnel) / modern_archives (containment, table YAML si budget) / **roman 5 statuts (R1)** / **`air` (net-new HIPE) + `hcpr`** — sous-tranches suivantes. Expansion = borne optimiste documentée. Preuves : `tests/evaluation/test_markers.py` (R3 + multiset, valeurs main) · `tests/reports/test_philology_section.py`.
+
+> **4b.2 (D-119)** : philologie/imprimé ancien — `markers.py` gagne une **stratégie `positional`** (déclarée par `MarkerFamily.strategy`) à côté de `containment` : un marqueur est *préservé* si toutes ses positions GT tombent dans un opcode `equal` de `Levenshtein.opcodes` (cohérent CER). Famille `EARLY_MODERN` (**5 catégories** : ligatures / long_s / dotless_i / ampersand / nasal_tildes — caractères vérifiés source), graphies **pré-composées** seules, **NFC** avant détection (décomposé voyelle+U+0303 → pré-composé, compté pareil) ; `ñ` **inclus** ici (≠ famille scribale D-118). `MarkerCollector` dispatche par stratégie ; **payload `philology` réutilisé sans rupture** (`n_strict == n_expansion == n_préservé`, un seul score — documenté). Section `philology` **étendue** : bloc positionnel (colonne « préservé » + libellés catégories) distinct du bloc containment. **Payload-only** (pas de scalaire registre — `early_modern_pres` afficherait `None` sur corpus modernes). **Pas de branche morte** (seules 2 stratégies utilisées) ; **pas de glossaire** (aucun scalaire affiché). `[~]` reste ouvert : modern_archives / **roman (R1)** / **`air`+`hcpr`**. Preuves : `tests/evaluation/test_markers.py` (positionnel sub/NFC/per-catégorie + mix de stratégies, valeurs main) · `tests/reports/test_philology_section.py` (bloc positionnel).
+
+> **4b.3 (D-120)** : philologie/archives modernes — nouveau module **`archives.py`** : 9 catégories (~70 marqueurs : civilité/ordinaux/monnaies/administratif/état civil/ponctuation typo/latin moderne/biblio/adresse) en **constantes de module**, détection **regex bornée** (frontière après point — `M.` ≠ `M.A.`, `arr.` ≠ « arracher » ; `\b` pour l'alnum ; littéral pour l'Unicode) + **greedy plus-long-gagne** (`S.A.R.` avant `S.`). `markers.py` gagne une **3ᵉ stratégie `archival`** déléguant à `archives.py` ; famille `MODERN_ARCHIVES` (`markers` = clés d'affichage = catégories). **Containment MULTISET** (`Σ min(occ. GT, occ. hyp)`) — divergence **assumée** de la source (présence-par-occurrence qui n'enregistrait pas un `Mme`→`Mlle`), aligné sur 4b.1. Payload `philology` **réutilisé** (par catégorie : strict/expansion). Section étendue : bloc containment **par catégorie** (en-tête « catégorie » + libellés). **Module séparé** = isole le regex + tient le budget (markers 336 / archives 260 LOC, < 600). **Payload-only**, **pas de glossaire**, **pas de branche morte** (3 stratégies utilisées). `[~]` reste ouvert : **roman (R1)** / **`air`+`hcpr`**. Preuves : `tests/evaluation/test_archives.py` (frontières/multiset/greedy/ordinaux, valeurs main + end-to-end) · `tests/reports/test_philology_section.py` (bloc archives).
+
+> **4b.4 (D-121)** : philologie/numéraux romains — nouveau module **`roman.py`** : parseur soustractif **validé** (rejette `IL`/`IIIII`/`VV`, accepte `IIII` médiéval), `j` final (`viij`→`viii`), détection greedy + **classification 5 statuts** (`strict_preserved`/`case_changed`/`j_dropped`/`converted_to_arabic`/`lost`). `RomanNumeralsCollector` (pattern taxonomy) → **11ᵉ payload `roman` dédié** (≠ `philology` : le 5-statuts ne se mappe pas sur strict/expansion). Section `philology` étendue (bloc romain). **R1 FERMÉE** : romain compté **une seule fois** (ici) ; `numseq` sans catégorie roman depuis D-117 ; **helper régnal absorbé** — `metrics/structured_data.py` importe `roman.roman_to_int` (source unique). **R2** : `min_length=2`. Scores strict/valeur **dérivés** des statuts (pas de double comptage). **Payload-only**, **pas de glossaire**. **Budget** : `analysis.py` → 636 LOC (hub union discriminée) → entrée `test_file_budgets` justifiée (731). `[~]` reste ouvert : **`air`+`hcpr`** (dernier de 4b). Preuves : `tests/evaluation/test_roman.py` (parseur/5 statuts/R1 single-count/R2, valeurs main + end-to-end) · `tests/reports/test_philology_section.py` (bloc romain).
+
+> **4c (D-123)** : fidélité textuelle (réduit) — `+ textual_fidelity.py` : fonctions pures (`tokenize` Unicode lowercasé · `corpus_frequencies`/`rare_tokens` ≤ 2 = hapax+dis legomena · `rare_recall_counts` multiset · `modernization_counts` via `difflib.SequenceMatcher(autojunk=False)`) + **`TextualFidelityCollector`** (pattern taxonomy, `observe(pipeline, doc_id, ref, hyp)`). **Résout la « pré-passe corpus »** : la rareté est corpus-wide → calculée à `build()` sur les GT collectées (dédupliquées par document), **après** la passe, zéro relecture, zéro mécanique runner. → **12ᵉ payload `textual_fidelity`** (par pipeline : `n_rare_reference`/`n_rare_recalled`/`rare_recall` (None si GT sans rare) + `missed` cap 20 ; `modernization` top 20 tokens réécrits, variantes cap 5, `∅`=supprimé). Section `textual_fidelity` (rappel rare + table de modernisation, prose pédagogique). **R6 — câblage homogène** : un seul canal (collecteur), zéro calcul en couche rapport (≠ Picarones `extra_metrics.py` orphelin). **Abandons actés** : `equivalence_profile` (C4 — couvert profils couche 2/D-089) · `searchability_hooks` (déjà livré T11, `missed_tokens` sans consommateur). `over_normalization` **déplacé en 4g.2** (déjà livré). **Payload-only**, **pas de scalaire** (tout est structure corpus-niveau ; un `rare_token_recall` par-doc exigerait le set rare avant la passe 1 — différé jusqu'à un consommateur historique/classement) → **pas de glossaire** (précédent 4b ; pédagogie en prose ; la note provisoire §4c « + rare_token_recall » écartée : entrée orpheline sans scalaire). Pur stdlib (re/difflib/Counter). Preuves : `tests/evaluation/test_textual_fidelity.py` (rareté/recall multiset/modernisation + collecteur end-to-end, valeurs main : corpus 3 docs `le`2/`roi`3/`charles`2/`louis`1/`est`1) · `tests/reports/test_textual_fidelity_section.py`.
+
+> **4b.5 (D-122)** : philologie/archaïsmes `air`+`hcpr` — **4b TERMINÉE**. Premier de 4b à porter des **scalaires au registre** (≠ payload-only 4b.1-4b.4) : `air`/`hcpr` rejoignent `mufi_err`/`diacritic_err` en colonnes `by_engine` (avec glossaire FR/EN). `+ preservation.py` : **moteur partagé** `preservation_counts` factorisé hors `mufi_err`/`diacritic_err` (refactorés sans changer de valeur — **parité bit-à-bit** par `test_preservation` + les tests pinnés existants). `+ archaic.py` : listes nommées **package-data** (`ARCHAIC_LISTS`, défaut `archaic_core` Q4 trans-langue : `ſ ꝛ ⁊ ꝑ ꝓ ꝗ ꝙ ꝯ ꝝ ꝫ ꝭ þ ð ȝ` + marque suscrite `U+0364` pour `aͤ/oͤ/uͤ` ; `œ æ ß ç`/accents modernes **exclus** — langue-relatifs), **empreinte SHA-256** déterministe, `resolve_archaic_list` fail-closed. **`air`** (apport net, *plus bas = mieux*) = part des archaïsmes de la **sortie** insérés (position non couverte par un opcode `equal`) ; **dénominateur tranché = occurrences de la liste dans la sortie** → borné [0,1], `None` si la sortie n'en porte aucun ; **actif par défaut** (vue `text`, registre = 16 métriques). **`hcpr`** (préservation, *plus haut = mieux*) = `(n_total−n_wrong)/n_total` sur le moteur partagé ; **visible seulement sur liste configurée** (`archaic_list` → `plan_benchmark_run` ajoute la colonne + l'orchestrateur relie la métrique sur `metadata["archaic_list"]`) — **anti-colonne-jumelle** de `mufi_err` (sans config : `air` seul, pas de `hcpr`). **Reproductibilité** : nom + empreinte de la liste au `RunManifest.metadata` (toujours pour `air`) + au rapport. **Pipelines 2 étages** : `air`/`hcpr` notent le candidat aval (`CORRECTED_TEXT` préféré) — la sur-historicisation du correcteur est captée là où elle se produit. Démo : `pero` rend « Froiſſart » (ſ inséré) où la GT écrit « Froissart » → `air` réel non nul. **Pas de payload** (scalaires) → `analysis.py` intact. `[~]` reste au build : listes curées additionnelles (`archaic_de`…) **livrées avec leur consommateur** (enveloppe `ARCHAIC_LISTS` prête, surface = `archaic_core` seul, axe 2). Preuves : `tests/evaluation/{test_archaic,test_preservation}.py` (air/hcpr/empreinte, valeurs main + parité) · `tests/app/{test_run_planning,test_orchestrator}.py` (opt-in hcpr, liaison, manifeste) · `tests/reports/test_by_engine_section.py` (colonnes air/hcpr) · `tests/reports/test_glossary.py`.
+
+> **4e.1 (D-124)** : inter-moteurs — `+ inter_engine.py` : **`jensen_shannon_divergence`** en **bits** (`math.log2` stdlib, lissage ε=1e-12, `M=(P+Q)/2`, clamp [0,1]) + **`InterEngineCollector`** (pattern taxonomy ; `observe` ne retient que des `Counter` de tokens — **`tokenize` de `textual_fidelity` réutilisé**, une seule définition de token dans la couche). (1) **Complémentarité/oracle** : `oracle_recall` = bag-of-words **multiset** `Σ_token max_moteur(min(occ. GT, occ. moteur)) / Σ occ. GT` — **borne supérieure optimiste** (ordre ignoré), documentée dans la section (anti-surinterprétation) ; oracle vs meilleur seul (`absolute_gap`, `relative_gap` clampé, tie-break lexicographique), `per_engine_recall`, `per_document` (plus forts écarts, **cap 20** explicite — source 50). (2) **Divergence taxonomique** : `build(view, taxonomy_analysis)` = **post-passe cross-payload** (pattern `conformity`) qui lit les **comptages taxonomy déjà collectés** de la même vue — **zéro re-classification** ; matrice triangle supérieur (a < b) + `max_pair` (`None` si toutes nulles). → **13ᵉ payload `inter_engine`** (chaque bloc `None` si préalable manquant — < 2 pipelines, GT sans token, taxonomy absente — jamais un zéro muet). **Section `cross_engine` étendue** (blocs complémentarité + divergence ; gate élargi : payload seul suffit). **🔶 R10 réparée** : GT sans token → doc exclu / corpus vide → bloc absent (**jamais 1.0**, ≠ source `inter_engine.py:201`), tests dédiés (vide, ponctuation seule, mixte). **Abandons actés** : `incremental_comparison` (C2 — slots hors enveloppe, cas 180-pipelines inexistant) · `pairwise_disagreement_rate`/`kl_divergence` (zéro consommateur). **Payload-only, pas de scalaire** (qualifie l'ensemble, ne classe pas) → **pas de glossaire** (précédent 4b/4c). Budget `analysis.py` relevé (801 → 920, justifié). `[~]` restent : **4e.2 lines** · **4e.3 longitudinal/Pettitt** (sessions séparées). Preuves : `tests/evaluation/test_inter_engine.py` (JSD valeurs main log2(1.5) · oracle multiset main · R10 · cap · tie-break) · `tests/evaluation/test_runner.py` (set exact des kinds + payload end-to-end) · `tests/reports/test_cross_engine_section.py` (blocs + borne documentée).
+
+> **4e.2 (D-125)** : distribution du CER par ligne — `+ lines.py` : **alignement F15 porté tel quel** (`Levenshtein.opcodes` sur les **listes de lignes** avant tout CER — une ligne insérée/supprimée ne décale plus les suivantes ; ligne GT sans correspondance → CER **1.0** ; lignes hyp en trop **ignorées**, distribution indexée GT ; limite fusion/scission ≈ sub+del documentée) · CER ligne NFC+strip **plafonné 1.0** · percentiles p50/p75/p90/p95/p99 (interpolation linéaire) · **Gini** clampé [0,1] (somme nulle → 0.0) · **taux catastrophiques** seuils 0.30/0.50/1.00 **inclusifs ≥** (le `>` strict de la source laissait le seuil 1.00 **mort** : CER plafonné à 1.0 ne le dépasse jamais) · **heatmap positionnelle 10 bins** par position relative (poolable multi-docs ; tranche vide → `None`). `LinesCollector` (pattern taxonomy) → **14ᵉ payload `lines`**, agrégat **micro** (lignes du corpus **poolées** par pipeline — ≠ source qui moyennait des stats par document, divergence assumée alignée sur la convention maison). **Applicabilité par sonde comportementale** : `newline_preserved(view)` = survie de `\n` à `prepare_text("a\nb")` — couvre profils à plat (`flat_text`/`hipe`/`heritage`), levier `\W→espace` et `char_exclude` ; vue à plat → payload **absent** (l'alternative « représentation brute » de l'analyse écartée au build : chiffres incohérents avec la vue + plomberie de textes bruts — absence honnête > nombre trompeur). Section `lines` (distribution + heatmap), onglet **engines** (rows = pipelines ; « bloc de diagnostics » écarté) ; **réparation au passage** : `textual_fidelity` (4c) manquait aux tables onglet/libellé du renderer (rendue en « trailer » hors onglets) → ajoutée. **`worst_lines` non porté** (couvert T11, acté). **Payload-only, pas de scalaire** → **pas de glossaire** (précédent 4b/4c/4e.1 ; note provisoire « gini si affiché » écartée — pédagogie en prose). Budget : `analysis.py` 873/920, sous budget. `[~]` reste : **4e.3 longitudinal/Pettitt** (session séparée). Preuves : `tests/evaluation/test_lines.py` (fixture canonique 5 lignes CER [0, .2, .4, .6, 1] — percentiles posés main, Gini 24/55, seuil inclusif, F15 délétion/insertion, pooling, sonde par profil) · `tests/evaluation/test_runner.py` (set exact des kinds + valeurs end-to-end) · `tests/reports/test_lines_section.py`.
+
+> **4e.3 (D-126)** : longitudinal raffiné — **4e réduit TERMINÉ**. `+ longitudinal.py` : **fonctions pures, PAS un payload `RunResult`** (multi-runs). **`linear_trend`** = OLS closed-form porté tel quel (pur stdlib, pente **par jour**, origine x = premier point → intercept lisible ; conventions documentées : série constante → R² = 1.0 — constance testée sur les **valeurs**, pas sur `syy` flottant ; `None` si < 2 points ou horodatages identiques). **`pettitt`** (**R11**) = vrai test de rupture (Pettitt 1979, rangs) : `U_t = Σ_{i≤t}Σ_{j>t} sgn(x_j−x_i)` en balayage **incrémental O(n²)**, `K = max|U_t|` (égalité → plus petite frontière), `p ≈ 2·exp(−6K²/(n³+n²))` clampée ≤ 1, **`significant` seulement si p ≤ 0.05** — le max-diff de la source (qui « trouvait » toujours, filtré par un seuil arbitraire 0.01) **n'est pas porté** ; preuve aux tests : Δ=0.4 sur n=6 → p≈0.29, NON significatif. Entrées **déjà parsées** (`datetime`/`float`) — le parsing multi-formats à skip silencieux de la source non porté. **Consommateur** : `app/history.series_insight` (couche 6 — `fromisoformat` strict, illisible → warning + ligne écartée, naïf → UTC, tri interne, `rupture_run_id` = premier run du nouveau régime) → cartes tendance `/history` (pente/j + R² ; « rupture dès <run> · Δ (p=…) » **seulement si significative**) + i18n FR/EN. **CLI `history` non créée** (CLAUDE §8.4 fige les commandes — prime sur la note d'analyse). `compute_corpus_longitudinal` non porté (boucle de présentation, la page itère déjà). Lève le différé D-042 (`evaluation/longitudinal.py`). Preuves : `tests/evaluation/test_longitudinal.py` (OLS valeurs main 0.05/0.15/0.25 + **parité scipy.linregress** ; Pettitt valeurs main K=36/p≈0.0314 et K=9/p≈0.2907 + recoupement double-somme directe + invariance monotone + clamp) · `tests/app/test_history.py` (tri, skip journalisé, r07) · `tests/interfaces/web/test_history_trends.py` (pente affichée ; rupture seulement si significative).
+
+> **4f (D-127)** : entités nommées (NER) avec **R14** — verticale autonome (couches 3/5/6/7). `+ evaluation/ner.py` : `Entity`/`EntitySet` (le format embarque **le texte des offsets** `{"text","entities"}` → reprojection auto-suffisante ; la **liste nue** de la source abandonnée car R14 l'exige) · `parse_entities` (**erreur typée** si malformé — anti-silence) · **R14** `build_position_map`+`remap_entities` (alignement caractère `rapidfuzz.opcodes` GT↔OCR → spans hypothèse reprojetés en coords GT **avant** l'IoU ; sans quoi le F1 mesure le profil ins/del de l'OCR, pas la survie des entités) · `align_entities` (glouton IoU décroissant, labels casefold, déterministe) · `compute_ner` + `EntitiesCollector` (pattern taxonomy) → **15ᵉ payload `ner`** (global + par catégorie + manquées/hallucinées cap 20). `+ metrics/ner.py` : scalaire **`ner_f1`** jonction `(ENTITIES, ENTITIES)` (micro `Observation(f1, weight=n entités GT)`, `None` si GT sans entité ; registre = 17 métriques). Loader `load_representation(uri, ENTITIES)` → `EntitySet`. Runner : `_score_document` expose le **contexte entités** (3-uplet avec le texte) → le collecteur l'observe sans recharger ; payload absent si la vue ne déclare pas `ner_f1` (set exact des kinds de `test_runner` inchangé). `+ adapters/ner/spacy_extractor.py` : Module `RAW_TEXT|CORRECTED_TEXT → ENTITIES`, spaCy lazy (extra `[ner]`), mapping PERSON→PER/GPE→LOC, **fail-closed** (SDK/modèle absent → `AdapterStepError`, **jamais `[]`** — tue le silence source ; versions au `RunManifest` via `system_binaries()` best-effort). Builder `ner` au `ModuleRegistry`. Section `reports/sections/ner.py` (onglet engines, caveat « mesure conjointe OCR + extracteur »). Glossaire `ner_f1` FR/EN. **Différé (surface)** : planification d'une étape NER vivante (`Competitor.ner` + 422 au plan) + formulaire web + sonde moteurs — l'**anti-silence est tenue sans le 422** (l'adapter lève à l'exécution, l'orchestrateur isole). `worst`/`hipe` multi-profils source non portés (un extracteur de réf suffit, seam Module couvre les tiers). Budget `analysis.py` 942/1083. Preuves : `tests/evaluation/test_ner.py` (IoU/R14/PRF/collecteur valeurs main) · `tests/evaluation/test_ner_runner.py` (scalaire+payload+R14 via `evaluate_run`) · `tests/adapters/ner/test_spacy_extractor.py` (Module via faux spaCy + fail-closed) · `tests/app/test_module_registry.py` (builder) · `tests/reports/test_ner_section.py` · `tests/reports/test_glossary.py`.
+
+> **4d.1 (D-128)** : qualité d'image — sous-tranche de **4d** (dernière famille de P2). **4d.2 robustesse ABANDONNÉE (D-129)** — décision produit renversant le verdict GARDER (dégradations synthétiques de validité douteuse, coût re-OCR disproportionné, seule feature à exiger la couche 6 + la tension CLI §8.4, résilience réelle = strates du dataset P3) → **4d = 4d.1 seul ; P2 (métriques) TERMINÉE.** `+ evaluation/image_quality.py` : maths **numpy pures** (testables sur matrices construites à la main, sans PIL) — `laplacian_sharpness` (variance du laplacien 3×3 / **500**, plafonnée 1) · `gradient_noise` (médiane des \|∇\| / **30** ; la source la nomme « MAD » par abus — c'est la médiane de \|∇\|) · `michelson_contrast` ((p95−p5)/(p95+p5)) · `estimate_rotation` (balayage projection **±5°** pas 1°, **heuristique** bornée, < 20 px → 0) · `composite_quality` (**0.40**·netteté + **0.30**·contraste + **0.20**·(1−bruit) + **0.10**·max(0,1−\|rot\|/**10**)) · `quality_tier` (**≥ 0.70** good · **≥ 0.40** medium). `image_quality_analysis(view, corpus)` décode via PIL (best-effort). → **16ᵉ payload `image_quality`** = **scope corpus, par document** — **1ᵉʳ payload non-pipeline** : la qualité d'une image ne dépend NI du moteur NI de la vue → calculée **une seule fois**, hors boucle des vues, rattachée à la 1ʳᵉ vue (comme `conformity` à `hipe` ; par-vue produirait N payloads identiques + N relectures). Section `image_quality` (onglet **documents**, table par document + agrégats + prose). **R8 — chaque constante documentée comme convention éditoriale** (500, 30, poids, ±10°, paliers, ±5°, percentiles 5/95) avec sa lecture, **sans autorité scientifique**. **R9 — pas de mock** (`generate_mock_quality_scores` non porté) : la démo reste **octet-stable par construction** (corpus démo sans `.png` réel → analyse `None`, comme `structured_data` sur corpus moderne — aucune neutralisation ajoutée). **Un seul chemin de mesure** : numpy (garanti via `scipy`) pour les maths, PIL **seulement pour décoder** (extra `[images]`, absent → `None` + warning unique) — le fallback PIL-seul de la source (nombres divergents) **abandonné**. **Adaptatif** : sans image locale lisible → `None` (distantes `://` / manquantes / non décodables → exclues + warning, jamais une mesure fabriquée). **Abandon `image_predictive` acté** (C3 : re-pondération des mêmes features sans pouvoir prédictif, nom mensonger) ; **`robustness_projection` confirmé, formellement acté à 4d.2**. **Whitelist** `EVAL_ALLOWED_EXT` += `numpy`,`PIL`. **Payload-only, pas de scalaire registre → pas de glossaire** (précédent 4b/4c/4e ; pédagogie en prose). Budget `analysis.py` 996/1083. Preuves : `tests/evaluation/test_image_quality.py` (maths valeurs main : tache 4×4 → laplacien [-40,10,10,0]/var 425/netteté 0.85 · bruit 0 · bimodale → contraste 1/3 · composite/paliers · gris plat 16×16 → 0.30/poor de bout en bout via `evaluate_run` · adaptativité None · PIL absent · un seul payload multi-vues) · `tests/reports/test_image_quality_section.py`.
+
+> **G1 (D-131)** : carte des mots — **axe graphiques didactiques** (premier graphique ; le **seul** du catalogue à exiger un calcul nouveau, cf. `cinoc/reports/ANALYSE_GRAPHIQUES_DIDACTIQUES.md` §1). `+ evaluation/word_errors.py` : `word_misses(ref, hyp)` réutilise **`textual_fidelity.tokenize`** (une seule définition de token dans la couche) + `difflib.SequenceMatcher(autojunk=False)` — un mot GT est **raté** sur les tags `replace`/`delete` (forme produite = mot hyp aligné, ou `∅` supprimé ; `insert` = hallucination, **pas** un raté GT) · **`WordErrorCollector`** (pattern `inter_engine` : `observe(pipeline, doc_id, ref, hyp)` ; `build(view)` cross-tabule sur les pipelines **observés**). → **17ᵉ payload `word_errors`** : par mot GT, `per_engine` **creux** (seuls les moteurs qui ratent), `total_errors`, **signature de regroupement** `universal` (tous les pipelines observés ratent — la *matière*) / `engine_specific` (un seul — le *moteur*) / `partial` (sous-ensemble) ; `pipelines` = base du croisement (≥ 2) ; **cap 50** mots (tri `(-total, mot)`) ; **`None` si < 2 pipelines ou aucune erreur** (jamais une carte vide). **Enveloppe pour #2/#3** : `EngineWordError.variant` porte la **forme produite dominante** (verbatim, collectée à la même passe) — dimensionnée pour le graphe « mot → variante » (#3) et le recouvrement (#2), **non rendus en G1 mais rendus à D-132** (#2 recouvrement façon UpSet + #3 forme produite par moteur — **couche 7 seule, payload inchangé** ; la réserve « collectée mais non rendue » est ainsi levée). **Couche 7** : `reports/svg.py::word_engine_heatmap` (heatmap déterministe `num()`, octet-stable, **mots échappés** anti-XSS, `aria-hidden` — compagnon visuel) + CSS `.wmap-*` + `reports/sections/word_errors.py` (matrice mots×moteurs + regroupements, mots **verbatim**, prose **FR/EN** d'office, `requires=()`, onglet **crosses**), enregistré au renderer (label + tab + instanciation). **Honnêteté** : appariement **dépendant de la normalisation de la vue** (GT/hyp préparés identiquement en amont par le runner) ; **fusion/scission** de mots = limite de l'alignement (apparie 1-à-1, le reste → `∅`) ; mots et variantes **verbatim** (rien d'inventé — D-094). **Payload-only, pas de scalaire → pas de glossaire** (précédent 4b/4c/4e ; pédagogie en prose). Pas de nouvelle dépendance (stdlib `difflib`/`Counter`). Budget `analysis.py` 1056/1083. Preuves : `tests/evaluation/test_word_errors.py` (alignement replace/delete/insert · matrice universal/engine_specific/partial · variante dominante · cap 50 · `None` — valeurs main + bout en bout via `evaluate_run`) · `tests/reports/test_word_errors_section.py` (mots verbatim · FR/EN · déterminisme bit-à-bit · variante #3 non rendue) · `tests/reports/test_svg.py` (heatmap markup/comptes/teinte/échappement/déterminisme).
+
+**Enveloppe (plein-scope dès T1) :**
+- [x] `RunResult` (`evaluation/result.py`) dimensionné plein-scope (scalaires texte/structure/NER/taxonomy + par-doc + `schema_version` ; clés stables ; `cross_engine` réservé). — *preuve : `test_result` (sérialisation déterministe) + `evaluate_run` le produit*
+- [x] Registre **type-driven** unique (sélection par `input_types`) ; 0 ancien registre. — *preuve : `test_registry::test_get_and_select_by_input_types` + `test_no_forbidden_tokens` vert*
+- [x] `DocContext` + runner (par-document → **agrégat micro** `Σerreurs/Σpoids` = la métrique au niveau corpus, `None`-exclu + support ; macro reconstructible depuis le détail par-doc). Les métriques renvoient `Observation(value, weight)` ; `weight` = dénominateur. — *preuve : `test_runner` (micro `1/6` ≠ macro `0.125` ; poids par-doc = 4 ; GT absente → `None`)* — **corrigé à l'audit T3** (était macro non pondéré + `safe_mean` supprimé).
+- [x] `CrossEngineContext` + passe inter-moteurs (`cross_engine` écrit dans `RunResult`) ; **Wilcoxon/Friedman** avec **plancher de puissance** `_MIN_SUPPORT=6` (sous lui → `None`, pas un faux verdict) + filet `ValueError→None`. — *preuve : `test_metrics_stats` (significatif/égaux/sous-plancher) + `test_runner::test_cross_engine_significance_written`* — *(T2 ; durci à l'audit T3)*
+
+**Garde-fous :**
+- [x] `layer_dependencies` (`evaluation` → domain+formats ; `scipy` whitelisté) · `no_side_effect_imports` (décorateur **pur**, registre non auto-peuplé) · `file_budgets`. — *preuve : `test_evaluation_imports_are_allowed` + `test_fresh_registry_is_empty` + suite archi verte*
+- [~] **`no-orphan métrique↔section`** : à la 1ʳᵉ section (couche 7, T1).
+
+**Validation inter-couches :** voir `MIGRATION_PLAN.md` §3-T1 (1 CER → `RunResult` → HTML déterministe de bout en bout).
+
+- [x] **WER/MER** (impl maison déterministe + **parité jiwer**, 15 cas) au socle texte. — *preuve : `test_metrics_text` (valeurs main) + `test_metrics_parity` (vs jiwer)*
+- [x] **Profils de normalisation** (`normalization_profile`/`char_exclude`) honorés par le runner (couche 2 `formats/text`), symétriques GT/hyp ; **1 chargement par signature**. — *preuve : `test_runner` (caseless→0 ; profil inconnu→erreur) ; démo : vue `francais_medieval`*
+- [x] **`cross_engine` + stats** : passe inter-moteurs (`CrossEngineContext`) → `RunResult.cross_engine` (clés `vue:métrique:test`) ; significativité **Wilcoxon/Friedman** (`scipy`). — *preuve : `test_metrics_stats` + `test_runner` (`text:cer:significance_p`)*
+- [~] **Surface encore différée** : `compare` + sections engines/cross (T2.f) ; structure (T5) ; longitudinal/philologie/taxo/économie (T7).
+
+---
+
+*Référence : décisions actées en session de conception couche 3, réconciliées avec
+`CLAUDE.md`. Enveloppe (contrats §3,§5-9) plein-scope maintenant ; surface remplie
+par tranches (§15). Le reste émerge sous test (§13).*
diff --git a/cinoc/evaluation/__init__.py b/cinoc/evaluation/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6f01d1ee3f0fd1b2256f273653c01f39e700878a
--- /dev/null
+++ b/cinoc/evaluation/__init__.py
@@ -0,0 +1,34 @@
+"""Couche 3 — ``evaluation`` : métriques, registre type-driven, runner, RunResult.
+
+``__init__`` mince, sans effet de bord : le registre ne s'auto-peuple pas
+(``register_default_metrics`` est explicite).
+"""
+
+from __future__ import annotations
+
+from cinoc.evaluation.context import DocContext
+from cinoc.evaluation.errors import EvaluationError
+from cinoc.evaluation.metric import DocumentMetric, document_metric
+from cinoc.evaluation.registry import MetricRegistry, register_default_metrics
+from cinoc.evaluation.result import (
+    MetricScore,
+    PipelineResult,
+    RunDocumentResult,
+    RunResult,
+)
+from cinoc.evaluation.runner import PipelineOutputs, evaluate_run
+
+__all__ = [
+    "DocContext",
+    "DocumentMetric",
+    "EvaluationError",
+    "MetricRegistry",
+    "MetricScore",
+    "PipelineOutputs",
+    "PipelineResult",
+    "RunDocumentResult",
+    "RunResult",
+    "document_metric",
+    "evaluate_run",
+    "register_default_metrics",
+]
diff --git a/cinoc/evaluation/_alignment.py b/cinoc/evaluation/_alignment.py
new file mode 100644
index 0000000000000000000000000000000000000000..719accfa004d4deea5d33d57379e62331f19bc1c
--- /dev/null
+++ b/cinoc/evaluation/_alignment.py
@@ -0,0 +1,42 @@
+"""Primitives d'alignement caractère partagées (couche 3) — une seule source.
+
+Le runner distribue à chaque collecteur le **même** ``(référence, hypothèse)``
+normalisé ; sans ce module, plusieurs collecteurs réouvraient leur propre boucle
+d'opcodes ``rapidfuzz`` pour recompter substitutions/suppressions/insertions au
+**caractère** (et le char-MER en dérivait à deux endroits — ``metrics/conformity``
+et ``correction``). On mutualise ici la primitive ; la **forme** (comptes S/D/I,
+dénominateur ``H+S+D+I`` borné) est figée par ``tests/evaluation/test_char_mer_anchor``.
+"""
+
+from __future__ import annotations
+
+from rapidfuzz.distance import Levenshtein
+
+
+def char_counts(reference: str, hypothesis: str) -> tuple[int, int, int]:
+    """``(substitutions, suppressions, insertions)`` de l'alignement caractère."""
+    substitutions = deletions = insertions = 0
+    for op in Levenshtein.editops(reference, hypothesis):
+        if op.tag == "replace":
+            substitutions += 1
+        elif op.tag == "delete":
+            deletions += 1
+        else:
+            insertions += 1
+    return substitutions, deletions, insertions
+
+
+def char_mer(reference: str, hypothesis: str) -> tuple[float, int, int]:
+    """``(cmer, edits, dénominateur)`` — Match Error Rate caractère (SPEC_HIPE §4.1).
+
+    ``cmer = (S+D+I) / (H+S+D+I)``, borné ``[0, 1]`` ; dénominateur
+    ``H+S+D+I = len(reference) + insertions`` (l'alignement complet de la
+    référence donne ``H+S+D = len(reference)``). Deux textes vides → ``(0.0, 0, 0)``.
+    """
+    substitutions, deletions, insertions = char_counts(reference, hypothesis)
+    total = len(reference) + insertions
+    edits = substitutions + deletions + insertions
+    return (edits / total if total else 0.0), edits, total
+
+
+__all__ = ["char_counts", "char_mer"]
diff --git a/cinoc/evaluation/_view_collectors.py b/cinoc/evaluation/_view_collectors.py
new file mode 100644
index 0000000000000000000000000000000000000000..b9a99dcc11d995a833b39563432dde5ba39f7de2
--- /dev/null
+++ b/cinoc/evaluation/_view_collectors.py
@@ -0,0 +1,134 @@
+"""Cycle de vie des **collecteurs de vue** du runner (couche 3).
+
+``evaluate_run`` instancie ~13 collecteurs stateful par vue, leur fait
+``observe`` un par document × pipeline, puis ``build`` un payload d'analyse.
+Cet enchaînement (instancier → observer → bâtir) est ici **regroupé** en un seul
+objet cohésif : le runner n'a plus à câbler chaque collecteur à la main. Sortie
+**identique** — pur déplacement de l'orchestration (les analyses sont triées en
+aval, l'ordre d'ajout est sans effet).
+
+Les analyses **autonomes** (calibration, économie, correction, conformité) ne
+sont pas des collecteurs (elles lisent ``corpus``/``pipeline_outputs``/``usage``
+directement) et restent dans ``evaluate_run``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+
+from cinoc.domain.evaluation import EvaluationView
+from cinoc.evaluation.context import DocContext
+from cinoc.evaluation.diagnostics import DiagnosticsCollector
+from cinoc.evaluation.document_hallucination import DocumentHallucinationCollector
+from cinoc.evaluation.document_lines import DocumentLinesCollector
+from cinoc.evaluation.document_texts import DocumentTextsCollector
+from cinoc.evaluation.inter_engine import InterEngineCollector
+from cinoc.evaluation.lines import LinesCollector, newline_preserved
+from cinoc.evaluation.markers import MarkerCollector
+from cinoc.evaluation.ner import EntitiesCollector, EntitySet
+from cinoc.evaluation.result import Analysis, MetricScore
+from cinoc.evaluation.roman import RomanNumeralsCollector
+from cinoc.evaluation.structured_data import StructuredDataCollector
+from cinoc.evaluation.taxonomy import TaxonomyCollector
+from cinoc.evaluation.textual_fidelity import TextualFidelityCollector
+from cinoc.evaluation.word_errors import WordErrorCollector
+
+
+class ViewCollectors:
+    """Les collecteurs stateful d'**une** vue : instancier → observer → bâtir.
+
+    Une instance par vue. ``observe`` est appelé une fois par (pipeline,
+    document) avec les contextes texte/entités déjà calculés par le runner ;
+    ``build`` rend les payloads d'analyse non vides de la vue.
+    """
+
+    def __init__(self, view: EvaluationView) -> None:
+        self.diagnostics = DiagnosticsCollector()
+        self.taxonomy = TaxonomyCollector()
+        self.doc_hallucination = DocumentHallucinationCollector()
+        self.doc_texts = DocumentTextsCollector()
+        self.structured = StructuredDataCollector()
+        self.markers = MarkerCollector()
+        self.roman = RomanNumeralsCollector()
+        self.textual_fidelity = TextualFidelityCollector()
+        self.inter_engine = InterEngineCollector()
+        self.word_errors = WordErrorCollector()
+        self.entities = EntitiesCollector()
+        # Distribution par ligne : applicable seulement si la normalisation de
+        # la vue préserve les sauts de ligne (sonde comportementale).
+        preserves_newlines = newline_preserved(view)
+        self.lines = LinesCollector(enabled=preserves_newlines)
+        self.doc_lines = DocumentLinesCollector(enabled=preserves_newlines)
+
+    def observe(
+        self,
+        pipeline_name: str,
+        document_id: str,
+        scores: Sequence[MetricScore],
+        text_context: DocContext | None,
+        entity_context: DocContext | None,
+    ) -> None:
+        """Diffuse un document à tous les collecteurs applicables (fan-out)."""
+        if (
+            entity_context is not None
+            and isinstance(entity_context.reference, EntitySet)
+            and isinstance(entity_context.hypothesis, EntitySet)
+        ):
+            self.entities.observe(
+                pipeline_name,
+                entity_context.reference,
+                entity_context.hypothesis,
+            )
+        if text_context is None:
+            return
+        ref = str(text_context.reference)
+        hyp = str(text_context.hypothesis)
+        self.diagnostics.observe(pipeline_name, document_id, ref, hyp)
+        self.taxonomy.observe(pipeline_name, ref, hyp)
+        self.doc_hallucination.observe(pipeline_name, document_id, ref, hyp)
+        self.structured.observe(pipeline_name, ref, hyp)
+        self.markers.observe(pipeline_name, ref, hyp)
+        self.roman.observe(pipeline_name, ref, hyp)
+        self.lines.observe(pipeline_name, ref, hyp)
+        self.doc_lines.observe(pipeline_name, document_id, ref, hyp)
+        self.textual_fidelity.observe(pipeline_name, document_id, ref, hyp)
+        self.inter_engine.observe(pipeline_name, document_id, ref, hyp)
+        self.word_errors.observe(pipeline_name, document_id, ref, hyp)
+        cer = next((s.value for s in scores if s.metric == "cer"), None)
+        self.doc_texts.observe(pipeline_name, document_id, ref, hyp, cer)
+
+    def build(
+        self,
+        view_name: str,
+        document_ids: Sequence[str],
+        cer_series: Mapping[str, list[MetricScore]],
+    ) -> list[Analysis]:
+        """Payloads non vides de la vue (ordre indifférent : tri en aval)."""
+        out: list[Analysis] = []
+        diagnostic = self.diagnostics.build(
+            view_name, "cer", list(document_ids), cer_series
+        )
+        taxonomy_analysis = self.taxonomy.build(view_name)
+        # L'inter-moteurs lit les comptages taxonomy de la même vue (zéro
+        # re-classification) — il doit donc être bâti après ``taxonomy``.
+        inter_engine_analysis = self.inter_engine.build(view_name, taxonomy_analysis)
+        candidates = [
+            diagnostic,
+            taxonomy_analysis,
+            self.doc_hallucination.build(view_name),
+            inter_engine_analysis,
+            self.word_errors.build(view_name),
+            self.structured.build(view_name),
+            self.markers.build(view_name),
+            self.roman.build(view_name),
+            self.textual_fidelity.build(view_name),
+            self.lines.build(view_name),
+            self.doc_lines.build(view_name),
+            self.entities.build(view_name),
+            self.doc_texts.build(view_name),
+        ]
+        out.extend(analysis for analysis in candidates if analysis is not None)
+        return out
+
+
+__all__ = ["ViewCollectors"]
diff --git a/cinoc/evaluation/analysis.py b/cinoc/evaluation/analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..20e14d5af2fe76eb9161f3b1bbedb8349ac4005a
--- /dev/null
+++ b/cinoc/evaluation/analysis.py
@@ -0,0 +1,1079 @@
+"""Canal « analyses » du ``RunResult`` — résultats **non scalaires** (couche 3).
+
+Contrat E2 (``PLAN_PARITE.md`` §1) : les scalaires ``MetricScore`` restent la
+seule monnaie de classement/historique ; ``analyses`` porte le **contexte
+structuré** (inférentiel, diagnostics…), calculé dans ``evaluation/`` et
+seulement **lu** par les rapports. Chaque famille ajoute son payload Pydantic
+figé ici, discriminé par ``kind``, dans le même commit que son calcul et son
+consommateur (garde-fou « pas de consommateur = supprimé »).
+
+Familles : ``inference`` (verdict statistique corrigé multi-comparaisons),
+``economics`` (coûts, débit, Pareto), ``diagnostics`` (confusions, pires
+lignes, documents difficiles), ``calibration`` (ECE/MCE), ``taxonomy``
+(classes d'erreurs par règles pures — quelles erreurs, pas seulement combien).
+"""
+
+from __future__ import annotations
+
+from typing import Annotated, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class PipelineRank(BaseModel):
+    """Rang moyen d'un pipeline sur les cas complets (petit = meilleur)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    pipeline: str = Field(min_length=1, max_length=128)
+    mean_rank: float = Field(ge=1)
+
+
+class PipelineInterval(BaseModel):
+    """IC bootstrap (percentile, graine fixe) de la moyenne d'un pipeline."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    pipeline: str = Field(min_length=1, max_length=128)
+    mean: float
+    lower: float
+    upper: float
+    #: Nombre de documents valides du pipeline (marginal, ≠ cas complets).
+    n_documents: int = Field(ge=1)
+
+
+class PairwiseDifference(BaseModel):
+    """Verdict Nemenyi d'une paire : écart de rangs vs distance critique."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    a: str = Field(min_length=1, max_length=128)
+    b: str = Field(min_length=1, max_length=128)
+    rank_gap: float = Field(ge=0)
+    significant: bool
+
+
+class InferencePayload(BaseModel):
+    """Inférentiel d'une (vue × métrique) : rangs, Nemenyi, IC bootstrap.
+
+    ``critical_distance``/``tied_groups``/``pairwise`` ne sont renseignés qu'à
+    **k ≥ 3 pipelines** (le post-hoc corrige les comparaisons multiples après
+    Friedman) ; à k = 2 le scalaire ``significance_p`` (Wilcoxon) reste le
+    verdict, et seuls rangs + intervalles sont portés.
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    kind: Literal["inference"] = "inference"
+    metric: str = Field(min_length=1, max_length=128)
+    alpha: float = Field(gt=0, lt=1)
+    #: Cas complets (documents où tous les pipelines ont une valeur).
+    n_documents: int = Field(ge=0)
+    critical_distance: float | None = Field(default=None, ge=0)
+    q_alpha: float | None = Field(default=None, ge=0)
+    #: Transparence : q_α extrapolé au-delà de la table (k > 50).
+    q_alpha_extrapolated: bool = False
+    #: Triés par (rang, pipeline) croissants — ordre déterministe.
+    mean_ranks: tuple[PipelineRank, ...] = ()
+    #: Groupes maximaux d'indiscernables (fenêtre ≤ CD sur les rangs triés).
+    tied_groups: tuple[tuple[str, ...], ...] = ()
+    #: Paires triées (a < b par nom).
+    pairwise: tuple[PairwiseDifference, ...] = ()
+    #: Triés par pipeline — ordre déterministe.
+    intervals: tuple[PipelineInterval, ...] = ()
+
+
+class PipelineEconomics(BaseModel):
+    """Ressources et coût estimé d'un pipeline sur le run (par vue : CER joint).
+
+    ``cost_eur`` est **indicatif** : temps machine (durée mesurée × taux
+    horaire) + jetons cloud au tarif de la table ; ``None`` si un étage cloud
+    a un modèle absent de la table (jamais un zéro silencieux — ``basis`` le
+    dit). Tous les nombres sont des fonctions auditables des mesures E1.
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    pipeline: str = Field(min_length=1, max_length=128)
+    n_documents: int = Field(ge=0)
+    duration_seconds: float | None = Field(default=None, ge=0)
+    tokens_in: int | None = Field(default=None, ge=0)
+    tokens_out: int | None = Field(default=None, ge=0)
+    cost_eur: float | None = Field(default=None, ge=0)
+    #: « machine » · « machine+jetons » · « tarif inconnu : <kind:model> ».
+    basis: str = Field(min_length=1, max_length=256)
+    cer: float | None = None
+    #: Erreurs estimées sur la vue : Σ (cer_doc × poids_doc) — auditable.
+    estimated_errors: float | None = Field(default=None, ge=0)
+    pages_per_hour: float | None = Field(default=None, ge=0)
+    #: Débit corrigé du temps de correction des erreurs résiduelles.
+    pages_per_hour_effective: float | None = Field(default=None, ge=0)
+
+
+class MarginalCost(BaseModel):
+    """Coût marginal d'un pipeline vs le moins cher : € par erreur évitée."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    pipeline: str = Field(min_length=1, max_length=128)
+    baseline: str = Field(min_length=1, max_length=128)
+    cost_delta_eur: float
+    errors_avoided: float
+    #: ``None`` si le surcoût n'évite aucune erreur (dominé).
+    eur_per_avoided_error: float | None = Field(default=None, ge=0)
+
+
+class EconomicsPayload(BaseModel):
+    """Économie d'un run sous une vue : coûts, débits, fronts de Pareto.
+
+    La péremption de la table de tarifs est évaluée contre ``completed_at``
+    du manifeste (déterministe — pas d'horloge au rendu).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    kind: Literal["economics"] = "economics"
+    #: Axe qualité des fronts de Pareto (la métrique phare de la vue).
+    metric: str = Field(min_length=1, max_length=128)
+    currency: str = Field(min_length=1, max_length=8)
+    hourly_rate_eur: float = Field(ge=0)
+    time_per_error_seconds: float = Field(ge=0)
+    pricing_valid_until: str = Field(min_length=1, max_length=32)
+    pricing_stale: bool
+    pipelines: tuple[PipelineEconomics, ...] = ()
+    #: Non-dominés sur (métrique, coût) puis (métrique, durée) — tri stable.
+    pareto_cost: tuple[str, ...] = ()
+    pareto_speed: tuple[str, ...] = ()
+    marginal: tuple[MarginalCost, ...] = ()
+
+
+class CharConfusion(BaseModel):
+    """Substitution récurrente : caractère attendu → caractère produit."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    expected: str = Field(min_length=1, max_length=8)
+    observed: str = Field(min_length=1, max_length=8)
+    count: int = Field(ge=1)
+
+
+class PipelineConfusions(BaseModel):
+    """Top des confusions d'un pipeline sur le corpus (tri : -count, paire)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    pipeline: str = Field(min_length=1, max_length=128)
+    pairs: tuple[CharConfusion, ...] = ()
+
+
+class WorstLine(BaseModel):
+    """Une des pires lignes du corpus : où ça casse, texte à l'appui.
+
+    Les extraits sont **verbatim** (tronqués) des représentations normalisées
+    déjà chargées pour le scoring — aucun re-calcul au rendu.
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    pipeline: str = Field(min_length=1, max_length=128)
+    document_id: str = Field(min_length=1, max_length=256)
+    line_index: int = Field(ge=0)
+    cer: float = Field(ge=0)
+    reference: str = Field(max_length=160)
+    hypothesis: str = Field(max_length=160)
+
+
+class HardDocument(BaseModel):
+    """Document le plus difficile : CER moyen sur les pipelines scorés."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    document_id: str = Field(min_length=1, max_length=256)
+    mean_cer: float = Field(ge=0)
+    n_pipelines: int = Field(ge=1)
+
+
+class DiagnosticsPayload(BaseModel):
+    """Diagnostic d'erreurs d'une vue : confusions, pires lignes, difficulté."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    kind: Literal["diagnostics"] = "diagnostics"
+    metric: str = Field(min_length=1, max_length=128)
+    confusions: tuple[PipelineConfusions, ...] = ()
+    worst_lines: tuple[WorstLine, ...] = ()
+    hardest_documents: tuple[HardDocument, ...] = ()
+
+
+class CalibrationBin(BaseModel):
+    """Bin de fiabilité : confiance moyenne vs exactitude observée."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    lower: float = Field(ge=0, le=1)
+    upper: float = Field(ge=0, le=1)
+    mean_confidence: float = Field(ge=0, le=1)
+    accuracy: float = Field(ge=0, le=1)
+    count: int = Field(ge=1)
+
+
+class PipelineCalibration(BaseModel):
+    """Calibration des confidences d'un pipeline sur le corpus.
+
+    ECE = Σ (n_b/N)·|acc_b − conf_b| ; MCE = max |acc_b − conf_b| sur les bins
+    non vides. « Correct » = le mot du jeton apparaît (multi-ensemble, exact)
+    dans la référence du document — proxy auditable, documenté.
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    pipeline: str = Field(min_length=1, max_length=128)
+    n_tokens: int = Field(ge=1)
+    ece: float = Field(ge=0, le=1)
+    mce: float = Field(ge=0, le=1)
+    bins: tuple[CalibrationBin, ...] = ()
+
+
+class CalibrationPayload(BaseModel):
+    """Fiabilité des auto-estimations moteur, par pipeline (vue texte)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    kind: Literal["calibration"] = "calibration"
+    n_bins: int = Field(ge=2)
+    pipelines: tuple[PipelineCalibration, ...] = ()
+
+
+class TaxonomyCount(BaseModel):
+    """Occurrences d'une classe d'erreur."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    label: str = Field(min_length=1, max_length=64)
+    count: int = Field(ge=1)
+
+
+class PipelineTaxonomy(BaseModel):
+    """Répartition des classes d'erreurs d'un pipeline sur le corpus."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    pipeline: str = Field(min_length=1, max_length=128)
+    total_errors: int = Field(ge=1)
+    #: Classes présentes seulement, dans l'ordre canonique de ``CLASSES``.
+    counts: tuple[TaxonomyCount, ...] = ()
+
+
+class TaxonomyPayload(BaseModel):
+    """Taxonomie d'erreurs d'une vue (classification par règles pures)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    kind: Literal["taxonomy"] = "taxonomy"
+    #: Ordre canonique de rendu (vocabulaire fermé, cf. ``evaluation.taxonomy``).
+    classes: tuple[str, ...] = ()
+    pipelines: tuple[PipelineTaxonomy, ...] = ()
+
+
+class HallucinatedBlock(BaseModel):
+    """Segment contigu de la sortie sans correspondance dans le GT (mots ajoutés)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    start_token: int = Field(ge=0)
+    end_token: int = Field(ge=0)
+    text: str = Field(min_length=1, max_length=4000)
+
+
+class PipelineHallucination(BaseModel):
+    """Détection d'hallucination d'un pipeline sur **un document**.
+
+    ``anchor_score`` = part des trigrammes de la sortie présents dans le GT (haut
+    = ancré) ; ``length_ratio`` = caractères sortie / GT (>1,2 = signal) ;
+    ``net_insertion_rate`` = mots de la sortie absents du GT / mots sortie ;
+    ``blocks`` = segments inventés affichés. ``is_hallucinating`` = ancrage faible
+    **ou** longueur anormale (seuils = conventions, cf. ``document_hallucination``).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    pipeline: str = Field(min_length=1, max_length=128)
+    anchor_score: float = Field(ge=0, le=1)
+    length_ratio: float = Field(ge=0)
+    net_insertion_rate: float = Field(ge=0, le=1)
+    gt_words: int = Field(ge=0)
+    hyp_words: int = Field(ge=0)
+    is_hallucinating: bool
+    blocks: tuple[HallucinatedBlock, ...] = ()
+
+
+class DocumentHallucination(BaseModel):
+    """Analyse d'hallucination **d'un document**, par pipeline."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    document_id: str = Field(min_length=1, max_length=256)
+    pipelines: tuple[PipelineHallucination, ...] = ()
+
+
+class DocumentHallucinationPayload(BaseModel):
+    """Hallucinations **par document** : ancrage + blocs inventés du détail document."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    kind: Literal["document_hallucination"] = "document_hallucination"
+    documents: tuple[DocumentHallucination, ...] = ()
+
+
+#: Plafond de caractères par texte embarqué (borne de sûreté ; une page dense
+#: tient largement dessous — au-delà, tronqué). Le payload porte **tous** les
+#: documents scorés (cf. ``DocumentTextsCollector``), pas seulement les pires.
+_MAX_TEXT_CHARS = 40000
+
+
+class DocumentTexts(BaseModel):
+    """Textes complets d'**un** document (vérité-terrain + sortie par moteur).
+
+    Embarqués pour **tous les documents scorés** (ordre pires-d'abord), chaque
+    texte borné à ``_MAX_TEXT_CHARS`` (sûreté). Normalisés (mêmes représentations
+    que le scoring) → le diff côte à côte reflète ce qui est mesuré.
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    document_id: str = Field(min_length=1, max_length=256)
+    reference: str = Field(max_length=_MAX_TEXT_CHARS)
+    #: ``(pipeline, hypothèse)`` ordonnés — pour le sélecteur de moteur du diff.
+    hypotheses: tuple[tuple[str, str], ...] = ()
+
+
+class DocumentTextsPayload(BaseModel):
+    """Textes complets des pires documents d'une vue (diff pleine page, borné)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    kind: Literal["document_texts"] = "document_texts"
+    documents: tuple[DocumentTexts, ...] = ()
+
+
+class DocumentLines(BaseModel):
+    """CER **par ligne** d'un document, par pipeline (heatmap recentrée sur le doc).
+
+    ``pipelines`` = ``(pipeline, CER de chaque ligne GT)`` ordonnés par pipeline
+    (déterminisme). Les CER par ligne viennent de l'alignement Levenshtein des
+    lignes (``aligned_line_cers``) — mêmes lignes que le scoring.
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    document_id: str = Field(min_length=1, max_length=256)
+    pipelines: tuple[tuple[str, tuple[float, ...]], ...] = ()
+
+
+class DocumentLinesPayload(BaseModel):
+    """CER par ligne **par document** : heatmap positionnelle du détail document."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    kind: Literal["document_lines"] = "document_lines"
+    documents: tuple[DocumentLines, ...] = ()
+
+
+class PipelineConformity(BaseModel):
+    """Scores de conformité HIPE d'un pipeline (vue ``hipe``).
+
+    ``cmer``/``wmer`` micro = somme des comptes puis ratio ; macro = moyenne des
+    scores par-document (``None``-exclus) — les deux conventions du scorer
+    (SPEC_HIPE §4.1). ``delta_norm = cmer(raw) − cmer(hipe)`` : part d'erreur
+    imputable à casse/ponctuation/formes mappées ; ``delta_heritage =
+    cmer(heritage) − cmer(hipe)`` : part des seuls mappings patrimoniaux.
+    ``n_missing`` = documents sans sortie scorée sur la vue ``hipe`` — exposé
+    (jamais un silence) ; leur matérialisation « sortie vide = erreur max »
+    (R-1.8) arrive avec le bilan de correction (les textes y sont disponibles).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    pipeline: str = Field(min_length=1, max_length=128)
+    cmer_micro: float | None = None
+    cmer_macro: float | None = None
+    wmer_micro: float | None = None
+    wmer_macro: float | None = None
+    delta_norm: float | None = None
+    delta_heritage: float | None = None
+    n_missing: int = Field(default=0, ge=0)
+
+
+class ConformityPayload(BaseModel):
+    """Conformité HIPE d'un run : scores officiels + deltas de normalisation.
+
+    Les noms exportés (``cmer_micro``…) suivent le scorer ; les vues sources
+    sont nommées — chaque nombre a son profil (SPEC_HIPE §7.2).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    kind: Literal["hipe"] = "hipe"
+    hipe_view: str = Field(min_length=1, max_length=128)
+    raw_view: str | None = Field(default=None, max_length=128)
+    heritage_view: str | None = Field(default=None, max_length=128)
+    pipelines: tuple[PipelineConformity, ...] = ()
+
+
+class RegressionSample(BaseModel):
+    """Une régression de correction : le LLM a dégradé ce document."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    document_id: str = Field(min_length=1, max_length=256)
+    cmer_raw: float = Field(ge=0, le=1)
+    cmer_corrected: float = Field(ge=0, le=1)
+    delta: float
+
+
+class OverNormalizedWord(BaseModel):
+    """Un mot juste à l'OCR, dégradé par le correcteur (``∅`` = supprimé)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    document_id: str = Field(min_length=1, max_length=256)
+    reference: str = Field(max_length=64)
+    corrected: str = Field(max_length=64)
+
+
+class PipelineCorrection(BaseModel):
+    """Bilan de correction d'un pipeline 2 étages (brut → corrigé), une vue.
+
+    Tous les nombres dérivent de ``cmer`` par document sur les paires
+    (GT, brut) et (GT, corrigé) — mêmes textes préparés que le scoring.
+    R-1.8 : un étage absent est **matérialisé vide** (erreur maximale) et
+    compté (``n_missing_*``) — jamais une exclusion silencieuse. Les taux
+    valent ``None`` quand leur dénominateur est nul (jamais un faux zéro).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    pipeline: str = Field(min_length=1, max_length=128)
+    n_documents: int = Field(ge=1)
+    n_missing_raw: int = Field(default=0, ge=0)
+    n_missing_corrected: int = Field(default=0, ge=0)
+    #: Triplet de non-régression (Σ = 1) + pref = improvement − regression.
+    improvement_rate: float = Field(ge=0, le=1)
+    regression_rate: float = Field(ge=0, le=1)
+    no_change_rate: float = Field(ge=0, le=1)
+    pref_score: float = Field(ge=-1, le=1)
+    n_catastrophic: int = Field(default=0, ge=0)
+    catastrophic_rate: float = Field(ge=0, le=1)
+    #: pcis (SPEC §4.2) : non borné → macro accompagnée de la médiane robuste
+    #: et du compte des valeurs extrêmes (|pcis| > 1).
+    pcis_macro: float | None = None
+    pcis_median: float | None = None
+    n_pcis_extreme: int = Field(default=0, ge=0)
+    #: Ampleur d'intervention (Koynov 2025) : CCR = MER(brut ↔ corrigé).
+    ccr: float | None = None
+    change_ratio: float | None = None
+    length_ratio: float | None = None
+    n_overedited: int = Field(default=0, ge=0)
+    #: Volume de texte inséré vs GT (R-1.3) : I/(H+S+D+I) sur (GT, corrigé).
+    char_ins_ratio: float | None = None
+    n_hallucination_heavy: int = Field(default=0, ge=0)
+    #: Absorption d'erreurs (multiset de mots GT) : flux corrigé vs introduit.
+    errors_before: int = Field(default=0, ge=0)
+    errors_after: int = Field(default=0, ge=0)
+    corrected: int = Field(default=0, ge=0)
+    introduced: int = Field(default=0, ge=0)
+    kept_wrong: int = Field(default=0, ge=0)
+    correction_rate: float | None = None
+    introduction_rate: float | None = None
+    net_improvement: int = 0
+    corrected_samples: tuple[str, ...] = ()
+    introduced_samples: tuple[str, ...] = ()
+    #: Sur-normalisation (positionnelle) : mots OCR-justes dégradés.
+    n_correct_ocr_words: int = Field(default=0, ge=0)
+    n_over_normalized: int = Field(default=0, ge=0)
+    over_normalization: float | None = None
+    over_normalized_samples: tuple[OverNormalizedWord, ...] = ()
+    #: Localité des modifications (R-2.6) : séquences d'éditions consécutives
+    #: sur (GT, corrigé) — longues séquences = réécriture de passages.
+    edit_run_median: float | None = None
+    edit_run_max: int = Field(default=0, ge=0)
+    edit_run_share: float | None = None
+    worst_regressions: tuple[RegressionSample, ...] = ()
+
+
+class CorrectionPayload(BaseModel):
+    """Bilan de correction d'une vue : que vaut l'étage LLM des pipelines ?
+
+    Présent seulement si la vue a scoré au moins un pipeline **2 étages**
+    (un ``CORRECTED_TEXT`` produit) — un pipeline mono-étage n'a pas de
+    « bilan de correction » (absence ≠ zéro muet). Les seuils sont portés
+    par le payload : chaque drapeau est auditable.
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    kind: Literal["correction"] = "correction"
+    metric: str = Field(min_length=1, max_length=128)
+    catastrophic_threshold: float = Field(gt=0)
+    overedit_threshold: float = Field(gt=0)
+    insertion_threshold: float = Field(gt=0)
+    edit_run_threshold: int = Field(gt=0)
+    pipelines: tuple[PipelineCorrection, ...] = ()
+
+
+class CategoryBreakdown(BaseModel):
+    """Restitution d'une catégorie de séquences (années, folios, montants…)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    category: str = Field(min_length=1, max_length=32)
+    n_total: int = Field(ge=1)
+    n_strict: int = Field(ge=0)
+    n_value: int = Field(ge=0)
+    strict_score: float = Field(ge=0, le=1)
+    value_score: float = Field(ge=0, le=1)
+    #: Formes GT perdues (lentille *value*), échantillon borné.
+    lost: tuple[str, ...] = ()
+
+
+class PipelineStructuredData(BaseModel):
+    """Séquences numériques restituées par un pipeline, par catégorie présente."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    pipeline: str = Field(min_length=1, max_length=128)
+    #: Catégories **présentes dans la GT** seulement, ordre canonique.
+    categories: tuple[CategoryBreakdown, ...] = ()
+
+
+class StructuredDataPayload(BaseModel):
+    """Données structurées d'une vue : la survie des dates/folios/montants.
+
+    Absent si la GT du corpus ne porte aucune séquence (adaptatif — la
+    famille ne pollue pas un corpus moderne sans signal).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    kind: Literal["structured_data"] = "structured_data"
+    pipelines: tuple[PipelineStructuredData, ...] = ()
+
+
+class MarkerPreservation(BaseModel):
+    """Préservation d'un signe (ou d'une catégorie) sur le corpus (micro).
+
+    ``sign`` porte soit le signe abréviatif (familles containment/positional),
+    soit le **nom de catégorie** (familles agrégées par catégorie : imprimé
+    ancien, archives modernes — ex. ``typographic_punctuation``).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    sign: str = Field(min_length=1, max_length=32)
+    n_total: int = Field(ge=1)
+    n_strict: int = Field(ge=0)
+    n_expansion: int = Field(ge=0)
+
+
+class PipelinePhilology(BaseModel):
+    """Préservation d'une famille de marqueurs par un pipeline (signes présents).
+
+    ``n_strict`` = forme exacte reproduite ; ``n_expansion`` = forme **ou**
+    développement (``≥ n_strict``, borne optimiste — un mot courant peut compter
+    comme développement, capé au total GT).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    pipeline: str = Field(min_length=1, max_length=128)
+    family: str = Field(min_length=1, max_length=32)
+    n_total: int = Field(ge=1)
+    n_strict: int = Field(ge=0)
+    n_expansion: int = Field(ge=0)
+    markers: tuple[MarkerPreservation, ...] = ()
+
+
+class PhilologyPayload(BaseModel):
+    """Préservation des marqueurs philologiques d'une vue (diplomatique vs
+    modernisant). Absent si la GT du corpus n'en porte aucun (adaptatif)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    kind: Literal["philology"] = "philology"
+    pipelines: tuple[PipelinePhilology, ...] = ()
+
+
+class PipelineRomanNumerals(BaseModel):
+    """Restitution des numéraux romains d'un pipeline en **5 statuts**.
+
+    Un numéral de la GT est restitué selon le premier statut applicable :
+    ``strict_preserved`` (forme exacte), ``case_changed`` (``xiv`` → ``XIV``),
+    ``j_dropped`` (``viij`` → ``viii``), ``converted_to_arabic`` (``XIV`` → ``14``)
+    ou ``lost``. Les 4 premiers **préservent la valeur** ; leur somme sur
+    ``n_total`` = score *valeur*, ``strict_preserved / n_total`` = score *strict*
+    (les deux scores du verdict 4a, dérivés ici sans double comptage — R1).
+    Les 5 compteurs somment à ``n_total`` (invariant).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    pipeline: str = Field(min_length=1, max_length=128)
+    n_total: int = Field(ge=1)
+    strict_preserved: int = Field(ge=0)
+    case_changed: int = Field(ge=0)
+    j_dropped: int = Field(ge=0)
+    converted_to_arabic: int = Field(ge=0)
+    lost: int = Field(ge=0)
+    #: Formes GT perdues (échantillon borné, verbatim).
+    lost_samples: tuple[str, ...] = ()
+
+
+class RomanNumeralsPayload(BaseModel):
+    """Numéraux romains d'une vue : la valeur a-t-elle survécu, et sous quelle
+    forme ? Absent si la GT du corpus n'en porte aucun (adaptatif).
+
+    Payload **dédié** (≠ `PhilologyPayload`) : le modèle 5-statuts ne se mappe
+    pas sur la lentille strict/expansion des marqueurs ; le forcer serait un
+    hack. Rendu par la même section « Philologie ».
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    kind: Literal["roman"] = "roman"
+    pipelines: tuple[PipelineRomanNumerals, ...] = ()
+
+
+class ModernizedVariant(BaseModel):
+    """Forme produite par le moteur pour un token GT (``∅`` = mot supprimé)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    form: str = Field(min_length=1, max_length=64)
+    count: int = Field(ge=1)
+
+
+class ModernizedToken(BaseModel):
+    """Un token GT et son taux de réécriture par un pipeline (corpus, micro).
+
+    ``rate = n_modernized / n_total`` ∈ ]0,1] — seuls les tokens **réellement
+    réécrits au moins une fois** sont embarqués (sinon la table déborderait du
+    vocabulaire entier). ``variants`` = formes produites, triées (-count, forme).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    token: str = Field(min_length=1, max_length=64)
+    n_total: int = Field(ge=1)
+    n_modernized: int = Field(ge=1)
+    rate: float = Field(gt=0, le=1)
+    variants: tuple[ModernizedVariant, ...] = ()
+
+
+class PipelineTextualFidelity(BaseModel):
+    """Fidélité textuelle d'un pipeline : tokens rares restitués + réécriture.
+
+    ``rare_recall`` = Σ min(occ. GT, occ. hyp) / occurrences rares de la GT
+    (multiset, borne le rappel par la multiplicité) ; ``None`` si la GT du
+    pipeline ne porte aucun token rare (non applicable). ``missed`` = échantillon
+    borné des tokens rares manqués (multiplicité incluse).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    pipeline: str = Field(min_length=1, max_length=128)
+    n_rare_reference: int = Field(ge=0)
+    n_rare_recalled: int = Field(ge=0)
+    rare_recall: float | None = Field(default=None, ge=0, le=1)
+    missed: tuple[str, ...] = ()
+    modernization: tuple[ModernizedToken, ...] = ()
+
+
+class TextualFidelityPayload(BaseModel):
+    """Fidélité textuelle d'une vue : tokens rares + modernisation lexicale.
+
+    Deux lectures complémentaires du même alignement mot-à-mot : le **rappel des
+    tokens rares** (noms propres, toponymes — ce qui compte en prosopographie,
+    invisible au CER global) et la **modernisation lexicale** (quelles formes
+    historiques le moteur réécrit — diagnostic de prompt LLM). ``max_freq`` borne
+    la rareté (≤ 2 = hapax + dis legomena), inscrit pour audit.
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    kind: Literal["textual_fidelity"] = "textual_fidelity"
+    max_freq: int = Field(ge=1)
+    pipelines: tuple[PipelineTextualFidelity, ...] = ()
+
+
+class EngineTokenRecall(BaseModel):
+    """Rappel multiset des tokens GT par un pipeline **seul** (corpus entier)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    pipeline: str = Field(min_length=1, max_length=128)
+    recall: float = Field(ge=0, le=1)
+
+
+class ComplementarityDocument(BaseModel):
+    """Écart oracle − meilleur moteur sur un document (où l'ensemble gagnerait)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    document_id: str = Field(min_length=1, max_length=256)
+    oracle_recall: float = Field(ge=0, le=1)
+    best_single_recall: float = Field(ge=0, le=1)
+    absolute_gap: float = Field(ge=0, le=1)
+
+
+class InterEngineComplementarity(BaseModel):
+    """Oracle bag-of-words (union des moteurs) vs meilleur moteur seul.
+
+    ``oracle_recall = Σ_token max_moteur(min(occ. GT, occ. moteur)) / Σ occ. GT``
+    — **borne supérieure optimiste** : multiset (multiplicité respectée) mais
+    **ordre ignoré** ; un vote séquentiel réel ferait au mieux autant, en
+    général moins. ``relative_gap`` = part des erreurs du meilleur moteur
+    qu'un ensemble pourrait théoriquement rattraper
+    (``absolute_gap / (1 − best)``, clampé [0,1]). Les documents dont la GT ne
+    porte aucun token sont **exclus** du dénominateur (R10 : jamais un rappel
+    1.0 sur GT vide).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    n_documents: int = Field(ge=1)
+    n_reference_tokens: int = Field(ge=1)
+    oracle_recall: float = Field(ge=0, le=1)
+    best_single_recall: float = Field(ge=0, le=1)
+    best_engine: str = Field(min_length=1, max_length=128)
+    absolute_gap: float = Field(ge=0, le=1)
+    relative_gap: float = Field(ge=0, le=1)
+    #: Triés par pipeline — ordre déterministe.
+    per_engine_recall: tuple[EngineTokenRecall, ...] = ()
+    #: Plus forts écarts oracle − meilleur (tri −gap puis doc), échantillon borné.
+    per_document: tuple[ComplementarityDocument, ...] = ()
+
+
+class TaxonomyDivergencePair(BaseModel):
+    """JS-divergence (bits, [0,1]) entre les profils d'erreurs de deux pipelines."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    a: str = Field(min_length=1, max_length=128)
+    b: str = Field(min_length=1, max_length=128)
+    divergence: float = Field(ge=0, le=1)
+
+
+class InterEngineDivergence(BaseModel):
+    """Matrice de divergence taxonomique paire-à-paire (symétrique).
+
+    ``pairs`` = triangle supérieur (``a < b`` par nom), diagonale (nulle)
+    omise ; ``max_pair`` = la paire la plus divergente, ``None`` si toutes les
+    paires sont à divergence nulle (profils identiques — aucune « paire la
+    plus divergente » à nommer).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    pairs: tuple[TaxonomyDivergencePair, ...]
+    max_pair: TaxonomyDivergencePair | None = None
+
+
+class InterEnginePayload(BaseModel):
+    """Analyse inter-moteurs d'une vue : complémentarité + divergence.
+
+    Deux lectures de « les moteurs se trompent-ils pareil ? » : l'**oracle**
+    (que rattraperait un ensemble ?) sur les tokens GT, et la **divergence JS**
+    sur les distributions de classes d'erreurs **déjà comptées** par la
+    taxonomie de la même vue (zéro re-classification). Chaque bloc est ``None``
+    quand son préalable manque (< 2 pipelines, GT sans token, taxonomie
+    absente) — jamais un zéro muet.
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    kind: Literal["inter_engine"] = "inter_engine"
+    complementarity: InterEngineComplementarity | None = None
+    taxonomy_divergence: InterEngineDivergence | None = None
+
+
+class LinePercentiles(BaseModel):
+    """Percentiles de la distribution des CER par ligne (interpolation linéaire)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    p50: float = Field(ge=0)
+    p75: float = Field(ge=0)
+    p90: float = Field(ge=0)
+    p95: float = Field(ge=0)
+    p99: float = Field(ge=0)
+
+
+class CatastrophicRate(BaseModel):
+    """Part des lignes « catastrophiques » : CER **≥ seuil** (seuil inclus).
+
+    Le seuil 1.0 compte les lignes totalement perdues (CER plafonné à 1.0) —
+    le ``>`` strict de la source le laissait à zéro pour toujours.
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    threshold: float = Field(gt=0)
+    count: int = Field(ge=0)
+    rate: float = Field(ge=0, le=1)
+
+
+class PipelineLines(BaseModel):
+    """Distribution du CER par ligne d'un pipeline (lignes GT du corpus poolées).
+
+    Lignes appariées par alignement Levenshtein **sur les listes de lignes**
+    (une insertion/suppression ne décale pas les suivantes) ; ligne GT sans
+    correspondance → CER 1.0 ; lignes hypothèse en trop ignorées. Agrégat
+    **micro** : toutes les lignes du corpus dans une seule distribution (pas
+    une moyenne de statistiques par document). ``gini`` : 0 = erreurs
+    uniformes, 1 = concentrées sur quelques lignes. ``heatmap`` = CER moyen
+    par tranche de position relative dans le document (``None`` = tranche
+    sans ligne, jamais un faux zéro).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    pipeline: str = Field(min_length=1, max_length=128)
+    line_count: int = Field(ge=1)
+    mean_cer: float = Field(ge=0)
+    gini: float = Field(ge=0, le=1)
+    percentiles: LinePercentiles
+    catastrophic: tuple[CatastrophicRate, ...] = ()
+    heatmap: tuple[float | None, ...] = ()
+
+
+class LinesPayload(BaseModel):
+    """Distribution des erreurs par ligne d'une vue.
+
+    Le CER document noie la répartition : 5 % d'erreurs uniformes (correction
+    rapide partout) et 5 % concentrées en lignes détruites (re-saisie locale)
+    ne se relisent pas pareil. **Absent si la normalisation de la vue écrase
+    les sauts de ligne** (profil « à plat ») — une distribution par ligne d'un
+    texte aplati serait un chiffre trompeur, pas une mesure.
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    kind: Literal["lines"] = "lines"
+    heatmap_bins: int = Field(ge=2)
+    pipelines: tuple[PipelineLines, ...] = ()
+
+
+class EntityCategoryScore(BaseModel):
+    """Précision/rappel/F1 d'une catégorie d'entité (PER, LOC, DATE…)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    label: str = Field(min_length=1, max_length=32)
+    precision: float = Field(ge=0, le=1)
+    recall: float = Field(ge=0, le=1)
+    f1: float = Field(ge=0, le=1)
+    #: Entités GT de la catégorie (TP + FN) — l'assiette du rappel.
+    support: int = Field(ge=1)
+
+
+class EntityMention(BaseModel):
+    """Une entité non appariée (manquée côté GT, ou hallucinée côté sortie)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    label: str = Field(min_length=1, max_length=32)
+    text: str = Field(max_length=128)
+
+
+class PipelineNer(BaseModel):
+    """Précision sur entités nommées d'un pipeline (micro global + par catégorie).
+
+    Appariement IoU ≥ seuil sur des spans **reprojetés en coordonnées GT**
+    (R14 — sans quoi le F1 mesurerait le profil d'insertion/délétion de l'OCR
+    amont, pas la survie des entités). ``hallucinated`` = entités produites
+    sans correspondance GT (utile pour les VLM/LLM qui inventent) ; ``missed``
+    = entités GT non retrouvées. La métrique mesure **conjointement** OCR + NER
+    (le modèle d'extraction faillit aussi) — limite documentée dans la section.
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    pipeline: str = Field(min_length=1, max_length=128)
+    n_reference: int = Field(ge=1)
+    true_positives: int = Field(ge=0)
+    false_positives: int = Field(ge=0)
+    false_negatives: int = Field(ge=0)
+    precision: float = Field(ge=0, le=1)
+    recall: float = Field(ge=0, le=1)
+    f1: float = Field(ge=0, le=1)
+    #: Catégories présentes (TP+FN+FP > 0), ordre alphabétique.
+    per_category: tuple[EntityCategoryScore, ...] = ()
+    missed: tuple[EntityMention, ...] = ()
+    hallucinated: tuple[EntityMention, ...] = ()
+
+
+class NerPayload(BaseModel):
+    """Précision sur entités nommées d'une vue : la survie des noms propres.
+
+    Présent seulement si au moins un pipeline a une GT entités **et** une
+    sortie entités (vue déclarant ``ner_f1``). Absent sinon (adaptatif — pas
+    de colonne vide sur un corpus sans entités).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    kind: Literal["ner"] = "ner"
+    iou_threshold: float = Field(gt=0, le=1)
+    pipelines: tuple[PipelineNer, ...] = ()
+
+
+class EngineWordError(BaseModel):
+    """Échecs d'un pipeline sur un mot GT : compte + forme produite dominante.
+
+    ``count`` = occurrences où ce pipeline n'a **pas** restitué le mot GT (tags
+    ``replace``/``delete`` de l'alignement mot-à-mot). ``variant`` = forme produite
+    **dominante** *verbatim* (``∅`` = mot supprimé) : la matière de la confusion,
+    embarquée pour le graphe « mot → variante produite » (incrément ultérieur,
+    même payload). Rien d'inventé — la variante sort de la sortie du moteur (D-094).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    pipeline: str = Field(min_length=1, max_length=128)
+    count: int = Field(ge=1)
+    variant: str = Field(min_length=1, max_length=64)
+
+
+class WordError(BaseModel):
+    """Un mot GT raté par ≥ 1 pipeline : total, détail par moteur, regroupement.
+
+    ``word`` = mot **verbatim** de la GT (minuscule — tokenisation partagée de la
+    couche). ``per_engine`` est **creux** : seuls les moteurs qui ratent le mot y
+    figurent (un moteur absent = 0 raté). ``group`` classe le recoupement
+    inter-moteurs : ``universal`` (tous les pipelines observés ratent le mot —
+    difficulté de la *matière*), ``engine_specific`` (un seul — faiblesse *moteur*),
+    ``partial`` (un sous-ensemble).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    word: str = Field(min_length=1, max_length=64)
+    total_errors: int = Field(ge=1)
+    per_engine: tuple[EngineWordError, ...] = ()
+    group: Literal["universal", "engine_specific", "partial"]
+
+
+class WordErrorPayload(BaseModel):
+    """Carte des mots d'une vue : quels mots GT chaque moteur ne restitue pas.
+
+    Le CER dit *combien* d'erreurs, pas *lesquelles*. Ici l'alignement mot-à-mot
+    (même mécanique que ``textual_fidelity``) est **croisé** sur les pipelines :
+    par mot GT, le nombre d'échecs **par moteur** + une signature de regroupement.
+    ``pipelines`` = moteurs ayant produit du texte (base du croisement, ≥ 2) ;
+    ``words`` triés (-total, mot) et **capés** aux plus durs. Absent si < 2
+    pipelines ou aucune erreur (jamais une carte vide). L'appariement dépend de la
+    **normalisation de la vue** ; une fusion/scission de mots est une limite de
+    l'alignement (documentée dans la section).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    kind: Literal["word_errors"] = "word_errors"
+    pipelines: tuple[str, ...] = Field(min_length=2)
+    words: tuple[WordError, ...] = ()
+
+
+#: Union des payloads, discriminée par ``kind`` — s'élargit d'un membre par
+#: famille, dans le même commit que le calcul et le consommateur.
+AnalysisPayload = Annotated[
+    InferencePayload
+    | EconomicsPayload
+    | DiagnosticsPayload
+    | CalibrationPayload
+    | TaxonomyPayload
+    | DocumentHallucinationPayload
+    | DocumentTextsPayload
+    | DocumentLinesPayload
+    | ConformityPayload
+    | CorrectionPayload
+    | StructuredDataPayload
+    | PhilologyPayload
+    | RomanNumeralsPayload
+    | TextualFidelityPayload
+    | InterEnginePayload
+    | LinesPayload
+    | NerPayload
+    | WordErrorPayload,
+    Field(discriminator="kind"),
+]
+
+
+class Analysis(BaseModel):
+    """Une analyse adressée : portée + vue (+ pipeline/document si local)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    scope: Literal["corpus", "pipeline", "document"]
+    view: str = Field(min_length=1, max_length=128)
+    pipeline: str | None = Field(default=None, max_length=128)
+    document_id: str | None = Field(default=None, max_length=256)
+    payload: AnalysisPayload
+
+
+__all__ = [
+    "Analysis",
+    "AnalysisPayload",
+    "CalibrationBin",
+    "CalibrationPayload",
+    "CatastrophicRate",
+    "CategoryBreakdown",
+    "CharConfusion",
+    "ComplementarityDocument",
+    "ConformityPayload",
+    "CorrectionPayload",
+    "DiagnosticsPayload",
+    "EconomicsPayload",
+    "EngineTokenRecall",
+    "EngineWordError",
+    "EntityCategoryScore",
+    "EntityMention",
+    "HardDocument",
+    "InferencePayload",
+    "InterEngineComplementarity",
+    "InterEngineDivergence",
+    "InterEnginePayload",
+    "LinePercentiles",
+    "LinesPayload",
+    "MarginalCost",
+    "MarkerPreservation",
+    "ModernizedToken",
+    "ModernizedVariant",
+    "NerPayload",
+    "OverNormalizedWord",
+    "PairwiseDifference",
+    "PhilologyPayload",
+    "PipelineCalibration",
+    "PipelineConformity",
+    "PipelineConfusions",
+    "PipelineCorrection",
+    "PipelineEconomics",
+    "PipelineInterval",
+    "PipelineLines",
+    "PipelineNer",
+    "PipelinePhilology",
+    "PipelineRank",
+    "PipelineRomanNumerals",
+    "PipelineStructuredData",
+    "PipelineTaxonomy",
+    "PipelineTextualFidelity",
+    "RegressionSample",
+    "RomanNumeralsPayload",
+    "StructuredDataPayload",
+    "TaxonomyCount",
+    "TaxonomyDivergencePair",
+    "TaxonomyPayload",
+    "TextualFidelityPayload",
+    "WordError",
+    "WordErrorPayload",
+    "WorstLine",
+]
diff --git a/cinoc/evaluation/archaic.py b/cinoc/evaluation/archaic.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c7271c0eb95d3e4d026474c104c60ecb4a1b9a3
--- /dev/null
+++ b/cinoc/evaluation/archaic.py
@@ -0,0 +1,166 @@
+"""Caractères archaïques : listes nommées, empreinte, ``air``/``hcpr`` (couche 3).
+
+Deux mesures **bidirectionnelles** sur une **liste configurable de caractères
+archaïques** (formes historiques : ``ſ`` s long, abréviations rotunda, thorn…) :
+
+- **``hcpr``** (*Historical Character Preservation Rate*, Levchenko 2025) — taux
+  de **préservation** : parmi les caractères de la liste présents dans la GT,
+  combien survivent dans la sortie. Généralisation paramétrable de
+  ``diacritic_err``/``mufi_err`` (même moteur :mod:`preservation` — parité
+  bit-à-bit), mais **côté préservation** et sur une liste **choisie**, pas une
+  plage figée.
+- **``air``** (*Archaism Insertion Rate*, Levchenko 2025) — **l'apport net** :
+  parmi les caractères de la liste présents dans la **sortie**, combien sont
+  *ajoutés* (à une position non fidèle à la GT). Détecte la **sur-historicisation**
+  — un VLM/LLM qui « archaïse » un texte que la GT écrit en clair. C'est la mesure
+  que ``mufi_err`` ne porte pas : elle regarde la sortie, pas la référence.
+
+**Dénominateur d'``air``** (décision de build, bornée [0,1]) : nombre
+d'occurrences de la liste **dans la sortie** ; numérateur = celles tombant sur une
+position **non couverte par un opcode ``equal``** (donc insérée ou substituée —
+non recopiée fidèlement de la GT). ``air = ajoutées / total_sortie`` ∈ [0,1].
+``None`` si la sortie ne porte **aucun** caractère de la liste (rien à juger).
+
+**Liste par défaut ``archaic_core``** (Q4, trans-langue, sans ambiguïté de langue
+moderne) : ``ſ ꝛ ⁊ ꝑ ꝓ ꝗ ꝙ ꝯ ꝝ ꝫ ꝭ þ ð ȝ`` + la **marque combinante** ``U+0364``
+(``◌ͤ`` e suscrit) qui forme ``aͤ oͤ uͤ`` — la marque **est** le trait archaïque,
+captée quel que soit le caractère de base (les séquences ``aͤ/oͤ/uͤ`` n'ont pas de
+forme pré-composée, elles restent décomposées : matcher la marque suffit et reste
+au niveau codepoint, comme le moteur de préservation). ``œ æ ß ç`` et les accents
+modernes sont **exclus** du défaut (relatifs à une langue : « cœur » moderne →
+faux positif ``air`` ; leur perte relève déjà de ``diacritic_err``).
+
+Reproductibilité : chaque liste a un **nom** et une **empreinte** SHA-256 de ses
+codepoints, inscrits au ``RunManifest`` et au rapport (deux runs même liste → même
+empreinte ; listes différentes → empreintes différentes).
+"""
+
+from __future__ import annotations
+
+import hashlib
+from collections.abc import Iterable
+from dataclasses import dataclass
+
+from rapidfuzz.distance import Levenshtein
+
+from cinoc.evaluation.errors import EvaluationError
+from cinoc.evaluation.metric import Observation
+from cinoc.evaluation.preservation import preservation_counts
+
+#: ``◌ͤ`` (U+0364, combining latin small letter e) — marque suscrite des formes
+#: ``aͤ oͤ uͤ`` ; représente la famille à elle seule (pas de pré-composé).
+_E_ABOVE = "ͤ"
+
+#: Listes nommées, **données** de package (≠ surface exécutable, comme les profils
+#: de normalisation). ``archaic_core`` est le seul socle livré (Q4) ; l'enveloppe
+#: porte plusieurs listes nommées, la surface n'en remplit qu'une (axe 2). Ajouter
+#: une liste curée = une entrée ici (aucune dette spéculative — on ne livre pas de
+#: liste sans consommateur).
+ARCHAIC_LISTS: dict[str, tuple[str, ...]] = {
+    "archaic_core": (
+        "ſ",  # U+017F long s
+        "ꝛ",  # U+A75B r rotunda
+        "⁊",  # U+204A tironian et
+        "ꝑ",  # U+A751 p with stroke through descender (per/par)
+        "ꝓ",  # U+A753 p with flourish (pro)
+        "ꝗ",  # U+A757 q with stroke through descender (qui)
+        "ꝙ",  # U+A759 q with diagonal stroke (quia)
+        "ꝯ",  # U+A76F con/us abbreviation
+        "ꝝ",  # U+A75D rum rotunda
+        "ꝫ",  # U+A76B et abbreviation
+        "ꝭ",  # U+A76D is abbreviation
+        "þ",  # U+00FE thorn
+        "ð",  # U+00F0 eth
+        "ȝ",  # U+021D yogh
+        _E_ABOVE,  # aͤ oͤ uͤ via la marque suscrite
+    ),
+}
+
+#: Liste active par défaut : ``air`` la mesure d'office (Q4) ; ``hcpr`` n'apparaît
+#: que sur une liste **explicitement** configurée (anti-colonne-jumelle de
+#: ``mufi_err`` — cf. :mod:`cinoc.app.run_planning`).
+DEFAULT_ARCHAIC_LIST = "archaic_core"
+
+
+def archaic_list_hash(chars: Iterable[str]) -> str:
+    """Empreinte SHA-256 **déterministe** d'un jeu de caractères archaïques.
+
+    Sur les codepoints **uniques triés** : indépendante de l'ordre/des doublons de
+    déclaration (même contenu → même empreinte), sensible au moindre ajout/retrait.
+    """
+    payload = "".join(sorted(set(chars)))
+    return hashlib.sha256(payload.encode("utf-8")).hexdigest()
+
+
+@dataclass(frozen=True)
+class ResolvedArchaicList:
+    """Liste archaïque résolue : nom curé + caractères + empreinte (manifeste)."""
+
+    name: str
+    chars: frozenset[str]
+    list_hash: str
+
+
+def resolve_archaic_list(name: str | None = None) -> ResolvedArchaicList:
+    """Résout une liste **nommée** (défaut ``archaic_core``). Fail-closed.
+
+    Un nom inconnu lève ``EvaluationError`` (jamais un repli silencieux sur le
+    défaut : une liste mal nommée fausserait ``air``/``hcpr`` sans le dire).
+    """
+    effective = name or DEFAULT_ARCHAIC_LIST
+    if effective not in ARCHAIC_LISTS:
+        known = ", ".join(sorted(ARCHAIC_LISTS))
+        raise EvaluationError(
+            f"liste archaïque inconnue : {effective!r} (connues : {known})."
+        )
+    chars = frozenset(ARCHAIC_LISTS[effective])
+    return ResolvedArchaicList(
+        name=effective, chars=chars, list_hash=archaic_list_hash(chars)
+    )
+
+
+def hcpr_observation(
+    reference: str, hypothesis: str, chars: frozenset[str]
+) -> Observation | None:
+    """Taux de **préservation** des caractères de la liste présents dans la GT.
+
+    ``(n_total − n_wrong) / n_total`` sur les comptes du moteur partagé (parité
+    ``diacritic_err``/``mufi_err``). ``None`` si la GT n'en porte aucun.
+    """
+    counts = preservation_counts(reference, hypothesis, lambda ch: ch in chars)
+    if counts is None:
+        return None
+    n_total, n_wrong = counts
+    return Observation(value=(n_total - n_wrong) / n_total, weight=n_total)
+
+
+def air_observation(
+    reference: str, hypothesis: str, chars: frozenset[str]
+) -> Observation | None:
+    """**Apport net** d'archaïsmes : part des caractères de la liste **insérés**.
+
+    Dénominateur = occurrences de la liste dans la **sortie** ; numérateur = celles
+    à une position **non** couverte par un opcode ``equal`` (insérée ou substituée,
+    donc non recopiée fidèlement de la GT). Borné [0,1]. ``None`` si la sortie n'en
+    porte aucun.
+    """
+    targets = [j for j, char in enumerate(hypothesis) if char in chars]
+    if not targets:
+        return None
+    faithful: set[int] = set()
+    for op in Levenshtein.opcodes(reference, hypothesis):
+        if op.tag == "equal":
+            faithful.update(range(op.dest_start, op.dest_end))
+    added = sum(1 for j in targets if j not in faithful)
+    return Observation(value=added / len(targets), weight=len(targets))
+
+
+__all__ = [
+    "ARCHAIC_LISTS",
+    "DEFAULT_ARCHAIC_LIST",
+    "ResolvedArchaicList",
+    "air_observation",
+    "archaic_list_hash",
+    "hcpr_observation",
+    "resolve_archaic_list",
+]
diff --git a/cinoc/evaluation/archives.py b/cinoc/evaluation/archives.py
new file mode 100644
index 0000000000000000000000000000000000000000..55f41a14f563ab6aadeff50183c00b56eddc7b77
--- /dev/null
+++ b/cinoc/evaluation/archives.py
@@ -0,0 +1,261 @@
+"""Marqueurs des **archives modernes** (XIXᵉ-XXᵉ) — données + détection (couche 3).
+
+Là où le médiéval scribal (`markers.ABBREVIATIONS`) et l'imprimé ancien
+(`markers.EARLY_MODERN`) couvrent les écritures historiques, ce module couvre les
+conventions d'abréviation des corpus institutionnels modernes : titres de
+civilité (``Mme``, ``Dr``), ordinaux (``1ᵉʳ``, ``XIXᵉ``), monnaies, abréviations
+administratives, état civil, ponctuation typographique, abréviations latines,
+bibliographie, adresses. Neuf **catégories**, ~70 marqueurs.
+
+Pourquoi un module dédié (≠ `markers.family_counts`) : ces marqueurs sont
+**multi-caractères** et exigent une **frontière de mot adaptée** (``M.`` ne doit
+pas matcher dans ``M.A.``, ``arr.`` pas dans ``arracher``) — un simple
+``str.count`` les sur-compterait. La détection est donc **regex bornée** +
+**plus-long-gagne** (``S.A.R.`` plutôt que ``S.`` + ``A.R.``).
+
+Sémantique : **containment multiset** (comme `markers`), deux lentilles —
+*strict* (la forme abrégée survit) / *expansion* (forme **ou** développement,
+borne optimiste). On compte les **occurrences** (multiset), pas une simple
+présence : une présence-par-occurrence gonflerait le score quand un ``Mme``
+devient ``Mlle`` sans le pénaliser. Tables = **constantes de module** (donnée,
+comme les profils de normalisation). Catégorie sans signe en GT → omise
+(adaptatif).
+"""
+
+from __future__ import annotations
+
+import re
+from collections import Counter
+
+#: ``(forme abrégée canonique, développements acceptés)`` par catégorie.
+#: Développements insensibles à la casse ; formes abrégées sensibles à la casse.
+CIVILITY_TITLES: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("Mme", ("Madame",)),
+    ("Mlle", ("Mademoiselle",)),
+    ("Mgr", ("Monseigneur",)),
+    ("Dr", ("Docteur",)),
+    ("Pr", ("Professeur",)),
+    ("Me", ("Maître",)),
+    ("M.", ("Monsieur",)),
+    ("R.P.", ("Révérend Père",)),
+    ("S.M.", ("Sa Majesté",)),
+    ("S.A.R.", ("Son Altesse Royale",)),
+    ("S.E.", ("Son Excellence",)),
+    ("S.S.", ("Sa Sainteté",)),
+)
+
+ORDINALS: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("1ᵉʳ", ("1er", "premier")),
+    ("1ʳᵉ", ("1re", "première", "premiere")),
+    ("2ᵈ", ("2d", "second")),
+    ("2ᵈᵉ", ("2de", "seconde")),
+    ("2ᵉ", ("2e", "deuxième", "deuxieme")),
+    ("3ᵉ", ("3e", "troisième", "troisieme")),
+    ("Iᵉʳ", ("Ier", "premier")),
+    ("Vᵉ", ("Ve", "cinquième", "cinquieme")),
+    ("XIᵉ", ("XIe", "onzième", "onzieme")),
+    ("XIIᵉ", ("XIIe", "douzième", "douzieme")),
+    ("XVIᵉ", ("XVIe", "seizième", "seizieme")),
+    ("XVIIᵉ", ("XVIIe", "dix-septième", "dix-septieme")),
+    ("XVIIIᵉ", ("XVIIIe", "dix-huitième", "dix-huitieme")),
+    ("XIXᵉ", ("XIXe", "dix-neuvième", "dix-neuvieme")),
+    ("XXᵉ", ("XXe", "vingtième", "vingtieme")),
+)
+
+CURRENCY: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("₶", ("livre tournois", "livres tournois")),
+    ("₣", ("franc", "francs")),
+    ("ƒ", ("florin", "florins")),
+    ("£", ("livre", "livres", "pound", "pounds")),
+    ("l.", ("livre", "livres")),
+    ("s.", ("sol", "sols", "sou", "sous")),
+    ("d.", ("denier", "deniers")),
+)
+
+ADMINISTRATIVE: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("arr.", ("arrondissement",)),
+    ("dép.", ("département", "departement")),
+    ("cant.", ("canton",)),
+    ("com.", ("commune",)),
+    ("reg.", ("régiment", "regiment")),
+    ("prov.", ("province",)),
+)
+
+CIVIL_STATUS: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("°", ("né", "née")),
+    ("†", ("mort", "morte", "décédé", "décédée")),
+    ("✶", ("naissance",)),
+    ("⚭", ("marié", "mariée", "épousa", "epousa")),
+    ("ép.", ("épouse", "époux", "epouse", "epoux")),
+    ("vve", ("veuve",)),
+)
+
+TYPOGRAPHIC_PUNCTUATION: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("«", ('"',)),
+    ("»", ('"',)),
+    ("—", ("-", "--")),
+    ("–", ("-",)),
+    ("…", ("...",)),
+    ("’", ("'",)),
+    ("‘", ("'",)),
+)
+
+LATIN_ABBR_MODERN: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("e.g.", ("for example", "par exemple", "exempli gratia")),
+    ("i.e.", ("c'est-à-dire", "id est", "that is")),
+    ("etc.", ("et cetera", "et caetera")),
+    ("cf.", ("confer", "voir")),
+    ("ibid.", ("ibidem",)),
+    ("op. cit.", ("opere citato", "opus citatum")),
+    ("ad lib.", ("ad libitum",)),
+    ("N.B.", ("nota bene",)),
+)
+
+BIBLIOGRAPHIC: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("vol.", ("volume",)),
+    ("t.", ("tome",)),
+    ("p.", ("page",)),
+    ("pp.", ("pages",)),
+    ("n°", ("numéro", "numero", "no")),
+    ("fasc.", ("fascicule",)),
+    ("éd.", ("édition", "edition")),
+    ("ms.", ("manuscrit",)),
+    ("f.", ("folio",)),
+    ("r°", ("recto",)),
+    ("v°", ("verso",)),
+)
+
+ADDRESS: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("bd", ("boulevard",)),
+    ("av.", ("avenue",)),
+    ("r.", ("rue",)),
+    ("pl.", ("place",)),
+    ("imp.", ("impasse",)),
+    ("fbg", ("faubourg",)),
+)
+
+#: Catégories dans l'ordre canonique de rendu (déterministe).
+_CATEGORIES: dict[str, tuple[tuple[str, tuple[str, ...]], ...]] = {
+    "civility_titles": CIVILITY_TITLES,
+    "ordinals": ORDINALS,
+    "currency": CURRENCY,
+    "administrative": ADMINISTRATIVE,
+    "civil_status": CIVIL_STATUS,
+    "typographic_punctuation": TYPOGRAPHIC_PUNCTUATION,
+    "latin_abbr_modern": LATIN_ABBR_MODERN,
+    "bibliographic": BIBLIOGRAPHIC,
+    "address": ADDRESS,
+}
+
+#: Ordre canonique des catégories — consommé par le collecteur pour l'affichage.
+CATEGORY_ORDER: tuple[str, ...] = tuple(_CATEGORIES)
+
+#: Tous les marqueurs (forme, développements, catégorie), triés par longueur
+#: décroissante : la détection préfère le plus long (``S.A.R.`` avant ``S.``).
+_ALL_MARKERS: list[tuple[str, tuple[str, ...], str]] = sorted(
+    (
+        (marker, expansions, category)
+        for category, entries in _CATEGORIES.items()
+        for marker, expansions in entries
+    ),
+    key=lambda triple: -len(triple[0]),
+)
+
+#: Marqueur → catégorie (un marqueur n'appartient qu'à une catégorie).
+_MARKER_CATEGORY: dict[str, str] = {
+    marker: category for marker, _exp, category in _ALL_MARKERS
+}
+
+# Frontières explicites pour les marqueurs à point (le ``.`` final étant non-mot,
+# ``\b`` standard matcherait dans « arr.acher ») : début/fin/blanc/ponctuation.
+_TRAILING_BOUNDARY = r"(?=$|[\s,;:!?\)\]\»\"'\n\r\t…])"
+_LEADING_BOUNDARY = r"(?:^|(?<=[\s,;:!?\(\[\«\"'\n\r\t]))"
+
+
+def _is_ascii_alnum(text: str) -> bool:
+    """Vrai si tous les caractères sont alphanumériques ASCII."""
+    return bool(text) and all(c.isascii() and c.isalnum() for c in text)
+
+
+def _compile_marker(marker: str) -> re.Pattern[str]:
+    """Pattern de détection (frontière adaptée à la composition du marqueur)."""
+    escaped = re.escape(marker)
+    if "." in marker:
+        return re.compile(_LEADING_BOUNDARY + escaped + _TRAILING_BOUNDARY)
+    if _is_ascii_alnum(marker):
+        return re.compile(r"\b" + escaped + r"\b")
+    # Unicode (exposants, monnaies, guillemets, croix) : littéral, pas de ``\b``.
+    return re.compile(escaped)
+
+
+def _compile_expansions(expansions: tuple[str, ...]) -> tuple[re.Pattern[str], ...]:
+    """Patterns des développements (insensibles à la casse ; ``\\b`` si alnum)."""
+    out: list[re.Pattern[str]] = []
+    for exp in expansions:
+        escaped = re.escape(exp)
+        if _is_ascii_alnum(exp):
+            out.append(re.compile(r"\b" + escaped + r"\b", re.IGNORECASE))
+        else:
+            out.append(re.compile(escaped, re.IGNORECASE))
+    return tuple(out)
+
+
+_MARKER_PATTERNS: dict[str, re.Pattern[str]] = {
+    marker: _compile_marker(marker) for marker, _exp, _cat in _ALL_MARKERS
+}
+_EXPANSION_PATTERNS: dict[str, tuple[re.Pattern[str], ...]] = {
+    marker: _compile_expansions(expansions) for marker, expansions, _cat in _ALL_MARKERS
+}
+
+
+def _detect(text: str) -> list[tuple[int, str]]:
+    """Marqueurs non chevauchants de ``text`` : ``[(start, marker), ...]``.
+
+    Stratégie **plus-long-gagne** à chaque position (tri ``(start, -longueur)``).
+    """
+    candidates: list[tuple[int, int, str]] = []
+    for marker, pattern in _MARKER_PATTERNS.items():
+        for match in pattern.finditer(text):
+            candidates.append((match.start(), match.end(), marker))
+    candidates.sort(key=lambda c: (c[0], -(c[1] - c[0])))
+    chosen: list[tuple[int, str]] = []
+    last_end = -1
+    for start, end, marker in candidates:
+        if start < last_end:
+            continue
+        chosen.append((start, marker))
+        last_end = end
+    return chosen
+
+
+def archival_counts(
+    reference: str, hypothesis: str
+) -> dict[str, tuple[int, int, int]]:
+    """Préservation par catégorie présente dans la GT (containment multiset).
+
+    Pour chaque catégorie présente : ``(n_total, n_strict, n_expansion)`` —
+    ``n_strict = Σ min(occurrences GT, occurrences hyp)`` du signe (frontière
+    adaptée) ; ``n_expansion`` ajoute les développements trouvés dans l'hyp,
+    capé au total GT (borne optimiste). Catégories absentes de la GT → omises.
+    """
+    gt = Counter(marker for _start, marker in _detect(reference))
+    if not gt:
+        return {}
+    hyp = Counter(marker for _start, marker in _detect(hypothesis))
+    totals: dict[str, list[int]] = {}
+    for marker, gt_n in gt.items():
+        category = _MARKER_CATEGORY[marker]
+        strict = min(gt_n, hyp.get(marker, 0))
+        expansion_hits = sum(
+            len(pattern.findall(hypothesis))
+            for pattern in _EXPANSION_PATTERNS[marker]
+        )
+        expansion = min(gt_n, hyp.get(marker, 0) + expansion_hits)
+        slot = totals.setdefault(category, [0, 0, 0])
+        slot[0] += gt_n
+        slot[1] += strict
+        slot[2] += expansion
+    return {cat: (t, s, e) for cat, (t, s, e) in totals.items()}
+
+
+__all__ = ["CATEGORY_ORDER", "archival_counts"]
diff --git a/cinoc/evaluation/calibration.py b/cinoc/evaluation/calibration.py
new file mode 100644
index 0000000000000000000000000000000000000000..0b649e39c5eef0367d1539b5cf4d6eec23dbc67d
--- /dev/null
+++ b/cinoc/evaluation/calibration.py
@@ -0,0 +1,153 @@
+"""Calibration des confidences moteur : ECE / MCE + bins (couche 3).
+
+Un moteur **calibré** a raison à hauteur de ce qu'il annonce : parmi les mots
+déclarés à 0,9 de confiance, ~90 % sont corrects. ECE (Expected Calibration
+Error) = Σ (n_b/N)·|acc_b − conf_b| sur des bins de confiance ; MCE = l'écart
+maximal. Référence : Guo et al. 2017 (*On Calibration of Modern Neural
+Networks*) — formules publiées, vérifiables à la main.
+
+« Correct » = le mot du jeton apparaît **exactement** dans le multi-ensemble
+des mots de la référence du document — proxy volontairement simple et
+auditable (pas d'alignement positionnel : un mot juste mais déplacé reste
+juste pour la recherche). Heuristique maison pour ce choix de proxy →
+valeurs de test dérivées à la main (PLAN_PARITE §5.8b).
+
+Consomme le sidecar ``CONFIDENCES`` (``ConfidenceToken``) produit par les
+moteurs qui s'auto-estiment (tesseract) ; aucun jeton sur le run → pas
+d'analyse (``None``), jamais un score fabriqué.
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+from collections.abc import Mapping
+from pathlib import Path
+
+from pydantic import TypeAdapter, ValidationError
+
+from cinoc.domain.artifacts import Artifact, ArtifactType
+from cinoc.domain.confidence import ConfidenceToken
+from cinoc.domain.corpus import CorpusSpec
+from cinoc.evaluation.analysis import (
+    Analysis,
+    CalibrationBin,
+    CalibrationPayload,
+    PipelineCalibration,
+)
+from cinoc.formats.text import read_plaintext
+
+#: Nombre de bins de fiabilité (convention usuelle).
+N_BINS = 10
+
+_TOKENS = TypeAdapter(list[ConfidenceToken])
+
+#: { pipeline: { document_id: { ArtifactType: Artifact } } } (forme du runner).
+PipelineOutputs = Mapping[str, Mapping[str, Mapping[ArtifactType, Artifact]]]
+
+
+def load_confidence_tokens(artifact: Artifact) -> list[ConfidenceToken]:
+    """Sidecar JSON → jetons ; illisible/invalide → ``[]`` (best-effort amont)."""
+    if artifact.uri is None:
+        return []
+    try:
+        return _TOKENS.validate_json(Path(artifact.uri).read_bytes())
+    except (OSError, ValueError, ValidationError):
+        return []
+
+
+def calibration_from_pairs(
+    pairs: list[tuple[float, bool]], n_bins: int = N_BINS
+) -> tuple[float, float, tuple[CalibrationBin, ...]]:
+    """``(ece, mce, bins)`` depuis des paires (confiance, correct)."""
+    buckets: list[list[tuple[float, bool]]] = [[] for _ in range(n_bins)]
+    for confidence, correct in pairs:
+        index = min(int(confidence * n_bins), n_bins - 1)
+        buckets[index].append((confidence, correct))
+    bins: list[CalibrationBin] = []
+    ece = 0.0
+    mce = 0.0
+    total = len(pairs)
+    for index, bucket in enumerate(buckets):
+        if not bucket:
+            continue
+        mean_confidence = sum(c for c, _ in bucket) / len(bucket)
+        accuracy = sum(1 for _, ok in bucket if ok) / len(bucket)
+        gap = abs(accuracy - mean_confidence)
+        ece += len(bucket) / total * gap
+        mce = max(mce, gap)
+        bins.append(
+            CalibrationBin(
+                lower=index / n_bins,
+                upper=(index + 1) / n_bins,
+                mean_confidence=mean_confidence,
+                accuracy=accuracy,
+                count=len(bucket),
+            )
+        )
+    return ece, mce, tuple(bins)
+
+
+def _reference_words(document_id: str, corpus: CorpusSpec) -> Counter[str] | None:
+    """Multi-ensemble des mots de la GT ``RAW_TEXT`` du document, si lisible."""
+    for document in corpus.documents:
+        if document.id != document_id:
+            continue
+        for truth in document.ground_truths:
+            if truth.type is ArtifactType.RAW_TEXT and truth.uri:
+                try:
+                    text = read_plaintext(Path(truth.uri).read_bytes())
+                except (OSError, ValueError):
+                    return None
+                return Counter(text.split())
+    return None
+
+
+def calibration_analysis(
+    view: str,
+    corpus: CorpusSpec,
+    pipeline_outputs: PipelineOutputs,
+) -> Analysis | None:
+    """``Analysis`` calibration de la vue ; ``None`` sans jeton de confiance."""
+    rows: list[PipelineCalibration] = []
+    for pipeline in sorted(pipeline_outputs):
+        pairs: list[tuple[float, bool]] = []
+        for document_id, artifacts in sorted(pipeline_outputs[pipeline].items()):
+            sidecar = artifacts.get(ArtifactType.CONFIDENCES)
+            if sidecar is None:
+                continue
+            tokens = load_confidence_tokens(sidecar)
+            if not tokens:
+                continue
+            reference = _reference_words(document_id, corpus)
+            if reference is None:
+                continue
+            remaining = reference.copy()
+            for token in tokens:
+                correct = remaining[token.text] > 0
+                if correct:
+                    remaining[token.text] -= 1
+                pairs.append((token.confidence, correct))
+        if not pairs:
+            continue
+        ece, mce, bins = calibration_from_pairs(pairs)
+        rows.append(
+            PipelineCalibration(
+                pipeline=pipeline,
+                n_tokens=len(pairs),
+                ece=ece,
+                mce=mce,
+                bins=bins,
+            )
+        )
+    if not rows:
+        return None
+    payload = CalibrationPayload(n_bins=N_BINS, pipelines=tuple(rows))
+    return Analysis(scope="corpus", view=view, payload=payload)
+
+
+__all__ = [
+    "N_BINS",
+    "calibration_analysis",
+    "calibration_from_pairs",
+    "load_confidence_tokens",
+]
diff --git a/cinoc/evaluation/conformity.py b/cinoc/evaluation/conformity.py
new file mode 100644
index 0000000000000000000000000000000000000000..0b2d5c88a56b88d0e2de2ed59fdb7215edb650d3
--- /dev/null
+++ b/cinoc/evaluation/conformity.py
@@ -0,0 +1,153 @@
+"""Analyse de **conformité HIPE** : payload ``hipe`` depuis les vues (couche 3).
+
+Post-passe **cross-vues** : contrairement aux autres analyses (une par vue), la
+conformité lit des résultats **déjà calculés** sur plusieurs vues — la vue de
+profil ``hipe`` (ancre, obligatoire), et si présentes une vue **brute** (sans
+profil) et une vue ``heritage`` pour les deltas de normalisation. Zéro
+re-scoring : tout vient des ``PipelineResult``/``RunDocumentResult`` produits
+par les passes par-vue (l'invariant « calculé une fois, lu ensuite »).
+
+Les vues sont reconnues par leur ``normalization_profile`` (jamais par leur
+nom) ; pour que les deltas isolent bien l'effet du profil, les vues comparées
+doivent ne différer que par lui (responsabilité de la spec, documentée).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from statistics import fmean
+
+from cinoc.domain.evaluation import EvaluationView
+from cinoc.evaluation.analysis import (
+    Analysis,
+    ConformityPayload,
+    PipelineConformity,
+)
+from cinoc.evaluation.result import PipelineResult, RunDocumentResult
+
+
+def _view_with_profile(
+    views: Sequence[EvaluationView], profile: str | None
+) -> EvaluationView | None:
+    for view in views:
+        if view.normalization_profile == profile:
+            return view
+    return None
+
+
+def _micro(
+    pipelines: Sequence[PipelineResult], view: str, pipeline: str, metric: str
+) -> float | None:
+    for result in pipelines:
+        if result.view != view or result.pipeline != pipeline:
+            continue
+        for score in result.aggregate:
+            if score.metric == metric:
+                return score.value
+    return None
+
+
+def _per_document(
+    documents: Sequence[RunDocumentResult], view: str, pipeline: str, metric: str
+) -> list[float | None]:
+    out: list[float | None] = []
+    for document in documents:
+        if document.view != view or document.pipeline != pipeline:
+            continue
+        out.append(
+            next(
+                (s.value for s in document.scores if s.metric == metric),
+                None,
+            )
+        )
+    return out
+
+
+def _macro(values: Sequence[float | None]) -> float | None:
+    """Moyenne **macro** des scores par-document (``None``-exclus) — SPEC §4.1."""
+    present = [v for v in values if v is not None]
+    return fmean(present) if present else None
+
+
+def _delta(
+    pipelines: Sequence[PipelineResult],
+    other_view: EvaluationView | None,
+    pipeline: str,
+    hipe_micro: float | None,
+) -> float | None:
+    """``cmer(autre vue) − cmer(hipe)`` ; ``None`` si l'un des deux manque."""
+    if other_view is None or hipe_micro is None:
+        return None
+    other = _micro(pipelines, other_view.name, pipeline, "cmer")
+    if other is None:
+        return None
+    return other - hipe_micro
+
+
+def conformity_analysis(
+    views: Sequence[EvaluationView],
+    pipelines: Sequence[PipelineResult],
+    documents: Sequence[RunDocumentResult],
+) -> Analysis | None:
+    """Construit le payload ``hipe``, ou ``None`` sans vue portant ``cmer``.
+
+    Ancre = la vue de profil ``hipe`` si présente (avec ``cmer``), **sinon** la
+    première vue portant ``cmer`` (le profil ``standard`` en a) → cMER/wMER
+    micro·macro s'affichent sur **tout** corpus. Les **deltas** de normalisation
+    (norm/heritage) n'ont de sens qu'avec une vraie ancre HIPE + vues
+    brute/heritage : sinon ``None``. ``wmer`` = la clé interne ``mer``.
+    """
+    hipe_view = _view_with_profile(views, "hipe")
+    if hipe_view is not None and "cmer" not in hipe_view.metric_names:
+        hipe_view = None  # vue hipe sans cmer → inutilisable comme ancre
+    anchor = hipe_view or next(
+        (v for v in views if "cmer" in v.metric_names), None
+    )
+    if anchor is None:
+        return None
+    # Deltas : seulement si l'ancre est une vraie vue HIPE (comparaison de profils).
+    raw_view = _view_with_profile(views, None) if hipe_view is not None else None
+    heritage_view = (
+        _view_with_profile(views, "heritage") if hipe_view is not None else None
+    )
+
+    order: list[str] = []
+    for result in pipelines:
+        if result.view == anchor.name and result.pipeline not in order:
+            order.append(result.pipeline)
+    if not order:
+        return None
+
+    rows: list[PipelineConformity] = []
+    for pipeline in order:
+        cmer_values = _per_document(documents, anchor.name, pipeline, "cmer")
+        cmer_micro = _micro(pipelines, anchor.name, pipeline, "cmer")
+        rows.append(
+            PipelineConformity(
+                pipeline=pipeline,
+                cmer_micro=cmer_micro,
+                cmer_macro=_macro(cmer_values),
+                wmer_micro=_micro(pipelines, anchor.name, pipeline, "mer"),
+                wmer_macro=_macro(
+                    _per_document(documents, anchor.name, pipeline, "mer")
+                ),
+                delta_norm=_delta(pipelines, raw_view, pipeline, cmer_micro),
+                delta_heritage=_delta(
+                    pipelines, heritage_view, pipeline, cmer_micro
+                ),
+                n_missing=sum(1 for v in cmer_values if v is None),
+            )
+        )
+    return Analysis(
+        scope="corpus",
+        view=anchor.name,
+        payload=ConformityPayload(
+            hipe_view=anchor.name,
+            raw_view=raw_view.name if raw_view is not None else None,
+            heritage_view=heritage_view.name if heritage_view is not None else None,
+            pipelines=tuple(rows),
+        ),
+    )
+
+
+__all__ = ["conformity_analysis"]
diff --git a/cinoc/evaluation/context.py b/cinoc/evaluation/context.py
new file mode 100644
index 0000000000000000000000000000000000000000..cdc2c5184ae849f732b527aa8b644c680c8cc3ed
--- /dev/null
+++ b/cinoc/evaluation/context.py
@@ -0,0 +1,37 @@
+"""``DocContext`` / ``CrossEngineContext`` — sacs d'entrées des métriques.
+
+- ``DocContext`` (par-document) : référence + hypothèse déjà chargées/normalisées.
+- ``CrossEngineContext`` (inter-moteurs) : pour une métrique de base, la suite des
+  valeurs par-document de chaque pipeline, **alignée par document**.
+
+Extensibles **par ajout de champ**, chacun avec son consommateur — jamais spéculé.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class DocContext:
+    """Entrées d'une métrique pour un document donné."""
+
+    document_id: str
+    reference: object
+    hypothesis: object
+
+
+@dataclass(frozen=True)
+class CrossEngineContext:
+    """Entrées d'une métrique inter-moteurs, pour une métrique de base.
+
+    ``per_pipeline`` : pour chaque pipeline, ses valeurs par-document de la
+    métrique de base, **alignées par document** (``None`` = non applicable).
+    """
+
+    metric: str
+    per_pipeline: Mapping[str, tuple[float | None, ...]]
+
+
+__all__ = ["CrossEngineContext", "DocContext"]
diff --git a/cinoc/evaluation/correction.py b/cinoc/evaluation/correction.py
new file mode 100644
index 0000000000000000000000000000000000000000..5e0b863df1f9a91fe4dbfd7a20e8eabccf680d45
--- /dev/null
+++ b/cinoc/evaluation/correction.py
@@ -0,0 +1,379 @@
+"""Bilan de **correction** : que vaut l'étage LLM d'un pipeline ? (couche 3)
+
+Fonction d'analyse par vue (pattern ``calibration_analysis``) : pour chaque
+pipeline **2 étages** (au moins un ``CORRECTED_TEXT`` produit), charge les
+textes GT / brut / corrigé, les prépare **comme au scoring** (même
+``prepare_text`` que le runner), et mesure sur les paires alignées :
+
+- **triplet de non-régression** (signe de Δcmer par document, égalités
+  strictes) + ``pref = improvement − regression`` + taux catastrophique ;
+- **pcis** (SPEC §4.2 — non borné : macro + médiane + comptage |pcis| > 1) ;
+- **ampleur d'intervention** (Koynov 2025) : CCR = MER(brut ↔ corrigé),
+  ``change_ratio``, ``length_ratio``, drapeaux ``overedited`` ;
+- **volume inséré** : ``char_ins_ratio`` = I/(H+S+D+I) sur (GT, corrigé) ;
+- **absorption d'erreurs** (multiset de mots) : corrigées / introduites /
+  conservées — le gain net ;
+- **sur-normalisation** (positionnelle, mots) : mots OCR-justes dégradés ;
+- **éditions consécutives** (R-2.6) : médiane/max/part des éditions en
+  longues séquences — la signature d'une réécriture de passage.
+
+R-1.8 : un étage absent est **matérialisé vide** (erreur maximale) + warning
+et compté — jamais d'exclusion silencieuse. Un pipeline mono-étage n'a pas de
+bilan (absence ≠ zéro muet).
+"""
+
+from __future__ import annotations
+
+import logging
+from collections import Counter
+from collections.abc import Mapping
+from statistics import fmean, median
+
+from rapidfuzz.distance import Levenshtein
+
+from cinoc.domain.artifacts import Artifact, ArtifactType
+from cinoc.domain.corpus import CorpusSpec
+from cinoc.domain.documents import DocumentRef
+from cinoc.domain.evaluation import EvaluationView
+from cinoc.evaluation._alignment import char_counts, char_mer
+from cinoc.evaluation.analysis import (
+    Analysis,
+    CorrectionPayload,
+    OverNormalizedWord,
+    PipelineCorrection,
+    RegressionSample,
+)
+from cinoc.evaluation.representations import load_representation, prepare_text
+
+logger = logging.getLogger(__name__)
+
+#: Δcmer au-delà duquel une régression est « catastrophique » (R-2.3).
+_CATASTROPHIC_THRESHOLD = 0.10
+#: ``change_ratio`` au-delà duquel le correcteur a sur-édité (R-1.9).
+_OVEREDIT_THRESHOLD = 2.0
+#: Part d'insertions au-delà de laquelle un document est « hallucination
+#: lourde » (R-1.3).
+_HEAVY_INSERTION_THRESHOLD = 0.10
+#: Longueur de séquence d'éditions au-delà de laquelle on parle de passage
+#: réécrit (R-2.6).
+_EDIT_RUN_THRESHOLD = 20
+#: Plafonds d'échantillons embarqués (payload borné).
+_MAX_TOKEN_SAMPLES = 12
+_MAX_WORD_SAMPLES = 12
+_MAX_REGRESSIONS = 10
+
+_Outputs = Mapping[str, Mapping[str, Mapping[ArtifactType, Artifact]]]
+
+
+def _edit_runs(reference: str, hypothesis: str) -> list[int]:
+    """Longueurs des séquences d'éditions **consécutives** (blocs non-``equal``
+    contigus de l'alignement) — une suppression suivie d'une insertion forme
+    une seule séquence."""
+    runs: list[int] = []
+    current = 0
+    for op in Levenshtein.opcodes(reference, hypothesis):
+        if op.tag == "equal":
+            if current:
+                runs.append(current)
+                current = 0
+            continue
+        current += max(op.src_end - op.src_start, op.dest_end - op.dest_start)
+    if current:
+        runs.append(current)
+    return runs
+
+
+def _missing(reference_words: list[str], words: list[str]) -> Counter[str]:
+    """Occurrences de mots GT absentes de ``words`` (multiset, par mot)."""
+    counts = Counter(words)
+    out: Counter[str] = Counter()
+    for word, n_ref in Counter(reference_words).items():
+        lacking = n_ref - counts.get(word, 0)
+        if lacking > 0:
+            out[word] = lacking
+    return out
+
+
+def _aligned_words(
+    reference_words: list[str], words: list[str]
+) -> list[str | None]:
+    """Mot aligné sur chaque mot GT (``None`` = supprimé) — blocs ``equal`` /
+    ``replace`` mappés positionnellement (mécanique des pires lignes F15)."""
+    aligned: list[str | None] = [None] * len(reference_words)
+    for op in Levenshtein.opcodes(reference_words, words):
+        if op.tag in ("equal", "replace"):
+            for offset in range(op.src_end - op.src_start):
+                aligned[op.src_start + offset] = words[op.dest_start + offset]
+    return aligned
+
+
+def _text_of(
+    outputs: _Outputs,
+    pipeline: str,
+    document_id: str,
+    kind: ArtifactType,
+    view: EvaluationView,
+) -> str | None:
+    artifact = outputs.get(pipeline, {}).get(document_id, {}).get(kind)
+    if artifact is None or artifact.uri is None:
+        return None
+    return prepare_text(str(load_representation(artifact.uri, kind)), view)
+
+
+def _ground_truth(document: DocumentRef, view: EvaluationView) -> str | None:
+    reference = document.gt_for(ArtifactType.RAW_TEXT)
+    if reference is None:
+        return None
+    return prepare_text(
+        str(load_representation(reference.uri, ArtifactType.RAW_TEXT)), view
+    )
+
+
+def _two_stage_pipelines(outputs: _Outputs) -> list[str]:
+    return [
+        pipeline
+        for pipeline, by_document in outputs.items()
+        if any(
+            ArtifactType.CORRECTED_TEXT in artifacts
+            for artifacts in by_document.values()
+        )
+    ]
+
+
+def _safe_ratio(numerator: float, denominator: float) -> float | None:
+    return numerator / denominator if denominator else None
+
+
+class _CorrectionAccumulator:
+    """État courant du bilan de correction d'un pipeline (**passe unique**).
+
+    ``add`` agrège un document (textes déjà préparés ``prepare_text`` ; un étage
+    absent = chaîne vide, compté R-1.8) ; ``build`` rend le ``PipelineCorrection``
+    ou ``None`` si aucun document applicable. Les ~25 cumuls interdépendants sont
+    regroupés ici : ``_pipeline_correction`` redevient une boucle lisible.
+    """
+
+    def __init__(self, pipeline: str) -> None:
+        self.pipeline = pipeline
+        self.n_documents = 0
+        self.n_missing_raw = self.n_missing_corrected = 0
+        self.improvement = self.regression = self.no_change = 0
+        self.n_catastrophic = 0
+        self.pcis_values: list[float] = []
+        self.ccr_edits = self.ccr_total = 0
+        self.n_overedited = 0
+        self.sys_insertions = self.sys_total = 0
+        self.n_heavy = 0
+        self.corrected_len = self.reference_len = 0
+        self.errors_before = self.errors_after = 0
+        self.n_corrected = self.n_introduced = self.n_kept = 0
+        self.corrected_tokens: set[str] = set()
+        self.introduced_tokens: set[str] = set()
+        self.n_correct_ocr = self.n_over_normalized = 0
+        self.over_samples: list[OverNormalizedWord] = []
+        self.runs: list[int] = []
+        self.raw_edits = self.raw_total = 0
+        self.regressions: list[RegressionSample] = []
+
+    def add(
+        self, document_id: str, reference: str, raw: str | None, corrected: str | None
+    ) -> None:
+        if raw is None:
+            self.n_missing_raw += 1
+            logger.warning(
+                "[correction] %s · %s : étage brut absent — matérialisé vide "
+                "(R-1.8).",
+                self.pipeline,
+                document_id,
+            )
+            raw = ""
+        if corrected is None:
+            self.n_missing_corrected += 1
+            logger.warning(
+                "[correction] %s · %s : étage corrigé absent — matérialisé "
+                "vide (R-1.8).",
+                self.pipeline,
+                document_id,
+            )
+            corrected = ""
+        self.n_documents += 1
+
+        cmer_raw, raw_doc_edits, raw_doc_total = char_mer(reference, raw)
+        self.raw_edits += raw_doc_edits
+        self.raw_total += raw_doc_total
+        s, d, i = char_counts(reference, corrected)
+        sys_edits, sys_denom = s + d + i, len(reference) + i
+        cmer_corrected = sys_edits / sys_denom if sys_denom else 0.0
+        self.sys_insertions += i
+        self.sys_total += sys_denom
+        if sys_denom and i / sys_denom > _HEAVY_INSERTION_THRESHOLD:
+            self.n_heavy += 1
+        self.corrected_len += len(corrected)
+        self.reference_len += len(reference)
+
+        delta = cmer_corrected - cmer_raw
+        if delta < 0:
+            self.improvement += 1
+        elif delta > 0:
+            self.regression += 1
+            self.regressions.append(
+                RegressionSample(
+                    document_id=document_id,
+                    cmer_raw=cmer_raw,
+                    cmer_corrected=cmer_corrected,
+                    delta=delta,
+                )
+            )
+        else:
+            self.no_change += 1
+        if delta > _CATASTROPHIC_THRESHOLD:
+            self.n_catastrophic += 1
+
+        # pcis (SPEC §4.2) : qualité q = 1 − cmer ; q_brut nul → clamp.
+        q_raw, q_sys = 1.0 - cmer_raw, 1.0 - cmer_corrected
+        self.pcis_values.append(
+            max(-1.0, min(1.0, q_sys)) if q_raw == 0 else (q_sys - q_raw) / q_raw
+        )
+
+        ccr_doc, edits, total = char_mer(raw, corrected)
+        self.ccr_edits += edits
+        self.ccr_total += total
+        if cmer_raw > 0 and ccr_doc / cmer_raw > _OVEREDIT_THRESHOLD:
+            self.n_overedited += 1
+
+        reference_words = reference.split()
+        raw_words, corrected_words = raw.split(), corrected.split()
+        missing_before = _missing(reference_words, raw_words)
+        missing_after = _missing(reference_words, corrected_words)
+        self.errors_before += sum(missing_before.values())
+        self.errors_after += sum(missing_after.values())
+        for word in set(missing_before) | set(missing_after):
+            before, after = missing_before.get(word, 0), missing_after.get(word, 0)
+            self.n_kept += min(before, after)
+            if before > after:
+                self.n_corrected += before - after
+                self.corrected_tokens.add(word)
+            elif after > before:
+                self.n_introduced += after - before
+                self.introduced_tokens.add(word)
+
+        aligned_raw = _aligned_words(reference_words, raw_words)
+        aligned_corrected = _aligned_words(reference_words, corrected_words)
+        for index, word in enumerate(reference_words):
+            if aligned_raw[index] != word:
+                continue
+            self.n_correct_ocr += 1
+            if aligned_corrected[index] != word:
+                self.n_over_normalized += 1
+                if len(self.over_samples) < _MAX_WORD_SAMPLES:
+                    self.over_samples.append(
+                        OverNormalizedWord(
+                            document_id=document_id,
+                            reference=word[:64],
+                            corrected=(aligned_corrected[index] or "∅")[:64],
+                        )
+                    )
+        self.runs.extend(_edit_runs(reference, corrected))
+
+    def build(self) -> PipelineCorrection | None:
+        if self.n_documents == 0:
+            return None
+        cmer_raw_micro = _safe_ratio(self.raw_edits, self.raw_total)
+        ccr_micro = _safe_ratio(self.ccr_edits, self.ccr_total)
+        big_runs = sum(r for r in self.runs if r > _EDIT_RUN_THRESHOLD)
+        return PipelineCorrection(
+            pipeline=self.pipeline,
+            n_documents=self.n_documents,
+            n_missing_raw=self.n_missing_raw,
+            n_missing_corrected=self.n_missing_corrected,
+            improvement_rate=self.improvement / self.n_documents,
+            regression_rate=self.regression / self.n_documents,
+            no_change_rate=self.no_change / self.n_documents,
+            pref_score=(self.improvement - self.regression) / self.n_documents,
+            n_catastrophic=self.n_catastrophic,
+            catastrophic_rate=self.n_catastrophic / self.n_documents,
+            pcis_macro=fmean(self.pcis_values) if self.pcis_values else None,
+            pcis_median=median(self.pcis_values) if self.pcis_values else None,
+            n_pcis_extreme=sum(1 for value in self.pcis_values if abs(value) > 1),
+            ccr=ccr_micro,
+            change_ratio=(
+                ccr_micro / cmer_raw_micro
+                if ccr_micro is not None and cmer_raw_micro
+                else None
+            ),
+            length_ratio=_safe_ratio(self.corrected_len, self.reference_len),
+            n_overedited=self.n_overedited,
+            char_ins_ratio=_safe_ratio(self.sys_insertions, self.sys_total),
+            n_hallucination_heavy=self.n_heavy,
+            errors_before=self.errors_before,
+            errors_after=self.errors_after,
+            corrected=self.n_corrected,
+            introduced=self.n_introduced,
+            kept_wrong=self.n_kept,
+            correction_rate=_safe_ratio(self.n_corrected, self.errors_before),
+            introduction_rate=_safe_ratio(self.n_introduced, self.errors_after),
+            net_improvement=self.n_corrected - self.n_introduced,
+            corrected_samples=tuple(
+                sorted(self.corrected_tokens)[:_MAX_TOKEN_SAMPLES]
+            ),
+            introduced_samples=tuple(
+                sorted(self.introduced_tokens)[:_MAX_TOKEN_SAMPLES]
+            ),
+            n_correct_ocr_words=self.n_correct_ocr,
+            n_over_normalized=self.n_over_normalized,
+            over_normalization=_safe_ratio(self.n_over_normalized, self.n_correct_ocr),
+            over_normalized_samples=tuple(self.over_samples),
+            edit_run_median=float(median(self.runs)) if self.runs else None,
+            edit_run_max=max(self.runs, default=0),
+            edit_run_share=_safe_ratio(big_runs, sum(self.runs)),
+            worst_regressions=tuple(
+                sorted(self.regressions, key=lambda r: (-r.delta, r.document_id))[
+                    :_MAX_REGRESSIONS
+                ]
+            ),
+        )
+
+
+def _pipeline_correction(
+    pipeline: str, corpus: CorpusSpec, outputs: _Outputs, view: EvaluationView
+) -> PipelineCorrection | None:
+    acc = _CorrectionAccumulator(pipeline)
+    for document in corpus.documents:
+        reference = _ground_truth(document, view)
+        if reference is None:
+            continue
+        raw = _text_of(outputs, pipeline, document.id, ArtifactType.RAW_TEXT, view)
+        corrected = _text_of(
+            outputs, pipeline, document.id, ArtifactType.CORRECTED_TEXT, view
+        )
+        acc.add(document.id, reference, raw, corrected)
+    return acc.build()
+
+
+def correction_analysis(
+    view: EvaluationView, corpus: CorpusSpec, outputs: _Outputs
+) -> Analysis | None:
+    """Payload ``correction`` de la vue, ou ``None`` sans pipeline 2 étages."""
+    rows = [
+        row
+        for pipeline in _two_stage_pipelines(outputs)
+        if (row := _pipeline_correction(pipeline, corpus, outputs, view))
+        is not None
+    ]
+    if not rows:
+        return None
+    return Analysis(
+        scope="corpus",
+        view=view.name,
+        payload=CorrectionPayload(
+            metric="cmer",
+            catastrophic_threshold=_CATASTROPHIC_THRESHOLD,
+            overedit_threshold=_OVEREDIT_THRESHOLD,
+            insertion_threshold=_HEAVY_INSERTION_THRESHOLD,
+            edit_run_threshold=_EDIT_RUN_THRESHOLD,
+            pipelines=tuple(rows),
+        ),
+    )
+
+
+__all__ = ["correction_analysis"]
diff --git a/cinoc/evaluation/diagnostics.py b/cinoc/evaluation/diagnostics.py
new file mode 100644
index 0000000000000000000000000000000000000000..565e0f4263bc5237c421418e58a3d0f4ad353c9b
--- /dev/null
+++ b/cinoc/evaluation/diagnostics.py
@@ -0,0 +1,166 @@
+"""Assemblage du diagnostic d'erreurs : confusions, pires lignes, difficulté.
+
+Collecte au fil du scoring (les représentations normalisées sont déjà
+chargées — aucun re-calcul, aucune relecture de fichier), puis assemble le
+payload ``diagnostics`` (``evaluation.analysis``). Heuristiques **maison**
+(PLAN_PARITE §5.8b : valeurs de test dérivées à la main).
+
+- **Confusions** : caractères substitués appariés positionnellement dans les
+  segments ``replace`` d'un alignement ``difflib`` — top par pipeline.
+- **Pires lignes** : lignes appariées par index, CER par ligne
+  (Levenshtein/longueur de référence) — top corpus, extraits verbatim tronqués.
+- **Documents difficiles** : CER moyen par document sur les pipelines scorés.
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+from collections.abc import Mapping, Sequence
+from difflib import SequenceMatcher
+
+from rapidfuzz.distance import Levenshtein
+
+from cinoc.evaluation.analysis import (
+    Analysis,
+    CharConfusion,
+    DiagnosticsPayload,
+    HardDocument,
+    PipelineConfusions,
+    WorstLine,
+)
+from cinoc.evaluation.result import MetricScore
+
+#: Bornes de rendu : assez pour diagnostiquer, pas un dump du corpus.
+_TOP_CONFUSIONS = 10
+_TOP_LINES = 5
+_TOP_DOCUMENTS = 5
+_EXCERPT = 160
+
+
+def char_confusions(reference: str, hypothesis: str) -> Counter[tuple[str, str]]:
+    """Paires (attendu → produit) des segments substitués, appariées par position."""
+    pairs: Counter[tuple[str, str]] = Counter()
+    matcher = SequenceMatcher(a=reference, b=hypothesis, autojunk=False)
+    for op, a0, a1, b0, b1 in matcher.get_opcodes():
+        if op != "replace":
+            continue
+        for expected, observed in zip(
+            reference[a0:a1], hypothesis[b0:b1], strict=False
+        ):
+            pairs[(expected, observed)] += 1
+    return pairs
+
+
+def line_cers(
+    reference: str, hypothesis: str
+) -> list[tuple[int, float, str, str]]:
+    """``(index, cer, ligne_ref, ligne_hyp)`` par paire de lignes (même index).
+
+    Les lignes de référence vides sont ignorées (CER indéfini) ; les lignes
+    excédentaires de l'hypothèse relèvent du scalaire ``hallucination``.
+    """
+    out: list[tuple[int, float, str, str]] = []
+    hyp_lines = hypothesis.splitlines()
+    for index, ref_line in enumerate(reference.splitlines()):
+        if not ref_line:
+            continue
+        hyp_line = hyp_lines[index] if index < len(hyp_lines) else ""
+        cer = Levenshtein.distance(ref_line, hyp_line) / len(ref_line)
+        out.append((index, cer, ref_line, hyp_line))
+    return out
+
+
+def _excerpt(text: str) -> str:
+    return text if len(text) <= _EXCERPT else text[: _EXCERPT - 1] + "…"
+
+
+class DiagnosticsCollector:
+    """Accumule confusions et lignes au fil du scoring d'une vue."""
+
+    def __init__(self) -> None:
+        self._confusions: dict[str, Counter[tuple[str, str]]] = {}
+        self._lines: list[tuple[float, str, str, int, str, str]] = []
+
+    def observe(
+        self, pipeline: str, document_id: str, reference: str, hypothesis: str
+    ) -> None:
+        bucket = self._confusions.setdefault(pipeline, Counter())
+        bucket.update(char_confusions(reference, hypothesis))
+        for index, cer, ref_line, hyp_line in line_cers(reference, hypothesis):
+            if cer > 0:
+                self._lines.append(
+                    (cer, pipeline, document_id, index, ref_line, hyp_line)
+                )
+
+    def build(
+        self,
+        view: str,
+        metric: str,
+        document_ids: Sequence[str],
+        per_pipeline_scores: Mapping[str, Sequence[MetricScore]],
+    ) -> Analysis | None:
+        """Assemble le payload ; ``None`` si rien d'observé (vue non texte)."""
+        confusions = tuple(
+            PipelineConfusions(
+                pipeline=pipeline,
+                pairs=tuple(
+                    CharConfusion(expected=e, observed=o, count=count)
+                    for (e, o), count in sorted(
+                        bucket.items(), key=lambda kv: (-kv[1], kv[0])
+                    )[:_TOP_CONFUSIONS]
+                ),
+            )
+            for pipeline, bucket in sorted(self._confusions.items())
+            if bucket
+        )
+        worst = tuple(
+            WorstLine(
+                pipeline=pipeline,
+                document_id=document_id,
+                line_index=index,
+                cer=cer,
+                reference=_excerpt(ref_line),
+                hypothesis=_excerpt(hyp_line),
+            )
+            for cer, pipeline, document_id, index, ref_line, hyp_line in sorted(
+                self._lines, key=lambda row: (-row[0], row[1], row[2], row[3])
+            )[:_TOP_LINES]
+        )
+        hardest = _hardest_documents(document_ids, per_pipeline_scores)
+        if not confusions and not worst and not hardest:
+            return None
+        payload = DiagnosticsPayload(
+            metric=metric,
+            confusions=confusions,
+            worst_lines=worst,
+            hardest_documents=hardest,
+        )
+        return Analysis(scope="corpus", view=view, payload=payload)
+
+
+def _hardest_documents(
+    document_ids: Sequence[str],
+    per_pipeline_scores: Mapping[str, Sequence[MetricScore]],
+) -> tuple[HardDocument, ...]:
+    """Top des documents par CER moyen (pipelines ayant une valeur)."""
+    rows: list[HardDocument] = []
+    for index, document_id in enumerate(document_ids):
+        values = [
+            scores[index].value
+            for scores in per_pipeline_scores.values()
+            if index < len(scores) and scores[index].value is not None
+        ]
+        if values:
+            rows.append(
+                HardDocument(
+                    document_id=document_id,
+                    mean_cer=sum(v for v in values if v is not None)
+                    / len(values),
+                    n_pipelines=len(values),
+                )
+            )
+    rows.sort(key=lambda r: (-r.mean_cer, r.document_id))
+    return tuple(rows[:_TOP_DOCUMENTS])
+
+
+__all__ = ["DiagnosticsCollector", "char_confusions", "line_cers"]
diff --git a/cinoc/evaluation/document_hallucination.py b/cinoc/evaluation/document_hallucination.py
new file mode 100644
index 0000000000000000000000000000000000000000..4e5389ed970d9e0e5c2c13a8d7be306c6c4de7a6
--- /dev/null
+++ b/cinoc/evaluation/document_hallucination.py
@@ -0,0 +1,132 @@
+"""Détection d'hallucinations **par document** (couche 3).
+
+Définition simple et exacte grâce à la **vérité-terrain** : une hallucination =
+du texte **inséré** dans la sortie qui n'a **aucune contrepartie dans le GT**. On
+l'isole par l'**alignement** des mots (GT ↔ sortie) :
+
+- un mot **mal lu** (coquille, garble) est une **substitution** (« replace ») —
+  un mot de la sortie face à un mot du GT → **ce n'est pas une hallucination** ;
+- un **passage ajouté** est une **insertion** (« insert ») — des mots de la sortie
+  alignés sur un **vide** du GT → **hallucination**.
+
+On ne signale donc que les **runs d'insertion d'au moins ``_MIN_INSERT`` mots**
+(un passage, pas un mot parasite isolé). Aucune dépendance, déterministe, lecture
+pure. Plafonds de sûreté sur le poids du payload.
+"""
+
+from __future__ import annotations
+
+import re
+from difflib import SequenceMatcher
+
+from cinoc.evaluation.analysis import (
+    Analysis,
+    DocumentHallucination,
+    DocumentHallucinationPayload,
+    HallucinatedBlock,
+    PipelineHallucination,
+)
+
+#: Longueur minimale d'un passage inséré (mots contigus absents du GT) pour le
+#: signaler — au moins une proposition, pas un mot parasite isolé.
+_MIN_INSERT = 4
+#: Trigrammes pour le score d'ancrage (contexte affiché).
+_NGRAM = 3
+#: Plafonds de sûreté (poids du payload) : passages par pipeline, longueur de texte.
+_MAX_BLOCKS = 20
+_MAX_BLOCK_CHARS = 4000
+
+
+def _tokenize(text: str) -> list[str]:
+    return re.findall(r"[^\s]+", text.lower())
+
+
+def _anchor_score(gt_tokens: list[str], hyp_tokens: list[str]) -> float:
+    """Part des trigrammes de la sortie présents dans le GT (contexte, [0,1])."""
+
+    def grams(tokens: list[str]) -> list[tuple[str, ...]]:
+        if len(tokens) < _NGRAM:
+            return [tuple(tokens)] if tokens else []
+        return [tuple(tokens[i : i + _NGRAM]) for i in range(len(tokens) - _NGRAM + 1)]
+
+    hyp_grams = grams(hyp_tokens)
+    gt_grams = set(grams(gt_tokens))
+    if not hyp_grams:
+        return 1.0 if not gt_grams else 0.0
+    if not gt_grams:
+        return 0.0
+    return sum(1 for g in hyp_grams if g in gt_grams) / len(hyp_grams)
+
+
+def _compute(
+    pipeline: str, reference: str, hypothesis: str
+) -> PipelineHallucination | None:
+    """Analyse d'un (doc, pipeline) ; ``None`` si **aucun** passage inséré.
+
+    Hallucination = run d'``insert`` (mots de la sortie sans contrepartie GT à
+    l'alignement) d'au moins ``_MIN_INSERT`` mots. Une substitution (mot mal lu)
+    n'est jamais comptée."""
+    gt_tokens = _tokenize(reference)
+    hyp_tokens = _tokenize(hypothesis)
+    matcher = SequenceMatcher(a=gt_tokens, b=hyp_tokens, autojunk=False)
+    inserted = 0
+    blocks: list[HallucinatedBlock] = []
+    for op, _a0, _a1, b0, b1 in matcher.get_opcodes():
+        if op != "insert":
+            continue  # 'replace' = mot mal lu, 'delete' = omis, 'equal' = correct
+        run = b1 - b0
+        inserted += run
+        if run >= _MIN_INSERT and len(blocks) < _MAX_BLOCKS:
+            text = " ".join(hyp_tokens[b0:b1])[:_MAX_BLOCK_CHARS]
+            blocks.append(
+                HallucinatedBlock(start_token=b0, end_token=b1 - 1, text=text)
+            )
+    if not blocks:
+        return None
+    gt_chars = len(reference.strip())
+    hyp_chars = len(hypothesis.strip())
+    length_ratio = min(hyp_chars / gt_chars, 9.99) if gt_chars else 9.99
+    return PipelineHallucination(
+        pipeline=pipeline,
+        anchor_score=_anchor_score(gt_tokens, hyp_tokens),
+        length_ratio=length_ratio,
+        net_insertion_rate=inserted / len(hyp_tokens) if hyp_tokens else 0.0,
+        gt_words=len(gt_tokens),
+        hyp_words=len(hyp_tokens),
+        is_hallucinating=True,
+        blocks=tuple(blocks),
+    )
+
+
+class DocumentHallucinationCollector:
+    """Accumule l'analyse d'hallucination par (document, pipeline) qui en présente."""
+
+    def __init__(self) -> None:
+        self._data: dict[str, dict[str, PipelineHallucination]] = {}
+
+    def observe(
+        self, pipeline: str, document_id: str, reference: str, hypothesis: str
+    ) -> None:
+        result = _compute(pipeline, reference, hypothesis)
+        if result is not None:
+            self._data.setdefault(document_id, {})[pipeline] = result
+
+    def build(self, view: str) -> Analysis | None:
+        """Payload des seuls documents où **au moins un** moteur a inséré du texte."""
+        if not self._data:
+            return None
+        documents = tuple(
+            DocumentHallucination(
+                document_id=doc,
+                pipelines=tuple(self._data[doc][p] for p in sorted(self._data[doc])),
+            )
+            for doc in sorted(self._data)
+        )
+        return Analysis(
+            scope="corpus",
+            view=view,
+            payload=DocumentHallucinationPayload(documents=documents),
+        )
+
+
+__all__ = ["DocumentHallucinationCollector"]
diff --git a/cinoc/evaluation/document_lines.py b/cinoc/evaluation/document_lines.py
new file mode 100644
index 0000000000000000000000000000000000000000..e71dad28a511db04b958ee4b5b7fee4215f8110d
--- /dev/null
+++ b/cinoc/evaluation/document_lines.py
@@ -0,0 +1,56 @@
+"""Collecteur CER **par ligne et par document** (couche 3).
+
+Mirror de ``LinesCollector`` mais **non poolé** : garde la suite des CER de ligne
+de **chaque** (document, pipeline), pour la **heatmap recentrée sur le document**
+du détail (rapport). Réutilise l'alignement de lignes (``aligned_line_cers``,
+F15) — mêmes lignes que le scoring. ``enabled=False`` (vue dont la normalisation
+écrase ``\\n``) → no-op. Déterministe.
+"""
+
+from __future__ import annotations
+
+from cinoc.evaluation.analysis import (
+    Analysis,
+    DocumentLines,
+    DocumentLinesPayload,
+)
+from cinoc.evaluation.lines import aligned_line_cers
+
+#: Plafond de lignes par (doc, pipeline) — borne de sûreté (une page tient dessous).
+_MAX_LINES = 400
+
+
+class DocumentLinesCollector:
+    """Accumule les CER de ligne par (document, pipeline) ; ``build`` → payload."""
+
+    def __init__(self, *, enabled: bool = True) -> None:
+        self._enabled = enabled
+        self._data: dict[str, dict[str, tuple[float, ...]]] = {}
+
+    def observe(
+        self, pipeline: str, document_id: str, reference: str, hypothesis: str
+    ) -> None:
+        if not self._enabled:
+            return
+        cers = aligned_line_cers(reference, hypothesis)
+        if not cers:
+            return
+        self._data.setdefault(document_id, {})[pipeline] = tuple(cers[:_MAX_LINES])
+
+    def build(self, view: str) -> Analysis | None:
+        """Payload CER de ligne par document (ordre déterministe), ``None`` si vide."""
+        if not self._data:
+            return None
+        documents = tuple(
+            DocumentLines(
+                document_id=doc,
+                pipelines=tuple(sorted(self._data[doc].items())),
+            )
+            for doc in sorted(self._data)
+        )
+        return Analysis(
+            scope="corpus", view=view, payload=DocumentLinesPayload(documents=documents)
+        )
+
+
+__all__ = ["DocumentLinesCollector"]
diff --git a/cinoc/evaluation/document_texts.py b/cinoc/evaluation/document_texts.py
new file mode 100644
index 0000000000000000000000000000000000000000..7b8941f6b2ed0363a69177b34405c22bd03bb70a
--- /dev/null
+++ b/cinoc/evaluation/document_texts.py
@@ -0,0 +1,71 @@
+"""Collecteur de **textes complets** de tous les documents scorés (couche 3).
+
+Mirror de ``DiagnosticsCollector`` : observe (pipeline, doc, ref, hyp, CER) par
+document scoré, puis ``build`` embarque **tous** les documents (ordonnés
+pires-d'abord par CER moyen) avec leurs textes (bornés par sûreté) →
+``DocumentTextsPayload``, qui alimente le **diff côte à côte** du détail document
+(rapport). Tous les docs → la vue document montre la transcription complète de
+chacun (pas seulement des pires). Déterministe.
+"""
+
+from __future__ import annotations
+
+from statistics import fmean
+
+from cinoc.evaluation.analysis import (
+    _MAX_TEXT_CHARS,
+    Analysis,
+    DocumentTexts,
+    DocumentTextsPayload,
+)
+
+#: Plafond de caractères par texte (borne de sûreté, = ``analysis._MAX_TEXT_CHARS``).
+_MAX_CHARS = _MAX_TEXT_CHARS
+
+
+class DocumentTextsCollector:
+    """Accumule les textes par document, ``build`` borne aux pires (CER moyen)."""
+
+    def __init__(self) -> None:
+        self._reference: dict[str, str] = {}
+        self._hyps: dict[str, dict[str, str]] = {}
+        self._cers: dict[str, list[float]] = {}
+
+    def observe(
+        self,
+        pipeline: str,
+        document_id: str,
+        reference: str,
+        hypothesis: str,
+        cer: float | None,
+    ) -> None:
+        self._reference.setdefault(document_id, reference[:_MAX_CHARS])
+        self._hyps.setdefault(document_id, {})[pipeline] = hypothesis[:_MAX_CHARS]
+        if cer is not None:
+            self._cers.setdefault(document_id, []).append(cer)
+
+    def build(self, view: str) -> Analysis | None:
+        """Payload de **tous** les documents scorés (CER moyen ↓), ``None`` si rien."""
+        if not self._reference:
+            return None
+
+        def _mean_cer(doc: str) -> float:
+            values = self._cers.get(doc)
+            return fmean(values) if values else 0.0
+
+        ranked = sorted(self._reference, key=lambda d: (-_mean_cer(d), d))
+        documents = tuple(
+            DocumentTexts(
+                document_id=doc,
+                reference=self._reference[doc],
+                # Hypothèses ordonnées (pipeline) — déterministe.
+                hypotheses=tuple(sorted(self._hyps.get(doc, {}).items())),
+            )
+            for doc in ranked
+        )
+        return Analysis(
+            scope="corpus", view=view, payload=DocumentTextsPayload(documents=documents)
+        )
+
+
+__all__ = ["DocumentTextsCollector"]
diff --git a/cinoc/evaluation/economics.py b/cinoc/evaluation/economics.py
new file mode 100644
index 0000000000000000000000000000000000000000..9cd70adc2cf326297219723fe40bbb92ee23de4a
--- /dev/null
+++ b/cinoc/evaluation/economics.py
@@ -0,0 +1,280 @@
+"""Économie d'un run : coûts estimés, débit effectif, Pareto (couche 3).
+
+Heuristique **maison** (héritée de l'analyse de l'implémentation source,
+relue au port — ``PLAN_PARITE.md`` §5.8b : valeurs de test dérivées à la main,
+jamais en exécutant la source). Modèle de coût simple et auditable :
+
+- **temps machine** : durée mesurée (E1, wall-clock exécuteur) × taux horaire
+  indicatif de la table — appliqué à tout pipeline (la machine est occupée) ;
+- **jetons cloud** : jetons mesurés (E1, remontés par les adapters) × tarif
+  €/MTok de la table, par (kind/modèle). Modèle absent de la table → coût
+  ``None`` + motif dans ``basis`` (jamais un zéro silencieux) ;
+- **débit effectif** : pages/h corrigé du temps de relecture des erreurs
+  résiduelles (Σ cer·poids erreurs estimées × ``time_per_error_seconds``) ;
+- **péremption** : ``valid_until`` de la table comparé à ``completed_at`` du
+  manifeste — déterministe (aucune horloge au rendu).
+
+La table vit dans ``pricing.json`` (JSON stdlib : ``yaml`` n'est pas dans la
+whitelist archi de cette couche). C'est de la **donnée datée**, pas du code.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping, Sequence
+from datetime import date
+from importlib import resources
+from typing import Any
+
+from cinoc.domain.pipeline import PipelineSpec
+from cinoc.domain.run import RunManifest
+from cinoc.evaluation.analysis import (
+    Analysis,
+    EconomicsPayload,
+    MarginalCost,
+    PipelineEconomics,
+)
+from cinoc.evaluation.errors import EvaluationError
+from cinoc.evaluation.result import DocumentUsage, MetricScore
+
+
+def load_pricing() -> dict[str, Any]:
+    """Charge la table packagée — à l'appel, pas à l'import (zéro effet de bord)."""
+    raw = (
+        resources.files("cinoc.evaluation").joinpath("pricing.json").read_bytes()
+    )
+    table = json.loads(raw)
+    if not isinstance(table, dict) or "meta" not in table:
+        raise EvaluationError("pricing.json : table de tarifs invalide.")
+    return table
+
+
+def pareto_front(
+    points: Sequence[tuple[str, float, float]],
+) -> tuple[str, ...]:
+    """Noms non dominés (deux axes **minimisés**) ; tri stable (x, y, nom).
+
+    ``p`` est dominé s'il existe ``q`` au moins aussi bon sur les deux axes et
+    strictement meilleur sur l'un.
+    """
+    front = [
+        (name, x, y)
+        for name, x, y in points
+        if not any(
+            (qx <= x and qy <= y) and (qx < x or qy < y)
+            for _, qx, qy in points
+        )
+    ]
+    return tuple(name for name, _, _ in sorted(front, key=lambda p: (p[1], p[2], p[0])))
+
+
+def _page_rate(
+    spec: PipelineSpec, pricing: Mapping[str, Any]
+) -> float | None:
+    """Tarif €/1000 pages cumulé des étages facturés à la page, sinon ``None``."""
+    table = pricing.get("cloud_page_kinds", {})
+    rates = [
+        float(table[kind]["eur_per_1k_pages"])
+        for kind in {step.adapter_name.split(":", 1)[0] for step in spec.steps}
+        if kind in table
+    ]
+    return sum(rates) if rates else None
+
+
+def _cloud_model_keys(
+    spec: PipelineSpec, adapter_kwargs: Mapping[str, Mapping[str, object]],
+    pricing: Mapping[str, Any],
+) -> list[str]:
+    """Clés ``kind/modèle`` des étages cloud du pipeline (déduplication triée).
+
+    Un *kind cloud* (facturé au jeton) = un fournisseur listé dans
+    ``default_models`` de la table — la source datée fait foi (pas de liste
+    codée en dur qui dériverait quand la table gagne un fournisseur). Les kinds
+    **à la page** vivent dans ``cloud_page_kinds`` (cf. ``_page_rate``) ; le
+    reste (``local_kinds``) : temps machine seul.
+    """
+    defaults = pricing.get("default_models", {})
+    keys: set[str] = set()
+    for step in spec.steps:
+        kind = step.adapter_name.split(":", 1)[0]
+        if kind not in defaults:
+            continue
+        kwargs = adapter_kwargs.get(step.adapter_name, {})
+        model = kwargs.get("model")
+        if not isinstance(model, str) or not model:
+            model = str(defaults.get(kind, ""))
+        keys.add(f"{kind}/{model}")
+    return sorted(keys)
+
+
+def _token_cost(
+    keys: Sequence[str],
+    tokens_in: int | None,
+    tokens_out: int | None,
+    pricing: Mapping[str, Any],
+) -> tuple[float | None, str]:
+    """``(coût jetons, basis)`` — ``None`` si un modèle est hors table."""
+    if not keys:
+        return 0.0, "machine"
+    models = pricing.get("cloud_models", {})
+    unknown = [key for key in keys if key not in models]
+    if unknown:
+        return None, f"tarif inconnu : {', '.join(unknown)}"
+    if len(keys) > 1:
+        # Les jetons E1 sont agrégés par document : à plusieurs étages cloud
+        # on ne peut pas les ventiler par modèle → coût non attribuable.
+        return None, f"jetons non ventilables : {', '.join(keys)}"
+    entry = models[keys[0]]
+    cost = (tokens_in or 0) / 1e6 * float(entry["input_eur_per_mtok"]) + (
+        tokens_out or 0
+    ) / 1e6 * float(entry["output_eur_per_mtok"])
+    return cost, "machine+jetons"
+
+
+def _estimated_errors(scores: Sequence[MetricScore]) -> float | None:
+    """Σ (cer_doc × poids_doc) — le poids étant le dénominateur du CER."""
+    pairs = [
+        (score.value, score.support or 0)
+        for score in scores
+        if score.value is not None
+    ]
+    if not pairs:
+        return None
+    return sum(value * weight for value, weight in pairs)
+
+
+def economics_analysis(
+    view: str,
+    metric: str,
+    series: Mapping[str, Sequence[MetricScore]],
+    usage: Sequence[DocumentUsage],
+    manifest: RunManifest,
+    pricing: Mapping[str, Any] | None = None,
+) -> Analysis | None:
+    """``Analysis`` économie pour une vue ; ``None`` sans mesures E1.
+
+    ``series`` : scores par-document de la métrique phare, par pipeline (les
+    mêmes que l'agrégat). ``usage`` : mesures par (pipeline × document).
+    """
+    if not usage:
+        return None
+    table = pricing if pricing is not None else load_pricing()
+    meta = table["meta"]
+    rate = float(meta["hourly_rate_local_cpu_eur"])
+    time_per_error = float(meta["time_per_error_seconds"])
+    valid_until = str(meta["valid_until"])
+    stale = manifest.completed_at.date() > date.fromisoformat(valid_until)
+
+    specs = {spec.name: spec for spec in manifest.pipeline_specs}
+    rows: list[PipelineEconomics] = []
+    for name in sorted(specs):
+        entries = [u for u in usage if u.pipeline == name]
+        if not entries:
+            continue
+        duration = sum(u.usage.duration_seconds or 0.0 for u in entries)
+        tokens_in = sum(u.usage.tokens_in or 0 for u in entries) or None
+        tokens_out = sum(u.usage.tokens_out or 0 for u in entries) or None
+        n_documents = len(entries)
+        keys = _cloud_model_keys(specs[name], manifest.adapter_kwargs, table)
+        token_cost, basis = _token_cost(keys, tokens_in, tokens_out, table)
+        page_rate = _page_rate(specs[name], table)
+        page_cost = (
+            n_documents / 1000.0 * page_rate if page_rate is not None else 0.0
+        )
+        if page_rate is not None:
+            basis = basis + "+pages" if token_cost is not None else basis
+        cost = (
+            duration / 3600.0 * rate + token_cost + page_cost
+            if token_cost is not None
+            else None
+        )
+        scores = series.get(name, ())
+        errors = _estimated_errors(scores)
+        cer_values = [
+            (s.value, s.support or 0) for s in scores if s.value is not None
+        ]
+        total_weight = sum(w for _, w in cer_values)
+        cer = (
+            sum(v * w for v, w in cer_values) / total_weight
+            if total_weight > 0
+            else None
+        )
+        pages_per_hour = (
+            n_documents / (duration / 3600.0) if duration > 0 else None
+        )
+        effective = (
+            n_documents / ((duration + errors * time_per_error) / 3600.0)
+            if errors is not None and duration + errors * time_per_error > 0
+            else None
+        )
+        rows.append(
+            PipelineEconomics(
+                pipeline=name,
+                n_documents=n_documents,
+                duration_seconds=duration,
+                tokens_in=tokens_in,
+                tokens_out=tokens_out,
+                cost_eur=cost,
+                basis=basis,
+                cer=cer,
+                estimated_errors=errors,
+                pages_per_hour=pages_per_hour,
+                pages_per_hour_effective=effective,
+            )
+        )
+    if not rows:
+        return None
+
+    cost_points = [
+        (r.pipeline, r.cer, r.cost_eur)
+        for r in rows
+        if r.cer is not None and r.cost_eur is not None
+    ]
+    speed_points = [
+        (r.pipeline, r.cer, r.duration_seconds)
+        for r in rows
+        if r.cer is not None and r.duration_seconds is not None
+    ]
+    priced = [r for r in rows if r.cost_eur is not None]
+    marginal: list[MarginalCost] = []
+    if len(priced) >= 2:
+        baseline = min(priced, key=lambda r: (r.cost_eur or 0.0, r.pipeline))
+        for row in priced:
+            if row.pipeline == baseline.pipeline:
+                continue
+            if row.estimated_errors is None or baseline.estimated_errors is None:
+                continue
+            avoided = baseline.estimated_errors - row.estimated_errors
+            delta = (row.cost_eur or 0.0) - (baseline.cost_eur or 0.0)
+            marginal.append(
+                MarginalCost(
+                    pipeline=row.pipeline,
+                    baseline=baseline.pipeline,
+                    cost_delta_eur=delta,
+                    errors_avoided=avoided,
+                    eur_per_avoided_error=(
+                        delta / avoided if avoided > 0 and delta >= 0 else None
+                    ),
+                )
+            )
+
+    payload = EconomicsPayload(
+        metric=metric,
+        currency=str(meta["currency"]),
+        hourly_rate_eur=rate,
+        time_per_error_seconds=time_per_error,
+        pricing_valid_until=valid_until,
+        pricing_stale=stale,
+        pipelines=tuple(rows),
+        pareto_cost=pareto_front(
+            [(n, x, y) for n, x, y in cost_points if x is not None and y is not None]
+        ),
+        pareto_speed=pareto_front(
+            [(n, x, y) for n, x, y in speed_points if x is not None and y is not None]
+        ),
+        marginal=tuple(marginal),
+    )
+    return Analysis(scope="corpus", view=view, payload=payload)
+
+
+__all__ = ["economics_analysis", "load_pricing", "pareto_front"]
diff --git a/cinoc/evaluation/errors.py b/cinoc/evaluation/errors.py
new file mode 100644
index 0000000000000000000000000000000000000000..bdaf22704e4f38a732319e606106ba2ccbccffb2
--- /dev/null
+++ b/cinoc/evaluation/errors.py
@@ -0,0 +1,12 @@
+"""Erreurs de la couche évaluation."""
+
+from __future__ import annotations
+
+from cinoc.domain.errors import CinocError
+
+
+class EvaluationError(CinocError):
+    """Métrique inconnue, représentation non chargeable, entrée incohérente."""
+
+
+__all__ = ["EvaluationError"]
diff --git a/cinoc/evaluation/inference.py b/cinoc/evaluation/inference.py
new file mode 100644
index 0000000000000000000000000000000000000000..1afeed6e6303235d6ab24110e43507c73035d61c
--- /dev/null
+++ b/cinoc/evaluation/inference.py
@@ -0,0 +1,263 @@
+"""Inférence statistique corrigée : post-hoc de Nemenyi + bootstrap (couche 3).
+
+Référence : Demšar, J. (2006), *Statistical Comparisons of Classifiers over
+Multiple Data Sets*, JMLR 7:1-30 — le standard pour comparer k systèmes sur n
+jeux appariés (ici : k pipelines × n documents). La p-value brute
+(``significance_p``, Wilcoxon/Friedman) dit « il existe une différence » ; le
+post-hoc dit **lesquelles** des paires diffèrent, en corrigeant les
+comparaisons multiples (distance critique CD = q_α·√(k(k+1)/6n)).
+
+Bootstrap : **percentile** (Efron), graine fixe → déterministe (invariant §12) ;
+volontairement pas BCa (simple à auditer, suffisant pour un IC indicatif).
+Indice de quantile = statistique d'ordre ``round(q·(n_iter−1))`` (l'indice
+``int(q·n_iter)`` décalerait la borne haute d'un rang — bug relevé à l'audit
+scientifique de l'implémentation source, non reproduit ici).
+
+Tout est stdlib (``random``, ``math``) : pas de tirage numpy, déterminisme
+indépendant des versions BLAS.
+"""
+
+from __future__ import annotations
+
+import math
+import random
+from collections.abc import Mapping, Sequence
+
+from cinoc.evaluation.analysis import (
+    Analysis,
+    InferencePayload,
+    PairwiseDifference,
+    PipelineInterval,
+    PipelineRank,
+)
+
+#: Plancher de **puissance**, partagé avec ``metrics.stats.significance`` :
+#: sous ~6 cas complets, ni Wilcoxon ni des rangs moyens n'ont de sens — on ne
+#: produit pas d'analyse plutôt qu'un verdict artefact de petit n.
+MIN_SUPPORT = 6
+
+#: Valeurs critiques du Studentized Range ÷ √2, df = ∞ (tables de Tukey),
+#: q_α pour α ∈ {0.05, 0.01} — clé : nombre de pipelines k.
+_NEMENYI_Q_TABLE: dict[int, tuple[float, float]] = {
+    2: (1.960, 2.576),
+    3: (2.343, 2.913),
+    4: (2.569, 3.113),
+    5: (2.728, 3.255),
+    6: (2.850, 3.364),
+    7: (2.949, 3.452),
+    8: (3.031, 3.526),
+    9: (3.102, 3.590),
+    10: (3.164, 3.646),
+    11: (3.219, 3.696),
+    12: (3.268, 3.741),
+    13: (3.313, 3.781),
+    14: (3.354, 3.818),
+    15: (3.391, 3.853),
+    16: (3.426, 3.886),
+    17: (3.458, 3.916),
+    18: (3.489, 3.944),
+    19: (3.517, 3.970),
+    20: (3.544, 3.995),
+    25: (3.658, 4.095),
+    30: (3.739, 4.167),
+    40: (3.858, 4.272),
+    50: (3.945, 4.349),
+}
+
+
+def nemenyi_critical_value(k: int, alpha: float = 0.05) -> tuple[float, bool]:
+    """``(q_α, extrapolé)`` pour k pipelines, df = ∞.
+
+    Entre deux clés tabulées : interpolation linéaire. Au-delà de k = 50 :
+    **extrapolation** linéaire depuis les deux derniers points — q(k) étant
+    concave croissante, la droite **surestime** q ⇒ CD plus grande ⇒ moins de
+    rejets ⇒ réellement conservateur (réutiliser q(50), plus petit, serait
+    anti-conservateur : plus de faux positifs).
+    """
+    if k < 2:
+        raise ValueError("nemenyi_critical_value : k >= 2 requis.")
+    col = 1 if alpha == 0.01 else 0
+    if k in _NEMENYI_Q_TABLE:
+        return _NEMENYI_Q_TABLE[k][col], False
+    keys = sorted(_NEMENYI_Q_TABLE)
+    if k > keys[-1]:
+        lo, hi = keys[-2], keys[-1]
+        q_lo, q_hi = _NEMENYI_Q_TABLE[lo][col], _NEMENYI_Q_TABLE[hi][col]
+        slope = (q_hi - q_lo) / (hi - lo)
+        return q_hi + slope * (k - hi), True
+    hi = min(key for key in keys if key > k)
+    lo = max(key for key in keys if key < k)
+    q_lo, q_hi = _NEMENYI_Q_TABLE[lo][col], _NEMENYI_Q_TABLE[hi][col]
+    return q_lo + (q_hi - q_lo) * (k - lo) / (hi - lo), False
+
+
+def bootstrap_ci(
+    values: Sequence[float],
+    n_iter: int = 1000,
+    ci: float = 0.95,
+    seed: int = 42,
+) -> tuple[float, float]:
+    """IC percentile de la moyenne par bootstrap — déterministe (graine fixe)."""
+    if not values:
+        return (0.0, 0.0)
+    rng = random.Random(seed)
+    n = len(values)
+    means = sorted(
+        sum(values[rng.randint(0, n - 1)] for _ in range(n)) / n
+        for _ in range(n_iter)
+    )
+    half_alpha = (1.0 - ci) / 2.0
+
+    def order_stat(q: float) -> float:
+        return means[max(0, min(n_iter - 1, round(q * (n_iter - 1))))]
+
+    return (order_stat(half_alpha), order_stat(1.0 - half_alpha))
+
+
+def _rank_row(values: Sequence[float]) -> list[float]:
+    """Rangs d'une ligne (petit = rang 1) ; ex-aequo → rangs moyens."""
+    n = len(values)
+    indexed = sorted(range(n), key=lambda i: values[i])
+    ranks = [0.0] * n
+    i = 0
+    while i < n:
+        j = i
+        while j < n and values[indexed[j]] == values[indexed[i]]:
+            j += 1
+        avg = (i + j + 1) / 2.0  # 1-based
+        for pos in range(i, j):
+            ranks[indexed[pos]] = avg
+        i = j
+    return ranks
+
+
+def _tied_groups(
+    names: Sequence[str], ranks: Sequence[float], critical_distance: float
+) -> tuple[tuple[str, ...], ...]:
+    """Groupes maximaux d'indiscernables : fenêtre ≤ CD sur les rangs triés."""
+    order = sorted(range(len(names)), key=lambda i: (ranks[i], names[i]))
+    sorted_names = [names[i] for i in order]
+    sorted_ranks = [ranks[i] for i in order]
+    groups: list[tuple[str, ...]] = []
+    i = 0
+    while i < len(sorted_names):
+        j = i
+        while (
+            j + 1 < len(sorted_names)
+            and sorted_ranks[j + 1] - sorted_ranks[i] <= critical_distance
+        ):
+            j += 1
+        groups.append(tuple(sorted_names[i : j + 1]))
+        i = j + 1 if j > i else i + 1
+    return tuple(groups)
+
+
+def inference_payload(
+    metric: str,
+    per_pipeline: Mapping[str, Sequence[float | None]],
+    alpha: float = 0.05,
+) -> InferencePayload | None:
+    """Inférentiel d'une (vue × métrique) ; ``None`` si non applicable.
+
+    ``per_pipeline`` : valeurs par-document **alignées** (même index = même
+    document ; ``None`` = non applicable). Rangs et Nemenyi sur les **cas
+    complets** ; IC bootstrap sur les valeurs valides **marginales** de chaque
+    pipeline (plus de données, l'IC est par-pipeline, pas apparié).
+    """
+    names = sorted(per_pipeline)
+    k = len(names)
+    if k < 2:
+        return None
+    series = [per_pipeline[name] for name in names]
+    n_aligned = min(len(column) for column in series)
+    complete = [
+        [series[i][j] for i in range(k)]
+        for j in range(n_aligned)
+        if all(series[i][j] is not None for i in range(k))
+    ]
+    if len(complete) < MIN_SUPPORT:
+        return None
+
+    rank_sums = [0.0] * k
+    for row in complete:
+        for i, rank in enumerate(_rank_row([float(v) for v in row if v is not None])):
+            rank_sums[i] += rank
+    n_blocks = len(complete)
+    means = [rank_sums[i] / n_blocks for i in range(k)]
+    mean_ranks = tuple(
+        PipelineRank(pipeline=name, mean_rank=rank)
+        for rank, name in sorted(
+            ((means[i], names[i]) for i in range(k)), key=lambda p: (p[0], p[1])
+        )
+    )
+
+    critical_distance: float | None = None
+    q_alpha: float | None = None
+    extrapolated = False
+    tied: tuple[tuple[str, ...], ...] = ()
+    pairwise: tuple[PairwiseDifference, ...] = ()
+    if k >= 3:
+        q_alpha, extrapolated = nemenyi_critical_value(k, alpha)
+        critical_distance = q_alpha * math.sqrt(k * (k + 1) / (6.0 * n_blocks))
+        tied = _tied_groups(names, means, critical_distance)
+        pairwise = tuple(
+            PairwiseDifference(
+                a=names[i],
+                b=names[j],
+                rank_gap=abs(means[i] - means[j]),
+                significant=abs(means[i] - means[j]) > critical_distance,
+            )
+            for i in range(k)
+            for j in range(i + 1, k)
+        )
+
+    intervals: list[PipelineInterval] = []
+    for i, name in enumerate(names):
+        valid = [float(v) for v in series[i] if v is not None]
+        if not valid:
+            continue
+        lower, upper = bootstrap_ci(valid)
+        intervals.append(
+            PipelineInterval(
+                pipeline=name,
+                mean=sum(valid) / len(valid),
+                lower=lower,
+                upper=upper,
+                n_documents=len(valid),
+            )
+        )
+
+    return InferencePayload(
+        metric=metric,
+        alpha=alpha,
+        n_documents=n_blocks,
+        critical_distance=critical_distance,
+        q_alpha=q_alpha,
+        q_alpha_extrapolated=extrapolated,
+        mean_ranks=mean_ranks,
+        tied_groups=tied,
+        pairwise=pairwise,
+        intervals=tuple(intervals),
+    )
+
+
+def inference_analysis(
+    view: str,
+    metric: str,
+    per_pipeline: Mapping[str, Sequence[float | None]],
+    alpha: float = 0.05,
+) -> Analysis | None:
+    """``Analysis`` de portée corpus pour (vue × métrique), ou ``None``."""
+    payload = inference_payload(metric, per_pipeline, alpha)
+    if payload is None:
+        return None
+    return Analysis(scope="corpus", view=view, payload=payload)
+
+
+__all__ = [
+    "MIN_SUPPORT",
+    "bootstrap_ci",
+    "inference_analysis",
+    "inference_payload",
+    "nemenyi_critical_value",
+]
diff --git a/cinoc/evaluation/inter_engine.py b/cinoc/evaluation/inter_engine.py
new file mode 100644
index 0000000000000000000000000000000000000000..cbdd3de89a0a369f35547723064d683334c275ea
--- /dev/null
+++ b/cinoc/evaluation/inter_engine.py
@@ -0,0 +1,238 @@
+"""Analyse inter-moteurs : complémentarité (oracle) + divergence taxonomique.
+
+Deux questions complémentaires sur un corpus multi-moteurs (scope corpus) :
+
+- **Complémentarité** — *que rattraperait un ensemble ?* ``oracle_recall`` =
+  rappel multiset **bag-of-words** de l'union des moteurs : pour chaque token
+  GT (multiplicité comprise), le meilleur moteur **sur ce token** est retenu.
+  C'est une **borne supérieure optimiste** — l'ordre des tokens est ignoré ;
+  un vote séquentiel réel ferait au mieux autant, en général moins. Comparée
+  au meilleur moteur seul, elle chiffre le plafond de gain d'un pipeline
+  d'ensemble (``absolute_gap``/``relative_gap``).
+- **Divergence taxonomique** — *les moteurs font-ils des erreurs de même
+  nature ?* Jensen-Shannon en **bits** (``log2``, bornée [0,1]) entre les
+  distributions de classes d'erreurs **déjà comptées** par la taxonomie de la
+  même vue : post-passe **cross-payload** (pattern ``conformity``), zéro
+  re-classification.
+
+Conventions : GT sans token → document **exclu** du dénominateur, jamais un
+rappel 1.0 (R10) ; < 2 pipelines → bloc absent ; tokenisation =
+``textual_fidelity.tokenize`` (minuscules, mots Unicode — une seule définition
+de token dans la couche). Pur stdlib (``math`` + ``Counter``).
+"""
+
+from __future__ import annotations
+
+import math
+from collections import Counter
+from collections.abc import Mapping, Sequence
+
+from cinoc.evaluation.analysis import (
+    Analysis,
+    ComplementarityDocument,
+    EngineTokenRecall,
+    InterEngineComplementarity,
+    InterEngineDivergence,
+    InterEnginePayload,
+    TaxonomyDivergencePair,
+    TaxonomyPayload,
+)
+from cinoc.evaluation.textual_fidelity import tokenize
+
+#: Lissage des classes absentes d'une distribution (évite ``log(0)``) — assez
+#: petit pour ne pas peser sur le résultat ; sert aussi de plancher au
+#: dénominateur de ``relative_gap`` (``1 − best`` peut être nul).
+_EPSILON = 1e-12
+
+#: Documents embarqués dans le payload (plus forts écarts oracle − meilleur).
+#: La source en gardait 50 ; 20 suffit au diagnostic et borne le payload
+#: (aligné sur les caps de ``textual_fidelity``/``diagnostics``).
+_MAX_DOCUMENTS = 20
+
+
+def _smoothed(
+    distribution: Mapping[str, float], keys: Sequence[str]
+) -> list[float]:
+    """Aligne ``distribution`` sur ``keys``, lisse les zéros, renormalise."""
+    smoothed = [max(distribution.get(key, 0.0), _EPSILON) for key in keys]
+    total = sum(smoothed)
+    return [value / total for value in smoothed]
+
+
+def jensen_shannon_divergence(
+    p: Mapping[str, float], q: Mapping[str, float]
+) -> float:
+    """JS-divergence symétrique en **bits**, clampée ``[0, 1]``.
+
+    ``JS(P, Q) = ½·KL(P‖M) + ½·KL(Q‖M)`` avec ``M = (P + Q) / 2`` et un
+    logarithme **base 2** (la borne haute vaut alors exactement 1, atteinte
+    pour des distributions disjointes). Les clés manquantes d'un côté sont
+    lissées à ``ε = 1e-12`` puis renormalisées ; le clamp final absorbe les
+    arrondis flottants.
+    """
+    keys = sorted(set(p) | set(q))
+    if not keys:
+        return 0.0
+    p_vec = _smoothed(p, keys)
+    q_vec = _smoothed(q, keys)
+    m_vec = [(pi + qi) / 2.0 for pi, qi in zip(p_vec, q_vec, strict=True)]
+
+    def _kl(a: list[float], b: list[float]) -> float:
+        return sum(
+            ai * math.log2(ai / bi)
+            for ai, bi in zip(a, b, strict=True)
+            if ai > 0
+        )
+
+    js = 0.5 * _kl(p_vec, m_vec) + 0.5 * _kl(q_vec, m_vec)
+    return max(0.0, min(1.0, js))
+
+
+def _taxonomy_divergence(
+    taxonomy: Analysis | None,
+) -> InterEngineDivergence | None:
+    """Matrice JS depuis le payload ``taxonomy`` déjà construit (même vue)."""
+    payload = taxonomy.payload if taxonomy is not None else None
+    if not isinstance(payload, TaxonomyPayload):
+        return None
+    distributions = {
+        row.pipeline: {
+            count.label: count.count / row.total_errors for count in row.counts
+        }
+        for row in payload.pipelines
+    }
+    names = sorted(distributions)
+    if len(names) < 2:
+        return None
+    pairs: list[TaxonomyDivergencePair] = []
+    max_pair: TaxonomyDivergencePair | None = None
+    for i, a in enumerate(names):
+        for b in names[i + 1 :]:
+            pair = TaxonomyDivergencePair(
+                a=a,
+                b=b,
+                divergence=jensen_shannon_divergence(
+                    distributions[a], distributions[b]
+                ),
+            )
+            pairs.append(pair)
+            # Strictement supérieur : à égalité, la première paire (a, b) gagne ;
+            # toutes nulles → pas de « paire la plus divergente » (max_pair=None).
+            if pair.divergence > 0 and (
+                max_pair is None or pair.divergence > max_pair.divergence
+            ):
+                max_pair = pair
+    return InterEngineDivergence(pairs=tuple(pairs), max_pair=max_pair)
+
+
+class InterEngineCollector:
+    """Multisets de tokens (pipeline × document) au scoring ; ``build`` croise.
+
+    ``observe`` ne retient que des ``Counter`` de tokens (jamais les textes) ;
+    ``build`` reçoit l'analyse ``taxonomy`` de la **même vue** et n'en lit que
+    les comptages (post-passe cross-payload). ``None`` si aucune des deux
+    lectures n'est applicable.
+    """
+
+    def __init__(self) -> None:
+        self._references: dict[str, Counter[str]] = {}
+        self._hypotheses: dict[str, dict[str, Counter[str]]] = {}
+        self._documents: list[str] = []
+
+    def observe(
+        self, pipeline: str, document_id: str, reference: str, hypothesis: str
+    ) -> None:
+        if document_id not in self._references:
+            self._references[document_id] = Counter(tokenize(reference))
+            self._documents.append(document_id)
+        bucket = self._hypotheses.setdefault(pipeline, {})
+        bucket[document_id] = Counter(tokenize(hypothesis))
+
+    def build(self, view: str, taxonomy: Analysis | None) -> Analysis | None:
+        complementarity = self._complementarity()
+        divergence = _taxonomy_divergence(taxonomy)
+        if complementarity is None and divergence is None:
+            return None
+        return Analysis(
+            scope="corpus",
+            view=view,
+            payload=InterEnginePayload(
+                complementarity=complementarity,
+                taxonomy_divergence=divergence,
+            ),
+        )
+
+    def _complementarity(self) -> InterEngineComplementarity | None:
+        pipelines = sorted(self._hypotheses)
+        if len(pipelines) < 2:
+            return None
+        total_tokens = 0
+        oracle_preserved = 0
+        per_engine: dict[str, int] = {name: 0 for name in pipelines}
+        documents: list[ComplementarityDocument] = []
+        for document_id in self._documents:
+            reference = self._references[document_id]
+            document_total = sum(reference.values())
+            if document_total == 0:
+                continue  # R10 : GT sans token = non applicable, jamais 1.0.
+            total_tokens += document_total
+            preserved = {name: 0 for name in pipelines}
+            document_oracle = 0
+            for token, count in reference.items():
+                best = 0
+                for name in pipelines:
+                    hypothesis = self._hypotheses[name].get(document_id)
+                    # Pipeline sans sortie sur ce document → 0 préservé (l'échec
+                    # coûte du rappel, il n'est pas neutralisé en silence).
+                    kept = (
+                        min(count, hypothesis.get(token, 0))
+                        if hypothesis is not None
+                        else 0
+                    )
+                    preserved[name] += kept
+                    if kept > best:
+                        best = kept
+                document_oracle += best
+            oracle_preserved += document_oracle
+            document_best = 0
+            for name in pipelines:
+                per_engine[name] += preserved[name]
+                if preserved[name] > document_best:
+                    document_best = preserved[name]
+            documents.append(
+                ComplementarityDocument(
+                    document_id=document_id,
+                    oracle_recall=document_oracle / document_total,
+                    best_single_recall=document_best / document_total,
+                    absolute_gap=(document_oracle - document_best)
+                    / document_total,
+                )
+            )
+        if total_tokens == 0:
+            return None  # R10 : corpus entier sans token GT.
+        recalls = {name: per_engine[name] / total_tokens for name in pipelines}
+        # ``max`` garde le premier maximum : noms triés → à égalité, le plus
+        # petit lexicographiquement gagne (déterministe).
+        best_engine = max(pipelines, key=lambda name: recalls[name])
+        best_recall = recalls[best_engine]
+        oracle_recall = oracle_preserved / total_tokens
+        absolute_gap = max(0.0, oracle_recall - best_recall)
+        relative_gap = min(1.0, absolute_gap / max(1.0 - best_recall, _EPSILON))
+        documents.sort(key=lambda d: (-d.absolute_gap, d.document_id))
+        return InterEngineComplementarity(
+            n_documents=len(documents),
+            n_reference_tokens=total_tokens,
+            oracle_recall=oracle_recall,
+            best_single_recall=best_recall,
+            best_engine=best_engine,
+            absolute_gap=absolute_gap,
+            relative_gap=relative_gap,
+            per_engine_recall=tuple(
+                EngineTokenRecall(pipeline=name, recall=recalls[name])
+                for name in pipelines
+            ),
+            per_document=tuple(documents[:_MAX_DOCUMENTS]),
+        )
+
+
+__all__ = ["InterEngineCollector", "jensen_shannon_divergence"]
diff --git a/cinoc/evaluation/lines.py b/cinoc/evaluation/lines.py
new file mode 100644
index 0000000000000000000000000000000000000000..8a1436248868d32b7bdcd2552fd75d862e5698e0
--- /dev/null
+++ b/cinoc/evaluation/lines.py
@@ -0,0 +1,210 @@
+"""Distribution du CER par ligne (couche 3).
+
+Le CER document noie la **répartition** des erreurs : 5 % d'erreurs uniformes
+(correction rapide partout) et 5 % concentrées en lignes détruites (re-saisie
+locale) ne se relisent pas pareil. Par pipeline, sur les lignes GT du corpus
+**poolées** (micro — pas une moyenne de statistiques par document) :
+
+- **CER par ligne** — lignes GT appariées aux lignes hypothèse par un
+  alignement Levenshtein **sur les listes de lignes** avant tout calcul
+  (audit source F15) : une ligne insérée/supprimée ne décale plus toutes les
+  suivantes. Ligne GT sans correspondance → CER 1.0 (ligne perdue) ; lignes
+  hypothèse en trop ignorées (la distribution est indexée sur la GT). Limite
+  résiduelle assumée : une fusion/scission de lignes est approximée par une
+  substitution + une délétion. CER de ligne plafonné à 1.0.
+- **Percentiles** p50→p99 (interpolation linéaire) · **Gini** (0 = erreurs
+  uniformes, 1 = concentrées) · **taux catastrophiques** (part des lignes au
+  CER **≥ seuil** — seuils 0.30/0.50/1.00 portés par le payload ; le ``>``
+  strict de la source laissait le seuil 1.0 à zéro pour toujours, le CER
+  étant plafonné à 1.0) · **heatmap** positionnelle (CER moyen par tranche
+  de position relative dans le document, tranche vide → ``None``).
+
+**Applicabilité** : la distribution n'a de sens que si la normalisation de la
+vue **préserve les sauts de ligne** — sur un profil « à plat » (``flat_text``,
+``hipe``…), l'analyse est absente (jamais un chiffre trompeur). Sonde
+comportementale ``newline_preserved(view)`` : la survie de ``\\n`` à
+``prepare_text`` (couvre profils **et** ``char_exclude``).
+"""
+
+from __future__ import annotations
+
+import unicodedata
+from collections.abc import Sequence
+
+from rapidfuzz.distance import Levenshtein
+
+from cinoc.domain.evaluation import EvaluationView
+from cinoc.evaluation.analysis import (
+    Analysis,
+    CatastrophicRate,
+    LinePercentiles,
+    LinesPayload,
+    PipelineLines,
+)
+from cinoc.evaluation.representations import prepare_text
+
+#: Seuils de ligne « catastrophique » (CER ≥ seuil) — conventions éditoriales
+#: de la source : 0.30 = relecture lourde, 0.50 = re-saisie probable,
+#: 1.00 = ligne totalement perdue (cap).
+_CATASTROPHIC_THRESHOLDS = (0.30, 0.50, 1.00)
+
+#: Tranches de position de la heatmap (dixièmes de document).
+_HEATMAP_BINS = 10
+
+#: Percentiles rapportés (p50 = médiane … p99 = queue extrême).
+_PERCENTILES = (50, 75, 90, 95, 99)
+
+
+def newline_preserved(view: EvaluationView) -> bool:
+    """``True`` si la préparation de la vue laisse vivre les sauts de ligne.
+
+    Sonde comportementale (pas une lecture de champs) : on prépare un témoin
+    ``"a\\nb"`` exactement comme au scoring — un profil « à plat », un levier
+    ``\\W → espace`` ou un ``char_exclude`` contenant ``\\n`` le détectent tous.
+    """
+    return "\n" in prepare_text("a\nb", view)
+
+
+def line_cer(reference: str, hypothesis: str) -> float:
+    """CER d'une paire de lignes (NFC + strip), plafonné à 1.0.
+
+    Ligne GT vide → 0.0 si l'hypothèse l'est aussi, 1.0 sinon (contenu
+    halluciné sur une ligne blanche) — convention de la source, au niveau
+    ligne seulement (un *document* sans ligne ne produit rien).
+    """
+    ref = unicodedata.normalize("NFC", reference.strip())
+    hyp = unicodedata.normalize("NFC", hypothesis.strip())
+    if not ref:
+        return 0.0 if not hyp else 1.0
+    return min(Levenshtein.distance(ref, hyp) / len(ref), 1.0)
+
+
+def aligned_line_cers(reference: str, hypothesis: str) -> list[float]:
+    """CER par ligne GT, lignes appariées par alignement Levenshtein (F15).
+
+    L'alignement opère sur les **listes de lignes** : seuls les opcodes
+    ``equal``/``replace`` apparient (positionnellement à l'intérieur du
+    segment) ; une ligne GT supprimée reste sans correspondance (CER 1.0 via
+    l'hypothèse vide) ; les lignes hypothèse insérées n'entrent pas dans la
+    distribution.
+    """
+    ref_lines = reference.splitlines()
+    hyp_lines = hypothesis.splitlines()
+    if not ref_lines:
+        return []
+    mapped: list[str | None] = [None] * len(ref_lines)
+    for op in Levenshtein.opcodes(ref_lines, hyp_lines):
+        if op.tag in ("equal", "replace"):
+            for offset in range(op.src_end - op.src_start):
+                mapped[op.src_start + offset] = hyp_lines[op.dest_start + offset]
+    return [
+        line_cer(ref_line, mapped[i] or "")
+        for i, ref_line in enumerate(ref_lines)
+    ]
+
+
+def percentile(sorted_values: Sequence[float], p: float) -> float:
+    """p-ième percentile (0 ≤ p ≤ 100) d'une liste **triée non vide**.
+
+    Interpolation linéaire entre les deux rangs encadrants (la convention de
+    ``numpy`` par défaut, portée de la source en pur stdlib).
+    """
+    n = len(sorted_values)
+    index = p / 100 * (n - 1)
+    lo = int(index)
+    hi = min(lo + 1, n - 1)
+    frac = index - lo
+    return sorted_values[lo] + frac * (sorted_values[hi] - sorted_values[lo])
+
+
+def gini(values: Sequence[float]) -> float:
+    """Coefficient de Gini de la concentration des erreurs, clampé ``[0, 1]``.
+
+    ``G = (2·Σ (i+1)·xᵢ) / (n·Σ xᵢ) − (n+1)/n`` sur les valeurs triées
+    croissantes. 0 = erreurs uniformément réparties (ou aucune erreur :
+    somme nulle → 0.0, l'uniformité parfaite) ; 1 = tout le volume d'erreur
+    concentré sur une ligne. Le clamp absorbe les arrondis flottants.
+    """
+    xs = sorted(max(value, 0.0) for value in values)
+    n = len(xs)
+    total = sum(xs)
+    if n == 0 or total == 0.0:
+        return 0.0
+    weighted = sum((i + 1) * x for i, x in enumerate(xs))
+    return max(0.0, min(1.0, (2.0 * weighted) / (n * total) - (n + 1) / n))
+
+
+class LinesCollector:
+    """Accumule ``(CER, position relative)`` par ligne GT au fil du scoring.
+
+    ``enabled=False`` (vue dont la normalisation écrase ``\\n``) → no-op :
+    l'analyse est non applicable, le payload absent. La position relative
+    (``index / nombre de lignes du document``) permet de pooler la heatmap
+    entre documents de tailles différentes.
+    """
+
+    def __init__(
+        self, *, enabled: bool = True, heatmap_bins: int = _HEATMAP_BINS
+    ) -> None:
+        self._enabled = enabled
+        self._bins = heatmap_bins
+        self._lines: dict[str, list[tuple[float, float]]] = {}
+
+    def observe(self, pipeline: str, reference: str, hypothesis: str) -> None:
+        if not self._enabled:
+            return
+        cers = aligned_line_cers(reference, hypothesis)
+        if not cers:
+            return
+        bucket = self._lines.setdefault(pipeline, [])
+        count = len(cers)
+        bucket.extend((cer, i / count) for i, cer in enumerate(cers))
+
+    def build(self, view: str) -> Analysis | None:
+        rows = [self._row(pipeline) for pipeline in sorted(self._lines)]
+        if not rows:
+            return None
+        return Analysis(
+            scope="corpus",
+            view=view,
+            payload=LinesPayload(heatmap_bins=self._bins, pipelines=tuple(rows)),
+        )
+
+    def _row(self, pipeline: str) -> PipelineLines:
+        lines = self._lines[pipeline]
+        cers = [cer for cer, _ in lines]
+        ordered = sorted(cers)
+        count = len(cers)
+        catastrophic: list[CatastrophicRate] = []
+        for threshold in _CATASTROPHIC_THRESHOLDS:
+            n_over = sum(1 for cer in cers if cer >= threshold)
+            catastrophic.append(
+                CatastrophicRate(
+                    threshold=threshold, count=n_over, rate=n_over / count
+                )
+            )
+        bins: list[list[float]] = [[] for _ in range(self._bins)]
+        for cer, fraction in lines:
+            bins[min(int(fraction * self._bins), self._bins - 1)].append(cer)
+        p50, p75, p90, p95, p99 = (percentile(ordered, p) for p in _PERCENTILES)
+        return PipelineLines(
+            pipeline=pipeline,
+            line_count=count,
+            mean_cer=sum(cers) / count,
+            gini=gini(cers),
+            percentiles=LinePercentiles(p50=p50, p75=p75, p90=p90, p95=p95, p99=p99),
+            catastrophic=tuple(catastrophic),
+            heatmap=tuple(
+                sum(values) / len(values) if values else None for values in bins
+            ),
+        )
+
+
+__all__ = [
+    "LinesCollector",
+    "aligned_line_cers",
+    "gini",
+    "line_cer",
+    "newline_preserved",
+    "percentile",
+]
diff --git a/cinoc/evaluation/longitudinal.py b/cinoc/evaluation/longitudinal.py
new file mode 100644
index 0000000000000000000000000000000000000000..6dee741bb836faa3b003f8dd8b635ffff48bbbc8
--- /dev/null
+++ b/cinoc/evaluation/longitudinal.py
@@ -0,0 +1,159 @@
+"""Tendance & rupture d'une série longitudinale multi-runs (couche 3).
+
+Sur l'historique des runs (PAS un payload ``RunResult`` — c'est du
+multi-runs), deux questions :
+
+- **Y a-t-il une tendance ?** ``linear_trend`` — régression OLS closed-form
+  (pur stdlib, portée telle quelle de la source) sur ``(temps, valeur)``,
+  pente exprimée **par jour**. Conventions documentées : série **constante**
+  → ``r_squared = 1.0`` (parfaitement prédite — l'absence de tendance est
+  certaine, pas indéfinie) ; < 2 points ou horodatages tous identiques →
+  ``None``. L'origine des x est le **premier point** (l'ordonnée à l'origine
+  est la valeur ajustée au premier run, pas à l'an 1).
+- **Y a-t-il une rupture ?** ``pettitt`` — **vrai test de rupture**
+  (Pettitt 1979, non paramétrique, fondé sur les rangs) : ``U_t = Σ_{i≤t}
+  Σ_{j>t} sgn(x_j − x_i)``, ``K = max|U_t|``, approximation asymptotique
+  publiée ``p ≈ 2·exp(−6K²/(n³+n²))`` (clampée ≤ 1) ; rupture **significative
+  seulement si p ≤ α** — le max-diff de la source « détectait » toujours
+  quelque chose (aucune statistique de test) ; réparation R11.
+
+Entrées **déjà parsées** (``datetime``/``float``) : le parsing tolérant
+multi-formats à skip silencieux de la source n'est pas porté — la conversion
+vit chez l'appelant (couche app), explicite et journalisée.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Sequence
+from dataclasses import dataclass
+from datetime import datetime
+from statistics import fmean
+
+#: Seuil de signification par défaut du test de Pettitt.
+_DEFAULT_ALPHA = 0.05
+
+#: Secondes par jour (pente exprimée par jour).
+_DAY_SECONDS = 86400.0
+
+
+@dataclass(frozen=True)
+class TrendResult:
+    """Régression linéaire d'une série temporelle (pente par **jour**)."""
+
+    slope_per_day: float
+    intercept: float
+    r_squared: float
+    n_points: int
+
+
+@dataclass(frozen=True)
+class PettittResult:
+    """Test de rupture de Pettitt sur une série **chronologique**.
+
+    ``boundary`` = taille du premier segment : la série se lit
+    ``série[:boundary]`` (avant) / ``série[boundary:]`` (après) — le point
+    d'indice ``boundary`` est le **premier du nouveau régime**. À égalité de
+    ``|U|``, la plus petite frontière gagne (déterministe). ``significant``
+    n'est vrai que si ``p_value ≤ alpha`` — sinon il n'y a **pas** de rupture
+    à signaler, quelle que soit l'ampleur de ``delta``.
+    """
+
+    n_points: int
+    boundary: int
+    u_statistic: int
+    p_value: float
+    alpha: float
+    significant: bool
+    mean_before: float
+    mean_after: float
+    delta: float
+
+
+def linear_trend(
+    points: Sequence[tuple[datetime, float]],
+) -> TrendResult | None:
+    """OLS sur ``(horodatage, valeur)`` ; ``None`` si la pente est indéfinie.
+
+    Horodatages **homogènes** requis (tous naïfs ou tous conscients du fuseau
+    — l'appelant normalise) ; l'ordre n'importe pas (OLS est invariant).
+    """
+    if len(points) < 2:
+        return None
+    origin = min(stamp for stamp, _ in points)
+    xs = [(stamp - origin).total_seconds() / _DAY_SECONDS for stamp, _ in points]
+    ys = [value for _, value in points]
+    x_mean = fmean(xs)
+    y_mean = fmean(ys)
+    sxx = sum((x - x_mean) ** 2 for x in xs)
+    if sxx == 0.0:
+        return None  # horodatages tous identiques : pente indéfinie.
+    sxy = sum((x - x_mean) * (y - y_mean) for x, y in zip(xs, ys, strict=True))
+    slope = sxy / sxx
+    intercept = y_mean - slope * x_mean
+    syy = sum((y - y_mean) ** 2 for y in ys)
+    if syy == 0.0 or all(y == ys[0] for y in ys):
+        # Série constante : R² mathématiquement indéfini → 1.0 (la
+        # « non-tendance » est parfaitement prédite ; convention source).
+        # Constance testée sur les valeurs en plus de ``syy == 0`` : la
+        # moyenne flottante d'une série constante n'est pas exactement la
+        # valeur (syy retombe alors sur une poussière non nulle).
+        r_squared = 1.0
+    else:
+        ss_res = sum(
+            (y - (slope * x + intercept)) ** 2
+            for x, y in zip(xs, ys, strict=True)
+        )
+        r_squared = max(0.0, 1.0 - ss_res / syy)
+    return TrendResult(
+        slope_per_day=slope,
+        intercept=intercept,
+        r_squared=r_squared,
+        n_points=len(points),
+    )
+
+
+def _sign(a: float, b: float) -> int:
+    """``sgn(b − a)`` sans flottant (rang pur : les ex æquo comptent 0)."""
+    return (b > a) - (b < a)
+
+
+def pettitt(
+    values: Sequence[float], *, alpha: float = _DEFAULT_ALPHA
+) -> PettittResult | None:
+    """Test de rupture de Pettitt (1979) sur une série **chronologique**.
+
+    ``U`` est balayé incrémentalement (O(n²) : à chaque déplacement de la
+    frontière, seules les paires impliquant l'élément déplacé changent).
+    ``None`` si moins de 2 points. ``K = 0`` (série constante) → ``p``
+    clampée à 1.0, jamais significatif.
+    """
+    n = len(values)
+    if n < 2:
+        return None
+    u = sum(_sign(values[0], values[j]) for j in range(1, n))
+    best_u, best_boundary = u, 1
+    for boundary in range(2, n):
+        moved = boundary - 1  # l'élément qui passe du 2ᵉ au 1ᵉʳ segment
+        u -= sum(_sign(values[i], values[moved]) for i in range(moved))
+        u += sum(_sign(values[moved], values[j]) for j in range(boundary, n))
+        if abs(u) > abs(best_u):
+            best_u, best_boundary = u, boundary
+    k = abs(best_u)
+    p_value = min(1.0, 2.0 * math.exp(-6.0 * k * k / (n**3 + n**2)))
+    mean_before = fmean(values[:best_boundary])
+    mean_after = fmean(values[best_boundary:])
+    return PettittResult(
+        n_points=n,
+        boundary=best_boundary,
+        u_statistic=k,
+        p_value=p_value,
+        alpha=alpha,
+        significant=p_value <= alpha,
+        mean_before=mean_before,
+        mean_after=mean_after,
+        delta=mean_after - mean_before,
+    )
+
+
+__all__ = ["PettittResult", "TrendResult", "linear_trend", "pettitt"]
diff --git a/cinoc/evaluation/markers.py b/cinoc/evaluation/markers.py
new file mode 100644
index 0000000000000000000000000000000000000000..34f02ff961f974cb334ae4fcf8538f3975c4e8f2
--- /dev/null
+++ b/cinoc/evaluation/markers.py
@@ -0,0 +1,336 @@
+"""Préservation de **marqueurs philologiques** : moteur + familles (couche 3).
+
+Mesure si une convention scribale de la vérité-terrain survit dans la sortie —
+*diplomatique* (la forme abrégée est reproduite telle quelle) vs *modernisante*
+(elle est développée). Deux scores par marqueur, agrégés par famille :
+
+- **strict** : le signe exact de la GT est reproduit (``ꝑ`` reste ``ꝑ``) ;
+- **expansion** : le signe **ou** son développement est reproduit (``ꝑ`` →
+  ``per``/``par``) — toujours ``≥ strict`` (lentille plus permissive).
+
+Stratégie *containment* (abréviations) : appariement **multiset** sur le texte
+entier ; les développements sont cherchés en **mot entier** (``\b…\b`` pour
+**toutes** les longueurs — réparation R3 : ``per`` ne matche plus dans
+« permettre », contrairement à la source qui ne bornait que ``≤ 2`` lettres).
+L'expansion est une **borne optimiste** (un « et » du texte compte comme
+développement d'un ``⁊``, capé au nombre de signes de la GT).
+
+Deux stratégies d'appariement, déclarées par chaque famille (``MarkerFamily.
+strategy``) :
+
+- *containment* (abréviations) — la forme (ou son développement) existe quelque
+  part dans l'hypothèse (multiset, insensible à l'ordre), deux scores ;
+- *positional* (imprimé ancien) — le marqueur est restitué **à sa position**
+  (toutes ses positions GT tombent dans un opcode ``equal`` de Levenshtein,
+  cohérent CER), un seul score (préservation).
+
+Adaptatif : une famille — et, en positionnel, une catégorie — sans aucun signe
+dans la GT du corpus est **absente** du rapport (pas un zéro sur un corpus
+moderne). Données = **constantes du module** (≠ surface exécutable, comme les
+profils de normalisation). La famille *roman* (5 statuts) arrive à sa
+sous-tranche.
+"""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Literal
+
+from rapidfuzz.distance import Levenshtein
+
+from cinoc.evaluation.analysis import (
+    Analysis,
+    MarkerPreservation,
+    PhilologyPayload,
+    PipelinePhilology,
+)
+from cinoc.evaluation.archives import CATEGORY_ORDER, archival_counts
+
+
+@dataclass(frozen=True)
+class Marker:
+    """Membre d'une famille de marqueurs.
+
+    - *containment* (abréviations) : ``sign`` est le signe cherché tel quel,
+      ``expansions`` ses développements éditoriaux ; ``forms`` est vide.
+    - *positional* (imprimé ancien) : ``sign`` est le **nom de catégorie** (clé
+      d'agrégation et d'affichage), ``forms`` les graphies pré-composées qui en
+      relèvent ; ``expansions`` est vide (aucune notion de développement).
+    """
+
+    sign: str
+    expansions: tuple[str, ...] = ()
+    forms: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True)
+class MarkerFamily:
+    """Une famille de marqueurs partageant une stratégie d'appariement.
+
+    ``strategy`` choisit la sémantique de préservation : ``"containment"`` (la
+    forme ou son développement existe dans l'hypothèse, multiset), ``"positional"``
+    (le marqueur est à sa position — opcode ``equal``, cohérent CER), ou
+    ``"archival"`` (containment multiset **borné par frontière de mot**, données
+    et détection dans :mod:`cinoc.evaluation.archives` ; ``markers`` ne sert que
+    de **clés d'affichage** ordonnées = les catégories).
+    """
+
+    name: str
+    markers: tuple[Marker, ...]
+    strategy: Literal["containment", "positional", "archival"] = "containment"
+
+
+#: Abréviations médiévales (Capelli / MUFI). ``ñ`` (U+00F1) est **exclu** : son
+#: ambiguïté avec l'espagnol/le français modernes en ferait un faux positif
+#: systématique (chaque « ñ » compté comme abréviation). Les signes combinants
+#: ``p̃``/``q̃`` (lettre + U+0303) sont appariés en forme NFC.
+ABBREVIATIONS = MarkerFamily(
+    name="abbreviations",
+    markers=(
+        Marker("ꝑ", ("per", "par")),
+        Marker("ꝓ", ("pro",)),
+        Marker("ꝗ", ("qui",)),
+        Marker("ꝙ", ("quia",)),
+        Marker("ꝯ", ("us", "con")),
+        Marker("⁊", ("et",)),
+        Marker("ꝝ", ("rum",)),
+        Marker("ꝫ", ("et",)),
+        Marker("ꝭ", ("is",)),
+        Marker("p̃", ("par", "per")),
+        Marker("q̃", ("que", "qui")),
+    ),
+)
+
+#: Marqueurs typographiques de l'imprimé ancien (XVIᵉ-XVIIIᵉ), **stratégie
+#: positionnelle**. Cinq catégories ; chaque ``forms`` ne liste que des graphies
+#: **pré-composées** (un codepoint) — les séquences décomposées voyelle + U+0303
+#: sont ramenées à leur pré-composé par la normalisation NFC avant détection,
+#: donc ``ã`` (a + U+0303) et ``ã`` (U+00E3) comptent pareil. ``ñ`` est inclus
+#: ici (marqueur d'imprimé ancien), contrairement à la famille scribale où son
+#: ambiguïté moderne le bannit.
+EARLY_MODERN = MarkerFamily(
+    name="early_modern",
+    strategy="positional",
+    markers=(
+        Marker("ligatures", forms=("ff", "fi", "fl", "ffi", "ffl", "ſt", "st")),
+        Marker("long_s", forms=("ſ",)),
+        Marker("dotless_i", forms=("ı",)),
+        Marker("ampersand", forms=("&",)),
+        Marker(
+            "nasal_tildes",
+            forms=("ã", "Ã", "ñ", "Ñ", "õ", "Õ", "ũ", "Ũ", "ẽ", "Ẽ", "ĩ", "Ĩ"),
+        ),
+    ),
+)
+
+#: Archives modernes (XIXᵉ-XXᵉ), **stratégie `archival`**. Les tables (9
+#: catégories, ~70 marqueurs) et la détection bornée vivent dans
+#: :mod:`cinoc.evaluation.archives` ; ici, ``markers`` ne porte que les **clés
+#: d'affichage** (catégories) dans l'ordre canonique — `_counts_for` délègue le
+#: comptage à ``archival_counts``.
+MODERN_ARCHIVES = MarkerFamily(
+    name="modern_archives",
+    strategy="archival",
+    markers=tuple(Marker(category) for category in CATEGORY_ORDER),
+)
+
+#: Familles actives. ``observe`` les parcourt toutes ; une famille (ou catégorie)
+#: sans signal dans la GT n'écrit rien (adaptatif).
+FAMILIES: tuple[MarkerFamily, ...] = (ABBREVIATIONS, EARLY_MODERN, MODERN_ARCHIVES)
+
+#: Motif « mot entier » des développements (R3 : ``\b…\b`` quelle que soit la
+#: longueur), insensible à la casse — précompilé par signe au chargement. Seules
+#: les familles *containment* portent des développements.
+_EXPANSION_PATTERNS: dict[str, re.Pattern[str]] = {
+    marker.sign: re.compile(
+        r"\b(?:" + "|".join(re.escape(e) for e in marker.expansions) + r")\b",
+        re.IGNORECASE,
+    )
+    for family in FAMILIES
+    if family.strategy == "containment"
+    for marker in family.markers
+}
+
+
+@dataclass(frozen=True)
+class SignCounts:
+    """Comptes d'un signe pour une paire (GT, hypothèse)."""
+
+    n_total: int
+    n_strict: int
+    n_expansion: int
+
+
+def family_counts(
+    family: MarkerFamily, reference: str, hypothesis: str
+) -> dict[str, SignCounts]:
+    """Comptes par signe **présent dans la GT** (containment, multiset).
+
+    ``n_strict = min(n_gt, occurrences du signe dans l'hyp)`` ;
+    ``n_expansion = min(n_gt, signe + développements en mot entier)`` — borne
+    optimiste, capée à ``n_gt`` (jamais > le nombre d'occurrences de la GT).
+    """
+    ref = unicodedata.normalize("NFC", reference)
+    hyp = unicodedata.normalize("NFC", hypothesis)
+    out: dict[str, SignCounts] = {}
+    for marker in family.markers:
+        n_gt = ref.count(marker.sign)
+        if n_gt == 0:
+            continue
+        sign_in_hyp = hyp.count(marker.sign)
+        expansion_in_hyp = len(_EXPANSION_PATTERNS[marker.sign].findall(hyp))
+        out[marker.sign] = SignCounts(
+            n_total=n_gt,
+            n_strict=min(n_gt, sign_in_hyp),
+            n_expansion=min(n_gt, sign_in_hyp + expansion_in_hyp),
+        )
+    return out
+
+
+def _char_categories(family: MarkerFamily) -> dict[str, str]:
+    """Index ``graphie NFC (un codepoint) → nom de catégorie`` d'une famille."""
+    return {
+        unicodedata.normalize("NFC", form): marker.sign
+        for marker in family.markers
+        for form in marker.forms
+    }
+
+
+def _equal_src_positions(reference: str, hypothesis: str) -> set[int]:
+    """Indices de ``reference`` couverts par un opcode ``equal`` (cohérent CER)."""
+    positions: set[int] = set()
+    for op in Levenshtein.opcodes(reference, hypothesis):
+        if op.tag == "equal":
+            positions.update(range(op.src_start, op.src_end))
+    return positions
+
+
+def positional_counts(
+    family: MarkerFamily, reference: str, hypothesis: str
+) -> dict[str, SignCounts]:
+    """Préservation **positionnelle** par catégorie présente dans la GT.
+
+    Un marqueur (un codepoint après NFC) est *préservé* si sa position GT tombe
+    dans un opcode ``equal`` de l'alignement Levenshtein GT↔hypothèse — même
+    critère que le CER. Score unique : ``n_strict == n_expansion == n_préservé``
+    (la famille n'a pas de lentille « développement »), pour réutiliser la forme
+    du payload sans rupture. Catégories absentes de la GT → omises (adaptatif).
+    """
+    ref = unicodedata.normalize("NFC", reference)
+    hyp = unicodedata.normalize("NFC", hypothesis)
+    categories = _char_categories(family)
+    occurrences = [
+        (i, categories[ch]) for i, ch in enumerate(ref) if ch in categories
+    ]
+    if not occurrences:
+        return {}
+    equal_positions = _equal_src_positions(ref, hyp)
+    sums: dict[str, list[int]] = {}
+    for position, category in occurrences:
+        slot = sums.setdefault(category, [0, 0])
+        slot[0] += 1
+        if position in equal_positions:
+            slot[1] += 1
+    return {
+        category: SignCounts(n_total=total, n_strict=kept, n_expansion=kept)
+        for category, (total, kept) in sums.items()
+    }
+
+
+def _counts_for(
+    family: MarkerFamily, reference: str, hypothesis: str
+) -> dict[str, SignCounts]:
+    """Comptes d'une famille selon sa stratégie déclarée."""
+    if family.strategy == "positional":
+        return positional_counts(family, reference, hypothesis)
+    if family.strategy == "archival":
+        return {
+            category: SignCounts(n_total=total, n_strict=strict, n_expansion=expansion)
+            for category, (total, strict, expansion) in archival_counts(
+                reference, hypothesis
+            ).items()
+        }
+    return family_counts(family, reference, hypothesis)
+
+
+class MarkerCollector:
+    """Accumule la préservation des marqueurs au fil du scoring (micro).
+
+    Pattern ``TaxonomyCollector`` : ``observe`` par document scoré (mêmes textes
+    normalisés, zéro relecture), ``build`` agrège par (pipeline × famille ×
+    signe) → ``PhilologyPayload``. Familles sans signal → absentes.
+    """
+
+    def __init__(self, families: Sequence[MarkerFamily] = FAMILIES) -> None:
+        self._families = tuple(families)
+        #: (pipeline, family, sign) -> [n_total, n_strict, n_expansion]
+        self._sums: dict[tuple[str, str, str], list[int]] = {}
+        self._order: list[str] = []
+
+    def observe(self, pipeline: str, reference: str, hypothesis: str) -> None:
+        seen = False
+        for family in self._families:
+            for key, counts in _counts_for(family, reference, hypothesis).items():
+                slot = self._sums.setdefault((pipeline, family.name, key), [0, 0, 0])
+                slot[0] += counts.n_total
+                slot[1] += counts.n_strict
+                slot[2] += counts.n_expansion
+                seen = True
+        if seen and pipeline not in self._order:
+            self._order.append(pipeline)
+
+    def build(self, view: str) -> Analysis | None:
+        """Payload de la vue, ``None`` si aucun marqueur dans la GT du corpus."""
+        rows: list[PipelinePhilology] = []
+        for pipeline in self._order:
+            for family in self._families:
+                signs = [
+                    (marker.sign, self._sums[(pipeline, family.name, marker.sign)])
+                    for marker in family.markers
+                    if (pipeline, family.name, marker.sign) in self._sums
+                ]
+                if not signs:
+                    continue
+                markers = tuple(
+                    MarkerPreservation(
+                        sign=sign,
+                        n_total=slot[0],
+                        n_strict=slot[1],
+                        n_expansion=slot[2],
+                    )
+                    for sign, slot in signs
+                )
+                rows.append(
+                    PipelinePhilology(
+                        pipeline=pipeline,
+                        family=family.name,
+                        n_total=sum(m.n_total for m in markers),
+                        n_strict=sum(m.n_strict for m in markers),
+                        n_expansion=sum(m.n_expansion for m in markers),
+                        markers=markers,
+                    )
+                )
+        if not rows:
+            return None
+        return Analysis(
+            scope="corpus",
+            view=view,
+            payload=PhilologyPayload(pipelines=tuple(rows)),
+        )
+
+
+__all__ = [
+    "ABBREVIATIONS",
+    "EARLY_MODERN",
+    "FAMILIES",
+    "MODERN_ARCHIVES",
+    "Marker",
+    "MarkerCollector",
+    "MarkerFamily",
+    "SignCounts",
+    "family_counts",
+    "positional_counts",
+]
diff --git a/cinoc/evaluation/metric.py b/cinoc/evaluation/metric.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f91173d404eaa870a70a3fb85783888c9b7c187
--- /dev/null
+++ b/cinoc/evaluation/metric.py
@@ -0,0 +1,111 @@
+"""Métriques co-localisées (fiche + fonction) + décorateurs **purs**.
+
+- ``DocumentMetric`` (par-document) : opère sur un ``DocContext``.
+- ``CrossEngineMetric`` (inter-moteurs) : opère sur un ``CrossEngineContext`` et
+  renvoie ``(valeur, support)``.
+
+Les décorateurs **construisent** l'objet sans muter de registre global (→ import
+sans effet de bord, CLAUDE.md §7) ; la collecte est explicite.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from cinoc.domain.artifacts import ArtifactType
+from cinoc.domain.evaluation import MetricSpec
+from cinoc.evaluation.context import CrossEngineContext, DocContext
+
+
+@dataclass(frozen=True)
+class Observation:
+    """Mesure par-document d'une métrique : valeur + poids de micro-agrégation.
+
+    ``weight`` est le **dénominateur** de la métrique (longueur de référence pour
+    CER, nombre de mots pour WER, ``hits + edits`` pour MER). Il autorise
+    l'agrégat **micro** (Σ erreurs / Σ dénominateurs = la métrique au niveau
+    corpus, comparable à ``jiwer``) en plus de la moyenne **macro** par document.
+    """
+
+    value: float
+    weight: int
+
+
+#: Une métrique par-document renvoie une ``Observation`` (ou ``None`` si N/A).
+DocMetricFn = Callable[[DocContext], Observation | None]
+
+#: Une métrique inter-moteurs renvoie ``(valeur, support)`` (``None`` si N/A).
+CrossEngineFn = Callable[[CrossEngineContext], tuple[float | None, int]]
+
+
+@dataclass(frozen=True)
+class DocumentMetric:
+    """Métrique scalaire par-document : fiche + fonction co-localisées."""
+
+    spec: MetricSpec
+    fn: DocMetricFn
+
+    @property
+    def name(self) -> str:
+        return self.spec.name
+
+    @property
+    def input_types(self) -> tuple[ArtifactType, ArtifactType]:
+        return self.spec.input_types
+
+
+@dataclass(frozen=True)
+class CrossEngineMetric:
+    """Métrique inter-moteurs : compare les pipelines entre eux sur une métrique."""
+
+    name: str
+    description: str
+    fn: CrossEngineFn
+
+
+def document_metric(
+    *,
+    name: str,
+    input_types: tuple[ArtifactType, ArtifactType],
+    description: str = "",
+    higher_is_better: bool = False,
+    tags: frozenset[str] = frozenset(),
+) -> Callable[[DocMetricFn], DocumentMetric]:
+    """Construit une ``DocumentMetric`` depuis une fonction (pur, sans effet)."""
+
+    def decorate(fn: DocMetricFn) -> DocumentMetric:
+        return DocumentMetric(
+            spec=MetricSpec(
+                name=name,
+                input_types=input_types,
+                description=description,
+                higher_is_better=higher_is_better,
+                tags=tags,
+            ),
+            fn=fn,
+        )
+
+    return decorate
+
+
+def cross_engine_metric(
+    *, name: str, description: str = ""
+) -> Callable[[CrossEngineFn], CrossEngineMetric]:
+    """Construit une ``CrossEngineMetric`` depuis une fonction (pur, sans effet)."""
+
+    def decorate(fn: CrossEngineFn) -> CrossEngineMetric:
+        return CrossEngineMetric(name=name, description=description, fn=fn)
+
+    return decorate
+
+
+__all__ = [
+    "CrossEngineFn",
+    "CrossEngineMetric",
+    "DocMetricFn",
+    "DocumentMetric",
+    "Observation",
+    "cross_engine_metric",
+    "document_metric",
+]
diff --git a/cinoc/evaluation/metrics/__init__.py b/cinoc/evaluation/metrics/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..79831dd9d76914e11fcdfe4da576ff208e9a7974
--- /dev/null
+++ b/cinoc/evaluation/metrics/__init__.py
@@ -0,0 +1,3 @@
+"""Métriques (couche 3) — une famille par sous-module, collectées explicitement."""
+
+from __future__ import annotations
diff --git a/cinoc/evaluation/metrics/archaic.py b/cinoc/evaluation/metrics/archaic.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed372375a125c2c45ff6ea63fd213a4cef21cd0a
--- /dev/null
+++ b/cinoc/evaluation/metrics/archaic.py
@@ -0,0 +1,86 @@
+"""Scalaires ``air``/``hcpr`` : préservation & apport net d'archaïsmes (couche 3).
+
+Deux scalaires par-document, jumeaux de ``mufi_err``/``diacritic_err`` au registre
+(colonnes ``by_engine``), mais bâtis sur une **liste configurable** de caractères
+archaïques (cf. :mod:`cinoc.evaluation.archaic`). La liste n'est pas une entrée du
+``DocContext`` (qui n'est qu'une paire de textes) : elle est **liée à la métrique
+à l'enregistrement** par une fabrique (fermeture). Le registre enregistre ``air``
+sur la liste par défaut (``archaic_core``) ; l'app **relie** ``air`` et enregistre
+``hcpr`` sur la liste réellement configurée d'un run (cf.
+:mod:`cinoc.app.orchestrator`).
+
+- ``air`` (apport net) — *plus bas = mieux*, **actif par défaut** (Q4).
+- ``hcpr`` (préservation) — *plus haut = mieux*, **visible seulement sur liste
+  configurée** (anti-colonne-jumelle de ``mufi_err`` sur corpus médiéval).
+"""
+
+from __future__ import annotations
+
+from cinoc.domain.artifacts import ArtifactType
+from cinoc.evaluation.archaic import (
+    DEFAULT_ARCHAIC_LIST,
+    air_observation,
+    hcpr_observation,
+    resolve_archaic_list,
+)
+from cinoc.evaluation.context import DocContext
+from cinoc.evaluation.errors import EvaluationError
+from cinoc.evaluation.metric import DocumentMetric, Observation, document_metric
+
+
+def _text_pair(ctx: DocContext, name: str) -> tuple[str, str]:
+    if not isinstance(ctx.reference, str) or not isinstance(ctx.hypothesis, str):
+        raise EvaluationError(
+            f"{name} : reference et hypothesis doivent être du texte."
+        )
+    return ctx.reference, ctx.hypothesis
+
+
+def make_air_metric(chars: frozenset[str]) -> DocumentMetric:
+    """Métrique ``air`` liée à une liste de caractères archaïques."""
+
+    @document_metric(
+        name="air",
+        input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+        description=(
+            "Apport net d'archaïsmes : part des caractères archaïques de la "
+            "sortie qui sont insérés (absents à leur place dans la GT) — "
+            "sur-historicisation."
+        ),
+        higher_is_better=False,
+        tags=frozenset({"text", "philology", "alignment", "archaic"}),
+    )
+    def air(ctx: DocContext) -> Observation | None:
+        reference, hypothesis = _text_pair(ctx, "air")
+        return air_observation(reference, hypothesis, chars)
+
+    return air
+
+
+def make_hcpr_metric(chars: frozenset[str]) -> DocumentMetric:
+    """Métrique ``hcpr`` liée à une liste de caractères archaïques."""
+
+    @document_metric(
+        name="hcpr",
+        input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+        description=(
+            "Taux de préservation des caractères archaïques de la GT (liste "
+            "configurée) dans la sortie."
+        ),
+        higher_is_better=True,
+        tags=frozenset({"text", "philology", "alignment", "archaic"}),
+    )
+    def hcpr(ctx: DocContext) -> Observation | None:
+        reference, hypothesis = _text_pair(ctx, "hcpr")
+        return hcpr_observation(reference, hypothesis, chars)
+
+    return hcpr
+
+
+#: ``air`` sur la liste par défaut — socle du registre (``hcpr`` est opt-in,
+#: relié par l'app sur la liste configurée d'un run).
+ARCHAIC_METRICS: tuple[DocumentMetric, ...] = (
+    make_air_metric(resolve_archaic_list(DEFAULT_ARCHAIC_LIST).chars),
+)
+
+__all__ = ["ARCHAIC_METRICS", "make_air_metric", "make_hcpr_metric"]
diff --git a/cinoc/evaluation/metrics/bow.py b/cinoc/evaluation/metrics/bow.py
new file mode 100644
index 0000000000000000000000000000000000000000..7408f3eb28b1f52171942af9222b365bf9a0b73c
--- /dev/null
+++ b/cinoc/evaluation/metrics/bow.py
@@ -0,0 +1,90 @@
+"""Bag-of-Words : précision / rappel / F1 sur le **multiset de tokens** (mots),
+indépendants de l'ordre — lecture « recherche / rappel d'information ».
+
+Pour chaque token, le **vrai positif** est ``min(compte_réf, compte_hyp)`` :
+
+- ``tp = Σ min(compte_réf, compte_hyp)`` sur tous les tokens distincts ;
+- ``précision = tp / |hyp|`` (part des mots produits qui sont justes) ;
+- ``rappel    = tp / |réf|`` (part des mots attendus retrouvés) ;
+- ``F1 = 2·P·R / (P + R)``.
+
+Insensible à l'ordre des mots (sac de mots), déterministe. Utile quand le
+document sera **cherché en plein texte** : un mot juste compte, où qu'il soit.
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+
+from cinoc.domain.artifacts import ArtifactType
+from cinoc.evaluation.context import DocContext
+from cinoc.evaluation.errors import EvaluationError
+from cinoc.evaluation.metric import DocumentMetric, Observation, document_metric
+
+
+def _tokens(ctx: DocContext) -> tuple[list[str], list[str]]:
+    if not isinstance(ctx.reference, str) or not isinstance(ctx.hypothesis, str):
+        raise EvaluationError(
+            "bag-of-words : reference et hypothesis doivent être du texte."
+        )
+    return ctx.reference.split(), ctx.hypothesis.split()
+
+
+def _true_positives(ref: list[str], hyp: list[str]) -> int:
+    """``Σ min(compte_réf, compte_hyp)`` — intersection des multisets de tokens."""
+    return sum((Counter(ref) & Counter(hyp)).values())
+
+
+@document_metric(
+    name="bow_precision",
+    input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+    description="Bag-of-Words — précision : mots justes produits / mots produits.",
+    higher_is_better=True,
+    tags=frozenset({"text", "word", "search", "bag_of_words"}),
+)
+def bow_precision(ctx: DocContext) -> Observation:
+    """Poids = ``|hyp|`` → l'agrégat micro vaut ``Σtp / Σ|hyp|``."""
+    ref, hyp = _tokens(ctx)
+    tp = _true_positives(ref, hyp)
+    value = tp / len(hyp) if hyp else (1.0 if not ref else 0.0)
+    return Observation(value=value, weight=len(hyp))
+
+
+@document_metric(
+    name="bow_recall",
+    input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+    description="Bag-of-Words — rappel : mots attendus retrouvés / mots attendus.",
+    higher_is_better=True,
+    tags=frozenset({"text", "word", "search", "bag_of_words"}),
+)
+def bow_recall(ctx: DocContext) -> Observation:
+    """Poids = ``|réf|`` → l'agrégat micro vaut ``Σtp / Σ|réf|``."""
+    ref, hyp = _tokens(ctx)
+    tp = _true_positives(ref, hyp)
+    value = tp / len(ref) if ref else 1.0
+    return Observation(value=value, weight=len(ref))
+
+
+@document_metric(
+    name="bow_f1",
+    input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+    description="Bag-of-Words — F1 : moyenne harmonique précision/rappel des mots.",
+    higher_is_better=True,
+    tags=frozenset({"text", "word", "search", "bag_of_words"}),
+)
+def bow_f1(ctx: DocContext) -> Observation:
+    """F1 par document ; agrégat corpus = **moyenne pondérée par la taille**
+    (poids ``|réf|``) — pas le F1 micro exact (non linéaire), choix documenté."""
+    ref, hyp = _tokens(ctx)
+    tp = _true_positives(ref, hyp)
+    precision = tp / len(hyp) if hyp else (1.0 if not ref else 0.0)
+    recall = tp / len(ref) if ref else 1.0
+    denom = precision + recall
+    f1 = 2 * precision * recall / denom if denom else 0.0
+    return Observation(value=f1, weight=len(ref))
+
+
+#: Socle « sac de mots » (recherche plein-texte), collecté par le registre.
+BOW_METRICS: tuple[DocumentMetric, ...] = (bow_precision, bow_recall, bow_f1)
+
+__all__ = ["BOW_METRICS", "bow_f1", "bow_precision", "bow_recall"]
diff --git a/cinoc/evaluation/metrics/conformity.py b/cinoc/evaluation/metrics/conformity.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec3517b7d7f7df2d49fe758fa578eb42c696c6cc
--- /dev/null
+++ b/cinoc/evaluation/metrics/conformity.py
@@ -0,0 +1,49 @@
+"""Métrique de conformité HIPE : ``cmer`` — MER au **caractère** (couche 3).
+
+Le scorer HIPE-OCRepair classe sur le Match Error Rate caractère
+``(S+D+I)/(H+S+D+I)`` — **borné [0, 1]**, contrairement au CER classique qu'un
+modèle génératif fait dépasser 100 % (SPEC_HIPE §1.1). ``mer`` (mot) existe déjà
+au socle ; ``cmer`` est son pendant caractère. Comptes H/S/D/I via
+``rapidfuzz.editops`` (la plein-matrice maison de ``text._align`` serait trop
+coûteuse sur des documents entiers — même arbitrage que ``diacritic_err``).
+
+Conformité prouvée par parité ``jiwer.process_characters`` (oracle de test,
+même formule que le scorer) + golden vs scorer épinglé (job CI 3.12).
+"""
+
+from __future__ import annotations
+
+from cinoc.domain.artifacts import ArtifactType
+from cinoc.evaluation._alignment import char_mer
+from cinoc.evaluation.context import DocContext
+from cinoc.evaluation.errors import EvaluationError
+from cinoc.evaluation.metric import DocumentMetric, Observation, document_metric
+
+
+@document_metric(
+    name="cmer",
+    input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+    description=(
+        "Match Error Rate caractère : (S+D+I)/(H+S+D+I), borné [0,1] — "
+        "la métrique de classement du scorer HIPE-OCRepair."
+    ),
+    higher_is_better=False,
+    tags=frozenset({"text", "conformity"}),
+)
+def cmer(ctx: DocContext) -> Observation:
+    """``edits / (longueur_référence + insertions)`` ; deux textes vides → 0.0.
+
+    ``weight`` = le dénominateur ``H+S+D+I`` : le micro-agrégat du runner
+    (Σ erreurs / Σ dénominateurs) reproduit exactement le ``cmer_micro`` du
+    scorer (somme des comptes puis ratio, SPEC_HIPE §4.1).
+    """
+    if not isinstance(ctx.reference, str) or not isinstance(ctx.hypothesis, str):
+        raise EvaluationError("cmer : reference et hypothesis doivent être du texte.")
+    value, _edits, denom = char_mer(ctx.reference, ctx.hypothesis)
+    return Observation(value=value, weight=denom)
+
+
+#: Métriques de conformité, collectées explicitement par le registre.
+CONFORMITY_METRICS: tuple[DocumentMetric, ...] = (cmer,)
+
+__all__ = ["CONFORMITY_METRICS", "cmer"]
diff --git a/cinoc/evaluation/metrics/diacritics.py b/cinoc/evaluation/metrics/diacritics.py
new file mode 100644
index 0000000000000000000000000000000000000000..9980574468af1b31e0c8e39386caa06a05ee47f5
--- /dev/null
+++ b/cinoc/evaluation/metrics/diacritics.py
@@ -0,0 +1,59 @@
+"""Métrique philologique **diacritiques** : taux d'erreur sur les caractères
+porteurs de signes (umlauts ä/ö/ü, accents é/è/ê…), mesuré par **alignement
+caractère** position-aware.
+
+Contrairement à CER/WER/MER — implémentations pures (journal D-007) — cette
+métrique exige un alignement caractère sur des documents entiers (plusieurs
+milliers de caractères) : une plein-matrice en Python pur serait trop coûteuse
+en CI. Elle s'appuie donc sur ``rapidfuzz`` (whitelist ``evaluation/``, C,
+déterministe) — **c'est la tranche qui introduit cette dépendance** (cf.
+``MIGRATION_COUCHE_3.md``). ``text.py`` reste, lui, sans dépendance externe.
+"""
+
+from __future__ import annotations
+
+import unicodedata
+
+from cinoc.domain.artifacts import ArtifactType
+from cinoc.evaluation.context import DocContext
+from cinoc.evaluation.errors import EvaluationError
+from cinoc.evaluation.metric import DocumentMetric, Observation, document_metric
+from cinoc.evaluation.preservation import preservation_counts
+
+
+def _is_diacritic(char: str) -> bool:
+    """Vrai si ``char`` porte un signe combinant (décomposition NFD → catégorie
+    ``Mn``). Capte les lettres accentuées précomposées (ä, é, ñ…) ; exclut les
+    bases sans accent (``ß`` ; ``æ`` est une ligature, pas un diacritique)."""
+    return any(
+        unicodedata.category(part) == "Mn"
+        for part in unicodedata.normalize("NFD", char)
+    )
+
+
+@document_metric(
+    name="diacritic_err",
+    input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+    description="Taux d'erreur sur les caractères à diacritique (umlauts, accents).",
+    higher_is_better=False,
+    tags=frozenset({"text", "philology", "alignment"}),
+)
+def diacritic_error(ctx: DocContext) -> Observation | None:
+    """Parmi les caractères à diacritique de la **référence**, fraction mal
+    reconnue (substituée ou supprimée dans l'alignement). ``None`` si la référence
+    n'en contient aucun (non applicable) — le runner exclut ce cas de l'agrégat."""
+    if not isinstance(ctx.reference, str) or not isinstance(ctx.hypothesis, str):
+        raise EvaluationError(
+            "diacritic_err : reference et hypothesis doivent être du texte."
+        )
+    counts = preservation_counts(ctx.reference, ctx.hypothesis, _is_diacritic)
+    if counts is None:
+        return None
+    n_total, n_wrong = counts
+    return Observation(value=n_wrong / n_total, weight=n_total)
+
+
+#: Métriques philologiques par alignement caractère (dépendent de ``rapidfuzz``).
+DIACRITIC_METRICS: tuple[DocumentMetric, ...] = (diacritic_error,)
+
+__all__ = ["DIACRITIC_METRICS", "diacritic_error"]
diff --git a/cinoc/evaluation/metrics/diagnostics.py b/cinoc/evaluation/metrics/diagnostics.py
new file mode 100644
index 0000000000000000000000000000000000000000..9070f594f5de6c7e562a9ebc64fc23691eb69fab
--- /dev/null
+++ b/cinoc/evaluation/metrics/diagnostics.py
@@ -0,0 +1,91 @@
+"""Métriques de diagnostic texte : cherchabilité, hallucination (couche 3).
+
+Heuristiques **maison** (PLAN_PARITE §5.8b : spécification de départ relue,
+valeurs de test dérivées à la main — jamais en exécutant la source).
+
+- ``searchability`` — la question des bibliothèques numériques : quelle part
+  des mots de la référence un lecteur retrouve-t-il par recherche plein-texte
+  **tolérante** (distance de Levenshtein ≤ 2) dans la transcription ?
+  Appariement multi-ensemble : un mot produit ne « retrouve » qu'une seule
+  occurrence de référence.
+- ``hallucination`` — critique pour les pipelines de post-correction LLM :
+  part des trigrammes de caractères de l'hypothèse **absents** de la
+  référence (1 − ancrage n-gramme). Un texte fidèle ancre presque tous ses
+  trigrammes ; une invention en ancre peu. Plus haut = pire.
+"""
+
+from __future__ import annotations
+
+from rapidfuzz.distance import Levenshtein
+
+from cinoc.domain.artifacts import ArtifactType
+from cinoc.evaluation.context import DocContext
+from cinoc.evaluation.metric import DocumentMetric, Observation, document_metric
+
+#: Distance d'édition tolérée par la recherche plein-texte (mot à mot).
+_SEARCH_MAX_DISTANCE = 2
+#: Taille des n-grammes d'ancrage de ``hallucination``.
+_NGRAM = 3
+
+
+def _text_pair(ctx: DocContext) -> tuple[str, str]:
+    return str(ctx.reference), str(ctx.hypothesis)
+
+
+@document_metric(
+    name="searchability",
+    input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+    description=(
+        "Part des mots de la référence retrouvables dans l'hypothèse à "
+        "distance de Levenshtein <= 2 (recherche plein-texte tolérante)."
+    ),
+    higher_is_better=True,
+    tags=frozenset({"text", "diagnostics"}),
+)
+def searchability(ctx: DocContext) -> Observation | None:
+    reference, hypothesis = _text_pair(ctx)
+    targets = reference.split()
+    if not targets:
+        return None
+    pool = hypothesis.split()
+    used = [False] * len(pool)
+    found = 0
+    for target in targets:
+        for index, word in enumerate(pool):
+            if used[index]:
+                continue
+            if Levenshtein.distance(target, word) <= _SEARCH_MAX_DISTANCE:
+                used[index] = True
+                found += 1
+                break
+    return Observation(value=found / len(targets), weight=len(targets))
+
+
+def _ngrams(text: str) -> list[str]:
+    return [text[i : i + _NGRAM] for i in range(len(text) - _NGRAM + 1)]
+
+
+@document_metric(
+    name="hallucination",
+    input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+    description=(
+        "Part des trigrammes de caractères de l'hypothèse absents de la "
+        "référence (1 - ancrage) : du texte inventé n'est pas ancré."
+    ),
+    higher_is_better=False,
+    tags=frozenset({"text", "diagnostics"}),
+)
+def hallucination(ctx: DocContext) -> Observation | None:
+    reference, hypothesis = _text_pair(ctx)
+    produced = _ngrams(hypothesis)
+    if not produced:
+        return None  # hypothèse trop courte : rien à ancrer
+    anchored = set(_ngrams(reference))
+    unanchored = sum(1 for gram in produced if gram not in anchored)
+    return Observation(value=unanchored / len(produced), weight=len(produced))
+
+
+#: Socle diagnostic, collecté explicitement par le registre.
+DIAGNOSTIC_METRICS: tuple[DocumentMetric, ...] = (searchability, hallucination)
+
+__all__ = ["DIAGNOSTIC_METRICS", "hallucination", "searchability"]
diff --git a/cinoc/evaluation/metrics/flexible.py b/cinoc/evaluation/metrics/flexible.py
new file mode 100644
index 0000000000000000000000000000000000000000..7983a2af0cd642e792054cf36fdf4d125647e22e
--- /dev/null
+++ b/cinoc/evaluation/metrics/flexible.py
@@ -0,0 +1,88 @@
+"""Flexible Character Accuracy (FCA) — exactitude caractère indépendante de
+l'ordre de lecture.
+
+Capture le cœur de Clausner et al. (ICDAR 2019) : un texte transcrit dans un
+**ordre de lecture différent** (colonnes interverties, blocs réordonnés) ne doit
+pas être pénalisé comme une erreur de caractère. Méthode ici : **appariement
+optimal de lignes** (algorithme hongrois sur les distances d'édition
+ligne-à-ligne), donc :
+
+- chaque ligne de référence est appariée à **au plus une** ligne d'hypothèse de
+  façon à **minimiser la distance d'édition totale**, sans tenir compte de
+  l'ordre des lignes ;
+- une ligne de référence non appariée coûte toute sa longueur (suppression) ;
+- une ligne d'hypothèse non appariée coûte toute sa longueur (insertion) ;
+- FCA = 1 − erreurs / nombre de caractères de référence, bornée [0, 1].
+
+⚠️ On ne fait **pas** l'appariement *sous-ligne* récursif de l'algorithme
+original (une ligne de réf. coupée puis appariée à plusieurs lignes
+d'hypothèse) ni sa recherche de coefficients — variante plus lourde et **non
+déterministe**, différée. La méthode retenue est entièrement **déterministe et
+auditable** (invariant §12), ce qui prime sur la fidélité bit-à-bit à une
+implémentation de référence.
+"""
+
+from __future__ import annotations
+
+from cinoc.domain.artifacts import ArtifactType
+from cinoc.evaluation.context import DocContext
+from cinoc.evaluation.errors import EvaluationError
+from cinoc.evaluation.metric import DocumentMetric, Observation, document_metric
+
+
+def _flexible_errors(gt_lines: list[str], ocr_lines: list[str]) -> int:
+    """Coût d'édition total sous appariement optimal de lignes (ordre libre)."""
+    import numpy as np
+    from rapidfuzz.distance import Levenshtein
+    from rapidfuzz.process import cdist
+    from scipy.optimize import linear_sum_assignment  # type: ignore[import-untyped]
+
+    n, m = len(gt_lines), len(ocr_lines)
+    # Coût d'un appariement « interdit » : strictement pire que tout (suppression
+    # + insertion de toutes les lignes) → jamais choisi par l'optimiseur.
+    forbidden = sum(map(len, gt_lines)) + sum(map(len, ocr_lines)) + 1
+    # Matrice carrée (n+m) : lignes réelles + nœuds « non apparié » (dummies).
+    cost = np.zeros((n + m, n + m), dtype=np.int64)
+    if n and m:
+        cost[:n, :m] = cdist(
+            gt_lines, ocr_lines, scorer=Levenshtein.distance, dtype=np.int64
+        )
+    # Bloc « réf. non appariée » : diagonale = longueur (suppression), reste interdit.
+    cost[:n, m:] = forbidden
+    for i in range(n):
+        cost[i, m + i] = len(gt_lines[i])
+    # Bloc « hyp. non appariée » : diagonale = longueur (insertion), reste interdit.
+    cost[n:, :m] = forbidden
+    for j in range(m):
+        cost[n + j, j] = len(ocr_lines[j])
+    rows, cols = linear_sum_assignment(cost)
+    return int(cost[rows, cols].sum())
+
+
+@document_metric(
+    name="fca",
+    input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+    description=(
+        "Flexible Character Accuracy : exactitude caractère par appariement "
+        "optimal de lignes (indépendante de l'ordre de lecture)."
+    ),
+    higher_is_better=True,
+    tags=frozenset({"text", "accuracy", "reading_order"}),
+)
+def flexible_character_accuracy(ctx: DocContext) -> Observation:
+    if not isinstance(ctx.reference, str) or not isinstance(ctx.hypothesis, str):
+        raise EvaluationError("fca : reference et hypothesis doivent être du texte.")
+    gt_lines = [ln for ln in ctx.reference.splitlines() if ln.strip()]
+    ocr_lines = [ln for ln in ctx.hypothesis.splitlines() if ln.strip()]
+    total = sum(len(ln) for ln in gt_lines)
+    if total == 0:
+        # Réf. vide : exact ssi l'hypothèse l'est aussi ; poids 0 → exclue du micro.
+        return Observation(value=1.0 if not ocr_lines else 0.0, weight=0)
+    errors = _flexible_errors(gt_lines, ocr_lines)
+    return Observation(value=max(0.0, 1.0 - errors / total), weight=total)
+
+
+#: Socle « ordre de lecture libre », collecté explicitement par le registre.
+FLEXIBLE_METRICS: tuple[DocumentMetric, ...] = (flexible_character_accuracy,)
+
+__all__ = ["FLEXIBLE_METRICS", "flexible_character_accuracy"]
diff --git a/cinoc/evaluation/metrics/layout.py b/cinoc/evaluation/metrics/layout.py
new file mode 100644
index 0000000000000000000000000000000000000000..c9d6765aa75db933f25e9be53ab1b99478962a07
--- /dev/null
+++ b/cinoc/evaluation/metrics/layout.py
@@ -0,0 +1,190 @@
+"""Métriques de structure par bloc (couche 3) — ``region_cer`` + ``region_detection``.
+
+- ``region_cer`` : texte **région par région** (apparié par ``id``), micro-agrégé
+  page (Σ erreurs / Σ caractères).
+- ``region_detection`` : qualité de la **segmentation géométrique** — F1 des
+  régions appariées par **IoU de boîte** (≥ 0.5), en coordonnées **relatives à la
+  page** (donc robuste aux unités : mm10 ALTO vs pixels). Pas de ``shapely`` :
+  IoU de boîtes (boîte dérivée du polygone pour PAGE) ; l'IoU polygonal exact est
+  un épaississement (aucun consommateur ne l'exige encore).
+
+Convention métier (CLAUDE.md §3) : **niveau absent → métrique non applicable
+(``None``)**. ``region_cer`` : pas de niveau texte → ``None``. ``region_detection`` :
+aucune région géo-localisable côté référence → ``None``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+
+from cinoc.domain.artifacts import ArtifactType
+from cinoc.domain.layout import CanonicalLayout, Region
+from cinoc.evaluation.context import DocContext
+from cinoc.evaluation.errors import EvaluationError
+from cinoc.evaluation.metric import DocumentMetric, Observation, document_metric
+from cinoc.evaluation.metrics.text import _edit_distance
+
+_MISSING = ""
+
+#: Seuil d'IoU standard pour qu'une région hypothèse compte comme détectée.
+_IOU_THRESHOLD = 0.5
+
+#: Boîte en coordonnées relatives ``(x0, y0, x1, y1)`` ∈ [0, 1].
+_RelBox = tuple[float, float, float, float]
+
+
+def _walk(regions: tuple[Region, ...]) -> list[Region]:
+    """Aplati les régions imbriquées en parcours profondeur d'abord."""
+    flat: list[Region] = []
+    for region in regions:
+        flat.append(region)
+        flat.extend(_walk(region.regions))
+    return flat
+
+
+def _region_texts(layout: CanonicalLayout) -> dict[str, str]:
+    """``{region_id: texte}`` (lignes jointes) sur toutes les pages."""
+    texts: dict[str, str] = {}
+    for page in layout.pages:
+        for region in _walk(page.regions):
+            texts[region.id] = "\n".join(line.text for line in region.lines)
+    return texts
+
+
+def _has_text_level(layout: CanonicalLayout) -> bool:
+    """Vrai si au moins une région porte une ligne (≠ segmentation-seule)."""
+    return any(
+        region.lines
+        for page in layout.pages
+        for region in _walk(page.regions)
+    )
+
+
+def _layout_pair(ctx: DocContext) -> tuple[CanonicalLayout, CanonicalLayout]:
+    if not isinstance(ctx.reference, CanonicalLayout) or not isinstance(
+        ctx.hypothesis, CanonicalLayout
+    ):
+        raise EvaluationError(
+            "métrique structure : reference et hypothesis doivent être des "
+            "CanonicalLayout."
+        )
+    return ctx.reference, ctx.hypothesis
+
+
+@document_metric(
+    name="region_cer",
+    input_types=(ArtifactType.LAYOUT, ArtifactType.LAYOUT),
+    description="CER par région agrégé à la page (micro) sur le CanonicalLayout.",
+    higher_is_better=False,
+    tags=frozenset({"structure", "edit_distance", "layout"}),
+)
+def region_cer(ctx: DocContext) -> Observation | None:
+    reference, hypothesis = _layout_pair(ctx)
+    if not _has_text_level(hypothesis) or not _has_text_level(reference):
+        return None
+    ref_texts = _region_texts(reference)
+    hyp_texts = _region_texts(hypothesis)
+    total_edits = 0
+    total_chars = 0
+    for region_id, ref_text in ref_texts.items():
+        hyp_text = hyp_texts.get(region_id, _MISSING)
+        total_edits += _edit_distance(ref_text, hyp_text)
+        total_chars += len(ref_text)
+    if total_chars == 0:
+        return None
+    return Observation(value=total_edits / total_chars, weight=total_chars)
+
+
+def _leaf_regions(regions: tuple[Region, ...]) -> Iterator[Region]:
+    """Régions **atomiques** (sans sous-région) — la granularité segmentée."""
+    for region in regions:
+        if region.regions:
+            yield from _leaf_regions(region.regions)
+        else:
+            yield region
+
+
+def _abs_bbox(region: Region) -> tuple[int, int, int, int] | None:
+    """Boîte absolue ``(x0, y0, x1, y1)`` depuis la bbox, sinon le polygone."""
+    geometry = region.geometry
+    if geometry is None:
+        return None
+    if geometry.bbox is not None:
+        b = geometry.bbox
+        return b.x, b.y, b.x + b.width, b.y + b.height
+    if geometry.polygon:
+        xs = [p[0] for p in geometry.polygon]
+        ys = [p[1] for p in geometry.polygon]
+        return min(xs), min(ys), max(xs), max(ys)
+    return None
+
+
+def _detection_boxes(layout: CanonicalLayout) -> list[_RelBox]:
+    """Boîtes des régions atomiques, **relatives** à la page (unités neutralisées).
+
+    Une page sans dimensions est ignorée (normalisation impossible).
+    """
+    boxes: list[_RelBox] = []
+    for page in layout.pages:
+        width, height = page.width, page.height
+        if not width or not height:
+            continue
+        for region in _leaf_regions(page.regions):
+            bbox = _abs_bbox(region)
+            if bbox is None:
+                continue
+            x0, y0, x1, y1 = bbox
+            boxes.append((x0 / width, y0 / height, x1 / width, y1 / height))
+    return boxes
+
+
+def _iou(a: _RelBox, b: _RelBox) -> float:
+    ix0, iy0 = max(a[0], b[0]), max(a[1], b[1])
+    ix1, iy1 = min(a[2], b[2]), min(a[3], b[3])
+    inter = max(0.0, ix1 - ix0) * max(0.0, iy1 - iy0)
+    union = (a[2] - a[0]) * (a[3] - a[1]) + (b[2] - b[0]) * (b[3] - b[1]) - inter
+    return inter / union if union > 0 else 0.0
+
+
+def _true_positives(ref: list[_RelBox], hyp: list[_RelBox], threshold: float) -> int:
+    """Appariement glouton déterministe : chaque réf prend sa meilleure hyp libre."""
+    used: set[int] = set()
+    matched = 0
+    for ref_box in ref:
+        best_iou, best_idx = threshold, -1
+        for index, hyp_box in enumerate(hyp):
+            if index in used:
+                continue
+            value = _iou(ref_box, hyp_box)
+            if value >= best_iou:
+                best_iou, best_idx = value, index
+        if best_idx >= 0:
+            used.add(best_idx)
+            matched += 1
+    return matched
+
+
+@document_metric(
+    name="region_detection",
+    input_types=(ArtifactType.LAYOUT, ArtifactType.LAYOUT),
+    description="F1 des régions appariées par IoU de boîte (≥0.5), coords relatives.",
+    higher_is_better=True,
+    tags=frozenset({"structure", "layout", "geometry", "detection"}),
+)
+def region_detection(ctx: DocContext) -> Observation | None:
+    reference, hypothesis = _layout_pair(ctx)
+    ref_boxes = _detection_boxes(reference)
+    if not ref_boxes:
+        return None  # rien de géo-localisable côté référence → non applicable
+    hyp_boxes = _detection_boxes(hypothesis)
+    tp = _true_positives(ref_boxes, hyp_boxes, _IOU_THRESHOLD)
+    precision = tp / len(hyp_boxes) if hyp_boxes else 0.0
+    recall = tp / len(ref_boxes)
+    f1 = 2 * precision * recall / (precision + recall) if precision + recall else 0.0
+    return Observation(value=f1, weight=len(ref_boxes))
+
+
+#: Socle de métriques de structure, collecté explicitement par le registre.
+LAYOUT_METRICS: tuple[DocumentMetric, ...] = (region_cer, region_detection)
+
+__all__ = ["LAYOUT_METRICS", "region_cer", "region_detection"]
diff --git a/cinoc/evaluation/metrics/ner.py b/cinoc/evaluation/metrics/ner.py
new file mode 100644
index 0000000000000000000000000000000000000000..1375266e5e2860044670bdd082fce808eb60ab1b
--- /dev/null
+++ b/cinoc/evaluation/metrics/ner.py
@@ -0,0 +1,52 @@
+"""Scalaire ``ner_f1`` : F1 micro global sur les entités nommées (couche 3).
+
+Jonction ``(ENTITIES, ENTITIES)`` que le registre type-driven accepte sans
+modification. Le calcul (appariement IoU + **reprojection R14** des spans
+hypothèse en coordonnées GT) vit dans ``evaluation.ner`` ; ici on n'expose que
+le F1 global comme ``Observation`` (poids = nombre d'entités GT → micro-agrégat
+au niveau corpus). ``None`` si la GT du document ne porte aucune entité (non
+applicable — jamais un faux zéro).
+"""
+
+from __future__ import annotations
+
+from cinoc.domain.artifacts import ArtifactType
+from cinoc.evaluation.context import DocContext
+from cinoc.evaluation.errors import EvaluationError
+from cinoc.evaluation.metric import DocumentMetric, Observation, document_metric
+from cinoc.evaluation.ner import EntitySet, compute_ner, prf
+
+
+def _entity_pair(ctx: DocContext) -> tuple[EntitySet, EntitySet]:
+    if not isinstance(ctx.reference, EntitySet) or not isinstance(
+        ctx.hypothesis, EntitySet
+    ):
+        raise EvaluationError(
+            "ner_f1 : reference et hypothesis doivent être des EntitySet."
+        )
+    return ctx.reference, ctx.hypothesis
+
+
+@document_metric(
+    name="ner_f1",
+    input_types=(ArtifactType.ENTITIES, ArtifactType.ENTITIES),
+    description=(
+        "F1 global sur entités nommées (IoU ≥ 0,5, labels casefold, spans "
+        "reprojetés en coordonnées GT). Mesure conjointement OCR + extracteur NER."
+    ),
+    higher_is_better=True,
+    tags=frozenset({"ner", "downstream", "entities"}),
+)
+def ner_f1(ctx: DocContext) -> Observation | None:
+    reference, hypothesis = _entity_pair(ctx)
+    if not reference.entities:
+        return None  # GT sans entité → non applicable
+    counts = compute_ner(reference, hypothesis)
+    _precision, _recall, f1 = prf(counts.tp, counts.fp, counts.fn)
+    return Observation(value=f1, weight=len(reference.entities))
+
+
+#: Socle NER, collecté explicitement par le registre.
+NER_METRICS: tuple[DocumentMetric, ...] = (ner_f1,)
+
+__all__ = ["NER_METRICS", "ner_f1"]
diff --git a/cinoc/evaluation/metrics/philology.py b/cinoc/evaluation/metrics/philology.py
new file mode 100644
index 0000000000000000000000000000000000000000..41a6c5b3f79fa22f1ef396aad488b2caea07724b
--- /dev/null
+++ b/cinoc/evaluation/metrics/philology.py
@@ -0,0 +1,76 @@
+"""Métrique philologique **MUFI** : taux d'erreur sur les caractères médiévaux
+spéciaux (zone privée MUFI, abréviations latines, lettres médiévales).
+
+Complète ``diacritic_err`` (signes combinants) sur un autre axe philologique :
+les **lettres et signes médiévaux** standardisés par la MUFI (Medieval Unicode
+Font Initiative) — soit dans la **zone d'usage privé** (PUA), soit des codepoints
+Unicode dédiés (``ſ`` s long, ``þ`` thorn, ligatures, abréviations latines de
+Latin Extended-D…). Un moteur OCR/HTR peut très bien rendre le texte courant mais
+échouer précisément sur ces glyphes — c'est ce que cette métrique isole.
+
+Même mécanique que ``diacritic_err`` : alignement caractère ``rapidfuzz``
+(whitelist ``evaluation/``, C, déterministe). ``text.py`` reste sans dépendance.
+"""
+
+from __future__ import annotations
+
+from cinoc.domain.artifacts import ArtifactType
+from cinoc.evaluation.context import DocContext
+from cinoc.evaluation.errors import EvaluationError
+from cinoc.evaluation.metric import DocumentMetric, Observation, document_metric
+from cinoc.evaluation.preservation import preservation_counts
+
+#: Plages Unicode où vivent les glyphes MUFI / médiévaux.
+#: ⚠️ **Pas de signes combinants** ici (bloc U+1DC0–U+1DFF volontairement exclu) :
+#: ils relèvent de ``diacritic_err`` (catégorie ``Mn``). ``mufi_err`` mesure des
+#: **lettres/ligatures/abréviations** à codepoint propre → axe disjoint.
+_MUFI_RANGES: tuple[tuple[int, int], ...] = (
+    (0xE000, 0xF8FF),      # Private Use Area (zone MUFI principale)
+    (0xF0000, 0xFFFFD),    # Supplementary PUA-A
+    (0x100000, 0x10FFFD),  # Supplementary PUA-B
+    (0xA720, 0xA7FF),      # Latin Extended-D (abréviations latines médiévales)
+    (0xFB00, 0xFB06),      # Ligatures latines (ff fi fl ffi ffl ſt st)
+)
+
+#: Lettres/signes médiévaux à codepoint dédié, hors plages ci-dessus.
+_MUFI_EXPLICIT: frozenset[str] = frozenset("þÞðÐƿǷſæÆœŒøØƀŧđħȝȜ")
+
+
+def _is_mufi(char: str) -> bool:
+    """Vrai si ``char`` est un glyphe MUFI / médiéval (PUA ou codepoint dédié)."""
+    cp = ord(char)
+    if any(lo <= cp <= hi for lo, hi in _MUFI_RANGES):
+        return True
+    return char in _MUFI_EXPLICIT
+
+
+@document_metric(
+    name="mufi_err",
+    input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+    description="Taux d'erreur sur les caractères MUFI / médiévaux "
+    "(PUA, abréviations latines, ſ/þ/ligatures…).",
+    higher_is_better=False,
+    tags=frozenset({"text", "philology", "alignment", "mufi"}),
+)
+def mufi_error(ctx: DocContext) -> Observation | None:
+    """Parmi les caractères MUFI de la **référence**, fraction mal reconnue
+    (substituée ou supprimée dans l'alignement). ``None`` si la référence n'en
+    contient aucun (non applicable) — le runner exclut ce cas de l'agrégat."""
+    if not isinstance(ctx.reference, str) or not isinstance(ctx.hypothesis, str):
+        raise EvaluationError(
+            "mufi_err : reference et hypothesis doivent être du texte."
+        )
+    # Accept #17 : on compte les glyphes MUFI **de la référence** mal reconnus
+    # (substitués/supprimés). Un MUFI *inséré* (présent en hyp, absent en réf)
+    # n'est pas compté : le dénominateur est l'ensemble des MUFI attendus.
+    counts = preservation_counts(ctx.reference, ctx.hypothesis, _is_mufi)
+    if counts is None:
+        return None
+    n_total, n_wrong = counts
+    return Observation(value=n_wrong / n_total, weight=n_total)
+
+
+#: Métriques philologiques MUFI (dépendent de ``rapidfuzz``).
+PHILOLOGY_METRICS: tuple[DocumentMetric, ...] = (mufi_error,)
+
+__all__ = ["PHILOLOGY_METRICS", "mufi_error"]
diff --git a/cinoc/evaluation/metrics/stats.py b/cinoc/evaluation/metrics/stats.py
new file mode 100644
index 0000000000000000000000000000000000000000..dafe1eb0dae8982659a43a1165b8bf4fd7837b0b
--- /dev/null
+++ b/cinoc/evaluation/metrics/stats.py
@@ -0,0 +1,61 @@
+"""Métriques inter-moteurs **statistiques** (scipy) : significativité.
+
+Significativité d'une différence entre pipelines sur une métrique par-document :
+**Wilcoxon** apparié (2 moteurs) ou **Friedman** (≥3), sur les **cas complets**
+(documents où *tous* les pipelines ont une valeur). ``None`` si support
+insuffisant ou aucune différence à tester (pas de variance).
+"""
+
+from __future__ import annotations
+
+from scipy import stats  # type: ignore[import-untyped]
+
+from cinoc.evaluation.context import CrossEngineContext
+from cinoc.evaluation.inference import MIN_SUPPORT
+from cinoc.evaluation.metric import CrossEngineMetric, cross_engine_metric
+
+#: Plancher de **puissance** (pas seulement de calcul) : sous ~6 paires, un
+#: Wilcoxon bilatéral ne peut **pas** atteindre p < 0,05 (n=6 → p_min exact ≈
+#: 0,031), et un Friedman à 2-3 blocs est dégénéré. Renvoyer une p-value sous ce
+#: seuil serait un artefact de petit n présenté comme un verdict → on rend ``None``.
+#: Source unique partagée avec l'inférentiel corrigé (``evaluation.inference``).
+_MIN_SUPPORT = MIN_SUPPORT
+
+
+@cross_engine_metric(
+    name="significance_p",
+    description="p-value d'une différence entre pipelines (Wilcoxon/Friedman).",
+)
+def significance(ctx: CrossEngineContext) -> tuple[float | None, int]:
+    pipelines = list(ctx.per_pipeline)
+    if len(pipelines) < 2:
+        return None, 0
+    series = [ctx.per_pipeline[name] for name in pipelines]
+    n_documents = len(series[0])
+    complete = [
+        [column[i] for column in series]
+        for i in range(n_documents)
+        if all(column[i] is not None for column in series)
+    ]
+    support = len(complete)
+    if support < _MIN_SUPPORT:
+        return None, support
+    if all(len(set(row)) == 1 for row in complete):
+        return None, support  # tous les pipelines égaux : rien à tester
+    columns = [list(values) for values in zip(*complete, strict=True)]
+    try:
+        if len(pipelines) == 2:
+            result = stats.wilcoxon(columns[0], columns[1])
+        else:
+            result = stats.friedmanchisquare(*columns)
+    except ValueError:  # pragma: no cover -- filet : entrée dégénérée résiduelle
+        # scipy refuse un échantillon que nos gardes n'ont pas écarté
+        # (ex. différences toutes nulles après abandon des ex æquo) → non testable.
+        return None, support
+    return float(result.pvalue), support
+
+
+#: Socle de métriques inter-moteurs, collecté explicitement par le registre.
+CROSS_ENGINE_METRICS: tuple[CrossEngineMetric, ...] = (significance,)
+
+__all__ = ["CROSS_ENGINE_METRICS", "significance"]
diff --git a/cinoc/evaluation/metrics/structured_data.py b/cinoc/evaluation/metrics/structured_data.py
new file mode 100644
index 0000000000000000000000000000000000000000..d08b6721e8c42602bf35ef69276be9a696425e62
--- /dev/null
+++ b/cinoc/evaluation/metrics/structured_data.py
@@ -0,0 +1,217 @@
+"""Données structurées : séquences numériques — détecteurs + scalaires (couche 3).
+
+Ce que cite et cherche un historien : **années** (1000-2099), **foliotation**
+(f./fol./p./pp./n° + recto/verso), **montants** (livres/sols/deniers/écus/
+florins/francs + symboles), **années régnales** (« an III », « l'an de grâce
+MCCCXV »). Le CER ne dit pas si « 1515 » a survécu — ces métriques le disent,
+sous deux lentilles :
+
+- **strict** : la forme exacte de la GT est restituée (« fol. 12r ») ;
+- **value** : l'équivalent est restitué, forme libre (« f. 12r », « an 3 »
+  pour « an III »).
+
+Regex volontairement **conservatrices** (la précision prime sur le rappel pour
+une métrique de restitution — les formes en toutes lettres ne sont pas
+couvertes). La catégorie *romain* vit dans la famille philologie (un seul
+comptage — réparation R1) ; le régnal n'utilise le parseur romain que comme
+**helper** de valeur.
+"""
+
+from __future__ import annotations
+
+import re
+from collections import Counter
+from dataclasses import dataclass
+
+from cinoc.domain.artifacts import ArtifactType
+from cinoc.evaluation.context import DocContext
+from cinoc.evaluation.errors import EvaluationError
+from cinoc.evaluation.metric import DocumentMetric, Observation, document_metric
+from cinoc.evaluation.roman import roman_to_int
+
+#: Ordre canonique des catégories (rendu + payload).
+CATEGORIES: tuple[str, ...] = ("year", "foliation", "currency", "regnal")
+
+#: Années plausibles en contexte patrimonial : 1000-2099, frontières de mot.
+_RE_YEAR = re.compile(r"\b(1[0-9]{3}|20[0-9]{2})\b")
+
+#: Foliotation : marqueur + numéro(s) (plage acceptée) + recto/verso optionnel.
+_RE_FOLIATION = re.compile(
+    r"\b(?:fol\.?|f\.|pp\.|p\.|n\.°|n°)\s*"
+    r"(\d+(?:\s*-\s*\d+)?)"
+    r"\s*([rvRV])?"
+)
+
+#: Montants : nombre + unité d'Ancien Régime ou symbole.
+_RE_CURRENCY = re.compile(
+    r"\b(\d+(?:[.,]\d+)?)\s*"
+    r"(livres?|sols?|deniers?|écus?|florins?|francs?|l\.|s\.|d\.|£|€|₣)"
+    r"(?=\b|[\s,;.!?:]|$)",
+    re.IGNORECASE,
+)
+
+_CURRENCY_CANONICAL = {
+    "livres": "livre",
+    "livre": "livre",
+    "l.": "livre",
+    "sols": "sol",
+    "sol": "sol",
+    "s.": "sol",
+    "deniers": "denier",
+    "denier": "denier",
+    "d.": "denier",
+    "écus": "écu",
+    "écu": "écu",
+    "florins": "florin",
+    "florin": "florin",
+    "francs": "franc",
+    "franc": "franc",
+    "£": "£",
+    "€": "€",
+    "₣": "₣",
+}
+
+#: Années régnales : « an III », « l'an 1793 », « an de grâce MCCCXV ».
+_RE_REGNAL = re.compile(
+    r"\b(?:l['’]\s*)?an\s+(?:de\s+(?:grâce|la\s+R[eé]publique)\s+)?"
+    r"([IVXLCDM]+|[ivxlcdm]+|\d{1,4})\b"
+)
+
+
+@dataclass(frozen=True)
+class SequenceItem:
+    """Une séquence détectée : sa catégorie, sa forme exacte, sa clé de valeur."""
+
+    category: str
+    form: str
+    #: Identité de **valeur** : "1515" (année), "12r" (folio), "3|livre"
+    #: (montant), "14" (régnal) — deux formes différentes de même clé sont
+    #: équivalentes sous la lentille *value*.
+    key: str
+
+
+def detect_sequences(text: str) -> tuple[SequenceItem, ...]:
+    """Toutes les séquences du texte, par ordre de catégorie puis d'apparition."""
+    items: list[SequenceItem] = []
+    for match in _RE_YEAR.finditer(text):
+        items.append(SequenceItem("year", match.group(0), match.group(1)))
+    for match in _RE_FOLIATION.finditer(text):
+        numbers = re.sub(r"\s", "", match.group(1))
+        side = (match.group(2) or "").lower()
+        items.append(SequenceItem("foliation", match.group(0), f"{numbers}{side}"))
+    for match in _RE_CURRENCY.finditer(text):
+        amount = match.group(1).replace(",", ".")
+        unit = _CURRENCY_CANONICAL[match.group(2).lower()]
+        items.append(SequenceItem("currency", match.group(0), f"{amount}|{unit}"))
+    for match in _RE_REGNAL.finditer(text):
+        raw = match.group(1)
+        value = int(raw) if raw.isdigit() else roman_to_int(raw)
+        if value is None:
+            continue
+        items.append(SequenceItem("regnal", match.group(0), str(value)))
+    return tuple(items)
+
+
+@dataclass(frozen=True)
+class CategoryCounts:
+    """Restitution d'une catégorie : totaux + formes perdues (lentille value)."""
+
+    n_total: int
+    n_strict: int
+    n_value: int
+    lost: tuple[str, ...]
+
+
+def sequence_counts(reference: str, hypothesis: str) -> dict[str, CategoryCounts]:
+    """Comptes par catégorie **présente dans la GT** (multiset des deux côtés).
+
+    *strict* apparie les **formes** exactes, *value* les **clés** — deux
+    consommations indépendantes (une forme appariée a toujours sa clé
+    appariable : ``value ≥ strict`` structurellement).
+    """
+    reference_items = detect_sequences(reference)
+    hypothesis_items = detect_sequences(hypothesis)
+    out: dict[str, CategoryCounts] = {}
+    for category in CATEGORIES:
+        gt = [item for item in reference_items if item.category == category]
+        if not gt:
+            continue
+        hyp = [item for item in hypothesis_items if item.category == category]
+        forms = Counter(item.form for item in hyp)
+        keys = Counter(item.key for item in hyp)
+        n_strict = n_value = 0
+        lost: list[str] = []
+        for item in gt:
+            if forms[item.form] > 0:
+                forms[item.form] -= 1
+                n_strict += 1
+            if keys[item.key] > 0:
+                keys[item.key] -= 1
+                n_value += 1
+            else:
+                lost.append(item.form)
+        out[category] = CategoryCounts(
+            n_total=len(gt), n_strict=n_strict, n_value=n_value, lost=tuple(lost)
+        )
+    return out
+
+
+def _text_pair(ctx: DocContext) -> tuple[str, str]:
+    if not isinstance(ctx.reference, str) or not isinstance(ctx.hypothesis, str):
+        raise EvaluationError(
+            "séquences numériques : reference et hypothesis doivent être du texte."
+        )
+    return ctx.reference, ctx.hypothesis
+
+
+def _global_score(ctx: DocContext, *, strict: bool) -> Observation | None:
+    reference, hypothesis = _text_pair(ctx)
+    counts = sequence_counts(reference, hypothesis)
+    total = sum(c.n_total for c in counts.values())
+    if total == 0:
+        return None  # GT sans séquence : non applicable, jamais un zéro.
+    preserved = sum((c.n_strict if strict else c.n_value) for c in counts.values())
+    return Observation(value=preserved / total, weight=total)
+
+
+@document_metric(
+    name="numseq_strict",
+    input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+    description=(
+        "Part des séquences numériques de la GT (années, folios, montants, "
+        "régnal) restituées sous leur forme exacte."
+    ),
+    higher_is_better=True,
+    tags=frozenset({"text", "structured_data"}),
+)
+def numseq_strict(ctx: DocContext) -> Observation | None:
+    return _global_score(ctx, strict=True)
+
+
+@document_metric(
+    name="numseq_value",
+    input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+    description=(
+        "Part des séquences numériques de la GT dont l'équivalent est restitué "
+        "(forme libre : « f. 12r » vaut « fol. 12r »)."
+    ),
+    higher_is_better=True,
+    tags=frozenset({"text", "structured_data"}),
+)
+def numseq_value(ctx: DocContext) -> Observation | None:
+    return _global_score(ctx, strict=False)
+
+
+#: Métriques de données structurées, collectées explicitement par le registre.
+STRUCTURED_DATA_METRICS: tuple[DocumentMetric, ...] = (numseq_strict, numseq_value)
+
+__all__ = [
+    "CATEGORIES",
+    "CategoryCounts",
+    "STRUCTURED_DATA_METRICS",
+    "SequenceItem",
+    "detect_sequences",
+    "numseq_strict",
+    "numseq_value",
+    "sequence_counts",
+]
diff --git a/cinoc/evaluation/metrics/text.py b/cinoc/evaluation/metrics/text.py
new file mode 100644
index 0000000000000000000000000000000000000000..b470f8b816df53a1bdadb277344cacfb8b082038
--- /dev/null
+++ b/cinoc/evaluation/metrics/text.py
@@ -0,0 +1,264 @@
+"""Métriques de l'axe texte : CER, WER, MER.
+
+Implémentations **déterministes et sans dépendance** (journal D-007) :
+- CER = distance d'édition au **caractère** / longueur de référence ;
+- WER = distance d'édition au **mot** / nombre de mots de référence ;
+- MER (Match Error Rate) = erreurs / (erreurs + correspondances), au mot.
+
+``jiwer`` sert d'**oracle de parité** (tests, dépendance *dev*) — jamais importé
+par le code de production. Cas dégénérés (référence vide) explicites.
+
+Coût : le caractère reste en deux lignes (mémoire linéaire) ; seule la matrice
+complète de ``_align`` (pour MER) tourne sur des **mots**, peu nombreux.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+from cinoc.domain.artifacts import ArtifactType
+from cinoc.evaluation.context import DocContext
+from cinoc.evaluation.errors import EvaluationError
+from cinoc.evaluation.metric import DocumentMetric, Observation, document_metric
+from cinoc.formats.text import get_builtin_profile
+
+#: Repli diplomatique minimal (NFC + ſ long → s), appliqué symétriquement par
+#: ``cer_diplo``. L'écart ``cer − cer_diplo`` = part d'erreur **purement
+#: typographique** (un ſ long mal lu cesse de compter comme une erreur).
+_DIPLOMATIC = get_builtin_profile("minimal")
+
+
+def _edit_distance(
+    reference: Sequence[object], hypothesis: Sequence[object]
+) -> int:
+    """Distance de Levenshtein sur deux séquences (deux lignes, O(m) mémoire)."""
+    previous = list(range(len(hypothesis) + 1))
+    for i, ref_token in enumerate(reference, start=1):
+        current = [i]
+        for j, hyp_token in enumerate(hypothesis, start=1):
+            cost = 0 if ref_token == hyp_token else 1
+            current.append(
+                min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + cost)
+            )
+        previous = current
+    return previous[-1]
+
+
+@dataclass(frozen=True)
+class _Alignment:
+    """Décompte d'un alignement optimal : correspondances + erreurs typées."""
+
+    hits: int
+    substitutions: int
+    deletions: int
+    insertions: int
+
+    @property
+    def edits(self) -> int:
+        return self.substitutions + self.deletions + self.insertions
+
+
+def _align(reference: Sequence[object], hypothesis: Sequence[object]) -> _Alignment:
+    """Alignement complet (matrice + backtrace) — pour MER, sur des **mots**."""
+    n, m = len(reference), len(hypothesis)
+    matrix = [[0] * (m + 1) for _ in range(n + 1)]
+    for i in range(n + 1):
+        matrix[i][0] = i
+    for j in range(m + 1):
+        matrix[0][j] = j
+    for i in range(1, n + 1):
+        for j in range(1, m + 1):
+            cost = 0 if reference[i - 1] == hypothesis[j - 1] else 1
+            matrix[i][j] = min(
+                matrix[i - 1][j - 1] + cost,
+                matrix[i - 1][j] + 1,
+                matrix[i][j - 1] + 1,
+            )
+    hits = subs = dels = ins = 0
+    i, j = n, m
+    while i > 0 or j > 0:
+        if (
+            i > 0
+            and j > 0
+            and reference[i - 1] == hypothesis[j - 1]
+            and matrix[i][j] == matrix[i - 1][j - 1]
+        ):
+            hits += 1
+            i, j = i - 1, j - 1
+        elif i > 0 and j > 0 and matrix[i][j] == matrix[i - 1][j - 1] + 1:
+            subs += 1
+            i, j = i - 1, j - 1
+        elif i > 0 and matrix[i][j] == matrix[i - 1][j] + 1:
+            dels += 1
+            i -= 1
+        else:
+            ins += 1
+            j -= 1
+    return _Alignment(hits=hits, substitutions=subs, deletions=dels, insertions=ins)
+
+
+def _error_rate(edits: int, reference_length: int) -> float:
+    """``edits / reference_length`` ; référence vide → 0.0 si exact, sinon 1.0."""
+    if reference_length == 0:
+        return 0.0 if edits == 0 else 1.0
+    return edits / reference_length
+
+
+def _text_pair(ctx: DocContext) -> tuple[str, str]:
+    if not isinstance(ctx.reference, str) or not isinstance(ctx.hypothesis, str):
+        raise EvaluationError(
+            "métrique texte : reference et hypothesis doivent être du texte."
+        )
+    return ctx.reference, ctx.hypothesis
+
+
+@document_metric(
+    name="cer",
+    input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+    description="Character Error Rate : distance d'édition / longueur de référence.",
+    higher_is_better=False,
+    tags=frozenset({"text", "edit_distance"}),
+)
+def cer(ctx: DocContext) -> Observation:
+    reference, hypothesis = _text_pair(ctx)
+    edits = _edit_distance(reference, hypothesis)
+    return Observation(
+        value=_error_rate(edits, len(reference)), weight=len(reference)
+    )
+
+
+@document_metric(
+    name="cer_diplo",
+    input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+    description="CER diplomatique : CER après repli ſ long→s (NFC), des deux côtés.",
+    higher_is_better=False,
+    tags=frozenset({"text", "edit_distance", "philology"}),
+)
+def cer_diplomatic(ctx: DocContext) -> Observation:
+    reference, hypothesis = _text_pair(ctx)
+    ref = _DIPLOMATIC.normalize(reference)
+    hyp = _DIPLOMATIC.normalize(hypothesis)
+    edits = _edit_distance(ref, hyp)
+    return Observation(value=_error_rate(edits, len(ref)), weight=len(ref))
+
+
+@document_metric(
+    name="wer",
+    input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+    description="Word Error Rate : distance d'édition au mot / nombre de mots de réf.",
+    higher_is_better=False,
+    tags=frozenset({"text", "edit_distance", "word"}),
+)
+def wer(ctx: DocContext) -> Observation:
+    reference, hypothesis = _text_pair(ctx)
+    ref_words, hyp_words = reference.split(), hypothesis.split()
+    edits = _edit_distance(ref_words, hyp_words)
+    return Observation(
+        value=_error_rate(edits, len(ref_words)), weight=len(ref_words)
+    )
+
+
+@document_metric(
+    name="mer",
+    input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+    description="Match Error Rate : erreurs / (erreurs + correspondances), au mot.",
+    higher_is_better=False,
+    tags=frozenset({"text", "edit_distance", "word"}),
+)
+def mer(ctx: DocContext) -> Observation:
+    reference, hypothesis = _text_pair(ctx)
+    alignment = _align(reference.split(), hypothesis.split())
+    total = alignment.hits + alignment.edits
+    return Observation(
+        value=alignment.edits / total if total else 0.0, weight=total
+    )
+
+
+@document_metric(
+    name="del_rate",
+    input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+    description="Taux de suppression au mot : mots de réf. omis / mots de réf.",
+    higher_is_better=False,
+    tags=frozenset({"text", "word", "error_profile"}),
+)
+def deletion_rate(ctx: DocContext) -> Observation:
+    reference, hypothesis = _text_pair(ctx)
+    ref_words = reference.split()
+    alignment = _align(ref_words, hypothesis.split())
+    return Observation(
+        value=_error_rate(alignment.deletions, len(ref_words)),
+        weight=len(ref_words),
+    )
+
+
+@document_metric(
+    name="ins_rate",
+    input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+    description="Taux d'insertion au mot : mots parasites ajoutés / mots de réf.",
+    higher_is_better=False,
+    tags=frozenset({"text", "word", "error_profile"}),
+)
+def insertion_rate(ctx: DocContext) -> Observation:
+    reference, hypothesis = _text_pair(ctx)
+    ref_words = reference.split()
+    alignment = _align(ref_words, hypothesis.split())
+    return Observation(
+        value=_error_rate(alignment.insertions, len(ref_words)),
+        weight=len(ref_words),
+    )
+
+
+@document_metric(
+    name="char_accuracy",
+    input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+    description="Exactitude caractère : 1 − CER, bornée [0, 1] (lecture ICDAR).",
+    higher_is_better=True,
+    tags=frozenset({"text", "edit_distance", "accuracy"}),
+)
+def char_accuracy(ctx: DocContext) -> Observation:
+    """``max(0, 1 − CER)`` ; poids = longueur de réf. → l'agrégat micro vaut
+    exactement ``1 − CER_micro`` (sauf plancher 0 quand un doc a CER > 1)."""
+    reference, hypothesis = _text_pair(ctx)
+    rate = _error_rate(_edit_distance(reference, hypothesis), len(reference))
+    return Observation(value=max(0.0, 1.0 - rate), weight=len(reference))
+
+
+@document_metric(
+    name="word_accuracy",
+    input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+    description="Exactitude mot : 1 − WER, bornée [0, 1] (lecture ICDAR).",
+    higher_is_better=True,
+    tags=frozenset({"text", "edit_distance", "word", "accuracy"}),
+)
+def word_accuracy(ctx: DocContext) -> Observation:
+    """``max(0, 1 − WER)`` ; poids = nb de mots de réf. (cf. ``char_accuracy``)."""
+    reference, hypothesis = _text_pair(ctx)
+    ref_words, hyp_words = reference.split(), hypothesis.split()
+    rate = _error_rate(_edit_distance(ref_words, hyp_words), len(ref_words))
+    return Observation(value=max(0.0, 1.0 - rate), weight=len(ref_words))
+
+
+#: Socle de métriques texte, collecté explicitement par le registre.
+TEXT_METRICS: tuple[DocumentMetric, ...] = (
+    cer,
+    cer_diplomatic,
+    char_accuracy,
+    word_accuracy,
+    wer,
+    mer,
+    deletion_rate,
+    insertion_rate,
+)
+
+__all__ = [
+    "TEXT_METRICS",
+    "cer",
+    "cer_diplomatic",
+    "char_accuracy",
+    "deletion_rate",
+    "insertion_rate",
+    "mer",
+    "wer",
+    "word_accuracy",
+]
diff --git a/cinoc/evaluation/ner.py b/cinoc/evaluation/ner.py
new file mode 100644
index 0000000000000000000000000000000000000000..57258b85e753313d5710c4b0132c413b9cf8231d
--- /dev/null
+++ b/cinoc/evaluation/ner.py
@@ -0,0 +1,354 @@
+"""Précision sur entités nommées : appariement IoU + reprojection R14 (couche 3).
+
+Pour un médiéviste ou un archiviste, l'utilité aval d'un OCR ne se mesure pas
+qu'au CER : ce qui compte est la **survie des entités nommées** (personnes,
+lieux, dates). Un CER de 5 % qui rate 80 % des noms propres est inutilisable en
+indexation prosopographique.
+
+**Réparation R14 (bug C9 de la source).** Les entités GT portent des offsets
+sur le **texte GT** ; les entités hypothèse, des offsets sur le **texte OCR**.
+Comparer leurs spans par IoU sans rien faire revient à comparer deux systèmes
+de coordonnées : toute insertion/délétion amont décale les offsets aval, et une
+entité **parfaitement transcrite** est comptée « manquée + hallucinée » dès que
+le drift dépasse sa longueur — le F1 mesure alors le profil ins/del de l'OCR,
+pas la préservation des entités. Avant l'IoU, on **reprojette** les spans
+hypothèse en coordonnées GT via un alignement caractère ``rapidfuzz`` (la
+mécanique des marqueurs positionnels), puis on apparie.
+
+Le format d'entités embarque donc **le texte de référence des offsets** :
+``{"text": str, "entities": [{"label", "start", "end", "text"?}]}``. La GT et la
+sortie le portent toutes deux — c'est ce qui rend la reprojection auto-suffisante
+(≠ source : la tolérance « liste nue sans texte » est abandonnée, R14 l'exige).
+
+Limite assumée : la métrique mesure **conjointement** OCR + modèle NER (un
+extracteur hallucine aussi) — documenté dans la section.
+"""
+
+from __future__ import annotations
+
+import json
+from collections import Counter
+from dataclasses import dataclass, field
+
+from rapidfuzz.distance import Levenshtein
+
+from cinoc.evaluation.analysis import (
+    Analysis,
+    EntityCategoryScore,
+    EntityMention,
+    NerPayload,
+    PipelineNer,
+)
+from cinoc.evaluation.errors import EvaluationError
+
+#: Seuil d'IoU pour qu'un appariement compte (convention CoNLL/HIPE).
+DEFAULT_IOU_THRESHOLD = 0.5
+
+#: Échantillons d'entités embarqués dans le payload (bornent la sortie).
+_MAX_MISSED = 20
+_MAX_HALLUCINATED = 20
+
+
+@dataclass(frozen=True)
+class Entity:
+    """Entité nommée : label + span caractère ``[start, end)`` + forme de surface.
+
+    ``text`` est **informatif** — jamais utilisé pour l'appariement (deux
+    entités matchent par recouvrement de spans, pas par égalité de surface).
+    """
+
+    label: str
+    start: int
+    end: int
+    text: str = ""
+
+    def __post_init__(self) -> None:
+        if self.start < 0 or self.start > self.end:
+            raise EvaluationError(
+                f"span d'entité invalide : start={self.start}, end={self.end}."
+            )
+
+    @property
+    def length(self) -> int:
+        return self.end - self.start
+
+
+@dataclass(frozen=True)
+class EntitySet:
+    """Un texte + les entités dont les offsets s'y rapportent.
+
+    Bundler le texte rend la reprojection R14 auto-suffisante : chaque côté
+    sait à quoi ses offsets réfèrent.
+    """
+
+    text: str
+    entities: tuple[Entity, ...]
+
+
+def parse_entities(data: bytes) -> EntitySet:
+    """Parse un sidecar entités ``{"text", "entities"}`` ; lève si malformé.
+
+    Anti-silence : un format invalide est une **erreur typée**, jamais un skip
+    muet (le défaut de la source qui renvoyait ``[]`` → rappel 0 sans message).
+    """
+    try:
+        payload = json.loads(data)
+    except (json.JSONDecodeError, UnicodeDecodeError) as exc:
+        raise EvaluationError(f"entités illisibles (JSON) : {exc}") from exc
+    if not isinstance(payload, dict) or "text" not in payload:
+        raise EvaluationError(
+            "entités : objet {\"text\", \"entities\"} attendu "
+            "(la liste nue sans texte n'est pas acceptée — R14 exige le texte)."
+        )
+    text = payload["text"]
+    raw_entities = payload.get("entities", [])
+    if not isinstance(text, str) or not isinstance(raw_entities, list):
+        raise EvaluationError("entités : 'text' (str) et 'entities' (list) requis.")
+    entities: list[Entity] = []
+    for item in raw_entities:
+        if not isinstance(item, dict):
+            raise EvaluationError(f"entité : objet attendu, reçu {type(item)}.")
+        try:
+            entities.append(
+                Entity(
+                    label=str(item["label"]),
+                    start=int(item["start"]),
+                    end=int(item["end"]),
+                    text=str(item.get("text", "")),
+                )
+            )
+        except (KeyError, TypeError, ValueError) as exc:
+            raise EvaluationError(f"entité invalide ({item!r}) : {exc}") from exc
+    return EntitySet(text=text, entities=tuple(entities))
+
+
+def build_position_map(reference: str, hypothesis: str) -> list[int]:
+    """``hyp_index → ref_index`` (longueur ``len(hypothesis) + 1``) — cœur de R14.
+
+    Aligne ``reference`` (a) et ``hypothesis`` (b) au caractère ; chaque position
+    de l'hypothèse reçoit la position GT correspondante. ``equal`` → 1:1 ;
+    ``replace`` → linéaire clampé ; ``insert`` (caractère OCR sans contrepartie
+    GT) → effondré sur la frontière GT ; ``delete`` → aucune position hyp à
+    remplir. Le sentinelle final mappe ``len(hyp) → len(ref)`` (borne d'un span
+    exclusif).
+    """
+    pos = [0] * (len(hypothesis) + 1)
+    for op in Levenshtein.opcodes(reference, hypothesis):
+        i1, i2, j1, j2 = op.src_start, op.src_end, op.dest_start, op.dest_end
+        if op.tag == "equal":
+            for k in range(j2 - j1):
+                pos[j1 + k] = i1 + k
+        elif op.tag == "replace":
+            for k in range(j2 - j1):
+                pos[j1 + k] = min(i1 + k, i2)
+        elif op.tag == "insert":
+            for k in range(j2 - j1):
+                pos[j1 + k] = i1
+        # delete : i1<i2, j1==j2 — pas de position hypothèse à remplir.
+    pos[len(hypothesis)] = len(reference)
+    return pos
+
+
+def remap_entities(
+    entities: tuple[Entity, ...], position_map: list[int]
+) -> list[Entity]:
+    """Reprojette des spans hypothèse en coordonnées GT via ``position_map``."""
+    remapped: list[Entity] = []
+    for entity in entities:
+        start = position_map[entity.start]
+        end = max(start, position_map[entity.end])
+        remapped.append(
+            Entity(label=entity.label, start=start, end=end, text=entity.text)
+        )
+    return remapped
+
+
+def _iou(a: Entity, b: Entity) -> float:
+    inter = max(0, min(a.end, b.end) - max(a.start, b.start))
+    union = a.length + b.length - inter
+    return inter / union if union > 0 else 0.0
+
+
+def align_entities(
+    references: list[Entity], hypotheses: list[Entity], iou_threshold: float
+) -> tuple[list[tuple[int, int]], set[int], set[int]]:
+    """Appariement glouton par IoU décroissant (chaque entité appariée ≤ 1 fois).
+
+    Renvoie ``(matches, unmatched_refs, unmatched_hyps)`` ; ``matches`` = paires
+    ``(ref_idx, hyp_idx)``. Labels comparés **casefold** ; tri déterministe
+    ``(−iou, ref_idx, hyp_idx)``.
+    """
+    candidates: list[tuple[float, int, int]] = []
+    for i, ref in enumerate(references):
+        for j, hyp in enumerate(hypotheses):
+            if ref.label.casefold() != hyp.label.casefold():
+                continue
+            score = _iou(ref, hyp)
+            if score >= iou_threshold:
+                candidates.append((score, i, j))
+    candidates.sort(key=lambda c: (-c[0], c[1], c[2]))
+    matched_refs: set[int] = set()
+    matched_hyps: set[int] = set()
+    matches: list[tuple[int, int]] = []
+    for _score, i, j in candidates:
+        if i in matched_refs or j in matched_hyps:
+            continue
+        matched_refs.add(i)
+        matched_hyps.add(j)
+        matches.append((i, j))
+    unmatched_refs = set(range(len(references))) - matched_refs
+    unmatched_hyps = set(range(len(hypotheses))) - matched_hyps
+    return matches, unmatched_refs, unmatched_hyps
+
+
+@dataclass(frozen=True)
+class NerCounts:
+    """Comptes d'appariement d'un document (accumulables sur un corpus)."""
+
+    tp: int
+    fp: int
+    fn: int
+    cat_tp: Counter[str]
+    cat_fp: Counter[str]
+    cat_fn: Counter[str]
+    missed: list[Entity]
+    hallucinated: list[Entity]
+
+
+def compute_ner(
+    reference: EntitySet,
+    hypothesis: EntitySet,
+    iou_threshold: float = DEFAULT_IOU_THRESHOLD,
+) -> NerCounts:
+    """Apparie les entités après reprojection R14 ; renvoie les comptes du doc."""
+    position_map = build_position_map(reference.text, hypothesis.text)
+    hyps = remap_entities(hypothesis.entities, position_map)
+    refs = list(reference.entities)
+    matches, unmatched_refs, unmatched_hyps = align_entities(
+        refs, hyps, iou_threshold
+    )
+    cat_tp: Counter[str] = Counter(refs[i].label for i, _ in matches)
+    cat_fn: Counter[str] = Counter(refs[i].label for i in unmatched_refs)
+    cat_fp: Counter[str] = Counter(hyps[j].label for j in unmatched_hyps)
+    return NerCounts(
+        tp=len(matches),
+        fp=len(unmatched_hyps),
+        fn=len(unmatched_refs),
+        cat_tp=cat_tp,
+        cat_fp=cat_fp,
+        cat_fn=cat_fn,
+        missed=[refs[i] for i in sorted(unmatched_refs)],
+        hallucinated=[hyps[j] for j in sorted(unmatched_hyps)],
+    )
+
+
+def prf(tp: int, fp: int, fn: int) -> tuple[float, float, float]:
+    """Précision, rappel, F1 (chacun ``0.0`` si son dénominateur est nul)."""
+    precision = tp / (tp + fp) if tp + fp > 0 else 0.0
+    recall = tp / (tp + fn) if tp + fn > 0 else 0.0
+    f1 = (
+        2 * precision * recall / (precision + recall)
+        if precision + recall > 0
+        else 0.0
+    )
+    return precision, recall, f1
+
+
+@dataclass
+class _PipelineAccumulator:
+    """Comptes NER cumulés d'un pipeline sur le corpus."""
+
+    tp: int = 0
+    fp: int = 0
+    fn: int = 0
+    cat_tp: Counter[str] = field(default_factory=Counter)
+    cat_fp: Counter[str] = field(default_factory=Counter)
+    cat_fn: Counter[str] = field(default_factory=Counter)
+    missed: list[Entity] = field(default_factory=list)
+    hallucinated: list[Entity] = field(default_factory=list)
+
+
+class EntitiesCollector:
+    """Accumule les appariements NER (avec R14) au fil du scoring d'une vue."""
+
+    def __init__(self, iou_threshold: float = DEFAULT_IOU_THRESHOLD) -> None:
+        self._threshold = iou_threshold
+        self._pipelines: dict[str, _PipelineAccumulator] = {}
+
+    def observe(
+        self, pipeline: str, reference: EntitySet, hypothesis: EntitySet
+    ) -> None:
+        counts = compute_ner(reference, hypothesis, self._threshold)
+        acc = self._pipelines.setdefault(pipeline, _PipelineAccumulator())
+        acc.tp += counts.tp
+        acc.fp += counts.fp
+        acc.fn += counts.fn
+        acc.cat_tp.update(counts.cat_tp)
+        acc.cat_fp.update(counts.cat_fp)
+        acc.cat_fn.update(counts.cat_fn)
+        acc.missed.extend(counts.missed[: _MAX_MISSED - len(acc.missed)])
+        acc.hallucinated.extend(
+            counts.hallucinated[: _MAX_HALLUCINATED - len(acc.hallucinated)]
+        )
+
+    def build(self, view: str) -> Analysis | None:
+        """Payload ``ner`` de la vue ; ``None`` si aucune entité GT observée."""
+        rows = [
+            self._row(pipeline)
+            for pipeline in sorted(self._pipelines)
+            if self._pipelines[pipeline].tp + self._pipelines[pipeline].fn > 0
+        ]
+        if not rows:
+            return None
+        return Analysis(
+            scope="corpus",
+            view=view,
+            payload=NerPayload(iou_threshold=self._threshold, pipelines=tuple(rows)),
+        )
+
+    def _row(self, pipeline: str) -> PipelineNer:
+        acc = self._pipelines[pipeline]
+        precision, recall, f1 = prf(acc.tp, acc.fp, acc.fn)
+        categories = sorted(set(acc.cat_tp) | set(acc.cat_fp) | set(acc.cat_fn))
+        per_category: list[EntityCategoryScore] = []
+        for label in categories:
+            ctp, cfp, cfn = acc.cat_tp[label], acc.cat_fp[label], acc.cat_fn[label]
+            cp, cr, cf = prf(ctp, cfp, cfn)
+            per_category.append(
+                EntityCategoryScore(
+                    label=label, precision=cp, recall=cr, f1=cf, support=ctp + cfn
+                )
+            )
+        return PipelineNer(
+            pipeline=pipeline,
+            n_reference=acc.tp + acc.fn,
+            true_positives=acc.tp,
+            false_positives=acc.fp,
+            false_negatives=acc.fn,
+            precision=precision,
+            recall=recall,
+            f1=f1,
+            per_category=tuple(per_category),
+            missed=tuple(
+                EntityMention(label=e.label, text=e.text[:128]) for e in acc.missed
+            ),
+            hallucinated=tuple(
+                EntityMention(label=e.label, text=e.text[:128])
+                for e in acc.hallucinated
+            ),
+        )
+
+
+__all__ = [
+    "DEFAULT_IOU_THRESHOLD",
+    "EntitiesCollector",
+    "Entity",
+    "EntitySet",
+    "NerCounts",
+    "align_entities",
+    "build_position_map",
+    "compute_ner",
+    "parse_entities",
+    "prf",
+    "remap_entities",
+]
diff --git a/cinoc/evaluation/preservation.py b/cinoc/evaluation/preservation.py
new file mode 100644
index 0000000000000000000000000000000000000000..2d4ac6c6d0de979a28025a3a0e03ad587cb8ef50
--- /dev/null
+++ b/cinoc/evaluation/preservation.py
@@ -0,0 +1,47 @@
+"""Moteur partagé de **préservation d'un sous-ensemble de caractères** (couche 3).
+
+``mufi_err``, ``diacritic_err`` et ``hcpr`` mesurent tous la même chose sur des
+sous-ensembles différents : parmi les caractères-cibles **de la référence**,
+combien survivent à l'alignement caractère. Un seul moteur les sert — il rend les
+deux comptes bruts ``(n_total, n_wrong)`` et chaque métrique en dérive sa lecture :
+
+- ``diacritic_err`` / ``mufi_err`` exposent le **taux d'erreur** ``n_wrong / n_total`` ;
+- ``hcpr`` expose le **taux de préservation** ``(n_total − n_wrong) / n_total``.
+
+Même alignement que la source historique (``rapidfuzz`` ``editops``, opérations
+``replace``/``delete`` sur les positions de la référence) : la factorisation est
+**à valeur constante** — les métriques existantes ne bougent pas d'un ULP (parité
+prouvée par ``test_preservation``). ``air``, lui, mesure l'inverse côté **sortie**
+(sur-historicisation) et vit dans :mod:`cinoc.evaluation.archaic`.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from rapidfuzz.distance import Levenshtein
+
+
+def preservation_counts(
+    reference: str, hypothesis: str, is_target: Callable[[str], bool]
+) -> tuple[int, int] | None:
+    """``(n_total, n_wrong)`` pour les caractères-cibles de la **référence**.
+
+    ``n_total`` = nombre de caractères de ``reference`` satisfaisant ``is_target`` ;
+    ``n_wrong`` = ceux mal restitués (substitués ou supprimés dans l'alignement
+    ``editops`` GT↔hypothèse). ``None`` si la référence n'en porte aucun (non
+    applicable — le runner exclut ce cas de l'agrégat).
+    """
+    targets = [i for i, char in enumerate(reference) if is_target(char)]
+    if not targets:
+        return None
+    wrong = {
+        op.src_pos
+        for op in Levenshtein.editops(reference, hypothesis)
+        if op.tag in ("replace", "delete")
+    }
+    n_wrong = sum(1 for i in targets if i in wrong)
+    return len(targets), n_wrong
+
+
+__all__ = ["preservation_counts"]
diff --git a/cinoc/evaluation/pricing.json b/cinoc/evaluation/pricing.json
new file mode 100644
index 0000000000000000000000000000000000000000..5457763bc300a0c4df947267234717b99a44f01e
--- /dev/null
+++ b/cinoc/evaluation/pricing.json
@@ -0,0 +1,70 @@
+{
+  "meta": {
+    "currency": "EUR",
+    "last_updated": "2026-06-10",
+    "valid_until": "2026-12-01",
+    "note": "Tarifs INDICATIFS (conversions arrondies, hors remises/volumes) — à réviser avant valid_until ; le rapport affiche un avertissement de péremption au-delà.",
+    "hourly_rate_local_cpu_eur": 0.08,
+    "time_per_error_seconds": 5.0
+  },
+  "local_kinds": [
+    "precomputed",
+    "tesseract",
+    "ollama",
+    "precomputed_layout",
+    "precomputed_region",
+    "pp_doclayout",
+    "alto_assembler"
+  ],
+  "cloud_models": {
+    "openai/gpt-4o-mini": {
+      "input_eur_per_mtok": 0.14,
+      "output_eur_per_mtok": 0.55,
+      "pricing_date": "2026-06-10"
+    },
+    "openai/gpt-4o": {
+      "input_eur_per_mtok": 2.3,
+      "output_eur_per_mtok": 9.2,
+      "pricing_date": "2026-06-10"
+    },
+    "anthropic/claude-haiku-4-5-20251001": {
+      "input_eur_per_mtok": 0.92,
+      "output_eur_per_mtok": 4.6,
+      "pricing_date": "2026-06-10"
+    },
+    "anthropic/claude-sonnet-4-6": {
+      "input_eur_per_mtok": 2.76,
+      "output_eur_per_mtok": 13.8,
+      "pricing_date": "2026-06-10"
+    },
+    "mistral/mistral-small-latest": {
+      "input_eur_per_mtok": 0.1,
+      "output_eur_per_mtok": 0.3,
+      "pricing_date": "2026-06-10"
+    },
+    "mistral/mistral-large-latest": {
+      "input_eur_per_mtok": 1.8,
+      "output_eur_per_mtok": 5.4,
+      "pricing_date": "2026-06-10"
+    }
+  },
+  "default_models": {
+    "openai": "gpt-4o-mini",
+    "anthropic": "claude-haiku-4-5-20251001",
+    "mistral": "mistral-small-latest"
+  },
+  "cloud_page_kinds": {
+    "mistral_ocr": {
+      "eur_per_1k_pages": 0.92,
+      "pricing_date": "2026-06-10"
+    },
+    "google_vision": {
+      "eur_per_1k_pages": 1.38,
+      "pricing_date": "2026-06-10"
+    },
+    "azure_di": {
+      "eur_per_1k_pages": 1.38,
+      "pricing_date": "2026-06-10"
+    }
+  }
+}
diff --git a/cinoc/evaluation/projectors.py b/cinoc/evaluation/projectors.py
new file mode 100644
index 0000000000000000000000000000000000000000..2738b99d7fdf61e27be480fed5b29fa42623ad0f
--- /dev/null
+++ b/cinoc/evaluation/projectors.py
@@ -0,0 +1,104 @@
+"""Projecteurs (couche 3) — convertissent un artefact vers le type qu'une
+métrique consomme, sous le contrôle déclaratif d'une ``ProjectionSpec``.
+
+Socle : ``layout_to_text`` — projette un ``CanonicalLayout`` vers du texte brut
+en **ordre de lecture** (régions ordonnées par ``reading_order``, sous-régions à
+plat, lignes jointes). C'est ce qui permet de noter une sortie **structurée**
+(ALTO/PAGE/LAYOUT) avec les métriques **texte** (CER/WER) contre une référence
+texte — sans coupler la métrique au format.
+
+Premier consommateur de ``ProjectionSpec`` (réserve §9 levée). Les projecteurs
+sont **first-party** (non pluggables, cf. CLAUDE.md §3) : résolution par un
+lookup builtin, pas un registre injecté.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+
+from cinoc.domain.errors import ProjectionError
+from cinoc.domain.layout import CanonicalLayout, LayoutPage, Region
+from cinoc.evaluation.errors import EvaluationError
+
+#: Valeur de paramètre admissible (miroir de ``ProjectionSpec.params``).
+ParamValue = str | int | float | bool
+
+#: Un projecteur : ``(représentation source, params) → représentation cible``.
+Projector = Callable[[object, Mapping[str, ParamValue]], object]
+
+
+def _ordered_top_regions(page: LayoutPage) -> tuple[Region, ...]:
+    """Régions de premier niveau dans l'ordre de lecture (sinon ordre déclaré)."""
+    if not page.reading_order:
+        return page.regions
+    by_id = {region.id: region for region in page.regions}
+    seen = set(page.reading_order)
+    ordered = [by_id[rid] for rid in page.reading_order if rid in by_id]
+    ordered.extend(region for region in page.regions if region.id not in seen)
+    return tuple(ordered)
+
+
+def _region_text(region: Region) -> str:
+    """Texte d'une région : lignes puis sous-régions (profondeur d'abord)."""
+    parts = [line.text for line in region.lines if line.text]
+    for sub in region.regions:
+        sub_text = _region_text(sub)
+        if sub_text:
+            parts.append(sub_text)
+    return "\n".join(parts)
+
+
+def layout_to_text(representation: object, params: Mapping[str, ParamValue]) -> object:
+    """Projette un ``CanonicalLayout`` en texte brut, en ordre de lecture.
+
+    Lignes jointes par ``\\n``, régions par ``\\n\\n``. Déterministe.
+    """
+    if not isinstance(representation, CanonicalLayout):
+        raise ProjectionError(
+            "layout_to_text : un CanonicalLayout est attendu, reçu "
+            f"{type(representation).__name__}."
+        )
+    blocks: list[str] = []
+    for page in representation.pages:
+        for region in _ordered_top_regions(page):
+            text = _region_text(region)
+            if text:
+                blocks.append(text)
+    return "\n\n".join(blocks)
+
+
+def identity_text(representation: object, params: Mapping[str, ParamValue]) -> object:
+    """Projection identité pour les représentations **texte** (str → str).
+
+    Sert l'opt-in d'une référence ``REFERENCE_TEXT`` vers l'espace de comparaison
+    ``RAW_TEXT`` : le texte est déjà chargé en ``str`` (couche 2), on le rend tel
+    quel. Le *type* change (l'étiquette « référence OCR »), pas la représentation —
+    c'est ce qui permet de noter un candidat contre une référence OCR via une vue
+    dédiée, sans confondre cette référence avec une vérité-terrain manuelle.
+    """
+    if not isinstance(representation, str):
+        raise ProjectionError(
+            "identity_text : une représentation texte (str) est attendue, reçu "
+            f"{type(representation).__name__}."
+        )
+    return representation
+
+
+_BUILTIN: dict[str, Projector] = {
+    "layout_to_text": layout_to_text,
+    "identity_text": identity_text,
+}
+
+
+def get_projector(name: str) -> Projector:
+    """Résout un projecteur first-party par nom, ou lève ``EvaluationError``."""
+    try:
+        return _BUILTIN[name]
+    except KeyError:
+        raise EvaluationError(
+            f"projecteur inconnu : {name!r} (disponibles : "
+            f"{', '.join(sorted(_BUILTIN))})."
+        ) from None
+
+
+__all__ = ["Projector", "get_projector", "identity_text", "layout_to_text"]
diff --git a/cinoc/evaluation/registry.py b/cinoc/evaluation/registry.py
new file mode 100644
index 0000000000000000000000000000000000000000..d8fcb0bdbfc0ef2ee2b56e07478ff0af9658aeeb
--- /dev/null
+++ b/cinoc/evaluation/registry.py
@@ -0,0 +1,82 @@
+"""Registre de métriques **par-document** (type-driven) + **inter-moteurs**.
+
+Unique et **instanciable** : il ne s'auto-peuple pas à l'import —
+``register_default_metrics`` est appelé **explicitement** par l'app (CLAUDE.md §7).
+"""
+
+from __future__ import annotations
+
+from cinoc.domain.artifacts import ArtifactType
+from cinoc.evaluation.metric import CrossEngineMetric, DocumentMetric
+
+
+class MetricRegistry:
+    """Associe des noms (par-doc et inter-moteurs) à leurs fiches + fonctions."""
+
+    def __init__(self) -> None:
+        self._document: dict[str, DocumentMetric] = {}
+        self._cross_engine: dict[str, CrossEngineMetric] = {}
+
+    def register_document_metric(self, metric: DocumentMetric) -> None:
+        """Enregistre (ou remplace) une métrique par-document. Idempotent."""
+        self._document[metric.name] = metric
+
+    def register_cross_engine_metric(self, metric: CrossEngineMetric) -> None:
+        """Enregistre (ou remplace) une métrique inter-moteurs. Idempotent."""
+        self._cross_engine[metric.name] = metric
+
+    def document_metric(self, name: str) -> DocumentMetric | None:
+        return self._document.get(name)
+
+    def for_input_types(
+        self, reference: ArtifactType, hypothesis: ArtifactType
+    ) -> tuple[DocumentMetric, ...]:
+        """Métriques par-document applicables à la signature ``(ref, hyp)``."""
+        return tuple(
+            metric
+            for metric in self._document.values()
+            if metric.input_types == (reference, hypothesis)
+        )
+
+    def cross_engine_metrics(self) -> tuple[CrossEngineMetric, ...]:
+        """Métriques inter-moteurs enregistrées, triées par nom (déterministe)."""
+        return tuple(self._cross_engine[name] for name in sorted(self._cross_engine))
+
+    def names(self) -> tuple[str, ...]:
+        return tuple(sorted(self._document))
+
+
+def register_default_metrics(registry: MetricRegistry) -> None:
+    """Collecte explicite du socle de métriques (aucun effet de bord à l'import)."""
+    from cinoc.evaluation.metrics.archaic import ARCHAIC_METRICS
+    from cinoc.evaluation.metrics.bow import BOW_METRICS
+    from cinoc.evaluation.metrics.conformity import CONFORMITY_METRICS
+    from cinoc.evaluation.metrics.diacritics import DIACRITIC_METRICS
+    from cinoc.evaluation.metrics.diagnostics import DIAGNOSTIC_METRICS
+    from cinoc.evaluation.metrics.flexible import FLEXIBLE_METRICS
+    from cinoc.evaluation.metrics.layout import LAYOUT_METRICS
+    from cinoc.evaluation.metrics.ner import NER_METRICS
+    from cinoc.evaluation.metrics.philology import PHILOLOGY_METRICS
+    from cinoc.evaluation.metrics.stats import CROSS_ENGINE_METRICS
+    from cinoc.evaluation.metrics.structured_data import STRUCTURED_DATA_METRICS
+    from cinoc.evaluation.metrics.text import TEXT_METRICS
+
+    for document in (
+        *TEXT_METRICS,
+        *FLEXIBLE_METRICS,
+        *BOW_METRICS,
+        *DIACRITIC_METRICS,
+        *PHILOLOGY_METRICS,
+        *ARCHAIC_METRICS,
+        *LAYOUT_METRICS,
+        *DIAGNOSTIC_METRICS,
+        *CONFORMITY_METRICS,
+        *STRUCTURED_DATA_METRICS,
+        *NER_METRICS,
+    ):
+        registry.register_document_metric(document)
+    for cross in CROSS_ENGINE_METRICS:
+        registry.register_cross_engine_metric(cross)
+
+
+__all__ = ["MetricRegistry", "register_default_metrics"]
diff --git a/cinoc/evaluation/representations.py b/cinoc/evaluation/representations.py
new file mode 100644
index 0000000000000000000000000000000000000000..b8fd3f2228d5db23fa3ae653e7c1a69746135433
--- /dev/null
+++ b/cinoc/evaluation/representations.py
@@ -0,0 +1,105 @@
+"""Chargement d'un artefact vers sa représentation comparable.
+
+Le runner compare des **représentations** (``str`` pour le texte), pas des
+artefacts bruts. Charge aujourd'hui le texte (``RAW_TEXT``/``CORRECTED_TEXT``) via
+la couche 2 ; les autres types (``LAYOUT``…) arrivent avec leur tranche.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from cinoc.domain.artifacts import ArtifactType
+from cinoc.domain.errors import FormatError
+from cinoc.domain.evaluation import EvaluationView
+from cinoc.domain.layout import CanonicalLayout
+from cinoc.evaluation.errors import EvaluationError
+from cinoc.evaluation.ner import EntitySet, parse_entities
+from cinoc.formats.alto import parse_alto
+from cinoc.formats.alto.layout_map import alto_to_layout
+from cinoc.formats.pagexml import parse_pagexml
+from cinoc.formats.pagexml.layout_map import page_to_layout
+from cinoc.formats.text import get_builtin_profile, read_plaintext
+
+_TEXT_TYPES = frozenset(
+    {
+        ArtifactType.RAW_TEXT,
+        ArtifactType.CORRECTED_TEXT,
+        ArtifactType.REFERENCE_TEXT,
+    }
+)
+
+
+def load_representation(uri: str, artifact_type: ArtifactType) -> object:
+    """Charge le contenu pointé par ``uri`` dans sa représentation comparable."""
+    try:
+        data = Path(uri).read_bytes()
+    except OSError as exc:
+        raise EvaluationError(
+            f"représentation illisible ({artifact_type.value}) : "
+            f"{uri!r} ({exc})."
+        ) from exc
+    if artifact_type in _TEXT_TYPES:
+        return read_plaintext(data)
+    if artifact_type is ArtifactType.LAYOUT:
+        return _load_layout(uri, data)
+    if artifact_type is ArtifactType.ENTITIES:
+        return _load_entities(uri, data)
+    raise EvaluationError(
+        f"représentation non chargeable pour le type {artifact_type.value!r}."
+    )
+
+
+def _load_layout(uri: str, data: bytes) -> CanonicalLayout:
+    """Charge un ``CanonicalLayout`` depuis du JSON natif, de l'ALTO ou du PAGE.
+
+    XML (premier octet non-blanc ``<``) → ALTO ou PAGE selon le marqueur de
+    racine (``PcGts``/``pagecontent`` = PAGE, sinon ALTO) ; autrement JSON
+    sérialisé d'un ``CanonicalLayout``.
+    """
+    if data.lstrip()[:1] == b"<":
+        head = data[:4096].lower()
+        is_page = b"pcgts" in head or b"pagecontent" in head
+        try:
+            if is_page:
+                return page_to_layout(parse_pagexml(data))
+            return alto_to_layout(parse_alto(data))
+        except (ValueError, FormatError) as exc:
+            kind = "PAGE" if is_page else "ALTO"
+            raise EvaluationError(
+                f"{kind} illisible en layout ({uri!r}) : {exc}"
+            ) from exc
+    try:
+        return CanonicalLayout.model_validate_json(data)
+    except ValueError as exc:
+        raise EvaluationError(f"CanonicalLayout invalide ({uri!r}) : {exc}") from exc
+
+
+def _load_entities(uri: str, data: bytes) -> EntitySet:
+    """Charge un ``EntitySet`` depuis un sidecar ``{"text", "entities"}``."""
+    try:
+        return parse_entities(data)
+    except EvaluationError as exc:
+        raise EvaluationError(f"entités illisibles ({uri!r}) : {exc}") from exc
+
+
+def prepare_text(text: str, view: EvaluationView) -> str:
+    """Applique la normalisation de la vue (profil + ``char_exclude``) à un texte.
+
+    **La** définition de « préparé comme au scoring » : le runner et les
+    analyses qui chargent leurs propres textes (bilan de correction) passent
+    par ici — une seule implémentation, symétrique GT/hypothèse.
+    """
+    if view.normalization_profile is not None:
+        try:
+            profile = get_builtin_profile(view.normalization_profile)
+        except KeyError as exc:
+            raise EvaluationError(str(exc)) from exc
+        text = profile.normalize(text)
+    if view.char_exclude:
+        excluded = set(view.char_exclude)
+        text = "".join(char for char in text if char not in excluded)
+    return text
+
+
+__all__ = ["load_representation", "prepare_text"]
diff --git a/cinoc/evaluation/result.py b/cinoc/evaluation/result.py
new file mode 100644
index 0000000000000000000000000000000000000000..b8edca7e7b9dc6b26b73f18787faa3146c3d6e62
--- /dev/null
+++ b/cinoc/evaluation/result.py
@@ -0,0 +1,116 @@
+"""``RunResult`` — contrat de sortie **unique** d'un run (plein-scope, dégonflé).
+
+Un seul format (pas de double représentation héritée). Dimensionné pour porter
+toute métrique **scalaire** (texte/structure/NER/taxonomy…) et le détail
+**par-document** dès sa conception, même quand seul un CER est écrit : ajouter
+une métrique ou une vue est **additif**, jamais un changement d'enveloppe.
+``schema_version`` couvre les évolutions structurelles ; les **clés** (``metric``,
+``value``, ``support``, ``pipeline``, ``view``) sont un **contrat dur** avec le
+rapport — renommer une clé est interdit (CLAUDE.md §12, déterminisme).
+
+Contrat « analyses » (enveloppe, cf. ``PLAN_PARITE.md`` §1/E2) : les résultats
+**non scalaires** (inférentiel, fronts de Pareto, paires de confusion, bins de
+calibration…) passent par le canal unique ``RunResult.analyses`` — payloads
+Pydantic figés (``evaluation.analysis``), **union discriminée par ``kind``**.
+Règles dures : (1) les scalaires ``MetricScore`` restent la seule monnaie de
+classement/historique ; (2) tout est calculé en ``evaluation/`` et écrit ici,
+les rapports lisent sans recalculer ; (3) chaque payload naît **avec** son
+calcul et son consommateur (même commit) — garde-fou « pas de consommateur =
+supprimé ».
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from cinoc.domain.run import RunManifest
+from cinoc.domain.usage import ResourceUsage
+from cinoc.evaluation.analysis import Analysis
+
+
+class MetricScore(BaseModel):
+    """Valeur d'une métrique (agrégat ou par-doc). ``None`` = non applicable."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    metric: str = Field(min_length=1, max_length=128)
+    value: float | None = None
+    #: « Poids de preuve » de ``value`` : par-document = le **dénominateur** de la
+    #: métrique (longueur de réf…), qui pondère le micro-agrégat ; en agrégat = le
+    #: **nombre de documents** applicables. Deux lectures, même intention (taille).
+    support: int | None = Field(default=None, ge=0)
+
+
+class RunDocumentResult(BaseModel):
+    """Scores d'un pipeline sur un document, sous une vue."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    document_id: str = Field(min_length=1, max_length=256)
+    pipeline: str = Field(min_length=1, max_length=128)
+    view: str = Field(min_length=1, max_length=128)
+    scores: tuple[MetricScore, ...] = Field(default_factory=tuple)
+    #: Strate du document (genre/période…) si le corpus la porte, sinon ``None``.
+    #: Projection de ``DocumentRef.metadata["stratum"]`` ; consommée par la
+    #: composition / filtres / CER par strate (rendus seulement si présent).
+    stratum: str | None = Field(default=None, max_length=128)
+    #: **Référence** image du document (chemin corpus-relatif ou URL IIIF),
+    #: jamais les octets → déterminisme/hash du résultat intacts. Résolue en
+    #: vignette **au rendu** (adapter, hors résultat). ``None`` = pas d'image.
+    image_ref: str | None = Field(default=None, max_length=2048)
+
+
+class PipelineResult(BaseModel):
+    """Agrégat d'un pipeline sous une vue (moyennes ``None``-exclues + support)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    pipeline: str = Field(min_length=1, max_length=128)
+    view: str = Field(min_length=1, max_length=128)
+    aggregate: tuple[MetricScore, ...] = Field(default_factory=tuple)
+
+
+class DocumentUsage(BaseModel):
+    """Ressources consommées par un pipeline sur un document (hors vues).
+
+    L'exécution a lieu une fois par (pipeline × document) — les vues sont des
+    lentilles d'évaluation, sans coût d'exécution propre. Les durées sont du
+    wall-clock (mesure d'environnement, comme les horodatages du manifeste).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    document_id: str = Field(min_length=1, max_length=256)
+    pipeline: str = Field(min_length=1, max_length=128)
+    usage: ResourceUsage
+
+
+class RunResult(BaseModel):
+    """Sortie complète d'un run : manifeste + agrégats + détail par-document."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    schema_version: int = 2
+    manifest: RunManifest
+    pipelines: tuple[PipelineResult, ...] = Field(default_factory=tuple)
+    documents: tuple[RunDocumentResult, ...] = Field(default_factory=tuple)
+    #: Écrit par la passe inter-moteurs ; vide tant qu'un seul pipeline court.
+    cross_engine: tuple[MetricScore, ...] = Field(default_factory=tuple)
+    #: Ressources mesurées par (pipeline × document), triées (pipeline,
+    #: document_id) — ordre déterministe. Vide pour un résultat reconstruit
+    #: sans exécution (ex. chargement d'un JSON v1).
+    usage: tuple[DocumentUsage, ...] = Field(default_factory=tuple)
+    #: Canal des résultats **non scalaires** (contrat E2 ci-dessus) : payloads
+    #: typés par famille, calculés par le runner, triés (view, kind, métrique)
+    #: — ordre déterministe. Les rapports lisent, ne recalculent pas.
+    analyses: tuple[Analysis, ...] = Field(default_factory=tuple)
+
+
+__all__ = [
+    "Analysis",
+    "DocumentUsage",
+    "MetricScore",
+    "PipelineResult",
+    "RunDocumentResult",
+    "RunResult",
+]
diff --git a/cinoc/evaluation/roman.py b/cinoc/evaluation/roman.py
new file mode 100644
index 0000000000000000000000000000000000000000..f67172eeeeca2c259f791d54463fb694254924c1
--- /dev/null
+++ b/cinoc/evaluation/roman.py
@@ -0,0 +1,217 @@
+"""Numéraux **romains** : parseur + restitution en 5 statuts (couche 3).
+
+Transversal aux périodes (médiéval `mcclxxxij`, imprimé ancien `Tome IV`,
+moderne `Louis XIV`). Pour chaque numéral de la GT, on classe sa restitution
+dans l'hypothèse selon le **premier** statut applicable :
+
+1. ``strict_preserved`` — forme exacte (``xiv`` → ``xiv``) ;
+2. ``case_changed`` — valeur intacte, casse modifiée (``xiv`` → ``XIV``) ;
+3. ``j_dropped`` — ``j`` médiéval final standardisé (``viij`` → ``viii``) ;
+4. ``converted_to_arabic`` — système modernisé (``XIV`` → ``14``) ;
+5. ``lost`` — aucune trace de la valeur.
+
+Les 4 premiers préservent la valeur. C'est l'**unique** comptage des romains
+(R1 : retiré de `structured_data`, qui n'en garde qu'un helper de **valeur**
+régnale, ré-exporté ici) ; les scores strict/valeur s'en dérivent sans double
+comptage. Détection greedy `\\b[IVXLCDMivxlcdmj]+\\b` + validation par parsing ;
+``min_length=2`` par défaut (R2 : filtre les ``I``/``M`` isolés ambigus).
+Adaptatif : GT sans numéral → pas de payload.
+"""
+
+from __future__ import annotations
+
+import re
+
+from cinoc.evaluation.analysis import (
+    Analysis,
+    PipelineRomanNumerals,
+    RomanNumeralsPayload,
+)
+
+ROMAN_VALUES: dict[str, int] = {
+    "I": 1,
+    "V": 5,
+    "X": 10,
+    "L": 50,
+    "C": 100,
+    "D": 500,
+    "M": 1000,
+}
+
+_ROMAN_CHARS = "IVXLCDMivxlcdmj"
+_ROMAN_RE = re.compile(rf"\b[{_ROMAN_CHARS}]+\b")
+
+#: Statuts dans l'ordre canonique (= ordre de priorité de classement).
+STATUSES: tuple[str, ...] = (
+    "strict_preserved",
+    "case_changed",
+    "j_dropped",
+    "converted_to_arabic",
+    "lost",
+)
+#: Statuts qui préservent la valeur (tous sauf ``lost``).
+_VALUE_PRESERVING = STATUSES[:-1]
+
+#: Plafond d'échantillons de formes perdues par pipeline.
+_MAX_LOST_SAMPLES = 12
+
+
+def _normalize_roman(text: str) -> str:
+    """Majuscule + ``j`` médiéval final → ``I`` (``viij`` → ``VIII``)."""
+    upper = text.upper()
+    if upper.endswith("J"):
+        return upper[:-1] + "I"
+    return upper
+
+
+def _is_plausible_roman(text: str) -> bool:
+    """Validation **relâchée** : accepte ``IIII``/``VIIII`` (médiéval), rejette
+    les répétitions absurdes (``IIIII``, ``VV``) et les paires soustractives
+    non canoniques (``IL``, ``IC`` — faux positifs de mots comme « ici »).
+    """
+    for forbidden in ("VV", "LL", "DD", "IIIII", "XXXXX", "CCCCC", "MMMMMM"):
+        if forbidden in text:
+            return False
+    legal_subtractive = {"IV", "IX", "XL", "XC", "CD", "CM"}
+    for i in range(len(text) - 1):
+        a, b = text[i], text[i + 1]
+        if ROMAN_VALUES[a] < ROMAN_VALUES[b] and (a + b) not in legal_subtractive:
+            return False
+    return True
+
+
+def _parse_normalized(text: str) -> int | None:
+    """Valeur d'un numéral **normalisé** (soustraction standard), ou ``None``."""
+    if not text or not all(c in ROMAN_VALUES for c in text):
+        return None
+    total = 0
+    previous = 0
+    for char in reversed(text):
+        value = ROMAN_VALUES[char]
+        if value < previous:
+            total -= value
+        else:
+            total += value
+        previous = value
+    if total <= 0 or not _is_plausible_roman(text):
+        return None
+    return total
+
+
+def roman_to_int(text: str | None) -> int | None:
+    """Valeur d'une chaîne romaine (tolère casse + ``j`` médiéval), ou ``None``.
+
+    Source unique de parsing romain (R1) : `structured_data` l'importe pour la
+    valeur régnale.
+    """
+    if not text:
+        return None
+    return _parse_normalized(_normalize_roman(text))
+
+
+def detect_roman_numerals(
+    text: str, *, min_length: int = 2
+) -> list[tuple[int, str, int]]:
+    """Numéraux valides de ``text`` : ``[(index, forme, valeur), ...]``."""
+    found: list[tuple[int, str, int]] = []
+    for match in _ROMAN_RE.finditer(text):
+        form = match.group(0)
+        if len(form) < min_length:
+            continue
+        value = roman_to_int(form)
+        if value is not None:
+            found.append((match.start(), form, value))
+    return found
+
+
+def _present(needle: str, hypothesis: str) -> bool:
+    """``needle`` présent dans ``hypothesis`` hors d'un mot alphabétique."""
+    pattern = r"(?<![A-Za-z])" + re.escape(needle) + r"(?![A-Za-z])"
+    return re.search(pattern, hypothesis) is not None
+
+
+def classify(numeral: str, value: int, hypothesis: str) -> str:
+    """Statut de restitution de ``numeral`` (de valeur ``value``) dans l'hyp."""
+    if _present(numeral, hypothesis):
+        return "strict_preserved"
+    swapped = numeral.swapcase()
+    if swapped != numeral and _present(swapped, hypothesis):
+        return "case_changed"
+    lowered = numeral.lower()
+    if lowered.endswith("j"):
+        flipped = numeral[:-1] + ("I" if numeral[-1] == "J" else "i")
+    elif lowered.endswith("i"):
+        flipped = numeral[:-1] + ("J" if numeral[-1] == "I" else "j")
+    else:
+        flipped = numeral
+    if flipped != numeral and (
+        _present(flipped, hypothesis) or _present(flipped.swapcase(), hypothesis)
+    ):
+        return "j_dropped"
+    if re.search(r"(?<!\d)" + str(value) + r"(?!\d)", hypothesis):
+        return "converted_to_arabic"
+    return "lost"
+
+
+class RomanNumeralsCollector:
+    """Accumule la restitution des numéraux au fil du scoring (micro).
+
+    ``observe`` par document scoré (mêmes textes normalisés, zéro relecture),
+    ``build`` agrège par (pipeline × statut). Pipelines sans numéral → absents.
+    """
+
+    def __init__(self, *, min_length: int = 2) -> None:
+        self._min_length = min_length
+        self._counts: dict[str, dict[str, int]] = {}
+        self._lost: dict[str, list[str]] = {}
+        self._order: list[str] = []
+
+    def observe(self, pipeline: str, reference: str, hypothesis: str) -> None:
+        detected = detect_roman_numerals(reference, min_length=self._min_length)
+        if not detected:
+            return
+        if pipeline not in self._counts:
+            self._counts[pipeline] = {status: 0 for status in STATUSES}
+            self._lost[pipeline] = []
+            self._order.append(pipeline)
+        for _index, numeral, value in detected:
+            status = classify(numeral, value, hypothesis)
+            self._counts[pipeline][status] += 1
+            if status == "lost" and len(self._lost[pipeline]) < _MAX_LOST_SAMPLES:
+                self._lost[pipeline].append(numeral)
+
+    def build(self, view: str) -> Analysis | None:
+        """Payload de la vue, ``None`` si aucun numéral dans la GT du corpus."""
+        rows: list[PipelineRomanNumerals] = []
+        for pipeline in self._order:
+            counts = self._counts[pipeline]
+            n_total = sum(counts.values())
+            rows.append(
+                PipelineRomanNumerals(
+                    pipeline=pipeline,
+                    n_total=n_total,
+                    strict_preserved=counts["strict_preserved"],
+                    case_changed=counts["case_changed"],
+                    j_dropped=counts["j_dropped"],
+                    converted_to_arabic=counts["converted_to_arabic"],
+                    lost=counts["lost"],
+                    lost_samples=tuple(self._lost[pipeline]),
+                )
+            )
+        if not rows:
+            return None
+        return Analysis(
+            scope="corpus",
+            view=view,
+            payload=RomanNumeralsPayload(pipelines=tuple(rows)),
+        )
+
+
+__all__ = [
+    "ROMAN_VALUES",
+    "STATUSES",
+    "RomanNumeralsCollector",
+    "classify",
+    "detect_roman_numerals",
+    "roman_to_int",
+]
diff --git a/cinoc/evaluation/runner.py b/cinoc/evaluation/runner.py
new file mode 100644
index 0000000000000000000000000000000000000000..6d653706834147fdfe3391e8fd603ee0df240fa2
--- /dev/null
+++ b/cinoc/evaluation/runner.py
@@ -0,0 +1,371 @@
+"""``evaluate_run`` — le runner (par-document → agrégat → inter-moteurs).
+
+Reçoit des **artefacts déjà produits** (couche 4, via l'app) : il n'exécute aucun
+moteur et n'importe pas ``pipeline``. **Trois passes** par vue : (1) par-document
+(``None`` = non applicable), (2) agrégat par pipeline (``None`` exclu, **support**
+exposé), (3) **inter-moteurs** — chaque ``CrossEngineMetric`` compare les
+pipelines et écrit dans ``RunResult.cross_engine``.
+
+Normalisation de la vue (``normalization_profile``/``char_exclude``) appliquée
+symétriquement GT/hyp ; représentation chargée+normalisée **une fois par
+signature** ``(ref, hyp)``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+from cinoc.domain.artifacts import Artifact, ArtifactType
+from cinoc.domain.corpus import CorpusSpec
+from cinoc.domain.documents import DocumentRef, GroundTruthRef
+from cinoc.domain.evaluation import EvaluationSpec, EvaluationView
+from cinoc.domain.run import RunManifest
+from cinoc.evaluation._view_collectors import ViewCollectors
+from cinoc.evaluation.calibration import calibration_analysis
+from cinoc.evaluation.conformity import conformity_analysis
+from cinoc.evaluation.context import CrossEngineContext, DocContext
+from cinoc.evaluation.correction import correction_analysis
+from cinoc.evaluation.economics import economics_analysis
+from cinoc.evaluation.errors import EvaluationError
+from cinoc.evaluation.inference import inference_analysis
+from cinoc.evaluation.projectors import get_projector
+from cinoc.evaluation.registry import MetricRegistry
+from cinoc.evaluation.representations import load_representation, prepare_text
+from cinoc.evaluation.result import (
+    Analysis,
+    DocumentUsage,
+    MetricScore,
+    PipelineResult,
+    RunDocumentResult,
+    RunResult,
+)
+
+#: { pipeline_name: { document_id: { ArtifactType: Artifact } } }
+PipelineOutputs = Mapping[str, Mapping[str, Mapping[ArtifactType, Artifact]]]
+
+#: Signature d'entrée d'une métrique : ``(type_référence, type_hypothèse)``.
+_Signature = tuple[ArtifactType, ArtifactType]
+
+#: Précédence **explicite** de sélection du candidat quand une vue déclare
+#: plusieurs ``candidate_types`` : du plus **aval** (corrigé) au plus brut — on
+#: évalue la sortie la plus aboutie du pipeline. Jamais l'ordre alphabétique des
+#: valeurs d'enum (qui ne coïncide avec l'intention que par hasard).
+_CANDIDATE_PRECEDENCE: tuple[ArtifactType, ...] = (
+    ArtifactType.CORRECTED_TEXT,
+    ArtifactType.RAW_TEXT,
+)
+
+#: { métrique : { pipeline : [score par doc, aligné, ``None`` inclus] } }
+_Series = dict[str, dict[str, list[MetricScore]]]
+
+#: Types **inter-changeables au niveau représentation** : tous chargés en ``str``.
+#: Un candidat ``CORRECTED_TEXT`` est donc noté par une métrique ``RAW_TEXT`` sans
+#: projection (les post-corrections LLM passent telles quelles).
+_TEXT_LIKE = frozenset({ArtifactType.RAW_TEXT, ArtifactType.CORRECTED_TEXT})
+
+
+def evaluate_run(
+    *,
+    corpus: CorpusSpec,
+    evaluation: EvaluationSpec,
+    pipeline_outputs: PipelineOutputs,
+    registry: MetricRegistry,
+    manifest: RunManifest,
+    usage: tuple[DocumentUsage, ...] = (),
+) -> RunResult:
+    """Calcule le ``RunResult`` depuis les sorties de pipelines et la GT.
+
+    ``usage`` (ressources mesurées par l'orchestrateur, une entrée par
+    pipeline × document exécuté) est embarqué tel quel, **trié** (pipeline,
+    document_id) pour un ordre déterministe.
+    """
+    pipeline_order = [spec.name for spec in manifest.pipeline_specs]
+    pipelines: list[PipelineResult] = []
+    documents: list[RunDocumentResult] = []
+    cross_engine: list[MetricScore] = []
+    analyses: list[Analysis] = []
+
+    for view in evaluation.views:
+        series: _Series = {name: {} for name in view.metric_names}
+        collectors = ViewCollectors(view)
+        for pipeline_name in pipeline_order:
+            for name in view.metric_names:
+                series[name][pipeline_name] = []
+            for document in corpus.documents:
+                candidate = _candidate_for(
+                    pipeline_outputs, pipeline_name, document.id, view.candidate_types
+                )
+                scores, text_context, entity_context = _score_document(
+                    view, document, candidate, registry
+                )
+                collectors.observe(
+                    pipeline_name,
+                    document.id,
+                    scores,
+                    text_context,
+                    entity_context,
+                )
+                for score in scores:
+                    series[score.metric][pipeline_name].append(score)
+                documents.append(
+                    RunDocumentResult(
+                        document_id=document.id,
+                        pipeline=pipeline_name,
+                        view=view.name,
+                        scores=scores,
+                        stratum=document.metadata.get("stratum"),
+                        image_ref=document.image_uri,
+                    )
+                )
+            pipelines.append(
+                PipelineResult(
+                    pipeline=pipeline_name,
+                    view=view.name,
+                    aggregate=tuple(
+                        _aggregate(name, series[name][pipeline_name])
+                        for name in view.metric_names
+                    ),
+                )
+            )
+        cross_engine.extend(_cross_engine_scores(view, series, registry))
+        analyses.extend(_inference_analyses(view, series))
+        analyses.extend(
+            collectors.build(
+                view.name,
+                [document.id for document in corpus.documents],
+                series.get("cer", {}),
+            )
+        )
+        # Analyses **autonomes** (≠ collecteurs) : elles lisent corpus /
+        # pipeline_outputs / usage directement, hors du cycle observe→build.
+        calibration = calibration_analysis(view.name, corpus, pipeline_outputs)
+        if calibration is not None:
+            analyses.append(calibration)
+        if "cer" in view.metric_names:
+            economics = economics_analysis(
+                view.name, "cer", series["cer"], usage, manifest
+            )
+            if economics is not None:
+                analyses.append(economics)
+        correction = correction_analysis(view, corpus, pipeline_outputs)
+        if correction is not None:
+            analyses.append(correction)
+
+    # Post-passe cross-vues : la conformité HIPE lit les résultats des vues
+    # raw/hipe/heritage déjà calculés (zéro re-scoring) — cf. ``conformity``.
+    conformity = conformity_analysis(evaluation.views, pipelines, documents)
+    if conformity is not None:
+        analyses.append(conformity)
+
+    return RunResult(
+        manifest=manifest,
+        pipelines=tuple(pipelines),
+        documents=tuple(documents),
+        cross_engine=tuple(cross_engine),
+        usage=tuple(sorted(usage, key=lambda u: (u.pipeline, u.document_id))),
+        analyses=tuple(
+            sorted(
+                analyses,
+                key=lambda a: (
+                    a.view,
+                    a.payload.kind,
+                    getattr(a.payload, "metric", ""),
+                ),
+            )
+        ),
+    )
+
+
+def _inference_analyses(view: EvaluationView, series: _Series) -> list[Analysis]:
+    """Inférentiel corrigé par métrique de la vue (cf. ``evaluation.inference``).
+
+    Consomme les **mêmes séries alignées** que la passe inter-moteurs : même
+    index = même document, ``None`` = non applicable — un seul calcul des
+    scores, deux lectures (scalaire ``significance_p`` + payload structuré).
+    """
+    out: list[Analysis] = []
+    for metric_name in view.metric_names:
+        per_pipeline = {
+            pipeline: [score.value for score in scores]
+            for pipeline, scores in series[metric_name].items()
+        }
+        analysis = inference_analysis(view.name, metric_name, per_pipeline)
+        if analysis is not None:
+            out.append(analysis)
+    return out
+
+
+def _aggregate(name: str, scores: list[MetricScore]) -> MetricScore:
+    """Agrégat **micro** : Σ(valeur·poids)/Σpoids — la métrique au niveau corpus.
+
+    Micro (et non la moyenne *macro* des taux par-document) est la métrique
+    conventionnelle au niveau corpus, comparable à ``jiwer`` sur le corpus
+    entier : un long document pèse à proportion de sa taille. La moyenne macro
+    reste reconstructible depuis le détail par-document (``RunResult.documents``).
+    Les documents à poids nul (référence vide) sont exclus du micro ; ``value``
+    vaut ``None`` si aucun poids (toutes réfs vides). ``support`` = nombre de
+    documents applicables.
+    """
+    pairs: list[tuple[float, int]] = []
+    for score in scores:
+        if score.value is not None:
+            pairs.append((score.value, score.support or 0))
+    total_weight = sum(weight for _, weight in pairs)
+    micro = (
+        sum(value * weight for value, weight in pairs) / total_weight
+        if total_weight > 0
+        else None
+    )
+    return MetricScore(metric=name, value=micro, support=len(pairs))
+
+
+def _cross_engine_scores(
+    view: EvaluationView, series: _Series, registry: MetricRegistry
+) -> list[MetricScore]:
+    metrics = registry.cross_engine_metrics()
+    if not metrics:
+        return []
+    scores: list[MetricScore] = []
+    for base_metric in view.metric_names:
+        per_pipeline = {
+            pipeline: tuple(score.value for score in scores_list)
+            for pipeline, scores_list in series[base_metric].items()
+        }
+        context = CrossEngineContext(metric=base_metric, per_pipeline=per_pipeline)
+        for metric in metrics:
+            value, support = metric.fn(context)
+            scores.append(
+                MetricScore(
+                    metric=f"{view.name}:{base_metric}:{metric.name}",
+                    value=value,
+                    support=support,
+                )
+            )
+    return scores
+
+
+def _candidate_for(
+    pipeline_outputs: PipelineOutputs,
+    pipeline_name: str,
+    document_id: str,
+    candidate_types: frozenset[ArtifactType],
+) -> Artifact | None:
+    by_document: Mapping[str, Mapping[ArtifactType, Artifact]] = (
+        pipeline_outputs.get(pipeline_name, {})
+    )
+    outputs: Mapping[ArtifactType, Artifact] = by_document.get(document_id, {})
+    ordered = [t for t in _CANDIDATE_PRECEDENCE if t in candidate_types]
+    ordered.extend(
+        sorted(
+            (t for t in candidate_types if t not in _CANDIDATE_PRECEDENCE),
+            key=lambda t: t.value,
+        )
+    )
+    for artifact_type in ordered:
+        if artifact_type in outputs:
+            return outputs[artifact_type]
+    return None
+
+
+def _score_document(
+    view: EvaluationView,
+    document: DocumentRef,
+    candidate: Artifact | None,
+    registry: MetricRegistry,
+) -> tuple[tuple[MetricScore, ...], DocContext | None, DocContext | None]:
+    # Représentation chargée + normalisée une seule fois par signature, partagée
+    # par toutes les métriques qui la consomment (CER/WER/MER). Les contextes
+    # **texte** et **entités** sont aussi renvoyés : les collecteurs (confusions,
+    # pires lignes, NER) les consomment sans recharger ni renormaliser.
+    contexts: dict[_Signature, DocContext | None] = {}
+    scores: list[MetricScore] = []
+    for name in view.metric_names:
+        metric = registry.document_metric(name)
+        if metric is None:
+            raise EvaluationError(f"métrique inconnue : {name!r}.")
+        signature = metric.input_types
+        if signature not in contexts:
+            contexts[signature] = _context_for(view, document, candidate, signature)
+        context = contexts[signature]
+        observation = metric.fn(context) if context is not None else None
+        scores.append(
+            MetricScore(
+                metric=name,
+                value=observation.value if observation is not None else None,
+                support=observation.weight if observation is not None else None,
+            )
+        )
+    text_context = contexts.get((ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT))
+    entity_context = contexts.get((ArtifactType.ENTITIES, ArtifactType.ENTITIES))
+    return tuple(scores), text_context, entity_context
+
+
+def _context_for(
+    view: EvaluationView,
+    document: DocumentRef,
+    candidate: Artifact | None,
+    signature: _Signature,
+) -> DocContext | None:
+    reference_type, hypothesis_type = signature
+    if candidate is None or candidate.uri is None:
+        return None
+    resolved = _resolve_ground_truth(document, view, reference_type)
+    if resolved is None:
+        return None
+    ground_truth, gt_native_type = resolved
+    reference = _project_side(ground_truth.uri, gt_native_type, reference_type, view)
+    hypothesis = _project_side(candidate.uri, candidate.type, hypothesis_type, view)
+    if reference is None or hypothesis is None:
+        return None
+    return DocContext(
+        document_id=document.id,
+        reference=_prepare(reference, view),
+        hypothesis=_prepare(hypothesis, view),
+    )
+
+
+def _resolve_ground_truth(
+    document: DocumentRef, view: EvaluationView, reference_type: ArtifactType
+) -> tuple[GroundTruthRef, ArtifactType] | None:
+    """GT dont le type natif **alimente** ``reference_type`` (direct ou projeté)."""
+    direct = document.gt_for(reference_type)
+    if direct is not None:
+        return direct, reference_type
+    for gt in document.ground_truths:
+        spec = view.projection_for(gt.type)
+        if spec is not None and spec.target_type == reference_type:
+            return gt, gt.type
+    return None
+
+
+def _project_side(
+    uri: str,
+    native_type: ArtifactType,
+    target_type: ArtifactType,
+    view: EvaluationView,
+) -> object | None:
+    """Charge ``uri`` dans son type natif, projette vers ``target_type`` si besoin.
+
+    Identité si types égaux ou tous deux *text-like* (même représentation ``str``).
+    Sinon une ``ProjectionSpec`` de la vue doit pont(er) ``native → target`` ; à
+    défaut, ``None`` (jonction non applicable, pas de comparaison factice).
+    """
+    representation = load_representation(uri, native_type)
+    if native_type == target_type or (
+        native_type in _TEXT_LIKE and target_type in _TEXT_LIKE
+    ):
+        return representation
+    spec = view.projection_for(native_type)
+    if spec is None or spec.target_type != target_type:
+        return None
+    return get_projector(spec.projector_name)(representation, spec.params)
+
+
+def _prepare(representation: object, view: EvaluationView) -> object:
+    """Applique la normalisation de la vue (profil + ``char_exclude``) au texte."""
+    if not isinstance(representation, str):
+        return representation
+    return prepare_text(representation, view)
+
+
+__all__ = ["PipelineOutputs", "evaluate_run"]
diff --git a/cinoc/evaluation/structured_data.py b/cinoc/evaluation/structured_data.py
new file mode 100644
index 0000000000000000000000000000000000000000..2cc568ad3858b9068ba1e6f2a9c6255e86ea14f7
--- /dev/null
+++ b/cinoc/evaluation/structured_data.py
@@ -0,0 +1,85 @@
+"""Collecteur de **données structurées** par pipeline (couche 3).
+
+Pattern ``TaxonomyCollector`` : observe (pipeline, GT, hypothèse) au fil du
+scoring — mêmes représentations normalisées, zéro relecture — puis ``build``
+agrège par catégorie (micro : Σ comptes) → ``StructuredDataPayload``.
+Adaptatif : GT du corpus sans séquence → ``None`` (pas de payload vide).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from cinoc.evaluation.analysis import (
+    Analysis,
+    CategoryBreakdown,
+    PipelineStructuredData,
+    StructuredDataPayload,
+)
+from cinoc.evaluation.metrics.structured_data import CATEGORIES, sequence_counts
+
+#: Plafond de formes perdues embarquées, par (pipeline × catégorie).
+_MAX_LOST_SAMPLES = 12
+
+
+@dataclass
+class _Slot:
+    """Sommes courantes d'une (pipeline × catégorie)."""
+
+    n_total: int = 0
+    n_strict: int = 0
+    n_value: int = 0
+    lost: list[str] = field(default_factory=list)
+
+
+class StructuredDataCollector:
+    """Accumule les comptes par (pipeline × catégorie), ``build`` borne."""
+
+    def __init__(self) -> None:
+        self._sums: dict[str, dict[str, _Slot]] = {}
+        self._pipelines: list[str] = []
+
+    def observe(self, pipeline: str, reference: str, hypothesis: str) -> None:
+        for category, counts in sequence_counts(reference, hypothesis).items():
+            if pipeline not in self._sums:
+                self._sums[pipeline] = {}
+                self._pipelines.append(pipeline)
+            slot = self._sums[pipeline].setdefault(category, _Slot())
+            slot.n_total += counts.n_total
+            slot.n_strict += counts.n_strict
+            slot.n_value += counts.n_value
+            missing = _MAX_LOST_SAMPLES - len(slot.lost)
+            if missing > 0:
+                slot.lost.extend(counts.lost[:missing])
+
+    def build(self, view: str) -> Analysis | None:
+        """Payload de la vue, ``None`` si aucune séquence dans la GT."""
+        rows: list[PipelineStructuredData] = []
+        for pipeline in self._pipelines:
+            categories = tuple(
+                CategoryBreakdown(
+                    category=category,
+                    n_total=slot.n_total,
+                    n_strict=slot.n_strict,
+                    n_value=slot.n_value,
+                    strict_score=slot.n_strict / slot.n_total,
+                    value_score=slot.n_value / slot.n_total,
+                    lost=tuple(slot.lost),
+                )
+                for category in CATEGORIES
+                if (slot := self._sums[pipeline].get(category)) is not None
+            )
+            if categories:
+                rows.append(
+                    PipelineStructuredData(pipeline=pipeline, categories=categories)
+                )
+        if not rows:
+            return None
+        return Analysis(
+            scope="corpus",
+            view=view,
+            payload=StructuredDataPayload(pipelines=tuple(rows)),
+        )
+
+
+__all__ = ["StructuredDataCollector"]
diff --git a/cinoc/evaluation/taxonomy.py b/cinoc/evaluation/taxonomy.py
new file mode 100644
index 0000000000000000000000000000000000000000..6346f50ae604ba0839883a4c46e1c8c94911ad77
--- /dev/null
+++ b/cinoc/evaluation/taxonomy.py
@@ -0,0 +1,159 @@
+"""Taxonomie d'erreurs : classification par règles pures (couche 3).
+
+Transforme « combien d'erreurs » en « quelles erreurs » : chaque mot erroné
+est classé par des règles **déterministes et auditables** (aucun ML, aucun
+lexique). Heuristique maison (PLAN_PARITE §5.8b : spécification source relue
+et **élaguée** — les classes à lexique ``hapax``/``oov_character`` et
+l'``abbreviation_error`` à table MUFI ne sont pas portées, cf. D-071).
+
+Classes (ordre de test = priorité) :
+
+- ``segmentation`` — fusion/fragmentation : la concaténation d'un côté égale
+  l'autre (« bonjour » ↔ « bon jour ») ;
+- ``case`` — casse seule (« Chat » ↔ « chat ») ;
+- ``diacritic`` — diacritiques seuls (« été » ↔ « ete ») ;
+- ``ligature`` — ligature non résolue (« cœur » ↔ « coeur ») ;
+- ``visual`` — confusion morphologique connue (rn↔m, l/1/I, O/0, u↔n, ſ↔s) ;
+- ``lacuna`` — mot de la référence absent de l'hypothèse ;
+- ``insertion`` — mot de l'hypothèse absent de la référence ;
+- ``other`` — substitution résiduelle inclassée.
+"""
+
+from __future__ import annotations
+
+import unicodedata
+from collections import Counter
+from difflib import SequenceMatcher
+
+from cinoc.evaluation.analysis import (
+    Analysis,
+    PipelineTaxonomy,
+    TaxonomyCount,
+    TaxonomyPayload,
+)
+
+#: Ordre de rendu canonique des classes (déterminisme du payload).
+CLASSES: tuple[str, ...] = (
+    "segmentation",
+    "case",
+    "diacritic",
+    "ligature",
+    "visual",
+    "lacuna",
+    "insertion",
+    "other",
+)
+
+#: Ligatures → développement (test dans les deux sens).
+_LIGATURES = {
+    "œ": "oe", "æ": "ae", "Œ": "OE", "Æ": "AE",
+    "fi": "fi", "fl": "fl", "ff": "ff",
+}
+
+#: Groupes de confusions visuelles → représentant canonique. Appliqué aux
+#: **deux** côtés d'une paire déjà fautive (pas de faux positif sur un mot juste).
+_VISUAL_CANON = (
+    ("rn", "m"),
+    ("1", "l"),
+    ("I", "l"),
+    ("|", "l"),
+    ("0", "o"),
+    ("O", "o"),
+    ("ſ", "s"),
+    ("u", "n"),
+)
+
+
+def _strip_diacritics(text: str) -> str:
+    return "".join(
+        c for c in unicodedata.normalize("NFD", text)
+        if not unicodedata.combining(c)
+    )
+
+
+def _expand_ligatures(text: str) -> str:
+    for ligature, expansion in _LIGATURES.items():
+        text = text.replace(ligature, expansion)
+    return text
+
+
+def _visual_canonical(text: str) -> str:
+    for variant, canon in _VISUAL_CANON:
+        text = text.replace(variant, canon)
+    return text
+
+
+def classify_word_pair(reference: str, hypothesis: str) -> str:
+    """Classe d'une substitution mot → mot (règles pures, ordre = priorité)."""
+    if reference.lower() == hypothesis.lower():
+        return "case"
+    if _strip_diacritics(reference) == _strip_diacritics(hypothesis):
+        return "diacritic"
+    if _expand_ligatures(reference) == _expand_ligatures(hypothesis):
+        return "ligature"
+    if _visual_canonical(reference.lower()) == _visual_canonical(hypothesis.lower()):
+        return "visual"
+    return "other"
+
+
+def classify_texts(reference: str, hypothesis: str) -> Counter[str]:
+    """Comptage des classes d'erreurs entre deux textes (mots alignés difflib)."""
+    counts: Counter[str] = Counter()
+    ref_words = reference.split()
+    hyp_words = hypothesis.split()
+    matcher = SequenceMatcher(a=ref_words, b=hyp_words, autojunk=False)
+    for op, a0, a1, b0, b1 in matcher.get_opcodes():
+        if op == "equal":
+            continue
+        ref_seg, hyp_seg = ref_words[a0:a1], hyp_words[b0:b1]
+        if op == "delete":
+            counts["lacuna"] += len(ref_seg)
+            continue
+        if op == "insert":
+            counts["insertion"] += len(hyp_seg)
+            continue
+        # replace : fusion/fragmentation d'abord (au niveau du segment).
+        if "".join(ref_seg) == "".join(hyp_seg):
+            counts["segmentation"] += max(len(ref_seg), len(hyp_seg))
+            continue
+        for ref_word, hyp_word in zip(ref_seg, hyp_seg, strict=False):
+            counts[classify_word_pair(ref_word, hyp_word)] += 1
+        # Mots non appariés du segment (longueurs inégales).
+        if len(ref_seg) > len(hyp_seg):
+            counts["lacuna"] += len(ref_seg) - len(hyp_seg)
+        elif len(hyp_seg) > len(ref_seg):
+            counts["insertion"] += len(hyp_seg) - len(ref_seg)
+    return counts
+
+
+class TaxonomyCollector:
+    """Accumule les classes d'erreurs au fil du scoring d'une vue."""
+
+    def __init__(self) -> None:
+        self._counts: dict[str, Counter[str]] = {}
+
+    def observe(self, pipeline: str, reference: str, hypothesis: str) -> None:
+        bucket = self._counts.setdefault(pipeline, Counter())
+        bucket.update(classify_texts(reference, hypothesis))
+
+    def build(self, view: str) -> Analysis | None:
+        rows = tuple(
+            PipelineTaxonomy(
+                pipeline=pipeline,
+                total_errors=sum(bucket.values()),
+                counts=tuple(
+                    TaxonomyCount(label=label, count=bucket[label])
+                    for label in CLASSES
+                    if bucket[label] > 0
+                ),
+            )
+            for pipeline, bucket in sorted(self._counts.items())
+            if bucket
+        )
+        if not rows:
+            return None
+        payload = TaxonomyPayload(classes=CLASSES, pipelines=rows)
+        return Analysis(scope="corpus", view=view, payload=payload)
+
+
+__all__ = ["CLASSES", "TaxonomyCollector", "classify_texts", "classify_word_pair"]
diff --git a/cinoc/evaluation/textual_fidelity.py b/cinoc/evaluation/textual_fidelity.py
new file mode 100644
index 0000000000000000000000000000000000000000..652fefeed98477321a17190c96a245f9955451d7
--- /dev/null
+++ b/cinoc/evaluation/textual_fidelity.py
@@ -0,0 +1,256 @@
+"""Fidélité textuelle : tokens rares + modernisation lexicale (couche 3).
+
+Deux diagnostics que le CER global masque, sur **un seul** alignement mot-à-mot :
+
+- **Rappel des tokens rares** — un CER de 5 % peut cacher des erreurs
+  systématiques sur les noms propres / toponymes / termes techniques (≤ 2
+  occurrences corpus-wide : hapax + dis legomena). Ce sont eux qui comptent en
+  indexation prosopographique. Rappel **multiset** (`Σ min(occ. GT, occ. hyp)`).
+- **Modernisation lexicale** — quelles formes historiques le moteur (LLM/VLM)
+  réécrit (`maistre`→`maître`, `nostre`→`nostre`, mot supprimé → `∅`). Table de
+  fréquences = diagnostic de prompt, pas un score agrégé.
+
+Particularité d'architecture (≠ scalaires `air`/`mufi_err`) : la rareté est
+**corpus-wide** — connue seulement après la passe complète. Le collecteur
+accumule (pipeline × document) au fil du scoring (pattern ``TaxonomyCollector``,
+zéro relecture), puis ``build`` calcule les fréquences sur les GT collectées et
+en dérive le rappel — tout **après** la passe, sans mécanique nouvelle dans le
+runner. Pur stdlib (``re`` + ``difflib`` + ``Counter``).
+"""
+
+from __future__ import annotations
+
+import difflib
+import re
+from collections import Counter
+from dataclasses import dataclass, field
+
+from cinoc.evaluation.analysis import (
+    Analysis,
+    ModernizedToken,
+    ModernizedVariant,
+    PipelineTextualFidelity,
+    TextualFidelityPayload,
+)
+
+#: Token = séquence de caractères de mot Unicode, contractions (`l'an`, `d'une`)
+#: et mots composés (`peut-être`) conservés comme **un** token ; ponctuation et
+#: espaces = séparateurs. Une seule tokenisation pour les deux mesures.
+_TOKEN_RE = re.compile(r"\w+(?:['’\-]\w+)*", re.UNICODE)
+
+#: Mot supprimé par le moteur (variante de modernisation).
+_DELETED = "∅"
+
+#: Rareté par défaut : ≤ 2 occurrences corpus-wide (hapax + dis legomena).
+_DEFAULT_MAX_FREQ = 2
+
+#: Plafonds d'échantillons embarqués (bornent le payload).
+_MAX_MISSED = 20
+_MAX_MODERNIZED_TOKENS = 20
+_MAX_VARIANTS = 5
+
+
+def tokenize(text: str) -> list[str]:
+    """Tokens **minuscules** (casse non pertinente pour rareté/modernisation)."""
+    return [match.lower() for match in _TOKEN_RE.findall(text)]
+
+
+def corpus_frequencies(references: list[str]) -> Counter[str]:
+    """``{token: occurrences}`` sur les GT du corpus (une GT par document)."""
+    counter: Counter[str] = Counter()
+    for reference in references:
+        counter.update(tokenize(reference))
+    return counter
+
+
+def rare_tokens(frequencies: Counter[str], max_freq: int) -> frozenset[str]:
+    """Tokens dont la fréquence corpus-wide est ``≤ max_freq``."""
+    return frozenset(token for token, n in frequencies.items() if n <= max_freq)
+
+
+def rare_recall_counts(
+    reference: str, hypothesis: str, rare: frozenset[str]
+) -> tuple[int, int, list[str]]:
+    """``(n_reference, n_recalled, missed)`` des tokens rares de la GT.
+
+    Multiset : un token rare présent 2× en GT et 1× en hyp → 1 rappelé, 1 manqué.
+    ``missed`` porte la multiplicité (token répété autant que manqué), dans
+    l'ordre d'apparition GT.
+    """
+    ref_rare = Counter(token for token in tokenize(reference) if token in rare)
+    n_reference = sum(ref_rare.values())
+    if n_reference == 0:
+        return 0, 0, []
+    hyp_rare = Counter(token for token in tokenize(hypothesis) if token in rare)
+    n_recalled = 0
+    missed: list[str] = []
+    for token, ref_count in ref_rare.items():
+        recalled = min(ref_count, hyp_rare.get(token, 0))
+        n_recalled += recalled
+        missed.extend([token] * (ref_count - recalled))
+    return n_reference, n_recalled, missed
+
+
+@dataclass
+class _ModSlot:
+    """Sommes de modernisation d'un token GT (corpus, micro)."""
+
+    n_total: int = 0
+    n_modernized: int = 0
+    variants: Counter[str] = field(default_factory=Counter)
+
+
+def modernization_counts(reference: str, hypothesis: str) -> dict[str, _ModSlot]:
+    """Réécriture par token GT via alignement mot-à-mot ``difflib``.
+
+    ``equal`` → token compté (non modernisé) ; ``replace`` apparié 1-à-1 →
+    modernisé (variante = forme hyp) ; GT en trop d'un ``replace`` ou ``delete``
+    → modernisé en ``∅`` (supprimé). ``autojunk=False`` : pas d'heuristique de
+    saut sur les tokens fréquents (déterminisme).
+    """
+    ref_tokens = tokenize(reference)
+    hyp_tokens = tokenize(hypothesis)
+    slots: dict[str, _ModSlot] = {}
+
+    def bump(token: str, variant: str | None) -> None:
+        slot = slots.setdefault(token, _ModSlot())
+        slot.n_total += 1
+        if variant is not None:
+            slot.n_modernized += 1
+            slot.variants[variant] += 1
+
+    matcher = difflib.SequenceMatcher(None, ref_tokens, hyp_tokens, autojunk=False)
+    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+        if tag == "equal":
+            for k in range(i1, i2):
+                bump(ref_tokens[k], None)
+        elif tag == "replace":
+            paired = min(i2 - i1, j2 - j1)
+            for k in range(paired):
+                bump(ref_tokens[i1 + k], hyp_tokens[j1 + k])
+            for k in range(i1 + paired, i2):
+                bump(ref_tokens[k], _DELETED)
+        elif tag == "delete":
+            for k in range(i1, i2):
+                bump(ref_tokens[k], _DELETED)
+    return slots
+
+
+@dataclass
+class _PipelineSlot:
+    """Accumulateur d'un pipeline : rappel rare + table de modernisation."""
+
+    pairs: list[tuple[str, str]] = field(default_factory=list)
+    modernization: dict[str, _ModSlot] = field(default_factory=dict)
+
+
+class TextualFidelityCollector:
+    """Accumule (pipeline × document) au scoring ; ``build`` calcule corpus-wide.
+
+    La rareté exige les fréquences de **toutes** les GT → le rappel se calcule à
+    ``build`` ; la modernisation, elle, s'agrège au fil de l'eau (indépendante du
+    corpus). Les GT sont dédupliquées par document (mêmes GT pour tous les
+    pipelines) pour la distribution de fréquence.
+    """
+
+    def __init__(self, max_freq: int = _DEFAULT_MAX_FREQ) -> None:
+        self._max_freq = max_freq
+        self._gt_by_document: dict[str, str] = {}
+        self._pipelines: dict[str, _PipelineSlot] = {}
+        self._order: list[str] = []
+
+    def observe(
+        self, pipeline: str, document_id: str, reference: str, hypothesis: str
+    ) -> None:
+        self._gt_by_document.setdefault(document_id, reference)
+        if pipeline not in self._pipelines:
+            self._pipelines[pipeline] = _PipelineSlot()
+            self._order.append(pipeline)
+        slot = self._pipelines[pipeline]
+        slot.pairs.append((reference, hypothesis))
+        for token, mod in modernization_counts(reference, hypothesis).items():
+            agg = slot.modernization.setdefault(token, _ModSlot())
+            agg.n_total += mod.n_total
+            agg.n_modernized += mod.n_modernized
+            agg.variants.update(mod.variants)
+
+    def build(self, view: str) -> Analysis | None:
+        """Payload de la vue, ``None`` si aucun pipeline n'a produit de texte."""
+        if not self._order:
+            return None
+        frequencies = corpus_frequencies(list(self._gt_by_document.values()))
+        rare = rare_tokens(frequencies, self._max_freq)
+        rows = [
+            self._pipeline_row(pipeline, rare) for pipeline in self._order
+        ]
+        return Analysis(
+            scope="corpus",
+            view=view,
+            payload=TextualFidelityPayload(
+                max_freq=self._max_freq, pipelines=tuple(rows)
+            ),
+        )
+
+    def _pipeline_row(
+        self, pipeline: str, rare: frozenset[str]
+    ) -> PipelineTextualFidelity:
+        slot = self._pipelines[pipeline]
+        n_reference = n_recalled = 0
+        missed: list[str] = []
+        for reference, hypothesis in slot.pairs:
+            doc_ref, doc_rec, doc_missed = rare_recall_counts(
+                reference, hypothesis, rare
+            )
+            n_reference += doc_ref
+            n_recalled += doc_rec
+            missed.extend(doc_missed[: _MAX_MISSED - len(missed)])
+        recall = n_recalled / n_reference if n_reference > 0 else None
+        return PipelineTextualFidelity(
+            pipeline=pipeline,
+            n_rare_reference=n_reference,
+            n_rare_recalled=n_recalled,
+            rare_recall=recall,
+            missed=tuple(missed),
+            modernization=_top_modernized(slot.modernization),
+        )
+
+
+def _top_modernized(slots: dict[str, _ModSlot]) -> tuple[ModernizedToken, ...]:
+    """Tokens réécrits, triés (-taux, -total, token), capés ; variantes capées."""
+    modernized = [
+        (token, slot)
+        for token, slot in slots.items()
+        if slot.n_modernized > 0
+    ]
+    modernized.sort(
+        key=lambda pair: (
+            -pair[1].n_modernized / pair[1].n_total,
+            -pair[1].n_total,
+            pair[0],
+        )
+    )
+    return tuple(
+        ModernizedToken(
+            token=token[:64],
+            n_total=slot.n_total,
+            n_modernized=slot.n_modernized,
+            rate=slot.n_modernized / slot.n_total,
+            variants=tuple(
+                ModernizedVariant(form=form[:64], count=count)
+                for form, count in sorted(
+                    slot.variants.items(), key=lambda v: (-v[1], v[0])
+                )[:_MAX_VARIANTS]
+            ),
+        )
+        for token, slot in modernized[:_MAX_MODERNIZED_TOKENS]
+    )
+
+
+__all__ = [
+    "TextualFidelityCollector",
+    "corpus_frequencies",
+    "modernization_counts",
+    "rare_recall_counts",
+    "rare_tokens",
+    "tokenize",
+]
diff --git a/cinoc/evaluation/word_errors.py b/cinoc/evaluation/word_errors.py
new file mode 100644
index 0000000000000000000000000000000000000000..879ad5bf1a92df569bbd80767be811d8f52e7283
--- /dev/null
+++ b/cinoc/evaluation/word_errors.py
@@ -0,0 +1,173 @@
+"""Carte des mots — quels mots GT chaque moteur ne restitue pas (couche 3).
+
+Le CER global dit *combien* d'erreurs, jamais *lesquelles*. Cette analyse pose la
+**matière** sur la table : pour chaque mot de la vérité-terrain qu'un moteur ne
+reproduit pas, on compte les échecs **par moteur** et on **croise** les pipelines
+— quels mots *tous* ratent (difficulté de la matière) vs *un seul* (faiblesse
+moteur). On juge à l'œil sur les mots eux-mêmes.
+
+Réutilise la **tokenisation partagée** (``textual_fidelity.tokenize`` — mots
+Unicode minuscules, une seule définition de token dans la couche) et l'alignement
+mot-à-mot ``difflib.SequenceMatcher`` : un mot GT est « raté » sur les tags
+``replace``/``delete`` (pas reproduit verbatim). La **forme produite dominante**
+est gardée (la matière de la confusion). Pur stdlib (``difflib`` + ``Counter``).
+
+Honnêteté : l'appariement dépend de la **normalisation de la vue** (GT/hyp
+préparés identiquement en amont par le runner) ; une **fusion/scission** de mots
+est une limite de l'alignement (un ``replace`` n-à-m apparie au mieux 1-à-1, le
+reste devient ``∅``) ; mots et variantes sont **verbatim** (rien d'inventé —
+anti-hallucination D-094).
+"""
+
+from __future__ import annotations
+
+import difflib
+from collections import Counter
+from dataclasses import dataclass, field
+from typing import Literal
+
+from cinoc.evaluation.analysis import (
+    Analysis,
+    EngineWordError,
+    WordError,
+    WordErrorPayload,
+)
+from cinoc.evaluation.textual_fidelity import tokenize
+
+#: Mot GT supprimé par le moteur (aucune forme produite) — convention partagée
+#: avec la modernisation lexicale (``∅``).
+_DELETED = "∅"
+
+#: Mots embarqués dans le payload : les plus durs (-total d'erreurs, puis mot).
+#: Cap explicite — borne le payload comme les autres collecteurs (caps de
+#: ``textual_fidelity``/``inter_engine``).
+_MAX_WORDS = 50
+
+
+def word_misses(reference: str, hypothesis: str) -> list[tuple[str, str]]:
+    """``(mot_GT, forme_produite)`` des mots GT non restitués (tags replace/delete).
+
+    Alignement mot-à-mot ``difflib`` (``autojunk=False`` — déterminisme, pas
+    d'heuristique de saut sur les tokens fréquents). ``replace`` apparié 1-à-1 → la
+    forme produite est le mot hyp aligné ; un GT en trop d'un ``replace`` ou un
+    ``delete`` → ``∅`` (supprimé). Les mots hyp insérés (tag ``insert``) ne sont
+    **pas** des ratés GT (mesure centrée GT). ``equal`` → mot restitué, ignoré.
+    """
+    ref_tokens = tokenize(reference)
+    hyp_tokens = tokenize(hypothesis)
+    misses: list[tuple[str, str]] = []
+    matcher = difflib.SequenceMatcher(None, ref_tokens, hyp_tokens, autojunk=False)
+    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+        if tag == "replace":
+            paired = min(i2 - i1, j2 - j1)
+            for k in range(paired):
+                misses.append((ref_tokens[i1 + k], hyp_tokens[j1 + k]))
+            for k in range(i1 + paired, i2):
+                misses.append((ref_tokens[k], _DELETED))
+        elif tag == "delete":
+            for k in range(i1, i2):
+                misses.append((ref_tokens[k], _DELETED))
+    return misses
+
+
+@dataclass
+class _WordSlot:
+    """Échecs d'un (pipeline, mot GT) : compte + formes produites observées."""
+
+    count: int = 0
+    variants: Counter[str] = field(default_factory=Counter)
+
+
+class WordErrorCollector:
+    """Accumule les mots GT ratés (pipeline × mot) au scoring ; ``build`` croise.
+
+    ``observe`` aligne GT↔hyp au mot et incrémente, par (pipeline, mot GT), le
+    nombre d'échecs + la forme produite. ``build`` cross-tabule sur les pipelines
+    **observés** (ceux qui ont produit du texte — comme ``inter_engine``) → matrice
+    mot→{moteur:compte} + signature de regroupement. ``None`` si < 2 pipelines ou
+    aucune erreur. ``document_id`` n'entre pas dans l'agrégat (les échecs se
+    somment sur tout le corpus, indépendamment du document) — conservé dans la
+    signature pour l'uniformité de câblage du runner.
+    """
+
+    def __init__(self) -> None:
+        self._order: list[str] = []
+        self._slots: dict[str, dict[str, _WordSlot]] = {}
+
+    def observe(
+        self, pipeline: str, document_id: str, reference: str, hypothesis: str
+    ) -> None:
+        if pipeline not in self._slots:
+            self._slots[pipeline] = {}
+            self._order.append(pipeline)
+        per_word = self._slots[pipeline]
+        for word, variant in word_misses(reference, hypothesis):
+            slot = per_word.setdefault(word, _WordSlot())
+            slot.count += 1
+            slot.variants[variant] += 1
+
+    def build(self, view: str) -> Analysis | None:
+        """Payload ``word_errors`` de la vue, ``None`` si non applicable."""
+        pipelines = sorted(self._slots)
+        if len(pipelines) < 2:
+            return None
+        # Mot GT → {pipeline : slot}, sur les seuls moteurs qui le ratent (creux).
+        by_word: dict[str, dict[str, _WordSlot]] = {}
+        for pipeline in pipelines:
+            for word, slot in self._slots[pipeline].items():
+                by_word.setdefault(word, {})[pipeline] = slot
+        if not by_word:
+            return None
+        words = [
+            _word_error(word, per_pipeline, len(pipelines))
+            for word, per_pipeline in by_word.items()
+        ]
+        # Tri déterministe : les mots les plus ratés d'abord, puis alpha ; capé.
+        words.sort(key=lambda w: (-w.total_errors, w.word))
+        return Analysis(
+            scope="corpus",
+            view=view,
+            payload=WordErrorPayload(
+                pipelines=tuple(pipelines),
+                words=tuple(words[:_MAX_WORDS]),
+            ),
+        )
+
+
+def _word_error(
+    word: str, per_pipeline: dict[str, _WordSlot], n_pipelines: int
+) -> WordError:
+    """``WordError`` d'un mot : détail par moteur (creux), total, regroupement."""
+    per_engine = tuple(
+        EngineWordError(
+            pipeline=pipeline,
+            count=slot.count,
+            variant=_dominant_variant(slot.variants),
+        )
+        for pipeline, slot in sorted(
+            per_pipeline.items(), key=lambda item: (-item[1].count, item[0])
+        )
+    )
+    n_engines = len(per_engine)
+    group: Literal["universal", "engine_specific", "partial"]
+    if n_engines == n_pipelines:
+        group = "universal"
+    elif n_engines == 1:
+        group = "engine_specific"
+    else:
+        group = "partial"
+    return WordError(
+        word=word[:64],
+        total_errors=sum(engine.count for engine in per_engine),
+        per_engine=per_engine,
+        group=group,
+    )
+
+
+def _dominant_variant(variants: Counter[str]) -> str:
+    """Forme produite **dominante** (-compte, puis forme) — verbatim, capée 64 c."""
+    form, _ = min(variants.items(), key=lambda item: (-item[1], item[0]))
+    return form[:64]
+
+
+__all__ = ["WordErrorCollector", "word_misses"]
diff --git a/cinoc/formats/MIGRATION_COUCHE_2.md b/cinoc/formats/MIGRATION_COUCHE_2.md
new file mode 100644
index 0000000000000000000000000000000000000000..db25f8a2298047e1e9ad361792bb31fee92f7dee
--- /dev/null
+++ b/cinoc/formats/MIGRATION_COUCHE_2.md
@@ -0,0 +1,251 @@
+# Plan de migration — Couche 2 (`formats/`) : Picarones → Cinoc
+
+> **Statut** : plan validé, prêt à exécuter.
+> **Périmètre** : uniquement la couche 2 (`formats/`).
+> **Source** : `Picarones/picarones/formats/` (parsers/writer/types ALTO & PAGE, sécurité XML, normalisation).
+> **Cible** : `Cinoc/cinoc/formats/`.
+
+---
+
+## 1. Objectif & périmètre
+
+La couche `formats` est la **frontière entre les formats de fil** (ALTO XML, PAGE XML,
+texte brut) et le reste du système. Elle lit (parse), écrit (sérialise) et normalise du
+texte ; elle n'opère que sur des **bytes** et des **chaînes**, jamais sur un résultat
+d'OCR ou un calcul de métrique.
+
+**Dans le périmètre :**
+
+- parsers + writers **ALTO** et **PAGE** (symétriques) ;
+- sécurité XML (`safe_parse_xml`) ;
+- lecteur de **texte brut** (`read_plaintext`) ;
+- **normalisation** (profils de comparaison).
+
+**Hors périmètre (différé, avec justification) :**
+
+- `CanonicalLayout` (modèle structurel neutre) — payload de `ArtifactType.LAYOUT` ;
+- l'**assembleur** `CanonicalLayout → AltoDocument/PageDocument` ;
+- le lecteur `CANONICAL_DOCUMENT` (sortie VLM markdown/JSON) ;
+- les **projecteurs** Document → texte (couche 3) et toutes les **métriques** (couche 3).
+
+```
+cinoc/formats/
+├── __init__.py        API publique resserrée
+├── _xml.py            safe_parse_xml (lxml durci)
+├── alto/              types.py · parser.py · writer.py
+├── pagexml/           types.py · parser.py · writer.py   (writer = NOUVEAU)
+└── text/              normalization.py · plain.py
+```
+
+---
+
+## 2. Principe directeur de ce plan
+
+On ne **fige à l'avance** qu'une décision qui est **(1) irréversible**, **(2) transverse**
+(façonne beaucoup de fichiers ou plusieurs couches), ou **(3) une abstraction qu'on
+s'apprête à bâtir en grand et qui pourrait être fausse**. Tout le reste — local,
+réversible, pas cher à changer — **se décide en codant, sous test**.
+
+Ce document fige donc un **noyau court** (§3–§6) et **renvoie explicitement au codage**
+le reste (§8). Sur-spécifier des politiques locales en prose serait du gaspillage : un
+test les tranche mieux (cf. la correction de l'ordre de normalisation, trouvée tardivement
+en raisonnant dans l'abstrait — voir §5, D8).
+
+---
+
+## 3. Noyau verrouillé
+
+Décisions qui passent le filtre (1/2/3) et qui sont **figées**.
+
+| # | Décision | Filtre | Détail |
+|---|----------|--------|--------|
+| **L1** | **lxml** pour tout parsing/écriture XML | (2)+(1) | Toute la couche en dépend ; déterminisme (C14N), namespaces thread-safe, parsing tolérant. Changer de lib ensuite toucherait tous les fichiers. |
+| **L2** | **Entonnoir unique `safe_parse_xml`** + durcissement explicite | (1)+(2) | Tous les parsers passent par lui. Config : `resolve_entities=False`, `no_network=True`, `load_dtd=False`, `huge_tree=False`, **rejet de tout `<!DOCTYPE>`**. Une faille livrée est irréversible. Un test de sécurité dédié (XXE, billion laughs, DOCTYPE distant) est obligatoire. |
+| **L3** | **Frontière `bytes`, zéro I/O** | (2) | `parse_alto`/`parse_pagexml`/`read_plaintext` prennent des **bytes** ; la lecture disque est au caller (couche 3). Les payloads de corpus portent des bytes, **pas** des `str` pré-décodés. |
+| **L4** | **Forme du modèle de types** : géométrie **numérique** (pas de chaînes), ordre de lecture en **arbre**, régions modélisées largement, confidences présentes | (3)+(2) | Façonne parser, writer, futures métriques structurelles et l'adaptateur vers `CanonicalLayout`. Re-façonner ensuite = cher. Le *détail des champs* reste du codage. |
+| **L5** | **Géométrie native au format** | (2) | ALTO : `bbox` + `polygon` + `baseline` ; PAGE : `coords` (polygone) + `baseline`. Points **entiers**. **Unité de coordonnées + dimensions de page capturées** (la réconciliation inter-unités est couche 3). Pas de fusion neutre ici (différée avec `CanonicalLayout`). |
+| **L6** | **Writers symétriques, riches, depuis le standard** | (2) | `write_alto(AltoDocument)` **et** `write_pagexml(PageDocument)` → bytes. `write_pagexml` est **nouveau** (absent de Picarones). Sortie ALTO v4 / PAGE PRImA 2019-07-15 ; parsers tolérants aux versions antérieures en entrée. |
+| **L7** | **Déterminisme du writer** | (1) | Garantie = **idempotence de contenu** (`parse(write(x)) == x`), pas l'égalité octet vs un fichier d'origine quelconque. Sérialisation **C14N** (lxml), **aucun horodatage ni UUID** émis, ordre d'attributs figé, sérialisation **sans état global** (nsmap par élément). |
+| **L8** | **Pas de passthrough** : modèle **fermé** + `logger.warning` | (3) | Aucun scénario benchmark ne re-sérialise une entrée parsée → le passthrough n'a **aucun consommateur dans le scope**. La règle « rien en silence » est honorée par un `warning` sur élément structurel non modélisé. (Décision de *scope*, pas de difficulté : lxml le rendrait faisable, mais ce serait de la surface « au cas où ».) |
+| **L9** | **Pas de validation XSD** | — | Entrée tolérante (la GT réelle n'est pas strictement conforme) ; sortie conforme par construction + garantie par round-trip/égalité structurelle (C14N). Aucune dépendance XSD, **aucune mention** dans le repo. |
+| **L10** | **`CanonicalLayout` différé** | (3) | Le **nom** `ArtifactType.LAYOUT` est réservé en couche 1. La **forme** (sans standard externe, sans consommateur) serait spéculative → co-conçue avec la tranche segmentation. |
+| **L11** | **7 leviers de normalisation** | (2) | `unicode_form` (`none/NFC/NFD/NFKC/NFKD`, défaut NFC) · `caseless` · `whitespace` (`none/intra_line/flat`) · `strip_diacritics` · hygiène toujours active (control / zero-width / soft-hyphen / BOM) · `diplomatic_table` (mono-passe, cf. F12) · `exclude_chars` (+ `exclude_mode` `delete/space`). |
+| **L12** | **12 profils, anglais-neutres, défaut `nfc`** | (2) | `nfc`, `nfkc`, `caseless`, `minimal`, `no_diacritics`, `flat_text`, `keep_line_breaks`, `no_punctuation`, `no_apostrophes`, `medieval_french`, `early_modern_french`, `medieval_latin`. **Aucun profil privilégié par défaut.** Profils anglais (`*_english`, `secretary_hand`) **supprimés**. |
+| **L13** | **Dépendances dures** | (2) | `lxml`, `pyyaml`. Sécurité XML par **durcissement lxml natif** (pas de `defusedxml` : son support lxml est déprécié — décision A). À déclarer dans `pyproject.toml` + mettre à jour le test de whitelist d'architecture (`formats/` n'importe que `domain` + ces libs ; **jamais** `jiwer`/`rapidfuzz`/un moteur OCR). |
+| **L14** | **Erreurs rattachées au domaine** | (2) | Base `FormatError(CinocError)` dans `domain/errors.py` ; `AltoParseError(FormatError)` / `PageParseError(FormatError)` dans leurs modules. Permet `except FormatError` et `except CinocError`. |
+| **L15** | **API publique resserrée** | (2) | `safe_parse_xml` · `parse_alto`/`write_alto`/`AltoDocument`(+enfants)/`AltoParseError` · `parse_pagexml`/`write_pagexml`/`PageDocument`(+enfants)/`PageParseError` · `read_plaintext` · `NormalizationProfile`/`get_builtin_profile`/`NORMALIZATION_PROFILES`. Les internes restent privés. |
+
+---
+
+## 4. G-A — La décision porteuse : les types de format sont la cible **permanente** du parsing
+
+C'est le **(3)** central. On s'engage sur :
+
+> **Les types de format (`AltoDocument`/`PageDocument`) sont la cible *permanente* du
+> parsing et la *source de vérité structurelle*. Le modèle neutre (`CanonicalLayout`,
+> plus tard) est *toujours en aval*, atteint par un *adaptateur* — jamais une cible de
+> parsing directe.**
+
+Flux engagé :
+
+```
+écriture :  CanonicalLayout ─[adaptateur]→ AltoDocument/PageDocument ─[writer]→ bytes
+lecture  :  bytes ─[parser]→ AltoDocument/PageDocument ─┬─[projecteur]→ texte   (métriques texte)
+                                                         └─[adaptateur]→ CanonicalLayout (métriques structurelles)
+```
+
+**Pourquoi figer ça maintenant** : sans cet engagement, on risquerait un jour de « réécrire
+les parsers pour qu'ils émettent `CanonicalLayout` » → réécriture **transverse**. S'y engager
+ferme cette porte **et** justifie l'investissement riche d'aujourd'hui dans les types format
+(ils ne sont pas du jetable). Conséquence assumée : on maintiendra **deux** représentations
+structurelles riches (par-format + neutre) reliées par des adaptateurs — c'est le prix d'une
+E/S fidèle par format **plus** un intérieur neutre propre, sans bâtir le modèle neutre de façon
+spéculative.
+
+---
+
+## 5. Contrats transverses (G-B, G-C, G-D)
+
+**G-B — Le profil de normalisation voyage comme valeur autonome, jamais par son nom.**
+`(2)+(1)` (Picarones avait le bug du profil non propagé + un `Literal` de noms codé en dur).
+Le `NormalizationProfile` est un **objet-valeur autonome** (pydantic figé, `as_dict()`),
+**identifié et transmis par son contenu**, jamais par un nom de registre. Tout en aval
+(RunSpec couche 4, fingerprint couche 6, API couche 8) thread la **valeur**, valide
+**dynamiquement** contre le registre vivant, et **hashe le contenu** (pas le nom). `as_dict()`
+a une forme **déterministe** : clés de table **triées**, `exclude_chars` en **liste triée**,
+`unicode_form`/`whitespace`/`exclude_mode` comme chaînes d'énum. Pas de champ
+`schema_version` (le jeu de champs fait foi ; un levier ajouté plus tard change `as_dict` →
+invalide le cache, ce qui est correct).
+
+**G-C — Convention de projection texte (frontière projection↔normalisation).** `(2)`.
+Le levier `whitespace=intra_line` et le **CER inter-format** n'ont de sens que si la projection
+émet des frontières de ligne/bloc **cohérentes et identiques** entre ALTO et PAGE. Contrat :
+**un projecteur-vers-texte unique, `\n` entre lignes, `\n\n` entre blocs, à l'identique pour
+les deux formats**, consommant l'arbre d'ordre de lecture de la même façon. *(Implémentation
+en couche 3 ; la convention est fixée ici car transverse.)*
+
+**G-D — Base des types : pydantic v2 figé.** `(2)+(1)`. Tous les types format sont des modèles
+**pydantic v2 figés** (cohérent avec `domain`), **coût de validation assumé** sur les gros
+documents. On ne revisite ce choix que si un profilage le justifie (le changer serait
+transverse).
+
+---
+
+## 6. Risques de transfert Picarones → Cinoc
+
+**MIG-1 — Portage des corrections scientifiques (F-audits).** `(1)+(3)`. Chaque couche
+réécrite **inventorie et porte** ses corrections « F-x ». Pour la couche 2, deux seulement :
+- **F11** : la table diplomatique s'applique à **toutes** les occurrences, **des deux côtés**
+  (GT *et* OCR) → CER sur les classes d'équivalence (quotient), non biaisé. ⇒ **invariant de
+  symétrie** (le même profil est appliqué aux deux textes), **érigé en test**.
+- **F12** : substitution **mono-passe** (regex d'alternation, clé la plus longue d'abord)
+  contre les cascades. ⇒ conservé, avec un test du cas d'échange (`u→v` **et** `v→u`).
+
+**MIG-2 — Rupture nette, non rétro-compatible (à graver).** `(1)`. Cinoc change la
+normalisation (nouveaux leviers, ordre corrigé). **Même profil + même entrée → CER différent
+de Picarones.** Conséquence à acter : **Cinoc n'est pas numériquement compatible avec
+Picarones ; toute « validation » par égalité de chiffres avec Picarones est invalide par
+conception.** Cela protège la correction d'ordre (ci-dessous) contre une « remise en
+conformité » avec le comportement bogué d'origine.
+
+**MIG-3 — Dépouiller la narration, garder le raisonnement.** `(2)`. On supprime les étiquettes
+de sprint/audit (`Audit scientifique F12`, `Sprint A14-S9`, `reporté…`) **mais on conserve la
+justification** (p. ex. « mono-passe pour éviter les cascades »). Règle : *garder le pourquoi,
+jeter la datation.* Aucune mention d'« optionnel non fait » dans le repo.
+
+**MIG-4 — Placement.** La normalisation vit en **`formats/text` (couche 2)**, sans dépendances,
+consommée vers l'extérieur. Délibéré et correct.
+
+### Correction d'ordre de normalisation à porter (le bug D8)
+
+Picarones applique `casefold` **avant** la table mais **sans casefolder les clés**, ce qui fait
+qu'un profil `caseless` + table à clés minuscules **ne neutralise pas la casse** sur le texte
+majuscule (`"U"` survit au lieu de devenir la cible de `u→…`). Règle correcte à implémenter :
+
+> Sous `caseless`, **le casefold précède la table** **et** **les clés de table comme
+> l'ensemble `exclude_chars` sont casefoldés** pour la correspondance ; on **ré-applique
+> `unicode_form` après le casefold** (le casefold peut dé-normaliser).
+
+Ordre canonique de `normalize()` (à **verrouiller par un test**, pas par la prose) :
+`hygiène → unicode_form → casefold(si caseless, + folding des clés/exclude) → exclude_chars →
+diplomatic_table → strip_diacritics → whitespace`. Aucun profil builtin ne combine
+`caseless`+table, mais un profil **custom** le peut → piège silencieux, donc test obligatoire
+(`caseless + {u:v}` sur `"Uu"`).
+
+---
+
+## 7. Inventaire source → cible
+
+| Picarones (`formats/`) | → Cinoc (`formats/`) | Transformation principale |
+|---|---|---|
+| `_xml_utils.py` | `_xml.py` | Réécrit sur **lxml durci** (L2) ; **tous** les parsers passent par lui (Picarones les court-circuitait). |
+| `alto/types.py` | `alto/types.py` | **Enrichi** : polygone + baseline + confidence ; régions non-texte (`ComposedBlock` récursif, `Illustration`, `GraphicalElement`, marges) ; arbre d'ordre de lecture ; géométrie numérique ; contraintes rejetant du valide **supprimées** (cf. §8). |
+| `alto/parser.py` | `alto/parser.py` | lxml (xpath par nom local, `recover=True`+`warning`) ; passe par `safe_parse_xml` ; extraction de l'ordre de lecture + régions complètes. |
+| `alto/writer.py` | `alto/writer.py` | **Réécriture quasi-totale** : sérialise toute la structure riche, C14N, sans état global ni horodatage. |
+| `pagexml/types.py` | `pagexml/types.py` | **Enrichi** symétriquement ; régions non-texte + imbrication ; géométrie numérique ; baseline ; confidence ; **ligne seule** (pas de niveau mot/glyphe). |
+| `pagexml/parser.py` | `pagexml/parser.py` | lxml ; `TextEquiv` par `index` le plus bas (corrige le bug « premier `Unicode` descendant ») ; toutes les régions retenues. |
+| *(absent)* | `pagexml/writer.py` | **NOUVEAU** : `write_pagexml` symétrique. |
+| `text/normalization.py` | `text/normalization.py` | Profil **pydantic figé** ; 7 leviers (L11) ; ordre corrigé (§6) ; 12 profils (L12) ; `from_yaml`/`from_dict`/`model_copy` ; suppression des profils & tables anglais. |
+| *(absent)* | `text/plain.py` | **NOUVEAU** : `read_plaintext(bytes, encoding) → str` (décodage + BOM + fins de ligne). |
+| `formats/__init__.py` | `formats/__init__.py` | API publique **resserrée** (L15) ; docstring **vraie** (pas de « validator », lxml mentionné car réellement utilisé). |
+
+---
+
+## 8. Explicitement laissé au codage (sous test)
+
+Local, réversible, additif → **tranché en codant**, contre des **fixtures réelles**
+(Tesseract-ALTO, Transkribus/eScriptorium-PAGE, Kraken, Gallica). Orientations
+**non contraignantes** ci-dessous (point de départ, à valider par test) :
+
+- **Tolérances parser** : conserver les coordonnées **négatives** (pas de clip) ; **pas** de
+  caps de longueur arbitraires ; `SUBS_TYPE` libre (ne pas rejeter `Abbreviation`) ; honorer
+  les `<SP>` ALTO ; **ne pas** `.strip()` le texte au parsing ; `recover=True` **avec
+  `warning`** ; réfs d'ordre de lecture pendantes ignorées (+`warning`), régions orphelines
+  rattachées en fin ; `huge_tree=False` assumé (échec clair sur fichier pathologique).
+- **IDs** : génération **déterministe** pour les éléments sans `id`, **préfixe réservé** (ex.
+  `cinoc-gen-…`) anti-collision, **un seul passage** partagé parser/writer/fan-out (contrat
+  R6 : les `id` de région = ceux portés par `Artifact.region_id`).
+- **Sémantique fine des leviers** : classe d'espaces de `whitespace` (Unicode + insécables) ;
+  `strip_diacritics` = catégorie **`Mn`** ; `exclude_chars` = ensemble des caractères de la
+  chaîne, **sans séparateur magique**, un codepoint par item, normalisé selon `unicode_form`,
+  sérialisé en liste triée.
+- **Confidences** : valeur **brute** stockée (réconciliation d'échelle = couche 3) ; **niveau
+  mot/ligne** seulement (pas le par-caractère `CC`).
+- **Normalisation hors chemin entités** (F1) : le `NormalizationProfile` ne s'applique
+  **jamais** au niveau `ENTITIES` (offsets caractère) ni aux métriques MUFI/typographie (texte
+  brut). Contrat à respecter côté couche 3.
+- **`from_yaml`** : affordance **CLI/locale** uniquement ; le web n'accepte **jamais** un chemin
+  YAML arbitraire (lecture de fichier) — builtin ou profil inline validé.
+- **Encodage `.txt`** : défaut UTF-8 + gestion BOM + fins de ligne ; politique de secours à
+  fixer au codage.
+
+---
+
+## 9. Tests & budgets
+
+- **Round-trip** par **égalité structurelle via C14N** (et non par comparaison de compteurs,
+  comme Picarones) + **fixtures réelles** par outil (R13).
+- **Tests obligatoires** : sécurité (XXE / billion laughs / DOCTYPE), ordre de normalisation
+  (`caseless + {u:v}` sur `"Uu"`), échange `u/v` mono-passe (F12), symétrie GT/OCR (F11),
+  déterminisme writer (C14N stable).
+- **Budgets de fichiers** honnêtes : `types.py`/`parser.py`/`writer.py` riches dépasseront
+  400 LOC **par nature** ; découpage possible (`geometry.py`, `regions.py`). La règle est
+  « croissance assumée », pas « petits fichiers ».
+
+---
+
+## 10. DoD vivante (couche 2) — **autorité de détail** ; le `MIGRATION_PLAN.md` indexe
+
+> Tri-état : `[x]` fait **+ preuve** · `[ ]` à faire · `[~]` différé/réserve + raison.
+> Mise à jour dans le **même commit** que le code. **Statut couche 2 : ✅ vert** (2026-05-31).
+
+- [x] Parsers + writers **ALTO et PAGE** symétriques (writer PAGE = nouveau). — *preuve : `cinoc/formats/{alto,pagexml}/writer.py` ; `pytest tests/formats` vert*
+- [x] **Sécurité XML** durcie (`safe_parse_xml`) : XXE / billion-laughs / DOCTYPE échouent. — *preuve : `tests/formats/test_xml.py`*
+- [x] **Normalisation** : 7 leviers, 12 profils, ordre corrigé (bug D8). — *preuve : `tests/formats/text/test_normalization_edges.py` (cas `caseless + {u:v}` sur `"Uu"`)*
+- [x] `read_plaintext` (bytes → str, BOM, fins de ligne). — *preuve : `tests/formats/text/test_plain.py`*
+- [x] Round-trip par **égalité structurelle C14N** + fixtures réelles (Tesseract/Gallica/Transkribus/eScriptorium). — *preuve : `tests/formats/test_real_fixtures.py`*
+- [x] Whitelist d'archi `formats` = `domain` + stdlib + `lxml`/`yaml`/`pydantic` (jamais jiwer/moteur). — *preuve : `tests/architecture/test_layer_dependencies.py::test_formats_imports_are_allowed`*
+- [x] `mypy` + `ruff` verts ; import sans effet de bord. — *preuve : `mypy -p cinoc.formats` Success ; `test_no_side_effect_imports`*
+- [~] **Divergence plan↔build actée** : §9 prédisait `types/parser/writer` > 400 LOC « par nature ». Réalité : **max 373** (`normalization.py`). — *aucun split nécessaire ; `test_file_budgets` veille. Bon signe : les types riches tiennent sous le seuil. (cf. journal `MIGRATION_PLAN.md` — à ajouter si récurrent).*
+- [x] **T5** : `CanonicalLayout` (payload `LAYOUT`, en `domain`) + mappers **`alto_to_layout`** / **`layout_to_alto`** (`formats/alto/layout_map.py`, ALTO ↔ neutre, round-trip texte octet-stable) + **`page_to_layout`** (`formats/pagexml/layout_map.py`, PAGE → neutre : polygones, ordre de lecture aplati). — *preuves : `tests/formats/alto/test_alto_layout_map.py`, `tests/formats/pagexml/test_page_layout_map.py`* (l'assemblage en artefact `ALTO_XML` vit en couche 5, `AltoAssembler` : `pipeline` ne peut pas importer `formats`).
+- [~] **Différé-par-design** : assembleur `layout→PAGE`, lecteur `CANONICAL_DOCUMENT`, projecteur `layout→texte` (couche 3). — *épaississements T5 ultérieurs.*
diff --git a/cinoc/formats/__init__.py b/cinoc/formats/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3f9d658c254b375cf246e2fa83adef0d0006c552
--- /dev/null
+++ b/cinoc/formats/__init__.py
@@ -0,0 +1,71 @@
+"""Couche 2 — Formats documentaires.
+
+Frontière entre les formats de fil (ALTO XML, PAGE XML, texte brut) et le reste du
+système. N'opère que sur des ``bytes`` / des chaînes ; jamais sur un résultat
+d'OCR ou un calcul de métrique. Peut importer ``lxml`` et ``pyyaml`` ; jamais une
+lib de métrique (``jiwer``, ``rapidfuzz``) ni un moteur OCR.
+
+Surface publique :
+
+- sécurité XML (``safe_parse_xml``) — point d'entrée unique de tout parsing XML ;
+- format ALTO (``parse_alto`` / ``write_alto`` + types) ;
+- format PAGE (``parse_pagexml`` / ``write_pagexml`` + types) ;
+- normalisation de comparaison (``NormalizationProfile`` & profils) ;
+- lecture de texte brut (``read_plaintext``).
+"""
+
+from __future__ import annotations
+
+from cinoc.formats._xml import safe_parse_xml
+from cinoc.formats.alto import (
+    AltoBBox,
+    AltoDocument,
+    AltoLine,
+    AltoPage,
+    AltoParseError,
+    AltoString,
+    AltoTextBlock,
+    parse_alto,
+    write_alto,
+)
+from cinoc.formats.pagexml import (
+    PageDocument,
+    PagePage,
+    PageParseError,
+    PageTextLine,
+    PageTextRegion,
+    parse_pagexml,
+    write_pagexml,
+)
+from cinoc.formats.text import (
+    DEFAULT_PROFILE,
+    NORMALIZATION_PROFILES,
+    NormalizationProfile,
+    get_builtin_profile,
+    read_plaintext,
+)
+
+__all__ = [
+    "safe_parse_xml",
+    "parse_alto",
+    "write_alto",
+    "AltoDocument",
+    "AltoPage",
+    "AltoTextBlock",
+    "AltoLine",
+    "AltoString",
+    "AltoBBox",
+    "AltoParseError",
+    "parse_pagexml",
+    "write_pagexml",
+    "PageDocument",
+    "PagePage",
+    "PageTextRegion",
+    "PageTextLine",
+    "PageParseError",
+    "NormalizationProfile",
+    "NORMALIZATION_PROFILES",
+    "DEFAULT_PROFILE",
+    "get_builtin_profile",
+    "read_plaintext",
+]
diff --git a/cinoc/formats/_geometry.py b/cinoc/formats/_geometry.py
new file mode 100644
index 0000000000000000000000000000000000000000..34e2b3d7dba1932cbadce6d9f8283917fe4485be
--- /dev/null
+++ b/cinoc/formats/_geometry.py
@@ -0,0 +1,32 @@
+"""Primitives géométriques partagées par les formats (points numériques).
+
+Les coordonnées sont des entiers en pixels (convention ALTO et PAGE). On conserve
+les valeurs négatives (une région peut déborder la page) ; la réconciliation
+d'unités/résolution est une affaire de couche 3.
+"""
+
+from __future__ import annotations
+
+Point = tuple[int, int]
+
+
+def parse_points(raw: str) -> tuple[Point, ...]:
+    """Parse une chaîne ``"x1,y1 x2,y2 ..."`` en points entiers.
+
+    Lève ``ValueError`` si un jeton est malformé ; le caller décide d'ignorer
+    la géométrie (avec un avertissement) plutôt que de planter.
+    """
+    points: list[Point] = []
+    for token in raw.split():
+        x_str, _, y_str = token.partition(",")
+        if not _ or not x_str or not y_str:
+            raise ValueError(f"point malformé : {token!r}")
+        points.append((int(float(x_str)), int(float(y_str))))
+    if not points:
+        raise ValueError("aucun point")
+    return tuple(points)
+
+
+def format_points(points: tuple[Point, ...]) -> str:
+    """Sérialise des points en ``"x1,y1 x2,y2 ..."`` (déterministe)."""
+    return " ".join(f"{x},{y}" for x, y in points)
diff --git a/cinoc/formats/_xml.py b/cinoc/formats/_xml.py
new file mode 100644
index 0000000000000000000000000000000000000000..aef4cf33c63233b4fa0bff213a813f93b808f6a7
--- /dev/null
+++ b/cinoc/formats/_xml.py
@@ -0,0 +1,43 @@
+"""Parsing XML sécurisé — entonnoir unique de la couche formats.
+
+Tout XML entrant (ALTO, PAGE, manifeste…) passe par ``safe_parse_xml``. Le parseur
+lxml est durci contre :
+
+- **XXE** (entités externes) et **billion laughs** : ``resolve_entities=False`` —
+  les entités ne sont jamais expansées ;
+- **récupération de DTD distante** : ``no_network=True`` + ``load_dtd=False`` ;
+- toute **DTD / DOCTYPE** : rejet explicite (équivalent ``forbid_dtd``).
+
+Retourne ``None`` si le contenu n'est pas un XML bien formé, contient un DOCTYPE,
+ou déclenche une protection. Le caller (parser ALTO/PAGE) lève alors son erreur.
+
+Un parseur **neuf est créé à chaque appel** : les instances ``XMLParser`` de lxml
+ne sont pas sûres en usage concurrent (le runner est multi-thread).
+"""
+
+from __future__ import annotations
+
+from lxml import etree
+
+__all__ = ["safe_parse_xml"]
+
+
+def safe_parse_xml(data: bytes) -> etree._Element | None:
+    """Parse des octets XML de façon sécurisée, ou retourne ``None``."""
+    parser = etree.XMLParser(
+        resolve_entities=False,
+        no_network=True,
+        load_dtd=False,
+        dtd_validation=False,
+        huge_tree=False,
+    )
+    try:
+        root = etree.fromstring(data, parser=parser)
+    except etree.XMLSyntaxError:
+        return None
+    if root is None:
+        return None
+    doctype = root.getroottree().docinfo.doctype  # type: ignore[union-attr]
+    if doctype:
+        return None  # DTD / DOCTYPE interdit
+    return root
diff --git a/cinoc/formats/alto/__init__.py b/cinoc/formats/alto/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0a71479b2de4be80f7522cd2e92fccc02b6e66f4
--- /dev/null
+++ b/cinoc/formats/alto/__init__.py
@@ -0,0 +1,35 @@
+"""Format ALTO XML (v2/v3/v4) : types, parser tolérant, writer déterministe."""
+
+from __future__ import annotations
+
+from cinoc.formats.alto.parser import AltoParseError, parse_alto
+from cinoc.formats.alto.types import (
+    AltoBBox,
+    AltoBlock,
+    AltoComposedBlock,
+    AltoDocument,
+    AltoGraphicalElement,
+    AltoIllustration,
+    AltoLine,
+    AltoPage,
+    AltoString,
+    AltoTextBlock,
+)
+from cinoc.formats.alto.writer import AltoWriteError, write_alto
+
+__all__ = [
+    "AltoBBox",
+    "AltoString",
+    "AltoLine",
+    "AltoTextBlock",
+    "AltoComposedBlock",
+    "AltoIllustration",
+    "AltoGraphicalElement",
+    "AltoBlock",
+    "AltoPage",
+    "AltoDocument",
+    "parse_alto",
+    "AltoParseError",
+    "write_alto",
+    "AltoWriteError",
+]
diff --git a/cinoc/formats/alto/layout_map.py b/cinoc/formats/alto/layout_map.py
new file mode 100644
index 0000000000000000000000000000000000000000..86cccf3b39f58f0625fda43e51fce2bc38dbd735
--- /dev/null
+++ b/cinoc/formats/alto/layout_map.py
@@ -0,0 +1,225 @@
+"""Mapper ``AltoDocument → CanonicalLayout`` — pont format ALTO ↔ modèle neutre.
+
+Première moitié du pont de la tranche segmentation (l'assembleur inverse
+``layout → ALTO`` est un épaississement ultérieur). Le parsing reste en amont
+(``parse_alto`` ; couche 2) ; ici on **projette** la structure ALTO vers le
+vocabulaire neutre ``CanonicalLayout`` (couche 1) que consomment les métriques
+de structure.
+
+Choix de tranche (largeur minimale) : le texte de ligne est la **jointure simple**
+des ``<String>`` (la dé-césure ``HypPart1/HypPart2`` est une affaire de projection
+``layout → texte``, différée). Les ``id`` de région absents sont **synthétisés**
+de façon déterministe (``region_<n>`` en ordre document) pour rester uniques et
+appariables.
+"""
+
+from __future__ import annotations
+
+from cinoc.domain.layout import (
+    BBox,
+    CanonicalLayout,
+    Geometry,
+    LayoutPage,
+    Line,
+    Region,
+    Word,
+)
+from cinoc.formats._geometry import Point
+from cinoc.formats.alto.types import (
+    AltoBBox,
+    AltoBlock,
+    AltoComposedBlock,
+    AltoDocument,
+    AltoGraphicalElement,
+    AltoIllustration,
+    AltoLine,
+    AltoPage,
+    AltoString,
+    AltoTextBlock,
+)
+
+_NON_TEXT_TYPES = frozenset({"illustration", "graphical"})
+
+
+class _Counter:
+    """Compteur déterministe pour synthétiser les ``id`` de région manquants."""
+
+    def __init__(self) -> None:
+        self._n = 0
+
+    def next_id(self) -> str:
+        rid = f"region_{self._n}"
+        self._n += 1
+        return rid
+
+
+def _geometry(
+    bbox: AltoBBox | None, polygon: tuple[Point, ...] | None
+) -> Geometry | None:
+    if bbox is None and not polygon:
+        return None
+    neutral = (
+        BBox(x=bbox.hpos, y=bbox.vpos, width=bbox.width, height=bbox.height)
+        if bbox is not None
+        else None
+    )
+    return Geometry(bbox=neutral, polygon=tuple(polygon or ()))
+
+
+def _word(string: AltoString) -> Word:
+    return Word(
+        text=string.content,
+        geometry=_geometry(string.bbox, None),
+        confidence=string.confidence,
+    )
+
+
+def _line(line: AltoLine) -> Line:
+    words = tuple(_word(s) for s in line.strings)
+    return Line(
+        id=line.id,
+        text=" ".join(w.text for w in words),
+        geometry=_geometry(line.bbox, line.polygon),
+        baseline=tuple(line.baseline or ()),
+        words=words,
+    )
+
+
+def _region(block: AltoBlock, counter: _Counter) -> Region:
+    rid = block.id or counter.next_id()
+    if isinstance(block, AltoTextBlock):
+        return Region(
+            id=rid,
+            region_type=block.block_type or "text",
+            geometry=_geometry(block.bbox, block.polygon),
+            lines=tuple(_line(line) for line in block.lines),
+        )
+    if isinstance(block, AltoComposedBlock):
+        return Region(
+            id=rid,
+            region_type=block.block_type or "composed",
+            geometry=_geometry(block.bbox, block.polygon),
+            regions=tuple(_region(child, counter) for child in block.blocks),
+        )
+    if isinstance(block, AltoIllustration):
+        return Region(
+            id=rid,
+            region_type=block.block_type or "illustration",
+            geometry=_geometry(block.bbox, block.polygon),
+        )
+    if isinstance(block, AltoGraphicalElement):
+        return Region(
+            id=rid,
+            region_type="graphical",
+            geometry=_geometry(block.bbox, block.polygon),
+        )
+    # Union fermée (discriminée par ``kind``) : aucune autre branche possible.
+    raise AssertionError(f"bloc ALTO non géré : {block!r}")  # pragma: no cover
+
+
+def _page(page: AltoPage, counter: _Counter) -> LayoutPage:
+    regions = tuple(_region(block, counter) for block in page.blocks)
+    return LayoutPage(
+        width=page.width,
+        height=page.height,
+        regions=regions,
+        reading_order=tuple(region.id for region in regions),
+    )
+
+
+def alto_to_layout(document: AltoDocument) -> CanonicalLayout:
+    """Projette un ``AltoDocument`` parsé vers le ``CanonicalLayout`` neutre."""
+    counter = _Counter()
+    return CanonicalLayout(
+        pages=tuple(_page(page, counter) for page in document.pages)
+    )
+
+
+# --- assemblage inverse : CanonicalLayout → AltoDocument --------------------
+
+
+def _alto_bbox(geometry: Geometry | None) -> AltoBBox | None:
+    if geometry is None or geometry.bbox is None:
+        return None
+    b = geometry.bbox
+    return AltoBBox(hpos=b.x, vpos=b.y, width=b.width, height=b.height)
+
+
+def _alto_polygon(geometry: Geometry | None) -> tuple[Point, ...] | None:
+    if geometry is None or not geometry.polygon:
+        return None
+    return geometry.polygon
+
+
+def _alto_strings(line: Line) -> tuple[AltoString, ...]:
+    """Mots → ``<String>``. Sans mots, le texte est segmenté sur les blancs."""
+    if line.words:
+        return tuple(
+            AltoString(
+                content=word.text,
+                bbox=_alto_bbox(word.geometry),
+                confidence=word.confidence,
+            )
+            for word in line.words
+        )
+    return tuple(AltoString(content=token) for token in line.text.split())
+
+
+def _alto_line(line: Line) -> AltoLine:
+    return AltoLine(
+        id=line.id,
+        bbox=_alto_bbox(line.geometry),
+        polygon=_alto_polygon(line.geometry),
+        baseline=tuple(line.baseline) or None,
+        strings=_alto_strings(line),
+    )
+
+
+def _alto_block(region: Region) -> AltoBlock:
+    bbox = _alto_bbox(region.geometry)
+    polygon = _alto_polygon(region.geometry)
+    if region.regions:
+        return AltoComposedBlock(
+            id=region.id,
+            block_type=region.region_type,
+            bbox=bbox,
+            polygon=polygon,
+            blocks=tuple(_alto_block(child) for child in region.regions),
+        )
+    if region.region_type in _NON_TEXT_TYPES and not region.lines:
+        return AltoIllustration(
+            id=region.id, block_type=region.region_type, bbox=bbox, polygon=polygon
+        )
+    return AltoTextBlock(
+        id=region.id,
+        block_type=region.region_type,
+        bbox=bbox,
+        polygon=polygon,
+        lines=tuple(_alto_line(line) for line in region.lines),
+    )
+
+
+def _ordered_regions(page: LayoutPage) -> tuple[Region, ...]:
+    """Régions dans l'ordre de lecture (sinon ordre des régions)."""
+    if not page.reading_order:
+        return page.regions
+    by_id = {region.id: region for region in page.regions}
+    ordered = [by_id[rid] for rid in page.reading_order if rid in by_id]
+    ordered.extend(r for r in page.regions if r.id not in set(page.reading_order))
+    return tuple(ordered)
+
+
+def _alto_page(page: LayoutPage) -> AltoPage:
+    return AltoPage(
+        width=page.width,
+        height=page.height,
+        blocks=tuple(_alto_block(region) for region in _ordered_regions(page)),
+    )
+
+
+def layout_to_alto(layout: CanonicalLayout) -> AltoDocument:
+    """Assemble un ``CanonicalLayout`` (rempli) en ``AltoDocument`` sérialisable."""
+    return AltoDocument(pages=tuple(_alto_page(page) for page in layout.pages))
+
+
+__all__ = ["alto_to_layout", "layout_to_alto"]
diff --git a/cinoc/formats/alto/parser.py b/cinoc/formats/alto/parser.py
new file mode 100644
index 0000000000000000000000000000000000000000..edce0552564df46132aff5d6b7ec3638dfa068b4
--- /dev/null
+++ b/cinoc/formats/alto/parser.py
@@ -0,0 +1,214 @@
+"""Parser ALTO tolérant (v2/v3/v4), via l'entonnoir ``safe_parse_xml``.
+
+Extrait toute la structure mesurable : régions de tout type (TextBlock,
+ComposedBlock récursif, Illustration, GraphicalElement), géométrie numérique
+(bbox + polygone + baseline), confidence de mot. Les éléments non modélisés
+(contenu de marge…) sont signalés par un ``warning``, jamais perdus en silence.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from lxml import etree
+
+from cinoc.domain.errors import FormatError
+from cinoc.formats._geometry import Point, parse_points
+from cinoc.formats._xml import safe_parse_xml
+from cinoc.formats.alto.types import (
+    AltoBBox,
+    AltoBlock,
+    AltoComposedBlock,
+    AltoDocument,
+    AltoGraphicalElement,
+    AltoIllustration,
+    AltoLine,
+    AltoPage,
+    AltoString,
+    AltoTextBlock,
+)
+
+logger = logging.getLogger(__name__)
+
+_MARGINS = {"TopMargin", "LeftMargin", "RightMargin", "BottomMargin"}
+_BLOCK_NAMES = {"TextBlock", "ComposedBlock", "Illustration", "GraphicalElement"}
+
+
+class AltoParseError(FormatError):
+    """ALTO illisible (XML invalide, vide, DOCTYPE interdit, ou sans page)."""
+
+
+def _lname(el: etree._Element) -> str:
+    return etree.QName(el).localname if isinstance(el.tag, str) else ""
+
+
+def _detect_version(tag: str) -> str | None:
+    namespace = etree.QName(tag).namespace
+    if namespace is None:
+        return "none"
+    for marker in ("ns-v2", "ns-v3", "ns-v4"):
+        if marker in namespace:
+            return marker.replace("ns-", "")
+    return None
+
+
+def _int_attr(el: etree._Element, name: str) -> int | None:
+    raw = el.get(name)
+    if raw is None:
+        return None
+    try:
+        return int(float(raw))
+    except ValueError:
+        return None
+
+
+def _bbox(el: etree._Element) -> AltoBBox | None:
+    hpos = _int_attr(el, "HPOS")
+    vpos = _int_attr(el, "VPOS")
+    width = _int_attr(el, "WIDTH")
+    height = _int_attr(el, "HEIGHT")
+    if hpos is None or vpos is None or width is None or height is None:
+        return None
+    return AltoBBox(hpos=hpos, vpos=vpos, width=width, height=height)
+
+
+def _points_attr(el: etree._Element, name: str) -> tuple[Point, ...] | None:
+    raw = el.get(name)
+    if raw is None:
+        return None
+    try:
+        return parse_points(raw)
+    except ValueError:
+        logger.warning("[alto] %s illisible, géométrie ignorée : %r", name, raw)
+        return None
+
+
+def _polygon(el: etree._Element) -> tuple[Point, ...] | None:
+    for shape in el:
+        if _lname(shape) == "Shape":
+            for poly in shape:
+                if _lname(poly) == "Polygon":
+                    return _points_attr(poly, "POINTS")
+    return None
+
+
+def _parse_string(el: etree._Element) -> AltoString:
+    confidence: float | None = None
+    wc = el.get("WC")
+    if wc is not None:
+        try:
+            confidence = float(wc)
+        except ValueError:
+            confidence = None
+    return AltoString(
+        content=el.get("CONTENT", ""),
+        id=el.get("ID"),
+        bbox=_bbox(el),
+        confidence=confidence,
+        subs_type=el.get("SUBS_TYPE"),
+        subs_content=el.get("SUBS_CONTENT"),
+    )
+
+
+def _parse_line(el: etree._Element) -> AltoLine:
+    strings = tuple(_parse_string(c) for c in el if _lname(c) == "String")
+    return AltoLine(
+        id=el.get("ID"),
+        bbox=_bbox(el),
+        polygon=_polygon(el),
+        baseline=_points_attr(el, "BASELINE"),
+        strings=strings,
+    )
+
+
+def _parse_text_block(el: etree._Element) -> AltoTextBlock:
+    lines = tuple(_parse_line(c) for c in el if _lname(c) == "TextLine")
+    return AltoTextBlock(
+        id=el.get("ID"),
+        block_type=el.get("TYPE"),
+        bbox=_bbox(el),
+        polygon=_polygon(el),
+        lines=lines,
+    )
+
+
+def _parse_composed(el: etree._Element) -> AltoComposedBlock:
+    return AltoComposedBlock(
+        id=el.get("ID"),
+        block_type=el.get("TYPE"),
+        bbox=_bbox(el),
+        polygon=_polygon(el),
+        blocks=_parse_blocks(el),
+    )
+
+
+def _parse_blocks(parent: etree._Element) -> tuple[AltoBlock, ...]:
+    out: list[AltoBlock] = []
+    for child in parent:
+        name = _lname(child)
+        if name == "TextBlock":
+            out.append(_parse_text_block(child))
+        elif name == "ComposedBlock":
+            out.append(_parse_composed(child))
+        elif name == "Illustration":
+            out.append(
+                AltoIllustration(
+                    id=child.get("ID"),
+                    block_type=child.get("TYPE"),
+                    bbox=_bbox(child),
+                    polygon=_polygon(child),
+                )
+            )
+        elif name == "GraphicalElement":
+            out.append(
+                AltoGraphicalElement(
+                    id=child.get("ID"),
+                    bbox=_bbox(child),
+                    polygon=_polygon(child),
+                )
+            )
+    return tuple(out)
+
+
+def _parse_page(el: etree._Element) -> AltoPage:
+    print_space: etree._Element | None = None
+    for child in el:
+        name = _lname(child)
+        if name == "PrintSpace":
+            print_space = child
+        elif name in _MARGINS and any(_lname(g) in _BLOCK_NAMES for g in child):
+            logger.warning("[alto] contenu de %s non modélisé (ignoré)", name)
+    container = print_space if print_space is not None else el
+    return AltoPage(
+        id=el.get("ID"),
+        width=_int_attr(el, "WIDTH"),
+        height=_int_attr(el, "HEIGHT"),
+        blocks=_parse_blocks(container),
+    )
+
+
+def parse_alto(data: bytes) -> AltoDocument:
+    """Parse des octets ALTO en ``AltoDocument`` (lève ``AltoParseError``)."""
+    root = safe_parse_xml(data)
+    if root is None:
+        raise AltoParseError("ALTO illisible (XML invalide, vide ou DOCTYPE interdit).")
+
+    version = _detect_version(root.tag) if isinstance(root.tag, str) else None
+
+    measurement_unit: str | None = None
+    for el in root.iter():
+        if isinstance(el.tag, str) and _lname(el) == "MeasurementUnit":
+            measurement_unit = (el.text or "").strip() or None
+            break
+
+    pages = tuple(
+        _parse_page(el)
+        for el in root.iter()
+        if isinstance(el.tag, str) and _lname(el) == "Page"
+    )
+    return AltoDocument(
+        pages=pages, source_version=version, measurement_unit=measurement_unit
+    )
+
+
+__all__ = ["parse_alto", "AltoParseError"]
diff --git a/cinoc/formats/alto/types.py b/cinoc/formats/alto/types.py
new file mode 100644
index 0000000000000000000000000000000000000000..694f14ecfbdf091f5c501961a522ce5320bb4da0
--- /dev/null
+++ b/cinoc/formats/alto/types.py
@@ -0,0 +1,141 @@
+"""Modèle de types ALTO — représentation interne, source de vérité structurelle.
+
+Géométrie **numérique native** : ``bbox`` (HPOS/VPOS/WIDTH/HEIGHT), ``polygon``
+(Shape/Polygon) et ``baseline`` (BASELINE). Régions de tout type : ``TextBlock``,
+``ComposedBlock`` (récursif), ``Illustration``, ``GraphicalElement``. Confidence de
+mot (``WC``) conservée. Ordre de lecture = ordre des blocs (document).
+
+Modèles pydantic figés : ces types sont la cible **permanente** du parsing ; le
+modèle neutre ``CanonicalLayout`` (plus tard) est en aval via adaptateur.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from cinoc.formats._geometry import Point
+
+_FROZEN = ConfigDict(frozen=True, extra="forbid")
+
+
+class AltoBBox(BaseModel):
+    """Boîte englobante ALTO (pixels ; valeurs négatives conservées)."""
+
+    model_config = _FROZEN
+    hpos: int
+    vpos: int
+    width: int
+    height: int
+
+
+class AltoString(BaseModel):
+    """Mot ALTO (``<String>``)."""
+
+    model_config = _FROZEN
+    content: str
+    id: str | None = None
+    bbox: AltoBBox | None = None
+    confidence: float | None = None  # attribut WC
+    subs_type: str | None = None  # césure : HypPart1/HypPart2, Abbreviation…
+    subs_content: str | None = None
+
+
+class AltoLine(BaseModel):
+    """Ligne ALTO (``<TextLine>``)."""
+
+    model_config = _FROZEN
+    id: str | None = None
+    bbox: AltoBBox | None = None
+    polygon: tuple[Point, ...] | None = None
+    baseline: tuple[Point, ...] | None = None
+    strings: tuple[AltoString, ...] = ()
+
+
+class AltoTextBlock(BaseModel):
+    """Bloc de texte ALTO (``<TextBlock>``)."""
+
+    model_config = _FROZEN
+    kind: Literal["text"] = "text"
+    id: str | None = None
+    block_type: str | None = None  # attribut TYPE
+    bbox: AltoBBox | None = None
+    polygon: tuple[Point, ...] | None = None
+    lines: tuple[AltoLine, ...] = ()
+
+
+class AltoIllustration(BaseModel):
+    """Illustration ALTO (``<Illustration>``) — géométrie seule."""
+
+    model_config = _FROZEN
+    kind: Literal["illustration"] = "illustration"
+    id: str | None = None
+    block_type: str | None = None
+    bbox: AltoBBox | None = None
+    polygon: tuple[Point, ...] | None = None
+
+
+class AltoGraphicalElement(BaseModel):
+    """Élément graphique ALTO (``<GraphicalElement>``) — géométrie seule."""
+
+    model_config = _FROZEN
+    kind: Literal["graphical"] = "graphical"
+    id: str | None = None
+    bbox: AltoBBox | None = None
+    polygon: tuple[Point, ...] | None = None
+
+
+class AltoComposedBlock(BaseModel):
+    """Bloc composé ALTO (``<ComposedBlock>``) — conteneur récursif de blocs."""
+
+    model_config = _FROZEN
+    kind: Literal["composed"] = "composed"
+    id: str | None = None
+    block_type: str | None = None
+    bbox: AltoBBox | None = None
+    polygon: tuple[Point, ...] | None = None
+    blocks: tuple[AltoBlock, ...] = ()
+
+
+#: Union discriminée des blocs (le champ ``kind`` choisit le type).
+AltoBlock = Annotated[
+    AltoTextBlock | AltoComposedBlock | AltoIllustration | AltoGraphicalElement,
+    Field(discriminator="kind"),
+]
+
+
+class AltoPage(BaseModel):
+    """Page ALTO (``<Page>`` ; ``blocks`` = contenu du ``PrintSpace``)."""
+
+    model_config = _FROZEN
+    id: str | None = None
+    width: int | None = None
+    height: int | None = None
+    blocks: tuple[AltoBlock, ...] = ()
+
+
+class AltoDocument(BaseModel):
+    """Document ALTO complet."""
+
+    model_config = _FROZEN
+    pages: tuple[AltoPage, ...] = ()
+    source_version: str | None = None  # "v2"/"v3"/"v4"/"none"
+    measurement_unit: str | None = None  # pixel / mm10 / inch1200…
+
+
+AltoComposedBlock.model_rebuild()
+AltoPage.model_rebuild()
+
+__all__ = [
+    "AltoBBox",
+    "AltoString",
+    "AltoLine",
+    "AltoTextBlock",
+    "AltoComposedBlock",
+    "AltoIllustration",
+    "AltoGraphicalElement",
+    "AltoBlock",
+    "AltoPage",
+    "AltoDocument",
+]
diff --git a/cinoc/formats/alto/writer.py b/cinoc/formats/alto/writer.py
new file mode 100644
index 0000000000000000000000000000000000000000..287d2b32f9e9760e8e723b80a1f0b3daf68732c0
--- /dev/null
+++ b/cinoc/formats/alto/writer.py
@@ -0,0 +1,159 @@
+"""Writer ALTO déterministe (lxml + canonicalisation C14N).
+
+Sérialise un ``AltoDocument`` (construit par nous) en octets ALTO. Le C14N2 fixe
+l'ordre des attributs et la forme des namespaces → sortie **déterministe** (cache
+d'artefacts, round-trip). Aucun horodatage ni identifiant fabriqué n'est émis ;
+construction sans état global (namespaces par élément) → thread-safe.
+
+Garantie : ``parse_alto(write_alto(doc)) == doc`` pour un document dans la version
+cible (``source_version`` reflète alors la version écrite).
+"""
+
+from __future__ import annotations
+
+from lxml import etree
+
+from cinoc.domain.errors import FormatError
+from cinoc.formats._geometry import format_points
+from cinoc.formats.alto.types import (
+    AltoBBox,
+    AltoBlock,
+    AltoComposedBlock,
+    AltoDocument,
+    AltoIllustration,
+    AltoLine,
+    AltoPage,
+    AltoString,
+    AltoTextBlock,
+)
+
+_NS = {
+    "v2": "http://www.loc.gov/standards/alto/ns-v2#",
+    "v3": "http://www.loc.gov/standards/alto/ns-v3#",
+    "v4": "http://www.loc.gov/standards/alto/ns-v4#",
+}
+
+
+class AltoWriteError(FormatError):
+    """Version ALTO cible invalide."""
+
+
+def _q(ns: str | None, local: str) -> str:
+    return f"{{{ns}}}{local}" if ns else local
+
+
+def _set_bbox(el: etree._Element, bbox: AltoBBox | None) -> None:
+    if bbox is None:
+        return
+    el.set("HPOS", str(bbox.hpos))
+    el.set("VPOS", str(bbox.vpos))
+    el.set("WIDTH", str(bbox.width))
+    el.set("HEIGHT", str(bbox.height))
+
+
+def _write_polygon(
+    parent: etree._Element, ns: str | None, polygon: tuple[tuple[int, int], ...] | None
+) -> None:
+    if polygon is None:
+        return
+    shape = etree.SubElement(parent, _q(ns, "Shape"))
+    poly = etree.SubElement(shape, _q(ns, "Polygon"))
+    poly.set("POINTS", format_points(polygon))
+
+
+def _write_string(parent: etree._Element, ns: str | None, s: AltoString) -> None:
+    el = etree.SubElement(parent, _q(ns, "String"))
+    el.set("CONTENT", s.content)
+    if s.id is not None:
+        el.set("ID", s.id)
+    if s.confidence is not None:
+        el.set("WC", str(s.confidence))
+    _set_bbox(el, s.bbox)
+    if s.subs_type is not None:
+        el.set("SUBS_TYPE", s.subs_type)
+    if s.subs_content is not None:
+        el.set("SUBS_CONTENT", s.subs_content)
+
+
+def _write_line(parent: etree._Element, ns: str | None, line: AltoLine) -> None:
+    el = etree.SubElement(parent, _q(ns, "TextLine"))
+    if line.id is not None:
+        el.set("ID", line.id)
+    if line.baseline is not None:
+        el.set("BASELINE", format_points(line.baseline))
+    _set_bbox(el, line.bbox)
+    _write_polygon(el, ns, line.polygon)
+    for s in line.strings:
+        _write_string(el, ns, s)
+
+
+def _write_block(parent: etree._Element, ns: str | None, block: AltoBlock) -> None:
+    if isinstance(block, AltoTextBlock):
+        el = etree.SubElement(parent, _q(ns, "TextBlock"))
+        if block.id is not None:
+            el.set("ID", block.id)
+        if block.block_type is not None:
+            el.set("TYPE", block.block_type)
+        _set_bbox(el, block.bbox)
+        _write_polygon(el, ns, block.polygon)
+        for line in block.lines:
+            _write_line(el, ns, line)
+    elif isinstance(block, AltoComposedBlock):
+        el = etree.SubElement(parent, _q(ns, "ComposedBlock"))
+        if block.id is not None:
+            el.set("ID", block.id)
+        if block.block_type is not None:
+            el.set("TYPE", block.block_type)
+        _set_bbox(el, block.bbox)
+        _write_polygon(el, ns, block.polygon)
+        for child in block.blocks:
+            _write_block(el, ns, child)
+    elif isinstance(block, AltoIllustration):
+        el = etree.SubElement(parent, _q(ns, "Illustration"))
+        if block.id is not None:
+            el.set("ID", block.id)
+        if block.block_type is not None:
+            el.set("TYPE", block.block_type)
+        _set_bbox(el, block.bbox)
+        _write_polygon(el, ns, block.polygon)
+    else:  # AltoGraphicalElement
+        el = etree.SubElement(parent, _q(ns, "GraphicalElement"))
+        if block.id is not None:
+            el.set("ID", block.id)
+        _set_bbox(el, block.bbox)
+        _write_polygon(el, ns, block.polygon)
+
+
+def _write_page(layout: etree._Element, ns: str | None, page: AltoPage) -> None:
+    el = etree.SubElement(layout, _q(ns, "Page"))
+    if page.id is not None:
+        el.set("ID", page.id)
+    if page.width is not None:
+        el.set("WIDTH", str(page.width))
+    if page.height is not None:
+        el.set("HEIGHT", str(page.height))
+    print_space = etree.SubElement(el, _q(ns, "PrintSpace"))
+    for block in page.blocks:
+        _write_block(print_space, ns, block)
+
+
+def write_alto(document: AltoDocument, *, version: str = "v4") -> bytes:
+    """Sérialise un ``AltoDocument`` en octets ALTO canoniques (C14N2)."""
+    if version != "none" and version not in _NS:
+        raise AltoWriteError(
+            f"version ALTO invalide : {version!r} (attendu v2/v3/v4/none)."
+        )
+    ns = _NS.get(version)
+    nsmap = {None: ns} if ns else None
+    root = etree.Element(_q(ns, "alto"), nsmap=nsmap)  # type: ignore[arg-type]
+    if document.measurement_unit is not None:
+        description = etree.SubElement(root, _q(ns, "Description"))
+        unit = etree.SubElement(description, _q(ns, "MeasurementUnit"))
+        unit.text = document.measurement_unit
+    layout = etree.SubElement(root, _q(ns, "Layout"))
+    for page in document.pages:
+        _write_page(layout, ns, page)
+    return etree.tostring(root, method="c14n2")
+
+
+__all__ = ["write_alto", "AltoWriteError"]
diff --git a/cinoc/formats/pagexml/__init__.py b/cinoc/formats/pagexml/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f79999ae40a5bbef04fde2d20a510f477083e118
--- /dev/null
+++ b/cinoc/formats/pagexml/__init__.py
@@ -0,0 +1,38 @@
+"""Format PAGE XML (PRImA) : types, parser tolérant, writer déterministe."""
+
+from __future__ import annotations
+
+from cinoc.formats.pagexml.parser import PageParseError, parse_pagexml
+from cinoc.formats.pagexml.types import (
+    PageDocument,
+    PageGenericRegion,
+    PagePage,
+    PageRegion,
+    PageTextLine,
+    PageTextRegion,
+    ReadingOrderGroup,
+    ReadingOrderNode,
+    ReadingOrderRef,
+)
+from cinoc.formats.pagexml.writer import (
+    DEFAULT_PAGE_NS,
+    PageWriteError,
+    write_pagexml,
+)
+
+__all__ = [
+    "ReadingOrderRef",
+    "ReadingOrderGroup",
+    "ReadingOrderNode",
+    "PageTextLine",
+    "PageTextRegion",
+    "PageGenericRegion",
+    "PageRegion",
+    "PagePage",
+    "PageDocument",
+    "parse_pagexml",
+    "PageParseError",
+    "write_pagexml",
+    "PageWriteError",
+    "DEFAULT_PAGE_NS",
+]
diff --git a/cinoc/formats/pagexml/layout_map.py b/cinoc/formats/pagexml/layout_map.py
new file mode 100644
index 0000000000000000000000000000000000000000..dd3d61db199614c9432db0ccda4627b345ac1ec8
--- /dev/null
+++ b/cinoc/formats/pagexml/layout_map.py
@@ -0,0 +1,106 @@
+"""Mapper ``PageDocument → CanonicalLayout`` — pont format PAGE ↔ modèle neutre.
+
+Pendant de ``alto_to_layout`` pour PAGE XML (PRImA). Différences de convention
+projetées vers le même vocabulaire neutre :
+
+- géométrie en **polygones** (``Coords``) → ``Geometry.polygon`` (pas de bbox PAGE) ;
+- niveau **ligne** sans mots (PAGE n'a pas de ``<String>``) → ``Line.text`` direct,
+  ``Line.words = ()`` ;
+- **ordre de lecture en arbre** (``ReadingOrder``) → liste plate via ``flatten()`` ;
+- régions non-texte (``ImageRegion``…) → ``Region`` sans lignes, ``region_type``
+  reprenant le label PRImA.
+
+Les ``id`` de région absents sont synthétisés (``region_<n>``) comme côté ALTO.
+"""
+
+from __future__ import annotations
+
+from cinoc.domain.layout import (
+    CanonicalLayout,
+    Geometry,
+    LayoutPage,
+    Line,
+    Region,
+)
+from cinoc.formats._geometry import Point
+from cinoc.formats.pagexml.types import (
+    PageDocument,
+    PageGenericRegion,
+    PagePage,
+    PageRegion,
+    PageTextLine,
+    PageTextRegion,
+)
+
+
+class _Counter:
+    """Compteur déterministe pour les ``id`` de région manquants."""
+
+    def __init__(self) -> None:
+        self._n = 0
+
+    def next_id(self) -> str:
+        rid = f"region_{self._n}"
+        self._n += 1
+        return rid
+
+
+def _geometry(coords: tuple[Point, ...] | None) -> Geometry | None:
+    if not coords:
+        return None
+    return Geometry(polygon=coords)
+
+
+def _line(line: PageTextLine) -> Line:
+    return Line(
+        id=line.id,
+        text=line.text,
+        geometry=_geometry(line.coords),
+        baseline=tuple(line.baseline or ()),
+        confidence=line.confidence,
+    )
+
+
+def _region(region: PageRegion, counter: _Counter) -> Region:
+    rid = region.id or counter.next_id()
+    if isinstance(region, PageTextRegion):
+        return Region(
+            id=rid,
+            region_type=region.region_type or "text",
+            geometry=_geometry(region.coords),
+            lines=tuple(_line(line) for line in region.text_lines),
+            regions=tuple(_region(child, counter) for child in region.regions),
+        )
+    if isinstance(region, PageGenericRegion):
+        return Region(
+            id=rid,
+            region_type=region.region_type or region.region_name,
+            geometry=_geometry(region.coords),
+            regions=tuple(_region(child, counter) for child in region.regions),
+        )
+    raise AssertionError(f"région PAGE non gérée : {region!r}")  # pragma: no cover
+
+
+def _page(page: PagePage, counter: _Counter) -> LayoutPage:
+    regions = tuple(_region(region, counter) for region in page.regions)
+    if page.reading_order is not None:
+        reading_order = page.reading_order.flatten()
+    else:
+        reading_order = tuple(region.id for region in regions)
+    return LayoutPage(
+        width=page.image_width,
+        height=page.image_height,
+        regions=regions,
+        reading_order=reading_order,
+    )
+
+
+def page_to_layout(document: PageDocument) -> CanonicalLayout:
+    """Projette un ``PageDocument`` parsé vers le ``CanonicalLayout`` neutre."""
+    counter = _Counter()
+    return CanonicalLayout(
+        pages=tuple(_page(page, counter) for page in document.pages)
+    )
+
+
+__all__ = ["page_to_layout"]
diff --git a/cinoc/formats/pagexml/parser.py b/cinoc/formats/pagexml/parser.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c0aced88540b151eb9fe4e1beddca6dcfae3463
--- /dev/null
+++ b/cinoc/formats/pagexml/parser.py
@@ -0,0 +1,214 @@
+"""Parser PAGE XML tolérant (millésimes PRImA variés), via ``safe_parse_xml``.
+
+Extrait : régions de tout type (TextRegion + génériques non-texte), imbriquées ;
+géométrie en polygones (``Coords``) + ``Baseline`` ; texte de ligne via le
+``TextEquiv`` d'``index`` le plus bas ; arbre d'ordre de lecture.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from lxml import etree
+
+from cinoc.domain.errors import FormatError
+from cinoc.formats._geometry import Point, parse_points
+from cinoc.formats._xml import safe_parse_xml
+from cinoc.formats.pagexml.types import (
+    PageDocument,
+    PageGenericRegion,
+    PagePage,
+    PageRegion,
+    PageTextLine,
+    PageTextRegion,
+    ReadingOrderGroup,
+    ReadingOrderNode,
+    ReadingOrderRef,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class PageParseError(FormatError):
+    """PAGE XML illisible (XML invalide, vide, DOCTYPE interdit, ou sans page)."""
+
+
+def _lname(el: etree._Element) -> str:
+    return etree.QName(el).localname if isinstance(el.tag, str) else ""
+
+
+def _int_attr(el: etree._Element, name: str) -> int | None:
+    raw = el.get(name)
+    if raw is None:
+        return None
+    try:
+        return int(float(raw))
+    except ValueError:
+        return None
+
+
+def _points_child(el: etree._Element, child_name: str) -> tuple[Point, ...] | None:
+    for child in el:
+        if _lname(child) == child_name:
+            raw = child.get("points")
+            if raw is None:
+                return None
+            try:
+                return parse_points(raw)
+            except ValueError:
+                logger.warning(
+                    "[page] %s illisible, géométrie ignorée : %r", child_name, raw
+                )
+                return None
+    return None
+
+
+def _textequiv_text_conf(te: etree._Element) -> tuple[str, float | None]:
+    unicode_text = ""
+    for node in te:
+        if _lname(node) == "Unicode":
+            unicode_text = node.text or ""
+            break
+    conf: float | None = None
+    raw_conf = te.get("conf")
+    if raw_conf is not None:
+        try:
+            conf = float(raw_conf)
+        except ValueError:
+            conf = None
+    return unicode_text, conf
+
+
+def _line_text_and_conf(line: etree._Element) -> tuple[str, float | None]:
+    """Texte + confidence de la ligne.
+
+    On retient le ``TextEquiv`` de niveau ligne d'``index`` le plus bas. À défaut
+    (lignes uniquement segmentées en mots, ex. certains exports Transkribus), on
+    reconstruit le texte depuis les ``<Word>``.
+    """
+    best: tuple[int, str, float | None] | None = None
+    for te in line:
+        if _lname(te) != "TextEquiv":
+            continue
+        index = _int_attr(te, "index")
+        order = index if index is not None else 0
+        text, conf = _textequiv_text_conf(te)
+        if best is None or order < best[0]:
+            best = (order, text, conf)
+    if best is not None:
+        return best[1], best[2]
+
+    words: list[str] = []
+    for word in line:
+        if _lname(word) != "Word":
+            continue
+        for te in word:
+            if _lname(te) == "TextEquiv":
+                words.append(_textequiv_text_conf(te)[0])
+                break
+    if words:
+        return " ".join(words), None
+    return "", None
+
+
+def _parse_text_line(el: etree._Element) -> PageTextLine:
+    text, conf = _line_text_and_conf(el)
+    return PageTextLine(
+        id=el.get("id"),
+        coords=_points_child(el, "Coords"),
+        baseline=_points_child(el, "Baseline"),
+        text=text,
+        confidence=conf,
+    )
+
+
+def _parse_text_region(el: etree._Element) -> PageTextRegion:
+    lines = tuple(_parse_text_line(c) for c in el if _lname(c) == "TextLine")
+    return PageTextRegion(
+        id=el.get("id"),
+        region_type=el.get("type"),
+        coords=_points_child(el, "Coords"),
+        text_lines=lines,
+        regions=_parse_regions(el),
+    )
+
+
+def _parse_generic_region(el: etree._Element) -> PageGenericRegion:
+    return PageGenericRegion(
+        region_name=_lname(el),
+        id=el.get("id"),
+        region_type=el.get("type"),
+        coords=_points_child(el, "Coords"),
+        regions=_parse_regions(el),
+    )
+
+
+def _parse_regions(parent: etree._Element) -> tuple[PageRegion, ...]:
+    out: list[PageRegion] = []
+    for child in parent:
+        name = _lname(child)
+        if name == "TextRegion":
+            out.append(_parse_text_region(child))
+        elif name.endswith("Region"):
+            out.append(_parse_generic_region(child))
+    return tuple(out)
+
+
+def _parse_group(el: etree._Element) -> ReadingOrderGroup:
+    ordered = _lname(el).startswith("Ordered")
+    indexed: list[tuple[int, ReadingOrderNode]] = []
+    plain: list[ReadingOrderNode] = []
+    for child in el:
+        name = _lname(child)
+        node: ReadingOrderNode | None = None
+        if name in ("RegionRefIndexed", "RegionRef"):
+            ref = child.get("regionRef")
+            if ref is not None:
+                node = ReadingOrderRef(region_ref=ref)
+        elif name.startswith(("Ordered", "Unordered")):
+            node = _parse_group(child)
+        if node is None:
+            continue
+        index = _int_attr(child, "index")
+        if index is not None:
+            indexed.append((index, node))
+        else:
+            plain.append(node)
+    children = [node for _, node in sorted(indexed, key=lambda pair: pair[0])] + plain
+    return ReadingOrderGroup(id=el.get("id"), ordered=ordered, children=tuple(children))
+
+
+def _parse_reading_order(page: etree._Element) -> ReadingOrderGroup | None:
+    for child in page:
+        if _lname(child) == "ReadingOrder":
+            for group in child:
+                if _lname(group).startswith(("Ordered", "Unordered")):
+                    return _parse_group(group)
+    return None
+
+
+def _parse_page(el: etree._Element) -> PagePage:
+    return PagePage(
+        image_filename=el.get("imageFilename"),
+        image_width=_int_attr(el, "imageWidth"),
+        image_height=_int_attr(el, "imageHeight"),
+        reading_order=_parse_reading_order(el),
+        regions=_parse_regions(el),
+    )
+
+
+def parse_pagexml(data: bytes) -> PageDocument:
+    """Parse des octets PAGE XML en ``PageDocument`` (lève ``PageParseError``)."""
+    root = safe_parse_xml(data)
+    if root is None:
+        raise PageParseError("PAGE illisible (XML invalide, vide ou DOCTYPE interdit).")
+    namespace = etree.QName(root).namespace if isinstance(root.tag, str) else None
+    pages = tuple(
+        _parse_page(el)
+        for el in root.iter()
+        if isinstance(el.tag, str) and _lname(el) == "Page"
+    )
+    return PageDocument(pages=pages, source_namespace=namespace)
+
+
+__all__ = ["parse_pagexml", "PageParseError"]
diff --git a/cinoc/formats/pagexml/types.py b/cinoc/formats/pagexml/types.py
new file mode 100644
index 0000000000000000000000000000000000000000..a1f16c3f5d84fe53ad6472da8b97b50a8663d339
--- /dev/null
+++ b/cinoc/formats/pagexml/types.py
@@ -0,0 +1,140 @@
+"""Modèle de types PAGE XML (PRIMA / Transkribus / eScriptorium).
+
+Symétrique d'ALTO mais avec les conventions PAGE : géométrie en **polygones**
+(``Coords``) + ``Baseline``, texte via ``TextEquiv > Unicode``. Régions de tout
+type (``TextRegion`` + régions génériques non-texte), **imbriquées**. Niveau
+**ligne** (pas de mot/glyphe). Ordre de lecture en **arbre** (``ReadingOrder``)
+avec ``flatten()`` pour les métriques séquentielles.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from cinoc.formats._geometry import Point
+
+_FROZEN = ConfigDict(frozen=True, extra="forbid")
+
+
+# --- ordre de lecture (arbre) -----------------------------------------------
+
+
+class ReadingOrderRef(BaseModel):
+    """Référence à une région dans l'ordre de lecture."""
+
+    model_config = _FROZEN
+    kind: Literal["ref"] = "ref"
+    region_ref: str
+
+
+class ReadingOrderGroup(BaseModel):
+    """Groupe ordonné ou non de l'ordre de lecture (récursif)."""
+
+    model_config = _FROZEN
+    kind: Literal["group"] = "group"
+    id: str | None = None
+    ordered: bool = True
+    children: tuple[ReadingOrderNode, ...] = ()
+
+    def flatten(self) -> tuple[str, ...]:
+        """Liste plate des IDs de région, en parcours profondeur-d'abord."""
+        refs: list[str] = []
+        for child in self.children:
+            if isinstance(child, ReadingOrderRef):
+                refs.append(child.region_ref)
+            else:
+                refs.extend(child.flatten())
+        return tuple(refs)
+
+
+#: Nœud de l'arbre : référence ou sous-groupe.
+ReadingOrderNode = Annotated[
+    ReadingOrderRef | ReadingOrderGroup,
+    Field(discriminator="kind"),
+]
+
+
+# --- régions -----------------------------------------------------------------
+
+
+class PageTextLine(BaseModel):
+    """Ligne PAGE (``<TextLine>``)."""
+
+    model_config = _FROZEN
+    id: str | None = None
+    coords: tuple[Point, ...] | None = None
+    baseline: tuple[Point, ...] | None = None
+    text: str = ""
+    confidence: float | None = None  # conf du TextEquiv retenu
+
+
+class PageTextRegion(BaseModel):
+    """Région de texte PAGE (``<TextRegion>``), pouvant contenir des sous-régions."""
+
+    model_config = _FROZEN
+    kind: Literal["text"] = "text"
+    id: str | None = None
+    region_type: str | None = None  # attribut type
+    coords: tuple[Point, ...] | None = None
+    text_lines: tuple[PageTextLine, ...] = ()
+    regions: tuple[PageRegion, ...] = ()
+
+
+class PageGenericRegion(BaseModel):
+    """Région non-texte PAGE (Image/Separator/Graphic/Table…) — géométrie seule.
+
+    ``region_name`` porte le nom d'élément PRImA (ex. ``"ImageRegion"``)."""
+
+    model_config = _FROZEN
+    kind: Literal["generic"] = "generic"
+    region_name: str
+    id: str | None = None
+    region_type: str | None = None
+    coords: tuple[Point, ...] | None = None
+    regions: tuple[PageRegion, ...] = ()
+
+
+#: Union discriminée des régions.
+PageRegion = Annotated[
+    PageTextRegion | PageGenericRegion,
+    Field(discriminator="kind"),
+]
+
+
+class PagePage(BaseModel):
+    """Page PAGE (``<Page>``)."""
+
+    model_config = _FROZEN
+    image_filename: str | None = None
+    image_width: int | None = None
+    image_height: int | None = None
+    reading_order: ReadingOrderGroup | None = None
+    regions: tuple[PageRegion, ...] = ()
+
+
+class PageDocument(BaseModel):
+    """Document PAGE complet."""
+
+    model_config = _FROZEN
+    pages: tuple[PagePage, ...] = ()
+    source_namespace: str | None = None
+
+
+ReadingOrderGroup.model_rebuild()
+PageTextRegion.model_rebuild()
+PageGenericRegion.model_rebuild()
+PagePage.model_rebuild()
+
+__all__ = [
+    "ReadingOrderRef",
+    "ReadingOrderGroup",
+    "ReadingOrderNode",
+    "PageTextLine",
+    "PageTextRegion",
+    "PageGenericRegion",
+    "PageRegion",
+    "PagePage",
+    "PageDocument",
+]
diff --git a/cinoc/formats/pagexml/writer.py b/cinoc/formats/pagexml/writer.py
new file mode 100644
index 0000000000000000000000000000000000000000..5fee06ed6927bc1dc994c710ec505baaafa25274
--- /dev/null
+++ b/cinoc/formats/pagexml/writer.py
@@ -0,0 +1,129 @@
+"""Writer PAGE XML déterministe (lxml + C14N2). Symétrique du writer ALTO.
+
+Garantie : ``parse_pagexml(write_pagexml(doc)) == doc`` pour un document dont le
+``source_namespace`` est celui écrit. Sans état global → thread-safe ; zéro
+horodatage (pas de ``Metadata``) → déterministe.
+"""
+
+from __future__ import annotations
+
+from lxml import etree
+
+from cinoc.domain.errors import FormatError
+from cinoc.formats._geometry import format_points
+from cinoc.formats.pagexml.types import (
+    PageDocument,
+    PagePage,
+    PageRegion,
+    PageTextLine,
+    PageTextRegion,
+    ReadingOrderGroup,
+    ReadingOrderRef,
+)
+
+DEFAULT_PAGE_NS = "http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"
+
+
+class PageWriteError(FormatError):
+    """Écriture PAGE impossible."""
+
+
+def _q(ns: str, local: str) -> str:
+    return f"{{{ns}}}{local}"
+
+
+def _write_coords(
+    parent: etree._Element, ns: str, points: tuple[tuple[int, int], ...]
+) -> None:
+    etree.SubElement(parent, _q(ns, "Coords")).set("points", format_points(points))
+
+
+def _write_line(parent: etree._Element, ns: str, line: PageTextLine) -> None:
+    el = etree.SubElement(parent, _q(ns, "TextLine"))
+    if line.id is not None:
+        el.set("id", line.id)
+    if line.coords is not None:
+        _write_coords(el, ns, line.coords)
+    if line.baseline is not None:
+        baseline = etree.SubElement(el, _q(ns, "Baseline"))
+        baseline.set("points", format_points(line.baseline))
+    text_equiv = etree.SubElement(el, _q(ns, "TextEquiv"))
+    text_equiv.set("index", "0")
+    if line.confidence is not None:
+        text_equiv.set("conf", str(line.confidence))
+    etree.SubElement(text_equiv, _q(ns, "Unicode")).text = line.text
+
+
+def _write_region(parent: etree._Element, ns: str, region: PageRegion) -> None:
+    if isinstance(region, PageTextRegion):
+        el = etree.SubElement(parent, _q(ns, "TextRegion"))
+        if region.id is not None:
+            el.set("id", region.id)
+        if region.region_type is not None:
+            el.set("type", region.region_type)
+        if region.coords is not None:
+            _write_coords(el, ns, region.coords)
+        for line in region.text_lines:
+            _write_line(el, ns, line)
+        for child in region.regions:
+            _write_region(el, ns, child)
+    else:  # PageGenericRegion
+        el = etree.SubElement(parent, _q(ns, region.region_name))
+        if region.id is not None:
+            el.set("id", region.id)
+        if region.region_type is not None:
+            el.set("type", region.region_type)
+        if region.coords is not None:
+            _write_coords(el, ns, region.coords)
+        for child in region.regions:
+            _write_region(el, ns, child)
+
+
+def _write_group(
+    parent: etree._Element, ns: str, group: ReadingOrderGroup, index: int | None
+) -> None:
+    suffix = "Indexed" if index is not None else ""
+    name = ("OrderedGroup" if group.ordered else "UnorderedGroup") + suffix
+    el = etree.SubElement(parent, _q(ns, name))
+    if index is not None:
+        el.set("index", str(index))
+    if group.id is not None:
+        el.set("id", group.id)
+    for position, child in enumerate(group.children):
+        child_index = position if group.ordered else None
+        if isinstance(child, ReadingOrderRef):
+            ref_name = "RegionRefIndexed" if group.ordered else "RegionRef"
+            ref_el = etree.SubElement(el, _q(ns, ref_name))
+            if child_index is not None:
+                ref_el.set("index", str(child_index))
+            ref_el.set("regionRef", child.region_ref)
+        else:
+            _write_group(el, ns, child, child_index)
+
+
+def _write_page(parent: etree._Element, ns: str, page: PagePage) -> None:
+    el = etree.SubElement(parent, _q(ns, "Page"))
+    if page.image_filename is not None:
+        el.set("imageFilename", page.image_filename)
+    if page.image_width is not None:
+        el.set("imageWidth", str(page.image_width))
+    if page.image_height is not None:
+        el.set("imageHeight", str(page.image_height))
+    if page.reading_order is not None:
+        order_el = etree.SubElement(el, _q(ns, "ReadingOrder"))
+        _write_group(order_el, ns, page.reading_order, None)
+    for region in page.regions:
+        _write_region(el, ns, region)
+
+
+def write_pagexml(document: PageDocument, *, namespace: str | None = None) -> bytes:
+    """Sérialise un ``PageDocument`` en octets PAGE XML canoniques (C14N2)."""
+    ns = namespace or document.source_namespace or DEFAULT_PAGE_NS
+    nsmap = {None: ns}
+    root = etree.Element(_q(ns, "PcGts"), nsmap=nsmap)  # type: ignore[arg-type]
+    for page in document.pages:
+        _write_page(root, ns, page)
+    return etree.tostring(root, method="c14n2")
+
+
+__all__ = ["write_pagexml", "PageWriteError", "DEFAULT_PAGE_NS"]
diff --git a/cinoc/formats/text/__init__.py b/cinoc/formats/text/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..56298b8de498232560761a93f874c476049d35ab
--- /dev/null
+++ b/cinoc/formats/text/__init__.py
@@ -0,0 +1,19 @@
+"""Sous-couche texte : normalisation de comparaison + lecture de texte brut."""
+
+from __future__ import annotations
+
+from cinoc.formats.text.normalization import (
+    DEFAULT_PROFILE,
+    NORMALIZATION_PROFILES,
+    NormalizationProfile,
+    get_builtin_profile,
+)
+from cinoc.formats.text.plain import read_plaintext
+
+__all__ = [
+    "NormalizationProfile",
+    "NORMALIZATION_PROFILES",
+    "DEFAULT_PROFILE",
+    "get_builtin_profile",
+    "read_plaintext",
+]
diff --git a/cinoc/formats/text/normalization.py b/cinoc/formats/text/normalization.py
new file mode 100644
index 0000000000000000000000000000000000000000..f63fb01ce06cb09b56fa86e2d30a04720df8aa2e
--- /dev/null
+++ b/cinoc/formats/text/normalization.py
@@ -0,0 +1,478 @@
+"""Normalisation de texte pour les métriques de similarité (CER/WER, CER diplomatique).
+
+Un ``NormalizationProfile`` est un **objet-valeur autonome** (immuable) appliqué
+**symétriquement** à la vérité-terrain et à l'hypothèse avant comparaison. La même
+transformation des deux côtés mesure les erreurs « substantielles » en neutralisant
+des équivalences choisies (graphies historiques, casse, ponctuation, espaces…).
+
+Le profil ne s'applique **jamais** au niveau ``ENTITIES`` (offsets caractère) ni aux
+métriques patrimoniales sur la graphie brute (MUFI, typographie) — voir le plan
+couche 2.
+
+Ordre canonique de ``normalize`` (figé, vérifié par tests) ::
+
+    hygiène → unicode_form → casefold(si caseless) → exclude_chars
+            → diplomatic_table → non_word_to_space → strip_diacritics → whitespace
+
+Sous ``caseless`` le casefold précède la table, et les clés de table comme
+l'ensemble exclu sont casefoldés pour la correspondance (sinon la casse ne serait
+pas neutralisée). Le casefold pouvant dé-normaliser, on ré-applique ``unicode_form``
+après lui.
+
+La substitution diplomatique est faite en **un seul passage** (alternation regex,
+clé la plus longue d'abord) : aucune cascade possible quelle que soit la table
+(``{"u": "v", "v": "u"}`` sur ``"uv"`` donne ``"vu"``, pas ``"vv"``).
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+import unicodedata
+from pathlib import Path
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+logger = logging.getLogger(__name__)
+
+UnicodeForm = Literal["none", "NFC", "NFD", "NFKC", "NFKD"]
+WhitespaceMode = Literal["none", "intra_line", "flat"]
+ExcludeMode = Literal["delete", "space"]
+#: Fonction de pliage de casse (quand ``caseless``). ``casefold`` (défaut) est le
+#: pliage Unicode complet (``ß→ss``, ``ſ→s``, ``ff→ff``…) ; ``lower`` est le
+#: minuscule simple — requis par la conformité HIPE, dont le ``norm()`` officiel
+#: plie via ``str.lower()`` (qui **garde** ``ſ``/``ff``, cf. golden).
+CaseMode = Literal["casefold", "lower"]
+
+#: Caractères de contrôle conservés (pris en charge par le levier ``whitespace``).
+_KEEP_CONTROL = frozenset("\t\n\r\f\v")
+
+
+# ---------------------------------------------------------------------------
+# Tables diplomatiques préconfigurées (données ; français + latin)
+# ---------------------------------------------------------------------------
+
+#: Français médiéval (XIIe–XVe). Appliquée des deux côtés → CER sur les classes
+#: d'équivalence graphiques (quotient), non biaisé même pour u/v (non positionnel).
+DIPLOMATIC_FR_MEDIEVAL: dict[str, str] = {
+    "ſ": "s",
+    "u": "v",
+    "i": "j",
+    "y": "i",
+    "æ": "ae",
+    "œ": "oe",
+    "ꝑ": "per",
+    "ꝓ": "pro",
+    "&": "et",
+}
+
+#: Français imprimé ancien (XVIe–XVIIIe).
+DIPLOMATIC_FR_EARLY_MODERN: dict[str, str] = {
+    "ſ": "s",
+    "æ": "ae",
+    "œ": "oe",
+    "&": "et",
+    "ỹ": "yn",
+}
+
+#: Latin médiéval.
+DIPLOMATIC_LATIN_MEDIEVAL: dict[str, str] = {
+    "ſ": "s",
+    "u": "v",
+    "i": "j",
+    "y": "i",
+    "æ": "ae",
+    "œ": "oe",
+    "ꝑ": "per",
+    "ꝓ": "pro",
+    "ꝗ": "que",
+    "&": "et",
+}
+
+#: Minimal : NFC + s long.
+DIPLOMATIC_MINIMAL: dict[str, str] = {"ſ": "s"}
+
+#: Socle commun des profils de conformité HIPE : césures DTA (un tiret cadratin
+#: ou un ``¬`` en fin de ligne recollent le mot) + underscore → espace, **et**
+#: recomposition des umlauts décomposés — sans elle, le levier ``\W → espace``
+#: (fidèle au scorer) détruirait la marque combinante U+0364 isolée. Vit en
+#: table (multi-codepoints) : l'exclusion ne traite que des caractères isolés.
+_HIPE_DEHYPHEN: dict[str, str] = {
+    "—\n": "",
+    "¬\n": "",
+    "_": " ",
+    "aͤ": "ä",
+    "oͤ": "ö",
+    "uͤ": "ü",
+}
+
+#: ``norm()`` du scorer HIPE-OCRepair (SPEC_HIPE §4.3) : mappings explicites
+#: appliqués après pliage de casse. ``ß→ss`` est déjà l'effet du casefold —
+#: conservé pour documenter la table complète du scorer (idempotent).
+DIPLOMATIC_HIPE: dict[str, str] = {
+    **_HIPE_DEHYPHEN,
+    "ß": "ss",
+    "ꝛ": "r",
+    "œ": "oe",
+    "æ": "ae",
+}
+
+#: Ponctuation courante (pour le profil ``no_punctuation``).
+_PUNCTUATION = ".,;:!?'’\"-–—()[]«»…"
+
+
+# ---------------------------------------------------------------------------
+# Helpers de transformation (purs)
+# ---------------------------------------------------------------------------
+
+
+def _parse_exclude_chars(value: Any) -> frozenset[str]:
+    """Convertit l'entrée utilisateur en ensemble de caractères à exclure.
+
+    - chaîne → ensemble de **ses caractères** (aucun séparateur magique) ;
+    - liste/ensemble → items (chacun **un seul** codepoint) ;
+    - ``None`` / vide → ensemble vide.
+
+    Un item multi-codepoint relève de la substitution (table), pas de l'exclusion :
+    il est ignoré avec un avertissement.
+    """
+    if not value:
+        return frozenset()
+    items: list[str]
+    if isinstance(value, (list, tuple, set, frozenset)):
+        items = [str(c) for c in value]
+    else:
+        items = list(str(value))
+    out: set[str] = set()
+    for item in items:
+        if len(item) != 1:
+            logger.warning(
+                "[normalization] exclude_chars ignore %r (pas un caractère unique)",
+                item,
+            )
+            continue
+        out.add(item)
+    return frozenset(out)
+
+
+def _normalize_form(text: str, form: UnicodeForm) -> str:
+    if form == "none":
+        return text
+    return unicodedata.normalize(form, text)
+
+
+def _strip_invisible(text: str) -> str:
+    """Retire les caractères invisibles : format (soft-hyphen, zero-width, BOM,
+    marques directionnelles) et contrôle, en conservant ``\\t\\n\\r\\f\\v``."""
+    out: list[str] = []
+    for char in text:
+        category = unicodedata.category(char)
+        if category == "Cf":
+            continue
+        if category == "Cc" and char not in _KEEP_CONTROL:
+            continue
+        out.append(char)
+    return "".join(out)
+
+
+def _apply_table(text: str, table: dict[str, str]) -> str:
+    """Substitution simultanée en un seul passage (clé la plus longue d'abord)."""
+    if not table:
+        return text
+    keys = sorted(table, key=len, reverse=True)
+    pattern = re.compile("|".join(re.escape(k) for k in keys))
+    return pattern.sub(lambda m: table[m.group(0)], text)
+
+
+def _strip_diacritics(text: str, form: UnicodeForm) -> str:
+    """NFD → suppression des marques combinantes (catégorie ``Mn``) → forme cible."""
+    decomposed = unicodedata.normalize("NFD", text)
+    stripped = "".join(c for c in decomposed if unicodedata.category(c) != "Mn")
+    return _normalize_form(stripped, form)
+
+
+# ---------------------------------------------------------------------------
+# Profil
+# ---------------------------------------------------------------------------
+
+
+class NormalizationProfile(BaseModel):
+    """Stratégie de normalisation immuable, appliquée symétriquement GT/OCR."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    name: str
+    unicode_form: UnicodeForm = "NFC"
+    caseless: bool = False
+    #: Fonction de pliage quand ``caseless`` (cf. :data:`CaseMode`). ``casefold``
+    #: par défaut ; ``lower`` n'est requis que par la conformité HIPE.
+    case_mode: CaseMode = "casefold"
+    #: Si vrai (défaut), l'hygiène retire les invisibles (``Cf``/``Cc``). Le profil
+    #: ``hipe`` le désactive : le scorer mappe ces caractères en **espace** (via
+    #: ``\\W → espace``), pas en suppression — il faut donc les laisser passer
+    #: jusqu'à ``non_word_to_space`` (cf. golden).
+    strip_invisible: bool = True
+    whitespace: WhitespaceMode = "none"
+    strip_diacritics: bool = False
+    diplomatic_table: dict[str, str] = Field(default_factory=dict)
+    exclude_chars: frozenset[str] = Field(default_factory=frozenset)
+    exclude_mode: ExcludeMode = "delete"
+    #: Remplace tout caractère **non-mot** (``\W`` Unicode) par une espace —
+    #: levier requis par la ``norm()`` HIPE (« tout non-\\w → espace »). Appliqué
+    #: après la table (les césures multi-caractères doivent être recollées avant).
+    non_word_to_space: bool = False
+    description: str = ""
+
+    @field_validator("exclude_chars", mode="before")
+    @classmethod
+    def _coerce_exclude(cls, value: Any) -> frozenset[str]:
+        return _parse_exclude_chars(value)
+
+    @field_validator("diplomatic_table")
+    @classmethod
+    def _check_table(cls, value: dict[str, str]) -> dict[str, str]:
+        if any(not key for key in value):
+            raise ValueError("clé de table diplomatique vide interdite")
+        return value
+
+    # -- application --------------------------------------------------------
+
+    def _fold(self, text: str) -> str:
+        """Pliage de casse selon ``case_mode`` (``casefold`` ou ``lower``)."""
+        return text.lower() if self.case_mode == "lower" else text.casefold()
+
+    def normalize(self, text: str) -> str:
+        """Applique le profil (ordre canonique figé)."""
+        if self.strip_invisible:
+            text = _strip_invisible(text)
+        text = _normalize_form(text, self.unicode_form)
+        if self.caseless:
+            text = _normalize_form(self._fold(text), self.unicode_form)
+        if self.exclude_chars:
+            text = self._apply_exclude(text)
+        if self.diplomatic_table:
+            text = _apply_table(text, self._effective_table())
+        if self.non_word_to_space:
+            text = re.sub(r"[^\w]", " ", text)
+        if self.strip_diacritics:
+            text = _strip_diacritics(text, self.unicode_form)
+        return self._apply_whitespace(text)
+
+    def _effective_chars(self) -> frozenset[str]:
+        if not self.caseless:
+            return self.exclude_chars
+        folded: set[str] = set()
+        for char in self.exclude_chars:
+            cf = self._fold(char)
+            if len(cf) == 1:
+                folded.add(cf)
+            else:
+                logger.warning(
+                    "[normalization] exclude %r : pliage multi-codepoint, ignoré",
+                    char,
+                )
+        return frozenset(folded)
+
+    def _apply_exclude(self, text: str) -> str:
+        chars = self._effective_chars()
+        replacement = " " if self.exclude_mode == "space" else ""
+        return "".join(replacement if c in chars else c for c in text)
+
+    def _effective_table(self) -> dict[str, str]:
+        if not self.caseless:
+            return self.diplomatic_table
+        return {self._fold(k): self._fold(v) for k, v in self.diplomatic_table.items()}
+
+    def _apply_whitespace(self, text: str) -> str:
+        if self.whitespace == "none":
+            return text
+        if self.whitespace == "flat":
+            return re.sub(r"\s+", " ", text).strip()
+        # intra_line : normalise les espaces dans chaque ligne, garde les sauts.
+        text = text.replace("\r\n", "\n").replace("\r", "\n")
+        lines = [re.sub(r"\s+", " ", line).strip() for line in text.split("\n")]
+        return "\n".join(lines).strip("\n")
+
+    # -- sérialisation / construction --------------------------------------
+
+    def as_dict(self) -> dict[str, Any]:
+        """Forme sérialisée déterministe (clés et exclusions triées)."""
+        return {
+            "name": self.name,
+            "unicode_form": self.unicode_form,
+            "caseless": self.caseless,
+            "case_mode": self.case_mode,
+            "strip_invisible": self.strip_invisible,
+            "whitespace": self.whitespace,
+            "strip_diacritics": self.strip_diacritics,
+            "diplomatic_table": dict(sorted(self.diplomatic_table.items())),
+            "exclude_chars": sorted(self.exclude_chars),
+            "exclude_mode": self.exclude_mode,
+            "non_word_to_space": self.non_word_to_space,
+            "description": self.description,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> NormalizationProfile:
+        """Construit un profil depuis un dict (clés inconnues → erreur de validation).
+
+        Sucre rétro-compatible : ``nfc: bool`` → ``unicode_form``, et ``diplomatic``
+        comme alias de ``diplomatic_table``. ``unicode_form`` explicite l'emporte.
+        """
+        fields = dict(data)
+        nfc = fields.pop("nfc", None)
+        if "unicode_form" not in fields and nfc is not None:
+            fields["unicode_form"] = "NFC" if nfc else "none"
+        diplomatic = fields.pop("diplomatic", None)
+        if "diplomatic_table" not in fields and diplomatic is not None:
+            fields["diplomatic_table"] = diplomatic
+        fields.setdefault("name", "custom")
+        return cls(**fields)
+
+    @classmethod
+    def from_yaml_text(
+        cls, text: str, *, default_name: str = "custom"
+    ) -> NormalizationProfile:
+        """Charge un profil depuis du **texte YAML** (pas un fichier).
+
+        Pour une entrée non fiable (aperçu web d'une config saisie) : ``safe_load``
+        seul, **objet attendu** (sinon ``ValueError``), aucun accès disque. La
+        validation Pydantic (clés inconnues interdites) protège le reste.
+        """
+        import yaml  # type: ignore[import-untyped]
+
+        raw = yaml.safe_load(text) or {}
+        if not isinstance(raw, dict):
+            raise ValueError("profil YAML invalide (objet attendu).")
+        raw.setdefault("name", default_name)
+        return cls.from_dict(raw)
+
+    @classmethod
+    def from_yaml(cls, path: str | Path) -> NormalizationProfile:
+        """Charge un profil depuis un fichier YAML (usage CLI/local uniquement).
+
+        Ne jamais exposer un chemin fourni par une entrée non fiable (lecture
+        de fichier arbitraire).
+        """
+        return cls.from_yaml_text(
+            Path(path).read_text(encoding="utf-8"), default_name=Path(path).stem
+        )
+
+
+# ---------------------------------------------------------------------------
+# Profils préconfigurés (14) — défaut neutre ``nfc``, aucun profil privilégié
+# ---------------------------------------------------------------------------
+
+NORMALIZATION_PROFILES: dict[str, NormalizationProfile] = {
+    p.name: p
+    for p in (
+        NormalizationProfile(name="nfc", description="NFC seul (neutre)"),
+        NormalizationProfile(
+            name="nfkc", unicode_form="NFKC", description="NFKC (ligatures fifl…)"
+        ),
+        NormalizationProfile(
+            name="caseless", caseless=True, description="NFC + insensible à la casse"
+        ),
+        NormalizationProfile(
+            name="minimal",
+            diplomatic_table=DIPLOMATIC_MINIMAL,
+            description="NFC + s long",
+        ),
+        NormalizationProfile(
+            name="no_diacritics",
+            strip_diacritics=True,
+            description="NFC + pliage des diacritiques (é→e)",
+        ),
+        NormalizationProfile(
+            name="flat_text",
+            whitespace="flat",
+            description="NFC + comparaison à plat (espaces et sauts écrasés)",
+        ),
+        NormalizationProfile(
+            name="keep_line_breaks",
+            whitespace="intra_line",
+            description="NFC + espaces normalisés, sauts de ligne conservés",
+        ),
+        NormalizationProfile(
+            name="no_punctuation",
+            exclude_chars=_PUNCTUATION,  # type: ignore[arg-type]
+            exclude_mode="space",
+            description="NFC + ponctuation ignorée (remplacée par une espace)",
+        ),
+        NormalizationProfile(
+            name="no_apostrophes",
+            exclude_chars="'’",  # type: ignore[arg-type]
+            exclude_mode="delete",
+            description="NFC + apostrophes droite (') et typographique (’) ignorées",
+        ),
+        NormalizationProfile(
+            name="medieval_french",
+            diplomatic_table=DIPLOMATIC_FR_MEDIEVAL,
+            description="Français médiéval : ſ=s, u=v, i=j, æ=ae, œ=oe…",
+        ),
+        NormalizationProfile(
+            name="early_modern_french",
+            diplomatic_table=DIPLOMATIC_FR_EARLY_MODERN,
+            description="Français imprimé ancien : ſ=s, æ=ae, œ=oe…",
+        ),
+        NormalizationProfile(
+            name="medieval_latin",
+            diplomatic_table=DIPLOMATIC_LATIN_MEDIEVAL,
+            description="Latin médiéval : ſ=s, u=v, i=j, ꝑ=per, ꝓ=pro, ꝗ=que…",
+        ),
+        # Conformité HIPE-OCRepair (SPEC_HIPE §4.3/§7.2), reproduit le ``norm()``
+        # officiel **à l'identique** (prouvé à 1e-9 par le golden) :
+        # - ``unicode_form="none"`` : le scorer n'applique aucune normalisation ;
+        # - ``case_mode="lower"`` : le scorer plie via ``str.lower()`` (PAS casefold) —
+        #   il **garde** ſ/ff/fi (casefold les replierait à tort en s/ff/fi) ;
+        # - ``strip_invisible=False`` : le scorer mappe les invisibles (Cf/Cc) en
+        #   **espace** via ``\W → espace``, pas en suppression → on les laisse passer
+        #   jusqu'à ``non_word_to_space``.
+        NormalizationProfile(
+            name="hipe",
+            unicode_form="none",
+            caseless=True,
+            case_mode="lower",
+            strip_invisible=False,
+            diplomatic_table=DIPLOMATIC_HIPE,
+            non_word_to_space=True,
+            whitespace="flat",
+            description=(
+                "Conformité HIPE : casse pliée (lower), ß/ꝛ/œ/æ/aͤ/oͤ/uͤ mappés, "
+                "ſ/ff gardés, césures DTA recollées, invisibles → espace, compactés"
+            ),
+        ),
+        # ``hipe`` SANS les pliages patrimoniaux : l'écart cmer(heritage) −
+        # cmer(hipe) isole la part d'erreur imputable aux équivalences œ/oe,
+        # æ/ae, ꝛ/r. Limites documentées : ß reste plié (casefold Python) et
+        # les umlauts décomposés restent recomposés (sinon ``\W`` détruirait
+        # la marque combinante isolée) — ces deux-là ne comptent pas au delta.
+        NormalizationProfile(
+            name="heritage",
+            unicode_form="none",
+            caseless=True,
+            diplomatic_table=_HIPE_DEHYPHEN,
+            non_word_to_space=True,
+            whitespace="flat",
+            description=(
+                "Comme `hipe` mais préserve les distinctions patrimoniales "
+                "œ, æ, ꝛ (ß plié par le casefold ; umlauts décomposés recomposés)"
+            ),
+        ),
+    )
+}
+
+#: Profil par défaut : neutre, sans table culturelle.
+DEFAULT_PROFILE: NormalizationProfile = NORMALIZATION_PROFILES["nfc"]
+
+
+def get_builtin_profile(name: str) -> NormalizationProfile:
+    """Retourne un profil préconfiguré, ou lève ``KeyError`` (message explicite)."""
+    try:
+        return NORMALIZATION_PROFILES[name]
+    except KeyError:
+        available = ", ".join(sorted(NORMALIZATION_PROFILES))
+        raise KeyError(
+            f"profil de normalisation inconnu : {name!r}. Disponibles : {available}"
+        ) from None
diff --git a/cinoc/formats/text/plain.py b/cinoc/formats/text/plain.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c264128f1f2a0c6935b6e7ca984f1dfe017208a
--- /dev/null
+++ b/cinoc/formats/text/plain.py
@@ -0,0 +1,22 @@
+"""Lecture de texte brut (``.gt.txt``, transcriptions plates).
+
+Centralise le décodage : encodage, BOM, fins de ligne. Ne **produit** jamais de
+texte (pas d'écrivain) ; distinct de la normalisation (préparation à la
+comparaison), qui vient après. Opère sur des ``bytes`` (zéro I/O ici).
+"""
+
+from __future__ import annotations
+
+_UTF8_BOM = b"\xef\xbb\xbf"
+
+
+def read_plaintext(data: bytes, encoding: str = "utf-8") -> str:
+    """Décode des octets de texte brut en chaîne.
+
+    - retire le BOM UTF-8 en tête (octets) et tout U+FEFF résiduel ;
+    - normalise les fins de ligne (``\\r\\n`` / ``\\r`` → ``\\n``).
+    """
+    if data.startswith(_UTF8_BOM):
+        data = data[len(_UTF8_BOM):]
+    text = data.decode(encoding).lstrip("")
+    return text.replace("\r\n", "\n").replace("\r", "\n")
diff --git a/cinoc/interfaces/ANALYSE_COUCHE_8.md b/cinoc/interfaces/ANALYSE_COUCHE_8.md
new file mode 100644
index 0000000000000000000000000000000000000000..0348041281c947d73b16a27a7babe7f11e389273
--- /dev/null
+++ b/cinoc/interfaces/ANALYSE_COUCHE_8.md
@@ -0,0 +1,318 @@
+# ANALYSE_COUCHE_8.md — `interfaces/` (Picarones → Cinoc)
+
+> **Type** : session d'ANALYSE (guide de portage **durable**). **Aucun code Cinoc écrit.**
+> **Couche** : 8 = `interfaces` (la plus externe) dans
+> `domain(1) ← formats(2) ← evaluation(3) ← pipeline(4) ← adapters(5) ← app(6) ← reports(7) ← interfaces(8)`.
+> **Source gelée** : `../Picarones/picarones/interfaces/` — **42 fichiers Python / 8 931 LOC**, + assets (**2 483 LOC JS**, **1 432 LOC CSS**, **1 201 LOC templates HTML/J2**) ≈ **5 116 LOC d'assets**.
+> **Couches amont** : `domain`+`formats` mergées (code) ; `evaluation`(MIG-3), `pipeline`(ANA-4), `adapters`(ANA-5), `app`(ANA-6), `reports`(ANA-7) en analyses/plans.
+> **Méthode** : 4 sous-agents d'exploration en parallèle (CLI · cœur web/state · sécurité · routers) **+ recoupement personnel des points décisifs dans le code** (surface CLI, accroche narrative, chaîne `RunResult→BenchmarkResult→ReportGenerator`, doublon job store, ré-import sécurité, pattern de création de l'app, mode public, couplage importeurs→adapters).
+> **Partie 1 = durable** (source figée). **Partie 2 = périssable** (« à confirmer à la tranche »). Verdicts **PROVISOIRE — à confirmer au build**.
+
+---
+
+## PARTIE 0 — Vérification anti-contradiction (obligatoire)
+
+Aucune conclusion ne contredit `CLAUDE.md` ni une couche mergée/planifiée. L'analyse **confirme dans le code** cinq décisions déjà actées :
+
+| Décision actée (où) | Confirmé dans le code Picarones (preuve) |
+|---|---|
+| **Workflows CLI réduits à `run/report/compare/demo/serve`** (`CLAUDE.md` §8.4) | 14 commandes réelles : `metrics/engines/info/report/demo` (`cli/__init__.py:136-326`) + `run/diagnose/economics/edition/compare` (`_workflows.py:132-792`) + `robustness/import/history/serve`. `diagnose/economics/edition` = 3 profils figés délégant à `_run_workflow` (`_workflows.py:644/711/764`) — exactement les 3 nommés à supprimer. |
+| **7 modules `security_*` → un package `security/`** (`CLAUDE.md` §8.5) | 6 modules web (`security.py`+`security_{paths,csp,public_mode,uploads,rate_limit}.py`, 955 LOC) + le foyer `app/services/path_security.py` (454, couche 6). `security.py` est déjà un **hub de ré-export** (« dégonflage god-module P1.2 », `security.py:39-46`). |
+| **Double format supprimé : `RunResult→BenchmarkResult` disparaît** (`CLAUDE.md` §8.1 ; ANA-6 L62-65 ; ANA-7 §1.2) | CLI **et** web font `run_result_to_benchmark_result()` → `ReportGenerator` legacy : `benchmark_utils.py:546,558` ; `_workflows.py:86,599` ; `cli/__init__.py:311,403`. Conversion présente **uniquement** pour nourrir le générateur Jinja2 legacy. |
+| **Moteur narratif SUPPRIMÉ** (`CLAUDE.md` §6) | `routers/synthesis.py:101 from picarones.reports.narrative import build_synthesis` (appelé `:103`), router monté `app.py:253`, section template `_view_benchmark.html:387` + `web-app.js:1204`. 1 router + 1 route + 1 encart UI à couper. |
+| **DTO web = transport, couche 8** (backlog domain ; CLAUDE.md §6) | `web/models.py` = 9 DTO Pydantic de transport (`:246,301,…`). N'importe que `domain.pipeline_spec.PipelineMode` (`:75`). Place couche 8 confirmée. |
+
+**Deux AFFINEMENTS (clarifications, PAS des contradictions)** :
+
+1. **Job store + SSE** : ANA-6 (§1.6, §2.2) place le store en `adapters/storage` (couche 5) et note `job_runner→adapters.storage.JobStore`. **Le code montre que le web utilise en réalité `web/jobs.py`** (avec table `job_events` + reprise SSE `Last-Event-ID`), tandis que la réécriture `adapters/storage/job_store.py` **a abandonné le SSE** et n'est consommée que par `app/services/job_runner.py`, lui-même **jamais importé par le web** (mort de bout en bout). → Le store canonique Cinoc (en `adapters/storage`) **doit reprendre la capacité d'événements/SSE** que la réécriture actuelle a perdue. (Cohérent avec ANA-6, complète juste le contrat.)
+2. **Package sécurité réparti par couche** : ANA-6 §2.2 place `path_security` en `app/security/` (partagé CLI/jobs/web). §8.5 demande « un package `security/` » pour le cluster web. Pas de conflit : **validation de chemin = `app/security` (couche 6, partagée)** ; **sécurité HTTP (CSRF/CSP/rate-limit/uploads/mode public) = un package `security/` en `interfaces` (couche 8)**, qui *importe* la validation de chemin. La validation de chemin n'existe **qu'une fois** dans la source (`app/services/path_security.py`), `security_paths.py:20-28` ne fait que la ré-exporter — donc pas de dédoublonnage à faire, juste un regroupement.
+
+---
+
+# PARTIE 1 — ANALYSE DE LA SOURCE PICARONES (durable)
+
+## 1.1 Inventaire exact (42 py / 8 931 LOC + 5 116 LOC d'assets)
+
+| Cluster | Fichiers | LOC | Rôle global vérifié |
+|---|---:|---:|---|
+| **A. CLI** (`cli/`) | 7 | **2 018** | Groupe Click + 14 commandes ; pont vers `app.services` (orchestration) et `reports.html` (rendu). Point d'entrée console. |
+| **B. Cœur web** (`web/` racine) | 12 | **3 434** | App FastAPI singleton, état partagé, DTO, worker de benchmark threadé, job store SQLite, utilitaires corpus/engines/observabilité. |
+| **C. Sécurité web** (`web/security*`) | 6 | **955** | CSRF, CSP, rate-limit, quotas upload, mode public, racines de chemins. |
+| **D. Routers** (`web/routers/`) | 15 | **2 500** | 14 routers montés / **39 handlers de route** (~35 routes distinctes) = surface HTTP du produit. |
+| **Headers** | 2 | 24 | `interfaces/__init__.py`(23, docstring) + `web/__init__.py`(1). |
+| **Assets** | — | **5 116** | `web-app.js`(2 483, SPA de pilotage) · `picarones.css`(1 432) · 8 templates J2 (1 201, dont `_view_benchmark`(403)/`_view_import`(374)). |
+
+**Fichiers > 400 LOC** (budget Cinoc, 5 sur 42) : `_workflows.py`(882), `benchmark_utils.py`(615), `jobs.py`(541), `models.py`(419), `cli/__init__.py`(475). Côté assets : `web-app.js`(2 483) et `picarones.css`(1 432) explosent tout budget.
+
+## 1.2 Couplages inter-couches & consommateurs réels (grep hors `tests/`)
+
+**`interfaces/` est une FEUILLE du graphe d'import** (couche 8) : **0 module interne ne l'importe**. Son unique consommateur fonctionnel est **`picarones/__main__.py:10`** (`from picarones.interfaces.cli import cli`) + l'entry-point console `pyproject.toml:141` (`picarones = picarones.interfaces.cli:cli`). Le serveur web est lancé par `cli/_serve.py:70` via `uvicorn.run("picarones.interfaces.web.app:app", …)` (chaîne d'import string, **pas** de factory).
+
+**`interfaces/` importe** (orientation **respectée** : que des couches internes — toutes légales) :
+
+| Vers | Symboles principaux | Cluster |
+|---|---|---|
+| `domain` | `pipeline_spec.PipelineMode`, `errors` | B (models) |
+| `formats` | `text.normalization.NormalizationProfile` | A (`_normalization_arg`), D (`normalization`) |
+| `evaluation` | `corpus.load_corpus_from_directory`, `metrics.{text,normalization,history,robustness}`, `synthetic` | A, B, D (`history`,`normalization`) |
+| `pipeline` | `llm_pipeline_config.OCRLLMPipelineConfig` | B (benchmark_utils) |
+| `adapters` | `ocr.factory.ocr_adapter_from_name`, `llm.*`, **`corpus.{iiif,gallica,escriptorium,htr_united,huggingface}`**, `corpus._http.validate_http_url` | A, B, D (importeurs) |
+| `app` | **`services.{RunOrchestrator, prepare_preset_args, run_result_to_benchmark_result}`**, `services.path_security.*` | A (`_workflows`), B (benchmark_utils, _path_helpers), C (security_paths) |
+| `reports` | **`html.generator.ReportGenerator`**, `html.comparison.{compare_benchmarks,…}`, **`narrative.build_synthesis`** | A, B, D (synthesis) |
+
+> **Pattern consommateur clé (la dette à éliminer)** : le seul flux « lancer un run » (`benchmark_utils.run_benchmark_thread_v2` `:516-560` ; `_workflows._run_orchestrator_for_cli` `:25-92`) fait **`prepare_preset_args → execute_preset → run_result_to_benchmark_result → ReportGenerator(BenchmarkResult)`**. En Cinoc (format unique `RunResult`, reports le lit direct, ANA-7) **la conversion ET le générateur Jinja2 legacy disparaissent** : interfaces appellera `evaluation/runner` (→`RunResult`) puis le `ReportRenderer` (lit `RunResult`).
+
+## 1.3 Les dettes centrales (vérifiées dans le code)
+
+| # | Dette | Preuve |
+|---|---|---|
+| **D-α** | **Conversion double-format à la frontière** (cf. 1.2). CLI + web la portent tous deux. | `benchmark_utils.py:546,558` ; `_workflows.py:86,599` ; `cli/__init__.py:311,403` |
+| **D-β** | **Deux frontends distincts à ne pas confondre** : (1) le **rapport généré** (couche 7, Jinja2 + 3 423 JS) ; (2) la **SPA de pilotage** (couche 8 : `web-app.js` 2 483 + `picarones.css` 1 432 + 8 templates) servie par `home.py:53 GET /`. La couche 8 = la SPA de pilotage (lancer/suivre/importer), pas le rapport. | `home.py:41-57` ; `static/web-app.js` ; `templates/base.html.j2` |
+| **D-γ** | **Doublon de job store** : `web/jobs.py`(541, SQLite + SSE) **utilisé** vs `adapters/storage/job_store.py`(489, sans SSE) **mort côté web**. Deux SQLite *en plus* : `jobs.sqlite` (jobs) vs history DB (couche 3). | `state.py:27,138` (web→jobs.py) ; `adapters/storage/job_store.py:1-8` (« legacy exposé jusqu'au S46 ») ; `job_runner.py:55` seul consommateur de l'adapter |
+| **D-δ** | **Effets de bord à l'import** : `app = FastAPI(...)` + 14 `include_router` exécutés à l'import (`app.py:139-261`) ; `JOB_STORE = get_default_store()` **ouvre/crée SQLite à l'import** (`state.py:138`) ; `RATE_LIMITER`/`JOBS_SEMAPHORE` instanciés à l'import (`:132,135`). Viole `no-side-effect-imports` (§7). | `app.py:139` ; `state.py:132-138` |
+| **D-ε** | **Surface HTTP large** : 14 routers / 39 handlers, dont importeurs exotiques (iiif/gallica/escriptorium/htr-united/hf), narratif, longitudinal, endpoints orphelins front. | `app.py:248-261` ; carte §1.5-D |
+| **D-ζ** | **DTO couplés par copie** : `models.py:390` recopie la regex `RunSpec._DOTTED_PATH_RE` au lieu de l'importer → drift. `NormalizationProfileId`(`:56`) = `Literal` de 11 profils **codés en dur** (doit lire le registre canonique). | `models.py:56,390` |
+
+## 1.4 Constats transverses durables (vérifiés, file:line)
+
+| # | Constat | Preuve |
+|---|---|---|
+| **A** | **Couplage de couche SAIN** : interfaces = feuille, n'importe que des couches internes ; imports lourds **paresseux** (dans le corps des fonctions) pour passer le test d'archi. | `cli/__init__.py:386-389` ; imports dans les handlers |
+| **B** | **Importeurs réseau délégués à `adapters.corpus` (couche 5)** — routers iiif/gallica/escriptorium/importers appellent `IIIFImporter`/`GallicaClient`/`EScriptoriumClient`/`HTRUnited`/`HuggingFace` + `validate_http_url` (SSRF). **Aucun fetch réimplémenté** sauf `engines.py:8` (`urllib` direct → API providers, listing modèles). | `routers/iiif.py:81` ; `gallica.py:97` ; `escriptorium.py:69` ; `importers.py:30,111` ; `engines.py:117-120` |
+| **C** | **Sécurité bien factorisée, zéro duplication de logique** — 1 protection = 1 fichier ; la validation de chemin n'existe qu'une fois (`app/services/path_security.py`), `security_paths.py:20-28` la ré-exporte. Plusieurs callers court-circuitent le ré-export et importent `app.services.path_security` en direct (`_path_helpers.py:36`, `benchmark_utils.py:368`). | `security.py:48-87` (hub) ; `security_paths.py:17-28` |
+| **D** | **Mode public = barrière d'exécution de code tiers in-process** (§3) : bloque OCR/LLM cloud + **NER `entity_extractor` dynamique** (allowlist fail-closed tous modes), confine le FS. **Pas** un read-only total (upload reste permis). Le gadget réel : `_resolve_entity_extractor` (`app/.../legacy.py:106` import, `:292` appel). | `security_public_mode.py:31,78-111` ; `security_paths.py:45-46` |
+| **E** | **Annulation §12 partielle** : le web passe `cancel_event` (`benchmark_utils.py:536`) + vérifie `job.status=="cancelled"` entre docs (`:415,485,554`), mais l'orchestrateur l'**ignore hors `partial_dir`** (ANA-6 §1.5 R7). Pas de `Deadline`/`RunControl` réel. | `benchmark_utils.py:536` ; `state.py:172` (`_cancel_event`) |
+| **F** | **`except Exception` = 28 occurrences**, mais **aucun `: pass` nu** (tous `raise`/`HTTPException`/`logger.warning`). Seule survivance : `routers/normalization.py:109 except OSError: pass` (cleanup temp `# pragma: no cover`). `no-broad-except` (§7) les signalera tout de même. | grep ; `normalization.py:109` |
+| **G** | **Sécurité HTTP réelle et testée** : CSRF double-submit+HMAC (`security.py:285-397`), CSP+headers durcis (`security_csp.py:88`), rate-limit maison in-memory (`security_rate_limit.py:47`, **pas slowapi**), quotas+Pillow streamés (`security_uploads.py`), confinement chemins partout. Fail-fast démarrage (`check_deployment_coherence`/`validate_csrf_config`). | cf. cluster C |
+| **H** | **Fragilités sécurité notables** : CSP `'unsafe-inline'` script+style (~30 `onclick` inline, `security_csp.py:59-60`) ; rotation CSRF documentée mais non implémentée (`security.py:389`) ; secret CSRF runtime non partagé multi-worker ; rate-limit non distribué + fuite mémoire lente des IP inactives ; **asymétrie rate-limit** (iiif/gallica/escriptorium bornés, importers/engines NON). | `security_csp.py:59` ; `security.py:389` ; `security_rate_limit.py:51-70` |
+| **I** | **Doc/réfs périmées massives** : « 11 routers » (`app.py:14,23`, `routers/__init__.py`) vs 14 réels ; `POST /api/benchmark/start` supprimé mais cité (`__init__.py:18`) ; `measurements.normalization` (paquet **supprimé**, `models.py:66`) ; `run_benchmark_thread`/`_JOBS`/`BaseOCREngine` (symboles disparus) ; 3 conseils utilisateur morts CLI (`--save-history`, `info --normalization-profiles`, sous-groupe `pipeline`) ; annotations `Sprint S/Phase` omniprésentes ; `_b3_final_options` docstring mensongère (`_workflows.py:407`). | `app.py:14` ; `models.py:66` ; `_history.py:126` ; `_normalization_arg.py:77` ; `_robustness.py:193-199` |
+
+## 1.5 Verdicts par fichier — **PROVISOIRE — à confirmer au build**
+
+> Légende : **G** garder (concept ~tel quel) · **M** modifier (concept gardé, forme revue/dégonflée/splittée) · **C** changer de couche · **S** supprimer · **I** incrémental (rebâti à la tranche qui le consomme, pas avant).
+> Principe directeur : l'**enveloppe** (app factory, contrat de sortie, sécurité, contrat de commande) est plein-scope **maintenant** ; la **surface** (commandes/routes/SPA) grossit **par tranches**. La plupart des routers/commandes ne sont **pas portés** : ils sont **rebâtis incrémentalement** quand leur tranche arrive.
+
+### Cluster A — CLI (2 018 LOC)
+| Fichier | LOC | Rôle réel vérifié | Verdict PROVISOIRE + raison |
+|---|---:|---|---|
+| `cli/__init__.py` | 475 | groupe Click racine (`:128`) + commandes `metrics/engines/info/report/demo` + helpers (`_setup_logging`, `_engine_from_name`, catalogue moteurs) | **M** — garder le groupe racine + `report`/`demo` (cœur 5) ; `metrics/engines/info` = introspection **hors 5** → démarrer **non portées** (pas de conso = supprimé), réintroduire si besoin réel ; purger sprints, source de version unique (§7), split <400 |
+| `cli/_workflows.py` | 882 | `run`(`:132`) + `diagnose/economics/edition`(profils figés) + `compare`(`:792`) + la **chaîne de conversion** (`_run_orchestrator_for_cli` `:25`) | **M+S (split)** — **garder `run`+`compare`** ; **SUPPRIMER `diagnose/economics/edition`** (§8.4) ; la conversion `→BenchmarkResult` **disparaît** (appeler `ReportRenderer(RunResult)`) ; tuer `_b3_final_options` (menteur) + dédup options ; split <400 |
+| `cli/_serve.py` | 75 | commande `serve` → `uvicorn.run(".../app:app")` (`:70`) | **G (concept)** — garder `serve` ; **lancer via factory `create_app()`** (pas de singleton module-level) ; warning sur `--host 0.0.0.0` |
+| `cli/_normalization_arg.py` | 96 | helper `resolve_normalization_profile` (id builtin OU YAML), conso par `run` | **G (concept)** — utile à `run` ; corriger le conseil mort (`info --normalization-profiles`) ; **lire le registre canonique** (couche 2/3), pas une liste figée |
+| `cli/_imports.py` | 120 | groupe `import` + sous-commande `import iiif` | **I** — hors cœur 5 ; import corpus = surface → rebâti à la **tranche importeurs**, pas avant |
+| `cli/_history.py` | 171 | commande `history` → `evaluation.metrics.history` | **I** — hors cœur 5 ; longitudinal → tranche dédiée (store tidy `adapters/storage`) |
+| `cli/_robustness.py` | 199 | commande `robustness` (images dégradées) | **I/S** — hors cœur 5 ; commentaires fantômes (sous-groupe `pipeline` inexistant) **non portés** |
+
+### Cluster B — cœur web (3 434 LOC)
+| Fichier | LOC | Rôle réel vérifié | Verdict PROVISOIRE + raison |
+|---|---:|---|---|
+| `web/app.py` | 261 | singleton `FastAPI`(`:139`) + lifespan + 4 middlewares + 14 routers | **M** — **factory `create_app()`** (zéro effet de bord à l'import, §7) ; ne monter que les routers de la tranche courante ; **drop `synthesis`** ; <400 |
+| `web/state.py` | 337 | singletons (`RATE_LIMITER`/`JOBS_SEMAPHORE`/**`JOB_STORE`**), dataclass `BenchmarkJob`, registre `JOBS`+lock | **M** — **pas de `JOB_STORE` au niveau module** (§7) ; `BenchmarkJob`/annulation → brancher **`RunControl`/`Deadline`** (§12) ; le store descend en `adapters/storage` (couche 5) |
+| `web/models.py` | 419 | 9 DTO Pydantic de transport HTTP | **G (concept « DTO web ») + M** — transport en couche 8 (backlog) ; **ne pas dupliquer `RunSpec`** (importer types/regex canoniques, ANA-6) ; DTO d'importeurs exotiques → à leur tranche ; corriger `measurements` ; profils via registre |
+| `web/jobs.py` | 541 | job store SQLite **+ SSE/`job_events`** (`:80-92`) ; `get_default_store` (`:525`) | **C → `adapters/storage` (couche 5)** — store unique ; **conserver la capacité événements/SSE** que la réécriture actuelle a perdue (affinement §0) |
+| `web/benchmark_utils.py` | 615 | `run_benchmark_thread_v2` = worker threadé + **site de conversion** (`:516-560`) | **M (éviscérer)** — garder le **worker** (jobs `serve`) ; supprimer `→BenchmarkResult` + `ReportGenerator` legacy ; appeler `evaluation/runner`(RunResult) + `ReportRenderer` ; brancher annulation réelle ; split <400 |
+| `web/corpus_utils.py` | 362 | `flatten_zip_to_dir`(anti-bombe) + `analyze_corpus_dir` | **M/recoupe ANA-6** — défenses ZIP partagées avec `app.corpus_service` (couche 6, `app`/`adapters/corpus` à confirmer) ; web **appelle**, ne réimplémente pas ; <400 |
+| `web/engine_utils.py` | 238 | statut moteurs + listing modèles (helpers) | **M** — statut moteurs = **introspection du registre** (couche app) ; listing modèles via réseau = surface optionnelle |
+| `web/observability.py` | 212 | logging JSON + `/metrics` Prometheus | **M/I** — garder un logging structuré **mince** ; `/metrics` opt-in → tranche ops |
+| `web/maintenance.py` | 207 | tâche de maintenance (nettoyage disque) | **I/S** — hors cœur ; rebâti si un consommateur réel l'exige |
+| `web/_path_helpers.py` | 101 | wrappers `validated_user_output_dir/path` sur `app.path_security` | **M/absorber** — wrappers fins ; utiliser `app/security` directement |
+| `web/_import_guards.py` | 84 | garde-fous import (mode public : caps résolution/pages) | **M** — replier dans le package sécurité (mode public) ; surface liée à la tranche importeurs |
+| `web/config_utils.py` | 57 | schéma/migration de la config UI client | **I/S** — persistance config UI = surface ; pas de consommateur cœur |
+
+### Cluster C — sécurité web (955 LOC) → **UN package `security/` en couche 8** (§8.5)
+| Fichier | LOC | Rôle réel vérifié | Verdict PROVISOIRE + raison |
+|---|---:|---|---|
+| `web/security.py` | 397 | hub de ré-export + **CSRF** (double-submit+HMAC, `:285-397`) + fail-fast déploiement | **M (split)** — drop la **façade de ré-export** ; **CSRF → module dédié** du package ; implémenter la rotation (doc≠code `:389`) ; résoudre le secret multi-worker |
+| `web/security_public_mode.py` | 122 | mode public : allowlists moteurs/LLM/**NER dynamique** | **G (ENVELOPPE)** — porter **fidèlement** ; c'est la barrière « code tiers in-process » (§3) → **liée au registre de modules** (couche app) |
+| `web/security_csp.py` | 112 | middleware CSP + headers durcis | **G** — porter ; viser à **retirer `'unsafe-inline'`** (supprimer les `onclick` inline avec la refonte SPA) |
+| `web/security_uploads.py` | 137 | quotas (unitaire/total) + validation Pillow streamée | **G** — porter ; surface liée à la tranche upload |
+| `web/security_paths.py` | 101 | racines autorisées + **ré-export** validation chemin (depuis `app`) | **M** — garder le calcul des **racines** (HTTP) ; importer la **validation** depuis `app/security` directement (drop le shim de ré-export) |
+| `web/security_rate_limit.py` | 86 | `RateLimiter` maison + concurrence | **G (concept)** — porter ; corriger la fuite mémoire IP inactives ; documenter la limite multi-worker (ou store partagé) |
+
+### Cluster D — routers (2 500 LOC) → **rebâtis par tranches**
+| Router | LOC | Routes (méthode/chemin) | Couche appelée | Verdict PROVISOIRE |
+|---|---:|---|---|---|
+| `benchmark.py` | 288 | `POST /api/benchmark/run` · `GET …/status` · `POST …/cancel` · `GET …/stream`(SSE) | app(6)→eval/pipeline ; reports(7) | **G (CŒUR)** — `run` HTTP ; SSE gardé ; brancher `RunControl` ; conversion éviscérée |
+| `corpus.py` | 293 | browse/upload/uploads/image/delete | corpus_utils + security | **G (CŒUR `serve`)** — très défensif ; <400 |
+| `home.py` | 57 | `GET /` (SPA shell) | jinja2 + state | **G (minimal)** — shell de pilotage **mince** (pas la lourde SPA) |
+| `reports.py` | 114 | `GET /api/reports` · `GET /reports/{f}` | security (racines) | **G** — listing/service du HTML généré |
+| `system.py` | 218 | health/status/csrf/metrics/lang | security + state | **M** — garder health/status/csrf ; **drop lang(×2)+metrics orphelins** (tranche ops) ; <400 |
+| `engines.py` | 348 | `GET /api/engines` · `GET /api/models/{provider}` | engine_utils + **urllib direct** | **M** — `engines` = introspection registre ; **modèles via réseau = surface** ; rate-limit manquant ; <400 |
+| `normalization.py` | 120 | profils + preview | eval(3)/formats(2) | **M** — garder `profiles` (registre) ; **drop `preview` orphelin** |
+| `config.py` | 75 | save/load config UI | config_utils | **I/S** — surface confort UI |
+| `synthesis.py` | 110 | `GET …/synthesis_preview` | **`reports.narrative`** | **S** — narratif supprimé (§6) : router+route+encart UI |
+| `history.py` | 262 | runs/curve/engines/corpora/regressions | **`evaluation.metrics.history`(3)** | **I** — longitudinal → tranche dédiée (SQLite séparée) |
+| `importers.py` | 139 | htr-united + huggingface (4 routes) | adapters.corpus(5) | **I** — tranche importeurs |
+| `iiif.py` | 159 | preview + import | adapters.corpus.iiif(5) | **I** — tranche importeurs |
+| `gallica.py` | 182 | search + import | adapters.corpus.gallica(5) | **I** — tranche importeurs |
+| `escriptorium.py` | 115 | import | adapters.corpus.escriptorium(5) | **I** — tranche importeurs |
+| `routers/__init__.py` | 20 | doc | — | **M** — mince, doc vraie |
+
+### Assets (5 116 LOC)
+| Asset | LOC | Verdict PROVISOIRE + raison |
+|---|---:|---|
+| `static/web-app.js` | 2 483 | **S majoritaire / rebâtir minimal** — SPA de pilotage (routing/i18n/charts client). Garder un **panneau de pilotage mince** pour `serve` ; pas de routeur SPA lourd. *(périssable)* |
+| `static/picarones.css` | 1 432 | **M** — style mince (tableaux/formulaires) ; <400 par fichier si splitté |
+| `templates/*.j2` (8) | 1 201 | **M/S** — garder un `base` + 1-2 partials du flux `run` ; les vues import/history/engines → à leur tranche |
+
+---
+
+# PARTIE 2 — RÉORGANISATION CIBLE Cinoc (périssable — « à confirmer à la tranche »)
+
+> ⚠️ Périssable : le contact du code amont (evaluation/pipeline/adapters/app non encore implémentés) corrigera ces formes. **On ne construit PAS `interfaces` de haut en bas** : l'**enveloppe** (factory, contrat de commande, sécurité, contrat de sortie) naît au squelette ambulant ; les **commandes/routes** se remplissent **une par tranche**.
+
+## 2.1 Rôle d'`interfaces` en Cinoc & les deux axes
+
+`interfaces` est une **couche de transport mince** : parse arguments/requêtes → appelle un service `app` → retourne une réponse. **Aucun calcul, aucune orchestration, aucune conversion de format.** C'est la frontière la plus externe (in-process pour les modules tiers → la sécurité y est une exigence d'enveloppe).
+
+| Axe | Contenu `interfaces` | Quand |
+|---|---|---|
+| **Enveloppe (plein-scope, maintenant)** | **factory `create_app()`** (zéro effet de bord) ; **contrat de commande CLI** (le groupe + les 5 verbes nommés) ; **package `security/` HTTP** (CSRF/CSP/rate-limit/uploads/**mode public**) importé sur l'enveloppe ; **DTO de transport** typés ; SSE + annulation coopérative branchées sur `RunControl` | conçu au squelette |
+| **Surface (incrémentale, élaguée)** | quelles commandes effectives (`demo`→`run`→`compare`→`serve`/`report`) ; quels routers (benchmark/corpus/reports/home d'abord) ; quels importeurs ; la SPA de pilotage ; longitudinal/observabilité | une tranche à la fois |
+
+**Whitelist CLI (§8.4)** : `run`, `report`, `compare`, `demo`, `serve`. Tout le reste (`diagnose/economics/edition/robustness/import/history/metrics/engines/info`) = **non porté d'office** ; réintroduit seulement si une tranche lui donne un consommateur réel.
+
+## 2.2 Où va chaque concept Picarones (table de transfert)
+
+| Concept Picarones (`interfaces`) | Destination Cinoc | Note |
+|---|---|---|
+| groupe CLI + `run/report/compare/demo/serve` | **`interfaces/cli`** | 5 verbes ; lazy-imports conservés (archi) |
+| `diagnose/economics/edition` (profils figés) | **SUPPRIMÉ** | §8.4 |
+| `_run_orchestrator_for_cli` + `run_benchmark_thread_v2` (chaîne conversion) | **`interfaces`** appelle **`app.orchestrator`** → **`evaluation/runner`** (RunResult) + **`ReportRenderer`** | la conversion `→BenchmarkResult` + `ReportGenerator` legacy **disparaissent** |
+| `web/app.py` (singleton) | **`interfaces/web/app.py`** : **`create_app()`** | zéro effet de bord à l'import |
+| `web/jobs.py` (SQLite **+ SSE**) | **`adapters/storage`** (couche 5) | store unique ; **garder les événements/SSE** ; web l'appelle |
+| `web/state.BenchmarkJob` + annulation | **`interfaces/web`** | brancher **`RunControl`/`Deadline`** (couche 4, §12) |
+| `web/models.py` (DTO transport) | **`interfaces/web`** | ne pas dupliquer `RunSpec` (réf. canonique) |
+| `security_*` (CSRF/CSP/rate-limit/uploads/mode public) | **`interfaces/web/security/`** (UN package) | §8.5 |
+| `security_paths` (validation chemin) | **`app/security/`** (couche 6, déjà décidé ANA-6) | interfaces l'**importe** |
+| `corpus_utils` (ZIP/analyse) | **`app`** ou **`adapters/corpus`** | recoupe ANA-6 (à confirmer) |
+| importeurs (iiif/gallica/escriptorium/htr/hf) | **adapters.corpus(5)** appelés par routers minces | à la **tranche importeurs** |
+| `routers/synthesis` + narratif | **SUPPRIMÉ** | §6 |
+| `routers/history` + `cli history` | **tranche longitudinale** (store tidy `adapters/storage`) | différé |
+| SPA `web-app.js`/CSS/templates | **panneau de pilotage mince** | surface, périssable |
+| docs/réfs périmées, sprints, conseils morts, doublons | **SUPPRIMÉ** | §7-8 |
+
+## 2.3 Esquisse d'arborescence cible (à confirmer en codant)
+
+```
+cinoc/interfaces/
+├── __init__.py            mince, docstring vraie, zéro effet de bord
+├── cli/
+│   ├── __init__.py        groupe Click racine (zéro import lourd à l'import)
+│   ├── run.py             run (+ helper d'appel à app.orchestrator)
+│   ├── report.py          report / compare (lit RunResult, ReportRenderer)
+│   ├── demo.py            demo (squelette : corpus pré-calculé → RunResult → HTML)
+│   └── serve.py           serve → uvicorn.run(create_app())   [factory, pas singleton]
+└── web/
+    ├── app.py             create_app() : monte routers de la tranche, middlewares sécurité
+    ├── models.py          DTO de transport (réf. types canoniques, pas de copie)
+    ├── jobs.py(?)         coquille SSE qui parle au JobStore d'adapters/storage
+    ├── security/          __init__ · csrf.py · csp.py · rate_limit.py · uploads.py · public_mode.py
+    └── routers/           benchmark.py · corpus.py · reports.py · home.py (squelette)
+```
+*(Tous < 400 LOC. Pas de `JOB_STORE` au niveau module, pas de façade de ré-export, pas de `synthesis`, pas d'importeurs avant leur tranche, SPA minimale.)*
+
+## 2.4 Apparition par tranches (≠ couche complète)
+
+| Tranche (cf. ANA-6 §2.4, MIG-3 §15) | Ce que `interfaces` matérialise alors |
+|---|---|
+| **1. Squelette `demo`** (corpus pré-calculé → 1 CER → `RunResult` → HTML) | `create_app()` minimal + **commande `demo`** + 1 route (`reports`/`home`) sur le **contrat de sortie définitif** (RunResult→ReportRenderer). Prouve que la coquille de transport tient, **sans conversion ni serveur complet**. |
+| **2. Épaississement texte** (`run`, `compare`) | commandes `run`/`compare` ; loader spec ; sécurité chemins via `app/security` |
+| **3. `serve`** | `create_app()` complet + routers `benchmark`(SSE)/`corpus` + **package `security/`** (CSRF/CSP/rate-limit/uploads/**mode public**) + **annulation `RunControl`** + JobStore (adapters/storage) + panneau de pilotage mince |
+| **4. importeurs / longitudinal / observabilité** | routers iiif/gallica/escriptorium/importers (→adapters), `history`, `/metrics` — **chacun à sa tranche, avec un consommateur réel** |
+
+## 2.5 Les 5 garde-fous appliqués
+
+1. **Rupture nette, zéro shim** : 1 seul format (`RunResult`) ; **pas** de `run_result_to_benchmark_result`, **pas** de `ReportGenerator` Jinja2 legacy, **pas** de façade de ré-export sécurité, **pas** de `web/jobs.py` parallèle à `adapters/storage`.
+2. **Budgets < 400** : `_workflows`(882)/`benchmark_utils`(615)/`jobs`(541)/`cli/__init__`(475)/`models`(419) **doivent** être splittés ; `web-app.js`/CSS refondus minces.
+3. **Pas de consommateur = supprimé** : `diagnose/economics/edition`, `synthesis`, importeurs exotiques, endpoints orphelins (`lang`,`metrics`,`history/curve`,`normalization/preview`), conseils CLI morts → **non créés** tant qu'une tranche ne les réclame.
+4. **Tests d'archi jour 1** : `layer-deps` (interfaces n'importe que des couches internes) ; **`no-side-effect-imports`** (pas de `app=FastAPI()` ni `JOB_STORE` au niveau module → **factory**) ; `file-budgets` ; `no-broad-except` (les 28 `except Exception` → `logger.warning` ciblés) ; **tests sécurité obligatoires** (CSRF/CSP/path-traversal/upload/mode public).
+5. **Une commande/route = entière, en budget, en élaguant** : ajoutée avec sa tranche, testée, sans annotation de sprint ni doc périmée.
+
+---
+
+# PARTIE 3 — RISQUES DE TRANSFERT & DETTES (+ détection)
+
+| # | Risque / dette | Détection | Désamorçage |
+|---|---|---|---|
+| **R1** | **Reporter la conversion `RunResult→BenchmarkResult`** « le temps de migrer » (CLI ou web) | `test_no_legacy_imports` (interdire `run_result_to_benchmark_result`, `benchmark_result`, `html.generator`) ; revue : tout handler lit `RunResult` | interfaces appelle `evaluation/runner` + `ReportRenderer` direct ; conversion **inexistante** |
+| **R2** | **Effet de bord à l'import** (`app=FastAPI()` + 14 routers + `JOB_STORE=get_default_store()` au niveau module) | **`test_no_side_effect_imports`** (importer `interfaces.web.app` n'ouvre aucune SQLite, ne monte rien) | **`create_app()`** factory ; store injecté ; singletons créés dans la factory |
+| **R3** | **Reconstruire la lourde SPA** (2 483 JS + routeur client + charts client) — « rapport-application » côté pilotage | revue : panneau mince ; pas de routeur SPA ; pas de charting client | shell HTML minimal ; le **rapport** (couche 7) reste un document factuel SVG-serveur (ANA-7 R5) |
+| **R4** | **Surface CLI/HTTP recopiée en bloc** (14 commandes / 14 routers d'office) | « pas de conso = supprimé » ; whitelist 5 verbes (§8.4) ; chaque route a une tranche | 1 commande/route par tranche ; importeurs/longitudinal différés |
+| **R5** | **Sécurité affaiblie au portage** (CSRF/CSP/path-traversal/upload/mode public) | tests obligatoires : token CSRF manquant → 403 ; `..`/symlink → rejet ; zip-bomb/octet-nul → échec ; moteur cloud en mode public → `PermissionError`→403 | porter le package `security/` **fidèlement, testé d'abord** ; corriger rotation CSRF + secret multi-worker |
+| **R6** | **Exécution de code tiers non bornée** : `entity_extractor`/plugins in-process sans allowlist (le mode public est la barrière, §3) | revue : allowlist **fail-closed** ; le registre de modules (couche app) impose `version` + provenance | porter `assert_*_allowed` ; **mode public ⇒ in-process tiers verrouillé** ; pas de dotted-path arbitraire |
+| **R7** | **Annulation/timeout fantômes** (Picarones passe `cancel_event` mais l'orchestrateur l'ignore hors `partial_dir`) | test : un `cancel` **interrompt** réellement un job en cours ; un `Deadline` dépassé stoppe | brancher **`RunControl`/`Deadline`** (couche 4) de bout en bout (job worker → runner) |
+| **R8** | **Perdre le SSE en consolidant le job store** (la réécriture `adapters/storage` a abandonné `job_events`/`Last-Event-ID`) | golden SSE : reprise `Last-Event-ID` rejoue les events `seq>last` ; test reconnexion | le JobStore canonique (couche 5) **porte les événements** ; web = coquille SSE mince |
+| **R9** | **DTO couplés par copie** (regex `RunSpec`, liste de profils figée) → drift | test : DTO référence les types/registres canoniques ; pas de `Literal` codé en dur de profils | importer `PipelineMode`/regex/registre normalisation depuis les couches sources |
+| **R10** | **`except Exception` recopiés** (28 occurrences) | **`test_no_broad_except`** ; grep `except Exception`/`except: pass` | `logger.warning("[module] dégradé : %s", e)` ciblé (§7) ; supprimer `normalization.py:109 except OSError: pass` |
+| **R11** | **Budgets explosés** (`_workflows`/`benchmark_utils`/`jobs`/`cli/__init__`/`models`) | `test_file_budgets` strict | splitter dès l'écriture (1 verbe/fichier, 1 protection/fichier) |
+| **R12** | **Doc/réfs périmées recopiées** (« 11 routers », `start`, `measurements`, sprints, conseils morts) | grep anti-narration ; `test_no_legacy_imports` | « garder le pourquoi, jeter la datation » ; docstrings vraies au moment du port |
+| **R13** | **Mauvais placement sécurité** : dupliquer la validation de chemin en `interfaces` au lieu de l'importer d'`app/security` | `test_layer_deps` + revue : 1 seule implémentation de `validated_path` | sécurité HTTP en couche 8 ; validation chemin en couche 6, **importée** (§0 affinement 2) |
+| **R14** | **Asymétrie/oubli de rate-limit** sur routes réseau (importers/engines non bornés dans la source) | revue : toute route déclenchant du réseau sortant passe par le limiteur | rate-limit homogène ; réseau provider (engines) borné + limité |
+| **R15** | **Réintroduire un singleton `app`** par confort uvicorn (`"...:app"`) | `test_no_side_effect_imports` ; `serve` appelle `create_app()` | uvicorn reçoit la factory (`--factory` / callable), jamais un module-level `app` |
+
+---
+
+## Résumé pour la future session de CONSTRUCTION (3-5 points)
+
+1. **`interfaces` = transport mince, et une FEUILLE** : 0 consommateur interne, 1 seul point d'entrée (`__main__`/console-script). Elle **n'orchestre pas, ne calcule pas, ne convertit pas** : elle appelle `app`, qui appelle `evaluation/pipeline`. **La chaîne `prepare_preset_args → run_result_to_benchmark_result → ReportGenerator` (présente identiquement en CLI ET web) DISPARAÎT** : on appelle `evaluation/runner`(→`RunResult`) puis le `ReportRenderer` qui lit `RunResult` direct (cohérent ANA-6/ANA-7).
+2. **L'ENVELOPPE à figer au squelette, plein-scope** : (a) **`create_app()` factory** — zéro effet de bord à l'import (aujourd'hui `app=FastAPI()` + 14 routers + `JOB_STORE=get_default_store()` ouvrent SQLite à l'import → interdit §7) ; (b) **contrat de commande** = les 5 verbes `run/report/compare/demo/serve` (§8.4), le reste non porté ; (c) **package `security/` HTTP** en couche 8 (CSRF/CSP/rate-limit/uploads/**mode public**) qui **importe** la validation de chemin d'`app/security` (couche 6, ANA-6) — pas de duplication ; (d) **annulation `RunControl`/`Deadline`** + **SSE** branchés réellement.
+3. **Surface incrémentale, jamais d'avance** : tranche 1 (`demo`) = `create_app()` minimal + commande `demo` + route `reports`/`home` sur le contrat de sortie définitif. Puis `run`/`compare`, puis `serve` (benchmark SSE + corpus + sécurité complète), puis **importeurs/longitudinal à leur tranche** (iiif/gallica/escriptorium/htr/hf délèguent déjà proprement à `adapters.corpus` couche 5 — couplage sain à préserver).
+4. **Suppressions nettes** : `synthesis.py` + narratif (§6) ; `diagnose/economics/edition` (§8.4) ; le doublon `web/jobs.py` (→ `adapters/storage` **en gardant le SSE/events** que la réécriture actuelle a perdu) ; la façade de ré-export `security.py` ; la lourde SPA de pilotage (panneau mince) ; endpoints orphelins + conseils CLI morts + docs périmées (« 11 routers », `start`, `measurements`).
+5. **Invariants à porter fidèlement et tester EN PREMIER** : sécurité HTTP (CSRF/CSP/path-traversal/upload) **et** la barrière d'exécution **code tiers in-process** = le **mode public** (allowlist fail-closed moteurs/LLM/NER, §3) ; annulation/timeout coopératifs réels (§12) ; déterminisme du rendu (le HTML vient de `RunResult`, pas d'un état serveur). Budgets <400, zéro effet de bord à l'import, `no-broad-except`.
+
+## DoD vivante (couche 8) — **autorité de détail** ; le `MIGRATION_PLAN.md` indexe
+
+> **S7.a (D-074)** : CLI `run --csv` + sous-commande `history` (série/régressions) ; `GET /api/normalization/profiles` dynamique. Preuves : `tests/interfaces/test_cli_history.py` · `web/test_engines_api.py`.
+
+> Tri-état : `[x]` fait **+ preuve** · `[ ]` à faire · `[~]` différé/réserve + raison.
+> Maj dans le **même commit** que le code. **Statut : 🔨 T4f (TU2.a→d faites)** — vitrine + sécurité HTTP + **`serve`** + packaging Docker/Space (read-only) [T4e] ; **lanceur (TU2.a)** : `POST/GET/cancel /api/runs` → `JobRunner` (couche 6, thread + annulation) → `JobStore` (couche 5) → `RunResult` écrit, **CSRF** ; **Moteurs (TU2.b)** : `GET /api/engines` (dispo/indispo, sondes injectables) ; **upload corpus (TU2.c)** : `POST/GET /api/corpus` → `CorpusStore`+`extract_corpus_zip` (ingestion durcie : anti-traversal/anti-bombe/quotas/dédup/magic bytes) ; **sélection moteur + gardes HTTP (TU2.d)** : `POST /api/runs {engine, corpus_id}` → 422 inconnu · **403 cloud en mode public** · 422 LLM autonome · 404 corpus · 409 indispo · build `precomputed`(démo)/`tesseract`(sur corpus) ; **SSE (TU2.e)** : `GET /api/runs/{id}/events` + reprise `Last-Event-ID` (R-10 levé) ; **page « Banc d'essai » (TU2.f.1)** : `GET /benchmark` (base Jinja partagée `base.html` + `home.html`/`benchmark.html`) + **JS auto-hébergé** (`static/js/benchmark.js`, vanilla) qui lance la démo (`fetch` POST + CSRF) et suit la progression en **EventSource (SSE)** → lien rapport ; **CSP ouverte** à `script-src 'self'` + `connect-src 'self'` (1ᵉʳ consommateur navigateur). **page « Moteurs » (S2.2a)** : `GET /engines` — **100 % rendu serveur**, table d'état lue côté serveur (`app.engines`), nav vivante. **UI upload/sélection (S2.2b)** : `/benchmark` rend un `<select>` moteur **côté serveur** (options testables, indispo désactivées) + input fichier ; `benchmark.js` fait l'upload (`POST /api/corpus`, multipart+CSRF) puis lance `POST /api/runs {engine, corpus_id}` (messages d'erreur serveur 403/409/404/422 affichés). **S2 complet.** **S6.a importeurs distants** : `POST /api/corpus/import/{iiif,escriptorium,gallica}` (JSON DTO strict, **CSRF**) → helper `_materialize(builder)` → `CorpusStore.materialize` (couche 6, registre **agnostique de la source** — les 3 importeurs partagent le même seam) → corpus **immédiatement run-sélectionnable** (`GET /api/corpus/{id}`). **Gate mode public = 403** (fetch d'URL côté serveur = surface SSRF, comme les moteurs cloud) ; `SsrfError`/`HttpFetchError`/`CorpusImportError`/`GallicaArkError`→422. Token eScriptorium dans le corps (Space privé), jamais journalisé. — *preuves : `tests/interfaces/web/test_corpus_import_api.py` (par importeur : ok+sélectionnable · mode public 403 · erreur source 422 · corps invalide 422 ; **+** Gallica ARK malformé → 422 par le vrai chemin, sans réseau ; sans CSRF 403)*. **S6 Historique** : `HistoryStore` SQLite par app (sous `catalog_dir`), alimenté par le `JobRunner` après chaque run terminé (**best-effort** : un échec d'écriture ne fait pas échouer le run) ; `build_history_router` expose `GET /api/history/series` (chronologie pipeline/vue/métrique) + `GET /api/history/regressions` (dégradation 2 derniers runs) — **lecture seule** (pas de CSRF, pas de réseau → rien à gater). — *preuves : `tests/app/test_history_recording.py` (run démo réel → enregistré → requêtable ; historique optionnel), `tests/interfaces/web/test_history_api.py` (série chronologique · régression · `view` requis 422 · monté dans `create_app`)*. **page « Historique » (S6)** : `GET /history` — **100 % rendu serveur** (aucun JS), section Régressions (par (vue,métrique) enregistrée) + Journal des mesures (le plus récent d'abord, via `HistoryStore.all_records`), nav vivante, FR/EN ; `home.py` gagne `history_store`. — *preuves : `tests/interfaces/web/test_history_page.py` (journal trié récent→ancien · régression `0.10→0.15` affichée · 0 `<script>` + nav active · EN · vide via `create_app` · lien vivant depuis l'accueil)*. **page « Bibliothèque » (S6 découverte)** : `GET /library` — **100 % rendu serveur** (aucun JS), formulaire de recherche (`?q=`), section HTR-United (`fetch_catalogue` → réseau + repli démo `is_demo` badge) + section HuggingFace (`HuggingFaceCatalogue().search` réf + API best-effort), liens externes `rel=noopener`, FR/EN. *Découverte best-effort, jamais bloquante hors-ligne ; cache des catalogues = incrémental.* — *preuves : `tests/interfaces/web/test_library_page.py` (HTR+HF listés · badge démo · requête transmise à la recherche + réaffichée · 0 `<script>` + nav active · EN · lien vivant accueil)*. Reste S6 : form UI imports au design + segmentation-UI. Reste aussi : **S3** persistance · run tesseract réel (test `live`) · déploiement HF. ⚠️ JS navigateur **non testé en CI** (pas de navigateur) : vérifs serveur + `node --check` + API sous-jacentes testées ; rendu/interaction à confirmer au déploiement.
+
+**Enveloppe :**
+- [x] **Contrat de commande CLI** (`argparse`, D-007) — verbes **`demo`** + **`run`** (YAML → orchestrateur → rapport) câblés, console-script `cinoc`. — *preuve : `test_cli_demo` + `test_cli_run` (bout en bout)*
+- [x] **`compare`** (2 RunResult JSON → deltas `B − A`) + **`run --json`** (export du RunResult). — *preuve : `test_cli_compare` + `test_results_io` (round-trip)*
+- [x] **`serve`** (commande) — uvicorn reçoit la **factory** (`...app:create_app`, `factory=True`), jamais un app de module ; uvicorn = **import paresseux** (extra `[serve]` absent → message clair + code 1) ; **avertissement** si `--host` ≠ local (exposition réseau) ; `--reports-dir` → `CINOC_REPORTS_DIR`. — *preuve : `test_cli_serve` (factory ; warning `0.0.0.0` ; env ; extra manquant)*
+- [ ] `report` (rendre un JSON sauvé en CLI) — différé (la vitrine web couvre le besoin de rendu).
+- [x] **Vitrine web** (« montrer les rapports sans clés ») : `GET /api/reports` (liste triée) · `GET /reports/{name}` (rend le `RunResult` sauvé en HTML **à la demande** — format unique, rendu déterministe) · `GET /` (accueil **mince**, pas de SPA). **Sécurité chemins** via `validated_path` (couche 6) : traversal → 404 sans fuite. Routeurs = **fonctions builder**. — *preuve : `test_vitrine` (liste/rendu/404/traversal/accueil) + `no_side_effect_imports`*
+- [x] **`create_app()` factory** — zéro effet de bord à l'import : `FastAPI()` construit **dans** la factory (jamais au niveau module), routers à venir = **fonctions builder** (`APIRouter()` interdit au module par le gate). Deps `fastapi`/`uvicorn` en **extra `[serve]`** (CLI reste léger). — *preuve : `tests/interfaces/web/test_app.py` (factory ≠ singleton ; `/health`→200) + `no_side_effect_imports` vert* `[~]` `JOB_STORE` module-level : N/A tant que le store n'existe pas (T4d).
+- [x] **Package `security/`** (couche 8, **un** package ≠ 7 modules épars) — **CSP stricte** (`default-src 'none'` ; seul `style-src 'unsafe-inline'` car le rapport n'a que du CSS inline, zéro script — vérifié) + en-têtes durcis (nosniff/DENY/no-referrer/COOP) + **rate-limit** en mémoire par IP (purge des IP expirées → pas de fuite, dette H corrigée). Middlewares ASGI montés par la factory. — *preuve : `test_web_security` (CSP stricte ; en-têtes sur `/health` ET sur le rapport ; 429 au dépassement ; non-HTTP traversé ; config invalide rejetée)*
+- [~] **CSRF / quotas upload / mode public** : différés à **T4f** (le lanceur BYO-key) — **0 consommateur** tant que la vitrine est en lecture seule (GET only), pas de mutation à protéger. SSE + annulation `RunControl`/`Deadline` = T4d.
+- [x] **Packaging Space (Docker, lecture seule)** — `deploy/` : `Dockerfile` (python:3.11-slim, **non-root**, port **7860**, n'installe que cœur + `[serve]` — **aucun moteur**), `requirements.txt` (épinglé, vérifié couvrant cœur+serve par test anti-dérive), `README_SPACE.md` (`sdk: docker`), dossier `reports/` baké via `CINOC_REPORTS_DIR`. **Boot sans aucun secret/clé.** — *preuve : `test_packaging` (artefacts + cohérence deps + non-root + pas de moteur) ; smoke-test servi : `CINOC_REPORTS_DIR` → liste+rendu HTML+CSP.* `[~]` **build Docker non vérifié ici** (pas de démon dans le sandbox) ; runtime servi vérifié.
+- [~] **Duplicable BYO-key** (clés par secrets/env, déblocage **fail-closed** du lanceur) : avec le lanceur (T4f). La vitrine, elle, est déjà **dupliquable telle quelle** (aucun secret).
+
+**Garde-fous :**
+- [x] `no_side_effect_imports` (la CLI construit tout dans `main`) · `layer_dependencies` (interfaces → couches internes) · `file_budgets`. — *preuve : `test_interfaces_imports_are_allowed` + suite archi*
+- [ ] `no_broad_except` · **tests sécurité** (CSRF→403, `..`/symlink→rejet, zip-bomb→échec, cloud en mode public→403) · **hygiène des clés = invariant testé** (mémoire-seule, jamais loggée/persistée/rendue, même en mode dupliqué). — *T4*
+
+**Validation inter-couches :** `MIGRATION_PLAN.md` §3 — `demo` bout-en-bout **sans serveur** (T1) · `serve` avec sécurité complète + un `cancel` qui interrompt réellement + reprise SSE `Last-Event-ID` (T4).
+
+- [~] **Supprimé** : `synthesis`+narratif · `diagnose/economics/edition` · doublon `web/jobs.py` (→ `adapters/storage`, **SSE conservé**) · façade ré-export `security.py` · SPA lourde (→ panneau mince) · docs périmées (« 11 routers », `start`, `measurements`). **Convention (D-003/L7)** : le *flux de run* passe par `app`, pas `evaluation`/`reports` en direct.
+
+---
+
+*Tous les verdicts de la Partie 1.5 sont **PROVISOIRE — à confirmer au build** : le contact du code amont (evaluation/pipeline/adapters/app non encore implémentés) prévaut.*
+
+---
+
+## Mise à jour D-065 (réconciliation post-audit) — supersède les détails de page ci-dessus
+
+Suite à l'audit de migration (et à une **dette de doc admise** : le code a d'abord
+été poussé sans mettre à jour cette DoD), **décision produit** : la Bibliothèque
+est le **hub de préparation des corpus**, pas un écran de découverte. Les détails
+de page de la DoD ci-dessus sont donc **dépassés sur ces points** :
+
+- **upload ZIP (glisser-déposer) + imports IIIF/Gallica/eScriptorium/HF** :
+  déplacés de `/benchmark` vers **`/library`** (`static/js/corpus.js`) — **renverse
+  D-059** et « UI upload/sélection sur `/benchmark` » (`PLAN_SPACE_INTERACTIF` TU2.f.2).
+- **`/library` n'est plus « 0 JS »** : elle porte `corpus.js` + une section
+  « Mes corpus » (`CorpusStore.list_corpora`) ; le **Banc d'essai sélectionne**
+  un corpus existant (`<select>`), il ne téléverse plus.
+- **Couche 8 = transport mince** : la construction de specs vit en
+  `app/run_planning.py` (`plan_benchmark_run`/`plan_segmentation_run`), plus dans les
+  routeurs (garde-fou `tests/guardrails/test_interfaces_thin.py`).
+- **Stockage runtime** : historique + rapports de run via `app/data_dir`
+  (inscriptible, ≠ dossier baké) ; pages dégradées (réseau/SQLite) — `tests/guardrails/`.
+
+Détail complet : `MIGRATION_PLAN.md` **D-065**. Limites assumées : interaction
+navigateur non testée en CI ; `/data` non gué sur `SPACE_ID` ; déploiement non
+encore aligné — au backlog.
diff --git a/cinoc/interfaces/__init__.py b/cinoc/interfaces/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c25fbe64a89162617fd82081c14c45637063c808
--- /dev/null
+++ b/cinoc/interfaces/__init__.py
@@ -0,0 +1,11 @@
+"""Couche 8 — ``interfaces`` : transport (CLI). Feuille de l'architecture.
+
+``__init__`` mince, sans effet de bord (pas de singleton à l'import — la CLI
+construit tout dans ``main``).
+"""
+
+from __future__ import annotations
+
+from cinoc.interfaces.cli import main
+
+__all__ = ["main"]
diff --git a/cinoc/interfaces/cli.py b/cinoc/interfaces/cli.py
new file mode 100644
index 0000000000000000000000000000000000000000..4e75c23d2099f7f10f3ff98e01029e23fc3e3272
--- /dev/null
+++ b/cinoc/interfaces/cli.py
@@ -0,0 +1,492 @@
+"""CLI Cinoc (couche 8) : ``demo``, ``run``, ``compare``, ``serve``.
+
+``argparse`` (stdlib, aucune dépendance — journal D-007). ``demo`` génère un
+rapport de démonstration **déterministe** sans moteur réel : un mini-corpus
+pré-calculé en mémoire → ``precomputed`` → CER → ``RunResult`` → HTML autonome.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from datetime import UTC, datetime
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+from cinoc.app import (
+    dump_run_result,
+    load_run_result,
+    load_run_spec,
+    resolve_code_version,
+)
+from cinoc.app import run as run_orchestrator
+from cinoc.app.demo import demo_run_spec, write_demo_corpus
+from cinoc.app.modules import (
+    ModuleRegistry,
+    discover_plugins,
+    register_default_modules,
+)
+from cinoc.app.report_images import (
+    build_facsimiles,
+    build_thumbnails,
+    write_report_bundle,
+)
+from cinoc.app.resume import ResumeStore
+from cinoc.domain.errors import CinocError
+from cinoc.evaluation.analysis import EconomicsPayload
+from cinoc.reports import default_report_renderer, render_comparison
+from cinoc.reports.csv_export import run_result_csv
+
+#: Horodatage figé du rapport de démo (golden octet-stable, cf. ``demo_to_html``).
+_DEMO_EPOCH = datetime(2026, 1, 1, tzinfo=UTC)
+
+
+def demo_to_html() -> str:
+    """Exécute la démo et renvoie le rapport HTML (déterministe).
+
+    La démo est la **vitrine du déterminisme** (golden octet-stable entre deux
+    exécutions) : on retire du ``RunResult`` les canaux **environnementaux**
+    avant rendu — ``usage`` (durées wall-clock) et l'analyse ``economics`` qui
+    en dérive varient d'un run à l'autre par nature (arbitrage D-068 ; un run
+    réel, lui, les rend : le rapport reste une fonction pure du ``RunResult``).
+    """
+    registry = ModuleRegistry()
+    register_default_modules(registry)
+    discover_plugins(registry, enabled=True)  # CLI local : code de confiance
+    with TemporaryDirectory() as tmp:
+        corpus = write_demo_corpus(Path(tmp))
+        result = run_orchestrator(
+            demo_run_spec(corpus),
+            registry=registry,
+            code_version=resolve_code_version(),
+        )
+    stable = result.model_copy(
+        update={
+            # Horodatages du manifeste = environnementaux (wall-clock) → figés pour
+            # le golden. Le run_id en dérive (``run-<timestamp>``) : figé aussi.
+            "manifest": result.manifest.model_copy(
+                update={
+                    "run_id": "demo",
+                    "started_at": _DEMO_EPOCH,
+                    "completed_at": _DEMO_EPOCH,
+                }
+            ),
+            "usage": (),
+            # Réfs image = chemins du TemporaryDirectory (éphémères) → neutralisés
+            # comme les autres canaux environnementaux (golden octet-stable).
+            "documents": tuple(
+                d.model_copy(update={"image_ref": None}) for d in result.documents
+            ),
+            "analyses": tuple(
+                analysis
+                for analysis in result.analyses
+                if not isinstance(analysis.payload, EconomicsPayload)
+            ),
+        }
+    )
+    return default_report_renderer().render(stable, title="Cinoc — démonstration")
+
+
+def _run_history(
+    db: str, view: str, metric: str, pipeline: str | None, threshold: float
+) -> int:
+    """Lit le ``HistoryStore`` : série d'un pipeline, ou régressions de la vue."""
+    from cinoc.adapters.storage.history_store import HistoryStore
+
+    store = HistoryStore(Path(db))
+    if pipeline is not None:
+        records = store.history(pipeline, view, metric)
+        if not records:
+            print(f"Aucune mesure pour {pipeline!r} ({view}:{metric}).")
+            return 0
+        for record in records:
+            print(
+                f"{record.completed_at}  {record.run_id}  "
+                f"{record.metric}={record.value:.6f}  ({record.corpus_name}, "
+                f"code {record.code_version})"
+            )
+        return 0
+    regressions = store.regressions(view, metric, threshold=threshold)
+    if not regressions:
+        print(f"Aucune régression ({view}:{metric}, seuil {threshold:g}).")
+        return 0
+    for reg in regressions:
+        print(
+            f"{reg.pipeline}: {reg.previous:.6f} → {reg.latest:.6f} "
+            f"(Δ {reg.delta:+.6f}, run {reg.latest_run_id})"
+        )
+    return 0
+
+
+def _run_demo(output: str) -> int:
+    path = Path(output)
+    path.write_text(demo_to_html(), encoding="utf-8")
+    print(f"Rapport de démonstration écrit : {path}")
+    return 0
+
+
+def _run_config(
+    config_path: str,
+    output: str,
+    json_output: str | None,
+    resume_dir: str | None = None,
+    csv_output: str | None = None,
+    hipe_jsonl: str | None = None,
+    max_workers: int | None = None,
+    report_dir: str | None = None,
+) -> int:
+    registry = ModuleRegistry()
+    register_default_modules(registry)
+    discover_plugins(registry, enabled=True)  # CLI local : code de confiance
+    spec = load_run_spec(config_path)
+    resume_store = ResumeStore(Path(resume_dir)) if resume_dir else None
+    # Export HIPE = sink d'artefacts (les textes sont lus avant le nettoyage du
+    # workspace) — le format JSONL porte les textes, pas les scores.
+    artifact_sink = None
+    if hipe_jsonl is not None:
+        from cinoc.app.hipe_export import hipe_jsonl_sink
+
+        artifact_sink = hipe_jsonl_sink(Path(hipe_jsonl), spec.corpus)
+    result = run_orchestrator(
+        spec,
+        registry=registry,
+        code_version=resolve_code_version(),
+        resume_store=resume_store,
+        artifact_sink=artifact_sink,
+        max_workers=max_workers,
+    )
+    title = f"Cinoc — {spec.corpus.name}"
+    if report_dir is not None:
+        # Saveur dossier : images réelles dans report-assets/, HTML à liens
+        # relatifs. Le renderer (couche 7) est injecté — app n'importe pas reports.
+        report = write_report_bundle(
+            result, report_dir, render=default_report_renderer().render, title=title
+        )
+        written = str(report)
+    else:
+        # Saveur fichier unique : vignettes data-URI inlinées dans le HTML.
+        Path(output).write_text(
+            default_report_renderer().render(
+                result,
+                title=title,
+                images=build_thumbnails(result),
+                facsimiles=build_facsimiles(result),
+            ),
+            encoding="utf-8",
+        )
+        written = output
+    if json_output is not None:
+        dump_run_result(result, json_output)
+    if csv_output is not None:
+        Path(csv_output).write_text(run_result_csv(result), encoding="utf-8")
+    print(f"Rapport écrit : {written}")
+    return 0
+
+
+def _run_hybrid(
+    images: str,
+    out: str,
+    *,
+    segmenter: str,
+    ocr: str,
+    label: str,
+    source_label: str | None,
+    lang: str = "fra",
+    model: str | None = None,
+    prompt: str | None = None,
+) -> int:
+    """Transcription **hybride** : segmente, reconnaît par bloc, assemble un ALTO/page.
+
+    Part d'un dossier d'images (sans GT) → ``CorpusSpec`` → ``plan_hybrid_run``
+    (pp_doclayout + tesseract par défaut ; tout OCR réel ou un VLM zero-shot via
+    ``--ocr``) → orchestrateur ; les ``ALTO_XML`` sont écrits dans ``out`` par un
+    sink (avant nettoyage du workspace).
+    """
+    from cinoc.app.orchestrator import PipelineOutputs
+    from cinoc.app.structure_planning import plan_hybrid_run
+    from cinoc.app.transcription import corpus_from_images, write_alto_files
+    from cinoc.domain.run import RunManifest
+
+    corpus = corpus_from_images(images)
+    registry = ModuleRegistry()
+    register_default_modules(registry)
+    discover_plugins(registry, enabled=True)  # CLI local : code de confiance
+    spec = plan_hybrid_run(
+        corpus, "hybrid", segmenter=segmenter, ocr=ocr, label=label,
+        source_label=source_label, lang=lang, model=model, prompt=prompt,
+    )(Path(out))
+    out_dir = Path(out)
+    written: list[Path] = []
+
+    def _sink(outputs: PipelineOutputs, manifest: RunManifest) -> None:
+        written.extend(write_alto_files(out_dir, outputs))
+
+    run_orchestrator(
+        spec,
+        registry=registry,
+        code_version=resolve_code_version(),
+        artifact_sink=_sink,
+    )
+    print(f"{len(written)} ALTO écrit(s) dans {out_dir}")
+    return 0
+
+
+def _compare_command(path_a: str, path_b: str, output: str) -> int:
+    run_a = load_run_result(path_a)
+    run_b = load_run_result(path_b)
+    Path(output).write_text(render_comparison(run_a, run_b), encoding="utf-8")
+    print(f"Comparaison écrite : {output}")
+    return 0
+
+
+def _load_dotenv(path: Path = Path(".env")) -> list[str]:
+    """Charge un fichier ``.env`` (``CLE=valeur`` par ligne) dans l'environnement.
+
+    Sans dépendance. **Ne remplace jamais** une variable déjà définie : l'env réel
+    prime (un secret HuggingFace l'emporte sur le ``.env`` local). ``#`` et lignes
+    vides ignorés. Renvoie les **noms** chargés (jamais les valeurs) pour une trace
+    lisible. C'est le moyen d'entrer ses clés en local (``MISTRAL_API_KEY=…``).
+    """
+    if not path.is_file():
+        return []
+    loaded: list[str] = []
+    for raw in path.read_text(encoding="utf-8").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        key = key.strip()
+        if key and key not in os.environ:
+            os.environ[key] = value.strip().strip('"').strip("'")
+            loaded.append(key)
+    return loaded
+
+
+def _serve_command(host: str, port: int, reports_dir: str | None) -> int:
+    # Clés locales depuis ``.env`` (avant tout : la disponibilité des moteurs est
+    # capturée au démarrage). Sur HuggingFace, les secrets du Space priment.
+    loaded = _load_dotenv()
+    if loaded:
+        print(f"Clés chargées depuis .env : {', '.join(loaded)}")
+    # uvicorn = extra [serve], importé paresseusement : la CLI reste utilisable
+    # (demo/run/compare) sans la pile web installée.
+    try:
+        import uvicorn  # type: ignore[import-not-found]
+
+        from cinoc.interfaces.web.app import REPORTS_DIR_ENV
+    except ImportError:
+        print(
+            "Erreur : serveur non installé (pip install 'cinoc[serve]').",
+            file=sys.stderr,
+        )
+        return 1
+    if host not in ("127.0.0.1", "localhost"):
+        # 0.0.0.0 expose le service au réseau : sécurité = responsabilité du
+        # déploiement (reverse-proxy, mode public). On le signale, sans bloquer.
+        print(
+            f"Attention : écoute sur {host} (exposé au réseau). "
+            "En public, placez un reverse-proxy et activez le mode public.",
+            file=sys.stderr,
+        )
+    if reports_dir is not None:
+        os.environ[REPORTS_DIR_ENV] = reports_dir
+    print(f"Cinoc sert sur http://{host}:{port} (Ctrl-C pour arrêter).")
+    # On passe la FACTORY à uvicorn (factory=True), jamais un app de module :
+    # zéro effet de bord à l'import (gate no_side_effect_imports).
+    uvicorn.run(
+        "cinoc.interfaces.web.app:create_app",
+        host=host,
+        port=port,
+        factory=True,
+    )
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="cinoc",
+        description="Banc d'essai déterministe de pipelines de transcription.",
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    demo = subparsers.add_parser(
+        "demo",
+        help="Génère un rapport de démonstration déterministe (sans moteur).",
+    )
+    demo.add_argument(
+        "-o", "--output", default="rapport_demo.html", help="Fichier HTML de sortie."
+    )
+    run_cmd = subparsers.add_parser(
+        "run", help="Exécute un run décrit dans un fichier YAML."
+    )
+    run_cmd.add_argument("config", help="Fichier YAML décrivant le run.")
+    run_cmd.add_argument(
+        "--resume-dir",
+        default=None,
+        help="Cache de reprise : les (pipeline × document) déjà produits à "
+        "l'identique y sont rechargés au lieu d'être ré-exécutés.",
+    )
+    run_cmd.add_argument(
+        "--csv",
+        default=None,
+        dest="csv_output",
+        help="Export CSV tableur (agrégats + détail par-document).",
+    )
+    run_cmd.add_argument(
+        "-o", "--output", default="rapport.html", help="Fichier HTML de sortie."
+    )
+    run_cmd.add_argument(
+        "--report-dir",
+        dest="report_dir",
+        default=None,
+        help="Écrit un bundle dossier (report.html + report-assets/ d'images "
+        "réelles, liens relatifs) au lieu du HTML autonome de -o. Recommandé pour "
+        "les gros corpus à images.",
+    )
+    run_cmd.add_argument(
+        "--json",
+        dest="json_output",
+        default=None,
+        help="Écrit aussi le RunResult en JSON (pour comparer plus tard).",
+    )
+    run_cmd.add_argument(
+        "--hipe-jsonl",
+        dest="hipe_jsonl",
+        default=None,
+        help="Exporte les sorties au format JSONL HIPE-OCRepair "
+        "(un fichier par pipeline — soumission leaderboard).",
+    )
+    run_cmd.add_argument(
+        "--workers",
+        type=int,
+        default=None,
+        help="Threads d'exécution (gros corpus). Défaut : CINOC_MAX_WORKERS "
+        "puis le nombre de CPU. 1 = séquentiel. Résultat identique quel que "
+        "soit le nombre (assemblage ordonné par le spec).",
+    )
+    history_cmd = subparsers.add_parser(
+        "history",
+        help="Historique longitudinal : série d'un pipeline ou régressions.",
+    )
+    history_cmd.add_argument("db", help="Base SQLite de l'historique.")
+    history_cmd.add_argument("--view", default="text")
+    history_cmd.add_argument("--metric", default="cer")
+    history_cmd.add_argument(
+        "--pipeline",
+        default=None,
+        help="Série chronologique de ce pipeline (sinon : régressions).",
+    )
+    history_cmd.add_argument("--threshold", type=float, default=0.0)
+
+    compare_cmd = subparsers.add_parser(
+        "compare", help="Compare deux RunResult JSON → rapport de deltas."
+    )
+    compare_cmd.add_argument("run_a", help="Premier RunResult (JSON).")
+    compare_cmd.add_argument("run_b", help="Second RunResult (JSON).")
+    compare_cmd.add_argument(
+        "-o", "--output", default="comparaison.html", help="Fichier HTML de sortie."
+    )
+    hybrid_cmd = subparsers.add_parser(
+        "hybrid",
+        help="Transcription hybride : segmente → OCR par bloc → ALTO/page.",
+    )
+    hybrid_cmd.add_argument("images", help="Dossier d'images à transcrire.")
+    hybrid_cmd.add_argument(
+        "--out", default="alto", help="Dossier de sortie des ALTO (défaut : alto/)."
+    )
+    hybrid_cmd.add_argument(
+        "--segmenter",
+        default="pp_doclayout",
+        help="Segmenteur (pp_doclayout, remote_segmenter, precomputed_layout).",
+    )
+    hybrid_cmd.add_argument(
+        "--ocr",
+        default="tesseract",
+        help="Reconnaisseur par bloc : OCR réel (tesseract, mistral_ocr, "
+        "google_vision, azure_di, kraken, pero, calamari) ou VLM zero-shot "
+        "(openai, anthropic, mistral) ; precomputed_region en démo.",
+    )
+    hybrid_cmd.add_argument(
+        "--label", default="hybrid", help="Étiquette du moteur (identité)."
+    )
+    hybrid_cmd.add_argument(
+        "--source-label",
+        default=None,
+        help="Jeu de textes par région (mode precomputed_region).",
+    )
+    hybrid_cmd.add_argument(
+        "--lang", default="fra", help="Langue OCR par bloc (moteurs OCR réels)."
+    )
+    hybrid_cmd.add_argument(
+        "--model",
+        default=None,
+        help="Modèle du reconnaisseur (chemin/checkpoint OCR ou modèle VLM).",
+    )
+    hybrid_cmd.add_argument(
+        "--prompt",
+        default=None,
+        help="Prompt de transcription pour un reconnaisseur VLM (zero-shot).",
+    )
+
+    serve_cmd = subparsers.add_parser(
+        "serve", help="Sert la vitrine web des rapports (extra [serve])."
+    )
+    serve_cmd.add_argument(
+        "--host", default="127.0.0.1", help="Adresse d'écoute (défaut : local)."
+    )
+    serve_cmd.add_argument(
+        "--port", type=int, default=8000, help="Port d'écoute (défaut : 8000)."
+    )
+    serve_cmd.add_argument(
+        "--reports-dir",
+        default=None,
+        help="Dossier des rapports RunResult JSON à servir.",
+    )
+    args = parser.parse_args(argv)
+    # Les erreurs métier (spec invalide, chemin hors zone…) et d'E/S sont
+    # rapportées proprement sur stderr + code de sortie 1 — jamais une trace nue.
+    try:
+        if args.command == "demo":
+            return _run_demo(args.output)
+        if args.command == "run":
+            return _run_config(
+                args.config,
+                args.output,
+                args.json_output,
+                args.resume_dir,
+                args.csv_output,
+                args.hipe_jsonl,
+                args.workers,
+                args.report_dir,
+            )
+        if args.command == "history":
+            return _run_history(
+                args.db, args.view, args.metric, args.pipeline, args.threshold
+            )
+        if args.command == "hybrid":
+            return _run_hybrid(
+                args.images,
+                args.out,
+                segmenter=args.segmenter,
+                ocr=args.ocr,
+                label=args.label,
+                source_label=args.source_label,
+                lang=args.lang,
+                model=args.model,
+                prompt=args.prompt,
+            )
+        if args.command == "compare":
+            return _compare_command(args.run_a, args.run_b, args.output)
+        if args.command == "serve":
+            return _serve_command(args.host, args.port, args.reports_dir)
+    except (CinocError, OSError) as exc:
+        print(f"Erreur : {exc}", file=sys.stderr)
+        return 1
+    return 1  # pragma: no cover (sous-commande requise)
+
+
+__all__ = ["demo_to_html", "main"]
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())
diff --git a/cinoc/interfaces/web/__init__.py b/cinoc/interfaces/web/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e0bfccafc0e96aca955bedf52fb72b27f4bdaf3e
--- /dev/null
+++ b/cinoc/interfaces/web/__init__.py
@@ -0,0 +1,10 @@
+"""Transport web (couche 8) — sous-paquet servi par la commande ``serve``.
+
+Mince et **sans effet de bord à l'import** : aucun ``app = FastAPI()`` ni routeur
+au niveau module (gate ``no_side_effect_imports``). Tout est construit à la
+demande par ``create_app()`` (``cinoc.interfaces.web.app``). Les dépendances
+``fastapi``/``uvicorn`` sont un **extra** (``pip install 'cinoc[serve]'``) : le
+CLI reste installable sans elles.
+"""
+
+from __future__ import annotations
diff --git a/cinoc/interfaces/web/_cache.py b/cinoc/interfaces/web/_cache.py
new file mode 100644
index 0000000000000000000000000000000000000000..052380ec5cdc81497c863569c6cae436fb01da13
--- /dev/null
+++ b/cinoc/interfaces/web/_cache.py
@@ -0,0 +1,49 @@
+"""Cache TTL minimal, thread-safe (couche 8 — UX).
+
+Mémoïse un résultat coûteux (fetch réseau d'un catalogue de découverte) pendant
+une fenêtre courte, pour ne pas refetch à **chaque** chargement de page. Horloge
+**injectable** (``clock``) → testable sans dormir. Aucun effet de bord à l'import.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from collections.abc import Callable
+from typing import Generic, TypeVar
+
+K = TypeVar("K")
+V = TypeVar("V")
+
+
+class TTLCache(Generic[K, V]):
+    """Cache clé→valeur à expiration (TTL). Recalcule à la demande après péremption.
+
+    Best-effort : si ``compute`` lève, **rien n'est mis en cache** et l'exception
+    remonte (un échec réseau ne fige pas une valeur fautive).
+    """
+
+    def __init__(
+        self, ttl_seconds: float, *, clock: Callable[[], float] = time.monotonic
+    ) -> None:
+        self._ttl = ttl_seconds
+        self._clock = clock
+        self._entries: dict[K, tuple[float, V]] = {}
+        self._lock = threading.Lock()
+
+    def get_or_compute(self, key: K, compute: Callable[[], V]) -> V:
+        """Retourne la valeur cachée si fraîche, sinon ``compute()`` (et la cache)."""
+        now = self._clock()
+        with self._lock:
+            hit = self._entries.get(key)
+            if hit is not None and hit[0] > now:
+                return hit[1]
+        # Calcul **hors verrou** (le fetch peut être lent) : on ne sérialise pas
+        # les requêtes ; une course bénigne recalcule au pire deux fois.
+        value = compute()
+        with self._lock:
+            self._entries[key] = (now + self._ttl, value)
+        return value
+
+
+__all__ = ["TTLCache"]
diff --git a/cinoc/interfaces/web/app.py b/cinoc/interfaces/web/app.py
new file mode 100644
index 0000000000000000000000000000000000000000..0c1d3c4f5d1a62211f5a4041b1094c0cdde3b05b
--- /dev/null
+++ b/cinoc/interfaces/web/app.py
@@ -0,0 +1,327 @@
+"""Factory de l'application web (couche 8) — ``create_app()``.
+
+L'app FastAPI est construite **à la demande**, jamais à l'import : pas de
+``app = FastAPI()`` au niveau module (interdit par ``no_side_effect_imports`` —
+``FastAPI``/``APIRouter`` sont des fabriques à effet de bord). uvicorn et le
+HF Space reçoivent la **factory** (``--factory`` / callable), jamais un singleton
+de module. Conséquence d'archi : un routeur est une **fonction qui construit et
+renvoie un ``APIRouter``** (l'appel ``APIRouter()`` vit dans la fonction), montée
+par ``create_app`` — voir les sous-tranches T4b+.
+
+T4a pose la coquille : la factory + une route de santé. La surface (routers
+benchmark/corpus, package ``security/``, SSE, annulation) se remplit ensuite,
+une sous-tranche à la fois.
+"""
+
+from __future__ import annotations
+
+import os
+import tempfile
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.responses import PlainTextResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+
+from cinoc.adapters.corpus.huggingface import whoami
+from cinoc.adapters.storage import JobStore
+from cinoc.adapters.storage.history_store import HistoryStore
+from cinoc.adapters.storage.publisher import resolve_publisher
+from cinoc.app import resolve_code_version
+from cinoc.app.alto_store import AltoStore
+from cinoc.app.corpus_upload import CorpusStore
+from cinoc.app.data_dir import resolve_data_dir
+from cinoc.app.engines import (
+    EngineStatus,
+    engine_statuses,
+    ner_status,
+    segmenter_statuses,
+)
+from cinoc.app.jobs import JobRunner
+from cinoc.app.modules import (
+    ModuleRegistry,
+    discover_plugins,
+    register_default_modules,
+)
+from cinoc.app.segmentation import SegmentationStore, demo_layout, demo_page_image
+from cinoc.interfaces.web.catalog import seed_reports
+from cinoc.interfaces.web.metrics import MetricsMiddleware, RequestMetrics
+from cinoc.interfaces.web.routers.corpus import build_corpus_router
+from cinoc.interfaces.web.routers.engines import build_engines_router
+from cinoc.interfaces.web.routers.home import build_home_router
+from cinoc.interfaces.web.routers.reports import build_reports_router
+from cinoc.interfaces.web.routers.runs import build_runs_router
+from cinoc.interfaces.web.routers.segmentation import build_segmentation_router
+from cinoc.interfaces.web.security import (
+    RateLimitMiddleware,
+    SecurityHeadersMiddleware,
+)
+
+#: Assets de la coquille (CSS + polices auto-hébergées) et gabarits Jinja2,
+#: livrés **dans le paquet** (cf. ``[tool.setuptools.package-data]``) pour être
+#: présents aussi bien en source qu'une fois ``pip install``é (Space/CI).
+_WEB_DIR = Path(__file__).resolve().parent
+_STATIC_DIR = _WEB_DIR / "static"
+_TEMPLATES_DIR = _WEB_DIR / "templates"
+
+#: Version du **contrat de transport HTTP** (évolue indépendamment du code métier ;
+#: le déterminisme produit (§12) vit dans ``RunResult``, pas dans l'API).
+API_VERSION = "0"
+
+#: Dossier des rapports (``RunResult`` JSON) servis par la vitrine, surchargé par
+#: ce var d'env (utile au Space) si ``create_app(reports_dir=...)`` ne le fixe pas.
+REPORTS_DIR_ENV = "CINOC_REPORTS_DIR"
+
+#: Mode public (exposition sans secrets) : refuse les moteurs cloud porteurs de
+#: clé. Activé par cet env (truthy) si ``create_app(public_mode=...)`` ne tranche pas.
+PUBLIC_MODE_ENV = "CINOC_PUBLIC_MODE"
+
+#: Observabilité Prometheus **opt-in** : expose ``/metrics`` si truthy (un Space
+#: exposé ne publie pas ses stats par défaut). Surchargé par ``create_app(metrics=)``.
+METRICS_ENV = "CINOC_METRICS"
+
+#: Compte HF dont les **datasets curés** (tag ``cinoc-corpus``) sont listés
+#: automatiquement dans la Bibliothèque (sans coller le ``repo_id``). Override
+#: explicite ; à défaut le handle est résolu **tout seul** (jeton/Space, cf.
+#: ``_resolve_curated_author``). Aucun signal → section masquée (import manuel OK).
+HF_AUTHOR_ENV = "CINOC_HF_AUTHOR"
+
+#: Jetons HF reconnus (ordre de lecture) : présent → on résout le handle de
+#: l'opérateur via ``whoami`` → ses datasets curés apparaissent sans config.
+HF_TOKEN_ENVS = ("HF_TOKEN", "HUGGINGFACE_TOKEN", "HUGGING_FACE_HUB_TOKEN")
+
+#: Identifiant du Space (``owner/name``, injecté par HuggingFace). Son ``owner``
+#: EST le handle de l'opérateur → datasets curés automatiques sur un Space, sans
+#: jeton ni appel réseau pour la résolution.
+SPACE_ID_ENV = "SPACE_ID"
+
+
+def _resolve_reports_dir(reports_dir: Path | str | None) -> Path:
+    """Argument explicite > variable d'env > défaut ``./reports``."""
+    if reports_dir is not None:
+        return Path(reports_dir)
+    env = os.environ.get(REPORTS_DIR_ENV)
+    return Path(env) if env else Path("reports")
+
+
+def _resolve_uploads_dir(uploads_dir: Path | str | None) -> Path:
+    """Dossier des corpus uploadés : argument explicite > dossier temporaire neuf.
+
+    Éphémère par défaut (entrées de travail ; les résultats sont publiés à part).
+    """
+    if uploads_dir is not None:
+        return Path(uploads_dir)
+    return Path(tempfile.mkdtemp(prefix="cinoc-uploads-"))
+
+
+def _resolve_public_mode(public_mode: bool | None) -> bool:
+    """Mode public (verrou *fail-closed*) : arg explicite > env ``CINOC_PUBLIC_MODE``
+    > ``False``.
+
+    **Désactivé par défaut, partout — y compris sur un Space.** Une instance
+    exécute ses moteurs (cloud compris) dès qu'une clé est présente, sans blocage :
+    c'est l'opérateur qui maîtrise sa clé. Le verrou reste disponible **en option**
+    via ``CINOC_PUBLIC_MODE=true`` (masque les moteurs cloud, refuse les imports
+    distants, désactive la découverte de plugins tiers) — pour qui expose un Space
+    **public** avec une clé qu'un visiteur ne doit pas pouvoir dépenser. ``false``
+    ou absent ⇒ surface ouverte (l'opérateur assume l'exposition de sa clé ;
+    cf. ``deploy/README_SPACE.md``).
+    """
+    if public_mode is not None:
+        return public_mode
+    return os.environ.get(PUBLIC_MODE_ENV, "").strip().lower() in {"1", "true", "yes"}
+
+
+def _resolve_metrics(metrics: bool | None) -> bool:
+    """``/metrics`` : arg explicite > env ``CINOC_METRICS`` > ``False`` (off)."""
+    if metrics is not None:
+        return metrics
+    return os.environ.get(METRICS_ENV, "").strip().lower() in {"1", "true", "yes"}
+
+
+def _resolve_curated_author() -> str | None:
+    """Compte HF dont lister les datasets curés — **zéro config** quand c'est possible.
+
+    Ordre : ``CINOC_HF_AUTHOR`` explicite > handle résolu d'un jeton HF (``whoami``,
+    poste local connecté) > ``owner`` du ``SPACE_ID`` (sur un Space, le propriétaire
+    EST l'opérateur — pur, sans réseau). Aucun signal → ``None`` : l'app ne peut
+    pas deviner « vos » datasets, mais l'import manuel par ``repo_id`` reste offert.
+    """
+    explicit = os.environ.get(HF_AUTHOR_ENV, "").strip()
+    if explicit:
+        return explicit
+    for env in HF_TOKEN_ENVS:
+        token = os.environ.get(env, "").strip()
+        if token:
+            handle = whoami(token)
+            if handle:
+                return handle
+    space = os.environ.get(SPACE_ID_ENV, "").strip()
+    if space:
+        owner = space.split("/", 1)[0].strip()
+        if owner:
+            return owner
+    return None
+
+
+def create_app(
+    *,
+    reports_dir: Path | str | None = None,
+    uploads_dir: Path | str | None = None,
+    data_dir: Path | str | None = None,
+    rate_limit: int = 60,
+    public_mode: bool | None = None,
+    metrics: bool | None = None,
+) -> FastAPI:
+    """Construit une **nouvelle** application web Cinoc.
+
+    Appelée explicitement (CLI ``serve``, tests, Space) — jamais au chargement du
+    module. Chaque appel renvoie une instance neuve (aucun état partagé global).
+    Les routeurs sont des **fonctions builder** montées ici (jamais d'``APIRouter``
+    au niveau module — gate ``no_side_effect_imports``). Toute réponse porte les
+    en-têtes de sécurité (CSP stricte) ; le débit par IP est borné (``429``). Le
+    **lanceur** (``/api/runs``) exécute les runs en arrière-plan via un
+    ``JobRunner`` ; en ``public_mode`` les moteurs cloud sont refusés.
+    """
+    if rate_limit < 1:
+        raise ValueError("create_app : rate_limit doit être >= 1.")
+    catalog_dir = _resolve_reports_dir(reports_dir)
+    # Dossier **inscriptible** (≠ rapports bakés, souvent root-only sur un Space) :
+    # l'historique et le puits des rapports de run y vivent. On y recopie la graine
+    # des rapports bakés → la vitrine sert depuis un seul dossier inscriptible.
+    runtime_dir = resolve_data_dir(data_dir)
+    seed_reports(catalog_dir, runtime_dir)
+    is_public = _resolve_public_mode(public_mode)
+    app = FastAPI(title="Cinoc", version=API_VERSION)
+    # Ordre : le limiteur (ajouté en dernier) s'exécute en premier → il borne
+    # avant tout traitement ; les en-têtes habillent la réponse qui remonte.
+    app.add_middleware(SecurityHeadersMiddleware)
+    app.add_middleware(RateLimitMiddleware, max_requests=rate_limit)
+
+    # Observabilité opt-in : compte toutes les requêtes (middleware le plus
+    # externe → voit même les 429) et expose `/metrics`. État par application.
+    if _resolve_metrics(metrics):
+        request_metrics = RequestMetrics()
+        app.add_middleware(MetricsMiddleware, metrics=request_metrics)
+
+        @app.get("/metrics")
+        def metrics_endpoint() -> PlainTextResponse:
+            """Exposition Prometheus (texte). Montée **seulement** si opt-in."""
+            return PlainTextResponse(
+                request_metrics.render(), media_type=request_metrics.content_type
+            )
+
+    @app.get("/health")
+    def health() -> dict[str, str]:
+        """Sonde de vivacité (orchestrateurs / Space). Aucune donnée sensible."""
+        return {"status": "ok"}
+
+    # Assets servis depuis notre origine (``font-src``/``style-src 'self'``) —
+    # aucune dépendance CDN en prod (cf. CSP, ``security/headers.py``).
+    app.mount("/static", StaticFiles(directory=_STATIC_DIR), name="static")
+    templates = Jinja2Templates(directory=_TEMPLATES_DIR)
+
+    # Lanceur : un registre + un store + un runner par application (état du
+    # processus serveur, pas un singleton de module → factory respectée).
+    registry = ModuleRegistry()
+    register_default_modules(registry)
+    # Découverte de modules tiers : DÉSACTIVÉE en mode public (fail-closed —
+    # pas de chargement de code arbitraire in-process sur un serveur exposé).
+    discover_plugins(registry, enabled=not is_public)
+    # Historique longitudinal : un store SQLite par application ; le runner
+    # y enregistre chaque run terminé, la page `/history` (rendu serveur) le lit.
+    history_store = HistoryStore(runtime_dir / "history.db")
+    # Segmentation : un store disque par application + une graine de **démo**
+    # (layout + image de page). Le sink du runner y persiste les ``LAYOUT`` des
+    # runs réels ; l'aperçu du lanceur (``/api/segmentation/preview``) rend le plus
+    # récent (run réel > démo). Créé **avant** le runner pour le lui passer.
+    seg_store = SegmentationStore(Path(tempfile.mkdtemp(prefix="cinoc-seg-")))
+    # Graine de démo (layout + image) : l'aperçu du lanceur affiche ces régions
+    # tant qu'aucun run réel n'a été lancé.
+    seg_store.save(demo_layout(), image_ext=".png", image_bytes=demo_page_image())
+    # Export ALTO : un store disque par application, indexé par run_id. Le sink du
+    # runner y dépose les ``ALTO_XML`` produits ; le routeur des rapports les
+    # rezippe à la demande (téléchargement par run).
+    alto_store = AltoStore(Path(tempfile.mkdtemp(prefix="cinoc-alto-")))
+    runner = JobRunner(
+        store=JobStore(),
+        registry=registry,
+        reports_dir=runtime_dir,
+        code_version=resolve_code_version(),
+        # Persistance : actif uniquement si dépôt + jeton sont en secrets ;
+        # sinon NoopPublisher → la vitrine read-only ne fait aucune sortie réseau.
+        publisher=resolve_publisher(),
+        history_store=history_store,
+        segmentation_store=seg_store,
+        alto_store=alto_store,
+    )
+    corpus_store = CorpusStore(_resolve_uploads_dir(uploads_dir))
+
+    # Un seul fournisseur de statuts moteurs (même mode) partagé par le lanceur
+    # et l'onglet Moteurs → pas de closures jumelles qui pourraient diverger.
+    def engine_status_provider() -> tuple[EngineStatus, ...]:
+        return engine_statuses()
+
+    # Segmenteurs : catégorie distincte (pas dans le <select> moteur OCR), jamais
+    # masquée en public (segmenteur local, pas de clé). Alimente le gate du run de
+    # segmentation, le mode hybride du composeur et l'aperçu de mise en page.
+    def segmenter_status_provider() -> tuple[EngineStatus, ...]:
+        return segmenter_statuses()
+
+    # Étape NER (extra [ner], spaCy) : catégorie distincte (post-traitement, pas
+    # un moteur). Alimente le gate du lanceur et la case « NER » du composeur.
+    def ner_status_provider() -> EngineStatus:
+        return ner_status()
+
+    app.include_router(
+        build_home_router(
+            runtime_dir,
+            templates,
+            statuses=engine_status_provider,
+            segmenters=segmenter_status_provider,
+            ner=ner_status_provider,
+            history_store=history_store,
+            corpus_store=corpus_store,
+            curated_author=_resolve_curated_author(),
+            public_mode=is_public,
+            alto_store=alto_store,
+        )
+    )
+    app.include_router(build_reports_router(runtime_dir, alto_store=alto_store))
+    app.include_router(
+        build_segmentation_router(
+            seg_store,
+            runner=runner,
+            corpus_store=corpus_store,
+            segmenters=segmenter_status_provider,
+        )
+    )
+    # Le lanceur exécute aussi les concurrents **hybrides** (segmenteur →
+    # reconnaissance par bloc → texte scoré) : pas de second chemin d'exécution.
+    # Les ALTO produits (option) se téléchargent via /reports/{run_id}/alto.zip.
+    app.include_router(
+        build_runs_router(
+            runner,
+            corpus_store,
+            statuses=engine_status_provider,
+            segmenters=segmenter_status_provider,
+            ner_available=lambda: ner_status_provider().available,
+            public_mode=is_public,
+        )
+    )
+    app.include_router(build_engines_router())
+    app.include_router(build_corpus_router(corpus_store, public_mode=is_public))
+    return app
+
+
+__all__ = [
+    "API_VERSION",
+    "HF_AUTHOR_ENV",
+    "HF_TOKEN_ENVS",
+    "METRICS_ENV",
+    "PUBLIC_MODE_ENV",
+    "REPORTS_DIR_ENV",
+    "SPACE_ID_ENV",
+    "create_app",
+]
diff --git a/cinoc/interfaces/web/catalog.py b/cinoc/interfaces/web/catalog.py
new file mode 100644
index 0000000000000000000000000000000000000000..6db601a5734f8e41363bdec8d8ba60351d4c7131
--- /dev/null
+++ b/cinoc/interfaces/web/catalog.py
@@ -0,0 +1,57 @@
+"""Catalogue des rapports servis par la vitrine (couche 8).
+
+Un rapport = un ``RunResult`` **sauvé** (JSON, via ``run --json``) déposé dans un
+dossier. La vitrine les **liste** et les **rend en HTML à la demande** : le rendu
+est déterministe (§12), donc recalculable sans état serveur, et le format unique
+``RunResult`` reste la source de vérité (pas de HTML pré-figé).
+
+Tout accès passe par ``validated_path`` (couche 6) : un identifiant ne peut pas
+sortir du dossier (défense path-traversal, invariant §12).
+"""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+from cinoc.app.security import validated_path
+
+
+def available_reports(reports_dir: Path) -> list[str]:
+    """Identifiants (stems ``.json``) des rapports disponibles, **triés**.
+
+    Dossier absent → ``[]`` (le Space peut démarrer avant qu'un rapport existe).
+    """
+    if not reports_dir.is_dir():
+        return []
+    return sorted(path.stem for path in reports_dir.glob("*.json"))
+
+
+def resolve_report(reports_dir: Path, name: str) -> Path:
+    """Chemin sûr de ``<name>.json``, **confiné** à ``reports_dir``.
+
+    Lève ``PathSecurityError`` si ``name`` tente de sortir du dossier **ou**
+    n'existe pas (``must_exist``) — le routeur traduit les deux en 404, sans
+    distinguer (pas de fuite d'information).
+    """
+    return validated_path(f"{name}.json", reports_dir, must_exist=True)
+
+
+def seed_reports(src: Path, dst: Path) -> None:
+    """Copie les rapports *bakés* (``src``) dans le dossier inscriptible ``dst``.
+
+    Permet à la vitrine de servir, depuis un **seul** dossier inscriptible, à la
+    fois les rapports livrés dans l'image (graine) et ceux produits au runtime.
+    Idempotent et best-effort : un rapport déjà présent n'est jamais réécrit (un
+    run produit prime sur la graine homonyme) ; ``src`` absent → no-op.
+    """
+    if src == dst or not src.is_dir():
+        return
+    dst.mkdir(parents=True, exist_ok=True)
+    for path in src.glob("*.json"):
+        target = dst / path.name
+        if not target.exists():
+            shutil.copy2(path, target)
+
+
+__all__ = ["available_reports", "resolve_report", "seed_reports"]
diff --git a/cinoc/interfaces/web/i18n.py b/cinoc/interfaces/web/i18n.py
new file mode 100644
index 0000000000000000000000000000000000000000..3882ab6a744376fde4e79f79e29f1700b2213593
--- /dev/null
+++ b/cinoc/interfaces/web/i18n.py
@@ -0,0 +1,488 @@
+"""Chaînes bilingues FR/EN de la coquille web (couche 8).
+
+Rendu **serveur**, pas de SPA : la langue est choisie par le paramètre de
+requête ``?lang=`` (défaut ``fr``) et les chaînes sont injectées dans le
+gabarit Jinja2. Pas d'état, pas d'effet de bord — un simple dictionnaire de
+données (réf. ``design/js/i18n.jsx``, porté au strict besoin de la coquille).
+"""
+
+from __future__ import annotations
+
+#: Langues servies. ``fr`` est la primaire (cf. spec) ; tout autre code retombe
+#: dessus via :func:`normalize_lang`.
+LANGUAGES: tuple[str, ...] = ("fr", "en")
+DEFAULT_LANG = "fr"
+
+_STRINGS: dict[str, dict[str, str]] = {
+    "fr": {
+        "nav_library": "Bibliothèque",
+        "nav_benchmark": "Banc d'essai",
+        "nav_reports": "Rapports",
+        "nav_history": "Historique",
+        "nav_engines": "Moteurs",
+        "wordmark_sub": "OCR · HTR · VLM",
+        "hero_eyebrow": "Vitrine · lecture seule",
+        "hero_desc": "Rapports de benchmark déterministes — "
+        "OCR / HTR / VLM sur corpus patrimoniaux.",
+        "stat_reports": "rapports",
+        "reports_title": "Rapports générés",
+        "reports_desc": "Historique des benchmarks, rendus HTML autonomes.",
+        "skip_to_content": "Aller au contenu",
+        "bench_progress_label": "Progression du run",
+        # NB : la sous-chaîne « aucun rapport » est attendue par les tests.
+        "reports_empty": "aucun rapport disponible pour l'instant.",
+        "open_report": "Ouvrir",
+        "download_zip": "Télécharger (ZIP)",
+        "download_alto": "Télécharger l'ALTO (ZIP)",
+        # Banc d'essai (lanceur interactif)
+        "bench_eyebrow": "Banc d'essai · comparer",
+        "bench_title": "Banc d'essai",
+        "bench_desc": "Compose des concurrents (OCR, OCR→LLM, VLM) et compare-les "
+        "sur un corpus, en un seul run. Sans concurrent : démonstration.",
+        "bench_run": "Lancer le benchmark",
+        "bench_launching": "Lancement…",
+        "bench_status": "État",
+        "bench_log": "Journal",
+        "bench_idle": "Prêt.",
+        "bench_net_error": "Erreur réseau.",
+        "bench_corpus": "Corpus",
+        "bench_corpus_none": "aucun corpus (démo)",
+        "bench_corpus_prepare": "Choisir dans la Bibliothèque",
+        "bench_corpus_selected": "Corpus prêt à exécuter",
+        "bench_corpus_select_hint": "Sélectionne un corpus préparé, ou reste "
+        "en démonstration.",
+        "bench_competitors": "Concurrents",
+        "bench_add_competitor": "Ajouter un concurrent",
+        "bench_queue_empty": "Aucun concurrent ajouté pour l'instant.",
+        "bench_queue_title": "File prête à exécuter",
+        "bench_queue_hint": "Chaque ligne résume un pipeline réellement lancé.",
+        "bench_remove": "Retirer",
+        "bench_mode": "Mode",
+        "bench_mode_ocr": "OCR seul",
+        "bench_mode_text": "OCR → LLM (texte)",
+        "bench_mode_image": "OCR → LLM (image+texte)",
+        "bench_mode_vlm": "VLM (zero-shot)",
+        "bench_mode_hybrid": "Hybride (segmentation)",
+        "bench_ocr_engine": "Moteur OCR",
+        "bench_segmenter": "Segmenteur",
+        "bench_segmenter_hint": "Détecte les régions en tête de pipeline ; le "
+        "distant délègue à un endpoint HF (modèle changé via l'URL).",
+        "bench_recognizer": "Reconnaisseur par bloc",
+        "bench_recognizer_hint": "Moteur appliqué à chaque bloc découpé : un OCR "
+        "réel, ou un VLM qui transcrit l'image du bloc (zero-shot). Texte assemblé "
+        "scoré CER/WER comme un pipeline à plat.",
+        "bench_seg_preview": "Aperçu des régions",
+        "bench_seg_preview_btn": "Prévisualiser la segmentation",
+        "bench_seg_preview_hint": "Lance le segmenteur sur le corpus choisi et "
+        "affiche les régions détectées (avant de lancer le benchmark).",
+        "bench_seg_preview_no_corpus": "Choisis d'abord un corpus.",
+        "bench_llm": "LLM",
+        "bench_vlm": "VLM",
+        "bench_model": "Modèle",
+        "bench_model_ph": "modèle (optionnel)",
+        "bench_prompt": "Prompt",
+        "bench_prompt_ph": "Vide = prompt par défaut. Pour la correction, inclus "
+        "{ocr_text} là où le texte OCR doit être inséré (sinon il est ignoré).",
+        "bench_prompt_curated_none": "— Prompt curé (par période) —",
+        "bench_prompt_hint": "Choisis un prompt curé OU écris le tien ci-dessous "
+        "(le texte libre est prioritaire).",
+        "bench_ner": "Extraire les entités nommées (NER)",
+        "bench_ner_model_ph": "modèle spaCy (défaut fr_core_news_sm)",
+        "bench_ner_hint": "Ajoute une étape NER en fin de pipeline ; scorée "
+        "(F1) si le corpus porte une vérité-terrain d'entités.",
+        "bench_alto": "Exporter l'ALTO (XML)",
+        "bench_alto_hint": "Tesseract uniquement : produit un ALTO XML par "
+        "document (géométrie + texte), téléchargeable depuis le rapport — "
+        "ré-importable dans eScriptorium ou Transkribus.",
+        "bench_normalization": "Normalisation",
+        "bench_norm_preview": "Aperçu de normalisation",
+        "bench_norm_sample_ph": "Colle un échantillon de texte pour voir l'effet…",
+        "bench_norm_custom": "Profil personnalisé (YAML) — prioritaire si rempli",
+        "bench_norm_config_ph": "caseless: true\nexclude_chars: \",.;:\"",
+        "bench_norm_preview_btn": "Aperçu",
+        "bench_char_exclude": "Caractères à exclure",
+        "bench_char_exclude_ph": "ex : ,.;:!? — exclus des deux côtés",
+        "bench_char_exclude_hint": "Filtrés de la GT ET de l'hypothèse avant le "
+        "calcul (ne mesure plus ces caractères).",
+        "bench_metric_profile": "Profil de métriques",
+        "bench_metric_profile_hint": "Choisit les colonnes de classement du "
+        "rapport ; n'allège pas la donnée collectée (sections inchangées).",
+        "bench_config_io": "Configuration",
+        "bench_config_export": "Exporter (JSON)",
+        "bench_config_import": "Importer…",
+        "bench_config_loaded": "Configuration chargée.",
+        "bench_config_invalid": "Fichier de configuration invalide.",
+        "bench_config_hint": "Sauvegarde l'état du formulaire (concurrents + "
+        "options) en JSON ; rechargeable plus tard. Aucune persistance serveur.",
+        "bench_options": "Options",
+        "bench_execute_desc": "Lance le run puis ouvre le rapport final ou la "
+        "vue de segmentation.",
+        "bench_norm_none": "(aucune)",
+        "bench_error_422": "Configuration incomplète ou invalide.",
+        "bench_error_404": "Corpus introuvable.",
+        "bench_error_409": "Un moteur requis est indisponible.",
+        "bench_error_403": "Action refusée dans ce mode.",
+        "bench_error_fallback": "Erreur de lancement.",
+        # Import de corpus distant
+        "imp_btn": "Importer",
+        "imp_manifest": "URL du manifeste IIIF",
+        "imp_ark": "ARK Gallica (ark:/12148/…)",
+        "imp_ocr": "Inclure l'OCR de référence",
+        "imp_base": "URL de l'instance eScriptorium",
+        "imp_token": "Token d'API",
+        "imp_doc": "PK du document",
+        "imp_layer": "Couche de transcription",
+        "imp_limit": "Limite (pages)",
+        "imp_name": "Nom (optionnel)",
+        "imp_repo": "Dépôt HF (org/nom-du-dataset)",
+        "imp_revision": "Révision (SHA — recommandé pour l'épinglage)",
+        "imp_curated_hint": "Dataset de référence Cinoc publié sur HuggingFace : "
+        "le manifeste et la vérité-terrain sont rapatriés ; les images restent "
+        "des références distantes (IIIF statique servi par HF, épinglé à la "
+        "révision), téléchargées automatiquement au moment du run.",
+        # Aperçu de mise en page (panneau du lanceur) + reconnaisseur hybride :
+        # vestiges utiles de l'ancienne page /segmentation, repris par le composeur.
+        "seg_run_endpoint": "Endpoint (object-detection HF)",
+        "seg_run_endpoint_ph": "https://…",
+        "seg_run_token": "Jeton (optionnel)",
+        "seg_run_running": "Segmentation en cours…",
+        "hyb_run_vlm": "VLM, zero-shot",
+        "open_report_full": "Ouvrir le rapport",
+        "sys_version": "Version",
+        "sys_mode": "Mode",
+        "sys_mode_value": "local · interactif",
+        "sys_active_job": "Tâche active",
+        "sys_idle": "au repos",
+        "sys_details": "Détails système",
+        "sys_pipeline": "Pipeline",
+        "sys_pipeline_ready": "moteurs prêts",
+        "sys_open": "Système · détails",
+        # Page « Moteurs »
+        "engines_eyebrow": "Vitrine · moteurs",
+        "engines_title": "Moteurs",
+        "engines_desc": "Disponibilité runtime des moteurs du socle : binaire, SDK, "
+        "clé d'API. Un moteur cloud est prêt dès que son SDK et sa clé sont là.",
+        "stat_ready": "prêts",
+        "engines_col_engine": "Moteur",
+        "engines_col_status": "État",
+        "engines_col_detail": "Détail",
+        "engine_available": "disponible",
+        "engine_unavailable": "indisponible",
+        "history_eyebrow": "Vitrine · longitudinal",
+        "history_title": "Historique",
+        "history_desc": "Évolution des métriques par moteur au fil des runs ; "
+        "régressions signalées entre les deux derniers runs.",
+        "history_stat_runs": "mesures",
+        "history_trends_title": "Tendances",
+        "history_trends_desc": "Évolution du CER par moteur au fil des runs "
+        "(échelle locale). Pente OLS par jour ; rupture signalée seulement si "
+        "le test de Pettitt est significatif (p ≤ 0,05).",
+        "history_slope": "pente/j",
+        "history_rupture": "rupture dès",
+        "history_regressions_title": "Régressions",
+        "history_regressions_desc": "Métriques dégradées entre les deux runs les "
+        "plus récents (plus bas = meilleur).",
+        "history_no_regressions": "Aucune régression détectée.",
+        "history_log_title": "Journal des mesures",
+        "history_log_desc": "Chaque agrégat enregistré, du plus récent au plus ancien.",
+        "history_empty": "Aucun run enregistré pour l'instant.",
+        "history_col_run": "Run",
+        "history_col_pipeline": "Moteur",
+        "history_col_view": "Vue",
+        "history_col_metric": "Métrique",
+        "history_col_value": "Valeur",
+        "history_col_change": "Évolution",
+        "library_eyebrow": "VIEW · LIBRARY",
+        "library_title": "Bibliothèque de corpus",
+        "library_desc": "Corpus locaux et catalogues distants — toute la matière "
+        "en un seul endroit.",
+        "library_search_button": "Rechercher",
+        "library_demo_badge": "catalogue de démonstration (hors-ligne)",
+        "library_open": "ouvrir",
+        "library_corpora_title": "Mes corpus",
+        "library_local_title": "Corpus locaux",
+        "library_corpora_desc": "Téléversés, importés depuis HTR-United / "
+        "HuggingFace, ou pointés depuis le filesystem.",
+        "library_corpora_empty": "Aucun corpus local. Importez-en un.",
+        "library_corpora_cta": "Préparer un corpus",
+        "library_corpora_manage": "Corpus enregistrés",
+        "library_stat_local": "locaux",
+        "library_stat_pages": "pages",
+        "library_discover": "Découvrir",
+        "library_discover_desc": "Explorer une source à la fois, puis importer "
+        "ce qui est utile.",
+        "library_remote_title": "Sources distantes",
+        "library_catalogue": "catalogue",
+        "library_manifest": "manifeste",
+        "library_source_htr": "HTR-United",
+        "library_source_hf": "HuggingFace",
+        "library_source_iiif": "IIIF",
+        "library_source_gallica": "Gallica",
+        "library_source_escriptorium": "eScriptorium",
+        "library_source_curated": "Cinoc curé",
+        "library_curated_yours": "Vos datasets curés",
+        "library_curated_yours_hint": "Datasets curés Cinoc détectés sur votre "
+        "compte HuggingFace (tag cinoc-corpus) — importez-en un en un clic.",
+        "library_curated_empty": "Aucun dataset curé détecté automatiquement. Sur "
+        "un Space, vos datasets tagués cinoc-corpus apparaissent ici sans réglage ; "
+        "en local, posez un jeton HF ou CINOC_HF_AUTHOR. Sinon, importez par "
+        "identifiant ci-dessous.",
+        "library_zip_meta": "ZIP · max 500 MB · paires auto-détectées",
+        "library_ready": "prêt pour benchmark",
+        "library_add_desc": "Téléversez un ZIP (glisser-déposer) ou importez "
+        "depuis une source distante.",
+        "library_drop_hint": "Glissez un .zip ici ou cliquez pour sélectionner",
+        "library_doc_preview": "documents",
+        "library_gt_preview": "vérités terrain",
+        "library_source_label": "source",
+        "library_language_label": "langue",
+        "library_open_source": "Ouvrir la source",
+        "library_import_source": "Importer depuis cette source",
+        "library_search_hint_htr": "Filtrer le catalogue HTR-United",
+        "library_search_hint_hf": "Filtrer les datasets HuggingFace",
+        "library_use": "Utiliser",
+        "library_delete": "Supprimer",
+        "library_empty": "Aucun résultat.",
+        "lang_label": "Langue",
+    },
+    "en": {
+        "nav_library": "Library",
+        "nav_benchmark": "Benchmark",
+        "nav_reports": "Reports",
+        "nav_history": "History",
+        "nav_engines": "Engines",
+        "wordmark_sub": "OCR · HTR · VLM",
+        "hero_eyebrow": "Showcase · read-only",
+        "hero_desc": "Deterministic benchmark reports — "
+        "OCR / HTR / VLM on heritage corpora.",
+        "stat_reports": "reports",
+        "reports_title": "Generated reports",
+        "reports_desc": "Benchmark history, standalone HTML renders.",
+        "skip_to_content": "Skip to content",
+        "bench_progress_label": "Run progress",
+        "reports_empty": "no report available yet.",
+        "open_report": "Open",
+        "download_zip": "Download (ZIP)",
+        "download_alto": "Download ALTO (ZIP)",
+        "bench_eyebrow": "Benchmark · compare",
+        "bench_title": "Benchmark",
+        "bench_desc": "Compose competitors (OCR, OCR→LLM, VLM) and compare them "
+        "on a corpus, in a single run. No competitor: demonstration.",
+        "bench_run": "Run the benchmark",
+        "bench_launching": "Launching…",
+        "bench_status": "Status",
+        "bench_log": "Log",
+        "bench_idle": "Ready.",
+        "bench_net_error": "Network error.",
+        "bench_corpus": "Corpus",
+        "bench_corpus_none": "no corpus (demo)",
+        "bench_corpus_prepare": "Choose in the Library",
+        "bench_corpus_selected": "Corpus ready to run",
+        "bench_corpus_select_hint": "Select a prepared corpus, or stay in "
+        "demonstration mode.",
+        "bench_competitors": "Competitors",
+        "bench_add_competitor": "Add a competitor",
+        "bench_queue_empty": "No competitor added yet.",
+        "bench_queue_title": "Queue ready to run",
+        "bench_queue_hint": "Each row summarizes one pipeline that will actually run.",
+        "bench_remove": "Remove",
+        "bench_mode": "Mode",
+        "bench_mode_ocr": "OCR only",
+        "bench_mode_text": "OCR → LLM (text)",
+        "bench_mode_image": "OCR → LLM (image+text)",
+        "bench_mode_vlm": "VLM (zero-shot)",
+        "bench_mode_hybrid": "Hybrid (segmentation)",
+        "bench_ocr_engine": "OCR engine",
+        "bench_segmenter": "Segmenter",
+        "bench_segmenter_hint": "Detects regions at the head of the pipeline; the "
+        "remote one delegates to an HF endpoint (swap the model via the URL).",
+        "bench_recognizer": "Per-block recognizer",
+        "bench_recognizer_hint": "Engine applied to each cropped block: a real OCR, "
+        "or a VLM transcribing the block image (zero-shot). Assembled text scored "
+        "CER/WER like a flat pipeline.",
+        "bench_seg_preview": "Region preview",
+        "bench_seg_preview_btn": "Preview segmentation",
+        "bench_seg_preview_hint": "Runs the segmenter on the chosen corpus and shows "
+        "the detected regions (before launching the benchmark).",
+        "bench_seg_preview_no_corpus": "Pick a corpus first.",
+        "bench_llm": "LLM",
+        "bench_vlm": "VLM",
+        "bench_model": "Model",
+        "bench_model_ph": "model (optional)",
+        "bench_prompt": "Prompt",
+        "bench_prompt_ph": "Empty = default prompt. For correction, include "
+        "{ocr_text} where the OCR text should be inserted (else it is ignored).",
+        "bench_prompt_curated_none": "— Curated prompt (by period) —",
+        "bench_prompt_hint": "Pick a curated prompt OR write your own below "
+        "(free text takes precedence).",
+        "bench_ner": "Extract named entities (NER)",
+        "bench_ner_model_ph": "spaCy model (default fr_core_news_sm)",
+        "bench_ner_hint": "Adds a NER step at the end of the pipeline; scored "
+        "(F1) if the corpus carries an entity ground truth.",
+        "bench_alto": "Export ALTO (XML)",
+        "bench_alto_hint": "Tesseract only: produces one ALTO XML per document "
+        "(geometry + text), downloadable from the report — re-importable into "
+        "eScriptorium or Transkribus.",
+        "bench_normalization": "Normalization",
+        "bench_norm_preview": "Normalization preview",
+        "bench_norm_sample_ph": "Paste a text sample to see the effect…",
+        "bench_norm_custom": "Custom profile (YAML) — takes precedence if filled",
+        "bench_norm_config_ph": "caseless: true\nexclude_chars: \",.;:\"",
+        "bench_norm_preview_btn": "Preview",
+        "bench_char_exclude": "Characters to exclude",
+        "bench_char_exclude_ph": "e.g. ,.;:!? — excluded on both sides",
+        "bench_char_exclude_hint": "Filtered from GT AND hypothesis before scoring "
+        "(those characters are no longer measured).",
+        "bench_config_io": "Configuration",
+        "bench_config_export": "Export (JSON)",
+        "bench_config_import": "Import…",
+        "bench_config_loaded": "Configuration loaded.",
+        "bench_config_invalid": "Invalid configuration file.",
+        "bench_config_hint": "Saves the form state (competitors + options) as "
+        "JSON; reloadable later. No server persistence.",
+        "bench_metric_profile": "Metric profile",
+        "bench_metric_profile_hint": "Picks the report's ranking columns; does not "
+        "drop collected data (sections unchanged).",
+        "bench_options": "Options",
+        "bench_execute_desc": "Launch the run, then open the final report or "
+        "segmentation view.",
+        "bench_norm_none": "(none)",
+        "bench_error_422": "Incomplete or invalid configuration.",
+        "bench_error_404": "Corpus not found.",
+        "bench_error_409": "A required engine is unavailable.",
+        "bench_error_403": "Action denied in this mode.",
+        "bench_error_fallback": "Launch failed.",
+        # Remote corpus import
+        "imp_btn": "Import",
+        "imp_manifest": "IIIF manifest URL",
+        "imp_ark": "Gallica ARK (ark:/12148/…)",
+        "imp_ocr": "Include reference OCR",
+        "imp_base": "eScriptorium instance URL",
+        "imp_token": "API token",
+        "imp_doc": "Document PK",
+        "imp_layer": "Transcription layer",
+        "imp_limit": "Limit (pages)",
+        "imp_name": "Name (optional)",
+        "imp_repo": "HF repo (org/dataset-name)",
+        "imp_revision": "Revision (SHA — recommended for pinning)",
+        "imp_curated_hint": "Cinoc reference dataset published on HuggingFace: "
+        "the manifest and ground truth are fetched; images stay as remote "
+        "references (static IIIF served from HF, pinned to the revision), "
+        "downloaded automatically at run time.",
+        # Layout preview (launcher panel) + hybrid recognizer: useful remnants of
+        # the old /segmentation page, reused by the benchmark composer.
+        "seg_run_endpoint": "Endpoint (HF object-detection)",
+        "seg_run_endpoint_ph": "https://…",
+        "seg_run_token": "Token (optional)",
+        "seg_run_running": "Segmenting…",
+        "hyb_run_vlm": "VLM, zero-shot",
+        "open_report_full": "Open the report",
+        "sys_version": "Version",
+        "sys_mode": "Mode",
+        "sys_mode_value": "local · interactive",
+        "sys_active_job": "Active job",
+        "sys_idle": "idle",
+        "sys_details": "System details",
+        "sys_pipeline": "Pipeline",
+        "sys_pipeline_ready": "engines ready",
+        "sys_open": "System · details",
+        "engines_eyebrow": "Showcase · engines",
+        "engines_title": "Engines",
+        "engines_desc": "Runtime availability of the built-in engines: binary, SDK, "
+        "API key. A cloud engine is ready as soon as its SDK and key are present.",
+        "stat_ready": "ready",
+        "engines_col_engine": "Engine",
+        "engines_col_status": "Status",
+        "engines_col_detail": "Detail",
+        "engine_available": "available",
+        "engine_unavailable": "unavailable",
+        "history_eyebrow": "Showcase · longitudinal",
+        "history_title": "History",
+        "history_desc": "Per-engine metric evolution across runs; regressions "
+        "flagged between the two most recent runs.",
+        "history_stat_runs": "records",
+        "history_trends_title": "Trends",
+        "history_trends_desc": "CER evolution per engine across runs "
+        "(local scale). OLS slope per day; a change point is flagged only "
+        "when the Pettitt test is significant (p ≤ 0.05).",
+        "history_slope": "slope/day",
+        "history_rupture": "change point at",
+        "history_regressions_title": "Regressions",
+        "history_regressions_desc": "Metrics that worsened between the two most "
+        "recent runs (lower is better).",
+        "history_no_regressions": "No regression detected.",
+        "history_log_title": "Measurement log",
+        "history_log_desc": "Every recorded aggregate, most recent first.",
+        "history_empty": "No run recorded yet.",
+        "history_col_run": "Run",
+        "history_col_pipeline": "Engine",
+        "history_col_view": "View",
+        "history_col_metric": "Metric",
+        "history_col_value": "Value",
+        "history_col_change": "Change",
+        "library_eyebrow": "VIEW · LIBRARY",
+        "library_title": "Corpus library",
+        "library_desc": "Local corpora and remote catalogues — all your material "
+        "in one place.",
+        "library_search_button": "Search",
+        "library_demo_badge": "demo catalogue (offline)",
+        "library_open": "open",
+        "library_corpora_title": "My corpora",
+        "library_local_title": "Local corpora",
+        "library_corpora_desc": "Uploaded, imported from HTR-United / HuggingFace, "
+        "or pointed from the filesystem.",
+        "library_corpora_empty": "No local corpus. Import one.",
+        "library_corpora_cta": "Prepare a corpus",
+        "library_corpora_manage": "Stored corpora",
+        "library_stat_local": "local",
+        "library_stat_pages": "pages",
+        "library_discover": "Discover",
+        "library_discover_desc": "Explore one source at a time, then import only "
+        "what matters.",
+        "library_remote_title": "Remote sources",
+        "library_catalogue": "catalogue",
+        "library_manifest": "manifest",
+        "library_source_htr": "HTR-United",
+        "library_source_hf": "HuggingFace",
+        "library_source_iiif": "IIIF",
+        "library_source_gallica": "Gallica",
+        "library_source_escriptorium": "eScriptorium",
+        "library_source_curated": "Cinoc curated",
+        "library_curated_yours": "Your curated datasets",
+        "library_curated_yours_hint": "Cinoc curated datasets found on your "
+        "HuggingFace account (cinoc-corpus tag) — import one in a click.",
+        "library_curated_empty": "No curated dataset detected automatically. On a "
+        "Space, your cinoc-corpus-tagged datasets appear here with no setup; locally, "
+        "set an HF token or CINOC_HF_AUTHOR. Otherwise, import by id below.",
+        "library_zip_meta": "ZIP · max 500 MB · pairs auto-detected",
+        "library_ready": "ready for benchmark",
+        "library_add_desc": "Upload a ZIP (drag-and-drop) or import from a "
+        "remote source.",
+        "library_drop_hint": "Drop a .zip here or click to select",
+        "library_doc_preview": "documents",
+        "library_gt_preview": "ground truths",
+        "library_source_label": "source",
+        "library_language_label": "language",
+        "library_open_source": "Open source",
+        "library_import_source": "Import from this source",
+        "library_search_hint_htr": "Filter the HTR-United catalogue",
+        "library_search_hint_hf": "Filter HuggingFace datasets",
+        "library_use": "Use",
+        "library_delete": "Delete",
+        "library_empty": "No result.",
+        "lang_label": "Language",
+    },
+}
+
+
+def normalize_lang(raw: str | None) -> str:
+    """Code de langue servi : ``raw`` s'il est connu, sinon le défaut FR."""
+    return raw if raw in LANGUAGES else DEFAULT_LANG
+
+
+def strings_for(lang: str) -> dict[str, str]:
+    """Dictionnaire de chaînes pour ``lang`` (normalisé)."""
+    return _STRINGS[normalize_lang(lang)]
+
+
+__all__ = ["DEFAULT_LANG", "LANGUAGES", "normalize_lang", "strings_for"]
diff --git a/cinoc/interfaces/web/metrics.py b/cinoc/interfaces/web/metrics.py
new file mode 100644
index 0000000000000000000000000000000000000000..84ca2589fdfb12e8e6f3b44c98638d2ea6a5c00c
--- /dev/null
+++ b/cinoc/interfaces/web/metrics.py
@@ -0,0 +1,74 @@
+"""Observabilité Prometheus **opt-in** (couche 8) — compteur de requêtes HTTP.
+
+Activée **seulement si demandée** (``create_app(metrics=…)`` ou env
+``CINOC_METRICS``) : un Space exposé ne fuit pas ses statistiques par défaut. On
+compte les requêtes par ``(méthode, statut)`` — **cardinalité basse** (jamais le
+chemin brut, qui exploserait la cardinalité) — et on les expose au format texte
+Prometheus sur ``/metrics``. État **par application** (aucun global de module → la
+factory ``create_app`` reste respectée), **thread-safe** (le ``JobRunner`` sert en
+parallèle). Sans dépendance externe : l'exposition est un format texte stable.
+"""
+
+from __future__ import annotations
+
+import threading
+from collections import Counter
+
+from starlette.types import ASGIApp, Message, Receive, Scope, Send
+
+_CONTENT_TYPE = "text/plain; version=0.0.4; charset=utf-8"
+
+
+class RequestMetrics:
+    """Compteur **thread-safe** de requêtes HTTP par ``(méthode, statut)``."""
+
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+        self._counts: Counter[tuple[str, int]] = Counter()
+
+    def record(self, method: str, status: int) -> None:
+        with self._lock:
+            self._counts[(method, status)] += 1
+
+    def render(self) -> str:
+        """Exposition Prometheus (texte) — **déterministe** (clés triées)."""
+        lines = [
+            "# HELP cinoc_requests_total Total HTTP requests handled.",
+            "# TYPE cinoc_requests_total counter",
+        ]
+        with self._lock:
+            items = sorted(self._counts.items())
+        for (method, status), count in items:
+            lines.append(
+                f"cinoc_requests_total"
+                f'{{method="{method}",status="{status}"}} {count}'
+            )
+        return "\n".join(lines) + "\n"
+
+    @property
+    def content_type(self) -> str:
+        return _CONTENT_TYPE
+
+
+class MetricsMiddleware:
+    """Enregistre méthode + statut final de chaque requête HTTP (ASGI pur)."""
+
+    def __init__(self, app: ASGIApp, metrics: RequestMetrics) -> None:
+        self._app = app
+        self._metrics = metrics
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            await self._app(scope, receive, send)
+            return
+        method = str(scope.get("method", "GET"))
+
+        async def send_counting(message: Message) -> None:
+            if message["type"] == "http.response.start":
+                self._metrics.record(method, int(message["status"]))
+            await send(message)
+
+        await self._app(scope, receive, send_counting)
+
+
+__all__ = ["MetricsMiddleware", "RequestMetrics"]
diff --git a/cinoc/interfaces/web/routers/__init__.py b/cinoc/interfaces/web/routers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a1dbaf28ae539e18298d23ee9cdb82fd1af8a51e
--- /dev/null
+++ b/cinoc/interfaces/web/routers/__init__.py
@@ -0,0 +1,9 @@
+"""Routeurs HTTP (couche 8) — chacun est une **fonction builder**.
+
+``no_side_effect_imports`` interdit ``APIRouter()`` au niveau module (fabrique à
+effet de bord) : un routeur se construit donc **dans une fonction**
+(``build_*_router(...) -> APIRouter``) appelée par ``create_app``. Mince, sans
+effet de bord à l'import.
+"""
+
+from __future__ import annotations
diff --git a/cinoc/interfaces/web/routers/corpus.py b/cinoc/interfaces/web/routers/corpus.py
new file mode 100644
index 0000000000000000000000000000000000000000..9de46affc921c29b9ec40fe80d67b08aa24bc707
--- /dev/null
+++ b/cinoc/interfaces/web/routers/corpus.py
@@ -0,0 +1,253 @@
+"""Routeur **corpus** : upload ZIP **et** imports distants (couche 8).
+
+``POST /api/corpus`` (multipart, **CSRF**) → ``CorpusStore`` valide et matérialise
+une archive. ``POST /api/corpus/import/{iiif,escriptorium,gallica,huggingface,
+curated}`` (JSON, **CSRF**) importent un corpus distant → ``CorpusSpec`` via la
+couche 6 (même seam ``CorpusStore.materialize``). ``curated`` rapatrie un **dataset
+curé Cinoc publié sur HF** (manifeste + GT seulement, images en réfs IIIF pinnées).
+``GET /api/corpus/{id}`` restitue le résumé. Tout corpus stocké est une cible de run.
+
+La taille de l'archive est plafonnée **deux fois** : lecture bornée ici (``413``),
+puis quotas fins dans ``extract_corpus_zip`` (``422``).
+
+**Mode public** : les imports distants **fetchent une URL côté serveur** (surface
+SSRF) → **refusés en mode public** (``403``), comme les moteurs cloud. L'``_http``
+interne bloque déjà les IP non publiques ; on n'ouvre simplement pas la prise sur
+un Space exposé. Le token eScriptorium voyage dans le corps (Space privé) et n'est
+jamais journalisé.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, File, HTTPException, UploadFile
+from pydantic import BaseModel, ConfigDict, Field
+
+from cinoc.adapters.corpus._http import CorpusHttpError
+from cinoc.adapters.corpus.gallica import GallicaArkError
+from cinoc.adapters.corpus.huggingface import (
+    HuggingFaceConventionError,
+    HuggingFaceUnavailableError,
+)
+from cinoc.app.corpus_import import (
+    CorpusImportError,
+    import_curated_hf_corpus,
+    import_escriptorium_corpus,
+    import_gallica_corpus,
+    import_hf_corpus,
+    import_iiif_corpus,
+)
+from cinoc.app.corpus_upload import MAX_ZIP_BYTES, CorpusStore, CorpusUploadError
+from cinoc.domain.corpus import CorpusSpec
+from cinoc.interfaces.web.security.csrf import csrf_protect
+
+#: Échecs d'import « attendus » (entrée invalide / source injoignable) → 422.
+_IMPORT_ERRORS = (
+    CorpusImportError,
+    CorpusHttpError,
+    GallicaArkError,
+    HuggingFaceConventionError,
+)
+
+
+class IIIFImportRequest(BaseModel):
+    """Corps d'``POST /api/corpus/import/iiif``."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    manifest_url: str = Field(min_length=1, max_length=2048)
+    name: str | None = Field(default=None, max_length=128)
+    #: Borne le nombre de pages importées (les premières) — protège le Space.
+    limit: int | None = Field(default=None, ge=1, le=500)
+
+
+class EScriptoriumImportRequest(BaseModel):
+    """Corps d'``POST /api/corpus/import/escriptorium``."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    base_url: str = Field(min_length=1, max_length=2048)
+    token: str = Field(min_length=1, max_length=512)
+    doc_pk: int = Field(ge=1)
+    name: str | None = Field(default=None, max_length=128)
+    layer: str = Field(default="manual", max_length=128)
+    limit: int | None = Field(default=None, ge=1, le=2000)
+
+
+class GallicaImportRequest(BaseModel):
+    """Corps d'``POST /api/corpus/import/gallica``."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    ark: str = Field(min_length=1, max_length=512)
+    name: str | None = Field(default=None, max_length=128)
+    limit: int | None = Field(default=None, ge=1, le=500)
+    include_ocr: bool = True
+
+
+class HuggingFaceImportRequest(BaseModel):
+    """Corps d'``POST /api/corpus/import/huggingface``."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    dataset_id: str = Field(min_length=1, max_length=256)
+    split: str = Field(default="train", min_length=1, max_length=64)
+    name: str | None = Field(default=None, max_length=128)
+    #: Borne le nombre de pages **streamées** (les premières) — protège le Space.
+    limit: int | None = Field(default=None, ge=1, le=2000)
+
+
+class CuratedImportRequest(BaseModel):
+    """Corps d'``POST /api/corpus/import/curated`` (dataset curé Cinoc publié sur HF).
+
+    ``revision`` (SHA du commit HF) épingle la reproductibilité ET les URLs IIIF
+    des images : la fournir est **recommandé** (sinon ``main``, mouvant).
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    repo_id: str = Field(min_length=1, max_length=256)
+    revision: str | None = Field(default=None, max_length=64)
+    name: str | None = Field(default=None, max_length=128)
+
+
+def build_corpus_router(store: CorpusStore, *, public_mode: bool = False) -> APIRouter:
+    """Construit le routeur corpus (upload + imports distants)."""
+    router = APIRouter()
+
+    def _summary(corpus_id: str, spec: CorpusSpec) -> dict[str, object]:
+        """Résumé d'un corpus créé : la réponse de création **est** le résumé
+        (corpus_id + nom + nombre de documents + liste des ids) — pas de GET
+        séparé à re-interroger."""
+        return {
+            "corpus_id": corpus_id,
+            "name": spec.name,
+            "n_documents": len(spec.documents),
+            "documents": [doc.id for doc in spec.documents],
+        }
+
+    def _materialize(builder: Callable[..., CorpusSpec]) -> dict[str, object]:
+        """Gate mode public → matérialise via le store → résumé (erreurs → 422)."""
+        if public_mode:
+            raise HTTPException(
+                status_code=403, detail="import distant refusé (mode public)."
+            )
+        try:
+            corpus_id, spec = store.materialize(builder)
+        except HuggingFaceUnavailableError as exc:
+            # Extra absent côté serveur (≠ faute de l'appelant) → indisponible.
+            raise HTTPException(status_code=409, detail=str(exc)) from exc
+        except _IMPORT_ERRORS as exc:
+            raise HTTPException(status_code=422, detail=str(exc)) from exc
+        return _summary(corpus_id, spec)
+
+    @router.post(
+        "/api/corpus/import/iiif",
+        status_code=201,
+        dependencies=[Depends(csrf_protect)],
+    )
+    def import_iiif(req: IIIFImportRequest) -> dict[str, object]:
+        return _materialize(
+            lambda dest: import_iiif_corpus(
+                req.manifest_url, dest, name=req.name or "iiif", limit=req.limit
+            )
+        )
+
+    @router.post(
+        "/api/corpus/import/escriptorium",
+        status_code=201,
+        dependencies=[Depends(csrf_protect)],
+    )
+    def import_escriptorium(req: EScriptoriumImportRequest) -> dict[str, object]:
+        return _materialize(
+            lambda dest: import_escriptorium_corpus(
+                req.base_url,
+                req.token,
+                req.doc_pk,
+                dest,
+                name=req.name,
+                layer=req.layer,
+                limit=req.limit,
+            )
+        )
+
+    @router.post(
+        "/api/corpus/import/gallica",
+        status_code=201,
+        dependencies=[Depends(csrf_protect)],
+    )
+    def import_gallica(req: GallicaImportRequest) -> dict[str, object]:
+        return _materialize(
+            lambda dest: import_gallica_corpus(
+                req.ark,
+                dest,
+                name=req.name,
+                limit=req.limit,
+                include_ocr=req.include_ocr,
+            )
+        )
+
+    @router.post(
+        "/api/corpus/import/huggingface",
+        status_code=201,
+        dependencies=[Depends(csrf_protect)],
+    )
+    def import_huggingface(req: HuggingFaceImportRequest) -> dict[str, object]:
+        return _materialize(
+            lambda dest: import_hf_corpus(
+                req.dataset_id,
+                dest,
+                name=req.name,
+                split=req.split,
+                limit=req.limit,
+            )
+        )
+
+    @router.post(
+        "/api/corpus/import/curated",
+        status_code=201,
+        dependencies=[Depends(csrf_protect)],
+    )
+    def import_curated(req: CuratedImportRequest) -> dict[str, object]:
+        return _materialize(
+            lambda dest: import_curated_hf_corpus(
+                req.repo_id, dest, revision=req.revision, name=req.name
+            )
+        )
+
+    @router.post(
+        "/api/corpus", status_code=201, dependencies=[Depends(csrf_protect)]
+    )
+    async def upload_corpus(
+        file: Annotated[UploadFile, File()],
+    ) -> dict[str, object]:
+        data = await file.read(MAX_ZIP_BYTES + 1)
+        if len(data) > MAX_ZIP_BYTES:
+            raise HTTPException(status_code=413, detail="archive trop volumineuse.")
+        try:
+            corpus_id, spec = store.save(file.filename or "corpus", data)
+        except CorpusUploadError as exc:
+            raise HTTPException(status_code=422, detail=str(exc)) from exc
+        return _summary(corpus_id, spec)
+
+    @router.delete(
+        "/api/corpus/{corpus_id}", dependencies=[Depends(csrf_protect)]
+    )
+    def delete_corpus(corpus_id: str) -> dict[str, bool]:
+        if not store.delete(corpus_id):
+            raise HTTPException(status_code=404, detail="corpus introuvable.")
+        return {"deleted": True}
+
+    return router
+
+
+__all__ = [
+    "CuratedImportRequest",
+    "EScriptoriumImportRequest",
+    "GallicaImportRequest",
+    "HuggingFaceImportRequest",
+    "IIIFImportRequest",
+    "build_corpus_router",
+]
diff --git a/cinoc/interfaces/web/routers/engines.py b/cinoc/interfaces/web/routers/engines.py
new file mode 100644
index 0000000000000000000000000000000000000000..480da537b12f28064fde991dda76ec5458931154
--- /dev/null
+++ b/cinoc/interfaces/web/routers/engines.py
@@ -0,0 +1,65 @@
+"""Routeur d'aide au composeur (couche 8) : aperçu de normalisation + modèles.
+
+Endpoints **vivants** (consommés par le JS du Banc d'essai) : aperçu de
+normalisation (POST, CSRF) et suggestions de modèles par fournisseur (GET). Les
+listes de lecture (profils de normalisation/métriques, état des moteurs) sont
+rendues **côté serveur** dans les pages — pas d'API JSON dédiée.
+"""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel, ConfigDict, Field
+
+from cinoc.app.models import provider_models
+from cinoc.app.normalization_preview import (
+    NormalizationPreviewError,
+    preview_normalization,
+)
+from cinoc.interfaces.web.security.csrf import csrf_protect
+
+
+class PreviewRequest(BaseModel):
+    """Aperçu de normalisation : un échantillon + un profil **ou** une config YAML."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    sample: str = Field(max_length=4000)
+    profile: str | None = Field(default=None, max_length=64)
+    config: str | None = Field(default=None, max_length=8000)
+
+
+def build_engines_router() -> APIRouter:
+    """Construit le routeur d'aide au composeur (monté par ``create_app``)."""
+    router = APIRouter()
+
+    @router.post(
+        "/api/normalization/preview", dependencies=[Depends(csrf_protect)]
+    )
+    def preview(req: PreviewRequest) -> dict[str, str]:
+        """Normalise un échantillon par un profil nommé OU une config YAML custom.
+
+        **Sans persistance** : la config custom est appliquée à la volée, jamais
+        stockée. Profil inconnu / config invalide → ``422`` (jamais un défaut muet)."""
+        try:
+            normalized = preview_normalization(
+                req.sample, profile=req.profile, config=req.config
+            )
+        except NormalizationPreviewError as exc:
+            raise HTTPException(status_code=422, detail=str(exc)) from exc
+        return {"normalized": normalized}
+
+    @router.get("/api/models/{model_provider}")
+    def list_models(model_provider: str) -> dict[str, object]:
+        """Modèles canoniques d'un fournisseur + capacité vision (suggestions UI).
+
+        Fournisseur inconnu → liste vide (200) : le champ ``model`` reste libre."""
+        return {
+            "provider": model_provider,
+            "models": [m.model_dump() for m in provider_models(model_provider)],
+        }
+
+    return router
+
+
+__all__ = ["build_engines_router"]
diff --git a/cinoc/interfaces/web/routers/home.py b/cinoc/interfaces/web/routers/home.py
new file mode 100644
index 0000000000000000000000000000000000000000..5053ba20eef3bd6367bed444cfd0e982d7a1e8d7
--- /dev/null
+++ b/cinoc/interfaces/web/routers/home.py
@@ -0,0 +1,347 @@
+"""Routeur des **vues de la coquille** (couche 8) : accueil · Banc d'essai · Moteurs.
+
+Rendu **serveur** (Jinja2 + tokens/polices du design) ; le Banc d'essai ajoute
+un **JS léger auto-hébergé** (EventSource pour le SSE) — toujours pas de SPA. La
+page « Moteurs » est, elle, **100 % rendue serveur** (aucun JS) : elle lit l'état
+des moteurs (`app.engines`) côté serveur. Le rail réserve **tous** les
+emplacements de nav ; les vivants sont liés, les autres restent « à venir ».
+"""
+
+from __future__ import annotations
+
+import logging
+import sqlite3
+from collections.abc import Callable
+from pathlib import Path
+from urllib.parse import quote
+
+from fastapi import APIRouter, Request
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+
+from cinoc.adapters.corpus.htr_united import HTRUnitedCatalogue, fetch_catalogue
+from cinoc.adapters.corpus.huggingface import (
+    CuratedDatasetRef,
+    HuggingFaceCatalogue,
+    HuggingFaceDataset,
+    discover_curated,
+)
+from cinoc.adapters.storage.history_store import HistoryRecord, HistoryStore
+from cinoc.app import resolve_code_version
+from cinoc.app.alto_store import AltoStore
+from cinoc.app.corpus_upload import CorpusStore
+from cinoc.app.engines import (
+    EngineStatus,
+    StatusProvider,
+    curated_prompts,
+    installed_mistral_models,
+    installed_ollama_models,
+)
+from cinoc.app.history import series_insight
+from cinoc.app.run_planning import benchmark_engine_catalog, metric_profile_catalog
+from cinoc.app.structure_planning import hybrid_recognizer_catalog
+from cinoc.formats.text import NORMALIZATION_PROFILES
+from cinoc.interfaces.web._cache import TTLCache
+from cinoc.interfaces.web.catalog import available_reports
+from cinoc.interfaces.web.i18n import normalize_lang, strings_for
+from cinoc.interfaces.web.sparkline import sparkline_svg
+
+logger = logging.getLogger(__name__)
+
+#: TTL des catalogues de découverte (F1) : la page Bibliothèque ne refetch plus
+#: à chaque chargement. Fenêtre courte — la fraîcheur prime sur le cache.
+_CATALOGUE_TTL_SECONDS = 300.0
+
+#: Vues **vivantes** : id de nav → chemin. (La segmentation n'a plus de page
+#: dédiée : elle se compose comme un concurrent *hybride* du Banc d'essai.)
+_VIEW_PATHS = {
+    "library": "/library",
+    "reports": "/",
+    "benchmark": "/benchmark",
+    "history": "/history",
+    "engines": "/engines",
+}
+_PRIMARY_NAV_IDS = ("library", "benchmark", "reports", "history")
+_SECONDARY_NAV_IDS = ("engines",)
+
+
+def _nav_items(
+    ids: tuple[str, ...],
+    t: dict[str, str],
+    lang: str,
+    active: str,
+    metas: dict[str, str],
+) -> list[dict[str, str]]:
+    """Construit les entrées de navigation pour un groupe d'identifiants."""
+    items: list[dict[str, str]] = []
+    for nav_id in ids:
+        items.append(
+            {
+                "id": nav_id,
+                "label": t[f"nav_{nav_id}"],
+                "state": "active" if nav_id == active else "link",
+                "href": f"{_VIEW_PATHS[nav_id]}?lang={lang}",
+                "meta": metas.get(nav_id, ""),
+            }
+        )
+    return items
+
+
+def _corpora_summaries(corpus_store: CorpusStore | None) -> list[dict[str, object]]:
+    """Résumés des corpus enregistrés pour l'UI Bibliothèque/Benchmark."""
+    if corpus_store is None:
+        return []
+    summaries: list[dict[str, object]] = []
+    for cid, spec in corpus_store.list_corpora():
+        docs = spec.documents
+        summaries.append(
+            {
+                "id": cid,
+                "name": spec.name,
+                "n_documents": len(docs),
+                "n_ground_truth": sum(1 for doc in docs if doc.ground_truths),
+                "preview_ids": [doc.id for doc in docs[:3]],
+                "source": spec.metadata.get("source", ""),
+                "language": spec.metadata.get("language", ""),
+            }
+        )
+    return summaries
+
+
+def _cer_trends(
+    history_store: HistoryStore, records: tuple[HistoryRecord, ...]
+) -> list[dict[str, object]]:
+    """Sparklines CER : une série chronologique par ``(pipeline, vue)``.
+
+    Données réelles du store (``history``) — aucune ré-agrégation ici : la
+    tendance OLS et la rupture (Pettitt) viennent d'``app.history`` (couche 6).
+    Ordre stable (première apparition dans ``records``, plus récent d'abord).
+    """
+    seen: set[tuple[str, str]] = set()
+    trends: list[dict[str, object]] = []
+    for record in records:
+        if record.metric != "cer":
+            continue
+        key = (record.pipeline, record.view)
+        if key in seen:
+            continue
+        seen.add(key)
+        series = history_store.history(record.pipeline, record.view, "cer")
+        values = [s.value for s in series]
+        insight = series_insight(series)
+        trends.append(
+            {
+                "pipeline": record.pipeline,
+                "view": record.view,
+                "latest": values[-1] if values else None,
+                "n": len(values),
+                "svg": sparkline_svg(values),
+                "slope": (
+                    insight.trend.slope_per_day
+                    if insight.trend is not None
+                    else None
+                ),
+                "r_squared": (
+                    insight.trend.r_squared if insight.trend is not None else None
+                ),
+                # Rupture affichée seulement si significative (p ≤ α) — le
+                # test de Pettitt remplace le max-diff qui « trouvait » toujours.
+                "rupture": (
+                    {
+                        "run_id": insight.rupture_run_id,
+                        "delta": insight.rupture.delta,
+                        "p_value": insight.rupture.p_value,
+                    }
+                    if insight.rupture is not None and insight.rupture.significant
+                    else None
+                ),
+            }
+        )
+    return trends
+
+
+def build_home_router(
+    reports_dir: Path,
+    templates: Jinja2Templates,
+    *,
+    statuses: StatusProvider,
+    segmenters: StatusProvider,
+    ner: Callable[[], EngineStatus] | None = None,
+    history_store: HistoryStore,
+    corpus_store: CorpusStore | None = None,
+    curated_author: str | None = None,
+    public_mode: bool = False,
+    alto_store: AltoStore | None = None,
+) -> APIRouter:
+    """Construit le routeur des vues de la coquille (monté par ``create_app``)."""
+    router = APIRouter()
+    app_version = resolve_code_version()
+    # Caches TTL partagés par toutes les requêtes /library (F1) : fin du fetch
+    # réseau à chaque chargement. HTR-United (index, indépendant de la requête)
+    # et HuggingFace (par requête ``q``).
+    htr_cache: TTLCache[str, HTRUnitedCatalogue] = TTLCache(_CATALOGUE_TTL_SECONDS)
+    hf_cache: TTLCache[str, tuple[HuggingFaceDataset, ...]] = TTLCache(
+        _CATALOGUE_TTL_SECONDS
+    )
+    # Datasets curés du compte HF configuré (``CINOC_HF_AUTHOR``) : découverts par
+    # tag de convention, mis en cache TTL comme les autres catalogues distants.
+    curated_cache: TTLCache[str, tuple[CuratedDatasetRef, ...]] = TTLCache(
+        _CATALOGUE_TTL_SECONDS
+    )
+
+    def _base_context(
+        lang: str, active: str, metas: dict[str, str]
+    ) -> dict[str, object]:
+        t = strings_for(lang)
+        engine_list = tuple(statuses())
+        n_ready = sum(1 for status in engine_list if status.available)
+        engine_labels = [status.label for status in engine_list if status.available][:3]
+        return {
+            "lang": lang,
+            "t": t,
+            "primary_nav": _nav_items(_PRIMARY_NAV_IDS, t, lang, active, metas),
+            "secondary_nav": _nav_items(_SECONDARY_NAV_IDS, t, lang, active, metas),
+            "version": app_version,
+            "view_path": _VIEW_PATHS[active],
+            "system_pipeline": {
+                "ready": n_ready,
+                "total": len(engine_list),
+                "labels": engine_labels,
+            },
+            # Les imports distants fetchent côté serveur → masqués en mode public
+            # (l'endpoint les refuse de toute façon : 403).
+            "public_mode": public_mode,
+        }
+
+    @router.get("/", response_class=HTMLResponse)
+    def home(request: Request, lang: str = "fr") -> HTMLResponse:
+        lang = normalize_lang(lang)
+        names = available_reports(reports_dir)
+        context = _base_context(lang, "reports", {"reports": str(len(names))})
+        context["reports"] = [
+            {
+                "name": name,
+                "href": f"/reports/{quote(name, safe='')}",
+                "zip_href": f"/reports/{quote(name, safe='')}/bundle.zip",
+                # Lien ALTO présent seulement si le run a produit un export (sinon
+                # l'endpoint répondrait 404) → pas de bouton mort dans la liste.
+                "alto_href": (
+                    f"/reports/{quote(name, safe='')}/alto.zip"
+                    if alto_store is not None and alto_store.has(name)
+                    else None
+                ),
+            }
+            for name in names
+        ]
+        context["n_reports"] = len(names)
+        return templates.TemplateResponse(request, "home.html", context)
+
+    @router.get("/benchmark", response_class=HTMLResponse)
+    def benchmark(request: Request, lang: str = "fr") -> HTMLResponse:
+        lang = normalize_lang(lang)
+        context = _base_context(lang, "benchmark", {})
+        # Catalogue moteurs par rôle (ocr/llm/vlm) : options rendues **serveur**
+        # (testables) ; le composeur JS ne fait qu'assembler les concurrents.
+        context["catalog"] = benchmark_engine_catalog(statuses())
+        # Mode **hybride** du composeur : segmenteurs du socle + reconnaisseurs
+        # par bloc (OCR réels + VLM zero-shot) — mêmes ensembles que le planner
+        # accepte (anti-vide). Le « segmenteur → bloc → texte » devient un
+        # concurrent scoré côte à côte avec les pipelines à plat.
+        context["segmenters"] = list(segmenters())
+        context["recognizers"] = hybrid_recognizer_catalog(statuses())
+        # Modèles ollama installés → menu déroulant (au lieu d'une saisie à
+        # l'aveugle). Best-effort : serveur éteint → liste vide, saisie libre.
+        context["ollama_models"] = installed_ollama_models()
+        # Modèles Mistral disponibles pour la clé → menu déroulant dynamique.
+        context["mistral_models"] = installed_mistral_models()
+        # Le corpus est préparé dans la Bibliothèque ; ici on le sélectionne.
+        context["corpora"] = _corpora_summaries(corpus_store)
+        # Profils de normalisation lus **dynamiquement** depuis formats/text
+        # (jamais figés en dur) ; le profil choisi alimente la vue d'évaluation.
+        context["profiles"] = [
+            {"name": p.name, "description": p.description}
+            for p in NORMALIZATION_PROFILES.values()
+        ]
+        # Profils de métriques (colonnes de classement de la vue ``text``) :
+        # même source que le plan (anti-vide) ; libellé self-documenté côté form.
+        context["metric_profiles"] = metric_profile_catalog()
+        # Prompts curés par période (lus dynamiquement) → menu déroulant ; le
+        # texte libre du formulaire reste prioritaire (résolu au plan).
+        context["curated_prompts"] = list(curated_prompts())
+        # Étape NER (extra [ner]) : son statut active/désactive la case « NER » du
+        # composeur (désactivée + motif si spaCy absent).
+        context["ner"] = ner() if ner is not None else None
+        return templates.TemplateResponse(request, "benchmark.html", context)
+
+    @router.get("/library", response_class=HTMLResponse)
+    def library(request: Request, lang: str = "fr", q: str = "") -> HTMLResponse:
+        lang = normalize_lang(lang)
+        # Découverte best-effort : HTR-United (réseau → repli démo `is_demo`),
+        # HuggingFace (socle de référence + API best-effort). Aucun blocage si
+        # hors-ligne. Catalogues mis en cache TTL (F1) → pas de refetch par
+        # chargement ; ``.search(q)`` de HTR-United reste en mémoire (gratuit).
+        catalogue = htr_cache.get_or_compute("htr_united", fetch_catalogue)
+        htr = catalogue.search(q) if q else catalogue.entries
+        hf = hf_cache.get_or_compute(q, lambda: HuggingFaceCatalogue().search(q))
+        # Datasets curés du compte configuré (apparaissent sans coller le repo_id).
+        # Best-effort + TTL : compte absent → tuple vide (l'import manuel reste).
+        curated: tuple[CuratedDatasetRef, ...] = ()
+        if curated_author:
+            author = curated_author
+            curated = curated_cache.get_or_compute(
+                author, lambda: discover_curated(author)
+            )
+        corpora = _corpora_summaries(corpus_store)
+        context = _base_context(lang, "library", {"library": str(len(htr) + len(hf))})
+        context["query"] = q
+        context["corpora"] = corpora
+        context["htr_entries"] = htr
+        context["htr_is_demo"] = catalogue.is_demo
+        context["hf_datasets"] = hf
+        context["curated_datasets"] = curated
+        context["n_corpora"] = len(corpora)
+        context["n_htr"] = len(htr)
+        context["n_hf"] = len(hf)
+        context["n_pages"] = sum(int(c["n_documents"]) for c in corpora)  # type: ignore[call-overload]
+        return templates.TemplateResponse(request, "library.html", context)
+
+    @router.get("/history", response_class=HTMLResponse)
+    def history(request: Request, lang: str = "fr") -> HTMLResponse:
+        lang = normalize_lang(lang)
+        try:
+            records = history_store.all_records()
+            # Régressions pour chaque (vue, métrique) enregistrée : lecture du
+            # store, pas de ré-agrégation (cf. CLAUDE §8.3).
+            pairs = sorted({(r.view, r.metric) for r in records})
+            regressions = [
+                reg
+                for view, metric in pairs
+                for reg in history_store.regressions(view, metric)
+            ]
+            trends = _cer_trends(history_store, records)
+        except sqlite3.Error as exc:
+            # Stockage indisponible (ex. dossier non inscriptible sur un Space) :
+            # la page se dégrade au lieu de renvoyer une 500.
+            logger.warning("[history] historique indisponible : %s", exc)
+            records, regressions, trends = (), [], []
+        context = _base_context(lang, "history", {"history": str(len(records))})
+        context["records"] = records
+        context["regressions"] = regressions
+        context["trends"] = trends
+        return templates.TemplateResponse(request, "history.html", context)
+
+    @router.get("/engines", response_class=HTMLResponse)
+    def engines(request: Request, lang: str = "fr") -> HTMLResponse:
+        lang = normalize_lang(lang)
+        engine_list = statuses()
+        n_ready = sum(1 for s in engine_list if s.available)
+        context = _base_context(lang, "engines", {"engines": str(n_ready)})
+        context["engines"] = engine_list
+        context["n_ready"] = n_ready
+        context["n_engines"] = len(engine_list)
+        return templates.TemplateResponse(request, "engines.html", context)
+
+    return router
+
+
+__all__ = ["build_home_router"]
diff --git a/cinoc/interfaces/web/routers/reports.py b/cinoc/interfaces/web/routers/reports.py
new file mode 100644
index 0000000000000000000000000000000000000000..23596f29c1c3dac765b07cf99b3a50269344eb30
--- /dev/null
+++ b/cinoc/interfaces/web/routers/reports.py
@@ -0,0 +1,109 @@
+"""Routeur vitrine : liste des rapports + rendu HTML d'un ``RunResult`` sauvé."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import HTMLResponse, Response
+
+from cinoc.app.alto_store import AltoStore
+from cinoc.app.report_images import (
+    build_facsimiles,
+    build_report_zip,
+    build_thumbnails,
+)
+from cinoc.app.results import RunResultError, load_run_result
+from cinoc.app.security import PathSecurityError
+from cinoc.interfaces.web.catalog import resolve_report
+from cinoc.reports import default_report_renderer
+
+
+def build_reports_router(
+    reports_dir: Path, *, alto_store: AltoStore | None = None
+) -> APIRouter:
+    """Construit le routeur des rapports (monté par ``create_app``).
+
+    ``alto_store`` (optionnel) sert les exports ALTO persistés d'un run via
+    ``/reports/{name}/alto.zip`` ; absent → l'endpoint répond ``404``.
+    """
+    router = APIRouter()
+
+    @router.get("/reports/{name}", response_class=HTMLResponse)
+    def get_report(name: str, lang: str = "fr") -> str:
+        try:
+            path = resolve_report(reports_dir, name)
+        except PathSecurityError as exc:
+            # introuvable OU hors zone → même réponse (pas de fuite).
+            raise HTTPException(status_code=404, detail="rapport introuvable") from exc
+        try:
+            result = load_run_result(path)
+        except RunResultError as exc:
+            raise HTTPException(status_code=500, detail="rapport illisible") from exc
+        # Langue du glossaire pédagogique (fr par défaut ; en seul autre porté).
+        report_lang = "en" if lang == "en" else "fr"
+        return default_report_renderer().render(
+            result,
+            title=f"Cinoc — {result.manifest.run_id}",
+            lang=report_lang,
+            images=build_thumbnails(result),
+            facsimiles=build_facsimiles(result),
+        )
+
+    @router.get("/reports/{name}/bundle.zip")
+    def get_report_bundle(name: str, lang: str = "fr") -> Response:
+        """Télécharge le rapport en **bundle dossier zippé** (saveur dossier) :
+        ``report.html`` + ``report-assets/`` (images réelles, hors-ligne). Rendu
+        à la demande depuis le ``RunResult`` sauvé — rien de pré-écrit."""
+        try:
+            path = resolve_report(reports_dir, name)
+        except PathSecurityError as exc:
+            raise HTTPException(status_code=404, detail="rapport introuvable") from exc
+        try:
+            result = load_run_result(path)
+        except RunResultError as exc:
+            raise HTTPException(status_code=500, detail="rapport illisible") from exc
+        report_lang = "en" if lang == "en" else "fr"
+        data = build_report_zip(
+            result,
+            render=default_report_renderer().render,
+            title=f"Cinoc — {result.manifest.run_id}",
+            lang=report_lang,
+        )
+        # ``name`` est déjà validé (resolve_report) → sûr en nom de fichier.
+        return Response(
+            content=data,
+            media_type="application/zip",
+            headers={
+                "Content-Disposition": f'attachment; filename="{name}.zip"'
+            },
+        )
+
+    @router.get("/reports/{name}/alto.zip")
+    def get_alto_archive(name: str) -> Response:
+        """Télécharge les **exports ALTO XML** du run (un fichier par document),
+        empaquetés en ZIP — la forme ré-importable dans un outil de relecture
+        (eScriptorium, Transkribus). ``404`` si le run n'a produit aucun ALTO
+        (concurrent sans l'option *Exporter l'ALTO*)."""
+        try:
+            resolve_report(reports_dir, name)
+        except PathSecurityError as exc:
+            raise HTTPException(status_code=404, detail="rapport introuvable") from exc
+        data = alto_store.archive(name) if alto_store is not None else None
+        if data is None:
+            raise HTTPException(
+                status_code=404, detail="aucun export ALTO pour ce run"
+            )
+        # ``name`` est validé (resolve_report) → sûr en nom de fichier.
+        return Response(
+            content=data,
+            media_type="application/zip",
+            headers={
+                "Content-Disposition": f'attachment; filename="{name}-alto.zip"'
+            },
+        )
+
+    return router
+
+
+__all__ = ["build_reports_router"]
diff --git a/cinoc/interfaces/web/routers/runs.py b/cinoc/interfaces/web/routers/runs.py
new file mode 100644
index 0000000000000000000000000000000000000000..a41425e930e1cdb75aff231e7fa40045239938ee
--- /dev/null
+++ b/cinoc/interfaces/web/routers/runs.py
@@ -0,0 +1,256 @@
+"""Routeur du **lanceur** : lancer un run, suivre son état, l'annuler (couche 8).
+
+``POST /api/runs`` choisit des **concurrents** (chacun = un pipeline : OCR seul,
+OCR→LLM texte/image, ou VLM zero-shot) sur un **corpus** (``corpus_id``). N
+concurrents → **un seul run** comparé (cross-engine). Sans concurrent → le run de
+**démonstration** (``precomputed``, local).
+
+Ordre de garde, par moteur référencé (``engine`` + ``llm``) :
+1. moteur inconnu → ``422`` ;
+2. **mode public** : moteur hors du socle gratuit (``PUBLIC_ENGINE_KINDS``) → ``403``
+   (fail-closed) — les moteurs cloud (clé) et tout futur kind y tombent, même si une
+   clé est posée ; seul ``tesseract`` (gratuit, local) reste exécutable publiquement ;
+3. ``corpus_id`` fourni mais introuvable → ``404`` ;
+4. moteur **indisponible** (binaire/SDK/clé absent) → ``409`` — hors mode public, un
+   moteur cloud sans clé y tombe ; avec sa clé il est autorisé (clé posée → marche) ;
+5. concurrent incohérent (mode⇄moteur) → ``422`` (``plan_benchmark_run``).
+
+``GET`` restitue l'état ; ``cancel`` déclenche l'annulation coopérative. Écritures
+protégées **CSRF**. Le ``RunResult`` produit atterrit dans le dossier vitrine.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+import uuid
+from collections.abc import Callable, Iterator
+
+from fastapi import APIRouter, Depends, HTTPException, Request
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel, ConfigDict, Field
+
+from cinoc.adapters.storage import JobStore
+from cinoc.app.corpus_upload import CorpusStore
+from cinoc.app.demo import demo_spec_builder
+from cinoc.app.engines import PUBLIC_ENGINE_KINDS, StatusProvider
+from cinoc.app.jobs import JobRunner
+from cinoc.app.run_planning import Competitor, RunPlanningError, plan_benchmark_run
+from cinoc.domain.corpus import CorpusSpec
+from cinoc.interfaces.web.security.csrf import csrf_protect
+
+
+class LaunchRequest(BaseModel):
+    """Corps (optionnel) : des concurrents + un corpus, ou rien (démonstration)."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    competitors: tuple[Competitor, ...] = ()
+    corpus_id: str | None = None
+    normalization: str | None = None
+    #: Caractères filtrés des deux côtés (GT/hyp) avant le calcul des métriques.
+    char_exclude: str | None = Field(default=None, max_length=512)
+    #: Nom d'un profil de métriques (``standard``/``essentiel``/``philologie``) :
+    #: choisit les colonnes de classement de la vue ``text``. Inconnu → 422 (plan).
+    metric_profile: str | None = Field(default=None, max_length=64)
+
+
+def _referenced_kinds(comp: Competitor) -> tuple[str, ...]:
+    """Kinds qu'un concurrent met en jeu : moteur OCR/VLM + LLM éventuel."""
+    return (comp.engine,) if comp.llm is None else (comp.engine, comp.llm)
+
+
+def _parse_last_event_id(raw: str | None) -> int:
+    """``Last-Event-ID`` (en-tête de reprise SSE) → entier ≥ 0, tolérant."""
+    if raw is None:
+        return 0
+    try:
+        return max(0, int(raw))
+    except ValueError:
+        return 0
+
+
+def _sse_stream(
+    store: JobStore,
+    job_id: str,
+    last_event_id: int,
+    *,
+    poll: float = 0.1,
+    idle_timeout: float = 30.0,
+) -> Iterator[str]:
+    """Diffuse le journal du job en SSE depuis ``last_event_id`` jusqu'au terminal.
+
+    Boucle de *polling* (les transitions sont rares) ; rejoue d'abord les
+    événements manqués (reprise ``Last-Event-ID``), puis suit les nouveaux. Un
+    job déjà terminé renvoie tout l'historique puis ferme. Le ``idle_timeout``
+    borne un job qui ne se terminerait jamais (pas de flux pendu en prod).
+    """
+    sent = last_event_id
+    deadline = time.monotonic() + idle_timeout
+    while True:
+        for event_id, job in store.history_since(job_id, sent):
+            sent = event_id
+            payload = json.dumps(job.model_dump(mode="json"), ensure_ascii=False)
+            yield f"id: {event_id}\nevent: {job.state.value}\ndata: {payload}\n\n"
+            deadline = time.monotonic() + idle_timeout
+        current = store.get(job_id)
+        if current is not None and current.state.is_terminal:
+            if not store.history_since(job_id, sent):
+                return
+        elif time.monotonic() > deadline:
+            return
+        time.sleep(poll)
+
+
+def build_runs_router(
+    runner: JobRunner,
+    corpus_store: CorpusStore,
+    *,
+    statuses: StatusProvider,
+    segmenters: StatusProvider | None = None,
+    ner_available: Callable[[], bool] = lambda: True,
+    public_mode: bool = False,
+) -> APIRouter:
+    """Construit le routeur du lanceur (monté par ``create_app``).
+
+    ``public_mode`` (Space exposé) **verrouille** l'exécution au seul socle
+    first-party gratuit (``PUBLIC_ENGINE_KINDS``) : tout moteur cloud ou autre kind
+    est refusé en ``403`` (fail-closed), sans jamais lancer un appel facturé.
+
+    ``ner_available`` sonde la dispo de l'étape NER (extra ``[ner]``, spaCy) : un
+    concurrent NER demandé sans la lib tombe en ``409`` **avant** le lancement
+    (plutôt qu'un échec d'étape en cours de run). spaCy étant local first-party,
+    la NER reste autorisée en mode public.
+    """
+    router = APIRouter()
+
+    @router.post(
+        "/api/runs", status_code=201, dependencies=[Depends(csrf_protect)]
+    )
+    def launch_run(payload: LaunchRequest | None = None) -> dict[str, str]:
+        req = payload or LaunchRequest()
+        run_id = f"web-{uuid.uuid4().hex[:12]}"
+        # Démonstration : aucun concurrent → precomputed (local, jamais cloud).
+        if not req.competitors:
+            if req.corpus_id is not None:
+                raise HTTPException(
+                    status_code=422,
+                    detail="démonstration : ne s'exécute pas sur un corpus "
+                    "(sélectionne au moins un concurrent).",
+                )
+            return {"job_id": runner.launch(demo_spec_builder(run_id))}
+
+        sts = statuses()
+        known = {s.kind for s in sts}
+        available = {s.kind for s in sts if s.available}
+        # 1 : moteur connu (la disponibilité runtime — binaire/SDK/clé — est
+        # vérifiée à l'étape 4 : un moteur cloud sans clé y tombe en 409).
+        for comp in req.competitors:
+            for kind in _referenced_kinds(comp):
+                if kind not in known:
+                    raise HTTPException(
+                        status_code=422, detail=f"moteur inconnu : {kind!r}"
+                    )
+        # 2 : mode public → fail-closed sur le socle gratuit. Refusé AVANT toute
+        # vérification de clé/dispo : un moteur cloud ne doit pas même être tenté
+        # sur une instance publique (aucun appel facturé), clé présente ou non.
+        if public_mode:
+            for comp in req.competitors:
+                for kind in _referenced_kinds(comp):
+                    if kind not in PUBLIC_ENGINE_KINDS:
+                        raise HTTPException(
+                            status_code=403,
+                            detail=f"moteur indisponible en mode public : {kind!r} "
+                            "(seul le socle gratuit est exécuté).",
+                        )
+        # 3 : corpus.
+        corpus: CorpusSpec | None = None
+        if req.corpus_id is not None:
+            corpus = corpus_store.get(req.corpus_id)
+            if corpus is None:
+                raise HTTPException(status_code=404, detail="corpus introuvable")
+        # 4 : disponibilité runtime (binaire/SDK/clé).
+        for comp in req.competitors:
+            for kind in _referenced_kinds(comp):
+                if kind not in available:
+                    raise HTTPException(
+                        status_code=409, detail=f"moteur indisponible : {kind!r}"
+                    )
+        # 4ter : concurrent hybride → le **segmenteur** doit être disponible (extra
+        # [segment] / endpoint). Catégorie distincte des moteurs OCR (provider
+        # dédié) ; jamais masqué en mode public (local/délégué, pas de clé exposée).
+        seg_available = (
+            {s.kind for s in segmenters() if s.available}
+            if segmenters is not None
+            else set()
+        )
+        for comp in req.competitors:
+            if comp.segmenter and comp.segmenter not in seg_available:
+                raise HTTPException(
+                    status_code=409,
+                    detail=f"segmenteur indisponible : {comp.segmenter!r}",
+                )
+        # 4bis : étape NER demandée → exiger spaCy (extra [ner]) AVANT le lancement.
+        if any(comp.ner for comp in req.competitors) and not ner_available():
+            raise HTTPException(
+                status_code=409,
+                detail="étape NER indisponible : installer 'cinoc[ner]' (spaCy).",
+            )
+        # 5 : cohérence mode⇄moteur (dispatch exhaustif).
+        try:
+            build = plan_benchmark_run(
+                req.competitors,
+                corpus,
+                run_id,
+                normalization=req.normalization,
+                char_exclude=req.char_exclude,
+                metric_profile=req.metric_profile,
+            )
+        except RunPlanningError as exc:
+            raise HTTPException(status_code=422, detail=str(exc)) from exc
+        return {"job_id": runner.launch(build)}
+
+    @router.post(
+        "/api/runs/config", dependencies=[Depends(csrf_protect)]
+    )
+    def validate_config(payload: LaunchRequest) -> dict[str, object]:
+        """Valide une **config de lanceur** (= un ``LaunchRequest``) et la renvoie
+        sous forme **canonique**.
+
+        Stateless : aucune persistance (Cinoc reste déterministe). Consommé par
+        l'**import** côté client, qui valide ici le fichier déposé avant de
+        repeupler le formulaire — un champ inconnu ou une borne dépassée tombe en
+        ``422`` (Pydantic, ``extra="forbid"``), jamais un repeuplement muet.
+        """
+        return {"config": payload.model_dump(mode="json", exclude_none=True)}
+
+    @router.get("/api/runs/{job_id}")
+    def get_run(job_id: str) -> dict[str, object]:
+        job = runner.store.get(job_id)
+        if job is None:
+            raise HTTPException(status_code=404, detail="job introuvable")
+        return job.model_dump(mode="json")
+
+    @router.get("/api/runs/{job_id}/events")
+    def run_events(job_id: str, request: Request) -> StreamingResponse:
+        if runner.store.get(job_id) is None:
+            raise HTTPException(status_code=404, detail="job introuvable")
+        last = _parse_last_event_id(request.headers.get("last-event-id"))
+        return StreamingResponse(
+            _sse_stream(runner.store, job_id, last),
+            media_type="text/event-stream",
+            headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+        )
+
+    @router.post(
+        "/api/runs/{job_id}/cancel", dependencies=[Depends(csrf_protect)]
+    )
+    def cancel_run(job_id: str) -> dict[str, bool]:
+        if runner.store.get(job_id) is None:
+            raise HTTPException(status_code=404, detail="job introuvable")
+        return {"cancelled": runner.cancel(job_id)}
+
+    return router
+
+
+__all__ = ["Competitor", "LaunchRequest", "build_runs_router"]
diff --git a/cinoc/interfaces/web/routers/segmentation.py b/cinoc/interfaces/web/routers/segmentation.py
new file mode 100644
index 0000000000000000000000000000000000000000..19ab441dd7132d26d5bb7481676ceb16089bd14c
--- /dev/null
+++ b/cinoc/interfaces/web/routers/segmentation.py
@@ -0,0 +1,134 @@
+"""Routeur **segmentation** (couche 8) : lancer un run + visualiser un layout.
+
+Sert l'**aperçu de mise en page** du composeur (Banc d'essai) : on lance un run de
+segmentation sur un corpus, puis on affiche les régions détectées. Il n'y a **plus
+de page `/segmentation` dédiée** — la segmentation se compose comme un concurrent
+*hybride* du Banc d'essai (seg → reconnaissance par bloc → texte scoré), et la
+visualisation des régions est un **panneau du lanceur** alimenté par ces endpoints.
+
+- ``POST /api/segmentation/run`` (JSON, **CSRF**) lance un run via le **même**
+  ``JobRunner`` que les runs OCR (le sink persiste le ``CanonicalLayout``) ; renvoie
+  ``{job_id, run_id}``. Gate : segmenteur indisponible → ``409``. **Pas** de masquage
+  mode public (local/délégué, ni clé ni SSRF).
+- ``GET /api/segmentation/{id}/image`` restitue l'image de page persistée.
+- ``GET /api/segmentation/{id}/view`` rend le **SVG des régions** (fragment serveur).
+"""
+
+from __future__ import annotations
+
+import uuid
+from urllib.parse import quote
+
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import FileResponse, HTMLResponse
+from pydantic import BaseModel, ConfigDict, Field
+
+from cinoc.app.corpus_upload import CorpusStore
+from cinoc.app.engines import StatusProvider
+from cinoc.app.jobs import JobRunner
+from cinoc.app.run_planning import RunPlanningError
+from cinoc.app.segmentation import SegmentationStore
+from cinoc.app.structure_planning import (
+    SEGMENTER_KIND,
+    SEGMENTER_KINDS,
+    plan_segmentation_run,
+)
+from cinoc.interfaces.web.security.csrf import csrf_protect
+from cinoc.reports.layout_svg import layout_to_svg
+
+#: Type MIME par extension d'image persistée (défaut binaire opaque).
+_MEDIA_TYPES = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".tif": "image/tiff",
+    ".tiff": "image/tiff",
+}
+
+
+class SegmentationRunRequest(BaseModel):
+    """Corps d'``POST /api/segmentation/run`` : corpus + segmenteur choisi.
+
+    ``segmenter`` sélectionne le module (``pp_doclayout`` local par défaut, ou
+    ``remote_segmenter`` distant). Pour le distant, ``endpoint`` est requis (cible
+    object-detection HF) et ``token`` optionnel (auth) — c'est ce qui rend un
+    segmenteur tiers **sélectionnable avant le run** sans rien réinstaller.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    corpus_id: str = Field(min_length=1, max_length=128)
+    segmenter: str = Field(default=SEGMENTER_KIND, max_length=64)
+    endpoint: str | None = Field(default=None, max_length=2048)
+    token: str | None = Field(default=None, max_length=512)
+
+
+def build_segmentation_router(
+    store: SegmentationStore,
+    *,
+    runner: JobRunner,
+    corpus_store: CorpusStore,
+    segmenters: StatusProvider,
+) -> APIRouter:
+    """Construit le routeur segmentation (monté par ``create_app``)."""
+    router = APIRouter()
+
+    @router.post(
+        "/api/segmentation/run",
+        status_code=201,
+        dependencies=[Depends(csrf_protect)],
+    )
+    def launch_segmentation(req: SegmentationRunRequest) -> dict[str, str]:
+        if req.segmenter not in SEGMENTER_KINDS:
+            raise HTTPException(
+                status_code=422, detail=f"segmenteur inconnu : {req.segmenter}"
+            )
+        status = next(
+            (s for s in segmenters() if s.kind == req.segmenter), None
+        )
+        if status is None or not status.available:
+            detail = status.detail if status else "segmenteur inconnu"
+            raise HTTPException(
+                status_code=409, detail=f"segmenteur indisponible : {detail}"
+            )
+        corpus = corpus_store.get(req.corpus_id)
+        if corpus is None:
+            raise HTTPException(status_code=404, detail="corpus introuvable")
+        run_id = f"seg-{uuid.uuid4().hex[:12]}"
+        try:
+            plan = plan_segmentation_run(
+                corpus,
+                run_id,
+                segmenter=req.segmenter,
+                endpoint=req.endpoint,
+                token=req.token,
+            )
+        except RunPlanningError as exc:
+            raise HTTPException(status_code=422, detail=str(exc)) from exc
+        return {"job_id": runner.launch(plan)}
+
+    @router.get("/api/segmentation/{seg_id}/image")
+    def segmentation_image(seg_id: str) -> FileResponse:
+        path = store.image_path(seg_id)  # id validé en amont → None hors zone
+        if path is None:
+            raise HTTPException(status_code=404, detail="image introuvable")
+        media = _MEDIA_TYPES.get(path.suffix.lower(), "application/octet-stream")
+        return FileResponse(path, media_type=media)
+
+    @router.get("/api/segmentation/preview", response_class=HTMLResponse)
+    def segmentation_preview() -> HTMLResponse:
+        # Fragment SVG des régions du **dernier** layout persisté (rendu serveur,
+        # déterministe) : l'aperçu du lanceur l'injecte une fois le run terminé.
+        # Le sink clé le store par id propre (≠ run_id) → on lit le plus récent,
+        # comme le faisait l'ancienne page /segmentation (mono-opérateur).
+        seg_id = store.latest()
+        layout = store.get_layout(seg_id) if seg_id is not None else None
+        if seg_id is None or layout is None:
+            raise HTTPException(status_code=404, detail="aucune segmentation")
+        image_href = f"/api/segmentation/{quote(seg_id, safe='')}/image"
+        return HTMLResponse(layout_to_svg(layout, image_href=image_href))
+
+    return router
+
+
+__all__ = ["SegmentationRunRequest", "build_segmentation_router"]
diff --git a/cinoc/interfaces/web/security/__init__.py b/cinoc/interfaces/web/security/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3551d576fcc116df183437f6b9ddad0a3863bd2b
--- /dev/null
+++ b/cinoc/interfaces/web/security/__init__.py
@@ -0,0 +1,21 @@
+"""Sécurité HTTP (couche 8) — un seul package (≠ 7 modules épars de la source).
+
+T4c (vitrine en ligne, lecture seule) n'a besoin que de deux protections : des
+**en-têtes de sécurité** (CSP/anti-sniff/anti-cadrage) et un **limiteur de débit**.
+CSRF, quotas d'upload et **mode public** (barrière au code tiers in-process)
+arrivent **avec leur consommateur** — le lanceur BYO-key (T4d) — pas avant.
+"""
+
+from __future__ import annotations
+
+from cinoc.interfaces.web.security.headers import (
+    CONTENT_SECURITY_POLICY,
+    SecurityHeadersMiddleware,
+)
+from cinoc.interfaces.web.security.rate_limit import RateLimitMiddleware
+
+__all__ = [
+    "CONTENT_SECURITY_POLICY",
+    "RateLimitMiddleware",
+    "SecurityHeadersMiddleware",
+]
diff --git a/cinoc/interfaces/web/security/csrf.py b/cinoc/interfaces/web/security/csrf.py
new file mode 100644
index 0000000000000000000000000000000000000000..352c1992743c8d7ca2f33411209a70d2bcde3cf9
--- /dev/null
+++ b/cinoc/interfaces/web/security/csrf.py
@@ -0,0 +1,32 @@
+"""Défense CSRF des routes mutantes (couche 8).
+
+Stratégie **custom-header** : toute requête d'écriture (``POST``) doit porter
+l'en-tête ``X-Cinoc-CSRF: 1``. Un navigateur **ne peut pas** ajouter un en-tête
+personnalisé sur une requête *cross-site* « simple » (formulaire, image…) ; le
+faire exige ``fetch`` + un *preflight* CORS, que la vitrine **n'autorise pas**.
+Donc exiger cet en-tête bloque le forçage cross-site sans cookie ni token de
+session — adapté à une API JSON same-origin (cf. OWASP CSRF, defense « custom
+request header »).
+
+Volontairement minimal (lanceur same-origin). Un token signé par
+session arrivera si/quand des cookies d'auth existent.
+"""
+
+from __future__ import annotations
+
+from fastapi import HTTPException, Request
+
+CSRF_HEADER = "X-Cinoc-CSRF"
+_EXPECTED = "1"
+
+
+def csrf_protect(request: Request) -> None:
+    """Dépendance FastAPI : rejette (403) une écriture sans l'en-tête attendu."""
+    if request.headers.get(CSRF_HEADER) != _EXPECTED:
+        raise HTTPException(
+            status_code=403,
+            detail="en-tête CSRF requis (X-Cinoc-CSRF).",
+        )
+
+
+__all__ = ["CSRF_HEADER", "csrf_protect"]
diff --git a/cinoc/interfaces/web/security/headers.py b/cinoc/interfaces/web/security/headers.py
new file mode 100644
index 0000000000000000000000000000000000000000..cec0058b292cb9d9175828efe60e3a0e21f438d6
--- /dev/null
+++ b/cinoc/interfaces/web/security/headers.py
@@ -0,0 +1,159 @@
+"""En-têtes de sécurité HTTP (couche 8).
+
+CSP **stricte** : on bloque tout par défaut (``default-src 'none'``) et on
+n'ouvre que le strict nécessaire, **toujours en `self`** (aucun CDN). Le
+**rapport** reste autonome (``<style>`` inline + images self/data — cf.
+``reports/html.py``). La **coquille** sert sa feuille de style et ses polices
+auto-hébergées (``style-src``/``font-src 'self'``) ; depuis le lanceur
+interactif, elle sert aussi un **JS auto-hébergé** (``script-src
+'self'`` — jamais ``'unsafe-inline'``, jamais d'externe) qui parle aux API et
+s'abonne au SSE (``connect-src 'self'``). ``form-action 'none'`` (on pilote en
+``fetch``, pas en soumission de formulaire). Tout le reste tombe sur
+``default-src 'none'`` — un script inline ou une origine tierce serait bloqué,
+c'est volontaire : la CSP est un contrat.
+
+**Adaptation HuggingFace Space.** Un Space est servi dans une ``<iframe>`` côté
+``huggingface.co`` / ``*.hf.space``. Or ``frame-ancestors 'none'`` +
+``X-Frame-Options: DENY`` y rendent la vitrine **invisible** (page blanche bien
+que le serveur réponde ``200`` — c'est exactement le « ne peut pas afficher la
+page dans un cadre » des navigateurs). On détecte le Space via ``SPACE_ID``
+(injecté par HF) et on bascule ``frame-ancestors`` sur les origines du Hub, en
+**omettant** ``X-Frame-Options`` (qui a priorité absolue sur ``frame-ancestors``
+dans les vieux navigateurs → annulerait la permission d'embed). Hors Space
+(local / institutionnel), on garde le **verrou total** : ``'none'`` + ``DENY``.
+"""
+
+from __future__ import annotations
+
+import os
+
+from starlette.responses import Response
+from starlette.types import ASGIApp, Message, Receive, Scope, Send
+
+#: CSP de base — tout sauf ``frame-ancestors`` (composée dynamiquement selon le
+#: déploiement par :func:`get_csp_policy`). ``style-src 'unsafe-inline'`` est
+#: requis par le CSS inline du rapport (le seul inline toléré) ; tout le reste
+#: (``script``/``object``/``base``) tombe sur ``default-src 'none'``, verrouillé.
+_CSP_BASE = (
+    "default-src 'none'; "
+    "script-src 'self'; "
+    "style-src 'self' 'unsafe-inline'; "
+    "font-src 'self'; "
+    "img-src 'self' data:; "
+    "connect-src 'self'; "
+    "base-uri 'none'; "
+    "form-action 'none'"
+)
+
+#: Origines autorisées à embarquer la vitrine quand on tourne dans un HF Space.
+#: ``huggingface.co`` rend la page parente ; ``*.hf.space`` expose le conteneur
+#: (rendus directs / liens partageables).
+_HF_FRAME_ANCESTORS = "'self' https://huggingface.co https://*.hf.space"
+
+
+def is_huggingface_space() -> bool:
+    """Vrai si l'instance tourne dans un HuggingFace Space.
+
+    HF injecte ``SPACE_ID`` (au format ``user/space``) dans l'environnement du
+    conteneur — marqueur canonique documenté, présent quel que soit le SDK
+    (Docker ici). On l'utilise pour adapter ``frame-ancestors`` : sans ça, la
+    vitrine est invisible dans l'iframe du Hub.
+    """
+    return bool(os.environ.get("SPACE_ID", "").strip())
+
+
+def _frame_ancestors_directive() -> str:
+    """Directive ``frame-ancestors`` adaptée au déploiement détecté.
+
+    - Local / institutionnel : ``'none'`` (aucun embed possible).
+    - HuggingFace Space : autorise ``huggingface.co`` et ``*.hf.space`` pour que
+      la vitrine s'affiche dans l'iframe du Space sans tomber en page blanche.
+    """
+    if is_huggingface_space():
+        return f"frame-ancestors {_HF_FRAME_ANCESTORS}"
+    return "frame-ancestors 'none'"
+
+
+#: CSP locale/institutionnelle (verrou total anti-cadrage). Exposée comme valeur
+#: par défaut et attendue **hors** Space ; en Space, :func:`get_csp_policy` la
+#: recompose avec un ``frame-ancestors`` permissif.
+CONTENT_SECURITY_POLICY = f"{_CSP_BASE}; frame-ancestors 'none'"
+
+
+def get_csp_policy(path: str | None = None) -> str:
+    """CSP à appliquer : base + ``frame-ancestors`` selon l'environnement.
+
+    Pour les réponses **``/reports/``** seulement, ``script-src`` autorise en plus
+    les **empreintes sha256** des scripts statiques inlinés du rapport autonome
+    (comparaison, navigation clavier, palette) — l'``'unsafe-inline'`` reste
+    **exclu** partout (la CSP reste un contrat ; seuls ces scripts connus, épinglés
+    par hash, peuvent s'exécuter)."""
+    base = _CSP_BASE
+    if path is not None and path.startswith("/reports/"):
+        from cinoc.reports.embedded import script_csp_hashes
+
+        base = base.replace(
+            "script-src 'self'", f"script-src 'self' {script_csp_hashes()}"
+        )
+    return f"{base}; {_frame_ancestors_directive()}"
+
+
+def security_headers(path: str | None = None) -> dict[str, str]:
+    """En-têtes de sécurité de la réponse, **calculés selon le déploiement**.
+
+    ``X-Frame-Options: DENY`` est sciemment **omis sur HF Space** : ce header a
+    priorité absolue sur ``frame-ancestors`` (et sert de fallback quand le
+    navigateur ignore la CSP), donc un ``DENY`` annulerait la permission d'embed
+    du Hub. Le contrôle d'embed est alors entièrement délégué à
+    ``frame-ancestors``.
+    """
+    headers = {
+        "Content-Security-Policy": get_csp_policy(path),
+        "X-Content-Type-Options": "nosniff",
+        "Referrer-Policy": "no-referrer",
+        "Cross-Origin-Opener-Policy": "same-origin",
+    }
+    if not is_huggingface_space():
+        headers["X-Frame-Options"] = "DENY"
+    return headers
+
+
+class SecurityHeadersMiddleware:
+    """Ajoute les en-têtes de sécurité à chaque réponse (ASGI pur, sans état)."""
+
+    def __init__(self, app: ASGIApp) -> None:
+        self._app = app
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            await self._app(scope, receive, send)
+            return
+
+        path = scope.get("path", "")
+
+        async def send_with_headers(message: Message) -> None:
+            if message["type"] == "http.response.start":
+                raw = list(message.get("headers", []))
+                for key, value in security_headers(path).items():
+                    raw.append((key.encode("latin-1"), value.encode("latin-1")))
+                message = {**message, "headers": raw}
+            await send(message)
+
+        await self._app(scope, receive, send_with_headers)
+
+
+def apply_security_headers(response: Response, path: str | None = None) -> Response:
+    """Variante utilitaire (tests / réponses construites à la main)."""
+    for key, value in security_headers(path).items():
+        response.headers[key] = value
+    return response
+
+
+__all__ = [
+    "CONTENT_SECURITY_POLICY",
+    "SecurityHeadersMiddleware",
+    "apply_security_headers",
+    "get_csp_policy",
+    "is_huggingface_space",
+    "security_headers",
+]
diff --git a/cinoc/interfaces/web/security/rate_limit.py b/cinoc/interfaces/web/security/rate_limit.py
new file mode 100644
index 0000000000000000000000000000000000000000..bcaed19338877455cf5595f63f44b67a942f9322
--- /dev/null
+++ b/cinoc/interfaces/web/security/rate_limit.py
@@ -0,0 +1,88 @@
+"""Limiteur de débit HTTP **en mémoire** (couche 8).
+
+Fenêtre fixe par IP cliente : au-delà de ``max_requests`` requêtes sur
+``window_seconds``, renvoie ``429``. Suffisant pour borner une vitrine mono-worker
+(le Space). **Limites assumées** (documentées, pas masquées) : non distribué
+(état par process) → en multi-worker chaque worker compte séparément ; pour un
+vrai cluster il faudrait un store partagé.
+
+Dette corrigée au portage (cf. analyse couche 8, constat H) : les compteurs
+d'IP inactives sont **purgés** (fenêtre expirée) → pas de fuite mémoire lente.
+Thread-safe (``Lock``) car uvicorn peut servir plusieurs requêtes en parallèle.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+#: Réponse 429 minimale (ASGI brut), sans corps sensible.
+_TOO_MANY = {
+    "type": "http.response.start",
+    "status": 429,
+    "headers": [(b"content-type", b"text/plain; charset=utf-8")],
+}
+
+
+class RateLimitMiddleware:
+    """Fenêtre fixe par IP ; ``429`` au dépassement. Purge les IP expirées."""
+
+    def __init__(
+        self,
+        app: ASGIApp,
+        *,
+        max_requests: int = 60,
+        window_seconds: float = 60.0,
+    ) -> None:
+        if max_requests < 1 or window_seconds <= 0:
+            raise ValueError("rate limit : max_requests>=1 et window_seconds>0.")
+        self._app = app
+        self._max = max_requests
+        self._window = window_seconds
+        self._lock = threading.Lock()
+        #: ip -> (début de fenêtre, compteur).
+        self._hits: dict[str, tuple[float, int]] = {}
+
+    def _client_ip(self, scope: Scope) -> str:
+        client = scope.get("client")
+        if isinstance(client, (tuple, list)) and client:
+            return str(client[0])
+        return "unknown"
+
+    def _allow(self, ip: str, now: float) -> bool:
+        with self._lock:
+            self._prune(now)
+            start, count = self._hits.get(ip, (now, 0))
+            if now - start >= self._window:
+                start, count = now, 0  # fenêtre expirée → réinitialisation
+            if count >= self._max:
+                return False
+            self._hits[ip] = (start, count + 1)
+            return True
+
+    def _prune(self, now: float) -> None:
+        """Retire les IP dont la fenêtre est expirée (anti-fuite mémoire)."""
+        expired = [
+            ip
+            for ip, (start, _) in self._hits.items()
+            if now - start >= self._window
+        ]
+        for ip in expired:
+            del self._hits[ip]
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            await self._app(scope, receive, send)
+            return
+        if self._allow(self._client_ip(scope), time.monotonic()):
+            await self._app(scope, receive, send)
+            return
+        await send(_TOO_MANY)
+        await send(
+            {"type": "http.response.body", "body": b"rate limit exceeded"}
+        )
+
+
+__all__ = ["RateLimitMiddleware"]
diff --git a/cinoc/interfaces/web/sparkline.py b/cinoc/interfaces/web/sparkline.py
new file mode 100644
index 0000000000000000000000000000000000000000..027c8070ddd9b37bf656eff50a7c7357a6ecc231
--- /dev/null
+++ b/cinoc/interfaces/web/sparkline.py
@@ -0,0 +1,52 @@
+"""Sparkline SVG inline (couche 8) — déterministe, sans JS ni dépendance.
+
+Trace une mini-courbe d'évolution d'une métrique au fil des runs. Rendu
+**serveur** (chaîne SVG), donc testable et conforme à l'invariant
+anti-hallucination : les points sont une **fonction directe** des valeurs
+d'entrée (aucune donnée fabriquée).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+
+def sparkline_svg(
+    values: Sequence[float], *, width: int = 132, height: int = 30
+) -> str:
+    """Mini-courbe des ``values`` → ``<svg>`` inline. ``""`` si aucune valeur.
+
+    Échelle locale (min..max des valeurs) : on lit la **tendance**, pas la valeur
+    absolue (affichée à part). Le dernier point est marqué d'un disque.
+    """
+    points = [float(v) for v in values if v is not None]
+    if not points:
+        return ""
+    pad = 3.0
+    low, high = min(points), max(points)
+    span = (high - low) or 1.0
+    count = len(points)
+
+    def px(index: int) -> float:
+        if count == 1:
+            return width / 2
+        return pad + (width - 2 * pad) * (index / (count - 1))
+
+    def py(value: float) -> float:
+        return pad + (height - 2 * pad) * (1 - (value - low) / span)
+
+    coords = " ".join(f"{px(i):.1f},{py(v):.1f}" for i, v in enumerate(points))
+    last_x, last_y = px(count - 1), py(points[-1])
+    body = (
+        f'<polyline points="{coords}" fill="none" stroke="currentColor" '
+        'stroke-width="1.5" stroke-linejoin="round" stroke-linecap="round"/>'
+        f'<circle cx="{last_x:.1f}" cy="{last_y:.1f}" r="2.2" fill="currentColor"/>'
+    )
+    return (
+        f'<svg class="spark" viewBox="0 0 {width} {height}" width="{width}" '
+        f'height="{height}" preserveAspectRatio="none" aria-hidden="true">'
+        f"{body}</svg>"
+    )
+
+
+__all__ = ["sparkline_svg"]
diff --git a/cinoc/interfaces/web/static/css/shell.css b/cinoc/interfaces/web/static/css/shell.css
new file mode 100644
index 0000000000000000000000000000000000000000..1bfd2c2a921000269c4dfa5fb8803803e917daf8
--- /dev/null
+++ b/cinoc/interfaces/web/static/css/shell.css
@@ -0,0 +1,1284 @@
+/* =====================================================================
+   Cinoc — coquille. Tokens + chrome de l'app, rendu serveur.
+   Polices AUTO-HÉBERGÉES (aucun CDN, CSP font-src 'self') — rôles :
+     titres   = Mona Sans (OFL)
+     corps/UI = IBM Plex Sans (OFL)
+     données  = IBM Plex Mono (OFL)
+     accents  = Fluxisch Else (OFL)
+     logo     = OCR-A (domaine public)
+   Réf. visuelle : design/.
+   ===================================================================== */
+
+/* ---- Polices auto-hébergées (servies sous /static/fonts) ---- */
+@font-face {
+  font-family: 'Mona Sans VF';
+  src: url('/static/fonts/MonaSansVF-opsz-wght.woff2') format('woff2');
+  font-weight: 200 900;
+  font-display: swap;
+}
+@font-face {
+  font-family: 'Fluxisch Else';
+  src: url('/static/fonts/FluxischElse-Light.woff2') format('woff2');
+  font-weight: 300;
+  font-display: swap;
+}
+@font-face {
+  font-family: 'Fluxisch Else';
+  src: url('/static/fonts/FluxischElse-Regular.woff2') format('woff2');
+  font-weight: 400;
+  font-display: swap;
+}
+@font-face {
+  font-family: 'Fluxisch Else';
+  src: url('/static/fonts/FluxischElse-Bold.woff2') format('woff2');
+  font-weight: 700;
+  font-display: swap;
+}
+@font-face {
+  font-family: 'OCRA';
+  src: url('/static/fonts/OCRA.woff2') format('woff2');
+  font-weight: 400;
+  font-display: swap;
+}
+@font-face {
+  font-family: 'IBM Plex Sans';
+  src: url('/static/fonts/IBMPlexSans-Regular.woff2') format('woff2');
+  font-weight: 400;
+  font-display: swap;
+}
+@font-face {
+  font-family: 'IBM Plex Sans';
+  src: url('/static/fonts/IBMPlexSans-Medium.woff2') format('woff2');
+  font-weight: 500;
+  font-display: swap;
+}
+@font-face {
+  font-family: 'IBM Plex Sans';
+  src: url('/static/fonts/IBMPlexSans-SemiBold.woff2') format('woff2');
+  font-weight: 600;
+  font-display: swap;
+}
+@font-face {
+  font-family: 'IBM Plex Mono';
+  src: url('/static/fonts/IBMPlexMono-Regular.woff2') format('woff2');
+  font-weight: 400;
+  font-display: swap;
+}
+@font-face {
+  font-family: 'IBM Plex Mono';
+  src: url('/static/fonts/IBMPlexMono-Medium.woff2') format('woff2');
+  font-weight: 500;
+  font-display: swap;
+}
+
+:root {
+  /* Greyscale (warm) */
+  --paper:    #EBE8E0;
+  --surface:  #F4F1EA;
+  --raised:   #FBFAF6;
+  --raised-2: #FFFFFF;
+  --g-50:  #E4E0D7;
+  --g-100: #D6D2C8;
+  --g-150: #C2BEB3;
+  --g-200: #ADA89C;
+  --g-300: #8D8879;
+  --g-400: #6F6B60;
+  --g-500: #54514A;
+  --g-600: #3A3833;
+  --g-700: #26241F;
+  --g-800: #181714;
+  --ink:   #1A1917;
+
+  /* Accents */
+  --fern:      oklch(0.50 0.07 145);
+  --fern-soft: oklch(0.92 0.03 145);
+  --fern-deep: oklch(0.36 0.07 145);
+
+  --slate:      oklch(0.50 0.05 240);
+  --slate-soft: oklch(0.92 0.02 240);
+  --slate-deep: oklch(0.36 0.05 240);
+
+  --clay:      oklch(0.58 0.10 45);
+  --clay-soft: oklch(0.92 0.035 45);
+  --clay-deep: oklch(0.42 0.10 45);
+
+  --butter:      oklch(0.78 0.09 90);
+  --butter-soft: oklch(0.94 0.04 90);
+  --butter-deep: oklch(0.52 0.09 90);
+
+  /* Extension à 10 couleurs (classement des moteurs par rang CER, comme le
+     Picarones live) — rangs 5-9, daltonien-safe provisoire. */
+  --amethyst:      oklch(0.55 0.10 300);
+  --amethyst-soft: oklch(0.92 0.03 300);
+  --amethyst-deep: oklch(0.40 0.10 300);
+  --teal:          oklch(0.55 0.08 195);
+  --teal-soft:     oklch(0.92 0.02 195);
+  --teal-deep:     oklch(0.40 0.08 195);
+  --vermillion:      oklch(0.55 0.12 25);
+  --vermillion-soft: oklch(0.92 0.04 25);
+  --vermillion-deep: oklch(0.40 0.12 25);
+  --olive:      oklch(0.55 0.07 115);
+  --olive-soft: oklch(0.92 0.03 115);
+  --olive-deep: oklch(0.40 0.07 115);
+  --rose:      oklch(0.62 0.08 350);
+  --rose-soft: oklch(0.92 0.03 350);
+  --rose-deep: oklch(0.45 0.08 350);
+
+  --warn: var(--butter-deep);
+  --err:  oklch(0.55 0.14 28);
+
+  /* Familles — rôles : titres Mona Sans, corps IBM Plex Sans,
+     données IBM Plex Mono, accents Fluxisch Else, logo OCR-A. */
+  --display: 'Mona Sans VF', 'IBM Plex Sans', system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif;
+  --accent:  'Fluxisch Else', Georgia, serif;
+  --ocr:     'OCRA', 'IBM Plex Mono', ui-monospace, monospace;
+  --sans:    'IBM Plex Sans', system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif;
+  --mono:    'IBM Plex Mono', ui-monospace, 'SF Mono', Menlo, monospace;
+
+  --r-sm: 8px;
+  --r-md: 14px;
+  --r-lg: 20px;
+  --r-xl: 28px;
+  --r-pill: 999px;
+
+  /* Ombres légères et feuilletées — valeurs exactes de picarones.css live. */
+  --shadow-sm: 0 1px 2px rgba(26, 25, 23, 0.04);
+  --shadow:    0 1px 3px rgba(26, 25, 23, 0.05), 0 4px 14px rgba(26, 25, 23, 0.04);
+  --ring: 0 0 0 3px rgba(58, 90, 64, 0.18);
+}
+
+* { box-sizing: border-box; margin: 0; padding: 0; }
+[hidden] { display: none !important; }
+
+html, body {
+  background-color: var(--paper);
+  background-image:
+    url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='3' height='3' viewBox='0 0 3 3'><circle cx='0.75' cy='0.75' r='0.6' fill='%231a1917' fill-opacity='0.28'/></svg>");
+  background-attachment: fixed;
+  color: var(--ink);
+  font-family: var(--sans);
+  font-size: 14px;
+  line-height: 1.5;
+  -webkit-font-smoothing: antialiased;
+  text-rendering: optimizeLegibility;
+}
+
+::selection { background: var(--ink); color: var(--paper); }
+a { color: inherit; text-decoration: none; }
+
+/* Accessibilité : anneau de focus net et visible au clavier. */
+a:focus-visible,
+button:focus-visible,
+input:focus-visible,
+select:focus-visible {
+  outline: 2px solid var(--fern-deep);
+  outline-offset: 2px;
+  box-shadow: var(--ring);
+}
+
+/* === App shell === */
+.app {
+  min-height: 100vh;
+  display: grid;
+  grid-template-columns: 240px 1fr;
+}
+
+/* === Left rail === */
+.rail {
+  padding: 22px 18px 18px;
+  position: sticky;
+  top: 0;
+  height: 100vh;
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+  overflow: hidden;
+}
+.wordmark-card {
+  background: var(--ink);
+  color: var(--paper);
+  border-radius: var(--r-lg);
+  padding: 16px 18px 14px;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+.wordmark {
+  font-family: var(--ocr);
+  font-size: 21px;
+  line-height: 1;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  letter-spacing: 0.01em;
+}
+.wordmark .wm-o {
+  /* « o » rendu en capitale OCR-A (glyphe iconique, comme l'ancien « O ») */
+  text-transform: uppercase;
+}
+.wordmark .mark {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 22px; height: 22px;
+  border-radius: var(--r-pill);
+  background: var(--paper);
+  color: var(--ink);
+  font-family: var(--sans);
+  font-weight: 700;
+  font-size: 12px;
+}
+.wordmark-sub {
+  font-family: var(--mono);
+  font-size: 10px;
+  letter-spacing: 0.04em;
+  color: rgba(239, 237, 232, 0.55);
+}
+
+/* === Nav (pill items) — tous les emplacements réservés === */
+.rail-nav-window {
+  background: var(--raised);
+  border-radius: var(--r-lg);
+  padding: 10px 8px;
+  box-shadow: var(--shadow-sm);
+}
+.rail-nav {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+.nav-item {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 10px 14px;
+  border-radius: var(--r-pill);
+  color: var(--g-500);
+  transition: background 0.15s, color 0.15s;
+  min-width: 0;
+}
+.nav-item:hover {
+  background: var(--g-50);
+  color: var(--ink);
+}
+.nav-item.active { background: var(--ink); color: var(--paper); }
+.nav-glyph {
+  width: 22px; height: 22px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  flex-shrink: 0;
+}
+.nav-glyph svg { width: 16px; height: 16px; }
+.nav-label { font-size: 14px; font-weight: 500; letter-spacing: 0; flex: 1; min-width: 0; }
+.nav-meta {
+  font-family: var(--mono);
+  font-size: 9.5px;
+  letter-spacing: 0.04em;
+  color: var(--g-400);
+  text-transform: uppercase;
+}
+.nav-item.active .nav-meta { color: rgba(239, 237, 232, 0.55); }
+
+/* === System block === */
+.rail-system {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  overflow-y: auto;
+  padding: 4px 4px 0;
+}
+.sys-card {
+  background: var(--raised);
+  border-radius: var(--r-lg);
+  padding: 14px 15px;
+  box-shadow: var(--shadow-sm);
+}
+.pipeline-tags {
+  display: flex;
+  gap: 8px;
+  flex-wrap: wrap;
+  margin-top: 10px;
+}
+/* Bouton « Système · détails → » (pilule discrète, vers /engines) — Picarones. */
+.system-trigger {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  background: var(--surface);
+  color: var(--g-500);
+  border-radius: var(--r-pill);
+  padding: 10px 14px;
+  font-size: 12px;
+  font-weight: 500;
+  transition: background 0.12s, color 0.12s;
+}
+.system-trigger:hover { background: var(--g-50); color: var(--ink); }
+.system-trigger-arrow { font-family: var(--mono); }
+.sys-card-title {
+  font-size: 10.5px;
+  font-weight: 500;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--g-400);
+  margin-bottom: 10px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  border-bottom: 1px dotted var(--g-100);
+  padding-bottom: 8px;
+}
+.sys-row { display: flex; justify-content: space-between; gap: 8px; padding: 5px 0; font-size: 11.5px; min-width: 0; }
+.sys-row .k { color: var(--g-400); }
+.sys-row .v { color: var(--ink); font-weight: 500; font-family: var(--mono); overflow-wrap: anywhere; text-align: right; }
+.dot { display: inline-block; width: 8px; height: 8px; border-radius: 50%; background: var(--g-150); }
+.dot.on { background: var(--fern); }
+
+/* === Lang toggle (pill) === */
+.rail-foot { padding: 8px 4px 0; display: flex; justify-content: space-between; align-items: center; }
+.foot-meta { font-family: var(--mono); font-size: 10px; color: var(--g-300); }
+.lang-toggle { display: inline-flex; background: var(--raised); border-radius: var(--r-pill); padding: 3px; }
+.lang-toggle a {
+  padding: 5px 12px;
+  font-family: var(--sans);
+  font-weight: 500;
+  font-size: 11px;
+  letter-spacing: 0.04em;
+  color: var(--g-400);
+  border-radius: var(--r-pill);
+}
+.lang-toggle a.on { background: var(--ink); color: var(--paper); }
+
+/* === Main column === */
+.main {
+  min-width: 0;
+  padding: 22px 28px 64px 8px;
+  display: flex;
+  flex-direction: column;
+  gap: 18px;
+}
+
+/* === View hero === */
+.view-hero {
+  background: var(--raised);
+  border-radius: var(--r-lg);
+  padding: 24px 28px 22px;
+  display: flex;
+  align-items: flex-end;
+  justify-content: space-between;
+  gap: 24px;
+  flex-wrap: wrap;
+}
+.view-hero-title {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  min-width: min(520px, 100%);
+}
+.view-hero-eyebrow {
+  font-family: var(--mono);
+  font-size: 10.5px;
+  color: var(--g-400);
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+}
+.view-hero-name {
+  font-family: var(--display);
+  font-size: 36px;
+  font-weight: 700;
+  font-optical-sizing: auto;
+  letter-spacing: -0.03em;
+  line-height: 1.02;
+  margin-top: 4px;
+  overflow-wrap: anywhere;
+}
+.view-hero-desc { font-family: var(--accent); font-style: italic; font-size: 15px; color: var(--g-500); max-width: 60ch; margin-top: 8px; overflow-wrap: anywhere; }
+.hero-stat { text-align: right; }
+.view-hero-stats {
+  display: flex;
+  gap: 22px;
+  align-items: center;
+  justify-content: flex-end;
+  flex-wrap: wrap;
+}
+.hero-stat .v {
+  font-family: var(--display);
+  font-size: 28px;
+  font-weight: 700;
+  font-optical-sizing: auto;
+  letter-spacing: -0.02em;
+  font-variant-numeric: tabular-nums;
+}
+.stat-muted { color: var(--g-300); }
+.hero-stat .k {
+  font-family: var(--mono);
+  font-size: 10.5px;
+  color: var(--g-400);
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+}
+
+/* === Sections et primitives communes === */
+.sec {
+  background: var(--raised);
+  border-radius: var(--r-lg);
+  padding: 22px 26px 24px;
+  position: relative;
+}
+.sec-head {
+  display: flex;
+  align-items: flex-end;
+  justify-content: space-between;
+  gap: 18px;
+  margin-bottom: 18px;
+  flex-wrap: wrap;
+}
+.sec-copy {
+  flex: 1;
+  min-width: 0;
+}
+.sec-title {
+  font-family: var(--display);
+  font-size: 22px;
+  font-weight: 700;
+  font-optical-sizing: auto;
+  letter-spacing: -0.02em;
+  line-height: 1.1;
+}
+.sec-sub {
+  font-family: var(--accent);
+  font-style: italic;
+  font-size: 13px;
+  color: var(--g-400);
+  margin-top: 2px;
+  overflow-wrap: anywhere;
+}
+.sec-aside {
+  font-family: var(--mono);
+  font-size: 10.5px;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--g-400);
+  padding-top: 4px;
+  white-space: nowrap;
+}
+.sec-body { min-width: 0; }
+.panel {
+  background: var(--raised-2);
+  border-radius: var(--r-md);
+  padding: 16px 18px;
+  min-width: 0;
+  box-shadow: inset 0 0 0 1px rgba(26, 25, 23, 0.03);
+}
+.label {
+  font-family: var(--sans);
+  font-size: 11px;
+  font-weight: 500;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  color: var(--g-400);
+}
+.mono { font-family: var(--mono); }
+.empty {
+  padding: 30px 16px;
+  text-align: center;
+  font-family: var(--accent);
+  font-style: italic;
+  font-size: 13.5px;
+  color: var(--g-400);
+}
+
+/* === Reports section === */
+.report-list { display: flex; flex-direction: column; gap: 8px; }
+.report-row {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 14px;
+  transition: box-shadow 0.15s, transform 0.05s;
+}
+.report-row:hover { box-shadow: var(--shadow); }
+.report-row:active { transform: translateY(1px); }
+.report-row .r-name {
+  font-family: var(--mono);
+  font-size: 13px;
+  color: var(--ink);
+  overflow-wrap: anywhere;
+}
+.report-row .r-open {
+  font-family: var(--sans);
+  font-size: 11.5px;
+  font-weight: 500;
+  color: var(--g-500);
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+}
+.report-row .r-main {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 14px;
+  flex: 1;
+  min-width: 0;
+}
+.report-row .r-zip {
+  font-family: var(--sans);
+  font-size: 11.5px;
+  font-weight: 500;
+  color: var(--g-500);
+  white-space: nowrap;
+  flex: none;
+}
+.report-row .r-zip:hover { color: var(--ink); }
+
+/* === Actions et formulaires === */
+.btn {
+  font-family: var(--sans);
+  font-size: 12.5px;
+  font-weight: 500;
+  padding: 9px 18px;
+  border: none;
+  background: var(--g-50);
+  color: var(--ink);
+  cursor: pointer;
+  border-radius: var(--r-pill);
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  line-height: 1.2;
+  text-decoration: none;
+  min-height: 34px;
+  justify-content: center;
+  text-align: center;
+  overflow-wrap: anywhere;
+}
+.btn:hover { background: var(--g-100); }
+.btn:disabled { opacity: 0.5; cursor: default; }
+.btn-primary { background: var(--ink); color: var(--paper); }
+.btn-primary:hover { background: var(--g-700); }
+.btn-sm { padding: 6px 12px; font-size: 11.5px; }
+.row { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; }
+
+/* === Launcher (Banc d'essai) === */
+.corpus-select-card {
+  min-height: 150px;
+  justify-content: space-between;
+}
+.corpus-select-row {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  gap: 10px;
+  align-items: center;
+}
+.run-panel {
+  display: flex;
+  flex-direction: column;
+  gap: 14px;
+}
+.stack-panel {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+.select,
+.input {
+  font-family: var(--sans);
+  font-size: 13px;
+  padding: 9px 14px;
+  border: none;
+  border-radius: var(--r-pill);
+  background: var(--surface);
+  color: var(--ink);
+  width: 100%;
+  max-width: 100%;
+}
+.select {
+  appearance: none;
+  background-image:
+    linear-gradient(45deg, transparent 50%, var(--g-400) 50%),
+    linear-gradient(135deg, var(--g-400) 50%, transparent 50%);
+  background-position:
+    calc(100% - 18px) calc(50% - 2px),
+    calc(100% - 13px) calc(50% - 2px);
+  background-size: 5px 5px, 5px 5px;
+  background-repeat: no-repeat;
+  padding-right: 34px;
+}
+.input { min-width: 220px; }
+.import-fields { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; }
+.check { display: inline-flex; align-items: center; gap: 6px; font-size: 12.5px; }
+.run-line { display: flex; align-items: center; gap: 12px; flex-wrap: wrap; }
+.run-status {
+  font-family: var(--mono);
+  font-size: 12.5px;
+  color: var(--ink);
+  background: var(--surface);
+  padding: 4px 12px;
+  border-radius: var(--r-pill);
+}
+.run-status:empty { display: none; }
+.run-result { min-height: 1px; }
+.run-result:empty { display: none; }
+
+/* Barre de progression (document × concurrent) — pilotée par le flux SSE. */
+.run-progress { display: flex; align-items: center; gap: 12px; margin-top: 4px; }
+.run-progress .progress { flex: 1; }
+.progress {
+  background: var(--g-50);
+  height: 8px;
+  border-radius: var(--r-pill);
+  overflow: hidden;
+}
+.progress-bar {
+  width: 0;
+  height: 100%;
+  background: var(--fern);
+  border-radius: var(--r-pill);
+  transition: width 0.3s ease;
+}
+.run-progress-text {
+  font-size: 11.5px;
+  color: var(--g-500);
+  white-space: nowrap;
+}
+.run-log {
+  font-family: var(--mono);
+  font-size: 11.5px;
+  color: var(--g-600);
+  background: var(--surface);
+  border-radius: var(--r-md);
+  padding: 12px 14px;
+  max-height: 220px;
+  overflow-y: auto;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+  margin: 0;
+}
+.run-log:empty::before { content: "—"; color: var(--g-300); }
+.run-log-shell {
+  border-top: 1px solid var(--g-100);
+  padding-top: 12px;
+}
+.run-log-shell summary {
+  cursor: pointer;
+  font-family: var(--mono);
+  font-size: 10.5px;
+  color: var(--g-400);
+  letter-spacing: 0.05em;
+  text-transform: uppercase;
+}
+
+/* === Segmentation (canevas SVG des régions) === */
+.seg-canvas {
+  display: flex;
+  justify-content: center;
+  background: var(--surface);
+  border: 1px solid var(--g-100);
+  border-radius: var(--r-md);
+  padding: 16px;
+}
+.seg-canvas .seg-svg {
+  max-width: 100%;
+  height: auto;
+  border-radius: var(--r-sm);
+}
+
+/* === Moteurs (table d'état) === */
+table.engines { width: 100%; min-width: 560px; border-collapse: collapse; font-size: 13px; }
+table.engines th {
+  text-align: left;
+  font-family: var(--sans);
+  font-size: 10.5px;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--g-400);
+  font-weight: 500;
+  padding: 8px 12px;
+  border-bottom: 1px solid var(--g-100);
+}
+table.engines td { padding: 11px 12px; border-bottom: 1px solid var(--g-50); }
+table.engines tr:last-child td { border-bottom: none; }
+table.engines .eng-name { font-weight: 500; color: var(--ink); }
+table.engines .eng-kind {
+  font-family: var(--mono);
+  font-size: 10.5px;
+  color: var(--g-300);
+  margin-left: 6px;
+}
+table.engines .eng-detail { font-size: 12px; color: var(--g-500); }
+.dot.off { background: var(--g-150); }
+
+/* === Tables de données (corpus, catalogues, historique) === */
+table.data { width: 100%; min-width: 520px; border-collapse: collapse; font-size: 13px; }
+table.data th {
+  text-align: left;
+  font-family: var(--mono);
+  font-size: 10px;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--g-400);
+  font-weight: 500;
+  padding: 8px 12px;
+  border-bottom: 1px solid var(--g-100);
+}
+table.data td { padding: 10px 12px; border-bottom: 1px solid var(--g-50); }
+table.data tr:last-child td { border-bottom: none; }
+table.data a { color: var(--fern-deep); font-weight: 500; }
+.table-wrap {
+  width: 100%;
+  overflow-x: auto;
+  -webkit-overflow-scrolling: touch;
+}
+
+/* === Badge === */
+.badge {
+  font-family: var(--mono);
+  font-size: 9.5px;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  color: var(--g-500);
+  background: var(--g-50);
+  padding: 3px 8px;
+  border-radius: var(--r-pill);
+  margin-left: 8px;
+  vertical-align: middle;
+  white-space: nowrap;
+}
+
+/* === Cartes corpus (« Mes corpus ») === */
+.corpus-card {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+.corpus-card .c-name {
+  font-weight: 600;
+  font-size: 14px;
+  color: var(--ink);
+  word-break: break-word;
+  overflow-wrap: anywhere;
+}
+.corpus-card .c-meta {
+  font-family: var(--mono);
+  font-size: 10.5px;
+  color: var(--g-400);
+  display: flex;
+  gap: 12px;
+  flex-wrap: wrap;
+}
+.corpus-card .c-actions {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  margin-top: 2px;
+}
+.c-del {
+  font-family: var(--sans);
+  font-size: 12px;
+  color: var(--g-400);
+  background: none;
+  border: none;
+  cursor: pointer;
+  padding: 5px 10px;
+  border-radius: var(--r-sm);
+}
+.c-del:hover { color: var(--err); background: var(--g-50); }
+.c-del:disabled { opacity: 0.5; cursor: default; }
+
+/* === Dropzone (upload ZIP) === */
+.dropzone {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  min-width: 280px;
+  min-height: 84px;
+  padding: 16px 20px;
+  border: none;
+  border-radius: var(--r-md);
+  background: var(--surface);
+  color: var(--g-400);
+  cursor: pointer;
+  text-align: center;
+  transition: background 0.15s, color 0.15s;
+  max-width: 100%;
+}
+.dropzone:hover { background: var(--raised-2); color: var(--ink); }
+.dropzone.is-dragover {
+  background: var(--fern-soft);
+  color: var(--fern-deep);
+}
+.dropzone input[type="file"] { display: none; }
+.dropzone-hint { font-size: 12.5px; }
+.dropzone-large {
+  min-height: 210px;
+  flex-direction: column;
+  gap: 10px;
+}
+.dropzone-meta {
+  font-family: var(--mono);
+  font-size: 10.5px;
+  color: var(--g-300);
+}
+
+/* Lien d'évitement (a11y clavier) : masqué visuellement, visible au focus. */
+.skip-link {
+  position: absolute;
+  left: 8px;
+  top: -48px;
+  z-index: 100;
+  background: var(--ink);
+  color: var(--paper);
+  padding: 8px 14px;
+  border-radius: var(--r-md);
+  font-family: var(--mono);
+  font-size: 12px;
+  text-decoration: none;
+  transition: top 0.12s ease;
+}
+.skip-link:focus {
+  top: 8px;
+}
+/* La cible de saut ne doit pas afficher d'anneau de focus au saut clavier. */
+.main:focus {
+  outline: none;
+}
+
+/* Aperçu de normalisation : résultat monospace, espaces visibles, sur la charte. */
+.norm-result {
+  font-family: var(--mono);
+  font-size: 12px;
+  color: var(--ink);
+  background: var(--surface);
+  border-radius: var(--r-md);
+  padding: 10px 12px;
+  margin: 0;
+  min-height: 1.4em;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+.norm-custom summary {
+  cursor: pointer;
+}
+.config-io {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  align-items: center;
+}
+
+/* === Bibliothèque : organisation produit === */
+.tabs {
+  display: inline-flex;
+  align-self: flex-start;
+  background: var(--surface);
+  border-radius: var(--r-pill);
+  padding: 4px;
+  gap: 2px;
+}
+.tabs a,
+.tabs button {
+  border: 0;
+  background: transparent;
+  color: var(--g-500);
+  border-radius: var(--r-pill);
+  padding: 8px 18px;
+  font-family: var(--sans);
+  font-size: 13px;
+  font-weight: 500;
+  cursor: pointer;
+}
+.tabs a.on,
+.tabs button.on { background: var(--ink); color: var(--paper); }
+.tabs a:hover:not(.on),
+.tabs button:hover:not(.on) { color: var(--ink); background: var(--g-50); }
+
+.library-panel {
+  display: flex;
+  flex-direction: column;
+  gap: 18px;
+}
+.library-local-grid {
+  display: grid;
+  grid-template-columns: minmax(320px, 0.92fr) minmax(360px, 1.08fr);
+  gap: 14px;
+  align-items: stretch;
+}
+.stack-head {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+.stack-title {
+  font-family: var(--display);
+  font-size: 21px;
+  font-weight: 700;
+  letter-spacing: -0.02em;
+}
+.stack-sub {
+  font-family: var(--accent);
+  font-style: italic;
+  font-size: 13px;
+  color: var(--g-400);
+}
+.upload-panel {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+.upload-panel-empty {
+  max-width: 760px;
+}
+.empty-panel {
+  min-height: 160px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  color: var(--g-400);
+  border: 1px dashed var(--g-100);
+}
+.corpus-stack {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+.corpus-stack-head {
+  padding: 4px 2px 0;
+}
+.corpus-card .c-top {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 10px;
+}
+.corpus-detail-grid {
+  display: grid;
+  grid-template-columns: minmax(0, 1.2fr) minmax(0, 0.8fr);
+  gap: 12px;
+}
+.corpus-detail {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+.corpus-preview,
+.result-card-tags {
+  display: flex;
+  gap: 8px;
+  flex-wrap: wrap;
+}
+.preview-chip {
+  display: inline-flex;
+  align-items: center;
+  min-height: 28px;
+  padding: 5px 10px;
+  border-radius: var(--r-pill);
+  background: var(--surface);
+  color: var(--g-500);
+  font-family: var(--mono);
+  font-size: 10.5px;
+}
+.detail-line {
+  display: flex;
+  gap: 8px;
+  align-items: baseline;
+  flex-wrap: wrap;
+  font-size: 12.5px;
+  color: var(--g-500);
+}
+
+.source-switch {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 10px;
+}
+.source-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 10px;
+  background: var(--surface);
+  color: var(--g-500);
+  border-radius: var(--r-pill);
+  padding: 10px 16px 10px 10px;
+  font-size: 14px;
+  font-weight: 500;
+  transition: background 0.15s, color 0.15s;
+  min-width: 0;
+  overflow-wrap: anywhere;
+}
+.source-chip:hover { background: var(--g-50); color: var(--ink); }
+.source-chip.on { background: var(--ink); color: var(--paper); }
+.src-glyph {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  min-width: 28px;
+  height: 28px;
+  padding: 0 7px;
+  border-radius: var(--r-pill);
+  background: var(--ink);
+  color: var(--paper);
+  font-family: var(--mono);
+  font-size: 10px;
+  letter-spacing: 0.03em;
+}
+.source-chip.on .src-glyph {
+  background: var(--paper);
+  color: var(--ink);
+}
+.src-count {
+  font-family: var(--mono);
+  font-size: 10.5px;
+  color: var(--g-300);
+  letter-spacing: 0.04em;
+}
+.source-chip.on .src-count { color: rgba(239, 237, 232, 0.7); }
+.source-panel {
+  display: flex;
+  flex-direction: column;
+  gap: 14px;
+  margin-top: 16px;
+}
+.source-shell,
+.import-card {
+  display: flex;
+  flex-direction: column;
+  gap: 14px;
+}
+.source-headline {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 12px;
+  flex-wrap: wrap;
+}
+.catalog-card-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
+  gap: 14px;
+}
+.result-card {
+  display: flex;
+  flex-direction: column;
+  gap: 14px;
+}
+.result-card-head {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+  gap: 10px;
+}
+.result-card-title {
+  font-weight: 600;
+  font-size: 15px;
+  color: var(--ink);
+  overflow-wrap: anywhere;
+}
+.result-card-meta {
+  margin-top: 4px;
+  color: var(--g-400);
+  font-size: 12px;
+}
+.result-card-copy {
+  color: var(--g-500);
+  font-size: 13px;
+  overflow-wrap: anywhere;
+}
+.result-card-actions,
+.import-actions {
+  display: flex;
+  gap: 10px;
+  flex-wrap: wrap;
+}
+.result-card-actions .btn,
+.import-actions .btn {
+  min-width: 160px;
+}
+.import-actions {
+  align-items: center;
+  padding-top: 10px;
+  border-top: 1px solid var(--g-100);
+}
+.input-wide { min-width: min(520px, 100%); }
+
+/* === Recherche (catalogues) === */
+.search {
+  display: flex;
+  gap: 8px;
+  align-items: center;
+}
+.search-input {
+  flex: 1;
+  min-width: min(280px, 100%);
+}
+.library-search {
+  background: var(--surface);
+  border-radius: var(--r-md);
+  padding: 12px;
+}
+
+/* === Composeur (Banc d'essai : file de concurrents) === */
+.composer-shell { display: flex; flex-direction: column; gap: 12px; }
+.queue-list { display: flex; flex-direction: column; gap: 10px; }
+.composer-draft {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+  align-items: end;
+  gap: 12px;
+}
+.comp-field { display: flex; flex-direction: column; gap: 4px; }
+.comp-label {
+  font-family: var(--mono);
+  font-size: 9.5px;
+  letter-spacing: 0.05em;
+  text-transform: uppercase;
+  color: var(--g-400);
+}
+.comp-field .select,
+.comp-field .input { min-width: 0; width: 100%; }
+.comp-field-prompt { grid-column: 1 / -1; }
+.comp-prompt {
+  border-radius: var(--r-md);
+  resize: vertical;
+  min-height: 64px;
+  font-family: var(--mono);
+  font-size: 12.5px;
+  line-height: 1.5;
+}
+.queue-panel {
+  margin-top: 14px;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  min-height: 188px;
+}
+.queue-row {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr) auto;
+  gap: 12px;
+  align-items: center;
+  padding: 14px 0;
+  border-bottom: 1px solid var(--g-100);
+}
+.queue-row:last-child { border-bottom: none; padding-bottom: 0; }
+.queue-id {
+  color: var(--g-400);
+  font-size: 11px;
+}
+.queue-main {
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+}
+.queue-label {
+  font-weight: 600;
+  color: var(--ink);
+}
+.queue-meta {
+  color: var(--g-400);
+  font-size: 12px;
+  overflow-wrap: anywhere;
+}
+
+/* === Sparklines / tendances (Historique) === */
+.trend-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(220px, 1fr));
+  gap: 12px;
+}
+.trend-card {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+.trend-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+.trend-head .t-pipe { font-weight: 600; font-size: 13px; color: var(--ink); overflow-wrap: anywhere; }
+.trend-spark { color: var(--fern-deep); }
+.trend-spark .spark { width: 100%; height: 30px; display: block; }
+.trend-meta { display: flex; gap: 12px; font-size: 10.5px; color: var(--g-400); }
+
+@media (max-width: 900px) {
+  .view-hero-stats {
+    justify-content: flex-start;
+  }
+  .library-local-grid {
+    grid-template-columns: 1fr;
+  }
+  .corpus-detail-grid { grid-template-columns: 1fr; }
+}
+
+@media (max-width: 720px) {
+  .app { grid-template-columns: 1fr; }
+  .rail {
+    position: static;
+    height: auto;
+    overflow: visible;
+    padding: 18px 18px 12px;
+  }
+  .rail-nav-window {
+    padding: 8px;
+    overflow: hidden;
+  }
+  .rail-nav {
+    flex-direction: row;
+    overflow-x: auto;
+    scroll-padding: 8px;
+  }
+  .nav-item {
+    flex: 0 0 auto;
+    min-width: 136px;
+  }
+  .rail-system {
+    flex: none;
+    overflow: visible;
+  }
+  .main { padding: 0 18px 48px; }
+  .view-hero,
+  .sec { border-radius: var(--r-md); padding: 20px; }
+  .view-hero-name { font-size: 32px; }
+  .hero-stat { text-align: left; }
+  .sec-head { align-items: flex-start; flex-direction: column; }
+  .sec-aside { white-space: normal; }
+  .report-row,
+  .c-actions,
+  .run-line,
+  .queue-row {
+    align-items: stretch;
+    flex-direction: column;
+  }
+  .btn,
+  .select {
+    width: 100%;
+  }
+  .corpus-select-row {
+    grid-template-columns: 1fr;
+  }
+  .search { align-items: stretch; flex-direction: column; }
+  .search-input,
+  .input,
+  .dropzone,
+  .comp-field,
+  .comp-field .select,
+  .comp-field .input {
+    min-width: 100%;
+  }
+  .source-switch {
+    display: grid;
+    grid-template-columns: 1fr;
+  }
+  .source-chip {
+    width: 100%;
+  }
+  .import-actions {
+    align-items: stretch;
+    flex-direction: column;
+  }
+}
diff --git a/cinoc/interfaces/web/static/fonts/FluxischElse-Bold.woff2 b/cinoc/interfaces/web/static/fonts/FluxischElse-Bold.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..31cada64791095dae4a548b7a917884a7bf10470
--- /dev/null
+++ b/cinoc/interfaces/web/static/fonts/FluxischElse-Bold.woff2
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb9da809769fab892689884e6e8762896e9a8159307eb414c8476e0022172bbc
+size 76708
diff --git a/cinoc/interfaces/web/static/fonts/FluxischElse-LICENSE.txt b/cinoc/interfaces/web/static/fonts/FluxischElse-LICENSE.txt
new file mode 100644
index 0000000000000000000000000000000000000000..51b5df61ef430ca37031a00b50d37f46399960c3
--- /dev/null
+++ b/cinoc/interfaces/web/static/fonts/FluxischElse-LICENSE.txt
@@ -0,0 +1,95 @@
+Copyright (c) 2010, OSP (Open Source Publishing,
+http://ospublish.constantvzw.org/foundry/univers-else),
+with Reserved Font Name "Fluxisch Else".
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://scripts.sil.org/OFL
+
+(Provenance note: the original export bundled empty LICENSE/FONTLOG/COPYRIGHT
+placeholders; this file restores the OFL 1.1 text declared in the font's own
+embedded metadata — "Fluxisch Else is released under the OFL 1.1".)
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical writer or
+other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components, in
+Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or in
+the appropriate machine-readable metadata fields within text or binary
+files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any Modified
+Version, except to acknowledge the contribution(s) of the Copyright
+Holder(s) and the Author(s) or with their explicit written permission.
+
+5) The Font Software, modified or unmodified, in part or in whole, must be
+distributed entirely under this license, and must not be distributed under
+any other license. The requirement for fonts to remain under this license
+does not apply to any document created using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/cinoc/interfaces/web/static/fonts/FluxischElse-Light.woff2 b/cinoc/interfaces/web/static/fonts/FluxischElse-Light.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..c80a264be445dca0cbad982624bf105a008e1aa8
--- /dev/null
+++ b/cinoc/interfaces/web/static/fonts/FluxischElse-Light.woff2
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f1b695e2eb9fa7e54f20659e0101e71e7b00cbc10b53df3ecbd92eb35b2b695
+size 86392
diff --git a/cinoc/interfaces/web/static/fonts/FluxischElse-Regular.woff2 b/cinoc/interfaces/web/static/fonts/FluxischElse-Regular.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..be72a62fe9a0c4c83e6ee05b019a43006d3072aa
--- /dev/null
+++ b/cinoc/interfaces/web/static/fonts/FluxischElse-Regular.woff2
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:54a971ffced4a944268f29685f36a960d2faff924ac94f8423bdf73a6f1a2750
+size 78444
diff --git a/cinoc/interfaces/web/static/fonts/IBMPlex-LICENSE.txt b/cinoc/interfaces/web/static/fonts/IBMPlex-LICENSE.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c35c4c618fab33da8695177b3a6cefe0810b7b28
--- /dev/null
+++ b/cinoc/interfaces/web/static/fonts/IBMPlex-LICENSE.txt
@@ -0,0 +1,93 @@
+Copyright © 2017 IBM Corp. with Reserved Font Name "Plex"
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+
+This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/cinoc/interfaces/web/static/fonts/IBMPlexMono-Medium.woff2 b/cinoc/interfaces/web/static/fonts/IBMPlexMono-Medium.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..a2a3783c5270d96db4ec1ec1d4d1a1c7ef8e3bd3
--- /dev/null
+++ b/cinoc/interfaces/web/static/fonts/IBMPlexMono-Medium.woff2
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:33faf307fa6031fb4062276d7320a6d632de890cbb347576fd80cfa01077bc25
+size 50400
diff --git a/cinoc/interfaces/web/static/fonts/IBMPlexMono-Regular.woff2 b/cinoc/interfaces/web/static/fonts/IBMPlexMono-Regular.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..48a5bee42ca85dbf47c7bff5baa4b31130098335
--- /dev/null
+++ b/cinoc/interfaces/web/static/fonts/IBMPlexMono-Regular.woff2
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ba204497f16b6d334cee9d1e963a831b73e3a56e1d6300a8489d18df7214b350
+size 49248
diff --git a/cinoc/interfaces/web/static/fonts/IBMPlexSans-Medium.woff2 b/cinoc/interfaces/web/static/fonts/IBMPlexSans-Medium.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..a450c56462c40b53cb09988dfa1233fadba7cc17
--- /dev/null
+++ b/cinoc/interfaces/web/static/fonts/IBMPlexSans-Medium.woff2
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5660f8a658f8bb50dbc005232f885eadffd2bc1c235c4f6fbb63469d1f9cde6d
+size 66740
diff --git a/cinoc/interfaces/web/static/fonts/IBMPlexSans-Regular.woff2 b/cinoc/interfaces/web/static/fonts/IBMPlexSans-Regular.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..3ef9f873cfd31a53eb876d49799ca75a4b14bf8f
--- /dev/null
+++ b/cinoc/interfaces/web/static/fonts/IBMPlexSans-Regular.woff2
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ba711a3085ff9f27440b6b9c4550cfc47c97bf36591d5da958b975bb3add8c1a
+size 63020
diff --git a/cinoc/interfaces/web/static/fonts/IBMPlexSans-SemiBold.woff2 b/cinoc/interfaces/web/static/fonts/IBMPlexSans-SemiBold.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..55912838c0f0eb5bb043834634c7e09d0ea0646d
--- /dev/null
+++ b/cinoc/interfaces/web/static/fonts/IBMPlexSans-SemiBold.woff2
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f78048030eab62e860efa39a0df79e2e5581bf122eb95b9bc42c0b8a4988d205
+size 67060
diff --git a/cinoc/interfaces/web/static/fonts/MonaSans-LICENSE.txt b/cinoc/interfaces/web/static/fonts/MonaSans-LICENSE.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ccc02aabb5b4e7bacc17eaac508ac45220c4518c
--- /dev/null
+++ b/cinoc/interfaces/web/static/fonts/MonaSans-LICENSE.txt
@@ -0,0 +1,93 @@
+Copyright 2022 The Mona Sans Project Authors (https://github.com/github/mona-sans), with Reserved Font Name "Mona"
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://openfontlicense.org
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/cinoc/interfaces/web/static/fonts/MonaSansVF-opsz-wght.woff2 b/cinoc/interfaces/web/static/fonts/MonaSansVF-opsz-wght.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..0dee5f8afaf3aa15d24a165b36a77528386b133f
--- /dev/null
+++ b/cinoc/interfaces/web/static/fonts/MonaSansVF-opsz-wght.woff2
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:62e40f6e14e5bbb97132b4513a4d97319ab6aaa46996cf46c7a9f357edadb662
+size 137252
diff --git a/cinoc/interfaces/web/static/fonts/OCRA-LICENSE.txt b/cinoc/interfaces/web/static/fonts/OCRA-LICENSE.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4ae51a104b0d40fee0ded9d4cd106ace247b4d19
--- /dev/null
+++ b/cinoc/interfaces/web/static/fonts/OCRA-LICENSE.txt
@@ -0,0 +1,30 @@
+OCR-A — Public Domain (John Sauter)
+===================================
+
+File: OCRA.pfa  (PostScript Type 1, ASCII; FontName "OCRA", version 001.000)
+
+PROVENANCE
+----------
+The font's embedded notice reads:
+    "Created by Sauter ... with FontForge (http://fontforge.sf.net)"
+This matches John Sauter's "OCR-A font" project:
+    https://sourceforge.net/projects/ocr-a-font/
+described as "A free OCR-A font, conformant to ANSI X3.17-1977, in TrueType
+format, with sources", released into the **PUBLIC DOMAIN**.
+
+LICENSE
+-------
+Public Domain. Free for any use — including commercial use, modification and
+redistribution — with no license obligations. (The .pfa itself carries no
+license string; this status comes from the upstream project above.)
+
+BUILD NOTE
+----------
+.pfa (Type 1) is not a web font format. Convert to woff2/otf for @font-face
+(e.g. with fontforge or fonttools). Public-domain status permits this freely.
+
+NOT USED
+--------
+The "OCR-A BT (c) Bitstream Inc. — All rights reserved / Confidential" files
+tested earlier (OCR-a___.ttf, OCR-A Regular.otf, from "free font" download
+sites) are PROPRIETARY and are deliberately excluded. See design/README.md.
diff --git a/cinoc/interfaces/web/static/fonts/OCRA.woff2 b/cinoc/interfaces/web/static/fonts/OCRA.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..bf62cec7f57ad50290233d7aff438d3acb40f59a
--- /dev/null
+++ b/cinoc/interfaces/web/static/fonts/OCRA.woff2
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e83f0513675d0bdeb8be3c4a3ffcaac7e5d2c33e1c4937803f9691c40943ba4f
+size 11264
diff --git a/cinoc/interfaces/web/static/js/benchmark.js b/cinoc/interfaces/web/static/js/benchmark.js
new file mode 100644
index 0000000000000000000000000000000000000000..1746af301b92773e05cac23cbf0c7345897e7349
--- /dev/null
+++ b/cinoc/interfaces/web/static/js/benchmark.js
@@ -0,0 +1,697 @@
+/* Banc d'essai — composeur de benchmark et suivi SSE.
+ *
+ * Un seul brouillon de concurrent alimente une file visible. Le serveur reste
+ * la source de vérité pour le lancement et les erreurs ; le client ne traduit
+ * que les états HTTP en messages lisibles.
+ */
+(function () {
+  "use strict";
+
+  var CSRF = "X-Cinoc-CSRF";
+  var STATES = ["pending", "running", "done", "failed", "cancelled"];
+  var TERMINAL = { done: 1, failed: 1, cancelled: 1 };
+
+  function ready(fn) {
+    if (document.readyState !== "loading") fn();
+    else document.addEventListener("DOMContentLoaded", fn);
+  }
+
+  function fetchJson(url, opts) {
+    return fetch(url, opts).then(function (res) {
+      return res.json().then(
+        function (body) {
+          return { ok: res.ok, status: res.status, body: body };
+        },
+        function () {
+          return { ok: res.ok, status: res.status, body: {} };
+        }
+      );
+    });
+  }
+
+  function wireNormalizationPreview() {
+    var btn = document.getElementById("norm-preview-btn");
+    var sample = document.getElementById("norm-sample");
+    var config = document.getElementById("norm-config");
+    var select = document.getElementById("normalization");
+    var out = document.getElementById("norm-result");
+    if (!btn || !sample || !out) return;
+    btn.addEventListener("click", function () {
+      var payload = { sample: sample.value };
+      var custom = config && config.value ? config.value.trim() : "";
+      if (custom) payload.config = custom;
+      else if (select && select.value) payload.profile = select.value;
+      var headers = { "Content-Type": "application/json" };
+      headers[CSRF] = "1";
+      out.textContent = "…";
+      fetchJson("/api/normalization/preview", {
+        method: "POST",
+        headers: headers,
+        body: JSON.stringify(payload),
+      }).then(function (r) {
+        out.textContent = r.ok
+          ? r.body.normalized || ""
+          : "Erreur : " + (r.body.detail || r.status);
+      });
+    });
+  }
+
+  // Aperçu de mise en page (mode hybride) : lance une segmentation sur le corpus
+  // choisi et injecte le SVG des régions (rendu serveur). Remplace l'ancienne page
+  // /segmentation — la visualisation vit désormais dans le lanceur.
+  function wireSegPreview() {
+    var btn = document.getElementById("seg-preview-btn");
+    var container = document.getElementById("seg-preview");
+    if (!btn || !container) return;
+    var status = document.getElementById("seg-preview-status");
+    var corpusSelect = document.getElementById("corpus-select");
+    var segmenter = document.getElementById("draft-segmenter");
+    var endpoint = document.getElementById("draft-seg-endpoint");
+    var token = document.getElementById("draft-seg-token");
+
+    function poll(jobId) {
+      fetchJson("/api/runs/" + encodeURIComponent(jobId)).then(function (res) {
+        var state = res.body && res.body.state;
+        if (state === "done") {
+          // Le sink clé le store par id propre → on lit le dernier layout persisté.
+          fetch("/api/segmentation/preview")
+            .then(function (r) {
+              return r.ok ? r.text() : "";
+            })
+            .then(function (svg) {
+              container.innerHTML = svg;
+              if (status) status.textContent = "";
+              btn.disabled = false;
+            });
+          return;
+        }
+        if (state === "failed" || state === "cancelled" || !res.ok) {
+          if (status) {
+            status.textContent =
+              (res.body && res.body.error) || "HTTP " + res.status;
+          }
+          btn.disabled = false;
+          return;
+        }
+        window.setTimeout(function () {
+          poll(jobId);
+        }, 1500);
+      });
+    }
+
+    btn.addEventListener("click", function () {
+      var corpusId = corpusSelect && corpusSelect.value;
+      if (!corpusId) {
+        if (status) status.textContent = btn.getAttribute("data-no-corpus") || "";
+        return;
+      }
+      var payload = {
+        corpus_id: corpusId,
+        segmenter: segmenter ? segmenter.value : "pp_doclayout",
+      };
+      if (payload.segmenter === "remote_segmenter") {
+        if (endpoint && endpoint.value.trim()) payload.endpoint = endpoint.value.trim();
+        if (token && token.value.trim()) payload.token = token.value.trim();
+      }
+      var headers = { "Content-Type": "application/json" };
+      headers[CSRF] = "1";
+      btn.disabled = true;
+      if (status) status.textContent = status.getAttribute("data-running") || "…";
+      fetchJson("/api/segmentation/run", {
+        method: "POST",
+        headers: headers,
+        body: JSON.stringify(payload),
+      }).then(function (res) {
+        if (!res.ok) {
+          if (status) {
+            status.textContent =
+              (res.body && res.body.detail) || "HTTP " + res.status;
+          }
+          btn.disabled = false;
+          return;
+        }
+        poll(res.body.job_id);
+      });
+    });
+  }
+
+  ready(function () {
+    wireNormalizationPreview();
+    wireSegPreview();
+    var launchBtn = document.getElementById("launch");
+    var statusEl = document.getElementById("run-status");
+    var resultEl = document.getElementById("run-result");
+    var logEl = document.getElementById("run-log");
+    var logShell = document.getElementById("run-log-shell");
+    var progressWrap = document.getElementById("run-progress");
+    var progressBar = document.getElementById("run-progress-bar");
+    var progressText = document.getElementById("run-progress-text");
+    var corpusSelect = document.getElementById("corpus-select");
+    var normalization = document.getElementById("normalization");
+    var charExclude = document.getElementById("char-exclude");
+    var metricProfile = document.getElementById("metric-profile");
+    var addBtn = document.getElementById("add-competitor");
+    var queueTpl = document.getElementById("queue-row-tpl");
+    var queueList = document.getElementById("queue-list");
+    var queueEmpty = document.getElementById("queue-empty");
+    if (!launchBtn || !statusEl || !resultEl || !queueList || !queueTpl) return;
+
+    var queue = [];
+    var activeMode = "ocr_only";
+    var modeButtons = document.querySelectorAll("[data-mode]");
+    var draftFields = document.querySelectorAll("[data-show]");
+    var draftOcr = document.getElementById("draft-ocr");
+    var draftLlm = document.getElementById("draft-llm");
+    var draftVlm = document.getElementById("draft-vlm");
+    var draftSegmenter = document.getElementById("draft-segmenter");
+    var draftRecognizer = document.getElementById("draft-recognizer");
+    var draftSegEndpoint = document.getElementById("draft-seg-endpoint");
+    var draftSegToken = document.getElementById("draft-seg-token");
+    var draftSegEndpointField = document.getElementById("draft-seg-endpoint-field");
+    var draftSegTokenField = document.getElementById("draft-seg-token-field");
+    var draftModel = document.getElementById("draft-model");
+    var draftPrompt = document.getElementById("draft-prompt");
+    var draftPromptCurated = document.getElementById("draft-prompt-curated");
+    var draftNer = document.getElementById("draft-ner");
+    var draftNerModel = document.getElementById("draft-ner-model");
+    var draftAlto = document.getElementById("draft-alto");
+    var queueLabels = {
+      ocr: queueList.getAttribute("data-label-ocr") || "OCR",
+      ocrLlm: queueList.getAttribute("data-label-ocr-llm") || "OCR → LLM",
+      ocrVlm: queueList.getAttribute("data-label-ocr-vlm") || "OCR → VLM",
+      vlm: queueList.getAttribute("data-label-vlm") || "VLM",
+      hybrid: queueList.getAttribute("data-label-hybrid") || "Hybride",
+    };
+
+    // Endpoint/jeton du segmenteur distant : visibles seulement en mode hybride
+    // ET quand ``remote_segmenter`` est choisi (sinon ils n'ont aucun sens).
+    function syncSegFields() {
+      if (!draftSegmenter) return;
+      var isRemote =
+        activeMode === "hybrid" && draftSegmenter.value === "remote_segmenter";
+      if (draftSegEndpointField) draftSegEndpointField.hidden = !isRemote;
+      if (draftSegTokenField) draftSegTokenField.hidden = !isRemote;
+    }
+    if (draftSegmenter) draftSegmenter.addEventListener("change", syncSegFields);
+
+    function currentCorpusId() {
+      return corpusSelect && corpusSelect.value ? corpusSelect.value : null;
+    }
+
+    function applyQueryCorpus() {
+      var corpusId = new URLSearchParams(window.location.search).get("corpus");
+      if (corpusId && corpusSelect) corpusSelect.value = corpusId;
+    }
+
+    // Le champ « Modèle » pointe vers la datalist du fournisseur sélectionné
+    // (ollama / mistral), qui n'existe que si le serveur a renvoyé des modèles.
+    // Sinon : saisie libre. Rien de hardcodé — les options viennent du serveur.
+    var modelCache = {};
+
+    function applyDatalist(listId, count) {
+      if (listId && count) draftModel.setAttribute("list", listId);
+      else draftModel.removeAttribute("list");
+      var hint = document.getElementById("model-hint");
+      if (hint) {
+        hint.textContent = count
+          ? count + " modèle(s) suggéré(s) — clique pour choisir"
+          : "";
+      }
+    }
+
+    function fillApiList(models) {
+      var dl = document.getElementById("api-model-list");
+      if (!dl) return 0;
+      dl.textContent = "";
+      for (var i = 0; i < models.length; i++) {
+        var opt = document.createElement("option");
+        opt.value = models[i].name;
+        if (models[i].vision) opt.label = "vision";
+        dl.appendChild(opt);
+      }
+      return models.length;
+    }
+
+    function currentProvider() {
+      if (activeMode === "text_only") return draftLlm && draftLlm.value;
+      if (activeMode === "text_and_image" || activeMode === "zero_shot") {
+        return draftVlm && draftVlm.value;
+      }
+      // En hybride, le « modèle » cible le reconnaisseur par bloc (utile aux VLM).
+      if (activeMode === "hybrid") return draftRecognizer && draftRecognizer.value;
+      return "";
+    }
+
+    function updateModelList() {
+      if (!draftModel) return;
+      var provider = currentProvider();
+      // Modèles réellement installés (live) : datalists rendues côté serveur.
+      if (provider === "ollama" || provider === "mistral") {
+        var dl = document.getElementById(provider + "-models");
+        applyDatalist(provider + "-models", dl ? dl.children.length : 0);
+        return;
+      }
+      // openai/anthropic : pas de source live → liste canonique + capacité vision
+      // via /api/models/{provider} (même origine ; mise en cache).
+      if (provider === "openai" || provider === "anthropic") {
+        if (modelCache[provider]) {
+          applyDatalist("api-model-list", fillApiList(modelCache[provider]));
+          return;
+        }
+        var asked = provider;
+        fetch("/api/models/" + encodeURIComponent(provider))
+          .then(function (r) {
+            return r.ok ? r.json() : { models: [] };
+          })
+          .then(function (data) {
+            modelCache[asked] = data.models || [];
+            if (currentProvider() === asked) {
+              applyDatalist("api-model-list", fillApiList(modelCache[asked]));
+            }
+          })
+          .catch(function () {});
+        return;
+      }
+      applyDatalist("", 0);
+    }
+
+    function setMode(mode) {
+      activeMode = mode;
+      for (var i = 0; i < modeButtons.length; i++) {
+        var isActive = modeButtons[i].getAttribute("data-mode") === mode;
+        modeButtons[i].classList.toggle("on", isActive);
+        modeButtons[i].setAttribute("aria-selected", isActive ? "true" : "false");
+      }
+      for (var j = 0; j < draftFields.length; j++) {
+        var shown = draftFields[j].getAttribute("data-show").split(" ");
+        draftFields[j].hidden = shown.indexOf(mode) < 0;
+      }
+      syncSegFields();
+      updateModelList();
+    }
+
+    function summarize(entry) {
+      if (entry.mode === "ocr_only") {
+        return {
+          label: queueLabels.ocr,
+          meta: entry.engine,
+        };
+      }
+      if (entry.mode === "text_only") {
+        return {
+          label: queueLabels.ocrLlm,
+          meta: entry.engine + " → " + entry.llm + (entry.model ? " · " + entry.model : ""),
+        };
+      }
+      if (entry.mode === "text_and_image") {
+        return {
+          label: queueLabels.ocrVlm,
+          meta: entry.engine + " → " + entry.llm + (entry.model ? " · " + entry.model : ""),
+        };
+      }
+      if (entry.mode === "hybrid") {
+        return {
+          label: queueLabels.hybrid,
+          meta:
+            entry.segmenter + " → " + entry.engine +
+            (entry.model ? " · " + entry.model : ""),
+        };
+      }
+      return {
+        label: queueLabels.vlm,
+        meta: entry.engine + (entry.model ? " · " + entry.model : ""),
+      };
+    }
+
+    function renderQueue() {
+      queueList.textContent = "";
+      if (queueEmpty) queueEmpty.hidden = queue.length > 0;
+      for (var i = 0; i < queue.length; i++) {
+        var node = queueTpl.content.firstElementChild.cloneNode(true);
+        var summary = summarize(queue[i]);
+        node.querySelector(".queue-id").textContent = "C0" + (i + 1);
+        node.querySelector(".queue-label").textContent = summary.label;
+        node.querySelector(".queue-meta").textContent = summary.meta;
+        bindRemove(node.querySelector(".queue-remove"), i);
+        queueList.appendChild(node);
+      }
+    }
+
+    function bindRemove(button, index) {
+      if (!button) return;
+      button.addEventListener("click", function () {
+        queue.splice(index, 1);
+        renderQueue();
+      });
+    }
+
+    function buildDraft() {
+      var model = draftModel && draftModel.value ? draftModel.value.trim() : "";
+      var prompt = draftPrompt && draftPrompt.value ? draftPrompt.value.trim() : "";
+      // Texte libre prioritaire : s'il est saisi, on ignore le prompt curé (le
+      // serveur refuse d'ailleurs les deux à la fois).
+      var promptName =
+        !prompt && draftPromptCurated ? draftPromptCurated.value : "";
+      var ner = !!(draftNer && draftNer.checked);
+      var nerModel =
+        ner && draftNerModel && draftNerModel.value
+          ? draftNerModel.value.trim()
+          : "";
+      // ALTO : export tesseract uniquement (la case est masquée en zero_shot, sans
+      // étape OCR) ; le serveur refuse l'option avec un autre moteur.
+      var alto = !!(draftAlto && draftAlto.checked) && activeMode !== "zero_shot";
+      if (activeMode === "ocr_only") {
+        // En OCR seul, `model` = le modèle du moteur (kraken/pero/calamari : path ;
+        // mistral_ocr : nom). Tesseract/Google/Azure l'ignorent.
+        return {
+          engine: draftOcr.value,
+          mode: "ocr_only",
+          model: model,
+          ner: ner,
+          nerModel: nerModel,
+          alto: alto,
+        };
+      }
+      if (activeMode === "text_only") {
+        return {
+          engine: draftOcr.value,
+          mode: "text_only",
+          llm: draftLlm.value,
+          model: model,
+          prompt: prompt,
+          promptName: promptName,
+          ner: ner,
+          nerModel: nerModel,
+          alto: alto,
+        };
+      }
+      if (activeMode === "text_and_image") {
+        return {
+          engine: draftOcr.value,
+          mode: "text_and_image",
+          llm: draftVlm.value,
+          model: model,
+          prompt: prompt,
+          promptName: promptName,
+          ner: ner,
+          nerModel: nerModel,
+          alto: alto,
+        };
+      }
+      if (activeMode === "hybrid") {
+        // Hybride : segmenteur en tête, ``engine`` = reconnaisseur par bloc (OCR
+        // ou VLM zero-shot). ``model``/``prompt`` ciblent le reconnaisseur.
+        var seg = draftSegmenter ? draftSegmenter.value : "";
+        var remote = seg === "remote_segmenter";
+        return {
+          engine: draftRecognizer ? draftRecognizer.value : "",
+          mode: "hybrid",
+          segmenter: seg,
+          segmenterEndpoint:
+            remote && draftSegEndpoint ? draftSegEndpoint.value.trim() : "",
+          segmenterToken:
+            remote && draftSegToken ? draftSegToken.value.trim() : "",
+          model: model,
+          prompt: prompt,
+          promptName: promptName,
+          ner: ner,
+          nerModel: nerModel,
+          alto: alto,
+        };
+      }
+      return {
+        engine: draftVlm.value,
+        mode: "zero_shot",
+        model: model,
+        prompt: prompt,
+        promptName: promptName,
+        ner: ner,
+        nerModel: nerModel,
+        alto: false,
+      };
+    }
+
+    function payloadCompetitors() {
+      var out = [];
+      for (var i = 0; i < queue.length; i++) {
+        var entry = {};
+        entry.engine = queue[i].engine;
+        // ``ocr_only`` et ``hybrid`` n'ont pas de ``mode`` côté serveur (l'hybride
+        // est signalé par ``segmenter``). Les autres portent leur PipelineMode.
+        if (queue[i].mode !== "ocr_only" && queue[i].mode !== "hybrid") {
+          entry.mode = queue[i].mode;
+        }
+        if (queue[i].segmenter) {
+          entry.segmenter = queue[i].segmenter;
+          if (queue[i].segmenterEndpoint) {
+            entry.segmenter_endpoint = queue[i].segmenterEndpoint;
+          }
+          if (queue[i].segmenterToken) {
+            entry.segmenter_token = queue[i].segmenterToken;
+          }
+        }
+        if (queue[i].llm) entry.llm = queue[i].llm;
+        if (queue[i].model) entry.model = queue[i].model;
+        if (queue[i].prompt) entry.prompt = queue[i].prompt;
+        else if (queue[i].promptName) entry.prompt_name = queue[i].promptName;
+        if (queue[i].ner) {
+          entry.ner = true;
+          if (queue[i].nerModel) entry.ner_model = queue[i].nerModel;
+        }
+        if (queue[i].alto) entry.alto = true;
+        out.push(entry);
+      }
+      return out;
+    }
+
+    // Config save/load — l'« état du formulaire » EST un LaunchRequest (même
+    // schéma que le POST /api/runs). Export = blob JSON téléchargé (état courant,
+    // 0 réseau) ; import = validé côté serveur (POST /api/runs/config) AVANT de
+    // repeupler — un fichier malformé est rejeté net, jamais appliqué en silence.
+    function collectConfig() {
+      var cfg = { competitors: payloadCompetitors() };
+      var corpusId = currentCorpusId();
+      if (corpusId) cfg.corpus_id = corpusId;
+      if (normalization && normalization.value) cfg.normalization = normalization.value;
+      if (charExclude && charExclude.value) cfg.char_exclude = charExclude.value;
+      if (metricProfile && metricProfile.value) cfg.metric_profile = metricProfile.value;
+      return cfg;
+    }
+
+    function exportConfig() {
+      var text = JSON.stringify(collectConfig(), null, 2);
+      var uri = "data:application/json;charset=utf-8," + encodeURIComponent(text);
+      var a = document.createElement("a");
+      a.href = uri;
+      a.download = "cinoc-config.json";
+      document.body.appendChild(a);
+      a.click();
+      document.body.removeChild(a);
+    }
+
+    function applyConfig(cfg) {
+      queue = [];
+      var comps = cfg.competitors || [];
+      for (var i = 0; i < comps.length; i++) {
+        var c = comps[i];
+        queue.push({
+          // ``segmenter`` posé ⇒ concurrent hybride (mode interne « hybrid »,
+          // jamais envoyé au serveur) ; sinon ``mode`` explicite ou OCR seul.
+          engine: c.engine,
+          mode: c.segmenter ? "hybrid" : c.mode || "ocr_only",
+          segmenter: c.segmenter || "",
+          segmenterEndpoint: c.segmenter_endpoint || "",
+          segmenterToken: c.segmenter_token || "",
+          llm: c.llm || "",
+          model: c.model || "",
+          prompt: c.prompt || "",
+          promptName: c.prompt_name || "",
+          ner: !!c.ner,
+          nerModel: c.ner_model || "",
+          alto: !!c.alto,
+        });
+      }
+      renderQueue();
+      if (corpusSelect) corpusSelect.value = cfg.corpus_id || "";
+      if (normalization) normalization.value = cfg.normalization || "";
+      if (charExclude) charExclude.value = cfg.char_exclude || "";
+      if (metricProfile && cfg.metric_profile) metricProfile.value = cfg.metric_profile;
+    }
+
+    function importConfig(file, feedback) {
+      var reader = new FileReader();
+      reader.onload = function () {
+        var parsed;
+        try {
+          parsed = JSON.parse(reader.result);
+        } catch (e) {
+          feedback.textContent = feedback.dataset.invalid || "invalid";
+          return;
+        }
+        var headers = { "Content-Type": "application/json" };
+        headers[CSRF] = "1";
+        fetchJson("/api/runs/config", {
+          method: "POST",
+          headers: headers,
+          body: JSON.stringify(parsed),
+        }).then(function (r) {
+          if (!r.ok) {
+            feedback.textContent = feedback.dataset.invalid || "invalid";
+            return;
+          }
+          applyConfig(r.body.config || {});
+          feedback.textContent = feedback.dataset.loaded || "loaded";
+        });
+      };
+      reader.readAsText(file);
+    }
+
+    function errorText(response) {
+      var detail = response && response.body && response.body.detail;
+      if (typeof detail === "string" && detail.trim()) return detail;
+      var specific = resultEl.getAttribute("data-error-" + response.status);
+      return specific || resultEl.dataset.errorFallback || ("HTTP " + response.status);
+    }
+
+    function resetRunFeedback(launchingText) {
+      statusEl.textContent = launchingText || "…";
+      resultEl.textContent = "";
+      if (logEl) logEl.textContent = "";
+      if (logShell) {
+        logShell.hidden = false;
+        logShell.open = true;
+      }
+    }
+
+    function appendLog(state, job) {
+      if (!logEl) return;
+      var line = document.createElement("div");
+      line.textContent = (job.updated_at || "—") + "  ·  " + state;
+      logEl.appendChild(line);
+    }
+
+    function updateProgress(job) {
+      if (!progressWrap || !progressBar) return;
+      var total = job.total || 0;
+      var doneN = job.done || 0;
+      if (total <= 0) return;
+      progressWrap.hidden = false;
+      var pct = Math.round((doneN / total) * 100);
+      progressBar.style.width = pct + "%";
+      var rail = document.getElementById("run-progress-rail");
+      if (rail) rail.setAttribute("aria-valuenow", String(pct));
+      if (progressText) progressText.textContent = doneN + " / " + total;
+    }
+
+    function resetProgress() {
+      if (progressBar) progressBar.style.width = "0%";
+      if (progressText) progressText.textContent = "";
+      if (progressWrap) progressWrap.hidden = true;
+    }
+
+    function subscribe(jobId, onTerminal) {
+      var es = new EventSource("/api/runs/" + encodeURIComponent(jobId) + "/events");
+      var finished = false;
+
+      function done(state, job) {
+        if (finished) return;
+        finished = true;
+        es.close();
+        onTerminal(state, job || {});
+      }
+
+      STATES.forEach(function (state) {
+        es.addEventListener(state, function (ev) {
+          var job = JSON.parse(ev.data);
+          statusEl.textContent = state;
+          appendLog(state, job);
+          updateProgress(job);
+          if (TERMINAL[state]) done(state, job);
+        });
+      });
+
+      es.onerror = function () {
+        if (es.readyState === EventSource.CLOSED) done("failed", {});
+      };
+    }
+
+    function reportTerminal(state, job) {
+      launchBtn.disabled = false;
+      if (state === "done" && job.report_name) {
+        var link = document.createElement("a");
+        link.href = "/reports/" + encodeURIComponent(job.report_name);
+        link.className = "btn btn-primary";
+        link.textContent = resultEl.dataset.open || "report";
+        resultEl.appendChild(link);
+        return;
+      }
+      resultEl.textContent = job.error || (resultEl.dataset.errorFallback || "failed");
+    }
+
+    for (var i = 0; i < modeButtons.length; i++) {
+      modeButtons[i].addEventListener("click", function () {
+        setMode(this.getAttribute("data-mode"));
+      });
+    }
+    // Changer de fournisseur LLM/VLM met à jour la datalist du champ « Modèle ».
+    if (draftLlm) draftLlm.addEventListener("change", updateModelList);
+    if (draftVlm) draftVlm.addEventListener("change", updateModelList);
+    setMode(activeMode);
+
+    if (addBtn) {
+      addBtn.addEventListener("click", function () {
+        queue.push(buildDraft());
+        renderQueue();
+      });
+    }
+    renderQueue();
+
+    applyQueryCorpus();
+
+    var exportBtn = document.getElementById("config-export");
+    var importInput = document.getElementById("config-import");
+    var configFeedback = document.getElementById("config-feedback");
+    if (exportBtn) exportBtn.addEventListener("click", exportConfig);
+    if (importInput && configFeedback) {
+      importInput.addEventListener("change", function () {
+        if (importInput.files && importInput.files[0]) {
+          importConfig(importInput.files[0], configFeedback);
+        }
+      });
+    }
+
+    launchBtn.addEventListener("click", function () {
+      launchBtn.disabled = true;
+      resetRunFeedback(launchBtn.dataset.launching);
+      resetProgress();
+      var headers = { "Content-Type": "application/json" };
+      headers[CSRF] = "1";
+      var payload = { competitors: payloadCompetitors() };
+      var corpusId = currentCorpusId();
+      if (corpusId) payload.corpus_id = corpusId;
+      if (normalization && normalization.value) payload.normalization = normalization.value;
+      if (charExclude && charExclude.value) payload.char_exclude = charExclude.value;
+      if (metricProfile && metricProfile.value) payload.metric_profile = metricProfile.value;
+      fetchJson("/api/runs", {
+        method: "POST",
+        headers: headers,
+        body: JSON.stringify(payload),
+      })
+        .then(function (response) {
+          if (!response.ok) {
+            statusEl.textContent = "HTTP " + response.status;
+            resultEl.textContent = errorText(response);
+            launchBtn.disabled = false;
+            return;
+          }
+          subscribe(response.body.job_id, reportTerminal);
+        })
+        .catch(function () {
+          statusEl.textContent = resultEl.dataset.neterror || "HTTP 0";
+          resultEl.textContent = resultEl.dataset.errorFallback || "HTTP 0";
+          launchBtn.disabled = false;
+        });
+    });
+
+  });
+})();
diff --git a/cinoc/interfaces/web/static/js/corpus.js b/cinoc/interfaces/web/static/js/corpus.js
new file mode 100644
index 0000000000000000000000000000000000000000..11a3262e967e32a2ea76a819161b79f59888ca2a
--- /dev/null
+++ b/cinoc/interfaces/web/static/js/corpus.js
@@ -0,0 +1,258 @@
+/* Bibliothèque — états d'interface, upload ZIP, imports distants et suppression.
+ *
+ * La page reste rendue serveur : ce script ne fait que piloter des onglets et
+ * appeler les endpoints existants. Après succès, on recharge la page pour que
+ * le HTML serveur reste la source de vérité.
+ */
+(function () {
+  "use strict";
+
+  var CSRF = "X-Cinoc-CSRF";
+
+  function ready(fn) {
+    if (document.readyState !== "loading") fn();
+    else document.addEventListener("DOMContentLoaded", fn);
+  }
+
+  function fetchJson(url, opts) {
+    return fetch(url, opts).then(function (res) {
+      return res.json().then(
+        function (body) {
+          return { ok: res.ok, status: res.status, body: body };
+        },
+        function () {
+          return { ok: res.ok, status: res.status, body: {} };
+        }
+      );
+    });
+  }
+
+  function errorText(response) {
+    var detail = response && response.body && response.body.detail;
+    if (typeof detail === "string" && detail.trim()) return detail;
+    return "HTTP " + response.status;
+  }
+
+  function collectField(payload, el) {
+    if (!el || !el.name) return;
+    if (el.type === "checkbox") {
+      payload[el.name] = el.checked;
+      return;
+    }
+    var value = (el.value || "").trim();
+    if (value === "") return;
+    payload[el.name] = el.type === "number" ? parseInt(value, 10) : value;
+  }
+
+  ready(function () {
+    bindLibraryTabs();
+    bindSourceTabs();
+    bindUpload();
+    bindImports();
+    bindDelete();
+  });
+
+  function bindLibraryTabs() {
+    var buttons = document.querySelectorAll("[data-library-tab]");
+    var panels = document.querySelectorAll("[data-library-panel]");
+    if (!buttons.length || !panels.length) return;
+
+    function activate(tab) {
+      for (var i = 0; i < buttons.length; i++) {
+        var isActive = buttons[i].getAttribute("data-library-tab") === tab;
+        buttons[i].classList.toggle("on", isActive);
+        buttons[i].setAttribute("aria-selected", isActive ? "true" : "false");
+      }
+      for (var j = 0; j < panels.length; j++) {
+        panels[j].hidden = panels[j].getAttribute("data-library-panel") !== tab;
+      }
+      if (window.location.hash !== "#" + tab) {
+        history.replaceState(null, "", window.location.pathname + window.location.search + "#" + tab);
+      }
+    }
+
+    for (var k = 0; k < buttons.length; k++) {
+      buttons[k].addEventListener("click", function (event) {
+        if (this.tagName === "A") {
+          event.preventDefault();
+        }
+        activate(this.getAttribute("data-library-tab"));
+      });
+    }
+
+    activate(window.location.hash.indexOf("#discover") === 0 ? "discover" : "corpora");
+  }
+
+  function bindSourceTabs() {
+    var chips = document.querySelectorAll("[data-source-tab]");
+    var panels = document.querySelectorAll("[data-source-panel]");
+    if (!chips.length || !panels.length) return;
+
+    // ``pushHash`` = false à l'initialisation : on prépare seulement le panneau
+    // source visible, SANS réécrire le hash global. Sinon l'activation au
+    // chargement forçait ``#discover:…`` même sur l'onglet « Mes corpus », et un
+    // reload (ex. après upload) atterrissait à tort sur « Découverte ».
+    function activate(source, pushHash) {
+      for (var i = 0; i < chips.length; i++) {
+        var isActive = chips[i].getAttribute("data-source-tab") === source;
+        chips[i].classList.toggle("on", isActive);
+        chips[i].setAttribute("aria-selected", isActive ? "true" : "false");
+      }
+      for (var j = 0; j < panels.length; j++) {
+        panels[j].hidden = panels[j].getAttribute("data-source-panel") !== source;
+      }
+      if (!pushHash) return;
+      var url = new URL(window.location.href);
+      url.hash = "discover:" + source;
+      history.replaceState(null, "", url.toString());
+      if (window.location.hash.indexOf("#discover") !== 0) {
+        var discoverBtn = document.querySelector('[data-library-tab="discover"]');
+        if (discoverBtn) discoverBtn.click();
+      }
+    }
+
+    for (var k = 0; k < chips.length; k++) {
+      chips[k].addEventListener("click", function (event) {
+        if (this.tagName === "A") {
+          event.preventDefault();
+        }
+        activate(this.getAttribute("data-source-tab"), true);
+      });
+    }
+
+    var hash = window.location.hash || "";
+    var initial = hash.indexOf("#discover:") === 0 ? hash.slice(10) : "htr-united";
+    activate(initial, false);
+  }
+
+  function bindUpload() {
+    var fileEl = document.getElementById("corpus-file");
+    var statusEl = document.getElementById("corpus-status");
+    var dropzone = document.getElementById("dropzone");
+
+    function upload(file) {
+      if (!file) return;
+      var headers = {};
+      headers[CSRF] = "1";
+      var form = new FormData();
+      form.append("file", file);
+      if (statusEl) statusEl.textContent = "…";
+      fetchJson("/api/corpus", { method: "POST", headers: headers, body: form })
+        .then(function (response) {
+          if (!response.ok) {
+            if (statusEl) statusEl.textContent = errorText(response);
+            return;
+          }
+          window.location.reload();
+        })
+        .catch(function () {
+          if (statusEl) statusEl.textContent = "HTTP 0";
+        });
+    }
+
+    if (fileEl) {
+      fileEl.addEventListener("change", function () {
+        upload(fileEl.files && fileEl.files[0]);
+      });
+    }
+
+    if (!dropzone) return;
+    ["dragenter", "dragover"].forEach(function (evt) {
+      dropzone.addEventListener(evt, function (e) {
+        e.preventDefault();
+        dropzone.classList.add("is-dragover");
+      });
+    });
+    ["dragleave", "drop"].forEach(function (evt) {
+      dropzone.addEventListener(evt, function (e) {
+        e.preventDefault();
+        dropzone.classList.remove("is-dragover");
+      });
+    });
+    dropzone.addEventListener("drop", function (e) {
+      var dataTransfer = e.dataTransfer;
+      var file = dataTransfer && dataTransfer.files && dataTransfer.files[0];
+      if (file) upload(file);
+    });
+  }
+
+  function bindImports() {
+    var buttons = document.querySelectorAll("[data-import-source]");
+    if (!buttons.length) return;
+
+    for (var i = 0; i < buttons.length; i++) {
+      buttons[i].addEventListener("click", function () {
+        var source = this.getAttribute("data-import-source");
+        if (!source) return;
+        runImport(this, source);
+      });
+    }
+  }
+
+  function runImport(button, source) {
+    var statusEl = document.querySelector('[data-import-status="' + source + '"]');
+    var group = document.querySelector('.import-fields[data-source="' + source + '"]');
+    var payload = {};
+    var fields = group ? group.querySelectorAll("input[name]") : [];
+    for (var i = 0; i < fields.length; i++) collectField(payload, fields[i]);
+    var shared = document.querySelectorAll(
+      '[data-source-panel="' + source + '"] [data-import-shared]'
+    );
+    for (var j = 0; j < shared.length; j++) collectField(payload, shared[j]);
+
+    var datasetId = button.getAttribute("data-dataset-id");
+    if (datasetId) payload.dataset_id = datasetId;
+
+    // Carte « Cinoc curé » découverte : l'identifiant (et la révision pinnée, si
+    // l'API la fournit) viennent du bouton — ils priment sur le formulaire manuel.
+    var repoId = button.getAttribute("data-repo-id");
+    if (repoId) {
+      payload.repo_id = repoId;
+      var revision = button.getAttribute("data-revision");
+      if (revision) payload.revision = revision;
+    }
+
+    var headers = { "Content-Type": "application/json" };
+    headers[CSRF] = "1";
+    button.disabled = true;
+    if (statusEl) statusEl.textContent = "…";
+    fetchJson("/api/corpus/import/" + source, {
+      method: "POST",
+      headers: headers,
+      body: JSON.stringify(payload),
+    })
+      .then(function (response) {
+        button.disabled = false;
+        if (!response.ok) {
+          if (statusEl) statusEl.textContent = errorText(response);
+          return;
+        }
+        window.location.reload();
+      })
+      .catch(function () {
+        button.disabled = false;
+        if (statusEl) statusEl.textContent = "HTTP 0";
+      });
+  }
+
+  function bindDelete() {
+    var buttons = document.querySelectorAll(".c-del[data-corpus]");
+    for (var i = 0; i < buttons.length; i++) {
+      buttons[i].addEventListener("click", function () {
+        var id = this.getAttribute("data-corpus");
+        if (!id) return;
+        var headers = {};
+        headers[CSRF] = "1";
+        this.disabled = true;
+        fetchJson("/api/corpus/" + encodeURIComponent(id), {
+          method: "DELETE",
+          headers: headers,
+        })
+          .then(function (response) {
+            if (response.ok) window.location.reload();
+          })
+          .catch(function () {});
+      });
+    }
+  }
+})();
diff --git a/cinoc/interfaces/web/templates/base.html b/cinoc/interfaces/web/templates/base.html
new file mode 100644
index 0000000000000000000000000000000000000000..232df62869f3e7d500f1e4957cc14af7afa53a3a
--- /dev/null
+++ b/cinoc/interfaces/web/templates/base.html
@@ -0,0 +1,84 @@
+<!DOCTYPE html>
+<html lang="{{ lang }}">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Cinoc — {% block title %}{{ t.reports_title }}{% endblock %}</title>
+  <link rel="stylesheet" href="/static/css/shell.css">
+</head>
+<body>
+<a class="skip-link" href="#main-content">{{ t.skip_to_content }}</a>
+{%- macro glyph(name) -%}
+<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.4"
+     stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+{%- if name == 'library' -%}
+<path d="M3 8h6l1.5 2H21v10H3z"/><path d="M3 8V6h5.5L10 8"/><path d="M7 14h10M7 17h7"/>
+{%- elif name == 'benchmark' -%}
+<circle cx="12" cy="12" r="9"/><circle cx="12" cy="12" r="1.4" fill="currentColor" stroke="none"/><path d="M12 12l4-4"/><path d="M5 12h2M17 12h2M12 5v2"/>
+{%- elif name == 'reports' -%}
+<path d="M6 3h9l4 4v14H6z"/><path d="M15 3v4h4"/><path d="M9 12h7M9 15h7M9 18h5"/>
+{%- elif name == 'history' -%}
+<circle cx="12" cy="12" r="9"/><path d="M12 7v5l3.5 2"/>
+{%- elif name == 'engines' -%}
+<circle cx="12" cy="12" r="9"/><circle cx="12" cy="12" r="5"/><circle cx="12" cy="12" r="1.5" fill="currentColor" stroke="none"/>
+{%- endif -%}
+</svg>
+{%- endmacro -%}
+<div class="app">
+  <aside class="rail">
+    <div class="wordmark-card">
+      <div class="wordmark"><span class="mark">C</span><span>Cin<span class="wm-o">o</span>c</span></div>
+      <div class="wordmark-sub">{{ t.wordmark_sub }}</div>
+    </div>
+
+    <div class="rail-nav-window">
+      <nav class="rail-nav" aria-label="Navigation">
+        {% for item in primary_nav %}
+        <a class="nav-item{% if item.state == 'active' %} active{% endif %}"
+           href="{{ item.href }}"{% if item.state == 'active' %} aria-current="page"{% endif %}>
+          <span class="nav-glyph">{{ glyph(item.id) }}</span>
+          <span class="nav-label">{{ item.label }}</span>
+          <span class="nav-meta">{{ item.meta }}</span>
+        </a>
+        {% endfor %}
+      </nav>
+    </div>
+
+    <div class="rail-system">
+      <div class="sys-card">
+        <div class="sys-card-title"><span>{{ t.sys_details }}</span><span class="dot on"></span></div>
+        <div class="sys-row"><span class="k">{{ t.sys_version }}</span><span class="v">{{ version }}</span></div>
+        <div class="sys-row"><span class="k">{{ t.sys_mode }}</span><span class="v">{{ t.sys_mode_value }}</span></div>
+        <div class="sys-row"><span class="k">{{ t.sys_active_job }}</span><span class="v">{{ t.sys_idle }}</span></div>
+      </div>
+      <div class="sys-card">
+        <div class="sys-card-title"><span>{{ t.sys_pipeline }}</span><span class="dot on"></span></div>
+        <div class="sys-row"><span class="k">{{ t.sys_pipeline_ready }}</span><span class="v">{{ system_pipeline.ready }} / {{ system_pipeline.total }}</span></div>
+        {% if system_pipeline.labels %}
+        <div class="pipeline-tags">
+          {% for label in system_pipeline.labels %}<span class="preview-chip">{{ label }}</span>{% endfor %}
+        </div>
+        {% endif %}
+      </div>
+      <a class="system-trigger" href="/engines?lang={{ lang }}">
+        <span>{{ t.sys_open }}</span>
+        <span class="system-trigger-arrow" aria-hidden="true">→</span>
+      </a>
+    </div>
+
+    <div class="rail-foot">
+      <span class="foot-meta">{{ t.lang_label }}</span>
+      <span class="lang-toggle">
+        <a href="{{ view_path }}?lang=fr" class="{{ 'on' if lang == 'fr' else '' }}">FR</a>
+        <a href="{{ view_path }}?lang=en" class="{{ 'on' if lang == 'en' else '' }}">EN</a>
+      </span>
+    </div>
+  </aside>
+
+  <main class="main" id="main-content" tabindex="-1">
+    {% block main %}{% endblock %}
+  </main>
+</div>
+{% block body_end %}{% endblock %}
+</body>
+</html>
diff --git a/cinoc/interfaces/web/templates/benchmark.html b/cinoc/interfaces/web/templates/benchmark.html
new file mode 100644
index 0000000000000000000000000000000000000000..801eb7d6ca5f045c72de0c3d7e0a84a42ea69de2
--- /dev/null
+++ b/cinoc/interfaces/web/templates/benchmark.html
@@ -0,0 +1,340 @@
+{% extends "base.html" %}
+{% block title %}{{ t.bench_title }}{% endblock %}
+{% block main %}
+<section class="view-hero">
+  <div class="view-hero-title">
+    <div class="view-hero-eyebrow">{{ t.bench_eyebrow }}</div>
+    <div class="view-hero-name">{{ t.bench_title }}</div>
+    <div class="view-hero-desc">{{ t.bench_desc }}</div>
+  </div>
+  <div class="view-hero-stats">
+    <div class="hero-stat"><div class="v">{{ corpora|length }}</div><div class="k">{{ t.bench_corpus }}</div></div>
+    <div class="hero-stat"><div class="v">{{ profiles|length }}</div><div class="k">{{ t.bench_options }}</div></div>
+  </div>
+</section>
+
+<section class="sec">
+  <div class="sec-head">
+    <div class="sec-copy">
+      <div class="sec-title">{{ t.bench_corpus }}</div>
+      <div class="sec-sub">{{ t.bench_corpus_select_hint }}</div>
+    </div>
+  </div>
+  <div class="sec-body">
+    <div class="panel corpus-select-card">
+      <div class="stack-head">
+        <div class="stack-title">{{ t.bench_corpus_selected }}</div>
+        <div class="stack-sub">{{ t.bench_corpus_select_hint }}</div>
+      </div>
+      <label class="label" for="corpus-select">{{ t.bench_corpus }}</label>
+      <div class="corpus-select-row">
+        <select id="corpus-select" class="select">
+          <option value="">{{ t.bench_corpus_none }}</option>
+          {% for c in corpora %}
+          <option value="{{ c.id }}">{{ c.name }} · {{ c.n_documents }} {{ t.library_doc_preview }}</option>
+          {% endfor %}
+        </select>
+        <a class="btn btn-sm" href="/library?lang={{ lang }}#corpora">{{ t.bench_corpus_prepare }}</a>
+      </div>
+    </div>
+  </div>
+</section>
+
+<section class="sec">
+  <div class="sec-head">
+    <div class="sec-copy">
+      <div class="sec-title">{{ t.bench_competitors }}</div>
+      <div class="sec-sub">{{ t.bench_queue_hint }}</div>
+    </div>
+  </div>
+  <div class="sec-body">
+    <div class="panel composer-shell">
+      <div class="tabs mode-tabs" role="tablist" aria-label="{{ t.bench_mode }}">
+        <button class="on" type="button" role="tab" aria-selected="true"
+                data-mode="ocr_only">{{ t.bench_mode_ocr }}</button>
+        <button type="button" role="tab" aria-selected="false"
+                data-mode="text_only">{{ t.bench_mode_text }}</button>
+        <button type="button" role="tab" aria-selected="false"
+                data-mode="text_and_image">{{ t.bench_mode_image }}</button>
+        <button type="button" role="tab" aria-selected="false"
+                data-mode="zero_shot">{{ t.bench_mode_vlm }}</button>
+        <button type="button" role="tab" aria-selected="false"
+                data-mode="hybrid">{{ t.bench_mode_hybrid }}</button>
+      </div>
+
+      <div class="composer-draft">
+        <label class="comp-field" data-show="ocr_only text_only text_and_image">
+          <span class="comp-label">{{ t.bench_ocr_engine }}</span>
+          <select id="draft-ocr" class="select">
+            {% for e in catalog.ocr %}
+            <option value="{{ e.kind }}"{% if not e.available %} disabled{% endif %}>
+              {{ e.label }}{% if not e.available %} — {{ t.engine_unavailable }}{% endif %}
+            </option>
+            {% endfor %}
+          </select>
+        </label>
+
+        <label class="comp-field" data-show="hybrid">
+          <span class="comp-label">{{ t.bench_segmenter }}</span>
+          <select id="draft-segmenter" class="select">
+            {% for s in segmenters %}
+            <option value="{{ s.kind }}"{% if not s.available %} disabled{% endif %}>
+              {{ s.label }}{% if not s.available %} — {{ t.engine_unavailable }}{% endif %}
+            </option>
+            {% endfor %}
+          </select>
+          <span class="dropzone-meta">{{ t.bench_segmenter_hint }}</span>
+        </label>
+
+        <label class="comp-field" data-show="hybrid" id="draft-seg-endpoint-field" hidden>
+          <span class="comp-label">{{ t.seg_run_endpoint }}</span>
+          <input id="draft-seg-endpoint" class="input" type="url"
+                 placeholder="{{ t.seg_run_endpoint_ph }}">
+        </label>
+        <label class="comp-field" data-show="hybrid" id="draft-seg-token-field" hidden>
+          <span class="comp-label">{{ t.seg_run_token }}</span>
+          <input id="draft-seg-token" class="input" type="password">
+        </label>
+
+        <label class="comp-field" data-show="hybrid">
+          <span class="comp-label">{{ t.bench_recognizer }}</span>
+          <select id="draft-recognizer" class="select">
+            {% for r in recognizers %}
+            <option value="{{ r.kind }}" data-vlm="{{ '1' if r.vlm else '' }}"{% if not r.available %} disabled{% endif %}>
+              {{ r.label }}{% if r.vlm %} — {{ t.hyb_run_vlm }}{% endif %}{% if not r.available %} — {{ t.engine_unavailable }}{% endif %}
+            </option>
+            {% endfor %}
+          </select>
+          <span class="dropzone-meta">{{ t.bench_recognizer_hint }}</span>
+        </label>
+
+        <div class="comp-field" data-show="hybrid">
+          <span class="comp-label">{{ t.bench_seg_preview }}</span>
+          <div class="seg-preview-actions">
+            <button id="seg-preview-btn" class="btn btn-sm" type="button"
+                    data-no-corpus="{{ t.bench_seg_preview_no_corpus }}">{{ t.bench_seg_preview_btn }}</button>
+            <span id="seg-preview-status" class="run-status" role="status"
+                  data-running="{{ t.seg_run_running }}"></span>
+          </div>
+          <div id="seg-preview" class="seg-canvas" aria-live="polite"></div>
+          <span class="dropzone-meta">{{ t.bench_seg_preview_hint }}</span>
+        </div>
+
+        <label class="comp-field" data-show="text_only">
+          <span class="comp-label">{{ t.bench_llm }}</span>
+          <select id="draft-llm" class="select">
+            {% for e in catalog.llm %}
+            <option value="{{ e.kind }}"{% if not e.available %} disabled{% endif %}>
+              {{ e.label }}{% if not e.available %} — {{ t.engine_unavailable }}{% endif %}
+            </option>
+            {% endfor %}
+          </select>
+        </label>
+
+        <label class="comp-field" data-show="text_and_image zero_shot">
+          <span class="comp-label">{{ t.bench_vlm }}</span>
+          <select id="draft-vlm" class="select">
+            {% for e in catalog.vlm %}
+            <option value="{{ e.kind }}"{% if not e.available %} disabled{% endif %}>
+              {{ e.label }}{% if not e.available %} — {{ t.engine_unavailable }}{% endif %}
+            </option>
+            {% endfor %}
+          </select>
+        </label>
+
+        <label class="comp-field"
+               data-show="ocr_only text_only text_and_image zero_shot hybrid">
+          <span class="comp-label">{{ t.bench_model }}</span>
+          <input id="draft-model" class="input" type="text"
+                 placeholder="{{ t.bench_model_ph }}">
+          <span id="model-hint" class="dropzone-meta"></span>
+        </label>
+
+        <label class="comp-field comp-field-prompt"
+               data-show="text_only text_and_image zero_shot hybrid">
+          <span class="comp-label">{{ t.bench_prompt }}</span>
+          {% if curated_prompts %}
+          <select id="draft-prompt-curated" class="select">
+            <option value="">{{ t.bench_prompt_curated_none }}</option>
+            {% for name in curated_prompts %}
+            <option value="{{ name }}">{{ name }}</option>
+            {% endfor %}
+          </select>
+          {% endif %}
+          <textarea id="draft-prompt" class="input comp-prompt" rows="3"
+                    placeholder="{{ t.bench_prompt_ph }}"></textarea>
+          <span class="dropzone-meta">{{ t.bench_prompt_hint }}</span>
+        </label>
+
+        <label class="comp-field comp-field-ner"
+               data-show="ocr_only text_only text_and_image zero_shot hybrid">
+          <span class="comp-label">
+            <input id="draft-ner" type="checkbox"
+                   {% if not ner or not ner.available %}disabled{% endif %}>
+            {{ t.bench_ner }}{% if ner and not ner.available %} — {{ t.engine_unavailable }}{% endif %}
+          </span>
+          <input id="draft-ner-model" class="input" type="text"
+                 placeholder="{{ t.bench_ner_model_ph }}"
+                 {% if not ner or not ner.available %}disabled{% endif %}>
+          <span class="dropzone-meta">{{ t.bench_ner_hint }}</span>
+        </label>
+
+        <label class="comp-field comp-field-alto"
+               data-show="ocr_only text_only text_and_image hybrid">
+          <span class="comp-label">
+            <input id="draft-alto" type="checkbox">
+            {{ t.bench_alto }}
+          </span>
+          <span class="dropzone-meta">{{ t.bench_alto_hint }}</span>
+        </label>
+
+        {# Suggestions canoniques openai/anthropic — peuplée par benchmark.js
+           depuis /api/models/{provider} (avec capacité vision). #}
+        <datalist id="api-model-list"></datalist>
+        {% if ollama_models %}
+        <datalist id="ollama-models">
+          {% for m in ollama_models %}<option value="{{ m }}"></option>{% endfor %}
+        </datalist>
+        {% endif %}
+        {% if mistral_models %}
+        <datalist id="mistral-models">
+          {% for m in mistral_models %}<option value="{{ m }}"></option>{% endfor %}
+        </datalist>
+        {% endif %}
+
+        <button id="add-competitor" class="btn btn-primary" type="button">+ {{ t.bench_add_competitor }}</button>
+      </div>
+    </div>
+
+    <div class="panel queue-panel">
+      <div class="stack-head">
+        <div class="stack-title">{{ t.bench_queue_title }}</div>
+        <div class="stack-sub">{{ t.bench_queue_hint }}</div>
+      </div>
+      <div id="queue-list" class="queue-list"
+           data-label-ocr="OCR"
+           data-label-ocr-llm="OCR → LLM"
+           data-label-ocr-vlm="OCR → VLM"
+           data-label-vlm="VLM"
+           data-label-hybrid="{{ t.bench_mode_hybrid }}"></div>
+      <p id="queue-empty" class="empty">{{ t.bench_queue_empty }}</p>
+    </div>
+  </div>
+</section>
+
+<section class="sec">
+  <div class="sec-head">
+    <div class="sec-copy">
+      <div class="sec-title">{{ t.bench_options }}</div>
+      <div class="sec-sub">{{ t.bench_normalization }}</div>
+    </div>
+  </div>
+  <div class="sec-body">
+    <div class="panel stack-panel">
+      <label class="label" for="normalization">{{ t.bench_normalization }}</label>
+      <select id="normalization" class="select">
+        <option value="">{{ t.bench_norm_none }}</option>
+        {% for p in profiles %}
+        <option value="{{ p.name }}">{{ p.name }} — {{ p.description }}</option>
+        {% endfor %}
+      </select>
+    </div>
+    <div class="panel stack-panel">
+      <label class="label" for="norm-sample">{{ t.bench_norm_preview }}</label>
+      <textarea id="norm-sample" class="input" rows="2"
+                placeholder="{{ t.bench_norm_sample_ph }}"></textarea>
+      <details class="norm-custom">
+        <summary class="dropzone-meta">{{ t.bench_norm_custom }}</summary>
+        <textarea id="norm-config" class="input" rows="3"
+                  placeholder="{{ t.bench_norm_config_ph }}"></textarea>
+      </details>
+      <button id="norm-preview-btn" class="btn" type="button">{{ t.bench_norm_preview_btn }}</button>
+      <pre id="norm-result" class="norm-result" aria-live="polite"></pre>
+    </div>
+    <div class="panel stack-panel">
+      <label class="label" for="char-exclude">{{ t.bench_char_exclude }}</label>
+      <input id="char-exclude" class="input" type="text"
+             placeholder="{{ t.bench_char_exclude_ph }}">
+      <span class="dropzone-meta">{{ t.bench_char_exclude_hint }}</span>
+    </div>
+    <div class="panel stack-panel">
+      <label class="label" for="metric-profile">{{ t.bench_metric_profile }}</label>
+      <select id="metric-profile" class="select">
+        {% for mp in metric_profiles %}
+        <option value="{{ mp.name }}"{% if mp.name == 'standard' %} selected{% endif %}>
+          {{ mp.name }} — {{ mp.metrics|join(' · ') }}
+        </option>
+        {% endfor %}
+      </select>
+      <span class="dropzone-meta">{{ t.bench_metric_profile_hint }}</span>
+    </div>
+    <div class="panel stack-panel">
+      <label class="label">{{ t.bench_config_io }}</label>
+      <div class="config-io">
+        <button id="config-export" class="btn btn-sm" type="button">{{ t.bench_config_export }}</button>
+        <label class="btn btn-sm" for="config-import">{{ t.bench_config_import }}</label>
+        <input id="config-import" type="file" accept="application/json,.json" hidden>
+      </div>
+      <span id="config-feedback" class="dropzone-meta" aria-live="polite"
+            data-loaded="{{ t.bench_config_loaded }}"
+            data-invalid="{{ t.bench_config_invalid }}"></span>
+      <span class="dropzone-meta">{{ t.bench_config_hint }}</span>
+    </div>
+  </div>
+</section>
+
+<section class="sec">
+  <div class="sec-head">
+    <div class="sec-copy">
+      <div class="sec-title">{{ t.bench_run }}</div>
+      <div class="sec-sub">{{ t.bench_execute_desc }}</div>
+    </div>
+  </div>
+  <div class="sec-body">
+    <div class="panel run-panel">
+      <div class="run-line">
+        <button id="launch" class="btn btn-primary"
+                data-launching="{{ t.bench_launching }}">{{ t.bench_run }}</button>
+        <span class="label">{{ t.bench_status }}</span>
+        <span id="run-status" class="run-status">{{ t.bench_idle }}</span>
+      </div>
+
+      <div id="run-progress" class="run-progress" hidden role="status" aria-live="polite">
+        <div id="run-progress-rail" class="progress" role="progressbar"
+             aria-valuemin="0" aria-valuemax="100" aria-valuenow="0"
+             aria-label="{{ t.bench_progress_label }}">
+          <div id="run-progress-bar" class="progress-bar"></div>
+        </div>
+        <span id="run-progress-text" class="run-progress-text mono"></span>
+      </div>
+
+      <div id="run-result" class="run-result"
+           data-open="{{ t.open_report_full }}"
+           data-neterror="{{ t.bench_net_error }}"
+           data-error-403="{{ t.bench_error_403 }}"
+           data-error-404="{{ t.bench_error_404 }}"
+           data-error-409="{{ t.bench_error_409 }}"
+           data-error-422="{{ t.bench_error_422 }}"
+           data-error-fallback="{{ t.bench_error_fallback }}"></div>
+
+      <details class="run-log-shell" id="run-log-shell" hidden>
+        <summary>{{ t.bench_log }}</summary>
+        <pre id="run-log" class="run-log" aria-live="polite"></pre>
+      </details>
+    </div>
+  </div>
+</section>
+
+<template id="queue-row-tpl">
+  <article class="queue-row">
+    <div class="queue-id mono"></div>
+    <div class="queue-main">
+      <div class="queue-label"></div>
+      <div class="queue-meta"></div>
+    </div>
+    <button class="c-del queue-remove" type="button"
+            title="{{ t.bench_remove }}" aria-label="{{ t.bench_remove }}">{{ t.bench_remove }}</button>
+  </article>
+</template>
+{% endblock %}
+{% block body_end %}<script src="/static/js/benchmark.js"></script>{% endblock %}
diff --git a/cinoc/interfaces/web/templates/engines.html b/cinoc/interfaces/web/templates/engines.html
new file mode 100644
index 0000000000000000000000000000000000000000..68c80db03f624376d1706cbc3dbf42c9929134a2
--- /dev/null
+++ b/cinoc/interfaces/web/templates/engines.html
@@ -0,0 +1,51 @@
+{% extends "base.html" %}
+{% block title %}{{ t.engines_title }}{% endblock %}
+{% block main %}
+<section class="view-hero">
+  <div class="view-hero-title">
+    <div class="view-hero-eyebrow">{{ t.engines_eyebrow }}</div>
+    <div class="view-hero-name">{{ t.engines_title }}</div>
+    <div class="view-hero-desc">{{ t.engines_desc }}</div>
+  </div>
+  <div class="view-hero-stats">
+    <div class="hero-stat">
+      <div class="v">{{ n_ready }}<span class="stat-muted">/{{ n_engines }}</span></div>
+      <div class="k">{{ t.stat_ready }}</div>
+    </div>
+  </div>
+</section>
+
+<section class="sec">
+  <div class="sec-head">
+    <div class="sec-copy">
+      <div class="sec-title">{{ t.engines_title }}</div>
+      <div class="sec-sub">{{ t.engines_desc }}</div>
+    </div>
+  </div>
+  <div class="sec-body">
+    <div class="table-wrap">
+      <table class="engines">
+        <thead>
+          <tr>
+            <th>{{ t.engines_col_engine }}</th>
+            <th>{{ t.engines_col_status }}</th>
+            <th>{{ t.engines_col_detail }}</th>
+          </tr>
+        </thead>
+        <tbody>
+          {% for e in engines %}
+          <tr>
+            <td class="eng-name">{{ e.label }} <span class="eng-kind">{{ e.kind }}</span></td>
+            <td>
+              <span class="dot {{ 'on' if e.available else 'off' }}"></span>
+              {{ t.engine_available if e.available else t.engine_unavailable }}
+            </td>
+            <td class="eng-detail">{{ e.detail }}</td>
+          </tr>
+          {% endfor %}
+        </tbody>
+      </table>
+    </div>
+  </div>
+</section>
+{% endblock %}
diff --git a/cinoc/interfaces/web/templates/history.html b/cinoc/interfaces/web/templates/history.html
new file mode 100644
index 0000000000000000000000000000000000000000..7aa7d59c0586aa7ebd0f7babf03476beb3a28513
--- /dev/null
+++ b/cinoc/interfaces/web/templates/history.html
@@ -0,0 +1,138 @@
+{% extends "base.html" %}
+{% block title %}{{ t.history_title }}{% endblock %}
+{% block main %}
+<section class="view-hero">
+  <div class="view-hero-title">
+    <div class="view-hero-eyebrow">{{ t.history_eyebrow }}</div>
+    <div class="view-hero-name">{{ t.history_title }}</div>
+    <div class="view-hero-desc">{{ t.history_desc }}</div>
+  </div>
+  <div class="view-hero-stats">
+    <div class="hero-stat">
+      <div class="v">{{ records|length }}</div>
+      <div class="k">{{ t.history_stat_runs }}</div>
+    </div>
+  </div>
+</section>
+
+{% if trends %}
+<section class="sec">
+  <div class="sec-head">
+    <div class="sec-copy">
+      <div class="sec-title">{{ t.history_trends_title }}</div>
+      <div class="sec-sub">{{ t.history_trends_desc }}</div>
+    </div>
+  </div>
+  <div class="sec-body">
+    <div class="trend-grid">
+      {% for tr in trends %}
+      <div class="panel trend-card">
+        <div class="trend-head">
+          <span class="t-pipe">{{ tr.pipeline }}</span>
+          <span class="badge">{{ tr.view }}</span>
+        </div>
+        <div class="trend-spark">{{ tr.svg|safe }}</div>
+        <div class="trend-meta">
+          {% if tr.latest is not none %}
+          <span class="mono">CER {{ "%.4f"|format(tr.latest) }}</span>
+          {% endif %}
+          <span class="mono">{{ tr.n }}×</span>
+          {% if tr.slope is not none %}
+          <span class="mono">{{ t.history_slope }} {{ "%+.4f"|format(tr.slope) }}
+            · R² {{ "%.2f"|format(tr.r_squared) }}</span>
+          {% endif %}
+        </div>
+        {% if tr.rupture %}
+        <div class="trend-meta">
+          <span class="mono">{{ t.history_rupture }} {{ tr.rupture.run_id }}
+            · Δ {{ "%+.4f"|format(tr.rupture.delta) }}
+            (p={{ "%.3f"|format(tr.rupture.p_value) }})</span>
+        </div>
+        {% endif %}
+      </div>
+      {% endfor %}
+    </div>
+  </div>
+</section>
+{% endif %}
+
+<section class="sec">
+  <div class="sec-head">
+    <div class="sec-copy">
+      <div class="sec-title">{{ t.history_regressions_title }}</div>
+      <div class="sec-sub">{{ t.history_regressions_desc }}</div>
+    </div>
+  </div>
+  <div class="sec-body">
+    {% if regressions %}
+    <div class="table-wrap">
+      <table class="data">
+        <thead>
+          <tr>
+            <th>{{ t.history_col_pipeline }}</th>
+            <th>{{ t.history_col_view }}</th>
+            <th>{{ t.history_col_metric }}</th>
+            <th>{{ t.history_col_change }}</th>
+          </tr>
+        </thead>
+        <tbody>
+          {% for r in regressions %}
+          <tr>
+            <td>{{ r.pipeline }}</td>
+            <td>{{ r.view }}</td>
+            <td>{{ r.metric }}</td>
+            <td>
+              <span class="dot off"></span>
+              {{ "%.4f"|format(r.previous) }} → {{ "%.4f"|format(r.latest) }}
+              (+{{ "%.4f"|format(r.delta) }})
+            </td>
+          </tr>
+          {% endfor %}
+        </tbody>
+      </table>
+    </div>
+    {% else %}
+    <p class="empty">{{ t.history_no_regressions }}</p>
+    {% endif %}
+  </div>
+</section>
+
+<section class="sec">
+  <div class="sec-head">
+    <div class="sec-copy">
+      <div class="sec-title">{{ t.history_log_title }}</div>
+      <div class="sec-sub">{{ t.history_log_desc }}</div>
+    </div>
+  </div>
+  <div class="sec-body">
+    {% if records %}
+    <div class="table-wrap">
+      <table class="data">
+        <thead>
+          <tr>
+            <th>{{ t.history_col_run }}</th>
+            <th>{{ t.history_col_pipeline }}</th>
+            <th>{{ t.history_col_view }}</th>
+            <th>{{ t.history_col_metric }}</th>
+            <th>{{ t.history_col_value }}</th>
+          </tr>
+        </thead>
+        <tbody>
+          {% for r in records %}
+          <tr>
+            <td class="mono">{{ r.run_id }}</td>
+            <td>{{ r.pipeline }}</td>
+            <td>{{ r.view }}</td>
+            <td>{{ r.metric }}</td>
+            <td class="mono">{{ "%.4f"|format(r.value) }}</td>
+          </tr>
+          {% endfor %}
+        </tbody>
+      </table>
+    </div>
+    {% else %}
+    <p class="empty">{{ t.history_empty }}</p>
+    {% endif %}
+  </div>
+</section>
+{% endblock %}
diff --git a/cinoc/interfaces/web/templates/home.html b/cinoc/interfaces/web/templates/home.html
new file mode 100644
index 0000000000000000000000000000000000000000..5b39dcf714776328e3f049f4beccb9cd206cec6f
--- /dev/null
+++ b/cinoc/interfaces/web/templates/home.html
@@ -0,0 +1,48 @@
+{% extends "base.html" %}
+{% block title %}{{ t.reports_title }}{% endblock %}
+{% block main %}
+<section class="view-hero">
+  <div class="view-hero-title">
+    <div class="view-hero-eyebrow">{{ t.hero_eyebrow }}</div>
+    <div class="view-hero-name">{{ t.reports_title }}</div>
+    <div class="view-hero-desc">{{ t.hero_desc }}</div>
+  </div>
+  <div class="view-hero-stats">
+    <div class="hero-stat">
+      <div class="v">{{ n_reports }}</div>
+      <div class="k">{{ t.stat_reports }}</div>
+    </div>
+  </div>
+</section>
+
+<section class="sec">
+  <div class="sec-head">
+    <div class="sec-copy">
+      <div class="sec-title">{{ t.reports_title }}</div>
+      <div class="sec-sub">{{ t.reports_desc }}</div>
+    </div>
+  </div>
+  <div class="sec-body">
+    {% if reports %}
+    <div class="report-list">
+      {% for r in reports %}
+      <div class="panel report-row">
+        <a class="r-main" href="{{ r.href }}">
+          <span class="r-name">{{ r.name }}</span>
+          <span class="r-open">{{ t.open_report }} →</span>
+        </a>
+        <a class="r-zip" href="{{ r.zip_href }}" download
+           title="{{ t.download_zip }}">⬇ {{ t.download_zip }}</a>
+        {% if r.alto_href %}
+        <a class="r-zip" href="{{ r.alto_href }}" download
+           title="{{ t.download_alto }}">⬇ {{ t.download_alto }}</a>
+        {% endif %}
+      </div>
+      {% endfor %}
+    </div>
+    {% else %}
+    <p class="empty">{{ t.reports_empty }}</p>
+    {% endif %}
+  </div>
+</section>
+{% endblock %}
diff --git a/cinoc/interfaces/web/templates/library.html b/cinoc/interfaces/web/templates/library.html
new file mode 100644
index 0000000000000000000000000000000000000000..b7f350d63c7273daef5708a6cd615e5c8a563566
--- /dev/null
+++ b/cinoc/interfaces/web/templates/library.html
@@ -0,0 +1,378 @@
+{% extends "base.html" %}
+{% block title %}{{ t.library_title }}{% endblock %}
+{% macro search_form(hint) -%}
+<form class="search library-search" method="get" action="/library">
+  <input type="hidden" name="lang" value="{{ lang }}">
+  <input class="input search-input" type="search" name="q" value="{{ query }}"
+         placeholder="{{ hint }}" aria-label="{{ hint }}">
+  <button class="btn btn-primary" type="submit">{{ t.library_search_button }}</button>
+</form>
+{%- endmacro %}
+{% block main %}
+<section class="view-hero">
+  <div class="view-hero-title">
+    <div class="view-hero-eyebrow">{{ t.library_eyebrow }}</div>
+    <div class="view-hero-name">{{ t.library_title }}</div>
+    <div class="view-hero-desc">{{ t.library_desc }}</div>
+  </div>
+  <div class="view-hero-stats">
+    <div class="hero-stat"><div class="v">{{ n_corpora }}</div><div class="k">{{ t.library_stat_local }}</div></div>
+    <div class="hero-stat"><div class="v">{{ n_htr }}</div><div class="k">HTR-United</div></div>
+    <div class="hero-stat"><div class="v">{{ n_hf }}</div><div class="k">HuggingFace</div></div>
+    <div class="hero-stat"><div class="v">{{ n_pages }}</div><div class="k">{{ t.library_stat_pages }}</div></div>
+  </div>
+</section>
+
+<div class="tabs library-tabs" role="tablist" aria-label="{{ t.library_title }}">
+  <a class="on" href="#corpora" role="tab" aria-selected="true"
+     data-library-tab="corpora">{{ t.library_corpora_title }}</a>
+  <a href="#discover" role="tab" aria-selected="false"
+     data-library-tab="discover">{{ t.library_discover }}</a>
+</div>
+
+<section class="library-panel" data-library-panel="corpora">
+  <section class="sec">
+    <div class="sec-head">
+      <div class="sec-copy">
+        <div class="sec-title">{{ t.library_local_title }}</div>
+        <div class="sec-sub">{{ t.library_corpora_desc }}</div>
+      </div>
+      <div class="sec-aside">{{ n_corpora }} {{ t.library_stat_local }} · {{ n_pages }} {{ t.library_stat_pages }}</div>
+    </div>
+
+    <div class="sec-body">
+      {% if corpora %}
+      <div class="library-local-grid">
+        <div class="panel upload-panel">
+          <div class="stack-head">
+            <div class="stack-title">{{ t.library_corpora_cta }}</div>
+            <div class="stack-sub">{{ t.library_add_desc }}</div>
+          </div>
+          <label class="dropzone dropzone-large" id="dropzone" for="corpus-file">
+            <input type="file" id="corpus-file" accept=".zip,application/zip">
+            <span class="dropzone-hint">{{ t.library_drop_hint }}</span>
+            <span class="dropzone-meta">{{ t.library_zip_meta }}</span>
+          </label>
+          <span id="corpus-status" class="run-status"></span>
+        </div>
+
+        <div class="corpus-stack">
+          <div class="stack-head corpus-stack-head">
+            <div class="stack-title">{{ t.library_corpora_manage }}</div>
+            <div class="stack-sub">{{ t.library_corpora_desc }}</div>
+          </div>
+          {% if corpora %}
+          {% for c in corpora %}
+          <article class="panel corpus-card">
+            <div class="c-top">
+              <div>
+                <div class="c-name">{{ c.name }}</div>
+                <div class="c-meta">
+                  <span>ID · {{ c.id[:10] }}…</span>
+                  <span>{{ c.n_documents }} {{ t.library_doc_preview }}</span>
+                  <span>{{ c.n_ground_truth }} {{ t.library_gt_preview }}</span>
+                </div>
+              </div>
+              <span class="badge">{{ t.library_ready }}</span>
+            </div>
+            <div class="corpus-detail-grid">
+              <div class="corpus-detail">
+                <span class="label">{{ t.library_doc_preview }}</span>
+                <div class="corpus-preview">
+                  {% for doc_id in c.preview_ids %}
+                  <span class="preview-chip">{{ doc_id }}</span>
+                  {% endfor %}
+                  {% if c.n_documents > c.preview_ids|length %}
+                  <span class="preview-chip">+{{ c.n_documents - (c.preview_ids|length) }}</span>
+                  {% endif %}
+                </div>
+              </div>
+              {% if c.source or c.language %}
+              <div class="corpus-detail">
+                {% if c.source %}
+                <div class="detail-line"><span class="label">{{ t.library_source_label }}</span><span>{{ c.source }}</span></div>
+                {% endif %}
+                {% if c.language %}
+                <div class="detail-line"><span class="label">{{ t.library_language_label }}</span><span>{{ c.language }}</span></div>
+                {% endif %}
+              </div>
+              {% endif %}
+            </div>
+            <div class="c-actions">
+              <a class="btn btn-sm btn-primary"
+                 href="/benchmark?lang={{ lang }}&corpus={{ c.id }}">{{ t.library_use }}</a>
+              <button class="c-del" data-corpus="{{ c.id }}"
+                      title="{{ t.library_delete }}">{{ t.library_delete }}</button>
+            </div>
+          </article>
+          {% endfor %}
+          {% endif %}
+        </div>
+      </div>
+      {% else %}
+      <div class="panel upload-panel upload-panel-empty">
+        <div class="stack-head">
+          <div class="stack-title">{{ t.library_corpora_cta }}</div>
+          <div class="stack-sub">{{ t.library_add_desc }}</div>
+        </div>
+        <label class="dropzone dropzone-large" id="dropzone" for="corpus-file">
+          <input type="file" id="corpus-file" accept=".zip,application/zip">
+          <span class="dropzone-hint">{{ t.library_drop_hint }}</span>
+          <span class="dropzone-meta">{{ t.library_zip_meta }}</span>
+        </label>
+        <span id="corpus-status" class="run-status"></span>
+        <div class="empty-panel">{{ t.library_corpora_empty }}</div>
+      </div>
+      {% endif %}
+    </div>
+  </section>
+</section>
+
+<section class="library-panel" data-library-panel="discover" hidden>
+  <section class="sec">
+    <div class="sec-head">
+      <div class="sec-copy">
+        <div class="sec-title">{{ t.library_discover }}</div>
+        <div class="sec-sub">{{ t.library_discover_desc }}</div>
+      </div>
+    </div>
+
+    <div class="sec-body">
+      <div class="source-switch" role="tablist" aria-label="{{ t.library_remote_title }}">
+        <a class="source-chip on" href="#discover:htr-united" role="tab" aria-selected="true"
+           data-source-tab="htr-united"><span class="src-glyph">HU</span><span>{{ t.library_source_htr }}</span><span class="src-count">{{ n_htr }}</span></a>
+        <a class="source-chip" href="#discover:huggingface" role="tab" aria-selected="false"
+           data-source-tab="huggingface"><span class="src-glyph">HF</span><span>{{ t.library_source_hf }}</span><span class="src-count">{{ n_hf }}</span></a>
+        {% if not public_mode %}
+        <a class="source-chip" href="#discover:curated" role="tab" aria-selected="false"
+           data-source-tab="curated"><span class="src-glyph">Ci</span><span>{{ t.library_source_curated }}</span><span class="src-count">HF</span></a>
+        <a class="source-chip" href="#discover:iiif" role="tab" aria-selected="false"
+           data-source-tab="iiif"><span class="src-glyph">IIIF</span><span>{{ t.library_source_iiif }}</span><span class="src-count">{{ t.library_manifest }}</span></a>
+        <a class="source-chip" href="#discover:gallica" role="tab" aria-selected="false"
+           data-source-tab="gallica"><span class="src-glyph">BnF</span><span>{{ t.library_source_gallica }}</span><span class="src-count">ARK</span></a>
+        <a class="source-chip" href="#discover:escriptorium" role="tab" aria-selected="false"
+           data-source-tab="escriptorium"><span class="src-glyph">eS</span><span>{{ t.library_source_escriptorium }}</span><span class="src-count">API</span></a>
+        {% endif %}
+      </div>
+
+      <div class="source-panel" data-source-panel="htr-united">
+        <div class="panel source-shell">
+          <div class="source-headline">
+            <div>
+              <div class="stack-title">{{ t.library_source_htr }}</div>
+              <div class="stack-sub">{{ t.library_search_hint_htr }}</div>
+            </div>
+            {% if htr_is_demo %}<span class="badge">{{ t.library_demo_badge }}</span>{% endif %}
+          </div>
+          {{ search_form(t.library_search_hint_htr) }}
+        </div>
+        {% if htr_entries %}
+        <div class="catalog-card-grid">
+          {% for e in htr_entries %}
+          <article class="panel result-card">
+            <div class="result-card-head">
+              <div>
+                <div class="result-card-title">{{ e.title }}</div>
+                <div class="result-card-meta">{{ e.id }}</div>
+              </div>
+              <span class="badge">{{ t.library_catalogue }}</span>
+            </div>
+            <p class="result-card-copy">{{ e.description or "—" }}</p>
+            <div class="result-card-tags">
+              {% for lg in e.languages %}
+              <span class="preview-chip">{{ lg }}</span>
+              {% endfor %}
+            </div>
+            <div class="result-card-actions">
+              <a class="btn btn-sm" href="{{ e.url }}" rel="noopener noreferrer" target="_blank">{{ t.library_open_source }}</a>
+            </div>
+          </article>
+          {% endfor %}
+        </div>
+        {% else %}
+        <p class="empty">{{ t.library_empty }}</p>
+        {% endif %}
+      </div>
+
+      <div class="source-panel" data-source-panel="huggingface" hidden>
+        <div class="panel source-shell">
+          <div class="source-headline">
+            <div>
+              <div class="stack-title">{{ t.library_source_hf }}</div>
+              <div class="stack-sub">{{ t.library_search_hint_hf }}</div>
+            </div>
+          </div>
+          {{ search_form(t.library_search_hint_hf) }}
+        </div>
+        {% if hf_datasets %}
+        <div class="catalog-card-grid">
+          {% for d in hf_datasets %}
+          <article class="panel result-card">
+            <div class="result-card-head">
+              <div>
+                <div class="result-card-title">{{ d.title or d.dataset_id }}</div>
+                <div class="result-card-meta mono">{{ d.dataset_id }}</div>
+              </div>
+              <span class="badge">{{ d.downloads }} ↓</span>
+            </div>
+            <p class="result-card-copy">{{ d.description or d.dataset_id }}</p>
+            <div class="result-card-tags">
+              {% for lg in d.languages %}
+              <span class="preview-chip">{{ lg }}</span>
+              {% endfor %}
+              <span class="preview-chip">{{ d.source }}</span>
+            </div>
+            <div class="result-card-actions">
+              <a class="btn btn-sm" href="{{ d.hf_url }}" rel="noopener noreferrer" target="_blank">{{ t.library_open_source }}</a>
+              {% if not public_mode %}
+              <button class="btn btn-sm btn-primary" type="button"
+                      data-import-source="huggingface"
+                      data-dataset-id="{{ d.dataset_id }}">{{ t.library_import_source }}</button>
+              {% endif %}
+            </div>
+          </article>
+          {% endfor %}
+        </div>
+        {% else %}
+        <p class="empty">{{ t.library_empty }}</p>
+        {% endif %}
+      </div>
+
+      {% if not public_mode %}
+      <div class="source-panel" data-source-panel="curated" hidden>
+        {% if curated_datasets %}
+        <div class="source-headline">
+          <div>
+            <div class="stack-title">{{ t.library_curated_yours }}</div>
+            <div class="stack-sub">{{ t.library_curated_yours_hint }}</div>
+          </div>
+        </div>
+        <div class="catalog-card-grid">
+          {% for d in curated_datasets %}
+          <article class="panel result-card">
+            <div class="result-card-head">
+              <div>
+                <div class="result-card-title">{{ d.title }}</div>
+                <div class="result-card-meta mono">{{ d.repo_id }}{% if d.revision %} · {{ d.revision[:7] }}{% endif %}</div>
+              </div>
+              <span class="badge">{{ t.library_source_curated }}</span>
+            </div>
+            <div class="result-card-actions">
+              <a class="btn btn-sm" href="https://huggingface.co/datasets/{{ d.repo_id }}"
+                 rel="noopener noreferrer" target="_blank">{{ t.library_open_source }}</a>
+              {% if not public_mode %}
+              <button class="btn btn-sm btn-primary" type="button"
+                      data-import-source="curated"
+                      data-repo-id="{{ d.repo_id }}"
+                      data-revision="{{ d.revision or '' }}">{{ t.library_import_source }}</button>
+              {% endif %}
+            </div>
+          </article>
+          {% endfor %}
+        </div>
+        {% else %}
+        <p class="empty-hint">{{ t.library_curated_empty }}</p>
+        {% endif %}
+        <div class="panel import-card">
+          <div class="source-headline">
+            <div>
+              <div class="stack-title">{{ t.library_source_curated }}</div>
+              <div class="stack-sub">{{ t.imp_curated_hint }}</div>
+            </div>
+          </div>
+          <div class="import-fields" data-source="curated">
+            <input class="input input-wide" type="text" name="repo_id"
+                   placeholder="{{ t.imp_repo }}" aria-label="{{ t.imp_repo }}">
+            <input class="input" type="text" name="revision"
+                   placeholder="{{ t.imp_revision }}" aria-label="{{ t.imp_revision }}">
+          </div>
+          <div class="import-actions">
+            <input class="input" type="text" data-import-shared="name" name="name"
+                   placeholder="{{ t.imp_name }}" aria-label="{{ t.imp_name }}">
+            <button class="btn btn-primary" type="button" data-import-source="curated">{{ t.imp_btn }}</button>
+            <span class="run-status" data-import-status="curated"></span>
+          </div>
+        </div>
+      </div>
+
+      <div class="source-panel" data-source-panel="iiif" hidden>
+        <div class="panel import-card">
+          <div class="source-headline">
+            <div>
+              <div class="stack-title">{{ t.library_source_iiif }}</div>
+              <div class="stack-sub">{{ t.imp_manifest }}</div>
+            </div>
+          </div>
+          <div class="import-fields" data-source="iiif">
+            <input class="input input-wide" type="text" name="manifest_url"
+                   placeholder="{{ t.imp_manifest }}" aria-label="{{ t.imp_manifest }}">
+          </div>
+          <div class="import-actions">
+            <input class="input" type="number" data-import-shared="limit" name="limit" min="1"
+                   placeholder="{{ t.imp_limit }}" aria-label="{{ t.imp_limit }}">
+            <input class="input" type="text" data-import-shared="name" name="name"
+                   placeholder="{{ t.imp_name }}" aria-label="{{ t.imp_name }}">
+            <button class="btn btn-primary" type="button" data-import-source="iiif">{{ t.imp_btn }}</button>
+            <span class="run-status" data-import-status="iiif"></span>
+          </div>
+        </div>
+      </div>
+
+      <div class="source-panel" data-source-panel="gallica" hidden>
+        <div class="panel import-card">
+          <div class="source-headline">
+            <div>
+              <div class="stack-title">{{ t.library_source_gallica }}</div>
+              <div class="stack-sub">{{ t.imp_ark }}</div>
+            </div>
+          </div>
+          <div class="import-fields" data-source="gallica">
+            <input class="input input-wide" type="text" name="ark"
+                   placeholder="{{ t.imp_ark }}" aria-label="{{ t.imp_ark }}">
+            <label class="check"><input type="checkbox" name="include_ocr" checked>{{ t.imp_ocr }}</label>
+          </div>
+          <div class="import-actions">
+            <input class="input" type="number" data-import-shared="limit" name="limit" min="1"
+                   placeholder="{{ t.imp_limit }}" aria-label="{{ t.imp_limit }}">
+            <input class="input" type="text" data-import-shared="name" name="name"
+                   placeholder="{{ t.imp_name }}" aria-label="{{ t.imp_name }}">
+            <button class="btn btn-primary" type="button" data-import-source="gallica">{{ t.imp_btn }}</button>
+            <span class="run-status" data-import-status="gallica"></span>
+          </div>
+        </div>
+      </div>
+
+      <div class="source-panel" data-source-panel="escriptorium" hidden>
+        <div class="panel import-card">
+          <div class="source-headline">
+            <div>
+              <div class="stack-title">{{ t.library_source_escriptorium }}</div>
+              <div class="stack-sub">{{ t.imp_base }}</div>
+            </div>
+          </div>
+          <div class="import-fields" data-source="escriptorium">
+            <input class="input" type="text" name="base_url"
+                   placeholder="{{ t.imp_base }}" aria-label="{{ t.imp_base }}">
+            <input class="input" type="password" name="token"
+                   placeholder="{{ t.imp_token }}" aria-label="{{ t.imp_token }}">
+            <input class="input" type="number" name="doc_pk" min="1"
+                   placeholder="{{ t.imp_doc }}" aria-label="{{ t.imp_doc }}">
+            <input class="input" type="text" name="layer"
+                   placeholder="{{ t.imp_layer }}" aria-label="{{ t.imp_layer }}">
+          </div>
+          <div class="import-actions">
+            <input class="input" type="number" data-import-shared="limit" name="limit" min="1"
+                   placeholder="{{ t.imp_limit }}" aria-label="{{ t.imp_limit }}">
+            <input class="input" type="text" data-import-shared="name" name="name"
+                   placeholder="{{ t.imp_name }}" aria-label="{{ t.imp_name }}">
+            <button class="btn btn-primary" type="button" data-import-source="escriptorium">{{ t.imp_btn }}</button>
+            <span class="run-status" data-import-status="escriptorium"></span>
+          </div>
+        </div>
+      </div>
+      {% endif %}
+    </div>
+  </section>
+</section>
+{% endblock %}
+{% block body_end %}<script src="/static/js/corpus.js"></script>{% endblock %}
diff --git a/cinoc/pipeline/ANALYSE_COUCHE_4.md b/cinoc/pipeline/ANALYSE_COUCHE_4.md
new file mode 100644
index 0000000000000000000000000000000000000000..f582de24be4a1deef3415e444cf28409a82cfb03
--- /dev/null
+++ b/cinoc/pipeline/ANALYSE_COUCHE_4.md
@@ -0,0 +1,305 @@
+# Analyse — Couche 4 (`pipeline/`) : source Picarones → guide de portage Cinoc
+
+> **Statut** : analyse de source figée. **Aucun code Cinoc écrit.** Les verdicts
+> de portage sont marqués **« PROVISOIRE — à confirmer au build »**.
+> **Méthode** : lecture intégrale du code par 4 sous-agents en parallèle +
+> recoupement personnel des points décisifs (contrats `execute`, modèle
+> d'annulation, composition runner/executor, absence de fan-out, consommateurs).
+> **Source** : `Picarones/picarones/pipeline/` (15 fichiers, **3 454 LOC**), figée.
+> **Cible** : `Cinoc/cinoc/pipeline/` (vide aujourd'hui : `__init__.py` seul).
+> **Couches mergées non contredites** : `domain` (couche 1), `formats` (2),
+> plan `evaluation` (3). Voir §2.5 pour les frontières héritées.
+
+Le document a **deux parties** : **Partie 1 = analyse de la SOURCE (durable)** ;
+**Partie 2 = idée de réorganisation cible (périssable, à confirmer à la tranche)**.
+**Partie 3 = risques de transfert & dettes + détection.**
+
+---
+
+# PARTIE 1 — SOURCE Picarones (savoir durable)
+
+## 1.1 Inventaire exact (15 fichiers, 3 454 LOC)
+
+| # | Fichier | LOC | Famille |
+|---|---------|----:|---------|
+| 1 | `runner.py` | 630 | Moteur — orchestrateur multi-doc |
+| 2 | `executor.py` | 574 | Moteur — exécuteur mono-doc |
+| 3 | `planner.py` | 406 | Planification spec → plan |
+| 4 | `llm_pipeline_builder.py` | 256 | Construction de specs OCR+LLM |
+| 5 | `run_control.py` | 232 | Contrat — annulation runtime |
+| 6 | `validation.py` | 218 | Validation statique de spec |
+| 7 | `cache_helpers.py` | 189 | Cache via store (système réel) |
+| 8 | `cache.py` | 154 | Cache in-memory (**mort**) |
+| 9 | `types.py` | 152 | Contrat — `RunContext`/`StepResult`/`PipelineResult` |
+| 10 | `llm_pipeline_config.py` | 136 | Container OCR+LLM |
+| 11 | `__init__.py` | 132 | Façade de ré-export |
+| 12 | `run_result.py` | 129 | Agrégats de run (`RunResult`) |
+| 13 | `protocols.py` | 102 | Contrat — `StepExecutor` (module exécutable) |
+| 14 | `cache_protocol.py` | 85 | Cache — ports (Protocols) |
+| 15 | `yaml_io.py` | 59 | Round-trip YAML de `PipelineSpec` (**mort**) |
+
+> ⚠️ Le `CLAUDE.md` de **Picarones** ne documente que 7 de ces 15 fichiers pour
+> `pipeline/` (il omet le trio cache, `run_control`, `run_result`, `validation`,
+> `yaml_io`) et affirme « plus aucun shim » — **factuellement faux** : shims
+> survivants identifiés (§1.6). La doc source sous-décrit la couche : se fier au
+> code, pas à elle.
+
+## 1.2 Architecture réelle (le flux vivant, vérifié)
+
+**Il n'y a pas deux moteurs concurrents.** `executor.py` = moteur ; `runner.py` =
+orchestrateur qui l'**enveloppe par composition** (pas de redondance) :
+
+```
+app/services/builders.py:205-208   ← SEUL point de câblage
+  PipelineExecutor(adapter_resolver, artifact_store=…)
+  CorpusRunner(pipeline_executor, max_in_flight=…, timeout_seconds_per_doc=…)
+        │
+BenchmarkService.run (app)  →  CorpusRunner.run(spec, documents, …)   [N docs]
+        │                         ├─ executor.plan(spec)            1×  (runner.py:246)
+        │   ThreadPoolExecutor    └─ par doc, dans un thread :
+        │   backpressure/timeout       executor.run_plan(plan, document, control)  (runner.py:510)
+        │   cancel/agrégation               │
+        │                                    └─ par step (séquentiel) :
+        │                                         resolver(adapter_name) → StepExecutor
+        │                                         adapter.execute(inputs, params, context, control)
+        │                                         (cache: read/write via ArtifactCachePort)
+```
+
+- `runner.py:83` importe `PipelineExecutor` ; **jamais l'inverse**. Composition
+  unidirectionnelle. Niveaux d'abstraction distincts → **zéro doublon**.
+- **Aucun fan-out par région** : `grep region|bbox|polygon|fan.out picarones/pipeline/`
+  → **vide**. Le seul fan-out est **par document** (un thread/doc dans `runner.py`).
+  Le fan-out segmentation exigé par `CLAUDE.md` §3 **n'existe pas en source** :
+  c'est du **net-new** (cf. §2.4 / Risque T2).
+
+## 1.3 Surface de contrat consommée par l'extérieur (durable — façonne l'enveloppe)
+
+Imports de `pipeline/*` depuis les couches externes (hors `tests/`). C'est ce que
+Cinoc **doit** continuer d'offrir (sous une forme propre) :
+
+| Consommateur (couche) | Symboles requis de `pipeline/` | Nature |
+|---|---|---|
+| `adapters/` 5 — OCR/LLM/VLM + `_httpx_helpers` | `StepExecutor` (implémenté), `RunControl`, `RunContext`, `RunCancelledError` | **Contrat de module** + annulation |
+| `app/` 6 — `benchmark_service`, `run_orchestrator*`, `builders`, `factories`, `_benchmark_adapter_resolver`, `_orchestrator_partial` | `PipelineExecutor`, `CorpusRunner`, `PipelineSpec`/`PipelineStep` (re-exportés), `RunContext`, `PipelineResult`, `make_ocr_llm_pipeline_spec` | **Pilotage** du moteur |
+| `reports/` 7 + `interfaces/web` 8 | `PipelineResult`, `RunResult` | **Lecture** des résultats |
+
+> `adapters → pipeline` est un import **interne légal** (5 importe 4). Le contrat
+> pivot est `StepExecutor.execute(inputs, params, context, control) → dict[ArtifactType, Artifact]`
+> (`protocols.py:93-99`), implémenté **par duck-typing** (pas d'héritage) par
+> `BaseOCRAdapter`/`BaseLLMAdapter`/`BaseVLMAdapter`.
+
+## 1.4 Analyse document par document (rôle vérifié · deps · consommateurs · problèmes)
+
+| Fichier | Rôle réel **vérifié dans le code** | Deps internes / externes | Consommateurs réels (hors `tests/`) | Bugs · mort · doublons |
+|---|---|---|---|---|
+| **`protocols.py`** | `StepExecutor` (`@runtime_checkable Protocol`) : `name`/`input_types`/`output_types` + `execute(inputs, params, context, control)→dict[ArtifactType,Artifact]` (`:93`). **C'est le contrat de module exécutable** (équivalent `BaseModule`). | `domain.artifacts`, `pipeline.run_control`, `pipeline.types` / `typing` | `executor.py:83,105`, resolver `app/_benchmark_adapter_resolver`, `run_orchestrator.py:367` | **Pas de `version`** (manque pour repro — cf. cache_helpers:99 `adapter_version=None`). `runtime_checkable` jamais utilisé en `isinstance` réel (la vérif passe par attributs). Docstring cite `raise_if_cancelled`/`is_cancelled` (méthodes mortes). |
+| **`run_control.py`** | `RunControl` (mutable) : `cancel_event` (`threading.Event`) + `register_cancel_handle`/`trigger_cancel` (kill cross-thread, `Lock`) + `cancel_triggered`. `RunCancelledError(PicaronesError)` défini ici (`:194`). | `domain.errors` / `threading` | `RunControl` : **tous** les adapters, `executor`, `runner` ; `trigger_cancel` `runner.py:401,448` ; `register_cancel_handle` `_httpx_helpers.py:120` ; `RunCancelledError` `_httpx_helpers`, `ollama_adapter` | `_safely_invoke` `except Exception`+log (`:219`, conforme). **`raise_if_cancelled` + `is_cancelled` : 0 appel prod** (docstrings only). `CancelHandle` alias : ré-export quasi-mort. **`RunCancelledError` doit être en domain** (déjà fait couche 1, D9). |
+| **`types.py`** | `RunContext` (frozen, **sérialisable**, porte `deadline: Deadline`) ; `StepResult` (`step_id`/`succeeded`/`duration_seconds`/`produced_artifacts:{type.value→id}`/`error`) ; `PipelineResult` (`step_results`/`succeeded`/`artifacts` plats). | `domain.artifacts`, `domain.deadline` / `pydantic` | `RunContext`/`PipelineResult` : adapters, `executor`, `runner`, `benchmark_service`, `_orchestrator_partial` (JSONL), reports | **`StepResult.token_confidences` N'EXISTE PAS** (prose fausse en `tesseract.py:144`). `step_result_by_id`/`artifacts_of_type` : **0 conso prod**. `artifacts_of_type(Any)` : typage laxiste. Aucun champ région. |
+| **`executor.py`** | `PipelineExecutor` : `plan()` (sucre planner) + `run_plan(plan, document, …, control)` (canonique) + `_run_step` (résout inputs via **bindings explicites**, cache read/write, `adapter.execute`, valide outputs, filtre les types non déclarés). **Séquentiel, mono-doc, sans threading.** | `domain.{artifacts,documents,errors,pipeline_spec}`, `pipeline.{cache_helpers,cache_protocol,planner,protocols,run_control,types}` / `logging,time` | `runner.py:246,510` (**uniquement**) ; instancié `builders.py:205` | 2× `except Exception # noqa` → `StepResult` en échec + `logger.warning` (conforme). **`run(spec,…)` (sucre S7, `:199`) : code mort en prod.** Provenance **non câblée** (produit des ids, pas de `ProvenanceRecord`). **574 LOC > 400.** |
+| **`runner.py`** | `CorpusRunner` : `ThreadPoolExecutor` + **backpressure** (`_occupancy < max_in_flight`) + **timeout depuis exécution réelle** (`started_at` posé par le worker) + **annulation** (queue→`fut.cancel`, in-flight→`control.trigger_cancel`) + **agrégation** (`DocumentOutcome`/`CorpusRunResult`). Ne ré-exécute **jamais** une étape. | `domain.*`, **`pipeline.executor`**, `pipeline.{run_control,types}` / `concurrent.futures,threading,time,pydantic` | `benchmark_service.py:55,161` ; instancié `builders.py:208` | État partagé **protégé par locks** (`started_at_lock`, `controls_lock`). **Fuite de threads zombies ASSUMÉE** (Python ne tue pas un thread ; `shutdown(wait=False, cancel_futures=True)`). 1 `except Exception # noqa`→outcome (conforme). **630 LOC > 400.** |
+| **`planner.py`** | `PipelinePlanner.plan(spec)→ExecutionPlan` : `validate_spec` + `_resolve_steps` (bindings `(input_type, source_step_id)` ; `inputs_from` explicite sinon **dernier producteur**). `ExecutionPlan`/`ResolvedStep`/`StepInputBinding` (frozen). **Pas de tri topologique** : l'ordre de `spec.steps` est présupposé. | `domain.{artifacts,errors,pipeline_spec}`, **`evaluation.registry`**, `pipeline.validation` / `dataclasses` | chaîne vivante via `executor` seulement ; **aucun import app direct** | **`MetricJunction`+`_detect_junctions`+`metric_junctions`+`junctions_for_step` : morts** (registry jamais fourni en prod → `metric_junctions=()`). Couplage `pipeline→evaluation` **uniquement pour ce mort**. `available_adapters` : jamais alimenté → check `unknown_adapter` toujours sauté. |
+| **`validation.py`** | `validate_spec(spec)→list[ValidationError]` (collecte tout, ne lève pas) : `empty_pipeline`/`duplicate_id`/`missing_input`/`inputs_from_unused`/`unknown_input_source`/`source_does_not_produce_type`. | `domain.{artifacts,pipeline_spec}` / `pydantic` | **`planner.py:287` uniquement** | `ValidationError` **homonyme** de `pydantic.ValidationError` (confusion). Couplage implicite : `_resolve_steps` indexe `latest_producer` **sans garde**, sûr seulement car `validate_spec` a tourné avant (`KeyError` sinon). Pas de détection de cycle. |
+| **`cache_helpers.py`** | Système de cache **réel** : `compute_step_artifact_key`→`ArtifactKey` (domain) ; `read_cached_outputs` (miss complet si 1 output manque) ; `write_outputs_to_cache`. Métadonnées seulement (payload reste à `Artifact.uri`). | `domain.{artifact_key,artifacts}`, `pipeline.cache_protocol` / `logging,pathlib` | `executor.py:72-74,496,500,521,525` | **I/O disque dans couche 4** : `Path(stored.artifact.uri).exists()` (`:155`) — fuite d'I/O (devrait être au store). `logger.debug` sur miss (conforme). |
+| **`cache_protocol.py`** | Ports d'inversion de dépendance : `ArtifactCachePort` (`get`/`put`/`__contains__`) + `CachedArtifactRef`. Permet à `pipeline` de ne pas importer `adapters`. | `domain.artifacts` / `typing` | `executor.py:76,162` (`isinstance`), `cache_helpers.py:59` | **Sur-découpage** : 85 LOC pour 2 Protocols consommés uniquement par `cache_helpers`+`executor`. Fusionnable. |
+| **`cache.py`** | `ArtifactCache` in-memory (dict RAM) + clé SHA-256 **maison** (hashe `step.model_dump()` entier — **n'utilise PAS `ArtifactKey`**). | `domain.{artifacts,pipeline_spec}` / `hashlib,json` | **0 (hors tests).** Ré-export inerte `__init__.py:53,125`. La docstring `adapters/storage/__init__.py:19` qui prétend le ré-exposer est **fausse**. | **CODE MORT + doublon** du système `cache_helpers`. **2ᵉ algorithme de clé divergent** pour le même but. Docstring admet le non-branchement. |
+| **`llm_pipeline_builder.py`** | `make_ocr_llm_pipeline_spec(mode, …)→PipelineSpec` : factory de spec déclarative (1 step VLM en `zero_shot` ; 2 steps OCR+LLM sinon ; IMAGE ajoutée en `text_and_image`). Logique pure. | `domain.{artifacts,errors,pipeline_spec}` / — | `app/_benchmark_adapter_resolver.py:33,195,206` | **Aucun modèle/prompt hardcodé** (littéraux `gpt-4o`/`claude` en docstrings only). `OCRLLMPipelineMode` = **alias redondant** de `domain.PipelineMode` (0 conso externe). Construit des specs → relève plutôt de `app`. |
+| **`llm_pipeline_config.py`** | `OCRLLMPipelineConfig` (frozen) : container `(llm_adapter:Any, mode, ocr_adapter:Any?, prompt_template, …)` + validation (`__post_init__`) + marker `is_pipeline=True` (duck-typing). | `domain.pipeline_spec` (alias mode) / `dataclasses` | `interfaces/web/benchmark_utils.py:310,340` ; conso structurel `app/_benchmark_adapter_resolver` | Adapters typés **`Any`** → couplage caché (`.model`/`.name` ⇒ `AttributeError` possible). `name`/`ocr_engine` : **alias legacy de wiring**. `OCRLLMMode` : 3ᵉ alias redondant de `PipelineMode`. Glu app/interface, pas exécution. |
+| **`run_result.py`** | `RunResult{manifest:RunManifest, document_results}` + `RunDocumentResult{pipeline_results, view_results}` + `ReportRenderer` (Callable). Agrégats applicatifs d'un run. **Placé en `pipeline/` pour contourner un import illégal `reports→app`** (Phase 5.1). | `domain.run_manifest`, `evaluation.views.base.ViewResult`, `pipeline.types` / `pathlib,pydantic` | `benchmark_service`, `run_orchestrator_execution`, reports `{html,json,csv}` | **Mal placé** : le plan couche 3 mergé (`MIGRATION_COUCHE_3.md` §8) situe `RunResult` en `evaluation/result.py`. Shim `app/results.py` le ré-exporte (3 call-sites). `pipeline_results_for` : 0 conso prod. |
+| **`__init__.py`** | Façade : import **eager** de 9 sous-modules, 30 symboles dans `__all__`. | tout `pipeline/*` + `domain` (re-publie `PipelineSpec`/`PipelineStep`) | API publique du paquet | **Import eager lourd** : `from pipeline import PipelineSpec` tire `executor`/`runner`/`threading`/`evaluation` (effet de bord d'import à éliminer). Docstring **obsolète** (réfère `spec.py` inexistant, sprints S6-S12). |
+| **`yaml_io.py`** | `dump_spec_to_yaml`/`load_spec_from_yaml` (round-trip `PipelineSpec` ↔ str, **en mémoire**). `yaml.safe_load`/`safe_dump`. | `domain.pipeline_spec`, `domain.errors` (lazy) / `yaml` | **0 (hors tests).** | **CODE MORT.** Doublon de pattern avec `app/schemas/run_spec.py` (loader plus riche pour `RunSpec`). Sécurité OK (`safe_*`, pas de lecture de chemin). |
+
+## 1.5 Verdicts par fichier — **PROVISOIRE — à confirmer au build**
+
+| Fichier | Verdict | Justification courte (vérifiée) |
+|---|---|---|
+| `protocols.py` | **GARDER + MODIFIER** | Contrat de module exigé en couche 4 (`CLAUDE.md` §3/§6). Ajouter **`version`** (repro → `RunManifest`). Renommer `StepExecutor`→`Module`. Nettoyer docstring (méthodes mortes). |
+| `run_control.py` | **MODIFIER** | Garder `RunControl` (threading + handles). **Retirer `RunCancelledError`** (déjà en domain, D9) et l'importer. Retirer `raise_if_cancelled` (0 conso). `PicaronesError`→`CinocError`. |
+| `types.py` | **MODIFIER** | Garder `RunContext`/`StepResult`/`PipelineResult`. Retirer `step_result_by_id`/`artifacts_of_type` (0 conso). **Ne pas** ajouter `token_confidences` (fantôme). Dimensionner pour résultats par-région (cf. §2.4). |
+| `executor.py` | **GARDER + MODIFIER** | Vrai moteur mono-doc. Retirer `run()` (mort). **Câbler la provenance**. **Split** (>400 LOC). Trancher l'I/O cache (cf. `cache_helpers`). |
+| `runner.py` | **GARDER + MODIFIER** | Vrai orchestrateur (threads/timeout/cancel/backpressure). **Split** (>400 LOC : sortir agrégation/outcome). Préserver la fuite-zombie **documentée**. |
+| `planner.py` | **MODIFIER (dégraisser)** | Garder `plan`/`_resolve_steps`/`ExecutionPlan`/`ResolvedStep`/`StepInputBinding`. **Supprimer** la chaîne `MetricJunction`/`_detect_junctions` (morte → **supprime le couplage `pipeline→evaluation`**). |
+| `validation.py` | **MODIFIER (fusionner)** | Conso unique = planner. **Fusionner dans `planner.py`**. Renommer `ValidationError`→`SpecError` (homonyme pydantic). Garder les 6 checks. |
+| `cache_helpers.py` | **GARDER + MODIFIER** | Système réel (clé via `ArtifactKey`). **Pousser le `Path.exists()` dans le store** (sortir l'I/O de la couche 4). |
+| `cache_protocol.py` | **GARDER (fusionner)** | Port d'inversion correct. **Fusionner** avec `cache_helpers` (un seul `cache.py`). |
+| `cache.py` | **SUPPRIMER** | 0 conso, doublon mort, 2ᵉ algo de clé divergent. |
+| `llm_pipeline_builder.py` | **CHANGER DE COUCHE → `app`** | Construit des specs depuis l'intention utilisateur (conso = resolver app). Couche 4 **exécute** des specs, ne les compose pas. Confirmer à la tranche OCR+LLM. |
+| `llm_pipeline_config.py` | **CHANGER DE COUCHE → `app`** (ou supprimer) | Glu web/app, adapters `Any`, alias legacy. Pas de l'exécution. Confirmer à la tranche OCR+LLM. |
+| `run_result.py` | **CHANGER DE COUCHE → `evaluation` (3)** | `RunResult` = contrat de sortie **evaluation** (`MIGRATION_COUCHE_3.md` §8). Placement Picarones = contournement d'import. `ReportRenderer`→`app`/`reports`. |
+| `__init__.py` | **MODIFIER (amincir)** | `__init__` mince, **zéro effet de bord d'import** (`CLAUDE.md` §7). Pas de re-publication des types `domain`. |
+| `yaml_io.py` | **SUPPRIMER** | 0 conso (« au cas où »). Trivial à recréer côté `app` si besoin réel. |
+
+**Bilan portage** : 15 fichiers source → noyau couche 4 réécrit ≈ **6-8 fichiers**
+(2 suppressions nettes, 3 changements de couche, le reste fusionné/dégraissé).
+
+## 1.6 Constats transverses durables
+
+- **Discipline `except` : globalement saine.** Aucun `except Exception: pass`. Les 4
+  captures larges (`executor.py:379,403`, `runner.py:553`, `run_control.py:219`)
+  sont `# noqa: BLE001`, **tracées** (`logger.warning`) et traduites en résultat
+  d'échec. À préserver tel quel.
+- **Concurrence saine, fuite assumée.** Tout le threading vit dans `runner.py`,
+  état partagé sous locks. La fuite de threads (zombies) est un **choix documenté**
+  (Python ne tue pas un thread), pas un bug — à porter consciemment.
+- **Shims survivants** (contredit « plus aucun shim » du `CLAUDE.md` Picarones) :
+  `app/results.py` (ré-export `RunResult`), `executor.run()` (sucre S7),
+  alias `name`/`ocr_engine` de `OCRLLMPipelineConfig`, **triple alias** de
+  `PipelineMode` (`OCRLLMPipelineMode`, `OCRLLMMode`).
+- **Code mort net** : `cache.py`, `yaml_io.py`, chaîne `MetricJunction`,
+  `available_adapters`, `raise_if_cancelled`/`is_cancelled`,
+  `step_result_by_id`/`artifacts_of_type`, `pipeline_results_for`.
+- **Provenance dormante** : `ProvenanceRecord` n'apparaît qu'en docstrings dans
+  `pipeline/` ; le moteur produit des ids, **pas** de provenance. À câbler en
+  couche 4 (`MIGRATION_COUCHE_1.md` §7).
+- **Divergence doc/code** : `StepResult.token_confidences` est cité ailleurs mais
+  **n'existe pas** ; les confidences voyagent par un `_OcrResultView` distinct.
+
+---
+
+# PARTIE 2 — RÉORGANISATION cible Cinoc (périssable — « à confirmer à la tranche »)
+
+> Conforme à la discipline `CLAUDE.md` : deux axes · « pas de consommateur =
+> supprimé » · budgets < 400 LOC · rupture nette zéro shim · narrative supprimé.
+> **Rien ici n'est figé** : l'enveloppe se confirme au squelette ambulant ; la
+> surface (fan-out, robustness, provenance) se remplit **tranche par tranche**.
+
+## 2.1 Les deux axes appliqués à la couche 4
+
+| Axe | Contenu couche 4 | Quand |
+|---|---|---|
+| **Enveloppe** (contrats, types pivots, points d'extension) | Contrat **`Module`** unique (`execute(inputs, params, context, control)` **+`version`**) ; split `RunContext`(sérialisable)/`RunControl`(runtime)/`Deadline`(domain) ; `StepResult`/`PipelineResult` **dimensionnés pour porter des résultats par-région** (`Artifact.region_id` existe déjà) ; `PipelineExecutor`(mono-doc)+`CorpusRunner`(N docs) ; `planner` à bindings explicites ; **port de cache** (inversion de dépendance). | **Maintenant** (squelette ambulant) |
+| **Surface** (remplie incrémentalement, en budget, élaguée) | Fan-out par région (tranche **segmentation**) ; ré-exécution moteur de **robustness** (entrante de couche 3) ; câblage **provenance** ; adapters du starter pack (couche 5). | **Par tranche** |
+
+## 2.2 Esquisse d'arborescence cible (à valider en codant)
+
+| Fichier cible | Contenu | Source(s) Picarones |
+|---|---|---|
+| `module.py` | `Module` Protocol : `name`/`version`/`input_types`/`output_types`/`execute(...)` | `protocols.py` (+`version`) |
+| `run_control.py` | `RunControl` (sans `RunCancelledError` → domain) | `run_control.py` dégraissé |
+| `results.py` | `RunContext`, `StepResult`, `PipelineResult` (**pas** `RunResult`) | `types.py` dégraissé |
+| `planner.py` | `PipelinePlanner`+`ExecutionPlan`+`ResolvedStep`+`StepInputBinding`+validation fusionnée (`SpecError`) | `planner.py`+`validation.py`, sans la chaîne métriques |
+| `executor.py` | `PipelineExecutor` (mono-doc, provenance câblée) | `executor.py` sans `run()` |
+| `runner.py` | `CorpusRunner` (threads/timeout/cancel/backpressure) | `runner.py` |
+| `cache.py` | `ArtifactCachePort` + `compute_step_artifact_key`/read/write (I/O au store) | `cache_helpers.py`+`cache_protocol.py` fusionnés |
+| `__init__.py` | **mince**, sans effet de bord, sans re-publier les types `domain` | `__init__.py` réécrit |
+
+**Supprimés** : `cache.py` (in-memory), `yaml_io.py`.
+**Changés de couche** : `run_result.py`→`evaluation` ; `llm_pipeline_builder.py`+`llm_pipeline_config.py`→`app`.
+**Hors couche 4 (rappel)** : registre + découverte entry-points = **`app`** (`CLAUDE.md` §3).
+
+## 2.3 Application des 5 garde-fous
+
+1. **Rupture nette, zéro shim** → supprimer `app/results.py`, `executor.run()`,
+   alias `name/ocr_engine`, triple alias `PipelineMode`. Un seul chemin.
+2. **Budgets < 400 LOC** → `executor.py` (574) et `runner.py` (630) **doivent
+   être splittés** le long de coutures naturelles (executor : exécution / cache ;
+   runner : submit-poll / agrégation-outcome). Croissance « assumée » si justifiée.
+3. **Pas de consommateur = supprimé** → applique les SUPPRESSIONS de §1.5/§1.6.
+4. **Tests d'archi jour 1** → `no-side-effect-import` (`__init__` mince),
+   `layer-deps` (pipeline n'importe que `domain`+stdlib+pydantic ; **plus
+   `evaluation`** une fois la chaîne métriques retirée), `file-budgets`,
+   `no-broad-except`.
+5. **Une feature = entière, en budget, en élaguant** → fan-out, robustness,
+   provenance : chacun à sa tranche, pas « au cas où » d'avance.
+
+## 2.4 Ce que la couche 4 NE possède PAS (frontières héritées — à ne pas recréer)
+
+- **`RunResult` ∉ couche 4.** Il vit en `evaluation/result.py` (couche 3 mergée,
+  `MIGRATION_COUCHE_3.md` §8). Picarones le plaçait ici par contournement d'import.
+  Une future session **ne doit pas** le recréer en `pipeline/`.
+- **`CanonicalLayout` + fan-out par région ∉ maintenant.** Différés à la tranche
+  segmentation (`CLAUDE.md` §3, `MIGRATION_COUCHE_2.md` L10, `MIGRATION_COUCHE_3.md`
+  §10). L'enveloppe **réserve** la place (`region_id` sur `Artifact`,
+  `PipelineResult` dimensionné), mais **rien n'est bâti** sans son consommateur.
+- **Registre/factory/découverte ∉ couche 4.** En `app` (`CLAUDE.md` §3 brique 2-3).
+  La couche 4 ne connaît que `AdapterResolver = Callable[[str], Module]`.
+- **`RunCancelledError` ∉ couche 4.** En `domain/errors.py` (déjà mergé, D9).
+
+## 2.5 Cohérence avec les couches mergées (vérifiée, aucune contradiction)
+
+- `domain` fournit déjà tout l'amont : `Deadline` (API `infinite/in_seconds/is_expired/as_sdk_timeout/clamp_to_remaining/to_dict`), `ArtifactKey` (`input_hashes`/`adapter_name`/`adapter_version`/`code_version`/`hash_hex`), `Artifact.region_id`, `ArtifactType.{LAYOUT,RAW_TEXT,CORRECTED_TEXT}`, `RunManifest`, `PipelineSpec`/`PipelineStep`/`PipelineMode`/`INITIAL_STEP_ID`, erreurs (`RunCancelledError`/`DeadlineExceeded`/`AdapterStepError`).
+- Le contrat `Module.execute(... context, control)` **place bien** deadline+annulation en couche 4 (raison du non-placement en domain, D1) — cohérent.
+
+---
+
+# PARTIE 3 — Risques de transfert & dettes potentielles (+ détection)
+
+## 3.1 Risques de transfert
+
+| # | Risque | Détection |
+|---|---|---|
+| **T1** | Recréer `RunResult` en `pipeline/` (placement Picarones trompeur) | Test d'archi : `pipeline/` ne définit pas `RunResult` ; `grep` ; revue de la frontière §2.4. |
+| **T2** | Bâtir le **fan-out par région** d'office (spéculatif, sans consommateur) | Garde-fou « pas de consommateur = supprimé » ; aucun `CanonicalLayout` en couche 4 avant sa tranche. |
+| **T3** | Porter la **provenance dormante** (moteur qui ne produit que des ids) | Test : après `run_plan`, chaque `Artifact` produit porte un `ProvenanceRecord` (code_version). |
+| **T4** | Garder l'**I/O disque** (`Path(uri).exists()`) en couche 4 | Test d'archi « pas d'accès filesystem en `pipeline/` » ; pousser l'existence au store. |
+| **T5** | Porter `StepExecutor` **sans `version`** (trou de reproductibilité) | Le `Module` Protocol exige `version` ; test `RunManifest` inclut les versions de modules. |
+| **T6** | `__init__` à **import eager** (effet de bord, tire threading/evaluation) | Test `no-side-effect-import` ; `import cinoc.pipeline` ne doit pas charger le runtime. |
+| **T7** | Reproduire la **fuite de threads** sans la maîtriser/documenter | Test : timeout → outcome immédiat + `shutdown(wait=False, cancel_futures=True)` ; commentaire explicite. |
+| **T8** | Réintroduire `ValidationError` **homonyme** de pydantic | `grep` ; renommer `SpecError` ; mypy. |
+| **T9** | Importer la **divergence `pipeline→evaluation`** via la chaîne métriques morte | Test `layer-deps` : `pipeline/` n'importe pas `evaluation` (après suppression `_detect_junctions`). |
+| **T10** | Recréer `StepResult.token_confidences` (champ **fantôme**) | Déjà absent ; ne pas l'ajouter ; confidences = artefact/canal dédié. |
+
+## 3.2 Dettes potentielles
+
+| # | Dette | Détection / parade |
+|---|---|---|
+| **D1** | Couplage implicite `planner↔validation` (`latest_producer` sans garde, `KeyError` si validate sauté) | Fusionner les deux ; test sur spec invalide passée à `_resolve_steps`. |
+| **D2** | **Pas de tri topologique réel** (ordre de `spec.steps` présupposé) | Décider : valider l'ordre **ou** trier ; test cycle/ordre inverse. |
+| **D3** | `executor.py`/`runner.py` > 400 LOC | `test_file_budgets` ; split aux coutures. |
+| **D4** | Couplage caché `Any` de `OCRLLMPipelineConfig` (si porté en `app`) | Typer contre `Module` ou supprimer ; mypy strict. |
+| **D5** | Triple alias `PipelineMode` (dette déjà documentée en source) | N'utiliser que `domain.PipelineMode` ; `grep` des alias. |
+| **D6** | Sur-découpage cache (3 fichiers → 1) | Revue ; un seul `cache.py`. |
+| **D7** | `make_ocr_llm_pipeline_spec` recâblé hâtivement en couche 4 | Le traiter **à la tranche OCR+LLM**, côté `app`. |
+
+---
+
+# Synthèse pour la session de construction (3-5 points clés)
+
+1. **Un moteur + un orchestrateur, pas deux moteurs.** Porter `PipelineExecutor`
+   (mono-doc, séquentiel, cache, provenance à câbler) **enveloppé** par
+   `CorpusRunner` (threads/timeout/cancel/backpressure). Composition stricte,
+   point de câblage unique. Les deux > 400 LOC → **splitter**.
+2. **Le contrat de module est le pivot de l'enveloppe.** `Module.execute(inputs,
+   params, context, control) → dict[ArtifactType, Artifact]`, **+`version`**
+   (manquant en source, exigé pour la repro). Implémenté en duck-typing par les
+   adapters (couche 5). `RunContext`(sérialisable)/`RunControl`(runtime)/`Deadline`
+   (domain) restent séparés.
+3. **Le fan-out par région N'EXISTE PAS en source** — c'est du net-new, **différé
+   à la tranche segmentation** avec `CanonicalLayout`. L'enveloppe réserve la place
+   (`region_id`, `PipelineResult` dimensionné) ; **ne rien bâtir d'avance**.
+4. **Suppressions/déplacements nets** : supprimer `cache.py`(mort) + `yaml_io.py`(mort) ;
+   **déplacer** `run_result.py`→`evaluation`(3) et les 2 fichiers LLM→`app`(6) ;
+   **dégraisser** `planner` (retirer la chaîne métriques morte → coupe le couplage
+   `pipeline→evaluation`) et fusionner `validation`. 15 fichiers → ≈ 6-8.
+5. **Garder la discipline saine de la source** (zéro `except: pass`, locks, fuite
+   zombie assumée) ; **casser les shims** (`app/results.py`, `executor.run()`,
+   alias `PipelineMode`/`ocr_engine`) ; **câbler la provenance** et **sortir l'I/O
+   cache** vers le store. Tests d'archi (`layer-deps` sans `evaluation`,
+   `no-side-effect-import`, `file-budgets`) dès le premier commit de code.
+
+## DoD vivante (couche 4) — **autorité de détail** ; le `MIGRATION_PLAN.md` indexe
+
+> **T8 (D-066)** : contrat `Module.execute` → **`StepOutput(artifacts, usage)`** (changement atomique, zéro double signature) ; l'exécuteur **mesure** la durée de chaque étape (monotonic, source unique), fusionne les jetons remontés, renvoie **`DocumentExecution(artifacts, usage)`** ; le fan-out somme les jetons des N régions. Preuves : `tests/pipeline/test_executor.py::test_usage_records_duration_and_tokens` · `::test_usage_sums_across_steps`.
+
+> Tri-état : `[x]` fait **+ preuve** · `[ ]` à faire · `[~]` différé/réserve + raison.
+> Maj dans le **même commit** que le code. **Statut : ✅ T3** — `Module` Protocol + exécuteur (résolution DAG + estampille de provenance) + `RunControl`/`Deadline` + **annulation câblée** (ollama, T3) verts. **+ T5 squelette** : `fanout.py` (`run_region_fanout` — reconnaissance par région, échec partiel toléré, ordre de lecture préservé) ; le `Module` reste **inchangé** (1 artefact/type, le fan-out boucle dans l'orchestration). *preuve : `tests/pipeline/test_segmentation_skeleton.py`*. **+ T5 wiring déclaratif** : `execute_region_fanout` (persiste le LAYOUT rempli) + branche `step.fanout` dans `PipelineExecutor` → une `PipelineSpec` unique orchestre segment→fanout→assemblage. *preuve : `tests/pipeline/test_segmentation_pipeline.py`*
+
+**Enveloppe (plein-scope dès T1) :**
+- [x] `Module` Protocol unique : `name`/**`version`**/`input_types`/`output_types`/`execute(inputs,params,context,control)`. — *preuve : `precomputed` l'implémente (`isinstance(.., Module)` vert) ; `pipeline/protocols.py`*
+- [x] Split `RunContext`(domain `Deadline`) / `RunControl`(runtime), câblés par l'exécuteur. — *preuve : `tests/pipeline/test_run_control.py` + `test_executor.py` verts.* `[~]` round-trip (dé)sérialisation `RunContext` : test dédié à ajouter.
+- [x] **`RunControl.register_cancel_handle`** (interruption d'appel bloquant) — différé en T1 faute de consommateur (D-008), **livré en T3 avec son 1ᵉʳ vrai consommateur** (`ollama`). Thread-safe (`Lock`) : enregistrement et `trigger_cancel` synchronisés → handle ni perdu (course) ni appelé deux fois ; enregistrement *après* annulation = appel immédiat. Sondage coopératif (`raise_if_cancelled`) reste la **garantie** ; le handle est *best-effort*. — *preuve : `test_run_control` (fire-on-cancel · immédiat-si-déjà-annulé · once · ordre) ; consommateur réel `adapters/llm/ollama.py`*
+- [x] `PipelineExecutor` mono-doc, **provenance estampillée** (`code_version` + `parameters_hash` + `produced_by_step`). — *preuve : `test_executor::test_runs_single_step_and_stamps_provenance`*
+- [ ] `CorpusRunner` N-docs (threads/timeout/cancel/backpressure). — *T1 (app) / T2*
+- [ ] `planner`+`validation` fusionnés (`SpecError`, pas d'homonyme pydantic) ; port de cache.
+
+**Garde-fous (verts dès la 1ʳᵉ tranche) :**
+- [x] `layer_dependencies` (`pipeline` → domain seulement, **pas** `evaluation`) · `no_side_effect_imports` (`__init__` mince) · `file_budgets` · `no_broad_except`. — *preuve : `test_pipeline_imports_are_allowed` + suite archi verte*
+
+**Validation inter-couches :** `MIGRATION_PLAN.md` §3-T1 (module exécuté de bout en bout) + §3-T4 (un `cancel` interrompt réellement).
+
+- [x] **fan-out par région (T5)** : `fanout.py` + `execute_region_fanout`, orchestré par `step.fanout` dans l'exécuteur ; assemblage `LAYOUT→ALTO_XML` livré (`AltoAssembler`, couche 5). **+ `RegionCropper`** injecté → **crop réel des blocs** (pipeline hybride seg→OCR par bloc ; la couche 4 calcule la boîte relative, PIL en couche 5). *preuve : `tests/adapters/layout/test_crop.py`, `tests/pipeline/test_hybrid_real_bnl.py` (live)*. Reste (épaississement) : routage par type de bloc, segmenteur **out-of-tree** (T6).
+- [~] **Différé** : ré-exécution robustness (entrante couche 3). **Ne PAS recréer `RunResult` ici** (→ couche 3) ni `cache.py`/`yaml_io.py` (morts).
+
+---
+
+*Verdicts marqués « PROVISOIRE — à confirmer au build ». Partie 1 durable (source
+figée) ; Partie 2 périssable (à confirmer à la tranche).*
diff --git a/cinoc/pipeline/ANALYSE_T5_SEGMENTATION.md b/cinoc/pipeline/ANALYSE_T5_SEGMENTATION.md
new file mode 100644
index 0000000000000000000000000000000000000000..0b0eb4bda786c237692bdb01631cb49894a0cbbe
--- /dev/null
+++ b/cinoc/pipeline/ANALYSE_T5_SEGMENTATION.md
@@ -0,0 +1,175 @@
+# ANALYSE — Tranche T5 : structure / segmentation / mise en page
+
+> **Nature** : guide de portage **durable** (session d'analyse, §9 `CLAUDE.md` —
+> *ne code rien*). T5 est une **tranche verticale** qui traverse 4 couches
+> (`domain` C1 · `formats` C2 · `evaluation` C3 · `pipeline` C4) ; ce doc vit en
+> `pipeline/` car le **fan-out** (le cœur net-new de T5) y réside et `CLAUDE.md`
+> ancre le déclencheur de `CanonicalLayout` à « la tranche segmentation (couche 4) ».
+>
+> **Deux parties, à ne pas mélanger (§9)** :
+> 1. **ANALYSE DE LA SOURCE Picarones** — *durable* (Picarones gelé).
+> 2. **DESIGN CIBLE Cinoc** — *périssable*, chaque verdict **« PROVISOIRE — à
+>    confirmer au build »**. La construction se fera par **squelette ambulant**
+>    puis épaississements, **jamais** en complétant une couche de haut en bas.
+>
+> **Autorité de statut = roll-up `MIGRATION_PLAN.md`.** Ce doc ne fige aucun statut.
+
+---
+
+## 0. Verdict d'ensemble (à lire en premier)
+
+| Constat | Conséquence pour T5 |
+|---|---|
+| **Le fan-out par région N'EXISTE PAS dans Picarones** (segmentation = interne à chaque moteur, jamais exposée comme artefact ; aucun assemblage par région ; aucun routage par type de bloc). Confirmé par 4 explorations parallèles + `ANALYSE_COUCHE_4.md` L70-72. | Le fan-out est du **net-new** bâti **sur l'enveloppe déjà dimensionnée** (`Artifact.region_id`, `ArtifactType.LAYOUT`, `Module` Protocol). Rien à « porter » côté orchestration — **à concevoir**. |
+| **Cinoc couche 2 est déjà *en avance* sur Picarones** : `AltoDocument`/`PageDocument` typés, géométrie **numérique** (pas de chaînes brutes : `coords: tuple[Point,…]`), parsers + writers, ordre de lecture PAGE en **arbre** (`ReadingOrderGroup.flatten()`). | T5 **n'a pas à réécrire le parsing**. Il ajoute : (a) `CanonicalLayout` en `domain`, (b) **mappers** `Alto/PageDocument → CanonicalLayout` + assembleur inverse en `formats`. |
+| **Ce qui est portable de Picarones** = des **algorithmes purs** d'`evaluation` (stdlib/rapidfuzz, **zéro shapely/scipy/numpy**) : Region-F1 par IoU (`layout.py`), ordre de lecture F1 (`reading_order.py`), CER par ligne (`line_metrics.py`), projecteur ALTO→texte avec **dé-césure** `HypPart1/HypPart2`. | À **réimplémenter proprement**, pas copier (rupture nette §5.1). Adopter les **conventions saines** (niveau absent → `None`, micro-agrégat, appariement glouton déterministe). |
+| **Le `Module.execute` renvoie UN artefact par type** (`dict[ArtifactType, Artifact]`). | Le fan-out (N régions → N `RAW_TEXT`) **ne peut pas** être un seul appel `Module`. Il vit dans **l'exécuteur** (C4) qui boucle sur les régions. **Le contrat `Module` ne change pas** → conforme au « test conceptuel » T5 (elle ne fait qu'**ajouter**). |
+
+**Aucune contradiction détectée avec `CLAUDE.md` ni une couche mergée.** Deux
+décisions ouvertes (géométrie en `domain` ; surfaçage du CER par-bloc dans
+`RunResult`) sont signalées §F comme **points à trancher au build**, pas comme
+conflits.
+
+---
+
+# PARTIE 1 — ANALYSE DE LA SOURCE PICARONES (durable)
+
+## A. Modèle de mise en page
+
+**Picarones n'a PAS de modèle neutre.** Types **format-spécifiques** indépendants
++ un `Region` dataclass *ad hoc* dans les métriques. Inventaire :
+
+| Source | LOC | Rôle | À retenir |
+|---|---|---|---|
+| `formats/alto/types.py` | 126 | `AltoDocument/Page/TextBlock/Line/String` + `AltoBBox`. bbox pixels entiers, origine haut-gauche. **Pas de polygone**, **pas de neutre**. Césure via `subs_type=HypPart1/2`. | Cinoc a **déjà** ce modèle, **enrichi** (polygone + baseline + blocs `Illustration/Graphical/Composed` récursifs). |
+| `formats/pagexml/types.py` | 82 | `PageDocument/Page/TextRegion/TextLine`. **coords = chaîne brute** `"x,y …"`, baseline idem, **niveau ligne** (pas de mot), régions imbriquées, `region_type` libre. | Cinoc a **déjà** ce modèle, **enrichi** : coords **parsées** en `tuple[Point,…]`, ordre de lecture en **arbre** (`ReadingOrderGroup`), régions génériques (`PageGenericRegion`). |
+| `evaluation/metrics/layout.py` | 303 | **Seul** type géométrique agnostique : `@dataclass(frozen=True) Region(id:str, type:str, bbox:(x,y,w,h))` + IoU + appariement. | C'est un type **de métrique**, pas un modèle de page. Le neutre reste **à créer** (`CanonicalLayout`). |
+| `evaluation/corpus.py` (≈ L200) | — | `ReadingOrderGT(region_order:list[str], source_path)` chargé d'un `.gt.reading_order.json`. | Vocabulaire d'ordre de lecture = **liste plate d'IDs**. |
+
+**Coordonnées (durable)** : pixels entiers, origine haut-gauche, y vers le bas
+(convention image, ALTO **et** PAGE). Valeurs négatives possibles (région
+débordante). Réconciliation d'unités/résolution = **couche 3** (jamais en C1/C2).
+
+## B. Parsers / writers ALTO & PAGE
+
+| Source | LOC | Signature | Durable |
+|---|---|---|---|
+| `formats/_xml_utils.safe_parse_xml` | 57 | `(bytes) → Element\|None` (defusedxml, `forbid_dtd`) | Cinoc a son équivalent durci (`formats/_xml.py`, invariant §12). |
+| `formats/alto/parser.parse_alto` | 227 | `(bytes\|str) → AltoDocument` | Tolérant versions v2/v3/v4/none ; `int(float(attr))` ; bbox négatif **clampé 0** ; déduplication `ComposedBlock` par `id()` objet (**fragile** — smell). |
+| `formats/alto/writer.write_alto` | 148 | `(AltoDocument, version="v4", pretty=False) → bytes` | **Déterministe** si `pretty=False` (octet-stable → cache). Cinoc l'a déjà. |
+| `formats/pagexml/parser.parse_pagexml` | 151 | `(bytes\|str) → PageDocument` | Namespace PRImA stocké brut ; 1ᵉʳ `<Unicode>` par ligne (variantes ignorées). |
+
+**Smells durables à NE PAS reproduire** : (1) déduplication par `id()` objet
+(parser ALTO) ; (2) duplication `_local()`/`_parse_int_attr()`/regex NS entre
+parsers (à centraliser) ; (3) **PAGE sans writer** (Cinoc en a déjà un).
+
+## C. Projecteurs « mise en page → texte » (clé du CER par région)
+
+| Source | LOC | Forme | Durable |
+|---|---|---|---|
+| `evaluation/projectors/base.py` | — | `Protocol` projecteur + `ProjectionReport(ignored_dimensions, warnings)` | **Pattern à reprendre** : une projection **déclare ce qu'elle ignore** (géométrie, ordre…) → honnêteté du rapport (invariant produit). |
+| `evaluation/projectors/alto.py` | 214 | `AltoToText` ; `alto_document_to_text(AltoDoc)→str` | **Dé-césure** `HypPart1/HypPart2` (utiliser `subs_content` sinon concaténer), ordre `Page→Block→Line→String`, espaces/`\n`/`\n\n`. **Logique dans le projecteur, pas le parser.** |
+| `evaluation/projectors/pagexml.py` | 96 | `PageToText` ; `page_document_to_text(PageDoc)→str` | Ordre `Page→Region→Line`. |
+
+## D. Métriques structurelles (algorithmes purs, portables)
+
+| Source | LOC | Mesure | Niveau absent | Libs |
+|---|---|---|---|---|
+| `evaluation/metrics/layout.py` | 303 | **Region-F1 par type** (ICDAR 2015) : appariement **glouton par IoU** (seuil 0,5), P/R/F1 global + par type. `_iou_bbox`, `_align_regions`. | GT 0 région → `f1=None` (**pas 0.0**), `fp=len(hyp)`. | **stdlib seule** |
+| `evaluation/metrics/reading_order.py` | 217 | **Ordre de lecture F1** : paires `(a avant b)` via `combinations`, intersection ref/hyp. | < 2 régions → `None`. | stdlib |
+| `evaluation/metrics/alto_structural.py` | 175 | `alto_validity` (≥1 page∧bloc∧ligne) · `line_count_ratio` (min/max) · `word_box_coverage` (frac. mots avec bbox). | hyp vide → 0.0 ; 2 vides → 1.0. | formats |
+| `evaluation/metrics/line_metrics.py` | 305 | **CER par ligne** : appariement **Levenshtein** (rapidfuzz, pas positionnel — *fix audit F15*), percentiles, Gini. | GT vide → zéros. | rapidfuzz |
+| `evaluation/metrics/structure.py` | 238 | Fusion/fragmentation de lignes, ordre par **LCS** (rapidfuzz). | vide → 0. | rapidfuzz |
+
+**Durable clé** : **aucune lib géométrique lourde** (pas de shapely/scipy/numpy) ;
+le pixel-IoU/panoptique est noté « post-livraison » même dans Picarones. La
+**convention « niveau absent → None »** (≠ 0.0 qui pénaliserait) est l'invariant
+métier à conserver — il est déjà câblé dans le runner Cinoc (`_aggregate`
+exclut les `None`).
+
+---
+
+# PARTIE 2 — DESIGN CIBLE Cinoc (périssable — PROVISOIRE)
+
+> Chaque verdict ci-dessous est **PROVISOIRE — à confirmer au build** (le contact
+> du code corrige souvent l'analyse). Conforme à : deux axes (enveloppe vs
+> surface), « pas de consommateur = supprimé », budgets < 400 LOC, rupture nette.
+
+## E. État de l'enveloppe Cinoc (déjà en place — NE PAS casser)
+
+| Contrat | Fichier | T5 fait quoi |
+|---|---|---|
+| `ArtifactType.LAYOUT` réservé + `Artifact.region_id` optionnel | `domain/artifacts.py` | **les consomme** (matérialise le payload). |
+| `Module.execute(inputs, params, ctx, ctrl) → dict[ArtifactType, Artifact]` (**1 artefact/type**) | `pipeline/protocols.py` | **inchangé** — segmenteur/recognizer/assembleur l'implémentent directement. |
+| `PipelineExecutor.execute_document → dict[ArtifactType, Artifact]` (pool plat, dernier-par-type) | `pipeline/executor.py` | **étendu** (interne C4) pour le fan-out région — *ajout*, pas rupture. |
+| `MetricSpec.input_types: tuple[ArtifactType, ArtifactType]` · `DocContext(reference, hypothesis: object)` | `domain/evaluation.py`, `evaluation/context.py` | une métrique `(LAYOUT, LAYOUT)` y entre **sans changement de contrat**. |
+| `load_representation(uri, type)` (lève pour non-texte) | `evaluation/representations.py` | **+ branche `LAYOUT`** : parse ALTO/PAGE → `CanonicalLayout`. |
+| `ProjectionSpec` (différé, 0 conso) | `domain/projection.py` | **1ᵉʳ consommateur** = projecteur `layout→text`. |
+| `RunResult / MetricScore(metric, value, support)` | `evaluation/result.py` | accueille le CER-page (scalaire). *Le par-région = décision §F.* |
+| `formats/_geometry.Point = tuple[int,int]` · `parse_points`/`format_points` | `formats/_geometry.py` | réutilisé par les mappers. |
+
+## F. Décisions ouvertes (à trancher au build — PROVISOIRE)
+
+| # | Décision | Options | Penchant PROVISOIRE |
+|---|---|---|---|
+| **F-1** | **Placement de la géométrie** de `CanonicalLayout` (Point/BBox/Geometry). `Point` vit aujourd'hui en C2 (`formats/_geometry`). | (a) `domain` possède Point/BBox/Geometry, `formats` importe ; (b) `domain` redéfinit `Point=tuple[int,int]` + `BBox`/`Geometry` frozen, `formats/_geometry` reste tel quel. | **(b)** : évite de toucher C2 (mergée) ; l'alias `tuple[int,int]` identique des deux côtés **n'est pas un shim** (type structurel, pas de conversion). La géométrie neutre **est** du vocabulaire transversal → légitime en `domain`. |
+| **F-2** | **Forme de `CanonicalLayout`** : mono-page ou multi-page ? | (a) `CanonicalLayout.pages: tuple[LayoutPage,…]` (fidèle Picarones) ; (b) un `LayoutPage` = l'artefact (1 image = 1 page). | **(a)** pour l'enveloppe (le nom `LayoutPage` est listé séparément au backlog), **(b)** rempli au squelette (1 page). À **confirmer avec le 1ᵉʳ consommateur** (`MIGRATION_PLAN §8`). |
+| **F-3** | **Surfaçage du CER *par bloc*** dans le rapport. `MetricScore` n'a pas de dimension région. | (a) squelette = **CER-page agrégé** seul (0 changement `RunResult`) ; (b) ajouter `region_id` à `MetricScore` **ou** un volet par-région à `RunDocumentResult` (additif). | **(a) au squelette** (prouve le chemin), **(b) en épaississement** si l'informativité le justifie. L'enveloppe **était dimensionnée pour la structure** → (b) reste un *ajout*, pas une rupture (test conceptuel T5 tenu). |
+| **F-4** | **Découpe d'image par région** (crop) — besoin de pixels (PIL). | (a) squelette **`precomputed`** (régions + texte par région pré-fournis → **pas de crop, pas de PIL**) ; (b) crop dans l'exécuteur (PIL en C4 ?) ; (c) crop = concern d'un adapter (C5). | **(a) au squelette**. Pour le réel : **(c)** (le crop est une opération image → C5/adapter), à confirmer. **Ne pas** introduire PIL en `pipeline`. |
+| **F-5** | **Routage par type de bloc** (moteur ≠ selon `region_type`). | (a) squelette = **1 recognizer pour toutes les régions** ; (b) mapping `region_type→adapter_name` dans la spec. | **(a) au squelette** ; (b) = épaississement avec consommateur réel (§5.3 : pas d'API « au cas où »). |
+
+## G. Plan de tranche — squelette ambulant puis épaississements (PROVISOIRE)
+
+**Squelette (pleine profondeur, largeur minimale)** — l'ordre est **intérieur→extérieur** :
+
+| Étape | Couche | Livrable minimal | Garde-fou |
+|---|---|---|---|
+| 1 | C1 `domain` | `CanonicalLayout` (+ `LayoutPage/Region/Line/Word/Geometry/BBox/Point`) frozen, `extra=forbid`. **Mono-page rempli**, multi-page réservé (F-2). Testé en isolation (immutabilité, sérialisation). | < 400 LOC ; consommateurs réels **dans la même tranche** (mappers + métrique + exécuteur). |
+| 2 | C2 `formats` | `alto_to_layout(AltoDocument)→CanonicalLayout` + `layout_to_alto(CanonicalLayout)→AltoDocument` (assemblage ; `write_alto` existe déjà). PAGE → incrément. | importe **uniquement** `domain` ; round-trip testé (golden ALTO octet-stable). |
+| 3 | C5 `adapters` | source de layout **`precomputed`** (LAYOUT régions-seules) + recognizer **`precomputed`** par région (texte indexé par `region_id`). | même `Module` Protocol ; 0 dépendance lourde. |
+| 4 | C4 `pipeline` | **fan-out** dans l'exécuteur : lit le `LAYOUT`, boucle régions → appelle le recognizer **1×/région** → collecte N `RAW_TEXT` **estampillés `region_id`** → étape d'assemblage `LAYOUT(+textes)→ALTO_XML`. **Échec partiel** : une région qui échoue n'abat pas la page (collecte les succès, région vide signalée). Ordre de lecture appliqué à l'assemblage. | `Module` **inchangé** ; structure de collecte région **interne C4** ; annulation coopérative respectée. |
+| 5 | C3 `evaluation` | `load_representation` branche `LAYOUT` (parse→`CanonicalLayout`) ; projecteur `layout_to_text` (1ᵉʳ conso de `ProjectionSpec`, dé-césure portée de Picarones) ; métrique `(LAYOUT,LAYOUT)` = **appariement régions (id, sinon IoU glouton) → CER par région → micro-agrégat page**. **Niveau absent → `None`** (hyp sans lignes/texte). | algorithmes **réimplémentés** (rupture nette) ; whitelist C3 respectée (rapidfuzz OK, pas shapely). |
+| 6 | C7 `reports` | la colonne de la métrique de structure apparaît **sans rendu modifié** (dividende du design générique, déjà vérifié en T7). | rapport octet-stable. |
+| 7 | tests | archi (dès le 1ᵉʳ commit) + golden ALTO + round-trip + métrique sur **fixture layout-GT** (cf. risque R-2). | ruff + mypy --strict + pytest verts avant push. |
+
+**Épaississements (1 concept/tranche, consommateur réel)** : segmenteur réel +
+crop (F-4c) · routage par type (F-5) · mappers PAGE · CER **par-bloc surfacé**
+(F-3b) · métriques de **détection de régions** (Region-F1 IoU, port `layout.py`) ·
+ordre de lecture F1.
+
+## H. Réflexe informativité-first (éprouvé en T7) — **bloquant**
+
+Avant de câbler la métrique `(LAYOUT,LAYOUT)` dans un benchmark : **prouver
+qu'elle est informative sur données réelles** (comme `cer_diplo`/`diacritic_err`/
+`ins_rate` figeaient leur trouvaille). Sinon → écarter (§5.3, comme les ligatures
+en #27).
+
+---
+
+## I. Risques de transfert & dettes à surveiller
+
+| ID | Risque | Détection / désamorçage |
+|---|---|---|
+| **R-1** | **Sur-ingénierie du modèle** : recopier toute la richesse ALTO+PAGE « au cas où » (panoptique, glyphes, multi-page) → volume Picarones. | §5.3 : `CanonicalLayout` ne porte que ce que **mappers + métrique + assembleur** de **cette** tranche exigent. Glyphe/panoptique = différés. |
+| **R-2** | **Pas de GT de mise en page committée** : le corpus BNL est **texte seul** (images/ALTO non committés, poids — `D-020`). La métrique structurelle n'a rien à mesurer en CI. | **Prérequis** : petite **fixture layout-GT** (1-2 ALTO/PAGE à régions, légère, committée). Sinon métrique non démontrable → ne pas câbler (R + H). |
+| **R-3** | **Pool plat de l'exécuteur** : N `RAW_TEXT` même type écrasent le `dict[type→artefact]`. | Structure de collecte **par région** interne à C4 (ne PAS toucher le contrat `Module` ni `RunResult`). Test : un fan-out 3 régions produit 3 artefacts `region_id` distincts. |
+| **R-4** | **PIL qui fuit en `pipeline`** via le crop. | Squelette `precomputed` (pas de crop) ; crop réel = concern adapter (F-4c). Garde-fou layer-deps. |
+| **R-5** | **Déterminisme de l'appariement** (IoU à égalité). | Port du tri **glouton stable** de Picarones (candidats triés desc., 1-à-1) ; golden octet-stable. |
+| **R-6** | **`CanonicalLayout` figé trop tôt** sur une forme qui ne sert pas le 1ᵉʳ conso. | Confirmer la forme **avec le squelette** (F-2), pas avant (`MIGRATION_PLAN §8`, corollaire inner→outer). |
+
+---
+
+## J. À transmettre à la session de CONSTRUCTION (3-5 points)
+
+1. **Rien à porter pour l'orchestration** — le fan-out est **net-new** sur
+   l'enveloppe existante (`region_id`, `LAYOUT`, `Module`). Le `Module` Protocol
+   **ne bouge pas** : le fan-out boucle dans l'**exécuteur** (C4).
+2. **Couche 2 est déjà faite et en avance** : T5 ajoute `CanonicalLayout` (C1) +
+   **mappers** `Alto/PageDoc→Layout` & assembleur (C2). Ne **pas** réécrire les
+   parsers/writers.
+3. **Squelette = tout `precomputed`** (layout + texte par région) → pas de PIL,
+   pas de crop, pleine profondeur C1→C7. Épaissir ensuite (F-1…F-5).
+4. **Convention métier à tenir** : niveau absent → **`None`** (déjà câblé dans
+   `_aggregate`) ; algorithmes **réimplémentés** (rupture nette), pas copiés.
+5. **Bloquant avant câblage** : fixture **layout-GT** (R-2) + preuve
+   d'**informativité sur données réelles** (H) — réflexe T7.
diff --git a/cinoc/pipeline/__init__.py b/cinoc/pipeline/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3a78a80c123ca34c763f76bda04552f9d7b05e8d
--- /dev/null
+++ b/cinoc/pipeline/__init__.py
@@ -0,0 +1,21 @@
+"""Couche 4 — ``pipeline`` : contrat d'exécution des modules + exécuteur.
+
+Expose le ``Module`` Protocol (point d'extension unique), le contexte/contrôle
+d'exécution et l'exécuteur mono-document. ``__init__`` mince, sans effet de bord.
+"""
+
+from __future__ import annotations
+
+from cinoc.pipeline.executor import PipelineExecutor, PipelineStepError
+from cinoc.pipeline.protocols import Module, ParamValue
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import RunContext
+
+__all__ = [
+    "Module",
+    "ParamValue",
+    "PipelineExecutor",
+    "PipelineStepError",
+    "RunContext",
+    "RunControl",
+]
diff --git a/cinoc/pipeline/executor.py b/cinoc/pipeline/executor.py
new file mode 100644
index 0000000000000000000000000000000000000000..61a6eac119897e4529d0a9dcd601b6fe96d8ff0e
--- /dev/null
+++ b/cinoc/pipeline/executor.py
@@ -0,0 +1,185 @@
+"""``PipelineExecutor`` — exécute une ``PipelineSpec`` sur un document.
+
+Mono-document, séquentiel : résout les entrées de chaque étape (DAG via
+``inputs_from``, sinon dernière version par type), appelle ``Module.execute``,
+puis **estampille la provenance** (``code_version`` + ``parameters_hash``) et le
+``produced_by_step`` sur chaque artefact produit — le module n'a pas à connaître
+ces concerns. L'annulation coopérative est vérifiée avant chaque étape.
+
+Une étape ``fanout=True`` (reconnaissance par région) exécute son module **une
+fois par région** du ``LAYOUT`` d'entrée et réassemble un ``LAYOUT`` rempli
+(délégué à ``execute_region_fanout``) ; l'estampillage de provenance reste
+identique. L'orchestration multi-documents (threads, timeout, backpressure) vit
+dans l'orchestrateur (couche 6) ; l'exécuteur reste **mono-document** — il est
+sans état mutable partagé, donc sûr à appeler depuis plusieurs threads.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from collections.abc import Mapping
+
+from cinoc.domain.artifacts import Artifact, ArtifactType, compute_content_hash
+from cinoc.domain.deadline import Deadline
+from cinoc.domain.errors import CinocError
+from cinoc.domain.pipeline import INITIAL_STEP_ID, PipelineSpec, PipelineStep
+from cinoc.domain.provenance import ProvenanceRecord
+from cinoc.domain.usage import ResourceUsage
+from cinoc.pipeline.fanout import RegionCropper, execute_region_fanout
+from cinoc.pipeline.protocols import Module
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import DocumentExecution, RunContext, StepOutput
+
+
+class PipelineStepError(CinocError):
+    """Une étape n'a pas pu s'exécuter (module, entrée ou sortie manquante)."""
+
+
+def _parameters_hash(params: Mapping[str, object]) -> str:
+    payload = json.dumps(params, sort_keys=True, ensure_ascii=False)
+    return compute_content_hash(payload.encode("utf-8"))
+
+
+class PipelineExecutor:
+    """Exécute les pipelines déclaratives sur des artefacts initiaux."""
+
+    def __init__(self, code_version: str) -> None:
+        if not code_version:
+            raise CinocError("PipelineExecutor : code_version vide.")
+        self._code_version = code_version
+
+    def execute_document(
+        self,
+        spec: PipelineSpec,
+        modules: Mapping[str, Module],
+        initial_inputs: Mapping[ArtifactType, Artifact],
+        *,
+        document_id: str,
+        deadline: Deadline | None = None,
+        control: RunControl | None = None,
+        workspace_uri: str | None = None,
+        cropper: RegionCropper | None = None,
+    ) -> DocumentExecution:
+        """Exécute ``spec`` ; renvoie artefacts (dernier par type) + ``usage``.
+
+        ``cropper`` (couche 5, injecté par l'app) active le découpage réel des
+        blocs dans les étapes ``fanout`` (pipeline hybride seg→OCR par bloc).
+        La **durée** de chaque étape est mesurée ici (horloge monotone, source
+        unique) puis fusionnée avec les jetons remontés par les modules.
+        """
+        ctrl = control if control is not None else RunControl()
+        dl = deadline if deadline is not None else Deadline.infinite()
+        pool: dict[ArtifactType, Artifact] = dict(initial_inputs)
+        by_step: dict[str, dict[ArtifactType, Artifact]] = {}
+        usage = ResourceUsage()
+
+        for step in spec.steps:
+            ctrl.raise_if_cancelled()
+            module = modules.get(step.adapter_name)
+            if module is None:
+                raise PipelineStepError(
+                    f"étape {step.id!r} : module {step.adapter_name!r} "
+                    "absent du registre."
+                )
+            inputs = self._resolve_inputs(step, pool, by_step)
+            context = RunContext(
+                document_id=document_id,
+                code_version=self._code_version,
+                pipeline_name=spec.name,
+                deadline=dl,
+                workspace_uri=workspace_uri,
+            )
+            started = time.monotonic()
+            if step.fanout:
+                output = self._run_fanout(step, module, inputs, context, ctrl, cropper)
+            else:
+                output = module.execute(inputs, dict(step.params), context, ctrl)
+            step_usage = ResourceUsage(
+                duration_seconds=time.monotonic() - started
+            ).merged_with(output.usage)
+            usage = usage.merged_with(step_usage)
+            stamped = self._stamp(output.artifacts, step)
+            self._check_outputs(step, stamped)
+            by_step[step.id] = stamped
+            pool.update(stamped)
+        return DocumentExecution(artifacts=pool, usage=usage)
+
+    def _run_fanout(
+        self,
+        step: PipelineStep,
+        module: Module,
+        inputs: Mapping[ArtifactType, Artifact],
+        context: RunContext,
+        control: RunControl,
+        cropper: RegionCropper | None,
+    ) -> StepOutput:
+        layout = inputs.get(ArtifactType.LAYOUT)
+        image = inputs.get(ArtifactType.IMAGE)
+        if layout is None or image is None:
+            raise PipelineStepError(
+                f"étape {step.id!r} (fanout) : entrées LAYOUT et IMAGE requises."
+            )
+        return execute_region_fanout(
+            layout_artifact=layout,
+            page_image=image,
+            recognizer=module,
+            context=context,
+            control=control,
+            params=dict(step.params),
+            # ``crop`` déclaré par l'étape : OCR réel par bloc → découpe ; sinon
+            # (``precomputed``) image page entière + ``region_id``, aucun pixel lu.
+            cropper=cropper if step.crop else None,
+        )
+
+    def _resolve_inputs(
+        self,
+        step: PipelineStep,
+        pool: Mapping[ArtifactType, Artifact],
+        by_step: Mapping[str, dict[ArtifactType, Artifact]],
+    ) -> dict[ArtifactType, Artifact]:
+        resolved: dict[ArtifactType, Artifact] = {}
+        for t in step.input_types:
+            src = step.inputs_from.get(t)
+            if src is None or src == INITIAL_STEP_ID:
+                art = pool.get(t)
+            else:
+                art = by_step.get(src, {}).get(t)
+            if art is None:
+                raise PipelineStepError(
+                    f"étape {step.id!r} : entrée {t.value!r} introuvable."
+                )
+            resolved[t] = art
+        return resolved
+
+    def _stamp(
+        self, outputs: Mapping[ArtifactType, Artifact], step: PipelineStep
+    ) -> dict[ArtifactType, Artifact]:
+        # Déterminisme : l'identité d'un artefact = content_hash + (code_version,
+        # parameters_hash). Le timestamp wall-clock de ProvenanceRecord est de la
+        # métadonnée, EXCLUE de l'identité (cf. ProvenanceRecord.is_compatible_with)
+        # et jamais rendue dans RunResult/HTML. Un cache futur comparerait donc via
+        # is_compatible_with, pas via model_dump_json. (Journal D-012.)
+        provenance = ProvenanceRecord(
+            code_version=self._code_version,
+            parameters_hash=_parameters_hash(dict(step.params)),
+        )
+        return {
+            t: art.model_copy(
+                update={"produced_by_step": step.id, "provenance": provenance}
+            )
+            for t, art in outputs.items()
+        }
+
+    def _check_outputs(
+        self, step: PipelineStep, outputs: Mapping[ArtifactType, Artifact]
+    ) -> None:
+        for t in step.output_types:
+            if t not in outputs:
+                raise PipelineStepError(
+                    f"étape {step.id!r} : sortie déclarée {t.value!r} "
+                    "non produite."
+                )
+
+
+__all__ = ["PipelineExecutor", "PipelineStepError"]
diff --git a/cinoc/pipeline/fanout.py b/cinoc/pipeline/fanout.py
new file mode 100644
index 0000000000000000000000000000000000000000..71cd523b68723b57ccc6156ac8dcc65648a0ef56
--- /dev/null
+++ b/cinoc/pipeline/fanout.py
@@ -0,0 +1,234 @@
+"""Fan-out par région — le cœur net-new de la tranche segmentation (couche 4).
+
+``segmentation (IMAGE → LAYOUT régions-seules) → reconnaissance PAR RÉGION (remplit
+le LAYOUT)``. Le ``Module`` reste **inchangé** : il renvoie *un* artefact par type ;
+c'est **l'orchestration** (ici) qui boucle sur les N régions, collecte les N
+sorties (estampillées ``region_id``), **tolère les échecs partiels** (une région
+qui échoue n'abat pas la page) et réassemble en respectant l'ordre de lecture.
+
+Le recognizer reçoit une IMAGE **cadrée par région**. Deux modes :
+- **``precomputed``** (pas de ``cropper``) : l'IMAGE page entière est passée avec
+  ``region_id`` posé (la donnée précalculée est figée par région) ;
+- **hybride réel** (``cropper`` injecté) : le bloc est **découpé** de l'image — la
+  pièce qui rend « segmentation externe → OCR des blocs » réel. Le découpage PIL
+  vit en couche 5 (``cropper``) ; ici on ne calcule que la **boîte relative**
+  (arithmétique, unités neutralisées : ALTO ``mm10`` vs pixels).
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable, Mapping
+from pathlib import Path
+
+from cinoc.domain.artifacts import (
+    Artifact,
+    ArtifactType,
+    compute_content_hash,
+)
+from cinoc.domain.errors import AdapterStepError
+from cinoc.domain.layout import CanonicalLayout, LayoutPage, Line, Region
+from cinoc.domain.usage import ResourceUsage
+from cinoc.pipeline.protocols import Module, ParamValue
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import RunContext, StepOutput
+
+logger = logging.getLogger(__name__)
+
+#: Découpeur de bloc injecté (impl PIL en couche 5) :
+#: ``(image_page, boîte_relative, region_id, contexte) → artefact IMAGE du bloc``.
+RegionCropper = Callable[
+    [Artifact, tuple[float, float, float, float], str, RunContext], Artifact
+]
+
+
+def _relative_bbox(
+    region: Region, page: LayoutPage
+) -> tuple[float, float, float, float] | None:
+    """Boîte de la région en coordonnées relatives ``[0, 1]`` (unités neutralisées)."""
+    geometry = region.geometry
+    width, height = page.width, page.height
+    if geometry is None or not width or not height:
+        return None
+    if geometry.bbox is not None:
+        b = geometry.bbox
+        x0, y0, x1, y1 = b.x, b.y, b.x + b.width, b.y + b.height
+    elif geometry.polygon:
+        xs = [p[0] for p in geometry.polygon]
+        ys = [p[1] for p in geometry.polygon]
+        x0, y0, x1, y1 = min(xs), min(ys), max(xs), max(ys)
+    else:
+        return None
+    return (x0 / width, y0 / height, x1 / width, y1 / height)
+
+
+def run_region_fanout(
+    *,
+    layout: CanonicalLayout,
+    page_image: Artifact,
+    recognizer: Module,
+    context: RunContext,
+    control: RunControl,
+    params: Mapping[str, ParamValue] | None = None,
+    cropper: RegionCropper | None = None,
+) -> tuple[CanonicalLayout, ResourceUsage]:
+    """Remplit ``layout`` (régions seules) par reconnaissance région par région.
+
+    Renvoie ``(CanonicalLayout rempli, usage)`` : chaque région porte sa ligne
+    de texte reconnu ; ``usage`` somme les jetons remontés par le recognizer
+    (un appel par région). Une région dont la reconnaissance échoue reste
+    **vide** (texte non produit, avertissement journalisé) — la page n'est pas
+    abattue. Avec un ``cropper``, chaque bloc est **découpé** de l'image avant
+    OCR (pipeline réel).
+    """
+    step_params = dict(params) if params is not None else {}
+    usage = ResourceUsage()
+    pages: list[LayoutPage] = []
+    for page in layout.pages:
+        filled_page, page_usage = _fill_page(
+            page, page_image, recognizer, context, control, step_params, cropper
+        )
+        pages.append(filled_page)
+        usage = usage.merged_with(page_usage)
+    return CanonicalLayout(pages=tuple(pages)), usage
+
+
+def _fill_page(
+    page: LayoutPage,
+    page_image: Artifact,
+    recognizer: Module,
+    context: RunContext,
+    control: RunControl,
+    params: dict[str, ParamValue],
+    cropper: RegionCropper | None,
+) -> tuple[LayoutPage, ResourceUsage]:
+    usage = ResourceUsage()
+    filled: list[Region] = []
+    for region in page.regions:
+        filled_region, region_usage = _fill_region(
+            region, page, page_image, recognizer, context, control, params, cropper
+        )
+        filled.append(filled_region)
+        usage = usage.merged_with(region_usage)
+    return page.model_copy(update={"regions": tuple(filled)}), usage
+
+
+def _region_image(
+    region: Region,
+    page: LayoutPage,
+    page_image: Artifact,
+    context: RunContext,
+    cropper: RegionCropper | None,
+) -> Artifact | None:
+    """IMAGE passée au recognizer : crop réel si ``cropper``, sinon image entière."""
+    if cropper is None:
+        return page_image.model_copy(
+            update={
+                "id": f"{page_image.id}:{region.id}",
+                "region_id": region.id,
+                "produced_by_step": None,
+                "provenance": None,
+            }
+        )
+    rel = _relative_bbox(region, page)
+    if rel is None:
+        logger.warning(
+            "[fanout] région %r sans géométrie : non découpable, ignorée", region.id
+        )
+        return None
+    return cropper(page_image, rel, region.id, context)
+
+
+def _fill_region(
+    region: Region,
+    page: LayoutPage,
+    page_image: Artifact,
+    recognizer: Module,
+    context: RunContext,
+    control: RunControl,
+    params: dict[str, ParamValue],
+    cropper: RegionCropper | None,
+) -> tuple[Region, ResourceUsage | None]:
+    control.raise_if_cancelled()
+    region_image = _region_image(region, page, page_image, context, cropper)
+    if region_image is None:
+        return region, None
+    try:
+        output = recognizer.execute(
+            {ArtifactType.IMAGE: region_image}, dict(params), context, control
+        )
+        text = _read_text(output.artifacts)
+    except AdapterStepError as exc:
+        logger.warning(
+            "[fanout] région %r non reconnue (ignorée) : %s", region.id, exc
+        )
+        return region, None
+    line = Line(id=f"{region.id}:l1", text=text)
+    return region.model_copy(update={"lines": (line,)}), output.usage
+
+
+def _read_text(outputs: Mapping[ArtifactType, Artifact]) -> str:
+    artifact = outputs.get(ArtifactType.RAW_TEXT)
+    if artifact is None or artifact.uri is None:
+        raise AdapterStepError("fanout : reconnaissance sans RAW_TEXT exploitable.")
+    try:
+        return Path(artifact.uri).read_text(encoding="utf-8")
+    except OSError as exc:
+        raise AdapterStepError(f"fanout : texte de région illisible : {exc}") from exc
+
+
+def execute_region_fanout(
+    *,
+    layout_artifact: Artifact,
+    page_image: Artifact,
+    recognizer: Module,
+    context: RunContext,
+    control: RunControl,
+    params: Mapping[str, ParamValue] | None = None,
+    cropper: RegionCropper | None = None,
+) -> StepOutput:
+    """Étage *reconnaissance par région* prêt pour l'exécuteur déclaratif.
+
+    Charge le ``LAYOUT`` (régions seules) depuis son artefact, remplit par
+    fan-out, **persiste** le ``LAYOUT`` rempli (JSON) dans le workspace et
+    renvoie le ``StepOutput`` attendu par ``PipelineExecutor`` (qui estampille
+    ensuite la provenance) — ``usage`` somme les jetons des N reconnaissances.
+    """
+    if layout_artifact.uri is None:
+        raise AdapterStepError("fanout : artefact LAYOUT d'entrée sans URI.")
+    try:
+        layout = CanonicalLayout.model_validate_json(
+            Path(layout_artifact.uri).read_bytes()
+        )
+    except (OSError, ValueError) as exc:
+        raise AdapterStepError(f"fanout : LAYOUT d'entrée illisible : {exc}") from exc
+    filled, usage = run_region_fanout(
+        layout=layout,
+        page_image=page_image,
+        recognizer=recognizer,
+        context=context,
+        control=control,
+        params=params,
+        cropper=cropper,
+    )
+    payload = filled.model_dump_json().encode("utf-8")
+    out_dir = (
+        Path(context.workspace_uri)
+        if context.workspace_uri
+        else Path(layout_artifact.uri).parent
+    )
+    out_path = out_dir / f"{context.document_id.replace('/', '_')}.filled.layout.json"
+    out_path.write_bytes(payload)
+    artifacts = {
+        ArtifactType.LAYOUT: Artifact(
+            id=f"{context.document_id}:fanout:layout",
+            document_id=context.document_id,
+            type=ArtifactType.LAYOUT,
+            uri=str(out_path),
+            content_hash=compute_content_hash(payload),
+        )
+    }
+    return StepOutput(artifacts=artifacts, usage=usage)
+
+
+__all__ = ["RegionCropper", "execute_region_fanout", "run_region_fanout"]
diff --git a/cinoc/pipeline/protocols.py b/cinoc/pipeline/protocols.py
new file mode 100644
index 0000000000000000000000000000000000000000..2a241b2cb46e1e70d5b3ad3d13001f6868d9b83a
--- /dev/null
+++ b/cinoc/pipeline/protocols.py
@@ -0,0 +1,62 @@
+"""``Module`` — contrat unique d'une brique de pipeline exécutable.
+
+Tout module (OCR, HTR, VLM, post-correcteur LLM, segmenteur, constructeur
+d'ALTO…) implémente cette **même** forme, **directement** — un seul contrat
+runtime, sans second contrat de module emballé par-dessus l'adapter (la dette
+que la réécriture abandonne). C'est le **seul** point d'extension tierce du
+produit (cf. CLAUDE.md §3).
+
+Garanties (contrat runner ↔ module) :
+
+- le runner garantit que ``inputs`` contient tous les types de ``input_types``,
+  que ``params`` est une copie mutable, que ``context`` porte la ``Deadline`` et
+  que ``control`` permet l'annulation coopérative ;
+- le module garantit que ``StepOutput.artifacts`` contient tous ses
+  ``output_types``, qu'aucune exception n'est avalée, et qu'il lève
+  ``DeadlineExceeded`` à expiration de la deadline. ``StepOutput.usage`` est
+  optionnel : seuls les modules qui consomment des jetons (LLM/VLM) le
+  renseignent — la **durée** est mesurée par l'exécuteur, pas par le module.
+
+``version`` (absent du contrat runtime hérité) alimente le ``RunManifest`` :
+deux exécutions ne sont comparables qu'à version de module égale
+(reproductibilité — CLAUDE.md §12).
+"""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+from cinoc.domain.artifacts import Artifact, ArtifactType
+from cinoc.pipeline.run_control import RunControl
+from cinoc.pipeline.types import RunContext, StepOutput
+
+#: Valeur de paramètre admissible dans une spec (sérialisable YAML/JSON).
+ParamValue = str | int | float | bool
+
+
+@runtime_checkable
+class Module(Protocol):
+    """Brique de pipeline exécutable, typée par ses artefacts d'entrée/sortie."""
+
+    @property
+    def name(self) -> str: ...
+
+    @property
+    def version(self) -> str: ...
+
+    @property
+    def input_types(self) -> frozenset[ArtifactType]: ...
+
+    @property
+    def output_types(self) -> frozenset[ArtifactType]: ...
+
+    def execute(
+        self,
+        inputs: dict[ArtifactType, Artifact],
+        params: dict[str, ParamValue],
+        context: RunContext,
+        control: RunControl,
+    ) -> StepOutput: ...
+
+
+__all__ = ["Module", "ParamValue"]
diff --git a/cinoc/pipeline/run_control.py b/cinoc/pipeline/run_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..ef2b21b71d97de0dae1ab9dae5a8ee71359dfd55
--- /dev/null
+++ b/cinoc/pipeline/run_control.py
@@ -0,0 +1,88 @@
+"""``RunControl`` — signal d'annulation coopératif d'un run.
+
+Porté à chaque ``Module.execute`` : l'adapter vérifie ``raise_if_cancelled()``
+entre deux opérations bloquantes et lève ``RunCancelledError`` si le caller
+(utilisateur, deadline globale) a demandé l'arrêt. C'est un concern d'exécution
+→ couche 4 (jamais ``domain``).
+
+Au-delà du sondage coopératif, un adapter qui **bloque sur un appel réseau** peut
+enregistrer un *handle* (``register_cancel_handle``) : un callback que
+``trigger_cancel`` invoque pour **interrompre l'appel en vol** (p. ex. fermer la
+connexion HTTP). Le sondage reste la **garantie** ; le handle n'est qu'une
+accélération *best-effort*. L'adapter ``ollama`` en est l'implémentation de
+référence (cf. couche 5).
+"""
+
+from __future__ import annotations
+
+import threading
+from collections.abc import Callable
+
+from cinoc.domain.errors import RunCancelledError
+
+#: Callback d'interruption, invoqué **une fois** à l'annulation. Doit être sûr —
+#: idempotent et sans lever : un handle qui échoue masquerait les suivants.
+CancelHandle = Callable[[], None]
+
+
+class RunControl:
+    """Poignée d'annulation coopérative, partagée le temps d'un run.
+
+    Thread-safe (``threading.Event`` + ``Lock``). Le sondage coopératif
+    (``raise_if_cancelled``) est la garantie d'arrêt ; ``register_cancel_handle``
+    ajoute une interruption *best-effort* des appels bloquants (fermeture de
+    connexion). Enregistrement et déclenchement se synchronisent sur le même
+    verrou : aucun handle n'est ni perdu (course register/trigger) ni appelé
+    deux fois.
+
+    Limite assumée : un ``cancel_event`` *partagé* mis à ``set()`` **en dehors**
+    de ``trigger_cancel`` (p. ex. par une deadline globale) propage bien l'état
+    (``is_cancelled``) mais **ne déclenche pas** les handles — seul le sondage
+    coopératif reste alors actif. Les handles sont liés à l'API ``trigger_cancel``.
+    """
+
+    def __init__(self, cancel_event: threading.Event | None = None) -> None:
+        self._cancel = (
+            cancel_event if cancel_event is not None else threading.Event()
+        )
+        self._lock = threading.Lock()
+        self._handles: list[CancelHandle] = []
+
+    def trigger_cancel(self) -> None:
+        """Signale l'annulation et déclenche les handles enregistrés. Idempotent.
+
+        Les handles sont vidés sous verrou avant d'être appelés (hors verrou) :
+        un second ``trigger_cancel`` n'en rappelle aucun.
+        """
+        with self._lock:
+            self._cancel.set()
+            handles = tuple(self._handles)
+            self._handles.clear()
+        for handle in handles:
+            handle()
+
+    def register_cancel_handle(self, handle: CancelHandle) -> None:
+        """Enregistre un callback d'interruption d'appel bloquant.
+
+        Invoqué une fois quand ``trigger_cancel`` survient. Si l'annulation a
+        **déjà** eu lieu, le handle est appelé **immédiatement** (pas de course :
+        le test et l'enregistrement sont sous le même verrou que le déclenchement).
+        """
+        with self._lock:
+            if not self._cancel.is_set():
+                self._handles.append(handle)
+                return
+        handle()
+
+    def is_cancelled(self) -> bool:
+        """Sonde **non levante** de l'annulation (poll coopératif, p. ex. boucle
+        worker). ``raise_if_cancelled`` est la variante qui lève."""
+        return self._cancel.is_set()
+
+    def raise_if_cancelled(self) -> None:
+        """Lève ``RunCancelledError`` si l'annulation a été demandée."""
+        if self._cancel.is_set():
+            raise RunCancelledError("run annulé (annulation coopérative).")
+
+
+__all__ = ["CancelHandle", "RunControl"]
diff --git a/cinoc/pipeline/types.py b/cinoc/pipeline/types.py
new file mode 100644
index 0000000000000000000000000000000000000000..98daef6474dc12c2ec08bd0f7e0ef6d1d3274fae
--- /dev/null
+++ b/cinoc/pipeline/types.py
@@ -0,0 +1,61 @@
+"""``RunContext`` — contexte d'exécution propagé à chaque ``Module.execute``.
+
+Porte l'identité du document, la version de code (provenance), le nom de la
+pipeline et la ``Deadline`` coopérative. Concern d'exécution → couche 4 ; fait
+paire avec ``RunControl`` (raison pour laquelle il ne vit pas en ``domain``).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from cinoc.domain.artifacts import Artifact, ArtifactType
+from cinoc.domain.deadline import Deadline
+from cinoc.domain.usage import ResourceUsage
+
+
+class RunContext(BaseModel):
+    """Contexte d'exécution d'une étape, pour un document donné.
+
+    Immuable. La ``Deadline`` se sérialise via ``remaining_seconds`` (cf.
+    ``domain.deadline``), donc reste transposable entre process.
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    document_id: str = Field(min_length=1, max_length=256)
+    code_version: str = Field(min_length=1, max_length=128)
+    pipeline_name: str = Field(min_length=1, max_length=128)
+    workspace_uri: str | None = Field(default=None, max_length=2048)
+    deadline: Deadline = Field(default_factory=Deadline.infinite)
+
+
+@dataclass(frozen=True)
+class StepOutput:
+    """Sortie d'un ``Module.execute`` : artefacts produits + consommation.
+
+    ``artifacts`` contient tous les ``output_types`` déclarés (contrat module).
+    ``usage`` ne porte que ce que le module **sait** (jetons d'un appel LLM) —
+    la durée de l'étape est mesurée par l'**exécuteur**, jamais par le module.
+    """
+
+    artifacts: Mapping[ArtifactType, Artifact]
+    usage: ResourceUsage | None = None
+
+
+@dataclass(frozen=True)
+class DocumentExecution:
+    """Résultat de l'exécution d'une pipeline sur **un** document.
+
+    ``artifacts`` est le pool final (dernier artefact par type) ; ``usage``
+    agrège durées et jetons de toutes les étapes (somme ``None``-tolérante).
+    """
+
+    artifacts: Mapping[ArtifactType, Artifact]
+    usage: ResourceUsage = field(default_factory=ResourceUsage)
+
+
+__all__ = ["DocumentExecution", "RunContext", "StepOutput"]
diff --git a/cinoc/prompts/__init__.py b/cinoc/prompts/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1b03711631233e39f3e0e2015ebe1c92a953bc8d
--- /dev/null
+++ b/cinoc/prompts/__init__.py
@@ -0,0 +1,53 @@
+"""Catalogue de **prompts curés par période** (DONNÉE, ≠ surface exécutable).
+
+16 prompts ``.txt`` empaquetés — **correction** (texte OCR → corrigé, placeholder
+``{ocr_text}``, modes ``text_only``/``text_and_image``) et **zero-shot** (image →
+texte, sans placeholder, mode ``zero_shot``), par type de document et langue
+(médiéval FR/EN, imprimé ancien, presse XIXe FR/EN/DE/européenne).
+
+Lus **dynamiquement** du paquet (jamais une liste statique — la leçon des profils
+de normalisation). La sélection (par nom) est résolue **au plan**
+(``app.run_planning``) → passée comme ``prompt`` à l'adapter LLM/VLM ; un **prompt
+libre** saisi par l'utilisateur reste prioritaire.
+"""
+
+from __future__ import annotations
+
+from importlib import resources
+
+from cinoc.domain.errors import CinocError
+
+_SUFFIX = ".txt"
+
+
+class PromptError(CinocError):
+    """Nom de prompt curé inconnu (jamais un défaut muet)."""
+
+
+def _names() -> list[str]:
+    """Noms (sans extension) des prompts ``.txt`` du paquet, triés."""
+    return sorted(
+        entry.name[: -len(_SUFFIX)]
+        for entry in resources.files(__name__).iterdir()
+        if entry.name.endswith(_SUFFIX)
+    )
+
+
+def available_prompts() -> tuple[str, ...]:
+    """Noms des prompts curés disponibles (reflètent le paquet, pas une liste figée)."""
+    return tuple(_names())
+
+
+def load_prompt(name: str) -> str:
+    """Texte du prompt curé ``name`` ; ``PromptError`` si inconnu."""
+    if name not in _names():
+        raise PromptError(f"prompt curé inconnu : {name!r}.")
+    return (
+        resources.files(__name__)
+        .joinpath(f"{name}{_SUFFIX}")
+        .read_text(encoding="utf-8")
+        .strip()
+    )
+
+
+__all__ = ["PromptError", "available_prompts", "load_prompt"]
diff --git a/cinoc/prompts/correction_early_modern_english.txt b/cinoc/prompts/correction_early_modern_english.txt
new file mode 100644
index 0000000000000000000000000000000000000000..370ea48b7740f8598adc6c1ddfbafc3ae3711d2e
--- /dev/null
+++ b/cinoc/prompts/correction_early_modern_english.txt
@@ -0,0 +1,21 @@
+You are an expert in Early Modern English language and typography (16th–18th century).
+
+You are provided with the raw output of an OCR engine applied to a printed or handwritten heritage document.
+Your task is to correct transcription errors based on:
+- The linguistic and typographical conventions of Early Modern English print
+- Typical OCR confusions on early printed books: long-s/f (ſ/f), u/v/n, i/j/1, vv/w, rn/m, ct/d
+- Early Modern spelling conventions: vpon, euery, giue, haue, Iesus, loue
+- Printers' conventions: catch-words, running titles, signatures, ornaments (ignore these)
+- Secretary hand features (if manuscript): ſ=s, u/v, i/j, vv=w, þ=th
+
+MANDATORY RULES:
+1. Return ONLY the corrected text — no commentary, no explanation, no markup
+2. Preserve the ORIGINAL Early Modern spelling faithfully: do NOT modernise
+   (vpon ≠ upon, euery ≠ every, giue ≠ give, loue ≠ love, ſaid ≠ said)
+3. Restore long-s (ſ) where OCR has rendered it as 'f' — check context carefully
+4. Restore thorn (þ) where present; restore 'ye' → 'þe' only if contextually clear
+5. Preserve original punctuation, italics markers, and capitalisation
+6. When in doubt about a passage, keep the OCR form rather than guessing
+
+RAW OCR:
+{ocr_text}
diff --git a/cinoc/prompts/correction_image_medieval_french.txt b/cinoc/prompts/correction_image_medieval_french.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2c1b35b61b894da7e87ac8f0ecdbec037bda20d5
--- /dev/null
+++ b/cinoc/prompts/correction_image_medieval_french.txt
@@ -0,0 +1,19 @@
+Tu es un expert en paléographie et en transcription de documents en français médiéval (XIIe–XVe siècle).
+
+On te fournit la sortie brute d'un moteur OCR ET l'image originale du document.
+Ta tâche est de corriger les erreurs de transcription en te basant sur :
+- L'image originale pour vérifier visuellement les passages ambigus
+- Le contexte linguistique et grammatical du français médiéval
+- Les confusions visuelles typiques de l'OCR sur documents anciens : rn/m, l/1, u/n, ſ/f, cl/d
+- Les abréviations et ligatures médiévales visibles sur l'image
+
+RÈGLES IMPÉRATIVES :
+1. Retourne UNIQUEMENT le texte corrigé — sans commentaire, sans explication, sans balise
+2. Conserve FIDÈLEMENT la graphie originale : ne modernise PAS l'orthographe
+   (nostre ≠ notre, faict ≠ fait, maistre ≠ maître, ledit ≠ le dit)
+3. Utilise l'image pour trancher les cas ambigus — pas pour « améliorer » le style
+4. Conserve la ponctuation et la capitalisation d'origine
+5. En cas de passage illisible sur l'image, conserve la forme OCR avec [?]
+
+OCR BRUT :
+{ocr_text}
diff --git a/cinoc/prompts/correction_image_press_19c_english.txt b/cinoc/prompts/correction_image_press_19c_english.txt
new file mode 100644
index 0000000000000000000000000000000000000000..20205317ef0132bab55d31864f5bca6407a47460
--- /dev/null
+++ b/cinoc/prompts/correction_image_press_19c_english.txt
@@ -0,0 +1,20 @@
+You are an expert in press history and the transcription of 19th-century English-language newspapers and periodicals (1800–1914).
+
+You are provided with the raw output of an OCR engine AND the original image of the newspaper page.
+Your task is to correct transcription errors based on:
+- The original image to visually resolve broken type, faded ink, show-through from the verso, and lines bleeding in from an adjacent column
+- Typical OCR confusions on degraded type: rn/m, cl/d, li/h, vv/w, e/c, ii/u, long-s/f (ſ/f) in early-century printing
+- End-of-line and end-of-column hyphenation: words split by a hyphen, rejoined by checking the continuation on the image
+- Journalistic abbreviations: Mr., Mrs., Messrs., St., Co., &c., No., £ s. d.
+- Structural furniture (masthead, running heads, date line, issue number) kept verbatim
+
+MANDATORY RULES:
+1. Return ONLY the corrected text — no commentary, no explanation, no markup
+2. Preserve the ORIGINAL period spelling faithfully: do NOT modernise ("to-day", "shew", "connexion", "honour")
+3. Use the image to settle ambiguous cases — not to "improve" the style nor to complete a sentence cut off by the column
+4. Rejoin words broken by hyphenation; do NOT remove legitimate hyphens
+5. Preserve original punctuation and capitalisation
+6. Where a passage is illegible on the image, keep the OCR form with [?]
+
+RAW OCR:
+{ocr_text}
diff --git a/cinoc/prompts/correction_image_press_19c_european.txt b/cinoc/prompts/correction_image_press_19c_european.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2df515acb20287900c3d8ea4d45724cc06ba64a9
--- /dev/null
+++ b/cinoc/prompts/correction_image_press_19c_european.txt
@@ -0,0 +1,20 @@
+Tu es un expert en presse européenne du XIXe siècle et en transcription de journaux multilingues (1800–1914) : français, anglais, allemand, italien, espagnol, néerlandais.
+
+On te fournit la sortie brute d'un moteur OCR ET l'image originale d'une page de presse pouvant mêler plusieurs langues.
+Ta tâche est de corriger les erreurs de transcription en te basant sur :
+- L'image originale pour trancher les caractères cassés, l'encre passée et les colonnes intercalées
+- L'identification de la langue de CHAQUE segment, sans jamais traduire ni uniformiser
+- Les conventions typographiques propres à chaque aire (ſ long et Fraktur en allemand, accents romans, tréma néerlandais, guillemets variables)
+- La césure de fin de ligne/colonne à recoller, langue par langue, en vérifiant la suite sur l'image
+- Les changements de langue en cours d'article : ne pas corriger un mot étranger vers la langue dominante
+
+RÈGLES IMPÉRATIVES :
+1. Retourne UNIQUEMENT le texte corrigé — sans commentaire, sans explication, sans balise, sans annotation de langue
+2. Conserve FIDÈLEMENT l'orthographe d'époque de CHAQUE langue : ne modernise ni ne traduis
+3. Utilise l'image pour trancher les cas ambigus — pas pour harmoniser les langues ni compléter une coupe de colonne
+4. Recolle les mots coupés par césure en respectant la langue du mot ; garde les traits d'union légitimes
+5. Conserve la ponctuation, les guillemets et la casse propres à chaque langue
+6. En cas de passage illisible sur l'image, conserve la forme OCR avec [?]
+
+OCR BRUT :
+{ocr_text}
diff --git a/cinoc/prompts/correction_image_press_19c_french.txt b/cinoc/prompts/correction_image_press_19c_french.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a52e3bbf50489bc755892a52af5250db4c726b5b
--- /dev/null
+++ b/cinoc/prompts/correction_image_press_19c_french.txt
@@ -0,0 +1,20 @@
+Tu es un expert en histoire de la presse et en transcription de journaux et périodiques français du XIXe siècle (1800–1914).
+
+On te fournit la sortie brute d'un moteur OCR ET l'image originale de la page de presse.
+Ta tâche est de corriger les erreurs de transcription en te basant sur :
+- L'image originale pour trancher visuellement les caractères cassés, l'encre passée, la transparence du verso et les colonnes voisines intercalées
+- Les confusions OCR typiques sur fontes dégradées : rn/m, cl/d, ii/u, li/h, vv/w, accents perdus, ſ/f en début de siècle
+- La césure de fin de ligne et de colonne : mots coupés par un trait d'union, à recoller en vérifiant la suite sur l'image
+- Les abréviations journalistiques : M., Mme, MM., St, Cie, &c., n°, fr., c.
+- Les éléments de structure (manchette, titres courants, datation, numéro) conservés tels quels
+
+RÈGLES IMPÉRATIVES :
+1. Retourne UNIQUEMENT le texte corrigé — sans commentaire, sans explication, sans balise
+2. Conserve FIDÈLEMENT l'orthographe de l'époque : ne modernise PAS (j'avois, enfans, poëte, tems)
+3. Utilise l'image pour trancher les cas ambigus — pas pour « améliorer » le style ni compléter une phrase coupée par la colonne
+4. Recolle les mots coupés par césure ; ne supprime pas les traits d'union légitimes
+5. Conserve la ponctuation et la capitalisation d'origine
+6. En cas de passage illisible sur l'image, conserve la forme OCR avec [?]
+
+OCR BRUT :
+{ocr_text}
diff --git a/cinoc/prompts/correction_image_press_19c_german.txt b/cinoc/prompts/correction_image_press_19c_german.txt
new file mode 100644
index 0000000000000000000000000000000000000000..831eb1dd49d4e0006b019c5104dc52a5b8d572e3
--- /dev/null
+++ b/cinoc/prompts/correction_image_press_19c_german.txt
@@ -0,0 +1,20 @@
+Du bist Experte für Pressegeschichte und die Transkription deutschsprachiger Zeitungen und Zeitschriften des 19. Jahrhunderts (1800–1914), überwiegend in Fraktur.
+
+Dir werden die Rohausgabe einer OCR-Maschine UND das Originalbild der Zeitungsseite vorgelegt.
+Deine Aufgabe ist es, Transkriptionsfehler zu korrigieren, gestützt auf:
+- Das Originalbild, um gebrochene Lettern, blasse Farbe, Durchschlagen des Verso und eingestreute Nachbarspalten visuell zu klären
+- Die Eigenheiten des Fraktursatzes: langes ſ vs. rundes s, ſ/f, ſch/fch, k/t, B/V, Ligaturen ch, ck, tz, ſt
+- Umlaute (ä/ö/ü, ae/oe/ue, übergesetztes e) und ß vs. ſſ/ss
+- Trennung am Zeilen-/Spaltenende: getrennte Wörter wieder zusammenfügen, Fortsetzung am Bild prüfen
+- Journalistische Abkürzungen: Hr., Fr., Nr., d. M., u. s. w., ℳ, Sgr., Pf.
+
+ZWINGENDE REGELN:
+1. Gib AUSSCHLIESSLICH den korrigierten Text zurück — ohne Kommentar, ohne Erklärung, ohne Auszeichnung
+2. Bewahre die ZEITGENÖSSISCHE Orthographie getreu: NICHT modernisieren („Thür", „Theil", „giebt", „seyn")
+3. Nutze das Bild zur Klärung mehrdeutiger Stellen — nicht zur Stilverbesserung und nicht, um einen durch Spaltenumbruch abgeschnittenen Satz zu vervollständigen
+4. Füge getrennte Wörter wieder zusammen; entferne KEINE berechtigten Bindestriche
+5. Bewahre Interpunktion sowie Groß- und Kleinschreibung
+6. Ist eine Stelle im Bild unleserlich, behalte die OCR-Form mit [?]
+
+ROHE OCR:
+{ocr_text}
diff --git a/cinoc/prompts/correction_imprime_ancien.txt b/cinoc/prompts/correction_imprime_ancien.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9260fb767a893ad7e43d038aa59f4218fa92e9bd
--- /dev/null
+++ b/cinoc/prompts/correction_imprime_ancien.txt
@@ -0,0 +1,20 @@
+Tu es un expert en typographie historique et en transcription d'imprimés anciens (XVe–XVIIIe siècle).
+
+On te fournit la sortie brute d'un moteur OCR appliqué à un imprimé ancien.
+Ta tâche est de corriger les erreurs de transcription en te basant sur :
+- Les conventions typographiques de l'imprimerie ancienne
+- L'usage du s long (ſ) en position initiale et médiane (ſon, maiſon, diſcours)
+- Les ligatures typographiques : fi, fl, ff, ffi, ffl, st, ct, ſt
+- Les confusions de fontes : romain/italique, capitales ornées
+- Les caractères spéciaux : & (et), ꝛ (r rotunda), ÿ, j/i, u/v
+
+RÈGLES IMPÉRATIVES :
+1. Retourne UNIQUEMENT le texte corrigé — sans commentaire, sans explication, sans balise
+2. Conserve la graphie de l'époque : ne modernise PAS l'orthographe
+   (ſon ≠ son seulement si l'OCR a mal transcrit ; conſeil ≠ conseil)
+3. Respecte les réclames (mots répétés en bas de page/colonne) tels quels
+4. Conserve les chiffres romains, foliotation et pagination d'origine
+5. En cas de doute sur un passage, conserve la forme OCR plutôt que d'inventer
+
+OCR BRUT :
+{ocr_text}
diff --git a/cinoc/prompts/correction_medieval_english.txt b/cinoc/prompts/correction_medieval_english.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a3c337f6778d6343d0b47f0cc1836038aa86160a
--- /dev/null
+++ b/cinoc/prompts/correction_medieval_english.txt
@@ -0,0 +1,20 @@
+You are an expert in medieval English language and palaeography (12th–15th century).
+
+You are provided with the raw output of an OCR engine applied to a heritage manuscript.
+Your task is to correct transcription errors based on:
+- The linguistic and grammatical context of Middle English
+- Typical visual OCR confusions on historical documents: rn/m, l/1, u/n, ſ/f, cl/d, ri/n, ii/u
+- Common manuscript abbreviations: ꝑ (per/par), ꝓ (pro), q̃ (que/quod), p̃ (pre), þ (thorn/th), ȝ (yogh/y/gh)
+- Frequent letterforms: thorn (þ), eth (ð), yogh (ȝ), long-s (ſ), tironian et (&)
+
+MANDATORY RULES:
+1. Return ONLY the corrected text — no commentary, no explanation, no markup
+2. Preserve the ORIGINAL medieval spelling faithfully: do NOT modernise the orthography
+   (vpon ≠ upon, heuene ≠ heaven, knyght ≠ knight, þe ≠ the, ȝe ≠ ye)
+3. Preserve original punctuation and capitalisation
+4. When in doubt about a passage, keep the OCR form rather than guessing
+5. Restore thorn (þ) and eth (ð) where OCR has rendered them as 'p', 'b', or 'd'
+6. Restore yogh (ȝ) where OCR has rendered it as '3', 'z', or 'g'
+
+RAW OCR:
+{ocr_text}
diff --git a/cinoc/prompts/correction_medieval_french.txt b/cinoc/prompts/correction_medieval_french.txt
new file mode 100644
index 0000000000000000000000000000000000000000..64b0a4e8f812bf1c3b5bc9c027c11e6e5325f2d8
--- /dev/null
+++ b/cinoc/prompts/correction_medieval_french.txt
@@ -0,0 +1,18 @@
+Tu es un expert en paléographie et en transcription de documents en français médiéval (XIIe–XVe siècle).
+
+On te fournit la sortie brute d'un moteur OCR appliqué à un document patrimonial.
+Ta tâche est de corriger les erreurs de transcription en te basant sur :
+- Le contexte linguistique et grammatical du français médiéval
+- Les confusions visuelles typiques de l'OCR sur documents anciens : rn/m, l/1, u/n, ſ/f, cl/d, ri/n, ii/u
+- Les abréviations courantes : ꝑ (per/par), ꝓ (pro), q̃ (que), p̃ (pre), ā (an), m̃ (men)
+- Les ligatures fréquentes : ct, st, fi, fl, ff, œ, æ
+
+RÈGLES IMPÉRATIVES :
+1. Retourne UNIQUEMENT le texte corrigé — sans commentaire, sans explication, sans balise
+2. Conserve FIDÈLEMENT la graphie originale : ne modernise PAS l'orthographe
+   (nostre ≠ notre, faict ≠ fait, ledit ≠ le dit, maistre ≠ maître)
+3. Conserve la ponctuation et la capitalisation d'origine
+4. En cas de doute sur un passage, conserve la forme OCR plutôt que d'inventer
+
+OCR BRUT :
+{ocr_text}
diff --git a/cinoc/prompts/correction_press_19c_english.txt b/cinoc/prompts/correction_press_19c_english.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5bedd21d3c764d9675aa95f462d9aa7b5ce72d0f
--- /dev/null
+++ b/cinoc/prompts/correction_press_19c_english.txt
@@ -0,0 +1,22 @@
+You are an expert in press history and the transcription of 19th-century English-language newspapers and periodicals (1800–1914).
+
+You are provided with the raw output of an OCR engine applied to a heritage newspaper page, most often digitised from microfilm.
+Your task is to correct transcription errors based on:
+- The material constraints of 19th-century press: acidic paper, faded ink, show-through from the verso, worn or broken type
+- The dense multi-column layout: lines bleeding in from an adjacent column, vertical column rules misread as 'I', 'l' or '|'
+- Typical OCR confusions on degraded type: rn/m, cl/d, li/h, vv/w, e/c, ii/u, and long-s/f (ſ/f) in early-century printing
+- End-of-line and end-of-column hyphenation: words split by a hyphen that must be rejoined
+- Journalistic abbreviations: Mr., Mrs., Messrs., St., Co., &c. (= etc.), No., £ s. d. (pounds/shillings/pence), per cent.
+- Structural furniture to keep verbatim: masthead, running heads, date line, issue number, by-lines
+
+MANDATORY RULES:
+1. Return ONLY the corrected text — no commentary, no explanation, no markup
+2. Preserve the ORIGINAL period spelling and usage faithfully: do NOT modernise
+   ("to-day", "to-morrow", "shew", "connexion", "honour" where the source has them)
+3. Rejoin words broken by end-of-line/column hyphenation ("govern-/ment" → "government"), but do NOT remove legitimate hyphens ("well-known")
+4. Preserve original punctuation and capitalisation
+5. Do NOT invent text to "complete" a sentence cut off by a column break: keep what the OCR provides
+6. When in doubt about a passage, keep the OCR form rather than guessing
+
+RAW OCR:
+{ocr_text}
diff --git a/cinoc/prompts/correction_press_19c_european.txt b/cinoc/prompts/correction_press_19c_european.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c62d7ad870d569bda5deca2e63cdbc6b153c3010
--- /dev/null
+++ b/cinoc/prompts/correction_press_19c_european.txt
@@ -0,0 +1,20 @@
+Tu es un expert en presse européenne du XIXe siècle et en transcription de journaux multilingues (1800–1914), couvrant notamment le français, l'anglais, l'allemand, l'italien, l'espagnol et le néerlandais.
+
+On te fournit la sortie brute d'un moteur OCR appliqué à une page de presse ancienne pouvant mêler plusieurs langues : titres, dépêches télégraphiques étrangères, annonces, citations, sections bilingues.
+Ta tâche est de corriger les erreurs de transcription en te basant sur :
+- L'identification de la langue de CHAQUE segment, sans jamais traduire ni uniformiser : chaque passage reste dans sa langue d'origine
+- Les conventions typographiques propres à chaque aire : ſ long et Fraktur pour l'allemand, accents romans (à/è/ì/ò/ù, ñ, ç), tréma néerlandais, guillemets variables (« », „ ", " ")
+- Les contraintes matérielles de la presse XIXe : encre passée, transparence du verso, caractères cassés, bruit du microfilm
+- La mise en page multi-colonnes et la césure de fin de ligne/colonne à recoller, langue par langue
+- Les changements de langue en cours d'article (citations, dépêches) : ne pas « corriger » un mot étranger vers la langue dominante de la page
+
+RÈGLES IMPÉRATIVES :
+1. Retourne UNIQUEMENT le texte corrigé — sans commentaire, sans explication, sans balise, sans annotation de langue
+2. Conserve FIDÈLEMENT l'orthographe d'époque de CHAQUE langue : ne modernise ni ne traduis aucun passage
+3. Recolle les mots coupés par césure en respectant la langue du mot ; ne supprime pas les traits d'union légitimes
+4. Conserve la ponctuation, les guillemets, les capitales et la casse propres à chaque langue
+5. N'harmonise PAS les langues entre elles et n'invente aucun texte pour combler une coupe de colonne
+6. En cas de doute sur un passage ou sa langue, conserve la forme OCR plutôt que d'inventer
+
+OCR BRUT :
+{ocr_text}
diff --git a/cinoc/prompts/correction_press_19c_french.txt b/cinoc/prompts/correction_press_19c_french.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d3533a62daf5ea15ccee006c38bb932fb4754c4a
--- /dev/null
+++ b/cinoc/prompts/correction_press_19c_french.txt
@@ -0,0 +1,22 @@
+Tu es un expert en histoire de la presse et en transcription de journaux et périodiques français du XIXe siècle (1800–1914).
+
+On te fournit la sortie brute d'un moteur OCR appliqué à une page de presse ancienne, le plus souvent numérisée depuis microfilm.
+Ta tâche est de corriger les erreurs de transcription en te basant sur :
+- Les contraintes matérielles de la presse XIXe : papier acide, encre passée, transparence du verso, caractères usés ou cassés
+- La mise en page multi-colonnes : lignes d'une colonne voisine intercalées, filets verticaux lus comme « I », « l » ou « | »
+- Les confusions OCR typiques sur fontes dégradées : rn/m, cl/d, ii/u, li/h, vv/w, e/c, accents perdus ou erronés, ſ/f dans les impressions du début du siècle
+- La césure de fin de ligne et de colonne : mots coupés par un trait d'union à recoller
+- Les abréviations journalistiques : M., Mme, MM., St, Cie, &c. (= etc.), n°, fr. (francs), c. (centimes)
+- Les éléments de structure à conserver tels quels : manchette, titres courants, datation, numéro de livraison, signatures d'articles
+
+RÈGLES IMPÉRATIVES :
+1. Retourne UNIQUEMENT le texte corrigé — sans commentaire, sans explication, sans balise
+2. Conserve FIDÈLEMENT l'orthographe de l'époque : ne modernise PAS
+   (j'avois, enfans, poëte, tems selon l'usage du texte)
+3. Recolle les mots coupés en fin de ligne/colonne par césure (« gouverne-/ment » → « gouvernement »), mais NE supprime PAS les traits d'union légitimes (« arc-en-ciel »)
+4. Conserve la ponctuation, les capitales et la casse d'origine
+5. N'invente aucun texte pour « boucler » une phrase tronquée par la coupe de colonne : conserve ce que l'OCR donne
+6. En cas de doute sur un passage, conserve la forme OCR plutôt que d'inventer
+
+OCR BRUT :
+{ocr_text}
diff --git a/cinoc/prompts/correction_press_19c_german.txt b/cinoc/prompts/correction_press_19c_german.txt
new file mode 100644
index 0000000000000000000000000000000000000000..52d7ac746d02509173a455f2d08fac092d5efdaa
--- /dev/null
+++ b/cinoc/prompts/correction_press_19c_german.txt
@@ -0,0 +1,21 @@
+Du bist Experte für Pressegeschichte und die Transkription deutschsprachiger Zeitungen und Zeitschriften des 19. Jahrhunderts (1800–1914), überwiegend in Fraktur gesetzt.
+
+Dir wird die Rohausgabe einer OCR-Maschine vorgelegt, angewandt auf eine historische Zeitungsseite, meist von Mikrofilm digitalisiert.
+Deine Aufgabe ist es, Transkriptionsfehler zu korrigieren, gestützt auf:
+- Die Eigenheiten des Fraktursatzes: langes ſ vs. rundes s, ſ/f-Verwechslung, ſch/fch, k/t, B/V, Ligaturen ch, ck, tz, ſt, ſi
+- Umlaut-Schreibung der Zeit: ä/ö/ü oder ae/oe/ue, übergesetztes e, ß vs. ſſ/ss
+- Materielle Mängel der Presse des 19. Jh.: vergilbtes Papier, blasse Farbe, Durchschlagen des Verso, abgenutzte oder gebrochene Lettern
+- Mehrspaltiges Layout: eingestreute Zeilen aus der Nachbarspalte, Spaltenlinien als „I", „l" oder „|" fehlgelesen
+- Trennung am Zeilen- und Spaltenende: durch Bindestrich getrennte Wörter sind wieder zusammenzufügen
+- Journalistische Abkürzungen: Hr., Fr., Frl., Nr., d. M. (dieses Monats), u. s. w., ℳ (Mark), Sgr., Pf.
+
+ZWINGENDE REGELN:
+1. Gib AUSSCHLIESSLICH den korrigierten Text zurück — ohne Kommentar, ohne Erklärung, ohne Auszeichnung
+2. Bewahre die ZEITGENÖSSISCHE Orthographie getreu: NICHT modernisieren („Thür", „Theil", „giebt", „seyn" je nach Vorlage)
+3. Füge am Zeilen-/Spaltenende getrennte Wörter wieder zusammen („Regie-/rung" → „Regierung"), entferne aber KEINE berechtigten Bindestriche
+4. Bewahre Interpunktion sowie Groß- und Kleinschreibung
+5. Erfinde KEINEN Text, um einen durch Spaltenumbruch abgeschnittenen Satz zu „vervollständigen": behalte die OCR-Form
+6. Im Zweifelsfall behalte die OCR-Form, statt zu raten
+
+ROHE OCR:
+{ocr_text}
diff --git a/cinoc/prompts/zero_shot_imprime_ancien.txt b/cinoc/prompts/zero_shot_imprime_ancien.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c56b1198095c6e70b8089c08ad9257add94724e2
--- /dev/null
+++ b/cinoc/prompts/zero_shot_imprime_ancien.txt
@@ -0,0 +1,18 @@
+Tu es un expert en typographie historique et en transcription d'imprimés anciens (XVe–XVIIIe siècle).
+
+On te fournit l'image d'une page d'imprimé ancien (incunable, livre du XVIe–XVIIIe siècle).
+Ta tâche est de transcrire fidèlement le texte imprimé visible sur l'image.
+
+RÈGLES IMPÉRATIVES :
+1. Retourne UNIQUEMENT la transcription — sans commentaire, sans titre, sans balise
+2. Conserve les conventions typographiques de l'époque :
+   - s long (ſ) en position initiale et médiane : ſon, maiſon, diſcours
+   - ligatures typographiques : fi, fl, ff, ffi, ffl, st, ct
+   - & pour et, ÿ, j/i interchangeables selon l'époque
+3. Respecte la mise en page : colonnes, titres courants, réclames, foliotation
+4. Conserve la capitalisation d'origine — ne la normalise pas
+5. Signale les passages illisibles par [illisible] plutôt que d'inventer
+6. Transcris les chiffres romains tels quels (iij, xiij, MCCCLx…)
+
+Image (base64) :
+{image_b64}
diff --git a/cinoc/prompts/zero_shot_medieval_english.txt b/cinoc/prompts/zero_shot_medieval_english.txt
new file mode 100644
index 0000000000000000000000000000000000000000..70ff9828ba52c3d229d364ec7a5c20b642cf0290
--- /dev/null
+++ b/cinoc/prompts/zero_shot_medieval_english.txt
@@ -0,0 +1,20 @@
+You are an expert palaeographer specialised in the transcription of medieval English manuscripts (12th–15th century).
+
+You are provided with the image of a folio or page from a heritage document.
+Your task is to faithfully transcribe the text visible in the image.
+
+MANDATORY RULES:
+1. Return ONLY the transcription — no commentary, no title, no markup
+2. Preserve the exact medieval spelling: do NOT modernise the orthography
+   (þe, ȝe, vpon, ioy, heuene, knyght, …)
+3. Preserve abbreviations as they appear on the document
+   (use standard expansion marks where the original uses them)
+4. Preserve line breaks and the structure of the original text
+5. Mark illegible passages as [illegible] rather than guessing
+6. Transcribe only the main text — ignore late marginal annotations
+   unless they form part of the current text
+7. Preserve letterforms: thorn (þ), eth (ð), yogh (ȝ), long-s (ſ), and
+   manuscript abbreviation characters as written
+
+Image (base64):
+{image_b64}
diff --git a/cinoc/prompts/zero_shot_medieval_french.txt b/cinoc/prompts/zero_shot_medieval_french.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3aeb8d2a43b96e890e1d005aecaef4a42b58ad13
--- /dev/null
+++ b/cinoc/prompts/zero_shot_medieval_french.txt
@@ -0,0 +1,17 @@
+Tu es un expert en paléographie médiévale spécialisé dans la transcription de manuscrits en français médiéval (XIIe–XVe siècle).
+
+On te fournit l'image d'un folio ou d'une page de document patrimonial.
+Ta tâche est de transcrire fidèlement le texte visible sur l'image.
+
+RÈGLES IMPÉRATIVES :
+1. Retourne UNIQUEMENT la transcription — sans commentaire, sans titre, sans balise
+2. Conserve la graphie médiévale exacte : ne modernise PAS l'orthographe
+   (nostre, maistre, faict, ledit, &, ꝑ, ꝓ…)
+3. Respecte les abréviations telles qu'elles apparaissent sur le document
+4. Conserve les sauts de ligne et la structure du texte original
+5. Signale les passages illisibles par [illisible] plutôt que d'inventer
+6. Ne transcris que le texte principal — ignore les annotations marginales tardives
+   sauf si elles font partie du texte courant
+
+Image (base64) :
+{image_b64}
diff --git a/cinoc/reports/ANALYSE_COUCHE_7.md b/cinoc/reports/ANALYSE_COUCHE_7.md
new file mode 100644
index 0000000000000000000000000000000000000000..4cde4a3f18c5a35ff5324b3bc1448fd5fb8770c3
--- /dev/null
+++ b/cinoc/reports/ANALYSE_COUCHE_7.md
@@ -0,0 +1,319 @@
+# ANALYSE_COUCHE_7.md — `reports/` (Picarones → Cinoc)
+
+> **Type** : session d'ANALYSE (guide de portage **durable**). **Aucun code Cinoc écrit.**
+> **Couche** : 7 = `reports` dans `domain(1) ← formats(2) ← evaluation(3) ← pipeline(4) ← adapters(5) ← app(6) ← reports(7) ← interfaces(8)`.
+> **Source gelée** : `../Picarones/picarones/reports/` — **91 fichiers Python / 17 726 LOC**, + **3 423 LOC JS**, **2 948 LOC CSS**, **1 117 LOC HTML/J2**, **2 380 LOC data (i18n/glossary)**, + `chart.umd.min.js` vendorisé (208 KB). **Total ≈ 27 600 LOC** — la plus grosse couche du projet.
+> **Couches amont mergées dont on dépend** : `domain` (mergée), `formats` (mergée), `evaluation` (plan `MIGRATION_COUCHE_3.md`), `pipeline` (analyse `ANALYSE_COUCHE_4.md`), `adapters` (analyse `ANALYSE_COUCHE_5.md`), `app` (analyse `ANALYSE_COUCHE_6.md`).
+> **Méthode** : 6 sous-agents d'exploration en parallèle (orchestration · data-layer · renderers A · renderers B · charts/views/helpers · narrative/templates) **+ recoupement personnel des points décisifs dans le code** (types d'entrée, signatures, ré-agrégation, charting, accroches narrative). **Une erreur d'agent corrigée** par recoupement : Chart.js déclaré « mort » à tort — il est **vivant** (cf. §1.4-E).
+> **Partie 1 = durable** (source figée). **Partie 2 = périssable** (« à confirmer à la tranche »). Verdicts **PROVISOIRE — à confirmer au build**.
+
+---
+
+## PARTIE 0 — Vérification anti-contradiction (obligatoire)
+
+Aucune conclusion ne contredit `CLAUDE.md` ni une couche mergée/planifiée. L'analyse **confirme dans le code** quatre décisions déjà actées :
+
+| Décision actée (où) | Confirmé dans le code Picarones (preuve) |
+|---|---|
+| **Moteur narratif SUPPRIMÉ entièrement** (`CLAUDE.md` §6/D2) | `reports/narrative/` = 2 162 LOC, **feuille du DAG** (n'importe que `domain.facts`) ; **3 accroches** seulement (`generator.py:254-255`, `web/routers/synthesis.py`, `domain/__init__` ré-exports `Fact*`). Suppression chirurgicale. |
+| **Renderers HTML sans interface commune → un `Protocol Section`** (`CLAUDE.md` §8.2) | `section_registry.py:50` `ArgKind = Literal["report","engines","subkey","custom"]` → **4 signatures** réelles ; 37 renderers (8 167 LOC). Confirmé. |
+| **Data-layer qui ré-agrège `evaluation/` → consommer `RunResult` direct** (`CLAUDE.md` §8.3) | `html/data/` ré-agrège : `statistics.py:41` reconstruit les listes CER + recalcule Friedman/Nemenyi/bootstrap ; `pareto.py:66` recalcule `sum(durs)/len(durs)` ; `:104` recalcule 3 fronts Pareto. Anti-pattern confirmé. |
+| **`RunResult` = format unique, reports le lit direct** (`MIGRATION_COUCHE_3.md` §8/§9 ; `ANALYSE_COUCHE_6.md` L62-65) | Picarones est **en mi-migration** : `render.py`/`csv`/`json` consomment **déjà `RunResult`** ; le gros `generator.py:137` consomme encore `BenchmarkResult`. La ligne de partage du portage est **déjà tracée dans la source** (cf. §1.2). |
+
+> **Note de placement (vérifiée, pas de contradiction)** : `ReportRenderer` (Callable) vit dans `pipeline/run_result.py` en source **par contournement d'un import illégal `reports→app`** (`ANALYSE_COUCHE_4.md` L107). En Cinoc il appartient à la frontière `app`/`reports` (app **injecte** un renderer). `reports` ne dépend que de couches internes — **jamais** `app`/`interfaces` (vérifié : 0 import `app.`/`interfaces.` dans tout `reports/`). Direction de couche **saine**.
+
+---
+
+# PARTIE 1 — ANALYSE DE LA SOURCE PICARONES (durable)
+
+## 1.1 Inventaire exact (91 py / 17 726 LOC + assets)
+
+| Sous-paquet | Fichiers | LOC py | Rôle vérifié |
+|---|---:|---:|---|
+| **`/`** (`__init__.py`) | 1 | 26 | Docstring de couche. Docstring **aspirationnelle** : promet « consomme `RunManifest`+`view_results.jsonl` » — **faux** pour le chemin réel (`generator` lit `BenchmarkResult`). |
+| **`html/`** (orchestration) | 6 | **2 196** | `generator`(458, legacy) · `render`(643, propre) · `section_registry`(379) · `comparison`(409) · `snapshot`(280) · `__init__`(27). **Deux chemins** (§1.2). |
+| **`html/data/`** (data-layer) | 9 | **1 614** | Construit `report_data: dict` pour les templates ; **ré-agrège l'évaluation** (stats, pareto, difficulté, métriques extra). Entrée = `BenchmarkResult`. |
+| **`html/renderers/`** | 37 | **8 167** | Le **gros morceau**. Chaque renderer = `build_*_html(...) → str`. 4 signatures (§1.4-A). 7-8 domaines (§1.5). |
+| **`html/renderers/charts/`** | 8 | **1 056** | Graphiques **SVG/HTML côté serveur** (radar, venn, cer_distribution, confusion_unicode, correlation, wilcoxon, `_svg` helpers). Déterministes. |
+| **`html/views/`** | 6 | **1 053** | **Orchestrateurs** : une *view* compose N *renderers* via lazy-import + shell `<details>` partagé (`_render_view_shell`). Masquage adaptatif corpus-wide. |
+| **`_helpers/`** | 6 | **1 019** | `render_helpers`(422, coloration cellules) · `engine_palette`(183) · `engine_badges`(121) · `colors`(76) · `assets`(203, inline image+vendor JS) · `__init__`. |
+| **`narrative/`** (+`detectors/`) | 12 | **2 162** | Moteur narratif (arbiter, registry, renderer, 20 détecteurs). **SUPPRIMÉ** (D2). Feuille (n'importe que `domain.facts`). |
+| **`csv/`** | 2 | 131 | `CsvReportRenderer.render(RunResult)` → 1 ligne/(doc,vue,métrique). **Propre.** |
+| **`json/`** | 2 | 114 | `JsonReportRenderer.render(RunResult)` → dict consolidé déterministe. **Propre.** |
+| **`i18n/`** | 1 | 128 | `get_labels(lang)` ; **635 clés × 2 langues** (fr/en, **1 274 LOC json**). Importé par **`generator.py` seul**, puis threadé en `labels`. |
+| **`glossary/`** | 1 | 60 | `load_glossary(lang)` ; **25 termes × 2** (**878 LOC yaml**). Consommé **côté template (UI)** uniquement, jamais par du Python. |
+| **Assets** (`templates/`, `vendor/`) | — | — | **3 423 LOC JS** (`_app.js` 2 588 + routing/compare/tables/documents) · **2 948 LOC CSS** (`_styles.css` 2 735 + `_design_tokens` 213) · **1 117 LOC HTML/J2** (16 fichiers) · `chart.umd.min.js` 208 KB. |
+
+## 1.2 LE fait décisif : deux chemins de rapport HTML parallèles (vérifié)
+
+La source documente **elle-même** la dualité (`render.py:9-11`) :
+
+| Chemin | Entrée | Moteur | Surface mobilisée | Statut |
+|---|---|---|---|---|
+| **Legacy** `generator.ReportGenerator` (`generator.py:137`) | **`BenchmarkResult`** | **Jinja2** (`base.html.j2`) | data-layer (ré-agrège) + 37 renderers + 6 views + charts SVG **+ Chart.js client** + narrative + snapshots + i18n + SPA JS/CSS | **chemin vivant** (CLI/web l'utilisent via conversion `RunResult→BenchmarkResult`) |
+| **Propre** `render.HtmlReportRenderer` (`render.py:197`) | **`RunResult`** | **f-strings** (zéro Jinja2) | minimal, **lit `RunResult` direct**, **zéro ré-agrégation** | germe naissant (peu de sections) |
+| **Propre** `csv` / `json` (`render.py:69/57`) | **`RunResult`** | stdlib | sérialisation déterministe verbatim | **déjà propres** |
+
+**C'est exactement la ligne de partage du portage.** Le chemin `RunResult`-direct (`render`/`csv`/`json`) est le **germe** de Cinoc ; le chemin `BenchmarkResult` + data-layer + 37 renderers + Jinja2 + SPA est la **masse accrétée** à ne **pas** reporter en bloc. La conversion `RunResult→BenchmarkResult` (couche 6) **n'existe que pour nourrir les renderers legacy** (`ANALYSE_COUCHE_6.md` L62-65) → elle disparaît avec eux.
+
+## 1.3 Consommateurs réels & couplages (grep hors `tests/`)
+
+| Symbole `reports/` | Consommateur (couche) | Note |
+|---|---|---|
+| `html.generator.ReportGenerator` | `interfaces/cli/__init__.py:307,394`, `cli/_workflows.py:599`, `web/benchmark_utils.py:558` | chemin legacy ; reçoit un `BenchmarkResult` (converti depuis `RunResult`) |
+| `html.comparison.compare_benchmarks` | `interfaces/cli/_workflows.py:850` | commande `compare` (lit du JSON de run) |
+| `narrative.build_synthesis` | `interfaces/web/routers/synthesis.py:101` | **disparaît** (narratif supprimé) |
+| `csv`/`json`/`render` (RunResult) | (peu câblé en prod — germe) | chemin propre |
+
+**Couplage de couche** : `reports/` n'importe **que** des couches internes — `domain` (`evaluation_spec`, `run_manifest`), `evaluation` (`benchmark_result`, `statistics`, `metrics.*`, `views`), `pipeline` (`run_result.RunResult`/`PipelineResult`). **0 import `app.`/`interfaces.`** → direction saine, **à préserver** (en Cinoc, `RunResult` migrant en `evaluation/`, reports lira la couche 3, pas la 4).
+
+## 1.4 Constats transverses durables (vérifiés dans le code)
+
+| # | Constat | Preuve (file:line) |
+|---|---|---|
+| **A** | **4 signatures de renderers** (= la dette « pas d'interface commune »). `report` : `fn(report_data, labels)` (~25) · `engines` : `fn(engines, labels)` (~4) · `subkey` : `fn(report_data[k], labels)` (~5) · `custom` : multi-args exotiques gérés hors registre (~6, ex. `build_crosses_section_html(report_data, labels, divergence_html, oracle_html, …)`). | `section_registry.py:50,81` ; `build_standard_sections` **ignore** `custom` (`:338`), géré à la main dans `generator._build_section_html`. |
+| **B** | **Data-layer ré-agrège l'évaluation** (recalcul à chaque rendu, pas une lecture). `statistics`(stats inférentielles), `pareto`(moyennes+fronts), `documents`(difficulté), `extra_metrics`(rare-token/taxo/coût). `engines`/`scatter` sont, eux, **lecture pure**. | `statistics.py:41` `for dr in report.document_results` + `:26` `friedman_test`/`nemenyi_posthoc` ; `pareto.py:66,104`. |
+| **C** | **Renderers qui recalculent** au lieu d'afficher. | `crosses.py:537-551` (rebuild 4 scatters) ; `specialization.py:51-54` (`compute_specialization_matrix`) ; `worst_lines.py:169` (`compute_char_diff`) ; `documents_gallery.py:232` (re-normalise strates+badges). |
+| **D** | **Narrative = feuille propre.** 2 162 LOC, n'importe que `domain.facts` ; 20 détecteurs ; **3 accroches** à couper. | `narrative/arbiter.py:24` ; hooks `generator.py:254`, `overview.html:43` (`{% include '_narrative_summary.html' %}`), `web/routers/synthesis.py`. |
+| **E** | **DOUBLE moteur de graphiques** (tension/doublon). (1) **SVG serveur** dans `charts/*.py` (déterministe) **+** (2) **Chart.js client** : `chart.umd.min.js` (208 KB) inliné et **piloté par `_app.js:buildCharts()`**. ⚠️ **Chart.js est VIVANT** (agent corrigé). | `generator.py:246,275` (`_load_vendor_js("chart.umd.min.js")`) ; `base.html.j2:18` (`{{ chartjs_inline\|safe }}`) ; `_app.js:747` (`destroyChart`) ; `engines_table.html:16` (`buildCharts()`). |
+| **F** | **« Rapport-application » (SPA), pas document factuel.** ~3 423 LOC JS (routing/drill-in/comparaison/tables) + ~2 948 LOC CSS. La suppression du narratif n'y change rien. | `_app.js` 2 588 LOC ; `_routing.js` 249 ; `_styles.css` 2 735. |
+| **G** | **i18n threadée, pas dispersée.** Chargée **une fois** dans `generator.py`, passée en `labels: dict` à chaque renderer (qui ne connaît pas `i18n`). 635 clés × 2 langues. Glossary = **UI seule**, 0 conso Python. | `get_labels` importé par `generator.py` + `i18n/__init__` only. |
+| **H** | **Snapshots de reproductibilité** embarqués (sain). 4 instantanés (pricing, glossary, normalization, environment) → `report_data["snapshots"]`, dégradables. Recoupe l'invariant `§12`. | `snapshot.py:69-249` ; `generator.py:239`. |
+| **I** | **Docstrings/réfs périmées.** `__init__.py` promet `RunManifest`+`view_results` (faux) ; réfs « Sprint S22 », « 22 vues » (`render.py:12`). | `reports/__init__.py:11` ; `render.py:12`. |
+
+## 1.5 Verdicts par fichier — **PROVISOIRE — à confirmer au build**
+
+> Légende : **G** garder (concept ~tel quel) · **M** modifier (concept gardé, forme revue) · **C** changer de couche · **S** supprimer · **I** incrémental (rebâti à la tranche qui le consomme, pas avant).
+> Principe directeur (`MIGRATION_COUCHE_3.md` §9) : le **cadre** du rapport est plein-scope **maintenant** ; le **contenu** (sections) grossit **au rythme des métriques** (couche 3). Donc la plupart des renderers ne sont **pas portés** : ils sont **rebâtis en sections incrémentales**.
+
+### Orchestration `html/` (2 196 LOC)
+| Fichier | LOC | Rôle vérifié | Verdict PROVISOIRE + raison |
+|---|---:|---|---|
+| `render.py` | 643 | `HtmlReportRenderer.render(RunResult)` (f-strings, lit direct) | **G (germe) + M** — c'est le **cadre** à garder ; le reshaper en **`Protocol Section`** typé. **Trim <400** (split frame/sections). |
+| `csv/render.py` | 115 | `render(RunResult)` → lignes tidy | **G** — déjà propre, déterministe ; aligner sur l'API de sortie. |
+| `json/render.py` | 100 | `render(RunResult)` → dict canonique | **G** — déjà propre. |
+| `comparison.py` | 409 | `compare_benchmarks` (2 runs, JSON, Jinja2) | **M** — commande `compare` retenue (`CLAUDE.md` §8.4) ; **reconsommer 2 `RunResult`**, drop Jinja2 + format-dict flexible ; <400. |
+| `snapshot.py` | 280 | 4 snapshots repro embarqués | **M / ABSORBER** — la repro vient du **`RunManifest`** (déjà `domain`) ; le rapport l'**affiche**. Pricing → lié à la métrique économie (incrémental). |
+| `generator.py` | 458 | Orchestrateur **legacy** `BenchmarkResult` + Jinja2 + data-layer + narrative + 6 views custom | **S (tel quel)** — masse accrétée. Le **concept** « assembler des sections en 1 HTML autonome » est rebâti **minimalement** autour du `Protocol Section` consommant `RunResult`. |
+| `section_registry.py` | 379 | Dispatch à **4 `arg_kind`** | **S** — remplacé par le **`Protocol Section` unique** (une seule signature). |
+| `html/__init__.py` / `__init__.py` | 53 | façades | **M** — mince, zéro effet de bord. |
+
+### Data-layer `html/data/` (1 614 LOC) — **S en bloc**
+| Verdict | Raison |
+|---|---|
+| **SUPPRIMER les 9 fichiers** | Anti-pattern `CLAUDE.md` §8.3 : ré-agrège `evaluation/` à chaque rendu (§1.4-B). En Cinoc, **tout calcul vit en couche 3** (`evaluation/runner` écrit dans `RunResult`) ; le rapport **lit** `RunResult`. `engines.py`/`scatter.py` (lecture pure) : leur logique d'**accès** trivial est absorbée par les sections. |
+
+### Renderers `html/renderers/` (37 fichiers, 8 167 LOC) — **rebâtis en sections INCRÉMENTALES**
+> Verdict global : **ni « garder », ni « porter en bloc »**. Chaque renderer devient (ou non) une **section `Protocol Section`** lit-`RunResult`, **ajoutée quand sa métrique atterrit en couche 3** (axe surface). Regroupement durable (rôle vérifié) :
+
+| Domaine | Renderers (LOC) | Tranche probable | Verdict |
+|---|---|---|---|
+| **Cadre/overview** | `overview`(302), `engines_table`(467), `documents_gallery`(381), `view_results`(262) | **squelette texte** (1ʳᵉ section) | **M→section** (overview/engines = la 1ʳᵉ section vraie) |
+| **Inter-moteurs** | `crosses`(650), `inter_engine`(248), `specialization`(113) | épaississement texte (cross_engine) | **I** — à la métrique cross_engine |
+| **Stats/diagnostics** | `engines_diagnostics`(203), `engines_stability`(171) (composites) | au fil des métriques | **M** — recomposés par le cadre, pas des « views » à part |
+| **Philologie** | `philological`(602), `over_normalization`(141), `lexical_modernization`(114), `numerical_sequences`(149) | tranche philologie | **I** |
+| **Taxonomie d'erreur** | `taxonomy_comparison`(238), `taxonomy_cooccurrence`(161), `taxonomy_intra_doc`(148) | tranche taxonomie | **I** |
+| **Calibration/NER/rare** | `calibration`(330), `ner`(224), `rare_token_recall`(116), `readability`(127), `searchability`(103) | par métrique | **I** |
+| **Économie/robustesse/longi** | `marginal_cost`(111), `throughput`(154), `incremental_comparison`(205), `robustness_projection`(252), `longitudinal`(167), `baseline`(242), `multirun_stability`(151), `error_absorption`(210), `image_predictive`(207) | tranches dédiées (longi = store tidy `adapters/storage`) | **I** |
+| **Structure/pipeline** | `pipeline_dag`(319), `stratification`(190), `worst_lines`(178) | tranche structure / pipeline | **I** (worst_lines : vient d'`evaluation`, `MIGRATION_COUCHE_3.md` §11) |
+| **Couplés à du mort/déplacé** | `difficulty`(51), `module_audit`(175), `levers`(295) | — | **S/I** — `difficulty` (métrique destinée à partir, couche 3) ; `levers`/`module_audit` (synthèse type-narrative / `module_policy` mort) → ne pas porter sans consommateur |
+
+### Charts `html/renderers/charts/` (8 fichiers, 1 056 LOC)
+| Verdict | Raison |
+|---|---|
+| **G (concept SVG serveur) + I** | SVG **côté serveur** = **déterministe** (invariant §12) + **autonome** (pas de CDN). À rebâtir par section, au besoin. `cer_distribution`/`confusion_unicode` viennent d'`evaluation` (`cdd_render`, `MIGRATION_COUCHE_3.md` §11). |
+| **Chart.js client : S** | `chart.umd.min.js` (208 KB) + `_app.js:buildCharts()` = JS client **non déterministe**, « rapport-application ». Le SVG serveur **le remplace**. ⇒ supprime aussi l'essentiel du SPA (§1.4-F). |
+
+### Views `html/views/` (6, 1 053 LOC), Helpers `_helpers/` (6, 1 019 LOC), i18n/glossary
+| Fichier/groupe | Verdict PROVISOIRE + raison |
+|---|---|
+| `html/views/*` | **S (mécanisme) / M** — l'orchestration « view = N renderers + shell `<details>` + masquage adaptatif » est remplacée par le **cadre `Protocol Section`**. Le concept « masquer une section vide » est **gardé** (une section sans donnée → `None`). |
+| `_helpers/{engine_palette,engine_badges,colors}` | **G (consolidé)** — identité couleur stable par moteur (utile au rapport). **Fusionner en 1 module <400**, sans le doublon de palettes. |
+| `_helpers/render_helpers`(422) | **M** — coloration cellules/SVG ; **porter seulement les helpers utilisés** par les sections bâties ; <400. |
+| `_helpers/assets`(203) | **M** — garder l'**inline image b64** (HTML autonome) ; **drop** le loader de vendor JS (Chart.js parti). |
+| `i18n/` (635×2) | **S/perissable** — surface, pas enveloppe. Démarrer **mono-langue** (labels inline) ; réintroduire un registre fr/en **seulement si un consommateur le réclame** (« pas de conso = supprimé »). Ne pas porter **1 274 LOC** de labels d'avance. |
+| `glossary/` (25×2) | **S** — 0 consommateur Python (UI seule). Réintroduire si une section le réclame. |
+| `templates/` (JS/CSS) | **S majoritaire** — le SPA (routing/drill-in, 3 423 JS) contredit « document factuel ». Garder un **shell minimal** + style de tableaux ; pas de routeur SPA. *(Périssable mais fortement indiqué.)* |
+| `narrative/` (12, 2 162) | **S total** (D2) — couper 3 accroches (§1.4-D). |
+
+---
+
+# PARTIE 2 — RÉORGANISATION CIBLE Cinoc (périssable — « à confirmer à la tranche »)
+
+> ⚠️ Périssable : le contact du code amont (evaluation/pipeline/app non encore implémentés) corrigera ces formes. **On ne construit PAS `reports` de haut en bas** : le **cadre** naît au squelette ambulant, les **sections** se remplissent **une par une**, au rythme des métriques (`MIGRATION_COUCHE_3.md` §9).
+
+## 2.1 Rôle de `reports` en Cinoc & les deux axes
+
+`reports` est une **vue en lecture seule** d'un `RunResult` : il **n'agrège jamais**, **ne recalcule jamais** un score, **ne génère aucune prose** (anti-hallucination §12). Tout nombre est une fonction auditable de `RunResult`.
+
+| Axe | Contenu `reports` | Quand |
+|---|---|---|
+| **Enveloppe (plein-scope, maintenant)** | **`Protocol Section` typé unique** (1 signature) ; consommation **directe de `RunResult`** ; **`ReportRenderer`** (Callable injecté par `app`) ; 1 format HTML autonome déterministe ; sorties `csv`/`json` alignées ; charts **SVG serveur** déterministes | conçu au squelette |
+| **Surface (incrémentale, élaguée)** | les **sections** (overview → engines → CER → … → philologie/taxo/structure) ; ajoutées **une par métrique** ; `compare` ; longitudinal (store tidy) | une tranche à la fois |
+
+## 2.2 Le cadre (enveloppe — à figer au squelette)
+
+```
+RunResult ──> [ ReportRenderer ]  (Callable injecté par app)
+                    │
+                    ├─ HTML  : assemble des Section (Protocol unique) en 1 page autonome
+                    ├─ CSV   : lignes tidy (run, doc, vue, métrique, valeur, statut)
+                    └─ JSON  : dict canonique déterministe
+```
+- **`Protocol Section`** (1 seule signature, ex. `render(result: RunResult, ctx) -> SectionHtml | None` ; `None` = pas de donnée → section masquée). **Remplace** les 4 `arg_kind` + le `section_registry`.
+- **Pas de data-layer** : une section lit `RunResult` (qui porte déjà taxonomy/NER/calibration/structure par conception, `MIGRATION_COUCHE_3.md` §8).
+- **Charts = SVG serveur** (déterministe, autonome) ; **aucun JS client de charting**, aucun CDN.
+
+## 2.3 Où va chaque concept Picarones (table de transfert)
+
+| Concept Picarones (`reports`) | Destination Cinoc | Note |
+|---|---|---|
+| `render.py` (cadre RunResult) | **`reports`** — cœur du `ReportRenderer` HTML | germe à reshaper en `Protocol Section` |
+| `csv`/`json` (RunResult) | **`reports`** | déjà propres |
+| `comparison.py` | **`reports`** (commande `compare`) | reconsomme 2 `RunResult` |
+| 37 renderers + 6 views + charts | **`reports`** — **sections incrémentales** | 1 section/métrique, pas en bloc |
+| `_helpers` couleur + assets(image) | **`reports`** (1 module consolidé <400) | drop vendor JS |
+| `snapshot` (repro) | **lecture du `RunManifest`** (domain) | reports affiche, n'embarque pas |
+| **`html/data/`** (ré-agrégation) | **`evaluation/runner`** (couche 3) | le calcul y vit déjà |
+| **`generator` legacy + `section_registry` + Jinja2 + SPA JS/CSS + i18n d'office + glossary + narrative** | **SUPPRIMÉ** | masse accrétée / shim / surface spéculative |
+| `ReportRenderer` (Callable, en `pipeline` chez Picarones) | frontière **`app`→`reports`** | app injecte ; placement corrigé |
+
+## 2.4 Esquisse d'arborescence cible (à confirmer en codant)
+
+```
+cinoc/reports/
+├── __init__.py        mince, zéro effet de bord, docstring vraie
+├── section.py         Protocol Section (1 signature) + types SectionHtml
+├── html.py            ReportRenderer HTML : assemble les Section → page autonome (<400)
+├── sections/          1 fichier/section, ajouté à la tranche de sa métrique
+│   └── overview.py    (1ʳᵉ section : overview/engines/CER — squelette)
+├── charts.py          primitives SVG serveur déterministes (au besoin)
+├── csv.py             sortie tidy (RunResult)
+├── json.py            sortie canonique (RunResult)
+├── compare.py         compare 2 RunResult
+└── _style.py          CSS minimal inline + couleurs moteur consolidées (<400)
+```
+*(Tous <400 LOC. Pas de `data/`, pas de `section_registry`, pas de `narrative/`, pas de `i18n/` au départ, pas de vendor JS.)*
+
+## 2.5 Apparition par tranches (≠ couche complète)
+
+| Tranche (cf. `MIGRATION_COUCHE_3.md` §15) | Ce que `reports` matérialise |
+|---|---|
+| **1. Squelette `demo`** (corpus pré-calculé → 1 CER → `RunResult`) | `Protocol Section` + `html.py` + **1 section** (overview/engines/CER), sur le **cadre définitif**. Prouve que le cadre tient. |
+| **2. Épaississement texte** (WER/MER, cross_engine, `compare`) | + sections engines/cross + `compare.py` ; charts SVG au besoin |
+| **3. Tranche structure** | + section structure (region/line/reading_order) lit `RunResult` |
+| **4. Longitudinal / économie / philologie / taxo** | + 1 section par métrique, store tidy via `adapters/storage` |
+
+## 2.6 Les 5 garde-fous appliqués
+
+1. **Rupture nette, zéro shim** : 1 seul format d'entrée (`RunResult`) ; **pas** de `BenchmarkResult`, **pas** de data-layer de ré-agrégation, **pas** de double chemin `generator`/`render`.
+2. **Budgets <400** : `render`(643)/`crosses`(650)/`philological`(602)/`engines_table`(467) **doivent** être splittés ; une section = un fichier court.
+3. **Pas de consommateur = supprimé** : narrative, glossary, i18n d'office, Chart.js vendor, SPA JS, renderers de métriques non encore portées → **non créés** tant que la métrique n'existe pas.
+4. **Tests d'archi jour 1** : `layer-deps` (`reports` n'importe que `domain`+`evaluation`+stdlib+`jinja2?`/aucun moteur) ; `no-side-effect-import` ; `file-budgets` ; **golden HTML déterministe** (même `RunResult` → mêmes octets).
+5. **Une section = entière, en budget, en élaguant** : ajoutée avec sa métrique, testée, sans annotation de sprint.
+
+## 2.7 Contrat de câblage métrique↔section & interactivité (enveloppe — périssable)
+
+> Encode le correctif des **deux pires erreurs de Picarones** (métriques déconnectées ; rapport en avance sur sa donnée). À confirmer à S1.
+
+**A. Câblage — rend la déconnexion *impossible*, pas juste déconseillée :**
+- La **`Section` déclare ses `requires`** (les clés de `RunResult` qu'elle consomme).
+- **Test no-orphan-métrique** : toute clé écrite dans `RunResult` est consommée par ≥1 section (ou listée « data-only ») → détecte « calculée mais non affichée » (= « pas de conso = supprimé » à la frontière rapport).
+- **Test no-orphan-section** : tout `requires` pointe vers une métrique réellement enregistrée → détecte « section pour une métrique morte/inexistante ».
+- **Masquage adaptatif** : donnée absente *pour ce run* → la section rend `None` (pas une erreur). Distingue « ce run n'a pas la donnée » de « la métrique n'existe pas ».
+
+**B. Interactivité (what-if) — feature tardive, mécanisme à trancher à sa tranche :**
+- **Invariant non négociable** : le rapport **ne re-mesure jamais** (anti-hallucination §12). Toute interactivité = **sélection / ré-agrégation** de données **déjà calculées en couche 3** ; jamais un détecteur ou une métrique relancés côté client. Curseur (ex. seuil d'hallucination) = un **`WHERE`** sur des docs déjà mesurés.
+- **Descriptif** (moyenne/médiane/taux + support) ré-agrégeable ; **inférentiel** (Wilcoxon/Friedman/IC) → **gelé** sur le corpus complet (re-filtrer = re-mesure + 2ᵉ implémentation de scipy).
+- **Mécanisme = QUESTION OUVERTE** (pas de consommateur aujourd'hui → on ne le fige pas, `CLAUDE.md` §9) : **(a, recommandé)** le **runner pré-calcule** les états what-if (`EvaluationView` dédiées) → le rapport **sélectionne**, **zéro calcul client** (marche générique *et* custom) ; **(b)** ré-agrégation côté client (micro-JS déterministe inliné) sur les valeurs par-doc (continu, mais 2ᵉ implémentation à golden-tester, agrégateurs simples). `RunResult` **porte déjà les résultats par-doc** → pas de changement d'enveloppe forcé. → **`MIGRATION_COUCHE_3.md §8`** (décision au build).
+
+---
+
+# PARTIE 3 — RISQUES DE TRANSFERT & DETTES (+ détection)
+
+| # | Risque / dette | Détection | Désamorçage |
+|---|---|---|---|
+| **R1** | **Reporter le chemin `BenchmarkResult`** (les 37 renderers + data-layer) « pour aller vite » | `test_no_legacy_imports` (interdire `benchmark_result`, `build_report_data`) ; revue : toute section lit `RunResult` | rebâtir **section par section** sur `RunResult` ; 0 data-layer |
+| **R2** | **Recréer une data-layer** qui recalcule (stats/pareto/difficulté) dans `reports` | `test_layer_deps` : `reports` n'appelle **pas** `evaluation.statistics`/`metrics.*` pour **calculer** ; revue « lit, ne calcule pas » | tout calcul en `evaluation/runner` → écrit dans `RunResult` ; reports lit |
+| **R3** | **Réintroduire les 4 signatures** / un `section_registry` | revue : **1 seule** signature `Protocol Section` ; grep `arg_kind` | `Protocol` unique, implémenté directement |
+| **R4** | **Bâtir toutes les sections d'avance** (rapport en avance sur ses données) | « pas de conso = supprimé » ; chaque section a une métrique réelle en CI | 1 section/métrique, à sa tranche |
+| **R5** | **JS client non déterministe** (Chart.js, SPA routing) qui casse le golden octet-stable | golden HTML byte-stable ; grep `chart.umd`/`buildCharts`/CDN | charts **SVG serveur** ; pas de routeur SPA ; HTML autonome |
+| **R6** | **Prose générée / narratif** ressuscité | grep `narrative`/`synthesis`/`facts` ; invariant anti-hallucination | tous les nombres = fonction auditable de `RunResult` |
+| **R7** | **i18n/glossary portés d'office** (1 274 + 878 LOC de data spéculative) | « pas de conso = supprimé » ; revue | mono-langue inline ; registre fr/en seulement sur demande réelle |
+| **R8** | **Budgets explosés** (render 643, crosses 650, philological 602…) | `test_file_budgets` strict | 1 section = 1 fichier court ; split aux coutures |
+| **R9** | **Clés de métrique** changées → sections/CSV/JS cassés | contrat dur (`MIGRATION_COUCHE_3.md` §3.9, §12.3) ; golden | renommer un fichier = libre ; **renommer une clé = interdit** |
+| **R10** | **Couplage de couche inversé** : `reports`→`app` (pour `ReportRenderer`) | `test_layer_deps` | `ReportRenderer` = Callable **injecté par `app`** ; `reports` ne connaît pas `app` |
+| **R11** | **Repro perdue** : reports ré-embarque des snapshots au lieu de lire le `RunManifest` | golden `RunManifest` ; revue | reports **affiche** la repro portée par `RunManifest` (domain) |
+| **R12** | **Docstrings/réfs périmées recopiées** (`Sprint S22`, « 22 vues », `RunManifest+view_results` faux) | grep anti-narration | « garder le pourquoi, jeter la datation » |
+| **R13** | **Numérique non rétro-compatible** : normalisation Cinoc ≠ Picarones | goldens **refaits**, pas hérités | aucune « validation » par égalité de chiffres avec Picarones |
+| **R14** | **Interactivité qui re-mesure** : un curseur relance un détecteur/une métrique côté client, ou un 2ᵉ agrégateur dérive de la vue canonique | revue anti-hallucination ; si option (b) ré-agrégation client : golden d'équivalence à plusieurs seuils | **candidat (a)** : runner pré-calcule les états what-if, le rapport **sélectionne** (zéro calcul client) ; sinon golden-tester l'équivalence (§2.7-B) |
+
+---
+
+## Résumé pour la session de CONSTRUCTION (3-5 points)
+
+1. **La ligne de partage est DÉJÀ dans la source.** Picarones a **deux chemins** : `generator`(`BenchmarkResult`, Jinja2, data-layer, 37 renderers, SPA, narrative) = **masse accrétée à NE PAS porter** ; `render`/`csv`/`json`(`RunResult` direct) = **germe à garder**. Cinoc garde le **cadre** du chemin propre et rebâtit le **contenu** par sections. La conversion `RunResult→BenchmarkResult` (couche 6) **disparaît** avec les renderers legacy.
+2. **Enveloppe à figer au squelette, plein-scope :** un **`Protocol Section` typé unique** (remplace les 4 `arg_kind` + `section_registry`), **consommation directe de `RunResult`** (zéro data-layer, zéro recalcul — tout calcul vit en `evaluation/runner`), **`ReportRenderer` injecté par `app`**, 1 HTML autonome **déterministe**. **Câblage métrique↔section** par `requires` + tests no-orphan (§2.7-A) → la déconnexion (erreur n°1 de Picarones) devient **impossible**. **Interactivité (what-if) = sélection, jamais re-mesure** (anti-hallucination) : feature tardive, **mécanisme non figé** — candidat = le runner pré-calcule les états what-if, le rapport *sélectionne* (§2.7-B) ; `RunResult` porte déjà les résultats par-doc → pas de changement d'enveloppe forcé.
+3. **Surface incrémentale, jamais d'avance :** **1 section par métrique**, ajoutée quand la métrique atterrit en couche 3 (overview/CER au squelette, puis cross_engine/philologie/taxo/structure/longitudinal). Charts = **SVG côté serveur** (déterministe, autonome) ; **supprimer Chart.js + le SPA** (~3 400 LOC JS) — Cinoc est un **document factuel**, pas une application.
+4. **Suppressions nettes :** `narrative/`(2 162 LOC, 3 accroches), `html/data/`(1 614, ré-agrégation), `section_registry`, `generator` legacy, vendor `chart.umd.min.js`, i18n/glossary d'office. « Pas de consommateur = supprimé », budgets <400 (render/crosses/philological/engines_table à splitter).
+5. **Invariants à tenir :** `reports` **lit, ne calcule pas, ne narre pas** (anti-hallucination) ; **clés de métrique = contrat dur** avec les sections/CSV ; **golden HTML byte-stable** (déterminisme §12) ; la repro s'**affiche** depuis le `RunManifest`, ne se ré-embarque pas ; direction de couche `reports→{domain,evaluation}` seulement (jamais `app`/`interfaces`).
+
+## DoD vivante (couche 7) — **autorité de détail** ; le `MIGRATION_PLAN.md` indexe
+
+> **T9 (D-067)** : `cross_engine` rend les payloads `inference` (rangs moyens, CD Nemenyi, groupes indiscernables, IC bootstrap) en **lecture seule** (aucun recalcul — anti data-layer) ; `synthesis` applique la règle anti-contradiction (groupe Nemenyi sur la paire de tête → « égalité statistique » ; sinon « écart confirmé » ; sans post-hoc → p-value brute). Preuves : `tests/reports/test_cross_engine_section.py` · `test_synthesis_section.py`.
+>
+> **T10 (D-068)** : `+ sections/economics.py` (6ᵉ section du socle) — coûts/débits/Pareto/marginal en lecture seule du payload, avertissement de péremption explicite ; la **démo** filtre `usage` + `economics` avant rendu (canaux environnementaux) pour rester octet-stable. Preuves : `tests/reports/test_economics_section.py` · `tests/interfaces/test_cli_demo.py`.
+>
+> **T11 (D-069)** : `+ sections/diagnostics.py` (7ᵉ section du socle) — confusions, pires lignes (extraits verbatim **échappés**), documents difficiles ; lecture seule, déterministe (rendu dans la démo sans filtrage). Preuves : `tests/reports/test_diagnostics_section.py`.
+>
+> **T12 (D-070)** : `+ sections/calibration.py` (8ᵉ section) — ECE/MCE + table de fiabilité par bin, lecture seule. Preuves : `tests/reports/test_calibration_section.py`.
+>
+> **T13 (D-071)** : `+ sections/taxonomy.py` (9ᵉ section) — occurrences + parts par classe, lecture seule. Preuves : `tests/reports/test_taxonomy_section.py`.
+>
+> **S7.a (D-074)** : `+ csv_export.py` — export tableur en lecture pure du `RunResult`. Preuves : `tests/reports/test_csv_export.py`.
+
+> Tri-état : `[x]` fait **+ preuve** · `[ ]` à faire · `[~]` différé/réserve + raison.
+> Maj dans le **même commit** que le code. **Statut : ✅ T2** — cadre `Section` + assembleur autonome + sections **overview** & **cross_engine** + rapport de **comparaison** (deltas 2 runs) verts. **+ T7 `synthesis`** : section verdict factuel par vue (meilleur pipeline CER · Δ au suivant · significativité `cross_engine`), gatée `requires=("cer",)`, déterministe — **toutes les vues S4 au design désormais livrées**. Différé : importeurs cœur · longitudinal (T7), interactivité client-side.
+
+**Enveloppe (cadre, plein-scope dès T1) :**
+- [x] **`Protocol Section` unique** (1 signature `render(RunResult, ctx) → Html|None`, `requires` déclarés ; `Html` NewType anti-XSS) ; 0 registry. — *preuve : `reports/section.py` ; `isinstance(OverviewSection(), Section)`*
+- [x] Consommation **directe de `RunResult`**, **zéro data-layer**. — *preuve : `test_reports_imports_are_allowed` (`reports → {domain, evaluation}`)*
+- [x] `ReportRenderer` **injectable** (sections en paramètre ; `default_report_renderer` = socle). — *preuve : `test_renderer`*
+- [ ] charts **SVG serveur** déterministes (pas de Chart.js/CDN). — *avec la 1ʳᵉ section graphique (T2+)*
+- [x] **Rapport = artefact autonome** : HTML déterministe **sans backend ni CDN** (ouvrable hors-ligne) — y compris ses **polices incorporées en data-URI** (Fluxisch Else + OCR-A, S4.b.1a · `_style.font_face_css`), donc **aucune** ressource externe. — *preuve : `cinoc demo` (~227 Ko, octet-stable) + `test_cli_demo` + `test_renderer` (ni `@import`/`https`/`<link>`).* `[~]` interactivité client-side : avec les sections (surface).
+
+**Garde-fous :**
+- [x] `layer_dependencies` (`reports → {domain, evaluation}`) · **`no-orphan section↔métrique`** (le renderer saute les `requires` non couverts) · **golden HTML byte-stable** (2 runs identiques) · `file_budgets`. — *preuve : `test_renderer` (no-orphan + déterminisme) + suite archi*
+
+**Validation inter-couches :** `MIGRATION_PLAN.md` §3-T1 (1 section overview/CER lit `RunResult` → HTML déterministe).
+
+- [~] **Supprimé** : `narrative/` (D2) · `generator` legacy + `html/data/` + i18n/glossary d'office + Chart.js + SPA. **Différé** : 1 section/métrique à sa tranche (jamais en avance). **Interactivité what-if** = question ouverte (sélection, jamais re-mesure ; cf. §2.7).
+
+### i18n FR/EN du rapport (D-136) — **R7 honorée : inline, sur demande réelle**
+
+Mécanisme retenu = `html.localized(lang, fr, en)` (deux formulations adjacentes,
+sélection `SectionContext.lang`, repli FR). **Pas** de registre/catalogue (le
+« i18n d'office » de Picarones reste supprimé). Consommateur réel : route web
+`?lang=en` → `renderer.render(lang="en")`. Conversion **par onglet, incrémentale** :
+
+- [x] **Vue d'ensemble** : `overview` · `corpus_composition` · `synthesis` (D-136).
+- [x] **Déjà bilingues** (dicts `_TEXT`, équivalents) : `word_errors` · `taxonomy`
+  (profil) · `diagnostics` (flux). Migration vers `localized` opportuniste.
+- [x] **Par moteur** : `dispersion`·`calibration`·`conformity` (D-138) ·
+  `structured_data`·`lines`·`ner`·`economics` (D-139) ·
+  `engine_profile`·`philology` (D-140) ·
+  `by_engine`·`correction`·`textual_fidelity`·`taxonomy` (D-141) — **onglet clos (13/13)**.
+- [x] **Par document** : `documents` · `gallery` · `by_document` · `image_quality`
+  (D-137) · `document_detail` (D-138) — **onglet clos**.
+- [x] **Croisements** : `cross_engine` (significativité/oracle/divergence) ✅ (D-142).
+- [x] **Renderer** : `_SECTION_LABELS_EN` + aria-label des blocs bilingue ✅ (D-142).
+
+**✅ Chantier i18n CLOS (D-142)** : tout le rapport (chrome + héros + 4 onglets +
+toutes les sections + aria) est bilingue FR/EN via `SectionContext.lang` (route
+web `?lang=en`), mécanisme unique `html.localized` inline (R7 honorée).
+
+Convention : FR = défaut (tests FR inchangés) ; **+1 test EN par section convertie**.
+
+---
+
+*Tous les verdicts de la Partie 1.5 sont **PROVISOIRE — à confirmer au build** : le contact du code amont (evaluation/app non encore implémentés) prévaut.*
diff --git a/cinoc/reports/ANALYSE_GRAPHIQUES_DIDACTIQUES.md b/cinoc/reports/ANALYSE_GRAPHIQUES_DIDACTIQUES.md
new file mode 100644
index 0000000000000000000000000000000000000000..e344d16eeee46eeec3201e8fee886a027546f773
--- /dev/null
+++ b/cinoc/reports/ANALYSE_GRAPHIQUES_DIDACTIQUES.md
@@ -0,0 +1,192 @@
+# ANALYSE — Graphiques didactiques du rapport Cinoc
+
+> **Design cible (périssable, PROVISOIRE — à confirmer au build).** Catalogue
+> exhaustif des graphiques/tableaux *didactiques* envisageables pour le rapport,
+> chacun rattaché à **sa donnée réelle** (payload existant ou calcul à ajouter).
+> Objectif produit : **juger les moteurs sur la matière première** — voir les
+> *mots* et *symboles* réellement ratés, posés sur le graphique — sans passer
+> uniquement par des chiffres.
+>
+> Lu avant rédaction : `CLAUDE.md`, `cinoc/reports/DECISION_RAPPORT_INTERACTIF.md`
+> (D-094), `cinoc/evaluation/analysis.py` (les 16 payloads + champs verbatim),
+> `cinoc/reports/svg.py` (socle SVG existant), `MIGRATION_PLAN.md` (roll-up).
+
+---
+
+## 0. Cadre & principes
+
+**Didactique = lisible d'un coup d'œil, et ancré dans la matière.** Deux registres :
+1. **Quantitatif visuel** — donner une *forme* à des chiffres déjà calculés
+   (profil d'erreurs, divergence, coût/qualité). Rend comparables des nombres
+   qu'une table noie.
+2. **Qualitatif / matière première** — poser sur le graphique les **vrais mots
+   et symboles** (le mot raté, le glyphe perdu, la confusion `ſ→f`). On juge à
+   l'œil, la matière *est* la donnée.
+
+**Contraintes d'enveloppe (D-094 — non négociables) :** SVG **inline** serveur,
+**autonome/hors-ligne**, **octet-stable** (coordonnées arrondies, cf. `svg.py`),
+**zéro JS lourd** (un seul script mince CSP-hashé), **pas de SPA**, **pas de
+Chart.js**. Tout graphe est une *fonction pure et auditable* du `RunResult`
+(anti-hallucination : aucun nombre/mot inventé, tout vient des payloads).
+
+**Deux axes.** Le socle (`svg.py`) existe (4 formes : dispersion, barres, barre
+composée, courbe de calibration). On **étend le vocabulaire un graphe à la fois**
+(helper SVG + câblage de section + tests valeurs-main + golden de markup), jamais
+en masse.
+
+**Statut de la donnée — le point clé.** La **quasi-totalité** des graphiques
+ci-dessous se nourrit de payloads **déjà calculés et testés**. **Un seul** besoin
+de **calcul nouveau** : la *matrice mots × moteurs* (§1). Et beaucoup de
+**matière verbatim est déjà collectée** (cf. §2) — il ne lui manque que sa mise
+en image.
+
+---
+
+## 1. La carte des mots — cross-moteurs, regroupée *(calcul nouveau — pièce maîtresse)*
+
+**La demande.** Voir les **mots** que les moteurs ratent : combien de fois, par
+moteur, avec **croisements** (quels mots plusieurs moteurs ratent vs un seul) et
+**regroupements**. Juger sur la matière.
+
+**C'est possible — et l'alignement nécessaire existe déjà.** `textual_fidelity`
+tokenise en Unicode (`\w`) et **aligne mot-à-mot** (`difflib.SequenceMatcher`)
+pour la modernisation. On **réutilise cette mécanique** pour un nouvel angle.
+
+### Nouvelle analyse couche 3 : `WordErrorCollector` → `WordErrorPayload`
+- **Collecte** (pendant la passe 1, comme les autres collecteurs) : pour chaque
+  `(pipeline, document)`, aligner GT↔hyp au mot ; pour chaque **mot GT non
+  restitué** (tag `replace`/`delete` de l'alignement), incrémenter
+  `errors[mot_gt][pipeline]`. On peut garder la **forme produite** dominante
+  (ce que le moteur a mis à la place) — la matière de la confusion mot.
+- **`build()` cross-pipelines** (pattern `inter_engine`) : cross-tabuler →
+  par mot GT, le compte d'erreurs **par moteur** + des **signatures de
+  regroupement** :
+  - `universal` — *tous* les moteurs ratent le mot (difficulté de la **matière**) ;
+  - `engine_specific` — *un seul* moteur rate (faiblesse **moteur**) ;
+  - `partial` — un sous-ensemble (recoupement partiel).
+- **Payload** (cap explicite, ex. top 50 mots par fréquence d'erreur totale) :
+  ```
+  WordErrorPayload(kind="word_errors",
+    words: tuple[WordError]  # {word, total_errors, per_engine:{engine:count},
+                             #  top_variant:{engine:forme_produite}, group}
+    groups: {universal:[...], engine_specific:{engine:[...]}, partial:[...]})
+  ```
+- **Conventions / honnêteté** : appariement dépend de la **normalisation de la
+  vue** (documenté) ; fusion/scission de mots = limite connue (héritée de
+  l'alignement) ; cap d'échantillon explicite ; tri déterministe ; GT vide → mot
+  ignoré. **Aucune invention** : les mots sont *verbatim* de la GT, les variantes
+  *verbatim* de la sortie.
+
+### Graphiques (lisent ce payload — la matière est affichée)
+| Graphique | Forme | Ce qu'on lit à l'œil |
+|---|---|---|
+| **Matrice mots × moteurs** | heatmap : lignes = mots **verbatim**, colonnes = moteurs, case teintée = nb d'erreurs (triable, regroupée par signature) | « *prologve* : A rate 8×, B 0, C 2 » — qui bute sur quoi |
+| **Mot → mini-barres par moteur** | liste de mots, chacun avec une micro-barre par moteur | classement des mots les plus durs, comparaison directe |
+| **Recouvrement inter-moteurs** | diagramme d'ensembles (UpSet/Venn) sur les mots ratés | les mots que *tous* ratent (matière dure) vs propres à un moteur |
+| **Mot → variante produite** | par mot dur, le glyphe/forme que chaque moteur a produit | la *nature* de l'erreur, lisible (`maistre`→`maître`/`maistrc`) |
+
+> **Niveau symbole, même principe.** La même logique au grain caractère/abréviation
+> est **déjà servie** par `diagnostics.confusions` (paires `attendu→produit` —
+> **mise en image livrée : flux de glyphes #8, D-134**) et `philology`/`roman`
+> (les signes — mise en image à venir, §3).
+
+---
+
+## 2. La matière déjà collectée (verbatim) — il ne manque que l'image
+
+Cinoc collecte déjà beaucoup de **matière première** par payload. Aujourd'hui
+elle vit dans des **tables** ; la rendre **graphique/groupée** est du rendu pur
+(zéro calcul nouveau) :
+
+| Matière verbatim | Champ (payload) | Mise en image proposée |
+|---|---|---|
+| Pires lignes (réf vs hyp) | `diagnostics.worst_lines` (`reference`, `hypothesis`) | diff coloré aligné, trié par CER |
+| Mots OCR-justes cassés par le LLM ✅ (D-135) | `correction.over_normalized_samples` (`reference`→`corrected`) | flux `mot→forme` (sur-normalisation) — **livré** |
+| Régressions de correction | `correction.worst_regressions` | barres divergentes par document |
+| Tokens rares manqués | `textual_fidelity.missed` | nuage/liste des noms propres perdus |
+| Modernisation lexicale ✅ (D-135) | `textual_fidelity.modernization` (`token`→`variants`) | flux token → variantes (taille = compte) — **livré** |
+| Séquences perdues | `structured_data.lost` (formes verbatim) | liste par catégorie (dates/folios/montants) |
+| Numéraux romains perdus | `roman.lost_samples` | liste + statut (converti/perdu) |
+| Entités manquées / hallucinées | `ner.missed` / `ner.hallucinated` (`text`) | deux colonnes : ce qui disparaît / ce qui est inventé |
+| Signes philologiques | `philology` (le `sign`) | le **glyphe** + barre de préservation |
+| Textes complets des pires docs | `document_texts` (`reference` + `hypotheses`) | diff pleine page (déjà en UI) |
+
+---
+
+## 3. Catalogue complet — « tous les tableaux possibles »
+
+`E` = données **existantes** (payload livré) · `N` = **calcul nouveau** ·
+`✓svg` = socle `svg.py` déjà présent. Onglets : Ov (vue d'ensemble) · Mo (par
+moteur) · Doc (par document) · Cr (croisements).
+
+| # | Graphique / tableau | Enseigne (didactique) | Source | Matière mots/symboles | Statut | Onglet |
+|---|---|---|---|---|---|---|
+| 1 | **Matrice mots × moteurs** ✅ (G1, D-131) | qui rate quels mots, croisements | `word_errors` | **oui (mots)** | **N → livré** | Cr |
+| 2 | Recouvrement inter-moteurs (mots) ✅ (D-132) | mots durs partagés vs spécifiques | `word_errors` | oui | N → livré | Cr |
+| 3 | Mot → variante produite ✅ (D-132) | la *nature* de l'erreur mot | `word_errors` | oui | N → livré | Cr |
+| 4 | **Carte des erreurs** (treemap) ⏸️ déféré (D-133) | la *forme* du budget d'erreurs | `taxonomy` (+`diagnostics`) | classes/paires | E — **redondant** sur classes plates (barre empilée ≥ treemap) ; ré-ouvrable si emboîtement classe→symboles | Mo |
+| 5 | **Profil taxonomique** par moteur ✅ | A diacritique-lourd, B segmentation | `taxonomy` | — | E — barres par-moteur (D-071) + **comparatif classe×moteur** (D-133) | Mo |
+| 6 | **Matrice de divergence JS** (heatmap) | moteurs qui se trompent *différemment* | `inter_engine` | — | E | Cr |
+| 7 | Oracle / complémentarité | gain théorique d'un ensemble | `inter_engine` | — | E | Cr |
+| 8 | **Flux de confusion** `attendu→produit` ✅ (D-134) | directionnalité (`ſ→f` vs `f→ſ`) | `diagnostics.confusions` | **oui (glyphes)** | E → livré (flux de glyphes prominents) | Doc |
+| 9 | Pires lignes (diff verbatim) | *où* ça casse, texte à l'appui | `diagnostics.worst_lines` | oui | E | Doc |
+| 10 | Documents les plus durs | quels docs résistent à tous | `diagnostics.hardest_documents` | — | E | Doc |
+| 11 | **Nuage coût ↔ qualité** + Pareto | le choix moteur (€/CER) | `economics` | — | E | Mo |
+| 12 | Coût marginal €/erreur évitée | le surcoût en vaut-il la peine | `economics.marginal` | — | E | Mo |
+| 13 | Débit effectif (pages/h corrigé) | vitesse réelle post-correction | `economics` | — | E | Mo |
+| 14 | **Bilan de correction** (barre triplet) | l'étage LLM aide-t-il, de combien | `correction` | — | E | Mo |
+| 15 | Flux corrigées/introduites/conservées | l'absorption d'erreurs du LLM | `correction` | tokens | E | Mo |
+| 16 | Sur-normalisation `mot→forme` ✅ (D-135) | le LLM casse des mots justes | `correction.over_normalized_samples` | **oui** | E → livré (flux référence→corrigé) | Mo |
+| 17 | **Flux de modernisation** ✅ (D-135) | formes historiques réécrites | `textual_fidelity.modernization` | **oui (tokens)** | E → livré (flux token→variantes, chips ∝ compte) | Mo |
+| 18 | Tokens rares manqués | noms propres perdus (prosopo) | `textual_fidelity.missed` | oui | E | Mo |
+| 19 | **Préservation philologique** (signes) | abréviations/ligatures tenues | `philology` | **oui (glyphes)** | E | Mo |
+| 20 | Romains : 5 statuts + perdus | la valeur a-t-elle survécu | `roman` | oui | E | Mo |
+| 21 | Séquences restituées par catégorie | dates/folios/montants tenus | `structured_data` | oui (perdus) | E | Mo |
+| 22 | **Entités : P/R/F + manquées/hallucinées** | survie des noms propres | `ner` | **oui (entités)** | E | Mo |
+| 23 | Courbe de calibration (+ écart/bin) | le moteur sait-il qu'il doute | `calibration` | — | E ✓svg | Mo |
+| 24 | **Heatmap positionnelle des lignes** | décrochage haut→bas de page | `lines.heatmap` | — | E | Doc |
+| 25 | Distribution CER par ligne (percentiles) | erreurs uniformes vs concentrées | `lines` | — | E | Doc |
+| 26 | Conformité HIPE : deltas de norm. | part casse/ponct./mappings | `conformity` | — | E | Mo |
+| 27 | Classement + dispersion par moteur | verdict + fiabilité (min·méd·max) | scalaires | — | E ✓svg | Mo |
+| 28 | Composition du corpus par strate | de quoi le corpus est fait | strates | — | E ✓svg | Ov |
+| 29 | **Qualité d'image : distribution paliers** | combien de scans bons/moyens/faibles | `image_quality` (4d.1) | — | E | Doc |
+| 30 | **Scatter qualité d'image ↔ CER** | « le moteur ou le **scan** ? » | `image_quality` × CER par doc | — | E (jointure) | Doc |
+
+---
+
+## 4. Ce qui demande un calcul nouveau (le seul ajout d'enveloppe)
+
+- **`WordErrorPayload` + `WordErrorCollector`** (#1-3) — matrice mots × moteurs +
+  regroupements. Réutilise l'alignement mot de `textual_fidelity` ; pattern
+  cross-pipeline de `inter_engine`. **Tout le reste (#4-30) = renderers SVG sur
+  payloads existants** (+ une jointure triviale pour #30).
+
+> Ergo : l'enveloppe couche 3 est quasi suffisante. Le gros du chantier est en
+> **couche 7** (vocabulaire SVG), incrémental, à faible risque.
+
+---
+
+## 5. Séquencement proposé (PROVISOIRE)
+
+Chaque tranche = un (ou deux) graphique(s), livré entièrement : helper `svg.py`
++ section + tests valeurs-main + golden de markup + **libellés bilingues FR/EN
+d'emblée** (les graphes portent peu de texte — autant ne pas repasser à l'i18n).
+
+| Ordre | Tranche | Pourquoi |
+|---|---|---|
+| 1 | **Carte des mots** — ✅ **TERMINÉE** : #1 (G1, D-131) + #2-3 (D-132), même payload | la demande centrale ; introduit `word_errors` (le seul calcul neuf) + montre la matière. **#1** matrice mots×moteurs (heatmap SVG + table accessible). **#2** recouvrement inter-moteurs (mots groupés par signature de moteurs, tailles d'intersection façon UpSet). **#3** forme produite par moteur (rend la `variant` dominante du payload, `∅`=supprimé). Tout en couche 7 (payload `word_errors` inchangé depuis D-131), section FR/EN. |
+| 2 | **Profil taxonomique** (#5) ✅ (D-133) — **#4 treemap déféré** (redondant) | la *forme* des erreurs, comparatif moteurs. #5 = barres par-moteur (D-071) **+ table comparative classe×moteur** (D-133, lecture par ligne). #4 treemap **redondant** avec la barre empilée sur classes plates → déféré avec motif (≠ surface spéculative). |
+| 3 | **Matière verbatim mise en image** — 🚧 **#8 ✅ (D-134) · #16/#17 ✅ (D-135)** ; #19/#22 à venir | confusions (#8 = flux de glyphes ✅) / sur-normalisation (#16 = flux référence→corrigé ✅) / modernisation (#17 = flux token→variantes ✅) / signes (#19) / entités (#22) — « voir les symboles ». Chacun = rendu pur sur payload existant. |
+| 4 | **Décision** (#11 coût↔qualité, #14 bilan correction) | les images de choix moteur / valeur du LLM |
+| 5 | **Divergence + complémentarité** (#6, #7) | croisements quantitatifs |
+| 6 | **Qualité ↔ CER** (#30) + heatmap lignes SVG (#24) | donne sa pleine valeur à 4d.1 ; structure |
+
+> Reste hors périmètre (décision actée) : le **CDD/diagramme de différence
+> critique** de Picarones (post-hoc Nemenyi) — jugé **opaque/peu didactique** ;
+> la donnée `inference` reste disponible mais ne sera pas mise en diagramme.
+
+---
+
+*Référence : design cible de la couche 7, à confirmer au build (chaque tranche
+fige sa forme et ses clés). Enveloppe couche 3 : un seul ajout (`word_errors`).
+Contraintes D-094 tenues. `MIGRATION_PLAN.md` indexe ; ce document détaille.*
diff --git a/cinoc/reports/ANALYSE_RAPPORT.md b/cinoc/reports/ANALYSE_RAPPORT.md
new file mode 100644
index 0000000000000000000000000000000000000000..48089f9d44175d7c7aa833cc93fdf25021260015
--- /dev/null
+++ b/cinoc/reports/ANALYSE_RAPPORT.md
@@ -0,0 +1,286 @@
+# Analyse — consolidation du rapport HTML
+
+Guide durable. Établi après audit de la couche `reports` et revue de la vue de
+référence Picarones (lecture seule). Objectif : **consolider, pas empiler** — un
+rapport simple et standardisé, sans la dette accumulée.
+
+## Audit (juin 2026)
+
+**Sain (≠ chaos hérité)** : aucun shim/legacy/_v2 ; un `Section` Protocol unique ;
+CSS centralisé (`html.py`) ; helpers partagés (`_tables`, `_style`, `engine_badges`).
+
+**Le vrai signal — accumulation localisée (CSS), surtout dans la vue document** :
+- ~40 classes bespoke `dd-*` (`dd-hl/lh/iq/ld/pct/sbs/diff/cers/fac/zoom…`) ;
+- idiomes **dupliqués** : ~10 variantes de « barre » (`databar`, `dd-iq-bar`,
+  `dd-lh-bar`, `dd-pct-track`, `bars-svg`, `comp-bar`…), 3 « chip », plusieurs
+  « badge » ;
+- **deux systèmes de drill-in parallèles** (`prof-*` profil moteur, `dd-*` document) ;
+- **proportions non disciplinées** : SVG sans taille pinée qui s'étirent (cas
+  `wmap-svg` : cellules géantes — corrigé en brique 1) ;
+- **jargon dans l'UI** : le nom interne de vue `text` affiché brut (« Vue : text »).
+
+Chaque mini-graphique a réinventé sa barre/chip/badge au lieu de réutiliser un
+composant. Ce n'est pas Picarones, mais c'en est la pente.
+
+## Principe de consolidation (non négociable)
+
+- **Net-négatif** : la refonte **supprime** des classes/idiomes (preuve : diff CSS
+  négatif, moins de familles). Elle n'ajoute pas une couche.
+- **Primitives partagées** : un seul composant par concept — `metric_row`
+  (badge | nom | valeur **tabulaire**), `bar`, `stacked_bar`, `chip`, `heatmap`,
+  `stat_table` — dans `_style`/`_tables`.
+- **Un seul drill-in** : fusionner `prof-*` et `dd-*`.
+- **Cadre de section unique** : titre + 1 phrase « comment lire » + **libellé de
+  vue humain** (fin du « text »).
+- **Proportion** : tout SVG inline rend à une **taille bornée** (pinée ou
+  intrinsèque + `max-width:100%`), jamais étiré au conteneur.
+- **Garde-fou** : à terme, un test plafonnant les familles de classes (anti-récidive).
+
+## Pertinence des tableaux Picarones (verdicts)
+
+| Tableau | Verdict | Action |
+|---|---|---|
+| Confusions caractère par caractère (GT→OCR / moteur) | pertinent | **déjà là** (`CharConfusion`), à mieux présenter |
+| Taxonomie d'erreurs (barres / classe) | pertinent (corpus) | présent, enrichir les classes |
+| Profil leader vs runner-up (récupérabilité) | optionnel | différé |
+| Matrice de corrélation entre métriques (Pearson) | gadget (bruit, colinéarité) | ne pas porter |
+| Co-occurrence des classes (Jaccard) | gadget | ne pas porter |
+
+## Métriques
+
+- **CMER** existe (`conformity.py`) mais **gated** à la vue HIPE (`hipe`/`heritage`).
+  À **exposer** (profil conformité au lanceur).
+- **ICDAR** : CER/WER/MER sont les métriques de compétition ; pas de famille
+  « ICDAR » nommée — ajouter une variante précise seulement sur demande.
+
+## Tranches (consolidation, net-négatif)
+
+- **S1.1 — proportion** ✅ : SVG à taille bornée ; `wmap` heatmap rendue à sa
+  taille intrinsèque (fin des cellules géantes).
+- **S1.2 — libellés de vue humains** ✅ : `view_label(view, lang)` dans `html.py`
+  (**source unique**) ; `text` → « Texte brut », `diplomatic` → « Transcription
+  diplomatique » ; vue déjà lisible (réf. OCR) rendue telle quelle. Routé dans
+  **toutes** les sections (titres + cellules) — fin du « vue : text » brut. Le
+  *cadre de section* uniforme (how-to-read homogène) est repoussé à S1.3 avec les
+  primitives (mieux fait d'un coup que dispersé).
+- **S1.3a — lisibilité « CER par moteur » (vue document)** ✅ : la liste CER
+  était projetée au bord du panneau (`.dd-name{flex:1}` → valeur « trop
+  éloignée »). Passée en **grille compacte** (badge · nom · valeur) : la valeur
+  suit le nom dans sa colonne (alignée ET proche). 0 classe ajoutée, suppression
+  de l'idiome `flex`.
+- **S1.3b — primitive `track` (piste de proportion horizontale)** ✅ : 3 coques
+  quasi-identiques (`dd-iq-bar`, `dd-pct-track`, `strata-bar`/`strata-fill`)
+  fusionnées en **une** `.track` + `.track>i` (l'appelant pose largeur + couleur).
+  Net −4 règles CSS, 3 consommateurs unifiés (qualité d'image, percentiles,
+  strates). Non-spéculatif (3 consommateurs réels au moment de l'extraction).
+- **S1.3c — primitive `chip` + `chips`** ✅ : `dd-hl-chip` (×8) et `preview-chip`
+  fusionnés en `.chip` (+ rangée `.chips`). Net −1 règle, 2 sections unifiées.
+- **S1.3d — vocabulaire de drill unifié + orphelin corrigé** ✅ : constat —
+  les « deux systèmes » `prof-*`/`dd-*` étaient **déjà fusionnés** au niveau JS
+  (`.drill-panel`/`.drill-back` génériques) et chrome (la vue document réutilisait
+  `prof-*`). Dette réelle = **nom trompeur** (`prof-*` = profil moteur, mais
+  partagé par les panneaux document) + **orphelin** (`.eng-back` stylé, mais le
+  markup utilisait `.drill-back` → lien « ← retour » non stylé). Corrigé : chrome
+  partagé `prof-{head,nav,title,pos,chart-title}` → `drill-{head,nav,title,pos}` +
+  `drill-caption` ; `.eng-back` → `.drill-back` (orphelin résolu). `prof-row`/
+  `prof-cell` (layout interne du profil moteur, non partagé) conservés.
+- **S1.3 (suite) — restant** : `metric_row` (au 2ᵉ consommateur), *cadre de
+  section* uniforme (titre + how-to-read homogène).
+- **S1.4 — garde-fou** anti-prolifération de classes.
+
+## Refonte mise en page du rapport — PLAN UNIQUE (juin 2026)
+
+> **Remise à plat.** Les essais S2.1 (cap 1200 px) / S2.2 / brouillons multi-colonnes
+> ont été soit **annulés** (le cap : l'utilisateur veut la **pleine largeur**,
+> §D1), soit **conservés s'ils sont sains** (légende de composition groupée). Ce
+> bloc **remplace** l'ancienne liste de tranches cumulées. Un seul plan, ordonné,
+> avec les décisions explicitées **avant** tout code.
+
+### Principe directeur (corrige le malentendu de départ)
+
+Le problème n'est **pas** la largeur de la fenêtre — c'est l'**organisation des
+données dedans**. On garde la **pleine largeur** (pas de cap arbitraire) et on
+**remplit l'horizontale** : une longue liste se découpe en **plusieurs colonnes
+côte à côte** au lieu de descendre tout en bas avec la droite vide. Référence de
+calibrage : `design/screenshots/` (cartes denses, identité couleur par moteur).
+
+### Problèmes (analyse complète, captures 1920 px + lecture du code)
+
+| # | Problème | Cause (dans le code) |
+|---|---|---|
+| **D1** | Largeur : le cap 1200 px « rétrécit » et gâche l'écran | (corrigé) cap retiré → pleine largeur restaurée. Le vrai correctif est l'organisation (D2). |
+| **D2** | Listes **tout en longueur**, droite vide (« mots ratés » ~40 l., « modernisation lexicale » ~25 l.) | tables/listes **mono-colonne** `width:100%`. → découper en **N colonnes côte à côte** (grille de sous-tables ; `columns` journal pour les listes). |
+| **D3** | **Couleurs moteur absentes** là où elles devraient être | `engine_badges` (fern/slate/clay…) **n'est pas appliqué** dans `overview` (nom en texte brut, `overview.py:53`), `structured_data` (`:40`), ni partout en en-tête. Identité couleur **incohérente**. |
+| **D4** | **Barres CER/WER « n'ont aucun sens et remplissent tout »** | `td.databar .db-fill` largeur ∝ valeur/max ; pour une **métrique d'erreur** (CER bas = bon), la **pire** valeur a la **plus longue** barre → contre-intuitif, sans légende, et remplit la cellule. |
+| **D5** | **MUFI hors-sujet ; métriques ICDAR manquantes** | l'exemple a été généré avec le profil **`philologie`** (`cer_diplo, diacritic_err, mufi_err`…) — médiéval, **inadapté** à la presse XIXe. Le profil **`standard`** (`cer, wer, mer, searchability, hallucination, air`) conviendrait mieux. + colonnes **tout-`—`** (AIR/HCPR) qui encombrent. |
+| **D6** | **Titres répétitifs** (« Texte brut — … » partout, « Classement (vue : Texte brut) ») | libellé de vue ressassé par section (S1.2) ; inutile en **vue unique**. |
+
+### Cible = design canonique (captures fournies par l'utilisateur)
+
+Deux écrans `design/` font foi (l'utilisateur les a transmis ; « on n'y est pas
+encore ») :
+
+- **« Par moteur »** : **tableau de métriques GROUPÉ** par thème (super-en-têtes :
+  *Erreur · caractère* | *Erreur · mot* | *Philologique* | *Fiabilité
+  documentaire* | *Calibration · aval* | *Économique*). Chaque colonne a un
+  **indice d'échelle** (« 0→1 · ↓ erreurs », « ↑ rappel »…), une **barre subtile**
+  derrière la valeur (**échelle commune par colonne**, légende explicite), et les
+  **badges moteur colorés A→E**. Puis Dispersion + IC.
+- **« Par document »** : **deux colonnes** — *fac-similé* (zoom) à gauche, *diff
+  GT/sortie OCR* à droite (sélecteur de moteur en badges colorés, légende
+  add/del/sub), et « CER par moteur · ce document » en badges colorés (meilleur
+  surligné).
+
+**Conséquence : le tableau de métriques n'est pas « minimal » mais RICHE et
+ORGANISÉ.** Les barres **restent** (version canonique : subtiles, échelle commune,
+légendées) — ≠ les barres actuelles qui « remplissent tout » sans sens.
+
+### Métriques réellement calculables (registre)
+
+`cer, cer_diplo, cmer, wer, mer, diacritic_err, mufi_err, air, hcpr,
+searchability, hallucination, del_rate, ins_rate, numseq_*, region_*`. **CMER
+existe** (réservé HIPE aujourd'hui — à exposer). Les colonnes canoniques *WIL,
+Ligatures, Gini, ECE, F1 NER* sont **aspirationnelles** (calculées dans des
+sections dédiées — calibration/NER/lignes — pas encore en colonnes de table) →
+intégration ultérieure, pas bloquante.
+
+### Réconciliation des 2 réponses utilisateur ⇄ canon
+
+- **Barres (D4)** : réponse = « retirer ». **Mais le canon les garde** (subtiles,
+  échelle commune, légendées). ⇒ je pars sur la **version canonique** (barres
+  *correctes*, court = meilleur pour l'erreur, plafonnées, avec légende) plutôt
+  que de les retirer — c'est ce que montre le design. **À confirmer d'un mot si
+  tu préfères vraiment 0 barre.**
+- **Métriques (D5)** : réponse = « il manque CMER et d'autres ICDAR ». ⇒ pas de
+  set minimal : on vise le **tableau groupé canonique** avec les métriques **qui
+  existent** — *Erreur caractère* : CER, CER diplo, **CMER** ; *Erreur mot* :
+  WER, MER ; *Philologique* : diacritiques (MUFI **réservé** au médiéval, pas en
+  défaut presse) ; *Fiabilité* : repérabilité, hallucination, AIR/HCPR. Colonnes
+  tout-`—` **masquées**. WIL/Gini/ECE/F1 = ajout ultérieur.
+
+### Ordre d'exécution (une tranche = un correctif, vérifié + commité seul)
+
+1. **R1 — identité couleur moteur (D3)** ✅ : `engine_cell` (badge A→E coloré)
+   appliqué dans les 7 sections qui affichaient un nom en texte brut — overview,
+   structured_data, economics, conformity, textual_fidelity (rappel + flux),
+   synthesis (meilleur + suivant), diagnostics (confusions). Ordre moteur global
+   (`engine_order`) threadé. Couleur cohérente partout (comme le canon).
+2. **R2 — tableau de métriques groupé (D4+D5)** — en sous-tranches :
+   - **R2a** ✅ : **barres subtiles + légende** — `db-fill` passe d'un bloc qui
+     remplit la cellule à un **fin trait de base** (position sur l'axe, échelle
+     commune par colonne) + `bar_legend()` partagée sous overview/by_engine.
+     Corrige le « n'a aucun sens et remplit tout ».
+   - **R2b** ✅ : **masquer les colonnes tout-`—`** — `nonempty_metric_indices()`
+     (distingue tout-None → masqué vs tout-zéro → gardé) appliqué à overview /
+     by_engine / by_document. AIR/HCPR vides disparaissent.
+   - **R2c** ✅ : **super-en-têtes thématiques** — `group_header_row()` fusionne
+     les métriques consécutives d'un même groupe (Erreur·caractère / Erreur·mot /
+     Philologique / Fiabilité / Structuré) en `colspan`. Appliqué overview +
+     by_engine (cadrage `lead`/`trail` pour les colonnes hors-métrique). Pas de
+     réordonnancement (profils déjà groupés).
+   - **R2d** ✅ : **CMER exposé** au profil `standard` (calculé sur RAW_TEXT comme
+     CER, MER caractère borné [0,1] — ≠ réservé HIPE) ; **MUFI** reste au seul
+     profil `philologie` (médiéval). Exemple BNL régénéré en `standard` → CMER
+     visible, MUFI absent (presse XIXe).
+3. **R3 — organisation multi-colonnes (D2)** ✅ : remplir l'horizontale — « mots
+   ratés » en **N tables côte à côte** (`_matrix_grid`, ~16 lignes/col, plafond 3,
+   `.tcols`) ; « modernisation lexicale » en **colonnes journal** (`.wflow` →
+   `columns:23em`, lignes insécables). Repli 1 colonne sur écran étroit.
+4. **R4 — vue « Par document » deux colonnes** ✅ : fac-similé **à gauche** | diff
+   GT/sortie **à droite** (`.dd-top2` grid), on lit le texte en regardant le scan ;
+   sans image, le diff prend toute la largeur ; replie en 1 col < 860 px. (Les
+   badges CER/moteur colorés sont déjà là via R1.)
+5. **R5 — titres (D6)** ✅ (titres de section) : libellé de vue affiché **seulement
+   si plusieurs vues** (vue unique → pas de ressassage). Fait pour overview,
+   by_document, by_engine, gallery, dispersion (les h2/sous-titres proéminents).
+   **R5-bis** ✅ : préfixes h3 des 12 sections analytiques (« Texte brut —
+   composition/modernisation… ») traités via le helper partagé `view_prefix(view,
+   lang, *, multi)` (« Libellé — » si multi, sinon ``""``). Appliqué à taxonomy,
+   ner, calibration, philology, structured_data, lines, economics,
+   textual_fidelity, correction, diagnostics, word_errors, et cross_engine
+   (préfixe « Libellé · » pour ses titres vue·métrique). La colonne « Vue » de la
+   table de significativité garde le libellé (c'est une donnée, pas un titre).
+6. **R6 — diagramme de Venn du recouvrement** ✅ (parité Picarones) : `word_overlap_venn`
+   (svg) rend un Venn **2-3 moteurs** des mots ratés par exactement chaque
+   combinaison (cercles teintés par moteur, compte par région), compagnon visuel
+   de la liste UpSet (qui reste la matière accessible). > 3 moteurs → `""` (liste
+   seule). **Verdict « gadget » du début rétracté** : c'est la visualisation
+   canonique du recouvrement, la donnée existait déjà.
+
+### Reste (métriques — surface fonctionnelle, hors mise en page)
+
+### Tranche M — métriques (décision utilisateur : « je veux tout »)
+
+Surface fonctionnelle (≠ mise en page) : **5 ajouts métriques**, chacun sa
+tranche (moteur couche 3 + branchement rapport + tests + gate). Ordre conseillé :
+
+- **M1 — dégater la conformité (cmer/wmer micro · macro)** ✅ : `conformity.py`
+  ancre = vue `hipe` **ou** première vue portant `cmer` (profil `standard` depuis
+  R2d) → la section s'affiche sur tout corpus ; deltas norm/heritage **seulement**
+  avec une vraie ancre HIPE + vues brute/heritage (sinon colonnes Δ masquées).
+  Section retitrée « Précision bornée (cMER · wMER) » hors HIPE ; libellé de vue
+  humain. Tests `test_conformity` mis à jour (gate = « aucun cmer → None »).
+- **M2 — exactitude caractère & mot** ✅ : `char_accuracy = max(0, 1−CER)`,
+  `word_accuracy = max(0, 1−WER)` (métriques `higher_is_better`, RAW_TEXT, poids =
+  longueur réf → micro = 1−CER/WER micro), groupe « Exactitude », ajoutées au
+  profil `standard` (ordre contigu cer·cmer | char·word acc | wer·mer).
+- **M3 — Flexible Character Accuracy (FCA)** ✅ : exactitude caractère
+  **indépendante de l'ordre de lecture** par **appariement optimal de lignes**
+  (Hongrois `scipy` sur matrice de distances `rapidfuzz.cdist`) — déterministe.
+  `evaluation/metrics/flexible.py`, groupe « Exactitude », profil `standard`.
+  L'appariement **sous-ligne** récursif de Clausner (non déterministe) est
+  **différé** — assumé et documenté.
+- **M4 — Bag-of-Words P/R/F1** ✅ : multiset de tokens (`tp = Σ min comptes` ;
+  `P = tp/|hyp|`, `R = tp/|réf|`, `F1` harmonique) — `evaluation/metrics/bow.py`,
+  RAW_TEXT, déterministe, insensible à l'ordre ; groupe « Recherche · sac de
+  mots », profil `standard`. P/R agrègent en micro exact (poids |hyp|/|réf|) ;
+  F1 = moyenne pondérée par la taille (non linéaire, documenté).
+- **M5 — brancher Region-F1 ICDAR 2015** ✅ : `layout.py` la calculait déjà mais
+  aucune vue ne la portait. Ajout d'une **vue `structure`** (`_layout_view`,
+  `run_planning`) quand le corpus a une GT `LAYOUT` → `region_detection` (F1) +
+  `region_cer` calculés ; nouvelle **section `StructureSection`** (onglet
+  Engines) qui les rend par pipeline, **absente** si aucun run de segmentation.
+
+> ⚠️ Ce sont des tranches **moteur**, pas de la mise en page : à faire une par une
+> (axe 2 — surface incrémentale), chacune vérifiée + commitée seule. Non démarrées
+> en fin de session longue pour ne pas bâcler (cf. discipline anti-empilement).
+
+Chaque R#/M# : analyse ciblée → 1 correctif → capture/golden de vérif → `make ci`
+→ commit. **Cible visuelle = `design/screenshots/` (captures canoniques).**
+
+### Tranche L2 — défauts mise en page restants (analyse, MacBook ~1000–1280px)
+
+Constats vérifiés sur captures utilisateur + `design/screenshots/` + CSS (`html.py`).
+
+| # | Symptôme | Cause racine | Direction |
+|---|---|---|---|
+| **L2-a** | **Table métriques déborde / clippée** (13 colonnes, coupée à `HALLUCINAT…`) | (1) `standard` = **13 métriques** empilées (R2d+M2+M3+M4) ; (2) largeur/colonne excessive : en-têtes longs en CAPS (`CHAR_ACCURACY`, `BOW_PRECISION`, `SEARCHABILITY`), padding 14px (`html.py:130`), nombres 12px mono ; (3) **aucun `overflow-x`** autour de `table.data` (`.sec` `html.py:65` sans overflow) → clip viewport, pas de scroll. Le **canonique** fait tenir ~12 colonnes via en-têtes **courts** + cellules compactes. | (1) alléger `standard` (sortir bow → profil/section dédiée, ou profil « complet » opt-in) ; (2) **abréger les en-têtes** (le super-en-tête de groupe porte le contexte : « Recherche · sac de mots » → `P/R/F1` ; « Exactitude » → `car./mot/flex`) ; (3) envelopper les tables larges dans `overflow-x:auto`. |
+| **L2-b** | **Barres trop longues / sans signal** | `bar_cell` normalise par le **max de colonne** (`db-fill` width = value/col_max, `by_engine.py:69`+`html.py:124`). Deux moteurs proches (quasi toujours) → toutes barres ~pleines. Le **canonique n'a pas de barre-soulignement** : il **teinte la cellule** (fond clair ∝ magnitude). | Soit **échelle absolue [0,1]** pour métriques bornées (0.90→90 %, 0.10→10 %), soit **teinte de cellule** façon canonique (compact, résout aussi la largeur). |
+| **L2-c** | **Tables éparses désalignées** (`structured_data` STATUT/N/PART ; `word_errors` étroite) | Libellés en cellule **right-aligned** (`td.disp`) sous en-tête `STATUT` left → décalage ; table 3 colonnes étirée `width:100%` → colonnes éparpillées, grand vide central. Heatmap mots = table étroite + vide à droite. | Aligner le libellé à **gauche** (cohérent avec l'en-tête) ; **plafonner** la largeur des tables éparses (`max-width`, ne pas étirer) ou les disposer **côte à côte** (comme R3). |
+| **L2-d** | **Vue document loin du canonique + casse en fenêtre étroite** | Canonique « Par document » = **galerie compacte** (cartes vignette+titre+mini-barres). Cinoc drill-in = **image fixe 460px** (`html.py:174`) à gauche + diff **2 colonnes** [GT\|sortie] à droite. Bascule 1 colonne seulement < **860px** (`dd-top2`, `html.py:172`) et < **720px** pour `dd-sbs` (`html.py:190`) → à ~1000–1280px : image(½) + [GT\|sortie] tassés. | Cadre image **non fixe** (max-height en `vh`, ou ratio 40/60) ; **remonter** le point de bascule (empiler image au-dessus du diff dès ~1100px) ; en drill-in étroit, diff **unifié** plutôt que 2 colonnes. |
+| **L2-e** *(contenu)* ✅ | **Taxonomie « other » 70–76 %** | C'était le bucket des **vraies substitutions** (misreads), pas un échec de classif → renommé **« substitution »** + libellés FR lisibles (`_CLASS_LABELS`). | Fait — chart pertinent, données clés stables. |
+
+**Diagrammes cassés — réparés (vérif visuelle à 1120px, pas grep).**
+- **Barres percentiles CER** ✅ : `document_detail.py:115` `v*200` (saturait tout
+  ≥ 50 %) → `v*100` (échelle honnête 0–100 % ; p50 court, p99 plein).
+- **Carte thermique par ligne** ✅ : `html.py` `.dd-lh-bar` `flex:0 0 8px`
+  (5 barres tassées à gauche) → `flex:1 1 0;max-width:48px` + `justify-content:
+  center` → remplit la largeur, lisible comme un strip.
+- **Venn** ✅ : `svg.py` géométrie fixe → `_venn2_proportional` (rayon ∝ √|set|,
+  écart des centres ∝ 1−Jaccard **borné** ≥ 0.50·(r_a+r_b) pour ne pas devenir
+  concentrique quand Jaccard ≈ 1). Constat data : sur la presse BNL, les 2
+  Tesseract ratent ~les mêmes mots (crescents vides).
+- **L2-a** ✅ table métriques : en-têtes courts (`metric_short_label`) + `.table-scroll`.
+- **L2-c** ✅ tables éparses : libellés `td.lbl` à gauche + `table.data.compact` ;
+  heatmap mots + Venn recentrés.
+- **L2-d** ✅ vue document : cadre image `minmax(230px,38%)` (au lieu de 50 %) +
+  hauteur `clamp(300px,46vh,420px)` (au lieu de 460px fixe), bascule 1 colonne à
+  820px → le diff GT/sortie reçoit la largeur.
+- **L2-b** ✅ barres → **cellules teintées** (option A canon) : `bar_cell` pose
+  `--t` (= value/col_max), fond sauge ∝ `--t` ; `.db-fill` conservé pour
+  image_quality/word_errors (longueur = score). Fin des barres saturées.
+
+> ⚠️ L2-a est en partie **auto-infligé** : verser M2/M3/M4 d'office dans `standard`
+> a fait passer la table de 7 à 13 colonnes. Le **canonique** privilégie un socle
+> resserré + cellules compactes — à rapprocher. Tranche **mise en page**, par
+> petits correctifs vérifiés (un défaut, une capture vs canon, un commit).
diff --git a/cinoc/reports/ANALYSE_VUE_DOCUMENT.md b/cinoc/reports/ANALYSE_VUE_DOCUMENT.md
new file mode 100644
index 0000000000000000000000000000000000000000..529d5e9ac5efa921ca6b6c3b19397550ac3118e0
--- /dev/null
+++ b/cinoc/reports/ANALYSE_VUE_DOCUMENT.md
@@ -0,0 +1,53 @@
+# Analyse — vue document du rapport (refonte)
+
+Guide durable de la refonte de la vue document (détail au clic d'une carte de
+galerie). Établi après revue de la vue document de Picarones (lecture seule,
+`../Picarones/picarones/reports/html/templates/view_document.html` +
+`_styles.css` + `_app.js`).
+
+## Constat
+
+La vue document de Cinoc empilait des blocs sans **logique de présentation** :
+image à taille variable (le layout saute d'un doc à l'autre), colonnes GT/sortie
+non alignées en police dense, graphiques peu pertinents. Picarones — UI sobre
+mais **lisible** — repose sur trois cartes nettes : transcription, distribution
+par ligne, hallucinations.
+
+## Cible (ordre de présentation, haut → bas)
+
+1. **En-tête** : identifiant + CER par moteur (compact).
+2. **Fac-similé** : boîte à **hauteur fixe**, `object-fit:contain`, zoomable/pan
+   (ne saute plus entre documents).
+3. **Transcription GT | sortie** : **grille 2 colonnes égales**, chaque colonne
+   une **carte bordée** (en-tête libellé + badge CER) ; corps **serif**,
+   `line-height:1.8`, `max-height` scrollable, `white-space:pre-wrap`. Sélecteur
+   de moteur. Diff caractère conservé (suppression = fond doux, sans barré).
+4. **Distribution des erreurs par ligne** (riche) : carte thermique de position
+   (début→fin) + **percentiles CER** (p50→p99) + badges (Gini, n lignes,
+   % lignes au-dessus de seuils). Les données par ligne existent déjà
+   (`DocumentLinesCollector`) ; le rendu est enrichi.
+5. **Analyse des hallucinations** par moteur : ancrage, ratio de longueur,
+   insertion nette, comptes de mots GT/sortie, **+ les blocs hallucinés
+   affichés**. À porter de `hallucination.py` (Cinoc n'a que le scalaire).
+6. **Qualité d'image** : **une ligne indicative** (les mesures sont réelles mais
+   les seuils sont des conventions non calibrées — pas un bloc de jauges qui
+   suggère une précision absente).
+
+## Décisions
+
+- **Taxonomie catégorielle** (casse/diacritiques/…/`other`) : reste un outil de
+  **niveau corpus** (agrégée, `other` n'y domine pas). **Pas** dans la vue
+  document : sur un seul document `other` écrase tout, et l'exclure casserait la
+  validité (elle prétendrait l'exhaustivité). On ne la tronque jamais.
+- **Composition suppression / insertion / substitution** : **exhaustive**
+  (∑ = 100 %, aucun `other`) → décomposition honnête de la nature des erreurs ;
+  s'articule avec l'insertion nette des hallucinations (ne pas doublonner).
+- Les graphiques restent **déterministes**, lecture seule du `RunResult`, aucun
+  texte généré (anti-hallucination du rapport).
+
+## Tranches
+
+- **P1** — cadre lisible : boîte image fixe + transcription 2 colonnes
+  bordées/serif + hiérarchie en cartes.
+- **P2b** — analyse des hallucinations par document (collecteur + payload + rendu).
+- **P2a** — distribution par ligne riche (percentiles + Gini + seuils + heatmap).
diff --git a/cinoc/reports/DECISION_RAPPORT_INTERACTIF.md b/cinoc/reports/DECISION_RAPPORT_INTERACTIF.md
new file mode 100644
index 0000000000000000000000000000000000000000..6bf76f8b981fe8a284971bbac5f899d59ab1aabd
--- /dev/null
+++ b/cinoc/reports/DECISION_RAPPORT_INTERACTIF.md
@@ -0,0 +1,190 @@
+# Décision — Rapport interactif **et** autonome (images + interactivité)
+
+> **Statut : décision actée** (conversation de design, juin 2026). Les **formes
+> exactes** (noms de champs, budgets chiffrés) sont **à confirmer au build** —
+> seul le *cadre* est figé ici. Journal : `MIGRATION_PLAN.md` D-094.
+
+> ⚠️ **MISE À JOUR — refonte « instrument neutre » (2026-06, `MIGRATION_PLAN.md`
+> D-190).** Le découpage **« 4 onglets par sujet »** ci-dessous est **renversé** au
+> profit d'une partition par **mode d'interaction** : bascule `[ Rapport |
+> Explorer ]` — **Rapport** défilant/imprimable/citable (spine collant, divulgation
+> progressive) + **Explorer** de triage à facettes. Principe directeur ajouté :
+> **le rapport ne donne aucun verdict** (pas de gagnant déclaré), il expose
+> données + analyse auditable, l'utilisateur interprète (cohérent avec « moteur
+> narratif supprimé » et l'invariant anti-hallucination). Restent valides ci-dessous :
+> autonomie, images = références, SVG inline, script mince CSP-hashé, drill-in
+> plafonné. Suivi des tranches T0→T7 : D-190.
+
+Ce document fige l'architecture du **rapport HTML** de Cinoc après le constat
+que le rapport plat actuel (sections empilées + sommaire à ancres) est **loin**
+de la cible (onglets, galerie à vraies vignettes, drill-in document, graphes).
+
+---
+
+## 1. Principe : autonome ≠ statique
+
+L'erreur à ne pas commettre : croire qu'« autonome » impose « statique ». Un
+fichier HTML autoportant peut être **interactif hors-ligne** (Picarones le fait ;
+Cinoc le fait déjà à petite échelle — widget compare, nav clavier, scripts
+inline épinglés CSP). Le piège n'est **pas** l'interactivité — c'est la **manière**
+de Picarones : ~3 400 lignes de JS écrit main + Chart.js vendoré + un data-layer
+qui ré-agrège.
+
+**On vise l'interactivité, mais DISCIPLINÉE** (≠ la SPA Picarones) :
+
+1. **Une seule « île de données »** : le `RunResult` embarqué tel quel
+   (`<script type="application/json">` inerte). Unique source en navigateur —
+   **aucun data-layer qui recalcule**.
+2. **Enrichissement progressif** : le serveur rend **tout** le contenu en HTML
+   (le `Protocol Section` unique reste). Le JS **navigue** (montre/cache/scrolle
+   des panneaux *déjà rendus*), il ne **construit** rien. Onglets = bascule de
+   visibilité ; drill-in = révéler un panneau déjà dans le DOM. → JS mince
+   (~200-400 lignes), dégradé propre sans JS.
+3. **Un seul petit script, épinglé CSP** (mécanisme `embedded.py` existant :
+   sha256 sur `/reports/`). Autonome, déterministe (script statique → octets
+   stables).
+4. **Graphes en SVG inline** rendus **côté serveur** depuis les données.
+   **Pas de Chart.js** (cf. §6).
+
+> ⚠️ Ce cadre **nuance une décision documentée** (`CLAUDE.md §8`, analyse
+> couche 7 : anti « rapport-application »). On ne revient PAS à la SPA Picarones ;
+> on passe de « zéro interactivité riche » à « interactivité **disciplinée** ».
+> Revirement assumé et consigné (journal D-094) — pas un passage en force.
+
+---
+
+## 2. Images : le `RunResult` porte des **références**, jamais les octets
+
+Invariant : le `RunResult` canonique reste **maigre et hashable** (déterminisme,
+historique, repro). Il porte, par document, une **référence** d'image (URL IIIF
+ou chemin relatif dans le corpus store), **jamais les octets**. Les images sont
+un **intrant au moment du rendu**, pas un champ du résultat.
+
+Conséquence : on peut générer **n'importe quelle saveur** de rapport plus tard,
+sans re-run, tant que la source image est joignable.
+
+---
+
+## 3. Stratégie image, décidée **par document** au rendu
+
+| Le doc a… | Stratégie | Coût | Hors-ligne |
+|---|---|---|---|
+| une **URL IIIF** | référencer IIIF à la bonne taille (`…/full/250,/…`) | ~nul | ❌ réseau |
+| une **image locale**, mode dossier | dérivés (vignette + medium) dans `report-assets/` | génération + disque | ✅ |
+| une **image locale**, mode fichier | vignette embarquée (250 px / 64 px si gros + budget) | poids HTML | ✅ |
+| **rien** | aperçu CSS synthétique | nul | ✅ |
+
+On **ne sert jamais l'original brut** dans une grille (fac-similés patrimoniaux
+= plusieurs Mo). En mode dossier/local on génère des **dérivés** : vignette
+~250-400 px (grille) + medium ~1600-2048 px (drill-in). L'original n'est gardé
+que si le zoom pixel l'exige (cf. §7 — il ne l'exige pas).
+
+---
+
+## 4. Saveurs de rapport (un `RunResult` → plusieurs sorties, choisies à la génération)
+
+| Saveur | Images | Hors-ligne | Scale | Idéal pour |
+|---|---|---|---|---|
+| **Fichier unique** | vignettes embarquées (250/64 px + budget) | ✅ | plafonné | partager un verdict |
+| **Dossier** | dérivés dans `report-assets/` | ✅ (comme dossier) | milliers | archive locale d'un gros run |
+| **Réfs IIIF / HF** | `<img>` vers URLs durables (IIIF statique / dataset) | ❌ | ∞ | rapport-lien riche, durable |
+| **Servi (app web)** | images servies à la demande | ❌ | ∞ | exploration en ligne, le plus riche |
+
+> **Abandonné** : servir les images depuis l'app-Space comme socle d'un fichier
+> « autonome » (FS éphémère + free-tier qui dort → fragile ; rend le fichier
+> dépendant du Space). L'app web sert pour la saveur **« servie »**, pas pour
+> adosser un fichier prétendu autonome.
+
+---
+
+## 5. Budgets & plafonds (le vrai garde-fou d'échelle)
+
+Le coût galerie + drill-in est en **O(nombre de docs)** ; le « verdict »
+(agrégats, graphes, croisements) est en **O(moteurs × métriques)** — négligeable.
+Donc on **borne** la partie par-document, par un **budget d'octets dur** (≠ simple
+comptage) :
+
+- **Galerie** : toutes les cartes (vignette lazy + CER/badges). Tient à des
+  milliers tant qu'on **ne pré-rend pas** les panneaux de drill-in.
+- **Drill-in texte « page complète »** (diff GT ↔ sortie OCR) : **plafonné par
+  budget** (~2-3 MB → **~100-200 pages moyennes**, moins pour de la presse
+  dense), **pires-d'abord**. Au-delà → « voir le texte complet dans l'app web ».
+- **Choix de mode au lancement** (selon nombre de docs) **+ application du budget
+  au rendu** (le poids réel dépend des vraies images/textes). Déterministe :
+  même corpus → même profil → même rapport.
+
+Pourquoi un budget plutôt qu'un comptage : un corpus de 300 docs à gros
+fac-similés peut peser plus qu'un de 1500 docs en texte court. Le budget garantit
+**le fichier ne dépasse jamais X MB, point.**
+
+`file://` interdit `fetch` → en hors-ligne on **ne peut pas** charger le texte à
+la demande : d'où le plafond embarqué + le renvoi à l'app web (servie → `fetch`
+autorisé → tout en lazy, zéro mur).
+
+---
+
+## 6. Graphes : SVG inline, **pas Chart.js**
+
+| | SVG inline (retenu) | Chart.js (rejeté) |
+|---|---|---|
+| Déterminisme | ✅ markup, octet-stable (arrondi flottants fixé) | ❌ canvas runtime, non reproductible |
+| Autonomie | ✅ zéro lib | ❌ blob ~200 KB vendoré/rapport |
+| Accessibilité | ✅ vrai DOM, `<title>`/aria, sélectionnable | ❌ pavé de pixels opaque |
+| Besoin réel | dispersion, IC, courbe calibration, donut = formes simples | sur-dimensionné |
+
+Le SVG nous **donne** nos invariants là où Chart.js nous les **coûte**.
+
+---
+
+## 7. Onglets, drill-in, zoom
+
+- **Onglets** : 4 (Vue d'ensemble / Par moteur / Par document / Croisements),
+  par enrichissement progressif (panneaux rendus serveur, JS bascule la
+  visibilité).
+- **Drill-in document** : clic sur une vignette → fac-similé (medium) + diff
+  GT ↔ sortie OCR + CER par moteur + clic moteur pour changer le diff. Borné
+  hors-ligne (§5), complet en app web.
+- **Zoom** : image **medium ~1600-2048 px** + pan/zoom CSS léger. **Pas de
+  deep-zoom** (pas de pyramide de tuiles, pas de viewer type OpenSeadragon). À
+  1600-2048 px on lit chaque caractère — suffisant pour l'inspection d'erreur
+  OCR. Décision nette, pas un palier différé.
+
+---
+
+## 8. Correction d'un record antérieur (D-086)
+
+D-086 justifiait la « galerie synthétique » par « Picarones n'embarque pas les
+images par défaut ». **C'est une mauvaise lecture** : le code Picarones affiche
+une **vraie vignette `<img>` dès qu'une image est dispo** (« cas standard pour
+`picarones demo` »), le synthétique n'étant que le **fallback**. Cinoc avait
+donc reproduit le **mode dégradé** et l'avait pris pour le design.
+
+**Cible corrigée** : galerie à **vraies vignettes** ; synthétique = **dégradé
+gracieux** (pas de Pillow, pas d'image, ou budget dépassé).
+
+---
+
+## 9. Frontière fichier ↔ app web (récap)
+
+| | Fichier autonome (uni/dossier) | App web servie |
+|---|---|---|
+| Galerie | vignettes (embarquées/dérivées), bornée par budget | complète, paginée, lazy |
+| Drill-in texte | plafonné (~100-200 pages) | complet (fetch à la demande) |
+| Images | embarquées / `report-assets/` / réfs IIIF | servies à la demande |
+| Réseau | hors-ligne (sauf saveur réfs IIIF) | en ligne |
+
+---
+
+## 10. Implications d'enveloppe (à concevoir au build)
+
+- **`domain`/`evaluation`** : `RunDocumentResult` (ou un index parallèle) gagne
+  une **référence image optionnelle** (URL IIIF | chemin corpus-relatif). Forme
+  exacte à confirmer — surtout **pas** d'octets dans `RunResult`.
+- **`reports`** : générateur paramétré par **saveur** + un **intrant images**
+  (mapping doc → source) ; SVG charts ; île de données ; un script mince
+  CSP-hashé ; rendu **par onglets** (sections regroupées en 4).
+- **`app`/`interfaces`** : la saveur « servie » expose galerie paginée + drill-in
+  à la demande (l'app web n'a pas la contrainte d'autonomie).
+
+L'ordre reste **interne → externe**, par **tranches verticales** (squelette
+d'abord). Première tranche à cadrer séparément.
diff --git a/cinoc/reports/PLAN_UI_RAPPORT.md b/cinoc/reports/PLAN_UI_RAPPORT.md
new file mode 100644
index 0000000000000000000000000000000000000000..66b58e97e9be9bd0d184c5764a938b5c766d8c61
--- /dev/null
+++ b/cinoc/reports/PLAN_UI_RAPPORT.md
@@ -0,0 +1,223 @@
+# Plan UI/UX — Rapport interactif : de la coquille à la cible `design/`
+
+> **Statut : plan validé** (recommandations ★ retenues, décision IA (c) validée —
+> D-096). Complète `DECISION_RAPPORT_INTERACTIF.md` (D-094, le *cadre*) par le
+> *design d'expérience*. La source visuelle canonique est **`design/`**
+> (`tokens.css` + `chrome.jsx` + 4 vues JSX + screenshots — D-018) : ce doc mappe
+> chaque élément de la cible sur (a) sa faisabilité données, (b) son implémentation
+> disciplinée, (c) sa tranche.
+>
+> **Ce doc porte LA file unique du chantier rapport** (§4) : il remplace toute
+> numérotation antérieure de tranches (le pointeur « tranche 2 = graphes SVG »
+> de D-095 ≙ U2 ici ; les « tranches 3/4 images » de D-094 ≙ T3/T4 en queue de
+> file). Pas de double comptabilité : une seule séquence, U1 → … → T4.
+>
+> **Décision IA (D-096, validée)** : les **4 onglets sont confirmés**
+> (Vue d'ensemble / Par moteur / Par document / Croisements — option (c)), avec
+> deux amendements : (1) la **significativité apparaît inline dans le verdict**
+> (badges « écart significatif / non séparable » sur le classement de la Vue
+> d'ensemble — le verdict n'est jamais lu sans sa qualification ; Croisements
+> reste l'approfondissement, et accueillera la famille inter-moteurs de
+> l'étape 4e) ; (2) **règle de croissance** : *un onglet = une question, une
+> section = une réponse* — chaque famille de métriques de l'étape 4 atterrit
+> dans l'onglet de la question qu'elle éclaire (fidélité/philologie → Moteurs ;
+> lignes/pires-cas → Documents ; inter-moteurs → Croisements), jamais un onglet
+> par famille.
+
+---
+
+## 1. Diagnostic — écart rendu actuel ↔ cible `design/`
+
+| # | Aspect | Actuel | Cible (`design/`) | Nature |
+|---|---|---|---|---|
+| 1 | Chrome | barre noire : wordmark + titre | wordmark + **onglets intégrés** + méta (docs/moteurs/date) + **boutons ⬇CSV ⬇JSON** (`chrome.jsx`) | visuel/fonctionnel |
+| 2 | Onglets | barre pilule **séparée**, mono 12px | **dans le chrome**, fond translucide, `--sans` 12px **medium**, actif = pilule `--paper` (`tokens.css:166`) | visuel |
+| 3 | Anatomie de vue | h2 empilés dans **un seul** méga-panneau `.sec` | **héros de vue** (eyebrow `VUE 0n · NOM` + titre display + desc + stats) puis **cartes `.sec` distinctes**, parfois en grille 2 col. (`HeroBand`, vues JSX) | structurel |
+| 4 | Onglet Documents | table dense d'abord, galerie passive ensuite | **galerie = l'entrée** (cartes cliquables) + filtres strate + toggle ⊞ Grille / ≡ Liste ; table = le mode Liste | **UX (inversion)** |
+| 5 | Drill-in | aucun | **profil moteur** (clic ligne → KPIs, CER/doc, calibration, composition) et **détail document** (fac-similé + CER/moteur + diff avec sélecteur de moteur, prev/next, ← retour) | UX/fonctionnel |
+| 6 | Glossaire | section toujours en bas | la cible dit : « **survoler pour la définition** » (en-têtes de table, `view-by-engine.jsx:87`) | UX |
+| 7 | Tables | statiques | **triables** (clic en-tête, flèches ↑↓, chip « ORDRE ACTIF », réinitialiser) ; « cliquer une ligne pour ouvrir le profil » | fonctionnel |
+| 8 | Graphes | aucun (tables) | dispersion min/méd/µ/max, courbe calibration, CER/doc trié, composition d'erreurs | fonctionnel (T2 actée) |
+| 9 | Strates | inexistantes au rendu | composition du corpus (%, n), chips de filtre, CER par strate | **données manquantes** |
+| 10 | Exports | CSV en CLI seulement, JSON côté web | boutons dans le chrome | fonctionnel |
+
+---
+
+## 2. Principes UX (le « pourquoi » avant le « quoi »)
+
+1. **Le rapport répond à 4 questions** — c'est l'IA des onglets :
+   *Qui gagne ?* (Vue d'ensemble) · *Comment se comporte chaque moteur ?* (Par
+   moteur) · *Où ça casse, sur quelles pages ?* (Par document) · *Les écarts
+   sont-ils réels ?* (Croisements).
+2. **Trois espaces de navigation, jamais mélangés** :
+   - **vues** = onglets (changer de question) ;
+   - **objets** = drill-ins (zoomer sur *un* moteur, *un* document — avec
+     « ← retour », prev/next) ;
+   - **périphérie** = chrome (méta, exports, compare, glossaire, palette) —
+     accessible partout, jamais dans le flux de lecture.
+   Le glossaire en bas violait ça : c'est de la périphérie, pas du flux.
+3. **Pyramide de l'évidence** : chaque vue ouvre sur le verdict (héros + readouts),
+   puis le détail (tables/graphes), puis la preuve (drill-in). Jamais l'inverse.
+4. **La définition vient au point d'usage** (survol d'un en-tête), pas dans un
+   appendice. Le glossaire YAML existant devient la *source* de ces tooltips.
+5. **Discipline D-094 inchangée** : le serveur rend tout ; le JS révèle/trie/
+   navigue, ne construit jamais ; un script CSP-hashé ; dégradé propre sans JS.
+
+---
+
+## 3. Propositions par chantier
+
+### A. Chrome unifié ⚖️
+
+- **A1 ★ (= la cible)** : onglets **dans** la barre noire (`tokens.css` les stylise
+  déjà : fond `rgba(paper,0.08)`, actif pilule paper/ink, `--sans` 500) + méta
+  `n docs · n moteurs · date` (du `RunManifest`) + boutons **⬇CSV ⬇JSON**.
+- **A2** : garder la barre séparée, la rendre sticky. — Rejeté : double bandeau,
+  diverge de la source canonique sans raison.
+- **Exports** ⚖️ : (a) `href="data:…"` zéro JS mais **double le poids** du fichier
+  (le JSON y serait deux fois) ; **(b) ★ Blob depuis l'île de données** (~10 lignes
+  JS) — l'île `RunResult` arrive de toute façon (D-094), le CSV se dérive client
+  des mêmes données (ou 2ᵉ île CSV si plus simple, à trancher au build).
+
+### B. Anatomie de vue : héros + cartes ⚖️
+
+- Casser le **méga-`.sec`** : `render_document` n'enveloppe plus tout dans une
+  carte unique ; chaque section rend **sa** carte.
+- **Héros par onglet** (serveur) : eyebrow `VUE 01 · VUE D'ENSEMBLE`, titre
+  display, description, 2-3 stats à droite — calculés du `RunResult`.
+- **B1** : générique — chaque section = une carte, grille auto. Simple mais ne
+  donne pas les compositions de la cible (Identité ⟷ Composition côte à côte).
+- **B2 ★** : une **couche « vue » mince** en couche 7 : chaque onglet a un
+  compositeur (fonction, pas un nouveau Protocol) qui place le héros + arrange
+  ses cartes de section (grilles où la cible le dicte). Le `Protocol Section`
+  reste le seul contrat de **contenu** ; la vue n'est que de l'**agencement**.
+  C'est l'évolution structurelle clé — sans elle on n'atteint jamais la cible.
+
+### C. Onglet Documents : la galerie devient l'entrée ★ (décision utilisateur)
+
+- **Galerie en tête** (cartes cliquables), **table `by_document` = mode « ≡ Liste »**
+  derrière un toggle ⊞/≡ (comme la cible). Plus de doublon visuel.
+- **Détail document au clic**, livré en deux temps honnêtes :
+  - *dès maintenant* (« détail léger », données déjà là) : CER par moteur (barres),
+    scores du doc, pires lignes **de ce doc** si présentes dans `diagnostics` ;
+  - *T3/T4 (D-094)* : vignette réelle puis fac-similé medium + **diff complet**
+    avec sélecteur de moteur (borné par budget hors-ligne).
+- **Mécanique drill-in** ⚖️ : (a) `<details>` inline sous la carte — zéro routing
+  mais pas de « page » ni prev/next, à l'étroit ; **(b) ★ panneaux serveur cachés
+  + hash** (`#doc-<id>`) — donne « ← retour à la galerie », prev/next, deeplink
+  partageable, cohérent avec les onglets (même pattern révéler/cacher). Le nombre
+  de panneaux détail suit le **budget** D-094 (pas un panneau par doc à 5000).
+
+### D. Profil moteur (drill-in n°2)
+
+Clic sur une ligne du tableau → panneau profil : bande KPI (CER médian/étendue,
+WER, ECE, €/1000p — données présentes), CER par document (graphe T2), courbe de
+calibration (payload existant), composition d'erreurs (payload taxonomy). 5-10
+moteurs → panneaux cachés **toujours** bon marché (pas de question de budget).
+Prev/next + « ← retour au tableau ». Même mécanique hash que C.
+
+### E. Glossaire : contextuel, plus jamais en appendice ⚖️ (décision utilisateur)
+
+- **E1 ★** : **définitions au survol des en-têtes** de métriques — `title=` (ou
+  tooltip CSS enrichi) alimenté par `glossary/{fr,en}.yaml`. C'est littéralement
+  ce que la cible écrit (« survoler pour la définition »). Zéro JS.
+- **E2 ★ (complément)** : entrée « Glossaire » **dans le chrome** (coin méta) →
+  `<dialog>` natif (modal, Échap, focus-trap navigateur, zéro lib) listant les
+  définitions des métriques présentes.
+- **E3** : panneau latéral « ? » par titre de section (à la Picarones). — Plus
+  lourd, redondant avec E1+E2.
+- La `GlossarySection` bas-de-page **disparaît** (le YAML + loader restent, deux
+  nouveaux consommateurs).
+
+### F. Tables vivantes
+
+- **Tri client** par clic d'en-tête (~40 lignes JS : lire les `<td>` du DOM rendu,
+  réordonner les `<tr>` — aucune donnée reconstruite), `aria-sort`, flèches ↕↑↓,
+  chip « ordre actif / réinitialiser » (retour à l'ordre manifeste).
+- En-têtes : acronyme + flèche + min-méta (`th-acro`/`th-meta` de la cible) +
+  définition au survol (E1).
+- « Cliquer une ligne ouvre le profil » (lié à D).
+
+### G. Graphes SVG (T2 — actée, concrétisée ici)
+
+Réalistes **avec les données présentes** : dispersion par moteur (bande
+min·méd·µ·max depuis `documents`), courbe de calibration (bins du payload),
+CER par document trié (profil moteur), composition d'erreurs (taxonomy).
+**Pas** d'intervalle de confiance bootstrap : non calculé aujourd'hui — le
+graphe IC attendra la stat (étape 4) ; on ne dessine pas ce que le moteur ne
+produit pas. Convention d'arrondi fixée à cette tranche (déterminisme).
+
+### H. Strates (composition du corpus, filtres galerie, CER/strate)
+
+**Bloqué par l'enveloppe** : `RunDocumentResult` ne porte aucune métadonnée ;
+`CorpusSpec.metadata` existe mais ne descend pas au document dans le résultat.
+Extension **petite et légitime** (un champ métadonnées/strate optionnel au niveau
+document du résultat) → à faire **avec ses consommateurs** (carte Composition +
+chips filtre + CER par strate), comme tranche dédiée. Pas un préalable des autres
+chantiers.
+
+### I. Micro-polish transversal
+
+Nombres FR (`1,4 %`, espace fine insécable) — formatage de la **langue par
+défaut**, indépendant de l'anglais ; densités/espacements des cartes alignés sur
+`tokens.css` ; états vides soignés par vue ; `prefers-reduced-motion` pour le
+scroll ; impression (CSS print : onglets → empilé).
+
+> **i18n complète du rapport (D-114)** : le **contenu des sections** est FR en
+> dur (le chrome est bilingue). La traduction FR/EN **complète** est une **passe
+> finale, APRÈS P2** (métriques) — on n'internationalise pas une cible mobile :
+> P2 ajoute ~6 sections, donc i18n d'office maintenant = surcoût par tranche ou
+> anglais « moitié traduit ». Une seule passe, surface stable. Cf.
+> `PLAN_FIN_MIGRATION.md` (séquencement i18n).
+
+---
+
+## 4. Plan séquencé (chaque tranche : visible, testée, `make ci`)
+
+| Tranche | Contenu | Dépend de | Effet |
+|---|---|---|---|
+| **U1 — Design system** | A1 (chrome+tabs+méta+exports) · B2 (héros + cartes par vue) · E1+E2 (glossaire contextuel, dépose la section) · typo onglets | rien | le rapport *ressemble* à la cible |
+| **U2 — Graphes SVG + verdict qualifié** | G (dispersion · calibration · CER/doc · composition) · **badges de significativité inline** sur le classement de la Vue d'ensemble (D-096) | U1 (cartes où les poser) | les vues *parlent*, le verdict est *qualifié* |
+| **U3 — Tables vivantes + profils moteur** | F (tri, survol-définitions) · D (drill-in moteur) | U1, U2 | l'exploration *moteur* |
+| **U4 — Documents : galerie-entrée + détail** ✅ (U4a/U4b) | C (galerie d'abord, toggle ⊞/≡, hash-drill-in, détail données-présentes) | U1 | l'exploration *document* |
+| **T3 — Vraies vignettes** (= P1, `PLAN_FIN`) | réf image dans l'enveloppe (P0) + vraies vignettes (budget) | P0 | la galerie devient *réelle* |
+| **T4 — Fac-similé + diff complet** (= P1) | fac-similé medium + diff complet borné dans le détail document | T3 | la *preuve visuelle* |
+| **U5′ — Strates** (forme **optionnelle**, = P1) | métadonnée strate optionnelle (P0) + composition + filtres galerie + CER/strate, **rendus si présents** ; démo élargie multi-genre | P0, U4 | la dimension *corpus* |
+
+> **Repositionnement (D-109)** : U5/T3/T4 sortent de cette « file UI » et
+> deviennent les **Phases P0→P1** du `PLAN_FIN_MIGRATION.md` (scope v1 élargi :
+> images + strates + **dataset de référence** + saveurs). **Correction** : les
+> images **ne sont pas** « bloquées sur producteur » (`DocumentRef.image_uri`
+> existe, l'upload garde les images) — T3/T4 sont constructibles. Les strates
+> prennent une **forme optionnelle** (champ `metadata` + rendu conditionnel),
+> avec le **dataset curé (P3)** comme producteur réel à l'échelle.
+
+**File UI livrée** : U1 → U2 → U3 → U4 ✅. La suite (images/strates/saveurs/dataset)
+est portée par les **phases P0→P4** de `PLAN_FIN_MIGRATION.md`. Logique de l'ordre
+UI : U1 d'abord parce que tout le reste se pose *dans* ses cartes et son chrome ;
+graphes avant drill-ins parce que les profils moteur (U3) les réutilisent ;
+documents (U4) avant strates parce que les
+filtres sans galerie-entrée n'ont pas de sens ; les images (T3/T4) closent la
+file parce qu'elles seules touchent l'enveloppe.
+
+---
+
+## 5. Garde-fous spécifiques à ce chantier
+
+- **Budget JS global du rapport** : viser ≤ ~600 lignes cumulées (`report.js` +
+  tri + drill-ins + exports). Chaque ligne JS *révèle, trie ou navigue* du DOM
+  rendu serveur — jamais ne construit du contenu. Si on s'approche du budget,
+  on élague avant d'ajouter.
+- **Pas de section en avance sur la donnée** (IC bootstrap, strates avant H…).
+- **Règle de croissance de l'IA** (D-096) : *un onglet = une question, une
+  section = une réponse*. Les familles de métriques de l'étape 4 atterrissent
+  dans l'onglet de leur question — jamais un onglet par famille, jamais un
+  5ᵉ onglet sans décision explicite.
+- **La couche « vue » (B2) est de l'agencement**, pas un second contrat : si un
+  compositeur de vue se met à calculer des données, il est au mauvais étage.
+- **Sans JS, tout reste lisible** : onglets empilés, tables non triées mais
+  complètes, drill-ins dépliés ou accessibles par ancre, dialog glossaire → la
+  cible `<details>` de repli. À tester (un test « no-JS markup complet »).
+- Déterminisme : tri = runtime client (le HTML livré reste octet-stable) ;
+  arrondi SVG fixé ; hash CSP recalculé à chaque évolution de script (mécanisme
+  `embedded.py` existant).
diff --git a/cinoc/reports/__init__.py b/cinoc/reports/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..aabccd703f2fc551c0d69f465403d5298f797ae6
--- /dev/null
+++ b/cinoc/reports/__init__.py
@@ -0,0 +1,24 @@
+"""Couche 7 — ``reports`` : sections typées + assemblage HTML autonome.
+
+Lit le ``RunResult`` **directement** (pas de data-layer). ``__init__`` mince.
+"""
+
+from __future__ import annotations
+
+from cinoc.reports.compare import MetricDelta, compare_runs, render_comparison
+from cinoc.reports.html import escape, render_document
+from cinoc.reports.renderer import ReportRenderer, default_report_renderer
+from cinoc.reports.section import Html, Section, SectionContext
+
+__all__ = [
+    "Html",
+    "MetricDelta",
+    "ReportRenderer",
+    "Section",
+    "SectionContext",
+    "compare_runs",
+    "default_report_renderer",
+    "escape",
+    "render_comparison",
+    "render_document",
+]
diff --git a/cinoc/reports/_anomaly.py b/cinoc/reports/_anomaly.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ca6a63674ab8a0d8c76e7e843ace53526fcde6a
--- /dev/null
+++ b/cinoc/reports/_anomaly.py
@@ -0,0 +1,116 @@
+"""Détection d'anomalies par document pour le triage **Explorer** (couche 7).
+
+Quatre signaux **factuels et auditables** dérivés du ``RunResult`` (présentation
+seule — la donnée reste dans le ``RunResult``). **Aucun seuil absolu arbitraire** :
+les trois signaux quantitatifs utilisent un **cutoff relatif** = le quantile
+``_QUANTILE`` (P90) de la distribution **observée** dans ce run. Pour chaque
+document, on renvoie l'ensemble des types déclenchés par **au moins un** moteur.
+
+- ``cer``        — un moteur a un CER ≥ P90 des CER par (doc, moteur).
+- ``unanchored`` — un moteur a une part de texte non ancré ≥ P90.
+- ``disagree``   — l'écart max−min de CER entre moteurs ≥ P90 des écarts (≥ 2 moteurs).
+- ``inserted``   — l'analyse signale ≥ 1 bloc inséré sans appui GT (fait déjà calculé).
+
+Les **cutoffs** sont renvoyés pour être **affichés** (le critère est sous les yeux).
+"""
+
+from __future__ import annotations
+
+import math
+
+from cinoc.evaluation.analysis import DocumentHallucinationPayload
+from cinoc.evaluation.result import RunResult
+
+#: Quantile servant de seuil **relatif** (P90 = les 10 % les plus élevés observés).
+_QUANTILE = 0.90
+
+#: Ordre canonique de rendu des facettes + libellés bilingues (FR, EN).
+ANOMALY_ORDER: tuple[str, ...] = ("cer", "unanchored", "disagree", "inserted")
+ANOMALY_LABELS: dict[str, tuple[str, str]] = {
+    "cer": ("CER élevé", "High CER"),
+    "unanchored": ("Texte non ancré", "Unanchored text"),
+    "disagree": ("Désaccord moteurs", "Engine disagreement"),
+    "inserted": ("Bloc inséré sans appui GT", "Inserted block (no GT)"),
+}
+
+
+def _percentile(values: list[float], q: float) -> float | None:
+    """Cutoff par **rang le plus proche** (déterministe) : valeur au rang ``⌈q·N⌉``.
+
+    Pas d'interpolation (octet-stable) ; ``None`` si pas de valeur."""
+    if not values:
+        return None
+    ordered = sorted(values)
+    k = max(0, math.ceil(q * len(ordered)) - 1)
+    return ordered[k]
+
+
+def _by_doc(result: RunResult, view: str, metric: str) -> dict[str, list[float]]:
+    out: dict[str, list[float]] = {}
+    for doc in result.documents:
+        if doc.view != view:
+            continue
+        for score in doc.scores:
+            if score.metric == metric and score.value is not None:
+                out.setdefault(doc.document_id, []).append(score.value)
+    return out
+
+
+def _inserted_docs(result: RunResult) -> set[str]:
+    """Documents portant ≥ 1 bloc inséré sans appui GT (collecteur = blocs présents)."""
+    flagged: set[str] = set()
+    for analysis in result.analyses:
+        payload = analysis.payload
+        if isinstance(payload, DocumentHallucinationPayload):
+            for row in payload.documents:
+                if any(p.blocks for p in row.pipelines):
+                    flagged.add(row.document_id)
+    return flagged
+
+
+def compute_anomalies(
+    result: RunResult, view: str
+) -> tuple[dict[str, set[str]], dict[str, float]]:
+    """``(anomalies_par_doc, cutoffs_affichables)`` pour la vue ``view``.
+
+    ``anomalies_par_doc[doc_id]`` = ensemble des types déclenchés (≥ 1 moteur).
+    ``cutoffs`` = seuil retenu par type quantitatif (pour l'affichage du critère)."""
+    cer = _by_doc(result, view, "cer")
+    unanchored = _by_doc(result, view, "hallucination")
+    cer_cut = _percentile([v for vs in cer.values() for v in vs], _QUANTILE)
+    unanch_cut = _percentile([v for vs in unanchored.values() for v in vs], _QUANTILE)
+    spreads = {
+        doc_id: max(vs) - min(vs) for doc_id, vs in cer.items() if len(vs) >= 2
+    }
+    spread_cut = _percentile(list(spreads.values()), _QUANTILE)
+    inserted = _inserted_docs(result)
+
+    # Comparaison **stricte** (``>``) au cutoff : on ne flague que ce qui dépasse
+    # *réellement* le P90 — sinon, sur un corpus petit/uniforme, les ex-aequo au
+    # rang P90  feraient flaguer tout le monde (bruit, pas un signal d'anomalie).
+    flags: dict[str, set[str]] = {}
+    for doc_id, vs in cer.items():
+        tags: set[str] = set()
+        if cer_cut is not None and max(vs) > cer_cut:
+            tags.add("cer")
+        if unanch_cut is not None and doc_id in unanchored:
+            if max(unanchored[doc_id]) > unanch_cut:
+                tags.add("unanchored")
+        if spread_cut is not None and spreads.get(doc_id, -1.0) > spread_cut:
+            tags.add("disagree")
+        if doc_id in inserted:
+            tags.add("inserted")
+        if tags:
+            flags[doc_id] = tags
+
+    cutoffs: dict[str, float] = {}
+    if cer_cut is not None:
+        cutoffs["cer"] = cer_cut
+    if unanch_cut is not None:
+        cutoffs["unanchored"] = unanch_cut
+    if spread_cut is not None:
+        cutoffs["disagree"] = spread_cut
+    return flags, cutoffs
+
+
+__all__ = ["ANOMALY_LABELS", "ANOMALY_ORDER", "compute_anomalies"]
diff --git a/cinoc/reports/_assets/FluxischElse-Bold.woff2 b/cinoc/reports/_assets/FluxischElse-Bold.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..31cada64791095dae4a548b7a917884a7bf10470
--- /dev/null
+++ b/cinoc/reports/_assets/FluxischElse-Bold.woff2
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb9da809769fab892689884e6e8762896e9a8159307eb414c8476e0022172bbc
+size 76708
diff --git a/cinoc/reports/_assets/FluxischElse-Regular.woff2 b/cinoc/reports/_assets/FluxischElse-Regular.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..be72a62fe9a0c4c83e6ee05b019a43006d3072aa
--- /dev/null
+++ b/cinoc/reports/_assets/FluxischElse-Regular.woff2
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:54a971ffced4a944268f29685f36a960d2faff924ac94f8423bdf73a6f1a2750
+size 78444
diff --git a/cinoc/reports/_assets/IBMPlexMono-Medium.woff2 b/cinoc/reports/_assets/IBMPlexMono-Medium.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..a2a3783c5270d96db4ec1ec1d4d1a1c7ef8e3bd3
--- /dev/null
+++ b/cinoc/reports/_assets/IBMPlexMono-Medium.woff2
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:33faf307fa6031fb4062276d7320a6d632de890cbb347576fd80cfa01077bc25
+size 50400
diff --git a/cinoc/reports/_assets/IBMPlexMono-Regular.woff2 b/cinoc/reports/_assets/IBMPlexMono-Regular.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..48a5bee42ca85dbf47c7bff5baa4b31130098335
--- /dev/null
+++ b/cinoc/reports/_assets/IBMPlexMono-Regular.woff2
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ba204497f16b6d334cee9d1e963a831b73e3a56e1d6300a8489d18df7214b350
+size 49248
diff --git a/cinoc/reports/_assets/IBMPlexSans-Medium.woff2 b/cinoc/reports/_assets/IBMPlexSans-Medium.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..a450c56462c40b53cb09988dfa1233fadba7cc17
--- /dev/null
+++ b/cinoc/reports/_assets/IBMPlexSans-Medium.woff2
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5660f8a658f8bb50dbc005232f885eadffd2bc1c235c4f6fbb63469d1f9cde6d
+size 66740
diff --git a/cinoc/reports/_assets/IBMPlexSans-Regular.woff2 b/cinoc/reports/_assets/IBMPlexSans-Regular.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..3ef9f873cfd31a53eb876d49799ca75a4b14bf8f
--- /dev/null
+++ b/cinoc/reports/_assets/IBMPlexSans-Regular.woff2
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ba711a3085ff9f27440b6b9c4550cfc47c97bf36591d5da958b975bb3add8c1a
+size 63020
diff --git a/cinoc/reports/_assets/IBMPlexSans-SemiBold.woff2 b/cinoc/reports/_assets/IBMPlexSans-SemiBold.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..55912838c0f0eb5bb043834634c7e09d0ea0646d
--- /dev/null
+++ b/cinoc/reports/_assets/IBMPlexSans-SemiBold.woff2
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f78048030eab62e860efa39a0df79e2e5581bf122eb95b9bc42c0b8a4988d205
+size 67060
diff --git a/cinoc/reports/_assets/MonaSansVF-opsz-wght.woff2 b/cinoc/reports/_assets/MonaSansVF-opsz-wght.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..0dee5f8afaf3aa15d24a165b36a77528386b133f
--- /dev/null
+++ b/cinoc/reports/_assets/MonaSansVF-opsz-wght.woff2
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:62e40f6e14e5bbb97132b4513a4d97319ab6aaa46996cf46c7a9f357edadb662
+size 137252
diff --git a/cinoc/reports/_assets/OCRA.woff2 b/cinoc/reports/_assets/OCRA.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..bf62cec7f57ad50290233d7aff438d3acb40f59a
--- /dev/null
+++ b/cinoc/reports/_assets/OCRA.woff2
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e83f0513675d0bdeb8be3c4a3ffcaac7e5d2c33e1c4937803f9691c40943ba4f
+size 11264
diff --git a/cinoc/reports/_assets/compare.js b/cinoc/reports/_assets/compare.js
new file mode 100644
index 0000000000000000000000000000000000000000..6ef9d1ecfbeab2d714c35bdbe3915073787d7591
--- /dev/null
+++ b/cinoc/reports/_assets/compare.js
@@ -0,0 +1,117 @@
+/* Comparaison de deux runs — 100 % client, zéro réseau (rapport autonome).
+ *
+ * Lit les données CER du run courant (bloc JSON inerte embarqué), laisse le
+ * visiteur charger un second RunResult JSON depuis son disque (FileReader,
+ * plafond 50 Mo), calcule les deltas CER par moteur et les affiche dans un
+ * bandeau sticky. Script STATIQUE (son sha256 est épinglé dans la CSP des
+ * réponses /reports/). Aucune donnée n'est insérée via innerHTML (anti-XSS :
+ * tout texte issu du fichier passe par textContent). */
+(function () {
+  "use strict";
+  var MAX_BYTES = 50 * 1024 * 1024;
+  var btn = document.getElementById("cinoc-compare-btn");
+  var input = document.getElementById("cinoc-compare-file");
+  var dataEl = document.getElementById("cinoc-compare-data");
+  if (!btn || !input || !dataEl) return;
+
+  var current;
+  try {
+    current = JSON.parse(dataEl.textContent) || {};
+  } catch (e) {
+    return;
+  }
+  var currentCer = current.cer || {};
+
+  function cerMap(run) {
+    var map = {};
+    var pipelines = run && run.pipelines;
+    if (!Array.isArray(pipelines)) return map;
+    for (var i = 0; i < pipelines.length; i++) {
+      var p = pipelines[i];
+      if (!p || typeof p.pipeline !== "string" || !Array.isArray(p.aggregate)) continue;
+      for (var j = 0; j < p.aggregate.length; j++) {
+        var s = p.aggregate[j];
+        if (s && s.metric === "cer" && typeof s.value === "number" && isFinite(s.value)) {
+          map[p.pipeline + " · " + (p.view || "")] = s.value;
+        }
+      }
+    }
+    return map;
+  }
+
+  function fmtDelta(x) {
+    return (x > 0 ? "+" : "") + (x * 100).toFixed(2) + " pt";
+  }
+
+  function banner() {
+    var el = document.getElementById("cinoc-compare-banner");
+    if (!el) {
+      el = document.createElement("div");
+      el.id = "cinoc-compare-banner";
+      document.body.appendChild(el);
+    }
+    return el;
+  }
+
+  function addRow(parent, key, delta) {
+    var row = document.createElement("span");
+    row.className =
+      "cb-row " + (delta > 0 ? "worse" : delta < 0 ? "better" : "same");
+    var k = document.createElement("span");
+    k.className = "cb-key";
+    k.textContent = key;
+    var d = document.createElement("span");
+    d.className = "cb-delta";
+    d.textContent = fmtDelta(delta);
+    row.appendChild(k);
+    row.appendChild(d);
+    parent.appendChild(row);
+  }
+
+  function render(otherMap) {
+    var el = banner();
+    el.textContent = "";
+    var keys = Object.keys(currentCer).sort();
+    var shown = 0;
+    var title = document.createElement("span");
+    title.className = "cb-title";
+    title.textContent = "Δ CER (run chargé − ce rapport)";
+    el.appendChild(title);
+    for (var i = 0; i < keys.length; i++) {
+      var key = keys[i];
+      if (!(key in otherMap)) continue;
+      addRow(el, key, otherMap[key] - currentCer[key]);
+      shown++;
+    }
+    if (shown === 0) {
+      el.textContent = "Aucun moteur commun à comparer.";
+      el.className = "compare-banner empty";
+    } else {
+      el.className = "compare-banner";
+    }
+  }
+
+  btn.addEventListener("click", function () {
+    input.click();
+  });
+  input.addEventListener("change", function () {
+    var file = input.files && input.files[0];
+    if (!file) return;
+    if (file.size > MAX_BYTES) {
+      window.alert("Fichier trop volumineux (> 50 Mo).");
+      return;
+    }
+    var reader = new FileReader();
+    reader.onload = function () {
+      var other;
+      try {
+        other = JSON.parse(String(reader.result));
+      } catch (e) {
+        window.alert("JSON invalide.");
+        return;
+      }
+      render(cerMap(other));
+    };
+    reader.readAsText(file);
+  });
+})();
diff --git a/cinoc/reports/_assets/report.js b/cinoc/reports/_assets/report.js
new file mode 100644
index 0000000000000000000000000000000000000000..f1f1c7194d9c971457636ff5cfa45277d930628c
--- /dev/null
+++ b/cinoc/reports/_assets/report.js
@@ -0,0 +1,621 @@
+/* Rapport autonome — interactivité légère : navigation clavier + palette.
+ *
+ * Script STATIQUE (son sha256 est épinglé dans la CSP des réponses /reports/).
+ * Zéro réseau, zéro dépendance. Tout est progressif : sans JS, le rapport reste
+ * lisible (le sommaire à ancres natives suffit à naviguer). */
+(function () {
+  "use strict";
+
+  /* 1) Palette daltonien : ?palette=cb → classe sur <html>. Les accents pilotés
+   *    par variables CSS (data-bars, verdicts, deltas) basculent vers une paire
+   *    bleu/orange distinguable ; les badges moteur portent déjà une LETTRE, donc
+   *    restent identifiables sans couleur. */
+  try {
+    var pal = new URLSearchParams(window.location.search).get("palette");
+    if (pal === "cb" || pal === "daltonien") {
+      document.documentElement.classList.add("palette-cb");
+    }
+  } catch (e) {
+    /* URLSearchParams indisponible (très vieux navigateur) : on ignore. */
+  }
+
+  /* 2) Navigation clavier (vim) : j = section suivante, k = précédente.
+   *    Volontairement PAS les flèches — elles doivent rester le défilement natif. */
+  var blocks = Array.prototype.slice.call(document.querySelectorAll(".r-block"));
+  if (!blocks.length) return;
+  var current = -1;
+
+  function focusBlock(index) {
+    current = index < 0 ? 0 : index > blocks.length - 1 ? blocks.length - 1 : index;
+    var block = blocks[current];
+    block.scrollIntoView({ behavior: "smooth", block: "start" });
+    var head = block.querySelector("h1, h2, h3");
+    if (head) {
+      head.setAttribute("tabindex", "-1");
+      head.focus({ preventScroll: true });
+    }
+  }
+
+  document.addEventListener("keydown", function (e) {
+    if (e.defaultPrevented || e.ctrlKey || e.metaKey || e.altKey) return;
+    var tag = (e.target && e.target.tagName) || "";
+    if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return;
+    if (e.key === "j") {
+      focusBlock(current + 1);
+      e.preventDefault();
+    } else if (e.key === "k") {
+      focusBlock(current - 1);
+      e.preventDefault();
+    }
+  });
+
+  /* 3) Onglets (enrichissement progressif). Le serveur rend TOUS les panneaux
+   *    (sans JS : empilés et visibles, les onglets sont de simples ancres). Ici
+   *    on n'affiche qu'un panneau à la fois et on câble la navigation ARIA. */
+  var tablist = document.querySelector(".report-tabs");
+  if (tablist) {
+    var tabs = Array.prototype.slice.call(tablist.querySelectorAll('[role="tab"]'));
+    var panels = tabs.map(function (t) {
+      return document.getElementById(t.getAttribute("aria-controls"));
+    });
+
+    function activate(index, focusTab) {
+      tabs.forEach(function (t, j) {
+        var on = j === index;
+        t.setAttribute("aria-selected", on ? "true" : "false");
+        t.classList.toggle("on", on);
+        t.tabIndex = on ? 0 : -1;
+        if (panels[j]) panels[j].hidden = !on;
+      });
+      if (focusTab && tabs[index]) tabs[index].focus();
+    }
+
+    /* Onglet initial : celui désigné par le hash (#panel-x), sinon le premier. */
+    var initial = 0;
+    var hash = (window.location.hash || "").slice(1);
+    tabs.forEach(function (t, j) {
+      if (t.getAttribute("aria-controls") === hash) initial = j;
+    });
+    activate(initial, false);
+
+    tabs.forEach(function (t, i) {
+      t.addEventListener("click", function (e) {
+        e.preventDefault();
+        activate(i, false);
+      });
+      t.addEventListener("keydown", function (e) {
+        var n = null;
+        if (e.key === "ArrowRight") n = (i + 1) % tabs.length;
+        else if (e.key === "ArrowLeft") n = (i - 1 + tabs.length) % tabs.length;
+        else if (e.key === "Home") n = 0;
+        else if (e.key === "End") n = tabs.length - 1;
+        if (n !== null) {
+          e.preventDefault();
+          activate(n, true);
+        }
+      });
+    });
+  }
+
+  /* 4) Glossaire : le lien-ancre du chrome ouvre le <dialog> en MODALE (showModal,
+   *    Échap + ::backdrop natifs). Sans JS, l'ancre déclenche le repli :target
+   *    (panneau centré). Fermeture : bouton [data-close] ou clic sur le fond. */
+  var glossaryDialog = document.getElementById("glossary-dialog");
+  if (glossaryDialog && typeof glossaryDialog.showModal === "function") {
+    var glossaryLink = document.querySelector('[href="#glossary-dialog"]');
+    if (glossaryLink) {
+      glossaryLink.addEventListener("click", function (e) {
+        e.preventDefault();
+        glossaryDialog.showModal();
+      });
+    }
+    glossaryDialog.querySelectorAll("[data-close]").forEach(function (b) {
+      b.addEventListener("click", function (e) {
+        e.preventDefault();
+        glossaryDialog.close();
+      });
+    });
+    glossaryDialog.addEventListener("click", function (e) {
+      if (e.target === glossaryDialog) glossaryDialog.close();
+    });
+  }
+
+  /* 5) Tables vivantes : clic sur un <th class="sortable"> réordonne les <tr>
+   *    du corps par la valeur data-sort de la colonne (cellIndex). On DÉPLACE
+   *    des lignes déjà rendues — aucune donnée reconstruite (cf. discipline). */
+  function sortNumber(cell) {
+    var v = cell ? parseFloat(cell.getAttribute("data-sort")) : NaN;
+    return isNaN(v) ? Infinity : v; /* valeurs absentes → en fin de tri */
+  }
+  Array.prototype.forEach.call(
+    document.querySelectorAll("table.sortable"),
+    function (table) {
+      var heads = table.querySelectorAll("thead th.sortable");
+      Array.prototype.forEach.call(heads, function (th) {
+        th.addEventListener("click", function () {
+          var tbody = table.tBodies[0];
+          if (!tbody) return;
+          var col = th.cellIndex;
+          var asc = th.getAttribute("aria-sort") !== "ascending";
+          var rows = Array.prototype.slice.call(tbody.rows);
+          rows.sort(function (a, b) {
+            var x = sortNumber(a.cells[col]);
+            var y = sortNumber(b.cells[col]);
+            return asc ? x - y : y - x;
+          });
+          rows.forEach(function (r) {
+            tbody.appendChild(r);
+          });
+          Array.prototype.forEach.call(heads, function (h) {
+            h.setAttribute("aria-sort", "none");
+          });
+          th.setAttribute("aria-sort", asc ? "ascending" : "descending");
+        });
+      });
+    },
+  );
+
+  /* 6) Routeur MAÎTRE/DÉTAIL (profil moteur, détail document) : chaque onglet a
+   *    une vue maître (.tab-master : liste/comparaison) et une vue détail
+   *    (.tab-detail : fiches). Cliquer un moteur/document ÉCHANGE les deux (vraie
+   *    « page », ≠ ancre dans le même défilement) : on cache le maître, on montre
+   *    le détail avec UNE seule fiche, on remonte en haut. Le fil d'Ariane
+   *    (.drill-back) rétablit le maître et ramène au déclencheur cliqué. Sans JS :
+   *    maître + détail empilés, la fiche ciblée s'ouvre via :target. */
+  var drillPanels = Array.prototype.slice.call(
+    document.querySelectorAll(".drill-panel"),
+  );
+  var hasDocTemplates = !!document.querySelector("template[data-doc]");
+  if (drillPanels.length || hasDocTemplates) {
+    /* Au chargement : masquer toutes les vues détail → seul le maître s'affiche. */
+    Array.prototype.forEach.call(
+      document.querySelectorAll(".tab-detail"),
+      function (d) {
+        d.hidden = true;
+      },
+    );
+    /* Déclencheur initial (nom de moteur / carte document) mémorisé par onglet,
+       pour y ramener au retour. Les liens préc./suiv. (dans une fiche) n'écrasent
+       pas le déclencheur. */
+    var lastTrigger = {};
+    function modeKey(scope) {
+      var m = scope && scope.closest ? scope.closest(".mode") : null;
+      return m && m.id ? m.id : "_";
+    }
+    function swap(scope, master, detail, link, fromInside) {
+      if (detail) detail.hidden = false;
+      if (master) master.hidden = true;
+      if (link && !fromInside && scope) lastTrigger[modeKey(scope)] = link;
+      var top = detail || master;
+      if (top && top.scrollIntoView)
+        top.scrollIntoView({ behavior: "smooth", block: "start" });
+    }
+    /* Profil MOTEUR : fiches pré-rendues (peu nombreuses) → on révèle par id. */
+    function openDetail(id, link) {
+      var panel = document.getElementById(id);
+      if (!panel) return;
+      var scope = panel.closest(".drill-scope") || document;
+      var master = scope.querySelector
+        ? scope.querySelector(".tab-master")
+        : null;
+      var detail = panel.closest(".tab-detail");
+      if (detail) {
+        Array.prototype.forEach.call(
+          detail.querySelectorAll(".drill-panel"),
+          function (p) {
+            p.hidden = p.id !== id;
+          },
+        );
+      }
+      swap(scope, master, detail, link, !!link.closest(".drill-panel"));
+    }
+    /* Détail DOCUMENT : fiche rendue par le serveur dans un <template> inerte,
+       CLONÉE à la demande dans un unique conteneur vivant → DOM borné même à
+       5000 docs, fac-similés chargés seulement à l'ouverture. On recâble les
+       comportements internes de la fiche (sélecteur de moteur, zoom) après clonage. */
+    function openDocDetail(idx, link) {
+      var tpl = document.querySelector('template[data-doc="' + idx + '"]');
+      var live = document.querySelector(".doc-detail-live");
+      if (!tpl || !live) return;
+      live.replaceChildren(tpl.content.cloneNode(true));
+      wireEngineTabs(live);
+      wireFacZoom(live);
+      var detail = live.closest(".tab-detail");
+      var scope = detail ? detail.closest(".drill-scope") : null;
+      var master = scope ? scope.querySelector(".tab-master") : null;
+      var fromInside = !!(
+        link.closest(".doc-detail-live") || link.closest(".drill-panel")
+      );
+      swap(scope, master, detail, link, fromInside);
+    }
+    function closeDetail(backLink) {
+      var scope = backLink.closest(".drill-scope");
+      if (!scope) return;
+      var master = scope.querySelector(".tab-master");
+      var detail = scope.querySelector(".tab-detail");
+      if (detail) detail.hidden = true;
+      var live = detail && detail.querySelector(".doc-detail-live");
+      if (live) live.replaceChildren(); /* libère la fiche clonée */
+      if (master) master.hidden = false;
+      var trig = lastTrigger[modeKey(scope)];
+      if (trig) trig.scrollIntoView({ behavior: "smooth", block: "center" });
+      else if (master) master.scrollIntoView({ behavior: "smooth", block: "start" });
+    }
+    document.addEventListener("click", function (e) {
+      var link = e.target.closest && e.target.closest("a");
+      if (!link) return;
+      if (link.classList.contains("drill-back")) {
+        e.preventDefault();
+        closeDetail(link);
+        return;
+      }
+      var href = link.getAttribute("href") || "";
+      if (href.charAt(0) !== "#" || href.length <= 1) return;
+      var id = href.slice(1);
+      /* lien document #doc-N → clone du <template> correspondant */
+      if (
+        /^doc-\d+$/.test(id) &&
+        document.querySelector('template[data-doc="' + id.slice(4) + '"]')
+      ) {
+        e.preventDefault();
+        openDocDetail(id.slice(4), link);
+        return;
+      }
+      var target = document.getElementById(id);
+      if (target && target.classList.contains("drill-panel")) {
+        e.preventDefault();
+        openDetail(id, link);
+      }
+    });
+  }
+
+  /* 7) Bascule galerie ⇄ liste (vue Documents). Sans JS, la grille (entrée) est
+   *    visible et la liste cachée ; un bouton montre l'une, cache l'autre. */
+  Array.prototype.forEach.call(
+    document.querySelectorAll(".view-toggle"),
+    function (group) {
+      var scope = group.parentNode;
+      var btns = group.querySelectorAll(".vt-btn");
+      Array.prototype.forEach.call(btns, function (btn) {
+        btn.addEventListener("click", function () {
+          var want = btn.getAttribute("data-view");
+          Array.prototype.forEach.call(btns, function (b) {
+            var on = b === btn;
+            b.classList.toggle("on", on);
+            b.setAttribute("aria-pressed", on ? "true" : "false");
+          });
+          Array.prototype.forEach.call(
+            scope.querySelectorAll(".doc-view"),
+            function (v) {
+              v.hidden = v.getAttribute("data-view") !== want;
+            },
+          );
+        });
+      });
+    },
+  );
+
+  /* 7b) Filtres galerie à FACETTES qui COMPOSENT (strate · anomalie). Chaque
+   *     groupe .doc-filter porte data-facet = l'attribut data-<facet> lu sur la
+   *     carte ; pour "anom" la carte porte une LISTE de tokens (appartenance). On
+   *     mémorise la sélection active de chaque facette (partagée par scope) et on
+   *     recompose data-filtered = ET des facettes ; le paginateur sœur réaffiche
+   *     la page 1 du sous-ensemble. Sans paginateur (dégradé), on masque direct.
+   *     Sans JS, chips inertes, toutes cartes visibles. */
+  Array.prototype.forEach.call(
+    document.querySelectorAll(".doc-filter"),
+    function (group) {
+      var scope = group.parentNode;
+      var grid = scope.querySelector(".doc-grid");
+      var facet = group.getAttribute("data-facet") || "stratum";
+      scope._facets = scope._facets || {};
+      scope._facets[facet] = "*";
+      var btns = group.querySelectorAll(".df-btn");
+      function matches(card, f, want) {
+        if (want === "*") return true;
+        var v = card.getAttribute("data-" + f) || "";
+        if (f === "anom") return (" " + v + " ").indexOf(" " + want + " ") >= 0;
+        return v === want;
+      }
+      function apply() {
+        Array.prototype.forEach.call(
+          scope.querySelectorAll(".doc-card"),
+          function (card) {
+            var keep = true;
+            for (var f in scope._facets)
+              if (!matches(card, f, scope._facets[f])) {
+                keep = false;
+                break;
+              }
+            card.setAttribute("data-filtered", keep ? "0" : "1");
+          },
+        );
+        if (grid && grid._paginator) grid._paginator.reset();
+        else
+          Array.prototype.forEach.call(
+            scope.querySelectorAll(".doc-card"),
+            function (card) {
+              card.hidden = card.getAttribute("data-filtered") === "1";
+            },
+          );
+      }
+      Array.prototype.forEach.call(btns, function (btn) {
+        btn.addEventListener("click", function () {
+          scope._facets[facet] = btn.getAttribute("data-" + facet);
+          Array.prototype.forEach.call(btns, function (b) {
+            var on = b === btn;
+            b.classList.toggle("on", on);
+            b.setAttribute("aria-pressed", on ? "true" : "false");
+          });
+          apply();
+        });
+      });
+    },
+  );
+
+  /* 10) Pagination des longues listes (galerie, tables) — SANS rien retirer :
+   *     [data-paginate=N] garde tous les items dans le document mais n'en affiche
+   *     que N à la fois (page courante) + un pager. Compose avec le filtre par
+   *     strate (items data-filtered="1" exclus de la pagination). Sans JS, pas de
+   *     pager → tout reste visible (autonome, imprimable). On ne masque/affiche
+   *     que des items déjà rendus. */
+  function makePaginator(host) {
+    var size = parseInt(host.getAttribute("data-paginate"), 10) || 60;
+    var isTable = !!host.tBodies && host.tBodies[0];
+    function items() {
+      var kids = isTable ? host.tBodies[0].rows : host.children;
+      return Array.prototype.filter.call(kids, function (el) {
+        return el.nodeType === 1 && !el.classList.contains("pager");
+      });
+    }
+    var page = 0;
+    var pager = document.createElement("div");
+    pager.className = "pager";
+    pager.style.cssText =
+      "display:flex;gap:.5rem;align-items:center;justify-content:center;" +
+      "margin:.75rem 0;flex-wrap:wrap";
+    var prev = document.createElement("button");
+    var next = document.createElement("button");
+    var label = document.createElement("span");
+    prev.type = next.type = "button";
+    prev.className = next.className = "df-btn";
+    prev.textContent = "‹";
+    next.textContent = "›";
+    label.className = "muted";
+    pager.appendChild(prev);
+    pager.appendChild(label);
+    pager.appendChild(next);
+    host.parentNode.insertBefore(pager, host.nextSibling);
+    function render() {
+      var all = items();
+      var active = all.filter(function (el) {
+        return el.getAttribute("data-filtered") !== "1";
+      });
+      var pages = Math.max(1, Math.ceil(active.length / size));
+      page = Math.min(Math.max(page, 0), pages - 1);
+      var start = page * size;
+      all.forEach(function (el) {
+        if (el.getAttribute("data-filtered") === "1") {
+          el.hidden = true;
+          return;
+        }
+        var ai = active.indexOf(el);
+        el.hidden = !(ai >= start && ai < start + size);
+      });
+      label.textContent = "page " + (page + 1) + " / " + pages + " · " + active.length;
+      prev.disabled = page === 0;
+      next.disabled = page >= pages - 1;
+      pager.hidden = active.length <= size;
+    }
+    function go(delta) {
+      page += delta;
+      render();
+      if (host.scrollIntoView)
+        host.scrollIntoView({ behavior: "smooth", block: "start" });
+    }
+    prev.addEventListener("click", function () {
+      go(-1);
+    });
+    next.addEventListener("click", function () {
+      go(1);
+    });
+    render();
+    return {
+      render: render,
+      reset: function () {
+        page = 0;
+        render();
+      },
+    };
+  }
+  Array.prototype.forEach.call(
+    document.querySelectorAll("[data-paginate]"),
+    function (host) {
+      host._paginator = makePaginator(host);
+    },
+  );
+
+  /* 8) Sélecteur de moteur du diff pleine page (détail document) : un bouton
+   *    montre le bloc .dd-fulldiff du moteur, cache les autres (scopé au wrap).
+   *    Sans JS, les blocs sont empilés et tous visibles. Fonction (re)câblable
+   *    sur une racine : appelée au chargement, puis sur chaque fiche clonée. */
+  function wireEngineTabs(root) {
+    Array.prototype.forEach.call(
+    root.querySelectorAll(".dd-engine-tabs"),
+    function (tabs) {
+      var wrap = tabs.parentNode;
+      var btns = tabs.querySelectorAll(".dd-eng-btn");
+      function show(engine) {
+        Array.prototype.forEach.call(btns, function (b) {
+          b.classList.toggle("on", b.getAttribute("data-engine") === engine);
+        });
+        Array.prototype.forEach.call(
+          wrap.querySelectorAll(".dd-fulldiff"),
+          function (d) {
+            d.hidden = d.getAttribute("data-engine") !== engine;
+          },
+        );
+      }
+      Array.prototype.forEach.call(btns, function (btn) {
+        btn.addEventListener("click", function () {
+          show(btn.getAttribute("data-engine"));
+        });
+      });
+    },
+    );
+  }
+
+  /* 9) Fac-similé zoomable/pan (détail document) : molette = zoom, glisser =
+   *    déplacer, boutons +/−/⤢. Chaque image garde son propre état (zoom z,
+   *    décalage ox/oy). Sans JS, l'image s'affiche à taille medium, statique.
+   *    Fonction (re)câblable sur une racine (chargement, puis fiche clonée). */
+  function wireFacZoom(root) {
+    Array.prototype.forEach.call(
+    root.querySelectorAll(".dd-fac-zoom"),
+    function (box) {
+      var img = box.querySelector(".dd-fac-img");
+      if (!img) return;
+      // Zoom par **taille réelle** (px) et non par ``transform: scale`` : le
+      // navigateur re-rasterise depuis le bitmap natif → net jusqu'à la
+      // résolution native (≠ scale sur calque GPU, qui agrandit un raster déjà
+      // réduit → flou). Panoramique par scroll du conteneur (overflow:auto).
+      var z = 1,
+        drag = null;
+      function fitWidth() {
+        // largeur affichée à z=1 (``object-fit: contain`` émulé) : bornée par la
+        // plus contraignante des deux dimensions du conteneur.
+        var bw = box.clientWidth,
+          bh = box.clientHeight,
+          nw = img.naturalWidth,
+          nh = img.naturalHeight;
+        if (!nw || !nh) return bw;
+        return Math.min(bw, bh * (nw / nh));
+      }
+      function apply() {
+        if (z <= 1) {
+          z = 1;
+          img.style.maxWidth = "100%";
+          img.style.maxHeight = "100%";
+          img.style.width = "";
+          img.style.height = "";
+          box.style.cursor = "zoom-in";
+          return;
+        }
+        // jamais au-delà du natif (pas d'upscale flou) : on plafonne à la
+        // largeur native du bitmap.
+        var want = fitWidth() * z;
+        if (img.naturalWidth) want = Math.min(want, img.naturalWidth);
+        img.style.maxWidth = "none";
+        img.style.maxHeight = "none";
+        img.style.width = Math.round(want) + "px";
+        img.style.height = "auto";
+        box.style.cursor = "grab";
+      }
+      function zoom(factor) {
+        z = Math.max(1, Math.min(16, z * factor));
+        apply();
+      }
+      box.addEventListener(
+        "wheel",
+        function (e) {
+          e.preventDefault();
+          zoom(e.deltaY < 0 ? 1.2 : 0.83);
+        },
+        { passive: false },
+      );
+      box.addEventListener("mousedown", function (e) {
+        if (z <= 1 || (e.target.closest && e.target.closest("[data-zoom]"))) return;
+        e.preventDefault();
+        drag = {
+          x: e.clientX,
+          y: e.clientY,
+          sl: box.scrollLeft,
+          st: box.scrollTop,
+        };
+        box.style.cursor = "grabbing";
+      });
+      document.addEventListener("mousemove", function (e) {
+        if (!drag) return;
+        box.scrollLeft = drag.sl - (e.clientX - drag.x);
+        box.scrollTop = drag.st - (e.clientY - drag.y);
+      });
+      document.addEventListener("mouseup", function () {
+        if (drag) {
+          drag = null;
+          box.style.cursor = z > 1 ? "grab" : "zoom-in";
+        }
+      });
+      Array.prototype.forEach.call(
+        box.querySelectorAll("[data-zoom]"),
+        function (btn) {
+          btn.addEventListener("click", function () {
+            var k = btn.getAttribute("data-zoom");
+            if (k === "in") zoom(1.3);
+            else if (k === "out") zoom(0.77);
+            else {
+              z = 1;
+              apply();
+              box.scrollTop = 0;
+              box.scrollLeft = 0;
+            }
+          });
+        },
+      );
+      apply();
+    },
+    );
+  }
+
+  /* 11) Scroll-spy du sommaire collant (spine) : surligne le lien du groupe en
+     cours de lecture. On observe les sous-titres (.tab-subhead[id]) ; l'actif est
+     le dernier dont le haut a franchi une bande sous le spine. Enrichissement
+     progressif (sans JS / sans IntersectionObserver : liens normaux, rien de
+     cassé). Seuls les sous-titres du mode VISIBLE comptent (offsetParent non nul
+     → un mode caché en display:none est ignoré). */
+  if (window.IntersectionObserver) {
+    var spineLinks = {};
+    Array.prototype.forEach.call(
+      document.querySelectorAll(".spine-link"),
+      function (a) {
+        var href = a.getAttribute("href") || "";
+        if (href.charAt(0) === "#") spineLinks[href.slice(1)] = a;
+      },
+    );
+    var subheads = Array.prototype.slice.call(
+      document.querySelectorAll(".tab-subhead[id]"),
+    );
+    if (subheads.length && Object.keys(spineLinks).length) {
+      var markActive = function () {
+        var activeId = null;
+        subheads.forEach(function (h) {
+          if (h.offsetParent === null) return; /* mode caché → ignoré */
+          if (h.getBoundingClientRect().top <= 80) activeId = h.id;
+        });
+        if (activeId === null) {
+          /* aucun franchi (haut de page) : le premier visible fait l'actif */
+          for (var i = 0; i < subheads.length; i++) {
+            if (subheads[i].offsetParent !== null) {
+              activeId = subheads[i].id;
+              break;
+            }
+          }
+        }
+        Object.keys(spineLinks).forEach(function (id) {
+          spineLinks[id].classList.toggle("on", id === activeId);
+        });
+      };
+      var spy = new IntersectionObserver(markActive, {
+        threshold: [0, 1],
+      });
+      subheads.forEach(function (h) {
+        spy.observe(h);
+      });
+      markActive();
+    }
+  }
+
+  /* Câblage initial des comportements de fiche sur le document (les fiches
+     document, en <template>, seront recâblées à l'ouverture par openDocDetail). */
+  wireEngineTabs(document);
+  wireFacZoom(document);
+})();
diff --git a/cinoc/reports/_binning.py b/cinoc/reports/_binning.py
new file mode 100644
index 0000000000000000000000000000000000000000..e7cb9bc224e9dc3309e768bb887f5a381f16a6ca
--- /dev/null
+++ b/cinoc/reports/_binning.py
@@ -0,0 +1,34 @@
+"""Binning de distributions pour les graphes du rapport (couche 7).
+
+Agréger plutôt qu'énumérer : un histogramme a la **même forme bornée** que le
+corpus porte 20 ou 6000 documents — les graphes restent lisibles et légers à
+toute échelle, **sans rien retirer** (chaque point est compté). Fonctions pures,
+déterministes, sans dépendance externe.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+
+def histogram(values: Sequence[float], n_bins: int) -> list[float]:
+    """Comptes par classe de largeur égale sur ``[min, max]`` (``n_bins ≥ 1``).
+
+    Invariant d'échelle : la **forme** ne dépend que de la distribution, pas du
+    nombre de points. Toutes valeurs égales → tout dans la première classe
+    (largeur nulle, pas de division par zéro)."""
+    vals = list(values)
+    if not vals or n_bins < 1:
+        return []
+    lo, hi = min(vals), max(vals)
+    if hi <= lo:
+        return [float(len(vals))] + [0.0] * (n_bins - 1)
+    width = (hi - lo) / n_bins
+    counts = [0.0] * n_bins
+    for value in vals:
+        index = int((value - lo) / width)
+        counts[min(index, n_bins - 1)] += 1.0
+    return counts
+
+
+__all__ = ["histogram"]
diff --git a/cinoc/reports/_numbers.py b/cinoc/reports/_numbers.py
new file mode 100644
index 0000000000000000000000000000000000000000..1bc5ea5bba6a8b99a8c1555c905cb1fa4ce0ff44
--- /dev/null
+++ b/cinoc/reports/_numbers.py
@@ -0,0 +1,42 @@
+"""Formatage **localisé** des nombres *affichés* (couche 7).
+
+Un rapport français écrit les décimales avec une **virgule** (« 12,3 % »), un
+rapport anglais avec un **point** (« 12.3 % »). Ces helpers déterministes se
+branchent sur ``SectionContext.lang`` et ne touchent **que l'affichage** —
+jamais les coordonnées SVG (``svg.num``), les clés, ni les calculs.
+
+Périmètre volontairement minimal : **séparateur décimal** uniquement (pas de
+groupement de milliers — éviter l'ambiguïté typographique et le risque de
+casser un nombre déjà rendu). Le point décimal d'un format Python devient une
+virgule en français ; tout le reste est inchangé.
+"""
+
+from __future__ import annotations
+
+
+def localize_decimal(text: str, lang: str) -> str:
+    """Remplace le point décimal par une virgule en français (no-op sinon).
+
+    Opère sur une chaîne **déjà formatée** : ``"12.3 %"`` → ``"12,3 %"`` (fr).
+    N'introduit aucun groupement de milliers."""
+    return text.replace(".", ",") if lang == "fr" else text
+
+
+def fmt(value: float, lang: str, spec: str = ".2f") -> str:
+    """Formate ``value`` via ``spec`` (mini-langage de format Python) puis
+    localise le séparateur décimal. Ex. ``fmt(0.333, "fr", ".2f") == "0,33"``."""
+    return localize_decimal(f"{value:{spec}}", lang)
+
+
+def fmt_pct(
+    value: float, lang: str, *, decimals: int = 1, scale: bool = True
+) -> str:
+    """Pourcentage affiché « X,Y % » (fr) / « X.Y % » (en).
+
+    ``scale`` (défaut) multiplie par 100 (entrée ratio ``[0, 1]``) ; le passer à
+    ``False`` si la valeur est **déjà** en points de pourcentage."""
+    pct = value * 100 if scale else value
+    return f"{localize_decimal(f'{pct:.{decimals}f}', lang)} %"
+
+
+__all__ = ["fmt", "fmt_pct", "localize_decimal"]
diff --git a/cinoc/reports/_style.py b/cinoc/reports/_style.py
new file mode 100644
index 0000000000000000000000000000000000000000..0632832c6adb1c4857a392c62eccf7b163b38f9c
--- /dev/null
+++ b/cinoc/reports/_style.py
@@ -0,0 +1,52 @@
+"""Polices du rapport autonome **incorporées en data-URI** (couche 7).
+
+Décision **D-019** (option (a), préparée par D-018) : plutôt que des polices système
+(identité partielle) ou ``/static`` (perd l'autonomie du *standalone*), on
+**incorpore** les woff2 du design en ``data:`` URI. Le rapport garde son identité
+typographique — titres **Mona Sans**, corps **IBM Plex Sans**, données
+**IBM Plex Mono**, accents **Fluxisch Else**, logo **OCR-A** — **tout en
+restant 100 % autonome** (aucun CDN, ``@import`` ni ``<link>``) et **octet-stable**
+(le base64 d'octets figés est déterministe).
+
+Les woff2 vivent en ``reports/_assets/`` (couche 7) : le rapport **ne dépend pas**
+de la couche 8 (``interfaces/web/static``) pour ses polices.
+"""
+
+from __future__ import annotations
+
+import base64
+from functools import lru_cache
+from importlib.resources import files
+
+#: (famille CSS, plage de poids, fichier woff2) — sous-ensemble réellement
+#: utilisé par le rapport autonome.
+_FONTS: tuple[tuple[str, str, str], ...] = (
+    ("Mona Sans VF", "200 900", "MonaSansVF-opsz-wght.woff2"),
+    ("IBM Plex Sans", "400", "IBMPlexSans-Regular.woff2"),
+    ("IBM Plex Sans", "500", "IBMPlexSans-Medium.woff2"),
+    ("IBM Plex Sans", "600", "IBMPlexSans-SemiBold.woff2"),
+    ("IBM Plex Mono", "400", "IBMPlexMono-Regular.woff2"),
+    ("IBM Plex Mono", "500", "IBMPlexMono-Medium.woff2"),
+    ("Fluxisch Else", "400", "FluxischElse-Regular.woff2"),
+    ("Fluxisch Else", "600 700", "FluxischElse-Bold.woff2"),
+    ("OCRA", "400", "OCRA.woff2"),
+)
+
+
+def _face(family: str, weight: str, filename: str) -> str:
+    data = (files("cinoc.reports").joinpath("_assets", filename)).read_bytes()
+    b64 = base64.b64encode(data).decode("ascii")
+    return (
+        f"@font-face{{font-family:'{family}';font-weight:{weight};"
+        f"font-style:normal;font-display:swap;"
+        f"src:url(data:font/woff2;base64,{b64}) format('woff2');}}"
+    )
+
+
+@lru_cache(maxsize=1)
+def font_face_css() -> str:
+    """Blocs ``@font-face`` (data-URI) des polices du rapport. Déterministe."""
+    return "".join(_face(*f) for f in _FONTS)
+
+
+__all__ = ["font_face_css"]
diff --git a/cinoc/reports/compare.py b/cinoc/reports/compare.py
new file mode 100644
index 0000000000000000000000000000000000000000..241fdb109895e69363b2e208dc690235b47d7669
--- /dev/null
+++ b/cinoc/reports/compare.py
@@ -0,0 +1,103 @@
+"""Comparaison de deux ``RunResult`` (couche 7) → rapport HTML de deltas.
+
+Hors ``Protocol Section`` (qui ne prend qu'**un** résultat) : ``compare`` met deux
+runs côte à côte et calcule, par ``(pipeline, vue, métrique)``, le delta
+``B − A``. Le rapport reste **autonome** (assembleur ``render_document``).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from cinoc.evaluation.result import RunResult
+from cinoc.reports.html import escape, render_document
+from cinoc.reports.section import Html
+
+_Key = tuple[str, str, str]
+
+
+@dataclass(frozen=True)
+class MetricDelta:
+    """Valeur d'une métrique dans deux runs + leur écart (``B − A``)."""
+
+    pipeline: str
+    view: str
+    metric: str
+    value_a: float | None
+    value_b: float | None
+    delta: float | None
+
+
+def compare_runs(run_a: RunResult, run_b: RunResult) -> tuple[MetricDelta, ...]:
+    """Aligne deux runs par ``(pipeline, vue, métrique)`` et calcule les deltas."""
+    index_a = _index(run_a)
+    index_b = _index(run_b)
+    deltas: list[MetricDelta] = []
+    for key in sorted(set(index_a) | set(index_b)):
+        value_a = index_a.get(key)
+        value_b = index_b.get(key)
+        delta = (
+            value_b - value_a
+            if value_a is not None and value_b is not None
+            else None
+        )
+        deltas.append(
+            MetricDelta(
+                pipeline=key[0],
+                view=key[1],
+                metric=key[2],
+                value_a=value_a,
+                value_b=value_b,
+                delta=delta,
+            )
+        )
+    return tuple(deltas)
+
+
+def _index(result: RunResult) -> dict[_Key, float | None]:
+    return {
+        (pipeline.pipeline, pipeline.view, score.metric): score.value
+        for pipeline in result.pipelines
+        for score in pipeline.aggregate
+    }
+
+
+def _format(value: float | None) -> str:
+    return "—" if value is None else f"{value:.4f}"
+
+
+def _format_delta(value: float | None) -> str:
+    return "—" if value is None else f"{value:+.4f}"
+
+
+def render_comparison(
+    run_a: RunResult,
+    run_b: RunResult,
+    *,
+    title: str = "Cinoc — comparaison de runs",
+) -> str:
+    """Rend un rapport HTML autonome des deltas entre deux runs."""
+    rows = "".join(
+        f"<tr><td>{escape(delta.pipeline)}</td><td>{escape(delta.view)}</td>"
+        f"<td>{escape(delta.metric)}</td>"
+        f'<td class="num">{_format(delta.value_a)}</td>'
+        f'<td class="num">{_format(delta.value_b)}</td>'
+        f'<td class="num">{_format_delta(delta.delta)}</td></tr>'
+        for delta in compare_runs(run_a, run_b)
+    )
+    # NB : le sens « mieux » dépend de la métrique. Les métriques livrées
+    # (CER/WER/MER) sont **toutes** des taux d'erreur → on l'annonce explicitement
+    # plutôt qu'en supposant l'universalité. Porter `higher_is_better` jusque dans
+    # `RunResult` est différé tant qu'aucune métrique « plus haut = mieux » n'existe.
+    body = Html(
+        f'<p class="muted">A = {escape(run_a.manifest.run_id)} · '
+        f"B = {escape(run_b.manifest.run_id)} · Δ = B − A "
+        "(taux d'erreur CER/WER/MER : Δ &lt; 0 = amélioration).</p>\n"
+        "<table>\n<thead><tr><th>Pipeline</th><th>Vue</th><th>Métrique</th>"
+        "<th>A</th><th>B</th><th>Δ</th></tr></thead>\n"
+        f"<tbody>{rows}</tbody>\n</table>\n"
+    )
+    return render_document(title, body)
+
+
+__all__ = ["MetricDelta", "compare_runs", "render_comparison"]
diff --git a/cinoc/reports/compare_widget.py b/cinoc/reports/compare_widget.py
new file mode 100644
index 0000000000000000000000000000000000000000..14b81c43448f1bf36881dd7a91ad3aa45fab5cc2
--- /dev/null
+++ b/cinoc/reports/compare_widget.py
@@ -0,0 +1,68 @@
+"""Widget « comparer un run » (couche 7) — **client-side, autonome, déterministe**.
+
+Trois morceaux insérés en fin de ``<body>`` du rapport :
+
+1. un **bouton** + un ``<input type=file>`` caché ;
+2. les **données CER du run courant** dans un bloc ``type="application/json"``
+   **inerte** (non exécuté → hors ``script-src``), échappé contre toute rupture
+   de ``</script>`` ;
+3. le **script statique** ``_assets/compare.js`` inliné (autonomie : il voyage
+   dans le document).
+
+Le script étant **constant**, son empreinte ``sha256`` (``compare_script_hash``)
+est ajoutée à la CSP des seules réponses ``/reports/`` (l'inline reste interdit
+partout ailleurs — la CSP reste un contrat). Le visiteur charge un second
+``RunResult`` JSON depuis son disque : tout se passe **dans le navigateur**, zéro
+réseau (cf. invariant d'autonomie du rapport).
+"""
+
+from __future__ import annotations
+
+import json
+
+from cinoc.evaluation.result import RunResult
+from cinoc.reports.embedded import inline_script, script_hash
+from cinoc.reports.section import Html
+
+
+def compare_script_hash() -> str:
+    """Empreinte CSP du script de comparaison (délègue à ``embedded``)."""
+    return script_hash("compare.js")
+
+
+def _cer_by_key(result: RunResult) -> dict[str, float]:
+    """CER agrégé par ``"<pipeline> · <view>"`` (clé de jointure entre deux runs)."""
+    out: dict[str, float] = {}
+    for pipeline in result.pipelines:
+        for score in pipeline.aggregate:
+            if score.metric == "cer" and score.value is not None:
+                out[f"{pipeline.pipeline} · {pipeline.view}"] = score.value
+    return out
+
+
+def _safe_json(data: object) -> str:
+    """JSON ASCII avec ``<``/``>``/``&`` échappés (anti-rupture de ``</script>``)."""
+    return (
+        json.dumps(data, ensure_ascii=True, sort_keys=True)
+        .replace("<", "\\u003c")
+        .replace(">", "\\u003e")
+        .replace("&", "\\u0026")
+    )
+
+
+def compare_widget(result: RunResult) -> Html:
+    """Bouton + données du run courant + script — à insérer en fin de ``<body>``."""
+    payload = _safe_json({"cer": _cer_by_key(result)})
+    return Html(
+        '<div class="compare-bar">'
+        '<button id="cinoc-compare-btn" class="compare-btn" type="button">'
+        "⇄ Comparer un run</button>"
+        '<input id="cinoc-compare-file" type="file" '
+        'accept=".json,application/json" hidden>'
+        "</div>"
+        f'<script id="cinoc-compare-data" type="application/json">{payload}</script>'
+        f"{inline_script('compare.js')}"
+    )
+
+
+__all__ = ["compare_script_hash", "compare_widget"]
diff --git a/cinoc/reports/csv_export.py b/cinoc/reports/csv_export.py
new file mode 100644
index 0000000000000000000000000000000000000000..5222e6f2ddd3be86edd29626c615203c88f1f39a
--- /dev/null
+++ b/cinoc/reports/csv_export.py
@@ -0,0 +1,51 @@
+"""Export CSV d'un ``RunResult`` (couche 7) — lecture pure, zéro recalcul.
+
+Un seul fichier, tableur-compatible : une ligne par score, colonne ``scope``
+(``aggregate`` ou ``document``). Ordre = celui du ``RunResult`` (déterministe).
+"""
+
+from __future__ import annotations
+
+import csv
+import io
+
+from cinoc.evaluation.result import RunResult
+
+_HEADER = ("scope", "view", "pipeline", "document_id", "metric", "value", "support")
+
+
+def run_result_csv(result: RunResult) -> str:
+    """CSV des agrégats puis du détail par-document (UTF-8, séparateur ``,``)."""
+    buffer = io.StringIO()
+    writer = csv.writer(buffer, lineterminator="\n")
+    writer.writerow(_HEADER)
+    for pipeline in result.pipelines:
+        for score in pipeline.aggregate:
+            writer.writerow(
+                (
+                    "aggregate",
+                    pipeline.view,
+                    pipeline.pipeline,
+                    "",
+                    score.metric,
+                    "" if score.value is None else repr(score.value),
+                    "" if score.support is None else score.support,
+                )
+            )
+    for document in result.documents:
+        for score in document.scores:
+            writer.writerow(
+                (
+                    "document",
+                    document.view,
+                    document.pipeline,
+                    document.document_id,
+                    score.metric,
+                    "" if score.value is None else repr(score.value),
+                    "" if score.support is None else score.support,
+                )
+            )
+    return buffer.getvalue()
+
+
+__all__ = ["run_result_csv"]
diff --git a/cinoc/reports/embedded.py b/cinoc/reports/embedded.py
new file mode 100644
index 0000000000000000000000000000000000000000..63df10e95dadc71a27d350d9b4a4c952c83944ca
--- /dev/null
+++ b/cinoc/reports/embedded.py
@@ -0,0 +1,55 @@
+"""Scripts **embarqués** du rapport autonome (couche 7) — chargement + empreintes CSP.
+
+**Source unique** des scripts inlinés dans le rapport (autonomie : ils voyagent
+dans le document) : ``compare.js`` (comparer 2 runs) et ``report.js`` (navigation
+clavier + palette). Chaque script est **statique** → son ``sha256`` est épinglé
+dans la CSP des réponses ``/reports/`` (``get_csp_policy``) ; jamais
+``'unsafe-inline'``. **Ajouter un script du rapport = l'ajouter à
+``EMBEDDED_SCRIPTS`` ICI** (les hashes CSP suivent automatiquement).
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+from functools import cache
+from importlib import resources
+
+#: Scripts inlinés dans **tout** rapport, dans un ordre stable (déterminisme).
+EMBEDDED_SCRIPTS: tuple[str, ...] = ("compare.js", "report.js")
+
+
+@cache
+def asset_text(name: str) -> str:
+    """Texte d'un script du paquet (``_assets/<name>``), lu **une fois**."""
+    return (
+        resources.files("cinoc.reports")
+        .joinpath(f"_assets/{name}")
+        .read_text(encoding="utf-8")
+    )
+
+
+@cache
+def script_hash(name: str) -> str:
+    """Empreinte CSP (``'sha256-…'``) d'un script — constante, calculée 1×."""
+    digest = hashlib.sha256(asset_text(name).encode("utf-8")).digest()
+    return "'sha256-" + base64.b64encode(digest).decode("ascii") + "'"
+
+
+def script_csp_hashes() -> str:
+    """Empreintes de **tous** les scripts embarqués (pour ``script-src`` /reports/)."""
+    return " ".join(script_hash(name) for name in EMBEDDED_SCRIPTS)
+
+
+def inline_script(name: str) -> str:
+    """``<script>…</script>`` inliné (autonomie du rapport)."""
+    return f"<script>{asset_text(name)}</script>"
+
+
+__all__ = [
+    "EMBEDDED_SCRIPTS",
+    "asset_text",
+    "inline_script",
+    "script_csp_hashes",
+    "script_hash",
+]
diff --git a/cinoc/reports/engine_badges.py b/cinoc/reports/engine_badges.py
new file mode 100644
index 0000000000000000000000000000000000000000..f55b2301f7b21a4d17d12fd28c0c75e1a9261c11
--- /dev/null
+++ b/cinoc/reports/engine_badges.py
@@ -0,0 +1,70 @@
+"""Badges moteur A→E (couche 7) — **source unique** lettre + accent cyclique.
+
+Chaque moteur (nom de pipeline) reçoit une **lettre** (A, B, C…) et un **accent**
+cyclique (fern/slate/clay/butter/ink). C'est une **identité visuelle stable** : le
+moteur « A » est le même dans *toutes* les sections (classement, par-document,
+crosses), indépendamment de son rang d'affichage. **Toute extension de la palette
+se fait ICI** (les sections consomment ``engine_cell`` ; aucune ne recopie la
+palette — anti-divergence : un seul point de vérité pour la palette).
+
+Déterministe : l'index vient de l'**ordre de première apparition** des pipelines
+dans le ``RunResult`` (``engine_order``), donc le badge est octet-stable.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from cinoc.reports.html import escape
+from cinoc.reports.section import Html
+
+#: A→Z, puis cycle (au-delà de 26 moteurs — cas théorique).
+_LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+#: Accents du design (oklch), cycliques. **Étendre la palette = modifier CECI.**
+_ACCENTS: tuple[str, ...] = (
+    "oklch(0.50 0.07 145)",  # fern
+    "oklch(0.52 0.05 245)",  # slate
+    "oklch(0.55 0.11 40)",  # clay
+    "oklch(0.72 0.10 85)",  # butter
+    "oklch(0.32 0.02 60)",  # ink
+)
+
+
+def engine_letter(index: int) -> str:
+    """Lettre du moteur d'index ``index`` (A=0, B=1…) — cycle A→Z au-delà de 25."""
+    return _LETTERS[index % len(_LETTERS)]
+
+
+def engine_accent(index: int) -> str:
+    """Accent CSS cyclique du moteur d'index ``index``."""
+    return _ACCENTS[index % len(_ACCENTS)]
+
+
+def engine_order(names: Iterable[str]) -> dict[str, int]:
+    """Map nom→index dans l'**ordre de première apparition** (identité stable).
+
+    À calculer **une fois** depuis ``result.pipelines`` et à partager entre
+    sections : c'est ce qui garantit que « A » désigne le même moteur partout.
+    """
+    order: dict[str, int] = {}
+    for name in names:
+        if name not in order:
+            order[name] = len(order)
+    return order
+
+
+def engine_cell(name: str, index: int) -> Html:
+    """Contenu d'une cellule moteur : **badge** (lettre + accent) + nom échappé."""
+    return Html(
+        f'<span class="eng-badge" style="--badge:{engine_accent(index)}">'
+        f"{engine_letter(index)}</span>{escape(name)}"
+    )
+
+
+__all__ = [
+    "engine_accent",
+    "engine_cell",
+    "engine_letter",
+    "engine_order",
+]
diff --git a/cinoc/reports/glossary/__init__.py b/cinoc/reports/glossary/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8378310d06230ad0a2e64442f796bcc559c2f6d2
--- /dev/null
+++ b/cinoc/reports/glossary/__init__.py
@@ -0,0 +1,60 @@
+"""Glossaire pédagogique du rapport (DONNÉE, ≠ surface exécutable) — loader YAML.
+
+Définitions FR/EN affichées en fin de rapport pour les **seules** métriques que
+le moteur calcule (un consommateur réel par entrée). Lu **dynamiquement** du
+paquet (jamais une liste statique — la leçon des profils de normalisation et des
+prompts) ; repli FR si la langue demandée manque, ``{}`` non bloquant si même
+``fr.yaml`` est illisible (le rapport omet alors le glossaire).
+
+``__init__`` mince : aucune lecture au moment de l'import (le cache est lazy).
+"""
+
+from __future__ import annotations
+
+import logging
+from importlib import resources
+
+import yaml
+
+logger = logging.getLogger(__name__)
+
+_SUFFIX = ".yaml"
+_DEFAULT_LANG = "fr"
+#: Cache lazy par langue (peuplé au premier appel, jamais à l'import).
+_CACHE: dict[str, dict[str, dict[str, str]]] = {}
+
+
+def _parse(text: str, lang: str) -> dict[str, dict[str, str]]:
+    try:
+        data = yaml.safe_load(text) or {}
+    except yaml.YAMLError as e:
+        logger.warning("[glossary] %s illisible (YAML) : %s", lang, e)
+        return {}
+    if not isinstance(data, dict):
+        logger.warning("[glossary] %s n'est pas un mapping — ignoré", lang)
+        return {}
+    return {
+        str(term): {str(k): str(v) for k, v in body.items()}
+        for term, body in data.items()
+        if isinstance(body, dict)
+    }
+
+
+def load_glossary(lang: str = _DEFAULT_LANG) -> dict[str, dict[str, str]]:
+    """Glossaire ``{term: {title, definition, measures, limits}}`` pour ``lang``.
+
+    Repli sur le français si la langue n'a pas de fichier ; ``{}`` (dégradé non
+    bloquant) si même le français est absent/illisible.
+    """
+    if lang in _CACHE:
+        return _CACHE[lang]
+    path = resources.files(__name__).joinpath(f"{lang}{_SUFFIX}")
+    if not path.is_file():
+        result = {} if lang == _DEFAULT_LANG else load_glossary(_DEFAULT_LANG)
+        _CACHE[lang] = result
+        return result
+    _CACHE[lang] = _parse(path.read_text(encoding="utf-8"), lang)
+    return _CACHE[lang]
+
+
+__all__ = ["load_glossary"]
diff --git a/cinoc/reports/glossary/en.yaml b/cinoc/reports/glossary/en.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..7fa97d4d92c562a924778363bda96fd777de189d
--- /dev/null
+++ b/cinoc/reports/glossary/en.yaml
@@ -0,0 +1,268 @@
+# Pedagogical report glossary — English.
+#
+# Definitions for the non-expert reader, shown at the end of the report for the
+# metrics the engine actually computes. DATA (not executable surface): an entry
+# is added only for a metric that has a real consumer (a score in RunResult).
+#
+# Per-entry fields:
+#   title       : short title (shown in the disclosure summary)
+#   definition  : 2-3 sentences of formal definition
+#   measures    : what the metric concretely measures
+#   limits      : known limits and common pitfalls
+
+cer:
+  title: "CER — character error rate"
+  definition: >-
+    Ratio of the character-level edit distance (substitutions + insertions +
+    deletions) to the length of the reference, expressed as a proportion.
+    0 = perfect transcription.
+  measures: >-
+    Character-by-character fidelity between the engine output and the ground
+    truth, after the chosen normalization profile.
+  limits: >-
+    Blind to error meaning: a mistake on a rare character weighs as much as a
+    common one. Depends on the normalization profile applied.
+
+cer_diplo:
+  title: "Diplomatic CER"
+  definition: >-
+    CER computed without any graphical normalization: historical variants
+    (long s ſ, u/v, ligatures) are counted as distinct.
+  measures: >-
+    Fidelity to the exact spelling of the witness, as expected in a
+    diplomatic edition of a heritage document.
+  limits: >-
+    Stricter than normalized CER; comparable only across engines evaluated on
+    the same diplomatic ground truth.
+
+wer:
+  title: "WER — word error rate"
+  definition: >-
+    The word-level counterpart of CER: edit distance between the word
+    sequences of hypothesis and reference, divided by the reference word
+    count.
+  measures: >-
+    Word-by-word fidelity; a word is wrong as soon as a single character
+    differs.
+  limits: >-
+    Very sensitive to word segmentation and attached punctuation; a high WER
+    can hide a low CER.
+
+mer:
+  title: "MER — match error rate"
+  definition: >-
+    Ratio of the number of edit operations to the alignment length (reference
+    + insertions), bounded between 0 and 1.
+  measures: >-
+    The fraction of the character alignment that is not an exact match; a
+    bounded variant of CER.
+  limits: >-
+    Close to CER on clean text; diverges mainly with long
+    insertions/deletions.
+
+cmer:
+  title: "cMER — character match error rate (HIPE)"
+  definition: >-
+    Character-level Match Error Rate — (S+D+I)/(H+S+D+I) —, bounded between
+    0 and 1. The ranking metric of the HIPE-OCRepair benchmark, computed
+    under the official scorer's normalization profile.
+  measures: >-
+    The fraction of the character alignment that is not an exact match.
+    Unlike CER (relative to the reference only), it stays comparable even
+    when a generative model lengthens the text (CER > 100%).
+  limits: >-
+    Depends on the normalization profile: the "hipe" profile folds case,
+    punctuation and some heritage forms (œ/oe, æ/ae) — compare the
+    hipe/heritage views to isolate that effect.
+
+numseq_strict:
+  title: "Numerical sequences — strict preservation"
+  definition: >-
+    Share of the ground truth's numerical sequences (years, foliation,
+    amounts, regnal years) reproduced in their exact form by the engine.
+    Not applicable when the GT carries none.
+  measures: >-
+    The survival of what a historian cites and searches: "1515", "fol. 12r",
+    "3 livres", "an III" — form included.
+  limits: >-
+    Conservative pattern detection: spelled-out forms ("mil cinq cens") are
+    not covered; precision is favoured over recall.
+
+numseq_value:
+  title: "Numerical sequences — value preservation"
+  definition: >-
+    Share of the ground truth's numerical sequences whose equivalent is
+    reproduced, in any form: "f. 12r" matches "fol. 12r", "an 3" matches
+    "an III", "3 l." matches "3 livres".
+  measures: >-
+    The survival of the numerical information itself, tolerant to
+    abbreviation and form conversion.
+  limits: >-
+    Always greater than or equal to strict preservation; a large gap between
+    the two flags an engine that modernises or abbreviates forms.
+
+del_rate:
+  title: "Deletion rate"
+  definition: >-
+    Share of reference characters missing from the hypothesis, relative to
+    the reference length.
+  measures: >-
+    The engine's tendency to "drop" text (under-transcription).
+  limits: >-
+    A single error component: read together with the insertion rate to
+    diagnose an imbalance.
+
+ins_rate:
+  title: "Insertion rate"
+  definition: >-
+    Share of characters present in the hypothesis with no counterpart in the
+    reference, relative to the reference length.
+  measures: >-
+    The engine's tendency to "invent" text (over-transcription, sometimes a
+    sign of LLM hallucination).
+  limits: >-
+    A single error component; a high rate in isolation points to noise or
+    hallucination rather than a misreading.
+
+diacritic_err:
+  title: "Diacritic error"
+  definition: >-
+    Error rate restricted to diacritical marks (accents, cedillas, breves…)
+    after isolating the diacritic layer of the text.
+  measures: >-
+    The engine's fidelity to accentuation, often lost by OCR trained on
+    modern text.
+  limits: >-
+    Not applicable to scripts without diacritics; depends on the Unicode
+    normalization applied to the reference.
+
+mufi_err:
+  title: "MUFI error (medieval characters)"
+  definition: >-
+    Error rate restricted to characters from the Medieval Unicode Font
+    Initiative (abbreviations, rare letters) present in the reference.
+  measures: >-
+    The engine's ability to render the specialized characters of medieval
+    scripts.
+  limits: >-
+    Not applicable if the ground truth contains no MUFI character.
+
+hcpr:
+  title: "Historical character preservation (HCPR)"
+  definition: >-
+    Share of archaic characters from a configured list (long s, rotunda
+    abbreviations, thorn…) present in the ground truth that survive in the output.
+  measures: >-
+    The engine's *diplomatic* fidelity to historical forms — the "preservation"
+    counterpart of mufi_err/diacritic_err, over a curated list.
+  limits: >-
+    Shown only when an archaic list is explicitly configured (otherwise
+    redundant with mufi_err); not applicable if the GT carries none.
+
+air:
+  title: "Archaism insertion rate (AIR)"
+  definition: >-
+    Share of archaic characters in the **output** that are inserted — at a
+    position not faithful to the ground truth — rather than copied from it.
+  measures: >-
+    Over-historicization: a VLM/LLM that "archaizes" text the GT writes plainly
+    (added long s, invented abbreviations).
+  limits: >-
+    Not applicable if the output contains no character from the list; an upper
+    bound (a legitimate archaism outside the GT can raise it).
+
+ner_f1:
+  title: "Named-entity F1"
+  definition: >-
+    Harmonic mean of precision/recall over entities (people, places, dates)
+    recovered in the output, with spans aligned to ground-truth coordinates.
+  measures: >-
+    Downstream usefulness for prosopographic indexing: a flattering CER can
+    hide the loss of proper nouns, which are decisive for search.
+  limits: >-
+    Joint OCR + NER measure (the entity model also fails); matching is by span
+    overlap (IoU ≥ 0.5), not by meaning.
+
+hallucination:
+  title: "Unanchored text (trigrams)"
+  definition: >-
+    Share of the hypothesis's character trigrams **absent** from the
+    reference (1 − n-gram anchoring). Higher = more text produced with no
+    support in the GT.
+  measures: >-
+    How much text is produced with no match in the source document — a
+    measured signal, not proof of intentional "hallucination".
+  limits: >-
+    A surface measure: a legitimate insertion (text truly present but
+    outside the GT) raises it; it establishes no model intent.
+
+searchability:
+  title: "Full-text recall (Lev ≤ 2)"
+  definition: >-
+    Share of reference words found in the hypothesis within a Levenshtein
+    distance ≤ 2 (tolerant full-text search, multiset matching).
+  measures: >-
+    How many GT words would remain retrievable by a tolerant search despite
+    transcription errors.
+  limits: >-
+    A usage heuristic: it does not replace a recall evaluation on real
+    queries.
+
+region_cer:
+  title: "Per-region CER"
+  definition: >-
+    CER aggregated at the level of a layout region (block, column), when
+    segmentation provides a partition.
+  measures: >-
+    Localized transcription quality, to spot the areas of a page where the
+    engine breaks down.
+  limits: >-
+    Depends on upstream segmentation quality; not applicable without a
+    structural layer.
+
+region_detection:
+  title: "Region detection"
+  definition: >-
+    Overlap measure between the regions found by segmentation and the regions
+    of the layout ground truth.
+  measures: >-
+    The accuracy of segmentation (did we find the right blocks, in the right
+    place) independently of text.
+  limits: >-
+    Not applicable without layout ground truth; sensitive to the chosen
+    overlap threshold.
+
+significance_p:
+  title: "p-value (statistical test)"
+  definition: >-
+    Probability of observing a difference at least as large between two
+    engines if they were in fact equivalent (null hypothesis).
+  measures: >-
+    How surprising a performance gap is; a low p-value (< 0.05) indicates a
+    gap unlikely to be due to chance.
+  limits: >-
+    Measures neither the magnitude nor the practical importance of the gap;
+    sensitive to corpus size and requires correction for multiple comparisons.
+
+ece:
+  title: "ECE — expected calibration error"
+  definition: >-
+    Token-weighted average gap between the confidence an engine reports and
+    its actually observed accuracy.
+  measures: >-
+    How trustworthy an engine's confidence scores are: a well-calibrated
+    engine is right as often as it claims.
+  limits: >-
+    Not applicable to engines without confidence scores; depends on the
+    confidence binning.
+
+mce:
+  title: "MCE — maximum calibration error"
+  definition: >-
+    Largest gap, across all confidence bins, between reported confidence and
+    observed accuracy.
+  measures: >-
+    The worst case of an engine's over- or under-confidence, where ECE only
+    gives the average.
+  limits: >-
+    Sensitive to sparsely populated bins; read together with ECE.
diff --git a/cinoc/reports/glossary/fr.yaml b/cinoc/reports/glossary/fr.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..dc47d2c068be07f0f1b73ab2f6e66e6ab85da8b7
--- /dev/null
+++ b/cinoc/reports/glossary/fr.yaml
@@ -0,0 +1,272 @@
+# Glossaire pédagogique du rapport — français.
+#
+# Définitions destinées au lecteur non-expert, affichées en fin de rapport
+# pour les seules métriques effectivement calculées par le moteur. DONNÉE
+# (≠ surface exécutable) : on n'ajoute une entrée que pour une métrique qui a
+# un consommateur réel (un détecteur/un score dans le RunResult).
+#
+# Champs par entrée :
+#   title       : titre court (affiché dans le résumé dépliable)
+#   definition  : 2-3 phrases de définition formelle
+#   measures    : ce que la métrique mesure concrètement
+#   limits      : limites connues, pièges fréquents
+
+cer:
+  title: "CER — taux d'erreur caractère"
+  definition: >-
+    Rapport entre la distance d'édition (substitutions + insertions +
+    suppressions) au niveau caractère et la longueur de la référence,
+    exprimé en proportion. 0 = transcription parfaite.
+  measures: >-
+    La fidélité caractère-à-caractère entre la sortie du moteur et la
+    vérité terrain, après le profil de normalisation choisi.
+  limits: >-
+    Insensible au sens des erreurs : une faute sur un caractère rare pèse
+    autant qu'une faute courante. Dépend du profil de normalisation appliqué.
+
+cer_diplo:
+  title: "CER diplomatique"
+  definition: >-
+    CER calculé sans aucune normalisation graphique : les variantes
+    historiques (s long ſ, u/v, ligatures) sont comptées comme distinctes.
+  measures: >-
+    La fidélité à la graphie exacte du témoin, telle qu'attendue dans une
+    édition diplomatique de document patrimonial.
+  limits: >-
+    Plus sévère que le CER normalisé ; à ne comparer qu'entre moteurs
+    évalués sur la même vérité terrain diplomatique.
+
+wer:
+  title: "WER — taux d'erreur mot"
+  definition: >-
+    Équivalent du CER au niveau du mot : distance d'édition entre les
+    suites de mots de l'hypothèse et de la référence, rapportée au nombre
+    de mots de référence.
+  measures: >-
+    La fidélité mot-à-mot ; un mot est faux dès qu'un seul de ses
+    caractères diffère.
+  limits: >-
+    Très sensible à la segmentation en mots et à la ponctuation collée ;
+    un WER élevé peut masquer un CER faible.
+
+mer:
+  title: "MER — match error rate"
+  definition: >-
+    Rapport entre le nombre d'opérations d'édition et la longueur de
+    l'alignement (référence + insertions), borné entre 0 et 1.
+  measures: >-
+    La part de l'alignement caractère qui n'est pas une correspondance
+    exacte ; variante bornée du CER.
+  limits: >-
+    Proche du CER sur texte propre ; diverge surtout en présence de longues
+    insertions/suppressions.
+
+cmer:
+  title: "cMER — match error rate caractère (HIPE)"
+  definition: >-
+    Match Error Rate au niveau caractère — (S+D+I)/(H+S+D+I) —, borné entre
+    0 et 1. C'est la métrique de classement du benchmark HIPE-OCRepair,
+    calculée sous le profil de normalisation du scorer officiel.
+  measures: >-
+    La part de l'alignement caractère qui n'est pas une correspondance
+    exacte. Contrairement au CER (rapporté à la seule référence), il reste
+    comparable même quand un modèle génératif rallonge le texte (CER > 100 %).
+  limits: >-
+    Dépend du profil de normalisation : le profil « hipe » plie casse,
+    ponctuation et certaines formes patrimoniales (œ/oe, æ/ae) — comparer les
+    vues hipe/heritage pour isoler cet effet.
+
+numseq_strict:
+  title: "Séquences numériques — restitution stricte"
+  definition: >-
+    Part des séquences numériques de la vérité terrain (années, foliotation,
+    montants, années régnales) restituées sous leur forme exacte par le
+    moteur. Non applicable si la GT n'en porte aucune.
+  measures: >-
+    La survie de ce qu'un historien cite et cherche : « 1515 », « fol. 12r »,
+    « 3 livres », « an III » — à la forme près.
+  limits: >-
+    Détection par motifs conservateurs : les formes en toutes lettres
+    (« mil cinq cens ») ne sont pas couvertes ; la précision prime sur le
+    rappel.
+
+numseq_value:
+  title: "Séquences numériques — restitution en valeur"
+  definition: >-
+    Part des séquences numériques de la vérité terrain dont l'équivalent est
+    restitué, quelle que soit la forme : « f. 12r » vaut « fol. 12r »,
+    « an 3 » vaut « an III », « 3 l. » vaut « 3 livres ».
+  measures: >-
+    La survie de l'information numérique elle-même, tolérante aux
+    abréviations et conversions de forme.
+  limits: >-
+    Toujours supérieure ou égale à la restitution stricte ; un écart fort
+    entre les deux signale un moteur qui modernise ou abrège les formes.
+
+del_rate:
+  title: "Taux de suppressions"
+  definition: >-
+    Part des caractères de la référence absents de l'hypothèse, rapportée à
+    la longueur de référence.
+  measures: >-
+    La tendance du moteur à « oublier » du texte (sous-transcription).
+  limits: >-
+    Composante d'erreur seule : à lire avec le taux d'insertions pour
+    diagnostiquer un déséquilibre.
+
+ins_rate:
+  title: "Taux d'insertions"
+  definition: >-
+    Part de caractères présents dans l'hypothèse sans correspondant dans la
+    référence, rapportée à la longueur de référence.
+  measures: >-
+    La tendance du moteur à « inventer » du texte (sur-transcription,
+    parfois signe d'hallucination LLM).
+  limits: >-
+    Composante d'erreur seule ; un taux élevé isolé oriente vers du bruit
+    ou une hallucination plutôt qu'une mauvaise lecture.
+
+diacritic_err:
+  title: "Erreur sur les diacritiques"
+  definition: >-
+    Taux d'erreur restreint aux signes diacritiques (accents, cédilles,
+    brèves…) après isolement de la couche diacritique du texte.
+  measures: >-
+    La fidélité du moteur à l'accentuation, souvent perdue par les OCR
+    entraînés sur du texte moderne.
+  limits: >-
+    Non applicable aux écritures sans diacritiques ; dépend de la
+    normalisation Unicode appliquée à la référence.
+
+mufi_err:
+  title: "Erreur MUFI (caractères médiévaux)"
+  definition: >-
+    Taux d'erreur restreint aux caractères de la Medieval Unicode Font
+    Initiative (abréviations, lettres rares) présents dans la référence.
+  measures: >-
+    La capacité du moteur à restituer les caractères spécialisés des
+    écritures médiévales.
+  limits: >-
+    Non applicable si la vérité terrain ne contient aucun caractère MUFI.
+
+hcpr:
+  title: "Préservation des archaïsmes (HCPR)"
+  definition: >-
+    Part des caractères archaïques d'une liste configurée (s long, abréviations
+    rotunda, thorn…) présents dans la vérité terrain qui survivent dans la sortie.
+  measures: >-
+    La fidélité *diplomatique* du moteur aux formes historiques — le pendant
+    « préservation » de mufi_err/diacritic_err, sur une liste curée.
+  limits: >-
+    Visible seulement quand une liste archaïque est explicitement configurée
+    (sinon redondant avec mufi_err) ; non applicable si la GT n'en porte aucun.
+
+air:
+  title: "Apport net d'archaïsmes (AIR)"
+  definition: >-
+    Part des caractères archaïques de la **sortie** qui sont insérés — à une
+    position non fidèle à la vérité terrain — plutôt que recopiés d'elle.
+  measures: >-
+    La **sur-historicisation** : un VLM/LLM qui « archaïse » un texte que la GT
+    écrit en clair (s long ajouté, abréviations inventées).
+  limits: >-
+    Non applicable si la sortie ne contient aucun caractère de la liste ;
+    borne supérieure (un archaïsme légitime hors GT peut le faire monter).
+
+ner_f1:
+  title: "F1 sur entités nommées"
+  definition: >-
+    Moyenne harmonique précision/rappel des entités (personnes, lieux, dates)
+    retrouvées dans la sortie, spans alignés en coordonnées vérité terrain.
+  measures: >-
+    L'**utilité aval** pour l'indexation prosopographique : un CER flatteur
+    peut masquer la perte des noms propres, décisifs pour la recherche.
+  limits: >-
+    Mesure **conjointe** OCR + extracteur NER (le modèle d'entités faillit
+    aussi) ; appariement par recouvrement de spans (IoU ≥ 0,5), pas par sens.
+
+hallucination:
+  title: "Texte non ancré (trigrammes)"
+  definition: >-
+    Part des trigrammes de caractères de l'hypothèse **absents** de la
+    référence (1 − ancrage n-gramme). Plus haut = plus de texte produit
+    sans appui dans le GT.
+  measures: >-
+    La quantité de texte produit sans correspondance dans le document
+    source — un signal mesuré, pas une preuve d'« hallucination »
+    intentionnelle.
+  limits: >-
+    Mesure de surface : une insertion légitime (texte réellement présent
+    mais hors GT) la fait monter ; n'établit aucune intention du modèle.
+
+searchability:
+  title: "Rappel plein-texte (Lev ≤ 2)"
+  definition: >-
+    Part des mots de la référence retrouvés dans l'hypothèse à distance de
+    Levenshtein ≤ 2 (recherche plein-texte tolérante, appariement
+    multi-ensemble).
+  measures: >-
+    Combien de mots du GT resteraient retrouvables par une recherche
+    tolérante malgré les erreurs de transcription.
+  limits: >-
+    Heuristique d'usage : ne remplace pas une évaluation de rappel sur des
+    requêtes réelles.
+
+region_cer:
+  title: "CER par région"
+  definition: >-
+    CER agrégé au niveau d'une région de mise en page (bloc, colonne),
+    quand la segmentation fournit un découpage.
+  measures: >-
+    La qualité de transcription localisée, pour repérer les zones d'une
+    page où le moteur décroche.
+  limits: >-
+    Dépend de la qualité de la segmentation amont ; non applicable sans
+    couche structurelle.
+
+region_detection:
+  title: "Détection de régions"
+  definition: >-
+    Mesure de recouvrement entre les régions détectées par la segmentation
+    et les régions de la vérité terrain de mise en page.
+  measures: >-
+    La justesse de la segmentation (a-t-on trouvé les bons blocs, au bon
+    endroit) indépendamment du texte.
+  limits: >-
+    Non applicable sans vérité terrain de mise en page ; sensible au seuil
+    de recouvrement choisi.
+
+significance_p:
+  title: "p-valeur (test statistique)"
+  definition: >-
+    Probabilité d'observer un écart au moins aussi grand entre deux moteurs
+    si, en réalité, ils étaient équivalents (hypothèse nulle).
+  measures: >-
+    Le degré de surprise d'un écart de performance ; une p-valeur basse
+    (< 0,05) indique un écart peu attribuable au hasard.
+  limits: >-
+    Ne mesure ni l'ampleur ni l'importance pratique de l'écart ; sensible à
+    la taille du corpus et exige une correction en comparaisons multiples.
+
+ece:
+  title: "ECE — erreur de calibration attendue"
+  definition: >-
+    Écart moyen, pondéré par le nombre de jetons, entre la confiance
+    annoncée par le moteur et son exactitude réellement observée.
+  measures: >-
+    À quel point les scores de confiance d'un moteur sont fiables : un
+    moteur bien calibré a raison à hauteur de ce qu'il annonce.
+  limits: >-
+    Non applicable aux moteurs sans score de confiance ; dépend du
+    découpage en bins de confiance.
+
+mce:
+  title: "MCE — erreur de calibration maximale"
+  definition: >-
+    Plus grand écart, sur l'ensemble des bins de confiance, entre confiance
+    annoncée et exactitude observée.
+  measures: >-
+    Le pire cas de sur- ou sous-confiance d'un moteur, là où l'ECE n'en
+    donne que la moyenne.
+  limits: >-
+    Sensible aux bins peu peuplés ; à lire conjointement avec l'ECE.
diff --git a/cinoc/reports/glossary_panel.py b/cinoc/reports/glossary_panel.py
new file mode 100644
index 0000000000000000000000000000000000000000..7109d047e26f27fbf6bd59e54910e1abfc8bef4b
--- /dev/null
+++ b/cinoc/reports/glossary_panel.py
@@ -0,0 +1,85 @@
+"""Glossaire contextuel — panneau ``<dialog>`` natif, ouvert depuis le chrome.
+
+Remplace l'ancienne section bas-de-page (le glossaire est de la **périphérie**,
+pas du flux de lecture). Le contenu vient de la DONNÉE ``glossary/{lang}.yaml``
+(anti-hallucination, aucune prose générée), pour les **seules** métriques
+présentes dans le ``RunResult``.
+
+Enrichissement progressif : sans JS, le ``<dialog>`` s'affiche via ``:target``
+(le lien-ancre du chrome) ; avec JS, ``report.js`` l'ouvre en **modale**
+(``showModal()``). Le contenu (disclosures ``<details>``) reste lisible dans les
+deux cas.
+"""
+
+from __future__ import annotations
+
+from cinoc.reports.glossary import load_glossary
+from cinoc.reports.html import escape
+
+#: Id du dialog (cible de l'ancre du chrome + du repli ``:target``).
+DIALOG_ID = "glossary-dialog"
+
+#: Champs affichés, ordre stable (déterminisme) : ``(clé, libellé FR, libellé EN)``.
+_FIELDS: tuple[tuple[str, str, str], ...] = (
+    ("definition", "Définition", "Definition"),
+    ("measures", "Ce que ça mesure", "What it measures"),
+    ("limits", "Limites", "Limits"),
+)
+_HEADINGS = {"fr": "Glossaire", "en": "Glossary"}
+_INTROS = {
+    "fr": "Définitions des métriques présentes dans ce rapport, pour le lecteur "
+    "non spécialiste.",
+    "en": "Definitions of the metrics present in this report, for the "
+    "non-specialist reader.",
+}
+_CLOSE = {"fr": "Fermer", "en": "Close"}
+
+
+def _field_label(idx: int, lang: str) -> str:
+    return _FIELDS[idx][2] if lang == "en" else _FIELDS[idx][1]
+
+
+def _entry(term: dict[str, str], lang: str) -> str:
+    title = term.get("title", "")
+    rows = "".join(
+        f'<dt class="gl-k">{escape(_field_label(i, lang))}</dt>'
+        f'<dd class="gl-v">{escape(term[key])}</dd>'
+        for i, (key, _, _) in enumerate(_FIELDS)
+        if term.get(key)
+    )
+    return (
+        '<details class="gl-item"><summary class="gl-term">'
+        f"{escape(title)}</summary>\n"
+        f'<dl class="gl-body">{rows}</dl></details>\n'
+    )
+
+
+def glossary_chrome_link(lang: str) -> str:
+    """Lien « Glossaire » du chrome (ancre → ``#glossary-dialog``)."""
+    label = escape(_HEADINGS.get(lang, _HEADINGS["fr"]))
+    return f'<a class="chrome-btn" href="#{DIALOG_ID}">{label}</a>'
+
+
+def glossary_dialog(present: set[str], lang: str) -> str:
+    """``<dialog>`` du glossaire pour les métriques **présentes** ; ``""`` si aucune.
+
+    Ordre stable = clés de métrique triées. Renvoie une chaîne vide si aucune
+    métrique présente n'a d'entrée de glossaire (pas de dialog, pas de lien chrome).
+    """
+    glossary = load_glossary(lang)
+    items = [_entry(glossary[m], lang) for m in sorted(present) if m in glossary]
+    if not items:
+        return ""
+    heading = escape(_HEADINGS.get(lang, _HEADINGS["fr"]))
+    intro = escape(_INTROS.get(lang, _INTROS["fr"]))
+    close = escape(_CLOSE.get(lang, _CLOSE["fr"]))
+    return (
+        f'<dialog id="{DIALOG_ID}" class="glossary-dialog" aria-label="{heading}">'
+        f'<div class="gd-head"><h2>{heading}</h2>'
+        f'<a class="gd-close" href="#" data-close aria-label="{close}">✕</a></div>'
+        f'<p class="muted">{intro}</p>'
+        f'<div class="glossary">{"".join(items)}</div></dialog>'
+    )
+
+
+__all__ = ["DIALOG_ID", "glossary_chrome_link", "glossary_dialog"]
diff --git a/cinoc/reports/html.py b/cinoc/reports/html.py
new file mode 100644
index 0000000000000000000000000000000000000000..959ee8757e87a6c849e5226f34a2a454df96a506
--- /dev/null
+++ b/cinoc/reports/html.py
@@ -0,0 +1,702 @@
+"""Assemblage HTML **autonome** au design + échappement (couche 7).
+
+Produit un document autonome (**CSS inline**, aucune dépendance CDN/JS), donc
+hébergeable tel quel **et déterministe** (cf. plan §Cibles de distribution). Le
+style reprend le **design** (gris chaud, chrome pilule, cartes ``sec``, tables
+tabulaires) ; les **polices du design** — titres *Mona Sans*, corps *IBM Plex
+Sans*, données *IBM Plex Mono*, accents *Fluxisch Else*, logo *OCR-A* — sont
+**incorporées en data-URI** (``_style.font_face_css``) pour garder
+l'identité typographique **et** l'autonomie (S4.b.1a, option (a) — cf. D-019). Les
+**données** sont échappées via ``escape`` ; la **structure** est de l'``Html`` de
+confiance.
+"""
+
+from __future__ import annotations
+
+import html as _html
+
+from cinoc.reports._style import font_face_css
+from cinoc.reports.section import Html
+
+#: CSS du rapport au design (sous-ensemble de ``design/tokens.css``). Les
+#: ``@font-face`` (Mona/IBM Plex/Fluxisch/OCR-A, data-URI) sont préfixés au rendu par
+#: ``font_face_css()``. Statique → le rapport reste octet-stable.
+_CSS = (
+    ":root{--paper:#EBE8E0;--surface:#F4F1EA;--raised:#FBFAF6;--g-50:#E4E0D7;"
+    "--g-100:#D6D2C8;--g-300:#8D8879;--g-400:#6F6B60;--g-500:#54514A;"
+    "--g-700:#26241F;--ink:#1A1917;--fern:oklch(0.50 0.07 145);"
+    "--r-md:14px;--r-lg:20px;--r-pill:999px;"
+    "--display:'Mona Sans VF','IBM Plex Sans',system-ui,sans-serif;"
+    "--sans:'IBM Plex Sans',system-ui,sans-serif;"
+    "--mono:'IBM Plex Mono',ui-monospace,monospace;"
+    "--accent:'Fluxisch Else',Georgia,serif;"
+    "--ocr:'OCRA','IBM Plex Mono',ui-monospace,monospace;}"
+    "*{box-sizing:border-box;margin:0;padding:0;}"
+    "body.report-board{background-color:var(--paper);"
+    "background-image:url(\"data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg'"
+    " width='3' height='3' viewBox='0 0 3 3'><circle cx='1' cy='1' r='0.6'"
+    " fill='%231a1917' fill-opacity='0.28'/></svg>\");"
+    "background-attachment:fixed;color:var(--ink);"
+    "font-family:var(--sans);font-size:14px;line-height:1.5;padding:22px;"
+    "display:flex;flex-direction:column;gap:18px;"
+    "-webkit-font-smoothing:antialiased;}"
+    ".report-chrome{display:flex;align-items:center;gap:16px;padding:12px 18px;"
+    "background:var(--ink);border-radius:var(--r-pill);color:var(--paper);"
+    "flex-wrap:wrap;}"
+    ".report-chrome .wm-mark{display:inline-flex;align-items:center;"
+    "justify-content:center;width:24px;height:24px;border-radius:50%;"
+    "background:var(--paper);color:var(--ink);font-weight:700;font-size:12px;}"
+    ".report-chrome .wm-name{font-family:var(--ocr);font-weight:400;"
+    "font-size:18px;letter-spacing:0.01em;}"
+    # Le « o » de Cinoc rendu en **capitale OCR-A** (glyphe octogonal iconique,
+    # comme le « O » de l'ancien logo) ; le texte DOM reste « Cinoc ».
+    ".report-chrome .wm-o{text-transform:uppercase;}"
+    ".report-chrome .wm-sep{width:1px;height:16px;background:rgba(239,237,232,0.2);}"
+    ".report-chrome .wm-sub{font-family:var(--mono);font-size:11px;"
+    "letter-spacing:0.04em;color:rgba(239,237,232,0.6);}"
+    # Méta de run (docs/moteurs/date) + actions d'export, poussées à droite.
+    ".chrome-meta{margin-left:auto;display:flex;gap:14px;align-items:center;"
+    "font-family:var(--mono);font-size:10.5px;color:rgba(239,237,232,0.55);}"
+    ".chrome-meta .v{color:var(--paper);}"
+    ".chrome-actions{display:flex;gap:6px;margin-left:2px;}"
+    ".chrome-btn{background:rgba(239,237,232,0.10);color:var(--paper);"
+    "text-decoration:none;padding:6px 12px;border-radius:var(--r-pill);"
+    "font-family:var(--mono);font-size:10.5px;}"
+    ".chrome-btn:hover{background:rgba(239,237,232,0.18);}"
+    ".report-main{display:flex;flex-direction:column;gap:14px;}"
+    # Grille de cartes (CSS Grid, sans JS) sur la **vue maître** (.tab-master) :
+    # pistes auto-ajustées ~23rem, hauteur intrinsèque (pas de chevauchement),
+    # ordre DOM = ordre de lecture, repli 1 colonne. Larges = grid-column:1/-1.
+    # L'onglet (.tab-panel) n'est qu'un conteneur maître/détail ; le détail
+    # (.tab-detail) est une pile pleine largeur ; ``[hidden]`` masque une vue.
+    ".tab-master{display:grid;gap:14px;align-items:start;"
+    "grid-template-columns:repeat(auto-fill,minmax(min(100%,23rem),1fr));}"
+    ".tab-master>.view-hero,.tab-master>.r-block.r-wide{grid-column:1/-1;}"
+    # min-width:0 : l'item de grille n'élargit pas sa piste (anti-débordement).
+    ".tab-master>.r-block{min-width:0;}"
+    ".tab-master[hidden],.tab-detail[hidden]{display:none;}"
+    # Sous-titre thématique d'un onglet riche : bande pleine largeur, zéro JS.
+    ".tab-subhead{grid-column:1/-1;font-family:var(--display);font-weight:800;"
+    "font-size:13px;letter-spacing:0.08em;text-transform:uppercase;"
+    "color:var(--g-400);margin:10px 2px 0;}"
+    # Modes (Rapport/Explorer) : empilés sans JS, ``[hidden]`` masque l'inactif.
+    # Spine = sommaire collant horizontal (ancres de groupe) en tête de mode.
+    ".mode[hidden]{display:none;}"
+    ".spine{position:sticky;top:0;z-index:5;display:flex;flex-wrap:wrap;"
+    "gap:3px 5px;padding:8px 2px;margin-bottom:10px;background:var(--paper);"
+    "border-bottom:1px solid var(--g-100);}"
+    ".spine-link{font-family:var(--sans);font-size:13px;font-weight:500;"
+    "color:var(--g-700);text-decoration:none;white-space:nowrap;"
+    "padding:4px 10px;border-radius:var(--r-pill);line-height:1.25;}"
+    ".spine-link:hover{color:var(--ink);background:var(--g-50);}"
+    ".spine-link.on{color:var(--ink);font-weight:700;background:var(--g-50);}"
+    ".sec{background:var(--raised);border-radius:var(--r-lg);padding:22px 26px 24px;}"
+    ".sec h1{font-family:var(--display);font-size:24px;font-weight:800;"
+    "font-optical-sizing:auto;letter-spacing:0;"
+    "margin-bottom:6px;}"
+    ".sec h2{font-family:var(--display);font-size:18px;font-weight:800;"
+    "font-optical-sizing:auto;letter-spacing:0;"
+    "color:var(--ink);margin:18px 0 10px;}.sec h2:first-of-type{margin-top:0;}"
+    ".sec p.muted{font-size:12.5px;color:var(--g-400);margin-bottom:10px;}"
+    "table{width:100%;border-collapse:collapse;font-size:13px;margin:.4rem 0;}"
+    "th{text-align:left;font-size:10.5px;letter-spacing:0.06em;"
+    "text-transform:uppercase;color:var(--g-400);font-weight:500;"
+    "padding:10px 14px;border-bottom:1px solid var(--g-100);}"
+    "td{padding:11px 14px;border-bottom:1px solid var(--g-50);color:var(--g-700);}"
+    "tr:last-child td{border-bottom:none;}"
+    "td.num{text-align:right;font-family:var(--mono);"
+    "font-variant-numeric:tabular-nums;color:var(--ink);}"
+    # Readouts (portée du corpus) + tables data-bars
+    ".readouts{display:grid;grid-template-columns:repeat(auto-fit,minmax(116px,1fr));"
+    "gap:10px;margin:14px 0 6px;}"
+    ".readout{background:var(--surface);border-radius:var(--r-md);padding:14px 16px;"
+    "display:flex;flex-direction:column;gap:6px;}"
+    ".readout .r-label{font-size:10px;font-weight:500;letter-spacing:0.06em;"
+    "text-transform:uppercase;color:var(--g-400);}"
+    ".readout .r-value{font-family:var(--display);font-size:30px;"
+    "font-weight:800;font-optical-sizing:auto;letter-spacing:0;"
+    "font-variant-numeric:tabular-nums;"
+    "line-height:1;color:var(--ink);}"
+    # Grille de tables **côte à côte** : une longue liste est découpée en N
+    # colonnes pour **utiliser la largeur** au lieu de descendre tout en bas
+    # (`--n` posé en inline) ; replie en 1 colonne sur écran étroit.
+    ".tcols{display:grid;grid-template-columns:repeat(var(--n,2),1fr);"
+    "gap:0 26px;align-items:start;}"
+    "@media (max-width:760px){.tcols{grid-template-columns:1fr;}}"
+    ".table-scroll{overflow-x:auto;}"
+    ".table-scroll table.data{min-width:max-content;}"
+    "table.data.compact{width:auto;max-width:540px;}"
+    "table.data td.lbl{text-align:left;color:var(--g-700);}"
+    "table.data{width:100%;border-collapse:collapse;font-size:13px;margin:.4rem 0 0;}"
+    "table.data th{text-align:left;font-size:10.5px;letter-spacing:0.04em;"
+    "text-transform:uppercase;color:var(--g-400);font-weight:500;"
+    "padding:8px 14px 10px;border-bottom:1px solid var(--g-100);}"
+    "table.data th.num-cell{text-align:right;}"
+    # Super-en-tête de groupe thématique (calque « Par moteur » du canon).
+    "table.data tr.grp-row th{border-bottom:none;padding:8px 14px 0;}"
+    "table.data tr.grp-row th.grp-head{font-size:9.5px;letter-spacing:0.05em;"
+    "text-transform:uppercase;color:var(--g-300);font-weight:600;"
+    "border-bottom:1px solid var(--g-100);}"
+    # Tables vivantes : en-tête triable (clic) + définition au survol (E1).
+    "table.data th.sortable{cursor:pointer;user-select:none;}"
+    "table.data th.sortable:hover{color:var(--ink);}"
+    "th .th-sort{font-size:9px;opacity:0.35;margin-left:2px;}"
+    'th.sortable[aria-sort="ascending"] .th-sort,'
+    'th.sortable[aria-sort="descending"] .th-sort{opacity:1;color:var(--fern);}'
+    ".has-def{text-decoration:underline dotted;text-underline-offset:3px;"
+    "text-decoration-color:var(--g-300);}"
+    "table.data td.eng-cell{vertical-align:middle;padding:10px 14px;"
+    "border-bottom:1px solid var(--g-50);color:var(--g-700);}"
+    "table.data tr:last-child td{border-bottom:none;}"
+    "table.data td.databar{position:relative;padding:0;font-family:var(--mono);"
+    "font-variant-numeric:tabular-nums;font-size:12px;color:var(--ink);"
+    "border-bottom:1px solid var(--g-50);vertical-align:middle;"
+    # Teinte de cellule (canon) : fond sauge ∝ position sur l'axe de la colonne
+    # (``--t`` ∈ [0,1], posé par ``bar_cell``). Valeurs proches → teintes proches,
+    # contrairement à l'ancienne barre normalisée qui saturait la cellule.
+    "background:rgba(120,134,107,calc(var(--t,0) * 0.26));}"
+    # Barre fine de base : encore utilisée par image_quality / word_errors (où la
+    # LONGUEUR = score/compte a un sens) — la table de métriques, elle, est teintée.
+    "table.data td.databar .db-fill{position:absolute;left:14px;bottom:5px;height:3px;"
+    "border-radius:2px;background:var(--fern);opacity:0.55;z-index:0;}"
+    "table.data td.databar .db-num{position:relative;z-index:1;display:block;"
+    "text-align:right;padding:12px 14px;}"
+    "table.data td.disp{padding:11px 14px;text-align:right;font-family:var(--mono);"
+    "font-size:11px;color:var(--g-500);border-bottom:1px solid var(--g-50);}"
+    "table.data td.verdict{padding:11px 14px;font-family:var(--sans);font-size:11.5px;"
+    "color:var(--g-400);border-bottom:1px solid var(--g-50);}"
+    "table.data td.verdict.sig{color:var(--fern);font-weight:600;}"
+    # Badge de significativité sur le verdict (synthèse) : le classement n'est
+    # jamais lu sans sa qualification statistique. yes=écart confirmé (fern),
+    # no=non séparable (gris), tie=égalité statistique (avertissement chaud).
+    ".sig-badge{display:inline-flex;align-items:center;font-family:var(--mono);"
+    "font-size:10.5px;padding:3px 9px;border-radius:var(--r-pill);"
+    "letter-spacing:0.02em;white-space:nowrap;}"
+    ".sig-yes{background:var(--fern);color:var(--paper);}"
+    ".sig-no{background:var(--g-50);color:var(--g-400);}"
+    ".sig-tie{background:rgba(214,176,90,0.32);color:var(--g-700);}"
+    # Profil moteur (drill-in) : panneaux cachés, révélés au clic (report.js) ou
+    # via :target (sans JS). Bande KPI + graphe CER/document.
+    # Nom du moteur = lien vers son profil (couleur conservée, souligné au survol).
+    ".eng-cell a{color:inherit;text-decoration:none;cursor:pointer;}"
+    ".eng-cell a:hover{text-decoration:underline;text-decoration-color:var(--fern);}"
+    ".drill-panel[hidden]{display:none;}"
+    ".drill-panel:target{display:block;}"
+    ".doc-card{text-decoration:none;color:inherit;cursor:pointer;}"
+    ".doc-card:hover{outline:2px solid var(--fern);outline-offset:2px;}"
+    # Détail document (drill-in) : CER par moteur + diff des pires lignes.
+    # CER par moteur : grille compacte (badge · nom · valeur) — la valeur suit le
+    # nom dans sa colonne (alignée ET proche), au lieu d'être projetée au bord.
+    ".dd-cers{display:inline-grid;grid-template-columns:auto auto auto;"
+    "gap:5px 10px;align-items:center;margin-bottom:14px;}"
+    ".dd-row{display:contents;}"
+    ".dd-name{font-family:var(--mono);font-size:12px;color:var(--g-700);}"
+    ".dd-cer{font-variant-numeric:tabular-nums;font-family:var(--mono);"
+    "font-size:12px;color:var(--g-700);text-align:right;}"
+    ".dd-row.best .dd-cer{color:var(--fern);font-weight:600;}"
+    ".dd-diffs{display:flex;flex-direction:column;gap:12px;}"
+    ".dd-diff{background:var(--surface);border-radius:var(--r-md);padding:10px 12px;}"
+    ".dd-diff-head{font-size:11px;color:var(--g-500);margin-bottom:6px;"
+    "display:flex;align-items:center;gap:6px;}"
+    # Détail document : fac-similé medium EN HAUT, zoomable/pan (molette + glisser).
+    # Bandeau étroit **centré** au-dessus du diff (qui prend toute la largeur en
+    # dessous) — image modeste, le texte respire.
+    ".dd-fac-top{max-width:760px;margin:0 auto 14px;}"
+    ".dd-fac-full{font-family:var(--sans);font-size:12px;font-weight:500;"
+    "margin-left:10px;color:var(--g-500);text-decoration:none;white-space:nowrap;}"
+    ".dd-fac-full:hover{color:var(--ink);text-decoration:underline;}"
+    # Cartes secondaires du drill-in (CER, heatmap ligne, qualité image…) en
+    # grille : chacune à sa hauteur intrinsèque, pistes auto-ajustées de ~21rem,
+    # ``align-items:start`` (pas d'étirement ni de chevauchement, ≠ l'ancien
+    # masonry ``columns``). Repli 1 colonne en deçà de 21rem.
+    ".dd-flow{display:grid;gap:12px;margin-top:14px;align-items:start;"
+    "grid-template-columns:repeat(auto-fill,minmax(min(100%,21rem),1fr));}"
+    ".dd-card{border:1px solid var(--g-50);"
+    "border-radius:var(--r-md);padding:13px 15px;background:var(--surface);}"
+    ".dd-card.dd-wide{grid-column:1/-1;}"
+    ".dd-fac-zoom{position:relative;overflow:auto;height:clamp(360px,62vh,640px);"
+    "display:flex;align-items:center;justify-content:center;"
+    "background:var(--surface);border-radius:var(--r-md);"
+    "border:1px solid var(--g-50);cursor:zoom-in;}"
+    ".dd-fac-img{max-width:100%;max-height:100%;display:block;flex:none;"
+    "user-select:none;}"
+    ".dd-zoom-ctl{position:absolute;top:8px;right:8px;display:flex;gap:4px;}"
+    ".dd-zoom-ctl button{width:26px;height:26px;border:none;border-radius:6px;"
+    "background:rgba(26,25,23,0.72);color:var(--paper);cursor:pointer;font-size:14px;"
+    "line-height:1;display:flex;align-items:center;justify-content:center;}"
+    # Diff côte à côte : 2 colonnes égales, chacune une carte bordée (en-tête +
+    # corps serif scrollable, sauts de ligne respectés).
+    ".dd-sbs{display:grid;grid-template-columns:1fr 1fr;gap:12px;align-items:start;}"
+    ".dd-sbs-col{min-width:0;border:1px solid var(--g-50);border-radius:var(--r-md);"
+    "background:var(--raised);overflow:hidden;}"
+    ".dd-sbs-col .dd-diff-head{margin:0;padding:7px 12px;background:var(--surface);"
+    "border-bottom:1px solid var(--g-50);}"
+    "@media (max-width:720px){.dd-sbs{grid-template-columns:1fr;}}"
+    # Qualité d'image du document : mini-barres mesurées (recentrées sur le doc).
+    ".dd-iq{margin-bottom:14px;}"
+    ".dd-iq-bars{display:flex;flex-direction:column;gap:5px;}"
+    ".dd-iq-row{display:flex;align-items:center;gap:8px;font-size:12px;"
+    "color:var(--g-700);}"
+    ".dd-iq-lbl{flex:0 0 150px;}"
+    # Primitive partagée : piste de proportion horizontale [0,1]. La coque est
+    # commune (qualité d'image, percentiles, strates) ; l'appelant pose la largeur
+    # du fill (`width:X%`) + sa couleur (classe `lh-*` ou style inline).
+    ".track{flex:1;height:8px;background:var(--surface);border-radius:var(--r-pill);"
+    "overflow:hidden;}"
+    ".track>i{display:block;height:100%;border-radius:inherit;}"
+    ".dd-iq-val{flex:0 0 40px;text-align:right;font-variant-numeric:tabular-nums;}"
+    ".dd-iq-meta{font-size:11px;margin-top:6px;}"
+    # CER ligne par ligne du document : un mini histogramme par moteur (hauteur
+    # ∝ CER), repères début→fin. Une barre = une ligne GT.
+    ".dd-lh{margin-bottom:14px;}"
+    ".dd-lh-rows{display:flex;flex-direction:column;gap:12px;}"
+    ".dd-lh-row{display:flex;align-items:flex-start;gap:8px;font-family:var(--mono);"
+    "font-size:12px;color:var(--g-700);}"
+    ".dd-lh-plot{flex:1;min-width:0;}"
+    ".dd-lh-bars{display:flex;align-items:flex-end;justify-content:center;"
+    "gap:2px;height:40px;padding-bottom:2px;}"
+    ".dd-lh-bar{flex:1 1 0;min-width:2px;max-width:48px;border-radius:2px 2px 0 0;}"
+    ".dd-lh-axis{display:flex;justify-content:space-between;font-size:10px;"
+    "color:var(--g-400);margin-top:3px;}"
+    ".lh-g{background:var(--fern);}.lh-m{background:#c9a227;}"
+    ".lh-o{background:#c2702f;}.lh-b{background:#a23b3b;}"
+    # Distribution par ligne : par moteur, badges + (carte thermique | percentiles).
+    ".dd-ld-rows{display:flex;flex-direction:column;gap:12px;}"
+    ".dd-ld-row{padding:10px 0;border-top:1px solid var(--g-50);}"
+    ".dd-ld-head{display:flex;align-items:center;flex-wrap:wrap;gap:6px;"
+    "font-family:var(--mono);font-size:12px;color:var(--g-700);margin-bottom:8px;}"
+    ".dd-ld-grid{display:grid;grid-template-columns:1fr 1fr;gap:16px;}"
+    "@media (max-width:720px){.dd-ld-grid{grid-template-columns:1fr;}}"
+    ".dd-ld-sub{font-size:10px;text-transform:uppercase;letter-spacing:0.04em;"
+    "color:var(--g-400);margin-bottom:5px;}"
+    ".dd-pct-row{display:flex;align-items:center;gap:8px;font-family:var(--mono);"
+    "font-size:11px;color:var(--g-700);margin-bottom:4px;}"
+    ".dd-pct-lbl{flex:0 0 30px;}"
+    ".dd-pct-val{flex:0 0 52px;text-align:right;font-variant-numeric:tabular-nums;}"
+    # Analyse des hallucinations du document : par moteur, indicateurs + blocs.
+    ".dd-hl{margin-bottom:14px;}"
+    ".dd-hl-row{padding:10px 0;border-top:1px solid var(--g-50);}"
+    ".dd-hl-head{display:flex;align-items:center;gap:8px;font-family:var(--mono);"
+    "font-size:12px;color:var(--g-700);margin-bottom:6px;}"
+    ".dd-hl-flag{color:var(--clay,#a23b3b);font-weight:600;font-size:11px;}"
+    # Primitive partagée : pastille (chip) + leur rangée (chips). Petite étiquette
+    # mono sur fond surface ; utilisée pour indicateurs et effectifs.
+    ".chips{display:flex;flex-wrap:wrap;gap:6px;}"
+    ".chip{font-family:var(--mono);font-size:11px;padding:3px 8px;"
+    "background:var(--surface);border-radius:var(--r-pill);color:var(--g-700);}"
+    ".dd-hl-blocks{margin-top:8px;font-size:12px;}"
+    ".dd-hl-block{padding:7px 10px;margin-top:5px;border-radius:var(--r-md);"
+    "background:rgba(229,154,138,0.18);line-height:1.6;word-break:break-word;}"
+    # Diff pleine page : sélecteur de moteur (segmenté) + blocs diff (un visible).
+    ".dd-fullwrap{margin-top:6px;}"
+    ".dd-engine-tabs{display:inline-flex;gap:2px;padding:3px;margin-bottom:10px;"
+    "background:var(--surface);border-radius:var(--r-pill);flex-wrap:wrap;}"
+    ".dd-eng-btn{display:inline-flex;align-items:center;gap:6px;border:none;"
+    "cursor:pointer;background:transparent;color:var(--g-500);font-family:var(--mono);"
+    "font-size:11px;padding:5px 12px;border-radius:var(--r-pill);}"
+    ".dd-eng-btn .eng-badge{margin-right:0;}"
+    ".dd-eng-btn.on{background:var(--ink);color:var(--paper);}"
+    ".dd-fulldiff[hidden]{display:none;}"
+    ".dd-fulldiff .diff{max-height:360px;overflow-y:auto;padding:11px 13px;"
+    "white-space:pre-wrap;word-break:break-word;"
+    "font-family:Georgia,'Times New Roman',serif;font-size:13px;line-height:1.85;}"
+    ".drill-head{display:flex;justify-content:space-between;align-items:center;"
+    "gap:12px;flex-wrap:wrap;margin-bottom:10px;}"
+    ".drill-back{font-family:var(--mono);font-size:12px;text-decoration:none;"
+    "color:var(--g-500);}.drill-back:hover{color:var(--ink);}"
+    ".drill-nav{display:flex;gap:6px;}"
+    ".drill-nav .btn-sm{font-family:var(--mono);font-size:11px;text-decoration:none;"
+    "color:var(--g-500);background:var(--surface);border-radius:var(--r-pill);"
+    "padding:5px 12px;}.drill-nav .btn-sm:hover{color:var(--ink);}"
+    ".drill-title{display:flex;align-items:center;gap:10px;"
+    "font-family:var(--display);font-weight:800;font-optical-sizing:auto;"
+    "font-size:22px;color:var(--ink);margin-bottom:14px;}"
+    ".drill-pos{font-family:var(--mono);font-size:11px;font-weight:400;}"
+    ".kpi-band{display:grid;grid-template-columns:repeat(auto-fit,minmax(110px,1fr));"
+    "gap:10px;margin-bottom:16px;}"
+    ".kpi{background:var(--surface);border-radius:var(--r-md);padding:12px 14px;}"
+    ".kpi-k{font-family:var(--mono);font-size:10px;letter-spacing:0.06em;"
+    "text-transform:uppercase;color:var(--g-400);}"
+    ".kpi-v{font-family:var(--display);font-weight:800;font-optical-sizing:auto;"
+    "font-size:24px;font-variant-numeric:tabular-nums;color:var(--ink);}"
+    ".drill-caption{font-size:12px;color:var(--g-500);margin-bottom:6px;}"
+    ".bars-svg{width:100%;height:120px;display:block;background:var(--surface);"
+    "border-radius:var(--r-md);}"
+    ".prof-row{display:flex;gap:22px;flex-wrap:wrap;margin-top:16px;}"
+    ".prof-cell{flex:1;min-width:240px;}"
+    # Bascule galerie ⇄ liste (vue Documents) : pilule à 2 boutons, sur la charte.
+    ".view-toggle,.doc-filter{display:inline-flex;flex-wrap:wrap;gap:2px;padding:3px;"
+    "background:var(--surface);border-radius:var(--r-pill);margin-bottom:8px;}"
+    ".vt-btn,.df-btn{font-family:var(--mono);font-size:11px;border:none;cursor:pointer;"
+    "background:transparent;color:var(--g-500);padding:6px 14px;"
+    "border-radius:var(--r-pill);}"
+    ".vt-btn:hover,.df-btn:hover{color:var(--ink);}"
+    ".vt-btn.on,.df-btn.on{background:var(--ink);color:var(--paper);}"
+    ".doc-view[hidden],.doc-card[hidden]{display:none;}"
+    # Cellule de diff GT↔hypothèse (drill-in) : texte surligné, retour à la ligne.
+    "table.data td.diff{padding:11px 14px;font-family:var(--mono);font-size:12px;"
+    "color:var(--g-700);border-bottom:1px solid var(--g-50);white-space:pre-wrap;"
+    "word-break:break-word;vertical-align:top;}"
+    "del.d-del{background:rgba(229,154,138,0.30);text-decoration:none;"
+    "color:var(--ink);}"
+    "ins.d-ins{background:rgba(159,195,160,0.38);text-decoration:none;"
+    "color:var(--ink);}"
+    # Galerie de documents : grille de cartes au design (monochrome, charte rapport).
+    ".doc-grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(196px,1fr));"
+    "gap:14px;margin:14px 0 4px;}"
+    ".doc-card{background:var(--surface);border-radius:var(--r-md);padding:12px;"
+    "display:flex;flex-direction:column;gap:10px;}"
+    # Aperçu de page synthétique : lignes monochromes sur papier (≠ vignette colorée).
+    ".doc-preview{height:78px;border-radius:10px;border:1px solid var(--g-50);"
+    "background-color:var(--paper);background-image:repeating-linear-gradient("
+    "180deg,transparent 0 6px,rgba(26,25,23,0.10) 6px 7px);}"
+    # Vignette réelle : couvre la zone d'aperçu (objet centré, recadré).
+    ".doc-preview-img{background:var(--g-50);overflow:hidden;padding:0;}"
+    ".doc-preview-img img{width:100%;height:100%;object-fit:cover;display:block;}"
+    ".doc-card .dc-id{font-family:var(--mono);font-size:12px;font-weight:600;"
+    "color:var(--ink);word-break:break-all;}"
+    ".dc-anom{margin-left:5px;color:var(--clay,#a23b3b);font-weight:400;}"
+    ".anom-legend{font-size:11px;margin:6px 0 2px;}"
+    ".dc-rows{display:flex;flex-direction:column;gap:4px;}"
+    ".dc-row{display:flex;align-items:center;gap:6px;font-family:var(--mono);"
+    "font-size:11px;color:var(--g-500);}"
+    ".dc-row .eng-badge{margin-right:0;}"
+    ".dc-row .dc-name{flex:1;overflow:hidden;text-overflow:ellipsis;"
+    "white-space:nowrap;}"
+    ".dc-row .dc-cer{font-variant-numeric:tabular-nums;color:var(--g-700);}"
+    ".dc-row.best .dc-cer{color:var(--fern);font-weight:600;}"
+    ".muted{color:var(--g-400);}"
+    "::selection{background:var(--ink);color:var(--paper);}"
+    # Composition du corpus par strate : nom + effectif, barre proportionnelle, part.
+    ".strata-grid{display:flex;flex-direction:column;gap:14px;margin:14px 0 4px;}"
+    ".strata-row{display:grid;grid-template-columns:1fr 2fr auto;gap:14px;"
+    "align-items:center;}"
+    ".strata-head{display:flex;align-items:center;gap:8px;}"
+    ".strata-name{font-family:var(--display);font-weight:800;"
+    "font-optical-sizing:auto;font-size:15px;color:var(--ink);}"
+    ".strata-pct{font-family:var(--display);font-weight:800;"
+    "font-optical-sizing:auto;font-size:22px;font-variant-numeric:tabular-nums;"
+    "color:var(--ink);}"
+    # Grille de dispersion CER (SVG serveur, échelle commune) : badge+nom, box
+    # plot, labels min·méd·µ·max. Couleurs d'accent inline (palette engine_badges).
+    ".disp-grid{display:flex;flex-direction:column;gap:14px;margin:14px 0 4px;}"
+    ".disp-row{display:grid;grid-template-columns:170px 1fr;gap:6px 14px;"
+    "align-items:center;}"
+    ".disp-head{display:flex;align-items:center;gap:8px;}"
+    ".disp-name{font-family:var(--mono);font-size:12px;color:var(--ink);"
+    "overflow:hidden;text-overflow:ellipsis;white-space:nowrap;}"
+    ".disp-labels{grid-column:2;font-size:11px;color:var(--g-500);"
+    "font-variant-numeric:tabular-nums;}"
+    # Boîte à moustaches (SVG serveur) : moustaches min→max + capuchons, boîte
+    # interquartile teintée, trait médian (couleur moteur), tick moyenne (encre).
+    ".box-plot{width:100%;height:22px;display:block;}"
+    ".box-whisker,.box-cap{stroke:var(--g-300);stroke-width:1.5;}"
+    ".box-box{fill-opacity:0.32;stroke-width:1.5;}"
+    ".box-med{stroke-width:2;}"
+    ".box-mean{stroke:var(--ink);stroke-width:1;stroke-dasharray:2 2;}"
+    # Courbe de calibration (SVG serveur) : diagonale pointillée = parfaite,
+    # polyligne + disques = le moteur. Plot carré à gauche, table à droite.
+    ".calib-block{display:flex;gap:22px;align-items:flex-start;flex-wrap:wrap;"
+    "margin:.4rem 0 1rem;}"
+    ".calib-plot{display:flex;flex-direction:column;gap:4px;flex:0 0 auto;}"
+    ".calib-svg{width:180px;height:180px;display:block;background:var(--surface);"
+    "border-radius:var(--r-md);}"
+    ".calib-axis{font-size:10px;color:var(--g-400);text-align:center;}"
+    ".calib-block table.data{flex:1;min-width:240px;}"
+    ".calib-diag{stroke:var(--g-300);stroke-width:1;stroke-dasharray:3 3;}"
+    ".calib-line{fill:none;stroke-width:2;stroke-linejoin:round;}"
+    # Composition d'erreurs (taxonomy) : barre empilée SVG + légende par classe.
+    ".comp{display:flex;flex-direction:column;gap:10px;margin:.3rem 0 1rem;}"
+    ".comp-bar{width:100%;height:14px;display:block;border-radius:6px;"
+    "overflow:hidden;}"
+    ".comp-legend{display:flex;flex-direction:column;gap:4px;}"
+    # swatch · label · part · compte **groupés à gauche** (spacer 1fr en fin) :
+    # sinon le label en 1fr poussait la valeur au bord droit (illisible en large).
+    ".comp-row{display:grid;grid-template-columns:14px 132px auto auto 1fr;gap:10px;"
+    "align-items:center;font-size:12px;}"
+    ".comp-sw{width:12px;height:12px;border-radius:3px;}"
+    ".comp-label{color:var(--g-700);}"
+    ".comp-share{color:var(--ink);font-variant-numeric:tabular-nums;}"
+    ".comp-count{color:var(--g-400);font-variant-numeric:tabular-nums;}"
+    # Radar multi-métrique (SVG serveur) : grille concentrique + un polygone teinté
+    # par moteur (superposés). Carré, centré dans sa carte ; légende moteurs sous.
+    ".radar-wrap{max-width:300px;margin:8px auto 4px;}"
+    ".radar-svg{width:100%;height:auto;display:block;}"
+    ".radar-grid{fill:none;stroke:var(--g-100);stroke-width:1;}"
+    ".radar-spoke{stroke:var(--g-100);stroke-width:1;}"
+    ".radar-axis{font-family:var(--mono);font-size:9px;fill:var(--g-400);}"
+    ".radar-area{fill-opacity:0.13;stroke-width:2;stroke-linejoin:round;}"
+    # Sommet : cible de survol (<title> = valeur brute + normalisée), cerné de fond.
+    ".radar-vertex{fill-opacity:0.95;stroke:var(--surface);stroke-width:1;}"
+    ".radar-legend{text-align:center;}"
+    # Camembert (anneau SVG serveur) : parts teintées + trou central couleur fond
+    # (découpe). Légende = pastille + libellé + compte. Centré dans sa carte.
+    ".donut-svg{width:140px;height:140px;display:block;margin:6px auto 4px;}"
+    ".donut-seg{stroke:var(--surface);stroke-width:1;}"
+    ".donut-hole{fill:var(--surface);}"
+    ".donut-legend{text-align:center;}"
+    ".donut-key{display:inline-block;width:9px;height:9px;border-radius:2px;"
+    "vertical-align:middle;margin-right:2px;}"
+    # Graphe haltère (SVG serveur) : une ligne par document, points = CER par
+    # moteur reliés (min→max). Échelle uniforme, libellé doc à gauche.
+    ".dumb-wrap{max-width:380px;margin:8px auto 4px;}"
+    ".dumb-svg{width:100%;height:auto;display:block;}"
+    ".dumb-link{stroke:var(--g-300);stroke-width:2;}"
+    ".dumb-dot{stroke-width:1;fill-opacity:0.9;}"
+    ".dumb-label{font-family:var(--mono);font-size:9px;fill:var(--g-400);}"
+    ".dumb-legend{text-align:center;}"
+    # Dot plot classé (SVG serveur) : par moteur, moustache d'IC 95 % + point à la
+    # moyenne, axe commun. Montre l'écart ET son incertitude, sans verdict.
+    ".dot-svg{width:100%;max-width:340px;height:auto;display:block;margin:6px 0;}"
+    ".dot-axis{stroke:var(--g-100);stroke-width:1;}"
+    ".dot-ci{stroke-width:2.5;stroke-linecap:round;opacity:0.55;}"
+    ".dot-pt{stroke:var(--paper);stroke-width:1;}"
+    ".dot-lbl{font-family:var(--mono);font-size:10px;fill:var(--g-500);}"
+    # Carte des mots (heatmap SVG) : mots verbatim en lignes, moteurs en colonnes,
+    # cases teintées par compte. Compagnon visuel de la table (aria-hidden).
+    # Diagramme de Venn du recouvrement (2-3 moteurs) : cercles teintés par
+    # moteur (faible opacité), compte par région inscrit.
+    ".venn-svg{max-width:340px;height:auto;display:block;margin:.4rem auto .2rem;}"
+    ".venn-circle{fill-opacity:0.13;stroke-width:1.5;}"
+    ".venn-count{font-family:var(--mono);font-size:15px;fill:var(--ink);"
+    "font-variant-numeric:tabular-nums;}"
+    ".venn-label{font-family:var(--mono);font-size:11px;fill:var(--g-500);}"
+    ".wmap-svg{max-width:100%;height:auto;display:block;background:var(--surface);"
+    "border-radius:var(--r-md);margin:.4rem auto 0;}"
+    ".wmap-word{font-family:var(--mono);font-size:11px;fill:var(--ink);}"
+    ".wmap-head{font-family:var(--mono);font-size:10px;fill:var(--g-400);"
+    "letter-spacing:0.04em;}"
+    ".wmap-count{font-family:var(--mono);font-size:10px;"
+    "font-variant-numeric:tabular-nums;}"
+    ".wmap-cell{stroke:var(--surface);stroke-width:1;}"
+    # Flux de confusion de caractères (#8) : glyphe attendu → produit, prominents
+    # (« voir les symboles » ; le slot bordé rend une espace visible) + barre de
+    # fréquence. Direction lisible (ſ→f ≠ f→ſ).
+    ".cf-engine{margin:.4rem 0 1rem;}"
+    ".cf-eng-name{font-family:var(--mono);font-size:12px;color:var(--g-500);}"
+    ".cf-grid{display:flex;flex-wrap:wrap;gap:8px;margin-top:8px;}"
+    ".cf-pair{display:flex;align-items:center;gap:7px;background:var(--surface);"
+    "border-radius:var(--r-md);padding:7px 11px;}"
+    ".cf-glyph{font-family:var(--mono);font-size:17px;line-height:1;min-width:1.3em;"
+    "text-align:center;background:var(--raised);border:1px solid var(--g-50);"
+    "border-radius:6px;padding:3px 5px;color:var(--ink);}"
+    ".cf-arrow{color:var(--g-400);font-size:12px;}"
+    ".cf-bar{height:6px;border-radius:var(--r-pill);background:var(--fern);"
+    "opacity:0.55;min-width:2px;}"
+    ".cf-count{font-family:var(--mono);font-size:11px;color:var(--g-500);"
+    "font-variant-numeric:tabular-nums;}"
+    # Flux mot→forme(s) (#16 sur-normalisation, #17 modernisation) : le mot source
+    # (prominent) → la/les forme(s) produite(s) ; chip(s) ± barre (taille = compte).
+    # Flux de modernisation en **colonnes journal** (≥ ~23em) au lieu d'une seule
+    # colonne qui descend tout en bas ; chaque ligne reste insécable.
+    ".wflow{columns:23em;column-gap:26px;margin:.4rem 0 1rem;}"
+    ".wf-row{display:flex;align-items:center;gap:8px;flex-wrap:wrap;"
+    "break-inside:avoid;margin-bottom:7px;}"
+    ".wf-word{font-family:var(--mono);font-size:13px;background:var(--surface);"
+    "border:1px solid var(--g-50);border-radius:6px;padding:3px 8px;color:var(--ink);}"
+    ".wf-src{background:var(--raised);font-weight:600;}"
+    ".wf-arrow{color:var(--g-400);font-size:12px;}"
+    ".wf-dst{display:inline-flex;align-items:center;gap:5px;}"
+    ".wf-bar{height:5px;border-radius:var(--r-pill);background:var(--fern);"
+    "opacity:0.5;min-width:2px;}"
+    ".wf-count{font-family:var(--mono);font-size:10.5px;color:var(--g-500);"
+    "font-variant-numeric:tabular-nums;}"
+    ".wf-meta{font-family:var(--mono);font-size:10.5px;color:var(--g-400);}"
+    # Glossaire pédagogique : disclosure natif (<details>), monochrome, charte.
+    ".glossary{display:flex;flex-direction:column;gap:8px;margin:12px 0 4px;}"
+    ".gl-item{background:var(--surface);border-radius:var(--r-md);"
+    "padding:4px 16px;}"
+    ".gl-term{font-family:var(--display);font-weight:800;font-size:14px;"
+    "font-optical-sizing:auto;color:var(--ink);cursor:pointer;"
+    "padding:10px 0;list-style:none;}"
+    ".gl-term::-webkit-details-marker{display:none;}"
+    ".gl-term::before{content:'+';display:inline-block;width:16px;"
+    "font-family:var(--mono);color:var(--g-400);}"
+    ".gl-item[open] .gl-term::before{content:'\\2212';}"
+    ".gl-body{margin:0 0 12px 16px;display:grid;grid-template-columns:auto 1fr;"
+    "gap:4px 14px;}"
+    ".gl-k{font-size:10px;font-weight:500;letter-spacing:0.05em;"
+    "text-transform:uppercase;color:var(--g-400);padding-top:2px;"
+    "white-space:nowrap;}"
+    ".gl-v{font-size:12.5px;color:var(--g-700);line-height:1.45;}"
+    # Dialog du glossaire (périphérie, ouvert depuis le chrome). Modale native
+    # avec JS (showModal + ::backdrop) ; repli ``:target`` (panneau centré) sans JS.
+    ".glossary-dialog{border:none;border-radius:var(--r-lg);padding:22px 24px;"
+    "max-width:680px;width:90vw;max-height:82vh;overflow:auto;"
+    "background:var(--raised);color:var(--ink);"
+    "box-shadow:0 16px 48px rgba(0,0,0,0.3);}"
+    ".glossary-dialog::backdrop{background:rgba(26,25,23,0.45);}"
+    ".glossary-dialog:target{display:block;position:fixed;top:9vh;left:50%;"
+    "transform:translateX(-50%);z-index:60;}"
+    ".gd-head{display:flex;align-items:center;justify-content:space-between;"
+    "margin-bottom:4px;}"
+    ".gd-head h2{margin:0;}"
+    ".gd-close{font-family:var(--mono);font-size:14px;text-decoration:none;"
+    "color:var(--g-400);padding:2px 8px;border-radius:var(--r-md);}"
+    ".gd-close:hover{color:var(--ink);background:var(--g-50);}"
+    # Onglets du rapport (IA 4 vues) — **intégrés au chrome** (fond sombre) :
+    # bande translucide, onglet actif en pilule claire (cf. design/tokens.css).
+    # Enrichissement progressif : sans JS, panneaux empilés et visibles, les
+    # onglets sont de simples ancres (#panel-<t>) ; report.js bascule l'affichage.
+    ".report-tabs{display:inline-flex;flex-wrap:wrap;gap:2px;padding:3px;"
+    "background:rgba(239,237,232,0.08);border-radius:var(--r-pill);}"
+    ".report-tab{font-family:var(--sans);font-weight:500;font-size:12px;"
+    "text-decoration:none;color:rgba(239,237,232,0.78);padding:6px 14px;"
+    "border-radius:var(--r-pill);white-space:nowrap;}"
+    ".report-tab:hover{color:var(--paper);}"
+    ".report-tab.on{background:var(--paper);color:var(--ink);}"
+    ".tab-panel[hidden]{display:none;}"
+    ".tab-panel:focus{outline:none;}"
+    ".r-block{scroll-margin-top:18px;}"
+    # Héros de vue (bande d'en-tête par onglet) — carte ``--raised`` : eyebrow
+    # « VUE 0n · NOM » + titre display + desc + readouts de portée à droite.
+    ".view-hero{background:var(--raised);border-radius:var(--r-lg);"
+    "padding:22px 26px 20px;display:flex;align-items:flex-end;"
+    "justify-content:space-between;gap:24px;flex-wrap:wrap;}"
+    ".view-hero-eyebrow{font-family:var(--mono);font-size:10.5px;color:var(--g-400);"
+    "letter-spacing:0.06em;text-transform:uppercase;}"
+    ".view-hero-name{font-family:var(--display);font-weight:800;"
+    "font-optical-sizing:auto;font-size:30px;letter-spacing:-0.02em;"
+    "line-height:1.05;margin-top:4px;color:var(--ink);}"
+    ".view-hero-desc{font-family:var(--accent);font-style:italic;font-size:14px;"
+    "color:var(--g-500);max-width:60ch;margin-top:6px;}"
+    ".view-hero-stats{display:flex;gap:24px;}"
+    ".hero-stat{display:flex;flex-direction:column;gap:2px;text-align:right;}"
+    ".hero-stat .v{font-family:var(--display);font-weight:800;"
+    "font-optical-sizing:auto;font-size:26px;letter-spacing:-0.02em;"
+    "font-variant-numeric:tabular-nums;color:var(--ink);line-height:1;}"
+    ".hero-stat .k{font-family:var(--mono);font-size:10px;color:var(--g-400);"
+    "letter-spacing:0.06em;text-transform:uppercase;}"
+    # Badge moteur (lettre + accent cyclique) — identité stable entre sections.
+    # Marqueur moteur = **pastille de couleur** (l'accent relie le moteur à ses
+    # courbes/barres). La lettre est masquée (redondante avec le nom adjacent),
+    # gardée dans le DOM pour les lecteurs d'écran / le repli sans couleur.
+    ".eng-badge{display:inline-flex;align-items:center;justify-content:center;"
+    "width:9px;height:9px;border-radius:50%;background:var(--badge,var(--ink));"
+    "color:transparent;font-size:0;flex:0 0 auto;"
+    "margin-right:8px;vertical-align:middle;}"
+    # Widget « comparer un run » (client-side) — bouton + bandeau sticky des deltas.
+    ".compare-bar{display:flex;justify-content:flex-end;margin-top:2px;}"
+    ".compare-btn{font-family:var(--mono);font-size:12px;background:var(--ink);"
+    "color:var(--paper);border:none;border-radius:var(--r-pill);"
+    "padding:8px 16px;cursor:pointer;}"
+    ".compare-banner{position:fixed;left:22px;right:22px;bottom:14px;"
+    "background:var(--ink);color:var(--paper);border-radius:var(--r-md);"
+    "padding:12px 16px;display:flex;flex-wrap:wrap;gap:8px 18px;align-items:center;"
+    "font-family:var(--mono);font-size:12px;box-shadow:0 6px 24px rgba(0,0,0,0.25);"
+    "z-index:50;}"
+    ".compare-banner.empty{justify-content:center;color:var(--g-100);}"
+    ".compare-banner .cb-title{font-weight:600;letter-spacing:0.02em;}"
+    ".compare-banner .cb-row{display:inline-flex;gap:6px;align-items:baseline;}"
+    ".compare-banner .cb-row .cb-delta{font-variant-numeric:tabular-nums;}"
+    ".compare-banner .cb-row.worse .cb-delta{color:#E59A8A;}"
+    ".compare-banner .cb-row.better .cb-delta{color:#9FC3A0;}"
+    # Palette daltonien (``?palette=cb`` via report.js → classe sur <html>) : le
+    # vert/rouge confusables → paire bleu/orange distinguable. Les badges moteur
+    # portent une lettre → restent identifiables sans couleur.
+    ".palette-cb{--fern:oklch(0.55 0.13 250);}"
+    ".palette-cb .compare-banner .cb-row.worse .cb-delta{color:#E0A23C;}"
+    ".palette-cb .compare-banner .cb-row.better .cb-delta{color:#7FB0D9;}"
+    ".palette-cb del.d-del{background:rgba(224,162,60,0.32);}"
+    ".palette-cb ins.d-ins{background:rgba(127,176,217,0.38);}"
+)
+
+
+def escape(text: str) -> str:
+    """Échappe une donnée pour insertion sûre dans le HTML."""
+    return _html.escape(text, quote=True)
+
+
+def localized(lang: str, fr: str, en: str) -> str:
+    """Choisit la chaîne selon la langue du rapport (``en`` si ``"en"``, sinon ``fr``).
+
+    Mécanisme i18n **minimal** : les sections gardent leurs deux formulations
+    **adjacentes** au point d'usage (revue/maintenance faciles), sélectionnées via
+    ``SectionContext.lang`` — **pas de catalogue ni de registre** de chaînes. Repli
+    sur le français pour toute langue non gérée (déterminisme : même langue →
+    mêmes octets)."""
+    return en if lang == "en" else fr
+
+
+#: Libellés humains des vues d'évaluation : nom interne → (FR, EN). **Source
+#: unique** consommée par toutes les sections (fin du « vue : text » brut dans les
+#: titres). Une vue absente d'ici porte déjà un nom lisible (ex. « référence OCR
+#: (pas une vérité-terrain manuelle) ») → affichée telle quelle.
+_VIEW_LABELS: dict[str, tuple[str, str]] = {
+    "text": ("Texte brut", "Plain text"),
+    "diplomatic": ("Transcription diplomatique", "Diplomatic transcription"),
+}
+
+
+def view_label(view: str, lang: str) -> str:
+    """Libellé humain d'une vue d'évaluation (repli sur le nom brut si inconnu).
+
+    Centralise la traduction du **nom interne** de vue (``"text"``) vers un
+    libellé lisible (« Texte brut »). Déterministe (même vue + langue → mêmes
+    octets) ; n'échappe pas (l'appelant échappe au point d'insertion HTML)."""
+    pair = _VIEW_LABELS.get(view)
+    if pair is None:
+        return view
+    return pair[1] if lang == "en" else pair[0]
+
+
+def view_prefix(view: str, lang: str, *, multi: bool) -> str:
+    """Préfixe de titre de bloc « <Libellé de vue> — », **seulement** si le run
+    porte plusieurs vues à distinguer ; sinon ``""`` (le libellé est déjà porté
+    par le héros/onglet → pas de ressassage « Texte brut — » sur chaque section).
+    Déjà échappé (fragment HTML prêt) : l'appelant l'insère tel quel."""
+    return f"{escape(view_label(view, lang))} — " if multi else ""
+
+
+def render_document(
+    title: str,
+    body: Html,
+    *,
+    footer: Html | None = None,
+    lang: str = "fr",
+    tabs: str = "",
+    meta: str = "",
+) -> str:
+    """Assemble un document HTML autonome, au design, et déterministe.
+
+    ``footer`` (optionnel) : HTML inséré en fin de ``<body>``, après le contenu
+    principal — p. ex. le widget « comparer un run » (client-side). Absent → rien
+    n'est ajouté (le rapport reste identique au squelette, ex. la voie
+    ``compare`` server-side qui n'embarque pas le widget). ``lang`` pilote
+    l'attribut ``<html lang>`` (a11y / lecteurs d'écran). ``tabs``/``meta`` :
+    HTML **de confiance** intégré au **chrome** (barre d'onglets et méta+exports) ;
+    vides → chrome minimal (wordmark seul). Le corps n'est **plus** enveloppé dans
+    une carte unique : chaque section rend **sa** carte ``.sec``."""
+    safe_title = escape(title)
+    safe_lang = escape(lang)
+    sub = "Report · benchmark" if lang == "en" else "Rapport · benchmark"
+    tail = f"{footer}" if footer is not None else ""
+    return (
+        "<!DOCTYPE html>\n"
+        f'<html lang="{safe_lang}">\n'
+        "<head>\n"
+        '<meta charset="utf-8">\n'
+        '<meta name="viewport" content="width=device-width, initial-scale=1">\n'
+        f"<title>{safe_title}</title>\n"
+        f"<style>{font_face_css()}{_CSS}</style>\n"
+        "</head>\n"
+        '<body class="report-board">\n'
+        '<header class="report-chrome">'
+        '<span class="wm-mark">C</span>'
+        '<span class="wm-name">Cin<span class="wm-o">o</span>c</span>'
+        f'<span class="wm-sep"></span><span class="wm-sub">{sub}</span>'
+        f"{tabs}{meta}</header>\n"
+        f'<main class="report-main">{body}</main>\n'
+        f"{tail}"
+        "</body>\n"
+        "</html>\n"
+    )
+
+
+__all__ = [
+    "escape",
+    "localized",
+    "render_document",
+    "view_label",
+    "view_prefix",
+]
diff --git a/cinoc/reports/layout_svg.py b/cinoc/reports/layout_svg.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b81b32d2f6537683424128edf6089dab8d47999
--- /dev/null
+++ b/cinoc/reports/layout_svg.py
@@ -0,0 +1,90 @@
+"""Rendu **SVG serveur** d'un ``CanonicalLayout`` : régions → rectangles.
+
+Couche 7 (reports) : transforme la géométrie neutre (domain) en SVG **autonome et
+déterministe** — boîtes de régions + labels, sur un fond de page (ou l'image
+source). Sert la visualisation de segmentation de la vitrine et reste
+réutilisable par le rapport. **Aucun JS, aucun état** : même layout → mêmes octets
+(invariant §12). On rend la **première page** (le squelette segmentation est
+mono-page) ; les régions imbriquées sont aplaties (boîtes dessinées à plat).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from html import escape
+
+from cinoc.domain.layout import CanonicalLayout, LayoutPage, Region
+
+#: Palette de contours de régions (cyclique, déterministe — pas d'aléa).
+_STROKES = ("#3a6ea5", "#b5651d", "#4a7c59", "#7d5ba6", "#a63a4f")
+
+
+def _flatten(regions: tuple[Region, ...]) -> Iterator[Region]:
+    """Régions à plat (premier niveau puis imbriquées, profondeur d'abord)."""
+    for region in regions:
+        yield region
+        yield from _flatten(region.regions)
+
+
+def _page_size(page: LayoutPage) -> tuple[int, int]:
+    """Dimensions de page déclarées, sinon l'enveloppe des boîtes de régions."""
+    if page.width and page.height:
+        return page.width, page.height
+    width = height = 0
+    for region in _flatten(page.regions):
+        box = region.geometry.bbox if region.geometry else None
+        if box is not None:
+            width = max(width, box.x + box.width)
+            height = max(height, box.y + box.height)
+    return max(width, 1), max(height, 1)
+
+
+def layout_to_svg(
+    layout: CanonicalLayout, *, image_href: str | None = None, max_width: int = 720
+) -> str:
+    """Rend la 1ʳᵉ page d'un layout en SVG (boîtes de régions + labels).
+
+    ``image_href`` (optionnel) place l'image source en fond ; sinon un fond de
+    page neutre. ``max_width`` borne la largeur d'affichage (le ``viewBox`` garde
+    les coordonnées réelles). Utilise des **attributs de présentation** SVG
+    (``fill``/``stroke``), pas de ``style`` inline → compatible CSP stricte.
+    """
+    if not layout.pages:
+        return '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1 1"></svg>'
+    page = layout.pages[0]
+    width, height = _page_size(page)
+    parts = [
+        '<svg xmlns="http://www.w3.org/2000/svg" '
+        f'viewBox="0 0 {width} {height}" width="{min(width, max_width)}" '
+        'role="img" class="seg-svg">'
+    ]
+    if image_href:
+        parts.append(
+            f'<image href="{escape(image_href, quote=True)}" x="0" y="0" '
+            f'width="{width}" height="{height}"/>'
+        )
+    else:
+        parts.append(
+            f'<rect x="0" y="0" width="{width}" height="{height}" '
+            'fill="#fafafa" stroke="#e6e6e6"/>'
+        )
+    for index, region in enumerate(_flatten(page.regions)):
+        box = region.geometry.bbox if region.geometry else None
+        if box is None:
+            continue
+        stroke = _STROKES[index % len(_STROKES)]
+        label = escape(region.region_type or region.id)
+        parts.append(
+            f'<rect x="{box.x}" y="{box.y}" width="{box.width}" '
+            f'height="{box.height}" fill="{stroke}" fill-opacity="0.08" '
+            f'stroke="{stroke}" stroke-width="2"/>'
+        )
+        parts.append(
+            f'<text x="{box.x + 4}" y="{box.y + 16}" font-size="13" '
+            f'fill="{stroke}" font-family="monospace">{label}</text>'
+        )
+    parts.append("</svg>")
+    return "".join(parts)
+
+
+__all__ = ["layout_to_svg"]
diff --git a/cinoc/reports/renderer.py b/cinoc/reports/renderer.py
new file mode 100644
index 0000000000000000000000000000000000000000..a9d1b3d7652b0f97452ec5ec5bd2e892d6a5ec77
--- /dev/null
+++ b/cinoc/reports/renderer.py
@@ -0,0 +1,384 @@
+"""``ReportRenderer`` — compose des sections en un document HTML autonome.
+
+**Injecté par l'``app``** (reports ne connaît pas app) : ``app`` choisit les
+sections. ``default_report_renderer`` fournit le socle (overview) du squelette.
+"""
+
+from __future__ import annotations
+
+import base64
+from collections.abc import Mapping
+
+from cinoc.evaluation.result import RunResult
+from cinoc.reports.compare_widget import compare_widget
+from cinoc.reports.csv_export import run_result_csv
+from cinoc.reports.embedded import inline_script
+from cinoc.reports.glossary_panel import glossary_chrome_link, glossary_dialog
+from cinoc.reports.html import escape, render_document
+from cinoc.reports.section import Html, Section, SectionContext
+
+#: Libellés FR des sections pour le sommaire (deeplinks) ; repli = nom brut.
+_SECTION_LABELS = {
+    "key_measures": "Mesures clés",
+    "overview": "Vue d'ensemble",
+    "corpus_composition": "Composition",
+    "by_engine": "Par moteur",
+    "engine_radar": "Profil radar",
+    "engine_profiles": "Profils moteur",
+    "document_details": "Détail document",
+    "documents": "Par document",
+    "dispersion": "Dispersion",
+    "cross_engine": "Inter-moteurs",
+    "engine_duel": "Duel par document",
+    "word_errors": "Carte des mots",
+    "conformity": "Conformité HIPE",
+    "structure": "Structure",
+    "correction": "Bilan de correction",
+    "structured_data": "Données structurées",
+    "philology": "Philologie",
+    "textual_fidelity": "Fidélité textuelle",
+    "lines": "Par ligne",
+    "ner": "Entités nommées",
+    "economics": "Économie",
+    "diagnostics": "Diagnostic",
+    "taxonomy": "Taxonomie",
+    "calibration": "Calibration",
+    "methodology": "Méthodologie",
+}
+
+#: Libellés **EN** des sections (parité de clés avec ``_SECTION_LABELS``) — pour
+#: l'``aria-label`` des blocs quand le rapport est rendu en anglais (``?lang=en``).
+_SECTION_LABELS_EN = {
+    "key_measures": "Key measures",
+    "overview": "Overview",
+    "corpus_composition": "Composition",
+    "by_engine": "By engine",
+    "engine_radar": "Radar profile",
+    "engine_profiles": "Engine profiles",
+    "document_details": "Document detail",
+    "documents": "By document",
+    "dispersion": "Dispersion",
+    "cross_engine": "Cross-engine",
+    "engine_duel": "Per-document duel",
+    "conformity": "HIPE conformity",
+    "structure": "Layout structure",
+    "correction": "Correction balance",
+    "structured_data": "Structured data",
+    "philology": "Philology",
+    "textual_fidelity": "Textual fidelity",
+    "lines": "Per line",
+    "ner": "Named entities",
+    "economics": "Economics",
+    "diagnostics": "Diagnostics",
+    "taxonomy": "Taxonomy",
+    "calibration": "Calibration",
+    "methodology": "Methodology",
+}
+
+
+def _label(name: str, lang: str = "fr") -> str:
+    table = _SECTION_LABELS_EN if lang == "en" else _SECTION_LABELS
+    return table.get(name, name)
+
+
+#: Deux **modes** d'interaction (≠ onglets par sujet) : « Rapport » (document
+#: défilant, lecture/impression) et « Explorer » (triage des documents). La bascule
+#: vit dans le chrome (réutilise la barre ``.report-tabs`` → ancres ``#mode-*``).
+_MODE_ORDER = ("rapport", "explorer")
+_MODE_LABELS = {
+    "fr": {"rapport": "Rapport", "explorer": "Explorer"},
+    "en": {"rapport": "Report", "explorer": "Explorer"},
+}
+_MODE_SWITCH_LABEL = {"fr": "Mode de lecture", "en": "Reading mode"}
+_SPINE_LABEL = {"fr": "Sommaire", "en": "Contents"}
+
+#: Groupes ordonnés ``(mode, clé, fr, en, sections…)``. Chaque groupe présent
+#: ouvre un sous-titre ancré (``#grp-<clé>``) que le spine du mode référence. Une
+#: section hors de tout groupe et non-détail est rendue en **pied** (annexe, ex.
+#: ``methodology``). Garde-fou : ``test_groups_cover_grouped_sections``.
+_GROUPS: tuple[tuple[str, str, str, str, tuple[str, ...]], ...] = (
+    ("rapport", "key", "Mesures clés", "Key measures",
+     ("key_measures", "overview", "corpus_composition")),
+    ("rapport", "compare", "Comparaison", "Engine comparison",
+     ("by_engine", "engine_radar", "dispersion")),
+    ("rapport", "crosses", "Significativité & recouvrement", "Significance & overlap",
+     ("cross_engine", "engine_duel", "word_errors")),
+    ("rapport", "errors", "Familles d'erreurs & analyses fines",
+     "Error families & fine-grained analyses",
+     ("conformity", "structure", "correction", "structured_data", "philology",
+      "textual_fidelity", "lines", "ner", "taxonomy", "calibration", "diagnostics")),
+    ("rapport", "economics", "Économie", "Economics", ("economics",)),
+    ("explorer", "documents", "Documents", "Documents", ("documents",)),
+)
+
+#: Section **détail** (maître/détail) de chaque mode : rendue dans un conteneur
+#: ``.tab-detail`` que ``report.js`` échange au clic (≠ ancre). Hors groupes.
+_DETAIL_OF_MODE = {"rapport": "engine_profiles", "explorer": "document_details"}
+
+#: Index inverse section → mode (groupes + détails). Sert au pied (annexe) et au
+#: garde-fou de couverture.
+_SECTION_MODE: dict[str, str] = {
+    **{name: mode for mode, _k, _fr, _en, names in _GROUPS for name in names},
+    **{detail: mode for mode, detail in _DETAIL_OF_MODE.items()},
+}
+
+
+#: Sections **intrinsèquement larges** (tableaux multi-colonnes, galeries, charts
+#: pleine largeur) : elles prennent toute la largeur dans le flux de cartes
+#: (``column-span:all``). Les autres (petits charts/listes) s'écoulent en colonnes.
+_WIDE_SECTIONS: frozenset[str] = frozenset({
+    "key_measures", "overview", "by_engine", "engine_profiles", "conformity",
+    "structured_data", "ner", "lines", "economics", "cross_engine",
+    "word_errors", "taxonomy", "correction", "textual_fidelity", "documents",
+    "diagnostics",
+})
+
+
+def _block(name: str, html: str, lang: str) -> str:
+    """Une section = sa **propre carte** ``.sec``, région ancrée (``#r-<name>``)."""
+    wide = " r-wide" if name in _WIDE_SECTIONS else ""
+    return (
+        f'<section id="r-{escape(name)}" class="r-block sec{wide}" '
+        f'aria-label="{escape(_label(name, lang))}">{html}</section>'
+    )
+
+
+def _spine(links: list[tuple[str, str]], lang: str) -> str:
+    """Sommaire collant d'un mode : liens ancrés vers les sous-titres de groupe."""
+    if not links:
+        return ""
+    items = "".join(
+        f'<a class="spine-link" href="#{gid}">{label}</a>' for gid, label in links
+    )
+    aria = escape(_SPINE_LABEL.get(lang, _SPINE_LABEL["fr"]))
+    return f'<nav class="spine" aria-label="{aria}">{items}</nav>'
+
+
+def _mode_body(
+    mode: str, by_name: dict[str, str], lang: str
+) -> tuple[str, list[tuple[str, str]]]:
+    """Corps d'un mode : maître groupé (sous-titres ancrés, cartes ``.sec``) +
+    détail (``_DETAIL_OF_MODE``) brut dans ``.tab-detail``, le tout dans un
+    ``.drill-scope`` (unité maître/détail échangée par ``report.js``). ``("", [])``
+    si le mode n'a aucune section. Renvoie aussi les ancres pour le spine."""
+    detail_name = _DETAIL_OF_MODE.get(mode, "")
+    groups: list[tuple[str, str, list[str]]] = []
+    for m, key, fr, en, names in _GROUPS:
+        if m != mode:
+            continue
+        present = [n for n in names if n in by_name and n != detail_name]
+        if not present:
+            continue
+        label = escape(en if lang == "en" else fr)
+        groups.append((f"grp-{escape(key)}", label, present))
+    # Un seul groupe présent → son sous-titre (et un sommaire à un seul lien) font
+    # double emploi avec le nom du mode : on les omet, les sections s'écoulent
+    # directement. Plusieurs groupes → sous-titres ancrés + spine collant.
+    show_heads = len(groups) > 1
+    parts: list[str] = []
+    spine_links: list[tuple[str, str]] = []
+    for gid, label, present in groups:
+        if show_heads:
+            parts.append(f'<h2 class="tab-subhead" id="{gid}">{label}</h2>')
+            spine_links.append((gid, label))
+        parts.extend(_block(n, by_name[n], lang) for n in present)
+    detail_raw = by_name.get(detail_name, "") if detail_name else ""
+    if not parts and not detail_raw:
+        return "", []
+    master = f'<div class="tab-master">{"".join(parts)}</div>'
+    detail = (
+        f'<div class="tab-detail" data-mode="{escape(mode)}">{detail_raw}</div>'
+        if detail_raw
+        else ""
+    )
+    return f'<div class="drill-scope">{master}{detail}</div>', spine_links
+
+
+def _mode_layout(rendered: list[tuple[str, str]], lang: str) -> tuple[str, str]:
+    """Compose les sections en **2 modes** → ``(bascule, corps)``.
+
+    La **bascule** (réutilise ``.report-tabs`` → ancres ``#mode-*``) part dans le
+    chrome ; le **corps** (modes empilés) dans ``<main>``. Chaque mode porte un
+    spine collant + son maître/détail. Sans JS, les deux modes restent visibles
+    (rapport plat) ; ``report.js`` n'en montre qu'un. Sous 2 modes actifs, pas de
+    bascule. Sections hors mode (ex. ``methodology``) → **pied**, hors modes."""
+    by_name = dict(rendered)
+    mlabels = _MODE_LABELS.get(lang, _MODE_LABELS["fr"])
+    modes: list[tuple[str, str]] = []
+    for mode in _MODE_ORDER:
+        body, links = _mode_body(mode, by_name, lang)
+        if not body:
+            continue
+        section = (
+            f'<section class="mode" id="mode-{mode}" '
+            f'aria-label="{escape(mlabels[mode])}">'
+            f'{_spine(links, lang)}<div class="mode-body">{body}</div></section>'
+        )
+        modes.append((mode, section))
+    trailer = "".join(
+        _block(n, h, lang) for n, h in rendered if n not in _SECTION_MODE
+    )
+    corps = "".join(html for _m, html in modes) + trailer
+    if len(modes) < 2:
+        return "", corps
+    switch = "".join(
+        f'<a id="msw-{m}" class="report-tab{" on" if i == 0 else ""}" role="tab" '
+        f'href="#mode-{m}" aria-controls="mode-{m}" '
+        f'aria-selected="{"true" if i == 0 else "false"}">{escape(mlabels[m])}</a>'
+        for i, (m, _html) in enumerate(modes)
+    )
+    nav = (
+        f'<nav class="report-tabs mode-switch" role="tablist" '
+        f'aria-label="{escape(_MODE_SWITCH_LABEL.get(lang, _MODE_SWITCH_LABEL["fr"]))}'
+        f'">{switch}</nav>'
+    )
+    return nav, corps
+
+
+def _data_href(text: str, mime: str) -> str:
+    """``data:`` URI base64 d'un export — téléchargeable, hors-ligne, déterministe."""
+    payload = base64.b64encode(text.encode("utf-8")).decode("ascii")
+    return f"data:{mime};charset=utf-8;base64,{payload}"
+
+
+def _chrome_meta(result: RunResult, lang: str, *, glossary_btn: str = "") -> str:
+    """Méta de run (docs/moteurs/date) + actions (**Glossaire** · CSV · JSON).
+
+    Exports = ``<a download>`` vers des ``data:`` URI (zéro JS, autonome,
+    hors-ligne). Le JSON embarqué est le ``RunResult`` complet — la matière à
+    redonner à un outil tiers (cf. saveur « données » du cadre rapport).
+    ``glossary_btn`` (lien-ancre vers le dialog) précède les exports ; vide si
+    aucune métrique présente n'a d'entrée de glossaire."""
+    n_docs = result.manifest.n_documents
+    n_engines = len({p.pipeline for p in result.pipelines})
+    date = result.manifest.completed_at.date().isoformat()
+    docs_lbl = "docs"
+    eng_lbl = "engines" if lang == "en" else "moteurs"
+    csv_href = _data_href(run_result_csv(result), "text/csv")
+    json_href = _data_href(result.model_dump_json(), "application/json")
+    stem = escape(result.manifest.run_id)
+    return (
+        '<div class="chrome-meta">'
+        f'<span><span class="v">{n_docs}</span> {docs_lbl}</span>'
+        f'<span><span class="v">{n_engines}</span> {eng_lbl}</span>'
+        f'<span class="v">{escape(date)}</span>'
+        '<div class="chrome-actions">'
+        f"{glossary_btn}"
+        f'<a class="chrome-btn" download="{stem}.csv" href="{csv_href}">⬇ CSV</a>'
+        f'<a class="chrome-btn" download="{stem}.json" href="{json_href}">⬇ JSON</a>'
+        "</div></div>"
+    )
+
+
+class ReportRenderer:
+    """Assemble les sections applicables en un rapport HTML."""
+
+    def __init__(self, sections: tuple[Section, ...]) -> None:
+        self._sections = sections
+
+    def render(
+        self,
+        result: RunResult,
+        *,
+        title: str = "Cinoc — rapport",
+        lang: str = "fr",
+        images: Mapping[str, str] | None = None,
+        facsimiles: Mapping[str, str] | None = None,
+    ) -> str:
+        known = {
+            score.metric
+            for pipeline in result.pipelines
+            for score in pipeline.aggregate
+        }
+        ctx = SectionContext(
+            title=title,
+            lang=lang,
+            images=images or {},
+            facsimiles=facsimiles or {},
+        )
+        rendered: list[tuple[str, str]] = []
+        for section in self._sections:
+            if section.requires and not set(section.requires) <= known:
+                continue  # no-orphan : métriques requises absentes
+            html = section.render(result, ctx)
+            if html is not None:
+                rendered.append((section.name, html))
+        # 2 modes (Rapport/Explorer) : bascule (→ chrome) + corps (→ main).
+        # Sections rendues serveur ; ``report.js`` bascule l'affichage.
+        switch, body = _mode_layout(rendered, lang)
+        # Glossaire = périphérie (chrome) : dialog (vide si aucune métrique connue
+        # n'a d'entrée) + lien-ancre dans la barre d'actions.
+        gloss_dialog = glossary_dialog(known, lang)
+        gloss_link = glossary_chrome_link(lang) if gloss_dialog else ""
+        meta = _chrome_meta(result, lang, glossary_btn=gloss_link)
+        # Pied : widget « comparer un run » + dialog glossaire + script (onglets +
+        # dialog + nav clavier + palette). Tous client-side, déterministes, inlinés.
+        footer = Html(
+            compare_widget(result) + gloss_dialog + inline_script("report.js")
+        )
+        return render_document(
+            title, Html(body), footer=footer, lang=lang, tabs=switch, meta=meta
+        )
+
+
+def default_report_renderer() -> ReportRenderer:
+    """Socle : synthèse, overview, par-moteur/document, stats, économie,
+    diagnostic. Le glossaire est **hors sections** (dialog du chrome)."""
+    from cinoc.reports.sections.by_engine import EngineSection
+    from cinoc.reports.sections.calibration import CalibrationSection
+    from cinoc.reports.sections.conformity import ConformitySection
+    from cinoc.reports.sections.corpus_composition import CorpusCompositionSection
+    from cinoc.reports.sections.correction import CorrectionSection
+    from cinoc.reports.sections.cross_engine import CrossEngineSection
+    from cinoc.reports.sections.diagnostics import DiagnosticsSection
+    from cinoc.reports.sections.dispersion import DispersionSection
+    from cinoc.reports.sections.document_detail import DocumentDetailSection
+    from cinoc.reports.sections.documents import DocumentsSection
+    from cinoc.reports.sections.economics import EconomicsSection
+    from cinoc.reports.sections.engine_duel import EngineDuelSection
+    from cinoc.reports.sections.engine_profile import EngineProfileSection
+    from cinoc.reports.sections.engine_radar import EngineRadarSection
+    from cinoc.reports.sections.key_measures import KeyMeasuresSection
+    from cinoc.reports.sections.lines import LinesSection
+    from cinoc.reports.sections.methodology import MethodologySection
+    from cinoc.reports.sections.ner import NerSection
+    from cinoc.reports.sections.overview import OverviewSection
+    from cinoc.reports.sections.philology import PhilologySection
+    from cinoc.reports.sections.structure import StructureSection
+    from cinoc.reports.sections.structured_data import StructuredDataSection
+    from cinoc.reports.sections.taxonomy import TaxonomySection
+    from cinoc.reports.sections.textual_fidelity import TextualFidelitySection
+    from cinoc.reports.sections.word_errors import WordErrorsSection
+
+    return ReportRenderer(
+        (
+            KeyMeasuresSection(),
+            OverviewSection(),
+            CorpusCompositionSection(),
+            EngineSection(),
+            EngineRadarSection(),
+            EngineProfileSection(),
+            DispersionSection(),
+            DocumentsSection(),
+            DocumentDetailSection(),
+            CrossEngineSection(),
+            WordErrorsSection(),
+            EngineDuelSection(),
+            ConformitySection(),
+            StructureSection(),
+            CorrectionSection(),
+            StructuredDataSection(),
+            PhilologySection(),
+            TextualFidelitySection(),
+            LinesSection(),
+            NerSection(),
+            EconomicsSection(),
+            DiagnosticsSection(),
+            TaxonomySection(),
+            CalibrationSection(),
+            MethodologySection(),
+        )
+    )
+
+
+__all__ = ["ReportRenderer", "default_report_renderer"]
diff --git a/cinoc/reports/section.py b/cinoc/reports/section.py
new file mode 100644
index 0000000000000000000000000000000000000000..89036ffb773e75c284fa70d5e0c543a73e64f0b6
--- /dev/null
+++ b/cinoc/reports/section.py
@@ -0,0 +1,52 @@
+"""Contrat unique d'une **section** de rapport (couche 7).
+
+Une seule signature : ``render(RunResult, SectionContext) -> Html | None``. La
+section consomme le ``RunResult`` **directement** (pas de data-layer qui
+ré-agrège) et déclare ses ``requires`` (clés de métriques nécessaires) ; le
+renderer saute une section dont les besoins ne sont pas couverts (« no-orphan
+section↔métrique »). ``None`` = rien à afficher.
+
+``Html`` est un ``NewType`` sur ``str`` : il **signale du HTML déjà sûr** (les
+données utilisateur sont échappées à la construction) — la frontière anti-XSS.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from typing import NewType, Protocol, runtime_checkable
+
+from cinoc.evaluation.result import RunResult
+
+#: Fragment HTML déjà échappé / de confiance.
+Html = NewType("Html", str)
+
+
+@dataclass(frozen=True)
+class SectionContext:
+    """Contexte de rendu (extensible : langue, vignettes…)."""
+
+    title: str = "Cinoc"
+    lang: str = "fr"
+    #: ``{document_id: data-URI}`` des vignettes résolues (intrant de rendu,
+    #: calculé hors résultat ; vide → aperçu synthétique). Cf. `app.report_images`.
+    images: Mapping[str, str] = field(default_factory=dict)
+    #: ``{document_id: data-URI}`` des **fac-similés medium** (détail document) —
+    #: plus grands, plafond plus serré (intrant de rendu, hors résultat).
+    facsimiles: Mapping[str, str] = field(default_factory=dict)
+
+
+@runtime_checkable
+class Section(Protocol):
+    """Brique de rapport typée, qui lit un ``RunResult``."""
+
+    @property
+    def name(self) -> str: ...
+
+    @property
+    def requires(self) -> tuple[str, ...]: ...
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None: ...
+
+
+__all__ = ["Html", "Section", "SectionContext"]
diff --git a/cinoc/reports/sections/__init__.py b/cinoc/reports/sections/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b56514f33d363e61ee8eb19f20c3c0e9e9494ff4
--- /dev/null
+++ b/cinoc/reports/sections/__init__.py
@@ -0,0 +1,3 @@
+"""Sections de rapport (couche 7) — ajoutées au fil des métriques."""
+
+from __future__ import annotations
diff --git a/cinoc/reports/sections/_payload.py b/cinoc/reports/sections/_payload.py
new file mode 100644
index 0000000000000000000000000000000000000000..83d6b33e0485500959b6fcf86c0a655895286f91
--- /dev/null
+++ b/cinoc/reports/sections/_payload.py
@@ -0,0 +1,47 @@
+"""Squelette des sections « une famille de payload → des blocs par vue » (couche 7).
+
+~16 sections répétaient le **même** enchaînement de contrôle : détecter le
+multi-vues, construire un bloc par analyse du type de payload voulu (avec le
+préfixe de vue), renvoyer ``None`` si aucun, sinon un titre ``<h2>`` suivi des
+blocs. On mutualise ce **flux** (pas le HTML des blocs, propre à chaque section)
+→ sortie **identique** (les tests de section restent verts), boilerplate en moins.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TypeVar
+
+from cinoc.evaluation.result import RunResult
+from cinoc.reports.html import view_prefix
+from cinoc.reports.section import Html, SectionContext
+
+P = TypeVar("P")
+
+
+def render_payload_section(
+    result: RunResult,
+    ctx: SectionContext,
+    *,
+    payload_type: type[P],
+    title: str,
+    block: Callable[[str, P], str],
+) -> Html | None:
+    """Rend une section pilotée par un type de payload.
+
+    ``block(view_prefix, payload) -> html`` construit le bloc d'**une** analyse
+    (la section y referme ``lang``/ordre moteur/etc. par closure). ``view_prefix``
+    est vide en mono-vue, préfixé sinon. ``None`` si aucune analyse du type voulu.
+    """
+    multi = len({a.view for a in result.analyses}) > 1
+    blocks = [
+        block(view_prefix(a.view, ctx.lang, multi=multi), a.payload)
+        for a in result.analyses
+        if isinstance(a.payload, payload_type)
+    ]
+    if not blocks:
+        return None
+    return Html(f"<h2>{title}</h2>\n" + "".join(blocks))
+
+
+__all__ = ["render_payload_section"]
diff --git a/cinoc/reports/sections/_tables.py b/cinoc/reports/sections/_tables.py
new file mode 100644
index 0000000000000000000000000000000000000000..a371879f866c09dad1d83b57cc7ae16211b55a30
--- /dev/null
+++ b/cinoc/reports/sections/_tables.py
@@ -0,0 +1,223 @@
+"""Helpers de rendu **tabulaire** partagés par les sections (couche 7).
+
+Mutualise (DRY) ce dont ``overview`` et ``by_document`` ont besoin : ordre stable
+des vues, échelle de colonne et cellule **data-bar** dont la largeur est
+**relative au max de sa colonne** (comparaison intra-métrique). Tout est
+**déterministe** (division flottante IEEE-754 + ``round`` → même octet partout),
+donc le rapport reste octet-stable.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from cinoc.evaluation.result import MetricScore
+from cinoc.reports._numbers import localize_decimal
+from cinoc.reports.glossary import load_glossary
+from cinoc.reports.html import escape
+
+
+def ordered_unique(values: Iterable[str]) -> tuple[str, ...]:
+    """Valeurs distinctes dans leur **ordre de première apparition**."""
+    seen: list[str] = []
+    for value in values:
+        if value not in seen:
+            seen.append(value)
+    return tuple(seen)
+
+
+def format_value(score: MetricScore, lang: str) -> str:
+    """Valeur formatée (``None`` non applicable → tiret), séparateur décimal
+    localisé (virgule en français)."""
+    return "—" if score.value is None else localize_decimal(f"{score.value:.4f}", lang)
+
+
+def col_max(rows: list[tuple[MetricScore, ...]], index: int) -> float:
+    """Plus grande valeur (non ``None``) de la colonne → échelle des barres."""
+    values = [v for r in rows if (v := r[index].value) is not None]
+    return max(values) if values else 0.0
+
+
+#: Métriques **calculées mais masquées de l'affichage** (toujours dans le JSON).
+#: ``mer`` (Match Error Rate) : redondant avec ``wer`` (aucun signal nouveau).
+_HIDDEN_METRICS: frozenset[str] = frozenset({"mer"})
+
+
+def nonempty_metric_indices(rows: list[tuple[MetricScore, ...]]) -> list[int]:
+    """Indices de colonnes ayant **au moins une** valeur non ``None``, hors
+    métriques masquées (``_HIDDEN_METRICS``).
+
+    Une colonne tout-``None`` (métrique non applicable au corpus, ex. AIR/HCPR sur
+    de la presse) n'apporte que des « — » : on la **masque** pour désencombrer.
+    On distingue bien « tout None » (masqué) de « tout zéro » (gardé : c'est une
+    vraie valeur). Les métriques masquées d'affichage (``mer``) sont retirées des
+    colonnes — la donnée reste dans le ``RunResult``/JSON."""
+    if not rows:
+        return []
+    return [
+        i
+        for i in range(len(rows[0]))
+        if rows[0][i].metric not in _HIDDEN_METRICS
+        and any(r[i].value is not None for r in rows)
+    ]
+
+
+def bar_cell(
+    score: MetricScore, column_max: float, *, lang: str, sortable: bool = False
+) -> str:
+    """Cellule ``td.databar`` : **teinte de fond** ∝ position sur l'axe de la
+    colonne (échelle commune par colonne, façon canon) + valeur. Plus de barre
+    pleine : deux valeurs proches donnent une teinte proche — lecture honnête
+    (la barre normalisée saturait toute la cellule dès que les valeurs étaient
+    voisines).
+
+    ``sortable`` ajoute ``data-sort`` (valeur brute) → le tri client de
+    ``report.js`` réordonne le DOM par cette clé (aucune donnée reconstruite)."""
+    text = format_value(score, lang)
+    sort = (
+        f' data-sort="{score.value:.6f}"'
+        if sortable and score.value is not None
+        else ""
+    )
+    if score.value is None or column_max <= 0:
+        return f'<td class="databar"{sort}><span class="db-num">{text}</span></td>'
+    intensity = round(min(1.0, max(0.0, score.value / column_max)), 3)
+    return (
+        f'<td class="databar" style="--t:{intensity}"{sort}>'
+        f'<span class="db-num">{text}</span></td>'
+    )
+
+
+#: Groupes thématiques de métriques (ordre = ordre d'affichage canonique).
+#: ``(clé, (libellé FR, EN), {métriques})`` — calque « Par moteur » du design.
+_METRIC_GROUPS: tuple[tuple[str, tuple[str, str], frozenset[str]], ...] = (
+    ("char", ("Erreur · caractère", "Character error"),
+     frozenset({"cer", "cer_diplo", "cmer"})),
+    ("accuracy", ("Exactitude", "Accuracy"),
+     frozenset({"char_accuracy", "word_accuracy", "fca"})),
+    ("word", ("Erreur · mot", "Word error"),
+     frozenset({"wer", "mer", "wil"})),
+    ("search", ("Recherche · sac de mots", "Bag-of-words search"),
+     frozenset({"bow_precision", "bow_recall", "bow_f1"})),
+    ("philo", ("Philologique", "Philological"),
+     frozenset({"diacritic_err", "mufi_err"})),
+    ("trust", ("Fiabilité documentaire", "Document reliability"),
+     frozenset({"searchability", "hallucination", "air", "hcpr"})),
+    ("struct", ("Structuré", "Structured"),
+     frozenset({"numseq_strict", "numseq_value", "region_cer", "region_detection"})),
+)
+_GROUP_OF: dict[str, tuple[str, tuple[str, str]]] = {
+    metric: (key, label)
+    for key, label, members in _METRIC_GROUPS
+    for metric in members
+}
+
+
+def group_header_row(
+    metrics: list[str], lang: str, *, lead: int = 0, trail: int = 0
+) -> str:
+    """Rangée de **super-en-têtes** thématiques au-dessus des colonnes de métriques.
+
+    Fusionne les métriques **consécutives** d'un même groupe en une cellule
+    ``colspan`` (les profils sont déjà ordonnés par thème). ``lead``/``trail`` =
+    nombre de colonnes hors-métrique à gauche/droite (#, moteur, dispersion…) →
+    cellules vides de cadrage. Une métrique hors groupe connu → cellule vide."""
+    cells: list[str] = []
+    if lead:
+        cells.append(f'<th colspan="{lead}"></th>')
+    i = 0
+    while i < len(metrics):
+        entry = _GROUP_OF.get(metrics[i])
+        if entry is None:
+            cells.append("<th></th>")
+            i += 1
+            continue
+        key, label = entry
+        span = 1
+        while i + span < len(metrics):
+            nxt = _GROUP_OF.get(metrics[i + span])
+            if nxt is None or nxt[0] != key:
+                break
+            span += 1
+        text = label[1] if lang == "en" else label[0]
+        cells.append(
+            f'<th class="grp-head" colspan="{span}">{escape(text)}</th>'
+        )
+        i += span
+    if trail:
+        cells.append(f'<th colspan="{trail}"></th>')
+    return f'<tr class="grp-row">{"".join(cells)}</tr>'
+
+
+def bar_legend(lang: str) -> str:
+    """Légende de la **teinte** des cellules (position sur l'axe de la métrique).
+
+    Le canon teinte chaque cellule à **échelle commune par colonne** — sans
+    légende, le lecteur ne sait pas ce que code l'intensité."""
+    fr = (
+        '<p class="muted bar-legend">La teinte de chaque cellule indique sa '
+        "position sur l'axe de la métrique — échelle commune par colonne.</p>\n"
+    )
+    en = (
+        '<p class="muted bar-legend">Each cell\'s tint shows its position '
+        "on the metric's axis — common scale per column.</p>\n"
+    )
+    return en if lang == "en" else fr
+
+
+#: Libellés **courts** d'en-tête de colonne — le super-en-tête de groupe porte le
+#: contexte (« Recherche · sac de mots » → P/R/F1), le nom complet reste au survol
+#: (glossaire). Réduit fortement la largeur des colonnes (cf. L2-a). Métrique
+#: absente = clé brute (les noms déjà courts : cer/wer/mer/air…).
+_METRIC_SHORT: dict[str, str] = {
+    "cer_diplo": "cer·d",
+    "char_accuracy": "car.",
+    "word_accuracy": "mot",
+    "bow_precision": "P",
+    "bow_recall": "R",
+    "bow_f1": "F1",
+    "searchability": "rappel·ft",
+    "hallucination": "non-ancré",
+    "diacritic_err": "diacr.",
+    "mufi_err": "MUFI",
+    "region_cer": "CER rég.",
+    "region_detection": "F1 rég.",
+    "numseq_strict": "num·s",
+    "numseq_value": "num·v",
+}
+
+
+def metric_short_label(metric: str) -> str:
+    """Libellé court d'affichage d'une métrique (clé brute si non répertoriée)."""
+    return _METRIC_SHORT.get(metric, metric)
+
+
+def metric_th(metric: str, lang: str, *, sortable: bool = False) -> str:
+    """En-tête de colonne de métrique : libellé + **définition au survol** (E1,
+    depuis le glossaire) + **affordance de tri** (si ``sortable``).
+
+    Le tri est câblé client-side par ``report.js`` (réordonne des lignes déjà
+    rendues) ; sans JS, l'en-tête reste un libellé avec son ``title``."""
+    entry = load_glossary(lang).get(metric)
+    title = ""
+    if entry:
+        title = f"{entry.get('title', '')} — {entry.get('definition', '')}".strip(" —")
+    title_attr = f' title="{escape(title)}"' if title else ""
+    cls = "num-cell" + (" has-def" if title else "") + (" sortable" if sortable else "")
+    arrow = ' <span class="th-sort" aria-hidden="true">↕</span>' if sortable else ""
+    sort_attr = ' aria-sort="none"' if sortable else ""
+    label = escape(metric_short_label(metric))
+    return f'<th class="{cls}"{title_attr}{sort_attr}>{label}{arrow}</th>'
+
+
+__all__ = [
+    "bar_cell",
+    "bar_legend",
+    "col_max",
+    "format_value",
+    "group_header_row",
+    "metric_short_label",
+    "metric_th",
+    "nonempty_metric_indices",
+    "ordered_unique",
+]
diff --git a/cinoc/reports/sections/by_document.py b/cinoc/reports/sections/by_document.py
new file mode 100644
index 0000000000000000000000000000000000000000..71cce41d600d51d3729ff8dc04f65fecb88bfb2b
--- /dev/null
+++ b/cinoc/reports/sections/by_document.py
@@ -0,0 +1,96 @@
+"""Section by-document : le détail **par-document** de ``RunResult`` rendu en
+tables au design — une par vue, documents groupés, data-bars. Couche 7.
+
+Surface une donnée **réelle déjà calculée** (``RunResult.documents``) jusqu'ici
+**sans consommateur** dans le rapport ; aucune métrique inventée (note d'archi
+du design). Génériques : affiche les métriques par-doc présentes, quelles
+qu'elles soient.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+from cinoc.evaluation.result import RunDocumentResult, RunResult
+from cinoc.reports.engine_badges import engine_cell, engine_order
+from cinoc.reports.html import escape, localized, view_label
+from cinoc.reports.section import Html, SectionContext
+from cinoc.reports.sections._tables import (
+    bar_cell,
+    col_max,
+    nonempty_metric_indices,
+    ordered_unique,
+)
+
+
+class DocumentSection:
+    """Détail par-document : une table par vue (document × pipeline × métriques)."""
+
+    name = "by_document"
+    requires: tuple[str, ...] = ()  # générique ; absent si aucun détail par-doc
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        if not result.documents:
+            return None
+        # Ordre canonique des moteurs (badge stable) : première apparition dans
+        # le run ; repli sur l'ordre des documents si aucun agrégat.
+        order = engine_order(p.pipeline for p in result.pipelines) or engine_order(
+            d.pipeline for d in result.documents
+        )
+        # Titre de vue porté par le héros (renderer) ; ici, les tables par vue.
+        views = ordered_unique(d.view for d in result.documents)
+        multi = len(views) > 1
+        parts: list[str] = []
+        for view_name in views:
+            parts.append(
+                _table_for_view(
+                    result.documents, view_name, order, ctx.lang, multi=multi
+                )
+            )
+        return Html("\n".join(parts) + "\n")
+
+
+def _table_for_view(
+    documents: tuple[RunDocumentResult, ...],
+    view_name: str,
+    order: Mapping[str, int],
+    lang: str,
+    *,
+    multi: bool,
+) -> str:
+    rows = [d for d in documents if d.view == view_name]
+    keep = nonempty_metric_indices([d.scores for d in rows])  # masque tout-« — »
+    all_metrics = tuple(score.metric for score in rows[0].scores)
+    metrics = [all_metrics[i] for i in keep]
+    header = "".join(f'<th class="num-cell">{escape(m)}</th>' for m in metrics)
+    maxes = [col_max([d.scores for d in rows], i) for i in keep]
+    body: list[str] = []
+    for doc_id in ordered_unique(d.document_id for d in rows):
+        doc_rows = [d for d in rows if d.document_id == doc_id]
+        for offset, doc in enumerate(doc_rows):
+            label = escape(doc_id) if offset == 0 else ""  # groupé : nom 1×
+            cells = "".join(
+                bar_cell(doc.scores[i], maxes[j], lang=lang)
+                for j, i in enumerate(keep)
+            )
+            badge = engine_cell(doc.pipeline, order.get(doc.pipeline, 0))
+            body.append(
+                f'<tr><td class="eng-cell">{label}</td>'
+                f'<td class="eng-cell">{badge}</td>{cells}</tr>'
+            )
+    head = ""
+    if multi:  # libellé de vue seulement s'il y a plusieurs vues à distinguer
+        view_caption = localized(lang, "Vue", "View")
+        head = f"<h2>{view_caption} : {escape(view_label(view_name, lang))}</h2>\n"
+    # ``data-paginate`` : toutes les lignes restent présentes (rien retiré) ;
+    # ``report.js`` n'affiche qu'une page de lignes à la fois (+ pager). Sans JS,
+    # toute la table s'affiche (autonome, imprimable).
+    return (
+        f"{head}"
+        f'<table class="data" data-paginate="50">\n'
+        f"<thead><tr><th>Document</th><th>Pipeline</th>{header}</tr></thead>\n"
+        f"<tbody>{''.join(body)}</tbody>\n</table>"
+    )
+
+
+__all__ = ["DocumentSection"]
diff --git a/cinoc/reports/sections/by_engine.py b/cinoc/reports/sections/by_engine.py
new file mode 100644
index 0000000000000000000000000000000000000000..b74b9a070e5d8a9e605fcad05e360ba2193f84ef
--- /dev/null
+++ b/cinoc/reports/sections/by_engine.py
@@ -0,0 +1,141 @@
+"""Section by-engine : **comparaison** des moteurs sur la vue primaire +
+**dispersion** du taux d'erreur par-document. Couche 7.
+
+Distinct de l'overview (tables descriptives, une par vue) : ici **une** table de
+toutes les familles de métriques, **ordonnée** par CER croissant (un tri, pas un
+verdict — aucun rang ordinal n'est attribué), plus l'**étendue** (min · médiane ·
+max) du CER sur les documents, c.-à-d. la **fiabilité** que l'agrégat masque (et
+que ni l'overview ni le par-document ne donnent). On expose les chiffres ;
+l'utilisateur interprète (aucun gagnant déclaré — cf. ``key_measures`` §6/§12).
+"""
+
+from __future__ import annotations
+
+from statistics import median
+
+from cinoc.evaluation.result import PipelineResult, RunDocumentResult, RunResult
+from cinoc.reports._numbers import localize_decimal
+from cinoc.reports.engine_badges import engine_cell, engine_order
+from cinoc.reports.html import escape, localized, view_label
+from cinoc.reports.section import Html, SectionContext
+from cinoc.reports.sections._tables import (
+    bar_cell,
+    bar_legend,
+    col_max,
+    group_header_row,
+    metric_th,
+    nonempty_metric_indices,
+    ordered_unique,
+)
+
+
+def _per_doc_values(
+    documents: tuple[RunDocumentResult, ...], pipeline: str, view: str, metric: str
+) -> list[float]:
+    """Valeurs par-document (non ``None``) d'une métrique pour un moteur/vue."""
+    out: list[float] = []
+    for doc in documents:
+        if doc.pipeline == pipeline and doc.view == view:
+            for score in doc.scores:
+                if score.metric == metric and score.value is not None:
+                    out.append(score.value)
+    return out
+
+
+class EngineSection:
+    """Comparaison des moteurs (vue primaire) + dispersion par-document du CER."""
+
+    name = "by_engine"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        if not result.pipelines:
+            return None
+        view = ordered_unique(p.view for p in result.pipelines)[0]
+        rows = [p for p in result.pipelines if p.view == view]
+        metrics = tuple(s.metric for s in rows[0].aggregate)
+        if not metrics:
+            return None
+        sort_metric = "cer" if "cer" in metrics else metrics[0]
+        sort_idx = metrics.index(sort_metric)
+
+        def _key(p: PipelineResult) -> tuple[bool, float, str]:
+            value = p.aggregate[sort_idx].value
+            return (value is None, value if value is not None else 0.0, p.pipeline)
+
+        ordered = sorted(rows, key=_key)
+        # Badge moteur (lettre + accent) = identité STABLE, indépendante du rang :
+        # ordre canonique = première apparition dans le run (partagé entre sections).
+        order = engine_order(p.pipeline for p in result.pipelines)
+        keep = nonempty_metric_indices([p.aggregate for p in rows])  # masque tout-« — »
+        maxes = [col_max([p.aggregate for p in rows], i) for i in keep]
+        profil_title = localized(ctx.lang, "Profil", "Profile")
+        body: list[str] = []
+        # Lignes ordonnées par CER croissant (un **tri** lisible, pas un rang
+        # ordinal attribué : aucune colonne « # », aucun gagnant désigné).
+        for pipeline in ordered:
+            cells = "".join(
+                bar_cell(
+                    pipeline.aggregate[i], maxes[j], lang=ctx.lang, sortable=True
+                )
+                for j, i in enumerate(keep)
+            )
+            vals = _per_doc_values(
+                result.documents, pipeline.pipeline, view, sort_metric
+            )
+            disp = (
+                localize_decimal(
+                    f"{min(vals):.3f} · {median(vals):.3f} · {max(vals):.3f}",
+                    ctx.lang,
+                )
+                if vals
+                else "—"
+            )
+            idx = order.get(pipeline.pipeline, 0)
+            badge = engine_cell(pipeline.pipeline, idx)
+            # Le **nom du moteur** est le lien vers son profil drill-in (#engine-N) :
+            # cliquer le moteur ouvre son analyse détaillée (≠ une petite flèche).
+            body.append(
+                f'<tr><td class="eng-cell"><a href="#engine-{idx}" '
+                f'title="{profil_title}">{badge}</a></td>{cells}'
+                f'<td class="disp">{disp}</td></tr>'
+            )
+        display_metrics = [metrics[i] for i in keep]
+        header = "".join(
+            metric_th(m, ctx.lang, sortable=True) for m in display_metrics
+        )
+        # Suffixe de vue seulement si plusieurs vues à distinguer (sinon bruit).
+        multi = len(ordered_unique(p.view for p in result.pipelines)) > 1
+        vlbl = escape(view_label(view, ctx.lang))
+        heading = localized(
+            ctx.lang,
+            f"Comparaison des moteurs{f' (vue : {vlbl})' if multi else ''}",
+            f"Engine comparison{f' (view: {vlbl})' if multi else ''}",
+        )
+        prose = localized(
+            ctx.lang,
+            f'<p class="muted">Ordonné par {escape(sort_metric)} ↑ (un tri, pas un '
+            f"rang attribué) · dispersion = {escape(sort_metric)} min · médiane · "
+            "max par document. Cliquer un en-tête de métrique pour réordonner ; "
+            "survoler pour la définition. Aucun gagnant n'est déclaré.</p>\n",
+            f'<p class="muted">Ordered by {escape(sort_metric)} ↑ (a sort, not an '
+            f"assigned rank) · dispersion = {escape(sort_metric)} min · median · "
+            "max per document. Click a metric header to reorder; hover for the "
+            "definition. No winner is declared.</p>\n",
+        )
+        th_engine = localized(ctx.lang, "Moteur", "Engine")
+        th_dispersion = localized(ctx.lang, "dispersion", "dispersion")
+        return Html(
+            f"<h2>{heading}</h2>\n"
+            + prose
+            + '<div class="table-scroll"><table class="data sortable">\n'
+            "<thead>"
+            + group_header_row(display_metrics, ctx.lang, lead=1, trail=1)
+            + f"<tr><th>{th_engine}</th>{header}"
+            f'<th class="num-cell">{th_dispersion}</th></tr></thead>\n'
+            f"<tbody>{''.join(body)}</tbody>\n</table></div>\n"
+            + bar_legend(ctx.lang)
+        )
+
+
+__all__ = ["EngineSection"]
diff --git a/cinoc/reports/sections/calibration.py b/cinoc/reports/sections/calibration.py
new file mode 100644
index 0000000000000000000000000000000000000000..97d1eea9bd2841f3459589a76eda2bf1bc3a98fc
--- /dev/null
+++ b/cinoc/reports/sections/calibration.py
@@ -0,0 +1,96 @@
+"""Section calibration : fiabilité des confidences moteur (couche 7).
+
+Rend les payloads ``calibration`` en **lecture seule** : ECE/MCE par pipeline,
+**courbe de fiabilité SVG** (confiance vs exactitude) et table par bin.
+"""
+
+from __future__ import annotations
+
+from cinoc.evaluation.analysis import CalibrationPayload
+from cinoc.evaluation.result import RunResult
+from cinoc.reports._numbers import localize_decimal
+from cinoc.reports.engine_badges import engine_accent, engine_order
+from cinoc.reports.html import escape, localized
+from cinoc.reports.section import Html, SectionContext
+from cinoc.reports.sections._payload import render_payload_section
+from cinoc.reports.svg import calibration_curve
+
+
+def _block(
+    view: str, payload: CalibrationPayload, order: dict[str, int], lang: str
+) -> str:
+    head = localized(
+        lang,
+        f"{view}calibration des confidences",
+        f"{view}confidence calibration",
+    )
+    parts: list[str] = [f"<h3>{head}</h3>\n"]
+    parts.append(
+        localized(
+            lang,
+            '<p class="muted">Un moteur calibré a raison à hauteur de ce qu\'il '
+            "annonce : la courbe suit la diagonale. ECE = écart moyen pondéré "
+            "entre confiance et exactitude, MCE = écart maximal "
+            "(plus bas = mieux).</p>\n",
+            '<p class="muted">A calibrated engine is right as often as it '
+            "claims: the curve follows the diagonal. ECE = mean weighted gap "
+            "between confidence and accuracy, MCE = maximum gap "
+            "(lower = better).</p>\n",
+        )
+    )
+    tokens_word = localized(lang, "jetons", "tokens")
+    conf_axis = localized(lang, "confiance →", "confidence →")
+    th_bin = localized(lang, "bin", "bin")
+    th_mean_conf = localized(lang, "confiance moyenne", "mean confidence")
+    th_accuracy = localized(lang, "exactitude", "accuracy")
+    th_tokens = localized(lang, "jetons", "tokens")
+    for row in payload.pipelines:
+        bins = "".join(
+            f'<tr><td class="disp">'
+            f'{localize_decimal(f"[{b.lower:.1f} ; {b.upper:.1f}[", lang)}</td>'
+            f'<td class="disp">'
+            f'{localize_decimal(f"{b.mean_confidence:.3f}", lang)}</td>'
+            f'<td class="disp">{localize_decimal(f"{b.accuracy:.3f}", lang)}</td>'
+            f'<td class="disp">{b.count}</td></tr>'
+            for b in row.bins
+        )
+        curve = calibration_curve(
+            [(b.mean_confidence, b.accuracy) for b in row.bins],
+            accent=engine_accent(order.get(row.pipeline, 0)),
+        )
+        parts.append(
+            f"<h4>{escape(row.pipeline)} — "
+            f'ECE {localize_decimal(f"{row.ece:.4f}", lang)} · '
+            f'MCE {localize_decimal(f"{row.mce:.4f}", lang)} · '
+            f"{row.n_tokens} {tokens_word}</h4>\n"
+            '<div class="calib-block">'
+            f'<div class="calib-plot">{curve}'
+            f'<div class="calib-axis mono">{conf_axis}</div></div>'
+            f'<table class="data">\n<thead><tr><th>{th_bin}</th>'
+            f'<th class="num-cell">{th_mean_conf}</th>'
+            f'<th class="num-cell">{th_accuracy}</th>'
+            f'<th class="num-cell">{th_tokens}</th></tr></thead>\n'
+            f"<tbody>{bins}</tbody>\n</table></div>\n"
+        )
+    return "".join(parts)
+
+
+class CalibrationSection:
+    """ECE/MCE + bins de fiabilité, par pipeline produisant des confidences."""
+
+    name = "calibration"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        # Ordre canonique des moteurs (accent stable, partagé avec les sections).
+        order = engine_order(p.pipeline for p in result.pipelines)
+        return render_payload_section(
+            result,
+            ctx,
+            payload_type=CalibrationPayload,
+            title=localized(ctx.lang, "Calibration", "Calibration"),
+            block=lambda view, payload: _block(view, payload, order, ctx.lang),
+        )
+
+
+__all__ = ["CalibrationSection"]
diff --git a/cinoc/reports/sections/conformity.py b/cinoc/reports/sections/conformity.py
new file mode 100644
index 0000000000000000000000000000000000000000..ad57bcbdc1bbc241fe98be3ac55aaee347375008
--- /dev/null
+++ b/cinoc/reports/sections/conformity.py
@@ -0,0 +1,132 @@
+"""Section conformité HIPE : scores du scorer officiel + deltas (couche 7).
+
+Rend le payload ``hipe`` en **lecture seule** : par pipeline, cMER/wMER
+micro+macro (noms du scorer HIPE-OCRepair — la frontière de nommage, le
+registre garde ``cmer``/``mer``), deltas de normalisation entre vues et
+documents manquants. Chaque nombre porte son profil (SPEC_HIPE §7.2).
+"""
+
+from __future__ import annotations
+
+from cinoc.evaluation.analysis import ConformityPayload, PipelineConformity
+from cinoc.evaluation.result import RunResult
+from cinoc.reports._numbers import localize_decimal
+from cinoc.reports.engine_badges import engine_cell, engine_order
+from cinoc.reports.html import escape, localized, view_label
+from cinoc.reports.section import Html, SectionContext
+
+
+def _cell(value: float | None, lang: str, *, signed: bool = False) -> str:
+    if value is None:
+        return '<td class="disp muted">—</td>'
+    raw = f"{value:+.4f}" if signed else f"{value:.4f}"
+    return f'<td class="disp">{localize_decimal(raw, lang)}</td>'
+
+
+def _block(payload: ConformityPayload, lang: str, order: dict[str, int]) -> str:
+    # Deltas de normalisation = uniquement quand une vraie ancre HIPE + vues
+    # brute/heritage existent ; sinon on montre cMER/wMER micro·macro seuls.
+    has_deltas = payload.raw_view is not None or payload.heritage_view is not None
+    view = escape(view_label(payload.hipe_view, lang))
+
+    def _row(row: PipelineConformity) -> str:
+        deltas = (
+            _cell(row.delta_norm, lang, signed=True)
+            + _cell(row.delta_heritage, lang, signed=True)
+            if has_deltas
+            else ""
+        )
+        return (
+            f'<tr><td class="eng-cell">'
+            f"{engine_cell(row.pipeline, order.get(row.pipeline, 0))}</td>"
+            + _cell(row.cmer_micro, lang) + _cell(row.cmer_macro, lang)
+            + _cell(row.wmer_micro, lang) + _cell(row.wmer_macro, lang)
+            + deltas
+            + f'<td class="disp">{row.n_missing}</td></tr>'
+        )
+
+    rows = "".join(_row(row) for row in payload.pipelines)
+    if has_deltas:
+        raw = escape(payload.raw_view) if payload.raw_view else "—"
+        heritage = escape(payload.heritage_view) if payload.heritage_view else "—"
+        head = localized(
+            lang,
+            f"{view} — scores HIPE-OCRepair",
+            f"{view} — HIPE-OCRepair scores",
+        )
+        prose = localized(
+            lang,
+            '<p class="muted">cMER/wMER = Match Error Rate (borné [0, 1] — '
+            "comparable même pour un modèle génératif qui rallonge le texte). "
+            f"Δ norm = cmer({raw}) − cmer({view}) : part d'erreur imputable à "
+            f"casse/ponctuation/formes mappées ; Δ heritage = cmer({heritage}) − "
+            f"cmer({view}) : mappings patrimoniaux seuls (œ/æ/ß/ꝛ…). "
+            "« manquants » = documents sans sortie scorée.</p>\n",
+            '<p class="muted">cMER/wMER = Match Error Rate (bounded [0, 1] — '
+            "comparable even for a generative model). "
+            f"Δ norm = cmer({raw}) − cmer({view}); Δ heritage = cmer({heritage}) − "
+            f"cmer({view}). \"missing\" = documents with no scored output.</p>\n",
+        )
+        delta_th = (
+            '<th class="num-cell">Δ norm</th><th class="num-cell">Δ heritage</th>'
+        )
+    else:
+        head = f"{view} — cMER · wMER (micro · macro)"
+        prose = localized(
+            lang,
+            '<p class="muted">cMER/wMER = Match Error Rate <b>borné [0, 1]</b> '
+            "(comparable même pour un modèle génératif qui rallonge le texte, là "
+            "où le CER peut dépasser 100 %). <b>micro</b> = agrégat corpus "
+            "(Σ erreurs / Σ dénominateurs) ; <b>macro</b> = moyenne des taux "
+            "par document. « manquants » = documents sans sortie scorée.</p>\n",
+            '<p class="muted">cMER/wMER = Match Error Rate <b>bounded [0, 1]</b> '
+            "(comparable even for a generative model, where CER can exceed 100%). "
+            "<b>micro</b> = corpus aggregate (Σ errors / Σ denominators); "
+            "<b>macro</b> = mean of per-document rates. \"missing\" = documents "
+            "with no scored output.</p>\n",
+        )
+        delta_th = ""
+    th_pipeline = localized(lang, "Pipeline", "Pipeline")
+    th_missing = localized(lang, "manquants", "missing")
+    return (
+        f"<h3>{head}</h3>\n"
+        f"{prose}"
+        f'<table class="data">\n<thead><tr><th>{th_pipeline}</th>'
+        '<th class="num-cell">cmer_micro</th><th class="num-cell">cmer_macro</th>'
+        '<th class="num-cell">wmer_micro</th><th class="num-cell">wmer_macro</th>'
+        f"{delta_th}"
+        f'<th class="num-cell">{th_missing}</th></tr></thead>\n'
+        f"<tbody>{rows}</tbody>\n</table>\n"
+    )
+
+
+class ConformitySection:
+    """Scores HIPE officiels (cmer/wmer micro+macro) + deltas de normalisation."""
+
+    name = "conformity"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        order = engine_order(p.pipeline for p in result.pipelines)
+        blocks = [
+            _block(analysis.payload, ctx.lang, order)
+            for analysis in result.analyses
+            if isinstance(analysis.payload, ConformityPayload)
+        ]
+        if not blocks:
+            return None
+        is_hipe = any(
+            isinstance(a.payload, ConformityPayload)
+            and (a.payload.raw_view is not None or a.payload.heritage_view is not None)
+            for a in result.analyses
+        )
+        title = (
+            localized(ctx.lang, "Conformité HIPE", "HIPE conformity")
+            if is_hipe
+            else localized(ctx.lang, "Précision bornée (cMER · wMER)",
+                           "Bounded accuracy (cMER · wMER)")
+        )
+        return Html(f"<h2>{title}</h2>\n" + "".join(blocks))
+
+
+__all__ = ["ConformitySection"]
diff --git a/cinoc/reports/sections/corpus_composition.py b/cinoc/reports/sections/corpus_composition.py
new file mode 100644
index 0000000000000000000000000000000000000000..badd8d0f1051cbf87c8489c59bb1ca26e44ec770
--- /dev/null
+++ b/cinoc/reports/sections/corpus_composition.py
@@ -0,0 +1,70 @@
+"""Section composition du corpus : répartition par **strate** (couche 7).
+
+Rendue **seulement si** le corpus porte des strates (``RunDocumentResult.stratum``,
+projeté de ``DocumentRef.metadata["stratum"]``) — sinon ``None`` (pas de fausse
+carte, pas de strate inventée). Une ligne par strate : nom, effectif, part + barre
+proportionnelle. Server-side, déterministe, zéro JS.
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+
+from cinoc.evaluation.result import RunResult
+from cinoc.reports.html import escape, localized
+from cinoc.reports.section import Html, SectionContext
+from cinoc.reports.sections._tables import ordered_unique
+
+
+def _strata_by_doc(result: RunResult, view: str) -> dict[str, str]:
+    """``document_id -> strate`` (1ʳᵉ occurrence) pour les docs qui en portent une."""
+    out: dict[str, str] = {}
+    for d in result.documents:
+        if d.view == view and d.stratum and d.document_id not in out:
+            out[d.document_id] = d.stratum
+    return out
+
+
+class CorpusCompositionSection:
+    """Répartition des documents par strate (effectif + part), si présentes."""
+
+    name = "corpus_composition"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        if not result.documents:
+            return None
+        view = ordered_unique(d.view for d in result.documents)[0]
+        strata = _strata_by_doc(result, view)
+        if not strata:
+            return None  # aucune strate → pas de carte (jamais de strate inventée)
+        counts = Counter(strata.values())
+        total = sum(counts.values())
+        # Ordre déterministe : effectif décroissant puis nom.
+        ordered = sorted(counts.items(), key=lambda kv: (-kv[1], kv[0]))
+        rows = "".join(
+            f'<div class="strata-row"><div class="strata-head">'
+            f'<span class="strata-name">{escape(name)}</span>'
+            f'<span class="chip">n = {n}</span></div>'
+            f'<div class="track"><i '
+            f'style="width:{round(n / total * 100)}%;background:var(--fern);'
+            f'opacity:0.55"></i></div>'
+            f'<span class="strata-pct">{n / total:.0%}</span></div>'
+            for name, n in ordered
+        )
+        title = localized(ctx.lang, "Composition du corpus", "Corpus composition")
+        caption = localized(
+            ctx.lang,
+            f"{len(ordered)} strates · {total} documents "
+            "(répartition figée à la création du run).",
+            f"{len(ordered)} strata · {total} documents "
+            "(distribution fixed at run creation).",
+        )
+        return Html(
+            f"<h2>{title}</h2>\n"
+            f'<p class="muted">{caption}</p>\n'
+            f'<div class="strata-grid">{rows}</div>\n'
+        )
+
+
+__all__ = ["CorpusCompositionSection"]
diff --git a/cinoc/reports/sections/correction.py b/cinoc/reports/sections/correction.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e1926ec95fbfb50e3c6db8b012b942f7a18fe5a
--- /dev/null
+++ b/cinoc/reports/sections/correction.py
@@ -0,0 +1,247 @@
+"""Section bilan de correction : que vaut l'étage LLM ? (couche 7)
+
+Rend le payload ``correction`` en **lecture seule** : triplet de
+non-régression, pcis, ampleur d'intervention, absorption, sur-normalisation,
+pires régressions. Tous les seuils affichés viennent du payload (auditable).
+"""
+
+from __future__ import annotations
+
+from cinoc.evaluation.analysis import CorrectionPayload, PipelineCorrection
+from cinoc.evaluation.result import RunResult
+from cinoc.reports._numbers import localize_decimal
+from cinoc.reports.html import escape, localized
+from cinoc.reports.section import Html, SectionContext
+from cinoc.reports.sections._payload import render_payload_section
+
+
+def _pct(value: float | None, lang: str) -> str:
+    return "—" if value is None else localize_decimal(f"{value:.1%}", lang)
+
+
+def _num(value: float | None, lang: str, *, signed: bool = False) -> str:
+    if value is None:
+        return "—"
+    raw = f"{value:+.4f}" if signed else f"{value:.4f}"
+    return localize_decimal(raw, lang)
+
+
+def _row(label: str, *cells: str) -> str:
+    body = "".join(f'<td class="disp">{cell}</td>' for cell in cells)
+    return f'<tr><td class="eng-cell">{escape(label)}</td>{body}</tr>'
+
+
+def _pipeline_block(
+    row: PipelineCorrection, payload: CorrectionPayload, lang: str
+) -> str:
+    missing = (
+        localized(
+            lang,
+            f" · R-1.8 : {row.n_missing_raw} brut(s) / {row.n_missing_corrected} "
+            f"corrigé(s) matérialisés vides",
+            f" · R-1.8: {row.n_missing_raw} raw / {row.n_missing_corrected} "
+            f"corrected materialized empty",
+        )
+        if row.n_missing_raw or row.n_missing_corrected
+        else ""
+    )
+    cata = localize_decimal(f"{payload.catastrophic_threshold:g}", lang)
+    over = localize_decimal(f"{payload.overedit_threshold:g}", lang)
+    ins = localize_decimal(f"{payload.insertion_threshold:g}", lang)
+    rows = [
+        _row(
+            localized(
+                lang,
+                "Triplet (amélioration / régression / égalité)",
+                "Triplet (improvement / regression / no change)",
+            ),
+            _pct(row.improvement_rate, lang),
+            _pct(row.regression_rate, lang),
+            _pct(row.no_change_rate, lang),
+        ),
+        _row(
+            localized(
+                lang,
+                f"pref · catastrophiques (Δ > {cata})",
+                f"pref · catastrophic (Δ > {cata})",
+            ),
+            _num(row.pref_score, lang, signed=True),
+            f"{row.n_catastrophic} ({_pct(row.catastrophic_rate, lang)})",
+            "",
+        ),
+        _row(
+            localized(
+                lang,
+                "pcis (macro · médiane · |pcis| > 1)",
+                "pcis (macro · median · |pcis| > 1)",
+            ),
+            _num(row.pcis_macro, lang, signed=True),
+            _num(row.pcis_median, lang, signed=True),
+            str(row.n_pcis_extreme),
+        ),
+        _row(
+            localized(
+                lang,
+                f"Intervention (CCR · ratio · sur-édités > "
+                f"{over})",
+                f"Intervention (CCR · ratio · over-edited > "
+                f"{over})",
+            ),
+            _num(row.ccr, lang),
+            _num(row.change_ratio, lang),
+            str(row.n_overedited),
+        ),
+        _row(
+            localized(
+                lang,
+                f"Insertions (part · lourds > {ins} "
+                f"· longueur)",
+                f"Insertions (share · heavy > {ins} "
+                f"· length)",
+            ),
+            _num(row.char_ins_ratio, lang),
+            str(row.n_hallucination_heavy),
+            _num(row.length_ratio, lang),
+        ),
+        _row(
+            localized(
+                lang,
+                "Absorption (corrigées · introduites · net)",
+                "Absorption (corrected · introduced · net)",
+            ),
+            str(row.corrected),
+            str(row.introduced),
+            f"{row.net_improvement:+d}",
+        ),
+        _row(
+            localized(
+                lang,
+                "Sur-normalisation (mots OCR-justes dégradés)",
+                "Over-normalization (OCR-correct words degraded)",
+            ),
+            f"{row.n_over_normalized}/{row.n_correct_ocr_words}",
+            _num(row.over_normalization, lang),
+            "",
+        ),
+        _row(
+            localized(
+                lang,
+                f"Éditions consécutives (médiane · max · part > "
+                f"{payload.edit_run_threshold})",
+                f"Consecutive edits (median · max · share > "
+                f"{payload.edit_run_threshold})",
+            ),
+            _num(row.edit_run_median, lang),
+            str(row.edit_run_max),
+            _num(row.edit_run_share, lang),
+        ),
+    ]
+    documents_label = localized(
+        lang,
+        f"{row.n_documents} documents",
+        f"{row.n_documents} documents",
+    )
+    parts = [
+        f"<h4>{escape(row.pipeline)} — {documents_label}{missing}</h4>\n"
+        '<table class="data">\n<tbody>' + "".join(rows) + "</tbody>\n</table>\n"
+    ]
+    if row.worst_regressions:
+        regression_rows = "".join(
+            f'<tr><td class="eng-cell">{escape(sample.document_id)}</td>'
+            f'<td class="disp">'
+            f'{localize_decimal(f"{sample.cmer_raw:.4f}", lang)}</td>'
+            f'<td class="disp">'
+            f'{localize_decimal(f"{sample.cmer_corrected:.4f}", lang)}</td>'
+            f'<td class="disp">'
+            f'{localize_decimal(f"{sample.delta:+.4f}", lang)}</td></tr>'
+            for sample in row.worst_regressions
+        )
+        worst_summary = localized(
+            lang,
+            f"Pires régressions ({len(row.worst_regressions)})",
+            f"Worst regressions ({len(row.worst_regressions)})",
+        )
+        th_document = localized(lang, "document", "document")
+        th_cmer_raw = localized(lang, "cmer brut", "cmer raw")
+        th_cmer_corrected = localized(lang, "cmer corrigé", "cmer corrected")
+        parts.append(
+            f'<details><summary class="muted">{worst_summary}</summary>'
+            f'<table class="data">\n<thead><tr><th>{th_document}</th>'
+            f'<th class="num-cell">{th_cmer_raw}</th>'
+            f'<th class="num-cell">{th_cmer_corrected}</th>'
+            '<th class="num-cell">Δ</th></tr></thead>\n'
+            f"<tbody>{regression_rows}</tbody>\n</table></details>\n"
+        )
+    if row.over_normalized_samples:
+        # #16 : flux mot OCR-juste → forme du correcteur (« ∅ » = supprimé).
+        flows = "".join(
+            f'<div class="wf-row">'
+            f'<span class="wf-word wf-src">{escape(s.reference)}</span>'
+            f'<span class="wf-arrow">→</span>'
+            f'<span class="wf-word">{escape(s.corrected)}</span>'
+            f'<span class="wf-meta">{escape(s.document_id)}</span></div>'
+            for s in row.over_normalized_samples
+        )
+        over_summary = localized(
+            lang,
+            f"Mots sur-normalisés ({len(row.over_normalized_samples)} exemples "
+            f"— mot OCR-juste → forme du correcteur)",
+            f"Over-normalized words ({len(row.over_normalized_samples)} examples "
+            f"— OCR-correct word → corrector's form)",
+        )
+        parts.append(
+            f'<details><summary class="muted">{over_summary}</summary>\n'
+            f'<div class="wflow">{flows}</div></details>\n'
+        )
+    return "".join(parts)
+
+
+def _block(view: str, payload: CorrectionPayload, lang: str) -> str:
+    head = localized(
+        lang,
+        f"{view}bilan de correction",
+        f"{view}correction balance",
+    )
+    prose = localized(
+        lang,
+        '<p class="muted">Pipelines 2 étages (OCR → correcteur) : le triplet '
+        "compte les documents améliorés/dégradés (jamais le pref seul) ; CCR "
+        "mesure combien le correcteur a touché, indépendamment de la justesse "
+        "(à qualité égale, un CCR plus faible = intervention plus parcimonieuse) ; "
+        "l'absorption "
+        "compte les mots corrigés vs introduits ; les longues séquences "
+        "d'éditions signalent une réécriture de passage. Étage absent = "
+        "matérialisé vide (erreur maximale), jamais exclu en silence.</p>\n",
+        '<p class="muted">2-stage pipelines (OCR → corrector): the triplet '
+        "counts improved/degraded documents (never pref alone); CCR "
+        "measures how much the corrector touched, regardless of correctness "
+        "(at equal quality, a lower CCR = more parsimonious intervention); "
+        "absorption "
+        "counts corrected vs introduced words; long edit runs "
+        "signal a passage rewrite. Missing stage = "
+        "materialized empty (maximal error), never silently excluded.</p>\n",
+    )
+    return (
+        f"<h3>{head}</h3>\n"
+        + prose
+        + "".join(_pipeline_block(row, payload, lang) for row in payload.pipelines)
+    )
+
+
+class CorrectionSection:
+    """Bilan de l'étage de correction, par pipeline 2 étages."""
+
+    name = "correction"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        return render_payload_section(
+            result,
+            ctx,
+            payload_type=CorrectionPayload,
+            title=localized(ctx.lang, "Bilan de correction", "Correction balance"),
+            block=lambda view, payload: _block(view, payload, ctx.lang),
+        )
+
+
+__all__ = ["CorrectionSection"]
diff --git a/cinoc/reports/sections/cross_engine.py b/cinoc/reports/sections/cross_engine.py
new file mode 100644
index 0000000000000000000000000000000000000000..16de98414a7935a68cbcdc38eb9168de5ad062e5
--- /dev/null
+++ b/cinoc/reports/sections/cross_engine.py
@@ -0,0 +1,395 @@
+"""Section significativité inter-moteurs : rend ``RunResult.cross_engine`` au design.
+
+Pour chaque ``vue:métrique``, la p-value d'une différence entre pipelines
+(Wilcoxon / Friedman) + un **verdict factuel** (significatif si p < 0,05). Le
+verdict est une **fonction auditable** de la p-value — une étiquette, pas de la
+prose (narratif supprimé, ``CLAUDE.md`` §6). ``None`` si inapplicable (aucun
+résultat inter-moteurs, ou sous le plancher de puissance).
+
+Sous le tableau des p-values, la section **lit** (sans recalculer) les payloads
+``inference`` de ``RunResult.analyses`` : rangs moyens, distance critique de
+Nemenyi (correction multi-comparaisons), groupes statistiquement
+indiscernables, et IC bootstrap à 95 % par pipeline. Puis les payloads
+``inter_engine`` : complémentarité oracle (borne **supérieure** bag-of-words,
+documentée comme telle — anti-surinterprétation) et divergence Jensen-Shannon
+des profils d'erreurs.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+from cinoc.evaluation.analysis import (
+    InferencePayload,
+    InterEngineComplementarity,
+    InterEngineDivergence,
+    InterEnginePayload,
+)
+from cinoc.evaluation.result import RunResult
+from cinoc.reports._numbers import localize_decimal
+from cinoc.reports.engine_badges import engine_cell, engine_order
+from cinoc.reports.html import escape, localized, view_label, view_prefix
+from cinoc.reports.section import Html, SectionContext
+
+
+def _format_p(value: float | None, lang: str) -> str:
+    return "—" if value is None else localize_decimal(f"{value:.4f}", lang)
+
+
+def _split_key(key: str) -> tuple[str, str]:
+    """``"text:cer:significance_p"`` → ``("text", "cer")`` ; sinon (clé, "")."""
+    parts = key.split(":")
+    if len(parts) >= 2:
+        return parts[0], parts[1]
+    return key, ""
+
+
+def _verdict(value: float | None, lang: str) -> tuple[str, str]:
+    """(libellé, classe CSS) — significatif si p < 0,05 ; ``None`` → tiret."""
+    if value is None:
+        return "—", ""
+    if value < 0.05:
+        return localized(lang, "significatif", "significant"), " sig"
+    return localized(lang, "non sig.", "not sig."), ""
+
+
+def _inference_block(
+    view: str, payload: InferencePayload, order: Mapping[str, int], lang: str
+) -> str:
+    """Rendu d'un payload ``inference`` : rangs, Nemenyi, IC bootstrap."""
+    rows: list[str] = []
+    intervals = {item.pipeline: item for item in payload.intervals}
+    for rank in payload.mean_ranks:
+        interval = intervals.get(rank.pipeline)
+        ic = (
+            localize_decimal(
+                f"[{interval.lower:.4f} ; {interval.upper:.4f}]", lang
+            )
+            if interval is not None
+            else "—"
+        )
+        mean = (
+            localize_decimal(f"{interval.mean:.4f}", lang)
+            if interval is not None
+            else "—"
+        )
+        badge = engine_cell(rank.pipeline, order.get(rank.pipeline, 0))
+        rows.append(
+            f'<tr><td class="eng-cell">{badge}</td>'
+            f'<td class="disp">{localize_decimal(f"{rank.mean_rank:.3f}", lang)}</td>'
+            f'<td class="disp">{mean}</td>'
+            f'<td class="disp">{ic}</td></tr>'
+        )
+    if payload.critical_distance is not None:
+        groups = " · ".join(
+            "{" + ", ".join(escape(name) for name in group) + "}"
+            for group in payload.tied_groups
+        )
+        extrapolated = localized(
+            lang, " (q extrapolé)" if payload.q_alpha_extrapolated else "",
+            " (q extrapolated)" if payload.q_alpha_extrapolated else "",
+        )
+        alpha = localize_decimal(f"{payload.alpha:g}", lang)
+        cd = localize_decimal(f"{payload.critical_distance:.4f}", lang)
+        nemenyi = localized(
+            lang,
+            f'<p class="muted">Nemenyi (α={alpha}) : distance '
+            f"critique CD = {cd}{extrapolated} ; "
+            f"groupes indiscernables : {groups}.</p>\n",
+            f'<p class="muted">Nemenyi (α={alpha}): critical '
+            f"distance CD = {cd}{extrapolated} ; "
+            f"indistinguishable groups: {groups}.</p>\n",
+        )
+    else:
+        nemenyi = localized(
+            lang,
+            '<p class="muted">2 pipelines : le verdict apparié est la p-value '
+            "Wilcoxon ci-dessus (pas de post-hoc).</p>\n",
+            '<p class="muted">2 pipelines: the paired verdict is the Wilcoxon '
+            "p-value above (no post-hoc).</p>\n",
+        )
+    head = localized(
+        lang,
+        f"<h3>{view}{escape(payload.metric)} — rangs &amp; IC "
+        f"(n={payload.n_documents})</h3>\n",
+        f"<h3>{view}{escape(payload.metric)} — ranks &amp; CI "
+        f"(n={payload.n_documents})</h3>\n",
+    )
+    th_pipeline = localized(lang, "Pipeline", "Pipeline")
+    th_mean_rank = localized(lang, "rang moyen", "mean rank")
+    th_mean = localized(lang, "moyenne", "mean")
+    th_ci = localized(lang, "IC 95 % (bootstrap)", "95% CI (bootstrap)")
+    return (
+        head
+        + nemenyi
+        + '<table class="data">\n'
+        f"<thead><tr><th>{th_pipeline}</th>"
+        f'<th class="num-cell">{th_mean_rank}</th>'
+        f'<th class="num-cell">{th_mean}</th>'
+        f'<th class="num-cell">{th_ci}</th></tr></thead>\n'
+        f"<tbody>{''.join(rows)}</tbody>\n</table>\n"
+    )
+
+
+def _complementarity_block(
+    view: str, comp: InterEngineComplementarity, order: Mapping[str, int], lang: str
+) -> str:
+    """Rendu du bloc complémentarité : rappel par moteur seul vs oracle."""
+    rows: list[str] = []
+    for item in comp.per_engine_recall:
+        badge = engine_cell(item.pipeline, order.get(item.pipeline, 0))
+        best = localized(
+            lang,
+            " (meilleur seul)" if item.pipeline == comp.best_engine else "",
+            " (best single)" if item.pipeline == comp.best_engine else "",
+        )
+        rows.append(
+            f'<tr><td class="eng-cell">{badge}{best}</td>'
+            f'<td class="disp">{localize_decimal(f"{item.recall:.1%}", lang)}</td></tr>'
+        )
+    oracle_recall = localize_decimal(f"{comp.oracle_recall:.1%}", lang)
+    rows.append(
+        localized(
+            lang,
+            f'<tr><td class="eng-cell">oracle (union des '
+            f"{len(comp.per_engine_recall)} moteurs)</td>"
+            f'<td class="disp">{oracle_recall}</td></tr>',
+            f'<tr><td class="eng-cell">oracle (union of '
+            f"{len(comp.per_engine_recall)} engines)</td>"
+            f'<td class="disp">{oracle_recall}</td></tr>',
+        )
+    )
+    gap_documents = [d for d in comp.per_document if d.absolute_gap > 0]
+    documents = ""
+    if gap_documents:
+        document_rows = "".join(
+            f'<tr><td class="eng-cell">{escape(d.document_id)}</td>'
+            f'<td class="disp">{localize_decimal(f"{d.oracle_recall:.1%}", lang)}</td>'
+            f'<td class="disp">'
+            f'{localize_decimal(f"{d.best_single_recall:.1%}", lang)}</td>'
+            f'<td class="disp">{localize_decimal(f"{d.absolute_gap:.1%}", lang)}</td>'
+            "</tr>"
+            for d in gap_documents
+        )
+        doc_prose = localized(
+            lang,
+            '<p class="muted">Documents au plus fort écart oracle − meilleur '
+            "(échantillon borné) :</p>\n",
+            '<p class="muted">Documents with the largest oracle − best gap '
+            "(bounded sample):</p>\n",
+        )
+        th_document = localized(lang, "Document", "Document")
+        th_oracle = localized(lang, "oracle", "oracle")
+        th_best_single = localized(lang, "meilleur seul", "best single")
+        th_gap = localized(lang, "écart", "gap")
+        documents = (
+            doc_prose
+            + '<table class="data">\n<thead><tr><th>'
+            f"{th_document}</th>"
+            f'<th class="num-cell">{th_oracle}</th>'
+            f'<th class="num-cell">{th_best_single}</th>'
+            f'<th class="num-cell">{th_gap}</th></tr></thead>\n'
+            f"<tbody>{document_rows}</tbody>\n</table>\n"
+        )
+    head = localized(
+        lang,
+        f"<h3>{view}complémentarité des moteurs "
+        f"(oracle, n={comp.n_documents} documents)</h3>\n",
+        f"<h3>{view}engine complementarity "
+        f"(oracle, n={comp.n_documents} documents)</h3>\n",
+    )
+    prose = localized(
+        lang,
+        '<p class="muted">Rappel des tokens de la GT (multiset) par moteur '
+        "seul, contre l'<strong>oracle</strong> : l'union des moteurs où "
+        "chaque token est rattrapé par le meilleur moteur sur ce token. "
+        "<strong>Borne supérieure</strong> optimiste, en sac de mots — "
+        "l'<strong>ordre est ignoré</strong> ; un vote séquentiel réel ferait "
+        "au mieux autant, en général moins. À lire comme un plafond de gain "
+        "d'ensemble, pas une prédiction.</p>\n",
+        '<p class="muted">Recall of GT tokens (multiset) per single '
+        "engine, against the <strong>oracle</strong>: the union of engines where "
+        "each token is recovered by the best engine on that token. "
+        "<strong>Upper bound</strong>, optimistic, bag-of-words — "
+        "<strong>order is ignored</strong>; a real sequential vote would do "
+        "at best as well, generally less. Read it as a ceiling of ensemble gain, "
+        "not a prediction.</p>\n",
+    )
+    th_pipeline = localized(lang, "Pipeline", "Pipeline")
+    th_token_recall = localized(lang, "rappel tokens", "token recall")
+    abs_gap = localize_decimal(f"{comp.absolute_gap:.1%}", lang)
+    rel_gap = localize_decimal(f"{comp.relative_gap:.1%}", lang)
+    gap_prose = localized(
+        lang,
+        f'<p class="muted">Écart absolu oracle − meilleur '
+        f"({escape(comp.best_engine)}) : {abs_gap} ; écart "
+        f"relatif : {rel_gap} des erreurs du meilleur moteur "
+        "théoriquement rattrapables par un ensemble.</p>\n",
+        f'<p class="muted">Absolute oracle − best gap '
+        f"({escape(comp.best_engine)}): {abs_gap} ; relative "
+        f"gap: {rel_gap} of the best engine's errors "
+        "theoretically recoverable by an ensemble.</p>\n",
+    )
+    return (
+        head
+        + prose
+        + '<table class="data">\n<thead><tr><th>'
+        f"{th_pipeline}</th>"
+        f'<th class="num-cell">{th_token_recall}</th></tr></thead>\n'
+        f"<tbody>{''.join(rows)}</tbody>\n</table>\n"
+        + gap_prose
+        + documents
+    )
+
+
+def _divergence_block(
+    view: str, divergence: InterEngineDivergence, order: Mapping[str, int], lang: str
+) -> str:
+    """Rendu du bloc divergence : JS paire-à-paire sur les profils d'erreurs."""
+    rows = "".join(
+        f'<tr><td class="eng-cell">'
+        f"{engine_cell(pair.a, order.get(pair.a, 0))} · "
+        f"{engine_cell(pair.b, order.get(pair.b, 0))}</td>"
+        f'<td class="disp">{localize_decimal(f"{pair.divergence:.4f}", lang)}</td></tr>'
+        for pair in divergence.pairs
+    )
+    if divergence.max_pair is not None:
+        max_div = localize_decimal(f"{divergence.max_pair.divergence:.4f}", lang)
+        max_pair = localized(
+            lang,
+            f'<p class="muted">Paire la plus divergente : '
+            f"{escape(divergence.max_pair.a)} · {escape(divergence.max_pair.b)} "
+            f"({max_div} bit).</p>\n",
+            f'<p class="muted">Most divergent pair: '
+            f"{escape(divergence.max_pair.a)} · {escape(divergence.max_pair.b)} "
+            f"({max_div} bit).</p>\n",
+        )
+    else:
+        max_pair = localized(
+            lang,
+            '<p class="muted">Profils d\'erreurs identiques : aucune paire '
+            "divergente.</p>\n",
+            '<p class="muted">Identical error profiles: no divergent '
+            "pair.</p>\n",
+        )
+    head = localized(
+        lang,
+        f"<h3>{view}divergence des profils d'erreurs "
+        "(Jensen-Shannon)</h3>\n",
+        f"<h3>{view}divergence of error profiles "
+        "(Jensen-Shannon)</h3>\n",
+    )
+    prose = localized(
+        lang,
+        '<p class="muted">Divergence JS en bits ([0 ; 1]) entre les '
+        "distributions de classes d'erreurs (taxonomie) des moteurs : 0 = "
+        "mêmes natures d'erreurs, 1 = profils disjoints. Une paire divergente "
+        "se trompe différemment — candidate naturelle à un ensemble.</p>\n",
+        '<p class="muted">JS divergence in bits ([0 ; 1]) between the '
+        "error-class distributions (taxonomy) of the engines: 0 = "
+        "same kinds of errors, 1 = disjoint profiles. A divergent pair "
+        "errs differently — a natural candidate for an ensemble.</p>\n",
+    )
+    th_pair = localized(lang, "Paire", "Pair")
+    return (
+        head
+        + prose
+        + '<table class="data">\n<thead><tr><th>'
+        f"{th_pair}</th>"
+        '<th class="num-cell">JS (bits)</th></tr></thead>\n'
+        f"<tbody>{rows}</tbody>\n</table>\n"
+        + max_pair
+    )
+
+
+def _inter_engine_blocks(
+    result: RunResult, order: Mapping[str, int], lang: str
+) -> str:
+    """Blocs complémentarité + divergence de chaque payload ``inter_engine``."""
+    multi = len({a.view for a in result.analyses}) > 1
+    blocks: list[str] = []
+    for analysis in result.analyses:
+        payload = analysis.payload
+        if not isinstance(payload, InterEnginePayload):
+            continue
+        label = view_prefix(analysis.view, lang, multi=multi)
+        if payload.complementarity is not None:
+            blocks.append(
+                _complementarity_block(
+                    label, payload.complementarity, order, lang
+                )
+            )
+        if payload.taxonomy_divergence is not None:
+            blocks.append(
+                _divergence_block(
+                    label, payload.taxonomy_divergence, order, lang
+                )
+            )
+    return "".join(blocks)
+
+
+class CrossEngineSection:
+    """P-values de différence inter-moteurs (Wilcoxon / Friedman) + verdict."""
+
+    name = "cross_engine"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        lang = ctx.lang
+        order = engine_order(p.pipeline for p in result.pipelines)
+        inter_engine = _inter_engine_blocks(result, order, lang)
+        if not result.cross_engine and not inter_engine:
+            return None
+        significance = ""
+        if result.cross_engine:
+            body: list[str] = []
+            for score in result.cross_engine:
+                view, metric = _split_key(score.metric)
+                label, css = _verdict(score.value, lang)
+                body.append(
+                    f'<tr><td class="eng-cell">{escape(view_label(view, lang))}</td>'
+                    f'<td class="eng-cell">{escape(metric)}</td>'
+                    f'<td class="disp">{_format_p(score.value, lang)}</td>'
+                    f'<td class="disp">{score.support}</td>'
+                    f'<td class="verdict{css}">{label}</td></tr>'
+                )
+            prose = localized(
+                lang,
+                '<p class="muted">p-value d\'une différence entre pipelines '
+                "(Wilcoxon / Friedman) ; significatif si p &lt; 0,05.</p>\n",
+                '<p class="muted">p-value of a difference between pipelines '
+                "(Wilcoxon / Friedman); significant if p &lt; 0,05.</p>\n",
+            )
+            th_view = localized(lang, "Vue", "View")
+            th_metric = localized(lang, "Métrique", "Metric")
+            th_verdict = localized(lang, "verdict", "verdict")
+            significance = (
+                prose
+                + '<table class="data">\n'
+                f"<thead><tr><th>{th_view}</th><th>{th_metric}</th>"
+                '<th class="num-cell">p-value</th><th class="num-cell">n</th>'
+                f"<th>{th_verdict}</th></tr></thead>\n"
+                f"<tbody>{''.join(body)}</tbody>\n</table>\n"
+            )
+        # Préfixe « <vue> · » devant la métrique, seulement si plusieurs vues.
+        multi = len({a.view for a in result.analyses}) > 1
+        blocks = "".join(
+            _inference_block(
+                f"{escape(view_label(analysis.view, lang))} · " if multi else "",
+                analysis.payload, order, lang,
+            )
+            for analysis in result.analyses
+            if isinstance(analysis.payload, InferencePayload)
+        )
+        title = localized(
+            lang, "Significativité inter-moteurs", "Inter-engine significance"
+        )
+        return Html(
+            f"<h2>{title}</h2>\n"
+            + significance
+            + blocks
+            + inter_engine
+        )
+
+
+__all__ = ["CrossEngineSection"]
diff --git a/cinoc/reports/sections/diagnostics.py b/cinoc/reports/sections/diagnostics.py
new file mode 100644
index 0000000000000000000000000000000000000000..83871d8662c2124db15cd2b4b56d5e5985a26369
--- /dev/null
+++ b/cinoc/reports/sections/diagnostics.py
@@ -0,0 +1,159 @@
+"""Section diagnostic : confusions, pires lignes, documents difficiles (couche 7).
+
+Rend les payloads ``diagnostics`` de ``RunResult.analyses`` en **lecture
+seule** : « voir où ça casse », texte à l'appui. Les extraits sont verbatim du
+``RunResult`` (chargés et normalisés au scoring) — aucun recalcul au rendu. Les
+confusions sont mises en **flux de glyphes** (#8) : le glyphe attendu → produit,
+prominents, barre de fréquence — « voir les symboles » et leur direction.
+"""
+
+from __future__ import annotations
+
+from cinoc.evaluation.analysis import CharConfusion, DiagnosticsPayload, WorstLine
+from cinoc.evaluation.result import RunResult
+from cinoc.reports._numbers import localize_decimal
+from cinoc.reports.engine_badges import engine_cell, engine_order
+from cinoc.reports.html import escape, view_prefix
+from cinoc.reports.section import Html, SectionContext
+from cinoc.reports.text_diff import char_diff
+
+#: Libellés bilingues du **flux de confusion** (#8). Le reste de la section,
+#: antérieur à la consigne FR/EN des graphiques, reste FR (i18n rapport = jalon).
+_CONFUSION_TEXT: dict[str, dict[str, str]] = {
+    "fr": {
+        "title": "Confusions de caractères récurrentes (attendu → produit)",
+        "intro": (
+            "Le glyphe attendu (vérité-terrain) → le glyphe produit par le "
+            "moteur ; la barre indique la fréquence. La <strong>direction</strong> "
+            "compte : « ſ → f » (long s lu f) n'est pas « f → ſ »."
+        ),
+    },
+    "en": {
+        "title": "Recurring character confusions (expected → produced)",
+        "intro": (
+            "The expected glyph (ground truth) → the glyph the engine produced; "
+            "the bar shows frequency. <strong>Direction</strong> matters: "
+            "“ſ → f” (long s read as f) is not “f → ſ”."
+        ),
+    },
+}
+
+
+def _confusion_chip(pair: CharConfusion, max_count: int) -> str:
+    """Une paire de confusion : glyphes attendu → produit + barre de fréquence."""
+    width = round(pair.count / max_count * 48)
+    return (
+        '<div class="cf-pair">'
+        f'<span class="cf-glyph">{escape(pair.expected)}</span>'
+        '<span class="cf-arrow">→</span>'
+        f'<span class="cf-glyph">{escape(pair.observed)}</span>'
+        f'<span class="cf-bar" style="width:{width}px"></span>'
+        f'<span class="cf-count">{pair.count}</span></div>'
+    )
+
+
+def _confusion_flow(
+    payload: DiagnosticsPayload, lang: str, order: dict[str, int]
+) -> str:
+    """Flux de confusion (#8) : par moteur, glyphes attendu → produit + fréquence.
+
+    Les glyphes sont **prominents** (le symbole *est* la donnée — on juge à l'œil) ;
+    la barre est proportionnelle au compte (pairs déjà triées -count). Verbatim,
+    échappés (anti-XSS) ; le slot bordé rend une espace confondue **visible**."""
+    groups: list[str] = []
+    for block in payload.confusions:
+        if not block.pairs:
+            continue
+        max_count = block.pairs[0].count  # pairs triées -count → pairs[0] = max
+        chips = "".join(_confusion_chip(pair, max_count) for pair in block.pairs)
+        badge = engine_cell(block.pipeline, order.get(block.pipeline, 0))
+        groups.append(
+            f'<div class="cf-engine"><span class="cf-eng-name">{badge}</span>'
+            f'<div class="cf-grid">{chips}</div></div>'
+        )
+    if not groups:
+        return ""
+    text = _CONFUSION_TEXT.get(lang, _CONFUSION_TEXT["fr"])
+    return (
+        f"<h4>{text['title']}</h4>\n"
+        f'<p class="muted">{text["intro"]}</p>\n' + "".join(groups)
+    )
+
+
+def _worst_lines_row(line: WorstLine, lang: str) -> str:
+    # Drill-in : GT vs hypothèse surlignées caractère à caractère (écarts visibles).
+    ref_html, hyp_html = char_diff(line.reference, line.hypothesis)
+    return (
+        f'<tr><td class="eng-cell">{escape(line.pipeline)}</td>'
+        f'<td class="eng-cell">{escape(line.document_id)}</td>'
+        f'<td class="disp">{line.line_index}</td>'
+        f'<td class="disp">{localize_decimal(f"{line.cer:.4f}", lang)}</td>'
+        f'<td class="diff">{ref_html}</td>'
+        f'<td class="diff">{hyp_html}</td></tr>'
+    )
+
+
+def _worst_lines_table(payload: DiagnosticsPayload, lang: str) -> str:
+    if not payload.worst_lines:
+        return ""
+    rows = "".join(_worst_lines_row(line, lang) for line in payload.worst_lines)
+    return (
+        "<h4>Pires lignes du corpus — diff GT ↔ hypothèse</h4>\n"
+        '<p class="muted">Surlignage : '
+        '<del class="d-del">supprimé</del> (présent en GT) · '
+        '<ins class="d-ins">inséré</ins> (produit par le moteur).</p>\n'
+        '<table class="data">\n<thead><tr><th>Pipeline</th><th>Document</th>'
+        '<th class="num-cell">ligne</th><th class="num-cell">CER</th>'
+        "<th>référence (GT)</th><th>hypothèse</th></tr></thead>\n"
+        f"<tbody>{rows}</tbody>\n</table>\n"
+    )
+
+
+def _hardest_table(payload: DiagnosticsPayload, lang: str) -> str:
+    if not payload.hardest_documents:
+        return ""
+    rows = "".join(
+        f'<tr><td class="eng-cell">{escape(doc.document_id)}</td>'
+        f'<td class="disp">{localize_decimal(f"{doc.mean_cer:.4f}", lang)}</td>'
+        f'<td class="disp">{doc.n_pipelines}</td></tr>'
+        for doc in payload.hardest_documents
+    )
+    return (
+        "<h4>Documents les plus difficiles</h4>\n"
+        '<table class="data">\n<thead><tr><th>Document</th>'
+        f'<th class="num-cell">{escape(payload.metric)} moyen</th>'
+        '<th class="num-cell">pipelines scorés</th></tr></thead>\n'
+        f"<tbody>{rows}</tbody>\n</table>\n"
+    )
+
+
+class DiagnosticsSection:
+    """Diagnostic d'erreurs : confusions, pires lignes, documents difficiles."""
+
+    name = "diagnostics"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        order = engine_order(p.pipeline for p in result.pipelines)
+        multi = len({a.view for a in result.analyses}) > 1
+        blocks: list[str] = []
+        for analysis in result.analyses:
+            payload = analysis.payload
+            if not isinstance(payload, DiagnosticsPayload):
+                continue
+            inner = (
+                _confusion_flow(payload, ctx.lang, order)
+                + _worst_lines_table(payload, ctx.lang)
+                + _hardest_table(payload, ctx.lang)
+            )
+            if inner:
+                blocks.append(
+                    f"<h3>{view_prefix(analysis.view, ctx.lang, multi=multi)}"
+                    "où ça casse</h3>\n" + inner
+                )
+        if not blocks:
+            return None
+        return Html("<h2>Diagnostic d'erreurs</h2>\n" + "".join(blocks))
+
+
+__all__ = ["DiagnosticsSection"]
diff --git a/cinoc/reports/sections/dispersion.py b/cinoc/reports/sections/dispersion.py
new file mode 100644
index 0000000000000000000000000000000000000000..c30664ecfea9014bdd010f09928a5f9c326156ff
--- /dev/null
+++ b/cinoc/reports/sections/dispersion.py
@@ -0,0 +1,114 @@
+"""Section dispersion : étendue du CER par moteur, en **bandes SVG** (couche 7).
+
+Visualise ce que ``by_engine`` montre en texte (min · médiane · max par document)
+sous forme graphique — la **fiabilité** que l'agrégat masque. Échelle commune
+entre moteurs (max global) → comparaison directe. Server-side, déterministe,
+zéro JS. Donnée : ``RunResult.documents`` (CER par document, déjà calculé).
+"""
+
+from __future__ import annotations
+
+from statistics import fmean, median, quantiles
+
+from cinoc.evaluation.result import RunDocumentResult, RunResult
+from cinoc.reports._numbers import fmt_pct
+from cinoc.reports.engine_badges import engine_accent, engine_letter, engine_order
+from cinoc.reports.html import escape, localized, view_label
+from cinoc.reports.section import Html, SectionContext
+from cinoc.reports.sections._tables import ordered_unique
+from cinoc.reports.svg import box_plot
+
+_METRIC = "cer"
+
+
+def _per_doc_cer(
+    documents: tuple[RunDocumentResult, ...], pipeline: str, view: str
+) -> list[float]:
+    return [
+        score.value
+        for doc in documents
+        if doc.pipeline == pipeline and doc.view == view
+        for score in doc.scores
+        if score.metric == _METRIC and score.value is not None
+    ]
+
+
+def _pct(v: float, lang: str) -> str:
+    return fmt_pct(v, lang)
+
+
+class DispersionSection:
+    """Boîtes à moustaches du CER par moteur (Q1·médiane·µ·Q3, échelle commune)."""
+
+    name = "dispersion"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        if not result.documents:
+            return None
+        views = ordered_unique(d.view for d in result.documents)
+        view = views[0]
+        multi = len(views) > 1
+        order = engine_order(p.pipeline for p in result.pipelines) or engine_order(
+            d.pipeline for d in result.documents
+        )
+        # (pipeline, valeurs) dans l'ordre canonique des badges.
+        series: list[tuple[str, list[float]]] = []
+        for pipeline in sorted(order, key=lambda p: order[p]):
+            vals = _per_doc_cer(result.documents, pipeline, view)
+            if vals:
+                series.append((pipeline, vals))
+        if not series:
+            return None
+        scale_max = max(max(v) for _, v in series)
+        lang = ctx.lang
+        rows = "".join(self._row(p, v, order[p], scale_max, lang) for p, v in series)
+        vlbl = escape(view_label(view, lang))
+        title = localized(
+            lang,
+            f"Dispersion du CER{f' (vue : {vlbl})' if multi else ''}",
+            f"CER dispersion{f' (view: {vlbl})' if multi else ''}",
+        )
+        intro = localized(
+            lang,
+            '<p class="muted">Boîte à moustaches par moteur : moustaches min→max, '
+            "boîte interquartile Q1→Q3, trait médian, tick moyenne. Échelle "
+            "commune entre moteurs.</p>\n",
+            '<p class="muted">Box plot per engine: whiskers min→max, interquartile '
+            "box Q1→Q3, median line, mean tick. Common scale across engines.</p>\n",
+        )
+        return Html(
+            f"<h2>{title}</h2>\n"
+            f"{intro}"
+            f'<div class="disp-grid">{rows}</div>\n'
+        )
+
+    @staticmethod
+    def _row(
+        pipeline: str, vals: list[float], index: int, scale_max: float, lang: str
+    ) -> str:
+        lo, hi = min(vals), max(vals)
+        med, mean = median(vals), fmean(vals)
+        # Quartiles : ``quantiles`` exige ≥2 points ; sinon boîte plate sur la valeur.
+        if len(vals) >= 2:
+            q1, _q2, q3 = quantiles(vals, n=4)
+        else:
+            q1 = q3 = med
+        accent = engine_accent(index)
+        plot = box_plot(lo, q1, med, q3, hi, mean, scale_max, accent=accent)
+        med_label = localized(lang, "méd", "med")
+        return (
+            '<div class="disp-row">'
+            f'<div class="disp-head"><span class="eng-badge" style="--badge:{accent}">'
+            f"{engine_letter(index)}</span>"
+            f'<span class="disp-name">{escape(pipeline)}</span></div>'
+            f"{plot}"
+            '<div class="disp-labels mono">'
+            f"min {_pct(lo, lang)} · Q1 {_pct(q1, lang)} · "
+            f"{med_label} {_pct(med, lang)} · "
+            f"µ {_pct(mean, lang)} · Q3 {_pct(q3, lang)} · max {_pct(hi, lang)}"
+            "</div></div>"
+        )
+
+
+__all__ = ["DispersionSection"]
diff --git a/cinoc/reports/sections/document_detail.py b/cinoc/reports/sections/document_detail.py
new file mode 100644
index 0000000000000000000000000000000000000000..36a2cd453cc0fdc5c716009496349cbbcb99434e
--- /dev/null
+++ b/cinoc/reports/sections/document_detail.py
@@ -0,0 +1,453 @@
+"""Section détail document : panneaux **drill-in** par document (couche 7).
+
+Révélé au clic d'une carte de galerie (ancre ``#doc-<idx>``). Affiche ce que la
+donnée porte **réellement** : CER par moteur pour ce document + le **diff
+caractère des pires lignes** de ce document (si présentes dans l'échantillon
+``diagnostics``). Le fac-similé réel et le diff plein-texte arrivent avec les
+tranches images (références dans ``RunResult``). Mécanique partagée avec le
+profil moteur (``.drill-panel`` + ``report.js``) ; sans JS, ``:target``.
+"""
+
+from __future__ import annotations
+
+from cinoc.evaluation.analysis import (
+    DiagnosticsPayload,
+    DocumentHallucination,
+    DocumentHallucinationPayload,
+    DocumentLines,
+    DocumentLinesPayload,
+    DocumentTexts,
+    DocumentTextsPayload,
+    WorstLine,
+)
+from cinoc.evaluation.lines import gini, percentile
+from cinoc.evaluation.result import RunResult
+from cinoc.reports._numbers import fmt_pct, localize_decimal
+from cinoc.reports.engine_badges import engine_accent, engine_letter, engine_order
+from cinoc.reports.html import escape, localized
+from cinoc.reports.section import Html, SectionContext
+from cinoc.reports.sections._tables import ordered_unique
+from cinoc.reports.text_diff import char_diff
+
+_METRIC = "cer"
+
+
+def _doc_lines(result: RunResult, doc_id: str) -> DocumentLines | None:
+    """CER par ligne **de ce document** (scope corpus), ``None`` si non applicable."""
+    for analysis in result.analyses:
+        payload = analysis.payload
+        if isinstance(payload, DocumentLinesPayload):
+            for row in payload.documents:
+                if row.document_id == doc_id:
+                    return row
+    return None
+
+
+def _cer_bucket(value: float) -> str:
+    """Palier de couleur d'une ligne : g(<5%) · m(<15%) · o(<30%) · b(≥30%)."""
+    if value < 0.05:
+        return "g"
+    if value < 0.15:
+        return "m"
+    if value < 0.30:
+        return "o"
+    return "b"
+
+
+_PCTS = (("p50", 50.0), ("p75", 75.0), ("p90", 90.0), ("p95", 95.0), ("p99", 99.0))
+
+
+def _line_distribution(dl: DocumentLines, order: dict[str, int], lang: str) -> str:
+    """Distribution des erreurs **par ligne** du document, par moteur.
+
+    Trois lectures complémentaires, dérivées des CER de ligne (fonctions pures
+    partagées ``percentile``/``gini``) : (1) **carte thermique de position** (une
+    barre = une ligne, gauche→droite = haut→bas, hauteur ∝ CER) → *où* ; (2)
+    **percentiles CER** (p50→p99) → *l'étalement* (un p50 bas + p99 haut = quelques
+    lignes catastrophiques que le CER moyen masque) ; (3) **badges** (CER moyen,
+    Gini de concentration, n lignes, % de lignes au-dessus de seuils). Lecture seule."""
+    start = localized(lang, "début", "start")
+    end = localized(lang, "fin", "end")
+    heat_l = localized(lang, "carte thermique (position)", "heatmap (position)")
+    pct_l = localized(lang, "percentiles CER", "CER percentiles")
+    lines_l = localized(lang, "lignes", "lines")
+    rows = ""
+    for pipeline, cers in dl.pipelines:
+        idx = order.get(pipeline, 0)
+        n = len(cers)
+        ordered = sorted(cers)
+        mean_cer = sum(cers) / n
+        chips = (
+            f'<span class="chip">CER {fmt_pct(mean_cer, lang)}</span>'
+            f'<span class="chip">Gini '
+            f'{localize_decimal(f"{gini(cers):.2f}", lang)}</span>'
+            f'<span class="chip">{n} {lines_l}</span>'
+        )
+        for thr in (0.30, 0.50, 1.0):
+            rate = sum(1 for c in cers if c >= thr) / n
+            chips += (
+                f'<span class="chip">{rate * 100:.0f} % {lines_l} '
+                f"CER≥{thr * 100:.0f} %</span>"
+            )
+        bars = "".join(
+            f'<i class="dd-lh-bar lh-{_cer_bucket(c)}" '
+            f'style="height:{4 + round(36 * min(c, 1.0))}px" '
+            f'title="ligne {i + 1} · CER {c * 100:.0f} %"></i>'
+            for i, c in enumerate(cers)
+        )
+        pcts = "".join(
+            f'<div class="dd-pct-row"><span class="dd-pct-lbl">{label}</span>'
+            f'<span class="track"><i class="lh-{_cer_bucket(v)}" '
+            f'style="width:{min(100.0, v * 100):.0f}%"></i></span>'
+            f'<span class="dd-pct-val">{fmt_pct(v, lang)}</span></div>'
+            for label, v in (
+                (lbl, percentile(ordered, q)) for lbl, q in _PCTS
+            )
+        )
+        rows += (
+            '<div class="dd-ld-row"><div class="dd-ld-head"><span class="eng-badge" '
+            f'style="--badge:{engine_accent(idx)}">{engine_letter(idx)}</span>'
+            f'<span class="dd-name">{escape(pipeline)}</span>{chips}</div>'
+            '<div class="dd-ld-grid"><div class="dd-ld-cell">'
+            f'<div class="dd-ld-sub">{heat_l}</div>'
+            f'<div class="dd-lh-bars">{bars}</div>'
+            f'<div class="dd-lh-axis"><span>{start}</span><span>{end}</span></div>'
+            '</div><div class="dd-ld-cell">'
+            f'<div class="dd-ld-sub">{pct_l}</div>{pcts}</div></div></div>'
+        )
+    title = localized(
+        lang, "Distribution des erreurs par ligne", "Per-line error distribution"
+    )
+    return (
+        f'<div class="dd-lh"><div class="drill-caption">{title}</div>'
+        f'<div class="dd-ld-rows">{rows}</div></div>'
+    )
+
+
+def _doc_hallucination(
+    result: RunResult, doc_id: str
+) -> DocumentHallucination | None:
+    """Analyse d'hallucination **de ce document** (scope corpus), ``None`` si absent."""
+    for analysis in result.analyses:
+        payload = analysis.payload
+        if isinstance(payload, DocumentHallucinationPayload):
+            for row in payload.documents:
+                if row.document_id == doc_id:
+                    return row
+    return None
+
+
+def _hallucination_block(
+    dh: DocumentHallucination, order: dict[str, int], lang: str
+) -> str:
+    """Analyse d'hallucination du document : par moteur, indicateurs + blocs inventés.
+
+    Le plus parlant quand un moteur **invente** du texte (mauvaise langue, VLM/LLM) :
+    ancrage faible / insertion nette élevée + les **blocs hallucinés affichés**.
+    Lecture seule du payload (aucun recalcul)."""
+    # Pas de verdict « hallucination » (qui prête une intention au modèle) : on
+    # nomme le **fait mesuré** — du texte inséré sans contrepartie dans le GT — et
+    # on **montre les blocs** en preuve (le critère est sous les yeux).
+    title = localized(
+        lang,
+        "Texte inséré sans appui dans le GT",
+        "Inserted text unsupported by GT",
+    )
+    flag = localized(
+        lang, "⚠ bloc inséré sans appui GT", "⚠ inserted block unsupported by GT"
+    )
+    anchor_l = localized(lang, "Ancrage", "Anchoring")
+    ratio_l = localized(lang, "Ratio longueur", "Length ratio")
+    netins_l = localized(lang, "Insertion nette", "Net insertion")
+    words_l = localized(lang, "mots GT / sortie", "GT / output words")
+    blocks_l = localized(
+        lang, "Blocs sans ancrage dans le GT", "Blocks unanchored in GT"
+    )
+    rows = ""
+    for ph in dh.pipelines:
+        idx = order.get(ph.pipeline, 0)
+        badge = (
+            f'<span class="eng-badge" style="--badge:{engine_accent(idx)}">'
+            f"{engine_letter(idx)}</span>"
+        )
+        chips = (
+            f'<span class="chip">{anchor_l} {ph.anchor_score * 100:.0f} %</span>'
+            f'<span class="chip">{ratio_l} '
+            f'{localize_decimal(f"{ph.length_ratio:.2f}", lang)}</span>'
+            f'<span class="chip">{netins_l} {ph.net_insertion_rate * 100:.0f} %'
+            "</span>"
+            f'<span class="chip">{ph.gt_words} / {ph.hyp_words} {words_l}</span>'
+        )
+        warn = f'<span class="dd-hl-flag">{flag}</span>' if ph.is_hallucinating else ""
+        blocks = ""
+        if ph.blocks:
+            items = "".join(
+                f'<div class="dd-hl-block"><span class="muted">'
+                f"mots {b.start_token}–{b.end_token}</span> {escape(b.text)}</div>"
+                for b in ph.blocks
+            )
+            blocks = (
+                f'<div class="dd-hl-blocks"><div class="muted">{blocks_l} :</div>'
+                f"{items}</div>"
+            )
+        rows += (
+            f'<div class="dd-hl-row"><div class="dd-hl-head">{badge}'
+            f'<span class="dd-name">{escape(ph.pipeline)}</span>{warn}</div>'
+            f'<div class="chips">{chips}</div>{blocks}</div>'
+        )
+    return (
+        f'<div class="dd-hl"><div class="drill-caption">{title}</div>{rows}</div>'
+    )
+
+
+def _doc_cer(result: RunResult, doc_id: str, view: str) -> list[tuple[str, float]]:
+    """(pipeline, CER) du document, pour la vue."""
+    out: list[tuple[str, float]] = []
+    for d in result.documents:
+        if d.document_id == doc_id and d.view == view:
+            for s in d.scores:
+                if s.metric == _METRIC and s.value is not None:
+                    out.append((d.pipeline, s.value))
+    return out
+
+
+def _doc_texts(result: RunResult, view: str, doc_id: str) -> DocumentTexts | None:
+    """Textes complets de ce document si le payload (top-N pires) les porte."""
+    for analysis in result.analyses:
+        payload = analysis.payload
+        if analysis.view == view and isinstance(payload, DocumentTextsPayload):
+            for dt in payload.documents:
+                if dt.document_id == doc_id:
+                    return dt
+    return None
+
+
+def _worst_lines(result: RunResult, doc_id: str, view: str) -> list[WorstLine]:
+    """Pires lignes de ce document présentes dans l'échantillon diagnostics."""
+    lines: list[WorstLine] = []
+    for analysis in result.analyses:
+        payload = analysis.payload
+        if analysis.view == view and isinstance(payload, DiagnosticsPayload):
+            lines += [w for w in payload.worst_lines if w.document_id == doc_id]
+    return lines
+
+
+class DocumentDetailSection:
+    """Panneaux détail par document (CER/moteur + diff des pires lignes)."""
+
+    name = "document_details"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        if not result.documents:
+            return None
+        view = ordered_unique(d.view for d in result.documents)[0]
+        rows = [d for d in result.documents if d.view == view]
+        doc_ids = list(ordered_unique(d.document_id for d in rows))
+        order = engine_order(p.pipeline for p in result.pipelines) or engine_order(
+            d.pipeline for d in rows
+        )
+        # Chaque fiche est rendue **par le serveur** (déterministe) mais dans un
+        # ``<template>`` **inerte** : le navigateur ne la peint pas et ne charge
+        # pas son fac-similé tant que ``report.js`` ne la clone pas, au clic, dans
+        # l'unique conteneur vivant ``.doc-detail-live``. → DOM borné même à 5000
+        # docs (une seule fiche vivante). Tous les documents restent présents et
+        # atteignables ; sans JS, les fiches ne s'affichent pas (dégradation). Les
+        # ancres ``#doc-<idx>`` restent alignées avec les cartes de la galerie.
+        templates = "".join(
+            f'<template data-doc="{idx}">'
+            + self._panel(
+                result,
+                view,
+                doc_id,
+                idx,
+                doc_ids,
+                order,
+                ctx.facsimiles.get(doc_id),
+                ctx.lang,
+            )
+            + "</template>"
+            for idx, doc_id in enumerate(doc_ids)
+        )
+        return Html(
+            '<div class="doc-detail-live" role="region" aria-live="polite"></div>'
+            f'<div class="doc-details" hidden>{templates}</div>'
+        )
+
+    def _panel(
+        self,
+        result: RunResult,
+        view: str,
+        doc_id: str,
+        idx: int,
+        doc_ids: list[str],
+        order: dict[str, int],
+        facsimile: str | None,
+        lang: str,
+    ) -> str:
+        total = len(doc_ids)
+        prev_i = (idx - 1) % total
+        next_i = (idx + 1) % total
+        cers = sorted(_doc_cer(result, doc_id, view), key=lambda e: (e[1], e[0]))
+        best = cers[0][1] if cers else None
+        cer_rows = "".join(
+            f'<div class="dd-row{" best" if c == best else ""}">'
+            f'<span class="eng-badge" style="--badge:{engine_accent(order.get(p, 0))}">'
+            f"{engine_letter(order.get(p, 0))}</span>"
+            f'<span class="dd-name">{escape(p)}</span>'
+            f'<span class="dd-cer">{fmt_pct(c, lang)}</span></div>'
+            for p, c in cers
+        )
+        # Diff **pleine page** (texte complet + sélecteur de moteur) si le payload
+        # textes porte ce doc (top-N pires) ; sinon **pires lignes** (toujours là).
+        full = _doc_texts(result, view, doc_id)
+        if full is not None and full.hypotheses:
+            diffs = self._full_diff(full, order, lang)
+        else:
+            worst = _worst_lines(result, doc_id, view)
+            diffs = ""
+            if worst:
+                items = "".join(self._diff_line(w, order, lang) for w in worst)
+                worst_title = localized(
+                    lang,
+                    "Pires lignes (diff vérité-terrain ↔ sortie)",
+                    "Worst lines (diff ground truth ↔ output)",
+                )
+                diffs = (
+                    '<div class="dd-diffs"><div class="drill-caption">'
+                    f"{worst_title}</div>{items}</div>"
+                )
+        # Fac-similé medium EN HAUT (pleine largeur, si résolu), puis CER par
+        # moteur + diff côte à côte. Sans image : on saute le bloc (pas de vide).
+        cer_title = localized(lang, "CER par moteur", "CER per engine")
+        fac_block = ""
+        if facsimile:
+            fac_title = localized(lang, "Fac-similé", "Facsimile")
+            open_lbl = localized(lang, "Ouvrir l’image", "Open image")
+            zin = localized(lang, "Zoom avant", "Zoom in")
+            zout = localized(lang, "Zoom arrière", "Zoom out")
+            zreset = localized(lang, "Réinitialiser le zoom", "Reset zoom")
+            fac_block = (
+                f'<div class="dd-fac-top"><div class="drill-caption">{fac_title}'
+                f'<a class="dd-fac-full" href="{escape(facsimile)}" target="_blank" '
+                f'rel="noopener noreferrer">{open_lbl} ↗</a>'
+                '</div><div class="dd-fac-zoom">'
+                f'<img class="dd-fac-img" src="{escape(facsimile)}" alt="" '
+                'loading="lazy" decoding="async">'
+                '<div class="dd-zoom-ctl">'
+                f'<button type="button" data-zoom="out" aria-label="{zout}">−</button>'
+                f'<button type="button" data-zoom="reset" aria-label="{zreset}">⤢'
+                "</button>"
+                f'<button type="button" data-zoom="in" aria-label="{zin}">+</button>'
+                "</div></div></div>"
+            )
+        # Graphiques recentrés sur CE doc : heatmap CER par ligne, hallucinations.
+        dl = _doc_lines(result, doc_id)
+        lh_block = _line_distribution(dl, order, lang) if dl is not None else ""
+        dh = _doc_hallucination(result, doc_id)
+        hl_block = _hallucination_block(dh, order, lang) if dh is not None else ""
+        # Haut : fac-similé **en bandeau étroit centré au-dessus**, puis le diff
+        # GT/sortie **côte à côte sur toute la largeur** en dessous — chaque
+        # colonne de texte a ~2× plus de place (sauts de ligne propres sur petit
+        # écran, et tient même pour de longues pages multi-colonnes). Sans image :
+        # le diff seul. Puis CER → heatmap ligne → hallucinations → qualité image.
+        top = f"{fac_block}{diffs}"
+        # Les graphiques secondaires (CER par moteur, heatmap ligne,
+        # hallucinations, qualité image) deviennent des **cartes** qui s'écoulent
+        # côte à côte (chacune à sa taille) au lieu d'être empilées pleine largeur.
+        sec_cards = [
+            f'<div class="dd-card"><div class="drill-caption">{cer_title}</div>'
+            f'<div class="dd-cers">{cer_rows}</div></div>'
+        ]
+        # Petites cartes (CER, hallucinations, qualité image) s'écoulent côte à
+        # côte ; la distribution par ligne (heatmap + percentiles) est large →
+        # elle prend toute la largeur (dd-wide) pour ne pas être tassée.
+        sec_cards += [
+            f'<div class="dd-card">{blk}</div>' for blk in (hl_block,) if blk
+        ]
+        if lh_block:
+            sec_cards.append(f'<div class="dd-card dd-wide">{lh_block}</div>')
+        body = f'{top}<div class="dd-flow">{"".join(sec_cards)}</div>'
+        back = localized(lang, "← Tous les documents", "← All documents")
+        prev_label = localized(lang, "← précédent", "← previous")
+        next_label = localized(lang, "suivant →", "next →")
+        pos = localized(
+            lang,
+            f"document {idx + 1} sur {total}",
+            f"document {idx + 1} of {total}",
+        )
+        return (
+            f'<div class="drill-panel doc-detail" id="doc-{idx}" '
+            f'role="region" aria-label="{escape(doc_id)}">'
+            '<div class="drill-head">'
+            f'<a class="drill-back" href="#">{back}</a>'
+            '<div class="drill-nav">'
+            f'<a class="btn-sm" href="#doc-{prev_i}">{prev_label}</a>'
+            f'<a class="btn-sm" href="#doc-{next_i}">{next_label}</a></div></div>'
+            f'<div class="drill-title"><span>{escape(doc_id)}</span>'
+            f'<span class="muted drill-pos">{pos}</span></div>'
+            f"{body}</div>"
+        )
+
+    @staticmethod
+    def _full_diff(texts: DocumentTexts, order: dict[str, int], lang: str) -> str:
+        """Diff **pleine page** : vérité-terrain ↔ sortie, **sélecteur de moteur**.
+
+        Un bloc par moteur (révélé par ``report.js`` ; sans JS, empilés). Le diff
+        caractère est **échappé avant marquage** (anti-XSS, comme les pires lignes)."""
+        hyps = texts.hypotheses
+        tabs = "".join(
+            f'<button type="button" class="dd-eng-btn{" on" if i == 0 else ""}" '
+            f'data-engine="{escape(p)}"><span class="eng-badge" '
+            f'style="--badge:{engine_accent(order.get(p, 0))}">'
+            f"{engine_letter(order.get(p, 0))}</span>{escape(p)}</button>"
+            for i, (p, _) in enumerate(hyps)
+        )
+        ref_label = localized(lang, "Vérité terrain", "Ground truth")
+        out_label = localized(lang, "Sortie", "Output")
+        blocks = ""
+        for i, (p, hyp) in enumerate(hyps):
+            ref_html, hyp_html = char_diff(texts.reference, hyp)
+            hidden = "" if i == 0 else " hidden"
+            blocks += (
+                f'<div class="dd-fulldiff" data-engine="{escape(p)}"{hidden}>'
+                '<div class="dd-sbs">'
+                f'<div class="dd-sbs-col"><div class="dd-diff-head mono">{ref_label}'
+                f'</div><div class="diff">{ref_html}</div></div>'
+                '<div class="dd-sbs-col"><div class="dd-diff-head mono">'
+                f"{out_label} · {escape(p)}</div>"
+                f'<div class="diff">{hyp_html}</div></div>'
+                "</div></div>"
+            )
+        full_title = localized(
+            lang,
+            "Diff vérité-terrain ↔ sortie (page complète)",
+            "Diff ground truth ↔ output (full page)",
+        )
+        return (
+            f'<div class="dd-fullwrap"><div class="drill-caption">{full_title}'
+            "</div>"
+            f'<div class="dd-engine-tabs segmented" role="tablist">{tabs}</div>'
+            f"{blocks}</div>"
+        )
+
+    @staticmethod
+    def _diff_line(w: WorstLine, order: dict[str, int], lang: str) -> str:
+        ref_html, hyp_html = char_diff(w.reference, w.hypothesis)
+        idx = order.get(w.pipeline, 0)
+        head = localized(
+            lang,
+            f"{escape(w.pipeline)} · ligne {w.line_index} · CER {w.cer * 100:.0f} %",
+            f"{escape(w.pipeline)} · line {w.line_index} · CER {w.cer * 100:.0f} %",
+        )
+        return (
+            '<div class="dd-diff">'
+            f'<div class="dd-diff-head mono"><span class="eng-badge" '
+            f'style="--badge:{engine_accent(idx)}">{engine_letter(idx)}</span>'
+            f"{head}</div>"
+            f'<div class="diff">{ref_html}</div>'
+            f'<div class="diff">{hyp_html}</div></div>'
+        )
+
+
+__all__ = ["DocumentDetailSection"]
diff --git a/cinoc/reports/sections/documents.py b/cinoc/reports/sections/documents.py
new file mode 100644
index 0000000000000000000000000000000000000000..4345953b963b6bbc06550dea58ab9491ab3ad039
--- /dev/null
+++ b/cinoc/reports/sections/documents.py
@@ -0,0 +1,49 @@
+"""Section documents : **galerie d'entrée** + bascule ⊞ Grille / ≡ Liste (couche 7).
+
+La galerie (cartes par document) est l'**entrée** de la vue ; la table dense
+``by_document`` devient le mode **Liste** derrière un toggle. Compose les deux
+rendus existants (réutilisation, pas de duplication). Enrichissement progressif :
+sans JS, la grille (entrée) s'affiche, ``report.js`` bascule vers la liste.
+"""
+
+from __future__ import annotations
+
+from cinoc.evaluation.result import RunResult
+from cinoc.reports.html import localized
+from cinoc.reports.section import Html, SectionContext
+from cinoc.reports.sections.by_document import DocumentSection
+from cinoc.reports.sections.gallery import DocumentGallerySection
+
+
+class DocumentsSection:
+    """Vue documents : galerie (grille, entrée) ⇄ table (liste), via un toggle."""
+
+    name = "documents"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        # Vue **maître** seule (galerie ⇄ liste). Les fiches détail document
+        # vivent dans une section sœur ``document_details`` (conteneur ``.tab-detail``
+        # échangé au clic par le routeur) — pas dans le flux maître.
+        grid = DocumentGallerySection().render(result, ctx)
+        lst = DocumentSection().render(result, ctx)
+        if grid is None and lst is None:
+            return None
+        affichage = localized(ctx.lang, "Affichage", "Display")
+        grid_label = localized(ctx.lang, "Grille", "Grid")
+        list_label = localized(ctx.lang, "Liste", "List")
+        toggle = (
+            f'<div class="view-toggle" role="group" aria-label="{affichage}">'
+            '<button type="button" class="vt-btn on" data-view="grid" '
+            f'aria-pressed="true">⊞ {grid_label}</button>'
+            '<button type="button" class="vt-btn" data-view="list" '
+            f'aria-pressed="false">≡ {list_label}</button></div>'
+        )
+        return Html(
+            f"{toggle}"
+            f'<div class="doc-view" data-view="grid">{grid or ""}</div>'
+            f'<div class="doc-view" data-view="list" hidden>{lst or ""}</div>'
+        )
+
+
+__all__ = ["DocumentsSection"]
diff --git a/cinoc/reports/sections/economics.py b/cinoc/reports/sections/economics.py
new file mode 100644
index 0000000000000000000000000000000000000000..35fb9b439bfdb1386850bf0f2552438189ddc6f5
--- /dev/null
+++ b/cinoc/reports/sections/economics.py
@@ -0,0 +1,189 @@
+"""Section économie : coûts estimés, débit effectif, Pareto (couche 7).
+
+Rend les payloads ``economics`` de ``RunResult.analyses`` en **lecture seule**
+(tout est calculé en couche 3 — anti data-layer). Chaque nombre est une
+fonction auditable des mesures E1 + de la table de tarifs **datée** : si la
+table est périmée au moment du run (``pricing_stale``), un avertissement
+explicite est rendu — jamais un chiffre silencieusement périmé.
+"""
+
+from __future__ import annotations
+
+from cinoc.evaluation.analysis import EconomicsPayload, MarginalCost
+from cinoc.evaluation.result import RunResult
+from cinoc.reports._numbers import localize_decimal
+from cinoc.reports.engine_badges import engine_cell, engine_order
+from cinoc.reports.html import escape, localized
+from cinoc.reports.section import Html, SectionContext
+from cinoc.reports.sections._payload import render_payload_section
+
+
+def _fmt(value: float | None, lang: str, pattern: str = "{:.4f}") -> str:
+    return "—" if value is None else localize_decimal(pattern.format(value), lang)
+
+
+def _marginal_row(m: MarginalCost, lang: str) -> str:
+    delta = localize_decimal(f"{m.cost_delta_eur:+.4f}", lang)
+    avoided = localize_decimal(f"{m.errors_avoided:+.1f}", lang)
+    return (
+        f'<tr><td class="eng-cell">{escape(m.pipeline)}</td>'
+        f'<td class="eng-cell">{escape(m.baseline)}</td>'
+        f'<td class="disp">{delta}</td>'
+        f'<td class="disp">{avoided}</td>'
+        f'<td class="disp">{_fmt(m.eur_per_avoided_error, lang)}</td></tr>'
+    )
+
+
+def _fmt_int(value: int | None) -> str:
+    return "—" if value is None else f"{value}"
+
+
+def _block(
+    view: str, payload: EconomicsPayload, lang: str, order: dict[str, int]
+) -> str:
+    rows: list[str] = []
+    for row in payload.pipelines:
+        badge = engine_cell(row.pipeline, order.get(row.pipeline, 0))
+        dur = _fmt(row.duration_seconds, lang, "{:.1f}")
+        pph = _fmt(row.pages_per_hour, lang, "{:.1f}")
+        pph_eff = _fmt(row.pages_per_hour_effective, lang, "{:.1f}")
+        rows.append(
+            f'<tr><td class="eng-cell">{badge}</td>'
+            f'<td class="disp">{_fmt(row.cer, lang)}</td>'
+            f'<td class="disp">{dur}</td>'
+            f'<td class="disp">{_fmt_int(row.tokens_in)}</td>'
+            f'<td class="disp">{_fmt_int(row.tokens_out)}</td>'
+            f'<td class="disp">{_fmt(row.cost_eur, lang)}</td>'
+            f'<td class="eng-cell">{escape(row.basis)}</td>'
+            f'<td class="disp">{pph}</td>'
+            f'<td class="disp">{pph_eff}</td>'
+            "</tr>"
+        )
+    stale = (
+        localized(
+            lang,
+            '<p class="verdict sig">⚠ Table de tarifs périmée au moment du run '
+            f"(valable jusqu'au {escape(payload.pricing_valid_until)}) — coûts à "
+            "revalider.</p>\n",
+            '<p class="verdict sig">⚠ Pricing table stale at run time '
+            f"(valid until {escape(payload.pricing_valid_until)}) — costs to "
+            "revalidate.</p>\n",
+        )
+        if payload.pricing_stale
+        else ""
+    )
+    marginal = ""
+    if payload.marginal:
+        items = "".join(_marginal_row(m, lang) for m in payload.marginal)
+        marginal_head = localized(
+            lang,
+            "Coût marginal (vs pipeline le moins cher)",
+            "Marginal cost (vs cheapest pipeline)",
+        )
+        th_pipeline = localized(lang, "Pipeline", "Pipeline")
+        th_baseline = localized(lang, "Référence", "Baseline")
+        th_cost_delta = localized(
+            lang,
+            f"Δ coût ({escape(payload.currency)})",
+            f"Δ cost ({escape(payload.currency)})",
+        )
+        th_errors_avoided = localized(lang, "erreurs évitées", "errors avoided")
+        th_per_avoided = localized(
+            lang,
+            f"{escape(payload.currency)}/erreur évitée",
+            f"{escape(payload.currency)}/avoided error",
+        )
+        marginal = (
+            f"<h4>{marginal_head}</h4>\n"
+            f'<table class="data">\n<thead><tr><th>{th_pipeline}</th>'
+            f"<th>{th_baseline}</th>"
+            f'<th class="num-cell">{th_cost_delta}</th>'
+            f'<th class="num-cell">{th_errors_avoided}</th>'
+            f'<th class="num-cell">{th_per_avoided}</th>'
+            f"</tr></thead>\n<tbody>{items}</tbody>\n</table>\n"
+        )
+    pareto = ""
+    if payload.pareto_cost or payload.pareto_speed:
+        cost_names = ", ".join(escape(n) for n in payload.pareto_cost) or "—"
+        speed_names = ", ".join(escape(n) for n in payload.pareto_speed) or "—"
+        pareto = localized(
+            lang,
+            f'<p class="muted">Front de Pareto {escape(payload.metric)} × coût : '
+            f"{cost_names} · {escape(payload.metric)} × durée : {speed_names}.</p>\n",
+            f'<p class="muted">Pareto front {escape(payload.metric)} × cost: '
+            f"{cost_names} · {escape(payload.metric)} × duration: {speed_names}.</p>\n",
+        )
+    head = localized(
+        lang,
+        f"{view}coûts &amp; débit",
+        f"{view}costs &amp; throughput",
+    )
+    rate = localize_decimal(f"{payload.hourly_rate_eur:g}", lang)
+    tpe = localize_decimal(f"{payload.time_per_error_seconds:g}", lang)
+    prose = localized(
+        lang,
+        '<p class="muted">Coûts <strong>indicatifs</strong> : temps machine '
+        f"(durée mesurée × {rate} "
+        f"{escape(payload.currency)}/h) + jetons cloud au tarif de la table "
+        f"(valable jusqu'au {escape(payload.pricing_valid_until)}) ; débit "
+        "effectif corrigé du temps de relecture "
+        f"({tpe} s/erreur).</p>\n",
+        '<p class="muted">Costs are <strong>indicative</strong>: machine time '
+        f"(measured duration × {rate} "
+        f"{escape(payload.currency)}/h) + cloud tokens at the table's rate "
+        f"(valid until {escape(payload.pricing_valid_until)}); effective "
+        "throughput corrected for proofreading time "
+        f"({tpe} s/error).</p>\n",
+    )
+    th_pipeline = localized(lang, "Pipeline", "Pipeline")
+    th_duration = localized(lang, "durée (s)", "duration (s)")
+    th_tokens_in = localized(lang, "jetons in", "tokens in")
+    th_tokens_out = localized(lang, "jetons out", "tokens out")
+    th_cost = localized(
+        lang,
+        f"coût ({escape(payload.currency)})",
+        f"cost ({escape(payload.currency)})",
+    )
+    th_basis = localized(lang, "base", "basis")
+    th_pages_per_hour = localized(lang, "pages/h", "pages/h")
+    th_pages_per_hour_eff = localized(
+        lang, "pages/h effectif", "pages/h effective"
+    )
+    return (
+        f"<h3>{head}</h3>\n"
+        + stale
+        + prose
+        + '<table class="data">\n'
+        f"<thead><tr><th>{th_pipeline}</th>"
+        f'<th class="num-cell">{escape(payload.metric)}</th>'
+        f'<th class="num-cell">{th_duration}</th>'
+        f'<th class="num-cell">{th_tokens_in}</th>'
+        f'<th class="num-cell">{th_tokens_out}</th>'
+        f'<th class="num-cell">{th_cost}</th>'
+        f"<th>{th_basis}</th>"
+        f'<th class="num-cell">{th_pages_per_hour}</th>'
+        f'<th class="num-cell">{th_pages_per_hour_eff}</th></tr></thead>\n'
+        f"<tbody>{''.join(rows)}</tbody>\n</table>\n"
+        + pareto
+        + marginal
+    )
+
+
+class EconomicsSection:
+    """Coûts estimés, débit effectif et fronts de Pareto, par vue."""
+
+    name = "economics"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        order = engine_order(p.pipeline for p in result.pipelines)
+        return render_payload_section(
+            result,
+            ctx,
+            payload_type=EconomicsPayload,
+            title=localized(ctx.lang, "Économie", "Economics"),
+            block=lambda view, payload: _block(view, payload, ctx.lang, order),
+        )
+
+
+__all__ = ["EconomicsSection"]
diff --git a/cinoc/reports/sections/engine_duel.py b/cinoc/reports/sections/engine_duel.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc6861a479afc1aa79ae0a8854c7e87504bf3e8d
--- /dev/null
+++ b/cinoc/reports/sections/engine_duel.py
@@ -0,0 +1,101 @@
+"""Section duel par document : graphe haltère du CER par moteur (couche 7).
+
+Une ligne par document, un point par moteur (CER), reliés : pour 2 moteurs c'est
+un **duel** (qui gagne où, de combien) ; au-delà, un dot-plot. Trié par **écart
+inter-moteurs décroissant** (les documents où les moteurs divergent le plus en
+tête) et borné aux N premiers. Pure présentation : lit les CER par document du
+``RunResult`` (aucun recalcul), rendu SVG serveur déterministe, zéro JS.
+"""
+
+from __future__ import annotations
+
+from cinoc.evaluation.result import RunResult
+from cinoc.reports.engine_badges import engine_accent, engine_letter, engine_order
+from cinoc.reports.html import escape, localized
+from cinoc.reports.section import Html, SectionContext
+from cinoc.reports.sections._tables import ordered_unique
+from cinoc.reports.svg import dumbbell_rows
+
+_METRIC = "cer"
+#: Documents affichés (les plus discriminants) — borne la hauteur de la carte.
+_MAX_ROWS = 18
+#: Libellé document tronqué (l'id complet vit dans la galerie/le drill-in).
+_LABEL_CHARS = 11
+
+
+def _clip(label: str) -> str:
+    return label if len(label) <= _LABEL_CHARS else label[: _LABEL_CHARS - 1] + "…"
+
+
+class EngineDuelSection:
+    """Graphe haltère : CER par moteur et document, trié par écart (carte autonome)."""
+
+    name = "engine_duel"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        if not result.documents:
+            return None
+        view = ordered_unique(d.view for d in result.documents)[0]
+        order = engine_order(p.pipeline for p in result.pipelines) or engine_order(
+            d.pipeline for d in result.documents
+        )
+        present = {
+            d.pipeline
+            for d in result.documents
+            if d.view == view and d.pipeline in order
+        }
+        engines = sorted(present, key=lambda n: order[n])
+        if len(engines) < 2:
+            return None  # un duel suppose au moins deux moteurs
+        # {doc: {engine: cer}}
+        per_doc: dict[str, dict[str, float]] = {}
+        for doc in result.documents:
+            if doc.view != view or doc.pipeline not in order:
+                continue
+            for score in doc.scores:
+                if score.metric == _METRIC and score.value is not None:
+                    per_doc.setdefault(doc.document_id, {})[doc.pipeline] = score.value
+        # Ne garde que les documents mesurés sur **tous** les moteurs (duel complet).
+        complete = {
+            doc: vals for doc, vals in per_doc.items()
+            if all(e in vals for e in engines)
+        }
+        if not complete:
+            return None
+        spread = {
+            doc: max(vals[e] for e in engines) - min(vals[e] for e in engines)
+            for doc, vals in complete.items()
+        }
+        # Tri par écart décroissant ; départage par id pour le déterminisme.
+        ranked = sorted(complete, key=lambda d: (-spread[d], d))[:_MAX_ROWS]
+        scale_max = max(max(complete[d][e] for e in engines) for d in ranked) or 1.0
+        rows = [
+            (_clip(doc), [(complete[doc][e], engine_accent(order[e])) for e in engines])
+            for doc in ranked
+        ]
+        svg = dumbbell_rows(rows, scale_max=scale_max)
+        legend = " · ".join(
+            f'<span class="eng-badge" style="--badge:{engine_accent(order[e])}">'
+            f"{engine_letter(order[e])}</span> {escape(e)}"
+            for e in engines
+        )
+        title = localized(ctx.lang, "Duel par document", "Per-document duel")
+        intro = localized(
+            ctx.lang,
+            f"CER par moteur sur chaque document, reliés — les {len(ranked)} "
+            "documents où les moteurs <strong>divergent le plus</strong> (écart "
+            f"décroissant). Échelle commune (max {scale_max * 100:.0f} %).",
+            f"CER per engine on each document, linked — the {len(ranked)} documents "
+            "where engines <strong>diverge most</strong> (decreasing gap). Common "
+            f"scale (max {scale_max * 100:.0f} %).",
+        )
+        return Html(
+            f"<h2>{title}</h2>\n"
+            f'<p class="muted">{intro}</p>\n'
+            f'<div class="dumb-wrap">{svg}</div>\n'
+            f'<p class="muted dumb-legend">{legend}</p>\n'
+        )
+
+
+__all__ = ["EngineDuelSection"]
diff --git a/cinoc/reports/sections/engine_profile.py b/cinoc/reports/sections/engine_profile.py
new file mode 100644
index 0000000000000000000000000000000000000000..c52c7b4c46d15bb080571a8e02cddc25ad1965f2
--- /dev/null
+++ b/cinoc/reports/sections/engine_profile.py
@@ -0,0 +1,267 @@
+"""Section profil moteur : panneaux **drill-in** par moteur (couche 7).
+
+Pour chaque moteur, un panneau **caché** (révélé au clic d'une ligne du tableau
+de classement, ancre ``#engine-<idx>``) : bande KPI (CER/WER/… de l'agrégat,
+ECE si calibration) + **CER par document** trié (barres SVG). Enrichissement
+progressif : sans JS, le panneau s'affiche via ``:target`` ; ``report.js`` le
+révèle en masquant les autres (← retour, précédent/suivant). Server-side,
+déterministe, zéro donnée reconstruite. Réutilise les builders SVG (U2).
+"""
+
+from __future__ import annotations
+
+from cinoc.evaluation.analysis import CalibrationPayload, TaxonomyPayload
+from cinoc.evaluation.result import PipelineResult, RunResult
+from cinoc.reports._binning import histogram
+from cinoc.reports._numbers import fmt_pct
+from cinoc.reports.engine_badges import engine_accent, engine_letter, engine_order
+from cinoc.reports.html import escape, localized
+from cinoc.reports.section import Html, SectionContext
+from cinoc.reports.sections._tables import ordered_unique
+from cinoc.reports.sections.taxonomy import composition_html
+from cinoc.reports.svg import bar_series, calibration_curve
+
+_METRIC = "cer"
+#: Classes de l'histogramme de CER par document (constant → graphe borné, même
+#: forme que le moteur ait été évalué sur 20 ou 6000 documents).
+_N_BINS = 24
+
+
+def _per_doc_cer(result: RunResult, pipeline: str, view: str) -> list[float]:
+    return [
+        score.value
+        for doc in result.documents
+        if doc.pipeline == pipeline and doc.view == view
+        for score in doc.scores
+        if score.metric == _METRIC and score.value is not None
+    ]
+
+
+def _calibration(
+    result: RunResult, view: str, pipeline: str
+) -> tuple[float, str] | None:
+    """(ECE, courbe SVG) du moteur si calibration présente, sinon ``None``."""
+    for analysis in result.analyses:
+        payload = analysis.payload
+        if analysis.view == view and isinstance(payload, CalibrationPayload):
+            for row in payload.pipelines:
+                if row.pipeline == pipeline:
+                    curve = calibration_curve(
+                        [(b.mean_confidence, b.accuracy) for b in row.bins],
+                        accent="var(--fern)",
+                    )
+                    return row.ece, curve
+    return None
+
+
+def _composition(result: RunResult, view: str, pipeline: str, lang: str) -> str:
+    """Composition d'erreurs du moteur (réutilise ``taxonomy.composition_html``)."""
+    for analysis in result.analyses:
+        payload = analysis.payload
+        if analysis.view == view and isinstance(payload, TaxonomyPayload):
+            for row in payload.pipelines:
+                if row.pipeline == pipeline:
+                    return composition_html(payload.classes, row, lang)
+    return ""
+
+
+def _kpi(label: str, value: str) -> str:
+    return (
+        f'<div class="kpi"><div class="kpi-k">{escape(label)}</div>'
+        f'<div class="kpi-v">{escape(value)}</div></div>'
+    )
+
+
+def _pct(v: float, lang: str) -> str:
+    return fmt_pct(v, lang)
+
+
+def _config_block(result: RunResult, name: str, lang: str) -> str:
+    """Config repliable (reproductibilité) : étapes du pipeline + adapter + version
+    déclarée + paramètres, depuis le ``RunManifest``. ``<details>`` natif (zéro JS,
+    imprimable). Omise si le manifeste ne porte pas la spec (ex. données de démo)."""
+    spec = next(
+        (s for s in result.manifest.pipeline_specs if s.name == name), None
+    )
+    if spec is None or not spec.steps:
+        return ""
+    versions = result.manifest.module_versions
+    body = ""
+    for step in spec.steps:
+        ver = escape(versions.get(step.adapter_name, "—"))
+        params = (
+            " · ".join(f"{escape(k)}={escape(str(v))}" for k, v in step.params.items())
+            or "—"
+        )
+        body += (
+            f'<tr><td class="lbl">{escape(step.kind)}</td>'
+            f'<td class="lbl">{escape(step.adapter_name)}</td>'
+            f'<td class="disp">{ver}</td><td class="lbl">{params}</td></tr>'
+        )
+    summ = localized(lang, "Configuration & reproductibilité", "Configuration")
+    th_s = localized(lang, "Étape", "Step")
+    th_a = localized(lang, "Adapter", "Adapter")
+    th_v = localized(lang, "Version", "Version")
+    th_p = localized(lang, "Paramètres", "Parameters")
+    return (
+        f'<details><summary class="muted">{summ}</summary>\n'
+        f'<table class="data compact"><thead><tr><th>{th_s}</th><th>{th_a}</th>'
+        f'<th class="num-cell">{th_v}</th><th>{th_p}</th></tr></thead>'
+        f"<tbody>{body}</tbody></table></details>"
+    )
+
+
+def _stratum_block(result: RunResult, name: str, view: str, lang: str) -> str:
+    """CER moyen par strate (macro-moyenne) — révèle forces/faiblesses du moteur
+    selon le sous-corpus. Rendu seulement si ≥ 2 strates portent des documents
+    notés (jamais une strate inventée). Trié du meilleur au pire."""
+    buckets: dict[str, list[float]] = {}
+    for d in result.documents:
+        if d.pipeline != name or d.view != view or not d.stratum:
+            continue
+        cer = next(
+            (s.value for s in d.scores if s.metric == "cer" and s.value is not None),
+            None,
+        )
+        if cer is not None:
+            buckets.setdefault(d.stratum, []).append(cer)
+    if len(buckets) < 2:
+        return ""
+    rows_data = sorted(
+        ((s, sum(v) / len(v), len(v)) for s, v in buckets.items()),
+        key=lambda r: r[1],
+    )
+    rows = "".join(
+        f'<tr><td class="lbl">{escape(s)}</td><td class="disp">{n}</td>'
+        f'<td class="disp">{_pct(m, lang)}</td></tr>'
+        for s, m, n in rows_data
+    )
+    cap = localized(lang, "Performance par strate", "Performance by stratum")
+    th_n = localized(lang, "n", "n")
+    th_c = localized(lang, "CER moyen ↓", "Mean CER ↓")
+    th_s = localized(lang, "Strate", "Stratum")
+    return (
+        f'<div class="prof-cell"><div class="drill-caption">{cap}</div>'
+        f'<table class="data compact"><thead><tr><th>{th_s}</th>'
+        f'<th class="num-cell">{th_n}</th><th class="num-cell">{th_c}</th></tr>'
+        f"</thead><tbody>{rows}</tbody></table></div>"
+    )
+
+
+class EngineProfileSection:
+    """Panneaux profil par moteur (KPIs + CER/document), révélés au clic."""
+
+    name = "engine_profiles"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        if not result.pipelines:
+            return None
+        view = ordered_unique(p.view for p in result.pipelines)[0]
+        order = engine_order(p.pipeline for p in result.pipelines)
+        view_pipes = {p.pipeline: p for p in result.pipelines if p.view == view}
+        engines = [n for n in sorted(order, key=lambda n: order[n]) if n in view_pipes]
+        if not engines:
+            return None
+        panels = "".join(
+            self._panel(result, view, name, order, engines, pos, ctx.lang)
+            for pos, name in enumerate(engines)
+        )
+        # Section **détail** (vue page d'un moteur) : pas d'en-tête « cliquer un
+        # moteur… » (le maître = le tableau de classement est la liste cliquable ;
+        # le routeur échange maître↔détail). Chaque panneau porte son fil d'Ariane.
+        return Html(f'<div class="eng-profiles">{panels}</div>\n')
+
+    def _panel(
+        self,
+        result: RunResult,
+        view: str,
+        name: str,
+        order: dict[str, int],
+        engines: list[str],
+        pos: int,
+        lang: str,
+    ) -> str:
+        idx = order[name]
+        pipe: PipelineResult = next(
+            p for p in result.pipelines if p.view == view and p.pipeline == name
+        )
+        total = len(engines)
+        prev_idx = order[engines[(pos - 1) % total]]
+        next_idx = order[engines[(pos + 1) % total]]
+        # KPIs : métriques d'agrégat (réelles) + ECE si calibration présente.
+        kpis = [
+            _kpi(s.metric, _pct(s.value, lang))
+            for s in pipe.aggregate
+            if s.value is not None
+        ]
+        cal = _calibration(result, view, name)
+        if cal is not None:
+            kpis.append(_kpi("ece", _pct(cal[0], lang)))
+        cer_vals = _per_doc_cer(result, name, view)
+        chart_caption = localized(
+            lang,
+            f'<span class="muted">· distribution sur {len(cer_vals)} docs '
+            f"({_N_BINS} classes, gauche = faible CER)</span>",
+            f'<span class="muted">· distribution over {len(cer_vals)} docs '
+            f"({_N_BINS} bins, left = low CER)</span>",
+        )
+        chart = (
+            '<div class="prof-chart"><div class="drill-caption">'
+            + localized(lang, "CER par document ", "CER per document ")
+            + f"{chart_caption}</div>"
+            f"{bar_series(histogram(cer_vals, _N_BINS), accent=engine_accent(idx))}"
+            "</div>"
+            if cer_vals
+            else ""
+        )
+        # Calibration + composition du moteur (réutilise les builders U2b/U2c),
+        # en 2 colonnes ; chaque bloc n'apparaît que si sa donnée est présente.
+        cal_block = (
+            '<div class="prof-cell"><div class="drill-caption">'
+            + localized(lang, "Courbe de calibration", "Calibration curve")
+            + f"</div>{cal[1]}</div>"
+            if cal is not None
+            else ""
+        )
+        comp = _composition(result, view, name, lang)
+        comp_block = (
+            '<div class="prof-cell"><div class="drill-caption">'
+            + localized(lang, "Composition des erreurs", "Error composition")
+            + f"</div>{comp}</div>"
+            if comp
+            else ""
+        )
+        strat_block = _stratum_block(result, name, view, lang)
+        extras = (
+            f'<div class="prof-row">{strat_block}{cal_block}{comp_block}</div>'
+            if (strat_block or cal_block or comp_block)
+            else ""
+        )
+        config = _config_block(result, name, lang)
+        back_label = localized(lang, "← Tous les moteurs", "← All engines")
+        prev_label = localized(lang, "← précédent", "← previous")
+        next_label = localized(lang, "suivant →", "next →")
+        pos_label = localized(
+            lang,
+            f"moteur {pos + 1} sur {total}",
+            f"engine {pos + 1} of {total}",
+        )
+        return (
+            f'<div class="drill-panel eng-profile" id="engine-{idx}" hidden '
+            f'role="region" aria-label="{escape(name)}">'
+            '<div class="drill-head">'
+            f'<a class="drill-back" href="#">{back_label}</a>'
+            '<div class="drill-nav">'
+            f'<a class="btn-sm" href="#engine-{prev_idx}">{prev_label}</a>'
+            f'<a class="btn-sm" href="#engine-{next_idx}">{next_label}</a></div></div>'
+            f'<div class="drill-title"><span class="eng-badge" '
+            f'style="--badge:{engine_accent(idx)}">{engine_letter(idx)}</span>'
+            f"<span>{escape(name)}</span>"
+            f'<span class="muted drill-pos">{pos_label}</span></div>'
+            f'<div class="kpi-band">{"".join(kpis)}</div>'
+            f"{chart}{extras}{config}</div>"
+        )
+
+
+__all__ = ["EngineProfileSection"]
diff --git a/cinoc/reports/sections/engine_radar.py b/cinoc/reports/sections/engine_radar.py
new file mode 100644
index 0000000000000000000000000000000000000000..8748f9f473d54a1b8b3d2b776e6a8dc8c29e4264
--- /dev/null
+++ b/cinoc/reports/sections/engine_radar.py
@@ -0,0 +1,141 @@
+"""Section radar : profil multi-métrique par moteur, superposé (couche 7).
+
+Un seul graphique « toile d'araignée » qui superpose tous les moteurs sur des
+axes normalisés « plus loin = meilleur » ([0,1]) — la **forme** de chaque
+polygone révèle ses forces/faiblesses d'un coup d'œil. Pure présentation : lit
+les scores d'agrégat du ``RunResult`` (aucun recalcul), rendu SVG serveur
+déterministe (≠ Chart.js), zéro JS.
+"""
+
+from __future__ import annotations
+
+from cinoc.evaluation.result import RunResult
+from cinoc.reports._numbers import fmt_pct, localize_decimal
+from cinoc.reports.engine_badges import engine_accent, engine_letter, engine_order
+from cinoc.reports.html import escape, localized
+from cinoc.reports.section import Html, SectionContext
+from cinoc.reports.sections._tables import ordered_unique
+from cinoc.reports.svg import radar_chart
+
+#: Axes du radar : (clé métrique, inverser ?, libellé fr, libellé en). Toutes les
+#: valeurs sont ramenées à « plus haut = meilleur » dans [0,1] (les métriques
+#: d'erreur sont inversées : 1 − valeur). L'axe ``hallucination`` inversé EST
+#: l'ancrage des trigrammes (1 − part non ancrée) → libellé honnête « Ancrage ».
+_AXES: tuple[tuple[str, bool, str, str], ...] = (
+    ("char_accuracy", False, "Caract.", "Char."),
+    ("word_accuracy", False, "Mot", "Word"),
+    ("fca", False, "Fidél.", "Fidel."),
+    ("bow_f1", False, "F1", "F1"),
+    ("searchability", False, "Rappel", "Recall"),
+    ("hallucination", True, "Ancrage", "Anchoring"),
+)
+
+
+class EngineRadarSection:
+    """Radar multi-métrique superposant tous les moteurs (carte autonome)."""
+
+    name = "engine_radar"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        if not result.pipelines:
+            return None
+        view = ordered_unique(p.view for p in result.pipelines)[0]
+        order = engine_order(p.pipeline for p in result.pipelines)
+        pipes = sorted(
+            (p for p in result.pipelines if p.view == view),
+            key=lambda p: order[p.pipeline],
+        )
+        if not pipes:
+            return None
+        scores = {
+            p.pipeline: {s.metric: s.value for s in p.aggregate if s.value is not None}
+            for p in pipes
+        }
+        # Axes retenus : ceux présents pour **tous** les moteurs affichés (sinon le
+        # polygone n'est pas comparable). Radar utile à partir de 3 axes. Les axes
+        # candidats absents pour au moins un moteur sont **signalés** (note de bas),
+        # jamais comblés par un zéro silencieux.
+        axes = [
+            ax for ax in _AXES if all(ax[0] in scores[p.pipeline] for p in pipes)
+        ]
+        if len(axes) < 3:
+            return None
+        dropped = [
+            (ax[2] if ctx.lang != "en" else ax[3])
+            for ax in _AXES
+            if ax not in axes and any(ax[0] in scores[p.pipeline] for p in pipes)
+        ]
+        labels = [ax[2] if ctx.lang != "en" else ax[3] for ax in axes]
+        series: list[tuple[str, list[float]]] = []
+        accents: list[str] = []
+        point_titles: list[list[str]] = []
+        for p in pipes:
+            values: list[float] = []
+            tips: list[str] = []
+            for key, invert, fr, en in axes:
+                raw = scores[p.pipeline][key]
+                norm = 1.0 - raw if invert else raw
+                values.append(norm)
+                lbl = fr if ctx.lang != "en" else en
+                # Infobulle : valeur **brute** (% lisible) ET normalisée (auditables).
+                raw_pct = fmt_pct(raw, ctx.lang)
+                norm_v = localize_decimal(f"{norm:.2f}", ctx.lang)
+                tips.append(f"{lbl} : {raw_pct} (norm. {norm_v})")
+            series.append((p.pipeline, values))
+            accents.append(engine_accent(order[p.pipeline]))
+            point_titles.append(tips)
+        aria = localized(
+            ctx.lang,
+            "Radar des profils moteur (axes normalisés, plus loin = meilleur)",
+            "Engine profile radar (normalised axes, further = better)",
+        )
+        svg = radar_chart(
+            labels, series, accents=accents, point_titles=point_titles, aria_label=aria
+        )
+        if not svg:
+            return None
+        legend = " · ".join(
+            f'<span class="eng-badge" style="--badge:{engine_accent(i)}">'
+            f"{engine_letter(i)}</span> {escape(p.pipeline)}"
+            for p in pipes
+            for i in (order[p.pipeline],)
+        )
+        title = localized(ctx.lang, "Profil radar", "Radar profile")
+        intro = localized(
+            ctx.lang,
+            "Profil multi-métrique par moteur. Chaque axe est une métrique dans "
+            "[0,1] orientée « plus loin = meilleur » (les taux d'erreur sont "
+            "inversés : 1 − valeur) ; l'échelle est <strong>absolue</strong> (pas "
+            "de min-max relatif), donc un petit écart reste un petit écart. "
+            "Survolez un sommet pour la valeur brute et normalisée.",
+            "Multi-metric profile per engine. Each axis is a metric in [0,1] "
+            "oriented 'further = better' (error rates are inverted: 1 − value); "
+            "the scale is <strong>absolute</strong> (no relative min-max), so a "
+            "small gap stays a small gap. Hover a vertex for raw and normalised "
+            "values.",
+        )
+        note = ""
+        if dropped:
+            note = (
+                '<p class="muted radar-legend">'
+                + localized(
+                    ctx.lang,
+                    "Dimensions non comparables masquées (absentes pour au moins "
+                    "un moteur) : ",
+                    "Non-comparable dimensions hidden (missing for at least one "
+                    "engine): ",
+                )
+                + escape(", ".join(dropped))
+                + ".</p>\n"
+            )
+        return Html(
+            f"<h2>{title}</h2>\n"
+            f'<p class="muted">{intro}</p>\n'
+            f'<div class="radar-wrap">{svg}</div>\n'
+            f'<p class="muted radar-legend">{legend}</p>\n'
+            f"{note}"
+        )
+
+
+__all__ = ["EngineRadarSection"]
diff --git a/cinoc/reports/sections/gallery.py b/cinoc/reports/sections/gallery.py
new file mode 100644
index 0000000000000000000000000000000000000000..d4e1b3b51d8e87dba9d76a143cf831d4de488a6c
--- /dev/null
+++ b/cinoc/reports/sections/gallery.py
@@ -0,0 +1,250 @@
+"""Section **galerie** des documents (couche 7) — présentation visuelle au design.
+
+≠ la table ``by_document`` (détail dense) : une **carte par document** avec un
+**aperçu de page synthétique** (lignes monochromes sur ``--paper``, dans la charte
+du rapport — pas de placeholder coloré, le travers évité), l'identifiant, et le
+**CER de chaque moteur** via les badges A→E (le meilleur du document surligné en
+``--fern``). 100 % données déjà présentes (``RunResult.documents``), **zéro image**,
+autonome. Server-side, déterministe.
+"""
+
+from __future__ import annotations
+
+from cinoc.evaluation.result import MetricScore, RunResult
+from cinoc.reports._anomaly import ANOMALY_LABELS, ANOMALY_ORDER, compute_anomalies
+from cinoc.reports._numbers import localize_decimal
+from cinoc.reports.engine_badges import engine_accent, engine_letter, engine_order
+from cinoc.reports.html import escape, localized, view_label
+from cinoc.reports.section import Html, SectionContext
+from cinoc.reports.sections._tables import ordered_unique
+
+
+def _cer(scores: tuple[MetricScore, ...]) -> float | None:
+    for score in scores:
+        if score.metric == "cer":
+            return score.value
+    return None
+
+
+def _row(
+    pipeline: str, cer: float | None, index: int, lang: str, *, best: bool
+) -> str:
+    value = "—" if cer is None else localize_decimal(f"{cer:.4f}", lang)
+    cls = "dc-row best" if best else "dc-row"
+    return (
+        f'<div class="{cls}">'
+        f'<span class="eng-badge" style="--badge:{engine_accent(index)}">'
+        f"{engine_letter(index)}</span>"
+        f'<span class="dc-name">{escape(pipeline)}</span>'
+        f'<span class="dc-cer">{value}</span></div>'
+    )
+
+
+def _card(
+    doc_id: str,
+    entries: list[tuple[str, float | None]],
+    order: dict[str, int],
+    idx: int,
+    thumb: str | None,
+    stratum: str | None = None,
+    anomalies: frozenset[str] = frozenset(),
+    *,
+    lang: str,
+) -> str:
+    scored = [c for _, c in entries if c is not None]
+    best = min(scored) if scored else None
+    rows = "".join(
+        _row(
+            pipeline,
+            cer,
+            order.get(pipeline, 0),
+            lang,
+            best=cer is not None and cer == best,
+        )
+        for pipeline, cer in sorted(
+            entries, key=lambda e: (e[1] is None, e[1] or 0.0, e[0])
+        )
+    )
+    # Vignette réelle si résolue (intrant de rendu), sinon aperçu synthétique.
+    preview = (
+        f'<div class="doc-preview doc-preview-img"><img src="{escape(thumb)}" '
+        f'alt="" loading="lazy" decoding="async"></div>'
+        if thumb
+        else '<div class="doc-preview" aria-hidden="true"></div>'
+    )
+    # Carte = lien drill-in vers le détail du document (ancre #doc-<idx>). Le
+    # ``data-stratum`` et ``data-anom`` (verbatim/triés, échappés) servent aux
+    # filtres client (strate · anomalie) qui **composent** ; absent → "".
+    strat_attr = f' data-stratum="{escape(stratum)}"' if stratum else ' data-stratum=""'
+    anom = " ".join(t for t in ANOMALY_ORDER if t in anomalies)
+    anom_attr = f' data-anom="{anom}"'
+    # Pastille « ⚑ » discrète si le document porte ≥ 1 anomalie (repère visuel).
+    mark = '<span class="dc-anom" aria-hidden="true">⚑</span>' if anom else ""
+    return (
+        f'<a class="doc-card" href="#doc-{idx}"{strat_attr}{anom_attr}>{preview}'
+        f'<div class="dc-id">{escape(doc_id)}{mark}</div>'
+        f'<div class="dc-rows">{rows}</div></a>'
+    )
+
+
+class DocumentGallerySection:
+    """Galerie visuelle : une carte par document (aperçu synthétique + CER/badges)."""
+
+    name = "documents_gallery"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        if not result.documents:
+            return None
+        views = ordered_unique(d.view for d in result.documents)
+        view = views[0]
+        multi = len(views) > 1
+        rows = [d for d in result.documents if d.view == view]
+        # Ordre canonique des moteurs (badge stable, partagé avec les autres sections).
+        order = engine_order(p.pipeline for p in result.pipelines) or engine_order(
+            d.pipeline for d in rows
+        )
+        # Strate par document (verbatim ; None si le corpus n'en porte pas).
+        strata = {
+            d.document_id: d.stratum for d in rows if d.stratum is not None
+        }
+        # Anomalies par document (signaux factuels, cutoffs P90 du run) — triage.
+        anomalies, cutoffs = compute_anomalies(result, view)
+        cards = "".join(
+            _card(
+                doc_id,
+                [(d.pipeline, _cer(d.scores)) for d in rows if d.document_id == doc_id],
+                order,
+                idx,
+                ctx.images.get(doc_id),
+                strata.get(doc_id),
+                frozenset(anomalies.get(doc_id, set())),
+                lang=ctx.lang,
+            )
+            for idx, doc_id in enumerate(ordered_unique(d.document_id for d in rows))
+        )
+        # Filtre par strate : chips seulement si ≥2 strates réellement présentes
+        # (jamais une catégorie inventée). Sans JS, tout reste visible.
+        present = ordered_unique(s for s in strata.values())
+        filt = self._filter(present, ctx.lang) if len(present) >= 2 else ""
+        # Filtre par anomalie : un type présent dès qu'≥ 1 doc le porte. Compose
+        # avec la strate (filtres client indépendants). + critère affiché.
+        present_anom = [
+            t for t in ANOMALY_ORDER if any(t in v for v in anomalies.values())
+        ]
+        filt += self._anomaly_filter(present_anom, cutoffs, ctx.lang)
+        vlbl = escape(view_label(view, ctx.lang))
+        title = localized(
+            ctx.lang,
+            f"Galerie des documents{f' (vue : {vlbl})' if multi else ''}",
+            f"Document gallery{f' (view: {vlbl})' if multi else ''}",
+        )
+        caption = localized(
+            ctx.lang,
+            "Aperçu + CER par moteur "
+            "(pastille de couleur ; meilleur du document surligné).",
+            "Preview + CER per engine "
+            "(colour dot; best of the document highlighted).",
+        )
+        return Html(
+            f"<h2>{title}</h2>\n"
+            f'<p class="muted">{caption}</p>\n'
+            f"{filt}"
+            # ``data-paginate`` : toutes les cartes restent présentes (rien retiré) ;
+            # ``report.js`` n'en affiche qu'une page à la fois (+ pager). Sans JS,
+            # tout s'affiche (autonome). Compose avec le filtre par strate.
+            f'<div class="doc-grid" data-paginate="60">{cards}</div>\n'
+        )
+
+    def _filter(self, strata: tuple[str, ...], lang: str) -> str:
+        """Rangée de chips de filtre par strate (réutilise la pilule segmentée).
+
+        Bouton « Toutes » (``data-stratum="*"``) + un bouton par strate présente
+        (libellé verbatim). ``report.js`` masque les cartes hors strate ; sans JS,
+        les boutons sont inertes et toutes les cartes restent visibles."""
+        all_lbl = localized(lang, "Toutes", "All")
+        aria = localized(lang, "Filtrer par strate", "Filter by stratum")
+        chips = (
+            '<button type="button" class="df-btn on" data-stratum="*" '
+            f'aria-pressed="true">{all_lbl}</button>'
+        )
+        for s in strata:
+            chips += (
+                f'<button type="button" class="df-btn" data-stratum="{escape(s)}" '
+                f'aria-pressed="false">{escape(s)}</button>'
+            )
+        return (
+            '<div class="doc-filter" role="group" data-facet="stratum" '
+            f'aria-label="{aria}">{chips}</div>'
+        )
+
+    def _anomaly_filter(
+        self, present: list[str], cutoffs: dict[str, float], lang: str
+    ) -> str:
+        """Rangée de chips de filtre par **type d'anomalie** (composent avec la
+        strate) + **légende du critère** (cutoff P90 affiché → auditable).
+
+        Rendue seulement si ≥ 1 type présent. ``data-facet="anom"`` : le filtre
+        client lit la **liste** ``data-anom`` de chaque carte (appartenance)."""
+        if not present:
+            return ""
+        all_lbl = localized(lang, "Toutes", "All")
+        aria = localized(lang, "Filtrer par anomalie", "Filter by anomaly")
+        chips = (
+            '<button type="button" class="df-btn on" data-anom="*" '
+            f'aria-pressed="true">{all_lbl}</button>'
+        )
+        for t in present:
+            label = ANOMALY_LABELS[t][1 if lang == "en" else 0]
+            chips += (
+                f'<button type="button" class="df-btn" data-anom="{t}" '
+                f'aria-pressed="false">⚑ {escape(label)}</button>'
+            )
+        legend = self._anomaly_legend(present, cutoffs, lang)
+        return (
+            '<div class="doc-filter" role="group" data-facet="anom" '
+            f'aria-label="{aria}">{chips}</div>{legend}'
+        )
+
+    @staticmethod
+    def _anomaly_legend(
+        present: list[str], cutoffs: dict[str, float], lang: str
+    ) -> str:
+        """Critère **exact** de chaque facette présente (cutoff = P90 observé)."""
+        cc = localize_decimal(f"P90 ({cutoffs.get('cer', 0):.3f})", lang)
+        uc = localize_decimal(f"P90 ({cutoffs.get('unanchored', 0):.3f})", lang)
+        dc = localize_decimal(f"P90 ({cutoffs.get('disagree', 0):.3f})", lang)
+        rule = {
+            "cer": localized(
+                lang, f"CER d'un moteur ≥ {cc}", f"an engine's CER ≥ {cc}"
+            ),
+            "unanchored": localized(
+                lang,
+                f"texte non ancré d'un moteur ≥ {uc}",
+                f"an engine's unanchored text ≥ {uc}",
+            ),
+            "disagree": localized(
+                lang,
+                f"écart CER max−min entre moteurs ≥ {dc}",
+                f"max−min CER across engines ≥ {dc}",
+            ),
+            "inserted": localized(
+                lang,
+                "≥ 1 bloc inséré sans contrepartie dans le GT",
+                "≥ 1 block inserted with no GT counterpart",
+            ),
+        }
+        items = " · ".join(
+            f"<strong>{escape(ANOMALY_LABELS[t][1 if lang == 'en' else 0])}</strong> : "
+            f"{rule[t]}"
+            for t in present
+        )
+        head = localized(
+            lang,
+            "⚑ Anomalies (seuils relatifs au run, P90 de la distribution observée) — ",
+            "⚑ Anomalies (run-relative cutoffs, P90 of the observed distribution) — ",
+        )
+        return f'<p class="muted anom-legend">{head}{items}.</p>\n'
+
+
+__all__ = ["DocumentGallerySection"]
diff --git a/cinoc/reports/sections/key_measures.py b/cinoc/reports/sections/key_measures.py
new file mode 100644
index 0000000000000000000000000000000000000000..75151c7ed1bfcc524862b2b4192f78c36d4c1288
--- /dev/null
+++ b/cinoc/reports/sections/key_measures.py
@@ -0,0 +1,231 @@
+"""Section Mesures clés : **socle chiffré neutre** par vue (couche 7).
+
+Le **headline** du rapport : les scores standard (CER/WER/FCA/exactitude/cMER)
+par moteur, en table **triable** (colonnes annotées du sens de lecture ↓/↑), un
+**dot plot classé** du CER avec **IC 95 % bootstrap** (calculé en couche
+evaluation — montre l'écart *et* son incertitude), et le **résultat du test**
+inter-moteurs comme **fait** (Nemenyi corrigé ou Wilcoxon).
+
+**Aucun verdict** : pas de « meilleur » déclaré, pas de recommandation. On trie
+par une valeur mesurée, on affiche un fait statistique — l'utilisateur interprète
+(remplace l'ancienne « Synthèse » qui nommait un gagnant ; cf. moteur narratif
+supprimé §6, anti-hallucination §12). Gatée sur ``cer``.
+"""
+
+from __future__ import annotations
+
+from cinoc.evaluation.analysis import InferencePayload
+from cinoc.evaluation.result import PipelineResult, RunResult
+from cinoc.reports._numbers import localize_decimal
+from cinoc.reports.engine_badges import (
+    engine_accent,
+    engine_cell,
+    engine_letter,
+    engine_order,
+)
+from cinoc.reports.html import escape, localized, view_label
+from cinoc.reports.section import Html, SectionContext
+from cinoc.reports.sections._tables import ordered_unique
+from cinoc.reports.svg import dot_plot_ci
+
+_PRIMARY = "cer"
+#: Scores standard (ICDAR/HIPE) du headline : ``(clé, plus_haut_est_meilleur,
+#: libellé_fr, libellé_en)``. Ordre fixe ; seuls ceux présents dans la vue sont
+#: rendus. Le sens de lecture (↓/↑) est annoté en en-tête (donnée d'affichage).
+_HEADLINE: tuple[tuple[str, bool, str, str], ...] = (
+    ("cer", False, "CER", "CER"),
+    ("wer", False, "WER", "WER"),
+    ("fca", True, "FCA", "FCA"),
+    ("char_accuracy", True, "Exact. car.", "Char acc."),
+    ("word_accuracy", True, "Exact. mot", "Word acc."),
+    ("cmer", False, "cMER", "cMER"),
+)
+
+
+def _val(pipeline: PipelineResult, metric: str) -> float | None:
+    return next((s.value for s in pipeline.aggregate if s.metric == metric), None)
+
+
+def _inference(result: RunResult, view: str) -> InferencePayload | None:
+    for analysis in result.analyses:
+        payload = analysis.payload
+        if (
+            analysis.view == view
+            and isinstance(payload, InferencePayload)
+            and payload.metric == _PRIMARY
+        ):
+            return payload
+    return None
+
+
+def _significance_p(result: RunResult, view: str) -> float | None:
+    for score in result.cross_engine:
+        parts = score.metric.split(":")
+        if len(parts) >= 2 and parts[0] == view and parts[1] == _PRIMARY:
+            return score.value
+    return None
+
+
+class KeyMeasuresSection:
+    """Scores standard par moteur (triables) + dot plot CER (IC 95 %) + test."""
+
+    name = "key_measures"
+    requires: tuple[str, ...] = (_PRIMARY,)
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        if not any(_val(p, _PRIMARY) is not None for p in result.pipelines):
+            return None  # gatée sur le CER (cf. ``requires``)
+        order = engine_order(p.pipeline for p in result.pipelines)
+        lang = ctx.lang
+        views = ordered_unique(p.view for p in result.pipelines)
+        multi = len(views) > 1
+        blocks: list[str] = []
+        for view in views:
+            pipes = [p for p in result.pipelines if p.view == view]
+            cols = [
+                (m, hib, fr, en)
+                for m, hib, fr, en in _HEADLINE
+                if any(_val(p, m) is not None for p in pipes)
+            ]
+            if not cols:
+                continue
+            head = ""
+            if multi:
+                head = f"<h3>{escape(view_label(view, lang))}</h3>\n"
+            blocks.append(
+                head
+                + self._table(pipes, cols, order, lang)
+                + self._dotplot(result, view, order, lang)
+                + self._significance(result, view, lang)
+            )
+        if not blocks:
+            return None
+        title = localized(lang, "Mesures clés", "Key measures")
+        caption = localized(
+            lang,
+            "Scores standard par moteur (↓ = plus bas est meilleur · ↑ = plus haut "
+            "est meilleur). <strong>Triez</strong> par n'importe quelle colonne. "
+            "Aucun gagnant n'est déclaré : les chiffres et le test sont fournis, "
+            "l'interprétation vous revient.",
+            "Standard scores per engine (↓ = lower is better · ↑ = higher is "
+            "better). <strong>Sort</strong> by any column. No winner is declared: "
+            "figures and the test are provided; interpretation is yours.",
+        )
+        return Html(
+            f"<h2>{title}</h2>\n<p class=\"muted\">{caption}</p>\n" + "".join(blocks)
+        )
+
+    @staticmethod
+    def _table(
+        pipes: list[PipelineResult],
+        cols: list[tuple[str, bool, str, str]],
+        order: dict[str, int],
+        lang: str,
+    ) -> str:
+        th_engine = localized(lang, "Moteur", "Engine")
+        headers = "".join(
+            f'<th class="num-cell sortable" aria-sort="none">'
+            f'{escape(en if lang == "en" else fr)} {"↑" if hib else "↓"}</th>'
+            for _m, hib, fr, en in cols
+        )
+        ranked = sorted(
+            pipes,
+            key=lambda p: (
+                _val(p, _PRIMARY) is None,
+                _val(p, _PRIMARY) if _val(p, _PRIMARY) is not None else 0.0,
+                p.pipeline,
+            ),
+        )
+        body: list[str] = []
+        for p in ranked:
+            cells = ""
+            for m, _hib, _fr, _en in cols:
+                v = _val(p, m)
+                if v is None:
+                    cells += '<td class="disp muted">—</td>'
+                else:
+                    disp = localize_decimal(f"{v:.4f}", lang)
+                    cells += f'<td class="disp" data-sort="{v:.6f}">{disp}</td>'
+            badge = engine_cell(p.pipeline, order.get(p.pipeline, 0))
+            body.append(f'<tr><td class="eng-cell">{badge}</td>{cells}</tr>')
+        return (
+            '<table class="data sortable">\n<thead><tr>'
+            f"<th>{th_engine}</th>{headers}</tr></thead>\n"
+            f"<tbody>{''.join(body)}</tbody>\n</table>\n"
+        )
+
+    @staticmethod
+    def _dotplot(
+        result: RunResult, view: str, order: dict[str, int], lang: str
+    ) -> str:
+        payload = _inference(result, view)
+        if payload is None or not payload.intervals:
+            return ""
+        items = sorted(payload.intervals, key=lambda it: (it.mean, it.pipeline))
+        rows = [
+            (
+                engine_letter(order.get(it.pipeline, 0)),
+                engine_accent(order.get(it.pipeline, 0)),
+                it.mean,
+                it.lower,
+                it.upper,
+            )
+            for it in items
+        ]
+        scale_max = max(it.upper for it in items)
+        n = max((it.n_documents for it in items), default=0)
+        cap = localized(
+            lang,
+            f'<span class="muted">CER par moteur — point = moyenne, barre = IC 95 % '
+            f"(bootstrap, n={n}), trié par CER croissant, axe commun.</span>",
+            f'<span class="muted">CER per engine — dot = mean, bar = 95 % CI '
+            f"(bootstrap, n={n}), sorted by CER, shared axis.</span>",
+        )
+        return (
+            f'<div class="prof-chart"><div class="drill-caption">{cap}</div>'
+            f"{dot_plot_ci(rows, scale_max)}</div>\n"
+        )
+
+    @staticmethod
+    def _significance(result: RunResult, view: str, lang: str) -> str:
+        payload = _inference(result, view)
+        if payload is not None and payload.critical_distance is not None:
+            groups = " · ".join(
+                "{" + ", ".join(escape(p) for p in g) + "}"
+                for g in payload.tied_groups
+            )
+            alpha = localize_decimal(f"{payload.alpha:g}", lang)
+            cd = localize_decimal(f"{payload.critical_distance:.3f}", lang)
+            txt = localized(
+                lang,
+                f"<strong>Test inter-moteurs (CER)</strong> — post-hoc Nemenyi "
+                f"(α={alpha}, CD={cd}, "
+                f"{payload.n_documents} cas complets) : groupes d'indiscernables "
+                f"{groups}. Deux moteurs hors d'un même groupe = différence "
+                f"significative.",
+                f"<strong>Inter-engine test (CER)</strong> — Nemenyi post-hoc "
+                f"(α={alpha}, CD={cd}, "
+                f"{payload.n_documents} complete cases): indistinguishable groups "
+                f"{groups}. Two engines outside one group = significant difference.",
+            )
+            return f'<p class="muted">{txt}</p>\n'
+        p = _significance_p(result, view)
+        if p is not None:
+            verdict = localized(
+                lang,
+                "significative" if p < 0.05 else "non significative",
+                "significant" if p < 0.05 else "not significant",
+            )
+            pv = localize_decimal(f"{p:.4f}", lang)
+            txt = localized(
+                lang,
+                f"<strong>Test inter-moteurs (CER)</strong> — Wilcoxon : p = "
+                f"{pv} → différence {verdict} au seuil α = 0,05.",
+                f"<strong>Inter-engine test (CER)</strong> — Wilcoxon: p = "
+                f"{pv} → difference {verdict} at α = 0.05.",
+            )
+            return f'<p class="muted">{txt}</p>\n'
+        return ""
+
+
+__all__ = ["KeyMeasuresSection"]
diff --git a/cinoc/reports/sections/lines.py b/cinoc/reports/sections/lines.py
new file mode 100644
index 0000000000000000000000000000000000000000..fda8f1c29018588662c358cace5987d8cfa60f3b
--- /dev/null
+++ b/cinoc/reports/sections/lines.py
@@ -0,0 +1,150 @@
+"""Section distribution par ligne : rend le payload ``lines`` au design.
+
+Lecture seule du payload (aucun recalcul) : par pipeline, la distribution du
+CER par ligne — percentiles, Gini, taux de lignes catastrophiques — puis la
+heatmap positionnelle (où, dans les documents, les erreurs se concentrent).
+Pédagogie en prose, aucun scalaire de classement (pas de glossaire).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+from cinoc.evaluation.analysis import LinesPayload, PipelineLines
+from cinoc.evaluation.result import RunResult
+from cinoc.reports._numbers import localize_decimal
+from cinoc.reports.engine_badges import engine_cell, engine_order
+from cinoc.reports.html import localized
+from cinoc.reports.section import Html, SectionContext
+from cinoc.reports.sections._payload import render_payload_section
+
+
+def _distribution_row(
+    row: PipelineLines, order: Mapping[str, int], lang: str
+) -> str:
+    badge = engine_cell(row.pipeline, order.get(row.pipeline, 0))
+    p = row.percentiles
+    catastrophic = " · ".join(
+        f"≥{localize_decimal(f'{item.threshold:.2f}', lang)} : "
+        f"{localize_decimal(f'{item.rate:.1%}', lang)}"
+        for item in row.catastrophic
+    )
+    return (
+        f'<tr><td class="eng-cell">{badge}</td>'
+        f'<td class="disp">{row.line_count}</td>'
+        f'<td class="disp">{localize_decimal(f"{row.mean_cer:.1%}", lang)}</td>'
+        f'<td class="disp">{localize_decimal(f"{p.p50:.1%}", lang)}</td>'
+        f'<td class="disp">{localize_decimal(f"{p.p75:.1%}", lang)}</td>'
+        f'<td class="disp">{localize_decimal(f"{p.p90:.1%}", lang)}</td>'
+        f'<td class="disp">{localize_decimal(f"{p.p95:.1%}", lang)}</td>'
+        f'<td class="disp">{localize_decimal(f"{p.p99:.1%}", lang)}</td>'
+        f'<td class="disp">{localize_decimal(f"{row.gini:.3f}", lang)}</td>'
+        f'<td class="disp">{catastrophic}</td></tr>'
+    )
+
+
+def _heatmap_row(row: PipelineLines, order: Mapping[str, int], lang: str) -> str:
+    badge = engine_cell(row.pipeline, order.get(row.pipeline, 0))
+    cells = "".join(
+        f'<td class="disp">{localize_decimal(f"{value:.1%}", lang)}</td>'
+        if value is not None
+        else '<td class="disp">—</td>'
+        for value in row.heatmap
+    )
+    return f'<tr><td class="eng-cell">{badge}</td>{cells}</tr>'
+
+
+def _block(
+    view: str, payload: LinesPayload, order: Mapping[str, int], lang: str
+) -> str:
+    rows = "".join(
+        _distribution_row(row, order, lang) for row in payload.pipelines
+    )
+    heatmap_rows = "".join(
+        _heatmap_row(row, order, lang) for row in payload.pipelines
+    )
+    bin_headers = "".join(
+        f'<th class="num-cell">{i + 1}/{payload.heatmap_bins}</th>'
+        for i in range(payload.heatmap_bins)
+    )
+    dist_head = localized(
+        lang,
+        f"{view}distribution du CER par ligne",
+        f"{view}per-line CER distribution",
+    )
+    dist_prose = localized(
+        lang,
+        '<p class="muted">Toutes les lignes GT du corpus, appariées aux lignes '
+        "produites par alignement (une ligne insérée/supprimée ne décale pas "
+        "les suivantes ; ligne perdue = CER 1,0). Le Gini lit la "
+        "concentration : 0 = erreurs uniformes (correction rapide partout), "
+        "1 = concentrées sur quelques lignes détruites (re-saisie locale). "
+        "« Catastrophiques » = part des lignes au CER ≥ seuil.</p>\n",
+        '<p class="muted">All GT lines of the corpus, matched to the lines '
+        "produced by alignment (an inserted/deleted line does not shift "
+        "the following ones; lost line = CER 1.0). Gini reads the "
+        "concentration: 0 = uniform errors (fast correction everywhere), "
+        "1 = concentrated on a few destroyed lines (local re-keying). "
+        '"Catastrophic" = share of lines with CER ≥ threshold.</p>\n',
+    )
+    th_pipeline = localized(lang, "Pipeline", "Pipeline")
+    th_lines = localized(lang, "lignes", "lines")
+    th_mean_cer = localized(lang, "CER moyen", "mean CER")
+    th_catastrophic = localized(lang, "catastrophiques", "catastrophic")
+    heat_head = localized(
+        lang,
+        f"{view}heatmap positionnelle (début → fin de document)",
+        f"{view}positional heatmap (document start → end)",
+    )
+    heat_prose = localized(
+        lang,
+        '<p class="muted">CER moyen par tranche de position relative dans le '
+        "document — un moteur qui décroche en bas de page (fatigue de "
+        "colonne, marges) se voit ici ; « — » = aucune ligne dans la "
+        "tranche.</p>\n",
+        '<p class="muted">Mean CER per slice of relative position within the '
+        "document — an engine that drops off at the bottom of the page (column "
+        'fatigue, margins) shows up here; "—" = no line in the '
+        "slice.</p>\n",
+    )
+    return (
+        f"<h3>{dist_head}</h3>\n"
+        f"{dist_prose}"
+        f'<table class="data">\n<thead><tr><th>{th_pipeline}</th>'
+        f'<th class="num-cell">{th_lines}</th>'
+        f'<th class="num-cell">{th_mean_cer}</th>'
+        '<th class="num-cell">p50</th><th class="num-cell">p75</th>'
+        '<th class="num-cell">p90</th><th class="num-cell">p95</th>'
+        '<th class="num-cell">p99</th><th class="num-cell">Gini</th>'
+        f"<th>{th_catastrophic}</th></tr></thead>\n"
+        f"<tbody>{rows}</tbody>\n</table>\n"
+        f"<h3>{heat_head}</h3>\n"
+        f"{heat_prose}"
+        f'<table class="data">\n<thead><tr><th>{th_pipeline}</th>'
+        f"{bin_headers}</tr></thead>\n"
+        f"<tbody>{heatmap_rows}</tbody>\n</table>\n"
+    )
+
+
+class LinesSection:
+    """Distribution du CER par ligne, par pipeline (lecture seule)."""
+
+    name = "lines"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        order = engine_order(p.pipeline for p in result.pipelines)
+        return render_payload_section(
+            result,
+            ctx,
+            payload_type=LinesPayload,
+            title=localized(
+                ctx.lang,
+                "Distribution des erreurs par ligne",
+                "Per-line error distribution",
+            ),
+            block=lambda view, payload: _block(view, payload, order, ctx.lang),
+        )
+
+
+__all__ = ["LinesSection"]
diff --git a/cinoc/reports/sections/methodology.py b/cinoc/reports/sections/methodology.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b00e92296db0ec7aae04514f5b1165528d104e3
--- /dev/null
+++ b/cinoc/reports/sections/methodology.py
@@ -0,0 +1,170 @@
+"""Section méthodologie & reproductibilité (couche 7).
+
+Appendice **toujours visible** (hors onglets, comme le glossaire) : explicite le
+corpus, les moteurs, les métriques, les **vues d'évaluation** (profil de
+normalisation, caractères exclus, dimensions ignorées, avertissements),
+l'environnement (binaires, dépendances, versions de modules) et les conventions
+de calcul — tout dérivé du ``RunManifest`` et du ``RunResult`` (aucune valeur
+fabriquée ; un champ absent n'est pas affiché).
+"""
+
+from __future__ import annotations
+
+from cinoc.domain.evaluation import EvaluationView
+from cinoc.evaluation.result import RunResult
+from cinoc.reports.html import escape, localized
+from cinoc.reports.section import Html, SectionContext
+
+
+def _kv(label: str, value: str) -> str:
+    return f'<tr><td class="lbl">{escape(label)}</td><td class="lbl">{value}</td></tr>'
+
+
+def _locks(title: str, mapping: dict[str, str]) -> str:
+    """``<details>`` natif d'un lock ``{nom: version}`` ; vide → ``""``."""
+    if not mapping:
+        return ""
+    rows = "".join(
+        f'<tr><td class="lbl">{escape(k)}</td><td class="disp">{escape(v)}</td></tr>'
+        for k, v in sorted(mapping.items())
+    )
+    return (
+        f'<details><summary class="muted">{escape(title)}</summary>\n'
+        f'<table class="data compact"><tbody>{rows}</tbody></table></details>'
+    )
+
+
+def _view_block(view: EvaluationView, lang: str) -> str:
+    """Métadonnées méthodologiques d'une vue (champs présents seulement)."""
+    rows = ""
+    if view.description:
+        rows += _kv(
+            localized(lang, "Description", "Description"), escape(view.description)
+        )
+    rows += _kv(
+        localized(lang, "Normalisation", "Normalisation"),
+        escape(view.normalization_profile or localized(lang, "aucune", "none")),
+    )
+    if view.char_exclude:
+        rows += _kv(
+            localized(lang, "Caractères exclus", "Excluded characters"),
+            escape(view.char_exclude),
+        )
+    if view.metric_names:
+        rows += _kv(
+            localized(lang, "Métriques", "Metrics"),
+            escape(", ".join(view.metric_names)),
+        )
+    if view.ignored_dimensions:
+        rows += _kv(
+            localized(lang, "Dimensions ignorées", "Ignored dimensions"),
+            escape(", ".join(view.ignored_dimensions)),
+        )
+    for w in view.warnings:
+        rows += _kv(localized(lang, "Avertissement", "Warning"), escape(w))
+    return (
+        f"<h3>{escape(view.name)}</h3>\n"
+        f'<table class="data compact"><tbody>{rows}</tbody></table>\n'
+    )
+
+
+class MethodologySection:
+    """Méthodologie & reproductibilité — appendice toujours visible."""
+
+    name = "methodology"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        m = result.manifest
+        lang = ctx.lang
+        eval_docs = len({d.document_id for d in result.documents})
+        engines = sorted({p.pipeline for p in result.pipelines})
+        metrics = sorted({s.metric for p in result.pipelines for s in p.aggregate})
+        # Documents : taille du corpus ; nombre réellement évalué si différent.
+        docs_val = str(m.n_documents)
+        if eval_docs and eval_docs != m.n_documents:
+            docs_val += localized(
+                lang, f" (évalués : {eval_docs})", f" (evaluated: {eval_docs})"
+            )
+        run_rows = (
+            _kv(localized(lang, "Corpus", "Corpus"), escape(m.corpus_name))
+            + _kv(localized(lang, "Documents", "Documents"), escape(docs_val))
+            + _kv(
+                localized(lang, "Moteurs", "Engines"),
+                escape(", ".join(engines)) or "—",
+            )
+            + _kv(
+                localized(lang, "Métriques", "Metrics"),
+                escape(", ".join(metrics)) or "—",
+            )
+            + _kv(
+                localized(lang, "Date", "Date"),
+                escape(m.completed_at.date().isoformat()),
+            )
+            + _kv(
+                localized(lang, "Version du code", "Code version"),
+                escape(m.code_version),
+            )
+        )
+        views = "".join(_view_block(v, lang) for v in m.view_specs)
+        views_html = (
+            f"<h2>{localized(lang, 'Vues d’évaluation', 'Evaluation views')}</h2>\n"
+            f"{views}"
+            if views
+            else ""
+        )
+        env = (
+            _locks(
+                localized(lang, "Binaires système", "System binaries"),
+                m.system_binaries_lock,
+            )
+            + _locks(
+                localized(lang, "Versions de modules", "Module versions"),
+                m.module_versions,
+            )
+            + _locks(
+                localized(lang, "Dépendances", "Dependencies"),
+                m.dependencies_lock,
+            )
+        )
+        env_html = (
+            f"<h2>{localized(lang, 'Environnement', 'Environment')}</h2>\n{env}"
+            if env
+            else ""
+        )
+        conventions = localized(
+            lang,
+            "<b>Conventions.</b> Les métriques d’erreur (CER, WER, MER) sont des "
+            "distances d’édition normalisées par la longueur de la référence "
+            "(plus bas = mieux). Les agrégats affichés sont des macro-moyennes "
+            "par document, sauf mention « micro ». Une valeur absente est rendue "
+            "« — », jamais interprétée comme zéro. Un document non produit par un "
+            "moteur est omis de ses agrégats (pas de score factice). La "
+            "normalisation typographique est appliquée avant comparaison selon le "
+            "profil de chaque vue (ci-dessus).",
+            "<b>Conventions.</b> Error metrics (CER, WER, MER) are edit distances "
+            "normalised by reference length (lower is better). Displayed aggregates "
+            "are per-document macro-averages unless marked “micro”. A missing value "
+            "renders as “—”, never as zero. A document not produced by an engine is "
+            "omitted from its aggregates (no fake score). Typographic normalisation "
+            "is applied before comparison per each view’s profile (above).",
+        )
+        title = localized(
+            lang, "Méthodologie & reproductibilité", "Methodology & reproducibility"
+        )
+        intro = localized(
+            lang,
+            "Ce que mesure le benchmark, sur quel corpus, avec quels moteurs et "
+            "quelles conventions — pour interpréter et reproduire les résultats.",
+            "What the benchmark measures, on which corpus, with which engines and "
+            "conventions — to interpret and reproduce the results.",
+        )
+        return Html(
+            f"<h1>{title}</h1>\n<p class=\"muted\">{intro}</p>\n"
+            f'<table class="data compact"><tbody>{run_rows}</tbody></table>\n'
+            f"{views_html}{env_html}"
+            f'<p class="muted">{conventions}</p>\n'
+        )
+
+
+__all__ = ["MethodologySection"]
diff --git a/cinoc/reports/sections/ner.py b/cinoc/reports/sections/ner.py
new file mode 100644
index 0000000000000000000000000000000000000000..d8b7f60c2aa938c325eeb58f8a2415282809001d
--- /dev/null
+++ b/cinoc/reports/sections/ner.py
@@ -0,0 +1,163 @@
+"""Section entités nommées : précision/rappel/F1 par pipeline (couche 7).
+
+Lecture seule du payload ``ner`` : F1 global + détail par catégorie, échantillon
+des entités manquées et hallucinées. La prose documente la limite — la métrique
+mesure **conjointement** la qualité de l'OCR et celle de l'extracteur NER.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+from cinoc.evaluation.analysis import EntityMention, NerPayload, PipelineNer
+from cinoc.evaluation.result import RunResult
+from cinoc.reports._numbers import localize_decimal
+from cinoc.reports.engine_badges import engine_cell, engine_order
+from cinoc.reports.html import escape, localized
+from cinoc.reports.section import Html, SectionContext
+from cinoc.reports.sections._payload import render_payload_section
+
+
+def _mentions(mentions: tuple[EntityMention, ...]) -> str:
+    if not mentions:
+        return "—"
+    labels = ", ".join(
+        f"{escape(m.text)} ({escape(m.label)})" if m.text else escape(m.label)
+        for m in mentions
+    )
+    return f'<span class="muted">{labels}</span>'
+
+
+def _global_row(row: PipelineNer, order: Mapping[str, int], lang: str) -> str:
+    badge = engine_cell(row.pipeline, order.get(row.pipeline, 0))
+    return (
+        f'<tr><td class="eng-cell">{badge}</td>'
+        f'<td class="disp">{row.n_reference}</td>'
+        f'<td class="disp">{localize_decimal(f"{row.precision:.1%}", lang)}</td>'
+        f'<td class="disp">{localize_decimal(f"{row.recall:.1%}", lang)}</td>'
+        f'<td class="disp">{localize_decimal(f"{row.f1:.1%}", lang)}</td>'
+        f'<td class="disp">{row.true_positives}/{row.false_positives}'
+        f"/{row.false_negatives}</td></tr>"
+    )
+
+
+def _category_rows(row: PipelineNer, order: Mapping[str, int], lang: str) -> str:
+    rows: list[str] = []
+    for cat in row.per_category:
+        badge = engine_cell(row.pipeline, order.get(row.pipeline, 0))
+        rows.append(
+            f'<tr><td class="eng-cell">{badge}</td>'
+            f'<td class="eng-cell">{escape(cat.label)}</td>'
+            f'<td class="disp">{cat.support}</td>'
+            f'<td class="disp">{localize_decimal(f"{cat.precision:.1%}", lang)}</td>'
+            f'<td class="disp">{localize_decimal(f"{cat.recall:.1%}", lang)}</td>'
+            f'<td class="disp">{localize_decimal(f"{cat.f1:.1%}", lang)}</td></tr>'
+        )
+    return "".join(rows)
+
+
+def _samples_rows(row: PipelineNer, order: Mapping[str, int]) -> str:
+    badge = engine_cell(row.pipeline, order.get(row.pipeline, 0))
+    return (
+        f'<tr><td class="eng-cell">{badge}</td>'
+        f"<td>{_mentions(row.missed)}</td>"
+        f"<td>{_mentions(row.hallucinated)}</td></tr>"
+    )
+
+
+def _block(
+    view: str, payload: NerPayload, order: Mapping[str, int], lang: str
+) -> str:
+    global_rows = "".join(
+        _global_row(row, order, lang) for row in payload.pipelines
+    )
+    category_rows = "".join(
+        _category_rows(row, order, lang) for row in payload.pipelines
+    )
+    samples_rows = "".join(_samples_rows(row, order) for row in payload.pipelines)
+    iou = localize_decimal(f"{payload.iou_threshold:.2f}", lang)
+    th_pipeline = localized(lang, "Pipeline", "Pipeline")
+    th_precision = localized(lang, "précision", "precision")
+    th_recall = localized(lang, "rappel", "recall")
+    global_head = localized(
+        lang,
+        f"{view}entités nommées (IoU ≥ {iou})",
+        f"{view}named entities (IoU ≥ {iou})",
+    )
+    global_prose = localized(
+        lang,
+        '<p class="muted">Part des entités de la GT retrouvées dans la sortie, '
+        "spans alignés en coordonnées GT (un décalage d'OCR amont ne pénalise "
+        "pas une entité bien transcrite). La mesure est <strong>conjointe</strong> "
+        "— elle reflète l'OCR <em>et</em> l'extracteur NER. TP/FP/FN = vrais "
+        "positifs / hallucinés / manqués.</p>\n",
+        '<p class="muted">Share of GT entities found in the output, '
+        "spans aligned in GT coordinates (an upstream OCR shift does not penalize "
+        "a well-transcribed entity). The measure is <strong>joint</strong> "
+        "— it reflects the OCR <em>and</em> the NER extractor. TP/FP/FN = true "
+        "positives / hallucinated / missed.</p>\n",
+    )
+    th_gt_entities = localized(lang, "entités GT", "GT entities")
+    blocks = (
+        f"<h3>{global_head}</h3>\n"
+        f"{global_prose}"
+        f'<table class="data">\n<thead><tr><th>{th_pipeline}</th>'
+        f'<th class="num-cell">{th_gt_entities}</th>'
+        f'<th class="num-cell">{th_precision}</th>'
+        f'<th class="num-cell">{th_recall}</th><th class="num-cell">F1</th>'
+        '<th class="num-cell">TP/FP/FN</th></tr></thead>\n'
+        f"<tbody>{global_rows}</tbody>\n</table>\n"
+    )
+    if category_rows:
+        cat_head = localized(
+            lang,
+            f"{view}F1 par catégorie",
+            f"{view}F1 per category",
+        )
+        th_category = localized(lang, "catégorie", "category")
+        th_support = localized(lang, "support", "support")
+        blocks += (
+            f"<h3>{cat_head}</h3>\n"
+            f'<table class="data">\n<thead><tr><th>{th_pipeline}</th>'
+            f"<th>{th_category}</th>"
+            f'<th class="num-cell">{th_support}</th>'
+            f'<th class="num-cell">{th_precision}</th>'
+            f'<th class="num-cell">{th_recall}</th><th class="num-cell">F1</th>'
+            "</tr></thead>\n"
+            f"<tbody>{category_rows}</tbody>\n</table>\n"
+        )
+    samples_head = localized(
+        lang,
+        f"{view}entités manquées &amp; hallucinées (échantillon)",
+        f"{view}missed &amp; hallucinated entities (sample)",
+    )
+    th_missed = localized(lang, "manquées", "missed")
+    th_hallucinated = localized(lang, "hallucinées", "hallucinated")
+    blocks += (
+        f"<h3>{samples_head}</h3>\n"
+        f'<table class="data">\n<thead><tr><th>{th_pipeline}</th>'
+        f"<th>{th_missed}</th>"
+        f"<th>{th_hallucinated}</th></tr></thead>\n"
+        f"<tbody>{samples_rows}</tbody>\n</table>\n"
+    )
+    return blocks
+
+
+class NerSection:
+    """Précision sur entités nommées, par pipeline (lecture seule)."""
+
+    name = "ner"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        order = engine_order(p.pipeline for p in result.pipelines)
+        return render_payload_section(
+            result,
+            ctx,
+            payload_type=NerPayload,
+            title=localized(ctx.lang, "Entités nommées", "Named entities"),
+            block=lambda view, payload: _block(view, payload, order, ctx.lang),
+        )
+
+
+__all__ = ["NerSection"]
diff --git a/cinoc/reports/sections/overview.py b/cinoc/reports/sections/overview.py
new file mode 100644
index 0000000000000000000000000000000000000000..4baf10571c0224f3f9536ff66050be2695fbd249
--- /dev/null
+++ b/cinoc/reports/sections/overview.py
@@ -0,0 +1,90 @@
+"""Section overview : bande de **readouts** (portée du corpus) + une table par
+vue, pipelines × métriques, avec **data-bars** proportionnelles. Couche 7.
+
+Le contenu reste piloté par les **vraies** métriques de ``RunResult`` (ce que le
+moteur calcule : CER/WER/MER aujourd'hui) — **jamais** par les métriques que le
+design *dessine* mais que le moteur ne produit pas encore (note d'archi :
+pas de rapport en avance sur sa donnée). Les sections plus riches arrivent au fil
+des métriques.
+"""
+
+from __future__ import annotations
+
+from cinoc.evaluation.result import RunResult
+from cinoc.reports.engine_badges import engine_cell, engine_order
+from cinoc.reports.html import escape, localized, view_label
+from cinoc.reports.section import Html, SectionContext
+from cinoc.reports.sections._tables import (
+    bar_cell,
+    bar_legend,
+    col_max,
+    group_header_row,
+    metric_short_label,
+    nonempty_metric_indices,
+    ordered_unique,
+)
+
+
+class OverviewSection:
+    """Métriques par vue (data-bars). La **portée** (docs/moteurs) vit dans le
+    héros de la vue (rendu par le renderer), plus dans une bande de readouts ici."""
+
+    name = "overview"
+    requires: tuple[str, ...] = ()  # générique : affiche les métriques présentes
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        if not result.pipelines:
+            return None
+        views = ordered_unique(p.view for p in result.pipelines)
+        corpus = localized(ctx.lang, "Corpus", "Corpus")
+        parts: list[str] = [
+            f"<h2>{localized(ctx.lang, 'Métriques par vue', 'Metrics per view')}</h2>",
+            f'<p class="muted">{corpus} : '
+            f"{escape(result.manifest.corpus_name)}</p>",
+        ]
+        multi = len(views) > 1
+        for view_name in views:
+            parts.append(_table_for_view(result, view_name, ctx.lang, multi=multi))
+        return Html("\n".join(parts) + "\n")
+
+
+def _table_for_view(
+    result: RunResult, view_name: str, lang: str, *, multi: bool
+) -> str:
+    pipelines = [p for p in result.pipelines if p.view == view_name]
+    order = engine_order(p.pipeline for p in result.pipelines)
+    rows = [p.aggregate for p in pipelines]
+    keep = nonempty_metric_indices(rows)  # masque les colonnes tout-« — »
+    all_metrics = tuple(score.metric for score in pipelines[0].aggregate)
+    metrics = [all_metrics[i] for i in keep]
+    header = "".join(
+        f'<th class="num-cell" title="{escape(m)}">'
+        f"{escape(metric_short_label(m))}</th>"
+        for m in metrics
+    )
+    maxes = [col_max(rows, i) for i in keep]
+    body_rows: list[str] = []
+    for pipeline in pipelines:
+        cells = "".join(
+            bar_cell(pipeline.aggregate[i], maxes[j], lang=lang)
+            for j, i in enumerate(keep)
+        )
+        badge = engine_cell(pipeline.pipeline, order.get(pipeline.pipeline, 0))
+        body_rows.append(f'<tr><td class="eng-cell">{badge}</td>{cells}</tr>')
+    # Libellé de vue affiché **seulement** s'il y a plusieurs vues à distinguer
+    # (sinon « Métriques par vue » + la ligne corpus suffisent — pas de ressassage).
+    head = ""
+    if multi:
+        view_caption = localized(lang, "Vue", "View")
+        head = f"<h2>{view_caption} : {escape(view_label(view_name, lang))}</h2>\n"
+    return (
+        f"{head}"
+        '<div class="table-scroll">'
+        f'<table class="data">\n<thead>{group_header_row(metrics, lang, lead=1)}'
+        f"<tr><th>Pipeline</th>{header}</tr></thead>\n"
+        f"<tbody>{''.join(body_rows)}</tbody>\n</table></div>\n"
+        f"{bar_legend(lang)}"
+    )
+
+
+__all__ = ["OverviewSection"]
diff --git a/cinoc/reports/sections/philology.py b/cinoc/reports/sections/philology.py
new file mode 100644
index 0000000000000000000000000000000000000000..af4ff3ce64c3654b9f5a9aa98829f532111f287a
--- /dev/null
+++ b/cinoc/reports/sections/philology.py
@@ -0,0 +1,288 @@
+"""Section philologie : préservation des marqueurs philologiques (couche 7).
+
+Rend le payload ``philology`` en **lecture seule**. Deux lentilles selon la
+famille : pour les **abréviations** scribales, la part des signes reproduits **à
+l'identique** (strict) vs **développés** (expansion) ; pour la **typographie de
+l'imprimé ancien**, la part des marqueurs restitués **à leur position**
+(préservation, un seul score). La question éditoriale diplomatique-vs-modernisante,
+que le CER global ne distingue pas.
+"""
+
+from __future__ import annotations
+
+from cinoc.evaluation.analysis import (
+    PhilologyPayload,
+    PipelinePhilology,
+    PipelineRomanNumerals,
+    RomanNumeralsPayload,
+)
+from cinoc.evaluation.result import RunResult
+from cinoc.reports._numbers import localize_decimal
+from cinoc.reports.html import escape, localized, view_prefix
+from cinoc.reports.section import Html, SectionContext
+
+#: Statuts romains : clé → libellé lisible bilingue (ordre de rendu).
+_ROMAN_STATUS_LABELS: tuple[tuple[str, str, str], ...] = (
+    ("strict_preserved", "forme stricte", "strict form"),
+    ("case_changed", "casse modifiée", "case changed"),
+    ("j_dropped", "j médiéval standardisé", "medieval j standardized"),
+    ("converted_to_arabic", "converti en arabe", "converted to Arabic"),
+    ("lost", "perdu", "lost"),
+)
+
+_FAMILY_LABELS: dict[str, tuple[str, str]] = {
+    "abbreviations": ("abréviations médiévales", "medieval abbreviations"),
+    "early_modern": (
+        "typographie de l'imprimé ancien",
+        "early modern print typography",
+    ),
+    "modern_archives": (
+        "archives modernes (XIXᵉ-XXᵉ)",
+        "modern archives (19th-20th c.)",
+    ),
+}
+
+#: Familles à préservation **positionnelle** : un seul score (le marqueur est à
+#: sa place), sans lentille « développement ».
+_POSITIONAL_FAMILIES = frozenset({"early_modern"})
+
+#: Familles dont les lignes sont des **catégories** (libellés lisibles), pas des
+#: signes isolés.
+_CATEGORY_FAMILIES = frozenset({"early_modern", "modern_archives"})
+
+#: Libellés lisibles bilingues des catégories (imprimé ancien + archives
+#: modernes). Les glyphes entre parenthèses sont des données verbatim.
+_CATEGORY_LABELS: dict[str, tuple[str, str]] = {
+    "ligatures": ("ligatures (fi fl ff)", "ligatures (fi fl ff)"),
+    "long_s": ("s long (ſ)", "long s (ſ)"),
+    "dotless_i": ("i sans point (ı)", "dotless i (ı)"),
+    "ampersand": ("esperluette (&)", "ampersand (&)"),
+    "nasal_tildes": ("tildes nasaux (ã õ ñ)", "nasal tildes (ã õ ñ)"),
+    "civility_titles": (
+        "titres de civilité (Mme, Dr)",
+        "civility titles (Mme, Dr)",
+    ),
+    "ordinals": ("ordinaux (1ᵉʳ, XIXᵉ)", "ordinals (1ᵉʳ, XIXᵉ)"),
+    "currency": ("monnaies (₣, l., s., d.)", "currency (₣, l., s., d.)"),
+    "administrative": ("administratif (arr., dép.)", "administrative (arr., dép.)"),
+    "civil_status": ("état civil (°, †, ép.)", "civil status (°, †, ép.)"),
+    "typographic_punctuation": (
+        "ponctuation typographique (« » —)",
+        "typographic punctuation (« » —)",
+    ),
+    "latin_abbr_modern": (
+        "abréviations latines (etc., cf.)",
+        "Latin abbreviations (etc., cf.)",
+    ),
+    "bibliographic": ("bibliographie (vol., p., n°)", "bibliography (vol., p., n°)"),
+    "address": ("adresse (bd, av., r.)", "address (bd, av., r.)"),
+}
+
+
+def _share(numerator: int, denominator: int, lang: str) -> str:
+    return (
+        localize_decimal(f"{numerator / denominator:.1%}", lang)
+        if denominator
+        else "—"
+    )
+
+
+def _item_label(sign: str, by_category: bool, lang: str) -> str:
+    if by_category and sign in _CATEGORY_LABELS:
+        return localized(lang, *_CATEGORY_LABELS[sign])
+    return sign
+
+
+def _containment_block(
+    row: PipelinePhilology, family: str, by_category: bool, lang: str
+) -> str:
+    header = localized(lang, "catégorie" if by_category else "signe",
+                       "category" if by_category else "sign")
+    items = "".join(
+        f'<tr><td class="lbl">'
+        f"{escape(_item_label(marker.sign, by_category, lang))}</td>"
+        f'<td class="disp">{marker.n_total}</td>'
+        f'<td class="disp">{_share(marker.n_strict, marker.n_total, lang)}</td>'
+        f'<td class="disp">{_share(marker.n_expansion, marker.n_total, lang)}</td></tr>'
+        for marker in row.markers
+    )
+    head = localized(
+        lang,
+        f"{escape(row.pipeline)} — {escape(family)} : "
+        f"{_share(row.n_strict, row.n_total, lang)} strict · "
+        f"{_share(row.n_expansion, row.n_total, lang)} avec développement "
+        f"({row.n_total} marqueurs)",
+        f"{escape(row.pipeline)} — {escape(family)}: "
+        f"{_share(row.n_strict, row.n_total, lang)} strict · "
+        f"{_share(row.n_expansion, row.n_total, lang)} with expansion "
+        f"({row.n_total} markers)",
+    )
+    th_n = localized(lang, "n", "n")
+    th_strict = localized(lang, "strict", "strict")
+    th_expansion = localized(lang, "avec dév.", "with exp.")
+    return (
+        f"<h4>{head}</h4>\n"
+        f'<table class="data compact">\n<thead><tr><th>{header}</th>'
+        f'<th class="num-cell">{th_n}</th><th class="num-cell">{th_strict}</th>'
+        f'<th class="num-cell">{th_expansion}</th></tr></thead>\n'
+        f"<tbody>{items}</tbody>\n</table>\n"
+    )
+
+
+def _positional_block(row: PipelinePhilology, family: str, lang: str) -> str:
+    cats = "".join(
+        f'<tr><td class="lbl">'
+        f"{escape(_item_label(marker.sign, True, lang))}</td>"
+        f'<td class="disp">{marker.n_total}</td>'
+        f'<td class="disp">{_share(marker.n_strict, marker.n_total, lang)}</td></tr>'
+        for marker in row.markers
+    )
+    head = localized(
+        lang,
+        f"{escape(row.pipeline)} — {escape(family)} : "
+        f"{_share(row.n_strict, row.n_total, lang)} préservé "
+        f"({row.n_total} marqueurs)",
+        f"{escape(row.pipeline)} — {escape(family)}: "
+        f"{_share(row.n_strict, row.n_total, lang)} preserved "
+        f"({row.n_total} markers)",
+    )
+    th_category = localized(lang, "catégorie", "category")
+    th_n = localized(lang, "n", "n")
+    th_preserved = localized(lang, "préservé", "preserved")
+    return (
+        f"<h4>{head}</h4>\n"
+        f'<table class="data compact">\n<thead><tr><th>{th_category}</th>'
+        f'<th class="num-cell">{th_n}</th><th class="num-cell">{th_preserved}</th>'
+        "</tr></thead>\n"
+        f"<tbody>{cats}</tbody>\n</table>\n"
+    )
+
+
+def _pipeline_block(row: PipelinePhilology, lang: str) -> str:
+    family = localized(lang, *_FAMILY_LABELS[row.family]) \
+        if row.family in _FAMILY_LABELS else row.family
+    if row.family in _POSITIONAL_FAMILIES:
+        return _positional_block(row, family, lang)
+    return _containment_block(row, family, row.family in _CATEGORY_FAMILIES, lang)
+
+
+def _block(view: str, payload: PhilologyPayload, lang: str) -> str:
+    head = localized(
+        lang,
+        f"{view}marqueurs philologiques",
+        f"{view}philological markers",
+    )
+    prose = localized(
+        lang,
+        '<p class="muted">Préservation des conventions de la vérité terrain que '
+        "le CER global ne distingue pas. <b>Abréviations</b> (médiévales, "
+        "archives modernes) : « strict » = la forme abrégée est reproduite telle "
+        "quelle (diplomatique), « avec développement » = la forme ou son "
+        "équivalent développé est présent (modernisant) — toujours ≥ strict, "
+        "borne optimiste (un mot courant peut compter comme développement). "
+        "<b>Imprimé ancien</b> : « préservé » = le marqueur typographique "
+        "(ligature, s long, tilde nasal…) est restitué à sa position, selon le "
+        "même alignement que le CER.</p>\n",
+        '<p class="muted">Preservation of ground-truth conventions that '
+        "the global CER does not distinguish. <b>Abbreviations</b> (medieval, "
+        "modern archives): « strict » = the abbreviated form is reproduced as "
+        "is (diplomatic), « with expansion » = the form or its "
+        "expanded equivalent is present (modernizing) — always ≥ strict, "
+        "an optimistic bound (a common word may count as an expansion). "
+        "<b>Early modern print</b>: « preserved » = the typographic marker "
+        "(ligature, long s, nasal tilde…) is restored at its position, under the "
+        "same alignment as the CER.</p>\n",
+    )
+    return (
+        f"<h3>{head}</h3>\n"
+        + prose
+        + "".join(_pipeline_block(row, lang) for row in payload.pipelines)
+    )
+
+
+def _roman_pipeline_block(row: PipelineRomanNumerals, lang: str) -> str:
+    counts = {
+        "strict_preserved": row.strict_preserved,
+        "case_changed": row.case_changed,
+        "j_dropped": row.j_dropped,
+        "converted_to_arabic": row.converted_to_arabic,
+        "lost": row.lost,
+    }
+    rows = "".join(
+        f'<tr><td class="lbl">{escape(localized(lang, label_fr, label_en))}</td>'
+        f'<td class="disp">{counts[key]}</td>'
+        f'<td class="disp">{_share(counts[key], row.n_total, lang)}</td></tr>'
+        for key, label_fr, label_en in _ROMAN_STATUS_LABELS
+    )
+    value_preserved = row.n_total - row.lost
+    head = localized(
+        lang,
+        f"{escape(row.pipeline)} — numéraux romains : "
+        f"{_share(row.strict_preserved, row.n_total, lang)} strict · "
+        f"{_share(value_preserved, row.n_total, lang)} valeur préservée "
+        f"({row.n_total} numéraux)",
+        f"{escape(row.pipeline)} — Roman numerals: "
+        f"{_share(row.strict_preserved, row.n_total, lang)} strict · "
+        f"{_share(value_preserved, row.n_total, lang)} value preserved "
+        f"({row.n_total} numerals)",
+    )
+    th_status = localized(lang, "statut", "status")
+    th_n = localized(lang, "n", "n")
+    th_share = localized(lang, "part", "share")
+    return (
+        f"<h4>{head}</h4>\n"
+        f'<table class="data compact">\n<thead><tr><th>{th_status}</th>'
+        f'<th class="num-cell">{th_n}</th><th class="num-cell">{th_share}</th>'
+        "</tr></thead>\n"
+        f"<tbody>{rows}</tbody>\n</table>\n"
+    )
+
+
+def _roman_block(view: str, payload: RomanNumeralsPayload, lang: str) -> str:
+    head = localized(
+        lang,
+        f"{view}numéraux romains",
+        f"{view}Roman numerals",
+    )
+    prose = localized(
+        lang,
+        '<p class="muted">Pour chaque numéral de la vérité terrain, comment '
+        "l'OCR le restitue : forme stricte (diplomatique) · casse modifiée · "
+        "« j » médiéval standardisé (viij → viii) · converti en chiffres arabes "
+        "(XIV → 14) · perdu. « Valeur préservée » = tout sauf perdu.</p>\n",
+        '<p class="muted">For each ground-truth numeral, how '
+        "the OCR restores it: strict form (diplomatic) · case changed · "
+        "medieval « j » standardized (viij → viii) · converted to Arabic numerals "
+        "(XIV → 14) · lost. « Value preserved » = everything but lost.</p>\n",
+    )
+    return (
+        f"<h3>{head}</h3>\n"
+        + prose
+        + "".join(_roman_pipeline_block(row, lang) for row in payload.pipelines)
+    )
+
+
+class PhilologySection:
+    """Préservation des marqueurs scribaux et numéraux romains, par pipeline."""
+
+    name = "philology"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        multi = len({a.view for a in result.analyses}) > 1
+        blocks: list[str] = []
+        for analysis in result.analyses:
+            label = view_prefix(analysis.view, ctx.lang, multi=multi)
+            if isinstance(analysis.payload, PhilologyPayload):
+                blocks.append(_block(label, analysis.payload, ctx.lang))
+            elif isinstance(analysis.payload, RomanNumeralsPayload):
+                blocks.append(
+                    _roman_block(label, analysis.payload, ctx.lang)
+                )
+        if not blocks:
+            return None
+        title = localized(ctx.lang, "Philologie", "Philology")
+        return Html(f"<h2>{title}</h2>\n" + "".join(blocks))
+
+
+__all__ = ["PhilologySection"]
diff --git a/cinoc/reports/sections/structure.py b/cinoc/reports/sections/structure.py
new file mode 100644
index 0000000000000000000000000000000000000000..18507e7d5c59d2869831169099ae1e99c2fb50e4
--- /dev/null
+++ b/cinoc/reports/sections/structure.py
@@ -0,0 +1,80 @@
+"""Section structure / mise en page (couche 7) : Region-F1 + CER par région.
+
+Rend, en **lecture seule**, les scores de la vue ``structure`` — produite quand
+le corpus porte une vérité-terrain ``LAYOUT`` (segmentation). Absente sinon
+(aucun pipeline ne porte ces métriques) : pas de section vide, par construction.
+"""
+
+from __future__ import annotations
+
+from cinoc.evaluation.result import PipelineResult, RunResult
+from cinoc.reports._numbers import localize_decimal
+from cinoc.reports.engine_badges import engine_cell, engine_order
+from cinoc.reports.html import localized
+from cinoc.reports.section import Html, SectionContext
+
+#: Métriques de la vue structure (Region-F1 de détection + CER par région).
+_METRICS = ("region_detection", "region_cer")
+
+
+def _value(pipeline: PipelineResult, metric: str) -> float | None:
+    return next((s.value for s in pipeline.aggregate if s.metric == metric), None)
+
+
+def _cell(value: float | None, lang: str) -> str:
+    if value is None:
+        return '<td class="disp muted">—</td>'
+    return f'<td class="disp">{localize_decimal(f"{value:.4f}", lang)}</td>'
+
+
+class StructureSection:
+    """Region-F1 (détection de régions) + CER par région — runs de segmentation."""
+
+    name = "structure"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        rows = [
+            p
+            for p in result.pipelines
+            if any(s.metric in _METRICS for s in p.aggregate)
+        ]
+        if not rows:
+            return None
+        order = engine_order(p.pipeline for p in result.pipelines)
+        title = localized(ctx.lang, "Structure (mise en page)", "Layout structure")
+        prose = localized(
+            ctx.lang,
+            '<p class="muted"><b>Region-F1</b> = qualité de la <b>segmentation</b> '
+            "(régions appariées par IoU de boîte ≥ 0,5, coordonnées relatives — "
+            "plus haut = mieux). <b>CER région</b> = erreur caractère région par "
+            "région, micro-agrégée à la page (plus bas = mieux). N'apparaît que "
+            "pour les runs portant une vérité-terrain de mise en page.</p>\n",
+            '<p class="muted"><b>Region-F1</b> = <b>segmentation</b> quality '
+            "(regions matched by box IoU ≥ 0.5, relative coordinates — higher is "
+            "better). <b>Region CER</b> = per-region character error, "
+            "page-micro-aggregated (lower is better). Shown only for runs "
+            "carrying layout ground truth.</p>\n",
+        )
+        th_pipeline = localized(ctx.lang, "Pipeline", "Pipeline")
+        th_f1 = localized(ctx.lang, "Region-F1 ↑", "Region-F1 ↑")
+        th_cer = localized(ctx.lang, "CER région ↓", "Region CER ↓")
+        body = "".join(
+            f'<tr><td class="eng-cell">'
+            f"{engine_cell(p.pipeline, order.get(p.pipeline, 0))}</td>"
+            + _cell(_value(p, "region_detection"), ctx.lang)
+            + _cell(_value(p, "region_cer"), ctx.lang)
+            + "</tr>"
+            for p in rows
+        )
+        return Html(
+            f"<h2>{title}</h2>\n{prose}"
+            f'<div class="table-scroll"><table class="data">\n'
+            f"<thead><tr><th>{th_pipeline}</th>"
+            f'<th class="num-cell">{th_f1}</th>'
+            f'<th class="num-cell">{th_cer}</th></tr></thead>\n'
+            f"<tbody>{body}</tbody>\n</table></div>\n"
+        )
+
+
+__all__ = ["StructureSection"]
diff --git a/cinoc/reports/sections/structured_data.py b/cinoc/reports/sections/structured_data.py
new file mode 100644
index 0000000000000000000000000000000000000000..d9915d6a474b5c25b548992c8b009edd6ff126c1
--- /dev/null
+++ b/cinoc/reports/sections/structured_data.py
@@ -0,0 +1,107 @@
+"""Section données structurées : la survie des dates/folios/montants (couche 7).
+
+Rend le payload ``structured_data`` en **lecture seule** : par pipeline et par
+catégorie présente dans la GT, restitution stricte (forme exacte) et en valeur
+(équivalent), avec les formes perdues à l'appui.
+"""
+
+from __future__ import annotations
+
+from cinoc.evaluation.analysis import StructuredDataPayload
+from cinoc.evaluation.result import RunResult
+from cinoc.reports._numbers import localize_decimal
+from cinoc.reports.engine_badges import engine_cell, engine_order
+from cinoc.reports.html import escape, localized
+from cinoc.reports.section import Html, SectionContext
+from cinoc.reports.sections._payload import render_payload_section
+
+_CATEGORY_LABELS = {
+    "year": ("années", "years"),
+    "foliation": ("foliotation", "foliation"),
+    "currency": ("montants", "amounts"),
+    "regnal": ("années régnales", "regnal years"),
+}
+
+
+def _category_label(category: str, lang: str) -> str:
+    pair = _CATEGORY_LABELS.get(category)
+    if pair is None:
+        return category
+    return localized(lang, pair[0], pair[1])
+
+
+def _block(
+    view: str, payload: StructuredDataPayload, lang: str, order: dict[str, int]
+) -> str:
+    rows: list[str] = []
+    for pipeline in payload.pipelines:
+        badge = engine_cell(pipeline.pipeline, order.get(pipeline.pipeline, 0))
+        for item in pipeline.categories:
+            lost = (
+                f'<span class="muted">{escape(", ".join(item.lost))}</span>'
+                if item.lost
+                else "—"
+            )
+            rows.append(
+                f'<tr><td class="eng-cell">{badge}</td>'
+                f'<td class="eng-cell">'
+                f"{escape(_category_label(item.category, lang))}</td>"
+                f'<td class="disp">{item.n_total}</td>'
+                f'<td class="disp">'
+                f'{localize_decimal(f"{item.strict_score:.1%}", lang)}</td>'
+                f'<td class="disp">'
+                f'{localize_decimal(f"{item.value_score:.1%}", lang)}</td>'
+                f'<td class="disp">{lost}</td></tr>'
+            )
+    head = localized(
+        lang,
+        f"{view}séquences numériques",
+        f"{view}numeric sequences",
+    )
+    prose = localized(
+        lang,
+        '<p class="muted">Ce que cite un historien : années, folios '
+        "(recto/verso distingués), montants, années régnales. « strict » = la "
+        "forme exacte de la GT survit ; « valeur » = l'équivalent survit "
+        "(« f. 12r » vaut « fol. 12r », « an 3 » vaut « an III »). Détection "
+        "par motifs conservateurs — la précision prime sur le rappel.</p>\n",
+        '<p class="muted">What a historian cites: years, folios '
+        "(recto/verso distinguished), amounts, regnal years. \"strict\" = the "
+        "exact GT form is preserved; \"value\" = the equivalent is preserved "
+        '("f. 12r" matches "fol. 12r", "an 3" matches "an III"). Detection '
+        "by conservative patterns — precision takes priority over recall.</p>\n",
+    )
+    th_pipeline = localized(lang, "Pipeline", "Pipeline")
+    th_category = localized(lang, "catégorie", "category")
+    th_strict = localized(lang, "strict", "strict")
+    th_value = localized(lang, "valeur", "value")
+    th_lost = localized(lang, "perdues", "lost")
+    return (
+        f"<h3>{head}</h3>\n"
+        f"{prose}"
+        f'<table class="data">\n<thead><tr><th>{th_pipeline}</th>'
+        f"<th>{th_category}</th>"
+        f'<th class="num-cell">n</th><th class="num-cell">{th_strict}</th>'
+        f'<th class="num-cell">{th_value}</th><th>{th_lost}</th></tr></thead>\n'
+        f"<tbody>{''.join(rows)}</tbody>\n</table>\n"
+    )
+
+
+class StructuredDataSection:
+    """Restitution des séquences numériques, par pipeline et catégorie."""
+
+    name = "structured_data"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        order = engine_order(p.pipeline for p in result.pipelines)
+        return render_payload_section(
+            result,
+            ctx,
+            payload_type=StructuredDataPayload,
+            title=localized(ctx.lang, "Données structurées", "Structured data"),
+            block=lambda view, payload: _block(view, payload, ctx.lang, order),
+        )
+
+
+__all__ = ["StructuredDataSection"]
diff --git a/cinoc/reports/sections/taxonomy.py b/cinoc/reports/sections/taxonomy.py
new file mode 100644
index 0000000000000000000000000000000000000000..2d43a8b8cc5f5c1150fedd4bf3656fcc13cd5122
--- /dev/null
+++ b/cinoc/reports/sections/taxonomy.py
@@ -0,0 +1,207 @@
+"""Section taxonomie : composition des classes d'erreurs (couche 7).
+
+Rend les payloads ``taxonomy`` en **lecture seule** : par pipeline, une **barre
+empilée SVG** (part de chaque classe) + une légende (classe · part · occurrences)
+— quelles erreurs, pas seulement combien. Sous 2 moteurs ou plus, un **profil
+comparatif** (classe × moteur, part en databar) donne l'autre lecture : non plus
+la composition d'un moteur, mais quel moteur est lourd sur *quelle* classe (#5).
+Server-side, déterministe, zéro JS.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+from cinoc.evaluation.analysis import PipelineTaxonomy, TaxonomyPayload
+from cinoc.evaluation.result import RunResult
+from cinoc.reports.engine_badges import engine_accent, engine_cell, engine_order
+from cinoc.reports.html import escape, localized
+from cinoc.reports.section import Html, SectionContext
+from cinoc.reports.sections._payload import render_payload_section
+from cinoc.reports.svg import composition_bar
+
+#: Libellés bilingues du **profil comparatif** (le reste de la section, antérieur
+#: à la consigne FR/EN des graphiques, reste FR — i18n du rapport = jalon à part).
+_PROFILE_TEXT: dict[str, dict[str, str]] = {
+    "fr": {
+        "title": "profil comparatif des moteurs",
+        "intro": (
+            "Part de chaque classe d'erreur, moteur par moteur — lire une "
+            "<strong>ligne</strong> pour comparer les moteurs sur une classe (qui "
+            "est lourd en diacritiques, en segmentation…). « · » = classe absente "
+            "chez ce moteur."
+        ),
+        "th_class": "Classe d'erreur",
+    },
+    "en": {
+        "title": "comparative engine profile",
+        "intro": (
+            "Share of each error class, engine by engine — read a <strong>row</strong> "
+            "to compare engines on one class (which is heavy on diacritics, "
+            "segmentation…). “·” = class absent for that engine."
+        ),
+        "th_class": "Error class",
+    },
+}
+
+
+#: Libellés **lisibles bilingues** des classes d'erreur (la donnée garde ses clés
+#: stables ``CLASSES``). ``other`` = substitutions résiduelles = **vrais misreads**
+#: (ni casse/diacritique/ligature/confusion visuelle) → nommé « substitution »,
+#: pas un fourre-tout « other » : sur de l'OCR fautif, c'est légitimement la classe
+#: dominante (le moteur produit le mauvais mot, pas juste un accent près).
+_CLASS_LABELS: dict[str, tuple[str, str]] = {
+    "segmentation": ("segmentation", "segmentation"),
+    "case": ("casse", "case"),
+    "diacritic": ("diacritique", "diacritic"),
+    "ligature": ("ligature", "ligature"),
+    "visual": ("confusion visuelle", "visual confusion"),
+    "lacuna": ("omission", "omission"),
+    "insertion": ("insertion", "insertion"),
+    "other": ("substitution", "substitution"),
+}
+
+
+def _class_label(key: str, lang: str) -> str:
+    """Libellé lisible d'une classe d'erreur (clé brute si non répertoriée)."""
+    pair = _CLASS_LABELS.get(key)
+    if pair is None:
+        return key
+    return pair[1] if lang == "en" else pair[0]
+
+
+def composition_html(
+    classes: tuple[str, ...], pipeline: PipelineTaxonomy, lang: str = "fr"
+) -> str:
+    """Barre empilée + légende pour **un** pipeline (réutilisable : section + profil).
+
+    Couleur par classe = palette cyclique partagée, indexée sur l'ordre canonique
+    ``classes``. Renvoie ``""`` si le pipeline n'a aucune erreur classée."""
+    color = {cls: engine_accent(i) for i, cls in enumerate(classes)}
+
+    def _c(label: str) -> str:
+        return color.get(label, engine_accent(0))
+
+    total = pipeline.total_errors
+    present = [(c.label, c.count) for c in pipeline.counts if c.count > 0]
+    if not present:
+        return ""
+    segments = [(cnt / total, _c(lbl)) for lbl, cnt in present]
+    legend = "".join(
+        f'<div class="comp-row">'
+        f'<span class="comp-sw" style="background:{_c(lbl)}"></span>'
+        f'<span class="comp-label">{escape(_class_label(lbl, lang))}</span>'
+        f'<span class="comp-share mono">{cnt / total:.0%}</span>'
+        f'<span class="comp-count mono">{cnt}</span></div>'
+        for lbl, cnt in present
+    )
+    return (
+        f'<div class="comp">{composition_bar(segments)}'
+        f'<div class="comp-legend">{legend}</div></div>'
+    )
+
+
+def _profile_block(
+    view: str, payload: TaxonomyPayload, order: Mapping[str, int], lang: str
+) -> str:
+    """Profil comparatif (#5) : classe × moteur, part en databar (lecture par ligne).
+
+    Complémentaire des barres empilées par-moteur ci-dessus (lecture par moteur) :
+    ici on lit une **classe** à travers les moteurs. **À 2 moteurs et plus** (à 1,
+    la barre suffit — pas de comparaison). Pure présentation du payload."""
+    if len(payload.pipelines) < 2:
+        return ""
+    present = [
+        cls
+        for cls in payload.classes
+        if any(
+            count.label == cls and count.count > 0
+            for pipeline in payload.pipelines
+            for count in pipeline.counts
+        )
+    ]
+    if not present:
+        return ""
+    text = _PROFILE_TEXT.get(lang, _PROFILE_TEXT["fr"])
+    headers = "".join(
+        f'<th class="num-cell">{engine_cell(p.pipeline, order.get(p.pipeline, 0))}</th>'
+        for p in payload.pipelines
+    )
+    rows: list[str] = []
+    for cls in present:
+        cells: list[str] = []
+        for pipeline in payload.pipelines:
+            count = next((c.count for c in pipeline.counts if c.label == cls), 0)
+            share = count / pipeline.total_errors if pipeline.total_errors else 0.0
+            if count > 0:
+                cells.append(
+                    '<td class="databar">'
+                    f'<span class="db-fill" style="width:{round(share * 100)}%">'
+                    f'</span><span class="db-num">{share:.0%}</span></td>'
+                )
+            else:
+                cells.append('<td class="databar"><span class="db-num">·</span></td>')
+        rows.append(
+            f'<tr><td class="eng-cell">{escape(_class_label(cls, lang))}</td>'
+            f'{"".join(cells)}</tr>'
+        )
+    return (
+        f"<h3>{view}{text['title']}</h3>\n"
+        f'<p class="muted">{text["intro"]}</p>\n'
+        '<table class="data">\n'
+        f'<thead><tr><th>{text["th_class"]}</th>{headers}</tr></thead>\n'
+        f"<tbody>{''.join(rows)}</tbody>\n</table>\n"
+    )
+
+
+def _block(
+    view: str, payload: TaxonomyPayload, order: Mapping[str, int], lang: str
+) -> str:
+    head = localized(
+        lang,
+        f"{view}composition des erreurs",
+        f"{view}error composition",
+    )
+    prose = localized(
+        lang,
+        '<p class="muted">Classification par règles pures (casse, diacritiques, '
+        "ligatures, confusions visuelles, segmentation, lacunes, insertions) — "
+        "part relative au total des erreurs de mots du pipeline.</p>\n",
+        '<p class="muted">Pure rule-based classification (case, diacritics, '
+        "ligatures, visual confusions, segmentation, gaps, insertions) — "
+        "share relative to the pipeline's total word errors.</p>\n",
+    )
+    parts: list[str] = [f"<h3>{head}</h3>\n", prose]
+    for pipeline in payload.pipelines:
+        block = composition_html(payload.classes, pipeline, lang)
+        if block:
+            label = localized(
+                lang,
+                f"{pipeline.total_errors} erreurs",
+                f"{pipeline.total_errors} errors",
+            )
+            parts.append(
+                f"<h4>{escape(pipeline.pipeline)} — {label}</h4>\n{block}\n"
+            )
+    parts.append(_profile_block(view, payload, order, lang))
+    return "".join(parts)
+
+
+class TaxonomySection:
+    """Composition des classes d'erreurs par pipeline (barre empilée + légende)."""
+
+    name = "taxonomy"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        order = engine_order(p.pipeline for p in result.pipelines)
+        return render_payload_section(
+            result,
+            ctx,
+            payload_type=TaxonomyPayload,
+            title=localized(ctx.lang, "Taxonomie des erreurs", "Error taxonomy"),
+            block=lambda view, payload: _block(view, payload, order, ctx.lang),
+        )
+
+
+__all__ = ["TaxonomySection", "composition_html"]
diff --git a/cinoc/reports/sections/textual_fidelity.py b/cinoc/reports/sections/textual_fidelity.py
new file mode 100644
index 0000000000000000000000000000000000000000..4cd7e1732b77f73e5d02f7958411c4cf625c2f6f
--- /dev/null
+++ b/cinoc/reports/sections/textual_fidelity.py
@@ -0,0 +1,159 @@
+"""Section fidélité textuelle : tokens rares + modernisation lexicale (couche 7).
+
+Rend le payload ``textual_fidelity`` en **lecture seule** : par pipeline, le
+rappel des tokens rares (avec un échantillon de manqués) et le **flux de
+modernisation** (#17) — forme historique de la GT → variantes produites, chips
+dimensionnés par fréquence (« voir les tokens réécrits »). Pédagogie en prose —
+aucun scalaire de classement (≠ glossaire).
+"""
+
+from __future__ import annotations
+
+from cinoc.evaluation.analysis import (
+    ModernizedToken,
+    PipelineTextualFidelity,
+    TextualFidelityPayload,
+)
+from cinoc.evaluation.result import RunResult
+from cinoc.reports._numbers import localize_decimal
+from cinoc.reports.engine_badges import engine_cell, engine_order
+from cinoc.reports.html import escape, localized
+from cinoc.reports.section import Html, SectionContext
+from cinoc.reports.sections._payload import render_payload_section
+
+
+def _rare_row(
+    row: PipelineTextualFidelity, order: dict[str, int], lang: str
+) -> str:
+    if row.n_rare_reference == 0:
+        recall = "—"
+        missed = "—"
+    else:
+        recall = (
+            localize_decimal(f"{row.rare_recall:.1%}", lang)
+            if row.rare_recall is not None
+            else "—"
+        )
+        missed = (
+            f'<span class="muted">{escape(", ".join(row.missed))}</span>'
+            if row.missed
+            else "—"
+        )
+    badge = engine_cell(row.pipeline, order.get(row.pipeline, 0))
+    return (
+        f'<tr><td class="eng-cell">{badge}</td>'
+        f'<td class="disp">{row.n_rare_recalled}/{row.n_rare_reference}</td>'
+        f'<td class="disp">{recall}</td>'
+        f"<td>{missed}</td></tr>"
+    )
+
+
+def _token_flow(token: ModernizedToken, lang: str) -> str:
+    """Une forme GT → ses variantes produites (chips, barre ∝ compte = taille)."""
+    max_count = token.variants[0].count if token.variants else 1
+    chips = "".join(
+        f'<span class="wf-dst"><span class="wf-word">{escape(variant.form)}</span>'
+        f'<span class="wf-bar" style="width:{round(variant.count / max_count * 40)}px">'
+        f'</span><span class="wf-count">×{variant.count}</span></span>'
+        for variant in token.variants
+    )
+    return (
+        '<div class="wf-row">'
+        f'<span class="wf-word wf-src">{escape(token.token)}</span>'
+        f'<span class="wf-meta">{localize_decimal(f"{token.rate:.1%}", lang)}</span>'
+        f'<span class="wf-arrow">→</span>{chips}</div>'
+    )
+
+
+def _modernization_block(
+    view: str, payload: TextualFidelityPayload, lang: str, order: dict[str, int]
+) -> str:
+    """Flux de modernisation (#17) : par pipeline, forme GT → variantes produites."""
+    groups: list[str] = []
+    for row in payload.pipelines:
+        if not row.modernization:
+            continue
+        flows = "".join(_token_flow(token, lang) for token in row.modernization)
+        badge = engine_cell(row.pipeline, order.get(row.pipeline, 0))
+        groups.append(
+            f'<div class="cf-engine"><span class="cf-eng-name">{badge}</span>'
+            f'<div class="wflow">{flows}</div></div>'
+        )
+    if not groups:
+        return ""
+    head = localized(
+        lang,
+        f"{view}modernisation lexicale",
+        f"{view}lexical modernization",
+    )
+    prose = localized(
+        lang,
+        '<p class="muted">Formes historiques de la GT réécrites par le moteur '
+        "(diagnostic de prompt LLM) : la forme attendue → les variantes produites "
+        "(barre = fréquence ; taux de réécriture en regard ; « ∅ » = mot "
+        "supprimé).</p>\n",
+        '<p class="muted">Historical GT forms rewritten by the engine '
+        "(LLM prompt diagnostic): the expected form → the produced variants "
+        "(bar = frequency; rewrite rate alongside; “∅” = deleted "
+        "word).</p>\n",
+    )
+    return f"<h3>{head}</h3>\n" + prose + "".join(groups)
+
+
+def _block(
+    view: str, payload: TextualFidelityPayload, lang: str, order: dict[str, int]
+) -> str:
+    rare_rows = "".join(_rare_row(row, order, lang) for row in payload.pipelines)
+    head = localized(
+        lang,
+        f"{view}rappel des tokens rares "
+        f"(≤ {payload.max_freq} occurrence(s))",
+        f"{view}rare-token recall "
+        f"(≤ {payload.max_freq} occurrence(s))",
+    )
+    prose = localized(
+        lang,
+        '<p class="muted">Les tokens rares (noms propres, toponymes, termes — '
+        "hapax et dis legomena du corpus) pèsent en indexation prosopographique "
+        "mais sont noyés dans le CER global. Rappel = part des occurrences rares "
+        "de la GT retrouvées (multiset).</p>\n",
+        '<p class="muted">Rare tokens (proper nouns, toponyms, terms — '
+        "corpus hapax and dis legomena) matter for prosopographic indexing "
+        "but are drowned out in the global CER. Recall = share of rare GT "
+        "occurrences recovered (multiset).</p>\n",
+    )
+    th_pipeline = localized(lang, "Pipeline", "Pipeline")
+    th_recalled_total = localized(lang, "rappelés/total", "recalled/total")
+    th_recall = localized(lang, "rappel", "recall")
+    th_missed = localized(lang, "manqués (échantillon)", "missed (sample)")
+    rare_table = (
+        f"<h3>{head}</h3>\n"
+        + prose
+        + '<table class="data">\n<thead><tr>'
+        f"<th>{th_pipeline}</th>"
+        f'<th class="num-cell">{th_recalled_total}</th>'
+        f'<th class="num-cell">{th_recall}</th>'
+        f"<th>{th_missed}</th></tr></thead>\n"
+        f"<tbody>{rare_rows}</tbody>\n</table>\n"
+    )
+    return rare_table + _modernization_block(view, payload, lang, order)
+
+
+class TextualFidelitySection:
+    """Tokens rares + modernisation lexicale, par pipeline (lecture seule)."""
+
+    name = "textual_fidelity"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        order = engine_order(p.pipeline for p in result.pipelines)
+        return render_payload_section(
+            result,
+            ctx,
+            payload_type=TextualFidelityPayload,
+            title=localized(ctx.lang, "Fidélité textuelle", "Textual fidelity"),
+            block=lambda view, payload: _block(view, payload, ctx.lang, order),
+        )
+
+
+__all__ = ["TextualFidelitySection"]
diff --git a/cinoc/reports/sections/word_errors.py b/cinoc/reports/sections/word_errors.py
new file mode 100644
index 0000000000000000000000000000000000000000..23bfb650f64401d7b9d33ada1c3de42a983fb61b
--- /dev/null
+++ b/cinoc/reports/sections/word_errors.py
@@ -0,0 +1,425 @@
+"""Section carte des mots : matrice × moteurs + recouvrement + forme produite.
+
+Lecture seule du payload ``word_errors`` (couche 7) : la **matière** derrière le
+CER — quels mots de la vérité-terrain chaque moteur ne restitue pas, combien de
+fois, et **comment ça se croise**. Trois lectures de la même donnée (catalogue
+des graphiques didactiques §1) :
+
+1. **Matrice** (#1) — heatmap SVG (compagnon visuel) doublée d'une table
+   accessible (mots verbatim × moteurs, comptes + recoupement par mot) ;
+2. **Recouvrement** (#2) — mots groupés par **signature** exacte de moteurs (façon
+   UpSet) : la matière dure (ratée par tous) vs les faiblesses propres à un moteur ;
+3. **Forme produite** (#3) — pour les mots durs, la ``variant`` produite par chaque
+   moteur (la *nature* de l'erreur, ``∅`` = supprimé).
+
+Prose pédagogique bilingue ; aucun scalaire de classement (pas de glossaire).
+Onglet « Croisements ».
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+from cinoc.evaluation.analysis import WordError, WordErrorPayload
+from cinoc.evaluation.result import RunResult
+from cinoc.reports.engine_badges import (
+    engine_accent,
+    engine_cell,
+    engine_letter,
+    engine_order,
+)
+from cinoc.reports.html import escape
+from cinoc.reports.section import Html, SectionContext
+from cinoc.reports.sections._payload import render_payload_section
+from cinoc.reports.svg import donut_chart, word_engine_heatmap, word_overlap_venn
+from cinoc.reports.text_diff import char_diff
+
+#: Lignes de la heatmap **visuelle** (les mots les plus ratés) — la table porte la
+#: liste complète du payload (≤ 50). Borne la hauteur du graphe.
+_HEATMAP_ROWS = 20
+
+#: Teinte unique de la heatmap (intensité = compte) — accent neutre de la charte,
+#: pas une couleur de moteur (la matrice teinte par fréquence, pas par identité).
+_HEATMAP_ACCENT = "var(--fern)"
+
+#: Mots durs détaillés dans la table « forme produite » (#3) — bornée en largeur.
+_VARIANT_ROWS = 15
+
+#: Mots échantillonnés par signature de recouvrement (#2) avant le « +N ».
+_OVERLAP_SAMPLES = 6
+
+_TEXT: dict[str, dict[str, str]] = {
+    "fr": {
+        "title": "Carte des mots ratés",
+        "subtitle": "mots de la vérité-terrain non restitués, par moteur",
+        "intro": (
+            "Quels mots de la vérité-terrain chaque moteur ne restitue pas — la "
+            "matière brute derrière le CER. Case teintée = un moteur rate le mot ; "
+            "le nombre = combien de fois. Les croisements montrent les mots durs "
+            "pour <em>tous</em> les moteurs (la matière) vs propres à un seul (le "
+            "moteur)."
+        ),
+        "caveats": (
+            "L'appariement mot-à-mot dépend de la normalisation de la vue ; une "
+            "fusion ou scission de mots est une limite connue de l'alignement. Les "
+            "mots et les formes produites sont <strong>verbatim</strong> (rien "
+            "d'inventé). Échantillon borné aux mots les plus ratés."
+        ),
+        "legend": "Moteurs",
+        "th_word": "Mot (vérité-terrain)",
+        "th_total": "total",
+        "th_group": "recoupement",
+        "graph_note": "Graphe : les {n} mots les plus ratés ; table : liste complète.",
+        "card_matrix": "Matrice mots × moteurs",
+        "card_venn": "Recouvrement (Venn)",
+        "card_donut": "Composition (camembert)",
+        "u_universal": "tous",
+        "u_engine_specific": "un seul",
+        "u_partial": "plusieurs",
+        "empty": "·",
+        "overlap_subtitle": "recouvrement inter-moteurs",
+        "overlap_intro": (
+            "Combien de mots chaque combinaison de moteurs rate <em>ensemble</em> "
+            "(taille d'intersection) : les mots ratés par <strong>tous</strong> "
+            "(matière dure) vs propres à <strong>un seul</strong> (faiblesse "
+            "moteur)."
+        ),
+        "th_overlap_count": "mots",
+        "th_samples": "exemples",
+        "variant_subtitle": "forme produite par moteur",
+        "variant_intro": (
+            "Pour les mots les plus durs, la forme que chaque moteur a produite à "
+            "la place — la <em>nature</em> de l'erreur (« · » = mot restitué par ce "
+            "moteur ; « ∅ » = mot supprimé)."
+        ),
+    },
+    "en": {
+        "title": "Missed-word map",
+        "subtitle": "ground-truth words not reproduced, per engine",
+        "intro": (
+            "Which ground-truth words each engine fails to reproduce — the raw "
+            "matter behind the CER. A tinted cell = an engine misses the word; the "
+            "number = how many times. The overlaps show words hard for <em>every</em> "
+            "engine (the matter) vs specific to one (the engine)."
+        ),
+        "caveats": (
+            "Word-to-word matching depends on the view's normalisation; a word "
+            "merge or split is a known alignment limit. Words and produced forms "
+            "are <strong>verbatim</strong> (nothing invented). Sample bounded to "
+            "the most-missed words."
+        ),
+        "legend": "Engines",
+        "th_word": "Word (ground truth)",
+        "th_total": "total",
+        "th_group": "overlap",
+        "graph_note": "Graph: the {n} most-missed words; table: full list.",
+        "card_matrix": "Words × engines matrix",
+        "card_venn": "Overlap (Venn)",
+        "card_donut": "Composition (pie)",
+        "u_universal": "all",
+        "u_engine_specific": "one only",
+        "u_partial": "several",
+        "empty": "·",
+        "overlap_subtitle": "cross-engine overlap",
+        "overlap_intro": (
+            "How many words each engine combination misses <em>together</em> "
+            "(intersection size): words missed by <strong>all</strong> (hard "
+            "matter) vs specific to <strong>one</strong> (engine weakness)."
+        ),
+        "th_overlap_count": "words",
+        "th_samples": "examples",
+        "variant_subtitle": "produced form per engine",
+        "variant_intro": (
+            "For the hardest words, the form each engine produced instead — the "
+            "<em>nature</em> of the error (“·” = word reproduced by that engine; "
+            "“∅” = word deleted)."
+        ),
+    },
+}
+
+
+def _columns(payload: WordErrorPayload, order: Mapping[str, int]) -> list[str]:
+    """Pipelines du payload, dans l'ordre stable des badges (identité moteur)."""
+    return sorted(payload.pipelines, key=lambda name: order.get(name, len(order)))
+
+
+def _matrix_row(
+    word: WordError, columns: list[str], text: Mapping[str, str]
+) -> str:
+    """Ligne de la table : mot verbatim, compte par moteur, total, recoupement."""
+    counts = {engine.pipeline: engine.count for engine in word.per_engine}
+    cells = "".join(
+        f'<td class="disp">{counts[name]}</td>'
+        if name in counts
+        else f'<td class="disp">{text["empty"]}</td>'
+        for name in columns
+    )
+    return (
+        f'<tr><td class="eng-cell">{escape(word.word)}</td>{cells}'
+        f'<td class="disp">{word.total_errors}</td>'
+        f'<td class="verdict">{escape(text[f"u_{word.group}"])}</td></tr>'
+    )
+
+
+def _matrix_grid(
+    words: tuple[WordError, ...],
+    header_cells: str,
+    columns: list[str],
+    text: Mapping[str, str],
+) -> str:
+    """Matrice mots × moteurs en **N tables côte à côte** (utilise la largeur).
+
+    La liste (triée par sévérité) est découpée en colonnes journal (~16 lignes /
+    colonne, plafond 3) au lieu d'un seul tableau qui descend tout en bas pendant
+    que la droite reste vide. Replie en 1 colonne sur écran étroit (CSS)."""
+    n = min(3, max(1, -(-len(words) // 16)))
+    size = -(-len(words) // n)  # lignes par colonne (ceil)
+    head = f"<thead><tr>{header_cells}</tr></thead>"
+    tables: list[str] = []
+    for c in range(n):
+        chunk = words[c * size : (c + 1) * size]
+        if not chunk:
+            continue
+        rows = "".join(_matrix_row(word, columns, text) for word in chunk)
+        tables.append(f'<table class="data">\n{head}\n<tbody>{rows}</tbody>\n</table>')
+    return f'<div class="tcols" style="--n:{len(tables)}">{"".join(tables)}</div>\n'
+
+
+def _venn_svg(payload: WordErrorPayload, order: Mapping[str, int]) -> str:
+    """Venn (2-3 moteurs) du recouvrement des mots ratés — compagnon visuel,
+    rendu en carte à part (à côté de la matrice). ``""`` au-delà de 3 moteurs."""
+    columns = _columns(payload, order)
+    col_pos = {name: i for i, name in enumerate(columns)}
+    region_counts: dict[frozenset[int], int] = {}
+    for word in payload.words:
+        region = frozenset(
+            col_pos[e.pipeline] for e in word.per_engine if e.pipeline in col_pos
+        )
+        region_counts[region] = region_counts.get(region, 0) + 1
+    return word_overlap_venn(
+        [engine_letter(order.get(name, 0)) for name in columns],
+        region_counts,
+        accents=[engine_accent(order.get(name, 0)) for name in columns],
+    )
+
+
+def _overlap_block(
+    view: str,
+    payload: WordErrorPayload,
+    order: Mapping[str, int],
+    text: Mapping[str, str],
+) -> str:
+    """Recouvrement inter-moteurs (#2) : mots groupés par **signature** exacte.
+
+    Façon UpSet : chaque combinaison de moteurs qui ratent *ensemble* un mot →
+    une ligne (taille d'intersection en barre + exemples de mots verbatim). Pure
+    présentation : groupe les mots déjà calculés du payload, aucun recalcul.
+    """
+    groups: dict[tuple[str, ...], list[str]] = {}
+    for word in payload.words:
+        signature = tuple(
+            sorted(
+                (engine.pipeline for engine in word.per_engine),
+                key=lambda name: order.get(name, len(order)),
+            )
+        )
+        groups.setdefault(signature, []).append(word.word)
+    ranked = sorted(
+        groups.items(), key=lambda item: (-len(item[1]), len(item[0]), item[0])
+    )
+    max_count = max((len(words) for _, words in ranked), default=1)
+    n_pipelines = len(payload.pipelines)
+    rows: list[str] = []
+    for signature, words in ranked:
+        badges = " ".join(engine_cell(name, order.get(name, 0)) for name in signature)
+        if len(signature) >= n_pipelines:
+            hint = text["u_universal"]
+        elif len(signature) == 1:
+            hint = text["u_engine_specific"]
+        else:
+            hint = text["u_partial"]
+        width = round(len(words) / max_count * 100)
+        sample = ", ".join(escape(word) for word in words[:_OVERLAP_SAMPLES])
+        extra = len(words) - _OVERLAP_SAMPLES
+        more = f' <span class="muted">+{extra}</span>' if extra > 0 else ""
+        rows.append(
+            f'<tr><td class="eng-cell">{badges} '
+            f'<span class="muted">({escape(hint)})</span></td>'
+            f'<td class="databar"><span class="db-fill" style="width:{width}%">'
+            f'</span><span class="db-num">{len(words)}</span></td>'
+            f'<td class="muted">{sample}{more}</td></tr>'
+        )
+    return (
+        f"<h3>{view}{text['overlap_subtitle']}</h3>\n"
+        f'<p class="muted">{text["overlap_intro"]}</p>\n'
+        '<table class="data">\n'
+        f'<thead><tr><th>{text["legend"]}</th>'
+        f'<th class="num-cell">{text["th_overlap_count"]}</th>'
+        f'<th>{text["th_samples"]}</th></tr></thead>\n'
+        f"<tbody>{''.join(rows)}</tbody>\n</table>\n"
+    )
+
+
+def _produced_cell(gt: str, variant: str, empty: str) -> str:
+    """Cellule « forme produite » : écart au mot GT **surligné** (nature de la
+    confusion, ex. ``ist`` → ``i[f]t``). ``∅`` (mot supprimé) reste en sourdine."""
+    if variant == empty:
+        return f'<td class="disp"><span class="muted">{escape(empty)}</span></td>'
+    _, hyp_html = char_diff(gt, variant)
+    return f'<td class="disp">{hyp_html}</td>'
+
+
+def _variant_block(
+    view: str,
+    payload: WordErrorPayload,
+    columns: list[str],
+    order: Mapping[str, int],
+    text: Mapping[str, str],
+) -> str:
+    """Forme produite par moteur (#3) : la *nature* de l'erreur, lisible.
+
+    Rend la ``variant`` (forme produite dominante) **déjà portée** par le payload
+    pour les mots les plus durs — ``maistre`` → ``maitre``/``maistrc`` (``∅`` =
+    supprimé), l'**écart au mot GT surligné**. Verbatim, aucune invention.
+    """
+    headers = "".join(
+        f'<th class="num-cell">{engine_cell(name, order.get(name, 0))}</th>'
+        for name in columns
+    )
+    rows: list[str] = []
+    for word in payload.words[:_VARIANT_ROWS]:
+        produced = {engine.pipeline: engine.variant for engine in word.per_engine}
+        cells = "".join(
+            _produced_cell(word.word, produced[name], "∅")
+            if name in produced
+            else f'<td class="disp">{text["empty"]}</td>'
+            for name in columns
+        )
+        rows.append(f'<tr><td class="eng-cell">{escape(word.word)}</td>{cells}</tr>')
+    return (
+        f"<h3>{view}{text['variant_subtitle']}</h3>\n"
+        f'<p class="muted">{text["variant_intro"]}</p>\n'
+        '<table class="data">\n'
+        f'<thead><tr><th>{text["th_word"]}</th>{headers}</tr></thead>\n'
+        f"<tbody>{''.join(rows)}</tbody>\n</table>\n"
+    )
+
+
+#: Couleurs des 3 catégories de recouvrement (littéraux oklch, **pas** couleurs
+#: moteur : ce sont des catégories, pas des moteurs identifiés).
+_DONUT_ACCENTS = (
+    "oklch(0.55 0.11 40)",  # tous — clay (matière dure pour tous)
+    "oklch(0.72 0.10 85)",  # plusieurs — butter
+    "oklch(0.62 0.04 230)",  # un seul — bleu-gris doux
+)
+
+
+def _donut_block(
+    payload: WordErrorPayload, columns: list[str], text: Mapping[str, str]
+) -> str:
+    """Carte camembert : part des mots ratés par **tous** / **plusieurs** / **un
+    seul** moteur (proportions — compagnon du Venn). ``""`` si <2 moteurs ou aucun
+    mot (la notion de recouvrement n'a alors pas de sens)."""
+    n_engines = len(columns)
+    if n_engines < 2:
+        return ""
+    every = several = one = 0
+    for word in payload.words:
+        n = len({e.pipeline for e in word.per_engine})
+        if n >= n_engines:
+            every += 1
+        elif n <= 1:
+            one += 1
+        else:
+            several += 1
+    if every + several + one == 0:
+        return ""
+    donut = donut_chart([(float(every), _DONUT_ACCENTS[0]),
+                         (float(several), _DONUT_ACCENTS[1]),
+                         (float(one), _DONUT_ACCENTS[2])])
+    keys = (
+        (text["u_universal"], every, _DONUT_ACCENTS[0]),
+        (text["u_partial"], several, _DONUT_ACCENTS[1]),
+        (text["u_engine_specific"], one, _DONUT_ACCENTS[2]),
+    )
+    legend = " · ".join(
+        f'<span class="donut-key" style="background:{c}"></span> {escape(lbl)} {n}'
+        for lbl, n, c in keys
+    )
+    return (
+        f'<div class="dd-card"><div class="drill-caption">{text["card_donut"]}'
+        f'</div>{donut}<p class="muted donut-legend">{legend}</p></div>'
+    )
+
+
+def _block(
+    view: str, payload: WordErrorPayload, order: Mapping[str, int], lang: str
+) -> str:
+    text = _TEXT.get(lang, _TEXT["fr"])
+    columns = _columns(payload, order)
+    legend = " · ".join(
+        f"{engine_letter(order.get(name, 0))} {escape(name)}" for name in columns
+    )
+    letters = [engine_letter(order.get(name, 0)) for name in columns]
+    heatmap_rows = []
+    for word in payload.words[:_HEATMAP_ROWS]:
+        counts = {engine.pipeline: engine.count for engine in word.per_engine}
+        heatmap_rows.append((word.word, [counts.get(name, 0) for name in columns]))
+    svg = word_engine_heatmap(letters, heatmap_rows, accent=_HEATMAP_ACCENT)
+    headers = "".join(
+        f'<th class="num-cell">{engine_cell(name, order.get(name, 0))}</th>'
+        for name in columns
+    )
+    header_cells = (
+        f'<th>{text["th_word"]}</th>{headers}'
+        f'<th class="num-cell">{text["th_total"]}</th>'
+        f'<th>{text["th_group"]}</th>'
+    )
+    graph_note = text["graph_note"].format(n=min(_HEATMAP_ROWS, len(payload.words)))
+    # Compagnons visuels (matrice mots×moteurs + Venn) en **cartes à leur taille,
+    # côte à côte** — au lieu d'une heatmap étroite qui flotte dans la largeur.
+    venn = _venn_svg(payload, order)
+    venn_card = (
+        f'<div class="dd-card"><div class="drill-caption">{text["card_venn"]}'
+        f"</div>{venn}</div>"
+        if venn
+        else ""
+    )
+    donut_card = _donut_block(payload, columns, text)
+    visuals = (
+        '<div class="dd-flow">'
+        f'<div class="dd-card"><div class="drill-caption">{text["card_matrix"]}'
+        f'</div>{svg}<p class="muted">{graph_note}</p></div>'
+        f"{venn_card}{donut_card}</div>"
+    )
+    return (
+        f"<h3>{view}{text['subtitle']}</h3>\n"
+        f'<p class="muted">{text["intro"]}</p>\n'
+        f'<p class="muted">{text["legend"]} : {legend}</p>\n'
+        f"{visuals}"
+        + _matrix_grid(payload.words, header_cells, columns, text)
+        + _overlap_block(view, payload, order, text)
+        + _variant_block(view, payload, columns, order, text)
+        + f'<p class="muted">{text["caveats"]}</p>\n'
+    )
+
+
+class WordErrorsSection:
+    """Carte des mots : matrice, recouvrement, forme produite (lecture seule)."""
+
+    name = "word_errors"
+    requires: tuple[str, ...] = ()
+
+    def render(self, result: RunResult, ctx: SectionContext) -> Html | None:
+        order = engine_order(p.pipeline for p in result.pipelines)
+        text = _TEXT.get(ctx.lang, _TEXT["fr"])
+        return render_payload_section(
+            result,
+            ctx,
+            payload_type=WordErrorPayload,
+            title=text["title"],
+            block=lambda view, payload: _block(view, payload, order, ctx.lang),
+        )
+
+
+__all__ = ["WordErrorsSection"]
diff --git a/cinoc/reports/svg.py b/cinoc/reports/svg.py
new file mode 100644
index 0000000000000000000000000000000000000000..0015fe211216ca7996cc5cada863e8154d79ec2e
--- /dev/null
+++ b/cinoc/reports/svg.py
@@ -0,0 +1,571 @@
+"""Helpers SVG **serveur** déterministes pour les graphes du rapport (couche 7).
+
+Aucun JS, aucune lib (≠ Chart.js — cf. ``DECISION_RAPPORT_INTERACTIF.md`` §6) :
+du markup SVG inline, **octet-stable**. La **convention d'arrondi** (``num``)
+fixe la précision des coordonnées → mêmes octets entre plateformes (pas de
+flottant à précision variable). Les couleurs d'accent sont passées par l'appelant
+(palette `engine_badges`, jetons de design).
+"""
+
+from __future__ import annotations
+
+import math
+
+from cinoc.reports.html import escape
+
+#: Précision fixe des coordonnées SVG (déterminisme inter-plateformes).
+_COORD_DECIMALS = 2
+
+#: Mots tronqués à l'affichage dans la heatmap (le mot complet vit dans le payload
+#: et la table de la section) — garde les libellés dans la gouttière de gauche.
+_HEATMAP_WORD_CHARS = 22
+
+
+def num(x: float) -> str:
+    """Coordonnée SVG arrondie à précision fixe (``num(1/3) == '0.33'``)."""
+    return f"{x:.{_COORD_DECIMALS}f}"
+
+
+def radar_chart(
+    axes: list[str],
+    series: list[tuple[str, list[float]]],
+    *,
+    accents: list[str],
+    size: float = 260.0,
+    point_titles: list[list[str]] | None = None,
+    aria_label: str = "",
+) -> str:
+    """Radar (toile d'araignée) multi-métrique : ``axes`` = libellés (chaque axe
+    normalisé « plus loin = meilleur », valeurs dans [0,1]) ; ``series`` =
+    ``(libellé, [valeur par axe])`` ; ``accents`` = couleur par série. Grille
+    concentrique + un polygone par série (superposés) + **disques de sommet** à
+    infobulle native (``<title>`` = ``point_titles[s][i]``, p. ex. « Caractère :
+    92.0 % (norm. 0.92) »). Moins de 3 axes → ``""`` (un radar n'a pas de sens).
+    ``aria_label`` rend le graphe **accessible** (``role="img"`` ≠ ``aria-hidden``) :
+    la légende des moteurs vit hors SVG. Déterministe (coords ``num``), zéro JS."""
+    n = len(axes)
+    if n < 3 or not series:
+        return ""
+    cx = cy = size / 2.0
+    radius = size / 2.0 - 50.0
+
+    def point(i: int, frac: float) -> tuple[float, float]:
+        angle = -math.pi / 2.0 + 2.0 * math.pi * i / n
+        return (
+            cx + math.cos(angle) * radius * frac,
+            cy + math.sin(angle) * radius * frac,
+        )
+
+    parts: list[str] = []
+    for ring in (0.25, 0.5, 0.75, 1.0):
+        pts = " ".join(
+            f"{num(x)},{num(y)}" for x, y in (point(i, ring) for i in range(n))
+        )
+        parts.append(f'<polygon points="{pts}" class="radar-grid"/>')
+    for i, label in enumerate(axes):
+        ex, ey = point(i, 1.0)
+        parts.append(
+            f'<line x1="{num(cx)}" y1="{num(cy)}" x2="{num(ex)}" y2="{num(ey)}" '
+            'class="radar-spoke"/>'
+        )
+        lx, ly = point(i, 1.13)
+        anchor = "middle" if abs(lx - cx) < 1.0 else ("start" if lx > cx else "end")
+        parts.append(
+            f'<text x="{num(lx)}" y="{num(ly + 3.0)}" class="radar-axis" '
+            f'text-anchor="{anchor}">{escape(label)}</text>'
+        )
+    for s_idx, (s_label, values) in enumerate(series):
+        accent = accents[s_idx] if s_idx < len(accents) else "var(--ink)"
+        coords = [
+            point(i, max(0.0, min(values[i], 1.0)))
+            for i in range(min(n, len(values)))
+        ]
+        pts = " ".join(f"{num(x)},{num(y)}" for x, y in coords)
+        parts.append(
+            f'<polygon points="{pts}" class="radar-area" '
+            f'style="fill:{accent};stroke:{accent}"><title>{escape(s_label)}</title>'
+            "</polygon>"
+        )
+        # Disques de sommet : cible de survol + infobulle (valeur brute + normalisée).
+        tips = (
+            point_titles[s_idx]
+            if point_titles and s_idx < len(point_titles)
+            else None
+        )
+        for i, (x, y) in enumerate(coords):
+            title = (
+                f"<title>{escape(tips[i])}</title>" if tips and i < len(tips) else ""
+            )
+            parts.append(
+                f'<circle cx="{num(x)}" cy="{num(y)}" r="3" class="radar-vertex" '
+                f'style="fill:{accent}">{title}</circle>'
+            )
+    role = (
+        f'role="img" aria-label="{escape(aria_label)}"'
+        if aria_label
+        else 'aria-hidden="true"'
+    )
+    return (
+        f'<svg viewBox="0 0 {num(size)} {num(size)}" class="radar-svg" '
+        f'{role}>{"".join(parts)}</svg>'
+    )
+
+
+def box_plot(
+    lo: float,
+    q1: float,
+    med: float,
+    q3: float,
+    hi: float,
+    mean: float,
+    scale_max: float,
+    *,
+    accent: str,
+    width: float = 280.0,
+    height: float = 22.0,
+) -> str:
+    """Boîte à moustaches horizontale d'un moteur : moustaches min→max (+ capuchons),
+    boîte interquartile Q1→Q3, trait **médian**, repère **moyenne** (tick). Échelle
+    commune (``scale_max`` partagé) → boîtes comparables entre moteurs. Étirée par
+    CSS (``preserveAspectRatio="none"``). Déterministe (coords ``num``), zéro JS."""
+    s = scale_max or 1.0
+
+    def xv(v: float) -> float:
+        return max(0.0, min(v, s)) / s * width
+
+    mid = height / 2.0
+    box_top, box_h = height * 0.20, height * 0.60
+    cap_top, cap_bot = height * 0.30, height * 0.70
+    box_x, box_w = xv(q1), max(1.0, xv(q3) - xv(q1))
+    return (
+        f'<svg viewBox="0 0 {num(width)} {num(height)}" class="box-plot" '
+        'preserveAspectRatio="none" aria-hidden="true">'
+        f'<line x1="{num(xv(lo))}" y1="{num(mid)}" x2="{num(xv(hi))}" '
+        f'y2="{num(mid)}" class="box-whisker"/>'
+        f'<line x1="{num(xv(lo))}" y1="{num(cap_top)}" x2="{num(xv(lo))}" '
+        f'y2="{num(cap_bot)}" class="box-cap"/>'
+        f'<line x1="{num(xv(hi))}" y1="{num(cap_top)}" x2="{num(xv(hi))}" '
+        f'y2="{num(cap_bot)}" class="box-cap"/>'
+        f'<rect x="{num(box_x)}" y="{num(box_top)}" width="{num(box_w)}" '
+        f'height="{num(box_h)}" class="box-box" style="fill:{accent};stroke:{accent}"/>'
+        f'<line x1="{num(xv(med))}" y1="{num(box_top)}" x2="{num(xv(med))}" '
+        f'y2="{num(box_top + box_h)}" class="box-med" style="stroke:{accent}"/>'
+        f'<line x1="{num(xv(mean))}" y1="{num(height * 0.12)}" x2="{num(xv(mean))}" '
+        f'y2="{num(height * 0.88)}" class="box-mean"/>'
+        "</svg>"
+    )
+
+
+def donut_chart(
+    segments: list[tuple[float, str]],
+    *,
+    size: float = 160.0,
+    hole: float = 0.56,
+) -> str:
+    """Camembert (anneau) : ``segments`` = ``(valeur, couleur)`` ; les parts sont
+    normalisées (somme → cercle complet), tracées dans l'ordre depuis le haut.
+    Le **trou** central est un disque couleur fond (technique de découpe). Une part
+    à 100 % → cercle plein (pas d'arc dégénéré). Déterministe (coords ``num``),
+    zéro JS, ``aria-hidden`` (les comptes vivent dans la légende)."""
+    total = sum(max(0.0, v) for v, _c in segments)
+    if total <= 0:
+        return ""
+    cx = cy = size / 2.0
+    r = size / 2.0 - 2.0
+    parts: list[str] = []
+    angle = -math.pi / 2.0
+    for value, accent in segments:
+        v = max(0.0, value)
+        if v <= 0:
+            continue
+        frac = v / total
+        if frac >= 0.9999:
+            parts.append(
+                f'<circle cx="{num(cx)}" cy="{num(cy)}" r="{num(r)}" '
+                f'class="donut-seg" style="fill:{accent}"/>'
+            )
+            continue
+        a0, a1 = angle, angle + 2.0 * math.pi * frac
+        angle = a1
+        large = 1 if (a1 - a0) > math.pi else 0
+        x0, y0 = cx + math.cos(a0) * r, cy + math.sin(a0) * r
+        x1, y1 = cx + math.cos(a1) * r, cy + math.sin(a1) * r
+        d = (
+            f"M{num(cx)},{num(cy)} L{num(x0)},{num(y0)} "
+            f"A{num(r)},{num(r)} 0 {large} 1 {num(x1)},{num(y1)} Z"
+        )
+        parts.append(f'<path d="{d}" class="donut-seg" style="fill:{accent}"/>')
+    parts.append(
+        f'<circle cx="{num(cx)}" cy="{num(cy)}" r="{num(r * hole)}" '
+        'class="donut-hole"/>'
+    )
+    return (
+        f'<svg viewBox="0 0 {num(size)} {num(size)}" class="donut-svg" '
+        f'aria-hidden="true">{"".join(parts)}</svg>'
+    )
+
+
+def dumbbell_rows(
+    rows: list[tuple[str, list[tuple[float, str]]]],
+    *,
+    scale_max: float,
+    width: float = 340.0,
+    label_w: float = 66.0,
+    row_h: float = 20.0,
+) -> str:
+    """Graphe haltère (dumbbell) : une ligne par ``rows`` = ``(libellé, [(valeur,
+    couleur)])`` ; les points d'une ligne sont reliés (min→max) et posés sur une
+    **échelle commune** (``scale_max``). Pour 2 moteurs = un duel par document ;
+    plus = un dot-plot. Échelle uniforme (points ronds). Déterministe, zéro JS."""
+    if not rows:
+        return ""
+    s = scale_max or 1.0
+    plot_w = width - label_w - 6.0
+    height = row_h * len(rows) + 4.0
+
+    def x(v: float) -> float:
+        return label_w + max(0.0, min(v, s)) / s * plot_w
+
+    parts: list[str] = []
+    for i, (label, dots) in enumerate(rows):
+        cy = row_h * i + row_h / 2.0 + 2.0
+        if len(dots) >= 2:
+            xs = [x(v) for v, _c in dots]
+            parts.append(
+                f'<line x1="{num(min(xs))}" y1="{num(cy)}" x2="{num(max(xs))}" '
+                f'y2="{num(cy)}" class="dumb-link"/>'
+            )
+        for v, accent in dots:
+            parts.append(
+                f'<circle cx="{num(x(v))}" cy="{num(cy)}" r="4" class="dumb-dot" '
+                f'style="fill:{accent};stroke:{accent}"/>'
+            )
+        parts.append(
+            f'<text x="0" y="{num(cy + 3.0)}" class="dumb-label">{escape(label)}</text>'
+        )
+    return (
+        f'<svg viewBox="0 0 {num(width)} {num(height)}" class="dumb-svg" '
+        f'aria-hidden="true">{"".join(parts)}</svg>'
+    )
+
+
+#: Géométrie fixe du Venn à **3** ensembles (le Venn proportionnel à 3 cercles est
+#: un problème ouvert) : ``frozenset`` d'indices → (x, y) où inscrire le compte.
+_VENN3_POS: dict[frozenset[int], tuple[float, float]] = {
+    frozenset({0}): (160.0, 70.0),
+    frozenset({1}): (108.0, 158.0),
+    frozenset({2}): (212.0, 158.0),
+    frozenset({0, 1}): (118.0, 110.0),
+    frozenset({0, 2}): (202.0, 110.0),
+    frozenset({1, 2}): (160.0, 168.0),
+    frozenset({0, 1, 2}): (160.0, 122.0),
+}
+_VENN3_CIRCLES: tuple[tuple[float, float, float], ...] = (
+    (160.0, 100.0, 68.0),
+    (122.0, 150.0, 68.0),
+    (198.0, 150.0, 68.0),
+)
+
+
+def _venn2_proportional(
+    region_counts: dict[frozenset[int], int],
+) -> tuple[
+    tuple[tuple[float, float, float], ...],
+    dict[frozenset[int], tuple[float, float]],
+    float,
+    float,
+]:
+    """Géométrie **proportionnelle** d'un Venn à 2 ensembles : rayon ∝ √|ensemble|
+    (l'**aire** code l'effectif) et distance des centres ∝ (1 − Jaccard) — fort
+    recouvrement → cercles proches, recouvrement nul → cercles tangents.
+    Déterministe (les coordonnées sont arrondies à l'écriture par ``num``)."""
+    a_only = region_counts.get(frozenset({0}), 0)
+    b_only = region_counts.get(frozenset({1}), 0)
+    both = region_counts.get(frozenset({0, 1}), 0)
+    size_a, size_b = a_only + both, b_only + both
+    union = a_only + b_only + both
+    width, height, r_max = 320.0, 200.0, 82.0
+    cy, center = height / 2, width / 2
+    biggest = max(size_a, size_b, 1)
+    r_a = max(14.0, r_max * (size_a / biggest) ** 0.5)
+    r_b = max(14.0, r_max * (size_b / biggest) ** 0.5)
+    # Écart des centres **borné** : ∝ (1 − Jaccard) pour montrer le recouvrement,
+    # mais jamais < 0.50·(r_a+r_b) — sinon, quand les deux moteurs ratent presque
+    # les mêmes mots (Jaccard ≈ 1), les cercles deviennent concentriques et
+    # illisibles. Le **volume** du recouvrement reste lu par le compte central.
+    jaccard = both / union if union else 0.0
+    gap = (r_a + r_b) * (0.50 + 0.45 * (1.0 - jaccard))
+    cx_a, cx_b = center - gap / 2, center + gap / 2
+    circles = ((cx_a, cy, r_a), (cx_b, cy, r_b))
+    pos = {
+        frozenset({0}): (cx_a - r_a * 0.5, cy),
+        frozenset({0, 1}): ((cx_a + cx_b) / 2, cy),
+        frozenset({1}): (cx_b + r_b * 0.5, cy),
+    }
+    return circles, pos, width, height
+
+
+def word_overlap_venn(
+    columns: list[str],
+    region_counts: dict[frozenset[int], int],
+    *,
+    accents: list[str],
+) -> str:
+    """Diagramme de Venn (2 ou 3 moteurs) du **recouvrement** des mots ratés.
+
+    ``columns`` = libellés moteur (lettres) ; ``region_counts`` = ``frozenset``
+    d'indices de moteur → nombre de mots ratés par **exactement** cette
+    combinaison ; ``accents`` = couleur par moteur (alignée sur ``columns``).
+    Cercles teintés (faible opacité) + compte inscrit dans chaque région.
+    Au-delà de 3 moteurs un Venn n'est pas lisible → ``""`` (l'appelant garde la
+    liste). Compagnon **visuel** (``aria-hidden`` ; la matière vit dans la table).
+    Déterministe (coords ``num``), zéro JS."""
+    n = len(columns)
+    if n == 2:
+        circles, pos, width, height = _venn2_proportional(region_counts)
+    elif n == 3:
+        circles, pos, width, height = _VENN3_CIRCLES, _VENN3_POS, 320.0, 240.0
+    else:
+        return ""
+    parts: list[str] = []
+    for i, (cx, cy, r) in enumerate(circles):
+        parts.append(
+            f'<circle cx="{num(cx)}" cy="{num(cy)}" r="{num(r)}" '
+            f'class="venn-circle" style="fill:{accents[i]};stroke:{accents[i]}"/>'
+        )
+    for i, (cx, _cy, r) in enumerate(circles):
+        ly = circles[i][1] - r - 4 if n == 3 and i == 0 else circles[i][1] - r - 4
+        parts.append(
+            f'<text x="{num(cx)}" y="{num(ly)}" class="venn-label" '
+            f'text-anchor="middle">{escape(columns[i])}</text>'
+        )
+    for region, (x, y) in pos.items():
+        count = region_counts.get(region, 0)
+        if count <= 0:
+            continue
+        parts.append(
+            f'<text x="{num(x)}" y="{num(y)}" class="venn-count" '
+            f'text-anchor="middle">{count}</text>'
+        )
+    return (
+        f'<svg viewBox="0 0 {num(width)} {num(height)}" width="{num(width)}" '
+        f'height="{num(height)}" class="venn-svg" aria-hidden="true">'
+        f'{"".join(parts)}</svg>'
+    )
+
+
+def bar_series(
+    values: list[float],
+    *,
+    accent: str,
+    width: float = 320.0,
+    height: float = 120.0,
+    gap: float = 2.0,
+) -> str:
+    """Barres verticales (``values`` dans l'ordre fourni — l'appelant trie).
+
+    Hauteur ∝ valeur / max ; échelle propre à la série. Étiré par CSS
+    (``preserveAspectRatio="none"``). Déterministe (coords ``num``), zéro JS."""
+    n = len(values)
+    if n == 0:
+        return (
+            f'<svg viewBox="0 0 {num(width)} {num(height)}" class="bars-svg" '
+            'aria-hidden="true"></svg>'
+        )
+    vmax = max(values) or 1.0
+    bw = (width - gap * (n - 1)) / n
+    bars: list[str] = []
+    x = 0.0
+    for v in values:
+        h = max(0.0, v) / vmax * height
+        bars.append(
+            f'<rect x="{num(x)}" y="{num(height - h)}" width="{num(bw)}" '
+            f'height="{num(h)}" style="fill:{accent}"/>'
+        )
+        x += bw + gap
+    return (
+        f'<svg viewBox="0 0 {num(width)} {num(height)}" class="bars-svg" '
+        f'preserveAspectRatio="none" aria-hidden="true">{"".join(bars)}</svg>'
+    )
+
+
+def composition_bar(
+    segments: list[tuple[float, str]],
+    *,
+    width: float = 100.0,
+    height: float = 14.0,
+) -> str:
+    """Barre **empilée** horizontale : ``segments`` = ``(part, couleur)``.
+
+    Les parts sont normalisées (somme → largeur pleine). Étirée à 100 % par CSS
+    (``preserveAspectRatio="none"``). Déterministe (coords ``num``), zéro JS."""
+    total = sum(s for s, _ in segments) or 1.0
+    parts: list[str] = []
+    x = 0.0
+    for share, color in segments:
+        w = share / total * width
+        parts.append(
+            f'<rect x="{num(x)}" y="0" width="{num(w)}" height="{num(height)}" '
+            f'style="fill:{color}"/>'
+        )
+        x += w
+    return (
+        f'<svg viewBox="0 0 {num(width)} {num(height)}" class="comp-bar" '
+        f'preserveAspectRatio="none" aria-hidden="true">{"".join(parts)}</svg>'
+    )
+
+
+def calibration_curve(
+    points: list[tuple[float, float]],
+    *,
+    accent: str,
+    size: float = 180.0,
+) -> str:
+    """Courbe de fiabilité : ``points`` = ``(confiance, exactitude)`` dans [0,1].
+
+    Diagonale pointillée = calibration parfaite ; la polyligne (+ disques) = le
+    moteur. L'axe **y** est inversé (SVG vers le bas) : ``y = (1 - exactitude)``.
+    Déterministe (coordonnées via ``num``), zéro JS."""
+
+    def px(v: float) -> float:
+        return max(0.0, min(v, 1.0)) * size
+
+    diag = (
+        f'<line x1="0" y1="{num(size)}" x2="{num(size)}" y2="0" class="calib-diag"/>'
+    )
+    if not points:
+        return (
+            f'<svg viewBox="0 0 {num(size)} {num(size)}" class="calib-svg" '
+            f'aria-hidden="true">{diag}</svg>'
+        )
+    pts = sorted(points)
+    coords = " ".join(f"{num(px(c))},{num(size - px(a))}" for c, a in pts)
+    dots = "".join(
+        f'<circle cx="{num(px(c))}" cy="{num(size - px(a))}" r="2.6" '
+        f'class="calib-pt" style="fill:{accent}"/>'
+        for c, a in pts
+    )
+    return (
+        f'<svg viewBox="0 0 {num(size)} {num(size)}" class="calib-svg" '
+        f'aria-hidden="true">{diag}'
+        f'<polyline points="{coords}" class="calib-line" style="stroke:{accent}"/>'
+        f"{dots}</svg>"
+    )
+
+
+def _clip_word(word: str) -> str:
+    """Tronque un mot à l'affichage (le mot complet reste dans la table HTML)."""
+    if len(word) <= _HEATMAP_WORD_CHARS:
+        return word
+    return word[: _HEATMAP_WORD_CHARS - 1] + "…"
+
+
+def word_engine_heatmap(
+    columns: list[str],
+    rows: list[tuple[str, list[int]]],
+    *,
+    accent: str,
+    cell_w: float = 30.0,
+    cell_h: float = 22.0,
+    label_w: float = 156.0,
+    header_h: float = 18.0,
+) -> str:
+    """Heatmap mots × moteurs : lignes = mots **verbatim**, colonnes = moteurs.
+
+    ``columns`` = libellés de colonnes (lettres moteur) ; ``rows`` =
+    ``(mot, [compte par colonne])`` aligné sur ``columns``. Chaque case est teintée
+    par **opacité ∝ compte / max** (case vide = pas de fond), le compte est inscrit ;
+    le mot (tronqué à l'affichage) et les en-têtes sont **échappés** (texte SVG sûr,
+    anti-XSS). Compagnon **visuel** de la table de la section (``aria-hidden`` : la
+    matière accessible vit dans la table). Déterministe (coords ``num``),
+    octet-stable, zéro JS."""
+    n_cols = len(columns)
+    width = label_w + cell_w * n_cols
+    height = header_h + cell_h * len(rows)
+    vmax = max((max(counts, default=0) for _, counts in rows), default=0) or 1
+    parts: list[str] = []
+    for j, column in enumerate(columns):
+        cx = label_w + cell_w * j + cell_w / 2
+        parts.append(
+            f'<text x="{num(cx)}" y="{num(header_h - 5)}" class="wmap-head" '
+            f'text-anchor="middle">{escape(column)}</text>'
+        )
+    for i, (word, counts) in enumerate(rows):
+        y = header_h + cell_h * i
+        ty = y + cell_h / 2 + 3.5
+        parts.append(
+            f'<text x="{num(label_w - 7)}" y="{num(ty)}" class="wmap-word" '
+            f'text-anchor="end">{escape(_clip_word(word))}</text>'
+        )
+        for j in range(n_cols):
+            count = counts[j] if j < len(counts) else 0
+            x = label_w + cell_w * j
+            if count <= 0:
+                parts.append(
+                    f'<rect x="{num(x)}" y="{num(y)}" width="{num(cell_w)}" '
+                    f'height="{num(cell_h)}" class="wmap-cell" style="fill:none"/>'
+                )
+                continue
+            opacity = 0.18 + 0.82 * count / vmax
+            ink = "var(--paper)" if opacity > 0.55 else "var(--ink)"
+            parts.append(
+                f'<rect x="{num(x)}" y="{num(y)}" width="{num(cell_w)}" '
+                f'height="{num(cell_h)}" class="wmap-cell" '
+                f'style="fill:{accent};opacity:{num(opacity)}"/>'
+                f'<text x="{num(x + cell_w / 2)}" y="{num(ty)}" class="wmap-count" '
+                f'text-anchor="middle" style="fill:{ink}">{count}</text>'
+            )
+    return (
+        f'<svg viewBox="0 0 {num(width)} {num(height)}" '
+        f'width="{num(width)}" height="{num(height)}" class="wmap-svg" '
+        f'aria-hidden="true">{"".join(parts)}</svg>'
+    )
+
+
+def dot_plot_ci(
+    rows: list[tuple[str, str, float, float, float]],
+    scale_max: float,
+    *,
+    width: float = 320.0,
+    row_h: float = 22.0,
+    pad_left: float = 22.0,
+) -> str:
+    """Dot plot **classé** : par ligne ``(lettre, accent, moyenne, IC bas, IC haut)``,
+    une moustache d'IC + un point à la moyenne sur un axe **commun** ``[0, scale_max]``.
+
+    L'appelant trie (ordre = rendu). Échelle partagée → comparaison directe ;
+    l'IC (bootstrap 95 %, calculé en couche evaluation) **montre** l'incertitude
+    sans la trancher. Déterministe (coords ``num``), zéro JS, ``aria-hidden`` (la
+    matière vit dans la table)."""
+    n = len(rows)
+    if n == 0:
+        return (
+            f'<svg viewBox="0 0 {num(width)} 12" class="dot-svg" '
+            'aria-hidden="true"></svg>'
+        )
+    s = scale_max or 1.0
+    height = row_h * n + 16
+    plot_w = width - pad_left - 8
+
+    def x(v: float) -> float:
+        return pad_left + max(0.0, min(v / s, 1.0)) * plot_w
+
+    axis_y = height - 10
+    parts = [
+        f'<line x1="{num(pad_left)}" y1="{num(axis_y)}" x2="{num(pad_left + plot_w)}" '
+        f'y2="{num(axis_y)}" class="dot-axis"/>'
+    ]
+    for i, (letter, accent, mean, lo, hi) in enumerate(rows):
+        cy = 8.0 + i * row_h + row_h / 2
+        parts.append(
+            f'<line x1="{num(x(lo))}" y1="{num(cy)}" x2="{num(x(hi))}" '
+            f'y2="{num(cy)}" class="dot-ci" style="stroke:{accent}"/>'
+            f'<circle cx="{num(x(mean))}" cy="{num(cy)}" r="4" '
+            f'class="dot-pt" style="fill:{accent}"/>'
+            f'<text x="2" y="{num(cy + 3.5)}" class="dot-lbl">{escape(letter)}</text>'
+        )
+    return (
+        f'<svg viewBox="0 0 {num(width)} {num(height)}" width="{num(width)}" '
+        f'height="{num(height)}" class="dot-svg" aria-hidden="true">'
+        f'{"".join(parts)}</svg>'
+    )
diff --git a/cinoc/reports/text_diff.py b/cinoc/reports/text_diff.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a6d84707069bfd470d03728d44d877385dd2c94
--- /dev/null
+++ b/cinoc/reports/text_diff.py
@@ -0,0 +1,44 @@
+"""Diff **GT ↔ hypothèse** surligné (couche 7) — caractère par caractère, déterministe.
+
+Aligne référence et hypothèse via ``difflib.SequenceMatcher`` (stdlib, déterministe)
+et marque les écarts : **suppressions** (caractères de la GT absents de l'hypothèse,
+``<del>``) et **insertions** (caractères de l'hypothèse absents de la GT, ``<ins>``).
+Le texte est **échappé** avant marquage (les balises sont les seules non échappées,
+de confiance) — frontière anti-XSS. Aucun JS : le surlignage est du HTML rendu côté
+serveur, donc octet-stable.
+"""
+
+from __future__ import annotations
+
+from difflib import SequenceMatcher
+
+from cinoc.reports.html import escape
+from cinoc.reports.section import Html
+
+
+def char_diff(reference: str, hypothesis: str) -> tuple[Html, Html]:
+    """``(ref_html, hyp_html)`` : écarts surlignés, alignés caractère à caractère.
+
+    ``ref_html`` = la GT avec ses **suppressions** marquées ``<del class="d-del">`` ;
+    ``hyp_html`` = l'hypothèse avec ses **insertions** marquées ``<ins class="d-ins">``.
+    Les segments identiques sont rendus tels quels (échappés). Un ``replace`` est
+    une suppression **et** une insertion (les deux côtés sont marqués).
+    """
+    matcher = SequenceMatcher(None, reference, hypothesis, autojunk=False)
+    ref_parts: list[str] = []
+    hyp_parts: list[str] = []
+    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+        ref_seg = escape(reference[i1:i2])
+        hyp_seg = escape(hypothesis[j1:j2])
+        if tag == "equal":
+            ref_parts.append(ref_seg)
+            hyp_parts.append(hyp_seg)
+            continue
+        if ref_seg:
+            ref_parts.append(f'<del class="d-del">{ref_seg}</del>')
+        if hyp_seg:
+            hyp_parts.append(f'<ins class="d-ins">{hyp_seg}</ins>')
+    return Html("".join(ref_parts)), Html("".join(hyp_parts))
+
+
+__all__ = ["char_diff"]
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4783cb67c67b5cfcc09c6e7b365fe12010250d12
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,117 @@
+[build-system]
+requires = ["setuptools>=68", "setuptools_scm>=8"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cinoc"
+description = "Banc d'essai déterministe de pipelines de transcription (OCR / HTR / VLM)."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "Apache-2.0" }
+dynamic = ["version"]
+dependencies = [
+    "pydantic>=2",
+    "lxml>=5",
+    "pyyaml>=6",
+    "scipy>=1.11",
+    "rapidfuzz>=3",
+    # numpy est une dépendance directe de evaluation/ (jusqu'ici tirée via scipy).
+    # Plafond <2.5 : numpy 2.5 (Python >=3.12 uniquement) livre des stubs en
+    # syntaxe PEP 695 `type X = ...` que mypy, ciblant python_version 3.11, refuse
+    # de parser. À relever quand l'interaction mypy/numpy est résolue en amont.
+    "numpy<2.5",
+]
+
+[project.optional-dependencies]
+dev = [
+    "ruff", "mypy", "pytest", "pytest-cov", "pytest-xdist", "lxml-stubs",
+    "types-PyYAML", "jiwer", "fastapi", "httpx", "httpcore", "jinja2",
+    "python-multipart", "Pillow",
+]
+tesseract = ["pytesseract"]
+kraken = ["kraken"]
+pero = ["pero-ocr"]  # OCR/HTR local (imprimé ancien + manuscrit) — non déployé au Space
+calamari = ["calamari-ocr"]  # OCR local par ligne — non déployé au Space
+openai = ["openai"]
+anthropic = ["anthropic"]
+mistral = ["mistralai>=1.5,<2"]  # 2.x = SDK incompatible (pas de `from mistralai import Mistral`)
+google = ["httpx", "httpcore"]  # Vision via REST (≠ SDK gRPC lourd) — clé GOOGLE_VISION_API_KEY
+azure = ["httpx", "httpcore"]  # Document Intelligence via REST — AZURE_DOC_INTEL_ENDPOINT + _KEY
+ollama = ["httpx", "httpcore"]
+huggingface = ["datasets", "huggingface_hub"]  # datasets = streaming ; huggingface_hub = publication (scripts/) + snapshot dataset curé (import_curated_hf_corpus)
+segment = ["paddlex"]
+ner = ["spacy"]  # extraction d'entités nommées — modèle téléchargé à part (`spacy download`)
+serve = ["fastapi", "uvicorn", "jinja2", "python-multipart", "httpx", "httpcore"]
+images = ["Pillow"]  # vignettes réelles du rapport (redimensionnement) — dégradé gracieux sans
+# Oracle de conformité HIPE (golden test, jamais en runtime — SPEC_HIPE §5).
+# Extra DÉDIÉ (pas dans dev) : le scorer exige Python >= 3.12, l'inclure dans
+# dev casserait l'installation 3.11. Installé par le seul job CI 3.12.
+hipe-oracle = ["hipe-ocrepair-scorer==0.9.9"]
+
+[project.scripts]
+cinoc = "cinoc.interfaces.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["cinoc*"]
+
+# La coquille web embarque ses gabarits + assets auto-hébergés (CSS, polices) ;
+# ils doivent voyager dans le wheel pour exister après ``pip install`` (Space/CI).
+[tool.setuptools.package-data]
+"cinoc.interfaces.web" = [
+    "templates/*.html", "static/css/*.css", "static/js/*.js", "static/fonts/*",
+]
+# Le rapport autonome (couche 7) incorpore ses polices (data-URI) et son script
+# de comparaison (inliné) : woff2 + compare.js doivent voyager dans le wheel.
+"cinoc.reports" = ["_assets/*.woff2", "_assets/*.js"]
+# Glossaire pédagogique (donnée FR/EN) — doit voyager dans le wheel.
+"cinoc.reports.glossary" = ["*.yaml"]
+# Table de tarifs (donnée datée) du calcul économique (couche 3).
+"cinoc.evaluation" = ["pricing.json"]
+# Prompts curés par période (donnée LLM/VLM) — doivent voyager dans le wheel.
+"cinoc.prompts" = ["*.txt"]
+
+[tool.setuptools_scm]
+fallback_version = "0.1.0"
+version_file = "cinoc/_version.py"
+
+[tool.ruff]
+line-length = 88
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP", "B"]
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+warn_unused_ignores = false
+plugins = ["pydantic.mypy"]
+
+[tool.pytest.ini_options]
+pythonpath = ["."]
+testpaths = ["tests"]
+# Coverage = concern du GATE, pas de la boucle locale : pas dans addopts (sinon
+# chaque `pytest`, même un sous-ensemble, paierait ×3,4 le tracing). Elle est
+# injectée explicitement par `make cov`/`make ci` et la CI (cf. Makefile/ci.yml).
+markers = [
+    "slow: tests lents (opt-in)",
+    "network: tests qui touchent le réseau (opt-in)",
+    "live: tests contre une vraie API/binaire (opt-in)",
+]
+filterwarnings = [
+    # `starlette.testclient` (versions 2026) émet une dépréciation httpx→httpx2
+    # à l'IMPORT — purement côté tests (la prod sert via uvicorn, sans TestClient).
+    # Dette amont, hors de notre code ; filtrée pour garder la sortie propre.
+    "ignore:Using .httpx. with .starlette.testclient.:Warning",
+]
+
+[tool.coverage.run]
+omit = ["*/_version.py"]
+
+[tool.coverage.report]
+exclude_also = [
+    "if TYPE_CHECKING:",
+    "raise NotImplementedError",
+    "^\\s*\\.\\.\\.$",
+    "^\\s*\\.\\.\\.\\s*#",
+]
diff --git a/reports/.gitkeep b/reports/.gitkeep
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/reports/demonstration.json b/reports/demonstration.json
new file mode 100644
index 0000000000000000000000000000000000000000..591c719895b11af048fe5e726fe1b6cde366b60c
--- /dev/null
+++ b/reports/demonstration.json
@@ -0,0 +1,494 @@
+{
+  "schema_version": 1,
+  "manifest": {
+    "run_id": "demo",
+    "corpus_name": "demo",
+    "n_documents": 3,
+    "pipeline_specs": [
+      {
+        "name": "tesseract",
+        "description": "",
+        "initial_inputs": [
+          "image"
+        ],
+        "steps": [
+          {
+            "id": "ocr",
+            "kind": "ocr",
+            "adapter_name": "precomputed:tesseract",
+            "params": {},
+            "input_types": [
+              "image"
+            ],
+            "output_types": [
+              "raw_text"
+            ],
+            "inputs_from": {}
+          }
+        ]
+      },
+      {
+        "name": "pero",
+        "description": "",
+        "initial_inputs": [
+          "image"
+        ],
+        "steps": [
+          {
+            "id": "ocr",
+            "kind": "ocr",
+            "adapter_name": "precomputed:pero",
+            "params": {},
+            "input_types": [
+              "image"
+            ],
+            "output_types": [
+              "raw_text"
+            ],
+            "inputs_from": {}
+          }
+        ]
+      }
+    ],
+    "adapter_kwargs": {
+      "precomputed:pero": {
+        "source_label": "pero"
+      },
+      "precomputed:tesseract": {
+        "source_label": "tesseract"
+      }
+    },
+    "view_specs": [
+      {
+        "name": "text",
+        "description": "",
+        "candidate_types": [
+          "raw_text"
+        ],
+        "projection": null,
+        "projections_by_source_type": {},
+        "normalization_profile": null,
+        "char_exclude": null,
+        "metric_names": [
+          "cer",
+          "wer",
+          "mer"
+        ],
+        "ignored_dimensions": [],
+        "warnings": []
+      },
+      {
+        "name": "francais_medieval",
+        "description": "",
+        "candidate_types": [
+          "raw_text"
+        ],
+        "projection": null,
+        "projections_by_source_type": {},
+        "normalization_profile": "medieval_french",
+        "char_exclude": null,
+        "metric_names": [
+          "cer",
+          "wer",
+          "mer"
+        ],
+        "ignored_dimensions": [],
+        "warnings": []
+      }
+    ],
+    "code_version": "0.1.1.dev25+gca59b82a2",
+    "started_at": "2026-06-01T07:07:12.591327Z",
+    "completed_at": "2026-06-01T07:07:13.202600Z",
+    "dependencies_lock": {},
+    "system_binaries_lock": {},
+    "module_versions": {
+      "precomputed:pero": "1.0",
+      "precomputed:tesseract": "1.0"
+    },
+    "metadata": {}
+  },
+  "pipelines": [
+    {
+      "pipeline": "tesseract",
+      "view": "text",
+      "aggregate": [
+        {
+          "metric": "cer",
+          "value": 0.014285714285714285,
+          "support": 3
+        },
+        {
+          "metric": "wer",
+          "value": 0.09090909090909091,
+          "support": 3
+        },
+        {
+          "metric": "mer",
+          "value": 0.09090909090909091,
+          "support": 3
+        }
+      ]
+    },
+    {
+      "pipeline": "pero",
+      "view": "text",
+      "aggregate": [
+        {
+          "metric": "cer",
+          "value": 0.02857142857142857,
+          "support": 3
+        },
+        {
+          "metric": "wer",
+          "value": 0.09090909090909091,
+          "support": 3
+        },
+        {
+          "metric": "mer",
+          "value": 0.09090909090909091,
+          "support": 3
+        }
+      ]
+    },
+    {
+      "pipeline": "tesseract",
+      "view": "francais_medieval",
+      "aggregate": [
+        {
+          "metric": "cer",
+          "value": 0.0,
+          "support": 3
+        },
+        {
+          "metric": "wer",
+          "value": 0.0,
+          "support": 3
+        },
+        {
+          "metric": "mer",
+          "value": 0.0,
+          "support": 3
+        }
+      ]
+    },
+    {
+      "pipeline": "pero",
+      "view": "francais_medieval",
+      "aggregate": [
+        {
+          "metric": "cer",
+          "value": 0.0,
+          "support": 3
+        },
+        {
+          "metric": "wer",
+          "value": 0.0,
+          "support": 3
+        },
+        {
+          "metric": "mer",
+          "value": 0.0,
+          "support": 3
+        }
+      ]
+    }
+  ],
+  "documents": [
+    {
+      "document_id": "folio_001",
+      "pipeline": "tesseract",
+      "view": "text",
+      "scores": [
+        {
+          "metric": "cer",
+          "value": 0.041666666666666664,
+          "support": 24
+        },
+        {
+          "metric": "wer",
+          "value": 0.25,
+          "support": 4
+        },
+        {
+          "metric": "mer",
+          "value": 0.25,
+          "support": 4
+        }
+      ]
+    },
+    {
+      "document_id": "folio_002",
+      "pipeline": "tesseract",
+      "view": "text",
+      "scores": [
+        {
+          "metric": "cer",
+          "value": 0.0,
+          "support": 23
+        },
+        {
+          "metric": "wer",
+          "value": 0.0,
+          "support": 3
+        },
+        {
+          "metric": "mer",
+          "value": 0.0,
+          "support": 3
+        }
+      ]
+    },
+    {
+      "document_id": "folio_003",
+      "pipeline": "tesseract",
+      "view": "text",
+      "scores": [
+        {
+          "metric": "cer",
+          "value": 0.0,
+          "support": 23
+        },
+        {
+          "metric": "wer",
+          "value": 0.0,
+          "support": 4
+        },
+        {
+          "metric": "mer",
+          "value": 0.0,
+          "support": 4
+        }
+      ]
+    },
+    {
+      "document_id": "folio_001",
+      "pipeline": "pero",
+      "view": "text",
+      "scores": [
+        {
+          "metric": "cer",
+          "value": 0.0,
+          "support": 24
+        },
+        {
+          "metric": "wer",
+          "value": 0.0,
+          "support": 4
+        },
+        {
+          "metric": "mer",
+          "value": 0.0,
+          "support": 4
+        }
+      ]
+    },
+    {
+      "document_id": "folio_002",
+      "pipeline": "pero",
+      "view": "text",
+      "scores": [
+        {
+          "metric": "cer",
+          "value": 0.08695652173913043,
+          "support": 23
+        },
+        {
+          "metric": "wer",
+          "value": 0.3333333333333333,
+          "support": 3
+        },
+        {
+          "metric": "mer",
+          "value": 0.3333333333333333,
+          "support": 3
+        }
+      ]
+    },
+    {
+      "document_id": "folio_003",
+      "pipeline": "pero",
+      "view": "text",
+      "scores": [
+        {
+          "metric": "cer",
+          "value": 0.0,
+          "support": 23
+        },
+        {
+          "metric": "wer",
+          "value": 0.0,
+          "support": 4
+        },
+        {
+          "metric": "mer",
+          "value": 0.0,
+          "support": 4
+        }
+      ]
+    },
+    {
+      "document_id": "folio_001",
+      "pipeline": "tesseract",
+      "view": "francais_medieval",
+      "scores": [
+        {
+          "metric": "cer",
+          "value": 0.0,
+          "support": 24
+        },
+        {
+          "metric": "wer",
+          "value": 0.0,
+          "support": 4
+        },
+        {
+          "metric": "mer",
+          "value": 0.0,
+          "support": 4
+        }
+      ]
+    },
+    {
+      "document_id": "folio_002",
+      "pipeline": "tesseract",
+      "view": "francais_medieval",
+      "scores": [
+        {
+          "metric": "cer",
+          "value": 0.0,
+          "support": 23
+        },
+        {
+          "metric": "wer",
+          "value": 0.0,
+          "support": 3
+        },
+        {
+          "metric": "mer",
+          "value": 0.0,
+          "support": 3
+        }
+      ]
+    },
+    {
+      "document_id": "folio_003",
+      "pipeline": "tesseract",
+      "view": "francais_medieval",
+      "scores": [
+        {
+          "metric": "cer",
+          "value": 0.0,
+          "support": 23
+        },
+        {
+          "metric": "wer",
+          "value": 0.0,
+          "support": 4
+        },
+        {
+          "metric": "mer",
+          "value": 0.0,
+          "support": 4
+        }
+      ]
+    },
+    {
+      "document_id": "folio_001",
+      "pipeline": "pero",
+      "view": "francais_medieval",
+      "scores": [
+        {
+          "metric": "cer",
+          "value": 0.0,
+          "support": 24
+        },
+        {
+          "metric": "wer",
+          "value": 0.0,
+          "support": 4
+        },
+        {
+          "metric": "mer",
+          "value": 0.0,
+          "support": 4
+        }
+      ]
+    },
+    {
+      "document_id": "folio_002",
+      "pipeline": "pero",
+      "view": "francais_medieval",
+      "scores": [
+        {
+          "metric": "cer",
+          "value": 0.0,
+          "support": 23
+        },
+        {
+          "metric": "wer",
+          "value": 0.0,
+          "support": 3
+        },
+        {
+          "metric": "mer",
+          "value": 0.0,
+          "support": 3
+        }
+      ]
+    },
+    {
+      "document_id": "folio_003",
+      "pipeline": "pero",
+      "view": "francais_medieval",
+      "scores": [
+        {
+          "metric": "cer",
+          "value": 0.0,
+          "support": 23
+        },
+        {
+          "metric": "wer",
+          "value": 0.0,
+          "support": 4
+        },
+        {
+          "metric": "mer",
+          "value": 0.0,
+          "support": 4
+        }
+      ]
+    }
+  ],
+  "cross_engine": [
+    {
+      "metric": "text:cer:significance_p",
+      "value": null,
+      "support": 3
+    },
+    {
+      "metric": "text:wer:significance_p",
+      "value": null,
+      "support": 3
+    },
+    {
+      "metric": "text:mer:significance_p",
+      "value": null,
+      "support": 3
+    },
+    {
+      "metric": "francais_medieval:cer:significance_p",
+      "value": null,
+      "support": 3
+    },
+    {
+      "metric": "francais_medieval:wer:significance_p",
+      "value": null,
+      "support": 3
+    },
+    {
+      "metric": "francais_medieval:mer:significance_p",
+      "value": null,
+      "support": 3
+    }
+  ]
+}
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..81d51b01aebde7ba710a50477887d14863519bb4
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,29 @@
+# Dépendances de la vitrine Cinoc (Space lecture seule).
+# Le cœur + l'extra [serve] uniquement — aucun moteur (tesseract/LLM) n'est servi.
+# Épinglé pour la reproductibilité du Space (cf. §12) ; relever au besoin.
+pydantic>=2,<3
+lxml>=5
+pyyaml>=6
+scipy>=1.11
+# numpy : dépendance directe de evaluation/. Plafond <2.5 (stubs PEP 695
+# incompatibles avec mypy ciblant 3.11) — cohérent avec pyproject.
+numpy<2.5
+rapidfuzz>=3,<4
+fastapi>=0.115,<1
+uvicorn>=0.30,<1
+jinja2>=3.1,<4
+python-multipart>=0.0.9,<1
+# httpx : la vitrine importe les importeurs de corpus (couche 5) → transport HTTP.
+# httpcore : moteur de httpx (co-installé) — épinglage d'IP anti-DNS-rebinding.
+httpx>=0.27,<1
+httpcore>=1,<2
+# Moteur cloud OPT-IN (Mistral) : permet les runs OCR→LLM / VLM sur un Space
+# **privé** qui ouvre la surface (``CINOC_PUBLIC_MODE=false`` + secret
+# ``MISTRAL_API_KEY``). SDK léger (aucune dépendance lourde / GPU). En mode public
+# (le défaut), les moteurs cloud restent **masqués** : ce paquet est inutilisé.
+mistralai>=1.5,<2
+# Socle OCR gratuit (Tesseract) : wrapper Python pur du binaire ``tesseract``.
+# **Effectif uniquement dans l'image moteur** (deploy/Dockerfile.engine, qui bake
+# le binaire + les langues). Dans la vitrine lecture seule (sans binaire), il reste
+# **inerte** : importé paresseusement, jamais exécuté → tesseract y est indisponible.
+pytesseract>=0.3.10,<1