diff --git a/.github/workflows/eval.yml b/.github/workflows/eval.yml
new file mode 100644
index 0000000..0d3dacc
--- /dev/null
+++ b/.github/workflows/eval.yml
@@ -0,0 +1,48 @@
+name: eval
+
+# Non-régression de la qualité d'extraction contre le vrai modèle.
+#
+# Les runners GitHub n'ont pas de GPU : ce workflow tourne sur un runner
+# auto-hébergé enregistré sur le DGX Spark avec le label `dgx`, et vise le
+# backend déployé sur cette machine. Lancement manuel (onglet Actions →
+# eval → Run workflow), typiquement sur la branche d'une PR qui touche aux
+# prompts, au modèle, au découpage ou aux templates.
+#
+# La référence (eval/baseline.json) se met à jour par PR, après validation :
+#   python eval/regression.py --api http://localhost:8080 --api-key $KEY --update-baseline
+
+on:
+  workflow_dispatch:
+    inputs:
+      api:
+        description: URL du backend à évaluer
+        default: http://localhost:8080
+      forms:
+        description: Formulaires (séparés par des espaces, vide = les 21)
+        default: ""
+
+jobs:
+  regression:
+    runs-on: [self-hosted, dgx]
+    timeout-minutes: 180
+    steps:
+      - uses: actions/checkout@v4
+      # truth.py n'importe que la partie pure de l'orchestrateur (core/fields, core/provenance).
+      - run: python3 -m pip install --user "httpx>=0.27.0,<1.0"
+      - name: Dossiers de test contre le backend
+        env:
+          API_KEY: ${{ secrets.DOCTORFILL_API_KEY }}
+          API_URL: ${{ inputs.api }}
+          FORMS: ${{ inputs.forms }}
+        run: |
+          python3 eval/regression.py --api "$API_URL" --api-key "$API_KEY" \
+            ${FORMS:+--forms $FORMS} --report report.md --json results.json
+      - if: always()
+        run: cat report.md >> "$GITHUB_STEP_SUMMARY" || true
+      - if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: eval-report
+          path: |
+            report.md
+            results.json
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
new file mode 100644
index 0000000..3cd12c0
--- /dev/null
+++ b/.github/workflows/tests.yml
@@ -0,0 +1,73 @@
+name: tests
+
+# À déclarer comme « required status checks » sur main (Settings → Branches) :
+# lint, orchestrator, marker-ocr, frontend. Sans cette règle, un merge reste
+# possible malgré une CI rouge.
+
+on:
+  push:
+    branches: [main, dev]
+  pull_request:
+
+concurrency:
+  group: tests-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install "ruff==0.16.9"
+      # Erreurs seulement (noms indéfinis, imports inutiles, syntaxe) : pas de style imposé.
+      - run: ruff check --select F,E9 services eval
+
+  orchestrator:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: services/orchestrator
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          # Celle de l'image nvcr.io/nvidia/pytorch de l'orchestrateur.
+          python-version: "3.12"
+          cache: pip
+          cache-dependency-path: services/orchestrator/requirements*.txt
+      - run: pip install -r requirements-dev.txt
+      # Sans GPU ni service : OCR, TEI et vLLM sont simulés. Couvre les 21
+      # formulaires du catalogue et les 21 dossiers de eval/dossiers/.
+      - run: python -m pytest tests -q --cov=. --cov-report=term:skip-covered --cov-fail-under=70
+
+  marker-ocr:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: services/marker_ocr
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      # textlayer.py seul : marker et ses modèles ne sont pas nécessaires.
+      - run: pip install "pypdfium2>=4.30.0,<6.0" "pikepdf>=9.0.0,<11.0" "pytest>=8.0,<10.0"
+      - run: python -m pytest tests -q
+
+  frontend:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: frontend
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+          cache-dependency-path: frontend/package-lock.json
+      - run: npm ci
+      - run: npm run build
diff --git a/.gitignore b/.gitignore
index df0c0ef..c85de79 100644
--- a/.gitignore
+++ b/.gitignore
@@ -27,9 +27,17 @@ services/orchestrator/uploads/
 services/orchestrator/results/
 
 # ── eval & logs
-eval
+# Seuls les sorties et les documents générés sont ignorés : une règle `eval`
+# entière rendait inertes les scripts et dossiers de test versionnés, et faisait
+# échouer tout `git add` sur eux.
+eval/results/
+eval/test_docs/
 services/logs/*.md
 
+# ── tests
+.pytest_cache
+.coverage
+
 # ── Formulaires medForms récupérés par tools/gen_catalog.py ──
 # Les PDF vierges appartiennent à medForms et pèsent ~2 Mo pièce : on versionne
 # la liste (tools/catalog_fr.txt) et les templates dérivés, pas les binaires.
diff --git a/README.md b/README.md
index 02eecaf..6501bc3 100644
--- a/README.md
+++ b/README.md
@@ -103,6 +103,20 @@ doctorfill/
 └── docs/wiki/                # Documentation wiki
 ```
 
+## Tests
+
+```bash
+cd services/orchestrator
+pip install -r requirements-dev.txt
+python -m pytest tests      # sans GPU : OCR, TEI et vLLM sont simulés
+```
+
+Exécutés en CI à chaque PR (`.github/workflows/tests.yml`) : les 21 formulaires
+et les 21 dossiers de `eval/dossiers/` de bout en bout. La qualité d'extraction
+du vrai modèle se contrôle avec `eval/regression.py` contre une référence.
+Détails, et réglage de GitHub pour bloquer un merge rouge :
+[docs/wiki/Tests.md](docs/wiki/Tests.md).
+
 ## Évaluation RAG
 
 ```bash
@@ -116,7 +130,10 @@ python generate_docs.py --count 60 --noise 10
 python run_eval.py --api http://localhost:8080 --api-key <KEY>
 ```
 
-Précision actuelle : **84.6%** sur Form_AVS (26 champs) — voir [#21](https://github.com/doctorfill-dev/DoctorFill/issues/21) pour le plan d'amélioration.
+Non-régression sur les 21 dossiers (vérité terrain dérivée des scénarios) :
+`python eval/regression.py --api http://localhost:8080 --api-key <KEY>` — voir [docs/wiki/Tests.md](docs/wiki/Tests.md).
+
+Dernière mesure connue, avant septembre 2026 : **84.6%** sur Form_AVS (26 champs) — voir [#21](https://github.com/doctorfill-dev/DoctorFill/issues/21) pour le plan d'amélioration.
 
 ## Roadmap
 
diff --git a/docs/wiki/Home.md b/docs/wiki/Home.md
index 10caf1d..e1f0109 100644
--- a/docs/wiki/Home.md
+++ b/docs/wiki/Home.md
@@ -11,6 +11,7 @@ Bienvenue sur le wiki de **DoctorFill**, l'application d'auto-remplissage de for
 | [Déploiement Frontend (Cloudflare)](Deploiement-Frontend-Cloudflare) | Déploiement du frontend sur Cloudflare Pages + Tunnel |
 | [Pipeline RAG](Pipeline-RAG) | Fonctionnement du pipeline RAG (OCR → Embedding → Retrieval → LLM) |
 | [Templates](Templates) | Documentation des templates de formulaires (AVS, Cardio, LAA) |
+| [Tests](Tests) | Tests en CI et non-régression de la qualité d'extraction |
 
 ## Stack technique
 
diff --git a/docs/wiki/Pipeline-RAG.md b/docs/wiki/Pipeline-RAG.md
index 6304f86..e1dd460 100644
--- a/docs/wiki/Pipeline-RAG.md
+++ b/docs/wiki/Pipeline-RAG.md
@@ -2,96 +2,136 @@
 
 ## Vue d'ensemble
 
-Le pipeline RAG (Retrieval-Augmented Generation) est le coeur de DoctorFill. Il extrait automatiquement les informations des documents médicaux pour remplir les formulaires.
+Le pipeline extrait les informations des documents médicaux d'un dossier pour
+remplir un formulaire medForms (XFA statique hybride, couche AcroForm comprise).
+Il est piloté par l'orchestrateur (`services/orchestrator/app.py`) et partagé
+par le traitement initial et le re-run (`_extract_fields`, `_fill_pdf`).
 
-## Étapes du pipeline
+```
+PDF ──► OCR (texte natif, sinon marker) ──► découpage + embeddings (ChromaDB)
+                                         └► synthèse médicale (LLM)
+                                                   │
+        champs du template ──► questions univoques ──► lots ──► LLM (JSON contraint)
+                                                                   │
+                           normalisation + provenance ◄────────────┘
+                                                   │
+                                     remplissage XFA + AcroForm
+```
 
-### 1. OCR — Extraction de texte
+## Étapes
 
-**Service** : Marker OCR (`:8082`)
+### 1. OCR
 
-- Chaque PDF est envoyé au service Marker OCR
-- Sortie : Markdown structuré (headings, tableaux, listes)
-- Parallélisation : `asyncio.Semaphore(5)` pour limiter les appels GPU concurrents
-- Timeout : 120s par document
+**Service** : `marker_ocr` (`:8082`). La couche texte native est lue d'abord
+(`textlayer.py`, quelques ms/page) ; l'OCR marker n'est lancé que pour les pages
+scannées. Résultats mis en cache par empreinte SHA-256.
 
-### 2. Chunking — Découpage du texte
+Un document illisible **n'interrompt plus le job** : il est écarté et signalé
+dans `warnings` (`/status`). Reprises proportionnées à la cause : service
+injoignable → 5 tentatives espacées ; délai dépassé ou 5xx → une seule reprise ;
+4xx → aucune. Si aucun document n'est lisible, le job échoue avec un message
+explicite.
 
-**Stratégie** : Semi-sémantique
+### 2. Découpage et embeddings
 
-1. **Découpage par headings Markdown** : chaque section `#`, `##`, `###` crée un chunk
-2. **Fallback** : si un chunk dépasse 400 mots, il est découpé avec 50 mots de chevauchement
+`extraction.chunk_document` — sections Markdown fusionnées si trop courtes
+(< 40 mots), découpées si trop longues (300 mots, chevauchement 50).
+**Chaque extrait porte sa source** : `[Source : 03_consultations.pdf — page 2 — Médecin traitant]`.
+Embeddings `BAAI/bge-m3` par lots de 64 (TEI `:8081`, reprises sur erreur
+transitoire), stockés dans une collection ChromaDB éphémère par job (réutilisée
+par le chat et le re-run).
 
-### 3. Embedding — Vectorisation
+### 3. Synthèse médicale
 
-**Service** : TEI (`:8081`) — Modèle `BAAI/bge-m3`
+`medical_synthesis.py` — JSON structuré (patient, diagnostics, incapacités,
+traitements, médecins, dates clés). Directe si le dossier tient dans la fenêtre,
+hiérarchique sinon (résumé par document, découpé si besoin, puis fusion).
+Replis : directe → hiérarchique ; fusion LLM → fusion déterministe. En cas
+d'échec complet, l'extraction continue sur les seuls documents.
 
-- Les chunks sont envoyés par batch de 64 pour éviter les timeouts
-- Les vecteurs sont stockés dans une collection ChromaDB éphémère (en mémoire)
-- Timeout : 120s par batch
+### 4. Préparation des champs
 
-### 4. Retrieval — Recherche sémantique
+`core/fields.py` :
 
-Pour chaque champ du formulaire :
+- **Champs soumis** : question rédigée, ni `computed` ni `preset` d'éditeur.
+  Un `preset` qui n'est que l'**état vierge** du champ (case « /Off », question
+  oui/non sur « non », compteur à 0) reste à remplir.
+- **Questions univoques** : les occurrences d'une structure répétée reçoivent
+  leur contexte — « (Contexte : période d'incapacité de travail n°2 sur 4 — de la
+  plus ancienne à la plus récente ; vide s'il n'y en a pas de n°2) ».
+- **Lots** : par section, jusqu'à 8 champs ; les occurrences d'une même
+  structure restent dans le même lot (jusqu'à 32) pour être réparties sans doublon.
 
-1. **Embedding de la question** : la question du template est vectorisée
-2. **Recherche ChromaDB** : `n_results = min(20, nombre_total_de_chunks)`
-3. **Reranking** : les 20 résultats sont re-classés par le modèle `BAAI/bge-reranker-v2-m3`
-4. **Sélection** : les 7 meilleurs chunks sont conservés
+### 5. Contexte du prompt
 
-### 5. Extraction LLM
+Deux modes, choisis par job selon un budget en tokens (`extraction.py`) :
 
-**Service** : vLLM (`:8000`) — Modèle `Qwen/Qwen2.5-14B-Instruct-AWQ`
+| Mode | Quand | Contexte |
+|------|-------|----------|
+| Dossier intégral | dossier ≤ `FULL_CONTEXT_MAX_TOKENS` (16k) et place dans la fenêtre | texte complet de tous les documents, identique pour tous les lots (préfixe mis en cache par vLLM) |
+| Extraits | au-delà | recherche vectorielle (30 candidats) → rerank `bge-reranker-v2-m3` (top 8) → extraits **entrelacés par rang** entre les champs du lot, dans `RAG_CONTEXT_TOKENS` (9k) |
 
-- Les 7 chunks sélectionnés sont envoyés comme contexte
-- Le LLM extrait la valeur selon des règles strictes (prompt système dédié)
-- Température : 0.05 (quasi-déterministe)
-- Format de réponse : `{"value": "...", "source_quote": "..."}`
+La synthèse est transmise **en entier** à chaque lot, avant les documents.
 
-### 6. Remplissage PDF
+### 6. Extraction LLM
 
-- Les valeurs extraites sont injectées dans le XML/XFA du formulaire PDF
-- Le PDF rempli est disponible en téléchargement
+**Service** : vLLM (`:8000`) — `Qwen/Qwen2.5-14B-Instruct-AWQ`, fenêtre 32k.
 
-## Prompt système
+- Réponse contrainte par **schéma JSON** (`response_format: json_schema`) : tous
+  les IDs sont présents, les listes de choix sont des `enum`. Repli automatique
+  sur `json_object` si le serveur refuse le schéma.
+- Température 0, `max_tokens` 4096, délai 600 s.
+- Reprises sur les seules erreurs transitoires (réseau, délai, 5xx, 429).
+- Fenêtre dépassée → contexte réduit de moitié (3 fois au plus) ;
+  réponse tronquée → lot scindé ; IDs absents → redemandés une fois.
 
-```
-Tu es un assistant spécialisé dans l'extraction de données depuis des documents médicaux.
-On te fournit des EXTRAITS de rapports et une QUESTION.
-
-RÈGLES STRICTES :
-1. Cherche la réponse dans les extraits fournis.
-2. Extrais la valeur EXACTE telle qu'elle apparaît dans le texte.
-3. Ne réponds "Inconnu" que si l'information est RÉELLEMENT ABSENTE.
-4. Réponds UNIQUEMENT en JSON valide.
-5. Pour les dates, conserve le format original du document.
-6. Pour les noms/prénoms, conserve la casse originale.
-```
+### 7. Normalisation et provenance
 
-## Optimisations réalisées
+- Valeurs : « non mentionné », « N/A », « ... », exemples de format → vide ;
+  dates → `JJ.MM.AAAA` ; oui/non canoniques ; nombres seuls ; sexe `M`/`F`.
+  La réponse brute reste dans `raw_value`.
+- Provenance (`core/provenance.py`) : la valeur est-elle retrouvable dans les
+  documents, et où ? Verdict `verified` / `attested` / `inferred` / `unverified`
+  / `not_checkable`, avec document, page et extrait. Pour une réponse choisie
+  (oui/non, option de liste), seule la citation compte.
 
-| Paramètre | Avant | Après | Impact |
-|-----------|-------|-------|--------|
-| MAX_FILES | 10 | 100 | Support de gros dossiers |
-| n_results | 5 | min(20, total) | Meilleure couverture |
-| reranked | top 3 | top 7 | Plus de contexte au LLM |
-| Embedding | 1 appel | Batch de 64 | Pas de timeout |
-| OCR | Séquentiel | Parallèle (sem=5) | ~2x plus rapide |
-| Température | 0.1 | 0.05 | Réponses plus stables |
-| Timeout embed/rerank | 60s | 120s | Pas de timeout sur gros corpus |
+### 8. Remplissage PDF
 
-## Métriques actuelles
+`core/fields.collect_form_values` construit les valeurs XFA et AcroForm :
+extraits, champs calculés, puis destinataire dérivé du canton.
+Cases à cocher : état déclaré par le formulaire (`On`/`Off` ou `1`/`0`).
+Listes : libellé choisi → valeur d'export, et libellé affiché dans l'apparence.
 
-| Métrique | Valeur |
-|----------|--------|
-| Précision AVS (26 champs) | 84.6% (22/26) |
-| Temps de traitement (70 docs) | ~90s |
-| Temps de traitement (100 docs) | <5 min (estimé) |
+## Réglages
+
+| Variable | Défaut | Rôle |
+|----------|--------|------|
+| `LLM_MAX_MODEL_LEN` | 32768 | À aligner sur `--max-model-len` de vLLM |
+| `FULL_CONTEXT_MAX_TOKENS` | 16000 | Seuil du mode dossier intégral |
+| `RAG_CONTEXT_TOKENS` | 9000 | Budget d'extraits par lot |
+| `MAX_TOKENS_EXTRACT` | 4096 | Génération par lot |
+| `LLM_TIMEOUT` / `SYNTHESIS_TIMEOUT` | 600 / 900 s | Délais LLM |
+| `MAX_BATCH_SIZE` / `MAX_FAMILY_SIZE` | 8 / 32 | Taille des lots |
+| `RETRIEVAL_CANDIDATES` / `RETRIEVAL_TOP_K` | 30 / 8 | Retrieval |
+| `KEEP_DEBUG_LOGS` | false | Conserver les journaux de debug au-delà du job |
 
-## Problèmes connus
+## Tests
 
-1. **Contamination par bruit** : les documents d'autres patients polluent le retrieval
-2. **Confusion d'entités** : patient/médecin/spécialiste mal distingués
-3. **Retrieval miss** : certains champs ne trouvent pas leur chunk pertinent
+```bash
+cd services/orchestrator
+pip install -r requirements-dev.txt
+python -m pytest tests
+```
+
+Sans GPU ni service : OCR, TEI et vLLM sont simulés. Les 21 formulaires et les
+21 dossiers d'évaluation sont vérifiés de bout en bout à chaque PR — voir
+[Tests](Tests.md).
+
+## Métriques
+
+| Métrique | Valeur |
+|----------|--------|
+| Précision AVS (26 champs, avant les changements de septembre 2026) | 84.6% (22/26) |
 
-→ Voir issue #21 pour le plan d'amélioration.
+À remesurer avec `eval/regression.py` (21 dossiers, 324 champs de vérité
+terrain) et `eval/check_grounding.py` — voir [Tests](Tests.md).
diff --git a/docs/wiki/Tests.md b/docs/wiki/Tests.md
new file mode 100644
index 0000000..f45e9b0
--- /dev/null
+++ b/docs/wiki/Tests.md
@@ -0,0 +1,80 @@
+# Tests et non-régression
+
+Deux questions différentes, deux dispositifs :
+
+| Question | Où | Quand | Bloque le merge |
+|---|---|---|---|
+| **Le code fait-il toujours ce qu'il doit ?** — chaque champ de chaque formulaire atteint le PDF, les erreurs sont absorbées, les valeurs normalisées | CI GitHub Actions (`.github/workflows/tests.yml`), sans GPU, services simulés | chaque PR et chaque push sur `main`/`dev` | oui, une fois les checks déclarés obligatoires (voir plus bas) |
+| **Le modèle trouve-t-il toujours les bonnes valeurs ?** — un changement de prompt, de modèle, de découpage ou de template ne dégrade pas l'extraction | `eval/regression.py` contre le vrai backend (`.github/workflows/eval.yml` sur le DGX) | à la demande, sur les PR qui touchent l'extraction | par la référence `eval/baseline.json` et la revue |
+
+## 1. CI — à chaque PR
+
+```bash
+cd services/orchestrator && pip install -r requirements-dev.txt && python -m pytest tests
+cd services/marker_ocr   && python -m pytest tests          # pypdfium2 + pikepdf suffisent
+```
+
+| Fichier | Ce qui est garanti |
+|---|---|
+| `test_catalogue.py` | Invariants des 21 templates : IDs, `xml_path` et `acroform_name` uniques, questions toutes rédigées, options alignées sur leurs valeurs d'export, table cantonale cohérente, chaque lot tient dans la fenêtre du modèle, **aucun formulaire ne perd de champs extraits** (`catalogue_coverage.json`) |
+| `test_catalogue_fill.py` | Pour les 21 formulaires, un PDF hybride XFA + AcroForm de même structure (`form_factory.py`) : **chaque champ extrait arrive dans les deux couches**, cases, boutons radio, listes et destinataire cantonal compris |
+| `test_eval_dossiers.py` | Les 21 dossiers de `eval/dossiers/` passent **par l'API HTTP** (upload → OCR → synthèse → extraction → `/fields` → `/download`), modèle simulé répondant la vérité terrain : 100 % dans `/fields` et dans le PDF livré. Le garde-fou qualité lui-même est testé (il note 100 % un modèle parfait, détecte une valeur fausse, sort en erreur sur un job en échec) |
+| `test_pipeline.py` | Robustesse : document illisible, panne d'embeddings, de rerank ou de synthèse, re-run, purge des fichiers patients, jeton du chat |
+| `test_extraction.py` | Appel LLM : contexte trop long, réponse tronquée, IDs absents, réponse vide, schéma refusé, erreurs 4xx/5xx |
+| `test_fields.py` | Préparation des champs et normalisation des valeurs |
+| `test_fill.py` | Écriture AcroForm/XFA sur un PDF minimal |
+| `marker_ocr/tests/test_textlayer.py` | Aiguillage couche texte native / OCR |
+
+Chaque garde-fou a été vérifié par mutation : réintroduire l'ancien bug (case
+« On » écrite « 0 », destinataire cantonal appliqué par nom, cases vierges
+exclues) fait échouer la CI.
+
+Le job `orchestrator` échoue aussi sous 70 % de couverture de code.
+
+### Rendre la CI bloquante
+
+Sans cette règle, GitHub autorise le merge d'une PR rouge.
+**Settings → Branches → Add branch protection rule** (ou *Rulesets*) sur `main` :
+
+- *Require a pull request before merging* ;
+- *Require status checks to pass before merging*, avec les checks
+  `lint`, `orchestrator`, `marker-ocr`, `frontend` ;
+- *Require branches to be up to date before merging* : la CI est rejouée sur
+  le résultat du merge, pas seulement sur la branche.
+
+## 2. Qualité d'extraction — contre le vrai modèle
+
+`eval/truth.py` dérive la vérité terrain des scénarios qui ont généré les
+dossiers (patient, médecin, incapacités, diagnostics, accident) : **324 champs
+sur les 21 formulaires**, chacun vérifié présent dans le texte du dossier.
+
+```bash
+# Sur main, après validation : fixer la référence (à committer)
+python eval/regression.py --api http://localhost:8080 --api-key $KEY --update-baseline
+
+# Sur une branche : comparer à la référence
+python eval/regression.py --api http://localhost:8080 --api-key $KEY --report report.md
+```
+
+Code de sortie : `0` sans régression, `1` en cas de régression, `2` si un
+dossier n'a pas pu être traité. Est une régression : un formulaire qui perd
+plus d'un champ juste par rapport à la référence (bruit de vLLM toléré), un
+champ en erreur de plus, ou une précision globale en baisse de plus de
+2 points. `--min-accuracy 0.85` ajoute un plancher absolu.
+
+Le rapport liste, par formulaire, les champs justes, l'écart à la référence,
+et le détail des champs faux (attendu / obtenu).
+
+### Sur le DGX, depuis GitHub
+
+`.github/workflows/eval.yml` (onglet *Actions → eval → Run workflow*) lance le
+même script sur un runner auto-hébergé portant le label `dgx`, et publie le
+rapport dans le résumé du job. Prérequis, une fois :
+
+1. enregistrer un runner sur le DGX (*Settings → Actions → Runners → New
+   self-hosted runner*), avec le label `dgx` ;
+2. créer le secret `DOCTORFILL_API_KEY` (*Settings → Secrets and variables →
+   Actions*).
+
+Le workflow est manuel : un runner auto-hébergé ne doit pas exécuter le code
+de n'importe quelle PR automatiquement.
diff --git a/eval/dossiers/__pycache__/__init__.cpython-314.pyc b/eval/dossiers/__pycache__/__init__.cpython-314.pyc
deleted file mode 100644
index 81506ac..0000000
Binary files a/eval/dossiers/__pycache__/__init__.cpython-314.pyc and /dev/null differ
diff --git a/eval/dossiers/__pycache__/praticiens.cpython-314.pyc b/eval/dossiers/__pycache__/praticiens.cpython-314.pyc
deleted file mode 100644
index f3bf9f9..0000000
Binary files a/eval/dossiers/__pycache__/praticiens.cpython-314.pyc and /dev/null differ
diff --git a/eval/dossiers/__pycache__/render.cpython-314.pyc b/eval/dossiers/__pycache__/render.cpython-314.pyc
deleted file mode 100644
index 3212082..0000000
Binary files a/eval/dossiers/__pycache__/render.cpython-314.pyc and /dev/null differ
diff --git a/eval/dossiers/__pycache__/scenarios_ai.cpython-314.pyc b/eval/dossiers/__pycache__/scenarios_ai.cpython-314.pyc
deleted file mode 100644
index 756fea1..0000000
Binary files a/eval/dossiers/__pycache__/scenarios_ai.cpython-314.pyc and /dev/null differ
diff --git a/eval/dossiers/__pycache__/scenarios_autres.cpython-314.pyc b/eval/dossiers/__pycache__/scenarios_autres.cpython-314.pyc
deleted file mode 100644
index 4a55c28..0000000
Binary files a/eval/dossiers/__pycache__/scenarios_autres.cpython-314.pyc and /dev/null differ
diff --git a/eval/dossiers/__pycache__/scenarios_laa.cpython-314.pyc b/eval/dossiers/__pycache__/scenarios_laa.cpython-314.pyc
deleted file mode 100644
index 5f19789..0000000
Binary files a/eval/dossiers/__pycache__/scenarios_laa.cpython-314.pyc and /dev/null differ
diff --git a/eval/dossiers/scenarios_autres.py b/eval/dossiers/scenarios_autres.py
index cb8b3fa..862798c 100644
--- a/eval/dossiers/scenarios_autres.py
+++ b/eval/dossiers/scenarios_autres.py
@@ -1,6 +1,6 @@
 """Scénarios LAMal, assurance militaire, LCA, adressages et prescriptions."""
 
-from .praticiens import BRUNNER, FAVRE, MORAND, ROSSIER, SCHMID, VERNET
+from .praticiens import BRUNNER, FAVRE, MORAND, ROSSIER, VERNET
 from .render import Patient, Scenario
 
 SCENARIOS = [
diff --git a/eval/dossiers/scenarios_laa.py b/eval/dossiers/scenarios_laa.py
index 22fe176..dd2063a 100644
--- a/eval/dossiers/scenarios_laa.py
+++ b/eval/dossiers/scenarios_laa.py
@@ -1,6 +1,6 @@
 """Scénarios des formulaires de l'assurance-accidents (LAA / Suva)."""
 
-from .praticiens import BRUNNER, KELLER, MORAND, VERNET
+from .praticiens import BRUNNER, KELLER, MORAND
 from .render import Patient, Scenario
 
 SCENARIOS = [
diff --git a/eval/regression.py b/eval/regression.py
new file mode 100644
index 0000000..7e51dba
--- /dev/null
+++ b/eval/regression.py
@@ -0,0 +1,236 @@
+"""
+Garde-fou qualité : les dossiers de test contre un backend réel, comparés à une référence.
+
+Les tests de CI simulent le modèle : ils prouvent que la chaîne de traitement est
+intacte, pas que le modèle trouve encore les bonnes valeurs. Une modification de
+prompt, de découpage, de modèle ou de template peut dégrader l'extraction sans
+casser un seul test. Ce script la mesure : il soumet chaque dossier de
+`eval/dossiers/` à l'API, compare le résultat à la vérité terrain dérivée des
+scénarios (`truth.py`), puis à la dernière référence validée (`baseline.json`).
+
+    # Fixer la référence (sur main, après validation) :
+    python eval/regression.py --api http://localhost:8080 --api-key $KEY --update-baseline
+
+    # Vérifier une branche avant merge :
+    python eval/regression.py --api http://localhost:8080 --api-key $KEY --report report.md
+
+    # Sous-ensemble :
+    python eval/regression.py ... --forms LCA_IncapaciteTravail AI_ReadaptationRente
+
+Code de sortie : 0 sans régression, 1 en cas de régression, 2 si un dossier n'a
+pas pu être traité (job en échec, délai dépassé, API injoignable).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import time
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Callable
+
+import httpx
+
+from truth import derive_truth, dossier_pdfs, load_scenarios, score
+
+BASELINE_PATH = Path(__file__).resolve().parent / "baseline.json"
+
+# Tolérances par défaut. vLLM n'est pas strictement déterministe (ordre du batch
+# continu), même à température 0 : un champ d'écart par formulaire est du bruit.
+MAX_FIELD_DROP = 1
+MAX_GLOBAL_DROP = 0.02
+
+
+def run_form(client: httpx.Client, form_id: str, pdfs: list[Path], poll_interval: float = 5.0,
+             timeout: float = 1800.0, sleep: Callable[[float], None] = time.sleep) -> dict[str, Any]:
+    """Soumet un dossier, attend le résultat et le note."""
+    started = time.monotonic()
+    files = [("report_files", (p.name, p.read_bytes(), "application/pdf")) for p in pdfs]
+    resp = client.post("/process-form", files=files, data={"form_id": form_id})
+    if resp.status_code != 200:
+        return {"form": form_id, "status": "rejected", "message": f"HTTP {resp.status_code}: {resp.text[:200]}"}
+    job = resp.json()
+    job_id, token = job["job_id"], job.get("token", "")
+
+    while True:
+        status = client.get(f"/status/{job_id}").json()
+        if status["status"] == "completed":
+            break
+        if status["status"] == "failed":
+            return {"form": form_id, "status": "failed", "message": status.get("message")}
+        if time.monotonic() - started > timeout:
+            return {"form": form_id, "status": "timeout", "message": f"> {timeout:.0f} s"}
+        sleep(poll_interval)
+
+    fields = client.get(f"/fields/{job_id}", params={"token": token}).json()["fields"]
+    result = score(derive_truth(form_id), fields)
+    result.update({
+        "form": form_id,
+        "status": "completed",
+        "seconds": round(time.monotonic() - started, 1),
+        "warnings": status.get("warnings", []),
+        "job_id": job_id,
+    })
+    return result
+
+
+def summarize(results: list[dict[str, Any]]) -> dict[str, Any]:
+    done = [r for r in results if r["status"] == "completed"]
+    truth = sum(r["truth_fields"] for r in done)
+    correct = sum(r["correct"] for r in done)
+    return {
+        "forms": len(results),
+        "completed": len(done),
+        "truth_fields": truth,
+        "correct": correct,
+        "accuracy": round(correct / truth, 4) if truth else None,
+        "errors": sum(r["errors"] for r in done),
+    }
+
+
+def compare(results: list[dict[str, Any]], baseline: dict[str, Any] | None,
+            max_field_drop: int = MAX_FIELD_DROP, max_global_drop: float = MAX_GLOBAL_DROP,
+            min_accuracy: float | None = None) -> list[str]:
+    """Régressions par rapport à la référence, en clair."""
+    problems: list[str] = []
+    reference = (baseline or {}).get("forms", {})
+    for r in results:
+        form = r["form"]
+        if r["status"] != "completed":
+            problems.append(f"{form} : job {r['status']} ({r.get('message')})")
+            continue
+        base = reference.get(form)
+        if base is None:
+            continue
+        if r["correct"] < base["correct"] - max_field_drop:
+            problems.append(f"{form} : {r['correct']}/{r['truth_fields']} champs justes "
+                            f"(référence {base['correct']}/{base['truth_fields']})")
+        if r["errors"] > base.get("errors", 0):
+            problems.append(f"{form} : {r['errors']} champ(s) en erreur (référence {base.get('errors', 0)})")
+
+    # Précision globale, sur les seuls formulaires présents des deux côtés.
+    shared = [r for r in results if r["status"] == "completed" and r["form"] in reference]
+    if shared:
+        cur = sum(r["correct"] for r in shared) / max(1, sum(r["truth_fields"] for r in shared))
+        ref = (sum(reference[r["form"]]["correct"] for r in shared)
+               / max(1, sum(reference[r["form"]]["truth_fields"] for r in shared)))
+        if cur < ref - max_global_drop:
+            problems.append(f"précision globale {cur:.1%} (référence {ref:.1%})")
+    if min_accuracy is not None:
+        overall = summarize(results)["accuracy"]
+        if overall is not None and overall < min_accuracy:
+            problems.append(f"précision globale {overall:.1%} sous le plancher {min_accuracy:.0%}")
+    return problems
+
+
+def baseline_from(results: list[dict[str, Any]], meta: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "_meta": {**meta, "updated": datetime.now(timezone.utc).isoformat(timespec="seconds")},
+        "global": summarize(results),
+        "forms": {r["form"]: {k: r[k] for k in ("correct", "truth_fields", "accuracy", "fill_rate", "errors")}
+                  for r in results if r["status"] == "completed"},
+    }
+
+
+def report_markdown(results: list[dict[str, Any]], problems: list[str],
+                    baseline: dict[str, Any] | None) -> str:
+    """Rapport lisible dans le résumé d'un job GitHub Actions ou en commentaire de PR."""
+    reference = (baseline or {}).get("forms", {})
+    summary = summarize(results)
+    lines = ["## Non-régression de l'extraction", ""]
+    if summary["accuracy"] is not None:
+        lines.append(f"**Précision globale : {summary['accuracy']:.1%}** "
+                     f"({summary['correct']}/{summary['truth_fields']} champs, "
+                     f"{summary['completed']}/{summary['forms']} dossiers traités, "
+                     f"{summary['errors']} champ(s) en erreur)")
+    lines.append("")
+    lines.append("✅ Aucune régression." if not problems else "❌ **Régressions :**")
+    lines += [f"- {p}" for p in problems]
+    lines += ["", "| Formulaire | Justes | Δ réf. | Remplis | Erreurs | Durée |",
+              "|---|---|---|---|---|---|"]
+    for r in results:
+        if r["status"] != "completed":
+            lines.append(f"| {r['form']} | — | — | — | {r['status']} | — |")
+            continue
+        base = reference.get(r["form"])
+        delta = f"{r['correct'] - base['correct']:+d}" if base else "n/a"
+        lines.append(f"| {r['form']} | {r['correct']}/{r['truth_fields']} | {delta} | "
+                     f"{r['filled']}/{r['fields']} | {r['errors']} | {r.get('seconds', 0):.0f} s |")
+    wrong = [(r["form"], d) for r in results if r["status"] == "completed"
+             for d in r["details"] if not d["match"]]
+    if wrong:
+        lines += ["", "<details><summary>Champs faux ou manquants</summary>", "",
+                  "| Formulaire | Champ | Attendu | Obtenu |", "|---|---|---|---|"]
+        for form, d in wrong:
+            got = d["extracted"].replace("\n", " ").replace("|", "/")[:60] or "∅"
+            lines.append(f"| {form} | {d['id']} ({d['category']}) | {d['expected']} | {got} |")
+        lines += ["", "</details>"]
+    return "\n".join(lines) + "\n"
+
+
+def main(argv: list[str] | None = None, client: httpx.Client | None = None) -> int:
+    """Point d'entrée. `client` permet aux tests de viser l'application en mémoire."""
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--api", default="http://localhost:8080")
+    parser.add_argument("--api-key", default="")
+    parser.add_argument("--forms", nargs="*", help="Formulaires à évaluer (défaut : tous)")
+    parser.add_argument("--baseline", type=Path, default=BASELINE_PATH)
+    parser.add_argument("--update-baseline", action="store_true", help="Écrire le résultat comme nouvelle référence")
+    parser.add_argument("--max-field-drop", type=int, default=MAX_FIELD_DROP)
+    parser.add_argument("--max-global-drop", type=float, default=MAX_GLOBAL_DROP)
+    parser.add_argument("--min-accuracy", type=float, help="Plancher absolu de précision globale (0-1)")
+    parser.add_argument("--parallel", type=int, default=2, help="Dossiers soumis de front")
+    parser.add_argument("--report", type=Path, help="Rapport markdown")
+    parser.add_argument("--json", type=Path, help="Résultats détaillés")
+    args = parser.parse_args(argv)
+
+    forms = args.forms or sorted(load_scenarios())
+    client = client or httpx.Client(base_url=args.api, headers={"X-API-Key": args.api_key}, timeout=900.0)
+    try:
+        health = client.get("/health").json()
+    except httpx.HTTPError as exc:
+        print(f"API injoignable ({args.api}) : {exc}", file=sys.stderr)
+        return 2
+    print(f"Backend {health.get('build')} — modèle {health.get('model')} — {len(forms)} dossiers")
+
+    def _one(form: str) -> dict[str, Any]:
+        result = run_form(client, form, dossier_pdfs(form))
+        shown = (f"{result['correct']}/{result['truth_fields']}" if result["status"] == "completed"
+                 else result["status"])
+        print(f"  {form:40} {shown}")
+        return result
+
+    with ThreadPoolExecutor(max_workers=max(1, args.parallel)) as pool:
+        results = list(pool.map(_one, forms))
+
+    baseline = json.loads(args.baseline.read_text(encoding="utf-8")) if args.baseline.exists() else None
+    problems = compare(results, baseline, args.max_field_drop, args.max_global_drop, args.min_accuracy)
+    report = report_markdown(results, problems, baseline)
+    print("\n" + report)
+    if args.report:
+        args.report.write_text(report, encoding="utf-8")
+    if args.json:
+        args.json.write_text(json.dumps(results, ensure_ascii=False, indent=2), encoding="utf-8")
+
+    failed = [r for r in results if r["status"] != "completed"]
+    if args.update_baseline:
+        if failed:
+            print("Référence non écrite : des dossiers n'ont pas été traités.", file=sys.stderr)
+            return 2
+        meta = {"build": health.get("build"), "model": health.get("model")}
+        args.baseline.write_text(json.dumps(baseline_from(results, meta), ensure_ascii=False, indent=2) + "\n",
+                                 encoding="utf-8")
+        print(f"Référence écrite : {args.baseline}")
+        return 0
+    if baseline is None:
+        print("Aucune référence : lancer une fois avec --update-baseline sur main.", file=sys.stderr)
+    if failed:
+        return 2
+    return 1 if problems else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/eval/run_eval.py b/eval/run_eval.py
index be84151..6342599 100644
--- a/eval/run_eval.py
+++ b/eval/run_eval.py
@@ -125,7 +125,7 @@ def run_evaluation(api_url: str, api_key: str = "", form_id: str = "AI_Readaptat
         return
 
     print(f"\n{'='*70}")
-    print(f"  ÉVALUATION DOCTORFILL RAG")
+    print("  ÉVALUATION DOCTORFILL RAG")
     print(f"{'='*70}")
     print(f"  API       : {api_url}")
     print(f"  Formulaire: {form_id}")
diff --git a/eval/truth.py b/eval/truth.py
new file mode 100644
index 0000000..11de0bc
--- /dev/null
+++ b/eval/truth.py
@@ -0,0 +1,234 @@
+"""
+Vérité terrain dérivée des scénarios de test, pour les 21 formulaires.
+
+`ground_truth.json` ne couvre qu'un formulaire (AI_ReadaptationRente) et a dû
+être réaligné à la main à chaque régénération de template. Les dossiers de
+`eval/dossiers/` sont, eux, générés à partir de scénarios structurés (patient,
+médecin, incapacités, diagnostics) : la valeur attendue d'un champ se déduit
+donc de sa structure medForms et de son nom, pour n'importe quel formulaire.
+
+Seuls les faits effectivement présents dans le texte du dossier sont retenus :
+un champ que le dossier ne documente pas ne peut pas être reproché au modèle.
+
+Utilisé par eval/regression.py (contre le vrai backend) et par les tests de
+l'orchestrateur (services simulés) : les deux mesurent avec la même règle.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+EVAL_DIR = Path(__file__).resolve().parent
+REPO_DIR = EVAL_DIR.parent
+ORCHESTRATOR_DIR = REPO_DIR / "services" / "orchestrator"
+DOSSIERS_DIR = EVAL_DIR / "dossiers"
+TEMPLATES_DIR = ORCHESTRATOR_DIR / "template"
+
+for _path in (EVAL_DIR, ORCHESTRATOR_DIR):
+    if str(_path) not in sys.path:
+        sys.path.insert(0, str(_path))
+
+from core.fields import coding_systems, fold, normalize_date, prepare_fields  # noqa: E402
+from core.provenance import SourceIndex  # noqa: E402
+
+# (structure, champ) → (attribut du patient, tolérance)
+_PATIENT = {
+    "lastName": ("nom", "exact"), "firstName": ("prenom", "exact"),
+    "birthDate": ("naissance", "date"), "sex": ("sexe", "exact"), "ssn": ("avs", "alnum"),
+    "street": ("rue", "fuzzy"), "zip": ("npa", "exact"), "city": ("ville", "fuzzy"),
+    "phone": ("tel", "phone"), "email": ("email", "exact"),
+}
+# Le fournisseur de prestations est le médecin traitant du scénario.
+_PROVIDER = {
+    "ean": ("gln", "alnum"), "zsr": ("rcc", "alnum"), "phone": ("tel", "phone"),
+    "email": ("email", "exact"), "street": ("rue", "fuzzy"), "zip": ("npa", "exact"),
+    "city": ("ville", "fuzzy"),
+}
+
+_INDEX = re.compile(r"\[(\d+)\]$")
+
+
+@dataclass
+class Expectation:
+    expected: str
+    tolerance: str
+    category: str
+
+    def as_dict(self) -> dict[str, str]:
+        return {"expected": self.expected, "tolerance": self.tolerance, "category": self.category}
+
+
+def load_scenarios() -> dict[str, Any]:
+    """Scénarios par identifiant de formulaire."""
+    from dossiers import SCENARIOS
+    return {s.form: s for s in SCENARIOS}
+
+
+def dossier_documents(form_id: str) -> list[dict[str, str]]:
+    """Texte des documents d'un dossier, tel que l'OCR le rendrait."""
+    folder = DOSSIERS_DIR / form_id
+    return [{"filename": md.with_suffix(".pdf").name, "markdown": md.read_text(encoding="utf-8")}
+            for md in sorted(folder.glob("[0-9]*.md"))]
+
+
+def dossier_pdfs(form_id: str) -> list[Path]:
+    return sorted((DOSSIERS_DIR / form_id).glob("[0-9]*.pdf"))
+
+
+def load_template(form_id: str, templates_dir: Path = TEMPLATES_DIR) -> dict:
+    return json.loads((templates_dir / f"Form_{form_id}.json").read_text(encoding="utf-8"))
+
+
+def _segments(field: dict) -> list[str]:
+    return [s for s in str(field.get("xml_path") or "").split("/") if s]
+
+
+def _index(segment: str) -> int:
+    match = _INDEX.search(segment)
+    return int(match.group(1)) if match else 0
+
+
+def _bare(segment: str) -> str:
+    return _INDEX.sub("", segment)
+
+
+def _candidates(scenario, fields: list[dict], coding: dict[str, str]) -> dict[str, Expectation]:
+    """Valeur attendue de chaque champ que le scénario renseigne."""
+    patient, medecin = scenario.patient, scenario.medecin
+    truth: dict[str, Expectation] = {}
+    diagnosis_rank = 0
+    for field in fields:
+        parts = _segments(field)
+        if not parts:
+            continue
+        leaf_segment = parts[-1]
+        leaf = _bare(leaf_segment)
+        container = parts[-2] if len(parts) >= 2 else ""
+        struct = _bare(container)
+        fid = str(field["id"])
+
+        if leaf == "treatmentCanton":
+            truth[fid] = Expectation(patient.canton, "exact", "admin")
+        elif struct == "patientS1Address" and leaf in _PATIENT and _index(leaf_segment) == 0:
+            attr, tol = _PATIENT[leaf]
+            truth[fid] = Expectation(getattr(patient, attr), tol, "patient")
+        elif struct == "providerS1Address" and leaf in _PROVIDER and _index(leaf_segment) == 0:
+            attr, tol = _PROVIDER[leaf]
+            truth[fid] = Expectation(getattr(medecin, attr), tol, "medecin")
+        elif struct == "unemployabilityS1Struct" and leaf in ("beginDate", "endDate", "percentageNum"):
+            rank = _index(container)
+            if rank < len(scenario.incapacites):
+                begin, end, rate = scenario.incapacites[rank]
+                value, tol = {"beginDate": (begin, "date"), "endDate": (end, "date"),
+                              "percentageNum": (rate, "percent")}[leaf]
+                truth[fid] = Expectation(value, tol, "incapacite")
+        elif struct.endswith("diagnosisS1Struct") and leaf == "code" \
+                and coding.get("/".join(parts[:-1])) != "CHOP":
+            if diagnosis_rank < len(scenario.diagnostics):
+                truth[fid] = Expectation(scenario.diagnostics[diagnosis_rank][0], "alnum", "diagnostic")
+            diagnosis_rank += 1
+        elif struct == "employerS1Address" and leaf in ("condensedName", "companyName"):
+            truth[fid] = Expectation(patient.employeur, "fuzzy", "travail")
+        elif leaf == "profession":
+            truth[fid] = Expectation(patient.profession, "fuzzy", "travail")
+        elif struct == "lawS1Struct" and leaf == "caseDate" and scenario.accident:
+            truth[fid] = Expectation(scenario.accident.get("date", ""), "date", "accident")
+    return {k: v for k, v in truth.items() if str(v.expected or "").strip()}
+
+
+def derive_truth(form_id: str, templates_dir: Path = TEMPLATES_DIR) -> dict[str, Expectation]:
+    """
+    Vérité terrain d'un formulaire : les champs extraits par le pipeline dont le
+    scénario fixe la valeur, et que le dossier documente réellement.
+    """
+    scenario = load_scenarios()[form_id]
+    template = load_template(form_id, templates_dir)
+    fields = prepare_fields(template)
+    index = SourceIndex(dossier_documents(form_id))
+    truth = {}
+    for fid, exp in _candidates(scenario, fields, coding_systems(template)).items():
+        needle = exp.expected
+        if exp.tolerance == "percent":
+            needle = re.sub(r"\D", "", needle)
+        if index.find(needle, whole_words=True) is not None:
+            truth[fid] = exp
+    return truth
+
+
+# ---------------------------------------------------------------------------
+# Comparaison
+# ---------------------------------------------------------------------------
+
+def _alnum(text: str) -> str:
+    return re.sub(r"[^0-9a-z]", "", fold(text))
+
+
+def _phone(text: str) -> str:
+    digits = re.sub(r"\D", "", text)
+    if digits.startswith("0041"):
+        digits = "0" + digits[4:]
+    elif digits.startswith("41") and len(digits) == 11:
+        digits = "0" + digits[2:]
+    return digits
+
+
+def _tokens(text: str) -> set[str]:
+    return set(re.findall(r"[0-9a-z]+", fold(text)))
+
+
+def matches(expected: str, extracted: str, tolerance: str) -> bool:
+    """La valeur extraite équivaut-elle à la valeur attendue ?"""
+    if not str(extracted or "").strip():
+        return False
+    if tolerance == "date":
+        return normalize_date(expected) == normalize_date(extracted)
+    if tolerance == "alnum":
+        return _alnum(expected) == _alnum(extracted)
+    if tolerance == "phone":
+        return _phone(expected) == _phone(extracted)
+    if tolerance == "percent":
+        exp, ext = re.search(r"\d+", expected), re.search(r"\d+", extracted)
+        return bool(exp and ext) and int(exp.group()) == int(ext.group())
+    if tolerance == "fuzzy":
+        a, b = fold(expected), fold(extracted)
+        if a in b or b in a:
+            return True
+        ta, tb = _tokens(a), _tokens(b)
+        return bool(ta and tb) and len(ta & tb) / len(ta | tb) >= 0.6
+    return fold(expected) == fold(extracted)
+
+
+def score(truth: dict[str, Expectation], fields_payload: list[dict]) -> dict[str, Any]:
+    """
+    Compare le résultat de /fields à la vérité terrain.
+
+    Returns:
+        métriques (précision, taux de remplissage, erreurs) et détail par champ.
+    """
+    by_id = {str(f["id"]): f for f in fields_payload}
+    details = []
+    correct = 0
+    for fid, exp in sorted(truth.items(), key=lambda kv: [int(p) for p in kv[0].split(".")]):
+        got = str((by_id.get(fid) or {}).get("value") or "")
+        ok = matches(exp.expected, got, exp.tolerance)
+        correct += ok
+        details.append({"id": fid, "category": exp.category, "expected": exp.expected,
+                        "extracted": got, "match": ok,
+                        "status": "ok" if ok else ("missing" if not got.strip() else "wrong")})
+    filled = sum(1 for f in fields_payload if str(f.get("value") or "").strip())
+    errors = sum(1 for f in fields_payload if f.get("error"))
+    return {
+        "truth_fields": len(truth),
+        "correct": correct,
+        "accuracy": round(correct / len(truth), 4) if truth else None,
+        "fields": len(fields_payload),
+        "filled": filled,
+        "fill_rate": round(filled / len(fields_payload), 4) if fields_payload else None,
+        "errors": errors,
+        "details": details,
+    }
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index 01227aa..177cb0f 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -40,6 +40,12 @@ const UI_BUILD = {
   builtAt: __APP_BUILT_AT__,
 };
 
+// Erreur de statut définitive : inutile de réinterroger le serveur.
+class PollFatalError extends Error {}
+
+// Coupures tolérées pendant le suivi d'une tâche avant d'abandonner.
+const MAX_POLL_FAILURES = 6;
+
 const apiFetch = (url: string, options: RequestInit = {}) => {
   const headers = new Headers(options.headers || {});
   if (API_KEY) headers.set("X-API-Key", API_KEY);
@@ -291,6 +297,7 @@ export default function App() {
   const [isLoading, setIsLoading] = useState(false);
   const [pdfUrl, setPdfUrl] = useState<string | null>(null);
   const [error, setError] = useState<string | null>(null);
+  const [warnings, setWarnings] = useState<string[]>([]);
   const [isDragging, setIsDragging] = useState(false);
   const [statusMessage, setStatusMessage] = useState<string>("");
   const [progress, setProgress] = useState<number>(0);
@@ -547,6 +554,8 @@ export default function App() {
     // Sauvegarder d'abord si modifié
     if (synthesisDirty) await handleSaveSynthesis();
     setIsRerunning(true);
+    setError(null);
+    setWarnings([]);
     setPdfUrl(null);
     setFormFields([]);
     try {
@@ -588,13 +597,15 @@ export default function App() {
     fetchStats();
   }, []);
 
-  const pollStatus = async (jid: string, token: string) => {
+  const pollStatus = async (jid: string, token: string, failures = 0) => {
     try {
       const res = await apiFetch(`${BASE_URL}/status/${jid}`);
+      if (res.status === 404) throw new PollFatalError("Tâche introuvable ou expirée.");
       if (!res.ok) throw new Error("Impossible de lire le statut de la tâche.");
       const data = await res.json();
       setStatusMessage(data.message);
       setProgress(data.progress);
+      setWarnings(data.warnings ?? []);
       if (data.status === "completed") {
         const pdfRes = await apiFetch(`${BASE_URL}/download/${jid}?token=${encodeURIComponent(token)}`);
         if (!pdfRes.ok) throw new Error("Erreur lors de la récupération du PDF.");
@@ -614,13 +625,22 @@ export default function App() {
       } else if (data.status === "failed") {
         setError(data.message);
         setIsLoading(false);
+        setIsRerunning(false);
         setStartedAt(null);
       } else {
         setTimeout(() => pollStatus(jid, token), 2000);
       }
     } catch (err: any) {
+      // Une coupure passagère (tunnel, Wi-Fi, redémarrage du proxy) ne doit pas
+      // abandonner une tâche qui continue côté serveur : on réessaie en espaçant.
+      if (!(err instanceof PollFatalError) && failures < MAX_POLL_FAILURES) {
+        setTimeout(() => pollStatus(jid, token, failures + 1), Math.min(2000 * 2 ** failures, 15000));
+        return;
+      }
       setError(err.message || "Perte de connexion avec le serveur.");
       setIsLoading(false);
+      setIsRerunning(false);
+      setStartedAt(null);
     }
   };
 
@@ -628,6 +648,7 @@ export default function App() {
     if (reports.length === 0 || !formId) { setError("Il manque le formulaire ou les rapports."); return; }
     setIsLoading(true);
     setError(null);
+    setWarnings([]);
     setPdfUrl(null);
     setProgress(0);
     setStatusMessage("Initialisation de la connexion...");
@@ -683,6 +704,7 @@ export default function App() {
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
           job_id: jobId,
+          token: jobToken,
           message: userMsg,
           history: chatMessages.map((m) => ({ role: m.role, content: m.content })),
         }),
@@ -855,6 +877,16 @@ export default function App() {
                   </div>
                 )}
 
+                {!error && warnings.length > 0 && (
+                  <div className="text-xs text-amber-800 bg-amber-50 border border-amber-200 p-3 rounded-sm space-y-1">
+                    {warnings.map((w, i) => (
+                      <div key={i} className="flex items-start">
+                        <span className="mr-2">⚠️</span> {w}
+                      </div>
+                    ))}
+                  </div>
+                )}
+
                 <div className="space-y-3 mt-2 pt-4 border-t border-zinc-100">
                   <Button
                     onClick={handleProcess}
diff --git a/services/.env.example b/services/.env.example
index 37454b9..7a0f43f 100644
--- a/services/.env.example
+++ b/services/.env.example
@@ -22,3 +22,18 @@ ALLOWED_ORIGINS=*
 
 # --- Cleanup automatique (duree de retention des jobs termines, en secondes)
 JOB_RETENTION_SECONDS=3600
+
+# --- Extraction (valeurs par défaut adaptées à Qwen2.5-14B, --max-model-len 32768)
+# LLM_MAX_MODEL_LEN doit rester aligné sur --max-model-len de vLLM (docker-compose).
+# LLM_MAX_MODEL_LEN=32768
+# Dossier transmis en entier au modèle en dessous de ce seuil (tokens estimés),
+# extraits sélectionnés par retrieval au-delà.
+# FULL_CONTEXT_MAX_TOKENS=16000
+# RAG_CONTEXT_TOKENS=9000
+# MAX_TOKENS_EXTRACT=4096
+# LLM_TIMEOUT=600
+# SYNTHESIS_TIMEOUT=900
+
+# --- Journaux de debug (texte intégral des dossiers) : purgés avec le job,
+# sauf KEEP_DEBUG_LOGS=true pour une session de mise au point.
+# KEEP_DEBUG_LOGS=false
diff --git a/services/docker-compose.yml b/services/docker-compose.yml
index 8fa48ba..df44fc1 100644
--- a/services/docker-compose.yml
+++ b/services/docker-compose.yml
@@ -8,7 +8,10 @@ services:
     # est un lot de requêtes d'extraction simultanées, donc c'est le débit agrégé qui
     # compte, pas la latence par flux — d'où max-num-seqs relevé de 8 à 24.
     # --enable-prefix-caching : tous les batchs d'un job partagent le même prompt
-    # système et le même bloc de synthèse, préfilé une seule fois.
+    # système, la même synthèse et — pour un dossier qui tient dans la fenêtre —
+    # le même texte intégral des documents, préfilés une seule fois.
+    # --max-model-len : à garder aligné sur LLM_MAX_MODEL_LEN de l'orchestrateur,
+    # qui y dimensionne le contexte de chaque prompt.
     command: >
       vllm serve Qwen/Qwen2.5-14B-Instruct-AWQ
       --max-model-len 32768
diff --git a/services/marker_ocr/.dockerignore b/services/marker_ocr/.dockerignore
new file mode 100644
index 0000000..a3c14cf
--- /dev/null
+++ b/services/marker_ocr/.dockerignore
@@ -0,0 +1,3 @@
+tests/
+**/__pycache__
+.pytest_cache
diff --git a/services/marker_ocr/app.py b/services/marker_ocr/app.py
index 5ebb3ea..b80526a 100644
--- a/services/marker_ocr/app.py
+++ b/services/marker_ocr/app.py
@@ -3,7 +3,6 @@
 import os
 import hashlib
 import logging
