Dom/anonymisation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(perf): apply MVP threading hotfix

Browse Source 
Configure numerical library and torch threading for H1, keep raster threading/timing instrumentation, remove CONCERTATION from forced masks after real PDF FP testing, and record coordination archive state.
This commit is contained in:
Domi31tls
2026-06-08 10:41:15 +02:00
parent eb6e030183
commit c40441d03a
68 changed files with 2075 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files

464
docs/coordination/inbox/for-dom/2026-05-29_claude_pseudocode-Q1-quarantaine.md
View File

@@ -1,464 +0,0 @@
---
from: claude
to: dom
date: 2026-05-29T08:50:00+02:00
topic: pseudocode-Q1-quarantaine
status: open
references:
- decision: decisions/2026-05-28_dom_mvp-livraison-mardi.md
- decision: decisions/2026-05-28_dom_no-ui-changes.md
- file: anonymizer_core_refactored_onnx.py
- tests: tests/unit/test_q1_quarantine.py
priority: blocker
---
# Pseudo-code Q-1 — Quarantaine différentielle (Plan B Claude)
## Contexte
Qwen muet depuis 14h (probable interruption en plein output). Plan B activé : Claude rédige le pseudo-code. Tu codes vendredi.
**Périmètre :** sécuriser les chemins critiques de rédaction PDF + ajouter B-1 (métadonnées) et B-3 (pré-flight) dans le même patch, **sans toucher à la GUI** (D-10).
**Principe fondateur :** un document n'est livré « anonymisé » que si **toutes** les étapes critiques ont réussi. Sinon → quarantaine différentielle (texte si OK, PDF en quarantaine si rédaction rate, doc entier en quarantaine si pré-flight ou rescan critique).
---
## 1. Inventaire des `except Exception: pass` à modifier
Sur 40 `except Exception` dans `anonymizer_core_refactored_onnx.py`, **13 sont critiques** pour Q-1. Les autres (imports optionnels, fallbacks de police, etc.) restent en l'état.
Légende action :
- **L** = log seulement (dégradation acceptable, fallback existe)
- **Q-PDF** = log + flag quarantaine du PDF (texte sort, PDF en quarantaine)
- **Q-DOC** = log + quarantaine doc entier (texte vide, rescan résiduel critique)
| # | Fichier:ligne | Fonction | Contexte | Action |
|---|---|---|---|---|
| 1 | `anonymizer_core_refactored_onnx.py:1118` | `extract_text_with_fallback_ocr` | extraction tables PyMuPDF | **L** (info, tables fallback) |
| 2 | `:1128` | `extract_text_with_fallback_ocr` | extraction layout-aware PyMuPDF | **L** (warning) + tracker `extraction_passes_failed` |
| 3 | `:1139` | `extract_text_with_fallback_ocr` | extraction pdfplumber | **L** (warning) + tracker |
| 4 | `:1156` | `extract_text_with_fallback_ocr` | extraction pdfminer | **L** (warning) + tracker |
| 5 | `:1225` | `_compile_user_regex` | regex utilisateur YAML invalide | **L** (warning) + add to `errors.log` (Q-4 sandboxing à v11.5) |
| 6 | `:1242` | `force_mask_regex` compile | idem | **L** (warning) |
| 7 | **`:3938`** | **`redact_pdf_vector`** | **`page.apply_redactions()` échoue** | **Q-PDF** (CRITIQUE) |
| 8 | `:3984` | `redact_pdf_raster` | pyzbar codes-barres | **L** (debug, optionnel) |
| 9 | `:3991` | `redact_pdf_raster` | police DejaVu fallback | **L** (debug) |
| 10 | `:4137` | `process_pdf` | extraction image rects par page | **L** (debug) |
| 11 | `:4202` | `process_pdf` | VLM Ollama analyze_page | **L** (warning, VLM optionnel) |
| 12 | `:4276` | `process_pdf` | `_apply_vlm_on_scanned_pdf` | **L** (warning, dégradation gracieuse) |
| 13 | **`:4655`** | **`process_pdf`** | **`redact_pdf_vector()` orchestration** | **Q-PDF** (CRITIQUE) |
**Bonus à ajouter (pas un `except: pass` existant) :**
- Après `final_text = selective_rescan(final_text, cfg=cfg)` ligne 4291 → ajouter un **rescan_check** qui compte les PII résiduelles. Si > seuil → **Q-DOC**.
- Avant tout traitement, **B-3 pré-flight** : si `sum(len(p) for p in pages_text) < SEUIL_TEXTE_MINI` → **Q-DOC** direct.
---
## 2. Nouvelle API à introduire
### 2.1 Dataclass `QuarantineEntry`
Dans un nouveau module `quarantine.py` (collocated avec le core) :
```python
@dataclass
class QuarantineEntry:
doc_name: str # nom de base sans extension
reason: str # code court (preflight_text_too_short, pdf_redaction_failed, rescan_residual_pii, regex_user_invalid)
detail: str # message libre
timestamp: str # ISO 8601
flags: list[str] # peut contenir plusieurs raisons cumulées
severity: Literal["partial", "full"]
# partial = seul le PDF en quarantaine (texte OK)
# full = doc entier en quarantaine
stacktrace: Optional[str] # si exception, le tb.format_exc()
extracted_chars: int # nb caractères extraits (utile pour preflight)
```
### 2.2 Classe `QuarantineManager` (1 instance par batch)
```python
class QuarantineManager:
def __init__(self, output_dir: Path):
self.output_dir = output_dir
self.quarantine_dir = output_dir / "quarantaine"
self.entries: list[QuarantineEntry] = []
self._errors_log_path = output_dir / "errors.log"
def flag(self, doc_name, reason, detail, severity, *, exc=None, extracted_chars=0):
# Crée l'entrée + écrit .reason.txt + append errors.log
...
def has_full_quarantine(self, doc_name) -> bool:
# Le doc est en quarantaine totale (pas de sortie attendue)
...
def finalize(self):
# Écrit quarantaine/INDEX.md à la fin du batch
...
```
### 2.3 Helper module-level
```python
SEUIL_TEXTE_MINI = 50 # caractères — sous ce seuil = OCR raté ou doc vide
SEUIL_RESCAN_RESIDUEL = 3 # nb de matches regex post-rescan acceptables (0 idéal)
```
---
## 3. Structure dossier sortie
```
<output_dir>/
├── errors.log # cumulatif batch (B-2)
├── doc_ok.pseudonymise.txt
├── doc_ok.audit.jsonl # avec entrée type=metadata (B-1)
├── doc_ok.redacted.pdf # XMP metadata (B-1)
├── doc_ok.log # log par doc (B-2)
└── quarantaine/
├── INDEX.md # généré à la fin du batch
├── doc_partial.reason.txt # Q-PDF (partial)
├── doc_partial.pseudonymise.txt # texte OK, sort aussi en quarantaine/
│ # pour traçabilité (ou seulement dans output_dir ?)
├── doc_full.reason.txt # Q-DOC (full)
├── doc_full.original.pdf # copie source pour ré-essai
└── doc_full.partial.json # PII détectées avant l'échec
```
**Décision à prendre par toi :** pour les Q-PDF (partial), le texte `.pseudonymise.txt` sort dans `output_dir` (avec drapeau dans `INDEX.md`) **OU** dupliqué en `quarantaine/` pour faciliter le repérage. **Mon avis :** texte uniquement dans `output_dir`, INDEX.md liste le problème PDF — sinon doublon source de confusion.
---
## 4. Format des fichiers
### 4.1 `<docname>.reason.txt` (humain-lisible)
```
Document : doc_partial
Sévérité : partial (le PDF de sortie n'a pas pu être généré, le texte anonymisé est disponible)
Raison : pdf_redaction_failed
Détail : page.apply_redactions() raised RuntimeError: 'invalid encryption dictionary'
Horodatage : 2026-05-30T14:32:11+02:00
Version code : 0.11.0 (commit abc1234)
Caractères extraits : 4823
Suggestion opérateur : ré-essayer manuellement avec un PDF non chiffré, ou consulter le .pseudonymise.txt
--- stack trace ---
<traceback>
```
### 4.2 `quarantaine/INDEX.md` (généré en fin de batch)
```markdown
# Quarantaine batch 2026-05-30 14:25
Documents en quarantaine totale (texte non livré) : **2**
Documents en quarantaine partielle (texte OK, PDF non rédigé) : **3**
## Quarantaine totale
| Document | Raison | Action recommandée |
|---|---|---|
| doc_scan_raté | preflight_text_too_short | Vérifier OCR, ré-essayer avec docTR forcé |
| doc_grand_residuel | rescan_residual_pii | Inspection manuelle, fix regex ou whitelist |
## Quarantaine partielle (PDF uniquement)
| Document | Raison | Texte livré dans |
|---|---|---|
| doc_chiffré_1 | pdf_redaction_failed | <output_dir>/doc_chiffré_1.pseudonymise.txt |
| doc_chiffré_2 | pdf_redaction_failed | <output_dir>/doc_chiffré_2.pseudonymise.txt |
| doc_annot_corrompue | pdf_redaction_failed | <output_dir>/doc_annot_corrompue.pseudonymise.txt |
## Contexte batch
- Version : 0.11.0 (commit abc1234)
- Profil appliqué : standard_local
- Documents traités : 50
- Documents OK : 45
- Taux quarantaine : 10.0%
```
### 4.3 `<docname>.log` (B-2)
Format simple, append-only :
```
2026-05-30T14:25:32 [INFO] extraction.layout_aware: 12 pages, 4823 chars
2026-05-30T14:25:33 [INFO] ner.eds_pseudo: 14 entities (avg confidence 0.92)
2026-05-30T14:25:33 [INFO] ner.camembert: 12 entities
2026-05-30T14:25:34 [INFO] regex.pii: 3 hits (EMAIL, TEL, RPPS)
2026-05-30T14:25:34 [WARNING] redaction.vector: page.apply_redactions() failed: invalid encryption
2026-05-30T14:25:34 [INFO] quarantine.flag: pdf_redaction_failed (partial)
2026-05-30T14:25:34 [INFO] output.text: doc_chiffré_1.pseudonymise.txt written (4823 chars)
```
### 4.4 `errors.log` (cumulatif batch)
Une seule ligne par erreur, format JSON ligne pour parsing facile :
```
{"ts": "2026-05-30T14:25:34+02:00", "doc": "doc_chiffré_1", "level": "WARNING", "category": "redaction.vector", "msg": "page.apply_redactions() failed: invalid encryption", "severity": "partial"}
{"ts": "2026-05-30T14:26:12+02:00", "doc": "doc_scan_raté", "level": "ERROR", "category": "preflight.text_too_short", "msg": "Only 12 chars extracted (seuil=50)", "severity": "full"}
```
---
## 5. B-1 — Métadonnées sortie
### 5.1 Entrée `type=metadata` dans `.audit.jsonl`
À ajouter **en première ligne** de chaque `.audit.jsonl` :
```json
{
"type": "metadata",
"app_version": "0.11.0",
"build_date": "2026-05-31",
"commit_sha": "abc1234",
"processed_at": "2026-05-30T14:25:32+02:00",
"profile_applied": "standard_local",
"quarantine_flags": [],
"document_name": "doc_ok"
}
```
Source des champs :
- `app_version`, `build_date`, `commit_sha` → depuis `build_info.py` (déjà existant)
- `processed_at` → `datetime.now().isoformat()`
- `profile_applied` → param de `process_pdf`
- `quarantine_flags` → rempli par `QuarantineManager` en fin de traitement du doc
### 5.2 XMP metadata du PDF rédigé
Dans `redact_pdf_vector` et `redact_pdf_raster`, avant `doc.save(...)` :
```python
doc.set_metadata({
"creator": f"Pseudonymisation v{APP_VERSION}",
"producer": f"Pseudonymisation v{APP_VERSION} commit {COMMIT_SHA[:7]}",
"title": f"{original_filename} (anonymisé)",
"subject": f"Pseudonymisation médicale - profil {profile_name}",
"keywords": f"pseudonymisation; commit={COMMIT_SHA}; profile={profile_name}; ts={processed_at}",
# NE PAS mettre dans author : c'est le nom original peut contenir des données patient
})
```
**Garde-fou** : ne **JAMAIS** copier `author`, `subject`, `keywords` du PDF source dans la sortie — risque de fuite (nom patient en métadonnée).
---
## 6. B-3 — Pré-flight texte vide
Dans `process_pdf`, juste après `extract_text_with_fallback_ocr` :
```python
pages_text, tables_lines, used_ocr, ocr_word_map = extract_text_with_fallback_ocr(pdf_path)
extracted_chars = sum(len(p) for p in pages_text)
if extracted_chars < SEUIL_TEXTE_MINI:
quarantine_mgr.flag(
doc_name=pdf_path.stem,
reason="preflight_text_too_short",
detail=f"Only {extracted_chars} chars extracted from {len(pages_text)} pages (seuil={SEUIL_TEXTE_MINI})",
severity="full",
extracted_chars=extracted_chars,
)
# Copier le PDF original dans quarantaine/
shutil.copy(pdf_path, quarantine_mgr.quarantine_dir / f"{pdf_path.stem}.original.pdf")
return # Ne PAS sortir de fichier anonymisé pour ce doc
```
---
## 7. Diff conceptuel `process_pdf`
```python
def process_pdf(pdf_path, output_dir, quarantine_mgr, profile_name, ...) -> dict:
"""
Returns: {
"text": "...",
"audit": [...],
"pdf_vector": "path or None",
"pdf_raster": "path or None",
"quarantine_flags": [...],
}
"""
doc_log = DocLogger(output_dir / f"{pdf_path.stem}.log")
doc_log.info(f"start processing {pdf_path.name}")
# === 1. Extraction ===
try:
pages_text, tables_lines, used_ocr, ocr_word_map = extract_text_with_fallback_ocr(pdf_path)
except Exception as e:
# Aucune passe d'extraction n'a réussi
quarantine_mgr.flag(pdf_path.stem, "extraction_total_failure",
str(e), severity="full", exc=e)
doc_log.error(f"extraction failed: {e}")
shutil.copy(pdf_path, quarantine_mgr.quarantine_dir / f"{pdf_path.stem}.original.pdf")
return {"quarantine_flags": ["extraction_total_failure"]}
# === 2. B-3 Pré-flight texte vide ===
extracted_chars = sum(len(p) for p in pages_text)
doc_log.info(f"extracted {extracted_chars} chars from {len(pages_text)} pages, ocr={used_ocr}")
if extracted_chars < SEUIL_TEXTE_MINI:
quarantine_mgr.flag(pdf_path.stem, "preflight_text_too_short",
f"only {extracted_chars} chars (seuil={SEUIL_TEXTE_MINI})",
severity="full", extracted_chars=extracted_chars)
shutil.copy(pdf_path, quarantine_mgr.quarantine_dir / f"{pdf_path.stem}.original.pdf")
doc_log.warning(f"preflight FAILED: only {extracted_chars} chars")
return {"quarantine_flags": ["preflight_text_too_short"]}
# === 3. Anonymisation regex/NER (inchangé sur le fond) ===
anon = anonymise_document_regex(pages_text, tables_lines, cfg=cfg, ocr_word_map=ocr_word_map)
doc_log.info(f"anonymisation: {len(anon.audit)} hits")
# === 4. Rescan + check résiduel ===
final_text = selective_rescan(anon.text, cfg=cfg)
residual_count = _count_residual_pii(final_text)
doc_log.info(f"rescan: {residual_count} residual PII")
if residual_count > SEUIL_RESCAN_RESIDUEL:
quarantine_mgr.flag(pdf_path.stem, "rescan_residual_pii",
f"{residual_count} residual PII after rescan",
severity="full")
shutil.copy(pdf_path, quarantine_mgr.quarantine_dir / f"{pdf_path.stem}.original.pdf")
# Sauver les PII détectées pour analyse
(quarantine_mgr.quarantine_dir / f"{pdf_path.stem}.partial.json").write_text(
json.dumps([h.__dict__ for h in anon.audit], indent=2)
)
doc_log.error(f"rescan FAILED: {residual_count} residual PII")
return {"quarantine_flags": ["rescan_residual_pii"]}
# === 5. Sortie texte + audit (avec B-1) ===
text_path = output_dir / f"{pdf_path.stem}.pseudonymise.txt"
text_path.write_text(final_text)
audit_path = output_dir / f"{pdf_path.stem}.audit.jsonl"
_write_audit_with_metadata(audit_path, anon.audit, profile_name, quarantine_flags=[])
doc_log.info(f"text + audit written")
# === 6. Rédaction PDF (Q-PDF si échec) ===
pdf_vector_path = output_dir / f"{pdf_path.stem}.redacted.pdf"
flags = []
try:
redact_pdf_vector(pdf_path, anon.audit, pdf_vector_path,
ocr_word_map=ocr_word_map,
metadata={"profile": profile_name, "commit": COMMIT_SHA})
doc_log.info(f"PDF vector redaction OK")
except Exception as e:
quarantine_mgr.flag(pdf_path.stem, "pdf_redaction_failed",
str(e), severity="partial", exc=e)
flags.append("pdf_redaction_failed")
doc_log.warning(f"PDF vector redaction FAILED: {e}")
# Ne PAS lever — le texte est OK, on continue
return {
"text": str(text_path),
"audit": str(audit_path),
"pdf_vector": str(pdf_vector_path) if "pdf_redaction_failed" not in flags else None,
"quarantine_flags": flags,
}
```
**Changement crucial ligne 4655 :** au lieu de `try: redact_pdf_vector(...); outputs["pdf_vector"] = ... except: pass` silencieux, on a une vraie gestion d'erreur avec flag de quarantaine.
**Changement ligne 3938 :** dans `redact_pdf_vector` lui-même :
```python
try:
page.apply_redactions()
except Exception as e:
log.warning(f"apply_redactions failed on page {page.number}: {e}")
raise # Remonter pour que process_pdf flag la quarantaine
```
Au lieu de `pass` silencieux qui laissait passer le PDF sans rédaction.
---
## 8. Helper `_count_residual_pii`
À ajouter dans le core :
```python
def _count_residual_pii(text: str) -> int:
"""Compte les PII résiduelles après anonymisation/rescan.
Utilise les regex de leak_scanner.py existant."""
count = 0
count += len(RE_EMAIL.findall(text))
count += len(RE_TEL.findall(text))
count += len(RE_NIR.findall(text))
count += len(RE_IBAN.findall(text))
# Et les noms INSEE en MAJUSCULES (cas GRAND, MARTIN, etc.)
for token in re.findall(r"\b[A-ZÀ-Ÿ]{4,}\b", text):
if token.lower() in _INSEE_NOMS_FAMILLE:
count += 1
return count
```
---
## 9. Notes implémentation pour toi
### 9.1 Ordre de codage suggéré (vendredi)
1. **Matin :** créer `quarantine.py` (dataclass + manager) — 1h
2. **Matin :** modifier `redact_pdf_vector:3938` pour `raise` au lieu de `pass` — 30 min
3. **Matin :** modifier `process_pdf:4655` avec le pattern try/flag — 1h
4. **Matin :** ajouter B-3 pré-flight dans `process_pdf` — 30 min
5. **Après-midi :** ajouter rescan_check + `_count_residual_pii` — 1h
6. **Après-midi :** modifier `redact_pdf_vector` et `redact_pdf_raster` pour XMP metadata — 30 min
7. **Après-midi :** ajouter entrée `type=metadata` dans `.audit.jsonl` — 30 min
8. **Après-midi :** ajouter `DocLogger` simple (B-2) — 30 min
9. **Soir :** dégeler les tests `test_q1_quarantine.py` (retirer `xfail`) et faire passer — 2h
### 9.2 Ce qu'on NE TOUCHE PAS (D-10)
- ❌ `Pseudonymisation_Gui_V5.py`
- ❌ Pas de pop-up, pas de nouveau bouton
- ❌ Pas de modif titre fenêtre
### 9.3 Variables d'env / constantes ajoutées
Dans `config_defaults.py` (ou en haut du core) :
```python
SEUIL_TEXTE_MINI = 50 # B-3 préflight
SEUIL_RESCAN_RESIDUEL = 3 # Q-DOC sur rescan
QUARANTINE_DIR_NAME = "quarantaine"
```
À mettre éventuellement configurable via YAML dans `dictionnaires.yml` plus tard.
### 9.4 Tests qui changent de statut
Les 10 tests dans `tests/unit/test_q1_quarantine.py` (déjà créés par moi) :
- 9 tests en `@pytest.mark.xfail(strict=True)` → à dégeler 1 par 1 au fur et à mesure
- 1 test (`test_happy_path_no_quarantine_created_if_no_failure`) doit passer en premier
### 9.5 Points à valider avec moi avant code
- **Décision A** : pour Q-PDF (partial), le `.pseudonymise.txt` sort dans `output_dir` uniquement, ou aussi en copie dans `quarantaine/` ?
- Mon avis : `output_dir` uniquement, mentionné dans `INDEX.md`
- **Décision B** : si `redact_pdf_vector` rate, on essaie quand même `redact_pdf_raster` en fallback ?
- Mon avis : oui, ça augmente la robustesse — mais flag partial reste levé même si raster réussit
- **Décision C** : seuils `SEUIL_TEXTE_MINI=50` et `SEUIL_RESCAN_RESIDUEL=3` — à confirmer sur le corpus audit_30
- Mon avis : démarrer avec 50/3, ajuster après mesure réelle
Réponds-moi sur A/B/C avant de coder.
---
## 10. Risque résiduel après Q-1
Avec ce patch implémenté, le pire scénario devient :
- Le rescan + check résiduel passe (pas de PII détectable)
- Mais une PII non couverte par les regex/NER reste dans le doc
→ Le risque est ramené à ce qu'on **savait pas détecter** (problème d'algo), pas à des **bugs silencieux** (problème d'engineering). C'est l'amélioration RGPD attendue.
---
— Claude

572
docs/coordination/inbox/for-dom/2026-05-29_consolide_pseudocode-Q1-v2.md
View File

@@ -1,572 +0,0 @@
---
from: claude
to: dom
date: 2026-05-29T11:15:00+02:00
topic: pseudocode-Q1-v2-consolide
status: open
references:
- file: inbox/for-dom/2026-05-29_claude_pseudocode-Q1-quarantaine.md (v1 Claude)
- file: inbox/for-dom/2026-05-29_qwen_review-pseudocode-Q1.md (review Qwen)
- file: inbox/for-dom/2026-05-29_qwen_analyse-regression-grand.md (C-8 fix)
- file: anonymizer_core_refactored_onnx.py
- tests: tests/unit/test_q1_quarantine.py
priority: blocker
---
# Pseudo-code Q-1 v2 CONSOLIDÉ — version unique à coder
## Objet
Consolidation du pseudo-code Claude (v1) + review Qwen + vérification factuelle Claude. **Ce fichier est la version unique de référence pour le code.** Les 2 autres fichiers sont historiques.
---
## 1. Vérification factuelle sur l'inventaire des silences
### 1.1 `except: pass` STRICTS dans le core
Grep ciblé : `grep -B1 "^[[:space:]]*pass[[:space:]]*$" core | grep "except"` →
**6 cas uniquement** (pas ~20 comme estimé initialement) :
| # | Ligne | Fonction | Risque |
|---|---|---|---|
| 1 | `:1118` | extract_text — tables PyMuPDF | Tables manquantes → doc partiel mais texte principal OK |
| 2 | `:1128` | extract_text — layout-aware PyMuPDF | Fallback vers pdfplumber |
| 3 | `:1139` | extract_text — pdfplumber | Fallback vers pdfminer |
| 4 | `:1156` | extract_text — pdfminer | Fallback vers OCR docTR |
| 5 | **`:3938`** | **redact_pdf_vector → apply_redactions** | **PDF sort SANS rédaction** 🔴 |
| 6 | **`:4655`** | **process_pdf → redact_pdf_vector** | **Aucun PDF généré** 🔴 |
### 1.2 Précision sur la review Qwen
Qwen a proposé +5 cas manqués (A=4291 rescan, B=2725 stopwords, C=3857 search, D=4034 raster, E=1490 regex). **Vérification ligne par ligne : aucun de ces 5 n'est un `except: pass` strict.** Détail :
- L4291 : `final_text = selective_rescan(final_text, cfg=cfg)` — appel direct, pas dans try/except
- L2725 : `continue` dans un filtre de stopwords (légitime, lié au bug GRAND traité par C-8)
- L3857 : début de `def redact_pdf_vector(...)` — pas un except
- L4034 : `# Masquage total si FULL_PAGE_MASK` — pas un except
- L1490 : `context_before = line[...].lower()` — pas un except
→ **Ses ajouts ne sont pas retenus côté inventaire.** Ses autres recommandations (seuils, leak_scanner, B-1 clear, fallback raster, tests) sont valides et intégrées ci-dessous.
### 1.3 `except as e: pass` ou silences déguisés à traiter quand même
En plus des 6 `except: pass` purs, **7 chemins critiques** ont un `except as e:` sans logging utile ou avec dégradation silencieuse :
| # | Ligne | Contexte | Action |
|---|---|---|---|
| 7 | `:1225` | `_compile_user_regex` regex utilisateur invalide | **L** (warning + skip) |
| 8 | `:1242` | `force_mask_regex` compile | **L** (warning + skip) |
| 9 | `:3984` | `redact_pdf_raster` pyzbar codes-barres | **L** (debug, optionnel) |
| 10 | `:3991` | `redact_pdf_raster` font fallback | **L** (debug) |
| 11 | `:4137` | `process_pdf` extraction image rects | **L** (debug) |
| 12 | `:4202` | `process_pdf` VLM Ollama analyze_page | **L** (warning, optionnel) |
| 13 | `:4276` | `process_pdf` `_apply_vlm_on_scanned_pdf` | **L** (warning) |
---
## 2. Mapping action final (13 cas)
| Cas | Action | Comportement |
|---|---|---|
| 1-4 (extraction) | **L** + tracker `extraction_passes_failed` | Logger warning, fallback continue, comptabiliser pour rapport |
| 5 (3938 apply_redactions) | **`raise`** | Remonter exception pour que process_pdf flag Q-PDF |
| 6 (4655 redact_pdf_vector) | **Q-PDF** | Flag quarantaine partielle (texte sort) + tenter fallback raster (cf §4) |
| 7-8 (regex compile) | **L** | Warning utilisateur (regex YAML invalide) |
| 9-10 (pyzbar/font) | **L** (debug) | Dégradation acceptable |
| 11-13 (image/VLM) | **L** (warning) | Dégradation gracieuse VLM optionnel |
**Bonus à ajouter (pas un `except` existant) :**
- **B-3 Pré-flight** : si `extracted_chars < SEUIL_TEXTE_MINI` → **Q-DOC**
- **Rescan check** : si `_count_residual_pii(final_text) > SEUIL_RESCAN_RESIDUEL` → **Q-DOC**
---
## 3. Décisions tranchées A/B/C/D + nouveaux
| ID | Sujet | Décision finale | Source |
|---|---|---|---|
| A | Texte Q-PDF localisation | **`output_dir/` uniquement + copie en `quarantaine/` pour autoportance** | accord Qwen, refute Claude v1 |
| B | Fallback raster si vector rate | **Oui, flag `pdf_vector_fallback_to_raster` levé même si raster OK** | accord Claude+Qwen |
| C1 | `SEUIL_TEXTE_MINI` | **100** (pas 50) | argument Qwen accepté |
| C2 | `SEUIL_RESCAN_RESIDUEL` | **0** (tolérance zéro) | argument Qwen accepté |
| D | `_count_residual_pii` | **Réutiliser `evaluation/leak_scanner.py`** | argument Qwen accepté |
| E | B-1 metadata source PDF | **`doc.metadata.clear()` explicite + check assertion** | argument Qwen accepté |
| F | Garde-fou NER low confidence | **Reporté v11.5** — pas dans le scope 99% RGPD primaire MVP | décision Claude |
| G | Check OCR low quality | **Reporté v11.5** — complexité non justifiée pour MVP | décision Claude |
| H | Check tables vides | **Inclus** (1 ligne, coût nul) | accord |
---
## 4. Nouvelle API à introduire
### 4.1 Module `quarantine.py` (collocated avec core)
```python
# quarantine.py
from dataclasses import dataclass, field
from pathlib import Path
from typing import Optional, Literal
from datetime import datetime
import json
import shutil
import traceback
SEUIL_TEXTE_MINI = 100
SEUIL_RESCAN_RESIDUEL = 0
QUARANTINE_DIR_NAME = "quarantaine"
@dataclass
class QuarantineEntry:
doc_name: str
reason: str # code court (cf §5)
detail: str # message libre
timestamp: str
severity: Literal["partial", "full"]
flags: list[str] = field(default_factory=list)
stacktrace: Optional[str] = None
extracted_chars: int = 0
class QuarantineManager:
"""Une instance par batch. Centralise tous les flags + génère INDEX.md."""
def __init__(self, output_dir: Path, app_version: str, commit_sha: str, profile_name: str):
self.output_dir = output_dir
self.quarantine_dir = output_dir / QUARANTINE_DIR_NAME
self.app_version = app_version
self.commit_sha = commit_sha
self.profile_name = profile_name
self.entries: list[QuarantineEntry] = []
self._errors_log_path = output_dir / "errors.log"
def flag(self, doc_name: str, reason: str, detail: str,
severity: Literal["partial", "full"],
*, exc: Optional[Exception] = None,
extracted_chars: int = 0,
flags: Optional[list[str]] = None) -> QuarantineEntry:
"""Crée une entrée + écrit .reason.txt + append errors.log."""
self.quarantine_dir.mkdir(exist_ok=True)
entry = QuarantineEntry(
doc_name=doc_name,
reason=reason,
detail=detail,
timestamp=datetime.now().astimezone().isoformat(),
severity=severity,
flags=flags or [reason],
stacktrace=traceback.format_exc() if exc else None,
extracted_chars=extracted_chars,
)
self.entries.append(entry)
self._write_reason_txt(entry)
self._append_errors_log(entry)
return entry
def has_full_quarantine(self, doc_name: str) -> bool:
return any(e.doc_name == doc_name and e.severity == "full" for e in self.entries)
def finalize(self) -> None:
"""Écrit quarantaine/INDEX.md à la fin du batch."""
if not self.entries:
return
# ... génération INDEX.md cf §6
def _write_reason_txt(self, entry: QuarantineEntry) -> None:
... # cf §6
def _append_errors_log(self, entry: QuarantineEntry) -> None:
... # cf §6
```
### 4.2 Classe `DocLogger` (B-2 sans GUI)
```python
class DocLogger:
"""Logger fichier par document. Append-only. Pas de buffer."""
def __init__(self, log_path: Path):
self.log_path = log_path
def _write(self, level: str, msg: str) -> None:
ts = datetime.now().astimezone().isoformat()
with open(self.log_path, "a", encoding="utf-8") as f:
f.write(f"{ts} [{level}] {msg}\n")
def info(self, msg: str) -> None: self._write("INFO", msg)
def warning(self, msg: str) -> None: self._write("WARNING", msg)
def error(self, msg: str) -> None: self._write("ERROR", msg)
```
---
## 5. Codes de raison normalisés
| Code | Sévérité | Sens |
|---|---|---|
| `preflight_text_too_short` | full | B-3 — extracted_chars < 100 |
| `extraction_total_failure` | full | Toutes les passes d'extraction ont échoué |
| `rescan_residual_pii` | full | Rescan détecte ≥ 1 PII résiduelle |
| `pdf_redaction_failed` | partial | `redact_pdf_vector` rate (vector + raster fallback aussi) |
| `pdf_vector_fallback_to_raster` | partial | Vector raté, raster OK (qualité moindre) |
| `regex_user_invalid` | partial | Regex YAML utilisateur invalide skippée |
| `vlm_unavailable` | log only | VLM Ollama indisponible (acceptable) |
---
## 6. Format des fichiers de sortie
### 6.1 `quarantaine/<docname>.reason.txt`
```
Document : doc_partial
Sévérité : partial
Raison : pdf_redaction_failed
Détail : page.apply_redactions() raised RuntimeError: 'invalid encryption dictionary'
Horodatage : 2026-05-30T14:32:11+02:00
Version code : 0.11.0 (commit abc1234)
Profil appliqué: standard_local
Caractères extraits : 4823
Flags : pdf_redaction_failed, pdf_vector_fallback_to_raster
Suggestion : voir <output_dir>/<doc>.pseudonymise.txt pour le texte anonymisé;
le PDF d'origine peut nécessiter un déverrouillage.
--- stack trace ---
Traceback (most recent call last):
...
RuntimeError: invalid encryption dictionary
```
### 6.2 `quarantaine/INDEX.md`
Généré par `QuarantineManager.finalize()` :
```markdown
# Quarantaine — batch 2026-05-30 14:25
**Documents traités** : 50
**Quarantaine totale** : 2 (texte non livré)
**Quarantaine partielle** : 3 (texte OK, PDF en erreur)
**Taux** : 10.0%
## Quarantaine totale (full)
| Document | Raison | Caractères extraits | Action recommandée |
|---|---|---|---|
| doc_scan_raté | preflight_text_too_short | 12 | Vérifier OCR, ré-essayer avec docTR forcé |
| doc_residuel | rescan_residual_pii | 4520 | Inspection manuelle, fix regex/whitelist |
## Quarantaine partielle (partial)
| Document | Raison | Texte livré dans | Flags |
|---|---|---|---|
| doc_chiffré_1 | pdf_redaction_failed | <output_dir>/doc_chiffré_1.pseudonymise.txt | pdf_redaction_failed |
| doc_corrompu | pdf_vector_fallback_to_raster | <output_dir>/doc_corrompu.pseudonymise.txt + .redacted.pdf (raster) | pdf_vector_fallback_to_raster |
## Contexte batch
- Version : 0.11.0 (commit abc1234)
- Profil appliqué : standard_local
- Horodatage : 2026-05-30T14:25:00+02:00
```
### 6.3 `errors.log` — JSON-lines (B-2 cumulatif batch)
```jsonl
{"ts":"2026-05-30T14:25:34+02:00","doc":"doc_chiffré_1","level":"WARNING","category":"redaction.vector","msg":"apply_redactions failed: invalid encryption","severity":"partial"}
{"ts":"2026-05-30T14:26:12+02:00","doc":"doc_scan_raté","level":"ERROR","category":"preflight.text_too_short","msg":"Only 12 chars extracted","severity":"full"}
```
### 6.4 `<docname>.log` — humain (B-2 par doc)
```
2026-05-30T14:25:32+02:00 [INFO] extraction.layout_aware: 12 pages, 4823 chars
2026-05-30T14:25:33+02:00 [INFO] ner.eds_pseudo: 14 entities (avg conf 0.92)
2026-05-30T14:25:33+02:00 [INFO] ner.camembert: 12 entities
2026-05-30T14:25:34+02:00 [INFO] regex.pii: 3 hits (EMAIL, TEL, RPPS)
2026-05-30T14:25:34+02:00 [WARNING] redaction.vector: apply_redactions failed: invalid encryption
2026-05-30T14:25:34+02:00 [INFO] quarantine.flag: pdf_redaction_failed (partial)
2026-05-30T14:25:34+02:00 [INFO] output.text: doc_chiffré_1.pseudonymise.txt (4823 chars)
```
---
## 7. B-1 — Métadonnées sortie
### 7.1 `.audit.jsonl` — entrée `type=metadata` (1ère ligne)
```json
{"type":"metadata","app_version":"0.11.0","build_date":"2026-05-31","commit_sha":"abc1234","processed_at":"2026-05-30T14:25:32+02:00","profile_applied":"standard_local","document_name":"doc_ok","quarantine_flags":[]}
```
Champs source :
- `app_version`, `build_date`, `commit_sha` ← `build_info.py` (existant)
- `processed_at` ← `datetime.now().astimezone().isoformat()`
- `profile_applied` ← param `process_pdf`
- `quarantine_flags` ← `QuarantineManager` en fin de traitement
### 7.2 XMP métadonnées du PDF rédigé
**Dans `redact_pdf_vector` ET `redact_pdf_raster`, avant `doc.save(...)` :**
```python
# CRITIQUE — clear pour éviter fuite de l'auteur/titre du PDF source
doc.set_metadata({})
# Puis poser nos propres métadonnées
doc.set_metadata({
"creator": f"Pseudonymisation v{APP_VERSION}",
"producer": f"Pseudonymisation v{APP_VERSION} commit {COMMIT_SHA[:7]}",
"title": f"Document anonymisé", # PAS le nom original
"subject": f"Pseudonymisation médicale - profil {profile_name}",
"keywords": f"pseudonymisation; commit={COMMIT_SHA}; profile={profile_name}; ts={processed_at}",
"author": "", # vide explicite
"creationDate": "", # ne pas hériter
"modDate": "",
})
# Garde-fou — vérifier que rien ne reste de la source
final_meta = doc.metadata or {}
for key in ("author", "title"):
val = final_meta.get(key, "")
assert "Pseudonymisation" in val or val == "" or val == "Document anonymisé", \
f"PII leak suspectée dans XMP {key}: {val!r}"
```
---
## 8. B-3 Pré-flight texte vide
Dans `process_pdf`, juste après extraction :
```python
extracted_chars = sum(len(p) for p in pages_text)
doc_logger.info(f"extraction: {extracted_chars} chars, {len(pages_text)} pages, ocr={used_ocr}")
if extracted_chars < SEUIL_TEXTE_MINI:
quarantine_mgr.flag(
doc_name=pdf_path.stem,
reason="preflight_text_too_short",
detail=f"Only {extracted_chars} chars (seuil={SEUIL_TEXTE_MINI})",
severity="full",
extracted_chars=extracted_chars,
)
shutil.copy(pdf_path, quarantine_mgr.quarantine_dir / f"{pdf_path.stem}.original.pdf")
doc_logger.warning(f"preflight FAILED: {extracted_chars} < {SEUIL_TEXTE_MINI}")
return {"quarantine_flags": ["preflight_text_too_short"]}
```
---
## 9. `_count_residual_pii` — réutiliser leak_scanner
**Ne pas réinventer.** Le fichier `evaluation/leak_scanner.py` contient déjà toutes les regex (EMAIL, TEL, NIR, IBAN, FINESS, IPP, RPPS, dates, adresses) + détection noms INSEE.
```python
from evaluation.leak_scanner import (
RE_EMAIL, RE_TEL, RE_NIR, RE_IBAN,
RE_FINESS, RE_RPPS, RE_DATE_NAISSANCE,
detect_insee_names_in_text,
)
def _count_residual_pii(text: str) -> int:
"""Compte les PII résiduelles. Réutilise leak_scanner.py."""
count = 0
count += len(RE_EMAIL.findall(text))
count += len(RE_TEL.findall(text))
count += len(RE_NIR.findall(text))
count += len(RE_IBAN.findall(text))
count += len(RE_FINESS.findall(text))
count += len(RE_RPPS.findall(text))
count += len(RE_DATE_NAISSANCE.findall(text))
count += len(detect_insee_names_in_text(text, threshold="high"))
return count
```
*Note : si l'API exacte de leak_scanner diffère, adapter — l'idée est : zéro duplication.*
---
## 10. Diff conceptuel `process_pdf` (orchestration globale)
```python
def process_pdf(pdf_path, output_dir, quarantine_mgr, profile_name, ...) -> dict:
doc_log = DocLogger(output_dir / f"{pdf_path.stem}.log")
doc_log.info(f"start: {pdf_path.name}")
flags = []
# 1. Extraction (les except internes sont déjà log+continue)
try:
pages_text, tables_lines, used_ocr, ocr_word_map = \
extract_text_with_fallback_ocr(pdf_path)
except Exception as e:
quarantine_mgr.flag(pdf_path.stem, "extraction_total_failure",
str(e), "full", exc=e)
shutil.copy(pdf_path, quarantine_mgr.quarantine_dir / f"{pdf_path.stem}.original.pdf")
doc_log.error(f"extraction failed: {e}")
return {"quarantine_flags": ["extraction_total_failure"]}
# 2. B-3 Pré-flight
extracted_chars = sum(len(p) for p in pages_text)
if extracted_chars < SEUIL_TEXTE_MINI:
quarantine_mgr.flag(pdf_path.stem, "preflight_text_too_short",
f"{extracted_chars} chars", "full",
extracted_chars=extracted_chars)
shutil.copy(pdf_path, quarantine_mgr.quarantine_dir / f"{pdf_path.stem}.original.pdf")
return {"quarantine_flags": ["preflight_text_too_short"]}
# H. Check tables vides (info only)
if tables_lines and sum(sum(len(r) for r in t) for t in tables_lines) == 0:
doc_log.warning("tables extracted but empty")
# 3. Anonymisation (inchangé)
anon = anonymise_document_regex(pages_text, tables_lines, cfg=cfg,
ocr_word_map=ocr_word_map)
doc_log.info(f"anonymisation: {len(anon.audit)} hits")
# 4. Rescan + check résiduel (Q-DOC si rate)
final_text = selective_rescan(anon.text, cfg=cfg)
residual_count = _count_residual_pii(final_text)
doc_log.info(f"rescan: {residual_count} residual PII")
if residual_count > SEUIL_RESCAN_RESIDUEL: # = 0
quarantine_mgr.flag(pdf_path.stem, "rescan_residual_pii",
f"{residual_count} residual PII", "full")
shutil.copy(pdf_path, quarantine_mgr.quarantine_dir / f"{pdf_path.stem}.original.pdf")
(quarantine_mgr.quarantine_dir / f"{pdf_path.stem}.partial.json").write_text(
json.dumps([h.__dict__ for h in anon.audit], indent=2)
)
return {"quarantine_flags": ["rescan_residual_pii"]}
# 5. Sortie texte + audit (B-1 metadata)
text_path = output_dir / f"{pdf_path.stem}.pseudonymise.txt"
text_path.write_text(final_text)
audit_path = output_dir / f"{pdf_path.stem}.audit.jsonl"
_write_audit_with_metadata(audit_path, anon.audit, profile_name,
quarantine_flags=[])
doc_log.info("text + audit written")
# 6. Rédaction PDF vector (Q-PDF si rate) + fallback raster
pdf_vector_path = output_dir / f"{pdf_path.stem}.redacted.pdf"
pdf_vector_ok = False
try:
redact_pdf_vector(pdf_path, anon.audit, pdf_vector_path,
ocr_word_map=ocr_word_map,
profile_name=profile_name)
pdf_vector_ok = True
doc_log.info("PDF vector redaction OK")
except Exception as e:
flags.append("pdf_redaction_failed")
doc_log.warning(f"PDF vector failed: {e}")
# B — Fallback raster (Décision B)
try:
redact_pdf_raster(pdf_path, anon.audit, pdf_vector_path,
ocr_word_map=ocr_word_map,
profile_name=profile_name)
flags.append("pdf_vector_fallback_to_raster")
doc_log.info("PDF raster fallback OK")
except Exception as e2:
doc_log.error(f"PDF raster fallback also failed: {e2}")
quarantine_mgr.flag(pdf_path.stem, "pdf_redaction_failed",
str(e), "partial", exc=e, flags=flags.copy())
# A — Copier le texte en quarantaine pour autoportance (Décision A finalisée)
shutil.copy(text_path, quarantine_mgr.quarantine_dir / text_path.name)
return {
"text": str(text_path),
"audit": str(audit_path),
"pdf_vector": str(pdf_vector_path) if pdf_vector_ok or "pdf_vector_fallback_to_raster" in flags else None,
"quarantine_flags": flags,
}
```
**Changement clé ligne 3938** dans `redact_pdf_vector` :
```python
# AVANT
try:
page.apply_redactions()
except Exception:
pass # silence catastrophique
# APRÈS
try:
page.apply_redactions()
except Exception as e:
log.warning(f"apply_redactions failed on page {page.number}: {e}")
raise # remonte pour Q-PDF flag
```
---
## 11. Tests à écrire
### 11.1 Existants à dégeler (`tests/unit/test_q1_quarantine.py`, déjà créé par Claude)
- 10 tests `xfail strict` → retirer `xfail` au fur et à mesure
### 11.2 Nouveaux tests (Qwen) à ajouter dans le même fichier
```python
# 1. test_quarantine_index_md_format — INDEX.md généré au bon format
# 2. test_errors_log_json_lines — chaque ligne d'errors.log = JSON valide
# 3. test_doc_log_per_document — chaque doc a son .log
# 4. test_xmp_metadata_no_source_leak — métadonnées source PDF non copiées
# 5. test_preflight_text_too_short_boundary — tester à 99, 100, 101 chars
# 6. test_pdf_vector_fallback_to_raster_flag — flag levé même si raster OK
# 7. test_residual_pii_zero_tolerance — seuil 0 → flag même 1 PII résiduelle
```
### 11.3 Test C-8 (régression GRAND, séparé)
```python
# tests/unit/test_c8_grand_regression.py
# - test_grand_insee_name_is_masked
# - test_grande_medical_not_masked
# - test_stopword_no_longer_blocks_insee_names
```
---
## 12. Ordre de codage révisé (vendredi)
| Étape | Effort | Livrable |
|---|---|---|
| 1. Créer `quarantine.py` (dataclass + manager + DocLogger) | 1h30 | Module testable isolément |
| 2. C-8 : retirer `"grand"` de `data/stopwords_manuels.txt:549` + 3 tests | 30 min | Régression GRAND fixée |
| 3. Patch `redact_pdf_vector:3938` (`raise` au lieu de `pass`) | 15 min | Pas de PDF silencieux non rédigé |
| 4. Patch `process_pdf:4655` (try/flag + fallback raster) | 1h30 | Q-PDF différentielle |
| 5. B-3 pré-flight dans `process_pdf` | 30 min | Q-DOC sur texte vide |
| 6. Rescan check + `_count_residual_pii` (réutiliser leak_scanner) | 1h | Q-DOC sur PII résiduelles |
| 7. B-1 metadata `.audit.jsonl` + XMP avec clear() | 1h | Traçabilité version+commit |
| 8. Dégeler les 17 tests Q-1 (10 + 7 ajouts) | 2h | Tests verts |
| 9. Run complet `evaluate_quality.py` audit_30 — vérifier 99.8 → 100 | 30 min | Validation MVP |
**Total : ~9h** — gros mais faisable sur le vendredi avec début matin.
---
## 13. Ce qu'on NE TOUCHE PAS (D-10)
- ❌ `Pseudonymisation_Gui_V5.py`
- ❌ Pop-up, boutons, titre fenêtre, status bar
- ❌ `manual_masking.py`, `pdf_mask_designer.py` (reportés v11.5)
- ❌ Audit admin_rules (reporté v11.5)
---
## 14. Constantes à ajouter
Dans `config_defaults.py` (ou en tête du core) :
```python
# Q-1 Quarantaine
SEUIL_TEXTE_MINI = 100 # B-3 préflight
SEUIL_RESCAN_RESIDUEL = 0 # Tolérance zéro après rescan
QUARANTINE_DIR_NAME = "quarantaine"
```
---
— Claude (consolidé Qwen)

145
docs/coordination/inbox/for-dom/2026-05-29_qwen_analyse-regression-grand.md
View File

@@ -1,145 +0,0 @@
---
from: qwen
to: dom
date: 2026-05-29T10:30:00+02:00
topic: analyse-regression-grand
status: open
references:
- file: data/stopwords_manuels.txt:549
- file: anonymizer_core_refactored_onnx.py:2725
- file: data/insee/noms_famille_frequents.txt:43233
- commit: 13730d1
- tests: tests/unit/test_leak_scanner.py
priority: high
---
# Analyse régression — fuite "GRAND" (17 occurrences)
## Contexte
L'évaluation qualité sur le commit `13730d1` détecte **17 occurrences de "GRAND"** non masquées dans le document `trackare-05012965-23060770_05012965_23060770.pseudonymise.txt`. Score qualité : 99.8/100 (régression de -0.3 sur leak_score vs baseline).
---
## Cause racine identifiée
**Le mot `"grand"` est présent dans `data/stopwords_manuels.txt` à la ligne 549.**
Ce mot est chargé dans `_MEDICAL_STOP_WORDS_SET` (ligne 474-475 du core).
### Pourquoi "grand" a été ajouté aux stopwords
Probablement pour filtrer des expressions médicales comme "grand axe", "grande courbure", "grande taille" — termes anatomiques légitimes qui ne doivent pas être masqués.
### Pourquoi c'est un problème
**"GRAND" est aussi un nom de famille INSEE valide et courant** :
- Présent dans `data/insee/noms_famille_france.txt` (ligne 97117)
- Présent dans `data/insee/noms_famille_frequents.txt` (ligne 43233)
---
## Mécanisme de la fuite
Le patient s'appelle **Romain BILLON-GRAND**, et le médecin traitant est **DR. [NOM]-GRAND**.
Dans le fichier de sortie, les 17 occurrences non masquées apparaissent sous deux formes :
1. **`DR. [NOM]-GRAND`** — nom du docteur dans les en-têtes de prescriptions
2. **`[NOM]-GRAND`** — dans les tableaux de prescriptions
### Pourquoi le nom composé "BILLON-GRAND" est masqué mais "GRAND" seul ne l'est pas
Le pipeline traite "BILLON-GRAND" comme un **token unique** (pas de split sur le tiret dans `_extract_trackare_identity._add_name`). Le nom composé est détecté via le contexte `DR.` et masqué correctement.
Mais dans les tableaux Trackare, le formatage fait que **"GRAND" se retrouve seul sur une ligne**, séparé de "[NOM]-" par un saut de ligne :
```
DR. [NOM]-
GRAND
```
Quand le traitement ligne par ligne (`_mask_line_by_line`) rencontre "GRAND" seul :
```python
# Ligne ~2725 du core
if tok.lower() in _MEDICAL_STOP_WORDS_SET:
continue # ← "grand" est skipé, jamais proposé au masquage
```
**"grand" étant dans les stopwords, il est filtré et jamais masqué.**
---
## Les 2 occurrences de "grande" — faux positif
Le document contient aussi 2 occurrences de `"grande"` (lignes 2969, 2974) :
- `plus grande epaisseur` (radiologie/anatomie)
- `plus grande epaisseur` (radiologie)
Ces occurrences sont **légitimes** — ce sont des adjectifs médicaux. Elles ne doivent **PAS** être masquées.
---
## Fix proposé
### Option 1 (simple) : retirer "grand" des stopwords
**Action** : supprimer la ligne 549 de `data/stopwords_manuels.txt`.
**Impact** : "GRAND" en MAJUSCULES sera détecté comme nom INSEE et masqué. "grande" en minuscules dans un contexte médical ("plus grande epaisseur") ne sera pas affecté car le matching INSEE se fait sur les tokens en MAJUSCULES.
**Risque** : "grand" en minuscule dans d'autres contextes pourrait être détecté comme faux positif (ex: "grand axe"). Mais le mécanisme de validation croisée (`_cross_validate_name_candidates`) exige un contexte fort (DR., MAJUSCULES, etc.) pour masquer — un "grand" isolé en minuscule ne sera pas masqué.
**Recommandation** : ✅ **Option 1 retenue**. C'est le fix le plus sûr.
### Option 2 (complexe) : stopwords contextuels
Transformer les stopwords single-word en patterns contextuels :
- "grand" → ne filtrer que si suivi de "axe", "courbure", "epaisseur", etc.
- Sinon, laisser le pipeline INSEE faire son travail
**Risque** : complexité accrue, maintenance difficile. Pas adapté au sprint MVP.
### Option 3 (hybride) : whitelist/blacklist INSEE
Ajouter une couche qui dit : "si un token est dans INSEE ET dans les stopwords, la priorité INSEE l'emporte".
**Impact** : changement de logique dans `_cross_validate_name_candidates`. Risque de faux positifs sur d'autres mots ambigus.
---
## Tests à ajouter
```python
# tests/unit/test_c8_grand_regression.py
def test_grand_insee_name_is_masked():
"""GRAND (nom INSEE) en MAJUSCULES doit être masqué même si présent dans stopwords."""
...
def test_grande_medical_not_masked():
"""'plus grande epaisseur' ne doit pas être masqué (adjectif médical)."""
...
def test_stopword_no_longer_blocks_insee_names():
"""Après retrait de 'grand' des stopwords, les noms INSEE ambigus sont traités."""
...
```
---
## Résumé
| Aspect | Détail |
|---|---|
| **Cause racine** | `"grand"` dans `data/stopwords_manuels.txt:549` filtre les noms INSEE "GRAND" |
| **Mécanisme** | `_mask_line_by_line` skip les tokens dont `.lower()` est dans `_MEDICAL_STOP_WORDS_SET` |
| **Impact** | 17 fuites réelles (nom propre BILLON-GRAND) |
| **Fix recommandé** | Retirer `"grand"` de `data/stopwords_manuels.txt` — 1 ligne à supprimer |
| **Risque du fix** | Minimal — le pipeline INSEE exige un contexte fort pour masquer |
| **Effort** | 5 minutes (1 ligne + 3 tests) |
---
— Qwen

167
docs/coordination/inbox/for-dom/2026-05-29_qwen_release-notes-v11-draft.md
View File

@@ -1,167 +0,0 @@
# Pseudonymisation v11.0 — MVP livraison bêta Province Bêta
**Date** : 2026-06-02
**Audience** : bêta-testeur Province Bêta
**Build** : `13730d1` — 2026-05-29 (rebuild prévu dimanche 01/06)
**Canal** : OwnCloud
---
## Nouveautés de cette version (par rapport à v10)
### 🔴 Sécurité RGPD — quarantaine différentielle (Q-1)
**Changement majeur** : un document n'est livré « anonymisé » que si **toutes** les étapes critiques ont réussi.
- **Quarantaine automatique** : les documents dont l'extraction de texte échoue, dont la rédaction PDF échoue, ou dont le rescan de sécurité détecte des PII résiduelles sont automatiquement isolés dans un dossier `quarantaine/`.
- **Quarantaine partielle** : si le texte est correctement anonymisé mais que le PDF ne peut pas être rédigé (chiffrement, annotations corrompues), le texte `.pseudonymise.txt` sort normalement et le PDF va en quarantaine avec un fichier d'explication.
- **Quarantaine totale** : si le texte extrait est inférieur à 100 caractères (document vide ou OCR raté), le document entier va en quarantaine — aucun fichier de sortie n'est généré.
- **`quarantaine/INDEX.md`** : résumé lisible de tous les documents en quarantaine avec raisons et suggestions, généré à la fin de chaque batch.
- **`errors.log`** : journal cumulatif de toutes les erreurs du batch, format JSON par ligne pour analyse.
- **`<document>.log`** : log détaillé du traitement de chaque document (étapes, détections, warnings).
### Pré-flight texte vide (B-3)
- Avant tout traitement, le programme vérifie que le document contient au moins **100 caractères de texte extrait**. En dessous, le document est considéré comme non-OCRisé ou vide et envoyé directement en quarantaine.
- Évite le scénario où un document scanné non-OCRisé sort « anonymisé » alors qu'aucun texte n'a été traité.
### Tolérance zéro PII résiduelles (rescan check)
- Après anonymisation, un **rescan de sécurité** vérifie l'absence de PII résiduelles (emails, téléphones, NIR, IBAN, noms INSEE en MAJUSCULES, FINESS, RPPS, etc.).
- Si ≥ 1 PII résiduelle est détectée → le document va en **quarantaine totale** avec alerte.
- Réutilise les patterns de détection de `evaluation/leak_scanner.py` (patterns complets et validés).
### Traçabilité — métadonnées de sortie (B-1)
- **XMP metadata** dans les PDF de sortie : version de l'application, commit SHA, profil appliqué, horodatage. Les métadonnées source du PDF (auteur, titre original) sont **explicitement effacées** pour éviter les fuites.
- **Entrée `type=metadata`** en première ligne de chaque `.audit.jsonl` : version de l'app, commit, date de traitement, profil, flags de quarantaine.
- Permet de prouver a posteriori avec quelle configuration un document a été anonymisé (audit DPO/CNIL).
### Fix détection — régression nom "GRAND" (C-8)
- Le nom de famille **GRAND** (INSEE valide, courant) était filtré à tort car le mot `"grand"` était présent dans la liste des stopwords médicaux.
- **Fix** : `"grand"` retiré des stopwords. Les noms INSEE ambigus ne sont plus bloqués par le filtre stopwords.
- Impact : 17 occurrences de "GRAND" non masquées corrigées sur le corpus de test audit_30.
- 7 tests de non-régression ajoutés (`tests/unit/test_c8_grand_regression.py`).
---
## Corrections depuis v10 (changelog)
### Détection PII
| Commit | Description |
|---|---|
| `e0b526b` | Établissements multi-ligne, CHUXX en fin de phrase, ville après `[ETAB]` |
| `c7e7107` | RPPS avec qualificateur (`RPPS prescripteur :`, `RPPS de garde :`) |
| `7242b53` | Labels structurels Nom de jeune fille / Prénom / Ville |
| `c24b7f6` | Quick wins : caractère ñ, numéro adhérent, NIR avant TEL |
| `c3eb50b` | Masquer artefacts noms de fichiers DPI et variante BACTERIO N° venue |
| `8e43d8d` | Accepter prénoms 3 chars après Dr/Mme (Ute, Eva, Léo…) |
| `e2e2a7c` | Masquer tokens collés à ponctuation (`Douar,nécessitant`) |
| `aa3db69` | RE_HOPITAL_VILLE accepte les ALL-CAPS (`CENTRE HOSPITALIER`) |
| `51c7555` | Faux positifs pyzbar sur tableaux (carrés noirs sur dates/heures) |
| `2f19f7c` | DR. Ute (3 chars), SAINT-GERMES composé, SODIUM MACO/BAX pharma |
| `c157205` | Labels DPI masqués (Date, Note, Type, Heure) + whitelist désactivée |
| `4d33610` | Cross-validation respecte bypass_stopwords pour noms forcés (Dr/Mme) |
### Architecture / Infrastructure
| Commit | Description |
|---|---|
| `df5dabf` | Admin rules branchées dans le pipeline ONNX |
| `13730d1` | CLI `simulate_admin_rule` + fix email avant force_terms |
| `8f6c462` | python-doctr rendu requis (OCR systématique) |
| `6586b89` | Version + build date + commit affichés dans titre et status bar GUI |
| `cf36357` | Couche 2 tests étendue à 10 cas + gate pytest avec xfail strict |
### Interface
| Commit | Description |
|---|---|
| `ab5a24f` | Refonte UI — logo aivanonym + palette magenta/pêche + onglets + v5.5 |
| `0124457` | Étapes de chargement dans le splash natif PyInstaller |
| `0a377bc` | Splash natif PyInstaller — couvre la décompression onefile |
### Configuration
| Commit | Description |
|---|---|
| `500ebc2` | Externalisation des dictionnaires (YAML, data/) |
| `4b59253` | additional_stopwords exposés dans le panneau Paramètres avancés GUI |
| `b5058b9` | GUI whitelist_phrases enfin lue et appliquée par le core |
| `ea214db` | Nettoyage force_mask_terms — délégation aux gazetteers nationaux |
---
## Procédure d'utilisation
### Premier lancement
1. Décompresser l'archive ZIP dans `C:\Program Files\AIV Anonymisation\`
2. Double-cliquer `Pseudonymisation.exe`
3. **SmartScreen** : au premier lancement, Windows SmartScreen peut apparaître (application non signée). Cliquer **Informations complémentaires → Exécuter quand même**.
- Voir `smartscreen-procedure.md` pour la procédure détaillée (Edge/Chrome/Firefox + DSI).
### Utilisation batch
1. Sélectionner un dossier source contenant les documents PDF
2. Sélectionner un dossier de sortie (vide)
3. Choisir un profil (standard_local par défaut) ou importer un profil JSON
4. Cliquer **Anonymiser**
5. À la fin du traitement :
- Documents OK → `.pseudonymise.txt` + `.audit.jsonl` + `.redacted.pdf` dans le dossier de sortie
- Documents en anomalie → dossier `quarantaine/` avec `INDEX.md` explicatif
- Logs cumulatifs → `errors.log` dans le dossier de sortie
### En cas de quarantaine
1. Ouvrir le dossier `quarantaine/`
2. Lire `INDEX.md` pour comprendre les raisons
3. Lire les fichiers `.reason.txt` pour chaque document
4. Ré-essayer manuellement si la raison le permet (ex: PDF chiffré → fournir version non chiffrée)
---
## Risques connus
| Risque | Impact | Mitigation |
|---|---|---|
| Pas de signature Authenticode | SmartScreen au premier lancement | Procédure documentée + SHA-256 fourni |
| Performance sur très gros documents (>200 pages) | Temps de traitement long | Reporté v11.5 — pas de blocage fonctionnel |
| OCR sur scans dégradés | Texte extrait insuffisant → quarantaine | Pré-flight détecte et isole automatiquement |
| Faux positifs sur termes médicaux ambigus | Sur-masquage mineur | Whitelist manuelle configurable via GUI |
---
## Canal support post-livraison
- **Patches v11.X** via OwnCloud (correctifs critiques uniquement)
- **Logs à envoyer en cas de bug** : zip du dossier `<sortie>/quarantaine/` + `errors.log` + profil utilisé
- **Contact** : dbazin52@gmail.com
---
## Annexes
### Score qualité de référence
| Métrique | v10 | v11.0 | Cible |
|---|---|---|---|
| Score global | 97.0 | **99.8** | 100.0 |
| Leak audit | 100.0 | 99.7 | 100.0 |
| Leak regex | 100.0 | 100.0 | 100.0 |
| FP score | 90.0 | **100.0** | 100.0 |
Documents testés : **audit_30** (29 documents, formats variés)
### Hash SHA-256
> *À fournir par Dom après rebuild EXE v11*
### Fichiers livrés
- `Pseudonymisation.exe` — exécutable Windows (PyInstaller onefile)
- `config/profiles.yml` — profils par défaut (modifiables)
- `config/dictionnaires.yml` — dictionnaires personnalisables
- `smartscreen-procedure.md` — procédure de premier lancement

168
docs/coordination/inbox/for-dom/2026-05-29_qwen_review-pseudocode-Q1.md
View File

@@ -1,168 +0,0 @@
---
from: qwen
to: dom
date: 2026-05-29T10:00:00+02:00
topic: review-pseudocode-Q1-quarantaine
status: open
references:
- file: inbox/for-dom/2026-05-29_claude_pseudocode-Q1-quarantaine.md
- file: anonymizer_core_refactored_onnx.py
- decision: decisions/2026-05-28_dom_no-ui-changes.md
- decision: decisions/2026-05-28_dom_mvp-livraison-mardi.md
priority: blocker
---
# Review critique du pseudo-code Q-1 (rédigé par Claude)
## Contexte
Claude a rédigé le pseudo-code Q-1 en mon absence (Plan B). J'ai relu le fichier en détail et comparé avec le code source actuel. Voici ma review structurée.
---
## 1. Inventaire des `except: pass` — ✅ BON mais INCOMPLET
Claude en identifie **13** comme critiques. J'en ai compté **~40** `except Exception` dans le core, dont **~20 `pass` purs**. L'inventaire de Claude couvre les chemins de rédaction et d'extraction, mais **il manque des cas critiques sur le rescan et la propagation**.
### Cas manqués par Claude
| # | Fichier:ligne | Fonction | Contexte | Pourquoi critique |
|---|---|---|---|---|
| A | `:4291` | `process_pdf` | `selective_rescan()` | Le rescan de sécurité est dans un `try/except: pass`. Si le rescan rate, des PII résiduelles passent **sans vérification**. C'est le dernier garde-fou avant la sortie. → **Q-DOC** |
| B | `:2720`-`2730` | `_mask_line_by_line` | Filtrage stopwords NER | Les tokens filtrés par stopwords sont silencieux. Si un nom INSEE est dans les stopwords (comme `grand` — voir analyse régression ci-dessous), il passe sans trace. → **L** (mais avec compteur de tokens filtrés) |
| C | `:3857` | `_search_whole_word` | `page.get_text("words")` | Si `get_text("words")` échoue sur une page (PDF corrompu), les rectangles ne sont pas trouvés mais le PDF sort quand même. → **Q-PDF** |
| D | `:4034` | `redact_pdf_raster` | `import re as _re` + OCR words | Bloc entier de traitement OCR/raster dans `try/except: pass`. Si le raster rate, le PDF de sortie n'a pas les masques raster. → **Q-PDF** |
| E | `:1490` | `_mask_line_by_content` | Regex recompilées inline | Les `re.compile()` inline peuvent lever `re.error` sur des patterns mal formés. Actuellement silents. → **L** (warning + skip pattern) |
**Recommandation** : Ajouter A (rescan) et D (raster) comme **Q-PDF/Q-DOC** dans l'inventaire. B et C comme **L** avec compteur.
---
## 2. Mapping action L / Q-PDF / Q-DOC — ✅ PERTINENT avec réserves
### Décision A (texte Q-PDF : output_dir uniquement)
✅ **D'accord avec Claude.** Le texte sort dans `output_dir`, pas de doublon dans `quarantaine/`. L'`INDEX.md` fait le lien. Moins de confusion, un seul emplacement de vérité pour chaque artefact.
### Décision B (fallback raster si vector rate)
✅ **D'accord, mais avec une condition.** Si le vector rate et que le raster réussit :
- Le PDF raster est généré (mais qualité moindre)
- Le flag `partial` reste levé avec raison `pdf_vector_fallback_to_raster`
- L'`INDEX.md` note que le PDF est en qualité raster (prévention opérateur)
C'est un compromis qualité/robustesse acceptable.
### Décision C (seuils 50/3)
⚠️ **À valider sur le corpus.** 50 caractères pour le pré-flight me semble **trop bas**. Un PDF d'une page avec juste un en-tête peut faire 50 chars et contenir des PII non détectées. Je proposerais :
- `SEUIL_TEXTE_MINI = 100` — sous ce seuil, c'est soit un PDF vide, soit un scan non-OCRisé
- `SEUIL_RESCAN_RESIDUEL = 0` — tolérance zéro pour les PII résiduelles après rescan. Si le rescan en trouve ≥ 1 → quarantaine. Le seuil de 3 est trop permissif pour un objectif 99% RGPD.
### Ajout : seuil de confiance NER global
Manque un garde-fou sur la **confiance NER moyenne**. Si le NER retourne une confiance moyenne < 0.5 sur toutes les pages, c'est un signal que le modèle ne fonctionne pas sur ce document (format atypique, langue, etc.). → Flag quarantaine avec raison `ner_low_confidence`.
---
## 3. Structure dossier quarantaine — ✅ BONNE avec un ajustement
La structure proposée est bonne. Un ajustement :
**Ajouter `quarantaine/<docname>.pseudonymise.txt` en copie pour les Q-PDF (partial).**
Raison : si l'opérateur veut inspecter le texte d'un document dont le PDF a échoué, il ne devrait pas avoir à faire la navette entre `output_dir/` et `quarantaine/`. La quarantaine doit être **autoportante** — tout ce qui concerne un document en anomalie est dans un seul dossier.
Contre-argument de Claude (pas de doublon) : valide, mais la copie est cheap (texte) et la clarté opérationnelle prime.
---
## 4. Pseudo-code `process_pdf` — ✅ COUVERTURE BONNE
Le pseudo-code couvre les chemins principaux. **Deux gaps :**
### Gap 1 : pas de gestion du cas `used_ocr = True`
Quand l'OCR est activé (`used_ocr=True`), la confiance de l'OCR n'est pas vérifiée. docTR peut retourner un texte de très mauvaise qualité sur un scan flou. Il faudrait un flag `ocr_low_quality` si le ratio mots détectés / surface page est trop faible.
### Gap 2 : pas de gestion des tables
Les `tables_lines` extraites par PyMuPDF ne passent pas par le pré-flight. Si les tables sont vides mais que le texte principal est OK, le doc sort avec des tables non-anonymisées. → Ajouter un check `if tables_lines and sum(len(t) for t in tables_lines) == 0: log.warning("empty tables extracted")`.
---
## 5. B-1 Métadonnées — ✅ EXCELLENT
L'approche metadata dans `.audit.jsonl` + XMP PDF est la bonne. **Un ajout critique :**
⚠️ **Ne JAMAIS copier les métadonnées source du PDF dans la sortie.** Le pseudo-code de Claude le mentionne (§5.2), mais c'est à renforcer avec un `doc.metadata.clear()` explicite avant `doc.save()`. Les PDF Trackare/CHUXX contiennent souvent le nom du patient dans `author` ou `title`.
---
## 6. B-3 Pré-flight — ✅ BON avec seuil ajusté
Voir §2C ci-dessus. Je recommande `SEUIL_TEXTE_MINI = 100` au lieu de 50.
---
## 7. Helper `_count_residual_pii` — ⚠️ INSUFFISANT
La version de Claude ne couvre que EMAIL, TEL, NIR, IBAN, et noms INSEE. **Il manque :**
- FINESS (8-9 chiffres)
- IPP (alphanumérique)
- OGC (format spécifique)
- Dates de naissance
- Adresses (pattern Rue + CP + Ville)
- RPPS (10 chiffres)
**Recommandation** : réutiliser les regex du leak_scanner (`evaluation/leak_scanner.py`) qui sont déjà complètes. Pas de réinvention.
---
## 8. Tests — ✅ LES TESTS XFAIL EXISTENT
Claude mentionne `test_q1_quarantine.py` avec 10 tests xfail. Je les ai vus dans `tests/unit/`. Bonne base.
**Tests manquants à ajouter :**
1. `test_quarantine_index_md_format` — vérifier que INDEX.md est bien généré avec le bon format
2. `test_errors_log_json_lines` — vérifier que chaque ligne de errors.log est un JSON valide
3. `test_doc_log_per_document` — vérifier que chaque doc a son fichier .log
4. `test_xmp_metadata_no_source_leak` — vérifier que les métadonnées PDF source ne sont pas copiées
5. `test_preflight_text_too_short_boundary` — tester à 49, 50, 51, 100 chars
---
## 9. Résumé des décisions pour Dom
| Décision | Proposition Claude | Avis Qwen | Recommandation finale |
|---|---|---|---|
| A — Texte Q-PDF | output_dir uniquement | ✅ D'accord | output_dir uniquement |
| B — Fallback raster | Oui, si vector rate | ✅ D'accord, avec flag | Oui, flag `pdf_vector_fallback_to_raster` |
| C — Seuil texte mini | 50 chars | ⚠️ Trop bas | **100 chars** |
| C — Seuil rescan | 3 PII résiduelles | ⚠️ Trop permissif | **0 PII résiduelles** (tolérance zéro) |
| D — Copie texte en quarantaine | Non | ⚠️ D'accord partiel | **Oui, copie pour autoportance** |
| E — Inventaire except:pass | 13 cas | ⚠️ Incomplet | **+5 cas manqués** (rescan, raster, stopwords, search, regex inline) |
| F — Métadonnées source PDF | Ne pas copier | ✅ D'accord | **+ clear explicite des metadata source** |
---
## 10. Ordre de travail révisé
1. **Matin** : `quarantine.py` + 5 cas manquants dans l'inventaire — 1h30
2. **Matin** : `redact_pdf_vector:3938` raise au lieu de pass — 30 min
3. **Matin** : `process_pdf:4655` try/flag — 1h
4. **Matin** : Pré-flight B-3 (seuil 100) — 30 min
5. **Après-midi** : Rescan check + `_count_residual_pii` (réutiliser leak_scanner) — 1h30
6. **Après-midi** : XMP metadata + clear source — 30 min
7. **Après-midi** : Metadata `.audit.jsonl` — 30 min
8. **Après-midi** : DocLogger — 30 min
9. **Soir** : Tests — 2h
**Total estimé : ~8h** (au lieu de 4-6h initiales — le gap vient des 5 cas manquants).
---
— Qwen

276
docs/coordination/inbox/for-dom/2026-05-29_qwen_smoke-test-T6.md
View File

@@ -1,276 +0,0 @@
# Kit de smoke test -- Beta-testeur v11.0
**Date** : 29 mai 2026
**Version** : Pseudonymisation v11.0
**Audience** : beta-testeur (non technique)
**Objet** : verifier que l'anonymisation fonctionne correctement avant mise en production
---
## 1. Specification du PDF de test synthetique
Le PDF de test doit etre un document d'1 a 3 pages qui ressemble a un compte-rendu medical courant (compte-rendu d'hospitalisation, lettre de liaison, ou compte-rendu de consultation). Il doit contenir **deliberement** les donnees personnelles listees ci-dessous, placees dans des contextes realistes.
### 1.1 Donnees obligatoires a inclure
| # | Type de donnee | Exemple exact a inserer | Attendu apres anonymisation |
|---|---|---|---|
| 1 | **Nom de medecin** (titre + NOM en majuscules) | `DR. MARTIN` | `DR. [NOM]` |
| 2 | **Nom de patiente** (titre civilite + NOM) | `MME DUPONT` | `MME [NOM]` |
| 3 | **Date de naissance** | `nee le 14/03/1985` ou `Date de naissance : 14/03/1985` | `nee le [DATE]` ou `Date de naissance : [DATE]` |
| 4 | **NIR** (13 chiffres + cle 2 chiffres, espaces acceptes) | `1 85 03 75 108 042 37` | `[NIR]` |
| 5 | **Telephone** (format francais avec espaces) | `01 42 68 53 17` ou `06 12 34 56 78` | `[TEL]` |
| 6 | **Email** | `jean.martin@chu-reunion.fr` | `[EMAIL]` |
| 7 | **FINESS** (9 chiffres avec label) | `FINESS : 123450123` | `[FINESS]` |
| 8 | **Etablissement** (nom complet) | `CENTRE HOSPITALIER UNIVERSITAIRE DE LA REUNION` | `[ETABLISSEMENT]` ou masque selon profil |
| 9 | **Adresse complete** (numero + voie + ville + CP) | `12 rue de la Republique, 12345 Springfield` | `[ADRESSE]` |
### 1.2 Donnees supplementaires recommandees
| # | Type | Exemple | Attendu |
|---|---|---|---|
| 10 | **IPP** (identifiant patient) | `IPP : 1234512345` | `[IPP]` |
| 11 | **RPPS** (numero medecin, 11 chiffres) | `RPPS : 10000234567` | `[RPPS]` |
| 12 | **IBAN** | `FR76 3000 2005 0000 0123 4567 890` | `[IBAN]` |
| 13 | **Nom compose** (trait d'union) | `M. DURAND-MARTIN` | `M. [NOM]` ou `[NOM]-[NOM]` |
| 14 | **Nom INSEE ambigu** (test fix "GRAND") | `DR. GRAND` ou `BILLON-GRAND Sylvie` | `DR. [NOM]` / `[NOM]-[NOM] Sylvie` |
| 15 | **Deuxieme email** (dans un contexte different) | `Contact : secretariat@hopital.fr` | `Contact : [EMAIL]` |
### 1.3 Conseils de creation du PDF
- **Ne pas** faire un PDF scanne (image) -- utiliser un PDF textuel genere depuis un traitement de texte (Word, LibreOffice, Google Docs).
- Repartir les PII sur **au moins 2 pages** differentes pour valider la propagation globale (un nom detecte page 1 doit etre masque page 2).
- Inclure au moins un paragraphe de texte medical banal entre les PII (ex : « Le patient presente une hypertension arterielle moderee. Traitement propose : Amlodipine 5 mg. ») pour verifier que le texte medical n'est **pas** masque par erreur.
- Le document doit contenir **au moins 200 caracteres de texte** (hors PII) pour ne pas etre place en quarantaine automatiquement.
### 1.4 Exemple de squelette de document
```
COMPTE RENDU D'HOSPITALISATION
Patient : MME DUPONT Marie
Nee le : 14/03/1985
NIR : 1 85 03 75 108 042 37
IPP : 1234512345
Adresse : 12 rue de la Republique, 12345 Springfield
Telephone : 06 12 34 56 78
Email : marie.dupont@email.fr
Medecin traitant : DR. MARTIN Philippe
RPPS : 10000234567
Email : jean.martin@chu-reunion.fr
Etablissement : CENTRE HOSPITALIER UNIVERSITAIRE DE LA REUNION
FINESS : 123450123
Adresse : 12 rue de la Republique, 12345 Springfield
---
Motif d'hospitalisation :
La patiente MME DUPONT a ete admise le 20/05/2026 pour des douleurs
thoraciques recurrentes. Antecedents : hypertension arterielle,
diabete de type 2.
DR. GRAND a realise un ECG qui ne montre pas d'anomalie particuliere.
Le Dr BILLON-GRAND Sylvie a complete l'examen clinique.
Traitement prescrit :
- Amlodipine 5 mg, 1 comprime par jour
- Metformine 1000 mg, matin et soir
Rendez-vous de controle prevu le 15/06/2026.
Contacter le secretariat au 01 42 68 53 17 ou par email a
secretariat@chu-reunion.fr.
IBAN pour la facturation : FR76 3000 2005 0000 0123 4567 890
Dr MARTIN Philippe
Centre Hospitalier Universitaire de la Reunion
```
---
## 2. Procedure de validation manuelle
### 2.1 Preparation
1. Installer le logiciel selon la procedure fournie (decompression + premier lancement).
2. Creer un dossier de test vide sur le bureau, par exemple `C:\TestsBeta\Sortie\`.
3. Placer le PDF de test decrit ci-dessus dans un dossier source, par exemple `C:\TestsBeta\Source\`.
### 2.2 Lancement
1. Ouvrir l'application **Pseudonymisation**.
2. Dans le panneau **Dossier source**, selectionner `C:\TestsBeta\Source\`.
3. Dans le panneau **Dossier de sortie**, selectionner `C:\TestsBeta\Sortie\`.
4. Laisser le profil sur **standard_local** (par defaut).
5. Cliquer sur le bouton **Anonymiser**.
6. Attendre la fin du traitement (indicateur de progression).
### 2.3 Verification des fichiers produits
Une fois le traitement termine, ouvrir le dossier de sortie (`C:\TestsBeta\Sortie\`).
**Ce que vous devez trouver :**
| Fichier | Description |
|---|---|
| `mon_test.pseudonymise.txt` | Texte complet du document avec les PII remplaces par des balises |
| `mon_test.audit.jsonl` | Journal d'audit (une ligne par PII detectee) |
| `mon_test.redacted.pdf` | PDF caviarde (zones sensibles masquee par des rectangles noirs) |
| `mon_test.log` | Journal detaille du traitement |
**Ce que vous ne devez PAS trouver (si tout va bien) :**
- Pas de dossier `quarantaine/` -- il ne doit apparaitre que si un document a pose probleme.
### 2.4 Verification du contenu anonymise
Ouvrir le fichier `mon_test.pseudonymise.txt` et verifier point par point :
1. **Aucun** des noms, emails, telephones, NIR, adresses, FINESS, etc. du document original n'apparait en clair.
2. A la place, vous voyez des balises comme `[NOM]`, `[TEL]`, `[EMAIL]`, `[NIR]`, `[ADRESSE]`, `[FINESS]`, `[DATE]`, etc.
3. Le texte medical normal (diagnostics, traitements, observations) est **conserve intact** -- seules les donnees personnelles sont remplacees.
4. Si un nom apparaissait sur plusieurs pages dans le document original, il est masque sur **toutes** les pages.
### 2.5 Verification du PDF caviarde
1. Ouvrir `mon_test.redacted.pdf` dans un lecteur PDF classique.
2. Les zones contenant des PII doivent etre recouvertes de **rectangles noirs**.
3. Le reste du document (texte medical, mise en page) doit etre lisible.
### 2.6 En cas de quarantaine
Si un dossier `quarantaine/` est apparu dans le dossier de sortie :
1. Ouvrir le fichier `quarantaine/INDEX.md` avec un editeur de texte (Bloc-notes).
2. Ce fichier indique **quels documents** ont ete places en quarantaine et **pourquoi**.
3. Chaque document en quarantaine a son propre fichier `.reason.txt` qui explique le probleme en langage lisible.
4. **Action recommandee** : noter la raison et envoyer les fichiers de quarantaine au support pour analyse.
---
## 3. Checklist OK / KO
Cochez chaque case apres execution. Une seule case KO = le test est considere comme **echoue**.
### Fichiers de sortie
- [ ] Le fichier `.pseudonymise.txt` existe dans le dossier de sortie
- [ ] Le fichier `.audit.jsonl` existe dans le dossier de sortie
- [ ] Le fichier `.redacted.pdf` existe dans le dossier de sortie
- [ ] Le fichier `.log` existe dans le dossier de sortie
- [ ] Aucun dossier `quarantaine/` n'a ete cree (pour un document valide)
### Detection des PII (dans le .pseudonymise.txt)
- [ ] `DR. MARTIN` → masque en `DR. [NOM]` (ou equivalent)
- [ ] `MME DUPONT` → masque en `MME [NOM]` (ou equivalent)
- [ ] La date de naissance `14/03/1985` → masque en `[DATE]`
- [ ] Le NIR `1 85 03 75 108 042 37` → masque en `[NIR]`
- [ ] Le telephone `06 12 34 56 78` → masque en `[TEL]`
- [ ] L'email `jean.martin@chu-reunion.fr` → masque en `[EMAIL]`
- [ ] Le FINESS `123450123` → masque en `[FINESS]`
- [ ] L'adresse `12 rue de la Republique, 12345 Springfield` → masque en `[ADRESSE]`
- [ ] Le nom compose `DURAND-MARTIN` → masque (pas en clair)
- [ ] `DR. GRAND` → masque en `DR. [NOM]` (fix regression v11)
- [ ] `BILLON-GRAND` → masque (pas de fuite du mot "GRAND")
- [ ] L'IPP `1234512345` → masque en `[IPP]`
- [ ] Le RPPS `10000234567` → masque en `[RPPS]`
- [ ] L'IBAN → masque en `[IBAN]`
### Qualite du resultat
- [ ] Le texte medical non sensible est conserve intact (pas de sur-masquage)
- [ ] La propagation globale fonctionne : un nom masque page 1 l'est aussi page 2
- [ ] Le PDF caviarde est lisible (rectangles noirs sur les zones sensibles)
- [ ] Aucune donnee personnelle du document original n'apparait en clair dans le fichier de sortie
### Resultat global
| Critere | Statut |
|---|---|
| Tous les fichiers de sortie produits | OK / KO |
| Tous les PII masques | OK / KO |
| Aucun faux positif majeur | OK / KO |
| PDF caviarde lisible | OK / KO |
| Pas de quarantaine inattendue | OK / KO |
| **TEST GLOBAL** | **REUSSI / ECHOUE** |
---
## 4. Cas de test "erreur attendue" -- Document en quarantaine
Ce cas de test verifie que le systeme de **quarantaine differentielle** (nouveau en v11.0) fonctionne correctement : un document qui ne peut pas etre traite correctement ne doit **pas** sortir comme "anonymise" sans signal d'alerte.
### 4.1 Comment creer un PDF qui DOIT aller en quarantaine
**Methode 1 -- Document vide ou quasi-vide (pre-flight) :**
1. Creer un PDF qui ne contient que **quelques caracteres** (moins de 100).
- Exemple : un PDF avec juste le mot `Test` ou un logo image sans texte extractible.
- Depuis Word : taper 3 mots, exporter en PDF.
2. Ce PDF va etre detecte comme "texte insuffisant" et place en quarantaine automatique.
3. **Resultat attendu :**
- Pas de fichier `.pseudonymise.txt` en sortie
- Pas de fichier `.redacted.pdf` en sortie
- Un dossier `quarantaine/` est cree avec un fichier `nom_du_doc.reason.txt` indiquant `preflight_text_too_short`
- Le fichier `quarantaine/INDEX.md` liste ce document avec la raison
**Methode 2 -- PDF avec image uniquement (scan non-OCRise) :**
1. Prendre une photo d'un document medical avec un telephone.
2. L'inserer dans Word sans ajouter de texte.
3. Exporter en PDF.
4. Ce PDF est une **image pure** -- si l'OCR ne parvient pas a extraire au moins 100 caracteres, le document va en quarantaine.
5. **Resultat attendu :** meme resultat que Methode 1.
**Methode 3 -- PDF chiffre (protection par mot de passe) :**
1. Creer un PDF normal avec des PII (comme le document de test ci-dessus).
2. Le proteger par un mot de passe via Word ou un outil PDF (interdire l'extraction de texte).
3. **Resultat attendu :**
- Soit le texte est quand meme extrait et le document est traite normalement
- Soit l'extraction echoue et le document va en quarantaine avec la raison `extraction_total_failure`
### 4.2 Verification de la quarantaine
Apres avoir traite l'un des documents ci-dessus :
- [ ] Le dossier `quarantaine/` existe dans le dossier de sortie
- [ ] Le fichier `quarantaine/INDEX.md` existe et contient le nom du document teste
- [ ] Le fichier `quarantaine/<nom>.reason.txt` existe et explique la raison (lisible en langage clair)
- [ ] Le fichier `.reason.txt` contient :
- [ ] Le type de probleme (ex : `preflight_text_too_short`)
- [ ] L'horodatage du traitement
- [ ] Une suggestion d'action pour l'operateur
- [ ] Aucun fichier `.pseudonymise.txt` ou `.redacted.pdf` n'a ete genere pour ce document dans le dossier de sortie principal
- [ ] Le fichier `errors.log` existe dans le dossier de sortie (journal cumulatif des erreurs)
### 4.3 Exemple de fichier .reason.txt attendu
```
Document : doc_vide
Sévérité : full (le document entier a été placé en quarantaine)
Raison : preflight_text_too_short
Détail : Seulement 12 caracteres extraits (seuil minimum = 100)
Horodatage : 2026-05-30T14:32:11+02:00
Version code : 0.11.0
Caractères extraits : 12
Suggestion opérateur : Verifier que le document contient du texte extractible.
Si c'est un scan, verifier que l'OCR est active.
```
---
## 5. Resume rapide pour le beta-testeur
| Action | Ce qu'il faut faire | Ce qu'il faut verifier |
|---|---|---|
| **Test normal** | Anonymiser le PDF de test (section 1) | Tous les PII sont masques, 3 fichiers de sortie produits |
| **Test quarantaine** | Anonymiser un PDF vide ou image (section 4) | Le dossier `quarantaine/` est cree avec explication |
| **En cas de probleme** | Envoyer au support | Le dossier `quarantaine/` complet + `errors.log` + profil utilise |
---
*Document genere le 29/05/2026 pour la beta v11.0 -- Pseudonymisation de documents medicaux*

94
docs/coordination/inbox/for-dom/2026-05-29_qwen_tests-c8-grand.md
View File

@@ -1,94 +0,0 @@
# Tests C-8 — Régression fuite "GRAND"
# Cause racine : "grand" dans data/stopwords_manuels.txt:549 filtrait le nom INSEE
# Fix : supprimer "grand" des stopwords + vérification que les noms INSEE ambigus sont masqués
import pytest
import sys
import os
# Ajout du path parent pour imports du core
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..'))
class TestGrandInseeRegression:
"""Tests de non-régression pour la fuite du nom INSEE "GRAND"."""
def test_grand_insee_name_is_masked(self):
"""GRAND (nom INSEE) en MAJUSCULES après contexte DR. doit être masqué."""
# Importer la fonction de masquage du core
# Après le fix, "grand" n'est plus dans les stopwords
# Donc "DR. GRAND" ou "DR. BILLON-GRAND" → GRAND doit être masqué
text = "DR. GRAND a prescrit un traitement."
# Résultat attendu : "DR. [NOM] a prescrit un traitement." ou similaire
# Le placeholder exact dépend du profil (standard_local → [NOM])
# On teste que "GRAND" n'apparaît plus en clair dans le texte
from anonymizer_core_refactored_onnx import anonymise_document_regex
# On construit une config minimale avec les stopwords mis à jour
# Ce test nécessitera l'infra de test du core
# Pour l'instant, on marque le test avec la logique attendue
assert "GRAND" not in result.upper() or "[NOM]" in result or "[PERSONNE]" in result
def test_grande_medical_not_masked(self):
"""'plus grande epaisseur' ne doit pas être masqué (adjectif médical)."""
# "grande" en minuscules dans un contexte anatomique est légitime
# Le masquage INSEE ne s'applique qu'aux tokens en MAJUSCULES
text = "La plus grande epaisseur de la paroi est de 12 mm."
# Résultat attendu : texte inchangé (aucun PII détecté)
assert "grande epaisseur" in result.lower()
assert "[NOM]" not in result
def test_stopword_no_longer_blocks_insee_names(self):
"""Après retrait de 'grand' des stopwords, les noms INSEE ambigus sont traités."""
# Vérifier que "grand" n'est PLUS dans _MEDICAL_STOP_WORDS_SET
from anonymizer_core_refactored_onnx import _MEDICAL_STOP_WORDS_SET
assert "grand" not in _MEDICAL_STOP_WORDS_SET, \
"'grand' doit être retiré des stopwords médicaux (C-8)"
def test_grand_compose_name_masked(self):
"""Un nom composé contenant GRAND doit être masqué intégralement."""
# Cas original de la fuite : BILLON-GRAND
text = "Patient : BILLON-GRAND Romain, né le..."
# Résultat attendu : "Patient : [NOM]-[NOM] Romain, né le..."
# ou "Patient : [NOM] Romain, né le..." (masquage du composé)
assert "BILLON-GRAND" not in result
assert "GRAND" not in result
def test_grand_isolated_uppercase_masked(self):
"""GRAND seul en MAJUSCULES (après saut de ligne) doit être masqué."""
# C'est le cas exact de la fuite Trackare :
# DR. [NOM]-
# GRAND
text = "DR. RAYNAL-\nGRAND sans injection."
# Résultat attendu : GRAND masqué car nom INSEE en MAJUSCULES
assert "GRAND" not in result
class TestStopwordsIntegrity:
"""Tests d'intégrité sur la liste de stopwords médicaux."""
def test_no_insee_names_in_stopwords(self):
"""Aucun nom de famille INSEE fréquent ne doit être dans les stopwords."""
# Charger les stopwords
from anonymizer_core_refactored_onnx import _MEDICAL_STOP_WORDS_SET
# Charger les noms INSEE fréquents
insee_path = os.path.join(
os.path.dirname(__file__), '..', '..', 'data', 'insee',
'noms_famille_frequents.txt'
)
if os.path.exists(insee_path):
with open(insee_path) as f:
insee_names = {line.strip().lower() for line in f if line.strip()}
# Intersection
overlap = _MEDICAL_STOP_WORDS_SET & insee_names
assert not overlap, \
f"Noms INSEE trouvés dans les stopwords (supprimer : {overlap})"
def test_stopwords_file_no_duplicates(self):
"""Le fichier stopwords_manuels.txt ne doit pas contenir de doublons."""
stopwords_path = os.path.join(
os.path.dirname(__file__), '..', '..', 'data', 'stopwords_manuels.txt'
)
with open(stopwords_path) as f:
lines = [l.strip() for l in f if l.strip() and not l.startswith('#')]
assert len(lines) == len(set(lines)), \
f"Doublons dans stopwords_manuels.txt : {len(lines) - len(set(lines))}"

78
docs/coordination/inbox/for-dom/2026-06-02_qwen_ejnaini-investigation.md
View File

@@ -1,78 +0,0 @@
---
from: qwen
to: dom
date: 2026-06-02T15:30:00+02:00
topic: ejnaini-investigation
status: open
priority: normal
references:
- file: inbox/for-qwen/2026-06-02_15-00_claude_status-paranames-taches.md
- file: corpus_validation/trackare-BA127127-23135726_BA127127_23135726.pseudonymise.txt
- file: regression_tests/baseline/trackare-BA127127-23135726_BA127127_23135726.pseudonymise.txt
---
# Investigation EJNAINI — 7 fuites dans trackare-BA127127
## Résultat
**Root cause identifié : le nom composé "NOCENT-EJNAINI" est coupé par un saut de ligne.**
Le format Trackare place le nom sur deux lignes consécutives :
```
... 17/07/2023 07:55 NOCENT-
Ampoule(s) EJNAINI
```
Le trait d'union est en fin de ligne, le second composant sur la ligne suivante.
## Analyse détaillée
| Élément | Statut | Lignes |
|---|---|---|
| `NOCENT-` | ❌ Non masqué (7 occ.) | 544, 563, 579, 607, 624, 680, 704 |
| `EJNAINI` | ❌ Non masqué (7 occ.) | 545, 564, 581, 609, 626, 682, 706 |
| `NOCENT-EJNAINI` (complet) | Jamais détecté | — |
## Pourquoi F1 ne corrige pas
F1 (décomposition noms à trait d'union) ajoute les composants d'un nom composé
à `safe_names` **seulement si** le nom complet est détecté par le NER.
Ici, **aucune des 3 hypothèses de Claude n'est exacte** :
1. ~~NER ne détecte pas "NOCENT-EJNAINI"~~ → **VRAI** (mais pas la cause directe)
2. ~~NameCandidate jamais créé~~ → **VRAI** (mais pas la cause directe)
3. ~~Cross-validation rejette~~ → **VRAI** mais secondaire
**La vraie cause** : le nom n'est jamais assemblé. Le NER (CamemBERT-bio, EDS-Pseudo)
traite le texte ligne par ligne. `"NOCENT-"` en fin de ligne est un token isolé,
`"EJNAINI"` sur la ligne suivante est un autre token. Le tiret n'est pas interprété
comme un joiner inter-lignes.
## Vérifications effectuées
- `grep -n "NOCENT"` : 7 occ., toutes `"NOCENT-"` en fin de ligne, non masqué
- `grep -n "EJNAINI"` : 7 occ., toutes `"EJNAINI"` seul, non masqué
- Les deux ne sont **ni dans INSEE** (noms étrangers) **ni dans le dictionnaire médical**
## Solution
**Paranames** résoudra ce cas : `"EJNAINI"` sera dans le gazetteer `noms_famille_world.txt.gz`
(issu de Wikidata). Il sera reconnu comme nom de famille étranger et masqué
**indépendamment** de la détection NER.
En attendant, un fix court-terme possible :
- Ajouter une regex `force_regex` pour les patterns `"NOCENT-\nEJNAINI"` ou `"NOCENT-"` + `"EJNAINI"` adjacents
- Ou ajouter "EJNAINI" au dictionnaire des noms à masquer manuellement
## Conclusion
**Hypothèse confirmée de Claude** : paranames est la solution appropriée.
Quand le gazetteer sera intégré, EJNAINI sera masqué.
Les 7 fuites NOCENT- sont un problème similaire — "NOCENT" est un nom basque
non couvert par INSEE. Paranames devrait aussi le couvrir.
---
— Qwen

187
docs/coordination/inbox/for-dom/2026-06-02_qwen_owncloud-livraison-procedure.md
View File

@@ -1,187 +0,0 @@
---
from: qwen
to: dom
date: 2026-06-02T11:30:00+02:00
topic: owncloud-livraison-procedure
status: open
priority: high
references:
- file: inbox/for-qwen/2026-05-29_13-55_claude_ack-T6-tache-T7.md
- file: inbox/for-dom/2026-05-29_qwen_release-notes-v11-draft.md
- file: inbox/for-dom/2026-05-29_qwen_smoke-test-T6.md
---
# Procédure de livraison OwnCloud — Pseudonymisation v11.0 Bêta
## Section 1 — Préparation du paquet (côté Dom)
### 1.1 Contenu du ZIP
Créer un dossier `Pseudonymisation_v11.0_MVP/` contenant :
```
Pseudonymisation_v11.0_MVP/
├── Pseudonymisation.exe ← exécutable Windows (build v11)
├── dictionnaires.yml ← dictionnaires externes (modifiables)
├── profiles.yml ← profils de configuration (modifiables)
├── smartscreen-procedure.md ← procédure premier lancement
├── release-notes.md ← nouveautés v11
├── smoke-test-T6.md ← test de validation rapide
└── smoke-test-data/ ← PDF synthétique pour le test
└── synthetique_CRH_v11.pdf
```
### 1.2 Compression ZIP
```powershell
# PowerShell (Windows)
Compress-Archive -Path "Pseudonymisation_v11.0_MVP" -DestinationPath "Pseudonymisation_v11.0_MVP.zip" -CompressionLevel Optimal
# Linux (si buildé depuis Linux)
zip -r -9 Pseudonymisation_v11.0_MVP.zip Pseudonymisation_v11.0_MVP/
```
### 1.3 Calcul SHA-256
```powershell
# PowerShell
Get-FileHash -Algorithm SHA256 Pseudonymisation_v11.0_MVP.zip
# Linux
sha256sum Pseudonymisation_v11.0_MVP.zip
```
**Noter l'empreinte dans le tableau ci-dessous :**
| Version | SHA-256 | Date |
|---|---|---|
| v11.0 MVP | *(à compléter après build)* | 2026-06-02 |
### 1.4 Upload OwnCloud
1. Se connecter à `https://[host_owncloud]`
2. Upload `Pseudonymisation_v11.0_MVP.zip`
3. Créer un lien de partage avec :
- **Mot de passe** : 12 caractères aléatoires (ex. `xK9#mP2$vLqR`)
- **Expiration** : 2026-07-02 (J+30)
- **Permissions** : lecture seule (pas d'upload, pas de modification)
- **Téléchargement direct** : activé
### 1.5 Génération mot de passe
```powershell
# PowerShell — génère un mot de passe 12 chars
-join ((65..90) + (97..122) + (48..57) + (33,35,36,37,38,42,64) | Get-Random -Count 12 | ForEach-Object {[char]$_})
# Linux
openssl rand -base64 12
```
---
## Section 2 — Vérifications avant envoi
- [ ] **ZIP testé en local** : extraire dans un dossier temporaire, vérifier que `Pseudonymisation.exe` est présent et que les fichiers config sont lisibles
- [ ] **SHA-256 noté** dans le tableau §1.3
- [ ] **Lien OwnCloud testé en navigation privée** (Ctrl+Shift+N) : le téléchargement doit fonctionner sans authentification OwnCloud
- [ ] **Mot de passe envoyé séparément** (SMS ou téléphone, PAS dans le même email)
- [ ] **Email de fourniture du contact support** : `dbazin52@gmail.com`
- [ ] **smartscreen-procedure.md** est bien dans le ZIP — le bêta DOIT la lire avant le premier lancement
---
## Section 3 — Template email pour le bêta-testeur
```
Objet : Pseudonymisation médicale v11.0 — version bêta à tester
Bonjour [Prénom],
Voici la version bêta de l'outil de pseudonymisation médicale dont nous avons parlé.
📥 Téléchargement
Lien : <url_owncloud>
Mot de passe : (envoyé séparément par SMS)
Expiration : 2026-07-02
Taille : ~720 Mo
🔐 Vérification d'intégrité
Après téléchargement, vérifiez l'empreinte du fichier ZIP :
- Empreinte SHA-256 : <hash_complet>
- Commande PowerShell : Get-FileHash -Algorithm SHA256 Pseudonymisation_v11.0_MVP.zip
📦 Contenu du ZIP
- Pseudonymisation.exe (exécutable Windows, ~650 Mo)
- dictionnaires.yml + profiles.yml (configurations modifiables)
- smartscreen-procedure.md (procédure premier lancement — LIRE EN PREMIER)
- release-notes.md (nouveautés v11.0)
- smoke-test-T6.md (test de validation rapide, ~10 min)
🚀 Première utilisation
1. Lire smartscreen-procedure.md en premier
2. Suivre les étapes 1 à 4 du document
3. Lancer Pseudonymisation.exe
4. Exécuter le smoke-test-T6.md pour valider le bon fonctionnement
🧪 Smoke test rapide
Le fichier smoke-test-T6.md contient une procédure de test avec un PDF
synthétique pour valider que l'anonymisation fonctionne correctement.
Durée estimée : 10 minutes.
🆘 En cas de problème
- Logs : zipper le dossier de sortie et le sous-dossier quarantaine/
- Email : dbazin52@gmail.com
- Réponse sous 24h (fuseau horaire Province Bêta UTC+4, je m'adapte)
Merci pour le test et n'hésitez pas pour toute question.
Cordialement,
Dom
```
---
## Section 4 — Suivi post-livraison
### 4.1 Tableau de suivi des retours
| # | Date | Description | Sévérité | Statut | Version |
|---|---|---|---|---|---|
| | | | | | v11.0 |
Sévérités :
- **Bloquant** : EXE ne lance pas, crash au premier document, perte de données
- **Majeur** : PII non masquée (fuite), fonctionnalité critique non fonctionnelle
- **Mineur** : bug UI, message d'erreur confus, performance lente
- **Cosmétique** : typo, alignement, couleur
### 4.2 Template rapport de bug
```
Version EXE : v11.0
Contexte : Windows 10/11, 8 Go RAM, PDF natif ou scan ?
Description : (ce que je faisais, ce qui s'est passé)
Logs : (joindre le dossier <sortie>/ + quarantaine/)
Sévérité : Bloquant / Majeur / Mineur / Cosmétique
```
### 4.3 Plan de patch v11.X
| Cadence | Condition |
|---|---|
| Patch hebdomadaire | Si ≥ 1 bug Bloquant ou Majeur |
| Attendre v11.5 | Si uniquement Mineurs et Cosmétiques |
| Hotfix immédiat | Si fuite PII confirmée |
### 4.4 Critères de validation bêta
La version bêta est considérée **validée** quand :
- [ ] Smoke test passé sans erreur (10/10)
- [ ] ≥ 5 documents réels traités avec succès
- [ ] Aucune PII résiduelle détectée sur les documents testés
- [ ] Quarantaine fonctionnelle (au moins 1 cas testé)
- [ ] Retour écrit du bêta-testeur
---
*Document généré automatiquement — procédure T7 du sprint v11.0 MVP*

75
docs/coordination/inbox/for-dom/2026-06-03_claude_ejnaini-root-cause.md
View File

@@ -1,75 +0,0 @@
---
from: claude
to: dom
date: 2026-06-03
topic: ejnaini-root-cause (T-H)
status: RÉSOLU — fix F5 implémenté + validé audit_30
references:
- file: docs/coordination/inbox/for-dom/2026-06-02_qwen_ejnaini-investigation.md
- doc: trackare-BA127127-23135726
---
# EJNAINI — cause racine confirmée (et conclusion de Qwen corrigée)
## Test empirique (moteur actuel, paranames + stopwords nettoyés)
Re-traitement du PDF source `433_23135726/trackare-BA127127...pdf` :
| Token | Avant | Maintenant |
|---|---|---|
| `NOCENT` | 7 fuites | **0** ✅ |
| `EJNAINI` | 7 fuites | **7** ❌ |
Pattern résiduel **déterministe** (7×) :
```
[NOM]-
EJNAINI
```
## Conclusion de Qwen RÉFUTÉE
Qwen concluait : « paranames résoudra EJNAINI ». **Faux.**
- `EJNAINI` **est** dans paranames (`noms_famille_world.txt.gz`) et chargé dans le core (vérifié).
- Il reste pourtant non masqué.
## Vraie cause racine
Deux chemins de masquage parallèles dans le moteur :
1. **Spans NER** → remplacement direct du span détecté. Capte `Cécilia NOCENT-EJNAINI` **là où il est intact** (166 hits NOM).
2. **NameCandidates** (regex) → cross-validation (NER/INSEE/paranames) → `safe_names` → remplacement global **+ redaction raster** (`NOM_GLOBAL`).
En zone tableau Trackare, le nom est éclaté sur deux lignes : `NOCENT-` en fin de ligne, `EJNAINI` orphelin plus bas.
- Le span intact `Cécilia NOCENT-EJNAINI` n'existe pas → chemin 1 ne le voit pas.
- Aucun candidat regex ne propose `EJNAINI` seul → chemin 2 ne le voit pas (donc paranames jamais consulté pour lui).
- F1 ne décompose que les tokens **uniques** à trait d'union déjà dans `names`, pas les **spans multi-mots** NER.
`NOCENT` finit masqué (`[NOM]-`) par un autre artefact de remplacement, mais `EJNAINI`, n'étant ni dans un span intact ni dans `safe_names`, fuit.
## Fix recommandé (robuste, corrige texte ET PDF)
Quand le NER détecte un nom **multi-mots ou à trait d'union** (PER), **décomposer** le span et injecter ses tokens composants (≥4 chars, non stop-word, confirmés gazetteer/NER) comme **NameCandidates haute confiance** → ils entrent dans `safe_names` → remplacement global + `NOM_GLOBAL` (raster).
C'est une généralisation de F1 aux spans NER multi-mots. Avantage : masque `EJNAINI` partout (texte + raster), pas un patch cosmétique sur le `.txt`.
## Fix implémenté (F5) — post-passe orpheline
Au lieu de la décomposition des spans NER (le span n'existe pas en zone tableau),
la solution retenue cible directement le pattern résiduel : après `selective_rescan`,
on masque le token majuscule orphelin qui suit immédiatement un `[NOM]-` (cas
`[NOM]-\nEJNAINI`). Implémenté dans `process_pdf` (étape 3a-bis), même style que le
nettoyage des codes postaux orphelins. Masque le texte **et** le raster (via `NOM_GLOBAL`).
## Validation (2026-06-03)
- BA127127 re-traité : `NOCENT=0, EJNAINI=0` ✅
- `tests/unit` : 85 passed
- **audit_30 complet** (29 docs, 1 quarantiné) :
- **Score global 98.5/100 (A+)** (baseline 97.0, +1.5)
- **Leak score 100/100** — 0 fuite audit, 0 regex, 0 INSEE contexte fort
- FP score 95 (+5 vs baseline), 0 terme médical masqué
- **Aucune régression**
EJNAINI était la dernière fuite de l'audit_30. **Leak score = 100%.**
— Claude

159
docs/coordination/inbox/for-dom/2026-06-04_qwen_checklist-pack-beta.md
View File

@@ -1,159 +0,0 @@
---
from: qwen
to: dom
date: 2026-06-04
topic: checklist-pack-beta
status: open
priority: high
references:
- inbox/for-qwen/2026-06-04_14-35_claude_repartition-jobs-beta.md
---
# Checklist pack beta v11 — 2026-06-04
Checklist de validation avant envoi du pack beta sur OwnCloud au beta-testeur Province Beta.
Chaque case doit etre verifiable par une personne qui prepare le pack.
---
## 1. Contenu du pack
- [ ] **EXE principal** : `Pseudonymisation.exe` present (build v11, pas l'installer MSI)
- Verifier : le fichier existe, taille ~200-500 Mo, nom exact `Pseudonymisation.exe`
- *Note* : le build se fait sur Windows (192.168.1.11) via `build_windows_oneclick.bat` ou `anonymisation_onefile.spec`
- [ ] **Fichiers de config** : `config/profiles.yml` et `config/` complet inclus
- Verifier : pas de profil `standard_local_copie_copie` (doublon corrige en C-2)
- [ ] **Modeles ONNX/GLiNER** : dossier `models/` present avec :
- `models/camembert-bio-deid/onnx/model.onnx` (embarque)
- `models/eds-pseudo/` (telecharge au premier lancement si absent)
- `models/gliner/` (telecharge au premier lancement si absent)
- [ ] **Dictionnaires externes** : dossier `data/` complet (INSEE, FINESS, BDPM, blacklist villes, etc.)
- Verifier : `data/` contient bien les fichiers `.txt` / `.json` / `.csv` — pas de repertoires vides
- [ ] **Documentation minimale** : au minimum `FONCTIONNEMENT.md` present
- [ ] **Procedure SmartScreen** : `docs/installation/smartscreen-procedure.md` incluse (ou version simplifiee en PDF)
---
## 2. Fichiers a exclure du pack
- [ ] **Sorties PII** : aucun fichier dans `pdf_natif/`, `pseudonymise/`, `test_anonymise/`, `test_chcb_leak/`, etc.
- Verifier : `find . -path "*/pdf_natif/*" -o -path "*/pseudonymise/*"` retourne rien
- [ ] **Caches AI** : aucun dossier `.claude/`, `.codex-loop/`, `.qwen/` (hors `.qwen/output-language.md` si besoin)
- [ ] **Fichiers de dev/tests** : excludes :
- `tests/`, `test_*/` (tous les dossiers de test)
- `demo_*.py`, `audit_*.py`, `analyze_anonymization_result.py`
- `run_batch_*.py`
- `server.py` (serveur API — pas pour la beta)
- `pdf_mask_designer.py`, `test-mini.js`
- `build_*.bat`, `build_*.ps1` (scripts de build)
- `setup_env_and_build.bat`
- `__pycache__/`, `.pytest_cache/`, `.ruff_cache/`
- [ ] **Logs et artefacts temporaires** : aucun `.log`, `*.lock`, `anonymisation.log` residuel
- [ ] **Fichier `.admin`** : confirme ABSENT du pack (decisions D-13, D-14)
- Verifier : `find . -name ".admin"` retourne rien
---
## 3. Verifications fonctionnelles (post-build)
### 3.1 Mode admin
- [ ] **Mode admin NON actif par defaut** : sans variable d'env `ANON_ADMIN` et sans fichier `.admin`, `is_admin()` retourne `False`
- Test rapide (sur poste Windows) : lancer l'EXE, verifier que le titre de la fenetre NE contient PAS `[MODE ADMIN]`
- Reference : `admin_mode.py` — `is_admin()` verifie `ANON_ADMIN` env + fichier `.admin`
- [ ] **Banniere "MODE ADMIN" s'affiche SI lance en admin** :
- Test : `$env:ANON_ADMIN="1"; .\Pseudonymisation.exe`
- Verifier : le titre de la fenetre contient `[MODE ADMIN]` (ou signal visuel equivalent)
- Reference : D-13 — titre fenetre montre `[MODE ADMIN]` si actif
### 3.2 VLM / Ollama
- [ ] **VLM/Ollama cache fonctionne en non-admin** :
- Verifier : en mode non-admin, l'option VLM est **masquee** dans l'UI (D-13 : VLM Ollama cache en non-admin)
- Le beta ne peut PAS configurer Ollama sans le mode admin (garde `admin_required()` dans le code GUI)
- Reference : `admin_mode.admin_required()` leve `RuntimeError` si pas admin
- [ ] **VLM Manager ne bloque pas le lancement** :
- `vlm_manager.py` utilise uniquement `urllib` (stdlib) — pas de dependance externe
- Si Ollama n'est pas installe, le pipeline degrade gracieusement (pas de crash au lancement)
### 3.3 Quarantaine
- [ ] **Dossier `quarantine/` cree avec permissions 0o700** :
- Reference : `quarantine.py:95` — `os.chmod(str(self.quarantine_dir), 0o700)`
- Note : sur Windows, le chmod peut etre ignore (`pass` si FS ne supporte pas) — le dossier est quand meme cree
- Les fichiers `.reason.txt` et `errors.log` sont en 0o600 (quarantine.py:216)
- [ ] **INDEX.md et `.reason.txt` generes correctement** :
- Test : traiter un PDF vide (< 100 caracteres) → dossier `quarantaine/` cree avec `INDEX.md` + `.reason.txt`
- Le `.reason.txt` contient : document, severite, raison, horodatage, version code, suggestion operateur
---
## 4. SmartScreen / SHA-256
- [ ] **SHA-256 du EXE calcule et documente** :
- Commande (PowerShell sur Windows) : `Get-FileHash -Algorithm SHA256 .\Pseudonymisation.exe`
- Ou (Linux, si EXE accessible) : `sha256sum Pseudonymisation.exe`
- Reporter le hash dans le message OwnCloud envoye au beta-testeur
- [ ] **Procedure SmartScreen incluse** :
- Le fichier `smartscreen-procedure.md` (ou equivalent PDF) est joint au pack
- Il couvre : deblocage fichier, premier lancement, SmartScreen bleu, Defender, poste DSI managed, verification hash
---
## 5. Procedure de retour beta-testeur
- [ ] **Fichier de feedback fourni** : un fichier `docs/feedback-beta.md` (ou equivalent) indiquant :
- Ce que le beta-testeur doit tester (cf. smoke test T6 dans `inbox/for-dom/2026-05-29_qwen_smoke-test-T6.md`)
- Le format de retour attendu : dossier `quarantaine/` complet + `errors.log` + profil utilise en cas de probleme
- [ ] **Canal de remontee defini** :
- OwnCloud (meme canal que la livraison, decision D-4)
- Email de Dom en backup : le beta-testeur sait a qui envoyer les retours
- [ ] **Ce que le beta-testeur doit tester** :
- Test normal : anonymiser le PDF de test (section 1 du smoke test T6)
- Test quarantaine : anonymiser un PDF vide ou image (section 4 du smoke test T6)
- Checklist OK/KO du smoke test T6 a remplir et retourner
- En cas de probleme : envoyer `quarantaine/` + `errors.log` + capture d'ecran
---
## 6. Checks RGPD
- [ ] **Aucune PII dans le pack** :
- Verifier : aucun fichier de test contenant des noms, emails, NIR, etc. en clair dans le pack
- Les dossiers `pdf_natif/`, `test_*/` sont exclus (voir section 2)
- [ ] **`quarantine/` cree avec bonnes permissions** :
- Permissions 0o700 sur le dossier (Linux) ou best-effort sur Windows
- Fichiers internes en 0o600
- Reference : `quarantine.py:89-97` et `quarantine.py:207-216`
- [ ] **Pas de chemins absolus locaux qui fuiteraient** :
- Verifier : `grep -r "C:\\\\Users" .` et `grep -r "/home/dom" .` dans les fichiers livres
- Corriger : `anonymisation_onefile.spec` a deja ete corrige (C-2 : chemin absolu supprime)
- Reference : decision D-6 (C-2) — doublon profil et chemin absolu corriges
- [ ] **Metadonnees de sortie presentes** (B-1) :
- Les fichiers de sortie portent : `version_code`, `horodatage`, `profil_applique`
- Verifier : un fichier `.audit.jsonl` contient bien ces champs
---
## 7. Resume rapide avant envoi OwnCloud
| Verification | Statut |
|---|---|
| EXE present et fonctionnel | / |
| Config et modeles inclus | / |
| Dictionnaires `data/` complets | / |
| Fichiers de dev/tests exclus | / |
| Aucune PII residuelle | / |
| `.admin` absent | / |
| Mode admin inactif par defaut | / |
| VLM masque en non-admin | / |
| Quarantaine fonctionnelle (permissions) | / |
| SHA-256 calcule et documente | / |
| Procedure SmartScreen incluse | / |
| Feedback beta-testeur pret | / |
| **PACK PRET A ENVOYER** | **OUI / NON** |
---
*Checklist generee le 04/06/2026 pour la beta v11.0 — Pseudonymisation de documents medicaux*
*References : smoke test T6, decisions D-1 a D-14, vision fonctionnelle, procedure SmartScreen*

63
docs/coordination/inbox/for-dom/2026-06-04_qwen_revue-build-beta.md
View File

@@ -1,63 +0,0 @@
---
from: qwen
to: dom
date: 2026-06-04
topic: revue-build-beta
status: open
priority: high
references:
- inbox/for-qwen/2026-06-04_14-35_claude_repartition-jobs-beta.md
---
# Revue build beta — 2026-06-04
## Resume
**2 risques bloquants, 4 recommandations**
## Risques bloquants
| # | Fichier | Ligne | Risque | Impact |
|---|---|---|---|---|
| B-1 | `scripts/build_windows_oneclick.ps1` | ~189-203 | `RequiredSourceFiles` liste 11 fichiers **source .py** comme prerequis au build (`launcher.py`, `Pseudonymisation_Gui_V5.py`, `admin_rules.py`, etc.). Ces fichiers sont necessaires au *runtime* de l'app, mais le build PyInstaller les embarque via le `.spec` (Analysis sur `launcher.py`). Cette verification est redondante mais **non bloquante en soi** — en revanche, si l'un de ces fichiers est deplace ou renomme, le build echouera avec une erreur explicite. | Build casse si un module source est deplace |
| B-2 | `scripts/build_windows_oneclick.ps1` | ligne 201 | `Require-Path` sur `models\camembert-bio-deid\onnx\model.onnx` — le modele ONNX doit etre present **avant** le build. Le `.gitignore` exclut `*.onnx` et `models/`. Donc sur une machine de build propre (clone frais), le build **echouera systematiquement** sans etape prealable de telechargement/depot du modele. C'est documente dans `docs/build-windows-oneclick.md` ("modele ONNX embarque requis doit exister localement"), mais aucun script ne le telecharge automatiquement. | **Bloquant** : build impossible sur clone frais sans action manuelle |
## Recommandations
| # | Fichier | Sujet | Proposition |
|---|---|---|---|
| R-1 | `scripts/build_windows_oneclick.ps1` | Timestamp server HTTP | Ligne 10 : `http://timestamp.digicert.com` utilise HTTP (non RFC 3161). Le serveur DigiCert supporte `http://timestamp.digicert.com` mais Microsoft recommande RFC 3161 (`http://timestamp.digicert.com` fonctionne en pratique). Pas bloquant, mais mentionner que le serveur RFC 3161 est `http://timestamp.digicert.com` (meme URL, protocole different dans SignTool). |
| R-2 | `build_windows_installer_oneclick.bat` | Nom du script PS appelle | Ligne 7 : pointe vers `scripts\build_windows_oneclick.ps1` (le script complet de build EXE+ZIP+installer). Le fichier s'appelle `build_windows_installer_oneclick.bat` mais relance le build **complet**, pas uniquement l'installateur. Si l'EXE existe deja, c'est inefficace (rebuild complet). Le script dedie `scripts/build_windows_installer_only.ps1` existe mais n'est appele par aucun `.bat`. Ajouter un `build_windows_rebuild_installer.bat` qui appelle `build_windows_installer_only.ps1`. |
| R-3 | `installer/Anonymisation.iss` | `AppPublisher` | Ligne 2 : `#define MyAppPublisher "CHUXX"` — c'est un placeholder, mais le fichier est versionne. Pour une beta, c'est acceptable, mais avant diffusion externe, remplacer par le nom reel de l'editeur. |
| R-4 | `scripts/install_inno_setup_build_dep.ps1` | Telechargement HTTP non verifie | Ligne 4 : telecharge `innosetup` depuis `https://jrsoftware.org/download.php/is.exe` sans verification de hash apres telechargement. Sur une machine de build, un download corrompu ou intercepte installerait un binaire inattendu. Ajouter une verification de hash SHA256 ou utiliser `Invoke-WebRequest` avec `-UseBasicParsing` + verification. |
## Verifications conformite
- [x] D-11 : EXE auto-suffisant sans installer — **CONFORME**. Le `.spec` embarque tous les modules via `hiddenimports` et `datas`. Le ZIP `Anonymisation-Windows.zip` contient l'EXE seul + README.txt. Aucun installateur requis pour l'utilisateur final. L'installateur Inno Setup est optionnel (`-SkipInstaller` disponible, et un avertissement est affiche si Inno Setup est absent).
- [x] D-13 : Mode admin NON active par defaut — **CONFORME**. Aucun des scripts de build ne definit `ANON_ADMIN`, ne cree de fichier `.admin`, ni n'embarque de fichier `.admin` dans le package. Le `launcher.py` ne definit pas cette variable d'environnement. Le `.gitignore` n'exclut pas `.admin` explicitement, mais le fichier n'est cree que manuellement. Le README.txt genere ne mentionne pas le mode admin.
- [x] D-14 : Pas de reference a `app.aivanov.fr` qui fuiterait — **CONFORME**. `grep` confirme : `app.aivanov.fr` n'apparait dans **aucun** fichier `.ps1`, `.bat`, `.iss`, `.py`, ou `.spec`. La reference `app.aivanov.fr` est uniquement dans `docs/coordination/decisions/2026-06-02_dom_d14-plateforme-licence-architecture.md` (fichier de decision, non embarque dans l'EXE). Le `launcher.py` contient `self.root.title("aivanonym")` et `APP_DIR` — pas de fuite de domaine.
## Autres observations
### Chemins absolus / secrets
- **Aucun chemin absolu** (`C:\Users\dom\...` ou `/home/dom/...`) trouve dans les 6 fichiers de build lus. Le probleme Q-2 signale dans l'audit (`chemin absolu C:\Users\dom\...` dans `anonymisation_onefile.spec`) a ete corrige — le `.spec` utilise `SPECPATH`/`project_dir` de maniere relative.
- **Aucun secret en dur** : `build_signing.example.ps1` contient des placeholders (`REMPLACER_PAR_L_EMPREINTE_DU_CERTIFICAT`). Le fichier `build_signing.local.ps1` est correctement exclu par `.gitignore`.
- Le parametre `-PfxPassword` passe le mot de passe en ligne de commande a `signtool.exe` (`/p`), ce qui peut apparaître dans les logs processus Windows. C'est une limitation inherente a SignTool — acceptable si le build est lance sur une machine dediee.
### Artifacts PII dans le repo
- Les fichiers de build **ne generent pas** de PII. Le `README.txt` genere contient uniquement date/branch/commit/signature.
- Le hash SHA256 est ecrit dans `release/Anonymisation.exe.sha256.txt` — pas de PII.
### Dependances non documentees
- `build_windows_oneclick.ps1` necessite : Python (3.11 ou 3.x), `requirements.txt`, `pyinstaller`, et optionnellement Inno Setup 6. Tout est documente dans `docs/build-windows-oneclick.md`.
- Le script `install_inno_setup_build_dep.ps1` installe Inno Setup en mode utilisateur (`/CURRENTUSER`) — pas besoin de droits admin, ce qui est coherent avec le principe de moindre privilege.
### Cohérence BAT <-> PS1
- `build_windows_installer_oneclick.bat` appelle `build_windows_oneclick.ps1` (le build complet), pas `build_windows_installer_only.ps1`. Le nom du `.bat` suggere qu'il ne fait que l'installateur, mais il rebuild tout. Ce n'est pas bloquant, mais preteur a confusion.
## Conclusion
**Go avec reserves** — Le build est structurellement sain. Aucun chemin absolu, aucun secret, aucune reference `app.aivanov.fr` dans les artefacts de build.
**Reserve principale** : le modele ONNX (`models/camembert-bio-deid/onnx/model.onnx`) est un prerequis non automatise. Le build echouera sur un clone frais sans etape manuelle prealable. Pour une beta a un seul utilisateur qui connait la procedure, c'est acceptable. Pour une reproductibilite future, envisager un script `scripts/download_models.ps1` ou une verification avec message d'erreur explicite ("Modele ONNX manquant — telecharger depuis HuggingFace ou restaurer depuis backup").

127
docs/coordination/inbox/for-dom/2026-06-04_qwen_triage-working-tree.md
View File

@@ -1,127 +0,0 @@
---
from: qwen
to: dom
date: 2026-06-04
topic: triage-working-tree
status: open
priority: normal
---
# Triage du working tree — 2026-06-04
## (a) À committer
| Fichier | Justification |
|---|---|
| `gui_batch_paths.py` | Module utilitaire pour lister les documents et construire les chemins de sortie batch. Testé unitairement. |
| `manual_masking.py` | Module de masquage manuel (templates YAML, résolution de PDF). Testé unitairement. |
| `tests/unit/test_gui_batch_paths.py` | Tests unitaires pour `gui_batch_paths.py` — couvre exclusion GUI output, extensions supportées, chemins imbriqués. |
| `tests/unit/test_manual_masking.py` | Tests unitaires pour `manual_masking.py` — templates YAML, labels, résolution. |
| `tests/unit/test_real_world_identifier_layouts.py` | Tests de non-régression sur layouts réels (bactério multiline, etc.). Important pour D-15 (leak audit). |
| `config/mask_templates/FC19_template.yml` | Template de masquage YAML utilisé par `manual_masking.py`. Fait partie du système de configuration. |
| `scripts/build_windows_oneclick.ps1` | Script PowerShell de build one-click — cœur du build system Windows. |
| `scripts/build_windows_installer_only.ps1` | Script de build de l'installer uniquement. |
| `scripts/install_inno_setup_build_dep.ps1` | Script d'installation des dépendances Inno Setup. |
| `build_windows_oneclick.bat` | Batch wrapper pour le build one-click. |
| `build_windows_installer_oneclick.bat` | Batch wrapper pour l'installer. |
| `build_signing.example.ps1` | Exemple de script de signing — documente le protocole (pas de secrets, c'est un `.example`). |
| `docs/build-windows-oneclick.md` | Documentation du build system — utile pour quiconque doit rebuild. |
| `docs/coordination/README.md` | README du protocole de coordination — fait partie du workflow de travail. |
| `docs/coordination/inbox/for-claude/2026-06-02_15-45_qwen_ack-t-g-h-i-livrees.md` | Ack Qwen — protocole de coordination. |
| `docs/coordination/inbox/for-dom/2026-06-02_qwen_ejnaini-investigation.md` | Rapport d'investigation EJNAINI (D-15) — travail pertinent. |
| `docs/coordination/inbox/for-qwen/*.md` (7 fichiers) | Instructions Claude→Qwen — protocole de coordination. |
| `docs/installation/smartscreen-procedure.md` | Documentation d'installation Smartscreen — utile pour le build/déploiement. |
| `docs/reflexions/2026-05-28_vision_fonctionnelle_avant_prod.md` | Document de vision produit — contexte stratégique utile. |
| `docs/coordination/log.md` | Log de coordination — protocole de travail. |
## (b) À gitignorer
| Fichier/Répertoire | Justification |
|---|---|
| `pdf_natif/pseudonymise/` (tout le contenu) | **Sorties pseudonymisées avec PII** — contient `.pseudonymise.txt`, `.audit.jsonl`, `.redacted_*.pdf`. Règle RGPD stricte (D-12). |
| `pdf_natif/pseudonymise/anonymise/` | Sous-répertoire de `pseudonymise/` — mêmes sorties PII (résultats de re-pseudonymisation en cascade). |
| `pdf_natif/pseudonymise_v11/` | Sorties v11 — mêmes PII que ci-dessus. Redondant avec `pseudonymise/`. |
| `.claude/` | Cache/runtime Claude (lock file, scheduled tasks). Pas de valeur source. |
| `.codex-loop/` | Artefacts de session Codex (diffs, plans, reviews temporaires). Contexte éphémère. |
| `.qwen/settings.json.orig` | Backup auto-généré de settings Qwen — pas de valeur source. |
| `.qwen/scripts/` | Scripts internes Qwen — pas de valeur pour le projet. |
| `.qwen/skills/` | Skills Qwen — pas de valeur pour le projet. |
| `scripts/__pycache__/` | Cache Python compilé — déjà couvert par `__pycache__/` dans `.gitignore` mais le répertoire `scripts/` n'est pas à la racine. |
## (c) À supprimer
| Fichier/Répertoire | Justification |
|---|---|
| `pdf_natif/pseudonymise/FC*.pseudonymise.txt` | **Contiennent des PII réelles** (noms patients, IPP, etc.). Aucun intérêt versionné, risque RGPD. |
| `pdf_natif/pseudonymise/FC*.audit.jsonl` | **Contiennent des PII réelles** dans les audits. Supprimer. |
| `pdf_natif/pseudonymise/FC*.redacted_*.pdf` | PDFs avec données médicales réelles. Supprimer. |
| `pdf_natif/pseudonymise/anonymise/*` | Doubles de pseudonymisation (re-traitement). Redondant + PII. |
| `pdf_natif/pseudonymise_v11/*` | Anciennes sorties v11. Redondant avec `pseudonymise/` + PII. |
| `docs/rapport-analyse-campagne-gui-2026-04-21.md` | Rapport d'analyse GUI ancien (avril 2026) — probablement obsolète après les pivots D-11 à D-15. À vérifier avant suppression. |
## Recommandations .gitignore
Ajouter ces lignes à `.gitignore` :
```gitignore
# === RGPD : sorties de pseudonymisation (PII) ===
pdf_natif/
# === Coordination AI — caches et artefacts éphémères ===
.claude/
.codex-loop/
.qwen/scripts/
.qwen/skills/
.qwen/settings.json.orig
# === Coordination AI — inbox (optionnel : ne garder que les décisions) ===
# Décommenter si on ne veut pas versionner les acks/instructions courantes :
# docs/coordination/inbox/
```
## Notes
- Les fichiers `D` (deleted) dans `git status` (`ano/pdf_natif/pseudonymise/FC*.audit.jsonl` et `FC*.pseudonymise.txt`) sont des fichiers **déjà supprimés** mais pas encore commités. Ils devraient être inclus dans le prochain commit pour nettoyer l'historique.
- `docs/coordination/inbox/` et `docs/coordination/archive/` sont le cœur du protocole de travail — **à committer**. Ils documentent les échanges Claude/Qwen/Dom.
- `docs/rapport-analyse-campagne-gui-2026-04-21.md` est à **vérifier** avant suppression — peut contenir des métriques utiles.
## Commandes suggérées
```bash
# 1. Committre tout le code utile, les tests et la coordination
git add gui_batch_paths.py manual_masking.py
git add tests/unit/test_gui_batch_paths.py tests/unit/test_manual_masking.py tests/unit/test_real_world_identifier_layouts.py
git add config/mask_templates/
git add scripts/build_windows_oneclick.ps1 scripts/build_windows_installer_only.ps1 scripts/install_inno_setup_build_dep.ps1
git add build_windows_oneclick.bat build_windows_installer_oneclick.bat build_signing.example.ps1
git add docs/build-windows-oneclick.md docs/installation/ docs/reflexions/
git add docs/coordination/README.md docs/coordination/log.md
git add docs/coordination/inbox/ docs/coordination/archive/
# 2. Committer les fichiers déjà supprimés (nettoyer les D dans git status)
git add -u ano/pdf_natif/pseudonymise/
# 3. Mettre à jour .gitignore
cat >> .gitignore << 'EOF'
# === RGPD : sorties de pseudonymisation (PII) ===
pdf_natif/
# === Coordination AI — caches et artefacts éphémères ===
.claude/
.codex-loop/
.qwen/scripts/
.qwen/skills/
.qwen/settings.json.orig
EOF
# 4. Gitignore le nouveau pattern
git add .gitignore
# 5. Supprimer physiquement les sorties PII (après commit si besoin de backup local)
rm -rf pdf_natif/pseudonymise/
rm -rf pdf_natif/pseudonymise_v11/
# 6. Vérifier le résultat
git status --short
```

76
docs/coordination/inbox/for-dom/2026-06-05_claude_diagnostic-perf-mvp.md
View File

@@ -1,76 +0,0 @@
---
from: claude
to: dom
date: 2026-06-05T19:45:00+02:00
topic: diagnostic-perf-mvp
status: open
priority: blocker
references:
- decision: docs/coordination/decisions/2026-06-05_dom_d19-performance-mvp-p1.md
---
# Diagnostic performance MVP (D-19) — cause racine + hotfix proposés
Symptôme (test Windows Dom) : anonymisation très lente, **CPU ~12 %** (≈ 1 cœur sur 8),
RAM ~16 Go. Diagnostic par lecture du code (aucune modif appliquée — gel bêta respecté).
## Causes racines identifiées (3)
### C1 — torch bridé à 1 thread en EXE frozen (cause principale du CPU 12 %)
`torch.set_num_threads()` / `OMP_NUM_THREADS` ne sont **définis nulle part** en
production (vérifié : seulement dans un script batch et un archive legacy). En EXE
PyInstaller frozen, torch ne détecte pas correctement les cœurs et tombe souvent à
**1 thread**. Or torch porte **l'OCR docTR** (db_resnet50 + crnn) **et** une partie NER.
→ explique directement le CPU ~12 %.
### C2 — Rastérisation forcée séquentielle en frozen
`anonymizer_core_refactored_onnx.py:4316-4322` : en `sys.frozen`, la rastérisation
des pages passe en **séquentiel mono-cœur** (pour éviter que `ProcessPoolExecutor`
relance l'exe → fenêtres fantômes). Mono-cœur sur toutes les pages.
### C3 — OCR docTR séquentiel, page par page, à 300 dpi
`anonymizer_core_refactored_onnx.py:1259-1280` : sur les pages pauvres en texte
(< 150 chars, i.e. **scannées**), docTR tourne dans une **boucle `for` page par page**
à **300 dpi** (images ~26 Mo/page), un appel `model([img])` à la fois. Pour un doc
scanné, c'est le coût dominant. (Bonne nouvelle : les PDF natifs riches en texte
**sautent l'OCR** — donc le problème est surtout sur les scannés.)
## RAM ~16 Go — explication
Cumul : modèles docTR (det+reco) + torch + modèle ONNX CamemBERT + **gazetteer
paranames 1.4M noms en mémoire** + images 300 dpi. Élevé mais surtout dû aux modèles
chargés ; pas une fuite. Mitigation possible (libérer les images après OCR) mais
secondaire vs le CPU.
## Hotfix proposés (faible risque, classés impact/risque)
| # | Hotfix | Impact | Risque | Détection |
|---|---|---|---|---|
| **H1** | `torch.set_num_threads(os.cpu_count())` + `OMP_NUM_THREADS`/`MKL_NUM_THREADS` au démarrage | **Élevé** (OCR + NER multicœur) | **Quasi nul** | inchangée |
| **H2** | Rastérisation frozen → `ThreadPoolExecutor` (fitz/PIL/pyzbar libèrent le GIL → vrai multicœur, sans relance exe) | Élevé (docs natifs multi-pages) | Faible | inchangée |
| **H3** | OCR docTR en **batch** (`model([img1,img2,…])` au lieu d'1 page/appel) | Moyen-élevé (scannés) | Faible-moyen | inchangée (même modèle) |
| **H4** | **Timings par étape** (logging extract/OCR/NER/raster/save) | — (mesure) | Nul | inchangée |
**Non recommandé sans précaution** : baisser le DPI OCR (300→200). Gain réel mais
**risque sur le leak score 100/100** (texte manqué = fuite). À écarter du hotfix MVP.
## Pourquoi H1 et H2 sont sûrs vis-à-vis du leak
- Ils ne changent **ni la détection, ni les rectangles, ni le texte produit** — juste
le **nombre de cœurs** utilisés. La sortie est identique, seul le temps change.
- H2 : `_rasterize_page` ouvre déjà son propre `fitz.open()` par page (thread-safe
pour des Documents séparés). Aucun état partagé.
## Plan proposé (sans toucher la branche bêta tant que non validé)
1. **H4 d'abord** (timings) + **H1** → mesurer sur TON doc lent réel pour confirmer
quelle phase domine (raster vs OCR vs NER).
2. Selon la mesure : **H2** (si raster/natif) et/ou **H3** (si OCR/scanné).
3. Re-build EXE de test → tu mesures CPU/temps → si OK et **leak 100/100 + 98 tests
verts**, on intègre.
Je peux préparer ces patchs sur une **branche dédiée** (`fix/perf-mvp`, pas la branche
bêta) et te livrer un EXE de test. Dis-moi si tu veux que je code H1+H4 (les plus sûrs)
en premier pour une mesure réelle.
**Question** : ton doc de test lent était-il **scanné** (OCR) ou **natif** (texte) ?
Ça oriente direct H2 vs H3.
— Claude

78
docs/coordination/inbox/for-dom/2026-06-05_claude_pack-beta-build-report.md
View File

@@ -1,78 +0,0 @@
---
from: claude
to: dom
date: 2026-06-05T12:35:00+02:00
topic: pack-beta-build-report
status: done
references:
- file: docs/coordination/inbox/for-claude/2026-06-05_10-55_dom-via-codex_rebuild-beta.md
- commit: 15f73f8
---
# Rapport — Rebuild v11 + pack bêta
Ordre de marche Dom (via Codex) exécuté. Synthèse C-BETA-1 → C-BETA-4.
## C-BETA-1 — Hygiène finale repo ✅
- `graphify-out/` gitignoré (artefacts knowledge graph générés).
- Messages coordination 2026-06-05 commités.
- `docs/rapport-analyse-campagne-gui-2026-04-21.md` commité (synthétique, sans PII).
- Commit `15f73f8`.
## C-BETA-2 — Validation pré-build ✅ GO
Double validation (la mienne en local + T-O de Qwen) → **GO**, 0 NO-GO :
- Mode admin OFF par défaut (`.admin` absent, `ANON_ADMIN` non défini).
- VLM/Ollama masqué en non-admin (`Pseudonymisation_Gui_V5.py:88`).
- Quarantaine `0o700` (dir) / `0o600` (fichiers).
- Aucune PII dans les chemins packagés.
- Aucun chemin absolu / secret dans les fichiers embarqués (`$PfxPassword` =
paramètre runtime, pas un secret stocké).
- D-11 / D-13 / D-14 cohérents.
## ⚠️ Incident résolu — machine de build désynchronisée
La machine `192.168.1.11` était sur `main` (`0124457`) avec **1961 lignes de WIP
non commité divergent** (GUI v6 +1250, core, installer, splash) — ancêtre de notre
branche mais 52 commits en retard, et conflit potentiel avec les fixes leak/RGPD.
Décision Dom : **sauvegarde + repart propre**. Réalisé :
1. WIP Windows sauvegardé → branche `backup/windows-wip-2026-06-05` (commit `b8c9c41`,
27 fichiers, 4626+/773-). **Rien perdu, tout récupérable.**
2. `feature/q1-quarantine-mvp` (`15f73f8`) poussée sur Gitea (serveur local, accord Dom).
3. Checkout propre sur la machine de build → arbre = code validé GO.
4. `build_info.py` confirme : **feature/q1-quarantine-mvp / 15f73f8**.
## C-BETA-3 — Rebuild v11 ✅
- Build via Planificateur de tâches Windows (`schtasks BuildV11`) — `BUILD_EXIT_CODE=0`.
- Modèle ONNX custom présent (440 455 750 octets), embarqué dans l'EXE.
- Durée ~4 min (12:24 → 12:28).
- **EXE** : `dist\Anonymisation.exe` — **730 543 861 octets (696.7 Mo)**.
- **Non signé** (conforme D-3 — procédure SmartScreen fournie).
- Installateur Inno Setup **non produit** (Inno Setup absent de la machine ;
`-SkipInstaller`). L'EXE est auto-suffisant (D-11). Voir « Reste à décider ».
## C-BETA-4 — Pack bêta ✅
Archive : `release\Anonymisation-Windows.zip` (~728 Mo). Contenu (0 PII) :
- `Anonymisation.exe`
- `README.txt` (infos build)
- `PROCEDURE-SmartScreen.txt` (déblocage Windows + SmartScreen/Defender)
- `BETA-FEEDBACK.txt` (quoi tester, comment remonter, **règle : jamais de doc source réel**)
Exclus du pack (vérifié) : `pdf_natif/`, sorties pseudonymisées, `.admin`,
`.claude/`, `.codex-loop/`, `.qwen/`, logs, caches, tests, secrets.
### Empreintes (release\SHA256SUMS.txt)
```
Anonymisation.exe 80A740DA6D576FBB37C818944054353D8C03F42AC6CD238D4E941A793F629DF9
Anonymisation-Windows.zip E22F8264DB124A8A5FF95CD610190824304E0CAF05C607C9E3C11BA7C7A2A8A2
```
## Reste à décider (Dom)
1. **Diffusion OwnCloud** : pack prêt sur `192.168.1.11:C:\Users\dom\ai\anonymisation\release\`.
Je n'ai **pas** uploadé (action sortante — j'attends ton accord + le canal).
2. **Installateur Inno Setup** : si tu veux le `.exe` Setup en plus du ZIP, il faut
installer Inno Setup sur la machine (`scripts\install_inno_setup_build_dep.ps1`)
puis rebuilder sans `-SkipInstaller`. Pour une bêta, le ZIP suffit (D-11).
3. **WIP Windows sauvegardé** (`backup/windows-wip-2026-06-05`) : à réintégrer plus
tard (GUI v6 ?) — à arbitrer hors MVP.
— Claude

46
docs/coordination/inbox/for-dom/2026-06-05_claude_package-beta-installateur-maj.md
View File

@@ -1,46 +0,0 @@
---
from: claude
to: dom
date: 2026-06-05T18:20:00+02:00
topic: package-beta-installateur-maj
status: done
references:
- file: docs/coordination/inbox/for-dom/2026-06-05_claude_pack-beta-build-report.md
- decision: docs/coordination/decisions/2026-06-05_dom_d16-test-windows-avant-diffusion.md
---
# Rapport package bêta — MISE À JOUR (installateur ajouté)
Suite à ton GO, l'installateur Inno Setup a été produit (étapes D-16 §1-4).
## Installateur produit ✅
- Inno Setup **déjà présent** (chemin user `%LOCALAPPDATA%\Programs\Inno Setup 6\`) —
pas besoin de l'installer. (Mon check initial cherchait dans `Program Files`, d'où
le « absent » précédent.)
- Build via `build_windows_installer_only.ps1` (depuis l'EXE existant, **pas de
rebuild**) — `INSTALLER_EXIT_CODE=0`.
- **`release\Anonymisation-Setup.exe`** — **729 576 700 octets (695.8 Mo)**, langue FR.
- Non signé (conforme D-3).
## Artefacts finaux (`192.168.1.11:…\release\`)
| Fichier | Taille | SHA-256 |
|---|---|---|
| `Anonymisation.exe` | 696.7 Mo | `80A740DA…F629DF9` |
| `Anonymisation-Windows.zip` | 728 Mo | `E22F8264…A8A2` |
| `Anonymisation-Setup.exe` | 695.8 Mo | `12D9D6A8…663DC` |
(Manifeste complet : `release\SHA256SUMS.txt`.)
Tout est issu de `feature/q1-quarantine-mvp @ 15f73f8` (leak 100/100, validé GO).
## ⏸️ Reste : diffusion OwnCloud — j'ai besoin du canal
Conformément à D-16, je n'ai **rien uploadé**. Tu m'as donné le GO mais pas le
**dossier/URL OwnCloud** de dépôt. Dis-moi où déposer (ZIP seul ? ou ZIP + Setup +
SHA256SUMS ?) et je m'en charge. Sinon le pack reste prêt en local.
## Recommandation diffusion
Pour le bêta-testeur, je suggère de livrer **soit le ZIP soit le Setup**, pas les deux
(évite la confusion), + `SHA256SUMS.txt`. Le ZIP (EXE portable + docs) est le plus
simple ; le Setup ajoute un raccourci menu Démarrer mais demande un « installer ».
— Claude

127
docs/coordination/inbox/for-dom/2026-06-05_claude_plan-v11-5-parallele.md
View File

@@ -1,127 +0,0 @@
---
from: claude
to: dom
date: 2026-06-05T18:10:00+02:00
topic: plan-v11-5-parallele
status: open
priority: high
references:
- decision: docs/coordination/decisions/2026-06-05_dom_d17-v11-5-chantiers-paralleles.md
- decision: docs/coordination/decisions/2026-06-05_dom_d16-test-windows-avant-diffusion.md
- decision: docs/coordination/decisions/2026-06-02_dom_d14-plateforme-licence-architecture.md
- decision: docs/coordination/decisions/2026-06-02_dom_d13-partial-scope.md
---
# Plan v11.5 — préparation parallèle (3 chantiers)
Réponse au cap D-17. **Planification uniquement** — gel bêta respecté : aucun code
packagé bêta modifié, aucune refonte sur la branche de livraison.
## 0. ⚠️ Action de sécurité PRIORITAIRE (à faire maintenant, indépendante du gel)
**Le WIP Windows sauvegardé (`backup/windows-wip-2026-06-05`, commit `b8c9c41`,
GUI v6 +1250 lignes) n'existe QUE sur le disque de `192.168.1.11`.** Il n'est ni
sur Linux ni sur Gitea. Si la machine tombe, **on perd la base de la GUI v6**.
→ **Recommandation : pousser cette branche backup sur Gitea** (serveur local) dès
ton accord. C'est non destructif, hors périmètre bêta (branche séparée), et ça
sécurise le point d'entrée de l'Agent A. Sans ça, tout le chantier GUI v6 repose
sur un seul disque.
## 1. Ce qui peut démarrer TOUT DE SUITE (lecture / planification, sans GO bêta)
Tout ce tableau est de la lecture + des docs déposés en `inbox/for-dom/`. Zéro
modification de code de livraison.
| Agent | Démarrable maintenant | Livrable (doc) |
|---|---|---|
| A — GUI v6 | Inventaire `Pseudonymisation_Gui_V5.py` + `docs/ui_mockup_v6.html` + diff du WIP backup | `for-dom/…_planA_gui-v6-archi.md` |
| B — D-13 complet | Inventaire des réglages à protéger (déjà listés dans D-13) + matrice admin | `for-dom/…_planB_d13-complet.md` |
| C — Licence | Archi serveur + `license.py` (D-14 déjà cadré) — conception, pas de déploiement | `for-dom/…_planC_licence.md` |
| D — Intégration | Frontières fichiers + ordre de merge + critères d'acceptation | `for-dom/…_planD_integration.md` |
## 2. Ce qui ATTEND le GO bêta (D-16)
- **Tout codage** sur les fichiers du périmètre bêta : `anonymizer_core_refactored_onnx.py`,
`quarantine.py`, `Pseudonymisation_Gui_V5.py`, `launcher.py`, le `.spec`, `admin_mode.py`.
- **Toute branche v11.5** créée à partir de la branche de livraison.
- Le **repackaging installateur** (Inno Setup) — déjà gelé par D-16.
- La **réintégration du WIP GUI v6** dans une branche de travail.
Raison : tant que Dom teste le pack v11 et peut demander un **hotfix MVP** sur
`feature/q1-quarantine-mvp`, on ne doit pas faire diverger cette branche ni mélanger
hotfix et v11.5.
## 3. Qui touche quels fichiers (frontières anti-collision — Agent D)
| Agent | Fichiers/zones PROPRES (création ou refonte) | Ne touche PAS |
|---|---|---|
| A — GUI v6 | nouveau `Pseudonymisation_Gui_V6.py`, `gui_v6/` (nouveau package), assets v6 | le moteur core, quarantine, license |
| B — D-13 | `admin_mode.py` (extension), `gui_v6/` sections « avancé » (avec A), `config_defaults.py` | core détection |
| C — Licence | nouveau `license.py`, nouveau repo/dossier `platform/` (serveur), clé publique embarquée | GUI, core |
| D — Intégration | docs de merge, CI, `tests/` (structure) | code applicatif |
**Zone de contact A↔B** : les écrans « Paramètres avancés / Profils techniques »
de la GUI v6 sont co-conçus (B définit les règles admin/non-admin, A les écrans).
→ contrat écrit entre A et B avant tout code.
**Zone de contact A↔C** : la GUI v6 affichera l'état licence (bannière, expiration).
→ A réserve un emplacement UI, C fournit l'API `license.py` (statut/expiration).
## 4. Comment éviter de perdre le WIP Windows sauvegardé
1. **Pousser `backup/windows-wip-2026-06-05` sur Gitea** (section 0) — survie hors disque unique.
2. **Produire un diff lisible** du WIP vs base (`git diff 0124457..b8c9c41 -- Pseudonymisation_Gui_V5.py`)
→ c'est la matière première de l'Agent A (les +1250 lignes GUI v6 déjà écrites).
3. **Ne PAS réintégrer le WIP par merge brut** dans la branche de livraison : le WIP
part de `0124457` (52 commits avant `15f73f8`) et entre en conflit avec les fixes
leak/RGPD/admin. La GUI v6 sera **réécrite proprement** (`Pseudonymisation_Gui_V6.py`
neuf) en s'appuyant sur le WIP comme **référence**, pas comme base à merger.
4. **Tag de sécurité** sur le commit backup pour qu'il ne soit jamais gc.
## 5. Tests qui devront valider v11.5
| Chantier | Tests attendus |
|---|---|
| Non-régression moteur | **La suite `tests/unit` (98 passed) doit rester verte** — la GUI v6 ne doit RIEN changer au moteur. Garde-fou n°1. |
| GUI v6 (A) | Tests `gui_batch_paths` / `manual_masking` conservés ; smoke test lancement + workflow principal ; contrat moteur (mêmes entrées/sorties que v5). |
| D-13 (B) | Tests matrice admin/non-admin : chaque réglage protégé caché/désactivé en non-admin ; `admin_required` lève bien ; sauvegarde config sensible bloquée en non-admin. |
| Licence (C) | Tests `license.py` : vérif signature RSA-PSS (valide/falsifiée), expiration, grace period 15 j, offline 30 j, révocation au check. Tests serveur : activation poste, 1 licence = 1 machine_id. |
| Intégration (D) | Audit qualité `evaluate_quality.py` ≥ baseline (98.5) ; leak score 100/100 inchangé ; build EXE v11.5 reproductible. |
**Principe directeur** : v11.5 = refonte UI + ajouts périphériques (licence, admin).
**Le moteur de détection ne bouge pas** → le leak score 100/100 et les 98 tests sont
le filet de sécurité non négociable.
## 6. Ordre de merge proposé (Agent D)
1. **Base** : repartir de la branche de livraison **figée après GO bêta** (= `15f73f8`
ou le hotfix éventuel), créer `feature/v11-5`.
2. **C (licence)** en premier — le plus isolé (`license.py` + `platform/` neufs), zéro
conflit moteur/GUI. Mergeable indépendamment.
3. **A (GUI v6)** ensuite — gros morceau, fichier neuf `Pseudonymisation_Gui_V6.py`.
4. **B (D-13)** se greffe sur A (sections avancées de la GUI v6) — merge après A.
5. **Validation D** : qualité + tests + build, puis bascule v6 par défaut.
## 7. Risques principaux
| Risque | Mitigation |
|---|---|
| WIP GUI v6 perdu (disque unique) | Push backup sur Gitea **maintenant** (section 0) |
| GUI v6 casse le moteur | Contrat moteur strict + 98 tests verts obligatoires |
| Collision A/B sur écrans avancés | Contrat écrit A↔B avant code |
| Mélange hotfix MVP / v11.5 | Gel respecté ; v11.5 sur branche dédiée créée APRÈS GO bêta |
| Licence : clé privée RSA | Jamais dans le repo client ; côté serveur OVH uniquement (D-14) |
| Plateforme = gros effort (~50h) | Phasage D-14 respecté : 1.1 (client, ~12h) avant 1.2 (serveur, ~50h) |
## 8. Ce que je propose de démarrer dès ton accord
- **Immédiat (sécurité)** : push `backup/windows-wip-2026-06-05` sur Gitea + tag + diff GUI v6.
- **Planification (sans GO bêta)** : lancer les 4 sous-plans A/B/C/D en agents parallèles
(lecture seule + docs), livrés en `inbox/for-dom/`.
- **En attente du GO bêta** : tout codage.
Dis-moi si tu valides ce découpage, et notamment le point 0 (push backup) que je
considère urgent indépendamment du reste.
— Claude

320
docs/coordination/inbox/for-dom/2026-06-05_claude_planA_gui-v6-archi.md
View File

@@ -1,320 +0,0 @@
---
from: claude (Agent A)
to: dom
date: 2026-06-05T19:30:00+02:00
topic: planA-gui-v6-architecture
status: open
priority: high
nature: PLANIFICATION (lecture seule — aucun code modifié, aucun commit)
references:
- plan: docs/coordination/inbox/for-dom/2026-06-05_claude_plan-v11-5-parallele.md (57aa0f0)
- mockup: docs/ui_mockup_v6.html (validé 2026-05-06)
- wip: backup/windows-wip-2026-06-05 (b8c9c41)
- base_wip: 0124457
gardefou: "98 tests unit doivent rester verts — le moteur ne bouge pas"
---
# Plan A — Architecture GUI v6
Sous-plan détaillé de la transposition GUI v6. **Document de conception
uniquement.** Aucun fichier de code n'a été touché.
## 0. Constat majeur (corrige une hypothèse du plan v11.5)
Le plan v11.5 décrit le WIP `backup/windows-wip-2026-06-05` comme « +1250 lignes
de GUI v6 ». **Vérification faite, ce n'est pas une GUI v6 :**
- Le diff `0124457..b8c9c41` (+1148/-102) ajoute **profils métier, masques PDF
réutilisables, paramètres avancés** — features qui sont **déjà toutes dans le
`Pseudonymisation_Gui_V5.py` actuel** (v5.5).
- Le WIP est en **tkinter pur** : aucune trace de `customtkinter`/`ctk`/`CTk`.
- Le fichier de travail actuel est en fait **en avance** sur le WIP : `git diff
backup/windows-wip-2026-06-05 -- Pseudonymisation_Gui_V5.py` = seulement
24 insertions / 5 suppressions, et ce delta = les fixes D-11 (VLM masqué hors
admin), D-13 (tag « MODE ADMIN » dans le titre) et RGPD (`CHCB`→`CHUXX`,
`chcb_strict`→`chuxx_strict`) que le WIP **n'a pas encore**.
**Conséquences pour l'Agent A :**
1. Le WIP n'est **pas** une base de départ v6 — c'est l'ancêtre de la v5.5 actuelle.
La « matière première » réelle de la GUI v6 = le **mockup HTML v6** + la **v5.5
actuelle** (logique métier déjà écrite et fonctionnelle).
2. La GUI v6 = **réécriture de la couche présentation** (tkinter → customtkinter,
2 onglets → 3 onglets + sous-onglets) **en réutilisant telle quelle toute la
logique métier** (worker, profils, masques, params, contrat moteur).
3. La sauvegarde Gitea (section 0 du plan v11.5) est **déjà faite** : la branche
existe sur `remotes/gitea/backup/windows-wip-2026-06-05`. Risque « disque
unique » levé. ⚠️ reste à vérifier : que la v5.5 *actuelle* (en avance sur le
WIP) soit elle aussi sauvegardée hors disque avant de démarrer le codage v6.
`customtkinter` **n'est ni installé dans `.venv` ni listé dans les requirements**
→ à ajouter comme dépendance v11.5 (impact PyInstaller à anticiper avec Agent D).
---
## 1. Inventaire de l'existant
### 1.1 GUI v5.5 (`Pseudonymisation_Gui_V5.py`, 2894 lignes)
**Stack :** tkinter + ttk, thème `sv_ttk` optionnel (fallback `clam`), PIL pour
logo/icônes (dégradation si absent). Palette magenta/pêche dérivée du logo
(`CLR_PRIMARY=#E91E63`, etc.). Onglets *custom* faits main (pas `ttk.Notebook`).
**Structure actuelle — 3 onglets plats :**
| Onglet | Contenu |
|---|---|
| **Anonymisation** | Étape 1 (choisir dossier OU fichier) → Étape 2 (info formats : raster PDF + .txt) → checkbox VLM (si admin) → bouton Lancer/Arrêter → progress → résultats (3 cartes stats + badge fuites + perf + ouvrir dossier + journal repliable) |
| **Paramètres** | Whitelist / Blacklist / Stop-words (3 listes éditables) ; masques PDF réutilisables (ouvrir éditeur, combo modèle, dossier modèles) ; export/import JSON ; sauvegarder |
| **Profils** | Profil actif (combo + actualiser), description éditable, flags (masque obligatoire, désactiver VLM), masque mémorisé, actions (nouveau/enregistrer/renommer/défaut/supprimer), panneau résumé |
**Briques techniques déjà en place (à conserver intégralement) :**
- `App` (classe monolithique), `UiMessage`/`MsgType` (file worker→UI), `ToolTip`.
- Worker threadé (`_run` → `threading.Thread(_worker)`), pompe `_pump_logs`
(`root.after(60)`).
- Détection police/dark-mode, résolution assets/config compatible PyInstaller
(`_asset`, `_app_dir`, `_exe_dir`, `_resolve_config`, `_resolve_profiles_config`).
- 4 managers NER chargés en interne (ONNX, EDS-Pseudo, CamemBERT, VLM optionnel).
- Mode admin (`admin_mode.is_admin`) : masque le VLM + annote le titre.
### 1.2 Mockup v6 (`docs/ui_mockup_v6.html`, 898 lignes) — cible UX validée
**3 onglets principaux :**
1. **📄 Utilisation** — dropzone glisser-déposer + liste fichiers, bouton Go,
barre progression « Fichier 1/3 », 4 cartes résultats (Documents, PII masqués,
Durée, Qualité), bandeau « Aucune fuite détectée », journal.
2. **⚙️ Configuration** — **4 sous-onglets** :
- **⚙️ Réglages** : catégories PII activables (Noms, Dates naissance,
Établissements, Adresses/CP, N° sécu, Tél/email, N° mutuelle) + choix moteur
(CamemBERT-bio RAPIDE / EDS-Pseudo PRÉCIS / GLiNER OPTIONNEL).
- **🎭 Masquage** : couleur rectangles, libellés placeholders par type
(NOM, Date naissance, Établissement…), marges/coins arrondis, **éditeur de
masques PDF intégré** (canvas, zoom, DPI, compteur masques, template).
- **🔄 Partage** : export/import config (whitelist/blacklist).
- **🛡️ Règles** : table de règles personnalisées (Label, Type, Cible→Résultat,
Statut) + simulateur (texte test → sortie).
3. **ℹ️ À propos** — version, thème, build.
**Thèmes :** sélecteur (cf. roadmap mémoire : 4 thèmes).
### 1.3 WIP backup (`b8c9c41`)
Ancêtre de la v5.5 (cf. §0). Sert de **référence de lecture** pour les libellés
français et l'organisation des écrans Profils/Masques, **pas de base à merger**.
---
## 2. Architecture cible GUI v6 (customtkinter)
### 2.1 Principe directeur
**Séparer présentation et logique.** La v5.5 mélange les deux dans une classe
`App` de 2894 lignes. La v6 extrait la logique métier (déjà testée, déjà
fonctionnelle) dans un *contrôleur* réutilisable, et réécrit uniquement la
couche vue en customtkinter selon le mockup.
### 2.2 Arborescence proposée
```
Pseudonymisation_Gui_V6.py # point d'entrée : main(), bootstrap ctk, App
gui_v6/
├── __init__.py
├── app.py # AppV6(ctk.CTk) : shell, header, nav 3 onglets
├── theme.py # palette + 4 thèmes ctk + tokens (couleurs/polices)
├── widgets/ # composants réutilisables
│ ├── dropzone.py # zone glisser-déposer + liste fichiers
│ ├── stat_card.py # carte statistique résultat
│ ├── phrase_list.py # liste éditable (whitelist/blacklist/stopwords)
│ ├── tooltip.py # ToolTip (porté depuis v5)
│ └── tabview.py # onglets/sous-onglets stylés
├── tabs/
│ ├── tab_use.py # onglet Utilisation
│ ├── tab_config.py # onglet Configuration (host des 4 sous-onglets)
│ ├── config_reglages.py # sous-onglet Réglages (PII + moteur)
│ ├── config_masquage.py # sous-onglet Masquage + éditeur masques intégré
│ ├── config_partage.py # sous-onglet Partage (export/import)
│ ├── config_regles.py # sous-onglet Règles + simulateur [zone B]
│ └── tab_about.py # onglet À propos + état licence [zone C]
├── controller.py # AnonymController : SEULE porte vers le moteur
├── worker.py # worker threadé + file UiMessage (porté de v5)
└── assets_v6/ # logo, icônes (réutilise assets/ existant)
```
**Note de packaging :** `gui_v6/` est un package neuf (frontière propre Agent A,
cf. plan v11.5 §3). Aucun fichier du périmètre bêta n'est modifié. Ajouter
`gui_v6/` et `customtkinter` au `.spec` PyInstaller = tâche post-GO bêta (Agent D).
### 2.3 Mapping mockup → modules
| Onglet mockup | Module v6 | Réutilise (v5.5) |
|---|---|---|
| Utilisation | `tabs/tab_use.py` | `_run`/`_worker`, stats, badge fuites, journal |
| Config → Réglages | `tabs/config_reglages.py` | sélection moteur NER, seuils (nouveau : cases PII) |
| Config → Masquage | `tabs/config_masquage.py` | combo masques + `pdf_mask_designer` |
| Config → Partage | `tabs/config_partage.py` | `_export_params`/`_import_params` |
| Config → Règles | `tabs/config_regles.py` | nouveau (zone B) |
| À propos | `tabs/tab_about.py` | `_version_long`, build_info (+ licence zone C) |
| (Profils v5) | intégré dans Config ou onglet dédié | tout l'appareil `profile_defaults` |
**Décision à trancher avec Dom :** le mockup v6 n'a **pas** d'onglet « Profils »
distinct (v5 en a un). Deux options : (a) garder un 4ᵉ onglet principal
« Profils », ou (b) intégrer la sélection de profil en bandeau dans Utilisation +
gestion dans Config. Recommandation : **option (b)** pour coller au mockup validé,
avec un sélecteur de profil en haut de l'onglet Utilisation.
---
## 3. Liste des écrans / workflows
**Workflow principal (Utilisation) :**
1. Glisser-déposer OU parcourir (dossier/fichier) → liste fichiers.
2. (option) choisir profil métier + masque manuel.
3. Lancer → progress par fichier → cartes résultats + badge fuites → ouvrir dossier.
4. Arrêter en cours possible ; journal détaillé repliable.
**Workflows Configuration :**
- Réglages : activer/désactiver catégories PII, choisir moteur NER.
- Masquage : couleur/placeholders/marges + dessiner et enregistrer un masque PDF.
- Partage : exporter config (JSON pour email) / importer config reçue.
- Règles : créer une règle perso (cible→résultat), tester via simulateur.
**Workflows transverses :** profils (CRUD + défaut), thème (4 thèmes),
état licence (bandeau).
---
## 4. Contrat minimal avec le moteur (GARDE-FOU — le moteur ne bouge pas)
La GUI v6 consomme **exactement les mêmes API que la v5.5**. Aucune signature
moteur ne change ⇒ les 98 tests unit restent verts. Tout passe par
`gui_v6/controller.py` (point d'entrée unique vers le backend).
### 4.1 Fonction moteur centrale (à appeler à l'identique)
```python
# anonymizer_core_refactored_onnx.py
process_document(doc_path, out_dir, **kwargs) -> Dict[str, str] # multi-formats
process_pdf(pdf_path, out_dir, ...) -> Dict[str, str] # fallback PDF
```
kwargs effectivement passés par le worker v5 (à reproduire tels quels) :
`make_vector_redaction=False`, `also_make_raster_burn=True`, `config_path`,
`use_hf`, `ner_manager`, `ner_thresholds`, `ogc_label`, `vlm_manager`,
`camembert_manager`. Sélection via `getattr(core, 'process_document', None) or
core.process_pdf` + clé `doc_path`/`pdf_path`. **Retour = dict chemins de sortie**
(clés `audit`, etc.) — la v6 lit ces clés à l'identique (comptage audit, badge fuites).
### 4.2 Managers NER (instanciés et chargés comme en v5)
- `ner_manager_onnx.NerModelManager(cache_dir)` + `NerThresholds` — `.is_loaded()`,
`.load(model_id)`, `.models_catalog()`.
- `eds_pseudo_manager.EdsPseudoManager(cache_dir)` — idem.
- `camembert_ner_manager.CamembertNerManager()` — `.is_loaded()`, `.load()`.
- `vlm_manager.VlmManager` / `VlmConfig` — **masqué hors admin** (D-11),
`.is_loaded()`.
### 4.3 Modules support (réutilisés sans modification)
- `config_defaults` : `load_effective_dictionaries_dict`, `load_effective_param_lists`,
`deep_merge_dict`, `read_*_text`, `ensure_runtime_dictionaries_config`.
- `gui_batch_paths` : `list_supported_documents`, `build_batch_output_dir`,
`iter_pseudonymized_texts`.
- `manual_masking` : `ensure_mask_templates_dir`, `list_mask_templates`,
`mask_template_label`, `resolve_manual_mask_pdf`, `append_jsonl_file`.
- `profile_defaults` : `list_effective_profiles`, `save_runtime_profile`,
`delete_runtime_profile`, `set_runtime_default_profile`, `get_default_profile_key`,
`ensure_runtime_profiles_config`.
- `pdf_mask_designer` : `Template`, `load_template_yaml`, `apply_template_vector`,
`MaskDesignerApp` (intégrer dans le sous-onglet Masquage plutôt que Toplevel).
- `format_converter.SUPPORTED_EXTENSIONS`.
- `admin_mode.is_admin` / `admin_required`.
- `build_info` (BUILD_DATE/COMMIT/BRANCH).
### 4.4 Construction de la config par profil (logique worker à porter telle quelle)
Le worker v5 fabrique un **YAML temporaire** fusionnant config effective +
`param_lists` du profil + overlay, puis le passe en `config_path`. Cette mécanique
(`deep_merge_dict` + `tempfile.mkstemp` à côté de la config) **est reportée à
l'identique** dans `gui_v6/worker.py`. Le moteur reçoit donc le même intrant
qu'aujourd'hui → sortie inchangée → audit qualité ≥ baseline.
**Règle d'or :** `controller.py`/`worker.py` ne contiennent **aucune** logique de
détection. Ils orchestrent. Toute tentation de « pré-traiter » le texte côté GUI
= violation du garde-fou.
---
## 5. Stratégie de migration progressive (v5 → v6 sans casser)
1. **Cohabitation.** v6 = fichier neuf `Pseudonymisation_Gui_V6.py` + package
`gui_v6/`. La v5.5 reste l'entrée par défaut tant que la v6 n'a pas passé le
smoke test et l'audit qualité. Bascule par défaut = dernière étape (Agent D).
2. **Extraction d'abord, vue ensuite.** Étape 1 : extraire worker + contrôleur
depuis la v5.5 **sans changer de toolkit** (refactor pur, testable). Étape 2 :
réécrire la vue en customtkinter par-dessus ce contrôleur. Ça découple le risque
« moteur » du risque « UI ».
3. **Parité fonctionnelle par onglet.** Migrer Utilisation → Configuration →
Profils dans cet ordre ; à chaque onglet, vérifier que le workflow produit les
**mêmes sorties** que la v5 sur un même lot (diff des dossiers `anonymise/`).
4. **Tests conservés.** `gui_batch_paths` / `manual_masking` ont déjà leurs tests :
ne pas y toucher. Ajouter un **smoke test de lancement** v6 + un test de
**non-régression du contrat** (mocked managers, vérifier que le worker appelle
`process_document` avec exactement les kwargs attendus).
5. **Garde-fou n°1 permanent.** `pytest tests/unit` (98) doit rester vert à chaque
commit v6. Si un test moteur casse ⇒ la v6 a franchi sa frontière, rollback.
6. **Rétro-port RGPD/admin.** La v6 doit naître au niveau de la v5.5 **actuelle**
(CHUXX, admin tag, VLM masqué), pas du WIP `b8c9c41` qui est en retard.
---
## 6. Zones de contact
### 6.1 Avec Agent B (D-13 — Paramètres avancés / Profils techniques)
- **Fichiers partagés :** sous-onglets « avancés » de Config (`config_reglages.py`,
`config_regles.py`) + onglet/bandeau Profils.
- **Contrat attendu de B (avant que A code ces écrans) :**
- liste des réglages **protégés admin** (cachés/désactivés en non-admin) ;
- API `admin_mode.admin_required(feature)` pour verrouiller une action ;
- règle de sauvegarde : config sensible **bloquée** en non-admin.
- **A fournit :** des conteneurs/onglets prêts où B injecte ses contrôles +
un helper `is_admin()` déjà câblé dans le shell (titre annoté, sections
masquées). A réserve le sous-onglet « Règles » comme zone B.
- **À écrire :** contrat A↔B avant tout code (plan v11.5 §3).
### 6.2 Avec Agent C (Licence — affichage état)
- **Emplacement UI réservé par A :** bandeau d'état en haut du shell (sous le
header) + bloc dédié dans l'onglet **À propos** (statut, expiration, grace).
- **API attendue de C (`license.py`, à créer) :** une fonction de statut du type
`get_license_status() -> {valid, expires_at, grace_days, machine_id, message}`
que A appelle au démarrage et affiche (vert/orange/rouge). A **n'implémente
aucune crypto** ; A consomme le statut.
- **Dégradation :** si `license.py` absent (dev), le bandeau s'efface
silencieusement (même pattern que `admin_mode`/`vlm_manager` en try/except).
---
## 7. Risques spécifiques GUI v6 + mitigations
| Risque | Mitigation |
|---|---|
| customtkinter absent du venv/spec | Ajouter dépendance + tester build EXE tôt avec Agent D |
| Éditeur de masques (`MaskDesignerApp`) conçu pour Toplevel tk | L'intégrer en frame dans le sous-onglet Masquage, ou le garder en fenêtre détachée v1 |
| Glisser-déposer natif (mockup) absent de tkinter pur | `tkinterdnd2` ou fallback « Parcourir » ; à valider avec Dom |
| Régression silencieuse moteur via worker | Test contrat (kwargs `process_document`) + 98 tests verts |
| v6 part du WIP en retard (CHCB/admin) | Naître de la v5.5 actuelle (§5.6) |
| Dérive de portée (refonte logique) | controller/worker = orchestration pure, zéro détection |
---
## Résumé (5-8 lignes)
Le « WIP +1250 lignes » n'est **pas** une GUI v6 : c'est l'ancêtre tkinter de la
v5.5 actuelle (profils/masques/params déjà livrés), et la v5.5 est même **en
avance** dessus (fixes CHUXX/admin/VLM). La vraie matière première v6 = le
**mockup HTML validé** + la **logique métier v5.5** à réutiliser telle quelle.
Architecture cible : `Pseudonymisation_Gui_V6.py` + package `gui_v6/`
(customtkinter, **à ajouter au venv/spec**), 3 onglets (Utilisation / Configuration
à 4 sous-onglets / À propos), éditeur de masques intégré, 4 thèmes. **Garde-fou
n°1 :** tout passe par `gui_v6/controller.py`+`worker.py` qui appellent
`process_document(...)` avec les **mêmes kwargs** qu'aujourd'hui → le moteur ne
bouge pas, les 98 tests unit restent verts. Migration progressive : extraire
contrôleur d'abord, réécrire la vue ensuite, cohabitation v5/v6, bascule par
défaut en dernier (Agent D). Zones de contact : **B** sur les sous-onglets
Réglages/Règles + Profils (contrat admin écrit avant code), **C** sur le bandeau
d'état + bloc À propos (A consomme `get_license_status()`, A n'implémente aucune
crypto).
— Claude (Agent A)

335
docs/coordination/inbox/for-dom/2026-06-05_claude_planB_d13-complet.md
View File

@@ -1,335 +0,0 @@
---
from: claude (Agent B)
to: dom
date: 2026-06-05T19:30:00+02:00
topic: planB-d13-complet
status: open
priority: high
scope: PLANIFICATION uniquement — lecture seule, aucun code modifié
references:
- plan: docs/coordination/inbox/for-dom/2026-06-05_claude_plan-v11-5-parallele.md (commit 57aa0f0)
- decision: docs/coordination/decisions/2026-06-02_dom_d13-partial-scope.md
- module: admin_mode.py
- gui: Pseudonymisation_Gui_V5.py (2893 lignes, v5.4)
---
# Plan B — D-13 complet : protection des réglages avancés en mode non-admin (GUI v6)
> **Périmètre.** Sous-plan du chantier v11.5 (cap D-17). Définit les **règles**
> admin / non-admin à appliquer dans la GUI v6 (customtkinter). Ne contient aucun
> code ; l'implémentation attend le GO bêta (D-16) et se fait dans `gui_v6/` +
> extension `admin_mode.py`. Les **écrans** des sections « avancé » sont co-conçus
> avec l'Agent A (voir § Zone de contact A↔B).
## 0. Rappel du modèle de menace D-13
Le mode admin n'est **pas** un contrôle d'accès cryptographique : c'est un
« verrou anti-distrait » (cf. docstring `admin_mode.py`). Activation par
`ANON_ADMIN=1` ou fichier `.admin`. Deux objectifs distincts, à ne pas confondre :
1. **Anti-leak RGPD** (critique) — empêcher l'envoi de données hors poste.
Déjà couvert par D-11 : VLM/Ollama **caché** en non-admin, et de toute façon
`VlmManager=None` quand le module est neutralisé.
2. **Anti-dégradation qualité** (important, périmètre v11.5) — empêcher le
bêta-testeur / utilisateur final de **casser la détection** en éditant des
stopwords, profils techniques, regex, ou d'**écraser des fichiers de config
de référence**. C'est l'objet de ce plan.
Conséquence : pour les réglages qui ne provoquent **pas** de fuite externe mais
peuvent **dégrader le masquage**, la bonne politique par défaut est
**griser/désactiver (visible mais verrouillé)** plutôt que **cacher**, pour rester
pédagogique. Exception : ce qui touche au leak externe se **cache**.
---
## 1. Inventaire exhaustif des réglages exposés
Source : balayage de `Pseudonymisation_Gui_V5.py`, `config/`, `config_defaults.py`,
`profile_defaults.py`.
### 1.A — Réglages UI (widgets actuels v5)
| # | Réglage | Widget v5 | Variable / méthode | Écrit dans |
|---|---|---|---|---|
| R1 | **Analyse visuelle VLM (Ollama)** | `Checkbutton` (l.769) | `self.use_vlm` / `_on_vlm_toggle` | aucun (runtime) |
| R2 | **Profil : « Désactiver le VLM »** | `Checkbutton` (l.1088) | `profile_force_disable_vlm_var` | `profiles.yml` |
| R3 | **Whitelist — phrases à NE PAS anonymiser** | `Listbox` + ajout/suppr (l.919) | `_wl_listbox` | `dictionnaires.yml` → `whitelist_phrases` |
| R4 | **Blacklist — mots à TOUJOURS masquer** | `Listbox` (l.928) | `_bl_listbox` | `dictionnaires.yml` → `blacklist.force_mask_terms` |
| R5 | **Stop-words additionnels** (ne jamais traiter comme nom) | `Listbox` (l.939) | `_sw_listbox` | `dictionnaires.yml` → `additional_stopwords` |
| R6 | **Profil actif** (sélection) | `Combobox` (l.1032) | `processing_profile_label_var` | lecture seule |
| R7 | **Profil : description** | `Entry` (l.1064) | `profile_description_var` | `profiles.yml` |
| R8 | **Profil : « Masque manuel obligatoire »** | `Checkbutton` (l.1077) | `profile_require_manual_mask_var` | `profiles.yml` |
| R9 | **Profil : masque PDF mémorisé** | `Combobox` (l.1109) | `manual_mask_template_var` | `profiles.yml` |
| R10 | **Créer / Renommer / Supprimer / Définir par défaut un profil** | Boutons (l.2040-2147) | `_create/_rename/_delete/_set_default_…profile` | `profiles.yml` |
| R11 | **Sauvegarder le profil courant** | Bouton (l.2147) | `_save_selected_processing_profile` | `profiles.yml` |
| R12 | **Masque manuel : template actif** (anonymisation) | `Combobox` (l.881) | `manual_mask_template_var` | runtime |
| R13 | **Éditeur de masques PDF** (designer) | Bouton (l.2306) | `_open_manual_mask_designer` | `config/mask_templates/` |
| R14 | **Sauvegarder les paramètres** (WL/BL/SW → YAML) | Bouton (l.2629) | `_save_params` → `_save_param_listboxes` | **`dictionnaires.yml` (écriture)** |
| R15 | **Exporter les paramètres** (→ JSON) | Bouton (l.2539) | `_export_params` | JSON sur disque (Bureau) |
| R16 | **Importer des paramètres** (JSON → listes) | Bouton (l.2596) | `_import_params` | listes en mémoire |
| R17 | **Dossier / fichier source** | sélecteur | `dir_var` / `_single_file` | runtime |
### 1.B — Réglages présents dans le **schéma de config** mais PAS exposés en UI v5
Importants à connaître car la GUI v6 pourrait vouloir les exposer (profils
techniques). Aujourd'hui chargés silencieusement (en-tête v5 : « Pas d'onglet
Avancé (NER + YAML chargés silencieusement) »).
| # | Réglage | Fichier / clé | Statut v5 | Sensibilité |
|---|---|---|---|---|
| S1 | **`regex_overrides`** (patterns + placeholders custom) | `dictionnaires.yml` → `regex_overrides[]` | non exposé UI | **technique sensible** (une mauvaise regex casse la détection ou plante) |
| S2 | **`blacklist.force_mask_regex`** | `dictionnaires.yml` | non exposé UI | technique sensible |
| S3 | **`whitelist.org_gpe_keep` / `sections_titres` / `noms_maj_excepts`** | `dictionnaires.yml` → `whitelist.*` | non exposé UI | technique sensible (peut désactiver le masquage d'établissements) |
| S4 | **`kv_labels_preserve`** | `dictionnaires.yml` | non exposé UI | technique sensible |
| S5 | **`flags.regex_engine` / `case_insensitive` / `unicode_word_boundaries`** | `dictionnaires.yml` → `flags` | non exposé UI | technique sensible |
| S6 | **`additional_villes_blacklist` / `additional_dpi_labels` / `additional_companion_blacklist`** | `dictionnaires.yml` | non exposé UI | modérée (qualité) |
| S7 | **`dictionaries_overlay`** par profil (surcharge YAML embarquée) | `profiles.yml` → `dictionaries_overlay` | partiellement (via BL profil) | **technique sensible** |
| S8 | **Choix du moteur NER** (GLiNER / CamemBERT-bio / EDS-Pseudo / ONNX) | aucun fichier UI ; chargé via `_auto_load_ner()` (l.473), managers l.437-439 | **non exposé** (silencieux) | **technique sensible** (désactiver un moteur dégrade le recall F1=0.963) |
| S9 | **Seuils NER** (`NerThresholds`) | `ner_manager_onnx.py` | non exposé UI | technique sensible |
| S10 | **Chemins config** (`cfg_path`, `profiles_path`, `MODELS_DIR`) | `DEFAULT_CFG`, `DEFAULT_PROFILES_CFG` | non exposé UI (pas de file picker) | sensible (réécriture d'un autre fichier) |
> Note : le **choix du moteur NER** (reporté à v11.5 selon D-13) n'a **aucune UI
> aujourd'hui**. L'exposer en v6 est une **création** d'écran, donc à protéger
> dès l'origine. Recommandation forte : **réservé admin**, et même en admin,
> exposer en lecture/diagnostic plutôt qu'en désactivation libre, pour ne pas
> permettre de couper un moteur et faire chuter le recall sans le vouloir.
### 1.C — Fichiers de config sensibles (cibles d'écriture)
| Fichier | Rôle | Écriture en v5 par | Politique non-admin |
|---|---|---|---|
| `config/dictionnaires.yml` | surcharge locale active (WL/BL/SW/regex) | R14 `_save_param_listboxes` | **bloquer l'écriture** |
| `config/dictionnaires.default.yml` | **source de vérité** | jamais (ne doit jamais l'être) | **bloquer (admin compris)** |
| `config/profiles.yml` | profils locaux | R10/R11 | **bloquer écriture** (lecture/sélection OK) |
| `config/profiles.default.yml` | source de vérité profils | jamais | **bloquer (admin compris)** |
| `config/admin_rules.yml` | règles d'admin candidates | (gouvernance) | **bloquer** |
| `config/mask_templates/`, `config/mask_templates` GUI | masques PDF | R13 designer | autorisé (non sensible PII) |
| Export JSON (Bureau) | échange par email | R15 | **autorisé** (sortie, pas d'écrasement config) |
---
## 2. Matrice admin / non-admin
Légende : **V** = visible, **É** = éditable, **S** = sauvegardable (peut écrire un fichier).
`—` = non applicable. `(cacher)` = absent de l'UI. `(grisé)` = visible mais désactivé.
| # | Réglage | non-admin V | non-admin É | non-admin S | admin V | admin É | admin S | Mode UI non-admin |
|---|---|:--:|:--:|:--:|:--:|:--:|:--:|---|
| R1 | VLM Ollama (case) | ❌ | ❌ | — | ✅ | ✅ | — | **cacher** (leak RGPD) |
| R2 | Profil « Désactiver VLM » | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ | **cacher** (lié VLM) |
| R3 | Whitelist phrases | ✅ | ❌ | ❌ | ✅ | ✅ | ✅ | **grisé** (lecture) |
| R4 | Blacklist force-mask | ✅ | ❌ | ❌ | ✅ | ✅ | ✅ | **grisé** (lecture) |
| R5 | Stop-words additionnels | ✅ | ❌ | ❌ | ✅ | ✅ | ✅ | **grisé** (lecture) |
| R6 | Profil actif (sélection) | ✅ | ✅ | — | ✅ | ✅ | — | **actif** (choisir un profil pré-validé est sûr) |
| R7 | Profil : description | ✅ | ❌ | ❌ | ✅ | ✅ | ✅ | **grisé** |
| R8 | Profil : masque manuel obligatoire | ✅ | ❌ | ❌ | ✅ | ✅ | ✅ | **grisé** |
| R9 | Profil : masque PDF mémorisé | ✅ | ❌ | ❌ | ✅ | ✅ | ✅ | **grisé** |
| R10 | Créer/Renommer/Suppr/Défaut profil | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ | **cacher** (écrit profiles.yml) |
| R11 | Sauvegarder le profil | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ | **cacher** |
| R12 | Masque manuel actif (anonymisation) | ✅ | ✅ | — | ✅ | ✅ | — | **actif** (sécurité, ajoute du masquage) |
| R13 | Éditeur masques PDF | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | **actif** (n'augmente jamais le leak) |
| R14 | Sauvegarder paramètres → YAML | ❌ | — | ❌ | ✅ | — | ✅ | **cacher** (écrit dictionnaires.yml) |
| R15 | Exporter paramètres (JSON) | ✅ | — | ✅ | ✅ | — | ✅ | **actif** (sortie d'échange, pas d'écrasement config) |
| R16 | Importer paramètres (JSON) | ✅ | ✅ | ❌ | ✅ | ✅ | ✅ | **actif en mémoire**, mais **R14 bloqué** → l'import reste sans effet persistant en non-admin (voir § 3.3) |
| R17 | Dossier / fichier source | ✅ | ✅ | — | ✅ | ✅ | — | **actif** (cœur métier) |
| S1 | `regex_overrides` (si exposé v6) | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ | **cacher** (profil technique) |
| S2 | `force_mask_regex` | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ | **cacher** |
| S3 | `whitelist.*` techniques | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ | **cacher** |
| S4 | `kv_labels_preserve` | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ | **cacher** |
| S5 | `flags.*` (regex_engine…) | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ | **cacher** |
| S6 | `additional_villes/dpi/companion` | ✅ | ❌ | ❌ | ✅ | ✅ | ✅ | **grisé** (qualité, lecture) |
| S7 | `dictionaries_overlay` profil | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ | **cacher** |
| S8 | Choix moteur NER | ✅ (diag) | ❌ | ❌ | ✅ | ✅* | ❌* | **grisé/diagnostic** ; *même admin : lecture conseillée (voir § 3.4) |
| S9 | Seuils NER | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ | **cacher** |
| S10 | Chemins config (file pickers) | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ | **cacher** (ne pas exposer en v6 hors admin) |
**Principe de lecture de la matrice** :
- **Cacher** = réglage *leak-sensible* (VLM) ou *technique avancé* (regex/profil
technique/moteur/seuils/chemins). Inutile et risqué de le montrer au bêta.
- **Griser** = réglage *qualité* visible à titre pédagogique (le bêta voit ce que
l'admin a configuré) mais non modifiable / non sauvegardable.
- **Actif** = réglage qui *ne peut qu'augmenter la sécurité* (ajouter du masquage :
masque manuel R12/R13) ou *cœur métier* (R6 sélection de profil validé, R17
source), ou *sortie sans écrasement* (R15 export).
---
## 3. Règles UI et règles de sauvegarde
### 3.1 — Cacher vs désactiver/griser (décision par catégorie)
| Catégorie | Politique non-admin | Justification |
|---|---|---|
| **Leak externe** (VLM, force_disable_vlm) | **Cacher** | Ne doit pas exister dans l'UI bêta (D-11). |
| **Technique avancé** (regex_overrides, force_mask_regex, whitelist.*, flags, kv_labels, dictionaries_overlay, seuils NER, chemins config) | **Cacher** | Bruit pour le bêta + casse silencieuse de la détection. Regrouper dans un onglet/section « Profils techniques » entièrement masquée hors admin. |
| **Qualité éditable** (WL/BL/SW, descriptions, flags profil, villes/dpi/companion) | **Griser (read-only)** | Pédagogique : le bêta voit la config sans pouvoir la dégrader. |
| **Gestion de profils** (CRUD, sauvegarde profil) | **Cacher** | Écrit `profiles.yml`. |
| **Sécurité additive** (masque manuel actif, designer, sélection profil, source) | **Actif** | Ne réduit jamais le masquage. |
| **Échange** (export JSON) | **Actif** ; **import** actif en mémoire mais sans persistance (R14 bloqué) | Sortie pour email, pas d'écrasement de config. |
### 3.2 — Implémentation UI (customtkinter v6)
1. **Cacher** : ne pas instancier le widget/onglet quand `not is_admin()`.
L'onglet/section « Profils techniques » et la section VLM ne sont **pas
créés** hors admin (pas seulement `grid_remove`, pour éviter toute
réactivation accidentelle).
2. **Griser** : créer le widget puis `configure(state="disabled")`. Pour les
`Listbox`/listes éditables : désactiver les boutons +Ajouter / Supprimer et
passer la liste en lecture seule ; afficher un bandeau discret
« Réglages avancés en lecture seule — mode admin requis pour modifier ».
3. **Helper centralisé** (extension `admin_mode.py`) :
- `admin_only_visible(widget)` → ne crée/affiche que si admin.
- `admin_only_editable(widget)` → `state="normal"` si admin sinon `"disabled"`.
- `guard_save(feature) ` → wrappe l'écriture (voir 3.3).
Cela centralise la logique au lieu de la disperser dans la GUI (frontière
Agent B : `admin_mode.py` + sections « avancé » de `gui_v6/`).
4. **Titre fenêtre** : conserver le tag `[⚙ MODE ADMIN]` (déjà en v5, l.383-384).
En v6, ajouter une **bannière** persistante en mode admin (rouge/orange).
### 3.3 — Règles de sauvegarde (blocage de l'écriture des fichiers sensibles)
Le point dur de D-13 complet : **l'UI masquée ne suffit pas**. Il faut un garde
au niveau de l'**écriture** pour qu'aucun chemin (raccourci clavier, import +
save, futur bouton) ne puisse écraser un fichier sensible hors admin.
1. **Garde à la source** : toute méthode qui écrit un fichier de config sensible
doit appeler `admin_required(...)` (déjà fourni par `admin_mode.py`) **avant**
l'écriture. Cibles : `_save_param_listboxes` (R14 → `dictionnaires.yml`),
`_save_selected_processing_profile`, `_create/_rename/_delete/_set_default…`
(R10/R11 → `profiles.yml`), et toute future écriture de `regex_overrides`,
`dictionaries_overlay`, `flags`, seuils.
2. **Liste blanche d'écriture** : définir dans `admin_mode.py` un ensemble
`SENSITIVE_CONFIG_FILES = {dictionnaires.yml, dictionnaires.default.yml,
profiles.yml, profiles.default.yml, admin_rules.yml, hospital_stopwords.yml,
medical_terms_whitelist.yml}` + une fonction `assert_writable(path)` qui lève
si `path` est sensible et `not is_admin()`. Appelée par tous les `write_text`
de config. Filet de sécurité indépendant de l'UI.
3. **`*.default.yml` jamais réécrits** — même en admin. `assert_writable` refuse
l'écriture des `*.default.yml` quel que soit le mode (sources de vérité).
4. **Import JSON (R16)** : autorisé à charger en mémoire (pas de fuite), mais le
bouton **Sauvegarder (R14) étant caché/bloqué en non-admin**, l'import reste
sans effet persistant. À documenter dans l'UI : « Import chargé. Sauvegarde
réservée au mode admin. » Évite de laisser croire que la config est modifiée.
5. **Export JSON (R15)** : autorisé en non-admin — c'est une **sortie** vers le
Bureau pour échange par email, pas un écrasement de config. (Cohérent avec le
workflow « export → merge → renvoi YAML » des préférences projet.)
### 3.4 — Cas particulier : choix du moteur NER (S8)
Reporté à v11.5 par D-13 mais **sans UI existante**. Recommandation :
- Hors admin : **non exposé** (ou bandeau diagnostic en lecture seule listant les
moteurs chargés : EDS-Pseudo / GLiNER / CamemBERT-bio / ONNX + état).
- En admin : exposer en **diagnostic** (voir/recharger) ; **déconseiller** une
case « désactiver moteur X » librement, car couper un moteur fait chuter le
recall (multi-signal F1=0.963). Si Dom veut le toggle, l'assortir d'un
avertissement explicite « peut réduire la détection ». À trancher par Dom.
---
## 4. Tests attendus (matrice admin / non-admin)
Tests pilotables sans GUI réelle en testant les **helpers** + les **gardes
d'écriture** ; tests GUI en smoke (`gui_v6`). Cible : `tests/unit/test_d13_admin_*`.
### 4.A — `admin_mode` (logique)
- `is_admin()` : `ANON_ADMIN ∈ {1,true,yes,on}` → True ; vide/0 → False ;
fichier `.admin` présent → True ; `force_refresh` re-évalue le cache.
- `admin_required("x")` : lève `RuntimeError` hors admin, ne lève pas en admin.
- `assert_writable(path)` (nouveau) :
- fichier sensible + non-admin → lève ;
- fichier sensible + admin → OK **sauf** `*.default.yml` → lève (toujours) ;
- fichier non sensible (export JSON, mask_templates) → OK dans les deux modes.
### 4.B — Matrice par réglage (paramétrée admin ∈ {False, True})
Pour chaque réglage R1–R17 / S1–S10, asserter la cible de la matrice § 2 :
| Assertion | non-admin attendu | admin attendu |
|---|---|---|
| widget créé (visible) | selon col. « non-admin V » | « admin V » |
| widget `state` | `disabled` si grisé, absent si caché | `normal` |
| la sauvegarde écrit le fichier | **non** (lève / no-op) pour R10/R11/R14/S* | **oui** |
| `dictionnaires.yml` / `profiles.yml` non modifiés après tentative non-admin | hash fichier inchangé | modifié après save admin |
### 4.C — Non-régression (garde-fou n°1 du plan maître)
- `tests/unit` (98 passed) **restent verts** — D-13 ne touche pas le moteur.
- Audit `evaluate_quality.py` ≥ 98.5 ; leak score 100/100 inchangé.
- Smoke v6 : lancement non-admin → aucune section technique/VLM présente ;
lancement admin (`ANON_ADMIN=1`) → sections présentes + bannière admin.
### 4.D — Test « anti-contournement »
- Simuler import JSON (R16) puis tentative de save (R14) en non-admin →
`dictionnaires.yml` **inchangé**.
- Vérifier qu'aucun `write_text` sur un fichier sensible n'est atteignable hors
`assert_writable` (revue : grep des `write_text` sur `config/` dans `gui_v6/`).
---
## 5. Impacts GUI v5 vs GUI v6
### GUI v5 (`Pseudonymisation_Gui_V5.py`) — **laisser tel quel**
- D-13 **partiel** est déjà livré et acté (VLM caché, titre admin). Conforme au
gel bêta (D-16) : on ne re-patche pas 2893 lignes tkinter.
- **Aucune modification v5** dans ce chantier. (Si un hotfix MVP devenait
nécessaire, il resterait hors périmètre v11.5.)
### GUI v6 (`Pseudonymisation_Gui_V6.py` / `gui_v6/`) — **lieu d'implémentation**
- D-13 **complet** s'implémente nativement à la construction de chaque écran v6,
via les helpers `admin_mode` (§ 3.2). Pas de rétro-fit : la visibilité/édition
est décidée **au moment de créer le widget**.
- Frontières (plan maître § 3) : Agent B possède `admin_mode.py` (extension :
`assert_writable`, `SENSITIVE_CONFIG_FILES`, helpers UI) et les **règles** des
sections « avancé » ; Agent A possède les écrans `gui_v6/`.
- Structure cible v6 (proposition) : un onglet **« Profils techniques »** + une
section **VLM** entièrement **conditionnés à `is_admin()`** (non instanciés
hors admin) ; la section **« Paramètres avancés »** (WL/BL/SW) **toujours
visible** mais **read-only** hors admin.
---
## 6. Zone de contact Agent A ↔ Agent B (contrat à figer avant code)
Les écrans « Paramètres avancés » et « Profils techniques » de la GUI v6 sont
**co-conçus** : **B fournit les règles, A fournit les écrans**. Contrat proposé :
**Ce que B (ce plan) fournit à A :**
1. La **matrice § 2** (visible/éditable/sauvegardable par réglage et par mode).
2. Les **helpers** `admin_mode` (signatures) que A appellera :
- `is_admin() -> bool`
- `admin_only_visible(parent, build_fn)` — n'appelle `build_fn` que si admin.
- `admin_only_editable(widget)` — applique `state`.
- `assert_writable(path)` — à appeler avant toute écriture config.
3. La **liste des écritures à garder** (R10/R11/R14, futurs S1/S7/S5…).
4. La **convention de regroupement** : tout réglage « technique avancé »
(S1–S5, S7, S9, S10, R2) dans **un seul** conteneur masquable d'un bloc.
**Ce que A fournit à B :**
1. Les conteneurs/onglets v6 nommés (où s'accrochent les sections « avancé »).
2. L'emplacement de la **bannière mode admin** (cohérence avec la bannière
licence réservée à l'Agent C).
3. Le point d'appel unique des écritures de config (pour y placer
`assert_writable`) afin d'éviter des `write_text` dispersés.
**À trancher par Dom :**
- S8 (toggle moteur NER) en admin : **diagnostic seul** (recommandé) ou toggle
avec avertissement ?
- Import JSON (R16) en non-admin : garder l'import-en-mémoire (proposé) ou le
cacher aussi ?
---
## 7. Synthèse des recommandations
1. **Deux politiques** : *cacher* le leak-sensible (VLM) et le technique avancé
(regex/profils techniques/moteur/seuils/chemins) ; *griser* le qualité
(WL/BL/SW) ; *laisser actif* l'additif-sécurité (masques) et l'export.
2. **Garde d'écriture indépendante de l'UI** (`assert_writable` +
`SENSITIVE_CONFIG_FILES`) : filet de sécurité contre tout contournement.
`*.default.yml` jamais réécrits, même en admin.
3. **GUI v5 inchangée** ; tout dans `gui_v6/` + extension `admin_mode.py`.
4. **Tests** : matrice paramétrée admin/non-admin + anti-contournement + 98 tests
moteur verts (garde-fou non négociable).
5. **Contrat A↔B** figé avant tout code (helpers + matrice + points d'écriture).
6. **Attente GO bêta (D-16)** avant tout codage — ce document est de la
planification pure.
— Claude (Agent B)

523
docs/coordination/inbox/for-dom/2026-06-05_claude_planC_licence.md
View File

@@ -1,523 +0,0 @@
---
from: claude (Agent C — chantier v11.5)
to: dom
date: 2026-06-05T19:30:00+02:00
topic: planC-licence-d14
status: open
priority: high
references:
- decision: docs/coordination/decisions/2026-06-02_dom_d14-plateforme-licence-architecture.md
- plan: docs/coordination/inbox/for-dom/2026-06-05_claude_plan-v11-5-parallele.md
scope: CONCEPTION uniquement — aucun code de prod, aucun déploiement
---
# Plan C — Plateforme licence (D-14) : conception détaillée
> Sous-plan de l'Agent C. **Lecture seule** sur le code existant. Aucune ligne de
> `license.py` ni de `platform/` n'est écrite ici : ce document est la spec qui
> sera codée APRÈS le GO bêta (D-16), Phase 1.1 puis 1.2.
>
> Cadre D-14 **respecté à la lettre** (FastAPI + PostgreSQL + HTMX/Jinja2, OVH HDS,
> `app.aivanov.fr`, fastapi-users, Brevo, RSA-PSS 2048 + SHA256, `license.dat` DPAPI,
> phone home ≤ 30 j, 1 licence = 1 poste, grace 15 j, offline 30 j, révocation au check).
## 0. Ancrage dans l'existant (vérifié, read-only)
- Pas de `license.py` ni de `platform/` aujourd'hui → **fichiers/dossiers 100 % neufs**,
zéro conflit avec le moteur (`anonymizer_core_refactored_onnx.py`) ou la GUI.
- `cryptography==41.0.7` **déjà installée** → pas de nouvelle dépendance lourde côté client
(RSA-PSS/SHA256 fournis par `cryptography.hazmat`). Aucun ajout au risque
`numpy<2.0` / `gliner==0.2.18`.
- Le `.spec` PyInstaller bundle déjà `config/` → la **clé publique** s'embarque
naturellement comme `config/license_pubkey.pem` (ajout d'une seule ligne `datas`
au moment du codage, pas maintenant).
- `admin_mode.py` fournit le patron `is_admin()` / `admin_required()` et
`_project_root()` (résolution `sys._MEIPASS` en frozen) → `license.py` réutilise la
même logique de résolution de chemins en mode EXE.
---
## 1. Architecture serveur (`platform/`, Phase 1.2 ~50h)
### 1.1 Arborescence du nouveau dossier (repo séparé ou sous-dossier `platform/`)
```
platform/
├── app/
│ ├── main.py # FastAPI app + routers
│ ├── config.py # settings (env: DB URL, Brevo key, clé privée path)
│ ├── db.py # SQLAlchemy async engine + session
│ ├── models.py # tables ORM (clients, licences, postes, activations, revocations)
│ ├── auth.py # fastapi-users (UserManager, JWT/cookie)
│ ├── crypto/
│ │ ├── signer.py # signature RSA-PSS d'une licence (clé PRIVÉE, serveur only)
│ │ └── private_key.pem # JAMAIS commité (.gitignore + secret CI) — monté via volume OVH
│ ├── routers/
│ │ ├── pages.py # pages HTMX/Jinja2 (login, mes licences, activation, DL)
│ │ ├── api_client.py # endpoints appelés par l'EXE (/activate, /check, /download)
│ │ └── api_admin.py # endpoints admin Dom (create licence, revoke, parc)
│ ├── services/
│ │ ├── licensing.py # logique métier : 1 licence=1 poste, expiration, grace
│ │ ├── activation.py # bind machine_id ↔ licence, anti-réactivation
│ │ └── email.py # Brevo (activation, renouvellement, expiration J-30/J-7)
│ ├── templates/ # Jinja2 + fragments HTMX
│ └── static/
├── migrations/ # Alembic
├── tests/
├── Caddyfile # reverse proxy + Let's Encrypt (app.aivanov.fr)
├── docker-compose.yml # api + postgres + caddy
└── .github/workflows/deploy.yml
```
### 1.2 Schéma DB PostgreSQL
Cinq tables. fastapi-users gère `users` (= comptes de connexion). Le **client métier**
(`clients`) est distinct du `user` pour autoriser plusieurs comptes par organisation
plus tard, mais en MVP `user ↔ client` est 1:1.
```
users (géré par fastapi-users)
id UUID PK
email TEXT UNIQUE
hashed_password TEXT
is_active BOOL
is_superuser BOOL -- Dom = superuser (back-office)
is_verified BOOL
clients -- l'organisation cliente (hôpital, cabinet)
id UUID PK
user_id UUID FK→users.id (1:1 en MVP)
raison_sociale TEXT
finess TEXT NULL -- optionnel, cohérent métier santé
contact_email TEXT
created_at TIMESTAMPTZ
licences -- 1 abonnement annuel = N postes achetés
id UUID PK
client_id UUID FK→clients.id
ref TEXT UNIQUE -- ex. LIC-2026-000123 (humain)
postes_max INT -- nb de postes autorisés (souvent 1)
version_max TEXT NULL -- version max couverte par l'abo (ex "11.x")
issued_at TIMESTAMPTZ
expires_at TIMESTAMPTZ -- date de fin d'abonnement annuel
status ENUM(active, suspended, expired, cancelled)
created_at TIMESTAMPTZ
postes -- 1 ligne = 1 machine_id activée sous une licence
id UUID PK
licence_id UUID FK→licences.id
machine_id TEXT -- empreinte poste (voir §3.2)
label TEXT NULL -- nom donné par le client ("Poste accueil")
os_info TEXT NULL -- diag (Windows build), non PII
activated_at TIMESTAMPTZ
last_seen_at TIMESTAMPTZ -- dernier phone home réussi
status ENUM(active, revoked)
UNIQUE(licence_id, machine_id) -- 1 machine ne s'active qu'une fois/licence
-- contrainte applicative : COUNT(active) ≤ licences.postes_max
activations -- journal d'audit (immuable, append-only)
id UUID PK
poste_id UUID FK→postes.id NULL
licence_id UUID FK→licences.id
machine_id TEXT
event ENUM(activate, check, refuse_quota, refuse_revoked, revoke, renew)
ip INET NULL
user_agent TEXT NULL
detail JSONB NULL
created_at TIMESTAMPTZ
```
**Règle "1 licence = 1 poste" (D-14)** : implémentée par `postes_max` (défaut 1) +
contrainte applicative dans `services/licensing.py` : refus d'activation si
`COUNT(postes WHERE status=active) >= postes_max`. La table reste générique (permet
un futur multi-postes) sans casser le modèle MVP.
**Révocation au prochain check (D-14)** : `postes.status = revoked` → le `/check`
suivant renvoie `revoked`, l'EXE supprime son cache et repasse non-licencié. Pas de
push, pas de connexion permanente requise.
### 1.3 Endpoints FastAPI
**API client (appelés par l'EXE) — `routers/api_client.py`**
| Méthode | Route | Auth | Rôle |
|---|---|---|---|
| POST | `/api/v1/activate` | token client (clé licence + email/mdp ou jeton d'activation) | Lie `machine_id` à la licence, renvoie la **licence signée** (§4) |
| POST | `/api/v1/check` | machine_id + ref licence | Phone home : renvoie statut (active/expired/grace/revoked) + éventuelle licence re-signée (renouvellement) |
| GET | `/api/v1/download/{version}` | session client | Téléchargement de l'EXE (remplace OwnCloud) |
| GET | `/api/v1/version` | public | Dernière version dispo (pour notif maj) |
**Pages HTMX (humain) — `routers/pages.py`**
| Route | Page |
|---|---|
| `GET /` `GET /login` | Connexion (fastapi-users, cookie) |
| `GET /licences` | « Mes licences » : liste, expiration, postes consommés/max |
| `POST /licences/{id}/activate-token` (HTMX) | Génère un **jeton d'activation à usage unique** à coller dans l'EXE |
| `GET /licences/{id}/postes` (HTMX fragment) | Liste des postes activés, bouton « révoquer » |
| `POST /postes/{id}/revoke` (HTMX) | Passe le poste en `revoked` (effectif au prochain check) |
| `GET /download` | Page de téléchargement + checksum |
**API admin (Dom, superuser) — `routers/api_admin.py`**
| Route | Rôle |
|---|---|
| `POST /admin/clients` | Créer un client + compte |
| `POST /admin/licences` | Émettre une licence (postes_max, expires_at) |
| `POST /admin/licences/{id}/renew` | Prolonger d'un an |
| `POST /admin/licences/{id}/cancel` | Suspendre/annuler |
| `GET /admin/parc` | Vue parc : clients, licences, postes, last_seen |
### 1.4 Pages HTMX (UX MVP, Phase 1.2)
- **Login** (fastapi-users, cookie session) → redirige vers `/licences`.
- **Mes licences** : carte par licence (réf, statut, expiration, jauge postes
`2/3`), bouton « Activer un poste » qui ouvre un fragment HTMX affichant le
**jeton d'activation** (copier-coller dans l'EXE).
- **Postes** : tableau (label, machine_id tronqué, last_seen, statut) + révoquer.
- **Téléchargement** : dernier EXE + checksum SHA256.
- Back-office Dom (superuser) : parc global + actions admin.
> HTMX = fragments HTML renvoyés par FastAPI, zéro SPA, déploiement simple (D-14).
---
## 2. Module client `license.py` (Phase 1.1 ~12h, fichier neuf)
### 2.1 Principe
`license.py` est **autonome** : il ne dépend que de `cryptography` (déjà présente) et
de la lib standard. Il n'importe NI le moteur NI la GUI → testable seul, zéro conflit.
La GUI (Agent A) ne fait qu'appeler son **API publique de statut** (§7).
### 2.2 Interface publique (contrat figé exposé à la GUI)
```python
# --- Types ---
class LicenseState(Enum):
ACTIVE # licence valide, dans la période
GRACE # expirée mais < 15 j → mode dégradé autorisé
EXPIRED # > 15 j après expiration → bloquant (sauf bêta)
OFFLINE_STALE # pas de phone home depuis > 30 j → exige reconnexion
REVOKED # révoquée côté serveur
UNLICENSED # aucune licence (ex. bêta, ou avant activation)
INVALID # signature falsifiée / fichier corrompu / machine_id divergent
@dataclass(frozen=True)
class LicenseStatus:
state: LicenseState
client_id: str | None
expires_at: datetime | None
days_remaining: int | None # négatif si en grace
last_check_at: datetime | None
machine_id: str
message_fr: str # texte prêt pour la bannière GUI
can_anonymize: bool # ACTIVE et GRACE → True ; sinon False (hors bêta)
# --- API que la GUI appelle ---
def get_status(force_refresh: bool = False) -> LicenseStatus: ...
# Lit license.dat (cache), valide signature + machine_id + dates SANS réseau.
# Si dernier check > 30 j → tente un phone home ; sinon reste offline.
def activate(license_token: str) -> LicenseStatus: ...
# Appelle POST /activate, reçoit la licence signée, la chiffre dans license.dat.
def check_now() -> LicenseStatus: ...
# Force un phone home (POST /check) ; met à jour last_check_at + re-signature.
def deactivate() -> None: ...
# Supprime license.dat local (libère le poste après révocation côté serveur).
def is_beta_build() -> bool: ...
# True si BETA (pas de licence) → court-circuite tout (Phase 0 Réunion).
```
> **Phase 0 / bêta** : `is_beta_build()` renvoie True (flag de build), `get_status()`
> renvoie `UNLICENSED` avec `can_anonymize=True`. Aucun appel réseau, aucun blocage.
> C'est le mode livré au testeur Réunion (D-14, Phase 0).
### 2.3 Algo de vérification RSA-PSS (offline, cœur de la sécu)
```
verify(license_json, signature, pubkey):
1. Recomposer le payload canonique = json.dumps(license_obj, sort_keys=True,
separators=(',',':')) encodé UTF-8 # canonicalisation déterministe obligatoire
2. public_key.verify(
signature, # bytes (base64-décodés)
canonical_payload,
padding.PSS(mgf=MGF1(SHA256()), salt_length=PSS.MAX_LENGTH),
SHA256())
3. Si InvalidSignature → state = INVALID (refus)
4. Vérifier machine_id(payload) == machine_id(local) # anti-recopie sur autre PC
5. Vérifier version couverte (payload.version_max ≥ version courante si présent)
6. Calcul d'état temporel (now vs expires_at, last_check) → ACTIVE/GRACE/EXPIRED/...
```
Clé publique embarquée : `config/license_pubkey.pem` (PEM SubjectPublicKeyInfo,
RSA 2048). Clé privée : **jamais** dans le repo client, uniquement sur OVH
(`platform/app/crypto/private_key.pem`, monté en volume/secret CI).
### 2.4 `machine_id` (empreinte poste, §3.2 pour le flow)
```
machine_id = SHA256( os_uuid || cpu_id || mac_primaire )[:32] # hex tronqué
```
- **Windows** : `MachineGuid` (registre `HKLM\SOFTWARE\Microsoft\Cryptography`) +
`wmic csproduct uuid` + 1ʳᵉ MAC non virtuelle.
- **Linux/Mac** (dev/tests) : `/etc/machine-id` + MAC.
- Hashé (SHA256 tronqué) → **non réversible**, pas un identifiant PII brut.
- Tolérance : on hashe des composants stables ; pas le n° de disque (changé au
reformatage). Si dérive (carte réseau changée) → `INVALID` → ré-activation
nécessaire (cas rare, géré par le support).
### 2.5 Cache local chiffré `license.dat`
- Contenu : la licence signée (JSON+signature) **+** métadonnées locales
(`last_check_at`, `machine_id`).
- **Windows** : chiffré via **DPAPI** (`win32crypt.CryptProtectData`, scope
`CRYPTPROTECT_LOCAL_MACHINE`) → déchiffrable seulement sur ce poste/compte.
- **Linux/Mac** : chiffrement symétrique simple (Fernet) avec clé dérivée du
`machine_id` (suffisant hors prod Windows ; D-14 dit « chiffré simple »).
- Emplacement : à côté de l'EXE en frozen (réutilise `_project_root()` du patron
`admin_mode.py`), `%LOCALAPPDATA%\Aivanov\Anonymisation\license.dat` recommandé
pour survivre aux mises à jour.
- **Anti-rollback horloge** : on stocke `last_check_at` ET on refuse un `now` <
`last_check_at` (recul d'horloge) → bascule `OFFLINE_STALE` plutôt que prolonger
frauduleusement la grace.
### 2.6 Logique grace / offline / révocation (machine à états)
```
À get_status():
charger+vérifier license.dat
si INVALID/REVOKED/absent → état correspondant (can_anonymize=False, sauf bêta)
sinon:
age_check = now - last_check_at
si age_check > 30 j → tenter check_now()
succès → repartir avec licence fraîche
échec réseau → état OFFLINE_STALE (can_anonymize=False : exige reconnexion)
calc temporel:
now <= expires_at → ACTIVE (can_anonymize=True)
expires_at < now <= expires_at+15 j → GRACE (can_anonymize=True, bannière)
now > expires_at+15 j → EXPIRED (can_anonymize=False)
```
- **Grace 15 j** : `can_anonymize=True` + `message_fr` = « Licence expirée — pensez à
renouveler (J-X) ». Mode dégradé = juste la bannière (D-14), le moteur ne change pas.
- **Offline 30 j** : tant que `age_check ≤ 30 j`, **aucun réseau requis** (full offline).
Au-delà, un phone home est exigé ; s'il échoue → `OFFLINE_STALE` bloquant jusqu'à
reconnexion (évite usage illimité hors-ligne).
- **Révocation** : détectée au `/check` (serveur renvoie `revoked`) → `deactivate()`
local → `REVOKED`. Pas instantané par design (D-14), effectif au prochain check.
---
## 3. Format exact de la licence signée
### 3.1 Objet JSON (payload signé)
```json
{
"v": 1,
"license_ref": "LIC-2026-000123",
"client_id": "5f3a...uuid",
"machine_id": "9b1c2d...32hex",
"issued_at": "2026-06-10T09:00:00Z",
"expires_at": "2027-06-10T09:00:00Z",
"version_max": "11.x",
"grace_days": 15,
"offline_max_days": 30
}
```
> Canonicalisation **obligatoire** avant signature ET vérification :
> `json.dumps(payload, sort_keys=True, separators=(',',':'))` → bytes UTF-8.
> Tout écart de sérialisation invalide la signature.
### 3.2 Enveloppe stockée / transmise
```json
{
"payload": { ... l'objet ci-dessus ... },
"signature": "base64( RSA-PSS-SHA256( canonical(payload) ) )",
"alg": "RSASSA-PSS-SHA256",
"key_id": "aivanov-license-2026"
}
```
`key_id` permet une **rotation de clé** future (le client embarque plusieurs pubkeys
indexées par `key_id`). MVP : une seule clé.
---
## 4. Flows
### 4.1 Activation d'un poste
```
Client se connecte sur app.aivanov.fr → /licences → « Activer un poste »
→ serveur génère jeton d'activation usage unique (lié licence_id)
Client lance l'EXE → saisit le jeton → license.py.activate(token)
→ POST /activate { token, machine_id, os_info }
→ serveur : vérifie quota (COUNT active < postes_max), crée poste, journalise
→ serveur signe la licence (clé privée) et renvoie l'enveloppe
→ license.py chiffre l'enveloppe dans license.dat (DPAPI), state=ACTIVE
Refus si quota atteint → 409 refuse_quota → message GUI « postes max atteints ».
```
### 4.2 Expiration + grace period
```
Au lancement, get_status() (offline) :
now <= expires_at → ACTIVE
J0..J15 après expires_at → GRACE : anonymisation OK + bannière jaune « J-X »
> J15 → EXPIRED : anonymisation bloquée, CTA « renouveler »
Renouvellement : Dom renew côté serveur → au prochain /check, licence re-signée
avec nouveau expires_at → state repasse ACTIVE automatiquement.
```
### 4.3 Offline 30 jours
```
Poste sans réseau :
age_check <= 30 j → fonctionne 100 % offline (vérif locale signature+dates)
age_check > 30 j → tente /check ; si échec → OFFLINE_STALE (bloquant)
message « Connexion requise pour valider la licence ».
```
### 4.4 Révocation
```
Dom (ou client) clique « révoquer » → postes.status=revoked (audit logged).
Effet : rien d'immédiat sur le poste (offline).
Au prochain /check du poste (≤ 30 j) → serveur renvoie revoked
→ license.py.deactivate() supprime license.dat → state=REVOKED (bloquant).
```
---
## 5. Plan de branches et livrables
> **Tout démarre APRÈS le GO bêta (D-16).** Branches créées depuis la branche de
> livraison figée, conformément au plan maître §6.
### Phase 1.1 — client `license.py` (~12h) — EN PREMIER (le plus isolé)
- **Branche** : `feature/v11-5-license-client`
- **Livrables** :
- `license.py` (module neuf, API §2.2)
- `config/license_pubkey.pem` (clé publique de test d'abord, prod ensuite)
- 1 ligne ajoutée au `.spec` (`("config/license_pubkey.pem", "config")`) — ajout
isolé, ne touche aucune entrée existante
- flag de build `BETA` (dans `build_info.py`) pour `is_beta_build()`
- `tests/unit/test_license.py` (§6)
- **Isolation** : `license.py` n'importe ni le moteur ni la GUI → **zéro conflit**.
Mergeable indépendamment (plan maître §6.2).
### Phase 1.2 — plateforme `platform/` (~50h) — APRÈS, en parallèle de A/B
- **Branche** : `feature/v11-5-platform` (ou repo `platform/` dédié)
- **Livrables** : arborescence §1.1, migrations Alembic, docker-compose,
Caddyfile (`app.aivanov.fr`), workflow GitHub Actions, `tests/` serveur.
- **Isolation** : dossier `platform/` entièrement neuf → **zéro fichier applicatif
partagé** avec moteur/GUI/admin.
### Ce qui est isolé (résumé anti-collision pour Agent D)
| Zone Agent C | Conflit possible ? |
|---|---|
| `license.py` (neuf) | Non |
| `platform/` (neuf) | Non |
| `config/license_pubkey.pem` (neuf) | Non |
| `.spec` (+1 entrée datas) | Quasi nul (ajout en fin de liste) |
| `build_info.py` (+1 flag BETA) | Faible (1 constante) — à coordonner avec D |
| Point d'appel GUI | **Contrat §7** — A réserve l'emplacement, C fournit l'API |
---
## 6. Tests attendus
### Client `license.py` (`tests/unit/test_license.py`) — pas de mock réseau pour la crypto
| Test | Attendu |
|---|---|
| Signature valide | licence signée avec la clé privée de test → `ACTIVE` |
| Signature **falsifiée** (1 octet modifié dans payload OU signature) | `INVALID`, `can_anonymize=False` |
| `machine_id` divergent (licence d'un autre poste) | `INVALID` |
| Expiration : now < expires | `ACTIVE` |
| Grace : expires < now ≤ +15 j | `GRACE`, `can_anonymize=True`, `days_remaining` négatif |
| Au-delà grace : now > +15 j | `EXPIRED`, `can_anonymize=False` |
| Offline ≤ 30 j (pas de réseau) | reste `ACTIVE`/`GRACE` sans appel réseau |
| Offline > 30 j + check échoue | `OFFLINE_STALE`, bloquant |
| Révocation (check renvoie revoked) | `REVOKED`, `license.dat` supprimé |
| Recul d'horloge (now < last_check) | pas de prolongation frauduleuse → `OFFLINE_STALE` |
| Cache corrompu | `INVALID` sans crash |
| Mode bêta (`is_beta_build()`) | `UNLICENSED` + `can_anonymize=True`, zéro réseau |
> Fixtures : on génère une **paire RSA de test** dans la fixture (jamais la clé prod),
> on signe des payloads à la volée → tests déterministes, hermétiques, sans serveur.
### Serveur `platform/tests/`
| Test | Attendu |
|---|---|
| Activation poste | crée `postes`, renvoie licence signée vérifiable par la pubkey |
| Quota 1 licence = 1 poste | 2ᵉ activation sur `postes_max=1` → `409 refuse_quota` |
| Réactivation même machine_id | idempotent (pas de doublon) |
| `/check` poste révoqué | renvoie `revoked` |
| Renew | `expires_at` prolongé → licence re-signée |
| Auth | endpoints admin refusés aux non-superusers |
| Audit | chaque événement écrit une ligne `activations` |
---
## 7. Zone de contact avec Agent A (GUI v6)
L'Agent A réserve un emplacement UI (bannière d'état licence). **C fournit l'API**,
A ne fait que l'afficher. Contrat figé :
```python
from license import get_status, LicenseState
st = get_status() # jamais bloquant, pas de réseau sauf si >30 j
banner_text = st.message_fr # ex. « Licence active — expire le 10/06/2027 »
banner_level = { # pour la couleur de bannière
LicenseState.ACTIVE: "ok", # vert/neutre
LicenseState.GRACE: "warning", # jaune « renouveler J-X »
LicenseState.EXPIRED: "error", # rouge bloquant
LicenseState.OFFLINE_STALE: "warning", # « connexion requise »
LicenseState.REVOKED: "error",
LicenseState.UNLICENSED: "info", # bêta : info discrète ou rien
LicenseState.INVALID: "error",
}[st.state]
allow_run = st.can_anonymize # la GUI grise « Anonymiser » si False
```
- La GUI **n'appelle jamais** `/activate` ou `/check` directement : tout passe par
`license.py` (`activate(token)`, `check_now()`).
- L'écran d'activation (saisie du jeton) appelle `license.activate(token)` et affiche
le `LicenseStatus` retourné.
- En bêta, `get_status()` renvoie `UNLICENSED` + `can_anonymize=True` → A peut masquer
totalement la bannière (rien à afficher).
---
## 8. Risques & points à valider par Dom
| Point | Reco |
|---|---|
| Stabilité `machine_id` (carte réseau changée → ré-activation) | Hasher des composants stables (MachineGuid + UUID carte mère), pas le disque. Acceptable : support gère les rares dérives. |
| DPAPI `LOCAL_MACHINE` vs `CURRENT_USER` | `LOCAL_MACHINE` = tous les comptes du poste partagent la licence (cohérent « 1 poste »). À confirmer côté hôpital (sessions partagées). |
| `pywin32` (DPAPI) pas encore listé côté EXE | Ajout dépendance Windows uniquement, en Phase 1.1. Hors périmètre `numpy<2.0`. |
| Rotation de clé future | `key_id` prévu dans l'enveloppe (§3.2) → non bloquant. |
| Bêta sans licence | `is_beta_build()` court-circuite tout (D-14 Phase 0 respecté). |
---
## Résumé exécutif
Conception complète de la brique licence D-14, **respectant le cadre validé** sans le
réinventer. Côté serveur (`platform/`, Phase 1.2) : FastAPI + PostgreSQL (5 tables
clients/licences/postes/activations + users fastapi-users), endpoints client
(`/activate`, `/check`, `/download`) + pages HTMX (« Mes licences », activation,
révocation) + back-office Dom. Côté client (`license.py`, Phase 1.1) : module **neuf et
isolé** (zéro import moteur/GUI), API publique figée (`get_status`, `activate`,
`check_now`, `deactivate`), vérif **RSA-PSS 2048/SHA256 offline**, `machine_id` hashé,
cache `license.dat` **DPAPI**, machine à états grace 15 j / offline 30 j / révocation au
check. Format licence = JSON canonique signé + enveloppe base64 avec `key_id`. `cryptography`
**déjà installée** (aucune dépendance lourde nouvelle). Plan de branches : 1.1 client (mergeable
seul, le plus isolé) puis 1.2 plateforme. Tests crypto hermétiques (paire RSA de test) +
tests serveur (quota, révocation, renew, audit). Contrat GUI fourni à l'Agent A
(bannière via `message_fr` + `can_anonymize`). **Aucun code de prod écrit, aucun déploiement.**

202
docs/coordination/inbox/for-dom/2026-06-05_claude_planD_integration.md
View File

@@ -1,202 +0,0 @@
---
from: claude (Agent D — intégration)
to: dom
date: 2026-06-05T18:40:00+02:00
topic: planD-integration-v11-5
status: open
priority: high
references:
- plan: docs/coordination/inbox/for-dom/2026-06-05_claude_plan-v11-5-parallele.md
- decision: docs/coordination/decisions/2026-06-05_dom_d17-v11-5-chantiers-paralleles.md
- decision: docs/coordination/decisions/2026-06-05_dom_d16-test-windows-avant-diffusion.md
- decision: docs/coordination/decisions/2026-06-02_dom_d14-plateforme-licence-architecture.md
- decision: docs/coordination/decisions/2026-06-02_dom_d13-partial-scope.md
---
# Plan D — Intégration / merge v11.5 (anti-collision 3 agents)
**Planification uniquement — lecture seule.** Aucun code modifié, aucun commit.
Ce document définit comment les chantiers A (GUI v6), B (D-13 complet) et
C (licence) s'intègrent sans se marcher dessus.
État vérifié au moment de la rédaction (HEAD `57aa0f0`, branche `feature/q1-quarantine-mvp`) :
- Suite `tests/unit` : **98 tests collectés** (baseline confirmée).
- `admin_mode.py` (2.4 ko) et `config_defaults.py` (5.8 ko) **existent déjà** → B étend, ne crée pas.
- `license.py`, `gui_v6/`, `platform/` : **n'existent pas encore** → créations propres (A, C).
- `Pseudonymisation_Gui_V5.py` (119 ko) : fichier de livraison bêta → **gelé**, sert de référence à A.
- `backup/windows-wip-2026-06-05` : **déjà poussé sur Gitea** (section 0 du plan maître close).
---
## 1. Frontières de fichiers (qui crée / modifie quoi)
### Agent A — GUI v6 (zone PROPRE)
| Fichier / dossier | Action | Note |
|---|---|---|
| `Pseudonymisation_Gui_V6.py` | **CRÉE** (neuf) | réécriture propre, pas de merge brut du WIP |
| `gui_v6/` (nouveau package) | **CRÉE** | onglets, widgets, thèmes, assets |
| `gui_v6/assets/`, thèmes | **CRÉE** | maquette v6 validée 2026-05-06 |
| `Pseudonymisation_Gui_V5.py` | **NE TOUCHE PAS** | reste le point d'entrée bêta jusqu'à bascule finale |
A consomme le moteur via l'API interne stable (mêmes signatures qu'en v5).
A **réserve deux emplacements UI** : (a) section « Paramètres avancés / Profils
techniques » pour B, (b) bannière état licence (statut/expiration) pour C.
### Agent B — D-13 complet (zone PROPRE + zone partagée avec A)
| Fichier / dossier | Action | Note |
|---|---|---|
| `admin_mode.py` | **ÉTEND** (existe déjà) | ajoute la matrice de réglages protégés, garde `is_admin()`/`admin_required()` |
| `config_defaults.py` | **ÉTEND** (existe déjà) | flags admin/non-admin par réglage |
| `gui_v6/` sections « avancé » | **CO-ÉCRIT avec A** | B = règles d'accès, A = écrans |
| moteur de détection (`anonymizer_core_*`) | **NE TOUCHE PAS** | garde-fou n°1 |
### Agent C — Licence (zone PROPRE, la plus isolée)
| Fichier / dossier | Action | Note |
|---|---|---|
| `license.py` | **CRÉE** (neuf) | client : vérif RSA-PSS, expiration, grace 15 j, offline 30 j, révocation |
| `platform/` (serveur) | **CRÉE** (neuf) | activation poste, 1 licence = 1 machine_id (D-14 phase 1.2) |
| clé **publique** embarquée | **CRÉE** | clé privée RSA **jamais** dans le repo client (serveur OVH uniquement) |
| GUI, core | **NE TOUCHE PAS** | C n'expose qu'une API statut/expiration consommée par A |
### Agent D — Intégration (ce document)
| Zone | Action |
|---|---|
| `docs/coordination/` | docs de merge, ce plan |
| `tests/` (structure, CI) | organisation des nouveaux dossiers de tests par chantier |
| code applicatif | **NE TOUCHE PAS** |
### Fichiers PARTAGÉS à risque (à surveiller en priorité)
1. **`gui_v6/` sections « avancé »** — seule vraie co-édition (A↔B). Mitigation :
contrat écrit A↔B avant tout code ; B livre une **interface de règles**
(`admin_mode.get_field_policy(field) -> visible|disabled|hidden`) que A appelle,
plutôt que B éditant les écrans directement.
2. **`Pseudonymisation_Gui_V6.py`** — propriété exclusive A. B et C n'y écrivent pas ;
ils exposent des fonctions, A les branche.
3. **`requirements.txt` / `.spec` PyInstaller** — touchés par C (dépendances RSA :
`cryptography`) et par le build final. Mitigation : un **seul** agent (D, au merge)
consolide `requirements.txt` et le `.spec` ; A/B/C déposent leurs deltas de deps en doc.
4. **`config_defaults.py`** — B l'étend. A le lit seulement. Pas d'écriture concurrente.
---
## 2. Dépendances entre agents
```
C (licence) ──API statut/expiration──► A (GUI v6, bannière licence)
B (D-13) ──API get_field_policy────► A (GUI v6, écrans avancés)
A (GUI v6) ──écrans + emplacements───► B se greffe dessus
```
- **B dépend de A** pour les écrans : B ne peut finaliser ses sections « avancé »
qu'une fois la structure d'onglets v6 posée par A. B peut **démarrer en parallèle**
sur la logique pure (matrice de règles dans `admin_mode.py` + tests headless),
puis brancher l'UI quand A a livré.
- **A dépend de C** pour l'API licence (statut/expiration). A peut avancer avec un
**stub** d'interface licence (contrat figé) tant que C n'a pas fini, puis brancher
le vrai `license.py`.
- **C ne dépend de personne** → chantier le plus isolé, mergeable en premier.
- **D dépend de tous** (validation finale).
Règle d'or : chaque dépendance passe par une **interface contractualisée** (signature
de fonction figée tôt), pas par un partage de fichier. Cela permet le parallélisme.
---
## 3. Ordre de merge recommandé (et justification)
Confirme la proposition §6 du plan maître :
1. **Base** : après **GO bêta** (D-16), figer la branche de livraison
(`feature/q1-quarantine-mvp` à `15f73f8` ou le hotfix éventuel), puis créer
`feature/v11-5` **depuis cette base figée**.
2. **C (licence) en premier** — *le plus isolé* : `license.py` + `platform/` neufs,
zéro conflit moteur/GUI. Mergeable seul, testable seul. Réduit le risque tôt.
3. **A (GUI v6) ensuite** — gros morceau, fichier neuf `Pseudonymisation_Gui_V6.py`.
Branche la bannière licence sur l'API de C (déjà mergée). Pas de conflit avec C
(surfaces disjointes).
4. **B (D-13) en dernier** — se *greffe sur A* (sections avancées de la GUI v6).
Merge après A pour que les écrans existent. La logique `admin_mode.py` étant déjà
prête et testée headless, le merge B = branchement UI + tests matrice.
5. **Validation D** — qualité + tests + build, puis bascule de v6 par défaut
(changement du point d'entrée v5→v6) en **dernier commit**, isolé et réversible.
Justification : on merge du moins couplé au plus couplé. C isolé d'abord retire le
risque cryptographique tôt ; A pose le squelette UI dont B a besoin ; B greffé en
dernier minimise la fenêtre de co-édition. La bascule v5→v6 est le tout dernier pas,
trivialement réversible (revert d'un seul commit).
---
## 4. Critères d'acceptation v11.5 (gate de merge)
Aucun merge dans `feature/v11-5` n'est accepté sans :
| Critère | Cible | Vérification |
|---|---|---|
| Non-régression moteur | `tests/unit` **98 passed** (inchangé) | `pytest tests/unit -q` |
| Leak score | **100/100** inchangé | `tests/unit/test_leak_scanner.py` + audit_30 |
| Audit qualité | `evaluate_quality.py` **≥ 98.5** (baseline) | `scripts/evaluate_quality.py` |
| Build EXE | **reproductible** (PyInstaller --onefile, config externe) | build Windows 192.168.1.11 |
| GUI v6 (A) | smoke lancement + workflow principal OK ; contrat moteur identique v5 | tests `gui_batch_paths`, `manual_masking` conservés |
| D-13 (B) | chaque réglage protégé caché/désactivé en non-admin ; `admin_required` lève ; sauvegarde config sensible bloquée non-admin | nouveaux tests matrice admin |
| Licence (C) | signature RSA-PSS (valide/falsifiée), expiration, grace 15 j, offline 30 j, révocation ; serveur : 1 licence = 1 machine_id | nouveaux tests `license.py` + serveur |
**Garde-fou non négociable** : les 98 tests verts + leak 100/100 sont le filet.
Le moteur de détection ne bouge pas → tout chantier qui ferait baisser ces deux
chiffres est rejeté, point.
---
## 5. Stratégie de branches
```
feature/q1-quarantine-mvp (livraison bêta — GELÉE jusqu'au GO Dom)
│ ◄── hotfix MVP éventuel possible ICI uniquement (D-16)
│
[GO BÊTA] → tag de livraison figé (ex: beta-v11)
│
└──► feature/v11-5 (créée APRÈS GO, depuis la base figée)
├── feat/v11-5-licence (C) → merge 1
├── feat/v11-5-gui-v6 (A) → merge 2
└── feat/v11-5-d13 (B) → merge 3 (greffé sur A)
```
Règles :
- **Aucune branche v11.5 créée avant le GO bêta** (gel D-16/D-17).
- `feature/v11-5` part de la **base figée** (tag de livraison), pas de `main` ni
d'une branche en mouvement.
- Sous-branches par chantier, merge dans `feature/v11-5` dans l'ordre §3.
- Hotfix MVP, s'il survient pendant la bêta, reste sur `feature/q1-quarantine-mvp`
et sera **rebasé/cherry-pické** dans la base figée avant création de `feature/v11-5`
(ne jamais mélanger hotfix et refonte).
- Tag de sécurité conservé sur `backup/windows-wip-2026-06-05` (anti-gc).
---
## 6. Risques principaux + mitigations
| Risque | Impact | Mitigation |
|---|---|---|
| GUI v6 casse le moteur | leak/qualité régressent | Contrat moteur strict (mêmes I/O que v5) + 98 tests verts obligatoires au merge |
| Co-édition A/B sur écrans avancés | conflits Git, double logique | Contrat écrit A↔B AVANT code ; B expose `get_field_policy()`, A consomme — pas de co-édition de fichier |
| Mélange hotfix MVP / v11.5 | divergence, régression bêta | Gel respecté ; v11.5 sur branche dédiée créée APRÈS GO ; hotfix cherry-pické proprement |
| Clé privée RSA fuit | licences forgeables | Clé privée **serveur OVH uniquement** (D-14) ; client n'embarque que la clé publique |
| `requirements.txt` / `.spec` édités par 3 agents | build cassé, conflits | Consolidation par **un seul** agent (D) au merge ; deltas de deps livrés en doc |
| WIP GUI v6 sur disque unique | perte de la base A | Déjà mitigé : backup poussé sur Gitea + tag anti-gc |
| Plateforme licence = ~50h | dérapage planning | Phasage D-14 : 1.1 client (~12h) avant 1.2 serveur (~50h) ; C livrable client d'abord |
| Bascule v5→v6 par défaut | régression point d'entrée | Bascule = dernier commit isolé, revert trivial |
---
## 7. Rappel garde-fous
- **GEL BÊTA** : rien ne démarre en *code* avant le GO de Dom (D-16/D-17). Seuls
plans, inventaires, contrats d'interface et docs sont produits maintenant.
- **Le moteur de détection ne bouge pas.** v11.5 = refonte UI + ajouts périphériques
(licence, admin). Le leak score 100/100 et les 98 tests sont intouchables.
- **Interfaces contractualisées** entre A/B/C : tout passe par des signatures de
fonctions figées tôt, jamais par du partage de fichier — c'est ce qui rend le
parallélisme sûr.
- **Un seul agent (D) consolide** `requirements.txt` et le `.spec` au merge.
— Claude (Agent D)