feat: replay E2E fonctionnel — 25/25 actions, 0 retries, SomEngine via serveur

Validé sur PC Windows (DESKTOP-58D5CAC, 2560x1600) :
- 8 clics résolus visuellement (1 anchor_template, 1 som_text_match, 6 som_vlm)
- Score moyen 0.75, temps moyen 1.6s
- Texte tapé correctement (bonjour, test word, date, email)
- 0 retries, 2 actions non vérifiées (OK)

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

.kiro/specs/rpa-vision-excellence/design.md

@@ -0,0 +1,335 @@
+# Document de Conception : RPA Vision Excellence
+
+## Vue d'ensemble
+
+Cette conception transforme RPA Vision V3 en un système RPA 100% Vision de niveau production en ajoutant quatre composants majeurs :
+
+1. **Validateur de Qualité d'Entraînement** - Validation et métriques de qualité d'entraînement
+2. **Matcher Hiérarchique** - Matching multi-niveau robuste
+3. **Apprenant Continu** - Apprentissage continu et adaptation
+4. **Gestionnaire de Variantes** - Gestion des variantes et états dynamiques
+
+L'architecture s'intègre aux composants existants (GraphBuilder, WorkflowPipeline, ExecutionLoop) sans les remplacer.
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│                        RPA Vision Excellence                        │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│  ┌──────────────────┐    ┌──────────────────┐    ┌────────────────┐ │
+│  │ Training Quality │    │   Hierarchical   │    │   Continuous   │ │
+│  │    Validator     │    │     Matcher      │    │    Learner     │ │
+│  └────────┬─────────┘    └────────┬─────────┘    └───────┬────────┘ │
+│           │                       │                       │         │
+│           ▼                       ▼                       ▼         │
+│  ┌──────────────────────────────────────────────────────────────┐   │
+│  │                      Variant Manager                         │   │
+│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐   │   │
+│  │  │   Variant   │  │    State    │  │   Drift Detector    │   │   │
+│  │  │   Cluster   │  │   Tracker   │  │                     │   │   │
+│  │  └─────────────┘  └─────────────┘  └─────────────────────┘   │   │
+│  └──────────────────────────────────────────────────────────────┘   │
+│                                                                     │
+├─────────────────────────────────────────────────────────────────────┤
+│                     Existing Components                             │
+│  ┌────────────┐  ┌────────────┐  ┌────────────┐  ┌────────────┐     | 
+│  │   Graph    │  │  Workflow  │  │  Execution │  │    FAISS   │     │   
+│  │  Builder   │  │  Pipeline  │  │    Loop    │  │   Manager  │     │  
+│  └────────────┘  └────────────┘  └────────────┘  └────────────┘     │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+## Composants et Interfaces
+
+### 1. Validateur de Qualité d'Entraînement
+
+```python
+class TrainingQualityValidator:
+    """Valide la qualité des workflows entraînés"""
+    
+    def validate_workflow(self, workflow: Workflow, 
+                         observations: List[ScreenState]) -> QualityReport
+    
+    def compute_cluster_metrics(self, embeddings: np.ndarray, 
+                                labels: np.ndarray) -> ClusterMetrics
+    
+    def detect_outliers(self, embeddings: np.ndarray) -> List[int]
+    
+    def cross_validate(self, workflow: Workflow, 
+                      observations: List[ScreenState],
+                      holdout_ratio: float = 0.2) -> ValidationResult
+
+@dataclass
+class QualityReport:
+    overall_score: float  # 0.0 - 1.0
+    cluster_metrics: Dict[str, ClusterMetrics]
+    outlier_indices: List[int]
+    validation_accuracy: float
+    recommendations: List[str]
+    is_production_ready: bool
+
+@dataclass
+class ClusterMetrics:
+    silhouette_score: float  # Score de silhouette
+    cohesion: float          # Cohésion intra-cluster
+    separation: float        # Séparation inter-cluster
+    sample_count: int        # Nombre d'échantillons
+    is_sufficient: bool      # Données suffisantes
+```
+
+### 2. Matcher Hiérarchique
+
+```python
+class HierarchicalMatcher:
+    """Système de matching multi-niveau"""
+    
+    def match(self, screenshot: Image, 
+              workflow: Workflow,
+              temporal_context: Optional[TemporalContext] = None) -> MatchResult
+    
+    def match_window_level(self, window_info: WindowContext,
+                          node: WorkflowNode) -> float
+    
+    def match_region_level(self, regions: List[UIRegion],
+                          template_regions: List[UIRegion]) -> float
+    
+    def match_element_level(self, elements: List[UIElement],
+                           template_elements: List[UIElement]) -> float
+
+@dataclass
+class MatchResult:
+    node_id: str
+    confidence: float              # Confiance globale
+    window_confidence: float       # Confiance niveau fenêtre
+    region_confidence: float       # Confiance niveau région
+    element_confidence: float      # Confiance niveau élément
+    temporal_boost: float          # Bonus temporel
+    matched_variant: Optional[str] # Variante matchée
+    alternatives: List[AlternativeMatch]
+
+@dataclass
+class TemporalContext:
+    previous_nodes: List[str]       # N derniers nodes matchés
+    previous_confidences: List[float]
+    time_since_last_match: float    # Temps depuis dernier match
+```
+
+### 3. Apprenant Continu
+
+```python
+class ContinuousLearner:
+    """Apprentissage continu et adaptation"""
+    
+    def update_prototype(self, node_id: str, 
+                        new_embedding: np.ndarray,
+                        execution_success: bool) -> None
+    
+    def detect_drift(self, node_id: str,
+                    recent_confidences: List[float]) -> DriftStatus
+    
+    def create_variant(self, node_id: str,
+                      variant_embedding: np.ndarray) -> str
+    
+    def consolidate_variants(self, node_id: str) -> None
+    
+    def rollback_prototype(self, node_id: str, version: int) -> None
+
+@dataclass
+class DriftStatus:
+    is_drifting: bool                # Dérive détectée
+    drift_severity: float            # Sévérité 0.0 - 1.0
+    consecutive_low_confidence: int  # Matchs faibles consécutifs
+    recommended_action: str          # "monitor", "create_variant", "retrain"
+
+class PrototypeVersionManager:
+    """Gère l'historique des versions de prototypes"""
+    
+    def save_version(self, node_id: str, embedding: np.ndarray) -> int
+    def get_version(self, node_id: str, version: int) -> np.ndarray
+    def list_versions(self, node_id: str) -> List[VersionInfo]
+```
+
+### 4. Gestionnaire de Variantes
+
+```python
+class VariantManager:
+    """Gère les variantes d'écran et états UI"""
+    
+    def detect_variants(self, embeddings: List[np.ndarray],
+                       similarity_threshold: float = 0.7) -> List[VariantCluster]
+    
+    def match_with_variants(self, query_embedding: np.ndarray,
+                           node_id: str) -> VariantMatchResult
+    
+    def add_variant(self, node_id: str, 
+                   variant_embedding: np.ndarray,
+                   metadata: Dict) -> str
+    
+    def detect_ui_states(self, elements: List[UIElement]) -> Dict[str, UIState]
+    
+    def detect_overlay(self, screenshot: Image,
+                      baseline: Image) -> Optional[OverlayInfo]
+
+@dataclass
+class VariantCluster:
+    variant_id: str
+    prototype: np.ndarray
+    member_count: int                # Nombre de membres
+    similarity_to_primary: float     # Similarité avec prototype principal
+
+@dataclass
+class UIState(Enum):
+    ENABLED = "enabled"      # Activé
+    DISABLED = "disabled"    # Désactivé
+    CHECKED = "checked"      # Coché
+    UNCHECKED = "unchecked"  # Non coché
+    LOADING = "loading"      # Chargement
+    ERROR = "error"          # Erreur
+    FOCUSED = "focused"      # Focus
+
+@dataclass
+class OverlayInfo:
+    overlay_type: str  # "modal", "popup", "tooltip", "dropdown"
+    bounds: Tuple[int, int, int, int]  # Coordonnées
+    blocking: bool     # Bloquant
+```
+
+## Modèles de Données
+
+### WorkflowNode Amélioré
+
+```python
+@dataclass
+class EnhancedWorkflowNode(WorkflowNode):
+    # Champs existants hérités
+    
+    # Nouveaux champs pour variantes
+    variants: List[NodeVariant] = field(default_factory=list)
+    primary_variant_id: str = "primary"
+    
+    # Métriques de qualité
+    quality_score: float = 0.0
+    observation_count: int = 0
+    
+    # Versioning des prototypes
+    prototype_version: int = 1
+    prototype_history: List[str] = field(default_factory=list)
+
+@dataclass
+class NodeVariant:
+    variant_id: str
+    embedding_path: str
+    similarity_to_primary: float  # Similarité avec prototype principal
+    observation_count: int        # Nombre d'observations
+    created_at: datetime
+    metadata: Dict[str, Any]
+```
+
+### Relations Spatiales
+
+```python
+@dataclass
+class SpatialRelation:
+    source_element_id: str
+    target_element_id: str
+    relation_type: str  # "above", "below", "left_of", "right_of", "inside"
+    distance: float     # Distance en pixels
+    confidence: float   # Confiance de la relation
+
+@dataclass
+class SemanticContainer:
+    container_id: str
+    container_type: str  # "form", "menu", "toolbar", "dialog", "list"
+    element_ids: List[str]  # IDs des éléments contenus
+    bounds: Tuple[int, int, int, int]  # Coordonnées du conteneur
+```
+
+## Propriétés de Correction
+
+*Une propriété est une caractéristique ou un comportement qui doit être vrai pour toutes les exécutions valides d'un système - essentiellement, une déclaration formelle de ce que le système doit faire. Les propriétés servent de pont entre les spécifications lisibles par l'humain et les garanties de correction vérifiables par machine.*
+
+### Propriété 1 : Cohérence de la Qualité des Clusters
+*Pour tout* ensemble d'embeddings assignés à un cluster, le score de silhouette calculé par Training_Quality_Validator DOIT être cohérent avec la fonction silhouette_score de sklearn avec une tolérance de 0.01
+**Valide : Exigences 1.1**
+
+### Propriété 2 : Correction de la Détection d'Outliers
+*Pour tout* ensemble d'embeddings, les outliers détectés par la méthode IQR DOIVENT avoir une distance au centroïde du cluster supérieure à Q3 + 1.5*IQR
+**Valide : Exigences 1.3**
+
+### Propriété 3 : Précision de la Validation Croisée
+*Pour tout* workflow avec N observations, la validation croisée avec 20% de holdout DOIT correctement matcher au moins 80% des observations retenues vers leurs nodes originaux
+**Valide : Exigences 1.5**
+
+### Propriété 4 : Bornes de Confiance Hiérarchique
+*Pour tout* résultat de match du Hierarchical_Matcher, la confiance finale DOIT être égale à 0.2*fenêtre + 0.3*région + 0.5*élément avec une tolérance de 0.001
+**Valide : Exigences 2.4**
+
+### Propriété 5 : Correction du Boost Temporel
+*Pour tout* match où le node matché est un successeur valide du node précédent, la confiance DOIT être augmentée de exactement 0.1 (plafonnée à 1.0)
+**Valide : Exigences 2.5**
+
+### Propriété 6 : Mise à Jour du Prototype par EMA
+*Pour toute* mise à jour de prototype, le nouveau prototype DOIT être égal à (1-alpha)*ancien_prototype + alpha*nouvel_embedding où alpha=0.1
+**Valide : Exigences 3.1**
+
+### Propriété 7 : Seuil de Détection de Dérive
+*Pour toute* séquence de 3 exécutions consécutives avec une confiance inférieure à 0.85, le Drift_Detector DOIT signaler une dérive potentielle
+**Valide : Exigences 3.2**
+
+### Propriété 8 : Seuil de Similarité des Variantes
+*Pour toute* variante créée, sa similarité avec le prototype principal DOIT être inférieure à 0.7 (différence > 0.3)
+**Valide : Exigences 4.2**
+
+### Propriété 9 : Sélection de la Meilleure Variante
+*Pour tout* match contre un node avec variantes, le match retourné DOIT avoir la plus haute similarité parmi toutes les variantes
+**Valide : Exigences 4.3**
+
+### Propriété 10 : Symétrie des Relations Spatiales
+*Pour toute* relation spatiale "A à_gauche_de B", il DOIT exister une relation correspondante "B à_droite_de A"
+**Valide : Exigences 5.1**
+
+### Propriété 11 : Backoff Exponentiel des Retries
+*Pour toute* action échouée avec retries, les temps d'attente DOIVENT suivre le pattern : temps_base * 2^(tentative-1) pour les tentatives 1, 2, 3
+**Valide : Exigences 7.1**
+
+## Gestion des Erreurs
+
+### Erreurs d'Entraînement
+- **InsufficientDataError** : Levée quand un cluster a moins de 3 observations
+- **LowQualityClusterError** : Levée quand le score de silhouette < 0.5
+- **OutlierDominanceError** : Levée quand les outliers dépassent 30% des observations
+
+### Erreurs de Matching
+- **NoMatchFoundError** : Levée quand aucun node ne matche au-dessus du seuil
+- **AmbiguousMatchError** : Levée quand plusieurs nodes matchent avec confiance similaire
+- **TemporalInconsistencyError** : Levée quand le node matché n'est pas atteignable depuis le précédent
+
+### Erreurs d'Apprentissage
+- **DriftConfirmedError** : Levée quand la dérive est confirmée et nécessite action utilisateur
+- **VariantLimitExceededError** : Levée quand un node dépasse 5 variantes
+- **PrototypeCorruptionError** : Levée quand la mise à jour du prototype produit un embedding invalide
+
+## Stratégie de Tests
+
+### Tests Unitaires
+- Tester chaque composant isolément avec dépendances mockées
+- Tester les cas limites : entrées vides, observation unique, variantes maximum
+- Tester les conditions d'erreur et la gestion des exceptions
+
+### Tests Basés sur les Propriétés
+- Utiliser la bibliothèque Hypothesis pour les tests property-based en Python
+- Chaque propriété de correction DOIT avoir un test property correspondant
+- Configurer minimum 100 itérations par test property
+- Taguer chaque test avec : `**Feature: rpa-vision-excellence, Property {N}: {description}**`
+
+### Tests d'Intégration
+- Tester le pipeline complet : entraînement → validation → matching → exécution
+- Tester le cycle d'apprentissage continu avec changements UI simulés
+- Tester les workflows de création et consolidation de variantes
+
+### Tests de Performance
+- Latence de matching : < 100ms pour un screenshot
+- Validation d'entraînement : < 5s pour un workflow avec 100 observations
+- Mise à jour de prototype : < 10ms par mise à jour