-import shutil
 import tempfile
 import time
 from pathlib import Path
diff --git a/services/marker_ocr/tests/__init__.py b/services/marker_ocr/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/services/marker_ocr/tests/conftest.py b/services/marker_ocr/tests/conftest.py
new file mode 100644
index 0000000..8f4cdd9
--- /dev/null
+++ b/services/marker_ocr/tests/conftest.py
@@ -0,0 +1,6 @@
+"""Tests de textlayer.py : seul pypdfium2 est requis, pas marker ni le GPU."""
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
diff --git a/services/marker_ocr/tests/test_textlayer.py b/services/marker_ocr/tests/test_textlayer.py
new file mode 100644
index 0000000..6fcc7b6
--- /dev/null
+++ b/services/marker_ocr/tests/test_textlayer.py
@@ -0,0 +1,63 @@
+"""
+Aiguillage couche texte / OCR (textlayer.py).
+
+Le piège est le faux négatif silencieux : une page scannée rend une chaîne
+vide sans erreur. Mal réglé dans un sens, l'OCR tourne pour rien sur tous les
+PDF exportés d'un DPI (des minutes par dossier) ; dans l'autre, un scan part
+sans texte et le formulaire reste vide.
+"""
+
+from pathlib import Path
+
+import pikepdf
+from pikepdf import Dictionary, Name
+
+from textlayer import _page_is_usable, extract_text_layer, should_skip_ocr
+
+TEXT = ("Rapport de consultation du 09.04.2026. Patiente DUPONT Jeanne, née le 02.02.1985. "
+        "Lombalgie aigue, incapacite de travail a 100 pour cent du 09.04.2026 au 30.04.2026.")
+
+
+def _pdf(path: Path, pages: list[bool]) -> Path:
+    """PDF dont chaque page porte du texte (True) ou n'en porte pas, comme un scan (False)."""
+    pdf = pikepdf.new()
+    font = pdf.make_indirect(Dictionary(Type=Name.Font, Subtype=Name.Type1,
+                                        BaseFont=Name.Helvetica, Encoding=Name.WinAnsiEncoding))
+    for with_text in pages:
+        pdf.add_blank_page(page_size=(595, 842))
+        page = pdf.pages[-1]
+        if with_text:
+            lines = [TEXT[i:i + 70] for i in range(0, len(TEXT), 70)]
+            body = "BT /F1 10 Tf 12 TL 50 780 Td " + " ".join(f"({line}) Tj T*" for line in lines) + " ET"
+            page.obj.Resources = Dictionary(Font=Dictionary(F1=font))
+            page.obj.Contents = pdf.make_stream(body.encode("latin-1"))
+        else:
+            page.obj.Contents = pdf.make_stream(b"0.9 g 50 50 495 742 re f")
+    pdf.save(str(path))
+    return path
+
+
+def test_native_text_skips_ocr(tmp_path):
+    text, ratio, pages = extract_text_layer(str(_pdf(tmp_path / "dpi.pdf", [True, True, True])))
+    assert (ratio, pages) == (1.0, 3)
+    assert "## Page 2" in text and "DUPONT Jeanne" in text
+    assert should_skip_ocr(ratio, pages)
+
+
+def test_scanned_document_goes_to_ocr(tmp_path):
+    _, ratio, pages = extract_text_layer(str(_pdf(tmp_path / "scan.pdf", [False, False])))
+    assert ratio == 0.0 and pages == 2
+    assert not should_skip_ocr(ratio, pages)
+
+
+def test_partly_scanned_document_goes_to_ocr(tmp_path):
+    # 3 pages sur 4 : sous le seuil de 80 %, une page manquerait à l'extraction.
+    _, ratio, pages = extract_text_layer(str(_pdf(tmp_path / "mixed.pdf", [True, True, True, False])))
+    assert ratio == 0.75
+    assert not should_skip_ocr(ratio, pages)
+
+
+def test_broken_font_encoding_is_not_trusted():
+    assert _page_is_usable(TEXT * 2)
+    assert not _page_is_usable("�" * 10 + TEXT)
+    assert not _page_is_usable("trop court")
diff --git a/services/orchestrator/.dockerignore b/services/orchestrator/.dockerignore
new file mode 100644
index 0000000..b7e8117
--- /dev/null
+++ b/services/orchestrator/.dockerignore
@@ -0,0 +1,6 @@
+# Hors de l'image : tests, caches, et les PDF medForms bruts (forms/ suffit).
+tests/
+**/__pycache__
+.pytest_cache
+.ruff_cache
+.medforms_cache
diff --git a/services/orchestrator/app.py b/services/orchestrator/app.py
index a12f01b..961f1ec 100644
--- a/services/orchestrator/app.py
+++ b/services/orchestrator/app.py
@@ -28,11 +28,13 @@
 from core.inject import inject_datasets
 from core.checkbox import discover_checkbox_paths, normalize_checkboxes
 from core.acroform import detect_form_type, fill_acroform
+from core.fields import batch_fields, collect_form_values, normalize_value, prepare_fields
 from core.provenance import SourceIndex, ground_value
+import extraction
 import stats
 from medical_synthesis import run_medical_synthesis
-from prompts import (SYSTEM_PROMPT_BATCH_EXTRACT, build_batch_extraction_prompt,
-                     SECTION_SYNTHESIS_KEYS, build_chat_messages, build_synthesis_refine_messages)
+from prompts import (SYSTEM_PROMPT_BATCH_EXTRACT, build_batch_extraction_messages,
+                     build_chat_messages, build_synthesis_refine_messages)
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -88,6 +90,16 @@ async def verify_api_key(request: Request, call_next):
 # --- Dossier de logs de debug (markdown OCR, chunks, résultats LLM)
 DEBUG_LOG_DIR = Path(os.getenv("DEBUG_LOG_DIR", "/tmp/doctorfill_debug"))
 DEBUG_LOG_DIR.mkdir(parents=True, exist_ok=True)
+# Ces journaux contiennent le texte intégral des dossiers patients. Ils étaient
+# conservés sans limite ; ils suivent désormais la rétention des jobs, sauf
+# demande explicite pour une session de mise au point.
+KEEP_DEBUG_LOGS = os.getenv("KEEP_DEBUG_LOGS", "false").lower() == "true"
+
+# Fichiers d'un job (PDF uploadés, formulaire rempli), un sous-dossier par job.
+# Un répertoire dédié plutôt que /tmp/<job_id> : la purge des orphelins peut
+# alors tout y supprimer sans risquer de toucher à autre chose.
+JOBS_DIR = Path(os.getenv("JOBS_DIR", "/tmp/doctorfill_jobs"))
+JOBS_DIR.mkdir(parents=True, exist_ok=True)
 
 JOBS: Dict[str, Dict[str, Any]] = {}
 JOB_RETENTION_SECONDS = int(os.getenv("JOB_RETENTION_SECONDS", "3600"))
@@ -157,11 +169,16 @@ def _build_id() -> str:
 # retrouvable dans le texte des documents, et où ? Le seuil de rerank qui tenait
 # ce rôle notait la source secondaire du prompt et flaggait 94 champs sur 112,
 # dont 76 correctement remplis — voir l'en-tête de core/provenance.py.
+#
+# Budget de tokens, délais et reprises de l'appel d'extraction : voir extraction.py.
 
-# Plafond de génération pour un batch d'extraction (~7 champs × valeur + citation).
-MAX_TOKENS_EXTRACT = int(os.getenv("MAX_TOKENS_EXTRACT", "2048"))
-# Retries sur un appel LLM d'extraction (l'OCR en a 5, le rerank 3, celui-ci n'en avait aucun).
-MAX_LLM_RETRIES = 3
+# Extraits retenus par champ après rerank, parmi les candidats de la recherche vectorielle.
+RETRIEVAL_CANDIDATES = int(os.getenv("RETRIEVAL_CANDIDATES", "30"))
+RETRIEVAL_TOP_K = int(os.getenv("RETRIEVAL_TOP_K", "8"))
+# Taille d'un lot d'extraction ; les occurrences d'une structure répétée restent
+# groupées jusqu'à MAX_FAMILY_SIZE (voir core/fields.batch_fields).
+MAX_BATCH_SIZE = int(os.getenv("MAX_BATCH_SIZE", "8"))
+MAX_FAMILY_SIZE = int(os.getenv("MAX_FAMILY_SIZE", "32"))
 
 # Requêtes LLM en vol. À garder aligné sur --max-num-seqs de vLLM (docker-compose) :
 # en dessous, le batch continu de vLLM tourne à vide ; au-dessus, les requêtes
@@ -233,6 +250,9 @@ async def startup_tasks():
     # [SEC-03] Scanner les templates disponibles
     VALID_FORM_IDS.update(_scan_templates())
     logger.info(f"Form IDs valides: {sorted(VALID_FORM_IDS)}")
+    # Les jobs d'avant un redémarrage ne sont plus en mémoire : leurs fichiers
+    # ne seraient jamais purgés par la boucle ci-dessous.
+    _purge_orphan_files()
 
     asyncio.create_task(_cleanup_expired_jobs())
 
@@ -241,89 +261,81 @@ async def _cleanup_expired_jobs():
     """Tâche de fond qui purge les jobs terminés et leurs fichiers temporaires."""
     while True:
         await asyncio.sleep(300)
-        now = time.time()
-        expired = [
-            jid for jid, data in JOBS.items()
-            if data.get("status") in ("completed", "failed")
-            and now - data.get("completed_at", now) > JOB_RETENTION_SECONDS
-        ]
-        for jid in expired:
-            tmp_dir = Path(f"/tmp/{jid}")
-            if tmp_dir.exists():
-                shutil.rmtree(tmp_dir, ignore_errors=True)
-                logger.info(f"Cleanup: fichiers temporaires supprimés pour job {jid}")
+        try:
+            _purge_expired_jobs()
+        except Exception as exc:
+            # Une exception ici arrêtait la tâche pour de bon : plus aucun job,
+            # ni aucun dossier patient sur disque, n'était purgé ensuite.
+            logger.error(f"Cleanup: échec de la purge ({type(exc).__name__}: {exc})")
+
+
+def _purge_expired_jobs() -> None:
+    """Purge les jobs terminés depuis plus de JOB_RETENTION_SECONDS et leurs fichiers."""
+    now = time.time()
+    expired = [
+        jid for jid, data in JOBS.items()
+        if data.get("status") in ("completed", "failed")
+        and now - data.get("completed_at", now) > JOB_RETENTION_SECONDS
+    ]
+    for jid in expired:
+        tmp_dir = JOBS_DIR / jid
+        if tmp_dir.exists():
+            shutil.rmtree(tmp_dir, ignore_errors=True)
+            logger.info(f"Cleanup: fichiers temporaires supprimés pour job {jid}")
+        debug_dir = JOBS[jid].get("_debug_dir")
+        if debug_dir and not KEEP_DEBUG_LOGS:
+            shutil.rmtree(debug_dir, ignore_errors=True)
+        try:
+            chroma_client.delete_collection(name=f"col_{jid}")
+        except Exception:
+            pass
+        JOBS.pop(jid, None)
+    if expired:
+        logger.info(f"Cleanup: {len(expired)} job(s) expiré(s) purgé(s)")
+    _purge_orphan_files(now)
+
+
+def _purge_orphan_files(now: float | None = None) -> None:
+    """
+    Supprime les fichiers de jobs que plus aucune entrée de JOBS ne référence.
+
+    JOBS vit en mémoire : après un redémarrage de l'orchestrateur, les PDF
+    uploadés et les journaux de debug (texte intégral des dossiers) des jobs
+    précédents n'étaient plus rattachés à rien, donc jamais supprimés. On purge
+    tout sous-dossier plus ancien que la rétention qui n'appartient pas à un
+    job connu.
+    """
+    now = time.time() if now is None else now
+    known = {str(JOBS_DIR / jid) for jid in JOBS}
+    known |= {str(job.get("_debug_dir")) for job in JOBS.values() if job.get("_debug_dir")}
+    roots = [JOBS_DIR] + ([] if KEEP_DEBUG_LOGS else [DEBUG_LOG_DIR])
+    removed = 0
+    for root in roots:
+        for entry in root.iterdir() if root.exists() else []:
             try:
-                chroma_client.delete_collection(name=f"col_{jid}")
-            except Exception:
-                pass
-            JOBS.pop(jid, None)
-        if expired:
-            logger.info(f"Cleanup: {len(expired)} job(s) expiré(s) purgé(s)")
+                if not entry.is_dir() or str(entry) in known:
+                    continue
+                if now - entry.stat().st_mtime <= JOB_RETENTION_SECONDS:
+                    continue
+            except OSError:
+                continue
+            shutil.rmtree(entry, ignore_errors=True)
+            removed += 1
+    if removed:
+        logger.info(f"Cleanup: {removed} dossier(s) orphelin(s) supprimé(s)")
 
 
 # ---------------------------------------------------
 # --- UTILS ---
 
-def markdown_semantic_chunking(md_text: str, max_words: int = 800) -> List[str]:
-    raw_chunks = re.split(r'(?=\n#{1,3} )', md_text)
-    final_chunks = []
-    for chunk in raw_chunks:
-        chunk = chunk.strip()
-        if not chunk:
-            continue
-        words = chunk.split()
-        if len(words) > max_words:
-            for i in range(0, len(words), max_words - 100):
-                final_chunks.append(" ".join(words[i:i + max_words]))
-        else:
-            final_chunks.append(chunk)
-    return final_chunks
-
-
-def _normalize_field_value(value: str, field_type: str | None) -> str:
-    """Normalise la valeur extraite selon le type du champ déclaré dans le template."""
-    if not value or not field_type:
-        return value
-    if field_type == "sex":
-        # Normalise vers M ou F
-        v = value.strip().upper()
-        if v in ("M", "MASCULIN", "HOMME", "MALE", "H"):
-            return "M"
-        if v in ("F", "FÉMININ", "FEMININ", "FEMME", "FEMALE"):
-            return "F"
-        # Cas où le LLM a renvoyé "M (masculin)" ou "F (féminin)"
-        if v.startswith("M"):
-            return "M"
-        if v.startswith("F"):
-            return "F"
-        return value  # Valeur non reconnue : on laisse passer
-    if field_type == "percent":
-        # Garde uniquement les chiffres (et éventuellement une virgule/point décimale)
-        match = re.search(r'\d+(?:[.,]\d+)?', value.replace("%", ""))
-        if match:
-            return match.group(0).replace(",", ".")
-        return value
-    return value
-
-
-def _resolve_option_value(value: str, f_def: Dict) -> str:
+class UserFacingError(Exception):
     """
-    Traduit le libellé choisi par le LLM en valeur d'export du formulaire.
+    Échec dont la cause peut être dite à l'utilisateur sans rien exposer.
 
-    Les groupes de boutons radio medForms exportent un index (« 0 », « 1 », …)
-    et non le libellé affiché ; `option_values` porte la correspondance, dérivée
-    du XFA par tools/gen_template. Un libellé inconnu est laissé tel quel : le
-    remplissage laissera alors le groupe vide plutôt que de cocher au hasard.
+    [SEC-10] garde les erreurs internes derrière un message générique ; celles-ci
+    décrivent le dossier soumis (« aucun document lisible ») et lui permettent
+    d'agir plutôt que de « réessayer » en vain.
     """
-    options = f_def.get("options")
-    option_values = f_def.get("option_values")
-    if not options or not option_values or len(options) != len(option_values):
-        return value
-    target = value.strip().casefold()
-    for label, exported in zip(options, option_values):
-        if label.strip().casefold() == target:
-            return exported
-    return value
 
 
 def _sanitize_filename(filename: str, index: int) -> str:
@@ -343,10 +355,37 @@ def _sanitize_filename(filename: str, index: int) -> str:
     return safe
 
 
+_TEI_TRANSIENT = (httpx.TimeoutException, httpx.NetworkError, httpx.RemoteProtocolError)
+
+
+async def _tei_post(client: httpx.AsyncClient, route: str, payload: Dict, timeout: float) -> Dict:
+    """
+    Appel TEI avec reprises sur erreur transitoire.
+
+    L'embedding n'en avait aucune : un seul hoquet du service pendant l'OCR
+    faisait échouer tout le job, après plusieurs minutes de traitement.
+    """
+    max_retries = 3
+    for attempt in range(1, max_retries + 1):
+        try:
+            resp = await client.post(f"{TEI_URL}{route}", json=payload, timeout=timeout)
+            resp.raise_for_status()
+            return resp.json()
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code < 500 or attempt == max_retries:
+                raise
+            err: Exception = e
+        except _TEI_TRANSIENT as e:
+            if attempt == max_retries:
+                raise
+            err = e
+        logger.warning(f"TEI {route} retry {attempt}/{max_retries}: {type(err).__name__}: {err}")
+        await asyncio.sleep(2 * attempt)
+    raise RuntimeError(f"TEI {route} sans réponse")
+
+
 async def fetch_embeddings(client: httpx.AsyncClient, texts: List[str]):
-    resp = await client.post(f"{TEI_URL}/embed", json={"texts": texts}, timeout=120.0)
-    resp.raise_for_status()
-    return resp.json()["embeddings"]
+    return (await _tei_post(client, "/embed", {"texts": texts}, timeout=120.0))["embeddings"]
 
 
 async def fetch_embeddings_batched(client: httpx.AsyncClient, texts: List[str], batch_size: int = 64) -> List:
@@ -379,107 +418,22 @@ async def fetch_question_embeddings(client: httpx.AsyncClient, form_id: str,
 
 async def fetch_rerank(client: httpx.AsyncClient, query: str, docs: List[str],
                        rerank_sem: asyncio.Semaphore = None):
-    """Rerank avec semaphore + retry sur PoolTimeout/ReadError/ConnectError."""
-    MAX_RETRIES = 3
-
-    async def _call():
-        resp = await client.post(f"{TEI_URL}/rerank", json={"query": query, "documents": docs}, timeout=300.0)
-        resp.raise_for_status()
-        return resp.json()["results"]
-
-    async def _call_with_retry():
-        for attempt in range(1, MAX_RETRIES + 1):
-            try:
-                return await _call()
-            except (httpx.PoolTimeout, httpx.ReadError, httpx.ConnectError) as e:
-                if attempt == MAX_RETRIES:
-                    raise
-                logger.warning(f"Rerank retry {attempt}/{MAX_RETRIES}: {type(e).__name__}: {e}")
-                await asyncio.sleep(2 * attempt)
-
+    """Rerank avec semaphore + retry sur erreur transitoire."""
     if rerank_sem:
         async with rerank_sem:
-            return await _call_with_retry()
+            data = await _tei_post(client, "/rerank", {"query": query, "documents": docs}, timeout=300.0)
     else:
-        return await _call_with_retry()
-
-
-def _filter_synthesis_for_section(synthesis: Dict | None, section_id: str) -> str | None:
-    """Retourne uniquement les clés de synthèse pertinentes pour la section donnée."""
-    if not synthesis:
-        return None
-    keys = SECTION_SYNTHESIS_KEYS.get(section_id, list(synthesis.keys()))
-    filtered = {k: synthesis[k] for k in keys if k in synthesis and synthesis[k]}
-    return json.dumps(filtered, ensure_ascii=False) if filtered else None
-
-
-def _extractable_fields(template: Dict) -> List[Dict]:
-    """
-    Champs à soumettre au modèle.
-
-    Écarte les champs `preset` : l'éditeur du formulaire les a déjà renseignés
-    (adresse de l'office destinataire, code EAN, données de routage) et ils font
-    autorité. Les extraire produisait des documents incohérents — un formulaire
-    AI adressé à « Helvetia Santé SA » parce que le dossier mentionnait cette
-    caisse, à l'adresse de l'Office AI restée en dessous. Ça allège aussi le
-    budget LLM de 112 questions sur l'ensemble du catalogue.
-    """
-    return [f for f in template["fields"]
-            if f.get("question", "").strip()
-            and not f.get("preset") and not f.get("computed")]
-
-
-def _computed_values(template: Dict) -> List[tuple[Dict, str]]:
-    """
-    Champs dont la valeur se déduit du formulaire lui-même.
-
-    Le bloc adresse du destinataire en est le seul cas aujourd'hui : il est la
-    version visible de champs structurés déjà renseignés par l'éditeur, mais
-    masqués dans la mise en page. Le demander au modèle produisait des adresses
-    inventées — un numéro de rue emprunté au patient, un code postal fabriqué.
-    """
-    return [(f, f["computed"]) for f in template["fields"] if f.get("computed")]
-
-
-def _canton_recipient(template: Dict, results: List[Dict]) -> Dict[str, str]:
-    """
-    Destinataire correspondant au canton de traitement extrait.
-
-    Un formulaire AI s'adresse à l'office AI *du canton du patient*. Le gabarit
-    porte cette table et la applique par script — mais le script ne s'exécute
-    que dans un lecteur XFA, jamais dans le PDF qu'on livre. Sans ça, un dossier
-    neuchâtelois partait à l'office de Berne, l'adresse par défaut du vierge.
-
-    Canton absent ou inconnu : on ne renvoie rien et le formulaire garde ses
-    valeurs d'origine — mieux vaut le défaut du gabarit qu'un office arbitraire.
-
-    Returns:
-        nom de champ → valeur, à écrire tel quel.
-    """
-    table = template.get("_recipient_by_canton")
-    if not table:
-        return {}
-    canton_ids = {str(f["id"]) for f in template["fields"]
-                  if f.get("name") == "treatmentCanton"}
-    for res in results:
-        if str(res.get("id")) not in canton_ids:
-            continue
-        valeur = str((res.get("result") or {}).get("value") or "").strip().upper()
-        if valeur in table:
-            logger.info("Destinataire dérivé du canton %s", valeur)
-            return table[valeur]
-        if valeur:
-            logger.warning("Canton %r hors de la table du formulaire", valeur)
-    return {}
+        data = await _tei_post(client, "/rerank", {"query": query, "documents": docs}, timeout=300.0)
+    return data["results"]
 
 
 def _synthesis_as_source(synthesis: Dict | None) -> List[Dict]:
     """
     Expose la synthèse médicale comme source indexable, marquée comme dérivée.
 
-    C'est la source *principale* du prompt d'extraction : sans elle dans l'index,
-    toute valeur citée depuis la synthèse plutôt que depuis un document brut
-    était déclarée non tracée. Le drapeau `derived` évite l'excès inverse — la
+    C'est une source du prompt d'extraction : sans elle dans l'index, toute
+    valeur citée depuis la synthèse plutôt que depuis un document brut était
+    déclarée non tracée. Le drapeau `derived` évite l'excès inverse — la
     synthèse est une production du modèle, s'y adosser ne vaut pas preuve.
     """
     if not synthesis:
@@ -491,96 +445,296 @@ def _synthesis_as_source(synthesis: Dict | None) -> List[Dict]:
     }]
 
 
