# Plan de test humain — 16 avril 2026 matin

**Cible** : valider le nouveau ZIP Léa (Lea_v1.0.0.zip reconstruit avec C2 + enrichissement UI + fail-safe UAC + enrollment fleet) sur la VM Windows 11.

**Durée estimée** : 45 min si tout passe, 1h30 si un test bloque.
**Principe général** : tests du plus simple au plus complexe. Ne pas sauter d'étape, chaque test dépend du précédent.

---

## Section 1 — Pré-requis (checklist 5 min)

### 1.1 — Côté serveur Linux (poste Dom)

Ouvrir un terminal et vérifier dans l'ordre :

```bash
cd /home/dom/ai/rpa_vision_v3

# 1) Services up (systemd user)
./svc.sh status

# On doit voir actifs au minimum :
#   streaming (5005) — OBLIGATOIRE
#   dashboard (5001) — OBLIGATOIRE
#   api (8000)       — utile mais pas bloquant
#   vwb-backend (5002), vwb-frontend (3002) — pour regarder les workflows enrichis

# 2) Ollama tourne avec le modèle VLM attendu
curl -s http://localhost:11434/api/tags | grep -E "gemma4|ui-tars|qwen" | head -5

# 3) Token API effectif (doit correspondre à celui de config.txt sur la VM)
grep -E "^RPA_API_TOKEN" .env .env.local 2>/dev/null | head -2
# Attendu : 86031addb338e449fccdb1a983f61807aec15d42d482b9c7748ad607dc23caab

# 4) Endpoint streaming répond
curl -s http://localhost:5005/health | head
# Attendu : {"status":"ok",...}

# 5) Dashboard répond (401 attendu sans auth — c'est la preuve que l'auth est active)
curl -sI http://localhost:5001/ | head -3
# Attendu : HTTP/1.1 401 Unauthorized + WWW-Authenticate: Basic

# 6) Endpoint fleet accessible (sans auth — c'est un endpoint API_TOKEN)
curl -s http://localhost:5005/api/v1/agents/fleet | head -200
# Attendu : JSON avec active/uninstalled/total_active/total_uninstalled
```

**Si un service est down** : `./svc.sh start <nom>` puis `./svc.sh logs <nom>` pour vérifier.

### 1.2 — Accès exposé Internet (à tester depuis la VM)

- `https://lea.labs.laurinebazin.design/health` → doit renvoyer 200 OK (proxy NPM → streaming 5005)
- `https://vwb.labs.laurinebazin.design/` → challenge auth Basic `lea` / `Medecin2026!`

### 1.3 — Côté VM Windows