.kiro/specs/rpa-vision-excellence/requirements.md

@@ -0,0 +1,106 @@
+# Requirements Document
+
+## Introduction
+
+Ce document définit les exigences pour transformer RPA Vision V3 en un système RPA 100% Vision de niveau production. L'objectif est d'améliorer la fiabilité de l'entraînement, la robustesse du matching, et la capacité d'adaptation continue aux changements d'interface utilisateur.
+
+Le système actuel présente des gaps critiques : pas de validation de qualité d'entraînement, matching trop simpliste basé uniquement sur similarité globale, pas d'apprentissage continu, et gestion insuffisante des variantes d'écran.
+
+## Glossary
+
+- **Training_Quality_Validator**: Composant qui évalue la qualité des workflows générés à partir des sessions d'entraînement
+- **Hierarchical_Matcher**: Système de matching multi-niveau (fenêtre → région → élément)
+- **Continuous_Learner**: Module d'apprentissage continu qui adapte les workflows aux changements
+- **Variant_Manager**: Gestionnaire des variantes légitimes d'un même état d'écran
+- **Drift_Detector**: Détecteur de changements significatifs dans l'interface utilisateur
+- **Cluster_Quality_Score**: Métrique de qualité d'un cluster DBSCAN (silhouette, cohésion, séparation)
+- **Embedding_Prototype**: Vecteur représentatif d'un état d'écran (moyenne normalisée des embeddings du cluster)
+- **Temporal_Context**: Séquence d'états précédents influençant le matching actuel
+- **UI_State**: État d'un élément UI (enabled, disabled, checked, loading, error)
+- **Spatial_Relation**: Relation spatiale entre éléments (above, below, left_of, right_of, inside)
+
+## Requirements
+
+### Requirement 1: Training Quality Validation
+
+**User Story:** As a RPA developer, I want to validate the quality of trained workflows, so that I can ensure reliable replay execution.
+
+#### Acceptance Criteria
+
+1. WHEN a workflow is built from a session THEN the Training_Quality_Validator SHALL compute cluster quality metrics including silhouette score, cohesion, and separation for each detected pattern
+2. WHEN cluster quality score falls below 0.7 THEN the Training_Quality_Validator SHALL flag the cluster as low-confidence and require additional training samples
+3. WHEN computing embedding prototypes THEN the Training_Quality_Validator SHALL detect and exclude outlier embeddings using IQR method with 1.5 threshold
+4. WHEN a workflow contains fewer than 3 observations per node THEN the Training_Quality_Validator SHALL mark the workflow as insufficient-data and prevent AUTO_CANDIDATE transition
+5. WHEN validating a workflow THEN the Training_Quality_Validator SHALL perform cross-validation by holding out 20% of observations and measuring match accuracy
+
+### Requirement 2: Hierarchical Matching System
+
+**User Story:** As a RPA system, I want to match screens using multiple levels of granularity, so that I can achieve more robust and accurate state recognition.
+
+#### Acceptance Criteria
+
+1. WHEN matching a screenshot THEN the Hierarchical_Matcher SHALL first match at window level using title pattern and process name with confidence weight 0.2
+2. WHEN window-level match succeeds THEN the Hierarchical_Matcher SHALL match at region level by comparing detected UI regions with stored region templates
+3. WHEN region-level match succeeds THEN the Hierarchical_Matcher SHALL match at element level by comparing individual UI elements within matched regions
+4. WHEN computing final match confidence THEN the Hierarchical_Matcher SHALL combine window, region, and element confidences using weighted formula: 0.2*window + 0.3*region + 0.5*element
+5. WHEN temporal context is available THEN the Hierarchical_Matcher SHALL boost confidence for nodes that are valid successors of the previous matched node by 0.1
+
+### Requirement 3: Continuous Learning and Adaptation
+
+**User Story:** As a RPA system, I want to continuously learn from new observations, so that I can adapt to UI changes without full retraining.
+
+#### Acceptance Criteria
+
+1. WHEN a successful execution occurs THEN the Continuous_Learner SHALL update the node embedding prototype using exponential moving average with alpha 0.1
+2. WHEN match confidence drops below 0.85 for 3 consecutive executions THEN the Drift_Detector SHALL flag potential UI drift and notify the user
+3. WHEN UI drift is confirmed THEN the Continuous_Learner SHALL create a new variant for the affected node while preserving the original
+4. WHEN a node has more than 5 variants THEN the Continuous_Learner SHALL consolidate variants by re-clustering with updated parameters
+5. WHEN updating prototypes THEN the Continuous_Learner SHALL maintain version history allowing rollback to previous prototype versions
+
+### Requirement 4: Variant and State Management
+
+**User Story:** As a RPA developer, I want the system to handle screen variants and dynamic states, so that workflows work reliably across different UI conditions.
+
+#### Acceptance Criteria
+
+1. WHEN building a workflow THEN the Variant_Manager SHALL detect and group similar but distinct screen states as variants of the same logical node
+2. WHEN a variant differs by more than 0.3 similarity from the primary prototype THEN the Variant_Manager SHALL create a separate variant entry with its own embedding
+3. WHEN matching against a node with variants THEN the Variant_Manager SHALL match against all variants and return the best match with variant identifier
+4. WHEN detecting UI element states THEN the Variant_Manager SHALL identify and store element states including enabled, disabled, checked, unchecked, loading, and error
+5. WHEN an unexpected popup or modal appears THEN the Variant_Manager SHALL detect the overlay and pause execution for user decision or apply configured handling rule
+
+### Requirement 5: Advanced UI Understanding
+
+**User Story:** As a RPA system, I want to understand UI structure and relationships, so that I can locate elements more reliably even when positions change.
+
+#### Acceptance Criteria
+
+1. WHEN detecting UI elements THEN the UI_Analyzer SHALL compute spatial relations between elements including above, below, left_of, right_of, and inside
+2. WHEN building a workflow THEN the UI_Analyzer SHALL group related elements into semantic containers such as forms, menus, toolbars, and dialogs
+3. WHEN resolving a target element THEN the UI_Analyzer SHALL use spatial relations as fallback when direct matching fails
+4. WHEN an element cannot be found by primary strategy THEN the UI_Analyzer SHALL search using anchor elements with known spatial relations
+5. WHEN detecting element states THEN the UI_Analyzer SHALL use visual features including color, opacity, and border style to determine enabled, disabled, or loading states
+
+### Requirement 6: Training Session Quality
+
+**User Story:** As a RPA developer, I want feedback on training session quality, so that I can improve my demonstrations for better workflow reliability.
+
+#### Acceptance Criteria
+
+1. WHEN a training session is uploaded THEN the Session_Analyzer SHALL compute a quality score based on screenshot clarity, action consistency, and timing patterns
+2. WHEN screenshots have low contrast or blur THEN the Session_Analyzer SHALL flag affected frames and suggest re-recording
+3. WHEN action timing is inconsistent with more than 2x standard deviation THEN the Session_Analyzer SHALL identify potentially problematic transitions
+4. WHEN duplicate or near-duplicate screenshots exceed 30% of session THEN the Session_Analyzer SHALL suggest optimizing capture frequency
+5. WHEN generating quality report THEN the Session_Analyzer SHALL provide actionable recommendations for improving training data
+
+### Requirement 7: Execution Robustness
+
+**User Story:** As a RPA system, I want robust execution handling, so that workflows can recover from transient failures and unexpected conditions.
+
+#### Acceptance Criteria
+
+1. WHEN an action fails THEN the Execution_Engine SHALL retry with exponential backoff up to 3 times before marking as failed
+2. WHEN a target element is not found THEN the Execution_Engine SHALL wait up to configured timeout with periodic re-detection before failing
+3. WHEN screen state does not match expected post-condition THEN the Execution_Engine SHALL attempt recovery by re-matching current state to workflow graph
+4. WHEN execution encounters an unknown screen THEN the Execution_Engine SHALL pause and request user guidance with screenshot and context
+5. WHEN recovering from failure THEN the Execution_Engine SHALL log detailed diagnostics including screenshots, match scores, and attempted strategies

