# Synthèse — 11 avril 2026 (préparée pendant ton absence)

Ce document résume ce qui s'est passé pendant ton absence. Lecture : ~10 minutes.

## 🎯 À lire en premier (60 secondes)

**Score global guardian : 6.8/10** — direction bonne, 5 commits du jour propres sans régression, mais **3 points critiques** à adresser.

### Les 3 actions à faire en rentrant (ordre de priorité)

1. **🔴 P0 — Committer `replay_failure_logger.py`** (fichier utilisé partout mais pas tracké git, un fresh clone ne démarre plus). 15 minutes. Bloquant absolu. Guardian item C1.
2. **🔴 P0 — Corriger l'asymétrie `Fenêtre incorrecte` strict → pause apprentissage** (même pattern que `no_screen_change strict` du commit `7cc03f6f1`, mais sur une autre branche). 1-2h. C'est exactement le bug qui a cassé ton test chirurgical ce matin (tu vas voir la timeline dans Partie 1). Guardian item C2.
3. **🔴 P1 — Premier replay Notepad E2E réussi pour activer Phase 1 apprentissage**. La DB `data/learning/target_memory.db` est **vide** (0 entrée). La greffe est câblée mais Léa n'a pas encore appris une seule fois en conditions réelles. Tu pourras l'activer dès que #2 est fait. Guardian item E4.

### Les 3 choses à savoir absolument

- **Test chirurgical** : échec propre au premier clic parce que Bloc-notes n'était plus au premier plan sur la VM (focus perdu). La chaîne stricte a fait exactement son job de protection (3 retries puis stop), mais elle est retombée dans la branche retry+stop legacy au lieu de la pause d'apprentissage. **C'est la preuve vivante du bug #2 ci-dessus.**
- **VWB est un piège** pour le nettoyage de workflows — bug DB runtime + bridge Léa→VWB qui perd 90% de l'info. **Recommandation agent VWB** : écrire un petit outil dédié (200 lignes, 1 jour) plutôt que réparer VWB (4-5 jours). Détails en Partie 4.
- **Code agent en 3 copies divergentes** : source à jour, deploy copy très en retard (sans UIA), worktree migration sans `replay_failure_logger.py`. Merger le worktree EN L'ÉTAT casserait le démarrage. C4 du guardian.

### Ce qui va vraiment bien 🟢

- Les 5 commits de la journée (`b92cb9db0`, `f82753deb`, `9188bd7df`, `a21f1ea9f`, `7cc03f6f1`) sont tous propres, bien documentés, testés et sans régression
- L'instrumentation `[REPLAY]` permet un debug multi-étages lisible
- La Phase 1 apprentissage est une greffe minimale et non-intrusive (exactement comme prévu dans le plan)
- Le fix de C (`7cc03f6f1`) montre la rigueur post-correction : re-lecture des feedbacks mémoire, pas de rustine
- Tests E2E + unit (hors VWB) toujours verts : 56/56

Le détail complet ci-dessous, partie par partie.

---

## Partie 1 — Résultat du test chirurgical

### Protocole
- Replay `replay_free_3935cd0b` lancé sur la session `sess_20260411T084629_2d588e`
- 3 actions injectées : click `Fichier` → wait 800ms → click `Enregistrer`
- Chaque click en mode `success_strict=True`, `expected_before='test.txt – Bloc-notes'`
- Les gardes B (score + drift) et C (pause apprentissage) sont en place

### Timeline
```
09:31:09  DISPATCH   test_chir_1_fichier (click Fichier)
09:31:11  REPORT     success=False error="Fenêtre incorrecte: 'Program Manager' (attendu: 'test.txt – Bloc-notes')"
09:31:11  VERIFY     final_success=False
09:31:11  DISPATCH   retry1
09:31:12  REPORT     success=False error="Fenêtre incorrecte: 'Program Manager' ..."  (identique)
09:31:13  DISPATCH   wait_retry (2s)
09:31:16  DISPATCH   retry2
09:31:17  REPORT     success=False error="Fenêtre incorrecte: 'Program Manager' ..."  (identique)
09:31:18  DISPATCH   retry3
09:31:19  REPORT     success=False error="Fenêtre incorrecte: 'Program Manager' ..."  (identique)
09:31:19  Replay échoué à test_chir_1_fichier_retry3 après 3 retries: status=error
```