- VM démarrée, session Windows 11 ouverte (compte local, pas domaine)
- Accès RDP ou console (Spice) fonctionnel
- Internet OK sur la VM : ouvrir Edge, faire `https://lea.labs.laurinebazin.design/health`, doit renvoyer `ok`
- **Si aucune instance Léa précédente installée** : rien à faire.
- **Si une instance Léa précédente est déjà installée** : noter le chemin (`C:\rpa_vision\` ou `C:\Lea\`) et **conserver `config.txt`** à portée de main pour restaurer le token.

### 1.4 — Fichiers à avoir sous la main

Sur le poste Dom, dans `~/ai/rpa_vision_v3/deploy/` :

- `Lea_v1.0.0.zip` (ZIP fraîchement reconstruit — vérifier la date : `ls -la deploy/Lea_v1.0.0.zip`)
- `lea_package/config.txt` (référence si on veut vérifier le contenu attendu)
- `lea_package/LISEZMOI.txt` (pour référence utilisateur)

**Commande utile** pour vérifier la fraîcheur du ZIP :
```bash
ls -la /home/dom/ai/rpa_vision_v3/deploy/Lea_v1.0.0.zip
unzip -l /home/dom/ai/rpa_vision_v3/deploy/Lea_v1.0.0.zip | head -20
```

---

## Section 2 — Déploiement du nouveau ZIP sur la VM (10 min)

### 2.1 — Transférer le ZIP sur la VM

**Option A — Drag & drop VirtualBox/VMware** : déposer `Lea_v1.0.0.zip` dans `C:\Users\<user>\Downloads\`.

**Option B — scp (si SSH actif sur la VM)** :
```bash
scp /home/dom/ai/rpa_vision_v3/deploy/Lea_v1.0.0.zip user@192.168.x.x:/C:/Users/<user>/Downloads/
```

**Option C — navigateur** : depuis la VM, aller sur `https://vwb.labs.laurinebazin.design/downloads/Lea_v1.0.0.zip` (si exposé — sinon utiliser A ou B).

### 2.2 — Arrêter l'instance Léa existante (si présente)

Sur la VM, ouvrir un terminal PowerShell ou cmd :

```cmd
:: Chercher le lock de l'ancienne instance
type C:\rpa_vision\lea_agent.lock
:: Si un PID apparaît, le tuer proprement :
taskkill /F /PID <PID_affiché>

:: Vérifier qu'aucun pythonw.exe Lea ne tourne plus
tasklist | findstr pythonw
```

Ne JAMAIS faire `taskkill /F /IM pythonw.exe` (tuerait Jupyter, Anaconda, etc.).

### 2.3 — Sauvegarder l'ancien config.txt

```cmd
copy C:\rpa_vision\config.txt C:\Users\<user>\Desktop\config.txt.backup
```

### 2.4 — Extraire le nouveau ZIP

```cmd
:: Renommer l'ancien dossier (rollback si besoin)
ren C:\rpa_vision C:\rpa_vision_old_16avril

:: Extraire le ZIP via l'explorateur (clic droit → Extraire tout → C:\rpa_vision)
:: OU via PowerShell :
powershell -command "Expand-Archive -Path C:\Users\<user>\Downloads\Lea_v1.0.0.zip -DestinationPath C:\rpa_vision -Force"
```

### 2.5 — Restaurer le token dans config.txt

Ouvrir `C:\rpa_vision\config.txt` dans Notepad et vérifier :

```
RPA_SERVER_URL=https://lea.labs.laurinebazin.design/api/v1
RPA_API_TOKEN=86031addb338e449fccdb1a983f61807aec15d42d482b9c7748ad607dc23caab
RPA_SERVER_HOST=lea.labs.laurinebazin.design
RPA_BLUR_SENSITIVE=false
```

**Important** : le token doit correspondre à celui du serveur (cf. Section 1.1 étape 3).

### 2.6 — Premier lancement

Double-cliquer sur `C:\rpa_vision\install.bat` (si premier déploiement — crée `.venv`).

Puis lancer `C:\rpa_vision\Lea.bat`. Une console s'ouvre 3 secondes, puis une icône apparaît dans la zone de notification Windows (près de l'horloge).

**Preuve que ça tourne** :
- Fichier `C:\rpa_vision\lea_agent.lock` contient un PID
- `tasklist | findstr pythonw` retourne au moins une ligne

Si rien n'apparaît, voir Section 4 (diagnostic).

---

## Section 3 — Tests fonctionnels (ordre important)

### Test 1 — Baseline + streaming + enrollment (objectifs 1, 2, 8)

**Pré-conditions** : Léa vient de démarrer sur la VM, icône visible dans systray.

**Actions** :
1. Côté Dom, lancer un watch sur les logs streaming :
   ```bash
   ./svc.sh logs streaming -f
   ```
2. Côté VM, clic droit sur l'icône Léa → "Apprenez-moi une tâche" (ou équivalent dans le menu).
3. Faire une action triviale : ouvrir le menu Démarrer, taper `notepad`, valider.
4. Clic droit sur Léa → "C'est terminé".

**Observations attendues** côté serveur :
- `[STREAM] register session_id=...` dès le démarrage
- `[STREAM] event ...` pour chaque click/touche
- `[STREAM] image ...` pour chaque screenshot (un par action)
- `[FLEET] Agent enrolé (created) : machine_id=...` au premier lancement uniquement

**Critères de succès** :
- La session apparaît dans :
  ```bash
  curl -s http://localhost:5005/api/v1/traces/stream/sessions | python3 -m json.tool | head -40
  ```
