snapshot: WIP 5j replay reliability (B1 watchdog + dialog handlers + grounding drift)

Snapshot avant correction du blocage relance Léa (3 incidents 24h: SSH refusé,
polls morts ×2). Point de rollback stable.

Contenu:
- agent_v1/core/executor.py: 5 patchs dialog handling (saveas drift, close_tab
  hotkey fallback, confirm_save Unicode apostrophe, foreground dialog
  recontextualization, runtime_dialog in-loop) + helpers normalize_window_hint,
  requires_post_verify_window_transition
- agent_v1/core/grounding.py: garde drift template fix (fallback_x/y plumbed)
- server_v1/replay_watchdog.py (NEW): orphan watchdog B1, scan 10s timeout 30s
- server_v1/api_stream.py: dispatched_action plumbing, watchdog lifespan,
  metrics endpoint
- server_v1/replay_engine.py: _schedule_retry préserve original_action +
  dispatched_action
- stream_processor.py: gardes _infer_tab_switch_target (no false switch_tab
  on save_as dialog open) + _attach_expected_window_before
- tests/integration: test_replay_watchdog.py (8 cas), test_stream_processor.py
- tests/unit: test_executor_verify_window_guard.py (start_button, close_tab,
  runtime_dialog, post_verify, transition fallbacks)

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

agent_v0/server_v1/replay_memory.py

@@ -103,15 +103,53 @@ def compute_screen_sig(window_title: str) -> str:
     return hashlib.sha256(norm.encode("utf-8")).hexdigest()[:16]
 
 
+def _round_float_list(values: Any, precision: int = 4) -> Optional[tuple[float, ...]]:
+    """Normaliser une liste de coordonnées flottantes pour le hash mémoire."""
+    if not isinstance(values, (list, tuple)):
+        return None
+    out = []
+    for value in values:
+        try:
+            out.append(round(float(value), precision))
+        except (TypeError, ValueError):
+            return None
+    return tuple(out)
+
+
+def _int_pair(values: Any) -> Optional[tuple[int, int]]:
+    """Extraire une paire entière stable pour les hints spatiaux."""
+    if not isinstance(values, (list, tuple)) or len(values) < 2:
+        return None
+    try:
+        return int(values[0]), int(values[1])
+    except (TypeError, ValueError):
+        return None
+
+
+def _should_reuse_recorded_window_relative_coords(fp: Any) -> bool:
+    """Décider si on doit remplacer la mémoire apprise par la position source.
+
+    Cette réécriture n'est légitime que pour les entrées faibles de type
+    `position_fallback`/`v4_unknown`, où la mémoire ne contient pas une vraie
+    localisation visuelle robuste mais seulement un clic écran dépendant de la
+    résolution. Pour les méthodes visuelles apprises (template, SoM, OCR...),
+    réinjecter un vieux `click_relative` source crée des collisions et des
+    dérives sur des boutons homonymes (`Enregistrer`, `OK`, etc.).
+    """
+    method = str(getattr(fp, "etype", "") or "").strip().lower()
+    return method in {"position_fallback", "v4_unknown"}
+
+
 class _TargetSpecLike:
     """Adaptateur dict → objet pour `TargetMemoryStore._hash_target_spec()`.
 
     Le hash interne de TargetMemoryStore utilise `getattr(spec, "by_role", ...)`
     qui ne fonctionne pas avec un dict brut. On expose les attributs nécessaires.
 
-    On intègre aussi `resolve_order` et `vlm_description` dans `context_hints`
-    pour qu'ils entrent dans le hash — deux actions avec le même `by_text`
-    mais un `resolve_order` différent doivent avoir des hashes distincts.
+    On intègre aussi `resolve_order`, `vlm_description` et des indices
+    spatiaux (SoM, click_relative) dans `context_hints` pour qu'ils entrent
+    dans le hash. Sinon, deux actions `Enregistrer` dans la même fenêtre
+    mais à des emplacements différents collisionnent.
     """
 
     __slots__ = ("by_role", "by_text", "by_position", "context_hints")
@@ -131,6 +169,21 @@ class _TargetSpecLike:
             hints["_vlm_desc"] = str(d["vlm_description"])
         if d.get("anchor_hint"):
             hints["_anchor_hint"] = str(d["anchor_hint"])
+
+        som_element = d.get("som_element") or {}
+        som_bbox = _round_float_list(som_element.get("bbox_norm"))
+        if som_bbox:
+            hints["_som_bbox"] = som_bbox
+        som_center = _round_float_list(som_element.get("center_norm"), precision=5)
+        if som_center:
+            hints["_som_center"] = som_center
+
+        window_capture = d.get("window_capture") or {}
+        click_relative = _int_pair(window_capture.get("click_relative"))
+        window_size = _int_pair(window_capture.get("window_size"))
+        if click_relative and window_size:
+            hints["_window_rel"] = f"{click_relative[0]},{click_relative[1]}@{window_size[0]}x{window_size[1]}"
+
         self.context_hints = hints
 
 
@@ -176,6 +229,46 @@ def memory_lookup(
         logger.debug("memory_lookup: fingerprint bbox invalide")
         return None
 
+    # Quand l'entrée mémoire provient d'un simple `position_fallback`, les
+    # coordonnées stockées reflètent surtout la géométrie écran source. Dans
+    # ce cas précis, réutiliser la position relative enregistrée dans la
+    # fenêtre source reste préférable si elle existe.
+    #
+    # En revanche, pour une méthode visuelle réellement apprise
+    # (`anchor_template`, `som_*`, `hybrid_text_direct`, ...), remplacer les
+    # coords mémorisées par un vieux `click_relative` crée des dérives sur
+    # des cibles textuelles homonymes. On garde donc les coords apprises.
+    window_capture = target_spec.get("window_capture") or {}
+    click_relative = window_capture.get("click_relative")
+    window_size = window_capture.get("window_size")
+    if (
+        _should_reuse_recorded_window_relative_coords(fp)
+        and (
+        isinstance(click_relative, (list, tuple))
+        and len(click_relative) >= 2
+        and isinstance(window_size, (list, tuple))
+        and len(window_size) >= 2
+        )
+    ):
+        try:
+            rel_x = float(click_relative[0])
+            rel_y = float(click_relative[1])
+            win_w = float(window_size[0])
+            win_h = float(window_size[1])
+            if win_w > 1 and win_h > 1:
+                x_pct = rel_x / win_w
+                y_pct = rel_y / win_h
+                logger.info(
+                    "memory_lookup: coords fenêtre source réutilisées "
+                    "(click_relative=%s, window_size=%s) -> (%.4f, %.4f)",
+                    click_relative,
+                    window_size,
+                    x_pct,
+                    y_pct,
+                )
+        except (TypeError, ValueError, ZeroDivisionError):
+            logger.debug("memory_lookup: window_capture invalide, fallback bbox")
+
     # Sanity check : les pourcentages doivent être dans [0, 1]
     if not (0.0 <= x_pct <= 1.0 and 0.0 <= y_pct <= 1.0):
         logger.warning(