+# Réponses choisies plutôt que recopiées : les retrouver dans le texte ne prouve rien.
+_NON_LITERAL_TYPES = {"bool", "choice"}
+
+
 def _annotate_confidence(results: List[Dict], source_index: SourceIndex,
-                         field_score_map: Dict[str, float]) -> None:
+                         field_score_map: Dict[str, float], fields_by_id: Dict[str, Dict]) -> None:
     """
-    Rattache chaque valeur extraite au texte dont elle provient.
+    Normalise chaque valeur extraite et la rattache au texte dont elle provient.
+
+    La normalisation (date au format JJ.MM.AAAA, « non mentionné » → vide, oui/non
+    canonique…) a lieu ici plutôt qu'au remplissage : le clinicien voit dans
+    l'application exactement ce qui sera écrit dans le formulaire. La valeur
+    brute du modèle reste disponible dans `raw_value` quand elle diffère.
 
     Aucun appel LLM supplémentaire, aucun seuil : la valeur se retrouve dans les
     documents ou elle ne s'y retrouve pas. Le résultat porte le verdict
     (`grounding`), et l'ancrage quand il existe — document, page, extrait — de
     quoi vérifier d'un coup d'œil plutôt que d'avoir à croire le modèle.
 
-    `rerank_score` reste renseigné à titre de diagnostic, mais ne déclenche plus
-    rien : voir l'en-tête de core/provenance.py.
-
-    On ne supprime jamais une valeur — c'est au clinicien de trancher.
+    On ne supprime jamais une valeur réelle — c'est au clinicien de trancher.
     """
     for res in results:
         payload = res.get("result")
         if not isinstance(payload, dict):
             continue
-        payload["rerank_score"] = round(field_score_map.get(str(res["id"]), 0.0), 4)
-
-        value = str(payload.get("value") or "").strip()
+        fid = str(res["id"])
+        f_def = fields_by_id.get(fid, {})
+        score = field_score_map.get(fid)
+        payload["rerank_score"] = round(score, 4) if score is not None else None
+
+        raw = str(payload.get("value") or "").strip()
+        value = normalize_value(raw, f_def)
+        if value != raw:
+            payload["raw_value"] = raw
+        payload["value"] = value
         if not value:
+            payload["source_quote"] = ""
             continue
-        payload.update(ground_value(value, str(payload.get("source_quote") or ""), source_index))
-
-
-def _group_fields_into_batches(fields: List[Dict], max_batch_size: int = 7) -> List[List[Dict]]:
-    """Groupe les champs par section (préfixe de l'ID), max max_batch_size par batch."""
-    from collections import defaultdict
-    by_section: Dict[str, List[Dict]] = defaultdict(list)
-    for f in fields:
-        section = str(f["id"]).split(".")[0]
-        by_section[section].append(f)
-    batches = []
-    for section_fields in by_section.values():
-        for i in range(0, len(section_fields), max_batch_size):
-            batches.append(section_fields[i:i + max_batch_size])
-    return batches
-
-
-async def extract_fields_batch_vllm(
-    client: httpx.AsyncClient,
-    fields: List[Dict],
-    chunks_context: str,
-    synthesis_json: str | None,
-    llm_sem: asyncio.Semaphore,
-) -> List[Dict]:
-    """Extrait plusieurs champs en un seul appel LLM (mode batch)."""
-    prompt = build_batch_extraction_prompt(fields, synthesis_json, chunks_context)
-    payload = {
-        "model": VLLM_MODEL,
-        "messages": [
-            {"role": "system", "content": SYSTEM_PROMPT_BATCH_EXTRACT},
-            {"role": "user", "content": prompt},
-        ],
-        "temperature": 0.05,
-        "response_format": {"type": "json_object"},
-        "max_tokens": MAX_TOKENS_EXTRACT,
-    }
+        payload.update(ground_value(value, str(payload.get("source_quote") or ""), source_index,
+                                    literal=f_def.get("type") not in _NON_LITERAL_TYPES))
 
-    async def _call_with_retry() -> Dict:
-        """Un JSON tronqué ou un pic de charge ne doit pas condamner les 7 champs du batch."""
-        for attempt in range(1, MAX_LLM_RETRIES + 1):
-            try:
-                async with llm_sem:
-                    resp = await client.post(f"{VLLM_URL}/chat/completions", json=payload, timeout=180.0)
-                    resp.raise_for_status()
-                    return json.loads(resp.json()["choices"][0]["message"]["content"])
-            except (httpx.PoolTimeout, httpx.ReadError, httpx.ConnectError,
-                    httpx.ReadTimeout, httpx.HTTPStatusError, json.JSONDecodeError) as e:
-                if attempt == MAX_LLM_RETRIES:
-                    raise
-                logger.warning(f"LLM retry {attempt}/{MAX_LLM_RETRIES} "
-                               f"({[f['id'] for f in fields]}): {type(e).__name__}: {e}")
-                await asyncio.sleep(2 * attempt)
 
-    try:
-        data = await _call_with_retry()
-        results = []
-        for field in fields:
-            fid = str(field["id"])
-            if fid in data and isinstance(data[fid], dict):
-                results.append({"id": field["id"], "result": data[fid]})
+async def _retrieve(client: httpx.AsyncClient, col, n_chunks: int, form_id: str,
+                    fields: List[Dict]) -> tuple[Dict[str, List[str]], Dict[str, float]]:
+    """
+    Extraits pertinents de chaque champ : recherche vectorielle puis rerank.
+
+    La requête est la question débarrassée de ses consignes de format, enrichie
+    du contexte de structure (voir core/fields.contextualize). Un rerank en
+    échec ne fait plus échouer le job : le champ garde l'ordre de la recherche
+    vectorielle, moins fin mais exploitable.
+    """
+    if n_chunks == 0 or not fields:
+        return {}, {}
+    queries = [f.get("retrieval_query") or f["question"] for f in fields]
+    q_embs = await fetch_question_embeddings(client, form_id, queries)
+
+    async def _one(query: str, q_emb) -> tuple[List[str], float | None]:
+        hits = col.query(query_embeddings=[q_emb],
+                         n_results=min(RETRIEVAL_CANDIDATES, n_chunks))["documents"][0]
+        try:
+            reranked = await fetch_rerank(client, query, hits, rerank_sem=_RERANK_SEM)
+        except Exception as exc:
+            logger.warning(f"Rerank indisponible, ordre vectoriel conservé : {type(exc).__name__}: {exc}")
+            return hits[:RETRIEVAL_TOP_K], None
+        top = reranked[:RETRIEVAL_TOP_K]
+        # Le meilleur score sert d'indice de pertinence du retrieval pour ce champ.
+        best = float(top[0].get("score", 0.0)) if top else 0.0
+        return [r["document"] for r in top], best
+
+    retrieved = await asyncio.gather(*[_one(q, e) for q, e in zip(queries, q_embs)])
+    chunk_map = {str(f["id"]): cks for f, (cks, _) in zip(fields, retrieved)}
+    score_map = {str(f["id"]): s for f, (_, s) in zip(fields, retrieved) if s is not None}
+    return chunk_map, score_map
+
+
+async def _extract_fields(client: httpx.AsyncClient, job_id: str, form_id: str, template: Dict,
+                          col, n_chunks: int, synthesis: Dict | None, documents: List[Dict],
+                          on_progress) -> List[Dict]:
+    """
+    Extraction de tous les champs d'un formulaire. Partagée par le pipeline et le re-run.
+
+    Deux modes de contexte :
+    - dossier intégral, quand il tient dans la fenêtre du modèle — le cas des
+      dossiers usuels. Aucune information ne dépend alors de la qualité du
+      retrieval, et vLLM ne calcule qu'une fois le préfixe commun à tous les lots ;
+    - extraits choisis par retrieval + rerank, au-delà.
+
+    La synthèse médicale est transmise en entier à chaque lot. Elle était filtrée
+    par numéro de section selon une table écrite pour la mise en page du seul
+    formulaire AVS : sur les autres formulaires, les champs d'incapacité de
+    travail, de diagnostic ou de médecin ne recevaient pas la partie de la
+    synthèse qui les concernait.
+    """
+    fields = prepare_fields(template)
+    fields_by_id = {str(f["id"]): f for f in fields}
+    batches = batch_fields(fields, max_batch_size=MAX_BATCH_SIZE, max_family_size=MAX_FAMILY_SIZE)
+    if not batches:
+        return []
+
+    source_index = SourceIndex(documents, _synthesis_as_source(synthesis))
+    docs_text = extraction.full_documents_text(documents)
+    synthesis_json = json.dumps(synthesis, ensure_ascii=False) if synthesis else None
+
+    # Budget : fenêtre du modèle − génération − marge − parties fixes du prompt.
+    fields_tokens = max(
+        extraction.estimate_tokens("\n".join(
+            (f.get("prompt_question") or f["question"]) + " ".join(f.get("options") or []) + " " * 40
+            for f in batch))
+        for batch in batches)
+    prompt_budget = (extraction.LLM_MAX_MODEL_LEN - extraction.MAX_TOKENS_EXTRACT
+                     - extraction.PROMPT_SAFETY_TOKENS
+                     - extraction.estimate_tokens(SYSTEM_PROMPT_BATCH_EXTRACT) - fields_tokens)
+    docs_budget = prompt_budget - (extraction.estimate_tokens(synthesis_json) if synthesis_json else 0)
+    if synthesis_json and docs_budget < 3000:
+        logger.warning(f"[{job_id[:8]}] Synthèse trop volumineuse pour le prompt d'extraction — omise")
+        synthesis_json, docs_budget = None, prompt_budget
+
+    full_mode = extraction.estimate_tokens(docs_text) <= min(extraction.FULL_CONTEXT_MAX_TOKENS, docs_budget)
+    rag_budget = max(1000, min(extraction.RAG_CONTEXT_TOKENS, docs_budget))
+
+    if full_mode:
+        field_chunk_map, field_score_map = {}, {}
+        logger.info(f"[{job_id[:8]}] {len(fields)} champs, {len(batches)} lots — dossier intégral "
+                    f"(~{extraction.estimate_tokens(docs_text)} tokens)")
+    else:
+        try:
+            field_chunk_map, field_score_map = await _retrieve(client, col, n_chunks, form_id, fields)
+        except Exception as exc:
+            # Encodage des questions ou recherche indisponible : on bascule sur le
+            # repli prévu plus bas (début du dossier) plutôt que d'échouer.
+            logger.error(f"[{job_id[:8]}] Retrieval indisponible : {type(exc).__name__}: {exc}")
+            JOBS.get(job_id, {}).setdefault("warnings", []).append(
+                "Recherche sémantique indisponible : extraction faite sur le début du dossier, "
+                "à relire attentivement.")
+            field_chunk_map, field_score_map = {}, {}
+        logger.info(f"[{job_id[:8]}] {len(fields)} champs, {len(batches)} lots — extraits "
+                    f"(budget {rag_budget} tokens/lot)")
+
+    def build_messages(batch: List[Dict], scale: float) -> List[Dict]:
+        if full_mode and scale >= 1.0:
+            return build_batch_extraction_messages(batch, synthesis_json, docs_text, full_documents=True)
+        if full_mode:
+            # Repli rare : l'estimation a sous-évalué le dossier. On tronque plutôt
+            # que d'abandonner le champ.
+            limit = int(docs_budget * scale) * 3
+            return build_batch_extraction_messages(batch, synthesis_json, docs_text[:limit])
+        if not field_chunk_map:
+            # Index vide (embeddings indisponibles) : le début du dossier plutôt
+            # que rien.
+            return build_batch_extraction_messages(batch, synthesis_json,
+                                                   docs_text[:int(rag_budget * scale) * 3])
+        context = extraction.build_rag_context(batch, field_chunk_map, int(rag_budget * scale))
+        return build_batch_extraction_messages(batch, synthesis_json, context)
+
+    done = 0
+
+    async def _run_batch(batch: List[Dict]) -> List[Dict]:
+        nonlocal done
+        result = await extraction.extract_batch(client, VLLM_URL, VLLM_MODEL, batch,
+                                                build_messages, _LLM_SEM)
+        _annotate_confidence(result, source_index, field_score_map, fields_by_id)
+        done += 1
+        on_progress(done, len(batches))
+        return result
+
+    batch_results = await asyncio.gather(*[_run_batch(b) for b in batches])
+    results = [item for batch in batch_results for item in batch]
+    failed = sum(1 for r in results if "error" in r)
+    if failed:
+        logger.warning(f"[{job_id[:8]}] {failed}/{len(results)} champs en erreur d'extraction")
+    return results
+
+
+_FIELD_ERRORS_WARNING = "champ(s) n'ont pas pu être extraits — à compléter à la main."
+
+
+def _record_field_errors(job: Dict, results: List[Dict]) -> None:
+    """Avertissement sur les champs en erreur, recalculé à chaque passage (re-run compris)."""
+    warnings = [w for w in job.setdefault("warnings", []) if not w.endswith(_FIELD_ERRORS_WARNING)]
+    failed = sum(1 for r in results if "error" in r)
+    if failed:
+        warnings.append(f"{failed} {_FIELD_ERRORS_WARNING}")
+    job["warnings"] = warnings
+
+
+def _template_fields_view(template: Dict) -> List[Dict]:
+    """Description des champs extraits, pour /fields et le chat."""
+    return [
+        {"id": f["id"], "label": f.get("label", str(f["id"])),
+         "question": f.get("question", ""), "section": str(f["id"]).split(".")[0]}
+        for f in prepare_fields(template)
+    ]
+
+
+def _fill_pdf(job_id: str, form_id: str, template: Dict, results: List[Dict],
+              tmp_dir: Path, suffix: str = "") -> tuple[Path, str]:
+    """
+    Écrit les valeurs dans le formulaire PDF. Partagé par le pipeline et le re-run.
+
+    Supporte XFA, AcroForm pur et formulaires hybrides. Le re-run en avait une
+    copie qui ignorait les champs calculés et le destinataire cantonal : après
+    un re-run, un formulaire AI repartait à l'office AI par défaut du gabarit.
+
+    Returns:
+        (chemin du PDF rempli, type de formulaire)
+    """
+    source_template_path = Path(f"forms/Form_{form_id}.pdf")
+    if not source_template_path.exists():
+        raise FileNotFoundError(f"Template introuvable pour form_id={form_id}")
+    empty_form_path = tmp_dir / f"empty{suffix}.pdf"
+    shutil.copy(source_template_path, empty_form_path)
+
+    form_type = detect_form_type(empty_form_path)
+    logger.info(f"[{job_id[:8]}] Type de formulaire détecté : {form_type}")
+
+    xfa_values, acro_values = collect_form_values(template, results)
+    output_pdf = tmp_dir / f"output{suffix}.pdf"
+    if output_pdf.exists():
+        output_pdf.unlink()
+
+    if form_type in ("xfa", "hybrid"):
+        base_xml = tmp_dir / f"base{suffix}.xml"
+        try:
+            extract_xfa_datasets(empty_form_path, base_xml)
+            checkbox_paths = discover_checkbox_paths(base_xml)
+            normalize_checkboxes(xfa_values, checkbox_paths)
+            filled_xml = tmp_dir / f"filled{suffix}.xml"
+            update_datasets(base_xml, xfa_values, filled_xml, template["fields"])
+            inject_datasets(empty_form_path, filled_xml, output_pdf)
+        except PDFNoXFAError:
+            logger.warning(f"[{job_id[:8]}] XFA introuvable malgré détection hybrid — fallback AcroForm")
+            form_type = "acroform"
+
+    if form_type == "acroform" or (form_type == "hybrid" and acro_values):
+        # Pour un hybride : repartir du PDF XFA déjà rempli si disponible, sinon template
+        acro_source = output_pdf if (form_type == "hybrid" and output_pdf.exists()) else empty_form_path
+        fill_acroform(acro_source, acro_values, output_pdf)
+
+    if form_type == "none" or not output_pdf.exists():
+        raise ValueError(f"Impossible de remplir le formulaire (type={form_type})")
+    return output_pdf, form_type
+
+
+def _load_template(form_id: str) -> Dict:
+    with open(f"template/Form_{form_id}.json", "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+MAX_OCR_RETRIES = 5
+
+
+async def _ocr_document(client: httpx.AsyncClient, path: Path) -> str:
+    """
+    Texte d'un PDF via le service OCR, avec reprises proportionnées à la cause.
+
+    Service injoignable (redémarrage) : jusqu'à 5 tentatives espacées. Délai
+    dépassé ou erreur 5xx : une seule reprise — un OCR de dix minutes rejoué
+    cinq fois, c'est une heure perdue. Erreur 4xx : le PDF est refusé, inutile
+    d'insister.
+    """
+    content = path.read_bytes()
+    last_err: Exception | None = None
+    for attempt in range(1, MAX_OCR_RETRIES + 1):
+        try:
+            resp = await client.post(
+                f"{MARKER_URL}/extract",
+                files={'file': (path.name, content, 'application/pdf')},
+                timeout=httpx.Timeout(600.0, connect=15.0))
+            resp.raise_for_status()
+            return resp.json().get("markdown", "") or ""
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code < 500 or attempt >= 2:
+                raise
+            last_err, delay = e, 5
+        except (httpx.TimeoutException, httpx.RemoteProtocolError) as e:
+            if isinstance(e, httpx.ConnectTimeout):
+                last_err, delay = e, 10 * attempt
+            elif attempt >= 2:
+                raise
             else:
-                results.append({"id": field["id"], "error": "field_missing_in_response"})
-        return results
-    except Exception as e:
-        logger.error(f"Erreur batch vLLM ({[f['id'] for f in fields]}): {e}")
-        return [{"id": f["id"], "error": "extraction_failed"} for f in fields]
+                last_err, delay = e, 5
+        except httpx.NetworkError as e:
+            last_err = e
+            delay = 10 * attempt if isinstance(e, httpx.ConnectError) else 2 * attempt
+        logger.warning(f"OCR retry {attempt}/{MAX_OCR_RETRIES} pour {path.name}: "
+                       f"{type(last_err).__name__} (retry in {delay}s)")
+        if attempt < MAX_OCR_RETRIES:
+            await asyncio.sleep(delay)
+    raise last_err or RuntimeError("OCR sans réponse")
 
 
 async def run_pipeline_task(job_id: str, form_id: str, tmp_dir: Path, report_paths: List[Path]):
@@ -593,31 +747,39 @@ async def run_pipeline_task(job_id: str, form_id: str, tmp_dir: Path, report_pat
     produire de plus vite. Le chronomètre court pendant l'attente — c'est bien le
     temps que l'utilisateur subit.
     """
-    if _PIPELINE_SEM.locked():
-        attente = stats.summary().get("recent_average_seconds")
-        repere = f" — environ {attente / 60:.0f} min" if attente else ""
-        logger.info(f"[{job_id[:8]}] En file d'attente ({MAX_PARALLEL_JOBS} exécutions en cours)")
-        JOBS[job_id].update({
-            "status": "processing",
-            "message": f"⏳ En file d'attente{repere}…",
-            "progress": 2,
-        })
+    _announce_queue(job_id)
     async with _PIPELINE_SEM:
         await _run_pipeline(job_id, form_id, tmp_dir, report_paths)
 
 
+def _announce_queue(job_id: str) -> None:
+    if not _PIPELINE_SEM.locked():
+        return
+    attente = stats.summary().get("recent_average_seconds")
+    repere = f" — environ {attente / 60:.0f} min" if attente else ""
+    logger.info(f"[{job_id[:8]}] En file d'attente ({MAX_PARALLEL_JOBS} exécutions en cours)")
+    JOBS[job_id].update({
+        "status": "processing",
+        "message": f"⏳ En file d'attente{repere}…",
+        "progress": 2,
+    })
+
+
 async def _run_pipeline(job_id: str, form_id: str, tmp_dir: Path, report_paths: List[Path]):
     """
     Pipeline avec streaming OCR→embed, synthèse médicale globale et semaphores rerank/LLM.
     - STEP 1 : OCR et embedding en parallèle via asyncio.Queue
     - STEP 2 : Synthèse médicale globale (LLM lit tous les documents, produit un JSON structuré)
-    - STEP 3 : RAG hybride (synthèse + chunks reranked) pour chaque champ
-    - STEP 4 : Injection XFA
+    - STEP 3 : Extraction des champs (dossier intégral ou RAG, selon sa taille)
+    - STEP 4 : Injection XFA / AcroForm
     """
     collection_name = f"col_{job_id}"
     debug_dir = DEBUG_LOG_DIR / f"{datetime.now().strftime('%Y%m%d_%H%M%S')}_{job_id[:8]}"
     debug_dir.mkdir(parents=True, exist_ok=True)
     (debug_dir / "markdown").mkdir(exist_ok=True)
+    # Connu dès le départ : un job en échec doit lui aussi voir ses journaux purgés.
+    JOBS[job_id]["_debug_dir"] = str(debug_dir)
+    warnings: List[str] = JOBS[job_id].setdefault("warnings", [])
 
     timings: Dict[str, float] = {}
     # Résultats OCR bruts (nécessaires pour la synthèse)
@@ -638,100 +800,101 @@ async def _run_pipeline(job_id: str, form_id: str, tmp_dir: Path, report_paths:
 
             t_ocr_start = time.perf_counter()
             ocr_done = 0
-            ocr_sem = _OCR_SEM
-            MAX_OCR_RETRIES = 5
             col = chroma_client.get_or_create_collection(name=collection_name)
             chunk_index = 0
-            all_chunks: List[str] = []
 
-            # Queue pour le pipeline OCR → embed
+            # Queue pour le pipeline OCR → embed ; None marque la fin du flux.
             ocr_queue: asyncio.Queue = asyncio.Queue()
-            embed_done = asyncio.Event()
 
-            async def _ocr_one(path: Path) -> tuple:
+            async def _ocr_one(path: Path) -> None:
                 """OCR un PDF et envoie le résultat dans la queue pour embedding."""
                 nonlocal ocr_done
-                async with ocr_sem:
-                    with open(path, "rb") as f:
-                        content = f.read()
-                    last_err = None
-                    for attempt in range(1, MAX_OCR_RETRIES + 1):
-                        try:
-                            resp = await client.post(
-                                f"{MARKER_URL}/extract",
-                                files={'file': (path.name, content, 'application/pdf')},
-                                timeout=600.0)
-                            resp.raise_for_status()
-                            md_text = resp.json().get("markdown", "")
-                            ocr_done += 1
-                            JOBS[job_id].update({
-                                "message": f"📄 OCR {ocr_done}/{total_files} documents...",
-                                "progress": 5 + int(35 * ocr_done / total_files)
-                            })
-                            # Debug : sauvegarder le markdown OCR
-                            md_filename = path.stem + ".md"
-                            (debug_dir / "markdown" / md_filename).write_text(md_text, encoding="utf-8")
-                            # Accumuler pour la synthèse médicale
-                            ocr_raw_results.append({"filename": path.name, "markdown": md_text})
-                            # Envoyer dans la queue pour embedding immédiat
-                            await ocr_queue.put((path.name, md_text))
-                            return path.name, md_text
-                        except (httpx.ReadError, httpx.ConnectError, httpx.RemoteProtocolError) as e:
-                            last_err = e
-                            delay = 10 * attempt if isinstance(e, httpx.ConnectError) else 2 * attempt
-                            logger.warning(f"[{job_id[:8]}] OCR retry {attempt}/{MAX_OCR_RETRIES} pour {path.name}: {type(e).__name__} (retry in {delay}s)")
-                            if attempt < MAX_OCR_RETRIES:
-                                await asyncio.sleep(delay)
-                    raise last_err
+                async with _OCR_SEM:
+                    try:
+                        md_text = await _ocr_document(client, path)
+                    except Exception as e:
+                        # Un document illisible ne condamne plus tout le dossier : il est
+                        # écarté, et l'utilisateur en est averti.
+                        logger.error(f"[{job_id[:8]}] OCR abandonné pour {path.name}: "
+                                     f"{type(e).__name__}: {e}")
+                        warnings.append(f"Document illisible, ignoré : {path.name}")
+                        md_text = None
+                ocr_done += 1
+                JOBS[job_id].update({
+                    "message": f"📄 OCR {ocr_done}/{total_files} documents...",
+                    "progress": 5 + int(35 * ocr_done / total_files)
+                })
+                if md_text is None:
+                    return
+                if not md_text.strip():
+                    warnings.append(f"Aucun texte trouvé dans : {path.name}")
+                    return
+                # Debug : sauvegarder le markdown OCR
+                (debug_dir / "markdown" / (path.stem + ".md")).write_text(md_text, encoding="utf-8")
+                ocr_raw_results.append({"filename": path.name, "markdown": md_text})
+                await ocr_queue.put((path.name, md_text))
 
             async def _embed_consumer():
                 """Consomme la queue OCR, chunk et embed au fil de l'eau."""
                 nonlocal chunk_index
                 pending_chunks: List[str] = []
+                embed_failed = False
 
-                while True:
+                async def _flush():
+                    nonlocal chunk_index, pending_chunks, embed_failed
+                    if not pending_chunks or embed_failed:
+                        pending_chunks = []
+                        return
                     try:
-                        name, md_text = await asyncio.wait_for(ocr_queue.get(), timeout=2.0)
-                    except asyncio.TimeoutError:
-                        if ocr_queue.empty() and embed_done.is_set():
-                            break
-                        continue
-
-                    doc_md = f"\n\n--- SOURCE: {name} ---\n\n" + md_text
-                    doc_chunks = markdown_semantic_chunking(doc_md)
-                    pending_chunks.extend(doc_chunks)
-                    all_chunks.extend(doc_chunks)
-
-                    # Embed quand on a accumulé assez de chunks
-                    if len(pending_chunks) >= 64 or (embed_done.is_set() and ocr_queue.empty()):
-                        if pending_chunks:
-                            embeds = await fetch_embeddings_batched(client, pending_chunks)
-                            ids = [f"{job_id}_{chunk_index + i}" for i in range(len(pending_chunks))]
-                            col.add(documents=pending_chunks, embeddings=embeds, ids=ids)
-                            chunk_index += len(pending_chunks)
-                            logger.info(f"[{job_id[:8]}] Embedded {chunk_index} chunks so far...")
-                            pending_chunks = []
-
-                # Flush les chunks restants
-                if pending_chunks:
-                    embeds = await fetch_embeddings_batched(client, pending_chunks)
+                        embeds = await fetch_embeddings_batched(client, pending_chunks)
+                    except Exception as e:
+                        # L'index ne sert qu'au retrieval des gros dossiers, au chat et au
+                        # re-run : son absence dégrade, elle ne justifie pas d'échouer.
+                        logger.error(f"[{job_id[:8]}] Embeddings indisponibles : {type(e).__name__}: {e}")
+                        warnings.append("Recherche sémantique indisponible : le chat sur le dossier "
+                                        "sera limité.")
+                        embed_failed, pending_chunks = True, []
+                        return
                     ids = [f"{job_id}_{chunk_index + i}" for i in range(len(pending_chunks))]
                     col.add(documents=pending_chunks, embeddings=embeds, ids=ids)
                     chunk_index += len(pending_chunks)
+                    logger.info(f"[{job_id[:8]}] Embedded {chunk_index} chunks so far...")
+                    pending_chunks = []
+
+                while True:
+                    item = await ocr_queue.get()
+                    if item is None:
+                        break
+                    name, md_text = item
+                    pending_chunks.extend(extraction.chunk_document(name, md_text))
+                    if len(pending_chunks) >= 64:
+                        await _flush()
+                await _flush()
 
             # Lancer OCR et embedding en parallèle (pipeline)
             embed_task = asyncio.create_task(_embed_consumer())
-            await asyncio.gather(*[_ocr_one(p) for p in report_paths])
-            embed_done.set()
+            try:
+                await asyncio.gather(*[_ocr_one(p) for p in report_paths])
+            finally:
+                # Toujours clore le flux : sans ce marqueur, le consommateur
+                # attendait indéfiniment après une erreur d'OCR.
+                await ocr_queue.put(None)
             await embed_task
 
+            # Ordre stable : l'OCR rend les documents dans l'ordre où il les finit.
+            ocr_raw_results.sort(key=lambda d: d["filename"])
+            if not ocr_raw_results:
+                raise UserFacingError(
+                    "Aucun texte n'a pu être extrait des documents fournis. "
+                    "Vérifiez qu'il s'agit bien de rapports lisibles (PDF non vides, non protégés).")
+
             t_ocr_end = time.perf_counter()
             timings["ocr_embed_pipeline"] = t_ocr_end - t_ocr_start
-            chunks = all_chunks
-            logger.info(f"[{job_id[:8]}] Pipeline OCR+embed terminé: {len(chunks)} chunks en {timings['ocr_embed_pipeline']:.1f}s")
+            logger.info(f"[{job_id[:8]}] Pipeline OCR+embed terminé: {chunk_index} chunks "
+                        f"en {timings['ocr_embed_pipeline']:.1f}s")
 
             # ============================================================
-            # STEP 2 : Synthèse médicale globale (nouveau)
+            # STEP 2 : Synthèse médicale globale
             # ============================================================
             JOBS[job_id].update({
                 "status": "processing",
@@ -741,19 +904,11 @@ async def _embed_consumer():
             t_synthesis_start = time.perf_counter()
             synthesis = await run_medical_synthesis(ocr_raw_results, VLLM_URL, VLLM_MODEL)
             timings["medical_synthesis"] = time.perf_counter() - t_synthesis_start
-
-            # Index de provenance : construit sur le texte OCR complet, pas sur
-            # les chunks retenus. Une citation exacte tirée d'un document classé
-            # hors du top-24 passait sinon pour inventée.
-            derived_sources = _synthesis_as_source(synthesis)
-            source_index = SourceIndex(ocr_raw_results, derived_sources)
             JOBS[job_id]["_source_documents"] = ocr_raw_results
 
-            synthesis_json: str | None = None
             if synthesis:
-                synthesis_json = json.dumps(synthesis, ensure_ascii=False)
-                nb_dx = len(synthesis.get("diagnostics", []))
-                nb_it = len(synthesis.get("incapacites_travail", []))
+                nb_dx = len(synthesis.get("diagnostics") or [])
+                nb_it = len(synthesis.get("incapacites_travail") or [])
                 logger.info(
                     f"[{job_id[:8]}] Synthèse OK en {timings['medical_synthesis']:.1f}s "
                     f"— {nb_dx} diagnostics, {nb_it} périodes d'incapacité"
@@ -763,96 +918,33 @@ async def _embed_consumer():
                     json.dumps(synthesis, ensure_ascii=False, indent=2), encoding="utf-8"
                 )
             else:
-                logger.warning(f"[{job_id[:8]}] Synthèse échouée — mode RAG pur activé")
+                logger.warning(f"[{job_id[:8]}] Synthèse échouée — extraction sur les seuls documents")
+                warnings.append("Synthèse médicale indisponible : extraction faite sur les seuls documents.")
 
             # ============================================================
-            # STEP 3 : RAG hybride — rerank par champ + batch LLM par section
-            # Phase A : retrieval + rerank en parallèle (sem=5), top-8 chunks/champ
-            # Phase B : batch LLM par section (sem=10), ~7 champs par appel
+            # STEP 3 : Extraction des champs
             # ============================================================
             t_rag_start = time.perf_counter()
             JOBS[job_id].update({"status": "processing",
                                  "message": "🤖 Analyse LLM et extraction des entités...", "progress": 50})
-            with open(f"template/Form_{form_id}.json", "r") as f:
-                template = json.load(f)
-
-            # Une question vide ne produit qu'un embedding parasite : les templates
-            # générés par tools/gen_template.py la laissent à "" tant qu'elle n'est
-            # pas rédigée.
-            fields_with_q = _extractable_fields(template)
-            n_fields = len(fields_with_q)
-            logger.info(f"[{job_id[:8]}] Step 3: {n_fields} champs — phase A rerank, phase B batch-LLM...")
-
-            all_q_embs = await fetch_question_embeddings(
-                client, form_id, [f["question"] for f in fields_with_q])
-
-            rerank_sem, llm_sem = _RERANK_SEM, _LLM_SEM
-
-            # --- Phase A : retrieval + rerank par champ (top-12 chunks) ---
-            async def _retrieve_for_field(field: Dict, q_emb) -> tuple[List[str], float]:
-                hits = col.query(query_embeddings=[q_emb], n_results=min(30, len(chunks)))["documents"][0]
-                reranked = await fetch_rerank(client, field["question"], hits, rerank_sem=rerank_sem)
-                top = reranked[:12]
-                # Le meilleur score sert d'indice de pertinence du retrieval pour ce champ.
-                best_score = float(top[0].get("score", 0.0)) if top else 0.0
-                return [r["document"] for r in top], best_score
-
-            retrieved: List[tuple[List[str], float]] = await asyncio.gather(*[
-                _retrieve_for_field(f, emb) for f, emb in zip(fields_with_q, all_q_embs)
-            ])
-            field_chunk_map: Dict[str, List[str]] = {
-                str(f["id"]): cks for f, (cks, _) in zip(fields_with_q, retrieved)
-            }
-            field_score_map: Dict[str, float] = {
-                str(f["id"]): score for f, (_, score) in zip(fields_with_q, retrieved)
-            }
+            template = _load_template(form_id)
 
-            # --- Phase B : batch LLM par section ---
-            batches = _group_fields_into_batches(fields_with_q, max_batch_size=7)
-            batches_done = 0
-
-            async def _extract_batch(batch_fields: List[Dict]) -> List[Dict]:
-                nonlocal batches_done
-                # Fusionner les chunks uniques du batch (max 16 chunks fusionnés)
-                seen: set = set()
-                merged_chunks: List[str] = []
-                for bf in batch_fields:
-                    for c in field_chunk_map.get(str(bf["id"]), []):
-                        if c not in seen:
-                            seen.add(c)
-                            merged_chunks.append(c)
-                chunks_ctx = "\n---\n".join(merged_chunks[:24])
-
-                # Filtrer la synthèse sur la section de ce batch
-                section = str(batch_fields[0]["id"]).split(".")[0]
-                filtered_synthesis = _filter_synthesis_for_section(synthesis, section)
-
-                result = await extract_fields_batch_vllm(
-                    client, batch_fields, chunks_ctx, filtered_synthesis, llm_sem
-                )
-                _annotate_confidence(result, source_index, field_score_map)
-                batches_done += 1
+            def _progress(done: int, total: int) -> None:
                 JOBS[job_id].update({
-                    "message": f"🤖 Extraction {batches_done}/{len(batches)} sections...",
-                    "progress": 50 + int(40 * batches_done / len(batches))
+                    "message": f"🤖 Extraction {done}/{total} sections...",
+                    "progress": 50 + int(40 * done / total),
                 })
-                return result
 
-            batch_results = await asyncio.gather(*[_extract_batch(b) for b in batches])
-            results = [item for batch in batch_results for item in batch]
-            t_rag_end = time.perf_counter()
-            timings["rag_extraction"] = t_rag_end - t_rag_start
+            results = await _extract_fields(client, job_id, form_id, template, col, chunk_index,
+                                            synthesis, ocr_raw_results, _progress)
+            timings["rag_extraction"] = time.perf_counter() - t_rag_start
 
             # Stocker les résultats bruts pour le debug/eval + chat
             JOBS[job_id]["_debug_results"] = results
-            JOBS[job_id]["_debug_chunks_count"] = len(chunks)
+            JOBS[job_id]["_debug_chunks_count"] = chunk_index
             JOBS[job_id]["_debug_synthesis"] = synthesis
             # Stocker les définitions de champs pour l'endpoint /fields
-            JOBS[job_id]["_template_fields"] = [
-                {"id": f["id"], "label": f.get("label", str(f["id"])),
-                 "question": f.get("question", ""), "section": str(f["id"]).split(".")[0]}
-                for f in fields_with_q
-            ]
+            JOBS[job_id]["_template_fields"] = _template_fields_view(template)
 
             # Debug : sauvegarder les résultats LLM
             results_debug = []
@@ -860,7 +952,9 @@ async def _extract_batch(batch_fields: List[Dict]) -> List[Dict]:
                 entry = {"field_id": r.get("id")}
                 if "result" in r:
                     entry["value"] = r["result"].get("value")
+                    entry["raw_value"] = r["result"].get("raw_value")
                     entry["source_quote"] = r["result"].get("source_quote")
+                    entry["grounding"] = r["result"].get("grounding")
                 if "error" in r:
                     entry["error"] = r["error"]
                 results_debug.append(entry)
@@ -869,85 +963,11 @@ async def _extract_batch(batch_fields: List[Dict]) -> List[Dict]:
 
             # ============================================================
             # STEP 4 : Injection des valeurs dans le formulaire PDF
-            #          Supporte XFA, AcroForm pur et formulaires hybrides
             # ============================================================
             t_xfa_start = time.perf_counter()
             JOBS[job_id].update({"status": "processing", "message": "✍️ Injection des données dans le formulaire PDF...",
                             "progress": 90})
-            empty_form_path = tmp_dir / "empty.pdf"
-
-            source_template_path = Path(f"forms/Form_{form_id}.pdf")
-            if not source_template_path.exists():
-                raise FileNotFoundError(f"Template introuvable pour form_id={form_id}")
-            shutil.copy(source_template_path, empty_form_path)
-
-            # Détecter le type de formulaire
-            form_type = detect_form_type(empty_form_path)
-            logger.info(f"[{job_id[:8]}] Type de formulaire détecté : {form_type}")
-
-            # Construire les valeurs extraites par champ
-            xfa_values: Dict[str, str] = {}    # xml_path → valeur
-            acro_values: Dict[str, str] = {}   # acroform_name → valeur
-
-            for res in results:
-                if "result" not in res or not res["result"].get("value"):
-                    continue
-                value = str(res["result"]["value"])
-                f_def = next((f for f in template["fields"] if f.get("id") == res["id"]), None)
-                if f_def is None:
-                    continue
-                # Normalisation selon le type déclaré dans le template
-                value = _normalize_field_value(value, f_def.get("type"))
-                value = _resolve_option_value(value, f_def)
-                # XFA path
-                if f_def.get("xml_path"):
-                    xfa_values[f_def["xml_path"]] = value
-                # AcroForm name (champ optionnel dans le template JSON)
-                if f_def.get("acroform_name"):
-                    acro_values[f_def["acroform_name"]] = value
-
-            for f_def, value in _computed_values(template):
-                if f_def.get("xml_path"):
-                    xfa_values[f_def["xml_path"]] = value
-                if f_def.get("acroform_name"):
-                    acro_values[f_def["acroform_name"]] = value
-
-            # Le destinataire dépend du canton : il écrase aussi bien les valeurs
-            # par défaut du gabarit que ce que le modèle aurait pu produire.
-            for nom, value in _canton_recipient(template, results).items():
-                for f_def in template["fields"]:
-                    if f_def.get("name") != nom:
-                        continue
-                    if f_def.get("xml_path"):
-                        xfa_values[f_def["xml_path"]] = value
-                    if f_def.get("acroform_name"):
-                        acro_values[f_def["acroform_name"]] = value
-
-            output_pdf = tmp_dir / "output.pdf"
-
-            if form_type in ("xfa", "hybrid"):
-                # --- Injection XFA ---
-                base_xml = tmp_dir / "base.xml"
-                try:
-                    extract_xfa_datasets(empty_form_path, base_xml)
-                    checkbox_paths = discover_checkbox_paths(base_xml)
-                    normalize_checkboxes(xfa_values, checkbox_paths)
-                    filled_xml = tmp_dir / "filled.xml"
-                    update_datasets(base_xml, xfa_values, filled_xml, template["fields"])
-                    # Pour un hybride, on part du template pour la base XFA
-                    inject_datasets(empty_form_path, filled_xml, output_pdf)
-                except PDFNoXFAError:
-                    logger.warning(f"[{job_id[:8]}] XFA introuvable malgré détection hybrid — fallback AcroForm")
-                    form_type = "acroform"
-
-            if form_type == "acroform" or (form_type == "hybrid" and acro_values):
-                # --- Injection AcroForm ---
-                # Pour un hybride : repartir du PDF XFA déjà rempli si disponible, sinon template
-                acro_source = output_pdf if (form_type == "hybrid" and output_pdf.exists()) else empty_form_path
-                fill_acroform(acro_source, acro_values, output_pdf)
-
-            if form_type == "none" or not output_pdf.exists():
-                raise ValueError(f"Impossible de remplir le formulaire (type={form_type})")
+            output_pdf, form_type = _fill_pdf(job_id, form_id, template, results, tmp_dir)
 
             t_xfa_end = time.perf_counter()
             timings["xfa_injection"] = t_xfa_end - t_xfa_start
@@ -957,24 +977,26 @@ async def _extract_batch(batch_fields: List[Dict]) -> List[Dict]:
             ok_count = sum(1 for r in results if "result" in r and r["result"].get("value"))
             err_count = sum(1 for r in results if "error" in r)
             empty_count = sum(1 for r in results if "result" in r and not r["result"].get("value"))
-            synthesis_info = "Non disponible (fallback RAG pur)"
+            _record_field_errors(JOBS[job_id], results)
+            synthesis_info = "Non disponible (extraction sur les seuls documents)"
             if synthesis:
-                nb_dx = len(synthesis.get("diagnostics", []))
-                nb_it = len(synthesis.get("incapacites_travail", []))
+                nb_dx = len(synthesis.get("diagnostics") or [])
+                nb_it = len(synthesis.get("incapacites_travail") or [])
                 synthesis_info = f"{nb_dx} diagnostics, {nb_it} périodes d'incapacité"
             summary = (
                 f"Job: {job_id}\nForm: {form_id}\nDate: {datetime.now().isoformat()}\n"
-                f"Fichiers: {total_files}\nChunks: {len(chunks)}\n"
+                f"Fichiers: {total_files} (lus: {len(ocr_raw_results)})\nChunks: {chunk_index}\n"
                 f"Type formulaire: {form_type}\n"
                 f"Synthèse médicale: {synthesis_info}\n"
-                f"Champs: {n_fields} (OK: {ok_count}, Erreurs: {err_count}, Vides: {empty_count})\n"
+                f"Champs: {len(results)} (OK: {ok_count}, Erreurs: {err_count}, Vides: {empty_count})\n"
                 f"Timings: OCR+embed={timings['ocr_embed_pipeline']:.1f}s, "
                 f"Synthèse={timings.get('medical_synthesis', 0):.1f}s, "
-                f"RAG={timings['rag_extraction']:.1f}s, Injection={timings['xfa_injection']:.1f}s, "
+                f"Extraction={timings['rag_extraction']:.1f}s, Injection={timings['xfa_injection']:.1f}s, "
                 f"Total={timings['total']:.1f}s\n"
             )
             (debug_dir / "summary.txt").write_text(summary, encoding="utf-8")
-            logger.info(f"[{job_id[:8]}] Pipeline terminé en {timings['total']:.1f}s — Debug: {debug_dir}")
+            logger.info(f"[{job_id[:8]}] Pipeline terminé en {timings['total']:.1f}s — "
+                        f"{ok_count}/{len(results)} champs remplis — Debug: {debug_dir}")
 
             # Durée vécue par l'utilisateur : de la soumission au formulaire prêt,
             # transfert et attente comprises. `timings["total"]` ne couvre que le
@@ -993,9 +1015,16 @@ async def _extract_batch(batch_fields: List[Dict]) -> List[Dict]:
                 "duration_s": round(elapsed, 1),
                 "_form_id": form_id,
                 "_tmp_dir": str(tmp_dir),
-                "_debug_dir": str(debug_dir),
             })
 
+    except UserFacingError as e:
+        logger.warning(f"Job {job_id} refusé : {e}")
+        JOBS[job_id].update({
+            "status": "failed",
+            "message": str(e),
+            "progress": 0,
+            "completed_at": time.time()
+        })
     except Exception as e:
         # [SEC-10] Log complet côté serveur, message générique côté client
         logger.error(f"Erreur Job {job_id}: {e}", exc_info=True)
@@ -1075,7 +1104,7 @@ async def process_form(
     # --- [SEC-07] Job ID complet (128 bits) + token secret
     job_id = uuid.uuid4().hex
     download_token = secrets.token_urlsafe(32)
-    tmp_dir = Path(f"/tmp/{job_id}")
+    tmp_dir = JOBS_DIR / job_id
     tmp_dir.mkdir(parents=True, exist_ok=True)
 
     saved_report_paths = []
@@ -1132,6 +1161,9 @@ async def get_status(job_id: str):
         "progress": job.get("progress"),
         "elapsed_s": round(time.time() - started, 1) if started else None,
         "duration_s": job.get("duration_s"),
+        # Ce que l'utilisateur doit savoir sans que le job échoue : document
+        # illisible écarté, champs à compléter à la main.
+        "warnings": job.get("warnings", []),
     }
 
 
@@ -1144,7 +1176,7 @@ async def get_fields(job_id: str, token: str = ""):
     if job_id not in JOBS or JOBS[job_id].get("status") != "completed":
         raise HTTPException(status_code=404, detail="Session introuvable ou traitement non terminé.")
     expected_token = JOBS[job_id].get("token", "")
-    if expected_token and token != expected_token:
+    if expected_token and not secrets.compare_digest(token, expected_token):
         raise HTTPException(status_code=403, detail="Token invalide.")
 
     template_fields = JOBS[job_id].get("_template_fields", [])
@@ -1168,6 +1200,9 @@ async def get_fields(job_id: str, token: str = ""):
             "source_page": payload.get("source_page"),
             "source_excerpt": payload.get("source_excerpt"),
             "source_match": payload.get("source_match"),
+            # Réponse du modèle avant normalisation, quand elle diffère.
+            "raw_value": payload.get("raw_value"),
+            "error": r.get("error"),
         })
     return {"fields": fields_out}
 
