Dom/rpa_vision_v3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
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>
This commit is contained in:
Dom
2026-03-31 14:04:41 +02:00
parent 5e0b53cfd1
commit a7de6a488b
79542 changed files with 6091757 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

347
.kiro/specs/multi-anchor-constraints/design.md Normal file
View File

@@ -0,0 +1,347 @@
# Multi-Anchor Constraints Design Document
## Overview
This document specifies the design for a multi-anchor constraint system that enables RPA Vision V3 to understand complex targeting instructions. The system combines multiple anchor references, hard constraints, and intelligent weighting to select optimal target elements with "combinatorial common sense."
## Architecture
The multi-anchor constraint system extends the existing TargetResolver with advanced targeting capabilities:
```
┌─────────────────────────────────────────────────────────────────┐
│ Multi-Anchor Constraint Architecture │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────┐ │
│ │ Enhanced │ │ Multi-Anchor │ │ Hard │ │
│ │ TargetSpec │ │ Resolver │ │ Constraints│ │
│ │ │ │ │ │ │ │
│ │ • hard_ │◄──►│ • Anchor │◄──►│ • Container │ │
│ │ constraints │ │ Evaluation │ │ Filter │ │
│ │ • weights │ │ • Best Combo │ │ • Area │ │
│ │ • multi-anchor │ │ Selection │ │ Filter │ │
│ └─────────────────┘ └─────────────────┘ └─────────────┘ │
│ │ │ │ │
│ │ │ │ │
│ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────┐ │
│ │ Container │ │ Weighted │ │ Tie-Break │ │
│ │ Resolver │ │ Scoring │ │ System │ │
│ │ │ │ │ │ │ │
│ │ • Text-based │ │ • Proximity │ │ • Stable │ │
│ │ Container │ │ • Alignment │ │ Selection │ │
│ │ Finding │ │ • Container │ │ • Multi- │ │
│ │ • Smallest │ │ • ROI IOU │ │ Criteria │ │
│ │ Container │ │ │ │ │ │
│ └─────────────────┘ └─────────────────┘ └─────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
```
## Components and Interfaces
### 1. Enhanced TargetSpec
Extension of the existing TargetSpec dataclass with new fields:
```python
from dataclasses import dataclass, field
from typing import Any, Dict, Optional
@dataclass
class TargetSpec:
# Existing fields
by_role: Optional[str] = None
by_text: Optional[str] = None
by_position: Optional[Dict[str, Any]] = None
selection_policy: str = "first"
context_hints: Dict[str, Any] = field(default_factory=dict)
# New fields for Fiche #11
hard_constraints: Dict[str, Any] = field(default_factory=dict)
weights: Dict[str, float] = field(default_factory=dict)
```
**Usage Examples:**
```python
# Multi-anchor with container constraint
target_spec = TargetSpec(
by_role="input",
context_hints={"near_text": ["Username", "Identifiant"]},
hard_constraints={"within_container_text": "Login"},
weights={"proximity": 0.45, "alignment": 0.35, "container": 0.20}
)
```
### 2. Multi-Anchor Resolution System
The core logic for evaluating multiple anchors and selecting the best combination:
```python
class MultiAnchorResolver:
def resolve_with_multiple_anchors(self, target_spec: TargetSpec,
ui_elements: List[UIElement]) -> Optional[ResolvedTarget]:
"""
Resolve target using multiple anchor evaluation
Process:
1. Extract all anchor texts from context_hints
2. Find all anchor candidates for each text
3. For each anchor candidate, build ROI and score all target candidates
4. Apply hard constraints to filter candidates
5. Apply weighted scoring to rank candidates
6. Use stable tie-breaking for final selection
"""
```
### 3. Hard Constraints System
Strict filtering system that eliminates candidates before scoring:
```python
class HardConstraintsFilter:
def apply_constraints(self, candidates: List[UIElement],
constraints: Dict[str, Any],
ui_elements: List[UIElement]) -> List[UIElement]:
"""
Apply hard constraints as strict filters
Supported constraints:
- within_container_text: Only elements within specified container
- min_area: Only elements with area >= threshold
- max_distance: Only elements within distance from anchor
"""
def _container_bbox_from_text(self, text: str,
ui_elements: List[UIElement]) -> Optional[BBox]:
"""
Find container bounding box from text label
Process:
1. Find element with matching text
2. If element is container type, use its bbox
3. If element is label, find smallest containing container
4. Return container bbox or None if not found
"""
```
### 4. Weighted Scoring System
Configurable scoring system with multiple criteria:
```python
class WeightedScorer:
def calculate_composite_score(self, element: UIElement,
anchor: Optional[UIElement],
roi_bbox: Optional[BBox],
container_bbox: Optional[BBox],
weights: Dict[str, float],
base_score: float) -> float:
"""
Calculate weighted composite score
Components:
- proximity: Distance from anchor (if available)
- alignment: Horizontal/vertical alignment with anchor
- container: Preference for elements in preferred container
- roi_iou: Intersection over union with ROI
"""
DEFAULT_WEIGHTS = {
"proximity": 0.35,
"alignment": 0.25,
"container": 0.15,
"roi_iou": 0.25
}
```
### 5. Container Resolution System
Text-based container finding with intelligent fallback:
```python
class ContainerResolver:
def find_container_by_text(self, text: str,
ui_elements: List[UIElement]) -> Optional[BBox]:
"""
Find container by text with smart detection
Process:
1. Find elements matching the text
2. Check if element is already a container type
3. If not, find smallest containing container
4. Return container bbox with preference for smallest
"""
CONTAINER_ROLES = {"panel", "container", "group", "form", "dialog", "window"}
CONTAINER_TYPES = {"panel", "container", "group", "form", "dialog", "window"}
```
### 6. Stable Tie-Breaking System
Multi-criteria tie-breaking for reproducible results:
```python
class TieBreaker:
def create_sort_key(self, element: UIElement, score: float) -> Tuple:
"""
Create stable sort key for tie-breaking
Criteria (in order):
1. Composite score (descending)
2. Element confidence (descending)
3. Element area (descending)
4. Element ID (ascending for stability)
"""
return (
score,
float(getattr(element, "confidence", 1.0) or 1.0),
self._bbox_area(element.bbox),
str(element.element_id)
)
```
## Data Models
### Enhanced Resolution Details
Extension of ResolvedTarget.resolution_details with multi-anchor information:
```python
resolution_details = {
# Existing fields
"healing_attempt": int,
"anchor_id": Optional[str],
"top3": List[Dict],
# New fields for multi-anchor
"anchors_attempted": List[str], # All anchor texts tried
"successful_anchor": Optional[str], # Which anchor text succeeded
"hard_constraints_applied": Dict[str, Any], # Constraints that were applied
"candidates_filtered": int, # How many candidates were filtered
"weights_used": Dict[str, float], # Actual weights applied
"tie_break_criteria": Optional[str], # Which tie-break criterion was used
"container_resolved": Optional[str], # Container text that was resolved
"performance_metrics": Dict[str, float] # Timing and efficiency metrics
}
```
### Multi-Anchor Metrics
```python
@dataclass
class MultiAnchorMetrics:
"""Metrics for multi-anchor resolution performance"""
total_anchors_attempted: int
successful_anchor_index: int
candidates_before_constraints: int
candidates_after_constraints: int
scoring_duration_ms: float
container_resolution_duration_ms: float
total_resolution_duration_ms: float
cache_hits: int
cache_misses: int
```
## Correctness Properties
*A property is a characteristic or behavior that should hold true across all valid executions of a system-essentially, a formal statement about what the system should do. Properties serve as the bridge between human-readable specifications and machine-verifiable correctness guarantees.*
### Property 1: Multi-anchor evaluation completeness
*For any* target specification with multiple anchor texts, all anchor texts should be attempted for resolution until one succeeds or all are exhausted
**Validates: Requirements 1.1, 1.3**
### Property 2: Hard constraint strictness
*For any* set of hard constraints, no element that violates any constraint should be included in the final candidate set
**Validates: Requirements 2.1, 2.4**
### Property 3: Container resolution consistency
*For any* container text specification, the same container should be resolved consistently across multiple calls with the same UI state
**Validates: Requirements 4.1, 4.4**
### Property 4: Weighted scoring monotonicity
*For any* two elements where element A is objectively better than element B on all weighted criteria, element A should have a higher composite score than element B
**Validates: Requirements 3.1, 3.2, 3.3, 3.4**
### Property 5: Tie-breaking determinism
*For any* UI state processed multiple times, when multiple elements have identical scores, the same element should always be selected
**Validates: Requirements 5.5**
### Property 6: Anchor fallback resilience
*For any* target specification where some anchor texts are missing, resolution should continue with available anchors without failing
**Validates: Requirements 1.3, 1.4**
### Property 7: Constraint filtering completeness
*For any* hard constraint specification, all elements that violate the constraint should be filtered out before scoring
**Validates: Requirements 2.2, 2.3**
### Property 8: Semantic variant equivalence
*For any* set of semantic variant anchor texts, elements found by any variant should be treated as equivalent candidates
**Validates: Requirements 6.1, 6.2**
### Property 9: Performance optimization consistency
*For any* multi-anchor resolution, UI element analysis should be reused between anchor evaluations to avoid redundant computation
**Validates: Requirements 8.2, 8.4**
### Property 10: Audit trail completeness
*For any* multi-anchor resolution, the resolution details should contain complete information about anchors attempted, constraints applied, and scoring performed
**Validates: Requirements 7.1, 7.2, 7.3, 7.5**
## Error Handling
### Multi-Anchor Failure Scenarios
1. **All Anchors Missing**: Fall back to anchor-less resolution with logging
2. **Invalid Container Text**: Log warning and continue without container constraint
3. **Malformed Weights**: Validate and fall back to default weights
4. **Empty Candidate Set**: Return None with detailed failure reason
5. **Scoring Calculation Errors**: Use base score with error logging
### Recovery Strategies
1. **Graceful Degradation**: Continue with available anchors when some fail
2. **Weight Validation**: Normalize weights to sum to 1.0 if invalid
3. **Container Fallback**: Continue without container constraint if resolution fails
4. **Performance Fallback**: Disable caching if cache operations fail
5. **Logging Resilience**: Continue operation even if audit logging fails
## Testing Strategy
### Unit Tests
- Test multi-anchor text extraction and candidate finding
- Test hard constraint filtering with various constraint types
- Test weighted scoring with different weight configurations
- Test container resolution with various text patterns
- Test tie-breaking with identical scores
- Test performance optimizations (caching, reuse)
### Property-Based Tests
Using Hypothesis framework with 100+ iterations per property:
- **Property 1**: Multi-anchor evaluation completeness
- **Property 2**: Hard constraint strictness
- **Property 3**: Container resolution consistency
- **Property 4**: Weighted scoring monotonicity
- **Property 5**: Tie-breaking determinism
- **Property 6**: Anchor fallback resilience
- **Property 7**: Constraint filtering completeness
- **Property 8**: Semantic variant equivalence
- **Property 9**: Performance optimization consistency
- **Property 10**: Audit trail completeness
### Integration Tests
- End-to-end multi-anchor resolution with complex UI states
- Performance benchmarks with large UI element sets
- Cross-component integration with existing healing system
- Real-world scenarios with Login/Settings panel disambiguation
- Stress testing with many anchors and constraints
### Performance Tests
- Multi-anchor resolution should complete within 50ms for typical UI states
- Memory usage should remain constant regardless of anchor count
- Cache hit rates should exceed 80% for repeated container lookups
- Scoring calculations should scale linearly with candidate count

