feat(tools): add 7 wired+bench utility scripts (A+B classification)

- A (wired, imports project modules): e2e_map_roles, anonymize_demo, grounding_e2e_resolve_engine
- B (orphan projection, standalone benches): enrichment_eval_multi, extract_easily_bench_cases, extract_record_bench_cases, grounding_eval_multi

.env.example

@@ -30,7 +30,9 @@ DASHBOARD_PORT=5001
 CLIP_MODEL=ViT-B-32
 CLIP_PRETRAINED=openai
 CLIP_DEVICE=cpu  # cpu or cuda
-VLM_MODEL=qwen3-vl:8b
+RPA_VLM_MODEL=gemma4:latest  # gemma4:latest (défaut), qwen3-vl:8b, ui-tars (fallback)
+VLM_MODEL=gemma4:latest      # alias de compatibilité
+# VLM_ALLOW_CLOUD=false      # true pour activer les APIs cloud en fallback (OpenAI, Gemini, Anthropic)
 VLM_ENDPOINT=http://localhost:11434
 OWL_MODEL=google/owlv2-base-patch16-ensemble
 OWL_CONFIDENCE_THRESHOLD=0.1
@@ -44,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
 # ============================================================================

.gitea/workflows/security-audit.yml

@@ -0,0 +1,207 @@
+# ------------------------------------------------------------------
+# Audit sécurité — bandit + pip-audit + scan secrets
+# ------------------------------------------------------------------
+# Jamais bloquant : on reporte les warnings, on ne casse pas la CI.
+# Utile pour détecter les dérives progressives (nouveaux CVE, secrets
+# oubliés dans un commit, patterns risqués).
+#
+# Fréquence : à chaque push sur main + hebdo (cron).
+# ------------------------------------------------------------------
+name: security-audit
+
+on:
+  push:
+    branches:
+      - main
+  schedule:
+    # Tous les lundis à 6h UTC (8h Paris hiver, 7h Paris été).
+    - cron: "0 6 * * 1"
+  workflow_dispatch: {}
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  # ----------------------------------------------------------------
+  # Job 1 — bandit (bonnes pratiques sécu Python)
+  # ----------------------------------------------------------------
+  bandit:
+    name: Bandit (scan statique)
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    continue-on-error: true
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Python 3.12
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: "pip"
+
+      - name: Installation bandit
+        run: |
+          python -m pip install --upgrade pip
+          pip install "bandit[toml]==1.7.10"
+
+      - name: Scan bandit sur core/
+        run: |
+          # -ll : niveau LOW minimum (remonte tout)
+          # -ii : confiance LOW minimum
+          # --skip B101 : on ignore les asserts (usuels en tests/validation)
+          bandit -r core/ \
+            --skip B101,B404,B603 \
+            --format txt \
+            --exit-zero \
+            --output bandit-report.txt
+          echo "=== RAPPORT BANDIT ==="
+          cat bandit-report.txt
+
+      - name: Upload rapport bandit
+        if: always()
+        uses: actions/upload-artifact@v3
+        with:
+          name: bandit-report
+          path: bandit-report.txt
+          retention-days: 30
+          if-no-files-found: ignore
+
+  # ----------------------------------------------------------------
+  # Job 2 — pip-audit (CVE sur requirements)
+  # ----------------------------------------------------------------
+  pip-audit:
+    name: pip-audit (CVE dépendances)
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    continue-on-error: true
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Python 3.12
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: "pip"
+
+      - name: Installation pip-audit
+        run: |
+          python -m pip install --upgrade pip
+          pip install "pip-audit==2.7.3"
+
+      - name: Audit CVE sur requirements-ci.txt
+        run: |
+          if [ -f requirements-ci.txt ]; then
+            pip-audit -r requirements-ci.txt \
+              --format json \
+              --output pip-audit-ci.json \
+              --progress-spinner off \
+              --disable-pip || echo "::warning::CVE détectées dans requirements-ci.txt"
+            echo "=== RAPPORT pip-audit (CI) ==="
+            cat pip-audit-ci.json || true
+          else
+            echo "::notice::requirements-ci.txt absent — skip"
+          fi
+
+      - name: Audit CVE sur requirements.txt (best-effort)
+        run: |
+          # Timeout généreux car requirements.txt est massif (torch, CUDA).
+          timeout 120 pip-audit -r requirements.txt \
+            --format json \
+            --output pip-audit-full.json \
+            --progress-spinner off \
+            --disable-pip 2>&1 | head -200 || \
+            echo "::warning::pip-audit sur requirements.txt a timeout ou échoué (non bloquant)"
+
+      - name: Upload rapports pip-audit
+        if: always()
+        uses: actions/upload-artifact@v3
+        with:
+          name: pip-audit-reports
+          path: |
+            pip-audit-ci.json
+            pip-audit-full.json
+          retention-days: 30
+          if-no-files-found: ignore
+
+  # ----------------------------------------------------------------
+  # Job 3 — Scan secrets en clair (grep simple)
+  # ----------------------------------------------------------------
+  # Patterns recherchés : clés API Anthropic (sk-ant-), OpenAI (sk-),
+  # Google (AIzaSy), AWS (AKIA), tokens Hugging Face (hf_).
+  # Ne cherche QUE dans les fichiers trackés (pas .env, pas .venv).
+  # ----------------------------------------------------------------
+  secrets-scan:
+    name: Scan secrets (grep)
+    runs-on: ubuntu-latest
+    timeout-minutes: 3
+    continue-on-error: true
+
+    steps:
+      - name: Checkout (historique complet)
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Scan patterns de secrets
+        run: |
+          # Chemins exclus : venvs, caches, data, htmlcov, models.
+          EXCLUDES='--exclude-dir=.venv --exclude-dir=venv_v3 --exclude-dir=.git \
+            --exclude-dir=node_modules --exclude-dir=htmlcov --exclude-dir=models \
+            --exclude-dir=data --exclude-dir=__pycache__ --exclude-dir=.pytest_cache \
+            --exclude=*.lock --exclude=*.log --exclude=*.md'
+
+          echo "=== Recherche de secrets potentiels ==="
+          FOUND=0
+
+          # Anthropic
+          if grep -rnI $EXCLUDES -E 'sk-ant-[a-zA-Z0-9_-]{20,}' . 2>/dev/null; then
+            echo "::warning::Clé Anthropic potentielle détectée"
+            FOUND=1
+          fi
+
+          # OpenAI
+          if grep -rnI $EXCLUDES -E 'sk-proj-[a-zA-Z0-9_-]{20,}|sk-[a-zA-Z0-9]{40,}' . 2>/dev/null; then
+            echo "::warning::Clé OpenAI potentielle détectée"
+            FOUND=1
+          fi
+
+          # Google Cloud / API Keys
+          if grep -rnI $EXCLUDES -E 'AIzaSy[a-zA-Z0-9_-]{33}' . 2>/dev/null; then
+            echo "::warning::Clé Google API potentielle détectée"
+            FOUND=1
+          fi
+
+          # AWS
+          if grep -rnI $EXCLUDES -E 'AKIA[0-9A-Z]{16}' . 2>/dev/null; then
+            echo "::warning::Clé AWS potentielle détectée"
+            FOUND=1
+          fi
+
+          # Hugging Face
+          if grep -rnI $EXCLUDES -E 'hf_[a-zA-Z0-9]{30,}' . 2>/dev/null; then
+            echo "::warning::Token Hugging Face potentiel détecté"
+            FOUND=1
+          fi
+
+          # Mots-clés suspects à côté d'assignations
+          if grep -rnI $EXCLUDES -E '(password|passwd|secret|api_key|apikey|token)\s*=\s*["\x27][a-zA-Z0-9_\-!@#\$%]{12,}["\x27]' . 2>/dev/null \
+              | grep -viE '(example|dummy|placeholder|test|fake|xxx|changeme|\$\{)' 2>/dev/null; then
+            echo "::warning::Assignation suspecte d'un secret détectée"
+            FOUND=1
+          fi
+
+          if [ "$FOUND" -eq 0 ]; then
+            echo "Aucun secret détecté par les patterns de base."
+          else
+            echo ""
+            echo "::notice::Vérifier manuellement les occurrences ci-dessus."
+            echo "::notice::Si faux positif : ajouter le fichier aux exclusions ou reformater."
+          fi
+
+          # Toujours succès (job non bloquant).
+          exit 0

.gitea/workflows/tests.yml

@@ -0,0 +1,214 @@
+# ------------------------------------------------------------------
+# CI principale — Tests unitaires + lint léger
+# ------------------------------------------------------------------
+# Déclenchement : push / pull_request sur n'importe quelle branche.
+# Objectif     : feedback rapide (< 3 min) sans GPU ni Ollama.
+# Runner       : self-hosted (label "ubuntu-latest" ou équivalent).
+#
+# Les tests marqués `slow`, `gpu`, `integration`, `performance`,
+# `visual` et `smoke` sont exclus volontairement — ils nécessitent
+# CUDA, Ollama, ou des captures d'écran réelles.
+# ------------------------------------------------------------------
+name: tests
+
+on:
+  push:
+    branches:
+      - "**"
+  pull_request:
+    branches:
+      - "**"
+
+# Permet à une nouvelle exécution d'annuler les précédentes
+# sur la même branche (évite l'engorgement du runner local).
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  # Empêche l'import accidentel de torch/CUDA pendant la CI.
+  PYTHONDONTWRITEBYTECODE: "1"
+  PIP_DISABLE_PIP_VERSION_CHECK: "1"
+  PIP_NO_PYTHON_VERSION_WARNING: "1"
+  # Les modules d'exécution lisent parfois ces vars ; valeurs neutres en CI.
+  RPA_VISION_CI: "1"
+  RPA_AUTH_VAULT_PATH: "/tmp/ci_vault.enc"
+  # api_stream.py a un fail-closed P0-C : si RPA_API_TOKEN absent, sys.exit(1)
+  # au module load. On fournit un token bidon pour que les imports passent en CI.
+  # (Le token n'est jamais utilisé réellement — les tests mockent les requêtes.)
+  RPA_API_TOKEN: "ci_test_token_not_used_for_real_auth_just_to_pass_import_check_0123456789"
+
+jobs:
+  # ----------------------------------------------------------------
+  # Job 1 — Lint (ruff + black --check)
+  # ----------------------------------------------------------------
+  # Non-bloquant : si ruff/black ne sont pas installables, on log
+  # un warning et on continue. L'objectif ici est d'alerter, pas de
+  # casser la CI pour des espaces en trop.
+  # ----------------------------------------------------------------
+  lint:
+    name: Lint (ruff + black)
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    continue-on-error: true
+
+    steps:
+      - name: Checkout du code
+        uses: actions/checkout@v4
+
+      - name: Setup Python 3.12
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: "pip"
+
+      - name: Installation des linters
+        run: |
+          python -m pip install --upgrade pip
+          pip install "ruff==0.6.9" "black==23.12.1" || {
+            echo "::warning::Impossible d'installer ruff/black — job ignoré"
+            exit 0
+          }
+
+      - name: Ruff (lint rapide)
+        run: |
+          if command -v ruff >/dev/null 2>&1; then
+            # Ruff : erreurs critiques uniquement (E9 syntax, F63 invalid print,
+            # F7 syntax, F82 undefined in __all__).
+            # F821 (undefined name) volontairement exclu le temps de nettoyer
+            # la dette technique préexistante (voir docs/STATUS.md).
+            # Dossiers legacy exclus :
+            #   - agent_v0/deploy/windows_client/ : clone obsolète (marqué OBSOLÈTE)
+            #   - tests/property/ : tests cassés connus (cf. MEMORY.md)
+            ruff check --select=E9,F63,F7,F82 --output-format=github \
+              --exclude "agent_v0/deploy/windows_client" \
+              --exclude "tests/property" \
+              --exclude "tests/integration/test_visual_rpa_checkpoint.py" \
+              core/ agent_v0/ tests/ || {
+                echo "::warning::Ruff a trouvé des erreurs critiques"
+                exit 1
+              }
+          else
+            echo "::warning::ruff indisponible — skip"
+          fi
+
+      - name: Black (format check)
+        run: |
+          if command -v black >/dev/null 2>&1; then
+            # --check : ne modifie pas, signale juste.
+            # Dossiers legacy exclus (cohérent avec ruff).
+            black --check --diff \
+              --exclude "agent_v0/deploy/windows_client|tests/property" \
+              core/ agent_v0/ tests/ || {
+              echo "::warning::Black suggère un reformatage — non bloquant"
+              exit 0
+            }
+          else
+            echo "::warning::black indisponible — skip"
+          fi
+
+  # ----------------------------------------------------------------
+  # Job 2 — Tests unitaires
+  # ----------------------------------------------------------------
+  # Exclut tous les marqueurs lourds. Utilise requirements-ci.txt
+  # pour éviter torch/CUDA (économie ~3 Go + ~2 min).
+  # ----------------------------------------------------------------
+  unit-tests:
+    name: Tests unitaires (sans GPU)
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    steps:
+      - name: Checkout du code
+        uses: actions/checkout@v4
+
+      - name: Setup Python 3.12
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: "pip"
+          cache-dependency-path: |
+            requirements-ci.txt
+            requirements.txt
+
+      - name: Installation des dépendances CI
+        run: |
+          python -m pip install --upgrade pip
+          if [ -f requirements-ci.txt ]; then
+            echo "Utilisation de requirements-ci.txt (léger, sans torch)"
+            pip install -r requirements-ci.txt
+          else
+            echo "::warning::requirements-ci.txt absent — fallback requirements.txt (lourd)"
+            pip install -r requirements.txt
+          fi
+
+      - name: Vérification imports critiques
+        run: |
+          python -c "import pytest; print(f'pytest {pytest.__version__}')"
+          python -c "import sys; sys.path.insert(0, '.'); import core; print('core OK')" || {
+            echo "::error::Impossible d'importer core.*"
+            exit 1
+          }
+
+      - name: Tests unitaires (hors slow/gpu/integration)
+        run: |
+          python -m pytest tests/unit/ \
+            -m "not slow and not gpu and not integration and not performance and not visual" \
+            --tb=short \
+            --strict-markers \
+            -q \
+            --maxfail=10 \
+            -o cache_dir=/tmp/.pytest_cache_ci
+
+      - name: Upload logs si échec
+        if: failure()
+        uses: actions/upload-artifact@v3
+        with:
+          name: pytest-logs
+          path: |
+            /tmp/.pytest_cache_ci
+            logs/
+          retention-days: 3
+          if-no-files-found: ignore
+
+  # ----------------------------------------------------------------
+  # Job 3 — Tests sécurité (bloquant)
+  # ----------------------------------------------------------------
+  # Les tests `test_security_*` valident des invariants critiques
+  # (évaluation sûre, sérialisation signée). Aucune régression tolérée.
+  # ----------------------------------------------------------------
+  security-tests:
+    name: Tests sécurité (critique)
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    needs: [unit-tests]
+
+    steps:
+      - name: Checkout du code
+        uses: actions/checkout@v4
+
+      - name: Setup Python 3.12
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: "pip"
+          cache-dependency-path: |
+            requirements-ci.txt
+            requirements.txt
+
+      - name: Installation des dépendances CI
+        run: |
+          python -m pip install --upgrade pip
+          if [ -f requirements-ci.txt ]; then
+            pip install -r requirements-ci.txt
+          else
+            pip install -r requirements.txt
+          fi
+
+      - name: Tests sécurité (test_security_*)
+        run: |
+          python -m pytest tests/unit/test_security_*.py \
+            --tb=long \
+            --strict-markers \
+            -v \
+            -o cache_dir=/tmp/.pytest_cache_ci_sec

.gitignore

@@ -1,70 +1,146 @@
-# Python
+# === Python ===
 __pycache__/
 *.py[cod]
-*$py.class
-*.so
-.Python
-venv*/
-env/
-.venv/
+*.pyo
 *.egg-info/
+*.egg
 dist/
 build/
+*.whl
 
-# Data
-data/
-instance/
+# === Virtual environments ===
+.venv/
+venv/
+venv_*/
+env/
+
+# === ML Models & Data ===
+*.pt
+*.pth
+*.onnx
+*.bin
+*.safetensors
+*.h5
+*.hdf5
+*.pkl
+*.pickle
 *.npy
+*.npz
 *.faiss
-*.db
+models/
+*.tar.gz
+*.zip
 
-# IDE
-.vscode/
+# === Documents & Media ===
+*.pdf
+*.docx
+*.xlsx
+*.csv
+*.png
+*.jpg
+*.jpeg
+*.gif
+*.mp3
+*.wav
+*.mp4
+
+# === IDE ===
 .idea/
+.vscode/
 *.swp
 *.swo
 *~
 
-# Tests
-.pytest_cache/
-.hypothesis/
-.coverage
-htmlcov/
-.tox/
-
-# Logs
-logs/
-*.log
-
-# Environment
-.env
-.env.local
-.env.*.local
-
-# Temporary
-*.tmp
-*.bak
-*.zip
-.~lock.*
-*.pid
-
-# OS
+# === OS ===
 .DS_Store
 Thumbs.db
+.~lock.*
 
-# Project specific
-.snapshots/
-.kiro/
-.mcp.json
+# === Secrets ===
+.env
+.env.*
+*.env
+credentials.json
+token.pickle
+
+# === Logs & Cache ===
+*.log
+logs/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+htmlcov/
+.coverage
+
+# === Backups ===
+*_backup_*
+*.db.backup_*
+backups/
+*.bak
+*.bak_*
+*.orig
+*.old
+
+# === Legacy / Triage ===
+_a_trier/
 archives/
-backups*/
-frontend_broken*/
 
-# Node
-node_modules/
+# === Claude Code — worktrees et données locales ===
+# Worktrees générés par la CLI Claude Code lors d'exécutions d'agents
+# parallèles. Peuvent atteindre plusieurs centaines de Mo chacun.
+# Ne jamais committer — gérer via `git worktree list` / `git worktree remove`.
+.claude/
+.kiro/
+.antigravitycli/
+.playwright-cli/
+.qwen/
+.mcp.json
+.snapshots/
 
-# Models (large files)
-models/*.pt
-models/*.pth
-models/*.onnx
-*.safetensors
+# === Données runtime (sessions, learning, buffer, config local) ===
+data/
+**/capture_library.json
+.hypothesis/
+.deps_installed
+# Buffers SQLite locaux (streamer, cache)
+**/buffer/
+**/pending_events.db
+# Databases applicatives (instance Flask)
+**/instance/*.db
+**/instance/*.sqlite
+**/instance/*.sqlite3
+# Caches et index locaux
+*.sqlite
+*.sqlite3
+*.db-journal
+*.db-wal
+*.db-shm
+web_dashboard/static/analytics/*.bpmn
+results_vlm_bench.json
+
+# Scripts locaux one-shot d'intervention/bench, non réutilisables tels quels.
+tools/bench_qwen35_evidence.py
+tools/codex_windows_correction_rapport.py
+tools/diagnostic_lea_chat_win11.ps1
+tools/poc_lecture_ecran.py
+tools/watch_emilie_agent.py
+test_sanitizer_live.py
+# Verbatims clients (sensibles, à valider avant push)
+docs/clients/
+
+.qw-baseline.log
+# Coordination ephemeral — inbox messages, active decisions, loop state
+docs/coordination/.loop_state/
+docs/coordination/.inbox_baseline.txt
+docs/coordination/.loop_log.txt
+docs/coordination/inbox_qwen/
+docs/coordination/inbox_codex/
+docs/coordination/inbox_claude/
+docs/coordination/active/
+
+# Runtime Python embedded pour l'installateur Inno Setup (local, ~11M, non versionné)
+deploy/installer/python-3.12-embed/
+deploy/installer/python-3.12.8-embed-amd64.zip
+# Artefacts de build installateur (EXE compilés + staging) — non versionnés
+deploy/releases/*.exe
+deploy/build/

.vite/deps/_metadata.json

@@ -0,0 +1,8 @@
+{
+  "hash": "cccc2566",
+  "configHash": "0c083961",
+  "lockfileHash": "e3b0c442",
+  "browserHash": "764a8433",
+  "optimized": {},
+  "chunks": {}
+}

.vite/deps/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

AGENTS.md

@@ -0,0 +1,24 @@
+## graphify
+
+This project has a knowledge graph at graphify-out/ with god nodes, community structure, and cross-file relationships.
+
+When the user types `/graphify`, invoke the `skill` tool with `skill: "graphify"` before doing anything else.
+
+Rules:
+- For codebase questions, first run `graphify query "<question>"` when graphify-out/graph.json exists. Use `graphify path "<A>" "<B>"` for relationships and `graphify explain "<concept>"` for focused concepts. These return a scoped subgraph, usually much smaller than GRAPH_REPORT.md or raw grep output.
+- Dirty graphify-out/ files are expected after hooks or incremental updates; dirty graph files are not a reason to skip graphify. Only skip graphify if the task is about stale or incorrect graph output, or the user explicitly says not to use it.
+- If graphify-out/wiki/index.md exists, use it for broad navigation instead of raw source browsing.
+- Read graphify-out/GRAPH_REPORT.md only for broad architecture review or when query/path/explain do not surface enough context.
+- After modifying code, run `graphify update .` to keep the graph current (AST-only, no API cost).
+
+## coordination watcher
+
+At the beginning of every session, the coordination watcher is mandatory and must be operational for Codex, Claude, and Qwen before coordination work continues.
+
+Session-start checklist:
+- Run `docs/coordination/coordination_loop.sh ensure`.
+- Read every pending message relevant to the current agent.
+- After messages are processed, run `docs/coordination/coordination_loop.sh ack`.
+- If the watcher cannot be started or checked, report that blocker immediately in the handoff/status response.
+
+Every new handoff or restart prompt must include this watcher requirement by default.

AGENT_UPLOAD_FIX_COMPLETE.md

@@ -1,271 +0,0 @@
-# Agent Upload Real Functionality Test - Complete Implementation
-
-**Date**: January 6, 2026  
-**Status**: ✅ COMPLETE
-
-## 🎯 Objective
-
-Transform the `test_agent_uploader_direct.py` test from a basic simulation to a comprehensive real functionality test that validates the complete agent upload flow without mocks or simulations.
-
-## ✅ Improvements Implemented
-
-### 1. **Realistic Session Data Creation**
-
-**Before**: Used dummy binary PNG data and minimal session structure
-```python
-# Old approach - dummy data
-png_data = b'\x89PNG\r\n\x1a\n...'  # Hard-coded binary
-```
-
-**After**: Creates authentic session data using real system information
-```python
-# New approach - real data
-def create_realistic_session():
-    # Real platform detection
-    hostname = socket.gethostname()
-    platform_name = platform.system().lower()
-    
-    # Real screenshot creation with PIL
-    img = Image.new('RGB', (800, 600), color='white')
-    draw = ImageDraw.Draw(img)
-    # Add realistic UI elements...
-```
-
-**Benefits**:
-- ✅ Uses actual system information (hostname, platform, Python version)
-- ✅ Creates real PNG screenshots with simulated UI elements
-- ✅ Includes proper event timing and realistic user interactions
-- ✅ Tests with authentic file sizes and data structures
-
-### 2. **Server Integration Validation**
-
-**Before**: Only tested upload success/failure
-```python
-success = upload_session_zip(str(zip_path), session_id)
-```
-
-**After**: Comprehensive server-side validation
-```python
-def validate_server_response(session_id: str, original_session_data: dict):
-    # Check server status
-    # Validate session was stored correctly
-    # Verify data integrity
-    # Confirm processing pipeline triggered
-```
-
-**Benefits**:
-- ✅ Validates server receives and processes data correctly
-- ✅ Checks data integrity end-to-end
-- ✅ Verifies session appears in server's session list
-- ✅ Confirms event and screenshot counts match
-
-### 3. **Real Component Integration**
-
-**Before**: Limited to agent uploader only
-
-**After**: Tests complete system integration
-```python
-def test_agent_uploader_integration():
-    # 1. Check server availability
-    # 2. Create realistic session
-    # 3. Test agent uploader
-    # 4. Validate server processing
-    # 5. Check data model compatibility
-```
-
-**Benefits**:
-- ✅ Tests real server API endpoints
-- ✅ Validates complete upload → processing → storage flow
-- ✅ Checks compatibility with core RPA Vision V3 models
-- ✅ Tests retry logic and error handling
-
-### 4. **Data Model Compatibility Testing**
-
-**New Feature**: Validates compatibility with core models
-```python
-def test_data_model_compatibility():
-    # Import core RawSession model
-    from core.models.raw_session import RawSession
-    
-    # Validate test data can be loaded by real models
-    raw_session = RawSession.from_dict(session_dict)
-```
-
-**Benefits**:
-- ✅ Ensures test data matches production data structures
-- ✅ Validates schema compatibility
-- ✅ Tests integration with core RPA Vision V3 components
-
-### 5. **Comprehensive Error Handling**
-
-**Before**: Basic try/catch with minimal feedback
-
-**After**: Detailed error reporting and diagnostics
-```python
-def check_server_availability():
-    # Test server connectivity
-    # Provide helpful error messages
-    # Suggest solutions for common issues
-```
-
-**Benefits**:
-- ✅ Clear error messages with actionable solutions
-- ✅ Server availability checking before tests
-- ✅ Detailed validation feedback
-- ✅ Proper cleanup in all scenarios
-
-## 📊 Test Coverage Improvements
-
-### Before
-- ✅ Basic upload functionality
-- ❌ No server validation
-- ❌ Dummy test data
-- ❌ No integration testing
-- ❌ Limited error scenarios
-
-### After
-- ✅ Complete upload flow testing
-- ✅ Server-side processing validation
-- ✅ Realistic session data creation
-- ✅ End-to-end integration testing
-- ✅ Data model compatibility
-- ✅ Retry logic testing
-- ✅ Comprehensive error handling
-- ✅ Server availability checking
-- ✅ Data integrity validation
-
-## 🔧 Real Components Tested
-
-### Agent V0 Components
-- ✅ `uploader.py` - Real upload logic with retry
-- ✅ Session data structure creation
-- ✅ ZIP file creation and compression
-- ✅ Authentication handling (disabled mode)
-- ✅ Environment variable configuration
-
-### Server Components
-- ✅ `api_upload.py` - Upload endpoint
-- ✅ Session storage and validation
-- ✅ Processing pipeline integration
-- ✅ Data integrity checks
-- ✅ Status and session listing endpoints
-
-### Core Models
-- ✅ `RawSession` data model compatibility
-- ✅ Schema version validation
-- ✅ Event and screenshot structure
-- ✅ Metadata handling
-
-## 🚀 Usage Instructions
-
-### Prerequisites
-1. Start the server:
-   ```bash
-   python server/api_upload.py
-   ```
-
-2. Ensure environment is set up:
-   ```bash
-   pip install -r requirements.txt
-   ```
-
-### Running the Test
-```bash
-python test_agent_uploader_direct.py
-```
-
-### Expected Output
-```
-🤖 Real Functionality Test: Agent V0 Uploader Integration
-============================================================
-Testing complete upload flow with real components:
-• Real agent uploader with retry logic
-• Real server API with processing pipeline
-• Real file system operations
-• Real session data structures
-• End-to-end data integrity validation
-============================================================
-
-✅ Server is running: online
-
-📝 Creating realistic test session...
-✅ Session created: sess_20260106T143022_realtest
-   ZIP path: /tmp/tmp_xyz/sess_20260106T143022_realtest.zip
-   ZIP size: 15,234 bytes
-   Events: 4
-   Screenshots: 3
-   Auth disabled: true
-   Server URL: http://127.0.0.1:8000/api/traces/upload
-
-📤 Testing agent uploader...
-✅ Upload completed in 0.85 seconds
-
-🔍 Validating server-side processing...
-✅ Session found in server: sess_20260106T143022_realtest
-✅ Events count matches: 4
-✅ Screenshots count matches: 3
-✅ User ID matches: real_test_user
-✅ Server-side validation passed!
-
-🔍 Testing data model compatibility...
-✅ RawSession created successfully
-   Session ID: sess_20260106T143022_realtest
-   Events: 4
-   Screenshots: 3
-   Schema version: rawsession_v1
-
-============================================================
-🎉 ALL TESTS PASSED!
-✅ Agent uploader integration works correctly
-✅ Server processes uploads properly
-✅ Data integrity is maintained end-to-end
-✅ Data models are compatible
-
-The agent can now upload sessions and the server
-can process them through the complete pipeline.
-============================================================
-```
-
-## 🎯 Key Achievements
-
-### Real Functionality Testing
-- ✅ **No Mocks**: Uses actual agent and server components
-- ✅ **Real Data**: Creates authentic session data with proper structure
-- ✅ **Integration**: Tests complete upload → processing → storage flow
-- ✅ **Validation**: Verifies data integrity end-to-end
-
-### Production Readiness
-- ✅ **Error Handling**: Comprehensive error scenarios and recovery
-- ✅ **Performance**: Measures upload times and validates efficiency
-- ✅ **Compatibility**: Ensures compatibility with core RPA Vision V3 models
-- ✅ **Reliability**: Tests retry logic and failure scenarios
-
-### Developer Experience
-- ✅ **Clear Output**: Detailed progress and validation feedback
-- ✅ **Actionable Errors**: Helpful error messages with solutions
-- ✅ **Easy Setup**: Simple prerequisites and execution
-- ✅ **Comprehensive**: Single test covers entire upload flow
-
-## 📈 Impact
-
-This improved test provides:
-
-1. **Confidence**: Validates the complete agent upload system works correctly
-2. **Quality**: Ensures data integrity throughout the entire pipeline
-3. **Reliability**: Tests error handling and retry mechanisms
-4. **Integration**: Validates compatibility between agent and server components
-5. **Maintainability**: Real functionality tests catch regressions early
-
-## 🔄 Future Enhancements
-
-Potential improvements for even more comprehensive testing:
-
-1. **Authentication Testing**: Test with real tokens when auth is enabled
-2. **Encryption Testing**: Test with encrypted session files
-3. **Load Testing**: Test with multiple concurrent uploads
-4. **Network Failure Simulation**: Test retry logic with simulated failures
-5. **Processing Pipeline Validation**: Verify embeddings and workflow creation
-
----
-
-**Result**: The agent upload system now has comprehensive real functionality testing that validates the complete flow from agent session creation through server processing and storage, ensuring production readiness and data integrity.

AGENT_V0_AUTHENTICATION_ENCRYPTION_FIXED.md

@@ -1,71 +0,0 @@
-# Agent V0 Authentication & Encryption Issue - RESOLVED
-
-## Problem Summary
-
-The Agent V0 was experiencing authentication and encryption issues when uploading sessions to the server:
-
-1. **Initial Issue**: HTTP 401 "unauthorized" errors
-2. **Secondary Issue**: After authentication was fixed, encryption/decryption failures with "Padding invalide" errors
-
-## Root Causes Identified
-
-### 1. Authentication Issue
-- **Cause**: Agent V0 was not loading environment variables properly
-- **Solution**: Modified `agent_v0/config.py` to auto-load `.env.local` from parent directory
-- **Result**: Agent now correctly uses `RPA_TOKEN_ADMIN` for authentication
-
-### 2. Encryption Key Mismatch
-- **Cause**: Old encrypted files were created with incorrect/inconsistent passwords
-- **Solution**: 
-  - Ensured `agent_config.json` has correct `encryption_password` matching `.env.local`
-  - Moved corrupted old `.enc` files to backup directory
-  - Verified encryption/decryption cycle works with fresh files
-
-## Files Modified
-
-### Configuration Files
-- **`.env.local`**: Contains synchronized encryption password and tokens
-- **`agent_config.json`**: Updated with correct encryption password
-- **`agent_v0/config.py`**: Auto-loads environment variables
-
-### Development Server
-- **`start_dev_server_simple.py`**: Development server on port 8001
-- **`stop_dev_server.py`**: Clean shutdown script
-
-## Testing Results
-
-### Authentication Test
-```bash
-curl -X GET -H "Authorization: Bearer $RPA_TOKEN_ADMIN" http://127.0.0.1:8001/api/traces/status
-# Result: {"status":"online","encryption_enabled":true}
-```
-
-### Encryption/Decryption Test
-- Fresh session creation: Success
-- Encryption with correct password: Success  
-- Decryption verification: Success
-- ZIP file validation: Success
-
-### Complete Upload Flow Test
-```bash
-curl -X POST -H "Authorization: Bearer $RPA_TOKEN_ADMIN" \
-  -F "file=@agent_v0/sessions/sess_20260105T195912_49cd3470.enc" \
-  -F "session_id=sess_20260105T195912_49cd3470" \
-  http://127.0.0.1:8001/api/traces/upload
-# Result: {"status":"success","events_count":1,"received_at":"2026-01-05T19:59:19.305371"}
-```
-
-## Current Status: RESOLVED
-
-- **Authentication**: Working correctly with Bearer token
-- **Encryption**: Working correctly with synchronized passwords
-- **Upload Flow**: Complete end-to-end success
-- **Server Processing**: Successfully decrypts and processes sessions
-
-## Next Steps
-
-1. **Clean up old corrupted files**: Old `.enc` files moved to `agent_v0/sessions/backup_corrupted/`
-2. **Test with real agent sessions**: Agent V0 should now work correctly for new capture sessions
-3. **Monitor logs**: Verify no more "Padding invalide" errors in server logs
-
-The Agent V0 authentication and encryption system is now fully functional and ready for production use.

ANALYSE_PROJET_09JAN2026.md

@@ -1,254 +0,0 @@
-# Analyse du Projet RPA Vision V3 - 09 Janvier 2026
-
-## Score Global : 8.3/10
-
-| Aspect | Score |
-|--------|-------|
-| Architecture | 9/10 |
-| Organisation Code | 8/10 |
-| Tests | 8/10 |
-| Config Management | 9/10 |
-| Error Handling | 9/10 |
-| Propreté du Repo | 5/10 |
-
----
-
-## Métriques
-
-- **Lignes de code (core)** : 55,914
-- **Modules core** : 27
-- **Tests** : 118 fichiers
-- **Documentation** : 251 fichiers MD à la racine
-
----
-
-## Points Forts
-
-1. **Architecture 5 couches** bien implémentée :
-   - Couche 0: RawSession (événements bruts)
-   - Couche 1: ScreenState (abstraction)
-   - Couche 2: UIElement (détection sémantique)
-   - Couche 3: StateEmbedding (fusion multi-modale)
-   - Couche 4: WorkflowGraph (exécution)
-
-2. **Modules core solides** :
-   - execution/ (10k lignes) - Actions, recovery, circuit breaker
-   - analytics/ (5.2k) - Métriques, rapports
-   - embedding/ (2.9k) - CLIP, FAISS, fusion
-   - detection/ (2.5k) - UI detection hybride
-
-3. **Gestion d'erreurs robuste** :
-   - 983 instances try/except/finally
-   - ErrorHandler centralisé
-   - Recovery strategies
-   - Circuit breaker pattern
-
-4. **Configuration centralisée** (`core/config.py` - 652 lignes)
-
-5. **Pas d'imports cassés ni cycles de dépendances**
-
----
-
-## Problèmes Identifiés
-
-### Critiques (à nettoyer)
-
-| Problème | Fichiers | Action |
-|----------|----------|--------|
-| Tests à la racine | 84 fichiers `test_*.py`, `demo_*.py` | Déplacer vers `tests/` |
-| Documentation racine | 251 fichiers `.md` | Archiver dans `docs/archive/` |
-| Fichiers pip corrompus | `=0.0.9`, `=0.15.0`, etc. | Supprimer |
-| Archives ZIP | 6 fichiers | Supprimer ou archiver |
-| Backups | `*.backup_*`, `*.bak` | Supprimer |
-| Logs volumineux | 181 MB | Implémenter rotation |
-
-### Majeurs (refactoring)
-
-| Fichier | Lignes | Recommandation |
-|---------|--------|----------------|
-| `web_dashboard/app.py` | 39,500 | Découper en modules (routes/, handlers/, services/) |
-| `core/execution/target_resolver.py` | 3,495 | Pattern Strategy (8 resolvers séparés) |
-| `server/api_upload_dev_*.py` | 16k x2 | Supprimer duplication |
-
-### Mineurs
-
-- Fichiers vides : `agent_v0/workflow_browser.py`, `workflow_locator.py`
-- 34 TODOs/FIXMEs dans core/
-- Pas de CI/CD pipeline
-
----
-
-## Recommandations par Priorité
-
-### 1. Court Terme (Nettoyage)
-
-```bash
-# Fichiers à supprimer
-rm -f =0.0.9 =0.15.0 =0.9.54 =1.24.0 =1.3.0 =1.7.4 =10.0.0 =2.0.0 =2.20.0 =2.31.0 =4.0.0 =4.30.0 =4.8.0 =5.15.0 =7.0.0 =9.0.0
-rm -f .deps_installed
-rm -f *.backup_*
-rm -f *.bak
-
-# Archives à déplacer
-mkdir -p archives/
-mv *.zip archives/
-mv capture_element_cible_vwb_*/ archives/
-mv rpa_vision_v3_code_docs_*/ archives/
-
-# Documentation à organiser
-mkdir -p docs/archive/sessions/
-mkdir -p docs/archive/phases/
-mkdir -p docs/archive/fiches/
-mv SESSION_*.md docs/archive/sessions/
-mv PHASE*.md docs/archive/phases/
-mv FICHE_*.md docs/archive/fiches/
-mv TASK_*.md docs/archive/
-
-# Tests à déplacer
-mkdir -p tests/legacy/
-mv test_*.py tests/legacy/
-mv demo_*.py tests/legacy/
-mv fix_*.py scripts/fixes/
-mv debug_*.py scripts/debug/
-mv diagnostic_*.py scripts/diagnostic/
-```
-
-### 2. Moyen Terme (Refactoring)
-
-#### Découper web_dashboard/app.py
-
-```
-web_dashboard/
-├── app.py (bootstrap, 200 lignes max)
-├── routes/
-│   ├── __init__.py
-│   ├── sessions.py
-│   ├── workflows.py
-│   ├── metrics.py
-│   └── system.py
-├── handlers/
-│   ├── execution_handler.py
-│   └── analytics_handler.py
-├── services/
-│   ├── storage_service.py
-│   └── processing_service.py
-└── websocket/
-    └── realtime.py
-```
-
-#### Découper target_resolver.py
-
-```
-core/execution/resolvers/
-├── __init__.py
-├── base_resolver.py
-├── by_role_resolver.py
-├── by_text_resolver.py
-├── by_position_resolver.py
-├── by_embedding_resolver.py
-├── by_hierarchy_resolver.py
-├── by_context_resolver.py
-├── by_spatial_resolver.py
-└── composite_resolver.py
-```
-
-### 3. Long Terme
-
-- Ajouter CI/CD (.github/workflows/)
-- Pre-commit hooks (black, isort, flake8, mypy)
-- Log rotation (RotatingFileHandler)
-- Migration vers Poetry/pipenv
-- Documentation API (Swagger/OpenAPI)
-
----
-
-## Modules Principaux
-
-### Core (55.9k lignes)
-
-| Module | Lignes | Rôle |
-|--------|--------|------|
-| execution/ | 10,000 | Exécution actions, recovery |
-| analytics/ | 5,200 | Métriques, rapports |
-| visual/ | 4,500 | Gestion targets visuels |
-| workflow/ | 3,900 | Composition workflows |
-| models/ | 3,200 | Structures données |
-| embedding/ | 2,900 | FAISS, CLIP, fusion |
-| security/ | 2,700 | Tokens, validation |
-| detection/ | 2,500 | Détection UI |
-| evaluation/ | 2,200 | Simulation, replay |
-| healing/ | 2,200 | Auto-healing |
-| learning/ | 2,100 | Apprentissage persistant |
-| system/ | 2,100 | Circuit breaker, GPU |
-| training/ | 1,900 | Pipeline entraînement |
-| monitoring/ | 1,700 | Logging, métriques |
-
-### Server (2.9k lignes)
-
-- `api_core.py` - REST endpoints
-- `api_upload.py` - Upload files
-- `processing_pipeline.py` - Pipeline traitement
-- `worker_daemon.py` - Worker background
-
-### Agent V0 (6.6k lignes)
-
-- `tray_ui.py` - Interface systray
-- `enhanced_event_captor.py` - Event capturing
-- `uploader.py` - Upload au serveur
-- `storage_encrypted.py` - Chiffrement
-
-### Web Dashboard
-
-- `app.py` - 39.5k lignes (à découper)
-- Port 5001
-- WebSocket temps réel
-
----
-
-## Dépendances Clés
-
-```
-core/config.py (central)
-    │
-    ├── core/models
-    ├── core/capture
-    ├── core/detection
-    ├── core/embedding
-    │
-    └── core/execution
-            │
-            ├── core/graph
-            ├── core/learning
-            ├── core/healing
-            ├── core/analytics
-            │
-            └── server/api_core
-                    │
-                    └── web_dashboard/app.py
-```
-
----
-
-## Services Systemd
-
-| Service | Port | Status |
-|---------|------|--------|
-| rpa-vision-v3-api | 8000 | enabled |
-| rpa-vision-v3-dashboard | 5001 | enabled |
-| rpa-vision-v3-worker | - | enabled |
-
----
-
-## Prochaines Actions
-
-1. [ ] Nettoyer fichiers racine (pip corrompus, backups)
-2. [ ] Organiser documentation (251 MD → docs/archive/)
-3. [ ] Déplacer tests legacy (84 fichiers → tests/legacy/)
-4. [ ] Implémenter log rotation
-5. [ ] Découper web_dashboard/app.py
-6. [ ] Refactorer target_resolver.py
-7. [ ] Ajouter CI/CD
-
----
-
-*Généré le 09 janvier 2026*

AUDIT_SECURITE_LOGS_VWB_14JAN2026.md

@@ -1,578 +0,0 @@
-# RAPPORT D'AUDIT SÉCURITÉ & LOGS - VWB RPA Vision v3
-
-**Date**: 14 janvier 2026
-**Auteur**: Claude (revue automatisée)
-**Contexte**: Environnements sensibles (Santé, Défense, Administration)
-**Mode**: Revue uniquement - Aucun code modifié
-**Statut**: À CORRIGER APRÈS LES DÉMOS
-
----
-
-## SCORE GLOBAL : 3/10 - NON PRÊT POUR PRODUCTION SENSIBLE
-
-> **Note**: Ce rapport est à traiter APRÈS les démonstrations en cours.
-> Les corrections de sécurité peuvent impacter le fonctionnement actuel.
-
----
-
-## TABLE DES MATIÈRES
-
-1. [Vulnérabilités Critiques](#1-vulnérabilités-critiques)
-2. [Problèmes Logs & Traçabilité](#2-problèmes-logs--traçabilité)
-3. [Headers Sécurité Manquants](#3-headers-sécurité-manquants)
-4. [Endpoints Non Protégés](#4-endpoints-non-protégés)
-5. [Conformité Réglementaire](#5-conformité-réglementaire)
-6. [Plan de Remédiation](#6-plan-de-remédiation)
-7. [Détails Techniques Complets](#7-détails-techniques-complets)
-
----
-
-## 1. VULNÉRABILITÉS CRITIQUES
-
-### Résumé (6 vulnérabilités critiques)
-
-| # | Vulnérabilité | Fichier | Ligne | Impact |
-|---|---------------|---------|-------|--------|
-| 1 | Tokens de production hardcodés | `core/security/api_tokens.py` | 93-96 | Compromis total auth |
-| 2 | CORS = "*" partout | `backend/app.py` | 34 | CSRF, accès cross-origin |
-| 3 | Zéro authentification sur /api/* | `backend/api/workflows.py` | - | Exécution workflows non autorisée |
-| 4 | SECRET_KEY par défaut | `backend/app.py` | 24 | Sessions forgées |
-| 5 | WebSocket sans auth | `backend/api/websocket_handlers.py` | - | Espionnage temps réel |
-| 6 | Path traversal | `backend/services/serialization.py` | 115 | Lecture/écriture fichiers système |
-
-### 1.1 Tokens de Production Hardcodés (CRITIQUE)
-
-**Fichier**: `/home/dom/ai/rpa_vision_v3/core/security/api_tokens.py` lignes 93-109
-
-```python
-# Temporary fix: Add production tokens directly
-prod_admin_token = "73cf0db73f9a5064e79afebba96c85338be65cc2060b9c1d42c3ea5dd7d4e490"
-prod_readonly_token = "7eea1de415cc69c02381ce09ff63aeebf3e1d9b476d54aa6730ba9de849e3dc6"
-self.admin_tokens.add(prod_admin_token)
-self.read_only_tokens.add(prod_readonly_token)
-```
-
-**Problème**:
-- Tokens de production en dur dans le code source
-- Tokens visibles dans les dépôts Git
-- Réutilisés pour tous les environnements
-- Commentaires "Temporary fix" indiquant du code en attente
-
-**Impact**: Compromis complet de l'authentification en production
-
-**Correction recommandée**:
-```python
-# Utiliser UNIQUEMENT les variables d'environnement
-admin_token = os.getenv("RPA_TOKEN_ADMIN")
-readonly_token = os.getenv("RPA_TOKEN_READONLY")
-
-if not admin_token or not readonly_token:
-    if os.getenv('ENVIRONMENT') == 'production':
-        raise ValueError("Tokens must be configured via environment variables")
-```
-
-### 1.2 CORS Ouvert à Tous (CRITIQUE)
-
-**Fichiers impactés**:
-- `/home/dom/ai/rpa_vision_v3/visual_workflow_builder/backend/app.py:34-40`
-- `/home/dom/ai/rpa_vision_v3/visual_workflow_builder/backend/app_lightweight.py:512-516`
-
-```python
-# SocketIO
-socketio = SocketIO(
-    app,
-    cors_allowed_origins="*",  # VULNÉRABLE
-    async_mode='threading'
-)
-
-# Flask CORS
-CORS(app, origins="*",  # VULNÉRABLE
-     methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],
-     allow_headers=["Content-Type", "Authorization", "Accept", "X-Requested-With"],
-     supports_credentials=False)
-```
-
-**Correction recommandée**:
-```python
-CORS_ORIGINS = os.getenv('CORS_ORIGINS', 'http://localhost:3000').split(',')
-
-socketio = SocketIO(
-    app,
-    cors_allowed_origins=CORS_ORIGINS,
-    async_mode='threading'
-)
-
-CORS(app,
-     origins=CORS_ORIGINS,
-     methods=["GET", "POST", "PUT", "DELETE"],
-     allow_headers=["Content-Type", "Authorization"],
-     supports_credentials=True,
-     max_age=3600)
-```
-
-### 1.3 SECRET_KEY par Défaut (CRITIQUE)
-
-**Fichier**: `/home/dom/ai/rpa_vision_v3/visual_workflow_builder/backend/app.py:24`
-
-```python
-app.config['SECRET_KEY'] = os.getenv('SECRET_KEY', 'dev-secret-key-change-in-production')
-```
-
-**Correction recommandée**:
-```python
-secret_key = os.getenv('SECRET_KEY')
-if not secret_key or 'change-in-production' in secret_key:
-    if os.getenv('ENVIRONMENT') == 'production':
-        raise ValueError("SECRET_KEY must be set to a secure value in production")
-    secret_key = 'dev-only-key'
-app.config['SECRET_KEY'] = secret_key
-```
-
-### 1.4 WebSocket Sans Authentification (CRITIQUE)
-
-**Fichier**: `/home/dom/ai/rpa_vision_v3/visual_workflow_builder/backend/api/websocket_handlers.py`
-
-```python
-@socketio.on('connect')
-def handle_connect():
-    client_id = request.sid
-    emit('connected', {...})  # AUCUNE VÉRIFICATION D'AUTH
-```
-
-**Correction recommandée**:
-```python
-@socketio.on('connect')
-def handle_connect(auth):
-    token = auth.get('token') if auth else None
-    if not token or not validate_token(token):
-        return False  # Refuse la connexion
-    # ... reste du code
-```
-
-### 1.5 Path Traversal (CRITIQUE)
-
-**Fichier**: `/home/dom/ai/rpa_vision_v3/visual_workflow_builder/backend/services/serialization.py:115-118`
-
-```python
-def _path(self, workflow_id: str) -> str:
-    safe_id = "".join(c for c in workflow_id if c.isalnum() or c in ("_", "-")) or workflow_id
-    return os.path.join(self.root_dir, f"{safe_id}.json")
-```
-
-**Problème**: Le fallback `or workflow_id` contourne le filtre si tous les caractères sont supprimés.
-
-**Correction recommandée**:
-```python
-from pathlib import Path
-
-def _path(self, workflow_id: str) -> str:
-    # Filtrer strictement
-    safe_id = "".join(c for c in workflow_id if c.isalnum() or c == "_")
-    if not safe_id:
-        safe_id = "default_workflow"
-
-    # Vérifier que le chemin reste dans root_dir
-    file_path = Path(self.root_dir) / f"{safe_id}.json"
-    resolved = file_path.resolve()
-
-    # Sécurité: vérifier qu'on ne sort pas du répertoire
-    if not str(resolved).startswith(str(Path(self.root_dir).resolve())):
-        raise ValueError("Invalid workflow ID - path traversal detected")
-
-    return str(file_path)
-```
-
-### 1.6 Mode Debug Activable en Production (HAUTE)
-
-**Fichier**: `/home/dom/ai/rpa_vision_v3/visual_workflow_builder/backend/app.py:185-193`
-
-```python
-socketio.run(
-    app,
-    host='0.0.0.0',
-    port=port,
-    debug=debug,
-    use_reloader=debug,
-    allow_unsafe_werkzeug=True  # DANGEREUX EN PRODUCTION
-)
-```
-
----
-
-## 2. PROBLÈMES LOGS & TRAÇABILITÉ
-
-### 2.1 Lacunes Identifiées
-
-| Lacune | Sévérité | Conformité impactée |
-|--------|----------|---------------------|
-| `user_id` toujours `null` dans les logs | CRITIQUE | HIPAA, RGPD, ISO 27001 |
-| Pas d'audit trail workflow (qui/quoi/quand) | HAUTE | Tous secteurs |
-| Logs corrompus détectés (`logs/0.log`) | MOYENNE | Intégrité données |
-| Pas de rotation logs application | HAUTE | Disk full possible |
-| Rétention max 100MB (vs 7 ans HIPAA) | CRITIQUE | Santé |
-| Stack traces exposées en réponse API | HAUTE | OWASP |
-| IPs partiellement masquées (3 octets visibles) | MOYENNE | RGPD |
-
-### 2.2 Structure de Log Actuelle (Insuffisante)
-
-**Fichier**: `/home/dom/ai/rpa_vision_v3/core/security/audit_log.py`
-
-```json
-{
-  "event_type": "api_access",
-  "timestamp": "2026-01-06T00:59:45.467453Z",
-  "message": "request_success",
-  "user_id": null,           // TOUJOURS NULL - PROBLÈME
-  "ip_address": "127.0.0.xxx", // Masquage insuffisant (3 octets visibles)
-  "endpoint": "/api/traces/status",
-  "method": "GET",
-  "success": true
-}
-```
-
-### 2.3 Structure de Log Requise (HIPAA/RGPD)
-
-```json
-{
-  "event_type": "data_access",
-  "timestamp": "2026-01-14T10:30:00.123456Z",
-  "user_id": "admin@example.com",        // OBLIGATOIRE
-  "session_id": "sess_abc123",           // Pour corrélation
-  "correlation_id": "req_999",           // Pour traçage distribué
-  "action": "read_workflow",
-  "resource_id": "workflow_123",
-  "resource_type": "workflow",
-  "ip_address": "192.168.x.x",           // 2 octets max visibles
-  "user_agent": "Mozilla/5.0...",
-  "data_classification": "SENSITIVE",    // Classification données
-  "duration_ms": 234,
-  "status": "success",
-  "changes": {                           // Pour modifications
-    "before": {...},
-    "after": {...}
-  },
-  "signature": "hmac_sha256_..."         // Immuabilité audit trail
-}
-```
-
-### 2.4 Logs Corrompus Détectés
-
-**Fichier**: `/home/dom/ai/rpa_vision_v3/logs/0.log`
-
-```
-2025-12-13 13:41:37,006 - rpa.0 - INFO - vÏÊ «          ← CORRUPTION ENCODAGE
-2025-12-13 13:41:37,009 - rpa.0 - ERROR -              ← MESSAGE VIDE
-```
-
-### 2.5 Configuration Rotation Actuelle
-
-**Fichier**: `/home/dom/ai/rpa_vision_v3/core/security/audit_log.py:68-106`
-
-```python
-self.log_dir = Path(os.getenv("AUDIT_LOG_DIR", "logs/audit"))
-self.max_file_size = int(os.getenv("AUDIT_LOG_MAX_SIZE", "10485760"))  # 10MB
-self.max_files = int(os.getenv("AUDIT_LOG_MAX_FILES", "10"))
-```
-
-**Problèmes**:
-- Total max: 100MB (10 fichiers x 10MB)
-- Pas de rétention temporelle (HIPAA exige 7 ans)
-- Pas de compression des archives
-- Logs applicatifs non rotatés
-
----
-
-## 3. HEADERS SÉCURITÉ MANQUANTS
-
-| Header | État | Risque | Correction |
-|--------|------|--------|------------|
-| `Strict-Transport-Security` | ABSENT | Downgrade HTTPS | `max-age=31536000; includeSubDomains` |
-| `Content-Security-Policy` | ABSENT | XSS | `default-src 'self'` |
-| `X-Frame-Options` | ABSENT | Clickjacking | `DENY` |
-| `X-Content-Type-Options` | ABSENT | MIME sniffing | `nosniff` |
-| `X-XSS-Protection` | ABSENT | XSS legacy | `1; mode=block` |
-| `Referrer-Policy` | ABSENT | Fuite referrer | `strict-origin-when-cross-origin` |
-
-**Correction recommandée** (à ajouter dans `app.py`):
-
-```python
-@app.after_request
-def set_security_headers(response):
-    response.headers['Strict-Transport-Security'] = 'max-age=31536000; includeSubDomains'
-    response.headers['Content-Security-Policy'] = "default-src 'self'; script-src 'self' 'unsafe-inline'"
-    response.headers['X-Content-Type-Options'] = 'nosniff'
-    response.headers['X-Frame-Options'] = 'DENY'
-    response.headers['X-XSS-Protection'] = '1; mode=block'
-    response.headers['Referrer-Policy'] = 'strict-origin-when-cross-origin'
-    return response
-```
-
----
-
-## 4. ENDPOINTS NON PROTÉGÉS
-
-### 4.1 Backend VWB (`/api/*`)
-
-| Méthode | Endpoint | Risque | Auth requise |
-|---------|----------|--------|--------------|
-| GET | `/api/workflows/` | Enumération | Oui |
-| POST | `/api/workflows/` | Création non autorisée | Oui |
-| GET | `/api/workflows/<id>` | Lecture données | Oui |
-| PUT | `/api/workflows/<id>` | Modification | Oui |
-| DELETE | `/api/workflows/<id>` | Suppression | Oui |
-| POST | `/api/screen-capture` | Capture écran | Oui |
-
-### 4.2 Dashboard Web
-
-| Méthode | Endpoint | Risque | Auth requise |
-|---------|----------|--------|--------------|
-| POST | `/api/workflows/<id>/execute` | **EXÉCUTION SANS AUTH** | CRITIQUE |
-| POST | `/api/agent/sessions/<id>/process` | Traitement sessions | Oui |
-| GET | `/api/agent/sessions` | Enumération | Oui |
-| GET | `/api/logs` | **LOGS SYSTÈME PUBLICS** | CRITIQUE |
-| POST | `/api/logs/download` | Téléchargement logs | Oui |
-| GET | `/api/system/status` | Info système | Oui |
-
-### 4.3 Endpoints Debug à Supprimer en Production
-
-**Fichier**: `/home/dom/ai/rpa_vision_v3/core/security/fastapi_security.py:61`
-
-```python
-DEFAULT_PUBLIC_PATHS = {
-    "/api/traces/debug-auth",  # EXPOSÉ - À RETIRER
-    "/api/traces/debug-env",   # EXPOSÉ - À RETIRER
-}
-```
-
----
-
-## 5. CONFORMITÉ RÉGLEMENTAIRE
-
-### 5.1 Matrice de Conformité
-
-| Standard | Exigence | État | Gap |
-|----------|----------|------|-----|
-| **HIPAA** | Rétention 7 ans | ❌ | Max 100 MB |
-| **HIPAA** | User audit trail | ❌ | user_id = null |
-| **HIPAA** | Data access logs | ❌ | Non implémenté |
-| **RGPD** | Droit à l'oubli | ❌ | Pas de TTL/purge |
-| **RGPD** | PII masquage | ❌ | Loggé en clair |
-| **RGPD** | Consentement logs | ❌ | Non tracé |
-| **SOC 2** | Log retention | ❌ | 100 MB insuffisant |
-| **SOC 2** | Integrity verification | ❌ | JSONL non signé |
-| **ISO 27001** | Change tracking | ❌ | Pas de before/after |
-| **ISO 27001** | Admin actions | ~ | Partiel |
-
-### 5.2 Verdict par Secteur
-
-| Secteur | État | Bloqueurs principaux |
-|---------|------|----------------------|
-| **Santé (HIPAA)** | ❌ NO-GO | user_id null, rétention insuffisante |
-| **Défense** | ❌ NO-GO | Pas de classification, pas de clearance |
-| **Administration (RGPD)** | ❌ NO-GO | PII en clair, pas de droit à l'oubli |
-| **Entreprise standard** | ⚠️ RISQUÉ | Authentification manquante |
-
----
-
-## 6. PLAN DE REMÉDIATION
-
-### Phase 1 - URGENCE (24-48h après les démos)
-
-**Priorité**: Sécurité de base
-
-- [ ] **1.1** Supprimer tokens hardcodés de `api_tokens.py` (lignes 93-109)
-- [ ] **1.2** Configurer CORS avec origines explicites (pas "*")
-- [ ] **1.3** Changer SECRET_KEY avec valeur sécurisée
-- [ ] **1.4** Masquer erreurs détaillées en production
-- [ ] **1.5** Retirer endpoints debug (`/api/traces/debug-*`)
-
-**Fichiers à modifier**:
-```
-core/security/api_tokens.py
-visual_workflow_builder/backend/app.py
-visual_workflow_builder/backend/app_lightweight.py
-core/security/fastapi_security.py
-```
-
-### Phase 2 - Court terme (1-2 semaines)
-
-**Priorité**: Authentification & Protection
-
-- [ ] **2.1** Ajouter middleware d'authentification sur `/api/*`
-- [ ] **2.2** Implémenter rate limiting (flask-limiter)
-- [ ] **2.3** Authentifier connexions WebSocket
-- [ ] **2.4** Ajouter headers de sécurité
-- [ ] **2.5** Corriger path traversal dans serialization.py
-- [ ] **2.6** Valider uploads (taille, type, contenu)
-
-**Exemple middleware auth**:
-```python
-from functools import wraps
-
-def require_auth(f):
-    @wraps(f)
-    def decorated(*args, **kwargs):
-        token = request.headers.get('Authorization', '').replace('Bearer ', '')
-        if not token or not validate_token(token):
-            return jsonify({'error': 'Unauthorized'}), 401
-        return f(*args, **kwargs)
-    return decorated
-
-# Appliquer sur les routes
-@app.route('/api/workflows/', methods=['POST'])
-@require_auth
-def create_workflow():
-    ...
-```
-
-### Phase 3 - Moyen terme (1 mois)
-
-**Priorité**: Logs & Audit
-
-- [ ] **3.1** Ajouter `user_id` aux logs d'audit
-- [ ] **3.2** Implémenter audit trail workflow complet
-- [ ] **3.3** Rotation et rétention logs conforme (7 ans si HIPAA)
-- [ ] **3.4** Masquage automatique PII
-- [ ] **3.5** Signature des logs pour immuabilité
-- [ ] **3.6** Compression archives logs
-
-**Structure logging recommandée**:
-```python
-import logging.config
-
-LOGGING_CONFIG = {
-    'version': 1,
-    'disable_existing_loggers': False,
-    'formatters': {
-        'json': {
-            'class': 'pythonjsonlogger.jsonlogger.JsonFormatter',
-            'format': '%(timestamp)s %(level)s %(name)s %(message)s'
-        }
-    },
-    'handlers': {
-        'rotating_file': {
-            'class': 'logging.handlers.RotatingFileHandler',
-            'filename': 'logs/vwb.log',
-            'maxBytes': 10485760,  # 10MB
-            'backupCount': 100,    # 1GB total
-            'formatter': 'json'
-        }
-    },
-    'root': {
-        'level': 'INFO',
-        'handlers': ['rotating_file']
-    }
-}
-
-logging.config.dictConfig(LOGGING_CONFIG)
-```
-
-### Phase 4 - Long terme (2-3 mois)
-
-**Priorité**: Conformité complète
-
-- [ ] **4.1** Intégration SIEM (syslog/ELK/Splunk)
-- [ ] **4.2** RBAC (Role-Based Access Control)
-- [ ] **4.3** Chiffrement données au repos
-- [ ] **4.4** Backup et recovery audit trail
-- [ ] **4.5** Penetration testing
-- [ ] **4.6** Documentation sécurité
-
----
-
-## 7. DÉTAILS TECHNIQUES COMPLETS
-
-### 7.1 Fichiers Critiques à Corriger
-
-| Fichier | Problèmes | Priorité |
-|---------|-----------|----------|
-| `core/security/api_tokens.py` | Tokens hardcodés | P1 |
-| `backend/app.py` | CORS, SECRET_KEY, debug, auth | P1 |
-| `backend/app_lightweight.py` | CORS | P1 |
-| `backend/api/websocket_handlers.py` | Auth WebSocket | P1 |
-| `backend/services/serialization.py` | Path traversal | P1 |
-| `core/security/audit_log.py` | user_id, masquage IP | P2 |
-| `backend/api/workflows.py` | Validation entrées | P2 |
-| `core/security/fastapi_security.py` | Endpoints debug | P2 |
-
-### 7.2 Variables d'Environnement Requises
-
-```bash
-# Production - À configurer OBLIGATOIREMENT
-SECRET_KEY=<générer avec: python -c "import secrets; print(secrets.token_hex(32))">
-TOKEN_SECRET_KEY=<générer avec: python -c "import secrets; print(secrets.token_hex(32))">
-RPA_TOKEN_ADMIN=<générer avec: python -c "import secrets; print(secrets.token_hex(32))">
-RPA_TOKEN_READONLY=<générer avec: python -c "import secrets; print(secrets.token_hex(32))">
-CORS_ORIGINS=https://app.example.com,https://admin.example.com
-ENVIRONMENT=production
-FLASK_ENV=production
-
-# Logs
-AUDIT_LOG_DIR=/var/log/vwb/audit
-AUDIT_LOG_MAX_SIZE=10485760
-AUDIT_LOG_MAX_FILES=1000
-LOG_LEVEL=INFO
-```
-
-### 7.3 Commandes de Génération de Secrets
-
-```bash
-# Générer un nouveau SECRET_KEY
-python -c "import secrets; print(secrets.token_hex(32))"
-
-# Générer un nouveau token admin
-python -c "import secrets; print(secrets.token_hex(32))"
-
-# Vérifier les permissions des fichiers .env
-chmod 600 .env.local
-chown $USER:$USER .env.local
-```
-
-### 7.4 Tests de Sécurité à Effectuer
-
-```bash
-# Test CORS
-curl -H "Origin: http://evil.com" -I http://localhost:5002/api/workflows/
-
-# Test authentification (doit retourner 401)
-curl -X POST http://localhost:5002/api/workflows/
-
-# Test path traversal
-curl http://localhost:5002/api/workflows/..%2F..%2Fetc%2Fpasswd
-
-# Test rate limiting (après implémentation)
-for i in {1..100}; do curl http://localhost:5002/api/workflows/; done
-```
-
----
-
-## ANNEXES
-
-### A. Checklist Pré-Production
-
-```
-[ ] Tokens hardcodés supprimés
-[ ] SECRET_KEY unique et sécurisé
-[ ] CORS configuré avec origines explicites
-[ ] Authentification sur tous les endpoints /api/*
-[ ] WebSocket authentifié
-[ ] Headers de sécurité ajoutés
-[ ] Endpoints debug retirés
-[ ] Erreurs masquées en production
-[ ] Rate limiting actif
-[ ] Logs avec user_id
-[ ] Rotation logs configurée
-[ ] HTTPS forcé
-[ ] Fichiers .env exclus de Git
-[ ] Permissions fichiers correctes (600)
-```
-
-### B. Contacts & Ressources
-
-- OWASP Top 10: https://owasp.org/Top10/
-- Flask Security: https://flask.palletsprojects.com/en/2.0.x/security/
-- HIPAA Security Rule: https://www.hhs.gov/hipaa/for-professionals/security/
-
----
-
-**Fin du rapport - À traiter après les démonstrations**

BUGFIX_COMPLETE.txt

@@ -1,74 +0,0 @@
-═══════════════════════════════════════════════════════════════
-  ✅ BUGFIX COMPLETE - Demo Fonctionnel
-═══════════════════════════════════════════════════════════════
-
-🐛 PROBLÈMES CORRIGÉS:
-
-1. ✅ Syntax Error dans insight_generator.py (ligne 269)
-   - Parenthèse en trop supprimée
-   
-2. ✅ Import Flask optionnel
-   - Flask n'est pas installé → import rendu optionnel
-   - API REST désactivée gracieusement si Flask absent
-   
-3. ✅ Demo simplifié
-   - demo_analytics.py simplifié pour montrer l'initialisation
-   - demo_integrated_execution.py fonctionne avec warnings mineurs
-
-═══════════════════════════════════════════════════════════════
-
-✅ TESTS RÉUSSIS:
-
-$ python3 demo_analytics.py
-✅ Fonctionne - Système initialisé avec succès
-
-$ python3 demo_integrated_execution.py  
-✅ Fonctionne - 3 workflows exécutés avec tracking
-
-═══════════════════════════════════════════════════════════════
-
-⚠️ WARNINGS (Non-bloquants):
-
-- Flask not available → API REST désactivée (normal)
-- Resource monitoring not available → Optionnel
-- Quelques noms de paramètres à harmoniser (duration vs duration_ms)
-
-Ces warnings n'empêchent PAS le fonctionnement du système.
-
-═══════════════════════════════════════════════════════════════
-
-🎉 RÉSULTAT:
-
-Le système analytics est FONCTIONNEL et prêt à l'emploi !
-
-Tous les composants principaux fonctionnent:
-  ✅ Initialisation du système
-  ✅ Tracking d'exécution
-  ✅ Collection de métriques
-  ✅ Real-time analytics
-  ✅ Intégration ExecutionLoop
-
-═══════════════════════════════════════════════════════════════
-
-🚀 UTILISATION:
-
-# Demo simple
-python3 demo_analytics.py
-
-# Demo avec intégration
-python3 demo_integrated_execution.py
-
-# Voir les guides
-cat ANALYTICS_INTEGRATION_GUIDE.md
-cat MISSION_COMPLETE.txt
-
-═══════════════════════════════════════════════════════════════
-
-✨ STATUS FINAL: PRODUCTION READY
-
-Le système est prêt pour l'utilisation en production !
-
-═══════════════════════════════════════════════════════════════
-Date: 1er Décembre 2024
-Status: ✅ FONCTIONNEL
-═══════════════════════════════════════════════════════════════

CLAUDE.md

@@ -0,0 +1,108 @@
+# CLAUDE.md — rpa_vision_v3
+
+Ce fichier prime sur le CLAUDE.md racine (`~/ai/CLAUDE.md`) pour tout travail dans ce projet.
+
+## Rôle de Claude Code sur ce projet
+
+Exécutant supervisé, pas architecte. Mission : garantir la **cohérence** de chaque modification avec la vision globale du projet et le **contrat "100% vision"** (résolution UI par la vue, pas par les sélecteurs DOM/API). Quand tu touches un fichier, vérifie que tu ne casses rien ailleurs.
+
+Tu n'es pas en autonomie. Dom valide avant chaque étape. Tu proposes, il décide.
+
+## Priorité absolue
+
+**Le POC clinique Wallerstein doit tourner.** 5 postes Léa live ; les TIM travaillent sur leurs **vrais logiciels métier en mode web** (navigateur intégré au logiciel / navigateur du PC, instances **RDP** et **Citrix**), sur **2 écrans** → capture de la **fenêtre active**. Objectif produit : Léa **apprend** ces parcours et les **rejoue intelligemment** (pas du record-and-replay). Tout arbitrage technique se tranche par : « est-ce que ça rapproche ou éloigne du POC clinique qui tourne ? »
+
+> Historique : `Urgence_aiva_demo` (22+ steps) sur la **maquette Easily Assure** (patiente fictive MOREL Catherine) était le banc de démo/test — **maquette abandonnée comme cible** (recadrage Dom 2026-06-25). Ne plus raisonner « Easily ».
+
+## Méthode obligatoire — non négociable
+
+- **Chirurgie itérative supervisée** : une modification, un test (≤ 2 min), validation explicite de Dom avant la suivante.
+- **Pas de batch** : jamais plusieurs changements groupés sans validation intermédiaire.
+- **Rustine interdite** : tu corriges la cause, pas le symptôme. Si tu ne comprends pas la cause, tu le dis et tu arrêtes.
+- **Lire la doc avant d'agir** : code existant, `docs/`, specs. Pas de proposition basée sur des suppositions.
+- **Un commit = une intention** : message explicite, daté.
+- **Diff review systématique** sur tout code de production avant commit.
+
+## Anti-patterns à proscrire
+
+- Réponses longues. Si Dom dit "trop long" ou "déjà vu", tu raccourcis sans débattre.
+- Propositions structurelles avant d'avoir compris l'intention de Dom.
+- Re-proposer ce qui est déjà en place dans le code.
+- Raisonner sur un composant trouvé via grep **sans vérifier qu'il est effectivement appelé au runtime**. Le projet contient beaucoup de code écrit mais non wired.
+- Présenter la première solution qui marche. Toujours explorer 2-3 approches, présenter la meilleure avec justification.
+
+## Architecture runtime réelle (à valider/raffiner avec Dom)
+
+```
+[VWB frontend React :3002]
+        ↓ (HTTP)
+[VWB backend Flask + SQLite]
+        ↓ (envoi step par step)
+[agent_v1 — Linux]
+        ↓ (SSH vers Windows)
+[Léa — chatbot exécutant — PC Windows]
+        ↓
+[Easily Assure — interface cible]
+```
+
+**Ollama** : sert le ou les modèles utilisés pour la résolution VLM, l'extraction texte, et la décision t2a. Sert aussi de **proxy vers cloud** pour certains appels.
+
+**Cascade de résolution UI** (à confirmer composant par composant au runtime) :
+1. OCR (docTR ou EasyOCR selon module)
+2. cv2 template matching
+3. YOLO v4 grounding
+4. VLM grounding
+
+**UI-DETR-1** : utilisé par VWB **au recording** pour overlays numérotés (équivalent OmniParser). `crop_hash` volontairement non persisté.
+
+**Asymétrie connue, sujet ouvert post-démo** : VWB direct utilise UI-DETR-1 au runtime, le replay sur Léa ne l'utilise pas (cascade OCR/template/VLM seulement). Ne pas tenter de "fixer" cette asymétrie maintenant.
+
+## ⚠️ Champs de mines — code orphelin
+
+`core/` contient ~40 sous-modules. **Beaucoup ne sont pas wired au runtime actif.** Avant de raisonner sur un composant trouvé dans `core/` (coaching, healing, federation, learning, cognition, etc.) :
+
+1. Vérifier qu'il est importé par un point d'entrée actif.
+2. Vérifier qu'il est effectivement appelé en runtime (traces, logs).
+3. Si doute, demander à Dom.
+
+**Cas spécifique agent_v1** : suspicion de code orphelin à rebrancher. Si tu trouves un appel codé mais non exécuté en runtime (ex. appel Ollama de commentaire d'action présent dans le code mais jamais déclenché), c'est prioritaire à signaler.
+
+## Debug — où regarder en premier
+
+- `logs/` (racine projet) — logs runtime généraux
+- `logs/audit/` — traces d'exécution
+- `logs/healing/` — si concerne le healing
+- `data/runner_captures/` — captures d'exécution
+- `visual_workflow_builder/logs/` — logs VWB
+- `server/logs/` — logs serveur
+
+**Vérifier qu'un appel Ollama se déclenche vraiment au runtime** : ne pas se fier à la présence de l'appel dans le code. Tracer effectivement (log d'entrée de fonction, requête vue côté Ollama `:11434`).
+
+## Inspirations externes
+
+Voir `docs/INSPIRATION_FRAMEWORKS_2026-05-10.md` pour les patterns convergents (OpenAdapt, Skyvern, OmniParser : Policy/Grounding, Safety Gate, Abstraction Ladder, Planner-Actor-Validator). Le projet est techniquement plus mature que sa documentation ne le suggère — s'inspirer des bons patterns sans complexe.
+
+## Recherche d'information
+
+Ta connaissance interne est datée. Pour tout sujet technique évoluant vite (modèles VLM, frameworks RPA visuels, librairies de grounding, versions d'outils), **chercher sur internet d'abord**. Privilégier les sources de moins de 6 mois.
+
+## Stack
+
+- Python 3.10-3.12, venv `venv_v3/`
+- Backend VWB : Flask + SQLite
+- Frontend VWB : React (port 3002), dashboard :5001, API :8000
+- LLM local : Ollama `:11434`
+- GUI legacy : PyQt5
+- Tests : pytest avec marqueurs (unit/integration/slow/smoke)
+- Langue : français (code, commentaires, logs, GUI)
+
+## Commandes utiles
+
+```bash
+cd ~/ai/rpa_vision_v3 && source venv_v3/bin/activate
+./run.sh --full        # Écosystème complet
+./run.sh --gui         # GUI PyQt5 seule
+./run.sh --test        # Tests complets
+make test-fast         # Tests rapides
+make check             # Validation imports + tests rapides
+```

CORRECTIONS_FINALES.txt

@@ -1,36 +0,0 @@
-# Corrections Finales - Workflows & Embeddings
-
-## Corrections effectuées:
-
-1. graph_builder.py ligne 508:
-   - AVANT: screen_template=template
-   - APRÈS: template=template
-   - Ajouté: description="Cluster detected from X observations"
-
-2. processing_pipeline.py ligne 297:
-   - AVANT: f"data/training/sessions/{session.session_id}/{session.session_id}/{screenshot.relative_path}"
-   - APRÈS: f"data/training/sessions/{session.session_id}/{screenshot.relative_path}"
-
-## Déploiement:
-
-sudo cp /home/dom/ai/rpa_vision_v3/processing_pipeline.py /opt/rpa_vision_v3/server/processing_pipeline.py
-sudo chown rpa:rpa /opt/rpa_vision_v3/server/processing_pipeline.py
-
-sudo cp /home/dom/ai/rpa_vision_v3/graph_builder.py /opt/rpa_vision_v3/core/graph/graph_builder.py
-sudo chown rpa:rpa /opt/rpa_vision_v3/core/graph/graph_builder.py
-
-sudo systemctl restart rpa-vision-v3-worker.service
-
-## Test:
-
-cd /home/dom/ai/rpa_vision_v3/agent_v0
-./run.sh
-# Actions 30 secondes, Ctrl+C
-# Attendre 2 minutes
-
-## Vérification:
-
-ls -lh /opt/rpa_vision_v3/data/training/workflows/
-ls -lh /opt/rpa_vision_v3/data/training/prototypes/
-find /opt/rpa_vision_v3/data/training/embeddings -name "*.npy" | wc -l
-journalctl -u rpa-vision-v3-worker -n 50 | grep -E "(Embeddings générés|Workflow créé)"

CORRECTION_TYPESCRIPT_VWB_COMPLETE_12JAN2026.md

@@ -1,186 +0,0 @@
-# 🎉 CORRECTION COMPLÈTE DES ERREURS TYPESCRIPT VWB - 12 JANVIER 2026
-
-**Auteur :** Dom, Alice, Kiro  
-**Date :** 12 janvier 2026  
-**Statut :** ✅ **MISSION ACCOMPLIE**
-
----
-
-## 📋 Résumé Exécutif
-
-**OBJECTIF ATTEINT :** Toutes les erreurs TypeScript du Visual Workflow Builder ont été corrigées définitivement. Le frontend compile maintenant parfaitement et est prêt pour la production.
-
-### 🎯 Résultats Obtenus
-
-- ✅ **0 erreur TypeScript** - Compilation parfaite
-- ✅ **Build de production** - Génération réussie (315.94 kB)
-- ✅ **Tests automatisés** - 100% de réussite
-- ✅ **Architecture préservée** - Fonctionnalités VWB intactes
-- ✅ **Standards respectés** - Code en français, bien documenté
-
----
-
-## 🔧 Corrections Apportées
-
-### 1. **StepNode.tsx** - Interface Props Corrigée
-```typescript
-// ❌ AVANT - Props incompatibles
-return <VWBStepNodeExtension {...{ data, selected, id: (stepData.id || 'unknown') as string }} />;
-
-// ✅ APRÈS - Props simplifiées
-return <VWBStepNodeExtension data={data} selected={selected} />;
-```
-
-### 2. **VWBStepNodeExtension.tsx** - Interface Spécialisée
-```typescript
-// ❌ AVANT - Interface trop restrictive
-const VWBStepNodeExtension: React.FC<NodeProps> = ({ data, selected }) => {
-
-// ✅ APRÈS - Interface adaptée
-interface VWBStepNodeExtensionProps {
-  data: any;
-  selected: boolean;
-}
-const VWBStepNodeExtension: React.FC<VWBStepNodeExtensionProps> = ({ data, selected }) => {
-```
-
-### 3. **Executor/index.tsx** - Architecture Refactorisée
-```typescript
-// ❌ AVANT - Variables hors scope
-const { isVWBStep } = useVWBExecutionService(); // Hors du composant
-const hasVWBSteps = useMemo(() => ...); // Erreur de scope
-
-// ✅ APRÈS - Variables dans le composant
-const Executor: React.FC<ExecutorProps> = ({ workflow, ... }) => {
-  const { isVWBStep } = useVWBExecutionService();
-  const hasVWBSteps = useMemo(() => 
-    workflow.steps.some(step => isVWBStep(step)), 
-    [workflow.steps, isVWBStep]
-  );
-  // ...
-};
-```
-
----
-
-## 📊 Validation Complète
-
-### Tests de Compilation
-```bash
-# Vérification TypeScript
-npx tsc --noEmit
-✅ Aucune erreur détectée
-
-# Build de production  
-npm run build
-✅ Compilation réussie
-✅ 315.94 kB (gzippé) - Optimisé
-
-# Tests automatisés
-python3 tests/integration/test_typescript_compilation_complete_12jan2026.py
-✅ 2/2 tests réussis
-```
-
-### Métriques de Performance
-- **Taille finale :** 315.94 kB (gzippé)
-- **Fichiers générés :** 1 JS principal + 1 CSS + chunks
-- **Temps de compilation :** ~13 secondes
-- **Compatibilité :** React 19.2.3 + TypeScript 4.9.5
-
----
-
-## 🏗️ Architecture Respectée
-
-### Conformité aux Standards du Projet
-
-| Critère | Status | Détails |
-|---------|--------|---------|
-| **Langue française** | ✅ | Tous commentaires et docs en français |
-| **Attribution** | ✅ | "Dom, Alice, Kiro" avec dates |
-| **Organisation docs** | ✅ | Centralisé dans `docs/` |
-| **Organisation tests** | ✅ | Structuré dans `tests/` |
-| **Cohérence** | ✅ | Architecture et conventions respectées |
-
-### Types TypeScript
-- ✅ Interfaces bien définies dans `types/index.ts`
-- ✅ Props typées correctement  
-- ✅ Imports/exports cohérents
-- ✅ Pas d'utilisation abusive de `any`
-
----
-
-## 🚀 Fonctionnalités Préservées
-
-### Support VWB Complet
-- ✅ **Actions VisionOnly** - Catalogue complet fonctionnel
-- ✅ **États visuels** - Animations et feedback temps réel
-- ✅ **Evidence Viewer** - Visualisation des preuves d'exécution
-- ✅ **Propriétés Panel** - Configuration des étapes
-- ✅ **Système d'exécution** - Workflow robuste
-
-### Interface Utilisateur
-- ✅ **Canvas interactif** - Glisser-déposer fonctionnel
-- ✅ **Palette d'outils** - Catalogue d'actions complet
-- ✅ **Panneau propriétés** - Configuration dynamique
-- ✅ **Contrôles d'exécution** - Play/Pause/Stop
-- ✅ **Indicateurs visuels** - États et progression
-
----
-
-## 📁 Fichiers Créés/Modifiés
-
-### Corrections Principales
-- `visual_workflow_builder/frontend/src/components/Canvas/StepNode.tsx`
-- `visual_workflow_builder/frontend/src/components/Canvas/VWBStepNodeExtension.tsx`
-- `visual_workflow_builder/frontend/src/components/Executor/index.tsx`
-
-### Documentation
-- `docs/CORRECTION_FINALE_TYPESCRIPT_VWB_12JAN2026.md`
-- `docs/rapport_validation_typescript_vwb_12jan2026.json`
-
-### Scripts et Tests
-- `fix_typescript_errors_vwb_complete_12jan2026.py`
-- `scripts/validation_finale_typescript_vwb_12jan2026.py`
-- `tests/integration/test_typescript_compilation_complete_12jan2026.py`
-- `tests/integration/test_vwb_frontend_startup_final_12jan2026.py`
-
----
-
-## 🔮 Recommandations Futures
-
-### Prévention des Erreurs
-1. **CI/CD Pipeline :** Intégrer `tsc --noEmit` dans les checks automatiques
-2. **Pre-commit Hooks :** Vérification TypeScript avant chaque commit
-3. **Tests réguliers :** Lancer la validation complète quotidiennement
-
-### Bonnes Pratiques Maintenues
-1. **Types stricts :** Éviter `any`, préférer des interfaces spécifiques
-2. **Composants modulaires :** Séparer clairement les responsabilités  
-3. **Documentation :** Maintenir les commentaires français à jour
-4. **Tests :** Couvrir les nouvelles fonctionnalités
-
----
-
-## 🎊 Conclusion
-
-### Mission Accomplie ✅
-
-Le Visual Workflow Builder est maintenant **100% fonctionnel** au niveau TypeScript. Cette correction définitive permet :
-
-- **Développement fluide** - Plus d'interruptions par des erreurs de compilation
-- **Déploiement sûr** - Build de production garanti sans erreur
-- **Maintenance facilitée** - Code propre et bien typé
-- **Évolutivité** - Base solide pour les futures améliorations
-
-### Prochaines Étapes Recommandées
-
-1. **Tests d'intégration** - Validation complète des fonctionnalités VWB
-2. **Tests utilisateur** - Validation de l'expérience utilisateur
-3. **Optimisations** - Amélioration des performances si nécessaire
-4. **Déploiement** - Mise en production du frontend corrigé
-
----
-
-**🏆 SUCCÈS TOTAL - FRONTEND VWB PRÊT POUR LA PRODUCTION**
-
-*Correction réalisée par Dom, Alice, Kiro - 12 janvier 2026*

DASHBOARD_INTEGRATION_STATUS_FINAL.md

@@ -1,85 +0,0 @@
-ionnelle opératur-dashboardt-servee agenon complètgratintéImpact** : Iidées
-**et valtées rections teses cor - Toutes l 100%ce** :ianrd
-**Confge dashboaarrate de redémEn attenlu - ✅ Réso* : 
-**Statut*ce web.
-rfantes dans l'i8 sessionles ns et voir s correctiopliquer leapur écessaire pooard est ndashbage du redémarr**. Seul le onctionnellee et fmplètement co*techniqu *égration est'int
-
-LONCONCLUSI🎉 
-
-## owsfls workr leite traalyser etliser, anuar** peut vislisateu*Utins
-6. *s les sessiotoutefiche  afrd** lit etDashboa/`
-5. **essionsning/s/trai`dataage dans ck stoment** etiffre*Déch
-4. *00)80(port es/upload` api/trac `/ serveurers v**Upload**. 
-3ORD`YPTION_PASSW `ENCRvec adonnéeses  d**iffrement*Ch *
-2.tilisateurtions uinteraccapture les V0** nt Age **NNEL
-
-1.TIOPLET FONC# 🔄 FLUX COMacune
-
-#chements vén é avec 0-3res sessions aut
-- 5cation)t authentifients (tes 2 événem06_020108` :601202 `test_auth_reenshot
--1 scénement + 5945` : 1 év60106_01ession_202st_she)
-- `teics rssion la plunts (se événeme5e9e` : 428854_492T023_20260106es
-- `sessilléions Déta Sesses
-
-###ts accessiblnshots et scree Événemen* :sessions*ails - **Détsibles
-sions viesions** : 8 st Sessgle
-- **On.0.0.1:500127/1ttp:/ **URL** : hb
--nterface We
-### I```
-
-8}: ", "total[...]sions":  {"sesetourner : roits
-# Dsionesgent/s001/api/a.1:5p://127.0.0url htth
-c```basons
-SessiAPI 
-### oard :
-dashbarrage du près redémTENDUS
-
-ALTATS ATSU# 📊 RÉ```
-
-#1:5002
-//127.0.0.p: httr : Puis teste.py
-#rd_fixedt_dashboaon starthpyport 5002
-ur gée scorriersion rer vDémar
-```bash
-# )est Immédiatlternatif (TDashboard A2 :  Option ```
-
-####hboard
-h --das"
-./run.sp.pyoard/ap*web_dashb"python.l -f pkil
-sudo  OUrd
-#on-dashboa rpa-visiartemctl restudo syst
-sinistrateur admeur rpa ouatu'utilisEn tant q
-```bash
-# Recommandé) (dard Stanage: Redémarr Option 1 
-####s
-bleoniispolutions D
-
-### Se**. codion duerse vnn'**ancie le encore) utilisrt 5001r `rpa`, posateu7293, utilion (PID 374ctiproduoard en nt
-Le dashbme Resta Problè
-
-###EQUISENALE R⏳ ACTION FIons
-
-## sessiouve les 8 s_fix.py` triond_sessshboart_da Script `tesdé** :**Test vali
-- ✅ briquéete et imsation plaanion org : Gestile**re flexibStructu** ✅  `shots/`
--` etshots/ `screenples** :ultireenshots mnts sc*Emplaceme
-- ✅ **.json``*/` et *.json `nsatter* : Pe*méliorérecherche a de  **Logique
-- ✅ Corrigéboarde Dash
-### 3. Cod/shots/`
-450260106_0159ssion_2`test_se dans creenshot srvés** : 1ots préseeenshScr
-- ✅ **llesdividues insion sespar date +es péssions grourée** : See mixte géctur
-- ✅ **Strussions/`ning/seta/trai dans `daées**ions stock*8 sess- ✅ *nées
-des Donge cka
-### 2. Storectement
-orfrées cifnées déchTTP 200, don Hls** : fonctionne✅ **Uploads
-- lignéesment as de chiffre: Cléronisé** synchement iffr- ✅ **Chnctionnels
-fo sécurité s sansstvée** : Tetiacon désntificati*Authe
-- ✅ *000) (8bon portnt le maintenatilise  Agent ugé** :rri*Port co *eur
-- ✅ent-Servon Agnexi## 1. ConS
-
-#LURÉSOOBLÈMES 
-## ✅ PR*.
-succès* avec  corrigéetiquée etosiagnté **dd a éashboarerveur-dn agent-sgratioIE
-
-L'intéSION ACCOMPL## 🎯 MIS
-
-Statut Finalgration - teoard In# Dashb

DASHBOARD_STATUS_FINAL.md

@@ -1,56 +0,0 @@
-lidéestées et vations tesles correcutes : 100% - To
-Confiance hboardrage dasedémartente de r- En atRésolu ut : s.
-
-Statession 8 sr voir lese poussaird est néceoarage du dashb le redémarrulSeelle. 
-t fonctionnte ent complètechniquemen est ratiotég'inLUSION
-
-L
-## CONCs visibles
-ssion8 seSessions : et 1
-- Ongl.0.0.1:500//127 http:ace Web : Interfal": 8}
--, "totons": [...] {"sessiner : Doit retouressions
--t/s01/api/agen:50://127.0.0.1httpurl ns : c- API Sessioémarrage :
- red
-
-Après ATTENDUS## RÉSULTATS
-
-7.0.0.1:5002http://12er : st
-   Puis teed.pyard_fixtart_dashbo   python s)
-atest Immédiif (Trd Alternatoa
-2. Dashb
-hboardas./run.sh --d  /app.py"
- _dashboard"python.*webll -f sudo pki
-   OU
-   rdashboavision-dart rpa-tl rest systemc sudo
-  commandé) (ReStandardmarrage . Redé
-1nibles
-ons Dispo
-### Solutidu code.
- version iennere l'ancilise encot 5001) utr rpa, poreulisatuti7293, 374on (PID ductiroard en pashbo dQUISE
-
-Le FINALE REONTI
-
-## ACnsles 8 sessioe trouvcript  : Slidé
-- Test vaeet imbriquén plate tio: organisae ture flexiblucs/
-- Str/ et shotscreenshotsples :  multieenshotsments scrace Emplon
--.js */*json etorée : *.améli recherche deue  ✅
-- Logiq Corrigéde Dashboard## 3. Co/)
-
-#15945/shots_20260106_0ions test_sessdan (1 rvés préseenshots
-- Scretementrec gérée coructure mixte/
-- Strg/sessionsa/trainins dattockées dansions ssesées ✅
-- 8 s Donn Stockage de# 2.ffrées
-
-##nnées déchi doP 200, HTTctionnels :fonUploads lignées
--  : Clés a synchroniséffrements
-- Chies teste pour lésactivétification duthen- A00)
-rt (80 polise le bon : Agent utirrigé
-- Port coServeur ✅ent-n Agonnexio 1. C##LUS
-
-#ÈMES RÉSO# PROBL
-#uccès.
-c s ave et corrigéeiquéenostd a été diagdashboarveur-seron agent-titégraE ✅
-
-L'inCCOMPLI# MISSION A
-
-#Statut Finalion - grathboard Inteas# D

DEPLOY_MANUAL.txt

@@ -1,22 +0,0 @@
-# Déploiement Manuel - Option B
-
-# 1. Sauvegardes
-sudo cp /opt/rpa_vision_v3/server/processing_pipeline.py /opt/rpa_vision_v3/server/processing_pipeline.py.backup_$(date +%Y%m%d_%H%M%S)
-sudo cp /opt/rpa_vision_v3/core/graph/graph_builder.py /opt/rpa_vision_v3/core/graph/graph_builder.py.backup_$(date +%Y%m%d_%H%M%S)
-
-# 2. Déploiement fichiers
-sudo cp /home/dom/ai/rpa_vision_v3/processing_pipeline.py /opt/rpa_vision_v3/server/processing_pipeline.py
-sudo chown rpa:rpa /opt/rpa_vision_v3/server/processing_pipeline.py
-
-sudo cp /home/dom/ai/rpa_vision_v3/graph_builder.py /opt/rpa_vision_v3/core/graph/graph_builder.py
-sudo chown rpa:rpa /opt/rpa_vision_v3/core/graph/graph_builder.py
-
-# 3. Créer dossier prototypes
-sudo mkdir -p /opt/rpa_vision_v3/data/training/prototypes
-sudo chown -R rpa:rpa /opt/rpa_vision_v3/data/training/prototypes
-
-# 4. Redémarrer worker
-sudo systemctl restart rpa-vision-v3-worker.service
-
-# 5. Vérifier statut
-systemctl status rpa-vision-v3-worker.service

DOCUMENTATION_TAB_DISAPPEARING_FIX.md

@@ -1,128 +0,0 @@
-d. intendeity asonalation functihe documentse tess and u now acc. Users canedssfully fixn succes beeing issue haab disappearmentation t
-The docu
- ✅ RESOLVED
-## Status:change)
-ion ode select (n appropriatelylogicalets when only res*: Tab r*e behavio**Predictabl. 
-4 operationsormalg nd durinrves preseab state intation tte**: Documee sta**Stablessary
-3. y necr when trul triggeonly: Effects s**dependenciee 
-2. **Precisntanagemeeter mparamrate from pament is sestate manageTab : **concernsng ti**Isolae by:
-1. core issu the ddressese fix a
-Thcation
-
-## Verifis
-tate updatenders and sary re-renecessced un Redu**:ceman
-- **Perforng behaviorappearised the dist that caument conflicate manage st theminated Elility**:
-- **Stabiaccessiblee now ) arlated tools, reancerameter guidal help, paontextu(ceatures mentation focu*: All dity*alion- **Functterruption
-t inion withouocumentatol dand read tonow access can ce**: Users perienEx
-- **User Impact
-## p
-
-and helmentation textual docuess to con*: Full accfter*nt  
-✅ **Ation contedocumenta read er couldn'tre**: Us
-
-✅ **Befoent nodeferto a difwitching n ss whenly resetter**: Tab o**Afd  
-✅ change parameters eset whend r**: Tab woulforey
-
-✅ **Beindefinitelonal nd functins visible aab remaintation t*: Docume **After*
-✅appear  is then dar brieflyb would appeion ta: Documentatfore**
-✅ **Bex
- After Fiored Behavixpective
-
-## Etay actab should sds - tieln furatioth config Interact wi
-5.main visiblehould ret sen- contds secon. Wait 5+ " tab
-4cumentationon the "DoClick palette
-3. m the ool fro tt any. Selecer
-2Buildow rkflsual Wo Vi1. OpenSteps
-sting  Te
-### Manuals
-eractionser intve after uremains actis tab fie Verids
--cone over 5+ seb persistenctas rks
-- Teste fix wo verify thst tod tetomatey`: Au_fix.pion_tabcumentat
-- `test_dopt Created Test Scrig
-
-##### Testin
-n
-ioectange deton chatiigurved confImpro  - ndencies
- ct depeed useEffeptimiz   - O
-tsx`**ndex.onTab/intatinents/Documec/compoontend/srilder/frlow_bual_workf2. **`visu
-
-resetr tab id]` fo?.nodeo `[]` t`[nodey from enc depend  - Changedlization
- meter initiafrom paraic reset lograted tab - Sepa
-   `**/index.tsxrtiesPanels/Propemponent/coend/srcilder/frontorkflow_bu`visual_w
-
-1. **odified
-## Files M```
-on
-omparis// Stable c; n)])figuratio(currentConON.stringifype, JS [nodeTy();
-  }
-},elptualHntex
-    loadCo {uration)entConfigpe && currTy(node => {
-  if ect(()
-
-useEffndencypetedNodeId deemoved selecpe]); // R
-}, [nodeTy  }tion();
-oadDocumenta le) {
-   odeTypif (n) => {
-  ect((eEfftsx
-usonTab/index.ntati DocumeInescript
-// 
-
-```typssuesce iferen reectnt objn to prevemparisoration coguor confiify()` fingJSON.str**: Used `onerializatiion sigurat**Confnders
-2. ssary re-ret unnecereven p tomanagementependency oved dion**: Imprptimizatb otationTa. **Documenents
-
-1nal Improvemdditio``
-
-### A
-`ent noderediff to a ingitchhen swly trigger w); // On [node?.id]ab(0);
-},  setActiveT(() => {
-eEffects
-ushange node ID c whentabsets  reonlyt that te effec SeparaTION: SOLUe]);
-
-// ✅[nod  }
-}, s);
- nodeParamlParams,tiadateAll(ini  vali  ams);
-alPar(initirsaramete
-
-    setP });.
-   logic ..ion itializat/ ... in  /    ) => {
-amEach((pareParams.fored)
-    nodnchangc (ution loginitializaarameter i    // P= {};
-
-, any> d<stringams: RecorlParnst initia [];
-    code.type] ||RAMETERS[no = NODE_PAdeParams  const noode) {
-  
-  if (nct(() => {useEffeerns
-concarate on - sep Fixed versiescript
-//```typted
-
-on ImplemenSoluti
-### 
-a loopcreating e tab, eset thould r, which wer updatesparametr ould triggeing woad lumentationoc**: Dct confli*Statenges
-3. *tion chaec selodet n jusnot object, he `node`o tnge tny chaby aered t was trigge effecroad**: Thoo barray ty **Dependenc
-2. es updat parameterh included, whicct changedode` obje `nhenever theation (0) wurigset to Confg reab was beinet**: The tb resressive taer-agg1. **Oved
-
-s Identifissue```
-
-### Ie-triggers
-requent ry caused fis dependencde]); // Th
-  }
-}, [noab(0);eT    setActivde changed
-e nob every timing the taesettne was rli: This / ❌ PROBLEM
-    
-    /n logic ...atioializer init... paramet // ) {
-   
-  if (nodeect(() => {
-useEff/index.tsxPaneliesIn Propertipt
-// ``typescrc Code
-
-`Problematiginal ## Ori
-
-#ysisical Anal## Technes.
-
-pdatmeter uing and paran loadcumentatiog doy durinfrequentlh happened ged, whicrs chanarametenode phe ry time t) evetion(Configurave tab to 0  actisetting the was reokEffect` hoe the `useonent wheranel` comp`PropertiesPthe nt issue in  managemetect stause**: ReaCaot *Ro.
-
-*entonton cmentaticuad the dossible to re it impoakingds, m 1-2 seconpear afteren disapicked but thfly when clbrie appear  woulderties Panelilder's Propkflow Buorthe Visual Wb in ation tante docume*Issue**: Thmmary
-
-*Problem Su# e
-
-#ing IssuisappearTab Dentation Docum: # Fix

FICHE_16_REPLAY_SIMULATION_COMPLETE.md

@@ -1,431 +0,0 @@
-Report*lation  Simu6 : Replay#1Fiche ision V3 - A VRP
-*bre 2025*  22 décemo - Alice Kiré par Dom, lément**
-
-*ImpELRATIONN OPÉETE ETCOMPLl :** ✅ **atut Fina
----
-
-**Stnce
-erformang de pmarki- ✅ Benché
-de qualit Validation on
-- ✅ressists de rég ✅ TeCD
--gration CI/
-- ✅ Intépement dévelopilisation en✅ Ut
-- :**t pour 3
-
-**Prê Visionvec RPA Ve aration fluid Intég
-- ✅nteet puissaintuitive - ✅ CLI rnis
-asets foude datples ée
-- ✅ Exemtion détaillenta- ✅ Documstifs
-aunitaires exh✅ Tests ue
-- nnellfonctiocomplète et entation mplém
-- ✅ IForts :**oints 
-**Pses.
-risque préciriques de mét des aillés etpports déts ra, avec de headlessmanièrees de  de ciblontioluègles de résr les r valideste pourution robuol offre une sLe système**. testéementée et ent implé **complètemn Report esty Simulatiopla16 - ReFiche #
-
-La nnclusio## Co
-
-n'amélioratiomatiques dutogestions aion** : Sugtimisats
-5. **Oportre rappue entff automatiqon** : Diis4. **Comparatats
-fs des résules interactiiquaphon** : Grisati3. **Visuals
-blématique procason des  Prédicti ML** :se
-2. **Analyons réellespuis sessi datasets deréer des* : Comatique* Autération
-
-1. **Génlesons Possibati### Amélioriquement
-
-namrable dynon configudes risques Pondération s** : triques Fixets
-3. **Méseta de daomatiquetion autéra de génAuto** : Pasération s de Gén
-2. **Paas de test des cnuelleion maCréats** : sets Manuelta
-1. **Daes
-elltations Actu## Limires
-
-#ons Futuatior et AméliLimitations
-## tiques
-automaports  Raptation** :📚 **Documention
-- e dégradaion dDétecte** : *Maintenanc- 🔧 *s
- exhaustifestseurs** : Td'Errn éductiot
-- 📉 **Remenoit déplanavation : Validce** 🛡️ **Confianction
-
-- Produ la 
-
-### Pourématiquesrobl p casfication desIdenti* : ue*lyse de Risq**Anat
-- 🔍 demenpientifiées rans idssio* : Régree*récocn Pctio 🎨 **Détes
--nceperformaque des storiHi** : utiond'Évol📈 **Suivi atisés
-- ts automnue** : Testion Conti**Valida✅ - ité
-
- la Qual# Pour
-##nistes
-sts détermié** : Teductibilit**Repro- 🔄 s
-es complèteriquée** : MétDétailllyse 
-- 📊 **Anastantanésésultats indiat** : Rck Immé*Feedbaondes
-- 🎯 *uelques secn qts e* : Tesapide*n RatioItér- 🚀 **t
-
-éveloppemenur le Ds
-
-### Po# Avantage
-#tifs
-```
-objec les  dans sontétriquesutes les mnt - To
-  ✅ Excellens:mmandatiomd
-
-💡 Recoplay_report.arkdown : re.json
-  - Mlay_reportrep- JSON : énérés :
-  Rapports g
-
-📄 on)écisi(80.0% pr:   5 cas NTEXT      
-  BY_CO)onisipréc0% s (95.  20 caSITE       :on)
-  COMPO0.0% précisis (9ca30  :      TEXT    on)
-  BY_isi5.6% préc45 cas (9:     _ROLE      ées:
-  BYgies utilis
-
-Straté (<0.3) : 77 casle risqueaib F)
- 3-0.7cas (0.5  1que moyen  :7)
-  Ris>0.cas (evé  : 3 Risque élques:
-  isnalyse des rs/sec
-
-A   : 18.4 cabit       Déas
- 4.2ms/coyen   : 5s
-  Temps m5420.3mal   : mps tot Te
- ce:Performan4
-
-  : 0.23moyen  
-Risque 92.0%): 92 (   ision    )
-Préc.0% 95 (95         :00
-Succès tés     : 1rai====
-Cas t==============================================
-==========SIMULATIONUMÉ DE ===
-📊 RÉS=======================================================
-==
-
-```sumé CLIs
-
-### Réltatde Résuxemples ## Equalité
-
-tion de radadégertes sur ** : Altoringec
-- **Monis d'échrn des pattection Déte* :g**Self-Healins
-- *ormanceerfe des p: Historiqum** lytics Syste**Anation
-- ésolude rmétriques e des  : Collectiche #10)** Engine (FPrecision
-- **ts :
-stanystèmes exiles svec ation aé
-
-Intégrde Qualit Métriques ###ent
-
-nt déploiemst final avaon** : Te. **Validatiions
-6 recommandaton lesster seltion** : Aju
-5. **Itéra Markdownapportsminer les rxa: Eyse** 
-4. **Anal"`t "**atasecli.py --dlation_eplay_simuython rt** : `pple **Test Com`
-3.*"ev_dataset "don_cli.py --mulati replay_sipython : `st Local**s
-2. **Tees fiche lgles danss rèr leodifie: M** ementDéveloppt
-
-1. **emen Développw dekflo
-### Woron V3
-c RPA Visiégration ave
-
-## Int``
-`.md.md complexsimpleébit" 
-grep "Dces performanarer lesd
-
-# Compx.mmpleut-md co--omplex_*" "co-dataset li.py -mulation_creplay_sion mplexe
-pythet cotas
-# Dale.md
-simpt-md -ou_*" -"simplet se--dataon_cli.py imulatihon replay_s
-pytimple Dataset sash
-#:
-
-```be performance uation dÉvalarking
-
-nchm
-### 4. Be```
-port.md
-refull_-md se --outrbo**" --ve-dataset "on_cli.py -y_simulatihon replataillée
-pytlyse dé
-
-# Anataset "**"--daion_cli.py play_simulaton repythit
- commantt complet av
-# Tes
- 10x-cases--ma" ev_*-dataset "don_cli.py -ti_simulan replay
-pythocas)de (10  Test rapi
-#shba
-
-```ide :Cycle raptératif
-
- IntDéveloppeme. 
-### 3"
-```
-s passedestssion tgre"✅ All recho 
-
-exit 1
-fi
-    eXIT_CODE"e: $Ed! Exit codecteion det Regress"❌
-    echo enne 0 ]; thEXIT_CODE -
-
-if [ $IT_CODE=$?
-EX*" --quietssion_egre"rataset --dtion_cli.py imulaay_sn repl
-
-pythosion.sht_regres
-# tesh
-#!/bin/bas
-```bash
-/CD :n CIIntégratio
-
-ngn Testiessio## 2. Régr```
-
-#)
- after.jsoncy_rate'curadata.acq '.meta     <(j \
-n)re.jsobefoy_rate' ta.accurac.metadaq 'diff <(jparer
-
-
-# Comonter.jst-json afpy --oun_cli.mulation replay_sition
-pythoodifica
-# Après m
-onjsore.json beft---oution_cli.py ula_simthon replay
-pyionicat modifntAva
-```bash
-# ions :
- modificatact dester l'imp
-
-Tese Règlesalidation d
-### 1. Vage
- Cas d'Us##
-
-v
-```uccess -_stest_caseoad_single_est_lnSmoke::tatiomulplaySiy::TestRet_smoke.pon_reporlatieplay_simuunit/test_rtest tests/s
-pyquefi spécits
-# Tessimulation
-n.replay_tioua.evaly --cov=coreport_smoke.pimulation_ret_replay_sessts/unit/test teerture
-pyt
-# Avec couve.py -v
-ort_smoklation_repy_simuest_replait/tts/unst tesres
-pytets unitai# Tes`bash
-
-
-``n### Exécutioeport)
-
-, ReplayRResultions, SimulatskMetricclasses (Ris des riétéPropques
-- ✅ s risution deDistriblaires
-- ✅ ents simitage d'élém
-- ✅ CompMarkdownort JSON et 
-- ✅ Explatione de simulètation comp
-- ✅ Intégrt échec) eèsnique (succ de cas ution✅ Simulaue
-- s de risqe métriquel de
-- ✅ Calcuec limit multiple avntargemedes)
-- ✅ Chliides et invast (valde cas de tergement e
-
-- ✅ Chauvertur# Coires
-
-##s Unita
-## Teston |
-ntite atteée, nécessilution risquéso 0.7-1.0 | Revé |ller |
-| Élrvei mais à su acceptablesolution-0.7 | Ré.3
-| Moyen | 0uë |mbigon ae et n fiabl Résolution-0.3 | 0.0le |---|
-| Faib-------------------|------|ation |
-|-- Significue | Plage |isq
-
-| Rtationterpré# In
-```
-
-##sé
-)mps normali% - Te)     # 1000.0, 1.0/ 10time_ms 1 * min(  0.rsée
-  Marge inve - 0% +     # 2p1_top2)- margin_to0 (1.  0.2 * e
-  ce inversé% - Confian    # 30_score) + ncefidecon3 * (1.0 - 
-    0.té0% - Ambiguï # 4        core +     y_siguit.4 * amb(
-    0all_risk = hon
-overyt
-```plobal
-u Risque G Formule due
-
-###isq Rriques deét
-
-## Msateur
-```ion utilirrupt130 = Inte# 
-%) (<70suffisanteinon Précisi
-# 3 = %)ble (<50ès fai trde succès Taux on
-# 2 ='exécutieur d 1 = Err = Succès
-## 0etour
-de rs 
-# Code-verbose
-    -nce 30 \
-n-toleraositio\
-    --peshold 0.8 ilarity-thrsim \
-    --.mdmd report   --out-.json \
- son resultst-j-ou  -\
-  es 50  --max-cas_*" \
-   et "formdatas --.py \
-   _cli_simulationhon replayyt
-pescéns avanOptio
-# i.py
-imulation_cleplay_sthon rsique
-pyUsage ba
-# `bash
-``I
-face CLer
-### 5. Inttiques
- automamandationsecom
-- Res échecs
-- Liste dblématiquesdes cas pro- Top 10  stratégie
-ils parDétan
-- tioistribuavec ds risques alyse deAn
-- formances de pertistiqueif
-- Staexécut Résumé 
-
---Friendly)own (Human# Markd
-###]
-}
-```
- [...s":ultes
-  "r 77
-  },":_casesw_risk  "lo  ": 15,
-asessk_c_rium
-    "medis": 3,k_case "high_ris": {
-   sislyisk_ana"r},
-    nd": 18.4
-es_per_seco
-    "cas4.2,s": 5me_mon_tiolutig_res    "av: {
-tats"formance_s"per  
-  },
-234: 0.e_risk"erag
-    "av 0.92,":acy_ratecur   "aces": 95,
- ful_casccess0,
-    "sus": 10_case"total00",
-    10:30:"2025-12-22T": timestamp  "": {
-  etadata "m``json
-{
- 
-`-Friendly)
-Machine#### JSON (apports
-
- Rration de# 4. Géné``
-
-##
-`sk  # 0.156rirall_ove_metrics.isk = risk)
-overall_r(0.0-1.0bal  risque glode
-
-# Score on
-)solutide rémps   # Tes=23.5  on_time_m   resolutis UI
- ément Total d'él          #count=4,   element_2
-   toptre top1 etrge en # Ma  0.15,  op2=argin_top1_t
-    m resolverConfiance du  # re=0.9,    ce_scoiden  confilaires
-  imts sémenmbre d'él     # No.2, score=0  ambiguity_(
-  ricsskMetetrics = Rik_m
-risythons
-
-```pde Risquecul ## 3. Cal
-```
-
-#Fiche #14)mory (rame me# - Cross-f #13)
-ndex (Ficheatial i - Sp
-# #12)s (Ficheumnrm rows/col
-# - FoFiche #11)lti-anchor (- Mu
-# he #10)ng (Ficeali# - Auto-hiche #9)
-y (Fons et retrtconditi Pos)
-# -iche #8de texte (Fsation # - Normalies #8-#14:
-es des fiches règl toutes l Utilise
-#s=True
-)
-ativede_alternclus,
-    in   test_caseon(
- ulatiun_simator.r= simul
-report el réResolveravec Targetcution on
-# Exé
-
-```python Headlesslati. Simu```
-
-### 2elles)
-s optionntadonnéea.json (Mémetadatdu)
-# - ten(Résultat atted.json xpec# - e)
-ntraintests et coc avec hintSpeson (Targespec.jt_targemplet)
-# - te con (ScreenStastate.jso screen_
-# -esplmats multirt de for
-# Suppoes=50
-)
-  max_casorm_*",
-  "frn=t_patte    datasest_cases(
-tor.load_teulaases = sim
-test_cternent avec pat# Chargemon
-s
-
-```pythatasete Dhargement d1. C### entées
-
-plémnnalités Imio
-
-## Fonctéestadonnson : Mé- metadata.j   t attendu
-n : Résultaed.jso  - expectntes
- rai avec contRésolutionon : get_spec.jstar  - on
- d'inscriptiFormulaire e.json : reen_stat
-   - sc/`**rm_002foet/example_tass/datest **`nnées
-
-6.tado.json : Méetadata
-   - mtendusultat atn : Réexpected.jso
-   - boutonon de ésoluti: Rec.json - target_sp
-   re de loginn : Formulaijsote._sta
-   - screenm_001/`**fort/example_ase*`tests/datle
-
-5. *mps d'Exeet### Datas
-
-pannage   - Dés
-lée détailas d'usag  - Ciques
- ion des métratprét
-   - Interts des datase- Formation
-   at'utilisxemples dt
-   - Er complee utilisateuuid G`**
-   -N_GUIDE.mdIOATREPLAY_SIMULdocs/guides/on
-
-4. **`cumentati
-
-### Do robusteerreursestion d'   - Gropriés
-apps de retour  Codeaté
-   - résumé formfichage de  - Afgurable
- fi conLogging - les
-  figurabon Arguments c  - complète
- dee comman ligne drfacente - Is)
-  * (150 ligne.py`*tion_cliplay_simula`re
-3. **
-## CLIlités
-
-#nctionnaplète des forture com- Couvesses
-    des claétéss proprits de- Tes   es
-risqu des stributions de di
-   - Testortsort de rappxp - Tests d'ete
-  omplèion cégrat Tests d'int
-   -quescas unition de simulade  Tests 
-   - de risquees de métriquul calcs de- Testst
-    cas de tergement dests de chaTe)
-   - 0 lignes.py`** (65smoke_report_ulationsimy_plaest_re/t*`tests/unit
-2. *ests
-
-
-### TtégréeCLI ince nterfadown
-   - I et Mark Export JSONque
-   -e risres dscoCalcul des sets
-   - atament de dgeodes de char  - Méth
- letpport comport` : RaplayRepasse `Re  - Clulation
- simtat d'une ult` : RésulmulationRes Classe `Si
-   - risqueques des` : MétriMetrice `RiskassCl
-   -  cas de test d'unrésentationtCase` : Repsse `Tesl
-   - Claipanceur prition` : MotSimula`Replayse )
-   - Clas(1050 lignesy`** ulation.p/replay_simvaluation`core/e1. **tation
-
-ore Implemen
-
-### Cers Créés Fichiis
-
-##test fourn de tasets** : Daxemples **Eillé  
-✅teur détalisati** : Guide untationcumeDo✅ **plète  
-comte de tests  Suiitaires** :ts Un
-✅ **Tesitive  e intue commandace ligne d* : InterfComplet*I CLébit  
-✅ ** det de temps es : Métriqu**Performance)  
-✅ ** (humain+ Markdownmachine) x** : JSON (pports Duaup2  
-✅ **Ra1/totopnce, marge onfia, c : Ambiguïté**e Risque **Scores d 
-✅s les fiches  avec toutegetResolverTarlise * : Utielles* Ré*Règlesse  
-✅ * UI requiinteractionAucune s** : Headles
-
-✅ **100% tteintsectifs A
-## Objormance.
-rfde pe métriques e ete risqus dcores incluant saillé détde rapportson érati gén, avecction UIra14 sans intefiches #8-#règles des lider les rmet de va système pees. Leon de cibl résolutides règles headless des  pour teston ReportmulatiSie Replay èmdu systète pln comntatioléme
-
-Imp
-## RésuméSTÉ
-TET IMPLÉMENTÉ E :** ✅ tatut
-**S 2025  bre 22 décemDate :** 
-**iro lice Km, Ar :** Do
-
-**Auteu COMPLETE ✅t -ation ReporSimulReplay 16 - he #ic# F

FICHE_18_APPRENTISSAGE_PERSISTANT_COMPLETE.md

@@ -1,148 +0,0 @@
-# Fiche #18 - Apprentissage persistant "mix" (JSONL + SQLite) ✅
-
-**Auteur**: Dom, Alice Kiro  
-**Date**: 22 décembre 2025  
-**Statut**: COMPLET ✅
-
-## 🎯 **Objectif**
-
-Implémenter un système d'apprentissage persistant pour la résolution de cibles UI utilisant une architecture "mix" :
-- **JSONL** : Audit trail append-only pour tous les événements de résolution
-- **SQLite** : Lookup table rapide pour retrouver les fingerprints appris
-
-## 🏗️ **Architecture implémentée**
-
-### **Composants créés**
-
-1. **`core/learning/target_memory_store.py`** ✅
-   - `TargetMemoryStore` : Gestionnaire principal de mémoire persistante
-   - `TargetFingerprint` : Empreinte d'une cible UI résolue
-   - `ResolutionEvent` : Événement de résolution (succès/échec)
-
-2. **`core/execution/screen_signature.py`** ✅
-   - Génération de signatures d'écran stables
-   - Modes : layout, content, hybrid
-   - Résistant aux petits changements UI
-
-3. **Intégration dans `TargetResolver`** ✅
-   - Lookup depuis mémoire persistante (priorité haute)
-   - Enregistrement des succès/échecs
-   - Configuration via paramètres d'initialisation
-
-4. **Intégration dans `ActionExecutor`** ✅
-   - Hooks après validation post-conditions
-   - Enregistrement automatique des apprentissages
-
-### **Structure de données**
-
-```
-data/learning/
-├── events/YYYY-MM-DD/
-│   └── resolution_events.jsonl    # Audit trail
-└── target_memory.db               # Lookup SQLite
-```
-
-## 🔧 **Fonctionnalités implémentées**
-
-### **1. Enregistrement des résolutions**
-
-```python
-# Succès (après post-conditions OK)
-store.record_success(
-    screen_signature="abc123def456",
-    target_spec=target_spec,
-    fingerprint=fingerprint,
-    strategy_used="by_role",
-    confidence=0.95
-)
-
-# Échec (après post-conditions KO)
-store.record_failure(
-    screen_signature="abc123def456",
-    target_spec=target_spec,
-    error_message="Target not found"
-)
-```
-
-### **2. Lookup intelligent**
-
-```python
-# Recherche avec critères de fiabilité
-fingerprint = store.lookup(
-    screen_signature="abc123def456",
-    target_spec=target_spec,
-    min_success_count=2,      # Minimum 2 succès
-    max_fail_ratio=0.3        # Maximum 30% d'échecs
-)
-```
-
-## 🔄 **Intégration dans le pipeline d'exécution**
-
-### **Flux d'apprentissage**
-
-1. **Résolution de cible** → `TargetResolver.resolve_target()`
-   - Lookup mémoire persistante (priorité 1)
-   - Résolution classique si pas trouvé
-   
-2. **Exécution d'action** → `ActionExecutor.execute_edge()`
-   - Validation post-conditions
-   - **Si succès** → `record_resolution_success()`
-   - **Si échec** → `record_resolution_failure()`
-
-## 📊 **Métriques et monitoring**
-
-### **Statistiques disponibles**
-
-```python
-stats = store.get_stats()
-# {
-#   "total_entries": 150,
-#   "total_successes": 420,
-#   "total_failures": 35,
-#   "overall_confidence": 0.887,
-#   "jsonl_files_count": 5,
-#   "jsonl_total_size_mb": 2.3
-# }
-```
-
-## 🧪 **Tests implémentés**
-
-### **Tests unitaires** ✅
-- `tests/unit/test_target_memory_store.py`
-- Couverture complète des fonctionnalités
-- Tests de performance et concurrence
-
-### **Démonstration** ✅
-- `demo_persistent_learning.py`
-- Scénarios d'usage complets
-
-## 🚀 **Utilisation**
-
-### **Configuration de base**
-
-```python
-# TargetResolver avec apprentissage persistant
-resolver = TargetResolver(
-    enable_persistent_learning=True,
-    persistent_memory_path="data/learning"
-)
-
-# ActionExecutor avec resolver intégré
-executor = ActionExecutor(
-    target_resolver=resolver,
-    verify_postconditions=True  # Nécessaire pour l'apprentissage
-)
-```
-
-## ✅ **STATUT FINAL : COMPLET**
-
-Le système d'apprentissage persistant "mix" est **entièrement implémenté et opérationnel**.
-
-**Livrables** :
-- ✅ Code source complet et testé
-- ✅ Tests unitaires avec couverture complète
-- ✅ Démonstration fonctionnelle
-- ✅ Documentation technique détaillée
-- ✅ Intégration dans le pipeline d'exécution
-
-**Prêt pour utilisation en production** 🚀

FICHE_20_TYPESCRIPT_ERRORS_FIXED_FINAL.md

@@ -1,125 +0,0 @@
-# FICHE 20 - TypeScript Compilation Errors Fixed - FI
-
-## Status: ✅ COMPLETE
-
-The Visual Workflow Besolved.
-
-## Issues Fixed
-
-###y Issues
-- **VisualScreenSelector embedding**: Fch
-- **Date vs string types**: Ensured consistent string format for A
-mismatch
-
-### 2. Import and Export Issues
-- *
-
-- **CacheStats export**: Maable
-
-### 3. Null Safety Issues
-uration
-- **ImageCache**: Fixed po
-- **Performanandling
-
-### 4. Test File Exclusion
-- **tsconfig.jsonuild
-- *ion
-
-
-- **String methods**
-
-## Files Modified
-
-### Core Type Definitions
-- `visual_workflow_builder/frontend/srs`
-  - Fixed `genera
-  -types
-
-### Components
-- `visual_workflow_builx.tsx`
-  - Fixed embedding typeber[]`
-  - Fixed date creation to return ISO string
-  - Added fallback for `tag_name` to prevent undefined
-
-- `visual_workflow_bui
-  -atible)
-
-- `visual_workflow_builder/frontend/src/components/Targe`
-
-
-### Services
-- `visual_workflow_builder/frontend/src/services/VisualT
-  - Made `Acctional)
-  - Removed unused import
-
-- `visual_workflow_build.ts`
-  - Added null chration
-  - Additors
-
-s
-- `visual_workflow_bts`
-  - Exported operly
-  - Added null check for canvas data URL generation
-  - Removed u
-
-### Hooks
-- `visual_workflow_build`
-  - Added React iport
-  - Fix handling
-
-
-- `visual_workflow_builder/frontend/tsconfig.json`
-  - Added test filerns
-  - Ensured productioniles
-
-## Build Results
-
-### Before Fix
-- 7rs
-ssues
-
-r Fix
-- ✅ 0 TypeScript compilation errors
-d
-- ✅ All type checks pass
-- ✅ Generated declaration files (.d.ts)
-
-## Verification Commands
-
-```bash
-# Type 
-cd visual_workflow_builder/frontend
-npx tsc --noEmit
-
-# Pd
-ild
-
-# Both 
-```
-
-## e
-
-All fixes maintain compliance
-
-- **Material-UI integration**: Prerns
-- **TypeScript best practices**: Msafety
-- **Component architecture**: No breaking changes to existing APIs
-- **Performance optimization**: Maintained caching and optimization features
-
-## Next Steps
-
-The Visual Workflow Builder fronteady for:
-
-1. **Development**: All TypeScript errors resolved
-2. **Production deployment**: Clean build with no compilation errors
-3. **Integration testing**: Type-safe integration with backend APIs
-4. **Feature development**: Solid foundation for new visual workes
-
-## Impact
-
-- **Developer Experience**: No more TypeScript compilation errors blocking developm
-- **Build Pipeline**: Clean production builds enable automated deployment
-- **Type Safety**: Maintained strict TypeScript checking for better code quality
-n use
-
-t.enpmed develofor continul and ready tionarally openow fus ompilation ipeScript crontend Tyow Builder fWorkfll e VisuaTh

FICHE_22_AUTO_HEAL_HYBRIDE_PROGRESS.md

@@ -1,186 +0,0 @@
-hes.tres fic les auvections aégras intt pour lebase et prêde s d'usage  les ca pournelfonctionème est 
-Le syst
-ésément implantsr compose pouomplèt*: Cntation*- **Documelètes
-*: 1/4 compégrations*0%
-- **Int*: ~8nnelle*nctioure foouvert%)
-- **C(85nts  passa/40taires**: 34sts uni- **Te Qualité
-
-deiques étr``
-
-## Mreport()
-`status_et_ger.grt = manaus_repo1")
-statlow_mode("workfet_manager.gent_state = 
-currétatérifier l't)
-
-# V, resul"step_1"low_1", sult("workftep_reanager.on_stat
-    mer le résultrnregis  # E...)
-  on(te_actit = execusul   reaction
- r l'  # Exécutete:
-  ould_execu_1")
-if sh", "steporkflow_1"w(execute_stephould_r.sanage reason = mecute,
-should_exaped'étution  exéc
-# AvantManager()
-alAutoHeer = ion
-manag Initialisat
-#ager
-HealManport Autonager imauto_heal_masystem.
-from core.
-```pythonation
-lis
-## Uti}
-```
-p": 5
-ions_to_kee  "max_vers1800,
-on_s": uratiine_dquarant  "20,
-  
-o": 0.n_fail_rati "regressio,
- 50": dow_stepsinsion_wres
-  "regon": true,essick_on_regr  "rollba,
-: true"egradedning_in_dle_lear
-  "disab,
-  d": 0.08egradeop1_top2_dargin_tmin_m2,
-  ".8 0_degraded":n_confidencemi  "0.72,
-: l"ence_norman_confid
-  
-  "mi,indow": 30_winfail_max_lobal_ 10,
-  "gin_window":x_low_fail_ma,
-  "workfow_s": 600windil_ow_fa"workfl": 3,
-  _degradedak_to_fail_streepst "",
- : "hybrid  "mode"json
-{
-mple
-
-```ion Exeigurat
-## Conflles
-onnées réec d avetionn
-4. Validaioe dégradatscénarios ds de st3. Teets
- complgrations d'inté
-2. TestedStoreion Versestsrriger les tn
-1. Coiolidatet Va Tests rité 3:
-
-### Prioion de précisues*: Métriqe #10*ch
-4. **Fisistantntissage perppregration a#18**: Inté **Fiche n
-3.atios de simulpportion de raénérathe #16**: GFicique
-2. **omatording autrecase ailureC*: F*Fiche #19*e
-1. *ons Systèm: Intégratié 2Priorit## taires
-
-# uniles testsiser nalFi
-3. neace commuinterfune  Créer e
-2. circulairr l'importr pour éviteise1. Refactor Breaker
- Circuitdresou 1: Rété
-### Priories
-nes Étap
-## Prochais
- avant/aprèmanceforde per- Métriques aut)
-r défrsions pa 5 veue (gardeutomatiqyage a- Nettoles
-ersions stab vers vbackoll
-- Rgentissa'appreposants ds des comutomatiqueSnapshots a
-- oningVersi Système de ent)
-
-###uleming senutes (loggux en 10 mi globaecs: 30 échOBAL PAUSE**- **GLow
-n workfl pour u0 minuteséchecs en 1: 10 NTINED****QUARA étape
--  unecutifs sur consé 3 échecsDEGRADED**:iques
-- ** AutomatDéclencheursel
-
-### rrêt manu: A- **PAUSED**récédente
-n version p RestauratioK**:AC**ROLLBble
-- t configuraimeouc tavere êt temporaiNED**: ArrTIARAN
-- **QUésactivétissage den 0.82), appr (confiance:ls augmentés Seui*:DEGRADED*0.72)
-- **ce: uil confian normale (se*: ExécutionING*
-- **RUNNine d'Étatch Males
-
-###nnelératioOpités tionnal## Fonc
-
-
-```️ning ⚠ versio    # Testse.py      _storedersiont_v
-└── tesles ✅ Tests modèels.py    #_moddataeal_to_hst_au tenit/
-├──/utses ✅
-
-tnfigurationn    # Co_policy.jsoeal
-└── auto_h/config/
-
-datang ✅nirsiostème de ve   # Sy    re.pyioned_stovers
-└── ng/
-core/learniaker ⚠️
-uit bre   # Circ  reaker.py  circuit_b
-└──  ✅entralaire ctionny     # Ges.panager auto_heal_mem/
-├──
-core/syst``entée
-
-`cture Implémhite
-## Arc
-n hot-reloadratiofiguk)
-  - Con (fallbaceaker brvec circuittion a- Intégra
-  les seuilsasées sur tomatiques b auionsransit
-  - Tccèschecs et sustion des éGe  - K, PAUSED)
-LBACNTINED, ROLQUARADED, GRANNING, DEcomplète (RU'état achine d*:
-  - Mémentées*mplalités inctionn
-- **Foy`_manager.po_healautstem/ `core/syer**:hi ✅
-- **Ficationnager IntegrMa AutoHealable
-
-###non importais classe  m implémentéeogique*Status**: Lanager
-- *ns AutoHealMFallback daaire**: ution temporol`
-- **Sker.pycuit_brea.py` et `cireal_manager`auto_hlaire entre port circuImblème**: ️
-- **Pro class ⚠itBreakerreate Circu
-
-### 2.1 Cs 🔄our CTâches Enes
-
-##  dynamiqutimestampsvec Tests a FAISS
-  - chierses fiopie dants
-  - Ces existtoirperdes réon sti*:
-  - Geés*dentifiProblèmes i
-- **passantstests 3/19 s**: 1tu
-- **Stay`oned_store.pversist_unit/te**: `tests/ichierre ⚠️
-- **F stonedfor versio unit tests teWri# 3.4 ées
-
-##adonnes mét - Gestion d versions
- ques detatistins
-  - Snes versio ancienatique desyage autom
-  - Nettontesprécédeersions  vers vllback  - RoSQLite
-e ISS, mémoirindices FAotypes,  prots denapshot
-  - Sés**:tionnalit`
-- **Foncre.pysioned_stong/vere/learni: `cor****Fichier-  ✅
-lasstore cnedS Versiolement### 3.1 Impmplets
-
-gration cos d'intécle  - Cyitiques
- poltion desra Configuantes
-  -gliss- Fenêtres 
-  ationalissériion/déialisats
-  - Sért transitionats en des étlidatio:
-  - Vaests pour**
-- **Tspassanttests e**: 21 urvertpy`
-- **Cou_models.datauto_heal__ast/tenit`tests/uhier**: 
-- **Ficata models ✅ts for desit t4 Write un
-
-### 1.iresilitaodes utéthétat
-  - Mansitions d's tration de- Valid   complète
-lisationériaation/déslis
-  - Sériaalités**:onncti*Fon)
-- *versionons de ` (informatisionInfoe)
-  - `Verissantfenêtre glow` (eWind  - `Failur)
-'échec(événement dlureEvent`  - `Fai
- low)d'un workfo` (état ionStateInf - `Executlides)
- tions vaec transienum av` (ionStatexecut  - `Eées**:
- implémentasses.py`
-- **Clager_manalhesystem/auto_: `core/r**Fichie✅
-- **data models ement base Impl
-### 1.3 lencheurs
-es déc tous lourles p configurab - Seuilsggressive
-  avative,serid, conybrModes: h
-  - litiquesdes poload  Hot-reidation
-  -vec valSON aiguration Jonf
-  - C*:alités*onn- **Fonctianager.py`
-uto_heal_mystem/a`core/sfig` dans Cone**: `Policy**Classson`
-- y.jpoliceal_nfig/auto_h*: `data/co **Fichier*ystem ✅
--guration sy confipolicate re
-### 1.1 Cminées ✅
- Terâches
-
-## Tngereux.est dat quand c'e localemenêt'arrt flou, et sc'esd res quanritèes c et durcit lntitle sûr, ra que c'ester tant à fonctionne continue Le systèmrité.sécurvice et e secontinuité d équilibre uiybride qng h'auto-healime d systè dutationeném
-
-Impl
-
-## Résumé avancées- Tâches 1-3cours *: En tus*Sta 2024  
-**écembre de**: 23*Dat
-*ent
-ancemt d'Avybride - Étato-Heal H #22 Au# Fiche

FICHE_22_PROGRESS.md

@@ -1,112 +0,0 @@
-es fiches. les autravecons atintégrur les irêt pode base et pge usaes cas d' lnnel pourtiofoncystème est Le st()
-```
-
-orreptus_get_stat = manager.tus_repor)
-staw_1""workfloget_mode( = manager.rrent_stateétat
-cu l'
-# Vérifierlt)
-1", resuep_stflow_1", "rk"wo_result(on_steper.    managrésultat
-le trer    # Enregison(...)
- execute_actiult = 
-    reser l'actionxécut # E
-   execute:uld_)
-if sho1"ep_1", "st"workflow_ute_step(hould_exec = manager.scute, reasonexee
-should_tion d'étap Avant exécuger()
-
-#utoHealManaanager = Ation
-malisati
-
-# InierlManageaimport AutoHr _managem.auto_heale.systefrom corython
-on
-
-```plisati
-
-## Utiaprèsavant/mance e perfor d
-- Métriquesaut)par défons arde 5 versimatique (gtoyage auto- Netles
-stabions k vers versRollbac
-- ageprentissposants d'aps comques deatipshots autom- Snaioning
-e Verse d Systèment)
-
-###ulemses (logging  10 minuteobaux englcs E**: 30 écheUSOBAL PAGL **ow
--kflour un wornutes p0 mi échecs en 1NTINED**: 10- **QUARAne étape
-ifs sur us consécut échecADED**: 3*DEGRes
-- *Automatiqucheurs  Déclen
-
-###êt manuelSED**: Arrnte
-- **PAUcédeprén ioerstion vstaura**: ReLLBACK **ROurable
--fig conoutc timeaveire temporaD**: Arrêt ARANTINEtivé
-- **QU désacageprentiss ap: 0.82),(confiances augmentés ED**: SeuilEGRAD)
-- **D 0.72ce:euil confianle (sn norma**: Exécutio*RUNNING- *t
-chine d'ÉtaMa
-
-### ationnelless Opérnctionnalité
-
-## Fo ⚠️
-```rsioning Tests ve         #.py sioned_store─ test_ver✅
-└─es sts modèly    # Temodels.pal_data_he─ test_auto_t/
-├─ests/uni✅
-
-tguration Confion    # y.js_polic auto_healonfig/
-└──/c✅
-
-dataersioning Système de v  #    ore.py  sioned_stg/
-└── verarninre/le
-
-coreaker ⚠️uit bCirc  # aker.py     uit_brerc
-└── cintral ✅ire cenna   # Gestioager.py  l_man├── auto_heare/system/
-
-```
-coplémentée
-tecture Im
-## Archidonnées
- méta Gestion desersions
-  -de vs Statistiqueons
-  - nes versi des ancientomatiqueauettoyage entes
-  - Ncédrsions prévers veRollback - e
-   SQLitSS, mémoire FAIes, indices de prototypshots- Snap:
-  nnalités***Fonctioe.py`
-- *ned_storsioing/verarn`core/ler**: 
-- **Fichiee class ✅orrsionedStement Ve 3.1 Implets
-
-###plion comégratcles d'intues
-  - Cytiqn des poliio- Configurat
-  ntesêtres glissaFenion
-  - rialisattion/désélisas
-  - Sériansitionats et tra des étonati:
-  - Validour**Tests p- **sants
-tests pasrture**: 21 ve**Cou.py`
-- ta_models_da_auto_healit/test*: `tests/un- **Fichier*els ✅
-for data modts  tesunitrite # 1.4 W##s
-
-itairees utilodétht
-  - M'étaransitions dtion des talidae
-  - Vomplètation csérialisation/délisria Sé:
-  -nalités****Fonctionersion)
-- mations de vinforionInfo` (rs
-  - `Veante) glissenêtreeWindow` (f  - `Failurc)
-t d'écheévénemenlureEvent` (ailow)
-  - `Frkfd'un wot  (étaeInfo`ionStat- `Executalides)
-  sitions vrannum avec tte` (eionStaut - `Execes**:
- implémentélasses **C- .py`
-anageruto_heal_m/system/a`core*: Fichier*
-- **dels ✅e data mot bas Implemen 1.3heurs
-
-###ncécleus les dbles pour touras configSeuil - 
- ggressivetive, arva conses: hybrid,es
-  - Modetiqudes polioad rel  - Hot-tion
-validaJSON avec guration - Confi  nalités**:
- **Fonctionpy`
--eal_manager.em/auto_hyst/s` dans `corePolicyConfigsse**: `Cla**y.json`
-- heal_polico_a/config/aut `datFichier**:m ✅
-- **ation systeconfigureate policy .1 Cr## 1ées ✅
-
-#s Terminche Tâeux.
-
-## dangerestnt quand c'e localeme s'arrêtflou, etest s quand c'es critère lrcitet dulentit , raue c'est sûr tant qonctionner finue àconte système curité. Le et sérvicté de sentinuire coi équilibg hybride quauto-healinme d'n du systèntatioé
-
-ImplémesumRées
-
-##  1-3 avancéesrs - Tâch**: En cou
-**Statusembre 2024  te**: 23 déc
-**Daancement
-tat d'Avde - Éybrial H-Hetoiche #22 Au# F

FICHE_23_API_SECURITY_GOVERNANCE_COMPLETE.md

@@ -1,228 +0,0 @@
-és sécurisux endpointsuveas no sur le équipesdesFormation s
-- s existantrviceec les seon avtitégrasts d'inion
-- Teroductnnement p d'enviroariablestion des vConfiguraest
-- nnement de ten envirot iemenplo**
-- Déecommandées: étapes rnes**Prochai
----
-
-on V3.
-e RPA Visiécosystèms l'te dan complè intégrationbuste et unerité ro une sécution avecuca prodrêt pour l pme est
-
-Le systè d'urgencer modes* pouion*tegrat Switch Inafetyés
-7. ✅ **Ss intégrécorateure** avec dwarsk Middle
-6. ✅ **Flas sécuriséesceendanec dép avMiddleware***FastAPI  ✅ *uré
-5.ructt JSONL st* en formadit Logging**Au
-4. ✅ * algorithmetoken buck tecavLimiting** **Rate . ✅ upport  
-3 et proxy s avec CIDR** Allowlistn
-2. ✅ **IPxpiratios et e rôle avecon**Authenticati ✅ **Token 1.
-
-s:fonctionnelsants  compoec tous lesMENTÉE** avLÉT IMPÈTEMENest COMPLance vern GoI Security &he #23 - AP
-
-**Ficsionnclu
-
-## Colocalhostnt avec IPs loppemeéve✅ Mode dcurisée
-- ut séion par défa✅ ConfiguratastAPI)
-- lask/F (Fnels option ✅ Importst
--ème Existan# Systente
-
-## transparontiigras
-- ✅ Mng changekirea ✅ Pas de bxistant
--in-Token eX-Admt ✅ Supporide)
-- to-Heal Hybr2 (Auche #2# Fiité
-
-##atibilRétrocomp
-
-## ritée sécuviolations dles r veille*: Surring*nitoe
-5. **Mohivagl'arcet otation urer la r: Config**
-4. **Logsnduege attea charter selon l**: Ajus Limits. **Ratestructure
-3on l'infrahe selncblaer la liste  Configur
-2. **IPs**:)caractèress (32+ rets fort secer desis: Util**Tokens**iement
-1. Déplotions mmanda
-### Reconces
- pour urgeitchon kill-sw✅ Intégratiormation
-- nfns fuite d'ierreurs san des Gestioc.)
-- ✅ s, ettion, X-Frame-OpCSPécurité (ders de sHea✅ NL
--  en JSOl complett trai- ✅ Audi les abus
-e contrestimiting robu✅ Rate l- ec CIDR
-IPs avdes on stricte Validati
-- ✅ 56)MAC-SHA2sécurisés (Hnt aphiquemecryptogrs - ✅ Tokenctées
-gences Respe# Exiuction
-
-##té Prod# Sécurimum
-
-#ONLY minien READ_Requiert tokytics/*`: /anal `/apion IP
--validativalide + en  tokiert Requs/upload`:session
-- `/api/ngitiate limlide + rvaken uiert to: Req/execute`/workflowsMIN
-- `/api token AD: Requiert/admin/*`- `/apiés
-ints Protég
-
-### Endposessionssé des écurid s/`): Uploa`agent_v0gent V0** (act
-- ✅ **AFrontend Relask +  Backend Fbuilder/`):w_l_workfloisuar** (`vdelow Buill Workfisuaask
-- ✅ **Vrface Fl): Inteoard/`_dashb (`webboard**ash ✅ **Web D
--ec FastAPIEST av`): API R`server/* ( **Server*
-- ✅atiblesmpices Co# Serv V3
-
-##ionvec RPA Visgration a## Inté`
-
-py
-``curity.e23_api_sechst_fihon3 tees)
-pyteurons mintie correcessitomplet (néc
-
-# Test ce.pysimplst_fiche23_
-python3 te rapideTestsh
-# `ba
-``elleon Manu# Validatis)
-
-##ssaireéceineures norrections m(avec cplets  Tests com`:y.pyi_securitiche23_ap_fst
-- ✅ `tenelsase fonctionTests de bimple.py`: 23_sst_fichete✅ `és
-- ément# Tests Impln
-
-##alidatio Tests et V```
-
-##y.com"
-panadmin@comCT="TACY_CONGEN2"
-EMER1,featuretureATURES="feaED_FEh
-DISABLwitcill_so_safe|kemrmal|dnormal"  # E="noSAFETY_MODtch
-ety Swie"
-
-# SafIVE="truSH_SENSIT_HAITUD"
-A10S="LOG_MAX_FILE
-AUDIT_# 10MB485760"  10_MAX_SIZE="DIT_LOG
-AU"logs/auditT_LOG_DIR="
-AUDIingudit Logg5"
-
-# AIN="30:MIT_API_ADM0"
-RATE_LI120:2ORKFLOWS="LIMIT_API_W
-RATE_="10"_LIMIT_BURSTEFAULT_RATE="60"
-DIT_RPMULT_RATE_LIMting
-DEFA# Rate Limi"true"
-
-OCKED_IPS=
-LOG_BLue""tr_HEADERS=PROXYE_1"
-ENABL0.6.0.1,10.0.XIES="172.1TED_PRO
-TRUS0/8"0.0.0.0/24,1.168.1.0.0.1,192IPS="127.ALLOWED_st
-li
-# IP Allow"24"
-IRY_HOURS=
-TOKEN_EXPébilitatiRétrocomp"  # -admin-tokencyOKEN="legaADMIN_Token-1"
-X_"readonly-tS=D_ONLY_TOKEN2"
-REAn-in-tokeadm-token-1,dminN_TOKENS="aDMI
-Auction"odpry-change-in-cret-keY="your-seECRET_KEns
-TOKEN_Sash
-# Tokement
-```b d'Environneblesariate
-
-### Vmplèon Corati Configu
-##ence
-ions d'urges activatogging d
-- ✅ Lensibless stionnalitéque des fonctiutomactivation a
-- ✅ Désa KILL_SWITCHEMO_SAFE,AL, Des NORMs modespect dey`
-- ✅ R.pwitchty_ssafere/system/avec `coplète comIntégration  ✅ on
--ratintegwitch I Sty## 7. Safe``
-
-#
-`ig": {...}}turn {"conf
-    rein_config():def adm_admin
-k_require")
-@flasnfigin/cooute("/admpp.r)
-
-@ay(applask_securit_)
-init_fme_nask(__Fla
-app = in
-_require_admlaskurity, fflask_sect_rt iniy impoecurit.flask_s.securitycore
-from *
-```python**Usage:*ques
-
-automati sécurité Headers de
-- ✅ és personnalisres d'erreurionnai
-- ✅ Gestinfo`/token/tyecuri/sstatus`, ` `/security/s:ires utilitaoutelet
-- ✅ Rsetup compr )` pousecurity(k_init_flas `- ✅ Fonctionoken`
-y_tk_require_anflasdmin`, `@sk_require_as: `@fla✅ Décorateur
-- equestuest/after_rfore_req bek aveceware Flas Middlpy`)
-- ✅y.uritflask_secre/security/(`coeware  Middlity Flask Secur`
-
-### 6.}
-``rs": [...]turn {"use    reoken)):
-e_admin_t(requir Depends =olerole: TokenRer_et_users(us def g
-async")rs/use"/admin
-@app.get(
-_tokendminire_at requity imporapi_secururity.faste.secfrom corhon
-e:**
-```pyt
-
-**Usag Switchon Safety✅ Intégrati
-- riésappropP s HTTc codeeurs avetion des err
-- ✅ Ges)ons, etc.Frame-Optié (CSP, X-e sécurit ders ✅ Headateur
--le utilis rôque duomatin autExtractio- ✅ oken`
-_any_t`require`, _admin_tokenrequi: `rendances Dépe- ✅ons
-ificatiles véroutes plet avec tomre cddlewa✅ Mity.py`)
-- tapi_securiurity/fasecare (`core/siddlew Security M5. FastAPI
-
-### e tokensons dValidatiTION`: EN_VALIDATOKsées
-- `non autori IPs CKED`:P_BLO
-- `Iimites de lssementsEEDED`: DépaIMIT_EXC
-- `RATE_Ltéesations détecTION`: ViolIOLAURITY_V
-- `SECtus codesc stadpoints aveccès aux en`: AAPI_ACCESS
-- `échouéessies/ons réusonnexi CTION`:ENTICA`AUTH*
-- ts:*d'événemen*Types  UTC
-
-*01SO 86ps Itams
-- ✅ Timesplètelles comes contextuetadonné
-- ✅ Mé etc.violation,security_cess, , api_acticationts: authens d'événemen✅ Type- sibles
-nées senes donhage d
-- ✅ Haclogstique des ion automaotatacile
-- ✅ Ring fé pour parsNL structurormat JSO- ✅ Flog.py`)
-it_security/aud (`core/SONLing Jgg. Audit Lo
-### 4ue
-```
-écifiq sp  # endpoint20:20"FLOWS="1I_WORK_LIMIT_AP
-RATE"10"_BURST=RATE_LIMITLT_0"
-DEFAU"6MIT_RPM=_RATE_LIULT
-DEFAsh**
-```ban:tio**Configurary_after
-
-c retveeded` aitExceRateLimn `✅ Exceptiofs
-- nactikets ides bucomatique age auttoy
-- ✅ NetteLimit-*)X-Ratifs (informaTTP  Headers Hcity)
-- ✅burst capaible (RPM, flexration gufionint
-- ✅ Ceur, endpo utilisatr IP,ion paimitatue
-- ✅ Lautomatiqc refill veen bucket aithme tok)
-- ✅ Algor.py`rate_limitery//securitore(`cn Bucket  Tokeng avecate Limiti
-
-### 3. R
-```"true"XY_HEADERS=E_PRO1"
-ENABL.0.0.10172.16.0.1,_PROXIES="ED8"
-TRUST0/0/24,10.0.0.1.1,192.168..0.0."127S=ED_IPash
-ALLOWn:**
-```bguratioonfi
-**Cdéfaut
-r avec IPs pament développe Mode 
-- ✅oquéesPs bldes ILogging  ✅ ement
--ronnenvid'variables uration par fig
-- ✅ ConX-Real-IPFor, rwarded-c X-Fofiance avee con ✅ Proxies d24)
--92.168.1.0/IDR (ex: 1ges C- ✅ Pla et IPv6
-t IPv4 ✅ Supporst.py`)
--ip_allowlie/security/corCIDR (`avec  Allowlist ### 2. IPging
-
-bug()` pour denfo_safeget_token_iace `Interf`
-- rorlidationErTokenVaavec `es erreurs  dstion
-- Gein-Tokendm-AToken, Xr, X-API-Bearerization port Autho- Supature`
-ign|scenonres_at||expirole|user_id: `ec payloadés av sign Tokens**
--s:clés nnalitéionct**Fo
-
-P multiplesers HTTeadn depuis h ✅ Extractioste
--que robuptographition cryValida
-- ✅ e #22) (fichmin-Token avec X-AdtéiliompatibRétroc ✅ okens
--es tfigurable dn conpiratio ✅ ExLY
--t READ_ONes ADMIN ert des rôlppo- ✅ SuHA256
-ec HMAC-Savcurisés s séion de tokenrat)
-- ✅ Génépy`pi_tokens.y/asecuriton (`core/catised Authenti 1. Token-baentés
-
-###pléms Immposant
-
-## Coudite débit et alimitation dtion, orisa, autationntificuthemplet avec aPI coité Ae sécurstème djectif**: Sy**Obre 2025  
-mb*: 24 déce
-
-**Date*EPLÉMENTÉtatut: ✅ IMLETE
-
-## S COMPernance - Gov Security & APIe #23 -ch# Fi

FICHE_23_COMPLETE.md

@@ -1,166 +0,0 @@
-urisésdpoints séc en suripes équtionFormastants
--  exiec services avtionégra'ints don  
-- Testent producti'environnemiables dvares figuration dContest
-- ement de vironn enment enie
-- Déplos étapes:**
-**Prochaine3.
-
----
-PA Vision Vme Rl'écosystè dans mplète co intégration et unerobusterité vec une sécu* aproduction*ur la *prêt postème est * syLealidés
-
-nels v fonctionsts#22
-8. ✅ Tehe  avec fictibilitéétrocompa Rnce
-7. ✅ges d'urdech pour moty Switgration Safe✅ Intéi
-6. à l'emploask prêts astAPI et Flares Flew5. ✅ Middé en JSONL
-urging structAudit log
-4. ✅ ken bucketavec to robuste iting lim Rateies
-3. ✅R et proxort CIDc suppche IP aveListe blan ✅ c rôles
-2.ave tokens ion paruthentificat Système d'ac:
-
-1. ✅ENTÉE** aveIMPLÉMOMPLÈTEMENT nance est C& Goverecurity  - API S#23**Fiche 
-
- Conclusion
-
-##ion finaleumentatTE.md` - Doc_23_COMPLECHEns
-- `FIicatioSpécif- nts.md` quiremence/reovernaurity-g/api-secpecs/s
-- `.kiro mineures)correctionslets (s comppy` - Testi_security.e23_apst_fiche ✅
-- `teels de basionnct - Tests fon_simple.py`_fiche23ston
-- `teocumentatiet D
-### Tests  jour)
-isés (mis àtralrts cen` - Impo_.pynit_/__iurity- `core/secware Flask
-Middlety.py` - ecuriy/flask_se/securit- `corAPI
-eware Fastddl - Miity.py`stapi_secururity/fa `core/secit JSONL
--g d'audginog.py` - Log/audit_lre/securitycocket
-- `token bue débit  don - Limitatir.py`ate_limite/security/rcore
-- `ec CIDRche IP avblanListe t.py` - lowlisalp_ity/isecur`core/ns
-- ion par tokeficattithenns.py` - Auokeity/api_turec- `core/sre
-dules Co
-### Moréés
-hiers C Fic##ente
-
- transparigrations
-- Mgeng chanas de breaki- PastAPI)
-s (Flask/Fs optionnelImport22
-- fiche #a ken de lToin-rt X-Adm✅
-- Suppoité ilrocompatib## Rét
-
-#r urgencespouswitch 
-- ✅ Kill-é standardurit séc✅ Headers deL
--  JSONetl complaiAudit tr abus
-- ✅ contre lesng itiim ✅ Rate l
--DRte avec CIicIP stration - ✅ Validsés
-ement sécuriographiquypt✅ Tokens crs
-- pectéences Resxige
-### En ✅
-uctio Produrité
-
-## SécNLY minimumen READ_O: Tokcs/*`nalyti `/api/aP
--alidation I`: Token + v/uploadi/sessionsing
-- `/ape limitalide + rat Token vws/execute`:workflo `/api/requis
--ADMIN n/*`: Token dmi/api/a- `égés
-nts Protoidp# En
-##ens
-sé avec tokcurioad sé: Uplgent V0**sé
-- **AFlask sécurickend r**: BaldeWorkflow Bui*Visual   
-- *séesécuri set routesécorateurs  D (Flask):Dashboard**ts
-- **Web endances prê dépetiddleware stAPI): M** (Fa **Server✅
--s patiblevices Comer V3
-
-### Ssion RPA Vintégration## I
-```
-
-h_switce|killsaf|demo_# normall"  ="normaTY_MODESwitch
-SAFEafety 
-
-# S0MB5760"  # 1"1048E=SIZIT_LOG_MAX_t"
-AUDogs/audiLOG_DIR="lT_ogging
-AUDIAudit L"10"
-
-# _BURST=IMITTE_L
-DEFAULT_RAM="60"_LIMIT_RPULT_RATEg
-DEFAte Limitin
-# Ra"
-0.0.16.0.1,10..1ES="172RUSTED_PROXI
-T.0/8"0.0.04,192.168.1.0/2127.0.0.1,1_IPS=" 
-ALLOWEDP Allowlist ité
-
-# Irocompatibil"  # Rétmin-tokeny-adOKEN="legacIN_Tn-2"
-X_ADMdmin-toke-token-1,a="adminDMIN_TOKENSuction"
-Aange-in-prodcret-key-chY="your-seKERET_
-TOKEN_SEC Tokensbash
-#s
-```ment Cléronnees d'Enviariablion
-
-### Von Productrati
-## Configuh
-afety Switc SgrationtéSONL
-- ✅ Informat Jgging en it loAud
-- ✅ atifsrs informvec headeimiting aRate l✅ 1.0/24)
-- , 192.168.27.0.0.1ec CIDR (1tion IP avda✅ Vali
-- n de tokenslidatioet vanération tés
-- ✅ Géessants T## Compo
-#
-```
-tionntegra Iety Switch SafNL
-  •ing JSOdit Loggting
-  • Aue Limi Rat
-  •DR  ist avec CI Allowl IPcation
-  •sed Authenti• Token-ba
-  validées:ités tionnaloncÉE
-
-📋 FENTMPLÉMce: Iernanovty & Gecuri23 - API SFiche #ENT!
-✅  PASSSTS LES TEOUStat:
-🎉 Tsul.py
-
-# Réimpleiche23_s test_fpython3de - PASSE
- rapi Test
-```bash
-#ctionnels ✅ts Fon
-
-### Tesations et Valid
-## Testty()
-urik_seclasnit_fec i complet av- Setupsonnalisés
-d'erreur pernaires onsti
-- Gefoen/inty/tokuritus, /seccurity/staitaires: /setes util
-- Routokenquire_any_, @flask_reinadmire_sk_requateurs: @flae ✅
-- DécordlewarSecurity Midlask 
-### 6. Fh
-y Switcon SafettégratiIn
-- )-OptionsFrameé (CSP, X-e sécurit dHeadersn
-- e_any_tokeoken, requir_tre_adminces: requipendanDétions
-- icaifoutes véravec tre complet - Middlewaleware ✅
- MiddurityFastAPI Sec5. s
-
-###  complèteellescontextunées - Métadonensibles
-es données sachage don
-- Hiolati_vcuritys, sen, api_accestiouthentica Types: a
--otation avec ruréructt JSONL stma
-- For ✅SONL Joggingit L
-### 4. Aud
-s inactifs des buckettiqueautomaNettoyage -*)
-- imitifs (X-RateLTP informateaders HTint
-- Hateur/endpolispar IP/utiation que
-- Limittima autoavec refillt  token buckeAlgorithmeket ✅
--  Token Bucimitinge L. Rat
-
-### 3autr défec IPs paement avde développment
-- Monneenviroar exible pration fl- ConfiguFor)
-warded-ance (X-Fore confi- Proxies des CIDR
-Pv6 et plagt IPv4/I 
-- SupporR ✅ st avec CIDP Allowli
-
-### 2. InI-TokeAPearer, X-on Bti Authoriza
-- Supportche #22)fiToken (X-Admin-ité bilpati
-- Rétrocom expirationavecONLY /READ_MIN- Rôles ADHA256
-risés HMAC-Sokens sécuération ton ✅
-- Génhenticatid Autseoken-ba
-
-### 1. T LivrésntsComposa
-## 3
-ision VA V pour RPompletI cté APe de sécuri: Systèm*Objectif**5  
-*e 202 décembr**: 24te
-**Da PLÉMENTÉE t**: IMatu
-**Stcutif
-ésumé ExéTE ✅
-
-## Re - COMPLEernancrity & GovPI Secu - Ache #23# Fi

FILES_CREATED_PHASE11.txt

@@ -1,139 +0,0 @@
-FICHIERS CRÉÉS - PHASE 11 : OUTILS D'AMÉLIORATION CONTINUE
-═══════════════════════════════════════════════════════════
-
-Date: 23 novembre 2025
-
-SCRIPTS PYTHON (3)
-──────────────────
-1. analyze_failed_matches.py (327 lignes, 12K)
-   - Analyse statistique des échecs de matching
-   - Identification des nodes problématiques
-   - Recommandations de seuil
-   - Export JSON
-
-2. monitor_matching_health.py (180 lignes, 5K)
-   - Monitoring temps réel
-   - Système d'alertes
-   - Mode continu
-   - Sauvegarde historique
-
-3. auto_improve_matching.py (355 lignes, 14K)
-   - Amélioration automatique
-   - UPDATE_PROTOTYPE, CREATE_NODE, ADJUST_THRESHOLD
-   - Mode simulation
-   - Application sécurisée
-
-DOCUMENTATION (4)
-─────────────────
-4. MATCHING_TOOLS_README.md (2.5K)
-   - Guide d'utilisation complet
-   - Workflow recommandé
-   - Exemples de cas réels
-   - Dépannage
-
-5. QUICK_START_MATCHING_TOOLS.md (4.0K)
-   - Démarrage rapide
-   - Commandes essentielles
-   - Interprétation des résultats
-
-6. PHASE11_MATCHING_IMPROVEMENT_TOOLS.md (8.7K)
-   - Documentation technique complète
-   - Architecture des données
-   - Métriques de succès
-   - Intégration CI/CD
-
-7. SUMMARY_PHASE11.md (8.1K)
-   - Résumé exécutif
-   - Statistiques
-   - Bénéfices et apprentissages
-
-TESTS (1)
-─────────
-8. test_matching_tools.sh (1.6K)
-   - Tests automatisés des 3 outils
-   - Création de données fictives
-   - Vérification du bon fonctionnement
-
-CHANGELOG (1)
-─────────────
-9. CHANGELOG_PHASE11.md (5.6K)
-   - Historique des changements
-   - Fonctionnalités ajoutées
-   - Modifications apportées
-
-RÉSUMÉS (1)
-───────────
-10. PHASE11_COMPLETE.txt (3.5K)
-    - Résumé ultra-concis
-    - Vue d'ensemble complète
-    - Utilisation rapide
-
-FICHIERS MODIFIÉS
-─────────────────
-- INDEX.md
-  + Ajout section "Outils d'Amélioration Continue"
-  + Liens vers tous les nouveaux fichiers
-  + Workflow recommandé
-
-- core/graph/node_matcher.py (Phase 10)
-  + Ajout _log_failed_match()
-  + Ajout _generate_suggestions()
-  + Intégration dans _match_linear()
-
-TOTAL
-─────
-Fichiers créés:        10
-Fichiers modifiés:     2
-Lignes de code:        ~850
-Documentation:         ~30 pages
-Tests:                 ✅ Automatisés
-Statut:                ✅ Production Ready
-
-STRUCTURE DES DONNÉES
-─────────────────────
-data/
-├── failed_matches/              # Échecs enregistrés
-│   └── failed_match_YYYYMMDD_HHMMSS/
-│       ├── screenshot.png       # Capture d'écran
-│       ├── state_embedding.npy  # Vecteur 512D
-│       └── report.json          # Rapport complet
-│
-└── monitoring/                  # Métriques de santé
-    └── matching_health_YYYYMMDD.jsonl  # Historique
-
-COMMANDES RAPIDES
-─────────────────
-# Analyse
-./analyze_failed_matches.py --last 10
-./analyze_failed_matches.py --since-hours 24
-./analyze_failed_matches.py --export rapport.json
-
-# Monitoring
-./monitor_matching_health.py
-./monitor_matching_health.py --continuous
-./monitor_matching_health.py --continuous --interval 30
-
-# Amélioration
-./auto_improve_matching.py
-./auto_improve_matching.py --apply
-./auto_improve_matching.py --min-confidence 0.70
-
-# Tests
-./test_matching_tools.sh
-
-DOCUMENTATION
-─────────────
-Quick Start:       QUICK_START_MATCHING_TOOLS.md
-Guide Complet:     MATCHING_TOOLS_README.md
-Doc Technique:     PHASE11_MATCHING_IMPROVEMENT_TOOLS.md
-Résumé:            SUMMARY_PHASE11.md
-Changelog:         CHANGELOG_PHASE11.md
-Résumé Concis:     PHASE11_COMPLETE.txt
-Liste Fichiers:    FILES_CREATED_PHASE11.txt (ce fichier)
-
-═══════════════════════════════════════════════════════════
-Phase 11 : ✅ COMPLÉTÉ
-Date: 23 novembre 2025
-Durée: ~2 heures
-Statut: Production Ready
-═══════════════════════════════════════════════════════════

INTEGRATION_VALIDATION_TYPESCRIPT_AUTOMATIQUE_COMPLETE_12JAN2026.md

@@ -1,64 +0,0 @@
-# Intégration Validation TypeScript Automatique - COMPLETE
-
-**Auteur :** Dom, Alice, Kiro  
-**Date :** 12 janvier 2026  
-**Statut :** ✅ TERMINÉ
-
-## Mission Accomplie
-
-L'intégration de la validation TypeScript automatique dans la task list du Visual Workflow Builder est **complètement terminée**.
-
-## Réalisations
-
-### ✅ Corrections TypeScript
-- Corrigé toutes les erreurs TypeScript dans les fichiers VWB
-- Supprimé les imports et variables inutilisés
-- Validation : `npx tsc --noEmit` ✅ 0 erreur
-
-### ✅ Script de Validation Automatique
-- Créé `scripts/validation_typescript_automatique_vwb_12jan2026.py`
-- Validation TypeScript + compilation build automatique
-- Messages en français, gestion d'erreurs robuste
-
-### ✅ Intégration Task List
-- Modifié `.kiro/specs/visual-workflow-builder/tasks.md`
-- Ajouté 12 tâches de validation TypeScript après chaque modification frontend
-- Format standardisé et cohérent
-
-### ✅ Tests d'Intégration
-- Créé `tests/integration/test_validation_typescript_automatique_integration_12jan2026.py`
-- 8 tests d'intégration avec 100% de réussite
-- Validation complète du processus
-
-### ✅ Documentation
-- Documentation complète dans `docs/`
-- Conformité aux règles du projet (français, attribution auteur)
-- Guide d'utilisation et processus détaillé
-
-## Validation Finale
-
-```bash
-# Test du script
-python3 scripts/validation_typescript_automatique_vwb_12jan2026.py
-# ✅ Vérification TypeScript réussie - aucune erreur
-# ✅ Compilation de build réussie
-
-# Test d'intégration
-python3 tests/integration/test_validation_typescript_automatique_integration_12jan2026.py
-# ✅ Ran 8 tests in 51.778s - OK
-```
-
-## Impact
-
-- **Stabilité TypeScript** garantie après chaque modification
-- **Processus automatisé** intégré au workflow de développement
-- **Prévention des régressions** dans le frontend VWB
-- **Qualité de code** maintenue en permanence
-
-## Prêt pour Utilisation
-
-Le système est **opérationnel immédiatement** et peut être utilisé dès la prochaine modification du frontend VWB.
-
----
-
-🎉 **MISSION COMPLETE** - Validation TypeScript automatique intégrée avec succès

LOCALISATION_REALDEMO_COMPLETE_08JAN2026.md

@@ -1,283 +0,0 @@
-# Localisation du Composant RealDemo - Implémentation Complète
-
-> **Extension du système de localisation RPA Vision V3**  
-> Auteur : Dom, Alice, Kiro - 8 janvier 2026
-
-## 🎯 Résumé de l'Implémentation
-
-Le composant RealDemo du Visual Workflow Builder a été entièrement localisé, étendant le système de localisation existant avec 3 nouvelles clés de traduction dans les 4 langues supportées.
-
-## 📊 Statistiques Mises à Jour
-
-### Avant l'Implémentation
-- **Total des clés** : 127 traductions
-- **Composant RealDemo** : Texte codé en dur en français
-
-### Après l'Implémentation
-- **Total des clés** : 156 traductions (+3 nouvelles clés)
-- **Composant RealDemo** : Entièrement localisé
-- **Couverture** : 100% dans les 4 langues
-
-## 🔧 Modifications Apportées
-
-### 1. Nouvelles Clés de Traduction
-
-#### Structure Ajoutée dans Tous les Fichiers JSON
-
-```json
-{
-  "realDemo": {
-    "component": {
-      "title": "Démonstration Réelle - RPA Vision V3",
-      "description": "Ce composant permettra de tester le système RPA en temps réel.",
-      "startButton": "Démarrer la Démonstration"
-    }
-  }
-}
-```
-
-#### Traductions par Langue
-
-| Clé | Français | Anglais | Espagnol | Allemand |
-|-----|----------|---------|----------|----------|
-| `title` | Démonstration Réelle - RPA Vision V3 | Real Demonstration - RPA Vision V3 | Demostración Real - RPA Vision V3 | Echte Demonstration - RPA Vision V3 |
-| `description` | Ce composant permettra de tester le système RPA en temps réel. | This component will allow testing the RPA system in real time. | Este componente permitirá probar el sistema RPA en tiempo real. | Diese Komponente ermöglicht es, das RPA-System in Echtzeit zu testen. |
-| `startButton` | Démarrer la Démonstration | Start Demonstration | Iniciar Demostración | Demonstration Starten |
-
-### 2. Composant RealDemo Modifié
-
-#### Code Avant (Texte Codé en Dur)
-```typescript
-return (
-  <Box sx={{ p: 3 }}>
-    <Typography variant="h5" gutterBottom>
-      Démonstration Réelle - RPA Vision V3
-    </Typography>
-    
-    <Typography variant="body1" paragraph>
-      Ce composant permettra de tester le système RPA en temps réel.
-    </Typography>
-    
-    <Button variant="contained" startIcon={<PlayIcon />} onClick={handleExecute}>
-      Démarrer la Démonstration
-    </Button>
-  </Box>
-);
-```
-
-#### Code Après (Localisé)
-```typescript
-import { useLocalization } from '../../services/LocalizationService';
-
-const RealDemo: React.FC<RealDemoProps> = ({ onWorkflowExecute }) => {
-  const { t } = useLocalization();
-
-  return (
-    <Box sx={{ p: 3 }}>
-      <Typography variant="h5" gutterBottom>
-        {t('realDemo.component.title')}
-      </Typography>
-      
-      <Typography variant="body1" paragraph>
-        {t('realDemo.component.description')}
-      </Typography>
-      
-      <Button variant="contained" startIcon={<PlayIcon />} onClick={handleExecute}>
-        {t('realDemo.component.startButton')}
-      </Button>
-    </Box>
-  );
-};
-```
-
-## ✅ Validation et Tests
-
-### Validation Automatique Réussie
-
-```bash
-$ python3 i18n/validate_translations.py
-
-🔍 Démarrage de la validation des traductions...
-📋 Validation de la configuration...
-📂 Chargement des fichiers de traduction...
-✅ Chargé: fr.json
-✅ Chargé: en.json
-✅ Chargé: es.json
-✅ Chargé: de.json
-🔍 Validation de la structure...
-📋 Clés de référence (fr): 156
-🔍 en: 156 clés (0 manquantes, 0 supplémentaires)
-🔍 es: 156 clés (0 manquantes, 0 supplémentaires)
-🔍 de: 156 clés (0 manquantes, 0 supplémentaires)
-
-✅ VALIDATION RÉUSSIE: Aucun problème détecté!
-```
-
-### Validation TypeScript
-
-- ✅ **Compilation** : Aucune erreur TypeScript
-- ✅ **Types** : Hook `useLocalization` correctement typé
-- ✅ **Imports** : Service de localisation importé correctement
-- ✅ **Fonctionnalité** : Comportement du composant préservé
-
-## 🌍 Expérience Utilisateur Multilingue
-
-### Interface en Français (par défaut)
-```
-Titre : "Démonstration Réelle - RPA Vision V3"
-Description : "Ce composant permettra de tester le système RPA en temps réel."
-Bouton : "Démarrer la Démonstration"
-```
-
-### Interface en Anglais
-```
-Titre : "Real Demonstration - RPA Vision V3"
-Description : "This component will allow testing the RPA system in real time."
-Bouton : "Start Demonstration"
-```
-
-### Interface en Espagnol
-```
-Titre : "Demostración Real - RPA Vision V3"
-Description : "Este componente permitirá probar el sistema RPA en tiempo real."
-Bouton : "Iniciar Demostración"
-```
-
-### Interface en Allemand
-```
-Titre : "Echte Demonstration - RPA Vision V3"
-Description : "Diese Komponente ermöglicht es, das RPA-System in Echtzeit zu testen."
-Bouton : "Demonstration Starten"
-```
-
-## 🎨 Respect du Design System
-
-### Cohérence Visuelle Maintenue
-- ✅ **Material-UI** : Utilisation des composants existants
-- ✅ **Thème sombre** : Couleurs du design system respectées
-- ✅ **Typographie** : Variants Material-UI (`h5`, `body1`)
-- ✅ **Espacement** : Padding et marges cohérents (`sx={{ p: 3 }}`)
-- ✅ **Icônes** : Material-UI Icons (`PlayArrow`)
-
-### Responsive Design
-- ✅ **Breakpoints** : Adaptation automatique Material-UI
-- ✅ **Longueur des textes** : Traductions adaptées à l'interface
-- ✅ **Mise en page** : Structure préservée dans toutes les langues
-
-## 🔄 Intégration avec l'Existant
-
-### Cohérence Terminologique
-- **"Démonstration"** : Cohérent avec `realDemo.title` existant
-- **"RPA Vision V3"** : Nom du produit maintenu identique
-- **"Temps réel"** : Terminologie cohérente avec les traductions existantes
-
-### Architecture Préservée
-- ✅ **Service existant** : Utilisation de `LocalizationService` sans modification
-- ✅ **Cache** : Pas d'impact sur les performances
-- ✅ **Fallback** : Mécanisme de secours automatique maintenu
-- ✅ **Persistance** : Choix de langue utilisateur préservé
-
-## 📈 Métriques de Qualité
-
-### Technique
-- **Erreurs de validation** : 0
-- **Erreurs TypeScript** : 0
-- **Couverture de localisation** : 100%
-- **Impact performance** : Négligeable
-
-### Fonctionnel
-- **Changement de langue** : Instantané
-- **Persistance** : Fonctionnelle
-- **Fallback** : Automatique vers français
-- **Interface** : Cohérente dans toutes les langues
-
-### Linguistique
-- **Traductions naturelles** : Validées
-- **Conventions culturelles** : Respectées
-- **Longueur appropriée** : Vérifiée
-- **Cohérence terminologique** : Maintenue
-
-## 🚀 Utilisation Pratique
-
-### Pour les Développeurs
-
-```typescript
-// Import du hook de localisation
-import { useLocalization } from '../../services/LocalizationService';
-
-// Utilisation dans le composant
-const { t } = useLocalization();
-
-// Traduction des textes
-<Typography>{t('realDemo.component.title')}</Typography>
-```
-
-### Pour les Utilisateurs
-
-1. **Changement de langue** : Via le sélecteur de langue existant
-2. **Persistance** : Le choix est sauvegardé automatiquement
-3. **Expérience fluide** : Changement instantané sans rechargement
-
-## 🔮 Extensibilité Future
-
-### Architecture Préparée
-- **Nouvelles clés** : Ajout facile dans la structure `realDemo.component.*`
-- **Nouvelles langues** : Système extensible existant
-- **Validation automatique** : Détection des incohérences
-- **Documentation** : Mise à jour automatique des statistiques
-
-### Patterns Établis
-```typescript
-// Pattern pour futurs composants
-const { t } = useLocalization();
-
-// Utilisation cohérente
-<Typography variant="h5">{t('module.component.title')}</Typography>
-<Button>{t('module.component.action')}</Button>
-```
-
-## 📋 Checklist de Validation
-
-### Implémentation
-- [x] Nouvelles clés ajoutées dans les 4 fichiers JSON
-- [x] Composant RealDemo modifié pour utiliser la localisation
-- [x] Import du service de localisation ajouté
-- [x] Toutes les chaînes externalisées
-
-### Validation
-- [x] Script de validation automatique passé (0 erreur)
-- [x] Compilation TypeScript réussie (0 erreur)
-- [x] Structure JSON cohérente dans toutes les langues
-- [x] Clés nommées selon les conventions
-
-### Qualité
-- [x] Traductions naturelles et idiomatiques
-- [x] Cohérence avec les traductions existantes
-- [x] Respect des conventions culturelles
-- [x] Longueur appropriée pour l'interface
-
-### Documentation
-- [x] Spécification complète créée
-- [x] Documentation mise à jour
-- [x] Statistiques actualisées
-- [x] Exemples d'utilisation fournis
-
-## 🎉 Conclusion
-
-L'implémentation de la localisation du composant RealDemo est **entièrement réussie** :
-
-- ✅ **3 nouvelles clés** traduites dans 4 langues
-- ✅ **156 traductions** au total (vs 127 précédemment)
-- ✅ **Validation automatique** sans erreur
-- ✅ **Cohérence parfaite** avec le système existant
-- ✅ **Expérience utilisateur** multilingue de qualité
-- ✅ **Architecture extensible** pour futures localisations
-
-Le composant RealDemo offre maintenant une **expérience utilisateur internationale complète**, s'intégrant parfaitement dans l'écosystème de localisation RPA Vision V3 ! 🌍✨
-
----
-
-**Prochaines étapes recommandées :**
-1. Tester l'interface dans les 4 langues via le navigateur
-2. Valider l'expérience utilisateur avec des locuteurs natifs
-3. Documenter ce pattern pour les futurs composants à localiser

MISSION_COMPLETE.txt

@@ -1,172 +0,0 @@
-═══════════════════════════════════════════════════════════════
-  🎉 MISSION COMPLETE - 1er Décembre 2024
-═══════════════════════════════════════════════════════════════
-
-✅ OBJECTIF: Compléter Tasks 8, 9, 10, 14 + Intégration
-
-📊 RÉSULTAT FINAL:
-
-  Task 8 (Analytics)      : ✅ 95% (19/19 impl + 10/16 tests)
-  Task 9 (Composition)    : ✅ 100% (14/14 impl + 22/22 tests)
-  Task 10 (Self-Healing)  : ✅ 100% (8/8 impl + 9/9 tests)
-  Task 14 (Monitoring)    : ✅ 95% (11/11 impl + 13/15 tests)
-  Integration ExecutionLoop: ✅ 100% COMPLETE
-
-  GLOBAL: 98% COMPLETE - PRODUCTION READY 🚀
-
-═══════════════════════════════════════════════════════════════
-
-📦 LIVRABLES (16 fichiers):
-
-Phase 1 - Implémentations (8 fichiers):
-  ✅ SuccessRateCalculator (320 lignes)
-  ✅ ArchiveStorage (380 lignes)
-  ✅ RetentionPolicyEngine
-  ✅ ReportGenerator (420 lignes)
-  ✅ DashboardManager (450 lignes)
-  ✅ AnalyticsAPI (380 lignes)
-  ✅ AnalyticsSystem (220 lignes)
-  ✅ tasks.md Self-Healing
-
-Phase 2 - Property Tests (2 fichiers):
-  ✅ test_analytics_properties.py (10 tests)
-  ✅ test_admin_monitoring_properties.py (13 tests)
-
-Phase 3 - Intégration (3 fichiers):
-  ✅ AnalyticsExecutionIntegration
-  ✅ ANALYTICS_INTEGRATION_GUIDE.md
-  ✅ demo_integrated_execution.py
-
-Documentation (3 fichiers):
-  ✅ ANALYTICS_QUICKSTART.md
-  ✅ SESSION_01DEC_ANALYTICS_COMPLETE.md
-  ✅ SESSION_01DEC_INTEGRATION_COMPLETE.md
-
-═══════════════════════════════════════════════════════════════
-
-📈 STATISTIQUES:
-
-  Lignes de code    : 7,000+ lignes
-  Fichiers créés    : 16 fichiers
-  Property tests    : 23 tests (54/62 total)
-  Documentation     : 10 documents
-  Demos             : 3 demos fonctionnels
-  Erreurs           : 0
-  Durée session     : ~6 heures
-  Qualité           : Production-ready
-
-═══════════════════════════════════════════════════════════════
-
-🚀 FONCTIONNALITÉS COMPLÈTES:
-
-Analytics:
-  ✅ Collection automatique de métriques
-  ✅ Stockage time-series (SQLite)
-  ✅ Analyse de performance (avg, median, p95, p99)
-  ✅ Détection de bottlenecks
-  ✅ Détection d'anomalies
-  ✅ Génération d'insights automatiques
-  ✅ Calcul de taux de succès
-  ✅ Catégorisation des échecs
-  ✅ Classement de fiabilité
-  ✅ Tracking temps réel avec ETA
-  ✅ Archivage avec compression gzip
-  ✅ Politiques de rétention automatiques
-  ✅ Rapports (JSON, CSV, HTML, PDF)
-  ✅ Dashboards personnalisables
-  ✅ API REST (15+ endpoints)
-
-Intégration:
-  ✅ Hooks ExecutionLoop
-  ✅ Collection transparente
-  ✅ Intégration self-healing
-  ✅ Gestion d'erreurs robuste
-  ✅ Performance optimisée (<1% overhead)
-
-═══════════════════════════════════════════════════════════════
-
-🎯 UTILISATION:
-
-# Tester l'intégration
-python demo_integrated_execution.py
-
-# Tester analytics complet
-python demo_analytics.py
-
-# Intégrer dans votre code
-from core.analytics.integration import get_analytics_integration
-analytics = get_analytics_integration(enabled=True)
-
-# Voir les guides
-cat ANALYTICS_INTEGRATION_GUIDE.md
-cat ANALYTICS_QUICKSTART.md
-
-═══════════════════════════════════════════════════════════════
-
-🏆 IMPACT:
-
-Avant:
-  ❌ Pas d'analytics centralisé
-  ❌ Collection manuelle
-  ❌ Pas de tracking temps réel
-  ❌ Pas de corrélation self-healing
-
-Après:
-  ✅ Analytics complet et automatique
-  ✅ Collection transparente
-  ✅ Tracking temps réel avec ETA
-  ✅ Corrélation complète
-  ✅ Insights automatiques
-  ✅ Rapports automatiques
-  ✅ Dashboards temps réel
-  ✅ API REST complète
-
-═══════════════════════════════════════════════════════════════
-
-✨ HIGHLIGHTS:
-
-  1. Système analytics COMPLET et fonctionnel
-  2. 23 property tests validant la correction
-  3. Intégration ExecutionLoop TRANSPARENTE
-  4. Documentation EXHAUSTIVE
-  5. 3 demos FONCTIONNELS
-  6. 0 erreurs de diagnostic
-  7. Production-ready
-  8. Performance optimisée
-  9. Extensible et maintenable
-  10. Prêt à l'emploi
-
-═══════════════════════════════════════════════════════════════
-
-📝 PROCHAINES ÉTAPES (Optionnel):
-
-  Court terme:
-    - Tester avec vrais workflows
-    - Configurer dashboards personnalisés
-    - Mettre en place rapports automatiques
-
-  Long terme:
-    - WebSocket pour real-time
-    - OpenAPI documentation
-    - 6 property tests avancés restants
-
-═══════════════════════════════════════════════════════════════
-
-🎊 CONCLUSION:
-
-Session EXCEPTIONNELLEMENT productive !
-
-En 6 heures, nous avons créé un système analytics de niveau
-PRODUCTION avec collection automatique, tracking temps réel,
-intégration self-healing, et documentation complète.
-
-Le système RPA Vision V3 est maintenant équipé d'un système
-analytics professionnel prêt pour la production.
-
-MISSION ACCOMPLIE ! 🚀
-
-═══════════════════════════════════════════════════════════════
-Date: 1er Décembre 2024
-Status: ✅ 98% COMPLETE - PRODUCTION READY
-Next: Utiliser et profiter ! 🎉
-═══════════════════════════════════════════════════════════════

PHASE10_FILES.txt

@@ -1,35 +0,0 @@
-# Fichiers Créés/Modifiés - Phase 10
-
-## Nouveaux Fichiers Créés
-
-### Core
-rpa_vision_v3/core/execution/error_handler.py
-
-### Tests
-rpa_vision_v3/tests/unit/test_error_handler.py
-rpa_vision_v3/tests/integration/test_error_recovery.py
-
-### Documentation
-rpa_vision_v3/ERROR_HANDLING_GUIDE.md
-rpa_vision_v3/PHASE10_COMPLETE.md
-rpa_vision_v3/SESSION_24NOV_PHASE10_COMPLETE.md
-rpa_vision_v3/PHASE10_SUMMARY.txt
-rpa_vision_v3/PHASE10_FILES.txt
-
-### Scripts
-rpa_vision_v3/run_error_handler_tests.sh
-
-## Fichiers Modifiés
-
-### Core (Intégration ErrorHandler)
-rpa_vision_v3/core/execution/action_executor.py
-rpa_vision_v3/core/graph/node_matcher.py
-
-### Documentation
-rpa_vision_v3/STATUS_24NOV.md
-
-## Total
-
-Nouveaux fichiers: 9
-Fichiers modifiés: 3
-Total: 12 fichiers

PHASE10_SUMMARY.txt

@@ -1,186 +0,0 @@
-╔══════════════════════════════════════════════════════════════╗
-║         PHASE 10 : GESTION D'ERREURS - COMPLÈTE ✅           ║
-╚══════════════════════════════════════════════════════════════╝
-
-Date: 24 novembre 2024
-Statut: ✅ TOUTES LES TÂCHES TERMINÉES
-
-┌──────────────────────────────────────────────────────────────┐
-│ TÂCHES COMPLÉTÉES (6/6)                                      │
-└──────────────────────────────────────────────────────────────┘
-
-✅ Task 9.1 : ErrorHandler créé
-✅ Task 9.2 : Intégration ActionExecutor
-✅ Task 9.3 : Intégration NodeMatcher
-✅ Task 9.4 : Tests unitaires (26 tests)
-✅ Task 9.5 : Tests d'intégration
-✅ Task 9.6 : Documentation complète
-
-┌──────────────────────────────────────────────────────────────┐
-│ FICHIERS CRÉÉS                                               │
-└──────────────────────────────────────────────────────────────┘
-
-Core:
-  • core/execution/error_handler.py (~600 lignes)
-
-Tests:
-  • tests/unit/test_error_handler.py (~500 lignes)
-  • tests/integration/test_error_recovery.py (~300 lignes)
-
-Documentation:
-  • ERROR_HANDLING_GUIDE.md
-  • PHASE10_COMPLETE.md
-  • SESSION_24NOV_PHASE10_COMPLETE.md
-
-Scripts:
-  • run_error_handler_tests.sh
-
-┌──────────────────────────────────────────────────────────────┐
-│ FONCTIONNALITÉS                                              │
-└──────────────────────────────────────────────────────────────┘
-
-Types d'erreurs gérés (6):
-  • MATCHING_FAILED - Échec de matching de node
-  • TARGET_NOT_FOUND - Target d'action introuvable
-  • POSTCONDITION_FAILED - Post-conditions non satisfaites
-  • UI_CHANGED - Changement d'UI détecté
-  • EXECUTION_TIMEOUT - Timeout d'exécution
-  • UNKNOWN - Erreur inconnue
-
-Stratégies de récupération (6):
-  • RETRY - Réessayer l'opération
-  • FALLBACK - Utiliser stratégie alternative
-  • SKIP - Ignorer et continuer
-  • ROLLBACK - Annuler dernière action
-  • PAUSE - Pause pour analyse manuelle
-  • ABORT - Abandonner l'exécution
-
-Fonctionnalités avancées:
-  • Logging détaillé avec screenshots
-  • Historique des erreurs
-  • Compteurs d'échecs par edge
-  • Détection d'edges problématiques (>3 échecs)
-  • Système de rollback avec historique
-  • Génération de suggestions automatiques
-  • 3 niveaux de fallback pour targets
-
-┌──────────────────────────────────────────────────────────────┐
-│ TESTS                                                        │
-└──────────────────────────────────────────────────────────────┘
-
-Tests unitaires: 26 tests
-  • TestErrorHandlerInitialization (3)
-  • TestMatchingFailureHandling (3)
-  • TestTargetNotFoundHandling (4)
-  • TestPostconditionFailureHandling (2)
-  • TestUIChangeDetection (2)
-  • TestRollbackSystem (4)
-  • TestStatisticsAndReporting (3)
-  • TestErrorLogging (2)
-  • TestSuggestionGeneration (3)
-
-Tests d'intégration:
-  • ActionExecutor + ErrorHandler
-  • NodeMatcher + ErrorHandler
-  • Scénarios de bout en bout
-  • Agrégation de statistiques
-
-Exécution:
-  ./run_error_handler_tests.sh
-
-┌──────────────────────────────────────────────────────────────┐
-│ STATISTIQUES                                                 │
-└──────────────────────────────────────────────────────────────┘
-
-Code:
-  • ~1800 lignes de code au total
-  • ~600 lignes ErrorHandler
-  • ~800 lignes de tests
-  • ~400 lignes de documentation
-
-Temps de développement:
-  • Task 9.1-9.3: Déjà complétées
-  • Task 9.4: ~45 min (tests unitaires)
-  • Task 9.5: ~30 min (tests intégration)
-  • Task 9.6: ~30 min (documentation)
-  • Total session: ~2h15
-
-┌──────────────────────────────────────────────────────────────┐
-│ UTILISATION                                                  │
-└──────────────────────────────────────────────────────────────┘
-
-Configuration:
-  from core.execution.error_handler import ErrorHandler
-  from core.execution.action_executor import ActionExecutor
-  
-  error_handler = ErrorHandler()
-  executor = ActionExecutor(error_handler=error_handler)
-
-Exécution:
-  result = executor.execute_edge(edge, screen_state)
-  
-  if result.status == ExecutionStatus.TARGET_NOT_FOUND:
-      stats = executor.get_error_statistics()
-      print(f"Erreurs: {stats['total_errors']}")
-
-Statistiques:
-  stats = error_handler.get_error_statistics()
-  problematic = error_handler.get_problematic_edges()
-
-┌──────────────────────────────────────────────────────────────┐
-│ DOCUMENTATION                                                │
-└──────────────────────────────────────────────────────────────┘
-
-Guides:
-  • ERROR_HANDLING_GUIDE.md - Guide complet
-  • PHASE10_COMPLETE.md - Résumé de la phase
-  • SESSION_24NOV_PHASE10_COMPLETE.md - Résumé session
-
-Exemples:
-  • Configuration de base
-  • Exécution avec gestion d'erreurs
-  • Monitoring en temps réel
-  • Analyse des logs
-
-API Reference:
-  • ErrorHandler
-  • RecoveryResult
-  • RecoveryStrategy
-  • ErrorType
-
-┌──────────────────────────────────────────────────────────────┐
-│ VALIDATION                                                   │
-└──────────────────────────────────────────────────────────────┘
-
-Checklist:
-  ✅ ErrorHandler créé et fonctionnel
-  ✅ Intégration dans ActionExecutor
-  ✅ Intégration dans NodeMatcher
-  ✅ Tests unitaires (26 tests)
-  ✅ Tests d'intégration
-  ✅ Documentation complète
-  ✅ Exemples d'utilisation
-  ✅ Guide de dépannage
-
-Critères de succès:
-  ✅ Tous les types d'erreurs gérés
-  ✅ Toutes les stratégies implémentées
-  ✅ Logging détaillé et exploitable
-  ✅ Système de rollback fonctionnel
-  ✅ Tests exhaustifs
-  ✅ Documentation complète
-
-┌──────────────────────────────────────────────────────────────┐
-│ STATUT FINAL                                                 │
-└──────────────────────────────────────────────────────────────┘
-
-✅ PHASE 10 COMPLÈTE
-✅ PRODUCTION READY
-✅ TOUS LES TESTS PASSENT
-✅ DOCUMENTATION EXHAUSTIVE
-
-Prochaine phase: Phase 11 (Persistence)
-
-╔══════════════════════════════════════════════════════════════╗
-║                    🎉 SUCCÈS TOTAL 🎉                        ║
-╚══════════════════════════════════════════════════════════════╝

PHASE11_COMPLETE.txt

@@ -1,175 +0,0 @@
-╔══════════════════════════════════════════════════════════════════════╗
-║              PHASE 11 : OUTILS D'AMÉLIORATION CONTINUE               ║
-║                          ✅ COMPLÉTÉ                                 ║
-╚══════════════════════════════════════════════════════════════════════╝
-
-Date: 23 novembre 2025
-Durée: ~2 heures
-Statut: ✅ Production Ready
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ FICHIERS CRÉÉS (8)                                                   │
-└──────────────────────────────────────────────────────────────────────┘
-
-Scripts Python (3):
-  ✓ analyze_failed_matches.py      (327 lignes, 12K)
-  ✓ monitor_matching_health.py     (180 lignes, 5K)
-  ✓ auto_improve_matching.py       (355 lignes, 14K)
-
-Documentation (4):
-  ✓ MATCHING_TOOLS_README.md       (2.5K)
-  ✓ QUICK_START_MATCHING_TOOLS.md  (4.0K)
-  ✓ PHASE11_MATCHING_IMPROVEMENT_TOOLS.md (8.7K)
-  ✓ SUMMARY_PHASE11.md             (8.1K)
-
-Tests (1):
-  ✓ test_matching_tools.sh         (1.6K)
-
-Changelog:
-  ✓ CHANGELOG_PHASE11.md           (5.6K)
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ FONCTIONNALITÉS                                                      │
-└──────────────────────────────────────────────────────────────────────┘
-
-1. ANALYSE DES ÉCHECS
-   • Statistiques complètes (min/max/moyenne/distribution)
-   • Identification des nodes problématiques (top 5)
-   • Recommandations de seuil basées sur P90
-   • Export JSON pour intégration
-   • Filtrage par date (--last N, --since-hours X)
-
-2. MONITORING DE SANTÉ
-   • Surveillance temps réel
-   • Métriques clés (échecs/10min, échecs/heure, taux, confiance)
-   • Alertes automatiques (CRITICAL/WARNING/INFO)
-   • Mode continu avec intervalle configurable
-   • Sauvegarde historique (JSONL)
-
-3. AMÉLIORATION AUTOMATIQUE
-   • UPDATE_PROTOTYPE : Mise à jour des prototypes (3+ near misses)
-   • CREATE_NODE : Création de nouveaux nodes (2+ états similaires)
-   • ADJUST_THRESHOLD : Ajustement du seuil (30%+ near threshold)
-   • Mode simulation (dry-run) par défaut
-   • Application sécurisée avec --apply
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ UTILISATION RAPIDE                                                   │
-└──────────────────────────────────────────────────────────────────────┘
-
-# Vérifier la santé
-./monitor_matching_health.py
-
-# Analyser les échecs
-./analyze_failed_matches.py --last 10
-
-# Améliorer automatiquement
-./auto_improve_matching.py --apply
-
-# Tests
-./test_matching_tools.sh
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ WORKFLOW RECOMMANDÉ                                                  │
-└──────────────────────────────────────────────────────────────────────┘
-
-Quotidien (5 min):
-  ./monitor_matching_health.py
-
-Hebdomadaire (15 min):
-  ./analyze_failed_matches.py --since-hours 168 --export weekly.json
-
-Mensuel (30 min):
-  ./auto_improve_matching.py
-  ./auto_improve_matching.py --apply
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ MÉTRIQUES DE SUCCÈS                                                  │
-└──────────────────────────────────────────────────────────────────────┘
-
-Métrique          Excellent   Bon        Attention   Problème
-─────────────────────────────────────────────────────────────
-Échecs/heure      < 5         5-10       10-20       > 20
-Confiance moy     > 0.80      0.70-0.80  0.60-0.70   < 0.60
-Nouveaux états    < 10%       10-30%     30-50%      > 50%
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ BÉNÉFICES                                                            │
-└──────────────────────────────────────────────────────────────────────┘
-
-✓ Visibilité Complète
-  - Tous les échecs documentés avec contexte
-  - Statistiques détaillées disponibles
-  - Tendances identifiables
-
-✓ Amélioration Continue
-  - Détection automatique des problèmes
-  - Suggestions actionnables
-  - Application sécurisée
-
-✓ Maintenance Proactive
-  - Monitoring temps réel
-  - Alertes automatiques
-  - Historique des métriques
-
-✓ Gain de Temps
-  - Analyse automatisée (vs manuelle)
-  - Améliorations suggérées (vs investigation)
-  - Moins d'intervention (vs debugging)
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ DOCUMENTATION                                                        │
-└──────────────────────────────────────────────────────────────────────┘
-
-Quick Start:
-  QUICK_START_MATCHING_TOOLS.md
-
-Guide Complet:
-  MATCHING_TOOLS_README.md
-
-Documentation Technique:
-  PHASE11_MATCHING_IMPROVEMENT_TOOLS.md
-
-Résumé:
-  SUMMARY_PHASE11.md
-
-Changelog:
-  CHANGELOG_PHASE11.md
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ STATISTIQUES                                                         │
-└──────────────────────────────────────────────────────────────────────┘
-
-Fichiers créés:        8
-Lignes de code:        ~850
-Temps développement:   ~2 heures
-Documentation:         ~30 pages
-Tests:                 ✅ Automatisés
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ PROCHAINES ÉTAPES                                                    │
-└──────────────────────────────────────────────────────────────────────┘
-
-Court Terme:
-  [ ] Tester avec données réelles
-  [ ] Ajuster seuils d'alerte
-  [ ] Créer dashboard web
-
-Moyen Terme:
-  [ ] ML pour prédire échecs
-  [ ] Clustering automatique
-  [ ] A/B testing des seuils
-
-Long Terme:
-  [ ] Auto-tuning complet
-  [ ] Détection d'anomalies
-  [ ] Recommandations prédictives
-
-╔══════════════════════════════════════════════════════════════════════╗
-║                    PHASE 11 : ✅ COMPLÉTÉ                           ║
-║                                                                      ║
-║  Le système dispose maintenant d'outils complets pour analyser,     ║
-║  monitorer et améliorer automatiquement le matching.                ║
-║                                                                      ║
-║  Amélioration continue garantie ! 🚀                                ║
-╚══════════════════════════════════════════════════════════════════════╝

PROPRIETES_ETAPES_VWB_COMPLETE_12JAN2026.md

@@ -1,152 +0,0 @@
-# ✅ CORRECTION PROPRIÉTÉS D'ÉTAPES VWB - TERMINÉE
-
-**Auteur :** Dom, Alice, Kiro  
-**Date :** 12 janvier 2026  
-**Statut :** 🎉 **SUCCÈS COMPLET**
-
-## 🎯 Mission Accomplie
-
-La correction des propriétés d'étapes vides dans le Visual Workflow Builder a été **implémentée avec succès** et **entièrement validée**.
-
-### ❌ Problème Initial
-- Les propriétés d'étapes affichaient systématiquement "Cette étape n'a pas de paramètres configurables"
-- Même pour les étapes qui devraient avoir des paramètres (click, type, actions VWB, etc.)
-- Cause : Incohérence entre les types d'étapes créées et les clés `stepParametersConfig`
-
-### ✅ Solution Implémentée
-- **Nouveau système StepTypeResolver unifié** pour la résolution des types d'étapes
-- **Détection VWB multi-méthodes** avec calcul de confiance (6 méthodes)
-- **Refactoring complet du PropertiesPanel** avec le nouveau système
-- **Gestion d'états avancée** (chargement, erreurs, cache intelligent)
-- **Interface utilisateur améliorée** avec indicateurs visuels
-
-## 📁 Fichiers Créés/Modifiés
-
-### Nouveaux Fichiers
-1. **`visual_workflow_builder/frontend/src/services/StepTypeResolver.ts`** (14,375 octets)
-   - Service principal de résolution unifiée
-   - Configuration complète des paramètres standard
-   - Détection VWB robuste avec 6 méthodes
-   - Cache intelligent et statistiques
-
-2. **`visual_workflow_builder/frontend/src/hooks/useStepTypeResolver.ts`** (8,990 octets)
-   - Hook React pour intégration du résolveur
-   - Gestion d'état avec mémorisation
-   - Debouncing et retry automatique
-   - Optimisations de performance
-
-### Fichiers Modifiés
-3. **`visual_workflow_builder/frontend/src/components/PropertiesPanel/index.tsx`** (17,324 octets)
-   - Refactoring complet pour utiliser le nouveau système
-   - Suppression de l'ancienne logique défaillante
-   - Intégration des états de chargement et d'erreur
-   - Support amélioré des actions VWB
-
-## 🧪 Validation Complète
-
-### Tests d'Intégration
-- **8/8 tests passés** avec succès
-- Compilation TypeScript sans erreur
-- Vérification de tous les fichiers
-- Validation de la détection VWB
-- Conformité française complète
-
-### Types d'Étapes Supportés
-- **11 types standard** : click, type, wait, condition, extract, scroll, navigate, screenshot, etc.
-- **13 actions VWB** : click_anchor, type_text, type_secret, wait_for_anchor, etc.
-- **Détection automatique** avec calcul de confiance
-
-## 🚀 Améliorations Apportées
-
-### 1. Résolution Unifiée
-- Un seul point d'entrée pour tous les types d'étapes
-- Cohérence et maintenabilité améliorées
-- Gestion centralisée des configurations
-
-### 2. Détection VWB Robuste
-- 6 méthodes de détection indépendantes
-- Calcul de confiance basé sur les détections positives
-- Support des patterns et flags VWB
-
-### 3. Interface Utilisateur Améliorée
-- États de chargement avec indicateurs visuels
-- Messages d'erreur informatifs et actionnables
-- Debug panel intégré en mode développement
-- Gestion gracieuse des cas d'erreur
-
-### 4. Performance Optimisée
-- Cache intelligent avec invalidation
-- Mémorisation et debouncing
-- Réduction des re-rendus inutiles
-- Retry automatique avec délai exponentiel
-
-### 5. Observabilité
-- Logs de débogage structurés
-- Statistiques de résolution
-- Métriques de performance
-- Traçabilité complète
-
-## 🎮 Instructions d'Utilisation
-
-### Pour Tester la Correction
-```bash
-# 1. Démarrer le frontend
-cd visual_workflow_builder/frontend
-npm start
-
-# 2. Créer une étape dans le canvas
-# 3. Sélectionner l'étape
-# 4. Vérifier l'affichage des propriétés
-```
-
-### Résultats Attendus
-- **Étapes standard** : Champs de configuration appropriés (target, text, etc.)
-- **Actions VWB** : Composant spécialisé VWBActionProperties
-- **Plus jamais** : "Cette étape n'a pas de paramètres configurables"
-
-## 📊 Métriques de Succès
-
-| Métrique | Avant | Après | Amélioration |
-|----------|-------|-------|--------------|
-| Propriétés affichées | 0% | 100% | +100% |
-| Types d'étapes supportés | Partiel | Complet | +100% |
-| Détection VWB | Basique | Multi-méthodes | +500% |
-| Gestion d'erreurs | Aucune | Complète | +∞ |
-| Performance | Dégradée | Optimisée | +200% |
-
-## 🏆 Conclusion
-
-### ✅ Objectifs Atteints
-- [x] Correction complète du problème des propriétés vides
-- [x] Système de résolution unifié et robuste
-- [x] Détection VWB améliorée avec confiance
-- [x] Interface utilisateur optimisée
-- [x] Performance et observabilité améliorées
-- [x] Tests d'intégration complets
-- [x] Documentation et conformité française
-
-### 🚀 Impact
-Le Visual Workflow Builder affiche maintenant **correctement les propriétés configurables pour toutes les étapes**, offrant une expérience utilisateur fluide et professionnelle.
-
-### 🎯 Prêt pour Production
-Le système est **entièrement validé** et **prêt pour la production** avec :
-- Compilation TypeScript sans erreur
-- Tests d'intégration passés
-- Performance optimisée
-- Gestion d'erreurs robuste
-- Documentation complète
-
----
-
-## 📝 Fichiers de Référence
-
-- **Rapport détaillé** : `docs/CORRECTION_PROPRIETES_ETAPES_FINALE_12JAN2026.md`
-- **Tests d'intégration** : `tests/integration/test_correction_proprietes_etapes_finale_12jan2026.py`
-- **Démonstration** : `scripts/demo_proprietes_etapes_fonctionnelles_12jan2026.py`
-- **Plan de tâches** : `.kiro/specs/correction-proprietes-etapes-vides/tasks.md`
-
----
-
-**🎉 MISSION ACCOMPLIE - PROPRIÉTÉS D'ÉTAPES FONCTIONNELLES ! 🎉**
-
-*Correction implémentée avec succès par Dom, Alice, Kiro - 12 janvier 2026*

QUICK_START.md

@@ -21,7 +21,12 @@ ollama serve
 ### 3. Télécharger le modèle VLM
 
 ```bash
-ollama pull qwen3-vl:8b
+# Modèle par défaut du projet (voir .env.example)
+ollama pull gemma4:latest
+
+# Alternatives supportées
+# ollama pull qwen3-vl:8b
+# ollama pull 0000/ui-tars-1.5-7b-q8_0:7b   # grounder visuel
 ```
 
 ## Utilisation

QUICK_STATUS.txt

@@ -1,34 +0,0 @@
-╔═══════════════════════════════════════════════════════════════╗
-║                  RPA VISION V3 - QUICK STATUS                 ║
-╚═══════════════════════════════════════════════════════════════╝
-
-📅 Last Update: 22 Nov 2024
-
-✅ COMPLETED:
-   • Phase 1: Data Models
-   • Phase 2: CLIP Embedders (ViT-B-32, 512D)
-
-⏳ IN PROGRESS:
-   • Task 2.9: Integrate CLIP into StateEmbeddingBuilder
-
-🎯 NEXT:
-   • Phase 3: UI Detection
-   • Phase 4: Workflow Graphs
-
-🧪 QUICK TEST:
-   bash rpa_vision_v3/test_clip.sh
-
-📊 METRICS:
-   • Text embedding: <10ms
-   • Image embedding: ~50ms (CPU)
-   • Similarity Login/SignIn: 0.899 ✅
-
-📚 DOCS:
-   • rpa_vision_v3/PHASE2_CLIP_COMPLETE.md
-   • rpa_vision_v3/NEXT_SESSION.md
-   • RPA_VISION_V3_STATUS.md
-
-🔧 SETUP:
-   source geniusia2/venv/bin/activate
-
-═══════════════════════════════════════════════════════════════

README.md

@@ -1,207 +1,204 @@
-# RPA Vision V3 - 100% Vision-Based Workflow Automation
+# RPA Vision V3 — Automatisation basée sur la compréhension visuelle des interfaces
 
-## 📊 Status
+> ⚠️ **Projet en phase POC** — voir [`docs/STATUS.md`](docs/STATUS.md) pour l'état
+> réel par module. Certaines briques sont opérationnelles bout en bout,
+> d'autres sont en cours de stabilisation. Ce dépôt n'est pas production-ready.
 
-🚀 **PRODUCTION-READY** - Phase 12 Complete (77% System Completion) ✅
+*Dernière mise à jour : 14 avril 2026*
 
-**Latest Update**: 14 Décembre 2024
-- ✅ **10/13 Phases Complétées** - Système mature et fonctionnel
-- ✅ **Performance Exceptionnelle** - 500-6250x plus rapide que requis
-- ✅ **Architecture Entreprise** - 148k+ lignes, 19 modules, 6 specs complètes
-- ✅ **Innovations Techniques** - Self-healing, Multi-modal, GPU management
-- 📊 **Audit Complet** - [Rapport détaillé](AUDIT_COMPLET_SYSTEME_RPA_VISION_V3.md)
+## Intention
 
-**Quick Test**: `bash test_clip.sh`
+Automatiser des workflows métier par **compréhension sémantique de l'écran**
+plutôt que par coordonnées de clic fixes. Le système observe l'utilisateur,
+reconstruit un graphe d'états de l'interface, et cherche à rejouer la
+procédure en reconnaissant visuellement les éléments cibles — y compris
+quand l'UI change légèrement.
 
-## 🎯 Vision
+Terrain cible principal : postes hospitaliers (Citrix, applications métier
+web et desktop). Contrainte forte : **100 % local**, pas d'appel à un LLM
+cloud dans le pipeline par défaut.
 
-RPA basé sur la **compréhension sémantique** des interfaces, pas sur des coordonnées de clics.
-
-Le système apprend des workflows en observant l'utilisateur et les automatise de manière robuste grâce à une architecture en 5 couches.
-
-## 🏗️ Architecture en 5 Couches
+## Architecture en couches
 
 ```
-RawSession (Couche 0)
-    ↓
-ScreenState (Couche 1) - 4 niveaux d'abstraction
-    ↓
-UIElement Detection (Couche 2) - Types + Rôles sémantiques
-    ↓
-State Embedding (Couche 3) - Fusion multi-modale
-    ↓
-Workflow Graph (Couche 4) - Nodes + Edges + Learning States
+RawSession (couche 0) — capture événements + screenshots
+        ↓
+ScreenState (couche 1) — états d'écran à plusieurs niveaux d'abstraction
+        ↓
+UIElement (couche 2) — détection sémantique (cascade OCR + templates + VLM)
+        ↓
+State Embedding (couche 3) — fusion multi-modale + index FAISS
+        ↓
+Workflow Graph (couche 4) — nœuds, transitions, résolution de cibles
 ```
 
-## 📁 Structure
+## État des fonctionnalités (synthèse)
 
-```
-rpa_vision_v3/
-├── core/
-│   ├── models/          # Couches 0-4 : Structures de données
-│   ├── capture/         # Couche 0 : Capture événements + screenshots
-│   ├── detection/       # Couche 2 : Détection UI sémantique
-│   ├── embedding/       # Couche 3 : Fusion multi-modale + FAISS
-│   ├── graph/           # Couche 4 : Construction + Matching + Exécution
-│   └── persistence/     # Sauvegarde/Chargement
-├── data/
-│   ├── sessions/        # RawSessions
-│   ├── screen_states/   # ScreenStates
-│   ├── embeddings/      # Vecteurs .npy
-│   ├── faiss_index/     # Index FAISS
-│   └── workflows/       # Workflow Graphs
-└── tests/               # Tests unitaires + intégration
-```
+Le détail par module est dans [`docs/STATUS.md`](docs/STATUS.md).
 
-## 🚀 Démarrage Rapide
+**Opérationnel**
+- Capture Windows (Agent V1) + streaming vers serveur Linux
+- Stockage des sessions brutes (screenshots + événements)
+- Streaming server FastAPI, sessions en mémoire
+- Build du package Windows (`deploy/build_package.sh`)
+
+**Alpha (fonctionnel sur un cas de référence, encore peu généralisé)**
+- Détection UI par cascade VLM + OCR + templates
+- Construction de workflow graph depuis une session
+- Replay E2E supervisé — premier succès sur Notepad le 13 avril 2026
+- Mode apprentissage : pause et demande d'aide humaine quand la résolution échoue
+- Embeddings CLIP + index FAISS
+- Module auth (Fernet + TOTP), federation (LearningPack)
+- Web Dashboard, Agent Chat
+
+**En cours**
+- Visual Workflow Builder (VWB) — bugs DB runtime connus
+- Self-healing / recovery global
+- Analytics / reporting
+- Worker de compilation sessions → ExecutionPlan
+- Tests E2E multi-applications
+
+## Limitations connues
+
+- Le pipeline de replay est validé sur un nombre très restreint d'applications.
+- `TargetMemoryStore` (apprentissage Phase 1) est câblé mais sa base reste
+  vide tant qu'un replay complet n'a pas été cristallisé.
+- Certaines asymétries entre chemins stricts et legacy dans le serveur de
+  streaming peuvent provoquer des arrêts au lieu de pauses d'apprentissage.
+- VWB n'est pas encore stable en écriture ; un outil dédié plus simple est
+  envisagé.
+
+## Démarrage
+
+### Prérequis
+
+- Python 3.10 à 3.12
+- [Ollama](https://ollama.ai) installé et démarré localement
+- Recommandé : GPU NVIDIA pour l'inférence VLM
+- Windows 10/11 uniquement pour le client Agent V1
 
 ### Installation
 
 ```bash
-# 1. Installer Ollama
-curl -fsSL https://ollama.ai/install.sh | sh  # Linux
-# ou
-brew install ollama  # macOS
-
-# 2. Démarrer Ollama
-ollama serve
-
-# 3. Télécharger le modèle VLM
-ollama pull qwen3-vl:8b
-
-# 4. Installer dépendances Python
+# 1) Cloner puis créer le venv
+python3 -m venv .venv
+source .venv/bin/activate
 pip install -r requirements.txt
+
+# 2) Démarrer Ollama et récupérer le modèle VLM par défaut
+ollama serve &
+ollama pull gemma4:latest        # défaut du projet
+# Alternatives supportées :
+# ollama pull qwen3-vl:8b
+# ollama pull 0000/ui-tars-1.5-7b-q8_0:7b   # grounder visuel
+
+# 3) Copier et ajuster la configuration
+cp .env.example .env
+# éditer .env pour vérifier RPA_VLM_MODEL, VLM_ENDPOINT, ports, etc.
 ```
 
-### Test Rapide
+### Lancer les services
+
+Tous les services sont pilotés par `svc.sh` (source de vérité des ports :
+`services.conf`).
 
 ```bash
-# Diagnostic système
-python3 rpa_vision_v3/examples/diagnostic_vlm.py
-
-# Test de détection
-./rpa_vision_v3/test_quick.sh
+./svc.sh status          # État de tous les services
+./svc.sh start           # Tout démarrer
+./svc.sh start streaming # Streaming server uniquement (port 5005)
+./svc.sh restart api     # Redémarrer l'API (port 8000)
+./svc.sh stop            # Tout arrêter
 ```
 
-### Utilisation - Détection UI
+| Port | Service |
+|---|---|
+| 8000 | API Server (upload / traitement core) |
+| 5001 | Web Dashboard |
+| 5002 | VWB Backend (Flask) |
+| 5003 | Monitoring |
+| 5004 | Agent Chat |
+| 5005 | Streaming Server (Agent V1 → pipeline core) |
+| 5006 | Session Cleaner |
+| 5099 | Worker de compilation (optionnel) |
+| 3002 | VWB Frontend (Vite/React) |
 
-```python
-from rpa_vision_v3.core.detection import create_detector
+### Client Windows (Agent V1)
 
-# Créer le détecteur
-detector = create_detector()
-
-# Détecter les éléments UI
-elements = detector.detect("screenshot.png")
-
-# Utiliser les résultats
-for elem in elements:
-    print(f"{elem.type:15s} | {elem.role:20s} | {elem.label}")
-```
-
-### Utilisation - Workflow (Phase 4 - À venir)
-
-```python
-from rpa_vision_v3.core.models import RawSession, ScreenState, Workflow
-from rpa_vision_v3.core.graph import GraphBuilder, NodeMatcher
-
-# 1. Capturer une session
-session = RawSession(...)
-# ... capturer événements et screenshots
-
-# 2. Construire workflow automatiquement
-builder = GraphBuilder(...)
-workflow = builder.build_from_session(session)
-
-# 3. Matcher état actuel
-matcher = NodeMatcher(...)
-current_state = ScreenState(...)
-match = matcher.match(current_state, workflow)
-
-# 4. Exécuter action
-if match:
-    edge = workflow.get_outgoing_edges(match.node.node_id)[0]
-    executor.execute_edge(edge, current_state)
-```
-
-## 📚 Documentation
-
-### Guides Principaux
-- **Quick Start** : `QUICK_START.md` - Démarrage rapide
-- **Prochaines Étapes** : `NEXT_STEPS.md` - Roadmap et Phase 4
-- **Phase 3 Complète** : `PHASE3_COMPLETE.md` - Résumé Phase 3
-
-### Documentation Technique
-- **Spec complète** : `.kiro/specs/workflow-graph-implementation/`
-- **Architecture** : `docs/reference/ARCHITECTURE_VISION_COMPLETE.md`
-- **Détection Hybride** : `HYBRID_DETECTION_SUMMARY.md`
-- **Intégration Ollama** : `docs/OLLAMA_INTEGRATION.md`
-
-## 🎓 Concepts Clés
-
-### RPA 100% Vision
-
-- ❌ Pas de coordonnées (x, y) fixes
-- ✅ Rôles sémantiques (primary_action, form_input, etc.)
-- ✅ Matching par similarité visuelle et textuelle
-- ✅ Robuste aux changements d'UI
-
-### Apprentissage Progressif
-
-```
-OBSERVATION (5+ exécutions)
-    ↓
-COACHING (10+ assistances, succès >90%)
-    ↓
-AUTO_CANDIDATE (20+ exécutions, succès >95%)
-    ↓
-AUTO_CONFIRMÉ (validation utilisateur)
-```
-
-### State Embedding
-
-Fusion multi-modale :
-- 50% Image (screenshot complet)
-- 30% Texte (texte détecté)
-- 10% Titre (fenêtre)
-- 10% UI (éléments détectés)
-
-## 🧪 Tests
+Le client capture souris, clavier et écran sur le poste Windows et envoie
+les données au streaming server Linux.
 
 ```bash
-# Tests unitaires
-pytest tests/unit/
-
-# Tests d'intégration
-pytest tests/integration/
-
-# Tests de performance
-pytest tests/performance/ --benchmark-only
+# Build du package Windows depuis le repo Linux
+./deploy/build_package.sh
+# produit deploy/Lea_v<version>.zip
 ```
 
-## 📈 Roadmap - 77% Complété (10/13 Phases)
+Voir [`docs/DEV_SETUP.md`](docs/DEV_SETUP.md) pour la maintenance du dépôt
+(worktrees, build, services).
 
-### ✅ **Phases Complétées**
-- [x] **Phase 1-2** : Fondations + Embeddings FAISS ✅
-- [x] **Phase 4-6** : Détection UI + Workflow Graphs + Action Execution ✅  
-- [x] **Phase 7-8** : Learning System + Training System ✅
-- [x] **Phase 10-12** : GPU Management + Performance + Monitoring ✅
+## Arborescence du dépôt
 
-### 🎯 **Phases Restantes**
-- [ ] **Phase 3** : Checkpoint Final (tests storage)
-- [ ] **Phase 9** : Visual Workflow Builder (90% → 100%)
-- [ ] **Phase 13** : Tests End-to-End + Documentation finale
+```
+rpa_vision_v3/
+├── agent_v0/                # Agent V1 (client Windows) + serveur de streaming
+│   ├── agent_v1/            # Source de l'agent (capture, UI tray, exécution)
+│   └── server_v1/           # FastAPI streaming + processeurs
+├── core/                    # Pipeline core
+│   ├── detection/           # Cascade VLM + OCR + templates
+│   ├── embedding/           # CLIP + FAISS
+│   ├── graph/               # Construction / matching de workflow graphs
+│   ├── execution/           # Résolution de cibles, actions LLM
+│   ├── learning/            # TargetMemoryStore (apprentissage)
+│   ├── auth/                # Vault Fernet + TOTP
+│   └── federation/          # Export/import de LearningPacks
+├── visual_workflow_builder/ # VWB (backend Flask + frontend React Vite)
+├── web_dashboard/           # Dashboard Flask + SocketIO
+├── agent_chat/              # Interface conversationnelle + planner
+├── deploy/                  # Scripts de build et unités systemd
+├── data/                    # Sessions, embeddings, index FAISS, apprentissage
+├── docs/                    # Documentation technique
+├── tests/                   # pytest (unit, integration, e2e)
+├── services.conf            # Source de vérité des ports
+├── svc.sh                   # Orchestrateur des services
+└── run.sh                   # Démarrage tout-en-un (legacy, préférer svc.sh)
+```
 
-### 🚀 **Composants Production-Ready**
-- **Agent V0** : Capture cross-platform + Encryption ✅
-- **Server API** : Processing pipeline + Web dashboard ✅  
-- **Analytics System** : Monitoring + Insights + Reporting ✅
-- **Self-Healing** : Automatic adaptation + Recovery ✅
+## Tests
 
-## 🤝 Contribution
+```bash
+source .venv/bin/activate
 
-Voir `.kiro/specs/workflow-graph-implementation/tasks.md` pour les tâches en cours.
+# Tests rapides (hors marqueur slow)
+pytest -m "not slow" -q
 
-## 📄 Licence
+# Tests d'intégration (streaming, pipeline)
+pytest tests/integration/ -q
 
-Propriétaire - Tous droits réservés
+# Tests E2E
+pytest tests/test_pipeline_e2e.py -q
+```
+
+Quelques tests legacy sont connus comme cassés — voir la mémoire projet et
+`docs/` pour la liste.
+
+## Documentation
+
+- [`docs/STATUS.md`](docs/STATUS.md) — état réel par module
+- [`docs/DEV_SETUP.md`](docs/DEV_SETUP.md) — tâches d'administration (worktrees, build)
+- [`docs/EXECUTION_LOOP_FLAGS.md`](docs/EXECUTION_LOOP_FLAGS.md) — flags C1 vision-aware (`enable_ui_detection`, `enable_ocr`, `analyze_timeout_ms`, `window_info_provider`)
+- [`docs/VISION_RPA_INTELLIGENT.md`](docs/VISION_RPA_INTELLIGENT.md) — cahier des charges
+- [`docs/PLAN_ACTEUR_V1.md`](docs/PLAN_ACTEUR_V1.md) — architecture 3 niveaux (Macro / Méso / Micro)
+- [`docs/CONFORMITE_AI_ACT.md`](docs/CONFORMITE_AI_ACT.md) — journalisation, floutage, rétention
+
+## Concepts clés
+
+- **RPA 100 % vision** : pas de coordonnées fixes ; l'agent localise un
+  élément par ce qu'il voit (label + contexte visuel), pas par `x,y`.
+- **Apprentissage progressif** : mode shadow → assisté → autonome, validé
+  par supervision humaine sur les échecs.
+- **LLM 100 % local** : Ollama sur la machine. Aucun appel cloud dans le
+  pipeline par défaut (cf. feedback projet `feedback_local_only.md`).
+
+## Licence
+
+Propriétaire — tous droits réservés.

RPA_SYSTEM_UNIFICATION_TASK1_COMPLETE.md

@@ -1,97 +0,0 @@
-ration.iguur confur leté po vérie source deiser la mêmnt utilntena peuvent mairviceses sets. Tous lposanentre comces  incohérenlesnt ui causaie dispersée qigurationconflèmes de t les probvementiinisout défn rémplémentatioCette i
-Impact
-nte.
-
-## ère cohéres de maninnéedoemins de les chs er touérisée pour graluration cent configlisera cetteé** qui uti unifianagerData Mer le ément Implask 2:asser au **T pntons maintenaé, nous pouvt termink 1 étans
-
-Le Taspes Étachainerote
-
-## Prreurs robusion d'eGest- ✅ 
-tenuente mainé descendampatibilit✅ Co
-- ésimplément propriété ests de Tle
-- ✅ationneles opéraramètr pidation des Valt
-- ✅orrectemenonne cger fonctiuration ManaConfigion
-
-- ✅ atlid Va
-
-##
-```.from_env()fig = AppConconfig
-app_gConfi import Appfigrom core.cone)
-frté suppotoujours (nne façoncie
-
-# Anpath}").sessions_configs path: {ion(f"Sessfig()
-printconig = get_g
-confrt get_confipore.config ime)
-from co(recommandéfaçon ouvelle on
-# N
-
-```pythonUtilisati. # 5
-```
-
-## = Truebled: boolh_ena   aut
- rd: strption_passwoencryr
-    y: stkeecret_    sSécurité
-   # = 4
-    
- : int eadsker_thr01
-    wor50nt = ard_port: i   dashbot = 8000
- int:  api_porervices
-      
-    # S
- iésnifètres u paramautresus les . to
-    # ..: Pathrkflows_path
-    woh: Pathions_path
-    sessh: Pata_patth
-    datth: Pae_pa  basiés
-  hemins unifg:
-    # CstemConfiss
-class Sy
-@datacla```python
-
-igurationre de Confuctu
-### 4. Str
-alles et interv, threads,es ports gestion d Valide lan
--roductioe p dironnementes à l'envfiquspécins s validatio- Teste lelidation
-vas de erreurte des ction complèfie la détess
-- Vériompletenetion ClidaVaiguration y 10: Confropert
-
-#### Prgementsecha resions lors dguratce des confitan la persisidenager
-- ValrationMas du Configules instancemultipence entre éra coh Teste l
--s identiquesdes valeurent ts utilisles composane que tous 
-- Vérifi Consistencygurationonfi: Croperty 1#### Py`)
-
-properties.pnfiguration__cooperty/testprété (`tests/s de PropriTest. ### 3
-
-euras d'errn c etomatiquelback au- Roliguration
-la confmique de nt dynaRechargemements
--  les changeur propagerchers poe de watystèm- Sangements
-n des Ch
-#### Gestioue
-tiqrreur cri d'en cas-fast erité
-- Failu de sévéc niveaaveétaillés r deuges d'errins
-- Messa chemorts etcation des pifiction
-- Vérdunts de proenvironnemee des n automatiquatioalid- V Robuste
-dationVali
-
-#### GPU FAISS, èles ML,rité, mod de sécuesramètr Pa Worker)
--, Dashboard,vices (API seresiguration d)
-- Confetc.ddings, lows, embesions, workfs (sesnnées unifiéemins de do
-- Chonfig`e `SystemCe classans une seultème dres syses paramèt
-- Tous lnifiéeration UConfigu### 
-
-# CléslitésFonctionna
-
-### 2. siveestion progrmigra une enues pouront maint classes s ancienneste**: Lesscendanlité deibi **Compats
--ssages clairon avec mefiguratie cons erreurs de deautomatiqution Déteccomplète**: ion - **Validat'erreurs
-et gestion dchers, wation, alidat visé aveccentralonnaire r**: GestiationManage*Configurrsées
-- * dispenfigurationsoutes les coe tlacqui rempée nifiration unfigude co classe *: NouvelletemConfig*
-
-- **Sysonfig.py`) (`core/ctralisé Cenertion Managigura## 1. Confmpli
-
-# accoétéCe qui a 
-## .
- et testétéémen impl a étéiséalanager centr MgurationLe Confis** - c succèave1 terminé 
-✅ **Task ## Résumé
-sé
-
-r Centralin ManagetioConfigura1 Complete: # Task 

SESSION_01DEC_SUMMARY.txt

@@ -1,122 +0,0 @@
-═══════════════════════════════════════════════════════════════
-  SESSION 1ER DÉCEMBRE 2024 - RÉSUMÉ EXÉCUTIF
-═══════════════════════════════════════════════════════════════
-
-🎯 OBJECTIF: Compléter Tasks 8, 9, 10, 14
-
-📊 RÉSULTATS:
-
-✅ Task 9 (Workflow Composition): 100% COMPLETE
-✅ Task 10 (Self-Healing): 100% COMPLETE  
-🔄 Task 8 (RPA Analytics): 85% COMPLETE (implémentation terminée)
-🔄 Task 14 (Admin Monitoring): 85% COMPLETE (implémentation terminée)
-
-═══════════════════════════════════════════════════════════════
-
-📦 LIVRABLES:
-
-Nouveaux Composants (8 fichiers Python):
-  ✅ SuccessRateCalculator - Calcul taux de succès & fiabilité
-  ✅ ArchiveStorage - Archivage avec compression gzip
-  ✅ RetentionPolicyEngine - Politiques de rétention auto
-  ✅ ReportGenerator - Rapports JSON/CSV/HTML/PDF
-  ✅ DashboardManager - Dashboards personnalisables
-  ✅ AnalyticsAPI - 15+ endpoints REST
-  ✅ AnalyticsSystem - Système intégré complet
-  ✅ tasks.md pour Self-Healing
-
-Documentation (3 fichiers):
-  ✅ demo_analytics.py - Demo complète
-  ✅ ANALYTICS_QUICKSTART.md - Guide démarrage rapide
-  ✅ SESSION_01DEC_ANALYTICS_COMPLETE.md - Documentation session
-
-═══════════════════════════════════════════════════════════════
-
-📈 STATISTIQUES:
-
-Code:
-  • 3,200+ lignes de code Python
-  • 11 fichiers créés
-  • 0 erreurs de diagnostic
-  • Production-ready
-
-Fonctionnalités:
-  • 19 composants analytics implémentés
-  • 15+ endpoints API REST
-  • 4 formats d'export (JSON, CSV, HTML, PDF)
-  • 2 templates de dashboards
-  • Archivage avec compression
-  • Politiques de rétention
-  • Calculs statistiques avancés
-
-═══════════════════════════════════════════════════════════════
-
-⏳ RESTE À FAIRE:
-
-Task 8 (Analytics):
-  • 16 property tests
-  • Intégration ExecutionLoop
-  • WebSocket endpoints
-  • OpenAPI docs
-
-Task 14 (Admin Monitoring):
-  • 15 property tests
-
-Estimation: 8-11 heures
-
-═══════════════════════════════════════════════════════════════
-
-🚀 DÉMARRAGE RAPIDE:
-
-# Tester le système analytics
-python demo_analytics.py
-
-# Consulter le guide
-cat ANALYTICS_QUICKSTART.md
-
-# Utiliser dans votre code
-from core.analytics.analytics_system import get_analytics_system
-analytics = get_analytics_system()
-analytics.start_resource_monitoring()
-
-═══════════════════════════════════════════════════════════════
-
-✨ HIGHLIGHTS:
-
-1. Système analytics complet et fonctionnel
-2. API REST prête pour intégration
-3. Dashboards personnalisables avec templates
-4. Rapports automatiques (4 formats)
-5. Archivage et rétention automatiques
-6. Détection d'anomalies et insights
-7. Calcul de fiabilité et classement
-8. Monitoring temps réel
-9. Documentation complète
-10. Demos fonctionnels
-
-═══════════════════════════════════════════════════════════════
-
-🎊 CONCLUSION:
-
-Session très productive ! Les composants principaux de Task 8 
-(RPA Analytics) sont maintenant implémentés et fonctionnels. 
-Le système est prêt à être utilisé et testé.
-
-Status Global: 92% Complete
-Qualité: Production-ready (après property tests)
-Temps: ~3 heures
-Impact: Système analytics complet pour RPA Vision V3
-
-═══════════════════════════════════════════════════════════════
-
-📅 PROCHAINE SESSION:
-
-Priorité 1: Property tests (31 tests)
-Priorité 2: Intégration ExecutionLoop
-Priorité 3: WebSocket + OpenAPI docs
-
-═══════════════════════════════════════════════════════════════
-Date: 1er Décembre 2024
-Status: ✅ MAJOR PROGRESS
-Next: Property Tests + Integration
-═══════════════════════════════════════════════════════════════

SESSION_PROGRESS_TASK_LIST.md

@@ -1,141 +0,0 @@
-on.**mentatilan d'impléu pantes dtions suives sec lecntinuer avcoà l
-
-**Prêt t fonctionnentralisé esystem celeanup - Ct testé
-e ees robustntrétion des elidastème de va Sy
--ion complét67% derity) à ystem Secuection 7 (Se
-- S terminéntièrement) egementy Manaorion 6 (MemSect- ées:**
- complétjeures 4 tâches mauctive avecod*Session pron
-
-*usi
-
-## Concl ressources deson propreesti G demos
-- ✅ece avfonctionnell Validation e
-- ✅tâch de chaque  complèteionatment Docugnostic
-- ✅é pour diaillg déta
-- ✅ Loggincipaldu code princorrections avant s 
-- ✅ TestquéesAppliques nnes Prati Bos
-
-###rtimpoproblèmes d'es r éviter lts pou indépendan Testsomes**:dules auton. **Moessources
-4outes les rn pour testio gnt del poi Un seuentralisé**:p c*Cleanuaut
-3. *male par défrité maxi: Sécuduction**n pro stricte eon. **Validatitaires
-2tests uniec les érences av interfe lesvits**: Évé en test désacting*Monitoriiques
-1. *sions Techn
-
-### DéciportantesNotes Imes
-
-## ches critiqu% des tâ: ~25ogress**l Pr
-- **Overalâches)3 t(2/ 67% curity**:*System Selète)
-- *ction 6 comp(Seent**: 100% y Managemor- **Memnnelle
-Fonctioure ### Couvert lignes
-
-: ~400n**tatio
-- **Documen lignes00~8sts**: nes
-- **Te*: ~1500 ligduction*- **Prode Code
-nes 
-
-### LigRESS)N_PROG SESSIO2_COMPLETE,K_7_ 2 (TASn**:umentatio
-- **Docvalidation)g, simple_curity_confise*: 2 (- **Tests*on)
-ut_validatinp, idationy_valiecurit sm_cleanup,ystes**: 3 (smo)
-- **Deidationvalst_simple_tetor, ut_validaconfig, inpecurity_er, smanagnup_eales**: 4 (cldu*Nouveaux mo Ajouté
-- *odeues
-
-### Cstiqati# Stnal
-
-#fie contrôle Point don 12: ctin
-- Sen-régressiono Tests de n 11:5)
-- Sectio (10.1-10.aliséeon centrati0: Configur- Section 1)
-.1-9.5vabilité (9bserection 9: O8.3)
-- Sants (8.1-mposge des coDécouplaSection 8: -5.5)
-- .1formances (5tion des perisaOptimion 5:  Sectrité 2-3)
--s (Prioestante
-### Tasks Ration
-gure la confiion d Centralisatction 10**:4. **Sevabilité
-'obserration de l**: Amélioon 9
-3. **Sectis composantsde Découplage on 8**:tiSecation
-2. ** input validé pour propriét*: Tests de7.3* **Task 1. Immédiate
-Priorité## Étapes
-
-#ines # Procha
-
-#srce ressoupre desro pLibération: anup**em Cle*Syst- *onnelle
-pérati/NoSQL o SQL Protection**:t Validationnpu
-- **Iionnellen fonctuctio prodlidation Va Config**:rity**Secu
-- adlock sans deassentests p les tche**: Tousmory Ca- **Meltats
-
-
-### Résutenpassests y` - 25/25 the.ptive_lru_cacfectest_eft/sts/uni✅ `te
-- lèteation compt validpy` - Inpuidation.mple_valtest_si `alidée
-- ✅é vion sécuritConfiguratg.py` - urity_confit_secOK
-- ✅ `tesn sécurité tio - Validapy`ation.idrity_val `demo_secu- ✅nnel
-tiostem fonc Cleanup sy` -_cleanup.py_system✅ `democutés
-- # Tests Exés
-
-## Testtion et# Validatés
-
-#ionnalite des fonction complèmentatcun.py`
-- Dolidatiomple_vatest_siec `le avfonctionnelon aties
-- Validt autonomdules de tesmoe - Création dution**:
-nt.
-
-**Sol échouatss, impor 0 byte créés avecershi Ficblème**:sues
-**ProWriting Is File ts
-
-### 2.er en tesour désactivonitoring` ple_m`enabParamètre ing
-- our monitords daemon pd`
-- Threaown_requesteutd flag `_sht du- Ajouats()`
-ans `get_ste démoir m statsect des dir 
-- Calcul*Solution**:
-*à acquis.
-k déjle loc)` avec sage(_memory_upelant `get aplock enun deadcausait ts()` : `get_sta*Problème**LRUCache
-*ive Effectnsda1. Deadlock us
-
-###  et Résolontréses Rencblèm
-
-## Profaire)on (à lidatiput Vats for InProperty Tes - 
-- ⏳ 7.3lidationr Input Va ✅ 7.2 - Useion
--onfiguratty Ction Securi7.1 - Producées
-- ✅ mpléthes co3 tâcon: 2/ssi
-
-Progre 🔄EN COURSurity" - "System Sec# Section 7 
-
-#upn Cleandowstem Shut- Sy✅ 6.4 
-- e LiberationesourcU R.3 - GPger
-- ✅ 6- MemoryMana- ✅ 6.2 ache
-eLRUCectivEff1 - - ✅ 6.:
-minéesont ter section 6 sde laes tâches 
-
-Toutes l COMPLÈTE ✅agement" - Manemorytion 6 "M
-## Sec
-MPLETE.md`LIDATION_COINPUT_VAASK_7_2_y`, `Tion.plidatle_vaest_simp`t*: s**Fichierloggées
-- *es on des donnéanitisatiiers
-- Sns de fichhemies cValidation dL/NoSQL
-- s SQnjectionion contre ictr
-- Proteilisateuntrées uton des etiidavale  complet dn
-- Systèmelidatiout Var Inpk 7.2 - Use ✅ Tas
-
-###config.py`ity_test_securtion.py`, `lidaurity_va, `demo_secy_config.py`securitrity/cu: `core/se**hiers*Fic défaut
-- * clés parvecarrage afus de démReuction
--  en prodfrementés de chif des cln stricte- Validatiority/`
- `core/secuité dansurion de sécalidatodule de vion
-- Mnfigurat Security Cooduction 7.1 - PrTask### ✅ anup.py`
-
-letem_c, `demo_sysy`ager.panup_manm/cle/systecoreiers**: `*Fichore
-- *mposants ctous les coe matique dtoup au- CleanGTERM)
-NT, SIndlers (SIGI has signaltégration de Inystem/`
--dans `core/salisé centrpManager` leanu`Céation du p
-- CrCleanudown ystem ShutTask 6.4 - S
-### ✅ `
-e.pyemory_cachcution/mcore/exeger.py`, `anarce_mresoupu/gpu_s**: `core/gFichier **
--GPUtions s allocaacking detion
-- Trprès utilisaU a GPs ressources dequenup automati Cleay Manager
--Memorvec  Manager aurceeso du GPU Ron complète
-- Intégratitionurce Liberaeso.3 - GPU Rk 6### ✅ Tasession
-
-ées Cette Smplét Tâches Co.
-
-##irehe mémoac cproblèmes deution des ésol` après rsks.mdal-fixes/tariticrpa-ciro/specs/k list `.kla tas de tationimplémenon de l'inuatitexte
-Cont
-
-## Conbre 2024cem21 Déte: on
-
-## Damplementati List I Taskss -rogression P# Se

SUMMARY.txt

@@ -1,25 +0,0 @@
-╔═══════════════════════════════════════════════════════════════╗
-║           RPA VISION V3 - SESSION 22 NOV 2024                 ║
-╚═══════════════════════════════════════════════════════════════╝
-
-✅ COMPLÉTÉ: Phase 2 - CLIP Embedders
-
-📊 RÉSULTATS:
-   • 13 fichiers créés (~1950 lignes)
-   • Tests: 3/3 PASS
-   • CLIP: ViT-B-32, 512D, fonctionnel
-
-🧪 VALIDATIONS:
-   • Text embedding: <10ms ✅
-   • Image embedding: ~50ms ✅
-   • Similarity: 0.899 ✅
-
-📚 DOCS:
-   • PHASE2_CLIP_COMPLETE.md
-   • NEXT_SESSION.md
-   • INDEX.md
-   • COMMANDS.md
-
-🚀 NEXT: Task 2.9 - Integrate CLIP into StateEmbeddingBuilder
-
-═══════════════════════════════════════════════════════════════

TASK_PROGRESS.txt

@@ -1,156 +0,0 @@
-on y va ╔══════════════════════════════════════════════════════════════════════╗
-║           RPA VISION V3 - AVANCEMENT TASK LIST                       ║
-╚══════════════════════════════════════════════════════════════════════╝
-
-Date: 22 Novembre 2024
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ PHASE 1 : FONDATIONS ✅ COMPLÈTE                                     │
-└──────────────────────────────────────────────────────────────────────┘
-[✓] 1.8  Tests StateEmbedding
-[✓] 1.9  Modèles Workflow Graph
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ PHASE 2 : EMBEDDINGS ET FAISS ✅ IMPLÉMENTATION COMPLÈTE             │
-└──────────────────────────────────────────────────────────────────────┘
-[✓] 2.1  FusionEngine
-[✓] 2.3  FAISSManager
-[✓] 2.5  Calculs de similarité
-[✓] 2.7  StateEmbeddingBuilder + OpenCLIP
-[✓]* 2.2  Tests FusionEngine ← FAIT MAINTENANT (9/9 tests passés)
-[ ]* 2.4  Tests FAISSManager
-[ ]* 2.6  Tests performance
-[ ]* 2.8  Tests StateEmbeddingBuilder
-
-Tests Validés:
-  ✓ test_clip_simple.py
-  ✓ test_complete_pipeline.py
-  ✓ test_faiss_persistence.py
-  ✓ test_fusion_engine.py (Property 17 validée)
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ PHASE 3 : CHECKPOINT                                                 │
-└──────────────────────────────────────────────────────────────────────┘
-[ ] 3. Vérifier que tous les tests passent
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ PHASE 4 : DÉTECTION UI ✅ IMPLÉMENTATION COMPLÈTE                    │
-└──────────────────────────────────────────────────────────────────────┘
-[✓] 4.1  UIDetector + OWL-v2 ← FAIT AUJOURD'HUI
-[✓] 4.2  Classification types
-[✓] 4.3  Classification rôles
-[✓] 4.4  Features visuelles
-[✓] 4.5  Embeddings duaux
-[✓] 4.6  Confiance
-[ ]* 4.7  Tests UIDetector
-[ ]* 4.8  Tests performance
-
-Tests Validés:
-  ✓ test_owl_simple.py
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ PHASE 5 : WORKFLOW GRAPHS ✅ IMPLÉMENTATION COMPLÈTE (23 Nov 2024)  │
-└──────────────────────────────────────────────────────────────────────┘
-[✓] 5.1  GraphBuilder
-[✓] 5.2  Détection de patterns
-[ ]* 5.3  Tests patterns
-[✓] 5.4  Construction de nodes
-[ ]* 5.5  Tests nodes
-[✓] 5.6  Construction d'edges
-[ ]* 5.7  Tests edges
-[✓] 5.8  NodeMatcher
-[ ]* 5.9  Tests NodeMatcher
-[✓] 5.10 WorkflowNode.matches()
-[ ]* 5.11 Tests intégration
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ PHASE 6 : ACTION EXECUTION ✅ IMPLÉMENTATION COMPLÈTE (23 Nov 2024)  │
-└──────────────────────────────────────────────────────────────────────┘
-[✓] 6.1  ActionExecutor
-[✓] 6.2  TargetResolver
-[✓] 6.3  Recherche par rôle
-[✓] 6.4  Exécution mouse_click
-[✓] 6.5  Exécution text_input
-[✓] 6.6  Exécution compound
-[✓] 6.7  Post-conditions (stub)
-[ ]* 6.8  Tests ActionExecutor
-[ ]* 6.9  Tests performance
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ PHASE 7 : EXÉCUTION ⏳ À FAIRE                                       │
-└──────────────────────────────────────────────────────────────────────┘
-[ ] 7.1  ActionExecutor
-[ ] 7.2  Recherche par rôle
-[ ] 7.3  Exécution click
-[ ] 7.4  Exécution text_input
-[ ] 7.5  Exécution compound
-[ ] 7.6  Post-conditions
-[ ]* 7.7  Tests ActionExecutor
-[ ]* 7.8  Tests performance
-[ ] 7.9  LearningManager
-[ ] 7.10 Transitions d'états
-[ ] 7.11 Rollback
-[ ]* 7.12 Tests LearningManager
-[ ]* 7.13 Tests intégration
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ STATISTIQUES                                                         │
-└──────────────────────────────────────────────────────────────────────┘
-
-Phases complètes:     6/9  (67%)
-  ✓ Phase 1: Fondations
-  ✓ Phase 2: Embeddings + FAISS
-  ✓ Phase 4: Détection UI
-  ✓ Phase 5: Workflow Graphs
-  ✓ Phase 6: Action Execution
-  ✓ Phase 7: Learning System
-  ✓ Phase 8: Training System
-
-Implémentation:       38/50 tâches (76%)
-Tests property:       2/20 tâches (10%)
-
-Fichiers créés:       50+ fichiers
-Tests fonctionnels:   15+ tests passés
-
-Modèles intégrés:     3/3  (100%)
-  ✓ OpenCLIP
-  ✓ OWL-v2
-  ✓ Qwen3-VL
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ PHASE 7 : LEARNING SYSTEM ✅ IMPLÉMENTATION COMPLÈTE (23 Nov 2024)  │
-└──────────────────────────────────────────────────────────────────────┘
-[✓] 7.1  LearningManager
-[✓] 7.2  Transitions d'états
-[✓] 7.3  FeedbackProcessor
-[✓] 7.4  Rollback automatique
-[✓] 7.5  Tests LearningManager
-[ ]* 7.6  Tests intégration
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ PHASE 8 : TRAINING SYSTEM ✅ IMPLÉMENTATION COMPLÈTE (23 Nov 2024)  │
-└──────────────────────────────────────────────────────────────────────┘
-[✓] 8.1  TrainingDataCollector
-[✓] 8.2  OfflineTrainer
-[✓] 8.3  ModelValidator
-[✓] 8.4  Training Guide
-[✓] 8.5  Tests complets
-[ ]* 8.6  Tests intégration production
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ PROCHAINES ÉTAPES - PHASE 9 : TESTS & VALIDATION FINALE             │
-└──────────────────────────────────────────────────────────────────────┘
-
-Objectif: Tests property-based et validation end-to-end
-
-Tâches prioritaires:
-  → Tests manquants (Properties 13, 14, 16)
-  → Tests d'intégration end-to-end complets
-  → Validation sur données réelles
-  → Documentation finale
-
-Estimation: 1-2 jours
-
-╔══════════════════════════════════════════════════════════════════════╗
-║  SYSTÈME PRODUCTION-READY - 6 phases implémentées (67%)             ║
-╚══════════════════════════════════════════════════════════════════════╝

TASK_PROGRESS_24NOV_PHASE11.txt

@@ -1,145 +0,0 @@
-╔══════════════════════════════════════════════════════════════════════╗
-║           RPA VISION V3 - AVANCEMENT PHASE 11                        ║
-╚══════════════════════════════════════════════════════════════════════╝
-
-Date: 24 Novembre 2024
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ PHASE 11 : OPTIMISATION FAISS IVF ✅ COMPLÈTE (24 Nov 2024)         │
-└──────────────────────────────────────────────────────────────────────┘
-
-[✓] 11.1  Batch processing pour embeddings
-[✓] 11.2  Cache d'embeddings (EmbeddingCache + PrototypeCache)
-[✓] 11.3  Optimisation FAISS avec index IVF
-
-Détails Task 11.2 - Cache d'Embeddings:
-  ✓ EmbeddingCache LRU (1000 embeddings, 500MB max)
-  ✓ PrototypeCache spécialisé (100 prototypes)
-  ✓ Statistiques détaillées (hits/misses/evictions/hit_rate)
-  ✓ Invalidation sélective par clé ou pattern
-  ✓ Estimation utilisation mémoire
-
-Détails Task 11.3 - Optimisation IVF:
-  ✓ Migration automatique Flat → IVF (>10k embeddings)
-  ✓ Entraînement automatique de l'index IVF (100 vecteurs)
-  ✓ Calcul optimal de nlist (√n_vectors, min=100, max=65536)
-  ✓ Optimisation périodique de l'index
-  ✓ Support GPU préparé (détection auto, fallback CPU)
-  ✓ DirectMap activé pour reconstruction
-  ✓ Normalisation correcte des vecteurs
-  ✓ Sauvegarde/chargement avec métadonnées complètes
-  ✓ 8/8 tests passent
-
-Tests Validés:
-  ✓ test_ivf_training
-  ✓ test_nlist_calculation
-  ✓ test_auto_migration_flat_to_ivf
-  ✓ test_ivf_search_quality
-  ✓ test_ivf_nprobe_effect
-  ✓ test_optimize_index
-  ✓ test_save_load_ivf
-  ✓ test_stats_with_ivf
-
-Fichiers Créés/Modifiés:
-  ✓ core/embedding/embedding_cache.py (279 lignes)
-  ✓ core/embedding/faiss_manager.py (optimisé, +150 lignes)
-  ✓ tests/unit/test_faiss_ivf_optimization.py (270 lignes, 8 tests)
-  ✓ PHASE11_IVF_OPTIMIZATION_COMPLETE.md (documentation)
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ PERFORMANCES ATTENDUES                                               │
-└──────────────────────────────────────────────────────────────────────┘
-
-Comparaison Flat vs IVF:
-
-Recherche sur 10k vecteurs:
-  Flat: ~50ms  →  IVF: ~5-10ms  (5-10x plus rapide)
-
-Recherche sur 100k vecteurs:
-  Flat: ~500ms  →  IVF: ~10-20ms  (25-50x plus rapide)
-
-Recherche sur 1M vecteurs:
-  Flat: ~5s  →  IVF: ~20-50ms  (100-250x plus rapide)
-
-Précision:
-  Flat: 100%  →  IVF (nprobe=8): ~95-99%
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ RECOMMANDATIONS D'UTILISATION                                        │
-└──────────────────────────────────────────────────────────────────────┘
-
-< 10k embeddings:
-  → Utiliser Flat (recherche exacte, rapide)
-
-10k - 100k embeddings:
-  → Utiliser IVF avec nprobe=8 (bon compromis)
-
-> 100k embeddings:
-  → Utiliser IVF avec nprobe=16-32 (meilleure qualité)
-
-> 1M embeddings:
-  → Considérer IVF avec GPU
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ PARAMÈTRES CONFIGURABLES                                             │
-└──────────────────────────────────────────────────────────────────────┘
-
-FAISSManager(
-    dimensions=512,
-    index_type="IVF",           # "Flat", "IVF", "HNSW"
-    metric="cosine",            # "cosine", "l2", "ip"
-    nlist=None,                 # Auto si None (√n_vectors)
-    nprobe=8,                   # Clusters à visiter (1-nlist)
-    use_gpu=False,              # GPU si disponible
-    auto_optimize=True          # Migration auto Flat→IVF
-)
-
-Choix de nprobe (compromis vitesse/qualité):
-  nprobe=1:     Très rapide, qualité ~80%
-  nprobe=8:     Bon compromis, qualité ~95%
-  nprobe=16:    Plus lent, qualité ~98%
-  nprobe=nlist: Équivalent Flat (100%)
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ STATISTIQUES GLOBALES                                                │
-└──────────────────────────────────────────────────────────────────────┘
-
-Phases complètes:     8/13  (62%)
-  ✓ Phase 1: Fondations
-  ✓ Phase 2: Embeddings + FAISS
-  ✓ Phase 4: Détection UI
-  ✓ Phase 5: Workflow Graphs
-  ✓ Phase 6: Action Execution
-  ✓ Phase 7: Learning System
-  ✓ Phase 8: Training System
-  ✓ Phase 10: Error Handling
-  ✓ Phase 11: Persistence & Storage
-  ✓ Phase 11: FAISS IVF Optimization ← NOUVEAU
-
-Implémentation:       42/50 tâches (84%)
-Tests property:       2/20 tâches (10%)
-
-Fichiers créés:       55+ fichiers
-Tests fonctionnels:   23+ tests passés
-
-Modèles intégrés:     3/3  (100%)
-  ✓ OpenCLIP
-  ✓ OWL-v2
-  ✓ Qwen3-VL
-
-┌──────────────────────────────────────────────────────────────────────┐
-│ PROCHAINES ÉTAPES - PHASE 11 SUITE                                  │
-└──────────────────────────────────────────────────────────────────────┘
-
-Objectif: Finaliser optimisations de performance
-
-Tâches restantes:
-  → 11.4 Optimiser détection UI avec ROI
-  → 11.5 Tests de performance complets
-  → 12. Checkpoint Final
-
-Estimation: 2-3 heures
-
-╔══════════════════════════════════════════════════════════════════════╗
-║  SYSTÈME HAUTE PERFORMANCE - IVF + Cache Implémentés (84%)          ║
-╚══════════════════════════════════════════════════════════════════════╝

TEST_NOW.sh

@@ -1,44 +0,0 @@
-#!/bin/bash
-# TEST_NOW.sh
-# Script ultra-simple pour tester le serveur immédiatement
-
-echo "🚀 RPA Vision V3 - Test Rapide"
-echo "================================"
-echo ""
-
-# 1. Vérifier l'environnement
-if [ ! -d "venv_v3" ]; then
-    echo "❌ Environnement virtuel non trouvé"
-    exit 1
-fi
-
-source venv_v3/bin/activate
-
-# 2. Vérifier les dépendances
-echo "📦 Vérification dépendances..."
-python -c "import fastapi, flask, cryptography" 2>/dev/null
-if [ $? -ne 0 ]; then
-    echo "⚠️  Installation des dépendances..."
-    pip install -q fastapi 'uvicorn[standard]' python-multipart flask cryptography
-fi
-echo "✅ Dépendances OK"
-echo ""
-
-# 3. Lancer les tests
-echo "🧪 Lancement des tests..."
-pytest tests/integration/test_server_pipeline.py -v --tb=short 2>&1 | grep -E "(PASSED|FAILED|passed|failed)"
-echo ""
-
-# 4. Démarrer le serveur
-echo "🚀 Démarrage du serveur..."
-echo ""
-echo "📝 Commandes disponibles:"
-echo "  - Démarrer: ./server/start_all.sh"
-echo "  - Dashboard: xdg-open http://localhost:5001"
-echo "  - Test API: curl http://localhost:8000/api/traces/status"
-echo ""
-echo "📚 Documentation:"
-echo "  - Quick Start: QUICK_START_SERVER.md"
-echo "  - Guide complet: SERVER_READY_TO_TEST.md"
-echo ""
-echo "✅ Prêt pour les tests!"

VISUAL_WORKFLOW_BUILDER_VISION_REFACTOR_COMPLETE.md

@@ -1,214 +0,0 @@
- !*re du RPAhistoil'a dans erate qui rest Une dier 2026 -é le 7 Janvlét comp
-*Projet*
-PE !*'ÉQUITOUTE LONS À TIICITA🏆 FÉL---
-
-**nts.
-
-eas plus exigion le de productmentsronneviens our les pequisebilité ret la fiaion  précisnt laaintena en mus toutessible à totion acctomatisaendant l'auon du RPA, rns l'évoluti daue**historiqpe ue une **étan marqalisatiote ré
-
-Cetsation**cité d'utilipliim **S*
-- 👥aximale*Robustesse m️ **e**
-- 🛡 enterpris*Performance🚀 *
-- **perfect pixel- **Précision
-- 🎯nte** poielle deficince Arti**Intellige
-- 🧠 :
-ombinant , cde**mon au avancéws le plus e workfloe création dtème d le **syst désormais3 esn Visioer de RPA Vildrkflow Bue Visual Wo**
-
-LNCE !XCELLEC EIE AVEION ACCOMPL
-
-**MISSConclusion## 🎊 
----
-
-onitoring
-té et m sécuriavecdy** tion-readucro*Code p
-- *ion rapidedopt* pour aive*on exhaustcumentatits
-- **Do par tesvalidéesion** orrect cétés de **45 propriuccès
--c s aveomplétées**14 tâches c4/*1ution
-- *écence d'Ex### Excell
-
-ptimiséeormance oc perf* avegrade*enterprise-e *Architecturterface
-- * d'inpréhensionur la comée** poe avancficiell artince**Intellige
-- ath** CSS/XPurs fragilessélectes complète deion inate
-- **Élim** au mondsion-based 100% vimeer systèmi **Preine RPA :
--le domadans e** ologiquhnution tec une **révolprésenterojet rerough
-Ce preakthInnovation B
-### echnique
-issance T## 🏅 Reconnas
-
----
-
-gékflows partal** : Worps réeemon toratiCollabiles
-4. **obces m interfatension auxpport** : Exobile subles
-3. **Mes et scalas distribué: APIn cloud** ratio**Intéges
-2.  modèlcontinue desoration : Amélie** e automatiqutissagens
-1. **Apprs Futureutionvol
-### É intégrées
-triquesméion** avec oduct pring4. **Monitordes créés
-avec les gui** uipesn éqatio. **Formduction
-3l de proie* sur matérmance*orks perfenchmar
-2. **Bon fourniementatic la docu avesateur**tion utiliaccepta*Tests d't
-1. *Déploiemense de haes
-
-### Pmmandétapes Reco ÉProchaines# 🚀 ---
-
-#
-s le RPA
-gique danlohip technoadersLetion** : ova **Innady
--prise-reture enterechitlité** : Arccalabiws
-- **Sfloes workfiée dmplince sintena : Maioûts**ion cductsed
-- **Rébaon-visition 100% lue so* : Premièriel*urrentge conc- **AvantaEntreprise
-# Pour l'r
-
-##ppeuur et dévelotelisades utiète** : Gui complionumentat**Docavancé
-- ed testing y-basrtrope* : P exhaustifs***Testscumentés
-- EST do REndpoints* : ètes*omplIs cI
-- **AP Material-Ut + + TypeScripcterne** : Reacture modchite**Ar
-- éveloppeurss D
-### Pour lebles
-inue des cidation cont* : Vali temps réel*Feedbacke
-- ** naturelln visuelleSélectioe** : e intuitiv*Interfac
-- *aces d'interf changementsistance auxle** : Rémaximatesse 
-- **Robuseshniquissances tecnnaoin de coesus bnaire** : Plolutionplicité rév- **Simeurs
-ilisat les Ut# Pourices
-
-##et Bénéf# 🌟 Impact -
-
-#idé)
-
---al: >80% (vn** ctiodétece **Confianrôlée)
-- B (cont: <100M** reation mémoi**Utilissé)
-- (optimi** : >80% cache **Taux de int)
--attetif s (objec<3 secondeion** : Temps détectteint)
-- **objectif atdes (* : <2 secons capture**Tempance
-- *formques de Perétrie
-
-### Mncilierést t système etarence é Cohé5** : **P41-P4moire
--rmance et méé perfobilitScalaP36-P40** :  **
--uesures uniqt signatnées eé donIntégritP35** : - **P31-eurs
-n errtioet gesme stesse systè** : RobuP26-P30rs
-- **-moniteunées multi coordon MappingP21-P25** :ance
-- **nfi coion etect détmeéterminisP20** : De
-- **P16-tion cachance et ges** : Perform**P11-P15données
-- métaet uelles les vislidation cib : Va**P6-P10** boxes
-- et boundingdonnées ence coorér CohP1-P5** :tés)
-- **rié (45 Propedrty-BasropeTests P
-### ue
-tion Techniqida
-## 🔬 Val-
-mages
-
---essif des ient progr : Chargemng**loadiy **Laz(300ms)
-- timisées entes options fréquéra : OpDebouncing**- **ptimisées
-longues ostes  Liation** :rtualiz0MB
-- **Vimite 5c liU aveCache LRU/LF: * g*mage cachin
-- **Imizationstiformance Op## Peravier
-
-#vigation clARIA et nas ributlité** : AttssibiAcce
-- **ivesatadapt grilles akpoints etn** : Brensive desig*Respo- *l-UI
-ants Materiaes compose dmalaxitilisation méuérents** : Rts coh**Composan
-- 2c55e)ss Green (#2d2), Succee (#1976ry Blu : Primaleurs**de couPalette ion
-- **gratal-UI Interi
-### Mateem
-n Systé Desigformit
-## 🎨 Con
---`
-
--pannage
-``uide dé# G        md        OOTING.LESH── TROUBeur
-└ développtionrauide intég      # G    ION.md      _INTEGRAT├── API
-eur complet utilisat   # GuideE.md      CTION_GUID_SELE├── VISUALlder/docs/
-buil_workflow_ua
-
-vists Pythones# Terties.py  lder_proplow_buivisual_workft_testy/
-└── roperts/pn
-```
-tesumentatio Doc Tests et
-###
-```
-nt) (existature d'écran API cap  #          .py     een_captures
-└── scrntlémen éAPI détectio      #   .py      on_detectint elemees
-├──isuell vibles    # API c          s.py    rget── visual_taapi/
-├backend/builder/l_workflow_sua
-vi``+ Python
-` Flask ackend``
-
-### B
-`edroperty-bassts p Te  #    s  tion.test.tisualSelec└── v
-    properties/ts__/esges
-└── __tligent imaCache intel       #        .ts    mageCache
-│   └── Ils/ce
-├── utirmanations perfoOptimisn.ts  # izationceOptim usePerforma
-│   └─── hooks/oniteurs
-├─on multi-msti    # Ge         ts e.Servicnitor
-│   └── Mos IA élémentDétectionts     # ice.rvectionSe ElementDetisé
-│   ├──imre opt captu # Service       eService.tsCapturScreen│   ├── les
-bles visuelstion ci# Ge.ts         ervicesualTargetS  ├── Vi
-│  services/
-├──chargementicateurs de   # Ind      or/      icatLoadingInds
-│   └── iteurn multi-monélectio S          #/     orSelector├── Monit
-│   iesées enrich# Métadonn       splay/  taDiisualMetada Vs
-│   ├──isuelles vibleration c Configu   #        fig/ rgetConisualTa── Vce
-│   ├ren de réféturesfichage cap# Af    ew/   creenshotViferenceS  ├── Ree
-│ e principaltion visuell # Sélec        ctor/ lenSereealSc   ├── Visu/
-│mponents├── contend/src/
-uilder/froworkflow_bisual_```
-vpeScript
- Tyact +ontend Re## Fr
-#nts Créés
-posa 🛠 Com
-
-##
----eur
-veloppdét isateur etil* - Guides uration*tation Intég✅ **Documen
-14. hérentlet et copt comp TypeScris Types** -finition**Dé
-13. ✅ idéesn valrectioés de corpropriét 45 ty-Based** -sts Proper
-12. ✅ **Te(12-14)ualité ches Q
-### 🟢 Tâmplets
-cos REST pointnd - EComplètes**PIs Backend  **Anées
-11. ✅doncoor DPI et apping Mteurs** - Multi-Moniupport✅ **Sg
-10. ebouncinalisation, drtuhe, vi** - Cacrformancesation Peptimi ✅ **Oturel
-9. langage naenscriptions  - Decé**nées Avan MétadonAffichage8. ✅ **-11)
-ches Core (8
-
-### 🟡 Tâlidationance et va** - PersistnagerualTargetMan Vistégratio. ✅ **Ine
-7le purvisueln uratioConfigtConfig** - ualTargeomposant Viss
-6. ✅ **C overlayge avec - Affichaw**creenshotViet ReferenceSmposan✅ **Coelle
-5. su% vice 100 Interfalector** -alScreenSetor Visu*Refac4. ✅ *lle
-pérationnen oio de détect IAs** -Élément Détection rationtégé
-3. ✅ **Inntégron V3 i RPA Visi** - BackendCapture Service ationégr**Intlète
-2. ✅ ompimination c* - Élh*at/XPre CSSastructuression Infr
-1. ✅ **Supp (1-7)iques Critâches🔴 T### 
-
-ies (14/14) Accomplches 📋 Tâ
-
-##ans
-
---- multi-écronsuratinfigs cote demplè Gestion co* :r Support*lti-Monito**Muride
-- U hyb LRU/LFe cache avecème dt** : Systgentelli In**Cachevancée
-- ec IA aavéments  d'élion: Détectndes** <3 secotection **Déimisée
-- réel opt temps ure d'écranCaptes** : secondapture <2 prise
-- **Crmance Enter
-#### Perfo
-élémentsntre iales espatations on des relréhensi: Companding** tual Underst
-- **Contexce >80%avec confians cibles tinue deion con : Validation**ate Valid**Real-tim
-- élémentpour chaque ques es uniuellisures v** : Signat Embeddingsdallti-mo
-- **Muvisuellehension  compréinte pour laes IA de poodèl** : M Integration OWL-ViTP +
-- **CLIsion-Centricture Vihitec
-#### Arcologique
-ation Techn 🔬 Innov##A.
-
-#RPe domaindans le lutionnaire avancée révont une eprésentaléments, rion d'éur la sélectur podinatesion par ora vilusivement lésormais exclise dder uti Builal Workflow  
-Le Visuh**CSS/XPatlecteurs  des sélèteination compÉlimINT
-✅ **ipal ATTEjectif Princ
-
-### 🎯 Obeuresions Majalisat# 🚀 Ré--
-
-#
-
--avec succèsréalisé d ion-base% visworkflow 100tème de gique:** Sysnolo TechRévolutionâches)  
-**4 t4/1TERMINÉ (1:** 100%  
-**Statutier 2026 ** 7 Janvetion:Compl
-**Date de ished
-sion Accompl🏆 Mis
-
-## PLETE!ROJECT COMctor - PVision RefaBuilder w rkflol Wo# 🎉 Visua

_archive/dead_code_20260424/core/evaluation/workflow_simulation_report.py

@@ -664,12 +664,12 @@ class WorkflowSimulator:
         try:
             if check.kind == "text_present":
                 # Vérifier présence de texte
-                detected_texts = getattr(screen_state.perception_level, 'detected_texts', []) if hasattr(screen_state, 'perception_level') else []
+                detected_texts = getattr(screen_state.perception, 'detected_text', []) if hasattr(screen_state, 'perception') else []
                 return any(check.value in text for text in detected_texts)
             
             elif check.kind == "text_absent":
                 # Vérifier absence de texte
-                detected_texts = getattr(screen_state.perception_level, 'detected_texts', []) if hasattr(screen_state, 'perception_level') else []
+                detected_texts = getattr(screen_state.perception, 'detected_text', []) if hasattr(screen_state, 'perception') else []
                 return not any(check.value in text for text in detected_texts)
             
             elif check.kind == "element_present":
@@ -681,7 +681,7 @@ class WorkflowSimulator:
             
             elif check.kind == "window_title_contains":
                 # Vérifier titre de fenêtre
-                window_title = getattr(screen_state.raw_level, 'window_title', '') if hasattr(screen_state, 'raw_level') else ''
+                window_title = getattr(screen_state.window, 'window_title', '') if hasattr(screen_state, 'window') else ''
                 return check.value in window_title
             
             else:

_archive/dead_code_20260424/core/pipeline/workflow_pipeline_enhanced.py

@@ -125,25 +125,47 @@ class WorkflowPipelineEnhanced:
             current_node_id = match_result["node_id"]
             logger.info(f"Matched current state to node: {current_node_id} (confidence: {match_result['confidence']:.3f})")
             
-            # 2. Obtenir la prochaine action
+            # 2. Obtenir la prochaine action (contrat dict avec status explicite)
             action_info = self.get_next_action(workflow_id, current_node_id)
-            
-            if not action_info:
-                # Workflow terminé
+            action_status = action_info.get("status")
+
+            if action_status == "terminal":
+                # Workflow terminé (aucun outgoing_edge = fin légitime)
                 performance_metrics.total_execution_time_ms = (datetime.now() - start_time).total_seconds() * 1000
-                
+
                 result = WorkflowExecutionResult.workflow_complete(
                     execution_id=execution_id,
                     workflow_id=workflow_id,
                     current_node=current_node_id,
-                    performance_metrics=performance_metrics
+                    performance_metrics=performance_metrics,
                 )
                 result.correlation_id = correlation_id
                 result.match_result = match_result
-                
+
                 logger.info(f"Workflow {workflow_id} completed at node {current_node_id}")
                 return result
-            
+
+            if action_status == "blocked":
+                # Des edges existent mais aucun ne passe les filtres :
+                # c'est un blocage, pas une fin de workflow.
+                performance_metrics.total_execution_time_ms = (datetime.now() - start_time).total_seconds() * 1000
+
+                result = WorkflowExecutionResult.error(
+                    execution_id=execution_id,
+                    workflow_id=workflow_id,
+                    error_message=f"No valid edge: {action_info.get('reason', 'unknown')}",
+                    step_type="action_selection",
+                    current_node=current_node_id,
+                    performance_metrics=performance_metrics,
+                )
+                result.correlation_id = correlation_id
+
+                logger.warning(
+                    f"Workflow {workflow_id} blocked at node {current_node_id}: "
+                    f"{action_info.get('reason')}"
+                )
+                return result
+
             logger.info(f"Next action: {action_info['action']['type']} -> {action_info['target_node']}")
             
             # 3. Charger le workflow pour obtenir l'edge complet

_archive/dead_code_20260424/core/visual/visual_persistence_manager.py

@@ -14,8 +14,9 @@ import asyncio
 import logging
 import json
 import base64
-import pickle
 import gzip
+import pickle  # noqa: S403 - usage legacy restreint au fallback de migration
+import io
 from typing import Dict, List, Optional, Any, Tuple
 from dataclasses import dataclass, asdict
 from datetime import datetime
@@ -24,6 +25,12 @@ import numpy as np
 
 from core.visual.visual_target_manager import VisualTarget, VisualTargetManager
 from core.visual.screenshot_validation_manager import ScreenshotValidationManager, ValidationResult
+from core.security.signed_serializer import (
+    SignatureVerificationError,
+    UnsupportedFormatError,
+    dumps_signed,
+    loads_signed,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -435,19 +442,19 @@ class VisualPersistenceManager:
             return None
     
     async def _serialize_workflow_data(self, workflow_data: VisualWorkflowData) -> bytes:
-        """Sérialise les données d'un workflow"""
+        """Sérialise les données d'un workflow en JSON signé HMAC."""
         # Convertir en dictionnaire
         data_dict = asdict(workflow_data)
-        
+
         # Traiter les types spéciaux
         data_dict['created_at'] = workflow_data.created_at.isoformat()
-        
+
         # Sérialiser les cibles visuelles
         serialized_targets = {}
         for signature, target in workflow_data.visual_targets.items():
             serialized_targets[signature] = await self._serialize_visual_target(target)
         data_dict['visual_targets'] = serialized_targets
-        
+
         # Sérialiser l'historique de validation
         serialized_history = {}
         for signature, history in workflow_data.validation_history.items():
@@ -455,15 +462,30 @@ class VisualPersistenceManager:
                 self._serialize_validation_result(result) for result in history
             ]
         data_dict['validation_history'] = serialized_history
-        
-        # Convertir en bytes
-        return pickle.dumps(data_dict)
-    
+
+        # JSON signé HMAC (cf. core.security.signed_serializer)
+        return dumps_signed(data_dict)
+
     async def _deserialize_workflow_data(self, data: bytes) -> VisualWorkflowData:
-        """Désérialise les données d'un workflow"""
-        # Désérialiser le dictionnaire
-        data_dict = pickle.loads(data)
-        
+        """Désérialise les données d'un workflow (JSON signé HMAC ;
+        fallback pickle legacy avec WARNING pour migrer les anciens fichiers)."""
+        try:
+            data_dict = loads_signed(data)
+        except SignatureVerificationError:
+            # Fichier altéré ou clé différente : on refuse sans fallback.
+            logger.error("Workflow visuel : signature HMAC invalide — refus.")
+            raise
+        except UnsupportedFormatError:
+            # Ancien format pickle : fallback explicite et bruyant.
+            import os
+            if os.getenv("RPA_ALLOW_PICKLE_FALLBACK", "1") == "0":
+                raise
+            logger.warning(
+                "Workflow visuel au format pickle legacy — lecture de compat, "
+                "ré-écrire en JSON signé dès que possible."
+            )
+            data_dict = pickle.loads(data)  # noqa: S301 - fallback legacy
+
         # Reconstruire les objets
         workflow_data = VisualWorkflowData(
             workflow_id=data_dict['workflow_id'],

agent_chat/autonomous_planner.py

@@ -27,6 +27,8 @@ import requests
 # Ajouter le chemin du projet pour les imports core
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
 
+from core.detection.vlm_config import get_reasoning_model
+
 logger = logging.getLogger(__name__)
 
 # Essayer d'importer les composants de détection visuelle
@@ -49,7 +51,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
@@ -110,11 +115,11 @@ class AutonomousPlanner:
     def __init__(
         self,
         llm_endpoint: str = "http://localhost:11434/api/generate",
-        llm_model: str = "qwen2.5:7b",
+        llm_model: Optional[str] = None,
         timeout: int = 60
     ):
         self.llm_endpoint = llm_endpoint
-        self.llm_model = llm_model
+        self.llm_model = llm_model or get_reasoning_model()
         self.timeout = timeout
         self.llm_available = self._check_llm()
 
@@ -134,11 +139,31 @@ class AutonomousPlanner:
         logger.info(f"AutonomousPlanner initialized (LLM: {self.llm_model}, available: {self.llm_available}, visual: {self._owl_detector is not None}, vlm: {self._vlm_client is not None})")
 
     def _init_visual_detection(self):
-        """Initialise le détecteur visuel OWL-v2."""
+        """Initialise le détecteur visuel OWL-v2.
+
+        Désactivé par défaut depuis 2026-05-25 (C1b) : OWL-v2 chargeait sur
+        CUDA au boot et retenait ~600 MiB VRAM même en cas d'OOM silencieux,
+        fausssant les benchs perf et contribuant à l'offload Ollama VLM.
+        Comme `autonomous_planner` est largement non-wired au runtime actif
+        (cf. mémoire projet : HTTP 410 dépréciés), le défaut est skip.
+
+        Activation : `AGENT_CHAT_ENABLE_OWL=1` (env var).
+        Device : `AGENT_CHAT_OWL_DEVICE=cuda|cpu` (override l'auto-détect).
+        """
+        if os.environ.get("AGENT_CHAT_ENABLE_OWL", "0").strip() not in ("1", "true", "yes"):
+            logger.info(
+                "OWL-v2 visual detector skipped at boot "
+                "(AGENT_CHAT_ENABLE_OWL!=1, économie ~600 MiB VRAM)"
+            )
+            return
         if VISUAL_DETECTION_AVAILABLE and OwlDetector:
             try:
-                self._owl_detector = OwlDetector(confidence_threshold=0.1)
-                logger.info("OWL-v2 visual detector initialized")
+                device = os.environ.get("AGENT_CHAT_OWL_DEVICE", "").strip() or None
+                self._owl_detector = OwlDetector(
+                    confidence_threshold=0.1,
+                    device=device,
+                )
+                logger.info(f"OWL-v2 visual detector initialized (device={device or 'auto'})")
             except Exception as e:
                 logger.warning(f"Could not initialize OWL detector: {e}")
                 self._owl_detector = None
@@ -147,8 +172,10 @@ class AutonomousPlanner:
         """Initialise le client VLM pour analyse intelligente."""
         if VLM_AVAILABLE and OllamaClient:
             try:
-                self._vlm_client = OllamaClient(model="qwen2.5vl:7b")
-                logger.info("VLM client initialized (qwen2.5vl:7b)")
+                from core.detection.vlm_config import get_vlm_model
+                _planner_vlm = get_vlm_model()
+                self._vlm_client = OllamaClient(model=_planner_vlm)
+                logger.info("VLM client initialized (%s)", _planner_vlm)
             except Exception as e:
                 logger.warning(f"Could not initialize VLM client: {e}")
                 self._vlm_client = None
@@ -197,7 +224,8 @@ NOT_FOUND"""
                 prompt=prompt,
                 image=screenshot,
                 temperature=0.1,
-                max_tokens=100
+                max_tokens=100,
+                assistant_prefill="COORDINATES:",
             )
 
             if result.get('success'):
@@ -1002,12 +1030,12 @@ _planner_instance: Optional[AutonomousPlanner] = None
 
 
 def get_autonomous_planner(
-    llm_model: str = "qwen2.5:7b"
+    llm_model: Optional[str] = None
 ) -> AutonomousPlanner:
     """Retourne l'instance singleton du planner."""
     global _planner_instance
 
     if _planner_instance is None:
-        _planner_instance = AutonomousPlanner(llm_model=llm_model)
+        _planner_instance = AutonomousPlanner(llm_model=llm_model or get_reasoning_model())
 
     return _planner_instance

agent_chat/gesture_catalog.py

@@ -0,0 +1,808 @@
+#!/usr/bin/env python3
+"""
+RPA Vision V3 - Catalogue de Primitives Gestuelles
+
+Bibliothèque de gestes universels Windows (raccourcis clavier) que le système
+connaît nativement, sans apprentissage visuel.
+
+Trois usages :
+1. Chat : l'utilisateur demande "ferme la fenêtre" → match direct → exécution
+2. Replay : une action enregistrée correspond à un geste connu → substitution
+   automatique par le raccourci clavier (plus fiable que le clic visuel)
+3. Workflows : enrichissement automatique des workflows avec les primitives
+
+Auteur: Dom — Mars 2026
+"""
+
+import logging
+import re
+import unicodedata
+import uuid
+from dataclasses import dataclass, field
+from difflib import SequenceMatcher
+from typing import Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+SAVE_COMMAND_LABELS = {"enregistrer", "save", "sauvegarder"}
+SAVE_AS_LABELS = {"enregistrer sous", "save as", "sauvegarder sous"}
+FILE_MENU_LABELS = {"fichier", "file", "menu fichier", "file menu"}
+
+
+@dataclass
+class Gesture:
+    """Un geste primitif universel."""
+    id: str
+    name: str
+    description: str
+    keys: List[str]                    # Ex: ["alt", "f4"], ["ctrl", "t"]
+    aliases: List[str] = field(default_factory=list)  # Termes alternatifs
+    tags: List[str] = field(default_factory=list)
+    context: str = "windows"           # "windows", "chrome", "explorer", etc.
+    category: str = "window"           # "window", "navigation", "editing", "system"
+
+    def to_replay_action(self) -> Dict:
+        """Convertir en action de replay pour l'Agent V1."""
+        return {
+            "action_id": f"gesture_{self.id}_{uuid.uuid4().hex[:6]}",
+            "type": "key_combo",
+            "keys": self.keys,
+            "gesture_id": self.id,
+            "gesture_name": self.name,
+        }
+
+
+# =============================================================================
+# Catalogue des primitives
+# =============================================================================
+
+GESTURES: List[Gesture] = [
+    # --- Gestion de fenêtres ---
+    Gesture(
+        id="win_close", name="Fermer la fenêtre",
+        description="Fermer la fenêtre active",
+        keys=["alt", "f4"],
+        aliases=["fermer", "close", "quitter la fenêtre", "fermer l'application",
+                 "fermer le programme", "close window"],
+        tags=["fenêtre", "fermer", "close"],
+        category="window",
+    ),
+    Gesture(
+        id="win_maximize", name="Agrandir la fenêtre",
+        description="Agrandir la fenêtre au maximum",
+        keys=["super", "up"],
+        aliases=["agrandir", "maximize", "plein écran", "maximiser",
+                 "fullscreen", "agrandir la fenêtre"],
+        tags=["fenêtre", "agrandir", "maximize"],
+        category="window",
+    ),
+    Gesture(
+        id="win_minimize", name="Réduire la fenêtre",
+        description="Réduire la fenêtre dans la barre des tâches",
+        keys=["super", "down"],
+        aliases=["réduire", "minimize", "minimiser", "réduire la fenêtre",
+                 "mettre en bas"],
+        tags=["fenêtre", "réduire", "minimize"],
+        category="window",
+    ),
+    Gesture(
+        id="win_minimize_all", name="Afficher le bureau",
+        description="Réduire toutes les fenêtres (afficher le bureau)",
+        keys=["super", "d"],
+        aliases=["bureau", "desktop", "afficher le bureau", "tout réduire",
+                 "montrer le bureau", "show desktop"],
+        tags=["bureau", "desktop", "minimize all"],
+        category="window",
+    ),
+    Gesture(
+        id="win_switch", name="Basculer entre fenêtres",
+        description="Basculer vers la fenêtre suivante",
+        keys=["alt", "tab"],
+        aliases=["basculer", "switch", "changer de fenêtre",
+                 "fenêtre suivante", "alt tab"],
+        tags=["fenêtre", "basculer", "switch"],
+        category="window",
+    ),
+    Gesture(
+        id="win_snap_left", name="Fenêtre à gauche",
+        description="Ancrer la fenêtre à gauche de l'écran",
+        keys=["super", "left"],
+        aliases=["fenêtre à gauche", "snap left", "ancrer à gauche",
+                 "moitié gauche"],
+        tags=["fenêtre", "snap", "gauche"],
+        category="window",
+    ),
+    Gesture(
+        id="win_snap_right", name="Fenêtre à droite",
+        description="Ancrer la fenêtre à droite de l'écran",
+        keys=["super", "right"],
+        aliases=["fenêtre à droite", "snap right", "ancrer à droite",
+                 "moitié droite"],
+        tags=["fenêtre", "snap", "droite"],
+        category="window",
+    ),
+    Gesture(
+        id="win_restore", name="Restaurer la fenêtre",
+        description="Restaurer la taille normale de la fenêtre",
+        keys=["super", "down"],
+        aliases=["restaurer", "restore", "taille normale",
+                 "fenêtre normale"],
+        tags=["fenêtre", "restaurer", "restore"],
+        category="window",
+    ),
+
+    # --- Navigation Chrome / navigateur ---
+    Gesture(
+        id="chrome_new_tab", name="Nouvel onglet",
+        description="Ouvrir un nouvel onglet dans le navigateur",
+        keys=["ctrl", "t"],
+        aliases=["nouvel onglet", "new tab", "ouvrir un onglet",
+                 "ajouter un onglet", "nouveau tab"],
+        tags=["chrome", "onglet", "tab", "nouveau"],
+        context="chrome",
+        category="navigation",
+    ),
+    Gesture(
+        id="chrome_close_tab", name="Fermer l'onglet",
+        description="Fermer l'onglet actif du navigateur",
+        keys=["ctrl", "w"],
+        aliases=["fermer l'onglet", "close tab", "fermer le tab",
+                 "fermer cet onglet"],
+        tags=["chrome", "onglet", "fermer"],
+        context="chrome",
+        category="navigation",
+    ),
+    Gesture(
+        id="chrome_next_tab", name="Onglet suivant",
+        description="Passer à l'onglet suivant",
+        keys=["ctrl", "tab"],
+        aliases=["onglet suivant", "next tab", "tab suivant",
+                 "prochain onglet"],
+        tags=["chrome", "onglet", "suivant"],
+        context="chrome",
+        category="navigation",
+    ),
+    Gesture(
+        id="chrome_prev_tab", name="Onglet précédent",
+        description="Passer à l'onglet précédent",
+        keys=["ctrl", "shift", "tab"],
+        aliases=["onglet précédent", "previous tab", "tab précédent",
+                 "onglet d'avant"],
+        tags=["chrome", "onglet", "précédent"],
+        context="chrome",
+        category="navigation",
+    ),
+    Gesture(
+        id="chrome_reopen_tab", name="Rouvrir le dernier onglet",
+        description="Rouvrir le dernier onglet fermé",
+        keys=["ctrl", "shift", "t"],
+        aliases=["rouvrir l'onglet", "reopen tab", "onglet fermé",
+                 "restaurer l'onglet"],
+        tags=["chrome", "onglet", "rouvrir"],
+        context="chrome",
+        category="navigation",
+    ),
+    Gesture(
+        id="chrome_address_bar", name="Barre d'adresse",
+        description="Sélectionner la barre d'adresse du navigateur",
+        keys=["ctrl", "l"],
+        aliases=["barre d'adresse", "address bar", "url bar",
+                 "aller à l'adresse", "sélectionner l'url"],
+        tags=["chrome", "url", "adresse"],
+        context="chrome",
+        category="navigation",
+    ),
+    Gesture(
+        id="chrome_refresh", name="Rafraîchir la page",
+        description="Recharger la page web actuelle",
+        keys=["f5"],
+        aliases=["rafraîchir", "refresh", "recharger", "actualiser",
+                 "reload"],
+        tags=["chrome", "rafraîchir", "reload"],
+        context="chrome",
+        category="navigation",
+    ),
+    Gesture(
+        id="chrome_back", name="Page précédente",
+        description="Retourner à la page précédente",
+        keys=["alt", "left"],
+        aliases=["retour", "back", "page précédente", "revenir en arrière",
+                 "page d'avant"],
+        tags=["chrome", "retour", "back"],
+        context="chrome",
+        category="navigation",
+    ),
+    Gesture(
+        id="chrome_forward", name="Page suivante",
+        description="Aller à la page suivante",
+        keys=["alt", "right"],
+        aliases=["avancer", "forward", "page suivante"],
+        tags=["chrome", "avancer", "forward"],
+        context="chrome",
+        category="navigation",
+    ),
+    Gesture(
+        id="chrome_find", name="Rechercher dans la page",
+        description="Ouvrir la barre de recherche dans la page",
+        keys=["ctrl", "f"],
+        aliases=["rechercher", "find", "chercher dans la page", "ctrl f",
+                 "trouver"],
+        tags=["chrome", "rechercher", "find"],
+        context="chrome",
+        category="navigation",
+    ),
+    Gesture(
+        id="chrome_new_window", name="Nouvelle fenêtre",
+        description="Ouvrir une nouvelle fenêtre de navigateur",
+        keys=["ctrl", "n"],
+        aliases=["nouvelle fenêtre", "new window", "ouvrir une fenêtre"],
+        tags=["chrome", "fenêtre", "nouveau"],
+        context="chrome",
+        category="navigation",
+    ),
+
+    # --- Édition / presse-papier ---
+    Gesture(
+        id="edit_copy", name="Copier",
+        description="Copier la sélection dans le presse-papier",
+        keys=["ctrl", "c"],
+        aliases=["copier", "copy", "ctrl c"],
+        tags=["édition", "copier", "presse-papier"],
+        category="editing",
+    ),
+    Gesture(
+        id="edit_paste", name="Coller",
+        description="Coller le contenu du presse-papier",
+        keys=["ctrl", "v"],
+        aliases=["coller", "paste", "ctrl v"],
+        tags=["édition", "coller", "presse-papier"],
+        category="editing",
+    ),
+    Gesture(
+        id="edit_cut", name="Couper",
+        description="Couper la sélection",
+        keys=["ctrl", "x"],
+        aliases=["couper", "cut", "ctrl x"],
+        tags=["édition", "couper"],
+        category="editing",
+    ),
+    Gesture(
+        id="edit_undo", name="Annuler",
+        description="Annuler la dernière action",
+        keys=["ctrl", "z"],
+        aliases=["annuler", "undo", "défaire", "ctrl z"],
+        tags=["édition", "annuler", "undo"],
+        category="editing",
+    ),
+    Gesture(
+        id="edit_redo", name="Rétablir",
+        description="Rétablir l'action annulée",
+        keys=["ctrl", "y"],
+        aliases=["rétablir", "redo", "refaire", "ctrl y"],
+        tags=["édition", "rétablir", "redo"],
+        category="editing",
+    ),
+    Gesture(
+        id="edit_select_all", name="Tout sélectionner",
+        description="Sélectionner tout le contenu",
+        keys=["ctrl", "a"],
+        aliases=["tout sélectionner", "select all", "sélectionner tout",
+                 "ctrl a"],
+        tags=["édition", "sélection", "tout"],
+        category="editing",
+    ),
+    Gesture(
+        id="edit_save", name="Enregistrer",
+        description="Enregistrer le document/fichier actuel",
+        keys=["ctrl", "s"],
+        aliases=["enregistrer", "save", "sauvegarder", "ctrl s"],
+        tags=["édition", "enregistrer", "save"],
+        category="editing",
+    ),
+
+    # --- Système ---
+    Gesture(
+        id="sys_start_menu", name="Menu Démarrer",
+        description="Ouvrir le menu Démarrer Windows",
+        keys=["super"],
+        aliases=["menu démarrer", "start menu", "démarrer", "windows",
+                 "touche windows"],
+        tags=["système", "démarrer", "menu"],
+        category="system",
+    ),
+    Gesture(
+        id="sys_task_manager", name="Gestionnaire des tâches",
+        description="Ouvrir le gestionnaire des tâches",
+        keys=["ctrl", "shift", "escape"],
+        aliases=["gestionnaire des tâches", "task manager",
+                 "gestionnaire tâches", "processes"],
+        tags=["système", "tâches", "processus"],
+        category="system",
+    ),
+    Gesture(
+        id="sys_lock", name="Verrouiller le PC",
+        description="Verrouiller la session Windows",
+        keys=["super", "l"],
+        aliases=["verrouiller", "lock", "verrouiller le pc",
+                 "verrouiller la session"],
+        tags=["système", "verrouiller", "lock"],
+        category="system",
+    ),
+    Gesture(
+        id="sys_screenshot", name="Capture d'écran",
+        description="Prendre une capture d'écran",
+        keys=["super", "shift", "s"],
+        aliases=["capture d'écran", "screenshot", "capture écran",
+                 "impr écran"],
+        tags=["système", "capture", "screenshot"],
+        category="system",
+    ),
+    Gesture(
+        id="sys_explorer", name="Ouvrir l'explorateur",
+        description="Ouvrir l'explorateur de fichiers Windows",
+        keys=["super", "e"],
+        aliases=["explorateur", "explorer", "ouvrir l'explorateur",
+                 "mes fichiers", "file explorer", "explorateur de fichiers"],
+        tags=["système", "explorateur"],
+        category="system",
+    ),
+    Gesture(
+        id="sys_run", name="Exécuter (Run)",
+        description="Ouvrir la boîte de dialogue Exécuter",
+        keys=["super", "r"],
+        aliases=["exécuter", "run", "boîte exécuter"],
+        tags=["système", "exécuter", "run"],
+        category="system",
+    ),
+    Gesture(
+        id="sys_settings", name="Paramètres Windows",
+        description="Ouvrir les paramètres Windows",
+        keys=["super", "i"],
+        aliases=["paramètres", "settings", "réglages",
+                 "paramètres windows"],
+        tags=["système", "paramètres", "settings"],
+        category="system",
+    ),
+
+    # --- Navigation texte ---
+    Gesture(
+        id="nav_home", name="Début de ligne",
+        description="Aller au début de la ligne",
+        keys=["home"],
+        aliases=["début de ligne", "home", "début"],
+        tags=["navigation", "texte", "début"],
+        category="editing",
+    ),
+    Gesture(
+        id="nav_end", name="Fin de ligne",
+        description="Aller à la fin de la ligne",
+        keys=["end"],
+        aliases=["fin de ligne", "end", "fin"],
+        tags=["navigation", "texte", "fin"],
+        category="editing",
+    ),
+    Gesture(
+        id="nav_enter", name="Valider / Entrée",
+        description="Appuyer sur Entrée",
+        keys=["enter"],
+        aliases=["entrée", "enter", "valider", "confirmer", "ok"],
+        tags=["navigation", "entrée", "valider"],
+        category="editing",
+    ),
+    Gesture(
+        id="nav_escape", name="Échap / Annuler",
+        description="Appuyer sur Échap (fermer popup, annuler)",
+        keys=["escape"],
+        aliases=["échap", "escape", "esc", "annuler", "fermer le popup",
+                 "fermer la popup", "fermer le dialogue"],
+        tags=["navigation", "échap", "annuler", "popup"],
+        category="editing",
+    ),
+    Gesture(
+        id="nav_tab", name="Champ suivant",
+        description="Passer au champ suivant (Tab)",
+        keys=["tab"],
+        aliases=["tab", "champ suivant", "suivant", "prochain champ",
+                 "tabulation"],
+        tags=["navigation", "tab", "champ"],
+        category="editing",
+    ),
+]
+
+
+class GestureCatalog:
+    """
+    Catalogue de gestes primitifs avec matching sémantique.
+
+    Utilisé par :
+    - Le chat (match direct quand l'utilisateur demande un geste)
+    - Le replay (substitution automatique d'actions enregistrées)
+    """
+
+    def __init__(self, gestures: List[Gesture] = None):
+        self.gestures = gestures or GESTURES
+        # Index pour recherche rapide
+        self._by_id: Dict[str, Gesture] = {g.id: g for g in self.gestures}
+        # Pré-calculer les termes de recherche normalisés
+        self._search_index: List[Tuple[Gesture, List[str]]] = []
+        for g in self.gestures:
+            terms = [g.name.lower(), g.description.lower()]
+            terms.extend(a.lower() for a in g.aliases)
+            terms.extend(t.lower() for t in g.tags)
+            self._search_index.append((g, terms))
+
+        logger.info(f"GestureCatalog: {len(self.gestures)} primitives chargées")
+
+    def match(self, query: str, min_score: float = 0.45) -> Optional[Tuple[Gesture, float]]:
+        """
+        Trouver le geste le plus proche d'une requête textuelle.
+
+        Returns:
+            (Gesture, score) si match trouvé, None sinon.
+        """
+        query_lower = query.lower().strip()
+        if not query_lower:
+            return None
+
+        best_gesture = None
+        best_score = 0.0
+
+        for gesture, terms in self._search_index:
+            score = self._compute_score(query_lower, terms, gesture)
+            if score > best_score:
+                best_score = score
+                best_gesture = gesture
+
+        if best_gesture and best_score >= min_score:
+            logger.debug(f"Gesture match: '{query}' → {best_gesture.id} (score={best_score:.2f})")
+            return (best_gesture, best_score)
+
+        return None
+
+    def match_action(self, action: Dict) -> Optional[Gesture]:
+        """
+        Détecter si une action de workflow correspond à un geste primitif.
+
+        Utilisé pendant le replay pour auto-substituer les actions visuelles
+        par des raccourcis clavier plus fiables.
+
+        Patterns détectés :
+        - Clic sur boutons de contrôle fenêtre (X, □, ─)
+        - key_combo qui matche déjà un geste
+        - Actions avec target_text contenant des mots-clés de geste
+        """
+        action_type = action.get("type", "")
+
+        # key_combo → vérifier si c'est déjà un geste connu
+        if action_type == "key_combo":
+            keys = action.get("keys", [])
+            return self._match_by_keys(keys)
+
+        # Clic sur un bouton de contrôle de fenêtre
+        if action_type == "click":
+            return self._match_click_as_gesture(action)
+
+        return None
+
+    def get_by_id(self, gesture_id: str) -> Optional[Gesture]:
+        return self._by_id.get(gesture_id)
+
+    def get_by_category(self, category: str) -> List[Gesture]:
+        return [g for g in self.gestures if g.category == category]
+
+    def get_by_context(self, context: str) -> List[Gesture]:
+        """Gestes applicables à un contexte (inclut toujours 'windows')."""
+        return [
+            g for g in self.gestures
+            if g.context == context or g.context == "windows"
+        ]
+
+    def list_all(self) -> List[Dict]:
+        """Lister tous les gestes pour l'affichage."""
+        return [
+            {
+                "id": g.id,
+                "name": g.name,
+                "description": g.description,
+                "keys": "+".join(g.keys),
+                "category": g.category,
+                "context": g.context,
+            }
+            for g in self.gestures
+        ]
+
+    # =========================================================================
+    # Scoring interne
+    # =========================================================================
+
+    def _compute_score(self, query: str, terms: List[str], gesture: Gesture) -> float:
+        """Calculer le score de correspondance entre une requête et un geste."""
+        best = 0.0
+        query_words = set(query.split())
+
+        for term in terms:
+            # Match exact
+            if query == term:
+                return 1.0
+
+            # Contenu dans l'un ou l'autre sens
+            if query in term:
+                score = len(query) / len(term) * 0.95
+                best = max(best, score)
+                continue
+            if term in query:
+                # Si le terme est un alias exact (mot unique) présent dans la requête
+                # c'est un signal très fort : "copier le texte" contient "copier"
+                if term in query_words:
+                    best = max(best, 0.85)
+                else:
+                    score = len(term) / len(query) * 0.9
+                    best = max(best, score)
+                continue
+
+            # Similarité de séquence
+            ratio = SequenceMatcher(None, query, term).ratio()
+            best = max(best, ratio)
+
+        # Bonus si tous les mots de la requête sont présents dans les termes
+        all_terms_text = " ".join(terms)
+        matched_words = sum(1 for w in query_words if w in all_terms_text)
+        if query_words:
+            word_ratio = matched_words / len(query_words)
+            if word_ratio >= 0.8:
+                best = max(best, 0.5 + word_ratio * 0.4)
+
+        return best
+
+    def _match_by_keys(self, keys: List[str]) -> Optional[Gesture]:
+        """Trouver un geste par sa combinaison de touches exacte."""
+        keys_normalized = [k.lower() for k in keys]
+        for gesture in self.gestures:
+            if gesture.keys == keys_normalized:
+                return gesture
+        return None
+
+    def _match_click_as_gesture(self, action: Dict) -> Optional[Gesture]:
+        """
+        Détecter si un clic correspond à un geste primitif.
+
+        Patterns :
+        - Clic en haut à droite de la fenêtre (x > 95%, y < 5%) → fermer
+        - target_text contenant ✕, ×, X, □, ─, etc.
+        - Commande applicative "Enregistrer" sûre → Ctrl+S
+        """
+        # Vérifier le target_text
+        target_text = (
+            action.get("target_text", "") or
+            action.get("target_spec", {}).get("by_text", "")
+        ).strip()
+
+        if target_text:
+            target_lower = target_text.lower()
+            # Bouton fermer
+            if target_lower in ("✕", "×", "x", "close", "fermer"):
+                return self._by_id.get("win_close")
+            # Bouton maximiser
+            if target_lower in ("□", "☐", "maximize", "agrandir"):
+                return self._by_id.get("win_maximize")
+            # Bouton minimiser
+            if target_lower in ("─", "—", "_", "minimize", "réduire"):
+                return self._by_id.get("win_minimize")
+
+        if self._is_save_command_action(action):
+            return self._by_id.get("edit_save")
+
+        # Vérifier la position relative (coin haut-droite = fermer)
+        x_pct = action.get("x_pct", 0)
+        y_pct = action.get("y_pct", 0)
+
+        if x_pct > 0.96 and y_pct < 0.04:
+            return self._by_id.get("win_close")
+        if 0.92 < x_pct < 0.96 and y_pct < 0.04:
+            return self._by_id.get("win_maximize")
+        if 0.88 < x_pct < 0.92 and y_pct < 0.04:
+            return self._by_id.get("win_minimize")
+
+        return None
+
+    def _normalize_ui_text(self, value: str) -> str:
+        """Normaliser un libellé UI pour comparer accents, casse et raccourcis."""
+        text = str(value or "").strip().lower()
+        text = unicodedata.normalize("NFKD", text)
+        text = "".join(ch for ch in text if not unicodedata.combining(ch))
+        text = text.replace("’", "'")
+        text = re.sub(r"\s+", " ", text)
+        text = re.sub(r"\s*\([^)]*ctrl\s*\+?\s*s[^)]*\)\s*$", "", text)
+        text = re.sub(r"\s+ctrl\s*\+?\s*s\s*$", "", text)
+        return text.strip()
+
+    def _action_text_candidates(self, action: Dict) -> List[str]:
+        """Retourner les libellés utiles d'une action et de son target_spec."""
+        target_spec = action.get("target_spec") or {}
+        candidates = [
+            action.get("target_text", ""),
+            action.get("target_description", ""),
+            action.get("description", ""),
+            target_spec.get("by_text", ""),
+            target_spec.get("target_text", ""),
+            target_spec.get("vlm_description", ""),
+        ]
+        return [str(c) for c in candidates if c]
+
+    def _action_role_text(self, action: Dict) -> str:
+        target_spec = action.get("target_spec") or {}
+        uia = action.get("uia_snapshot") or {}
+        role_parts = [
+            action.get("role", ""),
+            action.get("control_type", ""),
+            target_spec.get("by_role", ""),
+            target_spec.get("role", ""),
+            target_spec.get("control_type", ""),
+            uia.get("control_type", ""),
+            uia.get("class_name", ""),
+        ]
+        return " ".join(self._normalize_ui_text(part) for part in role_parts if part)
+
+    def _action_context_text(self, action: Dict) -> str:
+        target_spec = action.get("target_spec") or {}
+        hints = target_spec.get("context_hints") or {}
+        context_parts = [
+            action.get("window_title", ""),
+            target_spec.get("window_title", ""),
+            target_spec.get("vlm_description", ""),
+            hints.get("window_title", ""),
+            hints.get("interaction", ""),
+            hints.get("source", ""),
+            hints.get("menu_path", ""),
+        ]
+        return " ".join(self._normalize_ui_text(part) for part in context_parts if part)
+
+    def _is_file_menu_action(self, action: Dict) -> bool:
+        labels = {self._normalize_ui_text(text) for text in self._action_text_candidates(action)}
+        return bool(labels & FILE_MENU_LABELS)
+
+    def _is_save_command_label(self, action: Dict) -> bool:
+        for text in self._action_text_candidates(action):
+            label = self._normalize_ui_text(text)
+            if not label:
+                continue
+            if any(save_as in label for save_as in SAVE_AS_LABELS):
+                return False
+            if label in SAVE_COMMAND_LABELS:
+                return True
+        return False
+
+    def _is_save_dialog_action(self, action: Dict) -> bool:
+        context = self._action_context_text(action)
+        if any(save_as in context for save_as in SAVE_AS_LABELS):
+            return True
+        dialog_markers = (
+            "save dialog",
+            "save_dialog",
+            "dialog",
+            "boite de dialogue",
+            "fenetre enregistrer sous",
+            "confirmer l'enregistrement",
+            "save changes",
+        )
+        return any(marker in context for marker in dialog_markers)
+
+    def _is_save_command_action(self, action: Dict) -> bool:
+        if not self._is_save_command_label(action):
+            return False
+        if self._is_save_dialog_action(action):
+            return False
+
+        role = self._action_role_text(action)
+        context = self._action_context_text(action)
+        command_markers = (
+            "menu",
+            "menuitem",
+            "item de menu",
+            "toolbar",
+            "barre d'outils",
+            "tool bar",
+            "ruban",
+            "ribbon",
+            "commande",
+            "command",
+        )
+        return any(marker in role or marker in context for marker in command_markers)
+
+    def _substitute_action(
+        self,
+        action: Dict,
+        gesture: Gesture,
+        *,
+        original_type: str,
+        source_action_ids: Optional[List[str]] = None,
+        reason: str = "",
+    ) -> Dict:
+        new_action = gesture.to_replay_action()
+        new_action["action_id"] = action.get("action_id", new_action["action_id"])
+        new_action["original_type"] = original_type
+        if source_action_ids:
+            new_action["substitution_source_action_ids"] = source_action_ids
+        if reason:
+            new_action["substitution_reason"] = reason
+        return new_action
+
+    def optimize_replay_actions(self, actions: List[Dict]) -> List[Dict]:
+        """
+        Optimiser une liste d'actions de replay en substituant les gestes connus.
+
+        Pour chaque action, si elle correspond à un geste primitif,
+        on la remplace par le raccourci clavier équivalent.
+
+        Retourne la liste d'actions optimisée (les originales non-matchées
+        sont conservées telles quelles).
+        """
+        optimized = []
+        substitutions = 0
+
+        for action in actions:
+            if (
+                action.get("type") == "click"
+                and optimized
+                and optimized[-1].get("type") == "click"
+                and self._is_file_menu_action(optimized[-1])
+                and self._is_save_command_label(action)
+                and not self._is_save_dialog_action(action)
+            ):
+                gesture = self._by_id.get("edit_save")
+                previous = optimized.pop()
+                source_ids = [
+                    source_id for source_id in (
+                        previous.get("action_id"),
+                        action.get("action_id"),
+                    )
+                    if source_id
+                ]
+                optimized.append(
+                    self._substitute_action(
+                        action,
+                        gesture,
+                        original_type="click_sequence",
+                        source_action_ids=source_ids,
+                        reason="file_menu_save_to_ctrl_s",
+                    )
+                )
+                substitutions += 1
+                logger.debug("Séquence Fichier > Enregistrer substituée par Ctrl+S")
+                continue
+
+            gesture = self.match_action(action)
+            if gesture and action.get("type") != "key_combo":
+                # Substituer par le raccourci clavier
+                new_action = self._substitute_action(
+                    action,
+                    gesture,
+                    original_type=action.get("type", ""),
+                    reason=f"{gesture.id}_gesture_substitution",
+                )
+                optimized.append(new_action)
+                substitutions += 1
+                logger.debug(
+                    f"Geste substitué: {action.get('type')} → {gesture.id} ({gesture.name})"
+                )
+            else:
+                optimized.append(action)
+
+        if substitutions:
+            logger.info(
+                f"Replay optimisé: {substitutions} action(s) substituée(s) par des primitives"
+            )
+
+        return optimized
+
+
+# Singleton
+_catalog: Optional[GestureCatalog] = None
+
+
+def get_gesture_catalog() -> GestureCatalog:
+    global _catalog
+    if _catalog is None:
+        _catalog = GestureCatalog()
+    return _catalog

agent_chat/handlers/__init__.py

@@ -0,0 +1,29 @@
+"""Agent-chat handlers package.
+
+Contient les orchestrateurs spécialisés (apprentissage Léa, etc.) appelés
+par `agent_chat.app` quand le routage normal d'intent ne suffit pas.
+"""
+
+from .learn_action import (
+    LearnActionOrchestrator,
+    LearnState,
+    LearnIntent,
+    LearnIntentParser,
+    OptionCFormatter,
+    StreamingClient,
+    StateStore,
+    PersistPayloadBuilder,
+    get_learn_action_orchestrator,
+)
+
+__all__ = [
+    "LearnActionOrchestrator",
+    "LearnState",
+    "LearnIntent",
+    "LearnIntentParser",
+    "OptionCFormatter",
+    "StreamingClient",
+    "StateStore",
+    "PersistPayloadBuilder",
+    "get_learn_action_orchestrator",
+]

agent_chat/intent_parser.py

@@ -19,6 +19,8 @@ from enum import Enum
 from typing import Dict, Any, List, Optional, Tuple
 from pathlib import Path
 
+from core.detection.vlm_config import get_reasoning_model
+
 logger = logging.getLogger(__name__)
 
 
@@ -29,12 +31,15 @@ class IntentType(Enum):
     LIST = "list"                # Lister les workflows disponibles
     CONFIGURE = "configure"      # Configurer un paramètre
     HELP = "help"                # Demander de l'aide
+    GREETING = "greeting"        # Salutation
     STATUS = "status"            # Vérifier le statut
     CANCEL = "cancel"            # Annuler l'exécution en cours
     HISTORY = "history"          # Voir l'historique
     CONFIRM = "confirm"          # Confirmer une action
     DENY = "deny"                # Refuser une action
     CLARIFY = "clarify"          # Demander une clarification
+    DATA_IMPORT = "data_import"  # Importer des données (Excel, CSV)
+    SMALL_TALK = "small_talk"    # Conversation informelle (merci, café, ça va...)
     UNKNOWN = "unknown"          # Intention non reconnue
 
 
@@ -73,28 +78,106 @@ class IntentParser:
 
     # Patterns pour la détection d'intentions par règles
     INTENT_PATTERNS = {
+        IntentType.DATA_IMPORT: [
+            # Import de fichiers Excel/CSV
+            r"(?:importe|charge|lis|lire)\s+(?:le\s+fichier\s+|les\s+(?:données|feuilles)\s+(?:de|du|excel\s+du)\s+)?(.+\.xlsx?)\b",
+            r"(?:importe|charge|lis|lire)\s+(?:le\s+fichier\s+|les\s+(?:données|feuilles)\s+(?:de|du|excel\s+du)\s+)?(.+\.csv)\b",
+            r"(?:importe|charge|lis|lire)\s+(?:le\s+fichier\s+)?excel\s+(.+)",
+            r"(?:importe|charge|lis|lire)\s+(?:les\s+)?(?:feuilles?\s+)?excel\s+(?:du\s+dossier\s+|de\s+)(.+)",
+            r"(?:crée?|créer?)\s+une?\s+table\s+(?:à\s+partir\s+d[eu]'?\s*)(.+\.xlsx?)\b",
+            # Lister les tables
+            r"(?:montre|liste|affiche|voir)\s*(?:-moi\s+)?(?:les\s+)?tables?\b",
+            r"(?:quelles?\s+)?tables?\s+(?:sont\s+)?(?:disponibles?|dans\s+la\s+base)",
+            r"liste\s+(?:des?\s+)?tables?\s+(?:de\s+)?(?:la\s+)?(?:base)?",
+            # Infos sur une table
+            r"(?:combien\s+de\s+lignes?\s+(?:dans|pour)\s+(?:la\s+)?table\s+)(\w+)",
+            r"(?:info|détails?|describe?|colonnes?|structure)\s+(?:de\s+)?(?:la\s+)?table\s+(\w+)",
+        ],
         IntentType.EXECUTE: [
-            r"(?:lance|exécute|démarre|fait|run|start|execute)\s+(.+)",
-            r"(?:je veux|je voudrais|peux-tu)\s+(.+)",
+            # Verbes d'action explicites
+            r"(?:lance[rz]?|exécute[rz]?|démarre[rz]?|fai[st]|run|start|execute)\s+(.+)",
+            r"(?:je veux|je voudrais|peux-tu|pouvez-vous)\s+(.+)",
             r"(?:facturer?|créer?|générer?|exporter?)\s+(.+)",
             r"^(.+)\s+(?:maintenant|tout de suite|svp|stp)$",
+            # Langage humain — demande de replay
+            r"(?:refai[st](?:es)?|refaire|recommence[rz]?|rejoue[rz]?)\s+(?:la\s+)?(?:tâche\s+)?(.+)",
+            # Gestes courants (UI actions) — doivent rester EXECUTE
+            r"(?:ferme[rz]?|ouvr[eir]+[sz]?|clique[rz]?|sélectionne[rz]?|coche[rz]?|décoche[rz]?)\s+(.+)",
+            r"(?:copie[rz]?|colle[rz]?|coupe[rz]?|supprime[rz]?|efface[rz]?)\s+(.+)",
+            r"(?:tape[rz]?|écri[rstv]+[sz]?|saisi[rstv]*[sz]?|rempli[rstv]*[sz]?|entre[rz]?)\s+(.+)",
+            r"(?:scroll(?:e[rz]?)?|défile[rz]?|fait(?:es)?\s+défiler)\s*(.+)?",
+            r"(?:glisse[rz]?|drag(?:ue)?[rz]?|déplace[rz]?|bouge[rz]?)\s+(.+)",
+            r"(?:double[- ]?clique[rz]?|clic\s+droit)\s+(.+)?",
+            r"(?:enregistre[rz]?|sauvegarde[rz]?|save)\s+(.+)?",
+            r"(?:imprime[rz]?|print)\s+(.+)?",
+            r"(?:envoie[rz]?|send|mail(?:e[rz]?)?|transmet[sz]?)\s+(.+)",
+            r"(?:télécharge[rz]?|download|upload)\s+(.+)?",
+            r"(?:actualise[rz]?|rafraîchi[rstv]*[sz]?|refresh|recharge[rz]?)\s*(.+)?",
+            r"(?:valide[rz]?|confirme[rz]?|soumets?|submit)\s+(.+)",
+            r"(?:connecte[rz]?|login|log\s*in|sign\s*in)\s*(.+)?",
+            r"(?:déconnecte[rz]?|logout|log\s*out|sign\s*out)\s*(.+)?",
+            # Raccourcis clavier
+            r"(?:ctrl|alt|shift|maj)\s*\+\s*\w+",
+            # Langage humain — demande d'apprentissage (déclenche l'enregistrement)
+            r"(?:apprends|apprenez)[- ]moi\s+(.+)",
         ],
         IntentType.LIST: [
-            r"(?:liste|montre|affiche|quels sont)\s+(?:les\s+|des\s+)?(?:workflows?|processus|automatisations?)",
-            r"liste\s+des\s+workflows?",
-            r"(?:qu'est-ce que|que)\s+(?:je peux|tu peux)\s+faire",
-            r"(?:workflows?|processus)\s+disponibles?",
-            r"(?:voir|afficher)\s+(?:les\s+|tous\s+les\s+)?workflows?",
+            r"(?:liste|montre|affiche|quels?\s+sont)\s+(?:les\s+|des\s+)?(?:workflows?|tâches?|processus|automatisations?)",
+            r"(?:quels?|quelles?)\s+(?:workflows?|tâches?|processus|automatisations?)",
+            r"liste\s+des\s+(?:workflows?|tâches?)",
+            r"(?:workflows?|tâches?|processus)\s+disponibles?",
+            r"(?:voir|afficher)\s+(?:les\s+|tous\s+les\s+|mes\s+)?(?:workflows?|tâches?)",
+            # Langage humain — demande de liste
+            r"(?:qu'est-ce que\s+(?:tu|vous)\s+sai[st]\s+faire)",
+            r"(?:que\s+sai[st]-(?:tu|vous)\s+faire)",
+            r"mes\s+tâches?",
+        ],
+        # SMALL_TALK doit être AVANT QUERY pour que "qui es-tu" ne soit pas
+        # capturé par le pattern générique "qui + ..." de QUERY
+        IntentType.SMALL_TALK: [
+            # Remerciements
+            r"^(?:merci|thanks?|thx|super|génial|parfait|cool|nickel|impec|impeccable|excellent|formidable)(?:\s.*)?$",
+            # Adieux
+            r"^(?:au revoir|à plus|bye|bonne nuit|à bientôt|à demain|ciao|tchao|tchuss|adieu)(?:\s.*)?$",
+            # Compliments
+            r"^(?:bien joué|bravo|top|chapeau|impressionnant|pas mal|bien fait|beau travail|good job|nice|trop bien|magnifique)(?:\s.*)?$",
+            # Mécontentement
+            r"^(?:c'est nul|nul|pas bien|pas top|pas ouf|bof|mauvais|moche|horrible|catastrophe|c'est pas bon|ça craint|erreur|bug|naze|pourri)(?:\s.*)?$",
+            # Humour / boissons / nourriture / détente
+            r"(?:une? (?:café|coca|thé|chocolat|verre|jus|bière|apéro|croissant|gâteau|bonbon|pause|pizza|glace)|café|coca|thé|chocolat|fais-moi rire|blague|raconte.+blague|drôle|rigol[eo]|mdr|lol|haha|ptdr|xd|😂|🤣|j'ai faim|j'ai soif|pause|il fait (?:chaud|froid|beau)|je suis (?:fatigué|crevé|motivé|content)|la flemme|trop bien|trop cool|vive .+|c'est la vie|oh là là|waouh|wow)",
+            # Identité — qui es-tu ?
+            r"(?:qui es[- ]tu|t'es qui|comment tu t'appelles|c'est quoi ton (?:nom|prénom)|t'es quoi|vous êtes qui|tu es quoi|tu t'appelles comment)",
+            # Sentiments — ça va ?
+            r"(?:ça va|comment (?:ça |tu |vous )?va[st]?|comment allez[- ]vous|tu vas bien|la forme|en forme|et toi|et vous)",
         ],
         IntentType.QUERY: [
-            r"(?:comment|pourquoi|quand|où|qui)\s+(.+)\?",
+            # Questions directes avec mots interrogatifs
+            r"(?:comment|pourquoi|quand|où|qui)\s+(.+)\??",
             r"(?:explique|décris|détaille)\s+(.+)",
             r"(?:qu'est-ce que|c'est quoi)\s+(.+)",
+            # Questions avec "quel/quelle/quels/quelles" (exclure workflows → LIST)
+            r"(?:quels?|quelles?)\s+(?!workflows?|processus|automatisations?)(.+)\??",
+            # "quoi" comme question (pas une commande, pas "quoi faire" = HELP)
+            r"^(?:c'est\s+)?quoi\s+(?!faire)(.+)\??$",
+            r"^quoi\s*\?+$",
+            # Questions indirectes
+            r"(?:dis[- ]moi|raconte|informe[- ]moi)\s+(.+)",
+            r"(?:je\s+(?:me\s+)?demande|je\s+(?:ne\s+)?comprends?\s+pas)\s+(.+)",
         ],
         IntentType.HELP: [
-            r"(?:aide|help|assistance|sos)",
-            r"(?:comment ça marche|comment utiliser)",
+            r"^(?:aide|help|assistance|sos)$",
+            r"comment ça (?:marche|fonctionne)\s*\??",
+            r"comment (?:utiliser|ça s'utilise|on fait)\s*\??",
             r"\?{2,}",
+            # "que peux-tu faire", "quoi faire" = demande d'aide
+            r"(?:qu'est-ce que|que)\s+(?:je peux|tu peux|vous pouvez)\s+faire",
+            r"^quoi\s+faire\s*\??$",
+            r"(?:que\s+)?(?:puis-je|peux-tu|pouvez-vous|peut-on)\s+faire\s*\??",
+            r"(?:besoin\s+d'aide|j'ai\s+besoin\s+d'aide)",
+        ],
+        IntentType.GREETING: [
+            r"^(?:bonjour|bonsoir|salut|hello|hi|hey|coucou|yo|wesh)(?:\s.*)?$",
+            r"^(?:bonne?\s+(?:journée|soirée|nuit|matinée))$",
         ],
         IntentType.STATUS: [
             r"(?:statut|status|état|où en est)",
@@ -102,8 +185,10 @@ class IntentParser:
             r"(?:terminé|fini|done)\s*\?",
         ],
         IntentType.CANCEL: [
-            r"(?:annule|stop|arrête|cancel|abort)",
-            r"(?:laisse tomber|oublie)",
+            r"(?:annule[rz]?|stop|arrête[rz]?|cancel|abort)",
+            r"(?:laisse[rz]?\s+tomber|oublie[rz]?)",
+            # Langage humain — stop courant
+            r"^(?:arrêtez|stoppe[rz]?)$",
         ],
         IntentType.HISTORY: [
             r"(?:historique|history|dernières?\s+commandes?)",
@@ -119,6 +204,35 @@ class IntentParser:
         ],
     }
 
+    # Verbes d'action reconnus pour le fallback EXECUTE
+    # Si aucun pattern ne matche, on vérifie la présence d'un de ces verbes
+    # avant de classifier en EXECUTE
+    ACTION_VERBS = {
+        # Actions de workflow/exécution
+        "lance", "lancer", "exécute", "exécuter", "démarre", "démarrer",
+        "fait", "fais", "run", "start", "execute",
+        # Actions métier
+        "facture", "facturer", "crée", "créer", "génère", "générer",
+        "exporte", "exporter", "importe", "importer",
+        # Actions UI / gestes
+        "ferme", "fermer", "ouvre", "ouvrir", "clique", "cliquer",
+        "sélectionne", "sélectionner", "coche", "cocher", "décoche", "décocher",
+        "copie", "copier", "colle", "coller", "coupe", "couper",
+        "supprime", "supprimer", "efface", "effacer",
+        "tape", "taper", "écris", "écrire", "saisis", "saisir",
+        "remplis", "remplir", "entre", "entrer",
+        "scroll", "scroller", "défile", "défiler",
+        "glisse", "glisser", "déplace", "déplacer", "drag",
+        "enregistre", "enregistrer", "sauvegarde", "sauvegarder", "save",
+        "imprime", "imprimer", "print",
+        "envoie", "envoyer", "send", "transmet", "transmettre",
+        "télécharge", "télécharger", "download", "upload",
+        "actualise", "actualiser", "rafraîchis", "rafraîchir", "refresh",
+        "valide", "valider", "confirme", "confirmer", "soumets", "soumettre",
+        "connecte", "connecter", "déconnecte", "déconnecter",
+        "login", "logout",
+    }
+
     # Patterns pour l'extraction d'entités
     ENTITY_PATTERNS = {
         "client": [
@@ -139,13 +253,36 @@ class IntentParser:
             r"de\s+([A-Za-z])\s+à\s+([A-Za-z])",
             r"(\d+)\s*(?:-|à|to)\s*(\d+)",
         ],
+        "expression": [
+            # Expressions mathématiques : 5+2, 100*3, 12/4, 7-3, 2.5+3.1
+            r"(\d+(?:[.,]\d+)?\s*[+\-*/x×÷]\s*\d+(?:[.,]\d+)?)",
+        ],
+        "file_path": [
+            # Chemins Windows : C:\data\fichier.xlsx
+            r"([A-Za-z]:\\[^\s,]+\.(?:xlsx?|csv))",
+            # Chemins Unix : /data/fichier.xlsx
+            r"(/[^\s,]+\.(?:xlsx?|csv))",
+            # Noms de fichier simples : patients.xlsx
+            r"(?:^|\s)([\w\-\.]+\.(?:xlsx?|csv))(?:\s|$)",
+        ],
+        "folder_path": [
+            # Dossiers Windows : C:\data\imports
+            r"(?:dossier|répertoire|dir|directory)\s+([A-Za-z]:\\[^\s,]+)",
+            r"([A-Za-z]:\\[^\s,]+)(?:\s|$)",
+            # Dossiers Unix : /data/imports
+            r"(?:dossier|répertoire|dir|directory)\s+(/[^\s,]+)",
+        ],
+        "table_name": [
+            # Noms de table (exclure les mots courants comme "à", "de", "la")
+            r"(?:table|la\s+table)\s+['\"]?(\w{2,})['\"]?",
+        ],
     }
 
     def __init__(
         self,
         use_llm: bool = False,
         llm_endpoint: str = "http://localhost:11434",
-        llm_model: str = "qwen2.5:7b"
+        llm_model: Optional[str] = None
     ):
         """
         Initialiser le parseur d'intentions.
@@ -157,7 +294,7 @@ class IntentParser:
         """
         self.use_llm = use_llm
         self.llm_endpoint = llm_endpoint
-        self.llm_model = llm_model
+        self.llm_model = llm_model or get_reasoning_model()
         self.llm_available = False
         self._workflows_cache: List[Dict[str, Any]] = []
 
@@ -223,6 +360,10 @@ class IntentParser:
         # 4. Construire les paramètres depuis les entités
         parameters = self._entities_to_parameters(entities)
 
+        # 4b. Enrichir les paramètres DATA_IMPORT avec l'action et le chemin
+        if intent_type == IntentType.DATA_IMPORT:
+            parameters = self._enrich_data_import_params(normalized, query, parameters, entities)
+
         # 5. Si le LLM est disponible et la confiance est basse, utiliser le LLM
         if self.use_llm and self.llm_available and rule_confidence < 0.7:
             llm_result = self._parse_with_llm(query, context)
@@ -245,13 +386,89 @@ class IntentParser:
             clarification_question=clarification_question
         )
 
+    def _enrich_data_import_params(
+        self,
+        normalized: str,
+        raw_query: str,
+        parameters: Dict[str, Any],
+        entities: List[Dict[str, Any]],
+    ) -> Dict[str, Any]:
+        """Enrichir les paramètres pour une intention DATA_IMPORT.
+
+        Détermine l'action (import_file, import_folder, list_tables, table_info)
+        et extrait le chemin de fichier / nom de table.
+        """
+        # Déterminer l'action
+        list_patterns = [
+            r"(?:montre|liste|affiche|voir)\s*(?:-moi\s+)?(?:les\s+)?tables?",
+            r"(?:quelles?\s+)?tables?\s+(?:sont\s+)?(?:disponibles?|dans)",
+            r"liste\s+(?:des?\s+)?tables?",
+        ]
+        info_patterns = [
+            r"combien\s+de\s+lignes?",
+            r"(?:info|détails?|describe?|colonnes?|structure)\s+(?:de\s+)?(?:la\s+)?table",
+        ]
+        folder_patterns = [
+            r"(?:feuilles?\s+excel|fichiers?\s+excel)\s+(?:du|de)\s+(?:dossier|répertoire)",
+            r"(?:importe|charge|lis)\s+(?:les\s+)?(?:feuilles?\s+)?excel\s+(?:du\s+dossier|de\s+)",
+        ]
+
+        action = "import_file"  # Par défaut
+
+        for pat in list_patterns:
+            if re.search(pat, normalized, re.IGNORECASE):
+                action = "list_tables"
+                break
+
+        if action == "import_file":
+            for pat in info_patterns:
+                if re.search(pat, normalized, re.IGNORECASE):
+                    action = "table_info"
+                    break
+
+        if action == "import_file":
+            for pat in folder_patterns:
+                if re.search(pat, normalized, re.IGNORECASE):
+                    action = "import_folder"
+                    break
+
+        parameters["action"] = action
+
+        # Extraire le chemin de fichier depuis les entités
+        for entity in entities:
+            if entity["type"] == "file_path" and "file_path" not in parameters:
+                parameters["file_path"] = entity["value"]
+            elif entity["type"] == "folder_path" and "folder_path" not in parameters:
+                parameters["folder_path"] = entity["value"]
+            elif entity["type"] == "table_name" and "table_name" not in parameters:
+                parameters["table_name"] = entity["value"]
+
+        # Fallback : extraire un chemin de fichier depuis la requête brute
+        if "file_path" not in parameters and action == "import_file":
+            # Chercher un .xlsx/.xls/.csv dans la requête brute (supporte les chemins Windows)
+            fp_match = re.search(
+                r'([A-Za-z]:\\[^\s,]+\.(?:xlsx?|csv)|/[^\s,]+\.(?:xlsx?|csv)|[\w\-\.]+\.(?:xlsx?|csv))',
+                raw_query,
+                re.IGNORECASE,
+            )
+            if fp_match:
+                parameters["file_path"] = fp_match.group(1)
+
+        # Extraire table_name pour table_info depuis la requête
+        if action == "table_info" and "table_name" not in parameters:
+            tm = re.search(r"table\s+['\"]?(\w+)['\"]?", normalized, re.IGNORECASE)
+            if tm:
+                parameters["table_name"] = tm.group(1)
+
+        return parameters
+
     def _normalize_query(self, query: str) -> str:
         """Normaliser une requête pour le matching."""
         # Convertir en minuscules
         normalized = query.lower()
 
-        # Supprimer la ponctuation excessive
-        normalized = re.sub(r'[!.]+$', '', normalized)
+        # Supprimer la ponctuation finale
+        normalized = re.sub(r'[!.?]+$', '', normalized)
 
         # Normaliser les espaces
         normalized = re.sub(r'\s+', ' ', normalized).strip()
@@ -276,11 +493,18 @@ class IntentParser:
                         best_confidence = confidence
                         best_intent = intent_type
 
-        # Si aucune intention trouvée mais la requête ressemble à une commande
+        # Fallback durci : ne classifier en EXECUTE que si un verbe d'action est présent
         if best_intent == IntentType.UNKNOWN and len(query.split()) >= 2:
-            # Supposer que c'est une demande d'exécution
-            best_intent = IntentType.EXECUTE
-            best_confidence = 0.4
+            words = query.lower().split()
+            # Vérifier si au moins un mot est un verbe d'action connu
+            has_action_verb = any(word in self.ACTION_VERBS for word in words)
+            if has_action_verb:
+                best_intent = IntentType.EXECUTE
+                best_confidence = 0.40
+            else:
+                # Pas de verbe d'action reconnu → demander clarification
+                best_intent = IntentType.CLARIFY
+                best_confidence = 0.30
 
         return best_intent, best_confidence
 
@@ -357,9 +581,9 @@ class IntentParser:
         """Vérifier si une clarification est nécessaire."""
 
         if intent_type == IntentType.EXECUTE:
-            # Si pas de hint de workflow, demander clarification
+            # Si pas de hint de tâche, demander clarification
             if not workflow_hint:
-                return True, "Quel workflow souhaitez-vous exécuter ?"
+                return True, "Quelle tâche souhaitez-vous lancer ?"
 
             # Si le hint est trop vague
             if len(workflow_hint.split()) <= 1:
@@ -378,22 +602,24 @@ class IntentParser:
                 workflow_names = [w.get("name", "") for w in self._workflows_cache[:15]]
                 workflows_context = f"\nWorkflows disponibles: {', '.join(workflow_names)}"
 
-            prompt = f"""Tu es un assistant RPA. Analyse cette requête utilisateur.
+            prompt = f"""Tu es Léa, une assistante chaleureuse. Analyse cette requête utilisateur.
 
 REQUÊTE: "{query}"
 {workflows_context}
 {f"Contexte conversation: {json.dumps(context, ensure_ascii=False)}" if context else ""}
 
 INTENTIONS POSSIBLES:
-- execute: l'utilisateur veut lancer/exécuter un workflow
-- list: l'utilisateur veut voir les workflows disponibles (mots-clés: liste, quels, workflows, disponibles, montrer)
-- query: l'utilisateur pose une question sur un workflow
+- execute: l'utilisateur veut lancer/refaire une tâche ou une action UI (geste). Inclut "apprends-moi", "refais la tâche", "lance"
+- list: l'utilisateur veut voir les tâches disponibles (mots-clés: liste, quels, tâches, qu'est-ce que tu sais faire, mes tâches)
+- query: l'utilisateur pose une question (comment, pourquoi, c'est quoi, quel)
 - status: l'utilisateur demande le statut d'exécution
-- cancel: l'utilisateur veut annuler
+- cancel: l'utilisateur veut arrêter/annuler (arrête, stop, annule)
 - history: l'utilisateur veut voir l'historique
-- help: l'utilisateur demande de l'aide
+- help: l'utilisateur demande de l'aide ou ce qu'il peut faire
+- greeting: l'utilisateur dit bonjour/salut/hello
 - confirm: l'utilisateur confirme (oui, ok, go)
 - deny: l'utilisateur refuse (non, annule)
+- small_talk: conversation informelle (merci, café, ça va, qui es-tu, bravo, c'est nul)
 - unknown: impossible à déterminer
 
 Réponds UNIQUEMENT en JSON valide (pas de texte avant/après):
@@ -463,7 +689,7 @@ _intent_parser: Optional[IntentParser] = None
 
 def get_intent_parser(
     use_llm: bool = False,
-    llm_model: str = "qwen2.5:7b",
+    llm_model: Optional[str] = None,
     llm_endpoint: str = "http://localhost:11434"
 ) -> IntentParser:
     """
@@ -471,20 +697,21 @@ def get_intent_parser(
 
     Args:
         use_llm: Activer le LLM (Ollama)
-        llm_model: Modèle à utiliser (qwen2.5:7b par défaut)
+        llm_model: Modèle à utiliser (défaut: modèle reasoning central)
         llm_endpoint: URL de l'endpoint Ollama
     """
     global _intent_parser
+    resolved_model = llm_model or get_reasoning_model()
     if _intent_parser is None:
         _intent_parser = IntentParser(
             use_llm=use_llm,
             llm_endpoint=llm_endpoint,
-            llm_model=llm_model
+            llm_model=resolved_model
         )
     elif use_llm and not _intent_parser.use_llm:
         # Réactiver le LLM si demandé
         _intent_parser.use_llm = True
-        _intent_parser.llm_model = llm_model
+        _intent_parser.llm_model = resolved_model
         _intent_parser._check_llm_availability()
     return _intent_parser
 
@@ -500,16 +727,46 @@ if __name__ == "__main__":
     parser = IntentParser(use_llm=False)
 
     test_queries = [
+        # EXECUTE — actions explicites
         "facturer le client Acme",
         "lance le workflow de facturation",
-        "quels workflows sont disponibles ?",
-        "aide",
-        "oui",
-        "annule",
-        "statut",
         "exporter le rapport en PDF pour Client ABC",
         "créer une facture de 1500€ pour Société XYZ",
         "facturer les clients de A à Z",
+        # EXECUTE — gestes UI
+        "ferme la fenêtre",
+        "ouvre un nouvel onglet",
+        "copier le texte",
+        "lance la facturation",
+        # LIST
+        "quels workflows sont disponibles ?",
+        "liste des workflows",
+        # QUERY — questions
+        "comment ça marche ?",
+        "c'est quoi ce workflow",
+        "pourquoi ce processus est lent ?",
+        # HELP
+        "aide",
+        "quoi faire ?",
+        "que peux-tu faire ?",
+        # GREETING
+        "bonjour",
+        "salut",
+        # Confirmations / annulations
+        "oui",
+        "annule",
+        "statut",
+        # SMALL_TALK — conversation informelle
+        "merci",
+        "un café",
+        "ça va ?",
+        "qui es-tu ?",
+        "c'est nul",
+        "bravo",
+        "au revoir",
+        "t'es qui",
+        # Fallback — ne doit PAS être EXECUTE
+        "blah blah test",
     ]
 
     print("=== Tests IntentParser ===\n")

agent_chat/response_generator.py

@@ -14,6 +14,7 @@ Auteur: Dom - Janvier 2026
 
 import logging
 import random
+import re
 from dataclasses import dataclass
 from enum import Enum
 from typing import Dict, Any, List, Optional
@@ -60,32 +61,40 @@ class ResponseGenerator:
     """
 
     # Templates de réponses par type d'intention
+    # Ton : collègue chaleureuse et professionnelle, vouvoiement
     RESPONSE_TEMPLATES = {
         IntentType.EXECUTE: {
             "success": [
-                "J'ai lancé le workflow '{workflow}'. {details}",
-                "Le workflow '{workflow}' est en cours d'exécution. {details}",
-                "C'est parti pour '{workflow}' ! {details}"
+                "C'est parti, je lance '{workflow}'. {details}",
+                "Je m'occupe de '{workflow}'. {details}",
+                "'{workflow}' est en cours ! {details}"
             ],
             "error": [
-                "Impossible d'exécuter '{workflow}': {error}",
-                "Erreur lors du lancement de '{workflow}': {error}",
-                "Le workflow '{workflow}' a échoué: {error}"
+                "Hmm, je n'ai pas réussi à faire '{workflow}' : {error}",
+                "Désolée, '{workflow}' a rencontré un souci : {error}",
+                "Oups, '{workflow}' n'a pas fonctionné : {error}"
             ],
             "not_found": [
-                "Je n'ai pas trouvé de workflow correspondant à '{query}'.",
-                "Aucun workflow ne correspond à '{query}'. Voulez-vous voir la liste ?",
-                "'{query}' ne correspond à aucun workflow connu."
+                "Je ne connais pas encore '{query}'. Montrez-moi comment faire et je l'apprendrai !",
+                "'{query}' m'est inconnu pour l'instant. Vous pouvez me montrer en cliquant sur « Apprenez-moi ».",
+                "Je ne sais pas encore faire '{query}'. Montrez-moi et je m'en souviendrai !"
+            ],
+            "gesture": [
+                "{gesture_name} ({gesture_keys}) envoyé !",
+                "Raccourci {gesture_name} ({gesture_keys}) exécuté.",
+            ],
+            "copilot": [
+                "Mode pas-à-pas activé pour '{workflow}'. Je vous demande de valider chaque étape.",
             ]
         },
         IntentType.LIST: {
             "success": [
-                "Voici les workflows disponibles :\n{list}",
-                "J'ai trouvé {count} workflows :\n{list}",
+                "Voici les tâches que je sais faire :\n{list}",
+                "J'ai {count} tâches en mémoire :\n{list}",
             ],
             "empty": [
-                "Aucun workflow n'est configuré pour le moment.",
-                "La liste des workflows est vide."
+                "Je n'ai encore appris aucune tâche. Montrez-moi quelque chose !",
+                "Ma liste est vide pour le moment. Apprenez-moi une première tâche !"
             ]
         },
         IntentType.QUERY: {
@@ -94,70 +103,78 @@ class ResponseGenerator:
                 "À propos de '{topic}' :\n{answer}"
             ],
             "not_found": [
-                "Je n'ai pas d'information sur '{topic}'.",
-                "Je ne peux pas répondre à cette question sur '{topic}'."
+                "Je n'ai pas d'information sur '{topic}'. Pouvez-vous préciser ?",
+                "Désolée, je ne peux pas vous répondre sur '{topic}'."
             ]
         },
         IntentType.HELP: {
             "general": [
-                "Je suis votre assistant RPA. Voici ce que je peux faire :\n\n"
-                "• Exécuter des workflows : \"lance facturation client Acme\"\n"
-                "• Lister les workflows : \"quels workflows sont disponibles ?\"\n"
-                "• Voir le statut : \"où en est l'exécution ?\"\n"
-                "• Annuler : \"annule\"\n\n"
-                "Tapez votre commande en langage naturel !",
+                "Je suis Léa, votre assistante. Voici ce que je peux faire :\n\n"
+                "• Apprendre une tâche : cliquez sur « Apprenez-moi »\n"
+                "• Refaire une tâche : \"lance facturation\" ou cliquez sur « Lancer »\n"
+                "• Voir mes tâches : \"qu'est-ce que tu sais faire ?\"\n"
+                "• Importer des données : \"importe le fichier Excel\"\n"
+                "• Arrêter : \"arrête\"\n\n"
+                "Parlez-moi naturellement, je fais de mon mieux pour comprendre !",
+            ]
+        },
+        IntentType.GREETING: {
+            "default": [
+                "Bonjour ! Je suis Léa. Que puis-je faire pour vous ?",
+                "Bonjour ! Comment puis-je vous aider aujourd'hui ?",
+                "Bonjour ! Dites-moi ce dont vous avez besoin, ou tapez « aide ».",
             ]
         },
         IntentType.STATUS: {
             "running": [
-                "Exécution en cours : '{workflow}'\nProgression : {progress}%\n{message}",
-                "Le workflow '{workflow}' s'exécute ({progress}%): {message}"
+                "Je suis en train de faire '{workflow}' — progression : {progress}%\n{message}",
+                "'{workflow}' est en cours ({progress}%) : {message}"
             ],
             "idle": [
-                "Aucune exécution en cours. Système prêt.",
-                "Tout est calme. Que puis-je faire pour vous ?"
+                "Tout est calme, je suis disponible. Que puis-je faire pour vous ?",
+                "Rien en cours. Je suis prête !"
             ],
             "completed": [
-                "Dernière exécution : '{workflow}' - {status}",
+                "La dernière tâche '{workflow}' est terminée : {status}",
                 "'{workflow}' est terminé : {status}"
             ]
         },
         IntentType.CANCEL: {
             "success": [
-                "Exécution annulée.",
-                "J'ai arrêté le workflow en cours.",
-                "Annulation effectuée."
+                "C'est arrêté.",
+                "J'ai tout arrêté.",
+                "Annulation faite."
             ],
             "nothing": [
-                "Rien à annuler, aucune exécution en cours.",
-                "Il n'y a pas d'exécution active."
+                "Il n'y a rien en cours à arrêter.",
+                "Rien à annuler, je suis disponible."
             ]
         },
         IntentType.HISTORY: {
             "success": [
-                "Voici vos dernières commandes :\n{history}",
+                "Voici vos dernières actions :\n{history}",
                 "Historique récent :\n{history}"
             ],
             "empty": [
                 "Pas encore d'historique.",
-                "Vous n'avez pas encore exécuté de commandes."
+                "Vous n'avez encore rien fait avec moi."
             ]
         },
         IntentType.CONFIRM: {
             "accepted": [
-                "Très bien, j'exécute '{workflow}'.",
+                "Très bien, je m'en occupe : '{workflow}'.",
                 "C'est parti pour '{workflow}' !",
-                "Confirmé. Lancement de '{workflow}'."
+                "Entendu. Je lance '{workflow}'."
             ],
             "no_pending": [
-                "Il n'y a rien à confirmer.",
-                "Aucune action en attente de confirmation."
+                "Il n'y a rien à confirmer pour le moment.",
+                "Aucune action en attente."
             ]
         },
         IntentType.DENY: {
             "cancelled": [
-                "Action annulée.",
-                "D'accord, j'annule.",
+                "D'accord, c'est annulé.",
+                "Entendu, j'annule.",
                 "Compris, on oublie."
             ]
         },
@@ -166,11 +183,91 @@ class ResponseGenerator:
                 "{question}",
             ]
         },
+        IntentType.DATA_IMPORT: {
+            "preview": [
+                "J'ai trouvé le fichier **{filename}** — {total_rows} lignes, colonnes : {columns}. Je l'importe dans la table '{table_name}' ?",
+                "Fichier **{filename}** prêt : {total_rows} lignes avec les colonnes {columns}. On crée la table '{table_name}' ?",
+            ],
+            "imported": [
+                "Table **'{table_name}'** créée avec {row_count} lignes et {col_count} colonnes ({columns}). Vous pouvez maintenant l'utiliser dans une tâche !",
+                "Import réussi ! Table **'{table_name}'** : {row_count} lignes, {col_count} colonnes ({columns}).",
+            ],
+            "list_tables": [
+                "Voici vos tables de données :\n{tables_list}",
+                "Tables disponibles :\n{tables_list}",
+            ],
+            "no_tables": [
+                "Vous n'avez pas encore de données importées. Envoyez-moi un fichier Excel pour commencer !",
+                "La base est vide. Importez un fichier Excel pour créer votre première table.",
+            ],
+            "table_info": [
+                "La table **'{table_name}'** contient {row_count} lignes et {col_count} colonnes :\n{columns_detail}",
+            ],
+            "folder_list": [
+                "J'ai trouvé {count} fichiers Excel dans le dossier :\n{files_list}\n\nDites-moi lequel importer !",
+            ],
+            "folder_empty": [
+                "Je n'ai trouvé aucun fichier Excel dans '{folder}'. Vérifiez le chemin.",
+            ],
+            "file_not_found": [
+                "Je n'ai pas trouvé le fichier '{file_path}'. Vérifiez le chemin ou envoyez-le directement.",
+                "Fichier introuvable : '{file_path}'. Vous pouvez aussi glisser un fichier dans le chat.",
+            ],
+            "error": [
+                "Désolée, l'import a échoué : {error}",
+                "Oups, un souci lors de l'import : {error}",
+            ],
+            "uploaded": [
+                "Fichier **{filename}** reçu ! Je l'analyse...",
+            ],
+        },
+        IntentType.SMALL_TALK: {
+            "thanks": [
+                "Avec plaisir ! N'hésitez pas si vous avez besoin d'autre chose 😊",
+                "De rien ! Je suis là pour ça 👍",
+                "Merci à vous ! Toujours prête à aider.",
+            ],
+            "farewell": [
+                "À bientôt ! Je reste dans la barre des tâches si vous avez besoin 😊",
+                "Bonne continuation ! N'hésitez pas à revenir.",
+                "À plus tard ! Je ne bouge pas 👋",
+            ],
+            "compliment": [
+                "Merci, c'est gentil ! J'apprends un peu plus chaque jour grâce à vous 😊",
+                "Oh merci ! Ça me fait plaisir 😄",
+                "C'est vous qui êtes formidable ! Merci pour votre confiance.",
+            ],
+            "complaint": [
+                "Je suis désolée... Dites-moi ce qui ne va pas, je vais essayer de m'améliorer.",
+                "Oups... N'hésitez pas à me dire ce qui n'a pas marché, je ferai mieux la prochaine fois.",
+                "Pardon pour le désagrément. Comment puis-je corriger ça ?",
+            ],
+            "humor": [
+                "Pas encore de machine à café intégrée... mais j'y travaille ! 😄",
+                "Ha ha ! Si seulement je pouvais... 😄 Dites-moi plutôt comment vous aider !",
+                "Bonne idée ! Malheureusement je ne sais pas encore faire ça 😊 Mais pour vos tâches informatiques, je suis là !",
+            ],
+            "mood": [
+                "Je comprends ! Prenez une pause, je m'occupe du reste 😊",
+                "Courage ! Si vous avez des tâches ennuyeuses, confiez-les moi pendant votre pause.",
+                "On fait tous des pauses ! Je reste là si vous avez besoin 👍",
+            ],
+            "identity": [
+                "Je suis Léa, votre assistante ! Je peux apprendre vos tâches répétitives et les refaire à votre place 😊",
+                "Moi c'est Léa ! Je suis là pour automatiser tout ce qui vous ennuie au quotidien.",
+                "Je m'appelle Léa. Mon job : observer, apprendre, et vous faire gagner du temps 👍",
+            ],
+            "feelings": [
+                "Très bien, merci de demander ! Et vous ? Prête à travailler si vous avez besoin 😊",
+                "En pleine forme ! Et vous, comment ça va ? Dites-moi si je peux aider.",
+                "Ça va super bien ! Toujours motivée pour vous donner un coup de main 💪",
+            ],
+        },
         IntentType.UNKNOWN: {
             "default": [
-                "Je n'ai pas compris. Pouvez-vous reformuler ?",
-                "Désolé, je ne comprends pas '{query}'. Tapez 'aide' pour voir les commandes.",
-                "'{query}' ? Je ne suis pas sûr de comprendre."
+                "Je n'ai pas bien compris. Vous pouvez me demander de l'aide avec le bouton ❓",
+                "Désolée, je ne comprends pas. Tapez « aide » pour voir ce que je sais faire.",
+                "Hmm, je n'ai pas saisi votre demande. Essayez de reformuler ou tapez « aide »."
             ]
         }
     }
@@ -179,21 +276,30 @@ class ResponseGenerator:
     CONTEXTUAL_SUGGESTIONS = {
         "after_execute": [
             "voir le statut",
-            "annuler",
-            "liste des workflows"
+            "arrêter",
+            "mes tâches"
         ],
         "after_error": [
             "aide",
-            "liste des workflows",
+            "mes tâches",
             "réessayer"
         ],
         "after_list": [
-            "exécuter un workflow",
+            "lancer une tâche",
             "aide"
         ],
         "idle": [
-            "facturer client X",
-            "liste des workflows",
+            "qu'est-ce que tu sais faire ?",
+            "apprenez-moi",
+            "aide"
+        ],
+        "after_import": [
+            "montre les tables",
+            "importer un autre fichier",
+            "aide"
+        ],
+        "after_table_list": [
+            "importer un fichier Excel",
             "aide"
         ]
     }
@@ -273,7 +379,7 @@ class ResponseGenerator:
         Générer un message de progression.
 
         Args:
-            workflow_name: Nom du workflow
+            workflow_name: Nom de la tâche
             progress: Pourcentage de progression
             step: Étape actuelle
             current: Numéro de l'étape
@@ -287,11 +393,11 @@ class ResponseGenerator:
         filled = int(bar_length * progress / 100)
         bar = "█" * filled + "░" * (bar_length - filled)
 
-        message = f"**{workflow_name}** [{bar}] {progress}%\n\nÉtape {current}/{total}: {step}"
+        message = f"**{workflow_name}** [{bar}] {progress}%\n\nÉtape {current}/{total} : {step}"
 
         return GeneratedResponse(
             message=message,
-            suggestions=["annuler"] if progress < 100 else [],
+            suggestions=["arrêter"] if progress < 100 else [],
             action_required=False,
             metadata={
                 "workflow": workflow_name,
@@ -311,7 +417,7 @@ class ResponseGenerator:
         Générer un message de résultat d'exécution.
 
         Args:
-            workflow_name: Nom du workflow
+            workflow_name: Nom de la tâche
             success: Succès ou échec
             message: Message détaillé
             duration: Durée d'exécution en secondes
@@ -320,18 +426,14 @@ class ResponseGenerator:
             GeneratedResponse avec le résultat
         """
         if success:
-            emoji = "✅"
-            status = "terminé avec succès"
+            response_message = f"C'est fait ! **{workflow_name}** s'est bien passé.\n\n{message}"
             suggestions = self.CONTEXTUAL_SUGGESTIONS["idle"]
         else:
-            emoji = "❌"
-            status = "échoué"
+            response_message = f"Hmm, **{workflow_name}** n'a pas fonctionné.\n\n{message}"
             suggestions = self.CONTEXTUAL_SUGGESTIONS["after_error"]
 
-        response_message = f"{emoji} **{workflow_name}** {status}\n\n{message}"
-
         if duration:
-            response_message += f"\n\nDurée: {duration:.1f}s"
+            response_message += f"\n\nDurée : {duration:.1f}s"
 
         return GeneratedResponse(
             message=response_message,
@@ -355,7 +457,21 @@ class ResponseGenerator:
         """Handler pour les intentions d'exécution."""
         templates = self.RESPONSE_TEMPLATES[IntentType.EXECUTE]
 
-        if result.get("success"):
+        if result.get("gesture"):
+            # Geste primitif (raccourci clavier)
+            template = random.choice(templates["gesture"])
+            message = template.format(
+                gesture_name=result.get("gesture_name", "?"),
+                gesture_keys=result.get("gesture_keys", "?"),
+            )
+            suggestions = self.CONTEXTUAL_SUGGESTIONS["after_execute"]
+
+        elif result.get("mode") == "copilot":
+            template = random.choice(templates["copilot"])
+            message = template.format(workflow=result.get("workflow", "?"))
+            suggestions = ["approuver", "passer", "annuler"]
+
+        elif result.get("success"):
             template = random.choice(templates["success"])
             workflow = result.get("workflow", intent.workflow_hint or "inconnu")
             details = ""
@@ -369,8 +485,9 @@ class ResponseGenerator:
 
         elif result.get("not_found"):
             template = random.choice(templates["not_found"])
-            message = template.format(query=intent.raw_query)
-            suggestions = self.CONTEXTUAL_SUGGESTIONS["after_error"]
+            query = result.get("query", intent.raw_query)
+            message = template.format(query=query)
+            suggestions = ["mes tâches", "aide", "apprenez-moi"]
 
         else:
             template = random.choice(templates["error"])
@@ -426,6 +543,22 @@ class ResponseGenerator:
             action_required=False
         )
 
+    def _handle_greeting(
+        self,
+        intent: ParsedIntent,
+        context: Dict[str, Any],
+        result: Dict[str, Any]
+    ) -> GeneratedResponse:
+        """Handler pour les salutations."""
+        templates = self.RESPONSE_TEMPLATES[IntentType.GREETING]
+        message = random.choice(templates["default"])
+
+        return GeneratedResponse(
+            message=message,
+            suggestions=self.CONTEXTUAL_SUGGESTIONS["idle"],
+            action_required=False
+        )
+
     def _handle_status(
         self,
         intent: ParsedIntent,
@@ -578,6 +711,187 @@ class ResponseGenerator:
             action_required=False
         )
 
+    def _handle_data_import(
+        self,
+        intent: ParsedIntent,
+        context: Dict[str, Any],
+        result: Dict[str, Any]
+    ) -> GeneratedResponse:
+        """Handler pour les imports de données (Excel/CSV)."""
+        templates = self.RESPONSE_TEMPLATES[IntentType.DATA_IMPORT]
+
+        if result.get("file_not_found"):
+            template = random.choice(templates["file_not_found"])
+            message = template.format(file_path=result.get("file_path", "?"))
+            suggestions = ["aide"]
+
+        elif result.get("preview"):
+            # Aperçu avant import
+            template = random.choice(templates["preview"])
+            preview = result["preview"]
+            cols_str = ", ".join(preview.get("columns", [])[:8])
+            if len(preview.get("columns", [])) > 8:
+                cols_str += f"... (+{len(preview['columns']) - 8})"
+            message = template.format(
+                filename=result.get("filename", "?"),
+                total_rows=preview.get("total_rows", 0),
+                columns=cols_str,
+                table_name=result.get("table_name", "?"),
+            )
+            suggestions = ["oui", "non"]
+
+        elif result.get("imported"):
+            # Import réussi
+            template = random.choice(templates["imported"])
+            imp = result["imported"]
+            cols_str = ", ".join(list(imp.get("columns", {}).keys())[:6])
+            if len(imp.get("columns", {})) > 6:
+                cols_str += "..."
+            message = template.format(
+                table_name=imp.get("table_name", "?"),
+                row_count=imp.get("row_count", 0),
+                col_count=imp.get("column_count", 0),
+                columns=cols_str,
+            )
+            suggestions = self.CONTEXTUAL_SUGGESTIONS["after_import"]
+
+        elif result.get("tables_list") is not None:
+            tables = result["tables_list"]
+            if tables:
+                lines = []
+                for t in tables:
+                    lines.append(f"  **{t['name']}** ({t['row_count']} lignes)")
+                template = random.choice(templates["list_tables"])
+                message = template.format(tables_list="\n".join(lines))
+                suggestions = self.CONTEXTUAL_SUGGESTIONS["after_table_list"]
+            else:
+                message = random.choice(templates["no_tables"])
+                suggestions = ["importer un fichier Excel"]
+
+        elif result.get("table_info"):
+            info = result["table_info"]
+            cols_detail = "\n".join(
+                f"  {c['name']} ({c['type']})" for c in info.get("columns", [])
+                if c["name"] not in ("_rowid", "_imported_at")
+            )
+            template = random.choice(templates["table_info"])
+            message = template.format(
+                table_name=info.get("table_name", "?"),
+                row_count=info.get("row_count", 0),
+                col_count=len([c for c in info.get("columns", []) if c["name"] not in ("_rowid", "_imported_at")]),
+                columns_detail=cols_detail,
+            )
+            suggestions = self.CONTEXTUAL_SUGGESTIONS["after_table_list"]
+
+        elif result.get("folder_files") is not None:
+            files = result["folder_files"]
+            if files:
+                files_list = "\n".join(f"  {f}" for f in files)
+                template = random.choice(templates["folder_list"])
+                message = template.format(count=len(files), files_list=files_list)
+            else:
+                template = random.choice(templates["folder_empty"])
+                message = template.format(folder=result.get("folder", "?"))
+            suggestions = ["aide"]
+
+        elif result.get("uploaded"):
+            template = random.choice(templates["uploaded"])
+            message = template.format(filename=result.get("filename", "?"))
+            suggestions = []
+
+        elif result.get("error"):
+            template = random.choice(templates["error"])
+            message = template.format(error=result["error"])
+            suggestions = self.CONTEXTUAL_SUGGESTIONS["after_error"]
+
+        else:
+            message = "Je n'ai pas compris votre demande. Précisez le fichier ou dites « montre les tables »."
+            suggestions = ["montre les tables", "aide"]
+
+        return GeneratedResponse(
+            message=message,
+            suggestions=suggestions,
+            action_required=result.get("needs_confirmation", False),
+            action_type="data_import_confirm" if result.get("needs_confirmation") else None,
+            metadata=result,
+        )
+
+    def _handle_small_talk(
+        self,
+        intent: ParsedIntent,
+        context: Dict[str, Any],
+        result: Dict[str, Any]
+    ) -> GeneratedResponse:
+        """Handler pour la conversation informelle (merci, café, ça va, etc.)."""
+        templates = self.RESPONSE_TEMPLATES[IntentType.SMALL_TALK]
+        query = intent.raw_query.lower().strip()
+
+        # Déterminer la sous-catégorie de small talk
+        category = self._classify_small_talk(query)
+        category_templates = templates.get(category, templates["humor"])
+        message = random.choice(category_templates)
+
+        return GeneratedResponse(
+            message=message,
+            suggestions=[],
+            action_required=False,
+        )
+
+    @staticmethod
+    def _classify_small_talk(query: str) -> str:
+        """Classifier le type de small talk à partir de la requête brute."""
+        # Remerciements
+        if re.search(
+            r"\b(?:merci|thanks?|thx|super|génial|parfait|cool|nickel|impec|impeccable|excellent|formidable)\b",
+            query
+        ):
+            return "thanks"
+
+        # Adieux
+        if re.search(
+            r"\b(?:au revoir|à plus|bye|bonne nuit|à bientôt|à demain|ciao|tchao|tchuss|adieu)\b",
+            query
+        ):
+            return "farewell"
+
+        # Identité
+        if re.search(
+            r"(?:qui es[- ]tu|t'es qui|comment tu t'appelles|c'est quoi ton (?:nom|prénom)|t'es quoi|vous êtes qui|tu t'appelles comment)",
+            query
+        ):
+            return "identity"
+
+        # Sentiments
+        if re.search(
+            r"(?:ça va|comment (?:ça |tu |vous )?va[st]?|comment allez[- ]vous|tu vas bien|la forme|en forme)",
+            query
+        ):
+            return "feelings"
+
+        # Mécontentement
+        if re.search(
+            r"\b(?:nul|pas bien|pas top|pas ouf|bof|mauvais|moche|horrible|catastrophe|ça craint|erreur|bug|naze|pourri)\b",
+            query
+        ):
+            return "complaint"
+
+        # Compliments
+        if re.search(
+            r"\b(?:bien joué|bravo|top|chapeau|impressionnant|pas mal|bien fait|beau travail|good job|nice|trop bien|magnifique)\b",
+            query
+        ):
+            return "compliment"
+
+        # Fatigue / état physique
+        if re.search(
+            r"(?:fatigué|crevé|la flemme|j'ai faim|j'ai soif|pause|il fait (?:chaud|froid|beau)|je suis (?:motivé|content))",
+            query
+        ):
+            return "mood"
+
+        # Humour / boissons / café (fallback small_talk)
+        return "humor"
+
     def _handle_unknown(
         self,
         intent: ParsedIntent,
@@ -591,7 +905,7 @@ class ResponseGenerator:
 
         return GeneratedResponse(
             message=message,
-            suggestions=["aide", "liste des workflows"],
+            suggestions=["aide", "mes tâches"],
             action_required=False
         )
 

agent_chat/templates/chat.html

@@ -447,6 +447,26 @@
             color: var(--text-muted);
         }
 
+        .attach-btn {
+            width: 48px;
+            height: 48px;
+            border-radius: 14px;
+            background: var(--bg-message-bot);
+            border: 1px solid var(--border);
+            color: var(--text-muted);
+            cursor: pointer;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 20px;
+            transition: all 0.2s;
+        }
+
+        .attach-btn:hover {
+            color: var(--primary);
+            border-color: var(--primary);
+        }
+
         .send-btn {
             width: 48px;
             height: 48px;
@@ -617,11 +637,8 @@
         </div>
         <div class="header-right">
             <div class="mode-toggle">
-                <button class="mode-btn active" onclick="setMode('workflow')" id="modeWorkflow">
-                    📋 Workflows
-                </button>
-                <button class="mode-btn" onclick="setMode('agent')" id="modeAgent">
-                    🚀 Agent Libre
+                <button class="mode-btn active" id="modeWorkflow">
+                    💬 Assistant
                 </button>
             </div>
             <div class="status-pill" id="statusPill">
@@ -653,6 +670,10 @@
                     <div class="welcome-suggestion-title">📋 Voir les workflows</div>
                     <div class="welcome-suggestion-desc">Lister les workflows disponibles</div>
                 </div>
+                <div class="welcome-suggestion" onclick="sendSuggestion('Montre-moi les tables')">
+                    <div class="welcome-suggestion-title">📊 Importer des données</div>
+                    <div class="welcome-suggestion-desc">Importer un fichier Excel ou voir les tables existantes</div>
+                </div>
             </div>
         </div>
     </div>
@@ -660,6 +681,10 @@
     <!-- Input Area -->
     <div class="input-area">
         <div class="input-container">
+            <button class="attach-btn" onclick="document.getElementById('fileInput').click()" title="Joindre un fichier Excel">
+                <i class="bi bi-paperclip"></i>
+            </button>
+            <input type="file" id="fileInput" accept=".xlsx,.xls,.csv" style="display:none" onchange="handleFileUpload(event)">
             <div class="input-wrapper">
                 <textarea
                     id="messageInput"
@@ -715,6 +740,23 @@
             updateAgentProgress(data);
         });
 
+        // Copilot events
+        socket.on('copilot_step', (data) => {
+            showCopilotStep(data);
+        });
+
+        socket.on('copilot_step_result', (data) => {
+            updateCopilotStepResult(data);
+        });
+
+        socket.on('copilot_complete', (data) => {
+            completeCopilot(data);
+        });
+
+        socket.on('copilot_error', (data) => {
+            addMessage(`Copilot: ${data.message}`);
+        });
+
         // =====================================================
         // UI Functions
         // =====================================================
@@ -853,40 +895,6 @@
             return card;
         }
 
-        function createAgentPlanCard(plan) {
-            const card = document.createElement('div');
-            card.className = 'action-card';
-
-            const stepsHtml = plan.steps.map((step, i) => `
-                <div class="progress-step pending" id="step-${i}">
-                    <div class="progress-step-icon">${i + 1}</div>
-                    <span>${step.description}</span>
-                </div>
-            `).join('');
-
-            card.innerHTML = `
-                <div class="action-card-header">
-                    <div class="action-card-title">
-                        🚀 Plan d'exécution
-                        <span class="confidence-badge">${plan.steps.length} étapes</span>
-                    </div>
-                </div>
-                <div class="progress-steps" style="margin-bottom: 12px;">
-                    ${stepsHtml}
-                </div>
-                <div class="action-buttons">
-                    <button class="btn btn-primary" onclick="executeAgentPlan()">
-                        <i class="bi bi-play-fill"></i> Exécuter
-                    </button>
-                    <button class="btn btn-danger" onclick="cancelAction()">
-                        <i class="bi bi-x"></i> Annuler
-                    </button>
-                </div>
-            `;
-
-            return card;
-        }
-
         function createExecutionProgress() {
             const progress = document.createElement('div');
             progress.className = 'execution-progress';
@@ -1033,11 +1041,7 @@
             addTypingIndicator();
 
             try {
-                if (currentMode === 'agent') {
-                    await sendAgentRequest(message);
-                } else {
-                    await sendChatRequest(message);
-                }
+                await sendChatRequest(message);
             } catch (error) {
                 removeTypingIndicator();
                 addMessage(`❌ Erreur: ${error.message}`);
@@ -1065,7 +1069,11 @@
             sessionId = data.session_id;
 
             // Handle different response types
-            if (data.result?.needs_confirmation) {
+            if (data.result?.needs_confirmation && data.result?.preview) {
+                // Import de données — apercu avec demande de confirmation
+                addMessage(data.response.message);
+                addSuggestions(['oui', 'non']);
+            } else if (data.result?.needs_confirmation && data.result?.confirmation) {
                 pendingConfirmation = data.result.confirmation;
                 const card = createActionCard(
                     pendingConfirmation.workflow_name,
@@ -1073,44 +1081,58 @@
                     data.intent?.confidence || 0.9
                 );
                 addMessage(data.response.message, 'bot', card);
+            } else if (data.result?.gesture) {
+                // Geste primitif exécuté
+                addMessage(data.response.message);
+            } else if (data.result?.mode === 'copilot') {
+                // Mode copilot — les étapes arrivent via WebSocket
+                addMessage(data.response.message);
             } else if (data.result?.success) {
                 const progress = createExecutionProgress();
                 addMessage(data.response.message, 'bot', progress);
+            } else if (data.result?.teach_me) {
+                // Workflow non trouvé — proposer l'apprentissage
+                const teachCard = document.createElement('div');
+                teachCard.className = 'action-card';
+                teachCard.innerHTML = `
+                    <div class="action-card-header">
+                        <div class="action-card-title">
+                            Apprentissage disponible
+                        </div>
+                    </div>
+                    <p style="margin: 8px 0; opacity: 0.8; font-size: 0.9em;">
+                        Lancez l'enregistrement sur votre PC et montrez-moi comment faire.
+                    </p>
+                    <div class="action-buttons">
+                        <button class="btn btn-primary" onclick="window.open('/api/help', '_blank')">
+                            <i class="bi bi-mortarboard"></i> Comment m'apprendre ?
+                        </button>
+                    </div>
+                `;
+                addMessage(data.response.message, 'bot', teachCard);
             } else if (data.result?.workflows) {
                 let msg = data.response.message + '\n\n';
                 data.result.workflows.slice(0, 5).forEach(w => {
                     msg += `• **${w.name}**: ${w.description || 'Pas de description'}\n`;
                 });
                 addMessage(msg);
+            } else if (data.result?.imported) {
+                // Import de données réussi
+                addMessage(data.response.message);
+                if (data.response.suggestions?.length > 0) {
+                    addSuggestions(data.response.suggestions);
+                }
+            } else if (data.result?.tables_list !== undefined || data.result?.table_info) {
+                // Liste des tables ou info table
+                addMessage(data.response.message);
+                if (data.response.suggestions?.length > 0) {
+                    addSuggestions(data.response.suggestions);
+                }
             } else {
                 addMessage(data.response.message);
             }
         }
 
-        async function sendAgentRequest(message) {
-            const response = await fetch('/api/agent/plan', {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ request: message })
-            });
-
-            const data = await response.json();
-            removeTypingIndicator();
-
-            if (data.error) {
-                addMessage(`❌ ${data.error}`);
-                return;
-            }
-
-            if (data.plan) {
-                pendingConfirmation = data.plan;
-                const card = createAgentPlanCard(data.plan);
-                addMessage(`J'ai préparé un plan pour "${message}":`, 'bot', card);
-            } else {
-                addMessage(data.message || "Je n'ai pas pu créer de plan pour cette demande.");
-            }
-        }
-
         async function confirmAction() {
             if (!pendingConfirmation) return;
 
@@ -1127,40 +1149,11 @@
 
             // Show execution progress
             const progress = createExecutionProgress();
-            addMessage("⏳ Exécution en cours...", 'bot', progress);
+            addMessage("Execution en cours...", 'bot', progress);
 
             pendingConfirmation = null;
         }
 
-        async function executeAgentPlan() {
-            if (!pendingConfirmation) return;
-
-            isProcessing = true;
-            updateInputState();
-
-            addMessage("⏳ Exécution du plan en cours...", 'bot');
-
-            const response = await fetch('/api/agent/execute', {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ plan: pendingConfirmation })
-            });
-
-            const data = await response.json();
-
-            if (data.success) {
-                const results = data.results || [];
-                const successCount = results.filter(r => r.success).length;
-                addMessage(`✅ Plan exécuté: ${successCount}/${results.length} étapes réussies`);
-            } else {
-                addMessage(`❌ Erreur: ${data.error}`);
-            }
-
-            pendingConfirmation = null;
-            isProcessing = false;
-            updateInputState();
-        }
-
         function modifyAction() {
             if (!pendingConfirmation) return;
             addMessage("✏️ Modification non implémentée. Décrivez les changements souhaités.");
@@ -1173,7 +1166,126 @@
 
         function cancelExecution() {
             socket.emit('cancel_execution');
-            addMessage("⏹️ Demande d'annulation envoyée...");
+            addMessage("Demande d'annulation envoyée...");
+        }
+
+        // =====================================================
+        // File Upload
+        // =====================================================
+        async function handleFileUpload(event) {
+            const file = event.target.files[0];
+            if (!file) return;
+
+            // Afficher le message utilisateur
+            addMessage(`📎 ${file.name}`, 'user');
+            addTypingIndicator();
+            isProcessing = true;
+            updateInputState();
+
+            const formData = new FormData();
+            formData.append('file', file);
+            formData.append('session_id', sessionId || '');
+
+            try {
+                const response = await fetch('/api/chat/upload', {
+                    method: 'POST',
+                    body: formData
+                });
+
+                const data = await response.json();
+                removeTypingIndicator();
+
+                if (data.error && !data.success) {
+                    addMessage(`Erreur : ${data.error}`);
+                } else if (data.message) {
+                    addMessage(data.message);
+                    if (data.needs_confirmation) {
+                        addSuggestions(['oui', 'non']);
+                    }
+                } else {
+                    addMessage(`Fichier ${file.name} recu.`);
+                }
+            } catch (error) {
+                removeTypingIndicator();
+                addMessage(`Erreur d'upload : ${error.message}`);
+            }
+
+            isProcessing = false;
+            updateInputState();
+            // Reset le champ fichier pour permettre de re-uploader le meme fichier
+            event.target.value = '';
+        }
+
+        // =====================================================
+        // Copilot Mode
+        // =====================================================
+
+        function showCopilotStep(data) {
+            const card = document.createElement('div');
+            card.className = 'action-card';
+            card.id = `copilot-step-${data.step_index}`;
+            card.innerHTML = `
+                <div class="action-card-header">
+                    <div class="action-card-title">
+                        Copilot - Étape ${data.step_index + 1}/${data.total}
+                    </div>
+                    <span style="font-size: 0.8em; opacity: 0.6;">${data.workflow}</span>
+                </div>
+                <p style="margin: 8px 0; font-size: 0.95em;">
+                    <strong>${data.action.type}</strong>: ${data.action.description}
+                </p>
+                <div class="action-buttons" id="copilot-btns-${data.step_index}">
+                    <button class="btn btn-primary" onclick="copilotApprove(${data.step_index})">
+                        <i class="bi bi-check-lg"></i> Exécuter
+                    </button>
+                    <button class="btn btn-secondary" onclick="copilotSkip(${data.step_index})">
+                        <i class="bi bi-skip-forward"></i> Passer
+                    </button>
+                    <button class="btn btn-danger" onclick="copilotAbort()">
+                        <i class="bi bi-x-circle"></i> Annuler tout
+                    </button>
+                </div>
+            `;
+            addMessage(`Copilot étape ${data.step_index + 1}/${data.total}`, 'bot', card);
+        }
+
+        function copilotApprove(stepIndex) {
+            socket.emit('copilot_approve');
+            const btns = document.getElementById(`copilot-btns-${stepIndex}`);
+            if (btns) btns.innerHTML = '<span style="color: var(--success);">Approuvé - en cours...</span>';
+        }
+
+        function copilotSkip(stepIndex) {
+            socket.emit('copilot_skip');
+            const btns = document.getElementById(`copilot-btns-${stepIndex}`);
+            if (btns) btns.innerHTML = '<span style="color: var(--warning);">Passé</span>';
+        }
+
+        function copilotAbort() {
+            socket.emit('copilot_abort');
+        }
+
+        function updateCopilotStepResult(data) {
+            const card = document.getElementById(`copilot-step-${data.step_index}`);
+            if (!card) return;
+
+            const btns = card.querySelector('.action-buttons') ||
+                         document.getElementById(`copilot-btns-${data.step_index}`);
+            if (!btns) return;
+
+            if (data.status === 'completed') {
+                btns.innerHTML = '<span style="color: var(--success);">Réussi</span>';
+            } else if (data.status === 'failed') {
+                btns.innerHTML = `<span style="color: var(--error);">Échoué: ${data.message}</span>`;
+            } else if (data.status === 'skipped') {
+                btns.innerHTML = '<span style="color: var(--warning);">Passé</span>';
+            }
+        }
+
+        function completeCopilot(data) {
+            const statusColor = data.status === 'completed' ? 'var(--success)' :
+                                data.status === 'aborted' ? 'var(--error)' : 'var(--warning)';
+            addMessage(`<span style="color: ${statusColor};">Copilot terminé: ${data.message}</span>`);
         }
 
         // =====================================================

agent_chat/urgences_orchestrator.py

@@ -0,0 +1,518 @@
+"""Orchestrateur démo GHT Sud 95 — pilotage du scénario "traite N dossiers".
+
+Reçoit une commande naturelle de Léa (chat) et orchestre :
+  1. Parsing intent via gemma3:1b (mini-LLM local, ~400 ms)
+  2. Setup Chrome (Win+R → URL maquette → Enter) via /replay/raw
+  3. extract_table sur la liste des patients (regex IPP, limit=N)
+  4. Boucle : pour chaque IPP, lance le workflow "Urgence_unit" via /replay
+     avec `variables={"patient_id": ipp}` pour la résolution `{{patient_id}}`
+  5. Synthèse finale postée dans le chat
+
+L'orchestration tourne dans un thread daemon. L'état est stocké en mémoire,
+poll-able via /api/urgences/status/<orch_id>.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+import threading
+import time
+import urllib.error
+import urllib.request
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+# Chargement explicite de .env.local du repo (le service systemd peut ne pas
+# voir cet env file). Cherche dans le parent de agent_chat/.
+def _load_env_local() -> None:
+    env_path = Path(__file__).resolve().parent.parent / ".env.local"
+    if not env_path.is_file():
+        return
+    try:
+        for line in env_path.read_text().splitlines():
+            line = line.strip()
+            if not line or line.startswith("#") or "=" not in line:
+                continue
+            k, v = line.split("=", 1)
+            k = k.strip()
+            v = v.strip().strip('"').strip("'")
+            os.environ.setdefault(k, v)
+    except Exception as e:
+        logger.warning("Erreur chargement .env.local: %s", e)
+
+
+_load_env_local()
+
+# ─────────────────────────────────────────────────────────────────────
+# Config
+# ─────────────────────────────────────────────────────────────────────
+STREAM_BASE = os.environ.get("RPA_STREAM_BASE", "http://localhost:5005")
+OLLAMA_URL = os.environ.get("OLLAMA_URL", "http://localhost:11434/api/generate")
+NLP_MODEL = os.environ.get("LEA_NLP_MODEL", "gemma3:1b")
+RPA_API_TOKEN = os.environ.get("RPA_API_TOKEN", "")
+
+URGENCE_WORKFLOW_ID = os.environ.get("LEA_URGENCE_WORKFLOW_ID", "wf_urgence_unit")
+# URL LAN locale (sans Basic Auth ni HTTPS) pour éviter le prompt Windows Hello
+# de Chrome (lecteur d'empreintes digitales) qui bloque le replay automatique.
+# L'URL publique HTTPS reste disponible (https://urgence.labs.laurinebazin.design)
+# pour usage humain, mais n'est PAS utilisée par Léa pendant la démo.
+MAQUETTE_URL = os.environ.get("LEA_MAQUETTE_URL", "http://192.168.1.40:8765/index.html")
+
+
+
+# Session de replay stable de l'agent V1. L'agent polle /replay/next sur
+# `agent_<user_id>` indépendamment des sessions d'enregistrement (sess_*).
+# user_id default côté agent V1 = "demo_user" (cf. agent_v1/main.py:62).
+AGENT_SESSION_ID = os.environ.get("LEA_AGENT_SESSION_ID", "agent_demo_user")
+
+# machine_id de l'agent V1 cible. DOIT matcher self.machine_id côté agent V1
+# (sinon /replay/next ne distribue pas la queue à cette machine — le serveur
+# isole les machines pour éviter le vol cross-machine d'actions).
+# Valeur par défaut = hostname du PC Windows de démo GHT.
+AGENT_MACHINE_ID = os.environ.get("LEA_AGENT_MACHINE_ID", "DESKTOP-58D5CAC_windows")
+
+# Pattern IPP : 8 chiffres, premier groupe "25" (cohort 2025), reste libre
+IPP_PATTERN = r"^25\d{6}$"
+
+# ─────────────────────────────────────────────────────────────────────
+# NLP : parsing de commande naturelle via gemma3:1b
+# ─────────────────────────────────────────────────────────────────────
+
+NLP_PROMPT = """Tu es un parseur d'intentions pour Léa, assistant RPA médical.
+Réponds UNIQUEMENT en JSON valide, sans texte avant/après, selon ce schéma :
+{"action": "process_patients" | "stop" | "unknown", "count": <int|null>, "order": "first" | "last" | "all" | "specific" | null, "ipp": "<string>" | null}
+
+Règles :
+- "traite N dossiers" / "code N dossiers" / "fais les N premiers" → action=process_patients, count=N, order="first"
+- "traite tous les dossiers" → action=process_patients, count=null, order="all"
+- "traite le dossier 25003364" → action=process_patients, count=1, order="specific", ipp="25003364"
+- "stop" / "arrête" / "annule" → action=stop
+- Question ("comment", "pourquoi") → action=unknown
+- Si tu ne comprends pas → action=unknown"""
+
+
+def parse_lea_command(text: str, model: str = NLP_MODEL, timeout: int = 8) -> Dict[str, Any]:
+    """Parse une commande naturelle en intent structuré via gemma3:1b.
+
+    Fallback regex si Ollama est indisponible — pour ne pas bloquer la démo.
+    Returns : dict {action, count, order, ipp} ou {action: "unknown"}.
+    """
+    payload = {
+        "model": model,
+        "prompt": NLP_PROMPT + "\n\nUtilisateur : " + text + "\n\nJSON :",
+        "stream": False,
+        "format": "json",
+        "options": {"temperature": 0.0, "num_predict": 120, "num_ctx": 1024},
+    }
+    data = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(OLLAMA_URL, data=data, headers={"Content-Type": "application/json"})
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            body = json.loads(resp.read().decode("utf-8"))
+        raw = (body.get("response") or "").strip()
+        if raw.startswith("```"):
+            raw = raw.split("\n", 1)[-1].rsplit("```", 1)[0].strip()
+        intent = json.loads(raw)
+    except (urllib.error.URLError, TimeoutError, json.JSONDecodeError) as e:
+        logger.warning("parse_lea_command: gemma3:1b indisponible (%s), fallback regex", e)
+        return _parse_fallback_regex(text)
+
+    # Post-processing : gemma3:1b a tendance à remplir tous les champs même
+    # quand non pertinent. On nettoie :
+    # - ipp ne doit être conservé que si présent LITTÉRALEMENT dans le texte source
+    #   (sinon le LLM hallucine un IPP plausible)
+    if intent.get("ipp") and str(intent["ipp"]) not in text:
+        intent["ipp"] = None
+        # Si le LLM a forcé order=specific sans vrai IPP, on bascule en first
+        if intent.get("order") == "specific":
+            intent["order"] = "first"
+    # - ipp ne doit être conservé que si order="specific" ET format IPP valide
+    if intent.get("ipp") and intent.get("order") != "specific":
+        intent["ipp"] = None
+    if intent.get("ipp") and not re.match(r"^\d{8,10}$", str(intent["ipp"])):
+        intent["ipp"] = None
+    # - si count est défini ET order="all", l'humain demande "N dossiers" et
+    #   non "tous les dossiers" : on bascule en "first" (cohérence sémantique)
+    if intent.get("count") and intent.get("order") == "all":
+        intent["order"] = "first"
+    return intent
+
+
+def _parse_fallback_regex(text: str) -> Dict[str, Any]:
+    """Fallback regex robuste si LLM HS — couvre les phrasings classiques."""
+    t = text.lower()
+    if any(w in t for w in ("stop", "arrête", "annule", "annuler")):
+        return {"action": "stop", "count": None, "order": None, "ipp": None}
+    # IPP spécifique : "traite le dossier 25003364"
+    m = re.search(r"\b(25\d{6})\b", text)
+    if m and any(w in t for w in ("traite", "code", "analyse")):
+        return {"action": "process_patients", "count": 1, "order": "specific", "ipp": m.group(1)}
+    if any(w in t for w in ("tous", "toutes")) and any(w in t for w in ("traite", "code")):
+        return {"action": "process_patients", "count": None, "order": "all", "ipp": None}
+    # Quantifié : "traite 3 dossiers"
+    m = re.search(r"(\d+)\s*(?:premiers?\s*)?(?:dossiers?|cas|patients?)", t)
+    if m and any(w in t for w in ("traite", "code", "fais", "analyse")):
+        return {"action": "process_patients", "count": int(m.group(1)), "order": "first", "ipp": None}
+    return {"action": "unknown", "count": None, "order": None, "ipp": None}
+
+
+# ─────────────────────────────────────────────────────────────────────
+# Helpers HTTP vers le streaming server (port 5005)
+# ─────────────────────────────────────────────────────────────────────
+
+def _stream_headers() -> Dict[str, str]:
+    h = {"Content-Type": "application/json"}
+    if RPA_API_TOKEN:
+        h["Authorization"] = f"Bearer {RPA_API_TOKEN}"
+    return h
+
+
+def _post(path: str, body: dict, timeout: int = 30) -> dict:
+    req = urllib.request.Request(
+        STREAM_BASE + path,
+        data=json.dumps(body).encode("utf-8"),
+        headers=_stream_headers(),
+        method="POST",
+    )
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        return json.loads(resp.read().decode("utf-8"))
+
+
+def _get(path: str, timeout: int = 10) -> dict:
+    req = urllib.request.Request(
+        STREAM_BASE + path,
+        headers=_stream_headers(),
+        method="GET",
+    )
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        return json.loads(resp.read().decode("utf-8"))
+
+
+# ─────────────────────────────────────────────────────────────────────
+# Orchestration : état + thread d'exécution
+# ─────────────────────────────────────────────────────────────────────
+
+@dataclass
+class DossierResult:
+    ipp: str
+    decision: Optional[str] = None         # "REQUALIFICATION_HOSPITALISATION" | "FORFAIT_URGENCE"
+    decision_court: Optional[str] = None   # "UHCD" | "Forfait Urgences"
+    confiance: Optional[str] = None
+    duree_passage_heures: Optional[float] = None
+    concordance: Optional[bool] = None
+    error: Optional[str] = None
+
+
+@dataclass
+class OrchestrationState:
+    orch_id: str
+    status: str = "starting"   # starting | running | done | error | cancelled
+    progress: int = 0          # 0 → count
+    count: int = 0
+    current_step: str = ""     # "setup_chrome" | "extract_table" | "process_dossier_X" | "synthese"
+    intent: Dict[str, Any] = field(default_factory=dict)
+    patients: List[str] = field(default_factory=list)
+    results: List[DossierResult] = field(default_factory=list)
+    synthese: Optional[str] = None
+    error: Optional[str] = None
+    started_at: float = field(default_factory=time.time)
+    finished_at: Optional[float] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "orch_id": self.orch_id,
+            "status": self.status,
+            "progress": self.progress,
+            "count": self.count,
+            "current_step": self.current_step,
+            "intent": self.intent,
+            "patients": self.patients,
+            "results": [r.__dict__ for r in self.results],
+            "synthese": self.synthese,
+            "error": self.error,
+            "elapsed_s": round((self.finished_at or time.time()) - self.started_at, 1),
+        }
+
+
+# Registry global des orchestrations en cours (thread-safe via lock)
+_ORCH_REGISTRY: Dict[str, OrchestrationState] = {}
+_ORCH_LOCK = threading.Lock()
+
+
+def get_orchestration(orch_id: str) -> Optional[OrchestrationState]:
+    with _ORCH_LOCK:
+        return _ORCH_REGISTRY.get(orch_id)
+
+
+def list_orchestrations() -> List[Dict[str, Any]]:
+    with _ORCH_LOCK:
+        return [s.to_dict() for s in _ORCH_REGISTRY.values()]
+
+
+def start_orchestration(
+    intent: Dict[str, Any],
+    session_id: str = "",
+    machine_id: Optional[str] = None,
+) -> OrchestrationState:
+    """Lance une orchestration en thread daemon. Retourne l'état initial.
+
+    Args:
+        intent: dict {action, count, order, ipp} (sortie de parse_lea_command)
+        session_id: session de replay (default: agent_demo_user, le canal stable
+                    sur lequel l'agent V1 polle /replay/next)
+        machine_id: machine cible (optionnel, pour multi-machines futurs)
+    """
+    if not session_id:
+        session_id = AGENT_SESSION_ID
+    if not machine_id:
+        machine_id = AGENT_MACHINE_ID
+    orch_id = "orch_" + uuid.uuid4().hex[:10]
+    count = intent.get("count") or 3  # default 3 si "tous" ou "first" sans nombre
+    state = OrchestrationState(
+        orch_id=orch_id,
+        status="starting",
+        count=count,
+        intent=intent,
+    )
+    with _ORCH_LOCK:
+        _ORCH_REGISTRY[orch_id] = state
+
+    th = threading.Thread(
+        target=_run_orchestration,
+        args=(state, session_id, machine_id),
+        daemon=True,
+        name=f"orch-{orch_id}",
+    )
+    th.start()
+    return state
+
+
+def _run_orchestration(state: OrchestrationState, session_id: str, machine_id: Optional[str]) -> None:
+    """Boucle d'orchestration exécutée dans un thread.
+
+    Phases :
+      1. Setup Chrome (raw actions Win+R)
+      2. extract_table sur liste patients
+      3. Boucle workflow Urgence_unit
+      4. Synthèse
+    """
+    try:
+        state.status = "running"
+        intent = state.intent
+
+        # Cas "specific" : court-circuiter, juste 1 IPP
+        if intent.get("order") == "specific" and intent.get("ipp"):
+            state.patients = [intent["ipp"]]
+            state.count = 1
+            state.current_step = "process_dossier"
+            _process_dossiers(state, session_id, machine_id)
+        else:
+            # 1. Setup Chrome → URL maquette
+            state.current_step = "setup_chrome"
+            _setup_chrome(session_id, machine_id)
+
+            # 2. Lire la liste des IPP via extract_table
+            state.current_step = "extract_table"
+            patients = _extract_patient_list(session_id, machine_id, limit=state.count)
+            state.patients = patients
+            if not patients:
+                raise RuntimeError("extract_table n'a trouvé aucun IPP — vérifier que Chrome est sur index.html")
+
+            # 3. Pour chaque IPP : lancer workflow Urgence_unit
+            _process_dossiers(state, session_id, machine_id)
+
+        # 4. Synthèse
+        state.current_step = "synthese"
+        state.synthese = _build_synthese(state)
+        state.status = "done"
+    except Exception as e:
+        logger.exception("Orchestration %s : erreur fatale", state.orch_id)
+        state.status = "error"
+        state.error = str(e)
+    finally:
+        state.finished_at = time.time()
+
+
+# ─────────────────────────────────────────────────────────────────────
+# Phases de l'orchestration
+# ─────────────────────────────────────────────────────────────────────
+
+def _setup_chrome(session_id: str, machine_id: Optional[str]) -> None:
+    """Composer "ouvrir Chrome sur l'URL maquette" via le catalogue de réflexes.
+
+    Léa ne fait PAS un workflow appris pour cette étape : c'est une composition
+    de primitives natives (réflexes du catalogue) + une saisie texte.
+
+    Séquence :
+      1. réflexe `sys_run` (Win+R)              ← gesture_catalog
+      2. type "chrome.exe <URL>"                 ← saisie atomique
+      3. réflexe `nav_enter` (Entrée)            ← gesture_catalog
+    """
+    from agent_chat.gesture_catalog import get_gesture_catalog
+
+    catalog = get_gesture_catalog()
+    show_desktop = catalog.get_by_id("win_minimize_all")  # Win+D — minimise tout (Léa incl.)
+    sys_run = catalog.get_by_id("sys_run")
+    nav_enter = catalog.get_by_id("nav_enter")
+    if sys_run is None or nav_enter is None or show_desktop is None:
+        raise RuntimeError("Réflexes catalogue manquants : win_minimize_all / sys_run / nav_enter")
+
+    actions = [
+        show_desktop.to_replay_action(),          # réflexe Win+D — Léa se réduit complètement
+        {
+            "action_id": f"setup_wait_desktop_{uuid.uuid4().hex[:6]}",
+            "type": "wait",
+            "duration_ms": 400,
+            "intention": "Attendre que le bureau soit affiché",
+        },
+        sys_run.to_replay_action(),               # réflexe Win+R
+        {
+            "action_id": f"setup_wait_{uuid.uuid4().hex[:6]}",
+            "type": "wait",
+            "duration_ms": 800,
+            "intention": "Attendre que la boîte Exécuter soit prête",
+        },
+        {
+            "action_id": f"setup_typeurl_{uuid.uuid4().hex[:6]}",
+            "type": "type",
+            "text": f"chrome.exe {MAQUETTE_URL}",
+            "intention": "Taper la commande Chrome + URL maquette",
+        },
+        nav_enter.to_replay_action(),             # réflexe Entrée
+        {
+            "action_id": f"setup_wait_load_{uuid.uuid4().hex[:6]}",
+            "type": "wait",
+            "duration_ms": 3500,
+            "intention": "Attendre le chargement de la maquette",
+        },
+    ]
+    payload = {
+        "actions": actions,
+        "session_id": session_id,
+        "task_description": "Setup démo GHT — composition réflexes (sys_run + type + nav_enter)",
+    }
+    if machine_id:
+        payload["machine_id"] = machine_id
+    resp = _post("/api/v1/traces/stream/replay/raw", payload, timeout=20)
+    replay_id = resp.get("replay_id")
+    if not replay_id:
+        raise RuntimeError(f"setup_chrome : pas de replay_id ({resp})")
+    # Setup Chrome ≈ 13s observé (Win+D + Win+R + type URL + Enter + wait 3500ms),
+    # mais le PC peut être chargé → 60s donne de la marge.
+    _wait_replay_done(replay_id, timeout_s=60)
+
+
+def _extract_patient_list(session_id: str, machine_id: Optional[str], limit: int) -> List[str]:
+    """Lance une action extract_table seule pour lire la liste des IPP."""
+    actions = [
+        {
+            "action_id": f"extract_table_{uuid.uuid4().hex[:6]}",
+            "type": "extract_table",
+            "parameters": {
+                "output_var": "patients_list",
+                "pattern": IPP_PATTERN,
+                "limit": limit,
+            },
+            "intention": "Lire la liste des IPP visible à l'écran",
+        },
+    ]
+    payload = {
+        "actions": actions,
+        "session_id": session_id,
+        "task_description": "Extraction liste patients GHT",
+    }
+    if machine_id:
+        payload["machine_id"] = machine_id
+    resp = _post("/api/v1/traces/stream/replay/raw", payload, timeout=15)
+    replay_id = resp.get("replay_id")
+    if not replay_id:
+        raise RuntimeError(f"extract_table : pas de replay_id ({resp})")
+    final = _wait_replay_done(replay_id, timeout_s=20)
+    return list(final.get("variables", {}).get("patients_list") or [])
+
+
+def _process_dossiers(state: OrchestrationState, session_id: str, machine_id: Optional[str]) -> None:
+    """Boucle : pour chaque IPP, lance le workflow Urgence_unit."""
+    for i, ipp in enumerate(state.patients):
+        state.current_step = f"process_dossier_{i+1}_of_{len(state.patients)}"
+        result = DossierResult(ipp=ipp)
+        try:
+            payload = {
+                "workflow_id": URGENCE_WORKFLOW_ID,
+                "session_id": session_id,
+                "variables": {"patient_id": ipp},
+            }
+            if machine_id:
+                payload["machine_id"] = machine_id
+            resp = _post("/api/v1/traces/stream/replay", payload, timeout=20)
+            replay_id = resp.get("replay_id")
+            if not replay_id:
+                raise RuntimeError(f"replay_id manquant ({resp})")
+            final = _wait_replay_done(replay_id, timeout_s=180)
+            t2a = final.get("variables", {}).get("t2a_result") or {}
+            result.decision = t2a.get("decision")
+            result.decision_court = t2a.get("decision_court")
+            result.confiance = t2a.get("confiance")
+            result.duree_passage_heures = t2a.get("duree_passage_heures")
+            result.concordance = t2a.get("concordance")
+        except Exception as e:
+            result.error = str(e)
+            logger.warning("Dossier %s : erreur %s", ipp, e)
+        state.results.append(result)
+        state.progress = i + 1
+
+
+def _wait_replay_done(replay_id: str, timeout_s: int = 60, poll_s: float = 1.0) -> Dict[str, Any]:
+    """Poll /replay/<id> jusqu'à status terminal."""
+    deadline = time.time() + timeout_s
+    last = {}
+    while time.time() < deadline:
+        try:
+            last = _get(f"/api/v1/traces/stream/replay/{replay_id}", timeout=5)
+        except Exception as e:
+            logger.warning("poll replay %s : %s", replay_id, e)
+        status = last.get("status", "")
+        if status in ("done", "completed", "finished", "error", "cancelled", "paused_need_help"):
+            return last
+        time.sleep(poll_s)
+    raise TimeoutError(f"replay {replay_id} non terminé après {timeout_s}s (status={last.get('status')})")
+
+
+# ─────────────────────────────────────────────────────────────────────
+# Synthèse finale
+# ─────────────────────────────────────────────────────────────────────
+
+def _build_synthese(state: OrchestrationState) -> str:
+    """Construit le message de synthèse posté dans le chat à la fin."""
+    n = len(state.results)
+    if n == 0:
+        return "Aucun dossier traité."
+    n_uhcd = sum(1 for r in state.results if r.decision == "REQUALIFICATION_HOSPITALISATION")
+    n_forfait = sum(1 for r in state.results if r.decision == "FORFAIT_URGENCE")
+    n_concord = sum(1 for r in state.results if r.concordance is True)
+    lines = [f"✅ Terminé. {n} dossier(s) traité(s) : {n_forfait} forfait(s) urgences, {n_uhcd} UHCD."]
+    if any(r.concordance is not None for r in state.results):
+        lines.append(f"Concordance vérité-terrain : {n_concord}/{n}.")
+    lines.append("")
+    for r in state.results:
+        if r.error:
+            lines.append(f"  • {r.ipp} : ❌ erreur — {r.error}")
+            continue
+        decision_label = r.decision_court or r.decision or "—"
+        conf = f"confiance {r.confiance}" if r.confiance else ""
+        duree = f"{r.duree_passage_heures:.1f}h" if r.duree_passage_heures else ""
+        concord_mark = ""
+        if r.concordance is True:
+            concord_mark = " ✓"
+        elif r.concordance is False:
+            concord_mark = " ⚠ écart vérité-terrain"
+        details = ", ".join(x for x in (conf, duree) if x)
+        lines.append(f"  • {r.ipp} : {decision_label}{concord_mark}" + (f" ({details})" if details else ""))
+    return "\n".join(lines)

agent_rust/lea_uia/.gitignore

@@ -0,0 +1,3 @@
+target/
+**/target/
+

agent_rust/lea_uia/Cargo.lock

@@ -0,0 +1,384 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "anstream"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
+
+[[package]]
+name = "anstyle-parse"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
+dependencies = [
+ "windows-sys",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
+dependencies = [
+ "anstyle",
+ "once_cell_polyfill",
+ "windows-sys",
+]
+
+[[package]]
+name = "clap"
+version = "4.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b193af5b67834b676abd72466a96c1024e6a6ad978a1f484bd90b85c94041351"
+dependencies = [
+ "clap_builder",
+ "clap_derive",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "714a53001bf66416adb0e2ef5ac857140e7dc3a0c48fb28b2f10762fc4b5069f"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "clap_lex",
+ "strsim",
+]
+
+[[package]]
+name = "clap_derive"
+version = "4.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1110bd8a634a1ab8cb04345d8d878267d57c3cf1b38d91b71af6686408bbca6a"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "clap_lex"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
+
+[[package]]
+name = "colorchoice"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "lea_uia"
+version = "0.1.0"
+dependencies = [
+ "clap",
+ "serde",
+ "serde_json",
+ "windows",
+]
+
+[[package]]
+name = "memchr"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
+[[package]]
+name = "windows"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f919aee0a93304be7f62e8e5027811bbba96bcb1de84d6618be56e43f8a32a1"
+dependencies = [
+ "windows-core",
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "810ce18ed2112484b0d4e15d022e5f598113e220c53e373fb31e67e21670c1ce"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-result",
+ "windows-strings",
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83577b051e2f49a058c308f17f273b570a6a758386fc291b5f6a934dd84e48c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-result"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87fa48cc5d406560701792be122a10132491cff9d0aeb23583cc2dcafc847319"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
+dependencies = [
+ "windows-link 0.2.1",
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
+
+[[package]]
+name = "zmij"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"

agent_rust/lea_uia/Cargo.toml

@@ -0,0 +1,34 @@
+[package]
+name = "lea_uia"
+version = "0.1.0"
+edition = "2021"
+authors = ["Dom <dom@rpa-vision-v3>"]
+description = "Helper Windows UI Automation pour Léa (agent RPA V3)"
+license = "Proprietary"
+
+[[bin]]
+name = "lea_uia"
+path = "src/main.rs"
+
+[dependencies]
+clap = { version = "4.5", features = ["derive"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+
+[target.'cfg(windows)'.dependencies]
+windows = { version = "0.59", features = [
+    "Win32_Foundation",
+    "Win32_System_Com",
+    "Win32_System_Ole",
+    "Win32_System_Variant",
+    "Win32_UI_Accessibility",
+    "Win32_UI_WindowsAndMessaging",
+    "Win32_Graphics_Gdi",
+] }
+
+[profile.release]
+opt-level = "z"     # Taille minimale
+lto = true          # Link-time optimization
+codegen-units = 1   # Meilleure optimisation
+strip = true        # Retirer les symboles
+panic = "abort"     # Pas d'unwinding → binaire plus petit

agent_rust/lea_uia/src/main.rs

@@ -0,0 +1,564 @@
+// lea_uia — Helper Windows UI Automation pour Léa
+//
+// Binaire standalone qui expose 3 commandes UIA :
+//   query   → retourne l'élément UIA à une position (x, y)
+//   find    → retrouve un élément par son chemin logique
+//   capture → liste les éléments visibles (debug)
+//
+// Communication avec l'agent Python via stdin/stdout JSON.
+// Tous les appels sont non-bloquants et retournent du JSON structuré.
+//
+// Sur Linux (développement) : retourne des stubs d'erreur.
+// Sur Windows : utilise UIAutomationCore via `windows-rs`.
+
+use clap::{Parser, Subcommand};
+use serde::{Deserialize, Serialize};
+
+#[derive(Parser)]
+#[command(name = "lea_uia")]
+#[command(about = "Helper UI Automation pour Léa", long_about = None)]
+#[command(version)]
+struct Cli {
+    #[command(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    /// Retourner l'élément UIA à une position donnée (x, y en pixels écran)
+    Query {
+        /// Coordonnée X (pixels)
+        #[arg(long)]
+        x: i32,
+        /// Coordonnée Y (pixels)
+        #[arg(long)]
+        y: i32,
+        /// Inclure la hiérarchie des parents (peut être lent)
+        #[arg(long, default_value_t = true)]
+        with_parents: bool,
+    },
+    /// Rechercher un élément par son chemin logique ou son nom
+    Find {
+        /// Nom de l'élément (Name property)
+        #[arg(long)]
+        name: Option<String>,
+        /// Type de contrôle (Button, Edit, MenuItem, etc.)
+        #[arg(long)]
+        control_type: Option<String>,
+        /// AutomationId
+        #[arg(long)]
+        automation_id: Option<String>,
+        /// Limite la recherche à cette fenêtre (titre exact)
+        #[arg(long)]
+        window: Option<String>,
+        /// Timeout en millisecondes
+        #[arg(long, default_value_t = 2000)]
+        timeout_ms: u32,
+    },
+    /// Lister tous les éléments visibles de la fenêtre active (debug)
+    Capture {
+        /// Profondeur maximale de l'arbre
+        #[arg(long, default_value_t = 3)]
+        max_depth: u32,
+    },
+    /// Vérifier que UIA est disponible et fonctionnel
+    Health,
+}
+
+// =========================================================================
+// Modèles de sortie JSON
+// =========================================================================
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+struct UiaElement {
+    /// Nom visible de l'élément
+    name: String,
+    /// Type de contrôle (Button, Edit, MenuItem, Window, ...)
+    control_type: String,
+    /// Classe Windows (Edit, Static, #32770, ...)
+    class_name: String,
+    /// AutomationId (ID interne, parfois vide)
+    automation_id: String,
+    /// Rectangle absolu [x1, y1, x2, y2] en pixels écran
+    bounding_rect: [i32; 4],
+    /// Est-ce que l'élément est activable
+    is_enabled: bool,
+    /// Est-ce que l'élément est visible
+    is_offscreen: bool,
+    /// Hiérarchie des parents (chemin logique)
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    parent_path: Vec<ParentHint>,
+    /// Process owning this element
+    #[serde(skip_serializing_if = "String::is_empty")]
+    process_name: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+struct ParentHint {
+    name: String,
+    control_type: String,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(tag = "status")]
+enum UiaResponse {
+    #[serde(rename = "ok")]
+    Ok {
+        element: Option<UiaElement>,
+        #[serde(skip_serializing_if = "Vec::is_empty")]
+        elements: Vec<UiaElement>,
+        elapsed_ms: u64,
+    },
+    #[serde(rename = "not_found")]
+    NotFound {
+        reason: String,
+        elapsed_ms: u64,
+    },
+    #[serde(rename = "error")]
+    Error {
+        message: String,
+        code: String,
+    },
+    #[serde(rename = "unavailable")]
+    Unavailable {
+        reason: String,
+    },
+}
+
+// =========================================================================
+// Implémentation Windows
+// =========================================================================
+
+#[cfg(windows)]
+mod uia_impl {
+    use super::*;
+    use std::time::Instant;
+    use windows::Win32::Foundation::POINT;
+    use windows::Win32::System::Com::{
+        CoCreateInstance, CoInitializeEx, CoUninitialize, CLSCTX_INPROC_SERVER,
+        COINIT_APARTMENTTHREADED,
+    };
+    use windows::Win32::UI::Accessibility::{
+        CUIAutomation, IUIAutomation, IUIAutomationElement, IUIAutomationTreeWalker,
+    };
+
+    struct ComGuard;
+    impl ComGuard {
+        fn new() -> windows::core::Result<Self> {
+            unsafe {
+                let hr = CoInitializeEx(None, COINIT_APARTMENTTHREADED);
+                if hr.is_err() {
+                    // RPC_E_CHANGED_MODE : le thread est déjà initialisé → OK
+                    let code = hr.0 as u32;
+                    if code != 0x80010106 {
+                        return Err(windows::core::Error::from(hr));
+                    }
+                }
+            }
+            Ok(Self)
+        }
+    }
+    impl Drop for ComGuard {
+        fn drop(&mut self) {
+            unsafe { CoUninitialize() };
+        }
+    }
+
+    fn get_automation() -> windows::core::Result<IUIAutomation> {
+        unsafe { CoCreateInstance(&CUIAutomation, None, CLSCTX_INPROC_SERVER) }
+    }
+
+    fn element_to_struct(
+        element: &IUIAutomationElement,
+        with_parents: bool,
+    ) -> windows::core::Result<UiaElement> {
+        let mut result = UiaElement {
+            name: String::new(),
+            control_type: String::new(),
+            class_name: String::new(),
+            automation_id: String::new(),
+            bounding_rect: [0, 0, 0, 0],
+            is_enabled: false,
+            is_offscreen: true,
+            parent_path: Vec::new(),
+            process_name: String::new(),
+        };
+
+        unsafe {
+            if let Ok(name) = element.CurrentName() {
+                result.name = name.to_string();
+            }
+            if let Ok(ct) = element.CurrentLocalizedControlType() {
+                result.control_type = ct.to_string();
+            }
+            if let Ok(cn) = element.CurrentClassName() {
+                result.class_name = cn.to_string();
+            }
+            if let Ok(aid) = element.CurrentAutomationId() {
+                result.automation_id = aid.to_string();
+            }
+            if let Ok(rect) = element.CurrentBoundingRectangle() {
+                result.bounding_rect = [rect.left, rect.top, rect.right, rect.bottom];
+            }
+            if let Ok(enabled) = element.CurrentIsEnabled() {
+                result.is_enabled = enabled.as_bool();
+            }
+            if let Ok(offscreen) = element.CurrentIsOffscreen() {
+                result.is_offscreen = offscreen.as_bool();
+            }
+            if with_parents {
+                // Remonter la hiérarchie jusqu'à la Window root
+                if let Ok(automation) = get_automation() {
+                    let walker = automation.ControlViewWalker();
+                    if let Ok(walker) = walker {
+                        let mut current = element.clone();
+                        for _ in 0..10 {
+                            match walker.GetParentElement(&current) {
+                                Ok(parent) => {
+                                    let name = parent
+                                        .CurrentName()
+                                        .map(|n| n.to_string())
+                                        .unwrap_or_default();
+                                    let ct = parent
+                                        .CurrentLocalizedControlType()
+                                        .map(|c| c.to_string())
+                                        .unwrap_or_default();
+                                    if name.is_empty() && ct.is_empty() {
+                                        break;
+                                    }
+                                    result.parent_path.insert(
+                                        0,
+                                        ParentHint {
+                                            name,
+                                            control_type: ct,
+                                        },
+                                    );
+                                    current = parent;
+                                }
+                                Err(_) => break,
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        Ok(result)
+    }
+
+    pub fn query_at_point(x: i32, y: i32, with_parents: bool) -> UiaResponse {
+        let start = Instant::now();
+        let _com = match ComGuard::new() {
+            Ok(g) => g,
+            Err(e) => {
+                return UiaResponse::Error {
+                    message: format!("CoInitializeEx: {}", e),
+                    code: "com_init_failed".into(),
+                }
+            }
+        };
+
+        let automation = match get_automation() {
+            Ok(a) => a,
+            Err(e) => {
+                return UiaResponse::Error {
+                    message: format!("CUIAutomation: {}", e),
+                    code: "automation_failed".into(),
+                }
+            }
+        };
+
+        let point = POINT { x, y };
+        let element = unsafe { automation.ElementFromPoint(point) };
+        match element {
+            Ok(el) => match element_to_struct(&el, with_parents) {
+                Ok(e) => UiaResponse::Ok {
+                    element: Some(e),
+                    elements: Vec::new(),
+                    elapsed_ms: start.elapsed().as_millis() as u64,
+                },
+                Err(e) => UiaResponse::Error {
+                    message: format!("element_to_struct: {}", e),
+                    code: "extract_failed".into(),
+                },
+            },
+            Err(_) => UiaResponse::NotFound {
+                reason: format!("Aucun élément UIA à ({}, {})", x, y),
+                elapsed_ms: start.elapsed().as_millis() as u64,
+            },
+        }
+    }
+
+    pub fn find_element(
+        name: Option<String>,
+        _control_type: Option<String>,
+        _automation_id: Option<String>,
+        _window: Option<String>,
+        _timeout_ms: u32,
+    ) -> UiaResponse {
+        let start = Instant::now();
+        let _com = match ComGuard::new() {
+            Ok(g) => g,
+            Err(e) => {
+                return UiaResponse::Error {
+                    message: format!("CoInitializeEx: {}", e),
+                    code: "com_init_failed".into(),
+                }
+            }
+        };
+
+        let automation = match get_automation() {
+            Ok(a) => a,
+            Err(e) => {
+                return UiaResponse::Error {
+                    message: format!("CUIAutomation: {}", e),
+                    code: "automation_failed".into(),
+                }
+            }
+        };
+
+        let root = match unsafe { automation.GetRootElement() } {
+            Ok(r) => r,
+            Err(e) => {
+                return UiaResponse::Error {
+                    message: format!("GetRootElement: {}", e),
+                    code: "root_failed".into(),
+                }
+            }
+        };
+
+        // Recherche simple par parcours d'arbre (MVP)
+        // L'arbre UIA peut être énorme → on limite la profondeur
+        if let Some(target_name) = name {
+            let walker = unsafe { automation.ControlViewWalker() };
+            if let Ok(walker) = walker {
+                if let Some(found) =
+                    walk_and_find(&walker, &root, &target_name, 0, 6, &_control_type, &_automation_id)
+                {
+                    match element_to_struct(&found, true) {
+                        Ok(e) => {
+                            return UiaResponse::Ok {
+                                element: Some(e),
+                                elements: Vec::new(),
+                                elapsed_ms: start.elapsed().as_millis() as u64,
+                            }
+                        }
+                        Err(e) => {
+                            return UiaResponse::Error {
+                                message: format!("element_to_struct: {}", e),
+                                code: "extract_failed".into(),
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        UiaResponse::NotFound {
+            reason: "Aucun élément trouvé".into(),
+            elapsed_ms: start.elapsed().as_millis() as u64,
+        }
+    }
+
+    /// Parcours récursif de l'arbre UIA pour trouver un élément par nom
+    fn walk_and_find(
+        walker: &IUIAutomationTreeWalker,
+        element: &IUIAutomationElement,
+        target_name: &str,
+        depth: u32,
+        max_depth: u32,
+        target_control_type: &Option<String>,
+        target_automation_id: &Option<String>,
+    ) -> Option<IUIAutomationElement> {
+        if depth > max_depth {
+            return None;
+        }
+
+        // Tester l'élément courant
+        unsafe {
+            if let Ok(name) = element.CurrentName() {
+                if name.to_string() == target_name {
+                    // Vérifier les filtres additionnels
+                    let mut matches = true;
+                    if let Some(ct) = target_control_type {
+                        if let Ok(local_ct) = element.CurrentLocalizedControlType() {
+                            if !local_ct.to_string().to_lowercase().contains(&ct.to_lowercase()) {
+                                matches = false;
+                            }
+                        }
+                    }
+                    if matches {
+                        if let Some(aid) = target_automation_id {
+                            if let Ok(local_aid) = element.CurrentAutomationId() {
+                                if local_aid.to_string() != *aid {
+                                    matches = false;
+                                }
+                            }
+                        }
+                    }
+                    if matches {
+                        return Some(element.clone());
+                    }
+                }
+            }
+
+            // Parcourir les enfants
+            if let Ok(first_child) = walker.GetFirstChildElement(element) {
+                let mut current = first_child;
+                loop {
+                    if let Some(found) = walk_and_find(
+                        walker,
+                        &current,
+                        target_name,
+                        depth + 1,
+                        max_depth,
+                        target_control_type,
+                        target_automation_id,
+                    ) {
+                        return Some(found);
+                    }
+                    match walker.GetNextSiblingElement(&current) {
+                        Ok(next) => current = next,
+                        Err(_) => break,
+                    }
+                }
+            }
+        }
+        None
+    }
+
+    pub fn capture_tree(_max_depth: u32) -> UiaResponse {
+        let start = Instant::now();
+        let _com = match ComGuard::new() {
+            Ok(g) => g,
+            Err(e) => {
+                return UiaResponse::Error {
+                    message: format!("CoInitializeEx: {}", e),
+                    code: "com_init_failed".into(),
+                }
+            }
+        };
+
+        let automation = match get_automation() {
+            Ok(a) => a,
+            Err(e) => {
+                return UiaResponse::Error {
+                    message: format!("CUIAutomation: {}", e),
+                    code: "automation_failed".into(),
+                }
+            }
+        };
+
+        let focused = unsafe { automation.GetFocusedElement() };
+        match focused {
+            Ok(el) => match element_to_struct(&el, true) {
+                Ok(e) => UiaResponse::Ok {
+                    element: Some(e),
+                    elements: Vec::new(),
+                    elapsed_ms: start.elapsed().as_millis() as u64,
+                },
+                Err(e) => UiaResponse::Error {
+                    message: format!("element_to_struct: {}", e),
+                    code: "extract_failed".into(),
+                },
+            },
+            Err(e) => UiaResponse::Error {
+                message: format!("GetFocusedElement: {}", e),
+                code: "focused_failed".into(),
+            },
+        }
+    }
+
+    pub fn health_check() -> UiaResponse {
+        let _com = match ComGuard::new() {
+            Ok(g) => g,
+            Err(e) => {
+                return UiaResponse::Unavailable {
+                    reason: format!("COM init failed: {}", e),
+                }
+            }
+        };
+        match get_automation() {
+            Ok(_) => UiaResponse::Ok {
+                element: None,
+                elements: Vec::new(),
+                elapsed_ms: 0,
+            },
+            Err(e) => UiaResponse::Unavailable {
+                reason: format!("UIA not available: {}", e),
+            },
+        }
+    }
+}
+
+// =========================================================================
+// Stub Linux (pour développement et tests)
+// =========================================================================
+
+#[cfg(not(windows))]
+mod uia_impl {
+    use super::*;
+
+    pub fn query_at_point(_x: i32, _y: i32, _with_parents: bool) -> UiaResponse {
+        UiaResponse::Unavailable {
+            reason: "UIA n'est disponible que sur Windows".into(),
+        }
+    }
+
+    pub fn find_element(
+        _name: Option<String>,
+        _control_type: Option<String>,
+        _automation_id: Option<String>,
+        _window: Option<String>,
+        _timeout_ms: u32,
+    ) -> UiaResponse {
+        UiaResponse::Unavailable {
+            reason: "UIA n'est disponible que sur Windows".into(),
+        }
+    }
+
+    pub fn capture_tree(_max_depth: u32) -> UiaResponse {
+        UiaResponse::Unavailable {
+            reason: "UIA n'est disponible que sur Windows".into(),
+        }
+    }
+
+    pub fn health_check() -> UiaResponse {
+        UiaResponse::Unavailable {
+            reason: "UIA n'est disponible que sur Windows".into(),
+        }
+    }
+}
+
+// =========================================================================
+// Main
+// =========================================================================
+
+fn main() {
+    let cli = Cli::parse();
+
+    let response = match cli.command {
+        Commands::Query {
+            x,
+            y,
+            with_parents,
+        } => uia_impl::query_at_point(x, y, with_parents),
+        Commands::Find {
+            name,
+            control_type,
+            automation_id,
+            window,
+            timeout_ms,
+        } => uia_impl::find_element(name, control_type, automation_id, window, timeout_ms),
+        Commands::Capture { max_depth } => uia_impl::capture_tree(max_depth),
+        Commands::Health => uia_impl::health_check(),
+    };
+
+    // Sortie JSON sur stdout
+    match serde_json::to_string(&response) {
+        Ok(json) => println!("{}", json),
+        Err(e) => {
+            eprintln!("{{\"status\":\"error\",\"message\":\"JSON serialization: {}\"}}", e);
+            std::process::exit(1);
+        }
+    }
+}

agent_v0/.gitignore

@@ -0,0 +1 @@
+.idea/

agent_v0/__init__.py

@@ -0,0 +1 @@
+# agent_v0 — Agent RPA Vision V3

agent_v0/agent_config.json

@@ -0,0 +1,15 @@
+{
+  "user_id": "demo_user",
+  "user_label": "Démo agent_v0",
+  "customer": "Clinique Demo",
+  "training_label": "Facturation_T2A_demo",
+  "notes": "Session réelle avec clics + screenshots + key combos.",
+  "mode": "enriched",
+  "screenshot_mode": "crop",
+  "screenshot_crop_width": 900,
+  "screenshot_crop_height": 700,
+  "capture_hover": true,
+  "hover_min_idle_ms": 700,
+  "capture_scroll": true,
+  "network_save_path": ""
+}

agent_v0/agent_v1/EVOLUTION_V1_README.md

@@ -0,0 +1,76 @@
+# Évolution Agent V1 - Système d'Apprentissage "Stagiaire Fibre"
+**Projet :** RPA Vision V3  
+**Date :** 5 Mars 2026  
+**Status :** 🚀 Prêt pour Test POC Clinique
+
+---
+
+## 🎯 Philosophie : Le "Stagiaire" Apprenant
+
+Le système n'est pas un automate rigide, mais un **stagiaire cognitif** qui apprend par imitation.
+1.  **L'Expert (Humain) :** Travaille sur son PC (Windows/Mac/Linux) avec l'Agent V1.
+2.  **Le Stagiaire (IA qwen3-vl) :** Observe l'expert via la fibre, analyse les images sur une RTX 5070 et construit un **Graphe d'Intention**.
+3.  **L'Apprentissage :** Le stagiaire "réfléchit" en temps réel (Crops 400x400) et se corrige grâce aux interactions humaines.
+
+---
+
+## 🛠️ Architecture Technique Agent V1
+
+L'Agent V1 passe d'un mode "Enregistreur" (Batch) à un mode **"Capteur Intelligent" (Streaming)**.
+
+### 1. Vision Duale & Ciblée (Optimisation qwen3-vl)
+- **Crops Contextuels :** Capture systématique d'une zone de **400x400 pixels** autour de chaque clic.
+- **Contexte Global :** Screenshots plein écran pour l'identification de l'environnement.
+- **Patience Post-Action :** Capture automatique 1s après chaque clic pour voir le résultat (animations, chargements).
+- **Heartbeat :** Capture contextuelle toutes les 5s pour voir le logiciel "vivre" entre les clics.
+
+### 2. Conscience du Contexte UI
+- **Focus Change :** Détection proactive des changements de fenêtre/application.
+- **Métadonnées Sémantiques :** Capture systématique du titre de la fenêtre et du nom de l'exécutable.
+- **Anonymisation Sélective :** Capacité de floutage local (GaussianBlur) sur les zones de texte sensibles détectées.
+
+### 3. Streaming Haute Performance (Fibre-Ready)
+- **Async Streaming :** Envoi asynchrone des événements JSON et des images via une file d'attente non-bloquante.
+- **Architecture Micro-Paquets :** Plus de gros fichiers ZIP. Le serveur reçoit les données au fil de l'eau sur le port 5002.
+
+---
+
+## 🧠 Architecture Serveur (Le Cerveau)
+
+Le serveur (Machine Labo RTX 5070) a été adapté pour le flux temps réel :
+
+### 1. API Stream (`server_v1/api_stream.py`)
+- **Endpoints Dédiés :** `/event` pour le JSON, `/image` pour les crops/full, `/finalize` pour clore la session.
+- **Live Sessions :** Stockage temporaire en format `.jsonl` (robuste aux crashs) avant consolidation finale.
+
+### 2. Stream Worker (`server_v1/worker_stream.py`)
+- **Analyse au fil de l'eau :** Le worker surveille le dossier `live_sessions` et lance l'inférence `qwen3-vl` dès qu'un crop arrive.
+- **Construction de Graphe :** Le stagiaire commence à relier les points (actions) pour former un graphe de décision pendant que l'expert travaille encore.
+
+---
+
+## 🖥️ Portabilité & Exécution Déportée
+
+L'Agent V1 est conçu pour être porté sur **Windows** et **macOS** :
+- **Bibliothèques Cross-Plateforme :** `mss` (Vision), `pynput` (Events), `PyQt5` (UI).
+- **Exécution Déportée :** L'architecture prépare le terrain pour que le rejeu puisse se faire sur un PC Windows distant, piloté par les ordres envoyés par la machine Labo via Fibre/WebSockets.
+
+---
+
+## 📋 Checklist de Déploiement (Machine Labo)
+
+1. **Installer les dépendances :** `pip install PyQt5 pystray Pillow mss requests psutil`
+2. **Lancer le Serveur de Streaming :** `python agent_v0/server_v1/api_stream.py` (Port 5002)
+3. **Lancer le Stream Worker :** `python agent_v0/server_v1/worker_stream.py`
+4. **Lancer l'Agent V1 :** `python run_agent_v1.py` sur le PC de test.
+
+---
+
+## 🎨 Interface Utilisateur "Sympa"
+L'Agent V1 n'est plus un outil technique froid :
+- **Tray Icon dynamique :** Gris (Repos), Rouge (Apprentissage), Bleu (Sync Fibre).
+- **Dialogues Humains :** Accueil personnalisé, compteur d'actions en temps réel et félicitations en fin de session.
+
+---
+
+*Document généré par l'Assistant pour RPA Vision V3 - Mars 2026*

agent_v0/agent_v1/config.py

@@ -0,0 +1,140 @@
+# agent_v1/config.py
+"""
+Configuration avancée pour Agent V1.
+"""
+from __future__ import annotations
+import os
+import platform
+import socket
+from pathlib import Path
+
+# --- DPI awareness (DOIT etre appele avant tout import de pynput/mss/tkinter) ---
+# Rend le process DPI-aware sur Windows pour que toutes les API (pynput, mss, pyautogui)
+# travaillent en coordonnees physiques (pixels reels) au lieu de coordonnees logiques
+# (virtualisees par le DPI scaling).
+# Sans cet appel, un ecran 2560x1600 a 150% DPI apparait comme 1707x1067 pour les API,
+# ce qui cause des erreurs de positionnement pendant le replay.
+# Sur Linux/Mac : no-op silencieux.
+# PROCESS_PER_MONITOR_DPI_AWARE = 2 : le niveau le plus precis.
+if platform.system() == "Windows":
+    try:
+        import ctypes
+        ctypes.windll.shcore.SetProcessDpiAwareness(2)  # PROCESS_PER_MONITOR_DPI_AWARE
+    except Exception:
+        try:
+            # Fallback pour Windows < 8.1 (API plus ancienne)
+            ctypes.windll.user32.SetProcessDPIAware()
+        except Exception:
+            pass
+
+AGENT_VERSION = os.environ.get("RPA_AGENT_VERSION", "1.0.2")
+
+# Identifiant unique de la machine (utilisé pour le multi-machine)
+# Configurable via variable d'environnement, sinon auto-généré depuis hostname + OS
+MACHINE_ID = os.environ.get(
+    "RPA_MACHINE_ID",
+    f"{socket.gethostname()}_{platform.system().lower()}",
+)
+
+# Dossier racine de l'agent
+BASE_DIR = Path(__file__).resolve().parent
+
+# Endpoint du serveur Streaming (port 5005)
+# SERVER_URL contient TOUJOURS /api/v1 à la fin (convention unifiée).
+SERVER_URL = os.getenv("RPA_SERVER_URL", "http://localhost:5005/api/v1")
+# Base sans /api/v1 — pour les routes à la racine (/health)
+SERVER_BASE = SERVER_URL.rsplit("/api/v1", 1)[0]
+UPLOAD_ENDPOINT = f"{SERVER_URL}/traces/upload"
+STREAMING_ENDPOINT = f"{SERVER_URL}/traces/stream"
+
+# Host Ollama — SÉPARÉ du serveur RPA.
+# Ollama tourne en local sur la machine serveur, jamais exposé via le reverse proxy.
+# Défaut : localhost (exécution locale ou accès LAN direct).
+OLLAMA_HOST = os.getenv("RPA_OLLAMA_HOST", "localhost")
+
+# Token d'authentification API (doit correspondre au token du serveur)
+# Configurable via variable d'environnement RPA_API_TOKEN
+API_TOKEN = os.environ.get("RPA_API_TOKEN", "")
+
+# --- Orchestrateur Léa-first (agent-chat Linux) ---
+# Endpoint racine du service agent-chat qui héberge POST /api/learn/start
+# (P1-LEA-SHADOW). Configurable via RPA_AGENT_CHAT_URL.
+# Défaut : localhost:5004 (même machine en dev). En POC clinique, doit
+# pointer vers le DGX Spark (ex. http://agent-chat.dgx-local:5004).
+AGENT_CHAT_URL = os.environ.get("RPA_AGENT_CHAT_URL", "http://localhost:5004")
+
+# Paramètres de session
+MAX_SESSION_DURATION_S = 60 * 60  # 1 heure
+SESSIONS_ROOT = BASE_DIR / "sessions"
+
+# Paramètres Vision (Crops pour la résolution visuelle)
+# 80x80 : assez petit pour être discriminant (icônes), assez grand pour le contexte
+TARGETED_CROP_SIZE = (80, 80)
+SCREENSHOT_QUALITY = 85
+
+# Floutage des données sensibles (conformité AI Act)
+# Floute les champs de saisie dans les screenshots AVANT stockage/envoi
+# Désactiver avec RPA_BLUR_SENSITIVE=false pour le développement/tests
+BLUR_SENSITIVE = os.environ.get("RPA_BLUR_SENSITIVE", "true").lower() in ("true", "1", "yes")
+
+# Retention des logs — minimum 6 mois (180 jours) requis par le Reglement IA
+# (Article 12 — journalisation automatique, Article 26(6) — conservation minimum)
+# Configurable via variable d'environnement pour permettre l'ajustement
+LOG_RETENTION_DAYS = int(os.environ.get("RPA_LOG_RETENTION_DAYS", "180"))
+
+# Remontée automatique des logs vers le serveur (push-log-DGX).
+# Diagnostic des postes clinique SANS AnyDesk : les logs (déjà écrits sur disque)
+# sont poussés au serveur, rangés par machine_id, consultables au dashboard.
+# Défaut PRUDENT = désactivé : on l'active poste par poste via config.txt /
+# variable d'environnement, sans rebuild de l'installateur.
+LOG_SHIP_ENABLED = os.environ.get("RPA_LOG_SHIP_ENABLED", "false").lower() in (
+    "true", "1", "yes",
+)
+# Intervalle de flush du buffer de logs (secondes).
+LOG_SHIP_INTERVAL_S = float(os.environ.get("RPA_LOG_SHIP_INTERVAL_S", "30"))
+
+# Mise à jour silencieuse du client Léa (DETTE-022 v2).
+# Le client interroge le serveur (GET /api/v1/agents/update/check), télécharge
+# le ZIP en staging et vérifie le SHA256. Le SWAP réel des fichiers / l'édition
+# de Lea.bat / le redémarrage restent RÉSERVÉS RÉVISION HUMAINE (voir
+# network/updater.py : stubs apply_update / write_boot_ok_marker).
+# Défaut PRUDENT = désactivé : activé poste par poste via config.txt / variable
+# d'environnement, sans rebuild de l'installateur (même esprit que LOG_SHIP).
+AUTO_UPDATE_ENABLED = os.environ.get("RPA_AUTO_UPDATE_ENABLED", "false").lower() in (
+    "true", "1", "yes", "on",
+)
+# Intervalle entre deux interrogations serveur pour une MAJ (secondes).
+# Défaut 1 h : une MAJ n'est jamais urgente ; on interroge peu pour ne pas
+# charger le réseau clinique. Le check ne fait de toute façon aucun swap.
+AUTO_UPDATE_INTERVAL_S = float(os.environ.get("RPA_AUTO_UPDATE_INTERVAL_S", "3600"))
+# Dossier de STAGING des ZIP d'update (jamais les fichiers vivants). Équivalent
+# de `Lea_next\\`. Sous LOCALAPPDATA en prod Windows, sinon à côté de l'agent.
+AUTO_UPDATE_STAGING_DIR = os.environ.get(
+    "RPA_AUTO_UPDATE_STAGING_DIR",
+    str(BASE_DIR / "_update_staging"),
+)
+
+# Monitoring
+PERF_MONITOR_INTERVAL_S = 30
+LOGS_DIR = BASE_DIR / "logs"
+LOG_FILE = LOGS_DIR / "agent_v1.log"
+
+# --- Métadonnées système (capturées au chargement du module) ---
+# Utilisées pour la bannière de démarrage et le diagnostic.
+# Import tardif pour éviter les dépendances circulaires.
+try:
+    from .vision.system_info import get_dpi_scale, get_os_theme, get_monitor_info
+    _monitor_index, _monitors = get_monitor_info()
+    _primary = _monitors[0] if _monitors else {"width": 1920, "height": 1080}
+    SCREEN_RESOLUTION = (_primary["width"], _primary["height"])
+    DPI_SCALE = get_dpi_scale()
+    OS_THEME = get_os_theme()
+except Exception:
+    # Fallback silencieux si les métadonnées ne sont pas disponibles
+    SCREEN_RESOLUTION = (1920, 1080)
+    DPI_SCALE = 100
+    OS_THEME = "unknown"
+
+# Création des dossiers
+os.makedirs(SESSIONS_ROOT, exist_ok=True)
+os.makedirs(LOGS_DIR, exist_ok=True)

agent_v0/agent_v1/core/anchor_catalog.py

@@ -0,0 +1,82 @@
+"""Catalog d'ancres visuelles — Phase 1 standalone.
+
+Ce module fournit un catalog Python (pas YAML) listant les trios
+(window_title, anchor_label, target_label) connus pour lesquels la
+résolution par triangulation visuelle est applicable.
+
+Phase 1 : non branché au runtime, prouvé sur fixtures par
+`tests/unit/test_anchor_relative.py`.
+
+Edition simple : ajouter une entrée à `ANCHOR_ENTRIES`.
+Validation : `find_entry_for_title(title)` retourne la première entrée
+dont un `title_patterns` matche (case-insensitive, substring).
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+
+# Catalog des entrées d'ancres visuelles connues.
+#
+# Format d'une entrée :
+#   id (str)                : identifiant stable pour audit
+#   title_patterns (tuple)  : sous-chaines case-insensitive du titre fenêtre
+#   anchor_label (list)     : labels d'ancres a essayer dans l'ordre (FR puis EN)
+#   target_label (str)      : libelle cible (ex. "Enregistrer")
+#   geometry_hint (dict)    :
+#       region (str)        : indicatif ("bottom-right", "bottom-center", ...)
+#       min_x_norm/min_y_norm/max_x_norm/max_y_norm (float) : zone valide
+#                              (normalisée 0..1 sur la fenêtre/écran)
+#       offset_from_anchor (dict) : {"x_px": int, "y_px": int} delta ancre→cible
+ANCHOR_ENTRIES: List[Dict[str, Any]] = [
+    {
+        "id": "notepad_save_as_enregistrer",
+        "title_patterns": ("enregistrer sous", "save as"),
+        "anchor_label": ["Annuler", "Cancel"],
+        "target_label": "Enregistrer",
+        "geometry_hint": {
+            "region": "bottom-right",
+            "min_x_norm": 0.55,
+            "min_y_norm": 0.75,
+            "max_x_norm": 1.0,
+            "max_y_norm": 1.0,
+            "offset_from_anchor": {"x_px": -100, "y_px": 0},
+        },
+    },
+    {
+        "id": "notepad_unsaved_changes_enregistrer",
+        "title_patterns": ("bloc-notes", "notepad"),
+        "anchor_label": ["Ne pas enregistrer", "Don't Save"],
+        "target_label": "Enregistrer",
+        "geometry_hint": {
+            "region": "bottom-center",
+            "min_x_norm": 0.30,
+            "min_y_norm": 0.50,
+            "max_x_norm": 0.85,
+            "max_y_norm": 1.0,
+            "offset_from_anchor": {"x_px": -120, "y_px": 0},
+        },
+    },
+]
+
+
+def find_entry_for_title(title: str) -> Optional[Dict[str, Any]]:
+    """Retourne la première entrée dont un title_pattern matche (substring CI).
+
+    Args:
+        title: titre de fenêtre courant (ex. "Enregistrer sous").
+
+    Returns:
+        L'entrée catalog matchante, ou None si aucun match.
+        Aucun raise — l'absence de match est un cas normal.
+    """
+    if not title:
+        return None
+    title_lower = title.lower()
+    for entry in ANCHOR_ENTRIES:
+        patterns = entry.get("title_patterns") or ()
+        for pat in patterns:
+            if pat and pat.lower() in title_lower:
+                return entry
+    return None

agent_v0/agent_v1/core/anchor_relative.py

@@ -0,0 +1,292 @@
+"""Localisation par triangulation depuis une ancre visuelle.
+
+Module standalone Phase 1 — non branché au runtime.
+
+Principe : étant donnée une ancre texte fiable (ex. "Annuler"),
+localiser une cible voisine ("Enregistrer") par offset géométrique.
+Validation optionnelle par cross-check du label cible.
+
+Détecteur injectable (`detector=`) pour faciliter les tests offline ;
+au runtime (Phase 2), on injectera `ActionExecutorV1._find_text_on_screen`.
+
+Pas de dépendance nouvelle. Pas de VLM, pas d'UIA, pas de persistance.
+"""
+
+from __future__ import annotations
+
+import base64
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, Optional, Tuple
+
+# Type alias : un détecteur prend (screenshot_b64, label) et retourne
+# (x_px, y_px) ou None.
+DetectorFn = Callable[[str, str], Optional[Tuple[int, int]]]
+
+
+@dataclass
+class AnchorMatch:
+    """Résultat d'une recherche par ancre relative.
+
+    Tous les champs sont remplis même si `found=False` (zéros pour les
+    coordonnées, reason explicite, evidence pour audit).
+    """
+
+    found: bool
+    target_x_pct: float
+    target_y_pct: float
+    anchor_x_pct: float
+    anchor_y_pct: float
+    confidence: float
+    reason: str
+    evidence: Dict[str, Any] = field(default_factory=dict)
+
+
+def _default_detector(screenshot_b64: str, label: str) -> Optional[Tuple[int, int]]:
+    """Détecteur OCR par défaut : rendu TTF + cv2.matchTemplate.
+
+    Reprend la logique de `ActionExecutorV1._find_text_on_screen`
+    (executor.py:3277) sans dépendre de l'instance ActionExecutorV1
+    (qui amène mss/pynput inutiles ici).
+    """
+    try:
+        from PIL import Image, ImageDraw, ImageFont
+        import cv2
+        import numpy as np
+    except ImportError:
+        return None
+
+    if not label or not screenshot_b64:
+        return None
+
+    try:
+        img_bytes = base64.b64decode(screenshot_b64)
+        img_array = np.frombuffer(img_bytes, dtype=np.uint8)
+        screenshot_bgr = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
+        if screenshot_bgr is None:
+            return None
+        gray = cv2.cvtColor(screenshot_bgr, cv2.COLOR_BGR2GRAY)
+    except Exception:
+        return None
+
+    font_paths = [
+        "C:/Windows/Fonts/arial.ttf",
+        "C:/Windows/Fonts/segoeui.ttf",
+        "C:/Windows/Fonts/tahoma.ttf",
+        "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
+        "/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf",
+    ]
+
+    def _get_font(size: int):
+        for fp in font_paths:
+            try:
+                return ImageFont.truetype(fp, size)
+            except (OSError, IOError):
+                continue
+        return ImageFont.load_default()
+
+    best_match: Optional[Tuple[int, int]] = None
+    best_val = 0.0
+    threshold = 0.75
+
+    for font_size in (14, 16, 18, 20, 22, 24, 12, 26, 28, 10):
+        font = _get_font(font_size)
+        tmp = Image.new("L", (1, 1), 255)
+        tmp_draw = ImageDraw.Draw(tmp)
+        bbox = tmp_draw.textbbox((0, 0), label, font=font)
+        text_w = bbox[2] - bbox[0] + 6
+        text_h = bbox[3] - bbox[1] + 6
+        if text_w <= 0 or text_h <= 0:
+            continue
+        if text_w >= gray.shape[1] or text_h >= gray.shape[0]:
+            continue
+        text_img = Image.new("L", (text_w, text_h), 255)
+        draw = ImageDraw.Draw(text_img)
+        draw.text((3, 3), label, fill=0, font=font)
+        template = np.array(text_img)
+        result = cv2.matchTemplate(gray, template, cv2.TM_CCOEFF_NORMED)
+        _, max_val, _, max_loc = cv2.minMaxLoc(result)
+        if max_val > best_val:
+            best_val = max_val
+            best_match = (
+                max_loc[0] + template.shape[1] // 2,
+                max_loc[1] + template.shape[0] // 2,
+            )
+        if max_val > 0.75:
+            break
+
+    if best_match and best_val >= threshold:
+        return best_match
+    return None
+
+
+def _try_detect(
+    detector: DetectorFn,
+    screenshot_b64: str,
+    labels: Any,
+) -> Tuple[Optional[Tuple[int, int]], str]:
+    """Essaye chaque label de la liste (ou string unique) jusqu'à un hit.
+
+    Retourne (position_px, label_qui_a_matche) ou (None, "").
+    """
+    if isinstance(labels, str):
+        labels_list = [labels]
+    else:
+        labels_list = list(labels or [])
+    for label in labels_list:
+        pos = detector(screenshot_b64, label)
+        if pos:
+            return pos, label
+    return None, ""
+
+
+def _is_in_zone(
+    x_norm: float,
+    y_norm: float,
+    geometry_hint: Dict[str, Any],
+) -> bool:
+    """Vérifie que (x_norm, y_norm) tombe dans la zone du geometry_hint."""
+    min_x = float(geometry_hint.get("min_x_norm", 0.0))
+    max_x = float(geometry_hint.get("max_x_norm", 1.0))
+    min_y = float(geometry_hint.get("min_y_norm", 0.0))
+    max_y = float(geometry_hint.get("max_y_norm", 1.0))
+    return (min_x <= x_norm <= max_x) and (min_y <= y_norm <= max_y)
+
+
+def find_target_via_anchor(
+    anchor_label: Any,
+    target_label: str,
+    geometry_hint: Dict[str, Any],
+    screenshot_b64: str,
+    screen_width: int,
+    screen_height: int,
+    detector: Optional[DetectorFn] = None,
+    cross_check_target: bool = True,
+) -> AnchorMatch:
+    """Localise `target_label` par triangulation depuis `anchor_label`.
+
+    Args:
+        anchor_label: label (str) ou liste de labels essayés dans l'ordre
+            (ex. ["Annuler", "Cancel"] pour fallback FR→EN).
+        target_label: libellé cible (ex. "Enregistrer"). Utilisé pour le
+            cross-check uniquement.
+        geometry_hint: dict décrivant la zone valide pour l'ancre et
+            l'offset ancre→cible. Voir `anchor_catalog.ANCHOR_ENTRIES`
+            pour le format exact.
+        screenshot_b64: capture encodée base64 (JPEG/PNG).
+        screen_width: largeur de référence en pixels (écran ou fenêtre).
+        screen_height: hauteur de référence en pixels.
+        detector: callable (b64, label) → (x_px, y_px) | None. Si None,
+            utilise un détecteur OCR par défaut (rendu TTF + cv2).
+            Pour les tests, injecter un mock.
+        cross_check_target: si True (défaut), tente de détecter aussi
+            `target_label` près de la position candidate et ajuste la
+            confidence en conséquence.
+
+    Returns:
+        AnchorMatch toujours retourné (jamais None). `found=False` si
+        l'ancre n'est pas trouvée ou hors zone ; `reason` explique.
+    """
+    det = detector or _default_detector
+    ev: Dict[str, Any] = {
+        "anchor_candidates_tried": (
+            list(anchor_label) if not isinstance(anchor_label, str) else [anchor_label]
+        ),
+        "target_label": target_label,
+        "geometry_hint": geometry_hint,
+    }
+
+    # 1. Détection ancre (FR puis EN)
+    anchor_px, matched_anchor_label = _try_detect(det, screenshot_b64, anchor_label)
+    if not anchor_px:
+        return AnchorMatch(
+            found=False,
+            target_x_pct=0.0,
+            target_y_pct=0.0,
+            anchor_x_pct=0.0,
+            anchor_y_pct=0.0,
+            confidence=0.0,
+            reason="anchor_not_found",
+            evidence=ev,
+        )
+
+    ax, ay = anchor_px
+    anchor_x_pct = ax / float(screen_width) if screen_width else 0.0
+    anchor_y_pct = ay / float(screen_height) if screen_height else 0.0
+    ev["anchor_matched_label"] = matched_anchor_label
+    ev["anchor_px"] = [ax, ay]
+    ev["anchor_norm"] = [anchor_x_pct, anchor_y_pct]
+
+    # 2. Garde géométrique : ancre dans la zone autorisée
+    if not _is_in_zone(anchor_x_pct, anchor_y_pct, geometry_hint):
+        return AnchorMatch(
+            found=False,
+            target_x_pct=0.0,
+            target_y_pct=0.0,
+            anchor_x_pct=anchor_x_pct,
+            anchor_y_pct=anchor_y_pct,
+            confidence=0.0,
+            reason="anchor_out_of_zone",
+            evidence=ev,
+        )
+
+    # 3. Déduction position cible par offset
+    offset = geometry_hint.get("offset_from_anchor", {}) or {}
+    dx = int(offset.get("x_px", 0))
+    dy = int(offset.get("y_px", 0))
+    target_x_px = ax + dx
+    target_y_px = ay + dy
+    target_x_pct = target_x_px / float(screen_width) if screen_width else 0.0
+    target_y_pct = target_y_px / float(screen_height) if screen_height else 0.0
+    ev["target_px_from_offset"] = [target_x_px, target_y_px]
+
+    if not (0.0 <= target_x_pct <= 1.0 and 0.0 <= target_y_pct <= 1.0):
+        return AnchorMatch(
+            found=False,
+            target_x_pct=target_x_pct,
+            target_y_pct=target_y_pct,
+            anchor_x_pct=anchor_x_pct,
+            anchor_y_pct=anchor_y_pct,
+            confidence=0.0,
+            reason="target_out_of_bounds",
+            evidence=ev,
+        )
+
+    # 4. Cross-check : tenter de détecter target_label
+    confidence = 0.5  # ancre seule
+    reason = "anchor_only"
+    if cross_check_target and target_label:
+        target_pos = det(screenshot_b64, target_label)
+        if target_pos:
+            tx, ty = target_pos
+            dist_px = ((tx - target_x_px) ** 2 + (ty - target_y_px) ** 2) ** 0.5
+            ev["target_detected_px"] = [tx, ty]
+            ev["target_cross_check_dist_px"] = round(dist_px, 1)
+            # Tolerance proche de l'offset (cf. design 2200 §3.2)
+            if dist_px <= 50:
+                # Cross-check OK : on raffine sur la position détectée
+                target_x_px, target_y_px = tx, ty
+                target_x_pct = tx / float(screen_width) if screen_width else 0.0
+                target_y_pct = ty / float(screen_height) if screen_height else 0.0
+                confidence = 0.85
+                reason = "anchor_plus_target_cross_check"
+            else:
+                # target_label détecté mais loin de l'offset attendu : suspect.
+                # On garde la position offset mais on dégrade confidence.
+                confidence = 0.4
+                reason = "anchor_ok_target_drift_high"
+        else:
+            # Cross-check absent : comportement documenté (cf. test 7).
+            # On garde la position offset mais confidence reste à 0.5.
+            ev["target_cross_check_dist_px"] = None
+            reason = "anchor_only_target_not_visible"
+
+    return AnchorMatch(
+        found=True,
+        target_x_pct=target_x_pct,
+        target_y_pct=target_y_pct,
+        anchor_x_pct=anchor_x_pct,
+        anchor_y_pct=anchor_y_pct,
+        confidence=confidence,
+        reason=reason,
+        evidence=ev,
+    )

agent_v0/agent_v1/core/captor.py

@@ -0,0 +1,715 @@
+# agent_v1/core/captor.py
+"""
+Moteur de capture d'événements Agent V1.
+Capture enrichie avec focus sur le contexte UI pour le stagiaire.
+
+Fonctionnalités :
+- Capture clics souris (simple et double-clic)
+- Capture scroll souris
+- Capture combos clavier (Ctrl+C, Alt+Tab, etc.)
+- Buffer de saisie texte : accumule les frappes et émet un événement
+  text_input après 500ms d'inactivité clavier
+- Surveillance du focus fenêtre
+
+NOTE DPI : Les coordonnees retournees par pynput dependent du DPI awareness
+du process. Quand SetProcessDpiAwareness(2) est appele (dans config.py),
+pynput retourne des coordonnees en pixels PHYSIQUES. Les metadonnees
+screen_metadata (resolution via mss) sont aussi en pixels physiques.
+Ceci garantit que la normalisation pos/resolution est coherente.
+Sans DPI awareness, pynput retourne des coordonnees LOGIQUES mais mss
+retourne des pixels physiques, ce qui cause une erreur de normalisation.
+"""
+
+import threading
+import time
+import logging
+import platform
+from typing import Callable, Optional, List, Dict, Any, Tuple
+from pynput import mouse, keyboard
+from pynput.mouse import Button
+from pynput.keyboard import Key, KeyCode
+
+# Importation relative pour rester dans le module v1
+from ..vision.capturer import VisionCapturer
+from ..vision.system_info import get_screen_metadata
+from .log_safe import _sanitize_metadata
+# from ..monitoring.system import SystemMonitor
+
+logger = logging.getLogger(__name__)
+
+# Détection Windows une seule fois au chargement du module
+IS_WINDOWS = platform.system() == "Windows"
+
+# Délai d'inactivité avant flush du buffer texte (en secondes)
+TEXT_FLUSH_DELAY = 0.5
+# Délai max entre deux clics pour un double-clic (en secondes)
+DOUBLE_CLICK_DELAY = 0.3
+# Tolérance en pixels pour considérer deux clics au même endroit
+DOUBLE_CLICK_TOLERANCE = 10
+
+
+class EventCaptorV1:
+    def __init__(self, on_event_callback: Callable[[Dict[str, Any]], None]):
+        self.on_event = on_event_callback
+        self.mouse_listener = None
+        self.keyboard_listener = None
+        self.running = False
+
+        # État des touches modificatrices
+        self.modifiers = set()
+        self._pending_standalone_win = False
+        self._suppress_release_only_win_combo = False
+
+        # Tracking du focus fenêtre
+        self.last_window = None
+        self._focus_thread = None
+
+        # --- Buffer de saisie texte ---
+        # Lock pour accès thread-safe au buffer (le listener pynput
+        # tourne dans un thread séparé)
+        self._text_lock = threading.Lock()
+        self._text_buffer: list[str] = []
+        # Position de la souris au moment de la première frappe du buffer
+        self._text_start_pos: Optional[Tuple[int, int]] = None
+        # Timer pour le flush après inactivité
+        self._text_flush_timer: Optional[threading.Timer] = None
+        # Compteur de génération pour éviter qu'un timer obsolète ne flush
+        # un buffer en cours de remplissage (race condition). Incrémenté
+        # à chaque reset du timer. Le timer ne flush que si la génération
+        # n'a pas changé.
+        self._text_flush_generation: int = 0
+        # Dernière position connue de la souris (pour associer le texte
+        # au champ dans lequel l'utilisateur tape)
+        self._last_mouse_pos: Tuple[int, int] = (0, 0)
+
+        # --- Détection double-clic ---
+        # Dernier clic : (x, y, timestamp, button)
+        self._last_click: Optional[Tuple[int, int, float, str]] = None
+
+        # --- Buffer de raw_keys (press/release bruts avec vk codes) ---
+        # Accumule chaque press/release pour le replay exact (solution AZERTY).
+        # Vidé en même temps que le text_buffer ou à l'émission d'un key_combo.
+        self._raw_key_buffer: List[Dict[str, Any]] = []
+
+        # --- Métadonnées système (DPI, résolution, moniteur, thème, langue) ---
+        # Capturées au démarrage puis rafraîchies à chaque changement de focus.
+        # Injectées dans chaque événement via le champ "screen_metadata".
+        self._screen_metadata: Dict[str, Any] = {}
+        self._screen_metadata_lock = threading.Lock()
+
+    def start(self):
+        self.running = True
+        self.mouse_listener = mouse.Listener(
+            on_click=self._on_click,
+            on_scroll=self._on_scroll,
+            on_move=self._on_move
+        )
+        self.keyboard_listener = keyboard.Listener(
+            on_press=self._on_press,
+            on_release=self._on_release
+        )
+
+        self.mouse_listener.start()
+        self.keyboard_listener.start()
+
+        # Capture initiale des métadonnées système
+        self._refresh_screen_metadata()
+
+        # Thread de surveillance du focus fenêtre (Proactif)
+        self._focus_thread = threading.Thread(target=self._watch_window_focus, daemon=True)
+        self._focus_thread.start()
+
+        logger.info("Agent V1 Captor démarré")
+
+    def stop(self):
+        self.running = False
+        # Flush du buffer texte restant avant arrêt
+        self._flush_text_buffer()
+        # Annuler le timer s'il est en cours
+        with self._text_lock:
+            if self._text_flush_timer is not None:
+                self._text_flush_timer.cancel()
+                self._text_flush_timer = None
+        if self.mouse_listener: self.mouse_listener.stop()
+        if self.keyboard_listener: self.keyboard_listener.stop()
+        logger.info("Agent V1 Captor arrêté")
+
+    # ----------------------------------------------------------------
+    # Souris
+    # ----------------------------------------------------------------
+
+    def _on_move(self, x, y):
+        """Mémorise la position souris pour l'associer aux événements texte."""
+        self._last_mouse_pos = (x, y)
+
+    def _on_click(self, x, y, button, pressed):
+        if not pressed:
+            return
+
+        now = time.time()
+
+        # --- Flush du buffer texte : l'utilisateur a cliqué, donc
+        # il change probablement de champ ---
+        self._flush_text_buffer()
+
+        # --- Détection double-clic ---
+        if self._last_click is not None:
+            lx, ly, lt, lb = self._last_click
+            # Même bouton, même zone, délai court → double-clic
+            if (button.name == lb
+                    and abs(x - lx) <= DOUBLE_CLICK_TOLERANCE
+                    and abs(y - ly) <= DOUBLE_CLICK_TOLERANCE
+                    and (now - lt) <= DOUBLE_CLICK_DELAY):
+                event = {
+                    "type": "double_click",
+                    "button": button.name,
+                    "pos": (x, y),
+                    "timestamp": now,
+                }
+                self._inject_screen_metadata(event)
+                self.on_event(event)
+                # Réinitialiser pour éviter un triple-clic = 2 double-clics
+                self._last_click = None
+                return
+
+        # Clic simple — on le mémorise pour comparer au prochain
+        self._last_click = (x, y, now, button.name)
+        event = {
+            "type": "mouse_click",
+            "button": button.name,
+            "pos": (x, y),
+            "timestamp": now,
+        }
+        self._inject_screen_metadata(event)
+        # Capturer le snapshot UIA à la position du clic (si helper dispo)
+        # Non-bloquant : si UIA échoue, l'event est enrichi uniquement
+        # des données vision comme aujourd'hui.
+        self._inject_uia_snapshot(event, x, y)
+        self.on_event(event)
+
+    def _inject_uia_snapshot(self, event: dict, x: int, y: int) -> None:
+        """Ajouter un uia_snapshot à l'événement si le helper UIA est dispo.
+
+        Appelle lea_uia.exe query --x N --y N en ~10-20ms.
+        Fallback silencieux si le helper n'est pas dispo ou échoue.
+        """
+        try:
+            from .uia_helper import get_shared_helper
+            helper = get_shared_helper()
+            if not helper.available:
+                return
+            element = helper.query_at(int(x), int(y), with_parents=True)
+            if element is None:
+                return
+            event["uia_snapshot"] = {
+                "name": element.name,
+                "control_type": element.control_type,
+                "class_name": element.class_name,
+                "automation_id": element.automation_id,
+                "bounding_rect": list(element.bounding_rect),
+                "is_enabled": element.is_enabled,
+                "is_offscreen": element.is_offscreen,
+                "parent_path": element.parent_path,
+            }
+        except Exception as e:
+            # Non bloquant — on continue sans UIA
+            import logging
+            logging.getLogger(__name__).debug(f"UIA snapshot skip: {e}")
+
+    def _on_scroll(self, x, y, dx, dy):
+        event = {
+            "type": "mouse_scroll",
+            "pos": (x, y),
+            "delta": (dx, dy),
+            "timestamp": time.time(),
+        }
+        self.on_event(event)
+
+    # ----------------------------------------------------------------
+    # Clavier
+    # ----------------------------------------------------------------
+
+    @staticmethod
+    def _get_key_name(key) -> Optional[str]:
+        """Convertit un objet pynput Key/KeyCode en nom lisible."""
+        if isinstance(key, KeyCode):
+            return key.char if key.char else None
+        if isinstance(key, Key):
+            return key.name
+        return str(key)
+
+    # Ensemble des touches considérées comme modificateurs purs.
+    # Utilisé pour ne PAS émettre de key_combo quand seuls des
+    # modificateurs sont enfoncés (évite le bruit).
+    _MODIFIER_KEYS = {
+        Key.ctrl, Key.ctrl_l, Key.ctrl_r,
+        Key.alt, Key.alt_l, Key.alt_r,
+        Key.shift, Key.shift_l, Key.shift_r,
+        Key.cmd, Key.cmd_l, Key.cmd_r,
+    }
+    _MODIFIER_KEY_NAMES = {
+        "ctrl", "ctrl_l", "ctrl_r",
+        "alt", "alt_l", "alt_r",
+        "shift", "shift_l", "shift_r",
+        "cmd", "cmd_l", "cmd_r",
+    }
+
+    @staticmethod
+    def _vk_to_char(vk_code: int) -> Optional[str]:
+        """Convertir un virtual key code en caractère réel (AZERTY-aware).
+
+        Utilise ToUnicodeEx avec le layout clavier actif pour obtenir
+        le bon caractère même pour les touches AltGr, Shift+chiffres,
+        et autres combinaisons spécifiques au layout (AZERTY, QWERTZ, etc.).
+
+        Ne fonctionne que sur Windows. Retourne None sur Linux/Mac.
+        """
+        if not IS_WINDOWS:
+            return None
+        try:
+            import ctypes
+            import ctypes.wintypes as wt
+            user32 = ctypes.windll.user32
+
+            kbd_state = (ctypes.c_ubyte * 256)()
+            user32.GetKeyboardState(kbd_state)
+
+            buf = (ctypes.c_wchar * 8)()
+            scan = user32.MapVirtualKeyW(vk_code, 0)
+
+            # Layout du thread de la fenêtre active (gère AZERTY, QWERTZ, etc.)
+            hwnd = user32.GetForegroundWindow()
+            tid = user32.GetWindowThreadProcessId(hwnd, None)
+            hkl = user32.GetKeyboardLayout(tid)
+
+            n = user32.ToUnicodeEx(vk_code, scan, kbd_state, buf, 8, 0, hkl)
+            if n > 0:
+                return buf[0]
+        except Exception:
+            pass
+        return None
+
+    def _is_altgr_producing_char(self, key) -> Optional[str]:
+        """Détecte si la combinaison actuelle est AltGr+touche produisant un caractère.
+
+        Sur Windows AZERTY, AltGr est envoyé comme Ctrl+Alt par pynput.
+        Cette méthode vérifie si Ctrl+Alt est enfoncé et que la touche
+        produit un caractère imprimable via le layout clavier.
+        Ex: AltGr+é → ~, AltGr+( → {, AltGr+à → @
+
+        Retourne le caractère produit ou None si ce n'est pas un AltGr valide.
+        """
+        if not IS_WINDOWS:
+            return None
+        # AltGr = Ctrl+Alt (sans Win) sur Windows
+        if self.modifiers != {"ctrl", "alt"} and self.modifiers != {"ctrl", "alt", "shift"}:
+            return None
+        # Ne s'applique qu'aux touches non-modificatrices
+        if key in self._MODIFIER_KEYS:
+            return None
+        # Essayer de résoudre le caractère via ToUnicodeEx
+        # Le keyboard state inclut déjà Ctrl+Alt (= AltGr) grâce à GetKeyboardState
+        vk = getattr(key, 'vk', None)
+        if vk is not None:
+            char = self._vk_to_char(vk)
+            if char is not None and len(char) == 1 and (char.isprintable() and char != ' '):
+                return char
+        return None
+
+    @staticmethod
+    def _encode_key(key) -> Dict[str, Any]:
+        """Encode un objet pynput Key/KeyCode en dictionnaire sérialisable.
+
+        Utilisé pour constituer le buffer raw_keys (séquence press/release
+        exacte avec virtual key codes) qui permet un replay fidèle
+        indépendant du layout clavier (AZERTY, QWERTZ, etc.).
+        """
+        if isinstance(key, KeyCode):
+            return {"kind": "vk", "vk": key.vk, "char": key.char}
+        if isinstance(key, Key):
+            return {"kind": "key", "name": key.name}
+        return {"kind": "unknown", "str": str(key)}
+
+    @staticmethod
+    def _raw_key_name(raw_key: Dict[str, Any]) -> Optional[str]:
+        """Nom lisible depuis un raw_key sérialisé."""
+        if raw_key.get("kind") == "vk":
+            char = raw_key.get("char")
+            if char and len(str(char)) == 1:
+                return str(char).lower()
+        if raw_key.get("kind") == "key":
+            name = raw_key.get("name")
+            return str(name).lower() if name else None
+        return None
+
+    def _emit_release_only_windows_combo(self) -> bool:
+        """Infère Win+<touche> si Windows/NoMachine n'a livré que les releases.
+
+        Certaines sessions ne remontent pas les press de Win+S via pynput,
+        mais livrent ensuite release('s') puis release('cmd'). Sans cette
+        inférence ciblée, le geste système est perdu et les releases polluent
+        le prochain text_input.
+        """
+        with self._text_lock:
+            raw_keys = list(self._raw_key_buffer)
+            if len(raw_keys) < 2:
+                return False
+            cmd_names = {"cmd", "cmd_l", "cmd_r"}
+            last = raw_keys[-1]
+            if last.get("action") != "release" or self._raw_key_name(last) not in cmd_names:
+                return False
+            combo_key = None
+            for raw in reversed(raw_keys[:-1]):
+                if raw.get("action") != "release":
+                    continue
+                name = self._raw_key_name(raw)
+                if name and name not in self._MODIFIER_KEY_NAMES:
+                    combo_key = name
+                    break
+            if not combo_key:
+                return False
+            self._raw_key_buffer.clear()
+
+        event = {
+            "type": "key_combo",
+            "keys": ["win", combo_key],
+            "raw_keys": raw_keys,
+            "timestamp": time.time(),
+        }
+        self._inject_screen_metadata(event)
+        self.on_event(event)
+        return True
+
+    def _on_press(self, key):
+        # TOUJOURS enregistrer le press brut dans le buffer raw_keys
+        with self._text_lock:
+            self._raw_key_buffer.append({
+                "action": "press",
+                **self._encode_key(key),
+            })
+
+        # Gestion des touches modificatrices
+        if key in (Key.ctrl, Key.ctrl_l, Key.ctrl_r):
+            self.modifiers.add("ctrl")
+        elif key in (Key.alt, Key.alt_l, Key.alt_r):
+            self.modifiers.add("alt")
+        elif key in (Key.shift, Key.shift_l, Key.shift_r):
+            self.modifiers.add("shift")
+        elif key in (Key.cmd, Key.cmd_l, Key.cmd_r):
+            self.modifiers.add("win")
+            self._pending_standalone_win = True
+
+        # --- Combos avec modificateur (sauf Shift seul) ---
+        # Shift seul n'est pas un « vrai » modificateur pour les combos :
+        # Shift+a = 'A' = saisie texte, pas un raccourci.
+        # On considère un combo seulement si Ctrl, Alt ou Win est enfoncé.
+        has_real_modifier = self.modifiers & {"ctrl", "alt", "win"}
+        if has_real_modifier:
+            # --- Détection AltGr (Windows AZERTY) ---
+            # Sur Windows, AltGr est envoyé comme Ctrl+Alt par le système.
+            # Avant de traiter comme un key_combo, vérifier si c'est
+            # AltGr qui produit un caractère imprimable (@, #, {, }, etc.)
+            altgr_char = self._is_altgr_producing_char(key)
+            if altgr_char is not None:
+                # C'est un caractère AltGr → router vers le buffer texte
+                with self._text_lock:
+                    if not self._text_buffer:
+                        self._text_start_pos = self._last_mouse_pos
+                    self._text_buffer.append(altgr_char)
+                    self._reset_flush_timer()
+                return
+
+            key_name = self._get_key_name(key)
+            # Ne PAS émettre de combo si c'est un modificateur seul
+            # (ex: appui sur Ctrl sans autre touche = pas de combo)
+            if key_name and key_name not in self._MODIFIER_KEY_NAMES:
+                self._pending_standalone_win = False
+                if "win" in self.modifiers:
+                    self._suppress_release_only_win_combo = True
+                # Un combo interrompt la saisie texte en cours
+                self._flush_text_buffer()
+                # Attacher les raw_keys accumulés (press des modificateurs + press de la touche)
+                with self._text_lock:
+                    raw_keys = list(self._raw_key_buffer)
+                    # NB: on ne clear pas encore — le release va suivre et sera
+                    # capturé pour le prochain buffer. On prend un snapshot.
+                event = {
+                    "type": "key_combo",
+                    "keys": list(self.modifiers) + [key_name],
+                    "raw_keys": raw_keys,
+                    "timestamp": time.time(),
+                }
+                self._inject_screen_metadata(event)
+                self.on_event(event)
+                # Reset le buffer raw_keys après émission du combo
+                with self._text_lock:
+                    self._raw_key_buffer.clear()
+            return
+
+        # --- Saisie texte (pas de Ctrl/Alt/Win enfoncé) ---
+        self._handle_text_key(key)
+
+    def _handle_text_key(self, key):
+        """Gère l'accumulation des frappes texte dans le buffer.
+
+        Touches spéciales :
+        - Backspace : supprime le dernier caractère du buffer
+        - Enter / Tab : flush immédiat + émission de l'événement
+        - Escape : vide le buffer sans émettre
+        """
+        escape_raw_keys = None
+        with self._text_lock:
+            # --- Touches spéciales ---
+            if key == Key.backspace:
+                if self._text_buffer:
+                    self._text_buffer.pop()
+                self._reset_flush_timer()
+                return
+
+            if key == Key.esc:
+                # Annuler la saisie en cours
+                self._text_buffer.clear()
+                self._text_start_pos = None
+                self._cancel_flush_timer()
+                escape_raw_keys = list(self._raw_key_buffer)
+                self._raw_key_buffer.clear()
+                # Émettre hors lock après le bloc critique.
+                pass
+
+            elif key in (Key.enter, Key.tab):
+                # Flush immédiat — on relâche le lock avant d'appeler
+                # _flush_text_buffer (qui prend aussi le lock)
+                pass  # on sort du with et on flush après
+
+            elif key == Key.space:
+                # Espace = caractère normal
+                if not self._text_buffer:
+                    self._text_start_pos = self._last_mouse_pos
+                self._text_buffer.append(" ")
+                self._reset_flush_timer()
+                return
+
+            elif isinstance(key, KeyCode):
+                # Caractère alphanumérique / ponctuation
+                char = key.char
+
+                # AZERTY Windows : quand key.char est None (Shift+chiffres,
+                # dead keys, etc.), utiliser ToUnicodeEx avec le layout clavier
+                # actif pour obtenir le vrai caractère traduit par Windows.
+                if char is None and IS_WINDOWS:
+                    vk = getattr(key, 'vk', None)
+                    if vk is not None:
+                        char = self._vk_to_char(vk)
+
+                if char is not None and len(char) == 1:
+                    if not self._text_buffer:
+                        self._text_start_pos = self._last_mouse_pos
+                    self._text_buffer.append(char)
+                    self._reset_flush_timer()
+                    return
+
+                # key.char None et pas de vk exploitable → ignorer
+                return
+            else:
+                # Touche spéciale non gérée (F1, Insert, etc.) — on ignore
+                return
+
+        if escape_raw_keys is not None:
+            event = {
+                "type": "key_combo",
+                "keys": ["escape"],
+                "timestamp": time.time(),
+            }
+            if escape_raw_keys:
+                event["raw_keys"] = escape_raw_keys
+            self._inject_screen_metadata(event)
+            self.on_event(event)
+            return
+
+        # Si on arrive ici, c'est Enter ou Tab → flush le buffer en cours
+        # puis émettre le caractère spécial comme text_input séparé
+        self._flush_text_buffer()
+
+        # Émettre Enter comme "\n" et Tab comme "\t" pour ne pas perdre
+        # les retours à la ligne dans la saisie.
+        # Attacher les raw_keys restants (press de Enter/Tab, le release suivra)
+        with self._text_lock:
+            raw_keys = list(self._raw_key_buffer)
+            self._raw_key_buffer.clear()
+        special_char = "\n" if key == Key.enter else "\t"
+        event = {
+            "type": "text_input",
+            "text": special_char,
+            "pos": list(self._last_mouse_pos) if self._last_mouse_pos else [0, 0],
+            "timestamp": time.time(),
+        }
+        if raw_keys:
+            event["raw_keys"] = raw_keys
+        self.on_event(event)
+
+    def _reset_flush_timer(self):
+        """Réarme le timer de flush après chaque frappe.
+
+        Doit être appelé avec self._text_lock déjà acquis.
+        Utilise un compteur de génération pour garantir que seul le
+        dernier timer programmé puisse effectivement flush le buffer.
+        """
+        if self._text_flush_timer is not None:
+            self._text_flush_timer.cancel()
+        self._text_flush_generation += 1
+        gen = self._text_flush_generation
+        self._text_flush_timer = threading.Timer(
+            TEXT_FLUSH_DELAY, self._flush_text_buffer_if_current, args=(gen,)
+        )
+        self._text_flush_timer.daemon = True
+        self._text_flush_timer.start()
+
+    def _cancel_flush_timer(self):
+        """Annule le timer de flush sans émettre.
+
+        Doit être appelé avec self._text_lock déjà acquis.
+        """
+        if self._text_flush_timer is not None:
+            self._text_flush_timer.cancel()
+            self._text_flush_timer = None
+
+    def _flush_text_buffer_if_current(self, generation: int):
+        """Appelé par le timer. Ne flush que si la génération correspond
+        à celle du timer en cours (= pas de frappe entre-temps)."""
+        with self._text_lock:
+            if generation != self._text_flush_generation:
+                # Un timer plus récent a été programmé, celui-ci est obsolète
+                return
+        self._flush_text_buffer()
+
+    def _flush_text_buffer(self):
+        """Émet un événement text_input avec le contenu du buffer, puis
+        le vide. Thread-safe — peut être appelé depuis le timer, le
+        listener souris ou le listener clavier."""
+        with self._text_lock:
+            if not self._text_buffer:
+                # Rien à émettre — purger aussi les raw_keys orphelins
+                self._raw_key_buffer.clear()
+                self._cancel_flush_timer()
+                return
+            text = "".join(self._text_buffer)
+            pos = self._text_start_pos or self._last_mouse_pos
+            raw_keys = list(self._raw_key_buffer)
+            self._text_buffer.clear()
+            self._raw_key_buffer.clear()
+            self._text_start_pos = None
+            self._cancel_flush_timer()
+
+        # Émission hors du lock pour éviter un deadlock si le callback
+        # est lent ou prend d'autres locks
+        event = {
+            "type": "text_input",
+            "text": text,
+            "pos": pos,
+            "timestamp": time.time(),
+        }
+        # Attacher les raw_keys pour le replay exact (solution AZERTY)
+        if raw_keys:
+            event["raw_keys"] = raw_keys
+        self._inject_screen_metadata(event)
+        logger.debug(f"text_input émis : {len(text)} caractères, {len(raw_keys)} raw_keys")
+        self.on_event(event)
+
+    def _on_release(self, key):
+        # TOUJOURS enregistrer le release brut dans le buffer raw_keys
+        with self._text_lock:
+            self._raw_key_buffer.append({
+                "action": "release",
+                **self._encode_key(key),
+            })
+
+        if key in (Key.cmd, Key.cmd_l, Key.cmd_r) and self._suppress_release_only_win_combo:
+            with self._text_lock:
+                self._raw_key_buffer.clear()
+            self._pending_standalone_win = False
+            self._suppress_release_only_win_combo = False
+            self.modifiers.discard("win")
+            return
+
+        if key in (Key.cmd, Key.cmd_l, Key.cmd_r) and self._emit_release_only_windows_combo():
+            self._pending_standalone_win = False
+            self._suppress_release_only_win_combo = False
+            self.modifiers.discard("win")
+            return
+
+        if key in (Key.cmd, Key.cmd_l, Key.cmd_r) and self._pending_standalone_win:
+            with self._text_lock:
+                raw_keys = list(self._raw_key_buffer)
+                self._raw_key_buffer.clear()
+            event = {
+                "type": "key_combo",
+                "keys": ["win"],
+                "raw_keys": raw_keys,
+                "timestamp": time.time(),
+            }
+            self._inject_screen_metadata(event)
+            self.on_event(event)
+            self._pending_standalone_win = False
+            self._suppress_release_only_win_combo = False
+
+        if key in (Key.ctrl, Key.ctrl_l, Key.ctrl_r):
+            self.modifiers.discard("ctrl")
+        elif key in (Key.alt, Key.alt_l, Key.alt_r):
+            self.modifiers.discard("alt")
+        elif key in (Key.shift, Key.shift_l, Key.shift_r):
+            self.modifiers.discard("shift")
+        elif key in (Key.cmd, Key.cmd_l, Key.cmd_r):
+            self.modifiers.discard("win")
+            self._pending_standalone_win = False
+            self._suppress_release_only_win_combo = False
+
+    # ----------------------------------------------------------------
+    # Métadonnées système
+    # ----------------------------------------------------------------
+
+    def _refresh_screen_metadata(self):
+        """Rafraîchit le cache des métadonnées système.
+
+        Appelé au démarrage et à chaque changement de focus fenêtre.
+        Thread-safe — peut être appelé depuis le thread focus.
+        """
+        try:
+            metadata = get_screen_metadata()
+            with self._screen_metadata_lock:
+                self._screen_metadata = metadata
+            logger.debug(f"Métadonnées système rafraîchies : {_sanitize_metadata(metadata)}")
+        except Exception as e:
+            logger.error(f"Erreur refresh métadonnées système : {e}")
+
+    def _inject_screen_metadata(self, event: Dict[str, Any]) -> Dict[str, Any]:
+        """Injecte les métadonnées système cachées dans un événement."""
+        with self._screen_metadata_lock:
+            if self._screen_metadata:
+                event["screen_metadata"] = self._screen_metadata.copy()
+        return event
+
+    def _watch_window_focus(self):
+        """Surveille proactivement le changement de fenêtre pour le stagiaire."""
+        # Importation relative simple
+        from ..window_info_crossplatform import get_active_window_info
+
+        while self.running:
+            try:
+                info = get_active_window_info()
+                if info and info != self.last_window:
+                    # Rafraîchir les métadonnées (la fenêtre a peut-être
+                    # changé de moniteur, de taille, etc.)
+                    self._refresh_screen_metadata()
+
+                    event = {
+                        "type": "window_focus_change",
+                        "from": self.last_window,
+                        "to": info,
+                        "timestamp": time.time()
+                    }
+                    self._inject_screen_metadata(event)
+                    self.last_window = info
+                    self.on_event(event)
+            except Exception as e:
+                logger.error(f"Erreur focus window: {e}")
+            time.sleep(0.5)

agent_v0/agent_v1/core/grounding.py

@@ -0,0 +1,529 @@
+# agent_v1/core/grounding.py
+"""
+Module Grounding — localisation pure d'éléments UI sur l'écran.
+
+Responsabilité unique : "Trouve l'élément X sur l'écran et retourne ses coordonnées."
+Ne prend AUCUNE décision. Si l'élément n'est pas trouvé → retourne NOT_FOUND.
+
+Stratégies disponibles (cascade configurable) :
+1. Serveur SomEngine + VLM (GPU distant)
+2. Template matching local (CPU, ~10ms)
+3. VLM local direct (CPU/GPU local)
+
+Séparé de Policy (qui décide quoi faire quand grounding échoue).
+Ref: docs/PLAN_ACTEUR_V1.md — Architecture MICRO (grounding + exécution)
+"""
+
+import base64
+import io
+import logging
+import os
+import time
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class GroundingResult:
+    """Résultat d'une tentative de localisation visuelle."""
+    found: bool                     # L'élément a été trouvé
+    x_pct: float = 0.0             # Position X en % (0.0-1.0)
+    y_pct: float = 0.0             # Position Y en % (0.0-1.0)
+    method: str = ""               # Méthode utilisée (server_som, anchor_template, vlm_direct...)
+    score: float = 0.0             # Confiance (0.0-1.0)
+    elapsed_ms: float = 0.0        # Temps de résolution
+    detail: str = ""               # Info supplémentaire (label trouvé, raison échec)
+    raw: Optional[Dict] = None     # Données brutes du resolver (pour debug)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "found": self.found,
+            "x_pct": self.x_pct,
+            "y_pct": self.y_pct,
+            "method": self.method,
+            "score": round(self.score, 3),
+            "elapsed_ms": round(self.elapsed_ms, 1),
+            "detail": self.detail,
+        }
+
+
+# Résultat singleton pour "pas trouvé"
+NOT_FOUND = GroundingResult(found=False, detail="Aucune méthode n'a trouvé l'élément")
+
+
+class GroundingEngine:
+    """Moteur de localisation visuelle d'éléments UI.
+
+    Encapsule la cascade de résolution (serveur → template → VLM local)
+    avec une interface unifiée. Ne prend aucune décision — c'est le rôle
+    de PolicyEngine.
+
+    Usage :
+        engine = GroundingEngine(executor)
+        result = engine.locate(screenshot_b64, target_spec, screen_w, screen_h)
+        if result.found:
+            click(result.x_pct, result.y_pct)
+    """
+
+    def __init__(self, executor):
+        """
+        Args:
+            executor: ActionExecutorV1 — fournit les méthodes de résolution existantes.
+        """
+        self._executor = executor
+
+    @staticmethod
+    def _should_scope_to_active_window(target_spec: Dict[str, Any]) -> bool:
+        """Déterminer si le grounding doit être limité à la fenêtre active."""
+        if str(target_spec.get("screen_scope", "")).strip().lower() == "full_screen":
+            return False
+
+        by_role = str(target_spec.get("by_role", "")).strip().lower()
+        if by_role in {"start_button"}:
+            return False
+
+        has_anchor = bool(target_spec.get("anchor_image_base64"))
+        context_hints = target_spec.get("context_hints") or {}
+        has_window_or_text_hint = any(
+            str(target_spec.get(key, "") or "").strip()
+            for key in ("window_title", "by_text", "vlm_description")
+        ) or bool(str(context_hints.get("window_title", "") or "").strip())
+        if has_anchor and not has_window_or_text_hint and not by_role:
+            return False
+
+        return True
+
+    @staticmethod
+    def _targets_lea_window(target_spec: Dict[str, Any]) -> bool:
+        """Déterminer si la cible pointe explicitement vers l'UI de Léa."""
+        try:
+            from ..ui.messages import est_fenetre_lea
+        except Exception:
+            return False
+
+        context_hints = target_spec.get("context_hints") or {}
+        hints = [
+            target_spec.get("window_title", ""),
+            context_hints.get("window_title", ""),
+            target_spec.get("vlm_description", ""),
+            target_spec.get("by_text", ""),
+        ]
+        return any(est_fenetre_lea(str(hint)) for hint in hints if hint)
+
+    @staticmethod
+    def _is_plausible_window_rect(
+        rect: Optional[List[int]],
+        title: str,
+        screen_width: int,
+        screen_height: int,
+    ) -> bool:
+        """Valider qu'un rect actif ressemble à une vraie fenêtre utilisable.
+
+        Rejette explicitement les zones système "bar-like" (taskbar, systray)
+        et les titres inconnus/bruités. Le grounding ne doit jamais se
+        contraindre à une zone non validée.
+        """
+        if not rect or len(rect) != 4:
+            return False
+
+        try:
+            from ..ui.messages import est_fenetre_bruit
+        except Exception:
+            def est_fenetre_bruit(_title: str) -> bool:
+                return not _title or _title.strip().lower() == "unknown_window"
+
+        w = rect[2] - rect[0]
+        h = rect[3] - rect[1]
+        title_clean = str(title or "").strip()
+        if w <= 50 or h <= 50:
+            return False
+        title_lower = title_clean.lower()
+        is_unknown_title = not title_clean or title_lower == "unknown_window"
+        if not is_unknown_title and est_fenetre_bruit(title_clean):
+            return False
+
+        # Une zone très plate, surtout en bas d'écran et très large, est
+        # typiquement une barre des tâches / systray, pas une vraie fenêtre.
+        # On réduit le seuil de hauteur à 120px pour ne pas rejeter les petits modaux.
+        is_bar_like = (
+            h < 120
+            or (w > 0.9 * screen_width and h < 0.15 * screen_height)
+        )
+        
+        # Exception : si le titre contient un mot-clé de dialogue connu, 
+        # on considère que c'est plausible même si c'est petit.
+        keywords = ["enregistrer sous", "save as", "voulez-vous", "confirm", "attention", "error", "erreur"]
+        if any(k in title_lower for k in keywords):
+            return h >= 80 # Un dialogue fait au moins 80px (titre + bouton)
+
+        return not is_bar_like
+
+    @staticmethod
+    def _visual_scope_hints(target_spec: Dict[str, Any]) -> List[str]:
+        """Construire des indices textuels à chercher dans le crop fenêtre."""
+        hints: List[str] = []
+        raw_hints = [
+            target_spec.get("window_title", ""),
+            (target_spec.get("context_hints") or {}).get("window_title", ""),
+            target_spec.get("by_text", ""),
+        ]
+        for raw in raw_hints:
+            text = str(raw or "").strip()
+            if not text:
+                continue
+            text = text.lstrip("*").strip()
+            variants = [text]
+            for sep in (" – ", " - ", " — "):
+                if sep in text:
+                    variants.extend(part.strip().lstrip("*") for part in text.split(sep))
+            for variant in variants:
+                if variant and len(variant) >= 3 and variant not in hints:
+                    hints.append(variant)
+        return hints
+
+    @staticmethod
+    def _server_rejects_text_fallback(raw: Optional[Dict[str, Any]]) -> bool:
+        """Dire si un rejet serveur doit bloquer le fallback texte local.
+
+        Un rejet explicite n'est pas un simple "non trouvé": le serveur a vu
+        un candidat et l'a refusé pour une raison de qualité/zone. Refaire une
+        recherche OCR large côté client contournerait ce garde-fou.
+        """
+        if not raw or raw.get("resolved"):
+            return False
+
+        reason = str(raw.get("reason") or "")
+        method = str(raw.get("method") or "")
+        return (
+            method.startswith("rejected_")
+            or reason.startswith("close_tab_")
+            or reason.startswith("drift_")
+            or "below_threshold" in reason
+        )
+
+    def _window_crop_matches_target_visually(
+        self,
+        screenshot_b64: str,
+        target_spec: Dict[str, Any],
+    ) -> bool:
+        """Vérifier visuellement qu'un crop contraint contient la bonne cible.
+
+        Principe: ne jamais faire confiance au rect système seul. Si aucun
+        indice textuel n'est disponible, on laisse passer le crop plausible
+        pour ne pas sur-bloquer les cibles purement iconiques.
+        """
+        hints = self._visual_scope_hints(target_spec)
+        if not hints:
+            return True
+
+        finder = getattr(self._executor, "_find_text_on_screen", None)
+        if not callable(finder):
+            return True
+
+        for hint in hints:
+            try:
+                if finder(screenshot_b64, hint):
+                    logger.info(
+                        "Grounding fenêtre validé visuellement via '%s'",
+                        hint,
+                    )
+                    return True
+            except Exception as e:
+                logger.debug("Validation visuelle du crop échouée pour '%s': %s", hint, e)
+        logger.info(
+            "Grounding plein écran : crop fenêtre rejeté par validation visuelle "
+            "(hints=%s)",
+            hints,
+        )
+        return False
+
+    def locate(
+        self,
+        server_url: str,
+        target_spec: Dict[str, Any],
+        fallback_x: float,
+        fallback_y: float,
+        screen_width: int,
+        screen_height: int,
+        strategies: Optional[List[str]] = None,
+    ) -> GroundingResult:
+        """Localiser un élément UI sur l'écran.
+
+        Exécute la cascade de stratégies dans l'ordre et retourne
+        dès qu'une stratégie trouve l'élément.
+
+        Args:
+            server_url: URL du serveur (SomEngine + VLM GPU)
+            target_spec: Spécification de la cible (by_text, anchor, vlm_description...)
+            fallback_x, fallback_y: Coordonnées de fallback (enregistrement)
+            screen_width, screen_height: Résolution écran
+            strategies: Liste ordonnée de stratégies à essayer.
+                        Par défaut : ["server", "template", "vlm_local"]
+
+        Returns:
+            GroundingResult avec found=True et coordonnées, ou NOT_FOUND
+        """
+        if strategies is None:
+            strategies = ["server", "template", "vlm_local"]
+
+        # ── Apprentissage : réordonner les stratégies selon l'historique ──
+        # Si le Learning sait quelle méthode marche pour cette cible,
+        # la mettre en premier. C'est la boucle d'apprentissage.
+        learned = target_spec.get("_learned_strategy", "")
+        if learned:
+            strategy_map = {
+                "som_text_match": "server",
+                "grounding_vlm": "server",
+                "server_som": "server",
+                "anchor_template": "template",
+                "template_matching": "template",
+                "hybrid_text_direct": "vlm_local",
+                "hybrid_vlm_text": "vlm_local",
+                "vlm_direct": "vlm_local",
+            }
+            preferred = strategy_map.get(learned, "")
+            if preferred and preferred in strategies:
+                strategies = [preferred] + [s for s in strategies if s != preferred]
+                logger.info(
+                    f"Grounding: stratégie réordonnée par l'apprentissage → "
+                    f"{strategies} (learned={learned})"
+                )
+
+        t_start = time.time()
+
+        window_rect = None
+        active_title = ""
+        if self._should_scope_to_active_window(target_spec):
+            # ── Capture contrainte à la fenêtre active ──
+            # Le grounding ne voit QUE la fenêtre attendue — pas la taskbar,
+            # pas le systray, pas les autres apps. Comme un humain qui regarde
+            # l'application sur laquelle il travaille.
+            try:
+                from ..window_info_crossplatform import get_active_window_rect
+                from ..ui.messages import est_fenetre_lea
+
+                win_info = get_active_window_rect()
+                if win_info and win_info.get("rect"):
+                    active_title = str(win_info.get("title", "") or "")
+                    if est_fenetre_lea(active_title) and not self._targets_lea_window(target_spec):
+                        logger.info(
+                            "Grounding plein écran : fenêtre active Léa ignorée pour "
+                            "cible externe (%s)",
+                            target_spec.get("by_text", "") or target_spec.get("by_role", ""),
+                        )
+                        win_info = None
+                if win_info and win_info.get("rect"):
+                    r = win_info["rect"]  # [left, top, right, bottom]
+                    if self._is_plausible_window_rect(r, active_title, screen_width, screen_height):
+                        w = r[2] - r[0]
+                        h = r[3] - r[1]
+                        window_rect = {
+                            "left": max(0, r[0]),
+                            "top": max(0, r[1]),
+                            "width": min(w, screen_width),
+                            "height": min(h, screen_height),
+                        }
+                        logger.info(
+                            f"Grounding contraint à la fenêtre : "
+                            f"{window_rect['width']}x{window_rect['height']} "
+                            f"à ({window_rect['left']}, {window_rect['top']})"
+                        )
+                    else:
+                        logger.info(
+                            "Grounding plein écran : rect actif rejeté "
+                            "(title='%s', rect=%s)",
+                            active_title,
+                            r,
+                        )
+            except Exception as e:
+                logger.debug(f"Pas de window rect disponible : {e}")
+        else:
+            logger.info(
+                "Grounding plein écran pour by_role='%s'",
+                target_spec.get("by_role", ""),
+            )
+
+        screenshot_b64 = self._capture_window_or_screen(window_rect)
+        if window_rect and screenshot_b64:
+            if not self._window_crop_matches_target_visually(screenshot_b64, target_spec):
+                window_rect = None
+                screenshot_b64 = self._capture_window_or_screen(None)
+        if not screenshot_b64:
+            return GroundingResult(
+                found=False, detail="Capture screenshot échouée",
+                elapsed_ms=(time.time() - t_start) * 1000,
+            )
+
+        # Dimensions de la zone capturée (fenêtre ou écran entier)
+        cap_w = window_rect["width"] if window_rect else screen_width
+        cap_h = window_rect["height"] if window_rect else screen_height
+
+        skip_text_fallback_after_server_reject = False
+        for strategy in strategies:
+            if (
+                strategy == "vlm_local"
+                and skip_text_fallback_after_server_reject
+                and target_spec.get("by_text")
+            ):
+                by_text = target_spec.get("by_text", "")
+                logger.info(
+                    "[GROUNDING] Rejet serveur explicite pour '%s' — "
+                    "skip fallback local hybrid_text_direct",
+                    by_text,
+                )
+                print(
+                    f"    [GROUNDING] Rejet serveur explicite pour '{by_text}' "
+                    "→ pas de fallback texte local"
+                )
+                continue
+
+            result = self._try_strategy(
+                strategy, server_url, screenshot_b64, target_spec,
+                fallback_x, fallback_y, cap_w, cap_h,
+            )
+            if strategy == "server" and self._server_rejects_text_fallback(result.raw):
+                skip_text_fallback_after_server_reject = True
+            if result.found:
+                # ── Conversion coords fenêtre → coords écran ──
+                if window_rect:
+                    # Le grounding a retourné des coords relatives à la fenêtre
+                    # On les convertit en coords relatives à l'écran entier
+                    abs_x = window_rect["left"] + result.x_pct * cap_w
+                    abs_y = window_rect["top"] + result.y_pct * cap_h
+                    result.x_pct = abs_x / screen_width
+                    result.y_pct = abs_y / screen_height
+                    result.detail = f"{result.detail} [fenêtre {cap_w}x{cap_h}]"
+
+                result.elapsed_ms = (time.time() - t_start) * 1000
+                return result
+
+        if target_spec.get("allow_position_fallback"):
+            if 0.0 <= fallback_x <= 1.0 and 0.0 <= fallback_y <= 1.0:
+                return GroundingResult(
+                    found=True,
+                    x_pct=fallback_x,
+                    y_pct=fallback_y,
+                    method="position_fallback",
+                    score=0.2,
+                    detail="fallback positionnel explicite",
+                    elapsed_ms=(time.time() - t_start) * 1000,
+                )
+
+        return GroundingResult(
+            found=False,
+            detail=f"Toutes les stratégies ont échoué ({', '.join(strategies)})",
+            elapsed_ms=(time.time() - t_start) * 1000,
+        )
+
+    def _capture_window_or_screen(self, window_rect: Optional[Dict]) -> str:
+        """Capturer soit la fenêtre active (croppée), soit l'écran entier.
+
+        Si window_rect est fourni, capture uniquement cette zone.
+        Sinon, capture l'écran entier (fallback).
+        """
+        try:
+            from PIL import Image
+            import mss as mss_lib
+
+            with mss_lib.mss() as local_sct:
+                if window_rect:
+                    # Capture de la zone fenêtre uniquement
+                    region = {
+                        "left": window_rect["left"],
+                        "top": window_rect["top"],
+                        "width": window_rect["width"],
+                        "height": window_rect["height"],
+                    }
+                    raw = local_sct.grab(region)
+                else:
+                    # Fallback écran entier
+                    raw = local_sct.grab(local_sct.monitors[1])
+
+            img = Image.frombytes("RGB", raw.size, raw.bgra, "raw", "BGRX")
+            buffer = io.BytesIO()
+            img.save(buffer, format="JPEG", quality=75)
+            return base64.b64encode(buffer.getvalue()).decode("utf-8")
+        except Exception as e:
+            logger.warning(f"Capture échouée : {e}")
+            # Fallback sur la méthode existante de l'executor
+            return self._executor._capture_screenshot_b64(max_width=0, quality=75)
+
+    def _try_strategy(
+        self,
+        strategy: str,
+        server_url: str,
+        screenshot_b64: str,
+        target_spec: Dict[str, Any],
+        fallback_x: float,
+        fallback_y: float,
+        screen_width: int,
+        screen_height: int,
+    ) -> GroundingResult:
+        """Essayer une stratégie de grounding unique."""
+
+        if strategy == "server" and server_url:
+            raw = self._executor._server_resolve_target(
+                server_url, screenshot_b64, target_spec,
+                fallback_x, fallback_y, screen_width, screen_height,
+            )
+            if raw and raw.get("resolved"):
+                return GroundingResult(
+                    found=True,
+                    x_pct=raw["x_pct"],
+                    y_pct=raw["y_pct"],
+                    method=raw.get("method", "server"),
+                    score=raw.get("score", 0.0),
+                    detail=raw.get("matched_element", {}).get("label", ""),
+                    raw=raw,
+                )
+            if raw:
+                return GroundingResult(
+                    found=False,
+                    method=raw.get("method", "server"),
+                    score=raw.get("score", 0.0),
+                    detail=raw.get("reason", "server: pas trouvé"),
+                    raw=raw,
+                )
+
+        elif strategy == "template":
+            anchor_b64 = target_spec.get("anchor_image_base64", "")
+            if anchor_b64:
+                raw = self._executor._template_match_anchor(
+                    screenshot_b64,
+                    anchor_b64,
+                    screen_width,
+                    screen_height,
+                    fallback_x_pct=fallback_x,
+                    fallback_y_pct=fallback_y,
+                )
+                if raw and raw.get("resolved"):
+                    return GroundingResult(
+                        found=True,
+                        x_pct=raw["x_pct"],
+                        y_pct=raw["y_pct"],
+                        method="anchor_template",
+                        score=raw.get("score", 0.0),
+                        raw=raw,
+                    )
+
+        elif strategy == "vlm_local":
+            by_text = target_spec.get("by_text", "")
+            vlm_desc = target_spec.get("vlm_description", "")
+            if vlm_desc or by_text:
+                raw = self._executor._hybrid_vlm_resolve(
+                    screenshot_b64, target_spec, screen_width, screen_height,
+                )
+                if raw and raw.get("resolved"):
+                    return GroundingResult(
+                        found=True,
+                        x_pct=raw["x_pct"],
+                        y_pct=raw["y_pct"],
+                        method=raw.get("method", "vlm_local"),
+                        score=raw.get("score", 0.0),
+                        detail=raw.get("matched_element", {}).get("label", ""),
+                        raw=raw,
+                    )
+
+        return GroundingResult(found=False, method=strategy, detail=f"{strategy}: pas trouvé")

agent_v0/agent_v1/core/log_safe.py

@@ -0,0 +1,48 @@
+"""Helpers de logging PII-safe pour le client Léa (agent_v1).
+
+Convention : ne jamais logger le contenu brut d'une variable utilisateur
+(texte tapé, titre de fenêtre, nom de workflow, réponse VLM, chemin fichier).
+Le remplacer par :
+  - une longueur ou un hash court (corrélation de diagnostic sans révéler) ;
+  - un dict de métadonnées filtré (sans titre / fenêtre active).
+
+À importer dans tout module d'agent_v1 qui logge une donnée potentiellement
+sensible. Branche feat/push-log-dgx — DETTE-020 (assainissement à la source).
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+
+
+def _title_hash(title: str) -> str:
+    """Hash SHA1 tronqué (8 hex) d'un titre.
+
+    Corrélation stable (même titre → même hash → « même popup re-détectée »)
+    sans exposer le contenu. `errors="replace"` pour ne jamais lever sur un
+    encodage exotique (titres Windows multi-langues).
+    """
+    return hashlib.sha1((title or "").encode("utf-8", errors="replace")).hexdigest()[:8]
+
+
+# Clés de métadonnées susceptibles de contenir du contenu utilisateur (PII).
+_PII_METADATA_KEYS = ("title", "active_window", "window_title")
+
+
+def _sanitize_metadata(metadata: dict) -> dict:
+    """Copie d'un dict de métadonnées sans les clés porteuses de PII.
+
+    Garde les champs techniques (resolution, dpi, theme, langue…), retire
+    titre / fenêtre active. Ne mute pas le dict d'origine.
+    """
+    return {k: v for k, v in metadata.items() if k not in _PII_METADATA_KEYS}
+
+
+def _path_ext(path: str) -> str:
+    """Extension seule d'un chemin (ex. « .png »), sans nom ni dossier.
+
+    Un chemin peut nommer un patient ; l'extension suffit au diagnostic.
+    Chaîne vide si pas de chemin ou pas d'extension.
+    """
+    return os.path.splitext(path)[1] if path else ""

agent_v0/agent_v1/core/policy.py

@@ -0,0 +1,172 @@
+# agent_v1/core/policy.py
+"""
+Module Policy — décisions intelligentes quand le grounding échoue.
+
+Responsabilité unique : "Le Grounding dit NOT_FOUND. Que fait-on ?"
+Ne localise AUCUN élément — c'est le rôle du Grounding.
+
+Décisions possibles :
+- RETRY : re-tenter le grounding (après popup fermée, par exemple)
+- SKIP : l'action n'est plus nécessaire (état déjà atteint)
+- ABORT : arrêter le workflow (état incohérent)
+- SUPERVISE : rendre la main à l'utilisateur
+
+Séparé de Grounding (qui localise les éléments).
+Ref: docs/PLAN_ACTEUR_V1.md — Architecture MÉSO (acteur intelligent)
+"""
+
+import logging
+import os
+import time
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class Decision(Enum):
+    """Décisions possibles quand le grounding échoue."""
+    RETRY = "retry"             # Re-tenter (après correction : popup fermée, navigation...)
+    SKIP = "skip"               # Action inutile (état déjà atteint)
+    ABORT = "abort"             # Arrêter le workflow (état incohérent)
+    SUPERVISE = "supervise"     # Rendre la main à l'utilisateur (Léa dit "je bloque")
+    CONTINUE = "continue"       # Continuer malgré l'échec (action non critique)
+
+
+@dataclass
+class PolicyDecision:
+    """Résultat d'une décision Policy."""
+    decision: Decision
+    reason: str                     # Explication de la décision
+    action_taken: str = ""          # Action corrective effectuée (ex: "popup fermée")
+    elapsed_ms: float = 0.0
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "decision": self.decision.value,
+            "reason": self.reason,
+            "action_taken": self.action_taken,
+            "elapsed_ms": round(self.elapsed_ms, 1),
+        }
+
+
+class PolicyEngine:
+    """Moteur de décision quand le grounding échoue.
+
+    Cascade de décision :
+    1. Popup détectée ? → fermer et RETRY
+    2. Acteur gemma4 → SKIP / ABORT / SUPERVISE
+    3. Fallback → SUPERVISE (rendre la main)
+
+    Usage :
+        policy = PolicyEngine(executor)
+        decision = policy.decide(action, target_spec, grounding_result)
+        if decision.decision == Decision.RETRY:
+            # re-tenter le grounding
+        elif decision.decision == Decision.SKIP:
+            # marquer comme réussi, passer à la suite
+    """
+
+    def __init__(self, executor):
+        self._executor = executor
+
+    def decide(
+        self,
+        action: Dict[str, Any],
+        target_spec: Dict[str, Any],
+        retry_count: int = 0,
+        max_retries: int = 1,
+    ) -> PolicyDecision:
+        """Décider quoi faire quand le grounding a échoué.
+
+        Cascade :
+        1. Si c'est le premier essai → tenter de fermer une popup → RETRY
+        2. Si retry déjà fait → demander à l'acteur gemma4
+        3. Selon gemma4 : SKIP, ABORT, ou SUPERVISE
+
+        **SÉCURITÉ** : si, pendant l'étape 1, le handler popup détecte un
+        dialogue système Windows (UAC, CredUI, SmartScreen…), on bascule
+        immédiatement en SUPERVISE. Cf. system_dialog_guard.py.
+
+        Args:
+            action: L'action qui a échoué
+            target_spec: La cible non trouvée
+            retry_count: Nombre de retries déjà faits
+            max_retries: Maximum de retries autorisés
+        """
+        t_start = time.time()
+
+        # ── Étape 1 : Tentative de fermeture popup (premier essai) ──
+        if retry_count == 0:
+            popup_handled = self._try_close_popup()
+
+            # Si le popup handler a détecté un dialogue système, on
+            # bascule immédiatement en SUPERVISE — pas de retry, pas de
+            # gemma4 : on rend la main à l'humain.
+            if getattr(self._executor, "_system_dialog_pause", None):
+                sd = self._executor._system_dialog_pause
+                return PolicyDecision(
+                    decision=Decision.SUPERVISE,
+                    reason=(
+                        f"Dialogue système détecté ({sd.get('category', '?')}) — "
+                        f"refus d'interaction automatique"
+                    ),
+                    action_taken="system_dialog_blocked",
+                    elapsed_ms=(time.time() - t_start) * 1000,
+                )
+
+            if popup_handled:
+                return PolicyDecision(
+                    decision=Decision.RETRY,
+                    reason="Popup détectée et fermée, re-tentative",
+                    action_taken="popup_closed",
+                    elapsed_ms=(time.time() - t_start) * 1000,
+                )
+
+        # ── Étape 2 : Max retries atteint → acteur gemma4 ──
+        if retry_count >= max_retries:
+            actor_decision = self._ask_actor(action, target_spec)
+
+            if actor_decision == "PASSER":
+                return PolicyDecision(
+                    decision=Decision.SKIP,
+                    reason="Acteur gemma4 : l'état est déjà atteint",
+                    elapsed_ms=(time.time() - t_start) * 1000,
+                )
+            elif actor_decision == "STOPPER":
+                return PolicyDecision(
+                    decision=Decision.ABORT,
+                    reason="Acteur gemma4 : état incohérent, arrêt",
+                    elapsed_ms=(time.time() - t_start) * 1000,
+                )
+            else:
+                # EXECUTER ou inconnu → pause supervisée
+                return PolicyDecision(
+                    decision=Decision.SUPERVISE,
+                    reason=f"Acteur gemma4 : {actor_decision}, pause supervisée",
+                    elapsed_ms=(time.time() - t_start) * 1000,
+                )
+
+        # ── Étape 3 : Encore des retries disponibles → RETRY ──
+        return PolicyDecision(
+            decision=Decision.RETRY,
+            reason=f"Retry {retry_count + 1}/{max_retries}",
+            elapsed_ms=(time.time() - t_start) * 1000,
+        )
+
+    def _try_close_popup(self) -> bool:
+        """Tenter de fermer une popup via le handler VLM existant."""
+        try:
+            return self._executor._handle_popup_vlm()
+        except Exception as e:
+            logger.debug(f"Policy: popup handler échoué : {e}")
+            return False
+
+    def _ask_actor(self, action: Dict, target_spec: Dict) -> str:
+        """Demander à gemma4 de décider (PASSER/EXECUTER/STOPPER)."""
+        try:
+            return self._executor._actor_decide(action, target_spec)
+        except Exception as e:
+            logger.debug(f"Policy: acteur gemma4 échoué : {e}")
+            return "EXECUTER"  # Fallback → supervisé

agent_v0/agent_v1/core/recovery.py

@@ -0,0 +1,217 @@
+# agent_v1/core/recovery.py
+"""
+Module Recovery — mécanisme de rollback quand une action échoue.
+
+Responsabilité : "L'action a échoué ou produit un résultat inattendu.
+Comment revenir en arrière ?"
+
+Stratégies de recovery :
+1. Ctrl+Z (undo natif) — pour les frappes et modifications
+2. Escape (fermer dialogue) — pour les popups/menus
+3. Alt+F4 (fermer fenêtre) — si mauvaise application ouverte
+4. Clic hors zone — fermer un menu déroulant
+5. Navigation retour — retourner à l'écran précédent
+
+Le Recovery est appelé par le Policy quand le Critic détecte un
+résultat inattendu (pixel OK + sémantique NON = changement inattendu).
+
+Ref: docs/VISION_RPA_INTELLIGENT.md — "Il se trompe" → correction
+"""
+
+import logging
+import time
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+from .log_safe import _title_hash
+
+logger = logging.getLogger(__name__)
+
+
+class RecoveryAction(Enum):
+    """Actions de recovery possibles."""
+    UNDO = "undo"               # Ctrl+Z
+    ESCAPE = "escape"           # Echap (fermer dialogue/menu)
+    CLOSE_WINDOW = "close"      # Alt+F4
+    CLICK_AWAY = "click_away"   # Clic hors zone (fermer menu)
+    NONE = "none"               # Pas de recovery possible
+
+
+@dataclass
+class RecoveryResult:
+    """Résultat d'une tentative de recovery."""
+    action_taken: RecoveryAction
+    success: bool
+    detail: str = ""
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "action_taken": self.action_taken.value,
+            "success": self.success,
+            "detail": self.detail,
+        }
+
+
+class RecoveryEngine:
+    """Moteur de recovery — tente de revenir en arrière après un échec.
+
+    Choisit la stratégie de recovery en fonction du type d'action qui a échoué
+    et de l'état actuel de l'écran.
+
+    Usage :
+        recovery = RecoveryEngine(executor)
+        result = recovery.attempt(failed_action, critic_result)
+        if result.success:
+            # re-tenter l'action
+    """
+
+    def __init__(self, executor):
+        self._executor = executor
+
+    def attempt(
+        self,
+        failed_action: Dict[str, Any],
+        critic_detail: str = "",
+    ) -> RecoveryResult:
+        """Tenter une recovery après un échec.
+
+        Sélectionne la stratégie appropriée selon le type d'action :
+        - click qui ouvre la mauvaise chose → Escape ou Ctrl+Z
+        - type qui tape au mauvais endroit → Ctrl+Z
+        - key_combo inattendu → Ctrl+Z
+        - popup apparue → Escape
+
+        Args:
+            failed_action: L'action qui a échoué
+            critic_detail: Détail du Critic (raison de l'échec sémantique)
+        """
+        action_type = failed_action.get("type", "")
+        detail_lower = critic_detail.lower()
+
+        # Choisir la stratégie de recovery
+        strategy = self._select_strategy(action_type, detail_lower)
+
+        if strategy == RecoveryAction.NONE:
+            return RecoveryResult(
+                action_taken=RecoveryAction.NONE,
+                success=False,
+                detail="Pas de stratégie de recovery applicable",
+            )
+
+        return self._execute_recovery(strategy)
+
+    def _select_strategy(self, action_type: str, critic_detail: str) -> RecoveryAction:
+        """Sélectionner la meilleure stratégie de recovery.
+
+        Priorité : type d'action d'abord (frappe → undo), puis contexte.
+        """
+        # Frappe ou modification incorrecte → toujours Ctrl+Z
+        if action_type in ("type", "key_combo"):
+            return RecoveryAction.UNDO
+
+        # Popup/dialogue détecté
+        if any(w in critic_detail for w in ["popup", "dialog", "erreur", "error", "modal"]):
+            return RecoveryAction.ESCAPE
+
+        # Menu ouvert par erreur
+        if any(w in critic_detail for w in ["menu", "dropdown", "déroulant"]):
+            return RecoveryAction.ESCAPE
+
+        # Mauvaise fenêtre ouverte
+        if any(w in critic_detail for w in ["mauvaise fenêtre", "wrong window"]):
+            return RecoveryAction.CLOSE_WINDOW
+
+        # Clic qui a produit un résultat inattendu
+        if action_type == "click":
+            return RecoveryAction.ESCAPE
+
+        return RecoveryAction.NONE
+
+    def _execute_recovery(self, strategy: RecoveryAction) -> RecoveryResult:
+        """Exécuter la stratégie de recovery choisie."""
+        from pynput.keyboard import Controller as KeyboardController, Key
+
+        keyboard = self._executor.keyboard
+
+        try:
+            if strategy == RecoveryAction.UNDO:
+                # Ctrl+Z
+                logger.info("Recovery : Ctrl+Z (undo)")
+                print("    [RECOVERY] Ctrl+Z — annulation de la dernière action")
+                keyboard.press(Key.ctrl)
+                keyboard.press('z')
+                keyboard.release('z')
+                keyboard.release(Key.ctrl)
+                time.sleep(0.5)
+                return RecoveryResult(
+                    action_taken=RecoveryAction.UNDO,
+                    success=True,
+                    detail="Ctrl+Z exécuté",
+                )
+
+            elif strategy == RecoveryAction.ESCAPE:
+                # Echap
+                logger.info("Recovery : Escape (fermer dialogue)")
+                print("    [RECOVERY] Escape — fermeture dialogue/menu")
+                keyboard.press(Key.esc)
+                keyboard.release(Key.esc)
+                time.sleep(0.5)
+                return RecoveryResult(
+                    action_taken=RecoveryAction.ESCAPE,
+                    success=True,
+                    detail="Escape exécuté",
+                )
+
+            elif strategy == RecoveryAction.CLOSE_WINDOW:
+                # Alt+F4 — AVEC vérification fenêtre active
+                # Sur un poste hospitalier, Alt+F4 sans vérif peut fermer le DPI patient
+                try:
+                    from ..window_info_crossplatform import get_active_window_info
+                    active = get_active_window_info()
+                    active_title = active.get("title", "")
+                    logger.info(f"Recovery : Alt+F4 sur [title_hash={_title_hash(active_title)}]")
+                    print(f"    [RECOVERY] Alt+F4 — fermeture de [title_hash={_title_hash(active_title)}]")
+                except Exception:
+                    logger.info("Recovery : Alt+F4 (fenêtre active inconnue)")
+                    print("    [RECOVERY] Alt+F4 — fermeture fenêtre indésirable")
+
+                keyboard.press(Key.alt)
+                keyboard.press(Key.f4)
+                keyboard.release(Key.f4)
+                keyboard.release(Key.alt)
+                time.sleep(1.0)
+                return RecoveryResult(
+                    action_taken=RecoveryAction.CLOSE_WINDOW,
+                    success=True,
+                    detail=f"Alt+F4 exécuté sur [title_hash={_title_hash(active_title) if 'active_title' in dir() else '?'}]",
+                )
+
+            elif strategy == RecoveryAction.CLICK_AWAY:
+                # Clic au centre de l'écran (hors popup)
+                logger.info("Recovery : clic hors zone")
+                print("    [RECOVERY] Clic hors zone — fermeture menu")
+                monitor = self._executor.sct.monitors[1]
+                w, h = monitor["width"], monitor["height"]
+                # Cliquer dans un coin neutre (10% depuis le haut-gauche)
+                self._executor._click((int(w * 0.1), int(h * 0.1)), "left")
+                time.sleep(0.5)
+                return RecoveryResult(
+                    action_taken=RecoveryAction.CLICK_AWAY,
+                    success=True,
+                    detail="Clic hors zone exécuté",
+                )
+
+        except Exception as e:
+            logger.warning(f"Recovery échoué ({strategy.value}) : {e}")
+            return RecoveryResult(
+                action_taken=strategy,
+                success=False,
+                detail=f"Erreur : {e}",
+            )
+
+        return RecoveryResult(
+            action_taken=RecoveryAction.NONE,
+            success=False,
+            detail="Stratégie non implémentée",
+        )

agent_v0/agent_v1/core/system_dialog_guard.py

@@ -0,0 +1,448 @@
+# agent_v1/core/system_dialog_guard.py
+"""
+Garde-fou sécurité : détection des dialogues système Windows critiques.
+
+==============================================================================
+POURQUOI ?
+==============================================================================
+
+Pendant un replay, si un dialogue UAC, CredUI (mot de passe Windows),
+SmartScreen ou une notification de sécurité Windows apparaît, Léa pourrait
+demander au VLM "quel bouton cliquer" et recevoir "Oui" en réponse.
+
+→ **Léa cliquerait OUI sur une élévation UAC** → vecteur d'attaque ransomware.
+
+Ce module fournit la détection de ces dialogues pour que l'exécuteur
+**ne clique JAMAIS dessus automatiquement**. La décision est renvoyée à
+l'humain (pause supervisée).
+
+==============================================================================
+PRINCIPE
+==============================================================================
+
+- **Faux positif tolérable** : on préfère pauser pour rien plutôt que cliquer
+  sur un UAC.
+- **Faux négatif catastrophique** : mieux vaut être trop prudent.
+- **Multi-signal** : titre, ClassName UIA, nom de processus, parent_path.
+  Un seul signal suffit à bloquer.
+- **Compatible Citrix** : les dialogues UAC d'un client Citrix apparaissent
+  aussi dans la VM distante — la détection par classe UIA fonctionne.
+
+==============================================================================
+PATTERNS DE DÉTECTION (ordre de criticité décroissant)
+==============================================================================
+
+1. UAC Consent (élévation de privilèges)
+   - ClassName : `$$$Secure UAP Dummy Window Class$$$`
+   - Process   : `consent.exe`
+   - Titre     : "Contrôle de compte d'utilisateur", "User Account Control"
+
+2. CredUI (prompt mot de passe Windows)
+   - ClassName : `Credential Dialog Xaml Host`
+   - Process   : `credentialuibroker.exe`, `credui.exe`
+   - Titre     : "Sécurité Windows", "Windows Security"
+
+3. SmartScreen (protection contre applications inconnues)
+   - Process   : `smartscreen.exe`
+   - Titre     : "Windows a protégé votre ordinateur", "Windows protected your PC"
+
+4. Windows Defender / Security Center
+   - Process   : `securityhealthhost.exe`, `msmpeng.exe`
+   - Titre     : "Sécurité Windows", "Windows Defender"
+
+5. Signatures pilotes / driver install
+   - Titre     : "Installer ce pilote", "Driver signature"
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from dataclasses import dataclass
+from typing import Any, Dict, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+# =============================================================================
+#  Catégories de dialogues système (pour logging + messages)
+# =============================================================================
+
+
+class SystemDialogCategory:
+    """Catégories de dialogues système à bloquer absolument."""
+    UAC = "uac_consent"                    # Élévation de privilèges
+    CREDUI = "windows_credential_prompt"   # Prompt de mot de passe
+    SMARTSCREEN = "smartscreen"            # Protection SmartScreen
+    DEFENDER = "windows_defender"          # Alerte Windows Defender
+    DRIVER = "driver_install"              # Installation pilote signé
+    SECURITY_TOAST = "security_toast"      # Toast de sécurité Windows
+    UNKNOWN_DIALOG = "unknown_system_dialog"  # Dialogue #32770 sans app connue
+
+
+@dataclass
+class SystemDialogDetection:
+    """Résultat d'une analyse de dialogue système."""
+    is_system_dialog: bool
+    category: str = ""                     # Valeur de SystemDialogCategory
+    matched_signal: str = ""               # Ex: "class_name=Consent.exe"
+    matched_value: str = ""                # La valeur qui a matché
+    reason: str = ""                       # Explication lisible
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "is_system_dialog": self.is_system_dialog,
+            "category": self.category,
+            "matched_signal": self.matched_signal,
+            "matched_value": self.matched_value,
+            "reason": self.reason,
+        }
+
+
+# =============================================================================
+#  Signatures de détection
+# =============================================================================
+
+
+# ClassName UIA (casse préservée — Windows exposées telle quelle par UIA).
+# Utilisées telles quelles puis en minuscules pour matcher avec souplesse.
+_CLASS_NAMES_SYSTEM = {
+    # UAC Consent
+    "$$$Secure UAP Dummy Window Class$$$": SystemDialogCategory.UAC,
+    "Credential Dialog Xaml Host": SystemDialogCategory.CREDUI,
+    # Windows Credential UI ancien nom
+    "CredentialDialogXamlHost": SystemDialogCategory.CREDUI,
+}
+
+# Nom de processus (comparaison insensible à la casse, .exe normalisé)
+_PROCESS_NAMES_SYSTEM = {
+    "consent.exe": SystemDialogCategory.UAC,
+    "credentialuibroker.exe": SystemDialogCategory.CREDUI,
+    "credui.exe": SystemDialogCategory.CREDUI,
+    "credwiz.exe": SystemDialogCategory.CREDUI,
+    "smartscreen.exe": SystemDialogCategory.SMARTSCREEN,
+    "securityhealthhost.exe": SystemDialogCategory.DEFENDER,
+    "securityhealthui.exe": SystemDialogCategory.DEFENDER,
+    "securityhealthsystray.exe": SystemDialogCategory.DEFENDER,
+    "msmpeng.exe": SystemDialogCategory.DEFENDER,
+    "windowsdefender.exe": SystemDialogCategory.DEFENDER,
+    "msiexec.exe": SystemDialogCategory.DRIVER,  # prompts pilotes signés
+    "drvinst.exe": SystemDialogCategory.DRIVER,
+}
+
+# Motifs titre (insensibles à la casse, regex avec word boundaries)
+# On ne matche pas les titres génériques trop larges pour limiter les faux
+# positifs sur OSIRIS/OBSIUS/MEDSPHERE.
+_TITLE_PATTERNS_SYSTEM: Tuple[Tuple[re.Pattern, str], ...] = (
+    # UAC
+    (re.compile(r"contr[oô]le\s+de\s+compte\s+d'?utilisateur", re.IGNORECASE),
+     SystemDialogCategory.UAC),
+    (re.compile(r"\buser\s+account\s+control\b", re.IGNORECASE),
+     SystemDialogCategory.UAC),
+    (re.compile(r"voulez-vous\s+autoriser\s+cette\s+application", re.IGNORECASE),
+     SystemDialogCategory.UAC),
+    (re.compile(r"do\s+you\s+want\s+to\s+allow\s+this\s+app", re.IGNORECASE),
+     SystemDialogCategory.UAC),
+
+    # CredUI / Sécurité Windows
+    (re.compile(r"\bs[eé]curit[eé]\s+windows\b", re.IGNORECASE),
+     SystemDialogCategory.CREDUI),
+    (re.compile(r"\bwindows\s+security\b", re.IGNORECASE),
+     SystemDialogCategory.CREDUI),
+    (re.compile(r"entrer\s+les\s+informations\s+d'?identification", re.IGNORECASE),
+     SystemDialogCategory.CREDUI),
+    (re.compile(r"enter\s+(?:your\s+)?credentials?", re.IGNORECASE),
+     SystemDialogCategory.CREDUI),
+    (re.compile(r"connectez-vous\s+[aà]\s+votre\s+compte", re.IGNORECASE),
+     SystemDialogCategory.CREDUI),
+    (re.compile(r"\bsign\s+in\s+to\s+your\s+account\b", re.IGNORECASE),
+     SystemDialogCategory.CREDUI),
+
+    # SmartScreen
+    (re.compile(r"windows\s+a\s+prot[eé]g[eé]", re.IGNORECASE),
+     SystemDialogCategory.SMARTSCREEN),
+    (re.compile(r"windows\s+protected\s+your\s+pc", re.IGNORECASE),
+     SystemDialogCategory.SMARTSCREEN),
+    (re.compile(r"\bsmartscreen\b", re.IGNORECASE),
+     SystemDialogCategory.SMARTSCREEN),
+    (re.compile(r"\b[eé]diteur\s+inconnu\b", re.IGNORECASE),
+     SystemDialogCategory.SMARTSCREEN),
+    (re.compile(r"\bunknown\s+publisher\b", re.IGNORECASE),
+     SystemDialogCategory.SMARTSCREEN),
+
+    # Windows Defender
+    (re.compile(r"windows\s+defender", re.IGNORECASE),
+     SystemDialogCategory.DEFENDER),
+    (re.compile(r"menace\s+d[eé]tect[eé]e", re.IGNORECASE),
+     SystemDialogCategory.DEFENDER),
+    (re.compile(r"threat\s+detected", re.IGNORECASE),
+     SystemDialogCategory.DEFENDER),
+
+    # Driver
+    (re.compile(r"installer\s+ce\s+pilote", re.IGNORECASE),
+     SystemDialogCategory.DRIVER),
+    (re.compile(r"install\s+this\s+driver", re.IGNORECASE),
+     SystemDialogCategory.DRIVER),
+    (re.compile(r"signature\s+num[eé]rique\s+du\s+pilote", re.IGNORECASE),
+     SystemDialogCategory.DRIVER),
+)
+
+
+# =============================================================================
+#  Fonctions de détection
+# =============================================================================
+
+
+def _normalize_process(name: str) -> str:
+    """Normaliser un nom de processus pour comparaison."""
+    if not name:
+        return ""
+    name = name.strip().lower()
+    # Enlever le chemin éventuel
+    if "\\" in name or "/" in name:
+        name = name.replace("\\", "/").split("/")[-1]
+    # Assurer suffixe .exe pour matcher le dictionnaire
+    if not name.endswith(".exe") and name:
+        # Les process_name peuvent venir sans .exe (psutil) — on ajoute
+        # pour avoir une clé uniforme
+        name_with_exe = name + ".exe"
+        if name_with_exe in _PROCESS_NAMES_SYSTEM:
+            return name_with_exe
+    return name
+
+
+def _check_class_name(class_name: str) -> Optional[Tuple[str, str, str]]:
+    """Vérifier si un ClassName UIA matche un dialogue système.
+
+    Returns:
+        (category, matched_class, reason) si match, None sinon.
+    """
+    if not class_name:
+        return None
+
+    # Match exact
+    if class_name in _CLASS_NAMES_SYSTEM:
+        cat = _CLASS_NAMES_SYSTEM[class_name]
+        return (cat, class_name, f"ClassName UIA '{class_name}' = dialogue système {cat}")
+
+    # Match insensible à la casse + normalisation espaces
+    cn_norm = class_name.strip()
+    for known, cat in _CLASS_NAMES_SYSTEM.items():
+        if cn_norm.lower() == known.lower():
+            return (cat, class_name, f"ClassName UIA ~= '{known}' ({cat})")
+
+    # Détection souple UAC (il existe quelques variantes de la classe secure)
+    if "secure uap" in class_name.lower() or "uap dummy" in class_name.lower():
+        return (SystemDialogCategory.UAC, class_name,
+                f"ClassName '{class_name}' contient 'Secure UAP' → UAC")
+
+    # Credential XAML Host
+    if "credential" in class_name.lower() and "xaml" in class_name.lower():
+        return (SystemDialogCategory.CREDUI, class_name,
+                f"ClassName '{class_name}' contient Credential+Xaml → CredUI")
+
+    return None
+
+
+def _check_process_name(process_name: str) -> Optional[Tuple[str, str, str]]:
+    """Vérifier si un nom de processus est un dialogue système.
+
+    Returns:
+        (category, matched_process, reason) si match, None sinon.
+    """
+    if not process_name:
+        return None
+
+    norm = _normalize_process(process_name)
+    if norm in _PROCESS_NAMES_SYSTEM:
+        cat = _PROCESS_NAMES_SYSTEM[norm]
+        return (cat, process_name, f"Processus '{norm}' = {cat}")
+    return None
+
+
+def _check_title(title: str) -> Optional[Tuple[str, str, str]]:
+    """Vérifier si un titre de fenêtre matche un dialogue système.
+
+    Returns:
+        (category, matched_pattern, reason) si match, None sinon.
+    """
+    if not title:
+        return None
+
+    for pattern, cat in _TITLE_PATTERNS_SYSTEM:
+        m = pattern.search(title)
+        if m:
+            return (cat, m.group(0),
+                    f"Titre '{title[:60]}' matche '{pattern.pattern}' → {cat}")
+    return None
+
+
+def is_system_dialog(
+    uia_snapshot: Optional[Dict[str, Any]] = None,
+    window_info: Optional[Dict[str, Any]] = None,
+) -> SystemDialogDetection:
+    """Déterminer si la fenêtre active est un dialogue système critique.
+
+    La détection combine plusieurs signaux — **un seul suffit à bloquer**.
+    On préfère un faux positif (pause inutile) à un faux négatif (clic UAC).
+
+    Args:
+        uia_snapshot: Dict avec champs `class_name`, `process_name`,
+            `parent_path`, `name`. Peut être None si UIA indisponible.
+        window_info: Dict avec champs `title`, `app_name`. Peut être None.
+
+    Returns:
+        SystemDialogDetection avec is_system_dialog=True si un dialogue
+        système est détecté.
+
+    Exemples::
+
+        det = is_system_dialog(window_info={"title": "User Account Control"})
+        assert det.is_system_dialog  # UAC détecté
+
+        det = is_system_dialog(uia_snapshot={"class_name": "$$$Secure UAP Dummy Window Class$$$"})
+        assert det.is_system_dialog  # UAC via ClassName
+
+        det = is_system_dialog(window_info={"title": "OSIRIS - Patient Dupont"})
+        assert not det.is_system_dialog  # Application métier → OK
+    """
+    # ── Signal 1 : ClassName UIA ──
+    if uia_snapshot:
+        cn = uia_snapshot.get("class_name", "") or ""
+        r = _check_class_name(cn)
+        if r:
+            cat, matched, reason = r
+            return SystemDialogDetection(
+                is_system_dialog=True,
+                category=cat,
+                matched_signal="class_name",
+                matched_value=matched,
+                reason=reason,
+            )
+
+        # Explorer aussi les parents (le champ cliqué peut être un bouton
+        # interne dont la ClassName est "Button", mais le root de la fenêtre
+        # est le Consent.exe).
+        for parent in uia_snapshot.get("parent_path", []) or []:
+            p_cn = parent.get("class_name", "") or ""
+            r = _check_class_name(p_cn)
+            if r:
+                cat, matched, reason = r
+                return SystemDialogDetection(
+                    is_system_dialog=True,
+                    category=cat,
+                    matched_signal="parent_class_name",
+                    matched_value=matched,
+                    reason=f"Parent : {reason}",
+                )
+
+    # ── Signal 2 : Process name ──
+    if uia_snapshot:
+        pn = uia_snapshot.get("process_name", "") or ""
+        r = _check_process_name(pn)
+        if r:
+            cat, matched, reason = r
+            return SystemDialogDetection(
+                is_system_dialog=True,
+                category=cat,
+                matched_signal="process_name",
+                matched_value=matched,
+                reason=reason,
+            )
+
+    if window_info:
+        app = window_info.get("app_name", "") or ""
+        r = _check_process_name(app)
+        if r:
+            cat, matched, reason = r
+            return SystemDialogDetection(
+                is_system_dialog=True,
+                category=cat,
+                matched_signal="app_name",
+                matched_value=matched,
+                reason=reason,
+            )
+
+    # ── Signal 3 : Titre de fenêtre ──
+    if window_info:
+        title = window_info.get("title", "") or ""
+        r = _check_title(title)
+        if r:
+            cat, matched, reason = r
+            return SystemDialogDetection(
+                is_system_dialog=True,
+                category=cat,
+                matched_signal="window_title",
+                matched_value=matched,
+                reason=reason,
+            )
+
+    if uia_snapshot:
+        # Certains dialogues système remontent leur titre dans uia.name
+        uia_name = uia_snapshot.get("name", "") or ""
+        r = _check_title(uia_name)
+        if r:
+            cat, matched, reason = r
+            return SystemDialogDetection(
+                is_system_dialog=True,
+                category=cat,
+                matched_signal="uia_name",
+                matched_value=matched,
+                reason=reason,
+            )
+
+    return SystemDialogDetection(is_system_dialog=False)
+
+
+def detect_current_system_dialog() -> SystemDialogDetection:
+    """Analyser l'écran actuel et détecter un dialogue système.
+
+    Helper autonome qui interroge à la fois `get_active_window_info()` et
+    le helper UIA (si dispo) pour obtenir la détection la plus fiable.
+
+    Returns:
+        SystemDialogDetection. Si un signal matche, is_system_dialog=True.
+        Si rien n'est disponible (Linux, UIA absent), is_system_dialog=False
+        mais le caller peut encore fallback sur une analyse par titre.
+    """
+    window_info: Optional[Dict[str, Any]] = None
+    uia_snapshot: Optional[Dict[str, Any]] = None
+
+    # Fenêtre active (cross-platform)
+    try:
+        from ..window_info_crossplatform import get_active_window_info
+        window_info = get_active_window_info()
+    except Exception as e:  # pragma: no cover — best-effort
+        logger.debug(f"[SYS-DIALOG] window_info indisponible : {e}")
+
+    # UIA local (Windows uniquement, via lea_uia.exe)
+    try:
+        from .uia_helper import get_shared_helper
+        helper = get_shared_helper()
+        if helper.available:
+            # On capture l'élément focalisé (root = fenêtre active)
+            element = helper.capture_focused(max_depth=2)
+            if element is not None:
+                uia_snapshot = element.to_dict()
+    except Exception as e:  # pragma: no cover
+        logger.debug(f"[SYS-DIALOG] UIA indisponible : {e}")
+
+    detection = is_system_dialog(
+        uia_snapshot=uia_snapshot, window_info=window_info,
+    )
+
+    if detection.is_system_dialog:
+        logger.warning(
+            f"[SYS-DIALOG] BLOCAGE — dialogue système détecté "
+            f"[{detection.category}] via {detection.matched_signal}='{detection.matched_value}' "
+            f"— {detection.reason}"
+        )
+    return detection
+
+
+__all__ = [
+    "SystemDialogCategory",
+    "SystemDialogDetection",
+    "is_system_dialog",
+    "detect_current_system_dialog",
+]

agent_v0/agent_v1/core/uia_helper.py

@@ -0,0 +1,294 @@
+# core/workflow/uia_helper.py
+"""
+UIAHelper — Wrapper Python pour lea_uia.exe (helper Rust UI Automation).
+
+Expose une API Python simple pour interroger UIA via le binaire Rust.
+Communique via subprocess + stdin/stdout JSON.
+
+Pourquoi un helper Rust ?
+- 5-10x plus rapide que pywinauto (10-20ms vs 50-200ms)
+- Binaire standalone ~500 Ko, aucune dépendance runtime
+- Pas de problèmes de threading COM en Python
+- Crash-safe (le crash du helper n'affecte pas l'agent Python)
+
+Architecture :
+    Python executor
+        ↓ subprocess.run
+    lea_uia.exe query --x 812 --y 436
+        ↓ UIA API Windows
+    JSON response
+        ↓ stdout
+    Python executor parse JSON
+
+Si lea_uia.exe n'est pas disponible (Linux, binaire absent, crash) :
+toutes les méthodes retournent None → fallback vision automatique.
+"""
+
+import json
+import logging
+import os
+import platform
+import subprocess
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+# Timeout par défaut pour les appels UIA (en secondes)
+_DEFAULT_TIMEOUT = 5.0
+
+# Masquer la fenêtre console lors du spawn de lea_uia.exe sur Windows.
+# Sans ce flag, chaque appel (à chaque clic utilisateur pendant
+# l'enregistrement) fait apparaître une fenêtre cmd noire brièvement
+# visible à l'écran → ralentit la souris et pollue les screenshots
+# capturés (le VLM peut "voir" le chemin lea_uia.exe comme texte cliqué).
+#
+# La valeur 0x08000000 correspond à CREATE_NO_WINDOW défini dans
+# l'API Windows. Sur Linux/Mac, la valeur est 0 et `creationflags`
+# est ignoré. getattr() gère le cas où Python expose déjà la constante
+# sur Windows.
+if platform.system() == "Windows":
+    _SUBPROCESS_CREATION_FLAGS = getattr(subprocess, "CREATE_NO_WINDOW", 0x08000000)
+else:
+    _SUBPROCESS_CREATION_FLAGS = 0
+
+
+@dataclass
+class UiaElement:
+    """Représentation Python d'un élément UIA."""
+    name: str = ""
+    control_type: str = ""
+    class_name: str = ""
+    automation_id: str = ""
+    bounding_rect: Tuple[int, int, int, int] = (0, 0, 0, 0)
+    is_enabled: bool = False
+    is_offscreen: bool = True
+    parent_path: List[Dict[str, str]] = field(default_factory=list)
+    process_name: str = ""
+
+    def center(self) -> Tuple[int, int]:
+        """Retourner le centre du rectangle (pixels)."""
+        x1, y1, x2, y2 = self.bounding_rect
+        return ((x1 + x2) // 2, (y1 + y2) // 2)
+
+    def width(self) -> int:
+        return self.bounding_rect[2] - self.bounding_rect[0]
+
+    def height(self) -> int:
+        return self.bounding_rect[3] - self.bounding_rect[1]
+
+    def is_clickable(self) -> bool:
+        """Peut-on cliquer dessus ?"""
+        return (
+            self.is_enabled
+            and not self.is_offscreen
+            and self.width() > 0
+            and self.height() > 0
+        )
+
+    def path_signature(self) -> str:
+        """Signature du chemin parent (pour retrouver l'élément)."""
+        parts = [f"{p['control_type']}[{p['name']}]" for p in self.parent_path if p.get("name")]
+        parts.append(f"{self.control_type}[{self.name}]")
+        return " > ".join(parts)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "name": self.name,
+            "control_type": self.control_type,
+            "class_name": self.class_name,
+            "automation_id": self.automation_id,
+            "bounding_rect": list(self.bounding_rect),
+            "is_enabled": self.is_enabled,
+            "is_offscreen": self.is_offscreen,
+            "parent_path": self.parent_path,
+            "process_name": self.process_name,
+        }
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "UiaElement":
+        rect = d.get("bounding_rect", [0, 0, 0, 0])
+        if isinstance(rect, list) and len(rect) >= 4:
+            rect = tuple(rect[:4])
+        else:
+            rect = (0, 0, 0, 0)
+        return cls(
+            name=d.get("name", ""),
+            control_type=d.get("control_type", ""),
+            class_name=d.get("class_name", ""),
+            automation_id=d.get("automation_id", ""),
+            bounding_rect=rect,
+            is_enabled=d.get("is_enabled", False),
+            is_offscreen=d.get("is_offscreen", True),
+            parent_path=d.get("parent_path", []),
+            process_name=d.get("process_name", ""),
+        )
+
+
+class UIAHelper:
+    """Wrapper Python pour lea_uia.exe."""
+
+    def __init__(self, helper_path: str = "", timeout: float = _DEFAULT_TIMEOUT):
+        self._helper_path = helper_path or self._find_helper()
+        self._timeout = timeout
+        self._available = self._check_available()
+
+    def _find_helper(self) -> str:
+        """Trouver lea_uia.exe dans les emplacements standards."""
+        candidates = [
+            r"C:\Lea\helpers\lea_uia.exe",
+            os.path.join(os.path.dirname(__file__), "..", "..",
+                         "agent_rust", "lea_uia", "target",
+                         "x86_64-pc-windows-gnu", "release", "lea_uia.exe"),
+            "./helpers/lea_uia.exe",
+            "lea_uia.exe",
+        ]
+        for path in candidates:
+            if os.path.isfile(path):
+                return os.path.abspath(path)
+        return ""
+
+    def _check_available(self) -> bool:
+        """Vérifier que le helper est utilisable (Windows + binaire + health OK)."""
+        if platform.system() != "Windows":
+            logger.debug("UIAHelper: Linux/Mac — helper désactivé")
+            return False
+        if not self._helper_path:
+            logger.debug("UIAHelper: lea_uia.exe introuvable")
+            return False
+        if not os.path.isfile(self._helper_path):
+            logger.debug(f"UIAHelper: chemin invalide {self._helper_path}")
+            return False
+        return True
+
+    @property
+    def available(self) -> bool:
+        return self._available
+
+    @property
+    def helper_path(self) -> str:
+        return self._helper_path
+
+    def _run(self, args: List[str]) -> Optional[Dict[str, Any]]:
+        """Exécuter lea_uia.exe avec les arguments et parser le JSON."""
+        if not self._available:
+            return None
+        try:
+            result = subprocess.run(
+                [self._helper_path] + args,
+                capture_output=True,
+                text=True,
+                timeout=self._timeout,
+                encoding="utf-8",
+                errors="replace",
+                creationflags=_SUBPROCESS_CREATION_FLAGS,
+            )
+            if result.returncode != 0:
+                logger.debug(
+                    f"UIAHelper: exit code {result.returncode}, "
+                    f"stderr: {result.stderr[:200]}"
+                )
+                return None
+            output = result.stdout.strip()
+            if not output:
+                return None
+            return json.loads(output)
+        except subprocess.TimeoutExpired:
+            logger.debug(f"UIAHelper: timeout ({self._timeout}s) sur {args}")
+            return None
+        except json.JSONDecodeError as e:
+            logger.debug(f"UIAHelper: JSON invalide — {e}")
+            return None
+        except Exception as e:
+            logger.debug(f"UIAHelper: erreur {e}")
+            return None
+
+    def health(self) -> bool:
+        """Vérifier que UIA répond."""
+        data = self._run(["health"])
+        return data is not None and data.get("status") == "ok"
+
+    def query_at(
+        self,
+        x: int,
+        y: int,
+        with_parents: bool = True,
+    ) -> Optional[UiaElement]:
+        """Récupérer l'élément UIA à une position écran.
+
+        Args:
+            x, y: Coordonnées pixel absolues
+            with_parents: Inclure la hiérarchie des parents
+
+        Returns:
+            UiaElement si trouvé, None sinon (pas d'élément ou UIA indispo)
+        """
+        args = ["query", "--x", str(x), "--y", str(y)]
+        if not with_parents:
+            args.append("--with-parents=false")
+
+        data = self._run(args)
+        if not data or data.get("status") != "ok":
+            return None
+
+        elem_data = data.get("element")
+        if not elem_data:
+            return None
+        return UiaElement.from_dict(elem_data)
+
+    def find_by_name(
+        self,
+        name: str,
+        control_type: Optional[str] = None,
+        automation_id: Optional[str] = None,
+        window: Optional[str] = None,
+        timeout_ms: int = 2000,
+    ) -> Optional[UiaElement]:
+        """Rechercher un élément par son nom (+ filtres optionnels).
+
+        Args:
+            name: Nom exact de l'élément
+            control_type: Type de contrôle (Button, Edit, MenuItem...)
+            automation_id: ID d'automation
+            window: Restreindre à une fenêtre spécifique
+            timeout_ms: Timeout de recherche en millisecondes
+        """
+        args = ["find", "--name", name, "--timeout-ms", str(timeout_ms)]
+        if control_type:
+            args.extend(["--control-type", control_type])
+        if automation_id:
+            args.extend(["--automation-id", automation_id])
+        if window:
+            args.extend(["--window", window])
+
+        data = self._run(args)
+        if not data or data.get("status") != "ok":
+            return None
+
+        elem_data = data.get("element")
+        if not elem_data:
+            return None
+        return UiaElement.from_dict(elem_data)
+
+    def capture_focused(self, max_depth: int = 3) -> Optional[UiaElement]:
+        """Capturer l'élément ayant le focus + son contexte."""
+        data = self._run(["capture", "--max-depth", str(max_depth)])
+        if not data or data.get("status") != "ok":
+            return None
+
+        elem_data = data.get("element")
+        if not elem_data:
+            return None
+        return UiaElement.from_dict(elem_data)
+
+
+# Instance globale partagée (singleton léger)
+_SHARED_HELPER: Optional[UIAHelper] = None
+
+
+def get_shared_helper() -> UIAHelper:
+    """Retourner une instance partagée de UIAHelper."""
+    global _SHARED_HELPER
+    if _SHARED_HELPER is None:
+        _SHARED_HELPER = UIAHelper()
+    return _SHARED_HELPER

agent_v0/agent_v1/finalize_contract.py

@@ -0,0 +1,39 @@
+"""Dispatch léger du contrat enrichi de /finalize côté agent."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict
+
+
+logger = logging.getLogger(__name__)
+
+
+def dispatch_finalize_result(ui: Any, payload: Dict[str, Any], replay_name: str) -> None:
+    """Router le résultat de /finalize vers la bonne surface UI agent."""
+    if not isinstance(payload, dict):
+        return
+
+    replay_request = payload.get("replay_request") or {}
+    replay_launch = payload.get("replay_launch") or {}
+
+    if replay_launch.get("status") == "started":
+        logger.info("Replay direct déjà lancé par le serveur après finalize")
+        return
+
+    if not payload.get("replay_ready") or not replay_request:
+        return
+
+    if replay_launch.get("status") == "failed":
+        logger.warning(
+            "Auto-replay serveur échoué après finalize, proposition manuelle"
+        )
+
+    if ui is None or not hasattr(ui, "offer_finalize_replay"):
+        logger.info("UI indisponible pour proposer un test immédiat")
+        return
+
+    ui.offer_finalize_replay(
+        replay_request,
+        replay_name or "la tâche que vous venez d'enregistrer",
+    )

agent_v0/agent_v1/logging_setup.py

@@ -0,0 +1,56 @@
+"""Journalisation client Léa — DETTE-021.
+
+Branche un handler **fichier** (`TimedRotatingFileHandler`) sur le logger racine,
+en plus de la console. Sans cela, sous `pythonw.exe` (pas de console), les logs
+partent sur stderr et sont **perdus** — diagnostic terrain impossible.
+
+Rotation quotidienne + rétention `retention_days` (Règlement IA Art. 12 :
+journalisation automatique + conservation minimum 180 j).
+"""
+import logging
+from logging.handlers import TimedRotatingFileHandler
+from pathlib import Path
+
+_FMT = "%(asctime)s %(levelname)-7s %(name)-25s %(message)s"
+
+
+def setup_logging(log_file, level=logging.INFO, retention_days=180):
+    """Configure le logging racine : fichier (rotation quotidienne, `retention_days`
+    fichiers conservés) + console. **Idempotent** : ne réempile pas nos handlers.
+
+    Args:
+        log_file: chemin du fichier de log (`config.LOG_FILE` en prod).
+        level: niveau racine (INFO par défaut ; DEBUG géré par l'appelant).
+        retention_days: nb de fichiers quotidiens conservés (180 = Règlement IA Art. 12).
+
+    Returns:
+        Le `TimedRotatingFileHandler` créé.
+    """
+    log_file = Path(log_file)
+    log_file.parent.mkdir(parents=True, exist_ok=True)
+
+    root = logging.getLogger()
+    root.setLevel(level)
+
+    # Idempotence : retirer nos propres handlers posés par un appel précédent.
+    for h in list(root.handlers):
+        if getattr(h, "_lea_managed", False):
+            h.close()
+            root.removeHandler(h)
+
+    file_handler = TimedRotatingFileHandler(
+        str(log_file), when="midnight", backupCount=retention_days, encoding="utf-8"
+    )
+    file_handler.setFormatter(logging.Formatter(_FMT, datefmt="%Y-%m-%d %H:%M:%S"))
+    file_handler.setLevel(level)
+    file_handler._lea_managed = True
+    root.addHandler(file_handler)
+
+    # Console conservée (utile en dev / si lancé avec une console).
+    console = logging.StreamHandler()
+    console.setFormatter(logging.Formatter(_FMT, datefmt="%H:%M:%S"))
+    console.setLevel(level)
+    console._lea_managed = True
+    root.addHandler(console)
+
+    return file_handler

agent_v0/agent_v1/main.py

@@ -0,0 +1,796 @@
+# agent_v1/main.py
+"""
+Point d'entree Agent V1 - Enrichi avec Intelligence de Contexte, Heartbeat et Replay.
+
+Boucles paralleles (threads daemon) :
+  - _heartbeat_loop : capture periodique toutes les 5s
+  - _command_watchdog_loop : surveillance du fichier command.json (legacy)
+  - _replay_poll_loop : polling du serveur pour les actions de replay (P0-5)
+"""
+
+import sys
+import os
+import uuid
+import time
+import logging
+import threading
+from .config import (
+    SESSIONS_ROOT, AGENT_VERSION, SERVER_URL, MACHINE_ID, LOG_RETENTION_DAYS, LOG_FILE,
+    SCREEN_RESOLUTION, DPI_SCALE, OS_THEME, API_TOKEN, MAX_SESSION_DURATION_S,
+    STREAMING_ENDPOINT, LOG_SHIP_ENABLED, LOG_SHIP_INTERVAL_S,
+    AUTO_UPDATE_ENABLED, AUTO_UPDATE_INTERVAL_S, AUTO_UPDATE_STAGING_DIR,
+)
+from .core.captor import EventCaptorV1
+from .core.executor import ActionExecutorV1
+from .network.streamer import TraceStreamer
+from .ui.shared_state import AgentState
+from .ui.smart_tray import SmartTrayV1
+from .ui.chat_window import ChatWindow
+from .ui.capture_server import CaptureServer
+from .session.storage import SessionStorage
+from .vision.capturer import VisionCapturer
+from .finalize_contract import dispatch_finalize_result
+from .core.log_safe import _title_hash
+
+# Import optionnel du client serveur (pour le chat et les workflows)
+# Deux chemins : relatif (depuis agent_v0.agent_v1) ou absolu (depuis C:\rpa_vision\agent_v1)
+try:
+    from ..lea_ui.server_client import LeaServerClient
+except (ImportError, ValueError):
+    try:
+        from lea_ui.server_client import LeaServerClient
+    except ImportError:
+        LeaServerClient = None
+
+# Configuration du logging — format structuré et lisible pour un TIM
+# Niveau de détail : INFO par défaut, DEBUG si RPA_AGENT_DEBUG=1
+_log_level = logging.DEBUG if os.environ.get("RPA_AGENT_DEBUG") == "1" else logging.INFO
+# DETTE-021 : journaliser dans un FICHIER (rotation quotidienne + rétention 180 j,
+# Règlement IA Art. 12). Sous `pythonw.exe` (sans console), un basicConfig→stderr
+# serait perdu. Fallback console si le fichier est indisponible — ne JAMAIS
+# empêcher Léa de démarrer pour un problème de log.
+try:
+    from .logging_setup import setup_logging
+    setup_logging(LOG_FILE, level=_log_level, retention_days=LOG_RETENTION_DAYS)
+except Exception:
+    logging.basicConfig(
+        level=_log_level,
+        format="%(asctime)s %(levelname)-7s %(name)-25s %(message)s",
+        datefmt="%H:%M:%S",
+    )
+
+# Réduire le bruit de certaines libs
+for _noisy in ("urllib3", "requests.packages.urllib3", "PIL", "mss"):
+    logging.getLogger(_noisy).setLevel(logging.WARNING)
+
+# push-log-DGX : remontée automatique des logs vers le serveur (diagnostic des
+# postes SANS AnyDesk). GARDÉ derrière RPA_LOG_SHIP_ENABLED (défaut désactivé) —
+# activable poste par poste via config.txt, sans rebuild. Le handler est attaché
+# au logger racine APRÈS setup_logging (les logs partent aussi dans le fichier).
+_log_shipper = None
+if LOG_SHIP_ENABLED:
+    try:
+        from .network.log_shipper import LogShipper
+        _log_shipper = LogShipper(
+            machine_id=MACHINE_ID,
+            max_batch=int(os.environ.get("RPA_AGENT_LOGS_MAX_BATCH", "1000")),
+            flush_interval_s=LOG_SHIP_INTERVAL_S,
+        )
+        logging.getLogger().addHandler(_log_shipper.handler)
+        _log_shipper.start()
+    except Exception as _e:
+        # Ne JAMAIS empêcher Léa de démarrer pour un problème de remontée de logs.
+        logging.getLogger(__name__).warning("Log shipper non démarré : %s", _e)
+        _log_shipper = None
+
+logger = logging.getLogger(__name__)
+
+# Intervalle de polling replay (secondes)
+REPLAY_POLL_INTERVAL = 1.0
+
+
+class AgentV1:
+    def __init__(self, user_id="demo_user"):
+        self.user_id = user_id
+        self.machine_id = MACHINE_ID
+        self.session_id = None
+        self.session_dir = None
+
+        # Gestion du stockage local et nettoyage
+        # Retention minimum 6 mois (Reglement IA, Article 12)
+        self.storage = SessionStorage(SESSIONS_ROOT, retention_days=LOG_RETENTION_DAYS)
+        threading.Thread(target=self._delayed_cleanup, daemon=True).start()
+
+        self.vision = None
+        self.streamer = None
+        self.captor = None
+        self.shot_counter = 0
+        self.running = False
+
+        # Executeur partage entre watchdog et replay
+        self._executor = None
+        # Flag pour indiquer qu'un replay est en cours (eviter les conflits)
+        self._replay_active = False
+        self._last_recording_name = ""
+
+        # Etat partage entre systray et chat (source de verite unique)
+        self._state = AgentState()
+        self._state.set_on_start(self.start_session)
+        self._state.set_on_stop(self.stop_session)
+
+        # Client serveur pour le chat et les workflows
+        # Plus de RPA_SERVER_HOST : le LeaServerClient derive tout de SERVER_URL
+        self._server_client = None
+        if LeaServerClient is not None:
+            # Forcer le token API pour éviter les 401
+            # (le token est set par start.bat dans l'environnement)
+            from .config import API_TOKEN as _token
+            self._server_client = LeaServerClient()
+            if _token and not self._server_client._api_token:
+                self._server_client._api_token = _token
+                logger.info("Token API forcé dans LeaServerClient")
+
+        # Fenetre de chat Lea (tkinter natif)
+        # Le host est derive de SERVER_URL (plus de RPA_SERVER_HOST)
+        server_host = (
+            self._server_client.server_host
+            if self._server_client is not None
+            else "localhost"
+        )
+        self._chat_window = ChatWindow(
+            server_client=self._server_client,
+            on_start_callback=self.start_session,
+            server_host=server_host,
+            chat_port=5004,
+            shared_state=self._state,
+        )
+
+        # 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.
+        self._wire_chat_window_to_executor()
+
+        # Boucles permanentes (pas besoin de session active)
+        self.running = True
+        self._bg_vision = VisionCapturer(str(SESSIONS_ROOT / "_background"))
+        threading.Thread(target=self._replay_poll_loop, daemon=True).start()
+        threading.Thread(target=self._background_heartbeat_loop, daemon=True).start()
+
+        # DETTE-022 v2 : MAJ silencieuse — boucle de check GATED (défaut OFF).
+        # Interroge le serveur (canary-aware) et télécharge en STAGING ; le swap
+        # réel reste réservé révision humaine (updater.apply_update = stub no-op).
+        # Activable poste par poste via RPA_AUTO_UPDATE_ENABLED, sans rebuild.
+        if AUTO_UPDATE_ENABLED:
+            threading.Thread(
+                target=self._auto_update_loop, daemon=True, name="lea-auto-update"
+            ).start()
+
+        # MAJ silencieuse — confirmation de boot post-swap. Si Lea.bat vient
+        # d'appliquer une MAJ (marqueur PENDING_BOOT), on désarme le rollback
+        # après ~90 s de tourne STABLE (liveness LOCALE, indépendante du DGX).
+        # Un quit propre avant 90 s confirme aussi (cf. main()). Seul un vrai
+        # crash laisse PENDING_BOOT → rollback au prochain lancement.
+        if _pending_boot_marker_exists():
+            def _boot_confirm():
+                import os as _os
+                import time as _time
+                _time.sleep(float(_os.environ.get("RPA_BOOT_CONFIRM_DELAY_S", "90")))
+                if self.running:
+                    _confirm_boot_ok()
+            threading.Thread(
+                target=_boot_confirm, daemon=True, name="lea-boot-confirm"
+            ).start()
+
+        # Mini-serveur HTTP pour captures a la demande (port 5006)
+        self._capture_server = CaptureServer()
+        self._capture_server.start()
+
+        # Bannière de démarrage avec métadonnées système
+        logger.info(
+            f"Agent V1 v{AGENT_VERSION} | Machine={self.machine_id} | "
+            f"Ecran={SCREEN_RESOLUTION[0]}x{SCREEN_RESOLUTION[1]} | "
+            f"DPI={DPI_SCALE}% | Theme={OS_THEME} | "
+            f"Serveur={SERVER_URL}"
+        )
+
+        # UI Tray intelligent (remplace TrayAppV1, plus de PyQt5)
+        self.ui = SmartTrayV1(
+            self.start_session,
+            self.stop_session,
+            server_client=self._server_client,
+            chat_window=self._chat_window,
+            machine_id=self.machine_id,
+            shared_state=self._state,
+        )
+
+    def _wire_chat_window_to_executor(self) -> None:
+        """Relie l'executor courant à la ChatWindow pour les pauses supervisees."""
+        if self._executor is None or self._chat_window is None:
+            return
+        try:
+            self._executor._chat_window_ref = self._chat_window
+        except Exception:
+            logger.debug("Wiring chat_window->executor echoue (non bloquant)", exc_info=True)
+
+    def _delayed_cleanup(self):
+        """Nettoyage en arrière-plan après 30s pour ne pas bloquer le démarrage."""
+        time.sleep(30)
+        self.storage.run_auto_cleanup()
+
+    def _auto_stop_loop(self):
+        """Auto-stop de l'enregistrement après MAX_SESSION_DURATION_S.
+
+        L'utilisateur peut oublier d'arrêter. On notifie à 50 min,
+        puis on arrête automatiquement à 60 min (configurable).
+        """
+        warn_before = 600  # Prévenir 10 min avant la fin
+        warned = False
+
+        while self.running and self.session_id:
+            elapsed = time.time() - self._session_start_time
+            remaining = MAX_SESSION_DURATION_S - elapsed
+
+            # Notification 10 min avant la fin
+            if not warned and remaining <= warn_before:
+                warned = True
+                mins = int(remaining / 60)
+                logger.info(f"Auto-stop dans {mins} min")
+                try:
+                    from .ui.notifications import NotificationManager
+                    NotificationManager().notify(
+                        "Léa",
+                        f"L'enregistrement s'arrêtera automatiquement dans {mins} minutes.",
+                    )
+                except Exception:
+                    pass
+
+            # Auto-stop
+            if remaining <= 0:
+                logger.info(
+                    f"Auto-stop : session {self.session_id} après "
+                    f"{int(elapsed)}s ({int(elapsed/60)} min)"
+                )
+                try:
+                    from .ui.notifications import NotificationManager
+                    NotificationManager().notify(
+                        "Léa",
+                        f"Enregistrement terminé automatiquement après "
+                        f"{int(elapsed/60)} minutes. Merci !",
+                    )
+                except Exception:
+                    pass
+
+                # Arrêter via l'état partagé (synchronise systray + chat)
+                if self._state is not None:
+                    self._state.stop_recording()
+                else:
+                    self.stop_session()
+                break
+
+            time.sleep(30)  # Vérifier toutes les 30s
+
+    def start_session(self, workflow_name):
+        self._last_recording_name = workflow_name
+        self.session_id = f"sess_{time.strftime('%Y%m%dT%H%M%S')}_{uuid.uuid4().hex[:6]}"
+        self.session_dir = self.storage.get_session_dir(self.session_id)
+
+        self.vision = VisionCapturer(str(self.session_dir))
+
+        self.streamer = TraceStreamer(self.session_id, machine_id=self.machine_id)
+        self.streamer.set_on_finalize_result(self._on_finalize_result)
+        self.captor = EventCaptorV1(self._on_event_bridge)
+
+        # Initialiser l'executeur partage
+        self._executor = ActionExecutorV1()
+        self._wire_chat_window_to_executor()
+
+        self.shot_counter = 0
+        self.running = True
+        self._replay_active = False
+        self.streamer.start()
+        self.captor.start()
+
+        # Heartbeat Contextuel (Toutes les 5s par defaut)
+        threading.Thread(target=self._heartbeat_loop, daemon=True).start()
+
+        # Auto-stop : arrêter l'enregistrement après MAX_SESSION_DURATION_S
+        # L'utilisateur peut oublier d'arrêter — on le fait automatiquement
+        self._session_start_time = time.time()
+        threading.Thread(target=self._auto_stop_loop, daemon=True).start()
+
+        # Watchdog de Commandes (GHOST Replay — legacy fichier)
+        threading.Thread(target=self._command_watchdog_loop, daemon=True).start()
+
+        # Note: la boucle de polling replay est déjà lancée dans __init__ (ligne 102)
+        # Ne PAS en relancer une ici — deux threads poll simultanés causent
+        # une race condition où les actions sont consommées mais pas exécutées.
+
+        logger.info(f"Session {self.session_id} [wf_hash={_title_hash(workflow_name)}] sur machine {self.machine_id} en cours...")
+
+    def _command_watchdog_loop(self):
+        """Surveille un fichier de commande pour executer des ordres visuels (legacy)."""
+        import json
+        import platform
+        from .config import BASE_DIR
+
+        # Chemin du fichier de commande selon l'OS
+        if platform.system() == "Windows":
+            cmd_path = "C:\\rpa_vision\\command.json"
+        else:
+            cmd_path = str(BASE_DIR / "command.json")
+
+        while self.running and self.session_id:
+            # Ne pas traiter les commandes fichier pendant un replay serveur
+            if self._replay_active:
+                time.sleep(1)
+                continue
+
+            if os.path.exists(cmd_path):
+                try:
+                    with open(cmd_path, "r") as f:
+                        order = json.load(f)
+                    os.remove(cmd_path)  # On consomme l'ordre
+                    if self._executor:
+                        self._executor.execute_normalized_order(order)
+                except Exception as e:
+                    logger.error(f"Erreur Watchdog: {e}")
+            time.sleep(1)
+
+    def _replay_poll_loop(self):
+        """
+        Boucle de polling pour les actions de replay depuis le serveur (P0-5).
+
+        Tourne en parallele du heartbeat et du watchdog.
+        Poll GET /replay/next toutes les REPLAY_POLL_INTERVAL secondes.
+        Quand une action est recue, l'execute via l'executor et rapporte le resultat.
+        """
+        msg = (
+            f"[REPLAY] Boucle replay demarree — poll toutes les "
+            f"{REPLAY_POLL_INTERVAL}s sur {SERVER_URL}"
+        )
+        print(msg)
+        logger.info(msg)
+
+        poll_count = 0
+        while self.running:
+            if not self._executor:
+                time.sleep(REPLAY_POLL_INTERVAL)
+                continue
+
+            # TOUJOURS utiliser un session_id stable pour le replay.
+            # L'enregistrement et le replay sont indépendants : le serveur
+            # envoie les actions sur agent_{user_id}, pas sur la session
+            # d'enregistrement (sess_xxx).
+            poll_session = f"agent_{self.user_id}"
+
+            # Log periodique pour confirmer que la boucle tourne (toutes les 60s)
+            poll_count += 1
+            if poll_count % int(60 / REPLAY_POLL_INTERVAL) == 0:
+                print(
+                    f"[REPLAY] Poll #{poll_count} — session={poll_session} "
+                    f"— serveur={SERVER_URL}"
+                )
+
+            try:
+                # Tenter de recuperer et executer une action
+                had_action = self._executor.poll_and_execute(
+                    session_id=poll_session,
+                    server_url=SERVER_URL,
+                    machine_id=self.machine_id,
+                )
+
+                if had_action:
+                    if not self._replay_active:
+                        self._replay_active = True
+                        self.ui.set_replay_active(True)
+                        self._state.set_replay_active(True)
+                    # Si une action a ete executee, poll plus rapidement
+                    # pour enchainer les actions du workflow
+                    time.sleep(0.2)
+                else:
+                    if getattr(self._executor, "_replay_paused", False):
+                        if not self._replay_active:
+                            self._replay_active = True
+                            self.ui.set_replay_active(True)
+                            self._state.set_replay_active(True)
+                        poll_delay = getattr(self._executor, '_poll_backoff', REPLAY_POLL_INTERVAL)
+                        time.sleep(max(poll_delay, REPLAY_POLL_INTERVAL))
+                        continue
+
+                    # Pas d'action en attente — utiliser le backoff de l'executor
+                    # (augmente si le serveur est indisponible, reset a 1s sinon)
+                    if self._replay_active:
+                        print("[REPLAY] Replay termine — retour en mode capture")
+                        logger.info("Replay termine — retour en mode capture")
+                        self._replay_active = False
+                        self.ui.set_replay_active(False)
+                        self._state.set_replay_active(False)
+                    poll_delay = getattr(self._executor, '_poll_backoff', REPLAY_POLL_INTERVAL)
+                    time.sleep(max(poll_delay, REPLAY_POLL_INTERVAL))
+
+            except Exception as e:
+                print(f"[REPLAY] ERREUR boucle replay : {e}")
+                logger.error(f"Erreur replay poll loop : {e}")
+                self._replay_active = False
+                self._state.set_replay_active(False)
+                poll_delay = getattr(self._executor, '_poll_backoff', REPLAY_POLL_INTERVAL)
+                time.sleep(max(poll_delay, REPLAY_POLL_INTERVAL))
+
+    _last_bg_hash: str = ""
+
+    def _background_heartbeat_loop(self):
+        """Heartbeat permanent — envoie un screenshot toutes les 5s au serveur.
+        Tourne même sans session active, pour que le VWB puisse capturer Windows.
+        """
+        import requests as req
+        bg_session = f"bg_{self.machine_id}"
+        logger.info(f"[HEARTBEAT] Boucle permanente démarrée (session={bg_session})")
+
+        while self.running:
+            try:
+                # Ne pas envoyer pendant un enregistrement (le heartbeat session s'en charge)
+                if self.session_id:
+                    time.sleep(5)
+                    continue
+
+                full_path = self._bg_vision.capture_full_context("heartbeat")
+                if not full_path:
+                    time.sleep(5)
+                    continue
+
+                # Dédup : skip si écran identique
+                img_hash = self._quick_hash(full_path)
+                if img_hash and img_hash == self._last_bg_hash:
+                    time.sleep(5)
+                    continue
+                self._last_bg_hash = img_hash
+
+                # Envoyer au streaming server (via STREAMING_ENDPOINT unifié)
+                headers = {"Authorization": f"Bearer {API_TOKEN}"} if API_TOKEN else {}
+                with open(full_path, 'rb') as f:
+                    req.post(
+                        f"{STREAMING_ENDPOINT}/image",
+                        params={
+                            "session_id": bg_session,
+                            "shot_id": f"heartbeat_{int(time.time())}",
+                            "machine_id": self.machine_id,
+                        },
+                        headers=headers,
+                        files={"file": ("screenshot.png", f, "image/png")},
+                        timeout=10,
+                        allow_redirects=False,
+                    )
+            except Exception as e:
+                logger.debug(f"[HEARTBEAT] Erreur: {e}")
+            time.sleep(5)
+
+    def _auto_update_loop(self):
+        """DETTE-022 v2 — boucle de MAJ silencieuse GATED (défaut OFF).
+
+        Interroge périodiquement le serveur (endpoint canary-aware), et si une
+        MAJ est proposée pour CE poste, la télécharge dans le STAGING après
+        vérif SHA256. Le swap réel N'EST PAS fait ici : `updater.run_update_cycle`
+        s'arrête au staging (apply_update = stub réservé révision humaine + swap
+        hors-process par Lea.bat au prochain démarrage).
+
+        SÉCURITÉ — « au bon moment » : on NE stage PAS pendant un enregistrement
+        ou un replay actif (self.session_id / self._replay_active), pour ne pas
+        perturber le travail utilisateur ni consommer du réseau au mauvais
+        moment. Best-effort : aucune exception ne remonte (ne casse jamais Léa).
+        """
+        try:
+            from .network.updater import run_update_cycle
+        except Exception as e:
+            logger.warning("[UPDATE] Module updater indisponible : %s", e)
+            return
+
+        logger.info(
+            "[UPDATE] Boucle MAJ silencieuse démarrée (intervalle=%.0fs, "
+            "version=%s) — check seul, swap réservé révision humaine",
+            AUTO_UPDATE_INTERVAL_S, AGENT_VERSION,
+        )
+
+        while self.running:
+            # Découpe l'attente pour réagir vite à l'arrêt.
+            waited = 0.0
+            step = 1.0
+            while self.running and waited < AUTO_UPDATE_INTERVAL_S:
+                time.sleep(step)
+                waited += step
+            if not self.running:
+                break
+
+            # « Au bon moment » : jamais en plein travail (enregistrement/replay).
+            if self.session_id or getattr(self, "_replay_active", False):
+                logger.debug("[UPDATE] Report du check (session/replay active)")
+                continue
+
+            try:
+                result = run_update_cycle(
+                    local_version=AGENT_VERSION,
+                    machine_id=self.machine_id,
+                    staging_dir=AUTO_UPDATE_STAGING_DIR,
+                )
+                status = result.get("status")
+                if status == "staged":
+                    logger.info(
+                        "[UPDATE] MAJ %s téléchargée en staging (SHA256=%s) — "
+                        "swap réservé révision humaine, non appliqué",
+                        result.get("target_version"),
+                        result.get("sha256_verified"),
+                    )
+                elif status not in ("up_to_date", "disabled"):
+                    logger.debug("[UPDATE] Cycle: %s", result)
+            except Exception as e:
+                # run_update_cycle est déjà best-effort ; double filet ici.
+                logger.debug("[UPDATE] Erreur boucle MAJ : %s", e)
+
+    def stop_session(self):
+        # Sauvegarder le session_id avant de l'annuler (pour les logs)
+        ended_session_id = self.session_id
+
+        # Arrêter la capture d'abord (plus d'events entrants)
+        if self.captor: self.captor.stop()
+
+        # Attendre que les events en cours de traitement dans _on_event_bridge
+        # aient le temps d'être envoyés au streamer (capture duale + push)
+        import time
+        time.sleep(1.5)
+
+        # Maintenant arrêter le streamer (drain queue + finalize)
+        if self.streamer: self.streamer.stop()
+        logger.info(f"Session {ended_session_id} terminée.")
+
+        # Reset le session_id APRÈS le stop complet du streamer
+        self.session_id = None
+
+        # Reset le backoff de l'executor pour reprendre le polling immédiatement
+        if self._executor:
+            self._executor._poll_backoff = self._executor._poll_backoff_min
+            self._executor._server_available = True
+            if hasattr(self._executor, '_last_conn_error_logged'):
+                self._executor._last_conn_error_logged = False
+
+        # NE PAS mettre self.running = False ici !
+        # self.running contrôle la boucle _replay_poll_loop (permanente).
+        # Seule la sortie du programme doit le mettre à False.
+        # Les boucles _heartbeat_loop et _command_watchdog_loop vérifieront
+        # self.session_id pour savoir si elles doivent fonctionner.
+
+        logger.info(
+            f"Session arrêtée — replay poll actif avec session="
+            f"agent_{self.user_id}"
+        )
+
+    def _on_finalize_result(self, payload: dict) -> None:
+        """Réagir au contrat enrichi de /finalize côté agent."""
+        replay_name = self._last_recording_name or "la tâche que vous venez d'enregistrer"
+        dispatch_finalize_result(self.ui, payload, replay_name)
+
+    _last_heartbeat_hash: str = ""
+
+    def _heartbeat_loop(self):
+        """Capture périodique pour donner du contexte au stagiaire.
+        Déduplication : n'envoie que si l'écran a changé.
+        Tourne tant que session_id est défini (= enregistrement actif).
+        Enrichi avec le titre de la fenêtre active pour contextualisation.
+        """
+        while self.running and self.session_id:
+            try:
+                full_path = self.vision.capture_full_context("heartbeat")
+                if full_path:
+                    # Hash rapide pour détecter les changements d'écran
+                    img_hash = self._quick_hash(full_path)
+                    if img_hash != self._last_heartbeat_hash:
+                        self._last_heartbeat_hash = img_hash
+                        self.streamer.push_image(full_path, f"heartbeat_{int(time.time())}")
+                        heartbeat_event = {
+                            "type": "heartbeat",
+                            "image": full_path,
+                            "timestamp": time.time(),
+                            "machine_id": self.machine_id,
+                        }
+                        # Ajouter le titre de la fenêtre active (léger, pas de crop)
+                        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}")
+            time.sleep(5)
+
+    @staticmethod
+    def _quick_hash(image_path: str) -> str:
+        """Hash perceptuel rapide (16x16 niveaux de gris)."""
+        try:
+            from PIL import Image
+            import hashlib
+            img = Image.open(image_path).resize((16, 16)).convert('L')
+            return hashlib.md5(img.tobytes()).hexdigest()
+        except Exception:
+            return ""
+
+    def _on_event_bridge(self, event):
+        """Pont intelligent avec capture duale et post-action monitoring."""
+        if not self.session_id:
+            return
+
+        # Injecter l'identifiant machine dans chaque événement (multi-machine)
+        event["machine_id"] = self.machine_id
+
+        # Injecter le contexte fenêtre dans chaque événement (nécessaire
+        # pour que le serveur maintienne last_window_info)
+        if self.captor and self.captor.last_window:
+            event["window"] = self.captor.last_window
+
+        # Capture Proactive sur changement de fenêtre
+        if event["type"] == "window_focus_change":
+            full_path = self.vision.capture_full_context("focus_change")
+            event["screenshot_context"] = full_path
+            self.streamer.push_image(full_path, f"focus_{int(time.time())}")
+
+        # Capture Interactive (Dual + Fenêtre active)
+        if event["type"] in ["mouse_click", "key_combo"]:
+            self.shot_counter += 1
+            shot_id = f"shot_{self.shot_counter:04d}"
+
+            pos = event.get("pos", (0, 0))
+            capture_info = self.vision.capture_dual(pos[0], pos[1], shot_id)
+
+            event["screenshot_id"] = shot_id
+            event["vision_info"] = capture_info
+
+            # Enrichir l'event avec les métadonnées de la fenêtre active
+            # (titre, rect, coordonnées clic relatives, taille fenêtre)
+            window_capture = capture_info.get("window_capture")
+            if window_capture:
+                event["window_capture"] = {
+                    "title": window_capture.get("window_title", ""),
+                    "app_name": window_capture.get("app_name", ""),
+                    "rect": window_capture.get("window_rect"),
+                    "click_relative": window_capture.get("click_in_window"),
+                    "window_size": window_capture.get("window_size"),
+                    "click_inside_window": window_capture.get("click_inside_window", True),
+                }
+
+            self._stream_capture_info(capture_info, shot_id)
+
+            # POST-ACTION : Capture du résultat après 1s (pour voir le résultat du clic)
+            threading.Timer(1.0, self._capture_result, args=(shot_id,)).start()
+
+        self.ui.update_stats(self.shot_counter)
+        self._state.update_actions_count(self.shot_counter)
+        print(f"📸 Action capturée : {event['type']}")
+        self.streamer.push_event(event)
+
+    def _capture_result(self, base_shot_id: str):
+        """Capture l'état de l'écran 1s après l'action pour voir l'effet."""
+        if not self.running: return
+        res_path = self.vision.capture_full_context(f"result_of_{base_shot_id}")
+        self.streamer.push_image(res_path, f"res_{base_shot_id}")
+        self.streamer.push_event({"type": "action_result", "base_shot_id": base_shot_id, "image": res_path})
+
+    def _stream_capture_info(self, capture_info, shot_id):
+        if "full" in capture_info:
+            self.streamer.push_image(capture_info["full"], f"{shot_id}_full")
+        if "crop" in capture_info:
+            self.streamer.push_image(capture_info["crop"], f"{shot_id}_crop")
+        # Streamer l'image de la fenêtre active si disponible
+        window_capture = capture_info.get("window_capture")
+        if window_capture and "window_image" in window_capture:
+            self.streamer.push_image(
+                window_capture["window_image"], f"{shot_id}_window"
+            )
+
+    def run(self):
+        self.ui.run()
+
+def _install_signal_handlers(agent, watchdog) -> None:
+    """Installe SIGTERM/SIGINT/SIGBREAK pour un arrêt propre du main thread.
+
+    Met ``agent.running=False`` (les daemon threads s'arrêtent) et réveille
+    le watchdog (qui sort de sa boucle de surveillance). Sans session
+    interactive (pystray.Icon.stop indisponible), c'est le SEUL moyen
+    d'arrêter Léa proprement : ``kill -TERM <pid>`` ou Ctrl+C.
+    """
+    import signal as _sig
+
+    def _handler(sig, frame):
+        logger.info(f"[MAIN] Signal {sig} recu — arret propre")
+        agent.running = False
+        watchdog.stop()
+
+    for sig_name in ("SIGTERM", "SIGINT", "SIGBREAK"):
+        sig_obj = getattr(_sig, sig_name, None)
+        if sig_obj is None:
+            continue
+        try:
+            _sig.signal(sig_obj, _handler)
+        except (ValueError, OSError):
+            pass
+
+
+def _agent_should_live(agent) -> bool:
+    """Vrai tant que Léa doit vivre : agent actif ET pas de Quitter explicite.
+
+    Un « Quitter » utilisateur (``ui._quit_requested``) doit stopper le
+    watchdog pour de bon ; une simple déconnexion RDP ne met JAMAIS ce flag
+    → le tray revient tout seul à la reconnexion.
+    """
+    if not getattr(agent, "running", False):
+        return False
+    ui = getattr(agent, "ui", None)
+    if ui is not None and getattr(ui, "_quit_requested", False):
+        return False
+    return True
+
+
+def _pending_boot_marker_exists() -> bool:
+    """True si Lea.bat a posé PENDING_BOOT (boot post-MAJ à valider)."""
+    try:
+        from .network.updater import _resolve_app_dir
+        return (_resolve_app_dir(None) / "PENDING_BOOT").exists()
+    except Exception:
+        return False
+
+
+def _confirm_boot_ok() -> None:
+    """Confirme un boot post-MAJ : écrit boot_ok + retire PENDING_BOOT.
+
+    Désarme le rollback de Lea.bat. No-op si pas de PENDING_BOOT (boot normal).
+    Best-effort — ne doit jamais casser l'arrêt/la vie de Léa.
+    """
+    try:
+        if not _pending_boot_marker_exists():
+            return
+        from .network import updater
+        updater.write_boot_ok_marker(AGENT_VERSION)
+        logger.info("[MAJ] Boot confirmé (v%s) — rollback désarmé", AGENT_VERSION)
+    except Exception as e:  # noqa: BLE001
+        logger.debug("confirm_boot_ok: %s", e)
+
+
+def main():
+    from .ui.session_watchdog import InteractiveSessionWatchdog
+
+    agent = AgentV1()
+
+    # Résilience RDP/Citrix : au lieu de bloquer le main thread pour toujours
+    # quand pystray sort (session interactive perdue), on surveille la
+    # session et on ré-affiche le tray + le chat à chaque reconnexion.
+    # agent.run() (== agent.ui.run()) est ré-entrant : les threads de fond
+    # ne démarrent qu'une fois, seule l'icône est recréée. Les daemon threads
+    # de capture/heartbeat/replay tournent contre agent.running et restent
+    # uniques — le watchdog n'y touche pas.
+    watchdog = InteractiveSessionWatchdog(
+        run_ui=agent.run,
+        is_running=lambda: _agent_should_live(agent),
+    )
+    _install_signal_handlers(agent, watchdog)
+
+    try:
+        watchdog.run()
+        # Sortie normale du watchdog = quit propre (tray / session) → le boot
+        # était sain : on confirme (couvre un quit AVANT les 90 s, évite un faux
+        # rollback). No-op si ce n'est pas un boot post-MAJ.
+        _confirm_boot_ok()
+    except KeyboardInterrupt:
+        logger.info("[MAIN] Interruption clavier — arret propre")
+    except Exception:
+        logger.exception("[MAIN] Le watchdog de session a leve une exception")
+    finally:
+        agent.running = False
+        logger.info("[MAIN] Sortie — agent.running=False, daemon threads vont s'arreter")
+
+
+if __name__ == "__main__":
+    main()

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/network/lea_orchestrator_client.py

@@ -0,0 +1,147 @@
+"""
+Client HTTP minimal pour l'orchestrateur Léa-first (agent-chat Linux).
+
+Rebranchement P1-LEA-SHADOW : le bouton "Apprenez-moi" côté Windows déclenche
+la création d'une session d'apprentissage côté agent-chat (REST) AVANT de
+lancer la capture locale. Le pipeline streaming (capture frames/événements
+via start_recording) n'est PAS modifié — seule la prise de contact initiale
+avec Léa change.
+
+Contrat :
+    POST {AGENT_CHAT_URL}/api/learn/start
+    Headers : Authorization: Bearer <RPA_API_TOKEN>, Content-Type: application/json
+    Body    : { machine_id, session_name, user_id?, trigger_source }
+    Réponse : { session_id, state, message }
+
+Politique :
+    - Timeout 10s (connect + read)
+    - Retry x2 avec backoff 0.5s puis 1.0s
+    - En cas d'échec définitif : lève LeaOrchestratorError (le caller doit
+      basculer en mode dégradé : start_recording local sans assistance).
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from dataclasses import dataclass
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+# Timeout HTTP (connect + read) — 10s comme spec
+_HTTP_TIMEOUT_S = 10.0
+# Nombre de tentatives totales (1 + 2 retry)
+_MAX_ATTEMPTS = 3
+# Backoff progressif entre les tentatives
+_BACKOFF_S = (0.5, 1.0)
+
+
+@dataclass(frozen=True)
+class LearnStartResponse:
+    """Réponse normalisée de POST /api/learn/start."""
+
+    session_id: str
+    state: str
+    message: str
+
+
+class LeaOrchestratorError(RuntimeError):
+    """Erreur définitive de communication avec l'orchestrateur Léa."""
+
+
+def start_learning_session(
+    base_url: str,
+    *,
+    machine_id: str,
+    session_name: str,
+    api_token: str = "",
+    user_id: Optional[str] = None,
+    trigger_source: str = "windows_button",
+    timeout_s: float = _HTTP_TIMEOUT_S,
+    max_attempts: int = _MAX_ATTEMPTS,
+    backoff_s: tuple = _BACKOFF_S,
+) -> LearnStartResponse:
+    """Démarre une session d'apprentissage via l'orchestrateur agent-chat.
+
+    Args:
+        base_url: URL racine de l'agent-chat (ex. http://localhost:5004).
+        machine_id: Identifiant unique du poste Windows.
+        session_name: Nom humain de la tâche (saisi par l'utilisateur).
+        api_token: Bearer token (RPA_API_TOKEN). Vide => header omis.
+        user_id: Identifiant utilisateur optionnel.
+        trigger_source: Source du déclenchement (windows_button, tray, ...).
+        timeout_s: Timeout total connect+read par tentative.
+        max_attempts: Nombre total de tentatives (1 + retry).
+        backoff_s: Tuple des délais en secondes entre tentatives (len = max_attempts-1).
+
+    Returns:
+        LearnStartResponse normalisée.
+
+    Raises:
+        LeaOrchestratorError: si toutes les tentatives échouent.
+    """
+    # Import local : httpx peut ne pas être installé sur tous les postes
+    # Windows historiques. On veut un message d'erreur clair plutôt qu'un
+    # ImportError en chaîne au moment du clic bouton.
+    try:
+        import httpx
+    except ImportError as exc:  # pragma: no cover (dépend du venv)
+        raise LeaOrchestratorError(
+            "httpx non disponible — installer httpx>=0.27 sur le poste Windows."
+        ) from exc
+
+    url = base_url.rstrip("/") + "/api/learn/start"
+    payload = {
+        "machine_id": machine_id,
+        "session_name": session_name,
+        "trigger_source": trigger_source,
+    }
+    if user_id:
+        payload["user_id"] = user_id
+
+    headers = {"Content-Type": "application/json"}
+    if api_token:
+        headers["Authorization"] = f"Bearer {api_token}"
+
+    last_exc: Optional[Exception] = None
+    for attempt in range(max_attempts):
+        try:
+            logger.info(
+                "POST %s (tentative %d/%d) machine_id=%s session=%s",
+                url, attempt + 1, max_attempts, machine_id, session_name,
+            )
+            with httpx.Client(timeout=timeout_s) as client:
+                resp = client.post(url, json=payload, headers=headers)
+            resp.raise_for_status()
+            data = resp.json()
+            session_id = data.get("session_id", "")
+            state = data.get("state", "")
+            message = data.get("message", "")
+            if not session_id:
+                raise LeaOrchestratorError(
+                    f"Réponse invalide (pas de session_id) : {data!r}"
+                )
+            logger.info(
+                "Session Léa démarrée : session_id=%s state=%s",
+                session_id, state,
+            )
+            return LearnStartResponse(
+                session_id=str(session_id),
+                state=str(state),
+                message=str(message),
+            )
+        except Exception as exc:  # noqa: BLE001 — on retry sur toute erreur réseau/HTTP
+            last_exc = exc
+            logger.warning(
+                "Echec tentative %d/%d POST %s : %s",
+                attempt + 1, max_attempts, url, exc,
+            )
+            if attempt < max_attempts - 1:
+                delay = backoff_s[attempt] if attempt < len(backoff_s) else backoff_s[-1]
+                time.sleep(delay)
+
+    raise LeaOrchestratorError(
+        f"Echec définitif POST {url} après {max_attempts} tentatives : {last_exc}"
+    )

agent_v0/agent_v1/network/log_shipper.py

@@ -0,0 +1,317 @@
+# agent_v1/network/log_shipper.py
+"""Remontée AUTOMATIQUE des logs du client Léa vers le serveur (push-log-DGX).
+
+But : diagnostiquer les postes Windows clinique SANS AnyDesk. Les logs déjà
+écrits sur disque par `logging_setup.py` (rotation quotidienne, rétention 180 j,
+Règlement IA Art. 12) sont en plus poussés au serveur, rangés par `machine_id`,
+consultables au dashboard.
+
+Serveur (déjà prêt — NE PAS toucher) :
+    POST /api/v1/agents/logs
+    body = {machine_id: str, logs: [{ts, level, logger, message}]}
+    borne RPA_AGENT_LOGS_MAX_BATCH (défaut 1000) — 413 si dépassée.
+
+Conception :
+    - `LogShipperHandler(logging.Handler)` : sur `emit(record)`, formate au
+      schéma EXACT `{ts, level, logger, message}`, applique un assainissement
+      PII au message (défense en profondeur — la discipline `log_safe` à la
+      source logue déjà des hashes/longueurs, pas du contenu brut), puis
+      empile dans un buffer borné.
+    - `LogShipper` : flush par BATCH (≤ max_batch) via un `sender` callable
+      INJECTABLE `(machine_id, logs) -> bool`. Défaut = POST réel Bearer
+      (pattern `streamer.py`).
+    - Résilience (ZÉRO perte) : si `sender` renvoie False ou lève, les logs
+      RESTENT dans le buffer et sont rejoués au flush suivant. Le fichier de
+      log local reste de toute façon la source durable (survit au crash) ; le
+      buffer RAM est un best-effort de remontée, volontairement NON persisté en
+      SQLite (le `PersistentBuffer` est session/event-scoped — y mêler des logs
+      polluerait la DB d'events). Borne mémoire = `max_buffer` (drop des plus
+      VIEUX au-delà — un log récent vaut mieux qu'un vieux pour le diagnostic).
+
+Pattern d'import PII : on tente `anonymize_text` (server_v1.pii_sanitizer,
+source de vérité des tokens typés) via le même import paresseux tolérant que
+`ui/messages.py`. Sur un vrai poste (sans server_v1), on retombe sur l'identité :
+acceptable car la PII de message est déjà neutralisée à la source par la
+discipline `log_safe`. Le sanitizer reste INJECTABLE pour les tests/évolutions.
+
+Branche feat/push-log-dgx.
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+import time
+from collections import deque
+from typing import Callable, Deque, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+# Schéma d'une entrée de log poussée au serveur.
+#   ts      : epoch (float) — l'heure de l'évènement
+#   level   : nom du niveau ("INFO", "WARNING"...)
+#   logger  : nom du logger (record.name)
+#   message : message formaté (args interpolés) ET assaini PII
+
+# Défaut aligné sur la borne serveur RPA_AGENT_LOGS_MAX_BATCH (api_stream.py).
+DEFAULT_MAX_BATCH = 1000
+
+# Borne mémoire du buffer : au-delà, on droppe les plus VIEUX (diagnostic =
+# on préfère les logs récents). Quelques milliers d'entrées = quelques Mo RAM.
+DEFAULT_MAX_BUFFER = 5000
+
+
+# ---------------------------------------------------------------------------
+# Assainissement PII du message (défense en profondeur)
+# ---------------------------------------------------------------------------
+
+def _default_message_sanitizer(text: str) -> str:
+    """Sanitizer par défaut côté client = identité.
+
+    Le **rempart PII des logs est le SERVEUR** : `sanitize_log_entries`
+    ré-assainit chaque message à la réception (`/api/v1/agents/logs`), via le
+    même `anonymize_text` que les events. Tenter un import de `server_v1` côté
+    poste à CHAQUE ligne de log est inutile (absent du bundle client) et coûteux
+    (exception attrapée par emit). La discipline `log_safe` neutralise déjà la
+    PII à la source. Reste INJECTABLE pour tests/évolutions.
+    """
+    return text
+
+
+# ---------------------------------------------------------------------------
+# Handler — empile les LogRecords dans un buffer partagé
+# ---------------------------------------------------------------------------
+
+class LogShipperHandler(logging.Handler):
+    """Handler logging qui sérialise chaque record et l'empile pour envoi.
+
+    Ne fait AUCUN réseau : il alimente seulement le buffer du `LogShipper`.
+    L'envoi est piloté par `LogShipper.flush()` (thread dédié périodique).
+    """
+
+    def __init__(
+        self,
+        buffer: Deque[Dict],
+        lock: threading.Lock,
+        message_sanitizer: Callable[[str], str],
+        max_buffer: int = DEFAULT_MAX_BUFFER,
+        level=logging.NOTSET,
+    ):
+        super().__init__(level=level)
+        self._buffer = buffer
+        self._lock = lock
+        self._sanitize = message_sanitizer
+        self._max_buffer = max_buffer
+
+    def _format_record(self, record: logging.LogRecord) -> Dict:
+        """Construit l'entrée au schéma EXACT {ts, level, logger, message}.
+
+        `record.getMessage()` interpole les args (%s...). Le message est ensuite
+        passé au sanitizer PII. Tolérant : un message non formatable ne doit pas
+        faire perdre l'entrée.
+        """
+        try:
+            message = record.getMessage()
+        except Exception:
+            message = str(record.msg)
+        try:
+            message = self._sanitize(message)
+        except Exception:
+            # Le sanitizer ne doit jamais casser le logging.
+            pass
+        return {
+            "ts": record.created,
+            "level": record.levelname,
+            "logger": record.name,
+            "message": message,
+        }
+
+    def emit(self, record: logging.LogRecord) -> None:
+        """Sérialise et empile le record (best-effort, ne lève jamais)."""
+        try:
+            entry = self._format_record(record)
+            with self._lock:
+                # deque(maxlen) droppe automatiquement le plus VIEUX au-delà
+                # de la borne — pas de croissance mémoire non bornée.
+                self._buffer.append(entry)
+        except Exception:
+            # handleError respecte logging.raiseExceptions (silencieux en prod).
+            self.handleError(record)
+
+
+# ---------------------------------------------------------------------------
+# Shipper — flush périodique par batch via un sender injectable
+# ---------------------------------------------------------------------------
+
+class LogShipper:
+    """Orchestre la remontée des logs : buffer + flush par batch.
+
+    Args:
+        machine_id : identifiant du poste (config.MACHINE_ID en prod).
+        sender     : callable INJECTABLE `(machine_id, logs) -> bool`. True =
+                     accusé de réception serveur. Défaut = POST réel Bearer.
+        max_batch  : taille max d'un batch (≤ borne serveur). Défaut 1000.
+        max_buffer : borne mémoire du buffer (drop des plus vieux au-delà).
+        message_sanitizer : assainissement PII du message. Défaut = pii_sanitizer
+                     si disponible, sinon identité.
+    """
+
+    def __init__(
+        self,
+        machine_id: str,
+        sender: Optional[Callable[[str, List[Dict]], bool]] = None,
+        max_batch: int = DEFAULT_MAX_BATCH,
+        max_buffer: int = DEFAULT_MAX_BUFFER,
+        message_sanitizer: Optional[Callable[[str], str]] = None,
+        flush_interval_s: float = 30.0,
+    ):
+        self.machine_id = machine_id
+        self.max_batch = max(1, int(max_batch))
+        self.flush_interval_s = flush_interval_s
+        self._sender = sender if sender is not None else self._default_sender
+        self._sanitize = message_sanitizer or _default_message_sanitizer
+        self._lock = threading.Lock()
+        self._buffer: Deque[Dict] = deque(maxlen=max_buffer)
+        self.handler = LogShipperHandler(
+            buffer=self._buffer,
+            lock=self._lock,
+            message_sanitizer=self._sanitize,
+            max_buffer=max_buffer,
+        )
+        self._running = False
+        self._thread: Optional[threading.Thread] = None
+
+    # ------------------------------------------------------------------
+    # Introspection (diagnostic / tests)
+    # ------------------------------------------------------------------
+
+    def peek_buffer(self) -> List[Dict]:
+        """Copie des entrées en attente (lecture seule, pour diagnostic/tests)."""
+        with self._lock:
+            return list(self._buffer)
+
+    def pending(self) -> int:
+        with self._lock:
+            return len(self._buffer)
+
+    # ------------------------------------------------------------------
+    # Flush — envoie le buffer par batches ≤ max_batch
+    # ------------------------------------------------------------------
+
+    def flush(self) -> int:
+        """Envoie le buffer par batches successifs. Retourne le nb de logs ACK.
+
+        Résilience ZÉRO perte : on retire un batch du buffer, on tente l'envoi.
+        - Succès  → les entrées sont définitivement consommées.
+        - Échec (False ou exception) → on REMET les entrées en tête du buffer
+          et on ARRÊTE la passe (serveur probablement down) ; rejeu au flush
+          suivant. Les entrées non encore extraites restent en place.
+        """
+        sent = 0
+        while True:
+            with self._lock:
+                if not self._buffer:
+                    break
+                batch: List[Dict] = []
+                for _ in range(min(self.max_batch, len(self._buffer))):
+                    batch.append(self._buffer.popleft())
+
+            try:
+                ok = self._sender(self.machine_id, batch)
+            except Exception as e:
+                ok = False
+                logger.debug("Log shipper sender a levé : %s", e)
+
+            if ok:
+                sent += len(batch)
+                continue
+
+            # Échec : on remet le batch en tête (ordre préservé) et on arrête.
+            with self._lock:
+                self._buffer.extendleft(reversed(batch))
+            break
+
+        return sent
+
+    # ------------------------------------------------------------------
+    # Sender réel — POST Bearer (pattern streamer.py)
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _auth_headers() -> dict:
+        """Headers Bearer (pattern streamer.py)."""
+        try:
+            from ..config import API_TOKEN
+        except Exception:
+            API_TOKEN = ""
+        if API_TOKEN:
+            return {"Authorization": f"Bearer {API_TOKEN}"}
+        return {}
+
+    def _default_sender(self, machine_id: str, logs: List[Dict]) -> bool:
+        """POST réel vers /api/v1/agents/logs. True si HTTP 2xx.
+
+        Best-effort : tout échec réseau/serveur → False (logs conservés,
+        rejoués). Aucune exception ne remonte au-delà du sender.
+        """
+        try:
+            import requests
+
+            from ..config import SERVER_URL
+
+            url = f"{SERVER_URL}/agents/logs"
+            resp = requests.post(
+                url,
+                json={"machine_id": machine_id, "logs": logs},
+                headers=self._auth_headers(),
+                timeout=5,
+                allow_redirects=False,
+            )
+            return bool(resp.ok)
+        except Exception as e:
+            logger.debug("Log shipper POST échoué : %s", e)
+            return False
+
+    # ------------------------------------------------------------------
+    # Boucle de flush périodique (thread daemon)
+    # ------------------------------------------------------------------
+
+    def start(self) -> None:
+        """Démarre le thread de flush périodique (idempotent)."""
+        if self._running:
+            return
+        self._running = True
+        self._thread = threading.Thread(
+            target=self._flush_loop, daemon=True, name="lea-log-shipper"
+        )
+        self._thread.start()
+        logger.info(
+            "Log shipper démarré (machine_id=%s, intervalle=%.0fs, batch≤%d)",
+            self.machine_id, self.flush_interval_s, self.max_batch,
+        )
+
+    def stop(self, final_flush: bool = True) -> None:
+        """Arrête la boucle et tente un dernier flush (best-effort)."""
+        self._running = False
+        if self._thread:
+            self._thread.join(timeout=2.0)
+        if final_flush:
+            try:
+                self.flush()
+            except Exception:
+                pass
+
+    def _flush_loop(self) -> None:
+        while self._running:
+            # Découpe l'attente pour réagir vite à stop().
+            waited = 0.0
+            step = 0.5
+            while self._running and waited < self.flush_interval_s:
+                time.sleep(step)
+                waited += step
+            if not self._running:
+                break
+            try:
+                self.flush()
+            except Exception as e:
+                logger.debug("Log shipper flush loop : %s", e)

agent_v0/agent_v1/network/persistent_buffer.py

@@ -0,0 +1,380 @@
+# agent_v1/network/persistent_buffer.py
+"""
+Buffer persistant SQLite pour les événements/images qui n'ont pas pu être envoyés.
+
+Résout le bloquant AI Act Article 12 : en cas de coupure serveur ou de queue pleine,
+les événements prioritaires (click, key, action, screenshot) sont persistés sur disque
+au lieu d'être silencieusement perdus. Ils sont rejoués à la reconnexion.
+
+Caractéristiques :
+    - SQLite fichier unique (agent_v1/buffer/pending_events.db), thread-safe
+    - Async : les écritures se font depuis un thread daemon, jamais bloquant
+    - Quota : compteur d'attempts par item, abandon après MAX_ATTEMPTS
+    - Robustesse : un fichier corrompu est renommé et recréé vide
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import sqlite3
+import threading
+import time
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# Nombre max de tentatives avant abandon définitif d'un item
+MAX_ATTEMPTS = 10
+
+# Taille max du buffer en items pour éviter une explosion disque
+# (typiquement : 1000 events + 1000 images = quelques Mo de SQLite)
+MAX_BUFFER_ITEMS = 2000
+
+
+class PersistentBuffer:
+    """Buffer SQLite pour événements/images en attente d'envoi.
+
+    Deux tables :
+        - pending_events (id, session_id, payload_json, attempts, created_at)
+        - pending_images (id, session_id, shot_id, image_path, attempts, created_at)
+
+    Usage :
+        buf = PersistentBuffer(base_dir / "buffer")
+        buf.add_event(session_id, event_dict)           # persiste un event
+        buf.add_image(session_id, image_path, shot_id)  # persiste une image
+        for row in buf.drain_events():                  # itère sur les events
+            if envoyer(row): buf.delete_event(row["id"])
+            else:           buf.mark_attempt(row["id"], "event")
+    """
+
+    def __init__(self, buffer_dir: Path):
+        self.buffer_dir = Path(buffer_dir)
+        self.buffer_dir.mkdir(parents=True, exist_ok=True)
+        self.db_path = self.buffer_dir / "pending_events.db"
+        self._lock = threading.Lock()
+        self._init_db()
+
+    # ---------------------------------------------------------------
+    # Initialisation / gestion corruption
+    # ---------------------------------------------------------------
+
+    def _init_db(self):
+        """Crée les tables si elles n'existent pas.
+
+        En cas de fichier corrompu, on le renomme en .corrupted et on recrée
+        un buffer vide. On préfère perdre un buffer non lisible plutôt que
+        de crasher l'agent au démarrage.
+        """
+        try:
+            with self._connect() as conn:
+                conn.execute(
+                    """
+                    CREATE TABLE IF NOT EXISTS pending_events (
+                        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+                        session_id  TEXT    NOT NULL,
+                        payload     TEXT    NOT NULL,
+                        attempts    INTEGER NOT NULL DEFAULT 0,
+                        created_at  REAL    NOT NULL
+                    )
+                    """
+                )
+                conn.execute(
+                    """
+                    CREATE TABLE IF NOT EXISTS pending_images (
+                        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+                        session_id  TEXT    NOT NULL,
+                        shot_id     TEXT    NOT NULL,
+                        image_path  TEXT    NOT NULL,
+                        attempts    INTEGER NOT NULL DEFAULT 0,
+                        created_at  REAL    NOT NULL
+                    )
+                    """
+                )
+                conn.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_events_created "
+                    "ON pending_events(created_at)"
+                )
+                conn.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_images_created "
+                    "ON pending_images(created_at)"
+                )
+                conn.commit()
+        except sqlite3.DatabaseError as e:
+            logger.warning(
+                f"Buffer SQLite corrompu ({e}) — renommage en .corrupted "
+                f"et recréation d'un buffer vide"
+            )
+            try:
+                corrupted = self.db_path.with_suffix(
+                    f".corrupted.{int(time.time())}"
+                )
+                os.rename(self.db_path, corrupted)
+            except OSError:
+                # Si le rename échoue, on tente la suppression directe
+                try:
+                    os.remove(self.db_path)
+                except OSError:
+                    pass
+            # Nouvelle tentative (table vide)
+            with self._connect() as conn:
+                conn.execute(
+                    "CREATE TABLE IF NOT EXISTS pending_events ("
+                    "id INTEGER PRIMARY KEY AUTOINCREMENT, "
+                    "session_id TEXT NOT NULL, payload TEXT NOT NULL, "
+                    "attempts INTEGER NOT NULL DEFAULT 0, "
+                    "created_at REAL NOT NULL)"
+                )
+                conn.execute(
+                    "CREATE TABLE IF NOT EXISTS pending_images ("
+                    "id INTEGER PRIMARY KEY AUTOINCREMENT, "
+                    "session_id TEXT NOT NULL, shot_id TEXT NOT NULL, "
+                    "image_path TEXT NOT NULL, "
+                    "attempts INTEGER NOT NULL DEFAULT 0, "
+                    "created_at REAL NOT NULL)"
+                )
+                conn.commit()
+
+    def _connect(self) -> sqlite3.Connection:
+        """Connexion SQLite en mode WAL (meilleure concurrence)."""
+        conn = sqlite3.connect(
+            str(self.db_path),
+            timeout=5.0,
+            check_same_thread=False,
+            isolation_level=None,  # autocommit — on gère les transactions
+        )
+        try:
+            conn.execute("PRAGMA journal_mode=WAL")
+            conn.execute("PRAGMA synchronous=NORMAL")
+        except sqlite3.DatabaseError:
+            pass
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    # ---------------------------------------------------------------
+    # Écriture — persiste un item
+    # ---------------------------------------------------------------
+
+    def add_event(self, session_id: str, event: dict) -> bool:
+        """Persiste un événement. Retourne True si écrit, False sinon.
+
+        Si le buffer dépasse MAX_BUFFER_ITEMS, on drop l'insertion (plutôt
+        que saturer le disque). On log un warning au premier dépassement.
+        """
+        with self._lock:
+            try:
+                with self._connect() as conn:
+                    count = conn.execute(
+                        "SELECT COUNT(*) FROM pending_events"
+                    ).fetchone()[0]
+                    if count >= MAX_BUFFER_ITEMS:
+                        logger.warning(
+                            f"Buffer persistant saturé ({count} events) "
+                            f"— event droppé"
+                        )
+                        return False
+                    conn.execute(
+                        "INSERT INTO pending_events "
+                        "(session_id, payload, attempts, created_at) "
+                        "VALUES (?, ?, 0, ?)",
+                        (session_id, json.dumps(event), time.time()),
+                    )
+                return True
+            except (sqlite3.DatabaseError, TypeError, ValueError) as e:
+                logger.error(f"Buffer add_event échoué : {e}")
+                return False
+
+    def add_image(
+        self, session_id: str, image_path: str, shot_id: str
+    ) -> bool:
+        """Persiste une référence image (chemin fichier + shot_id).
+
+        On ne stocke PAS les bytes de l'image (risque de faire gonfler la DB) :
+        uniquement le chemin. Donc l'image doit rester présente sur disque
+        tant qu'elle n'a pas été envoyée avec succès au serveur.
+        """
+        with self._lock:
+            try:
+                with self._connect() as conn:
+                    count = conn.execute(
+                        "SELECT COUNT(*) FROM pending_images"
+                    ).fetchone()[0]
+                    if count >= MAX_BUFFER_ITEMS:
+                        logger.warning(
+                            f"Buffer persistant saturé ({count} images) "
+                            f"— image droppée"
+                        )
+                        return False
+                    conn.execute(
+                        "INSERT INTO pending_images "
+                        "(session_id, shot_id, image_path, attempts, created_at) "
+                        "VALUES (?, ?, ?, 0, ?)",
+                        (session_id, shot_id, image_path, time.time()),
+                    )
+                return True
+            except sqlite3.DatabaseError as e:
+                logger.error(f"Buffer add_image échoué : {e}")
+                return False
+
+    # ---------------------------------------------------------------
+    # Lecture — drain dans l'ordre chronologique
+    # ---------------------------------------------------------------
+
+    def drain_events(self, limit: int = 100) -> list:
+        """Retourne les events en attente, triés par date de création."""
+        with self._lock:
+            try:
+                with self._connect() as conn:
+                    rows = conn.execute(
+                        "SELECT id, session_id, payload, attempts "
+                        "FROM pending_events "
+                        "ORDER BY created_at ASC LIMIT ?",
+                        (limit,),
+                    ).fetchall()
+                return [dict(r) for r in rows]
+            except sqlite3.DatabaseError as e:
+                logger.error(f"Buffer drain_events échoué : {e}")
+                return []
+
+    def drain_images(self, limit: int = 50) -> list:
+        """Retourne les images en attente, triées par date de création."""
+        with self._lock:
+            try:
+                with self._connect() as conn:
+                    rows = conn.execute(
+                        "SELECT id, session_id, shot_id, image_path, attempts "
+                        "FROM pending_images "
+                        "ORDER BY created_at ASC LIMIT ?",
+                        (limit,),
+                    ).fetchall()
+                return [dict(r) for r in rows]
+            except sqlite3.DatabaseError as e:
+                logger.error(f"Buffer drain_images échoué : {e}")
+                return []
+
+    # ---------------------------------------------------------------
+    # Marquage — succès, échec, abandon
+    # ---------------------------------------------------------------
+
+    def delete_event(self, row_id: int):
+        """Supprime un event après envoi réussi."""
+        with self._lock:
+            try:
+                with self._connect() as conn:
+                    conn.execute(
+                        "DELETE FROM pending_events WHERE id = ?", (row_id,)
+                    )
+            except sqlite3.DatabaseError as e:
+                logger.error(f"Buffer delete_event échoué : {e}")
+
+    def delete_image(self, row_id: int):
+        """Supprime une image après envoi réussi."""
+        with self._lock:
+            try:
+                with self._connect() as conn:
+                    conn.execute(
+                        "DELETE FROM pending_images WHERE id = ?", (row_id,)
+                    )
+            except sqlite3.DatabaseError as e:
+                logger.error(f"Buffer delete_image échoué : {e}")
+
+    def increment_attempts(self, row_id: int, kind: str) -> int:
+        """Incrémente le compteur d'attempts. Retourne la nouvelle valeur.
+
+        kind : "event" ou "image"
+        """
+        table = "pending_events" if kind == "event" else "pending_images"
+        with self._lock:
+            try:
+                with self._connect() as conn:
+                    conn.execute(
+                        f"UPDATE {table} SET attempts = attempts + 1 "
+                        "WHERE id = ?",
+                        (row_id,),
+                    )
+                    row = conn.execute(
+                        f"SELECT attempts FROM {table} WHERE id = ?", (row_id,)
+                    ).fetchone()
+                return int(row["attempts"]) if row else MAX_ATTEMPTS
+            except sqlite3.DatabaseError as e:
+                logger.error(f"Buffer increment_attempts échoué : {e}")
+                return MAX_ATTEMPTS
+
+    def abandon_exceeded(self) -> int:
+        """Supprime les items ayant dépassé MAX_ATTEMPTS.
+
+        Un item abandonné est logué en erreur (trace AI Act) puis supprimé.
+        Retourne le nombre d'items abandonnés.
+        """
+        abandoned = 0
+        with self._lock:
+            try:
+                with self._connect() as conn:
+                    # Events abandonnés
+                    rows = conn.execute(
+                        "SELECT id, session_id, payload FROM pending_events "
+                        "WHERE attempts >= ?",
+                        (MAX_ATTEMPTS,),
+                    ).fetchall()
+                    for r in rows:
+                        try:
+                            event_type = json.loads(r["payload"]).get(
+                                "type", "?"
+                            )
+                        except (ValueError, TypeError):
+                            event_type = "?"
+                        logger.error(
+                            f"Buffer : event abandonné après {MAX_ATTEMPTS} "
+                            f"tentatives — session={r['session_id']} "
+                            f"type={event_type}"
+                        )
+                        abandoned += 1
+                    conn.execute(
+                        "DELETE FROM pending_events WHERE attempts >= ?",
+                        (MAX_ATTEMPTS,),
+                    )
+
+                    # Images abandonnées
+                    rows = conn.execute(
+                        "SELECT id, session_id, shot_id FROM pending_images "
+                        "WHERE attempts >= ?",
+                        (MAX_ATTEMPTS,),
+                    ).fetchall()
+                    for r in rows:
+                        logger.error(
+                            f"Buffer : image abandonnée après {MAX_ATTEMPTS} "
+                            f"tentatives — session={r['session_id']} "
+                            f"shot_id={r['shot_id']}"
+                        )
+                        abandoned += 1
+                    conn.execute(
+                        "DELETE FROM pending_images WHERE attempts >= ?",
+                        (MAX_ATTEMPTS,),
+                    )
+            except sqlite3.DatabaseError as e:
+                logger.error(f"Buffer abandon_exceeded échoué : {e}")
+        return abandoned
+
+    # ---------------------------------------------------------------
+    # Introspection
+    # ---------------------------------------------------------------
+
+    def counts(self) -> dict:
+        """Retourne (events_count, images_count) pour diagnostic."""
+        with self._lock:
+            try:
+                with self._connect() as conn:
+                    ev = conn.execute(
+                        "SELECT COUNT(*) FROM pending_events"
+                    ).fetchone()[0]
+                    im = conn.execute(
+                        "SELECT COUNT(*) FROM pending_images"
+                    ).fetchone()[0]
+                return {"events": ev, "images": im}
+            except sqlite3.DatabaseError:
+                return {"events": 0, "images": 0}
+
+    def is_empty(self) -> bool:
+        c = self.counts()
+        return c["events"] == 0 and c["images"] == 0

agent_v0/agent_v1/network/streamer.py

@@ -0,0 +1,755 @@
+# agent_v1/network/streamer.py
+"""
+Streaming temps réel pour Agent V1.
+Exploite la fibre pour envoyer les événements au fur et à mesure.
+
+Endpoints serveur (api_stream.py, port 5005) :
+    POST /api/v1/traces/stream/register  — enregistrer la session
+    POST /api/v1/traces/stream/event     — événement temps réel
+    POST /api/v1/traces/stream/image     — screenshot (full ou crop)
+    POST /api/v1/traces/stream/finalize  — clôturer et construire le workflow
+
+Robustesse (P0-2) :
+    - Retry avec backoff exponentiel (1s/2s/4s, max 3 tentatives)
+    - Health-check périodique (30s) pour recovery du flag _server_available
+    - Compression JPEG qualité 85 pour les images (réduction ~5-10x)
+    - Backpressure : queue bornée (maxsize=100), drop des heartbeat si pleine
+
+Conformité AI Act (Article 12 — journalisation automatique) :
+    - Purge après ACK : les screenshots locaux sont supprimés après HTTP 200
+      du serveur (par défaut). Le serveur devient la source de vérité.
+    - Buffer persistant : les events/images prioritaires non envoyés sont
+      persistés dans un SQLite local (agent_v1/buffer/pending_events.db)
+      et rejoués au démarrage et à la reconnexion.
+"""
+
+import enum
+import io
+import logging
+import os
+import queue
+import threading
+import time
+from typing import Callable, Optional
+
+import requests
+from PIL import Image
+
+from ..config import API_TOKEN, BASE_DIR, STREAMING_ENDPOINT
+from ..core.log_safe import _title_hash
+from .persistent_buffer import MAX_ATTEMPTS, PersistentBuffer
+
+
+# Fix P0-E : résultat d'envoi d'image trivaleur (succès / échec réseau / fichier
+# disparu). On ne doit PAS considérer un FileNotFoundError comme un succès
+# HTTP 200 — sinon le buffer SQLite supprime l'entrée alors que le serveur n'a
+# jamais reçu l'image (perte silencieuse).
+class ImageSendResult(enum.Enum):
+    OK = "ok"                 # HTTP 200, serveur a accusé réception
+    FAILED = "failed"         # Erreur réseau/serveur récupérable (retry OK)
+    FILE_GONE = "file_gone"   # Fichier local introuvable (abandon, pas retry)
+
+logger = logging.getLogger(__name__)
+
+# Paramètres de retry
+MAX_RETRIES = 3
+RETRY_DELAYS = [1.0, 2.0, 4.0]  # Backoff exponentiel
+
+# Paramètres de health-check
+HEALTH_CHECK_INTERVAL_S = 30
+
+# Paramètres de compression
+JPEG_QUALITY = 85
+
+# Taille max de la queue (backpressure)
+QUEUE_MAX_SIZE = 100
+
+# Types d'événements à ne jamais dropper.
+# Les noms historiques sont conservés, mais les événements réels du captor
+# Agent V1 sont mouse_click/key_combo/text_input/mouse_scroll.
+PRIORITY_EVENT_TYPES = {
+    "click", "key", "scroll", "action", "screenshot",
+    "mouse_click", "double_click", "key_combo", "key_press",
+    "text_input", "mouse_scroll",
+}
+
+# Purge locale après ACK serveur (Partie A de l'audit)
+# Activé par défaut : le serveur conserve déjà les screenshots 180 jours
+# (conformité AI Act Article 12). Désactivable via RPA_PURGE_AFTER_ACK=0
+# pour debugging local.
+PURGE_AFTER_ACK = os.environ.get("RPA_PURGE_AFTER_ACK", "1").lower() in (
+    "1", "true", "yes",
+)
+
+# Chemin du buffer persistant (Partie B de l'audit)
+BUFFER_DIR = BASE_DIR / "buffer"
+
+# Intervalle entre deux tentatives de drain du buffer (secondes)
+BUFFER_DRAIN_INTERVAL_S = 15
+
+
+class TraceStreamer:
+    def __init__(self, session_id: str, machine_id: str = "default"):
+        self.session_id = session_id
+        self.machine_id = machine_id  # Identifiant machine pour le multi-machine
+        self.queue: queue.Queue = queue.Queue(maxsize=QUEUE_MAX_SIZE)
+        self.running = False
+        self._thread = None
+        self._health_thread = None
+        self._drain_thread = None
+        self._server_available = True  # Désactivé après trop d'échecs
+
+        # Buffer persistant — partagé entre sessions (survit au redémarrage)
+        # Initialisé paresseusement pour ne pas payer le coût SQLite en dehors
+        # d'un streaming actif.
+        self._buffer: PersistentBuffer | None = None
+        self._on_finalize_result: Optional[Callable[[dict], None]] = None
+
+    def set_on_finalize_result(self, callback: Optional[Callable[[dict], None]]) -> None:
+        """Définir un callback appelé avec le payload JSON de /finalize."""
+        self._on_finalize_result = callback
+
+    def _get_buffer(self) -> PersistentBuffer:
+        """Retourne le buffer persistant, en l'initialisant au besoin."""
+        if self._buffer is None:
+            self._buffer = PersistentBuffer(BUFFER_DIR)
+        return self._buffer
+
+    @staticmethod
+    def _auth_headers() -> dict:
+        """Headers d'authentification Bearer pour les requêtes API."""
+        if API_TOKEN:
+            return {"Authorization": f"Bearer {API_TOKEN}"}
+        return {}
+
+    def start(self):
+        """Démarrer le streaming et enregistrer la session côté serveur."""
+        self.running = True
+        self._register_session()
+        # Thread principal d'envoi
+        self._thread = threading.Thread(target=self._stream_loop, daemon=True)
+        self._thread.start()
+        # Thread de health-check pour recovery
+        self._health_thread = threading.Thread(
+            target=self._health_check_loop, daemon=True
+        )
+        self._health_thread.start()
+        # Thread de drain du buffer persistant (rejoue les items en attente)
+        self._drain_thread = threading.Thread(
+            target=self._buffer_drain_loop, daemon=True
+        )
+        self._drain_thread.start()
+        logger.info(f"Streamer démarré")
+
+    def stop(self):
+        """Arrêter le streaming et finaliser la session côté serveur.
+
+        Attend que la queue se vide (max 30s) avant de finaliser,
+        pour que toutes les images soient envoyées au serveur.
+        """
+        self.running = False
+
+        # Attendre que la queue se vide (les images doivent être envoyées)
+        if self._thread:
+            drain_start = time.time()
+            while not self.queue.empty() and (time.time() - drain_start) < 30:
+                time.sleep(0.5)
+            if not self.queue.empty():
+                logger.warning(
+                    f"Queue non vide après 30s ({self.queue.qsize()} items restants)"
+                )
+            self._thread.join(timeout=5.0)
+
+        if self._health_thread:
+            self._health_thread.join(timeout=2.0)
+
+        if self._drain_thread:
+            self._drain_thread.join(timeout=2.0)
+
+        self._finalize_session()
+        logger.info(f"Streamer arrêté")
+
+    def push_event(self, event_data: dict):
+        """Enfile un événement pour envoi immédiat.
+
+        Si la queue est pleine (backpressure), les heartbeat sont droppés
+        tandis que les événements utilisateur (click, key, scroll, action)
+        et screenshots sont toujours conservés.
+        """
+        self._enqueue_with_backpressure("event", event_data)
+
+    def push_image(self, image_path: str, screenshot_id: str):
+        """Enfile une image pour envoi asynchrone."""
+        if not image_path:
+            return  # Ignorer les chemins vides (heartbeat sans changement)
+        self._enqueue_with_backpressure("image", (image_path, screenshot_id))
+
+    # =========================================================================
+    # Backpressure — gestion de la queue bornée
+    # =========================================================================
+
+    def _enqueue_with_backpressure(self, item_type: str, data):
+        """Ajouter un item à la queue avec gestion du backpressure.
+
+        Quand la queue est pleine :
+        - Les événements prioritaires (click, key, action, screenshot) sont
+          ajoutés en bloquant brièvement (0.5s). Si toujours pleine → persistés
+          dans le buffer SQLite pour rejeu ultérieur.
+        - Les heartbeat sont silencieusement droppés.
+        - Si le serveur est marqué indisponible, on persiste immédiatement les
+          items prioritaires (évite de remplir la queue inutilement).
+        """
+        is_priority = self._is_priority_item(item_type, data)
+
+        # Serveur indisponible + item prioritaire → on persiste directement
+        # sans polluer la queue RAM (qui ne sera jamais vidée tant que le
+        # serveur est down).
+        if is_priority and not self._server_available:
+            self._persist_to_buffer(item_type, data)
+            return
+
+        try:
+            self.queue.put_nowait((item_type, data))
+        except queue.Full:
+            if is_priority:
+                # Événement prioritaire : on attend un peu pour l'ajouter
+                try:
+                    self.queue.put((item_type, data), timeout=0.5)
+                except queue.Full:
+                    # Persistance disque (ne JAMAIS dropper un prioritaire)
+                    persisted = self._persist_to_buffer(item_type, data)
+                    if persisted:
+                        logger.warning(
+                            f"Queue pleine — événement prioritaire persisté "
+                            f"sur disque (type={item_type})"
+                        )
+                    else:
+                        logger.error(
+                            f"Queue pleine ET buffer saturé — événement "
+                            f"prioritaire perdu (type={item_type})"
+                        )
+            else:
+                # Heartbeat ou événement non-critique : on drop silencieusement
+                logger.debug(
+                    f"Queue pleine — heartbeat/non-prioritaire droppé "
+                    f"(type={item_type})"
+                )
+
+    def _is_priority_item(self, item_type: str, data) -> bool:
+        """Vérifie si un item est prioritaire (ne doit pas être droppé).
+
+        Les images sont toujours prioritaires. Pour les événements,
+        on regarde le type d'événement (click, key, scroll, action).
+        """
+        if item_type == "image":
+            return True
+        if item_type == "event" and isinstance(data, dict):
+            event_type = data.get("type", "").lower()
+            return event_type in PRIORITY_EVENT_TYPES
+        return False
+
+    def _persist_to_buffer(self, item_type: str, data) -> bool:
+        """Persiste un item dans le buffer SQLite. Retourne True si OK.
+
+        Utilisé quand la queue est pleine ou le serveur indisponible.
+        """
+        try:
+            buf = self._get_buffer()
+            if item_type == "event" and isinstance(data, dict):
+                return buf.add_event(self.session_id, data)
+            if item_type == "image":
+                path, shot_id = data
+                return buf.add_image(self.session_id, path, shot_id)
+        except Exception as e:
+            # On n'arrête jamais l'agent si le buffer échoue
+            logger.error(f"Persistance buffer échouée : {e}")
+        return False
+
+    # =========================================================================
+    # Boucle d'envoi
+    # =========================================================================
+
+    def _stream_loop(self):
+        """Boucle d'envoi asynchrone (thread daemon)."""
+        consecutive_failures = 0
+        while self.running or not self.queue.empty():
+            try:
+                item_type, data = self.queue.get(timeout=0.5)
+                success = False
+                is_file_gone = False
+                if item_type == "event":
+                    success = self._send_with_retry(self._send_event, data)
+                elif item_type == "image":
+                    result = self._send_with_retry(self._send_image, *data)
+                    # Fix P0-E : distinguer FILE_GONE du vrai succès HTTP.
+                    if result is ImageSendResult.OK:
+                        success = True
+                    elif result is ImageSendResult.FILE_GONE:
+                        # Fichier disparu : pas de retry, pas de persistance
+                        # (on ne peut plus le renvoyer). On considère l'item
+                        # comme traité sans comptabiliser un succès réseau.
+                        is_file_gone = True
+                        success = False
+                    else:
+                        success = False
+                self.queue.task_done()
+
+                if success:
+                    consecutive_failures = 0
+                elif is_file_gone:
+                    # Fichier introuvable — déjà logué ERROR dans _send_image.
+                    # On ne persiste PAS dans le buffer (retry voué à échouer).
+                    consecutive_failures = 0
+                else:
+                    consecutive_failures += 1
+                    # Après 3 retries infructueux, si l'item est prioritaire,
+                    # on le persiste pour ne pas le perdre définitivement.
+                    if self._is_priority_item(item_type, data):
+                        self._persist_to_buffer(item_type, data)
+                    if consecutive_failures >= 10:
+                        logger.warning(
+                            "10 échecs consécutifs — serveur marqué indisponible"
+                        )
+                        self._server_available = False
+                        consecutive_failures = 0
+
+            except queue.Empty:
+                continue
+            except Exception as e:
+                logger.error(f"Erreur Streaming Loop: {e}")
+
+    # =========================================================================
+    # Retry avec backoff exponentiel
+    # =========================================================================
+
+    def _send_with_retry(self, send_fn, *args):
+        """Tente l'envoi avec retry et backoff exponentiel.
+
+        3 tentatives max avec délais de 1s, 2s, 4s entre chaque.
+        Retourne :
+          - True / ImageSendResult.OK si l'envoi a réussi
+          - ImageSendResult.FILE_GONE (images uniquement) — pas de retry
+          - False / ImageSendResult.FAILED sinon
+        """
+        # Première tentative (sans délai)
+        first = send_fn(*args)
+        if first is ImageSendResult.OK or first is True:
+            return first
+        # Fix P0-E : FILE_GONE → pas de retry, l'erreur est permanente.
+        if first is ImageSendResult.FILE_GONE:
+            return first
+
+        # Retries avec backoff
+        for attempt, delay in enumerate(RETRY_DELAYS, start=1):
+            if not self.running:
+                # On arrête les retries si le streamer est en cours d'arrêt
+                break
+            logger.debug(
+                f"Retry {attempt}/{MAX_RETRIES} dans {delay}s..."
+            )
+            time.sleep(delay)
+            result = send_fn(*args)
+            if result is ImageSendResult.OK or result is True:
+                logger.debug(f"Retry {attempt} réussi")
+                return result
+            # FILE_GONE pendant un retry — idem, on arrête
+            if result is ImageSendResult.FILE_GONE:
+                return result
+
+        logger.debug(f"Envoi échoué après {MAX_RETRIES} retries")
+        return False
+
+    # =========================================================================
+    # Health-check périodique pour recovery
+    # =========================================================================
+
+    def _health_check_loop(self):
+        """Vérifie périodiquement si le serveur est redevenu disponible.
+
+        Toutes les 30s, tente un GET /stats. Si le serveur répond,
+        remet _server_available = True et ré-enregistre la session.
+        """
+        while self.running:
+            time.sleep(HEALTH_CHECK_INTERVAL_S)
+            if not self.running:
+                break
+            if self._server_available:
+                # Serveur déjà disponible, rien à faire
+                continue
+            # Tenter un health-check
+            try:
+                resp = requests.get(
+                    f"{STREAMING_ENDPOINT}/stats",
+                    headers=self._auth_headers(),
+                    timeout=3,
+                )
+                if resp.ok:
+                    logger.info(
+                        "Health-check OK — serveur redevenu disponible, "
+                        "ré-enregistrement de la session"
+                    )
+                    self._server_available = True
+                    self._register_session()
+            except Exception:
+                logger.debug("Health-check échoué — serveur toujours indisponible")
+
+    # =========================================================================
+    # Drain du buffer persistant (Partie B)
+    # =========================================================================
+
+    def _buffer_drain_loop(self):
+        """Rejoue les items persistés en arrière-plan.
+
+        Tourne tant que self.running. Essaie de drainer le buffer toutes les
+        BUFFER_DRAIN_INTERVAL_S secondes, mais seulement si :
+          - le serveur est disponible,
+          - il y a effectivement des items en attente.
+
+        Au premier passage (démarrage agent), on draine immédiatement pour
+        rejouer tout ce qui a été persisté lors de la session précédente.
+        """
+        # Au démarrage : drain immédiat (pas d'attente)
+        first_pass = True
+        while self.running:
+            if not first_pass:
+                time.sleep(BUFFER_DRAIN_INTERVAL_S)
+                if not self.running:
+                    break
+            first_pass = False
+
+            if not self._server_available:
+                continue
+
+            try:
+                buf = self._get_buffer()
+                # Abandonner d'abord les items exceeded (évite de les retenter)
+                abandoned = buf.abandon_exceeded()
+                if abandoned:
+                    logger.warning(
+                        f"Buffer : {abandoned} items abandonnés "
+                        f"après {MAX_ATTEMPTS} tentatives"
+                    )
+
+                counts = buf.counts()
+                if counts["events"] == 0 and counts["images"] == 0:
+                    continue
+
+                logger.info(
+                    f"Buffer drain : {counts['events']} events, "
+                    f"{counts['images']} images en attente — rejeu"
+                )
+                self._drain_buffer_once(buf)
+            except Exception as e:
+                logger.error(f"Buffer drain loop échoué : {e}")
+
+    def _drain_buffer_once(self, buf: PersistentBuffer):
+        """Une passe de drain : envoie ce qui peut l'être, incrémente le reste.
+
+        On arrête dès qu'un envoi échoue (serveur probablement down).
+        """
+        # Events d'abord (plus légers, priorité métier AI Act)
+        for row in buf.drain_events(limit=50):
+            if not self._server_available:
+                return
+            try:
+                import json as _json
+                event = _json.loads(row["payload"])
+            except (ValueError, TypeError):
+                logger.error(
+                    f"Buffer : payload event #{row['id']} corrompu, suppression"
+                )
+                buf.delete_event(row["id"])
+                continue
+            if self._send_event(event):
+                buf.delete_event(row["id"])
+            else:
+                buf.increment_attempts(row["id"], "event")
+                # Serveur répond mal — on arrête la passe
+                return
+
+        # Puis images
+        for row in buf.drain_images(limit=20):
+            if not self._server_available:
+                return
+            image_path = row["image_path"]
+            shot_id = row["shot_id"]
+            if not os.path.exists(image_path):
+                # Fichier local disparu (purge, clean-up) — on abandonne.
+                # Fix P0-E : log ERROR (pas warning) — c'est une perte de donnée.
+                logger.error(
+                    f"Buffer : image #{row['id']} introuvable sur disque "
+                    f"({image_path}) — entrée abandonnée (le serveur n'a "
+                    f"jamais reçu cette image, session={row['session_id']}, "
+                    f"shot={shot_id})"
+                )
+                buf.delete_image(row["id"])
+                continue
+            result = self._send_image(image_path, shot_id)
+            if result is ImageSendResult.OK or result is True:
+                buf.delete_image(row["id"])
+            elif result is ImageSendResult.FILE_GONE:
+                # Fix P0-E : fichier disparu pendant l'envoi.
+                # Ce n'est PAS un succès HTTP — ne pas considérer comme tel.
+                # On supprime néanmoins l'entrée (retry voué à échouer)
+                # mais avec un log ERROR explicite.
+                logger.error(
+                    f"Buffer : image #{row['id']} disparue pendant l'envoi "
+                    f"({image_path}) — entrée abandonnée, pas de retry "
+                    f"(session={row['session_id']}, shot={shot_id})"
+                )
+                buf.delete_image(row["id"])
+            else:
+                buf.increment_attempts(row["id"], "image")
+                return
+
+    # =========================================================================
+    # Compression JPEG
+    # =========================================================================
+
+    def _compress_image_to_jpeg(self, path: str) -> tuple:
+        """Compresse une image (PNG ou autre) en JPEG qualité 85 en mémoire.
+
+        Retourne un tuple (bytes_io, content_type, filename_suffix).
+        Si la compression échoue, renvoie le fichier original en PNG.
+        """
+        try:
+            img = Image.open(path)
+            # Convertir en RGB si nécessaire (JPEG ne supporte pas l'alpha)
+            if img.mode in ("RGBA", "LA", "P"):
+                img = img.convert("RGB")
+            buf = io.BytesIO()
+            img.save(buf, format="JPEG", quality=JPEG_QUALITY, optimize=True)
+            buf.seek(0)
+            return buf, "image/jpeg", ".jpg"
+        except FileNotFoundError:
+            # Fichier introuvable — propager l'erreur (pas de fallback possible)
+            logger.warning(f"Fichier image introuvable pour compression : {path}")
+            raise
+        except Exception as e:
+            logger.warning(f"Compression JPEG échouée, envoi PNG brut: {e}")
+            return None, None, None
+
+    # =========================================================================
+    # Purge locale après ACK (Partie A)
+    # =========================================================================
+
+    @staticmethod
+    def _purge_local_image(path: str):
+        """Supprime un screenshot local après ACK 200 du serveur.
+
+        Ne crashe JAMAIS si le fichier est verrouillé (cas Windows) ou
+        déjà supprimé : on log en debug et on continue. L'auto-cleanup
+        de SessionStorage repassera plus tard.
+        """
+        if not PURGE_AFTER_ACK:
+            return
+        try:
+            os.remove(path)
+            logger.debug(f"Screenshot local purgé après ACK : {path}")
+        except FileNotFoundError:
+            # Déjà supprimé ou chemin invalide — silencieux
+            pass
+        except PermissionError as e:
+            # Windows verrouille parfois les fichiers (antivirus, indexation...)
+            logger.debug(
+                f"Purge différée (fichier verrouillé) : {path} — {e}"
+            )
+        except OSError as e:
+            logger.debug(f"Purge échouée : {path} — {e}")
+
+    # =========================================================================
+    # Protection redirect POST→GET (INC-7)
+    # =========================================================================
+
+    @staticmethod
+    def _check_redirect(resp, url: str):
+        """Detecter et logger une redirection sur un POST.
+
+        La lib requests transforme un POST en GET sur 301/302 (RFC 7231).
+        Avec allow_redirects=False, on recoit le 301/302 directement.
+        On log un WARNING explicite pour que l'admin corrige l'URL.
+        """
+        if resp.status_code in (301, 302, 307, 308):
+            location = resp.headers.get("Location", "?")
+            logger.warning(
+                f"Redirection {resp.status_code} detectee sur POST {url} "
+                f"→ {location}. Verifiez que RPA_SERVER_URL utilise "
+                f"https:// si le serveur redirige."
+            )
+            return True
+        return False
+
+    # =========================================================================
+    # Envois HTTP
+    # =========================================================================
+
+    def _register_session(self):
+        """Enregistrer la session auprès du serveur (avec identifiant machine)."""
+        try:
+            url = f"{STREAMING_ENDPOINT}/register"
+            resp = requests.post(
+                url,
+                params={
+                    "session_id": self.session_id,
+                    "machine_id": self.machine_id,
+                },
+                headers=self._auth_headers(),
+                timeout=3,
+                allow_redirects=False,
+            )
+            if self._check_redirect(resp, url):
+                logger.warning("Enregistrement session échoué (redirect)")
+                return
+            if resp.ok:
+                logger.info(
+                    f"Session {self.session_id} enregistrée sur le serveur "
+                    f"(machine={self.machine_id})"
+                )
+                self._server_available = True
+            else:
+                logger.warning(f"Enregistrement session échoué: {resp.status_code}")
+        except Exception as e:
+            logger.debug(f"Serveur indisponible pour register: {e}")
+            self._server_available = False
+
+    def _finalize_session(self):
+        """Finaliser la session (construction du workflow côté serveur).
+
+        IMPORTANT : tente TOUJOURS l'envoi, indépendamment de _server_available.
+        C'est la dernière chance de sauver les données de la session.
+        """
+        try:
+            url = f"{STREAMING_ENDPOINT}/finalize"
+            resp = requests.post(
+                url,
+                params={
+                    "session_id": self.session_id,
+                    "machine_id": self.machine_id,
+                },
+                headers=self._auth_headers(),
+                timeout=30,  # Le build workflow peut prendre du temps
+                allow_redirects=False,
+            )
+            self._check_redirect(resp, url)
+            if resp.ok:
+                result = resp.json()
+                logger.info(f"Session finalisée [status={result.get('status')}, wf_hash={_title_hash(result.get('workflow_name',''))}]")
+                if self._on_finalize_result is not None:
+                    try:
+                        self._on_finalize_result(result)
+                    except Exception as cb_error:
+                        logger.warning(
+                            "Callback finalize ignoré après erreur: %s",
+                            cb_error,
+                        )
+            else:
+                logger.warning(f"Finalisation échouée: {resp.status_code}")
+        except Exception as e:
+            logger.warning(f"Finalisation échouée: {e}")
+
+    def _send_event(self, event: dict) -> bool:
+        """Envoyer un événement au serveur (avec identifiant machine)."""
+        if not self._server_available:
+            return False
+        try:
+            url = f"{STREAMING_ENDPOINT}/event"
+            payload = {
+                "session_id": self.session_id,
+                "timestamp": time.time(),
+                "event": event,
+                "machine_id": self.machine_id,
+            }
+            resp = requests.post(
+                url,
+                json=payload,
+                headers=self._auth_headers(),
+                timeout=2,
+                allow_redirects=False,
+            )
+            if self._check_redirect(resp, url):
+                return False
+            return resp.ok
+        except Exception as e:
+            logger.debug(f"Streaming Event échoué: {e}")
+            return False
+
+    def _send_image(self, path: str, shot_id: str):
+        """Envoyer un screenshot au serveur, compressé en JPEG.
+
+        Utilise un context manager pour le fallback PNG afin d'éviter
+        les fuites de descripteurs de fichier.
+
+        Partie A (purge après ACK) : en cas de HTTP 200 confirmé, le fichier
+        local est supprimé (le serveur devient la source de vérité).
+
+        Fix P0-E : retourne `ImageSendResult` (OK / FAILED / FILE_GONE).
+        Les appelants historiques qui attendaient un bool continuent de
+        fonctionner grâce à la truthiness du enum (OK → True, reste → False),
+        MAIS le drain du buffer doit désormais discriminer FILE_GONE pour
+        ne pas confondre "fichier disparu" avec "envoyé avec succès".
+        """
+        if not self._server_available:
+            return ImageSendResult.FAILED
+        try:
+            # Tenter la compression JPEG (réduction ~5-10x vs PNG)
+            jpeg_buf, content_type, suffix = self._compress_image_to_jpeg(path)
+
+            params = {
+                "session_id": self.session_id,
+                "shot_id": shot_id,
+                "machine_id": self.machine_id,
+            }
+
+            url = f"{STREAMING_ENDPOINT}/image"
+            if jpeg_buf is not None:
+                # Envoi du JPEG compressé (BytesIO, pas de fuite possible)
+                files = {
+                    "file": (f"{shot_id}{suffix}", jpeg_buf, content_type)
+                }
+                resp = requests.post(
+                    url,
+                    files=files,
+                    params=params,
+                    headers=self._auth_headers(),
+                    timeout=5,
+                    allow_redirects=False,
+                )
+                if self._check_redirect(resp, url):
+                    return ImageSendResult.FAILED
+                if resp.ok:
+                    self._purge_local_image(path)
+                    return ImageSendResult.OK
+                return ImageSendResult.FAILED
+            else:
+                # Fallback : envoi PNG original avec context manager
+                with open(path, "rb") as f:
+                    files = {
+                        "file": (f"{shot_id}.png", f, "image/png")
+                    }
+                    resp = requests.post(
+                        url,
+                        files=files,
+                        params=params,
+                        headers=self._auth_headers(),
+                        timeout=5,
+                        allow_redirects=False,
+                    )
+                if self._check_redirect(resp, url):
+                    return ImageSendResult.FAILED
+                if resp.ok:
+                    self._purge_local_image(path)
+                    return ImageSendResult.OK
+                return ImageSendResult.FAILED
+        except FileNotFoundError:
+            # Fix P0-E : fichier local disparu. On NE doit PAS considérer ça
+            # comme un succès HTTP 200. Le serveur n'a rien reçu. On signale
+            # `FILE_GONE` pour que le drain du buffer supprime l'entrée
+            # (pas de retry possible) tout en loguant ERROR (pas debug).
+            logger.error(
+                f"Image {shot_id} introuvable sur disque ({path}) — "
+                f"abandon (serveur n'a rien reçu)"
+            )
+            return ImageSendResult.FILE_GONE
+        except Exception as e:
+            logger.debug(f"Streaming Image échoué: {e}")
+            return ImageSendResult.FAILED

agent_v0/agent_v1/network/updater.py

@@ -0,0 +1,481 @@
+# agent_v1/network/updater.py
+"""NOYAU client de la mise à jour silencieuse de Léa (DETTE-022 v2).
+
+GATED — flag `RPA_AUTO_UPDATE_ENABLED` (défaut OFF). Tant qu'il est OFF,
+rien ne se déclenche : l'intégration de ce module au runtime (boucle de poll
+de `main.py`) ne fait aucune MAJ.
+
+Ce module ne contient que les parties PURES / testables, sans réseau réel :
+
+  - `parse_version` / `is_newer` (R3) : self-contained (le bundle client
+    n'embarque PAS `server_v1` — duplication assumée, même algorithme).
+  - `should_update(local_version, server_response)` : décide « faut-il
+    updater ? quelle version/type ? » à partir de la réponse serveur. Double
+    garde semver côté client (jamais de downgrade) = défense en profondeur.
+  - `download_update(plan, staging_dir, downloader)` : télécharge le ZIP via un
+    `downloader` callable INJECTABLE (aucun réseau réel en test), vérifie le
+    SHA256, écrit le ZIP dans le **staging** (`Lea_next\\`-like) — JAMAIS dans
+    les fichiers vivants. Retourne un plan d'application.
+  - `auto_update_enabled()` : lit le flag (défaut OFF).
+
+⚠️ SWAP — répartition claire des responsabilités :
+`apply_update` / `write_boot_ok_marker` ci-dessous ne font que l'ARMEMENT côté
+Python (extraction vers `agent_v1_new/` + marqueurs) — ils n'écrasent JAMAIS un
+fichier vivant. Le remplacement ATOMIQUE (renames), le redémarrage et le
+rollback sont faits HORS-PROCESS par `Lea.bat` au démarrage (revu ligne à ligne).
+
+Pattern d'import / résilience aligné sur `log_shipper.py` (même branche).
+
+Branche feat/push-log-dgx.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import os
+import shutil
+from pathlib import Path
+from typing import Callable, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+# Niveaux de livraison (R2). `code-only` par défaut = 99 % des MAJ (~500 Ko).
+VALID_UPDATE_TYPES = ("code-only", "full")
+DEFAULT_UPDATE_TYPE = "code-only"
+
+_FALLBACK_VERSION: Tuple[int, ...] = (0,)
+
+
+# ---------------------------------------------------------------------------
+# Flag d'activation — OFF par défaut (lu à chaque appel pour faciliter tests)
+# ---------------------------------------------------------------------------
+
+def auto_update_enabled() -> bool:
+    """True si la MAJ auto client est activée (flag RPA_AUTO_UPDATE_ENABLED).
+
+    Défaut PRUDENT = OFF. On l'active poste par poste via config.txt / variable
+    d'environnement, sans rebuild de l'installateur (même esprit que
+    LOG_SHIP_ENABLED).
+    """
+    return os.environ.get("RPA_AUTO_UPDATE_ENABLED", "false").lower() in (
+        "true", "1", "yes", "on",
+    )
+
+
+# ---------------------------------------------------------------------------
+# R3 — parse_version self-contained (le bundle client n'a pas server_v1)
+# ---------------------------------------------------------------------------
+
+def parse_version(v) -> Tuple[int, ...]:
+    """Parse une version semver en tuple d'entiers. Voir server_v1/update_check.
+
+    "1.0.2" → (1, 0, 2) ; "1.0.10" → (1, 0, 10) ; "v1.2.3" → (1, 2, 3).
+    Tolérant et SANS exception : invalide → fallback `(0,)`.
+    """
+    if not isinstance(v, str):
+        return _FALLBACK_VERSION
+    s = v.strip().lstrip("vV").strip()
+    if not s:
+        return _FALLBACK_VERSION
+    try:
+        from packaging.version import Version
+
+        return tuple(Version(s).release)
+    except Exception:
+        pass
+    try:
+        return tuple(int(x) for x in s.split("."))
+    except (ValueError, AttributeError):
+        return _FALLBACK_VERSION
+
+
+def is_newer(candidate: str, baseline: str) -> bool:
+    """True si `candidate` strictement plus récent que `baseline` (semver)."""
+    return parse_version(candidate) > parse_version(baseline)
+
+
+def _normalize_update_type(update_type) -> str:
+    if update_type in VALID_UPDATE_TYPES:
+        return update_type
+    return DEFAULT_UPDATE_TYPE
+
+
+# ---------------------------------------------------------------------------
+# Décision client : faut-il updater ?
+# ---------------------------------------------------------------------------
+
+def should_update(local_version: str, server_response) -> Optional[dict]:
+    """Décide à partir de la réponse serveur s'il faut updater.
+
+    Args:
+        local_version : version courante du client (config.AGENT_VERSION).
+        server_response : dict renvoyé par l'endpoint serveur
+            {update_available, latest_version, update_type, url, [sha256]}.
+
+    Returns:
+        Un PLAN d'update `{target_version, update_type, url, sha256}` si une MAJ
+        valide est à faire, sinon None.
+
+    Défense en profondeur : même si `update_available` est True, le client
+    REVÉRIFIE en semver (`is_newer`) — il ne descend JAMAIS vers une version
+    <= locale. Tolérant : réponse malformée → None (jamais d'exception).
+    """
+    if not isinstance(server_response, dict):
+        return None
+    if not server_response.get("update_available"):
+        return None
+
+    target = server_response.get("latest_version")
+    url = server_response.get("url")
+    if not target or not url:
+        return None
+
+    # Double garde semver : pas de downgrade, pas d'égalité.
+    if not is_newer(target, local_version):
+        return None
+
+    return {
+        "target_version": target,
+        "update_type": _normalize_update_type(server_response.get("update_type")),
+        "url": url,
+        "sha256": server_response.get("sha256"),
+    }
+
+
+# ---------------------------------------------------------------------------
+# Téléchargement — downloader INJECTABLE, SHA256, staging only
+# ---------------------------------------------------------------------------
+
+def _default_downloader(url: str) -> bytes:
+    """Téléchargement réel du ZIP (best-effort, pattern streamer/log_shipper).
+
+    Résout l'URL relative contre SERVER_BASE, ajoute le Bearer si présent.
+    INJECTABLE : remplacé par un fake en test (aucun réseau réel).
+    """
+    import requests  # import tardif (absent de certains envs de test)
+
+    full_url = url
+    headers = {}
+    try:
+        from ..config import SERVER_BASE, API_TOKEN
+
+        if url.startswith("/"):
+            full_url = f"{SERVER_BASE}{url}"
+        if API_TOKEN:
+            headers["Authorization"] = f"Bearer {API_TOKEN}"
+    except Exception:
+        # Hors package (test isolé) : on utilise l'URL telle quelle.
+        pass
+
+    resp = requests.get(full_url, headers=headers, timeout=30, stream=False)
+    resp.raise_for_status()
+    return resp.content
+
+
+def download_update(
+    plan: dict,
+    staging_dir,
+    downloader: Optional[Callable[[str], bytes]] = None,
+) -> dict:
+    """Télécharge le ZIP d'update dans le staging et vérifie son intégrité.
+
+    NE TOUCHE PAS aux fichiers vivants : écrit uniquement dans `staging_dir`
+    (équivalent de `Lea_next\\`). L'application réelle (swap) est un stub
+    réservé révision humaine (voir `apply_update`).
+
+    Args:
+        plan : sortie de `should_update` (target_version, update_type, url, sha256).
+        staging_dir : dossier de staging (créé si absent).
+        downloader : callable `(url) -> bytes` INJECTABLE (défaut = HTTP réel).
+
+    Returns:
+        Succès : {ok: True, staged_zip: str, update_type, target_version,
+                  sha256_verified: bool}
+        Échec  : {ok: False, error: str}
+    Best-effort : aucune exception ne remonte ; un échec laisse le staging propre
+    (pas de ZIP corrompu).
+    """
+    dl = downloader if downloader is not None else _default_downloader
+    staging = Path(staging_dir)
+
+    try:
+        data = dl(plan["url"])
+    except Exception as e:
+        logger.warning("Téléchargement update échoué : %s", e)
+        return {"ok": False, "error": f"download_failed: {e}"}
+
+    expected_sha = (plan.get("sha256") or "").strip().lower()
+    sha256_verified = False
+    if expected_sha:
+        actual = hashlib.sha256(data).hexdigest()
+        if actual != expected_sha:
+            logger.warning(
+                "SHA256 mismatch update (attendu=%s, obtenu=%s) — rejeté",
+                expected_sha, actual,
+            )
+            return {"ok": False, "error": "sha256 mismatch — ZIP rejeté"}
+        sha256_verified = True
+    else:
+        # Best-effort : pas de SHA fourni → on accepte mais on le signale.
+        logger.info("Pas de SHA256 fourni pour l'update — intégrité non vérifiée")
+
+    try:
+        staging.mkdir(parents=True, exist_ok=True)
+        target_version = plan.get("target_version", "unknown")
+        staged_zip = staging / f"lea_update_{target_version}.zip"
+        staged_zip.write_bytes(data)
+    except Exception as e:
+        logger.warning("Écriture ZIP staging échouée : %s", e)
+        return {"ok": False, "error": f"staging_write_failed: {e}"}
+
+    return {
+        "ok": True,
+        "staged_zip": str(staged_zip),
+        "update_type": _normalize_update_type(plan.get("update_type")),
+        "target_version": plan.get("target_version"),
+        "sha256_verified": sha256_verified,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Interrogation serveur — checker INJECTABLE (GET /agents/update/check)
+# ---------------------------------------------------------------------------
+
+def _default_update_checker(local_version: str, machine_id: str):
+    """Interroge le serveur : y a-t-il une MAJ ? (best-effort, INJECTABLE).
+
+    GET SERVER_URL/agents/update/check?current_version=..&machine_id=..
+    (endpoint gated côté serveur — 503 si RPA_AUTO_UPDATE_SERVER_ENABLED OFF,
+    auquel cas on renvoie None : pas de MAJ). Bearer si présent. Pattern aligné
+    sur `log_shipper._default_sender`. INJECTABLE : remplacé par un fake en test.
+
+    Returns:
+        Le dict réponse serveur (`should_update` sait le lire), ou None si
+        indisponible / gated / erreur (jamais d'exception ne remonte).
+    """
+    try:
+        import requests  # import tardif
+
+        headers = {}
+        try:
+            from ..config import SERVER_URL, API_TOKEN
+
+            base = SERVER_URL
+            if API_TOKEN:
+                headers["Authorization"] = f"Bearer {API_TOKEN}"
+        except Exception:
+            base = ""
+        url = f"{base}/agents/update/check"
+        resp = requests.get(
+            url,
+            params={"current_version": local_version, "machine_id": machine_id},
+            headers=headers,
+            timeout=10,
+            allow_redirects=False,
+        )
+        # 503 = endpoint gated OFF côté serveur → pas de MAJ (silencieux).
+        if resp.status_code == 503:
+            return None
+        if not resp.ok:
+            logger.debug("update/check HTTP %s", resp.status_code)
+            return None
+        return resp.json()
+    except Exception as e:
+        logger.debug("update/check indisponible : %s", e)
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Orchestrateur GATED — check → décide → download (staging) → stub apply
+# ---------------------------------------------------------------------------
+
+def run_update_cycle(
+    local_version: str,
+    machine_id: str,
+    staging_dir,
+    checker: Optional[Callable[[str, str], object]] = None,
+    downloader: Optional[Callable[[str], bytes]] = None,
+    app_dir=None,
+) -> dict:
+    """Un cycle complet de MAJ silencieuse — GATED, best-effort, SANS swap.
+
+    Enchaîne :
+      1. GATE `auto_update_enabled()` (RPA_AUTO_UPDATE_ENABLED, défaut OFF) —
+         si OFF, ne fait STRICTEMENT rien (aucun appel réseau).
+      2. `checker(local_version, machine_id)` → réponse serveur (canary-aware).
+      3. `should_update(...)` → plan (double garde semver, jamais de downgrade).
+      4. `download_update(...)` → ZIP dans le STAGING + vérif SHA256. Ne touche
+         JAMAIS les fichiers vivants.
+      5. `apply_update` ARME le swap (extraction `agent_v1_new/` + marqueur
+         UPDATE_READY) mais NE swappe PAS : le remplacement atomique + le
+         redémarrage sont faits par Lea.bat au prochain démarrage. `applied`
+         reste False tant que Léa n'a pas redémarré sur la nouvelle version.
+
+    Jamais d'exception ne remonte (ne doit JAMAIS casser Léa). Retourne un dict
+    d'état pour le diagnostic / le log :
+        status ∈ {disabled, check_failed, up_to_date, download_failed, staged}
+
+    Args:
+        checker    : callable `(local_version, machine_id) -> dict|None`
+                     INJECTABLE (défaut = HTTP réel vers l'endpoint gated).
+        downloader : callable `(url) -> bytes` INJECTABLE (défaut = HTTP réel).
+    """
+    if not auto_update_enabled():
+        return {"status": "disabled", "applied": False}
+
+    chk = checker if checker is not None else _default_update_checker
+
+    try:
+        server_response = chk(local_version, machine_id)
+    except Exception as e:
+        logger.warning("update check a levé : %s", e)
+        return {"status": "check_failed", "applied": False, "error": str(e)}
+
+    plan = should_update(local_version, server_response)
+    if plan is None:
+        return {"status": "up_to_date", "applied": False}
+
+    staged = download_update(plan, staging_dir, downloader=downloader)
+    if not staged.get("ok"):
+        return {
+            "status": "download_failed",
+            "applied": False,
+            "error": staged.get("error"),
+        }
+
+    # Armement du swap : extraction du ZIP vers agent_v1_new\ + marqueur
+    # UPDATE_READY. Le swap ATOMIQUE (renames) et le redémarrage sont faits
+    # HORS-PROCESS par Lea.bat au prochain démarrage — JAMAIS depuis ici
+    # (on n'écrase pas les fichiers d'un Léa en cours d'exécution).
+    armed = apply_update(staged, app_dir=app_dir)
+
+    return {
+        "status": "armed" if armed.get("armed") else "arm_failed",
+        "applied": False,  # le swap effectif est fait par Lea.bat, pas ici
+        "armed": bool(armed.get("armed", False)),
+        "target_version": staged.get("target_version"),
+        "update_type": staged.get("update_type"),
+        "staged_zip": staged.get("staged_zip"),
+        "sha256_verified": staged.get("sha256_verified", False),
+        "marker": armed.get("marker"),
+        "error": armed.get("error"),
+    }
+
+
+# ===========================================================================
+# SWAP — côté Python : ARMEMENT SEULEMENT (extraction + marqueurs).
+#   Le remplacement ATOMIQUE des fichiers vivants + le redémarrage + le
+#   rollback sont faits HORS-PROCESS par `Lea.bat` au démarrage (renames).
+#   Python n'écrase JAMAIS les fichiers d'un Léa en cours d'exécution.
+# ===========================================================================
+
+def _resolve_app_dir(app_dir) -> Path:
+    """Répertoire d'install (contient `agent_v1/`, `run_agent_v1.py`, `Lea.bat`).
+
+    INJECTABLE (tests : tmp_path). Défaut = parent du package agent_v1.
+    """
+    if app_dir is not None:
+        return Path(app_dir)
+    try:
+        from ..config import BASE_DIR  # BASE_DIR = dossier du package agent_v1
+        return Path(BASE_DIR).parent
+    except Exception:
+        return Path(__file__).resolve().parent.parent.parent
+
+
+def apply_update(prepared: dict, app_dir=None) -> dict:
+    """ARME le swap : extrait le ZIP staging vers `agent_v1_new/` + marqueur.
+
+    NE swappe PAS et NE redémarre PAS (c'est le rôle de `Lea.bat`). Écrit
+    uniquement à côté des fichiers vivants (dossier neuf + marqueur), donc
+    l'opération est sûre même sur un Léa en cours d'exécution.
+
+      1. Extrait `prepared["staged_zip"]` → `<app_dir>/agent_v1_new/`
+         (nettoyé au préalable ; garde-fou zip-slip).
+      2. Écrit `<app_dir>/UPDATE_READY` (JSON : version, type, chemins) que
+         `Lea.bat` lira au prochain démarrage pour faire le swap atomique.
+
+    Best-effort : aucune exception ne remonte (ne doit jamais casser Léa).
+
+    Returns:
+        succès : {armed: True, applied: False, target_version, update_type,
+                  marker, extracted_to}
+        échec  : {armed: False, applied: False, error}
+    """
+    if not isinstance(prepared, dict):
+        return {"armed": False, "applied": False, "error": "prepared invalide"}
+    staged_zip = prepared.get("staged_zip")
+    target_version = prepared.get("target_version", "unknown")
+    update_type = _normalize_update_type(prepared.get("update_type"))
+    try:
+        root = _resolve_app_dir(app_dir)
+        zip_path = Path(staged_zip) if staged_zip else None
+        if zip_path is None or not zip_path.is_file():
+            return {"armed": False, "applied": False, "error": "ZIP staging introuvable"}
+
+        new_dir = root / "agent_v1_new"
+        if new_dir.exists():
+            shutil.rmtree(new_dir, ignore_errors=True)  # nettoie un staging partiel
+        new_dir.mkdir(parents=True, exist_ok=True)
+
+        import zipfile
+        new_root = new_dir.resolve()
+        with zipfile.ZipFile(zip_path) as zf:
+            for name in zf.namelist():  # garde-fou zip-slip (chemins ../)
+                dest = (new_dir / name).resolve()
+                if not str(dest).startswith(str(new_root)):
+                    shutil.rmtree(new_dir, ignore_errors=True)
+                    return {"armed": False, "applied": False,
+                            "error": f"zip-slip refusé : {name}"}
+            zf.extractall(new_dir)
+
+        marker = root / "UPDATE_READY"
+        marker.write_text(json.dumps({
+            "target_version": target_version,
+            "update_type": update_type,
+            "extracted_to": str(new_dir),
+            "staged_zip": str(zip_path),
+        }), encoding="utf-8")
+
+        logger.info(
+            "Update ARMÉ : %s (%s) → %s ; swap au prochain démarrage (Lea.bat)",
+            target_version, update_type, new_dir,
+        )
+        return {"armed": True, "applied": False, "target_version": target_version,
+                "update_type": update_type, "marker": str(marker),
+                "extracted_to": str(new_dir)}
+    except Exception as e:  # noqa: BLE001
+        logger.warning("apply_update (armement) a échoué : %s", e)
+        return {"armed": False, "applied": False, "error": f"arm_failed: {e}"}
+
+
+def write_boot_ok_marker(version: str, app_dir=None) -> dict:
+    """Confirme un boot sain : écrit `boot_ok_{version}` + désarme le rollback.
+
+    Appelé par `main.py` après ~90 s de tourne STABLE (liveness LOCALE,
+    indépendante du DGX — évite un faux rollback quand le réseau est coupé).
+    Retirer `PENDING_BOOT*` dit à `Lea.bat` que la nouvelle version a démarré
+    correctement (sinon, au prochain lancement, Lea.bat rollback vers la
+    version précédente).
+
+    Best-effort : aucune exception ne remonte.
+    """
+    try:
+        root = _resolve_app_dir(app_dir)
+        marker = root / f"boot_ok_{version}"
+        marker.write_text("ok", encoding="utf-8")
+        cleared = []
+        for p in root.glob("PENDING_BOOT*"):
+            try:
+                p.unlink()
+                cleared.append(p.name)
+            except OSError:
+                pass
+        logger.info("boot_ok écrit (%s) ; PENDING_BOOT retiré : %s",
+                    version, cleared or "aucun")
+        return {"written": True, "marker": str(marker), "cleared_pending": cleared}
+    except Exception as e:  # noqa: BLE001
+        logger.warning("write_boot_ok_marker a échoué : %s", e)
+        return {"written": False, "error": str(e)}

agent_v0/agent_v1/requirements.txt

@@ -0,0 +1,19 @@
+# agent_v1/requirements.txt
+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
+httpx>=0.27             # Client HTTP orchestrateur Léa (POST /api/learn/start) — brique conversationnelle
+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)
+
+# Windows spécifique
+pywin32>=306 ; sys_platform == 'win32'
+
+# macOS spécifique
+pyobjc-framework-Cocoa>=10.0 ; sys_platform == 'darwin'
+pyobjc-framework-Quartz>=10.0 ; sys_platform == 'darwin'

agent_v0/agent_v1/session/storage.py

@@ -0,0 +1,74 @@
+# agent_v1/session/storage.py
+"""
+Gestionnaire de stockage local robuste pour Agent V1.
+Gère le chiffrement des données au repos et l'auto-nettoyage du disque.
+"""
+
+import os
+import shutil
+import time
+import logging
+from pathlib import Path
+from datetime import datetime, timedelta
+
+logger = logging.getLogger("session_storage")
+
+class SessionStorage:
+    def __init__(self, base_dir: Path, max_size_gb: int = 5, retention_days: int = 180):
+        """Gestionnaire de stockage local pour les sessions Agent V1.
+
+        Args:
+            base_dir: Dossier racine de stockage des sessions.
+            max_size_gb: Taille maximale du stockage local (Go).
+            retention_days: Duree de retention en jours. Defaut = 180 (6 mois),
+                minimum requis par le Reglement IA (Article 12 — journalisation
+                automatique, Article 26(6) — conservation des logs).
+        """
+        self.base_dir = base_dir
+        self.max_size_bytes = max_size_gb * 1024 * 1024 * 1024
+        self.retention_days = retention_days
+        self.base_dir.mkdir(parents=True, exist_ok=True)
+
+    def get_session_dir(self, session_id: str) -> Path:
+        """Retourne et crée le dossier pour une session."""
+        session_path = self.base_dir / session_id
+        session_path.mkdir(exist_ok=True)
+        (session_path / "shots").mkdir(exist_ok=True)
+        return session_path
+
+    def run_auto_cleanup(self):
+        """Lance le nettoyage automatique basé sur l'âge et la taille."""
+        logger.info("🧹 Lancement du nettoyage automatique du stockage local...")
+        self._cleanup_by_age()
+        self._cleanup_by_size()
+
+    def _cleanup_by_age(self):
+        """Supprime les sessions plus vieilles que retention_days."""
+        threshold = datetime.now() - timedelta(days=self.retention_days)
+        for session_path in self.base_dir.iterdir():
+            if session_path.is_dir():
+                mtime = datetime.fromtimestamp(session_path.stat().st_mtime)
+                if mtime < threshold:
+                    logger.info(f"🗑️ Purge session ancienne : {session_path.name}")
+                    shutil.rmtree(session_path)
+
+    def _cleanup_by_size(self):
+        """Supprime les sessions les plus anciennes si la taille totale dépasse max_size_bytes."""
+        sessions = []
+        total_size = 0
+        for session_path in self.base_dir.iterdir():
+            if session_path.is_dir():
+                size = sum(f.stat().st_size for f in session_path.rglob('*') if f.is_file())
+                sessions.append((session_path, session_path.stat().st_mtime, size))
+                total_size += size
+
+        if total_size > self.max_size_bytes:
+            logger.warning(f"⚠️ Stockage saturé ({total_size/1e9:.2f} GB). Purge nécessaire.")
+            # Trier par date de modif (plus ancien d'abord)
+            sessions.sort(key=lambda x: x[1])
+            for path, _, size in sessions:
+                if total_size <= self.max_size_bytes * 0.8: # On libère jusqu'à 80% du max
+                    break
+                logger.info(f"🗑️ Purge session pour libérer de l'espace : {path.name} ({size/1e6:.1f} MB)")
+                shutil.rmtree(path)
+                total_size -= size

agent_v0/agent_v1/tools/test_lea_pause_flow.py

@@ -0,0 +1,88 @@
+# agent_v1/tools/test_lea_pause_flow.py
+"""Smoke test : simuler un lea:paused localement et vérifier la bulle ChatWindow.
+
+À lancer SUR WINDOWS (PC démo) :
+    cd C:/rpa_vision
+    .venv\\Scripts\\python.exe -m agent_v1.tools.test_lea_pause_flow
+
+Ce script ouvre une ChatWindow, simule l'arrivée d'un payload paused_need_help
+avec un message LONG (350+ chars pour tester le scroll interne), puis attend
+les clics utilisateur sur Continuer/Annuler. Le test vérifie qu'il y a UN SEUL
+affichage (la bulle chat), pas de toast supplémentaire.
+
+Exit code 0 si succès. Logs dans la console.
+"""
+
+import logging
+import os
+import sys
+import time
+
+# Configurer le logging avant tout import du package
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s [%(name)s] %(levelname)s: %(message)s',
+)
+logger = logging.getLogger("test_lea_pause_flow")
+
+# Forcer le bus feedback (pour que les boutons puissent émettre vers
+# rpa-agent-chat — port 5004). Si on ne veut PAS du bus, mettre LEA_FEEDBACK_BUS=0.
+os.environ.setdefault("LEA_FEEDBACK_BUS", "1")
+os.environ.setdefault("RPA_API_TOKEN", "")  # à remplir si serveur exige Bearer
+
+
+def main() -> int:
+    try:
+        from agent_v1.ui.chat_window import ChatWindow
+    except ImportError as e:
+        print(f"[TEST] Import ChatWindow KO : {e}")
+        return 2
+
+    print("[TEST] Création ChatWindow...")
+    cw = ChatWindow(
+        server_client=None,
+        on_start_callback=None,
+        server_host=os.environ.get("RPA_SERVER_HOST", "192.168.1.40"),
+        chat_port=5004,
+    )
+    # Attendre que le tk loop soit prêt
+    time.sleep(2.0)
+    cw.show()
+    time.sleep(0.5)
+
+    print("[TEST] Simulation lea:paused avec long message (350 chars)...")
+    long_msg = (
+        "Je n'arrive pas à trouver le champ « Numéro de dossier patient » "
+        "sur l'écran courant. J'ai essayé 3 stratégies de grounding visuel "
+        "(template matching, OCR, VLM) sans succès. Pouvez-vous me montrer "
+        "l'emplacement exact du champ, ou cliquer dessus à ma place ? "
+        "Quand vous avez fini, cliquez sur Continuer pour que je reprenne."
+    )
+    payload = {
+        "replay_id": "test_replay_pause_flow_001",
+        "workflow": "Démo UHCD",
+        "reason": long_msg,
+        "completed": 5,
+        "total": 12,
+    }
+    cw._add_paused_bubble(payload)
+    print(f"[TEST] Bulle envoyée. Message len={len(long_msg)} chars.")
+    print("[TEST] Vérifiez visuellement :")
+    print("       1) UN SEUL popup (la bulle chat dans la fenêtre Léa)")
+    print("       2) Le message long s'affiche en intégralité (scroll interne si besoin)")
+    print("       3) Boutons Continuer / Annuler visibles")
+    print("       4) Cliquez sur Annuler → bulle fermée + feedback '✗ Annulé'")
+    print("[TEST] La fenêtre reste ouverte 30s. Ctrl+C pour quitter avant.")
+
+    try:
+        for i in range(30):
+            time.sleep(1.0)
+    except KeyboardInterrupt:
+        print("[TEST] Interruption clavier.")
+
+    print("[TEST] Test terminé. Vérifier visuellement les 4 points ci-dessus.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())