v1.0 - Version stable: multi-PC, détection UI-DETR-1, 3 modes exécution

- Frontend v4 accessible sur réseau local (192.168.1.40)
- Ports ouverts: 3002 (frontend), 5001 (backend), 5004 (dashboard)
- Ollama GPU fonctionnel
- Self-healing interactif
- Dashboard confiance

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

core/healing/models.py

@@ -0,0 +1,120 @@
+"""Data models for self-healing workflows."""
+
+from dataclasses import dataclass, field
+from typing import Optional, Dict, Any
+from datetime import datetime
+
+
+@dataclass
+class RecoveryContext:
+    """Context information for recovery attempts."""
+    original_action: str
+    target_element: str
+    failure_reason: str
+    screenshot_path: str
+    workflow_id: str
+    node_id: str
+    attempt_count: int
+    max_attempts: int = 3
+    confidence_threshold: float = 0.7
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            'original_action': self.original_action,
+            'target_element': self.target_element,
+            'failure_reason': self.failure_reason,
+            'screenshot_path': self.screenshot_path,
+            'workflow_id': self.workflow_id,
+            'node_id': self.node_id,
+            'attempt_count': self.attempt_count,
+            'max_attempts': self.max_attempts,
+            'confidence_threshold': self.confidence_threshold,
+            'metadata': self.metadata
+        }
+
+
+@dataclass
+class RecoveryResult:
+    """Result of a recovery attempt."""
+    success: bool
+    strategy_used: str
+    new_element: Optional[str] = None
+    confidence_score: float = 0.0
+    execution_time: float = 0.0
+    learned_pattern: Optional[Dict] = None
+    requires_user_input: bool = False
+    error_message: Optional[str] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            'success': self.success,
+            'strategy_used': self.strategy_used,
+            'new_element': self.new_element,
+            'confidence_score': self.confidence_score,
+            'execution_time': self.execution_time,
+            'learned_pattern': self.learned_pattern,
+            'requires_user_input': self.requires_user_input,
+            'error_message': self.error_message
+        }
+
+
+@dataclass
+class RecoveryPattern:
+    """A learned recovery pattern."""
+    pattern_id: str
+    original_failure: str
+    recovery_strategy: str
+    success_count: int
+    failure_count: int
+    confidence_score: float
+    context_metadata: Dict[str, Any]
+    created_at: datetime
+    last_used: datetime
+    
+    @property
+    def success_rate(self) -> float:
+        """Calculate success rate."""
+        total = self.success_count + self.failure_count
+        return self.success_count / total if total > 0 else 0.0
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            'pattern_id': self.pattern_id,
+            'original_failure': self.original_failure,
+            'recovery_strategy': self.recovery_strategy,
+            'success_count': self.success_count,
+            'failure_count': self.failure_count,
+            'confidence_score': self.confidence_score,
+            'context_metadata': self.context_metadata,
+            'created_at': self.created_at.isoformat(),
+            'last_used': self.last_used.isoformat()
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'RecoveryPattern':
+        """Create from dictionary."""
+        return cls(
+            pattern_id=data['pattern_id'],
+            original_failure=data['original_failure'],
+            recovery_strategy=data['recovery_strategy'],
+            success_count=data['success_count'],
+            failure_count=data['failure_count'],
+            confidence_score=data['confidence_score'],
+            context_metadata=data['context_metadata'],
+            created_at=datetime.fromisoformat(data['created_at']),
+            last_used=datetime.fromisoformat(data['last_used'])
+        )
+
+
+@dataclass
+class RecoverySuggestion:
+    """A suggested recovery action."""
+    strategy: str
+    confidence: float
+    description: str
+    estimated_time: float
+    metadata: Dict[str, Any] = field(default_factory=dict)