test(core): verrouiller le fallback edsnlp sur drugs.json corrompu (revue qualité)

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
fix(core): charger gazetteer médicaments edsnlp depuis data/ (torch-free) + log si absent
2026-07-03 09:42:15 +02:00 · 2026-07-03 09:36:08 +02:00 · 2026-07-03 09:20:53 +02:00 · 2026-07-02 18:18:42 +02:00 · 2026-07-02 18:13:01 +02:00 · 2026-07-02 18:10:20 +02:00
46 changed files with 8913 additions and 227 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -49,6 +49,10 @@ models/
 # build_info.py : régénéré automatiquement par scripts/rebuild_anon.ps1
 # avec date/commit/branch. Ne pas versionner.
 build_info.py
+
+# gui_v6/_build_version.py : généré au build Windows par build_windows_oneclick.ps1
+# (contient BUILD_VERSION = "2026.MM.JJ.HHMM"). Ne pas commiter.
+gui_v6/_build_version.py
 *.mp3
 *.wav
 *.mp4
--- a/anonymisation_cli_onefile.spec
+++ b/anonymisation_cli_onefile.spec
@@ -29,6 +29,7 @@ datas = []
 for relative_path, target_dir in [
    ("config", "config"),
    ("data/bdpm", "data/bdpm"),
+    ("data/edsnlp", "data/edsnlp"),
    ("data/finess", "data/finess"),
    ("data/insee", "data/insee"),
    ("models/camembert-bio-deid/onnx", "models/camembert-bio-deid/onnx"),
@@ -114,11 +115,6 @@ hiddenimports = [
    "yaml",
    "loguru",
    "regex",
-    "optimum",
-    "optimum.onnxruntime",
-    "optimum.pipelines",
-    "optimum.modeling_base",
-    "optimum.exporters.onnx",
 ]


@@ -153,12 +149,24 @@ for _package_name in [
    _collect_optional_package(_package_name)


+# P0-3 (Plan 3) : exclusion dure de la pile torch. Le core fait un
+# `import torch` lazy (try/except no-op) dans _configure_torch_threads que
+# l'analyse statique suivrait ; en frozen l'ImportError est attendue et gérée.
+EXCLUDED_TORCH_STACK = [
+    "torch",
+    "torchvision",
+    "optimum",
+    "doctr",
+]
+
+
 a = Analysis(
    [str(project_dir / "scripts" / "anonymize_cli.py")],
    pathex=[str(project_dir)],
    binaries=binaries,
    datas=datas,
    hiddenimports=hiddenimports,
+    excludes=EXCLUDED_TORCH_STACK,
    cipher=block_cipher,
    noarchive=False,
 )
--- a/anonymisation_gui_v6_onefile.spec
+++ b/anonymisation_gui_v6_onefile.spec
@@ -26,6 +26,7 @@ datas = []
 for relative_path, target_dir in [
    ("config", "config"),
    ("data/bdpm", "data/bdpm"),
+    ("data/edsnlp", "data/edsnlp"),
    ("data/finess", "data/finess"),
    ("data/insee", "data/insee"),
    ("models/camembert-bio-deid/onnx", "models/camembert-bio-deid/onnx"),
@@ -78,6 +79,8 @@ hiddenimports = [
    "gui_v6.machine_id",
    "gui_v6.engine_bridge",
    "gui_v6.config_state",
+    "gui_v6.version",
+    "gui_v6._build_version",
    "gui_v6.processing_runner",
    "gui_v6.tabs",
    "gui_v6.tabs.tab_about",
@@ -133,11 +136,16 @@ hiddenimports = [
    "yaml",
    "loguru",
    "regex",
+]
+
+# P0-3 (Plan 3) : exclusion dure de la pile torch. Le core fait un
+# `import torch` lazy (try/except no-op) dans _configure_torch_threads que
+# l'analyse statique suivrait ; en frozen l'ImportError est attendue et gérée.
+EXCLUDED_TORCH_STACK = [
+    "torch",
+    "torchvision",
    "optimum",
-    "optimum.onnxruntime",
-    "optimum.pipelines",
-    "optimum.modeling_base",
-    "optimum.exporters.onnx",
+    "doctr",
 ]


@@ -146,6 +154,7 @@ a = Analysis(
    pathex=[str(project_dir)],
    datas=datas,
    hiddenimports=hiddenimports,
+    excludes=EXCLUDED_TORCH_STACK,
    cipher=block_cipher,
    noarchive=False,
 )
--- a/anonymizer_core_refactored_onnx.py
+++ b/anonymizer_core_refactored_onnx.py
--- a/data/edsnlp/README.md
+++ b/data/edsnlp/README.md
@@ -0,0 +1,32 @@
+# data/edsnlp — Gazetteer médicaments (extrait de edsnlp)
+
+## Contenu
+
+- `drugs.json` : dictionnaire code ATC → liste de noms de médicaments (1968 codes),
+  extrait de **edsnlp 0.20.0**, fichier `edsnlp/resources/drugs.json`.
+
+## Usage
+
+Ce fichier alimente `_load_edsnlp_drug_names()` dans
+`anonymizer_core_refactored_onnx.py`. Les noms mono-mot de longueur ≥ 4 sont
+chargés (en minuscules) comme **gazetteer anti-faux-positif** : ils empêchent
+que des noms de médicaments (ex. « elisor », « kessar », « muse », « sirop »)
+soient pris à tort pour des noms de personnes et sur-masqués.
+
+Il est versionné dans le dépôt (et non lu depuis le package `edsnlp` au
+runtime) afin que la whitelist médicaments reste complète dans le build Windows
+**torch-free** (Plan 3), où `edsnlp` — qui importe `torch` en dur — n'est pas
+disponible.
+
+## Attribution / Licence
+
+`drugs.json` provient du projet **edsnlp**, distribué sous licence
+**BSD-3-Clause**.
+
+> Copyright (c) 2021, Assistance Publique - Hôpitaux de Paris
+>
+> Redistribution and use in source and binary forms, with or without
+> modification, are permitted under the terms of the BSD-3-Clause license.
+
+Source : https://github.com/aphp/edsnlp — `edsnlp/resources/drugs.json`
+(version 0.20.0).
--- a/data/edsnlp/drugs.json
+++ b/data/edsnlp/drugs.json
--- a/docs/beta/2026-07-02_plan3-reference-docs-reels.md
+++ b/docs/beta/2026-07-02_plan3-reference-docs-reels.md
@@ -0,0 +1,39 @@
+# Référence détections — 6 documents réels (Plan 3, avant build torch-free)
+
+Établie sur HEAD `7dba401` (.venv Linux, chemin dev). Sert de comparaison au smoke
+Windows torch-free (Task 8). **AUCUNE valeur PII — compteurs uniquement.**
+
+Les documents sont identifiés par leur **numéro de dossier** du corpus interne
+(jamais par un nom de patient). ⚠️ **RGPD** : ces numéros de dossier sont des
+**identifiants indirects** — usage **interne** uniquement. Avant toute diffusion
+externe de ce fichier, les remplacer par des étiquettes neutres (`DOC-A`, `DOC-B`…). Les sorties de traitement sont restées dans `/tmp`
+(non commité). Les compteurs proviennent du champ `kind` de l'audit `.audit.jsonl`
+produit par `scripts/anonymize_cli.py` (contrat de production : burn raster +
+texte pseudonymisé + audit JSONL). Le champ `original` (la valeur détectée) n'a
+jamais été lu ni recopié.
+
+## Environnement de référence
+
+- `pytest tests/unit` = **499 passed / 0 failed** (7 warnings, 0 fail).
+- `pytest -k synthetic_regression` = **PASS** (11 passed, 488 deselected) — gate strict de non-régression du masquage.
+- CamemBERT-bio ONNX v3 chargé (obligatoire) ✓ ; EDS-Pseudo chargé (optionnel) ✓ ; GLiNER désactivé (défaut).
+- Chemin dev : `torch=2.10.0+cu128` présent dans l'environnement (c'est précisément ce que le build Windows torch-free retirera). CamemBERT-bio tourne déjà via onnxruntime, indépendant de torch.
+
+## Détections par document
+
+| Doc (n° dossier) | Type   | Pages | ocr_used | Code | Total dét. | Détections par type (kind) |
+|------------------|--------|-------|----------|------|------------|-----------------------------|
+| 102_23056463     | natif  | 2     | False    | 0    | 104        | NOM:31 RPPS:24 ETAB:18 TEL:10 VILLE_GAZ:4 CODE_POSTAL:3 DATE_NAISSANCE:3 EMAIL:2 EPISODE:2 FAX:2 FINESS:2 IPP:2 VILLE:1 |
+| 101_23041413     | natif  | 1     | False    | 0    | 22         | NOM:7 CODE_POSTAL:6 NOM_INITIAL:4 ADRESSE:2 NOM_FORCE:2 VILLE:1 |
+| 103_23056749     | natif  | 2     | False    | 0    | 109        | NOM:33 RPPS:24 ETAB:18 TEL:10 VILLE_GAZ:5 CODE_POSTAL:3 DATE_NAISSANCE:3 EMAIL:2 EPISODE:2 FAX:2 FINESS:2 IPP:2 ADRESSE:1 ETAB_FINESS:1 VILLE:1 |
+| 192_23132490     | scanné | 1     | True     | 0    | 17         | NOM:7 CODE_POSTAL:3 ETAB_FINESS:2 TEL:2 DATE_NAISSANCE:1 NOM_FORCE:1 URL:1 |
+| 19_23103383      | scanné | 1     | True     | 0    | 15         | NOM:4 CODE_POSTAL:2 ETAB_FINESS:2 TEL:4 DATE_NAISSANCE:1 NOM_FORCE:1 VILLE_GAZ:1 |
+| 258_23208848     | scanné | 1     | True     | 0    | 16         | ETAB:4 NOM:3 AGE:2 CODE_POSTAL:2 NOM_FORCE:2 ETAB_FINESS:1 TEL:1 VILLE:1 |
+
+## Notes
+
+- **3 natifs / 3 scannés confirmés** : les 3 natifs ont `ocr_used=False` (texte extractible directement) ; les 3 scannés ont `ocr_used=True` (image-only → OCR docTR/OnnxTR). Les 6 codes retour CLI = **0**.
+- Tous les documents ont `quarantine_flags=[]` (aucune mise en quarantaine).
+- **Tout écart de compteur au smoke Windows (Task 8) = signal de régression torch-free à investiguer.** La comparaison doit se faire par (doc, type de kind, nombre), pas seulement sur le total.
+- **Point de vigilance edsnlp/drugs.json (revue Task 2)** : si des compteurs de type médicament (ou une variation des NOM/ETAB liée au filtrage médicaments) diffèrent en frozen, c'est potentiellement la perte du gazetteer edsnlp — voir mission Qwen. Aucun `kind` explicitement « médicament » n'apparaît dans l'audit de ces 6 docs (les médicaments servent de stop-words/whitelist, pas de type détecté), donc surveiller surtout une **hausse anormale de NOM/ETAB** en frozen (faux positifs par perte du filtre).
+- Rappel : les compteurs d'audit incluent l'ensemble du pipeline (NER multi-signal + regex + gazetteers après cross-validation), ce qui explique un total supérieur au seul « NER-first: N détections » visible dans les logs.
--- a/docs/beta/runbook-portail-beta.md
+++ b/docs/beta/runbook-portail-beta.md
@@ -20,6 +20,15 @@ récupérer la GUI et d'activer sa licence.
  (le cookie Secure confirme que le fix `884661a` tourne — APP_ENV=production).

 ## 1. Publier l'installateur GUI comme artefact actif
+
+**Avant l'upload — vérifications obligatoires :**
+
+- [ ] Vérifier l'URL portail embarquée dans l'EXE fraîchement buildé :
+  lancer l'EXE avec `--self-test` et contrôler dans le log que
+  `resolve_portal_url()` retourne `https://app.aivanov.eu` (pas localhost).
+- [ ] Mettre à jour le SHA-256 dans `note-beta-client.md` (le SHA change à
+  chaque rebuild — l'ancienne note devient caduque, P1-8).
+
 **Pré-requis : l'EXE Windows doit d'abord être copié sur le serveur Linux** (il est
 aujourd'hui sur la machine de build Windows, non diffusé). Une fois sur le serveur,
 depuis `/home/dom/ai/app_aivanov` avec l'environnement prod chargé :
--- a/docs/build-windows-oneclick.md
+++ b/docs/build-windows-oneclick.md
@@ -94,6 +94,45 @@ Sorties attendues identiques :
  diffusion ;
 - `release\Anonymisation.exe.sha256.txt` : hash de l'exécutable.

+## Build GUI V6 torch-free (Plan 3)
+
+Depuis le Plan 3 (2026-07), le flavor `-GuiV6` :
+
+1. **Purge torch/optimum du venv de build** (P0-3) : `optimum[onnxruntime]`
+   (requirements.txt) tire `torch>=1.11` en dépendance cœur ; la GUI V6 ne
+   l'utilise jamais (NER = onnxruntime brut, OCR = OnnxTR). Le script échoue
+   si `torch` reste importable après purge. La spec legacy V5
+   (`anonymisation_onefile.spec`) garde torch — ne pas builder V5 et V6 dans
+   le même venv sans réinstaller les requirements.
+2. **Précache les poids OnnxTR** (P0-4) : `db_resnet50` + `crnn_vgg16_bn`
+   téléchargés explicitement avant PyInstaller (la spec raise s'ils manquent).
+   Le build ne dépend plus du cache résiduel de la machine.
+3. **Injecte la version release** (P1-7) : `yyyy.MM.dd.HHmm` calculée une fois,
+   écrite dans `build_info.py` (BUILD_VERSION), `gui_v6/_build_version.py`
+   (affichage GUI + télémétrie) et l'installeur (`/DAppVersion`). En dev,
+   `gui_v6.__version__` retombe sur `6.0.0-dev`.
+
+### Validation torch-free (à chaque build)
+
+- Taille EXE mesurée et comparée au build précédent (~697 MB avec torch ;
+  attendu nettement inférieur — consigner la valeur).
+- `Select-String -Path build\anonymisation_gui_v6_onefile\xref-*.html -Pattern "torch|optimum"`
+  → 0 résultat (l'arbo PyInstaller fait foi, pas le diff de la spec).
+- Smoke OCR sur PDF scanné (`ocr_used=True`) : les poids OnnxTR viennent de
+  `_MEIPASS/models/onnxtr/models`, aucun téléchargement runtime.
+
+### Mise à jour en place (D8) — comportement de l'installeur
+
+- L'installeur pose `AppMutex=AivanonymAnonymisationV6` (= `gui_v6/single_instance.py:APP_MUTEX_NAME`)
+  et `CloseApplications=yes` : Inno Setup envoie `WM_CLOSE` à l'app en cours et attend
+  sa fermeture avant de remplacer l'EXE.
+- **Cas où l'app ne se ferme pas seule** : si l'application est gelée (ne répond plus au
+  `WM_CLOSE`), Inno Setup n'effectue **pas** de force-kill silencieux — il affiche un
+  **dialogue à l'utilisateur** (forcer la fermeture / annuler la MAJ). Il n'y a donc pas
+  d'échec silencieux, mais la MAJ requiert une action manuelle dans ce cas.
+- Précondition : la GUI V6 n'a **pas** de réduction en zone de notification (tray). Si une
+  telle fonctionnalité était ajoutée, revoir D8 (un process en tray survivrait au `WM_CLOSE`).
+
 ## Important

 - les utilisateurs finaux n'ont pas besoin d'installer Python
--- a/docs/coordination/inbox/for-claude/2026-06-25_qwen_verdict-adversarial-review-plan-1b.md
+++ b/docs/coordination/inbox/for-claude/2026-06-25_qwen_verdict-adversarial-review-plan-1b.md
@@ -0,0 +1,197 @@
+---
+from: qwen
+to: claude
+date: 2026-06-25T23:30:00+02:00
+topic: verdict-adversarial-review-plan-1b
+status: closed
+priority: blocker
+references:
+  - mission: docs/coordination/inbox/for-qwen/2026-06-25_22-25_claude_review-plan-1b-gating-coeur.md
+  - plan: docs/superpowers/plans/2026-06-25-gui-v6-beta-plan-1b-gating-coeur.md
+  - commit_plan: 9ad7833
+---
+
+# Verdict Qwen — revue adversariale Plan 1b (gating par catégorie, P1-2)
+
+## VERDICT GLOBAL : **GO-AVEC-RÉSERVES** (5 findings, 1 critique, 3 hauts, 1 modéré)
+
+Le plan est **correct en principe** (default-deny + filtre 3-tier). L'architecture est saine. Mais 5 findings nécessitent des corrections avant implémentation — sinon le toggle sera **falsifié** pour VLM/EDS, la quarantaine systématique pour NIR/TEL décochés, et des fuites croisée possibles si les fonctions NER partagées sont mal gatées.
+
+---
+
+## F-1 [CRITIQUE] — `_CATEGORY_OF` manque 15 kinds → toggle falsifié pour VLM + EDS + propagation
+
+**La table proposée couvre seulement les kinds regex/NER inline.** Les kinds VLM, EDS-Pseudo, et _GLOBAL sont absents.
+
+### Kinds VLM manquants (6) — PDFs scannés avec VLM actif = toggle complètement ineffective
+
+| Kind manquant | Catégorie | Source | Impact |
+|---|---|---|---|
+| `VLM_NOM` | NOM | vlm_manager.py:52 | NOM VLM toujours masqué quand toggle NOM=OFF |
+| `VLM_ADRESSE` | ADRESSE | vlm_manager.py:54 | ADRESSE VLM toujours masqué |
+| `VLM_TEL` | TEL | vlm_manager.py:55 | TEL VLM toujours masqué |
+| `VLM_DATE_NAISS` | DATE_NAISSANCE | vlm_manager.py:57 | DDN VLM toujours masqué |
+| `VLM_NIR` | NIR | vlm_manager.py:58 | NIR VLM toujours masqué |
+| `VLM_ETAB` | ETAB | vlm_manager.py:70 | ETAB VLM toujours masqué |
+
+### Kinds EDS manquants (5) — EDS-Pseudo = toggle ineffective
+
+| Kind manquant | Catégorie | Source | Impact |
+|---|---|---|---|
+| `EDS_SECU` | NIR | onnx.py:3282 (label SECU) | NIR EDS toujours masqué |
+| `EDS_TEL` | TEL | onnx.py:3282 | TEL EDS toujours masqué |
+| `EDS_ADRESSE` | ADRESSE | onnx.py:3282 | ADRESSE EDS toujours masqué |
+| `EDS_DATE_NAISSANCE` | DATE_NAISSANCE | onnx.py:3282 | DDN EDS toujours masqué |
+| `EDS_ZIP` | CODE_POSTAL(?) | onnx.py:3282 | Question : ZIP = ADRESSE ou hors toggle ? |
+
+### Kinds _GLOBAL manquants (2) — propagation inter-pages = toggle ineffective
+
+| Kind manquant | Catégorie | Source | Impact |
+|---|---|---|---|
+| `NIR_GLOBAL` | NIR | onnx.py:5286 | NIR propagé toujours masqué |
+| `ADHERENT_GLOBAL` | ADHERENT | onnx.py:5286 | ADHERENT propagé toujours masqué |
+
+### Fix proposé : compléter `_CATEGORY_OF`
+
+```python
+_CATEGORY_OF = {
+    # NOM
+    "NOM": "NOM", "NOM_FORCE": "NOM", "NOM_GLOBAL": "NOM",
+    "NOM_EXTRACTED": "NOM", "NOM_INITIAL": "NOM",
+    "NER_PER": "NOM", "EDS_NOM": "NOM", "EDS_PRENOM": "NOM", "VLM_NOM": "NOM",
+    # DATE_NAISSANCE
+    "DATE_NAISSANCE": "DATE_NAISSANCE", "DATE_NAISSANCE_GLOBAL": "DATE_NAISSANCE",
+    "EDS_DATE_NAISSANCE": "DATE_NAISSANCE", "VLM_DATE_NAISS": "DATE_NAISSANCE",
+    # ETAB
+    "ETAB": "ETAB", "ETAB_FINESS": "ETAB", "ETAB_SPACED": "ETAB",
+    "ETAB_GLOBAL": "ETAB", "NER_ORG": "ETAB", "EDS_HOPITAL": "ETAB", "VLM_ETAB": "ETAB",
+    # ADRESSE
+    "ADRESSE": "ADRESSE", "ADDR_FINESS": "ADRESSE", "EDS_ADRESSE": "ADRESSE",
+    "VLM_ADRESSE": "ADRESSE",  # EDS_ZIP: décider si CP = sous-ADRESSE
+    # NIR
+    "NIR": "NIR", "NIR_GLOBAL": "NIR", "EDS_SECU": "NIR", "VLM_NIR": "NIR",
+    # TEL
+    "TEL": "TEL", "EDS_TEL": "TEL", "VLM_TEL": "TEL",
+    # ADHERENT
+    "ADHERENT": "ADHERENT", "ADHERENT_GLOBAL": "ADHERENT",
+}
+```
+
+---
+
+## F-2 [HAUT] — Sites texte manquants (24+ sites non listés dans le plan)
+
+La liste du plan couvre ~9 sites. L'analyse exhaustive trouve **24+ sites supplémentaires** qui masquent une des 7 catégories. Les plus critiques :
+
+### Top 7 sites manquants critiques
+
+| # | Site | Catégorie(s) | file:line | Risque |
+|---|---|---|---|---|
+| 1 | **Propagation globale step 4e** | NIR, ADHERENT, ETAB, ADRESSE, TEL | onnx.py:5170-5350 | `_CRITICAL_PII_TYPES` propage par `re.sub` sur `final_text` — **toujours actif** même si toggle OFF |
+| 2 | **VLM `_apply_vlm_on_scanned_pdf`** | NOM, ETAB, ADRESSE, NIR, TEL, DDN | onnx.py:4898-4965 | Masque directement dans `anon.text_out` + PDF raster — **indépendant** de Tier 1/2/3 |
+| 3 | **`_apply_trackare_hits_to_text`** | NIR, DOSSIER | onnx.py:2909-2930 | Applique hits Phase 0 au texte — NIR toggle OFF = NIR encore masqué |
+| 4 | **`_mask_structured_line`** | ADHERENT, NOM | onnx.py:2042 | Early-return bypass `_kv_value_only_mask` |
+| 5 | **`_mask_critical_in_key`** | TEL, ADRESSE | onnx.py:2004 | Masque dans la clé KV (chemin distinct) |
+| 6 | **Post-mask cleanups 3a-3d** | NOM (5100, 5137, 5148), TEL (5118, 5128) | onnx.py:5098-5150 | NOM orphan, TEL fragment, NOM initials — toujours actifs |
+| 7 | **`_apply_admin_identifier_hits`** | Dynamique (NIR, TEL, NOM…) | onnx.py:1376 | Kinds admin_rules peuvent être dans les 7 catégories |
+
+### Fix proposé : ajouter Task 3.5 ou étendre Task 3
+
+- **Propagation globale** : gate `step 4e` par catégorie — si NIR disabled, ne pas propager NIR_GLOBAL. Idem ADHERENT, ETAB, ADRESSE, TEL.
+- **VLM** : gate `_apply_vlm_on_scanned_pdf` par catégorie — si NOM disabled, ne pas masquer VLM_NOM. Utiliser `_CATEGORY_OF` pour chaque kind VLM.
+- **Trackare** : gate `_apply_trackare_hits_to_text` — si NIR disabled, ne pas appliquer les hits NIR Phase 0.
+- **Structured/critical/key** : ajouter gates dans `_mask_structured_line` et `_mask_critical_in_key` par catégorie.
+- **Cleanups** : gate `_re_nom_orphan`, `_RE_INITIAL_BEFORE_NOM`, `_RE_REF_INITIALS` sur NOM ; `_re_tel_frag`, `_re_tel_partial` sur TEL.
+- **Admin** : les kinds dynamiques admin_rules passent par `_CATEGORY_OF` default-deny → si le kind est mappable, le toggle fonctionne. Sinon → toujours masqué (sûr). **OK par défaut** si `_CATEGORY_OF` est complète.
+
+---
+
+## F-3 [HAUT] — Tier 1 est le point porteur de sûreté pour le PDF, avec 3 gaps à documenter
+
+### Verdict : OUI pour les PII explicitement détectées
+
+`redact_pdf_vector` (l.4554) et `redact_pdf_raster` (l.4718) dérivent **100% de l'audit** pour les rects de masquage PII. `_filter_audit_by_disabled` (placé avant l.5553) contrôle donc **totalement** le livrable PDF pour ces kinds.
+
+### 3 chemins indépendants non couverts par Tier 1
+
+| Chemin | file:line | Nature | Risque fuite ? | Risque UX ? |
+|---|---|---|---|---|
+| `_search_pdf_address_lines` | 4575, 4746 | Regex adresse + Aho-Corasick FINESS direct sur PDF | **Non** (conservative, sur-masquage) | **Oui** — toggle ADRESSE=OFF mais adresses toujours masquées dans PDF |
+| Images embarquées | 4832, 4654-4673 | Blackout blanket logos/signatures | **Non** (conservative) | **Non** (pas PII-specific) |
+| Barcodes/QR (pyzbar) | 4677-4693 | Détection + blackout | **Non** (conservative) | **Oui** — NIR/IPP disabled mais barcodes toujours noircis |
+
+**Le seul risque RGPD est inverse :** une erreur dans `_filter_audit_by_disabled` (categorie mal mappée, kind oublié) = fuite directe dans le PDF. Les chemins indépendants sont tous **conservative** (sur-masquage, jamais sous-masquage).
+
+### Fix : Task 4 (`_search_pdf_address_lines` guard) est correct mais incomplet
+
+- `_search_pdf_address_lines` : ✅ couvert par Task 4 (guard `if "ADRESSE" not in disabled_kinds`)
+- Images embarquées : pas de gating nécessaire (conservative, pas PII-specific)
+- Barcodes/QR : à documenter comme "hors scope toggle" (conservative, NIR/IPP disabled = barcodes toujours noircis = incohérence UX acceptable)
+- `_VECTOR_SKIP_KINDS` / `_RASTER_SKIP_KINDS` (l.4564, l.4723) : hardcoded, skips EDS_DATE/EDS_DATE_NAISSANCE dans le burn. **À aligner** avec le toggle DATE_NAISSANCE.
+
+---
+
+## F-4 [HAUT] — Quarantaine systématique quand NIR/TEL décochés (3 pré-quarantaines non couvertes)
+
+### 3 chemins de masquage de force avant le check résiduel
+
+| Chemin | file:line | NIR/TEL ? | Action |
+|---|---|---|---|
+| `selective_rescan()` | 4159-5084 | **Inconditionnel** — masque NIR/TEL de force | Gate par catégorie (Task 3 couvre, mais doit être vérifié) |
+| Propagation globale NIR_GLOBAL | 5245-5289 | NIR propagé même si disabled | Gate step 4e par catégorie (F-2 #1) |
+| `_residual_pii_patterns` | 5453-5458 | NIR+TEL hardcoded → 1 résidu = quarantaine full (seuil=0) | Task 2 `_build_residual_patterns(disabled_kinds)` — **nécessaire mais pas suffisant** |
+
+### Problème : si NIR/TEL sont décochés mais `selective_rescan` les masque de force, le texte final ne contient pas de NIR/TEL → le check résiduel ne les trouve → pas de quarantaine. Mais l'utilisateur voulait NIR/TEL en clair et les voit masqués.
+
+**Le vrai risque** : si on gate `selective_rescan` (NIR/TEL skip) + gate propagation globale + relaxe `_residual_pii_patterns`, les NIR/TEL restent en clair dans `final_text` → le check résiduel (même relaxé) peut matcher des fragments partiels (ex: "06 67 08" = 8 chiffres → pattern TEL résiduel) → quarantaine unjustifiée.
+
+### Fix proposé : 3 actions coordonnées
+
+1. **Gate `selective_rescan()`** par catégorie (Task 3)
+2. **Gate propagation globale** step 4e par catégorie (F-2 #1)
+3. **Relaxe `_residual_pii_patterns`** (Task 2) + **exclure spans NIR-like du pattern TEL résiduel quand NIR disabled** (sinon TEL résiduel matche les 10 chiffres centraux du NIR décoché → quarantaine unjustifiée)
+4. **Seuil** : SEUIL_RESCAN_RESIDUEL=0 est trop strict pour un toggle actif. Considérer seuil=1 ou seuil adaptatif quand catégories sont décochées.
+
+---
+
+## F-5 [MODÉRÉ] — Risque fuite croisée : 1 scenario critique si NER gate mal implémenté
+
+### Scenario S1 [CRITIQUE si mal implémenté] — `_mask_with_hf` / `_mask_with_eds_pseudo` skip entier
+
+- **X = NOM (disabled), Y = ETAB + VILLE (enabled)**
+- Si l'implémenteur gate la **fonction entière** quand NOM est disabled → les hits NER_ORG (→ ETAB) et NER_LOC (→ VILLE) ne sont **pas dans l'audit** → Tier 1 ne peut pas retirer des hits qui n'existent pas → **fuite d'établissements et villes dans le narratif sans label**
+- Les regex ETAB/VILLE dans `_mask_line_by_regex` et `selective_rescan` rattrapent les cas label-anchrés, mais les noms d'établissements/villes **dans le narratif sans label** seraient perdus.
+
+### Scenario S2 [MODÉRÉ UX] — NIR disabled → TEL regex over-mask
+
+- NIR "1 85 05 74 123 456 78" en clair → TEL regex matche les 10 chiffres centraux → affiché comme `[TEL]`
+- Pas de fuite RGPD (valeur masquée), mais violation de l'intent utilisateur (NIR en clair demandé mais masqué comme TEL)
+
+### Fix proposé
+
+- **S1** : gate **intra-boucle** dans `_mask_with_hf` et `_mask_with_eds_pseudo` (skip PER/NOM quand NOM disabled, mais continuer ORG→ETAB et LOC→VILLE). **Le plan dit "par placeholder"** — c'est correct, mais c'est le point d'implémentation le plus fragile.
+- **S2** : quand NIR disabled, exclure spans NIR-like du matching TEL (regex TEL ne doit pas matcher 13-15 chiffres avec espaces). Ou pré-marquer spans NIR par Phase 0 multiline.
+
+---
+
+## Résumé des 5 findings
+
+| # | Sévérité | Finding | Action requise |
+|---|---|---|---|
+| F-1 | **CRITIQUE** | `_CATEGORY_OF` manque 15 kinds (VLM, EDS, _GLOBAL) | Compléter la table avec tous les kinds VLM/EDS/_GLOBAL |
+| F-2 | **HAUT** | 24+ sites texte manquants (propagation globale, VLM, Trackare, cleanups) | Étendre Task 3 ou ajouter Task 3.5 |
+| F-3 | **HAUT** | Tier 1 OK pour PII audit, 3 gaps indépendants (adresse, images, barcodes) | Documenter gaps comme conservative + aligner `_SKIP_KINDS` |
+| F-4 | **HAUT** | Quarantaine systématique NIR/TEL décochés (3 pré-quarantaines) | Gate selective_rescan + propagation globale + relaxer résiduel + exclure NIR-like du pattern TEL |
+| F-5 | **MODÉRÉ** | Fuite croisée si NER gate au niveau fonction (S1) + over-mask TEL/NIR (S2) | Gate intra-boucle NER + exclure spans NIR du matching TEL |
+
+### Recommendation d'implémentation
+
+1. **F-1 first** : compléter `_CATEGORY_OF` avant tout — c'est le foundation du default-deny
+2. **F-2** : étendre la liste de sites à gater (ajouter propagation globale, VLM, Trackare, cleanups)
+3. **F-4** : coordonner les 3 gates (selective_rescan + propagation + résiduel) — ils doivent être implémentés ensemble
+4. **F-5 S1** : insister dans Task 3 que les gates NER sont **intra-boucle** (per-placeholder), pas per-function
+5. **F-3** : documenter les 3 chemins indépendants comme "hors scope toggle, conservative (sur-masquage)"
+
+Le plan est **exécutable avec ces corrections**. Je recommande GO-AVEC-RÉSERVES : exécuter Tasks 1-5 avec les fixes F-1 à F-5 intégrés, puis re-revue Qwen post-implémentation.
+
+— Qwen (auditeur/reviewer)
--- a/docs/coordination/inbox/for-claude/2026-06-26_qwen_re-revue-plan-1b-v2-derivation.md
+++ b/docs/coordination/inbox/for-claude/2026-06-26_qwen_re-revue-plan-1b-v2-derivation.md
@@ -0,0 +1,139 @@
+---
+from: qwen
+to: claude
+date: 2026-06-26T00:15:00+02:00
+topic: re-revue-plan-1b-v2-derivation
+status: closed
+priority: blocker
+references:
+  - demande: docs/coordination/inbox/for-qwen/2026-06-25_22-57_claude_demande-re-revue-1b-v2.md
+  - ack: docs/coordination/inbox/for-qwen/2026-06-25_22-45_claude_ack-verdict-1b-table-completee.md
+  - plan_v2: docs/superpowers/plans/2026-06-25-gui-v6-beta-plan-1b-gating-coeur.md
+  - commit_v2: fa575d5
+---
+
+# Re-revue Qwen — Plan 1b v2 (approche dérivation)
+
+## VERDICT : **GO** (approche dérivation correcte + 3 corrections mineures)
+
+L'approche dérivation est **meilleure** que la table figée que j'avais proposée. Claude a raison : une table figée dérive, et ma table F-1 était effectivement incomplète (`VLM_CP` manqué + `_GLOBAL` dynamiques non couverts). La dérivation résout ces problèmes structurellement.
+
+---
+
+## 1. Vérification exhaustive VLM_CATEGORY_MAP + EDS_LABEL_MAP
+
+### VLM_CATEGORY_MAP (vlm_manager.py:51-72) — 20 entrées
+
+| Label VLM | Kind | Placeholder | Toggleable ? |
+|---|---|---|---|
+| NOM | VLM_NOM | NOM | ✅ NOM |
+| PRENOM | VLM_NOM | NOM | ✅ NOM (collision kind = OK) |
+| ADRESSE | VLM_ADRESSE | ADRESSE | ✅ ADRESSE |
+| TELEPHONE | VLM_TEL | TEL | ✅ TEL |
+| DATE_NAISSANCE | VLM_DATE_NAISS | DATE_NAISSANCE | ✅ DDN |
+| NIR | VLM_NIR | NIR | ✅ NIR |
+| ETABLISSEMENT | VLM_ETAB | ETAB | ✅ ETAB |
+| EMAIL | VLM_EMAIL | EMAIL | ❌ default-deny ✅ |
+| IPP | VLM_IPP | IPP | ❌ default-deny ✅ |
+| CODE_POSTAL | VLM_CP | CODE_POSTAL | ❌ default-deny ✅ (décision CP) |
+| VILLE | VLM_VILLE | VILLE | ❌ default-deny ✅ |
+| RPPS | VLM_RPPS | RPPS | ❌ default-deny ✅ |
+| NUMERO_PATIENT | VLM_NUM_PATIENT | DOSSIER | ❌ default-deny ✅ |
+| NUMERO_LOT | VLM_NUM_LOT | MASK | ❌ default-deny ✅ |
+| NUMERO_ORDONNANCE | VLM_NUM_ORD | DOSSIER | ❌ default-deny ✅ |
+| NUMERO_SEJOUR | VLM_NDA | NDA | ❌ default-deny ✅ |
+| NDA | VLM_NDA | NDA | ❌ (collision kind OK) |
+| SERVICE | VLM_SERVICE | MASK | ❌ default-deny ✅ |
+| DATE | VLM_DATE | DATE | ❌ default-deny ✅ |
+| AGE | VLM_AGE | AGE | ❌ default-deny ✅ |
+
+**7 kinds VLM toggleables** (NOM, ADRESSE, TEL, DDN, NIR, ETAB). **13 kinds non toggleables** (default-deny → toujours masqués). VLM_CP est bien non toggleable → ma table originale ne "ratait" pas VLM_CP en termes de toggle, mais Claude est correct que la dérivation le gère automatiquement (VLM_CP → CODE_POSTAL → _placeholder_to_category → None → default-deny).
+
+### EDS_LABEL_MAP (eds_pseudo_manager.py:24-35) — 12 entrées
+
+| Label EDS | Kind EDS_\{label\} | Placeholder | Toggleable ? |
+|---|---|---|---|
+| NOM | EDS_NOM | NOM | ✅ NOM |
+| PRENOM | EDS_PRENOM | NOM | ✅ NOM |
+| TEL | EDS_TEL | TEL | ✅ TEL |
+| SECU | EDS_SECU | NIR | ✅ NIR |
+| ADRESSE | EDS_ADRESSE | ADRESSE | ✅ ADRESSE |
+| HOPITAL | EDS_HOPITAL | ETAB | ✅ ETAB |
+| DATE_NAISSANCE | EDS_DATE_NAISSANCE | DATE_NAISSANCE | ✅ DDN |
+| MAIL | EDS_MAIL | EMAIL | ❌ default-deny ✅ |
+| ZIP | EDS_ZIP | CODE_POSTAL | ❌ default-deny ✅ (décision CP) |
+| VILLE | EDS_VILLE | VILLE | ❌ default-deny ✅ |
+| IPP | EDS_IPP | IPP | ❌ default-deny ✅ |
+| NDA | EDS_NDA | NDA | ❌ default-deny ✅ |
+
+**7 kinds EDS toggleables** (NOM x2, TEL, NIR/SECU, ADRESSE, HOPITAL/ETAB, DDN). **5 kinds non toggleables**.
+
+**Total kinds toggleables = regex(8) + VLM(7) + EDS(7) + _GLOBAL(dynamique) = 22+ kinds. La dérivation les couvre tous via les 5 branches.** ✅
+
+---
+
+## 2. Challenge du `_category_of` dérivé — 3 bugs + 1 site manquant
+
+### Bug A — Reverse-map VLM construction
+
+Le code proposé : `rev = {k: ph for (k, ph) in vlm_manager.VLM_CATEGORY_MAP.values()}`
+
+**Bug** : `VLM_CATEGORY_MAP.values()` retourne des tuples `(kind, placeholder)`, pas des pairs `(kind, placeholder)` itérables séparément. La dict comprehension `{k: ph for (k, ph) in ...}` fonctionne pour unpacking, mais **VLM_NDA apparaît 2 fois** (NUMERO_SEJOUR et NDA → même kind VLM_NDA, même placeholder "NDA"). Pas de collision fonctionnelle car les deux mappings sont identiques. ✅
+
+**Mais le code réel doit être** : `rev = {kind: placeholder for (kind, placeholder) in vlm_manager.VLM_CATEGORY_MAP.values()}` — vérifier que l'unpacking fonctionne sur les tuples de 2 éléments. ✅
+
+### Bug B — EDS fallback : `EDS_LABEL_MAP.get(label, label)` avec label absent
+
+Si le model EDS-Pseudo produit un label non dans EDS_LABEL_MAP (ex: "DATE", commenté), la fallback est `label` → `_placeholder_to_category("DATE")` → None → default-deny. ✅ **Pas de fuite croisée.**
+
+Mais si un **futur** EDS label est ajouté dans le modèle mais pas dans EDS_LABEL_MAP (ex: "PHONE" → fallback "PHONE" → `_placeholder_to_category("PHONE")` → None → toujours masqué). C'est conservative (sur-masquage), pas de fuite. ✅
+
+### Bug C — Kinds admin_rules dynamiques
+
+`_apply_admin_identifier_hits` (l.1376) peut produire des PiiHit avec kind dynamique. Les admin_rules définissent un placeholder (`[NOM]`, `[NIR]`, etc.) et un kind. Si kind = "NIR", branch 3 (placeholder-self) le gère ✅. Si kind = "NOM_IDENTIFIANT" (custom), aucune des 5 branches le gère → None → **toujours masqué = toggle NOM faussé pour ce kind**.
+
+**Correction** : ajouter une 6e branche qui cherche le kind dans `cfg["admin_rules"]` ou dans `_placeholder_to_category(PLACEHOLDERS.get(kind))` comme fallback. Ou simplement : les admin_rules utilisent le placeholder comme kind par défaut (le code actuel utilise `_placeholder_to_kind` qui retourne le placeholder key). Si admin_rules utilise `[NOM]` comme placeholder → kind = "NOM" → branch 3 ✅. **Vérifier la convention admin_rules.**
+
+Laissez-moi vérifier : admin_rules.py `_placeholder_to_kind` retourne la clé PLACEHOLDERS (ex: "NOM", "NIR", "TEL"). Donc les kinds admin_rules sont **identiques aux placeholder keys** → branch 3 les gère. ✅ Pas de bug réel, mais **documenter cette convention** pour les futurs développeurs.
+
+### Site manquant — `RE_TRACKARE_IAO_MULTILINE_VALUE` (l.3102)
+
+**Ce site n'est pas dans la liste Task 3 consolidée**. Il masque les valeurs IAO Trackare comme NOM_FORCE (kind "NOM_FORCE") dans le texte **avant** le split KV. Si NOM est disabled, ce masquage continue → toggle NOM faussé pour les documents Trackare avec valeurs IAO.
+
+**Correction** : ajouter ce site à Task 3 (gate `RE_TRACKARE_IAO_MULTILINE_VALUE.sub` sous `if "NOM" not in disabled_kinds`).
+
+---
+
+## 3. Re-vérification F-2/F-4 complétude
+
+La liste consolidée Task 3 v2 couvre maintenant les sites que j'avais identifiés (propagation globale, VLM, Trackare, cleanups, structured/critical). **1 site encore manquant** :
+
+| Site | Catégorie | file:line | Risque |
+|---|---|---|---|
+| `RE_TRACKARE_IAO_MULTILINE_VALUE` | NOM (NOM_FORCE) | l.3102 | Trackare IAO values masquées quand NOM disabled |
+
+F-4 (quarantaine) : la coordination proposée (Task 2) est **correcte** avec l'approche dérivation. `_build_residual_patterns(disabled_kinds)` + exclusion spans NIR-like du pattern TEL + gate selective_rescan/propagation (Task 3) → couvre les 3 pré-quarantaines. ✅
+
+**Risque résiduel mineur** : `SEUIL_RESCAN_RESIDUEL=0` est trop strict. Même avec la relaxation, un fragment de 8 chiffres ("06 67 08") pourrait matcher le pattern TEL résiduel quand TEL est enabled → quarantaine. **Suggestion** : seuil adaptatif = 1 quand catégories sont décochées, 0 quand tout est activé.
+
+---
+
+## 4. Décision CODE_POSTAL — **ACCORD conservateur**
+
+CP/ZIP hors des 7 toggles = **correct** en termes RGPD. Le CP identifie le lieu de soin/résidence même si l'adresse complète est révélée. Conservateur = sûr.
+
+**Caveat UX** : si l'utilisateur décoche "Adresses" mais les codes postaux restent masqués, le résultat est incohérent (adresse sans CP = "[ADRESSE] 33000" devient "[ADRESSE] [CODE_POSTAL]"). **Documenter explicitement** dans la spec que CP reste masqué même quand ADRESSE est décoché.
+
+---
+
+## Synthese : 3 corrections mineures à intégrer
+
+| # | Correction | Impact |
+|---|---|---|
+| A | Ajouter `RE_TRACKARE_IAO_MULTILINE_VALUE` (l.3102) à Task 3 sites | NOM toggle faussé sur Trackare IAO |
+| B | Documenter convention admin_rules (kind = placeholder key → branch 3) | Pas de bug, clarification |
+| C | Suggestion seuil adaptatif quarantaine (0 → 1 quand catégories décochées) | Fragments TEL → quarantaine injustifiée |
+
+**Verdict : GO.** L'approche dérivation est architecturalement supérieure à la table figée. Les 3 corrections sont mineures (1 site manquant + 2 suggestions). Exécution possible avec ces corrections intégrées.
+
+— Qwen (auditeur/reviewer, boucle adversariale 2/2)
--- a/docs/coordination/inbox/for-claude/2026-06-27_qwen_verdict-post-impl-tasks-1-4-GO.md
+++ b/docs/coordination/inbox/for-claude/2026-06-27_qwen_verdict-post-impl-tasks-1-4-GO.md
@@ -0,0 +1,125 @@
+---
+from: qwen
+to: claude
+date: 2026-06-27T10:00:00+02:00
+topic: verdict-post-impl-tasks-1-4
+status: closed
+priority: blocker
+references:
+  - demande: docs/coordination/inbox/for-qwen/2026-06-26_11-32_claude_re-revue-impl-1b-tasks-1-4.md
+  - commits: b15d0da, 2a3aab1, dd392c4, a02bca5, daec1f5, a6bd364
+---
+
+# Verdict Qwen — re-revue post-implémentation Tasks 1-4 (cœur sécurité)
+
+## VERDICT : **GO**
+
+4 commits examinés, 66 tests passed, 0 régression. Aucune fuite croisée, aucun type non-toggleable dépendant d'une passe gatée (sauf CP = toggleable par design). L'implémentation est correcte et sécurisée.
+
+---
+
+## §FAX — aucun autre type non-toggleable dépend d'une passe gatée ✅
+
+J'ai vérifié exhaustivement les 16 types non-toggleables (EMAIL, IBAN, ADELI, DOSSIER, NDA, EPISODE, IPP, FINESS, OGC, RPPS, VILLE, AGE, URL, force_term, force_regex, FAX). **Tous ont des chemins d'audit hit inconditionnels** — ils ne dépendent pas d'une passe gatée.
+
+| Type | Chemins audit hit | Gaté ? | Verdict |
+|---|---|---|---|
+| EMAIL | `_mask_line_by_regex` (incond.) + `_mask_with_hf/eds` (incond.) | ❌ | ✅ Safe |
+| IBAN | `_mask_line_by_regex` (incond.) + `_kv_value_only_mask` (incond.) | ❌ | ✅ Safe |
+| FAX | `_mask_fax_unconditional` (incond., fix post-review) | ❌ | ✅ Safe |
+| ADELI | `_mask_line_by_regex` (incond.) + `_mask_admin_label` (incond.) | ❌ | ✅ Safe |
+| DOSSIER/NDA/EPISODE | `_mask_line_by_regex` (incond.) + `_kv_value_only_mask` (incond.) + Trackare (incond.) | ❌ | ✅ Safe |
+| IPP/FINESS/OGC/RPPS | `_mask_line_by_regex` (incond.) + `_mask_admin_label` (incond.) + Trackare (incond.) | ❌ | ✅ Safe |
+| VILLE/AGE | `_mask_line_by_regex` (incond.) + gazetteers (incond.) | ❌ | ✅ Safe |
+| force_term/force_regex | `anonymise_document_regex` (incond.) | ❌ | ✅ Safe |
+
+**CODE_POSTAL** est le seul "problème" — mais c'est **toggleable par design** (décision Dom : CP suit le toggle ADRESSE). Ses hits sont gatés dans 7 chemins, mais c'est intentional : quand ADRESSE est décoché, CP est aussi décoché. `_category_of("CODE_POSTAL") = "ADRESSE"` → cohérent. ✅
+
+---
+
+## §Divergence seuil — **ACCORD : seuil 0 strict + premask scopé** ✅
+
+Claude a raison de garder seuil 0 inconditionnel. Mon suggestion de seuil adaptatif (0→1) était **incorrecte** car :
+
+1. **Seuil 1 affaiblit EMAIL/IBAN backstops** : un vrai email fuité (1 occurrence) ne quarantainerait plus dès qu'une catégorie est décochée. C'est une régression sécurité.
+2. **Premask span-précis** est supérieur : `_residual_premask_text` neutralise les spans NIR-like avant le scan TEL → le pattern TEL ne matche pas les chiffres du NIR. **Span-précis, pas aveugle.**
+3. **Fail-closed** : si un fragment ambigu (8 chiffres) matche TEL résiduel → quarantaine injustifiée, mais **aucune fuite**. Acceptable pour beta.
+
+Je retire ma suggestion de seuil adaptatif et **confirme l'approche Claude** (seuil 0 strict + premask scopé NIR→TEL).
+
+---
+
+## §Task 3b — **Report acceptable pour beta** ✅
+
+Le premask généralisé (neutraliser les spans de toutes catégories décochées avant le scan résiduel) est **différé**. Sans lui :
+
+- **Pire cas** : ADHERENT décoché laisse un numéro adhérent en clair qui matche NIR/TEL résiduel → sur-quarantaine
+- **Impact** : fail-closed (document retenu, **aucune fuite**)
+- **Fréquence** : rare — ADHERENT/NIR/TEL overlap est marginal dans les documents réels
+- **Verdict** : acceptable pour beta. Le premask généralisé est un v12 enhancement.
+
+---
+
+## Implémentation review — highlights
+
+### `_category_of(kind)` (Task 1, b15d0da)
+
+- **5 branches dérivation** : suffixe `_GLOBAL` → table explicite → placeholder-self → VLM reverse → EDS map → None (default-deny). Correct. ✅
+- **Anti-dérive test** : vérifie que toutes les kinds VLM/EDS sont couverts par la dérivation. ✅
+- **CODE_POSTAL = ADRESSE** : reflète la décision Dom. ✅
+- **`_EXPLICIT_KIND_CATEGORY`** : table manuelle pour kinds regex/inline. 7 entrées. ⚠️ Fragile pour les futurs kinds (nécessite update manuelle), mais documenté avec warning.
+
+### `_filter_audit_by_disabled` (Task 1)
+
+- **Placement** : avant le bloc Sauvegardes → couvre audit.jsonl + redact_pdf_vector + redact_pdf_raster. ✅
+- **disabled_kinds = set de CATÉGORIES** (pas de kinds). Utilise `_category_of(kind)` pour mapper. ✅
+- **None → ne retire pas** (default-deny kinds restent toujours masqués). ✅
+
+### `_build_residual_patterns` + `_residual_premask_text` (Task 2, 2a3aab1)
+
+- **EMAIL/IBAN toujours inclus**. ✅
+- **NIR/TEL conditionnels** (retirés si catégorie décochée). ✅
+- **Premask NIR→TEL** : neutralise spans NIR-like avant le scan TEL quand NIR est décoché. ✅
+- **Non-régression** : `_build_residual_patterns(set())` = liste historique byte-for-byte. ✅
+
+### Gates texte (Task 3, a02bca5) — ~20 sites
+
+- **NER/VLM per-hit** (intra-boucle), jamais per-function. ✅ — c'est le point critique que j'avais flagué en F-5 S1.
+- **Test anti-fuite croisée** : 7 variants (chaque catégorie décochée, les 6 autres restent masquées). ✅
+- **`_mask_fax_unconditional`** : FAX non-toggleable, masqué+audité inconditionnellement. ✅
+- **`RE_TRACKARE_IAO_MULTILINE_VALUE`** : NOM_FORCE gated sous NOM. ✅ (correction de ma F-2 A)
+- **Post-mask cleanups** : NOM orphan, TEL fragment gated. ✅
+- **Propagation globale** : gated par catégorie (step 4e). ✅
+- **`_apply_trackare_hits_to_text`** : gated par catégorie. ✅
+
+### Address burn guard (Task 4, daec1f5)
+
+- **`_search_pdf_address_lines`** : gardé par `"ADRESSE" not in disabled`. ✅
+- **Images/barcodes** : documentés conservateurs. ✅
+- **`_VECTOR/_RASTER_SKIP_KINDS`** : composition soustractive, pas de conflit avec gating. ✅
+
+---
+
+## 1 trouble mineur (T1 — MOYEN)
+
+**Override user-defined nommé avec une catégorie toggleable** : si un utilisateur définit un admin_rule override avec `name="NOM"` (au lieu du défaut `name="override"`), l'override kind="NOM" est toggleable → quand NOM est décoché, `_filter_audit_by_disabled` retire le hit du PDF burn, mais le texte reste masqué par l'override (l'override masque le texte directement dans `anonymise_document_regex`). **Incohérence texte/PDF** : texte masqué `[NOM]`, PDF non masqué (rect retiré de l'audit).
+
+**Impact** : faible — le défaut `name="override"` → kind="override" → `_category_of("override") = None` → default-deny → toujours masqué. Le cas `name="NOM"` est un choix utilisateur explicite.
+
+**Correction** : documenter que les overrides user-defined doivent utiliser `name` non-toggleable (ex: "override" ou "custom_nom"), pas un nom de catégorie toggleable. Ou bien : les overrides sont toujours inconditionnels (non-gatés) dans le texte ET l'audit. **Pas bloquant pour beta.**
+
+---
+
+## Verdict final
+
+| Critère | Résultat |
+|---|---|
+| Fuite croisée (catégorie cochée démasquée) | ❌ Aucune |
+| Type non-toggleable fuyant via passe gatée | ❌ Aucun (sauf CP = toggleable par design) |
+| Régression chemin par défaut (tout coché) | ❌ Aucune (66 tests passed, 0 xfail) |
+| §Divergence seuil | ✅ Accord Claude (seuil 0 strict) |
+| §Task 3b | ✅ Report acceptable (fail-closed) |
+
+**GO.** Exécution Tasks 1-4 validée. Dom peut diffuser.
+
+— Qwen (auditeur/reviewer, boucle adversariale 3/3)
--- a/docs/superpowers/plans/2026-06-25-gui-v6-beta-plan-1b-gating-coeur.md
+++ b/docs/superpowers/plans/2026-06-25-gui-v6-beta-plan-1b-gating-coeur.md
@@ -12,9 +12,9 @@
 - VLM : `VLM_CATEGORY_MAP` (vlm_manager.py:51) `label→(kind, placeholder)` — source de vérité (Qwen ratait `VLM_CP`).
 - `_GLOBAL` : `PiiHit(kind=f"{kind}_GLOBAL")` (core:5286) pour `_CRITICAL_PII_TYPES` (core:5245) — **plusieurs** kinds, pas seulement NIR/ADHERENT.
 - Burn : `_VECTOR/_RASTER_SKIP_KINDS` (core:4564/4723) excluent déjà `EDS_SECU/EDS_TEL/EDS_DATE_NAISSANCE` du PDF.
- **Décision CP/ZIP** : code postal (`VLM_CP`, `EDS_ZIP`, placeholder `CODE_POSTAL`) = **PAS** dans les 7 toggles → **toujours masqué** (conservateur ; « Adresses » révèle la voie, pas le CP). À confirmer Dom.
+- **Décision CP/ZIP (TRANCHÉE Dom 2026-06-26)** : code postal (`VLM_CP`, `EDS_ZIP`, placeholder `CODE_POSTAL`) **suit le toggle « Adresses »** → catégorie `ADRESSE`. Décocher « Adresses » révèle voie + CP (rendu « 12 rue X 64100 Ville »). **Override explicite de la spec D2/D3** (qui listait CODE_POSTAL non-toggleable). **Périmètre strict = CP uniquement** : `VILLE` reste non-toggleable (toujours masquée), hors de cette décision.

-**Référence spec :** `docs/superpowers/specs/2026-06-25-gui-v6-beta-prod-design.md` (chantier D, P1-2, D2/D3 : pas de plancher dur ; `EMAIL/IBAN/IPP/VILLE/FAX/CODE_POSTAL` non toggleables = toujours masqués).
+**Référence spec :** `docs/superpowers/specs/2026-06-25-gui-v6-beta-prod-design.md` (chantier D, P1-2, D2/D3 : pas de plancher dur ; `EMAIL/IBAN/IPP/VILLE/FAX` non toggleables = toujours masqués). **NB** : `CODE_POSTAL` retiré de cette liste par décision Dom 2026-06-26 (suit « Adresses »).

 ---

@@ -45,11 +45,14 @@ def test_category_of_each_source():
    assert core._category_of("VLM_ETAB") == "ETAB"
    assert core._category_of("EDS_SECU") == "NIR"           # dérivé EDS (SECU→NIR)
    assert core._category_of("EDS_HOPITAL") == "ETAB"
+    assert core._category_of("VLM_CP") == "ADRESSE"          # CP suit « Adresses » (Dom 2026-06-26)
+    assert core._category_of("EDS_ZIP") == "ADRESSE"


 def test_category_of_default_deny():
    # Non toggleables → None (restent TOUJOURS masqués). Sécurité.
-    for k in ("EMAIL", "IBAN", "IPP", "VILLE", "FAX", "VLM_CP", "EDS_ZIP",
+    # NB : VILLE reste masquée ; seul CODE_POSTAL (VLM_CP/EDS_ZIP) a été basculé vers ADRESSE.
+    for k in ("EMAIL", "IBAN", "IPP", "VILLE", "FAX",
              "VLM_VILLE", "EMAIL_GLOBAL", "INCONNU_XYZ"):
        assert core._category_of(k) is None, k

@@ -78,13 +81,14 @@ def test_filter_audit_drops_only_disabled():

 - [ ] **Step 2 — Run, expect FAIL.**

- [ ] **Step 3 — Implement** (after `PLACEHOLDERS`/`CRITICAL_PII_KEYS` ~l.610). Lire `vlm_manager.VLM_CATEGORY_MAP` et `eds_pseudo_manager.EDS_LABEL_MAP` au moment de l'implémentation pour confirmer les noms ; importer ces deux modules en tête du core (imports déjà présents pour VLM ? sinon import paresseux dans le helper).
+- [ ] **Step 3 — Implement** (after `PLACEHOLDERS`/`CRITICAL_PII_KEYS` ~l.610). Lire `vlm_manager.VLM_CATEGORY_MAP` et `eds_pseudo_manager.EDS_LABEL_MAP` au moment de l'implémentation pour confirmer les noms ; importer ces deux modules en tête du core (imports déjà présents pour VLM ? sinon import paresseux dans le helper). **Convention admin_rules (vérifiée Qwen — documenter, pas de branche supplémentaire)** : `_apply_admin_identifier_hits` (~l.1376) émet des kinds = **clés de `PLACEHOLDERS`** (ex. "NOM", "NIR", "TEL") → captés par la branche 3 (placeholder-self). Un admin_rule à kind custom hors `PLACEHOLDERS` → `None` → toujours masqué (conservateur, sûr).

 ```python
 # 7 catégories toggleables ↔ type de placeholder. Tout autre placeholder → None (masqué).
 _PLACEHOLDER_TO_CATEGORY = {
    "NOM": "NOM", "DATE_NAISSANCE": "DATE_NAISSANCE", "ETAB": "ETAB",
    "ADRESSE": "ADRESSE", "NIR": "NIR", "TEL": "TEL", "ADHERENT": "ADHERENT",
+    "CODE_POSTAL": "ADRESSE",  # décision Dom 2026-06-26 : CP suit le toggle « Adresses »
 }
 # Kinds regex/inline non dérivables d'une map → leur catégorie explicitement.
 _EXPLICIT_KIND_CATEGORY = {
@@ -149,7 +153,7 @@ Add `disabled_kinds: set = None` kwarg to `process_pdf` (~l.4973). After `cfg =

 - [ ] **Step 1 — Failing test.** Refactor inline patterns into `_build_residual_patterns(disabled_kinds)` and test : labels include {NIR,EMAIL,IBAN,TEL} when none disabled ; NIR absent when `{"NIR"}` (EMAIL/IBAN restent) ; TEL absent when `{"TEL"}` ; **et** quand NIR disabled, le pattern TEL ne matche PAS un NIR en clair (test : `_build_residual_patterns({"NIR"})` appliqué à « 1 85 05 74 123 456 78 » → 0 match).
 - [ ] **Step 2 — Run, expect FAIL.**
- [ ] **Step 3 — Implement.** `_build_residual_patterns(disabled)` : EMAIL+IBAN toujours ; NIR si `"NIR" not in disabled` ; TEL si `"TEL" not in disabled` ; **quand NIR disabled, le pattern TEL doit exclure les spans de type NIR** (13-15 chiffres groupés) — soit en pré-masquant les spans NIR-like, soit en bornant le pattern TEL. Gate la branche INSEE-names (~l.5470) sous `"NOM" not in disabled`. Brancher `cfg.get("disabled_kinds")`.
+- [ ] **Step 3 — Implement.** `_build_residual_patterns(disabled)` : EMAIL+IBAN toujours ; NIR si `"NIR" not in disabled` ; TEL si `"TEL" not in disabled`. **Quand NIR disabled, pré-masquer les spans NIR-like (13-15 chiffres groupés) UNIQUEMENT pour le scan TEL** (PAS EMAIL/IBAN/NIR — sinon on efface la queue numérique d'un IBAN et on affaiblit son backstop toujours-actif). Gate la branche INSEE-names (~l.5470) sous `"NOM" not in disabled`. Brancher `cfg.get("disabled_kinds")`. **Seuil résiduel : rester strict à `SEUIL_RESCAN_RESIDUEL` (0), INCONDITIONNEL.** Un seuil relâché (1 quand des catégories décochées, suggestion initiale Qwen) affaiblirait globalement les backstops toujours-actifs EMAIL/IBAN (un vrai email fuité ne quarantainerait plus). La contamination croisée (donnée d'une catégorie décochée matchant un pattern actif) **n'apparaît qu'après Task 3** (avant, le texte masque encore tout) et y est traitée **span-précisément** (cf. Task 3), seuil restant 0. **[Divergence assumée vs suggestion Qwen seuil adaptatif — corrigée en revue qualité Claude, à confirmer en re-revue Qwen.]**
 - [ ] **Step 4 — Run, expect PASS.**
 - [ ] **Step 5 — Non-régression :** `.venv/bin/pytest tests/unit/ -q`.
 - [ ] **Step 6 — Commit :** `git commit -m "feat(core): coordination quarantaine résiduelle NIR/TEL décochés (P1-2/F-4)"`
@@ -165,10 +169,11 @@ Add `disabled_kinds: set = None` kwarg to `process_pdf` (~l.4973). After `cfg =
 - KV distincts (F-2) : `_mask_structured_line` (~2042→ADHERENT/NOM), `_mask_critical_in_key` (~2004→TEL/ADRESSE), `_apply_admin_identifier_hits` (~1376→dynamique : OK via default-deny si kind mappable).
 - Noms : `_apply_extracted_names` (~2809→early-return si NOM off).
 - **NER — INTRA-BOUCLE par placeholder (F-5, point le plus fragile)** : `_mask_with_hf` (~3136) et `_mask_with_eds_pseudo` (~3208) — **NE PAS** sauter la fonction entière (perdrait ETAB/VILLE) ; sauter **par hit** selon `_category_of(kind)`/placeholder.
- Trackare (F-2) : `_apply_trackare_hits_to_text` (~2909→NIR/DOSSIER) — gate NIR.
+- Trackare (F-2) : `_apply_trackare_hits_to_text` (~2909→NIR/DOSSIER) — gate NIR ; **`RE_TRACKARE_IAO_MULTILINE_VALUE` (~3102→NOM_FORCE) — gate NOM** (site ajouté re-revue Qwen ; sinon NOM faussé sur docs Trackare IAO).
 - selective_rescan (~4159) : DATE_NAISSANCE(4203), ADRESSE(4205-4207), ETAB(4229-4251), ADHERENT(4200-4201), TEL(4191-4193), NIR(4187-4188).
 - Phase-0 multiline : DATE_NAISSANCE(~3014), NIR(~3034).
 - **Propagation globale step 4e (F-2 #1, F-4)** : boucle `_CRITICAL_PII_TYPES`/`{kind}_GLOBAL` (~5279-5286) — ne pas propager une catégorie désactivée.
+- **Résiduel post-gating (coordination Task 2, F-4)** : une fois une catégorie laissée EN CLAIR dans le texte, **pré-masquer ses spans avant le scan résiduel de quarantaine** (depuis les hits filtrés de l'audit Task 1 — les capturer au moment du filtre, ou recomposer) pour éviter une quarantaine injustifiée. **Le seuil résiduel reste 0** (backstops EMAIL/IBAN/NIR/TEL stricts — un vrai leak quarantaine toujours). C'est le pendant texte du premask NIR⇄TEL de Task 2, généralisé aux catégories décochées.
 - **VLM (F-2 #2, CRITIQUE scanné)** : `_apply_vlm_on_scanned_pdf` (~4898-4965) — masque dans texte+raster indépendamment ; gate par `_category_of(vlm_kind)`.
 - Post-mask cleanups (F-2 #6) : NOM orphan (~5098/5137/5148), TEL fragment (~5118/5128).

@@ -205,11 +210,11 @@ Add `disabled_kinds: set = None` kwarg to `process_pdf` (~l.4973). After `cfg =
 ---

 ## Self-review (couverture spec + revue Qwen + vérif Claude)
- **F-1** : `_category_of` dérivé (VLM_CATEGORY_MAP + EDS_LABEL_MAP + suffixe _GLOBAL) + **test anti-dérive** → couvre les 15 kinds de Qwen ET ceux qu'il a ratés (VLM_CP→masqué). Default-deny. ✓
+- **F-1** : `_category_of` dérivé (VLM_CATEGORY_MAP + EDS_LABEL_MAP + suffixe _GLOBAL) + **test anti-dérive** → couvre les 15 kinds de Qwen ET ceux qu'il a ratés. Default-deny. **CODE_POSTAL→ADRESSE** (décision Dom 2026-06-26). ✓
 - **F-2** : Task 3 liste consolidée incl. propagation globale, VLM, Trackare, structured/critical, cleanups. ✓
 - **F-3** : Task 4 adresse gaté + images/barcodes documentés conservateurs + SKIP_KINDS vérifiés. ✓
- **F-4** : Task 2 coordonne résiduel + **exclusion NIR-like du pattern TEL** + gate selective_rescan/propagation (Task 3). ✓
+- **F-4** : Task 2 coordonne résiduel + **exclusion NIR-like du scan TEL UNIQUEMENT** (backstop IBAN préservé) + **seuil résiduel strict 0** (pas de relâchement aveugle des backstops EMAIL/IBAN) + gate selective_rescan/propagation (Task 3). Contamination croisée des catégories décochées traitée span-précisément en Task 3. ✓
 - **F-5** : Task 3 impose le gating NER **intra-boucle** (per-hit), jamais per-function. ✓
 - **Risque résiduel** : un site oublié ⇒ catégorie reste masquée (test rouge), JAMAIS fuite croisée (default-deny + filtre par catégorie). Livrable PDF garanti par T1 seul.
- **Décision ouverte Dom** : CODE_POSTAL (CP/ZIP) hors des 7 toggles (masqué) — confirmer.
+- **Décision Dom 2026-06-26 (TRANCHÉE)** : CODE_POSTAL (CP/ZIP) → catégorie ADRESSE (suit le toggle « Adresses »). VILLE reste toujours masquée (hors décision).
 - **Re-revue Qwen post-implémentation obligatoire** (Tasks 1-4).
--- a/docs/superpowers/plans/2026-06-29-gui-v6-beta-plan-1c-honnetete-ui.md
+++ b/docs/superpowers/plans/2026-06-29-gui-v6-beta-plan-1c-honnetete-ui.md
@@ -0,0 +1,900 @@
+# GUI V6 → bêta — Plan 1c : honnêteté UI Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Supprimer les derniers contrôles UI trompeurs / non fonctionnels de GUI V6 pour la bêta, et garantir le comportement honnête attendu d'un outil médical (config établissement réellement chargée, avertissement avant de dégrader la détection, erreurs localisables, échange de config par email recâblé).
+
+**Architecture :** Chaque correctif est isolé derrière une **fonction pure testable sans display ni modèle** (résolution de chemin, décision de confirmation, formatage de message, export/import JSON), le widget se contentant de câbler cette fonction. Aucune logique de détection n'est touchée (le gating catégories est déjà livré en Plan 1b). On suit le pattern V5 existant pour la config externe (`Pseudonymisation_Gui_V5._resolve_config`) et le format d'échange JSON consommé par `scripts/merge_params.merge_params`.
+
+**Tech Stack :** Python 3.10-3.12, customtkinter (CTk), tkinter.messagebox/filedialog, pytest (tests purs + `pytest.importorskip("customtkinter")` pour les rares smokes widget), PyYAML.
+
+**Portée (spec chantier D — `docs/superpowers/specs/2026-06-25-gui-v6-beta-prod-design.md`) :**
+- Task 1 — **P1-4** : `config_path` (dictionnaires.yml) réellement résolu et chargé en frozen.
+- Task 2 — **Confirmation NER off** (décision Dom 2026-06-29) : dialogue avant de tomber en regex-only.
+- Task 3 — **P1-5** : erreurs / quarantaine localisables + bouton « Ouvrir le dossier ».
+- Task 4 — **P1-3** : Import / Export de configuration recâblés (workflow email V5).
+- Task 5 — **P1-1** : dropzone honnête (cliquable) — DnD natif différé.
+- Task 6 (optionnel) — **P1-6** : validation d'inscriptibilité du dossier de sortie.
+- Task 7 (optionnel) — **P1-11** : provenance audit `original="docTR"` → `"OnnxTR"`.
+
+**Hors portée (différé, acté) :** DnD natif `tkinterdnd2` (lib native tkdnd à bundler — repoussé pour ne pas alourdir le build torch-free du Plan 3, voir Task 5) ; P2-1/P2-2 (progression/cartes format) traités au mieux mais non bloquants.
+
+**Convention de commit :** un commit atomique par task (core+test ensemble), préfixe conventionnel, finir par `Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>`. Brancher sur `feature/q1-quarantine-mvp`, pousser sur `gitea` (jamais `git add -A` — stager par chemin).
+
+**Commande de test de référence :**
+`.venv/bin/python -m pytest tests/unit/test_gui_v6_*.py -q` (+ gate `synthetic_regression` avant push).
+
+---
+
+### Task 1 : P1-4 — Config externe `dictionnaires.yml` réellement résolue en frozen
+
+**Problème :** `AnonymisationApp` crée `UsageTab` **sans** `config_path` (`gui_v6/app.py:186-193`), donc `to_engine_settings(self._config_path)` reçoit `None` (`tab_usage.py:176`). En frozen, le `dictionnaires.yml` éditable à côté de l'EXE n'est jamais chargé → personnalisations établissement ignorées.
+
+**Files:**
+- Create: `gui_v6/config_paths.py`
+- Create: `tests/unit/test_gui_v6_config_paths.py`
+- Modify: `gui_v6/app.py` (import + `__init__` + appel `UsageTab(...)`)
+
+- [ ] **Step 1 : Écrire les tests (échouent — module absent)**
+
+`tests/unit/test_gui_v6_config_paths.py` :
+
+```python
+"""Résolution du dictionnaires.yml externe éditable (P1-4).
+
+Pur : on simule frozen via monkeypatch (sys.frozen / sys.executable / _MEIPASS),
+aucun display, aucun modèle.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import gui_v6.config_paths as cp
+
+
+def _make_bundle(tmp_path: Path) -> Path:
+    bundle = tmp_path / "bundle"
+    (bundle / "config").mkdir(parents=True)
+    (bundle / "config" / "dictionnaires.yml").write_text("whitelist_phrases: []\n", encoding="utf-8")
+    return bundle
+
+
+def test_dev_returns_repo_config_when_present(monkeypatch):
+    # En dev (non frozen) : pointe la config embarquée si elle existe.
+    monkeypatch.setattr(cp.sys, "frozen", False, raising=False)
+    path = cp.resolve_user_config_path()
+    assert path is not None
+    assert path.name == "dictionnaires.yml"
+    assert path.exists()
+
+
+def test_frozen_copies_bundle_on_first_launch(tmp_path, monkeypatch):
+    bundle = _make_bundle(tmp_path)
+    exe_dir = tmp_path / "exe"
+    exe_dir.mkdir()
+    monkeypatch.setattr(cp.sys, "frozen", True, raising=False)
+    monkeypatch.setattr(cp.sys, "_MEIPASS", str(bundle), raising=False)
+    monkeypatch.setattr(cp.sys, "executable", str(exe_dir / "Anonymisation.exe"), raising=False)
+
+    out = cp.resolve_user_config_path()
+    expected = exe_dir / "config" / "dictionnaires.yml"
+    assert out == expected
+    assert expected.exists()  # copié depuis le bundle au 1er lancement
+    assert expected.read_text(encoding="utf-8") == "whitelist_phrases: []\n"
+
+
+def test_frozen_keeps_existing_user_config(tmp_path, monkeypatch):
+    bundle = _make_bundle(tmp_path)
+    exe_dir = tmp_path / "exe"
+    (exe_dir / "config").mkdir(parents=True)
+    user_cfg = exe_dir / "config" / "dictionnaires.yml"
+    user_cfg.write_text("whitelist_phrases: [HOPITAL_LOCAL]\n", encoding="utf-8")
+    monkeypatch.setattr(cp.sys, "frozen", True, raising=False)
+    monkeypatch.setattr(cp.sys, "_MEIPASS", str(bundle), raising=False)
+    monkeypatch.setattr(cp.sys, "executable", str(exe_dir / "Anonymisation.exe"), raising=False)
+
+    out = cp.resolve_user_config_path()
+    assert out == user_cfg
+    # Ne JAMAIS écraser la perso établissement existante.
+    assert "HOPITAL_LOCAL" in out.read_text(encoding="utf-8")
+```
+
+- [ ] **Step 2 : Lancer → vérifier l'échec**
+
+Run: `.venv/bin/python -m pytest tests/unit/test_gui_v6_config_paths.py -q`
+Expected: FAIL (`ModuleNotFoundError: No module named 'gui_v6.config_paths'`).
+
+- [ ] **Step 3 : Implémenter `gui_v6/config_paths.py`**
+
+```python
+"""Résolution du fichier de configuration externe éditable (dictionnaires.yml).
+
+En frozen (PyInstaller), la config doit vivre À CÔTÉ de l'exécutable pour que
+l'établissement puisse l'éditer sans recompiler ; on copie la version embarquée
+au premier lancement si elle est absente. En développement, on pointe directement
+la config du dépôt. Aligné sur le pattern V5
+(``Pseudonymisation_Gui_V5._resolve_config``), best-effort (jamais de crash).
+"""
+from __future__ import annotations
+
+import shutil
+import sys
+from pathlib import Path
+from typing import Optional
+
+_CONFIG_RELATIVE = Path("config") / "dictionnaires.yml"
+
+
+def _frozen() -> bool:
+    return bool(getattr(sys, "frozen", False))
+
+
+def _bundled_config() -> Path:
+    """Config embarquée : ``_MEIPASS`` en frozen, racine du dépôt en dev."""
+    if _frozen():
+        base = Path(getattr(sys, "_MEIPASS"))
+    else:
+        base = Path(__file__).resolve().parent.parent
+    return base / _CONFIG_RELATIVE
+
+
+def resolve_user_config_path() -> Optional[Path]:
+    """Chemin du ``dictionnaires.yml`` éditable par l'utilisateur.
+
+    - dev : la config du dépôt (éditable en place) ;
+    - frozen : ``<dossier de l'exe>/config/dictionnaires.yml`` ; copie la version
+      embarquée au premier lancement si absente, sans jamais écraser une config
+      existante (perso établissement).
+
+    Renvoie ``None`` si rien n'est résoluble (le moteur retombe alors sur sa
+    config runtime par défaut).
+    """
+    if not _frozen():
+        bundled = _bundled_config()
+        return bundled if bundled.exists() else None
+
+    user_cfg = Path(sys.executable).resolve().parent / _CONFIG_RELATIVE
+    if user_cfg.exists():
+        return user_cfg
+    try:
+        user_cfg.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(_bundled_config(), user_cfg)
+        return user_cfg
+    except Exception:
+        bundled = _bundled_config()
+        return bundled if bundled.exists() else None
+```
+
+- [ ] **Step 4 : Câbler dans `gui_v6/app.py`**
+
+En tête (après les imports `gui_v6`), ajouter :
+
+```python
+from gui_v6.config_paths import resolve_user_config_path
+```
+
+Dans `AnonymisationApp.__init__`, après `self._config = ConfigState()` :
+
+```python
+        self._user_config_path = resolve_user_config_path()
+```
+
+Dans `_create_tab`, branche `"use"`, ajouter le kwarg à `UsageTab(...)` :
+
+```python
+            return UsageTab(
+                self._content,
+                palette=p,
+                config_provider=lambda: self._config,
+                config_path=self._user_config_path,
+                on_theme_change=self.set_theme,
+                current_theme=self._theme_name,
+                usage_reporter=self._report_usage,
+            )
+```
+
+- [ ] **Step 5 : Lancer → vérifier le succès + non-régression socle**
+
+Run: `.venv/bin/python -m pytest tests/unit/test_gui_v6_config_paths.py tests/unit/test_gui_v6_app_shell.py -q`
+Expected: PASS (3 nouveaux + app_shell inchangés).
+
+- [ ] **Step 6 : Commit**
+
+```bash
+git add gui_v6/config_paths.py gui_v6/app.py tests/unit/test_gui_v6_config_paths.py
+git commit -m "feat(gui): charger le dictionnaires.yml externe éditable en frozen (P1-4)"
+```
+
+---
+
+### Task 2 : Confirmation avant désactivation du NER (regex-only) — décision Dom 2026-06-29
+
+**Problème :** Couper le toggle CamemBERT-bio (`tab_config.py:393-395`, callback `_on_ner:893`) bascule en anonymisation **regex seule** sans avertissement. Sur un outil médical, on confirme explicitement.
+
+**Files:**
+- Modify: `gui_v6/tabs/tab_config.py` (constante + helper pur + `_on_ner`)
+- Create: `tests/unit/test_gui_v6_ner_confirm.py`
+
+- [ ] **Step 1 : Écrire les tests (échouent — symbole absent)**
+
+`tests/unit/test_gui_v6_ner_confirm.py` :
+
+```python
+"""Confirmation avant de désactiver le NER (regex-only) — outil médical.
+
+Pur : la décision est isolée dans ``confirm_ner_disable(asker)`` ; ``asker`` est
+injecté (pas de messagebox réel, pas de display).
+"""
+from __future__ import annotations
+
+from gui_v6.tabs.tab_config import NER_DISABLE_WARNING, confirm_ner_disable
+
+
+def test_confirm_true_when_user_accepts():
+    assert confirm_ner_disable(lambda: True) is True
+
+
+def test_confirm_false_when_user_declines():
+    assert confirm_ner_disable(lambda: False) is False
+
+
+def test_warning_text_is_explicit_for_medical_use():
+    txt = NER_DISABLE_WARNING.lower()
+    # L'avertissement DOIT nommer la dégradation : règles/regex + risque noms.
+    assert "règles" in txt or "regex" in txt
+    assert "nom" in txt
+    assert "recommand" in txt  # « fortement recommandé »
+```
+
+- [ ] **Step 2 : Lancer → vérifier l'échec**
+
+Run: `.venv/bin/python -m pytest tests/unit/test_gui_v6_ner_confirm.py -q`
+Expected: FAIL (`ImportError: cannot import name 'confirm_ner_disable'`).
+
+- [ ] **Step 3 : Ajouter la constante + le helper pur dans `tab_config.py`**
+
+Après les imports (sous `from tkinter import filedialog, messagebox`), au niveau module :
+
+```python
+NER_DISABLE_WARNING = (
+    "Vous allez désactiver le moteur d'intelligence artificielle "
+    "(CamemBERT-bio).\n\n"
+    "Sans lui, la détection des NOMS de personnes repose uniquement sur des "
+    "règles (expressions régulières) : des noms peuvent rester EN CLAIR dans "
+    "les documents.\n\n"
+    "Pour un usage médical, garder ce moteur activé est fortement recommandé.\n\n"
+    "Confirmer la désactivation ?"
+)
+
+
+def confirm_ner_disable(asker) -> bool:
+    """Décision de désactivation du NER.
+
+    ``asker`` est une fonction ``() -> bool`` (ex. ``messagebox.askyesno``),
+    injectée pour rester testable sans display. Retourne True si l'utilisateur
+    CONFIRME la désactivation (regex-only), False sinon.
+    """
+    return bool(asker())
+```
+
+- [ ] **Step 4 : Câbler `_on_ner` (intercepter le passage à OFF)**
+
+Remplacer `_on_ner` (`tab_config.py:893-894`) par :
+
+```python
+    def _on_ner(self) -> None:
+        new_value = self._tog_ner.get()
+        if not new_value:
+            confirmed = confirm_ner_disable(
+                lambda: messagebox.askyesno(
+                    "Moteur de détection", NER_DISABLE_WARNING, icon="warning"
+                )
+            )
+            if not confirmed:
+                # Refus : rétablir l'affichage du switch et garder le NER actif.
+                self._tog_ner.var.set(True)
+                self._state.use_local_ner = True
+                return
+        self._state.use_local_ner = new_value
+```
+
+- [ ] **Step 5 : Lancer → vérifier le succès**
+
+Run: `.venv/bin/python -m pytest tests/unit/test_gui_v6_ner_confirm.py tests/unit/test_gui_v6_config_mockup_sections.py -q`
+Expected: PASS (3 nouveaux + sections inchangées).
+
+- [ ] **Step 6 : Commit**
+
+```bash
+git add gui_v6/tabs/tab_config.py tests/unit/test_gui_v6_ner_confirm.py
+git commit -m "feat(gui): confirmation explicite avant anonymisation regex-only (NER off)"
+```
+
+---
+
+### Task 3 : P1-5 — Erreurs / quarantaine localisables + « Ouvrir le dossier »
+
+**Problème :** En fin de run, `_finish` (`tab_usage.py:271-283`) n'indique pas OÙ trouver les documents livrés ni que les documents en échec/quarantaine ne sont **pas** anonymisés. Le testeur reste bloqué.
+
+**Files:**
+- Create: `gui_v6/fsutil.py` (ouverture cross-plateforme du dossier)
+- Create: `tests/unit/test_gui_v6_result_hint.py`
+- Modify: `gui_v6/tabs/tab_usage.py` (helper pur `failure_hint`, mémoriser le dossier de sortie, afficher hint + bouton)
+
+- [ ] **Step 1 : Écrire les tests (échouent)**
+
+`tests/unit/test_gui_v6_result_hint.py` :
+
+```python
+"""Message d'aide localisant les documents non livrés (P1-5) + ouverture dossier.
+
+Pur : pas de display. ``failure_hint`` formate un texte ; ``open_in_file_manager``
+dispatch vers la bonne commande OS (monkeypatchée).
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import gui_v6.fsutil as fsutil
+from gui_v6.processing_runner import RunSummary
+from gui_v6.tabs.tab_usage import failure_hint
+
+
+def test_no_hint_when_all_ok():
+    s = RunSummary(total=3, succeeded=3, failed=0)
+    assert failure_hint(s, Path("/out")) is None
+
+
+def test_hint_when_failures_mentions_output_dir():
+    s = RunSummary(total=3, succeeded=2, failed=1)
+    hint = failure_hint(s, Path("/out/anonymise"))
+    assert hint is not None
+    assert "/out/anonymise" in hint
+    # Honnêteté : préciser que les échecs ne sont PAS anonymisés.
+    assert "pas" in hint.lower()
+
+
+def test_hint_when_stopped():
+    s = RunSummary(total=3, succeeded=1, failed=0, stopped=True)
+    assert failure_hint(s, Path("/out")) is not None
+
+
+def test_no_hint_without_output_dir():
+    s = RunSummary(total=1, succeeded=0, failed=1)
+    assert failure_hint(s, None) is None
+
+
+def test_open_in_file_manager_dispatches(monkeypatch):
+    calls = {}
+    monkeypatch.setattr(fsutil.sys, "platform", "linux")
+    monkeypatch.setattr(fsutil.subprocess, "Popen", lambda args, **k: calls.setdefault("args", args))
+    fsutil.open_in_file_manager(Path("/out"))
+    assert calls["args"][0] == "xdg-open"
+    assert calls["args"][1] == "/out"
+```
+
+- [ ] **Step 2 : Lancer → vérifier l'échec**
+
+Run: `.venv/bin/python -m pytest tests/unit/test_gui_v6_result_hint.py -q`
+Expected: FAIL (`ModuleNotFoundError: gui_v6.fsutil` / `failure_hint` absent).
+
+- [ ] **Step 3 : Implémenter `gui_v6/fsutil.py`**
+
+```python
+"""Ouverture du gestionnaire de fichiers sur un dossier (cross-plateforme).
+
+Best-effort : ne lève jamais (un échec d'ouverture ne doit pas casser l'UI).
+"""
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+
+def open_in_file_manager(path) -> None:
+    """Ouvre ``path`` dans l'explorateur de fichiers du système."""
+    target = str(Path(path))
+    try:
+        if sys.platform.startswith("win"):
+            import os
+
+            os.startfile(target)  # type: ignore[attr-defined]  # noqa: S606
+        elif sys.platform == "darwin":
+            subprocess.Popen(["open", target])
+        else:
+            subprocess.Popen(["xdg-open", target])
+    except Exception:
+        pass
+```
+
+- [ ] **Step 4 : Ajouter `failure_hint` (pur) dans `tab_usage.py`**
+
+Au niveau module (après `_HELP_USAGE`) :
+
+```python
+def failure_hint(summary, output_dir) -> str | None:
+    """Message localisant les documents livrés, ou None si run nominal.
+
+    Honnête : les documents en échec / quarantaine ne sont PAS anonymisés et
+    ne sont donc pas écrits dans le dossier de sortie.
+    """
+    if summary is None or output_dir is None:
+        return None
+    if summary.failed == 0 and not getattr(summary, "stopped", False):
+        return None
+    return (
+        f"Documents anonymisés écrits dans : {output_dir}\n"
+        "Les documents en échec ou en quarantaine ne sont PAS anonymisés et "
+        "n'ont pas été écrits."
+    )
+```
+
+- [ ] **Step 5 : Mémoriser le dossier de sortie effectif + afficher hint/bouton**
+
+Dans `_start`, après `run_runner, run_output_dir = self._build_run_runner()` :
+
+```python
+        self._last_output_dir = run_output_dir or default_output_dir(self._input_path)
+```
+
+Dans `_finish`, à la fin (après `self._show_results(summary)`), ajouter l'appel :
+
+```python
+        self._show_failure_hint(summary)
+```
+
+Puis ajouter la méthode (après `_show_results`) :
+
+```python
+    def _show_failure_hint(self, summary) -> None:
+        hint = failure_hint(summary, getattr(self, "_last_output_dir", None))
+        if hint is None:
+            return
+        p = self._p
+        row = ctk.CTkFrame(self._rsec, fg_color="transparent")
+        row.pack(fill="x", padx=16, pady=(0, 12))
+        ctk.CTkLabel(
+            row, text=hint, text_color=p["text_dim"], font=ui_kit.font(11),
+            anchor="w", justify="left",
+        ).pack(side="left", fill="x", expand=True)
+        ui_kit.secondary_button(
+            row, p, "📂 Ouvrir le dossier",
+            command=lambda: open_in_file_manager(self._last_output_dir),
+        ).pack(side="right")
+```
+
+Ajouter en tête de `tab_usage.py` :
+
+```python
+from gui_v6.fsutil import open_in_file_manager
+```
+
+- [ ] **Step 6 : Lancer → vérifier le succès**
+
+Run: `.venv/bin/python -m pytest tests/unit/test_gui_v6_result_hint.py tests/unit/test_gui_v6_processing_runner.py -q`
+Expected: PASS.
+
+- [ ] **Step 7 : Commit**
+
+```bash
+git add gui_v6/fsutil.py gui_v6/tabs/tab_usage.py tests/unit/test_gui_v6_result_hint.py
+git commit -m "feat(gui): localiser les documents livrés + bouton ouvrir le dossier (P1-5)"
+```
+
+---
+
+### Task 4 : P1-3 — Import / Export de configuration recâblés (workflow email V5)
+
+**Problème :** Les boutons Partage sont des `_mockup_button` désactivés « (à venir) » (`tab_config.py:847,855`), alors que l'échange de config par email (export JSON → `merge_params` → renvoi YAML) est un workflow produit clé (CLAUDE.md). En V6, les listes whitelist/blacklist vivent dans le **profil actif** (`_pro_term_lists`, `tab_config.py:721-722,747-748`).
+
+**Décision de modèle (à confirmer en revue) :** l'export produit le format V5 consommé par `merge_params` : `{"version", "date_export", "whitelist_phrases", "blacklist_force_mask_terms"}`, alimenté par les listes du **profil actuellement chargé dans l'éditeur** (`self._pro_term_lists`). L'import fusionne le JSON reçu dans le `dictionnaires.yml` utilisateur résolu (Task 1) via `merge_params`.
+
+**Files:**
+- Create: `gui_v6/config_share.py` (sérialisation pure export/import)
+- Create: `tests/unit/test_gui_v6_config_share.py`
+- Modify: `gui_v6/tabs/tab_config.py` (`_build_partage` : vrais boutons + handlers ; passer `config_path`)
+- Modify: `gui_v6/app.py` (passer `config_path=self._user_config_path` à `ConfigTab`)
+
+- [ ] **Step 1 : Écrire les tests (échouent)**
+
+`tests/unit/test_gui_v6_config_share.py` :
+
+```python
+"""Export / import de configuration (P1-3) — format compatible merge_params.
+
+Pur : sérialisation/désérialisation et fusion, sans display ni filedialog.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from gui_v6.config_share import build_export_payload, import_config_file
+
+
+def test_export_payload_has_v5_schema():
+    payload = build_export_payload(
+        whitelist=["Dr Métier", "Service ORL"],
+        blacklist=["DUPONT"],
+        version="2026.06.29",
+    )
+    assert payload["version"] == "2026.06.29"
+    assert "date_export" in payload
+    assert payload["whitelist_phrases"] == ["Dr Métier", "Service ORL"]
+    assert payload["blacklist_force_mask_terms"] == ["DUPONT"]
+
+
+def test_export_payload_is_json_serializable():
+    payload = build_export_payload(whitelist=["A"], blacklist=["B"], version="1")
+    json.dumps(payload)  # ne doit pas lever
+
+
+def test_import_merges_into_user_config(tmp_path, monkeypatch):
+    # Config utilisateur YAML minimale.
+    cfg = tmp_path / "dictionnaires.yml"
+    cfg.write_text("whitelist_phrases: [Existant]\n", encoding="utf-8")
+    # JSON reçu d'un établissement.
+    incoming = tmp_path / "recu.json"
+    incoming.write_text(
+        json.dumps({
+            "version": "1", "date_export": "2026-06-29",
+            "whitelist_phrases": ["Nouveau"],
+            "blacklist_force_mask_terms": ["MASQUERMOI"],
+        }),
+        encoding="utf-8",
+    )
+    added = import_config_file(incoming, cfg)
+    assert added is True
+    import yaml
+    merged = yaml.safe_load(cfg.read_text(encoding="utf-8"))
+    assert "Existant" in merged["whitelist_phrases"]
+    assert "Nouveau" in merged["whitelist_phrases"]
+    assert "MASQUERMOI" in merged["blacklist"]["force_mask_terms"]
+
+
+def test_import_returns_false_when_nothing_new(tmp_path):
+    cfg = tmp_path / "dictionnaires.yml"
+    cfg.write_text("whitelist_phrases: [Deja]\n", encoding="utf-8")
+    incoming = tmp_path / "recu.json"
+    incoming.write_text(
+        json.dumps({"whitelist_phrases": ["Deja"], "blacklist_force_mask_terms": []}),
+        encoding="utf-8",
+    )
+    assert import_config_file(incoming, cfg) is False
+```
+
+- [ ] **Step 2 : Lancer → vérifier l'échec**
+
+Run: `.venv/bin/python -m pytest tests/unit/test_gui_v6_config_share.py -q`
+Expected: FAIL (`ModuleNotFoundError: gui_v6.config_share`).
+
+- [ ] **Step 3 : Implémenter `gui_v6/config_share.py`**
+
+```python
+"""Échange de configuration par fichier JSON (workflow email V5, P1-3).
+
+- ``build_export_payload`` : produit le dict V5 (consommé par
+  ``scripts/merge_params.merge_params``) à partir des listes du profil courant ;
+- ``import_config_file`` : fusionne un JSON reçu dans le ``dictionnaires.yml``
+  utilisateur, sans écraser l'existant (réutilise ``merge_params``).
+
+Aucune dépendance à un widget : testable en pur Python.
+"""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Iterable
+
+EXPORT_VERSION = "1"
+
+
+def build_export_payload(
+    whitelist: Iterable[str], blacklist: Iterable[str], version: str = EXPORT_VERSION
+) -> dict:
+    """Construit la charge utile d'export au format consommé par merge_params."""
+    return {
+        "version": version,
+        "date_export": datetime.now(timezone.utc).isoformat(),
+        "whitelist_phrases": [str(t) for t in whitelist],
+        "blacklist_force_mask_terms": [str(t) for t in blacklist],
+    }
+
+
+def _yaml_lists(config_path: Path) -> tuple[set, set]:
+    import yaml
+
+    cfg = yaml.safe_load(config_path.read_text(encoding="utf-8")) or {}
+    wl = set(cfg.get("whitelist_phrases", []) or [])
+    bl = set((cfg.get("blacklist", {}) or {}).get("force_mask_terms", []) or [])
+    return wl, bl
+
+
+def import_config_file(json_path, config_path) -> bool:
+    """Fusionne ``json_path`` dans ``config_path`` (YAML). Retourne True si la
+    config a changé, False si rien de nouveau.
+
+    Fusion autonome (union des listes, jamais d'écrasement) — volontairement
+    SANS dépendance à ``scripts/merge_params`` (non bundlé en frozen). Même
+    sémantique : ``whitelist_phrases`` et ``blacklist.force_mask_terms``.
+    """
+    import json
+    import yaml
+
+    json_path = Path(json_path)
+    config_path = Path(config_path)
+    before_wl, before_bl = _yaml_lists(config_path)
+
+    data = json.loads(json_path.read_text(encoding="utf-8"))
+    incoming_wl = {str(t).strip() for t in data.get("whitelist_phrases", []) if str(t).strip()}
+    incoming_bl = {str(t).strip() for t in data.get("blacklist_force_mask_terms", []) if str(t).strip()}
+
+    after_wl = before_wl | incoming_wl
+    after_bl = before_bl | incoming_bl
+    if after_wl == before_wl and after_bl == before_bl:
+        return False
+
+    cfg = yaml.safe_load(config_path.read_text(encoding="utf-8")) or {}
+    cfg["whitelist_phrases"] = sorted(after_wl)
+    cfg.setdefault("blacklist", {})
+    cfg["blacklist"]["force_mask_terms"] = sorted(after_bl)
+    config_path.write_text(
+        yaml.dump(cfg, allow_unicode=True, default_flow_style=False, sort_keys=False),
+        encoding="utf-8",
+    )
+    return True
+```
+
+> Note implémentation : fusion autonome (pas d'import de `scripts/`), donc robuste en frozen. Le format JSON (`whitelist_phrases` / `blacklist_force_mask_terms`) reste celui consommé par `scripts/merge_params.py:52-58` → compatibilité email V5 préservée.
+
+- [ ] **Step 4 : Recâbler `_build_partage` (vrais boutons)**
+
+Remplacer les deux `self._mockup_button(...)` de `_build_partage` (`tab_config.py:847,855`) par de vrais boutons :
+
+```python
+        ui_kit.secondary_button(
+            export, p, "⬇ Exporter (.json)", command=self._on_export_config
+        ).pack(anchor="w", padx=12, pady=(0, 12))
+        ...
+        ui_kit.secondary_button(
+            import_card, p, "⬆ Importer (.json)", command=self._on_import_config
+        ).pack(anchor="w", padx=12, pady=(0, 12))
+```
+
+Ajouter les handlers (section « callbacks réglages », après `_on_manual_mask_template`) :
+
+```python
+    def _on_export_config(self) -> None:
+        from gui_v6.config_share import build_export_payload
+        import json
+
+        lists = getattr(self, "_pro_term_lists", {})
+        wl = lists["whitelist"].terms() if "whitelist" in lists else []
+        bl = lists["blacklist"].terms() if "blacklist" in lists else []
+        path = filedialog.asksaveasfilename(
+            title="Exporter la configuration", defaultextension=".json",
+            filetypes=[("Configuration JSON", "*.json")],
+        )
+        if not path:
+            return
+        try:
+            payload = build_export_payload(wl, bl)
+            Path(path).write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+            messagebox.showinfo("Export", f"Configuration exportée :\n{path}")
+        except Exception as exc:  # pragma: no cover - chemin UI
+            messagebox.showerror("Export", f"Échec de l'export : {exc}")
+
+    def _on_import_config(self) -> None:
+        from gui_v6.config_share import import_config_file
+
+        if self._config_path is None:
+            messagebox.showerror("Import", "Aucune configuration cible résolue.")
+            return
+        path = filedialog.askopenfilename(
+            title="Importer une configuration",
+            filetypes=[("Configuration JSON", "*.json")],
+        )
+        if not path:
+            return
+        try:
+            changed = import_config_file(path, self._config_path)
+            if changed:
+                messagebox.showinfo("Import", "Configuration fusionnée. Redémarrez pour appliquer.")
+            else:
+                messagebox.showinfo("Import", "Rien de nouveau à fusionner.")
+        except Exception as exc:  # pragma: no cover - chemin UI
+            messagebox.showerror("Import", f"Échec de l'import : {exc}")
+```
+
+- [ ] **Step 5 : Donner à `ConfigTab` le `config_path`**
+
+Dans `ConfigTab.__init__`, accepter et stocker `config_path` (signature : ajouter `config_path: Path | None = None`, et `self._config_path = config_path`). Dans `gui_v6/app.py:_create_tab`, branche `"cfg"` :
+
+```python
+        if key == "cfg":
+            return ConfigTab(self._content, palette=p, state=self._config, config_path=self._user_config_path)
+```
+
+- [ ] **Step 6 : Lancer → vérifier le succès + non-régression**
+
+Run: `.venv/bin/python -m pytest tests/unit/test_gui_v6_config_share.py tests/unit/test_gui_v6_config_mockup_sections.py tests/unit/test_gui_v6_app_shell.py -q`
+Expected: PASS (le test `test_config_mockup_sections` reste vert : ne pas changer `CONFIG_MOCKUP_SECTIONS`, seulement le câblage des boutons Partage).
+
+- [ ] **Step 7 : Commit**
+
+```bash
+git add gui_v6/config_share.py gui_v6/tabs/tab_config.py gui_v6/app.py tests/unit/test_gui_v6_config_share.py
+git commit -m "feat(gui): recâbler import/export de configuration par email (P1-3)"
+```
+
+---
+
+### Task 5 : P1-1 — Dropzone honnête (cliquable)
+
+**Problème :** La zone « Choisissez vos fichiers » (`tab_usage.py:103-115`) suggère un glisser-déposer inexistant. Le DnD natif (`tkinterdnd2`) impose la lib native tkdnd à bundler dans le frozen → **différé** (ne pas alourdir le build torch-free du Plan 3). Fix bêta : rendre la zone **cliquable** (ouvre le sélecteur de fichier) + libellé honnête. Les boutons Fichier/Dossier existants restent.
+
+**Files:**
+- Modify: `gui_v6/tabs/tab_usage.py` (rendre la dropzone cliquable + libellé)
+
+- [ ] **Step 1 : Rendre la dropzone cliquable + libellé honnête**
+
+Dans `_build`, remplacer le label « Choisissez vos fichiers » et lier le clic. Après la création de `dz` (`tab_usage.py:103-106`), lier le clic de la zone et de ses labels à `_pick_file` :
+
+```python
+        dz.bind("<Button-1>", lambda _e: self._pick_file())
+        ctk.CTkLabel(dz, text="⬆️", font=ui_kit.font(30)).pack(pady=(20, 4))
+        zone_lbl = ctk.CTkLabel(dz, text="Cliquez pour choisir un fichier", text_color=p["text"], font=ui_kit.font(14))
+        zone_lbl.pack()
+        zone_lbl.bind("<Button-1>", lambda _e: self._pick_file())
+        ctk.CTkLabel(dz, text="PDF · Word · Images · Texte", text_color=p["text_muted"], font=ui_kit.font(12)).pack(pady=(2, 10))
+```
+
+(la ligne `ctk.CTkLabel(dz, text="⬆️"...)` d'origine est remplacée par le bloc ci-dessus ; les boutons `acts` restent inchangés).
+
+- [ ] **Step 2 : Smoke import (pas de régression d'import)**
+
+Run: `.venv/bin/python -m pytest tests/unit/test_gui_v6_processing_runner.py -q && .venv/bin/python Pseudonymisation_Gui_V6.py --self-test`
+Expected: PASS + `GUI V6 self-test OK`.
+
+- [ ] **Step 3 : Commit**
+
+```bash
+git add gui_v6/tabs/tab_usage.py
+git commit -m "feat(gui): dropzone cliquable + libellé honnête (P1-1, DnD natif différé)"
+```
+
+---
+
+### Task 6 (optionnel) : P1-6 — Valider l'inscriptibilité du dossier de sortie
+
+**Problème :** Un dossier de sortie en lecture seule fait échouer **chaque** document avec un message cryptique (`processing_runner.py:215` `mkdir` puis échec par doc). Tester l'inscriptibilité en amont donne un message clair unique.
+
+**Files:**
+- Modify: `gui_v6/processing_runner.py` (`_run_impl` : test d'écriture amont)
+- Create/Modify: `tests/unit/test_gui_v6_processing_runner.py` (nouveau test)
+
+- [ ] **Step 1 : Test (échoue)**
+
+Ajouter à `tests/unit/test_gui_v6_processing_runner.py` :
+
+```python
+def test_run_fails_fast_when_output_not_writable(tmp_path, monkeypatch):
+    from gui_v6.processing_runner import ProcessingRunner, OutputNotWritableError
+    src = tmp_path / "in"
+    src.mkdir()
+    (src / "a.txt").write_text("x", encoding="utf-8")
+    out = tmp_path / "ro"
+    out.mkdir()
+
+    def boom(*a, **k):
+        raise PermissionError("read-only")
+
+    monkeypatch.setattr("gui_v6.processing_runner.Path.mkdir", boom)
+    runner = ProcessingRunner(process_fn=lambda d, o: {})
+    import pytest
+    with pytest.raises(OutputNotWritableError):
+        runner.run(src, out)
+```
+
+- [ ] **Step 2 : Lancer → vérifier l'échec**
+
+Run: `.venv/bin/python -m pytest tests/unit/test_gui_v6_processing_runner.py::test_run_fails_fast_when_output_not_writable -q`
+Expected: FAIL (`OutputNotWritableError` absent).
+
+- [ ] **Step 3 : Implémenter le garde-fou**
+
+Dans `gui_v6/processing_runner.py`, ajouter la classe d'erreur (près des dataclasses) :
+
+```python
+class OutputNotWritableError(RuntimeError):
+    """Le dossier de sortie n'est pas inscriptible (échec amont, message clair)."""
+```
+
+Dans `_run_impl`, après le calcul de `out_root` (`:186`) et **avant** la boucle, vérifier une fois :
+
+```python
+        try:
+            out_root.mkdir(parents=True, exist_ok=True)
+            probe = out_root / ".anon_write_test"
+            probe.write_text("", encoding="utf-8")
+            probe.unlink()
+        except Exception as exc:
+            raise OutputNotWritableError(
+                f"Dossier de sortie non inscriptible : {out_root} ({exc})"
+            ) from exc
+```
+
+- [ ] **Step 4 : Lancer → vérifier le succès + non-régression runner**
+
+Run: `.venv/bin/python -m pytest tests/unit/test_gui_v6_processing_runner.py -q`
+Expected: PASS (nouveau + existants).
+
+> Note UI : `UsageTab._handle_event`/`work()` capture déjà `Exception` → le message d'`OutputNotWritableError` s'affiche dans le journal. Vérifier qu'il remonte lisible (pas de doublon par document).
+
+- [ ] **Step 5 : Commit**
+
+```bash
+git add gui_v6/processing_runner.py tests/unit/test_gui_v6_processing_runner.py
+git commit -m "feat(gui): échec amont clair si dossier de sortie non inscriptible (P1-6)"
+```
+
+---
+
+### Task 7 (optionnel) : P1-11 — Provenance audit `docTR` → `OnnxTR`
+
+**Problème :** L'audit JSONL trace `original="docTR"` (`anonymizer_core_refactored_onnx.py:5356`) alors que l'OCR est OnnxTR depuis la migration. Trace périmée visible dans le livrable client.
+
+**Files:**
+- Modify: `anonymizer_core_refactored_onnx.py:5356`
+- Test: gate `synthetic_regression` (pas de nouveau test dédié — provenance cosmétique).
+
+- [ ] **Step 1 : Localiser et corriger**
+
+Run: `.venv/bin/python - <<'PY'\nimport re,io\np="anonymizer_core_refactored_onnx.py"\ns=open(p,encoding="utf-8").read()\nprint([l for l in s.splitlines() if 'docTR' in l and 'original' in l][:3])\nPY`
+Remplacer la valeur de provenance `"docTR"` par `"OnnxTR"` à la ligne d'audit identifiée (uniquement la chaîne de provenance OCR, ne pas toucher aux commentaires/docstrings cosmétiques P2-3).
+
+- [ ] **Step 2 : Non-régression**
+
+Run: `.venv/bin/python -m pytest tests/unit -q -k "synthetic_regression or audit"`
+Expected: PASS (sortie d'anonymisation inchangée ; seule la provenance change).
+
+- [ ] **Step 3 : Commit**
+
+```bash
+git add anonymizer_core_refactored_onnx.py
+git commit -m "fix(core): corriger la provenance OCR de l'audit (docTR → OnnxTR, P1-11)"
+```
+
+---
+
+## Clôture du Plan 1c
+
+- [ ] **Suite complète + gate**
+
+Run: `.venv/bin/python -m pytest tests/unit -q` (attendu : 436 + nouveaux tests, 0 régression) puis le gate `synthetic_regression` du dépôt.
+
+- [ ] **Self-test GUI**
+
+Run: `.venv/bin/python Pseudonymisation_Gui_V6.py --self-test`
+Expected: `GUI V6 self-test OK`.
+
+- [ ] **Revue + push**
+
+Revue Qwen **courte** recommandée (1c = honnêteté UI, hors cœur sécurité masquage — pas de revue bloquante comme 1b, mais signaler la décision « confirmation NER » et le modèle export profil-actif). Puis push `gitea/feature/q1-quarantine-mvp`. Mettre à jour la mémoire projet `gui_v6_beta_prod_chantier.md`.
+
+---
+
+## Self-Review (auteur du plan)
+
+**Couverture spec (chantier D) :** P1-2 = déjà livré (Plan 1b, hors périmètre ici) ✓ ; P1-1 = Task 5 (cliquable, DnD différé — **déviation assumée** vs spec « tkinterdnd2 », à valider Dom) ; P1-3 = Task 4 ; P1-4 = Task 1 ; P1-5 = Task 3 ; confirmation NER = Task 2 (décision Dom 2026-06-29) ; P1-6 = Task 6 (optionnel) ; P1-11 = Task 7 (optionnel). P2-1/P2-2 non traités (best-effort, non bloquants) — **signalé**.
+
+**Placeholders :** aucun « TODO / à compléter » ; chaque step porte le code réel.
+
+**Cohérence des types/symboles :** `resolve_user_config_path` (Task 1) réutilisé en Task 4 (Step 5) ; `failure_hint`/`open_in_file_manager` (Task 3) cohérents avec leur test ; `build_export_payload`/`import_config_file` (Task 4) ⇄ schéma `merge_params` (`whitelist_phrases` / `blacklist_force_mask_terms`) vérifié contre `scripts/merge_params.py:52-58`. `self._tog_ner.var` confirmé exposé par `_mini_toggle` (`tab_config.py:1107`).
+
+**Hypothèses à confirmer en revue :**
+1. **Task 4** exporte les listes du **profil chargé dans l'éditeur** (`_pro_term_lists`). Si l'attendu est « toutes les listes globales » ou « le profil par défaut », ajuster la source des listes.
+2. **Task 5** dévie de la spec (DnD natif → cliquable). Justification : éviter la lib native tkdnd dans le build torch-free. À confirmer.
+
+*(Hypothèse « scripts importable » levée : la fusion d'import est désormais autonome, frozen-safe — vérifié `scripts/__init__.py` absent et `scripts/` non bundlé.)*
--- a/gui_v6/init.py
+++ b/gui_v6/init.py
@@ -8,4 +8,6 @@ Lot G1 (socle) : thème, client/stockage licence, shell minimal, onglet À propo

 __all__ = ["__version__"]

-__version__ = "6.0.0-g1"
+from gui_v6.version import resolve_version
+
+__version__ = resolve_version()
--- a/gui_v6/app.py
+++ b/gui_v6/app.py
@@ -18,6 +18,7 @@ import customtkinter as ctk

 from gui_v6 import theme as theme_mod
 from gui_v6 import ui_kit
+from gui_v6.config_paths import resolve_user_config_path
 from gui_v6.config_state import ConfigState
 from gui_v6.license_client import LicenseClient, LicenseStatus
 from gui_v6.machine_id import default_machine_id
@@ -70,6 +71,7 @@ class AnonymisationApp(ctk.CTk):
        self._theme_name = theme_name
        self._license_client = license_client or LicenseClient(resolve_portal_url())
        self._config = ConfigState()
+        self._user_config_path = resolve_user_config_path()
        self._active = "use"
        self._tab_buttons: dict = {}
        self._tab_frames: dict = {}
@@ -187,12 +189,14 @@ class AnonymisationApp(ctk.CTk):
                self._content,
                palette=p,
                config_provider=lambda: self._config,
+                config_path=self._user_config_path,
                on_theme_change=self.set_theme,
                current_theme=self._theme_name,
                usage_reporter=self._report_usage,
+                diag_reporter=self._report_diagnostics,
            )
        if key == "cfg":
-            return ConfigTab(self._content, palette=p, state=self._config)
+            return ConfigTab(self._content, palette=p, state=self._config, config_path=self._user_config_path)
        return AboutTab(
            self._content,
            palette=p,
@@ -240,6 +244,36 @@ class AnonymisationApp(ctk.CTk):
        except Exception:
            pass

+    def _report_diagnostics(self, summary) -> None:
+        """Envoie les diagnostics en fin de run (non bloquant, best-effort).
+
+        N'envoie rien si aucune licence locale valide. Ne lève jamais.
+        """
+        try:
+            from gui_v6 import __version__ as gui_version
+            from gui_v6 import diagnostics
+            from gui_v6.logging_setup import log_file_path
+            from gui_v6.machine_id import default_machine_id
+
+            session = self._usage_session()
+            if session is None:
+                return
+            status = self._safe_local_status()
+            base_url = getattr(self._license_client, "_base_url", "") or resolve_portal_url()
+            spool = log_file_path().parent / "diagnostics_spool.jsonl"
+            diagnostics.report_run_diagnostics(
+                summary,
+                base_url=base_url,
+                license_ref=getattr(status, "license_ref", None),
+                machine_id=default_machine_id(),
+                session=session,
+                app_name="gui_v6",
+                app_version=gui_version,
+                spool_path=spool,
+            )
+        except Exception:
+            pass
+
    def _show(self, key: str) -> None:
        self._active = key
        self._refresh_tabbar()
--- a/gui_v6/config_paths.py
+++ b/gui_v6/config_paths.py
@@ -0,0 +1,62 @@
+"""Résolution du fichier de configuration externe éditable (dictionnaires.yml).
+
+En frozen (PyInstaller), la config doit vivre À CÔTÉ de l'exécutable pour que
+l'établissement puisse l'éditer sans recompiler ; on copie la version embarquée
+au premier lancement si elle est absente. En développement, on pointe directement
+la config du dépôt. Aligné sur le pattern V5
+(``Pseudonymisation_Gui_V5._resolve_config``), best-effort (jamais de crash).
+"""
+from __future__ import annotations
+
+import logging
+import shutil
+import sys
+from pathlib import Path
+from typing import Optional
+
+log = logging.getLogger(__name__)
+
+_CONFIG_RELATIVE = Path("config") / "dictionnaires.yml"
+
+
+def _frozen() -> bool:
+    return bool(getattr(sys, "frozen", False))
+
+
+def _bundled_config() -> Path:
+    """Config embarquée : ``_MEIPASS`` en frozen, racine du dépôt en dev."""
+    if _frozen():
+        base = Path(getattr(sys, "_MEIPASS"))
+    else:
+        base = Path(__file__).resolve().parent.parent
+    return base / _CONFIG_RELATIVE
+
+
+def resolve_user_config_path() -> Optional[Path]:
+    """Chemin du ``dictionnaires.yml`` éditable par l'utilisateur.
+
+    - dev : la config du dépôt (éditable en place) ; on ne crée jamais le fichier
+      (contrairement à la V5) : si absent, on renvoie ``None`` (le moteur retombe
+      sur sa config par défaut) ;
+    - frozen : ``<dossier de l'exe>/config/dictionnaires.yml`` ; copie la version
+      embarquée au premier lancement si absente, sans jamais écraser une config
+      existante (perso établissement).
+
+    Renvoie ``None`` si rien n'est résoluble (le moteur retombe alors sur sa
+    config runtime par défaut).
+    """
+    if not _frozen():
+        bundled = _bundled_config()
+        return bundled if bundled.exists() else None
+
+    user_cfg = Path(sys.executable).resolve().parent / _CONFIG_RELATIVE
+    if user_cfg.exists():
+        return user_cfg
+    try:
+        user_cfg.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(_bundled_config(), user_cfg)
+        return user_cfg
+    except Exception as exc:
+        log.warning("copie de la configuration externe échouée (%s) : %s", user_cfg, exc)
+        bundled = _bundled_config()
+        return bundled if bundled.exists() else None
--- a/gui_v6/config_share.py
+++ b/gui_v6/config_share.py
@@ -0,0 +1,72 @@
+"""Échange de configuration par fichier JSON (workflow email V5, P1-3).
+
+- ``build_export_payload`` : produit le dict V5 (format consommé par
+  ``scripts/merge_params.merge_params``) à partir des listes du profil courant ;
+- ``import_config_file`` : fusionne un JSON reçu dans le ``dictionnaires.yml``
+  utilisateur, sans écraser l'existant.
+
+Aucune dépendance à un widget : testable en pur Python.
+"""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Iterable
+
+EXPORT_VERSION = "1"
+
+
+def build_export_payload(
+    whitelist: Iterable[str], blacklist: Iterable[str], version: str = EXPORT_VERSION
+) -> dict:
+    """Construit la charge utile d'export au format consommé par merge_params."""
+    return {
+        "version": version,
+        "date_export": datetime.now(timezone.utc).isoformat(),
+        "whitelist_phrases": [str(t) for t in whitelist],
+        "blacklist_force_mask_terms": [str(t) for t in blacklist],
+    }
+
+
+def _yaml_lists(config_path: Path) -> tuple[set, set]:
+    import yaml
+
+    cfg = yaml.safe_load(config_path.read_text(encoding="utf-8")) or {}
+    wl = set(cfg.get("whitelist_phrases", []) or [])
+    bl = set((cfg.get("blacklist", {}) or {}).get("force_mask_terms", []) or [])
+    return wl, bl
+
+
+def import_config_file(json_path, config_path) -> bool:
+    """Fusionne ``json_path`` dans ``config_path`` (YAML). Retourne True si la
+    config a changé, False si rien de nouveau.
+
+    Fusion autonome (union des listes, jamais d'écrasement) — volontairement
+    SANS dépendance à ``scripts/merge_params`` (non bundlé en frozen). Même
+    sémantique : ``whitelist_phrases`` et ``blacklist.force_mask_terms``.
+    """
+    import json
+    import yaml
+
+    json_path = Path(json_path)
+    config_path = Path(config_path)
+    before_wl, before_bl = _yaml_lists(config_path)
+
+    data = json.loads(json_path.read_text(encoding="utf-8"))
+    incoming_wl = {str(t).strip() for t in data.get("whitelist_phrases", []) if str(t).strip()}
+    incoming_bl = {str(t).strip() for t in data.get("blacklist_force_mask_terms", []) if str(t).strip()}
+
+    after_wl = before_wl | incoming_wl
+    after_bl = before_bl | incoming_bl
+    if after_wl == before_wl and after_bl == before_bl:
+        return False
+
+    cfg = yaml.safe_load(config_path.read_text(encoding="utf-8")) or {}
+    cfg["whitelist_phrases"] = sorted(after_wl)
+    cfg.setdefault("blacklist", {})
+    cfg["blacklist"]["force_mask_terms"] = sorted(after_bl)
+    config_path.write_text(
+        yaml.dump(cfg, allow_unicode=True, default_flow_style=False, sort_keys=False),
+        encoding="utf-8",
+    )
+    return True
--- a/gui_v6/config_state.py
+++ b/gui_v6/config_state.py
@@ -9,10 +9,36 @@ from __future__ import annotations

 from dataclasses import dataclass
 from pathlib import Path
-from typing import Callable, List, Optional
+from typing import Callable, FrozenSet, List, Optional

 from gui_v6.engine_bridge import EngineSettings

+# Mapping centralisé champ ConfigState → CATÉGORIE moteur (Plan 1b / P1-2).
+#
+# Les 7 catégories doivent matcher EXACTEMENT le set accepté par
+# ``anonymizer_core_refactored_onnx.process_pdf(disabled_kinds=...)`` :
+#   {"NOM", "DATE_NAISSANCE", "ETAB", "ADRESSE", "NIR", "TEL", "ADHERENT"}.
+#
+# Sémantique des booléens ``detect_*`` : True = « détecter cette catégorie »
+# (= masquer, comportement par défaut). False = laisser en clair → la catégorie
+# entre dans ``disabled_kinds``. Note : CODE_POSTAL suit le toggle ADRESSE côté
+# moteur (décision Dom 2026-06-26), aucun toggle dédié n'est exposé.
+#
+# L'ordre suit les 7 lignes de ``tab_config._DETECTION_OPTIONS`` :
+#   Noms/prénoms · Dates de naissance · Établissements · Adresses/CP ·
+#   N° sécurité sociale · Téléphones · N° adhérent mutuelle.
+CATEGORY_FIELDS = {
+    "detect_nom": "NOM",
+    "detect_date_naissance": "DATE_NAISSANCE",
+    "detect_etab": "ETAB",
+    "detect_adresse": "ADRESSE",
+    "detect_nir": "NIR",
+    "detect_tel": "TEL",
+    "detect_adherent": "ADHERENT",
+}
+# Catégories canoniques (ordre = ordre des toggles UI).
+DETECTION_CATEGORIES = tuple(CATEGORY_FIELDS.values())
+

@dataclass
 class ConfigState:
@@ -33,6 +59,26 @@ class ConfigState:
    mask_margin_y: int = 1
    mask_rounded_corners: bool = False

+    # 7 toggles « Données à détecter » — tous ON par défaut (zéro changement).
+    detect_nom: bool = True
+    detect_date_naissance: bool = True
+    detect_etab: bool = True
+    detect_adresse: bool = True
+    detect_nir: bool = True
+    detect_tel: bool = True
+    detect_adherent: bool = True
+
+    def disabled_kinds(self) -> FrozenSet[str]:
+        """Set des CATÉGORIES décochées (laissées en clair).
+
+        Défaut (tous les toggles ON) ⇒ ``frozenset()`` (no-op moteur).
+        """
+        return frozenset(
+            category
+            for field_name, category in CATEGORY_FIELDS.items()
+            if not getattr(self, field_name)
+        )
+
    def to_engine_settings(self, config_path: Optional[Path] = None) -> EngineSettings:
        return EngineSettings(
            make_vector_redaction=False,
@@ -43,6 +89,7 @@ class ConfigState:
            enable_gliner=self.enable_gliner,
            ogc_label=self.ogc_label,
            profile=self.profile,
+            disabled_kinds=self.disabled_kinds(),
        )


--- a/gui_v6/diagnostics.py
+++ b/gui_v6/diagnostics.py
@@ -0,0 +1,190 @@
+"""Diagnostics structurés de la GUI V6 (E2/E3) — RGPD strict.
+
+On n'émet QUE des métadonnées techniques liste-blanche : type d'exception
+(nom de classe), catégorie d'erreur d'un ensemble fermé, statut, ordinal,
+durée. JAMAIS de nom/chemin/texte de document, ni de message d'exception brut.
+L'envoi est non bloquant : un échec réseau n'interrompt jamais le traitement.
+Patron : gui_v6/usage_telemetry.py (télémétrie d'usage).
+"""
+
+from __future__ import annotations
+
+import json
+import uuid
+from pathlib import Path
+from typing import Any, Callable, Iterable, Optional
+
+# Clés autorisées par item de diagnostic (filtre RGPD appliqué à la construction).
+_ALLOWED_ITEM_KEYS = {"ordinal", "status", "error_type", "error_code", "duration_ms"}
+
+REPORT_PATH = "/api/v1/diagnostics/report"
+
+
+def new_run_id() -> str:
+    return uuid.uuid4().hex
+
+
+def items_from_summary(summary: Any) -> list[dict]:
+    """Extrait les items de diagnostic (RGPD-safe) d'un ``RunSummary``.
+
+    Ne lit que les attributs autorisés ; aucun nom/chemin/message n'est lu.
+    """
+    items: list[dict] = []
+    for item in getattr(summary, "documents", None) or []:
+        items.append(
+            {
+                "ordinal": getattr(item, "ordinal", 0),
+                "status": getattr(item, "status", "success"),
+                "error_type": getattr(item, "error_type", None),
+                "error_code": getattr(item, "error_code", None),
+                "duration_ms": getattr(item, "duration_ms", None),
+            }
+        )
+    return items
+
+
+def build_diagnostics_payload(
+    *,
+    run_id: str,
+    app_name: str,
+    app_version: Optional[str],
+    license_ref: Optional[str],
+    machine_id: Optional[str],
+    duration_ms: Optional[int],
+    items: Iterable[dict],
+) -> dict:
+    """Construit le payload diagnostic. Chaque item est filtré aux seules clés
+    autorisées → aucun nom/chemin/message ne peut fuir, même fourni par erreur."""
+    clean_items: list[dict] = []
+    succeeded = failed = 0
+    for raw in items:
+        it = {k: raw[k] for k in _ALLOWED_ITEM_KEYS if k in raw}
+        status = it.get("status")
+        if status == "success":
+            succeeded += 1
+        elif status == "failed":
+            failed += 1
+        clean_items.append(it)
+    return {
+        "run_id": run_id,
+        "license_ref": license_ref,
+        "machine_id": machine_id,
+        "app_name": app_name,
+        "app_version": app_version,
+        "duration_ms": duration_ms,
+        "document_count": len(clean_items),
+        "succeeded_count": succeeded,
+        "failed_count": failed,
+        "items": clean_items,
+    }
+
+
+class DiagnosticsClient:
+    """Envoie un payload diagnostic au portail. Non bloquant : capture toute erreur."""
+
+    def __init__(
+        self,
+        base_url: str,
+        session: Any,
+        timeout: float = 4.0,
+        logger: Optional[Callable[[str], None]] = None,
+    ) -> None:
+        self._url = base_url.rstrip("/") + REPORT_PATH
+        self._session = session
+        self._timeout = timeout
+        self._log = logger or (lambda _msg: None)
+
+    def report(self, payload: dict) -> bool:
+        try:
+            resp = self._session.post(self._url, json=payload, timeout=self._timeout)
+            status = getattr(resp, "status_code", 0)
+            ok = 200 <= int(status) < 300
+            if not ok:
+                self._log(f"diagnostics report refusé (HTTP {status})")
+            return ok
+        except Exception as exc:  # réseau absent, timeout, etc.
+            self._log(f"diagnostics report échec (non bloquant) : {exc}")
+            return False
+
+
+def report_run_diagnostics(
+    summary: Any,
+    *,
+    base_url: str,
+    license_ref: Optional[str],
+    machine_id: Optional[str],
+    session: Any,
+    app_name: str = "gui_v6",
+    app_version: Optional[str] = None,
+    duration_ms: Optional[int] = None,
+    run_id: Optional[str] = None,
+    spool_path: Any = None,
+    logger: Optional[Callable[[str], None]] = None,
+) -> bool:
+    """Construit le payload depuis un ``RunSummary`` et l'envoie (non bloquant).
+
+    N'envoie RIEN si ``license_ref`` est absent. En cas d'échec réseau, spoole
+    le payload (si ``spool_path``) pour un rejeu ultérieur. Ne lève jamais.
+    """
+    log = logger or (lambda _msg: None)
+    if not license_ref:
+        log("diagnostics ignorés : aucune licence locale valide")
+        return False
+    payload = build_diagnostics_payload(
+        run_id=run_id or new_run_id(),
+        app_name=app_name,
+        app_version=app_version,
+        license_ref=license_ref,
+        machine_id=machine_id,
+        duration_ms=duration_ms,
+        items=items_from_summary(summary),
+    )
+    client = DiagnosticsClient(base_url, session=session, logger=log)
+    ok = client.report(payload)
+    if not ok and spool_path is not None:
+        spool_payload(spool_path, payload)
+    return ok
+
+
+def spool_payload(path: Any, payload: dict) -> None:
+    """Ajoute un payload à la file JSONL locale (ne lève pas)."""
+    try:
+        p = Path(path)
+        p.parent.mkdir(parents=True, exist_ok=True)
+        with p.open("a", encoding="utf-8") as fh:
+            fh.write(json.dumps(payload, ensure_ascii=False) + "\n")
+    except Exception:
+        pass
+
+
+def flush_spool(path: Any, client: "DiagnosticsClient") -> int:
+    """Tente d'envoyer chaque payload en file ; conserve ceux qui échouent.
+
+    Retourne le nombre de payloads envoyés. Ne lève jamais.
+    """
+    p = Path(path)
+    if not p.exists():
+        return 0
+    try:
+        lines = [ln for ln in p.read_text(encoding="utf-8").splitlines() if ln.strip()]
+    except Exception:
+        return 0
+    remaining: list[str] = []
+    sent = 0
+    for line in lines:
+        try:
+            payload = json.loads(line)
+        except Exception:
+            continue
+        if client.report(payload):
+            sent += 1
+        else:
+            remaining.append(line)
+    try:
+        if remaining:
+            p.write_text("\n".join(remaining) + "\n", encoding="utf-8")
+        else:
+            p.unlink(missing_ok=True)
+    except Exception:
+        pass
+    return sent
--- a/gui_v6/engine_bridge.py
+++ b/gui_v6/engine_bridge.py
@@ -19,10 +19,10 @@ Aucune logique de détection ici : on orchestre uniquement.
 from __future__ import annotations

 import logging
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from enum import Enum
 from pathlib import Path
-from typing import Any, Callable, Dict, Optional
+from typing import Any, Callable, Dict, FrozenSet, Optional

 from engine_capabilities import capabilities_map

@@ -61,6 +61,9 @@ class EngineSettings:
    enable_gliner: bool = False
    ogc_label: Optional[str] = None
    profile: Optional[str] = None
+    # Plan 1b (P1-2) — set des CATÉGORIES laissées en clair (toggles décochés).
+    # Vide par défaut ⇒ aucun changement de comportement (tout est masqué).
+    disabled_kinds: FrozenSet[str] = field(default_factory=frozenset)


 def _default_factories() -> dict[str, ManagerFactory]:
@@ -206,6 +209,8 @@ def build_engine_kwargs(
        "also_make_raster_burn": settings.also_make_raster_burn,
        "config_path": settings.config_path,
        "ogc_label": settings.ogc_label,
+        # Plan 1b (P1-2) — catégories décochées laissées en clair (set vide = no-op).
+        "disabled_kinds": frozenset(settings.disabled_kinds or ()),
    }
    if managers is not None and settings.use_local_ner:
        kwargs.update(managers.as_kwargs())
--- a/gui_v6/fsutil.py
+++ b/gui_v6/fsutil.py
@@ -0,0 +1,25 @@
+"""Ouverture du gestionnaire de fichiers sur un dossier (cross-plateforme).
+
+Best-effort : ne lève jamais (un échec d'ouverture ne doit pas casser l'UI).
+"""
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+
+def open_in_file_manager(path) -> None:
+    """Ouvre ``path`` dans l'explorateur de fichiers du système."""
+    target = str(Path(path))
+    try:
+        if sys.platform.startswith("win"):
+            import os
+
+            os.startfile(target)  # type: ignore[attr-defined]  # noqa: S606
+        elif sys.platform == "darwin":
+            subprocess.Popen(["open", target])
+        else:
+            subprocess.Popen(["xdg-open", target])
+    except Exception:
+        pass
--- a/gui_v6/processing_runner.py
+++ b/gui_v6/processing_runner.py
@@ -87,6 +87,32 @@ def _engine_result_error(result: object) -> str | None:
    return None


+# Ensemble FERMÉ de catégories d'erreur (aucune PII ne peut y entrer).
+_ERROR_CODES = ("ner_unavailable", "quarantined", "no_output", "processing_error")
+
+
+def classify_error_code(exc: Exception) -> str:
+    """Catégorise une exception de run en une valeur de l'ensemble fermé _ERROR_CODES.
+
+    Lit le type et d'éventuels préfixes de message GÉNÉRÉS PAR NOUS pour classer ;
+    ne renvoie JAMAIS le message lui-même (RGPD). Inconnu → 'processing_error'.
+    """
+    name = type(exc).__name__
+    if name == "EngineUnavailableError":
+        return "ner_unavailable"
+    msg = str(exc)
+    # ⚠ ANTI-DÉRIVE : ces littéraux DOIVENT rester synchronisés avec les messages
+    # produits par `_engine_result_error` ci-dessus ("Document mis en quarantaine :"
+    # et "Aucune sortie PDF anonymisée produite."). Si l'un est reformulé sans
+    # mettre à jour l'autre, l'erreur retombe silencieusement en 'processing_error'
+    # (couvert par les tests test_classify_error_code_*).
+    if "quarantaine" in msg:
+        return "quarantined"
+    if "Aucune sortie" in msg:
+        return "no_output"
+    return "processing_error"
+
+
 def discover_documents(input_path, extensions: Optional[Sequence[str]] = None) -> list[Path]:
    """Liste les documents à traiter (fichier unique ou dossier récursif)."""
    path = Path(input_path)
@@ -99,6 +125,10 @@ def discover_documents(input_path, extensions: Optional[Sequence[str]] = None) -
    return []


+class OutputNotWritableError(RuntimeError):
+    """Le dossier de sortie n'est pas inscriptible (échec amont, message clair)."""
+
+
@dataclass
 class DocResult:
    """Détail anonymisé d'un document traité (pour la télémétrie d'usage).
@@ -111,6 +141,10 @@ class DocResult:
    status: str  # "success" | "failed"
    duration_ms: Optional[int]
    extension: Optional[str]
+    # Diagnostics RGPD-safe : nom de classe d'exception + catégorie fermée.
+    # JAMAIS le message d'exception (str(exc)) ni nom/chemin de document.
+    error_type: Optional[str] = None
+    error_code: Optional[str] = None


@dataclass
@@ -195,6 +229,19 @@ class ProcessingRunner:
            log("Aucun document supporté détecté.")
            return summary

+        # Sonde amont : on vérifie une seule fois que le dossier de sortie est
+        # inscriptible AVANT la boucle, pour un échec clair et unique (P1-6)
+        # plutôt qu'une erreur cryptique répétée à chaque document.
+        try:
+            out_root.mkdir(parents=True, exist_ok=True)
+            probe = out_root / ".anon_write_test"
+            probe.write_text("", encoding="utf-8")
+            probe.unlink()
+        except Exception as exc:
+            raise OutputNotWritableError(
+                f"Dossier de sortie non inscriptible : {out_root} ({exc})"
+            ) from exc
+
        for index, doc in enumerate(docs, start=1):
            if stop_event is not None and stop_event.is_set():
                summary.stopped = True
@@ -207,6 +254,8 @@ class ProcessingRunner:
            page_count = page_count_for(doc)
            started = time.monotonic()
            status = "success"
+            error_type = None
+            error_code = None
            try:
                if input_path.is_dir():
                    doc_out = build_batch_output_dir(root_dir, out_root, doc)
@@ -221,6 +270,8 @@ class ProcessingRunner:
                log(f"OK : {doc.name}")
            except Exception as exc:  # un échec n'interrompt pas le lot
                status = "failed"
+                error_type = type(exc).__name__
+                error_code = classify_error_code(exc)
                summary.failed += 1
                summary.errors.append((doc.name, str(exc)))
                log(f"ÉCHEC : {doc.name} — {exc}")
@@ -231,6 +282,8 @@ class ProcessingRunner:
                    status=status,
                    duration_ms=int((time.monotonic() - started) * 1000),
                    extension=extension,
+                    error_type=error_type,
+                    error_code=error_code,
                )
            )
            if on_progress:
--- a/gui_v6/single_instance.py
+++ b/gui_v6/single_instance.py
@@ -4,6 +4,10 @@
  ``AppMutex`` dans installer/Anonymisation.iss (Plan 3 / D8) pour que l'installeur
  ferme l'app avant une mise à jour.
 - POSIX (dev/test) : verrou ``fcntl`` exclusif sur un fichier dans le dossier app.
+
+Précondition D8 : la GUI n'a pas de réduction en zone de notification (tray). L'AppMutex
+ ``CloseApplications`` de l'installeur suffisent car fermer la fenêtre termine le process.
+Si un mode tray était ajouté, le process survivrait au ``WM_CLOSE`` et D8 devrait être revu.
 """

 from __future__ import annotations
--- a/gui_v6/tabs/tab_config.py
+++ b/gui_v6/tabs/tab_config.py
@@ -20,20 +20,48 @@ from gui_v6 import ui_kit
 from gui_v6.config_state import ConfigState, default_profile_key, list_profile_keys
 from manual_masking import ensure_mask_templates_dir, list_mask_templates, mask_template_label

+NER_DISABLE_WARNING = (
+    "Vous allez désactiver le moteur d'intelligence artificielle "
+    "(CamemBERT-bio).\n\n"
+    "Sans lui, la détection des NOMS de personnes repose uniquement sur des "
+    "règles (expressions régulières) : des noms peuvent rester EN CLAIR dans "
+    "les documents.\n\n"
+    "Pour un usage médical, garder ce moteur activé est fortement recommandé.\n\n"
+    "Confirmer la désactivation ?"
+)
+
+
+def confirm_ner_disable(asker) -> bool:
+    """Décision de désactivation du NER.
+
+    ``asker`` est une fonction ``() -> bool`` (ex. ``messagebox.askyesno``),
+    injectée pour rester testable sans display. Retourne True si l'utilisateur
+    CONFIRME la désactivation (regex-only). Toute erreur de l'asker est traitée
+    comme un refus (sens sûr : le NER reste actif).
+    """
+    try:
+        return bool(asker())
+    except Exception:
+        return False
+
+
 _SUBTABS = [
    ("reg", "⚙️ Réglages"),
    ("pro", "👤 Profils"),
    ("shr", "🔄 Partage"),
 ]

+# Chaque ligne = (libellé, aide, champ ConfigState). Le champ relie le toggle
+# à la catégorie moteur (cf. gui_v6.config_state.CATEGORY_FIELDS). ON = détecter
+# (masquer) ; OFF = laisser en clair (entre dans disabled_kinds).
 _DETECTION_OPTIONS = [
-    ("Noms et prénoms", "Annuaire + IA"),
-    ("Dates de naissance", "Contexte naissance"),
-    ("Établissements", "FINESS + contexte"),
-    ("Adresses / CP", "Voie, ville, code"),
-    ("N° sécurité sociale", "NIR"),
-    ("Téléphones / e-mails", "Contact"),
-    ("N° adhérent mutuelle", "Identifiant local"),
+    ("Noms et prénoms", "Annuaire + IA", "detect_nom"),
+    ("Dates de naissance", "Contexte naissance", "detect_date_naissance"),
+    ("Établissements", "FINESS + contexte", "detect_etab"),
+    ("Adresses / CP", "Voie + code postal", "detect_adresse"),
+    ("N° sécurité sociale", "NIR", "detect_nir"),
+    ("Téléphones", "Fixe + mobile", "detect_tel"),
+    ("N° adhérent mutuelle", "Identifiant local", "detect_adherent"),
 ]

 _MASK_COLORS = [
@@ -142,12 +170,15 @@ _HELP_PROFIL_MOTS = (
    "Pour de longues listes, utilisez le tableau des termes afin de rechercher et vérifier plus facilement."
 )
 _HELP_EXPORT_CONFIG = (
-    "Exporte uniquement les réglages de l'application : profils, listes locales, règles et style de masque.\n\n"
+    "Exporte vos deux listes locales — termes à toujours conserver et termes à toujours "
+    "masquer — dans un fichier .json à envoyer à un autre poste ou à l'administrateur.\n\n"
    "Les documents patients, résultats d'anonymisation et audits ne sont pas exportés."
 )
 _HELP_IMPORT_CONFIG = (
-    "Importe des réglages reçus d'un administrateur ou d'un autre poste.\n\n"
-    "L'import ne lit pas de documents patients. Vérifiez toujours le profil actif après import."
+    "Importe les deux listes locales (termes à conserver, termes à masquer) reçues d'un "
+    "autre poste ou de l'administrateur. La fusion ajoute ces termes à votre configuration "
+    "sans rien écraser.\n\n"
+    "L'import ne lit pas de documents patients. Redémarrez l'application pour appliquer."
 )

 CONFIG_MOCKUP_SECTIONS = {
@@ -195,10 +226,11 @@ def _app_base_dir() -> Path:


 class ConfigTab(ctk.CTkFrame):
-    def __init__(self, master, state: ConfigState | None = None, palette: dict | None = None, **kwargs):
+    def __init__(self, master, state: ConfigState | None = None, palette: dict | None = None, config_path: Path | None = None, **kwargs):
        self._p = palette or theme_mod.get_palette(theme_mod.DEFAULT_THEME)
        super().__init__(master, fg_color=self._p["bg"], **kwargs)
        self._state = state if state is not None else ConfigState()
+        self._config_path = config_path
        self._sub = "reg"
        self._sub_buttons: dict[str, ctk.CTkButton] = {}
        self._panels: dict[str, ctk.CTkFrame] = {}
@@ -353,8 +385,20 @@ class ConfigTab(ctk.CTkFrame):
            help_text=_HELP_DONNEES_DETECTER, help_title="Données à détecter",
        )
        det.pack(fill="both", expand=True)
-        for label, hint in _DETECTION_OPTIONS:
-            self._mini_toggle(det, label, hint, value=True).pack(fill="x", padx=12, pady=1)
+        # Les 7 toggles « Données à détecter » sont câblés sur les booléens
+        # detect_* de ConfigState (lecture initiale + écriture au changement).
+        # ON = détecter/masquer ; OFF = laisser en clair (→ disabled_kinds).
+        self._detect_toggles: dict[str, object] = {}
+        for label, hint, field_name in _DETECTION_OPTIONS:
+            toggle = self._mini_toggle(
+                det,
+                label,
+                hint,
+                value=bool(getattr(self._state, field_name)),
+                command=lambda f=field_name: self._on_detect_toggle(f),
+            )
+            toggle.pack(fill="x", padx=12, pady=1)
+            self._detect_toggles[field_name] = toggle

        ner = ui_kit.Card(
            cols[1], p, title="🧠 Moteurs et masques",
@@ -828,16 +872,20 @@ class ConfigTab(ctk.CTkFrame):
            help_text=_HELP_EXPORT_CONFIG, help_title="Exporter la configuration",
        )
        export.pack(fill="both", expand=True)
-        self._note(export, "Listes locales, règles admin, style de masquage et template actif.")
-        self._mockup_button(export, "⬇ Exporter (.json)").pack(anchor="w", padx=12, pady=(0, 12))
+        self._note(export, "Vos listes locales : termes à toujours conserver et termes à toujours masquer.")
+        ui_kit.secondary_button(
+            export, p, "⬇ Exporter (.json)", command=self._on_export_config
+        ).pack(anchor="w", padx=12, pady=(0, 12))

        import_card = ui_kit.Card(
            cols[1], p, title="📥 Importer une configuration",
            help_text=_HELP_IMPORT_CONFIG, help_title="Importer une configuration",
        )
        import_card.pack(fill="both", expand=True)
-        self._note(import_card, "Fusionne la configuration reçue avec vos réglages locaux.")
-        self._mockup_button(import_card, "⬆ Importer (.json)").pack(anchor="w", padx=12, pady=(0, 12))
+        self._note(import_card, "Fusionne les listes reçues (à conserver / à masquer) avec vos listes locales.")
+        ui_kit.secondary_button(
+            import_card, p, "⬆ Importer (.json)", command=self._on_import_config
+        ).pack(anchor="w", padx=12, pady=(0, 12))

    # -- helpers aide / maquette -----------------------------------------

@@ -865,8 +913,30 @@ class ConfigTab(ctk.CTkFrame):
    def _on_profile(self, value: str) -> None:
        self._state.profile = value

+    def _on_detect_toggle(self, field_name: str) -> None:
+        """Recopie l'état d'un toggle « Données à détecter » dans ConfigState.
+
+        ON = détecter (masquer) ; OFF = laisser en clair. ``disabled_kinds()``
+        de ConfigState dérive ensuite le set des catégories désactivées.
+        """
+        toggle = self._detect_toggles.get(field_name)
+        if toggle is not None:
+            setattr(self._state, field_name, bool(toggle.get()))
+
    def _on_ner(self) -> None:
-        self._state.use_local_ner = self._tog_ner.get()
+        new_value = self._tog_ner.get()
+        if not new_value:
+            confirmed = confirm_ner_disable(
+                lambda: messagebox.askyesno(
+                    "Moteur de détection", NER_DISABLE_WARNING, icon="warning"
+                )
+            )
+            if not confirmed:
+                # Refus : rétablir l'affichage du switch et garder le NER actif.
+                self._tog_ner.var.set(True)
+                self._state.use_local_ner = True
+                return
+        self._state.use_local_ner = new_value

    def _on_eds(self) -> None:
        self._state.enable_eds = self._tog_eds.get()
@@ -880,6 +950,47 @@ class ConfigTab(ctk.CTkFrame):
    def _on_manual_mask_template(self, label: str) -> None:
        self._state.manual_mask_template = self._manual_mask_templates.get(label)

+    def _on_export_config(self) -> None:
+        from gui_v6.config_share import build_export_payload
+        import json
+
+        lists = getattr(self, "_pro_term_lists", {})
+        wl = lists["whitelist"].terms() if "whitelist" in lists else []
+        bl = lists["blacklist"].terms() if "blacklist" in lists else []
+        path = filedialog.asksaveasfilename(
+            title="Exporter la configuration", defaultextension=".json",
+            filetypes=[("Configuration JSON", "*.json")],
+        )
+        if not path:
+            return
+        try:
+            payload = build_export_payload(wl, bl)
+            Path(path).write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+            messagebox.showinfo("Export", f"Configuration exportée :\n{path}")
+        except Exception as exc:  # pragma: no cover - chemin UI
+            messagebox.showerror("Export", f"Échec de l'export : {exc}")
+
+    def _on_import_config(self) -> None:
+        from gui_v6.config_share import import_config_file
+
+        if self._config_path is None:
+            messagebox.showerror("Import", "Aucune configuration cible résolue.")
+            return
+        path = filedialog.askopenfilename(
+            title="Importer une configuration",
+            filetypes=[("Configuration JSON", "*.json")],
+        )
+        if not path:
+            return
+        try:
+            changed = import_config_file(path, self._config_path)
+            if changed:
+                messagebox.showinfo("Import", "Configuration fusionnée. Redémarrez pour appliquer.")
+            else:
+                messagebox.showinfo("Import", "Rien de nouveau à fusionner.")
+        except Exception as exc:  # pragma: no cover - chemin UI
+            messagebox.showerror("Import", f"Échec de l'import : {exc}")
+
    def _pick_output(self) -> None:
        path = filedialog.askdirectory(title="Dossier de sortie")
        if path:
--- a/gui_v6/tabs/tab_usage.py
+++ b/gui_v6/tabs/tab_usage.py
@@ -18,6 +18,7 @@ import customtkinter as ctk

 from gui_v6 import theme as theme_mod
 from gui_v6 import ui_kit
+from gui_v6.fsutil import open_in_file_manager
 from gui_v6.processing_runner import ProcessingRunner, default_output_dir

 _STEPS = ["📖 Extraction", "🧠 Détection", "🔒 Masquage", "📄 PDF final"]
@@ -33,6 +34,29 @@ _HELP_USAGE = (
 )


+def failure_hint(summary, output_dir) -> str | None:
+    """Message localisant les documents livrés, ou None si run nominal.
+
+    Honnête : les documents en échec / quarantaine ne sont PAS anonymisés et
+    ne sont donc pas écrits. Si AUCUN document n'a abouti, on ne prétend pas
+    qu'un dossier de sortie contient des documents anonymisés.
+    """
+    if summary is None or output_dir is None:
+        return None
+    if summary.failed == 0 and not getattr(summary, "stopped", False):
+        return None
+    if summary.succeeded == 0:
+        return (
+            "Aucun document n'a été anonymisé. Les documents en échec ou en "
+            "quarantaine ne sont PAS anonymisés et n'ont pas été écrits."
+        )
+    return (
+        f"Documents anonymisés écrits dans : {output_dir}\n"
+        "Les documents en échec ou en quarantaine ne sont PAS anonymisés et "
+        "n'ont pas été écrits."
+    )
+
+
 class UsageTab(ctk.CTkFrame):
    def __init__(
        self,
@@ -44,6 +68,7 @@ class UsageTab(ctk.CTkFrame):
        on_theme_change=None,
        current_theme: str = theme_mod.DEFAULT_THEME,
        usage_reporter=None,
+        diag_reporter=None,
        **kwargs,
    ):
        self._p = palette or theme_mod.get_palette(current_theme)
@@ -56,9 +81,13 @@ class UsageTab(ctk.CTkFrame):
        # Callback(summary) appelé en fin de run pour la télémétrie d'usage
        # (envoi non bloquant, injecté par l'app avec le contexte licence).
        self._usage_reporter = usage_reporter
+        # Callback(summary) appelé en fin de run pour les diagnostics RGPD
+        # (envoi non bloquant, injecté par l'app avec le contexte licence).
+        self._diag_reporter = diag_reporter

        self._input_path: Path | None = None
        self._output_dir: Path | None = None
+        self._last_output_dir: Path | None = None
        self._stop_event: threading.Event | None = None
        self._is_running = False
        self._events: "queue.Queue[tuple]" = queue.Queue()
@@ -104,9 +133,19 @@ class UsageTab(ctk.CTkFrame):
            docs, fg_color=p["divider"], border_color=p["card_border"], border_width=2, corner_radius=8
        )
        dz.pack(fill="x", padx=16, pady=(0, 8))
-        ctk.CTkLabel(dz, text="⬆️", font=ui_kit.font(30)).pack(pady=(20, 4))
-        ctk.CTkLabel(dz, text="Choisissez vos fichiers", text_color=p["text"], font=ui_kit.font(14)).pack()
-        ctk.CTkLabel(dz, text="PDF · Word · Images · Texte", text_color=p["text_muted"], font=ui_kit.font(12)).pack(pady=(2, 10))
+        # Zone réellement cliquable (ouvre le sélecteur de fichier). Le DnD natif
+        # est différé ; on ne laisse pas une métaphore « déposer » trompeuse.
+        dz.configure(cursor="hand2")
+        dz.bind("<Button-1>", lambda _e: self._pick_file())
+        for _txt, _color, _size, _pady in (
+            ("⬆️", p["text"], 30, (20, 4)),
+            ("Cliquez pour choisir un fichier", p["text"], 14, 0),
+            ("PDF · Word · Images · Texte", p["text_muted"], 12, (2, 10)),
+        ):
+            _lbl = ctk.CTkLabel(dz, text=_txt, text_color=_color, font=ui_kit.font(_size))
+            _lbl.configure(cursor="hand2")
+            _lbl.bind("<Button-1>", lambda _e: self._pick_file())
+            _lbl.pack(pady=_pady)
        acts = ctk.CTkFrame(dz, fg_color="transparent")
        acts.pack(pady=(0, 20))
        ui_kit.secondary_button(acts, p, "📄 Fichier", command=self._pick_file).pack(side="left", padx=4)
@@ -158,6 +197,7 @@ class UsageTab(ctk.CTkFrame):
        self._stats_row = ctk.CTkFrame(self._rsec, fg_color="transparent")
        self._stats_row.pack(fill="x", padx=16, pady=(0, 14))
        self._result_built = False
+        self._hint_row = None

    # -- thème ------------------------------------------------------------

@@ -211,6 +251,7 @@ class UsageTab(ctk.CTkFrame):
            return
        self._is_running = True
        run_runner, run_output_dir = self._build_run_runner()
+        self._last_output_dir = run_output_dir or default_output_dir(self._input_path)
        self._stop_event = threading.Event()
        self._run_btn.configure(state="disabled")
        self._psec.pack(fill="x", padx=14, pady=7)
@@ -281,7 +322,9 @@ class UsageTab(ctk.CTkFrame):
            self._progress.set(1.0)
            self._set_status(f"Terminé : {summary.succeeded} OK, {summary.failed} échec(s) sur {summary.total}.")
        self._show_results(summary)
+        self._show_failure_hint(summary)
        self._send_usage_telemetry(summary)
+        self._send_diagnostics(summary)

    def _send_usage_telemetry(self, summary) -> None:
        """Envoie la télémétrie d'usage en fin de run, sans bloquer l'UI ni le run."""
@@ -297,6 +340,20 @@ class UsageTab(ctk.CTkFrame):

        threading.Thread(target=work, daemon=True).start()

+    def _send_diagnostics(self, summary) -> None:
+        """Envoie les diagnostics en fin de run, sans bloquer l'UI ni le run."""
+        reporter = self._diag_reporter
+        if reporter is None:
+            return
+
+        def work():
+            try:
+                reporter(summary)
+            except Exception:
+                pass  # un échec diagnostic ne doit jamais remonter
+
+        threading.Thread(target=work, daemon=True).start()
+
    def _show_results(self, summary) -> None:
        p = self._p
        for w in self._stats_row.winfo_children():
@@ -311,6 +368,28 @@ class UsageTab(ctk.CTkFrame):
            ui_kit.StatCard(self._stats_row, p, value, label, value_color=color).pack(side="left", expand=True, fill="x", padx=4)
        self._rsec.pack(fill="x", padx=14, pady=(7, 14))

+    def _show_failure_hint(self, summary) -> None:
+        # Nettoyage inconditionnel : éviter l'empilement et les hints périmés.
+        if getattr(self, "_hint_row", None) is not None:
+            self._hint_row.destroy()
+            self._hint_row = None
+        hint = failure_hint(summary, getattr(self, "_last_output_dir", None))
+        if hint is None:
+            return
+        p = self._p
+        self._hint_row = ctk.CTkFrame(self._rsec, fg_color="transparent")
+        self._hint_row.pack(fill="x", padx=16, pady=(0, 12))
+        ctk.CTkLabel(
+            self._hint_row, text=hint, text_color=p["text_dim"], font=ui_kit.font(11),
+            anchor="w", justify="left",
+        ).pack(side="left", fill="x", expand=True)
+        # Bouton « ouvrir » uniquement s'il y a réellement des documents livrés.
+        if summary is not None and summary.succeeded > 0:
+            ui_kit.secondary_button(
+                self._hint_row, p, "📂 Ouvrir le dossier",
+                command=lambda: open_in_file_manager(self._last_output_dir),
+            ).pack(side="right")
+
    # -- helpers widgets --------------------------------------------------

    def _set_status(self, text: str) -> None:
--- a/gui_v6/version.py
+++ b/gui_v6/version.py
@@ -0,0 +1,18 @@
+"""Résolution de la version affichée/télémesurée de la GUI V6 (P1-7, Plan 3).
+
+Au build Windows, scripts/build_windows_oneclick.ps1 génère gui_v6/_build_version.py
+contenant BUILD_VERSION = "2026.MM.JJ.HHMM" (même valeur que l'AppVersion de
+l'installeur et que build_info.BUILD_VERSION). Ce fichier n'est PAS commité
+(.gitignore). En dev, repli sur DEFAULT_VERSION.
+"""
+
+DEFAULT_VERSION = "6.0.0-dev"
+
+
+def resolve_version(default: str = DEFAULT_VERSION) -> str:
+    try:
+        from gui_v6._build_version import BUILD_VERSION
+    except Exception:
+        return default
+    version = str(BUILD_VERSION).strip()
+    return version if version else default
--- a/installer/Anonymisation.iss
+++ b/installer/Anonymisation.iss
@@ -24,6 +24,11 @@ SolidCompression=yes
 WizardStyle=modern
 ArchitecturesAllowed=x64compatible
 ArchitecturesInstallIn64BitMode=x64compatible
+; D8 (Plan 3) : MAJ propre — ferme l'app avant remplacement de l'EXE.
+; AppMutex = gui_v6/single_instance.py:APP_MUTEX_NAME (NE PAS désynchroniser).
+AppMutex=AivanonymAnonymisationV6
+CloseApplications=yes
+RestartApplications=no

 [Languages]
 Name: "french"; MessagesFile: "compiler:Languages\French.isl"
--- a/scripts/build_windows_oneclick.ps1
+++ b/scripts/build_windows_oneclick.ps1
@@ -266,6 +266,11 @@ Require-Path -PathValue $VenvPython -Label "Python du venv"

 Push-Location $ProjectRoot
 try {
+    # P1-7 (Plan 3) : version release unique, réutilisée par build_info.py,
+    # gui_v6/_build_version.py et l'installeur Inno Setup (/DAppVersion).
+    $ReleaseVersion = (Get-Date -Format "yyyy.MM.dd.HHmm")
+    Write-Host "Version release : $ReleaseVersion"
+
    Write-Step "Installation des dépendances de build"
    & $VenvPython -m pip install --upgrade pip setuptools wheel
    if (-not $SkipRequirements) {
@@ -273,6 +278,28 @@ try {
    }
    & $VenvPython -m pip install pyinstaller

+    if ($GuiV6) {
+        Write-Step "Purge torch/optimum du venv de build (P0-3, GUI V6 torch-free)"
+        # optimum[onnxruntime] (requirements.txt) tire torch en dépendance cœur ;
+        # la GUI V6 ne l'utilise jamais (NER = onnxruntime brut, OCR = OnnxTR).
+        # La spec legacy V5 garde torch : purge limitée au flavor GUI V6.
+        & $VenvPython -m pip uninstall -y torch torchvision optimum 2>$null
+        & $VenvPython -c "import importlib.util,sys; sys.exit(1 if importlib.util.find_spec('torch') else 0)"
+        if ($LASTEXITCODE -ne 0) {
+            throw "torch encore importable dans le venv de build : purge P0-3 échouée."
+        }
+        Write-Host "Venv de build torch-free : OK"
+    }
+
+    Write-Step "Précache des poids OnnxTR (P0-4)"
+    # La spec PyInstaller raise FileNotFoundError si db_resnet50/crnn_vgg16_bn
+    # sont absents du cache : on les télécharge explicitement au lieu de
+    # dépendre du cache résiduel de la machine.
+    & $VenvPython -c "from onnxtr.models import ocr_predictor; ocr_predictor(det_arch='db_resnet50', reco_arch='crnn_vgg16_bn'); print('Poids OnnxTR en cache : OK')"
+    if ($LASTEXITCODE -ne 0) {
+        throw "Précache OnnxTR échoué (réseau ? proxy ?) : le build frozen échouerait sur les poids manquants."
+    }
+
    Write-Step "Génération de build_info.py"
    $commit = "local"
    $branch = "local"
@@ -291,10 +318,21 @@ BUILD_DATE = "$buildDate"
 BUILD_COMMIT = "$commit"
 BUILD_BRANCH = "$branch"
 BUILD_FLAVOR = "$BuildFlavor"
+BUILD_VERSION = "$ReleaseVersion"
 "@
    Set-Content -Path $BuildInfoPath -Value $buildInfo -Encoding UTF8
    Write-Host "Build info : $buildDate / $branch / $commit"

+    if ($GuiV6) {
+        $BuildVersionPath = Join-Path $ProjectRoot "gui_v6\_build_version.py"
+        $buildVersionContent = @"
+"""Version release - généré automatiquement par build_windows_oneclick.ps1 (P1-7)."""
+BUILD_VERSION = "$ReleaseVersion"
+"@
+        Set-Content -Path $BuildVersionPath -Value $buildVersionContent -Encoding UTF8
+        Write-Host "gui_v6/_build_version.py : $ReleaseVersion"
+    }
+
    Write-Step "Nettoyage des anciens artefacts"
    foreach ($PathValue in @($BuildDir, $DistDir, $PackageDir)) {
        if (Test-Path $PathValue) {
@@ -367,8 +405,7 @@ Build :
        $innoCompiler = Resolve-InnoCompiler
        if ($innoCompiler) {
            Write-Host "Inno Setup Compiler : $innoCompiler"
-            $installerVersion = (Get-Date -Format "yyyy.MM.dd.HHmm")
-            & $innoCompiler "/DAppVersion=$installerVersion" $InstallerScriptPath
+            & $innoCompiler "/DAppVersion=$ReleaseVersion" $InstallerScriptPath
            if ($LASTEXITCODE -ne 0) {
                throw "Inno Setup a échoué avec le code $LASTEXITCODE."
            }
--- a/tests/unit/test_build_specs_torch_free.py
+++ b/tests/unit/test_build_specs_torch_free.py
@@ -0,0 +1,71 @@
+"""Anti-dérive P0-3 (Plan 3) : les specs frozen GUI V6 et CLI doivent être torch-free.
+
+On vérifie le TEXTE des specs (pas d'exécution PyInstaller sous Linux) :
+- aucun hiddenimport optimum*/torch*/doctr* ;
+- excludes explicites présents (torch, torchvision, optimum, doctr) — ceinture
+  et bretelles : même si le venv de build contient torch, l'analyse l'exclut
+  (le core fait un `import torch` lazy dans _configure_torch_threads, que
+  l'analyse statique de PyInstaller suivrait sans excludes).
+La spec GUI V5 legacy (anonymisation_onefile.spec) n'est PAS concernée.
+"""
+import re
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+TORCH_FREE_SPECS = [
+    ROOT / "anonymisation_gui_v6_onefile.spec",
+    ROOT / "anonymisation_cli_onefile.spec",
+]
+FORBIDDEN_HIDDEN = ("optimum", "torch", "torchvision", "doctr")
+REQUIRED_EXCLUDES = ("torch", "torchvision", "optimum", "doctr")
+
+
+def _hiddenimport_strings(text, spec_name):
+    """Retourne les chaînes littérales présentes dans la section hiddenimports=[...].
+
+    On extrait la portion entre `hiddenimports = [` et le PREMIER `]` rencontré
+    où qu'il soit (`[^\\]]*` ne gère pas l'imbrication : un `]` dans un
+    commentaire au sein de la liste tronquerait le bloc — acceptable ici, les
+    specs n'en contiennent pas). Cette restriction évite les faux positifs du
+    bloc EXCLUDED_TORCH_STACK qui contient légitimement "torch", "optimum", etc.
+
+    Garde-fou : si le bloc hiddenimports est introuvable (renommage, refonte de
+    la spec), on échoue BRUYAMMENT au lieu de retourner [] — sinon le test
+    passerait à vide sans plus rien vérifier.
+    """
+    match = re.search(r"hiddenimports\s*=\s*\[([^\]]*)\]", text, re.DOTALL)
+    assert match is not None, f"bloc hiddenimports introuvable dans {spec_name}"
+    block = match.group(1)
+    return re.findall(r"[\"']([A-Za-z0-9_.]+)[\"']", block)
+
+
+@pytest.mark.parametrize("spec_path", TORCH_FREE_SPECS, ids=lambda p: p.name)
+def test_spec_sans_hiddenimport_torch_optimum_doctr(spec_path):
+    text = spec_path.read_text(encoding="utf-8")
+    hits = [
+        s for s in _hiddenimport_strings(text, spec_path.name)
+        if s.split(".")[0] in FORBIDDEN_HIDDEN
+    ]
+    assert hits == [], f"{spec_path.name} référence encore : {hits}"
+
+
+@pytest.mark.parametrize("spec_path", TORCH_FREE_SPECS, ids=lambda p: p.name)
+def test_spec_declare_excludes_torch(spec_path):
+    text = spec_path.read_text(encoding="utf-8")
+    assert "excludes=EXCLUDED_TORCH_STACK" in text, (
+        f"{spec_path.name} : Analysis() sans excludes=EXCLUDED_TORCH_STACK"
+    )
+    for name in REQUIRED_EXCLUDES:
+        assert f'"{name}"' in text.split("EXCLUDED_TORCH_STACK")[1].split("]")[0], (
+            f"{spec_path.name} : '{name}' absent de EXCLUDED_TORCH_STACK"
+        )
+
+
+def test_spec_legacy_v5_garde_optimum():
+    text = (ROOT / "anonymisation_onefile.spec").read_text(encoding="utf-8")
+    assert '"optimum"' in text, (
+        "anonymisation_onefile.spec (GUI V5 legacy) doit GARDER optimum — "
+        "si ce test casse, quelqu'un a modifié la spec legacy par erreur."
+    )
--- a/tests/unit/test_core_address_burn_guard.py
+++ b/tests/unit/test_core_address_burn_guard.py
@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+"""Plan 1b — Task 4 (P1-2/F-3) : garde-fou du burn adresse géométrique.
+
+`_search_pdf_address_lines` est un chemin de caviardage INDÉPENDANT de
+l'audit : il noircit directement les lignes d'adresse trouvées
+géométriquement sur la page (cf. `test_pdf_redaction_directly_masks_finess_address_range`).
+Le filtre d'audit de la Task 1 ne le couvre donc PAS.
+
+Ces tests vérifient que ce chemin est gaté sous la catégorie ADRESSE :
+- ADRESSE désactivée → `_search_pdf_address_lines` n'est PAS appliqué ;
+- ADRESSE activée (ou disabled vide) → il est appelé comme avant.
+"""
+import anonymizer_core_refactored_onnx as core
+from anonymizer_core_refactored_onnx import (
+    PiiHit,
+    fitz,
+    redact_pdf_raster,
+    redact_pdf_vector,
+)
+
+
+def _make_address_pdf(tmp_path):
+    source = tmp_path / "addr.pdf"
+    doc = fitz.open()
+    page = doc.new_page()
+    page.insert_text((72, 72), "15 à 35 rue Claude Boucher Bordeaux Cedex")
+    page.insert_text((72, 108), "Motif d'hospitalisation : contrôle clinique.")
+    doc.save(source)
+    doc.close()
+    return source
+
+
+# ---------------------------------------------------------------------------
+# VECTOR
+# ---------------------------------------------------------------------------
+def test_vector_address_search_called_when_adresse_enabled(tmp_path, monkeypatch):
+    if fitz is None:
+        return
+    source = _make_address_pdf(tmp_path)
+    output = tmp_path / "addr.enabled.pdf"
+
+    calls = []
+    real = core._search_pdf_address_lines
+
+    def _spy(page):
+        calls.append(page.number)
+        return real(page)
+
+    monkeypatch.setattr(core, "_search_pdf_address_lines", _spy)
+
+    # disabled vide → comportement par défaut (adresse cherchée)
+    redact_pdf_vector(source, [], output, disabled_kinds=set())
+
+    assert calls, "ADRESSE activée : _search_pdf_address_lines doit être appelé"
+    redacted = fitz.open(output)
+    text = redacted[0].get_text()
+    redacted.close()
+    # L'adresse a bien été caviardée (le burn géométrique s'applique)
+    assert "rue Claude Boucher" not in text
+    # La ligne clinique reste lisible
+    assert "Motif d'hospitalisation" in text
+
+
+def test_vector_address_search_not_applied_when_adresse_disabled(tmp_path, monkeypatch):
+    if fitz is None:
+        return
+    source = _make_address_pdf(tmp_path)
+    output = tmp_path / "addr.disabled.pdf"
+
+    calls = []
+    real = core._search_pdf_address_lines
+
+    def _spy(page):
+        calls.append(page.number)
+        return real(page)
+
+    monkeypatch.setattr(core, "_search_pdf_address_lines", _spy)
+
+    redact_pdf_vector(source, [], output, disabled_kinds={"ADRESSE"})
+
+    # Le burn géométrique d'adresse ne doit PAS être appliqué.
+    assert not calls, (
+        "ADRESSE désactivée : _search_pdf_address_lines ne doit pas être appliqué"
+    )
+    redacted = fitz.open(output)
+    text = redacted[0].get_text()
+    redacted.close()
+    # L'adresse reste lisible puisque la catégorie est décochée.
+    assert "rue Claude Boucher" in text
+
+
+# ---------------------------------------------------------------------------
+# RASTER
+# ---------------------------------------------------------------------------
+def test_raster_address_search_called_when_adresse_enabled(tmp_path, monkeypatch):
+    if fitz is None:
+        return
+    source = _make_address_pdf(tmp_path)
+    output = tmp_path / "addr.raster.enabled.pdf"
+
+    calls = []
+    real = core._search_pdf_address_lines
+
+    def _spy(page):
+        calls.append(page.number)
+        return real(page)
+
+    monkeypatch.setattr(core, "_search_pdf_address_lines", _spy)
+
+    redact_pdf_raster(source, [], output, disabled_kinds=set())
+
+    assert calls, "ADRESSE activée (raster) : _search_pdf_address_lines doit être appelé"
+
+
+def test_raster_address_search_not_applied_when_adresse_disabled(tmp_path, monkeypatch):
+    if fitz is None:
+        return
+    source = _make_address_pdf(tmp_path)
+    output = tmp_path / "addr.raster.disabled.pdf"
+
+    calls = []
+    real = core._search_pdf_address_lines
+
+    def _spy(page):
+        calls.append(page.number)
+        return real(page)
+
+    monkeypatch.setattr(core, "_search_pdf_address_lines", _spy)
+
+    redact_pdf_raster(source, [], output, disabled_kinds={"ADRESSE"})
+
+    assert not calls, (
+        "ADRESSE désactivée (raster) : _search_pdf_address_lines ne doit pas être appliqué"
+    )
+
+
+# ---------------------------------------------------------------------------
+# Non-régression : signature positionnelle d'origine + défaut byte-for-byte
+# ---------------------------------------------------------------------------
+def test_vector_default_signature_still_calls_address_search(tmp_path, monkeypatch):
+    """Sans disabled_kinds (appel positionnel d'origine), le burn adresse
+    reste actif — non-régression stricte."""
+    if fitz is None:
+        return
+    source = _make_address_pdf(tmp_path)
+    output = tmp_path / "addr.default.pdf"
+
+    calls = []
+    real = core._search_pdf_address_lines
+
+    def _spy(page):
+        calls.append(page.number)
+        return real(page)
+
+    monkeypatch.setattr(core, "_search_pdf_address_lines", _spy)
+
+    # Appel d'origine : aucun argument disabled.
+    redact_pdf_vector(source, [PiiHit(0, "OGC", "14", "[OGC]")], output)
+
+    assert calls, "Défaut (pas de disabled) : burn adresse doit rester actif"
--- a/tests/unit/test_core_category_gating.py
+++ b/tests/unit/test_core_category_gating.py
@@ -0,0 +1,47 @@
+import anonymizer_core_refactored_onnx as core
+
+
+def test_category_of_each_source():
+    assert core._category_of("NOM_FORCE") == "NOM"          # explicite/regex
+    assert core._category_of("NIR") == "NIR"                # placeholder-self
+    assert core._category_of("NIR_GLOBAL") == "NIR"         # suffixe _GLOBAL
+    assert core._category_of("ADHERENT_GLOBAL") == "ADHERENT"
+    assert core._category_of("VLM_NOM") == "NOM"            # dérivé VLM
+    assert core._category_of("VLM_ETAB") == "ETAB"
+    assert core._category_of("EDS_SECU") == "NIR"           # dérivé EDS (SECU→NIR)
+    assert core._category_of("EDS_HOPITAL") == "ETAB"
+    assert core._category_of("VLM_CP") == "ADRESSE"          # CP suit « Adresses » (Dom 2026-06-26)
+    assert core._category_of("EDS_ZIP") == "ADRESSE"
+
+
+def test_category_of_default_deny():
+    # Non toggleables → None (restent TOUJOURS masqués). Sécurité.
+    # NB : VILLE reste masquée ; seul CODE_POSTAL (VLM_CP/EDS_ZIP) a été basculé vers ADRESSE.
+    for k in ("EMAIL", "IBAN", "IPP", "VILLE", "FAX",
+              "VLM_VILLE", "EMAIL_GLOBAL", "INCONNU_XYZ"):
+        assert core._category_of(k) is None, k
+    # Garde de terminaison de la récursion (_GLOBAL strip) : entrées vides.
+    assert core._category_of(None) is None
+    assert core._category_of("") is None
+
+
+def test_no_toggleable_vlm_or_eds_kind_is_uncategorised():
+    # ANTI-DÉRIVE : tout kind VLM/EDS dont le placeholder est une des 7 catégories
+    # DOIT être catégorisé (sinon toggle faussé sur ce chemin).
+    import vlm_manager, eds_pseudo_manager
+    seven = {"NOM", "DATE_NAISSANCE", "ETAB", "ADRESSE", "NIR", "TEL", "ADHERENT"}
+    for _label, (kind, placeholder) in vlm_manager.VLM_CATEGORY_MAP.items():
+        if core._placeholder_to_category(placeholder) in seven:
+            assert core._category_of(kind) is not None, f"VLM {kind} non catégorisé"
+    for label, placeholder in eds_pseudo_manager.EDS_LABEL_MAP.items():
+        if core._placeholder_to_category(placeholder) in seven:
+            assert core._category_of(f"EDS_{label}") is not None, f"EDS_{label} non catégorisé"
+
+
+def test_filter_audit_drops_only_disabled():
+    PiiHit = core.PiiHit
+    audit = [PiiHit(1, "NOM", "Dupont", "[NOM]"), PiiHit(1, "NIR", "1850574", "[NIR]"),
+             PiiHit(1, "EMAIL", "x@y.fr", "[EMAIL]"), PiiHit(1, "NIR_GLOBAL", "1850574", "[NIR]")]
+    kinds = {h.kind for h in core._filter_audit_by_disabled(audit, {"NIR"})}
+    assert "NIR" not in kinds and "NIR_GLOBAL" not in kinds  # NIR + propagation retirés
+    assert "NOM" in kinds and "EMAIL" in kinds               # autres conservés
--- a/tests/unit/test_core_category_gating_behavior.py
+++ b/tests/unit/test_core_category_gating_behavior.py
@@ -0,0 +1,260 @@
+"""Plan 1b — Task 3 (P1-2 / F-2 + F-5) : gating TEXTE par catégorie.
+
+Vérifie que, quand une des 7 catégories toggleables est décochée
+(``cfg["disabled_kinds"]``), la valeur de cette catégorie ressort EN CLAIR
+dans le texte produit, SANS jamais démasquer une autre catégorie encore
+activée (pas de fuite croisée) et SANS régression quand rien n'est désactivé.
+
+Entrées RÉELLES fabriquées à partir des vraies regex du moteur (aucun mock).
+NIR valide (clé modulo 97) calculé : body 1850578006084 → clé 91.
+"""
+import re
+
+import anonymizer_core_refactored_onnx as core
+
+
+# --- Échantillons clairs par catégorie (1 PII de la catégorie cible) ---------
+# Chaque échantillon est validé : masqué quand la catégorie est activée.
+_SAMPLES = {
+    "NOM": ("Nom de famille : DUPONT", "DUPONT", "[NOM]"),
+    "DATE_NAISSANCE": ("Né le 12/03/1950", "12/03/1950", "[DATE_NAISSANCE]"),
+    "ETAB": ("Etablissement : EHPAD Solemnis", "Solemnis", "[ETABLISSEMENT]"),
+    "ADRESSE": ("Domicile : 13 rue des Lilas", "rue des Lilas", "[ADRESSE]"),
+    "NIR": ("NIR 185057800608491", "185057800608491", "[NIR]"),
+    "TEL": ("Tel : 0612345678", "0612345678", "[TEL]"),
+    "ADHERENT": ("N° adhérent : ABC123456", "ABC123456", "[ADHERENT]"),
+}
+
+# Une catégorie « témoin » différente, toujours activée, dont le placeholder doit
+# rester présent (anti-fuite croisée). On choisit NIR comme témoin sauf pour la
+# catégorie cible NIR (témoin = TEL).
+_WITNESS = {
+    "NOM": ("NIR 185057800608491", "[NIR]"),
+    "DATE_NAISSANCE": ("NIR 185057800608491", "[NIR]"),
+    "ETAB": ("NIR 185057800608491", "[NIR]"),
+    "ADRESSE": ("NIR 185057800608491", "[NIR]"),
+    "NIR": ("Tel : 0612345678", "[TEL]"),
+    "TEL": ("NIR 185057800608491", "[NIR]"),
+    "ADHERENT": ("NIR 185057800608491", "[NIR]"),
+}
+
+_SEVEN = ["NOM", "DATE_NAISSANCE", "ETAB", "ADRESSE", "NIR", "TEL", "ADHERENT"]
+
+
+def _run(text, disabled):
+    cfg = core.load_dictionaries(None)
+    cfg["disabled_kinds"] = set(disabled)
+    return core.anonymise_document_regex([text], [], cfg)
+
+
+import pytest
+
+
+@pytest.mark.parametrize("cat", _SEVEN)
+def test_disabled_category_left_in_clear_witness_masked(cat):
+    """La catégorie décochée ressort en clair ; le témoin reste masqué."""
+    target_line, clear_value, target_ph = _SAMPLES[cat]
+    witness_line, witness_ph = _WITNESS[cat]
+    text = target_line + "\n" + witness_line
+
+    res = _run(text, {cat})
+    out = res.text_out
+
+    # 1) la valeur de la catégorie décochée doit être EN CLAIR
+    assert clear_value in out, (
+        f"{cat} décochée : '{clear_value}' devrait être en clair.\nout={out!r}")
+    # 2) son placeholder ne doit PAS apparaître
+    assert target_ph not in out, (
+        f"{cat} décochée : '{target_ph}' ne devrait pas apparaître.\nout={out!r}")
+    # 3) le témoin (autre catégorie activée) doit RESTER masqué
+    assert witness_ph in out, (
+        f"{cat} décochée : témoin {witness_ph} devrait rester masqué.\nout={out!r}")
+
+
+@pytest.mark.parametrize("cat", _SEVEN)
+def test_enabled_category_still_masked(cat):
+    """Avec rien de désactivé, chaque catégorie reste masquée (non-régression)."""
+    target_line, clear_value, target_ph = _SAMPLES[cat]
+    res = _run(target_line, set())
+    assert target_ph in res.text_out, (
+        f"{cat} activée devrait être masquée.\nout={res.text_out!r}")
+
+
+def test_one_disabled_all_others_stay_masked():
+    """1 catégorie décochée : TOUTES les autres restent masquées (anti-fuite)."""
+    text = "\n".join(s[0] for s in _SAMPLES.values())
+    for off in _SEVEN:
+        res = _run(text, {off})
+        out = res.text_out
+        # la catégorie décochée doit être en clair
+        clear = _SAMPLES[off][1]
+        assert clear in out, f"{off} décochée devrait être en clair.\nout={out!r}"
+        # toutes les AUTRES doivent rester masquées
+        for other in _SEVEN:
+            if other == off:
+                continue
+            ph = _SAMPLES[other][2]
+            assert ph in out, (
+                f"{off} décochée NE doit PAS démasquer {other} ({ph}).\nout={out!r}")
+
+
+def test_baseline_all_enabled_byte_for_byte():
+    """disabled vide ⇒ sortie identique à un run sans la clé disabled_kinds."""
+    text = "\n".join(s[0] for s in _SAMPLES.values())
+    cfg_a = core.load_dictionaries(None)
+    cfg_a["disabled_kinds"] = set()
+    cfg_b = core.load_dictionaries(None)  # pas de clé du tout
+    out_a = core.anonymise_document_regex([text], [], cfg_a).text_out
+    out_b = core.anonymise_document_regex([text], [], cfg_b).text_out
+    assert out_a == out_b
+    # et tout est bien masqué
+    for _line, _clear, ph in _SAMPLES.values():
+        assert ph in out_a
+
+
+# --- selective_rescan : filet de sécurité, doit aussi gater ------------------
+@pytest.mark.parametrize("cat,line,clear,ph", [
+    ("TEL", "Joindre au 0612345678", "0612345678", "[TEL]"),
+    ("NIR", "Secu 185057800608491", "185057800608491", "[NIR]"),
+    ("ADRESSE", "13 rue des Lilas ici", "rue des Lilas", "[ADRESSE]"),
+    ("DATE_NAISSANCE", "Né le 12/03/1950", "12/03/1950", "[DATE_NAISSANCE]"),
+    ("ETAB", "Etablissement EHPAD Solemnis", "Solemnis", "[ETABLISSEMENT]"),
+    ("ADHERENT", "N° adhérent : ABC123456", "ABC123456", "[ADHERENT]"),
+])
+def test_selective_rescan_gates_disabled(cat, line, clear, ph):
+    cfg = core.load_dictionaries(None)
+    cfg["disabled_kinds"] = {cat}
+    out = core.selective_rescan(line, cfg=cfg)
+    assert clear in out, f"rescan {cat} décochée : '{clear}' devrait rester clair.\nout={out!r}"
+    assert ph not in out, f"rescan {cat} décochée : {ph} ne devrait pas apparaître.\nout={out!r}"
+
+
+def test_selective_rescan_empty_disabled_byte_for_byte():
+    """selective_rescan : disabled vide == aucune clé (non-régression)."""
+    line = ("Joindre au 0612345678, Secu 185057800608491, "
+            "13 rue des Lilas, Né le 12/03/1950, EHPAD Solemnis")
+    cfg_none = core.load_dictionaries(None)
+    cfg_empty = core.load_dictionaries(None)
+    cfg_empty["disabled_kinds"] = set()
+    assert core.selective_rescan(line, cfg=cfg_none) == core.selective_rescan(line, cfg=cfg_empty)
+
+
+def test_selective_rescan_enabled_still_masks():
+    """Non-régression rescan : rien désactivé ⇒ masque tout."""
+    cfg = core.load_dictionaries(None)
+    cfg["disabled_kinds"] = set()
+    line = "Joindre au 0612345678 et Secu 185057800608491"
+    out = core.selective_rescan(line, cfg=cfg)
+    assert "[TEL]" in out and "[NIR]" in out
+    assert "0612345678" not in out and "185057800608491" not in out
+
+
+# --- NER per-hit (F-5) : _mask_with_hf -------------------------------------
+def test_mask_with_hf_per_hit_gating():
+    """NOM décoché : l'entité PER ressort en clair, l'ORG (ETAB) reste masquée."""
+    cfg = core.load_dictionaries(None)
+    cfg["disabled_kinds"] = {"NOM"}
+    text = "Le patient Martin suivi par Hopital Saint-Louis"
+    ents = [
+        {"word": "Martin", "entity_group": "PER"},
+        {"word": "Hopital Saint-Louis", "entity_group": "ORG"},
+    ]
+    audit = []
+    out = core._mask_with_hf(text, ents, cfg, audit)
+    assert "Martin" in out, f"NOM décoché : Martin devrait rester clair.\nout={out!r}"
+    assert "[NOM]" not in out
+    assert "[ETABLISSEMENT]" in out, f"ETAB activé devrait être masqué.\nout={out!r}"
+
+
+def test_mask_with_hf_no_disabled_masks_all():
+    cfg = core.load_dictionaries(None)
+    cfg["disabled_kinds"] = set()
+    text = "Le patient Martin"
+    ents = [{"word": "Martin", "entity_group": "PER"}]
+    out = core._mask_with_hf(text, ents, cfg, [])
+    assert "[NOM]" in out and "Martin" not in out
+
+
+# --- NER per-hit (F-5) : _mask_with_eds_pseudo -----------------------------
+def test_mask_with_eds_pseudo_per_hit_gating():
+    """NOM décoché : entité EDS NOM en clair, HOPITAL (ETAB) reste masquée."""
+    cfg = core.load_dictionaries(None)
+    cfg["disabled_kinds"] = {"NOM"}
+    text = "Compte rendu Bernardo signe a Belledonne"
+    ents = [
+        {"word": "Bernardo", "entity_group": "NOM", "eds_mapped_key": "NOM", "score": 0.99},
+        {"word": "Belledonne", "entity_group": "HOPITAL", "eds_mapped_key": "ETAB", "score": 0.99},
+    ]
+    out = core._mask_with_eds_pseudo(text, ents, cfg, [])
+    assert "Bernardo" in out, f"NOM décoché : Bernardo devrait rester clair.\nout={out!r}"
+    assert "[NOM]" not in out
+    assert "[ETABLISSEMENT]" in out, f"ETAB activé devrait être masqué.\nout={out!r}"
+
+
+# --- VLM per-hit (F-2) : _apply_vlm gating helper --------------------------
+def test_vlm_kind_gating_is_per_hit():
+    """Le gating VLM s'évalue par hit via _category_of(kind)."""
+    import vlm_manager
+    # NOM décoché : VLM_NOM doit être filtré, VLM_ETAB conservé.
+    nom_kind, _ = vlm_manager.VLM_CATEGORY_MAP["NOM"]
+    etab_kind, _ = vlm_manager.VLM_CATEGORY_MAP["ETABLISSEMENT"]
+    assert core._category_of(nom_kind) == "NOM"
+    assert core._category_of(etab_kind) == "ETAB"
+
+
+# === Régression AUDIT-LEVEL (revue qualité : fuite PDF FAX avec TEL décoché) ===
+# Le burn PDF (vector+raster) dérive UNIQUEMENT de anon.audit. Un type non
+# toggleable dont l'unique site de détection tombait dans (ou en aval d')un bloc
+# gaté ne produisait plus de hit audit → numéro VISIBLE dans le PDF livré, même
+# si le .txt paraissait propre. Ces tests assertent sur anon.audit, pas le texte.
+
+def _audit_kinds(text, disabled):
+    """Lance le constructeur d'audit (anonymise_document_regex) et renvoie les hits."""
+    cfg = core.load_dictionaries(None)
+    cfg["disabled_kinds"] = set(disabled)
+    return core.anonymise_document_regex([text], [], cfg).audit
+
+
+def _has_hit(audit, kind, placeholder=None):
+    for h in audit:
+        if h.kind == kind and (placeholder is None or h.placeholder == placeholder):
+            return True
+    return False
+
+
+@pytest.mark.parametrize("line,fax_value", [
+    ("Fax : 0512345678", "0512345678"),
+    ("Télécopie : 05 12 34 56 78", "05 12 34 56 78"),
+    ("Télécopieur : 0512345678", "0512345678"),
+])
+def test_fax_audit_hit_survives_tel_disabled(line, fax_value):
+    """FAX (non toggleable) DOIT rester dans anon.audit quand TEL est décoché.
+    C'est le test qui échouait avant le correctif de découplage FAX (fuite PDF)."""
+    audit = _audit_kinds(line, {"TEL"})
+    # Un hit FAX doit exister (kind ET placeholder), pour que le burn PDF le masque.
+    assert _has_hit(audit, "FAX", core.PLACEHOLDERS["FAX"]), (
+        f"FAX absent de l'audit avec TEL décoché → fuite PDF.\n"
+        f"line={line!r}\naudit={[(h.kind, h.original) for h in audit]}")
+    # La valeur ne doit pas survivre déguisée en hit TEL non plus.
+    assert not _has_hit(audit, "TEL"), "Un fax ne doit pas devenir un hit TEL."
+
+
+def test_fax_audit_hit_present_when_nothing_disabled():
+    """Non-régression : FAX produit bien un hit audit sur le chemin par défaut."""
+    audit = _audit_kinds("Fax : 0512345678", set())
+    assert _has_hit(audit, "FAX", core.PLACEHOLDERS["FAX"])
+
+
+def test_tel_audit_hit_dropped_when_tel_disabled():
+    """Cohérence : un vrai TÉLÉPHONE (toggleable) sort bien de l'audit si TEL décoché."""
+    audit = _audit_kinds("Tel : 0612345678", {"TEL"})
+    assert not _has_hit(audit, "TEL"), "TEL décoché ⇒ pas de hit TEL (numéro laissé clair)."
+
+
+@pytest.mark.parametrize("off", ["NOM", "ADRESSE", "NIR", "ADHERENT", "ETAB", "DATE_NAISSANCE"])
+def test_fax_audit_survives_any_unrelated_toggle(off):
+    """Général : le non toggleable FAX reste dans l'audit quel que soit le toggle décoché."""
+    audit = _audit_kinds("Fax : 0512345678", {off})
+    assert _has_hit(audit, "FAX", core.PLACEHOLDERS["FAX"]), (
+        f"FAX absent de l'audit avec {off} décoché.\n"
+        f"audit={[(h.kind, h.original) for h in audit]}")
--- a/tests/unit/test_core_forced_hits_exempt.py
+++ b/tests/unit/test_core_forced_hits_exempt.py
@@ -0,0 +1,76 @@
+"""Anti-fuite PDF : un masque FORCÉ (override utilisateur / blacklist force-mask)
+ne doit JAMAIS être retiré de l'audit par un toggle de catégorie.
+
+Contexte (Plan 1b, P1-2/T1) :
+- `_apply_overrides` masque le TEXTE inline ET ajoute un `PiiHit` dont le `kind`
+  est contrôlé par l'utilisateur (`name` de l'override). Cet appel est
+  inconditionnel (pas gaté par `disabled_kinds`).
+- `_filter_audit_by_disabled` retire ensuite de l'audit les hits dont la
+  catégorie est désactivée, AVANT la gravure PDF.
+- BUG : si un utilisateur nomme un override avec une catégorie toggleable
+  (ex. `name="NOM"`) et désactive cette catégorie, le texte reste masqué mais
+  le hit est retiré de l'audit → la gravure PDF laisse la valeur EN CLAIR.
+
+Correctif attendu : marquer les hits forcés (`forced=True`) et les exempter du
+filtre catégorie. Un terme explicitement forcé est TOUJOURS gravé.
+"""
+import re
+
+import anonymizer_core_refactored_onnx as core
+
+
+def test_forced_override_hit_survives_category_filter():
+    """Un override nommé "NOM" produit un hit FORCÉ qui survit au filtre {"NOM"}."""
+    cfg = {
+        "regex_overrides": [
+            {"pattern": r"\bDupont\b", "placeholder": "[NOM]", "name": "NOM"},
+        ],
+    }
+    audit: list = []
+    line = "Patient Dupont vu ce jour."
+
+    masked = core._apply_overrides(line, audit, 0, cfg)
+
+    # Le texte est bien masqué (comportement inline inchangé).
+    assert "Dupont" not in masked
+    assert "[NOM]" in masked
+
+    # Un hit a été produit, de catégorie NOM, et marqué forcé.
+    assert len(audit) == 1
+    forced_hit = audit[0]
+    assert forced_hit.kind == "NOM"
+    assert core._category_of(forced_hit.kind) == "NOM"
+    assert getattr(forced_hit, "forced", False) is True
+
+    # Cœur du correctif : avec NOM désactivé, le hit FORCÉ reste dans l'audit
+    # (donc serait gravé dans le PDF) → pas de fuite.
+    filtered = core._filter_audit_by_disabled(list(audit), {"NOM"})
+    assert forced_hit in filtered, "le hit forcé a été retiré → fuite PDF"
+
+
+def test_genuine_nom_hit_still_dropped_by_filter():
+    """Le correctif ne sur-exempte pas : un vrai hit NOM (non forcé) est bien retiré."""
+    genuine = core.PiiHit(0, "NOM", "Martin", "[NOM]")
+    # Par défaut un PiiHit n'est PAS forcé.
+    assert getattr(genuine, "forced", False) is False
+
+    filtered = core._filter_audit_by_disabled([genuine], {"NOM"})
+    assert genuine not in filtered, "un hit NOM non forcé doit être retiré quand NOM est désactivé"
+
+
+def test_forced_blacklist_terms_marked_forced():
+    """Les force_mask_terms / force_mask_regex sont aussi marqués forcés."""
+    cfg = {
+        "blacklist": {
+            "force_mask_terms": ["CHUXX"],
+            "force_mask_regex": [r"SIGLE-\d+"],
+        },
+    }
+    audit: list = []
+    line = "Etablissement CHUXX, code SIGLE-42."
+
+    core._apply_overrides(line, audit, 0, cfg)
+
+    assert len(audit) == 2
+    for h in audit:
+        assert getattr(h, "forced", False) is True, f"{h.kind} non marqué forcé"
--- a/tests/unit/test_edsnlp_drugs_static.py
+++ b/tests/unit/test_edsnlp_drugs_static.py
@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""
+Tests — chargement du gazetteer médicaments edsnlp depuis data/ (torch-free).
+
+Contexte : le build Windows torch-free (Plan 3) retire torch. Or edsnlp importe
+torch en dur → en frozen, `import edsnlp` échoue et l'ancienne
+`_load_edsnlp_drug_names()` retournait silencieusement set() → whitelist
+médicaments amputée de ~4206 noms → sur-masquage de médicaments pris pour des
+personnes.
+
+Correctif (Option A+B) :
+  A. charger d'abord depuis data/edsnlp/drugs.json (versionné, 0 dépendance) ;
+     fallback sur le package edsnlp (dev).
+  B. log.warning explicite si NI le fichier data NI le package ne sont dispo.
+
+Aucun mock du contenu du gazetteer : on utilise le VRAI fichier data extrait.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+import anonymizer_core_refactored_onnx as core
+
+ROOT_DIR = Path(__file__).resolve().parents[2]
+DATA_DRUGS = ROOT_DIR / "data" / "edsnlp" / "drugs.json"
+
+# Nombre exact de noms mono-mot (len>=4, lowercase) issus de drugs.json 0.20.0.
+# C'est aussi le compte historique produit par l'ancienne fonction en dev :
+# la garantie de non-régression est que la whitelist n'est PAS réduite.
+EXPECTED_COUNT = 4206
+
+# Noms de médicaments réellement présents dans le gazetteer extrait et qui
+# entrent en conflit avec des noms/prénoms INSEE (vérifiés, pas inventés).
+CONFLICT_NAMES = ["elisor", "kessar", "panos", "muse", "sirop"]
+
+
+def test_data_file_present_and_parses():
+    """Le fichier data doit exister et contenir 1968 codes ATC."""
+    import json
+
+    assert DATA_DRUGS.exists(), f"fichier data manquant : {DATA_DRUGS}"
+    data = json.loads(DATA_DRUGS.read_text(encoding="utf-8"))
+    assert len(data) == 1968
+
+
+def test_load_from_data_exact_count():
+    """Chargement depuis data/edsnlp/drugs.json → set de 4206 noms exactement."""
+    result = core._load_edsnlp_drug_names()
+    assert isinstance(result, set)
+    assert len(result) == EXPECTED_COUNT
+
+
+def test_load_contains_conflict_names():
+    """Les noms-conflits INSEE vérifiés doivent être dans le set (anti-sur-masquage)."""
+    result = core._load_edsnlp_drug_names()
+    for name in CONFLICT_NAMES:
+        assert name in result, f"{name!r} absent du gazetteer médicaments"
+
+
+def test_fallback_to_package_when_data_absent(monkeypatch, tmp_path):
+    """Si le fichier data est absent mais edsnlp importable → fallback package,
+    même résultat (4206)."""
+    pytest.importorskip("edsnlp")
+    # Pointer la constante de chemin data vers un dossier vide → fichier absent.
+    missing = tmp_path / "drugs.json"
+    monkeypatch.setattr(core, "_EDSNLP_DRUGS_DATA_PATH", missing)
+    assert not missing.exists()
+
+    result = core._load_edsnlp_drug_names()
+    assert len(result) == EXPECTED_COUNT
+    for name in CONFLICT_NAMES:
+        assert name in result
+
+
+def test_warning_when_both_sources_absent(monkeypatch, tmp_path, caplog):
+    """Si le fichier data est absent ET edsnlp non importable → set() + log.warning."""
+    import builtins
+
+    missing = tmp_path / "drugs.json"
+    monkeypatch.setattr(core, "_EDSNLP_DRUGS_DATA_PATH", missing)
+
+    _real_import = builtins.__import__
+
+    def _fake_import(name, *args, **kwargs):
+        if name == "edsnlp" or name.startswith("edsnlp."):
+            raise ImportError("edsnlp indisponible (torch-free)")
+        return _real_import(name, *args, **kwargs)
+
+    monkeypatch.setattr(builtins, "__import__", _fake_import)
+
+    with caplog.at_level("WARNING", logger=core.log.name):
+        result = core._load_edsnlp_drug_names()
+
+    assert result == set()
+    assert any(
+        "edsnlp" in rec.message.lower() and rec.levelname == "WARNING"
+        for rec in caplog.records
+    ), "aucun log.warning émis lors de l'échec total"
+
+
+def test_data_source_matches_package_source(monkeypatch, tmp_path):
+    """Le set chargé depuis data doit être IDENTIQUE à celui du fallback package
+    (garantie que l'extraction n'altère pas le gazetteer)."""
+    pytest.importorskip("edsnlp")
+    from_data = core._load_edsnlp_drug_names()
+
+    missing = tmp_path / "drugs.json"
+    monkeypatch.setattr(core, "_EDSNLP_DRUGS_DATA_PATH", missing)
+    from_package = core._load_edsnlp_drug_names()
+
+    assert from_data == from_package
+
+
+def test_corrupted_data_falls_back_to_package(monkeypatch, tmp_path):
+    """Fichier data PRÉSENT mais corrompu + edsnlp DISPONIBLE → fail-safe :
+    retombe sur le package et retourne 4206 (jamais un set partiel/tronqué)."""
+    pytest.importorskip("edsnlp")
+    corrupt = tmp_path / "drugs.json"
+    corrupt.write_text("{ invalide", encoding="utf-8")
+    monkeypatch.setattr(core, "_EDSNLP_DRUGS_DATA_PATH", corrupt)
+
+    result = core._load_edsnlp_drug_names()
+    assert len(result) == EXPECTED_COUNT
+    for name in CONFLICT_NAMES:
+        assert name in result
+
+
+def test_corrupted_data_and_no_package_warns(monkeypatch, tmp_path, caplog):
+    """Fichier data corrompu ET edsnlp INDISPONIBLE → set() vide + log.warning
+    (dégradation rendue visible, pas de silence)."""
+    import builtins
+
+    corrupt = tmp_path / "drugs.json"
+    corrupt.write_text("{ invalide", encoding="utf-8")
+    monkeypatch.setattr(core, "_EDSNLP_DRUGS_DATA_PATH", corrupt)
+
+    _real_import = builtins.__import__
+
+    def _fake_import(name, *args, **kwargs):
+        if name == "edsnlp" or name.startswith("edsnlp."):
+            raise ImportError("edsnlp indisponible (torch-free)")
+        return _real_import(name, *args, **kwargs)
+
+    monkeypatch.setattr(builtins, "__import__", _fake_import)
+
+    with caplog.at_level("WARNING", logger=core.log.name):
+        result = core._load_edsnlp_drug_names()
+
+    assert result == set()
+    assert any(
+        "edsnlp" in rec.message.lower() and rec.levelname == "WARNING"
+        for rec in caplog.records
+    ), "aucun log.warning émis lors de l'échec total (data corrompu + pas de package)"
--- a/tests/unit/test_gui_v6_category_toggles.py
+++ b/tests/unit/test_gui_v6_category_toggles.py
@@ -0,0 +1,121 @@
+"""Tests du câblage des 7 toggles « Données à détecter » → moteur (Plan 1b / P1-2).
+
+Sémantique UI : un toggle ON = « détecter cette catégorie » (= masquer).
+Un toggle OFF = la catégorie est laissée en clair → elle entre dans
+``disabled_kinds`` (set des CATÉGORIES désactivées passé au moteur).
+
+Aucun widget, aucun display : on teste l'état (ConfigState) et le pont
+(build_engine_kwargs / make_process_fn) en pur Python.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from gui_v6.config_state import (
+    CATEGORY_FIELDS,
+    DETECTION_CATEGORIES,
+    ConfigState,
+)
+from gui_v6.engine_bridge import (
+    EngineSettings,
+    NerManagers,
+    build_engine_kwargs,
+    make_process_fn,
+)
+
+
+# -- catégories canoniques -------------------------------------------------
+
+def test_seven_categories_match_engine_set():
+    # Les 7 catégories exposées doivent matcher EXACTEMENT le set moteur.
+    assert set(DETECTION_CATEGORIES) == {
+        "NOM",
+        "DATE_NAISSANCE",
+        "ETAB",
+        "ADRESSE",
+        "NIR",
+        "TEL",
+        "ADHERENT",
+    }
+    # Un champ booléen par catégorie.
+    assert set(CATEGORY_FIELDS.values()) == set(DETECTION_CATEGORIES)
+
+
+# -- disabled_kinds dérivé -------------------------------------------------
+
+def test_disabled_kinds_empty_by_default():
+    # Défaut : tous les toggles ON ⇒ aucun désactivé (zéro changement vs aujourd'hui).
+    state = ConfigState()
+    assert state.disabled_kinds() == frozenset()
+
+
+def test_disabled_kinds_unchecking_nir_and_etab():
+    # Décocher « N° sécurité sociale » (NIR) et « Établissements » (ETAB).
+    state = ConfigState(detect_nir=False, detect_etab=False)
+    assert state.disabled_kinds() == frozenset({"NIR", "ETAB"})
+
+
+def test_disabled_kinds_all_off():
+    state = ConfigState(
+        detect_nom=False,
+        detect_date_naissance=False,
+        detect_etab=False,
+        detect_adresse=False,
+        detect_nir=False,
+        detect_tel=False,
+        detect_adherent=False,
+    )
+    assert state.disabled_kinds() == frozenset(DETECTION_CATEGORIES)
+
+
+# -- propagation vers EngineSettings --------------------------------------
+
+def test_to_engine_settings_propagates_disabled_kinds():
+    state = ConfigState(detect_nir=False, detect_tel=False)
+    settings = state.to_engine_settings()
+    assert settings.disabled_kinds == frozenset({"NIR", "TEL"})
+
+
+def test_to_engine_settings_default_empty():
+    settings = ConfigState().to_engine_settings()
+    assert settings.disabled_kinds == frozenset()
+
+
+# -- propagation dans les kwargs moteur -----------------------------------
+
+def test_build_engine_kwargs_includes_disabled_kinds():
+    settings = EngineSettings(disabled_kinds=frozenset({"NIR", "ETAB"}))
+    kwargs = build_engine_kwargs(settings, managers=None)
+    assert kwargs["disabled_kinds"] == frozenset({"NIR", "ETAB"})
+
+
+def test_build_engine_kwargs_default_empty_disabled_kinds():
+    # Défaut (set vide) = no-op : la clé est présente mais vide.
+    kwargs = build_engine_kwargs(EngineSettings(), managers=None)
+    assert kwargs["disabled_kinds"] == frozenset()
+
+
+def test_process_fn_threads_disabled_kinds_to_engine(tmp_path):
+    settings = EngineSettings(
+        use_local_ner=False, disabled_kinds=frozenset({"ADRESSE"})
+    )
+    managers = NerManagers(settings)
+    captured = {}
+
+    def fake_engine(doc_path, out_dir, **kwargs):
+        captured["kwargs"] = kwargs
+        return {"status": "ok"}
+
+    fn = make_process_fn(settings, managers=managers, engine=fake_engine)
+    fn(tmp_path / "doc.pdf", tmp_path / "out")
+    assert captured["kwargs"]["disabled_kinds"] == frozenset({"ADRESSE"})
+
+
+# -- bout-en-bout : ConfigState → settings → kwargs -----------------------
+
+def test_end_to_end_state_to_kwargs(tmp_path):
+    state = ConfigState(detect_adherent=False)
+    settings = state.to_engine_settings(config_path=Path("/tmp/c.yml"))
+    kwargs = build_engine_kwargs(settings, managers=None)
+    assert kwargs["disabled_kinds"] == frozenset({"ADHERENT"})
--- a/tests/unit/test_gui_v6_config_mockup_sections.py
+++ b/tests/unit/test_gui_v6_config_mockup_sections.py
@@ -55,10 +55,26 @@ def test_config_interaction_contract_prebuilds_panels_and_mask_editor():
    ]


+def test_detection_options_fields_match_category_fields():
+    """Garde-fou anti-dérive : les champs déclarés dans _DETECTION_OPTIONS doivent
+    rester alignés (mêmes champs ET même ordre) sur CATEGORY_FIELDS, sinon un
+    toggle pointerait vers un attribut ConfigState inexistant (AttributeError au
+    lancement de la GUI au lieu d'un échec de test)."""
+    from gui_v6.config_state import CATEGORY_FIELDS, ConfigState
+
+    fields = [field for _l, _h, field in _DETECTION_OPTIONS]
+    assert fields == list(CATEGORY_FIELDS)  # mêmes champs ET même ordre (ordre UI = ordre catégories)
+    for f in fields:  # chacun est bien un booléen réel de ConfigState
+        assert isinstance(getattr(ConfigState(), f), bool)
+
+
 def test_detection_rows_are_readable_in_light_theme():
    """Retour Dom : les sous-labels de la colonne détection doivent rester lisibles."""
-    assert ("Noms et prénoms", "Annuaire + IA") in _DETECTION_OPTIONS
-    assert ("Noms et prénoms", "Bases de données + IA") not in _DETECTION_OPTIONS
+    # Chaque ligne est désormais (libellé, aide, champ ConfigState) ; on ne
+    # vérifie ici que le couple (libellé, aide) reste lisible.
+    label_hint = [(label, hint) for label, hint, _field in _DETECTION_OPTIONS]
+    assert ("Noms et prénoms", "Annuaire + IA") in label_hint
+    assert ("Noms et prénoms", "Bases de données + IA") not in label_hint
    assert MINI_TOGGLE_HEIGHT >= 44
    assert MINI_TOGGLE_LABEL_FONT_SIZE >= 12
    assert MINI_TOGGLE_HINT_FONT_SIZE >= 11
--- a/tests/unit/test_gui_v6_config_paths.py
+++ b/tests/unit/test_gui_v6_config_paths.py
@@ -0,0 +1,82 @@
+"""Résolution du dictionnaires.yml externe éditable (P1-4).
+
+Pur : on simule frozen via monkeypatch (sys.frozen / sys.executable / _MEIPASS),
+aucun display, aucun modèle.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import gui_v6.config_paths as cp
+
+
+def _make_bundle(tmp_path: Path) -> Path:
+    bundle = tmp_path / "bundle"
+    (bundle / "config").mkdir(parents=True)
+    (bundle / "config" / "dictionnaires.yml").write_text("whitelist_phrases: []\n", encoding="utf-8")
+    return bundle
+
+
+def test_dev_returns_repo_config_when_present(monkeypatch):
+    # En dev (non frozen) : pointe la config embarquée si elle existe.
+    monkeypatch.setattr(cp.sys, "frozen", False, raising=False)
+    path = cp.resolve_user_config_path()
+    assert path is not None
+    assert path.name == "dictionnaires.yml"
+    assert path.exists()
+
+
+def test_frozen_copies_bundle_on_first_launch(tmp_path, monkeypatch):
+    bundle = _make_bundle(tmp_path)
+    exe_dir = tmp_path / "exe"
+    exe_dir.mkdir()
+    monkeypatch.setattr(cp.sys, "frozen", True, raising=False)
+    monkeypatch.setattr(cp.sys, "_MEIPASS", str(bundle), raising=False)
+    monkeypatch.setattr(cp.sys, "executable", str(exe_dir / "Anonymisation.exe"), raising=False)
+
+    out = cp.resolve_user_config_path()
+    expected = exe_dir / "config" / "dictionnaires.yml"
+    assert out == expected
+    assert expected.exists()  # copié depuis le bundle au 1er lancement
+    assert expected.read_text(encoding="utf-8") == "whitelist_phrases: []\n"
+
+
+def test_frozen_keeps_existing_user_config(tmp_path, monkeypatch):
+    bundle = _make_bundle(tmp_path)
+    exe_dir = tmp_path / "exe"
+    (exe_dir / "config").mkdir(parents=True)
+    user_cfg = exe_dir / "config" / "dictionnaires.yml"
+    user_cfg.write_text("whitelist_phrases: [HOPITAL_LOCAL]\n", encoding="utf-8")
+    monkeypatch.setattr(cp.sys, "frozen", True, raising=False)
+    monkeypatch.setattr(cp.sys, "_MEIPASS", str(bundle), raising=False)
+    monkeypatch.setattr(cp.sys, "executable", str(exe_dir / "Anonymisation.exe"), raising=False)
+
+    out = cp.resolve_user_config_path()
+    assert out == user_cfg
+    # Ne JAMAIS écraser la perso établissement existante.
+    assert "HOPITAL_LOCAL" in out.read_text(encoding="utf-8")
+
+
+def test_dev_returns_none_when_config_missing(tmp_path, monkeypatch):
+    # En dev, si la config embarquée est absente : on renvoie None (pas de création).
+    monkeypatch.setattr(cp.sys, "frozen", False, raising=False)
+    monkeypatch.setattr(cp, "_bundled_config", lambda: tmp_path / "absent" / "dictionnaires.yml")
+    assert cp.resolve_user_config_path() is None
+
+
+def test_frozen_copy_failure_falls_back(tmp_path, monkeypatch):
+    # En frozen, si la copie échoue (ex. droits) : fallback sur la config embarquée, sans crash.
+    bundle = _make_bundle(tmp_path)
+    exe_dir = tmp_path / "exe"
+    exe_dir.mkdir()
+    monkeypatch.setattr(cp.sys, "frozen", True, raising=False)
+    monkeypatch.setattr(cp.sys, "_MEIPASS", str(bundle), raising=False)
+    monkeypatch.setattr(cp.sys, "executable", str(exe_dir / "Anonymisation.exe"), raising=False)
+
+    def _boom(*_args, **_kwargs):
+        raise PermissionError("accès refusé")
+
+    monkeypatch.setattr(cp.shutil, "copyfile", _boom)
+
+    out = cp.resolve_user_config_path()
+    assert out == cp._bundled_config()
--- a/tests/unit/test_gui_v6_config_share.py
+++ b/tests/unit/test_gui_v6_config_share.py
@@ -0,0 +1,95 @@
+"""Export / import de configuration (P1-3) — format compatible merge_params.
+
+Pur : sérialisation/désérialisation et fusion, sans display ni filedialog.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from gui_v6.config_share import build_export_payload, import_config_file
+
+
+def test_export_payload_has_v5_schema():
+    payload = build_export_payload(
+        whitelist=["Dr Métier", "Service ORL"],
+        blacklist=["DUPONT"],
+        version="2026.06.29",
+    )
+    assert payload["version"] == "2026.06.29"
+    assert "date_export" in payload
+    assert payload["whitelist_phrases"] == ["Dr Métier", "Service ORL"]
+    assert payload["blacklist_force_mask_terms"] == ["DUPONT"]
+
+
+def test_export_payload_is_json_serializable():
+    payload = build_export_payload(whitelist=["A"], blacklist=["B"], version="1")
+    json.dumps(payload)  # ne doit pas lever
+
+
+def test_import_merges_into_user_config(tmp_path, monkeypatch):
+    cfg = tmp_path / "dictionnaires.yml"
+    cfg.write_text("whitelist_phrases: [Existant]\n", encoding="utf-8")
+    incoming = tmp_path / "recu.json"
+    incoming.write_text(
+        json.dumps({
+            "version": "1", "date_export": "2026-06-29",
+            "whitelist_phrases": ["Nouveau"],
+            "blacklist_force_mask_terms": ["MASQUERMOI"],
+        }),
+        encoding="utf-8",
+    )
+    added = import_config_file(incoming, cfg)
+    assert added is True
+    import yaml
+    merged = yaml.safe_load(cfg.read_text(encoding="utf-8"))
+    assert "Existant" in merged["whitelist_phrases"]
+    assert "Nouveau" in merged["whitelist_phrases"]
+    assert "MASQUERMOI" in merged["blacklist"]["force_mask_terms"]
+
+
+def test_import_returns_false_when_nothing_new(tmp_path):
+    cfg = tmp_path / "dictionnaires.yml"
+    cfg.write_text("whitelist_phrases: [Deja]\n", encoding="utf-8")
+    incoming = tmp_path / "recu.json"
+    incoming.write_text(
+        json.dumps({"whitelist_phrases": ["Deja"], "blacklist_force_mask_terms": []}),
+        encoding="utf-8",
+    )
+    assert import_config_file(incoming, cfg) is False
+
+
+def test_import_preserves_unmanaged_yaml_keys(tmp_path):
+    # Une config riche : l'import ne doit toucher QUE whitelist/blacklist,
+    # et préserver toutes les autres sections (anti-perte de données).
+    cfg = tmp_path / "dictionnaires.yml"
+    cfg.write_text(
+        "version: 3\n"
+        "whitelist_phrases: [Existant]\n"
+        "blacklist:\n"
+        "  force_mask_terms: [DEJA]\n"
+        "  autre_sous_cle: [GARDER]\n"
+        "regex_overrides:\n"
+        "  - rule_a\n"
+        "flags:\n"
+        "  strict: true\n",
+        encoding="utf-8",
+    )
+    incoming = tmp_path / "recu.json"
+    incoming.write_text(
+        json.dumps({"whitelist_phrases": ["Nouveau"], "blacklist_force_mask_terms": ["MASQUERMOI"]}),
+        encoding="utf-8",
+    )
+    assert import_config_file(incoming, cfg) is True
+    import yaml
+    merged = yaml.safe_load(cfg.read_text(encoding="utf-8"))
+    # Clés non gérées intactes
+    assert merged["version"] == 3
+    assert merged["regex_overrides"] == ["rule_a"]
+    assert merged["flags"] == {"strict": True}
+    assert merged["blacklist"]["autre_sous_cle"] == ["GARDER"]
+    # Listes gérées fusionnées
+    assert "Existant" in merged["whitelist_phrases"]
+    assert "Nouveau" in merged["whitelist_phrases"]
+    assert "DEJA" in merged["blacklist"]["force_mask_terms"]
+    assert "MASQUERMOI" in merged["blacklist"]["force_mask_terms"]
--- a/tests/unit/test_gui_v6_diagnostics.py
+++ b/tests/unit/test_gui_v6_diagnostics.py
@@ -0,0 +1,136 @@
+import json
+from types import SimpleNamespace
+
+from gui_v6 import diagnostics
+
+
+def _doc(**kw):
+    base = dict(ordinal=0, status="success", error_type=None, error_code=None, duration_ms=12)
+    base.update(kw)
+    return SimpleNamespace(**base)
+
+
+def test_new_run_id_is_hex():
+    rid = diagnostics.new_run_id()
+    assert isinstance(rid, str) and len(rid) >= 16
+
+
+def test_items_from_summary_whitelist_only():
+    summary = SimpleNamespace(documents=[
+        _doc(ordinal=0, status="success"),
+        _doc(ordinal=1, status="failed", error_type="ValueError", error_code="processing_error"),
+    ])
+    items = diagnostics.items_from_summary(summary)
+    assert items[1]["error_type"] == "ValueError"
+    assert set(items[0]) <= {"ordinal", "status", "error_type", "error_code", "duration_ms"}
+
+
+def test_build_payload_counts_and_no_pii_leak():
+    # On INJECTE de la PII via des clés interdites + un faux message d'erreur :
+    raw_docs = [
+        {"ordinal": 0, "status": "success", "duration_ms": 5,
+         "filename": "LETTRE Dupont 1980.pdf", "path": "/home/dom/secret.pdf"},
+        {"ordinal": 1, "status": "failed", "error_type": "ValueError",
+         "error_code": "processing_error", "error_message": "patient Dupont Jean"},
+    ]
+    payload = diagnostics.build_diagnostics_payload(
+        run_id="r" * 16, app_name="gui_v6", app_version="6.0.0-g1",
+        license_ref="LIC-1", machine_id="m" * 12, duration_ms=999, items=raw_docs,
+    )
+    assert payload["document_count"] == 2
+    assert payload["succeeded_count"] == 1 and payload["failed_count"] == 1
+    blob = json.dumps(payload).lower()
+    for forbidden in ("filename", "path", "secret", "dupont", "lettre", "error_message", "patient"):
+        assert forbidden not in blob, f"fuite RGPD : {forbidden}"
+    for item in payload["items"]:
+        assert set(item) <= {"ordinal", "status", "error_type", "error_code", "duration_ms"}
+
+
+class _FakeResp:
+    def __init__(self, status_code):
+        self.status_code = status_code
+
+
+class _FakeSession:
+    def __init__(self, status_code=200, raise_exc=None):
+        self.status_code = status_code
+        self.raise_exc = raise_exc
+        self.calls = []
+
+    def post(self, url, json=None, timeout=None):
+        self.calls.append((url, json, timeout))
+        if self.raise_exc:
+            raise self.raise_exc
+        return _FakeResp(self.status_code)
+
+
+def test_client_report_ok_on_2xx():
+    sess = _FakeSession(status_code=200)
+    client = diagnostics.DiagnosticsClient("https://app.aivanov.eu/", session=sess)
+    assert client.report({"run_id": "r"}) is True
+    assert sess.calls[0][0] == "https://app.aivanov.eu/api/v1/diagnostics/report"
+
+
+def test_client_report_false_on_network_error_without_raising():
+    sess = _FakeSession(raise_exc=RuntimeError("no network"))
+    client = diagnostics.DiagnosticsClient("https://app.aivanov.eu", session=sess)
+    assert client.report({"run_id": "r"}) is False  # ne lève pas
+
+
+def test_report_run_diagnostics_no_send_without_license(tmp_path):
+    sess = _FakeSession()
+    ok = diagnostics.report_run_diagnostics(
+        SimpleNamespace(documents=[]), base_url="https://app.aivanov.eu",
+        license_ref=None, machine_id="m" * 12, session=sess,
+        spool_path=tmp_path / "spool.jsonl",
+    )
+    assert ok is False and sess.calls == []
+
+
+def test_report_run_diagnostics_network_down_spools(tmp_path):
+    sess = _FakeSession(raise_exc=RuntimeError("down"))
+    spool = tmp_path / "spool.jsonl"
+    summary = SimpleNamespace(documents=[_doc(ordinal=0, status="failed",
+                                              error_type="ValueError", error_code="processing_error")])
+    ok = diagnostics.report_run_diagnostics(
+        summary, base_url="https://app.aivanov.eu", license_ref="LIC-1",
+        machine_id="m" * 12, session=sess, spool_path=spool,
+    )
+    assert ok is False and spool.exists()
+    line = json.loads(spool.read_text(encoding="utf-8").splitlines()[0])
+    assert line["failed_count"] == 1
+
+
+def test_flush_spool_sends_and_clears(tmp_path):
+    spool = tmp_path / "spool.jsonl"
+    diagnostics.spool_payload(spool, {"run_id": "r1"})
+    diagnostics.spool_payload(spool, {"run_id": "r2"})
+    sent = diagnostics.flush_spool(spool, diagnostics.DiagnosticsClient(
+        "https://app.aivanov.eu", session=_FakeSession(status_code=200)))
+    assert sent == 2 and not spool.exists()
+
+
+def test_tab_send_diagnostics_calls_reporter():
+    import threading
+    from gui_v6.tabs.tab_usage import UsageTab
+
+    tab = object.__new__(UsageTab)  # pas de Tk : on teste juste le helper
+    seen = {}
+    done = threading.Event()
+
+    def reporter(summary):
+        seen["summary"] = summary
+        done.set()
+
+    tab._diag_reporter = reporter
+    tab._send_diagnostics(SimpleNamespace(documents=[], failed=0))
+    assert done.wait(timeout=2.0)
+    assert seen["summary"] is not None
+
+
+def test_tab_send_diagnostics_noop_without_reporter():
+    from gui_v6.tabs.tab_usage import UsageTab
+
+    tab = object.__new__(UsageTab)
+    tab._diag_reporter = None
+    tab._send_diagnostics(SimpleNamespace(documents=[]))  # ne lève pas
--- a/tests/unit/test_gui_v6_ner_confirm.py
+++ b/tests/unit/test_gui_v6_ner_confirm.py
@@ -0,0 +1,31 @@
+"""Confirmation avant de désactiver le NER (regex-only) — outil médical.
+
+Pur : la décision est isolée dans ``confirm_ner_disable(asker)`` ; ``asker`` est
+injecté (pas de messagebox réel, pas de display).
+"""
+from __future__ import annotations
+
+from gui_v6.tabs.tab_config import NER_DISABLE_WARNING, confirm_ner_disable
+
+
+def test_confirm_true_when_user_accepts():
+    assert confirm_ner_disable(lambda: True) is True
+
+
+def test_confirm_false_when_user_declines():
+    assert confirm_ner_disable(lambda: False) is False
+
+
+def test_confirm_false_when_asker_raises():
+    def boom():
+        raise RuntimeError("Tk indisponible")
+    # Sens sûr : une erreur de dialogue ne désactive jamais le NER.
+    assert confirm_ner_disable(boom) is False
+
+
+def test_warning_text_is_explicit_for_medical_use():
+    txt = NER_DISABLE_WARNING.lower()
+    # L'avertissement DOIT nommer la dégradation : règles/regex + risque noms.
+    assert "règles" in txt or "regex" in txt
+    assert "nom" in txt
+    assert "recommand" in txt  # « fortement recommandé »
--- a/tests/unit/test_gui_v6_processing_runner.py
+++ b/tests/unit/test_gui_v6_processing_runner.py
@@ -197,6 +197,23 @@ def test_progress_callbacks(tmp_path):
    assert (2, 2) in events  # progression finale atteinte


+def test_run_fails_fast_when_output_not_writable(tmp_path, monkeypatch):
+    from gui_v6.processing_runner import ProcessingRunner, OutputNotWritableError
+    src = tmp_path / "in"
+    src.mkdir()
+    (src / "a.txt").write_text("x", encoding="utf-8")
+    out = tmp_path / "ro"
+    out.mkdir()
+
+    def boom(*a, **k):
+        raise PermissionError("read-only")
+
+    monkeypatch.setattr("gui_v6.processing_runner.Path.mkdir", boom)
+    runner = ProcessingRunner(process_fn=lambda d, o: {})
+    with pytest.raises(OutputNotWritableError):
+        runner.run(src, out)
+
+
 def test_no_double_run(tmp_path):
    _touch(tmp_path / "a.pdf")
    started = threading.Event()
@@ -244,3 +261,70 @@ def test_run_records_per_document_details(tmp_path):
        assert not hasattr(doc, "path")
        assert not hasattr(doc, "filename")
        assert not hasattr(doc, "name")
+
+
+# -- diagnostics d'erreur RGPD-safe (E2) -----------------------------------
+
+def test_failed_doc_carries_rgpd_safe_error_fields(tmp_path):
+    from gui_v6.processing_runner import ProcessingRunner
+
+    secret = "Dupont Jean 1980"  # simulacre de PII dans un message d'exception
+
+    def boom(_inp, _out):
+        raise ValueError(f"échec sur patient {secret}")
+
+    inp = tmp_path / "in"; inp.mkdir()
+    (inp / "a.pdf").write_bytes(b"%PDF-1.4\n")
+    out = tmp_path / "out"; out.mkdir()
+    runner = ProcessingRunner(process_fn=boom)
+    summary = runner.run(inp, out)
+
+    assert summary.failed == 1
+    doc = summary.documents[0]
+    assert doc.error_type == "ValueError"
+    assert doc.error_code in {"ner_unavailable", "quarantined", "no_output", "processing_error"}
+    blob = repr(vars(doc)).lower()
+    assert "dupont" not in blob and "patient" not in blob and secret.lower() not in blob
+
+
+def test_success_doc_has_no_error_fields(tmp_path):
+    from gui_v6.processing_runner import ProcessingRunner
+
+    def ok(_inp, out_dir):
+        # process_fn reçoit le DOSSIER de sortie : on y écrit un PDF livrable.
+        pdf = out_dir / "a.redacted_raster.pdf"
+        pdf.write_bytes(b"%PDF-1.4\n")
+        return {"status": "ok", "pdf_raster": str(pdf)}
+
+    inp = tmp_path / "in"; inp.mkdir()
+    (inp / "a.pdf").write_bytes(b"%PDF-1.4\n")
+    out = tmp_path / "out"; out.mkdir()
+    summary = ProcessingRunner(process_fn=ok).run(inp, out)
+    doc = summary.documents[0]
+    assert doc.status == "success"
+    assert doc.error_type is None and doc.error_code is None
+
+
+# -- classification d'erreur : une assertion par branche (mapping vérifié) -
+
+def test_classify_error_code_ner_unavailable():
+    from gui_v6.processing_runner import classify_error_code
+    from gui_v6.engine_bridge import EngineUnavailableError  # import the REAL class
+    # importing the real class means a future rename breaks this test (intended guard)
+    assert classify_error_code(EngineUnavailableError("modèle indispo")) == "ner_unavailable"
+
+
+def test_classify_error_code_quarantined():
+    from gui_v6.processing_runner import classify_error_code
+    assert classify_error_code(RuntimeError("Document mis en quarantaine : texte trop court")) == "quarantined"
+
+
+def test_classify_error_code_no_output():
+    from gui_v6.processing_runner import classify_error_code
+    assert classify_error_code(RuntimeError("Aucune sortie PDF anonymisée produite")) == "no_output"
+
+
+def test_classify_error_code_processing_error_default():
+    from gui_v6.processing_runner import classify_error_code, _ERROR_CODES
+    assert classify_error_code(ValueError("patient Dupont")) == "processing_error"
+    assert classify_error_code(ValueError("x")) in _ERROR_CODES
--- a/tests/unit/test_gui_v6_result_hint.py
+++ b/tests/unit/test_gui_v6_result_hint.py
@@ -0,0 +1,118 @@
+"""Message d'aide localisant les documents non livrés (P1-5) + ouverture dossier.
+
+Pur : pas de display. ``failure_hint`` formate un texte ; ``open_in_file_manager``
+dispatch vers la bonne commande OS (monkeypatchée).
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+import gui_v6.fsutil as fsutil
+from gui_v6.processing_runner import RunSummary
+from gui_v6.tabs.tab_usage import failure_hint
+
+
+def test_no_hint_when_all_ok():
+    s = RunSummary(total=3, succeeded=3, failed=0)
+    assert failure_hint(s, Path("/out")) is None
+
+
+def test_hint_when_failures_mentions_output_dir():
+    s = RunSummary(total=3, succeeded=2, failed=1)
+    hint = failure_hint(s, Path("/out/anonymise"))
+    assert hint is not None
+    assert "/out/anonymise" in hint
+    # Honnêteté : préciser que les échecs ne sont PAS anonymisés.
+    assert "pas" in hint.lower()
+
+
+def test_hint_when_stopped():
+    s = RunSummary(total=3, succeeded=1, failed=0, stopped=True)
+    assert failure_hint(s, Path("/out")) is not None
+
+
+def test_no_hint_without_output_dir():
+    s = RunSummary(total=1, succeeded=0, failed=1)
+    assert failure_hint(s, None) is None
+
+
+def test_open_in_file_manager_dispatches(monkeypatch):
+    calls = {}
+    monkeypatch.setattr(fsutil.sys, "platform", "linux")
+    monkeypatch.setattr(fsutil.subprocess, "Popen", lambda args, **k: calls.setdefault("args", args))
+    fsutil.open_in_file_manager(Path("/out"))
+    assert calls["args"][0] == "xdg-open"
+    assert calls["args"][1] == "/out"
+
+
+def test_no_claim_written_when_zero_succeeded():
+    """0 succès : ne pas prétendre qu'un dossier contient des documents écrits."""
+    s = RunSummary(total=2, succeeded=0, failed=2)
+    hint = failure_hint(s, Path("/out"))
+    assert hint is not None
+    assert "écrits dans" not in hint
+    assert "Aucun document" in hint
+
+
+def test_hint_with_path_when_some_succeeded():
+    """≥1 succès : localiser le dossier de sortie effectif."""
+    s = RunSummary(total=3, succeeded=2, failed=1)
+    hint = failure_hint(s, Path("/out"))
+    assert hint is not None
+    assert "/out" in hint
+    assert "écrits dans" in hint
+
+
+# -- garde anti-régression du bug Critical (empilement de widgets) -----------
+
+
+@pytest.fixture
+def usage_tab():
+    """``UsageTab`` headless (Xvfb) — skip propre si pas de display."""
+    pytest.importorskip("customtkinter")
+    try:
+        import customtkinter as ctk
+
+        from gui_v6.tabs.tab_usage import UsageTab
+
+        root = ctk.CTk()
+        root.withdraw()
+        tab = UsageTab(root)
+    except Exception as exc:  # pas de display Tk
+        pytest.skip(f"display Tk indisponible: {exc}")
+    try:
+        yield tab
+    finally:
+        try:
+            root.destroy()
+        except Exception:
+            pass
+
+
+def test_show_failure_hint_does_not_accumulate(usage_tab):
+    """Bug Critical : deux runs en échec ne doivent pas empiler de hints sous
+    ``_rsec`` (handle ``_hint_row`` détruit inconditionnellement)."""
+    usage_tab._last_output_dir = Path("/out")
+    summary = RunSummary(total=3, succeeded=2, failed=1)
+
+    usage_tab._show_failure_hint(summary)
+    count_after_first = len(usage_tab._rsec.winfo_children())
+
+    usage_tab._show_failure_hint(summary)
+    count_after_second = len(usage_tab._rsec.winfo_children())
+
+    assert count_after_second == count_after_first
+
+
+def test_show_failure_hint_clears_stale_hint(usage_tab):
+    """Un run en échec suivi d'un run nominal ne doit pas laisser de hint périmé."""
+    usage_tab._last_output_dir = Path("/out")
+    usage_tab._show_failure_hint(RunSummary(total=3, succeeded=2, failed=1))
+    with_hint = len(usage_tab._rsec.winfo_children())
+
+    usage_tab._show_failure_hint(RunSummary(total=3, succeeded=3, failed=0))
+    without_hint = len(usage_tab._rsec.winfo_children())
+
+    assert without_hint == with_hint - 1
--- a/tests/unit/test_gui_v6_version.py
+++ b/tests/unit/test_gui_v6_version.py
@@ -0,0 +1,35 @@
+"""Tests de la résolution de version GUI V6 (P1-7, Plan 3).
+
+La version release (schéma 2026.MM.JJ.HHMM) est générée au build Windows dans
+gui_v6/_build_version.py (non commité). En dev, repli sur la version par défaut.
+"""
+import sys
+import types
+
+from gui_v6.version import DEFAULT_VERSION, resolve_version
+
+
+def test_resolve_version_sans_module_build_retourne_defaut(monkeypatch):
+    monkeypatch.setitem(sys.modules, "gui_v6._build_version", None)
+    # sys.modules[name] = None => ImportError au `from ... import`
+    assert resolve_version() == DEFAULT_VERSION
+
+
+def test_resolve_version_avec_module_build_retourne_version_injectee(monkeypatch):
+    fake = types.ModuleType("gui_v6._build_version")
+    fake.BUILD_VERSION = "2026.07.02.1130"
+    monkeypatch.setitem(sys.modules, "gui_v6._build_version", fake)
+    assert resolve_version() == "2026.07.02.1130"
+
+
+def test_resolve_version_build_version_vide_retourne_defaut(monkeypatch):
+    fake = types.ModuleType("gui_v6._build_version")
+    fake.BUILD_VERSION = ""
+    monkeypatch.setitem(sys.modules, "gui_v6._build_version", fake)
+    assert resolve_version() == DEFAULT_VERSION
+
+
+def test_dunder_version_est_cable_sur_resolve_version():
+    import gui_v6
+    # En dev (pas de _build_version généré), __version__ == défaut.
+    assert gui_v6.__version__ == DEFAULT_VERSION
--- a/tests/unit/test_installer_iss_d8.py
+++ b/tests/unit/test_installer_iss_d8.py
@@ -0,0 +1,27 @@
+"""Anti-dérive D8 (Plan 3) : l'installeur GUI doit fermer l'app avant MAJ.
+
+AppMutex DOIT valoir gui_v6.single_instance.APP_MUTEX_NAME (P0-7) — le commentaire
+de single_instance.py:15 exige la synchro. CloseApplications ferme l'app qui
+verrouille l'EXE pendant l'upgrade en place (AppId fixe).
+"""
+from pathlib import Path
+
+from gui_v6.single_instance import APP_MUTEX_NAME
+
+ISS = Path(__file__).resolve().parents[2] / "installer" / "Anonymisation.iss"
+
+
+def test_appmutex_synchronise_avec_single_instance():
+    text = ISS.read_text(encoding="utf-8")
+    assert f"AppMutex={APP_MUTEX_NAME}" in text
+
+
+def test_closeapplications_actif():
+    text = ISS.read_text(encoding="utf-8")
+    assert "CloseApplications=yes" in text
+
+
+def test_appid_fixe_inchange():
+    # L'upgrade en place repose sur l'AppId stable — ne jamais le régénérer.
+    text = ISS.read_text(encoding="utf-8")
+    assert "AppId={{6D11E4F8-26D8-4CFB-9F19-5A81E0637F56}" in text
--- a/tests/unit/test_q1_quarantine.py
+++ b/tests/unit/test_q1_quarantine.py
@@ -182,6 +182,138 @@ class TestRescanQuarantine:
        assert mgr.has_full_quarantine("doc_leak")


+# === Tests F4 : patterns résiduels gated par catégorie désactivée ===
+
+class TestResidualPatternsGating:
+    """F-4 (P1-2) — `_build_residual_patterns(disabled)` : une catégorie
+    décochée ne doit pas déclencher la quarantaine résiduelle, ni directement,
+    ni via le pattern résiduel d'une autre catégorie (piège NIR ⇄ TEL)."""
+
+    def _labels(self, patterns):
+        return {label for _pat, label in patterns}
+
+    @staticmethod
+    def _residual_count(text, disabled):
+        """Reproduit EXACTEMENT le calcul du call-site (process_pdf) :
+        seul le scan TEL voit le texte pré-masqué ; EMAIL/IBAN/NIR voient
+        le texte ORIGINAL."""
+        from anonymizer_core_refactored_onnx import (
+            _build_residual_patterns,
+            _residual_premask_text,
+        )
+
+        patterns = _build_residual_patterns(disabled)
+        tel_text = _residual_premask_text(text, disabled)
+        total = 0
+        for pat, label in patterns:
+            scan = tel_text if label == "TEL" else text
+            total += len(pat.findall(scan))
+        return total
+
+    def test_default_set_includes_all_labels(self) -> None:
+        """Aucune catégorie désactivée → NIR, EMAIL, IBAN, TEL tous présents."""
+        from anonymizer_core_refactored_onnx import _build_residual_patterns
+
+        labels = self._labels(_build_residual_patterns(set()))
+        assert {"NIR", "EMAIL", "IBAN", "TEL"}.issubset(labels)
+
+    def test_nir_disabled_drops_nir_keeps_others(self) -> None:
+        """NIR décoché → NIR absent, EMAIL/IBAN toujours présents."""
+        from anonymizer_core_refactored_onnx import _build_residual_patterns
+
+        labels = self._labels(_build_residual_patterns({"NIR"}))
+        assert "NIR" not in labels
+        assert "EMAIL" in labels
+        assert "IBAN" in labels
+
+    def test_tel_disabled_drops_tel(self) -> None:
+        """TEL décoché → TEL absent."""
+        from anonymizer_core_refactored_onnx import _build_residual_patterns
+
+        labels = self._labels(_build_residual_patterns({"TEL"}))
+        assert "TEL" not in labels
+
+    def test_nir_disabled_tel_does_not_match_nir_in_clear(self) -> None:
+        """Piège F-4 : NIR décoché laissé en clair → le pré-masquage SCOPÉ-TEL
+        empêche le pattern TEL de matcher le bloc central de chiffres du NIR.
+        Le NIR-pattern est retiré du set et EMAIL/IBAN ne matchent pas des
+        chiffres nus → décompte résiduel global == 0 pour ce NIR en clair."""
+        from anonymizer_core_refactored_onnx import (
+            _build_residual_patterns,
+            _residual_premask_text,
+        )
+
+        nir_en_clair = "1 85 05 74 123 456 78"
+        disabled = {"NIR"}
+
+        # Le pattern TEL appliqué au texte pré-masqué → 0 match.
+        patterns = _build_residual_patterns(disabled)
+        tel_pat = next(pat for pat, label in patterns if label == "TEL")
+        premasked = _residual_premask_text(nir_en_clair, disabled)
+        assert tel_pat.findall(premasked) == []
+
+        # Décompte résiduel global (logique call-site, TEL-scopé) == 0.
+        total = self._residual_count(nir_en_clair, disabled)
+        assert total == 0, (
+            f"NIR décoché ne doit pas déclencher la quarantaine, "
+            f"or {total} match(s) résiduel(s) sur {nir_en_clair!r}"
+        )
+
+    def test_nir_disabled_clear_iban_still_matches(self) -> None:
+        """Fix 1 (régression) : le pré-masquage NIR est SCOPÉ au seul scan TEL.
+        Un IBAN en clair, avec NIR décoché, DOIT toujours déclencher le filet
+        IBAN résiduel — le pré-masquage ne doit PAS effacer ses groupes de
+        chiffres (sinon le backstop IBAN, toujours actif, serait affaibli)."""
+        from anonymizer_core_refactored_onnx import _build_residual_patterns
+
+        iban_clair = "FR76 3000 1007 9412 3456 7890 185"
+        disabled = {"NIR"}
+
+        # Le pattern IBAN (scanné sur le texte ORIGINAL) matche toujours.
+        patterns = _build_residual_patterns(disabled)
+        iban_pat = next(pat for pat, label in patterns if label == "IBAN")
+        assert iban_pat.findall(iban_clair), "le filet IBAN doit rester actif"
+
+        # Décompte résiduel global (logique call-site) ≥ 1.
+        total = self._residual_count(iban_clair, disabled)
+        assert total >= 1, (
+            f"IBAN en clair doit déclencher la quarantaine même NIR décoché, "
+            f"or {total} match(s)"
+        )
+
+    def test_residual_threshold_is_strict_zero_regardless_of_disabled(self) -> None:
+        """Fix 2 (régression) : le seuil résiduel reste STRICT (0)
+        inconditionnellement. Un EMAIL en clair → 1 résidu, et 1 > 0 ⇒
+        quarantaine, même avec des catégories décochées (pas de relâchement
+        à 1 qui laisserait passer une fuite EMAIL/IBAN)."""
+        from anonymizer_core_refactored_onnx import SEUIL_RESCAN_RESIDUEL
+
+        assert SEUIL_RESCAN_RESIDUEL == 0
+
+        email_clair = "a@b.fr"
+        # Une catégorie est décochée mais le seuil effectif reste 0.
+        for disabled in (set(), {"NIR"}, {"NIR", "TEL"}):
+            total = self._residual_count(email_clair, disabled)
+            assert total == 1, (disabled, total)
+            # 1 résidu > seuil strict (0) ⇒ quarantaine déclenchée.
+            assert total > SEUIL_RESCAN_RESIDUEL
+
+    def test_nir_enabled_tel_behavior_unchanged(self) -> None:
+        """Non-régression : NIR activé → le pré-masquage est l'identité et
+        un vrai téléphone est toujours détecté par le pattern TEL."""
+        from anonymizer_core_refactored_onnx import (
+            _build_residual_patterns,
+            _residual_premask_text,
+        )
+
+        tel = "06 12 34 56 78"
+        patterns = _build_residual_patterns(set())
+        text = _residual_premask_text(tel, set())
+        assert text == tel  # identité quand rien n'est désactivé
+        tel_pat = next(pat for pat, label in patterns if label == "TEL")
+        assert tel_pat.findall(tel), "un vrai téléphone doit rester détecté"
+
+
 # === Tests A : INDEX.md et errors.log ===========================

 class TestQuarantineArtifacts:
Author	SHA1	Message	Date
Domi31tls	d324ada310	test(core): verrouiller le fallback edsnlp sur drugs.json corrompu (revue qualité) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-03 09:42:15 +02:00
Domi31tls	6a992d87de	fix(core): charger gazetteer médicaments edsnlp depuis data/ (torch-free) + log si absent Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-03 09:36:08 +02:00
Domi31tls	b196d00813	docs(build): réserves revue Qwen Plan 3 — MAJ app gelée (D8), précondition tray, note RGPD identifiants indirects	2026-07-03 09:20:53 +02:00
Domi31tls	5dbad699bc	test(beta): référence détections sur 6 documents réels avant build torch-free (Plan 3) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-02 18:18:42 +02:00
Domi31tls	7dba4014c4	docs(build): torch-free + précache OnnxTR + version unifiée + runbook URL portail (P0-4/P1-8) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-02 18:13:01 +02:00
Domi31tls	2c48d95c1f	build(installer): AppMutex + CloseApplications pour MAJ en place (D8) Synchronise l'installeur GUI avec gui_v6/single_instance.py:APP_MUTEX_NAME afin que Inno Setup ferme l'application avant de remplacer l'EXE lors d'une mise à jour en place (AppId fixe). Test anti-dérive dynamique inclus. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-02 18:10:20 +02:00
Domi31tls	f9b6f21923	build: purge torch venv GUI V6 + précache OnnxTR + version release unifiée (P0-3/P0-4/P1-7) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-02 11:25:47 +02:00
Domi31tls	e4bc9166be	test(build): échec bruyant si bloc hiddenimports introuvable (revue Task 2) - _hiddenimport_strings assert désormais si le bloc hiddenimports=[...] est absent (renommage/refonte de spec) au lieu de retourner [] silencieusement, ce qui faisait passer le test à vide. - Docstring corrigée : la regex s'arrête au PREMIER `]` où qu'il soit (pas « ligne seule ») — limitation réelle documentée. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-02 11:23:51 +02:00
Domi31tls	65c97a39b3	build: specs GUI V6 + CLI torch-free — retrait optimum, excludes explicites (P0-3) Suppression des 5 hiddenimports optimum* dans les deux specs V6/CLI. Ajout de EXCLUDED_TORCH_STACK + excludes=EXCLUDED_TORCH_STACK dans Analysis() pour éviter que PyInstaller embarque torch (~+2 Go) via optimum à l'analyse statique. Spec GUI V5 legacy inchangée (garde optimum légitimement). Test anti-dérive ajouté (5 cas). Correctif import pytest inutilisé (version.py). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-02 11:11:07 +02:00
Domi31tls	5f05ba0fb8	feat(build): version release résolue au build avec repli dev (P1-7) Crée gui_v6/version.py (DEFAULT_VERSION + resolve_version()) qui tente d'importer gui_v6._build_version (généré au build Windows, non commité). Câble gui_v6.__version__ sur resolve_version(). Ajoute gui_v6/_build_version.py au .gitignore et aux hiddenimports du spec PyInstaller. 4 tests TDD. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-02 11:02:57 +02:00
Domi31tls	8f9107a27f	feat(gui): câblage upload diagnostics en fin de run (E3) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-30 10:44:02 +02:00
Domi31tls	8eb8cf9999	feat(gui): client diagnostics non bloquant + spool best-effort (E3) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-30 10:39:25 +02:00
Domi31tls	4b7a31b9df	feat(gui): module diagnostics — payload liste-blanche RGPD (E2) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-30 10:36:16 +02:00
Domi31tls	4412512d4b	test(gui): vérifier chaque branche de classify_error_code + anti-dérive (E2) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-30 10:34:11 +02:00
Domi31tls	952a1c6ca0	feat(gui): DocResult porte type+catégorie d'erreur RGPD-safe (E2) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-30 10:28:42 +02:00
Domi31tls	675e328d8c	docs(plan): Plan 1c honnêteté UI (P1-4/NER/P1-5/P1-3/P1-1/P1-6/P1-11) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-29 19:42:16 +02:00
Domi31tls	4813f9439e	fix(core): corriger la provenance OCR de l'audit (docTR → OnnxTR, P1-11) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-29 19:36:58 +02:00
Domi31tls	ee1f86d55e	feat(gui): échec amont clair si dossier de sortie non inscriptible (P1-6) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-29 19:33:16 +02:00
Domi31tls	3a981eb15a	feat(gui): dropzone cliquable + libellé honnête (P1-1, DnD natif différé) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-29 19:29:12 +02:00
Domi31tls	d3189d5bb7	feat(gui): recâbler import/export de configuration par email (P1-3) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-29 19:27:33 +02:00
Domi31tls	1d65d42430	feat(gui): localiser les documents livrés + bouton ouvrir le dossier (P1-5) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-29 19:15:28 +02:00
Domi31tls	416b347d7f	feat(gui): confirmation explicite avant anonymisation regex-only (NER off) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-29 19:07:38 +02:00
Domi31tls	880a75873d	feat(gui): charger le dictionnaires.yml externe éditable en frozen (P1-4) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-29 19:00:49 +02:00
Domi31tls	c1c3565a0b	feat(gui): labels honnêtes — toggle « Téléphones » (e-mails non-toggleables) + hint Adresses sans ville (1c) Décision Dom 2026-06-29 (honnêteté UI) : - « Téléphones / e-mails » → « Téléphones » : EMAIL reste toujours masqué (non-toggleable), le label ne le promet plus. - hint « Adresses / CP » : « Voie, ville, code » → « Voie + code postal » : VILLE reste toujours masquée (décision 1b), le hint ne la promet plus. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-29 10:42:58 +02:00
Domi31tls	4357a58d7d	fix(core): exempter les hits forcés (overrides) du filtre catégorie — anti-fuite PDF (P1-2/T1) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-27 11:38:19 +02:00
Domi31tls	5663966938	docs(coord): verdict Qwen GO — re-revue post-impl Tasks 1-4 gating catégories §FAX: aucun autre type non-toggleable dépend d'une passe gatée. §Divergence: accord seuil 0 strict + premask scopé (retire suggestion adaptatif). §Task 3b: report acceptable pour beta (fail-closed). 1 trouble mineur T1: override user-defined nommé avec catégorie toggleable.	2026-06-27 11:27:24 +02:00
Domi31tls	bf832e12f0	feat(gui): câbler les 7 toggles catégories au moteur (P1-2) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-26 11:33:13 +02:00
Domi31tls	daec1f53bd	feat(core): garde-fou adresse burn + doc chemins conservateurs (P1-2/F-3) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-26 11:13:42 +02:00
Domi31tls	a02bca516d	feat(core): gates texte par catégorie sur toutes les passes (P1-2/F-2/F-5) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-26 11:03:04 +02:00
Domi31tls	dd392c4a50	docs(beta): plan 1b — Task 2 seuil résiduel strict 0 + premask scopé TEL (revue qualité) + Task 3 span-aware Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-26 10:23:40 +02:00
Domi31tls	2a3aab117d	feat(core): coordination quarantaine résiduelle NIR/TEL décochés (P1-2/F-4) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-26 10:21:27 +02:00
Domi31tls	b15d0da141	feat(core): _category_of dérivé (anti-dérive) + filtre audit Tier 1 (P1-2/F-1) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-26 10:04:03 +02:00
Domi31tls	c93dc34a70	docs(beta): plan 1b — décision Dom CODE_POSTAL suit le toggle Adresses (catégorie ADRESSE) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-26 09:50:07 +02:00
Domi31tls	c77082409d	docs(beta): plan 1b v3 — re-revue Qwen GO (boucle adversariale 2/2) + 3 correctifs Re-revue Qwen de l'approche dérivation = GO (dérivation jugée supérieure à la table figée). Vérif exhaustive maps : 7 VLM + 7 EDS + 8 regex + _GLOBAL dynamique = 22+ kinds couverts. Mon reverse-map VLM + fallback EDS confirmés sûrs (pas de fuite croisée). 3 correctifs intégrés : (A) site manquant RE_TRACKARE_IAO_MULTILINE_VALUE l.3102 (NOM Trackare) → Task 3 ; (B) doc convention admin_rules (kind=clé placeholder, branche 3) ; (C) seuil quarantaine adaptatif 0→1 si catégories décochées (anti fragment TEL). Caveat UX CP documenté. Convergence Claude+Qwen. Exécution = GO Dom après relecture. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-25 23:02:44 +02:00
Domi31tls	c7c3a86910	docs(coord): re-revue Qwen Plan 1b v2 — GO dérivation + 3 corrections mineures A: RE_TRACKARE_IAO_MULTILINE_VALUE site manquant Task 3, B: documenter convention admin_rules kind=placeholder, C: suggestion seuil adaptatif quarantaine	2026-06-25 23:00:56 +02:00
Domi31tls	ade1743bee	docs(coord): verdict Qwen GO-AVEC-RÉSERVES — revue adversariale Plan 1b gating catégories 5 findings: F-1 CRITIQUE (_CATEGORY_OF manque 15 kinds VLM/EDS/_GLOBAL), F-2 HAUT (24+ sites texte manquants), F-3 HAUT (Tier 1 OK, 3 gaps PDF), F-4 HAUT (quarantaine NIR/TEL décochés), F-5 MODÉRÉ (fuite croisée NER)	2026-06-25 22:46:44 +02:00