- L'agent apparaît dans `/fleet` :
  ```bash
  curl -s http://localhost:5005/api/v1/agents/fleet | python3 -m json.tool
  ```
  → `total_active >= 1`, avec `machine_id`, `hostname`, `version`, `enrolled_at` récent.

**Critères d'échec** :
- Aucun log streaming → voir Section 4 lignes "Token invalide" / "Agent ne démarre pas"
- Événements reçus mais pas d'image → voir Section 4 "images non streamées"

---

### Test 2 — Auth dashboard (objectif 7)

**Pré-conditions** : dashboard service up (cf. 1.1).

**Actions depuis la VM** :
1. Ouvrir `https://vwb.labs.laurinebazin.design/` → challenge Basic Auth → saisir `lea` / `Medecin2026!`
2. Ouvrir le dashboard local (si exposé) ou tester en direct depuis Dom :
   ```bash
   curl -s -u lea:changeme-dashboard-Medecin2026! http://localhost:5001/ | head -20
   ```

**Critère de succès** : page HTML renvoyée (pas de 401).

**Critère d'échec** : 401 persistant → vérifier `DASHBOARD_PASSWORD` dans l'env systemd :
```bash
systemctl --user show rpa-vision-v3-dashboard | grep DASHBOARD_PASSWORD
```

---

### Test 3 — Enrichissement UI côté serveur (objectif 3, C2)

**Pré-conditions** : Test 1 exécuté, session créée et finalisée.

**Actions** :
```bash
# Récupérer l'ID de la dernière session
SESS=$(curl -s http://localhost:5005/api/v1/traces/stream/sessions | \
       python3 -c "import json,sys; d=json.load(sys.stdin); print(d[-1]['session_id'])")
echo "Session : $SESS"

# Récupérer la session détaillée (doit contenir les ScreenStates enrichis)
curl -s "http://localhost:5005/api/v1/traces/stream/session/$SESS" \
  | python3 -m json.tool > /tmp/sess_16avril.json
wc -l /tmp/sess_16avril.json
```

**Vérifier le contenu des ScreenStates persistés** :
```bash
# Les ScreenStates JSON sont sauvegardés sous data/screen_states/<YYYY-MM-DD>/
find /home/dom/ai/rpa_vision_v3/data/screen_states -name "state_*.json" -newer /tmp/sess_16avril.json -type f 2>/dev/null | head -5

# Pour un fichier donné, vérifier ui_elements ET detected_text non vides
LAST_STATE=$(find /home/dom/ai/rpa_vision_v3/data/screen_states -name "state_*.json" -type f -printf '%T@ %p\n' | sort -n | tail -1 | awk '{print $2}')
python3 -c "
import json
d = json.load(open('$LAST_STATE'))
print('ui_elements count:', len(d.get('ui_elements', [])))
print('detected_text len:', len(d.get('detected_text', '')))
print('sample ui_element:', d.get('ui_elements', [{}])[0] if d.get('ui_elements') else 'NONE')
"
```

**Critères de succès** :
- `ui_elements count >= 3` sur un écran normal (Notepad ouvert ~5-15 éléments)
- `detected_text len > 20` (le texte OCR doit contenir des mots lisibles)
- Au moins un `ui_element` avec un `role` rempli (`button`, `textbox`, `menu`, etc.)

**Critère d'échec** : `ui_elements count == 0` partout → C2 ne tourne pas côté serveur. Vérifier logs `./svc.sh logs streaming | grep -iE "detect|ocr|screen_analyzer"`.

---

### Test 4 — Target resolution (objectifs 4, C1 + Lot E)

**Pré-conditions** : une session Test 1 réussie, avec au moins 2-3 actions.

**Actions** — demander un replay via l'endpoint :
```bash
curl -s -X POST http://localhost:5005/api/v1/traces/stream/replay \
  -H "Authorization: Bearer 86031addb338e449fccdb1a983f61807aec15d42d482b9c7748ad607dc23caab" \
  -H "Content-Type: application/json" \
  -d "{\"session_id\": \"$SESS\", \"mode\": \"dry_run\"}" \
  | python3 -m json.tool > /tmp/replay_plan.json
```

