fix(agent): capture JPEG+downscale (allege CPU/disque, frequence intacte) + robustesse chemin _background/shots

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

agent_v0/agent_v1/vision/capture_io.py

@@ -0,0 +1,110 @@
+"""Politique de sauvegarde des captures — réduction du poids disque.
+
+Constat : tous les shots étaient sauvés en PNG plein écran lossless
+(``img.save(path, "PNG", quality=...)`` — PNG ignore ``quality``), d'où
+~90 Go pour 13 sessions. La majorité de ce poids n'a aucune valeur de
+grounding (full + full_blurred en doublon, heartbeats plein écran).
+
+Cette politique distingue le **type** de shot et écrit le format adapté :
+
+- ``crop``      → PNG lossless. C'est la cible de grounding qwen3-vl ; on
+  préserve chaque pixel (perte JPEG = bruit sur de petites icônes). Le crop
+  fait 80×80 → poids négligeable, aucun intérêt à le dégrader.
+- ``full`` / ``window`` / ``context`` → JPEG ``quality=SCREENSHOT_QUALITY,
+  optimize=True``. Ce sont des vues contextuelles / humaines : la
+  compression JPEG (~5-10x) est sans impact fonctionnel.
+- ``heartbeat`` → JPEG **downscalé** (largeur max ``HEARTBEAT_MAX_WIDTH``,
+  ratio préservé). C'est de la *liveness* (le serveur vérifie juste qu'un
+  écran a changé), pas du grounding → la pleine résolution est du gaspillage.
+
+``save_capture`` retourne le chemin RÉELLEMENT écrit, extension ajustée selon
+le format. L'appelant doit utiliser ce retour (et non un chemin ``.png``
+présumé) pour streamer / référencer le bon fichier.
+
+⚠️ Contrat avec le serveur : l'extension du crop NE DOIT PAS changer (le
+serveur retrouve le crop par basename via ``vision_info.crop`` — voir
+``stream_processor._extract_crop_b64`` stratégie 1). C'est pourquoi ``crop``
+reste PNG. Les full/window/context/heartbeat sont retrouvés par
+``screenshot_id`` avec extension ``.png`` hardcodée côté serveur, mais le
+serveur réécrit toujours l'upload sous ``{shot_id}.png`` (le suffixe envoyé
+sur le fil est ignoré) → changer l'extension LOCALE de ces types est sûr.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Iterable
+
+from PIL import Image
+
+from ..config import SCREENSHOT_QUALITY
+
+# Types sauvés en JPEG (vue contextuelle / humaine, pas de grounding pixel).
+_JPEG_KINDS: frozenset = frozenset({"full", "window", "context"})
+
+# Largeur max d'un heartbeat downscalé. 1280 px suffit largement pour de la
+# liveness (détecter qu'un écran a changé) ; on divise le poids d'un 2560 px
+# par ~4 (surface) avant compression JPEG.
+HEARTBEAT_MAX_WIDTH = 1280
+
+
+def _ensure_jpeg_ready(img: Image.Image) -> Image.Image:
+    """Convertit en RGB si nécessaire (JPEG ne supporte ni alpha ni palette)."""
+    if img.mode in ("RGBA", "LA", "P"):
+        return img.convert("RGB")
+    return img
+
+
+def _downscale_to_width(img: Image.Image, max_width: int) -> Image.Image:
+    """Réduit l'image à ``max_width`` en préservant le ratio (no-op si plus petite)."""
+    if img.width <= max_width:
+        return img
+    new_height = max(1, round(img.height * max_width / img.width))
+    return img.resize((max_width, new_height), Image.LANCZOS)
+
+
+def save_capture(img: Image.Image, path_base: str, kind: str) -> str:
+    """Sauve ``img`` selon la politique du ``kind`` et retourne le chemin écrit.
+
+    Args:
+        img: image PIL à sauvegarder.
+        path_base: chemin SANS extension (ex.
+            ``.../shots/shot_0001_full``). L'extension finale (``.png`` ou
+            ``.jpg``) est ajoutée par la politique.
+        kind: type de shot — ``"crop"`` | ``"full"`` | ``"window"`` |
+            ``"context"`` | ``"heartbeat"``.
+
+    Returns:
+        Le chemin RÉELLEMENT écrit, avec la bonne extension.
+
+    Raises:
+        ValueError: si ``kind`` n'est pas reconnu (fail-closed : on refuse
+            d'écrire un fichier dont la politique est indéterminée).
+    """
+    if kind == "crop":
+        out_path = f"{path_base}.png"
+        img.save(out_path, "PNG")
+        return out_path
+
+    if kind in _JPEG_KINDS:
+        out_path = f"{path_base}.jpg"
+        _ensure_jpeg_ready(img).save(
+            out_path, "JPEG", quality=SCREENSHOT_QUALITY, optimize=True
+        )
+        return out_path
+
+    if kind == "heartbeat":
+        out_path = f"{path_base}.jpg"
+        small = _downscale_to_width(_ensure_jpeg_ready(img), HEARTBEAT_MAX_WIDTH)
+        small.save(out_path, "JPEG", quality=SCREENSHOT_QUALITY)
+        return out_path
+
+    raise ValueError(
+        f"kind de capture inconnu : {kind!r} "
+        f"(attendu: crop, full, window, context, heartbeat)"
+    )
+
+
+def known_kinds() -> Iterable[str]:
+    """Retourne les ``kind`` supportés (utile pour la validation appelant)."""
+    return ("crop", *sorted(_JPEG_KINDS), "heartbeat")