@@ -1178,6 +1213,7 @@ async def get_fields(job_id: str, token: str = ""):
 class ChatRequest(BaseModel):
     job_id: str
     message: str
+    token: str = ""
     history: List[Dict[str, Any]] = []
 
 
@@ -1193,6 +1229,11 @@ async def chat_endpoint(request: ChatRequest):
     job = JOBS.get(request.job_id)
     if not job or job.get("status") != "completed":
         raise HTTPException(status_code=404, detail="Session introuvable ou traitement non terminé.")
+    # Le chat lit le dossier patient : même contrôle que /fields et /download,
+    # qui l'exigeaient déjà alors que celui-ci s'en passait.
+    expected_token = job.get("token", "")
+    if expected_token and not secrets.compare_digest(request.token, expected_token):
+        raise HTTPException(status_code=403, detail="Token invalide.")
 
     synthesis = job.get("_debug_synthesis")
     synthesis_json = json.dumps(synthesis, ensure_ascii=False) if synthesis else None
@@ -1309,24 +1350,23 @@ async def get_synthesis(job_id: str, token: str = ""):
 
 @app.post("/synthesis/{job_id}/generate")
 async def generate_synthesis(job_id: str, token: str = ""):
-    """(Re)génère la synthèse médicale depuis les fichiers OCR sauvegardés sur disque."""
+    """(Re)génère la synthèse médicale depuis le texte OCR conservé avec le job."""
     job = _validate_job_token(job_id, token)
-    debug_dir = Path(job.get("_debug_dir", ""))
-    markdown_dir = debug_dir / "markdown"
-    if not markdown_dir.exists():
-        raise HTTPException(status_code=404, detail="Fichiers OCR introuvables (session expirée ou trop ancienne).")
-
-    ocr_results = []
-    for md_file in sorted(markdown_dir.glob("*.md")):
-        try:
-            ocr_results.append({"filename": md_file.name, "markdown": md_file.read_text(encoding="utf-8")})
-        except Exception:
-            pass
+    # Le texte OCR vit avec le job ; les journaux de debug, purgés avec lui, ne
+    # servent plus que de secours pour un job antérieur à ce changement.
+    ocr_results = list(job.get("_source_documents") or [])
+    if not ocr_results:
+        markdown_dir = Path(job.get("_debug_dir", "")) / "markdown"
+        for md_file in sorted(markdown_dir.glob("*.md")) if markdown_dir.exists() else []:
+            try:
+                ocr_results.append({"filename": md_file.name, "markdown": md_file.read_text(encoding="utf-8")})
+            except OSError:
+                pass
 
     if not ocr_results:
-        raise HTTPException(status_code=404, detail="Aucun fichier OCR trouvé pour régénérer la synthèse.")
+        raise HTTPException(status_code=404, detail="Texte OCR introuvable (session expirée ou trop ancienne).")
 
-    logger.info(f"[{job_id[:8]}] Régénération synthèse depuis {len(ocr_results)} fichiers OCR...")
+    logger.info(f"[{job_id[:8]}] Régénération synthèse depuis {len(ocr_results)} documents...")
     synthesis = await run_medical_synthesis(ocr_results, VLLM_URL, VLLM_MODEL)
     if synthesis is None:
         raise HTTPException(status_code=502, detail="Le LLM n'a pas pu générer la synthèse. Vérifiez les logs.")
@@ -1381,11 +1421,18 @@ async def refine_synthesis(job_id: str, request: SynthesisRefineRequest):
 
 
 async def rerun_pipeline_task(job_id: str):
+    """Re-run sous le même portier que le pipeline : il sollicite autant le GPU."""
+    _announce_queue(job_id)
+    async with _PIPELINE_SEM:
+        await _rerun_pipeline(job_id)
+
+
+async def _rerun_pipeline(job_id: str):
     """Re-run rapide : saute l'OCR/embedding, réutilise le ChromaDB existant avec la synthèse mise à jour."""
     form_id = JOBS[job_id].get("_form_id")
     synthesis = JOBS[job_id].get("_debug_synthesis")
     collection_name = f"col_{job_id}"
-    tmp_dir = Path(JOBS[job_id].get("_tmp_dir", f"/tmp/{job_id}"))
+    tmp_dir = Path(JOBS[job_id].get("_tmp_dir") or JOBS_DIR / job_id)
     tmp_dir.mkdir(parents=True, exist_ok=True)
 
     try:
@@ -1393,127 +1440,31 @@ async def rerun_pipeline_task(job_id: str):
 
         col = chroma_client.get_collection(name=collection_name)
         col_count = col.count()
-        if col_count == 0:
-            raise ValueError("ChromaDB vide — session expirée, impossible de relancer sans re-OCR.")
-
-        with open(f"template/Form_{form_id}.json", "r") as f:
-            template = json.load(f)
+        documents = JOBS[job_id].get("_source_documents") or []
+        if not documents:
+            raise ValueError("Contexte du job vide — session expirée, impossible de relancer sans re-OCR.")
 
-        fields_with_q = _extractable_fields(template)
-        n_fields = len(fields_with_q)
-        logger.info(f"[{job_id[:8]}] Re-run: {n_fields} champs, {col_count} chunks en ChromaDB.")
-
-        # Le re-run ne repasse pas par l'OCR : il réutilise le texte conservé
-        # avec le job. Sans lui, aucune valeur ne pourrait être rattachée.
-        source_index = SourceIndex(JOBS[job_id].get("_source_documents", []),
-                                   _synthesis_as_source(synthesis))
+        template = _load_template(form_id)
+        logger.info(f"[{job_id[:8]}] Re-run: {col_count} chunks en ChromaDB.")
 
         limits = httpx.Limits(max_connections=50, max_keepalive_connections=10, keepalive_expiry=30)
         async with httpx.AsyncClient(limits=limits) as client:
-            JOBS[job_id].update({"message": "🔄 Re-run : re-encodage des questions...", "progress": 15})
-            all_q_embs = await fetch_question_embeddings(
-                client, form_id, [f["question"] for f in fields_with_q])
-
-            rerank_sem, llm_sem = _RERANK_SEM, _LLM_SEM
-
-            async def _retrieve_field(field: Dict, q_emb) -> tuple[List[str], float]:
-                hits = col.query(query_embeddings=[q_emb], n_results=min(30, col_count))["documents"][0]
-                reranked = await fetch_rerank(client, field["question"], hits, rerank_sem=rerank_sem)
-                top = reranked[:12]
-                best_score = float(top[0].get("score", 0.0)) if top else 0.0
-                return [r["document"] for r in top], best_score
-
-            JOBS[job_id].update({"message": "🔄 Re-run : retrieval + reranking...", "progress": 30})
-            retrieved: List[tuple[List[str], float]] = await asyncio.gather(*[
-                _retrieve_field(f, emb) for f, emb in zip(fields_with_q, all_q_embs)
-            ])
-            field_chunk_map: Dict[str, List[str]] = {
-                str(f["id"]): cks for f, (cks, _) in zip(fields_with_q, retrieved)
-            }
-            field_score_map: Dict[str, float] = {
-                str(f["id"]): score for f, (_, score) in zip(fields_with_q, retrieved)
-            }
+            JOBS[job_id].update({"message": "🔄 Re-run : extraction...", "progress": 30})
 
-            batches = _group_fields_into_batches(fields_with_q, max_batch_size=7)
-            batches_done = 0
-
-            async def _extract_batch_rerun(batch_fields: List[Dict]) -> List[Dict]:
-                nonlocal batches_done
-                seen: set = set()
-                merged: List[str] = []
-                for bf in batch_fields:
-                    for c in field_chunk_map.get(str(bf["id"]), []):
-                        if c not in seen:
-                            seen.add(c)
-                            merged.append(c)
-                chunks_ctx = "\n---\n".join(merged[:24])
-                section = str(batch_fields[0]["id"]).split(".")[0]
-                filtered_synthesis = _filter_synthesis_for_section(synthesis, section)
-                result = await extract_fields_batch_vllm(client, batch_fields, chunks_ctx, filtered_synthesis, llm_sem)
-                _annotate_confidence(result, source_index, field_score_map)
-                batches_done += 1
+            def _progress(done: int, total: int) -> None:
                 JOBS[job_id].update({
-                    "message": f"🔄 Re-run : extraction {batches_done}/{len(batches)}...",
-                    "progress": 40 + int(45 * batches_done / len(batches))
+                    "message": f"🔄 Re-run : extraction {done}/{total}...",
+                    "progress": 30 + int(55 * done / total),
                 })
-                return result
-
-            batch_results = await asyncio.gather(*[_extract_batch_rerun(b) for b in batches])
-            results = [item for batch in batch_results for item in batch]
 
+            results = await _extract_fields(client, job_id, form_id, template, col, col_count,
+                                            synthesis, documents, _progress)
             JOBS[job_id]["_debug_results"] = results
-            JOBS[job_id]["_template_fields"] = [
-                {"id": f["id"], "label": f.get("label", str(f["id"])),
-                 "question": f.get("question", ""), "section": str(f["id"]).split(".")[0]}
-                for f in fields_with_q
-            ]
+            JOBS[job_id]["_template_fields"] = _template_fields_view(template)
+            _record_field_errors(JOBS[job_id], results)
 
-            # Step 4: PDF fill
             JOBS[job_id].update({"message": "✍️ Re-run : injection dans le formulaire...", "progress": 88})