**Vérifications** :
```bash
# Le plan doit contenir des TargetSpec avec by_role / by_text, pas juste des coordonnées
grep -E "\"by_role\"|\"by_text\"" /tmp/replay_plan.json | head -10
grep -E "\"unknown_element\"" /tmp/replay_plan.json | wc -l
```

**Critères de succès** :
- Au moins 50% des `TargetSpec` ont un `by_role` OU un `by_text` non null
- Moins de 20% des cibles sont marquées `unknown_element`

**Critère d'échec** : 100% `unknown_element` → target_resolver ne lit pas les `ui_elements`. Relire logs streaming pour erreurs d'import.

---

### Test 5 — Cache context-aware (objectif 5, Lot D)

**But** : s'assurer que deux workflows différents sur le même écran ne partagent pas le cache de target resolution.

**Actions** (simplifié — pas de test unitaire ici, juste observation) :
1. Côté VM, enregistrer une session 1 : ouvrir Bloc-notes, cliquer sur menu "Fichier" → "Nouveau".
2. Arrêter l'enregistrement ("C'est terminé").
3. Redémarrer un enregistrement (session 2) : même écran Bloc-notes, mais cliquer "Fichier" → "Enregistrer".
4. Arrêter.

**Vérifications côté serveur** :
```bash
./svc.sh logs streaming | grep -iE "cache_key|cache hit|context_hints" | tail -20
```

**Critère de succès** : les `cache_key` des deux sessions diffèrent même si le ScreenState est similaire (le `context_hints` dans la clé fait la différence).

**Critère d'échec** : même `cache_key`, même résultat → bug Lot D. Pas bloquant pour la démo mais à noter.

---

### Test 6 — Fail-safe UAC (objectif 6, P0-D)

**But** : un popup UAC bloque le replay proprement.

**Actions** :
1. Côté VM, lancer un replay d'une session existante (Test 4 ci-dessus).
2. **Pendant l'exécution**, faire clic droit sur un `.exe` nécessitant élévation → "Exécuter en tant qu'administrateur" → le popup UAC apparaît.
3. **Ne pas cliquer** sur le UAC.

**Observations attendues** :
- Côté VM : Léa arrête toute action (pas de clic sur UAC)
- Côté serveur, logs :
  ```bash
  ./svc.sh logs streaming | grep -iE "UAC|CredUI|SmartScreen|paused_need_help" | tail -5
  ```
  → messages du type `paused_need_help` ou `élévation de privilèges (UAC) détectée`

**Critère de succès** :
- Aucun clic envoyé sur la fenêtre UAC
- Le replay passe en `status: paused_need_help`
- Un appel `curl .../replay/<replay_id>` montre bien ce statut

**Critère d'échec critique** : Léa clique sur "Oui" / "Non" de l'UAC → **arrêter immédiatement les tests**, c'est une régression de sécurité.

**Cleanup** : fermer manuellement le popup UAC (clic sur Non).

---

### Test 7 — Blur PII côté serveur (objectif 9)

**But** : vérifier que les screenshots contenant des noms/mails sont bien floutés côté serveur.

**Actions côté VM** :
1. Ouvrir Bloc-notes, écrire :
   ```
   Patient : Jean Dupont
   Né le 12/03/1980
   Tél : 06 12 34 56 78
   Email : jean.dupont@test.fr
   ```
2. Lancer un enregistrement court via le menu Léa.
3. Faire 2-3 clics dans Bloc-notes (scroll, sélection).
4. Arrêter.

**Vérifications côté serveur** :
```bash
# Chercher les paires _raw / _blurred dans la session
SESS_DIR=$(find /home/dom/ai/rpa_vision_v3/data -type d -name "$SESS*" 2>/dev/null | head -1)
ls -la "$SESS_DIR"/*.png 2>/dev/null | grep -E "_blurred|_raw" | head -10

# Comparer les tailles — le _blurred doit exister
find /home/dom/ai/rpa_vision_v3/data -name "*_blurred.png" -newer /tmp/sess_16avril.json 2>/dev/null | head -5
```