117
.kiro/specs/multi-anchor-constraints/requirements.md Normal file
View File

@@ -0,0 +1,117 @@
# Document d'Exigences - Système Multi-Anchor et Contraintes
**Auteur :** Dom, Alice Kiro
**Date :** 15 décembre 2024
## Introduction
Ce document spécifie les exigences pour un système de contraintes multi-anchor et de bon sens combinatoire pour RPA Vision V3. Le système permettra au bot de "comprendre" des consignes complexes en utilisant plusieurs ancres de référence, des contraintes strictes (hard constraints), et des pondérations intelligentes pour choisir le meilleur élément cible.
## Glossaire
- **Système Multi-Anchor** : Système capable d'utiliser plusieurs ancres de référence pour localiser un élément cible
- **Contraintes Strictes** : Contraintes qui filtrent les candidats (ex: "dans le conteneur Login")
- **Contraintes Souples** : Contraintes pondérées qui influencent le score final (ex: proximité, alignement)
- **Intelligence Combinatoire** : Capacité à combiner plusieurs critères pour prendre une décision optimale
- **Contexte de Conteneur** : Contexte de conteneur identifié par texte (ex: "Panneau Login", "Dialogue Paramètres")
- **Fallback d'Ancre** : Mécanisme de fallback entre plusieurs ancres possibles
- **Stabilité de Départage** : Mécanisme de départage stable et reproductible
- **Scoring Pondéré** : Système de scoring avec pondérations configurables
## Exigences
### Exigence 1
**Histoire Utilisateur :** En tant que développeur de workflow, je veux spécifier plusieurs textes d'ancrage pour la résolution de cible, afin que le système puisse trouver des éléments même quand le texte de l'interface varie.
#### Critères d'Acceptation
1. QUAND une spécification de cible contient plusieurs textes d'ancrage dans context_hints, LE Système Multi-Anchor DOIT tenter la résolution avec chaque texte d'ancrage
2. QUAND plusieurs ancres sont disponibles, LE Système Multi-Anchor DOIT évaluer tous les candidats d'ancrage et sélectionner la meilleure combinaison
3. QUAND un texte d'ancrage n'est pas trouvé, LE Système Multi-Anchor DOIT continuer avec les textes d'ancrage restants sans échouer
4. QUAND tous les textes d'ancrage échouent, LE Système Multi-Anchor DOIT revenir à une résolution sans ancrage
5. QUAND une ancre réussit, LE Système Multi-Anchor DOIT enregistrer quel texte d'ancrage a été réussi pour l'optimisation future
### Exigence 2
**Histoire Utilisateur :** En tant que développeur de workflow, je veux spécifier des contraintes strictes qui filtrent rigoureusement les candidats, afin que le système ne considère que les éléments dans le bon contexte.
#### Critères d'Acceptation
1. QUAND des contraintes strictes sont spécifiées dans la spécification de cible, LE Système de Contraintes DOIT les appliquer comme filtres stricts avant le scoring
2. QUAND une contrainte "within_container_text" est spécifiée, LE Système de Contraintes DOIT seulement considérer les éléments dans le conteneur identifié
3. QUAND une contrainte "min_area" est spécifiée, LE Système de Contraintes DOIT exclure les éléments plus petits que le seuil
4. QUAND aucun élément ne passe les contraintes strictes, LE Système de Contraintes DOIT retourner aucune correspondance plutôt que de relâcher les contraintes
5. QUAND des contraintes strictes sont appliquées, LE Système de Contraintes DOIT enregistrer quelles contraintes ont filtré combien de candidats
### Exigence 3
**Histoire Utilisateur :** En tant que développeur de workflow, je veux configurer les poids de scoring pour différents critères, afin que le système priorise ce qui compte le plus pour mon cas d'usage.
#### Critères d'Acceptation
1. QUAND des poids de scoring sont spécifiés dans la spécification de cible, LE Système de Scoring DOIT les appliquer pour combiner différents composants de scoring
2. QUAND un poids de proximité est spécifié, LE Système de Scoring DOIT pondérer la distance spatiale de l'ancre en conséquence
3. QUAND un poids d'alignement est spécifié, LE Système de Scoring DOIT pondérer l'alignement spatial (horizontal/vertical) en conséquence
4. QUAND un poids de conteneur est spécifié, LE Système de Scoring DOIT pondérer la préférence de conteneur en conséquence
5. QUAND les poids ne sont pas spécifiés, LE Système de Scoring DOIT utiliser des poids par défaut équilibrés
### Exigence 4
**Histoire Utilisateur :** En tant qu'utilisateur du système, je veux que le système trouve les conteneurs par leurs étiquettes de texte, afin que les contraintes puissent référencer les panneaux et dialogues d'interface par leurs noms visibles.
#### Critères d'Acceptation
1. QUAND un texte de conteneur est spécifié, LE Résolveur de Conteneur DOIT trouver des éléments avec un texte correspondant qui sont des conteneurs
2. QUAND l'élément correspondant est déjà un type de conteneur, LE Résolveur de Conteneur DOIT utiliser sa boîte englobante directement
3. QUAND l'élément correspondant est une étiquette, LE Résolveur de Conteneur DOIT trouver le plus petit conteneur englobant
4. QUAND plusieurs conteneurs correspondent, LE Résolveur de Conteneur DOIT préférer le plus petit conteneur (le plus spécifique)
5. QUAND aucun conteneur n'est trouvé, LE Résolveur de Conteneur DOIT retourner null et enregistrer l'échec
### Exigence 5
**Histoire Utilisateur :** En tant qu'opérateur système, je veux un départage stable quand plusieurs éléments ont des scores identiques, afin que la sélection soit prévisible et reproductible.
#### Critères d'Acceptation
1. QUAND plusieurs candidats ont des scores composites identiques, LE Système de Départage DOIT utiliser la confiance comme critère secondaire
2. QUAND la confiance est aussi identique, LE Système de Départage DOIT utiliser la surface de l'élément comme critère tertiaire
3. QUAND la surface est aussi identique, LE Système de Départage DOIT utiliser l'ID de l'élément comme critère final
4. QUAND le départage est appliqué, LE Système de Départage DOIT enregistrer les critères de départage utilisés
5. QUAND le même état d'interface est traité plusieurs fois, LE Système de Départage DOIT toujours sélectionner le même élément
### Exigence 6
**Histoire Utilisateur :** En tant que développeur de workflow, je veux que le système gère les variantes sémantiques dans les textes d'ancrage, afin que "Username" et "Identifiant" puissent tous deux fonctionner comme ancres.
#### Critères d'Acceptation
1. QUAND plusieurs textes d'ancrage sont fournis, LE Système Sémantique DOIT les traiter comme des alternatives équivalentes
2. QUAND les textes d'ancrage incluent des variantes sémantiques, LE Système Sémantique DOIT trouver des éléments correspondant à n'importe quelle variante
3. QUAND plusieurs variantes correspondent, LE Système Sémantique DOIT préférer les correspondances exactes aux correspondances floues
4. QUAND la correspondance floue est utilisée, LE Système Sémantique DOIT appliquer des seuils de similarité cohérents
5. QUAND la correspondance sémantique réussit, LE Système Sémantique DOIT enregistrer quelle variante a été réussie
### Exigence 7
**Histoire Utilisateur :** En tant qu'administrateur système, je veux un logging complet de la résolution multi-anchor, afin que je puisse déboguer des scénarios de ciblage complexes.
#### Critères d'Acceptation
1. QUAND une résolution multi-anchor est effectuée, LE Système de Logging DOIT enregistrer tous les textes d'ancrage tentés
2. QUAND des contraintes strictes sont appliquées, LE Système de Logging DOIT enregistrer les types de contraintes et les résultats de filtrage
3. QUAND le scoring est effectué, LE Système de Logging DOIT enregistrer les meilleurs candidats avec leurs scores
4. QUAND un départage se produit, LE Système de Logging DOIT enregistrer les critères de départage utilisés
5. QUAND la résolution se termine, LE Système de Logging DOIT fournir une piste d'audit complète dans resolution_details
### Exigence 8
**Histoire Utilisateur :** En tant qu'utilisateur soucieux des performances, je veux que la résolution multi-anchor soit efficace, afin que le ciblage complexe ne ralentisse pas significativement l'exécution du workflow.
#### Critères d'Acceptation
1. QUAND une résolution multi-anchor est effectuée, LE Système de Performance DOIT se terminer en moins de 50ms pour des états d'interface typiques
2. QUAND plusieurs ancres sont évaluées, LE Système de Performance DOIT réutiliser l'analyse des éléments d'interface entre les ancres
3. QUAND une résolution de conteneur est effectuée, LE Système de Performance DOIT mettre en cache les recherches de conteneur dans la même résolution
4. QUAND le scoring est effectué, LE Système de Performance DOIT éviter les calculs redondants
5. QUAND la résolution se termine, LE Système de Performance DOIT enregistrer les métriques de timing pour le monitoring des performances