### Analyse critique

**Ce qui a BIEN fonctionné** (à conserver) :
- `_validate_match_context` côté agent Windows : a détecté le mismatch de fenêtre active (`Program Manager` vs `test.txt – Bloc-notes`)
- **Pas de clic dans le vide** : la pré-vérif stricte refuse de cliquer quand la fenêtre active n'est pas celle attendue, exactement comme prévu
- Instrumentation `[REPLAY]` parfaitement lisible : chaque étape, chaque erreur, chaque retry
- Retry automatique × 3 avec wait interleaved

**Ce qui a MAL fonctionné** (à corriger) :

1. **`Bloc-notes` n'était plus au premier plan** quand le test a démarré. La fenêtre active sur la VM était `Program Manager` (= le bureau Windows). Hypothèses :
   - Tu as fermé Bloc-notes avant de partir
   - Un événement Windows a volé le focus (notification, chat Léa, etc.)
   - Bloc-notes était minimisé

2. **L'erreur `Fenêtre incorrecte` en mode strict retombe dans la branche retry+stop** (réflexe RPA classique), **pas** dans la pause apprentissage. C'est une **incohérence** avec le correctif C que j'ai fait pour `no_screen_change` : les deux devraient avoir le même traitement.

### Ce qu'il aurait fallu faire

Dans `api_stream.py`, la branche qui traite l'erreur `Fenêtre incorrecte` devrait :
- En mode **strict** : `status = "paused_need_help"` avec `pause_message = "Je m'attendais à voir 'test.txt – Bloc-notes' mais je vois 'Program Manager'. Peux-tu me montrer la bonne fenêtre ?"` → queue intacte, attente d'intervention humaine
- En mode **legacy** (non strict) : retry × 3 puis continue (comportement actuel)

C'est **symétrique** au correctif C (`no_screen_change strict → pause apprentissage`). À faire dans un prochain commit.

### Ce que ça valide quand même

Malgré l'échec sur un problème environnemental (focus perdu), **la chaîne stricte complète fonctionne** :
- Pré-vérif stricte ✅
- Retry automatique ✅
- Arrêt propre après retries ✅
- Instrumentation lisible ✅
- Pas de clic "aveugle" dans le désordre ✅

On a juste besoin d'aligner le traitement d'erreur sur la philosophie d'apprentissage.

---

## Partie 2 — Dettes techniques connues (pré-audit)

En attendant le rapport du project-quality-guardian, voici ce que je sais déjà :

### Dettes hautes (connues et documentées)

1. **`agent_v0/deploy/windows_client/agent_v1/core/executor.py`** : 1302 lignes de divergence non committée avec le dev copy. Risque à chaque nouveau packaging Windows.
2. **Module `replay_failure_logger.py`** : importé dans `api_stream.py` mais PAS tracké dans git. Bug pré-existant signalé par le subagent VWB tout à l'heure. À vérifier : soit le fichier existe sur disque (ignoré par gitignore), soit l'import est cassé silencieusement.
3. **Migration `agent_v0/` → top-level** : non mergée, dans un worktree (`.claude/worktrees/agent-a0ebc90f/`). Trois commits prêts mais en attente de ton review.
4. **`visual_workflow_builder/backend/instance/workflows.db`** : modifié non committé depuis le début de la session. Probablement des données de test.
5. **`live_session_manager.py`** : modifié non committé. Dans l'état initial de la session, devrait être committé séparément ou ignoré.

### Dettes moyennes

