rpa_vision_v3/docs/PLAN_TEST_HUMAIN_16AVRIL.md

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 :

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 :

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) :

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 :

:: 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

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

2.4 — Extraire le nouveau ZIP

:: 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 :

   ./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 :

  curl -s http://localhost:5005/api/v1/traces/stream/sessions | python3 -m json.tool | head -40
  

• L'agent apparaît dans /fleet :

  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 :

   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 :

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 :

# 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 :

# 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 :

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 :

# 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 :

./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 :

  ./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 :

# 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 :

# 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)

# É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é :

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é :

# 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) :

{
  "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) :

{
  "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.