.kiro/specs/rpa-vision-excellence/tasks.md

@@ -0,0 +1,243 @@
+# Plan d'Implémentation
+
+## Phase 1 : Validateur de Qualité d'Entraînement
+
+- [x] 1. Implémenter le cœur du Validateur de Qualité
+  - [x] 1.1 Créer `core/training/quality_validator.py` avec la classe TrainingQualityValidator
+    - Implémenter la méthode `validate_workflow()` retournant QualityReport
+    - Implémenter `compute_cluster_metrics()` utilisant sklearn silhouette_score
+    - Créer les dataclasses QualityReport et ClusterMetrics
+    - _Exigences : 1.1, 1.4_
+  - [x]* 1.2 Écrire le test property pour la cohérence de qualité des clusters
+    - **Propriété 1 : Cohérence de la Qualité des Clusters**
+    - **Valide : Exigences 1.1**
+  - [x] 1.3 Implémenter la détection d'outliers avec méthode IQR
+    - Créer la méthode `detect_outliers()` avec seuil IQR 1.5
+    - Retourner les indices des embeddings outliers
+    - _Exigences : 1.3_
+  - [x]* 1.4 Écrire le test property pour la détection d'outliers
+    - **Propriété 2 : Correction de la Détection d'Outliers**
+    - **Valide : Exigences 1.3**
+  - [x] 1.5 Implémenter la validation croisée pour la qualité du workflow
+    - Créer la méthode `cross_validate()` avec ratio holdout configurable
+    - Calculer la précision de match sur les observations retenues
+    - _Exigences : 1.5_
+  - [x]* 1.6 Écrire le test property pour la validation croisée
+    - **Propriété 3 : Précision de la Validation Croisée**
+    - **Valide : Exigences 1.5**
+
+- [x] 2. Intégrer le Validateur de Qualité avec GraphBuilder
+  - [x] 2.1 Modifier `core/graph/graph_builder.py` pour appeler le validateur après création du workflow
+    - Ajouter l'étape de validation de qualité dans `build_from_session()`
+    - Stocker les métriques de qualité dans les métadonnées du workflow
+    - _Exigences : 1.1, 1.2_
+  - [x] 2.2 Ajouter les restrictions d'état basées sur la qualité
+    - Empêcher la transition AUTO_CANDIDATE si qualité < 0.7
+    - Marquer les clusters à faible confiance dans le workflow
+    - _Exigences : 1.2, 1.4_
+
+- [x] 3. Point de contrôle - Vérifier que tous les tests passent
+  - Vérifier que tous les tests passent, demander à l'utilisateur si des questions se posent.
+
+## Phase 2 : Matcher Hiérarchique
+
+- [x] 4. Implémenter le cœur du Matcher Hiérarchique
+  - [x] 4.1 Créer `core/matching/hierarchical_matcher.py` avec la classe HierarchicalMatcher
+    - Implémenter la méthode `match()` retournant MatchResult
+    - Créer les dataclasses MatchResult et TemporalContext
+    - _Exigences : 2.1, 2.2, 2.3_
+  - [x] 4.2 Implémenter le matching niveau fenêtre
+    - Créer `match_window_level()` comparant pattern de titre et processus
+    - Retourner un score de confiance 0.0-1.0
+    - _Exigences : 2.1_
+  - [x] 4.3 Implémenter le matching niveau région
+    - Créer `match_region_level()` comparant les régions UI
+    - Utiliser IoU et similarité d'embedding pour le matching de régions
+    - _Exigences : 2.2_
+  - [x] 4.4 Implémenter le matching niveau élément
+    - Créer `match_element_level()` comparant les éléments individuels
+    - Utiliser rôle, texte et similarité visuelle
+    - _Exigences : 2.3_
+  - [x] 4.5 Implémenter la formule de combinaison de confiance
+    - Combiner : 0.2*fenêtre + 0.3*région + 0.5*élément
+    - _Exigences : 2.4_
+  - [x]* 4.6 Écrire le test property pour les bornes de confiance
+    - **Propriété 4 : Bornes de Confiance Hiérarchique**
+    - **Valide : Exigences 2.4**
+  - [x] 4.7 Implémenter le boost de contexte temporel
+    - Augmenter la confiance de 0.1 pour les nodes successeurs valides
+    - Plafonner la confiance finale à 1.0
+    - _Exigences : 2.5_
+  - [x]* 4.8 Écrire le test property pour le boost temporel
+    - **Propriété 5 : Correction du Boost Temporel**
+    - **Valide : Exigences 2.5**
+
+- [x] 5. Intégrer le Matcher Hiérarchique avec le Pipeline
+  - [x] 5.1 Modifier `core/pipeline/workflow_pipeline.py` pour utiliser HierarchicalMatcher
+    - Remplacer le matching FAISS simple par l'approche hiérarchique
+    - Maintenir le contexte temporel entre les matchs
+    - _Exigences : 2.1, 2.2, 2.3, 2.4, 2.5_
+
+- [x] 6. Point de contrôle - Vérifier que tous les tests passent
+  - Vérifier que tous les tests passent, demander à l'utilisateur si des questions se posent.
+
+## Phase 3 : Apprenant Continu
+
+- [x] 7. Implémenter le cœur de l'Apprenant Continu
+  - [x] 7.1 Créer `core/learning/continuous_learner.py` avec la classe ContinuousLearner
+    - Implémenter `update_prototype()` avec EMA (alpha=0.1)
+    - Créer la dataclass DriftStatus
+    - _Exigences : 3.1_
+  - [x]* 7.2 Écrire le test property pour la mise à jour EMA du prototype
+    - **Propriété 6 : Mise à Jour du Prototype par EMA**
+    - **Valide : Exigences 3.1**
+  - [x] 7.3 Implémenter la détection de dérive
+    - Créer `detect_drift()` suivant les matchs consécutifs à faible confiance
+    - Signaler la dérive après 3 matchs consécutifs sous 0.85
+    - _Exigences : 3.2_
+  - [x]* 7.4 Écrire le test property pour la détection de dérive
+    - **Propriété 7 : Seuil de Détection de Dérive**
+    - **Valide : Exigences 3.2**
+  - [x] 7.5 Implémenter la création de variante sur dérive
+    - Créer `create_variant()` pour les nouvelles variantes UI
+    - Stocker l'embedding de variante séparément
+    - _Exigences : 3.3_
+  - [x] 7.6 Implémenter la consolidation des variantes
+    - Créer `consolidate_variants()` quand les variantes dépassent 5
+    - Re-clusteriser les variantes pour réduire le nombre
+    - _Exigences : 3.4_
+
+- [x] 8. Implémenter le Gestionnaire de Versions de Prototypes
+  - [x] 8.1 Créer `core/learning/prototype_version_manager.py`
+    - Implémenter `save_version()`, `get_version()`, `list_versions()`
+    - Stocker les versions comme fichiers .npy avec métadonnées
+    - _Exigences : 3.5_
+  - [x] 8.2 Implémenter la fonctionnalité de rollback
+    - Créer `rollback_prototype()` pour restaurer une version précédente
+    - Mettre à jour l'index FAISS lors du rollback
+    - _Exigences : 3.5_
+
+- [x] 9. Intégrer l'Apprenant Continu avec la Boucle d'Exécution
+  - [x] 9.1 Modifier `core/execution/execution_loop.py` pour appeler l'apprenant
+    - Mettre à jour le prototype après exécution réussie
+    - Vérifier la dérive après chaque match
+    - _Exigences : 3.1, 3.2_
+
+- [x] 10. Point de contrôle - Vérifier que tous les tests passent
+  - Vérifier que tous les tests passent, demander à l'utilisateur si des questions se posent.
+
+## Phase 4 : Gestionnaire de Variantes
+
+- [x] 11. Implémenter le cœur du Gestionnaire de Variantes
+  - [x] 11.1 Créer `core/variants/variant_manager.py` avec la classe VariantManager
+    - Implémenter `detect_variants()` utilisant le clustering par similarité
+    - Créer les dataclasses VariantCluster et NodeVariant
+    - _Exigences : 4.1_
+  - [x] 11.2 Implémenter le matching avec variantes
+    - Créer `match_with_variants()` retournant le meilleur match de variante
+    - Comparer contre toutes les variantes, retourner la plus haute similarité
+    - _Exigences : 4.3_
+  - [x]* 11.3 Écrire le test property pour le seuil de similarité des variantes
+    - **Propriété 8 : Seuil de Similarité des Variantes**
+    - **Valide : Exigences 4.2**
+  - [x]* 11.4 Écrire le test property pour la sélection de la meilleure variante
+    - **Propriété 9 : Sélection de la Meilleure Variante**
+    - **Valide : Exigences 4.3**
+  - [x] 11.5 Implémenter la détection d'états UI
+    - Créer `detect_ui_states()` analysant les caractéristiques visuelles
+    - Détecter : états activé, désactivé, coché, chargement, erreur
+    - _Exigences : 4.4_
+  - [x] 11.6 Implémenter la détection d'overlay
+    - Créer `detect_overlay()` comparant l'écran actuel vs baseline
+    - Identifier les overlays modal, popup, tooltip, dropdown
+    - _Exigences : 4.5_
+
+- [x] 12. Améliorer le modèle WorkflowNode
+  - [x] 12.1 Mettre à jour `core/models/workflow_graph.py` avec support des variantes
+    - Ajouter les champs variants list, primary_variant_id, quality_score
+    - Ajouter les champs prototype_version et prototype_history
+    - _Exigences : 4.1, 4.2, 4.3_
+
+- [x] 13. Point de contrôle - Vérifier que tous les tests passent
+  - Vérifier que tous les tests passent, demander à l'utilisateur si des questions se posent.
+
+## Phase 5 : Compréhension UI Avancée
+
+- [x] 14. Implémenter les Relations Spatiales
+  - [x] 14.1 Créer `core/detection/spatial_analyzer.py` avec la classe SpatialAnalyzer
+    - Implémenter `compute_relations()` entre éléments UI
+    - Supporter : relations au-dessus, en-dessous, à_gauche_de, à_droite_de, à_l'intérieur
+    - _Exigences : 5.1_
+  - [x]* 14.2 Écrire le test property pour la symétrie des relations spatiales
+    - **Propriété 10 : Symétrie des Relations Spatiales**
+    - **Valide : Exigences 5.1**
+  - [x] 14.3 Implémenter la détection de conteneurs sémantiques
+    - Créer `detect_containers()` groupant les éléments liés
+    - Identifier : conteneurs formulaire, menu, barre d'outils, dialogue, liste
+    - _Exigences : 5.2_
+
+- [x] 15. Améliorer le Target Resolver avec fallback spatial
+  - [x] 15.1 Modifier `core/execution/target_resolver.py` pour utiliser les relations spatiales
+    - Ajouter la stratégie de fallback par relation spatiale
+    - Utiliser les éléments ancres quand le match direct échoue
+    - _Exigences : 5.3, 5.4_
+  - [x] 15.2 Ajouter la détection d'état visuel au matching d'éléments
+    - Détecter activé/désactivé depuis couleur, opacité, bordure
+    - _Exigences : 5.5_
+
+- [x] 16. Point de contrôle - Vérifier que tous les tests passent
+  - Vérifier que tous les tests passent, demander à l'utilisateur si des questions se posent.
+
+## Phase 6 : Qualité des Sessions d'Entraînement
+
+- [x] 17. Implémenter l'Analyseur de Session
+  - [x] 17.1 Créer `core/training/session_analyzer.py` avec la classe SessionAnalyzer
+    - Implémenter `analyze_session()` retournant SessionQualityReport
+    - Calculer le score de qualité depuis clarté, cohérence, timing
+    - _Exigences : 6.1_
+  - [x] 17.2 Implémenter la détection de qualité des screenshots
+    - Détecter faible contraste, flou, artefacts
+    - Marquer les frames problématiques
+    - _Exigences : 6.2_
+  - [x] 17.3 Implémenter l'analyse de timing
+    - Détecter le timing d'action incohérent (>2x écart-type)
+    - Identifier les transitions problématiques
+    - _Exigences : 6.3_
+  - [x] 17.4 Implémenter la détection de doublons
+    - Détecter les screenshots quasi-dupliqués
+    - Suggérer l'optimisation de la fréquence de capture
+    - _Exigences : 6.4_
+  - [x] 17.5 Générer des recommandations actionnables
+    - Fournir des suggestions d'amélioration spécifiques
+    - _Exigences : 6.5_
+
+- [x] 18. Point de contrôle - Vérifier que tous les tests passent
+  - Vérifier que tous les tests passent, demander à l'utilisateur si des questions se posent.
+
+## Phase 7 : Robustesse d'Exécution
+
+- [x] 19. Améliorer le Moteur d'Exécution
+  - [x] 19.1 Implémenter le retry avec backoff exponentiel
+    - Ajouter la logique de retry à l'exécution d'action
+    - Utiliser le pattern temps_base * 2^(tentative-1)
+    - _Exigences : 7.1_
+  - [x]* 19.2 Écrire le test property pour le backoff exponentiel
+    - **Propriété 11 : Backoff Exponentiel des Retries**
+    - **Valide : Exigences 7.1**
+  - [x] 19.3 Implémenter l'attente d'élément avec re-détection
+    - Attendre jusqu'au timeout avec re-détection périodique
+    - _Exigences : 7.2_
+  - [x] 19.4 Implémenter la récupération d'état
+    - Re-matcher l'état actuel vers le graphe de workflow en cas d'échec
+    - Trouver un chemin de récupération si possible
+    - _Exigences : 7.3_
+  - [x] 19.5 Implémenter la gestion d'écran inconnu
+    - Mettre en pause l'exécution sur écran inconnu
+    - Demander guidance utilisateur avec contexte
+    - _Exigences : 7.4_
+  - [x] 19.6 Implémenter les diagnostics détaillés d'échec
+    - Logger screenshots, scores de match, stratégies
+    - _Exigences : 7.5_
+
+- [x] 20. Point de contrôle final - Vérifier que tous les tests passent
+  - Vérifier que tous les tests passent, demander à l'utilisateur si des questions se posent.