6. **`_a_trier/`** : dossier de code/scripts à trier, jamais nettoyé. Grande taille, pollue les grep.
7. **`archives/`** : ancien code archivé dans le dépôt. Grossit le repo.
8. **Phase 1 apprentissage activable mais non testée en conditions réelles** : `TargetMemoryStore` est branché mais aucune session n'a encore déclenché un `memory_record_success` ni un `memory_lookup HIT`. Attend le premier replay complet qui réussit.
9. **Agent Windows dev vs deploy vs build/Lea/** : trois copies parallèles du code agent, avec divergences possibles à chaque modification.

### Dettes basses

10. **Clics parasites d'arrêt d'enregistrement** : systématiquement capturés dans les sessions (clic sur systray, icône Léa, bouton Arrêter). À filtrer côté captor (ex: ignorer les N dernières secondes, ou tout clic sur fenêtre Léa).
11. **Phrases types non externalisées** : `pause_message`, `error_description`, etc. sont hardcodées dans le code. Doivent passer en JSON/YAML i18n-ready.
12. **Service `worker` (port 5099)** : toujours inactif. Le worker VLM qui compile les sessions en workflows n'est pas lancé. Résultat : les sessions enregistrées ne sont jamais compilées automatiquement en ExecutionPlan.

---

## Partie 3 — Ce que j'ai fait pendant ton absence (commits)

Aucun commit pendant ton absence. Juste :
- Lancement du test chirurgical (échec propre comme analysé)
- Lancement de 2 agents d'audit en background
- Création de ce document de synthèse

---

## Partie 4 — Résultat des agents d'audit

### Audit projet global — **TERMINÉ** ✅

**Score global** : **6.8/10** — direction technique bonne, 5 commits du jour propres et sans régression, mais **incohérence philosophique non corrigée** + dette de cohérence multi-copies.

#### 🔴 Les 3 choses à savoir en rentrant (synthèse exécutive du guardian)

1. **Phase 1 apprentissage est techniquement branchée MAIS `data/learning/target_memory.db` est VIDE (0 entrée).** Aucun replay n'a encore survécu au post-cond strict pour cristalliser. Ça veut dire que **tu n'as pas encore vu Léa apprendre**, tu as juste câblé l'apprentissage. Le premier replay qui passe en entier déclenchera la boucle.

2. **Asymétrie strict pré-vérif vs post-vérif** (gros point) : le fix `7cc03f6f1` corrige `no_screen_change strict → paused_need_help`, mais **la branche `Fenêtre incorrecte` en pré-vérif strict retombe toujours en retry+stop legacy**. C'est une **violation directe de `feedback_failure_is_learning.md` sur un chemin différent**. Même pattern, même oubli. C'est exactement ce qui a cassé ton test chirurgical ce matin.

3. **Trois copies divergentes du code agent** :
   - `agent_v0/agent_v1/` (source à jour avec UIA, grounding, policy, recovery)
   - `agent_v0/deploy/windows_client/agent_v1/` (1303 lignes non committées, **sans `uia_helper.py`**)
   - `.claude/worktrees/agent-a0ebc90f/` (migration top-level, **sans `replay_failure_logger.py`**)
   
   Tout packaging Windows depuis la deploy copy manque UIA + tous les fix du 10-11 avril. Si tu merges le worktree EN L'ÉTAT, ça casse le démarrage serveur.

#### Cohérence vision / implémentation

5 principes directeurs de la mémoire :
| # | Principe | Statut | Remarque |
|---|---|---|---|
| A1 | 100% visuel (pas de raccourcis inventés) | ✅ Respecté | Grep OK côté replay V4 |
| A2 | LLM 100% local (Ollama) | ⚠️ **Violé dans VWB** | `vlm_provider.py` priorise OpenAI/Gemini/Anthropic avant Ollama, 3 clés cloud dans `.env.local` |
| A3 | Léa n'est pas une boîte à clic | ⚠️ Partiel | Infra en place mais DB vide + asymétrie pré-vérif |
| A4 | Échec = apprentissage, pas arrêt | ⚠️ Partiel | Fix `no_screen_change` OK, pas `Fenêtre incorrecte` |
| A5 | Citrix / 100% vision | ✅ Cohérent | UIA est accélérateur local VM, cascade visuelle reste le core |

**Violation critique découverte** : `visual_workflow_builder/backend/vlm_provider.py` ligne 53-72 — la classe `VisionHub` priorise `OpenAI (gpt-4o) → Gemini → Anthropic → Ollama en dernier`. Importé par `app.py:165`. **Un client déployé avec les mêmes clés d'env enverrait ses écrans médicaux à OpenAI.** Grave.

#### État des fonctionnalités (14 fonctions)

| # | Fonctionnalité | Statut | Preuve |
|---|---|---|---|
| B1 | Agent V1 streaming (capture Windows) | ✅ OK | `executor.py` 2177L, /replay/next pollé |
| B2 | Streaming server `api_stream.py` | ✅ OK | 4401L, rpa-streaming active running |
| B3 | SomEngine (YOLO + docTR + VLM) | ✅ OK (dormant dans cascade) | `_resolve_by_som` défini mais appelé seulement en V4 resolve_order |
| B4 | Resolve cascade (OCR/template/VLM/grounding/SoM) | ✅ OK | `_resolve_target_sync:1530` |
| B5 | Contrôle strict étapes (title_match) | ⚠️ OK post, **incohérent pré** | Cf point #2 ci-dessus |
| B6 | UIA local (lea_uia.exe) | ⚠️ **OK source, ABSENT deploy** | `deploy/windows_client/.../core/` n'a pas `uia_helper.py` |
| B7 | TargetMemoryStore Phase 1 | ⚠️ Greffe OK, **DB vide** | `SELECT COUNT(*) FROM target_memory` → 0 |
| B8 | Instrumentation `[REPLAY]` | ✅ OK | 13 logs structurés |
| B9 | Garde qualité résolution | ✅ OK | 7 tests unitaires inline |
| B10 | `no_screen_change strict → pause` | ✅ OK | commit `7cc03f6f1` |
| B11 | VWB | ⚠️ Audit séparé — BROKEN en écriture | Voir section VWB ci-dessous |
| B12 | Fédération (`core/federation/`) | ✅ Import OK, non testée | |
| B13 | Module auth (`core/auth/`) | ✅ Partiellement branché | |
| B14 | Workers systemd | ⚠️ Mixte | streaming/agent-chat/api OK, dashboard inactive, worker 5099 NOT LISTENING, healthcheck failed |

#### Dettes techniques — 20 items priorisés (rapport complet)

**🔴 Priorité haute** (5 items) :

| # | Lieu | Nature | Effort |
|---|---|---|---|
| **C1** | `agent_v0/server_v1/replay_failure_logger.py` | **Fichier ni tracké ni gitignoré**, importé à `api_stream.py:29`. **Un `git clone` ne peut plus démarrer le serveur.** | < 15 min (git add) |
| **C2** | `api_stream.py` branche `Fenêtre incorrecte` | Asymétrie avec fix `7cc03f6f1` — bloquer avec `paused_need_help` au lieu de retry+stop | 1-2h |
| **C3** | `deploy/windows_client/agent_v1/core/executor.py` | 1303 insertions non committées, manque `uia_helper.py` + `grounding.py` + `policy.py` + `recovery.py` | Demi-journée |
| **C4** | `.claude/worktrees/agent-a0ebc90f/` | Worktree ne contient pas `replay_failure_logger.py` → merge cassera l'import | 1-2h |
| **C5** | `tests/unit/test_som_integration.py::test_resolve_success` | Mock cassé par refactoring, cible `api_stream._get_som_engine_api` au lieu de `resolve_engine.*` | 30 min |

**🟡 Priorité moyenne** (7 items) :

- **C6** : `vlm_provider.py` cloud-first (violation A2) — 1-2h
- **C7** : `live_session_manager.py` 118 lignes non committées (code propre utile) — 30 min
- **C8** : Worker port 5099 inactif (sessions jamais compilées en ExecutionPlan) — 1-2h
- **C9** : Services systemd healthcheck + artifact-retention failed — 30 min
- **C10** : Scaffold vide `agent_v1/` top-level — < 15 min
- **C11** : 22 fichiers en `M` non committés (diffus) — demi-journée triage
- **C12** : `core/detection/vlm_config.py` non tracké — 10 min

**🟢 Priorité basse** (8 items) :

- **C13** : `_a_trier/` 561 Mo + `visual_workflow_builder/_a_trier/` 7.6 Go
- **C14** : 2 venvs VWB → 15.6 Go disque
- **C15** : `core/execution/target_resolver.py` (3495L V3 dormant)
- **C16** : README.md obsolète (décembre 2024)
- **C17** : `web_dashboard/app.py.bak_20260304_2225`
- **C18** : `archives/` 21 Mo committé dans le repo
- **C19** : 53 TODO/FIXME/HACK dans Python
- **C20** : `data/training/live_sessions/` 5.1 Go sans rotation

#### Régressions potentielles depuis le matin

**Aucune nouvelle régression** introduite par les 5 commits du jour. L'incohérence `Fenêtre incorrecte` est **pré-existante** (branche legacy qui aurait dû être corrigée en même temps). Guardian a vérifié les 4 branches de `/replay/result` (lignes 3090-3330) — elles s'enchaînent proprement, pas d'interaction non triviale entre D1-D5.

#### Recommandations priorisées du guardian

| # | Priorité | Action | Effort | Justification vision |
|---|---|---|---|---|
| **E1** | **P0** | Committer `replay_failure_logger.py` | < 15 min | Empêche tout fresh clone/deploiement |
| **E2** | **P0** | Corriger asymétrie `Fenêtre incorrecte` → `paused_need_help` | 1-2h | Respect `feedback_failure_is_learning.md` + débloque test chirurgical |
| **E3** | **P1** | Sync deploy copy avec source + ajouter uia_helper/grounding/policy/recovery | Demi-journée | Sans ça Léa n'a pas accès à ses propres progrès sur VM |
| **E4** | **P1** | **Premier replay E2E réussi** pour activer Phase 1 (Notepad propre, 2 fois, vérifier target_memory.db) | 1-2h | **Seule façon de prouver que Léa apprend vraiment** |
| **E5** | **P1** | Décider du sort du worktree (compléter ou refaire) | 1-2h | Éviter dette multi-copies |
| **E6** | **P2** | Gater `vlm_provider.py` derrière env var (violation 100% local) | 1-2h | Respect `feedback_local_only.md` |
| **E7** | **P2** | Relancer worker 5099 + vérifier compilation sessions | 1-2h | Pipeline apprentissage cassé en bout |
| **E8** | **P2** | Committer `live_session_manager.py` | 30 min | Dette git |
| **E9** | **P3** | Réparer test_som_integration | 30 min | Suite unit verte |
| **E10** | **P3** | Nettoyer 2 venvs VWB | 30 min | 15.6 Go disque |

### Audit VWB — **TERMINÉ** ✅

**TL;DR : VWB est un piège pour notre besoin. Recommandation = Option A (petit outil dédié 1 jour).**

#### État global
Partiellement fonctionnel en **lecture**, **CASSÉ en écriture** (bug runtime trivial), et **gravement amputé en contenu** (bridge Léa→VWB perd 90% de l'information). Le scaffolding est là, la chaîne end-to-end ne fonctionne pas.

#### Bug bloquant immédiat
Le processus 1800738 (vwb-backend:5002) tient un handle sur une version **supprimée** de `workflows.db` (6 file descriptors sur `(deleted)`). Toute écriture → `sqlite3.OperationalError: attempt to write a readonly database`. Un `systemctl --user restart rpa-vwb-backend` règle ce point — mais les vrais problèmes restent.

#### Ambiguïtés structurelles (dette)
| Problème | Impact |
|---|---|
| `frontend/` (vieux, inactif) vs `frontend_v4/` (actif) | Confusion à chaque lecture code |
| `app.py` (5002, avec api_v3) vs `app_lightweight.py` (5003, SANS api_v3) | Deux backends parallèles |
| `db/models.py` (legacy) vs `instance/workflows.db` SQLAlchemy (api_v3) | **Deux DB parallèles** — workflows visibles ici ≠ workflows visibles là |

#### Ce qui marche côté code (vérifié)
- `GET /api/v3/learned-workflows` : liste 126 workflows Léa sur disque
- Routes CRUD Step : add/update/delete/reorder (existent backend + client TS)
- PropertiesPanel 1415 lignes — édite délais, texte, direction, hover_duration
- UI drag-and-drop ajout step via tool palette → React Flow
- `POST /api/v3/execute-windows` : proxy vers streaming server, fonctionnel

#### Ce qui manque (critique pour le nettoyage)

1. **Import compound = coquille vide** : 95% des edges Léa sont des actions `type: compound` avec 10-40 sous-étapes (clic + waits + text_input lettre par lettre). Le bridge crée **UN seul step VWB** pour toute la compound → *"Impossible de nettoyer ce qu'on ne voit pas"*
2. **Pas d'auth VWB → streaming server** : `requests.get(...)` sans header Authorization, donc `streaming_server_available: false`. VWB ne voit que les workflows déjà compilés (max 4 avril), pas les sessions récentes
3. **Pas de screenshots attachés** : les `shots/*.png` de session ne sont jamais liés aux steps importés
4. **Pas de réordonnancement UI** : `reorderSteps` existe backend + client, mais **aucun composant React ne l'appelle**
5. **Édition target_spec absente** : PropertiesPanel n'a **aucun champ** `x_pct`, `y_pct`, `target_role`, `target_text`, `vlm_description`. Impossible de corriger un faux positif
6. **Pas d'ingestion raw events** : `live_events.jsonl`, `build_replay_from_raw_events`, `execution_plan_to_actions` ne sont pas importés dans VWB
7. **Pas de liste "sessions récentes"** : aucun endpoint VWB qui liste les `sess_*` sur disque
8. **Zéro test** sur le pont Léa ↔ VWB

#### Effort de réparation estimé

| Item | Effort |
|---|---|
| Restart service (fix DB readonly) | 5 min |
| Ajouter auth Bearer VWB → :5005 | 30 min |
| Décomposer actions compound en N steps VWB | **1 jour** |
| Attacher screenshots aux steps | **1 jour** |
| Édition target_spec dans PropertiesPanel | 0.5 jour |
| Drag-to-reorder UI | 0.5 jour |
| Endpoint `/live-sessions` + importer raw | **1-2 jours** |
| Tests minimal | 0.5 jour |
| **Total** | **4-5 jours** |

Et encore, **on hériterait de la dette** (deux DB, deux backends, zéro test, frontend abandonné).

#### Recommandation — 3 options

**Option A (recommandée) — Outil dédié léger, 1 jour** ⭐
Écrire un petit Flask (200 lignes) qui :
1. Liste les sessions `live_sessions/*/sess_*` sur disque
2. Charge `live_events.jsonl` via `build_replay_from_raw_events` (existe déjà dans `stream_processor.py:1279`)
3. Affiche la liste linéaire des actions + screenshots `shots/` correspondants
4. Checkbox "supprimer cette étape" + édition texte simple
5. Re-sérialise et POST vers `/api/v1/traces/stream/replay/raw`

**Évite toute la complexité VWB** et cible exactement le besoin : "supprimer 3 clics parasites et relancer".

**Option B — Réparer VWB minimalement (2 jours)** — restart + auth + décomposer compound. Hérite de toute la dette UX.

**Option C — Abandonner VWB** — suggéré par l'accumulation de dette (126 workflows "pending_review", zéro test sur le pont, deux backends, frontend abandonné)

**Vote de l'agent VWB** : *"Option A. Le besoin réel est 'supprimer 3 clics parasites et relancer' — c'est 30 secondes d'UX, pas un Visual Workflow Builder."*

**Mon vote aussi** : **A**. Parce que ça sert directement notre prochain test replay. B prend plus de temps qu'il ne nous fait gagner. C laisse la dette pourrir.

---

## Partie 5 — Actions recommandées quand tu rentres

Par ordre de priorité :

### P0 — À faire dans les 10 premières minutes de ton retour

1. **Vérifier sur la VM** que Bloc-notes est bien fermé (ou pas), et si possible ce qui a volé le focus
2. **Lire la partie 1** de cette synthèse (résultat test chirurgical)
3. **Lire les rapports des 2 agents** (sections 4)

### P1 — À discuter avec moi

4. **Corriger l'incohérence `Fenêtre incorrecte strict → pause apprentissage`** (même pattern que C)
5. **Décider** : on continue à stabiliser le replay avec des tests manuels, OU on passe à l'intégration d'OS-Atlas-Base-7B comme grounder, OU on attaque VWB comme outil de correction ?
6. **Externaliser les phrases types** en JSON i18n (petit commit)

### P2 — Plus tard dans la journée

7. Merger la migration `agent_v0/` → top-level (worktree déjà prêt)
8. Investiguer le fichier `replay_failure_logger.py` (importé, pas tracké)
9. Démarrer le worker VLM pour que les sessions soient compilées en workflows

### P3 — Semaine prochaine

10. Nettoyer `_a_trier/` et `archives/`
11. Sync de l'agent deploy copy avec le dev
12. Implémenter le filtre "ignore clics de fin d'enregistrement" côté captor

---

*Document généré automatiquement pendant l'absence de Dom. Sera mis à jour avec les rapports des agents d'audit.*