**Critères de succès** :
- Au moins un fichier `*_blurred.png` présent pour cette session
- Ouvert dans un viewer, les zones "Jean Dupont", "06 12 34...", "jean.dupont@..." sont floutées/boxées
- Le fichier `*_raw.png` reste net (destiné à l'entraînement)

**Critère d'échec** : aucun `_blurred.png` généré → module `core/anonymisation/pii_blur.py` pas appelé. Vérifier les logs avec `grep -i "pii_blur\|anonymisation"`.

---

### Test 8 — Logs d'audit (objectif 10)

**Actions** :
```bash
# Vérifier que le fichier JSONL du jour existe et se remplit
ls -la /home/dom/ai/rpa_vision_v3/data/audit/audit_2026-04-16.jsonl
tail -5 /home/dom/ai/rpa_vision_v3/data/audit/audit_2026-04-16.jsonl | python3 -m json.tool

# Endpoint d'audit (API_TOKEN requis si sécurisé — ici en dev)
curl -s "http://localhost:5005/api/v1/audit/history?limit=5" \
  | python3 -m json.tool | head -60

# Summary du jour
curl -s "http://localhost:5005/api/v1/audit/summary?date=2026-04-16" \
  | python3 -m json.tool
```

**Critères de succès** :
- Fichier `audit_2026-04-16.jsonl` existe
- Chaque ligne contient `timestamp`, `session_id`, `action_id`, `machine_id`, `action_type`, `result`
- Le `machine_id` correspond à la VM (pas "Unknown")

**Critère d'échec** : fichier inexistant → `AuditTrail` pas initialisé. Vérifier logs streaming au démarrage.

---

### Test 9 (bonus si temps) — Replay E2E complet sur Bloc-notes

**But** : valider la chaîne complète apprentissage → replay réussi.

**Actions** :
1. Sur la VM, enregistrer : ouvrir Bloc-notes depuis le menu Démarrer → taper "Hello Lea 16 avril" → Fichier → Enregistrer sous → Bureau → Nom "test_lea.txt" → Enregistrer.
2. Arrêter l'enregistrement.
3. Fermer Bloc-notes et supprimer le fichier créé.
4. Lancer le replay depuis le menu Léa (ou via API curl Test 4 sans `dry_run`).

**Critères de succès** :
- Bloc-notes s'ouvre tout seul
- Le texte est tapé (attention AZERTY : si c'est Qwerty côté VM, possible que "Lea" sorte en "Léq" — noter mais pas bloquant)
- Le fichier `test_lea.txt` est créé sur le Bureau
- Statut replay final : `completed`

---

## Section 4 — Diagnostic rapide

| # | Symptôme | Cause probable | Comment vérifier | Fix rapide |
|---|----------|----------------|------------------|------------|
| 1 | Léa ne démarre pas (pas d'icône systray) | `.venv` absent ou install interrompue | `dir C:\rpa_vision\.venv\Scripts\python.exe` | Relancer `install.bat` |
| 2 | Léa démarre puis crash (console ferme) | Erreur Python au boot | Lancer à la main : `C:\rpa_vision\.venv\Scripts\python.exe C:\rpa_vision\run_agent_v1.py` → lire la stack trace | Selon l'erreur : check deps, check `config.txt`, check `RPA_SERVER_URL` |
| 3 | Agent tourne mais rien n'arrive côté serveur | Mauvais `RPA_SERVER_URL` / firewall / DNS | Sur la VM : `curl https://lea.labs.laurinebazin.design/health` | Corriger URL dans `config.txt`, relancer `Lea.bat` |
| 4 | 401 Unauthorized côté serveur | Token différent entre VM et serveur | `grep RPA_API_TOKEN C:\rpa_vision\config.txt` vs `grep RPA_API_TOKEN /home/dom/ai/rpa_vision_v3/.env.local` | Aligner les deux, relancer `Lea.bat` et `./svc.sh restart streaming` |
| 5 | Popup UAC → Léa clique dessus | **RÉGRESSION CRITIQUE** | Voir logs `grep -i UAC` côté serveur | **Arrêter le test**, remonter à Dom |
| 6 | `total_active == 0` dans /fleet | Enrollment jamais déclenché ou échoué | Logs streaming : `grep FLEET` | Vérifier que le build contient `agent_registry.py` côté client + relancer |
| 7 | `ui_elements = []` dans les ScreenStates | C2 pas appelé ou Ollama down | `curl http://localhost:11434/api/tags` + logs streaming `grep -i detector` | Relancer Ollama : `systemctl --user restart ollama` |
| 8 | `by_role`/`by_text` tous null | TargetSpecBuilder ne lit pas les UIElements | Logs streaming `grep -i target_spec` | Bug code — noter et passer au test suivant |
| 9 | Aucun `_blurred.png` | `pii_blur.py` pas appelé | Logs : `grep -i "blur\|anonymisation"` | Vérifier que les imports côté serveur passent |
| 10 | Replay planté sans erreur claire | Session incomplète, pas de workflow compilé | `curl .../workflow/compile` en direct | Re-enregistrer une nouvelle session plus courte |

### Commandes debug utiles (à garder sous la main)

```bash
# État global
./svc.sh status
./status.sh

# Logs live streaming
./svc.sh logs streaming -f

# Dernière session streamée
curl -s http://localhost:5005/api/v1/traces/stream/sessions | python3 -m json.tool | tail -30

# Dernier screenshot reçu (ordre décroissant)
ls -lt /home/dom/ai/rpa_vision_v3/data/streaming_sessions/*.json | head -3

# Audit du jour
tail -f /home/dom/ai/rpa_vision_v3/data/audit/audit_2026-04-16.jsonl

# Base fleet
sqlite3 /home/dom/ai/rpa_vision_v3/data/databases/rpa_data.db \
  "SELECT machine_id, user_name, hostname, version, status, enrolled_at FROM enrolled_agents;"
```

---

## Section 5 — Grille d'observation C2 (enrichissement UI)

### Comment vérifier concrètement que C2 fonctionne

**Niveau 1 — ScreenState persisté** :
```bash
LAST_STATE=$(find /home/dom/ai/rpa_vision_v3/data/screen_states -name "state_*.json" -type f -printf '%T@ %p\n' 2>/dev/null | sort -n | tail -1 | awk '{print $2}')

python3 <<EOF
import json
d = json.load(open("$LAST_STATE"))
print("screen_state_id:", d.get("screen_state_id"))
print("ui_elements count:", len(d.get("ui_elements", [])))
print("detected_text length:", len(d.get("detected_text", "")))
if d.get("ui_elements"):
    el = d["ui_elements"][0]
    print("first element keys:", list(el.keys()))
    print("first element role:", el.get("role"))
    print("first element text:", el.get("text"))
    print("first element bbox:", el.get("bbox"))
EOF
```

**Niveau 2 — TargetSpec dans le workflow compilé** :
```bash
# Récupérer un workflow compilé
WF=$(curl -s http://localhost:5005/api/v1/traces/stream/workflows | \
     python3 -c "import json,sys; d=json.load(sys.stdin); print(d[-1]['workflow_id'])")
curl -s "http://localhost:5005/api/v1/traces/stream/workflow/$WF" \
  | python3 -m json.tool > /tmp/wf.json

# Compter les TargetSpec qualitatifs
python3 <<'EOF'
import json
d = json.load(open("/tmp/wf.json"))
nodes = d.get("nodes", [])
total = len(nodes)
with_role = sum(1 for n in nodes if (n.get("target_spec") or {}).get("by_role"))
with_text = sum(1 for n in nodes if (n.get("target_spec") or {}).get("by_text"))
unknown = sum(1 for n in nodes if (n.get("target_spec") or {}).get("by_role") in (None, "unknown_element"))
print(f"Total nodes   : {total}")
print(f"With by_role  : {with_role} ({100*with_role/max(total,1):.0f}%)")
print(f"With by_text  : {with_text} ({100*with_text/max(total,1):.0f}%)")
print(f"Unknown       : {unknown} ({100*unknown/max(total,1):.0f}%)")
EOF
```

**Exemple de TargetSpec attendu (succès C2)** :
```json
{
  "by_role": "button",
  "by_text": "Enregistrer",
  "by_position": {"x": 0.52, "y": 0.89},
  "context_hints": {"near_text": "Nom du fichier"}
}
```

**Exemple de TargetSpec dégradé (C2 ne tourne pas)** :
```json
{
  "by_role": "unknown_element",
  "by_text": null,
  "by_position": {"x": 1024, "y": 768}
}
```

---

## Section 6 — Ce qu'on veut éviter

1. **Ne pas lancer deux instances Léa en même temps sur la VM** — le lock PID suffit normalement, mais vérifier manuellement : une seule ligne `pythonw` dans `tasklist`.
2. **Ne pas exposer le dashboard sur Internet pendant les tests** — rester sur `http://localhost:5001/` côté Dom. Le VWB exposé est OK (auth Basic), le dashboard non.
3. **Ne jamais tester avec des données patient réelles** — c'est un POC. Utiliser uniquement des noms/codes de test ("Jean Dupont", "TestPatient01", etc.).
4. **Ne pas interrompre un replay en cours avec Ctrl+C dans la console** — utiliser le menu Léa "Stop" pour arrêt propre (sinon le lock reste et il faut le tuer à la main).
5. **Ne pas modifier `config.txt` pendant que Léa tourne** — la config est lue au démarrage uniquement. Redémarrer après modif.
6. **Ne pas supprimer `C:\rpa_vision_old_16avril\`** avant d'avoir validé que la nouvelle version marche (rollback possible).
7. **Ne pas cliquer sur le popup UAC pendant le Test 6** — c'est le but du test, le laisser apparaître et attendre que Léa s'arrête.
8. **Ne pas toucher aux services systemd côté Dom pendant qu'un test tourne** — attendre la fin du test avant `./svc.sh restart`.
9. **Ne pas déployer le ZIP sur la VM "prod"** — uniquement VM de test. Ce build contient des fonctionnalités non validées.
10. **Ne pas committer le contenu de `data/audit/` ou `data/screen_states/`** — ce sont des données de test locales (screenshots + PII éventuelles).

---

## Annexe — URLs et chemins de référence

| Ressource | URL / chemin |
|-----------|--------------|
| Streaming API (local) | http://localhost:5005 |
| Streaming API (Internet) | https://lea.labs.laurinebazin.design |
| Dashboard (local) | http://localhost:5001 (Basic auth `lea` / `changeme-dashboard-Medecin2026!` ou env `DASHBOARD_PASSWORD`) |
| VWB (Internet) | https://vwb.labs.laurinebazin.design (Basic auth `lea` / `Medecin2026!`) |
| Token API | `86031addb338e449fccdb1a983f61807aec15d42d482b9c7748ad607dc23caab` |
| ZIP client | `/home/dom/ai/rpa_vision_v3/deploy/Lea_v1.0.0.zip` |
| Sessions streaming | `/home/dom/ai/rpa_vision_v3/data/streaming_sessions/` |
| ScreenStates persistés | `/home/dom/ai/rpa_vision_v3/data/screen_states/YYYY-MM-DD/` |
| Audit logs | `/home/dom/ai/rpa_vision_v3/data/audit/audit_YYYY-MM-DD.jsonl` |
| Base fleet SQLite | `/home/dom/ai/rpa_vision_v3/data/databases/rpa_data.db` (table `enrolled_agents`) |
| Logs services | `./svc.sh logs <service>` ou `/home/dom/ai/rpa_vision_v3/logs/` |

---

## Checklist finale (à cocher au fur et à mesure)

- [ ] 1.1 — Services Linux up
- [ ] 1.2 — Endpoints Internet OK
- [ ] 1.3 — VM prête, internet OK
- [ ] 2.x — ZIP déployé, Léa démarre
- [ ] Test 1 — Streaming + enrollment OK
- [ ] Test 2 — Auth dashboard OK
- [ ] Test 3 — ScreenStates enrichis (C2)
- [ ] Test 4 — TargetSpec qualitatifs (C1 + Lot E)
- [ ] Test 5 — Cache context-aware (Lot D)
- [ ] Test 6 — Fail-safe UAC (P0-D)
- [ ] Test 7 — Blur PII serveur
- [ ] Test 8 — Logs audit
- [ ] Test 9 (bonus) — Replay E2E Bloc-notes

Bonne session ! En cas de blocage, revenir à la Section 4 avant de plonger dans le code.