116
.kiro/specs/multi-anchor-constraints/tasks.md Normal file
View File

@@ -0,0 +1,116 @@
# Plan d'Implémentation - Multi-Anchor Constraints (Fiche #11)
**Auteur :** Dom, Alice Kiro
**Date :** 15 décembre 2024
## Statut: Implémentation Core Complète ✅
L'implémentation principale du système multi-anchor avec contraintes est **complète**. Les fonctionnalités suivantes sont opérationnelles:
- ✅ Multi-anchor resolution avec fallback automatique
- ✅ Hard constraints (within_container_text, min_area)
- ✅ Weighted scoring avec pondérations configurables
- ✅ Tie-breaking stable et déterministe
- ✅ Audit trail complet avec métriques de performance
- ✅ Tests unitaires et property-based tests
## Tâches Restantes
- [ ] 2.3 Écrire un test de propriété pour la résolution de conteneur
- **Propriété 3: Cohérence de la résolution de conteneur**
- **Valide: Exigences 4.1, 4.4**
- Implémenter test property-based pour vérifier que la résolution de conteneur est cohérente
- [ ] 3.3 Écrire un test de propriété pour la strictesse des contraintes
- **Propriété 2: Strictesse des contraintes strictes**
- **Valide: Exigences 2.1, 2.4**
- Implémenter test property-based pour vérifier qu'aucun élément violant les contraintes n'est sélectionné
- [ ] 3.4 Écrire un test de propriété pour le filtrage complet des contraintes
- **Propriété 7: Complétude du filtrage des contraintes**
- **Valide: Exigences 2.2, 2.3**
- Implémenter test property-based pour vérifier que tous les types de contraintes filtrent correctement
- [ ] 4.4 Écrire un test de propriété pour la complétude de l'évaluation multi-anchor
- **Propriété 1: Complétude de l'évaluation multi-anchor**
- **Valide: Exigences 1.1, 1.3**
- Implémenter test property-based pour vérifier que toutes les ancres sont tentées
- [ ] 4.5 Écrire un test de propriété pour la résilience du fallback d'ancrage
- **Propriété 6: Résilience du fallback d'ancrage**
- **Valide: Exigences 1.3, 1.4**
- Implémenter test property-based pour vérifier le fallback quand les ancres échouent
- [ ] 5.3 Écrire un test de propriété pour la monotonicité du scoring pondéré
- **Propriété 4: Monotonicité du scoring pondéré**
- **Valide: Exigences 3.1, 3.2, 3.3, 3.4**
- Implémenter test property-based pour vérifier que les scores respectent la monotonicité
- [ ] 6.3 Écrire un test de propriété pour le déterminisme du tie-breaking
- **Propriété 5: Déterminisme du tie-breaking**
- **Valide: Exigences 5.5**
- Implémenter test property-based pour vérifier la stabilité du tie-breaking
- [ ] 8.1 Implémenter la réutilisation de l'analyse des éléments UI
- Éviter de re-analyser les mêmes éléments entre les ancres
- Réutiliser les calculs de distance et d'alignement
- _Exigences: 8.2, 8.4_
- [ ] 8.2 Implémenter le cache des résolutions de conteneur
- Cacher les résolutions de conteneur dans la même résolution
- Éviter les lookups redondants de conteneur
- _Exigences: 8.3_
- [ ] 8.3 Ajouter les métriques de performance détaillées
- Mesurer les durées de résolution, scoring, contraintes séparément
- Compter les cache hits/misses pour les conteneurs
- _Exigences: 8.5_
- [ ] 8.4 Écrire un test de propriété pour la cohérence de l'optimisation des performances
- **Propriété 9: Cohérence de l'optimisation des performances**
- **Valide: Exigences 8.2, 8.4**
- Implémenter test property-based pour vérifier que les optimisations n'affectent pas la cohérence
- [ ] 10.1 Intégrer avec le système de guérison existant
- S'assurer que les nouvelles fonctionnalités fonctionnent avec les profils de guérison
- Tester l'interaction avec healing_attempt et les seuils relaxés
- _Exigences: Toutes_
- [ ] 10.2 Tests de performance avec des UI states complexes
- Vérifier que la résolution multi-anchor reste sous 50ms
- Mesurer l'impact mémoire des nouvelles fonctionnalités
- _Exigences: 8.1_
- [ ] 10.3 Tests d'intégration de bout en bout
- Scénarios réels avec panels Login/Settings
- Cas complexes avec multiples ancres et contraintes
- _Exigences: Toutes_
- [ ] 11. Point de contrôle final - S'assurer que tous les tests passent
- S'assurer que tous les tests passent, demander à l'utilisateur si des questions se posent.
## Notes d'Implémentation
### Fonctionnalités Complètes ✅
1. **Multi-Anchor System**: La méthode `_evaluate_all_anchor_candidate_combinations` implémente l'évaluation complète de toutes les combinaisons ancre-candidat avec fallback automatique.
2. **Hard Constraints**: La méthode `_apply_hard_constraints` filtre strictement les candidats selon les contraintes `within_container_text` et `min_area`.
3. **Weighted Scoring**: La méthode `_score_candidate_sniper` utilise des pondérations configurables pour proximity, alignment, container, et roi_iou.
4. **Stable Tie-Breaking**: Les méthodes `_create_stable_sort_key` et `_select_best_candidate_with_tiebreak` assurent un départage déterministe.
5. **Container Resolution**: La méthode `_container_bbox_from_text` trouve intelligemment les conteneurs par texte.
6. **Audit Trail**: Les métadonnées complètes sont incluses dans `resolution_details` avec toutes les informations de performance et de débogage.
### Tests Existants ✅
- Tests unitaires complets dans `test_fiche11_multi_anchor_constraints.py`
- Tests property-based partiels (4 propriétés sur 10 implémentées)
- Tests d'intégration avec scénarios réels
### Architecture
Le système s'intègre parfaitement dans l'architecture existante de `TargetResolver` sans casser la compatibilité. Les nouvelles fonctionnalités sont activées via les champs `hard_constraints` et `weights` de `TargetSpec`.