agent_v0/agent_v1/vision/capturer.py

@@ -18,8 +18,9 @@ import platform
 from typing import Any, Dict, List, Optional, Tuple
 from PIL import Image, ImageFilter, ImageStat
 import mss
-from ..config import TARGETED_CROP_SIZE, SCREENSHOT_QUALITY, BLUR_SENSITIVE
+from ..config import TARGETED_CROP_SIZE, BLUR_SENSITIVE
 from .blur_sensitive import blur_sensitive_regions
+from .capture_io import save_capture
 
 logger = logging.getLogger(__name__)
 
@@ -425,6 +426,18 @@ class VisionCapturer:
         # On ne crée plus self.sct ici car mss n'est pas thread-safe sous Windows
         self.last_img_hash = None
 
+    def _ensure_shots_dir(self) -> None:
+        """Garantit l'existence de `shots/` avant toute écriture.
+
+        Le dossier est créé dans `__init__`, mais l'auto-cleanup de
+        `SessionStorage` (`shutil.rmtree` par âge/taille) peut supprimer tout
+        le dossier de session — y compris la session permanente `_background`.
+        Sans ce garde, la capture suivante lève `[Errno 2] No such file or
+        directory` (bug observé poste Émilie). On recrée donc le répertoire
+        cible juste avant chaque sauvegarde.
+        """
+        os.makedirs(self.shots_dir, exist_ok=True)
+
     def capture_full_context(self, name_suffix: str, force=False) -> str:
         """
         Capture l'écran complet.
@@ -460,9 +473,15 @@ class VisionCapturer:
             if BLUR_SENSITIVE:
                 blur_sensitive_regions(img)
 
-            path = os.path.join(self.shots_dir, f"context_{int(time.time())}_{name_suffix}.png")
-            img.save(path, "PNG", quality=SCREENSHOT_QUALITY)
-            return path
+            # Politique d'écriture : les heartbeats sont de la liveness pure
+            # (le serveur vérifie juste qu'un écran a changé) → JPEG downscalé.
+            # Les autres contextes (focus_change, result_of_*) → JPEG q85.
+            kind = "heartbeat" if "heartbeat" in name_suffix else "context"
+            self._ensure_shots_dir()
+            path_base = os.path.join(
+                self.shots_dir, f"context_{int(time.time())}_{name_suffix}"
+            )
+            return save_capture(img, path_base, kind)
         except Exception as e:
             logger.error(f"Erreur Context Capture: {e}")
             return ""
@@ -506,10 +525,10 @@ class VisionCapturer:
                     return result
                 return {}
 
-            full_path = os.path.join(self.shots_dir, f"{screenshot_id}_full.png")
+            full_base = os.path.join(self.shots_dir, f"{screenshot_id}_full")
 
             # Capture du Crop (Cœur de l'apprentissage qwen3-vl)
-            crop_path = os.path.join(self.shots_dir, f"{screenshot_id}_crop.png")
+            crop_base = os.path.join(self.shots_dir, f"{screenshot_id}_crop")
             w, h = TARGETED_CROP_SIZE
             left = max(0, x - w // 2)
             top = max(0, y - h // 2)
@@ -523,8 +542,11 @@ class VisionCapturer:
                 blur_sensitive_regions(img)
                 blur_sensitive_regions(crop_img)
 
-            img.save(full_path, "PNG", quality=SCREENSHOT_QUALITY)
-            crop_img.save(crop_path, "PNG", quality=SCREENSHOT_QUALITY)
+            # Politique d'écriture : full = vue contextuelle → JPEG q85 ;
+            # crop = cible de grounding qwen3-vl → PNG lossless (contrat serveur).
+            self._ensure_shots_dir()
+            full_path = save_capture(img, full_base, "full")
+            crop_path = save_capture(crop_img, crop_base, "crop")
 
             # Mise à jour du hash pour le prochain heartbeat
             self.last_img_hash = self._compute_quick_hash(img)
@@ -648,11 +670,12 @@ class VisionCapturer:
             if BLUR_SENSITIVE:
                 blur_sensitive_regions(window_img)
 
-            # Sauvegarde
-            window_path = os.path.join(
-                self.shots_dir, f"{screenshot_id}_window.png"
+            # Sauvegarde — fenêtre = vue contextuelle → JPEG q85 (politique).
+            self._ensure_shots_dir()
+            window_base = os.path.join(
+                self.shots_dir, f"{screenshot_id}_window"
             )
-            window_img.save(window_path, "PNG", quality=SCREENSHOT_QUALITY)
+            window_path = save_capture(window_img, window_base, "window")
 
             result = {
                 "window_image": window_path,