-            empty_form_path = tmp_dir / "empty_rerun.pdf"
-            source_template_path = Path(f"forms/Form_{form_id}.pdf")
-            if not source_template_path.exists():
-                raise FileNotFoundError(f"Template PDF introuvable pour form_id={form_id}")
-            shutil.copy(source_template_path, empty_form_path)
-
-            form_type = detect_form_type(empty_form_path)
-            xfa_values: Dict[str, str] = {}
-            acro_values: Dict[str, str] = {}
-
-            for res in results:
-                if "result" not in res or not res["result"].get("value"):
-                    continue
-                value = str(res["result"]["value"])
-                f_def = next((f for f in template["fields"] if f.get("id") == res["id"]), None)
-                if f_def is None:
-                    continue
-                value = _normalize_field_value(value, f_def.get("type"))
-                value = _resolve_option_value(value, f_def)
-                if f_def.get("xml_path"):
-                    xfa_values[f_def["xml_path"]] = value
-                if f_def.get("acroform_name"):
-                    acro_values[f_def["acroform_name"]] = value
-
-            output_pdf = tmp_dir / "output_rerun.pdf"
-
-            if form_type in ("xfa", "hybrid"):
-                base_xml = tmp_dir / "base_rerun.xml"
-                try:
-                    extract_xfa_datasets(empty_form_path, base_xml)
-                    checkbox_paths = discover_checkbox_paths(base_xml)
-                    normalize_checkboxes(xfa_values, checkbox_paths)
-                    filled_xml = tmp_dir / "filled_rerun.xml"
-                    update_datasets(base_xml, xfa_values, filled_xml, template["fields"])
-                    inject_datasets(empty_form_path, filled_xml, output_pdf)
-                except PDFNoXFAError:
-                    form_type = "acroform"
-
-            if form_type == "acroform" or (form_type == "hybrid" and acro_values):
-                acro_source = output_pdf if (form_type == "hybrid" and output_pdf.exists()) else empty_form_path
-                fill_acroform(acro_source, acro_values, output_pdf)
-
-            if not output_pdf.exists():
-                raise ValueError(f"Impossible de générer le formulaire re-run (type={form_type})")
+            output_pdf, _ = _fill_pdf(job_id, form_id, template, results, tmp_dir, suffix="_rerun")
 
         JOBS[job_id].update({
             "status": "completed",
@@ -1542,6 +1493,9 @@ async def trigger_rerun(job_id: str, background_tasks: BackgroundTasks, token: s
         raise HTTPException(status_code=409, detail="Un traitement est déjà en cours.")
     if not job.get("_form_id"):
         raise HTTPException(status_code=400, detail="Métadonnées de re-run manquantes (job trop ancien ?).")
+    # Marqué tout de suite : sinon un second clic, avant le démarrage de la tâche
+    # de fond, lançait un second re-run concurrent sur le même job.
+    job.update({"status": "processing", "message": "🔄 Re-run en préparation...", "progress": 2})
     background_tasks.add_task(rerun_pipeline_task, job_id)
     return {"ok": True, "job_id": job_id}
 
@@ -1587,6 +1541,7 @@ async def debug_results(job_id: str, token: str = ""):
                 "value": r.get("result", {}).get("value") if "result" in r else None,
                 "source_quote": r.get("result", {}).get("source_quote") if "result" in r else None,
                 "quote_verified": r.get("result", {}).get("quote_verified") if "result" in r else None,
+                "raw_value": r.get("result", {}).get("raw_value") if "result" in r else None,
                 "rerank_score": r.get("result", {}).get("rerank_score") if "result" in r else None,
                 "grounding": r.get("result", {}).get("grounding") if "result" in r else None,
                 "source_document": r.get("result", {}).get("source_document") if "result" in r else None,
diff --git a/services/orchestrator/core/acroform.py b/services/orchestrator/core/acroform.py
index 2a3b3e9..8b2e970 100644
--- a/services/orchestrator/core/acroform.py
+++ b/services/orchestrator/core/acroform.py
@@ -233,6 +233,31 @@ def _fill_radio(field_obj: pikepdf.Object, value: Any) -> bool:
     return True
 
 
+def _choice_option(field_obj: pikepdf.Object, value: Any) -> tuple[str, str]:
+    """
+    (valeur d'export, libellé affiché) d'une liste de choix pour `value`.
+
+    Une liste /Ch peut déclarer ses options en paires [export, libellé] : le
+    formulaire attend l'export dans /V (« 1 »), le lecteur affiche le libellé
+    (« oui »). Écrire le libellé dans /V, ou dessiner l'export dans l'apparence,
+    donnait un champ incohérent ou un « 1 » à l'écran. On accepte l'un comme
+    l'autre en entrée.
+    """
+    text = "" if value is None else str(value).strip()
+    options = field_obj.get("/Opt")
+    if options is None:
+        return text, text
+    target = text.casefold()
+    for option in options:
+        if isinstance(option, pikepdf.Array) and len(option) >= 2:
+            export, display = str(option[0]), str(option[1])
+        else:
+            export = display = str(option)
+        if target in (export.strip().casefold(), display.strip().casefold()):
+            return export, display
+    return text, text
+
+
 def _fill_fields_recursive(
     pdf: pikepdf.Pdf,
     acroform: pikepdf.Object,
@@ -272,7 +297,11 @@ def _fill_fields_recursive(
         if full_name in values_by_name and full_name not in filled:
             value = values_by_name[full_name]
             on_state = _checkbox_on_state(obj) if _is_checkbox(obj) else None
-            obj["/V"] = _normalize_acroform_value(value, on_state)
+            if str(obj.get("/FT") or "") == "/Ch":
+                export, value = _choice_option(obj, value)
+                obj["/V"] = pikepdf.String(export)
+            else:
+                obj["/V"] = _normalize_acroform_value(value, on_state)
             # On construit l'apparence nous-mêmes : PDFium n'honore pas /NeedAppearances.
             try:
                 build_appearance(pdf, acroform, obj, value, on_state)
diff --git a/services/orchestrator/core/checkbox.py b/services/orchestrator/core/checkbox.py
index b9a2c91..816c93b 100644
--- a/services/orchestrator/core/checkbox.py
+++ b/services/orchestrator/core/checkbox.py
@@ -90,8 +90,9 @@ def discover_checkbox_paths(datasets_xml: str | Path) -> List[str]:
 # Checkbox Normalization
 # ──────────────────────────────────────────────────────────────
 
-_TRUTHY = {"on", "true", "1", "yes", "y", "x", "checked"}
-_FALSY = {"off", "false", "0", "no", "n", ""}
+# Le modèle répond en français : « oui » tombait dans le repli « Off ».
+_TRUTHY = {"on", "true", "1", "yes", "y", "x", "checked", "oui", "vrai", "coché", "coche"}
+_FALSY = {"off", "false", "0", "no", "n", "", "non", "faux"}
 
 
 def _to_on_off(value: Any) -> str:
diff --git a/services/orchestrator/core/fields.py b/services/orchestrator/core/fields.py
new file mode 100644
index 0000000..bf34c32
--- /dev/null
+++ b/services/orchestrator/core/fields.py
@@ -0,0 +1,607 @@
+"""
+core/fields.py — Préparation des champs d'un template, avant et après le modèle.
+
+Avant l'appel LLM : quels champs soumettre, comment formuler leur question pour
+qu'elle soit univoque, et comment les regrouper en lots cohérents.
+Après : ramener la réponse du modèle à une valeur que le formulaire accepte.
+
+Tout est déterministe et sans dépendance réseau : c'est la partie du pipeline
+qu'on peut tester entièrement hors ligne.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+import unicodedata
+from datetime import date
+from typing import Any, Iterable
+
+logger = logging.getLogger(__name__)
+
+
+def fold(text: str) -> str:
+    """Forme comparable : minuscules, sans accents, espaces réduits."""
+    decomposed = unicodedata.normalize("NFKD", str(text).casefold())
+    stripped = "".join(c for c in decomposed if not unicodedata.combining(c))
+    return " ".join(stripped.split())
+
+
+# ---------------------------------------------------------------------------
+# Quels champs soumettre au modèle
+# ---------------------------------------------------------------------------
+
+def _is_yes_no(labels: Iterable[str]) -> bool:
+    folded = [fold(label) for label in labels]
+    return any(f.startswith("oui") for f in folded) and any(f.startswith("non") for f in folded)
+
+
+def is_blank_default(field: dict) -> bool:
+    """
+    Le `preset` d'un champ n'est-il que l'état vierge du formulaire ?
+
+    `preset` recopie la valeur que le PDF vierge porte déjà. Pour un bloc adresse
+    ou un régime d'assurance, c'est une donnée de l'éditeur qui fait autorité.
+    Mais une case décochée (« /Off »), une question oui/non positionnée sur
+    « non » ou un compteur à 0 ne disent rien : c'est l'état par défaut d'un
+    formulaire que personne n'a encore rempli. Les tenir pour acquis écartait de
+    l'extraction 79 cases à cocher et une dizaine de questions fermées — des
+    champs cliniques (urgence, hospitalisation, rechute…) jamais remplis.
+    """
+    preset = str(field.get("preset") or "").strip()
+    if not preset:
+        return False
+    state = preset.lstrip("/").strip().casefold()
+    kind = field.get("type")
+    if kind == "bool":
+        return state in {"off", "0", "no", "non", "false"}
+    if kind == "int":
+        # « /0 » est un état de bouton, pas un nombre : on n'y touche pas.
+        return preset == "0"
+    if kind == "choice":
+        labels = field.get("options") or []
+        if not _is_yes_no(labels):
+            return False
+        values = field.get("option_values") or []
+        for index, label in enumerate(labels):
+            if fold(label).startswith("non"):
+                if state == fold(label):
+                    return True
+                if index < len(values) and state == str(values[index]).casefold():
+                    return True
+    return False
+
+
+def extractable_fields(template: dict) -> list[dict]:
+    """
+    Champs à soumettre au modèle.
+
+    Écarte les champs `computed` (déduits du formulaire lui-même) et les champs
+    `preset` : l'éditeur du formulaire les a déjà renseignés (adresse de l'office
+    destinataire, code EAN, données de routage) et ils font autorité. Les
+    extraire produisait des documents incohérents — un formulaire AI adressé à
+    « Helvetia Santé SA » parce que le dossier mentionnait cette caisse, à
+    l'adresse de l'Office AI restée en dessous.
+
+    Exception : un `preset` qui n'est que l'état vierge du champ (voir
+    `is_blank_default`) reste à remplir.
+    """
+    return [f for f in template.get("fields", [])
+            if "id" in f
+            and str(f.get("question") or "").strip()
+            and "computed" not in f
+            and (not f.get("preset") or is_blank_default(f))]
+
+
+# ---------------------------------------------------------------------------
+# Questions univoques
+# ---------------------------------------------------------------------------
+
+# Conteneurs medForms dont les occurrences successives portent des champs de même
+# question. Le libellé nomme ce que chaque occurrence représente ; l'ordre dit au
+# modèle comment les répartir.
+STRUCT_CONTEXT: dict[str, tuple[str, str]] = {
+    "unemployabilityS1Struct": ("période d'incapacité de travail",
+                                "de la plus ancienne à la plus récente"),
+    "diagnosisS1Struct": ("diagnostic", "du principal au plus secondaire"),
+    "treatmentS1Struct": ("traitement", "ordre chronologique"),
+    "documentS1Struct": ("document annexé", "ordre des documents"),
+    "therapyStruct": ("thérapie", "ordre chronologique"),
+    "anamnesisStruct": ("anamnèse", "ordre chronologique"),
+}
+
+_INDEX = re.compile(r"\[\d+\]$")
+
+
+def _segments(xml_path: str | None) -> list[str]:
+    return [s for s in str(xml_path or "").split("/") if s]
+
+
+def _canonical_struct(segment: str) -> str:
+    """`bdiagnosisS1Struct[2]` → `diagnosisS1Struct` : même structure, préfixe d'ordre."""
+    bare = _INDEX.sub("", segment)
+    for known in STRUCT_CONTEXT:
+        if bare.endswith(known):
+            return known
+    return bare
+
+
+def _container(field: dict) -> str:
+    """Chemin du conteneur d'un champ, indices et préfixes d'ordre effacés."""
+    parts = _segments(field.get("xml_path"))[:-1]
+    if not parts:
+        return ""
+    return "/".join([_INDEX.sub("", p) for p in parts[:-1]] + [_canonical_struct(parts[-1])])
+
+
+def _struct_of(field: dict) -> str:
+    parts = _segments(field.get("xml_path"))
+    return _canonical_struct(parts[-2]) if len(parts) >= 2 else ""
+
+
+def coding_systems(template: dict) -> dict[str, str]:
+    """
+    Conteneur → système de codage imposé par le formulaire (`type` prérempli).
+
+    Les formulaires d'hospitalisation portent quatre blocs `diagnosisS1Struct`,
+    dont deux réservés aux interventions (codage CHOP). Sans cette distinction,
+    ils étaient numérotés « diagnostic n°3 et n°4 » et recevaient des codes CIM-10.
+    """
+    systems: dict[str, str] = {}
+    for f in template.get("fields", []):
+        preset = str(f.get("preset") or "")
+        parts = _segments(f.get("xml_path"))
+        if f.get("name") == "type" and preset in ("ICD", "CHOP") and len(parts) >= 2:
+            systems["/".join(parts[:-1])] = preset
+    return systems
+
+
+def _context_of(field: dict, coding: dict[str, str]) -> tuple[str, str, str]:
+    """(clé de numérotation, libellé, ordre) de la structure qui porte un champ."""
+    parts = _segments(field.get("xml_path"))
+    key = _container(field)
+    label, order = STRUCT_CONTEXT.get(_struct_of(field), ("", ""))
+    if coding.get("/".join(parts[:-1])) == "CHOP":
+        return key + "#CHOP", "intervention", "ordre chronologique"
+    return key, label, order
+
+
+# Consignes de format dans une question : utiles au modèle, parasites pour la
+# recherche sémantique (« Répondre UNIQUEMENT par … AG, AI, AR, BE… »).
+_BRACKETS = re.compile(r"\[[^\]]*\]")
+_ANSWER_HINT = re.compile(r"\b(?:Répondre|Reprendre|Répondez)\b.*$", re.IGNORECASE | re.DOTALL)
+
+
+def retrieval_text(question: str) -> str:
+    """Question débarrassée de ses consignes de format, pour l'embedding et le rerank."""
+    text = _ANSWER_HINT.sub("", _BRACKETS.sub("", question))
+    return " ".join(text.split()) or question
+
+
+def contextualize(fields: list[dict], coding: dict[str, str] | None = None) -> list[dict]:
+    """
+    Rend chaque question univoque au sein du formulaire.
+
+    Le vocabulaire medForms produit la même question pour les occurrences
+    successives d'une structure : « Quelle est la date de début de la période
+    concernée ? » quatre fois pour quatre périodes d'incapacité, deux fois
+    « Quel est le numéro de téléphone du patient ? » pour `phone` et `phone[1]`.
+    177 champs du catalogue sont dans ce cas. Le modèle n'avait aucun moyen de
+    savoir laquelle il remplissait : il répétait la même valeur partout ou
+    laissait tout vide.
+
+    On ajoute à ces questions le contexte que porte le chemin XFA : la structure
+    (« période d'incapacité de travail ») et le rang de l'occurrence.
+
+    Args:
+        coding: système de codage par conteneur (voir `coding_systems`).
+
+    Returns:
+        copies des champs, enrichies de `prompt_question` (pour le modèle) et
+        `retrieval_query` (pour la recherche sémantique).
+    """
+    coding = coding or {}
+    by_question: dict[str, list[int]] = {}
+    for index, field in enumerate(fields):
+        by_question.setdefault(fold(field.get("question", "")), []).append(index)
+
+    prepared = [dict(f) for f in fields]
+    for indexes in by_question.values():
+        base = prepared[indexes[0]]
+        if len(indexes) == 1:
+            base["prompt_question"] = base.get("question", "")
+            base["retrieval_query"] = retrieval_text(base.get("question", ""))
+            continue
+
+        # Rang calculé par structure : un `beginDate` de traitement ne partage pas
+        # la numérotation des périodes d'incapacité qui ont la même question.
+        by_struct: dict[str, list[int]] = {}
+        for i in indexes:
+            by_struct.setdefault(_context_of(prepared[i], coding)[0], []).append(i)
+
+        for members in by_struct.values():
+            for rank, i in enumerate(members, start=1):
+                field = prepared[i]
+                question = field.get("question", "")
+                _, label, order = _context_of(field, coding)
+                total = len(members)
+                if label and total > 1:
+                    hint = f"{label} n°{rank} sur {total} — {order} ; vide s'il n'y en a pas de n°{rank}"
+                elif label:
+                    hint = label
+                elif total > 1:
+                    hint = (f"occurrence n°{rank} sur {total} de cette question — une valeur "
+                            f"différente par occurrence ; vide s'il n'y en a pas de n°{rank}")
+                else:
+                    hint = ""
+                field["prompt_question"] = f"{question} (Contexte : {hint}.)" if hint else question
+                field["retrieval_query"] = retrieval_text(question) + (f" — {label}" if label else "")
+    return prepared
+
+
+def prepare_fields(template: dict) -> list[dict]:
+    """Champs à extraire, prêts pour la recherche et le prompt."""
+    return contextualize(extractable_fields(template), coding_systems(template))
+
+
+# ---------------------------------------------------------------------------
+# Lots d'extraction
+# ---------------------------------------------------------------------------
+
+def batch_fields(fields: list[dict], max_batch_size: int = 8,
+                 max_family_size: int = 32) -> list[list[dict]]:
+    """
+    Regroupe les champs en lots pour l'appel LLM.
+
+    Par section d'abord (préfixe de l'ID), puis en gardant ensemble les
+    occurrences d'une même structure répétée : les quatre périodes d'incapacité
+    doivent être réparties dans un seul appel, sans quoi deux appels distincts
+    attribuent la même période au n°1 et au n°2.
+    """
+    question_count: dict[str, int] = {}
+    for f in fields:
+        key = fold(f.get("question", ""))
+        question_count[key] = question_count.get(key, 0) + 1
+
+    # section → familles, dans l'ordre d'apparition
+    sections: dict[str, dict[str, list[dict]]] = {}
+    for f in fields:
+        section = str(f["id"]).split(".")[0]
+        repeated = question_count[fold(f.get("question", ""))] > 1 and _container(f)
+        family = f"family:{_container(f)}" if repeated else f"field:{f['id']}"
+        sections.setdefault(section, {}).setdefault(family, []).append(f)
+
+    batches: list[list[dict]] = []
+    for families in sections.values():
+        current: list[dict] = []
+        for members in families.values():
+            if len(members) > 1:
+                if current:
+                    batches.append(current)
+                    current = []
+                for i in range(0, len(members), max_family_size):
+                    batches.append(members[i:i + max_family_size])
+                continue
+            current.extend(members)
+            if len(current) >= max_batch_size:
+                batches.append(current)
+                current = []
+        if current:
+            batches.append(current)
+    return batches
+
+
+# ---------------------------------------------------------------------------
+# Normalisation des valeurs produites par le modèle
+# ---------------------------------------------------------------------------
+
+# Réponses qui disent « je n'ai pas trouvé » au lieu de laisser la chaîne vide.
+# Écrites telles quelles, elles remplissaient le formulaire de « Non mentionné ».
+_NULL_LIKE = re.compile(
+    r"^(?:null|none|nil|nan|n/?a|n\.?c\.?|n\.?d\.?|inconnue?s?|\?+|[-–—_.… ]*"
+    r"|(?:aucune |pas d')?information(?:s)?(?: non disponibles?| absentes?| manquantes?)?"
+    r"|non (?:mentionn|precis|renseign|specifi|disponible|communiqu|indiqu|document|trouv"
+    r"|applicable|connu|fourni|determin|rapport|stipul|detaill)\w*(?:\W.*)?"
+    r"|(?:pas|rien) (?:de donnee|d'information|mentionne|precise|trouve|indique)\w*(?:\W.*)?"
+    r"|(?:information|donnee)s? (?:non|pas) (?:disponible|mentionne|precise|trouve|fourni)\w*(?:\W.*)?)$"
+)
+# Exemples de format recopiés à la place d'une valeur.
+_PLACEHOLDER = re.compile(r"^<[^<>]*>$|\b(?:jj|dd)\W?mm\W?(?:aaaa|yyyy|aa|yy)\b|x{3,}|^\.\.\.$")
+
+
+def is_null_like(value: str) -> bool:
+    folded = fold(value)
+    return not folded or bool(_NULL_LIKE.match(folded)) or bool(_PLACEHOLDER.search(folded))
+
+
+def coerce_text(value: Any) -> str:
+    """Ramène n'importe quelle valeur JSON à une chaîne."""
+    if value is None:
+        return ""
+    if isinstance(value, bool):
+        return "oui" if value else "non"
+    if isinstance(value, float) and value.is_integer():
+        return str(int(value))
+    if isinstance(value, (list, tuple)):
+        return "\n".join(t for t in (coerce_text(v).strip() for v in value) if t)
+    if isinstance(value, dict):
+        for key in ("value", "valeur", "text"):
+            if key in value:
+                return coerce_text(value[key])
+        return "\n".join(f"{k} : {coerce_text(v)}" for k, v in value.items() if coerce_text(v))
+    return str(value)
+
+
+_MONTHS = {
+    "janvier": 1, "janv": 1, "jan": 1, "fevrier": 2, "fevr": 2, "fev": 2, "mars": 3,
+    "avril": 4, "avr": 4, "mai": 5, "juin": 6, "juillet": 7, "juil": 7, "aout": 8,
+    "septembre": 9, "sept": 9, "sep": 9, "octobre": 10, "oct": 10, "novembre": 11,
+    "nov": 11, "decembre": 12, "dec": 12,
+}
+_DATE_NUMERIC = re.compile(r"\b(\d{1,2})[./-](\d{1,2})[./-](\d{4}|\d{2})\b")
+_DATE_ISO = re.compile(r"\b(\d{4})-(\d{1,2})-(\d{1,2})\b")
+_DATE_WORDS = re.compile(r"\b(\d{1,2})(?:er)?\s+([a-z]+)\.?\s+(\d{4})\b")
+
+
+def _format_date(day: int, month: int, year: int) -> str | None:
+    try:
+        date(year, month, day)
+    except ValueError:
+        return None
+    return f"{day:02d}.{month:02d}.{year:04d}"
+
+
+def normalize_date(value: str) -> str:
+    """
+    Ramène une date au format JJ.MM.AAAA demandé par les formulaires.
+
+    Accepte « 2025-03-15 », « 15/3/2025 », « 15 mars 2025 », et une date seule
+    noyée dans du texte (« dès le 15.03.2025 »). Plusieurs dates, ou aucune
+    date reconnue : la valeur est rendue telle quelle.
+    """
+    folded = fold(value)
+    found: list[str] = []
+    for m in _DATE_ISO.finditer(folded):
+        found.append(_format_date(int(m.group(3)), int(m.group(2)), int(m.group(1))) or "")
+    without_iso = _DATE_ISO.sub(" ", folded)
+    for m in _DATE_NUMERIC.finditer(without_iso):
+        year = int(m.group(3))
+        if len(m.group(3)) == 2:
+            pivot = date.today().year % 100 + 1
+            year += 2000 if year <= pivot else 1900
+        found.append(_format_date(int(m.group(1)), int(m.group(2)), year) or "")
+    for m in _DATE_WORDS.finditer(folded):
+        month = _MONTHS.get(m.group(2))
+        if month:
+            found.append(_format_date(int(m.group(1)), month, int(m.group(3))) or "")
+    distinct = {d for d in found if d}
+    if len(distinct) == 1 and len(found) == 1:
+        return distinct.pop()
+    return value
+
+
+_TRUE_WORDS = {"oui", "yes", "true", "vrai", "1", "on", "x", "coche", "checked", "y", "o"}
+_FALSE_WORDS = {"non", "no", "false", "faux", "0", "off", "n", "decoche", "unchecked"}
+
+
+def normalize_bool(value: str) -> str:
+    """« oui », « non », ou "" si la réponse ne tranche pas."""
+    folded = fold(value).rstrip(".!")
+    if folded in _TRUE_WORDS or re.match(r"oui\b", folded):
+        return "oui"
+    if folded in _FALSE_WORDS or re.match(r"non\b", folded):
+        return "non"
+    return ""
+
+
+def normalize_sex(value: str) -> str:
+    folded = fold(value).rstrip(".")
+    if folded in {"f", "feminin", "femme", "female", "madame", "mme", "mlle", "fille"} \
+            or folded.startswith(("femin", "femme", "madame")):
+        return "F"
+    if folded in {"m", "masculin", "homme", "male", "h", "monsieur", "mr", "garcon"} \
+            or folded.startswith(("mascul", "homme", "monsieur")):
+        return "M"
+    return value
+
+
+def normalize_value(raw: Any, field: dict | None) -> str:
+    """
+    Valeur prête à être écrite, selon le type déclaré dans le template.
+
+    Une réponse qui équivaut à « rien trouvé » devient "" : le champ reste vide,
+    ce qui est le seul état honnête.
+    """
+    value = coerce_text(raw).strip()
+    if not value:
+        return ""
+    field = field or {}
+    kind = field.get("type")
+    options = field.get("options") or []
+
+    # Une option peut ressembler à une non-réponse (« Inconnue ») : la vérifier d'abord.
+    if kind == "choice" and any(fold(o) == fold(value) for o in options):
+        return next(o for o in options if fold(o) == fold(value))
+    if is_null_like(value):
+        return ""
+
+    if kind == "bool":
+        return normalize_bool(value)
+    if kind == "sex":
+        return normalize_sex(value)
+    if kind == "date":
+        return normalize_date(value)
+    if kind == "percent":
+        match = re.search(r"\d+(?:[.,]\d+)?", value.replace("%", ""))
+        return match.group(0).replace(",", ".") if match else value
+    if kind == "int":
+        match = re.search(r"\d+", value)
+        return match.group(0) if match else value
+    return value
+
+
+def resolve_option(value: str, field: dict) -> str:
+    """
+    Traduit le libellé choisi par le modèle en valeur d'export du formulaire.
+
+    Les groupes de boutons radio medForms exportent un index (« 0 », « 1 », …)
+    et non le libellé affiché ; `option_values` porte la correspondance. On
+    accepte aussi la valeur d'export elle-même et un libellé abrégé
+    (« oui » pour « oui (= Major RF) ») s'il ne désigne qu'une option.
+
+    Un libellé inconnu est laissé tel quel : le remplissage laissera alors le
+    groupe vide plutôt que de cocher au hasard.
+    """
+    options = field.get("options") or []
+    values = field.get("option_values") or []
+    if not options:
+        return value
+    exported = values if len(values) == len(options) else options
+    target = fold(value)
+
+    for label, export in zip(options, exported):
+        if fold(label) == target:
+            return export
+    if values:
+        for export in values:
+            if fold(export) == target:
+                return export
+    prefixed = [export for label, export in zip(options, exported)
+                if re.match(rf"{re.escape(target)}(?:\W|$)", fold(label))]
+    if target and len(prefixed) == 1:
+        return prefixed[0]
+    return value
+
+
+def bool_item(value: str, field: dict, truthy: bool) -> str:
+    """
+    Valeur XFA d'une case à cocher : l'état déclaré par le formulaire.
+
+    Les cases medForms n'utilisent pas toutes le même couple : « On/Off » pour
+    certaines, « 1/0 » pour d'autres. `options` porte, dans l'ordre, les états
+    coché puis décoché lus dans le XFA.
+    """
+    options = field.get("options") or []
+    if len(options) >= 2:
+        return options[0] if truthy else options[1]
+    return "1" if truthy else "0"
+
+
+# ---------------------------------------------------------------------------
+# Du résultat d'extraction aux valeurs du formulaire
+# ---------------------------------------------------------------------------
+
+def computed_values(template: dict) -> list[tuple[dict, str]]:
+    """
+    Champs dont la valeur se déduit du formulaire lui-même.
+
+    Le bloc adresse du destinataire en est le seul cas aujourd'hui : il est la
+    version visible de champs structurés déjà renseignés par l'éditeur, mais
+    masqués dans la mise en page. Le demander au modèle produisait des adresses
+    inventées — un numéro de rue emprunté au patient, un code postal fabriqué.
+    """
+    return [(f, f["computed"]) for f in template.get("fields", []) if f.get("computed")]
+
+
+# Structure que la table cantonale alimente : le bloc de l'office destinataire.
+_RECIPIENT_STRUCTS = {"insuranceS1Address", "recipientS1Address"}
+
+
+def is_recipient_field(field: dict) -> bool:
+    """
+    Le champ appartient-il au destinataire du formulaire ?
+
+    La table cantonale nomme ses champs sans leur structure (`street`, `zip`,
+    `ean`, `input`), et ces noms reviennent dans les blocs patient, médecin ou
+    traitement. Appliquée par nom seul, elle remplaçait l'adresse du patient par
+    celle de l'office AI, le GLN du médecin par celui de l'office, et les
+    remarques libres par une chaîne technique « exaddress#@#… ».
+    """
+    if str(field.get("name") or "").startswith("recipient"):
+        return True
+    parts = _segments(field.get("xml_path"))
+    return len(parts) >= 2 and _INDEX.sub("", parts[-2]) in _RECIPIENT_STRUCTS
+
+
+def canton_recipient(template: dict, results: list[dict]) -> dict[str, str]:
+    """
+    Destinataire correspondant au canton de traitement extrait.
+
+    Un formulaire AI s'adresse à l'office AI *du canton du patient*. Le gabarit
+    porte cette table et l'applique par script — mais le script ne s'exécute
+    que dans un lecteur XFA, jamais dans le PDF qu'on livre. Sans ça, un dossier
+    neuchâtelois partait à l'office de Berne, l'adresse par défaut du vierge.
+
+    Canton absent ou inconnu : on ne renvoie rien et le formulaire garde ses
+    valeurs d'origine — mieux vaut le défaut du gabarit qu'un office arbitraire.
+
+    Returns:
+        nom de champ → valeur, à écrire tel quel.
+    """
+    table = template.get("_recipient_by_canton")
+    if not table:
+        return {}
+    canton_ids = {str(f["id"]) for f in template.get("fields", [])
+                  if f.get("name") == "treatmentCanton"}
+    for res in results:
+        if str(res.get("id")) not in canton_ids:
+            continue
+        valeur = str((res.get("result") or {}).get("value") or "").strip().upper()
+        if valeur in table:
+            logger.info("Destinataire dérivé du canton %s", valeur)
+            return table[valeur]
+        if valeur:
+            logger.warning("Canton %r hors de la table du formulaire", valeur)
+    return {}
+
+
+def collect_form_values(template: dict, results: list[dict]) -> tuple[dict[str, str], dict[str, str]]:
+    """
+    Valeurs à écrire dans le PDF, par chemin XFA et par nom AcroForm.
+
+    Réunit, dans cet ordre de priorité croissante : les valeurs extraites, les
+    champs calculés, puis le destinataire dérivé du canton. Partagé par le
+    pipeline et le re-run, qui l'avaient chacun recopié — et le re-run avait
+    perdu en route les deux dernières étapes.
+    """
+    by_id = {str(f["id"]): f for f in template.get("fields", []) if "id" in f}
+    xfa_values: dict[str, str] = {}
+    acro_values: dict[str, str] = {}
+
+    def _put(f_def: dict, xfa_value: str, acro_value: str) -> None:
+        if f_def.get("xml_path"):
+            xfa_values[f_def["xml_path"]] = xfa_value
+        if f_def.get("acroform_name"):
+            acro_values[f_def["acroform_name"]] = acro_value
+
+    for res in results:
+        payload = res.get("result")
+        if not isinstance(payload, dict):
+            continue
+        f_def = by_id.get(str(res.get("id")))
+        if f_def is None:
+            continue
+        value = normalize_value(payload.get("value"), f_def)
+        if not value:
+            continue
+        kind = f_def.get("type")
+        if kind == "bool":
+            truthy = value == "oui"
+            _put(f_def, bool_item(value, f_def, truthy), "1" if truthy else "0")
+        elif kind == "choice":
+            exported = resolve_option(value, f_def)
+            _put(f_def, exported, exported)
+        else:
+            _put(f_def, value, value)
+
+    for f_def, value in computed_values(template):
+        _put(f_def, value, value)
+
+    # Le destinataire dépend du canton : il écrase aussi bien les valeurs par
+    # défaut du gabarit que ce que le modèle aurait pu produire.
+    for nom, value in canton_recipient(template, results).items():
+        for f_def in template.get("fields", []):
+            if f_def.get("name") == nom and is_recipient_field(f_def):
+                _put(f_def, value, value)
+
+    return xfa_values, acro_values
diff --git a/services/orchestrator/core/fill.py b/services/orchestrator/core/fill.py
index 60cd086..c1d545f 100644
--- a/services/orchestrator/core/fill.py
+++ b/services/orchestrator/core/fill.py
@@ -78,7 +78,19 @@ def _normalize_value(value: Any, kind: str) -> str:
         return ""
 
     if kind == "bool":
-        return "1" if value in {"1", "true", "True", True} else "0"
+        # La valeur arrive déjà sous la forme d'un état de la case (« 1 »/« 0 »,
+        # « On »/« Off », selon ce que déclare le formulaire) : on la garde.
+        # L'ancienne règle ramenait à « 0 » tout ce qui n'était pas « 1 » ou
+        # « true » — « oui », « On » compris : la case restait décochée côté XFA
+        # quand elle était cochée côté AcroForm.
+        if isinstance(value, bool):
+            return "1" if value else "0"
+        text = str(value).strip()
+        if text.casefold() in {"true", "yes", "oui", "vrai"}:
+            return "1"
+        if text.casefold() in {"false", "no", "non", "faux"}:
+            return "0"
+        return text
 
     if kind == "int":
         try:
diff --git a/services/orchestrator/core/provenance.py b/services/orchestrator/core/provenance.py
index d257766..93d08f7 100644
--- a/services/orchestrator/core/provenance.py
+++ b/services/orchestrator/core/provenance.py
@@ -303,13 +303,20 @@ def _locate_quote(quote: str, index: SourceIndex) -> tuple[dict | None, bool]:
     return None, False
 
 
-def ground_value(value: str, quote: str, index: SourceIndex) -> dict[str, Any]:
+def ground_value(value: str, quote: str, index: SourceIndex,
+                 literal: bool = True) -> dict[str, Any]:
     """
     Rattache une valeur extraite à son texte source.
 
     Trois questions, dans cet ordre : la citation existe-t-elle vraiment ? la
     valeur y figure-t-elle ? sinon, figure-t-elle ailleurs dans les documents ?
 
+    Args:
+        literal: False pour une réponse choisie plutôt que recopiée — « oui »,
+            « non », une option de liste, un sigle de canton. La retrouver dans
+            le texte ne prouve rien (« ne » figure dans toute phrase négative) :
+            seule la citation qui la justifie compte.
+
     Returns:
         {grounding, quote_verified, source_document, source_page, source_excerpt}
     """
@@ -331,6 +338,11 @@ def _grade(strong: str, hit: dict) -> str:
         """Un ancrage dans un texte dérivé ne vaut jamais mieux que « à relire »."""
         return INFERRED if hit.get("derived") else strong
 
+    if not literal:
+        result["grounding"] = INFERRED if quote_hit is not None else UNVERIFIED
+        _locate(quote_hit)
+        return result
+
     # Une valeur d'un seul caractère se retrouve partout par accident : on ne peut
     # ni l'attester ni la démentir, et le prétendre serait pire que se taire.
     if len(normalize(value)) < MIN_VALUE_CHARS:
diff --git a/services/orchestrator/extraction.py b/services/orchestrator/extraction.py
new file mode 100644
index 0000000..40b6222
--- /dev/null
+++ b/services/orchestrator/extraction.py
@@ -0,0 +1,421 @@
+"""
+extraction.py — Découpage des documents, contexte du prompt et appel LLM d'extraction.
+
+Trois causes de champs vides ou en erreur y sont traitées :
+
+- **Contexte hors budget.** Les extraits étaient comptés, pas mesurés : 24
+  extraits de 800 mots dépassent la fenêtre de 32k tokens de vLLM, qui répond
+  400 — et les 7 champs du lot échouaient après trois tentatives identiques.
+  Le contexte est désormais construit contre un budget en tokens.
+- **Extraits mal répartis.** Les extraits d'un lot étaient concaténés champ par
+  champ puis tronqués : les derniers champs du lot n'avaient souvent plus aucun
+  extrait. Ils sont maintenant entrelacés par rang.
+- **Réponses incomplètes.** Un JSON tronqué, un ID oublié ou une valeur rendue
+  en chaîne plutôt qu'en objet perdaient le champ. La réponse est contrainte
+  par un schéma JSON, lue avec tolérance, et un lot qui échoue est scindé puis
+  rejoué plutôt qu'abandonné.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import re
+from typing import Any, Callable, Dict, List
+
+import httpx
+
+from core.fields import coerce_text
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Budget de tokens
+# ---------------------------------------------------------------------------
+
+# À garder aligné sur --max-model-len de vLLM (docker-compose).
+LLM_MAX_MODEL_LEN = int(os.getenv("LLM_MAX_MODEL_LEN", "32768"))
+# Plafond de génération d'un lot. Un lot de 28 champs (quatre périodes
+# d'incapacité) produit ~2 000 tokens de JSON ; 2048 tronquait les gros lots.
+MAX_TOKENS_EXTRACT = int(os.getenv("MAX_TOKENS_EXTRACT", "4096"))
+# Marge pour l'écart entre l'estimation et le tokenizer réel.
+PROMPT_SAFETY_TOKENS = 1024
+# Dossier transmis en entier au modèle s'il tient sous ce seuil : plus aucune
+# information ne dépend de la qualité du retrieval, et le préfixe commun à tous
+# les lots n'est calculé qu'une fois par vLLM.
+FULL_CONTEXT_MAX_TOKENS = int(os.getenv("FULL_CONTEXT_MAX_TOKENS", "16000"))
+# Au-delà : extraits sélectionnés par le retrieval, dans ce budget par lot.
+RAG_CONTEXT_TOKENS = int(os.getenv("RAG_CONTEXT_TOKENS", "9000"))
+# Délai d'un appel d'extraction. Sous charge (24 requêtes en vol sur le GB10),
+# 180 s ne suffisaient pas : le délai expirait, la requête était rejouée, et la
+# charge augmentait d'autant.
+LLM_TIMEOUT = float(os.getenv("LLM_TIMEOUT", "600"))
+MAX_LLM_RETRIES = int(os.getenv("MAX_LLM_RETRIES", "3"))
+
+
+def estimate_tokens(text: str) -> int:
+    """
+    Estimation prudente du nombre de tokens.
+
+    Le français médical (accents, nombres, codes) tourne autour de 3,5
+    caractères par token avec le tokenizer Qwen ; on compte 3 pour ne jamais
+    sous-estimer — c'est la sous-estimation qui provoque les erreurs 400.
+    """
+    return len(text) // 3 + 1
+
+
+# ---------------------------------------------------------------------------
+# Découpage des documents
+# ---------------------------------------------------------------------------
+
+_HEADING = re.compile(r"^(#{1,3})\s+(.+?)\s*$", re.MULTILINE)
+_PAGE_TITLE = re.compile(r"^page\s+(\d+)$", re.IGNORECASE)
+
+CHUNK_MAX_WORDS = int(os.getenv("CHUNK_MAX_WORDS", "300"))
+CHUNK_OVERLAP_WORDS = int(os.getenv("CHUNK_OVERLAP_WORDS", "50"))
+CHUNK_MIN_WORDS = int(os.getenv("CHUNK_MIN_WORDS", "40"))
+
+
+def chunk_document(filename: str, markdown: str, max_words: int = CHUNK_MAX_WORDS,
+                   overlap: int = CHUNK_OVERLAP_WORDS, min_words: int = CHUNK_MIN_WORDS) -> List[str]:
+    """
+    Découpe un document en extraits autonomes.
+
+    Chaque extrait porte en tête sa source — document, page, section. Seul le
+    premier extrait d'un document la portait : les suivants arrivaient au
+    modèle sans qu'il sache de quel rapport, ni de quelle date, ils venaient.
+    Un « Téléphone : 021 … » isolé ne dit pas s'il s'agit du patient ou du
+    médecin ; « [Source : 01_fiche.pdf — Médecin traitant] » le dit.
+
+    Les sections trop courtes sont fusionnées avec la suivante (un titre seul
+    n'est qu'un embedding parasite), les trop longues découpées avec
+    chevauchement, à une taille que le reranker évalue sans la tronquer.
+    """
+    sections: List[tuple[int | None, str, str]] = []  # (page, titre, texte)
+    page: int | None = None
+    positions = [(m.start(), m.group(2).strip()) for m in _HEADING.finditer(markdown)]
+    if not positions or positions[0][0] > 0:
+        positions.insert(0, (0, ""))
+    for index, (start, title) in enumerate(positions):
+        end = positions[index + 1][0] if index + 1 < len(positions) else len(markdown)
+        body = markdown[start:end].strip()
+        page_match = _PAGE_TITLE.match(title)
+        if page_match:
+            # « ## Page 3 » passe dans l'en-tête de l'extrait, pas dans son texte.
+            page = int(page_match.group(1))
+            title = ""
+            body = body.split("\n", 1)[1].strip() if "\n" in body else ""
+        if body:
+            sections.append((page, title, body))
+
+    # Fusion des sections trop courtes avec la suivante, sur la même page.
+    merged: List[tuple[int | None, str, str]] = []
+    for sec in sections:
+        if merged:
+            prev_page, prev_title, prev_body = merged[-1]
+            if len(prev_body.split()) < min_words and prev_page == sec[0]:
+                merged[-1] = (prev_page, prev_title or sec[1], prev_body + "\n\n" + sec[2])
+                continue
+        merged.append(sec)
+
+    chunks: List[str] = []
+    step = max(1, max_words - overlap)
+    for sec_page, title, body in merged:
+        label = filename
+        if sec_page is not None:
+            label += f" — page {sec_page}"
+        if title:
+            label += f" — {title}"
+        header = f"[Source : {label}]"
+        words = body.split()
+        if len(words) <= max_words:
+            chunks.append(f"{header}\n{body}")
+            continue
+        for i in range(0, len(words), step):
+            part = words[i:i + max_words]
+            chunks.append(f"{header}\n{' '.join(part)}")
+            if i + max_words >= len(words):
+                break
+    return chunks
+
+
+def full_documents_text(documents: List[Dict[str, str]]) -> str:
+    """Texte intégral du dossier, un bloc par document, dans un ordre stable."""
+    blocks = []
+    for doc in sorted(documents, key=lambda d: d.get("filename", "")):
+        text = (doc.get("markdown") or "").strip()
+        if text:
+            blocks.append(f"=== DOCUMENT : {doc.get('filename', 'document')} ===\n{text}")
+    return "\n\n".join(blocks)
+
+
+def build_rag_context(fields: List[Dict], field_chunks: Dict[str, List[str]],
+                      budget_tokens: int) -> str:
+    """
+    Extraits d'un lot, entrelacés par rang et bornés par un budget en tokens.
+
+    Le meilleur extrait de chaque champ passe avant le second de quiconque :
+    aucun champ du lot ne se retrouve sans source parce que ses voisins ont
+    consommé le budget.
+    """
+    lists = [field_chunks.get(str(f["id"]), []) for f in fields]
+    seen: set = set()
+    selected: List[str] = []
+    used = 0
+    depth = max((len(lst) for lst in lists), default=0)
+    for rank in range(depth):
+        for lst in lists:
+            if rank >= len(lst) or lst[rank] in seen:
+                continue
+            cost = estimate_tokens(lst[rank])
+            if used + cost > budget_tokens:
+                continue
+            seen.add(lst[rank])
+            selected.append(lst[rank])
+            used += cost
+    return "\n\n---\n\n".join(selected)
+
+
+# ---------------------------------------------------------------------------
+# Appel LLM
+# ---------------------------------------------------------------------------
+
+class ContextOverflow(Exception):
+    """Le prompt dépasse la fenêtre du modèle : rejouer tel quel est inutile."""
+
+
+class TruncatedResponse(Exception):
+    """La génération a atteint max_tokens : le JSON est incomplet."""
+
+
+class SchemaUnsupported(Exception):
+    """Le serveur refuse `response_format: json_schema`."""
+
+
+# Le schéma JSON contraint la génération (vLLM, décodage guidé) : plus d'ID
+# oublié ni de clé déformée. Désactivé au premier refus du serveur.
+_schema_supported = os.getenv("LLM_JSON_SCHEMA", "true").lower() == "true"
+
+
+def response_schema(fields: List[Dict]) -> Dict[str, Any]:
+    """Schéma de la réponse attendue : un objet par ID, valeur et citation."""
+    properties = {}
+    for f in fields:
+        value: Dict[str, Any] = {"type": "string"}
+        options = f.get("options")
+        if f.get("type") == "choice" and options:
+            # "" reste permis : l'absence d'information prime sur l'obligation de choisir.
+            value = {"type": "string", "enum": list(dict.fromkeys(list(options) + [""]))}
+        properties[str(f["id"])] = {
+            "type": "object",
+            "properties": {"value": value, "source_quote": {"type": "string"}},
+            "required": ["value", "source_quote"],
+            "additionalProperties": False,
+        }
+    return {
+        "type": "object",
+        "properties": properties,
+        "required": list(properties),
+        "additionalProperties": False,
+    }
+
+
+def _load_json_object(content: str) -> Dict[str, Any]:
+    try:
+        data = json.loads(content)
+    except json.JSONDecodeError:
+        start, end = content.find("{"), content.rfind("}")
+        if start == -1 or end <= start:
+            raise
+        data = json.loads(content[start:end + 1])
+    if not isinstance(data, dict):
+        raise json.JSONDecodeError("réponse JSON non objet", content, 0)
+    return data
+
+
+def _clean_key(key: Any) -> str:
+    return str(key).strip().strip("[]•").strip()
+
+
+def parse_response(content: str, fields: List[Dict]) -> Dict[str, Dict[str, str]]:
+    """
+    Lit la réponse du modèle, avec tolérance.
+
+    Accepte les écarts courants hors décodage guidé : ID entre crochets, valeur
+    rendue en chaîne ou en liste plutôt qu'en objet, réponse enveloppée dans
+    une clé unique (« champs », « fields »).
+
+    Returns:
+        ID → {"value", "source_quote"}, pour les seuls IDs trouvés.
+    """
+    data = _load_json_object(content)
+    wanted = {str(f["id"]) for f in fields}
+    entries = {_clean_key(k): v for k, v in data.items()}
+    if not wanted & set(entries) and len(entries) == 1:
+        inner = next(iter(entries.values()))
+        if isinstance(inner, dict):
+            entries = {_clean_key(k): v for k, v in inner.items()}
+
+    parsed: Dict[str, Dict[str, str]] = {}
+    for fid in wanted:
+        if fid not in entries:
+            continue
+        raw = entries[fid]
+        if isinstance(raw, dict):
+            value = raw.get("value", raw.get("valeur", ""))
+            quote = raw.get("source_quote", raw.get("citation", ""))
+        else:
+            value, quote = raw, ""
+        parsed[fid] = {"value": coerce_text(value).strip(), "source_quote": coerce_text(quote).strip()}
+    return parsed
+
+
+async def _post_chat(client: httpx.AsyncClient, url: str, payload: Dict[str, Any],
+                     llm_sem: asyncio.Semaphore) -> str:
+    """Un appel chat/completions, erreurs classées. Retourne le contenu du message."""
+    async with llm_sem:
+        resp = await client.post(f"{url}/chat/completions", json=payload,
+                                 timeout=httpx.Timeout(LLM_TIMEOUT, connect=15.0))
+    if resp.status_code == 400:
+        detail = resp.text.lower()
+        # Libellés selon les versions de vLLM : « maximum context length is… »,
+        # « …is longer than the maximum model length of… ».
+        if any(k in detail for k in ("context length", "maximum context", "too long",
+                                     "maximum model length", "longer than the maximum")):
+            raise ContextOverflow(resp.text[:300])
+        if "response_format" in payload and payload["response_format"].get("type") == "json_schema" \
+                and any(k in detail for k in ("json_schema", "response_format", "guided", "schema")):
+            raise SchemaUnsupported(resp.text[:300])
+    resp.raise_for_status()
+    choice = resp.json()["choices"][0]
+    if choice.get("finish_reason") == "length":
+        raise TruncatedResponse(f"{len(choice['message'].get('content') or '')} caractères générés")
+    return choice["message"]["content"] or ""
+
+
+_TRANSIENT = (httpx.TimeoutException, httpx.NetworkError, httpx.RemoteProtocolError)
+
+
+async def call_extraction(client: httpx.AsyncClient, url: str, model: str,
+                          messages: List[Dict], fields: List[Dict],
+                          llm_sem: asyncio.Semaphore) -> Dict[str, Dict[str, str]]:
+    """
+    Appel d'extraction avec reprises sur les seules erreurs transitoires.
+
+    Réseau, délai, 5xx, 429 : on rejoue. Une erreur 4xx, un prompt trop long ou
+    une réponse tronquée se reproduiraient à l'identique : on les remonte tout
+    de suite à l'appelant, qui scinde le lot.
+    """
+    global _schema_supported
+    for attempt in range(1, MAX_LLM_RETRIES + 1):
+        payload: Dict[str, Any] = {
+            "model": model,
+            "messages": messages,
+            "temperature": 0.0,
+            "max_tokens": MAX_TOKENS_EXTRACT,
+        }
+        if _schema_supported:
+            payload["response_format"] = {
+                "type": "json_schema",
+                "json_schema": {"name": "extraction", "schema": response_schema(fields)},
+            }
+        else:
+            payload["response_format"] = {"type": "json_object"}
+        try:
+            content = await _post_chat(client, url, payload, llm_sem)
+            return parse_response(content, fields)
+        except SchemaUnsupported as exc:
+            logger.warning("json_schema refusé par le serveur, repli sur json_object : %s", exc)
+            _schema_supported = False
+            # Rejoué sans consommer de tentative : le refus ne dit rien de la requête.
+            return await call_extraction(client, url, model, messages, fields, llm_sem)
+        except (ContextOverflow, TruncatedResponse):
+            raise
+        except httpx.HTTPStatusError as exc:
+            status = exc.response.status_code
+            if status < 500 and status != 429:
+                raise
+            error: Exception = exc
+        except (json.JSONDecodeError, *_TRANSIENT) as exc:
+            error = exc
+        if attempt == MAX_LLM_RETRIES:
+            raise error
+        logger.warning("LLM retry %d/%d (%s) : %s: %s", attempt, MAX_LLM_RETRIES,
+                       [f["id"] for f in fields], type(error).__name__, error)
+        await asyncio.sleep(2 * attempt)
+    raise RuntimeError("appel d'extraction sans réponse")
+
+
+PromptBuilder = Callable[[List[Dict], float], List[Dict]]
+
+
+async def extract_batch(client: httpx.AsyncClient, url: str, model: str,
+                        fields: List[Dict], build_messages: PromptBuilder,
+                        llm_sem: asyncio.Semaphore, _depth: int = 0, _shrink: int = 0) -> List[Dict]:
+    """
+    Extrait un lot de champs, sans jamais perdre tout le lot sur une erreur.
+
+    - prompt trop long : rejoué avec un contexte réduit de moitié, trois fois au plus ;
+    - réponse tronquée : le lot est scindé en deux, chaque moitié rejouée ;
+    - IDs absents de la réponse : redemandés une fois, dans un lot à eux ;
+    - autre échec : le lot est scindé une fois avant d'abandonner.
+
+    Args:
+        build_messages: (champs, échelle du contexte) → messages. L'échelle
+            vaut 1 puis 0.5, 0.25… à chaque dépassement de la fenêtre.
+
+    Returns:
+        [{"id", "result": {"value", "source_quote"}}] ou [{"id", "error"}].
+    """
+    ids = [f["id"] for f in fields]
+
+    async def _split(depth: int) -> List[Dict]:
+        half = len(fields) // 2
+        parts = await asyncio.gather(
+            extract_batch(client, url, model, fields[:half], build_messages, llm_sem, depth, _shrink),
+            extract_batch(client, url, model, fields[half:], build_messages, llm_sem, depth, _shrink),
+        )
+        return parts[0] + parts[1]
+
+    try:
+        data = await call_extraction(client, url, model, build_messages(fields, 0.5 ** _shrink),
+                                     fields, llm_sem)
+    except ContextOverflow as exc:
+        if _shrink >= 3:
+            logger.error("Extraction abandonnée, contexte irréductible (%s) : %s", ids, exc)
+            return [{"id": f["id"], "error": "extraction_failed"} for f in fields]
+        logger.warning("Lot %s : fenêtre dépassée, contexte réduit", ids)
+        return await extract_batch(client, url, model, fields, build_messages, llm_sem,
+                                   _depth, _shrink + 1)
+    except TruncatedResponse as exc:
+        if len(fields) == 1 or _depth >= 5:
+            logger.error("Extraction abandonnée, réponse tronquée (%s) : %s", ids, exc)
+            return [{"id": f["id"], "error": "extraction_failed"} for f in fields]
+        logger.warning("Lot %s : réponse tronquée, lot scindé", ids)
+        return await _split(_depth + 1)
+    except Exception as exc:
+        logger.error("Erreur batch vLLM (%s) : %s: %s", ids, type(exc).__name__, exc)
+        if len(fields) > 1 and _depth == 0:
+            return await _split(1)
+        return [{"id": f["id"], "error": "extraction_failed"} for f in fields]
+
+    missing = [f for f in fields if str(f["id"]) not in data]
+    if missing and _depth == 0:
+        # Une fois, y compris quand la réponse ne contient aucun ID ({} valide) :
+        # le modèle s'est écarté de la consigne, pas forcément du dossier.
+        logger.info("IDs absents de la réponse, redemandés : %s", [f["id"] for f in missing])
+        retry = await extract_batch(client, url, model, missing, build_messages, llm_sem, 1, _shrink)
+        for r in retry:
+            if "result" in r:
+                data[str(r["id"])] = r["result"]
+
+    results = []
+    for f in fields:
+        entry = data.get(str(f["id"]))
+        if entry is None:
+            results.append({"id": f["id"], "error": "field_missing_in_response"})
+        else:
+            results.append({"id": f["id"], "result": dict(entry)})
+    return results
diff --git a/services/orchestrator/medical_synthesis.py b/services/orchestrator/medical_synthesis.py
index a20460c..68718a8 100644
--- a/services/orchestrator/medical_synthesis.py
+++ b/services/orchestrator/medical_synthesis.py
@@ -6,12 +6,18 @@
 - Hiérarchique : trop de texte → résumé par document puis fusion
 
 Le résultat est un dict Python (issu du JSON LLM) contenant diagnostics, incapacités, etc.
-En cas d'échec, retourne None pour que le pipeline continue avec le RAG pur.
+En cas d'échec, retourne None pour que le pipeline continue sur les seuls documents.
+
+Chaque étape a désormais un repli plutôt qu'un point de rupture : la stratégie
+directe qui échoue (fenêtre dépassée, JSON tronqué) passe la main à la
+hiérarchique, un document trop long pour un résumé est découpé, et une fusion
+impossible est remplacée par une fusion déterministe des résumés.
 """
 
+import asyncio
 import json
 import logging
-import re
+import os
 import time
 from typing import Any
 
@@ -28,12 +34,29 @@
 
 logger = logging.getLogger(__name__)
 
-# Seuil en tokens estimés au-delà duquel on passe en mode hiérarchique.
-# 28k laisse ~4k tokens pour le prompt système et la réponse JSON dans une fenêtre de 32k.
-MAX_DIRECT_TOKENS = 28_000
+# À garder aligné sur --max-model-len de vLLM (docker-compose).
+LLM_MAX_MODEL_LEN = int(os.getenv("LLM_MAX_MODEL_LEN", "32768"))
+
+# Génération réservée à la synthèse. Elle n'avait pas de plafond explicite :
+# vLLM lui laissait ce que le prompt n'occupait pas, soit parfois moins de 4k
+# tokens pour un JSON exhaustif — tronqué, donc illisible, donc perdu.
+SYNTHESIS_MAX_TOKENS = int(os.getenv("SYNTHESIS_MAX_TOKENS", "6144"))
+SUMMARY_MAX_TOKENS = int(os.getenv("SUMMARY_MAX_TOKENS", "3072"))
+
+# Seuil en tokens estimés au-delà duquel on passe en mode hiérarchique :
+# fenêtre − génération − consignes et squelette JSON du prompt.
+MAX_DIRECT_TOKENS = LLM_MAX_MODEL_LEN - SYNTHESIS_MAX_TOKENS - 2500
+# Taille maximale d'un morceau de document soumis à un résumé.
+MAX_DOC_TOKENS = LLM_MAX_MODEL_LEN - SUMMARY_MAX_TOKENS - 2000
+
+# Timeout LLM pour la synthèse. À ~20 tokens/s sur le GB10, 6k tokens de JSON
+# prennent 5 minutes : les 180 s d'origine faisaient échouer les gros dossiers.
+SYNTHESIS_TIMEOUT = float(os.getenv("SYNTHESIS_TIMEOUT", "900"))
+MAX_SYNTHESIS_RETRIES = 2
 
-# Timeout LLM pour la synthèse (plus long qu'une extraction de champ classique)
-SYNTHESIS_TIMEOUT = 180  # secondes
+
+class _Unrecoverable(Exception):
+    """Erreur qu'un nouvel essai à l'identique reproduirait (fenêtre, troncature)."""
 
 
 # ---------------------------------------------------------------------------
@@ -42,8 +65,14 @@
 
 
 def estimate_tokens(text: str) -> int:
-    """Estimation rapide : ~4 caractères = 1 token (heuristique valable pour FR/EN)."""
-    return len(text) // 4
+    """
+    Estimation prudente : ~3 caractères par token.
+
+    L'ancienne heuristique (4 caractères) sous-estimait le français médical —
+    accents, dates, codes — et laissait passer en mode direct des dossiers
+    qui dépassaient la fenêtre du modèle.
+    """
+    return len(text) // 3 + 1
 
 
 def _extract_json_from_response(text: str) -> dict[str, Any]:
@@ -57,7 +86,10 @@ def _extract_json_from_response(text: str) -> dict[str, Any]:
     if start == -1 or end == -1 or end <= start:
         raise ValueError(f"Aucun JSON trouvé dans la réponse : {text[:200]}")
     json_str = text[start : end + 1]
-    return json.loads(json_str)
+    data = json.loads(json_str)
+    if not isinstance(data, dict):
+        raise ValueError("La synthèse n'est pas un objet JSON")
+    return data
 
 
 async def _call_llm(
@@ -65,9 +97,16 @@ async def _call_llm(
     user_prompt: str,
     vllm_url: str,
     model_name: str,
-    timeout: int = SYNTHESIS_TIMEOUT,
+    max_tokens: int = SYNTHESIS_MAX_TOKENS,
+    timeout: float = SYNTHESIS_TIMEOUT,
 ) -> str:
-    """Appel vLLM et retourne le contenu texte de la réponse."""
+    """
+    Appel vLLM et retourne le contenu texte de la réponse.
+
+    Rejoue une fois les erreurs transitoires. Une fenêtre dépassée ou une
+    réponse tronquée sont remontées sans nouvel essai : l'appelant change de
+    stratégie.
+    """
     payload = {
         "model": model_name,
         "messages": [
@@ -75,13 +114,28 @@ async def _call_llm(
             {"role": "user", "content": user_prompt},
         ],
         "temperature": 0.05,
+        "max_tokens": max_tokens,
         "response_format": {"type": "json_object"},
     }
-    async with httpx.AsyncClient(timeout=timeout) as client:
-        resp = await client.post(f"{vllm_url}/chat/completions", json=payload)
-        resp.raise_for_status()
-        data = resp.json()
-    return data["choices"][0]["message"]["content"]
+    for attempt in range(1, MAX_SYNTHESIS_RETRIES + 1):
+        try:
+            async with httpx.AsyncClient(timeout=httpx.Timeout(timeout, connect=15.0)) as client:
+                resp = await client.post(f"{vllm_url}/chat/completions", json=payload)
+            if resp.status_code == 400:
+                raise _Unrecoverable(f"requête refusée : {resp.text[:200]}")
+            resp.raise_for_status()
+            choice = resp.json()["choices"][0]
+            if choice.get("finish_reason") == "length":
+                raise _Unrecoverable("réponse tronquée (max_tokens atteint)")
+            return choice["message"]["content"] or ""
+        except _Unrecoverable:
+            raise
+        except (httpx.HTTPError, KeyError, ValueError) as exc:
+            if attempt == MAX_SYNTHESIS_RETRIES:
+                raise
+            logger.warning("Synthèse : nouvel essai après %s: %s", type(exc).__name__, exc)
+            await asyncio.sleep(3)
+    raise RuntimeError("synthèse sans réponse")
 
 
 # ---------------------------------------------------------------------------
@@ -96,12 +150,7 @@ async def _synthesize_direct(
 ) -> dict[str, Any]:
     """Synthèse en un seul appel LLM. Utilisée quand le texte tient dans la fenêtre."""
     user_prompt = build_synthesis_prompt(all_docs_text)
-    raw = await _call_llm(
-        SYSTEM_PROMPT_SYNTHESIS,
-        user_prompt,
-        vllm_url,
-        model_name,
-    )
+    raw = await _call_llm(SYSTEM_PROMPT_SYNTHESIS, user_prompt, vllm_url, model_name)
     return _extract_json_from_response(raw)
 
 
@@ -110,6 +159,33 @@ async def _synthesize_direct(
 # ---------------------------------------------------------------------------
 
 
+def _split_document(name: str, text: str, max_tokens: int = MAX_DOC_TOKENS) -> list[tuple[str, str]]:
+    """
+    Découpe un document trop long pour un seul résumé.
+
+    Coupe sur les sauts de paragraphe les plus proches de la limite, pour ne
+    pas scinder une ligne de diagnostic en deux.
+    """
+    if estimate_tokens(text) <= max_tokens:
+        return [(name, text)]
+    max_chars = max_tokens * 3
+    parts: list[str] = []
+    rest = text
+    while rest:
+        if len(rest) <= max_chars:
+            parts.append(rest)
+            break
+        cut = rest.rfind("\n\n", 0, max_chars)
+        if cut < max_chars // 2:
+            cut = rest.rfind("\n", 0, max_chars)
+        if cut < max_chars // 2:
+            cut = max_chars
+        parts.append(rest[:cut])
+        rest = rest[cut:].lstrip()
+    total = len(parts)
+    return [(f"{name} (partie {i}/{total})", part) for i, part in enumerate(parts, start=1)]
+
+
 async def _summarize_single_doc(
     doc_text: str,
     doc_name: str,
@@ -118,13 +194,8 @@ async def _summarize_single_doc(
 ) -> dict[str, Any]:
     """Résumé d'un seul document médical."""
     user_prompt = build_per_doc_summary_prompt(doc_text, doc_name)
-    raw = await _call_llm(
-        SYSTEM_PROMPT_PER_DOC_SUMMARY,
-        user_prompt,
-        vllm_url,
-        model_name,
-        timeout=120,
-    )
+    raw = await _call_llm(SYSTEM_PROMPT_PER_DOC_SUMMARY, user_prompt, vllm_url, model_name,
+                          max_tokens=SUMMARY_MAX_TOKENS)
     return _extract_json_from_response(raw)
 
 
@@ -135,41 +206,76 @@ async def _merge_summaries(
 ) -> dict[str, Any]:
     """Fusionne les résumés de chaque document en un dossier unifié."""
     summaries_json = json.dumps(summaries, ensure_ascii=False, indent=2)
+    if estimate_tokens(summaries_json) > MAX_DIRECT_TOKENS:
+        raise _Unrecoverable("résumés trop volumineux pour une fusion par le modèle")
     user_prompt = build_merge_summaries_prompt(summaries_json)
-    raw = await _call_llm(
-        SYSTEM_PROMPT_MERGE_SUMMARIES,
-        user_prompt,
-        vllm_url,
-        model_name,
-        timeout=SYNTHESIS_TIMEOUT,
-    )
+    raw = await _call_llm(SYSTEM_PROMPT_MERGE_SUMMARIES, user_prompt, vllm_url, model_name)
     return _extract_json_from_response(raw)
 
 
+def _combine_summaries(summaries: list[dict[str, Any]]) -> dict[str, Any]:
+    """
+    Fusion déterministe des résumés par document, sans appel LLM.
+
+    Repli de `_merge_summaries` : moins synthétique (les doublons entre
+    documents subsistent), mais aucune information n'est perdue — ce qui
+    compte davantage pour remplir un formulaire que l'élégance du résumé.
+    """
+    combined: dict[str, Any] = {
+        "patient": {}, "diagnostics": [], "incapacites_travail": [], "traitements": [],
+        "medecins": [], "dates_cles": {}, "pronostic": None, "canton_traitement": None,
+    }
+    pronostics: list[str] = []
+    for summary in summaries:
+        source = summary.get("document")
+        for key, value in (summary.get("patient") or {}).items():
+            if value and not combined["patient"].get(key):
+                combined["patient"][key] = value
+        for key in ("diagnostics", "incapacites_travail"):
+            for entry in summary.get(key) or []:
+                if isinstance(entry, dict):
+                    entry = {**entry, "document_source": entry.get("document_source") or source}
+                combined[key].append(entry)
+        for key in ("traitements", "medecins"):
+            combined[key].extend(summary.get(key) or [])
+        dates = summary.get("dates_cles") or {}
+        if isinstance(dates, dict):
+            for key, value in dates.items():
+                if value and not combined["dates_cles"].get(key):
+                    combined["dates_cles"][key] = value
+        if summary.get("dates_importantes"):
+            combined.setdefault("dates_importantes", []).extend(summary["dates_importantes"])
+        if summary.get("pronostic"):
+            pronostics.append(str(summary["pronostic"]))
+        if summary.get("canton_traitement") and not combined["canton_traitement"]:
+            combined["canton_traitement"] = summary["canton_traitement"]
+    combined["pronostic"] = "\n".join(pronostics) or None
+    return combined
+
+
 async def _synthesize_hierarchical(
     docs: list[tuple[str, str]],  # [(doc_name, doc_text), ...]
     vllm_url: str,
     model_name: str,
 ) -> dict[str, Any]:
     """
-    Synthèse hiérarchique : résumé par document en séquentiel (pour ne pas saturer le GPU),
-    puis fusion en un seul appel.
+    Synthèse hiérarchique : résumé par document (3 en parallèle pour ne pas
+    saturer le GPU), puis fusion en un seul appel.
     """
-    import asyncio
-
-    summaries = []
+    parts = [part for name, text in docs for part in _split_document(name, text)]
     sem = asyncio.Semaphore(3)  # 3 docs en parallèle max
 
     async def _summarize_with_sem(name: str, text: str) -> dict[str, Any] | None:
         async with sem:
             try:
-                return await _summarize_single_doc(text, name, vllm_url, model_name)
+                summary = await _summarize_single_doc(text, name, vllm_url, model_name)
+                summary.setdefault("document", name)
+                return summary
             except Exception as exc:
                 logger.warning("Échec résumé doc '%s' : %s", name, exc)
                 return None
 
-    tasks = [_summarize_with_sem(name, text) for name, text in docs]
-    results = await asyncio.gather(*tasks)
+    results = await asyncio.gather(*[_summarize_with_sem(name, text) for name, text in parts])
     summaries = [r for r in results if r is not None]
 
     if not summaries:
@@ -178,7 +284,11 @@ async def _summarize_with_sem(name: str, text: str) -> dict[str, Any] | None:
     if len(summaries) == 1:
         return summaries[0]
 
-    return await _merge_summaries(summaries, vllm_url, model_name)
+    try:
+        return await _merge_summaries(summaries, vllm_url, model_name)
+    except Exception as exc:
+        logger.warning("Fusion des résumés par le modèle impossible (%s) — fusion déterministe", exc)
+        return _combine_summaries(summaries)
 
 
 # ---------------------------------------------------------------------------
@@ -201,7 +311,7 @@ async def run_medical_synthesis(
 
     Returns:
         dict Python représentant le dossier médical synthétisé,
-        ou None si la synthèse a échoué (le pipeline continue avec RAG pur).
+        ou None si la synthèse a échoué (le pipeline continue sur les seuls documents).
     """
     if not ocr_results:
         logger.warning("run_medical_synthesis : aucun document OCR fourni")
@@ -210,9 +320,9 @@ async def run_medical_synthesis(
     t0 = time.time()
 
     try:
-        # Construire le texte complet de tous les documents
+        # Ordre stable : même dossier, même prompt — et même préfixe pour vLLM.
         docs: list[tuple[str, str]] = []
-        for r in ocr_results:
+        for r in sorted(ocr_results, key=lambda d: d.get("filename", "")):
             name = r.get("filename", "document_inconnu")
             text = r.get("markdown", "")
             if text.strip():
@@ -235,16 +345,23 @@ async def run_medical_synthesis(
             total_tokens,
         )
 
+        result = None
+        strategy = "hiérarchique"
         if total_tokens <= MAX_DIRECT_TOKENS:
-            result = await _synthesize_direct(all_docs_text, vllm_url, model_name)
-            strategy = "directe"
-        else:
+            try:
+                result = await _synthesize_direct(all_docs_text, vllm_url, model_name)
+                strategy = "directe"
+            except Exception as exc:
+                # Un seul document mal formé ou un JSON tronqué ne justifie pas
+                # de renoncer : les résumés par document tiennent plus sûrement.
+                logger.warning("Synthèse directe impossible (%s: %s) — passage en hiérarchique",
+                               type(exc).__name__, exc)
+        if result is None:
             result = await _synthesize_hierarchical(docs, vllm_url, model_name)
-            strategy = "hiérarchique"
 
         elapsed = time.time() - t0
-        nb_diagnostics = len(result.get("diagnostics", []))
-        nb_incapacites = len(result.get("incapacites_travail", []))
+        nb_diagnostics = len(result.get("diagnostics") or [])
+        nb_incapacites = len(result.get("incapacites_travail") or [])
 
         logger.info(
             "Synthèse médicale terminée (%s) en %.1fs — %d diagnostics, %d périodes d'incapacité",
@@ -260,7 +377,7 @@ async def run_medical_synthesis(
         elapsed = time.time() - t0
         logger.error(
             "Échec de la synthèse médicale après %.1fs : %s — "
-            "le pipeline continuera avec le RAG pur",
+            "le pipeline continuera sur les seuls documents",
             elapsed,
             exc,
         )
diff --git a/services/orchestrator/prompts.py b/services/orchestrator/prompts.py
index 9c554a9..1bdc661 100644
--- a/services/orchestrator/prompts.py
+++ b/services/orchestrator/prompts.py
@@ -190,106 +190,83 @@ def build_merge_summaries_prompt(summaries_json: str) -> str:
 # 3. EXTRACTION BATCH (remplissage du formulaire — plusieurs champs par appel)
 # ---------------------------------------------------------------------------
 
-# Mapping section → clés de la synthèse pertinentes
-# La clé est le préfixe de l'ID du champ (avant le premier '.')
-SECTION_SYNTHESIS_KEYS: Dict[str, List[str]] = {
-    "1":  ["canton_traitement", "patient"],
-    "2":  ["patient", "medecins"],
-    "3":  ["incapacites_travail", "dates_cles"],
-    "4":  ["diagnostics", "traitements"],
-    "5":  ["incapacites_travail", "pronostic"],
-    "6":  ["incapacites_travail", "traitements"],
-    "7":  ["medecins"],
-    "8":  ["diagnostics", "traitements"],
-    "9":  ["medecins"],
-    "10": ["pronostic"],
-}
-
-
 SYSTEM_PROMPT_BATCH_EXTRACT = """\
-Tu es un assistant spécialisé dans l'extraction précise de données depuis des dossiers médicaux suisses.
-On te fournit une SYNTHÈSE MÉDICALE structurée et/ou des EXTRAITS de documents, \
-ainsi qu'une liste de CHAMPS à remplir pour un formulaire administratif.
+Tu es un assistant spécialisé dans l'extraction précise de données depuis des dossiers médicaux suisses, \
+pour remplir un formulaire administratif d'assurance (AI, LAA, LAMal, LAM, LCA).
+
+On te fournit :
+- une SYNTHÈSE MÉDICALE structurée du dossier, produite automatiquement : elle aide à s'orienter \
+mais peut contenir des erreurs ;
+- les DOCUMENTS du dossier (texte intégral ou extraits les plus pertinents), chacun précédé de sa source ;
+- la liste des CHAMPS à remplir, chacun identifié par son ID entre crochets.
 
 RÈGLES STRICTES :
-1. Cherche la réponse de chaque champ EN PRIORITÉ dans la SYNTHÈSE MÉDICALE si elle est fournie.
-2. Si la synthèse ne contient pas l'information, cherche dans les EXTRAITS DE DOCUMENTS.
-3. Si l'information est introuvable dans toutes les sources, retourne exactement "" (chaîne vide).
+1. Réponds pour TOUS les IDs demandés, en reprenant exactement ces IDs comme clés du JSON.
+2. Les DOCUMENTS font foi. En cas de désaccord entre la synthèse et les documents, suis les documents.
+3. Si l'information est introuvable, "value" vaut "" (chaîne vide). N'écris jamais « non mentionné », \
+« inconnu », « N/A », « ... » ni un exemple de format à la place d'une valeur.
 4. NE JAMAIS inventer, déduire ou supposer une valeur absente des sources.
-5. Réponds UNIQUEMENT en JSON valide, sans texte avant ou après.
-6. Réponds à TOUS les IDs demandés, même si la valeur est "".
-7. Pour les dates, utilise le format DD.MM.YYYY.
-8. Pour les listes (ex: diagnostics), liste TOUTES les entrées séparées par des sauts de ligne.
-9. "source_quote" doit être la citation EXACTE du texte source (max 100 caractères).
-   Si valeur vide, mettre "" pour source_quote aussi.
-10. Les clés techniques de la synthèse ("document_source", noms de fichiers .pdf)
-    désignent la provenance interne d'une information : ne les utilise JAMAIS comme
-    valeur d'un champ.
-11. Ne complète JAMAIS une adresse ou une coordonnée partielle avec des éléments
-    provenant d'une autre personne ou d'une autre entité. Une adresse de cabinet
-    sans rue reste sans rue.
+5. Distingue les personnes et les entités : patient, médecin traitant, médecin de famille, employeur, \
+assureur, destinataire. Une coordonnée n'appartient qu'à la personne ou l'entité à laquelle le document \
+l'attribue. Ne complète JAMAIS une adresse ou une coordonnée partielle avec des éléments d'une autre \
+personne ou entité : une adresse de cabinet sans rue reste sans rue.
+6. Dates au format JJ.MM.AAAA. Nombres et pourcentages : le nombre seul, sans unité ni symbole.
+7. Question fermée (oui/non) : réponds seulement si les sources permettent de trancher, sinon "".
+8. Si le champ propose une liste de valeurs, reprends exactement l'une d'elles.
+9. Champs répétés (« n°2 sur 4 ») : attribue les éléments dans l'ordre indiqué, un élément différent \
+par occurrence. S'il y a moins d'éléments que d'occurrences, laisse "" les occurrences en surnombre \
+plutôt que de répéter une valeur.
+10. Pour les listes (ex : diagnostics), liste TOUTES les entrées séparées par des sauts de ligne.
+11. "source_quote" : citation EXACTE et courte (100 caractères au plus) du passage des DOCUMENTS qui \
+justifie la valeur, recopiée mot pour mot. "" si la valeur est vide.
+12. Les clés techniques de la synthèse ("document_source", noms de fichiers .pdf) désignent la \
+provenance interne d'une information : ne les utilise JAMAIS comme valeur d'un champ.
+13. Réponds UNIQUEMENT par l'objet JSON demandé, sans texte avant ou après.
 """
 
 
-def build_batch_extraction_prompt(
+def build_batch_extraction_messages(
     fields: List[Dict],
     synthesis_json: str | None,
-    chunks_context: str | None,
-) -> str:
-    """
-    Construit le prompt pour extraire plusieurs champs en un seul appel LLM.
-    La synthèse est déjà pré-filtrée sur la section pertinente.
+    documents: str | None,
+    full_documents: bool = False,
+) -> List[Dict]:
     """
-    import json as _json
+    Messages d'extraction pour un lot de champs.
 
+    L'ordre compte pour vLLM (--enable-prefix-caching) : prompt système, synthèse
+    puis documents forment un préfixe identique pour tous les lots d'un job
+    lorsque les documents sont transmis en entier — il n'est calculé qu'une fois.
+    Seule la liste des champs, placée en dernier, varie d'un lot à l'autre.
+    """
     parts = []
-
     if synthesis_json:
-        parts.append(f"SYNTHÈSE MÉDICALE (source principale) :\n{synthesis_json}")
-
-    if chunks_context:
-        parts.append(f"EXTRAITS DE DOCUMENTS (source secondaire) :\n{chunks_context}")
-
-    # Les options d'un groupe de boutons radio doivent être reprises telles quelles :
-    # le remplissage les apparie au libellé exact pour choisir le bouton à cocher.
+        parts.append("SYNTHÈSE MÉDICALE (aide à l'orientation — les documents font foi) :\n"
+                     + synthesis_json)
+    if documents:
+        title = ("DOCUMENTS DU DOSSIER (texte intégral)" if full_documents
+                 else "EXTRAITS DE DOCUMENTS (les plus pertinents pour ces champs)")
+        parts.append(f"{title} :\n{documents}")
+
+    # Les options d'une liste doivent être reprises telles quelles : le remplissage
+    # les apparie au libellé exact pour choisir le bouton à cocher.
     def _line(f: Dict) -> str:
-        line = f'• [{f["id"]}] {f["question"]}'
+        line = f'• [{f["id"]}] {f.get("prompt_question") or f["question"]}'
         options = f.get("options")
         if options and f.get("type") == "choice":
             line += " (réponds exactement par l'une de ces valeurs : " + " | ".join(options) + ")"
         return line
 
-    field_lines = "\n".join(_line(f) for f in fields)
-    parts.append(f"CHAMPS À EXTRAIRE :\n{field_lines}")
-
-    # Fournir un exemple JSON avec tous les IDs pour guider le modèle
-    example = {str(f["id"]): {"value": "...", "source_quote": "..."} for f in fields}
+    parts.append("CHAMPS À EXTRAIRE :\n" + "\n".join(_line(f) for f in fields))
+    ids = ", ".join(f'"{f["id"]}"' for f in fields)
     parts.append(
-        f"RÉPONDS UNIQUEMENT avec ce JSON (tous les IDs sont obligatoires) :\n"
-        + _json.dumps(example, ensure_ascii=False, indent=2)
-    )
-
-    return "\n\n".join(parts)
-
-
-# ---------------------------------------------------------------------------
-# Compatibilité ascendante (ancienne interface mono-champ)
-# ---------------------------------------------------------------------------
-
-SYSTEM_PROMPT_EXTRACT = SYSTEM_PROMPT_BATCH_EXTRACT
-
-
-def build_field_extraction_prompt(
-    question: str,
-    synthesis_json: str | None,
-    chunks_context: str | None,
-) -> str:
-    """Interface mono-champ conservée pour compatibilité."""
-    return build_batch_extraction_prompt(
-        fields=[{"id": "result", "question": question}],
-        synthesis_json=synthesis_json,
-        chunks_context=chunks_context,
+        "RÉPONDS UNIQUEMENT par un objet JSON dont les clés sont exactement : " + ids + ".\n"
+        'Chaque clé a pour valeur un objet {"value": <chaîne>, "source_quote": <chaîne>}.'
     )
+    return [
+        {"role": "system", "content": SYSTEM_PROMPT_BATCH_EXTRACT},
+        {"role": "user", "content": "\n\n".join(parts)},
+    ]
 
 
 # ---------------------------------------------------------------------------
diff --git a/services/orchestrator/requirements-dev.txt b/services/orchestrator/requirements-dev.txt
new file mode 100644
index 0000000..42bca33
--- /dev/null
+++ b/services/orchestrator/requirements-dev.txt
@@ -0,0 +1,5 @@
+# Dépendances de test de l'orchestrateur (hors image Docker).
+#   pip install -r requirements-dev.txt && python -m pytest tests
+-r requirements.txt
+pytest>=8.0,<10.0
+pytest-cov>=5.0,<8.0
diff --git a/services/orchestrator/template/Form_LAA_PremierDiagnostic_MTBI.json b/services/orchestrator/template/Form_LAA_PremierDiagnostic_MTBI.json
index 0d9d770..a937f39 100644
--- a/services/orchestrator/template/Form_LAA_PremierDiagnostic_MTBI.json
+++ b/services/orchestrator/template/Form_LAA_PremierDiagnostic_MTBI.json
@@ -557,7 +557,9 @@
       "acroform_name": "topmostSubform[0].page1[0].insuranceSelector[0]",
       "type": "choice",
       "options": [
-        "Sélectionner l'assureur...",
+        "Sélectionner l'assureur..."
+      ],
+      "option_values": [
         "0"
       ],
       "preset": "0"
diff --git a/services/orchestrator/template/Form_LAA_PriseEnChargeHospitaliere.json b/services/orchestrator/template/Form_LAA_PriseEnChargeHospitaliere.json
index 81079a1..bfa85b5 100644
--- a/services/orchestrator/template/Form_LAA_PriseEnChargeHospitaliere.json
+++ b/services/orchestrator/template/Form_LAA_PriseEnChargeHospitaliere.json
@@ -490,7 +490,7 @@
       "id": "2.7",
       "name": "name",
       "label": "name",
-      "question": "Quel est le libellé du diagnostic posé ?",
+      "question": "Quelle est l'intervention ou l'opération réalisée (libellé) ?",
       "required": false,
       "xml_path": "topmostSubform/page1/ddiagnosisS1Struct/name",
       "acroform_name": "topmostSubform[0].page1[0].ddiagnosisS1Struct[0].name[0]"
@@ -499,7 +499,7 @@
       "id": "2.8",
       "name": "code",
       "label": "code",
-      "question": "Quel est le code CIM-10 du diagnostic ? Reprendre le code exactement tel qu'il figure dans les documents, sans le reformuler.",
+      "question": "Quel est le code CHOP de l'intervention ? Reprendre le code exactement tel qu'il figure dans les documents, sans le reformuler.",
       "required": false,
       "xml_path": "topmostSubform/page1/ddiagnosisS1Struct/code",
       "acroform_name": "topmostSubform[0].page1[0].ddiagnosisS1Struct[0].code[0]"
@@ -523,7 +523,7 @@
       "id": "3.4",
       "name": "input",
       "label": "input",
-      "question": "Y a-t-il une précision à apporter sur le diagnostic ?",
+      "question": "Y a-t-il une précision à apporter sur l'intervention ?",
       "required": false,
       "xml_path": "topmostSubform/page1/ddiagnosisS1Struct/input",
       "acroform_name": "topmostSubform[0].page1[0].ddiagnosisS1Struct[0].input[0]"
@@ -532,7 +532,7 @@
       "id": "2.9",
       "name": "name",
       "label": "name",
-      "question": "Quel est le libellé du diagnostic posé ?",
+      "question": "Quelle est l'intervention ou l'opération réalisée (libellé) ?",
       "required": false,
       "xml_path": "topmostSubform/page1/ediagnosisS1Struct/name",
       "acroform_name": "topmostSubform[0].page1[0].ediagnosisS1Struct[0].name[0]"
@@ -541,7 +541,7 @@
       "id": "2.10",
       "name": "code",
       "label": "code",
-      "question": "Quel est le code CIM-10 du diagnostic ? Reprendre le code exactement tel qu'il figure dans les documents, sans le reformuler.",
+      "question": "Quel est le code CHOP de l'intervention ? Reprendre le code exactement tel qu'il figure dans les documents, sans le reformuler.",
       "required": false,
       "xml_path": "topmostSubform/page1/ediagnosisS1Struct/code",
       "acroform_name": "topmostSubform[0].page1[0].ediagnosisS1Struct[0].code[0]"
@@ -565,7 +565,7 @@
       "id": "3.5",
       "name": "input",
       "label": "input",
-      "question": "Y a-t-il une précision à apporter sur le diagnostic ?",
+      "question": "Y a-t-il une précision à apporter sur l'intervention ?",
       "required": false,
       "xml_path": "topmostSubform/page1/ediagnosisS1Struct/input",
       "acroform_name": "topmostSubform[0].page1[0].ediagnosisS1Struct[0].input[0]"
@@ -619,7 +619,9 @@
         "Unfallversicherung Stadt Zürich",
         "Vaudoise Générale",
         "Visana Services AG (UVG)",
-        "Zürich Versicherungsgesellschaft AG",
+        "Zürich Versicherungsgesellschaft AG"
+      ],
+      "option_values": [
         "0",
         "1",
         "2",
diff --git a/services/orchestrator/template/Form_LAA_RapportAbrege.json b/services/orchestrator/template/Form_LAA_RapportAbrege.json
index 92ef326..ff1c037 100644
--- a/services/orchestrator/template/Form_LAA_RapportAbrege.json
+++ b/services/orchestrator/template/Form_LAA_RapportAbrege.json
@@ -287,7 +287,9 @@
       "acroform_name": "topmostSubform[0].page1[0].insuranceSelector[0]",
       "type": "choice",
       "options": [
-        "Sélectionner l'assureur...",
+        "Sélectionner l'assureur..."
+      ],
+      "option_values": [
         "0"
       ],
       "preset": "0"
diff --git a/services/orchestrator/template/Form_LAA_RapportInitial.json b/services/orchestrator/template/Form_LAA_RapportInitial.json
index abc1a3c..d54034d 100644
--- a/services/orchestrator/template/Form_LAA_RapportInitial.json
+++ b/services/orchestrator/template/Form_LAA_RapportInitial.json
@@ -386,7 +386,9 @@
       "acroform_name": "topmostSubform[0].page1[0].insuranceSelector[0]",
       "type": "choice",
       "options": [
-        "Sélectionner l'assureur...",
+        "Sélectionner l'assureur..."
+      ],
+      "option_values": [
         "0"
       ],
       "preset": "0"
diff --git a/services/orchestrator/template/Form_LAM_RapportIntermediaire.json b/services/orchestrator/template/Form_LAM_RapportIntermediaire.json
index 07e1893..8a9d82c 100644
--- a/services/orchestrator/template/Form_LAM_RapportIntermediaire.json
+++ b/services/orchestrator/template/Form_LAM_RapportIntermediaire.json
@@ -473,7 +473,9 @@
       "type": "choice",
       "options": [
         "non",
-        "oui",
+        "oui"
+      ],
+      "option_values": [
         "0",
         "1"
       ],
@@ -490,7 +492,9 @@
       "type": "choice",
       "options": [
         "non",
-        "oui",
+        "oui"
+      ],
+      "option_values": [
         "0",
         "1"
       ],
@@ -525,7 +529,9 @@
       "type": "choice",
       "options": [
         "non",
-        "oui",
+        "oui"
+      ],
+      "option_values": [
         "0",
         "1"
       ],
diff --git a/services/orchestrator/template/Form_LAMal_RapportInitial.json b/services/orchestrator/template/Form_LAMal_RapportInitial.json
index 470c809..506285b 100644
--- a/services/orchestrator/template/Form_LAMal_RapportInitial.json
+++ b/services/orchestrator/template/Form_LAMal_RapportInitial.json
@@ -432,7 +432,9 @@
       "acroform_name": "topmostSubform[0].page1[0].insuranceSelector[0]",
       "type": "choice",
       "options": [
-        "Sélectionner l'assureur...",
+        "Sélectionner l'assureur..."
+      ],
+      "option_values": [
         "0"
       ],
       "preset": "0"
diff --git a/services/orchestrator/template/Form_LCA_IncapaciteTravail.json b/services/orchestrator/template/Form_LCA_IncapaciteTravail.json
index ceaf0ed..879e43e 100644
--- a/services/orchestrator/template/Form_LCA_IncapaciteTravail.json
+++ b/services/orchestrator/template/Form_LCA_IncapaciteTravail.json
@@ -324,7 +324,9 @@
       "acroform_name": "topmostSubform[0].page1[0].insuranceSelector[0]",
       "type": "choice",
       "options": [
-        "Sélectionner l'assureur...",
+        "Sélectionner l'assureur..."
+      ],
+      "option_values": [
         "0"
       ],
       "preset": "0"
diff --git a/services/orchestrator/tests/__init__.py b/services/orchestrator/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/services/orchestrator/tests/catalogue_coverage.json b/services/orchestrator/tests/catalogue_coverage.json
new file mode 100644
index 0000000..e58c15d
--- /dev/null
+++ b/services/orchestrator/tests/catalogue_coverage.json
@@ -0,0 +1,26 @@
+{
+  "_comment": "Champs soumis au modèle par formulaire. Une baisse fait échouer tests/test_catalogue.py : à mettre à jour seulement si elle est voulue.",
+  "extractable": {
+    "AI_MoyensAuxiliaires": 22,
+    "AI_RapportIntermediaire_Actualisation": 34,
+    "AI_RapportIntermediaire_Revision": 47,
+    "AI_ReadaptationRente": 81,
+    "Adressage_Angiologie": 81,
+    "Adressage_Cardiologie": 64,
+    "Gyneco_AnnonceMaternite": 22,
+    "LAA_CertificatMedical_Suva": 77,
+    "LAA_MoyensAuxiliaires": 67,
+    "LAA_Physiotherapie": 58,
+    "LAA_Physiotherapie_LongueDuree": 67,
+    "LAA_PremierDiagnostic_MTBI": 62,
+    "LAA_PriseEnChargeHospitaliere": 53,
+    "LAA_RapportAbrege": 36,
+    "LAA_RapportInitial": 94,
+    "LAA_RapportIntermediaire_Suva": 58,
+    "LAM_FeuilleMaladieAccident": 77,
+    "LAM_RapportIntermediaire": 54,
+    "LAMal_RapportInitial": 107,
+    "LCA_IncapaciteTravail": 110,
+    "Prescription_EnseignementDiabete": 70
+  }
+}
diff --git a/services/orchestrator/tests/conftest.py b/services/orchestrator/tests/conftest.py
new file mode 100644
index 0000000..25d7a3d
--- /dev/null
+++ b/services/orchestrator/tests/conftest.py
@@ -0,0 +1,25 @@
+"""
+Configuration commune des tests de l'orchestrateur.
+
+Les tests tournent sans GPU ni service : OCR, TEI et vLLM sont simulés par un
+transport httpx (voir test_pipeline.py). Seuls pikepdf, pypdf et chromadb —
+dépendances de l'orchestrateur — sont requis.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import tempfile
+from pathlib import Path
+
+ORCHESTRATOR_DIR = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ORCHESTRATOR_DIR))
+
+# Avant l'import de app : ses répertoires de travail sont créés au chargement.
+_scratch = Path(tempfile.mkdtemp(prefix="doctorfill-tests-"))
+os.environ.setdefault("DEBUG_LOG_DIR", str(_scratch / "debug"))
+os.environ.setdefault("STATS_DIR", str(_scratch / "stats"))
+os.environ.setdefault("JOBS_DIR", str(_scratch / "jobs"))
+os.environ.setdefault("API_KEY", "")
+os.environ.setdefault("ANONYMIZED_TELEMETRY", "False")
diff --git a/services/orchestrator/tests/fakes.py b/services/orchestrator/tests/fakes.py
new file mode 100644
index 0000000..6729364
--- /dev/null
+++ b/services/orchestrator/tests/fakes.py
@@ -0,0 +1,75 @@
+"""
+Services simulés (marker, TEI, vLLM) derrière un transport httpx.
+
+Tout client httpx.AsyncClient créé pendant un test — par l'orchestrateur comme
+par medical_synthesis — passe par le handler installé, sans réseau.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import re
+from typing import Callable
+
+import httpx
+
+Handler = Callable[[httpx.Request], httpx.Response]
+
+
+def hashed_vector(text: str, dim: int = 32) -> list[float]:
+    """Embedding déterministe par sac de mots, suffisant pour ordonner des extraits."""
+    vec = [0.0] * dim
+    for word in re.findall(r"\w+", text.lower()):
+        vec[hash(word) % dim] += 1.0
+    norm = sum(v * v for v in vec) ** 0.5 or 1.0
+    return [v / norm for v in vec]
+
+
+def embed_response(request: httpx.Request) -> httpx.Response:
+    texts = json.loads(request.content)["texts"]
+    return httpx.Response(200, json={"embeddings": [hashed_vector(t) for t in texts]})
+
+
+def rerank_response(request: httpx.Request) -> httpx.Response:
+    payload = json.loads(request.content)
+    query = set(re.findall(r"\w+", payload["query"].lower()))
+    scored = [{"document": d, "score": len(query & set(re.findall(r"\w+", d.lower()))) / 10}
+              for d in payload["documents"]]
+    return httpx.Response(200, json={"results": sorted(scored, key=lambda r: -r["score"])})
+
+
+def completion(content: str | dict) -> httpx.Response:
+    text = content if isinstance(content, str) else json.dumps(content, ensure_ascii=False)
+    return httpx.Response(200, json={"choices": [{"message": {"content": text}, "finish_reason": "stop"}]})
+
+
+def uploaded_filename(request: httpx.Request) -> str:
+    return re.search(r'filename="([^"]+)"', request.content.decode("latin-1")).group(1)
+
+
+def schema_ids(request: httpx.Request) -> list[str]:
+    """IDs demandés par un appel d'extraction (schéma JSON de la réponse)."""
+    body = json.loads(request.content)
+    return list(body["response_format"]["json_schema"]["schema"]["properties"])
+
+
+def is_synthesis(request: httpx.Request) -> bool:
+    return "médecin expert" in json.loads(request.content)["messages"][0]["content"]
+
+
+def install(monkeypatch, handler: Handler) -> None:
+    """Route tout httpx.AsyncClient vers `handler` et neutralise les attentes de reprise."""
+    real_client = httpx.AsyncClient
+
+    class MockedClient(real_client):
+        def __init__(self, *args, **kwargs):
+            kwargs.pop("limits", None)
+            kwargs["transport"] = httpx.MockTransport(handler)
+            super().__init__(*args, **kwargs)
+
+    async def _no_sleep(*_a, **_k):
+        return None
+
+    monkeypatch.setattr(httpx, "AsyncClient", MockedClient)
+    monkeypatch.setattr(asyncio, "sleep", _no_sleep)
diff --git a/services/orchestrator/tests/form_factory.py b/services/orchestrator/tests/form_factory.py
new file mode 100644
index 0000000..fb42cb4
--- /dev/null
+++ b/services/orchestrator/tests/form_factory.py
@@ -0,0 +1,179 @@
+"""
+PDF hybrides XFA + AcroForm construits à partir d'un template du catalogue.
+
+Les PDF medForms ne sont pas versionnés. Pour vérifier en CI que chaque champ de
+chaque formulaire atteint le PDF, on reconstruit un formulaire de même structure :
+
+- couche AcroForm : arbre de champs issu des `acroform_name` (y compris les noms
+  échappés « Block_2\\.1 » et les nœuds « #area[0] », scindés comme le fait le
+  producteur des vrais PDF) ; case à cocher pour `bool`, groupe radio pour un
+  `choice` à valeurs d'export, liste déroulante pour les autres `choice` ;
+- couche XFA : packet `datasets` avec un nœud par `xml_path`, frères indexés
+  compris (`phone[1]`, `unemployabilityS1Struct[2]`).
+
+Le remplissage passe ensuite par le code de production (`_fill_pdf`) : détection
+« hybrid », injection XFA puis AcroForm.
+"""
+
+from __future__ import annotations
+
+import re
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+import pikepdf
+from pikepdf import Array, Dictionary, Name, String
+
+from core.extract import extract_xfa_packets
+from core.fill import _find
+
+_FF_RADIO = 1 << 15
+_FF_NO_TOGGLE_OFF = 1 << 14
+_FF_COMBO = 1 << 17
+_XFA_DATA_NS = "http://www.xfa.org/schema/xfa-data/1.0/"
+_SEGMENT = re.compile(r"^(.*?)(?:\[(\d+)\])?$")
+
+
+def widget_kind(field: dict) -> str:
+    """Type de widget AcroForm qu'un champ du template reçoit dans le PDF de test."""
+    kind = field.get("type")
+    options, values = field.get("options") or [], field.get("option_values") or []
+    if kind == "bool":
+        return "checkbox" if options else "checkbox_ap"
+    if kind == "choice" and options and len(values) == len(options):
+        return "radio"
+    if kind == "choice" and options:
+        return "combo"
+    return "text"
+
+
+def _state_stream(pdf: pikepdf.Pdf) -> pikepdf.Stream:
+    return pikepdf.Stream(pdf, b"q Q")
+
+
+def _datasets_xml(fields: list[dict]) -> bytes:
+    ET.register_namespace("xfa", _XFA_DATA_NS)
+    root = ET.Element(f"{{{_XFA_DATA_NS}}}datasets")
+    data = ET.SubElement(root, f"{{{_XFA_DATA_NS}}}data")
+    for field in fields:
+        node = data
+        for segment in [s for s in field["xml_path"].split("/") if s]:
+            tag, index = _SEGMENT.match(segment).groups()
+            index = int(index or 0)
+            siblings = [c for c in node if c.tag == tag]
+            while len(siblings) <= index:
+                siblings.append(ET.SubElement(node, tag))
+            node = siblings[index]
+        if field.get("type") == "bool" and (field.get("options") or [None])[-1] == "Off":
+            node.text = "Off"
+    return ET.tostring(root, encoding="utf-8")
+
+
+def build_hybrid_form(template: dict, path: Path) -> Path:
+    """Écrit le formulaire de test d'un template et le retourne."""
+    fields = [f for f in template["fields"] if "id" in f and f.get("acroform_name")]
+    pdf = pikepdf.new()
+    pdf.add_blank_page(page_size=(595, 842))
+    page = pdf.pages[0]
+    helv = pdf.make_indirect(Dictionary(Type=Name.Font, Subtype=Name.Type1,
+                                        BaseFont=Name.Helvetica, Encoding=Name.WinAnsiEncoding))
+    zadb = pdf.make_indirect(Dictionary(Type=Name.Font, Subtype=Name.Type1, BaseFont=Name.ZapfDingbats))
+
+    top: list = []
+    nodes: dict[str, pikepdf.Object] = {}
+    annots: list = []
+
+    def container(parts: list[str]) -> pikepdf.Object | None:
+        """Nœud intermédiaire pour le chemin `parts`, créé au besoin."""
+        if not parts:
+            return None
+        key = ".".join(parts)
+        if key not in nodes:
+            parent = container(parts[:-1])
+            node = pdf.make_indirect(Dictionary(T=String(parts[-1]), Kids=Array()))
+            if parent is None:
+                top.append(node)
+            else:
+                node.Parent = parent
+                parent.Kids.append(node)
+            nodes[key] = node
+        return nodes[key]
+
+    def widget(**entries) -> pikepdf.Object:
+        obj = pdf.make_indirect(Dictionary(Type=Name.Annot, Subtype=Name.Widget,
+                                           Rect=Array([40, 40, 300, 58]), P=page.obj, **entries))
+        annots.append(obj)
+        return obj
+
+    for field in fields:
+        parts = field["acroform_name"].split(".")
+        parent = container(parts[:-1])
+        kind = widget_kind(field)
+        if kind == "radio":
+            leaf = pdf.make_indirect(Dictionary(T=String(parts[-1]), FT=Name.Btn,
+                                                Ff=_FF_RADIO | _FF_NO_TOGGLE_OFF, Kids=Array()))
+            for value in field["option_values"]:
+                kid = widget(AS=Name.Off, Parent=leaf, AP=Dictionary(N=Dictionary({
+                    f"/{value}": _state_stream(pdf), "/Off": _state_stream(pdf)})))
+                leaf.Kids.append(kid)
+        elif kind == "checkbox":
+            leaf = widget(T=String(parts[-1]), FT=Name.Btn, V=Name.Off, AS=Name.Off)
+        elif kind == "checkbox_ap":
+            # Case dessinée par Designer, état coché « /1 » (AI_ReadaptationRente).
+            leaf = widget(T=String(parts[-1]), FT=Name.Btn, AS=Name.Off,
+                          AP=Dictionary(N=Dictionary({"/1": _state_stream(pdf), "/Off": _state_stream(pdf)})))
+        elif kind == "combo":
+            leaf = widget(T=String(parts[-1]), FT=Name.Ch, Ff=_FF_COMBO, DA=String("/Helv 0 Tf 0 g"),
+                          Opt=Array([String(o) for o in field["options"]]))
+        else:
+            leaf = widget(T=String(parts[-1]), FT=Name.Tx, DA=String("/Helv 0 Tf 0 g"))
+        if parent is None:
+            top.append(leaf)
+        else:
+            leaf.Parent = parent
+            parent.Kids.append(leaf)
+
+    datasets = pdf.make_stream(_datasets_xml(fields))
+    page.obj.Annots = Array(annots)
+    pdf.Root.AcroForm = Dictionary(Fields=Array(top), DA=String("/Helv 0 Tf 0 g"),
+                                   DR=Dictionary(Font=Dictionary(Helv=helv, ZaDb=zadb)),
+                                   XFA=Array([String("datasets"), datasets]))
+    path.parent.mkdir(parents=True, exist_ok=True)
+    pdf.save(str(path))
+    return path
+
+
+# ---------------------------------------------------------------------------
+# Relecture
+# ---------------------------------------------------------------------------
+
+def read_acroform(path: Path) -> dict[str, str | None]:
+    """Nom complet → /V (texte, ou nom d'état pour un bouton) de chaque champ terminal."""
+    values: dict[str, str | None] = {}
+
+    def walk(objs, prefix: str) -> None:
+        for obj in objs:
+            t = obj.get("/T")
+            name = f"{prefix}.{t}" if prefix and t is not None else (str(t) if t is not None else prefix)
+            if obj.get("/FT") is not None:
+                v = obj.get("/V")
+                values[name] = str(v) if v is not None else None
+                continue
+            if obj.get("/Kids") is not None:
+                walk(obj.Kids, name)
+
+    with pikepdf.open(str(path)) as pdf:
+        walk(pdf.Root.AcroForm.Fields, "")
+    return values
+
+
+def read_datasets(path: Path, xml_paths: list[str]) -> dict[str, str | None]:
+    """xml_path → texte du nœud dans le packet datasets du PDF rempli."""
+    import defusedxml.ElementTree as DET
+
+    root = DET.fromstring(extract_xfa_packets(path)["datasets"].encode("utf-8"))
+    out = {}
+    for xml_path in xml_paths:
+        node = _find(root, xml_path)
+        out[xml_path] = None if node is None else (node.text or "")
+    return out
diff --git a/services/orchestrator/tests/pdf_factory.py b/services/orchestrator/tests/pdf_factory.py
new file mode 100644
index 0000000..f912e31
--- /dev/null
+++ b/services/orchestrator/tests/pdf_factory.py
@@ -0,0 +1,73 @@
+"""
+Fabrique de formulaires PDF minimaux pour les tests.
+
+Les PDF medForms ne sont pas versionnés (voir .gitignore) : on construit un
+AcroForm équivalent — champs texte, case à cocher sans /AP comme chez medForms,
+liste de choix à options [export, libellé] — avec pikepdf.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pikepdf
+from pikepdf import Array, Dictionary, Name, String
+
+_FF_COMBO = 1 << 17
+
+
+def make_acroform(path: Path, fields: list[tuple[str, str, dict]]) -> Path:
+    """
+    Args:
+        fields: (nom, type, options) avec type ∈ {"text", "checkbox", "combo"} ;
+            pour "combo", options["opt"] liste des paires (export, libellé).
+    """
+    pdf = pikepdf.new()
+    pdf.add_blank_page(page_size=(595, 842))
+    page = pdf.pages[0]
+    helv = pdf.make_indirect(Dictionary(Type=Name.Font, Subtype=Name.Type1,
+                                        BaseFont=Name.Helvetica, Encoding=Name.WinAnsiEncoding))
+    zadb = pdf.make_indirect(Dictionary(Type=Name.Font, Subtype=Name.Type1, BaseFont=Name.ZapfDingbats))
+
+    widgets = []
+    y = 800
+    for name, kind, options in fields:
+        widget = Dictionary(Type=Name.Annot, Subtype=Name.Widget, T=String(name),
+                            Rect=Array([50, y - 18, 400, y]), P=page.obj,
+                            DA=String("/Helv 0 Tf 0 g"))
+        if kind == "text":
+            widget.FT = Name.Tx
+        elif kind == "checkbox":
+            widget.FT = Name.Btn
+            widget.V = Name.Off
+            widget.AS = Name.Off
+        elif kind == "combo":
+            widget.FT = Name.Ch
+            widget.Ff = _FF_COMBO
+            widget.Opt = Array([Array([String(e), String(d)]) for e, d in options["opt"]])
+        widgets.append(pdf.make_indirect(widget))
+        y -= 30
+
+    page.obj.Annots = Array(widgets)
+    pdf.Root.AcroForm = Dictionary(Fields=Array(widgets), DR=Dictionary(Font=Dictionary(Helv=helv, ZaDb=zadb)),
+                                   DA=String("/Helv 0 Tf 0 g"))
+    pdf.save(str(path))
+    return path
+
+
+def read_fields(path: Path) -> dict[str, dict]:
+    """Nom → {V, AS, has_ap, ap_text} de chaque champ d'un PDF rempli."""
+    out = {}
+    with pikepdf.open(str(path)) as pdf:
+        for field in pdf.Root.AcroForm.Fields:
+            ap = field.get("/AP")
+            ap_text = ""
+            if ap is not None and isinstance(ap.get("/N"), pikepdf.Stream):
+                ap_text = ap.N.read_bytes().decode("latin-1")
+            out[str(field.T)] = {
+                "V": str(field.get("/V")) if field.get("/V") is not None else None,
+                "AS": str(field.get("/AS")) if field.get("/AS") is not None else None,
+                "has_ap": ap is not None,
+                "ap_text": ap_text,
+            }
+    return out
diff --git a/services/orchestrator/tests/test_catalogue.py b/services/orchestrator/tests/test_catalogue.py
new file mode 100644
index 0000000..0c41fd1
--- /dev/null
+++ b/services/orchestrator/tests/test_catalogue.py
@@ -0,0 +1,116 @@
+"""
+Invariants des 21 templates du catalogue.
+
+Les templates sont régénérés par tools/gen_template.py et retouchés à la main :
+chacune de ces règles correspond à un défaut déjà rencontré (identifiants en
+double, deux entrées visant le même nœud XFA, options fusionnées avec leurs
+valeurs d'export, formulaire publié avec des questions vides…).
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+import pytest
+
+import extraction
+from core.fields import batch_fields, is_recipient_field, prepare_fields
+from prompts import SYSTEM_PROMPT_BATCH_EXTRACT, build_batch_extraction_messages
+
+TEMPLATE_DIR = Path(__file__).resolve().parent.parent / "template"
+TEMPLATES = {p.stem.removeprefix("Form_"): json.loads(p.read_text(encoding="utf-8"))
+             for p in sorted(TEMPLATE_DIR.glob("Form_*.json"))}
+KNOWN_TYPES = {None, "date", "bool", "choice", "sex", "percent", "int"}
+CANTONS = {"AG", "AI", "AR", "BE", "BL", "BS", "FR", "GE", "GL", "GR", "JU", "LU", "NE", "NW",
+           "OW", "SG", "SH", "SO", "SZ", "TG", "TI", "UR", "VD", "VS", "ZG", "ZH", "LI"}
+
+
+def _fields(template: dict) -> list[dict]:
+    return [f for f in template["fields"] if "id" in f]
+
+
+def test_catalogue_is_complete():
+    catalogue = (TEMPLATE_DIR.parent / "tools" / "catalog_fr.txt").read_text(encoding="utf-8")
+    listed = {line.split()[1] for line in catalogue.splitlines()
+              if line.strip() and not line.startswith("#")}
+    assert listed == set(TEMPLATES)
+
+
+@pytest.mark.parametrize("form_id", sorted(TEMPLATES))
+def test_identifiers_and_targets_are_unique(form_id):
+    fields = _fields(TEMPLATES[form_id])
+    for key in ("id", "xml_path", "acroform_name"):
+        values = [str(f.get(key)) for f in fields]
+        duplicates = {v for v in values if values.count(v) > 1}
+        assert not duplicates, f"{key} en double : {sorted(duplicates)[:5]}"
+    assert all(re.fullmatch(r"\d+\.\d+", str(f["id"])) for f in fields)
+    assert all(f.get("xml_path") and f.get("acroform_name") for f in fields)
+
+
+@pytest.mark.parametrize("form_id", sorted(TEMPLATES))
+def test_published_forms_have_every_question_written(form_id):
+    template = TEMPLATES[form_id]
+    assert template.get("_reviewed") is True, "formulaire non publié par /forms"
+    unwritten = [f["id"] for f in _fields(template)
+                 if "computed" not in f and not str(f.get("question") or "").strip()]
+    assert not unwritten
+
+
+@pytest.mark.parametrize("form_id", sorted(TEMPLATES))
+def test_field_types_and_options_are_consistent(form_id):
+    for f in _fields(TEMPLATES[form_id]):
+        assert f.get("type") in KNOWN_TYPES, f["id"]
+        options, values = f.get("options") or [], f.get("option_values")
+        if values is not None:
+            assert len(values) == len(options), f"{f['id']} : libellés et valeurs désalignés"
+        if f.get("type") == "choice" and f.get("question") and not f.get("preset"):
+            assert options, f"{f['id']} : liste de choix sans options"
+        # Libellés suivis de leurs index : deux groupes <items> fusionnés.
+        n = len(options) // 2
+        assert not (n and not values and options[n:] == [str(i) for i in range(n)]), \
+            f"{f['id']} : options fusionnées avec leurs valeurs d'export"
+
+
+@pytest.mark.parametrize("form_id", sorted(TEMPLATES))
+def test_canton_recipients_target_existing_fields(form_id):
+    template = TEMPLATES[form_id]
+    table = template.get("_recipient_by_canton")
+    if not table:
+        return
+    targets = {f.get("name") for f in _fields(template) if is_recipient_field(f)}
+    assert set(table) <= CANTONS
+    for canton, entries in table.items():
+        assert set(entries) & targets, f"{canton} : aucun champ du destinataire visé"
+    canton_fields = [f for f in _fields(template) if f.get("name") == "treatmentCanton"]
+    assert canton_fields, "table cantonale sans champ treatmentCanton"
+    assert set(table) <= set(canton_fields[0].get("options") or []), "canton de la table non proposé au modèle"
+
+
+@pytest.mark.parametrize("form_id", sorted(TEMPLATES))
+def test_every_batch_fits_the_model_window(form_id):
+    """Le plus gros lot, avec la synthèse et le dossier intégral au seuil, tient dans la fenêtre."""
+    batches = batch_fields(prepare_fields(TEMPLATES[form_id]))
+    synthesis = "x" * 3 * 4000                                   # synthèse de ~4k tokens
+    documents = "x" * 3 * extraction.FULL_CONTEXT_MAX_TOKENS     # dossier au seuil du mode intégral
+    for batch in batches:
+        messages = build_batch_extraction_messages(batch, synthesis, documents, full_documents=True)
+        prompt = sum(extraction.estimate_tokens(m["content"]) for m in messages)
+        assert prompt + extraction.MAX_TOKENS_EXTRACT <= extraction.LLM_MAX_MODEL_LEN, \
+            f"lot {[f['id'] for f in batch][:3]}… : {prompt} tokens de prompt"
+    assert extraction.estimate_tokens(SYSTEM_PROMPT_BATCH_EXTRACT) < 2000
+
+
+def test_no_field_silently_leaves_the_extraction():
+    """
+    Aucun formulaire ne perd de champs soumis au modèle sans qu'on le décide.
+
+    C'est ainsi que 91 champs avaient disparu : une règle de filtrage trop large,
+    sans aucun test pour le remarquer. Une hausse passe ; une baisse voulue se
+    reporte dans tests/catalogue_coverage.json.
+    """
+    snapshot = json.loads((Path(__file__).parent / "catalogue_coverage.json").read_text(encoding="utf-8"))
+    current = {form_id: len(prepare_fields(t)) for form_id, t in TEMPLATES.items()}
+    lost = {f: (n, current.get(f, 0)) for f, n in snapshot["extractable"].items() if current.get(f, 0) < n}
+    assert not lost, f"champs perdus (avant, après) : {lost}"
diff --git a/services/orchestrator/tests/test_catalogue_fill.py b/services/orchestrator/tests/test_catalogue_fill.py
new file mode 100644
index 0000000..d707c02
--- /dev/null
+++ b/services/orchestrator/tests/test_catalogue_fill.py
@@ -0,0 +1,90 @@
+"""
+Chaque champ de chaque formulaire du catalogue atteint le PDF, dans les deux couches.
+
+Pour les 21 formulaires : on simule une réponse du modèle pour tous les champs
+extraits — sous une forme réaliste, à normaliser (date ISO, « Oui », « 50 % »,
+libellé d'option) — puis on remplit un PDF hybride de même structure avec le
+code de production. Un champ que le template décrit mais que le remplissage ne
+retrouve pas (chemin XFA, nom AcroForm, état de case, valeur d'export) fait
+échouer le test : c'est exactement la régression silencieuse qu'un template
+régénéré ou une modification de core/ pourrait introduire.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+import app as orchestrator
+from core.fields import is_recipient_field, prepare_fields
+from tests.form_factory import build_hybrid_form, read_acroform, read_datasets, widget_kind
+
+TEMPLATE_DIR = Path(__file__).resolve().parent.parent / "template"
+FORMS = sorted(p.stem.removeprefix("Form_") for p in TEMPLATE_DIR.glob("Form_*.json"))
+
+
+def _answer(field: dict) -> tuple[str, str, str]:
+    """(réponse du modèle, valeur XFA attendue, /V AcroForm attendue) pour un champ."""
+    kind = field.get("type")
+    options, values = field.get("options") or [], field.get("option_values") or []
+    widget = widget_kind(field)
+    if kind == "date":
+        return "2026-03-15", "15.03.2026", "15.03.2026"
+    if kind == "percent":
+        return "50 %", "50", "50"
+    if kind == "int":
+        return "12 séances", "12", "12"
+    if kind == "sex":
+        return "féminin", "F", "F"
+    if kind == "bool":
+        on = options[0] if options else "1"
+        return "Oui", on, "/On" if widget == "checkbox" else "/1"
+    if kind == "choice" and options:
+        label = options[-1]
+        if widget == "radio":
+            return label, values[-1], f"/{values[-1]}"
+        return label, label, label
+    value = f"Valeur {field['id']}"
+    return value, value, value
+
+
+@pytest.mark.parametrize("form_id", FORMS)
+def test_every_field_reaches_both_layers(form_id, tmp_path, monkeypatch):
+    template = json.loads((TEMPLATE_DIR / f"Form_{form_id}.json").read_text(encoding="utf-8"))
+    monkeypatch.chdir(tmp_path)
+    build_hybrid_form(template, tmp_path / "forms" / f"Form_{form_id}.pdf")
+
+    fields = prepare_fields(template)
+    results, expected_xfa, expected_acro = [], {}, {}
+    for field in fields:
+        answer, xfa_value, acro_value = _answer(field)
+        results.append({"id": field["id"], "result": {"value": answer, "source_quote": ""}})
+        expected_xfa[field["xml_path"]] = xfa_value
+        expected_acro[field["acroform_name"]] = acro_value
+
+    # Canton : une valeur de la table pour exercer le destinataire cantonal.
+    table = template.get("_recipient_by_canton") or {}
+    canton_field = next((f for f in fields if f.get("name") == "treatmentCanton"), None)
+    if table and canton_field:
+        canton = "NE" if "NE" in table else sorted(table)[0]
+        next(r for r in results if r["id"] == canton_field["id"])["result"]["value"] = canton
+        expected_xfa[canton_field["xml_path"]] = expected_acro[canton_field["acroform_name"]] = canton
+        for name, value in table[canton].items():
+            for f in template["fields"]:
+                if f.get("name") == name and is_recipient_field(f):
+                    expected_xfa[f["xml_path"]] = expected_acro[f["acroform_name"]] = value
+
+    output, form_type = orchestrator._fill_pdf("test", form_id, template, results, tmp_path)
+    assert form_type == "hybrid"
+
+    datasets = read_datasets(output, list(expected_xfa))
+    acroform = read_acroform(output)
+    missing_xfa = {p: (v, datasets.get(p)) for p, v in expected_xfa.items()
+                   if v and datasets.get(p) != v}
+    missing_acro = {n: (v, acroform.get(n)) for n, v in expected_acro.items()
+                    if v and acroform.get(n) != v}
+    assert not missing_xfa, f"{len(missing_xfa)} champ(s) XFA non écrits : {list(missing_xfa.items())[:5]}"
+    assert not missing_acro, f"{len(missing_acro)} champ(s) AcroForm non écrits : {list(missing_acro.items())[:5]}"
+    assert len(fields) > 0
diff --git a/services/orchestrator/tests/test_eval_dossiers.py b/services/orchestrator/tests/test_eval_dossiers.py
new file mode 100644
index 0000000..95b5ebb
--- /dev/null
+++ b/services/orchestrator/tests/test_eval_dossiers.py
@@ -0,0 +1,166 @@
+"""
+Les 21 dossiers d'évaluation, de bout en bout, par l'API HTTP — modèle simulé.
+
+Chaque dossier de `eval/dossiers/` (PDF réels, 4 à 7 documents) est soumis à
+/process-form avec le script de non-régression lui-même (`eval/regression.py`),
+contre l'application en mémoire. OCR, embeddings et LLM sont simulés ; le
+« modèle » répond la vérité terrain dérivée des scénarios (`eval/truth.py`).
+
+Ce que ça garantit à chaque merge, pour chaque formulaire du catalogue :
+- le dossier traverse tout le pipeline sans erreur (upload, OCR, synthèse,
+  extraction, remplissage, /fields, /download) ;
+- une valeur juste en sortie du modèle arrive juste dans /fields *et* dans le
+  PDF livré — normalisation, options, destinataire cantonal compris ;
+- le script de non-régression note 100 % un modèle parfait, et détecte une
+  valeur fausse (sinon il ne protégerait de rien sur le DGX).
+
+Ce qu'il ne garantit pas : la qualité du vrai modèle. C'est le rôle de
+`eval/regression.py` contre le backend réel (voir docs/wiki/Tests.md).
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import httpx
+import pytest
+from fastapi.testclient import TestClient
+
+import app as orchestrator
+import extraction
+from core.fields import normalize_value
+from tests import fakes
+from tests.form_factory import build_hybrid_form, read_acroform
+
+EVAL_DIR = Path(__file__).resolve().parents[3] / "eval"
+sys.path.insert(0, str(EVAL_DIR))
+
+import regression  # noqa: E402
+import truth  # noqa: E402
+
+FORMS = sorted(truth.load_scenarios())
+
+
+class DossierServices:
+    """OCR rendant le markdown du dossier, LLM répondant la vérité terrain."""
+
+    def __init__(self):
+        self.form_id = ""
+        self.answers: dict[str, str] = {}
+        self.fail_ocr = False
+
+    def use(self, form_id: str, corrupt: set[str] = frozenset()) -> None:
+        self.form_id = form_id
+        expected = truth.derive_truth(form_id)
+        self.answers = {fid: ("valeur fausse" if fid in corrupt else exp.expected)
+                        for fid, exp in expected.items()}
+
+    def handler(self, request):
+        path = request.url.path
+        if path.endswith("/extract"):
+            if self.fail_ocr:
+                return httpx.Response(500, json={"detail": "échec"})
+            name = fakes.uploaded_filename(request)
+            md = (truth.DOSSIERS_DIR / self.form_id / name).with_suffix(".md")
+            return httpx.Response(200, json={"markdown": md.read_text(encoding="utf-8")})
+        if path.endswith("/embed"):
+            return fakes.embed_response(request)
+        if path.endswith("/rerank"):
+            return fakes.rerank_response(request)
+        if fakes.is_synthesis(request):
+            return fakes.completion({"patient": {}, "diagnostics": [], "incapacites_travail": []})
+        return fakes.completion({fid: {"value": self.answers.get(fid, ""), "source_quote": ""}
+                                 for fid in fakes.schema_ids(request)})
+
+
+@pytest.fixture(scope="module")
+def form_pdfs(tmp_path_factory):
+    """Un PDF hybride de test par formulaire, construit une fois pour le module."""
+    root = tmp_path_factory.mktemp("catalogue")
+    for form_id in FORMS:
+        build_hybrid_form(truth.load_template(form_id), root / "forms" / f"Form_{form_id}.pdf")
+    return root / "forms"
+
+
+@pytest.fixture
+def api(form_pdfs, tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    (tmp_path / "template").symlink_to(truth.TEMPLATES_DIR, target_is_directory=True)
+    (tmp_path / "forms").symlink_to(form_pdfs, target_is_directory=True)
+    monkeypatch.setattr(orchestrator, "VALID_FORM_IDS", set(FORMS))
+    services = DossierServices()
+    fakes.install(monkeypatch, lambda request: services.handler(request))
+    return TestClient(orchestrator.app), services
+
+
+def _no_wait(_seconds: float) -> None:
+    return None
+
+
+@pytest.mark.parametrize("form_id", FORMS)
+def test_dossier_fits_the_full_context_mode(form_id):
+    docs = truth.dossier_documents(form_id)
+    assert docs, "dossier vide"
+    assert extraction.estimate_tokens(extraction.full_documents_text(docs)) <= extraction.FULL_CONTEXT_MAX_TOKENS
+
+
+@pytest.mark.parametrize("form_id", FORMS)
+def test_perfect_model_scores_perfectly_through_the_api(api, form_id):
+    client, services = api
+    services.use(form_id)
+    result = regression.run_form(client, form_id, truth.dossier_pdfs(form_id), sleep=_no_wait)
+
+    assert result["status"] == "completed", result.get("message")
+    assert result["errors"] == 0
+    wrong = [d for d in result["details"] if not d["match"]]
+    assert result["truth_fields"] >= 5
+    assert not wrong, wrong[:3]
+
+    # Le PDF livré porte les mêmes valeurs que /fields.
+    job = orchestrator.JOBS[result["job_id"]]
+    pdf = client.get(f"/download/{result['job_id']}", params={"token": job["token"]})
+    assert pdf.status_code == 200
+    out = Path(job["file_path"])
+    acro = read_acroform(out)
+    template = truth.load_template(form_id)
+    by_id = {str(f["id"]): f for f in template["fields"] if "id" in f}
+    for fid, exp in truth.derive_truth(form_id).items():
+        field = by_id[fid]
+        written = acro.get(field["acroform_name"])
+        assert written is not None and truth.matches(exp.expected, normalize_value(written, field),
+                                                     exp.tolerance), \
+            f"{fid} ({field['name']}) : attendu {exp.expected!r}, PDF {written!r}"
+
+
+def test_regression_gate_detects_a_wrong_value_and_a_failed_job(api, tmp_path):
+    client, services = api
+    form_id = "LCA_IncapaciteTravail"
+    baseline = tmp_path / "baseline.json"
+    argv = ["--forms", form_id, "--baseline", str(baseline), "--parallel", "1"]
+
+    services.use(form_id)
+    assert regression.main(argv + ["--update-baseline"], client=client) == 0
+    reference = json.loads(baseline.read_text(encoding="utf-8"))
+    assert reference["forms"][form_id]["accuracy"] == 1.0
+
+    assert regression.main(argv, client=client) == 0
+
+    # Deux valeurs fausses : au-delà de la tolérance d'un champ, la porte se ferme.
+    corrupt = set(sorted(truth.derive_truth(form_id))[:2])
+    services.use(form_id, corrupt=corrupt)
+    report = tmp_path / "report.md"
+    assert regression.main(argv + ["--report", str(report)], client=client) == 1
+    assert "❌" in report.read_text(encoding="utf-8")
+
+    services.fail_ocr = True
+    assert regression.main(argv, client=client) == 2
+
+
+def test_gate_tolerates_one_field_of_noise():
+    base = {"forms": {"F": {"correct": 10, "truth_fields": 10, "errors": 0}}}
+    one_off = [{"form": "F", "status": "completed", "correct": 9, "truth_fields": 10, "errors": 0}]
+    assert regression.compare(one_off, base, max_global_drop=0.2) == []
+    two_off = [{"form": "F", "status": "completed", "correct": 8, "truth_fields": 10, "errors": 0}]
+    assert regression.compare(two_off, base, max_global_drop=0.2)
diff --git a/services/orchestrator/tests/test_extraction.py b/services/orchestrator/tests/test_extraction.py
new file mode 100644
index 0000000..25b1b73
--- /dev/null
+++ b/services/orchestrator/tests/test_extraction.py
@@ -0,0 +1,252 @@
+"""Découpage, contexte et appel LLM résilient (extraction.py)."""
+
+import asyncio
+import json
+
+import httpx
+import pytest
+
+import extraction
+from extraction import (
+    build_rag_context,
+    chunk_document,
+    extract_batch,
+    full_documents_text,
+    parse_response,
+    response_schema,
+)
+from prompts import build_batch_extraction_messages
+
+URL = "http://vllm.test/v1"
+
+
+# --- Découpage ------------------------------------------------------------------
+
+def test_every_chunk_carries_its_source():
+    md = ("# Fiche\n\nÉtablie le 09.04.2026.\n\n## Identité\n\n- Nom : DUPONT\n\n"
+          "## Médecin traitant\n\n" + " ".join(f"mot{i}" for i in range(700)))
+    chunks = chunk_document("01_fiche.pdf", md, max_words=300, overlap=50, min_words=10)
+    assert all(c.startswith("[Source : 01_fiche.pdf") for c in chunks)
+    assert any("Médecin traitant" in c.splitlines()[0] for c in chunks[1:])
+    assert max(len(c.split()) for c in chunks) <= 300 + 10
+
+
+def test_text_layer_pages_are_labelled_and_small_sections_merged():
+    md = "## Page 1\n\nCourt.\n\n## Page 2\n\n" + " ".join(["texte"] * 80)
+    chunks = chunk_document("scan.pdf", md, min_words=40)
+    assert chunks[0].startswith("[Source : scan.pdf — page 1]")
+    assert "## Page" not in chunks[0]
+    assert chunks[-1].startswith("[Source : scan.pdf — page 2]")
+
+
+def test_full_documents_text_is_stable():
+    docs = [{"filename": "b.pdf", "markdown": "B"}, {"filename": "a.pdf", "markdown": "A"},
+            {"filename": "c.pdf", "markdown": "  "}]
+    assert full_documents_text(docs) == "=== DOCUMENT : a.pdf ===\nA\n\n=== DOCUMENT : b.pdf ===\nB"
+
+
+def test_rag_context_interleaves_and_respects_budget():
+    chunks = {"1": ["a1 " * 30, "a2 " * 30, "a3 " * 30], "2": ["b1 " * 30, "b2 " * 30]}
+    fields = [{"id": "1"}, {"id": "2"}]
+    context = build_rag_context(fields, chunks, budget_tokens=10_000)
+    order = [block.split()[0] for block in context.split("\n\n---\n\n")]
+    assert order == ["a1", "b1", "a2", "b2", "a3"]
+    small = build_rag_context(fields, chunks, budget_tokens=70)
+    assert [b.split()[0] for b in small.split("\n\n---\n\n")] == ["a1", "b1"]
+
+
+# --- Lecture de la réponse ---------------------------------------------------------
+
+FIELDS = [{"id": "1.1", "question": "Nom ?"}, {"id": "1.2", "question": "Prénom ?"},
+          {"id": "1.3", "question": "Sexe ?", "type": "choice", "options": ["M", "F"]}]
+
+
+def test_parse_response_is_tolerant():
+    content = json.dumps({"[1.1]": {"value": "DUPONT", "source_quote": "Nom : DUPONT"},
+                          "1.2": "Jean", "1.3": {"valeur": ["F"]}})
+    parsed = parse_response("Voici :\n" + content, FIELDS)
+    assert parsed["1.1"] == {"value": "DUPONT", "source_quote": "Nom : DUPONT"}
+    assert parsed["1.2"] == {"value": "Jean", "source_quote": ""}
+    assert parsed["1.3"]["value"] == "F"
+
+
+def test_parse_response_unwraps_single_envelope():
+    content = json.dumps({"champs": {"1.1": {"value": "X", "source_quote": ""}}})
+    assert parse_response(content, FIELDS)["1.1"]["value"] == "X"
+
+
+def test_schema_constrains_ids_and_choices():
+    schema = response_schema(FIELDS)
+    assert schema["required"] == ["1.1", "1.2", "1.3"]
+    assert schema["properties"]["1.3"]["properties"]["value"]["enum"] == ["M", "F", ""]
+
+
+def test_prompt_puts_shared_context_first():
+    messages = build_batch_extraction_messages(FIELDS[:1], '{"patient": {}}', "DOCS", full_documents=True)
+    user = messages[1]["content"]
+    assert user.index("SYNTHÈSE") < user.index("DOCUMENTS DU DOSSIER") < user.index("CHAMPS À EXTRAIRE")
+    assert '"..."' not in user
+
+
+# --- Appel résilient ---------------------------------------------------------------
+
+def _completion(payload, finish_reason="stop"):
+    return httpx.Response(200, json={"choices": [{"message": {"content": json.dumps(payload)},
+                                                  "finish_reason": finish_reason}]})
+
+
+def _ids(request):
+    body = json.loads(request.content)
+    fmt = body.get("response_format", {})
+    if fmt.get("type") == "json_schema":
+        return list(fmt["json_schema"]["schema"]["properties"])
+    return [line.split("]")[0].split("[")[1] for line in body["messages"][1]["content"].splitlines()
+            if line.startswith("• [")]
+
+
+def _run(handler, fields, builder=None):
+    async def go():
+        async with httpx.AsyncClient(transport=httpx.MockTransport(handler)) as client:
+            return await extract_batch(client, URL, "model", fields,
+                                       builder or (lambda b, s: build_batch_extraction_messages(b, None, "ctx")),
+                                       asyncio.Semaphore(4))
+    return asyncio.run(go())
+
+
+@pytest.fixture(autouse=True)
+def _fast(monkeypatch):
+    monkeypatch.setattr(extraction, "_schema_supported", True)
+    monkeypatch.setattr(asyncio, "sleep", _no_sleep)
+
+
+async def _no_sleep(*_args, **_kwargs):
+    return None
+
+
+def test_truncated_batch_is_split_not_lost():
+    calls = []
+
+    def handler(request):
+        ids = _ids(request)
+        calls.append(ids)
+        if len(ids) > 1:
+            return _completion({}, finish_reason="length")
+        return _completion({ids[0]: {"value": f"v{ids[0]}", "source_quote": ""}})
+
+    results = _run(handler, FIELDS)
+    assert [r["result"]["value"] for r in results] == ["v1.1", "v1.2", "v1.3"]
+    assert calls[0] == ["1.1", "1.2", "1.3"]
+
+
+def test_context_overflow_shrinks_context_for_single_field():
+    scales = []
+
+    def builder(batch, scale):
+        scales.append(scale)
+        return build_batch_extraction_messages(batch, None, "ctx")
+
+    def handler(request):
+        if scales[-1] >= 1.0:
+            return httpx.Response(400, text="This model's maximum context length is 32768 tokens.")
+        return _completion({"1.1": {"value": "ok", "source_quote": ""}})
+
+    results = _run(handler, FIELDS[:1], builder)
+    assert results[0]["result"]["value"] == "ok"
+    assert scales[0] == 1.0 and scales[-1] < 1.0
+
+
+def test_missing_ids_are_asked_again():
+    seen = []
+
+    def handler(request):
+        ids = _ids(request)
+        seen.append(ids)
+        return _completion({ids[0]: {"value": "A", "source_quote": ""}})
+
+    results = _run(handler, FIELDS[:2])
+    assert seen == [["1.1", "1.2"], ["1.2"]]
+    assert all("result" in r for r in results)
+
+
+def test_schema_refusal_falls_back_to_json_object():
+    formats = []
+
+    def handler(request):
+        fmt = json.loads(request.content)["response_format"]["type"]
+        formats.append(fmt)
+        if fmt == "json_schema":
+            return httpx.Response(400, text="Unsupported response_format json_schema")
+        return _completion({"1.1": {"value": "B", "source_quote": ""}})
+
+    results = _run(handler, FIELDS[:1])
+    assert formats == ["json_schema", "json_object"]
+    assert results[0]["result"]["value"] == "B"
+
+
+def test_server_errors_are_retried_then_reported_per_field():
+    attempts = []
+
+    def handler(request):
+        attempts.append(1)
+        return httpx.Response(503, text="overloaded")
+
+    results = _run(handler, FIELDS[:2])
+    assert all(r.get("error") == "extraction_failed" for r in results)
+    # 3 essais sur le lot, puis 3 sur chacune des deux moitiés.
+    assert len(attempts) == 9
+
+
+def test_client_errors_are_not_retried():
+    attempts = []
+
+    def handler(request):
+        attempts.append(1)
+        return httpx.Response(422, text="bad request")
+
+    results = _run(handler, FIELDS[:1])
+    assert results[0]["error"] == "extraction_failed"
+    assert len(attempts) == 1
+
+
+def test_context_overflow_shrinks_instead_of_splitting():
+    seen = []
+
+    def builder(batch, scale):
+        seen.append(([f["id"] for f in batch], scale))
+        return build_batch_extraction_messages(batch, None, "ctx")
+
+    def handler(request):
+        if seen[-1][1] > 0.25:
+            return httpx.Response(400, text="maximum context length exceeded")
+        return _completion({i: {"value": "v", "source_quote": ""} for i in seen[-1][0]})
+
+    results = _run(handler, FIELDS[:2], builder)
+    assert all("result" in r for r in results)
+    assert [ids for ids, _ in seen] == [["1.1", "1.2"]] * 3
+    assert [scale for _, scale in seen] == [1.0, 0.5, 0.25]
+
+
+def test_empty_response_is_asked_again():
+    calls = []
+
+    def handler(request):
+        calls.append(_ids(request))
+        if len(calls) == 1:
+            return _completion({})
+        return _completion({i: {"value": "v", "source_quote": ""} for i in calls[-1]})
+
+    results = _run(handler, FIELDS[:2])
+    assert calls == [["1.1", "1.2"], ["1.1", "1.2"]]
+    assert all("result" in r for r in results)
+
+
+def test_persistently_empty_response_is_reported_not_looped():
+    calls = []
+
+    def handler(request):
+        calls.append(1)
+        return _completion({})
+
+    results = _run(handler, FIELDS[:2])
+    assert len(calls) == 2
+    assert all(r["error"] == "field_missing_in_response" for r in results)
diff --git a/services/orchestrator/tests/test_fields.py b/services/orchestrator/tests/test_fields.py
new file mode 100644
index 0000000..1481d51
--- /dev/null
+++ b/services/orchestrator/tests/test_fields.py
@@ -0,0 +1,235 @@
+"""Préparation des champs et normalisation des valeurs (core/fields.py)."""
+
+import json
+from pathlib import Path
+
+import pytest
+
+from core.fields import (
+    batch_fields,
+    collect_form_values,
+    contextualize,
+    extractable_fields,
+    is_blank_default,
+    normalize_date,
+    normalize_value,
+    prepare_fields,
+    resolve_option,
+    retrieval_text,
+)
+
+TEMPLATE_DIR = Path(__file__).resolve().parent.parent / "template"
+
+
+# --- Presets -----------------------------------------------------------------
+
+@pytest.mark.parametrize("field, expected", [
+    ({"type": "bool", "preset": "/Off"}, True),
+    ({"type": "bool", "preset": "/On"}, False),
+    ({"type": "int", "preset": "0"}, True),
+    ({"type": "int", "preset": "/0"}, False),
+    ({"type": "choice", "preset": "non", "options": ["non", "oui"]}, True),
+    ({"type": "choice", "preset": "0", "options": ["non", "oui (= Major RF)"],
+      "option_values": ["0", "1"]}, True),
+    ({"type": "choice", "preset": "1", "options": ["non", "oui"], "option_values": ["0", "1"]}, False),
+    ({"type": "choice", "preset": "LAA", "options": ["LAMal", "LCA", "LAA"]}, False),
+    ({"preset": "IV-Stelle Kanton Bern"}, False),
+])
+def test_blank_default(field, expected):
+    assert is_blank_default(field) is expected
+
+
+def test_extractable_fields_keeps_blank_checkboxes_and_authoritative_presets_out():
+    template = {"fields": [
+        {"comments": "Section 1"},
+        {"id": "1.1", "question": "Urgent ?", "type": "bool", "preset": "/Off"},
+        {"id": "1.2", "question": "Régime ?", "type": "choice", "preset": "LAA",
+         "options": ["LAA", "LCA"]},
+        {"id": "1.3", "question": "Adresse office ?", "preset": "Office AI"},
+        {"id": "1.4", "question": "", "computed": "x"},
+        {"id": "1.5", "question": "Nom ?"},
+    ]}
+    assert [f["id"] for f in extractable_fields(template)] == ["1.1", "1.5"]
+
+
+def test_catalogue_exposes_blank_checkboxes():
+    """Les 79 cases vierges du catalogue sont désormais soumises au modèle."""
+    template = json.loads((TEMPLATE_DIR / "Form_Adressage_Angiologie.json").read_text(encoding="utf-8"))
+    ids = {f["id"] for f in extractable_fields(template)}
+    urgency = next(f for f in template["fields"] if f.get("name") == "appointmentUrgency")
+    assert urgency["id"] in ids
+
+
+# --- Questions univoques -------------------------------------------------------
+
+def _period_fields():
+    base = "topmostSubform/page1/unemployabilityS1Struct"
+    fields = []
+    for i, suffix in enumerate(["", "[1]", "[2]"]):
+        fields.append({"id": f"1.{10 + 2 * i}", "question": "Quelle est la date de début de la période concernée ?",
+                       "xml_path": f"{base}{suffix}/beginDate", "type": "date"})
+        fields.append({"id": f"1.{11 + 2 * i}", "question": "Quel est le pourcentage indiqué ?",
+                       "xml_path": f"{base}{suffix}/percentageNum", "type": "percent"})
+    return fields
+
+
+def test_repeated_questions_get_occurrence_context():
+    prepared = contextualize(_period_fields() + [
+        {"id": "2.1", "question": "Quelle est la date de début de la période concernée ?",
+         "xml_path": "topmostSubform/page1/treatmentS1Struct/beginDate"},
+        {"id": "2.2", "question": "Quel est le nom du patient ?",
+         "xml_path": "topmostSubform/page1/patientS1Address/lastName"},
+    ])
+    by_id = {f["id"]: f for f in prepared}
+    assert "période d'incapacité de travail n°1 sur 3" in by_id["1.10"]["prompt_question"]
+    assert "période d'incapacité de travail n°3 sur 3" in by_id["1.14"]["prompt_question"]
+    # Même question, autre structure : pas de numérotation partagée.
+    assert "Contexte : traitement." in by_id["2.1"]["prompt_question"]
+    # Question unique : inchangée.
+    assert by_id["2.2"]["prompt_question"] == "Quel est le nom du patient ?"
+    assert by_id["1.10"]["retrieval_query"].endswith("période d'incapacité de travail")
+
+
+def test_repeated_siblings_without_known_struct():
+    prepared = contextualize([
+        {"id": "1.1", "question": "Téléphone du patient ?", "xml_path": "t/p/patientS1Address/phone"},
+        {"id": "1.2", "question": "Téléphone du patient ?", "xml_path": "t/p/patientS1Address/phone[1]"},
+    ])
+    assert "occurrence n°1 sur 2" in prepared[0]["prompt_question"]
+    assert "occurrence n°2 sur 2" in prepared[1]["prompt_question"]
+
+
+def test_prefixed_diagnosis_structs_share_numbering():
+    prepared = contextualize([
+        {"id": f"4.{i}", "question": "Quel est le libellé du diagnostic posé ?",
+         "xml_path": f"t/page1/{p}diagnosisS1Struct/name"}
+        for i, p in enumerate("abde", start=1)
+    ])
+    assert "diagnostic n°4 sur 4" in prepared[3]["prompt_question"]
+
+
+def test_retrieval_text_drops_format_instructions():
+    q = "Quel est le canton ? Répondre UNIQUEMENT par deux lettres (ex. : NE, VD, GE)."
+    assert retrieval_text(q) == "Quel est le canton ?"
+    assert retrieval_text("Date ? [format : JJ.MM.AAAA]") == "Date ?"
+
+
+def test_batches_keep_repeated_structures_together():
+    fields = contextualize(
+        [{"id": f"1.{i}", "question": f"Q{i} ?", "xml_path": f"t/p/f{i}"} for i in range(1, 4)]
+        + _period_fields()
+    )
+    batches = batch_fields(fields, max_batch_size=2)
+    period_batch = next(b for b in batches if any(f["id"] == "1.10" for f in b))
+    assert {f["id"] for f in period_batch} == {f["id"] for f in _period_fields()}
+    assert all(len(b) <= 2 for b in batches if b is not period_batch)
+
+
+def test_every_catalogue_form_prepares_and_batches():
+    for path in sorted(TEMPLATE_DIR.glob("Form_*.json")):
+        template = json.loads(path.read_text(encoding="utf-8"))
+        fields = prepare_fields(template)
+        batches = batch_fields(fields)
+        assert sorted(f["id"] for b in batches for f in b) == sorted(f["id"] for f in fields), path.name
+        assert all(len(b) <= 32 for b in batches), path.name
+
+
+# --- Valeurs ------------------------------------------------------------------------
+
+@pytest.mark.parametrize("raw", [
+    "Non mentionné", "non précisé dans les documents", "N/A", "null", "...", "…", "Inconnu",
+    "<nom>", "JJ.MM.AAAA", "756.XXXX.XXXX.XX", "Information non disponible", "-",
+])
+def test_null_like_answers_become_empty(raw):
+    assert normalize_value(raw, {}) == ""
+
+
+@pytest.mark.parametrize("raw", ["non", "Aucun", "Aucune allergie connue", "x"])
+def test_real_answers_survive(raw):
+    assert normalize_value(raw, {}) == raw
+
+
+@pytest.mark.parametrize("raw, expected", [
+    ("2025-03-15", "15.03.2025"),
+    ("15/3/2025", "15.03.2025"),
+    ("15 mars 2025", "15.03.2025"),
+    ("1er février 2024", "01.02.2024"),
+    ("dès le 07.04.2026", "07.04.2026"),
+    ("du 01.01.2025 au 31.01.2025", "du 01.01.2025 au 31.01.2025"),
+    ("31.02.2025", "31.02.2025"),
+])
+def test_normalize_date(raw, expected):
+    assert normalize_date(raw) == expected
+
+
+@pytest.mark.parametrize("raw, kind, expected", [
+    ("Oui", "bool", "oui"), ("On", "bool", "oui"), ("1", "bool", "oui"),
+    ("Non, pas d'urgence", "bool", "non"), ("peut-être", "bool", ""),
+    ("Madame", "sex", "F"), ("Monsieur", "sex", "M"), ("masculin", "sex", "M"),
+    ("50 %", "percent", "50"), ("12 séances", "int", "12"),
+    (["Lombalgie", "HTA"], None, "Lombalgie\nHTA"), (42.0, None, "42"), (True, None, "oui"),
+])
+def test_normalize_value_by_type(raw, kind, expected):
+    assert normalize_value(raw, {"type": kind}) == expected
+
+
+def test_choice_option_that_looks_null_is_kept():
+    assert normalize_value("Inconnue", {"type": "choice", "options": ["Maladie", "Inconnue"]}) == "Inconnue"
+
+
+@pytest.mark.parametrize("value, expected", [
+    ("oui", "1"), ("Oui", "1"), ("1", "1"), ("non", "0"), ("peut-être", "peut-être"),
+])
+def test_resolve_option(value, expected):
+    field = {"options": ["non", "oui (= Major RF)"], "option_values": ["0", "1"]}
+    assert resolve_option(value, field) == expected
+
+
+def test_collect_form_values_routes_types_and_recipient():
+    template = {
+        "_recipient_by_canton": {"NE": {"recipientBlock": "Office AI NE", "street": "Espacité 4"}},
+        "fields": [
+            {"id": "1.1", "name": "treatmentCanton", "type": "choice", "options": ["NE", "VD"],
+             "xml_path": "a/treatmentCanton", "acroform_name": "a.treatmentCanton"},
+            {"id": "1.2", "name": "urgent", "type": "bool", "options": ["On", "Off"],
+             "xml_path": "a/urgent", "acroform_name": "a.urgent"},
+            {"id": "1.3", "name": "ask", "type": "choice", "options": ["non", "oui"],
+             "option_values": ["0", "1"], "xml_path": "a/ask", "acroform_name": "a.ask"},
+            {"id": "1.4", "name": "birthDate", "type": "date", "xml_path": "a/birthDate"},
+            {"id": "1.5", "name": "recipientBlock", "xml_path": "a/recipientBlock",
+             "acroform_name": "a.recipientBlock"},
+            {"id": "1.6", "name": "footer", "computed": "Pied de page", "acroform_name": "a.footer"},
+            {"id": "1.7", "name": "remark", "xml_path": "a/remark"},
+            {"id": "1.8", "name": "street", "xml_path": "a/patientS1Address/street"},
+            {"id": "1.9", "name": "street", "xml_path": "a/insuranceS1Address/street", "preset": "Rue BE"},
+        ],
+    }
+    results = [
+        {"id": "1.1", "result": {"value": "NE"}},
+        {"id": "1.2", "result": {"value": "oui"}},
+        {"id": "1.3", "result": {"value": "oui"}},
+        {"id": "1.4", "result": {"value": "2024-02-01"}},
+        {"id": "1.7", "result": {"value": "non mentionné"}},
+        {"id": "1.8", "result": {"value": "Rue du Lac 12"}},
+        {"id": "9.9", "error": "extraction_failed"},
+    ]
+    xfa, acro = collect_form_values(template, results)
+    assert xfa["a/urgent"] == "On" and acro["a.urgent"] == "1"
+    assert xfa["a/ask"] == "1" and acro["a.ask"] == "1"
+    assert xfa["a/birthDate"] == "01.02.2024"
+    assert xfa["a/recipientBlock"] == "Office AI NE"
+    assert acro["a.footer"] == "Pied de page"
+    assert "a/remark" not in xfa
+    # La table cantonale vise le bloc de l'office, pas l'homonyme du patient.
+    assert xfa["a/insuranceS1Address/street"] == "Espacité 4"
+    assert xfa["a/patientS1Address/street"] == "Rue du Lac 12"
+
+
+def test_procedure_slots_are_not_numbered_as_diagnoses():
+    """Blocs `d`/`e` codés CHOP : interventions, numérotées à part des diagnostics."""
+    template = json.loads((TEMPLATE_DIR / "Form_LAA_PriseEnChargeHospitaliere.json").read_text(encoding="utf-8"))
+    by_path = {f["xml_path"]: f for f in prepare_fields(template)}
+    assert "diagnostic n°2 sur 2" in by_path["topmostSubform/page1/bdiagnosisS1Struct/name"]["prompt_question"]
+    procedure = by_path["topmostSubform/page1/ediagnosisS1Struct/code"]
+    assert "CHOP" in procedure["question"]
+    assert "intervention n°2 sur 2" in procedure["prompt_question"]
diff --git a/services/orchestrator/tests/test_fill.py b/services/orchestrator/tests/test_fill.py
new file mode 100644
index 0000000..7a0aece
--- /dev/null
+++ b/services/orchestrator/tests/test_fill.py
@@ -0,0 +1,56 @@
+"""Écriture des valeurs dans le PDF : AcroForm, datasets XFA, cases à cocher."""
+
+from core.acroform import fill_acroform
+from core.checkbox import normalize_checkboxes
+from core.fill import update_datasets
+from tests.pdf_factory import make_acroform, read_fields
+
+
+def test_fill_acroform_text_checkbox_and_choice(tmp_path):
+    blank = make_acroform(tmp_path / "blank.pdf", [
+        ("lastName", "text", {}),
+        ("urgent", "checkbox", {}),
+        ("notUrgent", "checkbox", {}),
+        ("ask4Hospitalization", "combo", {"opt": [("0", "non"), ("1", "oui")]}),
+        ("reason", "combo", {"opt": [("M", "Maladie"), ("A", "Accident")]}),
+    ])
+    out = tmp_path / "out.pdf"
+    filled = fill_acroform(blank, {
+        "lastName": "Dupont", "urgent": "1", "notUrgent": "0",
+        "ask4Hospitalization": "1", "reason": "Accident",
+    }, out)
+    assert filled == {"lastName", "urgent", "notUrgent", "ask4Hospitalization", "reason"}
+
+    fields = read_fields(out)
+    assert fields["lastName"]["V"] == "Dupont" and "(Dupont) Tj" in fields["lastName"]["ap_text"]
+    assert fields["urgent"]["V"] == "/On" and fields["urgent"]["AS"] == "/On"
+    assert fields["notUrgent"]["V"] == "/Off" and fields["notUrgent"]["AS"] == "/Off"
+    # Export dans /V, libellé à l'écran — dans les deux sens d'appariement.
+    assert fields["ask4Hospitalization"]["V"] == "1"
+    assert "(oui) Tj" in fields["ask4Hospitalization"]["ap_text"]
+    assert fields["reason"]["V"] == "A"
+    assert "(Accident) Tj" in fields["reason"]["ap_text"]
+
+
+def test_update_datasets_keeps_checkbox_states(tmp_path):
+    src = tmp_path / "base.xml"
+    src.write_text(
+        '<xfa:datasets xmlns:xfa="http://www.xfa.org/schema/xfa-data/1.0/"><xfa:data>'
+        "<form><page1><urgent>Off</urgent><hosp/><phone/><phone/></page1></form>"
+        "</xfa:data></xfa:datasets>", encoding="utf-8")
+    dst = tmp_path / "filled.xml"
+    fields = [{"xml_path": "form/page1/urgent", "type": "bool"},
+              {"xml_path": "form/page1/hosp", "type": "bool"}]
+    update_datasets(src, {"form/page1/urgent": "On", "form/page1/hosp": "oui",
+                          "form/page1/phone[1]": "079 000 00 00"}, dst, fields)
+    xml = dst.read_text(encoding="utf-8")
+    # « On » n'est plus ramené à « 0 », « oui » coche la case.
+    assert "<urgent>On</urgent>" in xml
+    assert "<hosp>1</hosp>" in xml
+    assert "<phone /><phone>079 000 00 00</phone>" in xml.replace("<phone/>", "<phone />")
+
+
+def test_normalize_checkboxes_understands_french():
+    values = {"a": "oui", "b": "non", "c": "Dupont"}
+    normalize_checkboxes(values, ["a", "b"])
+    assert values == {"a": "On", "b": "Off", "c": "Dupont"}
diff --git a/services/orchestrator/tests/test_pipeline.py b/services/orchestrator/tests/test_pipeline.py
new file mode 100644
index 0000000..43c077a
--- /dev/null
+++ b/services/orchestrator/tests/test_pipeline.py
@@ -0,0 +1,338 @@
+"""
+Pipeline complet, services simulés : OCR → embeddings → synthèse → extraction →
+remplissage, puis re-run et chat.
+
+Le transport httpx remplace marker, TEI et vLLM ; le formulaire est un vrai PDF
+AcroForm (tests/pdf_factory.py) et le remplissage passe par le code de
+production. Ce qui est vérifié, c'est l'enchaînement : qu'un document illisible
+n'emporte pas le job, que le re-run écrive les mêmes champs dérivés que le
+premier passage, que le dossier soit transmis en entier quand il tient.
+"""
+
+import asyncio
+import json
+import re
+import time
+from pathlib import Path
+
+import httpx
+import pytest
+from fastapi.testclient import TestClient
+
+import app as orchestrator
+import medical_synthesis
+from tests import fakes
+from tests.pdf_factory import make_acroform, read_fields
+
+DOCS = {
+    "01_fiche.pdf": (
+        "# Fiche administrative\n\n## Identité\n\n- Nom : DUPONT\n- Prénom : Jeanne\n"
+        "- Date de naissance : 02.02.1985\n- Canton : Neuchâtel (NE)\n\n"
+        "## Contexte\n\nConsultation en urgence pour lombalgie aiguë, patiente hospitalisée."
+    ),
+    "02_consultation.pdf": (
+        "# Consultation du 09.04.2026\n\nLombalgie aiguë (M54.5). Incapacité de travail à 100 % "
+        "du 09.04.2026 au 30.04.2026."
+    ),
+    "03_scan_illisible.pdf": None,  # le service OCR échoue sur celui-ci
+}
+
+# Réponses du « modèle » : ce qu'un LLM rendrait, écarts de format compris.
+LLM_ANSWERS = {
+    "1.1": {"value": "NE", "source_quote": "Canton : Neuchâtel (NE)"},
+    "1.2": {"value": "DUPONT", "source_quote": "Nom : DUPONT"},
+    "1.3": {"value": "1985-02-02", "source_quote": "Date de naissance : 02.02.1985"},
+    "1.4": {"value": "Oui", "source_quote": "Consultation en urgence"},
+    "1.5": {"value": "oui", "source_quote": "patiente hospitalisée"},
+    "1.6": {"value": "Non mentionné", "source_quote": ""},
+}
+
+SYNTHESIS = {"patient": {"nom": "DUPONT", "prenom": "Jeanne"}, "diagnostics": [],
+             "incapacites_travail": [], "canton_traitement": "NE"}
+
+
+def _template():
+    return {
+        "_reviewed": True,
+        "_recipient_by_canton": {"NE": {"recipientBlock": "Office AI du canton de Neuchâtel"},
+                                 "VD": {"recipientBlock": "Office AI du canton de Vaud"}},
+        "fields": [
+            {"comments": "Section 1"},
+            {"id": "1.1", "name": "treatmentCanton", "question": "Canton de traitement ?",
+             "type": "choice", "options": ["NE", "VD"], "acroform_name": "treatmentCanton"},
+            {"id": "1.2", "name": "lastName", "question": "Nom du patient ?", "acroform_name": "lastName"},
+            {"id": "1.3", "name": "birthDate", "question": "Date de naissance ? [format : JJ.MM.AAAA]",
+             "type": "date", "acroform_name": "birthDate"},
+            {"id": "1.4", "name": "urgent", "question": "Consultation urgente ? Répondre par oui ou non.",
+             "type": "bool", "options": ["On", "Off"], "preset": "/Off", "acroform_name": "urgent"},
+            {"id": "1.5", "name": "ask4Hospitalization", "question": "Hospitalisé ? Répondre par oui ou non.",
+             "type": "choice", "options": ["non", "oui"], "option_values": ["0", "1"], "preset": "0",
+             "acroform_name": "ask4Hospitalization"},
+            {"id": "1.6", "name": "email", "question": "E-mail du patient ?", "acroform_name": "email"},
+            {"id": "1.7", "name": "insurance", "question": "Régime ?", "type": "choice",
+             "options": ["LAA", "LCA"], "preset": "LAA", "acroform_name": "insurance"},
+            {"id": "2.1", "name": "recipientBlock", "acroform_name": "recipientBlock", "computed": ""},
+            {"id": "2.2", "name": "footer", "acroform_name": "footer", "computed": "DoctorFill — test"},
+        ],
+    }
+
+
+class FakeServices:
+    """Marker, TEI et vLLM derrière un seul transport httpx."""
+
+    def __init__(self):
+        self.extraction_prompts: list[str] = []
+        self.ocr_calls: dict[str, int] = {}
+
+    def handler(self, request: httpx.Request) -> httpx.Response:
+        path = request.url.path
+        if path.endswith("/extract"):
+            body = request.content.decode("latin-1")
+            name = re.search(r'filename="([^"]+)"', body).group(1)
+            self.ocr_calls[name] = self.ocr_calls.get(name, 0) + 1
+            if DOCS[name] is None:
+                return httpx.Response(500, json={"detail": "Erreur lors de l'extraction du PDF."})
+            return httpx.Response(200, json={"markdown": DOCS[name], "status": "success"})
+        if path.endswith("/embed"):
+            return fakes.embed_response(request)
+        if path.endswith("/rerank"):
+            return fakes.rerank_response(request)
+        if path.endswith("/chat/completions"):
+            body = json.loads(request.content)
+            system = body["messages"][0]["content"]
+            if "médecin expert" in system:
+                content = json.dumps(SYNTHESIS)
+            else:
+                self.extraction_prompts.append(body["messages"][1]["content"])
+                ids = list(body["response_format"]["json_schema"]["schema"]["properties"])
+                content = json.dumps({i: LLM_ANSWERS[i] for i in ids})
+            return httpx.Response(200, json={"choices": [{"message": {"content": content},
+                                                          "finish_reason": "stop"}]})
+        return httpx.Response(404)
+
+
+@pytest.fixture
+def workspace(tmp_path, monkeypatch):
+    """Répertoire de travail de l'orchestrateur : template/, forms/, dossiers uploadés."""
+    monkeypatch.chdir(tmp_path)
+    (tmp_path / "template").mkdir()
+    (tmp_path / "forms").mkdir()
+    (tmp_path / "template" / "Form_Test.json").write_text(json.dumps(_template()), encoding="utf-8")
+    make_acroform(tmp_path / "forms" / "Form_Test.pdf", [
+        ("treatmentCanton", "combo", {"opt": [("NE", "NE"), ("VD", "VD")]}),
+        ("lastName", "text", {}), ("birthDate", "text", {}), ("urgent", "checkbox", {}),
+        ("ask4Hospitalization", "combo", {"opt": [("0", "non"), ("1", "oui")]}),
+        ("email", "text", {}), ("insurance", "text", {}), ("recipientBlock", "text", {}),
+        ("footer", "text", {}),
+    ])
+    uploads = tmp_path / "uploads"
+    uploads.mkdir()
+    for name in DOCS:
+        (uploads / name).write_bytes(b"%PDF-1.4 " + name.encode())
+
+    services = FakeServices()
+    # Résolu à chaque requête : un test peut remplacer services.handler en cours de route.
+    fakes.install(monkeypatch, lambda request: services.handler(request))
+    monkeypatch.setattr(orchestrator, "VALID_FORM_IDS", {"Test"})
+    return tmp_path, uploads, services
+
+
+def _start_job(tmp_path: Path, uploads: Path) -> str:
+    job_id = f"test{time.time_ns():x}"
+    orchestrator.JOBS[job_id] = {"status": "pending", "progress": 0, "token": "secret",
+                                 "started_at": time.time()}
+    tmp_dir = tmp_path / "job"
+    tmp_dir.mkdir(exist_ok=True)
+    asyncio.run(orchestrator.run_pipeline_task(job_id, "Test", tmp_dir, sorted(uploads.glob("*.pdf"))))
+    return job_id
+
+
+def test_pipeline_fills_form_and_survives_unreadable_document(workspace):
+    tmp_path, uploads, services = workspace
+    job_id = _start_job(tmp_path, uploads)
+    job = orchestrator.JOBS[job_id]
+
+    assert job["status"] == "completed", job.get("message")
+    assert any("03_scan_illisible.pdf" in w for w in job["warnings"])
+    # Une erreur 5xx de l'OCR est rejouée une fois, pas cinq.
+    assert services.ocr_calls["03_scan_illisible.pdf"] == 2
+
+    # Dossier court : transmis en entier, identique pour tous les lots.
+    assert services.extraction_prompts
+    assert all("DOCUMENTS DU DOSSIER (texte intégral)" in p for p in services.extraction_prompts)
+    assert all("=== DOCUMENT : 01_fiche.pdf ===" in p for p in services.extraction_prompts)
+    # Le preset d'éditeur n'est pas soumis ; la case vierge et la question oui/non le sont.
+    asked = "\n".join(services.extraction_prompts)
+    assert "[1.7]" not in asked and "[1.4]" in asked and "[1.5]" in asked
+
+    fields = read_fields(Path(job["file_path"]))
+    assert fields["lastName"]["V"] == "DUPONT"
+    assert fields["birthDate"]["V"] == "02.02.1985"          # date ISO normalisée
+    assert fields["urgent"]["V"] == "/On"                     # « Oui » coche la case
+    assert fields["ask4Hospitalization"]["V"] == "1"          # libellé → valeur d'export
+    assert fields["email"]["V"] is None                       # « Non mentionné » n'est pas écrit
+    assert fields["recipientBlock"]["V"] == "Office AI du canton de Neuchâtel"
+    assert fields["footer"]["V"] == "DoctorFill — test"
+
+    results = {r["id"]: r["result"] for r in job["_debug_results"]}
+    assert results["1.3"]["value"] == "02.02.1985" and results["1.3"]["raw_value"] == "1985-02-02"
+    assert results["1.6"]["value"] == ""
+    assert results["1.2"]["grounding"] == "verified"
+    assert results["1.4"]["grounding"] == "inferred"          # « oui » : justifié par la citation seule
+
+
+def test_rerun_writes_the_same_derived_fields(workspace):
+    tmp_path, uploads, services = workspace
+    job_id = _start_job(tmp_path, uploads)
+    services.extraction_prompts.clear()
+
+    asyncio.run(orchestrator.rerun_pipeline_task(job_id))
+    job = orchestrator.JOBS[job_id]
+    assert job["status"] == "completed", job.get("message")
+    assert job["file_path"].endswith("output_rerun.pdf")
+    fields = read_fields(Path(job["file_path"]))
+    # Le re-run perdait le destinataire cantonal et les champs calculés.
+    assert fields["recipientBlock"]["V"] == "Office AI du canton de Neuchâtel"
+    assert fields["footer"]["V"] == "DoctorFill — test"
+    assert fields["urgent"]["V"] == "/On"
+    assert services.extraction_prompts
+
+
+def test_job_fails_with_actionable_message_when_nothing_is_readable(workspace, monkeypatch):
+    tmp_path, uploads, _ = workspace
+    for name in list(DOCS):
+        monkeypatch.setitem(DOCS, name, None)
+    job_id = _start_job(tmp_path, uploads)
+    job = orchestrator.JOBS[job_id]
+    assert job["status"] == "failed"
+    assert "Aucun texte" in job["message"]
+
+
+def test_synthesis_failure_does_not_block_extraction(workspace, monkeypatch):
+    tmp_path, uploads, _ = workspace
+
+    async def _broken(*_a, **_k):
+        return None
+    monkeypatch.setattr(orchestrator, "run_medical_synthesis", _broken)
+    job_id = _start_job(tmp_path, uploads)
+    job = orchestrator.JOBS[job_id]
+    assert job["status"] == "completed"
+    assert any("Synthèse" in w for w in job["warnings"])
+
+
+def test_chat_requires_the_job_token(workspace):
+    tmp_path, uploads, _ = workspace
+    job_id = _start_job(tmp_path, uploads)
+    client = TestClient(orchestrator.app)
+    resp = client.post("/chat", json={"job_id": job_id, "message": "Diagnostic ?"})
+    assert resp.status_code == 403
+    status = client.get(f"/status/{job_id}").json()
+    assert status["status"] == "completed" and status["warnings"]
+    fields = client.get(f"/fields/{job_id}", params={"token": "secret"}).json()["fields"]
+    assert {f["id"] for f in fields} >= {"1.4", "1.5"}
+    assert client.get(f"/fields/{job_id}", params={"token": "nope"}).status_code == 403
+
+
+def test_synthesis_falls_back_to_hierarchical(monkeypatch):
+    calls = []
+
+    async def fake_call(system, user, url, model, **kwargs):
+        calls.append(system)
+        if system == medical_synthesis.SYSTEM_PROMPT_SYNTHESIS:
+            raise medical_synthesis._Unrecoverable("réponse tronquée")
+        if system == medical_synthesis.SYSTEM_PROMPT_PER_DOC_SUMMARY:
+            name = re.search(r"DOCUMENT : (.+)", user).group(1)
+            return json.dumps({"document": name, "patient": {"nom": "DUPONT"},
+                               "diagnostics": [{"description": f"dx {name}"}]})
+        raise medical_synthesis._Unrecoverable("fusion impossible")
+
+    monkeypatch.setattr(medical_synthesis, "_call_llm", fake_call)
+    result = asyncio.run(medical_synthesis.run_medical_synthesis(
+        [{"filename": "b.pdf", "markdown": "texte b"}, {"filename": "a.pdf", "markdown": "texte a"}],
+        "http://vllm", "model"))
+    # Directe → hiérarchique → fusion déterministe : rien n'est perdu.
+    assert [d["description"] for d in result["diagnostics"]] == ["dx a.pdf", "dx b.pdf"]
+    assert result["patient"]["nom"] == "DUPONT"
+    assert calls[0] == medical_synthesis.SYSTEM_PROMPT_SYNTHESIS
+
+
+def test_long_documents_are_split_for_summaries():
+    text = "\n\n".join(f"Paragraphe {i} " + "mot " * 200 for i in range(60))
+    parts = medical_synthesis._split_document("long.pdf", text, max_tokens=2000)
+    assert len(parts) > 1
+    assert parts[0][0] == f"long.pdf (partie 1/{len(parts)})"
+    assert "".join(p for _, p in parts).replace("\n", "") == text.replace("\n", "")
+
+
+def test_expired_jobs_take_their_debug_logs_with_them(workspace):
+    tmp_path, uploads, _ = workspace
+    job_id = _start_job(tmp_path, uploads)
+    debug_dir = Path(orchestrator.JOBS[job_id]["_debug_dir"])
+    assert (debug_dir / "markdown" / "01_fiche.md").exists()
+    orchestrator.JOBS[job_id]["completed_at"] = time.time() - orchestrator.JOB_RETENTION_SECONDS - 1
+    orchestrator._purge_expired_jobs()
+    assert job_id not in orchestrator.JOBS
+    assert not debug_dir.exists()
+
+
+def test_embedding_outage_degrades_instead_of_failing(workspace, monkeypatch):
+    tmp_path, uploads, services = workspace
+    real = services.handler
+
+    def handler(request):
+        if request.url.path.endswith("/embed"):
+            return httpx.Response(503, text="TEI down")
+        return real(request)
+    monkeypatch.setattr(services, "handler", handler)
+
+    job_id = _start_job(tmp_path, uploads)
+    job = orchestrator.JOBS[job_id]
+    assert job["status"] == "completed", job.get("message")
+    assert any("Recherche sémantique" in w for w in job["warnings"])
+    assert read_fields(Path(job["file_path"]))["lastName"]["V"] == "DUPONT"
+
+
+def test_field_error_warning_is_recomputed_on_each_pass():
+    job = {"warnings": ["Document illisible, ignoré : x.pdf"]}
+    orchestrator._record_field_errors(job, [{"id": "1.1", "error": "extraction_failed"}, {"id": "1.2"}])
+    assert job["warnings"][-1].startswith("1 champ(s)")
+    orchestrator._record_field_errors(job, [{"id": "1.1", "result": {}}])
+    assert job["warnings"] == ["Document illisible, ignoré : x.pdf"]
+
+
+def test_retrieval_outage_on_large_dossier_degrades(workspace, monkeypatch):
+    """Dossier au-delà du mode intégral, TEI tombé au moment d'encoder les questions."""
+    tmp_path, uploads, services = workspace
+    import extraction
+    monkeypatch.setattr(extraction, "FULL_CONTEXT_MAX_TOKENS", 10)
+
+    async def _down(*_a, **_k):
+        raise httpx.ConnectError("TEI down")
+    monkeypatch.setattr(orchestrator, "fetch_question_embeddings", _down)
+
+    job_id = _start_job(tmp_path, uploads)
+    job = orchestrator.JOBS[job_id]
+    assert job["status"] == "completed", job.get("message")
+    assert any("début du dossier" in w for w in job["warnings"])
+    assert "EXTRAITS DE DOCUMENTS" in services.extraction_prompts[0]
+    assert read_fields(Path(job["file_path"]))["lastName"]["V"] == "DUPONT"
+
+
+def test_orphan_files_from_before_a_restart_are_purged(tmp_path, monkeypatch):
+    import os
+    jobs_dir, debug_dir = tmp_path / "jobs", tmp_path / "debug"
+    monkeypatch.setattr(orchestrator, "JOBS_DIR", jobs_dir)
+    monkeypatch.setattr(orchestrator, "DEBUG_LOG_DIR", debug_dir)
+    old = time.time() - orchestrator.JOB_RETENTION_SECONDS - 60
+    stale = [jobs_dir / ("a" * 32), debug_dir / "20260101_000000_aaaaaaaa"]
+    fresh = jobs_dir / ("b" * 32)
+    active = debug_dir / "20260101_000000_cccccccc"
+    for d in stale + [fresh, active]:
+        (d / "markdown").mkdir(parents=True)
+    for d in stale + [active]:
+        os.utime(d, (old, old))
+    monkeypatch.setitem(orchestrator.JOBS, "c" * 32, {"status": "processing", "_debug_dir": str(active)})
+
+    orchestrator._purge_orphan_files()
+    assert not any(d.exists() for d in stale)
+    assert fresh.exists() and active.exists()
diff --git a/services/orchestrator/tools/gen_template.py b/services/orchestrator/tools/gen_template.py
index 522f5da..f146b10 100644
--- a/services/orchestrator/tools/gen_template.py
+++ b/services/orchestrator/tools/gen_template.py
@@ -523,10 +523,29 @@ def _ui_kind(elem: ET.Element) -> str:
     return _tag(ui[0][0])
 
 
+def _item_groups(elem: ET.Element) -> tuple[list[str], list[str]]:
+    """
+    (libellés, valeurs enregistrées) des <items> d'un champ.
+
+    Une liste XFA peut porter deux groupes <items> : les libellés affichés, et
+    les valeurs enregistrées (`save="1"`). Les concaténer donnait des options
+    comme ['non', 'oui', '0', '1'] : le modèle pouvait répondre « 0 », et « oui »
+    n'était jamais traduit en « 1 », donc jamais coché.
+    """
+    shown: list[str] = []
+    saved: list[str] = []
+    for group in _children(elem, "items"):
+        texts = [t.text for t in _children(group, "text") if t.text]
+        (saved if group.get("save") == "1" else shown).extend(texts)
+    if not shown:
+        # Un seul groupe, marqué `save` : il sert aussi de libellé.
+        return saved, []
+    return shown, saved if len(saved) == len(shown) else []
+
+
 def _items(elem: ET.Element) -> list[str]:
-    """Valeurs proposées par le champ (états d'une case, options d'une liste)."""
-    return [t.text for group in _children(elem, "items")
-            for t in _children(group, "text") if t.text]
+    """Valeurs proposées par le champ (états d'une case, libellés d'une liste)."""
+    return _item_groups(elem)[0]
 
 
 # Texte indicatif du gabarit Designer, pas une valeur : « <TT.MM.JJJJ> ».
@@ -613,7 +632,7 @@ def parse_xfa_fields(template_xml: str) -> list[dict[str, Any]]:
         ui = _ui_kind(elem)
         segments = [s.split("[")[0] for s in som_path]
         question, vocab_type = _describe(segments[-1], segments[:-1])
-        options, option_values = _items(elem), []
+        options, option_values = _item_groups(elem)
         field_type = UI_TO_TYPE.get(ui)
         if _tag(elem) == "exclGroup":
             options, option_values = _exclgroup_options(elem)
@@ -833,11 +852,11 @@ def build_template(pdf_path: Path, keep_technical: bool = False,
     entries: list[dict[str, Any]] = []
     reused_keys: set[str | None] = set()
 
-    # Les sections d'un template rédigé encodent un découpage métier que
-    # SECTION_SYNTHESIS_KEYS (prompts.py) exploite pour cibler la synthèse
-    # injectée dans chaque prompt. Une numérotation dérivée des pages XFA le
-    # détruirait : on repart donc du numéro de section existant, et les champs
-    # nouveaux vont dans une section créée après la dernière connue.
+    # Les sections d'un template rédigé encodent un découpage métier : elles
+    # déterminent les lots d'extraction (core/fields.batch_fields), et les IDs
+    # de champs en dérivent. Une numérotation dérivée des pages XFA les
+    # bouleverserait : on repart donc du numéro de section existant, et les
+    # champs nouveaux vont dans une section créée après la dernière connue.
     prior_sections = {
         int(str(f["id"]).split(".")[0])
         for f in prior.values()