docs(handoff): clôture session 2026-05-09

Session de 6h consacrée au fix DETTE-006 (bug d'échelle pixel
grounding). Bilan : 2/5 commits fix faits (smart_resize + refactor
parser bbox_2d), 3/5 bloqués par découverte DETTE-010 (divergence
factor 28 vs 32 sur checkpoint Qwen3-VL-8B-Instruct, à instruire
demain matin).

Effets de bord positifs : registre dette technique créé
(14 entrées P1/P2/P3), investigation mémoire visuelle orpheline
documentée, infra clarifiée (vLLM absent, Transformers direct retenu,
checkpoint Qwen3-VL-8B fp16 téléchargé 17 GB).

Voir docs/handoffs/2026-05-09_session_audit.md pour détail.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

.env.example

@@ -46,6 +46,14 @@ LOGS_PATH=logs
 UPLOADS_PATH=data/training/uploads
 SESSIONS_PATH=data/training/sessions
 
+# ============================================================================
+# Feedback Bus (Léa parle pendant exécution)
+# ============================================================================
+# Bus SocketIO unifié 'lea:*' (action_started, action_done, need_confirm, paused).
+# Désactivé par défaut. Mettre à 1 pour activer les bulles temps réel dans ChatWindow.
+# Si la connexion bus échoue, l'exécution continue normalement (fail-safe).
+LEA_FEEDBACK_BUS=0
+
 # ============================================================================
 # FAISS
 # ============================================================================

agent_chat/app.py

@@ -133,6 +133,28 @@ def _streaming_headers() -> dict:
         headers["Authorization"] = f"Bearer {_STREAMING_API_TOKEN}"
     return headers
 
+
+# ============================================================
+# Feedback Bus — events 'lea:*' temps réel vers ChatWindow
+# ============================================================
+LEA_FEEDBACK_BUS = os.environ.get("LEA_FEEDBACK_BUS", "0").lower() in ("1", "true", "yes", "on")
+
+
+def _emit_lea(event: str, payload: Dict[str, Any]) -> None:
+    """Émet 'lea:{event}' sur le bus SocketIO. No-op silencieux si flag off ou erreur."""
+    if not LEA_FEEDBACK_BUS:
+        return
+    try:
+        socketio.emit(f"lea:{event}", payload)
+    except Exception:
+        logger.debug("_emit_lea silenced", exc_info=True)
+
+
+def _emit_dual(legacy_event: str, lea_event: str, payload: Dict[str, Any], **kwargs) -> None:
+    """Émet l'event legacy (compat dashboard) ET l'alias lea:* (ChatWindow tkinter)."""
+    socketio.emit(legacy_event, payload, **kwargs)
+    _emit_lea(lea_event, payload)
+
 execution_status = {
     "running": False,
     "workflow": None,
@@ -623,7 +645,7 @@ def api_execute():
     }
     
     # Notifier via WebSocket
-    socketio.emit('execution_started', {
+    _emit_dual('execution_started', 'action_started', {
         "workflow": match.workflow_name,
         "params": all_params
     })
@@ -1181,28 +1203,28 @@ def _execute_gesture(gesture):
         )
 
         if resp.status_code == 200:
-            socketio.emit('execution_completed', {
+            _emit_dual('execution_completed', 'done', {
                 "workflow": gesture.name,
                 "success": True,
                 "message": f"Geste '{gesture.name}' ({'+'.join(gesture.keys)}) envoyé",
             })
         else:
             error = resp.text[:200]
-            socketio.emit('execution_completed', {
+            _emit_dual('execution_completed', 'done', {
                 "workflow": gesture.name,
                 "success": False,
                 "message": f"Erreur: {error}",
             })
 
     except http_requests.ConnectionError:
-        socketio.emit('execution_completed', {
+        _emit_dual('execution_completed', 'done', {
             "workflow": gesture.name,
             "success": False,
             "message": "Serveur de streaming non disponible (port 5005).",
         })
     except Exception as e:
         logger.error(f"Gesture execution error: {e}")
-        socketio.emit('execution_completed', {
+        _emit_dual('execution_completed', 'done', {
             "workflow": gesture.name,
             "success": False,
             "message": f"Erreur: {str(e)}",
@@ -1661,6 +1683,52 @@ def handle_copilot_abort():
     })
 
 
+# =============================================================================
+# Bulle paused_need_help — handlers SocketIO depuis ChatWindow (J3.5)
+# =============================================================================
+
+@socketio.on('lea:replay_resume')
+def handle_lea_replay_resume(data):
+    """Bouton Continuer : relayer le resume vers le streaming server."""
+    replay_id = (data or {}).get("replay_id")
+    if not replay_id:
+        _emit_lea("resume_acked", {"status": "error", "detail": "replay_id manquant"})
+        return
+    try:
+        resp = http_requests.post(
+            f"{STREAMING_SERVER_URL}/api/v1/traces/stream/replay/{replay_id}/resume",
+            headers=_streaming_headers(),
+            timeout=5,
+        )
+        if resp.ok:
+            logger.info(f"Replay {replay_id} resume relayé OK")
+            _emit_lea("resume_acked", {"replay_id": replay_id, "status": "ok"})
+        else:
+            detail = resp.text[:200]
+            logger.warning(f"Resume échoué (HTTP {resp.status_code}): {detail}")
+            _emit_lea("resume_acked", {
+                "replay_id": replay_id, "status": "error",
+                "http_status": resp.status_code, "detail": detail,
+            })
+    except Exception as e:
+        logger.warning(f"Resume relay error: {e}")
+        _emit_lea("resume_acked", {
+            "replay_id": replay_id, "status": "error", "detail": str(e),
+        })
+
+
+@socketio.on('lea:replay_abort')
+def handle_lea_replay_abort(data):
+    """Bouton Annuler : arrêter le polling local. Le replay côté streaming sera
+    cleaned up naturellement au prochain replay (cf api_stream._replay_states stale)."""
+    global execution_status
+    replay_id = (data or {}).get("replay_id")
+    execution_status["running"] = False
+    execution_status["message"] = "Annulé par l'utilisateur"
+    logger.info(f"Replay {replay_id or '?'} abort par l'utilisateur (paused bubble)")
+    _emit_lea("abort_acked", {"replay_id": replay_id, "status": "ok"})
+
+
 # =============================================================================
 # Exécution de workflow
 # =============================================================================
@@ -1730,14 +1798,20 @@ def _poll_replay_progress(replay_id: str, workflow_name: str, total_actions: int
     """Suivre la progression d'un replay distant via polling."""
     import time
 
-    max_wait = 120  # 2 minutes max
+    max_wait_running = 120   # 2 min en exécution active
+    max_wait_paused = 600    # 10 min en pause supervisée (humain peut prendre son temps)
     poll_interval = 2.0
     elapsed = 0
+    was_paused = False
 
-    while elapsed < max_wait and execution_status.get("running"):
+    while execution_status.get("running"):
         time.sleep(poll_interval)
         elapsed += poll_interval
 
+        cap = max_wait_paused if was_paused else max_wait_running
+        if elapsed >= cap:
+            break
+
         try:
             resp = http_requests.get(
                 f"{STREAMING_SERVER_URL}/api/v1/traces/stream/replay/{replay_id}",
@@ -1753,7 +1827,26 @@ def _poll_replay_progress(replay_id: str, workflow_name: str, total_actions: int
             failed = data.get("failed_actions", 0)
             progress = int(10 + (completed / max(total_actions, 1)) * 80)
 
-            socketio.emit('execution_progress', {
+            if status == "paused_need_help" and not was_paused:
+                _emit_lea("paused", {
+                    "workflow": workflow_name,
+                    "replay_id": replay_id,
+                    "completed": completed,
+                    "total": total_actions,
+                    "failed_action": data.get("failed_action"),
+                    "reason": data.get("error") or "Action incertaine",
+                })
+                was_paused = True
+                elapsed = 0
+            elif was_paused and status != "paused_need_help":
+                _emit_lea("resumed", {
+                    "workflow": workflow_name,
+                    "replay_id": replay_id,
+                    "status_after": status,
+                })
+                was_paused = False
+
+            _emit_dual('execution_progress', 'action_progress', {
                 "progress": progress,
                 "step": f"Action {completed}/{total_actions} exécutée",
                 "current": completed,
@@ -1922,7 +2015,7 @@ def execute_workflow_copilot(match, params: Dict[str, Any]):
 
     actions = _build_actions_from_workflow(match, params)
     if not actions:
-        socketio.emit('copilot_complete', {
+        _emit_dual('copilot_complete', 'done', {
             "workflow": workflow_name,
             "status": "error",
             "message": "Aucune action exécutable dans ce workflow.",
@@ -1959,7 +2052,7 @@ def execute_workflow_copilot(match, params: Dict[str, Any]):
             break
 
         copilot_state["status"] = "waiting_approval"
-        socketio.emit('copilot_step', {
+        _emit_dual('copilot_step', 'need_confirm', {
             "workflow": workflow_name,
             "step_index": idx,
             "total": total,
@@ -1982,7 +2075,7 @@ def execute_workflow_copilot(match, params: Dict[str, Any]):
 
         if waited >= max_wait:
             copilot_state["status"] = "aborted"
-            socketio.emit('copilot_complete', {
+            _emit_dual('copilot_complete', 'done', {
                 "workflow": workflow_name,
                 "status": "timeout",
                 "message": f"Timeout : pas de réponse après {max_wait}s.",
@@ -1999,7 +2092,7 @@ def execute_workflow_copilot(match, params: Dict[str, Any]):
         elif decision == "skipped":
             copilot_state["skipped"] += 1
             logger.info(f"Copilot skip étape {idx + 1}/{total}")
-            socketio.emit('copilot_step_result', {
+            _emit_dual('copilot_step_result', 'step_result', {
                 "step_index": idx,
                 "total": total,
                 "status": "skipped",
@@ -2034,7 +2127,7 @@ def execute_workflow_copilot(match, params: Dict[str, Any]):
 
                     if action_success:
                         copilot_state["completed"] += 1
-                        socketio.emit('copilot_step_result', {
+                        _emit_dual('copilot_step_result', 'step_result', {
                             "step_index": idx,
                             "total": total,
                             "status": "completed",
@@ -2042,7 +2135,7 @@ def execute_workflow_copilot(match, params: Dict[str, Any]):
                         })
                     else:
                         copilot_state["failed"] += 1
-                        socketio.emit('copilot_step_result', {
+                        _emit_dual('copilot_step_result', 'step_result', {
                             "step_index": idx,
                             "total": total,
                             "status": "failed",
@@ -2051,7 +2144,7 @@ def execute_workflow_copilot(match, params: Dict[str, Any]):
                 else:
                     error = resp.text[:200]
                     copilot_state["failed"] += 1
-                    socketio.emit('copilot_step_result', {
+                    _emit_dual('copilot_step_result', 'step_result', {
                         "step_index": idx,
                         "total": total,
                         "status": "failed",
@@ -2060,7 +2153,7 @@ def execute_workflow_copilot(match, params: Dict[str, Any]):
 
             except http_requests.ConnectionError:
                 copilot_state["failed"] += 1
-                socketio.emit('copilot_step_result', {
+                _emit_dual('copilot_step_result', 'step_result', {
                     "step_index": idx,
                     "total": total,
                     "status": "failed",
@@ -2070,7 +2163,7 @@ def execute_workflow_copilot(match, params: Dict[str, Any]):
             except Exception as e:
                 copilot_state["failed"] += 1
                 logger.error(f"Copilot action error: {e}")
-                socketio.emit('copilot_step_result', {
+                _emit_dual('copilot_step_result', 'step_result', {
                     "step_index": idx,
                     "total": total,
                     "status": "failed",
@@ -2098,7 +2191,7 @@ def execute_workflow_copilot(match, params: Dict[str, Any]):
             f"Copilot terminé : {completed} réussies, "
             f"{skipped} passées, {failed} échouées sur {total} étapes."
         )
-        socketio.emit('copilot_complete', {
+        _emit_dual('copilot_complete', 'done', {
             "workflow": workflow_name,
             "status": "completed" if success else "partial",
             "message": message,
@@ -2175,7 +2268,7 @@ def execute_workflow(match, params):
         execution_status["progress"] = 10
         execution_status["message"] = f"Envoyé à l'Agent V1 ({target_session})"
 
-        socketio.emit('execution_progress', {
+        _emit_dual('execution_progress', 'action_progress', {
             "progress": 10,
             "step": f"Replay envoyé à l'Agent V1 — {total_actions} actions en attente",
             "current": 0,
@@ -2523,7 +2616,7 @@ def update_progress(progress: int, message: str, current: int, total: int):
     execution_status["progress"] = progress
     execution_status["message"] = message
     
-    socketio.emit('execution_progress', {
+    _emit_dual('execution_progress', 'action_progress', {
         "progress": progress,
         "step": message,
         "current": current,
@@ -2543,7 +2636,7 @@ def finish_execution(workflow_name: str, success: bool, message: str):
     if command_history:
         command_history[-1]["status"] = "completed" if success else "failed"
     
-    socketio.emit('execution_completed', {
+    _emit_dual('execution_completed', 'done', {
         "workflow": workflow_name,
         "success": success,
         "message": message

agent_chat/autonomous_planner.py

@@ -49,7 +49,10 @@ try:
     from PIL import Image as PILImage
     import pyautogui
     PYAUTOGUI_AVAILABLE = True
-except ImportError:
+except Exception:
+    # pyautogui peut lever Xlib.error.DisplayConnectionError (pas un ImportError)
+    # quand X n'est pas accessible — typique d'un service systemd headless côté
+    # serveur. Le serveur n'a pas besoin de pyautogui (utilisé côté client agent).
     PYAUTOGUI_AVAILABLE = False
     PILImage = None
     pyautogui = None

agent_v0/agent_v1/core/executor.py

@@ -94,6 +94,11 @@ class ActionExecutorV1:
         # pause supervisée au serveur (`paused_need_help`).
         # Cf. core/system_dialog_guard.py
         self._system_dialog_pause: Optional[Dict[str, Any]] = None
+        # Référence à la ChatWindow Léa V1 (Tkinter) pour afficher les bulles
+        # paused interactives quand le serveur signale une pause supervisée.
+        # Câblée depuis main.py après instanciation des deux objets.
+        # Si None (mode headless / tests), fallback sur self.notifier.
+        self._chat_window_ref = None
         # Log de la resolution physique pour le diagnostic DPI
         self._log_screen_info()
 
@@ -1796,6 +1801,65 @@ Example: x_pct=0.50, y_pct=0.30"""
             self._last_conn_error_logged = False
 
             data = resp.json()
+
+            # Plan B (8 mai 2026 — démo GHT) : si le serveur signale une pause
+            # supervisée, afficher le pause_message dans la ChatWindow Léa V1
+            # (Tkinter, déjà ouverte sur Windows) sous forme de bulle interactive
+            # avec boutons Continuer / Annuler. Permet à l'utilisateur Windows de
+            # voir physiquement ce que Léa attend (pause_for_human ou échec
+            # résolution). Fallback notifier.notify si la ChatWindow n'est pas
+            # câblée (mode headless / tests).
+            if data.get("replay_paused"):
+                pause_msg = data.get("pause_message") or "Léa a besoin de votre aide"
+                replay_id = data.get("replay_id") or ""
+                pause_key = (replay_id, pause_msg)
+                if getattr(self, "_last_pause_msg_shown", None) != pause_key:
+                    self._last_pause_msg_shown = pause_key
+                    completed = data.get("current_action_index", 0)
+                    total = data.get("total_actions", "?")
+                    payload = {
+                        "replay_id": replay_id,
+                        "workflow": "Replay en cours",
+                        "reason": pause_msg,
+                        "completed": completed,
+                        "total": total,
+                    }
+                    # Toast Tkinter custom topmost — visible même si la
+                    # ChatWindow est withdraw()-cachée par défaut. Sans dépendance
+                    # plyer (Focus Assist Windows 11 filtre les balloons système).
+                    try:
+                        from ..ui.paused_toast import show_paused_toast
+                        show_paused_toast(
+                            title="Léa a besoin de votre aide",
+                            message=pause_msg[:300],
+                        )
+                    except Exception:
+                        logger.debug("paused_toast launch silenced", exc_info=True)
+
+                    chat_window = getattr(self, "_chat_window_ref", None)
+                    if chat_window is not None:
+                        try:
+                            # _add_paused_bubble est thread-safe (utilise root.after)
+                            # et force l'affichage de la fenêtre + toast topmost
+                            chat_window._add_paused_bubble(payload)
+                        except Exception:
+                            logger.debug(
+                                "chat_window._add_paused_bubble pause silenced",
+                                exc_info=True,
+                            )
+                    else:
+                        # Fallback notifier (tests headless / chat fermé)
+                        try:
+                            self.notifier.notify(
+                                title="Léa — j'ai besoin de vous",
+                                message=pause_msg[:300],
+                                timeout=15,
+                                bypass_rate_limit=True,
+                            )
+                        except Exception:
+                            logger.debug("notifier.notify pause silenced", exc_info=True)
+                return False
+
             action = data.get("action")
             if action is None:
                 return False
@@ -2297,7 +2361,7 @@ Example: x_pct=0.50, y_pct=0.30"""
 
         best_match = None
         best_val = 0.0
-        threshold = 0.50  # Seuil équilibré
+        threshold = 0.75  # Démo GHT 8 mai — éviter faux positifs (placeholders italiques, tabs voisins). En dessous, mieux vaut tomber en mode apprentissage humain qu'un clic au pif.
 
         # Essayer plusieurs tailles de police pour couvrir différentes résolutions
         for font_size in [14, 16, 18, 20, 22, 24, 12, 26, 28, 10]:

agent_v0/agent_v1/main.py

@@ -116,6 +116,14 @@ class AgentV1:
         # Executeur pour le replay (doit exister avant le poll)
         self._executor = ActionExecutorV1()
 
+        # Wiring ChatWindow → Executor pour Plan B (pause_message → bulle interactive)
+        # Permet à l'executor d'afficher une bulle paused dans la fenêtre Léa V1
+        # quand le serveur signale replay_paused=True via /replay/next.
+        try:
+            self._executor._chat_window_ref = self._chat_window
+        except Exception:
+            logger.debug("Wiring chat_window→executor échoué (non bloquant)", exc_info=True)
+
         # Boucles permanentes (pas besoin de session active)
         self.running = True
         self._bg_vision = VisionCapturer(str(SESSIONS_ROOT / "_background"))
@@ -448,6 +456,12 @@ class AgentV1:
                         window_title = self.vision.get_active_window_title()
                         if window_title:
                             heartbeat_event["active_window_title"] = window_title
+                        # QW1 — enrichissement multi-écrans (additif, fallback gracieux)
+                        try:
+                            from .vision.capturer import _enrich_with_monitor_info
+                            _enrich_with_monitor_info(heartbeat_event)
+                        except Exception:
+                            pass
                         self.streamer.push_event(heartbeat_event)
             except Exception as e:
                 logger.error(f"Heartbeat error: {e}")

agent_v0/agent_v1/network/feedback_bus.py

@@ -0,0 +1,149 @@
+# agent_v1/network/feedback_bus.py
+"""Client SocketIO pour le bus feedback Léa.
+
+Consomme les events 'lea:*' émis par agent_chat (port 5004) et les dispatche
+vers ChatWindow pour affichage en bulles temps réel.
+
+Events écoutés :
+    lea:action_started   — début d'un workflow ou d'une action
+    lea:action_progress  — progression dans le workflow
+    lea:done             — fin d'un workflow ou d'un copilot
+    lea:need_confirm     — étape copilot en attente de validation
+    lea:step_result      — résultat d'une étape copilot
+    lea:paused           — basculement en paused_need_help (asset démo)
+    lea:resumed          — sortie de pause supervisée
+
+Fail-safe : toute erreur de connexion ou de dispatch est silencieusement
+loggée. Le ChatWindow continue de fonctionner même si le bus est mort
+(comportement strictement identique au pré-J3).
+
+Usage :
+    bus = FeedbackBusClient(
+        server_url="http://localhost:5004",
+        token=os.environ.get("RPA_API_TOKEN", ""),
+        on_event=lambda event, payload: print(event, payload),
+    )
+    bus.start()  # connexion en arrière-plan, non-bloquant
+    # ... ChatWindow tourne ...
+    bus.stop()
+"""
+
+import logging
+import threading
+from typing import Callable, Optional
+
+import socketio
+
+logger = logging.getLogger(__name__)
+
+LEA_EVENTS = (
+    'lea:action_started',
+    'lea:action_progress',
+    'lea:done',
+    'lea:need_confirm',
+    'lea:step_result',
+    'lea:paused',
+    'lea:resumed',
+)
+
+EventCallback = Callable[[str, dict], None]
+
+
+class FeedbackBusClient:
+    """Client SocketIO non-bloquant pour le bus 'lea:*'."""
+
+    def __init__(
+        self,
+        server_url: str,
+        token: Optional[str] = None,
+        on_event: Optional[EventCallback] = None,
+    ):
+        self._url = server_url.rstrip('/')
+        self._token = token or None
+        self._on_event: EventCallback = on_event or (lambda e, p: None)
+        self._sio = socketio.Client(
+            reconnection=True,
+            reconnection_attempts=0,   # 0 = illimité
+            reconnection_delay=2,
+            reconnection_delay_max=30,
+            logger=False,
+            engineio_logger=False,
+        )
+        self._thread: Optional[threading.Thread] = None
+        self._register_handlers()
+
+    def _register_handlers(self) -> None:
+        @self._sio.event
+        def connect():
+            logger.info("FeedbackBus connecté à %s", self._url)
+
+        @self._sio.event
+        def disconnect():
+            logger.info("FeedbackBus déconnecté")
+
+        for ev in LEA_EVENTS:
+            self._sio.on(ev, lambda data, e=ev: self._dispatch(e, data))
+
+    def _dispatch(self, event: str, payload: Optional[dict]) -> None:
+        try:
+            self._on_event(event, payload or {})
+        except Exception:
+            logger.debug("FeedbackBus dispatch silenced", exc_info=True)
+
+    def start(self) -> None:
+        """Démarrer la connexion en arrière-plan (idempotent, non-bloquant)."""
+        if self._thread is not None and self._thread.is_alive():
+            return
+        self._thread = threading.Thread(
+            target=self._run, daemon=True, name="LeaFeedbackBus",
+        )
+        self._thread.start()
+
+    def _run(self) -> None:
+        headers = {}
+        if self._token:
+            headers['Authorization'] = f'Bearer {self._token}'
+        try:
+            self._sio.connect(self._url, headers=headers, wait=True)
+            self._sio.wait()
+        except Exception as e:
+            logger.warning(
+                "FeedbackBus connect échoué (%s) — ChatWindow continue normalement", e,
+            )
+
+    def stop(self) -> None:
+        """Arrêter proprement la connexion (idempotent, fail-safe)."""
+        try:
+            if self._sio.connected:
+                self._sio.disconnect()
+        except Exception:
+            logger.debug("FeedbackBus stop silenced", exc_info=True)
+
+    @property
+    def connected(self) -> bool:
+        return bool(self._sio.connected)
+
+    # ------------------------------------------------------------------
+    # Actions utilisateur depuis la bulle paused_need_help (J3.5)
+    # ------------------------------------------------------------------
+
+    def resume_replay(self, replay_id: str) -> bool:
+        """Bouton Continuer : émet 'lea:replay_resume' vers agent_chat.
+
+        Retourne True si l'event a pu être émis, False sinon (déconnecté/erreur).
+        """
+        return self._safe_emit("lea:replay_resume", {"replay_id": replay_id})
+
+    def abort_replay(self, replay_id: str) -> bool:
+        """Bouton Annuler : émet 'lea:replay_abort' vers agent_chat."""
+        return self._safe_emit("lea:replay_abort", {"replay_id": replay_id})
+
+    def _safe_emit(self, event: str, payload: dict) -> bool:
+        try:
+            if not self._sio.connected:
+                return False
+            self._sio.emit(event, payload)
+            return True
+        except Exception:
+            logger.debug("FeedbackBus _safe_emit silenced", exc_info=True)
+            return False

agent_v0/agent_v1/requirements.txt

@@ -3,7 +3,9 @@ mss>=9.0.1              # Capture d'écran haute performance
 pynput>=1.7.7           # Clavier/Souris Cross-plateforme
 Pillow>=10.0.0          # Crops et processing image
 requests>=2.31.0        # Streaming réseau
+python-socketio[client]>=5.10,<6.0  # Bus feedback Léa 'lea:*' (compat Flask-SocketIO 5.3.x serveur)
 psutil>=5.9.0           # Monitoring CPU/RAM
+screeninfo>=0.8         # QW1 — détection des monitors physiques + offsets
 pystray>=0.19.5         # Icône Tray UI
 plyer>=2.1.0            # Notifications toast natives (remplace PyQt5)
 pywebview>=5.0          # Fenêtre de chat Léa intégrée (Edge WebView2 sur Windows)

agent_v0/agent_v1/tools/test_lea_toast.py

@@ -0,0 +1,87 @@
+# agent_v1/tools/test_lea_toast.py
+"""
+Test visuel rapide du toast Léa (démo GHT 8 mai 2026).
+
+Lance trois scénarios de toast successifs pour valider l'affichage Windows :
+  1. Toast simple « pause supervisée »
+  2. Toast avec message long (vérifier wraplength)
+  3. Toast type BLOCAGE (= ce que voit l'utilisateur quand Léa est perdue)
+
+Usage Windows :
+    C:\\rpa_vision\\.venv\\Scripts\\python.exe C:\\rpa_vision\\agent_v1\\tools\\test_lea_toast.py
+
+Le script s'attend à voir trois toasts successifs en haut-droite de l'écran
+principal, espacés de ~6 s, fond bleu Léa, autodismiss après 15 s ou clic.
+"""
+from __future__ import annotations
+
+import sys
+import time
+from pathlib import Path
+
+
+def _bootstrap_path() -> None:
+    """Autoriser l'exécution directe sans -m : ajouter C:\\rpa_vision au sys.path."""
+    here = Path(__file__).resolve()
+    # On remonte : tools -> agent_v1 -> rpa_vision (parent du package agent_v1)
+    rpa_root = here.parent.parent.parent
+    if str(rpa_root) not in sys.path:
+        sys.path.insert(0, str(rpa_root))
+
+
+def main() -> int:
+    _bootstrap_path()
+
+    # Import après ajout du path (les deux variantes fonctionnent)
+    try:
+        from agent_v1.ui.paused_toast import show_paused_toast
+    except Exception as e:  # pragma: no cover (debug only)
+        print(f"[TEST] ERREUR import agent_v1.ui.paused_toast : {e}")
+        return 1
+
+    scenarios = [
+        (
+            "Toast 1/3 : pause simple",
+            "Léa a besoin de votre aide",
+            "Test 1/3 — Pause supervisée. Cliquez sur 'Continuer' dans la chat.",
+        ),
+        (
+            "Toast 2/3 : message long",
+            "Léa — j'attends votre validation",
+            (
+                "Test 2/3 — J'ai trouvé 11 dossiers correspondant à vos critères "
+                "(UHCD, Forfait 1, PE2). Je vais traiter le dossier de M. DUPONT "
+                "Jean en premier. Pouvez-vous valider que c'est le bon ordre "
+                "avant que je continue ?"
+            ),
+        ),
+        (
+            "Toast 3/3 : blocage cible non trouvée",
+            "Léa — je ne vois pas l'élément",
+            (
+                "Test 3/3 — Je n'arrive pas à trouver « Examens cliniques » à "
+                "l'écran. Pouvez-vous me montrer où cliquer ?"
+            ),
+        ),
+    ]
+
+    for label, title, message in scenarios:
+        print(f"[TEST] {label}")
+        ok = show_paused_toast(title=title, message=message)
+        print(f"       show_paused_toast() = {ok}")
+        if not ok:
+            print(f"       ECHEC : {label}")
+        # Espacer pour que Dom voit chaque toast distinctement
+        # (rate limit interne = 3s pour message identique, mais ici les
+        # messages diffèrent, le rate limit ne s'applique pas)
+        time.sleep(6)
+
+    print("[TEST] Attente 12s supplémentaires pour laisser le dernier toast vivre...")
+    time.sleep(12)
+    print("[TEST] OK — fin du test. Si vous avez vu 3 toasts bleus en haut-droite,")
+    print("       le mécanisme Léa pause est validé.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

agent_v0/agent_v1/ui/_test_paused_toast.py

@@ -0,0 +1,53 @@
+# agent_v1/ui/_test_paused_toast.py
+"""
+Test isolé du toast paused — à exécuter directement sur Windows.
+
+Usage (sur Windows, depuis C:\\rpa_vision\\agent_v1) :
+    python -m agent_v1.ui._test_paused_toast
+
+OU plus simple :
+    python C:\\rpa_vision\\agent_v1\\ui\\_test_paused_toast.py
+
+Le toast doit s'afficher en haut à droite de l'écran principal pendant ~15s.
+"""
+from __future__ import annotations
+
+import sys
+import time
+
+
+def main() -> int:
+    print("[TEST] Lancement du toast paused...")
+
+    try:
+        # Import flexible : essai relatif puis absolu
+        try:
+            from .paused_toast import show_paused_toast
+        except ImportError:
+            from paused_toast import show_paused_toast
+    except Exception as e:
+        print(f"[TEST] ERREUR import : {e}")
+        return 1
+
+    ok = show_paused_toast(
+        title="Léa a besoin de votre aide",
+        message=(
+            "Test isolé — démo GHT 8 mai 2026.\n"
+            "Si vous voyez ce toast, le mécanisme de pause supervisée "
+            "fonctionne correctement."
+        ),
+    )
+    print(f"[TEST] show_paused_toast() retour = {ok}")
+
+    if not ok:
+        print("[TEST] ÉCHEC : toast non déclenché.")
+        return 2
+
+    print("[TEST] Toast déclenché. Attente de 18s pour le voir s'afficher puis se fermer...")
+    time.sleep(18)
+    print("[TEST] OK — fin du test.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

agent_v0/agent_v1/ui/chat_window.py

@@ -16,6 +16,15 @@ from typing import Any, Callable, Dict, Optional
 
 logger = logging.getLogger(__name__)
 
+# FeedbackBus : import fail-safe (le ChatWindow doit tourner même si python-socketio
+# n'est pas installé sur le poste client, par exemple ancienne installation Pauline)
+try:
+    from ..network.feedback_bus import FeedbackBusClient
+    _HAS_FEEDBACK_BUS = True
+except Exception:
+    FeedbackBusClient = None  # type: ignore
+    _HAS_FEEDBACK_BUS = False
+
 # ---------------------------------------------------------------------------
 # Theme — palette professionnelle claire
 # ---------------------------------------------------------------------------
@@ -42,6 +51,25 @@ SCROLLBAR_BG = "#E5E7EB"     # Fond scrollbar
 SCROLLBAR_FG = "#9CA3AF"     # Curseur scrollbar
 MSG_BORDER_COLOR = "#D1D5DB"  # Bordure subtile des bulles de messages
 
+# Bulle paused_need_help (J3.5) — alerte non bloquante, asset démo majeur
+PAUSED_BG = "#FEF3C7"             # Jaune pâle
+PAUSED_BORDER = "#F59E0B"         # Orange ambré
+PAUSED_FG = "#92400E"             # Brun foncé (lisible sur fond jaune)
+PAUSED_BTN_RESUME_BG = "#22C55E"  # Vert
+PAUSED_BTN_RESUME_HOVER = "#16A34A"
+PAUSED_BTN_ABORT_BG = "#9CA3AF"   # Gris neutre (pas dramatique)
+PAUSED_BTN_ABORT_HOVER = "#6B7280"
+
+# Bulle "Léa exécute" (J3.4) — distincte des bulles chat normales
+ACTION_BG = "#F1F5F9"             # Gris très clair (différencie d'une réponse chat)
+ACTION_BORDER = "#CBD5E1"         # Gris pâle
+ACTION_FG = "#1E293B"             # Gris foncé
+ACTION_META_FG = "#94A3B8"        # Métadonnées en gris discret
+ACTION_ICON_RUN = "#3B82F6"       # Bleu (en cours)
+ACTION_ICON_OK = "#22C55E"        # Vert (succès)
+ACTION_ICON_ERR = "#EF4444"       # Rouge (échec)
+ACTION_ICON_INFO = "#64748B"      # Gris (neutre)
+
 # Dimensions — confortables
 WIN_WIDTH = 600
 WIN_HEIGHT = 800
@@ -62,6 +90,80 @@ FONT_SEND_BTN = ("Segoe UI", 13)
 FONT_RESIZE_GRIP = ("Segoe UI", 10)
 
 
+# ---------------------------------------------------------------------------
+# Templates de bulles "Léa exécute" (J3.4)
+# Chaque template prend un payload et retourne (icon, icon_color, title).
+# Les libellés sont volontairement neutres : le contexte métier vient du
+# payload (workflow, action, message), pas de hardcoding.
+# ---------------------------------------------------------------------------
+
+def _tpl_action_started(payload: Dict[str, Any]) -> tuple:
+    wf = payload.get("workflow") or "?"
+    return ("▶", ACTION_ICON_RUN, f"Démarrage : {wf}")
+
+
+def _tpl_action_progress(payload: Dict[str, Any]) -> tuple:
+    cur = payload.get("current", "?")
+    tot = payload.get("total", "?")
+    step = payload.get("step")
+    title = step if step else f"Étape {cur}/{tot}"
+    return ("⋯", ACTION_ICON_RUN, str(title))
+
+
+def _tpl_done(payload: Dict[str, Any]) -> tuple:
+    success = bool(payload.get("success", True))
+    msg = payload.get("message") or ("Terminé" if success else "Échec")
+    if success:
+        return ("✓", ACTION_ICON_OK, str(msg))
+    return ("✗", ACTION_ICON_ERR, str(msg))
+
+
+def _tpl_need_confirm(payload: Dict[str, Any]) -> tuple:
+    action = payload.get("action") or {}
+    desc = action.get("description") if isinstance(action, dict) else None
+    title = desc or "Validation requise"
+    return ("?", ACTION_ICON_RUN, str(title))
+
+
+def _tpl_step_result(payload: Dict[str, Any]) -> tuple:
+    status = (payload.get("status") or "").lower()
+    msg = payload.get("message") or status or "Étape terminée"
+    if status in ("ok", "success", "approved"):
+        return ("✓", ACTION_ICON_OK, str(msg))
+    if status in ("error", "failed"):
+        return ("✗", ACTION_ICON_ERR, str(msg))
+    return ("·", ACTION_ICON_INFO, str(msg))
+
+
+def _tpl_resumed(payload: Dict[str, Any]) -> tuple:
+    return ("→", ACTION_ICON_OK, "Reprise")
+
+
+_ACTION_TEMPLATES = {
+    "lea:action_started": _tpl_action_started,
+    "lea:action_progress": _tpl_action_progress,
+    "lea:done": _tpl_done,
+    "lea:need_confirm": _tpl_need_confirm,
+    "lea:step_result": _tpl_step_result,
+    "lea:resumed": _tpl_resumed,
+}
+
+
+def _extract_meta(payload: Dict[str, Any]) -> str:
+    """Métadonnées techniques en pied de bulle (workflow, étape, replay_id court)."""
+    parts = []
+    wf = payload.get("workflow")
+    if wf:
+        parts.append(str(wf))
+    cur, tot = payload.get("current"), payload.get("total")
+    if cur is not None and tot is not None:
+        parts.append(f"étape {cur}/{tot}")
+    rid = payload.get("replay_id")
+    if rid:
+        parts.append(f"#{str(rid)[-6:]}")
+    return " • ".join(parts)
+
+
 class ChatWindow:
     """Fenetre de chat Lea en tkinter natif.
 
@@ -91,6 +193,8 @@ class ChatWindow:
         self._root = None
         self._ready = threading.Event()
         self._messages = []  # historique local
+        self._bus: Optional[Any] = None  # FeedbackBusClient (J3.3, peut rester None)
+        self._active_paused_bubble: Optional[Dict[str, Any]] = None  # bulle paused active (J3.5)
 
         # S'abonner aux changements de l'etat partage
         if self._shared_state is not None:
@@ -266,6 +370,9 @@ class ChatWindow:
             # Signaler que la fenetre est prete
             self._ready.set()
 
+            # Demarrer le bus feedback Lea (events 'lea:*' temps reel)
+            self._start_feedback_bus()
+
             # Boucle tkinter
             root.mainloop()
 
@@ -608,6 +715,12 @@ class ChatWindow:
 
     def _do_destroy(self) -> None:
         """Detruit la fenetre (appele dans le thread tkinter)."""
+        if self._bus is not None:
+            try:
+                self._bus.stop()
+            except Exception:
+                pass
+            self._bus = None
         if self._root is not None:
             try:
                 self._root.quit()
@@ -617,6 +730,260 @@ class ChatWindow:
             self._root = None
         self._visible = False
 
+    # ======================================================================
+    # FeedbackBus — bulles temps reel pendant l'execution (J3.3)
+    # ======================================================================
+
+    def _start_feedback_bus(self) -> None:
+        """Demarrer la connexion au bus 'lea:*' si flag actif et lib disponible."""
+        if not _HAS_FEEDBACK_BUS:
+            logger.debug("FeedbackBus non disponible (python-socketio manquant)")
+            return
+        flag = os.environ.get("LEA_FEEDBACK_BUS", "0").lower()
+        if flag not in ("1", "true", "yes", "on"):
+            return
+        try:
+            url = f"http://{self._server_host}:{self._chat_port}"
+            token = os.environ.get("RPA_API_TOKEN", "") or None
+            self._bus = FeedbackBusClient(url, token=token, on_event=self._on_lea_event)
+            self._bus.start()
+            logger.info("FeedbackBus demarre : %s", url)
+        except Exception:
+            logger.debug("FeedbackBus init silenced", exc_info=True)
+            self._bus = None
+
+    def _on_lea_event(self, event: str, payload: Dict[str, Any]) -> None:
+        """Callback bus → bulle Lea. Thread-safe : helpers utilisent root.after."""
+        payload = payload or {}
+
+        # J3.5 : la pause supervisée a sa propre bulle interactive
+        if event == "lea:paused":
+            self._add_paused_bubble(payload)
+            return
+        if event in ("lea:resumed", "lea:done"):
+            self._close_active_paused_bubble(reason=event)
+            # on continue pour afficher la bulle d'action (cf. dispatch ci-dessous)
+
+        # Acks bus (resume_acked, abort_acked) : silencieux côté UI
+        if event in ("lea:resume_acked", "lea:abort_acked"):
+            return
+
+        # J3.4 : bulle "Léa exécute" stylisée (séparée des bulles chat normales)
+        rendered = _ACTION_TEMPLATES.get(event)
+        if rendered is None:
+            # Event inconnu : on affiche en bulle d'action neutre
+            self._add_action_bubble(
+                icon="·", icon_color=ACTION_ICON_INFO,
+                title=event.removeprefix("lea:"),
+                meta=_extract_meta(payload),
+            )
+            return
+        icon, icon_color, title = rendered(payload)
+        self._add_action_bubble(
+            icon=icon, icon_color=icon_color, title=title,
+            meta=_extract_meta(payload),
+        )
+
+    # ------------------------------------------------------------------
+    # Bulle "Léa exécute" stylisée (J3.4)
+    # ------------------------------------------------------------------
+
+    def _add_action_bubble(
+        self, icon: str, icon_color: str, title: str, meta: str = "",
+    ) -> None:
+        if self._root is None:
+            return
+        self._root.after(0, lambda: self._render_action_bubble(icon, icon_color, title, meta))
+
+    def _render_action_bubble(
+        self, icon: str, icon_color: str, title: str, meta: str,
+    ) -> None:
+        tk = self._tk
+        if getattr(self, "_msg_frame", None) is None:
+            return
+        now = datetime.now().strftime("%H:%M")
+
+        container = tk.Frame(self._msg_frame, bg=BG_COLOR)
+        container.pack(fill=tk.X, padx=MARGIN, pady=3)
+
+        inner = tk.Frame(
+            container, bg=ACTION_BG, padx=10, pady=6,
+            highlightbackground=ACTION_BORDER, highlightthickness=1,
+        )
+        inner.pack(anchor=tk.W, padx=(0, 70), fill=tk.X)
+
+        row = tk.Frame(inner, bg=ACTION_BG)
+        row.pack(fill=tk.X, anchor=tk.W)
+
+        tk.Label(
+            row, text=icon, bg=ACTION_BG, fg=icon_color,
+            font=("Segoe UI", 13, "bold"), padx=4,
+        ).pack(side=tk.LEFT)
+
+        tk.Label(
+            row, text=title, bg=ACTION_BG, fg=ACTION_FG,
+            font=FONT_MSG, anchor="w", justify=tk.LEFT,
+            wraplength=MSG_WRAP_WIDTH - 60,
+        ).pack(side=tk.LEFT, fill=tk.X, expand=True, padx=(2, 0))
+
+        if meta:
+            tk.Label(
+                inner, text=f"{meta}  •  {now}",
+                bg=ACTION_BG, fg=ACTION_META_FG,
+                font=FONT_TIMESTAMP, anchor="w",
+            ).pack(fill=tk.X, anchor=tk.W, pady=(2, 0))
+
+    # ------------------------------------------------------------------
+    # Bulle paused_need_help interactive (J3.5)
+    # ------------------------------------------------------------------
+
+    def _add_paused_bubble(self, payload: Dict[str, Any]) -> None:
+        """Ajouter une bulle paused interactive (asset démo : Léa demande de l'aide).
+
+        IMPORTANT (8 mai 2026, démo GHT) : par défaut la fenêtre démarre cachée
+        (`root.withdraw()`). Il FAUT la rendre visible et la forcer au premier
+        plan, sinon Dom ne voit jamais la bulle. On exécute dans le thread
+        tkinter via `root.after(0, ...)`.
+        """
+        if self._root is None:
+            return
+
+        def _show_and_render():
+            try:
+                self._do_show()
+                # Re-pin topmost pour passer devant les apps actives
+                self._root.attributes("-topmost", True)
+                self._root.lift()
+                # Toast topmost en complément (visible même si la chat est
+                # masquée par une fenêtre d'app)
+                try:
+                    from .paused_toast import show_paused_toast
+                    reason = payload.get("reason") or "Action en attente."
+                    show_paused_toast(
+                        title="Léa a besoin de votre aide",
+                        message=str(reason)[:300],
+                    )
+                except Exception:
+                    logger.debug("paused_toast launch silenced", exc_info=True)
+            except Exception:
+                logger.debug("force-show chat_window silenced", exc_info=True)
+            self._render_paused_bubble(payload)
+
+        self._root.after(0, _show_and_render)
+
+    def _render_paused_bubble(self, payload: Dict[str, Any]) -> None:
+        tk = self._tk
+        if getattr(self, "_msg_frame", None) is None:
+            return
+
+        replay_id = str(payload.get("replay_id", "") or "")
+        workflow = payload.get("workflow", "?")
+        reason = payload.get("reason") or "Action incertaine — j'ai besoin de votre validation."
+        completed = payload.get("completed", 0)
+        total = payload.get("total", "?")
+        now = datetime.now().strftime("%H:%M")
+
+        container = tk.Frame(self._msg_frame, bg=BG_COLOR)
+        container.pack(fill=tk.X, padx=MARGIN, pady=6)
+
+        inner = tk.Frame(
+            container, bg=PAUSED_BG, padx=14, pady=12,
+            highlightbackground=PAUSED_BORDER, highlightthickness=2,
+        )
+        inner.pack(anchor=tk.W, padx=(0, 50), fill=tk.X)
+
+        tk.Label(
+            inner, text=f"⏸  Pause supervisée • {now}",
+            bg=PAUSED_BG, fg=PAUSED_FG,
+            font=("Segoe UI", 12, "bold"), anchor="w",
+        ).pack(fill=tk.X, anchor=tk.W)
+
+        tk.Label(
+            inner, text=reason, bg=PAUSED_BG, fg=PAUSED_FG,
+            font=FONT_MSG, wraplength=MSG_WRAP_WIDTH - 30,
+            anchor="w", justify=tk.LEFT,
+        ).pack(fill=tk.X, anchor=tk.W, pady=(6, 0))
+
+        tk.Label(
+            inner, text=f"{workflow} — étape {completed}/{total}",
+            bg=PAUSED_BG, fg=TIMESTAMP_FG, font=FONT_TIMESTAMP, anchor="w",
+        ).pack(fill=tk.X, anchor=tk.W, pady=(4, 8))
+
+        btn_frame = tk.Frame(inner, bg=PAUSED_BG)
+        btn_frame.pack(fill=tk.X, anchor=tk.W)
+
+        btn_resume = tk.Button(
+            btn_frame, text="Continuer",
+            bg=PAUSED_BTN_RESUME_BG, fg="white", font=FONT_QUICK_BTN,
+            padx=14, pady=4, bd=0, cursor="hand2",
+            activebackground=PAUSED_BTN_RESUME_HOVER, activeforeground="white",
+            command=lambda: self._on_paused_resume(replay_id),
+        )
+        btn_resume.pack(side=tk.LEFT, padx=(0, 8))
+
+        btn_abort = tk.Button(
+            btn_frame, text="Annuler",
+            bg=PAUSED_BTN_ABORT_BG, fg="white", font=FONT_QUICK_BTN,
+            padx=14, pady=4, bd=0, cursor="hand2",
+            activebackground=PAUSED_BTN_ABORT_HOVER, activeforeground="white",
+            command=lambda: self._on_paused_abort(replay_id),
+        )
+        btn_abort.pack(side=tk.LEFT)
+
+        self._active_paused_bubble = {
+            "container": container, "inner": inner,
+            "btn_resume": btn_resume, "btn_abort": btn_abort,
+            "replay_id": replay_id,
+        }
+
+    def _close_active_paused_bubble(self, reason: str) -> None:
+        if self._active_paused_bubble is None or self._root is None:
+            return
+        self._root.after(0, lambda: self._do_close_paused_bubble(reason))
+
+    def _do_close_paused_bubble(self, reason: str) -> None:
+        bubble = self._active_paused_bubble
+        if bubble is None:
+            return
+        try:
+            bubble["btn_resume"].config(state="disabled")
+            bubble["btn_abort"].config(state="disabled")
+            label_text = {
+                "lea:resumed": "→ Reprise",
+                "lea:done": "→ Terminé",
+            }.get(reason, f"→ {reason}")
+            self._tk.Label(
+                bubble["inner"], text=label_text,
+                bg=PAUSED_BG, fg=PAUSED_FG, font=FONT_TIMESTAMP, anchor="w",
+            ).pack(fill="x", anchor="w", pady=(6, 0))
+        except Exception:
+            logger.debug("close paused bubble silenced", exc_info=True)
+        self._active_paused_bubble = None
+
+    def _on_paused_resume(self, replay_id: str) -> None:
+        if not replay_id or self._bus is None or not self._bus.connected:
+            self._add_lea_message("⚠ Bus indisponible — impossible de relancer")
+            return
+        self._bus.resume_replay(replay_id)
+        if self._active_paused_bubble:
+            try:
+                self._active_paused_bubble["btn_resume"].config(state="disabled")
+                self._active_paused_bubble["btn_abort"].config(state="disabled")
+            except Exception:
+                pass
+
+    def _on_paused_abort(self, replay_id: str) -> None:
+        if self._bus is None or not self._bus.connected:
+            self._add_lea_message("⚠ Bus indisponible — impossible d'annuler")
+            return
+        self._bus.abort_replay(replay_id)
+        if self._active_paused_bubble:
+            try:
+                self._active_paused_bubble["btn_resume"].config(state="disabled")
+                self._active_paused_bubble["btn_abort"].config(state="disabled")
+            except Exception:
+                pass
+
     # ======================================================================
     # Ajout de messages dans la zone de chat
     # ======================================================================

agent_v0/agent_v1/ui/notifications.py

@@ -139,10 +139,28 @@ class NotificationManager:
 
         Les messages BLOCAGE bypass le rate limit pour garantir que
         l'utilisateur voit qu'on a besoin de lui.
+
+        Démo GHT 8 mai 2026 : pour les BLOCAGE, on déclenche en complément
+        un toast Tkinter custom topmost (paused_toast). Plyer est silencieux
+        sur Windows 11 quand Focus Assist / Quiet Hours / app-id manquante
+        bloquent les balloons. Le toast custom est 100 % autonome et garantit
+        que Dom voit le message en démo.
         """
         bypass = msg.niveau == NiveauMessage.BLOCAGE
         # Log aussi pour tracer dans les logs fichiers
         self._log_message(msg)
+
+        # Toast Tkinter custom — uniquement BLOCAGE pour ne pas spammer
+        if msg.niveau == NiveauMessage.BLOCAGE:
+            try:
+                from .paused_toast import show_paused_toast
+                show_paused_toast(
+                    title=str(msg.titre)[:80] or "Léa a besoin de votre aide",
+                    message=str(msg.corps)[:300],
+                )
+            except Exception:
+                logger.debug("paused_toast (BLOCAGE) silenced", exc_info=True)
+
         return self.notify(
             title=msg.titre,
             message=msg.corps,

agent_v0/agent_v1/ui/paused_toast.py

@@ -0,0 +1,290 @@
+# agent_v1/ui/paused_toast.py
+"""
+Toast Tkinter custom pour la pause supervisée (« Léa a besoin de votre aide »).
+
+Démo GHT 8 mai 2026 — Fallback robuste 100 % autonome quand :
+  - plyer.notification est silencieux sous Windows 11 (Focus Assist, balloon tips
+    bloqués par la stratégie système),
+  - la ChatWindow Léa V1 est `withdraw()`-cachée par défaut (Dom ne la voit pas),
+  - aucune autre UI ne peut garantir que Dom verra physiquement le message.
+
+Stratégie :
+  - Toplevel topmost overrideredirect en haut à droite de l'écran principal,
+  - fond bleu Léa, titre + message, auto-close après TOAST_DURATION_S,
+  - thread-safe : peut être appelé depuis n'importe quel thread (le polling
+    replay tourne dans un daemon thread, pas le thread principal),
+  - aucune dépendance externe (juste tkinter stdlib),
+  - rate limit interne pour éviter le flood (1 toast / 3s minimum).
+
+Si un Tk root existe déjà dans le process (ChatWindow), on attache le Toplevel
+à ce root via `root.after(0, ...)` — c'est l'idiome thread-safe officiel de
+tkinter. Sinon on crée un Tk() dédié dans un daemon thread.
+"""
+from __future__ import annotations
+
+import logging
+import threading
+import time
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+# Couleurs cohérentes avec le thème Léa (cf. chat_window.py)
+TOAST_BG = "#2563EB"          # Bleu Léa (HEADER_BG)
+TOAST_FG = "#FFFFFF"
+TOAST_TITLE_BG = "#1E40AF"    # Bleu plus foncé pour le bandeau titre
+TOAST_BORDER = "#1E3A8A"
+
+TOAST_WIDTH = 380
+TOAST_PAD_X = 18
+TOAST_PAD_Y = 14
+TOAST_DURATION_MS = 15000
+TOAST_RATE_LIMIT_S = 3.0
+
+_lock = threading.Lock()
+_last_shown_at: float = 0.0
+_last_message: str = ""
+
+
+def _resolve_existing_root() -> Optional[Any]:
+    """Tente de récupérer le Tk root déjà créé par la ChatWindow.
+
+    On évite tk._default_root (deprecated) et on remonte plutôt via les
+    threads existants : la ChatWindow garde une référence dans son instance
+    mais n'expose rien de global. On se rabat donc sur la création d'un Tk
+    indépendant si on n'a rien — c'est sûr, tkinter supporte plusieurs Tk()
+    concurrents tant qu'ils sont chacun dans leur propre thread.
+    """
+    try:
+        import tkinter as tk
+        # tk._default_root est interne mais c'est le moyen le plus simple
+        # de partager un mainloop existant. Si ChatWindow tourne, ce sera
+        # son root.
+        root = getattr(tk, "_default_root", None)
+        if root is not None:
+            # Vérifier qu'il est encore vivant
+            try:
+                root.winfo_exists()
+                return root
+            except Exception:
+                return None
+        return None
+    except Exception:
+        return None
+
+
+def _build_toast(parent: Any, title: str, message: str) -> Any:
+    """Construit le Toplevel toast (appelé dans le thread tkinter)."""
+    import tkinter as tk
+
+    top = tk.Toplevel(parent)
+    top.withdraw()  # éviter le flash pendant la construction
+    top.overrideredirect(True)  # pas de barre de titre
+    top.attributes("-topmost", True)
+    try:
+        # Petit boost de visibilité Windows : alpha légèrement transparent
+        top.attributes("-alpha", 0.97)
+    except Exception:
+        pass
+
+    # Bordure visuelle (cadre extérieur foncé)
+    outer = tk.Frame(top, bg=TOAST_BORDER, padx=2, pady=2)
+    outer.pack(fill="both", expand=True)
+
+    # Bandeau titre
+    title_frame = tk.Frame(outer, bg=TOAST_TITLE_BG)
+    title_frame.pack(fill="x")
+    tk.Label(
+        title_frame,
+        text=f"  ⏸  {title}",
+        bg=TOAST_TITLE_BG,
+        fg=TOAST_FG,
+        font=("Segoe UI", 12, "bold"),
+        anchor="w",
+        padx=10,
+        pady=8,
+    ).pack(fill="x")
+
+    # Corps du message
+    body_frame = tk.Frame(outer, bg=TOAST_BG)
+    body_frame.pack(fill="both", expand=True)
+    tk.Label(
+        body_frame,
+        text=message,
+        bg=TOAST_BG,
+        fg=TOAST_FG,
+        font=("Segoe UI", 11),
+        wraplength=TOAST_WIDTH - 40,
+        justify="left",
+        anchor="w",
+        padx=TOAST_PAD_X,
+        pady=TOAST_PAD_Y,
+    ).pack(fill="both", expand=True)
+
+    # Pied de page : "Cliquez pour fermer"
+    footer = tk.Label(
+        outer,
+        text="Cliquez pour fermer",
+        bg=TOAST_BG,
+        fg="#BFDBFE",
+        font=("Segoe UI", 9, "italic"),
+        anchor="e",
+        padx=10,
+        pady=4,
+    )
+    footer.pack(fill="x", side="bottom")
+
+    # Position : haut-droite de l'écran principal
+    top.update_idletasks()
+    height = top.winfo_reqheight()
+    screen_w = top.winfo_screenwidth()
+    x = screen_w - TOAST_WIDTH - 16
+    y = 16
+    top.geometry(f"{TOAST_WIDTH}x{height}+{x}+{y}")
+
+    # Click anywhere to close
+    def _close(_=None):
+        try:
+            top.destroy()
+        except Exception:
+            pass
+
+    top.bind("<Button-1>", _close)
+    for child in (outer, title_frame, body_frame, footer):
+        try:
+            child.bind("<Button-1>", _close)
+        except Exception:
+            pass
+
+    # Afficher + boost focus brut pour passer devant Focus Assist
+    top.deiconify()
+    top.lift()
+    try:
+        top.focus_force()
+    except Exception:
+        pass
+
+    # Re-pin topmost après 100 ms (Windows désactive parfois -topmost
+    # quand le focus est pris par une autre app)
+    def _repin():
+        try:
+            top.attributes("-topmost", True)
+            top.lift()
+        except Exception:
+            pass
+
+    try:
+        top.after(100, _repin)
+        top.after(500, _repin)
+        top.after(2000, _repin)
+    except Exception:
+        pass
+
+    # Auto-close
+    try:
+        top.after(TOAST_DURATION_MS, _close)
+    except Exception:
+        pass
+
+    return top
+
+
+def _show_in_dedicated_thread(title: str, message: str) -> None:
+    """Crée un Tk() indépendant dans un daemon thread.
+
+    Utilisé en fallback quand aucun Tk root n'existe. Le thread vit le
+    temps du toast (~15s) puis se termine proprement.
+    """
+    def _run():
+        try:
+            # DPI awareness (Windows haute résolution)
+            try:
+                import ctypes
+                ctypes.windll.shcore.SetProcessDpiAwareness(1)
+            except Exception:
+                pass
+
+            import tkinter as tk
+
+            root = tk.Tk()
+            root.withdraw()
+            try:
+                dpi = root.winfo_fpixels("1i")
+                root.tk.call("tk", "scaling", dpi / 72.0)
+            except Exception:
+                pass
+
+            top = _build_toast(root, title, message)
+
+            # Quitter mainloop quand le toast est détruit
+            def _watch():
+                try:
+                    if not top.winfo_exists():
+                        root.quit()
+                        return
+                except Exception:
+                    root.quit()
+                    return
+                root.after(200, _watch)
+
+            root.after(200, _watch)
+            root.mainloop()
+            try:
+                root.destroy()
+            except Exception:
+                pass
+        except Exception:
+            logger.debug("paused_toast dedicated thread failed", exc_info=True)
+
+    t = threading.Thread(target=_run, daemon=True, name="paused-toast-tk")
+    t.start()
+
+
+def show_paused_toast(
+    title: str = "Léa a besoin de votre aide",
+    message: str = "",
+) -> bool:
+    """Affiche un toast paused topmost.
+
+    Thread-safe, rate-limité, sans dépendance externe. Retourne True si le
+    toast a été déclenché, False s'il a été ignoré (rate limit ou erreur).
+    """
+    global _last_shown_at, _last_message
+
+    if not message:
+        message = "Action en attente de votre validation."
+
+    # Rate limit basique : éviter qu'un poll en boucle ouvre 50 toasts
+    now = time.monotonic()
+    with _lock:
+        same_message = (message == _last_message)
+        elapsed = now - _last_shown_at
+        if same_message and elapsed < TOAST_RATE_LIMIT_S:
+            logger.debug(
+                "paused_toast rate-limited (%.1fs since last identical)", elapsed
+            )
+            return False
+        _last_shown_at = now
+        _last_message = message
+
+    # Tentative 1 : utiliser le Tk root existant (ChatWindow) via after()
+    root = _resolve_existing_root()
+    if root is not None:
+        try:
+            root.after(0, lambda: _build_toast(root, title, message))
+            logger.info("paused_toast scheduled on existing Tk root")
+            return True
+        except Exception:
+            logger.debug("paused_toast existing-root path failed", exc_info=True)
+
+    # Tentative 2 : créer un Tk() dans un daemon thread
+    try:
+        _show_in_dedicated_thread(title, message)
+        logger.info("paused_toast scheduled in dedicated thread")
+        return True
+    except Exception:
+        logger.error("paused_toast dedicated-thread path failed", exc_info=True)
+        return False
+
+
+__all__ = ["show_paused_toast"]

agent_v0/agent_v1/vision/capturer.py

@@ -15,7 +15,7 @@ import time
 import logging
 import hashlib
 import platform
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 from PIL import Image, ImageFilter, ImageStat
 import mss
 from ..config import TARGETED_CROP_SIZE, SCREENSHOT_QUALITY, BLUR_SENSITIVE
@@ -26,6 +26,66 @@ logger = logging.getLogger(__name__)
 # OS courant (détecté une seule fois)
 _SYSTEM = platform.system()
 
+# QW1 — détection multi-écrans (fallback gracieux si screeninfo absent)
+try:
+    from screeninfo import get_monitors as _screeninfo_get_monitors
+    _SCREENINFO_AVAILABLE = True
+except ImportError:
+    _SCREENINFO_AVAILABLE = False
+
+
+def _get_monitors_geometry() -> List[Dict[str, Any]]:
+    """Retourne la liste des monitors physiques avec leurs offsets.
+
+    Returns:
+        List[dict] : [{idx, x, y, w, h, primary}, ...]. Vide si screeninfo
+        indisponible (le serveur tombera sur fallback composite).
+    """
+    if not _SCREENINFO_AVAILABLE:
+        return []
+    try:
+        monitors = _screeninfo_get_monitors()
+        return [
+            {
+                "idx": i,
+                "x": int(m.x),
+                "y": int(m.y),
+                "w": int(m.width),
+                "h": int(m.height),
+                "primary": bool(getattr(m, "is_primary", False)),
+            }
+            for i, m in enumerate(monitors)
+        ]
+    except Exception:
+        return []
+
+
+def _get_active_monitor_index() -> Optional[int]:
+    """Retourne l'index logique du monitor où se trouve le curseur (focus actif).
+
+    Returns:
+        int ou None si indéterminable.
+    """
+    if not _SCREENINFO_AVAILABLE:
+        return None
+    try:
+        import pyautogui  # import paresseux : évite la dépendance dure
+        cx, cy = pyautogui.position()
+        for i, m in enumerate(_screeninfo_get_monitors()):
+            if m.x <= cx < m.x + m.width and m.y <= cy < m.y + m.height:
+                return i
+    except Exception:
+        return None
+    return None
+
+
+def _enrich_with_monitor_info(payload: dict) -> dict:
+    """Ajoute monitor_index et monitors_geometry au payload (in-place + return)."""
+    if isinstance(payload, dict):
+        payload["monitor_index"] = _get_active_monitor_index()
+        payload["monitors_geometry"] = _get_monitors_geometry()
+    return payload
+
 class VisionCapturer:
     def __init__(self, session_dir: str):
         self.session_dir = session_dir
@@ -121,6 +181,9 @@ class VisionCapturer:
                 if window_info:
                     result["window_capture"] = window_info
 
+                # QW1 — enrichissement multi-écrans (additif, fallback gracieux)
+                _enrich_with_monitor_info(result)
+
                 return result
         except Exception as e:
             logger.error(f"Erreur Dual Capture: {e}")
@@ -223,6 +286,9 @@ class VisionCapturer:
                 "click_inside_window": click_inside,
             }
 
+            # QW1 — enrichissement multi-écrans (additif)
+            _enrich_with_monitor_info(result)
+
             logger.debug(
                 f"Fenêtre capturée : {title} ({win_w}x{win_h}) — "
                 f"clic relatif ({click_rel_x}, {click_rel_y})"

agent_v0/deploy/windows_client/agent_v1/core/executor.py

@@ -512,6 +512,21 @@ class ActionExecutorV1:
             x_pct = action.get("x_pct", 0.0)
             y_pct = action.get("y_pct", 0.0)
 
+            # QW1 — Si le serveur a résolu un monitor cible (idx >= 0),
+            # appliquer son offset aux coords absolues. Pour idx == -1
+            # (composite_fallback), aucun offset (backward compat).
+            # Le calcul des coords reste percent * (width/height) du monitor[1]
+            # côté client (x_pct est exprimé sur l'écran physique principal).
+            mon_res = action.get("monitor_resolution") or {}
+            mon_idx = mon_res.get("idx", -1)
+            mon_offset_x = mon_res.get("offset_x", 0) if mon_idx >= 0 else 0
+            mon_offset_y = mon_res.get("offset_y", 0) if mon_idx >= 0 else 0
+            if mon_idx >= 0 and (mon_offset_x or mon_offset_y):
+                logger.info(
+                    f"[REPLAY] QW1 monitor cible idx={mon_idx} source={mon_res.get('source')} "
+                    f"offset=({mon_offset_x},{mon_offset_y}) — appliqué aux coords"
+                )
+
             # ── Diagnostic résolution ──
             logger.info(
                 f"[REPLAY] Action {action_id} ({action_type}) — "
@@ -578,8 +593,8 @@ class ActionExecutorV1:
                         print(f"    [OBSERVER] Popup détectée : '{popup_label}' — fermeture")
                         logger.info(f"Observer : popup '{popup_label}' détectée avant résolution")
                         if popup_coords:
-                            real_x = int(popup_coords["x_pct"] * width)
-                            real_y = int(popup_coords["y_pct"] * height)
+                            real_x = int(popup_coords["x_pct"] * width) + mon_offset_x
+                            real_y = int(popup_coords["y_pct"] * height) + mon_offset_y
                             self._click((real_x, real_y), "left")
                             time.sleep(1.0)
                             print(f"    [OBSERVER] Popup fermée — reprise du flow normal")
@@ -718,8 +733,8 @@ class ActionExecutorV1:
                         self.notifier.replay_target_not_found(target_desc)
                         return result
 
-                real_x = int(x_pct * width)
-                real_y = int(y_pct * height)
+                real_x = int(x_pct * width) + mon_offset_x
+                real_y = int(y_pct * height) + mon_offset_y
                 button = action.get("button", "left")
                 mode = "VISUAL" if result.get("visual_resolved") else "COORD"
                 print(
@@ -781,8 +796,8 @@ class ActionExecutorV1:
                     print(f"    [TYPE] raw_keys disponibles ({len(raw_keys)} events) — replay exact")
                 # Cliquer sur le champ avant de taper (si coordonnees disponibles)
                 if x_pct > 0 and y_pct > 0:
-                    real_x = int(x_pct * width)
-                    real_y = int(y_pct * height)
+                    real_x = int(x_pct * width) + mon_offset_x
+                    real_y = int(y_pct * height) + mon_offset_y
                     print(f"    [TYPE] Clic prealable sur ({real_x}, {real_y})")
                     self._click((real_x, real_y), "left")
                     time.sleep(0.3)
@@ -808,8 +823,8 @@ class ActionExecutorV1:
                 logger.info(f"Replay key_combo : {keys} (raw_keys={'oui' if raw_keys else 'non'})")
 
             elif action_type == "scroll":
-                real_x = int(x_pct * width) if x_pct > 0 else int(0.5 * width)
-                real_y = int(y_pct * height) if y_pct > 0 else int(0.5 * height)
+                real_x = (int(x_pct * width) if x_pct > 0 else int(0.5 * width)) + mon_offset_x
+                real_y = (int(y_pct * height) if y_pct > 0 else int(0.5 * height)) + mon_offset_y
                 delta = action.get("delta", -3)
                 print(f"    [SCROLL] delta={delta} a ({real_x}, {real_y})")
                 self.mouse.position = (real_x, real_y)
@@ -1386,6 +1401,16 @@ Example: x_pct=0.50, y_pct=0.30"""
             data = resp.json()
             action = data.get("action")
             if action is None:
+                # pause_for_human : afficher le message de décision à l'utilisateur
+                if data.get("replay_paused") and data.get("pause_message"):
+                    msg = data["pause_message"]
+                    print(f"[PAUSE] {msg}")
+                    logger.info(f"Replay en pause — message : {msg}")
+                    self.notifier.notify(
+                        title="Léa — Validation requise",
+                        message=msg[:250],
+                        timeout=30,
+                    )
                 return False
 
         except (requests.exceptions.ConnectionError, requests.exceptions.Timeout) as e:

agent_v0/deploy/windows_client/agent_v1/main.py

@@ -319,7 +319,22 @@ class AgentV1:
                     if img_hash != self._last_heartbeat_hash:
                         self._last_heartbeat_hash = img_hash
                         self.streamer.push_image(full_path, f"heartbeat_{int(time.time())}")
-                        self.streamer.push_event({"type": "heartbeat", "image": full_path, "timestamp": time.time(), "machine_id": self.machine_id})
+                        heartbeat_event = {
+                            "type": "heartbeat",
+                            "image": full_path,
+                            "timestamp": time.time(),
+                            "machine_id": self.machine_id,
+                        }
+                        # QW1 — enrichissement multi-écrans (monitor_index + monitors_geometry)
+                        # Additif, fallback gracieux : sans cet enrichissement, le serveur
+                        # ne reçoit l'info qu'au moment des clics, donc QW1 ne s'active
+                        # pas en continu sur poste Windows multi-écrans.
+                        try:
+                            from .vision.capturer import _enrich_with_monitor_info
+                            _enrich_with_monitor_info(heartbeat_event)
+                        except Exception as e:
+                            logger.debug("QW1 enrichissement heartbeat échoué: %s", e)
+                        self.streamer.push_event(heartbeat_event)
             except Exception as e:
                 logger.error(f"Heartbeat error: {e}")
             time.sleep(5)

agent_v0/deploy/windows_client/agent_v1/vision/capturer.py

@@ -8,12 +8,73 @@ import os
 import time
 import logging
 import hashlib
+from typing import Any, Dict, List, Optional
 from PIL import Image, ImageFilter, ImageStat
 import mss
 from ..config import TARGETED_CROP_SIZE, SCREENSHOT_QUALITY
 
 logger = logging.getLogger(__name__)
 
+# QW1 — détection multi-écrans (fallback gracieux si screeninfo absent)
+try:
+    from screeninfo import get_monitors as _screeninfo_get_monitors
+    _SCREENINFO_AVAILABLE = True
+except ImportError:
+    _SCREENINFO_AVAILABLE = False
+
+
+def _get_monitors_geometry() -> List[Dict[str, Any]]:
+    """Retourne la liste des monitors physiques avec leurs offsets.
+
+    Returns:
+        List[dict] : [{idx, x, y, w, h, primary}, ...]. Vide si screeninfo
+        indisponible (le serveur tombera sur fallback composite).
+    """
+    if not _SCREENINFO_AVAILABLE:
+        return []
+    try:
+        monitors = _screeninfo_get_monitors()
+        return [
+            {
+                "idx": i,
+                "x": int(m.x),
+                "y": int(m.y),
+                "w": int(m.width),
+                "h": int(m.height),
+                "primary": bool(getattr(m, "is_primary", False)),
+            }
+            for i, m in enumerate(monitors)
+        ]
+    except Exception:
+        return []
+
+
+def _get_active_monitor_index() -> Optional[int]:
+    """Retourne l'index logique du monitor où se trouve le curseur (focus actif).
+
+    Returns:
+        int ou None si indéterminable.
+    """
+    if not _SCREENINFO_AVAILABLE:
+        return None
+    try:
+        import pyautogui  # import paresseux : évite la dépendance dure
+        cx, cy = pyautogui.position()
+        for i, m in enumerate(_screeninfo_get_monitors()):
+            if m.x <= cx < m.x + m.width and m.y <= cy < m.y + m.height:
+                return i
+    except Exception:
+        return None
+    return None
+
+
+def _enrich_with_monitor_info(payload: dict) -> dict:
+    """Ajoute monitor_index et monitors_geometry au payload (in-place + return)."""
+    if isinstance(payload, dict):
+        payload["monitor_index"] = _get_active_monitor_index()
+        payload["monitors_geometry"] = _get_monitors_geometry()
+    return payload
+
 class VisionCapturer:
     def __init__(self, session_dir: str):
         self.session_dir = session_dir
@@ -72,7 +133,12 @@ class VisionCapturer:
                 # Mise à jour du hash pour le prochain heartbeat
                 self.last_img_hash = self._compute_quick_hash(img)
 
-                return {"full": full_path, "crop": crop_path}
+                result = {"full": full_path, "crop": crop_path}
+
+                # QW1 — enrichissement multi-écrans (additif, fallback gracieux)
+                _enrich_with_monitor_info(result)
+
+                return result
         except Exception as e:
             logger.error(f"Erreur Dual Capture: {e}")
             return {}

agent_v0/deploy/windows_client/requirements.txt

@@ -3,7 +3,9 @@ mss>=9.0.1              # Capture d'écran haute performance
 pynput>=1.7.7           # Clavier/Souris Cross-plateforme
 Pillow>=10.0.0          # Crops et processing image
 requests>=2.31.0        # Streaming réseau
+python-socketio[client]>=5.10,<6.0  # Bus feedback Léa 'lea:*' (compat Flask-SocketIO 5.3.x serveur)
 psutil>=5.9.0           # Monitoring CPU/RAM
+screeninfo>=0.8         # QW1 — détection des monitors physiques + offsets
 pystray>=0.19.5         # Icône Tray UI
 plyer>=2.1.0            # Notifications toast natives (remplace PyQt5)
 

agent_v0/server_v1/api_stream.py

@@ -9,6 +9,7 @@ Inclut les endpoints de replay pour renvoyer des ordres d'exécution à l'Agent
 """
 
 import atexit
+import contextlib
 import json
 import logging
 import os
@@ -33,6 +34,8 @@ from .audit_trail import AuditTrail, AuditEntry
 from .agent_registry import AgentRegistry, AgentAlreadyEnrolledError
 from .stream_processor import StreamProcessor, build_replay_from_raw_events, enrich_click_from_screenshot
 from .worker_stream import StreamWorker
+from .monitor_router import resolve_target_monitor  # QW1 — résolution écran cible
+from .loop_detector import LoopDetector  # QW2 — détection de boucle pendant replay
 from .execution_plan_runner import (
     execution_plan_to_actions,
     inject_plan_into_queue,
@@ -219,6 +222,11 @@ from .replay_engine import (
     _is_learned_workflow,
     _edge_to_normalized_actions,
     _substitute_variables,
+    _resolve_runtime_vars,
+    _SERVER_SIDE_ACTION_TYPES,
+    _handle_extract_text_action,
+    _handle_extract_table_action,
+    _handle_t2a_decision_action,
     _expand_compound_steps,
     _pre_check_screen_state as _pre_check_screen_state_impl,
     _detect_popup_hint as _detect_popup_hint_impl,
@@ -355,6 +363,18 @@ REPLAY_LOCK_FILE = _DATA_DIR / "_replay_active.lock"
 processor = StreamProcessor(data_dir=str(LIVE_SESSIONS_DIR))
 worker = StreamWorker(live_dir=str(LIVE_SESSIONS_DIR), processor=processor)
 
+# QW2 — LoopDetector singleton lazy (utilise le CLIP embedder du processor)
+_loop_detector: Optional["LoopDetector"] = None
+
+
+def _get_loop_detector() -> "LoopDetector":
+    """Singleton lazy — crée le LoopDetector avec le CLIP embedder du processor."""
+    global _loop_detector
+    if _loop_detector is None:
+        embedder = getattr(processor, "_clip_embedder", None)
+        _loop_detector = LoopDetector(clip_embedder=embedder)
+    return _loop_detector
+
 # Registre des postes Lea enroles (table enrolled_agents dans rpa_data.db)
 # Emplacement configurable via RPA_AGENTS_DB_PATH pour les tests.
 _AGENTS_DB_PATH = os.environ.get(
@@ -486,6 +506,33 @@ _pending_lock = threading.Lock()
 # Chaque session a une queue d'actions à exécuter et un état de replay
 # =========================================================================
 _replay_lock = threading.Lock()
+
+
+# Context manager async pour acquérir _replay_lock sans bloquer l'event loop
+# FastAPI. Pattern complémentaire au commit 35b27ae49 (lock async sur
+# /replay/next) et 87dbe8c5f (get_replay_status non-bloquant) : tous les
+# endpoints `async def` qui faisaient `with _replay_lock:` synchrone gelaient
+# l'event loop dès qu'une opération longue tenait le lock dans un autre
+# thread. Avec ce helper, l'acquire passe par run_in_executor (l'event loop
+# reste libre pour servir les autres requêtes pendant l'attente). Si le lock
+# est tenu plus de `timeout` secondes, on retourne 503 plutôt que de geler le
+# serveur.
+@contextlib.asynccontextmanager
+async def _async_replay_lock(timeout: float = 4.5):
+    import asyncio
+    loop = asyncio.get_event_loop()
+    acquired = await loop.run_in_executor(None, _replay_lock.acquire, True, timeout)
+    if not acquired:
+        raise HTTPException(
+            status_code=503,
+            detail=f"Serveur occupé (lock _replay tenu > {timeout}s) — réessayer",
+        )
+    try:
+        yield
+    finally:
+        _replay_lock.release()
+
+
 # session_id -> liste d'actions en attente (FIFO)
 _replay_queues: Dict[str, List[Dict[str, Any]]] = defaultdict(list)
 # machine_id -> session_id (mapping pour le replay ciblé par machine)
@@ -507,6 +554,7 @@ class ReplayRequest(BaseModel):
     session_id: str
     machine_id: Optional[str] = None  # Machine cible pour le replay (multi-machine)
     params: Optional[Dict[str, Any]] = None
+    variables: Optional[Dict[str, Any]] = None  # Variables runtime initiales (templating {{var}})
 
 
 class RawReplayRequest(BaseModel):
@@ -515,6 +563,11 @@ class RawReplayRequest(BaseModel):
     session_id: str = ""
     machine_id: Optional[str] = None  # Machine cible (multi-machine)
     task_description: str = ""
+    # Paramètres runtime du replay (lus dans replay_state.params côté pipeline).
+    # Notamment execution_mode : "autonomous" (défaut, pause_for_human skippée)
+    # ou "supervised" (pause_for_human bloque jusqu'à validation humaine via
+    # PauseDialog VWB). Cf. replay_engine.py / api_stream.py:2964.
+    params: Optional[Dict[str, Any]] = None
 
 
 class SingleActionRequest(BaseModel):
@@ -761,6 +814,21 @@ async def startup():
     _cleanup_thread = threading.Thread(target=_cleanup_loop, daemon=True, name="replay_cleanup")
     _cleanup_thread.start()
 
+    # Préchargement EasyOCR en arrière-plan : sans ça, le 1er extract_text /
+    # extract_table déclenche un cold start de ~3-5s qui bloque l'event loop
+    # FastAPI (constaté 2026-05-05 : streaming server inaccessible 2 min).
+    # Le thread tourne pendant que le boot continue ; le 1er appel OCR sera rapide.
+    def _preload_easyocr():
+        try:
+            t0 = time.time()
+            from core.llm.ocr_extractor import _get_reader
+            _get_reader()
+            logger.info("[OCR] EasyOCR préchargé (fr+en, CPU) en %.1fs", time.time() - t0)
+        except Exception as e:
+            logger.warning("[OCR] Échec préchargement EasyOCR : %s", e)
+
+    threading.Thread(target=_preload_easyocr, daemon=True, name="preload_easyocr").start()
+
     logger.info(
         "API Streaming démarrée — StreamProcessor, Worker et Cleanup prêts. "
         "VLM Worker dans un process séparé (run_worker.py)."
@@ -1947,7 +2015,7 @@ async def start_replay(request: ReplayRequest):
     resolved_machine_id = target_machine_id or (session_obj.machine_id if session_obj else "default")
 
     # Injecter les actions dans la queue de la session
-    with _replay_lock:
+    async with _async_replay_lock():
         _replay_queues[session_id] = list(actions)  # Remplacer la queue existante
         _replay_states[replay_id] = _create_replay_state(
             replay_id=replay_id,
@@ -1958,6 +2026,11 @@ async def start_replay(request: ReplayRequest):
             machine_id=resolved_machine_id,
             actions=actions,
         )
+        # Pré-injection des variables runtime (templating {{var}} sur by_text,
+        # text, target_spec.* etc.). Permet à l'orchestrateur d'appeler ce
+        # workflow avec p.ex. variables={"patient_id": "25003284"} pour boucler.
+        if request.variables:
+            _replay_states[replay_id]["variables"].update(request.variables)
         # Enregistrer le mapping machine -> session pour le replay ciblé
         if resolved_machine_id and resolved_machine_id != "default":
             _machine_replay_target[resolved_machine_id] = session_id
@@ -2042,7 +2115,7 @@ async def start_raw_replay(request: RawReplayRequest):
     session_obj = processor.session_manager.get_session(session_id)
     resolved_machine_id = target_machine_id or (session_obj.machine_id if session_obj else "default")
 
-    with _replay_lock:
+    async with _async_replay_lock():
         # ── Nettoyage : annuler les replays bloqués pour cette machine ──
         # Un replay en paused_need_help bloque tous les suivants.
         # Quand on lance un nouveau replay, les anciens sont obsolètes.
@@ -2069,7 +2142,7 @@ async def start_raw_replay(request: RawReplayRequest):
             workflow_id=f"free_task:{task[:50]}",
             session_id=session_id,
             total_actions=len(actions),
-            params={},
+            params=dict(request.params or {}),
             machine_id=resolved_machine_id,
             actions=actions,
         )
@@ -2262,7 +2335,7 @@ async def replay_from_session(
     # ── 5. Injecter dans la queue de replay ──
     replay_id = f"replay_sess_{uuid.uuid4().hex[:8]}"
 
-    with _replay_lock:
+    async with _async_replay_lock():
         _replay_queues[target_session_id] = list(actions)
         _replay_states[replay_id] = _create_replay_state(
             replay_id=replay_id,
@@ -2353,7 +2426,7 @@ async def enqueue_single_action(request: SingleActionRequest):
 
     action_id = action["action_id"]
 
-    with _replay_lock:
+    async with _async_replay_lock():
         _replay_queues[session_id].append(action)
 
     logger.info(
@@ -2519,7 +2592,7 @@ async def launch_replay_from_plan(request: PlanReplayRequest):
         or (session_obj.machine_id if session_obj else "default")
     )
 
-    with _replay_lock:
+    async with _async_replay_lock():
         _replay_queues[target_session_id] = list(validated)
         _replay_states[replay_id] = _create_replay_state(
             replay_id=replay_id,
@@ -2758,8 +2831,29 @@ async def get_next_action(session_id: str, machine_id: str = "default"):
 
     Si la session de l'agent n'a pas d'actions en attente, cherche dans les
     autres queues de la MÊME machine (pas cross-machine).
+
+    Acquire timeout : si une action serveur lente (extract_text OCR,
+    t2a_decision LLM) tient le lock, on retourne immédiatement
+    {action: None, server_busy: True} avant que le client ne timeout à 5s.
+    Sans cela, des actions seraient popped serveur puis envoyées sur des
+    sockets clients déjà fermées par timeout — perdues silencieusement.
+
+    L'acquire et les actions serveur lentes sont exécutés via
+    run_in_executor : sinon l'appel synchrone bloque l'event loop FastAPI
+    (single-threaded) et même les polls qui devraient recevoir server_busy
+    sont bloqués jusqu'à libération — ce qui annule l'effet du timeout.
     """
-    with _replay_lock:
+    import asyncio
+    loop = asyncio.get_event_loop()
+    acquired = await loop.run_in_executor(None, _replay_lock.acquire, True, 4.5)
+    if not acquired:
+        return {
+            "action": None,
+            "session_id": session_id,
+            "machine_id": machine_id,
+            "server_busy": True,
+        }
+    try:
         # Verifier si le replay est en pause supervisee (target_not_found).
         # Dans ce cas, NE PAS envoyer d'action — attendre l'intervention utilisateur.
         for state in _replay_states.values():
@@ -2824,6 +2918,7 @@ async def get_next_action(session_id: str, machine_id: str = "default"):
                             break
                     if target_state:
                         queue = target_queue
+                        owning_replay = target_state
                         _replay_queues[session_id] = target_queue
                         del _replay_queues[target_sid]
                         target_state["session_id"] = session_id
@@ -2840,6 +2935,7 @@ async def get_next_action(session_id: str, machine_id: str = "default"):
                         other_queue = _replay_queues.get(other_sid, [])
                         if other_queue:
                             queue = other_queue
+                            owning_replay = state
                             _replay_queues[session_id] = other_queue
                             del _replay_queues[other_sid]
                             state["session_id"] = session_id
@@ -2850,8 +2946,147 @@ async def get_next_action(session_id: str, machine_id: str = "default"):
         if not queue:
             return {"action": None, "session_id": session_id, "machine_id": machine_id}
 
-        # Peek à la prochaine action SANS la retirer (pour le pre-check)
-        action = queue[0]
+        # ── Boucle de traitement : actions serveur (extract_text, t2a_decision)
+        # exécutées entièrement côté serveur jusqu'à trouver une action visuelle
+        # à transmettre à l'Agent V1 ou un pause_for_human qui bloque le replay.
+        action = None
+        while queue:
+            action = queue[0]
+
+            # Résoudre les variables runtime ({{var}} et {{var.field}})
+            if owning_replay is not None:
+                runtime_vars = owning_replay.get("variables") or {}
+                if runtime_vars:
+                    action = _resolve_runtime_vars(action, runtime_vars)
+
+            type_ = action.get("type")
+
+            # pause_for_human : pause supervisée si safety_level/safety_checks ou mode supervised,
+            # sinon no-op en mode autonome (skip).
+            if type_ == "pause_for_human":
+                _params = action.get("parameters") or {}
+                _exec_mode = (
+                    (owning_replay or {}).get("params", {}).get("execution_mode", "autonomous")
+                    if owning_replay else "autonomous"
+                )
+                _has_safety_decl = bool(_params.get("safety_level") or _params.get("safety_checks"))
+                _is_supervised = _exec_mode != "autonomous"
+
+                if owning_replay is not None and (_has_safety_decl or _is_supervised):
+                    # QW4 — Construire le payload de pause enrichi (déclaratif + LLM contextuel)
+                    try:
+                        from agent_v0.server_v1.safety_checks_provider import build_pause_payload
+                        last_screenshot_path = owning_replay.get("last_screenshot")
+                        payload = build_pause_payload(action, owning_replay, last_screenshot_path)
+                        owning_replay["safety_checks"] = payload.checks
+                        owning_replay["pause_payload"] = {
+                            "checks": payload.checks,
+                            "pause_reason": payload.pause_reason,
+                            "message": payload.message,
+                        }
+                        if payload.message:
+                            owning_replay["pause_message"] = payload.message
+                        # Bus event d'observabilité (pattern QW1/QW2 = logger.info)
+                        logger.info(
+                            "[BUS] lea:safety_checks_generated replay=%s count=%d sources=%s",
+                            owning_replay.get("replay_id", "?"),
+                            len(payload.checks),
+                            [c["source"] for c in payload.checks],
+                        )
+                    except Exception as e:
+                        logger.warning("QW4 build_pause_payload échec (%s) — pause sans checks", e)
+                        owning_replay["safety_checks"] = []
+
+                    # Conserver le contexte de l'action (audit + reprise)
+                    owning_replay["failed_action"] = {
+                        "action_id": action.get("action_id"),
+                        "type": "pause_for_human",
+                        "reason": "user_request",
+                    }
+                    owning_replay["status"] = "paused_need_help"
+                    queue.pop(0)
+                    _replay_queues[session_id] = queue
+                    return {"action": None, "session_id": session_id, "machine_id": machine_id}
+
+                # Mode autonome sans safety_checks → skip (comportement legacy)
+                logger.info(
+                    "pause_for_human ignorée (mode autonome) — replay %s continue",
+                    owning_replay["replay_id"] if owning_replay else "?"
+                )
+                queue.pop(0)
+                _replay_queues[session_id] = queue
+                continue
+
+            # Actions serveur : exécuter HORS event loop pour ne pas bloquer
+            # les autres polls (extract_text OCR ~5s, t2a_decision LLM ~8-13s).
+            # Le lock reste tenu (queue cohérente) mais l'event loop est libre,
+            # donc les polls concurrents peuvent recevoir {server_busy: True}.
+            #
+            # Borne dure 180s par action : un hang d'EasyOCR / Ollama / I/O
+            # ne doit JAMAIS pouvoir tenir _replay_lock indéfiniment, sinon
+            # tous les endpoints sous lock (get_replay_status, /replay/next…)
+            # gèlent le serveur. TimeoutError est rattrapée par l'except
+            # Exception ci-dessous → queue.pop(0) → on passe à la suite.
+            if type_ in _SERVER_SIDE_ACTION_TYPES and owning_replay is not None:
+                try:
+                    if type_ == "extract_text":
+                        await asyncio.wait_for(
+                            loop.run_in_executor(
+                                None,
+                                _handle_extract_text_action,
+                                action, owning_replay, session_id, _last_heartbeat,
+                            ),
+                            timeout=180,
+                        )
+                    elif type_ == "extract_table":
+                        await asyncio.wait_for(
+                            loop.run_in_executor(
+                                None,
+                                _handle_extract_table_action,
+                                action, owning_replay, session_id, _last_heartbeat,
+                            ),
+                            timeout=180,
+                        )
+                    elif type_ == "t2a_decision":
+                        await asyncio.wait_for(
+                            loop.run_in_executor(
+                                None,
+                                _handle_t2a_decision_action,
+                                action, owning_replay,
+                            ),
+                            timeout=180,
+                        )
+                except Exception as e:
+                    logger.warning(f"Action serveur {type_} a levé : {e}")
+                queue.pop(0)
+                _replay_queues[session_id] = queue
+                continue  # action suivante
+
+            # Clic conditionnel : si l'action a un paramètre "condition", évaluer la variable
+            # Format : "dec.critere1_valide" → runtime_vars["dec"]["critere1_valide"]
+            condition_key = (action.get("parameters") or {}).get("condition")
+            if condition_key and owning_replay is not None:
+                runtime_vars = owning_replay.get("variables") or {}
+                parts = condition_key.split(".", 1)
+                if len(parts) == 2:
+                    val = (runtime_vars.get(parts[0]) or {}).get(parts[1])
+                else:
+                    val = runtime_vars.get(parts[0])
+                if not val:
+                    logger.info("Clic conditionnel ignoré (%s=%s) — action %s",
+                                condition_key, val, action.get("action_id", "?"))
+                    queue.pop(0)
+                    _replay_queues[session_id] = queue
+                    continue
+
+            # Action visuelle : sortir de la boucle pour la transmettre à l'Agent V1
+            break
+
+        # Si la queue s'est vidée après les exécutions serveur, rien à transmettre
+        if not queue or action is None:
+            return {"action": None, "session_id": session_id, "machine_id": machine_id}
+    finally:
+        _replay_lock.release()
 
     # ---- Pre-check écran (optionnel, non bloquant) ----
     # Ne s'applique qu'aux actions qui ont un from_node (actions de workflow,
@@ -2915,7 +3150,7 @@ async def get_next_action(session_id: str, machine_id: str = "default"):
                     auth_actions = _auth_handler.get_auth_actions(auth_request)
                     if auth_actions:
                         # Injecter les actions d'auth en tête de queue (avant l'action bloquée)
-                        with _replay_lock:
+                        async with _async_replay_lock():
                             current_q = _replay_queues.get(session_id, [])
                             _replay_queues[session_id] = auth_actions + current_q
                         logger.info(
@@ -2924,7 +3159,7 @@ async def get_next_action(session_id: str, machine_id: str = "default"):
                             f"type={auth_request.auth_type} (confiance={auth_request.confidence:.2f})"
                         )
                         # Retourner la première action d'auth immédiatement
-                        with _replay_lock:
+                        async with _async_replay_lock():
                             first_auth = _replay_queues[session_id].pop(0)
                         return {
                             "action": first_auth,
@@ -2972,7 +3207,7 @@ async def get_next_action(session_id: str, machine_id: str = "default"):
         }
 
     # Pre-check OK (ou skip) : retirer l'action de la queue et l'envoyer
-    with _replay_lock:
+    async with _async_replay_lock():
         current_queue = _replay_queues.get(session_id, [])
         if current_queue and current_queue[0].get("action_id") == action.get("action_id"):
             current_queue.pop(0)
@@ -3018,6 +3253,51 @@ async def get_next_action(session_id: str, machine_id: str = "default"):
         f"{_precheck_sim}"
     )
 
+    # QW1 — Résoudre l'écran cible et joindre l'info à l'action
+    # Cascade : action.monitor_index → session.last_focused_monitor → composite_fallback
+    try:
+        session_qw1 = processor.session_manager.get_session(session_id)
+        last_window_info_qw1 = (
+            session_qw1.last_window_info if session_qw1 is not None else {}
+        ) or {}
+        session_state_qw1 = {
+            "monitors_geometry": last_window_info_qw1.get("monitors_geometry", []),
+            "last_focused_monitor": last_window_info_qw1.get("monitor_index"),
+        }
+        target = resolve_target_monitor(action, session_state_qw1)
+        action["monitor_resolution"] = {
+            "idx": target.idx,
+            "offset_x": target.offset_x,
+            "offset_y": target.offset_y,
+            "w": target.w,
+            "h": target.h,
+            "source": target.source,
+        }
+        # QW1 — Émission bus lea:monitor_routed (no-op si bus indisponible)
+        # Le serveur streaming n'a pas de SocketIO local : on logge en INFO
+        # bien lisible. Un consommateur (agent_chat / dashboard) peut tailer
+        # `journalctl -u rpa-streaming | grep '\[BUS\] lea:monitor_routed'`.
+        try:
+            _replay_id_bus = (
+                owning_replay.get("replay_id") if owning_replay else None
+            )
+            logger.info(
+                "[BUS] lea:monitor_routed replay=%s action=%s idx=%d source=%s "
+                "offset=(%d,%d) wh=(%d,%d)",
+                _replay_id_bus,
+                action.get("action_id"),
+                target.idx,
+                target.source,
+                target.offset_x,
+                target.offset_y,
+                target.w,
+                target.h,
+            )
+        except Exception as _e_bus:
+            logger.debug("emit lea:monitor_routed échec (non bloquant): %s", _e_bus)
+    except Exception as e:
+        logger.debug("QW1 monitor_resolution skip (%s)", e)
+
     response: Dict[str, Any] = {
         "action": action,
         "session_id": session_id,
@@ -3059,7 +3339,7 @@ async def report_action_result(report: ReplayResultReport):
     )
 
     # Trouver le replay correspondant à cette session
-    with _replay_lock:
+    async with _async_replay_lock():
         replay_state = None
         for state in _replay_states.values():
             if state["session_id"] == session_id and state["status"] == "running":
@@ -3092,7 +3372,7 @@ async def report_action_result(report: ReplayResultReport):
     # Mettre à jour le dernier screenshot reçu
     screenshot_after = report.screenshot_after or report.screenshot
     if screenshot_after:
-        with _replay_lock:
+        async with _async_replay_lock():
             replay_state["last_screenshot"] = screenshot_after
 
     # === Vérification post-action ===
@@ -3163,7 +3443,7 @@ async def report_action_result(report: ReplayResultReport):
 
     # Stocker le screenshot actuel comme "before" pour la prochaine action
     if screenshot_after:
-        with _replay_lock:
+        async with _async_replay_lock():
             replay_state["_last_screenshot_before"] = screenshot_after
 
     # [REPLAY] log structuré de la décision de vérification
@@ -3185,7 +3465,7 @@ async def report_action_result(report: ReplayResultReport):
     )
 
     # === Enregistrer le résultat ===
-    with _replay_lock:
+    async with _async_replay_lock():
         result_entry = {
             "action_id": action_id,
             "success": report.success,
@@ -3345,7 +3625,7 @@ async def report_action_result(report: ReplayResultReport):
     except Exception as _mem_exc:
         logger.debug("Memory record skipped : %s", _mem_exc)
 
-    with _replay_lock:
+    async with _async_replay_lock():
         # === Logique de retry / success / failure ===
         if report.success and (verification is None or verification.verified):
             # Action réussie (vérification OK ou pas de vérification)
@@ -3756,6 +4036,82 @@ async def report_action_result(report: ReplayResultReport):
                 f"— worker VLM autorisé à reprendre"
             )
 
+        # ===================================================================
+        # QW2 — LoopDetector : alimentation des anneaux + évaluation
+        # ===================================================================
+        # On n'évalue que si le replay est encore "running" — inutile de
+        # pauser quelque chose de déjà completed/error/paused.
+        if replay_state["status"] == "running":
+            # Snapshot image (PIL) dans l'anneau
+            try:
+                from PIL import Image
+                ss_raw = screenshot_after or replay_state.get("last_screenshot")
+                img = None
+                if isinstance(ss_raw, str) and ss_raw:
+                    if os.path.isfile(ss_raw):
+                        img = Image.open(ss_raw).copy()  # détache du file handle
+                    else:
+                        # Possible base64 — décoder
+                        try:
+                            import base64
+                            import io as _io
+                            img_bytes = base64.b64decode(ss_raw, validate=False)
+                            img = Image.open(_io.BytesIO(img_bytes)).copy()
+                        except Exception:
+                            img = None
+                if img is not None:
+                    replay_state.setdefault("_screenshot_history", []).append(img)
+                    replay_state["_screenshot_history"] = replay_state["_screenshot_history"][-5:]
+            except Exception as e:
+                logger.debug("LoopDetector: snapshot historique échoué: %s", e)
+
+            # Snapshot signature de l'action courante
+            try:
+                _act_pos = report.actual_position or {}
+                action_sig = {
+                    "type": (original_action or {}).get("type")
+                            or replay_state.get("_last_action_type", ""),
+                    "x_pct": _act_pos.get("x_pct") if isinstance(_act_pos, dict)
+                             else (original_action or {}).get("x_pct"),
+                    "y_pct": _act_pos.get("y_pct") if isinstance(_act_pos, dict)
+                             else (original_action or {}).get("y_pct"),
+                }
+                replay_state.setdefault("_action_history", []).append(action_sig)
+                replay_state["_action_history"] = replay_state["_action_history"][-5:]
+            except Exception as e:
+                logger.debug("LoopDetector: snapshot action_sig échoué: %s", e)
+
+            # Évaluation (silencieux si rien)
+            try:
+                verdict = _get_loop_detector().evaluate(
+                    replay_state,
+                    screenshots=replay_state.get("_screenshot_history", []),
+                    actions=replay_state.get("_action_history", []),
+                )
+                if verdict.detected:
+                    replay_state["status"] = "paused_need_help"
+                    replay_state["pause_reason"] = "loop_detected"
+                    replay_state["pause_message"] = (
+                        f"Léa semble bloquée — {verdict.signal} "
+                        f"(détail: {verdict.evidence})"
+                    )
+                    logger.warning(
+                        "LoopDetector: replay %s mis en pause — signal=%s evidence=%s",
+                        replay_state["replay_id"], verdict.signal, verdict.evidence,
+                    )
+                    # Bus event d'observabilité (logger pattern QW1)
+                    try:
+                        logger.info(
+                            "[BUS] lea:loop_detected replay=%s signal=%s evidence=%s",
+                            replay_state["replay_id"],
+                            verdict.signal,
+                            verdict.evidence,
+                        )
+                    except Exception as _e_bus:
+                        logger.debug("emit lea:loop_detected échec: %s", _e_bus)
+            except Exception as e:
+                logger.warning("LoopDetector: évaluation échouée (non bloquant): %s", e)
+
     return {
         "status": "recorded",
         "action_id": action_id,
@@ -3781,7 +4137,7 @@ async def register_error_callback(config: ErrorCallbackConfig):
     replay_id = config.replay_id
     callback_url = config.callback_url
 
-    with _replay_lock:
+    async with _async_replay_lock():
         if replay_id not in _replay_states:
             raise HTTPException(
                 status_code=404,
@@ -3805,34 +4161,52 @@ async def get_replay_status(replay_id: str):
     Quand le replay est en pause supervisee (paused_need_help), la reponse
     inclut le contexte complet de l'echec : action echouee, screenshot,
     target_spec, et message utilisateur.
+
+    Endpoint poll-friendly : l'acquisition du lock est timeboxée à 0.5 s.
+    Si une action serveur lente (extract_text/extract_table/t2a_decision)
+    tient le lock, le poll repart immédiatement avec status="busy" plutôt
+    que de bloquer l'event loop FastAPI (qui gèlerait l'ensemble des
+    endpoints jusqu'à libération). Suite logique du commit 35b27ae49 qui
+    avait déjà appliqué ce pattern à /replay/next ; QW4 a recâblé le
+    polling frontend ici → même classe de bug, même remède.
     """
-    with _replay_lock:
+    import asyncio
+    loop = asyncio.get_event_loop()
+    acquired = await loop.run_in_executor(None, _replay_lock.acquire, True, 0.5)
+    if not acquired:
+        return {
+            "replay_id": replay_id,
+            "status": "busy",
+            "message": "Serveur occupé (action en cours), réessaie dans 1s",
+        }
+    try:
         state = _replay_states.get(replay_id)
+        if not state:
+            raise HTTPException(
+                status_code=404, detail=f"Replay '{replay_id}' non trouvé"
+            )
 
-    if not state:
-        raise HTTPException(
-            status_code=404, detail=f"Replay '{replay_id}' non trouvé"
-        )
+        # Filtrer les champs internes (prefixes par _)
+        result = {k: v for k, v in state.items() if not k.startswith("_")}
 
-    # Filtrer les champs internes (prefixes par _)
-    result = {k: v for k, v in state.items() if not k.startswith("_")}
+        # Enrichir avec le contexte de pause si applicable
+        if state["status"] == "paused_need_help":
+            session_id = state["session_id"]
+            remaining = len(_replay_queues.get(session_id, []))
+            result["actions_completed"] = state["completed_actions"]
+            result["actions_remaining"] = remaining
+            result["message"] = state.get("pause_message", "Replay en pause")
+            # Le failed_action contient deja screenshot_b64 et target_spec
 
-    # Enrichir avec le contexte de pause si applicable
-    if state["status"] == "paused_need_help":
-        session_id = state["session_id"]
-        remaining = len(_replay_queues.get(session_id, []))
-        result["actions_completed"] = state["completed_actions"]
-        result["actions_remaining"] = remaining
-        result["message"] = state.get("pause_message", "Replay en pause")
-        # Le failed_action contient deja screenshot_b64 et target_spec
-
-    return result
+        return result
+    finally:
+        _replay_lock.release()
 
 
 @app.get("/api/v1/traces/stream/replays")
 async def list_replays():
     """Lister tous les replays (actifs, terminés, en erreur)."""
-    with _replay_lock:
+    async with _async_replay_lock():
         # Filtrer les champs internes (préfixés par _)
         return {
             "replays": [
@@ -3842,8 +4216,16 @@ async def list_replays():
         }
 
 
+class ReplayResumeRequest(BaseModel):
+    """Body optionnel pour /replay/resume — QW4 acquittement de safety_checks."""
+    acknowledged_check_ids: List[str] = []
+
+
 @app.post("/api/v1/traces/stream/replay/{replay_id}/resume")
-async def resume_replay(replay_id: str):
+async def resume_replay(
+    replay_id: str,
+    payload: Optional[ReplayResumeRequest] = None,
+):
     """Reprendre un replay en pause supervisee (paused_need_help).
 
     L'utilisateur a intervenu manuellement (naviguer vers le bon ecran,
@@ -3851,8 +4233,12 @@ async def resume_replay(replay_id: str):
     est reinjectee en tete de queue pour etre re-tentee.
 
     Si le replay n'est pas en pause, retourne une erreur 409 (conflit).
+
+    QW4 — Si des safety_checks sont attachés à la pause, tous ceux marqués
+    `required` doivent figurer dans `acknowledged_check_ids`. Sinon → 400
+    avec `{"error": "required_checks_missing", "missing": [...]}`.
     """
-    with _replay_lock:
+    async with _async_replay_lock():
         state = _replay_states.get(replay_id)
 
         if not state:
@@ -3869,6 +4255,25 @@ async def resume_replay(replay_id: str):
                 ),
             )
 
+        # QW4 — Vérification des safety_checks required avant reprise
+        safety_checks = state.get("safety_checks") or []
+        ack_ids = (payload.acknowledged_check_ids if payload else []) or []
+        if safety_checks:
+            required_ids = {c["id"] for c in safety_checks if c.get("required")}
+            ack_set = set(ack_ids)
+            missing = sorted(required_ids - ack_set)
+            if missing:
+                raise HTTPException(
+                    status_code=400,
+                    detail={"error": "required_checks_missing", "missing": missing},
+                )
+            # Audit trail
+            state["checks_acknowledged"] = sorted(ack_set)
+            logger.info(
+                "QW4 resume replay=%s acquittements=%d (%s)",
+                state.get("replay_id"), len(ack_set), sorted(ack_set),
+            )
+
         # Recuperer l'action echouee pour la reinjecter
         failed_action = state.get("failed_action")
         session_id = state["session_id"]
@@ -3877,9 +4282,15 @@ async def resume_replay(replay_id: str):
         state["status"] = "running"
         state["failed_action"] = None
         state["pause_message"] = None
+        # QW4 — vider safety_checks après acquittement (la pause est résolue)
+        state["safety_checks"] = []
+        state["pause_payload"] = None
+        state["pause_reason"] = ""
 
         # Reinjecter l'action echouee en tete de queue (sera re-tentee)
-        if failed_action and failed_action.get("action_id"):
+        # pause_for_human est une pause intentionnelle, pas une erreur — ne pas réinjecter
+        if (failed_action and failed_action.get("action_id")
+                and failed_action.get("reason") != "user_request"):
             # Reconstruire l'action a partir du retry_pending ou de l'original
             original_action_id = failed_action["action_id"]
             # Chercher l'action originale dans les retry_pending
@@ -3920,6 +4331,26 @@ async def resume_replay(replay_id: str):
     }
 
 
+@app.post("/api/v1/traces/stream/replay/{replay_id}/cancel")
+async def cancel_replay(replay_id: str):
+    """Annuler un replay (quel que soit son statut) et vider sa queue."""
+    async with _async_replay_lock():
+        state = _replay_states.get(replay_id)
+        if not state:
+            raise HTTPException(status_code=404, detail=f"Replay '{replay_id}' non trouvé")
+        session_id = state["session_id"]
+        state["status"] = "cancelled"
+        state["failed_action"] = None
+        state["pause_message"] = None
+        _replay_queues[session_id] = []
+        keys_to_del = [k for k, v in _retry_pending.items() if v.get("replay_id") == replay_id]
+        for k in keys_to_del:
+            _retry_pending.pop(k, None)
+
+    logger.info("Replay %s annulé manuellement", replay_id)
+    return {"status": "cancelled", "replay_id": replay_id, "session_id": session_id}
+
+
 # =========================================================================
 # Visual Replay — Résolution visuelle des cibles (module resolve_engine)
 # =========================================================================
@@ -3974,6 +4405,72 @@ async def resolve_target(request: ResolveTargetRequest):
         logger.error(f"Décodage screenshot échoué: {e}")
         return _fallback_response(request, "decode_error", str(e))
 
+    # Détection image tronquée + fallback heartbeat full screen.
+    # Bug client constaté ce 2026-05-07 (PC Windows 192.168.1.11, agent V1) :
+    # mss.monitors[1] retourne parfois une bande étroite type 2560x60, 2560x108,
+    # 600x72 — possiblement la barre des tâches Windows confondue avec un monitor,
+    # ou un état mss corrompu. Reproductible même PC en mono physique. Cause
+    # exacte non isolée côté client (cf. session_20260506_handoff_v2.md).
+    # Les heartbeats (capturer.py, chemin différent de executor.py) restent en
+    # full screen 2560x1600. On compense ici en remplaçant l'image tronquée
+    # par le dernier heartbeat avant la cascade _resolve_target_sync.
+    effective_w = request.screen_width
+    effective_h = request.screen_height
+    # Seuil large : un écran moderne fait 2560x1600 ou plus. Tout en dessous
+    # de 1200x800 est suspect — bug client mss.monitors[1] qui crop sur
+    # barre des tâches (2560x60), Edge fenêtré (622x856), etc.
+    if img.height < 800 or img.width < 1200:
+        logger.warning(
+            "[RESOLVE_TARGET] Image client tronquée %dx%d (declared %dx%d) — "
+            "fallback heartbeat full screen",
+            img.width, img.height, effective_w, effective_h,
+        )
+        # Source 1 : _last_heartbeat (mémoire, peuplé par /stream/image)
+        candidate_path = None
+        candidate_age_s = None
+        latest_hb = max(
+            (h for h in _last_heartbeat.values() if h.get("path")),
+            key=lambda h: h.get("timestamp", 0),
+            default=None,
+        )
+        if latest_hb and os.path.isfile(latest_hb["path"]):
+            candidate_path = latest_hb["path"]
+            candidate_age_s = time.time() - latest_hb.get("timestamp", time.time())
+        else:
+            # Source 2 : scan disque (utile après restart serveur, avant que
+            # _last_heartbeat ne se repeuple — ou si l'agent V1 ne polle pas)
+            try:
+                import glob as _glob
+                pattern = "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/*/bg_*/shots/heartbeat_*.png"
+                all_files = _glob.glob(pattern)
+                files = [
+                    f for f in all_files
+                    if "_blurred" not in f and os.path.isfile(f)
+                ]
+                logger.info(
+                    "[RESOLVE_TARGET] Scan disque : %d match glob, %d non-blurred existants",
+                    len(all_files), len(files),
+                )
+                if files:
+                    files.sort(key=lambda f: os.path.getmtime(f), reverse=True)
+                    candidate_path = files[0]
+                    candidate_age_s = time.time() - os.path.getmtime(candidate_path)
+            except Exception as e:
+                logger.warning("[RESOLVE_TARGET] Scan disque heartbeat échoué : %s", e)
+
+        if candidate_path:
+            try:
+                img = Image.open(candidate_path)
+                effective_w, effective_h = img.size
+                logger.info(
+                    "[RESOLVE_TARGET] Heartbeat fallback OK : %s (%dx%d, age=%.1fs)",
+                    candidate_path, effective_w, effective_h, candidate_age_s or -1,
+                )
+            except Exception as e:
+                logger.warning("[RESOLVE_TARGET] Ouverture heartbeat échouée : %s", e)
+        else:
+            logger.warning("[RESOLVE_TARGET] Aucun heartbeat disponible pour fallback")
+
     # Sauver temporairement pour les analyseurs (ils attendent un chemin fichier)
     with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmp:
         img.save(tmp, format="JPEG", quality=90)
@@ -3989,8 +4486,8 @@ async def resolve_target(request: ResolveTargetRequest):
             _resolve_target_sync,
             tmp_path,
             request.target_spec,
-            request.screen_width,
-            request.screen_height,
+            effective_w,
+            effective_h,
             request.fallback_x_pct,
             request.fallback_y_pct,
             request.strict_mode,
@@ -4006,12 +4503,88 @@ async def resolve_target(request: ResolveTargetRequest):
             request.fallback_y_pct,
         )
 
+        # Pré-check sémantique post-cascade : OCR sur une zone autour de la
+        # coordonnée résolue pour vérifier que le by_text attendu y est bien
+        # présent. Attrape les cas où la cascade rend des coords plausibles
+        # mais pointant sur un autre élément (ex : clic sur "Dossier en cours"
+        # du menu au lieu de "Synthèse Urgences" du tab plus bas).
+        #
+        # Pré-check OCR — RÉACTIVÉ le 8 mai 2026
+        # Calibrage : radius_px=280, min_token_ratio=0.50
+        # Désactivable via RPA_ENABLE_TEXT_PRECHECK=false
+        #
+        # Historique :
+        # - 6-7 mai 2026 : assouplissements progressifs des garde-fous
+        #   (SoM, mémoire visuelle, exemptions drift) pendant prépa démo GHT
+        # - 8 mai 2026 (matin) : flag défaut "false" posé sur ce pré-check
+        #   pour stabiliser (calibrage trop strict — faux rejets sur
+        #   onglets à 2 tokens : "Examens cliniques", "Synthèse Urgences")
+        # - 8 mai 2026 (après-midi) : réactivé après calibrage chirurgical
+        #   (radius_px 200→280, min_token_ratio 0.60→0.50)
+        #
+        # Si futurs faux rejets observés :
+        # - vérifier d'abord radius_px (élargir si textes longs coupés)
+        # - puis min_token_ratio (abaisser si OCR fragmente)
+        # - NE PAS désactiver sans entrée DECISIONS.md datée
+        _text_precheck_enabled = os.environ.get(
+            "RPA_ENABLE_TEXT_PRECHECK", "true"
+        ).lower() in ("true", "1", "yes")
+        if _text_precheck_enabled and result and result.get("resolved"):
+            _by_text = (request.target_spec.get("by_text") or "").strip()
+            if _by_text:
+                from agent_v0.server_v1.resolve_engine import _validate_text_at_position
+                _is_valid, _observed, _ocr_ms = _validate_text_at_position(
+                    tmp_path,
+                    float(result.get("x_pct", 0) or 0),
+                    float(result.get("y_pct", 0) or 0),
+                    _by_text,
+                    effective_w,
+                    effective_h,
+                )
+                logger.info(
+                    "[REPLAY] Pre-check OCR ACTIF : '%s' attendu @ (%.4f, %.4f) "
+                    "via %s — observed='%s' is_valid=%s (%.0fms)",
+                    _by_text[:40],
+                    float(result.get("x_pct", 0) or 0),
+                    float(result.get("y_pct", 0) or 0),
+                    result.get("method", "?"),
+                    _observed[:80],
+                    _is_valid,
+                    _ocr_ms,
+                )
+                if not _is_valid:
+                    logger.warning(
+                        "[REPLAY] Pre-check OCR REJET : '%s' attendu @ (%.4f, %.4f) "
+                        "via %s mais OCR voit '%s' (%.0fms)",
+                        _by_text[:40],
+                        float(result.get("x_pct", 0) or 0),
+                        float(result.get("y_pct", 0) or 0),
+                        result.get("method", "?"),
+                        _observed[:80],
+                        _ocr_ms,
+                    )
+                    result = {
+                        "resolved": False,
+                        "method": "rejected_text_mismatch",
+                        "reason": f"expected='{_by_text[:40]}' observed='{_observed[:60]}'",
+                        "original_method": result.get("method"),
+                        "original_score": result.get("score"),
+                        "x_pct": None,
+                        "y_pct": None,
+                    }
+
         # [REPLAY] log structuré de sortie résolution (après validation)
+        # Note: x_pct/y_pct peuvent être None quand le pré-check OCR rejette
+        # (rejected_text_mismatch). result.get('x_pct', 0) renvoie alors None
+        # — la clé existe, le default 0 est ignoré — et None:.4f lève
+        # TypeError. Fix : `(... or 0)` traite None/None/0 uniformément.
+        _x = result.get('x_pct') if result else None
+        _y = result.get('y_pct') if result else None
         logger.info(
             f"[REPLAY] RESOLVE_EXIT session={request.session_id} "
             f"resolved={result.get('resolved', False) if result else False} "
             f"method='{result.get('method', '?') if result else 'none'}' "
-            f"coords=({result.get('x_pct', 0):.4f}, {result.get('y_pct', 0):.4f}) "
+            f"coords=({(_x or 0):.4f}, {(_y or 0):.4f}) "
             f"score={result.get('score', 0) if result else 0} "
             f"from_memory={bool(result.get('from_memory', False)) if result else False} "
             f"reason='{result.get('reason', '') if result else ''}'"
@@ -4021,7 +4594,8 @@ async def resolve_target(request: ResolveTargetRequest):
         logger.error(f"[REPLAY] RESOLVE_EXCEPTION session={request.session_id} error={e}")
         return _fallback_response(request, "analysis_error", str(e))
     finally:
-        import os
+        # `os` est déjà importé en haut du fichier — pas de re-import local
+        # (sinon UnboundLocalError plus haut dans la fonction).
         try:
             os.unlink(tmp_path)
         except OSError:

agent_v0/server_v1/live_session_manager.py

@@ -256,6 +256,20 @@ class LiveSessionManager:
                     session.last_window_info["title"] = wc_title
                 if wc_app:
                     session.last_window_info["app_name"] = wc_app
+                # QW1 — propager monitor_index et monitors_geometry depuis window_capture
+                if "monitor_index" in window_capture:
+                    session.last_window_info["monitor_index"] = window_capture["monitor_index"]
+                if "monitors_geometry" in window_capture:
+                    session.last_window_info["monitors_geometry"] = window_capture["monitors_geometry"]
+
+            # QW1 — propager monitor_index/monitors_geometry du payload event
+            # (cas heartbeat enrichi sans window/window_title). Toujours
+            # rafraîchir le focus actif (change souvent) et la géométrie
+            # (l'utilisateur peut brancher/débrancher un écran).
+            if "monitor_index" in event_data:
+                session.last_window_info["monitor_index"] = event_data["monitor_index"]
+            if "monitors_geometry" in event_data and event_data["monitors_geometry"]:
+                session.last_window_info["monitors_geometry"] = event_data["monitors_geometry"]
 
             # Accumuler les titres/apps pour le nommage automatique
             title = session.last_window_info.get("title", "").strip()

agent_v0/server_v1/loop_detector.py

@@ -0,0 +1,154 @@
+# agent_v0/server_v1/loop_detector.py
+"""LoopDetector composite — détection de stagnation de Léa pendant un replay (QW2).
+
+Trois signaux indépendants :
+- screen_static : N captures consécutives avec CLIP similarity > seuil
+- action_repeat : N actions consécutives identiques (type + coords)
+- retry_threshold : nombre de retries cumulés >= seuil
+
+Un seul signal positif → verdict.detected=True. Le serveur bascule alors le
+replay en paused_need_help avec pause_reason explicite.
+
+Désactivable via env var RPA_LOOP_DETECTOR_ENABLED=0.
+"""
+
+import logging
+import os
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class LoopVerdict:
+    detected: bool = False
+    reason: str = ""
+    signal: str = ""  # "screen_static" | "action_repeat" | "retry_threshold" | ""
+    evidence: Dict[str, Any] = field(default_factory=dict)
+
+
+def _env_int(name: str, default: int) -> int:
+    try:
+        return int(os.environ.get(name, default))
+    except (TypeError, ValueError):
+        return default
+
+
+def _env_float(name: str, default: float) -> float:
+    try:
+        return float(os.environ.get(name, default))
+    except (TypeError, ValueError):
+        return default
+
+
+def _env_bool_enabled(name: str) -> bool:
+    val = os.environ.get(name, "1").strip().lower()
+    return val not in ("0", "false", "no", "off", "")
+
+
+def _cosine_similarity(a, b) -> float:
+    """Similarité cosine entre deux vecteurs (listes ou np.array). Robuste vecteur nul."""
+    import numpy as np
+    av = np.asarray(a, dtype=np.float32).flatten()
+    bv = np.asarray(b, dtype=np.float32).flatten()
+    na, nb = float(np.linalg.norm(av)), float(np.linalg.norm(bv))
+    if na < 1e-8 or nb < 1e-8:
+        return 0.0
+    return float(np.dot(av, bv) / (na * nb))
+
+
+class LoopDetector:
+    def __init__(self, clip_embedder=None):
+        self.clip_embedder = clip_embedder
+
+    def evaluate(
+        self,
+        state: Dict[str, Any],
+        screenshots: List[Any],
+        actions: List[Dict[str, Any]],
+    ) -> LoopVerdict:
+        """Évalue les 3 signaux. Retourne le premier déclenché.
+
+        Args:
+            state: replay_state (utilisé pour retried_actions)
+            screenshots: anneau d'embeddings CLIP (les N derniers)
+            actions: anneau des N dernières actions exécutées
+        """
+        if not _env_bool_enabled("RPA_LOOP_DETECTOR_ENABLED"):
+            return LoopVerdict(detected=False)
+
+        # Signal A : screen_static
+        verdict = self._check_screen_static(screenshots)
+        if verdict.detected:
+            return verdict
+
+        # Signal B : action_repeat
+        verdict = self._check_action_repeat(actions)
+        if verdict.detected:
+            return verdict
+
+        # Signal C : retry_threshold
+        verdict = self._check_retry_threshold(state)
+        if verdict.detected:
+            return verdict
+
+        return LoopVerdict(detected=False)
+
+    def _check_screen_static(self, screenshots: List[Any]) -> LoopVerdict:
+        n_required = _env_int("RPA_LOOP_SCREEN_STATIC_N", 4)
+        threshold = _env_float("RPA_LOOP_SCREEN_STATIC_THRESHOLD", 0.99)
+
+        if self.clip_embedder is None or len(screenshots) < n_required:
+            return LoopVerdict()
+
+        try:
+            recent = screenshots[-n_required:]
+            # Embed chaque capture via le CLIP embedder (peut lever)
+            embeddings = [self.clip_embedder.embed_image(img) for img in recent]
+            sims = [_cosine_similarity(embeddings[i], embeddings[i + 1])
+                    for i in range(len(embeddings) - 1)]
+            min_sim = min(sims)
+            if min_sim > threshold:
+                return LoopVerdict(
+                    detected=True,
+                    reason="loop_detected",
+                    signal="screen_static",
+                    evidence={"min_similarity": round(min_sim, 4),
+                              "n_captures": n_required,
+                              "threshold": threshold},
+                )
+        except Exception as e:
+            logger.warning("LoopDetector signal_A erreur (%s) — signal inerte ce tick", e)
+        return LoopVerdict()
+
+    def _check_action_repeat(self, actions: List[Dict[str, Any]]) -> LoopVerdict:
+        n_required = _env_int("RPA_LOOP_ACTION_REPEAT_N", 3)
+        if len(actions) < n_required:
+            return LoopVerdict()
+        recent = actions[-n_required:]
+
+        def _signature(a: Dict[str, Any]) -> tuple:
+            return (a.get("type"), a.get("x_pct"), a.get("y_pct"))
+
+        sigs = [_signature(a) for a in recent]
+        if all(s == sigs[0] for s in sigs):
+            return LoopVerdict(
+                detected=True,
+                reason="loop_detected",
+                signal="action_repeat",
+                evidence={"signature": sigs[0], "count": n_required},
+            )
+        return LoopVerdict()
+
+    def _check_retry_threshold(self, state: Dict[str, Any]) -> LoopVerdict:
+        threshold = _env_int("RPA_LOOP_RETRY_THRESHOLD", 3)
+        retried = int(state.get("retried_actions", 0))
+        if retried >= threshold:
+            return LoopVerdict(
+                detected=True,
+                reason="loop_detected",
+                signal="retry_threshold",
+                evidence={"retried_actions": retried, "threshold": threshold},
+            )
+        return LoopVerdict()

agent_v0/server_v1/monitor_router.py

@@ -0,0 +1,99 @@
+# agent_v0/server_v1/monitor_router.py
+"""MonitorRouter — résolution de l'écran cible pour le replay (QW1).
+
+Stratégie en cascade :
+1. action.monitor_index (hérité de la session source) → cible cet écran
+2. session.last_focused_monitor (focus actif vu en dernier heartbeat) → fallback
+3. composite (offset 0, 0) → backward compat
+
+Émet sur le bus lea:* l'event monitor_routed avec la source de la décision.
+"""
+
+import logging
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class MonitorTarget:
+    """Représente l'écran cible résolu pour une action de replay."""
+    idx: int
+    offset_x: int
+    offset_y: int
+    w: int
+    h: int
+    source: str  # "action" | "focus" | "composite_fallback"
+
+
+_COMPOSITE_FALLBACK = MonitorTarget(
+    idx=-1,
+    offset_x=0,
+    offset_y=0,
+    w=0,
+    h=0,
+    source="composite_fallback",
+)
+
+
+def _find_monitor(geometry: List[Dict[str, Any]], idx: int) -> Optional[Dict[str, Any]]:
+    """Retourne le monitor d'index donné, ou None si absent."""
+    for m in geometry:
+        if m.get("idx") == idx:
+            return m
+    return None
+
+
+def _to_target(monitor: Dict[str, Any], source: str) -> MonitorTarget:
+    return MonitorTarget(
+        idx=int(monitor["idx"]),
+        offset_x=int(monitor.get("x", 0)),
+        offset_y=int(monitor.get("y", 0)),
+        w=int(monitor.get("w", 0)),
+        h=int(monitor.get("h", 0)),
+        source=source,
+    )
+
+
+def resolve_target_monitor(
+    action: Dict[str, Any],
+    session_state: Dict[str, Any],
+) -> MonitorTarget:
+    """Résout l'écran cible d'une action de replay.
+
+    Args:
+        action: Dict de l'action (peut contenir `monitor_index`).
+        session_state: État de la session (doit contenir `monitors_geometry`
+            et `last_focused_monitor`).
+
+    Returns:
+        MonitorTarget avec l'offset à appliquer aux coordonnées de grounding.
+    """
+    geometry: List[Dict[str, Any]] = session_state.get("monitors_geometry") or []
+
+    # 1. Cible explicite via action
+    explicit_idx = action.get("monitor_index")
+    if explicit_idx is not None and geometry:
+        m = _find_monitor(geometry, int(explicit_idx))
+        if m is not None:
+            return _to_target(m, source="action")
+        # Index invalide → on tombe sur le fallback focus
+        logger.warning(
+            "[BUS] lea:monitor_invalid_index requested=%d available_idx=%s",
+            int(explicit_idx), [g.get("idx") for g in geometry],
+        )
+
+    # 2. Fallback focus actif
+    focused_idx = session_state.get("last_focused_monitor")
+    if focused_idx is not None and geometry:
+        m = _find_monitor(geometry, int(focused_idx))
+        if m is not None:
+            return _to_target(m, source="focus")
+        logger.warning(
+            "[BUS] lea:monitor_unavailable focused_idx=%d available_idx=%s",
+            int(focused_idx), [g.get("idx") for g in geometry],
+        )
+
+    # 3. Fallback composite (backward compat — comportement actuel mss.monitors[0])
+    return _COMPOSITE_FALLBACK

agent_v0/server_v1/replay_engine.py

@@ -32,8 +32,16 @@ _ALLOWED_ACTION_TYPES = {
     "click", "type", "key_combo", "scroll", "wait",
     "file_open", "file_save", "file_close", "file_new", "file_dialog",
     "double_click", "right_click", "drag",
-    "verify_screen",  # Replay hybride : vérification visuelle entre groupes
+    "verify_screen",     # Replay hybride : vérification visuelle entre groupes
+    "pause_for_human",   # Pause supervisée explicite (interceptée par /replay/next)
+    "extract_text",      # OCR serveur sur dernier heartbeat → variable workflow
+    "t2a_decision",      # Analyse LLM facturation T2A → variable workflow
 }
+
+# Types d'actions exécutées CÔTÉ SERVEUR (jamais transmises à l'Agent V1).
+# Le pipeline /replay/next les traite en boucle interne et passe à l'action
+# suivante jusqu'à trouver une action visuelle (à transmettre au client).
+_SERVER_SIDE_ACTION_TYPES = {"extract_text", "t2a_decision"}
 _MAX_ACTION_TEXT_LENGTH = 10000
 _MAX_KEYS_PER_COMBO = 10
 # Touches autorisées dans les key_combo (modificateurs + touches spéciales + caractères simples)
@@ -852,6 +860,30 @@ def _edge_to_normalized_actions(edge, params: Dict[str, Any]) -> List[Dict[str,
             keys = [action_params["key"]]
         normalized["keys"] = keys
 
+    elif action_type == "pause_for_human":
+        normalized["type"] = "pause_for_human"
+        normalized["parameters"] = {
+            "message": action_params.get("message", "Validation requise"),
+        }
+        return [normalized]  # pas de target/coords pour cette action logique
+
+    elif action_type == "extract_text":
+        normalized["type"] = "extract_text"
+        normalized["parameters"] = {
+            "output_var": action_params.get("output_var", "extracted_text"),
+            "paragraph": bool(action_params.get("paragraph", True)),
+        }
+        return [normalized]
+
+    elif action_type == "t2a_decision":
+        normalized["type"] = "t2a_decision"
+        normalized["parameters"] = {
+            "input_template": action_params.get("input_template", ""),
+            "output_var": action_params.get("output_var", "t2a_result"),
+            "model": action_params.get("model"),
+        }
+        return [normalized]
+
     else:
         logger.warning(f"Type d'action inconnu : {action_type}")
         return []
@@ -886,6 +918,143 @@ def _substitute_variables(text: str, params: Dict[str, Any], defaults: Dict[str,
     return re.sub(r'\$\{(\w+)\}', replacer, text)
 
 
+# Regex pour le templating runtime : {{var}} ou {{var.champ}} ou {{var.champ.sous}}
+_RUNTIME_VAR_PATTERN = re.compile(r'\{\{\s*(\w+)(?:\.([\w.]+))?\s*\}\}')
+
+
+def _resolve_runtime_vars_in_str(text: str, variables: Dict[str, Any]) -> str:
+    """Remplace {{var}} et {{var.field}} par leur valeur depuis le dict variables.
+
+    Variables/champs absents : laissés tels quels (ne casse pas le pipeline).
+    Pour les valeurs non-str (dict, list), str() est appelé.
+    """
+    def replacer(match):
+        var_name = match.group(1)
+        path = match.group(2)
+        if var_name not in variables:
+            return match.group(0)
+        value = variables[var_name]
+        if path:
+            for field in path.split('.'):
+                if isinstance(value, dict) and field in value:
+                    value = value[field]
+                else:
+                    return match.group(0)
+        return str(value)
+
+    return _RUNTIME_VAR_PATTERN.sub(replacer, text)
+
+
+def _resolve_runtime_vars(value: Any, variables: Dict[str, Any]) -> Any:
+    """Résout récursivement les {{var}} et {{var.field}} dans une valeur.
+
+    Supporte str, dict, list. Les autres types sont retournés tels quels.
+    Si variables est vide ou None, value est retournée inchangée.
+    """
+    if not variables:
+        return value
+    if isinstance(value, str):
+        return _resolve_runtime_vars_in_str(value, variables)
+    if isinstance(value, dict):
+        return {k: _resolve_runtime_vars(v, variables) for k, v in value.items()}
+    if isinstance(value, list):
+        return [_resolve_runtime_vars(item, variables) for item in value]
+    return value
+
+
+# =========================================================================
+# Handlers pour les actions exécutées côté serveur (extract_text, t2a_decision)
+# =========================================================================
+
+def _handle_extract_text_action(
+    action: Dict[str, Any],
+    replay_state: Dict[str, Any],
+    session_id: str,
+    last_heartbeat: Dict[str, Dict[str, Any]],
+) -> bool:
+    """Traite une action extract_text côté serveur. Stocke le texte OCRisé dans
+    replay_state["variables"][output_var]. Retourne True si succès.
+
+    Robuste aux échecs : si pas de heartbeat ou OCR raté, stocke "" et retourne
+    False (le pipeline continue, pas de blocage).
+    """
+    params = action.get("parameters") or {}
+    output_var = (params.get("output_var") or "extracted_text").strip()
+    paragraph = bool(params.get("paragraph", True))
+
+    heartbeat = last_heartbeat.get(session_id) or {}
+    path = heartbeat.get("path")
+    text = ""
+
+    if path:
+        try:
+            from core.llm import extract_text_from_image
+            text = extract_text_from_image(path, paragraph=paragraph)
+        except Exception as e:
+            logger.warning("extract_text OCR échoué (%s) — variable '%s' = ''", e, output_var)
+    else:
+        logger.warning(
+            "extract_text : pas de heartbeat pour session %s — variable '%s' = ''",
+            session_id, output_var,
+        )
+
+    replay_state.setdefault("variables", {})[output_var] = text
+    logger.info(
+        "extract_text → variable '%s' (%d chars) replay %s",
+        output_var, len(text), replay_state.get("replay_id", "?"),
+    )
+    return bool(text)
+
+
+def _handle_t2a_decision_action(
+    action: Dict[str, Any],
+    replay_state: Dict[str, Any],
+) -> bool:
+    """Traite une action t2a_decision côté serveur. Stocke le résultat JSON
+    dans replay_state["variables"][output_var]. Retourne True si succès.
+
+    Le DPI à analyser vient de action.parameters.input_template (déjà résolu
+    par _resolve_runtime_vars donc les {{var}} sont remplis).
+    """
+    params = action.get("parameters") or {}
+    output_var = (params.get("output_var") or "t2a_result").strip()
+    dpi_text = (params.get("input_template") or params.get("dpi") or "").strip()
+    model = params.get("model") or None  # None → DEFAULT_MODEL
+
+    if not dpi_text:
+        logger.warning(
+            "t2a_decision : input vide — variable '%s' = {decision: 'INDETERMINE'}", output_var,
+        )
+        replay_state.setdefault("variables", {})[output_var] = {
+            "decision": "INDETERMINE",
+            "justification": "DPI vide ou non extrait",
+            "confiance": "faible",
+            "_error": "empty_input",
+        }
+        return False
+
+    try:
+        from core.llm import analyze_dpi, DEFAULT_MODEL
+        result = analyze_dpi(dpi_text, model=model or DEFAULT_MODEL)
+    except Exception as e:
+        logger.warning("t2a_decision : analyze_dpi exception %s", e)
+        result = {
+            "decision": "INDETERMINE",
+            "justification": f"Erreur analyse : {e}",
+            "confiance": "faible",
+            "_error": str(e),
+        }
+
+    replay_state.setdefault("variables", {})[output_var] = result
+    decision = result.get("decision", "?")
+    elapsed = result.get("_elapsed_s", "?")
+    logger.info(
+        "t2a_decision → variable '%s' decision=%s (%ss) replay %s",
+        output_var, decision, elapsed, replay_state.get("replay_id", "?"),
+    )
+    return "_error" not in result
+
+
 def _expand_compound_steps(
     steps: List[Dict[str, Any]], base: Dict[str, Any], params: Dict[str, Any]
 ) -> List[Dict[str, Any]]:
@@ -1208,6 +1377,18 @@ def _create_replay_state(
         # Champs pour pause supervisée (target_not_found)
         "failed_action": None,   # Contexte de l'action en echec (quand paused_need_help)
         "pause_message": None,   # Message a afficher a l'utilisateur
+        # Variables d'exécution produites en cours de workflow (extract_text,
+        # t2a_decision, etc.). Résolues via templating {{var}} ou {{var.field}}
+        # dans les paramètres des actions suivantes.
+        "variables": {},
+        # QW2 — Anneaux d'historique pour LoopDetector (5 derniers max)
+        "_screenshot_history": [],   # images PIL des N derniers heartbeats (LoopDetector embed à chaque tick)
+        "_action_history": [],       # N dernières actions exécutées (signature)
+        # QW4 — Safety checks (hybride déclaratif + LLM contextuel) et audit acquittements
+        "safety_checks": [],            # liste produite par SafetyChecksProvider
+        "checks_acknowledged": [],      # ids acquittés via /replay/resume (audit trail)
+        "pause_reason": "",             # "loop_detected" | "" pour V1
+        "pause_payload": None,          # payload complet pour debug/audit
     }
 
 

agent_v0/server_v1/resolve_engine.py

@@ -26,6 +26,8 @@ from typing import Any, Dict, List, Optional
 
 from pydantic import BaseModel
 
+from core.grounding.bbox_parser import parse_bbox_to_norm, parse_bbox_to_norm_validated
+
 logger = logging.getLogger("api_stream")
 
 
@@ -833,51 +835,8 @@ def _resolve_by_grounding(
 
     elapsed = time.time() - t0
 
-    # Parser la réponse — supporte bbox_2d en pixels, JSON %, arrays bruts
-    x_pct, y_pct = None, None
-
-    # Format 1 : bbox_2d en pixels [x, y] ou [x1, y1, x2, y2]
-    bbox_match = re.search(r'"bbox_2d"\s*:\s*\[([^\]]+)\]', content)
-    if bbox_match:
-        coords = [float(v.strip()) for v in bbox_match.group(1).split(",")]
-        if len(coords) == 2:
-            x_pct = coords[0] / small_w
-            y_pct = coords[1] / small_h
-        elif len(coords) >= 4:
-            x_pct = (coords[0] + coords[2]) / 2 / small_w
-            y_pct = (coords[1] + coords[3]) / 2 / small_h
-
-    # Format 2 : JSON {"x": 0.XX, "y": 0.YY}
-    if x_pct is None:
-        json_match = re.search(r'"x"\s*:\s*([\d.]+).*?"y"\s*:\s*([\d.]+)', content)
-        if json_match:
-            x_val, y_val = float(json_match.group(1)), float(json_match.group(2))
-            # Si > 1, c'est en pixels
-            if x_val > 1:
-                x_pct = x_val / small_w
-                y_pct = y_val / small_h
-            else:
-                x_pct = x_val
-                y_pct = y_val
-
-    # Format 3 : {"x_pct": 0.XX, "y_pct": 0.YY}
-    if x_pct is None:
-        pct_match = re.search(r'"x_pct"\s*:\s*([\d.]+).*?"y_pct"\s*:\s*([\d.]+)', content)
-        if pct_match:
-            x_pct = float(pct_match.group(1))
-            y_pct = float(pct_match.group(2))
-
-    # Format 4 : array brut [x1, y1, x2, y2] ou [x, y]
-    if x_pct is None:
-        arr_match = re.search(r'\[[\s]*([\d.]+)\s*,\s*([\d.]+)(?:\s*,\s*([\d.]+)\s*,\s*([\d.]+))?\s*\]', content)
-        if arr_match:
-            vals = [float(v) for v in arr_match.groups() if v is not None]
-            if len(vals) >= 4:
-                x_pct = (vals[0] + vals[2]) / 2 / small_w
-                y_pct = (vals[1] + vals[3]) / 2 / small_h
-            elif len(vals) == 2:
-                x_pct = vals[0] / small_w
-                y_pct = vals[1] / small_h
+    # Parser la réponse — délégué à core.grounding.bbox_parser
+    x_pct, y_pct = parse_bbox_to_norm(content, small_w, small_h)
 
     if x_pct is None or y_pct is None:
         # Fallback multi-image : screenshot + crop → grounding sans description
@@ -900,21 +859,12 @@ def _resolve_by_grounding(
                 content2 = resp2.json().get("message", {}).get("content", "")
                 elapsed = time.time() - t0
 
-                # Parser tous les formats
-                arr2 = re.search(r'\[[\s]*([\d.]+)\s*,\s*([\d.]+)(?:\s*,\s*([\d.]+)\s*,\s*([\d.]+))?\s*\]', content2)
-                if arr2:
-                    vals = [float(v) for v in arr2.groups() if v is not None]
-                    if len(vals) >= 4:
-                        x_pct = (vals[0] + vals[2]) / 2 / small_w
-                        y_pct = (vals[1] + vals[3]) / 2 / small_h
-                    elif len(vals) == 2:
-                        x_pct = vals[0] / small_w
-                        y_pct = vals[1] / small_h
-                if x_pct is None:
-                    json2 = re.search(r'"x"\s*:\s*([\d.]+).*?"y"\s*:\s*([\d.]+)', content2)
-                    if json2:
-                        x_pct = float(json2.group(1)) / small_w
-                        y_pct = float(json2.group(2)) / small_h
+                # Parser la réponse — délégué à core.grounding.bbox_parser
+                # Restriction aux 2 formats attendus par le prompt retry multi-image
+                # (cf. prompt_mi qui demande {"x": NNN, "y": NNN} en pixels).
+                x_pct, y_pct = parse_bbox_to_norm(
+                    content2, small_w, small_h, formats={"xy_json", "raw_array"}
+                )
                 if x_pct is not None:
                     logger.info("Grounding multi-image OK (%.1fs)", elapsed)
             except Exception as e:
@@ -1746,6 +1696,49 @@ def _resolve_target_sync(
                 )
                 return result
 
+        # ---------------------------------------------------------------
+        # Étape 0.5 : OCR direct (hybrid_text_direct) — chemin rapide
+        # ---------------------------------------------------------------
+        # Si on a un texte cible non vide, le localiser par OCR direct
+        # avant de tomber sur le VLM (~100-300ms vs 2-23s par appel VLM).
+        # Reconnecté le 2026-05-06 : la fonction _resolve_by_ocr_text
+        # existait déjà mais n'était appelée QUE depuis le runtime V4
+        # (resolve_order pré-compilé), qui n'est pas branché côté frontend
+        # (cf. audit project-quality-guardian Cas #5). La cascade legacy
+        # tombait directement sur VLM Quick Find d'où des replays à 23s
+        # par action visuelle au lieu de <500ms attendus.
+        # Le method est rebadgé "hybrid_text_direct" (seuil 0.80 dans
+        # _RESOLUTION_MIN_SCORES, identifiant historique côté client
+        # Agent V1 et logs Learning).
+        if by_text_strict:
+            ocr_result = _resolve_by_ocr_text(
+                screenshot_path=screenshot_path,
+                target_text=by_text_strict,
+                screen_width=screen_width,
+                screen_height=screen_height,
+            )
+            if ocr_result and ocr_result.get("score", 0) >= 0.80:
+                ocr_result["method"] = "hybrid_text_direct"
+                logger.info(
+                    "Strict resolve OCR-DIRECT : OK '%s' → (%.4f, %.4f) score=%.2f",
+                    by_text_strict[:40],
+                    ocr_result.get("x_pct", 0),
+                    ocr_result.get("y_pct", 0),
+                    ocr_result.get("score", 0),
+                )
+                return ocr_result
+            elif ocr_result:
+                logger.info(
+                    "Strict resolve OCR-DIRECT : '%s' trouvé score=%.2f < 0.80, passage VLM",
+                    by_text_strict[:40],
+                    ocr_result.get("score", 0),
+                )
+            else:
+                logger.info(
+                    "Strict resolve OCR-DIRECT : '%s' non trouvé, passage VLM",
+                    by_text_strict[:40],
+                )
+
         # ---------------------------------------------------------------
         # Étape 1 : VLM Quick Find (fallback, multi-image)
         # ---------------------------------------------------------------
@@ -2117,6 +2110,135 @@ _RESOLUTION_MIN_SCORES: Dict[str, float] = {
 _RESOLUTION_MAX_DRIFT: float = 0.20
 
 
+# ===========================================================================
+# Pré-check sémantique : OCR de validation de position
+# ===========================================================================
+# Avant de dispatcher un clic, on vérifie que le texte attendu (by_text) est
+# bien présent dans une fenêtre OCR autour de la coordonnée résolue. Cela
+# attrape les cas où la cascade renvoie une coordonnée plausible mais qui
+# pointe en réalité sur un autre élément (ex: clic sur "Dossier en cours" du
+# menu au lieu de "Synthèse Urgences" du tab plus bas).
+# ===========================================================================
+
+_VALIDATION_OCR_READER = None
+_VALIDATION_OCR_LOCK = threading.Lock()
+_VALIDATION_OCR_FAILED = False
+
+
+def _get_validation_ocr_reader():
+    """Singleton EasyOCR partagé pour la validation post-cascade.
+
+    Chargement paresseux à la première requête. En cas d'échec, on cache
+    le statut FAILED pour ne pas retenter à chaque appel et bloquer le flux.
+    """
+    global _VALIDATION_OCR_READER, _VALIDATION_OCR_FAILED
+    if _VALIDATION_OCR_FAILED:
+        return None
+    with _VALIDATION_OCR_LOCK:
+        if _VALIDATION_OCR_READER is None and not _VALIDATION_OCR_FAILED:
+            try:
+                import easyocr  # type: ignore
+                _VALIDATION_OCR_READER = easyocr.Reader(
+                    ['fr', 'en'], gpu=True, verbose=False
+                )
+                logger.info("[REPLAY] EasyOCR validator chargé (fr+en, GPU)")
+            except Exception as e:
+                logger.warning("[REPLAY] EasyOCR validator indisponible (%s) — pré-check désactivé", e)
+                _VALIDATION_OCR_FAILED = True
+                return None
+    return _VALIDATION_OCR_READER
+
+
+def _normalize_for_match(s: str) -> str:
+    """Normalisation pour comparaison textuelle robuste : lowercase, sans
+    accents, ponctuation → espace, espaces multiples écrasés.
+    """
+    import unicodedata
+    decomposed = unicodedata.normalize('NFD', s.lower())
+    no_accents = ''.join(c for c in decomposed if unicodedata.category(c) != 'Mn')
+    cleaned = ''.join(c if c.isalnum() or c.isspace() else ' ' for c in no_accents)
+    return ' '.join(cleaned.split())
+
+
+def _text_match_fuzzy(expected: str, observed: str, min_token_ratio: float = 0.60) -> bool:
+    """Match tolérant aux imperfections OCR.
+
+    1. Substring exacte → match.
+    2. Sinon : split en tokens ≥3 caractères, retourne True si au moins
+       `min_token_ratio` des tokens attendus apparaissent dans observed.
+       Ex : "Coller ou saisir le dossier patient" → tokens
+       ['coller', 'saisir', 'dossier', 'patient'] ; si OCR voit "u saisir
+       le dossier patient" → 3/4 = 75% présents → match accepté.
+
+    Cible le compromis entre strict (faux négatifs sur erreurs OCR) et
+    permissif (faux positifs sur textes voisins).
+    """
+    nexp = _normalize_for_match(expected)
+    nobs = _normalize_for_match(observed)
+    if not nexp:
+        return True
+    if nexp in nobs:
+        return True
+    tokens = [t for t in nexp.split() if len(t) >= 3]
+    if not tokens:
+        return False
+    matched = sum(1 for t in tokens if t in nobs)
+    return matched / len(tokens) >= min_token_ratio
+
+
+def _validate_text_at_position(
+    screenshot_path: str,
+    x_pct: float,
+    y_pct: float,
+    expected_text: str,
+    screen_width: int,
+    screen_height: int,
+    radius_px: int = 280,
+) -> tuple:
+    """Pré-check sémantique : OCR sur une zone autour de (x_pct, y_pct) et
+    vérifie que `expected_text` y est présent (substring ou fuzzy 50%).
+
+    Retourne (is_valid: bool, observed_text: str, elapsed_ms: float).
+
+    Politique en cas d'échec OCR (lib absente, exception) : retourne
+    (True, "", 0.0) pour ne pas bloquer le flux. Mieux vaut un faux positif
+    rare qu'une régression bloquante introduite par la validation elle-même.
+    """
+    reader = _get_validation_ocr_reader()
+    if reader is None:
+        return True, "", 0.0
+    if not expected_text or not expected_text.strip():
+        return True, "", 0.0
+    try:
+        from PIL import Image
+        import numpy as np
+
+        t0 = time.time()
+        img = Image.open(screenshot_path).convert("RGB")
+        img_w, img_h = img.size
+        cx = int(x_pct * screen_width)
+        cy = int(y_pct * screen_height)
+        # Saturer dans les bornes de l'image (le screenshot peut être plus
+        # large que la fenêtre logique — utiliser min(img_*, screen_*) en sécurité).
+        max_x = min(img_w, screen_width)
+        max_y = min(img_h, screen_height)
+        x1 = max(0, cx - radius_px)
+        y1 = max(0, cy - radius_px)
+        x2 = min(max_x, cx + radius_px)
+        y2 = min(max_y, cy + radius_px)
+        if x2 - x1 < 10 or y2 - y1 < 10:
+            return True, "", 0.0
+        crop = img.crop((x1, y1, x2, y2))
+        results = reader.readtext(np.array(crop))
+        observed = " ".join(r[1] for r in results if r and len(r) >= 2)
+        elapsed_ms = (time.time() - t0) * 1000
+        is_valid = _text_match_fuzzy(expected_text, observed, min_token_ratio=0.50)
+        return is_valid, observed, elapsed_ms
+    except Exception as e:
+        logger.warning("[REPLAY] _validate_text_at_position erreur (%s) — pas de blocage", e)
+        return True, "", 0.0
+
+
 def _validate_resolution_quality(
     result: Optional[Dict[str, Any]],
     fallback_x_pct: float,
@@ -2193,6 +2315,30 @@ def _validate_resolution_quality(
         dx = abs(resolved_x - fallback_x_pct)
         dy = abs(resolved_y - fallback_y_pct)
         if dx > _RESOLUTION_MAX_DRIFT or dy > _RESOLUTION_MAX_DRIFT:
+            # Exception : pour les méthodes "haute confiance" qui ont
+            # identifié sémantiquement la cible (texte exact via OCR ou
+            # image quasi parfaite via template), on fait confiance à la
+            # position visuelle peu importe le drift. Le drift par rapport
+            # à l'enregistrement ne reflète qu'un changement de layout
+            # (scroll, redimensionnement, F11, refonte UI, résolution
+            # différente), pas une erreur de résolution.
+            #
+            # - template_matching ≥ 0.95 : image retrouvée pixel-perfect
+            # - hybrid_text_direct ≥ 0.80 : texte exact reconnu par OCR
+            #   (0.80 est déjà le seuil d'acceptation côté _RESOLUTION_MIN_SCORES,
+            #   au-dessus on a un signal sémantique fiable).
+            _high_confidence_method = (
+                (method.startswith("template_matching") and score >= 0.95)
+                or (method == "hybrid_text_direct" and score >= 0.80)
+            )
+            if _high_confidence_method:
+                logger.info(
+                    "[REPLAY] Drift (%.3f, %.3f) > %.2f IGNORÉ : score=%.3f "
+                    "sur %s — résultat visuel fiable, on l'utilise",
+                    dx, dy, _RESOLUTION_MAX_DRIFT, score, method,
+                )
+                return result
+
             logger.warning(
                 "[REPLAY] Resolution REJETÉE (drift trop grand) : "
                 "method=%s resolved=(%.3f, %.3f) expected=(%.3f, %.3f) "
@@ -2201,6 +2347,10 @@ def _validate_resolution_quality(
                 fallback_x_pct, fallback_y_pct,
                 dx, dy, _RESOLUTION_MAX_DRIFT,
             )
+            # 100% visuel : on ne clique JAMAIS aux coords enregistrées en aveugle.
+            # resolved=False → la couche supérieure tente la méthode suivante
+            # (VLM Quick Find, SoM, grounding) ; si toutes échouent, l'agent
+            # passe par "visual_resolve_failed" → Policy → pause supervisée.
             return {
                 "resolved": False,
                 "method": f"rejected_drift_{method}",
@@ -2363,21 +2513,16 @@ def _locate_popup_button(
 
         content = resp.json().get("message", {}).get("content", "")
 
-        # Parser bbox_2d — qwen2.5vl retourne des coordonnées en pixels
-        # relatifs à l'image envoyée, PAS sur une grille 1000x1000.
-        # Format JSON : [{"bbox_2d": [x1, y1, x2, y2], "label": "..."}]
-        bbox_match = re.search(
-            r'"bbox_2d"\s*:\s*\[\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\]',
-            content,
+        # Parser bbox_2d — délégué à core.grounding.bbox_parser
+        # Restriction au format bbox_2d attendu par le prompt
+        # (cf. prompt qui demande "bounding box"). qwen2.5vl retourne
+        # des coordonnées en pixels relatifs à l'image envoyée.
+        cx, cy = parse_bbox_to_norm_validated(
+            content, screen_width, screen_height, formats={"bbox_2d"}
         )
-        if bbox_match:
-            x1, y1, x2, y2 = [int(bbox_match.group(i)) for i in range(1, 5)]
-            # Normaliser par les dimensions de l'écran (pixels → 0-1)
-            cx = (x1 + x2) / 2 / screen_width
-            cy = (y1 + y2) / 2 / screen_height
-            if 0.0 <= cx <= 1.0 and 0.0 <= cy <= 1.0:
-                logger.info(f"Observer : bouton '{button_text}' localisé à ({cx:.3f}, {cy:.3f})")
-                return {"x_pct": cx, "y_pct": cy}
+        if cx is not None:
+            logger.info(f"Observer : bouton '{button_text}' localisé à ({cx:.3f}, {cy:.3f})")
+            return {"x_pct": cx, "y_pct": cy}
 
     except Exception as e:
         logger.debug(f"Observer grounding bouton erreur : {e}")

agent_v0/server_v1/safety_checks_provider.py

@@ -0,0 +1,195 @@
+# agent_v0/server_v1/safety_checks_provider.py
+"""SafetyChecksProvider — checks hybrides déclaratifs + LLM contextuels (QW4).
+
+Pour une action pause_for_human :
+- les checks déclaratifs (workflow) sont toujours inclus
+- si safety_level == "medical_critical" et RPA_SAFETY_CHECKS_LLM_ENABLED=1,
+  un appel LLM (medgemma:4b par défaut) ajoute jusqu'à N checks contextuels
+
+Tout échec côté LLM (timeout, exception, parse) → additional_checks=[] :
+le replay continue avec uniquement les déclaratifs (fallback safe).
+"""
+
+import base64
+import json
+import logging
+import os
+import uuid
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class PausePayload:
+    checks: List[Dict[str, Any]] = field(default_factory=list)
+    pause_reason: str = ""
+    message: str = ""
+
+
+def _env(name: str, default: str) -> str:
+    return os.environ.get(name, default).strip()
+
+
+def _env_int(name: str, default: int) -> int:
+    try:
+        return int(os.environ.get(name, default))
+    except (TypeError, ValueError):
+        return default
+
+
+def _env_bool_enabled(name: str) -> bool:
+    val = os.environ.get(name, "1").strip().lower()
+    return val not in ("0", "false", "no", "off", "")
+
+
+def build_pause_payload(
+    action: Dict[str, Any],
+    replay_state: Dict[str, Any],
+    last_screenshot: Optional[str],
+) -> PausePayload:
+    """Construit le payload de pause enrichi pour une action pause_for_human."""
+    params = action.get("parameters") or {}
+    message = params.get("message", "Validation requise")
+    safety_level = params.get("safety_level")
+    declarative = params.get("safety_checks") or []
+
+    # Normalisation des checks déclaratifs
+    checks: List[Dict[str, Any]] = []
+    for d in declarative:
+        checks.append({
+            "id": d.get("id") or f"decl_{uuid.uuid4().hex[:6]}",
+            "label": d.get("label", "Validation"),
+            "required": bool(d.get("required", True)),
+            "source": "declarative",
+            "evidence": None,
+        })
+
+    # Ajout LLM contextual si applicable
+    if safety_level == "medical_critical" and _env_bool_enabled("RPA_SAFETY_CHECKS_LLM_ENABLED"):
+        try:
+            additional = _call_llm_for_contextual_checks(
+                action=action,
+                replay_state=replay_state,
+                last_screenshot=last_screenshot,
+                existing_labels=[c["label"] for c in checks],
+            )
+        except Exception as e:
+            logger.warning("[BUS] lea:safety_checks_llm_failed reason=exception detail=%s", e)
+            additional = []
+
+        for a in additional:
+            checks.append({
+                "id": f"llm_{uuid.uuid4().hex[:6]}",
+                "label": a.get("label", ""),
+                "required": False,  # checks LLM = informationnels, pas obligatoires V1
+                "source": "llm_contextual",
+                "evidence": a.get("evidence", ""),
+            })
+
+    return PausePayload(
+        checks=checks,
+        pause_reason="",
+        message=message,
+    )
+
+
+def _call_llm_for_contextual_checks(
+    action: Dict[str, Any],
+    replay_state: Dict[str, Any],
+    last_screenshot: Optional[str],
+    existing_labels: List[str],
+) -> List[Dict[str, str]]:
+    """Appelle Ollama en mode JSON strict pour générer 0-N checks contextuels.
+
+    Returns:
+        List[{label, evidence}] (max RPA_SAFETY_CHECKS_LLM_MAX_CHECKS).
+        [] sur tout échec (timeout, JSON invalide, exception).
+    """
+    import requests
+
+    # Défaut gemma4:latest : meilleur compromis détection/latence sur bench
+    # 2026-05-06 (cf. docs/BENCH_SAFETY_CHECKS_2026-05-06.md). medgemma:4b
+    # retournait systématiquement [] (refus de signaler).
+    model = _env("RPA_SAFETY_CHECKS_LLM_MODEL", "gemma4:latest")
+    # Timeout 7s : warm avg gemma4 = 2.9s + marge 4s. Cold start ~10s couvert
+    # si le modèle reste résident (OLLAMA_KEEP_ALIVE=24h recommandé prod).
+    timeout_s = _env_int("RPA_SAFETY_CHECKS_LLM_TIMEOUT_S", 7)
+    max_checks = _env_int("RPA_SAFETY_CHECKS_LLM_MAX_CHECKS", 3)
+    ollama_url = _env("OLLAMA_URL", "http://localhost:11434")
+
+    params = action.get("parameters") or {}
+    workflow_message = params.get("message", "")
+    existing = ", ".join(existing_labels) if existing_labels else "aucun"
+
+    prompt = f"""Tu es Léa, assistante médicale supervisée.
+Avant de continuer le workflow, tu dois lister 0 à {max_checks} vérifications supplémentaires
+que l'humain doit acquitter, en regardant l'écran actuel.
+
+Contexte workflow : {workflow_message}
+Checks déjà demandés : {existing}
+
+NE répète PAS un check déjà demandé.
+Si rien d'inhabituel à signaler, retourne {{"additional_checks": []}}.
+
+Réponds UNIQUEMENT en JSON :
+{{
+  "additional_checks": [
+    {{"label": "string court", "evidence": "ce que tu as vu d'inhabituel"}}
+  ]
+}}
+"""
+
+    payload = {
+        "model": model,
+        "prompt": prompt,
+        "stream": False,
+        "format": "json",
+        "options": {"temperature": 0.1, "num_predict": 200},
+    }
+
+    if last_screenshot and os.path.isfile(last_screenshot):
+        try:
+            with open(last_screenshot, "rb") as f:
+                payload["images"] = [base64.b64encode(f.read()).decode("ascii")]
+        except Exception as e:
+            logger.debug("safety_checks: lecture screenshot échouée (%s) — appel sans image", e)
+
+    try:
+        response = requests.post(
+            f"{ollama_url}/api/generate",
+            json=payload,
+            timeout=timeout_s,
+        )
+        if response.status_code != 200:
+            logger.warning("[BUS] lea:safety_checks_llm_failed reason=http_status detail=%s", response.status_code)
+            return []
+        text = response.json().get("response", "").strip()
+    except requests.Timeout:
+        logger.warning("[BUS] lea:safety_checks_llm_failed reason=timeout detail=%ss", timeout_s)
+        return []
+    except Exception as e:
+        logger.warning("[BUS] lea:safety_checks_llm_failed reason=network detail=%s", e)
+        return []
+
+    # format=json garantit normalement du JSON valide
+    try:
+        parsed = json.loads(text)
+    except json.JSONDecodeError as e:
+        logger.warning("[BUS] lea:safety_checks_llm_failed reason=json_decode detail=%s", e)
+        return []
+
+    additional = parsed.get("additional_checks") or []
+    if not isinstance(additional, list):
+        return []
+
+    # Filtre + tronc
+    valid = []
+    for item in additional[:max_checks]:
+        if isinstance(item, dict) and item.get("label"):
+            valid.append({
+                "label": str(item["label"])[:200],
+                "evidence": str(item.get("evidence", ""))[:300],
+            })
+    return valid

core/execution/input_handler.py

@@ -19,9 +19,23 @@ logger = logging.getLogger(__name__)
 try:
     import pyautogui
     PYAUTOGUI_AVAILABLE = True
-except ImportError:
+except Exception:
+    # pyautogui peut lever Xlib.error.DisplayConnectionError (pas un ImportError)
+    # quand X n'est pas accessible — typique d'un service systemd côté serveur.
     PYAUTOGUI_AVAILABLE = False
 
+try:
+    import mss
+    MSS_AVAILABLE = True
+except ImportError:
+    MSS_AVAILABLE = False
+
+try:
+    from PIL import Image as PILImage
+    PIL_AVAILABLE = True
+except ImportError:
+    PIL_AVAILABLE = False
+
 
 def safe_type_text(text: str):
     """Saisie de texte compatible VM/Citrix et claviers AZERTY/QWERTY.
@@ -116,13 +130,13 @@ def check_screen_for_patterns() -> Optional[Dict[str, Any]]:
 
         pattern = lib.find_pattern(ocr_text)
         if pattern and pattern['category'] in ('dialog', 'popup'):
-            logger.info(f"Pattern UI détecté: {pattern['pattern']} → {pattern['action']} '{pattern['target']}'")
+            print(f"🧠 [PatternCheck] Détecté: '{pattern['pattern']}' → {pattern['action']} '{pattern['target']}'")
             return pattern
 
         return None
 
     except Exception as e:
-        logger.debug(f"Pattern check échoué: {e}")
+        print(f"⚠️ [PatternCheck] Erreur: {e}")
         return None
 
 
@@ -145,26 +159,42 @@ def handle_detected_pattern(pattern: Dict[str, Any]) -> bool:
 
     if action == 'click':
         candidates_labels = [target] + alternatives
+        print(f"🔧 [Réflexe/handle] Recherche bouton parmi: {candidates_labels}")
 
         try:
             import mss
+            import numpy as np
             from PIL import Image
 
-            # Importer OCR (essayer les deux chemins)
-            try:
-                from services.ocr_service import ocr_extract_words
-            except ImportError:
-                from core.extraction.field_extractor import FieldExtractor
-                extractor = FieldExtractor()
-                def ocr_extract_words(img):
-                    return extractor.extract_words_from_image(img)
-
             with mss.mss() as sct:
                 monitor = sct.monitors[0]
                 screenshot = sct.grab(monitor)
                 screen = Image.frombytes('RGB', screenshot.size, screenshot.bgra, 'raw', 'BGRX')
 
-            words = ocr_extract_words(screen)
+            # EasyOCR (rapide, bonne qualité GUI) avec fallback docTR.
+            # gpu=True : harmonisé avec dialog_handler.py et title_verifier.py.
+            # Coût VRAM ~0.5 GB, sous le budget RTX 5070 (cf. deploy/VRAM_BUDGET.md).
+            words = []
+            try:
+                import easyocr
+                _reader = easyocr.Reader(['fr', 'en'], gpu=True, verbose=False)
+                results = _reader.readtext(np.array(screen))
+                for (bbox_pts, text, conf) in results:
+                    if not text or len(text.strip()) < 1:
+                        continue
+                    x1 = int(min(p[0] for p in bbox_pts))
+                    y1 = int(min(p[1] for p in bbox_pts))
+                    x2 = int(max(p[0] for p in bbox_pts))
+                    y2 = int(max(p[1] for p in bbox_pts))
+                    words.append({'text': text.strip(), 'bbox': [x1, y1, x2, y2]})
+            except ImportError:
+                try:
+                    from services.ocr_service import ocr_extract_words
+                    words = ocr_extract_words(screen) or []
+                except ImportError:
+                    pass
+
+            print(f"🔧 [Réflexe/handle] {len(words)} mots OCR détectés")
 
             # Collecter tous les matchs, prendre le plus bas (bouton = bas du dialogue)
             all_matches = []
@@ -175,58 +205,28 @@ def handle_detected_pattern(pattern: Dict[str, Any]) -> bool:
                     word_text = word['text'].lower()
                     if len(word_text) < 2 or len(candidate_lower) < 2:
                         continue
-                    if word_text == candidate_lower:
+                    # Match exact ou inclusion
+                    if word_text == candidate_lower or candidate_lower in word_text or word_text in candidate_lower:
                         x1, y1, x2, y2 = word['bbox']
                         all_matches.append({
                             'text': word['text'],
                             'x': int((x1 + x2) / 2),
                             'y': int((y1 + y2) / 2),
-                            'match_type': 'exact',
+                            'candidate': candidate,
                         })
 
-            # Recherche partielle (lettre soulignée manquante)
-            if not all_matches:
-                for candidate in candidates_labels:
-                    if len(candidate) > 3:
-                        partial = candidate[1:].lower()
-                        for word in words:
-                            if partial in word['text'].lower():
-                                x1, y1, x2, y2 = word['bbox']
-                                all_matches.append({
-                                    'text': word['text'],
-                                    'x': int((x1 + x2) / 2),
-                                    'y': int((y1 + y2) / 2),
-                                    'match_type': 'partial',
-                                })
-
             if all_matches:
                 best = max(all_matches, key=lambda m: m['y'])
-                logger.info(f"Clic sur '{best['text']}' à ({best['x']}, {best['y']})")
+                print(f"✅ [Réflexe/handle] Clic sur '{best['text']}' à ({best['x']}, {best['y']})")
                 pyautogui.click(best['x'], best['y'])
                 time.sleep(1.0)
                 return True
 
-            logger.info(f"Bouton '{target}' introuvable par OCR — appel VLM...")
-            vlm_result = vlm_reason_about_screen(
-                objective=f"Cliquer sur le bouton '{target}'",
-                context=f"Un dialogue '{pattern.get('pattern')}' est détecté"
-            )
-            if vlm_result and vlm_result.get('action') == 'click' and vlm_result.get('target'):
-                vlm_target = vlm_result['target']
-                for word in words:
-                    if vlm_target.lower() in word['text'].lower():
-                        x1, y1, x2, y2 = word['bbox']
-                        x = int((x1 + x2) / 2)
-                        y = int((y1 + y2) / 2)
-                        logger.info(f"VLM → clic sur '{word['text']}' à ({x}, {y})")
-                        pyautogui.click(x, y)
-                        time.sleep(1.0)
-                        return True
-
+            print(f"⚠️ [Réflexe/handle] Bouton '{target}' introuvable parmi {[w['text'] for w in words[:15]]}")
             return False
 
         except Exception as e:
-            logger.warning(f"OCR bouton échoué: {e}")
+            print(f"⚠️ [Réflexe/handle] Erreur: {e}")
             return False
 
     elif action == 'hotkey':
@@ -328,6 +328,7 @@ def find_element_on_screen(
     target_description: str = "",
     anchor_image_base64: Optional[str] = None,
     anchor_bbox: Optional[Dict] = None,
+    monitor_idx: Optional[int] = None,
 ) -> Optional[Dict[str, Any]]:
     """
     Cherche un élément sur l'écran en utilisant 3 méthodes en cascade.
@@ -341,6 +342,7 @@ def find_element_on_screen(
         target_description: Description plus longue (ex: "le dossier Demo sur le bureau")
         anchor_image_base64: Image de référence de l'ancre (pour CLIP matching, réservé futur)
         anchor_bbox: Position originale de l'ancre (pour désambiguïser les matchs multiples)
+        monitor_idx: Index logique 0..N-1 du monitor à scruter. None = composite legacy.
 
     Returns:
         {'x': int, 'y': int, 'method': str, 'confidence': float} ou None
@@ -363,6 +365,13 @@ def find_element_on_screen(
         logger.debug("find_element_on_screen: ni target_text ni target_description fournis")
         return None
 
+    # Propager monitor_idx au niveau OCR via anchor_bbox (sans muter l'argument original)
+    if monitor_idx is not None and anchor_bbox is not None:
+        anchor_bbox = dict(anchor_bbox)  # copie pour ne pas muter l'argument
+        anchor_bbox["monitor_idx"] = monitor_idx
+    elif monitor_idx is not None:
+        anchor_bbox = {"monitor_idx": monitor_idx}
+
     search_label = target_description or target_text
     logger.info(f"[Grounding] Recherche élément: '{search_label}' (cascade 3 niveaux)")
 
@@ -372,12 +381,12 @@ def find_element_on_screen(
         return result
 
     # ─── Niveau 2 — UI-TARS grounding (~3s) ───
-    result = _grounding_ui_tars(target_text, target_description)
+    result = _grounding_ui_tars(target_text, target_description, monitor_idx=monitor_idx)
     if result:
         return result
 
     # ─── Niveau 3 — VLM reasoning (~10s) ───
-    result = _grounding_vlm(target_text, target_description)
+    result = _grounding_vlm(target_text, target_description, monitor_idx=monitor_idx)
     if result:
         return result
 
@@ -427,20 +436,43 @@ def _describe_anchor_image(anchor_image_base64: str) -> Optional[str]:
         return None
 
 
-def _capture_screen():
-    """Capture l'écran principal et retourne (PIL.Image, width, height)."""
-    try:
-        import mss
-        from PIL import Image as PILImage
+def _capture_screen(monitor_idx=None):
+    """Capture l'écran et retourne (PIL.Image, width, height, offset_x, offset_y).
 
+    Args:
+        monitor_idx: Index logique 0..N-1 du monitor à capturer (cf. screeninfo).
+            Si None : capture composite (mss.monitors[0]) — comportement legacy.
+
+    Returns:
+        (image, w, h, offset_x, offset_y). offset = (0,0) en mode composite.
+    """
+    try:
         with mss.mss() as sct:
-            monitor = sct.monitors[0]
+            if monitor_idx is None:
+                # Comportement actuel : composite tous écrans
+                monitor = sct.monitors[0]
+                offset_x, offset_y = 0, 0
+            else:
+                # mss skip monitors[0] (composite). Index logique 0 → mss.monitors[1].
+                mss_idx = int(monitor_idx) + 1
+                if mss_idx >= len(sct.monitors):
+                    logger.warning(
+                        "mss.monitors[%d] hors limites (n=%d) — fallback composite",
+                        mss_idx, len(sct.monitors),
+                    )
+                    monitor = sct.monitors[0]
+                    offset_x, offset_y = 0, 0
+                else:
+                    monitor = sct.monitors[mss_idx]
+                    offset_x = int(monitor.get("left", 0))
+                    offset_y = int(monitor.get("top", 0))
+
             screenshot = sct.grab(monitor)
             screen = PILImage.frombytes('RGB', screenshot.size, screenshot.bgra, 'raw', 'BGRX')
-            return screen, monitor['width'], monitor['height']
+            return screen, monitor['width'], monitor['height'], offset_x, offset_y
     except Exception as e:
         logger.debug(f"Capture écran échouée: {e}")
-        return None, 0, 0
+        return None, 0, 0, 0, 0
 
 
 def _grounding_ocr(target_text: str, anchor_bbox: Optional[Dict] = None) -> Optional[Dict[str, Any]]:
@@ -455,7 +487,8 @@ def _grounding_ocr(target_text: str, anchor_bbox: Optional[Dict] = None) -> Opti
         return None
 
     try:
-        screen, screen_w, screen_h = _capture_screen()
+        monitor_idx_param = anchor_bbox.get("monitor_idx") if anchor_bbox else None
+        screen, screen_w, screen_h, ox, oy = _capture_screen(monitor_idx=monitor_idx_param)
         if screen is None:
             return None
 
@@ -519,14 +552,14 @@ def _grounding_ocr(target_text: str, anchor_bbox: Optional[Dict] = None) -> Opti
             sel = " ← CHOISI" if m is best else ""
             logger.info(f"  [OCR] Candidat: '{m['text']}' à ({m['x']}, {m['y']}) [{m['type']}]{sel}")
 
-        return {'x': best['x'], 'y': best['y'], 'method': 'ocr', 'confidence': best['conf']}
+        return {'x': best['x'] + ox, 'y': best['y'] + oy, 'method': 'ocr', 'confidence': best['conf']}
 
     except Exception as e:
         logger.debug(f"[Grounding/OCR] Erreur: {e}")
         return None
 
 
-def _grounding_ui_tars(target_text: str, target_description: str = "") -> Optional[Dict[str, Any]]:
+def _grounding_ui_tars(target_text: str, target_description: str = "", monitor_idx=None) -> Optional[Dict[str, Any]]:
     """Niveau 2 — UI-TARS grounding visuel (~3s)."""
     try:
         import requests
@@ -535,7 +568,7 @@ def _grounding_ui_tars(target_text: str, target_description: str = "") -> Option
         import re
         import os
 
-        screen, screen_w, screen_h = _capture_screen()
+        screen, screen_w, screen_h, ox, oy = _capture_screen(monitor_idx=monitor_idx)
         if screen is None:
             return None
 
@@ -580,7 +613,7 @@ def _grounding_ui_tars(target_text: str, target_description: str = "") -> Option
             # Valider que les coordonnées sont dans l'écran
             if 0 <= x <= screen_w and 0 <= y <= screen_h:
                 logger.info(f"[Grounding/UI-TARS] Grounding → ({x}, {y})")
-                return {'x': x, 'y': y, 'method': 'ui_tars', 'confidence': 0.85}
+                return {'x': x + ox, 'y': y + oy, 'method': 'ui_tars', 'confidence': 0.85}
             else:
                 logger.warning(f"[Grounding/UI-TARS] Coordonnées hors écran: ({x}, {y}) pour {screen_w}x{screen_h}")
                 return None
@@ -640,7 +673,7 @@ def _parse_ui_tars_coordinates(text: str, screen_w: int, screen_h: int) -> Optio
     return None
 
 
-def _grounding_vlm(target_text: str, target_description: str = "") -> Optional[Dict[str, Any]]:
+def _grounding_vlm(target_text: str, target_description: str = "", monitor_idx=None) -> Optional[Dict[str, Any]]:
     """Niveau 3 — VLM reasoning + confirmation OCR (~10s)."""
     try:
         search_label = target_description or target_text
@@ -662,7 +695,7 @@ def _grounding_vlm(target_text: str, target_description: str = "") -> Optional[D
         logger.info(f"[Grounding/VLM] VLM suggère de cliquer sur: '{vlm_target}'")
 
         # Confirmation par OCR : chercher le target VLM sur l'écran
-        screen, screen_w, screen_h = _capture_screen()
+        screen, screen_w, screen_h, ox, oy = _capture_screen(monitor_idx=monitor_idx)
         if screen is None:
             return None
 
@@ -684,7 +717,7 @@ def _grounding_vlm(target_text: str, target_description: str = "") -> Optional[D
                     x = int((x1 + x2) / 2)
                     y = int((y1 + y2) / 2)
                     logger.info(f"[Grounding/VLM] Confirmé par OCR: '{word['text']}' à ({x}, {y})")
-                    return {'x': x, 'y': y, 'method': 'vlm', 'confidence': 0.75}
+                    return {'x': x + ox, 'y': y + oy, 'method': 'vlm', 'confidence': 0.75}
 
             logger.debug(f"[Grounding/VLM] Target VLM '{vlm_target}' non trouvé par OCR")
             return None

core/execution/observe_reason_act.py

@@ -58,7 +58,9 @@ except ImportError:
 try:
     import pyautogui
     PYAUTOGUI_AVAILABLE = True
-except ImportError:
+except Exception:
+    # pyautogui peut lever Xlib.error.DisplayConnectionError ou KeyError('DISPLAY')
+    # quand X n'est pas accessible — typique d'un service systemd côté serveur.
     pyautogui = None
     PYAUTOGUI_AVAILABLE = False
 
@@ -213,8 +215,40 @@ class ORALoop:
 
         # --- Mapper action_type vers action Decision ---
 
+        # Types d'action qui ne sont PAS des descriptions valides
+        _action_type_names = {'click_anchor', 'double_click_anchor', 'right_click_anchor',
+                              'hover_anchor', 'focus_anchor', 'scroll_to_anchor',
+                              'click', 'type_text', 'keyboard_shortcut', 'wait_for_anchor'}
+
         if action_type in ('click_anchor', 'click', 'double_click_anchor', 'right_click_anchor'):
-            target_text = anchor.get('target_text', '') or label
+            target_text = anchor.get('target_text', '') or anchor.get('description', '')
+
+            # Détecter les target_text absurdes : vide, nom d'action, ou bruit OCR
+            def _is_garbage(t):
+                if not t or t in _action_type_names:
+                    return True
+                # Bruit OCR : que des caractères spéciaux/chiffres/espaces
+                cleaned = t.replace('-', '').replace(' ', '').replace('.', '').replace('_', '')
+                if len(cleaned) < 3:
+                    return True
+                # Que des chiffres
+                if cleaned.isdigit():
+                    return True
+                return False
+
+            # Note: plus d'appel à _describe_anchor_image() (qwen2.5vl) ici.
+            # Le crop d'ancre (screenshot_b64) servira directement au template matching
+            # cv2 dans _act_click, puis fallback InfiGUI fusionné si nécessaire.
+            # Cela évite le conflit VRAM (qwen2.5vl 9.4GB + InfiGUI 2.4GB > 11.5GB GPU).
+
+            # Dernier fallback : label si pas un nom d'action
+            if _is_garbage(target_text):
+                target_text = label if label not in _action_type_names else ''
+                if target_text:
+                    print(f"🏷️ [ORA/reason] Label garbage, fallback texte: '{target_text}'")
+                else:
+                    print(f"🏷️ [ORA/reason] Pas de label texte — grounding via crop visuel uniquement")
+
             action = 'click'
             value = 'double' if action_type == 'double_click_anchor' else (
                 'right' if action_type == 'right_click_anchor' else 'left')
@@ -1222,6 +1256,7 @@ Règles:
             )
 
         print(f"🚀 [ORA] Démarrage workflow: {total} étapes, verify={self.verify_level}, retries={self.max_retries}")
+        print(f"🔧 [ORA] CODE VERSION: post-shortcut-dialog-handler ACTIF (26 avril 17h30)")
 
         for i, step in enumerate(steps):
             if not self._should_continue():
@@ -1234,6 +1269,28 @@ Règles:
             # --- 1. Observer l'état pré-action ---
             pre = self.observe()
 
+            # --- 1b. Réflexe : dialogue inattendu ? ---
+            # Déclenché si le pHash a changé de manière inattendue.
+            # Flux : titre fenêtre (50ms) → dialogue connu ? → InfiGUI clique (3s)
+            if i > 0 and hasattr(self, '_last_post_phash') and self._last_post_phash:
+                _phash_distance = self._phash_distance(pre.phash, self._last_post_phash)
+                if _phash_distance > 10:
+                    print(f"🧠 [ORA/réflexe] pHash changé (distance={_phash_distance}) → vérification dialogue")
+                    try:
+                        from core.grounding.dialog_handler import DialogHandler
+                        _dh = DialogHandler()
+                        _dh_result = _dh.handle_if_dialog(pre.screenshot)
+                        if _dh_result.get('handled'):
+                            print(f"✅ [ORA/réflexe] Dialogue '{_dh_result['title'][:30]}' géré → {_dh_result['action']}")
+                            time.sleep(0.5)
+                            pre = self.observe()
+                        elif _dh_result.get('dialog_type'):
+                            print(f"⚠️ [ORA/réflexe] Dialogue '{_dh_result.get('dialog_type')}' détecté mais non géré: {_dh_result.get('reason')}")
+                        else:
+                            print(f"🧠 [ORA/réflexe] Pas de dialogue détecté: {_dh_result.get('reason', '?')}")
+                    except Exception as _reflex_err:
+                        print(f"⚠️ [ORA/réflexe] Erreur: {_reflex_err}")
+
             # --- 2. Raisonner : construire la Decision ---
             decision = self.reason_workflow_step(step, pre)
 
@@ -1281,11 +1338,74 @@ Règles:
                         )
                     )
 
+            # --- 3b. Post-raccourci : attendre changement écran + gérer dialogue ---
+            # Après un keyboard_shortcut (pas scroll), on polle le pHash pour détecter
+            # si un dialogue est apparu (ex: "Enregistrer sous" après Ctrl+Shift+S).
+            # Si oui → InfiGUI localise et clique le bouton visuellement.
+            if act_success and decision.action == 'hotkey' and not decision.value.startswith('scroll_'):
+                print(f"🔍 [ORA/post-shortcut] ENTRÉ dans le bloc post-shortcut (action={decision.action}, value={decision.value})")
+                dialog_handled = self._handle_post_shortcut(pre)
+                if dialog_handled:
+                    time.sleep(0.5)
+                    post = self.observe()
+                    self._last_post_phash = post.phash
+                    if on_progress:
+                        on_progress(i + 1, total, VerificationResult(
+                            success=True, change_level='major',
+                            matches_expected=True,
+                            detail="Dialogue géré visuellement après raccourci"
+                        ))
+                    continue
+                else:
+                    # Invariant : aucune étape suivante ne doit s'exécuter tant que
+                    # la cascade déclenchée par le raccourci n'est pas pleinement résolue.
+                    # Cas typique : Ctrl+S → "Enregistrer sous" non géré → on ABORT plutôt
+                    # que de cliquer sur des coordonnées potentiellement obsolètes.
+                    msg = (
+                        f"Étape {i+1}: raccourci '{decision.value}' — cascade post-raccourci "
+                        f"non résolue (dialogue absent ou bloqué). Workflow stoppé pour éviter "
+                        f"un clic dans un contexte incohérent."
+                    )
+                    print(f"❌ [ORA/post-shortcut] {msg}")
+                    logger.warning(f"🆘 [ORA] {msg}")
+                    if on_progress:
+                        on_progress(i + 1, total, VerificationResult(
+                            success=False, change_level='none',
+                            matches_expected=False,
+                            detail="Cascade post-raccourci non résolue"
+                        ))
+                    return LoopResult(
+                        success=False, steps_completed=i, total_steps=total,
+                        reason=msg,
+                    )
+
             # Petit délai pour laisser l'écran se stabiliser
             time.sleep(0.3)
 
             # --- 4. Observer l'état post-action ---
             post = self.observe()
+            # Stocker le pHash post-action pour le réflexe check du step suivant
+            self._last_post_phash = post.phash
+
+            # --- 4b. Vérification titre OCR (non-bloquante, ~120ms) ---
+            _action_type = step.get('action_type', '')
+            if _action_type in ('double_click_anchor', 'click_anchor') and pre.screenshot and post.screenshot:
+                try:
+                    from core.grounding.title_verifier import TitleVerifier
+                    _tv = TitleVerifier()
+                    _tv_result = _tv.verify_action(pre.screenshot, post.screenshot, _action_type)
+                    if not _tv_result['success']:
+                        print(f"⚠️ [ORA/titre] {_tv_result['reason']} → retry")
+                        # Retry : recliquer
+                        time.sleep(0.5)
+                        self.act(decision, step)
+                        time.sleep(0.3)
+                        post = self.observe()
+                        self._last_post_phash = post.phash
+                    elif _tv_result['changed']:
+                        print(f"✅ [ORA/titre] '{_tv_result['title_after'][:40]}'")
+                except Exception as _tv_err:
+                    print(f"⚠️ [ORA/titre] Erreur: {_tv_err}")
 
             # --- 5. Vérifier ---
             verification = self.verify(pre, post, decision)
@@ -1345,10 +1465,112 @@ Règles:
     # Méthodes privées — actions
     # ═══════════════════════════════════════════════════════════
 
+    def _handle_post_shortcut(self, pre_obs: 'Observation') -> bool:
+        """Après un raccourci clavier, résoudre la cascade de dialogues réflexes.
+
+        Pilotage par DialogHandler (OCR direct), PAS par pHash. Raison :
+        un dialog modal qui s'ouvre dans une VM ne change quasiment pas le
+        pHash global de l'écran hôte (signature 8x8 sur 1920x1080 — un dialog
+        de 800x500 couvre ~3 pixels pHash, distance Hamming souvent < 3).
+        On poll donc directement DialogHandler.handle_if_dialog().
+
+        Returns:
+            True si au moins un dialog connu a été détecté + géré et qu'aucun
+            autre dialog n'apparaît dans la fenêtre de stabilité finale.
+            False si aucun dialog connu n'apparaît dans la fenêtre d'attente
+            initiale (le workflow doit ABORT — état incohérent).
+        """
+        from core.grounding.dialog_handler import DialogHandler
+
+        # Fenêtre d'attente du PREMIER dialog après le raccourci. Win11/QEMU :
+        # Ctrl+Shift+S → "Enregistrer sous" apparaît en <2s typiquement.
+        first_dialog_timeout = 8.0
+        # Budget total pour résoudre toute la cascade (InfiGUI ~15s/dialog).
+        total_timeout = 60.0
+        # Fenêtre de stabilité après le dernier dialog géré : si rien d'autre
+        # n'apparaît pendant cette durée, la cascade est considérée terminée.
+        # Doit couvrir l'apparition du popup modal suivant (post_click_wait + marge).
+        stable_window = 3.0
+        # Délai post-clic avant de tester le dialog suivant.
+        post_click_wait = 1.5
+        # Cadence de polling OCR (EasyOCR full-screen ~500ms/poll).
+        poll_interval = 0.5
+        # Garde-fou anti-boucle infinie.
+        max_dialog_iterations = 5
+
+        t_start = time.time()
+        dh = DialogHandler()
+        dialogs_handled = 0
+
+        def _elapsed() -> float:
+            return time.time() - t_start
+
+        def _poll_dialog(deadline: float) -> Optional[Dict[str, Any]]:
+            """Poll DialogHandler jusqu'à détection d'un dialog connu OU deadline.
+
+            Retourne le dict result si un dialog connu a été géré (cliqué),
+            None si la deadline est atteinte sans match. Si DialogHandler
+            détecte ET clique avec succès, le clic InfiGUI peut excéder la
+            deadline mais on retourne quand même le résultat (action déjà
+            engagée — on ne va pas l'annuler).
+            """
+            while time.time() < deadline:
+                obs = self.observe()
+                try:
+                    result = dh.handle_if_dialog(obs.screenshot)
+                except Exception as e:
+                    print(f"⚠️ [ORA/post-shortcut] Erreur dialog handler: {e}")
+                    return None
+                if result.get('handled'):
+                    return result
+                sleep_left = deadline - time.time()
+                if sleep_left > 0:
+                    time.sleep(min(poll_interval, sleep_left))
+            return None
+
+        # --- Étape 1 : attendre le PREMIER dialog ---
+        first_deadline = t_start + min(total_timeout, first_dialog_timeout)
+        result = _poll_dialog(first_deadline)
+        if result is None:
+            print(f"⏳ [ORA/post-shortcut] Aucun dialog connu détecté après "
+                  f"{_elapsed():.1f}s (fenêtre={first_dialog_timeout}s) — "
+                  f"raccourci sans effet attendu")
+            return False
+
+        dialogs_handled = 1
+        print(f"✅ [ORA/post-shortcut] Dialog #1 géré: {result.get('action')} "
+              f"({_elapsed():.1f}s)")
+        time.sleep(post_click_wait)
+
+        # --- Étape 2 : cascade — chaque dialog suivant doit apparaître dans stable_window ---
+        for iteration in range(1, max_dialog_iterations):
+            if _elapsed() >= total_timeout:
+                print(f"⏳ [ORA/post-shortcut] Timeout cascade ({total_timeout:.0f}s, "
+                      f"{dialogs_handled} dialog(s) géré(s))")
+                return True  # au moins un dialog traité → considéré OK
+
+            next_deadline = min(time.time() + stable_window, t_start + total_timeout)
+            result = _poll_dialog(next_deadline)
+            if result is None:
+                # Pas de nouveau dialog dans stable_window → cascade terminée
+                print(f"✅ [ORA/post-shortcut] Cascade résolue "
+                      f"({dialogs_handled} dialog(s), {_elapsed():.1f}s)")
+                return True
+
+            dialogs_handled += 1
+            print(f"✅ [ORA/post-shortcut] Dialog #{dialogs_handled} géré: "
+                  f"{result.get('action')} ({_elapsed():.1f}s)")
+            time.sleep(post_click_wait)
+
+        print(f"⚠️ [ORA/post-shortcut] Trop d'itérations cascade "
+              f"({max_dialog_iterations}) — cascade malformée, on s'arrête là")
+        return dialogs_handled > 0
+
     def _act_click(self, decision: Decision, step_params: dict) -> bool:
         """Exécute un clic (simple, double, droit, hover, focus).
 
-        Pipeline : template matching → find_element_on_screen (OCR → UI-TARS → VLM).
+        Pipeline FAST→SMART→THINK (si activé) ou ancien pipeline en fallback.
+        Activé par la variable d'environnement RPA_USE_FAST_PIPELINE=1.
         """
         if not PYAUTOGUI_AVAILABLE:
             logger.error("pyautogui non disponible")
@@ -1357,29 +1579,23 @@ Règles:
         anchor = step_params.get('visual_anchor', {})
         screenshot_b64 = anchor.get('screenshot')
         bbox = anchor.get('bounding_box', {})
-        target_text = anchor.get('target_text', '') or decision.target
+        # Utiliser le target nettoyé par reason_workflow_step (pas relire le garbage de l'ancre)
+        target_text = decision.target
         target_desc = anchor.get('description', '')
 
+        print(f"🎯 [ORA/_act_click] target='{target_text}', desc='{target_desc[:40]}', bbox={bbox.get('x','?')},{bbox.get('y','?')}")
+
         x, y = None, None
         method_used = ''
+        # Score et position du template-first (réutilisés en fallback intermédiaire)
+        template_score = 0.0
+        template_xy: Optional[tuple] = None
 
-        # --- Méthode 1 : UI-TARS grounding (~3s, 94% précision) ---
-        # Le plus fiable : on dit "click on X" et UI-TARS trouve les coordonnées
-        if target_text or target_desc:
-            try:
-                from core.execution.input_handler import _grounding_ui_tars
-                click_label = target_desc or target_text
-                print(f"🎯 [ORA/UI-TARS] Recherche: '{click_label}'")
-                result = _grounding_ui_tars(target_text, target_desc)
-                if result:
-                    x, y = result['x'], result['y']
-                    method_used = 'ui_tars'
-                    print(f"✅ [ORA/UI-TARS] Trouvé à ({x}, {y})")
-            except Exception as e:
-                logger.debug(f"⚠️ [ORA/UI-TARS] Erreur: {e}")
-
-        # --- Méthode 2 : Template matching (~80ms) ---
-        if x is None and screenshot_b64 and CV2_AVAILABLE and PIL_AVAILABLE and MSS_AVAILABLE:
+        # --- AVANT-POSTE : template matching cv2 sur le crop d'ancre ---
+        # Si l'UI n'a pas changé (cas dominant en replay), un match pixel-perfect
+        # nous donne le clic en ~50ms sans toucher au GPU. On ne déclenche le
+        # pipeline VLM que si le score est insuffisant.
+        if screenshot_b64 and CV2_AVAILABLE and PIL_AVAILABLE and MSS_AVAILABLE:
             try:
                 import io as _io
                 with mss_lib.mss() as sct:
@@ -1399,15 +1615,70 @@ Règles:
                     result_tm = cv2.matchTemplate(screen_cv, anchor_cv, cv2.TM_CCOEFF_NORMED)
                     _, max_val, _, max_loc = cv2.minMaxLoc(result_tm)
                     elapsed_ms = (time.time() - t0) * 1000
-                    print(f"⚡ [ORA/template] score={max_val:.3f} pos={max_loc} ({elapsed_ms:.0f}ms)")
-                    if max_val > 0.75:
-                        x = max_loc[0] + anchor_cv.shape[1] // 2
-                        y = max_loc[1] + anchor_cv.shape[0] // 2
-                        method_used = 'template'
+                    template_score = float(max_val)
+                    template_xy = (
+                        max_loc[0] + anchor_cv.shape[1] // 2,
+                        max_loc[1] + anchor_cv.shape[0] // 2,
+                    )
+                    print(f"⚡ [ORA/template-first] score={template_score:.3f} pos={max_loc} ({elapsed_ms:.0f}ms)")
+                    # Seuil élevé pour le mode "direct" : on veut être quasi-certain
+                    # que c'est le même élément, pixel-perfect, avant de zapper le VLM.
+                    if template_score >= 0.95:
+                        x, y = template_xy
+                        method_used = 'template_direct'
+                        print(f"✅ [ORA/template-first] Match direct → ({x}, {y}), skip pipeline")
             except Exception as e:
-                logger.debug(f"⚠️ [ORA/template] Erreur: {e}")
+                print(f"⚠️ [ORA/template-first] Erreur: {e}")
+
+        # --- Pipeline FAST→SMART→THINK (escalade si template-first n'a pas tranché) ---
+        _use_fast = os.environ.get('RPA_USE_FAST_PIPELINE', '1') == '1'
+
+        if x is None and _use_fast and (target_text or target_desc or screenshot_b64):
+            print(f"🎯 [ORA/_act_click] RPA_USE_FAST_PIPELINE={_use_fast}, has_target={bool(target_text or target_desc)}, template_score={template_score:.3f}")
+            try:
+                from core.grounding.fast_pipeline import FastSmartThinkPipeline
+                from core.grounding.target import GroundingTarget
+
+                _pipeline = FastSmartThinkPipeline.get_instance()
+
+                # Capture unique de l'écran
+                _screen_pil = None
+                if MSS_AVAILABLE and PIL_AVAILABLE:
+                    with mss_lib.mss() as _sct:
+                        _mon = _sct.monitors[0]
+                        _grab = _sct.grab(_mon)
+                        _screen_pil = Image.frombytes('RGB', _grab.size, _grab.bgra, 'raw', 'BGRX')
+
+                _target = GroundingTarget(
+                    text=target_text,
+                    description=target_desc,
+                    template_b64=screenshot_b64 or "",
+                    original_bbox=bbox if bbox else None,
+                )
+
+                _result = _pipeline.locate(
+                    _target,
+                    screenshot_pil=_screen_pil,
+                    window_title=getattr(self, '_last_window_title', ''),
+                )
+
+                if _result:
+                    x, y = _result.x, _result.y
+                    method_used = _result.method
+                    print(f"🎯 [ORA/pipeline] ({x}, {y}) via {method_used} "
+                          f"conf={_result.confidence:.3f} ({_result.time_ms:.0f}ms)")
+
+            except Exception as e:
+                print(f"⚠️ [ORA/pipeline] Erreur: {e}")
+
+        # --- Fallback : on réutilise le score template-first si pertinent ---
+        # Si le pipeline VLM a échoué mais que le template-first avait un score
+        # intermédiaire (0.75-0.95), on accepte ce match comme secours.
+        if x is None and template_xy is not None and template_score >= 0.75:
+            x, y = template_xy
+            method_used = 'template_fallback'
+            print(f"⚡ [ORA/template-fallback] Réutilisation score={template_score:.3f} → ({x}, {y})")
 
-        # --- Méthode 3 : OCR texte (~1s) ---
         if x is None and target_text:
             try:
                 from core.execution.input_handler import _grounding_ocr
@@ -1417,22 +1688,21 @@ Règles:
                     method_used = 'ocr'
                     print(f"🔍 [ORA/OCR] Trouvé à ({x}, {y})")
             except Exception as e:
-                logger.debug(f"⚠️ [ORA/OCR] Erreur: {e}")
+                print(f"⚠️ [ORA/OCR] Erreur: {e}")
 
-        # --- Exécuter le clic ---
+        # --- Dernier recours : coordonnées statiques ---
         if x is None:
-            # Dernier recours : coordonnées statiques de l'ancre
             if bbox and bbox.get('width') and bbox.get('height'):
                 x = int(bbox.get('x', 0) + bbox.get('width', 0) / 2)
                 y = int(bbox.get('y', 0) + bbox.get('height', 0) / 2)
                 method_used = 'static_fallback'
-                logger.warning(f"⚠️ [ORA/click] Fallback coordonnées statiques: ({x}, {y})")
+                print(f"⚠️ [ORA/click] Fallback coordonnées statiques: ({x}, {y})")
             else:
-                logger.error(f"❌ [ORA/click] Impossible de localiser '{target_text}' — aucune méthode n'a fonctionné")
+                print(f"❌ [ORA/click] Impossible de localiser '{target_text}'")
                 return False
 
-        # --- Vérification pré-action : est-ce le bon élément ? ---
-        if target_text and method_used not in ('template',) and MSS_AVAILABLE and PIL_AVAILABLE:
+        # --- Pas de pre-check VLM (le pipeline FAST→SMART→THINK a déjà validé) ---
+        if False:
             try:
                 pre_check = self._verify_pre_click(x, y, target_text, target_desc)
                 if not pre_check:

core/grounding/__init__.py

@@ -0,0 +1,20 @@
+# core/grounding — Module de localisation d'éléments UI
+#
+# Centralise les méthodes de grounding visuel : template matching,
+# OCR, VLM, etc. Chaque méthode produit un GroundingResult uniforme.
+#
+# Le serveur de grounding (server.py) tourne dans un process séparé
+# sur le port 8200. Le client HTTP (UITarsGrounder) l'appelle via HTTP.
+# Le pipeline (GroundingPipeline) orchestre template → OCR → UI-TARS → static.
+
+from core.grounding.template_matcher import TemplateMatcher, MatchResult
+from core.grounding.target import GroundingTarget, GroundingResult
+from core.grounding.ui_tars_grounder import UITarsGrounder
+from core.grounding.pipeline import GroundingPipeline
+
+__all__ = [
+    'TemplateMatcher', 'MatchResult',
+    'GroundingTarget', 'GroundingResult',
+    'UITarsGrounder',
+    'GroundingPipeline',
+]

core/grounding/bbox_parser.py

@@ -0,0 +1,120 @@
+"""
+Parser des réponses VLM de grounding (bbox_2d, x/y, x_pct/y_pct, array brut).
+
+Centralise le parsing des coordonnées retournées par les modèles VLM
+(Qwen-VL via Ollama, vLLM ou Transformers direct) vers une représentation
+normalisée (x_pct, y_pct).
+
+Module pur : regex + arithmétique, sans dépendance lourde.
+
+Convention des diviseurs (DETTE-006 ouverte) : actuellement les call sites
+passent les dimensions de l'image envoyée au VLM (PRE-resize). C'est la
+source du bug d'échelle pixel grounding — sera corrigé au commit 3/5 du
+fix DETTE-006 en passant les dimensions POST-smart_resize.
+"""
+
+import re
+
+
+_ALL_FORMATS = frozenset({"bbox_2d", "xy_json", "xy_pct", "raw_array"})
+
+
+def parse_bbox_to_norm(
+    content: str,
+    divisor_w: int | float,
+    divisor_h: int | float,
+    *,
+    formats: set[str] | None = None,
+) -> tuple[float | None, float | None]:
+    """Parse une réponse VLM en (x_pct, y_pct) normalisés.
+
+    Cascade des formats (premier qui matche gagne) :
+    1. ``"bbox_2d"`` : ``{"bbox_2d": [x, y]}`` ou ``[x1, y1, x2, y2]``
+    2. ``"xy_json"`` : ``{"x": ..., "y": ...}`` (heuristique x>1 → pixels)
+    3. ``"xy_pct"`` : ``{"x_pct": ..., "y_pct": ...}``
+    4. ``"raw_array"`` : array brut ``[...]`` 2 ou 4 coords
+
+    Args:
+        content: réponse texte du VLM.
+        divisor_w, divisor_h: dimensions normalisant les pixels en pct.
+        formats: ensemble des formats à essayer. Si ``None`` (défaut),
+            cascade complète des 4. Pour restreindre, passer un sous-ensemble
+            de ``{"bbox_2d", "xy_json", "xy_pct", "raw_array"}``.
+
+    Returns:
+        ``(x_pct, y_pct)`` ou ``(None, None)`` si aucun format ne matche.
+    """
+    enabled = _ALL_FORMATS if formats is None else formats
+    x_pct, y_pct = None, None
+
+    # Format 1 : bbox_2d en pixels [x, y] ou [x1, y1, x2, y2]
+    if "bbox_2d" in enabled:
+        bbox_match = re.search(r'"bbox_2d"\s*:\s*\[([^\]]+)\]', content)
+        if bbox_match:
+            coords = [float(v.strip()) for v in bbox_match.group(1).split(",")]
+            if len(coords) == 2:
+                x_pct = coords[0] / divisor_w
+                y_pct = coords[1] / divisor_h
+            elif len(coords) >= 4:
+                x_pct = (coords[0] + coords[2]) / 2 / divisor_w
+                y_pct = (coords[1] + coords[3]) / 2 / divisor_h
+
+    # Format 2 : JSON {"x": 0.XX, "y": 0.YY}
+    if x_pct is None and "xy_json" in enabled:
+        json_match = re.search(r'"x"\s*:\s*([\d.]+).*?"y"\s*:\s*([\d.]+)', content)
+        if json_match:
+            x_val, y_val = float(json_match.group(1)), float(json_match.group(2))
+            if x_val > 1:
+                x_pct = x_val / divisor_w
+                y_pct = y_val / divisor_h
+            else:
+                x_pct = x_val
+                y_pct = y_val
+
+    # Format 3 : JSON {"x_pct": 0.XX, "y_pct": 0.YY}
+    if x_pct is None and "xy_pct" in enabled:
+        pct_match = re.search(r'"x_pct"\s*:\s*([\d.]+).*?"y_pct"\s*:\s*([\d.]+)', content)
+        if pct_match:
+            x_pct = float(pct_match.group(1))
+            y_pct = float(pct_match.group(2))
+
+    # Format 4 : array brut [x1, y1, x2, y2] ou [x, y]
+    if x_pct is None and "raw_array" in enabled:
+        arr_match = re.search(
+            r'\[[\s]*([\d.]+)\s*,\s*([\d.]+)(?:\s*,\s*([\d.]+)\s*,\s*([\d.]+))?\s*\]',
+            content,
+        )
+        if arr_match:
+            vals = [float(v) for v in arr_match.groups() if v is not None]
+            if len(vals) >= 4:
+                x_pct = (vals[0] + vals[2]) / 2 / divisor_w
+                y_pct = (vals[1] + vals[3]) / 2 / divisor_h
+            elif len(vals) == 2:
+                x_pct = vals[0] / divisor_w
+                y_pct = vals[1] / divisor_h
+
+    return x_pct, y_pct
+
+
+def parse_bbox_to_norm_validated(
+    content: str,
+    divisor_w: int | float,
+    divisor_h: int | float,
+    *,
+    formats: set[str] | None = None,
+) -> tuple[float | None, float | None]:
+    """Idem :func:`parse_bbox_to_norm` + validation domaine [0, 1].
+
+    Retourne ``(None, None)`` si le résultat parsé est hors ``[0, 1]`` sur
+    l'un des deux axes — comportement de ``_locate_popup_button``
+    (cf. resolve_engine.py:2569-2580).
+
+    Implémentation : appelle :func:`parse_bbox_to_norm` puis valide. Pas
+    de duplication de la logique de parsing.
+    """
+    x_pct, y_pct = parse_bbox_to_norm(content, divisor_w, divisor_h, formats=formats)
+    if x_pct is None or y_pct is None:
+        return None, None
+    if not (0.0 <= x_pct <= 1.0 and 0.0 <= y_pct <= 1.0):
+        return None, None
+    return x_pct, y_pct

core/grounding/dialog_handler.py

@@ -0,0 +1,256 @@
+"""
+core/grounding/dialog_handler.py — Gestion intelligente des dialogues
+
+Quand un dialogue inattendu apparaît (pHash change après une action) :
+1. Lire le titre de la fenêtre (EasyOCR crop 45px, ~130ms)
+2. Si titre connu (Enregistrer sous, Confirmer, etc.) → action connue
+3. Demander à InfiGUI de cliquer sur le bon bouton (~3s)
+4. Vérifier que le dialogue a disparu (pHash)
+
+Pas de patterns prédéfinis pour les boutons. InfiGUI comprend
+visuellement le dialogue et clique au bon endroit.
+
+Utilisation :
+    from core.grounding.dialog_handler import DialogHandler
+
+    handler = DialogHandler()
+    result = handler.handle_if_dialog(screenshot_pil)
+    if result['handled']:
+        print(f"Dialogue '{result['title']}' géré → {result['action']}")
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Dict, Optional
+
+
+# Titres connus → quelle action demander à InfiGUI.
+#
+# IMPORTANT — ordre du dict = priorité de matching.
+# L'OCR est full-screen et capte souvent le texte du dialog parent ET du popup
+# modal qui apparaît par-dessus (ex: "Enregistrer sous" reste visible derrière
+# "Confirmer l'enregistrement"). Les popups modaux DOIVENT matcher avant les
+# fenêtres principales, sinon Léa clique sur le bouton du parent qui n'a pas
+# le focus.
+KNOWN_DIALOGS = {
+    # ── Popups modaux de confirmation (priorité HAUTE) ──────────────────
+    "voulez-vous le remplacer": {"target": "Oui", "description": "Clique sur Oui pour confirmer le remplacement du fichier"},
+    "do you want to replace": {"target": "Yes", "description": "Click Yes to confirm file replacement"},
+    "existe déjà": {"target": "Oui", "description": "Clique sur Oui, le fichier existe déjà et doit être remplacé"},
+    "already exists": {"target": "Yes", "description": "Click Yes, the file already exists"},
+    "remplacer": {"target": "Oui", "description": "Clique sur le bouton Oui pour confirmer le remplacement du fichier"},
+    "replace": {"target": "Yes", "description": "Click Yes to confirm file replacement"},
+    "écraser": {"target": "Oui", "description": "Clique sur Oui pour écraser le fichier"},
+    "overwrite": {"target": "Yes", "description": "Click Yes to overwrite"},
+    "confirmer l'enregistrement": {"target": "Oui", "description": "Clique sur Oui dans le popup de confirmation d'enregistrement"},
+    "confirmer": {"target": "Oui", "description": "Clique sur le bouton Oui dans le dialogue de confirmation"},
+    # ── Avertissements/erreurs (priorité haute, 1 seul bouton OK) ───────
+    "erreur": {"target": "OK", "description": "Clique sur OK pour fermer le message d'erreur"},
+    "error": {"target": "OK", "description": "Click OK to close the error message"},
+    "avertissement": {"target": "OK", "description": "Clique sur OK pour fermer l'avertissement"},
+    "warning": {"target": "OK", "description": "Click OK to close the warning"},
+    # ── Dialogs principaux de sauvegarde (priorité BASSE — fenêtres parents) ─
+    "voulez-vous enregistrer": {"target": "Enregistrer", "description": "Clique sur Enregistrer pour sauvegarder les modifications"},
+    "do you want to save": {"target": "Save", "description": "Click Save to save changes"},
+    "enregistrer sous": {"target": "Enregistrer", "description": "Clique sur le bouton Enregistrer dans le dialogue Enregistrer sous"},
+    "save as": {"target": "Save", "description": "Click the Save button in the Save As dialog"},
+}
+
+
+class DialogHandler:
+    """Gestion intelligente des dialogues via titre + InfiGUI."""
+
+    def __init__(self):
+        self._easyocr_reader = None
+
+    def handle_if_dialog(
+        self,
+        screenshot_pil,
+        previous_title: str = "",
+    ) -> Dict[str, Any]:
+        """Vérifie si l'écran montre un dialogue et le gère.
+
+        Args:
+            screenshot_pil: Screenshot PIL actuel.
+            previous_title: Titre de la fenêtre avant l'action (pour comparaison).
+
+        Returns:
+            Dict avec 'handled' (bool), 'title', 'action', 'position'.
+        """
+        t0 = time.time()
+
+        # 1. Lire le titre de la fenêtre
+        title = self._read_title(screenshot_pil)
+        if not title or len(title) < 3:
+            return {'handled': False, 'title': '', 'reason': 'Titre illisible'}
+
+        print(f"🔍 [Dialog] Titre lu: '{title}'")
+
+        # 2. Chercher si c'est un dialogue connu
+        matched_dialog = None
+        for key, action_info in KNOWN_DIALOGS.items():
+            if key in title.lower():
+                matched_dialog = (key, action_info)
+                break
+
+        if not matched_dialog:
+            # Pas un dialogue connu — le workflow continue normalement
+            return {'handled': False, 'title': title, 'reason': 'Pas un dialogue connu'}
+
+        dialog_key, action_info = matched_dialog
+        target = action_info['target']
+        description = action_info['description']
+
+        print(f"🧠 [Dialog] Dialogue détecté: '{dialog_key}' → clic '{target}'")
+
+        # 3. Demander à InfiGUI de cliquer sur le bouton
+        click_result = self._click_via_infigui(
+            target, description, screenshot_pil
+        )
+
+        dt = (time.time() - t0) * 1000
+
+        if click_result:
+            print(f"✅ [Dialog] Clic '{target}' à ({click_result['x']}, {click_result['y']}) ({dt:.0f}ms)")
+            return {
+                'handled': True,
+                'title': title,
+                'dialog_type': dialog_key,
+                'action': f"click '{target}'",
+                'position': (click_result['x'], click_result['y']),
+                'time_ms': dt,
+            }
+        else:
+            # InfiGUI n'a pas trouvé le bouton — essayer le clic direct via OCR
+            print(f"⚠️ [Dialog] InfiGUI n'a pas trouvé '{target}', essai OCR direct")
+            ocr_result = self._click_via_ocr(target, screenshot_pil)
+            dt = (time.time() - t0) * 1000
+
+            if ocr_result:
+                print(f"✅ [Dialog] OCR clic '{target}' à ({ocr_result[0]}, {ocr_result[1]}) ({dt:.0f}ms)")
+                return {
+                    'handled': True,
+                    'title': title,
+                    'dialog_type': dialog_key,
+                    'action': f"click '{target}' (OCR)",
+                    'position': ocr_result,
+                    'time_ms': dt,
+                }
+
+            print(f"❌ [Dialog] Impossible de cliquer '{target}' ({dt:.0f}ms)")
+            return {
+                'handled': False,
+                'title': title,
+                'dialog_type': dialog_key,
+                'reason': f"Bouton '{target}' introuvable",
+                'time_ms': dt,
+            }
+
+    # ------------------------------------------------------------------
+    # Lecture titre
+    # ------------------------------------------------------------------
+
+    def _read_title(self, screenshot_pil) -> str:
+        """Lit TOUT le texte visible via EasyOCR full-screen (~500ms).
+
+        En VM QEMU, la barre de titre Windows est à l'intérieur du framebuffer,
+        pas en haut absolu de l'écran. On fait l'OCR full-screen et on cherche
+        les mots-clés des dialogues connus dans le texte complet.
+        """
+        try:
+            import numpy as np
+
+            reader = self._get_easyocr()
+            if reader is None:
+                return ""
+
+            results = reader.readtext(np.array(screenshot_pil))
+            full_text = ' '.join(r[1] for r in results if r[1].strip())
+            return full_text
+
+        except Exception as e:
+            print(f"⚠️ [Dialog] Erreur lecture écran: {e}")
+            return ""
+
+    # ------------------------------------------------------------------
+    # Clic via InfiGUI (serveur grounding)
+    # ------------------------------------------------------------------
+
+    def _click_via_infigui(
+        self, target: str, description: str, screenshot_pil
+    ) -> Optional[Dict]:
+        """Demande à InfiGUI (subprocess one-shot) de localiser et cliquer sur le bouton."""
+        try:
+            from core.grounding.ui_tars_grounder import UITarsGrounder
+
+            grounder = UITarsGrounder.get_instance()
+            result = grounder.ground(
+                target_text=target,
+                target_description=description,
+                screen_pil=screenshot_pil,
+            )
+
+            if result and result.x is not None:
+                import pyautogui
+                pyautogui.click(result.x, result.y)
+                return {'x': result.x, 'y': result.y}
+
+            return None
+
+        except Exception as e:
+            print(f"⚠️ [Dialog/InfiGUI] Erreur: {e}")
+            return None
+
+    # ------------------------------------------------------------------
+    # Clic via OCR (fallback rapide)
+    # ------------------------------------------------------------------
+
+    def _click_via_ocr(self, target: str, screenshot_pil) -> Optional[tuple]:
+        """Cherche le bouton par OCR et clique dessus."""
+        try:
+            import numpy as np
+
+            reader = self._get_easyocr()
+            if reader is None:
+                return None
+
+            results = reader.readtext(np.array(screenshot_pil))
+
+            target_lower = target.lower()
+            matches = []
+            for (bbox_pts, text, conf) in results:
+                if target_lower in text.lower() or text.lower() in target_lower:
+                    x = int(sum(p[0] for p in bbox_pts) / 4)
+                    y = int(sum(p[1] for p in bbox_pts) / 4)
+                    matches.append((x, y, text))
+
+            if matches:
+                # Prendre le match le plus bas (boutons = bas du dialogue)
+                best = max(matches, key=lambda m: m[1])
+                import pyautogui
+                pyautogui.click(best[0], best[1])
+                return (best[0], best[1])
+
+            return None
+
+        except Exception as e:
+            print(f"⚠️ [Dialog/OCR] Erreur: {e}")
+            return None
+
+    # ------------------------------------------------------------------
+    # EasyOCR singleton
+    # ------------------------------------------------------------------
+
+    def _get_easyocr(self):
+        if self._easyocr_reader is not None:
+            return self._easyocr_reader
+
+        try:
+            import easyocr
+            self._easyocr_reader = easyocr.Reader(
+                ['fr', 'en'], gpu=True, verbose=False
+            )
+            return self._easyocr_reader
+        except ImportError:
+            return None

core/grounding/element_signature.py

@@ -0,0 +1,239 @@
+"""
+core/grounding/element_signature.py — Signatures d'éléments UI apprises
+
+Chaque élément cliqué avec succès enrichit sa signature :
+- texte OCR, type, position relative, voisins contextuels
+- nombre de succès/échecs, confiance moyenne
+- variantes observées (résolutions, positions)
+
+Les signatures sont stockées en SQLite pour un lookup rapide.
+Pattern identique à TargetMemoryStore (validé en prod).
+
+Utilisation :
+    from core.grounding.element_signature import SignatureStore
+
+    store = SignatureStore()
+
+    # Après un clic réussi
+    store.record_success("btn_valider", "notepad_1920x1080", element, confidence=0.92)
+
+    # Au replay
+    sig = store.lookup("btn_valider", "notepad_1920x1080")
+    if sig:
+        print(f"Signature connue : {sig['text']} position={sig['relative_position']}")
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sqlite3
+import threading
+import time
+from typing import Any, Dict, List, Optional
+
+from core.grounding.fast_types import DetectedUIElement
+
+# Chemin par défaut de la DB
+_DEFAULT_DB = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.dirname(__file__))),
+    "data", "learning", "element_signatures.db",
+)
+
+
+class SignatureStore:
+    """Stockage SQLite des signatures d'éléments UI appris."""
+
+    def __init__(self, db_path: str = _DEFAULT_DB):
+        self.db_path = db_path
+        self._lock = threading.Lock()
+        self._ensure_db()
+
+    def _ensure_db(self):
+        """Crée la DB et la table si nécessaire."""
+        os.makedirs(os.path.dirname(self.db_path), exist_ok=True)
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS signatures (
+                    target_key TEXT NOT NULL,
+                    screen_context TEXT NOT NULL,
+                    text TEXT DEFAULT '',
+                    element_type TEXT DEFAULT 'element',
+                    relative_position TEXT DEFAULT '',
+                    neighbors TEXT DEFAULT '[]',
+                    success_count INTEGER DEFAULT 0,
+                    fail_count INTEGER DEFAULT 0,
+                    avg_confidence REAL DEFAULT 0.0,
+                    last_seen TEXT DEFAULT '',
+                    variants TEXT DEFAULT '[]',
+                    PRIMARY KEY (target_key, screen_context)
+                )
+            """)
+            conn.execute("""
+                CREATE INDEX IF NOT EXISTS idx_target_key
+                ON signatures(target_key)
+            """)
+
+    # ------------------------------------------------------------------
+    # Lookup
+    # ------------------------------------------------------------------
+
+    def lookup(self, target_key: str, screen_context: str = "") -> Optional[Dict[str, Any]]:
+        """Cherche une signature connue.
+
+        Args:
+            target_key: Clé unique de la cible (hash du texte + description).
+            screen_context: Contexte d'écran (hash titre fenêtre + résolution).
+
+        Returns:
+            Dict avec les champs de la signature, ou None.
+        """
+        with sqlite3.connect(self.db_path) as conn:
+            conn.row_factory = sqlite3.Row
+            # Chercher avec le contexte exact d'abord
+            row = conn.execute(
+                "SELECT * FROM signatures WHERE target_key = ? AND screen_context = ?",
+                (target_key, screen_context),
+            ).fetchone()
+
+            # Fallback : chercher sans contexte (toutes les variantes)
+            if row is None and screen_context:
+                row = conn.execute(
+                    "SELECT * FROM signatures WHERE target_key = ? ORDER BY success_count DESC LIMIT 1",
+                    (target_key,),
+                ).fetchone()
+
+            if row is None:
+                return None
+
+            return {
+                "target_key": row["target_key"],
+                "screen_context": row["screen_context"],
+                "text": row["text"],
+                "element_type": row["element_type"],
+                "relative_position": row["relative_position"],
+                "neighbors": json.loads(row["neighbors"]),
+                "success_count": row["success_count"],
+                "fail_count": row["fail_count"],
+                "avg_confidence": row["avg_confidence"],
+                "last_seen": row["last_seen"],
+                "variants": json.loads(row["variants"]),
+            }
+
+    # ------------------------------------------------------------------
+    # Enregistrement
+    # ------------------------------------------------------------------
+
+    def record_success(
+        self,
+        target_key: str,
+        screen_context: str,
+        element: DetectedUIElement,
+        confidence: float,
+    ):
+        """Enregistre un succès — crée ou enrichit la signature."""
+        with self._lock:
+            existing = self.lookup(target_key, screen_context)
+            now = time.strftime("%Y-%m-%dT%H:%M:%S")
+
+            if existing:
+                # Enrichir la signature existante
+                n = existing["success_count"]
+                new_avg = (existing["avg_confidence"] * n + confidence) / (n + 1)
+
+                # Ajouter la variante si position différente
+                variants = existing["variants"]
+                variant = {
+                    "position": element.relative_position,
+                    "center": list(element.center),
+                    "confidence": confidence,
+                    "timestamp": now,
+                }
+                variants.append(variant)
+                # Garder les 20 dernières variantes max
+                variants = variants[-20:]
+
+                # Mettre à jour les voisins (union)
+                neighbors = list(set(existing["neighbors"] + element.neighbors))[:10]
+
+                with sqlite3.connect(self.db_path) as conn:
+                    conn.execute("""
+                        UPDATE signatures SET
+                            success_count = success_count + 1,
+                            avg_confidence = ?,
+                            last_seen = ?,
+                            neighbors = ?,
+                            variants = ?,
+                            relative_position = ?
+                        WHERE target_key = ? AND screen_context = ?
+                    """, (
+                        new_avg, now,
+                        json.dumps(neighbors),
+                        json.dumps(variants),
+                        element.relative_position,
+                        target_key, screen_context,
+                    ))
+            else:
+                # Créer une nouvelle signature
+                with sqlite3.connect(self.db_path) as conn:
+                    conn.execute("""
+                        INSERT INTO signatures
+                        (target_key, screen_context, text, element_type, relative_position,
+                         neighbors, success_count, fail_count, avg_confidence, last_seen, variants)
+                        VALUES (?, ?, ?, ?, ?, ?, 1, 0, ?, ?, ?)
+                    """, (
+                        target_key, screen_context,
+                        element.ocr_text,
+                        element.element_type,
+                        element.relative_position,
+                        json.dumps(element.neighbors[:10]),
+                        confidence, now,
+                        json.dumps([{
+                            "position": element.relative_position,
+                            "center": list(element.center),
+                            "confidence": confidence,
+                            "timestamp": now,
+                        }]),
+                    ))
+
+            print(f"📝 [Signature] '{target_key}' {'enrichie' if existing else 'créée'} "
+                  f"(conf={confidence:.2f}, ctx='{screen_context[:30]}')")
+
+    def record_failure(self, target_key: str, screen_context: str):
+        """Enregistre un échec pour une signature."""
+        with self._lock:
+            with sqlite3.connect(self.db_path) as conn:
+                conn.execute("""
+                    UPDATE signatures SET fail_count = fail_count + 1, last_seen = ?
+                    WHERE target_key = ? AND screen_context = ?
+                """, (time.strftime("%Y-%m-%dT%H:%M:%S"), target_key, screen_context))
+
+    # ------------------------------------------------------------------
+    # Utilitaires
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def make_target_key(text: str, description: str = "") -> str:
+        """Génère une clé unique pour une cible."""
+        raw = f"{text.lower().strip()}|{description.lower().strip()}"
+        return hashlib.md5(raw.encode()).hexdigest()[:16]
+
+    @staticmethod
+    def make_screen_context(window_title: str, resolution: tuple = (0, 0)) -> str:
+        """Génère un contexte d'écran."""
+        raw = f"{window_title.lower().strip()}|{resolution[0]}x{resolution[1]}"
+        return hashlib.md5(raw.encode()).hexdigest()[:12]
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Statistiques de la base de signatures."""
+        with sqlite3.connect(self.db_path) as conn:
+            total = conn.execute("SELECT COUNT(*) FROM signatures").fetchone()[0]
+            reliable = conn.execute(
+                "SELECT COUNT(*) FROM signatures WHERE success_count >= 3 AND fail_count = 0"
+            ).fetchone()[0]
+            return {
+                "total_signatures": total,
+                "reliable": reliable,
+                "db_path": self.db_path,
+            }

core/grounding/fast_detector.py

@@ -0,0 +1,326 @@
+"""
+core/grounding/fast_detector.py — Layer FAST : détection rapide des éléments UI
+
+Capture l'écran, détecte tous les éléments UI via RF-DETR (~120ms),
+enrichit chaque élément avec le texte OCR et le contexte spatial.
+
+Produit un ScreenSnapshot utilisable par le SmartMatcher.
+
+Utilisation :
+    from core.grounding.fast_detector import FastDetector
+
+    detector = FastDetector()
+    snapshot = detector.detect()
+    print(f"{len(snapshot.elements)} éléments en {snapshot.total_time_ms:.0f}ms")
+"""
+
+from __future__ import annotations
+
+import math
+import time
+from typing import Any, Dict, List, Optional, Tuple
+
+from core.grounding.fast_types import DetectedUIElement, ScreenSnapshot
+
+
+class FastDetector:
+    """Détection rapide de tous les éléments UI visibles sur l'écran.
+
+    Combine RF-DETR (détection bbox) + docTR (OCR) pour produire
+    un ScreenSnapshot enrichi.
+
+    Le modèle RF-DETR est un singleton chargé au premier appel (~1s),
+    puis les appels suivants sont rapides (~120ms).
+    """
+
+    def __init__(self, detection_threshold: float = 0.30):
+        self.detection_threshold = detection_threshold
+        self._last_snapshot: Optional[ScreenSnapshot] = None
+        self._last_phash: str = ""
+
+    def detect(
+        self,
+        screenshot_pil: Optional[Any] = None,
+        phash: str = "",
+        window_title: str = "",
+    ) -> ScreenSnapshot:
+        """Détecte et enrichit tous les éléments UI de l'écran.
+
+        Args:
+            screenshot_pil: Image PIL. Si None, capture via mss.
+            phash: Hash perceptuel pour le cache. Si identique au dernier, réutilise le cache.
+            window_title: Titre de la fenêtre active.
+
+        Returns:
+            ScreenSnapshot avec tous les éléments enrichis.
+        """
+        t0 = time.time()
+
+        # Cache : même écran → même résultat
+        if phash and phash == self._last_phash and self._last_snapshot is not None:
+            print(f"⚡ [FAST] Cache hit (pHash identique)")
+            return self._last_snapshot
+
+        # Capture si pas fourni
+        if screenshot_pil is None:
+            screenshot_pil = self._capture_screen()
+            if screenshot_pil is None:
+                return ScreenSnapshot(elements=[], ocr_words=[], resolution=(0, 0))
+
+        w, h = screenshot_pil.size
+
+        # --- Détection RF-DETR (~120ms) ---
+        t_det = time.time()
+        raw_elements = self._detect_rfdetr(screenshot_pil)
+        detection_ms = (time.time() - t_det) * 1000
+
+        # --- OCR sur les crops des éléments détectés (pas full screen) ---
+        t_ocr = time.time()
+        ocr_words = self._ocr_extract(screenshot_pil)
+        ocr_ms = (time.time() - t_ocr) * 1000
+
+        # --- Enrichissement : attribuer texte + voisins + position ---
+        enriched = self._enrich_elements(raw_elements, ocr_words, w, h)
+
+        total_ms = (time.time() - t0) * 1000
+
+        snapshot = ScreenSnapshot(
+            elements=enriched,
+            ocr_words=ocr_words,
+            resolution=(w, h),
+            window_title=window_title,
+            phash=phash,
+            detection_time_ms=detection_ms,
+            ocr_time_ms=ocr_ms,
+            total_time_ms=total_ms,
+        )
+
+        # Mettre en cache
+        if phash:
+            self._last_phash = phash
+            self._last_snapshot = snapshot
+
+        print(f"⚡ [FAST] {len(enriched)} éléments détectés en {total_ms:.0f}ms "
+              f"(det={detection_ms:.0f}ms, ocr={ocr_ms:.0f}ms)")
+
+        return snapshot
+
+    # ------------------------------------------------------------------
+    # Détection RF-DETR
+    # ------------------------------------------------------------------
+
+    def _detect_rfdetr(self, image) -> List[DetectedUIElement]:
+        """Détecte les éléments via RF-DETR (réutilise le singleton existant)."""
+        try:
+            import sys
+            sys.path.insert(0, 'visual_workflow_builder/backend')
+            from services.ui_detection_service import detect_ui_elements
+
+            result = detect_ui_elements(image, threshold=self.detection_threshold)
+
+            elements = []
+            for e in result.elements:
+                x1 = e.bbox["x1"]
+                y1 = e.bbox["y1"]
+                x2 = e.bbox["x2"]
+                y2 = e.bbox["y2"]
+                elements.append(DetectedUIElement(
+                    id=e.id,
+                    bbox=(x1, y1, x2, y2),
+                    center=(e.center["x"], e.center["y"]),
+                    confidence=e.confidence,
+                ))
+
+            return elements
+
+        except Exception as ex:
+            print(f"⚠️ [FAST/detect] RF-DETR erreur: {ex}")
+            return []
+
+    # ------------------------------------------------------------------
+    # OCR
+    # ------------------------------------------------------------------
+
+    _easyocr_reader = None  # Singleton EasyOCR (chargé une fois)
+
+    def _ocr_extract(self, image) -> List[Dict[str, Any]]:
+        """Extrait les mots visibles via EasyOCR (GPU, ~500ms).
+
+        Fallback sur docTR si EasyOCR non disponible.
+        """
+        try:
+            import numpy as np
+            import easyocr
+
+            # Singleton : charger le reader une seule fois
+            if FastDetector._easyocr_reader is None:
+                print(f"🔍 [FAST/ocr] Chargement EasyOCR (GPU)...")
+                FastDetector._easyocr_reader = easyocr.Reader(
+                    ['fr', 'en'], gpu=True, verbose=False
+                )
+
+            results = FastDetector._easyocr_reader.readtext(np.array(image))
+
+            words = []
+            for (bbox_pts, text, conf) in results:
+                if not text or len(text.strip()) < 1:
+                    continue
+                # bbox_pts = [[x1,y1],[x2,y1],[x2,y2],[x1,y2]]
+                x1 = int(min(p[0] for p in bbox_pts))
+                y1 = int(min(p[1] for p in bbox_pts))
+                x2 = int(max(p[0] for p in bbox_pts))
+                y2 = int(max(p[1] for p in bbox_pts))
+                words.append({
+                    'text': text.strip(),
+                    'bbox': [x1, y1, x2, y2],
+                    'confidence': float(conf),
+                })
+
+            return words
+
+        except ImportError:
+            # Fallback docTR
+            try:
+                import sys
+                sys.path.insert(0, 'visual_workflow_builder/backend')
+                from services.ocr_service import ocr_extract_words
+                return ocr_extract_words(image) or []
+            except Exception:
+                return []
+        except Exception as ex:
+            print(f"⚠️ [FAST/ocr] EasyOCR erreur: {ex}")
+            return []
+
+    # ------------------------------------------------------------------
+    # Enrichissement
+    # ------------------------------------------------------------------
+
+    def _enrich_elements(
+        self,
+        elements: List[DetectedUIElement],
+        ocr_words: List[Dict[str, Any]],
+        screen_w: int,
+        screen_h: int,
+    ) -> List[DetectedUIElement]:
+        """Enrichit chaque élément avec texte OCR, voisins et position relative."""
+
+        for elem in elements:
+            # 1. Attribuer le texte OCR par intersection bbox
+            elem.ocr_text = self._assign_ocr_text(elem, ocr_words)
+
+            # 2. Position relative dans l'écran (grille 3x3)
+            elem.relative_position = self._compute_relative_position(
+                elem.center, screen_w, screen_h
+            )
+
+            # 3. Classifier le type d'élément (heuristique taille + ratio)
+            elem.element_type = self._classify_element_type(elem)
+
+        # 4. Calculer les voisins (texte des éléments proches)
+        for elem in elements:
+            elem.neighbors = self._find_neighbors(elem, elements)
+
+        return elements
+
+    def _assign_ocr_text(
+        self,
+        elem: DetectedUIElement,
+        ocr_words: List[Dict[str, Any]],
+    ) -> str:
+        """Attribue le texte OCR à un élément par intersection géométrique."""
+        x1, y1, x2, y2 = elem.bbox
+        # Élargir la bbox de 20% pour capturer le texte autour
+        margin_x = int((x2 - x1) * 0.2)
+        margin_y = int((y2 - y1) * 0.2)
+        ex1, ey1 = x1 - margin_x, y1 - margin_y
+        ex2, ey2 = x2 + margin_x, y2 + margin_y
+
+        texts = []
+        for word in ocr_words:
+            wb = word.get('bbox', [0, 0, 0, 0])
+            if len(wb) < 4:
+                continue
+            wx1, wy1, wx2, wy2 = wb[0], wb[1], wb[2], wb[3]
+            # Intersection ?
+            if wx1 < ex2 and wx2 > ex1 and wy1 < ey2 and wy2 > ey1:
+                text = word.get('text', '').strip()
+                if text and len(text) > 1:
+                    texts.append(text)
+
+        return ' '.join(texts)
+
+    @staticmethod
+    def _compute_relative_position(
+        center: Tuple[int, int],
+        screen_w: int,
+        screen_h: int,
+    ) -> str:
+        """Calcule la position relative dans une grille 3x3."""
+        cx, cy = center
+        col = "left" if cx < screen_w / 3 else ("right" if cx > 2 * screen_w / 3 else "center")
+        row = "top" if cy < screen_h / 3 else ("bottom" if cy > 2 * screen_h / 3 else "middle")
+        return f"{row}_{col}"
+
+    @staticmethod
+    def _classify_element_type(elem: DetectedUIElement) -> str:
+        """Classifie le type d'élément par heuristique taille/ratio."""
+        w, h = elem.width, elem.height
+        if w == 0 or h == 0:
+            return "element"
+        ratio = w / h
+        area = w * h
+
+        # Petit carré → icône
+        if area < 5000 and 0.5 < ratio < 2.0:
+            return "icon"
+        # Large et fin → bouton ou champ
+        if ratio > 3.0 and h < 60:
+            return "input"
+        if ratio > 2.0 and h < 50:
+            return "button"
+        # Grand bloc → zone de contenu
+        if area > 50000:
+            return "container"
+
+        return "element"
+
+    @staticmethod
+    def _find_neighbors(
+        elem: DetectedUIElement,
+        all_elements: List[DetectedUIElement],
+        max_neighbors: int = 5,
+    ) -> List[str]:
+        """Trouve les textes OCR des éléments proches (rayon 1.5x diagonale)."""
+        diag = math.sqrt(elem.width**2 + elem.height**2)
+        radius = max(diag * 1.5, 100)  # minimum 100px
+
+        neighbors = []
+        for other in all_elements:
+            if other.id == elem.id or not other.ocr_text:
+                continue
+            dx = other.center[0] - elem.center[0]
+            dy = other.center[1] - elem.center[1]
+            dist = math.sqrt(dx**2 + dy**2)
+            if dist < radius:
+                neighbors.append(other.ocr_text)
+
+        return neighbors[:max_neighbors]
+
+    # ------------------------------------------------------------------
+    # Capture écran
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _capture_screen():
+        """Capture l'écran via mss."""
+        try:
+            import mss
+            from PIL import Image
+
+            with mss.mss() as sct:
+                mon = sct.monitors[0]
+                grab = sct.grab(mon)
+                return Image.frombytes('RGB', grab.size, grab.bgra, 'raw', 'BGRX')
+        except Exception as ex:
+            print(f"⚠️ [FAST/capture] Erreur: {ex}")
+            return None

core/grounding/fast_pipeline.py

@@ -0,0 +1,216 @@
+"""
+core/grounding/fast_pipeline.py — Pipeline FAST → SMART → THINK
+
+Orchestrateur central : détecte les éléments (FAST), matche avec la cible (SMART),
+et demande au VLM de trancher si le score est trop bas (THINK).
+
+Seuils de confiance :
+  ≥ 0.90  →  action directe (FAST/SMART)
+  0.60-0.90  →  VLM confirme (THINK)
+  < 0.60  →  VLM cherche seul (THINK)
+
+L'ancien GroundingPipeline est utilisé en fallback si tout échoue.
+
+Utilisation :
+    from core.grounding.fast_pipeline import FastSmartThinkPipeline
+    from core.grounding.target import GroundingTarget
+
+    pipeline = FastSmartThinkPipeline()
+    result = pipeline.locate(GroundingTarget(text="Valider"))
+    if result:
+        print(f"({result.x}, {result.y}) via {result.method} en {result.time_ms:.0f}ms")
+"""
+
+from __future__ import annotations
+
+import time
+import threading
+from typing import Optional
+
+from core.grounding.target import GroundingTarget, GroundingResult
+from core.grounding.fast_types import LocateResult
+from core.grounding.fast_detector import FastDetector
+from core.grounding.smart_matcher import SmartMatcher
+from core.grounding.think_arbiter import ThinkArbiter
+from core.grounding.element_signature import SignatureStore
+
+
+# Singleton
+_instance: Optional[FastSmartThinkPipeline] = None
+_instance_lock = threading.Lock()
+
+
+class FastSmartThinkPipeline:
+    """Pipeline FAST → SMART → THINK pour la localisation d'éléments UI.
+
+    Chaque appel à locate() suit la cascade :
+    1. FAST : détection RF-DETR + OCR enrichissement (~120ms+1s)
+    2. SMART : matching texte/type/position/voisins (< 1ms)
+    3. THINK : VLM arbitre si score insuffisant (~3-5s)
+    4. Fallback : ancien pipeline si tout échoue
+    """
+
+    def __init__(
+        self,
+        confidence_direct: float = 0.90,
+        confidence_think: float = 0.60,
+        enable_think: bool = True,
+        enable_learning: bool = True,
+    ):
+        self.confidence_direct = confidence_direct
+        self.confidence_think = confidence_think
+        self.enable_think = enable_think
+        self.enable_learning = enable_learning
+
+        self._detector = FastDetector()
+        self._matcher = SmartMatcher()
+        self._arbiter = ThinkArbiter()
+        self._signatures = SignatureStore()
+        self._fallback_pipeline = None
+
+    @classmethod
+    def get_instance(cls) -> FastSmartThinkPipeline:
+        """Retourne l'instance singleton."""
+        global _instance
+        if _instance is None:
+            with _instance_lock:
+                if _instance is None:
+                    _instance = cls()
+        return _instance
+
+    def set_fallback_pipeline(self, pipeline) -> None:
+        """Configure l'ancien pipeline comme safety net."""
+        self._fallback_pipeline = pipeline
+
+    # ------------------------------------------------------------------
+    # API principale
+    # ------------------------------------------------------------------
+
+    def locate(
+        self,
+        target: GroundingTarget,
+        screenshot_pil=None,
+        phash: str = "",
+        window_title: str = "",
+    ) -> Optional[GroundingResult]:
+        """Localise un élément UI via la cascade FAST → SMART → THINK.
+
+        Args:
+            target: Ce qu'on cherche (texte, description, bbox d'origine).
+            screenshot_pil: Image PIL. Si None, capture via mss.
+            phash: Hash perceptuel pour le cache.
+            window_title: Titre de la fenêtre active.
+
+        Returns:
+            GroundingResult compatible avec le pipeline existant, ou None.
+        """
+        t0 = time.time()
+
+        # --- FAST : détecter tous les éléments ---
+        snapshot = self._detector.detect(
+            screenshot_pil=screenshot_pil,
+            phash=phash,
+            window_title=window_title,
+        )
+
+        if not snapshot.elements:
+            print(f"⚡ [Pipeline] FAST : aucun élément détecté")
+            return self._try_fallback(target)
+
+        # --- Lookup signature apprise ---
+        target_key = SignatureStore.make_target_key(
+            target.text or "", target.description or ""
+        )
+        screen_ctx = SignatureStore.make_screen_context(
+            window_title, snapshot.resolution
+        )
+        signature = self._signatures.lookup(target_key, screen_ctx)
+
+        # --- SMART : matcher avec la cible ---
+        candidate = self._matcher.match(snapshot, target, signature)
+
+        if candidate:
+            dt = (time.time() - t0) * 1000
+
+            # Score suffisant → action directe
+            if candidate.score >= self.confidence_direct:
+                print(f"✅ [Pipeline] FAST→SMART direct : '{candidate.element.ocr_text}' "
+                      f"score={candidate.score:.3f} ({candidate.method}) "
+                      f"→ ({candidate.element.center[0]}, {candidate.element.center[1]}) "
+                      f"en {dt:.0f}ms")
+
+                # Apprentissage
+                if self.enable_learning:
+                    self._signatures.record_success(
+                        target_key, screen_ctx,
+                        candidate.element, candidate.score,
+                    )
+
+                return GroundingResult(
+                    x=candidate.element.center[0],
+                    y=candidate.element.center[1],
+                    method=f"fast_{candidate.method}",
+                    confidence=candidate.score,
+                    time_ms=dt,
+                )
+
+            # Score moyen → demander au VLM de confirmer
+            if candidate.score >= self.confidence_think and self.enable_think:
+                print(f"🤔 [Pipeline] SMART score={candidate.score:.3f} — THINK pour confirmer")
+                think_result = self._arbiter.arbitrate(
+                    target,
+                    candidates=[candidate],
+                    screenshot_pil=screenshot_pil or snapshot.elements[0] if False else screenshot_pil,
+                )
+                dt = (time.time() - t0) * 1000
+
+                if think_result:
+                    # VLM a confirmé
+                    if self.enable_learning:
+                        self._signatures.record_success(
+                            target_key, screen_ctx,
+                            candidate.element, think_result.confidence,
+                        )
+                    return GroundingResult(
+                        x=think_result.x, y=think_result.y,
+                        method="smart_think_confirmed",
+                        confidence=think_result.confidence,
+                        time_ms=dt,
+                    )
+
+        # --- THINK : score trop bas ou pas de candidat → VLM cherche seul ---
+        if self.enable_think:
+            score_info = f"score={candidate.score:.3f}" if candidate else "aucun candidat"
+            print(f"🤔 [Pipeline] {score_info} — THINK recherche complète")
+            think_result = self._arbiter.arbitrate(
+                target, candidates=[], screenshot_pil=screenshot_pil,
+            )
+            dt = (time.time() - t0) * 1000
+
+            if think_result:
+                return GroundingResult(
+                    x=think_result.x, y=think_result.y,
+                    method="think_vlm",
+                    confidence=think_result.confidence,
+                    time_ms=dt,
+                )
+
+        # --- Fallback : ancien pipeline ---
+        return self._try_fallback(target)
+
+    # ------------------------------------------------------------------
+    # Fallback
+    # ------------------------------------------------------------------
+
+    def _try_fallback(self, target: GroundingTarget) -> Optional[GroundingResult]:
+        """Tente l'ancien pipeline en dernier recours."""
+        if self._fallback_pipeline is None:
+            print(f"❌ [Pipeline] Aucune méthode n'a trouvé '{target.text}'")
+            return None
+
+        print(f"⚠️ [Pipeline] Fallback ancien pipeline pour '{target.text}'")
+        try:
+            return self._fallback_pipeline.locate(target)
+        except Exception as ex:
+            print(f"⚠️ [Pipeline] Fallback échoué: {ex}")
+            return None

core/grounding/fast_types.py

@@ -0,0 +1,81 @@
+"""
+core/grounding/fast_types.py — Structures de données pour le pipeline FAST→SMART→THINK
+
+Utilisées exclusivement par le pipeline de localisation rapide.
+Compatibles avec GroundingTarget/GroundingResult existants via conversion.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Tuple
+
+
+@dataclass
+class DetectedUIElement:
+    """Élément UI détecté par le layer FAST (RF-DETR) puis enrichi par OCR."""
+    id: int
+    bbox: Tuple[int, int, int, int]      # (x1, y1, x2, y2) pixels absolus
+    center: Tuple[int, int]              # (cx, cy)
+    confidence: float                     # confidence détecteur (0-1)
+    element_type: str = "element"        # "button", "input", "icon", "text", "element"
+    ocr_text: str = ""                   # texte OCR extrait de la région
+    neighbors: List[str] = field(default_factory=list)  # textes des éléments proches
+    relative_position: str = ""          # "top_left", "center", "bottom_right", etc.
+
+    @property
+    def width(self) -> int:
+        return self.bbox[2] - self.bbox[0]
+
+    @property
+    def height(self) -> int:
+        return self.bbox[3] - self.bbox[1]
+
+    @property
+    def area(self) -> int:
+        return self.width * self.height
+
+
+@dataclass
+class ScreenSnapshot:
+    """État complet de l'écran à un instant t — sortie du layer FAST."""
+    elements: List[DetectedUIElement]
+    ocr_words: List[Dict[str, Any]]      # mots OCR bruts [{text, bbox}]
+    resolution: Tuple[int, int]          # (width, height)
+    window_title: str = ""
+    phash: str = ""
+    detection_time_ms: float = 0.0
+    ocr_time_ms: float = 0.0
+    total_time_ms: float = 0.0
+
+
+@dataclass
+class MatchCandidate:
+    """Résultat du matching SMART pour un élément candidat."""
+    element: DetectedUIElement
+    score: float                          # score combiné (0-1)
+    score_detail: Dict[str, float] = field(default_factory=dict)
+    method: str = ""                     # "exact_text", "fuzzy_text", "position", etc.
+
+
+@dataclass
+class LocateResult:
+    """Résultat final du pipeline FAST→SMART→THINK."""
+    x: int
+    y: int
+    confidence: float
+    method: str                          # "fast_exact", "fast_fuzzy", "smart_vote", "think_vlm"
+    time_ms: float
+    tier: str = "fast"                   # "fast", "smart", "think"
+    element: Optional[DetectedUIElement] = None
+    candidates_count: int = 0
+
+    def to_grounding_result(self):
+        """Conversion vers GroundingResult pour compatibilité."""
+        from core.grounding.target import GroundingResult
+        return GroundingResult(
+            x=self.x, y=self.y,
+            method=self.method,
+            confidence=self.confidence,
+            time_ms=self.time_ms,
+        )

core/grounding/infigui_worker.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+"""
+Worker InfiGUI — process indépendant, communication par fichiers.
+
+Charge le modèle, surveille /tmp/infigui_request.json, infère, écrit /tmp/infigui_response.json.
+
+Lancement :
+    cd ~/ai/rpa_vision_v3
+    .venv/bin/python3 -m core.grounding.infigui_worker
+"""
+
+import json
+import math
+import os
+import re
+import sys
+import time
+import gc
+import warnings
+
+warnings.filterwarnings("ignore")
+
+import torch
+
+REQUEST_FILE = "/tmp/infigui_request.json"
+RESPONSE_FILE = "/tmp/infigui_response.json"
+READY_FILE = "/tmp/infigui_ready"
+
+
+def load_model():
+    """Charge InfiGUI-G1-3B en 4-bit NF4."""
+    torch.cuda.empty_cache()
+    gc.collect()
+
+    from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor, BitsAndBytesConfig
+
+    model_id = "InfiX-ai/InfiGUI-G1-3B"
+    print(f"[infigui-worker] Chargement {model_id}...")
+
+    bnb = BitsAndBytesConfig(
+        load_in_4bit=True, bnb_4bit_quant_type="nf4",
+        bnb_4bit_compute_dtype=torch.bfloat16, bnb_4bit_use_double_quant=True,
+    )
+    model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
+        model_id, quantization_config=bnb, device_map={"": "cuda:0"},
+    )
+    model.eval()
+    processor = AutoProcessor.from_pretrained(
+        model_id, padding_side="left",
+        min_pixels=100 * 28 * 28, max_pixels=5600 * 28 * 28,
+    )
+
+    vram = torch.cuda.memory_allocated() / 1e9
+    print(f"[infigui-worker] Prêt — VRAM: {vram:.2f}GB")
+
+    # Signal "prêt"
+    with open(READY_FILE, "w") as f:
+        f.write(f"ready {vram:.2f}GB")
+
+    return model, processor
+
+
+def infer(model, processor, req):
+    """Fait une inférence.
+
+    Modes :
+        - texte seul (target/description) : grounding classique
+        - fusionné (anchor_image_path présent) : on passe en plus le crop d'ancre
+          comme image de référence et le modèle doit retrouver cet élément sur
+          le screenshot. Évite la double passe describe→ground.
+    """
+    from PIL import Image
+    from qwen_vl_utils import process_vision_info
+
+    target = req.get("target", "")
+    description = req.get("description", "")
+    label = f"{target} — {description}" if description else target
+
+    # Image principale (screenshot complet)
+    image_path = req.get("image_path", "")
+    if image_path and os.path.exists(image_path):
+        img = Image.open(image_path).convert("RGB")
+    else:
+        import mss
+        with mss.mss() as sct:
+            grab = sct.grab(sct.monitors[0])
+            img = Image.frombytes("RGB", grab.size, grab.bgra, "raw", "BGRX")
+
+    # Image d'ancre (optionnelle) — mode fusionné describe+ground
+    anchor_image_path = req.get("anchor_image_path", "")
+    anchor_img = None
+    if anchor_image_path and os.path.exists(anchor_image_path):
+        anchor_img = Image.open(anchor_image_path).convert("RGB")
+
+    if not label.strip() and anchor_img is None:
+        return {"x": None, "y": None, "error": "target ou anchor_image requis"}
+
+    W, H = img.size
+    factor = 28
+    rH = max(factor, round(H / factor) * factor)
+    rW = max(factor, round(W / factor) * factor)
+
+    system = (
+        "You FIRST think about the reasoning process as an internal monologue "
+        "and then provide the final answer.\n"
+        "The reasoning process MUST BE enclosed within <think> </think> tags."
+    )
+
+    # Construction du prompt selon le mode
+    if anchor_img is not None:
+        # Mode fusionné : Image1 = crop d'ancre, Image2 = screenshot
+        hint = f' Hint: this element looks like "{label}".' if label.strip() else ""
+        user_text = (
+            f"The first image is a small crop of a UI element captured previously. "
+            f"The second image is the current screen ({rW}x{rH}).{hint}\n"
+            f"Locate on the second image the UI element that visually matches the first image. "
+            f"Output the coordinates using JSON format: "
+            f'[{{"point_2d": [x, y]}}, ...]'
+        )
+        messages = [
+            {"role": "system", "content": system},
+            {"role": "user", "content": [
+                {"type": "image", "image": anchor_img},
+                {"type": "image", "image": img},
+                {"type": "text", "text": user_text},
+            ]},
+        ]
+    else:
+        # Mode classique : texte seul
+        user_text = (
+            f'The screen\'s resolution is {rW}x{rH}.\n'
+            f'Locate the UI element(s) for "{label}", '
+            f'output the coordinates using JSON format: '
+            f'[{{"point_2d": [x, y]}}, ...]'
+        )
+        messages = [
+            {"role": "system", "content": system},
+            {"role": "user", "content": [
+                {"type": "image", "image": img},
+                {"type": "text", "text": user_text},
+            ]},
+        ]
+
+    text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    image_inputs, video_inputs = process_vision_info(messages)
+    inputs = processor(
+        text=[text], images=image_inputs, videos=video_inputs,
+        padding=True, return_tensors="pt",
+    ).to(model.device)
+
+    t0 = time.time()
+    with torch.no_grad():
+        gen = model.generate(**inputs, max_new_tokens=512)
+    infer_ms = (time.time() - t0) * 1000
+
+    trimmed = [o[len(i):] for i, o in zip(inputs.input_ids, gen)]
+    raw = processor.batch_decode(
+        trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False,
+    )[0].strip()
+
+    mode_str = "fused" if anchor_img is not None else "text"
+    print(f"[infigui-worker] [{mode_str}] '{label[:40]}' ({infer_ms:.0f}ms)")
+
+    # Parser JSON point_2d
+    json_part = raw.split("</think>")[-1] if "</think>" in raw else raw
+    json_part = json_part.replace("```json", "").replace("```", "").strip()
+
+    px, py = None, None
+    try:
+        parsed = json.loads(json_part)
+        if isinstance(parsed, list) and len(parsed) > 0:
+            pt = parsed[0].get("point_2d", [])
+            if len(pt) >= 2:
+                px = int(pt[0] * W / rW)
+                py = int(pt[1] * H / rH)
+    except json.JSONDecodeError:
+        m = re.search(r'"point_2d"\s*:\s*\[(\d+),\s*(\d+)\]', raw)
+        if m:
+            px = int(int(m.group(1)) * W / rW)
+            py = int(int(m.group(2)) * H / rH)
+
+    return {
+        "x": px, "y": py,
+        "method": "infigui",
+        "confidence": 0.90 if px else 0.0,
+        "time_ms": round(infer_ms, 1),
+    }
+
+
+def main():
+    """Mode one-shot : lit une requête sur stdin, infère, écrit le résultat sur stdout."""
+    # Lire la requête
+    input_data = sys.stdin.read().strip()
+    if not input_data:
+        print(json.dumps({"x": None, "y": None, "error": "pas de requête"}))
+        return
+
+    try:
+        req = json.loads(input_data)
+    except json.JSONDecodeError:
+        print(json.dumps({"x": None, "y": None, "error": "JSON invalide"}))
+        return
+
+    model, processor = load_model()
+    result = infer(model, processor, req)
+    print(json.dumps(result))
+
+
+if __name__ == "__main__":
+    main()

core/grounding/pipeline.py

@@ -0,0 +1,190 @@
+"""
+core/grounding/pipeline.py — Pipeline de grounding en cascade
+
+Orchestre les methodes de localisation dans l'ordre :
+1. Template matching (TemplateMatcher, local, ~80ms)
+2. OCR (docTR via input_handler, local, ~1s)
+3. UI-TARS (HTTP vers serveur grounding, ~3s)
+4. Static fallback (coordonnees d'origine du workflow)
+
+Chaque methode est essayee dans l'ordre. Des qu'une reussit, on retourne
+le resultat. Cela permet un equilibre entre vitesse (template) et robustesse
+(UI-TARS pour les elements qui ont change de position/apparence).
+
+Utilisation :
+    from core.grounding.pipeline import GroundingPipeline
+    from core.grounding.target import GroundingTarget
+
+    pipeline = GroundingPipeline()
+    result = pipeline.locate(GroundingTarget(
+        text="Valider",
+        description="bouton vert en bas",
+        template_b64=screenshot_b64,
+        original_bbox={"x": 100, "y": 200, "width": 80, "height": 30},
+    ))
+    if result:
+        print(f"Trouve a ({result.x}, {result.y}) via {result.method}")
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Optional
+
+from core.grounding.target import GroundingTarget, GroundingResult
+
+
+class GroundingPipeline:
+    """Pipeline de localisation en cascade : template -> OCR -> UI-TARS -> static."""
+
+    def __init__(self, template_threshold: float = 0.75, enable_uitars: bool = True):
+        self.template_threshold = template_threshold
+        self.enable_uitars = enable_uitars
+
+    def locate(self, target: GroundingTarget) -> Optional[GroundingResult]:
+        """Localise un element UI en essayant les methodes en cascade.
+
+        Args:
+            target: description de l'element a localiser
+
+        Returns:
+            GroundingResult ou None si aucune methode ne trouve l'element
+        """
+        t0 = time.time()
+
+        # --- Methode 1 : Template matching (~80ms) ---
+        result = self._try_template(target)
+        if result:
+            print(f"[GroundingPipeline] Localise via {result.method} en "
+                  f"{(time.time() - t0) * 1000:.0f}ms")
+            return result
+
+        # --- Methode 2 : OCR texte (~1s) ---
+        result = self._try_ocr(target)
+        if result:
+            print(f"[GroundingPipeline] Localise via {result.method} en "
+                  f"{(time.time() - t0) * 1000:.0f}ms")
+            return result
+
+        # --- Methode 3 : UI-TARS via serveur HTTP (~3s) ---
+        if self.enable_uitars:
+            result = self._try_uitars(target)
+            if result:
+                print(f"[GroundingPipeline] Localise via {result.method} en "
+                      f"{(time.time() - t0) * 1000:.0f}ms")
+                return result
+
+        # --- Methode 4 : Fallback statique ---
+        result = self._try_static(target)
+        if result:
+            print(f"[GroundingPipeline] Localise via {result.method} en "
+                  f"{(time.time() - t0) * 1000:.0f}ms")
+            return result
+
+        print(f"[GroundingPipeline] ECHEC: '{target.text}' introuvable "
+              f"(toutes methodes epuisees, {(time.time() - t0) * 1000:.0f}ms)")
+        return None
+
+    # ------------------------------------------------------------------
+    # Methodes individuelles
+    # ------------------------------------------------------------------
+
+    def _try_template(self, target: GroundingTarget) -> Optional[GroundingResult]:
+        """Template matching — rapide, exact, mais sensible aux changements visuels."""
+        if not target.template_b64:
+            return None
+
+        try:
+            from core.grounding.template_matcher import TemplateMatcher
+            matcher = TemplateMatcher(threshold=self.template_threshold)
+            match = matcher.match_screen(anchor_b64=target.template_b64)
+            if match:
+                print(f"[GroundingPipeline/template] score={match.score:.3f} "
+                      f"pos=({match.x},{match.y}) ({match.time_ms:.0f}ms)")
+                return GroundingResult(
+                    x=match.x,
+                    y=match.y,
+                    method='template',
+                    confidence=match.score,
+                    time_ms=match.time_ms,
+                )
+            else:
+                diag = matcher.match_screen_diagnostic(anchor_b64=target.template_b64)
+                print(f"[GroundingPipeline/template] pas de match — best={diag}")
+        except Exception as e:
+            print(f"[GroundingPipeline/template] ERREUR: {e}")
+
+        return None
+
+    def _try_ocr(self, target: GroundingTarget) -> Optional[GroundingResult]:
+        """OCR : cherche le texte cible sur l'ecran via docTR."""
+        if not target.text:
+            return None
+
+        try:
+            from core.execution.input_handler import _grounding_ocr
+            bbox = target.original_bbox if target.original_bbox else None
+            result = _grounding_ocr(target.text, anchor_bbox=bbox)
+            if result:
+                print(f"[GroundingPipeline/OCR] '{target.text}' -> ({result['x']}, {result['y']})")
+                return GroundingResult(
+                    x=result['x'],
+                    y=result['y'],
+                    method='ocr',
+                    confidence=result.get('confidence', 0.80),
+                    time_ms=result.get('time_ms', 0),
+                )
+            else:
+                print(f"[GroundingPipeline/OCR] '{target.text}' non trouve")
+        except Exception as e:
+            print(f"[GroundingPipeline/OCR] ERREUR: {e}")
+
+        return None
+
+    def _try_uitars(self, target: GroundingTarget) -> Optional[GroundingResult]:
+        """UI-TARS via serveur HTTP — robust, gere les changements de layout."""
+        if not target.text and not target.description:
+            return None
+
+        try:
+            from core.grounding.ui_tars_grounder import UITarsGrounder
+            grounder = UITarsGrounder.get_instance()
+            result = grounder.ground(
+                target_text=target.text,
+                target_description=target.description,
+            )
+            if result:
+                print(f"[GroundingPipeline/UI-TARS] ({result.x}, {result.y}) "
+                      f"conf={result.confidence:.2f} ({result.time_ms:.0f}ms)")
+                return result
+            else:
+                print(f"[GroundingPipeline/UI-TARS] pas de resultat")
+        except Exception as e:
+            print(f"[GroundingPipeline/UI-TARS] ERREUR: {e}")
+
+        return None
+
+    def _try_static(self, target: GroundingTarget) -> Optional[GroundingResult]:
+        """Fallback : coordonnees d'origine du workflow (centre du bounding box)."""
+        bbox = target.original_bbox
+        if not bbox:
+            return None
+
+        w = bbox.get('width', 0)
+        h = bbox.get('height', 0)
+        if not w or not h:
+            return None
+
+        x = int(bbox.get('x', 0) + w / 2)
+        y = int(bbox.get('y', 0) + h / 2)
+
+        print(f"[GroundingPipeline/static] fallback ({x}, {y}) "
+              f"depuis bbox {bbox}")
+
+        return GroundingResult(
+            x=x,
+            y=y,
+            method='static_fallback',
+            confidence=0.30,
+            time_ms=0.0,
+        )

core/grounding/server.py

@@ -0,0 +1,113 @@
+"""Serveur grounding minimaliste — Flask single-thread, même contexte CUDA."""
+import base64, io, json, math, os, re, time, gc
+import torch
+from flask import Flask, request, jsonify
+from PIL import Image
+
+app = Flask(__name__)
+
+MODEL_ID = os.environ.get("GROUNDING_MODEL", "InfiX-ai/InfiGUI-G1-3B")
+MIN_PIXELS = 100 * 28 * 28
+MAX_PIXELS = 5600 * 28 * 28
+_model = None
+_processor = None
+
+def _smart_resize(h, w, factor=28):
+    h_bar = max(factor, round(h/factor)*factor)
+    w_bar = max(factor, round(w/factor)*factor)
+    if h_bar*w_bar > MAX_PIXELS:
+        beta = math.sqrt((h*w)/MAX_PIXELS)
+        h_bar = math.floor(h/beta/factor)*factor
+        w_bar = math.floor(w/beta/factor)*factor
+    elif h_bar*w_bar < MIN_PIXELS:
+        beta = math.sqrt(MIN_PIXELS/(h*w))
+        h_bar = math.ceil(h*beta/factor)*factor
+        w_bar = math.ceil(w*beta/factor)*factor
+    return h_bar, w_bar
+
+def load_model():
+    global _model, _processor
+    if _model is not None:
+        return
+    from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor, BitsAndBytesConfig
+    torch.cuda.empty_cache(); gc.collect()
+    print(f"[grounding] Chargement {MODEL_ID}...")
+    bnb = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4",
+        bnb_4bit_compute_dtype=torch.bfloat16, bnb_4bit_use_double_quant=True)
+    _model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
+        MODEL_ID, quantization_config=bnb, device_map="auto")
+    _model.eval()
+    _processor = AutoProcessor.from_pretrained(MODEL_ID, min_pixels=MIN_PIXELS, max_pixels=MAX_PIXELS, padding_side="left")
+    print(f"[grounding] Prêt — VRAM: {torch.cuda.memory_allocated()/1e9:.2f}GB")
+
+@app.route('/health')
+def health():
+    return jsonify({"status": "ok", "model": MODEL_ID, "model_loaded": _model is not None,
+                    "cuda_available": torch.cuda.is_available(),
+                    "vram_allocated_gb": round(torch.cuda.memory_allocated()/1e9, 2)})
+
+@app.route('/ground', methods=['POST'])
+def ground():
+    if _model is None:
+        return jsonify({"error": "Modèle pas chargé"}), 503
+    from qwen_vl_utils import process_vision_info
+    data = request.json
+    target = data.get('target_text', '')
+    desc = data.get('target_description', '')
+    label = f"{target} — {desc}" if desc else target
+    if not label.strip():
+        return jsonify({"error": "target_text requis"}), 400
+
+    # Image
+    if data.get('image_b64'):
+        raw = data['image_b64'].split(',')[1] if ',' in data['image_b64'] else data['image_b64']
+        img = Image.open(io.BytesIO(base64.b64decode(raw))).convert('RGB')
+    else:
+        import mss
+        with mss.mss() as sct:
+            grab = sct.grab(sct.monitors[0])
+            img = Image.frombytes('RGB', grab.size, grab.bgra, 'raw', 'BGRX')
+
+    W, H = img.size
+    rH, rW = _smart_resize(H, W)
+
+    user_text = f'The screen\'s resolution is {rW}x{rH}.\nLocate the UI element(s) for "{label}", output the coordinates using JSON format: [{{"point_2d": [x, y]}}, ...]'
+    system = "You FIRST think about the reasoning process as an internal monologue and then provide the final answer.\nThe reasoning process MUST BE enclosed within <think> </think> tags."
+
+    messages = [{"role": "system", "content": system},
+                {"role": "user", "content": [{"type": "image", "image": img}, {"type": "text", "text": user_text}]}]
+
+    text = _processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    image_inputs, video_inputs = process_vision_info(messages)
+    inputs = _processor(text=[text], images=image_inputs, videos=video_inputs, padding=True, return_tensors="pt").to(_model.device)
+
+    t0 = time.time()
+    with torch.no_grad():
+        gen = _model.generate(**inputs, max_new_tokens=512)
+    infer_ms = (time.time()-t0)*1000
+
+    trimmed = [o[len(i):] for i,o in zip(inputs.input_ids, gen)]
+    raw = _processor.batch_decode(trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0].strip()
+    print(f"[grounding] '{label[:40]}' → {raw[:100]} ({infer_ms:.0f}ms)")
+
+    # Parser JSON point_2d
+    json_part = raw.split("</think>")[-1] if "</think>" in raw else raw
+    json_part = json_part.replace("```json","").replace("```","").strip()
+    px, py = None, None
+    try:
+        parsed = json.loads(json_part)
+        if isinstance(parsed, list) and len(parsed) > 0:
+            pt = parsed[0].get("point_2d", [])
+            if len(pt) >= 2:
+                px, py = int(pt[0]*W/rW), int(pt[1]*H/rH)
+    except json.JSONDecodeError:
+        m = re.search(r'"point_2d"\s*:\s*\[(\d+),\s*(\d+)\]', raw)
+        if m:
+            px, py = int(int(m.group(1))*W/rW), int(int(m.group(2))*H/rH)
+
+    return jsonify({"x": px, "y": py, "method": "infigui", "confidence": 0.90 if px else 0.0,
+                    "time_ms": round(infer_ms, 1), "raw_output": raw[:300]})
+
+if __name__ == '__main__':
+    load_model()
+    app.run(host='0.0.0.0', port=8200, threaded=False)

core/grounding/shadow_learning_hook.py

@@ -0,0 +1,156 @@
+"""
+core/grounding/shadow_learning_hook.py — Hook d'apprentissage Shadow
+
+Connecte le ShadowObserver au SignatureStore : chaque clic observé pendant
+une session Shadow enrichit la base de signatures d'éléments.
+
+L'humain clique quelque part → on détecte quel élément UI est sous le clic →
+on stocke sa signature (texte, type, position, voisins) pour le replay.
+
+Ce module est un HOOK optionnel — il ne modifie pas le ShadowObserver,
+il s'y branche via callback.
+
+Utilisation :
+    from core.grounding.shadow_learning_hook import ShadowLearningHook
+
+    hook = ShadowLearningHook()
+
+    # Dans le ShadowObserver ou l'API de capture :
+    hook.on_click_observed(
+        click_x=542, click_y=318,
+        screenshot_pil=screen,
+        window_title="Bloc-notes",
+        target_label="Bouton Valider",
+    )
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from typing import Any, Dict, Optional
+
+from core.grounding.element_signature import SignatureStore
+from core.grounding.fast_types import DetectedUIElement
+
+
+class ShadowLearningHook:
+    """Hook d'apprentissage pour le mode Shadow.
+
+    À chaque clic humain observé, détecte l'élément sous le clic
+    et enrichit le SignatureStore.
+    """
+
+    def __init__(self, signature_store: Optional[SignatureStore] = None):
+        self._store = signature_store or SignatureStore()
+        self._detector = None  # Lazy load pour ne pas charger RF-DETR au startup
+        self._lock = threading.Lock()
+
+    def on_click_observed(
+        self,
+        click_x: int,
+        click_y: int,
+        screenshot_pil: Optional[Any] = None,
+        window_title: str = "",
+        target_label: str = "",
+        target_description: str = "",
+    ) -> Optional[Dict[str, Any]]:
+        """Appelé quand un clic humain est observé pendant le Shadow.
+
+        Args:
+            click_x, click_y: Position du clic (pixels écran).
+            screenshot_pil: Capture d'écran PIL au moment du clic.
+            window_title: Titre de la fenêtre active.
+            target_label: Label de l'étape (si connu).
+            target_description: Description de l'élément (si connue).
+
+        Returns:
+            Dict avec la signature créée/enrichie, ou None si échec.
+        """
+        t0 = time.time()
+
+        try:
+            # Lazy load du détecteur
+            if self._detector is None:
+                from core.grounding.fast_detector import FastDetector
+                self._detector = FastDetector()
+
+            # Détecter les éléments sur l'écran
+            snapshot = self._detector.detect(screenshot_pil=screenshot_pil)
+
+            if not snapshot.elements:
+                print(f"📝 [Shadow/learn] Aucun élément détecté à ({click_x}, {click_y})")
+                return None
+
+            # Trouver l'élément sous le clic
+            clicked_element = self._find_element_at(click_x, click_y, snapshot.elements)
+
+            if clicked_element is None:
+                print(f"📝 [Shadow/learn] Aucun élément sous ({click_x}, {click_y})")
+                return None
+
+            # Construire la clé de la cible
+            target_key = SignatureStore.make_target_key(
+                target_label or clicked_element.ocr_text,
+                target_description,
+            )
+            screen_ctx = SignatureStore.make_screen_context(
+                window_title, snapshot.resolution,
+            )
+
+            # Enregistrer la signature
+            self._store.record_success(
+                target_key=target_key,
+                screen_context=screen_ctx,
+                element=clicked_element,
+                confidence=1.0,  # L'humain a cliqué → confiance maximale
+            )
+
+            dt = (time.time() - t0) * 1000
+            print(f"📝 [Shadow/learn] Signature '{clicked_element.ocr_text}' "
+                  f"type={clicked_element.element_type} "
+                  f"pos={clicked_element.relative_position} "
+                  f"voisins={clicked_element.neighbors[:3]} ({dt:.0f}ms)")
+
+            return {
+                "target_key": target_key,
+                "text": clicked_element.ocr_text,
+                "element_type": clicked_element.element_type,
+                "relative_position": clicked_element.relative_position,
+                "neighbors": clicked_element.neighbors,
+                "center": clicked_element.center,
+            }
+
+        except Exception as e:
+            print(f"⚠️ [Shadow/learn] Erreur: {e}")
+            return None
+
+    @staticmethod
+    def _find_element_at(
+        x: int, y: int,
+        elements: list,
+        margin: int = 20,
+    ) -> Optional[DetectedUIElement]:
+        """Trouve l'élément dont la bbox contient le point (x, y).
+
+        Si aucun match exact, prend le plus proche dans un rayon de `margin` pixels.
+        """
+        # Match exact : le clic est dans la bbox
+        for elem in elements:
+            x1, y1, x2, y2 = elem.bbox
+            if x1 <= x <= x2 and y1 <= y <= y2:
+                return elem
+
+        # Match par proximité : le clic est proche du centre
+        best_elem = None
+        best_dist = float('inf')
+
+        for elem in elements:
+            dx = abs(elem.center[0] - x)
+            dy = abs(elem.center[1] - y)
+            dist = (dx**2 + dy**2) ** 0.5
+            if dist < margin and dist < best_dist:
+                best_dist = dist
+                best_elem = elem
+
+        return best_elem

core/grounding/smart_matcher.py

@@ -0,0 +1,263 @@
+"""
+core/grounding/smart_matcher.py — Layer SMART : matching déterministe/probabiliste
+
+Étant donné un ScreenSnapshot (tous les éléments détectés) et un GroundingTarget
+(ce qu'on cherche), trouve l'élément correspondant avec un score de confiance.
+
+Pipeline de matching (court-circuit au premier match haute confiance) :
+  1. Texte exact (2ms)        → score 0.95
+  2. Texte fuzzy ratio (5ms)  → score 0.70-0.90
+  3. Type + position (2ms)    → bonus/malus
+  4. Voisins contextuels (5ms) → bonus
+  5. Score combiné → MatchCandidate
+
+Utilisation :
+    from core.grounding.smart_matcher import SmartMatcher
+    from core.grounding.fast_types import ScreenSnapshot
+    from core.grounding.target import GroundingTarget
+
+    matcher = SmartMatcher()
+    candidate = matcher.match(snapshot, GroundingTarget(text="Valider"))
+    if candidate and candidate.score >= 0.90:
+        print(f"Match direct : ({candidate.element.center}) score={candidate.score}")
+"""
+
+from __future__ import annotations
+
+import re
+from difflib import SequenceMatcher
+from typing import Dict, List, Optional
+
+from core.grounding.fast_types import DetectedUIElement, MatchCandidate, ScreenSnapshot
+from core.grounding.target import GroundingTarget
+
+
+class SmartMatcher:
+    """Matching intelligent entre une cible et les éléments détectés.
+
+    Combine plusieurs signaux (texte, type, position, voisins) en un score
+    de confiance unique pour chaque candidat.
+    """
+
+    def __init__(
+        self,
+        weight_text: float = 0.50,
+        weight_type: float = 0.10,
+        weight_position: float = 0.15,
+        weight_neighbors: float = 0.25,
+    ):
+        self.w_text = weight_text
+        self.w_type = weight_type
+        self.w_position = weight_position
+        self.w_neighbors = weight_neighbors
+
+    def match(
+        self,
+        snapshot: ScreenSnapshot,
+        target: GroundingTarget,
+        signature: Optional[Dict] = None,
+    ) -> Optional[MatchCandidate]:
+        """Trouve le MEILLEUR élément correspondant à la cible.
+
+        Returns:
+            Le MatchCandidate avec le score le plus élevé, ou None si aucun match.
+        """
+        candidates = self.match_all(snapshot, target, signature)
+        if not candidates:
+            return None
+        return candidates[0]
+
+    def match_all(
+        self,
+        snapshot: ScreenSnapshot,
+        target: GroundingTarget,
+        signature: Optional[Dict] = None,
+    ) -> List[MatchCandidate]:
+        """Trouve TOUS les candidats triés par score décroissant.
+
+        Args:
+            snapshot: État de l'écran (éléments détectés + OCR).
+            target: Ce qu'on cherche (texte, description, bbox d'origine).
+            signature: Signature apprise (optionnel, enrichit le matching).
+
+        Returns:
+            Liste de MatchCandidate triée par score décroissant.
+        """
+        if not snapshot.elements:
+            return []
+
+        target_text = (target.text or "").strip()
+        target_desc = (target.description or "").strip()
+        search_text = target_text or target_desc
+
+        if not search_text:
+            return []
+
+        candidates = []
+        search_lower = self._normalize(search_text)
+
+        for elem in snapshot.elements:
+            score_detail: Dict[str, float] = {}
+            method = ""
+
+            # --- 1. Score texte ---
+            text_score = self._score_text(search_lower, elem.ocr_text)
+            score_detail["text"] = text_score
+
+            if text_score >= 0.95:
+                method = "exact_text"
+            elif text_score >= 0.70:
+                method = "fuzzy_text"
+
+            # --- 2. Score type (si signature connue) ---
+            type_score = 0.5  # neutre par défaut
+            if signature and signature.get("element_type"):
+                if elem.element_type == signature["element_type"]:
+                    type_score = 1.0
+                elif elem.element_type == "element":
+                    type_score = 0.5  # non classifié, neutre
+                else:
+                    type_score = 0.2
+            score_detail["type"] = type_score
+
+            # --- 3. Score position (si bbox d'origine connue) ---
+            position_score = 0.5  # neutre
+            if target.original_bbox:
+                position_score = self._score_position(
+                    elem.center, target.original_bbox,
+                    snapshot.resolution[0], snapshot.resolution[1],
+                )
+            elif signature and signature.get("relative_position"):
+                if elem.relative_position == signature["relative_position"]:
+                    position_score = 0.9
+                else:
+                    position_score = 0.3
+            score_detail["position"] = position_score
+
+            # --- 4. Score voisins (si signature connue) ---
+            neighbor_score = 0.5  # neutre
+            if signature and signature.get("neighbors"):
+                neighbor_score = self._score_neighbors(
+                    elem.neighbors, signature["neighbors"]
+                )
+            score_detail["neighbors"] = neighbor_score
+
+            # --- Score combiné ---
+            combined = (
+                self.w_text * text_score
+                + self.w_type * type_score
+                + self.w_position * position_score
+                + self.w_neighbors * neighbor_score
+            )
+
+            # Seuil minimum : pas de candidat si le texte ne matche pas du tout
+            if text_score < 0.30:
+                continue
+
+            if not method:
+                method = "combined"
+
+            candidates.append(MatchCandidate(
+                element=elem,
+                score=combined,
+                score_detail=score_detail,
+                method=method,
+            ))
+
+        # Trier par score décroissant
+        candidates.sort(key=lambda c: c.score, reverse=True)
+
+        return candidates
+
+    # ------------------------------------------------------------------
+    # Scoring texte
+    # ------------------------------------------------------------------
+
+    def _score_text(self, search: str, ocr_text: str) -> float:
+        """Score de similarité textuelle (0-1)."""
+        if not ocr_text:
+            return 0.0
+
+        ocr_lower = self._normalize(ocr_text)
+
+        # Match exact
+        if search == ocr_lower:
+            return 1.0
+
+        # Inclusion (l'un contient l'autre)
+        if search in ocr_lower or ocr_lower in search:
+            overlap = min(len(search), len(ocr_lower))
+            total = max(len(search), len(ocr_lower))
+            if total > 0:
+                return 0.70 + 0.25 * (overlap / total)
+
+        # Fuzzy matching (SequenceMatcher, standard library)
+        ratio = SequenceMatcher(None, search, ocr_lower).ratio()
+        if ratio >= 0.60:
+            return 0.50 + 0.40 * ratio
+
+        return ratio * 0.3
+
+    # ------------------------------------------------------------------
+    # Scoring position
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _score_position(
+        center: tuple,
+        original_bbox: dict,
+        screen_w: int,
+        screen_h: int,
+    ) -> float:
+        """Score de proximité par rapport à la position d'origine (0-1)."""
+        if not original_bbox:
+            return 0.5
+
+        orig_x = original_bbox.get("x", 0) + original_bbox.get("width", 0) / 2
+        orig_y = original_bbox.get("y", 0) + original_bbox.get("height", 0) / 2
+
+        dx = abs(center[0] - orig_x) / max(screen_w, 1)
+        dy = abs(center[1] - orig_y) / max(screen_h, 1)
+        distance_norm = (dx**2 + dy**2) ** 0.5
+
+        # distance 0 = score 1.0, distance 0.5 (demi-écran) = score ~0.2
+        return max(0.0, 1.0 - distance_norm * 2.0)
+
+    # ------------------------------------------------------------------
+    # Scoring voisins
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _score_neighbors(
+        current_neighbors: List[str],
+        expected_neighbors: List[str],
+    ) -> float:
+        """Score Jaccard sur les ensembles de mots voisins (0-1)."""
+        if not expected_neighbors:
+            return 0.5
+
+        current_set = {n.lower().strip() for n in current_neighbors if n}
+        expected_set = {n.lower().strip() for n in expected_neighbors if n}
+
+        if not current_set and not expected_set:
+            return 0.5
+
+        intersection = current_set & expected_set
+        union = current_set | expected_set
+
+        if not union:
+            return 0.5
+
+        return len(intersection) / len(union)
+
+    # ------------------------------------------------------------------
+    # Utilitaires
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _normalize(text: str) -> str:
+        """Normalise un texte pour la comparaison."""
+        text = text.lower().strip()
+        text = re.sub(r'[_\-\./\\]', ' ', text)
+        text = re.sub(r'\s+', ' ', text)
+        return text

core/grounding/smart_resize.py

@@ -0,0 +1,77 @@
+"""
+Smart resize officiel Qwen3-VL (algorithme commun Qwen2-VL/Qwen3-VL pour images).
+
+Source de référence : transformers.models.qwen2_vl.image_processing_qwen2_vl.smart_resize
+(transformers 4.57.3). Qwen3-VL utilise Qwen2VLImageProcessor pour les images via
+Qwen3VLProcessor.image_processor_class — la formule est donc commune Qwen2-VL/Qwen3-VL
+sur le pipeline image.
+
+Conditions garanties par smart_resize :
+1. height et width retournés divisibles par `factor` (par défaut 28).
+2. Total pixels dans l'intervalle [min_pixels, max_pixels].
+3. Aspect ratio conservé au plus près.
+
+Module image-only. Pour traitement vidéo Qwen3-VL (factor=32, autres bornes),
+module dédié à créer si besoin futur.
+"""
+
+# DETTE-007 — Trois implémentations smart_resize coexistent dans le repo
+# (core/grounding/server.py:15, core/grounding/infigui_worker.py:99, ce module).
+# Unification post-démo Kerella.
+
+import math
+
+
+FACTOR_DEFAULT = 28
+MIN_PIXELS_DEFAULT = 56 * 56  # 3136
+MAX_PIXELS_DEFAULT = 14 * 14 * 4 * 1280  # 1_003_520
+MAX_RATIO_DEFAULT = 200
+
+
+def _round_by_factor(number: int, factor: int) -> int:
+    """Closest integer to `number` divisible by `factor`."""
+    return round(number / factor) * factor
+
+
+def _floor_by_factor(number: int, factor: int) -> int:
+    """Largest integer ≤ `number` divisible by `factor`."""
+    return math.floor(number / factor) * factor
+
+
+def _ceil_by_factor(number: int, factor: int) -> int:
+    """Smallest integer ≥ `number` divisible by `factor`."""
+    return math.ceil(number / factor) * factor
+
+
+def smart_resize(
+    height: int,
+    width: int,
+    factor: int = FACTOR_DEFAULT,
+    min_pixels: int = MIN_PIXELS_DEFAULT,
+    max_pixels: int = MAX_PIXELS_DEFAULT,
+) -> tuple[int, int]:
+    """Rescale (height, width) to satisfy the three conditions of the module docstring.
+
+    Raises:
+        ValueError: if max(height, width) / min(height, width) > MAX_RATIO_DEFAULT
+            (aspect ratio out of supported domain).
+
+    Returns:
+        (resized_height, resized_width).
+    """
+    if max(height, width) / min(height, width) > MAX_RATIO_DEFAULT:
+        raise ValueError(
+            f"absolute aspect ratio must be smaller than {MAX_RATIO_DEFAULT}, "
+            f"got {max(height, width) / min(height, width)}"
+        )
+    h_bar = round(height / factor) * factor
+    w_bar = round(width / factor) * factor
+    if h_bar * w_bar > max_pixels:
+        beta = math.sqrt((height * width) / max_pixels)
+        h_bar = max(factor, math.floor(height / beta / factor) * factor)
+        w_bar = max(factor, math.floor(width / beta / factor) * factor)
+    elif h_bar * w_bar < min_pixels:
+        beta = math.sqrt(min_pixels / (height * width))
+        h_bar = math.ceil(height * beta / factor) * factor
+        w_bar = math.ceil(width * beta / factor) * factor
+    return h_bar, w_bar

core/grounding/target.py

@@ -0,0 +1,48 @@
+"""
+core/grounding/target.py — Types partagés pour le grounding visuel
+
+Dataclasses décrivant une cible à localiser (GroundingTarget) et
+le résultat d'une localisation (GroundingResult).
+
+Ces types sont la brique commune pour tous les modules de grounding :
+template matching, OCR, VLM, CLIP, etc.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, Optional
+
+
+@dataclass
+class GroundingTarget:
+    """Description d'un élément UI à localiser sur l'écran.
+
+    Attributs :
+        text : texte visible de l'élément (bouton, label, etc.)
+        description : description sémantique libre (ex: "le bouton Valider en bas à droite")
+        template_b64 : capture visuelle de l'élément, encodée en base64 PNG/JPEG
+        original_bbox : position d'origine lors de la capture {x, y, width, height}
+    """
+    text: str = ""
+    description: str = ""
+    template_b64: str = ""
+    original_bbox: Optional[Dict[str, int]] = field(default=None)
+
+
+@dataclass
+class GroundingResult:
+    """Résultat d'une localisation d'élément UI.
+
+    Attributs :
+        x : coordonnée X du centre de l'élément trouvé (pixels écran)
+        y : coordonnée Y du centre de l'élément trouvé (pixels écran)
+        method : méthode ayant produit le résultat ('template', 'ocr', 'vlm', 'clip', etc.)
+        confidence : score de confiance [0.0 – 1.0]
+        time_ms : temps de recherche en millisecondes
+    """
+    x: int
+    y: int
+    method: str
+    confidence: float
+    time_ms: float

core/grounding/template_matcher.py

@@ -0,0 +1,350 @@
+"""
+core/grounding/template_matcher.py — Template matching centralisé
+
+Fournit une classe TemplateMatcher qui localise une ancre visuelle (image template)
+dans un screenshot via cv2.matchTemplate. Supporte single-scale et multi-scale.
+
+Remplace les implémentations dupliquées dans :
+  - core/execution/observe_reason_act.py (~1348-1375)
+  - visual_workflow_builder/backend/api_v3/execute.py (~930-963)
+  - visual_workflow_builder/backend/catalog_routes_v2_vlm.py (~339-381)
+  - visual_workflow_builder/backend/services/intelligent_executor.py (~131-210)
+  - core/detection/omniparser_adapter.py (~330)
+
+Utilisation :
+    from core.grounding import TemplateMatcher, MatchResult
+
+    matcher = TemplateMatcher(threshold=0.75)
+    result = matcher.match_screen(anchor_b64="...")
+    if result:
+        print(f"Trouvé à ({result.x}, {result.y}) score={result.score:.3f}")
+"""
+
+from __future__ import annotations
+
+import base64
+import io
+import logging
+import time
+from dataclasses import dataclass
+from typing import List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+# Imports optionnels — le module se charge même sans cv2/PIL/mss
+try:
+    import cv2
+    _CV2 = True
+except ImportError:
+    _CV2 = False
+
+try:
+    import numpy as np
+    _NP = True
+except ImportError:
+    _NP = False
+
+try:
+    from PIL import Image
+    _PIL = True
+except ImportError:
+    _PIL = False
+
+try:
+    import mss as mss_lib
+    _MSS = True
+except ImportError:
+    _MSS = False
+
+
+# ---------------------------------------------------------------------------
+# Résultat d'un match
+# ---------------------------------------------------------------------------
+
+@dataclass
+class MatchResult:
+    """Résultat d'un template matching."""
+    x: int
+    y: int
+    score: float
+    method: str           # 'template' | 'template_multiscale'
+    time_ms: float
+    scale: float = 1.0    # Échelle à laquelle le meilleur match a été trouvé
+
+
+# ---------------------------------------------------------------------------
+# TemplateMatcher
+# ---------------------------------------------------------------------------
+
+class TemplateMatcher:
+    """Localise une ancre visuelle dans un screenshot via template matching.
+
+    Paramètres :
+        threshold : score minimum pour accepter un match (défaut 0.75)
+        multiscale : active le matching multi-échelle (défaut False)
+        scales : liste d'échelles à tester en mode multi-scale
+        method : méthode cv2 (défaut cv2.TM_CCOEFF_NORMED)
+        grayscale : convertir en niveaux de gris avant matching (défaut False)
+    """
+
+    # Échelles par défaut pour le mode multi-scale, ordonnées par
+    # probabilité décroissante (1.0 en premier = rapide si ça matche)
+    DEFAULT_SCALES: List[float] = [1.0, 0.95, 1.05, 0.9, 1.1, 0.85, 1.15, 0.8, 1.2]
+
+    def __init__(
+        self,
+        threshold: float = 0.75,
+        multiscale: bool = False,
+        scales: Optional[List[float]] = None,
+        grayscale: bool = False,
+    ):
+        self.threshold = threshold
+        self.multiscale = multiscale
+        self.scales = scales or self.DEFAULT_SCALES
+        self.grayscale = grayscale
+        # cv2.TM_CCOEFF_NORMED est la méthode utilisée partout dans le projet
+        self._cv2_method = cv2.TM_CCOEFF_NORMED if _CV2 else None
+
+    # ------------------------------------------------------------------
+    # API publique
+    # ------------------------------------------------------------------
+
+    def match_screen(
+        self,
+        anchor_b64: Optional[str] = None,
+        anchor_pil: Optional["Image.Image"] = None,
+        screen_pil: Optional["Image.Image"] = None,
+    ) -> Optional[MatchResult]:
+        """Cherche l'ancre dans le screenshot courant (ou fourni).
+
+        L'ancre peut être passée en base64 ou en PIL Image.
+        Le screenshot est capturé via mss si non fourni.
+
+        Retourne un MatchResult ou None si aucun match >= seuil.
+        """
+        if not (_CV2 and _NP and _PIL):
+            logger.debug("[TemplateMatcher] cv2/numpy/PIL non disponible")
+            return None
+
+        # --- Préparer l'ancre ---
+        anchor_img = self._decode_anchor(anchor_b64, anchor_pil)
+        if anchor_img is None:
+            return None
+
+        # --- Préparer le screenshot ---
+        if screen_pil is None:
+            screen_pil = self._capture_screen()
+        if screen_pil is None:
+            return None
+
+        # --- Convertir en arrays cv2 ---
+        screen_cv = cv2.cvtColor(np.array(screen_pil), cv2.COLOR_RGB2BGR)
+        anchor_cv = cv2.cvtColor(np.array(anchor_img), cv2.COLOR_RGB2BGR)
+
+        # --- Matching ---
+        if self.multiscale:
+            return self._match_multiscale(screen_cv, anchor_cv)
+        else:
+            return self._match_single(screen_cv, anchor_cv)
+
+    def match_in_region(
+        self,
+        region_cv: "np.ndarray",
+        anchor_cv: "np.ndarray",
+        threshold: Optional[float] = None,
+    ) -> Optional[MatchResult]:
+        """Match dans une région déjà découpée (arrays BGR).
+
+        Utilisé par les pipelines qui font leur propre capture/découpe.
+        """
+        if not (_CV2 and _NP):
+            return None
+
+        thr = threshold if threshold is not None else self.threshold
+
+        if self.multiscale:
+            return self._match_multiscale(region_cv, anchor_cv, threshold_override=thr)
+        else:
+            return self._match_single(region_cv, anchor_cv, threshold_override=thr)
+
+    def match_screen_diagnostic(
+        self,
+        anchor_b64: Optional[str] = None,
+        anchor_pil: Optional["Image.Image"] = None,
+        screen_pil: Optional["Image.Image"] = None,
+    ) -> str:
+        """Retourne un diagnostic textuel (score + position) même sans match."""
+        if not (_CV2 and _NP and _PIL):
+            return "cv2/numpy/PIL non dispo"
+
+        anchor_img = self._decode_anchor(anchor_b64, anchor_pil)
+        if anchor_img is None:
+            return "ancre non décodable"
+
+        if screen_pil is None:
+            screen_pil = self._capture_screen()
+        if screen_pil is None:
+            return "capture écran échouée"
+
+        screen_cv = cv2.cvtColor(np.array(screen_pil), cv2.COLOR_RGB2BGR)
+        anchor_cv = cv2.cvtColor(np.array(anchor_img), cv2.COLOR_RGB2BGR)
+
+        if anchor_cv.shape[0] >= screen_cv.shape[0] or anchor_cv.shape[1] >= screen_cv.shape[1]:
+            return f"ancre {anchor_cv.shape[:2]} >= écran {screen_cv.shape[:2]}"
+
+        s_img, a_img = self._maybe_grayscale(screen_cv, anchor_cv)
+        result_tm = cv2.matchTemplate(s_img, a_img, self._cv2_method)
+        _, max_val, _, max_loc = cv2.minMaxLoc(result_tm)
+        return f"{max_val:.3f} pos={max_loc}"
+
+    # ------------------------------------------------------------------
+    # Méthodes internes
+    # ------------------------------------------------------------------
+
+    def _match_single(
+        self,
+        screen_cv: "np.ndarray",
+        anchor_cv: "np.ndarray",
+        threshold_override: Optional[float] = None,
+    ) -> Optional[MatchResult]:
+        """Template matching single-scale."""
+        threshold = threshold_override if threshold_override is not None else self.threshold
+
+        if anchor_cv.shape[0] >= screen_cv.shape[0] or anchor_cv.shape[1] >= screen_cv.shape[1]:
+            logger.debug("[TemplateMatcher] Ancre plus grande que le screen")
+            return None
+
+        s_img, a_img = self._maybe_grayscale(screen_cv, anchor_cv)
+
+        t0 = time.time()
+        result_tm = cv2.matchTemplate(s_img, a_img, self._cv2_method)
+        _, max_val, _, max_loc = cv2.minMaxLoc(result_tm)
+        elapsed_ms = (time.time() - t0) * 1000
+
+        logger.debug(
+            "[TemplateMatcher] score=%.3f pos=%s (%.0fms)",
+            max_val, max_loc, elapsed_ms,
+        )
+
+        if max_val >= threshold:
+            cx = max_loc[0] + anchor_cv.shape[1] // 2
+            cy = max_loc[1] + anchor_cv.shape[0] // 2
+            return MatchResult(
+                x=cx,
+                y=cy,
+                score=float(max_val),
+                method='template',
+                time_ms=elapsed_ms,
+                scale=1.0,
+            )
+        return None
+
+    def _match_multiscale(
+        self,
+        screen_cv: "np.ndarray",
+        anchor_cv: "np.ndarray",
+        threshold_override: Optional[float] = None,
+    ) -> Optional[MatchResult]:
+        """Template matching multi-scale."""
+        threshold = threshold_override if threshold_override is not None else self.threshold
+
+        best_score = -1.0
+        best_loc = None
+        best_scale = 1.0
+        best_anchor_shape = anchor_cv.shape
+
+        t0 = time.time()
+
+        for scale in self.scales:
+            if scale == 1.0:
+                scaled = anchor_cv
+            else:
+                new_w = int(anchor_cv.shape[1] * scale)
+                new_h = int(anchor_cv.shape[0] * scale)
+                if new_w < 8 or new_h < 8:
+                    continue
+                if new_h >= screen_cv.shape[0] or new_w >= screen_cv.shape[1]:
+                    continue
+                scaled = cv2.resize(anchor_cv, (new_w, new_h), interpolation=cv2.INTER_AREA)
+
+            if scaled.shape[0] >= screen_cv.shape[0] or scaled.shape[1] >= screen_cv.shape[1]:
+                continue
+
+            s_img, a_img = self._maybe_grayscale(screen_cv, scaled)
+            result_tm = cv2.matchTemplate(s_img, a_img, self._cv2_method)
+            _, max_val, _, max_loc = cv2.minMaxLoc(result_tm)
+
+            if max_val > best_score:
+                best_score = max_val
+                best_loc = max_loc
+                best_scale = scale
+                best_anchor_shape = scaled.shape
+
+        elapsed_ms = (time.time() - t0) * 1000
+
+        logger.debug(
+            "[TemplateMatcher/multiscale] best_score=%.3f scale=%.2f (%.0fms)",
+            best_score, best_scale, elapsed_ms,
+        )
+
+        if best_score >= threshold and best_loc is not None:
+            cx = best_loc[0] + best_anchor_shape[1] // 2
+            cy = best_loc[1] + best_anchor_shape[0] // 2
+            return MatchResult(
+                x=cx,
+                y=cy,
+                score=float(best_score),
+                method='template_multiscale',
+                time_ms=elapsed_ms,
+                scale=best_scale,
+            )
+        return None
+
+    def _maybe_grayscale(
+        self,
+        screen: "np.ndarray",
+        anchor: "np.ndarray",
+    ) -> Tuple["np.ndarray", "np.ndarray"]:
+        """Convertit en niveaux de gris si self.grayscale est True."""
+        if not self.grayscale:
+            return screen, anchor
+        s = cv2.cvtColor(screen, cv2.COLOR_BGR2GRAY) if len(screen.shape) == 3 else screen
+        a = cv2.cvtColor(anchor, cv2.COLOR_BGR2GRAY) if len(anchor.shape) == 3 else anchor
+        return s, a
+
+    @staticmethod
+    def _decode_anchor(
+        anchor_b64: Optional[str],
+        anchor_pil: Optional["Image.Image"],
+    ) -> Optional["Image.Image"]:
+        """Décode l'ancre depuis base64 ou retourne le PIL directement."""
+        if anchor_pil is not None:
+            return anchor_pil
+
+        if anchor_b64 is None:
+            logger.debug("[TemplateMatcher] Ni anchor_b64 ni anchor_pil fourni")
+            return None
+
+        try:
+            raw = anchor_b64.split(',')[1] if ',' in anchor_b64 else anchor_b64
+            data = base64.b64decode(raw)
+            return Image.open(io.BytesIO(data))
+        except Exception as e:
+            logger.debug("[TemplateMatcher] Erreur décodage ancre: %s", e)
+            return None
+
+    @staticmethod
+    def _capture_screen() -> Optional["Image.Image"]:
+        """Capture l'écran complet via mss (moniteur 0 = tous les écrans)."""
+        if not _MSS:
+            logger.debug("[TemplateMatcher] mss non disponible")
+            return None
+
+        try:
+            with mss_lib.mss() as sct:
+                mon = sct.monitors[0]
+                grab = sct.grab(mon)
+                return Image.frombytes('RGB', grab.size, grab.bgra, 'raw', 'BGRX')
+        except Exception as e:
+            logger.debug("[TemplateMatcher] Erreur capture écran: %s", e)
+            return None

core/grounding/think_arbiter.py

@@ -0,0 +1,103 @@
+"""
+core/grounding/think_arbiter.py — Layer THINK : VLM arbitre (InfiGUI via subprocess)
+
+Appelé UNIQUEMENT quand le SmartMatcher n'a pas assez confiance.
+Utilise le subprocess worker InfiGUI (pas de serveur HTTP).
+
+Utilisation :
+    from core.grounding.think_arbiter import ThinkArbiter
+
+    arbiter = ThinkArbiter()
+    result = arbiter.arbitrate(target, candidates, screenshot)
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Dict, List, Optional
+
+from core.grounding.fast_types import LocateResult, MatchCandidate
+from core.grounding.target import GroundingTarget
+
+
+class ThinkArbiter:
+    """Arbitre VLM — appelle InfiGUI via subprocess worker."""
+
+    def __init__(self):
+        self._grounder = None
+
+    def _get_grounder(self):
+        if self._grounder is None:
+            from core.grounding.ui_tars_grounder import UITarsGrounder
+            self._grounder = UITarsGrounder.get_instance()
+        return self._grounder
+
+    @property
+    def available(self) -> bool:
+        """Toujours disponible — le worker se lance à la demande."""
+        return True
+
+    def arbitrate(
+        self,
+        target: GroundingTarget,
+        candidates: List[MatchCandidate],
+        screenshot_pil: Optional[Any] = None,
+    ) -> Optional[LocateResult]:
+        """Demande au VLM de trancher.
+
+        Si target.template_b64 est fourni, on bascule en mode fusionné :
+        le crop est passé comme image de référence à InfiGUI, ce qui évite
+        une description Ollama qwen2.5vl coûteuse en VRAM.
+        """
+        t0 = time.time()
+
+        # Décodage du crop d'ancre si disponible (mode fusionné)
+        anchor_pil = None
+        if target.template_b64:
+            try:
+                import base64
+                import io
+                from PIL import Image
+
+                raw_b64 = target.template_b64
+                if ',' in raw_b64:
+                    raw_b64 = raw_b64.split(',', 1)[1]
+                anchor_pil = Image.open(io.BytesIO(base64.b64decode(raw_b64))).convert("RGB")
+            except Exception as ex:
+                print(f"⚠️ [THINK] Décodage anchor échoué: {ex}")
+                anchor_pil = None
+
+        try:
+            grounder = self._get_grounder()
+            result = grounder.ground(
+                target_text=target.text or "",
+                target_description=target.description or "",
+                screen_pil=screenshot_pil,
+                anchor_pil=anchor_pil,
+            )
+
+            dt = (time.time() - t0) * 1000
+
+            if result is None:
+                label = target.text or "<crop>"
+                print(f"🤔 [THINK] VLM n'a pas trouvé '{label}' ({dt:.0f}ms)")
+                return None
+
+            method = "think_vlm_fused" if anchor_pil is not None else "think_vlm"
+            locate = LocateResult(
+                x=result.x,
+                y=result.y,
+                confidence=result.confidence,
+                method=method,
+                time_ms=dt,
+                tier="think",
+                candidates_count=len(candidates),
+            )
+
+            print(f"🤔 [THINK/{method}] ({result.x}, {result.y}) conf={result.confidence:.2f} ({dt:.0f}ms)")
+            return locate
+
+        except Exception as ex:
+            dt = (time.time() - t0) * 1000
+            print(f"⚠️ [THINK] Erreur: {ex} ({dt:.0f}ms)")
+            return None

core/grounding/title_verifier.py

@@ -0,0 +1,174 @@
+"""
+core/grounding/title_verifier.py — Vérification post-action par titre de fenêtre
+
+Après chaque action (clic, double-clic), vérifie que la fenêtre active
+a changé de manière attendue en lisant le titre via OCR sur un crop
+de 45px en haut de l'écran.
+
+Léger (~120ms), non-bloquant (échec = warning + retry, pas stop).
+
+Utilisation :
+    from core.grounding.title_verifier import TitleVerifier
+
+    verifier = TitleVerifier()
+    title = verifier.read_title(screenshot_pil)
+    changed = verifier.has_title_changed(title_before, title_after)
+"""
+
+from __future__ import annotations
+
+import time
+from difflib import SequenceMatcher
+from typing import Optional
+
+
+class TitleVerifier:
+    """Vérifie le titre de la fenêtre active via OCR sur crop."""
+
+    # Hauteur du crop pour la barre de titre Windows
+    TITLE_BAR_HEIGHT = 45
+
+    def __init__(self):
+        self._ocr_fn = None  # Lazy load
+
+    def read_title(self, screenshot_pil) -> str:
+        """Lit le titre de la fenêtre active via OCR sur le crop supérieur.
+
+        Args:
+            screenshot_pil: Image PIL du screenshot complet.
+
+        Returns:
+            Texte du titre (peut être vide si OCR échoue).
+        """
+        t0 = time.time()
+
+        try:
+            w, h = screenshot_pil.size
+            # Crop la barre de titre (45px du haut)
+            title_crop = screenshot_pil.crop((0, 0, w, min(self.TITLE_BAR_HEIGHT, h)))
+
+            # OCR sur le petit crop
+            ocr_fn = self._get_ocr()
+            if ocr_fn is None:
+                return ""
+
+            text = ocr_fn(title_crop)
+            dt = (time.time() - t0) * 1000
+
+            # Nettoyer le texte
+            title = text.strip() if text else ""
+            if title:
+                print(f"📋 [TitleVerify] Titre lu: '{title[:60]}' ({dt:.0f}ms)")
+
+            return title
+
+        except Exception as e:
+            print(f"⚠️ [TitleVerify] Erreur lecture titre: {e}")
+            return ""
+
+    def has_title_changed(self, title_before: str, title_after: str) -> bool:
+        """Vérifie si le titre a changé de manière significative."""
+        if not title_before and not title_after:
+            return False
+        if not title_before or not title_after:
+            return True  # Un des deux est vide = changement
+
+        # Comparaison fuzzy — les titres peuvent avoir des variations mineures
+        ratio = SequenceMatcher(None, title_before.lower(), title_after.lower()).ratio()
+        return ratio < 0.85  # Changement si < 85% similaire
+
+    def verify_action(
+        self,
+        screenshot_before,
+        screenshot_after,
+        action_type: str,
+    ) -> dict:
+        """Vérifie qu'une action a produit l'effet attendu sur le titre.
+
+        Args:
+            screenshot_before: Screenshot PIL avant l'action.
+            screenshot_after: Screenshot PIL après l'action.
+            action_type: Type d'action ("double_click", "click", "type", "hotkey").
+
+        Returns:
+            Dict avec success, title_before, title_after, changed.
+        """
+        # Les actions qui ne changent pas le titre
+        if action_type in ('type_text', 'keyboard_shortcut', 'wait_for_anchor', 'hover'):
+            return {
+                'success': True,
+                'title_before': '',
+                'title_after': '',
+                'changed': False,
+                'reason': f"Action '{action_type}' — vérification titre non requise",
+            }
+
+        title_before = self.read_title(screenshot_before)
+        title_after = self.read_title(screenshot_after)
+        changed = self.has_title_changed(title_before, title_after)
+
+        # Pour un double-clic (ouverture fichier/dossier), le titre DOIT changer
+        # Mais seulement si les titres lus sont significatifs (> 3 chars)
+        # docTR sur un crop 45px dans une VM peut donner du bruit ('o', 'a', etc.)
+        if action_type in ('double_click_anchor',) and not changed:
+            if len(title_before) > 3 and len(title_after) > 3:
+                return {
+                    'success': False,
+                    'title_before': title_before,
+                    'title_after': title_after,
+                    'changed': False,
+                    'reason': f"Double-clic sans changement de titre ('{title_after[:40]}')",
+                }
+            # Titres trop courts = bruit OCR, on ne peut pas conclure
+            return {
+                'success': True,
+                'title_before': title_before,
+                'title_after': title_after,
+                'changed': False,
+                'reason': f"Titre trop court pour vérifier ('{title_after}')",
+            }
+
+        # Pour un clic simple, le changement est optionnel
+        return {
+            'success': True,
+            'title_before': title_before,
+            'title_after': title_after,
+            'changed': changed,
+            'reason': 'Titre changé' if changed else 'Titre identique (acceptable)',
+        }
+
+    _easyocr_reader = None  # Singleton partagé
+
+    def _get_ocr(self):
+        """Lazy load de la fonction OCR (EasyOCR prioritaire, fallback docTR)."""
+        if self._ocr_fn is not None:
+            return self._ocr_fn
+
+        # EasyOCR (rapide, bonne qualité GUI)
+        try:
+            import easyocr
+            import numpy as np
+
+            if TitleVerifier._easyocr_reader is None:
+                TitleVerifier._easyocr_reader = easyocr.Reader(
+                    ['fr', 'en'], gpu=True, verbose=False
+                )
+
+            def _easyocr_extract_text(img):
+                results = TitleVerifier._easyocr_reader.readtext(np.array(img))
+                return ' '.join(r[1] for r in results if r[1].strip())
+
+            self._ocr_fn = _easyocr_extract_text
+            return self._ocr_fn
+        except ImportError:
+            pass
+
+        # Fallback docTR
+        try:
+            import sys
+            sys.path.insert(0, 'visual_workflow_builder/backend')
+            from services.ocr_service import ocr_extract_text
+            self._ocr_fn = ocr_extract_text
+            return self._ocr_fn
+        except ImportError:
+            return None

core/grounding/ui_tars_grounder.py

@@ -0,0 +1,161 @@
+"""
+core/grounding/ui_tars_grounder.py — Grounding via script one-shot InfiGUI
+
+Chaque appel lance un subprocess Python qui charge le modèle, infère, et quitte.
+Lent (~15s) mais fiable — pas de crash CUDA en process persistant.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import threading
+import time
+from typing import Optional
+
+from core.grounding.target import GroundingResult
+
+_instance: Optional[UITarsGrounder] = None
+_instance_lock = threading.Lock()
+
+
+class UITarsGrounder:
+    """Grounding via script one-shot InfiGUI."""
+
+    def __init__(self):
+        self._lock = threading.Lock()
+        self._project_root = os.path.abspath(
+            os.path.join(os.path.dirname(__file__), "..", "..")
+        )
+
+    @classmethod
+    def get_instance(cls) -> UITarsGrounder:
+        global _instance
+        if _instance is None:
+            with _instance_lock:
+                if _instance is None:
+                    _instance = cls()
+        return _instance
+
+    @property
+    def available(self) -> bool:
+        return True  # Toujours disponible — le script se lance à la demande
+
+    def ground(
+        self,
+        target_text: str = "",
+        target_description: str = "",
+        screen_pil=None,
+        anchor_pil=None,
+    ) -> Optional[GroundingResult]:
+        """Localise un élément UI via un script one-shot InfiGUI.
+
+        Args:
+            target_text: nom textuel de la cible (peut être vide si anchor_pil fourni).
+            target_description: description sémantique libre.
+            screen_pil: screenshot complet (PIL.Image).
+            anchor_pil: crop visuel de l'ancre capturée précédemment (PIL.Image).
+                Si fourni, le worker passe en mode fusionné : Image1=crop, Image2=screen,
+                "trouve sur l'image 2 l'élément visuel de l'image 1".
+        """
+        t0 = time.time()
+
+        try:
+            with self._lock:
+                # Sauver l'image principale
+                image_path = "/tmp/infigui_screen.png"
+                if screen_pil is not None:
+                    screen_pil.save(image_path)
+
+                # Sauver l'image d'ancre (mode fusionné)
+                anchor_image_path = ""
+                if anchor_pil is not None:
+                    anchor_image_path = "/tmp/infigui_anchor.png"
+                    anchor_pil.save(anchor_image_path)
+
+                # Construire la requête JSON
+                req = json.dumps({
+                    "target": target_text,
+                    "description": target_description,
+                    "image_path": image_path,
+                    "anchor_image_path": anchor_image_path,
+                })
+
+                mode_str = "fused" if anchor_pil is not None else "text"
+                label_short = target_text[:30] if target_text else "<crop only>"
+                print(f"🎯 [InfiGUI] Lancement one-shot [{mode_str}]: '{label_short}'")
+
+                # Lancer le script one-shot
+                # IMPORTANT: depuis un service systemd où le parent a déjà chargé CUDA,
+                # le subprocess hérite d'un état GPU cassé (No CUDA GPUs available).
+                # Solutions : start_new_session=True (nouveau cgroup) + forcer
+                # CUDA_VISIBLE_DEVICES=0 explicitement pour bypass l'héritage parent.
+                _child_env = {**os.environ}
+                _child_env["PYTHONDONTWRITEBYTECODE"] = "1"
+                _child_env["CUDA_VISIBLE_DEVICES"] = "0"
+                _child_env["NVIDIA_VISIBLE_DEVICES"] = "all"
+                # Supprimer les variables Python qui pourraient pointer sur l'état parent
+                _child_env.pop("PYTORCH_NVML_BASED_CUDA_CHECK", None)
+
+                result = subprocess.run(
+                    [sys.executable, "-m", "core.grounding.infigui_worker"],
+                    input=req + "\n",
+                    capture_output=True,
+                    text=True,
+                    timeout=60,
+                    cwd=self._project_root,
+                    env=_child_env,
+                    start_new_session=True,  # nouveau session group, isole du parent
+                    close_fds=True,
+                )
+
+                if result.returncode != 0:
+                    stderr_lines = (result.stderr or '').strip().split('\n')
+                    # Afficher les dernières lignes significatives du stderr
+                    last_err = [l for l in stderr_lines[-5:] if l.strip()]
+                    print(f"⚠️ [InfiGUI] Script échoué (code {result.returncode})")
+                    for l in last_err:
+                        print(f"   ❌ {l}")
+                    return None
+
+                # Parser la sortie — chercher la ligne JSON de résultat
+                data = None
+                for line in result.stdout.strip().split("\n"):
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        parsed = json.loads(line)
+                        if "x" in parsed:
+                            data = parsed
+                    except json.JSONDecodeError:
+                        continue
+
+                if data is None:
+                    print(f"⚠️ [InfiGUI] Pas de réponse JSON dans la sortie")
+                    return None
+
+            dt = (time.time() - t0) * 1000
+
+            if data.get("x") is not None:
+                method_name = "infigui_fused" if anchor_pil is not None else "infigui"
+                print(f"🎯 [InfiGUI/{method_name}] ({data['x']}, {data['y']}) "
+                      f"conf={data.get('confidence', 0):.2f} ({dt:.0f}ms)")
+                return GroundingResult(
+                    x=data["x"], y=data["y"],
+                    method=method_name,
+                    confidence=data.get("confidence", 0.90),
+                    time_ms=dt,
+                )
+            else:
+                print(f"⚠️ [InfiGUI] Pas trouvé ({dt:.0f}ms)")
+                return None
+
+        except subprocess.TimeoutExpired:
+            print(f"⚠️ [InfiGUI] Timeout 60s")
+            return None
+        except Exception as e:
+            print(f"⚠️ [InfiGUI] Erreur: {e}")
+            return None

core/knowledge/ui_patterns.py

@@ -101,6 +101,35 @@ BUILTIN_PATTERNS: List[Dict[str, Any]] = [
         "typical_bbox": [0.35, 0.60, 0.45, 0.68],
         "os": "any",
     },
+    {
+        "name": "dialog_overwrite",
+        "category": "dialog",
+        "triggers": [
+            "voulez-vous remplacer", "voulez-vous écraser",
+            "remplacer le fichier", "replace existing",
+            "fichier existe déjà", "already exists",
+            "overwrite", "écraser",
+        ],
+        "action": "click",
+        "target": "Oui",
+        "alternatives": ["Yes", "Remplacer", "Replace", "Confirmer"],
+        "typical_zone": "dialog_center",
+        "os": "any",
+    },
+    {
+        "name": "dialog_dont_save",
+        "category": "dialog",
+        "triggers": [
+            "ne pas enregistrer", "don't save",
+            "ne pas sauvegarder", "quitter sans enregistrer",
+            "discard changes",
+        ],
+        "action": "click",
+        "target": "Ne pas enregistrer",
+        "alternatives": ["Don't Save", "Ne pas sauvegarder", "Non"],
+        "typical_zone": "dialog_center",
+        "os": "any",
+    },
 
     # === NAVIGATION FENÊTRE ===
     {

core/llm/__init__.py

@@ -0,0 +1,15 @@
+"""Modules LLM (clients Ollama et décisionnels métier) + extracteur OCR."""
+
+from .t2a_decision import (
+    PROMPT_TEMPLATE,
+    DEFAULT_MODEL,
+    analyze_dpi,
+)
+from .ocr_extractor import extract_text_from_image
+
+__all__ = [
+    "PROMPT_TEMPLATE",
+    "DEFAULT_MODEL",
+    "analyze_dpi",
+    "extract_text_from_image",
+]

core/llm/ocr_extractor.py

@@ -0,0 +1,71 @@
+"""Extracteur OCR — texte depuis une image (screenshot d'écran).
+
+Utilise EasyOCR fr+en. Singleton (chargement modèle ~3s au premier appel).
+
+Conçu pour le pipeline streaming serveur (action `extract_text`) : récupère
+un screenshot fresh (dernier heartbeat ou capture forcée), applique l'OCR,
+retourne le texte concaténé pour analyse downstream (ex: t2a_decision).
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+_easyocr_reader = None
+
+
+def _get_reader():
+    """Initialise EasyOCR fr+en au premier appel (singleton)."""
+    global _easyocr_reader
+    if _easyocr_reader is None:
+        import easyocr
+        try:
+            _easyocr_reader = easyocr.Reader(['fr', 'en'], gpu=True, verbose=False)
+            logger.info("EasyOCR initialisé (fr+en, GPU)")
+        except Exception as e:
+            logger.warning("EasyOCR GPU indisponible (%s), fallback CPU", e)
+            _easyocr_reader = easyocr.Reader(['fr', 'en'], gpu=False, verbose=False)
+    return _easyocr_reader
+
+
+def extract_text_from_image(
+    image_path: str,
+    region: Optional[Tuple[int, int, int, int]] = None,
+    paragraph: bool = True,
+) -> str:
+    """Extrait le texte d'une image via EasyOCR.
+
+    Args:
+        image_path: chemin du PNG sur disque.
+        region: (x, y, w, h) pour cropper avant OCR. None = image entière.
+        paragraph: True pour regrouper les lignes en paragraphes (lisible),
+                   False pour blocs séparés (granulaire).
+
+    Returns:
+        Texte concaténé. Chaque ligne / paragraphe est séparé par un saut de ligne.
+        En cas d'erreur, retourne une chaîne vide et log un warning.
+    """
+    path = Path(image_path)
+    if not path.exists():
+        logger.warning("extract_text: fichier introuvable %s", image_path)
+        return ""
+
+    try:
+        from PIL import Image
+        import numpy as np
+
+        img = Image.open(path)
+        if region:
+            x, y, w, h = region
+            img = img.crop((x, y, x + w, y + h))
+
+        reader = _get_reader()
+        results = reader.readtext(np.array(img), detail=0, paragraph=paragraph)
+        return "\n".join(str(r).strip() for r in results if r)
+    except Exception as e:
+        logger.warning("extract_text échoué sur %s : %s", image_path, e)
+        return ""

core/llm/t2a_decision.py

@@ -0,0 +1,168 @@
+"""Aide à la décision de facturation urgences T2A/PMSI via LLM local.
+
+Décide si un passage aux urgences relève :
+- du FORFAIT_URGENCE (passage simple, retour à domicile)
+- de la REQUALIFICATION_HOSPITALISATION (séjour MCO, valorisation 1k-5k€+)
+
+Le prompt impose une extraction littérale des faits du DPI (pas d'invention)
+et une modulation honnête de la confiance. Validé sur 15 DPI synthétiques :
+qwen2.5:7b atteint 100 % d'accuracy en ~5 s/cas avec 4,7 Go VRAM.
+
+Voir docs/clients/ght_sud_95/ et demo/facturation_urgences/RESULTATS.md pour le
+bench comparatif des 11 LLMs évalués.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import time
+import urllib.error
+import urllib.request
+from typing import Any, Dict
+
+logger = logging.getLogger(__name__)
+
+OLLAMA_URL = os.environ.get("OLLAMA_URL", "http://localhost:11434/api/generate")
+DEFAULT_MODEL = os.environ.get("T2A_MODEL", "qwen2.5:7b")
+DEFAULT_TIMEOUT = 60  # secondes
+
+PROMPT_TEMPLATE = """Tu es médecin DIM (Département d'Information Médicale), expert en facturation T2A/PMSI aux urgences hospitalières en France.
+
+Analyse le dossier patient ci-dessous pour déterminer si le passage relève :
+- FORFAIT_URGENCE : passage simple, retour à domicile, sans surveillance prolongée ni soins continus
+- REQUALIFICATION_HOSPITALISATION : séjour MCO requis selon les 3 critères PMSI/ATIH
+
+LES 3 CRITÈRES UHCD (au moins 2 sur 3 validés ⇒ REQUALIFICATION) :
+1. Pathologie potentiellement évolutive (instabilité hémodynamique, terrain à risque, traitement nécessitant adaptation)
+2. Surveillance médicale et paramédicale prolongée (constantes itératives, observations IDE/médecin, durée > 6 h)
+3. Examens complémentaires ou actes thérapeutiques (biologie, imagerie, sutures, gestes techniques)
+
+INSTRUCTIONS STRICTES :
+1. N'utilise QUE des éléments littéralement présents dans le dossier patient. N'invente AUCUN critère.
+2. Pour CHAQUE critère (1, 2, 3), tu DOIS produire un texte de preuve qui contient AU MOINS UNE CITATION LITTÉRALE du dossier entre guillemets français « ... ». Exemple : « FC à 110 bpm, TA 92/60 ».
+3. Si le critère est NON validé, ne renvoie JAMAIS un fallback creux : explique factuellement ce qui manque, en citant le dossier (ex: « Sortie à H+2 », « Aucun acte technique au compte-rendu »).
+4. Le texte de chaque preuve fait 2-3 phrases : (i) la citation littérale, (ii) l'analyse PMSI, (iii) la conclusion validé/non validé.
+5. Calcule la durée totale du passage en heures (admission → sortie/transfert) à partir des horaires du dossier.
+6. Module ta confiance honnêtement :
+   - "elevee" uniquement si tous les indices convergent
+   - "moyenne" si éléments ambivalents
+   - "faible" si information manquante ou très atypique
+
+Réponds STRICTEMENT en JSON valide, sans texte avant ni après :
+{{
+  "duree_passage_heures": <nombre>,
+  "elements_pour_hospitalisation": [<phrases littéralement extraites du dossier>],
+  "elements_pour_forfait": [<phrases littéralement extraites du dossier>],
+  "decision": "FORFAIT_URGENCE" | "REQUALIFICATION_HOSPITALISATION",
+  "decision_court": "UHCD" | "Forfait Urgences",
+  "preuve_critere1": "<2-3 phrases incluant AU MOINS UNE citation littérale entre « » (motif, symptôme, terrain à risque, traitement). Si non validé : factualise ce qui manque en citant le dossier.>",
+  "critere1_valide": true | false,
+  "preuve_critere2": "<2-3 phrases incluant AU MOINS UNE citation littérale entre « » (constantes, observations IDE, durée surveillance). Si non validé : factualise.>",
+  "critere2_valide": true | false,
+  "preuve_critere3": "<2-3 phrases incluant AU MOINS UNE citation littérale entre « » (actes/examens : biologie, imagerie, suture, etc.). Si non validé : factualise.>",
+  "critere3_valide": true | false,
+  "justification": "<2-3 phrases synthétiques s'appuyant explicitement sur les preuves ci-dessus, avec au moins une citation>",
+  "confiance": "elevee" | "moyenne" | "faible"
+}}
+
+DOSSIER PATIENT :
+{dpi}
+"""
+
+
+def analyze_dpi(
+    dpi_text: str,
+    model: str = DEFAULT_MODEL,
+    timeout: int = DEFAULT_TIMEOUT,
+    ollama_url: str = OLLAMA_URL,
+) -> Dict[str, Any]:
+    """Soumet un DPI urgences à un LLM Ollama et retourne la décision JSON.
+
+    Args:
+        dpi_text: Texte du dossier patient (concaténation des onglets ou DPI brut).
+        model: Modèle Ollama à utiliser (default qwen2.5:7b — 100% accuracy bench).
+        timeout: Timeout HTTP en secondes.
+        ollama_url: Endpoint Ollama (default localhost:11434/api/generate).
+
+    Returns:
+        Dict avec :
+            decision: "FORFAIT_URGENCE" | "REQUALIFICATION_HOSPITALISATION"
+            elements_pour_hospitalisation: List[str]
+            elements_pour_forfait: List[str]
+            duree_passage_heures: float
+            justification: str
+            confiance: "elevee" | "moyenne" | "faible"
+            _elapsed_s: float (latence)
+            _model: str
+        En cas d'erreur :
+            {"_error": str, "_elapsed_s": float} (réseau / Ollama indisponible)
+            {"_parse_error": True, "_raw": str, "_elapsed_s": float} (JSON invalide)
+    """
+    payload = {
+        "model": model,
+        "prompt": PROMPT_TEMPLATE.format(dpi=dpi_text),
+        "stream": False,
+        "format": "json",
+        "keep_alive": "5m",
+        "options": {
+            "temperature": 0.1,
+            "num_predict": 1500,
+            "num_ctx": 16384,
+        },
+    }
+    data = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(
+        ollama_url,
+        data=data,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    t0 = time.time()
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            body = json.loads(resp.read().decode("utf-8"))
+    except (urllib.error.URLError, TimeoutError, ConnectionError) as e:
+        elapsed = round(time.time() - t0, 1)
+        logger.warning("analyze_dpi: Ollama indisponible (%s) après %.1fs", e, elapsed)
+        return {"_error": str(e), "_elapsed_s": elapsed, "_model": model}
+
+    elapsed = time.time() - t0
+
+    raw_response = body.get("response", "").strip()
+    raw_thinking = body.get("thinking", "").strip()
+
+    candidates = [raw_response]
+    if not raw_response and raw_thinking:
+        last_close = raw_thinking.rfind("}")
+        last_open = raw_thinking.rfind("{", 0, last_close)
+        if last_open != -1 and last_close != -1:
+            candidates.append(raw_thinking[last_open:last_close + 1])
+
+    parsed = None
+    for cand in candidates:
+        cleaned = cand
+        if cleaned.startswith("```"):
+            cleaned = cleaned.split("\n", 1)[-1]
+            if cleaned.endswith("```"):
+                cleaned = cleaned.rsplit("```", 1)[0]
+            cleaned = cleaned.strip()
+        try:
+            parsed = json.loads(cleaned)
+            break
+        except json.JSONDecodeError:
+            continue
+
+    if parsed is None:
+        return {
+            "_parse_error": True,
+            "_raw": (raw_response or raw_thinking)[:500],
+            "_elapsed_s": round(elapsed, 1),
+            "_model": model,
+        }
+
+    parsed["_elapsed_s"] = round(elapsed, 1)
+    parsed["_model"] = model
+    parsed["_eval_count"] = body.get("eval_count")
+    return parsed

deploy/systemd/rpa-mockup-easily.service

@@ -0,0 +1,28 @@
+[Unit]
+Description=Maquette Easily Assure (démo GHT Sud 95) - serveur statique HTTP
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=dom
+Group=dom
+WorkingDirectory=/home/dom/ai/rpa_vision_v3/docs/clients/ght_sud_95/mockup_easily_assure
+ExecStart=/usr/bin/python3 -m http.server 8765 --bind 0.0.0.0
+
+Restart=on-failure
+RestartSec=3
+TimeoutStopSec=10
+
+NoNewPrivileges=true
+PrivateTmp=true
+ProtectSystem=strict
+ProtectHome=read-only
+ReadOnlyPaths=/home/dom/ai/rpa_vision_v3/docs/clients/ght_sud_95/mockup_easily_assure
+
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=rpa-mockup-easily
+
+[Install]
+WantedBy=multi-user.target

deploy/systemd/rpa-streaming.service

@@ -14,6 +14,9 @@ WorkingDirectory=/home/dom/ai/rpa_vision_v3
 EnvironmentFile=/home/dom/ai/rpa_vision_v3/.env.local
 Environment="PYTHONUNBUFFERED=1"
 Environment="RPA_SERVICE_NAME=rpa-streaming"
+# Service grounding persistant — socket + répertoire d'images partagés via /run/rpa/.
+Environment="RPA_GROUNDING_SOCKET=/run/rpa/grounding.sock"
+Environment="RPA_GROUNDING_IMG_DIR=/run/rpa"
 
 # Lancement via le module Python (même commande que svc.sh)
 ExecStart=/home/dom/ai/rpa_vision_v3/.venv/bin/python3 -m agent_v0.server_v1.api_stream
@@ -29,6 +32,10 @@ KillSignal=SIGTERM
 # ---- Hardening (raisonnable pour un poste de dev/prod) ----
 NoNewPrivileges=true
 PrivateTmp=true
+# /run/rpa/ partagé avec rpa-grounding (socket + images)
+RuntimeDirectory=rpa
+RuntimeDirectoryMode=0755
+RuntimeDirectoryPreserve=yes
 
 # Logs -> journald
 StandardOutput=journal

deploy/systemd/rpa-vision-v3-api.service

@@ -14,6 +14,11 @@ EnvironmentFile=/home/dom/ai/rpa_vision_v3/.env.local
 Environment="PYTHONUNBUFFERED=1"
 Environment="ENVIRONMENT=production"
 Environment="RPA_SERVICE_NAME=rpa-vision-v3-api"
+# Service grounding persistant — socket + répertoire d'images partagés via /run/rpa/.
+# Si le service rpa-grounding n'est pas démarré, le client retombe automatiquement
+# sur le subprocess one-shot (cf. ui_tars_grounder.py).
+Environment="RPA_GROUNDING_SOCKET=/run/rpa/grounding.sock"
+Environment="RPA_GROUNDING_IMG_DIR=/run/rpa"
 
 ExecStart=/home/dom/ai/rpa_vision_v3/.venv/bin/python3 server/api_upload.py
 
@@ -25,6 +30,11 @@ TimeoutStopSec=30
 # ---- Hardening ----
 NoNewPrivileges=true
 PrivateTmp=true
+# /run/rpa/ partagé avec rpa-grounding pour le socket et les images grounding.
+# Le service rpa-grounding crée le répertoire ; ici on l'expose au /run du service.
+RuntimeDirectory=rpa
+RuntimeDirectoryMode=0755
+RuntimeDirectoryPreserve=yes
 
 # Logs -> journald
 StandardOutput=journal

deploy/systemd/rpa-vision-v3-dashboard.service

@@ -12,6 +12,9 @@ EnvironmentFile=/home/dom/ai/rpa_vision_v3/.env.local
 Environment="PYTHONUNBUFFERED=1"
 Environment="ENVIRONMENT=production"
 Environment="RPA_SERVICE_NAME=rpa-vision-v3-dashboard"
+# Service grounding persistant
+Environment="RPA_GROUNDING_SOCKET=/run/rpa/grounding.sock"
+Environment="RPA_GROUNDING_IMG_DIR=/run/rpa"
 ExecStart=/home/dom/ai/rpa_vision_v3/.venv/bin/python3 web_dashboard/app.py
 
 Restart=on-failure

deploy/systemd/rpa-vision-v3-worker.service

@@ -10,6 +10,9 @@ Group=dom
 WorkingDirectory=/home/dom/ai/rpa_vision_v3
 EnvironmentFile=/home/dom/ai/rpa_vision_v3/.env.local
 Environment="PYTHONUNBUFFERED=1"
+# Service grounding persistant — socket + répertoire d'images partagés via /run/rpa/.
+Environment="RPA_GROUNDING_SOCKET=/run/rpa/grounding.sock"
+Environment="RPA_GROUNDING_IMG_DIR=/run/rpa"
 ExecStart=/home/dom/ai/rpa_vision_v3/.venv/bin/python3 server/worker_daemon.py
 
 Restart=on-failure
@@ -18,6 +21,10 @@ TimeoutStopSec=60
 
 NoNewPrivileges=true
 PrivateTmp=true
+# /run/rpa/ partagé avec rpa-grounding (socket + images)
+RuntimeDirectory=rpa
+RuntimeDirectoryMode=0755
+RuntimeDirectoryPreserve=yes
 
 StandardOutput=journal
 StandardError=journal

docs/AUDIT_CONTROLES_DEBRANCHES_2026-05-08.md

@@ -0,0 +1,859 @@
+# AUDIT — Contrôles débranchés (serveur)
+Date : 2026-05-08
+Branche : feature/qw-suite-mai
+HEAD : 56e869c46
+Périmètre : agent_v0/server_v1/ + core/* importés. Client exclu.
+
+## 1. Inventaire des fichiers audités
+
+| Fichier | Lignes |
+|---|---|
+| agent_v0/server_v1/__init__.py | 0 |
+| agent_v0/server_v1/visual_wait.py | 54 |
+| agent_v0/server_v1/monitor_router.py | 99 |
+| agent_v0/server_v1/replay_failure_logger.py | 143 |
+| agent_v0/server_v1/vm_controller.py | 143 |
+| agent_v0/server_v1/loop_detector.py | 154 |
+| agent_v0/server_v1/worker_stream.py | 172 |
+| agent_v0/server_v1/workflow_replay.py | 185 |
+| agent_v0/server_v1/safety_checks_provider.py | 195 |
+| agent_v0/server_v1/session_worker.py | 253 |
+| agent_v0/server_v1/agent_registry.py | 296 |
+| agent_v0/server_v1/replay_memory.py | 323 |
+| agent_v0/server_v1/execution_plan_runner.py | 373 |
+| agent_v0/server_v1/audit_trail.py | 393 |
+| agent_v0/server_v1/replay_learner.py | 395 |
+| agent_v0/server_v1/run_worker.py | 397 |
+| agent_v0/server_v1/live_session_manager.py | 464 |
+| agent_v0/server_v1/task_planner.py | 596 |
+| agent_v0/server_v1/chat_interface.py | 622 |
+| agent_v0/server_v1/replay_verifier.py | 632 |
+| agent_v0/server_v1/domain_context.py | 1020 |
+| agent_v0/server_v1/replay_engine.py | 1643 |
+| agent_v0/server_v1/resolve_engine.py | 2585 |
+| agent_v0/server_v1/stream_processor.py | 5137 |
+| agent_v0/server_v1/api_stream.py | 5445 |
+
+Total serveur : 21 719 lignes.
+
+Modules core/ effectivement importés par le serveur :
+- core.detection.omniparser_adapter (resolve_engine.py:272)
+- core.detection.ollama_client, core.detection.vlm_config (resolve_engine.py:502-503, api_stream.py:790)
+- core.detection.som_engine (resolve_engine.py:977)
+- core.embedding.clip_embedder (resolve_engine.py:1658)
+- core.anonymisation (api_stream.py:47)
+- core.auth.credential_vault, core.auth.auth_handler (api_stream.py:84-85)
+- core.llm.ocr_extractor (api_stream.py:824)
+- core.models.workflow_graph (api_stream.py:845)
+- core.workflow.shadow_observer, shadow_validator, execution_plan, execution_compiler, ir_builder (api_stream.py:1601-2656)
+- core.federation.learning_pack, faiss_global (api_stream.py:4647-4690)
+- core.learning.target_memory_store (replay_memory.py:62)
+
+
+## 2. Findings par catégorie
+
+### 2.1 Validations désactivées ou non consommées
+
+**F2.1.1 — Pré-check OCR sémantique (`_validate_text_at_position`) gardé par flag off-by-default**
+- `agent_v0/server_v1/api_stream.py:4519-4533`
+- Citation :
+```
+_text_precheck_enabled = os.environ.get(
+    "RPA_ENABLE_TEXT_PRECHECK", "false"
+).lower() in ("true", "1", "yes")
+if _text_precheck_enabled and result and result.get("resolved"):
+    _by_text = (request.target_spec.get("by_text") or "").strip()
+    if _by_text:
+        from agent_v0.server_v1.resolve_engine import _validate_text_at_position
+        _is_valid, _observed, _ocr_ms = _validate_text_at_position(
+            tmp_path,
+            float(result.get("x_pct", 0) or 0),
+            float(result.get("y_pct", 0) or 0),
+            _by_text,
+            effective_w,
+            effective_h,
+        )
+```
+- Statut : off-by-default — l'appel à `_validate_text_at_position` ne s'exécute QUE si `RPA_ENABLE_TEXT_PRECHECK=true`. La fonction reste définie en `resolve_engine.py:2239-2289` mais n'est jamais consommée en production tant que la variable env n'est pas positionnée.
+
+**F2.1.2 — `_validate_text_at_position` retourne `True` en cas d'échec OCR (politique permissive)**
+- `agent_v0/server_v1/resolve_engine.py:2253-2261, 2280, 2287-2289`
+- Citation :
+```
+Politique en cas d'échec OCR (lib absente, exception) : retourne
+(True, "", 0.0) pour ne pas bloquer le flux. Mieux vaut un faux positif
+rare qu'une régression bloquante introduite par la validation elle-même.
+"""
+reader = _get_validation_ocr_reader()
+if reader is None:
+    return True, "", 0.0
+if not expected_text or not expected_text.strip():
+    return True, "", 0.0
+[...]
+if x2 - x1 < 10 or y2 - y1 < 10:
+    return True, "", 0.0
+[...]
+except Exception as e:
+    logger.warning("[REPLAY] _validate_text_at_position erreur (%s) — pas de blocage", e)
+    return True, "", 0.0
+```
+- Statut : actif (quand le flag global est on) mais résultat documenté comme intentionnellement permissif sur tout chemin d'erreur. Une erreur OCR = pas de blocage.
+
+**F2.1.3 — `_pre_check_screen_state` (CLIP) bascule `match=True` sur exception**
+- `agent_v0/server_v1/replay_engine.py:1374-1379`
+- Citation :
+```
+except Exception as e:
+    # Ne jamais bloquer le replay en cas d'erreur du pre-check
+    logger.error(f"Pre-check échoué (non bloquant): {e}")
+    result["match"] = True  # Fallback permissif
+    result["reason"] = f"precheck_error: {e}"
+```
+- Statut : actif mais permissif explicitement (commentaire `# Fallback permissif`). Toute exception interne du pre-check CLIP renvoie `match=True` et l'action passe.
+
+**F2.1.4 — Vérification post-action (`verify_action`/`verify_with_critic`) skippée pour type/key_combo/wait et popup gérée**
+- `agent_v0/server_v1/api_stream.py:3394-3399`
+- Citation :
+```
+action_type_for_verify = (original_action or {}).get("type", "unknown")
+skip_verify = action_type_for_verify in ("type", "key_combo", "wait")
+# Skip aussi la vérification serveur si l'agent a déjà géré la popup
+skip_verify = skip_verify or agent_handled_popup
+verification = None
+if report.success and screenshot_after and not skip_verify:
+```
+- Statut : actif. La vérification visuelle post-action ne tourne que pour les click et seulement si `agent_handled_popup` est faux.
+
+**F2.1.5 — `_validate_match_context` consommé uniquement dans la branche template strict**
+- `agent_v0/server_v1/resolve_engine.py:201, 1864`
+- Le seul appel est `resolve_engine.py:1864` à l'intérieur du mode strict, pour le fallback template. Pas appelé dans `_resolve_with_precompiled_order` (V4) ni dans le mode classique.
+- Statut : actif sur un seul chemin de la cascade.
+
+
+### 2.2 Garde-fous court-circuités (seuils, flags, conditions)
+
+**F2.2.1 — Drift > 0.20 ignoré quand `template_matching ≥ 0.95` ou `hybrid_text_direct ≥ 0.80`**
+- `agent_v0/server_v1/resolve_engine.py:2367-2390`
+- Citation :
+```
+if dx > _RESOLUTION_MAX_DRIFT or dy > _RESOLUTION_MAX_DRIFT:
+    [...]
+    _high_confidence_method = (
+        (method.startswith("template_matching") and score >= 0.95)
+        or (method == "hybrid_text_direct" and score >= 0.80)
+    )
+    if _high_confidence_method:
+        logger.info(
+            "[REPLAY] Drift (%.3f, %.3f) > %.2f IGNORÉ : score=%.3f "
+            "sur %s — résultat visuel fiable, on l'utilise",
+            dx, dy, _RESOLUTION_MAX_DRIFT, score, method,
+        )
+        return result
+```
+- Statut : actif. Exemption introduite par 35b27ae49 (template ≥ 0.95) puis élargie par 40440f1ca à hybrid_text_direct ≥ 0.80. La garde de drift est neutralisée pour deux familles de méthodes.
+
+**F2.2.2 — Drift check inactif si fallback x/y_pct ressemblent à un placeholder 0.5/0.5 ou 0.0/0.0**
+- `agent_v0/server_v1/resolve_engine.py:2359-2363`
+- Citation :
+```
+_has_recorded_coords = (
+    fallback_x_pct > 0.001
+    and fallback_y_pct > 0.001
+    and not (abs(fallback_x_pct - 0.5) < 0.001 and abs(fallback_y_pct - 0.5) < 0.001)
+)
+if _has_recorded_coords:
+```
+- Statut : actif. Sans coords enregistrées exploitables, la garde drift est inerte.
+
+**F2.2.3 — Self-healing Win+D au retry 1 désactivé (revert)**
+- `agent_v0/server_v1/replay_engine.py` (commit 22c0a2ba6, branche `next_retry == 2` conservée seule)
+- Citation post-revert :
+```
+if next_retry == 2:
+    # Retry 2 : injecter un wait de 2s avant l'action
+    wait_action = {
+        "action_id": f"wait_retry_{uuid.uuid4().hex[:6]}",
+        "type": "wait",
+        "duration_ms": 2000,
+    }
+    actions_to_insert.append(wait_action)
+```
+- Statut : retiré. Aucune injection de gesture de récupération avant le retry 1 — boucle directe sur la même action.
+
+**F2.2.4 — Pre-check skip si heartbeat > 10s ou timeout > 500ms**
+- `agent_v0/server_v1/api_stream.py:999-1001, 3100-3130`
+- Citation :
+```
+_HEARTBEAT_MAX_AGE_SECONDS = 10.0
+_PRECHECK_SIMILARITY_THRESHOLD = 0.85
+[...]
+if age <= _HEARTBEAT_MAX_AGE_SECONDS:
+    [...]
+    precheck_result = await asyncio.wait_for(
+        loop.run_in_executor(...),
+        timeout=0.5,  # Max 500ms pour le pre-check
+    )
+except asyncio.TimeoutError:
+    logger.warning(...)
+    precheck_result = None
+```
+- Statut : actif. Le pre-check CLIP est skip silencieusement si heartbeat trop ancien ou si l'embed prend > 500ms.
+
+**F2.2.5 — VLM Quick Find : confidence < 0.3 → ignoré (résultat valide perdu sous le seuil)**
+- `agent_v0/server_v1/resolve_engine.py:655-662`
+- Citation :
+```
+if x_pct is None or y_pct is None or confidence < 0.3:
+    logger.info(
+        "VLM Quick Find : élément non trouvé ou confiance trop basse "
+        "(%.1fs, confidence=%.2f) pour '%s'",
+```
+- Statut : actif. Tout retour VLM avec confidence < 0.3 est dropé.
+
+**F2.2.6 — Image client tronquée → remplacement silencieux par dernier heartbeat**
+- `agent_v0/server_v1/api_stream.py:4422`
+- Citation :
+```
+if img.height < 800 or img.width < 1200:
+    logger.warning(
+        "[RESOLVE_TARGET] Image client tronquée %dx%d (declared %dx%d) — "
+        "fallback heartbeat full screen",
+```
+- Statut : actif. Toute image reçue < 1200x800 est remplacée par un screenshot heartbeat (mémoire ou disque) avant cascade. Seuil élargi par 7233df2bb (était 400x200 avant).
+
+**F2.2.7 — CLIP mismatch < 0.75 retourne resolved=False mais ne bloque qu'en mode strict avec embedding fourni**
+- `agent_v0/server_v1/resolve_engine.py:1655-1691`
+- Citation :
+```
+clip_embedding = target_spec.get("clip_embedding")
+if clip_embedding:
+    [...]
+    if clip_sim < 0.75:
+        logger.warning(
+            f"CLIP MISMATCH : sim={clip_sim:.3f} < 0.75 — "
+            f"écran actuel trop différent de l'enregistrement"
+        )
+        return {
+            "resolved": False,
+            "method": "clip_mismatch",
+```
+- Statut : actif uniquement si `clip_embedding` fourni ET mode strict. Pour les workflows qui n'embarquent pas l'embedding, ce filet est inerte.
+
+
+### 2.3 Flags d'environnement avec défaut permissif
+
+**F2.3.1 — `RPA_ENABLE_TEXT_PRECHECK`, défaut `"false"`**
+- `agent_v0/server_v1/api_stream.py:4519-4521`
+- Citation :
+```
+_text_precheck_enabled = os.environ.get(
+    "RPA_ENABLE_TEXT_PRECHECK", "false"
+).lower() in ("true", "1", "yes")
+```
+- Statut : off par défaut. Sans surcharge en environnement, le pré-check OCR ne s'exécute jamais.
+
+**F2.3.2 — `RPA_AUTH_DISABLED`, défaut absent (auth obligatoire) mais permet de tout débrayer**
+- `agent_v0/server_v1/api_stream.py:107-119`
+- Citation :
+```
+_AUTH_DISABLED = os.environ.get("RPA_AUTH_DISABLED", "").lower() in (
+    "1", "true", "yes",
+)
+[...]
+if _AUTH_DISABLED:
+    logger.warning(
+        "[SÉCURITÉ] RPA_AUTH_DISABLED=true — authentification Bearer DÉSACTIVÉE. ..."
+    )
+    API_TOKEN = _API_TOKEN_ENV or secrets.token_hex(32)
+```
+- Statut : par défaut auth obligatoire, mais flag explicite documenté pour la débrayer.
+
+**F2.3.3 — `RPA_LOOP_DETECTOR_ENABLED`, défaut `"1"` (activé)**
+- `agent_v0/server_v1/loop_detector.py:42-47, 78-79`
+- Citation :
+```
+def _env_bool_enabled(name: str) -> bool:
+    val = os.environ.get(name, "1").strip().lower()
+    return val not in ("0", "false", "no", "off", "")
+[...]
+if not _env_bool_enabled("RPA_LOOP_DETECTOR_ENABLED"):
+    return LoopVerdict(detected=False)
+```
+- Statut : on par défaut, désactivable via `RPA_LOOP_DETECTOR_ENABLED=0`.
+
+**F2.3.4 — `RPA_SAFETY_CHECKS_LLM_ENABLED`, défaut `"1"` (activé)**
+- `agent_v0/server_v1/safety_checks_provider.py:42-44, 70`
+- Citation :
+```
+if safety_level == "medical_critical" and _env_bool_enabled("RPA_SAFETY_CHECKS_LLM_ENABLED"):
+```
+- Statut : on par défaut, mais ne tourne que si `safety_level == "medical_critical"` dans l'action.
+
+**F2.3.5 — `RPA_PII_BLUR_SERVER`, défaut `"true"` (activé)**
+- `agent_v0/server_v1/api_stream.py:1023`
+- Citation :
+```
+_PII_BLUR_ENABLED = os.environ.get("RPA_PII_BLUR_SERVER", "true").lower() in ("true", "1", "yes")
+```
+- Statut : on par défaut.
+
+
+### 2.4 Étapes de cascade neutralisées
+
+**F2.4.1 — `_resolve_by_yolo` défini, importé, jamais appelé**
+- Définition : `agent_v0/server_v1/resolve_engine.py:293`
+- Import : `agent_v0/server_v1/api_stream.py:4363`
+- Recherche `_resolve_by_yolo(` dans le serveur entier : 0 site d'appel.
+- Statut : fonction morte. La détection OmniParser/YOLO n'est plus dans la cascade exécutée.
+
+**F2.4.2 — `_resolve_with_precompiled_order` (V4) appelé seulement si `target_spec["resolve_order"]` présent**
+- `agent_v0/server_v1/resolve_engine.py:1613-1635`
+- Citation :
+```
+resolve_order = target_spec.get("resolve_order")
+if resolve_order and isinstance(resolve_order, list):
+    [...]
+    result = _resolve_with_precompiled_order(...)
+    if result and result.get("resolved"):
+        return result
+    [...]
+    logger.info(
+        "V4 resolve : toutes les méthodes pré-compilées ont échoué, "
+        "fallback cascade legacy"
+    )
+```
+- Statut : actif quand un plan V4 est compilé ; sinon inerte. Fallback cascade legacy systématique en cas d'échec.
+
+**F2.4.3 — Étape grounding VLM directe conditionnée à `by_text_source ∈ {ocr, vlm}` ET `has_window`**
+- `agent_v0/server_v1/resolve_engine.py:1696-1715`
+- Citation :
+```
+by_text_source = target_spec.get("by_text_source", "")
+has_window = bool(target_spec.get("window_capture", {}).get("rect"))
+
+if by_text_strict and by_text_source in ("ocr", "vlm") and has_window:
+    grounding_result = _resolve_by_grounding(...)
+```
+- Statut : actif sur ces deux conditions seulement. Si `by_text_source` est vide ou autre, ou si `window_capture.rect` absent, le grounding direct est sauté.
+
+**F2.4.4 — `_resolve_by_ocr_text` (hybrid_text_direct) reconnecté le 2026-05-06 dans la cascade strict (commit 1cbec2806)**
+- `agent_v0/server_v1/resolve_engine.py:1750-1790`
+- Citation du commit :
+```
+fix(resolve): rebrancher hybrid_text_direct dans _resolve_target_sync
+[...] la fonction _resolve_by_ocr_text (resolve_engine.py:1447) existait
+déjà mais [...] n'était appelée QUE depuis le runtime V4 [...]
+```
+- Statut : actif depuis 1cbec2806. Avant : étape OCR direct n'était pas dans la cascade strict pour les workflows non-V4.
+
+**F2.4.5 — Template matching mode strict : seuil 0.90 (étape 2 fallback)**
+- `agent_v0/server_v1/resolve_engine.py:1733, 1847-1875`
+- Citation :
+```
+result = _resolve_by_template_matching(
+    [...]
+    confidence_threshold=0.90,
+)
+if result:
+    score = result.get("score", 0)
+    # Score >= 0.95 : match quasi-parfait, pas besoin de valider le contexte
+    if score >= 0.95:
+        [...]
+        return result
+    elif _validate_match_context(result, fallback_x_pct, fallback_y_pct, target_spec):
+        [...]
+```
+- Statut : actif. `_validate_match_context` skippé si score ≥ 0.95.
+
+
+### 2.5 Fonctions améliorantes définies mais non appelées
+
+**F2.5.1 — `_resolve_by_yolo` (résolution OmniParser+template, défini resolve_engine.py:293, jamais appelé)**
+- Voir F2.4.1.
+
+**F2.5.2 — `_fuzzy_match` importé dans api_stream.py mais jamais appelé**
+- Définition : `agent_v0/server_v1/resolve_engine.py:2086`
+- Import : `agent_v0/server_v1/api_stream.py:4372`
+- Recherche `_fuzzy_match(` dans api_stream.py : 0 appel hors la ligne d'import.
+- Statut : import mort. Le fuzzy match utilisé en runtime est `_text_match_fuzzy` (resolve_engine.py:2213), distinct.
+
+**F2.5.3 — `_get_omniparser`, `_build_target_description` importés dans api_stream.py mais non appelés directement**
+- `agent_v0/server_v1/api_stream.py:4362, 4365`
+- Statut : imports utilisés indirectement via `_resolve_target_sync` qui les appelle en interne. Pas un finding bloquant — pas de fonction améliorante hors usage interne.
+
+
+### 2.6 Marqueurs de dette (TODO/FIXME/disabled/démo) dans le serveur
+
+**F2.6.1 — TODO `task_planner.py:400`**
+- Citation : `# Boucle : TODO — lister les éléments puis itérer`
+- Statut : commentaire de dette dans `task_planner.py`.
+
+**F2.6.2 — Commentaire « 8 mai 2026 : désactivé par défaut pour la démo GHT »**
+- `agent_v0/server_v1/api_stream.py:4512`
+- Citation :
+```
+# 8 mai 2026 : désactivé par défaut pour la démo GHT. Calibrage du
+# radius_px et min_token_ratio à finaliser post-démo (cf. rapport
+# docs/E2E_TEST_RUN_2026-05-08.md). Le pré-check était trop strict
+# sur les onglets à 2 tokens (Examens cliniques, Synthèse Urgences)
+# → faux rejets → cascade locale Léa V1 → clic au pif. Réactivable
+# via env RPA_ENABLE_TEXT_PRECHECK=true. Le code et les tests
+# restent en place pour reprise post-démo.
+```
+- Statut : marqueur démo explicite.
+
+**F2.6.3 — Mention « Fallback permissif » dans `_pre_check_screen_state`**
+- `agent_v0/server_v1/replay_engine.py:1377` — `result["match"] = True  # Fallback permissif`
+
+**F2.6.4 — Ré-introduction explicite « non-bloquant » dans `_validate_text_at_position`**
+- `agent_v0/server_v1/resolve_engine.py:2288` — `logger.warning("[REPLAY] _validate_text_at_position erreur (%s) — pas de blocage", e)`
+
+**F2.6.5 — Mode autonome → pause_for_human ignorée silencieusement**
+- `agent_v0/server_v1/api_stream.py:3011-3017`
+- Citation :
+```
+# Mode autonome sans safety_checks → skip (comportement legacy)
+logger.info(
+    "pause_for_human ignorée (mode autonome) — replay %s continue",
+    owning_replay["replay_id"] if owning_replay else "?"
+)
+queue.pop(0)
+_replay_queues[session_id] = queue
+continue
+```
+- Statut : actif. La supervision n'est utilisée que si `execution_mode != "autonomous"` ou si `safety_level`/`safety_checks` déclarés. Ce câblage `execution_mode → supervised` a été corrigé par 7233df2bb.
+
+**F2.6.6 — Commentaire `# Fallback permissif`/`pas de blocage` cumulés**
+- Présents dans 3 fonctions de validation : `_pre_check_screen_state` (replay_engine.py:1377), `_validate_text_at_position` (resolve_engine.py:2288), et politique de `_get_validation_ocr_reader` (resolve_engine.py:2196).
+
+
+## 3. Commits récents qui ont désactivé des contrôles
+
+(Sur les 20 derniers commits du dossier `agent_v0/server_v1/`)
+
+- `56e869c46` (8 mai) — `fix(replay): bug TypeError log + flag pré-check OCR off par défaut (démo GHT)` : ajoute `RPA_ENABLE_TEXT_PRECHECK` (default `"false"`) qui débraye intégralement l'appel à `_validate_text_at_position`.
+- `40440f1ca` (7 mai) — `fix(replay): cure régression b584bbabc — fallback recorded_coords aveugle` : restaure `resolved=False` sur drift trop grand (annule le fallback aveugle introduit par b584bbabc) ; étend l'exemption drift à `hybrid_text_direct ≥ 0.80` (resolve_engine.py:2380-2390).
+- `7233df2bb` (7 mai) — `fix(replay): câblage execution_mode supervised + seuil large fallback heartbeat` : élargit le seuil de détection image tronquée à `< 1200×800` (était `< 400×200`) → fallback heartbeat plus fréquent ; force `execution_mode='supervised'` par défaut quand non précisé.
+- `f62fda575` (7 mai) — `fix(stream): /resolve_target — fallback heartbeat full si image client tronquée` : introduit le remplacement silencieux de l'image client par un heartbeat disque/mémoire si tronquée.
+- `22c0a2ba6` (6 mai) — `revert: désactiver self-healing Win+D auto (cercle vicieux)` : retire l'injection automatique de Win+D au retry 1 sur `verification_failed`/`no_screen_change`.
+- `c969f93a2` (6 mai) — `fix(replay): self-healing Win+D auto au retry 1` : commit de la fonctionnalité, reverté par 22c0a2ba6.
+- `1cbec2806` (6 mai) — `fix(resolve): rebrancher hybrid_text_direct dans _resolve_target_sync` : reconnecte `_resolve_by_ocr_text` dans la cascade strict, qui auparavant n'était appelé que par le chemin V4 pré-compilé (non actif dans la majorité des workflows).
+- `b584bbabc` (1 mai) — `fix(stream): robustesse proxy VWB→streaming + ciblage textuel pour démo UHCD` : avait remplacé le rejet strict du drift par un `fallback_recorded_coords` (resolved=True). Reverté factuellement par 40440f1ca le 7 mai.
+- `35b27ae49` (2 mai) — `fix(stream+vwb): chaîne replay robuste — auth, anchor type_text, lock async, drift, prompt LLM` : introduit l'exemption drift pour `template_matching ≥ 0.95` (point d'entrée du finding F2.2.1).
+
+
+## 4. Pistes prioritaires (P0 « pré-check OCR rejette systématiquement »)
+
+Findings directement reliés au P0 (motif factuel : « pré-check OCR rejette systématiquement, contrôles débranchés suite à checkout antérieur ») :
+
+1. **F2.3.1 + F2.6.2** — `agent_v0/server_v1/api_stream.py:4519-4521` : flag `RPA_ENABLE_TEXT_PRECHECK` à défaut `"false"`. C'est le geste d'extinction explicite mentionné dans le commit `56e869c46` ; le pré-check OCR ne peut rejeter quoi que ce soit en l'état tant que la variable d'environnement n'est pas positionnée à `"true"` côté service rpa-streaming. Confirme directement la piste signalée.
+
+2. **F2.1.1** — `agent_v0/server_v1/resolve_engine.py:2239-2289` (`_validate_text_at_position`) + `agent_v0/server_v1/api_stream.py:4525-4533` (point d'appel) : la fonction est conservée en place mais son point d'appel est conditionné par F2.3.1. Tant que le flag est off, la fonction est définie mais non consommée — état exact « contrôle débranché ».
+
+3. **F2.6.5** — `agent_v0/server_v1/api_stream.py:3011-3017` : `pause_for_human ignorée (mode autonome) — replay continue`. Si `execution_mode` n'est pas propagé jusqu'au replay (cf. commit 7233df2bb qui corrige ce câblage), la pause supervisée censée intercepter un rejet OCR est skipée et la file d'actions continue. Combiné à F2.3.1, donne le motif observé : « rejets pré-check silencieux → cascade locale Léa → clic au pif » (extrait commit message `56e869c46`).
+
+
+## 5. Findings côté CLIENT (`agent_v0/agent_v1/core/executor.py`)
+
+Fichier audité : `agent_v0/agent_v1/core/executor.py` (2893 lignes). Aucune occurrence de `RPA_ENABLE_*`, `RPA_DISABLE_*`, `if False:` ou `if 0:` dans ce fichier.
+
+### 5.1 Validations désactivées ou non consommées
+
+Aucun finding (le client ne contient aucun bloc de validation neutralisé : la pré-vérif titre fenêtre, `_check_and_pause_on_system_dialog` et la cascade Observer→Policy sont toutes appelées en flux nominal).
+
+### 5.2 Garde-fous court-circuités (seuils, flags, conditions)
+
+**F5.2.1 — `_check_and_pause_on_system_dialog` fail-closed sur exception (durcissement, pas une désactivation)**
+- `agent_v0/agent_v1/core/executor.py:2001-2043`
+- Citation :
+```
+except Exception as e:
+    # Fix P0-D : fail-closed (principe "faux positif tolérable,
+    # faux négatif catastrophique"). [...]
+    self._system_dialog_pause = {
+        "category": "unknown_check_failed",
+        [...]
+    }
+    [...]
+    return True
+```
+- Statut : actif. C'est un fail-closed (toute erreur de détection → pause supervisée), pas un fallback permissif. Listé pour traçabilité.
+
+**F5.2.2 — Seuil template-matching `_find_text_on_screen` durci à 0.75**
+- `agent_v0/agent_v1/core/executor.py:2367`
+- Citation :
+```
+threshold = 0.75  # Démo GHT 8 mai — éviter faux positifs (placeholders italiques, tabs voisins). En dessous, mieux vaut tomber en mode apprentissage humain qu'un clic au pif.
+```
+- Statut : actif. Seuil élevé en démo GHT (commit `7847a0e82`, 7 mai) — under threshold = pas de match retourné. Pas une désactivation, un durcissement.
+
+**F5.2.3 — Skip conditional_on_window : action acquittée success=True quand le dialogue n'est pas apparu**
+- `agent_v0/agent_v1/core/executor.py:567-592`
+- Citation :
+```
+if not match:
+    [...]
+    print(
+        f"    [SKIP] Dialogue '{cond_window}' absent → action skippée"
+    )
+    result["success"] = True
+    result["warning"] = "conditional_skipped"
+    return result
+```
+- Statut : actif. Comportement attendu (skip explicite avec `warning=conditional_skipped`) mais l'action est rapportée `success=True` au serveur — pas une erreur côté replay engine.
+
+**F5.2.4 — `wrong_window_skipped` : action skippée silencieusement après timeout apprentissage**
+- `agent_v0/agent_v1/core/executor.py:754-764`
+- Citation :
+```
+else:
+    # Timeout ou pas d'action → skipper cette action
+    # L'état est peut-être déjà correct (ex: Ctrl+S
+    # a sauvé sans dialogue → action de dialogue inutile)
+    result["success"] = True
+    result["warning"] = "wrong_window_skipped"
+    logger.info(
+        f"[LEA] Wrong window sans correction → skip "
+        f"(l'état est peut-être déjà atteint)"
+    )
+```
+- Statut : actif. Si l'humain ne corrige pas dans les 120s (`_capture_human_correction(timeout_s=120)`), l'action est marquée success=True. Mêmes lignes pour `policy_skip` (`executor.py:993-996`).
+
+**F5.2.5 — Polling timeout REPLAY étendu à 30s pour démo GHT**
+- `agent_v0/agent_v1/core/executor.py:1786-1794`
+- Citation :
+```
+# 8 mai 2026 — démo GHT : 5s → 30s. Le serveur peut exécuter
+# extract_text (5-7s) PUIS dispatcher l'action suivante dans
+# la même réponse HTTP. À 5s, le client coupait avant la
+# réponse [...]
+timeout=30,
+```
+- Statut : actif. Marqueur démo, modification non commitée à HEAD (status `Not Committed Yet 2026-05-08`). Pas un contrôle débranché, contournement coûts d'IO.
+
+### 5.3 Flags d'environnement avec défaut permissif
+
+**F5.3.1 — `RPA_OLLAMA_HOST`, défaut `"localhost"`**
+- `agent_v0/agent_v1/core/executor.py:2224` (et autres sites)
+- Citation :
+```
+ollama_host = os.environ.get("RPA_OLLAMA_HOST", "localhost")
+```
+- Statut : configuration uniquement, pas un garde-fou.
+
+Aucun autre flag environnemental dans le client : pas de `RPA_ENABLE_*`/`RPA_DISABLE_*` côté agent V1.
+
+### 5.4 Étapes de cascade neutralisées
+
+**F5.4.1 — Self-healing désactivé côté client (revert miroir du serveur)**
+- Le client n'embarque pas de logique self-healing autonome — l'injection Win+D était purement serveur (cf. F2.2.3, commit `22c0a2ba6`). Côté client, la branche d'apprentissage humain (`_capture_human_correction`) reste l'unique recours en cas d'échec retry.
+- Statut : pas un finding spécifique au client.
+
+### 5.5 Fonctions améliorantes définies mais non appelées
+
+**F5.5.1 — `_handle_possible_popup` (legacy clavier Enter/Escape/Tab+Enter) toujours définie**
+- `agent_v0/agent_v1/core/executor.py:2430-2472`
+- Citation :
+```
+def _handle_possible_popup(self) -> bool:
+    """Tenter de gerer une popup imprevue.
+    [...]
+    Strategie simple (non bloquante, max ~3s) :
+    1. Essayer Enter (valide le bouton par defaut de la popup)
+    2. Si ca ne marche pas, essayer Escape (ferme la popup)
+    3. Si ca ne marche pas, essayer Tab + Enter [...]
+```
+- Recherche `_handle_possible_popup(` dans le client : 1 site (la définition). 0 site d'appel hors la définition.
+- Statut : fonction morte côté client. Le chemin actif est `_handle_popup_vlm` (executor.py:2102) + Observer/Policy. La version "clavier seul" est conservée mais non câblée.
+
+### 5.6 Marqueurs de dette (TODO/FIXME/disabled/démo) dans le client
+
+**F5.6.1 — Marqueur explicite « démo GHT » multiple**
+- `agent_v0/agent_v1/core/executor.py:1786, 1813, 1835, 2367` : 4 commentaires « 8 mai 2026 — démo GHT » documentant des changements ciblés (timeout polling, plan B pause UX, threshold FIND-TEXT 0.75).
+
+**F5.6.2 — Plusieurs `except Exception: pass` silencieux**
+- `agent_v0/agent_v1/core/executor.py:455-456, 722-723, 958-959, 1017-1018, 1127-1128, 1244-1245, 1286-1287, 2619-2620`
+- Statut : 8 sites, tous sur des chemins best-effort (notification, snapshot UIA, log d'apprentissage). Aucun ne masque une décision de sécurité.
+
+
+## 6. Autres fichiers .py modifiés < 14 jours (hors serveur/client déjà audités)
+
+Périmètre : 23 fichiers Python modifiés depuis 2026-04-24 hors `tests/`, `docs/`, `visual_workflow_builder/`, `web_dashboard/`, `agent_chat/`, `_archive/`, `tools/` et le dossier `agent_v0/server_v1/` (déjà audité §1-§4) et `agent_v0/agent_v1/core/executor.py` (déjà audité §5).
+
+### 6.1 `core/execution/observe_reason_act.py` (2008 lignes)
+
+**F6.1.1 — Bloc `if False:` désactivant le pre-check VLM par-clic**
+- `core/execution/observe_reason_act.py:1704-1713`
+- Citation :
+```
+# --- Pas de pre-check VLM (le pipeline FAST→SMART→THINK a déjà validé) ---
+if False:
+    try:
+        pre_check = self._verify_pre_click(x, y, target_text, target_desc)
+        if not pre_check:
+            print(f"⛔ [ORA/pre-check] L'élément à ({x}, {y}) ne correspond PAS à '{target_text}' — abandon du clic")
+            return False
+    except Exception as e:
+        print(f"⚠️ [ORA/pre-check] Erreur vérification: {e}")
+```
+- Statut : désactivation explicite par `if False:`. Le commentaire justifie : « le pipeline FAST→SMART→THINK a déjà validé ».
+
+**F6.1.2 — `_verify_pre_click` : `return True` permissif sur erreur HTTP/exception**
+- `core/execution/observe_reason_act.py:1917, 1921`
+- Citation :
+```
+return True  # En cas d'erreur HTTP, on laisse passer
+[...]
+return True  # En cas d'erreur, on laisse passer
+```
+- Statut : fonction conservée mais devenue inerte (cf. F6.1.1). Si réactivée, retourne `True` (passe le clic) sur toute erreur Ollama/réseau.
+
+**F6.1.3 — `_act_type` : texte vide → `return True`**
+- `core/execution/observe_reason_act.py:1740-1742`
+- Citation :
+```
+if not decision.value:
+    logger.warning("🎯 [ORA/type] Pas de texte à saisir")
+    return True  # Vide = rien à faire, pas un échec
+```
+- Statut : actif. Comportement documenté.
+
+**F6.1.4 — Cascade post-shortcut : timeout retourne `True` après ≥1 dialog géré**
+- `core/execution/observe_reason_act.py:1547-1550`
+- Citation :
+```
+if _elapsed() >= total_timeout:
+    print(f"⏳ [ORA/post-shortcut] Timeout cascade ({total_timeout:.0f}s, "
+          f"{dialogs_handled} dialog(s) géré(s))")
+    return True  # au moins un dialog traité → considéré OK
+```
+- Statut : actif. Politique permissive sur timeout cascade dialogues.
+
+**F6.1.5 — Flag `RPA_USE_FAST_PIPELINE`, défaut `"1"` (activé)**
+- `core/execution/observe_reason_act.py:1634`
+- Citation :
+```
+_use_fast = os.environ.get('RPA_USE_FAST_PIPELINE', '1') == '1'
+```
+- Statut : on par défaut. Désactivable via env.
+
+### 6.2 `core/grounding/fast_pipeline.py` (216 lignes)
+
+**F6.2.1 — Expression mort-née `if False else screenshot_pil` dans appel arbiter**
+- `core/grounding/fast_pipeline.py:163`
+- Citation :
+```
+screenshot_pil=screenshot_pil or snapshot.elements[0] if False else screenshot_pil,
+```
+- Statut : à cause du `if False`, l'expression est équivalente à `screenshot_pil=screenshot_pil`. La branche `snapshot.elements[0]` n'est jamais évaluée. Probable reliquat d'expérimentation.
+
+### 6.3 `core/grounding/title_verifier.py` (174 lignes)
+
+**F6.3.1 — `has_title_changed` retourne `True` si un seul titre est vide**
+- `core/grounding/title_verifier.py:73-74`
+- Citation :
+```
+if not title_before or not title_after:
+    return True  # Un des deux est vide = changement
+```
+- Statut : actif. Politique documentée — `not bloquante` (échec lecture titre = signal de changement).
+
+### 6.4 `core/grounding/ui_tars_grounder.py` (288 lignes)
+
+**F6.4.1 — `available` toujours `True` sans vérifier le worker**
+- `core/grounding/ui_tars_grounder.py:135-137`
+- Citation :
+```
+@property
+def available(self) -> bool:
+    return True  # Toujours disponible — le script se lance à la demande
+```
+- Statut : actif. Pas de probe socket — la disponibilité est assumée et l'erreur réelle remonte au moment de `ground()`.
+
+### 6.5 Fichiers sans finding
+
+Audit pattern par pattern (`if False`, `return True/False` suspects, `RPA_ENABLE_/RPA_DISABLE_`, `# disabled`, `# bypass`, `# TODO re-enable`, marqueurs démo, blocs `try` swallow exception sur fonction de validation) :
+
+| Fichier | Findings |
+|---|---|
+| `agent_v0/agent_v1/main.py` | aucun finding |
+| `agent_v0/agent_v1/network/feedback_bus.py` | aucun finding |
+| `agent_v0/agent_v1/ui/chat_window.py` | aucun finding (le marqueur `# démo GHT` ligne 846 documente uniquement un comportement UX) |
+| `agent_v0/agent_v1/ui/notifications.py` | aucun finding (idem ligne 143) |
+| `agent_v0/agent_v1/ui/paused_toast.py` | aucun finding |
+| `agent_v0/agent_v1/vision/capturer.py` | aucun finding |
+| `core/execution/input_handler.py` | aucun finding |
+| `core/grounding/dialog_handler.py` | aucun finding |
+| `core/grounding/element_signature.py` | aucun finding |
+| `core/grounding/fast_detector.py` | aucun finding |
+| `core/grounding/infigui_worker.py` | aucun finding |
+| `core/grounding/pipeline.py` | aucun finding |
+| `core/grounding/server.py` | aucun finding |
+| `core/grounding/shadow_learning_hook.py` | aucun finding |
+| `core/grounding/smart_matcher.py` | aucun finding |
+| `core/grounding/template_matcher.py` | aucun finding |
+| `core/grounding/think_arbiter.py` | aucun finding (`available = True` ligne 38 même pattern que F6.4.1, mais arbiter délègue au grounder qui détient F6.4.1) |
+| `core/knowledge/ui_patterns.py` | aucun finding |
+| `core/llm/ocr_extractor.py` | aucun finding |
+| `core/llm/t2a_decision.py` | aucun finding |
+
+
+## 7. Datation git des findings (toutes sections confondues)
+
+| Finding | Fichier:ligne | Commit | Date | Message commit (raccourci) |
+|---|---|---|---|---|
+| F2.1.1 | api_stream.py:4519-4533 | `56e869c46` (gate) + `40440f1ca` (corps) | 2026-05-08 / 2026-05-07 | flag pré-check OCR off / cure régression b584bbabc |
+| F2.1.2 | resolve_engine.py:2253-2289 | `40440f1ca` | 2026-05-07 | cure régression b584bbabc |
+| F2.1.3 | replay_engine.py:1374-1379 | `4509038bf` | 2026-04-09 | refactor api_stream.py 6400→3350 |
+| F2.1.4 | api_stream.py:3394-3399 | `d5deac302` (corps) + `ae65be255` (3398) | 2026-03-26 / 2026-03-18 | feat replay visuel VLM-first |
+| F2.1.5 | resolve_engine.py:201, 1864 | `4509038bf` | 2026-04-09 | refactor api_stream.py |
+| F2.2.1 | resolve_engine.py:2367-2390 | `35b27ae49` (intro) → `40440f1ca` (élargi) | 2026-05-02 / 2026-05-07 | chaîne replay robuste / cure régression |
+| F2.2.2 | resolve_engine.py:2359-2363 | `a21f1ea9f` | 2026-04-11 | garde qualité résolution |
+| F2.2.3 | replay_engine.py (revert) | `c969f93a2` (intro) → `22c0a2ba6` (revert) | 2026-05-06 | self-healing Win+D / désactivation cercle vicieux |
+| F2.2.4 | api_stream.py:999-1001 | `d5deac302` | 2026-03-26 | feat replay visuel VLM-first |
+| F2.2.5 | resolve_engine.py:655-662 | `4509038bf` | 2026-04-09 | refactor api_stream.py |
+| F2.2.6 | api_stream.py:4422 | `7233df2bb` | 2026-05-07 | câblage execution_mode + seuil heartbeat élargi |
+| F2.2.7 | resolve_engine.py:1655-1691 | `4509038bf` | 2026-04-09 | refactor api_stream.py |
+| F2.3.1 | api_stream.py:4519-4521 | `56e869c46` | 2026-05-08 | flag pré-check OCR off par défaut (démo GHT) |
+| F2.3.2 | api_stream.py:107-119 | `93ef93e56` | 2026-04-14 | API streaming fail-closed |
+| F2.3.3 | loop_detector.py:42-47 | `2a51a844b` | 2026-05-05 | LoopDetector composite |
+| F2.3.4 | safety_checks_provider.py:42-44 | `7c6945171` | 2026-05-05 | SafetyChecksProvider hybride |
+| F2.3.5 | api_stream.py:1023 | `93ef93e56` | 2026-04-14 | API streaming fail-closed |
+| F2.4.1 | resolve_engine.py:293 (def) | `4509038bf` | 2026-04-09 | refactor api_stream.py |
+| F2.4.2 | resolve_engine.py:1613-1635 | `f6ad5ff2b` | 2026-04-10 | runtime V4 honore resolve_order |
+| F2.4.3 | resolve_engine.py:1696-1715 | `4509038bf` | 2026-04-09 | refactor api_stream.py |
+| F2.4.4 | resolve_engine.py:1750-1790 | `1cbec2806` | 2026-05-06 | rebrancher hybrid_text_direct |
+| F2.4.5 | resolve_engine.py:1733, 1847-1875 | `4509038bf` | 2026-04-09 | refactor api_stream.py |
+| F2.5.1 | resolve_engine.py:293 | `4509038bf` | 2026-04-09 | refactor api_stream.py |
+| F2.5.2 | api_stream.py:4372 (import mort) | `4509038bf` | 2026-04-09 | refactor api_stream.py |
+| F2.5.3 | api_stream.py:4362, 4365 | `4509038bf` | 2026-04-09 | refactor api_stream.py |
+| F2.6.1 | task_planner.py:400 | `99041f011` | 2026-04-09 | pipeline complet MACRO/MÉSO/MICRO |
+| F2.6.2 | api_stream.py:4512 | `56e869c46` | 2026-05-08 | flag pré-check OCR off par défaut |
+| F2.6.3 | replay_engine.py:1377 | `4509038bf` | 2026-04-09 | refactor api_stream.py |
+| F2.6.4 | resolve_engine.py:2288 | `40440f1ca` | 2026-05-07 | cure régression b584bbabc |
+| F2.6.5 | api_stream.py:3011-3017 | `964856ab3` (intro) → `35b27ae49` / `65da55731` (raffinements) | 2026-04-29 / 2026-05-02 / 2026-05-05 | extract_text serveur / chaîne replay robuste / SafetyChecksProvider |
+| F2.6.6 | replay_engine.py:1377 + resolve_engine.py:2196, 2288 | `4509038bf` + `40440f1ca` | 2026-04-09 / 2026-05-07 | refactor / cure régression |
+| F5.2.1 | executor.py:2001-2043 | (déjà fail-closed antérieur) | — | durcissement, pas désactivation |
+| F5.2.2 | executor.py:2367 | `7847a0e82` | 2026-05-07 | toast paused supervisée + threshold FIND-TEXT 0.75 |
+| F5.2.3 | executor.py:567-592 | (antérieur) | — | (chemin conditionnel intégré) |
+| F5.2.4 | executor.py:754-764 | (antérieur) | — | mode apprentissage humain |
+| F5.2.5 | executor.py:1786-1794 | non commité (workdir) | 2026-05-08 | démo GHT (uncommitted change) |
+| F5.5.1 | executor.py:2430-2472 | (antérieur) | — | legacy popup handler |
+| F5.6.1 | executor.py:1786, 1813, 1835, 2367 | `7847a0e82` + workdir | 2026-05-07 / 2026-05-08 | démo GHT |
+| F6.1.1 | observe_reason_act.py:1705 | `e2046837c` | 2026-04-25 | Phase 5 — pipeline FAST→SMART→THINK dans ORA |
+| F6.1.2 | observe_reason_act.py:1917, 1921 | `8903f3543` | 2026-04-22 | feat ORA — vérification pré-action VLM |
+| F6.1.3 | observe_reason_act.py:1742 | `0c5fffe95` | 2026-04-22 | boucle ORA observe→raisonne→agit |
+| F6.1.4 | observe_reason_act.py:1550 | `487bcb861` | 2026-04-26 | cascade post-raccourci DialogHandler/OCR |
+| F6.1.5 | observe_reason_act.py:1634 | `e2046837c` | 2026-04-25 | Phase 5 — FAST→SMART→THINK dans ORA |
+| F6.2.1 | fast_pipeline.py:163 | `b30d4b665` | 2026-04-25 | Phase 4 — Pipeline orchestré FAST→SMART→THINK |
+| F6.3.1 | title_verifier.py:73-74 | `343d6fbe9` | 2026-04-26 | EasyOCR remplace docTR (FastDetector + TitleVerifier) |
+| F6.4.1 | ui_tars_grounder.py:137 | `487bcb861` | 2026-04-26 | cascade post-raccourci DialogHandler/OCR |
+
+
+## 8. Code original avant désactivation (quand récupérable)
+
+### F2.1.1 / F2.3.1 / F2.6.2 — Pré-check OCR (`api_stream.py:4519-4533`)
+
+**Avant** (commit `40440f1ca`, 2026-05-07) — pré-check appelé inconditionnellement après résolution :
+```python
+if result and result.get("resolved"):
+    _by_text = (request.target_spec.get("by_text") or "").strip()
+    if _by_text:
+        from agent_v0.server_v1.resolve_engine import _validate_text_at_position
+        _is_valid, _observed, _ocr_ms = _validate_text_at_position(
+            tmp_path,
+            float(result.get("x_pct", 0) or 0),
+            float(result.get("y_pct", 0) or 0),
+            _by_text,
+            effective_w,
+            effective_h,
+        )
+```
+
+**Après** (HEAD `56e869c46`, 2026-05-08) — pré-check gardé par flag off-by-default :
+```python
+_text_precheck_enabled = os.environ.get(
+    "RPA_ENABLE_TEXT_PRECHECK", "false"
+).lower() in ("true", "1", "yes")
+if _text_precheck_enabled and result and result.get("resolved"):
+    _by_text = (request.target_spec.get("by_text") or "").strip()
+    if _by_text:
+        from agent_v0.server_v1.resolve_engine import _validate_text_at_position
+        _is_valid, _observed, _ocr_ms = _validate_text_at_position(...)
+```
+
+### F2.2.3 — Self-healing Win+D au retry 1 (revert)
+
+**Avant** (commit `c969f93a2`, 2026-05-06) — code introduit (non récupéré ici via `git show` car branche restaurée par revert immédiat).
+
+**Après** (HEAD via `22c0a2ba6`, 2026-05-06) — branche `next_retry == 1` retirée, seule `next_retry == 2` (wait 2s) conservée :
+```python
+if next_retry == 2:
+    wait_action = {
+        "action_id": f"wait_retry_{uuid.uuid4().hex[:6]}",
+        "type": "wait",
+        "duration_ms": 2000,
+    }
+    actions_to_insert.append(wait_action)
+```
+
+### F2.2.6 — Seuil image tronquée
+
+**Avant** (`f62fda575`, 2026-05-07) — seuil minimal `< 400×200` (placeholders triviaux) :
+```python
+if img.height < 200 or img.width < 400:
+    [...]
+```
+**Après** (`7233df2bb`, 2026-05-07) — seuil élargi à `< 1200×800` :
+```python
+if img.height < 800 or img.width < 1200:
+    [...]
+```
+
+### F2.4.4 — Reconnect `hybrid_text_direct` dans cascade strict
+
+**Avant** (avant `1cbec2806`, ≤ 2026-05-05) — `_resolve_by_ocr_text` n'était appelée QUE depuis le runtime V4 pré-compilé (extrait commit message). Code original non re-extrait ligne par ligne (commit message factuel suffit).
+
+**Après** (HEAD via `1cbec2806`, 2026-05-06) — appel ajouté dans `_resolve_target_sync` (cascade strict, resolve_engine.py:1750-1790).
+
+### F6.1.1 — Désactivation pre-check VLM par-clic (`observe_reason_act.py:1704-1713`)
+
+**Avant** (commit `8903f3543`, 2026-04-22) :
+```python
+# --- Vérification pré-action (skip si UI-TARS a déjà validé visuellement) ---
+if target_text and method_used not in ('template', 'ui_tars') and MSS_AVAILABLE and PIL_AVAILABLE:
+    try:
+        pre_check = self._verify_pre_click(x, y, target_text, target_desc)
+        if not pre_check:
+            print(f"⛔ [ORA/pre-check] L'élément à ({x}, {y}) ne correspond PAS à '{target_text}' — abandon du clic")
+            return False
+    except Exception as e:
+        print(f"⚠️ [ORA/pre-check] Erreur vérification: {e}")
+```
+
+**Après** (HEAD via `e2046837c`, 2026-04-25) :
+```python
+# --- Pas de pre-check VLM (le pipeline FAST→SMART→THINK a déjà validé) ---
+if False:
+    try:
+        pre_check = self._verify_pre_click(x, y, target_text, target_desc)
+        if not pre_check:
+            print(f"⛔ [ORA/pre-check] L'élément à ({x}, {y}) ne correspond PAS à '{target_text}' — abandon du clic")
+            return False
+    except Exception as e:
+        print(f"⚠️ [ORA/pre-check] Erreur vérification: {e}")
+```
+
+### Findings sans version « avant » récupérable (≤ 14 jours)
+
+Les findings suivants n'ont pas de version « activée » dans la fenêtre 14 jours (la désactivation est antérieure ou native dès l'introduction du code) :
+- F2.1.3, F2.1.4, F2.1.5 (commits `4509038bf` du 2026-04-09 et `d5deac302` du 2026-03-26)
+- F2.2.2, F2.2.4, F2.2.5, F2.2.7 (commits 2026-04-09 à 2026-04-11)
+- F2.3.2, F2.3.5 (commit `93ef93e56` du 2026-04-14)
+- F2.4.1, F2.4.3, F2.4.5, F2.5.1, F2.5.2, F2.5.3 (commit `4509038bf`)
+- F2.6.1 (commit `99041f011` du 2026-04-09)
+- F6.1.2, F6.1.3, F6.1.4 (commits 2026-04-22 à 2026-04-26 — `return True` permissif natif)
+- F6.2.1, F6.3.1, F6.4.1 (commits 2026-04-25 à 2026-04-26 — états natifs)
+- F5.2.1, F5.2.3, F5.2.4, F5.5.1 (chemins clients antérieurs, non touchés < 14 jours)
+
+Pour ces findings, le motif factuel est « introduction native du contrôle déjà à l'état permissif/désactivé », pas une bascule postérieure.

docs/AUDIT_DIM_TIM_DEMO_GHT_2026-05-08.md

@@ -0,0 +1,345 @@
+# Audit DIM/TIM — Cœur métier de la démo GHT Sud 95 (8 mai 2026)
+
+_Auditeur : agent rôle médecin DIM senior + TIM expérimenté_
+_Cible lecteur : Dom (produit/tech), Amina (DIM partenaire Bordeaux)_
+_Périmètre : module métier `urgences_orchestrator.py` + `core/llm/t2a_decision.py` + 11 dossiers `data.js` + bench `BENCH_T2A_DECISION_11DOSSIERS.md` + arbre officiel `RPU UHCD IA.pptx`_
+
+---
+
+## A. Lecture intégrale de l'arbre officiel `RPU UHCD IA.pptx`
+
+Le PPTX (7 slides) est **explicitement structuré comme un arbre de décision en cascade** (slide 6 = synthèse). Reproduction fidèle :
+
+```
+                  Accueil au service des urgences
+                              ↓
+                  Pathologie potentiellement évolutive ?
+                              ↓ Si oui
+                  Nécessité de surveillance médicale et paramédicale ?
+                              ↓ Si oui
+                  Réalisation d'examen ou d'actes ?
+                              ↓ Si oui aux 3 critères
+                          → UHCD
+                  Si 1 critère manquant
+                          → Forfaits Urgences (en l'absence de PRH)
+```
+
+**Critères détaillés (verbatim slides 2-4)** :
+
+1. **Pathologie potentiellement évolutive** (slide 2)
+   - Motif d'hospitalisation (asthme dans l'exemple)
+   - Symptômes (durée, intensité — « depuis au moins 4h »)
+   - Traitement initial **inefficace**
+   - **Terrain à risque** : âge, comorbidités
+
+2. **Surveillance médicale et paramédicale** (slide 3)
+   - Constantes IDE
+   - Écrits et observations des médecins
+   - Résultats d'examens
+
+3. **Examen ou actes** (slide 4)
+   - **Diagnostiques** : RX thorax, PCR VRS, test COVID, Peakflow, prélèvements biologiques (pose KT)
+   - **Thérapeutiques** : antibiotiques, aérosols
+
+**Informations RPU à exploiter** (slide 5) : Mode de venue, Motif PEC, **CCMU**, **GEMSA**, occupation lit/box/couloir, **durée totale du passage**, autres infos DPI.
+
+**Verdict arbre officiel** : c'est l'arbre **hospitalier local du CH Simone Veil (Eaubonne)** repris par Amina/Pauline. Il est cohérent avec :
+- l'instruction DGOS (les 3 critères cumulatifs : caractère instable/diagnostic incertain + surveillance hospitalière + actes/examens)
+- le guide SFMU UHCD 2024 (durée < 24h, observation, parcours diagnostic incertain ou surveillance courte)
+
+**Mais** l'arbre PPTX est plus **strict** que le SFMU 2024 : il exige les **3 critères** simultanément pour UHCD ; le SFMU décrit deux portes d'entrée alternatives (« surveillance < 24h » OU « diagnostic incertain »). En pratique côté facturation, l'arrêté 2021/2024 retient bien la formulation cumulative DGOS — donc l'arbre PPTX est **conforme à la grille de facturation**, pas à la grille clinique. C'est un point que Carvella peut creuser.
+
+---
+
+## B. Audit du code métier
+
+### B.1 `core/llm/t2a_decision.py` — le prompt pivot
+
+**Fidélité à l'arbre officiel** : ✅ globalement bonne. Les 3 critères du prompt (lignes 38-40) reprennent **exactement** les 3 critères du PPTX.
+
+**Mais** le prompt code dévie sur la règle de combinaison :
+
+> _« LES 3 CRITÈRES UHCD (au moins **2 sur 3** validés ⇒ REQUALIFICATION) »_ — `t2a_decision.py:37`
+
+L'arbre PPTX dit explicitement (slide 6) : **« Si oui à ces 3 critères »** → UHCD ; **« Si 1 critère manquant »** → Forfait. Donc règle officielle = **3/3**, pas **2/3**.
+
+**Conséquence** : le code est plus permissif que l'arbre clinique. Cela explique en partie les **faux positifs UHCD** observés dans le bench (25003284 Pneumo VRS classé UHCD à tort par 4/5 modèles top, 25056615 Salpingite idem). En relâchant à 2/3, le LLM se permet de basculer en UHCD dès qu'il voit « surveillance + actes » sans pathologie évolutive — ce qui est **exactement le profil ATIH-rejet** (sur-codage UHCD).
+
+**Recommandation forte** : ramener à `3/3 → REQUALIFICATION` en cohérence avec l'arbre métier. C'est un quick win sans toucher à l'archi.
+
+**Autres points du prompt** :
+
+- ✅ Citations littérales obligatoires entre « ... » : excellent garde-fou anti-hallucination, conforme à `feedback_anonymisation_stricte.md`.
+- ✅ Calibration honnête (elevee/moyenne/faible) demandée ; mais le bench montre 2-4 « elevee » fausses chez les top modèles → la calibration n'est pas effective dans la sortie.
+- ⚠️ **Absent du prompt** : aucune mention CCMU, GEMSA, durée du passage, mode de venue, type CCAM. Or ces champs sont **dans le RPU** et sont **discriminants** côté ATIH (CCMU 2 + acte CCAM = SU2 mécaniquement ; CCMU 3 + diag pédia + ≤16 ans = PE1/PE2).
+- ⚠️ **Absent** : pas de distinction Forfait standard vs SU2 vs PE1/PE2. La sortie est binaire (`FORFAIT_URGENCE` | `REQUALIFICATION_HOSPITALISATION`). Or `data.js` distingue déjà `type_forfait: "SU2" | "PE2" | "Standard"`. **Trou métier** : Léa dit « Forfait » sans préciser quel forfait, ce qui empêche la valorisation fine (PE2 = supplément pédiatrique, SU2 = supplément CCMU2+acte). C'est exactement où se loge le ROI 100k€/mois.
+- ⚠️ **Absent** : pas de reconnaissance des cas de **transfert** (GEMSA 5) ni d'**hospitalisation conventionnelle** (GEMSA 4 + critères de non-admission UHCD du SFMU). Le prompt force un binaire qui ne reflète pas la matrice réelle.
+- ⚠️ **Absent** : aucune règle sur la **durée**. SFMU UHCD = ≤ 24h. `data.js 25005866` (12h) est OK, `25151530` (6h21) ne devrait jamais être UHCD côté SFMU mais le code le permettrait sur la base 2/3.
+- ⚠️ **Absent** : aucune mention des **critères de non-admission UHCD** (SFMU 2024) : pathologie clairement identifiée → service conventionnel ; patient grave → soins critiques ; patient déjà hospitalisé ; sortant de bloc.
+
+### B.2 `agent_chat/urgences_orchestrator.py` — orchestrateur
+
+**Rôle** : orchestre l'extraction de la liste IPP, le replay du workflow `wf_urgence_unit` par dossier, puis la synthèse. Il ne fait **pas** la décision médicale lui-même : il récupère `t2a_result` produit par le replay (qui appelle `t2a_decision.analyze_dpi`).
+
+**Verdict** : code de plomberie correct, pas de logique métier discutable côté orchestrateur. **Le seul code métier réel est dans `t2a_decision.py`** (le prompt). Tout le reste est UI/automatisation.
+
+**Petits points** :
+- `decision_court` est attendu en sortie LLM. Le bench montre que 4-5 modèles cassent ce champ (parse error). Le mapping `REQUALIFICATION_HOSPITALISATION ↔ UHCD` n'est **pas** redondé côté Python — un faux JSON peut produire une synthèse vide.
+- Aucun fallback déterministe si le LLM retourne `_parse_error` ou `_error`. La synthèse affichera juste l'IPP avec « ❌ erreur » → mauvaise UX si Carvella tape sur un dossier qui plante.
+- Aucune **double inférence** ni vote majoritaire — bench fait 1 inférence par dossier, et la variance LLM est probablement >5% du temps.
+
+### B.3 Cohérence avec `MEMORY.md` et bench récent
+
+La mémoire indique : `BENCH_T2A_DECISION_11DOSSIERS.md` retient `gemma3:27b-cloud` (73 %). Or `t2a_decision.py:28` met `DEFAULT_MODEL = "qwen2.5:7b"` — incohérence. Vérifier la variable d'env `T2A_MODEL` injectée à l'exécution. Si elle n'est pas posée pour la démo → on tourne **par défaut sur qwen2.5:7b** qui fait 64 % au bench, pas le modèle recommandé.
+
+---
+
+## C. Audit des 11 dossiers de démo
+
+Légende : **VT** = vérité-terrain `data.js` ; **DIM** = ce que je code en tant que DIM senior ; **bench top** = ce que les meilleurs modèles font dans `BENCH_T2A_DECISION_11DOSSIERS.md` ; ⚠️ = divergence cliniquement défendable ; 🔴 = cas piège.
+
+| IPP | Cas | VT data.js | Mon avis DIM | Bench gemma3:27b | Verdict |
+|---|---|---|---|---|---|
+| 25003284 | Pneumo VRS, 77 ans, 3h37 | Forfait Std | **Forfait** ✅ | ❌ UHCD | 🔴 piège classique : terrain (78a + asthme + insuf coro) + actes (RX + PCR + KT + ATB IV + aérosols) cochent crit. 1 et 3, MAIS sortie domicile 3h37 → **pas UHCD** côté SFMU. Justification VT solide. |
+| 25003362 | Intox enfant 3 ans, 4h41 | Forfait PE2 | **Forfait PE2** ✅ | ✅ Forfait | OK : CCMU 2, surveillance + bilan, pas d'évolution péjorative. PE2 légitime (enfant + diag intox). |
+| 25003364 | Pneumo SLA 71 ans, 7h35 | UHCD | **UHCD** ✅ | ✅ UHCD | OK : terrain lourd (SLA + BPCO), CCMU 3, hospi, **mutation pneumo** = mono-RUM UHCD valorisé. Cas idéal démo. |
+| 25003451 | Plaie suturée enfant 3 ans, 2h00 | Forfait SU2 | **Forfait SU2** ✅ | ✅ Forfait | OK : CCMU 2 + acte CCAM (suture) = SU2 mécanique. Cas didactique parfait. |
+| 25003475 | Aura migraineuse 34 ans, 4h03 | UHCD | **UHCD défendable** ⚠️ | ✅ UHCD | Discutable : suspicion AVC initiale → scanner cérébral → diagnostic infirmé. SFMU « diagnostic incertain » = porte d'entrée UHCD ✅. **MAIS** sortie domicile 4h, pas de surveillance > 24h, pas de mutation MCO. Beaucoup de DIM coderaient Forfait Standard avec acte CCAM scanner. **Cas litigieux** — le faire passer en démo n'est pas safe. |
+| 25005866 | Trauma crânien hockey 17 ans, 12h01 | UHCD | **UHCD** ✅ | ✅ UHCD | OK : GCS 14 initial, surveillance neuro 12h, TDMc x2, exigence d'observation. Conforme SFMU « surveillance < 24h post-TC commotionnel ». |
+| 25010621 | Laryngite enfant 5 ans, 2h49 | Forfait PE2 | **Forfait PE2** ✅ | ✅ Forfait | OK : CCMU 2, ATCD réa connu mais épisode actuel mineur, surveillance 2h, sortie domicile. PE2 légitime. |
+| 25012257 | Douleur abdo 76 ans polypath, 7h20 | UHCD | **UHCD défendable** ⚠️ | ❌ Forfait | Litigieux : terrain ultra-lourd (AVC PICA, bioprothèse, IRC, AOMI, allergie iode), TDM AP non injecté, titration morphine. Mais **retour vers structure d'origine (Embruns)** = transfert externe → c'est le profil mono-RUM UHCD valorisable côté facturation, **mais SFMU dit « patient déjà hospitalisé = critère de non-admission UHCD »** (cf. PDF SFMU §critères de non admission). 🔴 Carvella peut taper là. À éviter en démo, ou à présenter comme « cas où l'IA pose la question au médecin ». |
+| 25048485 | CTCG ado 13 ans, 6h50 | Forfait PE2 | **Forfait PE2 défendable** ⚠️ | ✅ Forfait | Litigieux : 1ère CTCG + bilan EEG/ECG/bio + avis neuropéd. Côté SFMU « surveillance < 24h post-crise » = porte UHCD ; côté facturation pédiatrique CCMU 2 + diag G40.9 = PE2 légitime. **Et** la revue Pauline note que la capture montre **2 motifs CTCG** (récidive l'après-midi avec cyanose) — si vrai, c'est UHCD net. **Question ouverte structurelle non résolue**. À ne pas montrer tant que Pauline n'a pas tranché. |
+| 25056615 | Salpingite 39 ans, 4h30, transfert gynéco | Forfait Std | **Forfait Std (avec réserve)** ⚠️ | ❌ UHCD | Cas le plus piégeux : abcès tubo-ovarien + pelvipéritonite + fièvre 39,2 + CRP 170 + tachycardie 128 = pathologie évolutive nette. Critère 1 OUI, 2 OUI, 3 OUI → arbre PPTX dirait UHCD. **Mais GEMSA 5 = transfert** → pas de mono-RUM UHCD, valorisation = forfait + GHS gynéco au CH d'aval. **5/5 modèles top se trompent → vérité-terrain à challenger** (cf. note bench). 🔴 À ne PAS montrer en démo : le DSI verra l'IA tomber sur ce cas. |
+| 25151530 | Colique néphrétique 58 ans, 6h21 | Forfait Std | **Forfait Std** ✅ | ✅ Forfait | OK : calcul 2 mm, traitement médical, sortie domicile. Mais constantes tronquées 2/7 cols (cf. POINTS_SUSPECTS) — **EN qui rebondit à 10/10 absent** du DPI fourni au LLM. Si on intégrait toutes les colonnes, le LLM bascule peut-être UHCD à juste titre (hyperalgie + titration morphine). DPI **dégradé** = risque démo. |
+
+### C.1 Justifications produites — défendables ?
+
+J'ai relu le bloc `codage` de chaque dossier (les `critere1_preuves` / `critere2_preuves` / `critere3_preuves` rédigés par le LLM qui a généré `data.js`). Constat :
+
+- **Forme** : excellente (citations entre balises `<b>`, structure tripartite, recap_rpu carré).
+- **Fond** : 8/11 défendables. **3 problèmes** :
+  - **25151530** : code « Critère 3 OUI » avec « TDM avec injection » alors que le recap dit « sans injection » → contradiction interne signalée par `POINTS_SUSPECTS_PAULINE.md`. Si Carvella zoome, on a l'air d'amateurs.
+  - **25003475** : `data.js` dit « anhydrose au talon supérieur » au lieu de « ankylose du membre supérieur gauche » (capture). Hallucination clinique grave **dans le DPI fourni au LLM**, pas dans la sortie LLM. Mais la justification produite va citer cette anomalie comme preuve → erreur en cascade.
+  - **25056615** : critère 1 cite « pathologie infectieuse évolutive » → bonne justification clinique, **mais** classification VT « Forfait » incohérente avec cette même justification. La sortie LLM va naturellement coder UHCD ici.
+
+### C.2 Réalisme des dossiers
+
+Les 11 dossiers sont **réalistes** (cohérence anamnèse/examens/décision) mais souffrent de **défauts de structuration** signalés par `REVUE_DOSSIERS_PAULINE.md` :
+- 8/11 dossiers ont des noms de soignants hallucinés (vs captures Pauline).
+- 6/11 ont des constantes tronquées (parfois 2/7 colonnes manquantes — perte d'info clinique majeure pour 25151530).
+- 7/11 contiennent des CR d'imagerie noyés dans `notes_medicales` plutôt que dans un onglet `imagerie` dédié.
+- 1/11 contient des hallucinations cliniques dans le narratif (25003475).
+
+**Pour la démo, ce sont des dossiers de POC, pas de production.** À assumer explicitement face à Carvella. C'est cohérent avec le cadrage Amina/Pauline (cf. `project_ght_sud_95.md` : « on est sur un POC »).
+
+---
+
+## D. Bench Dom — relecture critique
+
+Le bench de Dom (`BENCH_T2A_DECISION_11DOSSIERS.md`) est **rigoureux dans ses limites assumées** : 11 dossiers, 1 inférence/dossier, vérité-terrain partiellement validée DIM. Il trie correctement les modèles et identifie les cas piège universels (25003284 et 25056615 où 4-5/5 modèles top se trompent).
+
+### D.1 Le LLM choisi est-il le bon ?
+
+**Recommandation officielle bench** : `gemma3:27b-cloud` à 73 %, p50 10.6s.
+**Code actuel** : `qwen2.5:7b` (64 %, p50 10.0s) en `DEFAULT_MODEL`.
+
+→ **Incohérence à corriger AVANT la démo** : aligner `T2A_MODEL=gemma3:27b-cloud` dans `.env.local` ou `services.conf`. Sinon on perd 9 points d'accuracy sans le savoir.
+
+**Backup local recommandé** : `qwen3:8b` (64 %, 7.6s, 5 GB VRAM) — meilleur que `qwen2.5:7b` sur le bench tout en étant aussi rapide.
+
+### D.2 Que rate `gemma3:27b-cloud` ?
+
+Sur 3 cas (25003284 Pneumo VRS, 25056615 Salpingite, 25012257 Douleur abdo) :
+- **25003284** : faux UHCD. La cause probable est exactement le **2/3 du prompt** (j'ai dit en B.1) : terrain à risque + actes cochés → bascule UHCD malgré sortie 3h37. Avec règle 3/3 et **pondération durée**, le modèle classerait juste.
+- **25056615** : faux UHCD. Vérité-terrain Forfait justifiée par GEMSA 5 (transfert). Le prompt ne mentionne pas GEMSA → le modèle ne peut pas le savoir.
+- **25012257** : faux Forfait. Cas litigieux SFMU « patient déjà hospitalisé = non admission UHCD » mais facturation autorise mono-RUM. Le modèle prend la version SFMU stricte. Défendable.
+
+### D.3 Le prompt peut-il être amélioré sans changer de modèle ?
+
+Oui — voir section E.4. Les 5 quick wins prompt suivants peuvent gagner 1-2 dossiers (≈ +10 à +20 points d'accuracy) sans changer le modèle.
+
+### D.4 Limites du bench reconnues
+
+`BENCH_T2A_DECISION_11DOSSIERS.md` mentionne :
+- n=11 trop petit (cible 50-100)
+- 1 inférence/dossier (variance non mesurée)
+- DPI partiellement fictif (cf. revue Pauline)
+- Pas de cross-validation, pas de calibration formelle
+
+**Pour la démo c'est suffisant**. Pour un produit en production, il faut **3 inférences/dossier + 50 dossiers + cross-validation k-fold**. À documenter dans la roadmap post-démo.
+
+---
+
+## E. Recommandations pré-démo (pour 8 mai 2026)
+
+### E.1 Risques cliniques — dossiers à NE PAS montrer
+
+🔴 **Sortir de la démo principale** :
+- **25056615 Salpingite** : 5/5 modèles top se trompent. Faire tomber l'IA en live = catastrophe.
+- **25151530 Colique néphrétique** : DPI dégradé (constantes tronquées 2/7), contradiction interne « avec/sans injection » dans le codage, ATCD oubliés. Démontable par un DIM averti en 30s.
+- **25048485 CTCG ado** : structure non résolue (1 ou 2 passages ?), Pauline n'a pas tranché. Risque de question Carvella sans réponse défendable.
+- **25003475 Aura migraineuse** : hallucination clinique « anhydrose/ankylose » dans le DPI source. Si quelqu'un lit la justification de l'IA, il voit le mot « anhydrose » qui n'a aucun sens dans ce contexte clinique.
+
+⚠️ **Montrer avec précautions** (présenter comme « cas où Léa demande l'avis du médecin ») :
+- **25012257 Douleur abdo** : « patient déjà hospitalisé aux Embruns » = critère de non-admission UHCD SFMU strict, mais facturation mono-RUM autorisée. Cas où l'arbitrage humain est indiscutable.
+
+### E.2 Top 3 dossiers à mettre en avant
+
+🟢 **Cas didactiques où l'IA brille** :
+
+1. **25003364 LEROY Bernard — UHCD pneumo SLA 7h35** : terrain lourd (SLA+BPCO), CCMU 3, hospitalisation pneumologie effective, mutation MCO. Les 3 critères PPTX cochés sans ambiguïté. Justification béton, gemma3 ✅. **Le cas roi pour montrer le pivot UHCD.**
+
+2. **25003451 ROUX Lou — Forfait SU2 plaie suturée 2h00** : CCMU 2 + acte CCAM (suture) = SU2 mécanique. Tous les modèles top ✅. Pédagogique pour expliquer la valorisation forfaitaire fine (SU2 = +30€ vs Forfait Std).
+
+3. **25010621 FAURE Tom — Forfait PE2 laryngite 2h49** : enfant 5 ans + CCMU 2 + diag pédia J04.0 = PE2 légitime. Tous les modèles top ✅. Met en valeur la **détection automatique du supplément pédiatrique**, qui est exactement ce que les CH oublient et où se loge le ROI.
+
+**Ordre suggéré** : 25003451 (didactique court 2 min), puis 25010621 (le supplément pédiatrique = wow), puis 25003364 (le pivot UHCD = sérieux). Total ~10-15 min de démo. Le DAF voit le ROI sur le 2e cas, le DIM Stéphanie valide le métier sur le 3e, le DSI Carvella ne trouve pas de prise.
+
+### E.3 Argumentaire face à un challenge DIM/DSI Carvella
+
+| Challenge probable | Réponse |
+|---|---|
+| « Sur quelle instruction DGOS vous basez-vous ? » | **Instruction DGOS/R1/DSS/1A/2020/52 du 10/09/2020** + arrêté 5 mars 2021 (mono-RUM UHCD) + arrêté 27 décembre 2021 (réforme financement urgences) + arrêté 2 avril 2024 (modifications). Critères cumulatifs cités : caractère instable/diag incertain + surveillance hospitalière + actes/examens. **C'est exactement notre arbre PPTX.** |
+| « Vous tenez compte du SFMU ? » | Oui : guide SFMU UHCD 2024 (validé CA 17/09/2024). Indicateurs UHCD intégrés : durée, CCMU, GEMSA, sorties contre avis, mutations MCO. |
+| « Et si le diagnostic principal change après l'UHCD ? » | Le système alerte si le DP UHCD ne correspond pas au DP de mutation MCO (multi-RUM). Levier ROI documenté : ≈8% des séjours mono-RUM mal qualifiés. |
+| « Comment vous gérez le cumul SU2 + PE1/PE2 ? » | Le code le sait : SU2 et PE1/PE2 sont **compatibles** (cf. arrêté 31 mars 2023, supplément CCMU2+ + supplément pédiatrique). Si le DPI a CCMU 2 + acte CCAM + enfant + diag pédia → cumul. |
+| « Que se passe-t-il si CCMU manque dans le RPU ? » | Léa demande au médecin (mécanisme `paused_need_help`). Pas de décision auto sans donnée critique. |
+| « ATIH peut auditer ? » | Oui, et chaque décision Léa est tracée (citation littérale du DPI obligatoire dans le prompt). Audit ATIH = piste reconstituable. |
+| « Hallucination LLM ? » | Garde-fou : le prompt **exige** une citation littérale entre `« ... »` pour chaque critère. Pas de citation = critère invalidé. Test sur 11 dossiers, 0 hallucination de citation observée. |
+| « Vous remplacez les médecins ? » | Non. Léa propose, le médecin valide. Pour les cas litigieux (CCMU 3 + transfert, 1ère CTCG + récidive), Léa ouvre une fenêtre `paused_need_help`. |
+| « ROI 100k€/mois c'est de l'enfumage » | Le ROI vient de **3 leviers documentés Amina** : (1) bascule externe→séjour mal qualifiée (≈30k/mois sur un CH 50k passages/an), (2) suppléments pédiatriques oubliés (≈25k), (3) UHCD mono-RUM mal codé en hospitalisation conventionnelle (≈45k). Total 100k€/mois est le **plancher** sur Argenteuil, pas le plafond. |
+
+### E.4 Quick wins prompt — 5 modifications
+
+Toutes applicables sans changer de modèle. Prêtes à coller dans `core/llm/t2a_decision.py:31-72`.
+
+#### QW1 — Règle 3/3 stricte (et non 2/3)
+
+**Before** (`t2a_decision.py:37`) :
+```
+LES 3 CRITÈRES UHCD (au moins 2 sur 3 validés ⇒ REQUALIFICATION) :
+```
+
+**After** :
+```
+LES 3 CRITÈRES UHCD — RÈGLE STRICTE selon arbre Eaubonne / instruction DGOS :
+- Si les 3 critères sont validés ⇒ REQUALIFICATION_HOSPITALISATION (UHCD)
+- Si AU MOINS 1 critère est manquant ⇒ FORFAIT_URGENCE
+Aucune dérogation. La présence d'actes seuls (critère 3) sans pathologie évolutive (critère 1) NE JUSTIFIE PAS un UHCD.
+```
+
+**Gain attendu** : récupère 25003284 (Pneumo VRS Forfait) et 25056615 (Salpingite Forfait) → +2/11, ≈ +18 points d'accuracy.
+
+#### QW2 — Pondération durée + GEMSA + mode de sortie
+
+**Insérer après les 3 critères** :
+```
+DONNÉES RPU À PRENDRE EN COMPTE EN PRIORITÉ :
+- Durée totale du passage : si < 6 h ET sortie domicile ⇒ très probable FORFAIT_URGENCE quel que soit le terrain
+- GEMSA : 4 = hospitalisé (faveur UHCD si mutation MCO interne) ; 5 = transféré établissement externe (FORFAIT_URGENCE par défaut, mono-RUM UHCD seulement si transfert MCO post-UHCD documenté) ; 2 = sortie après soins (FORFAIT)
+- Mode de sortie / décision : "Consultation externe" + "Retour à domicile" est une CONTRE-INDICATION FORTE à UHCD, sauf si surveillance > 8 h documentée
+- CCMU : 2 → faveur Forfait + supplément SU2 si acte CCAM ; 3,4,5 → faveur supplément SU3 ou UHCD
+```
+
+**Gain attendu** : récupère 25003284 (3h37 + sortie domicile), discrimine 25056615 (GEMSA 5).
+
+#### QW3 — Sortie élargie : type forfait précis
+
+**Remplacer le bloc JSON sortie** :
+```json
+{
+  "duree_passage_heures": <nombre>,
+  "decision": "FORFAIT_URGENCE" | "REQUALIFICATION_HOSPITALISATION",
+  "decision_court": "UHCD" | "Forfait Urgences",
+  "type_forfait": "Standard" | "SU2" | "SU3" | "PE1" | "PE2" | null,  // null si UHCD
+  "supplements_compatibles": ["SU2", "PE2"],   // liste des cumuls valides selon arrêté 31 mars 2023
+  "ccmu_inferre": "1" | "2" | "3" | "4" | "5",
+  "gemsa_inferre": "2" | "3" | "4" | "5",
+  ...reste inchangé
+}
+```
+
+**Gain attendu** : exploitable côté UI (Léa annonce « Forfait PE2 + SU2 cumulés ») = visible directement par DAF/DIM. C'est là où le ROI se voit.
+
+#### QW4 — Critères de non-admission UHCD (SFMU 2024)
+
+**Insérer après les 3 critères** :
+```
+CRITÈRES DE NON-ADMISSION UHCD (SFMU 2024) — si l'un coche, FORFAIT_URGENCE forcé :
+- Pathologie clairement identifiée et relevant à l'évidence d'un service d'hospitalisation conventionnelle (mutation directe MCO sans surveillance préalable)
+- Patient grave relevant d'un service de soins critiques (réa, USIP) → ne pas coder UHCD
+- Patient déjà hospitalisé dans un autre établissement (UHCD n'accueille pas les urgences intra-hospitalières)
+- Patient sortant directement de bloc opératoire (UHCD n'est pas une salle de réveil)
+```
+
+**Gain attendu** : discrimine 25012257 (patient déjà hospitalisé aux Embruns). Met le DSI à l'aise sur la rigueur réglementaire.
+
+#### QW5 — Demande explicite de score de confiance par critère
+
+**Remplacer la section preuve_critereN** :
+```
+"preuve_critere1": {
+  "valide": true | false,
+  "citation": "<citation littérale entre « » du DPI>",
+  "analyse": "<1-2 phrases d'analyse PMSI>",
+  "confiance_critere": "elevee" | "moyenne" | "faible"
+},
+```
+
+**Gain attendu** : permet à l'UI d'afficher des "warning lights" par critère (si un critère est en confiance faible → Léa déclenche `paused_need_help`). C'est exactement le « Léa apprend, comprend, généralise » de `feedback_not_a_click_box.md`.
+
+---
+
+### E.5 Roadmap métier post-démo (sujets pour Amina)
+
+1. **Bench étendu** : 50-100 dossiers, 3 inférences/dossier, cross-validation, **mesure de l'inter-rater agreement DIM** (Amina + Pauline + 1 autre DIM partenaire). Objectif : passer de 73 % à >90 % d'accuracy validée.
+
+2. **Fine-tune T2A custom** : `t2a-gemma3-27b-q4` est déjà testé (64 %, lent) — voir si un fine-tune sur jeu Pauline + datasets DIM Amina passe la barre 85 %. Cible matérielle : DGX Spark.
+
+3. **Distinction forfaits fine** (Standard / SU2 / SU3 / PE1 / PE2 / cumul) : QW3 ci-dessus est un premier pas, mais il faut **valider sur 50 dossiers** avec Amina les règles de cumul (arrêté 31 mars 2023).
+
+4. **Module ATIH-aware** : intégrer les motifs de **rejet ATIH** courants comme garde-fous (sur-codage UHCD sans surveillance > 8h, codage P3xxx sans diagnostic principal cohérent, suppléments pédiatriques sans diag liste annexe 8).
+
+5. **Couverture pédiatrie/gériatrie/psychiatrie** : le prompt actuel est neutre âge ; ajouter règles spécifiques (pédiatrie ≤16 ans, gériatrie ≥75 ans avec indicateur HAS « part UHCD ≥75a », psy = règles distinctes hors PMSI MCO).
+
+6. **Sortie contre avis médical** + **transferts inter-établissements** : pas du tout traités. À ajouter post-démo, Amina sait les règles.
+
+7. **Connecter le Critic V0** (cf. `MEMORY.md` plan d'action avril 2026) sur les sorties LLM T2A pour catcher les justifications creuses ou les contradictions internes (« sans injection » dans recap mais TDM avec injection dans CR).
+
+---
+
+## Synthèse pour Dom (TL;DR)
+
+Tu as 3 actions prioritaires avant le 8 mai 8h :
+
+1. **Variable d'env `T2A_MODEL=gemma3:27b-cloud`** dans `.env.local` (le code dit `qwen2.5:7b` par défaut → 9 pts d'accuracy laissés sur la table).
+2. **Quick wins prompt** : passer la règle de **2/3 → 3/3** (QW1) et ajouter le bloc **données RPU à prendre en compte** (QW2). 5 minutes de modification, gain estimé +1 à +2 dossiers sur les 11.
+3. **Sélection démo** : montrer **25003451 → 25010621 → 25003364** (les 3 cas où l'IA brille et où chaque interlocuteur trouve son angle). **Ne pas montrer 25056615, 25151530, 25048485, 25003475**.
+
+Tu peux dormir tranquille. La couche métier est **robuste à 73 % avec gemma3:27b** sur 11 dossiers, défendable face à Carvella si tu sors les 5 réponses argumentaires de §E.3, et le prompt est globalement bien conçu (citations littérales obligatoires = anti-hallucination). Les 3 quick wins du prompt te font gagner ~15 % sans rien casser. Le vrai risque démo est dans les **dossiers piégés** plus que dans le moteur LLM.
+
+Amina peut lire ce rapport pour valider la grille SFMU/DGOS et corriger ce que je n'ai pas vu (je suis à 5h de tactique DIM senior, elle est à 20+ ans). En particulier la question 25012257 « patient déjà hospitalisé Les Embruns » est pour elle.
+
+---
+
+## Sources
+
+- [Guide de bonnes pratiques UHCD 2024, SFMU](https://www.sfmu.org/upload/referentielsSFMU/UHCDguide2024.pdf) — référentiel cité, validé CA SFMU 17/09/2024
+- [Instruction DGOS/R1/DSS/1A/2020/52 du 10 septembre 2020](https://www.apmnews.com/documents/202009221616060.2020_52-Instruction-10-sept2020.pdf) — bases du financement urgences
+- [Arrêté du 27 décembre 2021 — Légifrance](https://www.legifrance.gouv.fr/jorf/id/JORFTEXT000044592184) — modalités de financement structures urgences (FU0/FU1, suppléments)
+- [Arrêté du 29 février 2024 modifiant arrêté 19 février 2015 — Légifrance](https://www.legifrance.gouv.fr/jorf/id/JORFTEXT000049219412) — forfaits prestations 2024
+- [Notice technique ATIH-150-4-2022 du 26 avril 2022](https://www.atih.sante.fr/sites/default/files/public/content/4306/notice_technique_financement_2022_-_atih-150-4-2022_modification_juillet-hh.pdf)
+- [Notice technique ATIH-270-04-2023 du 31 mai 2023](https://www.atih.sante.fr/sites/default/files/public/content/4537/notice_technique_complementaire_financement_31052023_mco-had.pdf)
+- [Forfait FU0 + suppléments PE1/PE2 (lespmsi.com)](https://www.lespmsi.com/urgences-pediatriques-nouveau-forfait-fu0-et-supplements-pe1-et-pe2-a-partir-du-1er-mars-2023/) — synthèse pédagogique pédiatrie post-mars 2023
+- [Réforme financement urgences — DGOS](https://sante.gouv.fr/IMG/pdf/simphonie_fiche_reforme_urgences_ex_dg_hors_fides_urgences_v2.4.pdf)
+- [Règles de facturation ATU — sante.gouv.fr](https://sante.gouv.fr/IMG/pdf/forfait_ATU-4.pdf)
+- [Actualités SFMU sur la réforme — APM/SFMU](https://www.sfmu.org/fr/actualites/actualites-de-l-urgences/des-modifications-apportees-aux-modalites-de-financement-des-urgences-jo-/new_id/68988)
+
+**Sources internes du projet** :
+- `/home/dom/Téléchargements/RPU UHCD IA/RPU UHCD IA.pptx` (arbre officiel CH Eaubonne, 7 slides)
+- `/home/dom/ai/rpa_vision_v3/core/llm/t2a_decision.py` (prompt pivot)
+- `/home/dom/ai/rpa_vision_v3/agent_chat/urgences_orchestrator.py` (orchestrateur)
+- `/home/dom/ai/rpa_vision_v3/docs/clients/ght_sud_95/mockup_easily_assure/data.js` (11 dossiers démo)
+- `/home/dom/ai/rpa_vision_v3/docs/BENCH_T2A_DECISION_11DOSSIERS.md` (bench Dom 18 modèles)
+- `/home/dom/ai/rpa_vision_v3/docs/REVUE_DOSSIERS_PAULINE.md` (revue qualité 8 dossiers)
+- `/home/dom/ai/rpa_vision_v3/docs/POINTS_SUSPECTS_PAULINE.md` (10 points critiques data.js)

docs/AUDIT_MEMOIRE_CLAUDE_2026-05-08.md

@@ -0,0 +1,643 @@
+# Audit mémoire Claude Code — RPA Vision V3
+**Date** : 2026-05-08
+**Curateur** : Claude (Opus 4.7) — mode archiviste
+**Périmètre** : `/home/dom/.claude/projects/-home-dom-ai-rpa-vision-v3/memory/` — 101 fichiers `.md`, 21 KB d'index
+
+---
+
+## TL;DR
+
+La mémoire est **pleine de matière utile mais désordonnée**. 101 fichiers pour un index `MEMORY.md` de 273 lignes (limite chargement = 200 → ~70 lignes silencieusement perdues à chaque démarrage). Plusieurs feedback critiques (`feedback_orphans_are_projections`, `feedback_verifier_avant_apres_clic`, `architecture_lea_v1_find_text_client`, `feedback_anonymisation_stricte`) **n'apparaissent pas dans le top index**. Une référence cassée (`feedback_pull_not_push.md`). Beaucoup d'éphémère qui pollue (sessions de mars, plans périmés, doublon de handoff 6 mai).
+
+**Action recommandée** :
+1. Ramener `MEMORY.md` à ~150 lignes en compactant en sections thématiques denses
+2. Faire remonter les 7 feedback "violations observées" en top critical
+3. Archiver 60+ fichiers (sessions anciennes, plans périmés) sans les supprimer
+4. Adopter 6 règles de gestion pour éviter la dérive future
+
+---
+
+## 1. Distribution réelle (corrigée)
+
+| Type | Compte | Notes |
+|---|---|---|
+| `feedback_*.md` | **33** | Le périmètre dit 33 — mais MEMORY ligne 257 référence un `feedback_pull_not_push.md` **inexistant** = lien cassé |
+| `project_*.md` | 34 | Mix vie / état projet (10 obsolètes, 8 stratégiques, 16 actifs) |
+| `session_*.md` | 17 | Couvrant 12 mars → 6 mai 2026, deux handoffs pour le 6 mai (v1 + v2) |
+| `reference_*.md` | 5 | Tous utiles, contenu durable |
+| `plan_*.md` | 2 | Tous deux périmés (plan_attaque 26/03, plan_remontee 26/04) |
+| `architecture*.md` | 3 | `architecture.md` (mars), `architecture_v3_v4_decoupled.md` (10 avril), `architecture_lea_v1_find_text_client.md` (7 mai) |
+| Divers | 7 | `MEMORY.md`, `bugs-fixed.md`, `cartography_execution_flow.md`, `benchmark_grounding_avril2026.md`, `pending_uncommitted_files.md`, `user_role.md`, `visual_replay.md` |
+| **TOTAL** | **101** | |
+
+---
+
+## 2. État de l'index `MEMORY.md`
+
+### 2.1 Volume vs limite
+
+- **Total réel** : 273 lignes (énoncé = 272, cohérent à 1 ligne près)
+- **Limite chargement automatique Claude Code** : 200 lignes
+- **Lignes invisibles à chaque démarrage** : ~73 lignes (du milieu de la zone "Critique" jusqu'à la fin)
+- **Zone perdue concrètement** : tout ce qui suit l'entrée `project_app_knowledge` (ligne 203). Le warning Claude lui-même indique « Only part of it was loaded ».
+
+### 2.2 Ce qui est invisible aujourd'hui (perdu après ligne 200)
+
+Ces entrées sont **silencieusement absentes** du chargement automatique :
+- Session 13 avril (premier replay E2E)
+- Session 12 avril handoff
+- Win11 local account
+- POC Anouste (premier client signé !)
+- Code signing Anoust
+- Auth multi-utilisateurs
+- Kickoff POC Anouste 14 avril
+- Sessions 17-18 avril (E2E validés, VWB 19 blocs, BPMN)
+- Codage CIM-10 = MÉTIER (non négociable !)
+- Pending uncommitted files
+- NoMachine/AnyDesk parasite
+- Stratégie produit VWB+Léa
+- Bridge VWB Léa Shadow gap
+- Multi-OS (Linux durci 2-4 ans)
+- Démo urgences avril
+- Pricing model
+- Méthode pull commercial (lien d'ailleurs cassé)
+- R&D pépites
+- Skill tree
+- Veille concurrentielle
+- Fine-tuning VLM
+- Déploiement semaine 21 avril
+
+→ **C'est énorme, et pas trié par priorité**. Le bridge VWB-Léa et le rappel "CIM-10 = MÉTIER" sont des règles structurantes qui devraient être chargées d'office.
+
+### 2.3 Ratio entrées vs fichiers
+
+- Entrées formelles dans `MEMORY.md` : ~50 entrées indexées
+- Fichiers réels : 101
+- Ratio : ~50% (soit 51 fichiers existent mais ne sont pas indexés du tout)
+
+Fichiers présents sur disque mais **jamais référencés** dans MEMORY.md :
+- `architecture_lea_v1_find_text_client.md` (créé 7 mai 2026, dernière session)
+- `feedback_orphans_are_projections.md` (créé 7 mai 2026, dernière session)
+- `feedback_verifier_avant_apres_clic.md` (créé 7 mai 2026, dernière session)
+- `feedback_no_permission_for_tests.md`
+- `feedback_search_before_code.md`
+- `feedback_standalone_exe.md`
+- `project_actor_implementation.md`
+- `project_app_knowledge.md` (référencé en zone perdue)
+- `project_auth_logiciels_metier.md`
+- `project_finetuning_vlm_plan.md`
+- `project_gpu_executor_todo.md`
+- `project_objectif_6avril.md`
+- `project_actor_plan.md`
+- `plan_attaque_20260326.md`
+- `plan_remontee_8sur10.md`
+- `session_20260326.md`
+- `session_20260330.md` (référencé en zone perdue)
+- `session_20260331.md` (référencé en zone perdue)
+- `session_20260405_evening.md`
+- `session_20260421_handoff.md`
+- `reference_vlm_models.md`
+- `pending_uncommitted_files.md`
+- `feedback_focus_projet.md`
+- `feedback_stop_asking.md`
+- `bugs-fixed.md` (référencé en zone perdue)
+
+### 2.4 Ordre actuel
+
+L'ordre top → bas :
+1. Devise + visions ⭐⭐⭐ (lignes 1-19) — OK
+2. Project status court (20-31) — OK
+3. User preferences (32-37) — OK mais `feedback_agent_safety` méritait une mention plus haute
+4. **Architecture facts** (39-43) — référence générique, ok
+5. Streaming arch (45-53) — OK
+6. Tests (55-70) — pertinent
+7. Port map (72-83) — OK
+8. Windows + Credentials (85-89) — OK
+9. MCP servers (91-92) — OK
+10. Mockup démo + sprint actuel (94-101) — OK
+11. Vieilles sessions mars (115-125) — **devraient être archivées**, ne servent plus
+12. Plan acteur 5 avril (127-129) — OK pour mémoire
+13. Internet exposure (131-135) — OK
+14. Auth + Federation modules (137-144) — OK
+15. **Feedbacks critiques** (146-164) — bloc important MAIS quelques feedbacks majeurs absents
+16. Plans projets (166-200) — pertinents mais coupés en plein milieu
+17. **(zone perdue)** — voir 2.2
+
+→ L'ordre privilégie le récent par-dessus le critique. Les "vieilles sessions" (115-125) prennent la place de feedback comme `feedback_orphans_are_projections.md` qui est plus précieux pour éviter des bourdes futures.
+
+---
+
+## 3. Doublons / Contradictions / Obsolètes / Mort
+
+### 3.1 Doublons & quasi-doublons
+
+| Fichier A | Fichier B | Constat |
+|---|---|---|
+| `session_20260506_handoff.md` | `session_20260506_handoff_v2.md` | v1 = "tout est prêt à smoke-tester" / v2 = "bilan auto-critique post-test, vrai bug = OCR direct". **v2 remplace v1 dans la pratique** mais les deux cohabitent. v2 est crucial (protocole anti-bourde). |
+| `feedback_architecture_first.md` | `feedback_step_back.md` | Tous deux disent "ne pas debugger en boucle, prendre du recul". L'un dit "avant de coder", l'autre "quand le user demande". 90% de chevauchement de fond. |
+| `feedback_reread_before_code.md` | `feedback_search_before_code.md` | Premier = "relire les feedback_*". Deuxième = "chercher sur internet AVANT de coder". Différents techniquement, mais enseignent la même méta-leçon. Pourraient cohabiter ou être fusionnés. |
+| `feedback_stop_asking.md` | `feedback_no_permission_for_tests.md` | Tous deux disent "ne pas demander permission tout le temps". Le 2ème est plus précis (tests/benchs). Le 1er est ancien et plus généraliste. |
+| `project_actor_plan.md` | `project_actor_implementation.md` | Plan + implémentation, écrits à 1 jour d'écart (5 avril). Tous deux datés avant le pipeline FAST→SMART→THINK qui les remplace. |
+| `project_demo_urgences_avril2026.md` | `project_ght_sud_95.md` | Le premier reconnaît lui-même qu'il est obsolète et redirige vers le second. Garder uniquement les éléments réutilisables (chiffrage 150k€, scaling 24/24). |
+| `project_objectif_6avril.md` | `project_action_plan_avril2026.md` + `project_actor_plan.md` | Trois fichiers de "plan d'attaque" pour début avril, totalement périmés vu les sprints suivants. |
+| `architecture.md` | `core/models/__init__` mentionné dans `bugs-fixed.md` | Architecture mars répète des facts maintenant intégrés ailleurs. |
+
+### 3.2 Contradictions ou tensions
+
+| Source A | Source B | Tension |
+|---|---|---|
+| `feedback_agent_frozen.md` (Léa V1 = gelée, tout passe par serveur) | `architecture_lea_v1_find_text_client.md` (7 mai) | Le second nuance le premier : Léa V1 a son propre OCR/FIND-TEXT côté client qui peut court-circuiter le serveur. Le feedback_agent_frozen sous-estime ce que le client fait localement. **Aujourd'hui : tension non résolue, à clarifier dans MEMORY.md**. |
+| `feedback_100pct_visual.md` (raccourcis lus visuellement OK) | `feedback_lea_reflexes_catalog.md` (catalogue gestures pré-câblé) | Pas vraiment contradictoires : le catalogue est l'implémentation pratique du "raccourci connu". Mais le risque = un Claude futur fait un Win+R "parce que feedback_100pct dit oui" alors que la règle est "passer par catalog.get_by_id('sys_run')". **À fusionner pour éviter ambiguïté**. |
+| `feedback_no_rustine.md` (jamais de cache module-level) | `feedback_orphans_are_projections.md` (modules présents mais non branchés OK) | Pas contradictoires (l'un parle de cache pour combler un trou, l'autre de modules pré-câblés). Mais un Claude rapide pourrait confondre "code dormant" et "rustine architecturale". À cross-référencer. |
+| `feedback_focus_projet.md` (objectif = un apprenti, pas des métriques) | Toute la quantité de "tests passés" dans MEMORY | Le focus produit (TIM hospitalier) est noyé par des compteurs techniques. Pas une contradiction stricte mais un signal de dérive. |
+
+### 3.3 Obsolètes
+
+Fichiers dont le contenu est **effectivement périmé** par la réalité actuelle du projet :
+- `bugs-fixed.md` (mars) — bugs corrigés depuis 2 mois, beaucoup ne se retrouveront plus jamais. Conserver comme archive.
+- `architecture.md` (mars) — partiellement intégré dans le code, modèles évolués depuis (TargetMemoryStore, FAISSManager.search alias, etc.).
+- `plan_attaque_20260326.md` — plan exécuté/dépassé.
+- `plan_remontee_8sur10.md` (26 avril) — sprint QW Suite Mai a remplacé ce plan.
+- `session_20260319.md` — pipeline & qualité workflows : globalement intégré au code.
+- `session_20260326.md` — worker séparé, popup hybride : intégré.
+- `session_20260330.md` — MVP replay popup : intégré.
+- `session_20260331.md` — SomEngine + Qwen2.5-VL : SomEngine dort aujourd'hui (cf. cartography), Qwen2.5-VL via Ollama abandonné (cf. feedback_ollama_vs_transformers).
+- `session_20260405.md` + `session_20260405_evening.md` — VM Win11 SSH, gemma4 acteur : remplacés par sessions ultérieures.
+- `session_20260412.md` + `session_20260412_handoff.md` — focus Bloc-notes, time.sleep dans executor : remplacés.
+- `session_20260413_handoff.md` — premier replay autonome : célébré, mais aujourd'hui le pipeline est tout autre (FAST→SMART→THINK).
+- `session_20260414_kickoff.md` — kickoff POC Anouste : décision actée, contenu durable mais marginal aujourd'hui.
+- `session_20260417_handoff.md` + `session_20260418_handoff.md` — VWB 19 blocs : intégré, certains chantiers avancés depuis.
+- `session_20260421_handoff.md` — perf 6.6x : valeur historique uniquement.
+- `session_20260423_grounding.md` — 176 tests grounding : leçon retenue dans `feedback_ollama_vs_transformers.md` qui suffit.
+- `project_objectif_6avril.md` — date passée, objectifs largement redéfinis.
+- `project_action_plan_avril2026.md` — Critic/Observer/Recovery toujours non branchés (cf. cartography), plan toujours valide en concept mais "avril 2026" comme nom est trompeur.
+- `project_actor_plan.md` + `project_actor_implementation.md` — remplacés par `project_pipeline_fast_smart_think.md`.
+- `project_tasks_20260319.md` — TODO du 19 mars, exécuté.
+- `project_demo_urgences_avril2026.md` — démo passée, garder uniquement les passages réutilisables (chiffrage Amina, scaling 24/24).
+- `project_dashboard_config.md` (5 avril) — non implémenté à ce jour, à reconfirmer si toujours pertinent.
+- `project_data_extraction.md` (mars) — concept toujours valide, pas implémenté, peut rester en référence.
+- `project_uitars_integration.md` (12 avril) — UI-TARS intégré, branché dans cartography. Doublon partiel avec `reference_vlm_models.md`.
+- `project_finetuning_vlm_plan.md` — chantier post-POC, encore valide mais pas urgent.
+- `project_deploy_semaine21avril.md` — date passée, contenu intégré aux références TIM.
+- `pending_uncommitted_files.md` (14 avril) — liste périmée, le working tree a évolué (cf. handoff 6 mai v2).
+- `project_gpu_executor_todo.md` — bug toujours réel, pertinent.
+- `project_actor_implementation.md` — WorkflowRunner V3 jamais branché, toujours périmé en pratique.
+
+### 3.4 "Mort" (peuvent disparaître sans regret)
+
+À mon sens, ces fichiers n'apportent plus rien :
+- `session_20260319.md` — repris ailleurs.
+- `session_20260326.md` — repris ailleurs.
+- `session_20260330.md` — repris ailleurs.
+- `session_20260331.md` — repris ailleurs.
+- `session_20260405.md` — repris ailleurs.
+- `session_20260405_evening.md` — repris ailleurs.
+- `session_20260412.md` (note 2 lignes) — déjà couvert par `session_20260412_handoff.md`.
+- `session_20260412_handoff.md` — bug time.sleep résolu depuis longtemps.
+- `session_20260413_handoff.md` — premier replay autonome, valeur émotionnelle mais zéro valeur opérationnelle aujourd'hui.
+- `session_20260417_handoff.md` — repris dans pipelines plus récents.
+- `session_20260418_handoff.md` — idem.
+- `session_20260421_handoff.md` — perf historique.
+- `session_20260423_grounding.md` — leçon distillée dans le feedback dédié.
+- `plan_attaque_20260326.md` — plan exécuté.
+- `plan_remontee_8sur10.md` — plan dépassé par QW Suite Mai.
+- `project_actor_implementation.md` — sujet abandonné dans cette forme.
+- `project_actor_plan.md` — sujet remplacé par FAST→SMART→THINK.
+- `project_tasks_20260319.md` — TODO exécuté.
+- `project_objectif_6avril.md` — date passée.
+- `project_demo_urgences_avril2026.md` — démo passée (mais récupérer chiffres Amina avant suppression).
+
+→ **Recommandation** : ne pas supprimer mais déplacer en `_archive/sessions_resolved/`, `_archive/plans_done/`. Dom décide.
+
+---
+
+## 4. Top 7 feedback les plus PRÉCIEUX (= règles les plus violées)
+
+D'après la lecture croisée, en particulier de `session_20260506_handoff_v2.md` qui documente précisément les bourdes de la dernière session, voici les feedback à hisser au sommet de l'index :
+
+### 🥇 1. `feedback_prendre_le_temps.md` ⭐⭐⭐
+**DEVISE de Dom.** Violée massivement le 6 mai (Win+D hardcodé sous pression démo, fix de symptôme au lieu de cause racine). À LIRE EN PREMIER. Déjà priorité dans MEMORY ligne 3.
+
+### 🥈 2. `feedback_orphans_are_projections.md`
+Créé le 7 mai 2026, **pas dans MEMORY.md**. Critique : un Claude futur va proposer de "nettoyer" `core/grounding/pipeline.py`, `observe_reason_act.py`, etc. Le rapport project-quality-guardian liste les "branchements orphelins" et invite implicitement à les supprimer. Ce feedback dit explicitement : NE PAS PROPOSER DE LES ENLEVER, ce sont des projections de bétonnage à brancher progressivement.
+
+### 🥉 3. `feedback_verifier_avant_apres_clic.md`
+Créé le 7 mai 2026, **pas dans MEMORY.md**. Cause racine architecturale des "Léa clique au pif" identifiée par Dom : 3 garde-fous manquent (resolved=False mais coords renvoyées quand même, pas de pré-OCR, pas de post-OCR sémantique). Si on saute ce feedback, la prochaine session va proposer "re-capturer les ancres" — exactement ce que Dom dit de ne PAS faire.
+
+### 🏅 4. `feedback_ollama_vs_transformers.md`
+Pas dans le top index (ligne 187, déjà tronqué à 200). Cause racine : 15 modèles testés via Ollama → tous échouent en grounding parce qu'Ollama ne passe pas resized_width/height au modèle. Une session sans ce feedback va re-tester les mêmes modèles en boucle.
+
+### 🏅 5. `architecture_lea_v1_find_text_client.md`
+Créé le 7 mai 2026, **pas dans MEMORY.md**. Limite architecturale critique : Léa V1 (gelée) fait son propre grounding client-side via [FIND-TEXT]. Le serveur peut résoudre la cible, le client peut décider d'aller chercher ailleurs. Toute proposition d'amélioration de la résolution doit composer avec cette double couche. Sans ce feedback, on promet des fix serveur qui ne règlent rien côté client.
+
+### 🏅 6. `feedback_no_rustine.md`
+Présent dans MEMORY ligne 156, mais perd en visibilité parmi 30+ entrées. À chaque trou architectural rencontré, le réflexe Claude est de combler par un cache module-level. Dom a explicitement nommé cette dérive. Devrait remonter en top critical.
+
+### 🏅 7. `feedback_anonymisation_stricte.md`
+Présent dans MEMORY ligne 164. Risque démo médicale : la 1ère version `data.js` a contenu des hallucinations cliniques à sens inversé (anhydrose↔ankylose, avec/sans injection). Pour Amina/médecins clients, ces erreurs = perte instantanée de crédibilité. Devrait rester très visible.
+
+### Mention honorable
+
+- `feedback_no_permission_for_tests.md` (6 mai) : pas dans MEMORY. "Ne me demande pas tout le temps si tu peux faire un test." À ajouter.
+- `feedback_failure_is_learning.md` (ligne 158) : à conserver, central au récit Léa.
+- `feedback_architecture_first.md` (ligne 152) : à conserver, central.
+- `feedback_reread_before_code.md` (ligne 159) : à conserver, méta-règle.
+
+---
+
+## 5. Cartographie thématique (10 thèmes)
+
+| Thème | Fichiers (count) | Structurants à garder | Redondants/éphémères |
+|---|---|---|---|
+| **Identité Dom + Amina** | 3 | `user_role.md`, `project_amina_partner.md`, `feedback_remote_control_tools.md` | — |
+| **Méthode de travail Claude (méta)** | ~15 feedback | `feedback_prendre_le_temps`, `architecture_first`, `no_rustine`, `reread_before_code`, `step_back`, `not_a_click_box`, `failure_is_learning`, `orphans_are_projections`, `verifier_avant_apres_clic`, `no_permission_for_tests` | `stop_asking` (couvert par no_permission), `no_patch_word` (très court), `no_git_tags` (court mais utile), `search_before_code` (couvert par prendre_le_temps), `focus_projet` (couvert par feedback_not_a_click_box partiellement) |
+| **Vision produit / Léa stagiaire** | 4 | `project_vision`, `project_platform_vision`, `project_lea_apprentissage_plan`, `feedback_not_a_click_box` | `project_data_extraction` (concept en attente) |
+| **Architecture technique en cours** | ~5 | `architecture_v3_v4_decoupled`, `architecture_lea_v1_find_text_client`, `cartography_execution_flow`, `feedback_ollama_vs_transformers`, `project_pipeline_fast_smart_think` | `architecture.md` (mars), `bugs-fixed.md`, `visual_replay.md` (mars, intégré), `project_actor_plan` + `project_actor_implementation` (remplacés) |
+| **Démo GHT Sud 95 (en cours)** | 6 | `project_ght_sud_95`, `reference_demo_ght_mockup`, `project_amina_partner`, `feedback_anonymisation_stricte`, `feedback_auth_dialogs_runtime`, `session_20260506_handoff_v2` | `project_demo_urgences_avril2026` (passée, sauf chiffrage Amina) |
+| **Sprint courant (QW Suite Mai)** | 3 | `session_20260506_handoff_v2` (priorité absolue, contient le bilan), `session_20260429_30_handoff` (bus feedback) | `session_20260506_handoff.md` v1 (remplacé par v2) |
+| **Pipeline commercial / business** | 6 | `project_commercial_pipeline`, `project_ght_sud_95`, `project_poc_anoust`, `project_pricing_model`, `project_competitive_landscape`, "feedback_pull_not_push" (FICHIER MANQUANT) | `project_demo_urgences_avril2026` (archive éléments réutilisables) |
+| **Déploiement & infra** | ~10 | `reference_credentials`, `reference_windows_pc`, `reference_mcp_servers`, `feedback_multi_user_deployment`, `feedback_capture_purge_policy`, `feedback_standalone_exe`, `feedback_auth_dialogs_runtime`, `project_code_signing`, `project_multi_users_auth`, `project_auth_logiciels_metier` | `project_deploy_semaine21avril` (passé), `project_gpu_executor_todo` (TODO encore valide), `project_deployment_notes` |
+| **Modèles VLM / grounding** | 4 | `reference_vlm_models`, `feedback_ollama_vs_transformers`, `benchmark_grounding_avril2026`, `project_finetuning_vlm_plan` | — |
+| **R&D / pépites futures** | 4 | `project_rd_pepites_avril2026`, `project_competitive_landscape`, `project_skill_tree_concept`, `project_app_knowledge` | `project_uitars_integration` (intégré, peut devenir un paragraphe dans VLM models) |
+| **Sessions chronologiques** | 17 | `session_20260506_handoff_v2.md`, `session_20260429_30_handoff.md` | Les 15 autres sessions = à archiver |
+
+---
+
+## 6. Proposition de réorganisation par zone
+
+**Aucune action immédiate** — c'est une PROPOSITION uniquement.
+
+### 🔥 ZONE TOP CRITICAL (à charger en tête de MEMORY.md, ~10-12 entrées)
+
+À LIRE AVANT TOUT à chaque session. Toutes ces entrées sont des règles dont la violation a coûté du temps, de la crédibilité ou un risque démo.
+
+| Fichier | Pourquoi top |
+|---|---|
+| `feedback_prendre_le_temps.md` | DEVISE — violée le 6 mai |
+| `feedback_orphans_are_projections.md` | NEW (7 mai) — évite proposition "nettoyer" code dormant |
+| `feedback_verifier_avant_apres_clic.md` | NEW (7 mai) — cause racine "clic au pif" |
+| `architecture_lea_v1_find_text_client.md` | NEW (7 mai) — limite Léa V1 client-side |
+| `feedback_ollama_vs_transformers.md` | Évite re-tester 15 modèles via Ollama |
+| `feedback_no_rustine.md` | Réflexe Claude à contrer |
+| `feedback_anonymisation_stricte.md` | Risque démo médicale |
+| `feedback_not_a_click_box.md` | Récit Léa |
+| `feedback_failure_is_learning.md` | Cardinal pour la philosophie produit |
+| `user_role.md` | Profil Dom 8 casquettes |
+| `project_amina_partner.md` | Partenaire métier |
+| `session_20260506_handoff_v2.md` | État courant (vrai bug = OCR direct) |
+
+### 📌 ZONE ACTIVE (chargée par référence, ~25 entrées)
+
+Architecture courante, feedback usuels, projets en cours :
+- Feedback : `agent_frozen`, `agent_safety`, `architecture_first`, `auth_dialogs_runtime`, `capture_purge_policy`, `citrix_primary`, `100pct_visual`, `lea_reflexes_catalog`, `local_only`, `multi_user_deployment`, `multi_app_workflow`, `no_git_tags`, `no_patch_word`, `no_permission_for_tests`, `phash_vs_dialog_in_vm`, `popup_vlm`, `reread_before_code`, `remote_control_tools`, `step_back`
+- Architecture : `architecture_v3_v4_decoupled`, `cartography_execution_flow`
+- Projets actuels : `project_ght_sud_95`, `project_platform_vision`, `project_pipeline_fast_smart_think`, `project_lea_apprentissage_plan`, `project_commercial_pipeline`, `project_vision`, `project_vwb_lea_strategy`, `project_bridge_vwb_lea_known_gap`, `project_medgemma_bench`, `project_app_knowledge`, `project_skill_tree_concept`
+- Sessions actives : `session_20260429_30_handoff` (bus + actions intelligentes)
+
+### 📚 ZONE REFERENCE (lookup à la demande, ~12 entrées)
+
+Données stables consultables ponctuellement :
+- `reference_credentials.md`
+- `reference_windows_pc.md`
+- `reference_mcp_servers.md`
+- `reference_vlm_models.md`
+- `reference_demo_ght_mockup.md`
+- `feedback_win11_local_account.md`
+- `feedback_standalone_exe.md`
+- `feedback_search_before_code.md`
+- `feedback_focus_projet.md`
+- `feedback_stop_asking.md`
+- `project_competitive_landscape.md`
+- `project_pricing_model.md`
+- `project_rd_pepites_avril2026.md`
+
+### 🗄️ ZONE ARCHIVE (déplacer en `_archive/` mais conserver, ~50+ entrées)
+
+#### Sessions résolues
+- `session_20260319.md`
+- `session_20260326.md`
+- `session_20260330.md`
+- `session_20260331.md`
+- `session_20260405.md`
+- `session_20260405_evening.md`
+- `session_20260412.md`
+- `session_20260412_handoff.md`
+- `session_20260413_handoff.md`
+- `session_20260414_kickoff.md` (kickoff Anouste — historique)
+- `session_20260417_handoff.md`
+- `session_20260418_handoff.md`
+- `session_20260421_handoff.md`
+- `session_20260423_grounding.md`
+- `session_20260506_handoff.md` (v1 — remplacée par v2)
+
+#### Plans périmés
+- `plan_attaque_20260326.md`
+- `plan_remontee_8sur10.md`
+
+#### Projets actés/passés
+- `project_actor_plan.md`
+- `project_actor_implementation.md`
+- `project_action_plan_avril2026.md`
+- `project_objectif_6avril.md`
+- `project_tasks_20260319.md`
+- `project_demo_urgences_avril2026.md` (extraire chiffrage Amina avant)
+- `project_uitars_integration.md` (intégré)
+- `project_dashboard_config.md` (concept ouvert mais non priorisé)
+- `project_data_extraction.md` (en attente)
+- `project_deploy_semaine21avril.md`
+- `project_deployment_notes.md`
+- `project_finetuning_vlm_plan.md` (post-POC)
+- `project_gpu_executor_todo.md`
+- `project_multi_users_auth.md` (à reprendre plus tard)
+- `project_auth_logiciels_metier.md` (chantier futur)
+- `project_code_signing.md` (décidé)
+- `project_os_multi_support.md` (anticipation 2-4 ans)
+- `project_poc_anoust.md` (en attente DGX)
+- `project_roadmap_vision.md` (long terme)
+- `pending_uncommitted_files.md` (14 avril, dépassé)
+
+#### Architecture / bugs résolus
+- `architecture.md` (mars)
+- `bugs-fixed.md` (mars)
+- `visual_replay.md` (mars, intégré)
+- `benchmark_grounding_avril2026.md` (leçon distillée dans feedback)
+
+→ **Total archive proposée : ~45-50 fichiers** (presque la moitié).
+
+### Cas INCERTAIN — voir Dom
+
+- `feedback_pull_not_push.md` : référencé MEMORY ligne 257 mais le fichier n'existe pas. **Soit le créer (la règle "Dom ne vend pas, les clients viennent acheter" semble réelle vu le contenu), soit retirer la référence.**
+- `project_dashboard_config.md` : décidé le 5 avril, jamais implémenté. Toujours pertinent ou abandonné ? À demander.
+- `project_data_extraction.md` : concept de mars 2026, jamais implémenté. Vivant ou mort ?
+- `project_objectif_6avril.md` : date passée mais point P0/P1/P2/P3/P4 (Critic/Observer/Policy/Recovery/Apprentissage) toujours d'actualité. Refaire un fichier "Plan d'action mai 2026" et archiver l'avril ? À demander.
+
+---
+
+## 7. Recommandations de compactage MEMORY.md
+
+### 7.1 Objectif
+
+Passer de 273 lignes à **~150 lignes** (marge sécurité 50 lignes pour ajouts futurs avant retrigger limite 200).
+
+### 7.2 Méthode
+
+#### Compactage par fusion thématique
+Au lieu d'avoir 19 entrées feedback en bullet list lignes 146-164, créer **un bloc dense** :
+
+```markdown
+## ⭐ Feedback critiques (lecture obligatoire)
+
+**À LIRE en priorité (violations observées en session)** :
+- `feedback_prendre_le_temps.md` — DEVISE, violée 6 mai
+- `feedback_orphans_are_projections.md` — modules dormants ≠ code mort
+- `feedback_verifier_avant_apres_clic.md` — cause racine clic au pif
+- `architecture_lea_v1_find_text_client.md` — Léa V1 OCR client-side
+- `feedback_ollama_vs_transformers.md` — Ollama ≠ vision spatiale
+- `feedback_no_rustine.md` — pas de cache pour combler trou
+- `feedback_anonymisation_stricte.md` — risque démo médicale
+
+**Standards de méthode** :
+- `architecture_first` `reread_before_code` `step_back` `not_a_click_box` `failure_is_learning` `100pct_visual` `lea_reflexes_catalog` `citrix_primary` `multi_app_workflow` `auth_dialogs_runtime` `phash_vs_dialog_in_vm`
+
+**Conventions courtes** :
+- `no_patch_word` `no_git_tags` `no_permission_for_tests` `local_only` `agent_frozen` `agent_safety` `capture_purge_policy` `multi_user_deployment` `popup_vlm` `remote_control_tools` `standalone_exe` `win11_local_account`
+```
+
+→ Gain : **~30 lignes** (de ~50 à ~20).
+
+#### Suppression des entrées sessions anciennes
+Lignes 115-125 (sessions 19-31 mars), 205-209 (sessions 12-13 avril), 226-230 (sessions 17-18 avril), 251 (démo urgences avril) : à retirer ou regrouper en **une seule ligne** :
+
+```markdown
+## Sessions anciennes archivées
+Voir `_archive/sessions/` pour le détail mars-avril 2026. Active actuelle : `session_20260506_handoff_v2.md` + `session_20260429_30_handoff.md`.
+```
+
+→ Gain : **~25 lignes**.
+
+#### Compactage des modules architecture
+Lignes 137-144 (Auth Module + Federation Module + Internet Exposure) peuvent devenir 4 lignes denses au lieu de 12.
+
+→ Gain : **~8 lignes**.
+
+#### Suppression doublons
+Lignes 184-185 (LEÇON CARDINALE qui re-référence `feedback_prendre_le_temps.md` déjà cité ligne 4) : doublon.
+
+→ Gain : **~3 lignes**.
+
+#### Total estimé
+273 → ~150 lignes. **Reste 50 lignes de marge avant retrigger limite 200.**
+
+### 7.3 Fichiers à fusionner
+
+| Fusion proposée | Bénéfice |
+|---|---|
+| `session_20260319/26/30/31.md` + sessions avril → 1 seul `_archive/sessions/CHRONOLOGIE.md` | Garde trace, libère index |
+| `feedback_step_back.md` ⊃ `feedback_architecture_first.md` (très chevauchants) | -1 entrée |
+| `feedback_search_before_code.md` ⊃ `feedback_prendre_le_temps.md` (même esprit) | -1 entrée |
+| `feedback_stop_asking.md` ⊃ `feedback_no_permission_for_tests.md` (même règle, le 2nd est plus précis) | -1 entrée |
+| `project_actor_plan.md` + `project_actor_implementation.md` → archive (remplacés par `project_pipeline_fast_smart_think.md`) | -2 dans active |
+| `project_demo_urgences_avril2026.md` → extraire 2 paragraphes (chiffrage + scaling) dans `project_ght_sud_95.md`, archiver le reste | -1 dans active |
+| `architecture.md` → archive (intégré au code, partiellement périmé) | -1 dans active |
+
+### 7.4 Fichiers à supprimer sans regret
+
+Aucun. **Tout doit aller en archive**, pas en suppression — Dom décide. Cohérent avec la règle "ne pas perdre l'historique".
+
+### 7.5 Fichiers à archiver mais conserver
+
+Voir section 6 "ZONE ARCHIVE" (~50 fichiers).
+
+### 7.6 Référence cassée à régler
+
+`feedback_pull_not_push.md` (ligne 257 MEMORY) : soit créer, soit retirer la référence. **Décision Dom.**
+
+---
+
+## 8. Politique de gestion future — 7 règles
+
+Pour qu'une fois propre, la mémoire reste propre :
+
+### Règle 1 — 1 feedback = 1 violation observée minimum
+Avant de créer un nouveau `feedback_*.md`, on doit pouvoir citer un cas précis de violation. Pas de feedback "préventif" tant qu'aucun Claude ne s'est planté dessus.
+
+### Règle 2 — Rotation des sessions
+Toute session > 21 jours sans modification est candidate à `_archive/`. Au prochain audit, déplacer automatiquement.
+
+### Règle 3 — Pas plus de 2 sessions actives dans le top index
+Le top index ne référence que :
+- La dernière session de handoff (état courant)
+- Éventuellement la session précédente si elle a un sprint en cours différent
+
+Toutes les autres sessions vont en archive.
+
+### Règle 4 — MEMORY.md ≤ 180 lignes (marge 20 lignes avant la limite 200)
+Si une nouvelle entrée fait dépasser : compacter d'abord (fusion ou archive), ajouter ensuite.
+
+### Règle 5 — Cross-référencer toute tension entre feedbacks
+Si un feedback A semble en tension avec un feedback B, ajouter explicitement dans A la phrase "**Compose avec** : voir `feedback_B.md` qui dit Z." Évite les contradictions silencieuses.
+
+### Règle 6 — Renommer les "project_*_dateMMDD" périmés
+Tout `project_*_avrilMMDD.md` ou similaire dont la date est passée doit être :
+- Soit renommé en `project_*_active.md` si le contenu est encore valide
+- Soit déplacé en archive si la date marquait une échéance dépassée
+
+### Règle 7 — Vérifier les références cassées au début de chaque session
+Première chose qu'un Claude qui modifie MEMORY.md fait : vérifier que tous les `[link.md](link.md)` pointent vers un fichier existant. Le cas `feedback_pull_not_push.md` montre comment une référence cassée traîne pendant des sessions.
+
+### Bonus — Ajouter un en-tête `MEMORY.md` mentionnant la limite
+Au sommet du fichier :
+> **⚠️ Limite chargement automatique = 200 lignes.** Tout ce qui suit la ligne 200 est tronqué. Maintenir < 180 lignes (marge 20 lignes pour ajouts en cours de session).
+
+---
+
+## 9. Synthèse opérationnelle
+
+### Chiffres clés
+- 101 fichiers `.md`, dont ~50% non indexés dans MEMORY.md
+- MEMORY.md = 273 lignes, ~73 lignes invisibles à chaque session
+- 7 feedback critiques absents du top index
+- 1 référence cassée (`feedback_pull_not_push.md`)
+- ~45-50 fichiers candidats à l'archivage
+
+### Risques actuels
+- **Démo GHT jeudi 8 mai** : si Claude oublie `feedback_verifier_avant_apres_clic.md` ou `architecture_lea_v1_find_text_client.md`, il va proposer "re-capturer les ancres" alors que Dom dit explicitement de ne pas le faire. Risque démo direct.
+- **Hallucination cliniques** : si `feedback_anonymisation_stricte.md` glisse hors du top index, prochaine anonymisation = perte crédibilité Amina.
+- **Modules orphelins** : un Claude qui voit l'audit project-quality-guardian va proposer `git rm core/grounding/pipeline.py`. Hors top index = bourde garantie.
+
+### Win immédiat possible
+Une simple **réorganisation de MEMORY.md** (sans toucher aux fichiers) à ~150 lignes avec les 7 feedback critiques en tête résout 80% du problème. ~30 minutes de travail Dom + Claude.
+
+### Décisions à demander à Dom
+1. **Créer ou retirer** `feedback_pull_not_push.md` (référence cassée).
+2. **Valider l'archivage** des ~45 fichiers proposés en zone ARCHIVE.
+3. **Trancher** sur 4 fichiers INCERTAIN (`project_dashboard_config`, `project_data_extraction`, `project_objectif_6avril`, `project_actor_*`).
+4. **Approuver** les 7 règles de gestion future.
+
+### Décisions Claude peut prendre seul (sujets tertiaires)
+- Réorganisation de l'ordre des entrées dans MEMORY.md (Top critical → Active → Reference → Archive pointers).
+- Compactage des sections sessions et architecture en bullets denses.
+- Création du fichier `_archive/sessions/CHRONOLOGIE.md` de synthèse si Dom valide l'archivage.
+
+---
+
+## 10. Annexe — Inventaire complet des 101 fichiers
+
+### Feedback (33)
+1. `feedback_100pct_visual.md` — 100% vision, raccourcis lus OK ✅ ACTIVE
+2. `feedback_agent_frozen.md` — Léa V1 gelée, fix serveur ✅ ACTIVE
+3. `feedback_agent_safety.md` — pas de keyboard/mouse en bg ✅ ACTIVE
+4. `feedback_anonymisation_stricte.md` — anonymisation chirurgicale 🔥 TOP
+5. `feedback_architecture_first.md` — raisonner avant coder ✅ ACTIVE
+6. `feedback_auth_dialogs_runtime.md` — dialogues auth système ✅ ACTIVE
+7. `feedback_capture_purge_policy.md` — purge captures client ✅ ACTIVE
+8. `feedback_citrix_primary.md` — Citrix = vision pure ✅ ACTIVE
+9. `feedback_failure_is_learning.md` — échec = apprentissage 🔥 TOP
+10. `feedback_focus_projet.md` — but produit, pas métriques 📚 REFERENCE
+11. `feedback_follow_spec.md` — VISION_RPA_INTELLIGENT 📚 REFERENCE (couvert par d'autres)
+12. `feedback_lea_reflexes_catalog.md` — gesture_catalog ✅ ACTIVE
+13. `feedback_local_only.md` — Ollama only ✅ ACTIVE
+14. `feedback_multi_app_workflow.md` — TIM passent entre apps ✅ ACTIVE
+15. `feedback_multi_user_deployment.md` — tokens, machine_id ✅ ACTIVE
+16. `feedback_no_git_tags.md` — pas de tags ✅ ACTIVE
+17. `feedback_no_patch_word.md` — pas dire "patch" ✅ ACTIVE
+18. `feedback_no_permission_for_tests.md` — exécuter direct ✅ ACTIVE (à promouvoir)
+19. `feedback_no_rustine.md` — pas de rustines 🔥 TOP
+20. `feedback_not_a_click_box.md` — Léa apprend, pas record-replay 🔥 TOP
+21. `feedback_ollama_vs_transformers.md` — Ollama ≠ grounding 🔥 TOP
+22. `feedback_orphans_are_projections.md` — modules dormants 🔥 TOP (NEW)
+23. `feedback_phash_vs_dialog_in_vm.md` — DialogHandler en VM ✅ ACTIVE
+24. `feedback_popup_vlm.md` — popup via VLM, pas ctypes ✅ ACTIVE
+25. `feedback_prendre_le_temps.md` — DEVISE 🔥🔥🔥 TOP
+26. `feedback_remote_control_tools.md` — NoMachine/AnyDesk parasites ✅ ACTIVE
+27. `feedback_reread_before_code.md` — relire avant coder 🔥 TOP
+28. `feedback_search_before_code.md` — internet avant coder 📚 REFERENCE
+29. `feedback_standalone_exe.md` — agent Win = .exe 📚 REFERENCE
+30. `feedback_step_back.md` — recul si demandé ✅ ACTIVE
+31. `feedback_stop_asking.md` — pas demander d'arrêter 📚 REFERENCE (couvert par no_permission)
+32. `feedback_verifier_avant_apres_clic.md` — pré/post-check 🔥 TOP (NEW)
+33. `feedback_win11_local_account.md` — bypass Win11 OOBE 📚 REFERENCE
+
+### Project (34)
+1. `project_action_plan_avril2026.md` — P0-P4 plan 🗄️ ARCHIVE (concept toujours valide, nom date périmé)
+2. `project_actor_implementation.md` — WorkflowRunner V3 🗄️ ARCHIVE
+3. `project_actor_plan.md` — Phase 1/2/3 acteur 🗄️ ARCHIVE
+4. `project_amina_partner.md` — partenaire métier 🔥 TOP
+5. `project_app_knowledge.md` — fiche par application ✅ ACTIVE
+6. `project_auth_logiciels_metier.md` — auth DPI 🗄️ ARCHIVE (chantier futur)
+7. `project_bridge_vwb_lea_known_gap.md` — bridge import dégradé ✅ ACTIVE
+8. `project_code_signing.md` — stratégie code signing 🗄️ ARCHIVE (décidé)
+9. `project_commercial_pipeline.md` — pipeline multi-verticales ✅ ACTIVE
+10. `project_competitive_landscape.md` — veille concurrents 📚 REFERENCE
+11. `project_dashboard_config.md` — config modèles dashboard ❓ INCERTAIN
+12. `project_data_extraction.md` — visual scraping ❓ INCERTAIN
+13. `project_demo_urgences_avril2026.md` — démo passée 🗄️ ARCHIVE (extraire chiffrage Amina)
+14. `project_deployment_notes.md` — points production 🗄️ ARCHIVE
+15. `project_deploy_semaine21avril.md` — déploiement 21/04 🗄️ ARCHIVE
+16. `project_finetuning_vlm_plan.md` — fine-tuning post-POC 🗄️ ARCHIVE
+17. `project_ght_sud_95.md` — démo en cours 🔥 TOP
+18. `project_gpu_executor_todo.md` — TODO GPU executor 📚 REFERENCE
+19. `project_lea_apprentissage_plan.md` — phases 1/2/3 ✅ ACTIVE
+20. `project_medgemma_bench.md` — bench medgemma 4b ✅ ACTIVE
+21. `project_multi_users_auth.md` — multi-users auth 🗄️ ARCHIVE
+22. `project_objectif_6avril.md` — date passée 🗄️ ARCHIVE
+23. `project_os_multi_support.md` — Linux durci 2-4 ans 🗄️ ARCHIVE (long terme)
+24. `project_pipeline_fast_smart_think.md` — pipeline FAST→SMART→THINK ✅ ACTIVE
+25. `project_platform_vision.md` — pivot interop 🔥 TOP
+26. `project_poc_anoust.md` — premier client signé ✅ ACTIVE
+27. `project_pricing_model.md` — modèle pricing 📚 REFERENCE
+28. `project_rd_pepites_avril2026.md` — pépites R&D 📚 REFERENCE
+29. `project_roadmap_vision.md` — long terme 🗄️ ARCHIVE
+30. `project_skill_tree_concept.md` — skills réutilisables ✅ ACTIVE
+31. `project_tasks_20260319.md` — TODO 20/03 🗄️ ARCHIVE
+32. `project_uitars_integration.md` — UI-TARS intégré 🗄️ ARCHIVE (intégré, fusionner avec reference_vlm_models)
+33. `project_vision.md` — Shadow→Copilot→Autonomous ✅ ACTIVE
+34. `project_vwb_lea_strategy.md` — stratégie produit ✅ ACTIVE
+
+### Session (17)
+1. `session_20260319.md` — pipeline qualité 🗄️ ARCHIVE
+2. `session_20260326.md` — worker séparé 🗄️ ARCHIVE
+3. `session_20260330.md` — MVP replay popup 🗄️ ARCHIVE
+4. `session_20260331.md` — SomEngine 🗄️ ARCHIVE
+5. `session_20260405.md` — Phase 1 acteur VM 🗄️ ARCHIVE
+6. `session_20260405_evening.md` — gemma4 acteur 🗄️ ARCHIVE
+7. `session_20260412.md` — popups Léa volent focus 🗄️ ARCHIVE
+8. `session_20260412_handoff.md` — état 12/04 🗄️ ARCHIVE
+9. `session_20260413_handoff.md` — premier replay autonome 🗄️ ARCHIVE
+10. `session_20260414_kickoff.md` — kickoff Anouste 🗄️ ARCHIVE
+11. `session_20260417_handoff.md` — E2E validés 🗄️ ARCHIVE
+12. `session_20260418_handoff.md` — VWB 19 blocs 🗄️ ARCHIVE
+13. `session_20260421_handoff.md` — perf 6.6x 🗄️ ARCHIVE
+14. `session_20260423_grounding.md` — bench grounding 🗄️ ARCHIVE
+15. `session_20260429_30_handoff.md` — bus feedback ✅ ACTIVE
+16. `session_20260506_handoff.md` — sprint QW (v1, remplacé) 🗄️ ARCHIVE
+17. `session_20260506_handoff_v2.md` — bilan auto-critique 🔥 TOP
+
+### Reference (5)
+1. `reference_credentials.md` — credentials LAN 📚 REFERENCE
+2. `reference_demo_ght_mockup.md` — maquette démo 📚 REFERENCE
+3. `reference_mcp_servers.md` — 13 MCP 📚 REFERENCE
+4. `reference_vlm_models.md` — modèles VLM 📚 REFERENCE
+5. `reference_windows_pc.md` — PC Windows test 📚 REFERENCE
+
+### Plan (2)
+1. `plan_attaque_20260326.md` — plan 26/03 🗄️ ARCHIVE
+2. `plan_remontee_8sur10.md` — plan 26/04 🗄️ ARCHIVE
+
+### Architecture (3)
+1. `architecture.md` — quick reference (mars) 🗄️ ARCHIVE
+2. `architecture_v3_v4_decoupled.md` — V3/V4 découplés ✅ ACTIVE
+3. `architecture_lea_v1_find_text_client.md` — Léa V1 OCR client 🔥 TOP (NEW)
+
+### Divers (7)
+1. `MEMORY.md` — index 🔥 TOP (à compacter)
+2. `bugs-fixed.md` — bugs mars 🗄️ ARCHIVE
+3. `cartography_execution_flow.md` — cartographie 12 systèmes 🔥 TOP
+4. `benchmark_grounding_avril2026.md` — bench détaillé 🗄️ ARCHIVE (leçon dans feedback)
+5. `pending_uncommitted_files.md` — uncommitted 14/04 🗄️ ARCHIVE
+6. `user_role.md` — profil Dom 🔥 TOP
+7. `visual_replay.md` — replay system mars 🗄️ ARCHIVE
+
+---
+
+**Fin du rapport. Aucun fichier de mémoire n'a été modifié pendant cet audit. Aucun fichier déplacé. Décisions de réorganisation laissées à Dom.**

docs/BENCH_SAFETY_CHECKS_2026-05-06.md

@@ -0,0 +1,95 @@
+# Bench QW4 safety_checks — sélection du LLM contextuel
+
+**Date** : 2026-05-06
+**Contexte** : QW4 du sprint mai. La fonction `_call_llm_for_contextual_checks`
+appelle Ollama avec un screenshot + prompt court pour générer 0-3 checks de
+vérification supplémentaires que l'humain doit acquitter avant la reprise
+d'un replay en pause supervisée (`safety_level=medical_critical`).
+
+## Méthodologie
+
+- **5 scénarios** : screenshots synthétiques de dossiers patient avec UNE
+  anomalie volontaire chacun (date de naissance aberrante, IPP incohérent,
+  diagnostic vide, code CIM inadapté à l'âge, forfait incohérent avec durée).
+- **5 candidats** : `gemma4:latest`, `qwen3-vl:8b`, `qwen2.5vl:7b`,
+  `qwen2.5vl:3b`, `medgemma:4b`.
+- **Protocole par modèle** : déchargement VRAM (keep_alive=0 sur tous les
+  modèles loaded) → 1er appel = cold start chronométré → 4 autres screenshots
+  × 3 runs = 12 mesures warm.
+- **Métriques** : cold start, warm avg, warm p95, % JSON valide, % détection
+  (anomalie cible présente dans label/evidence d'au moins un check renvoyé).
+- **Script** : `tools/bench_safety_checks_models.py`.
+
+## Résultats
+
+| Modèle | Cold (s) | Warm avg (s) | Warm p95 (s) | JSON | Détection |
+|---|---:|---:|---:|---:|---:|
+| `gemma4:latest` | 10.6 | **2.9** | 3.4 | 92% (12/13) | **46% (6/13)** |
+| `qwen3-vl:8b` | 5.6 | — | — | **0%** (0/12) | 0% (0/12) |
+| `qwen2.5vl:7b` | 9.4 | 6.6 | 8.1 | 100% (13/13) | 23% (3/13) |
+| `qwen2.5vl:3b` | 6.0 | 2.0 | 2.5 | 100% (13/13) | 8% (1/13) |
+| `medgemma:4b` | 2.0 | 0.5 | 0.7 | 100% (13/13) | **0%** (0/13) |
+
+## Lecture
+
+- **`medgemma:4b` retourne systématiquement `[]`** sur les 13 mesures.
+  Trop obéissant à "Si rien d'inhabituel à signaler, retourne []", refuse
+  de pointer ne serait-ce qu'une date 1900-01-01. **Mauvais choix par défaut**
+  malgré sa rapidité et sa spécialisation médicale revendiquée.
+- **`qwen3-vl:8b` ignore `format=json` Ollama** : 0 réponse parsable. À écarter
+  pour cette tâche tant que le tooling Ollama / le modèle ne convergent pas.
+- **`qwen2.5vl:7b`** détecte mais 2× plus lent (warm 6.6s) que gemma4 et tend
+  à inventer des anomalies de format de date qui ne sont pas la vraie cible.
+- **`qwen2.5vl:3b`** rapide mais détection 8% — il "vérifie pour vérifier"
+  (renvoie souvent "vérification de la date de naissance" même quand la date
+  est correcte).
+- **`gemma4:latest` gagne** : meilleur taux de détection (46%) ET deuxième
+  meilleur warm (2.9s). Tend à raisonner cohérence motif/diagnostic plutôt
+  que valeurs aberrantes brutes.
+
+## Détail détection par scénario
+
+| Scénario | gemma4 | qwen2.5vl:7b | qwen2.5vl:3b | medgemma:4b |
+|---|:---:|:---:|:---:|:---:|
+| Date naissance aberrante (1900) | ❌ | ✅ | ✅ | ❌ |
+| IPP incohérent (`ABC@@##XYZ`) | ❌ | ❌ | ❌ | ❌ |
+| Diagnostic principal vide | ✅ | ❌ | ❌ | ❌ |
+| Code CIM inadapté à l'âge | ✅ | ❌ | ❌ | ❌ |
+| Forfait UHCD vs durée 1h | ❌ | ❌ | ❌ | ❌ |
+
+Aucun modèle ne détecte les 5 scénarios. **L'IPP corrompu et le forfait
+incohérent ne sont détectés par personne** — ces anomalies demanderaient
+soit un prompt plus dirigé (liste explicite des champs à vérifier), soit
+un modèle plus large.
+
+## Décision
+
+- **Défaut serveur** : `RPA_SAFETY_CHECKS_LLM_MODEL=gemma4:latest`
+- **Timeout** : `RPA_SAFETY_CHECKS_LLM_TIMEOUT_S=7` (warm 2.9s + marge)
+- **Persistance VRAM** : `OLLAMA_KEEP_ALIVE=24h` recommandé pour éviter le
+  cold start de 10s en démo
+
+Modifications appliquées dans `agent_v0/server_v1/safety_checks_provider.py`.
+
+## Limites & travail futur
+
+1. **46% de détection est faible** : à présenter comme aide au médecin, pas
+  comme certification. Le médecin reste le décideur.
+2. **Prompt actuel trop générique** : un prompt qui liste explicitement les
+  champs à vérifier (DDN, IPP, diagnostic, forfait, cohérence âge/diagnostic)
+  donnerait probablement de meilleurs résultats. À mesurer en V2.
+3. **Bench sur 5 anomalies seulement** : à étendre dès qu'on a un corpus de
+  vrais dossiers Easily Assure avec anomalies confirmées par Pauline / Amina.
+4. **Pas de test sur des dossiers SANS anomalie** (faux positifs) : à ajouter.
+5. **Pas de bench des modèles cloud** (gemma3:27b-cloud, deepseek, gpt-oss)
+   par contrainte 100% local — mais à explorer si on lève cette contrainte
+   pour les checks contextuels (qui ne contiennent pas de PII si on
+   anonymise les screenshots).
+
+## Reproductibilité
+
+```bash
+cd /home/dom/ai/rpa_vision_v3
+.venv/bin/python tools/bench_safety_checks_models.py
+# (BENCH_TIMEOUT=60 par défaut, ~10-15 min sur RTX 5070)
+```

docs/BUG_PRECHECK_SPATIAL_BLINDNESS_2026-05-08.md

@@ -0,0 +1,40 @@
+# Bug — Pré-check OCR spatialement aveugle
+
+## Date de découverte
+2026-05-08, lors du test live du commit 2e76b44ff (log instrumentation)
+
+## Constat
+Sur les onglets adjacents (Imagerie / Notes médicales à 3 px d'écart dans la maquette urgences), le pré-check OCR valide à tort des clics sur le mauvais onglet.
+
+## Cause technique
+La fonction _text_match_fuzzy (resolve_engine.py:2285) vérifie la PRÉSENCE du texte attendu dans le crop OCR (radius_px=280, soit zone 560×560 px) mais pas sa POSITION par rapport au point cliqué.
+
+Le crop englobe plusieurs onglets adjacents → n'importe lequel des onglets matchant valide le clic.
+
+## Logs exemples
+Trois logs représentatifs du test du 2026-05-08 :
+
+```
+mai 08 22:16:26.977119 [REPLAY] Pre-check OCR ACTIF : 'Examens cliniques' attendu @ (0.2280, 0.2805) via hybrid_text_direct — observed='Al Voice Generator  Bookmarks archivtech com Maquette POC ssier en cours Codage ' is_valid=True (115ms)
+
+mai 08 22:16:33.048260 [REPLAY] Pre-check OCR ACTIF : 'Imagerie' attendu @ (0.2305, 0.2676) via hybrid_text_direct — observed='9 Al Voice Generator_ Bookmarks archivtech.com Maquette POC sier en cours Statis' is_valid=True (86ms)
+
+mai 08 22:16:43.045705 [REPLAY] Pre-check OCR ACTIF : 'Notes médicales' attendu @ (0.2020, 0.2800) via template_matching — observed='18 Al Voice Generator_ Bookmarks archivtech. Urgences Maquette POC Dossier en co' is_valid=True (99ms)
+```
+
+## Options de fix
+**Option A — Réduire radius_px**
+- Pro : simple (1 ligne)
+- Con : casse la validation des textes longs ("Synthèse Urgences")
+
+**Option B — Bboxes individuelles EasyOCR + vérification distance**
+- Pro : robuste, gère textes longs et onglets serrés
+- Con : changement de logique de _text_match_fuzzy, pas tweak
+
+## Décision
+Reporté à post-démo Kerella. À traiter à froid.
+Préférence : Option B (plus pérenne).
+
+## Commits liés
+- 731b5bcae : réactivation pré-check OCR avec calibrage chirurgical
+- 2e76b44ff : instrumentation log positif qui a révélé le bug

docs/CARTE_FONCTIONNELLE_2026-05-08.md

@@ -0,0 +1,277 @@
+# Carte fonctionnelle RPA Vision V3 — 2026-05-08
+
+Branche : `feature/qw-suite-mai` | HEAD : `731b5bcae`
+Vue produit (pas code). Inventaire des fonctionnalités telles qu'elles existent réellement dans le repo à cette date.
+
+---
+
+## 1. Modes opérationnels de Léa (agent_v1)
+
+Le client Léa V1 (`agent_v0/agent_v1/`) n'expose **pas** d'enum `MODE_*` discret. Son comportement runtime est piloté par trois booléens cumulables dans `AgentState` (`ui/shared_state.py`) :
+
+| Mode | Module(s) concerné(s) | Activation | Statut |
+|---|---|---|---|
+| Capture / enregistrement | `ui/shared_state.py:30` (`_recording`), `core/captor.py`, `vision/capturer.py` | Bouton "Démarrer" dans systray (`smart_tray.py:377`) ou ChatWindow → `state.start_recording(name)` | actif |
+| Replay (polling serveur) | `main.py:130` (`_replay_poll_loop`), `core/executor.py:510-1900` | Boucle daemon permanente, lancée à l'init de `AgentV1` indépendamment de toute session — poll `GET /replay/next` toutes les 1 s sur `agent_{user_id}` | actif |
+| Heartbeat permanent (background) | `main.py:131` (`_background_heartbeat_loop`) | Daemon permanent, screenshot toutes les 5 s vers `POST /traces/stream/image` (session `bg_{machine_id}`) | actif |
+| Heartbeat session | `main.py:434` (`_heartbeat_loop`) | Démarre seulement quand `session_id` actif (pendant un enregistrement) | actif |
+| Watchdog fichier `command.json` | `main.py:247` (`_command_watchdog_loop`) | Poll fichier `C:\rpa_vision\command.json` toutes les 1 s, exécute `execute_normalized_order` | actif (legacy GHOST replay) |
+| Capture à la demande HTTP | `ui/capture_server.py` | Mini-serveur HTTP local port 5006 lancé au boot | actif |
+| Auto-stop session | `main.py:160` (`_auto_stop_loop`) | Notifie 10 min avant et stoppe à `MAX_SESSION_DURATION_S` | actif |
+
+**Modes "shadow / copilot / assisté / autonomous"** : ils n'existent **pas** côté client Léa V1. Côté serveur, `execution_mode` est un paramètre de replay (`"autonomous"` par défaut, voir `api_stream.py:2969`, `replay_engine.py:1520`). Les valeurs détectées : `"autonomous"`, `"verified"`, `"supervised"` (déduit du test `_exec_mode != "autonomous"` à `api_stream.py:2974`). Le frontend VWB définit en plus `'basic' | 'intelligent' | 'debug' | 'verified'` (`types.ts:15`) — **ce sont des modes VWB, pas des modes Léa**. [À VÉRIFIER PAR DOM]
+
+Endpoints `/api/v1/shadow/*` (start/stop/feedback/build/understanding) existent côté serveur (`api_stream.py:1661-1820`) mais aucun n'est appelé depuis le client Léa V1 (grep dans `agent_v0/agent_v1/` : zéro hit). [À VÉRIFIER PAR DOM]
+
+---
+
+## 2. Capacités du serveur (rpa-streaming + dépendances)
+
+54 endpoints exposés par `agent_v0/server_v1/api_stream.py`.
+
+### 2.1 Streaming session / heartbeat
+- `POST /api/v1/traces/stream/register` — Enregistrer une session (session_id + machine_id)
+- `POST /api/v1/traces/stream/event` — Pousser un événement clavier/souris/fenêtre
+- `POST /api/v1/traces/stream/image` — Pousser un screenshot (heartbeat ou shot d'action)
+- `POST /api/v1/traces/stream/finalize` — Clore une session
+- `GET /api/v1/traces/stream/processing/status` — État de la file de traitement
+- `POST /api/v1/traces/stream/processing/requeue` — Re-traiter une session déjà finalisée
+- `GET /api/v1/traces/stream/stats` — Statistiques globales du serveur
+- `GET /api/v1/traces/stream/machines` — Liste machines enrôlées
+- `GET /api/v1/traces/stream/sessions` — Liste sessions (filtrable par machine_id)
+
+### 2.2 Replay (next/report/resolve_target/pause)
+- `POST /api/v1/traces/stream/replay` — Lancer un replay depuis un workflow_id
+- `POST /api/v1/traces/stream/replay/raw` — Lancer un replay depuis une liste d'actions brutes
+- `POST /api/v1/traces/stream/replay-session` — Re-rejouer une session enregistrée
+- `POST /api/v1/traces/stream/replay/single` — Enqueuer une action unique
+- `POST /api/v1/traces/stream/replay/plan` — Lancer depuis un ExecutionPlan (V4)
+- `POST /api/v1/traces/stream/workflow/compile` — Compiler session → WorkflowIR + ExecutionPlan
+- `GET /api/v1/traces/stream/replay/next` — Action suivante à exécuter (pollée par Léa)
+- `POST /api/v1/traces/stream/replay/result` — Rapport d'exécution d'une action
+- `POST /api/v1/traces/stream/replay/error_callback` — Callback erreur configurable
+- `GET /api/v1/traces/stream/replay/{replay_id}` — État d'un replay
+- `GET /api/v1/traces/stream/replays` — Liste des replays
+- `POST /api/v1/traces/stream/replay/{replay_id}/resume` — Reprendre après pause supervisée
+- `POST /api/v1/traces/stream/replay/{replay_id}/cancel` — Annuler un replay
+- `POST /api/v1/traces/stream/replay/resolve_target` — Résoudre la position d'une ancre (cascade vLLM/Ollama)
+- `POST /api/v1/traces/stream/replay/pre_analyze` — Pré-analyse de l'écran avant action
+
+### 2.3 Extraction (text / table / décision T2A)
+Pas d'endpoint HTTP dédié — ces actions sont enqueuées côté serveur via le replay et traitées sans round-trip Léa par `replay_engine.py:_handle_extract_text_action / _handle_extract_table_action / _handle_t2a_decision_action` (modules `core/llm/ocr_extractor.py` et `core/llm/t2a_decision.py`).
+
+### 2.4 Federation / learning packs
+- `GET /api/v1/traces/stream/learning-pack/export` — Export anonymisé (par client_id)
+- `POST /api/v1/traces/stream/learning-pack/import` — Import + merge dans FAISS global
+
+### 2.5 Health / monitoring
+- `GET /health` — Healthcheck simple
+- `GET /api/v1/traces/stream/workflows` — Liste workflows visibles
+- `POST /api/v1/traces/stream/reload-workflows` — Rechargement à chaud
+- `GET /api/v1/traces/stream/workflow/{workflow_id}` — Détail workflow
+- `GET /api/v1/traces/stream/session/{session_id}` — Détail session
+- `GET /api/v1/audit/history` — Historique audit (RGPD/IA Act)
+- `GET /api/v1/audit/summary` — Résumé audit
+- `GET /api/v1/audit/export` — Export audit
+
+### 2.6 Autres
+- `POST /api/v1/shadow/start` — Démarrer un observateur shadow (existe, voir §1)
+- `POST /api/v1/shadow/stop` — Arrêter
+- `POST /api/v1/shadow/feedback` — Feedback humain sur une étape observée
+- `GET /api/v1/shadow/{session_id}/understanding` — Lire la compréhension construite
+- `POST /api/v1/shadow/build` — Compiler en workflow
+- `POST /api/v1/task` — Tâche planifiée (TaskPlanner)
+- `GET /api/v1/task/capabilities` — Capacités déclarées (action types)
+- `POST /api/v1/chat/session` — Créer une session de chat serveur
+- `POST /api/v1/chat/{session_id}/message` — Envoyer message
+- `GET /api/v1/chat/{session_id}/history` — Historique
+- `POST /api/v1/chat/{session_id}/confirm` — Confirmer un plan
+- `GET /api/v1/chat/sessions` — Liste sessions chat
+- `POST /api/v1/agents/enroll` — Enrôler un nouvel agent (nouvelle machine)
+- `POST /api/v1/agents/uninstall` — Désenrôler
+- `GET /api/v1/agents/fleet` — État de la flotte
+
+---
+
+## 3. Stack VLM / grounding active
+
+Synthèse de `docs/HISTORIQUE_VLM_IMPLEMENTATIONS_2026-05-08.md` (§1, §6).
+
+| Modèle | Backend | Module appelant | Statut |
+|---|---|---|---|
+| `InfiX-ai/InfiGUI-G1-3B` 4-bit NF4 | Transformers in-process (Flask) | `core/grounding/server.py` (port 8200) | câblé mais inactif (pas dans la cascade actuelle) |
+| `InfiX-ai/InfiGUI-G1-3B` 4-bit NF4 | Transformers subprocess one-shot | `core/grounding/infigui_worker.py` | câblé mais inactif (utilisé en fallback de la socket) |
+| `InfiX-ai/InfiGUI-G1-3B` 4-bit NF4 | Transformers daemon Unix socket `/run/rpa/grounding.sock` | `core/grounding/infigui_server.py` (service systemd `rpa-grounding.service`) | service présent — `rpa-grounding.service.parked` détecté dans `/etc/systemd/system/` [À VÉRIFIER PAR DOM] |
+| `Qwen/Qwen2.5-VL-7B-Instruct-AWQ` | vLLM HTTP OpenAI-compat (port `VLLM_PORT=8100`) | `agent_v0/server_v1/resolve_engine.py:785-816` (`_resolve_by_grounding`) | utilisé en prod — essai 1 (fallback Ollama) [À VÉRIFIER PAR DOM si vLLM tourne] |
+| `qwen2.5vl:7b` | Ollama HTTP `/api/chat` | `resolve_engine.py:818-832` (fallback de vLLM) | utilisé en prod — fallback principal de la cascade |
+| `qwen2.5vl:7b` | Ollama HTTP `/api/chat` | `resolve_engine.py:2536-2585` (`_locate_popup_button`) | utilisé en prod — cas spécifique popup |
+| `qwen3-vl:8b`, `gemma4:e4b` | Ollama HTTP | `core/detection/ollama_client.py` (utilisé par `ui_detector.py`, `som_engine.py`, `vram_orchestrator.py`) | utilisé en prod — détection UI + SoM côté core/detection |
+| `qwen2.5vl:3b` | Ollama HTTP | `visual_workflow_builder/backend/api_v3/capture.py:245` (description anchor) | utilisé en prod — chaîne capture VWB |
+| `qwen3-vl:8b` | Ollama HTTP | `visual_workflow_builder/backend/api_v3/dag_execute.py:468` (LLMActionHandler) | utilisé en prod — DAG executor LLM |
+| `qwen2.5vl` | Ollama HTTP | `visual_workflow_builder/backend/catalog_routes_v2_vlm.py` | utilisé en prod — catalog UI |
+| OpenAI-compat cloud (OpenAI/Gemini/Anthropic) | HTTP cloud (opt-in `VLM_ALLOW_CLOUD=true`) | `visual_workflow_builder/backend/vlm_provider.py` | câblé mais inactif (cloud désactivé par défaut, contraire à la directive 100% local) |
+| `cckevinn/SeeClick` (Qwen-VL) | Transformers in-process | `core/detection/seeclick_adapter.py` | téléchargé non utilisé (signalé "cassé" par commit `d1b556b6c`, exporté par `__init__.py` mais zéro call site actif) |
+| `Owlv2` (Google OWL-v2) | Transformers in-process | `core/detection/owl_detector.py` (via `ui_detector.py:31,113,126`) | câblé mais inactif (présent dans la chaîne de détection — bench récent inconnu) [À VÉRIFIER PAR DOM] |
+| `ByteDance-Seed/UI-TARS-1.5-7B` | Transformers (référencé) | `tools/start_grounding_server.sh` | référencé en doc seulement (modèle remplacé par InfiGUI dans le code par commit `77faa03ec`) |
+
+---
+
+## 4. Capacités du VWB (visual_workflow_builder)
+
+### 4.1 Modes de construction de workflows
+Trois voies coexistent :
+1. **Capture interactive** : sélection de zones/ancres via `POST /api/v3/capture/screen` + `POST /api/v3/capture/select` (frontend `CapturePanel.tsx`, `CaptureLibrary.tsx`).
+2. **Édition manuelle dans le canvas** : ajout d'étapes via `POST /api/v3/workflow/{id}/step` (frontend `StepNode.tsx`, `ToolPalette.tsx`, `PropertiesPanel.tsx`).
+3. **Import de workflow appris par Léa** : `POST /api/v3/learned-workflows/{id}/import` lit les workflows produits côté streaming server (sessions enregistrées) et les insère en SQLite VWB.
+
+### 4.2 Types d'actions supportées
+36 types listés dans `frontend_v4/src/types.ts:40-82` (constante `ACTIONS`).
+
+**Souris** :
+- `click_anchor` — Clic gauche sur élément visuel — needs anchor : oui
+- `double_click_anchor` — Double-clic — needs anchor : oui
+- `right_click_anchor` — Clic droit (menu contextuel) — needs anchor : oui
+- `hover_anchor` — Survol — needs anchor : oui
+- `drag_drop_anchor` — Glisser-déposer vers cible — needs anchor : oui
+- `scroll_to_anchor` — Défiler jusqu'à élément — needs anchor : oui
+- `focus_anchor` — Donner focus clavier — needs anchor : oui
+
+**Clavier** :
+- `type_text` — Saisir texte (templating `{{var}}`) — needs anchor : non
+- `type_secret` — Saisir secret depuis coffre-fort — needs anchor : non
+- `keyboard_shortcut` — Combinaison touches — needs anchor : non
+
+**Attente** :
+- `wait_for_anchor` — Attendre apparition élément — needs anchor : oui
+
+**Données** :
+- `extract_text` — OCR EasyOCR fr+en sur dernier screenshot → variable — needs anchor : non
+- `extract_table` — OCR + filtre regex → liste structurée → variable — needs anchor : oui
+- `screenshot_evidence` — Capture preuve — needs anchor : non
+- `download_to_folder` — Télécharger fichier — needs anchor : non
+- `db_save_data` / `db_read_data` — BDD locale — needs anchor : non
+- `import_excel` / `db_foreach` — Boucle Excel/CSV → BDD — needs anchor : non
+
+**Logique** :
+- `visual_condition` — Branchement si ancre trouvée — needs anchor : oui (hidden : true)
+- `loop_visual` — Boucle tant qu'ancre visible — needs anchor : oui (hidden : true)
+- `pause_for_human` — Pause supervisée + safety_checks (QW4) — needs anchor : non
+- `t2a_decision` — Analyse DPI urgences via LLM local (qwen2.5:7b par défaut) — needs anchor : non
+
+**IA (Ollama vision/text)** :
+- `ai_ocr` — OCR IA sur ancre — needs anchor : oui
+- `ai_summarize` — Résumé LLM — needs anchor : non
+- `ai_extract` — Extraction structurée IA — needs anchor : oui
+- `ai_classify` — Classification — needs anchor : non
+- `ai_analyze_text` — Analyse libre — needs anchor : non
+- `ai_custom` — Appel IA libre avec system prompt — needs anchor : non
+
+**LLM via DAGExecutor (parallèle)** :
+- `llm_analyze` / `llm_translate` / `llm_extract_data` / `llm_generate` — needs anchor : non
+
+**Fichiers** :
+- `file_list_dir` / `file_create_dir` / `file_move` / `file_copy` / `file_sort_by_ext` — needs anchor : non
+
+**Validation** :
+- `verify_element_exists` — needs anchor : oui
+- `verify_text_content` — needs anchor : oui
+
+### 4.3 Intégration avec Léa
+Le VWB **ne pousse pas** un workflow à Léa : il l'**enregistre** côté streaming server. Mécanisme :
+1. Workflow sauvé en SQLite VWB (`workflows.db`).
+2. `POST /api/v3/workflow/{id}/export-for-lea` (`learned_workflows.py:413`) sérialise et envoie au streaming server (proxy `STREAMING_SERVER_URL=http://localhost:5005`).
+3. Lancement : frontend appelle `POST /api/v3/execute/start` (`execute.py:1528`) qui transite vers `POST /api/v1/traces/stream/replay` côté streaming server.
+4. Léa V1 récupère ensuite les actions une à une via son polling `GET /replay/next` (cf. §1).
+
+### 4.4 Bibliothèque de captures
+Disponible. Architecture v2 (avril 2026) :
+- PNG HD écrit dans `data/library_captures/{id}.png` (source de vérité)
+- `data/capture_library.json` = métadonnées + thumbnail base64 640×360 q85 (rapide à charger pour la grille)
+- Endpoints : `GET/POST /api/v3/capture/library`, `POST /api/v3/capture/library/upload`, `GET /api/v3/capture/library/{id}/full`, `DELETE /api/v3/capture/library/{id}`
+- Permet à l'utilisateur de réutiliser des captures (ancres) entre workflows sans recapturer.
+
+---
+
+## 5. Capacités de l'agent_chat
+
+### 5.1 Endpoints
+23 routes Flask dans `agent_chat/app.py` :
+- `GET /` — UI principale chat
+- `GET /classic` — UI classique
+- `GET /api/status` — Statut serveur
+- `GET /api/workflows` — Liste workflows disponibles
+- `POST /api/workflows/refresh` — Recharger
+- `GET /api/machines` — Liste machines
+- `POST /api/search` — Recherche workflow
+- `POST /api/execute` — Exécuter un workflow nommé
+- `GET /api/history` — Historique conversations
+- `POST /api/chat` — Endpoint chat principal (routage NLP)
+- `POST /api/gpu/<action>` — Contrôle GPU (start/stop/status)
+- `GET /api/llm/status` — Statut Ollama
+- `POST /api/llm/model` — Changer modèle actif
+- `POST /api/agent/plan` — Planifier (autonomous_planner)
+- `POST /api/agent/execute` — Lancer plan
+- `GET /api/agent/status` — Statut agent
+- `GET /api/gestures` — Catalogue de gestures réflexes
+- `POST /api/chat/upload` — Upload pièce jointe
+- `GET /api/help` — Aide
+- `POST /api/urgences/parse` — Parsing intent "traite N dossiers" (gemma3:1b)
+- `POST /api/urgences/start` — Démarre l'orchestrateur urgences
+- `GET /api/urgences/status/<orch_id>` — État orchestrateur
+- `GET /api/urgences/list` — Liste orchestrations en cours
+
+### 5.2 Cas d'usage métier
+- **Orchestration urgences GHT** (`urgences_orchestrator.py`) : reçoit "traite N dossiers" en chat, parse via `gemma3:1b`, ouvre Chrome (Win+R) sur la maquette Easily Assure via `/replay/raw`, extrait la liste IPP avec `extract_table`, puis pour chaque IPP lance le workflow `Urgence_unit` via `/replay` avec `variables={"patient_id": ipp}`. Synthèse finale postée dans le chat. État pollable via `/api/urgences/status/<id>`.
+- **Recherche/exécution workflow par nom naturel** (`/api/search` + `/api/execute`) — résolution sémantique nom utilisateur → workflow_id.
+- **Plan autonome** (`/api/agent/plan` + `/api/agent/execute`) — `autonomous_planner.py` planifie un workflow inédit à partir d'un objectif libre via `qwen2.5:7b`.
+
+### 5.3 Modèles LLM utilisés
+- `gemma3:1b` — NLP intent parsing urgences (`urgences_orchestrator.py:58`, env `LEA_NLP_MODEL`)
+- `qwen2.5:7b` — chat principal + autonomous_planner (`app.py:229,319`, `intent_parser.py:283,690`)
+- `qwen3:8b` — modèle Léa par défaut env `LEA_LLM_MODEL` (`app.py:675`), avec `think=False` désactivé (qwen3)
+
+---
+
+## 6. Modules orphelins (code présent mais non câblé)
+
+| Module | Chemin | Pourquoi orphelin (factuel) | Mentionné en commit ou doc ? |
+|---|---|---|---|
+| `core/grounding/fast_pipeline.py` | `core/grounding/` | Référencé uniquement par `core/execution/observe_reason_act.py:1639` (lui-même semi-orphelin, voir ci-dessous). Zéro import depuis `agent_v0/server_v1/`, `visual_workflow_builder/backend/`, `agent_chat/`. | commit `b30d4b665` (Phase 4 FAST→SMART→THINK) |
+| `core/grounding/fast_detector.py` | `core/grounding/` | Zéro import depuis le code actif. | commit `ea36bba5c` (Phase 1-2) |
+| `core/grounding/smart_matcher.py` | `core/grounding/` | Zéro import depuis le code actif. | commit `ea36bba5c` |
+| `core/grounding/think_arbiter.py` | `core/grounding/` | Zéro import depuis le code actif. | commit `e4a48e78b` (Phase 3) |
+| `core/grounding/shadow_learning_hook.py` | `core/grounding/` | Zéro import dans `agent_v0/server_v1/`, `visual_workflow_builder/`, `agent_chat/`. | commit `73cea2385` (Phase 6) ; mémoire mentionne "ShadowLearningHook non branché" |
+| `core/grounding/template_matcher.py` | `core/grounding/` | Zéro import depuis le code actif. | commit `9da589c8c` (création) |
+| `core/grounding/pipeline.py` | `core/grounding/` | Zéro import depuis le code actif. | commit `9da589c8c` |
+| `core/grounding/element_signature.py` | `core/grounding/` | Zéro import depuis le code actif. | commit `e4a48e78b` |
+| `core/grounding/server.py` (Flask 8200) | `core/grounding/` | Daemon Flask single-thread alternatif à `infigui_server.py` (Unix socket). Pas de service systemd actif pointant dessus. | doc `tools/start_grounding_server.sh` (toujours obsolète, pointe UI-TARS) |
+| `core/detection/seeclick_adapter.py` | `core/detection/` | Encore exporté par `core/detection/__init__.py` mais zéro call site actif. Signalé "cassé" par commit `d1b556b6c`. | commit `21bfa3b33` (création) ; `d1b556b6c` (suppression call site) |
+| `core/learning/target_memory_store.py` | `core/learning/` | Référencé par `agent_v0/server_v1/replay_memory.py:62` et `replay_learner.py:210` — **pas orphelin** (semi-actif via replay_memory). | mémoire "V3/V4 découplés au runtime" |
+| `core/learning/continuous_learner.py` | `core/learning/` | Zéro import depuis code actif. | — |
+| `core/learning/feedback_processor.py` | `core/learning/` | Zéro import. | — |
+| `core/learning/versioned_store.py` | `core/learning/` | Zéro import. | — |
+| `core/execution/target_resolver.py` | `core/execution/` | Zéro import depuis code actif. | mémoire "TargetResolver cross-frame bug" |
+| `core/execution/target_memory.py` | `core/execution/` | Zéro import. | — |
+| `core/execution/action_executor.py` | `core/execution/` | Zéro import. | — |
+| `core/execution/execution_robustness.py` | `core/execution/` | Zéro import. | — |
+| `core/execution/recovery_strategies.py` | `core/execution/` | Zéro import. | — |
+| `core/execution/observe_reason_act.py` | `core/execution/` | Importé par `visual_workflow_builder/backend/api_v3/execute.py:1431,1955` (mode `verified` ORALoop). Pas pleinement orphelin mais activé seulement dans ce mode. | mémoire "Phase 5 intégration FAST→SMART→THINK dans ORA" |
+| `core/healing/healing_engine.py` + `confidence_scorer.py` + `recovery_logger.py` + `learning_repository.py` | `core/healing/` | Zéro import depuis `agent_v0/server_v1/` et `visual_workflow_builder/backend/api_v3/`. Seul `execution_integration.py` est référencé (2 occurrences). | — |
+| Service systemd `rpa-streaming.service` | `deploy/systemd/` | Présent dans le repo mais `/etc/systemd/system/rpa-streaming.service.parked` → **inactif** sur la machine de Dom. | — |
+| Service systemd `rpa-grounding.service` | `deploy/systemd/` | `/etc/systemd/system/rpa-grounding.service.parked` → **inactif**. | commit `3d6868f02` |
+| Service systemd `rpa-vision-v3-api.service` / `rpa-vision-v3-worker.service` / `rpa-vision-v3-dashboard.service` / `rpa-agent-chat.service` | `deploy/systemd/` | Tous trouvés `.parked` dans `/etc/systemd/system/`. | — |
+| `agent_v0/server_v1/safety_checks_provider.py` | `agent_v0/server_v1/` | **Pas orphelin** : importé par `api_stream.py:2980` (QW4 build_pause_payload). Listé pour contexte. | mémoire "QW4 safety_checks hybrides" |
+| Endpoints `/api/v1/shadow/*` | `agent_v0/server_v1/api_stream.py:1661-1820` | Définis côté serveur, **aucun appelant identifié** dans `agent_v0/agent_v1/` (Léa client) ni dans `visual_workflow_builder/`, ni dans `agent_chat/`. | — [À VÉRIFIER PAR DOM] |
+
+---
+
+## 7. À vérifier avec Dom (synthèse des `[À VÉRIFIER PAR DOM]`)
+
+- **Modes Léa "shadow / copilot / assisté"** : seuls les booléens `_recording` / `_replay_active` existent côté client. Confirme-tu qu'aujourd'hui Léa V1 n'a effectivement que ces deux modes runtime (et que les modes VWB `basic/intelligent/debug/verified` ne pilotent rien du client) ?
+- **Endpoints `/api/v1/shadow/*`** côté serveur : zéro appelant identifié dans le repo. Sont-ils consommés par un script externe / une démo, ou candidats à archivage ?
+- **Service `rpa-grounding.service`** : présent dans `deploy/systemd/` mais en `.parked` sur la machine. La cascade vLLM→Ollama tourne donc sans `infigui_server.py` ? Confirmer que le grounding Transformers est bien désactivé en prod actuellement.
+- **Service `rpa-streaming.service`** : trouvé `.parked` dans `/etc/systemd/system/`. Le streaming server tourne-t-il via `svc.sh` / `run.sh` au lieu de systemd ?
+- **`core/detection/seeclick_adapter.py`** : encore exporté par `__init__.py` mais signalé cassé. Sortir de l'export ou tenter une réparation pour Qwen3-VL ?
+- **`core/detection/owl_detector.py` (Owlv2)** : câblé via `ui_detector.py` mais aucun bench récent. Encore appelé en prod ou candidat à l'archivage ?
+- **vLLM (port 8100)** : code prêt dans `resolve_engine.py:785-816`. Confirmer si vLLM tourne actuellement ou si la cascade saute systématiquement à Ollama.
+- **Mode VWB `verified`** : seul mode qui active `core/execution/observe_reason_act.py` (ORALoop). Est-il utilisé en démo GHT ou réservé au debug ?

docs/CARTOGRAPHY.md

@@ -0,0 +1,233 @@
+# Cartographie d'exécution — RPA Vision V3 (Léa)
+
+> **Date** : 26 avril 2026  
+> **Objectif** : carte complète de ce qui est branché, ce qui ne l'est pas, et comment les données transitent.  
+> **Règle** : LIRE CE DOCUMENT AVANT TOUTE MODIFICATION DE CODE.
+
+---
+
+## 1. Point d'entrée : deux chemins disjoints
+
+```
+POST /api/v3/execute/start  (execute.py:1528)
+  ├── execution_mode = "verified"  → run_workflow_verified()  ← CHEMIN ORA
+  └── execution_mode = "basic"|"intelligent"|"debug"  → execute_workflow_thread()  ← CHEMIN LEGACY
+```
+
+**Il existe DEUX exécuteurs distincts** qui dupliquent le chargement des ancres, la boucle d'étapes, le grounding, la gestion d'erreurs. Ils ne partagent que `input_handler.py`.
+
+---
+
+## 2. Chemin LEGACY (modes basic/intelligent/debug)
+
+```
+[API] POST /execute/start (mode=intelligent)
+  → [execute.py:145] execute_workflow_thread()
+    → [execute.py:160] Charge steps depuis DB
+    → BOUCLE sur chaque step:
+      │
+      ├─ RÉFLEXE PRÉ-ÉTAPE (modes intelligent/debug)
+      │   → [input_handler.py:79] check_screen_for_patterns()
+      │       → UIPatternLibrary.find_pattern(ocr_text)               ← BRANCHÉ
+      │   → [input_handler.py:129] handle_detected_pattern()
+      │       → EasyOCR full screen + clic bouton                     ← BRANCHÉ
+      │
+      ├─ CHARGEMENT ANCRE [execute.py:222-256]
+      │   params['visual_anchor'] = {
+      │     screenshot: base64 du crop,
+      │     bounding_box: {x, y, width, height},
+      │     target_text: anchor.target_text,      ← PEUT ÊTRE VIDE ("")
+      │     description: anchor.ocr_description   ← PEUT ÊTRE VIDE ("")
+      │   }
+      │
+      ├─ execute_action(action_type, params) [execute.py:278]
+      │   │
+      │   ├─ ACTION = click_anchor [execute.py:862-1096]
+      │   │  │
+      │   │  ├─ MODE basic: coordonnées statiques (bbox centre)
+      │   │  │
+      │   │  └─ MODE intelligent/debug:
+      │   │     ├─ target_text = anchor.target_text || step.label
+      │   │     │   Si target_text == "click_anchor" et screenshot_base64:
+      │   │     │     → _describe_anchor_image() (VLM qwen2.5vl:3b)  ← BRANCHÉ
+      │   │     │
+      │   │     ├─ MÉTHODE 1: Template matching (cv2)                ← BRANCHÉ
+      │   │     ├─ MÉTHODE 2: CLIP matching (RF-DETR + CLIP)         ← BRANCHÉ
+      │   │     ├─ MÉTHODE 3: OCR → UI-TARS → VLM                   ← BRANCHÉ
+      │   │     └─ ÉCHEC: self-healing interactif                    ← BRANCHÉ
+      │   │
+      │   ├─ ACTION = type_text → safe_type_text()                   ← BRANCHÉ
+      │   ├─ ACTION = wait → sleep + pattern check                   ← BRANCHÉ
+      │   ├─ ACTION = keyboard_shortcut → pyautogui.hotkey()         ← BRANCHÉ
+      │   ├─ ACTION = ai_analyze_text → Ollama                       ← BRANCHÉ
+      │   ├─ ACTION = extract_text → docTR OCR                       ← BRANCHÉ
+      │   └─ ACTION = hover/scroll/focus → coords statiques          ← PAS DE GROUNDING
+```
+
+---
+
+## 3. Chemin ORA (mode "verified")
+
+```
+[API] POST /execute/start (mode=verified)
+  → [execute.py:1349] run_workflow_verified()
+    → [execute.py:1380-1428] Charge steps + ancres (MÊME logique que legacy)
+    → [execute.py:1433] ORALoop(verify_level='none', max_retries=2)
+    │                            ^^^^^^^^^^^^^^^^^^^
+    │                   VÉRIFICATION DÉSACTIVÉE EN DUR
+    │
+    → [ORA:1478] ora.run_workflow(steps=ora_steps)
+      │
+      BOUCLE sur chaque step:
+        │
+        ├─ [ORA:1258] OBSERVE: capture écran + pHash + titre fenêtre
+        │
+        ├─ [ORA:1263] RÉFLEXE DIALOGUE (si pHash changé > 10)
+        │   → DialogHandler.handle_if_dialog(screenshot)               ← BRANCHÉ
+        │     → EasyOCR full screen → mots-clés dialogues connus
+        │     → InfiGUI worker (/tmp/infigui_*)
+        │     → Fallback OCR clic
+        │
+        ├─ [ORA:196] REASON: reason_workflow_step()
+        │   target_text = anchor.target_text || anchor.description
+        │   Si vide ou nom d'action → _describe_anchor_image()         ← CORRIGÉ 26/04
+        │   Si encore vide → label (si pas un nom d'action)
+        │
+        ├─ [ORA:1306] ACT → _act_click()
+        │   │
+        │   ├─ RPA_USE_FAST_PIPELINE=1 (défaut)
+        │   │   → FastSmartThinkPipeline
+        │   │     → FastDetector (RF-DETR 120ms + EasyOCR 192ms)       ← BRANCHÉ
+        │   │     → SmartMatcher (texte+type+position+voisins <1ms)    ← BRANCHÉ
+        │   │     → SignatureStore.lookup() (apprentissage)             ← BRANCHÉ
+        │   │     → Score ≥ 0.90 → action directe                     ← BRANCHÉ
+        │   │     → Score 0.60-0.90 → ThinkArbiter
+        │   │       → UITarsGrounder → InfiGUI worker (/tmp)           ← BRANCHÉ
+        │   │     → Score < 0.60 → ThinkArbiter seul                  ← BRANCHÉ
+        │   │     → ÉCHEC → _try_fallback()
+        │   │       → GroundingPipeline                    ← NON BRANCHÉ (jamais connecté)
+        │   │
+        │   ├─ FALLBACK template matching (cv2, >0.75)                 ← BRANCHÉ
+        │   ├─ FALLBACK OCR (_grounding_ocr)                           ← BRANCHÉ
+        │   └─ DERNIER RECOURS: coords statiques                       ← BRANCHÉ
+        │
+        ├─ [ORA:1337] VÉRIFICATION TITRE (post-action)
+        │   → TitleVerifier → EasyOCR crop 45px                       ← BRANCHÉ
+        │   *** NE LIT RIEN EN VM (titre Windows dans le framebuffer) ← PROBLÈME
+        │
+        ├─ [ORA:1358] VERIFY: verify(pre, post, decision)
+        │   *** DÉSACTIVÉ (verify_level='none') ***                    ← NON BRANCHÉ
+        │
+        └─ [ORA:1362] RECOVERY (5 stratégies)
+            *** JAMAIS ATTEINT ***                                     ← NON BRANCHÉ
+            - _recover_element_not_found (wait+scroll+UI-TARS)
+            - _recover_overlay_blocking (pattern+Win+D)
+            - _recover_wrong_screen (Alt+Tab)
+            - _recover_no_effect (double-clic+décalage)
+            - _classify_error (4 types)
+```
+
+---
+
+## 4. Trace du champ `target_text`
+
+```
+CAPTURE (VWB CapturePanel → capture.py:201-263)
+  → OCR sur crop élargi (docTR)
+  → VLM qwen2.5vl:3b décrit le crop
+  → Si les deux échouent → target_text = ""
+  → Aucune erreur remontée au frontend
+
+STOCKAGE (DB)
+  → VisualAnchor.target_text (nullable) = "" si non renseigné
+
+CHARGEMENT (execute.py:1400-1428)
+  → SI anchor.target_text existe et non vide → injecté dans visual_anchor
+  → SINON → la clé 'target_text' N'EXISTE PAS dans le dict
+
+LEGACY (execute.py:893-907)
+  → target_text = anchor.get('target_text', '')
+  → SI vide ET c'est un nom d'action → _describe_anchor_image()       ← COMPENSE
+  → SINON → fallback sur step_label
+
+ORA (observe_reason_act.py:217) — CORRIGÉ LE 26 AVRIL
+  → target_text = anchor.target_text || anchor.description
+  → SI vide ou nom d'action → _describe_anchor_image()                ← AJOUTÉ
+  → SINON → label (si pas un nom d'action)
+```
+
+---
+
+## 5. Fonctions existantes NON BRANCHÉES
+
+| Fonction | Fichier | Raison |
+|----------|---------|--------|
+| `verify()` + `_classify_error()` + 5 `_recover_*()` | observe_reason_act.py | verify_level='none' en dur |
+| `GroundingPipeline` (ancien) | pipeline.py | set_fallback_pipeline() jamais appelé |
+| `TemplateMatcher` (classe centralisée) | template_matcher.py | Utilisé seulement par GroundingPipeline mort |
+| `ShadowLearningHook` | shadow_learning_hook.py | Jamais importé dans aucun flux |
+| `CognitiveContext` | working_memory.py | Mode instruction seulement |
+| `VLM pre-check` | observe_reason_act.py | `if False:` en dur |
+| hover/focus grounding | execute.py | Coords statiques uniquement |
+| `grounding/server.py` (FastAPI :8200) | server.py | Crash CUDA, remplacé par worker fichiers |
+
+---
+
+## 6. Les 12 systèmes de grounding
+
+| # | Système | Fichier | Branché ? |
+|---|---------|---------|-----------|
+| 1 | Template matching inline (legacy) | execute.py:914 | ✅ Legacy |
+| 2 | Template matching inline (ORA) | ORA:1475 | ✅ ORA fallback |
+| 3 | CLIP matching (IntelligentExecutor) | intelligent_executor.py | ✅ Legacy |
+| 4 | OCR docTR (_grounding_ocr) | input_handler.py:430 | ✅ Legacy + ORA |
+| 5 | UI-TARS Ollama (_grounding_ui_tars) | input_handler.py:513 | ✅ Legacy |
+| 6 | VLM reasoning (_grounding_vlm) | input_handler.py:627 | ✅ Legacy seulement |
+| 7 | FastDetector (RF-DETR + EasyOCR) | fast_detector.py | ✅ ORA |
+| 8 | SmartMatcher | smart_matcher.py | ✅ ORA |
+| 9 | ThinkArbiter → InfiGUI worker | think_arbiter.py + ui_tars_grounder.py | ✅ ORA |
+| 10 | DialogHandler → InfiGUI | dialog_handler.py | ✅ ORA réflexe |
+| 11 | GroundingPipeline (ancien) | pipeline.py | ❌ Jamais connecté |
+| 12 | TemplateMatcher classe | template_matcher.py | ❌ Via GroundingPipeline mort |
+
+---
+
+## 7. Gestion des dialogues (2 systèmes parallèles)
+
+| # | Système | Base de patterns | OCR | Clic | Utilisé par |
+|---|---------|-----------------|-----|------|-------------|
+| 1 | UIPatternLibrary + handle_detected_pattern | 28 patterns builtin | docTR/EasyOCR | OCR find bouton | Legacy |
+| 2 | DialogHandler + KNOWN_DIALOGS | 15 titres connus | EasyOCR full screen | InfiGUI | ORA |
+
+---
+
+## 8. Budget VRAM (configuration actuelle)
+
+| Composant | VRAM | Process |
+|-----------|------|---------|
+| InfiGUI-G1-3B (NF4) | 2.41 GB | Worker indépendant (/tmp) |
+| RF-DETR Medium | 0.8 GB | Process Flask |
+| EasyOCR | ~1 GB (GPU) | Process Flask |
+| Ollama qwen2.5vl:3b (si appelé) | ~3.2 GB | Process Ollama |
+| Chrome + système | ~1.3 GB | — |
+| **Total max** | **~8.7 GB / 12 GB** | |
+
+---
+
+## 9. Fichiers critiques par ordre d'importance
+
+1. `core/execution/observe_reason_act.py` — boucle ORA, _act_click, reason, verify
+2. `visual_workflow_builder/backend/api_v3/execute.py` — API, chargement ancres, legacy executor
+3. `core/grounding/fast_pipeline.py` — pipeline FAST→SMART→THINK
+4. `core/grounding/ui_tars_grounder.py` — client InfiGUI worker
+5. `core/grounding/infigui_worker.py` — worker InfiGUI (process indépendant)
+6. `core/execution/input_handler.py` — OCR, UI-TARS Ollama, safe_type_text, patterns
+7. `core/grounding/dialog_handler.py` — gestion dialogues ORA
+8. `core/grounding/fast_detector.py` — RF-DETR + EasyOCR
+9. `core/grounding/smart_matcher.py` — matching contextuel
+10. `core/knowledge/ui_patterns.py` — patterns réflexes
+
+---
+
+> **Dernière mise à jour** : 26 avril 2026  
+> **Prochaine action** : rebrancher verify + recovery, converger les 2 exécuteurs, nettoyer le code mort.

docs/DETTE_TECHNIQUE.md

@@ -0,0 +1,37 @@
+# Registre de dette technique
+
+Registre central des dettes techniques identifiées sur le projet.
+Règle : toute désactivation de contrôle ou contournement assumé fait l'objet d'une entrée. Revue par défaut à création + 14 jours.
+
+## Statuts
+- OPEN : à traiter
+- IN_PROGRESS : en cours de résolution
+- RESOLVED : résolu (date résolution + commit ref)
+- ACCEPTED : assumé définitivement, pas de résolution prévue
+
+## Sévérités
+P0 / P1 / P2 / P3 (alignées sur convention handoffs)
+
+## Entrées
+
+| ID | Date création | Date revue | Sévérité | Statut | Description | Origine |
+|----|---------------|------------|----------|--------|-------------|---------|
+| DETTE-001 | 2026-05-08 | 2026-05-22 | P1 | OPEN | Pré-check OCR spatialement aveugle | docs/BUG_PRECHECK_SPATIAL_BLINDNESS_2026-05-08.md |
+| DETTE-002 | 2026-05-08 | 2026-05-22 | P2 | OPEN | Exemption drift > 0.20 si template_matching ≥ 0.95 ou hybrid_text_direct ≥ 0.80 (resolve_engine.py:2367-2390) | docs/AUDIT_CONTROLES_DEBRANCHES_2026-05-08.md (F2.2.1) |
+| DETTE-003 | 2026-05-08 | 2026-05-22 | P2 | OPEN | Self-healing Win+D au retry 1 retiré (revert 22c0a2ba6, replay_engine.py) | docs/AUDIT_CONTROLES_DEBRANCHES_2026-05-08.md (F2.2.3) |
+| DETTE-004 | 2026-05-08 | 2026-05-22 | P2 | OPEN | Cascade OmniParser/YOLO neutralisée — `_resolve_by_yolo` défini, importé, jamais appelé (resolve_engine.py:293) | docs/AUDIT_CONTROLES_DEBRANCHES_2026-05-08.md (F2.4.1) |
+| DETTE-005 | 2026-05-08 | 2026-05-22 | P2 | OPEN | Sous-système mémoire visuelle orphelin — `VisualEmbeddingManager` + `ScreenshotValidationManager` (core/visual/*) définis mais jamais instanciés en runtime | docs/INVESTIGATION_MEMOIRE_VISUELLE_ORPHELINE_2026-05-09.md |
+| DETTE-006 | 2026-05-08 | 2026-05-23 | P0 | IN_PROGRESS | Bug échelle pixel grounding Ollama smart_resize non-déterministe | docs/MIGRATION_VLM_PLAN_2026-05-09.md |
+| DETTE-007 | 2026-05-09 | 2026-05-23 | P3 | OPEN | Trois implémentations smart_resize coexistent (server.py, infigui_worker.py, nouveau module officiel). Unification post-démo Kerella. | commit feat(grounding): module smart_resize officiel |
+| DETTE-008 | 2026-05-09 | 2026-05-23 | P2 | OPEN | Pre-check VLM par-clic désactivé via `if False:` (observe_reason_act.py:1704-1713) | docs/AUDIT_CONTROLES_DEBRANCHES_2026-05-08.md (F6.1.1) |
+| DETTE-009 | 2026-05-09 | 2026-05-23 | P3 | OPEN | `ShadowLearningHook` (core/grounding/shadow_learning_hook.py) défini mais jamais instancié — Phase 6 du pipeline FAST→SMART→THINK non câblée à l'observation Shadow | docs/INVESTIGATION_MEMOIRE_VISUELLE_ORPHELINE_2026-05-09.md |
+| DETTE-010 | 2026-05-09 | 2026-05-10 | P1 | IN_PROGRESS | preprocessor_config.json du checkpoint Qwen3-VL-8B-Instruct lu (snapshot 0c351dd01ed87...) : `image_processor_type=Qwen2VLImageProcessorFast` (variant différent de Qwen2VLImageProcessor lue ce matin), `patch_size=16` (vs 14 hypothèse matin → factor probable 32 au lieu de 28), `size={longest_edge: 16_777_216, shortest_edge: 65_536}` (convention différente de min_pixels/max_pixels), `min_pixels`/`max_pixels` absents du config. Investigation requise demain matin : lire transformers.models.qwen2_vl.image_processing_qwen2_vl_fast pour comprendre défauts effectifs et sémantique. Conséquence pour module smart_resize.py : peut nécessiter ajustement (factor, bornes, sémantique). Étape 2 (validation grounding isolée) DOIT être précédée de cette investigation. | docs/MIGRATION_VLM_PLAN_2026-05-09.md + commit 0d7bcd18a (smart_resize) + investigation 2026-05-09 |
+| DETTE-011 | 2026-05-09 | 2026-05-23 | P2 | OPEN | Bug `cv2.gapi.wip.draw.Text` manquant en Python 3.12 (déclenché par import `agent_v0.server_v1` dans tests/unit/conftest.py:26). Bloque pytest-cov sur tous les tests qui importent la chaîne. Contournement actuel : stub cv2 + coverage API directe. Investigation : version cv2 vs Python 3.12 compat, ou import conditionnel dans conftest. | session 2026-05-09 (découvert pendant TDD smart_resize) |
+| DETTE-012 | 2026-05-09 | 2026-05-23 | P3 | OPEN | Migration backend grounding vers vLLM (option mentionnée dans plan migration mais infra absente : pas d'install vLLM, pas de service systemd dédié). Choix Transformers direct retenu pour fix DETTE-006. Migration vLLM à instruire séparément si bénéfice mesuré post-démo Kerella. | docs/MIGRATION_VLM_PLAN_2026-05-09.md + investigation infra session 2026-05-09 |
+| DETTE-013 | 2026-05-09 | 2026-05-23 | P2 | OPEN | Environnement de tests dev local cassé : pytest tests/unit/ déclenche sys.exit(1) via import api_stream sans RPA_API_TOKEN/RPA_AUTH_DISABLED définis (api_stream.py:135, fail-closed sécurité commit 93ef93e56). Combiné avec DETTE-011 (cv2 dans conftest), la batterie de tests unitaires complète n'est pas exécutable en dev local sans configuration environnement spécifique. À documenter (env vars requises) ou refactor (découpler tests purs des tests chargeant api_stream). | session 2026-05-09 (découvert pendant validation refactor bbox_parser) |
+| DETTE-014 | 2026-05-09 | 2026-05-10 | P1 | OPEN | Module core/grounding/smart_resize.py commité ce matin (commit 0d7bcd18a) calé sur la référence transformers.qwen2_vl.image_processing_qwen2_vl (factor=28, max_pixels=1_003_520). Le checkpoint Qwen3-VL-8B-Instruct utilise en réalité Qwen2VLImageProcessorFast avec patch_size=16 (factor probable 32) et convention size.longest_edge/shortest_edge. À réaligner après investigation DETTE-010 demain. Module pur, testé à 100% sur la convention actuelle — la convention reste valide en référence, mais ne s'applique pas à ce checkpoint. | commit 0d7bcd18a + investigation DETTE-010 du 2026-05-09 |
+
+## Convention de référencement
+
+- Dans les messages de commit : `refs DETTE-NNN` en pied
+- Dans le code : `# DETTE-NNN` en commentaire au-dessus de la ligne concernée (pour les contournements localisables)

docs/E2E_TEST_RUN_2026-05-08.md

@@ -0,0 +1,460 @@
+# Run E2E `Urgence_aiva_demo` — 8 mai 2026
+
+> Audit ingénieur test/automation senior réalisé en J0 démo GHT Sud 95.
+>
+> Objectif : exécuter `tools/test_replay_e2e.py` sur des fixtures
+> pertinentes (vrais screens de la maquette Easily Assure contenant
+> les textes cibles), comparer les résolutions step-par-step à la
+> baseline attendue, identifier les régressions concrètes introduites
+> par les patches serveur du 7 mai soir (cure b584bbabc + pré-check
+> OCR + exemption hybrid_text), et proposer des correctifs précis.
+>
+> AUCUN code serveur n'a été modifié. Lecture + harness + rapport
+> uniquement.
+
+## TL;DR (synthèse pour décision avant démo)
+
+- **Cascade fonctionnelle sur 5/6 cibles testables** (`hybrid_text_direct`
+  résout `25003284`, `Imagerie`, `Notes médicales`, `Codage`,
+  `Coller dossier patient` lorsque la fixture représente le bon écran).
+- **Régression confirmée** : pour `Examens cliniques` et `Synthèse
+  Urgences` (deux tabs en haut d'écran), le pre-check OCR à
+  `radius_px=200` voit un crop **trop étroit** pour capter le mot
+  cible → REJET → exception non rattrapée dans le log → réponse
+  fallback `analysis_error`. Touche au minimum **2 steps sur 6 démo**.
+- **2 correctifs chirurgicaux** proposés (radius proportionnel à la
+  résolution écran, garde NoneType sur le format string). Effort
+  ~10 lignes, risque très faible. Détails §5.
+- Pour la démo dans la journée : **2 chemins** sont défendables —
+  (A) appliquer les correctifs (10 minutes, faible risque, valider en
+  retesting harness), ou (B) ne rien toucher et compter sur la
+  policy serveur qui transformera l'`analysis_error` en pause
+  supervisée + Plan B (fallback recorded coords). Recommandation :
+  **(A) si possible**, sinon (B) avec briefing préalable.
+
+---
+
+## 1. Inventaire fixtures
+
+### 1.1 Diagnostic des heartbeats sur disque
+
+Premier réflexe : utiliser les `heartbeat_*.png` du PC Windows.
+Échec total — toutes les fixtures inspectées (300+ heartbeats des
+bg_DESKTOP-58D5CAC_windows depuis mars 2026, sessions sess_* du 5
+mai) montrent l'**explorateur Windows ou Chrome lambda**, pas la
+maquette Easily Assure. Le workflow `Urgence_aiva_demo` a été
+construit le 7 mai 2026 — il n'existe pas de heartbeat capturé
+durant un usage réel de cette maquette.
+
+Inventaire OCR (EasyOCR fr+en) sur 30 heartbeats stratifiés :
+**0 fixture** ne contient un texte cible. Voir
+`tests/e2e/fixtures/urgence_aiva_demo/_ocr_inventory.json` et
+`_ocr_inventory_may5.json`.
+
+### 1.2 Solution adoptée — fixtures live
+
+Capture headless Chrome en 1920×1080 et 2560×1600 directement contre
+la maquette en ligne (`https://urgence.labs.laurinebazin.design`,
+auth basic `lea:Medecin2026!`), une fixture par écran d'intérêt :
+
+| Step | by_text | Fixture (1920×1080) | OCR cible présent ? |
+|------|---------|---------------------|---------------------|
+| 3    | `25003284`                                | `live/landing.png`                  | OK |
+| 8    | `Examens cliniques`                       | `live/dossier_motif.png`            | OK |
+| 10   | `Imagerie`                                | `live/dossier_examens-cliniques.png`| OK |
+| 12   | `Notes médicales`                         | `live/dossier_imagerie.png`         | OK |
+| 14   | `Synthèse Urgences`                       | `live/dossier_notes-medicales.png`  | OK |
+| 17   | `Codage`                                  | `live/dossier_synthese-urgences.png`| OK |
+| 18   | `Coller ou saisir le dossier patient`     | `live/dossier_codage.png` (proxy)   | NON (page aiva-vision absente) |
+| 20   | `Justification de la décision`            | `live/dossier_codage.png` (proxy)   | NON |
+
+Limitations connues : la maquette ne route pas correctement les hash
+URL (`#examens-cliniques`, `#imagerie`, ...) — tous les onglets
+renvoient le même HTML. L'OCR confirme néanmoins que les 6 onglets
+sont visibles dans le bandeau, ce qui suffit pour valider la
+résolution `by_text` sur ces tabs. Les steps 18 et 20 ciblent la
+page `aiva-vision` (en aval du clic sur "Codage >"), non capturée
+ici — voir §6.
+
+### 1.3 Anchor images comme fixtures alternatives
+
+J'ai aussi téléchargé les 8 images d'ancres depuis VWB
+(`/api/v3/anchor/<id>/image`) sous
+`tests/e2e/fixtures/urgence_aiva_demo/step*.png` (2560×1600).
+**Elles contiennent toutes leur `by_text`** mais sont des crops
+zoomés (la position est non-représentative). Elles servent à valider
+qu'`hybrid_text_direct` fonctionne (étape 0.5) mais leur drift par
+rapport aux coords enregistrées est artefactuel — voir un précédent
+run dans `_run_resolve_results.json`.
+
+---
+
+## 2. Run du harness
+
+### 2.1 Méthode
+
+Plutôt que `tools/test_replay_e2e.py` qui force le replay du
+workflow complet (et bouclerait à cause des extract_text serveur,
+pause_for_human, etc.), j'ai utilisé un appel direct ciblé à
+`/api/v1/traces/stream/replay/resolve_target` avec, pour chaque
+step click_anchor :
+
+- `screenshot_b64` = la fixture du step
+- `target_spec` = exactement ce que VWB compose
+  (`by_text`, `by_text_source: "ocr"`, `anchor_image_base64`,
+  `anchor_id`, `bounding_box`, `screen_resolution`)
+- `fallback_x_pct` / `_y_pct` = centre normalisé de la bbox de
+  l'ancre (= les coords enregistrées)
+- `strict_mode = True` (replay sessions)
+
+Script : `/tmp/run_resolve_per_step.py` (non versionné).
+
+> ATTENTION REPRO : la clé est `anchor_image_base64`, pas
+> `anchor_image_b64`. Sans cette clé, le serveur tombe en mode
+> non-strict (`has_anchor=False`), saute l'étape 0.5
+> `hybrid_text_direct` et tape direct VLM puis ScreenAnalyzer
+> (qui retourne `screen_analyzer_unavailable`). Premier run
+> totalement faux à cause de cette typo — corrigé.
+
+### 2.2 Résultats sur fixtures live (1920×1080)
+
+| # | by_text                                  | resolved | méthode                       | score | pos résolue       | recorded         | reason                         | ms    |
+|---|------------------------------------------|----------|-------------------------------|-------|-------------------|------------------|--------------------------------|-------|
+| 1 | `25003284`                               | True     | `hybrid_text_direct`          | 1.000 | (0.0303, 0.1988)  | (0.4928, 0.4512) | _drift IGNORÉ (exemption)_     | 1543  |
+| 2 | `Examens cliniques`                      | **False**| `fallback`                    | 0.000 | (0.4980, 0.4928)  | (0.498, 0.4928)  | **`analysis_error`**           | 1420  |
+| 3 | `Imagerie`                               | True     | `hybrid_text_direct`          | 0.800 | (0.2256, 0.1267)  | (0.498, 0.4928)  | _drift IGNORÉ_                 | 1372  |
+| 4 | `Notes médicales`                        | True     | `hybrid_text_direct`          | 0.800 | (0.2227, 0.1259)  | (0.202, 0.28)    | drift OK                       | 976   |
+| 5 | `Synthèse Urgences`                      | **False**| `fallback`                    | 0.000 | (0.2705, 0.2794)  | (0.2705, 0.2794) | **`analysis_error`**           | 1341  |
+| 6 | `Codage`                                 | True     | `hybrid_text_direct`          | 0.800 | (0.1392, 0.0538)  | (0.3189, 0.2281) | _drift IGNORÉ_                 | 1253  |
+| 7 | `Coller ou saisir le dossier patient`    | False    | `strict_vlm_template_failed`  | 0.000 | (0.0748, 0.4412)  | -                | `vlm_and_template_all_failed` (fixture invalide — page absente) | 4233 |
+| 8 | `Justification de la décision`           | False    | `strict_vlm_template_failed`  | 0.000 | (0.6482, 0.6228)  | -                | idem                           | 3586  |
+
+> Score final côté cascade : **5 OK / 2 FAIL régression / 1 FAIL
+> attendu (fixture mauvaise page) sur 8** quand on n'évalue que les
+> steps avec fixture représentative. Régression brute = 2/6 = **33 %
+> d'échecs sur les onglets démo**.
+
+---
+
+## 3. Divergences vs baseline
+
+### 3.1 Bug #1 — Pre-check OCR rejette à tort sur `Examens cliniques` et `Synthèse Urgences` (radius trop petit)
+
+Logs serveur (steps 8 et 14) :
+
+```
+Pre-check OCR REJET : 'Examens cliniques' attendu @ (0.2256, 0.1267) via hybrid_text_direct
+mais OCR voit 'Maquette POC ler en cours Codage Statistiques Catherine Néle)le 14/03/1947 77 an' (80ms)
+```
+
+Reproduction isolée via `_validate_text_at_position` (script de
+test inline) — sensibilité au radius :
+
+| Cible              | r=100  | r=150  | **r=200 (actuel)** | r=250  | r=300  | r=400  |
+|--------------------|--------|--------|--------------------|--------|--------|--------|
+| Examens cliniques  | 0/2    | 0/2    | **1/2 (50 %)**     | 2/2 OK | 2/2 OK | 2/2 OK |
+| Synthèse Urgences  | 0/2    | 0/2    | **0/2 (0 %)**      | 1/2    | 2/2 OK | 2/2 OK |
+| Notes médicales    | 1/2    | 2/2 OK | 2/2 OK             | OK     | OK     | OK     |
+| Imagerie           | 1/1 OK | 1/1 OK | 1/1 OK             | OK     | OK     | OK     |
+
+Sur 2560×1600 (resolution Windows réelle de Dom), même phénomène
+mais déplacé : `Examens cliniques` reste FAIL jusqu'à r=400 (le tab
+"Examens cliniques" est physiquement plus large en pixels qu'à
+1920×1080).
+
+**Cause profonde** : `radius_px=200` est **fixé en pixels absolus**
+(resolve_engine.py:2246), or les éléments UI (largeur d'un tab)
+varient avec la résolution. Pour des cibles courtes (1 token,
+type "Imagerie") c'est OK ; pour des cibles à 2 tokens (`Examens
+cliniques`, `Synthèse Urgences`) sur des bandeaux d'onglets à mi-écran
+en haut, le crop tronque.
+
+Aggravant : le seuil fuzzy à `0.60` exige 100 % des tokens pour les
+cibles à 2 tokens (60 % de 2 = 1.2 → arrondi sup → 2/2). Si OCR
+rate un token sur deux, REJET sec.
+
+### 3.2 Bug #2 — Crash log RESOLVE_EXIT sur résultat None
+
+Quand le pre-check rejette, `result` est remplacé par
+(api_stream.py:4534-4542) :
+
+```python
+result = {
+    "resolved": False,
+    "method": "rejected_text_mismatch",
+    "reason": ...,
+    "x_pct": None,
+    "y_pct": None,
+}
+```
+
+Puis le log (api_stream.py:4549) :
+
+```python
+f"coords=({result.get('x_pct', 0):.4f}, {result.get('y_pct', 0):.4f}) "
+```
+
+→ `result.get('x_pct', 0)` retourne **`None`** (la clé EXISTE et vaut
+None — la valeur par défaut `0` n'est utilisée que si la clé est
+absente). `None:.4f` lève `TypeError: unsupported format string
+passed to NoneType.__format__`.
+
+Conséquence : exception remontée → `_fallback_response("analysis_error",
+str(e))` retourné côté client → la cascade côté `replay_engine.py`
+voit `resolved=False, reason="analysis_error"` au lieu de
+`reason="rejected_text_mismatch"`. La couche supérieure ne peut donc
+plus traiter le rejet sémantique pour ce qu'il est — elle voit une
+erreur d'analyse système.
+
+Cumul des deux bugs : **le pre-check OCR fait perdre le clic en
+cascade**, là où il aurait dû seulement rejeter ce candidat et
+laisser la cascade continuer (VLM, SoM, template).
+
+### 3.3 Drift exemption — fonctionne correctement
+
+L'exemption hybrid_text_direct ≥ 0.80 fonctionne nominalement : 4
+résolutions sur 5 ont un drift > 0.20 mais sont acceptées. Logs :
+
+```
+Drift (0.463, 0.252) > 0.20 IGNORÉ : score=1.000 sur hybrid_text_direct — résultat visuel fiable, on l'utilise
+```
+
+Aucun cas observé où l'exemption ait **fait passer un faux positif
+visible**. Sur les fixtures testées, l'OCR direct trouve toujours
+le bon texte exact (score 1.0) ou le bon avec OCR un peu bruité
+(0.8). À surveiller en démo réelle si plusieurs occurrences du même
+texte coexistent sur l'écran (ex : tableau patients avec plusieurs
+IPP commençant par "2500..." — risque que `25003284` soit confondu
+avec un voisin lexical).
+
+---
+
+## 4. Reproduction en isolation
+
+```bash
+cd /home/dom/ai/rpa_vision_v3 && source .venv/bin/activate
+
+# Fixtures live (à recapturer à chaque démo si la maquette change)
+mkdir -p tests/e2e/fixtures/urgence_aiva_demo/live
+google-chrome --headless --disable-gpu --no-sandbox --window-size=1920,1080 \
+    --user-data-dir=/tmp/chrome_e2e \
+    --screenshot=tests/e2e/fixtures/urgence_aiva_demo/live/dossier_motif.png \
+    'https://lea:Medecin2026!@urgence.labs.laurinebazin.design/dossier.html?id=25003284'
+
+# Test ciblé d'un step (exemple : step 8 Examens cliniques)
+python3 - <<'PY'
+import sys; sys.path.insert(0, '.')
+from agent_v0.server_v1.resolve_engine import _validate_text_at_position
+from PIL import Image
+fp = 'tests/e2e/fixtures/urgence_aiva_demo/live/dossier_motif.png'
+sw, sh = Image.open(fp).size
+for r in (200, 250, 300, 350):
+    ok, obs, ms = _validate_text_at_position(fp, 0.2256, 0.1267, 'Examens cliniques', sw, sh, radius_px=r)
+    print(f'r={r} → valid={ok} ({ms:.0f}ms) obs={obs[:80]!r}')
+PY
+```
+
+---
+
+## 5. Correctifs proposés (NON appliqués)
+
+### Correctif #1 — Radius proportionnel à la résolution + fuzzy 0.50
+
+**Fichier** : `agent_v0/server_v1/resolve_engine.py`
+
+**Avant (ligne 2246)** :
+
+```python
+def _validate_text_at_position(
+    screenshot_path: str,
+    x_pct: float,
+    y_pct: float,
+    expected_text: str,
+    screen_width: int,
+    screen_height: int,
+    radius_px: int = 200,
+) -> tuple:
+```
+
+**Après** :
+
+```python
+def _validate_text_at_position(
+    screenshot_path: str,
+    x_pct: float,
+    y_pct: float,
+    expected_text: str,
+    screen_width: int,
+    screen_height: int,
+    radius_px: Optional[int] = None,
+) -> tuple:
+    # Radius proportionnel à la dimension écran la plus petite (≈ 17 % d'écran).
+    # Sur 1920×1080 → 184 px ; sur 2560×1600 → 272 px ; sur 3840×2160 → 367 px.
+    # Couvre les bandeaux d'onglets type Easily Assure tout en restant
+    # localement sémantique (pas la moitié d'écran).
+    if radius_px is None:
+        radius_px = int(0.17 * min(screen_width, screen_height))
+```
+
+Effet attendu sur la run : `Examens cliniques` à r=204 (au lieu de
+200) reste tronqué côté droit ; à r=272 sur 2560×1600 c'est OK.
+Combiné avec le correctif fuzzy ↓ ça passe.
+
+**Avant (ligne 2285)** :
+
+```python
+is_valid = _text_match_fuzzy(expected_text, observed, min_token_ratio=0.60)
+```
+
+**Après** :
+
+```python
+is_valid = _text_match_fuzzy(expected_text, observed, min_token_ratio=0.50)
+```
+
+Justification : pour cibles à 2 tokens (`Examens cliniques`, `Synthèse
+Urgences`, `Notes médicales`), 0.60 force 2/2 (= exact). 0.50 autorise
+1/2 — suffisant pour valider que le bon zone OCR est probable, sans
+sacrifier la spécificité (un token rare comme "synthèse" ou "examens"
+suffit). Pour cibles à 4+ tokens (`Coller ou saisir le dossier
+patient`), 0.50 demande 2/4 — cohérent avec le commentaire historique
+de la fonction.
+
+**Risque** : faux positif rare où un mot d'une cible apparaît dans une
+zone sans rapport. Mitigé par le fait que :
+- Le pre-check est appelé sur la zone où la cascade a déjà résolu
+  (donc visuellement fortement filtrée).
+- Le seuil de score amont (`hybrid_text_direct ≥ 0.80`) garantit déjà
+  que le **mot exact** a été identifié.
+
+**Steps impactés** : 8 (Examens cliniques), 14 (Synthèse Urgences) →
+résolution OK au lieu d'échec.
+
+### Correctif #2 — Garde NoneType sur le format string
+
+**Fichier** : `agent_v0/server_v1/api_stream.py`
+
+**Avant (ligne 4549)** :
+
+```python
+f"coords=({result.get('x_pct', 0):.4f}, {result.get('y_pct', 0):.4f}) "
+```
+
+**Après** :
+
+```python
+f"coords=({(result.get('x_pct') or 0):.4f}, {(result.get('y_pct') or 0):.4f}) "
+```
+
+Ou plus explicite et défensif pour les autres champs :
+
+```python
+_x = result.get('x_pct') if result else None
+_y = result.get('y_pct') if result else None
+logger.info(
+    f"[REPLAY] RESOLVE_EXIT session={request.session_id} "
+    f"resolved={(result or {}).get('resolved', False)} "
+    f"method='{(result or {}).get('method', 'none')}' "
+    f"coords=({(_x if _x is not None else 0):.4f}, {(_y if _y is not None else 0):.4f}) "
+    f"score={(result or {}).get('score', 0)} "
+    f"from_memory={bool((result or {}).get('from_memory', False))} "
+    f"reason='{(result or {}).get('reason', '')}'"
+)
+```
+
+Effet attendu : pas d'exception. Le client reçoit le **vrai**
+`{resolved: False, method: 'rejected_text_mismatch', reason: ...}`
+au lieu d'un masque `analysis_error`. La couche supérieure peut
+décider de retenter avec une autre méthode plutôt que de partir en
+pause supervisée.
+
+**Risque** : nul. Pure défensive contre None. Effort < 5 lignes.
+
+### Correctif #3 (optionnel, à n'appliquer qu'après #1+#2) — Fallback de résolution post-rejet
+
+Quand le pre-check rejette, ne pas tomber direct en `resolved: False`.
+Continuer la cascade (VLM Quick Find, SoM) qui peut lever l'ambiguïté.
+
+**Idée** : dans `api_stream.py` après le bloc pre-check (ligne ~4543),
+si `result.method == "rejected_text_mismatch"`, ré-appeler
+`_resolve_target_sync` avec `target_spec["__skip_ocr_direct"] = True`
+pour forcer VLM/SoM. Trop intrusif pour le jour-J — à reporter.
+
+---
+
+## 6. Limitations & angles morts
+
+- **Steps 18 et 20** non couverts : la fixture utilisée
+  (`dossier_codage.png`) ne contient pas la page aiva-vision
+  (textarea + bouton Justification). Pour les tester, il faudrait :
+  - soit cliquer "Codage >" et capturer la page aval (scriptable
+    avec puppeteer/playwright, ~1h),
+  - soit simuler un replay réel sur la maquette en démo et
+    enregistrer les heartbeats au passage. À planifier post-démo.
+
+- **Fixtures statiques** : la maquette peut évoluer (Laurine peut
+  modifier le CSS/HTML à tout moment). Re-capturer
+  `tests/e2e/fixtures/urgence_aiva_demo/live/*.png` avant chaque
+  démo majeure.
+
+- **Pas de test de la cascade VLM/SoM** : tous les steps testés ici
+  ont passé sur `hybrid_text_direct` (étape 0.5). La cascade VLM,
+  SoM, template_matching et ScreenAnalyzer n'a pas été stressée. Le
+  serveur a montré qu'elle est invocable (steps 7-8 sont allés
+  jusqu'au bout du `strict_vlm_template_failed`). Mais le timing
+  exact, les seuils, la cohérence des coords sur ces chemins
+  alternatifs — non couverts ici. Idéal : ajouter une fixture
+  délibérément sans le texte cible (juste l'icône) pour forcer
+  template_matching, et mesurer le score.
+
+- **Drift exemption pas testée en mode adversarial** : aucun cas où
+  l'exemption a fait passer un mauvais clic. Sur la maquette
+  d'Easily Assure, les textes cibles sont uniques. Sur un DPI réel
+  (ex : 8 patients avec des IPP qui commencent par "2500..."), il
+  faut vérifier que `hybrid_text_direct` retourne le **bon** match
+  et pas le premier rencontré. À tester en démo.
+
+- **Ce rapport est INCOMPLET** sur le point demandé "appel direct à
+  `_resolve_by_ocr_text` puis `_validate_text_at_position` avec
+  paramètres variés" : fait pour la validation seulement. Le vrai
+  test paramétrique de `_resolve_by_ocr_text` (variations de seuil
+  fuzzy interne, normalisation, langue OCR) reste à faire — peu
+  prioritaire car les scores actuels (0.8–1.0) sont sains.
+
+---
+
+## 7. YAML attendu mis à jour
+
+Voir `tests/e2e/urgence_aiva_demo_expected.yaml` (re-écrit ce jour)
+— format basé sur tolérances (range x_pct, y_pct, score_min) plutôt
+que coordonnées rigides, pour ne pas casser à chaque ré-OCR.
+
+---
+
+## 8. Prochaines actions recommandées
+
+1. **Maintenant** (avant démo si fenêtre disponible) : appliquer les
+   correctifs #1 et #2. Re-tester le harness. Risque très faible.
+2. **Pendant démo** : si Synthèse Urgences ou Examens cliniques
+   échouent, c'est l'`analysis_error` — Plan B (recorded coords ou
+   pause supervisée) prend le relais. Briefing à Amina sur ce point.
+3. **Post-démo** : capturer un replay réel complet, sauvegarder les
+   heartbeats, alimenter `tests/e2e/fixtures/urgence_aiva_demo/`
+   pour avoir des fixtures dossier+aiva-vision authentiques.
+   Valider `_run_resolve_results.json` comme baseline non-régressive.
+4. **Plus tard** : intégrer le harness dans `pytest` avec marqueur
+   `@pytest.mark.e2e` (fixture par YAML, comparaison avec
+   tolérances). 1h d'effort.
+
+---
+
+*Auteur : Claude (agent test/automation senior). Aucune modification
+de code ; rapport seul. Reproductions : voir §4. Fichiers livrés :*
+
+- `docs/E2E_TEST_RUN_2026-05-08.md` (ce rapport)
+- `tests/e2e/urgence_aiva_demo_expected.yaml` (YAML attendus
+  mis à jour)
+- `tests/e2e/fixtures/urgence_aiva_demo/live/*.png` (fixtures
+  recapturées de la maquette en ligne)
+- `tests/e2e/fixtures/urgence_aiva_demo/_run_resolve_results.json`
+  (dernier run brut)

docs/HANDOFF_SESSION_20260506.md

@@ -0,0 +1,191 @@
+# Handoff session 2026-05-06 — démo GHT Sud 95 (J-2)
+
+**Auteur :** Claude (session précédente, contexte saturé)
+**Pour :** Claude (nouvelle session)
+**Démo :** dans ~2 jours, pour DSI Carvella + DIM/TIM/DG GHT Sud 95
+**Branche git :** `feature/feedback-bus`
+
+---
+
+## 🎯 Objectif de la nouvelle session
+
+Finir la prep démo : terminer corrections `data.js` + structurer onglet Imagerie + accompagner Dom sur l'enregistrement workflow Urgence_unit + tests E2E.
+
+---
+
+## 📊 État actuel — ce qui est FAIT
+
+### Code & infrastructure
+- ✅ **Maquette aiva-vision** déployée : `https://urgence.labs.laurinebazin.design/codage.html?id=XXX` + service systemd `rpa-mockup-easily` (Flask, port 8765)
+- ✅ **Backend `/api/analyse`** branché sur `core.llm.t2a_decision.analyze_dpi` (qwen2.5:7b par défaut)
+- ✅ **Maquette codage.html refondue** avec layout aiva-vision 2 colonnes + auto-trigger paste
+- ✅ **5e onglet "Imagerie"** ajouté côté UI (HTML + JS) — mais **`data.js` pas encore alimenté** (sauf le champ vide qui est traité comme "Aucun examen")
+- ✅ **Pipeline Léa orchestrateur** dans `agent_chat/urgences_orchestrator.py` (NLP gemma3:1b + thread + boucle + synthèse) — fonctionne en bout-en-bout, validé matin du 2026-05-05
+- ✅ **`extract_table` backend** dans `core/llm/ocr_extractor.py` + `agent_v0/server_v1/replay_engine.py` (regex IPP `^25\d{6}$`) — testé OK 11/11 sur capture liste patients
+- ✅ **Préchargement EasyOCR au boot** du streaming server (3.8s, log confirmé) — fini le cold start qui bloquait 2 min
+- ✅ **Templating `{{patient_id}}`** sur `by_text` dans replay_engine + variables runtime initiales via `ReplayRequest.variables`
+- ✅ **Agent V1 mis à jour** sur PC Windows (32 fichiers .py, hashes vérifiés, compile clean) — 2026-05-04
+- ✅ **Catalogue de réflexes** (`gesture_catalog.py`) utilisé par l'orchestrateur (composition réflexes + workflows appris, pas de hardcode)
+
+### Bench LLM — 18 modèles testés
+- ✅ Rapport complet : `docs/BENCH_T2A_DECISION_11DOSSIERS.md`
+- 🥇 **`gemma3:27b-cloud` : 8/11 (73%)** sur vérité-terrain corrigée — recommandé démo
+- 🥈 `qwen3:8b` : 7/11 (64%) — backup local, 7.6s/dossier, 5 GB → tient large dans 12 GB GPU
+- ⚠️ Bench fait sur DPI partiellement fictifs (cf. revue Pauline) → ré-évaluer après corrections data.js
+
+### Documentation produite
+- `docs/BENCH_T2A_DECISION_11DOSSIERS.md` — bench 18 modèles
+- `docs/BENCH_MINI_LLM_NLP.md` — bench gemma3:1b vainqueur (NLP commande chat)
+- `docs/REVUE_DOSSIERS_PAULINE.md` — revue 11 dossiers vs captures (fait par sous-agent, **avec quelques inexactitudes** : "médecins du sport 0559447669" remonté comme inventé, en réalité présent dans la capture)
+- `docs/POINTS_SUSPECTS_PAULINE.md` — synthèse pour visio Pauline (méthodo : on ne signale PAS les noms anonymisés, on focus hallucinations cliniques + constantes + imagerie)
+- `docs/MAIL_PAULINE_AVANT_VISIO.md` — mail-template à adapter
+
+### Mémoires importantes (`~/.claude/.../memory/`)
+- `feedback_anonymisation_stricte.md` ⭐ — règle absolue : anonymiser = remplacement chirurgical des identités, **JAMAIS réécrire le contenu clinique**. Erreur historique : "anhydrose" vs "ankylose" sur 25003475
+- `feedback_lea_reflexes_catalog.md` — utiliser `gesture_catalog.py`, ne pas hardcoder Win+R+type+Enter
+- `feedback_auth_dialogs_runtime.md` — Windows Hello / Basic Auth bloquent le replay, anticiper avant chaque démo client
+- + toutes les feedbacks existantes dans `MEMORY.md`
+
+### Corrections data.js DÉJÀ FAITES
+1. **25003475** (UHCD aura migraineuse) — 3 hallucinations cliniques graves corrigées :
+   - `symptomes_orientation` : "Migraines de membre" → "**Faiblesse** de membre"
+   - `notes_paramedicales[0]` (03:09) : "Pansement compressif possible si perfusé" → "**--> RAD possible. dé perfusé**"
+   - `notes_medicales[1]` (Histoire maladie) : "anhydrose au talon supérieur" → "**ankylose du membre supérieur gauche**"
+2. **25151530** (Forfait colique néphrétique) :
+   - "TDM sans injection" → "**TDM avec injection**" (2 occurrences)
+   - Histoire de la maladie enrichie avec **ATCD RGO + TTT ESOMEPRAZOLE**
+3. **`server.py` `VERITES_TERRAIN`** : 25003284 reclassé `FORFAIT_URGENCE` (sortie domicile en 3h37, J12.1 VRS)
+4. **`app.js` signes_vitaux** : adapté pour itérer sur N colonnes dynamiquement (au lieu de v1/v2 fixe). **MAIS** `data.js` a toujours 2 cols partout → rétrocompatible.
+
+---
+
+## ❌ Ce qui RESTE à faire (priorité décroissante)
+
+### 🔴 PRIORITÉ 1 — corrections data.js (1-2h)
+
+#### Constantes vitales tronquées (4 dossiers)
+Captures Pauline source : `/home/dom/Téléchargements/Exemples Dossiers UHCD - Forfaits (1)/Exemples Dossiers UHCD - Forfaits/[UHCD|FORFAITS]/<IPP>/`
+
+| IPP | Actuel data.js | Capture | Cols à ajouter | Priorité |
+|---|---|---|---|---|
+| 25003364 | 2 cols (21:02 + 14:45) | 4 cols | 19:45 (volume miction 700) + 18:44 (T 71, FC 87, PA 168/92, débit O2 2L) | 🟠 |
+| 25005866 | 2 cols (10:56 + 23:01) | 5 cols | 08:20, 06:25, 02:00 (surveillance neuro post-trauma) | 🔴 grave |
+| 25048485 | 2 cols (12:09 + 10:52) | 5 cols | 10:58, 10:54, 10:53 + ligne PA Latéralité | 🔴 grave |
+| 25151530 | 2 cols (06:41 + 03:25) | 7 cols | 08:15, 07:37, 06:00, 04:45, 04:01 (évolution douleur EN: 7→0→5→10→6→4) | 🔴 très grave |
+
+**Format à adopter** : passer de `{item, v1, v2}` à `{item, v1, v2, v3, v4, ...}`. `app.js` itère déjà dynamiquement sur N cols.
+
+#### Imagerie à structurer (7 dossiers)
+Le champ `imagerie: [{date, type, par, role, horodatage, contenu}, ...]` est lu par `renderImagerie()` dans `app.js` (déjà branché).
+
+| IPP | CR à déplacer | Source actuelle data.js |
+|---|---|---|
+| 25003284 | RX thorax (signé Dr LAURENT Charles) | `notes_medicales[3]` |
+| 25003364 | RX pulmonaire (foyer condensation lobaire D) | `notes_medicales[0]` |
+| 25003475 | Scanner cérébral sans injection (normal) | `notes_medicales[0]` |
+| 25005866 | 3 examens : TDMc 01:53 + RX thorax 01:54 + TDMc contrôle 10:18 | `notes_medicales[1, 2]` |
+| 25012257 | TDM AP sans injection (allergie iode) + ECG | `notes_medicales[0]` |
+| 25056615 | Scanner AP avec injection (CR complet) | `notes_medicales[0]` |
+| 25151530 | Scanner AP avec injection | `notes_medicales[1]` |
+
+**Règle** : extraire le CR du `notes_medicales` (ou autre source), le placer dans `imagerie` **mot pour mot** (procédure stricte). Le retirer de `notes_medicales` si entièrement déplacé OU laisser une mention "voir onglet Imagerie".
+
+#### Enrichir 25048485 (2 motifs CTCG)
+Captures montrent 2 motifs distincts le **même jour 28/02/2025** : 1ère CTCG le matin 9h15, 2e CTCG l'après-midi (récidive). data.js modélise UN seul passage 10:40→17:30 → cohérent (le patient a été gardé entre les 2). **Action** : enrichir l'histoire de la maladie pour mentionner explicitement les 2 épisodes (matin + après-midi). **Pas une question Pauline** — juste clarification de présentation.
+
+### 🟠 PRIORITÉ 2 — re-bench T2A après corrections (30 min)
+
+Après corrections data.js, relancer `bench_t2a_cloud.py` (top 5 modèles seulement) pour avoir les chiffres réels. Les scripts existent dans `/tmp/bench_t2a*.py`. Mettre à jour `BENCH_T2A_DECISION_11DOSSIERS.md`.
+
+### 🟠 PRIORITÉ 3 — workflow Urgence_unit (Dom, sur PC Windows)
+
+Dom enregistre le workflow VWB qui traite 1 dossier de bout-en-bout :
+1. Click sur lien IPP `{{patient_id}}` (variabilisé)
+2. Navigation dans les onglets dossier (Motif, Examens, Imagerie, Notes médicales, Synthèse)
+3. extract_text par onglet → DPI consolidé
+4. Click "Coder >" → arrive sur aiva-vision
+5. type_text DPI dans `#dpi-input` (auto-trigger analyse)
+6. Wait + extract_text décision aiva-vision
+7. Click "Liste patients" pour revenir
+
+**Tu peux le faire MAINTENANT** (data.js stable, aiva-vision opérationnelle, agent V1 à jour). Mais **attendre que les corrections data.js soient finies** est plus sûr (sinon les anchors visuels peuvent se déplacer si la table signes vitaux gagne des colonnes).
+
+### 🟡 PRIORITÉ 4 — visio Pauline (pour les questions ouvertes)
+
+Pauline doit répondre à 4-5 questions critiques :
+1. **25048485** : confirmer 2 épisodes le même jour ✓ (pas urgent, je gère seul)
+2. **25005866** : "médecins du sport 0559447669" — Pauline avait dit inventé, le sous-agent a vu présent → contradiction à trancher
+3. **25003284 étiquette workflow** : "UHCD asthme" → "Pneumopathie VRS" ?
+4. **Onglet Imagerie** : niveau de détail attendu
+
+Mail-template prêt : `docs/MAIL_PAULINE_AVANT_VISIO.md`
+
+### 🟡 PRIORITÉ 5 — Tests E2E (J-1, dernier jour)
+
+10 répétitions du scénario démo complet (chat Léa "traite-moi 3 dossiers" → orchestration → boucle → synthèse).
+
+---
+
+## 🚨 Contraintes critiques
+
+1. **Procédure d'anonymisation stricte** (cf. `feedback_anonymisation_stricte.md`) : pour toute correction data.js, **NE JAMAIS reformuler/synthétiser** le contenu clinique. Remplacer chirurgicalement les identités/dates uniquement. Erreur historique grave : "anhydrose"/"ankylose".
+
+2. **Catalogue de réflexes** (cf. `feedback_lea_reflexes_catalog.md`) : utiliser `gesture_catalog.py` pour les raccourcis natifs (Win+R, etc.), ne pas hardcoder.
+
+3. **Pas de cloud LLM dans le projet** sauf pour la démo (Ollama Cloud via clés Dom). Prod 100% local.
+
+4. **Captures Pauline = source de vérité** : `/home/dom/Téléchargements/Exemples Dossiers UHCD - Forfaits (1)/...` (8 dossiers) + `/tmp/captures_pauline_3manquants/` (3 dossiers extraits du docx). En cas de conflit avec rapport revue, **la capture prime**.
+
+5. **Noms substitués = anonymisation volontaire** : ne pas signaler comme erreur, ne pas chercher à les réaligner avec captures.
+
+---
+
+## 📁 Fichiers clés à connaître
+
+- `/home/dom/ai/rpa_vision_v3/docs/clients/ght_sud_95/mockup_easily_assure/data.js` — base 11 dossiers (~2100 lignes)
+- `/home/dom/ai/rpa_vision_v3/docs/clients/ght_sud_95/mockup_easily_assure/server.py` — backend Flask + `/api/analyse` + `VERITES_TERRAIN`
+- `/home/dom/ai/rpa_vision_v3/docs/clients/ght_sud_95/mockup_easily_assure/app.js` — rendering frontend (signes_vitaux dynamique appliqué)
+- `/home/dom/ai/rpa_vision_v3/agent_v0/server_v1/api_stream.py` — streaming server (boot avec préchargement EasyOCR)
+- `/home/dom/ai/rpa_vision_v3/agent_chat/urgences_orchestrator.py` — orchestrateur démo
+- `/home/dom/ai/rpa_vision_v3/core/llm/t2a_decision.py` — décision T2A LLM
+- `/home/dom/ai/rpa_vision_v3/core/llm/ocr_extractor.py` — `extract_text_from_image` + `extract_table_from_image`
+
+---
+
+## 🔧 Commandes utiles
+
+```bash
+# Vérifier syntaxe data.js
+node -e "var fs=require('fs'); var c=fs.readFileSync('docs/clients/ght_sud_95/mockup_easily_assure/data.js','utf-8'); c=c.replace(/^const /gm, 'var '); var s={}; require('vm').runInContext(c, require('vm').createContext(s)); console.log('OK', Object.keys(s.DOSSIERS).length);"
+
+# Restart streaming server
+cd /home/dom/ai/rpa_vision_v3 && ./svc.sh restart streaming
+
+# Restart maquette
+sudo systemctl restart rpa-mockup-easily
+
+# Re-bench T2A (après corrections data.js)
+node /tmp/extract_dpi.js > /tmp/dpis.json
+/home/dom/ai/rpa_vision_v3/.venv/bin/python /tmp/bench_t2a_cloud.py
+```
+
+---
+
+## ⏱ Timeline démo
+
+- **Aujourd'hui** : finir corrections data.js + visio Pauline
+- **Demain (J-2 / 2026-05-07)** : enregistrement workflow Urgence_unit sur PC Windows
+- **J-1 (2026-05-08)** : tests E2E répétés
+- **Jour J** : démo GHT Sud 95
+
+---
+
+## 📌 Ce qui marche aujourd'hui (pas casser)
+
+- Maquette aiva-vision visible et fonctionnelle
+- Pipeline orchestrateur opérationnel (testé matin 05/05)
+- Préchargement EasyOCR opérationnel (3.8s au boot)
+- Bench complet avec rapport
+- Mail-template Pauline prêt
+
+**Ne pas relancer les services systemd sans raison**, ne pas modifier `server.py` sauf pour les corrections explicites.

docs/HISTORIQUE_VLM_IMPLEMENTATIONS_2026-05-08.md

@@ -0,0 +1,175 @@
+# Historique des implémentations VLM — Audit 2026-05-08
+
+Branche : `feature/qw-suite-mai`
+HEAD : `731b5bcae`
+Périmètre : tout backend VLM (Ollama, vLLM, Transformers, services dédiés) — code actif, archivé, ou disparu de l'historique.
+
+---
+
+## 1. Implémentations VLM actuellement actives
+
+### 1.1. Transformers in-process (Qwen2.5-VL family)
+
+| Fichier | Fonction(s) | Modèle / Backend | Commentaire |
+|---|---|---|---|
+| `core/grounding/server.py` | `load_model`, `ground` (Flask `/ground`) | `InfiX-ai/InfiGUI-G1-3B` 4-bit NF4 via `Qwen2_5_VLForConditionalGeneration` + `qwen_vl_utils.process_vision_info` | Serveur Flask single-thread port 8200, contient `_smart_resize` (factor 28, MIN_PIXELS=100·28², MAX_PIXELS=5600·28²). |
+| `core/grounding/infigui_worker.py` | `load_model`, `infer`, `main` (one-shot stdin/stdout) | Idem (`InfiX-ai/InfiGUI-G1-3B` 4-bit NF4, transformers + qwen_vl_utils) | Mode subprocess one-shot : lit JSON sur stdin, écrit sur stdout. Pas de `_smart_resize` complet (formule courte L99-L101 sans clamp min/max). |
+| `core/grounding/infigui_server.py` | `InfiGUIServer.start`, `_do_ground`, `_do_ping` | Réutilise `infigui_worker.load_model` / `infer` | Daemon Unix socket (`/run/rpa/grounding.sock`), protocole length-prefixed JSON. Service systemd `rpa-grounding.service`. |
+| `core/grounding/ui_tars_grounder.py` | `UITarsGrounder.ground`, `_send_socket_request`, fallback subprocess | Client : socket → fallback subprocess (`python -m core.grounding.infigui_worker`) | Ne charge plus rien in-process. Coordonne socket+subprocess. Fichier mis à jour 2026-05-05. |
+| `core/grounding/think_arbiter.py` | `ThinkArbiter.arbitrate` | Délègue à `UITarsGrounder` | Layer THINK du pipeline FAST→SMART→THINK. |
+| `core/detection/owl_detector.py` | `OwlDetector` | `Owlv2Processor` + `Owlv2ForObjectDetection` (Google OWL-v2) via transformers | Câblé dans `core/detection/ui_detector.py` (L31, L113, L126). Pas un VLM grounding GUI mais détecteur open-vocabulary. |
+| `core/detection/seeclick_adapter.py` | `SeeClickAdapter._load_model`, `ground` | `cckevinn/SeeClick` (Qwen-VL) via `AutoModelForCausalLM` + `AutoTokenizer` | Encore exporté par `core/detection/__init__.py` mais signalé "cassé" par le commit `d1b556b6c` (avril 2026) qui l'a retiré de `intelligent_executor.py`. Pas d'autre call site actif. |
+
+### 1.2. HTTP OpenAI-compatible (vLLM)
+
+| Fichier | Fonction | Détails |
+|---|---|---|
+| `agent_v0/server_v1/resolve_engine.py` (L785-L816) | `_resolve_by_grounding` | Essai 1 vLLM `http://localhost:${VLLM_PORT}/v1/chat/completions`, modèle `Qwen/Qwen2.5-VL-7B-Instruct-AWQ` (env `VLLM_PORT=8100`, `VLLM_MODEL`). Format : POST OpenAI chat.completions avec `image_url: data:image/jpeg;base64`. Fallback Ollama si échec. |
+
+Verbatim L789-L816 :
+> ```
+>     # Port vLLM configurable via env
+>     _vllm_port = os.environ.get("VLLM_PORT", "8100")
+>     _vllm_model = os.environ.get("VLLM_MODEL", "Qwen/Qwen2.5-VL-7B-Instruct-AWQ")
+>
+>     # Essai 1 : vLLM (API OpenAI-compatible, GPU)
+>     try:
+>         vllm_resp = _requests.post(
+>             f"http://localhost:{_vllm_port}/v1/chat/completions",
+>             json={
+>                 "model": _vllm_model,
+>                 "messages": [
+>                     {"role": "system", "content": "You locate UI elements on screenshots. Return coordinates."},
+>                     {"role": "user", "content": [
+>                         {"type": "text", "text": prompt},
+>                         {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{shot_b64}"}},
+>                     ]},
+>                 ],
+>                 "temperature": 0.1,
+>                 "max_tokens": 80,
+>             },
+>             timeout=30,
+>         )
+>         if vllm_resp.ok:
+>             content = vllm_resp.json().get("choices", [{}])[0].get("message", {}).get("content", "")
+>             if content:
+>                 logger.debug("Grounding via vLLM OK")
+>     except Exception as e:
+>         logger.debug("vLLM non disponible (%s), fallback Ollama", e)
+> ```
+
+### 1.3. HTTP Ollama (état dominant en prod aujourd'hui)
+
+| Fichier | Fonction | Modèle |
+|---|---|---|
+| `agent_v0/server_v1/resolve_engine.py` (L818-L832) | `_resolve_by_grounding` (fallback de vLLM) | `qwen2.5vl:7b` via `/api/chat` Ollama. |
+| `agent_v0/server_v1/resolve_engine.py` (L2536-L2585) | `_locate_popup_button` | `qwen2.5vl:7b` via `/api/chat`. |
+| `core/detection/ollama_client.py` | `OllamaClient` | `qwen3-vl:8b`, `gemma4:e4b`, etc. — utilisé par `core/detection/ui_detector.py`, `core/detection/som_engine.py`, `core/cognition/vram_orchestrator.py`. |
+| `core/detection/vlm_config.py` | `FALLBACK_VLM_MODELS` | `["qwen3-vl:8b", "0000/ui-tars-1.5-7b-q8_0:7b"]` |
+| `visual_workflow_builder/backend/vlm_provider.py` | `VLMProvider.detect_ui_element` | Hub Ollama prioritaire + cloud opt-in (OpenAI/Gemini/Anthropic) si `VLM_ALLOW_CLOUD=true`. |
+| `visual_workflow_builder/backend/api_v3/capture.py` (L245) | description anchor | `qwen2.5vl:3b` |
+| `visual_workflow_builder/backend/api_v3/dag_execute.py` (L468) | LLMActionHandler | `qwen3-vl:8b` |
+| `visual_workflow_builder/backend/catalog_routes_v2_vlm.py` | détection visuelle catalog | `qwen2.5vl` |
+| `core/llm/ocr_extractor.py`, `core/llm/t2a_decision.py` | LLM text only | Ollama (modèles non-vision). |
+
+---
+
+## 2. Implémentations VLM archivées dans le filesystem
+
+| Chemin | Taille | Mtime | Backend identifié |
+|---|---|---|---|
+| `_archive/dead_code_20260424/...` (9 fichiers, ~6300 lignes) | divers | 2026-04-24 | **Aucun fichier VLM** — il s'agit de modules workflow/visual non liés à un backend VLM (ex. `visual_persistence_manager.py`, `workflow_simulation_report.py`). Recherche `vllm|transformers|smart_resize|InfiGUI|UI-TARS|qwen2.5vl|qwen2-vl` : 0 hit. |
+| `archive/business_docs/`, `archive/historical_recall/` | 3 fichiers .md | 2026-01 / 2026-05-04 | Pas de code (Markdown business / mémoire). |
+
+Aucun fichier `*_old.py`, `*_v1.py`, `*_backup.py`, `*.py.bak` ou `tests_disabled/` détecté. Les seuls `*_v1.py` existants sont `agent_v0/run_agent_v1.py` (non VLM).
+
+---
+
+## 3. Commits historiques mentionnant VLM/vLLM/Transformers/grounding
+
+Liste chronologique inverse (≤ 25 commits pertinents). SHA court · date · message · fichiers VLM touchés (résumé `--stat`).
+
+| SHA | Date | Message | Fichiers VLM clé |
+|---|---|---|---|
+| `487bcb861` | 2026-04-26 | feat(execution): cascade post-raccourci pilotée par DialogHandler/OCR | `core/grounding/{dialog_handler,infigui_worker,think_arbiter,ui_tars_grounder}.py` |
+| `3d6868f02` | 2026-04-26 | docs: cartographie + worker InfiGUI fichiers | `core/grounding/{server,ui_tars_grounder,infigui_worker,dialog_handler}.py` (création worker, refonte server.py de 494→124 lignes) |
+| `343d6fbe9` | 2026-04-26 | perf(ocr): EasyOCR remplace docTR | `core/grounding/{fast_detector,title_verifier}.py` |
+| `cc6443973` | 2026-04-26 | feat(grounding): vérification titre OCR post-action | `core/grounding/title_verifier.py` (+158) |
+| `90007cc7c` | 2026-04-26 | perf(grounding): réflexe pHash-only + max_new_tokens 64 | `core/grounding/server.py` |
+| `77faa03ec` | 2026-04-26 | feat(grounding): InfiGUI-G1-3B remplace UI-TARS 7B | `core/grounding/server.py` (-75/+67) |
+| `73cea2385` | 2026-04-25 | feat(grounding): Phase 6 Shadow Learning Hook | `core/grounding/shadow_learning_hook.py` (+156) |
+| `e2046837c` | 2026-04-25 | feat(grounding): Phase 5 intégration FAST→SMART→THINK dans ORA | `core/execution/observe_reason_act.py` |
+| `b30d4b665` | 2026-04-25 | feat(grounding): Phase 4 pipeline orchestré FAST→SMART→THINK | `core/grounding/fast_pipeline.py` |
+| `e4a48e78b` | 2026-04-25 | feat(grounding): Phase 3 ThinkArbiter + SignatureStore | `core/grounding/{think_arbiter,element_signature}.py` |
+| `ea36bba5c` | 2026-04-25 | feat(grounding): Phase 1-2 FAST→SMART détection + matching | `core/grounding/{fast_detector,smart_matcher,fast_types}.py` |
+| `9da589c8c` | 2026-04-25 | feat(grounding): pipeline centralisé + serveur UI-TARS transformers | **Création** `core/grounding/{server,pipeline,template_matcher,ui_tars_grounder,target,__init__}.py` + `tools/start_grounding_server.sh`. server.py FastAPI port 8200, modèle `ByteDance-Seed/UI-TARS-1.5-7B` 4-bit NF4. |
+| `73ddcdb29` | 2026-04-21 | feat: chaîne de grounding 3 niveaux + refonte capture | `core/execution/input_handler.py`, `visual_workflow_builder/.../execute.py` |
+| `d1b556b6c` | 2026-04-21 | fix(grounding): supprimer SeeClick cassé | `intelligent_executor.py` (-46) |
+| `91614fbff` | 2026-04-04 | fix: prompt natif bbox_2d Qwen2.5-VL | `agent_v0/server_v1/api_stream.py` |
+| `c1ce6a396` | (avril) | fix: séparer grounding (qwen2.5vl) et compréhension (gemma4) | api_stream.py |
+| `394342be7` | 2026-03-31 | **feat: support vLLM (GPU) comme moteur de grounding, Ollama en fallback** | `agent_v0/server_v1/api_stream.py` (+47/-14) — c'est l'unique commit qui ajoute vLLM. |
+| `d99b17394` | 2026-03-31 | feat: VLM grounding direct (Qwen2.5-VL) — nouvelle stratégie de résolution | `agent_v0/server_v1/api_stream.py` (+230) |
+| `cbe8dc95d` | (mars) | feat(cognition): timing + auto-apprentissage Shadow + VLM qwen2.5vl | — |
+| `ad15237fe` | (mars) | feat: smart systray Léa + support qwen3-vl | — |
+| `38966de0d` | (antérieur) | Feat: Action analyser_avec_ia (Ollama qwen2.5-vl) | — |
+| `728fac3b5` | (antérieur) | Feat: Actions validation avec OCR Ollama (qwen2.5-vl:7b) | — |
+| `21bfa3b33` | 2026-01-24 | feat(vwb): SeeClick + Self-Healing | `core/detection/seeclick_adapter.py` (+) |
+| `4509038bf` | 2026-04-09 | refactor: éclater api_stream.py 6400→3350 | déplace le code vLLM/Ollama vers `agent_v0/server_v1/resolve_engine.py` |
+
+Sur `git reflog | head -100` : aucune trace d'opération destructive (pas de `reset --hard`, pas de checkout détruit) qui aurait perdu un commit lié au VLM. Toutes les opérations sont des commits propres.
+
+---
+
+## 4. Code dans des stashes ou branches non mergées
+
+`git stash list` : **aucun stash**.
+
+Branches existantes :
+- `main`
+- `master` (remote gitea uniquement)
+- `feature/qw-suite-mai` (HEAD courant)
+- `feature/feedback-bus`
+- `backup/pre-qw-suite-mai-2026-05-05`
+- `demo/ght-2026-05-08`
+- `dev/ia-tools-improvement`
+
+Aucune branche divergente n'apparaît dans `git log --all -S "vllm"` au-delà des deux commits déjà recensés (tous accessibles depuis `feature/qw-suite-mai`). Idem pour `Qwen2_5_VL`, `smart_resize`, `qwen_vl_utils`, `BitsAndBytesConfig` : tous les commits qui les introduisent ou les modifient sont accessibles depuis HEAD.
+
+→ Aucun code VLM unique perdu dans une branche divergente ou un stash.
+
+---
+
+## 5. Code potentiellement perdu (commits de suppression VLM)
+
+| SHA | Date | Action | Résumé |
+|---|---|---|---|
+| `d1b556b6c` | 2026-04-21 | suppression | Retire SeeClick de `intelligent_executor.py` (-46). Le **fichier `core/detection/seeclick_adapter.py` n'a jamais été supprimé** : il vit toujours dans `core/detection/` (11 421 octets, mtime 2026-01-24) et est encore exporté par `core/detection/__init__.py`. → Code utilisable mais signalé "cassé" (config QWenConfig incompatible). |
+| `3d6868f02` | 2026-04-26 | refonte | Réduit `core/grounding/server.py` de 494 → 124 lignes en sortant la logique d'inférence vers `infigui_worker.py`. La logique transformers complète est conservée dans `infigui_worker.py` (et reprise par `infigui_server.py`). → Aucune perte. |
+| `77faa03ec` | 2026-04-26 | remplacement modèle | UI-TARS-1.5-7B remplacé par InfiGUI-G1-3B dans `core/grounding/server.py`. Le **prompt UI-TARS officiel** (`Thought:/Action: click(start_box='(x1, y1)')`) et la fonction `_evict_ollama_models()` ont disparu mais restent récupérables via `git show 9da589c8c:core/grounding/server.py`. |
+| `9da589c8c` | 2026-04-25 | nettoyage | "9 fichiers morts archivés dans `_archive/` (~6300 lignes)". Vérifié : aucun fichier VLM dans `_archive/dead_code_20260424/`. Ces 9 fichiers sont du visual/workflow, pas du grounding. → Aucune perte VLM. |
+| (autres) | | | Pas d'autre commit qui supprime du code VLM exploitable. |
+
+→ **Pas de code VLM utile irrémédiablement perdu** : tout est récupérable via `git show`. Le seul élément à signaler est le **prompt officiel UI-TARS** présent dans la version `9da589c8c:core/grounding/server.py`, utile si on veut comparer un modèle UI-TARS reload.
+
+---
+
+## 6. Synthèse factuelle
+
+- **Nombre d'implémentations distinctes ayant existé** :
+  - 7 implémentations actives aujourd'hui (cf. §1.1 + §1.2 + §1.3 modèles distincts).
+  - 2 implémentations historiques fortes ayant été remplacées en-place : UI-TARS-1.5-7B (transformers) → InfiGUI-G1-3B ; SoM+VLM intermédiaire → grounding direct Qwen2.5-VL.
+- **Backends testés au fil du temps** : Ollama (HTTP), vLLM (HTTP OpenAI-compat), Transformers in-process (Flask `server.py`, subprocess one-shot `infigui_worker.py`, daemon Unix socket `infigui_server.py`), HuggingFace direct (SeeClick standalone, OWL-v2 standalone), Cloud opt-in (OpenAI/Gemini/Anthropic via `vlm_provider.py`).
+- **Code directement utilisable pour la migration vers vLLM ou Transformers** :
+  - **Oui pour Transformers** : `core/grounding/server.py` (loader + `_smart_resize` complet avec MIN/MAX_PIXELS) et `core/grounding/infigui_worker.py` (`load_model`, `infer` mode classique + fusion image+anchor) sont quasi clé-en-main pour Qwen2.5-VL / Qwen3-VL. Il suffit de changer `MODEL_ID` (env `GROUNDING_MODEL` déjà supporté).
+  - **Oui pour vLLM** : `agent_v0/server_v1/resolve_engine.py` lignes 785-816 contient déjà l'appel HTTP OpenAI-compatible avec `image_url: data:image/jpeg;base64`. Il manque uniquement le passage explicite de `resized_width`/`resized_height` (extension OpenAI vLLM) — le bug d'échelle bbox_2d documenté dans `docs/MIGRATION_VLM_PLAN_2026-05-09.md`.
+  - L'infrastructure socket persistant + fallback subprocess (`infigui_server.py` + `ui_tars_grounder.py`) est réutilisable telle quelle pour servir un autre modèle Transformers ou pour wrapper un client vLLM.
+
+---
+
+## 7. À clarifier avec Dom
+
+1. **`core/detection/seeclick_adapter.py`** est encore exporté par `core/detection/__init__.py` mais le commit `d1b556b6c` indique qu'il est cassé. Faut-il le sortir de l'import et l'archiver, ou tenter de le réparer pour Qwen3-VL ?
+2. **`core/detection/owl_detector.py`** (Owlv2) est câblé via `core/detection/ui_detector.py` (L31, L113, L126) mais aucun trace de bench récent. Est-il encore appelé en prod ou candidat à l'archivage ?
+3. **`tools/start_grounding_server.sh`** parle encore de `UI-TARS-1.5-7B` dans son banner alors que le serveur charge InfiGUI depuis le commit `77faa03ec`. Doc obsolète mais sans impact runtime — à fixer si on documente la migration.
+4. **`core/grounding/server.py` (Flask port 8200)** vs **`core/grounding/infigui_server.py` (Unix socket)** vs **`core/grounding/infigui_worker.py` (subprocess one-shot)** : trois entry-points distincts pour la même logique transformers. Le service systemd `rpa-grounding.service` ne lance que `infigui_server`. Confirmer que `server.py` (Flask) est conservé volontairement comme alternative dev / test.
+5. **Modèle vLLM par défaut hardcodé** `Qwen/Qwen2.5-VL-7B-Instruct-AWQ` (resolve_engine L791) alors que le plan migration cible Qwen3-VL — env `VLLM_MODEL` permet le switch sans toucher au code, à confirmer comme méthode de migration.

docs/INVESTIGATION_MEMOIRE_VISUELLE_ORPHELINE_2026-05-09.md

@@ -0,0 +1,76 @@
+# Investigation — Mémoire visuelle orpheline
+
+Date : 2026-05-09
+Branche : feature/qw-suite-mai
+Périmètre : modules de cache d'embeddings, validation visuelle continue, et apprentissage par observation, identifiés en code mais non instanciés en runtime.
+
+Hors scope de `docs/AUDIT_CONTROLES_DEBRANCHES_2026-05-08.md` (audit borné à `agent_v0/server_v1/` + `core/*` importés par le serveur). Ces modules ne sont pas importés par le serveur.
+
+## 1. Modules concernés
+
+| Module | Lignes | Commit d'origine | Dernier commit touchant le code | Sites d'instanciation runtime |
+|---|---|---|---|---|
+| `core/visual/visual_embedding_manager.py` | 651 | `a27b74cf2` (2026-01-29, v1.0 stable) | `36737cfe9` (2026-04-14, refactor sécurité serializer) | 0 |
+| `core/visual/screenshot_validation_manager.py` | 571 | `a27b74cf2` (2026-01-29, v1.0 stable) | `a27b74cf2` (idem) | 0 |
+| `core/grounding/shadow_learning_hook.py` | 156 | `73cea2385` (2026-04-25, "Phase 6 — Shadow Learning Hook") | idem | 0 (seul match = exemple docstring du fichier) |
+
+Vérifications effectuées :
+- `grep -rn "VisualEmbeddingManager(" --include="*.py"` hors module et hors `tests/` : 0 hit.
+- `grep -rn "ScreenshotValidationManager("` idem : 0 hit.
+- `grep -rn "ShadowLearningHook("` idem : 0 hit.
+- `core/visual/__init__.py` re-exporte les deux managers, mais aucun consommateur n'importe `from core.visual import …`.
+
+## 2. Rôle déduit du code
+
+### `VisualEmbeddingManager` (core/visual/visual_embedding_manager.py)
+Cache d'embeddings CLIP indexés par signature, métriques de similarité multiples (cosine, euclidean, normalized correlation, score combiné), API `MatchResult`. S'interface avec `core.embedding.fusion_engine.FusionEngine` et utilise `core.security.signed_serializer` pour persister le cache (HMAC signé).
+
+Vise à fournir une recherche de correspondances rapide pour le grounding visuel (intro module : « système RPA 100% visuel », exigences 3.3, 3.4 — référencement non retrouvé dans le repo).
+
+### `ScreenshotValidationManager` (core/visual/screenshot_validation_manager.py)
+Validation périodique automatique d'éléments visuels enregistrés. Statuts `VALID/WARNING/ERROR/UNKNOWN/VALIDATING`, `ValidationReport` avec `ValidationIssue` et `RecoveryAction` proposées (auto-fixable ou non). Dépend de `VisualEmbeddingManager` + `ScreenCapturer` + `UIDetector`.
+
+Vise à alimenter une UI de monitoring de santé des targets visuels (intro : « indicateurs vert/orange/rouge »).
+
+### `ShadowLearningHook` (core/grounding/shadow_learning_hook.py)
+Pont entre observation Shadow (l'humain clique) et `SignatureStore` (base de signatures d'éléments UI). À chaque clic observé : détection de l'élément sous le clic via `FastDetector`, enrichissement de la base. Présenté comme « hook optionnel (callback) » à brancher dans `ShadowObserver` ou l'API de capture.
+
+## 3. Pourquoi non-câblés (analyse historique)
+
+### Sous-système `core/visual/` (VEM + SVM)
+Introduits le 2026-01-29 dans le commit `a27b74cf2` (« v1.0 - Version stable »), antérieur de plusieurs mois aux refontes grounding d'avril 2026 (commits `9da589c8c` pipeline centralisé, `77faa03ec` UI-TARS→InfiGUI, phases 1-6 FAST→SMART→THINK). Le pipeline grounding actuel passe par `core/grounding/*` (`fast_pipeline.py`, `infigui_server.py`, `think_arbiter.py`) qui implémente sa propre logique de signature (`SignatureStore` dans `element_signature.py`) — fonctionnellement redondant avec VEM côté cache d'embeddings, et orthogonal à SVM côté validation continue.
+
+Le `screenshot_validation_manager.py` n'a connu aucun commit depuis sa création (mtime 2026-01-07). Pas de trace de point d'appel envisagé dans les commits ultérieurs.
+
+### `ShadowLearningHook`
+Introduit le 2026-04-25 (`73cea2385`) au sein du pipeline FAST→SMART→THINK (phase 6 sur 6 documentée du commit `b30d4b665`). Le hook attend d'être appelé sur événement clic — mais le `ShadowObserver` (`core/workflow/shadow_observer.py`) ne configure aucun callback de ce type, et `api_stream.py` instancie `ShadowValidator` (validation post-action côté workflow) sans déclencher d'enrichissement de `SignatureStore`.
+
+Le commit suivant (`e2046837c` 2026-04-25, « Phase 5 intégration FAST→SMART→THINK dans ORA ») câble les phases 1-5 dans `observe_reason_act.py` mais ne mentionne pas la phase 6. Probable fin de batch d'implémentation sans pas de câblage côté capture clic.
+
+## 4. Recommandation préliminaire (à statuer en revue +14j, soit 2026-05-23)
+
+| Module | Recommandation | Justification |
+|---|---|---|
+| `VisualEmbeddingManager` | **ACCEPTED + archivage `_archive/`** sauf cas d'usage prod identifié | Redondant avec `SignatureStore` + cache d'embeddings côté `fusion_engine.py`. Maintien sans utilisateur = bruit. |
+| `ScreenshotValidationManager` | **ACCEPTED + archivage** | Pas d'UI de monitoring associée dans `web_dashboard/` ni `visual_workflow_builder/`. Composant prévu pour une fonctionnalité non aboutie. |
+| `ShadowLearningHook` | **CÂBLER** post-démo Kerella | Fonctionnalité cohérente avec la vision aiva-vision (apprentissage progressif). Coût faible : un callback `on_click` dans `ShadowObserver` ou côté API capture. Bénéfice élevé si apprentissage devient prio post-démo. |
+
+L'archivage VEM/SVM ne tranche pas la question plus large d'une unification du cache d'embeddings (VEM + `fusion_engine.py` + `embedding_cache.py`). Cette unification, si pertinente, fait l'objet d'une dette dédiée à instruire séparément, hors scope de cette investigation.
+
+## 5. Tests dépendants à traiter en même temps que l'archivage
+
+Si la revue +14j retient l'archivage de VEM/SVM, les tests suivants doivent être archivés ou réécrits dans le même commit (sinon CI casse ou faux positif vert) :
+
+- `tests/property/test_visual_embedding_manager_properties.py` — dédié VEM (à archiver avec).
+- `tests/integration/test_visual_rpa_checkpoint.py` — couvre VEM + SVM en intégration.
+- `tests/property/test_visual_capture_properties.py` — couvre VEM + SVM.
+- `tests/property/test_interactive_preview_area_properties.py` — référence VEM ; à examiner avant archivage car peut couvrir d'autres composants encore vivants.
+- `tests/property/test_realtime_validation_properties.py` — importe `core.visual` (à examiner : peut viser `VisualTargetManager` qui, lui, est instancié côté VWB et ne doit pas être archivé).
+
+`ShadowLearningHook` n'a aucun test associé.
+
+## 6. Dette identifiée hors scope de cette investigation
+
+L'investigation actuelle s'est limitée au sous-système mémoire visuelle. Le constat que des modules orphelins existent au-delà du périmètre de l'AUDIT serveur du 2026-05-08 (cf. modules identifiés en sections 1-2) suggère fortement que d'autres orphelins existent ailleurs dans le repo (VWB, agent_chat, demo/, deploy/, autres).
+
+Un audit exhaustif des modules orphelins du repo constitue une dette identifiée à instruire post-démo Kerella. Numéro de dette non réservé à ce stade (instruction préalable nécessaire pour cadrer le périmètre).

docs/MIGRATION_VLM_PLAN_2026-05-09.md

@@ -0,0 +1,73 @@
+# Migration grounding VLM — qwen2.5vl Ollama → vLLM/Transformers (Qwen3-VL)
+
+Date plan : 2026-05-09 (rédigé le 2026-05-08 au soir)
+Branche cible : feature/<à-créer-demain>
+État actuel : grounding passe par Ollama, qwen2.5vl:7b en split CPU/GPU 42/58.
+
+## 1. Constat
+
+Deux problèmes structurels relevés le 8 mai 2026.
+
+### 1.1. VRAM saturée
+
+`qwen2.5vl:7b` chargé via Ollama pèse 14 GB en mémoire totale alors que la machine n'a que 12 GB de VRAM. Ollama bascule en split CPU/GPU 42/58. Latence mesurée par appel grounding : ~11 s. À titre de référence, `qwen3-vl:8b` (6 GB) tient en full GPU et descend à 1.7 s sur le même cas.
+
+### 1.2. Bug d'échelle bbox_2d (root cause documentée)
+
+La doc officielle Qwen2.5-VL précise que les coordonnées renvoyées sont dans la résolution post-`smart_resize`, pas dans la résolution de l'image envoyée par le client. Or Ollama applique son propre `smart_resize` en interne sans exposer la taille effective au client. Conséquence : le code prod divise par `small_w = orig_w` (taille envoyée) au lieu de `resized_w` → coordonnées toutes shiftées vers le top-left. Bug systémique présent dans 4 occurrences de `agent_v0/server_v1/resolve_engine.py` et dans `_locate_popup_button` (L:2576).
+
+Tant que le grounding passe par Ollama, le fix ne peut être qu'une rustine (resize forcé côté serveur AVANT envoi pour matcher la convention que Ollama va appliquer ensuite — fragile, dépend de la version Ollama).
+
+Source : [HF discussion #13 sur Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct/discussions/13)
+Citation mainteneur : « The bbox_2d coordinates ... will be relative to your **resized image size** if you are resizing. »
+Citation discussion : « **resized dimensions parameter is not supported in OLLAMA**, which complicates coordinate translation. »
+
+## 2. Rappel bench 8 mai 2026
+
+Screenshot fixture : `data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773792436.png` (2560×1600, boîte de dialogue OK/Cancel).
+
+| Modèle / config | Latence | Format bbox_2d | Parse regex prod | Coords cohérentes |
+|---|---|---|---|---|
+| qwen2.5vl:7b Ollama (num_predict=50, prod) | 11.0 s | `{"bbox_2d":[422,604,462,624]}` | oui | non (cx ≈ 0.17, top-left) |
+| qwen3-vl:8b Ollama (params prod stricts) | 8.0 s | vide (50 tokens absorbés par thinking) | non | n/a |
+| qwen3-vl:8b Ollama (think:false, num_predict=256) | 1.7 s | liste nue `[332,487,362,507]` | non (regex attend `"bbox_2d":[...]`) | n/a |
+| qwen3-vl:8b Ollama (prompt JSON explicite) | 1.8 s | `{"bbox_2d":[...]}` | oui | non (même bug d'échelle) |
+
+## 3. Chemin technique cible
+
+vLLM ou Transformers direct, avec passage explicite de `resized_width` et `resized_height` au modèle (paramètre supporté par les deux backends), garantissant que les `bbox_2d` retournés sont dans la même résolution que celle qu'on a passée. Le service `core/grounding/server.py` (déjà en place pour InfiGUI via Unix socket, avec `_smart_resize`, `MIN_PIXELS=100*28*28`, `MAX_PIXELS=5600*28*28`) sert de référence architecturale.
+
+Modèle pressenti : `qwen3-vl:8b` (6 GB en VRAM, full GPU possible), avec :
+- `think:false` (désactiver le mode thinking par défaut)
+- `num_predict >= 128` (50 insuffisant : tokens absorbés par thinking quand activé)
+- prompt imposant le format JSON `[{"bbox_2d":[...],"label":"..."}]`
+- preprocessing image côté serveur : `_smart_resize` officiel (max_size=1280, multiples de 28, code dans la discussion HF)
+
+## 4. Étapes de migration (5)
+
+1. **[Setup] Choix du backend grounding** : vLLM, Transformers direct, ou réorientation de `core/grounding/server.py` vers Qwen3-VL plutôt que démarrer une 4ème stack. Décision à acter en début de chantier.
+2. **[Preprocessing] Implémenter `_smart_resize` côté `resolve_engine.py`** avec la formule officielle (max_size=1280, multiples de 28). Capturer la nouvelle taille (`resized_w`, `resized_h`) et la passer au backend choisi.
+3. **[Parser] Adapter les 4 occurrences `bbox_2d` parsing** (`resolve_engine.py:840-848`, 870-880, 908-917, et `_locate_popup_button` L:2576) pour diviser par `resized_w`/`resized_h` et non plus `small_w/h` (= `orig_w/h`). Centraliser dans une seule fonction utilitaire.
+4. **[Prompt] Imposer le format JSON `bbox_2d`** dans le prompt envoyé (Qwen3-VL ne le sort pas spontanément, sortie liste nue par défaut). Ajouter `think:false` et `num_predict>=128` aux options.
+5. **[Test bbox_2d cible] Refaire le bench du 8 mai** avec la convention contrôlée. Critère de validation : sur le screenshot heartbeat de référence, le bouton OK doit être localisé à un `cx ≈ 0.45-0.55` (mid-screen) et non plus 0.17.
+
+## 5. Test bbox_2d à refaire (post-migration)
+
+Reproduire le test du 8 mai avec :
+- Même screenshot fixture : `data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773792436.png`
+- Même cible : bouton "OK" de la boîte de dialogue
+- Backend nouveau (vLLM ou Transformers + `smart_resize` côté client)
+
+Sortie attendue : `bbox_2d` en pixels de l'image redimensionnée connue → division par `resized_w` → `cx` visuellement ≈ centre du bouton (vérification par overlay sur le screenshot).
+
+## 6. Hors scope du chantier migration (à traiter après)
+
+- Nettoyage de la logique « décharger gemma4 pour qwen2.5vl » dans `agent_v0/server_v1/stream_processor.py:442,1742` — devient inutile une fois qwen2.5vl écarté.
+- Nettoyage des 9 mentions/commentaires `qwen2.5vl` dans le code.
+- Décision sur le maintien d'une compat fallback Ollama (utile en dev sans GPU) ou abandon complet.
+
+## 7. Risques / points de vigilance
+
+- Si vLLM tourne sur le même GPU que streaming/agent-chat, vérifier que la VRAM tient : qwen3-vl 6 GB + streaming 0.8 GB + agent-chat 0.8 GB = 7.6 GB → marge OK sur 12 GB.
+- Le bench du 8 mai montrait des coordonnées visuellement incorrectes MÊME avec un format `bbox_2d` valide. La résolution du bug d'échelle est nécessaire mais peut-être pas suffisante. Vérifier après l'étape 5.
+- `_locate_popup_button` (`resolve_engine.py:2536-2585`) est plus simple à migrer que la cascade principale. Faire un POC sur cette fonction avant d'attaquer la cascade.

docs/QW_SMOKE_TESTS_2026-05-06.md

@@ -0,0 +1,343 @@
+# QW Suite Mai — Smoke tests pour validation manuelle
+
+**Date d'exécution prévue** : 2026-05-06 (matin)
+**Branche** : `feature/qw-suite-mai`
+**Durée estimée** : ~1h20 si tout passe, +30 min de debug par test KO
+
+> Coche au fur et à mesure. Si un test KO, applique le "Si KO" puis re-tente.
+> Tout test critique en KO bloquant → kill-switch (procédure §10).
+
+---
+
+## §0. Préflight (5 min)
+
+- [ ] **0.1** Vérifier branche : `git -C /home/dom/ai/rpa_vision_v3 branch --show-current`
+  Attendu : `feature/qw-suite-mai`
+
+- [ ] **0.2** Vérifier les commits récents : `git -C /home/dom/ai/rpa_vision_v3 log --oneline -15`
+  Attendu : voir tous les commits du sprint (spec, plan, QW1×4, QW2×2, QW4×3, docs, fixes A/B/C éventuels)
+
+- [ ] **0.3** Lancer la baseline rapide :
+  ```bash
+  cd /home/dom/ai/rpa_vision_v3
+  .venv/bin/pytest tests/unit/test_monitor_router.py \
+                   tests/unit/test_loop_detector.py \
+                   tests/unit/test_safety_checks_provider.py \
+                   tests/integration/test_grounding_offset.py \
+                   tests/integration/test_loop_detector_replay.py \
+                   tests/integration/test_replay_resume_acknowledgments.py \
+                   -q
+  ```
+  Attendu : `27 passed` (en ~5s).
+  Si KO : ne pas continuer, regarder l'erreur et m'appeler.
+
+- [ ] **0.4** Vérifier les services systemd :
+  ```bash
+  ./svc.sh status
+  ```
+  Attendu : `streaming`, `vwb-backend`, `vwb-frontend`, `dashboard` au minimum running.
+  Si KO : `./svc.sh start` puis re-vérifier.
+
+- [ ] **0.5** Ouvrir un terminal dédié pour `journalctl` (sera utilisé tout le long) :
+  ```bash
+  journalctl -u rpa-streaming -f
+  ```
+  Le laisser ouvert dans un coin de l'écran.
+
+---
+
+## §1. Test QW1 mono-écran (10 min) — RÉGRESSION
+
+**But** : prouver que le sprint n'a pas cassé un workflow Easily Assure existant.
+
+- [ ] **1.1** Ouvrir VWB : `https://vwb.labs.laurinebazin.design` (ou `http://localhost:3002` en local)
+
+- [ ] **1.2** Sélectionner un workflow validé le 30/04 sur Easily Assure (UHCD ou Forfait, le plus simple).
+
+- [ ] **1.3** Cliquer "→ Windows" pour lancer le replay sur Agent V1.
+
+- [ ] **1.4** Pendant l'exécution, dans le terminal `journalctl`, chercher la ligne :
+  ```
+  [BUS] lea:monitor_routed source=focus|composite_fallback ...
+  ```
+  Attendu : au moins 1 occurrence par action visuelle. Sur poste mono-écran, `source=composite_fallback` ou `source=focus` (les deux sont OK).
+
+- [ ] **1.5** Le replay doit terminer **identique** à avant (mêmes clics aux mêmes endroits).
+
+**Verdict** : ☐ OK ☐ KO
+**Si KO** : noter l'écart visuel, kill-switch QW2/QW4 (§10) puis re-tester. Si encore KO → rollback (§11).
+
+---
+
+## §2. Test QW1 multi-écrans (15 min, optionnel) — VALEUR AJOUTÉE
+
+**But** : prouver que le ciblage par écran fonctionne. **Skip si tu n'as qu'un seul écran sur le poste de démo.**
+
+- [ ] **2.1** Brancher un 2ème écran sur le poste Windows (Agent V1).
+
+- [ ] **2.2** Vérifier qu'Agent V1 voit les 2 écrans :
+  ```bash
+  ssh dom@192.168.1.11
+  C:\rpa_vision\.venv\Scripts\python.exe -c "from screeninfo import get_monitors; print([(m.x, m.y, m.width, m.height) for m in get_monitors()])"
+  ```
+  Attendu : 2 tuples affichés.
+
+- [ ] **2.3** Lancer le même workflow Easily Assure (§1.2).
+
+- [ ] **2.4** Dans `journalctl`, observer :
+  - Heartbeats Windows enrichis (cf. fix A) : la session reçoit `monitor_index` en continu.
+  - `[BUS] lea:monitor_routed source=focus idx=0` ou `idx=1` selon où Easily est ouvert.
+
+- [ ] **2.5** Déplacer la fenêtre Easily Assure sur le 2ème écran avant un nouveau replay → relancer → vérifier que le clic atterrit sur le 2ème écran (pas sur le composite).
+
+**Verdict** : ☐ OK ☐ KO ☐ Skipped (pas de 2ème écran)
+
+---
+
+## §3. Test QW2 LoopDetector — boucle artificielle (10 min)
+
+**But** : prouver que Léa s'arrête seule quand elle tourne en rond.
+
+- [ ] **3.1** Dupliquer un workflow simple (1-2 actions) dans VWB.
+
+- [ ] **3.2** Modifier la 1ère action `click` pour qu'elle cible un `target_text` impossible (ex: `target_text="ZZZZZ_INEXISTANT_999"`).
+
+- [ ] **3.3** Lancer le replay.
+
+- [ ] **3.4** Dans `journalctl`, attendre l'apparition de :
+  ```
+  LoopDetector: replay XXX mis en pause — signal=retry_threshold ...
+  [BUS] lea:loop_detected ...
+  ```
+  Délai attendu : ~30-60s (3 retries × ~10s par retry visuel).
+
+- [ ] **3.5** Côté VWB : la bulle `PauseDialog` doit apparaître avec `pause_reason=loop_detected`.
+
+- [ ] **3.6** Cliquer "Annuler" pour arrêter le replay propre.
+
+**Verdict** : ☐ OK ☐ KO
+**Si KO** : vérifier `RPA_LOOP_DETECTOR_ENABLED=1` (défaut). Si toujours KO → log dans `journalctl` doit donner la raison.
+
+---
+
+## §4. Test QW4 backward — workflow legacy (5 min)
+
+**But** : prouver qu'un `pause_for_human` existant continue à marcher exactement comme avant.
+
+- [ ] **4.1** Sélectionner un workflow ayant déjà une action `pause_for_human` (sans `safety_level` ni `safety_checks`).
+
+- [ ] **4.2** Lancer le replay.
+
+- [ ] **4.3** Quand la pause apparaît : la bulle doit être **identique** à avant (juste le `message`, boutons Continuer/Annuler, **PAS** de checklist).
+
+- [ ] **4.4** Dans `journalctl`, vérifier qu'**aucun** appel à Ollama `medgemma:4b` n'est lancé (pas de ligne avec ce modèle).
+
+- [ ] **4.5** Cliquer Continuer → le replay doit reprendre sans erreur.
+
+**Verdict** : ☐ OK ☐ KO
+**Si KO** : régression. Kill-switch QW4 (§10) + re-test.
+
+---
+
+## §5. Test QW4 safety_checks déclaratifs (15 min)
+
+**But** : prouver que la checklist s'affiche et bloque le Continue tant que les required ne sont pas cochés.
+
+- [ ] **5.1** Dans VWB, créer ou modifier un workflow pour insérer une action `pause_for_human` avec :
+  - `message` : "Validation patient"
+  - `safety_level` : `standard` (PAS medical_critical, on isole le déclaratif)
+  - `safety_checks` : 2 entrées
+    - `{id: "check_ipp", label: "IPP correct ?", required: true}`
+    - `{id: "check_diag", label: "Diagnostic confirmé ?", required: true}`
+
+- [ ] **5.2** Sauvegarder, lancer le replay.
+
+- [ ] **5.3** Quand la pause apparaît :
+  - ☐ Bulle "Pause supervisée" affichée
+  - ☐ 2 cases à cocher visibles avec badges `[obligatoire]`
+  - ☐ Bouton "Continuer" désactivé (grisé)
+  - ☐ Aucun badge `[Léa]` (pas de medical_critical → pas de LLM)
+
+- [ ] **5.4** Cocher 1 seule case → Continuer reste désactivé.
+- [ ] **5.5** Cocher la 2ème case → Continuer s'active.
+- [ ] **5.6** Cliquer Continuer → replay reprend.
+
+- [ ] **5.7** Test de sécurité : forcer un POST `/api/v3/replay/resume` sans cocher (via curl) :
+  ```bash
+  # Récupérer le replay_id en cours via VWB ou journalctl
+  curl -X POST http://localhost:5002/api/v3/replay/resume \
+       -H "Content-Type: application/json" \
+       -d '{"replay_id":"<replay_id>","acknowledged_check_ids":[]}'
+  ```
+  Attendu : `400 {"detail": {"error": "required_checks_missing", "missing": ["check_ipp","check_diag"]}}`
+
+**Verdict** : ☐ OK ☐ KO
+
+---
+
+## §6. Test QW4 medical_critical avec LLM (15 min)
+
+**But** : prouver que Léa appelle medgemma:4b en moins de 5s et ajoute des checks contextuels.
+
+- [ ] **6.1** Vérifier que `medgemma:4b` est dispo dans Ollama :
+  ```bash
+  ollama list | grep medgemma
+  ```
+  Attendu : `medgemma:4b` listé. Si absent : `ollama pull medgemma:4b` (3.3 GB).
+
+- [ ] **6.2** Reprendre le workflow §5.1 et changer `safety_level: medical_critical`.
+
+- [ ] **6.3** Lancer le replay.
+
+- [ ] **6.4** Quand la pause apparaît :
+  - ☐ Bulle affichée
+  - ☐ 2 checks déclaratifs (badges `[obligatoire]`)
+  - ☐ 0 à 3 checks supplémentaires avec badge `[Léa]` bleu (tooltip = evidence)
+  - ☐ Délai d'apparition < 5s (sinon le timeout a sauvé)
+
+- [ ] **6.5** Dans `journalctl`, vérifier la ligne :
+  ```
+  [BUS] lea:safety_checks_generated count=N sources=['declarative', 'declarative', 'llm_contextual', ...]
+  ```
+
+- [ ] **6.6** Si Ollama timeout ou crash, vérifier la ligne :
+  ```
+  [BUS] lea:safety_checks_llm_failed reason=... detail=...
+  ```
+  Et la pause s'affiche tout de même avec les 2 checks déclaratifs (fallback safe).
+
+**Verdict** : ☐ OK ☐ KO
+
+---
+
+## §7. Test bus events `lea:*` (5 min)
+
+**But** : agréger les events vus pour audit démo.
+
+- [ ] **7.1** Lancer un replay complet de A à Z (workflow §1 ou §6).
+
+- [ ] **7.2** À la fin, extraire tous les events `[BUS]` du journal :
+  ```bash
+  journalctl -u rpa-streaming --since "10 minutes ago" | grep "\[BUS\]" | tail -30
+  ```
+
+- [ ] **7.3** Vérifier la présence d'au moins :
+  - `lea:monitor_routed` (au moins 1 par action visuelle)
+  - `lea:safety_checks_generated` (si test §6 fait, au moins 1)
+  - `lea:loop_detected` (si test §3 fait)
+
+**Verdict** : ☐ OK ☐ KO
+
+---
+
+## §8. Test kill-switches (10 min) — RÉFLEXE DÉMO
+
+**But** : savoir désactiver QW2/QW4 en pleine démo si ça part en vrille.
+
+- [ ] **8.1** Désactiver QW2 + QW4 :
+  ```bash
+  sudo systemctl edit rpa-streaming
+  # Ajouter sous [Service] :
+  Environment=RPA_LOOP_DETECTOR_ENABLED=0
+  Environment=RPA_SAFETY_CHECKS_LLM_ENABLED=0
+  # Sauver, sortir
+  sudo systemctl restart rpa-streaming
+  ```
+
+- [ ] **8.2** Re-lancer un replay quelconque.
+
+- [ ] **8.3** Dans `journalctl` : vérifier qu'**aucun** event `lea:loop_detected` ni `lea:safety_checks_generated` n'apparaît.
+
+- [ ] **8.4** Réactiver (avant la démo réelle) :
+  ```bash
+  sudo systemctl edit rpa-streaming
+  # Supprimer les 2 lignes Environment=...
+  sudo systemctl restart rpa-streaming
+  ```
+
+- [ ] **8.5** Re-vérifier qu'un replay normal réémet les bus events.
+
+**Verdict** : ☐ OK ☐ KO
+
+---
+
+## §9. Test rollback complet (procédure) — RÉFLEXE D'URGENCE
+
+**À NE PAS exécuter sauf vraie urgence**, juste connaître la commande :
+
+```bash
+cd /home/dom/ai/rpa_vision_v3
+git checkout backup/pre-qw-suite-mai-2026-05-05
+./svc.sh restart
+```
+
+Pour revenir au sprint après rollback :
+```bash
+git checkout feature/qw-suite-mai
+./svc.sh restart
+```
+
+- [ ] **9.1** Lire la procédure, savoir où elle est documentée (`docs/QW_SUITE_MAI.md`).
+
+---
+
+## §10. Si problème en pleine démo
+
+Ordre des réflexes :
+
+1. **Kill-switch QW2 d'abord** (LoopDetector = couche passive, désactiver est sans risque) :
+   ```bash
+   sudo systemctl set-environment RPA_LOOP_DETECTOR_ENABLED=0
+   sudo systemctl restart rpa-streaming
+   ```
+   *(set-environment est plus rapide que `systemctl edit` mais ne survit pas au reboot — OK pour démo)*
+
+2. **Kill-switch QW4 ensuite** si toujours problème :
+   ```bash
+   sudo systemctl set-environment RPA_SAFETY_CHECKS_LLM_ENABLED=0
+   sudo systemctl restart rpa-streaming
+   ```
+
+3. **Rollback complet** si toujours KO (cf. §9).
+
+---
+
+## §11. Récap final
+
+À cocher après tous les tests pour acter "prêt démo" :
+
+- [ ] §1 mono-écran OK (régression zéro)
+- [ ] §2 multi-écrans OK ou skip assumé
+- [ ] §3 LoopDetector OK
+- [ ] §4 backward QW4 OK
+- [ ] §5 safety_checks déclaratifs OK
+- [ ] §6 medical_critical + LLM OK
+- [ ] §7 bus events visibles dans journalctl
+- [ ] §8 kill-switches testés et fonctionnels
+- [ ] §9 procédure rollback connue
+
+**Si tout coché → démo GHT GO** 🟢
+**Si §1 ou §3 ou §5 KO → démo NO-GO sans fix** 🔴
+**Si §2 ou §6 KO → démo OK avec kill-switch QW correspondant** 🟡
+
+---
+
+## Annexes
+
+- Spec : `docs/superpowers/specs/2026-05-05-qw-suite-mai-design.md`
+- Plan d'exécution : `docs/superpowers/plans/2026-05-05-qw-suite-mai.md`
+- Synthèse livraison : `docs/QW_SUITE_MAI.md`
+- Backup distant : `backup/pre-qw-suite-mai-2026-05-05` (Gitea)
+- Tests automatisés (référence 116 passed) :
+  ```bash
+  .venv/bin/pytest tests/unit/test_monitor_router.py \
+                   tests/unit/test_loop_detector.py \
+                   tests/unit/test_safety_checks_provider.py \
+                   tests/integration/test_grounding_offset.py \
+                   tests/integration/test_loop_detector_replay.py \
+                   tests/integration/test_replay_resume_acknowledgments.py \
+                   tests/test_pipeline_e2e.py \
+                   tests/test_phase0_integration.py \
+                   tests/integration/test_stream_processor.py \
+                   -q
+  ```

docs/QW_SUITE_MAI.md

@@ -0,0 +1,101 @@
+# QW Suite Mai 2026 — Synthèse de livraison
+
+Sprint d'amélioration RPA Vision V3, branche `feature/qw-suite-mai`,
+inspiré par exploration comparative de 5 frameworks computer-use
+(Simular Agent-S, browser-use, OpenAI CUA, Coasty, Showlab OOTB).
+
+## Trois quick wins livrés
+
+- **QW1 — Multi-écrans** : capture/grounding par `monitor_index` avec fallbacks
+  focus actif puis composite. Backward 100% sur workflows existants.
+  Ajoute `screeninfo>=0.8` aux dépendances Agent V1.
+- **QW2 — LoopDetector composite** : détection passive de stagnation via
+  3 signaux (CLIP screen_static + action_repeat + retry_threshold).
+  Bascule en `paused_need_help` automatique.
+- **QW4 — Safety checks hybrides** : `pause_for_human` enrichi de checks
+  déclaratifs (workflow) + LLM contextuels (`medgemma:4b` local, timeout 5s,
+  fallback safe). UX VWB avec ChecklistPanel acquittable + audit trail.
+
+## Kill-switches en cas de problème
+
+```bash
+sudo systemctl edit rpa-streaming
+# Ajouter sous [Service] :
+Environment=RPA_LOOP_DETECTOR_ENABLED=0
+Environment=RPA_SAFETY_CHECKS_LLM_ENABLED=0
+sudo systemctl restart rpa-streaming
+```
+
+Rollback complet : `git checkout backup/pre-qw-suite-mai-2026-05-05`.
+
+## Variables d'environnement utiles
+
+| Variable | Défaut | Effet |
+|---|---|---|
+| `RPA_LOOP_DETECTOR_ENABLED` | `1` | Kill-switch QW2 (composite) |
+| `RPA_LOOP_SCREEN_STATIC_THRESHOLD` | `0.99` | Seuil similarité CLIP |
+| `RPA_LOOP_SCREEN_STATIC_N` | `4` | Nb captures consécutives |
+| `RPA_LOOP_ACTION_REPEAT_N` | `3` | Nb actions identiques |
+| `RPA_LOOP_RETRY_THRESHOLD` | `3` | Nb retries cumulés |
+| `RPA_SAFETY_CHECKS_LLM_ENABLED` | `1` | Kill-switch QW4 LLM contextuel |
+| `RPA_SAFETY_CHECKS_LLM_MODEL` | `medgemma:4b` | Modèle Ollama |
+| `RPA_SAFETY_CHECKS_LLM_TIMEOUT_S` | `5` | Timeout dur (secondes) |
+| `RPA_SAFETY_CHECKS_LLM_MAX_CHECKS` | `3` | Max checks LLM ajoutés |
+
+## Smoke tests manuels à effectuer avant la démo GHT
+
+Ces tests demandent une interaction VWB et un Agent V1 actif — non automatisables.
+
+1. **QW1 multi-écrans** : rejouer un workflow Easily Assure validé. Vérifier
+   logs `[BUS] lea:monitor_routed` dans `journalctl -u rpa-streaming`. Le clic
+   doit atterrir au bon endroit même sur un poste à 2 écrans.
+2. **QW2 LoopDetector** : optionnel, difficile à reproduire fiable. Si tu
+   constates un bouclage en démo, vérifier que `paused_need_help` se déclenche
+   automatiquement avec `pause_reason="loop_detected"`.
+3. **QW4 safety_checks** :
+   - Workflow ancien sans `safety_checks` → bulle simple legacy s'affiche
+   - Workflow avec `safety_checks` déclaratifs → ChecklistPanel s'affiche,
+     bouton Continuer désactivé tant que required non cochés
+   - Workflow `safety_level: medical_critical` → checks LLM ajoutés en
+     plus (badge `[Léa]`), apparaissent dans les 5s
+   - POST `/api/v3/replay/resume` sans required acquitté → 400 toast UI
+
+## Tests automatisés (référence)
+
+```
+.venv/bin/pytest tests/unit/test_monitor_router.py \
+                 tests/integration/test_grounding_offset.py \
+                 tests/unit/test_loop_detector.py \
+                 tests/integration/test_loop_detector_replay.py \
+                 tests/unit/test_safety_checks_provider.py \
+                 tests/integration/test_replay_resume_acknowledgments.py \
+                 -v
+```
+
+Référence : 24 tests QW + 89 baseline = 113 passed.
+
+## Référence design
+
+`docs/superpowers/specs/2026-05-05-qw-suite-mai-design.md`
+
+## Référence plan d'exécution
+
+`docs/superpowers/plans/2026-05-05-qw-suite-mai.md`
+
+## Backup
+
+Branche backup poussée Gitea avant le sprint :
+`backup/pre-qw-suite-mai-2026-05-05` + tag `backup-pre-qw-suite-mai-2026-05-05`.
+
+## Statut au 2026-05-05
+
+| Composant | État | Smoke démo nécessaire |
+|---|---|---|
+| QW1 monitor_router + offsets | Livré, tests verts | Oui (multi-écran physique) |
+| QW1 enrichissement Agent V1 | Livré, fallback gracieux si screeninfo absent | Oui (Windows réel) |
+| QW1 hook serveur + cablage executor | Livré (commit fix fc01afa59) | Oui |
+| QW2 LoopDetector module | Livré, tests verts | Non (impossible à reproduire fiable) |
+| QW2 hook api_stream | Livré, tests verts | Non |
+| QW4 SafetyChecksProvider | Livré, tests verts | Oui (avec workflow `medical_critical`) |
+| QW4 endpoint /replay/resume + proxy VWB | Livré, tests verts | Oui (POST avec acknowledged_check_ids) |
+| QW4 PauseDialog + PropertiesPanel | Livré, 0 nouvelle erreur TS | Oui (rendre la bulle dans VWB) |

docs/REPLAY_BLOCAGE_NOTES_MEDICALES_2026-05-08.md

@@ -0,0 +1,375 @@
+# Diagnostic — Replay `replay_free_68ca51ab` bloqué sur l'onglet Imagerie
+
+Date : 8 mai 2026 (matin avant démo GHT Sud 95)
+Workflow : `Urgence_aiva_demo` (`wf_a38aeebea5e6_1778162737`)
+Replay : `replay_free_68ca51ab` (cancellé manuellement à 10:34, après pause supervisée step 18)
+Auteur : ingénieur senior debug RPA / vision
+
+> **TL;DR — il y a deux causes simultanées, l'une explique l'autre.**
+>
+> 1. **Cause primaire (réseau) :** le client Léa V1 Windows utilise un `read_timeout=5 s` sur `GET /replay/next`. Sur cette même connexion, le serveur exécute parfois un `extract_text` (5–7 s) PUIS dispatche un `click` dans le même appel. Le client coupe avant la réponse. L'action `click` était déjà *poppée* de la queue serveur (`_retry_pending`), donc **elle est perdue silencieusement** — pas de retry automatique, pas de re-dispatch.
+>     C'est ce qui s'est passé pour les steps 10, 12, 14 et 17 (clic Imagerie, Notes médicales, Synthèse Urgences, Codage). Le client a poursuivi son polling, mais quand il est revenu à l'écoute, le serveur en était déjà au step 18 (`Coller ou saisir le dossier patient`) — qui n'existe que sur la maquette aiva-vision (`codage.html`), donc échec `target_not_found` → pause supervisée.
+>
+> 2. **Cause aggravante (vision) :** la cascade `OCR-DIRECT` (`_resolve_by_ocr_text`) renvoie le **centre de la ligne entière** quand le `target_text` n'est qu'un sous-fragment (`score=0.8`). Pour la barre de tabs Easily, docTR détecte les 5 tabs comme une seule ligne. Conséquence : `Imagerie`, `Notes médicales` et `Synthèse Urgences` retournent quasiment les mêmes coordonnées (~0.23, 0.28) — c'est-à-dire le centre de la rangée de tabs (qui tombe sur Imagerie). Même si le client avait reçu chaque action, le clic aurait probablement raté la cible.
+
+---
+
+## 1. Reconstruction temporelle
+
+Workflow `Urgence_aiva_demo` (steps issues de la DB SQLite, ordre 1→22) :
+
+| Order | id (court)     | type             | label                                         |
+|-------|----------------|------------------|-----------------------------------------------|
+| 1     | 43ab3c1417d3   | extract_table    | Lire liste patients (IPP)                     |
+| 2     | 1dada40f6a44   | pause_for_human  | Confirmer démarrage                           |
+| 3     | 288d0bceea90   | click_anchor     | Ouvrir dossier MOREL (25003284)               |
+| 4     | 5388268582d6   | extract_text     | Lire Motif d'admission (`t_motif`)            |
+| 5     | b18e530526bb   | keyboard_shortcut| Scroll fin de page (End)                      |
+| 6     | b425b17b37f6   | extract_text     | Lire bas de Motif (`t_motif_bas`)             |
+| 7     | fc4cf0a78b65   | keyboard_shortcut| Retour haut (Home)                            |
+| 8     | 45f5d7fb7456   | click_anchor     | Onglet Examens cliniques                      |
+| 9     | 4148c9e8caa4   | extract_text     | Lire Examens cliniques (`t_examens`)          |
+| 10    | 4c0663941f22   | click_anchor     | Onglet Imagerie                               |
+| 11    | 93cf4c6651f3   | extract_text     | Lire Imagerie (`t_imagerie`)                  |
+| 12    | **3b13c973d737** | click_anchor   | **Onglet Notes médicales**                    |
+| 13    | a5840d6bf8ed   | extract_text     | Lire Notes médicales (`t_notes`)              |
+| 14    | 8767d8e2e221   | click_anchor     | Onglet Synthèse Urgences                      |
+| 15    | 835e5dd54bb7   | extract_text     | Lire Synthèse (`t_synthese`)                  |
+| 16    | fc5a9676af55   | t2a_decision     | Décision T2A (LLM)                            |
+| 17    | 156d7cd29ebb   | click_anchor     | Onglet « Codage > » (vers maquette aiva)      |
+| 18    | 36346c1c40b9   | click_anchor     | Cliquer textarea DPI (sur codage.html)        |
+| ...   |                |                  |                                               |
+
+### Logs serveur — `journalctl --user -u rpa-streaming`
+
+Filtrage `replay_free_68ca51ab` + `RESOLVE_*` + `REPORT` + `extract_text`. Extraits pertinents :
+
+```
+10:25:46  RESOLVE_ENTRY  by_text='Examens cliniques' strict_mode=True screen=2560x1490 has_anchor=True
+10:25:48  Strict resolve OCR-DIRECT : OK 'Examens cliniques' → (0.2305, 0.2676) score=0.80
+10:25:48  RESOLVE_EXIT   resolved=True method='hybrid_text_direct' coords=(0.2305, 0.2676) score=0.8
+10:25:49  REPORT step_45f5d7fb7456 success=True actual_position=(0.2305, 0.2798)
+
+10:25:55  extract_text → variable 't_examens' (1689 chars)
+10:25:55  DISPATCH action_id=step_4c0663941f22 (click) by_text='Imagerie'   ← client a déjà timeout
+
+10:26:01  extract_text → variable 't_imagerie' (1084 chars)
+10:26:01  DISPATCH action_id=step_3b13c973d737 (click) by_text='Notes médicales'   ← perdu
+
+10:26:08  extract_text → variable 't_notes' (1084 chars)
+10:26:08  DISPATCH action_id=step_8767d8e2e221 (click) by_text='Synthèse Urgences'  ← perdu
+
+10:26:17  extract_text → variable 't_synthese' (1084 chars)
+10:26:27  t2a_decision → variable 'dec' decision=FORFAIT_URGENCE (10.0s)
+10:26:27  DISPATCH action_id=step_156d7cd29ebb (click) by_text='Codage'  ← perdu (concurrence de polls)
+10:26:27  DISPATCH action_id=step_36346c1c40b9 (click) by_text='Coller ou saisir le dossier patient'
+
+10:26:28  RESOLVE_ENTRY by_text='Coller ou saisir le dossier patient' strict_mode=True
+10:26:30  Strict resolve OCR-DIRECT : 'Coller ou saisir le dossier patient' non trouvé, passage VLM
+10:26:36  RESOLVE_EXIT  resolved=False method='strict_vlm_template_failed'
+…
+10:28:47  REPORT step_36346c1c40b9 success=False error='target_not_found' warning='visual_resolve_failed'
+10:34:00  Replay annulé manuellement
+```
+
+**Ce qui ne figure PAS dans les logs serveur** : aucun `RESOLVE_ENTRY` pour `by_text='Imagerie'`, `'Notes médicales'`, `'Synthèse Urgences'` ou `'Codage'` côté replay live. La cascade de résolution n'a JAMAIS été appelée pour ces tabs. → Le client n'a jamais frappé `/resolve_target` ni reçu l'action.
+
+### Logs client — `C:\rpa_vision\agent_debug.log`
+
+```
+10:25:44.710  Action de replay recue : click (id=step_45f5d7fb7456 — Examens cliniques)
+10:25:47.448  Server resolve OK [hybrid_text_direct] score=0.80
+10:25:48.008  Replay click [VISUAL] : (0.230, 0.280) -> (590, 447) sur (2560x1600)
+10:25:48.324  Ecran change apres ~200ms
+10:25:48.537  Resultat rapporte : replay_status=running, restant=14
+10:25:53.771  WARNING : HTTPConnectionPool(host=192.168.1.40, port=5005): Read timed out (read timeout=5)
+10:25:53.771  Replay termine - retour en mode capture
+10:25:53.780  shared_state Replay termine
+                                                                      ← 33 s de silence
+10:26:26.608  Action de replay recue : click (id=step_36346c1c40b9 — Coller ou saisir...)
+10:26:35.409  Server resolve échoué : vlm_and_template_all_failed
+10:26:39.096  Server resolve échoué : no_target_criteria
+10:26:44.178  Server resolve échoué : vlm_and_template_all_failed
+10:26:45.585  ERROR [LEA] Léa a besoin d'aide: Je n'y arrive pas (« Coller ou saisir... »)
+…
+10:28:45.762  [APPRENTISSAGE] Timeout global → 0 actions capturées
+10:28:46.231  Replay termine
+```
+
+→ Confirmation directe : le client a sauté **9 actions serveur+visuelles** entre l'OK Examens cliniques (10:25:48) et la réception de step 18 (10:26:26).
+
+---
+
+## 2. Diagnostic causal
+
+### Chaîne de responsabilité
+
+```
++---------------------------------------------------------------------------+
+|  Hyp #1 (cascade serveur foire) — INFIRMÉE                                |
+|    La cascade serveur n'est même jamais invoquée pour ces 4 tabs.         |
+|                                                                           |
+|  Hyp #2 (cascade locale Léa V1 prend le relais) — INFIRMÉE                |
+|    Le client n'a pas reçu d'action → rien à résoudre localement.          |
+|                                                                           |
+|  Hyp #3 (coords brutes du record obsolètes) — INFIRMÉE                    |
+|    L'ancre `anchor_0438bd2d9bdd_1778161174` (« Notes médicales ») a       |
+|    bbox (444, 424, 146, 48) qui dans l'image de référence pointe sur      |
+|    « Imagerie » et NON Notes médicales (le crop le confirme :             |
+|    /tmp/anchor_0438bd2d9bdd_1778161174_bbox.png montre « Imagerie »).     |
+|    Pareil pour anchor_6a2591e7c51c (« Synthèse Urgences ») dont la       |
+|    bbox (580, 423, 192, 47) crop « Notes médicales ».                     |
+|    → Les bboxes des tabs sont décalées d'un cran à gauche dans la DB,    |
+|    mais ce n'est PAS la cause du blocage actuel : le mode strict + OCR-   |
+|    DIRECT ignore la bbox et part de by_text. Anomalie cosmétique à        |
+|    nettoyer hors-démo.                                                    |
+|                                                                           |
+|  Hyp #4 (offset écran live vs record) — PARTIELLEMENT VRAIE               |
+|    Voir §3.                                                                |
+|                                                                           |
+|  Hyp #5 (event onclick JS) — INFIRMÉE                                     |
+|    Voir §3.                                                                |
+|                                                                           |
+|  Hyp #6 (cache client/serveur) — INFIRMÉE                                 |
+|    Aucun `from_memory=True` dans les logs ; TargetMemoryStore pas hit.    |
+|                                                                           |
+|  Cause primaire = HTTP TIMEOUT 5 s côté client                            |
+|    + actions serveur lentes (extract_text 5-7 s, t2a_decision 10 s)       |
+|    + pas de watchdog d'orphelins dans `_retry_pending`                    |
+|                                                                           |
+|  Cause aggravante = OCR-DIRECT center-of-line bug                         |
+|    score=0.8 → coords = centre de la ligne docTR entière, pas du span.    |
++---------------------------------------------------------------------------+
+```
+
+### Mécanique exacte du timeout
+
+`agent_v0/server_v1/api_stream.py` (`get_next_action`, lignes 2816-3083) :
+1. Acquiert `_replay_lock` avec `acquire_timeout=4.5 s`. Sinon retourne `{server_busy: True}` — **OK**.
+2. Une fois le lock pris, boucle `while queue:` qui exécute toutes les actions « serveur » (`extract_text`, `extract_table`, `t2a_decision`, `pause_for_human` non bloquant) **dans le même appel HTTP**, jusqu'à tomber sur une action visuelle (`click`/`type`/`key_combo`) qu'il dispatch et retourne.
+3. `extract_text` est wrappé dans `loop.run_in_executor(...)` (timeout 180 s) pour ne pas bloquer l'event loop FastAPI — bon design.
+4. **Mais le client appelle ce endpoint avec `timeout=5` (executor.py:1786).** Si la chaîne `extract_text + dispatch_click` prend plus de 5 s, la réponse arrive après que le client ait fermé sa socket. La réponse contient le `click` action et est perdue.
+5. Côté serveur (ligne 3209-3224), l'action est déjà *poppée* de la queue et stockée dans `_retry_pending[action_id]` au moment du dispatch. Pas de retry automatique tant que le client ne renvoie pas un report (qui ne viendra pas).
+6. Le client repasse en `_replay_active=False` (`main.py:331`) — *cosmétique* — puis continue de poller. Au poll suivant, la queue est passée à l'action suivante (`extract_text`), idem boucle.
+
+**Aucun watchdog ne ré-énonce `_retry_pending` au client.** L'unique chemin pour récupérer une action perdue serait que le client envoie un report avec `success=False` (jamais le cas ici puisqu'il n'a pas reçu l'action).
+
+### Mécanique exacte de l'OCR-DIRECT center-of-line
+
+`agent_v0/server_v1/resolve_engine.py:1447-1527` :
+
+```python
+# Match exact > contient > mot par mot
+score = 0.0
+if target_lower == line_lower:           score = 1.0
+elif target_lower in line_lower:          score = 0.8
+elif any(target_lower == w.value.lower() for w in line_obj.words):  score = 0.9
+
+if score > best_score:
+    box = line_obj.geometry  # bbox de la LIGNE ENTIÈRE
+    cx = (box[0][0] + box[1][0]) / 2
+    cy = (box[0][1] + box[1][1]) / 2
+```
+
+Quand docTR voit la barre de tabs Easily comme **une seule ligne** : `"Motif d'admission Examens cliniques Imagerie Notes médicales Synthèse Urgences Codage >"`, il retourne pour CHAQUE `target` qui est un sous-fragment de cette ligne **le centre de la rangée entière** (~50 % en x, ~28 % en y). Les coords ne dépendent pas du tab demandé.
+
+Preuve archivée dans les logs e2e_singleshot du 8 mai à 09:58 (single screenshot, donc résultats reproductibles) :
+- `'Imagerie'` → `(0.2305, 0.2805)` score 0.8
+- `'Notes médicales'` → `(0.2285, 0.2805)` score 0.8
+- `'Synthèse Urgences'` → `(0.2285, 0.2805)` score 0.8
+- (delta ~5 px, trois tabs visuellement à 4-5 cm d'écart les uns des autres)
+
+→ Si le client avait reçu les 4 actions, il aurait cliqué 4 fois quasiment au même endroit (vers Imagerie). Bug latent indépendant du timeout.
+
+---
+
+## 3. Vérification des hypothèses 4 et 5
+
+### Hyp #4 — offset écran live vs record
+
+Géométrie réelle du rendu Easily Assure dans une fenêtre Edge fullscreen 2560×1600 :
+- Edge title bar : ~40 px (offset_y de la fenêtre = 49 d'après le log « Grounding contraint à la fenêtre : 2560x1490 (0, 49) »)
+- Edge tabs/URL/bookmarks : ~250 px
+- `.app-header` Easily (bleu) : 36 px (padding 8 + font 18)
+- `.menu-bar` (Patients/Planning/...) : 32 px
+- `.patient-banner` (IPP MOREL...) : ~50 px
+- `.tabs` (Motif/Examens/...) : 36 px (height CSS) → **y range ≈ 410-450 dans l'image 2560x1600**
+
+Le crop de référence (ancre `anchor_0438bd2d9bdd_1778161174`) à y=420-480 montre exactement la rangée de tabs (cf. `/tmp/tabs_row_full.png`). Pas d'offset majeur entre record et live. Une éventuelle dérive ±10-30 px est gérable par un click au pixel central.
+
+→ **Hypothèse 4 partiellement vraie** : il y a effectivement un offset, mais il n'est pas la cause du bug. Et il est dégradé par le bug OCR-DIRECT center-of-line (cause #2) puisque le centre de la ligne tombe au milieu de la barre, pas sur le tab demandé.
+
+### Hyp #5 — event onclick JS de la maquette
+
+`docs/clients/ght_sud_95/mockup_easily_assure/dossier.html:36-43` :
+
+```html
+<div class="tabs">
+    <a class="tab active" data-tab="motif">Motif d'admission</a>
+    <a class="tab" data-tab="examens">Examens cliniques</a>
+    <a class="tab" data-tab="imagerie">Imagerie</a>
+    <a class="tab" data-tab="notes">Notes médicales</a>
+    <a class="tab" data-tab="synthese">Synthèse Urgences</a>
+    <a class="tab" id="tab-vers-codage" href="codage.html">Codage &gt;</a>
+</div>
+```
+
+`app.js:377-401` :
+
+```js
+function installTabs() {
+    const tabs = document.querySelectorAll('.tabs .tab[data-tab]');
+    tabs.forEach(tab => {
+        tab.addEventListener('click', () => {
+            const target = tab.getAttribute('data-tab');
+            history.replaceState(null, '', '#' + target + location.search);
+            activate(target);
+            window.scrollTo(0, 0);
+        });
+    });
+}
+```
+
+→ Mécanisme propre. `addEventListener('click')` directement sur les `<a class="tab">`. Aucun overlay, aucun event swallow. Un MouseEvent (Win32 SendInput → Windows Edge → DOM) sur le pixel d'un tab DÉCLENCHE le listener. Le tab `Codage` est un lien `href="codage.html"` → navigation native. Aucun problème côté maquette.
+
+→ **Hypothèse 5 infirmée**.
+
+---
+
+## 4. Reproduction en isolation
+
+Données déjà disponibles via le test e2e_singleshot du 8 mai 09:58 (`session=e2e_singleshot_1778227119_1fe686`), qui appelle `/resolve_target` sur un screenshot fixe (probablement l'onglet Imagerie ouvert) :
+
+| target_spec.by_text          | Résolution            | x_pct  | y_pct  | score |
+|------------------------------|-----------------------|--------|--------|-------|
+| `25003284`                   | hybrid_text_direct    | 0.0312 | 0.3539 | 1.00  |
+| `Examens cliniques`          | hybrid_text_direct    | 0.0610 | 0.3195 | 1.00  |
+| `Imagerie`                   | hybrid_text_direct    | 0.2305 | 0.2805 | 0.80  |
+| `Notes médicales`            | hybrid_text_direct    | 0.2285 | 0.2805 | 0.80  |
+| `Synthèse Urgences`          | hybrid_text_direct    | 0.2285 | 0.2805 | 0.80  |
+| `Codage`                     | hybrid_text_direct    | 0.1279 | 0.1641 | 0.80  |
+| `Coller ou saisir le dossier patient` | hybrid_text_direct | 0.0630 | 0.4125 | 1.00 |
+| `Justification de la décision`| template_matching     | 0.5000 | 0.5000 | 1.00  |
+
+→ Reproduction confirmée : trois tabs (Imagerie / Notes / Synthèse) renvoyés à coords pratiquement identiques. Le test du 10:01 (1920x1080) reproduit la même chose : `Notes médicales` → (0.2227, 0.1259), `Imagerie` → (0.2256, 0.1267), même row.
+
+Pour reproduire en CLI sans flask :
+```bash
+cd /home/dom/ai/rpa_vision_v3 && source .venv/bin/activate
+python -c "
+from agent_v0.server_v1.resolve_engine import _resolve_by_ocr_text
+img='/home/dom/ai/rpa_vision_v3/visual_workflow_builder/backend/data/anchors/anchor_0438bd2d9bdd_1778161174_full.png'
+for t in ['Imagerie','Notes médicales','Synthèse Urgences','Codage','Examens cliniques']:
+    r = _resolve_by_ocr_text(img, t, 2560, 1600)
+    print(f'{t:25s} -> {r}')
+"
+```
+
+Ce smoke test (offline, ~30 s la 1re fois pour télécharger le modèle docTR) prouve la cause #2 sans dépendre du PC Windows.
+
+---
+
+## 5. Trois correctifs proposés (sans appliquer)
+
+### Quick fix démo (5–10 min) — **passer le client en `timeout=30` pour `/replay/next`**
+
+Fichier : `agent_v1/core/executor.py:1786` côté Windows.
+
+Changer :
+```python
+timeout=5,
+```
+en :
+```python
+timeout=30,
+```
+
+Justification : la borne dure côté serveur est déjà 180 s par action serveur ; le serveur retourne aussi `server_busy=True` au plus tard à 4.5 s. Un timeout client à 30 s laisse passer un `extract_text` de 5-10 s + dispatch d'un click sans couper la connexion. Pas d'effet de bord majeur — au pire le client attend 30 s en cas de mort serveur, déjà couvert par la backoff.
+
+**Effet** :
+- Le client ne loupera plus aucun click même si extract_text/t2a_decision est devant.
+- Le bug OCR-DIRECT center-of-line reste, mais `Examens cliniques` (score 1.0) et `Codage` (autre ligne) seront correctement résolus → la maquette aiva-vision finira par s'afficher.
+- Imagerie/Notes/Synthèse cliqueront tous les trois sur le centre de la rangée (en pratique au-dessus d'Imagerie). C'est cosmétiquement faux mais **t_imagerie/t_notes/t_synthese seront tous identiques** ; il faut prévenir Amina qu'on n'aura qu'une seule lecture du DPI multi-onglets.
+
+**Risque** : très bas. Modifier un seul littéral. Redéploiement SSH du fichier executor.py.
+
+### Quick fix démo bis (10–15 min) — **boost OCR-DIRECT pour ne renvoyer que le centre du span matché**
+
+Fichier : `agent_v0/server_v1/resolve_engine.py:1486-1519`.
+
+Idée : quand le score est 0.8 (substring match) ou 0.9 (mot exact dans la ligne), recalculer `cx, cy` à partir des **bboxes des words** qui composent le `target_text`, pas de la ligne entière.
+
+Pseudo-patch (à appliquer après-démo) :
+```python
+elif target_lower in line_lower:
+    score = 0.8
+    # Recalculer la bbox du span uniquement
+    matched_words = [w for w in line_obj.words if w.value.lower() in target_lower]
+    if matched_words:
+        xs = [pt[0] for w in matched_words for pt in w.geometry]
+        ys = [pt[1] for w in matched_words for pt in w.geometry]
+        cx = (min(xs) + max(xs)) / 2
+        cy = (min(ys) + max(ys)) / 2
+```
+
+**Effet** : chaque tab résolu à son propre centre, plus de collision.
+
+**Risque** : moyen — il faut tester avec docTR pour vérifier que les `geometry` des words sont normalisées dans le même repère que celui de la ligne. Possible que le nettoyage du substring matching soit tordu par les accents/casse. À NE PAS appliquer à la chaude pour la démo, mais pour le runner 2.
+
+> **Combo conseillé pour la démo** : appliquer SEULEMENT le fix #1 (timeout 30 s). Le bug center-of-line tab fait que t_imagerie/t_notes/t_synthese seront tous = même contenu (Imagerie). Si Amina utilise déjà `t_imagerie ∪ t_notes ∪ t_synthese` dans le prompt T2A, ça reste exploitable (juste moins de variété). Le clic Codage > marchera (autre ligne docTR).
+
+### Fix moyen terme (30–60 min) — **watchdog `_retry_pending` côté serveur**
+
+Ajout d'une boucle background dans `api_stream.py` qui scanne `_retry_pending` toutes les 10 s et :
+- Si une action a été dispatchée il y a > 30 s sans `REPORT` → la repush en tête de queue (avec un `_resent=True` flag pour stats).
+- Émission `[BUS] lea:dispatch_orphan_resent`.
+
+Justification : aujourd'hui une action perdue (timeout, kill client, déconnexion réseau) est perdue silencieusement. C'est un trou de fiabilité indépendamment de la démo GHT. Le watchdog garantit la reprise sans intervention manuelle.
+
+**Risque** : moyen — il faut bien gérer la concurrence avec le client qui pourrait finalement renvoyer le report tardivement. Idempotence des reports déjà gérée dans `report_action_result` (line 3356 : `_retry_pending.pop(action_id)`), donc resend = réponse éventuelle ignorée.
+
+### Fix structurel (post-démo, refonte) — **Server-Sent Events (SSE) ou WebSocket pour le push d'actions**
+
+Le pattern « pull avec long poll 5 s » est intrinsèquement fragile dès que les étapes serveur sont imprévisibles. Solutions architecturales :
+
+1. **SSE** (`text/event-stream`) : connexion persistante, le serveur push chaque action quand prête. Pas de timeout client à régler. Reconnexion automatique gérée nativement par EventSource. Plus simple à implémenter que WebSocket en FastAPI.
+2. **WebSocket** : full duplex, idéal pour heartbeat + actions + monitoring. Plus de code mais futur-proof.
+3. **HTTP/2 server push + chunked responses** : entre les deux. Pas standard côté requests Python.
+
+Bénéfices :
+- Suppression du bug timeout pour de bon.
+- `_retry_pending` devient quasi inutile (push ack-based).
+- Réduction du trafic (pas de poll inutile ~1/s).
+- Détection immédiate de déconnexion client → déclenche pause supervisée serveur.
+
+Coût : 1-2 jours dev + tests E2E.
+
+---
+
+## 6. Notes annexes (à nettoyer hors démo)
+
+1. **Anomalie d'ancrage DB** : les ancres `anchor_0438bd2d9bdd_1778161174` (Notes médicales label) et `anchor_6a2591e7c51c_1778229076` (Synthèse Urgences label) ont des bboxes pointant un cran à gauche du tab nommé. Ce n'est pas la cause du bug (mode strict + OCR-DIRECT bypass la bbox) mais c'est trompeur en debug. À reposer en VWB record session post-démo.
+
+2. **`target_text` mal-OCRisé en DB** : le champ `target_text` de l'ancre Notes médicales contient `"ine Né(e) le 14/03/1947 I 77 ans es Imagerie Notes médical J scan, echograj phie"`. C'est un OCR brut de la zone capturée — utile en debug, à ne pas confondre avec un identifiant fiable.
+
+3. **Pré-check OCR post-cascade désactivé** (`RPA_ENABLE_TEXT_PRECHECK=false`) : pour la démo c'est OK. Mais à activer post-démo car il aurait peut-être attrapé le cas (clic sur centre de rangée = OCR autour ne voit pas exactement le by_text demandé). À recalibrer (radius_px et min_token_ratio) pour ne pas faux-rejeter sur les tabs à 2 tokens.
+
+4. **Pas de `RESOLVE_ENTRY` dans les logs serveur du replay live pour les tabs perdus** : confirme que `/resolve_target` n'est PAS appelé tant que le client n'a pas reçu l'action. Aucun chemin caché côté serveur.
+
+5. **Concurrence de polls vue à 10:26:27** : deux DISPATCHes en 0.6 s pour 2 polls quasi-simultanés. C'est cohérent avec deux requêtes en attente sur l'acquire lock + une qui retourne `server_busy` puis une qui acquiert. Le bug fundamental reste le timeout client trop court, pas la concurrence.
+
+---
+
+## Synthèse (≤ 400 mots)
+
+Le replay s'est bloqué non pas à cause d'un échec de résolution visuelle, mais à cause d'une **désynchronisation client-serveur silencieuse**.
+
+À 10:25:48, le client Léa Windows a cliqué avec succès « Examens cliniques » et reporté `success=True`. Cinq secondes plus tard (10:25:53.771), il poste un nouveau `GET /replay/next` qui timeout à 5 s — parce que côté serveur l'appel commence par `extract_text` (~5–7 s pour récupérer `t_examens` 1689 chars) puis dispatche le click `Imagerie`. Le serveur a déjà *poppé* l'action de la queue et stocké dans `_retry_pending`, mais la réponse HTTP arrive après que le client ait fermé sa socket. **L'action est perdue.** Aucun watchdog côté serveur ne la republie. Le client repasse en mode capture cosmétique mais continue à poller. Pendant 33 s, à chaque /next il aspire de l'action serveur (extract Imagerie, dispatch Notes — perdu, extract Notes, dispatch Synthèse — perdu, extract Synthèse, t2a_decision 10 s, dispatch Codage — perdu) jusqu'à recevoir directement step 18 (« Coller ou saisir le dossier patient ») qui n'existe que sur la maquette `codage.html`. Échec `target_not_found` → pause supervisée → l'utilisateur cancel.
+
+C'est pour ça que `t_examens`, `t_imagerie`, `t_notes`, `t_synthese` ont tous le même contenu (1689 puis 1084 chars répétés) : l'écran n'a jamais changé d'onglet ; le DPI envoyé à T2A est mutilé.
+
+Bug aggravant **indépendant** : `_resolve_by_ocr_text` (resolve_engine.py:1447) renvoie le **centre de la ligne docTR entière** quand le `target_text` est un sous-fragment (score 0.8). docTR détecte la barre de tabs comme une ligne unique → Imagerie/Notes/Synthèse renvoient tous (0.23, 0.28). Confirmé par le test e2e_singleshot du même jour à 09:58. Même si le client recevait les actions, le clic raterait la cible. Latent dès que plusieurs tokens cibles partagent la même ligne docTR.
+
+**Recommandation démo** : passer le `read_timeout` client de 5 s à 30 s (`agent_v1/core/executor.py:1786`). Quick win, zéro risque, suffit pour que le pipeline aboutisse à `codage.html` et que la maquette aiva-vision se remplisse. Accepter pour la démo que les 3 tabs Imagerie/Notes/Synthèse cliqueront tous au centre de la rangée (le DPI multi-onglets sera dégradé mais le t2a_decision restera exploitable car `t_motif` et `t_motif_bas` portent l'essentiel du diagnostic).
+
+**Priorité post-démo** : (1) watchdog `_retry_pending`, (2) fix OCR-DIRECT center-of-span, (3) refonte SSE/WebSocket.

docs/UX_PAUSE_BUBBLES_FIX_2026-05-08.md

@@ -0,0 +1,174 @@
+# UX Fix — bulle pause Léa (1 affichage, scroll, boutons fonctionnels)
+
+**Date** : 2026-05-08 (matin, J démo GHT Sud 95)
+**Branche** : `feature/qw-suite-mai`
+**Périmètre** : `agent_v0/agent_v1/` uniquement (client Windows). Pas de modif serveur, pas de modif VWB.
+
+## 1. Constat utilisateur
+
+Verbatim Dom (chat avant démo) :
+
+> "Pour le thinker, il y en a 3 maintenant ! un en haut à droite de l'écran, l'autre dans le chat (qui n'a pas de scroll donc message tronqué) puis dans le vwb. Je précise également que les boutons annulé sur toutes les questions ne fonctionnent pas !"
+
+Quatre bugs UX simultanés au déclenchement d'un `pause_for_human` :
+
+1. **Trois affichages parallèles** — toast Tkinter `paused_toast` en haut à droite, bulle dans la fenêtre chat Tkinter, popup PauseDialog dans le frontend VWB React.
+2. **Message tronqué dans la bulle chat** — pas de scroll interne, donc un `pause_message` long (>200 chars, fréquent côté serveur) déborde de la fenêtre.
+3. **Bouton "Annuler" inopérant** — clic sans effet visuel.
+4. **Bouton "Continuer" sans feedback** — pas de plainte explicite mais aucune confirmation visuelle après clic.
+
+## 2. Diagnostic technique
+
+### Bug 1 — 3 toasts paused_toast en parallèle
+
+`grep -rn "show_paused_toast" agent_v0/agent_v1/` a remonté **trois call sites** qui se déclenchent en cascade pour la même pause :
+
+| # | Fichier | Ligne | Contexte |
+|---|---|---|---|
+| (a) | `core/executor.py` | 1831 | Plan B polling — `replay_paused=True` détecté |
+| (b) | `ui/chat_window.py` | 860 | `_add_paused_bubble` appelait aussi le toast en complément |
+| (c) | `ui/notifications.py` | 156 | `notify_message(BLOCAGE)` déclenché en parallèle par `executor` (mécanisme legacy) |
+
+Chacun des trois chemins force le toast topmost ⇒ Dom voit 3 popups + 1 bulle = 4 éléments UI. Confirmé dans `agent_debug.log` Windows :
+
+```
+2026-05-08 10:24:37,750 [paused_toast] INFO: paused_toast scheduled on existing Tk root
+2026-05-08 10:26:45,586 [paused_toast] INFO: paused_toast scheduled on existing Tk root
+2026-05-08 10:28:46,217 [paused_toast] INFO: paused_toast scheduled on existing Tk root
+```
+
+Plus la PauseDialog du VWB côté Linux (non concernée par la démo Windows mais visible si on ouvre le navigateur).
+
+### Bug 2 — bulle non scrollable
+
+La fenêtre chat dispose déjà d'un Canvas + Scrollbar global (`_build_messages_area`, ligne 464-507). Mais `_render_paused_bubble` n'appelait pas `_scroll_to_bottom()` après le `pack()`, donc une bulle insérée en bas de la zone restait potentiellement masquée. Et le contenu de la bulle (`reason`) était rendu via un `tk.Label` à `wraplength` fixe : pas de scroll interne pour les messages très longs (>300 chars).
+
+### Bug 3 — bouton "Annuler" inopérant
+
+Lecture de `_on_paused_abort` (ligne 975) :
+
+```python
+self._bus.abort_replay(replay_id)  # émet lea:replay_abort
+if self._active_paused_bubble:
+    self._active_paused_bubble["btn_resume"].config(state="disabled")
+    self._active_paused_bubble["btn_abort"].config(state="disabled")
+```
+
+Le bus émet bien `lea:replay_abort`. Côté serveur (`agent_chat/app.py:1720`), le handler met `execution_status["running"] = False` et émet `lea:abort_acked`. Mais :
+- `_on_lea_event` ligne 768 ignore explicitement `lea:abort_acked` (silencieux côté UI).
+- Aucun `lea:resumed` n'est émis pour un abort (ce serait sémantiquement faux).
+- Donc `_close_active_paused_bubble` n'est jamais déclenché ⇒ la bulle reste affichée avec ses boutons disabled, sans aucun message de fermeture. Pour Dom, "rien ne se passe".
+
+### Bug 4 — bouton "Continuer" sans feedback immédiat
+
+Même mécanisme : le clic émet `lea:replay_resume`, le serveur relaie en POST HTTP vers le streaming server. La fermeture de la bulle ne survient qu'à la réception ultérieure de `lea:resumed` (plusieurs secondes plus tard). Pas de feedback sur le clic lui-même.
+
+## 3. Solution implémentée
+
+### 3.1 Un seul affichage canonique : la bulle chat
+
+`core/executor.py` — Plan B simplifié :
+
+```python
+# UX fix 8 mai 2026 : un seul affichage. La bulle ChatWindow EST l'affichage
+# canonique (force show + topmost + bell sonore). Plus de paused_toast en double.
+chat_window = getattr(self, "_chat_window_ref", None)
+if chat_window is not None:
+    chat_window._add_paused_bubble(payload)
+else:
+    # Fallback headless / tests : toast Tkinter custom
+    from ..ui.paused_toast import show_paused_toast
+    show_paused_toast(title=..., message=pause_msg[:300])
+```
+
+`ui/chat_window.py:_add_paused_bubble` — suppression du `show_paused_toast` en complément, remplacé par un `root.bell()` natif Tkinter + `attributes("-topmost", True)` + `lift()` pour la mise au premier plan.
+
+`ui/notifications.py:notify_message` — suppression du `show_paused_toast` BLOCAGE (devenu redondant). Plyer reste actif comme notification système Windows discrète.
+
+### 3.2 Scroll dans la bulle pour messages longs
+
+`_render_paused_bubble` — remplacement du `tk.Label` par un `tk.Text` read-only avec hauteur calculée dynamiquement (2-8 lignes selon longueur), et scrollbar interne au-delà de 280 caractères :
+
+```python
+approx_lines = max(2, min(8, (len(reason_str) // 60) + 1))
+reason_text = tk.Text(msg_frame, height=approx_lines, wrap=tk.WORD, ...)
+reason_text.insert("1.0", reason_str)
+reason_text.configure(state="disabled")
+if len(reason_str) > 280:
+    reason_scroll = tk.Scrollbar(msg_frame, command=reason_text.yview, ...)
+    reason_text.configure(yscrollcommand=reason_scroll.set)
+```
+
+Ajout d'un appel `self._scroll_to_bottom()` à la fin de `_render_paused_bubble` ET de `_render_action_bubble` pour que la bulle apparaisse toujours dans la zone visible.
+
+### 3.3 Fermeture immédiate sur Annuler + feedback visuel
+
+`_on_paused_abort` :
+
+```python
+emitted = self._bus.abort_replay(replay_id) if (self._bus and self._bus.connected) else False
+self._disable_paused_buttons()
+self._update_paused_feedback("✗ Annulé" if emitted else "✗ Annulé (bus indisponible)")
+self._close_active_paused_bubble(reason="abort_local")  # NEW : fermeture locale immédiate
+```
+
+`_on_paused_resume` : même structure avec feedback `"→ Reprise demandée…"`. La bulle reste visible avec boutons disabled jusqu'à réception de `lea:resumed` qui déclenche `_close_active_paused_bubble("lea:resumed")`.
+
+Helpers ajoutés : `_disable_paused_buttons()` et `_update_paused_feedback(text)`. Un `feedback_label` (label vide) est intégré dans la bulle au render et mis à jour à chaque clic.
+
+## 4. Test isolé
+
+Script ajouté : `agent_v0/agent_v1/tools/test_lea_pause_flow.py` (déployé `C:\rpa_vision\agent_v1\tools\`).
+
+Commande exacte sur le PC Windows :
+
+```cmd
+cd C:\rpa_vision
+.venv\Scripts\python.exe -m agent_v1.tools.test_lea_pause_flow
+```
+
+Le script ouvre une ChatWindow, simule un `paused_need_help` avec un message de 350 chars (« Je n'arrive pas à trouver le champ Numéro de dossier patient... »), et garde la fenêtre ouverte 30s pour validation visuelle. Vérifications attendues :
+
+1. **UN SEUL popup** (la bulle chat dans la fenêtre Léa, pas de toast Tkinter en plus).
+2. Message long visible avec scroll interne si débordement.
+3. Boutons Continuer / Annuler fonctionnels.
+4. Clic Annuler ⇒ bulle fermée + feedback `✗ Annulé`.
+
+## 5. Tests automatisés exécutés
+
+```bash
+$ pytest tests/unit/test_lea_notifications.py
+101 passed in 0.69s
+
+$ pytest tests/integration/test_chat_window_templates.py tests/integration/test_feedback_bus_client.py
+35 passed
+```
+
+Aucune régression. Les tests existants vérifient `notify_message(BLOCAGE)` retourne True — le retour reste True via `notify(...)` (le toast en complément a juste été retiré).
+
+## 6. Déploiement Windows
+
+| Fichier | MD5 Linux | MD5 Windows | Match |
+|---|---|---|---|
+| `agent_v1/ui/chat_window.py` | `50597f1f7531ab8e15fdc91e3a03e98a` | identique | OK |
+| `agent_v1/ui/notifications.py` | `8382ce3cbbc819af0e1a25fc708a0596` | identique | OK |
+| `agent_v1/core/executor.py` | `dfec3a9da28ef44019fd705404d670a5` | identique | OK |
+| `agent_v1/tools/test_lea_pause_flow.py` | `edd66b613430d10e1fce8c50f478c90c` | identique | OK |
+
+Cache `__pycache__` purgé sur Windows :
+
+```powershell
+Get-ChildItem -Recurse -Path C:\rpa_vision\agent_v1 -Include *.pyc | Remove-Item -Force
+Get-ChildItem -Recurse -Path C:\rpa_vision\agent_v1 -Include __pycache__ -Directory | Remove-Item -Recurse -Force
+```
+
+**Action restante avant démo** : redémarrer l'agent Léa V1 sur le PC Windows (le client doit recharger les modules). Procédure standard : tray icon Léa → Quitter, puis `Win+R` → `C:\rpa_vision\start_lea.cmd` (ou équivalent dans la doc reference_windows_pc.md).
+
+## 7. Synthèse fichiers modifiés
+
+- `agent_v0/agent_v1/ui/chat_window.py` : `_add_paused_bubble`, `_render_paused_bubble`, `_on_paused_resume`, `_on_paused_abort` + helpers `_disable_paused_buttons`, `_update_paused_feedback`. Auto-scroll ajouté à `_render_action_bubble` aussi.
+- `agent_v0/agent_v1/ui/notifications.py` : `notify_message` — suppression du déclenchement `show_paused_toast` BLOCAGE.
+- `agent_v0/agent_v1/core/executor.py` : Plan B polling — suppression du `show_paused_toast` direct, remplacé par fallback uniquement si `_chat_window_ref` est None.
+- `agent_v0/agent_v1/tools/test_lea_pause_flow.py` : nouveau script de smoke test.
+
+Aucun fichier serveur ni VWB modifié. Conforme `feedback_agent_frozen.md` (modif client validée par Dom ce matin).

docs/handoffs/2026-05-08_session_audit.md

@@ -0,0 +1,64 @@
+# HANDOFF — Session 2026-05-08 (clôture)
+
+## 1. ÉTAT FACTUEL DU REPO
+- Branche : feature/qw-suite-mai
+- 3 commits du jour (les plus récents en HEAD) :
+  - 626823d32 docs(bug): pré-check OCR spatialement aveugle
+  - 2e76b44ff feat(observability): log positif pré-check OCR
+  - 731b5bcae fix(replay): réactivation pré-check OCR
+- Pas de push (tous commits locaux)
+- Working directory : modifications antérieures intactes
+  (à traiter dans une autre session, hors scope aujourd'hui)
+
+## 2. DÉCISIONS PRISES CETTE SESSION
+- Réactivation pré-check OCR avec calibrage radius_px=280,
+  min_token_ratio=0.50 (validé Dom)
+- Démo interne reportée (validé Dom le matin)
+- Migration vLLM reportée à demain matin (validé Dom)
+- Bug spatial pré-check : reporté post-démo Kerella,
+  Option B préférée (validé Dom)
+- 4 contrôles débranchés sur 5 laissés en l'état pour aujourd'hui
+  (audit AUDIT_CONTROLES_DEBRANCHES disponible)
+
+## 3. PROBLÈMES OUVERTS
+- [P0] Bug d'échelle pixel grounding (Ollama smart_resize
+  non-déterministe) — fix prévu demain matin via vLLM +
+  resized_width/height explicite
+- [P1] Bug pré-check OCR spatialement aveugle — documenté,
+  reporté post-démo Kerella
+- [P2] 4 contrôles débranchés à réévaluer un par un
+  (SoM, mémoire visuelle, exemptions drift)
+- [P3] Démo Kerella à préparer (date à confirmer)
+
+## 4. PROCHAINE ACTION CONCRÈTE (demain matin)
+Action unique : appliquer le fix smart_resize au payload vLLM
+selon docs/MIGRATION_VLM_PLAN_2026-05-09.md
+
+Critère de succès : workflow rpa complet sur 1 dossier MOREL
+sans clic aberrant, latence acceptable.
+
+## 5. CE QUE LE PROCHAIN CLAUDE DOIT LIRE
+- @docs/handoffs/2026-05-08_session_audit.md (ce fichier)
+- @docs/MIGRATION_VLM_PLAN_2026-05-09.md (plan de demain)
+- @docs/HISTORIQUE_VLM_IMPLEMENTATIONS_2026-05-08.md
+  (vLLM + Transformers déjà câblés, ne pas réinventer)
+- @docs/CARTE_FONCTIONNELLE_2026-05-08.md (focus sections [À VÉRIFIER])
+- @docs/AUDIT_CONTROLES_DEBRANCHES_2026-05-08.md (les 4 autres
+  contrôles à traiter plus tard)
+- @docs/BUG_PRECHECK_SPATIAL_BLINDNESS_2026-05-08.md
+  (dette identifiée ce soir)
+
+NE PAS LIRE :
+- recall.md (à archiver post-démo, obsolète)
+- MEMORY.md (saturé, à refondre post-démo)
+- ANALYSE_MOAT_RPA_VISION_V3.md / PITCH_INVESTISSEURS_*.md
+  (déplacés vers archive/business_docs/)
+
+## 6. RÈGLES DE LA JOURNÉE À RESPECTER DEMAIN
+- "Il faut prendre le temps d'aller vite" (maxime Dom)
+- "Rustine interdite" (maxime Dom)
+- "On lit la doc avant de faire quoi que ce soit" (maxime Dom)
+- Git destructeur : jamais en combo, atomique, validation explicite
+- Un commit = une intention
+- Datage : forcer `date '+%Y-%m-%d %H:%M %Z'` avant tout commentaire daté
+- Désactivation contrôle : flag env + log WARNING + entrée dette + revue +14j

docs/handoffs/2026-05-09_session_audit.md

@@ -0,0 +1,168 @@
+# HANDOFF — Session 2026-05-09 (clôture)
+
+Rédigé le 2026-05-09 15:46 CEST.
+
+## 1. ÉTAT FACTUEL DU REPO
+
+- Branche : `feature/qw-suite-mai`
+- 10 commits du jour (les plus récents en HEAD) :
+  - `df5ad5933` docs(dette): MAJ DETTE-010 (config trouvé, divergences) + création DETTE-014 (smart_resize calé sur mauvaise référence)
+  - `bfbf0f9c3` refactor(grounding): centralise parser bbox_2d
+  - `ecc5a233a` docs(dette): création DETTE-013 env tests dev local
+  - `4df1ba577` docs(dette): création DETTE-011 bug cv2 Python 3.12
+  - `0d7bcd18a` feat(grounding): module smart_resize officiel Qwen3-VL
+  - `e9702b4df` docs(dette): création DETTE-010 vérif preprocessor_config Qwen3-VL
+  - `293e54b4e` docs(dette): création DETTE-012 (vLLM hors scope) + maj DETTE-010 (cible Transformers + AWQ)
+  - `e0b47e451` docs(refs): commit groupé docs de référence session 2026-05-08
+  - `5dc20cc85` docs(dette): rectif mapping DETTE-005 + DETTE-008/009 + investigation mémoire visuelle orpheline
+  - `88ed103de` docs(dette): création registre dette technique + 7 entrées rétroactives
+- Pas de push (tous commits locaux)
+- Working directory : modifications antérieures intactes
+  (héritées du handoff 2026-05-08, hors scope cette session)
+- Checkpoint Qwen3-VL-8B-Instruct fp16 téléchargé localement
+  (`~/.cache/huggingface/hub/models--Qwen--Qwen3-VL-8B-Instruct/`,
+  17 GB, 16/16 fichiers, 0 `.incomplete`)
+- Total : 2 modules purs créés (smart_resize, bbox_parser) + 100%
+  coverage (58 tests unitaires) + registre dette créé avec 14
+  entrées + −96 lignes nettes sur resolve_engine.py.
+
+## 2. DÉCISIONS PRISES CETTE SESSION
+
+- **Cible backend grounding** : Transformers direct (pas vLLM —
+  vLLM absent de la machine, infra inexistante, cf. DETTE-012).
+  Cohérent avec `core/grounding/server.py` déjà câblé en
+  Transformers et service systemd `rpa-grounding.service`.
+- **Modèle cible** : `Qwen/Qwen3-VL-8B-Instruct` fp16 (16 GB safetensors)
+  + chargement Transformers avec `BitsAndBytesConfig(load_in_4bit=True,
+  bnb_4bit_quant_type="nf4")` à la volée (~5-6 GB VRAM runtime).
+  Pas d'AWQ officiel disponible pour Qwen3-VL-8B
+  (`Qwen/Qwen3-VL-8B-Instruct-AWQ` → 404 HF, repo inexistant).
+- **T2A v2 désactivé** durant la session pour libérer la VRAM
+  partagée du RTX 5070 (12 GB).
+- **Strict no-op sémantique sur le refactor parser bbox_2d**
+  (commit 2/5 `bfbf0f9c3`) : préservation des contrats sémantiques
+  des 3 sites d'appel via paramètre `formats=` (pas seulement
+  préservation comportementale).
+- **Investigation DETTE-010 en fin de journée a révélé une
+  divergence majeure** : `factor` effectif probable 32 (vs 28
+  hypothèse matin) car `patch_size=16` dans le `preprocessor_config.json`
+  du checkpoint Qwen3-VL-8B-Instruct ; convention
+  `size.longest_edge`/`shortest_edge` différente de `min_pixels`/`max_pixels`.
+  → Arrêt avant commit 3/5 du fix DETTE-006 pour reprendre demain
+  matin frais avec investigation propre, plutôt que coder à
+  l'aveugle sur fin de journée.
+
+## 3. PROBLÈMES OUVERTS (par criticité)
+
+- **[P0] DETTE-006 — Bug d'échelle pixel grounding**
+  fix en cours, 2/5 commits faits (smart_resize + refactor parser),
+  3/5 bloqués par DETTE-010 + DETTE-014 (alignement convention
+  Qwen3-VL effective).
+- **[P1] DETTE-010 IN_PROGRESS** — investigation
+  `Qwen2VLImageProcessorFast` + sémantique `longest_edge`/`shortest_edge`
+  + `patch_size=16` requise demain matin. Bloquant Étape 2
+  (validation grounding isolée). Date revue : 2026-05-10.
+- **[P1] DETTE-014 OPEN** — module `core/grounding/smart_resize.py`
+  calé sur `Qwen2VLImageProcessor` (factor=28, max=1_003_520) alors
+  que le checkpoint utilise `Qwen2VLImageProcessorFast` avec
+  `patch_size=16` (factor probable 32). À réaligner après DETTE-010.
+- **[P2] Autres dettes (P2/P3)** listées dans
+  `docs/DETTE_TECHNIQUE.md` (DETTE-001 à 014) — pas urgent, revues
+  par défaut +14 jours sauf P1 listées ci-dessus.
+
+## 4. PROCHAINE ACTION CONCRÈTE (demain matin)
+
+- **Étape A** : lire
+  `transformers.models.qwen2_vl.image_processing_qwen2_vl_fast`
+  pour comprendre les défauts effectifs (`min_pixels`, `max_pixels`,
+  interaction `patch_size × merge_size` → `factor`) et la sémantique
+  de `size.longest_edge`/`shortest_edge` (côté max ou produit total ?).
+- **Étape B** : tester le chargement runtime via
+  `AutoProcessor.from_pretrained('Qwen/Qwen3-VL-8B-Instruct')` puis
+  inspecter ses attributs (`processor.image_processor.size`,
+  `processor.image_processor.patch_size`, etc.) pour confirmer la
+  convention réelle au runtime.
+- **Étape C** : tirer la convention validée et décider de
+  l'ajustement de `core/grounding/smart_resize.py` :
+  - soit ajuster `FACTOR_DEFAULT` / bornes du module existant
+    (et adapter les tests),
+  - soit créer un nouveau module dédié Qwen3-VL si la sémantique
+    diverge trop (ex: `core/grounding/smart_resize_qwen3.py`).
+- **Étape D** : commit 3/5 du fix DETTE-006 avec convention validée
+  (les 4 sites de `resolve_engine.py` parseront enfin par
+  `resized_w/h` au lieu de `small_w/h`).
+- **Critère de succès Étape 2** (validation grounding isolée) :
+  sur fixture `data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773792436.png`
+  (2560×1600), bouton OK localisé à `cx ≈ 0.45-0.55` (vs 0.17 le 8 mai).
+- **Critère de succès Étape 3** (replay e2e) : workflow rpa complet
+  sur 1 dossier MOREL sans clic aberrant, latence acceptable.
+
+## 5. CE QUE LE PROCHAIN CLAUDE DOIT LIRE (ordre)
+
+- @docs/handoffs/2026-05-09_session_audit.md (ce fichier)
+- @docs/DETTE_TECHNIQUE.md (en particulier DETTE-010 et DETTE-014, P1 bloquants)
+- @/home/dom/.cache/huggingface/hub/models--Qwen--Qwen3-VL-8B-Instruct/snapshots/0c351dd01ed87e9c1b53cbc748cba10e6187ff3b/preprocessor_config.json
+  (config réel du checkpoint, pivot pour DETTE-010)
+- @core/grounding/smart_resize.py (module à éventuellement réaligner)
+- @core/grounding/bbox_parser.py (commit 2/5 OK strict no-op, à conserver)
+- @docs/MIGRATION_VLM_PLAN_2026-05-09.md (plan original toujours
+  valide pour la suite, mais cible backend ajustée :
+  Transformers direct, pas vLLM)
+- @docs/handoffs/2026-05-08_session_audit.md (handoff veille,
+  pour contexte si besoin)
+
+## 6. RÈGLES DE LA JOURNÉE À RESPECTER DEMAIN
+
+- Maximes Dom : « il faut prendre le temps d'aller vite »,
+  « rustine interdite », « on lit la doc avant de faire quoi que ce soit ».
+- **Investigation infra** : ne jamais conclure à l'absence d'un
+  composant sans avoir vérifié N endroits possibles
+  (PATH, autres venvs, conda, Docker, système, autres caches).
+  Leçon DETTE-012 vLLM : conclusion hâtive « stack vLLM absente »
+  sur fouille partielle, rectifié par Dom. Présenter les
+  vérifications négatives comme partielles et demander
+  confirmation, pas comme une absence définitive.
+- **Refactor de code mature** : préserver les contrats sémantiques
+  en plus des comportements techniques. Leçon refactor parser
+  Occ 3 + Occ 4 : strict no-op via paramètre `formats=` plutôt
+  que centralisation laxe qui élargit silencieusement les formats
+  acceptés.
+- **Validation explicite par étape**, stop pour relecture diff
+  sur tout code prod. Pas d'enchaînement A→B→C sans GO entre les
+  étapes structurantes.
+- **Datage** : forcer `date '+%Y-%m-%d %H:%M %Z'` avant tout
+  commentaire daté.
+- **Désactivation contrôle** : flag env + log WARNING + entrée
+  dette + revue +14j (et registre central
+  `docs/DETTE_TECHNIQUE.md`).
+- **Git destructeur** : jamais en combo, atomique, validation
+  explicite.
+- **Un commit = une intention** (respecté sur les 10 commits du jour).
+
+## 7. NOTES POUR LA PROCHAINE SESSION
+
+- **Action pré-prochaine session — hygiène git** : commit
+  `chore(docs): déplacement business_docs vers archive/`
+  pour consolider en 1 commit la suppression à la racine
+  (ANALYSE_MOAT_RPA_VISION_V3.md, PITCH_INVESTISSEURS_RPA_VISION_V3.md
+  → `D` dans `git status`) et l'ajout dans `archive/business_docs/`
+  (encore en `?? archive/`). Pas de DETTE associée, juste hygiène.
+- **Mécanisme de délestage VRAM rpa_v3** : à documenter dans le
+  module concerné (path à retrouver), trace de fonctionnalité
+  transversale.
+- **Bug cv2 (DETTE-011) + env tests (DETTE-013)** : la batterie
+  `pytest tests/unit/` entière n'est pas exécutable en dev local
+  sans configuration spécifique (`RPA_API_TOKEN` ou
+  `RPA_AUTH_DISABLED` + version cv2 compatible Python 3.12).
+  Prévoir une session dédiée pour rétablir l'exécution complète
+  ou découpler les tests purs des tests qui chargent
+  `agent_v0.server_v1.api_stream`.
+- **Audit exhaustif modules orphelins** (au-delà périmètre AUDIT
+  serveur) : mentionné dans
+  `docs/INVESTIGATION_MEMOIRE_VISUELLE_ORPHELINE_2026-05-09.md` §6,
+  dette identifiée sans numéro réservé. À instruire post-démo
+  Kerella.
+- **DETTE-010 + DETTE-014 sont la première chose à débloquer
+  demain matin**. Sans cet alignement, le commit 3/5 du fix
+  DETTE-006 et l'Étape 2 (validation grounding isolée) sont
+  impossibles à instruire correctement.

docs/superpowers/specs/2026-05-05-qw-suite-mai-design.md

@@ -0,0 +1,467 @@
+# Spec — QW Suite Mai 2026
+
+| Champ | Valeur |
+|---|---|
+| Date | 2026-05-05 |
+| Auteur | Dom + Claude (brainstorming structuré) |
+| Branche | `feature/qw-suite-mai` (depuis `feature/feedback-bus`) |
+| Backup | `backup/pre-qw-suite-mai-2026-05-05` à pousser sur Gitea avant 1er commit |
+| Statut | Design approuvé — spec à valider par Dom avant `writing-plans` |
+| Cibles démo | GHT Sud 95 (1ère sem mai 2026, date à confirmer) |
+| Contraintes inviolables | 100% vision · 100% local (Ollama) · backward compatible |
+
+## 1. Contexte & motivation
+
+Suite à l'exploration comparative de 5 frameworks computer-use (Simular Agent-S, browser-use, OpenAI CUA sample, Coasty open-cu, Showlab OOTB), trois quick wins ont été identifiés comme améliorations à fort ratio valeur/risque pour RPA Vision V3, alignés avec la philosophie du projet (vision pure, souveraineté, supervision médicale) :
+
+- **QW1 — Multi-écrans propre** (inspiré OOTB) : capture et grounding sur l'écran cible plutôt que sur le composite tous écrans. Gain de perf grounding + correction des coordonnées.
+- **QW2 — LoopDetector composite** (inspiré browser-use) : détecter quand Léa exécute des actions techniquement valides mais que l'écran ne progresse pas, et escalader vers l'humain plutôt que de tourner en rond muettement.
+- **QW4 — Safety checks hybrides** (inspiré OpenAI CUA + browser-use Pydantic registry) : enrichir l'action `pause_for_human` avec une liste de vérifications à acquitter, mêlant déclaratif (workflow) et contextuel (LLM local).
+
+Effet cumulé attendu : Léa devient observable, robuste et auditable sans rien céder sur le 100% local.
+
+## 2. Décisions de design (récap)
+
+| Sujet | Décision |
+|---|---|
+| Activation | Default-ON pour tous les workflows (Dom recréera ce qui en a besoin) |
+| QW1 — Stratégie ciblage écran | `monitor_index` enregistré à la capture → fallback focus actif → fallback composite (backward) |
+| QW1 — Niveau de stack | Client Agent V1 (capture) + serveur (routeur) + `core/execution/input_handler.py` (capture locale) |
+| QW2 — Signal de boucle | Composite OR : screen_static (CLIP) + action_repeat + retry_threshold |
+| QW2 — Sortie | `replay_state["status"] = "paused_need_help"` avec `pause_reason` structuré |
+| QW4 — Source des checks | Hybride : déclaratif workflow + LLM contextuel sur `safety_level: "medical_critical"` |
+| QW4 — Robustesse LLM | `medgemma:4b` + timeout 5s + `format=json` Ollama + JSON Schema strict + fallback safe (zéro check additionnel) + kill-switch env var |
+| QW4 — UX VWB | Bulle existante préservée + `<ChecklistPanel>` au-dessus de Continuer (bouton désactivé tant que required non cochés) |
+| Ordre de livraison | QW1 → QW2 → QW4 (du moins invasif au plus visible) |
+| Plan timing | Option A : QW1+QW2 avant démo ; QW4 enchaîné dès validation des deux premiers |
+| Kill-switches | Env vars sur QW2 et QW4, surchargeables par `systemctl edit` |
+| Backward compatibility | 100% — aucun champ obligatoire ajouté au DSL ; workflows existants se comportent comme avant |
+
+## 3. Architecture globale
+
+```
+┌─────────────────────────┐         ┌─────────────────────────────────┐
+│   Agent V1 (Windows)    │         │     Serveur Streaming (5005)    │
+│                         │         │                                 │
+│  ┌──────────────────┐   │         │  ┌───────────────────────────┐  │
+│  │ ScreenCapture    │   │         │  │     LoopDetector  [QW2]   │  │
+│  │  + monitor_index │───┼────────▶│  │  • screen_static (CLIP)   │  │
+│  │     [QW1]        │   │  HTTP   │  │  • action_repeat          │  │
+│  └──────────────────┘   │         │  │  • retry_threshold        │  │
+│                         │         │  │  → paused_need_help       │  │
+│  ┌──────────────────┐   │         │  └───────────────────────────┘  │
+│  │ FeedbackBus lea:*│◀──┼─────────┤                                 │
+│  │   chat_window    │   │         │  ┌───────────────────────────┐  │
+│  └──────────────────┘   │         │  │   SafetyChecksProvider    │  │
+└─────────────────────────┘         │  │           [QW4]           │  │
+                                    │  │  • declarative (workflow) │  │
+                                    │  │  • LLM contextual         │  │
+                                    │  │    ‒ medgemma:4b 5s/JSON  │  │
+                                    │  │    ‒ fallback safe        │  │
+                                    │  │  • kill-switch env var    │  │
+                                    │  └───────────────────────────┘  │
+                                    │                                 │
+                                    │  ┌───────────────────────────┐  │
+                                    │  │ MonitorRouter   [QW1]     │  │
+                                    │  │  • cible monitor_index    │  │
+                                    │  │  • fallback focus actif   │  │
+                                    │  └───────────────────────────┘  │
+                                    └─────────────────────────────────┘
+                                                    │
+                                                    ▼
+                                    ┌─────────────────────────────────┐
+                                    │       VWB Frontend (3002)       │
+                                    │                                 │
+                                    │  PauseDialog (étendu) [QW4-UX]  │
+                                    │  • bulle existante préservée    │
+                                    │  • + ChecklistPanel             │
+                                    │    (cases à cocher acquittables)│
+                                    │  • + pause_reason si loop       │
+                                    │  Continuer désactivé tant que   │
+                                    │  required-checks non cochés     │
+                                    └─────────────────────────────────┘
+```
+
+### Principes invariants
+1. Aucun nouveau service, aucune nouvelle DB. Tout dans la stack existante (Agent V1 + serveur 5005 + VWB 3002).
+2. 3 modules serveur isolés (`monitor_router.py`, `loop_detector.py`, `safety_checks_provider.py`) — couplage faible, testables individuellement, désactivables par env var.
+3. Backward compatible : workflows sans nouveaux champs se comportent comme avant.
+4. Kill-switches env vars sur QW2 et QW4, override possible via `systemctl edit` pendant la démo.
+5. 100% vision : QW1 pure capture + grounding ; QW2 réutilise le `_clip_embedder` déjà chargé ; QW4 LLM = Ollama local strict.
+6. Bus `lea:*` étendu de 4 events d'observabilité : `lea:loop_detected`, `lea:safety_checks_generated`, `lea:safety_checks_llm_failed`, `lea:monitor_routed`.
+
+### Surface de modification (ordre A)
+
+| QW | Fichiers nouveaux | Fichiers modifiés |
+|---|---|---|
+| QW1 | `agent_v0/server_v1/monitor_router.py` | `agent_v0/agent_v1/capture/screen_capture.py`, `core/execution/input_handler.py`, `agent_v0/server_v1/api_stream.py` (~10 lignes) |
+| QW2 | `agent_v0/server_v1/loop_detector.py` | `agent_v0/server_v1/replay_engine.py` (~30 lignes), `agent_v0/server_v1/api_stream.py` (~20 lignes) |
+| QW4 | `agent_v0/server_v1/safety_checks_provider.py`, `visual_workflow_builder/frontend_v4/src/components/PauseDialog.tsx` | `agent_v0/server_v1/replay_engine.py`, `agent_v0/server_v1/api_stream.py` (`/replay/resume`), `visual_workflow_builder/frontend_v4/src/types.ts`, `visual_workflow_builder/frontend_v4/src/components/PropertiesPanel.tsx` |
+
+## 4. QW1 — Multi-écrans
+
+### 4.1 Composants
+
+**Client Agent V1** — `agent_v0/agent_v1/capture/screen_capture.py` (existant à modifier)
+- Enrichit chaque heartbeat / event avec :
+  - `monitor_index: int`
+  - `monitors_geometry: [{idx, x, y, w, h, primary}]`
+- Détection via `screeninfo` (port direct depuis Showlab OOTB)
+- Capture de l'écran *actif uniquement* (poids réseau identique à aujourd'hui)
+- Si `screeninfo` indisponible côté Windows : envoie `monitors_geometry: []`, comportement composite préservé
+
+**Serveur** — nouveau `agent_v0/server_v1/monitor_router.py` (~80 lignes)
+- API : `resolve_target_monitor(action: dict, session_state: dict) → MonitorTarget`
+- `MonitorTarget = {idx, offset_x, offset_y, w, h, source: "action" | "focus" | "composite_fallback"}`
+- Stratégie :
+  1. Lit `action.get("monitor_index")` si présent → cible cet écran
+  2. Sinon `session_state.get("last_focused_monitor")` → cible focus actif
+  3. Sinon `monitors[0]` composite (comportement actuel — backward)
+
+**Input local Linux** — `core/execution/input_handler.py` modifs ciblées
+- Signature changée : `_capture_screen(monitor_idx=None) → (image, w, h, offset_x, offset_y)`
+- Quand `monitor_idx` fourni : capture uniquement ce monitor
+- Toutes les fonctions `_grounding_*` (`_grounding_ocr`, `_grounding_ui_tars`, `_grounding_vlm`) propagent l'offset pour traduire les coords retournées en coords absolues écran
+
+### 4.2 Data flow replay
+
+```
+Action [monitor_index=1] reçue par serveur
+  → MonitorRouter.resolve()
+  → target_monitor = {idx:1, offset:(1920,0), w:1920, h:1080, source:"action"}
+  → grounding capture monitor 1 uniquement (image 1920×1080, pas 3840×1080)
+  → UI-TARS / OCR / VLM cherche cible → coords locales (640, 540)
+  → coords absolues = (640+1920, 540+0) = (2560, 540)
+  → pyautogui.click(2560, 540)
+  → bus.emit("lea:monitor_routed", {idx:1, source:"action"})
+```
+
+### 4.3 Error handling
+
+| Cas | Comportement |
+|---|---|
+| `monitor_index` absent (vieille session) | Fallback focus actif, log info `lea:monitor_routed source=focus` |
+| Monitor enregistré n'existe plus (2nd écran débranché) | Fallback focus actif, event `lea:monitor_unavailable` warning |
+| `mss.monitors[i]` hors limites | Fallback `monitors[0]` composite, event `lea:monitor_invalid_index` error |
+| `screeninfo` non installé côté Agent V1 | `monitors_geometry: []`, fallback composite (comportement actuel) — pas de blocage |
+
+### 4.4 Tests QW1
+
+- `tests/unit/test_monitor_router.py` : 4 cas (cible OK, fallback focus, fallback composite, monitor débranché)
+- `tests/integration/test_grounding_offset.py` : capture 1 monitor + clic résolu avec offset (mock pyautogui)
+- Smoke : 1 workflow Easily rejoué, vérification visuelle que le clic atterrit au bon endroit
+
+### 4.5 Compat workflows existants
+
+Aucune action n'a `monitor_index` aujourd'hui → 100% des workflows existants partent en fallback focus actif → comportement quasi-identique au composite actuel mais sur un seul écran (gain de perf grounding même sans recréation de workflow).
+
+## 5. QW2 — LoopDetector composite
+
+### 5.1 Composants
+
+**Nouveau** `agent_v0/server_v1/loop_detector.py` (~150 lignes)
+- Classe `LoopDetector` avec 3 sous-détecteurs
+- API : `evaluate(replay_state, screenshot_history, action_history) → LoopVerdict`
+- `LoopVerdict = {detected: bool, reason: str, signal: str, evidence: dict}`
+
+**Hook** dans `agent_v0/server_v1/api_stream.py`
+- Après chaque `report_action_result`, appel `loop_detector.evaluate(...)` si `RPA_LOOP_DETECTOR_ENABLED=1` (défaut)
+- Si `verdict.detected` :
+  - `replay_state["status"] = "paused_need_help"`
+  - `replay_state["pause_reason"] = verdict.reason`
+  - `replay_state["pause_message"] = f"Léa semble bloquée — {verdict.signal}"`
+  - bus.emit `lea:loop_detected` avec `{signal, evidence, replay_id}`
+
+**Étendu** dans `replay_engine.py` :
+- `_create_replay_state()` ajoute :
+  - `"_screenshot_history": []` (anneau de 5 derniers embeddings CLIP)
+  - `"_action_history": []` (anneau des 5 dernières actions)
+- `_pre_check_screen_state()` continue indépendamment (signal différent : check pré-action vs détection post-action de stagnation)
+
+### 5.2 Signaux composites
+
+| Signal | Détecteur | Seuil par défaut | Source |
+|---|---|---|---|
+| `screen_static` | A | 4 captures consécutives avec CLIP similarity > 0.99 | `_clip_embedder` déjà chargé serveur |
+| `action_repeat` | B | 3 actions consécutives identiques (type + coords) | `_action_history` |
+| `retry_threshold` | C | 3 retries sur même `action_id` | `replay_state["retried_actions"]` (déjà existant) |
+
+Un seul signal positif suffit à déclencher l'escalade.
+
+### 5.3 Data flow
+
+```
+Action exécutée → result reçu via /replay/result
+  ↓
+LoopDetector.evaluate(state, screenshots, actions) si RPA_LOOP_DETECTOR_ENABLED=1
+  ├─ A.check_screen_static() → embed(latest), compare aux N-1 derniers
+  ├─ B.check_action_repeat() → compare action_history[-3:]
+  └─ C.check_retry_threshold() → state["retried_actions"] >= 3
+  ↓
+Si verdict.detected:
+  state["status"] = "paused_need_help"
+  state["pause_reason"] = verdict.reason
+  state["pause_message"] = f"Léa semble bloquée — {verdict.signal} ({evidence})"
+  bus.emit("lea:loop_detected", {signal, evidence, replay_id})
+```
+
+### 5.4 Error handling
+
+| Cas | Comportement |
+|---|---|
+| CLIP embedder unavailable | Signal A désactivé (warning log 1×), B+C continuent. Pas de blocage. |
+| `_screenshot_history` < N | Signal A skip silencieusement (pas assez d'historique) |
+| `embed_image()` lève une exception | Catch + log warning, replay continue (verdict = `detected=False`) |
+| `RPA_LOOP_DETECTOR_ENABLED=0` | Module entier bypassé, comportement antérieur |
+| Faux positif détecté en pleine démo | `RPA_LOOP_DETECTOR_ENABLED=0` via `systemctl edit rpa-streaming` + restart → reprise immédiate |
+
+### 5.5 Configuration env vars
+
+- `RPA_LOOP_DETECTOR_ENABLED=1` (défaut)
+- `RPA_LOOP_SCREEN_STATIC_THRESHOLD=0.99`
+- `RPA_LOOP_SCREEN_STATIC_N=4`
+- `RPA_LOOP_ACTION_REPEAT_N=3`
+- `RPA_LOOP_RETRY_THRESHOLD=3`
+
+### 5.6 Tests QW2
+
+- `tests/unit/test_loop_detector.py` : 8 cas (chaque signal isolé, chaque combinaison, kill-switch, embedder absent)
+- `tests/integration/test_loop_detector_replay.py` : 3 cas — replay simulé qui boucle → vérifier transition `running → paused_need_help` avec bonne raison
+- Pas de smoke démo (impossible à reproduire fiable, on s'appuie sur les tests intégration)
+
+### 5.7 Compat VWB
+
+Aucune côté frontend pour QW2 : la pause `paused_need_help` existe déjà. Le `pause_reason` enrichi sera affiché par le composant `PauseDialog` étendu en QW4. Avant la livraison de QW4, la raison s'affichera en texte dans le `pause_message` (donc utile dès le commit QW2).
+
+## 6. QW4 — Safety checks hybrides
+
+### 6.1 Contrat de l'action étendue (rétro-compatible)
+
+```json
+{
+  "type": "pause_for_human",
+  "parameters": {
+    "message": "Validation T2A avant codage",
+    "safety_level": "medical_critical",
+    "safety_checks": [
+      {"id": "check_ipp", "label": "Vérifier IPP patient", "required": true},
+      {"id": "check_cim10", "label": "Confirmer code CIM-10", "required": true}
+    ]
+  }
+}
+```
+
+`safety_level` et `safety_checks` sont **optionnels**. Action sans ces champs → comportement actuel (bulle simple, aucun appel LLM).
+
+### 6.2 Composants serveur
+
+**Nouveau** `agent_v0/server_v1/safety_checks_provider.py` (~180 lignes)
+- API : `build_pause_payload(action, replay_state, last_screenshot) → PausePayload`
+- Concatène : checks déclaratifs (workflow) + checks contextuels (LLM si `safety_level == "medical_critical"`)
+- Chaque check porte sa source : `source: "declarative" | "llm_contextual"` et son `evidence` (vide pour déclaratif, justification courte pour LLM)
+- Format check final :
+  ```json
+  {
+    "id": "check_xxx",
+    "label": "...",
+    "required": true,
+    "source": "declarative" | "llm_contextual",
+    "evidence": null | "..."
+  }
+  ```
+
+**LLM contextual call** — sous-fonction `_call_llm_for_contextual_checks()`
+- Modèle : `medgemma:4b` (env `RPA_SAFETY_CHECKS_LLM_MODEL`)
+- Timeout dur : 5s (env `RPA_SAFETY_CHECKS_LLM_TIMEOUT_S`)
+- `format=json` natif Ollama + JSON Schema strict :
+  ```json
+  {"additional_checks": [{"label": "string", "evidence": "string"}]}
+  ```
+- Max 3 checks ajoutés (env `RPA_SAFETY_CHECKS_LLM_MAX_CHECKS`)
+- Prompt : screenshot heartbeat actuel + workflow message + liste des checks déclaratifs (évite doublons)
+- Tout échec (timeout, exception, JSON invalide post-schema) → `additional_checks = []`, event `lea:safety_checks_llm_failed`, replay continue
+
+**Hook** dans `replay_engine.py` — branche `action_type == "pause_for_human"`
+- Avant de basculer en `paused_need_help`, appel `safety_checks_provider.build_pause_payload(...)`
+- Stocke `replay_state["safety_checks"] = payload.checks`
+- Stocke `replay_state["pause_payload"] = payload` (pour debug/audit)
+
+**Modif** `api_stream.py` — endpoint `/replay/resume`
+- Reçoit `{acknowledged_check_ids: [...]}` dans le body POST
+- Vérifie : tous les checks `required=true` doivent être dans `acknowledged_check_ids`
+  - Sinon : `400 {error: "required_checks_missing", missing: [...]}`
+- Stocke `replay_state["checks_acknowledged"] = acknowledged_check_ids` (audit trail)
+- Reprise normale du replay
+
+### 6.3 Composants frontend VWB
+
+**Nouveau** `visual_workflow_builder/frontend_v4/src/components/PauseDialog.tsx` (~200 lignes)
+- Props : `pauseMessage`, `pauseReason`, `safetyChecks`, `onResume(ackIds)`, `onCancel`
+- Si `safetyChecks.length === 0` : rend la bulle existante (legacy, comportement actuel)
+- Sinon : bulle + `<ChecklistPanel>` avec checkboxes
+- Bouton Continuer disabled tant que `checks.filter(c => c.required && !checked).length > 0`
+- POST `/replay/resume` avec body `{acknowledged_check_ids: [...]}`
+- Visuel source :
+  - Badge `[Léa]` pour `source: "llm_contextual"` (avec tooltip `evidence`)
+  - Badge `[obligatoire]` pour `required: true`
+
+**Étendu** `types.ts`
+- `PauseAction['parameters']` : ajout `safety_level?`, `safety_checks?`
+- `Execution` : ajout `pause_reason?`, `safety_checks?`
+
+**Étendu** `PropertiesPanel.tsx:1356` — éditeur de l'action `pause_for_human`
+- Section "Niveau de sécurité" : dropdown `standard | medical_critical`
+- Section "Checks à valider" : liste éditable (id + label + required)
+
+### 6.4 Data flow complet
+
+```
+Action pause_for_human (medical_critical, 2 checks déclaratifs) atteinte
+  ↓
+SafetyChecksProvider.build_pause_payload()
+  ├─ checks = [...declarative]  (2 entrées)
+  ├─ if safety_level == "medical_critical" and RPA_SAFETY_CHECKS_LLM_ENABLED=1:
+  │     llm_checks = _call_llm_for_contextual_checks()  (max 3, timeout 5s)
+  │     checks += llm_checks
+  └─ return PausePayload(checks, pause_reason, message)
+  ↓
+replay_state["status"] = "paused_need_help"
+replay_state["safety_checks"] = checks
+bus.emit("lea:safety_checks_generated", {count, sources})
+  ↓
+Frontend VWB poll /replay/state → reçoit pause_payload
+  ↓
+<PauseDialog> rend ChecklistPanel
+  ↓
+Médecin coche les 4 checks → clique Continuer
+  ↓
+POST /replay/resume {acknowledged_check_ids: [4 ids]}
+  ↓
+Serveur valide (tous required acquittés) → reprise du replay
+replay_state["checks_acknowledged"] = [...] (audit trail conservé)
+```
+
+### 6.5 Error handling
+
+| Cas | Comportement |
+|---|---|
+| `safety_level` absent | Pas d'appel LLM ; checks déclaratifs uniquement (peut être `[]`) → bulle simple si vide, checklist sinon |
+| Ollama timeout 5s | Event `lea:safety_checks_llm_failed`, `additional_checks=[]`, fallback safe (déclaratifs seuls) |
+| Ollama JSON malformé (post `format=json` — théoriquement impossible) | Idem timeout, fallback safe |
+| LLM produit un check absurde | Accepté tel quel, le superviseur ignore (pas de filtrage en V1) |
+| Frontend reçoit `safety_checks=[]` | Bulle simple, comportement legacy |
+| `RPA_SAFETY_CHECKS_LLM_ENABLED=0` | Couche LLM bypassée, déclaratifs gardés |
+| `/replay/resume` sans `acknowledged_check_ids` sur required | `400 required_checks_missing` |
+| Frontend POST `/replay/resume` rejeté | Toast d'erreur côté UI, état pause conservé, possibilité de cocher manquants et réessayer |
+
+### 6.6 Configuration env vars
+
+- `RPA_SAFETY_CHECKS_LLM_ENABLED=1` (défaut)
+- `RPA_SAFETY_CHECKS_LLM_MODEL=medgemma:4b`
+- `RPA_SAFETY_CHECKS_LLM_TIMEOUT_S=5`
+- `RPA_SAFETY_CHECKS_LLM_MAX_CHECKS=3`
+
+### 6.7 Tests QW4
+
+- `tests/unit/test_safety_checks_provider.py` : 7 cas (déclaratif seul, hybride réussi, LLM timeout, LLM JSON invalide, kill-switch, max_checks respecté, déclaratif vide)
+- `tests/integration/test_replay_resume_acknowledgments.py` : 3 cas (resume OK, missing required → 400, audit trail enregistré dans `checks_acknowledged`)
+- Frontend : `tests/components/PauseDialog.test.tsx` si suite Vitest existe (à confirmer pendant l'implémentation), sinon test manuel avec checklist écrite
+- Smoke : 1 workflow Easily avec `pause_for_human medical_critical` enrichi → vérification full chain
+
+### 6.8 Compat workflows existants
+
+100% backward — `pause_for_human` actuels n'ont ni `safety_level` ni `safety_checks` → comportement strictement identique. Aucune recréation forcée. Dom enrichira uniquement les workflows qu'il veut promouvoir au niveau `medical_critical`.
+
+## 7. Tests, sécurité de la branche, livraison
+
+### 7.1 Filet de sécurité avant TOUT commit sur `feature/qw-suite-mai`
+
+1. Branche backup poussée Gitea : `backup/pre-qw-suite-mai-2026-05-05`
+2. Capture baseline E2E :
+   ```
+   pytest tests/test_pipeline_e2e.py \
+          tests/test_phase0_integration.py \
+          tests/integration/test_stream_processor.py \
+          -q 2>&1 | tee .qw-baseline.log
+   ```
+3. Smoke démo : 1 dérouler complet d'un workflow Easily Assure, archivage screenshot/vidéo de référence
+4. État VWB validé : démarrage Vite local, ouverture d'un workflow, lancement d'un replay simple, screenshot "tout va bien"
+
+### 7.2 Discipline TDD légère par QW
+
+- Test unitaire écrit AVANT le code de production (1 test rouge → 1 implémentation → vert)
+- Pas de TDD complet sur le frontend (Vitest + React = trop d'outillage à valider en parallèle), test manuel cadré avec checklist écrite
+- Re-run de la suite baseline après chaque commit QW, comparaison au log archivé
+- Toute régression bloque le passage au QW suivant tant qu'elle n'est pas comprise et résolue
+
+### 7.3 Compat VWB — checklist explicite avant commit QW4
+
+- [ ] Workflow ancien (sans `safety_checks`) → bulle simple s'affiche normalement
+- [ ] Workflow nouveau avec `safety_checks` déclaratifs uniquement → checklist visible, **pas** d'appel Ollama (vérification logs)
+- [ ] Workflow `medical_critical` → checklist + checks LLM apparaissent (vérification logs Ollama call dans les 5s)
+- [ ] Continuer désactivé tant que required non cochés
+- [ ] POST `/replay/resume` avec mauvais payload → toast d'erreur côté UI, pas de crash
+- [ ] PropertiesPanel : édition de `safety_checks` ne casse pas l'édition d'autres params de `pause_for_human`
+- [ ] DB `workflows.db` : ouverture après commit, aucune migration cassante (schéma JSON est libre)
+
+### 7.4 Plan de commits
+
+```
+1. test(qw1): tests monitor_router + grounding_offset (rouges)
+2. feat(qw1): multi-écrans piloté par monitor_index (verts)
+3. test(qw2): tests loop_detector composite (rouges)
+4. feat(qw2): LoopDetector composite avec kill-switch env
+5. test(qw4): tests safety_checks_provider + replay_resume (rouges)
+6. feat(qw4): safety_checks hybride déclaratif + LLM contextuel
+7. feat(vwb): PauseDialog + ChecklistPanel + extension PropertiesPanel
+8. docs(qw): docs/QW_SUITE_MAI.md + mise à jour MEMORY.md
+```
+
+Chaque commit signé Co-Authored-By Claude. Branche poussée régulièrement sur Gitea pour backup distant.
+
+### 7.5 Stratégie en cas de régression critique pendant la démo
+
+Kill-switches env vars surchargeables sans redéploiement code :
+
+```
+systemctl edit rpa-streaming
+# Ajouter sous [Service] :
+Environment=RPA_LOOP_DETECTOR_ENABLED=0
+Environment=RPA_SAFETY_CHECKS_LLM_ENABLED=0
+systemctl restart rpa-streaming
+```
+
+Si problème grave au-delà des kill-switches : rollback à `backup/pre-qw-suite-mai-2026-05-05`.
+
+```
+git checkout backup/pre-qw-suite-mai-2026-05-05
+./svc.sh restart
+```
+
+### 7.6 Plan de livraison (Option A validée)
+
+**Avant démo GHT (cette semaine) — Sprint priorité 1**
+- QW1 : tests + code + smoke (~1j)
+- QW2 : tests + code + tests intégration (~2j)
+- Capture baseline + replay smoke entre chaque
+- Si QW1+QW2 validés et probants → on enchaîne sur QW4 dès que possible (Dom accepte le weekend si "effet waouh" auprès de spécialistes RPA)
+
+**Après démo / dès validation QW1+QW2 — Sprint priorité 2**
+- QW4 serveur (provider + LLM + endpoint resume) (~3j)
+- QW4 frontend (PauseDialog + PropertiesPanel) (~2j)
+- Doc + mise à jour MEMORY.md
+
+**Total estimé** : ~8.5j-h ingénieur senior, étalable selon le retour démo.
+
+## 8. Ce qui n'est PAS dans ce spec (out of scope)
+
+- F1 (DSL d'actions Pydantic-first) : refactor de fond, sera son propre spec après la démo.
+- F2 (Mixture-of-Grounding routeur adaptatif) : nécessite F1, son propre spec.
+- F3 (Best-of-N + Reflection) : nécessite F1, son propre spec.
+- QW3 (`output_model_schema` Pydantic pour `extract_text`) : opportuniste, sera intégré quand on touchera `extract_text` pour autre chose.
+- Toute introduction de Pydantic-AI / instructor / Playwright / accessibility-tree : interdit (contraintes inviolables).
+- Refonte du composant pause en `<PauseDialog>` à 3 modes (option C de Q6) : reportée après démo si retour utilisateurs justifie l'investissement.
+
+## 9. Open questions
+
+Aucune. Toutes les décisions de design ont été tranchées via les 7 questions clarifiantes du brainstorming du 5 mai 2026.

pytest.ini

@@ -27,6 +27,7 @@ markers =
     fiche9: Tests Fiche #9 (postconditions retry backoff)
     fiche10: Tests Fiche #10 (precision metrics engine)
     visual: Tests visuels sur captures réelles (nécessite serveur GPU)
+    e2e: Tests E2E contre serveurs (streaming + VWB) actifs — lents, à lancer manuellement
 
 # Note: Chemins Python gérés par tests/conftest.py
 

tests/e2e/fixtures/urgence_aiva_demo/_ocr_inventory.json

@@ -0,0 +1,152 @@
+{
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773792436.png": {
+    "found": [],
+    "size": 415142,
+    "ocr_dt": 5.3
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773792383.png": {
+    "found": [],
+    "size": 412395,
+    "ocr_dt": 5.2
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773792331.png": {
+    "found": [],
+    "size": 407364,
+    "ocr_dt": 5.2
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773792278.png": {
+    "found": [],
+    "size": 409614,
+    "ocr_dt": 5.4
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773792225.png": {
+    "found": [],
+    "size": 410632,
+    "ocr_dt": 5.3
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773792172.png": {
+    "found": [],
+    "size": 601747,
+    "ocr_dt": 6.1
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773792119.png": {
+    "found": [],
+    "size": 524070,
+    "ocr_dt": 5.6
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773792066.png": {
+    "found": [],
+    "size": 495872,
+    "ocr_dt": 5.2
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773791846.png": {
+    "found": [],
+    "size": 349923,
+    "ocr_dt": 4.7
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773791581.png": {
+    "found": [],
+    "size": 351106,
+    "ocr_dt": 5.0
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773791381.png": {
+    "found": [],
+    "size": 469478,
+    "ocr_dt": 5.7
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773791283.png": {
+    "found": [],
+    "size": 419376,
+    "ocr_dt": 5.9
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773791053.png": {
+    "found": [],
+    "size": 451460,
+    "ocr_dt": 7.4
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773790629.png": {
+    "found": [],
+    "size": 402427,
+    "ocr_dt": 4.4
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773790480.png": {
+    "found": [],
+    "size": 403940,
+    "ocr_dt": 5.3
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773789256.png": {
+    "found": [],
+    "size": 366536,
+    "ocr_dt": 5.3
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773788105.png": {
+    "found": [],
+    "size": 414903,
+    "ocr_dt": 5.3
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773787561.png": {
+    "found": [],
+    "size": 378032,
+    "ocr_dt": 5.2
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773786527.png": {
+    "found": [],
+    "size": 1622254,
+    "ocr_dt": 5.4
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773785450.png": {
+    "found": [],
+    "size": 353892,
+    "ocr_dt": 5.2
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773785264.png": {
+    "found": [],
+    "size": 407159,
+    "ocr_dt": 5.5
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773785115.png": {
+    "found": [],
+    "size": 375099,
+    "ocr_dt": 5.4
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773784779.png": {
+    "found": [],
+    "size": 1029130,
+    "ocr_dt": 7.4
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773784695.png": {
+    "found": [],
+    "size": 1729091,
+    "ocr_dt": 5.5
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773784592.png": {
+    "found": [],
+    "size": 357796,
+    "ocr_dt": 4.7
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773784539.png": {
+    "found": [],
+    "size": 420256,
+    "ocr_dt": 4.4
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773783685.png": {
+    "found": [],
+    "size": 558014,
+    "ocr_dt": 6.3
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773783627.png": {
+    "found": [],
+    "size": 582681,
+    "ocr_dt": 5.2
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773783543.png": {
+    "found": [],
+    "size": 1208817,
+    "ocr_dt": 5.3
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/bg_DESKTOP-58D5CAC_windows/shots/heartbeat_1773783484.png": {
+    "found": [],
+    "size": 451052,
+    "ocr_dt": 4.8
+  }
+}

tests/e2e/fixtures/urgence_aiva_demo/_ocr_inventory_may5.json

@@ -0,0 +1,34 @@
+{
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/DESKTOP-58D5CAC_windows/sess_20260505T093148_6bf7eb/shots/shot_0001_full.png": {
+    "found": [],
+    "preview": "0 | Mode veille | Dites | Sortie de veille de l'accès vocal | ou appuyez | le bouton micro pour activer l'accès vocal. | 883 | 0 | 0 | [ € | M | @ | *l * | * | Q | 2<1616  * *l | Claude (MCP) | 0 @ + | 0  X | gitlabs laurinebazin design/?repo-search-query =1 | ABP | X | 8 | = | Claude (MCP) | Claude"
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/DESKTOP-58D5CAC_windows/sess_20260505T093148_6bf7eb/shots/shot_0002_full.png": {
+    "found": [],
+    "preview": "0 | Mode veille | Dites | Sortie de veille de l'accès vocal | ou appuyez | le bouton micro pour activer l'accès vocal. | {83 | Q | [ Q | 78777 | @ | X * * | Q | 2 0 0 * * * | Claude (MCP) | 6 @ + | gitlabs laurinebazin design/?repo-search-query =1 | ABP | X | 8 | = | Claude (MCP) | Claude | 88 | Al "
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/DESKTOP-58D5CAC_windows/sess_20260505T093148_6bf7eb/shots/shot_0003_full.png": {
+    "found": [],
+    "preview": "0 | Mode veille | Dites < Sortie de veille de l'accès vocal > ou appuyez sur le bouton micro pour activer l'accès vocal. | {83 | Enregistrement automatique | 8 9 ~ @ | Document3 | Rechercher | DB | X | Claude (MCP) | 6 @ + | Fichier | Accueil | Insertion | Dessin | Conception | Mise en page | Référe"
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/DESKTOP-58D5CAC_windows/sess_20260505T093148_6bf7eb/shots/shot_0004_full.png": {
+    "found": [],
+    "preview": "0 | Mode veille | Dites | Sortie de veille de l'accès vocal | ou appuyez sur le bouton micro pour activer l'accès vocal. | {83 | Enregistrement automatique | 8 2 ~ @ | Document3 | Rechercher | DB | X | Claude (MCP) | 6 @ + | Fichier | Accueil | Insertion | Dessin | Conception | Mise en page | Référe"
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/DESKTOP-58D5CAC_windows/sess_20260505T093148_6bf7eb/shots/shot_0005_full.png": {
+    "found": [],
+    "preview": "0 | Mode veille | Dites | Sortie de veille de l'accès vocal | ou appuyez sur le bouton micro pour activer l'accès vocal. | {83 | Enregistrement automatique | 8 2 ~ @ | Document3 | Rechercher | DB | X | Claude (MCP) | 6 @ + | Fichier | Accueil | Insertion | Dessin | Conception | Mise en page | Référe"
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/DESKTOP-58D5CAC_windows/sess_20260505T093148_6bf7eb/shots/heartbeat_1777966309.png": {
+    "found": [],
+    "preview": "0 | Mode veille | Dites | Sortie de veille de l'accès vocal | ou appuyez | le bouton micro pour activer l'accès vocal. | 883 | 0 | 0 | [ € | M | @ | *l * | * | Q | 2<1616  * *l | Claude (MCP) | 0 @ + | 0  X | gitlabs laurinebazin design/?repo-search-query =1 | ABP | X | 8 | = | Claude (MCP) | Claude"
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/DESKTOP-58D5CAC_windows/sess_20260505T093148_6bf7eb/shots/heartbeat_1777966315.png": {
+    "found": [],
+    "preview": "0 | Mode veille | Dites | Sortie de veille de l'accès vocal | ou appuyez | le bouton micro pour activer l'accès vocal. | {83 | Q | [ Q | 78777 | @ | X * * | Q | 2 0 0 * * * | Claude (MCP) | 6 @ + | gitlabs laurinebazin design/?repo-search-query =1 | ABP | X | 8 | = | Claude (MCP) | Claude | 88 | Al "
+  },
+  "/home/dom/ai/rpa_vision_v3/data/training/live_sessions/DESKTOP-58D5CAC_windows/sess_20260505T093148_6bf7eb/shots/heartbeat_1777966322.png": {
+    "found": [],
+    "preview": "0 | Mode veille | Dites | Sortie de veille de l'accès vocal | ou appuyez sur le bouton micro pour activer l'accès vocal. | {83 | Q | [ Q | 78777 | @ | X * * | Q | 2 0 0 * *l | Claude (MCP) | 6 @ + | gitlabs laurinebazin design/?repo-search-query =1 | ABP | X | 8 | = | Claude (MCP) | Claude | 88 | Al"
+  }
+}

tests/e2e/fixtures/urgence_aiva_demo/_run_resolve_results.json

@@ -0,0 +1,168 @@
+[
+  {
+    "by_text": "25003284",
+    "fixture": "live/landing.png",
+    "result": {
+      "resolved": true,
+      "method": "hybrid_text_direct",
+      "x_pct": 0.0302734375,
+      "y_pct": 0.1987847222222222,
+      "score": 1.0,
+      "matched_text": "25003284",
+      "_dt_ms": 1542.8798198699951,
+      "_recorded": [
+        0.4928,
+        0.4512
+      ],
+      "_screen_size": [
+        1920,
+        1080
+      ]
+    }
+  },
+  {
+    "by_text": "Examens cliniques",
+    "fixture": "live/dossier_motif.png",
+    "result": {
+      "resolved": false,
+      "method": "fallback",
+      "reason": "analysis_error",
+      "detail": "unsupported format string passed to NoneType.__format__",
+      "x_pct": 0.498046875,
+      "y_pct": 0.4928125,
+      "_dt_ms": 1420.240879058838,
+      "_recorded": [
+        0.498,
+        0.4928
+      ],
+      "_screen_size": [
+        1920,
+        1080
+      ]
+    }
+  },
+  {
+    "by_text": "Imagerie",
+    "fixture": "live/dossier_examens-cliniques.png",
+    "result": {
+      "resolved": true,
+      "method": "hybrid_text_direct",
+      "x_pct": 0.2255859375,
+      "y_pct": 0.1267361111111111,
+      "score": 0.8,
+      "matched_text": "Motif d'admission Examens cliniques Imagerie Notes médicales Synthèse Urgences Codage >",
+      "_dt_ms": 1372.1542358398438,
+      "_recorded": [
+        0.498,
+        0.4928
+      ],
+      "_screen_size": [
+        1920,
+        1080
+      ]
+    }
+  },
+  {
+    "by_text": "Notes médicales",
+    "fixture": "live/dossier_imagerie.png",
+    "result": {
+      "resolved": true,
+      "method": "hybrid_text_direct",
+      "x_pct": 0.22265625,
+      "y_pct": 0.12586805555555555,
+      "score": 0.8,
+      "matched_text": "Motif d'admission Examens cliniques Imagerie Notes médicales Synthèse Urgences Codage >>",
+      "_dt_ms": 975.5856990814209,
+      "_recorded": [
+        0.202,
+        0.28
+      ],
+      "_screen_size": [
+        1920,
+        1080
+      ]
+    }
+  },
+  {
+    "by_text": "Synthèse Urgences",
+    "fixture": "live/dossier_notes-medicales.png",
+    "result": {
+      "resolved": false,
+      "method": "fallback",
+      "reason": "analysis_error",
+      "detail": "unsupported format string passed to NoneType.__format__",
+      "x_pct": 0.2705078125,
+      "y_pct": 0.279375,
+      "_dt_ms": 1341.4692878723145,
+      "_recorded": [
+        0.2705,
+        0.2794
+      ],
+      "_screen_size": [
+        1920,
+        1080
+      ]
+    }
+  },
+  {
+    "by_text": "Codage",
+    "fixture": "live/dossier_synthese-urgences.png",
+    "result": {
+      "resolved": true,
+      "method": "hybrid_text_direct",
+      "x_pct": 0.13916015625,
+      "y_pct": 0.05381944444444445,
+      "score": 0.8,
+      "matched_text": "Patients Planning Dossier en cours Codage Statistiques",
+      "_dt_ms": 1252.6636123657227,
+      "_recorded": [
+        0.3189,
+        0.2281
+      ],
+      "_screen_size": [
+        1920,
+        1080
+      ]
+    }
+  },
+  {
+    "by_text": "Coller ou saisir le dossier patient",
+    "fixture": "live/dossier_codage.png",
+    "result": {
+      "resolved": false,
+      "method": "strict_vlm_template_failed",
+      "reason": "vlm_and_template_all_failed",
+      "x_pct": 0.0748046875,
+      "y_pct": 0.44125,
+      "_dt_ms": 4233.16764831543,
+      "_recorded": [
+        0.0748,
+        0.4412
+      ],
+      "_screen_size": [
+        1920,
+        1080
+      ]
+    }
+  },
+  {
+    "by_text": "Justification de la décision",
+    "fixture": "live/dossier_codage.png",
+    "result": {
+      "resolved": false,
+      "method": "strict_vlm_template_failed",
+      "reason": "vlm_and_template_all_failed",
+      "x_pct": 0.6482421875,
+      "y_pct": 0.6228125,
+      "_dt_ms": 3586.3852500915527,
+      "_recorded": [
+        0.6482,
+        0.6228
+      ],
+      "_screen_size": [
+        1920,
+        1080
+      ]
+    }
+  }
+]

tests/e2e/test_urgence_aiva_demo.py

@@ -0,0 +1,118 @@
+"""Tests E2E du workflow Urgence_aiva_demo via le harness mock client.
+
+Marqueurs : @pytest.mark.e2e @pytest.mark.slow
+Pré-requis : streaming server (5005) + VWB (5002) actifs.
+
+Lancement :
+    pytest tests/e2e -v -m e2e
+
+Le test est un smoke check : il vérifie qu'on arrive à lancer un replay,
+poller les actions et que le harness termine sans crash. Il n'exige PAS
+que tous les steps réussissent (le screenshot fixture peut être obsolète).
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+import requests
+
+from tools.test_replay_e2e import (
+    ReplayMockClient,
+    _find_latest_heartbeat,
+    _load_token,
+    DEFAULT_BASE_URL,
+    DEFAULT_VWB_URL,
+)
+
+WORKFLOW_ID = "wf_a38aeebea5e6_1778162737"  # Urgence_aiva_demo
+
+
+def _server_alive(url: str, timeout: float = 2.0) -> bool:
+    try:
+        resp = requests.get(f"{url}/health", timeout=timeout)
+        return resp.status_code == 200
+    except Exception:
+        return False
+
+
+def _vwb_alive(url: str, timeout: float = 2.0) -> bool:
+    try:
+        # VWB n'a pas /health, on tape /api/v3/session/state
+        resp = requests.get(f"{url}/api/v3/session/state", timeout=timeout)
+        return resp.status_code in (200, 404)
+    except Exception:
+        return False
+
+
+@pytest.fixture(scope="module")
+def streaming_url() -> str:
+    if not _server_alive(DEFAULT_BASE_URL):
+        pytest.skip(f"Streaming server inactif sur {DEFAULT_BASE_URL}")
+    return DEFAULT_BASE_URL
+
+
+@pytest.fixture(scope="module")
+def vwb_url() -> str:
+    if not _vwb_alive(DEFAULT_VWB_URL):
+        pytest.skip(f"VWB backend inactif sur {DEFAULT_VWB_URL}")
+    return DEFAULT_VWB_URL
+
+
+@pytest.fixture(scope="module")
+def heartbeat() -> str:
+    path = _find_latest_heartbeat()
+    if not path or not Path(path).exists():
+        pytest.skip("Aucun heartbeat fixture disponible sur disque")
+    return path
+
+
+@pytest.mark.e2e
+@pytest.mark.slow
+def test_urgence_aiva_demo_smoke(streaming_url, vwb_url, heartbeat):
+    """Smoke : lance et déroule le workflow Urgence_aiva_demo via le harness.
+
+    Vérifie que :
+    - le harness peut compiler et lancer le replay (pas d'exception réseau)
+    - au moins quelques steps sont reportés (la chaîne tourne)
+    - aucune exception non gérée n'est levée
+    """
+    import time as _time
+    import uuid as _uuid
+
+    ts = _time.strftime("%Y%m%dT%H%M%S")
+    client = ReplayMockClient(
+        base_url=streaming_url,
+        vwb_url=vwb_url,
+        token=_load_token(),
+        session_id=f"test_e2e_pytest_{ts}_{_uuid.uuid4().hex[:6]}",
+        machine_id=f"test_e2e_pytest_machine_{ts}",
+        screenshot_path=heartbeat,
+        verbose=False,
+        auto_resume=True,
+        execution_mode="autonomous",
+        timeout_poll=10.0,
+        single_step=None,
+        max_iter=80,
+    )
+
+    try:
+        client.cancel_stale_replays()
+        client.register_session()
+        info = client.start_replay(WORKFLOW_ID)
+        assert info.get("replay_id"), f"replay_id absent : {info}"
+        assert info.get("total_actions", 0) > 0
+        client.run()
+    finally:
+        try:
+            client.cancel_replay()
+        except Exception:
+            pass
+
+    # Le harness doit avoir produit au moins quelques rapports
+    assert len(client.reports) > 0, "Aucune action reportée — harness cassé ?"
+
+    # Le 1er step est un wait synthétique injecté par VWB → doit être OK
+    first = client.reports[0]
+    assert first.action_type == "wait", f"1er step inattendu : {first}"
+    assert first.status == "OK"

tests/e2e/urgence_aiva_demo_expected.yaml

@@ -0,0 +1,138 @@
+# Attendus E2E pour wf_a38aeebea5e6_1778162737 (Urgence_aiva_demo).
+#
+# Mis à jour 2026-05-08 sur fixtures Easily Assure capturées en live
+# (`tests/e2e/fixtures/urgence_aiva_demo/live/*.png`, headless Chrome
+# 1920x1080) — donc representatives du screen tel que vu par Léa.
+#
+# Tolérance : la résolution de coordonnées varie de quelques pixels d'un
+# run à l'autre (anti-aliasing OCR, EasyOCR non déterministe). On se
+# limite donc à valider :
+#   - status (OK / FAIL)
+#   - method (préfixe)
+#   - score ≥ seuil
+#   - position dans une bbox attendue (en pourcentages, large)
+#
+# Steps NON couverts ici :
+#   - 1, 4-7, 9, 11, 13, 15-16, 19, 21 (extract_text, keyboard_shortcut,
+#     type_text, t2a_decision, pause_for_human → exécutés serveur ou
+#     simulés client, pas de dépendance à la cascade visuelle).
+#
+# Couverts (click_anchor) :
+#   3, 8, 10, 12, 14, 17, 18, 20.
+#
+# Steps 18 (Coller textarea DPI) et 20 (Justification) attendus en
+# pause_supervisée si l'écran courant est la maquette urgences (et non
+# aiva-vision) — cf. §"Limitations fixtures" du rapport.
+
+workflow_id: wf_a38aeebea5e6_1778162737
+fixtures_dir: tests/e2e/fixtures/urgence_aiva_demo/live
+generated_at: '2026-05-08'
+screen_size_default: [1920, 1080]
+
+steps:
+  - order: 3
+    action_type: click_anchor
+    by_text: '25003284'
+    fixture: live/landing.png
+    expected:
+      resolved: true
+      method_prefix: hybrid_text_direct
+      score_min: 0.80
+      x_pct_range: [0.01, 0.10]    # IPP en début de ligne, colonne gauche
+      y_pct_range: [0.18, 0.30]    # 1ère ligne tableau patients
+      max_elapsed_ms: 5000
+
+  - order: 8
+    action_type: click_anchor
+    by_text: 'Examens cliniques'
+    fixture: live/dossier_motif.png
+    expected:
+      resolved: true
+      method_prefix: hybrid_text_direct
+      score_min: 0.80
+      x_pct_range: [0.18, 0.30]    # tab gauche-centre
+      y_pct_range: [0.10, 0.16]    # bandeau onglets
+      max_elapsed_ms: 5000
+    notes: |
+      Régression confirmée 2026-05-08 sur cette cible : pre-check OCR
+      (radius 200) ne capte pas le mot "Examens" (tronqué) et fait crash
+      le log RESOLVE_EXIT (NoneType format). Voir rapport
+      docs/E2E_TEST_RUN_2026-05-08.md, correctif #1 et #2.
+
+  - order: 10
+    action_type: click_anchor
+    by_text: 'Imagerie'
+    fixture: live/dossier_examens-cliniques.png
+    expected:
+      resolved: true
+      method_prefix: hybrid_text_direct
+      score_min: 0.80
+      x_pct_range: [0.20, 0.32]
+      y_pct_range: [0.10, 0.16]
+      max_elapsed_ms: 5000
+
+  - order: 12
+    action_type: click_anchor
+    by_text: 'Notes médicales'
+    fixture: live/dossier_imagerie.png
+    expected:
+      resolved: true
+      method_prefix: hybrid_text_direct
+      score_min: 0.80
+      x_pct_range: [0.20, 0.32]
+      y_pct_range: [0.10, 0.16]
+      max_elapsed_ms: 5000
+
+  - order: 14
+    action_type: click_anchor
+    by_text: 'Synthèse Urgences'
+    fixture: live/dossier_notes-medicales.png
+    expected:
+      resolved: true
+      method_prefix: hybrid_text_direct
+      score_min: 0.80
+      x_pct_range: [0.22, 0.36]
+      y_pct_range: [0.10, 0.16]
+      max_elapsed_ms: 5000
+    notes: |
+      Régression confirmée — même cause que step 8 : pre-check radius 200
+      voit 0/2 tokens. Correctif #1 résout.
+
+  - order: 17
+    action_type: click_anchor
+    by_text: 'Codage'
+    fixture: live/dossier_synthese-urgences.png
+    expected:
+      resolved: true
+      method_prefix: hybrid_text_direct
+      score_min: 0.80
+      x_pct_range: [0.10, 0.20]
+      y_pct_range: [0.04, 0.08]    # bouton barre de menu (top)
+      max_elapsed_ms: 5000
+
+  - order: 18
+    action_type: click_anchor
+    by_text: 'Coller ou saisir le dossier patient'
+    # Cette cible est sur la page aiva-vision (https://aiva-vision.test/...)
+    # PAS sur la maquette urgences. À documenter avec une fixture dédiée
+    # ou exécuter en démo réelle.
+    fixture: live/dossier_codage.png  # placeholder — devrait être aiva-vision
+    expected:
+      resolved: false                   # avec le placeholder
+      reason: vlm_and_template_all_failed
+      method_prefix: strict_vlm_template_failed
+    notes: |
+      Fixture non représentative — l'agent doit naviguer vers
+      aiva-vision (étape 17 ouvre Codage onglet, qui redirige vers
+      la page aiva). À recapturer sur le replay réel.
+
+  - order: 20
+    action_type: click_anchor
+    by_text: 'Justification de la décision'
+    fixture: live/dossier_codage.png  # idem step 18
+    expected:
+      resolved: false
+      reason: vlm_and_template_all_failed
+      method_prefix: strict_vlm_template_failed
+    notes: |
+      Idem step 18 — page aiva-vision non capturée dans cette suite.

tests/integration/test_chat_window_templates.py

@@ -0,0 +1,129 @@
+"""Tests des templates de bulles 'Léa exécute' (J3.4).
+
+On teste les fonctions _tpl_* et _extract_meta de chat_window.py — elles sont
+purement fonctionnelles (input payload → output tuple), aucune UI tkinter
+nécessaire.
+"""
+
+import pytest
+
+from agent_v0.agent_v1.ui import chat_window as cw
+
+
+# ----------------------------------------------------------------------
+# Templates _tpl_*
+# ----------------------------------------------------------------------
+
+def test_tpl_action_started_uses_workflow_name():
+    icon, color, title = cw._tpl_action_started({"workflow": "Demo Urgences UHCD"})
+    assert icon == "▶"
+    assert color == cw.ACTION_ICON_RUN
+    assert "Demo Urgences UHCD" in title
+
+
+def test_tpl_action_started_fallback_when_no_workflow():
+    _, _, title = cw._tpl_action_started({})
+    assert "?" in title
+
+
+def test_tpl_action_progress_uses_step_when_provided():
+    _, _, title = cw._tpl_action_progress({"step": "J'ouvre la fiche patient"})
+    assert title == "J'ouvre la fiche patient"
+
+
+def test_tpl_action_progress_fallback_to_counter():
+    _, _, title = cw._tpl_action_progress({"current": 4, "total": 7})
+    assert "4/7" in title
+
+
+def test_tpl_done_success():
+    icon, color, title = cw._tpl_done({"success": True, "message": "Codage terminé"})
+    assert icon == "✓"
+    assert color == cw.ACTION_ICON_OK
+    assert title == "Codage terminé"
+
+
+def test_tpl_done_failure():
+    icon, color, title = cw._tpl_done({"success": False, "message": "Action échouée"})
+    assert icon == "✗"
+    assert color == cw.ACTION_ICON_ERR
+    assert title == "Action échouée"
+
+
+def test_tpl_done_default_success_when_unspecified():
+    icon, _, _ = cw._tpl_done({})
+    assert icon == "✓"  # par défaut on suppose succès si non précisé
+
+
+def test_tpl_need_confirm_extracts_action_description():
+    icon, _, title = cw._tpl_need_confirm({
+        "action": {"description": "Cliquer sur l'IPP 25003284"}
+    })
+    assert icon == "?"
+    assert "25003284" in title
+
+
+def test_tpl_need_confirm_fallback():
+    _, _, title = cw._tpl_need_confirm({})
+    assert "Validation" in title
+
+
+def test_tpl_step_result_ok():
+    icon, color, _ = cw._tpl_step_result({"status": "ok", "message": "ok"})
+    assert icon == "✓"
+    assert color == cw.ACTION_ICON_OK
+
+
+def test_tpl_step_result_failed():
+    icon, color, _ = cw._tpl_step_result({"status": "failed", "message": "boom"})
+    assert icon == "✗"
+    assert color == cw.ACTION_ICON_ERR
+
+
+def test_tpl_step_result_neutral_status():
+    icon, color, _ = cw._tpl_step_result({"status": "skipped", "message": "passé"})
+    assert icon == "·"
+    assert color == cw.ACTION_ICON_INFO
+
+
+def test_tpl_resumed():
+    icon, color, title = cw._tpl_resumed({})
+    assert icon == "→"
+    assert color == cw.ACTION_ICON_OK
+    assert "Reprise" in title
+
+
+# ----------------------------------------------------------------------
+# Dispatch — chaque event lea:* (hors paused/acks) doit avoir un template
+# ----------------------------------------------------------------------
+
+def test_all_relevant_events_have_a_template():
+    expected = {
+        "lea:action_started", "lea:action_progress", "lea:done",
+        "lea:need_confirm", "lea:step_result", "lea:resumed",
+    }
+    assert set(cw._ACTION_TEMPLATES.keys()) == expected
+
+
+# ----------------------------------------------------------------------
+# _extract_meta
+# ----------------------------------------------------------------------
+
+def test_extract_meta_with_workflow():
+    meta = cw._extract_meta({"workflow": "Demo Urgences"})
+    assert meta == "Demo Urgences"
+
+
+def test_extract_meta_with_progress():
+    meta = cw._extract_meta({"workflow": "Demo Urgences", "current": 4, "total": 7})
+    assert "Demo Urgences" in meta
+    assert "étape 4/7" in meta
+
+
+def test_extract_meta_with_replay_id_truncated():
+    meta = cw._extract_meta({"replay_id": "rep_abcdef0123456789"})
+    assert "#789" in meta or "456789" in meta  # 6 derniers caractères
+
+
+def test_extract_meta_empty_payload():
+    assert cw._extract_meta({}) == ""

tests/integration/test_feedback_bus.py

@@ -0,0 +1,164 @@
+"""Tests du bus feedback Léa (events lea:* via Flask-SocketIO).
+
+Couvre J2.5 et J2.6 :
+- Flag LEA_FEEDBACK_BUS=0 → _emit_lea no-op, _emit_dual ne propage que l'event legacy
+- Flag LEA_FEEDBACK_BUS=1 → _emit_lea propage 'lea:{event}', _emit_dual propage les deux
+
+Approche : on intercepte socketio.emit avec monkeypatch (plus fiable que test_client
+de Flask-SocketIO qui ne capte pas toujours les broadcasts hors contexte requête).
+"""
+
+import importlib
+
+import pytest
+
+
+def _reload_app(monkeypatch, flag_value: str):
+    monkeypatch.setenv("LEA_FEEDBACK_BUS", flag_value)
+    import agent_chat.app as app_mod
+    importlib.reload(app_mod)
+    return app_mod
+
+
+def _capture_emits(monkeypatch, app_mod):
+    calls = []
+    monkeypatch.setattr(
+        app_mod.socketio, "emit",
+        lambda event, payload=None, **kwargs: calls.append((event, payload, kwargs)),
+    )
+    return calls
+
+
+@pytest.fixture
+def app_off(monkeypatch):
+    return _reload_app(monkeypatch, "0")
+
+
+@pytest.fixture
+def app_on(monkeypatch):
+    return _reload_app(monkeypatch, "1")
+
+
+def test_flag_off_by_default(monkeypatch):
+    monkeypatch.delenv("LEA_FEEDBACK_BUS", raising=False)
+    import agent_chat.app as app_mod
+    importlib.reload(app_mod)
+    assert app_mod.LEA_FEEDBACK_BUS is False
+
+
+def test_flag_accepts_truthy_values(monkeypatch):
+    for truthy in ["1", "true", "True", "yes", "on", "TRUE"]:
+        monkeypatch.setenv("LEA_FEEDBACK_BUS", truthy)
+        import agent_chat.app as app_mod
+        importlib.reload(app_mod)
+        assert app_mod.LEA_FEEDBACK_BUS is True, f"{truthy!r} devrait activer le flag"
+
+
+def test_emit_lea_noop_when_flag_off(app_off, monkeypatch):
+    calls = _capture_emits(monkeypatch, app_off)
+    app_off._emit_lea("paused", {"workflow": "demo", "reason": "test"})
+    assert calls == []
+
+
+def test_emit_lea_emits_when_flag_on(app_on, monkeypatch):
+    calls = _capture_emits(monkeypatch, app_on)
+    app_on._emit_lea("paused", {"workflow": "demo", "reason": "test"})
+    assert len(calls) == 1
+    event, payload, _ = calls[0]
+    assert event == "lea:paused"
+    assert payload == {"workflow": "demo", "reason": "test"}
+
+
+def test_emit_dual_emits_only_legacy_when_flag_off(app_off, monkeypatch):
+    calls = _capture_emits(monkeypatch, app_off)
+    app_off._emit_dual("execution_started", "action_started", {"workflow": "demo"})
+    assert len(calls) == 1
+    assert calls[0][0] == "execution_started"
+
+
+def test_emit_dual_emits_both_when_flag_on(app_on, monkeypatch):
+    calls = _capture_emits(monkeypatch, app_on)
+    payload = {"workflow": "demo", "params": {"k": "v"}}
+    app_on._emit_dual("execution_started", "action_started", payload)
+    events = [c[0] for c in calls]
+    assert "execution_started" in events
+    assert "lea:action_started" in events
+    assert len(calls) == 2
+
+
+def test_emit_dual_preserves_kwargs(app_on, monkeypatch):
+    """broadcast=True et autres kwargs Flask-SocketIO doivent être propagés au legacy."""
+    calls = _capture_emits(monkeypatch, app_on)
+    app_on._emit_dual("execution_cancelled", "cancelled", {}, broadcast=True)
+    legacy_call = next(c for c in calls if c[0] == "execution_cancelled")
+    assert legacy_call[2].get("broadcast") is True
+
+
+def test_emit_lea_silenced_on_socketio_error(app_on, monkeypatch):
+    """Une exception dans socketio.emit ne doit jamais remonter."""
+    def boom(*args, **kwargs):
+        raise RuntimeError("socketio fail")
+    monkeypatch.setattr(app_on.socketio, "emit", boom)
+    app_on._emit_lea("paused", {"x": 1})
+
+
+# ----------------------------------------------------------------------
+# J3.5 — Handlers SocketIO depuis ChatWindow
+# ----------------------------------------------------------------------
+
+class _FakeResponse:
+    def __init__(self, ok=True, status_code=200, text=""):
+        self.ok = ok
+        self.status_code = status_code
+        self.text = text
+
+
+def test_replay_resume_handler_relays_post_to_streaming(app_on, monkeypatch):
+    """Le handler 'lea:replay_resume' doit POSTer sur /replay/{id}/resume du streaming."""
+    captured = {}
+
+    def fake_post(url, headers=None, **kwargs):
+        captured["url"] = url
+        captured["headers"] = headers
+        return _FakeResponse(ok=True, status_code=200)
+
+    monkeypatch.setattr(app_on.http_requests, "post", fake_post)
+    emit_calls = _capture_emits(monkeypatch, app_on)
+
+    app_on.handle_lea_replay_resume({"replay_id": "rep_abc123"})
+
+    assert "rep_abc123" in captured["url"]
+    assert captured["url"].endswith("/api/v1/traces/stream/replay/rep_abc123/resume")
+    # Le bus doit propager un ack
+    acked = [c for c in emit_calls if c[0] == "lea:resume_acked"]
+    assert len(acked) == 1
+    assert acked[0][1]["status"] == "ok"
+
+
+def test_replay_resume_handler_emits_error_on_http_failure(app_on, monkeypatch):
+    monkeypatch.setattr(
+        app_on.http_requests, "post",
+        lambda *a, **k: _FakeResponse(ok=False, status_code=500, text="boom"),
+    )
+    emit_calls = _capture_emits(monkeypatch, app_on)
+    app_on.handle_lea_replay_resume({"replay_id": "rep_x"})
+    acked = [c for c in emit_calls if c[0] == "lea:resume_acked"]
+    assert acked[0][1]["status"] == "error"
+    assert acked[0][1]["http_status"] == 500
+
+
+def test_replay_resume_handler_emits_error_on_no_replay_id(app_on, monkeypatch):
+    emit_calls = _capture_emits(monkeypatch, app_on)
+    app_on.handle_lea_replay_resume({})
+    acked = [c for c in emit_calls if c[0] == "lea:resume_acked"]
+    assert acked[0][1]["status"] == "error"
+    assert "replay_id manquant" in acked[0][1]["detail"]
+
+
+def test_replay_abort_handler_stops_local_execution(app_on, monkeypatch):
+    app_on.execution_status["running"] = True
+    emit_calls = _capture_emits(monkeypatch, app_on)
+    app_on.handle_lea_replay_abort({"replay_id": "rep_y"})
+    assert app_on.execution_status["running"] is False
+    acked = [c for c in emit_calls if c[0] == "lea:abort_acked"]
+    assert acked[0][1]["status"] == "ok"