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>

_a_trier/utilitaires/analyze_encrypted_file.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+"""
+Analyze the structure of an encrypted file to understand the padding issue.
+"""
+
+import os
+import sys
+from pathlib import Path
+
+def analyze_encrypted_file():
+    """Analyze the encrypted file structure."""
+    
+    print("=== Analyzing Encrypted File Structure ===")
+    
+    # Load environment
+    env_local_path = Path(".env.local")
+    if env_local_path.exists():
+        with open(env_local_path, 'r') as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith('#') and '=' in line:
+                    key, value = line.split('=', 1)
+                    os.environ[key.strip()] = value.strip()
+    
+    password = os.getenv("ENCRYPTION_PASSWORD")
+    print(f"Password: {password[:16]}..." if password else "No password")
+    
+    # Find encrypted file
+    enc_files = list(Path("agent_v0/sessions").glob("*.enc"))
+    if not enc_files:
+        print("No .enc files found")
+        return False
+    
+    enc_file = enc_files[0]
+    print(f"Analyzing: {enc_file}")
+    print(f"File size: {enc_file.stat().st_size} bytes")
+    
+    # Read file structure
+    with open(enc_file, 'rb') as f:
+        salt = f.read(16)
+        iv = f.read(16)
+        ciphertext = f.read()
+    
+    print(f"Salt: {len(salt)} bytes")
+    print(f"IV: {len(iv)} bytes")
+    print(f"Ciphertext: {len(ciphertext)} bytes")
+    print(f"Ciphertext % 16: {len(ciphertext) % 16}")
+    
+    if len(ciphertext) % 16 != 0:
+        print("Ciphertext length is not a multiple of 16!")
+        return False
+    
+    # Try manual decryption to see where it fails
+    try:
+        from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+        from cryptography.hazmat.backends import default_backend
+        from cryptography.hazmat.primitives import hashes
+        from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+        
+        # Derive key
+        kdf = PBKDF2HMAC(
+            algorithm=hashes.SHA256(),
+            length=32,
+            salt=salt,
+            iterations=100000,
+            backend=default_backend()
+        )
+        key = kdf.derive(password.encode('utf-8'))
+        print("Key derivation successful")
+        
+        # Decrypt
+        cipher = Cipher(
+            algorithms.AES(key),
+            modes.CBC(iv),
+            backend=default_backend()
+        )
+        decryptor = cipher.decryptor()
+        plaintext = decryptor.update(ciphertext) + decryptor.finalize()
+        print(f"Decryption successful, plaintext length: {len(plaintext)}")
+        
+        # Check padding
+        if len(plaintext) == 0:
+            print("Plaintext is empty!")
+            return False
+        
+        padding_length = plaintext[-1]
+        print(f"Last byte (padding length): {padding_length}")
+        
+        if padding_length < 1 or padding_length > 16:
+            print(f"Invalid padding length: {padding_length}")
+            return False
+        
+        # Check padding bytes
+        padding_bytes = plaintext[-padding_length:]
+        print(f"Padding bytes: {[b for b in padding_bytes]}")
+        
+        all_correct = all(b == padding_length for b in padding_bytes)
+        if not all_correct:
+            print("Padding bytes are not all the same!")
+            print(f"Expected all bytes to be {padding_length}")
+            return False
+        
+        print("Padding validation successful")
+        return True
+        
+    except Exception as e:
+        print(f"Manual decryption failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+if __name__ == "__main__":
+    success = analyze_encrypted_file()
+    sys.exit(0 if success else 1)

_a_trier/utilitaires/analyze_failed_matches.py

@@ -0,0 +1,327 @@
+#!/usr/bin/env python3
+"""
+Analyseur des échecs de matching pour amélioration continue du système.
+
+Ce script analyse les rapports d'échecs de matching et génère des statistiques
+et recommandations pour améliorer le graphe de workflow.
+"""
+
+import json
+import sys
+from pathlib import Path
+from datetime import datetime, timedelta
+from typing import List, Dict, Any
+from collections import Counter, defaultdict
+import argparse
+
+
+class FailedMatchAnalyzer:
+    """Analyseur des échecs de matching."""
+    
+    def __init__(self, failed_matches_dir: str = "data/failed_matches"):
+        self.failed_matches_dir = Path(failed_matches_dir)
+        self.reports: List[Dict[str, Any]] = []
+    
+    def load_reports(self, last_n: int = None, since_hours: int = None):
+        """
+        Charger les rapports d'échecs.
+        
+        Args:
+            last_n: Charger les N derniers rapports
+            since_hours: Charger les rapports des X dernières heures
+        """
+        if not self.failed_matches_dir.exists():
+            print(f"⚠️  Aucun dossier d'échecs trouvé: {self.failed_matches_dir}")
+            return
+        
+        # Lister tous les dossiers d'échecs
+        match_dirs = sorted(
+            [d for d in self.failed_matches_dir.iterdir() if d.is_dir()],
+            key=lambda x: x.name,
+            reverse=True
+        )
+        
+        if not match_dirs:
+            print("⚠️  Aucun échec de matching enregistré")
+            return
+        
+        # Filtrer par date si nécessaire
+        if since_hours:
+            cutoff = datetime.now() - timedelta(hours=since_hours)
+            match_dirs = [
+                d for d in match_dirs
+                if self._parse_timestamp(d.name) >= cutoff
+            ]
+        
+        # Limiter le nombre si nécessaire
+        if last_n:
+            match_dirs = match_dirs[:last_n]
+        
+        # Charger les rapports
+        for match_dir in match_dirs:
+            report_path = match_dir / "report.json"
+            if report_path.exists():
+                try:
+                    with open(report_path, 'r') as f:
+                        report = json.load(f)
+                        report['_dir'] = match_dir
+                        self.reports.append(report)
+                except Exception as e:
+                    print(f"⚠️  Erreur lors du chargement de {report_path}: {e}")
+        
+        print(f"✓ {len(self.reports)} rapports chargés")
+    
+    def _parse_timestamp(self, dirname: str) -> datetime:
+        """Parser le timestamp depuis le nom du dossier."""
+        try:
+            # Format: failed_match_20251123_143052
+            timestamp_str = dirname.replace("failed_match_", "")
+            return datetime.strptime(timestamp_str, "%Y%m%d_%H%M%S")
+        except:
+            return datetime.min
+    
+    def analyze(self) -> Dict[str, Any]:
+        """Analyser tous les rapports et générer des statistiques."""
+        if not self.reports:
+            return {}
+        
+        analysis = {
+            'total_failures': len(self.reports),
+            'date_range': self._get_date_range(),
+            'confidence_stats': self._analyze_confidence(),
+            'suggestions_summary': self._analyze_suggestions(),
+            'problematic_nodes': self._identify_problematic_nodes(),
+            'threshold_recommendations': self._recommend_thresholds(),
+            'new_states_detected': self._count_new_states()
+        }
+        
+        return analysis
+    
+    def _get_date_range(self) -> Dict[str, str]:
+        """Obtenir la plage de dates des rapports."""
+        timestamps = [
+            datetime.strptime(r['timestamp'], "%Y%m%d_%H%M%S")
+            for r in self.reports
+        ]
+        return {
+            'first': min(timestamps).strftime("%Y-%m-%d %H:%M:%S"),
+            'last': max(timestamps).strftime("%Y-%m-%d %H:%M:%S")
+        }
+    
+    def _analyze_confidence(self) -> Dict[str, Any]:
+        """Analyser les niveaux de confiance."""
+        confidences = [
+            r['matching_results']['best_confidence']
+            for r in self.reports
+        ]
+        
+        return {
+            'min': min(confidences),
+            'max': max(confidences),
+            'avg': sum(confidences) / len(confidences),
+            'below_70': sum(1 for c in confidences if c < 0.70),
+            'between_70_85': sum(1 for c in confidences if 0.70 <= c < 0.85),
+            'above_85': sum(1 for c in confidences if c >= 0.85)
+        }
+    
+    def _analyze_suggestions(self) -> Dict[str, int]:
+        """Compter les types de suggestions."""
+        suggestion_types = Counter()
+        
+        for report in self.reports:
+            for suggestion in report.get('suggestions', []):
+                # Extraire le type de suggestion (avant le ':')
+                suggestion_type = suggestion.split(':')[0]
+                suggestion_types[suggestion_type] += 1
+        
+        return dict(suggestion_types)
+    
+    def _identify_problematic_nodes(self) -> List[Dict[str, Any]]:
+        """Identifier les nodes qui causent le plus de confusion."""
+        node_near_misses = defaultdict(list)
+        
+        for report in self.reports:
+            similarities = report['matching_results'].get('similarities', [])
+            if similarities:
+                best = similarities[0]
+                confidence = best['similarity']
+                # Near miss: entre 0.70 et threshold
+                if 0.70 <= confidence < report['matching_results']['threshold']:
+                    node_near_misses[best['node_id']].append({
+                        'confidence': confidence,
+                        'label': best['node_label'],
+                        'timestamp': report['timestamp']
+                    })
+        
+        # Trier par nombre de near misses
+        problematic = [
+            {
+                'node_id': node_id,
+                'node_label': misses[0]['label'],
+                'near_miss_count': len(misses),
+                'avg_confidence': sum(m['confidence'] for m in misses) / len(misses)
+            }
+            for node_id, misses in node_near_misses.items()
+        ]
+        
+        return sorted(problematic, key=lambda x: x['near_miss_count'], reverse=True)
+    
+    def _recommend_thresholds(self) -> Dict[str, Any]:
+        """Recommander des ajustements de seuil."""
+        confidences = [
+            r['matching_results']['best_confidence']
+            for r in self.reports
+        ]
+        
+        # Calculer le percentile 90 des confidences
+        sorted_conf = sorted(confidences)
+        p90_index = int(len(sorted_conf) * 0.9)
+        p90 = sorted_conf[p90_index] if sorted_conf else 0.85
+        
+        current_threshold = self.reports[0]['matching_results']['threshold']
+        
+        recommendations = {
+            'current_threshold': current_threshold,
+            'p90_confidence': p90,
+            'recommended_threshold': max(0.70, min(0.90, p90 - 0.02))
+        }
+        
+        if p90 < current_threshold - 0.05:
+            recommendations['action'] = "LOWER_THRESHOLD"
+            recommendations['reason'] = f"90% des échecs ont une confiance < {p90:.3f}"
+        elif p90 > current_threshold + 0.05:
+            recommendations['action'] = "RAISE_THRESHOLD"
+            recommendations['reason'] = "Beaucoup de faux positifs potentiels"
+        else:
+            recommendations['action'] = "KEEP_CURRENT"
+            recommendations['reason'] = "Seuil approprié"
+        
+        return recommendations
+    
+    def _count_new_states(self) -> int:
+        """Compter les nouveaux états détectés (confiance < 0.70)."""
+        return sum(
+            1 for r in self.reports
+            if r['matching_results']['best_confidence'] < 0.70
+        )
+    
+    def print_report(self, analysis: Dict[str, Any]):
+        """Afficher le rapport d'analyse."""
+        print("\n" + "="*70)
+        print("RAPPORT D'ANALYSE DES ÉCHECS DE MATCHING")
+        print("="*70)
+        
+        print(f"\n📊 Statistiques Générales")
+        print(f"  • Total d'échecs: {analysis['total_failures']}")
+        print(f"  • Période: {analysis['date_range']['first']} → {analysis['date_range']['last']}")
+        
+        print(f"\n📈 Niveaux de Confiance")
+        conf = analysis['confidence_stats']
+        print(f"  • Minimum: {conf['min']:.3f}")
+        print(f"  • Maximum: {conf['max']:.3f}")
+        print(f"  • Moyenne: {conf['avg']:.3f}")
+        print(f"  • < 0.70 (nouveaux états): {conf['below_70']}")
+        print(f"  • 0.70-0.85 (near miss): {conf['between_70_85']}")
+        print(f"  • > 0.85 (faux négatifs): {conf['above_85']}")
+        
+        print(f"\n💡 Suggestions Générées")
+        for suggestion_type, count in analysis['suggestions_summary'].items():
+            print(f"  • {suggestion_type}: {count}")
+        
+        print(f"\n⚠️  Nodes Problématiques (Top 5)")
+        for i, node in enumerate(analysis['problematic_nodes'][:5], 1):
+            print(f"  {i}. {node['node_label']} (ID: {node['node_id']})")
+            print(f"     - Near misses: {node['near_miss_count']}")
+            print(f"     - Confiance moyenne: {node['avg_confidence']:.3f}")
+        
+        print(f"\n🎯 Recommandations de Seuil")
+        thresh = analysis['threshold_recommendations']
+        print(f"  • Seuil actuel: {thresh['current_threshold']:.3f}")
+        print(f"  • P90 des confidences: {thresh['p90_confidence']:.3f}")
+        print(f"  • Seuil recommandé: {thresh['recommended_threshold']:.3f}")
+        print(f"  • Action: {thresh['action']}")
+        print(f"  • Raison: {thresh['reason']}")
+        
+        print(f"\n🆕 Nouveaux États Détectés")
+        print(f"  • {analysis['new_states_detected']} états potentiellement nouveaux")
+        print(f"    (confiance < 0.70, nécessitent création de nodes)")
+        
+        print("\n" + "="*70)
+    
+    def export_detailed_report(self, output_path: str = "failed_matches_analysis.json"):
+        """Exporter un rapport détaillé en JSON."""
+        analysis = self.analyze()
+        
+        detailed_report = {
+            'analysis': analysis,
+            'individual_reports': [
+                {
+                    'timestamp': r['timestamp'],
+                    'confidence': r['matching_results']['best_confidence'],
+                    'suggestions': r['suggestions'],
+                    'window_title': r['state']['window_title'],
+                    'screenshot_path': str(r['_dir'] / "screenshot.png")
+                }
+                for r in self.reports
+            ]
+        }
+        
+        with open(output_path, 'w') as f:
+            json.dump(detailed_report, f, indent=2)
+        
+        print(f"\n✓ Rapport détaillé exporté: {output_path}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Analyser les échecs de matching pour amélioration continue"
+    )
+    parser.add_argument(
+        '--last',
+        type=int,
+        help="Analyser les N derniers échecs"
+    )
+    parser.add_argument(
+        '--since-hours',
+        type=int,
+        help="Analyser les échecs des X dernières heures"
+    )
+    parser.add_argument(
+        '--export',
+        type=str,
+        help="Exporter le rapport détaillé en JSON"
+    )
+    parser.add_argument(
+        '--dir',
+        type=str,
+        default="data/failed_matches",
+        help="Dossier contenant les échecs (défaut: data/failed_matches)"
+    )
+    
+    args = parser.parse_args()
+    
+    # Créer l'analyseur
+    analyzer = FailedMatchAnalyzer(failed_matches_dir=args.dir)
+    
+    # Charger les rapports
+    analyzer.load_reports(last_n=args.last, since_hours=args.since_hours)
+    
+    if not analyzer.reports:
+        print("\n❌ Aucun rapport à analyser")
+        return 1
+    
+    # Analyser
+    analysis = analyzer.analyze()
+    
+    # Afficher le rapport
+    analyzer.print_report(analysis)
+    
+    # Exporter si demandé
+    if args.export:
+        analyzer.export_detailed_report(args.export)
+    
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

_a_trier/utilitaires/auto_improve_matching.py

@@ -0,0 +1,355 @@
+#!/usr/bin/env python3
+"""
+Script d'amélioration automatique du système de matching.
+
+Analyse les échecs et propose/applique des améliorations automatiques:
+- Mise à jour des prototypes de nodes
+- Ajustement des seuils
+- Création de nouveaux nodes
+"""
+
+import json
+import sys
+import shutil
+from pathlib import Path
+from datetime import datetime
+from typing import List, Dict, Any, Optional
+import numpy as np
+import argparse
+
+
+class MatchingAutoImprover:
+    """Amélioration automatique du système de matching."""
+    
+    def __init__(
+        self,
+        failed_matches_dir: str = "data/failed_matches",
+        workflows_dir: str = "data/workflows",
+        dry_run: bool = True
+    ):
+        self.failed_matches_dir = Path(failed_matches_dir)
+        self.workflows_dir = Path(workflows_dir)
+        self.dry_run = dry_run
+        self.improvements = []
+    
+    def analyze_and_improve(self, min_confidence: float = 0.75) -> List[Dict[str, Any]]:
+        """
+        Analyser les échecs et générer des améliorations.
+        
+        Args:
+            min_confidence: Seuil minimum pour considérer une mise à jour
+        """
+        print("\n🔍 Analyse des échecs de matching...")
+        
+        # Charger tous les rapports
+        reports = self._load_all_reports()
+        
+        if not reports:
+            print("⚠️  Aucun échec à analyser")
+            return []
+        
+        print(f"✓ {len(reports)} rapports chargés")
+        
+        # Identifier les améliorations possibles
+        self.improvements = []
+        
+        # 1. Nodes à mettre à jour (near misses)
+        self._identify_prototype_updates(reports, min_confidence)
+        
+        # 2. Nouveaux nodes à créer
+        self._identify_new_nodes(reports)
+        
+        # 3. Ajustements de seuil
+        self._identify_threshold_adjustments(reports)
+        
+        return self.improvements
+    
+    def _load_all_reports(self) -> List[Dict[str, Any]]:
+        """Charger tous les rapports d'échecs."""
+        if not self.failed_matches_dir.exists():
+            return []
+        
+        reports = []
+        for match_dir in self.failed_matches_dir.iterdir():
+            if not match_dir.is_dir():
+                continue
+            
+            report_path = match_dir / "report.json"
+            if report_path.exists():
+                try:
+                    with open(report_path, 'r') as f:
+                        report = json.load(f)
+                        report['_dir'] = match_dir
+                        reports.append(report)
+                except:
+                    continue
+        
+        return reports
+    
+    def _identify_prototype_updates(self, reports: List[Dict], min_confidence: float):
+        """Identifier les prototypes à mettre à jour."""
+        # Grouper par node_id les near misses
+        node_near_misses = {}
+        
+        for report in reports:
+            similarities = report['matching_results'].get('similarities', [])
+            if not similarities:
+                continue
+            
+            best = similarities[0]
+            confidence = best['similarity']
+            
+            # Near miss: entre min_confidence et threshold
+            threshold = report['matching_results']['threshold']
+            if min_confidence <= confidence < threshold:
+                node_id = best['node_id']
+                if node_id not in node_near_misses:
+                    node_near_misses[node_id] = []
+                
+                node_near_misses[node_id].append({
+                    'report': report,
+                    'confidence': confidence,
+                    'embedding_path': report['_dir'] / "state_embedding.npy"
+                })
+        
+        # Proposer des mises à jour pour les nodes avec plusieurs near misses
+        for node_id, misses in node_near_misses.items():
+            if len(misses) >= 3:  # Au moins 3 near misses
+                self.improvements.append({
+                    'type': 'UPDATE_PROTOTYPE',
+                    'node_id': node_id,
+                    'node_label': misses[0]['report']['matching_results']['similarities'][0]['node_label'],
+                    'near_miss_count': len(misses),
+                    'avg_confidence': sum(m['confidence'] for m in misses) / len(misses),
+                    'embeddings': [m['embedding_path'] for m in misses]
+                })
+    
+    def _identify_new_nodes(self, reports: List[Dict]):
+        """Identifier les nouveaux nodes à créer."""
+        # Grouper les états très différents (confidence < 0.70)
+        new_states = []
+        
+        for report in reports:
+            confidence = report['matching_results']['best_confidence']
+            if confidence < 0.70:
+                new_states.append({
+                    'report': report,
+                    'confidence': confidence,
+                    'screenshot': report['_dir'] / "screenshot.png",
+                    'embedding': report['_dir'] / "state_embedding.npy",
+                    'window_title': report['state']['window_title']
+                })
+        
+        if new_states:
+            # Grouper par fenêtre
+            by_window = {}
+            for state in new_states:
+                window = state['window_title'] or 'unknown'
+                if window not in by_window:
+                    by_window[window] = []
+                by_window[window].append(state)
+            
+            # Proposer création de nodes
+            for window, states in by_window.items():
+                if len(states) >= 2:  # Au moins 2 occurrences
+                    self.improvements.append({
+                        'type': 'CREATE_NODE',
+                        'window_title': window,
+                        'occurrence_count': len(states),
+                        'avg_confidence': sum(s['confidence'] for s in states) / len(states),
+                        'screenshots': [s['screenshot'] for s in states],
+                        'embeddings': [s['embedding'] for s in states]
+                    })
+    
+    def _identify_threshold_adjustments(self, reports: List[Dict]):
+        """Identifier les ajustements de seuil nécessaires."""
+        confidences = [r['matching_results']['best_confidence'] for r in reports]
+        
+        if not confidences:
+            return
+        
+        # Calculer statistiques
+        sorted_conf = sorted(confidences)
+        p90 = sorted_conf[int(len(sorted_conf) * 0.9)]
+        current_threshold = reports[0]['matching_results']['threshold']
+        
+        # Si beaucoup d'échecs ont une confiance proche du seuil
+        near_threshold = sum(1 for c in confidences if current_threshold - 0.05 <= c < current_threshold)
+        
+        if near_threshold > len(confidences) * 0.3:  # Plus de 30%
+            recommended = max(0.70, p90 - 0.02)
+            self.improvements.append({
+                'type': 'ADJUST_THRESHOLD',
+                'current_threshold': current_threshold,
+                'recommended_threshold': recommended,
+                'reason': f"{near_threshold} échecs proches du seuil ({near_threshold/len(confidences)*100:.1f}%)",
+                'p90_confidence': p90
+            })
+    
+    def apply_improvements(self, improvements: List[Dict[str, Any]] = None):
+        """Appliquer les améliorations identifiées."""
+        if improvements is None:
+            improvements = self.improvements
+        
+        if not improvements:
+            print("\n⚠️  Aucune amélioration à appliquer")
+            return
+        
+        print(f"\n{'🔧 SIMULATION' if self.dry_run else '🔧 APPLICATION'} DES AMÉLIORATIONS")
+        print("="*70)
+        
+        for i, improvement in enumerate(improvements, 1):
+            print(f"\n{i}. {improvement['type']}")
+            
+            if improvement['type'] == 'UPDATE_PROTOTYPE':
+                self._apply_prototype_update(improvement)
+            
+            elif improvement['type'] == 'CREATE_NODE':
+                self._apply_node_creation(improvement)
+            
+            elif improvement['type'] == 'ADJUST_THRESHOLD':
+                self._apply_threshold_adjustment(improvement)
+        
+        if self.dry_run:
+            print("\n💡 Mode simulation - Aucune modification appliquée")
+            print("   Relancez avec --apply pour appliquer les changements")
+    
+    def _apply_prototype_update(self, improvement: Dict):
+        """Appliquer une mise à jour de prototype."""
+        print(f"   Node: {improvement['node_label']} (ID: {improvement['node_id']})")
+        print(f"   Near misses: {improvement['near_miss_count']}")
+        print(f"   Confiance moyenne: {improvement['avg_confidence']:.3f}")
+        
+        if not self.dry_run:
+            # Charger tous les embeddings
+            embeddings = []
+            for emb_path in improvement['embeddings']:
+                if Path(emb_path).exists():
+                    embeddings.append(np.load(emb_path))
+            
+            if embeddings:
+                # Calculer le nouveau prototype (moyenne)
+                new_prototype = np.mean(embeddings, axis=0)
+                
+                # Sauvegarder (à adapter selon votre structure)
+                prototype_path = self.workflows_dir / f"node_{improvement['node_id']}_prototype.npy"
+                np.save(prototype_path, new_prototype)
+                print(f"   ✓ Prototype mis à jour: {prototype_path}")
+        else:
+            print(f"   → Mettrait à jour le prototype avec {len(improvement['embeddings'])} embeddings")
+    
+    def _apply_node_creation(self, improvement: Dict):
+        """Appliquer une création de node."""
+        print(f"   Fenêtre: {improvement['window_title']}")
+        print(f"   Occurrences: {improvement['occurrence_count']}")
+        print(f"   Confiance moyenne: {improvement['avg_confidence']:.3f}")
+        
+        if not self.dry_run:
+            # Créer un nouveau node (à adapter selon votre structure)
+            node_id = f"node_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+            node_dir = self.workflows_dir / node_id
+            node_dir.mkdir(parents=True, exist_ok=True)
+            
+            # Copier les screenshots
+            for i, screenshot in enumerate(improvement['screenshots']):
+                if Path(screenshot).exists():
+                    shutil.copy(screenshot, node_dir / f"example_{i}.png")
+            
+            # Calculer et sauvegarder le prototype
+            embeddings = []
+            for emb_path in improvement['embeddings']:
+                if Path(emb_path).exists():
+                    embeddings.append(np.load(emb_path))
+            
+            if embeddings:
+                prototype = np.mean(embeddings, axis=0)
+                np.save(node_dir / "prototype.npy", prototype)
+            
+            print(f"   ✓ Node créé: {node_dir}")
+        else:
+            print(f"   → Créerait un nouveau node avec {improvement['occurrence_count']} exemples")
+    
+    def _apply_threshold_adjustment(self, improvement: Dict):
+        """Appliquer un ajustement de seuil."""
+        print(f"   Seuil actuel: {improvement['current_threshold']:.3f}")
+        print(f"   Seuil recommandé: {improvement['recommended_threshold']:.3f}")
+        print(f"   Raison: {improvement['reason']}")
+        
+        if not self.dry_run:
+            # Mettre à jour la configuration (à adapter)
+            config_path = Path("config/matching_config.json")
+            if config_path.exists():
+                with open(config_path, 'r') as f:
+                    config = json.load(f)
+                
+                config['similarity_threshold'] = improvement['recommended_threshold']
+                
+                with open(config_path, 'w') as f:
+                    json.dump(config, f, indent=2)
+                
+                print(f"   ✓ Configuration mise à jour: {config_path}")
+        else:
+            print(f"   → Mettrait à jour le seuil dans la configuration")
+    
+    def print_summary(self):
+        """Afficher un résumé des améliorations."""
+        print("\n" + "="*70)
+        print("RÉSUMÉ DES AMÉLIORATIONS PROPOSÉES")
+        print("="*70)
+        
+        by_type = {}
+        for imp in self.improvements:
+            imp_type = imp['type']
+            if imp_type not in by_type:
+                by_type[imp_type] = []
+            by_type[imp_type].append(imp)
+        
+        for imp_type, imps in by_type.items():
+            print(f"\n{imp_type}: {len(imps)}")
+            for imp in imps:
+                if imp_type == 'UPDATE_PROTOTYPE':
+                    print(f"  • {imp['node_label']}: {imp['near_miss_count']} near misses")
+                elif imp_type == 'CREATE_NODE':
+                    print(f"  • {imp['window_title']}: {imp['occurrence_count']} occurrences")
+                elif imp_type == 'ADJUST_THRESHOLD':
+                    print(f"  • {imp['current_threshold']:.3f} → {imp['recommended_threshold']:.3f}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Amélioration automatique du système de matching"
+    )
+    parser.add_argument(
+        '--apply',
+        action='store_true',
+        help="Appliquer les améliorations (sinon mode simulation)"
+    )
+    parser.add_argument(
+        '--min-confidence',
+        type=float,
+        default=0.75,
+        help="Confiance minimum pour mise à jour (défaut: 0.75)"
+    )
+    
+    args = parser.parse_args()
+    
+    improver = MatchingAutoImprover(dry_run=not args.apply)
+    
+    # Analyser
+    improvements = improver.analyze_and_improve(min_confidence=args.min_confidence)
+    
+    if not improvements:
+        print("\n✅ Aucune amélioration nécessaire")
+        return 0
+    
+    # Afficher le résumé
+    improver.print_summary()
+    
+    # Appliquer
+    improver.apply_improvements()
+    
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

_a_trier/utilitaires/check_dashboard_port.sh

@@ -0,0 +1,115 @@
+#!/bin/bash
+#
+# Script de vérification du port pour le dashboard RPA Vision V3
+# Vérifie si le port 5001 est disponible et propose des alternatives
+#
+
+set -e
+
+# Couleurs
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+NC='\033[0m'
+
+echo "╔══════════════════════════════════════════════════════════════╗"
+echo "║     VÉRIFICATION DES PORTS - DASHBOARD RPA VISION V3        ║"
+echo "╚══════════════════════════════════════════════════════════════╝"
+echo ""
+
+# Port par défaut
+DEFAULT_PORT=5001
+
+# Fonction pour vérifier si un port est utilisé
+check_port() {
+    local port=$1
+    if ss -tuln | grep -q ":${port} "; then
+        return 1  # Port occupé
+    else
+        return 0  # Port libre
+    fi
+}
+
+# Fonction pour trouver le processus utilisant un port
+get_process_on_port() {
+    local port=$1
+    lsof -i :${port} 2>/dev/null | grep LISTEN | awk '{print $2}' | head -1
+}
+
+# Vérifier le port par défaut (5001)
+echo -e "${YELLOW}[1/3]${NC} Vérification du port ${DEFAULT_PORT}..."
+if check_port ${DEFAULT_PORT}; then
+    echo -e "${GREEN}✓${NC} Port ${DEFAULT_PORT} disponible"
+    PORT_STATUS="available"
+else
+    echo -e "${RED}✗${NC} Port ${DEFAULT_PORT} occupé"
+    PID=$(get_process_on_port ${DEFAULT_PORT})
+    if [ -n "$PID" ]; then
+        PROCESS=$(ps -p $PID -o comm= 2>/dev/null || echo "inconnu")
+        echo -e "  Processus: ${PROCESS} (PID: ${PID})"
+        echo -e "  Commande: ${YELLOW}kill ${PID}${NC} pour libérer le port"
+    fi
+    PORT_STATUS="occupied"
+fi
+
+# Vérifier les ports alternatifs
+echo ""
+echo -e "${YELLOW}[2/3]${NC} Vérification des ports alternatifs..."
+
+ALTERNATIVE_PORTS=(5000 3000 8000 8080 8888 9000)
+AVAILABLE_PORTS=()
+
+for port in "${ALTERNATIVE_PORTS[@]}"; do
+    if check_port $port; then
+        echo -e "${GREEN}✓${NC} Port ${port} disponible"
+        AVAILABLE_PORTS+=($port)
+    else
+        echo -e "${RED}✗${NC} Port ${port} occupé"
+    fi
+done
+
+# Résumé et recommandations
+echo ""
+echo -e "${YELLOW}[3/3]${NC} Résumé et recommandations..."
+echo ""
+
+if [ "$PORT_STATUS" = "available" ]; then
+    echo -e "${GREEN}✅ PRÊT${NC} - Le port par défaut (${DEFAULT_PORT}) est disponible"
+    echo ""
+    echo "Lancement du dashboard:"
+    echo -e "  ${GREEN}cd rpa_vision_v3${NC}"
+    echo -e "  ${GREEN}./run.sh --dashboard${NC}"
+    echo ""
+    echo "Accès: http://localhost:${DEFAULT_PORT}"
+else
+    echo -e "${YELLOW}⚠️  ATTENTION${NC} - Le port ${DEFAULT_PORT} est occupé"
+    echo ""
+    
+    if [ ${#AVAILABLE_PORTS[@]} -gt 0 ]; then
+        echo "Ports alternatifs disponibles:"
+        for port in "${AVAILABLE_PORTS[@]}"; do
+            echo -e "  • Port ${port}: ${GREEN}disponible${NC}"
+        done
+        echo ""
+        echo "Pour utiliser un port alternatif:"
+        echo -e "  ${YELLOW}export FLASK_PORT=${AVAILABLE_PORTS[0]}${NC}"
+        echo -e "  ${YELLOW}cd rpa_vision_v3${NC}"
+        echo -e "  ${YELLOW}./run.sh --dashboard${NC}"
+        echo ""
+        echo "Ou modifier web_dashboard/app.py ligne 165:"
+        echo -e "  ${YELLOW}app.run(debug=True, host='0.0.0.0', port=${AVAILABLE_PORTS[0]})${NC}"
+    else
+        echo -e "${RED}❌ PROBLÈME${NC} - Aucun port web standard n'est disponible"
+        echo ""
+        echo "Actions recommandées:"
+        echo "  1. Arrêter les serveurs web inutilisés"
+        echo "  2. Vérifier les processus: ps aux | grep python"
+        echo "  3. Libérer le port 5001: kill \$(lsof -t -i:5001)"
+    fi
+fi
+
+echo ""
+echo "╔══════════════════════════════════════════════════════════════╗"
+echo "║                    VÉRIFICATION TERMINÉE                     ║"
+echo "╚══════════════════════════════════════════════════════════════╝"
+

_a_trier/utilitaires/check_flask.sh

@@ -0,0 +1,74 @@
+#!/bin/bash
+
+echo "═══════════════════════════════════════════════════════════════"
+echo "  🔍 Flask Installation Check"
+echo "═══════════════════════════════════════════════════════════════"
+echo ""
+
+# Check if venv is activated
+if [[ "$VIRTUAL_ENV" == *"venv_v3"* ]]; then
+    echo "✅ venv_v3 is activated"
+    echo "   Path: $VIRTUAL_ENV"
+else
+    echo "⚠️  venv_v3 is NOT activated"
+    echo "   Activating now..."
+    source venv_v3/bin/activate
+fi
+
+echo ""
+echo "Checking Flask installation..."
+echo ""
+
+# Check Flask
+if python3 -c "import flask" 2>/dev/null; then
+    VERSION=$(python3 -c "import importlib.metadata; print(importlib.metadata.version('flask'))" 2>/dev/null)
+    echo "✅ Flask installed: version $VERSION"
+else
+    echo "❌ Flask NOT installed"
+    echo "   Run: pip install Flask>=3.0.0"
+    exit 1
+fi
+
+# Check Flask-SocketIO
+if python3 -c "import flask_socketio" 2>/dev/null; then
+    VERSION=$(python3 -c "import importlib.metadata; print(importlib.metadata.version('flask-socketio'))" 2>/dev/null)
+    echo "✅ Flask-SocketIO installed: version $VERSION"
+else
+    echo "❌ Flask-SocketIO NOT installed"
+    echo "   Run: pip install Flask-SocketIO>=5.3.0"
+    exit 1
+fi
+
+echo ""
+echo "═══════════════════════════════════════════════════════════════"
+echo "  Flask Components in Project"
+echo "═══════════════════════════════════════════════════════════════"
+echo ""
+
+# List Flask components
+echo "📁 Flask-based components:"
+echo "   1. web_dashboard/app.py (port 5001)"
+echo "   2. command_interface/app.py (port 5002)"
+echo "   3. server/api_core.py (port 8000)"
+echo "   4. core/analytics/api/analytics_api.py (port 5000)"
+
+echo ""
+echo "═══════════════════════════════════════════════════════════════"
+echo "  Quick Start Commands"
+echo "═══════════════════════════════════════════════════════════════"
+echo ""
+echo "# Activate venv (if not already active)"
+echo "source venv_v3/bin/activate"
+echo ""
+echo "# Launch dashboard"
+echo "python3 web_dashboard/app.py"
+echo ""
+echo "# Launch command interface"
+echo "python3 command_interface/app.py"
+echo ""
+echo "# Launch analytics API"
+echo "python3 test_analytics_server.py"
+echo ""
+echo "═══════════════════════════════════════════════════════════════"
+echo "✅ Flask is ready to use!"
+echo "═══════════════════════════════════════════════════════════════"

_a_trier/utilitaires/check_status.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+# Script de vérification du statut après correction des tokens
+
+echo "🔍 RPA Vision V3 - Vérification Post-Correction"
+echo "==============================================="
+echo ""
+
+echo "📊 1. STATUT DES SERVICES"
+echo "------------------------"
+for service in rpa-vision-v3-api rpa-vision-v3-worker rpa-vision-v3-dashboard; do
+    status=$(systemctl is-active $service)
+    if [ "$status" = "active" ]; then
+        echo "✅ $service: $status"
+    else
+        echo "❌ $service: $status"
+    fi
+done
+echo ""
+
+echo "📋 2. LOGS RÉCENTS API (dernières 20 lignes)"
+echo "--------------------------------------------"
+sudo journalctl -u rpa-vision-v3-api -n 20 --no-pager | grep -E "(TokenManager|token|Bearer|Upload)" || echo "Aucune ligne pertinente trouvée"
+echo ""
+
+echo "🔑 3. TOKENS CONFIGURÉS (tronqués)"
+echo "----------------------------------"
+sudo cat /etc/rpa_vision_v3/rpa_vision_v3.env | grep RPA_TOKEN | while read line; do
+    key=$(echo $line | cut -d'=' -f1)
+    value=$(echo $line | cut -d'=' -f2)
+    echo "$key=${value:0:16}..."
+done
+echo ""
+
+echo "📂 4. SESSIONS RÉCENTES (5 dernières)"
+echo "-------------------------------------"
+ls -lht /opt/rpa_vision_v3/data/training/sessions/*.json 2>/dev/null | head -5 || echo "Aucune session trouvée"
+echo ""
+
+echo "🌐 5. TEST API (endpoint /api/traces/status)"
+echo "--------------------------------------------"
+curl -s http://localhost:8000/api/traces/status 2>/dev/null | python3 -m json.tool 2>/dev/null || echo "API non accessible"
+echo ""
+
+echo "✅ Vérification terminée"

_a_trier/utilitaires/check_visual_rpa_progress.py

@@ -0,0 +1,268 @@
+#!/usr/bin/env python3
+"""
+Script de vérification du progrès RPA 100% Visuel
+
+Vérifie l'état d'avancement de l'implémentation du système RPA 100% visuel.
+Tâche 15: Checkpoint Final - Validation complète du système
+"""
+
+import os
+from pathlib import Path
+import json
+
+def check_visual_rpa_progress():
+    """Vérifie le progrès de l'implémentation RPA 100% visuel - Checkpoint Final"""
+    
+    project_root = Path(__file__).parent
+    
+    print("🏁 CHECKPOINT FINAL - Système RPA 100% Visuel")
+    print("=" * 60)
+    
+    # 1. Vérifier les composants Core
+    print("\n📦 Composants Core (core/visual/):")
+    core_visual_path = project_root / "core" / "visual"
+    
+    core_files = [
+        "visual_target_manager.py",
+        "visual_embedding_manager.py", 
+        "screenshot_validation_manager.py",
+        "contextual_capture_service.py",
+        "realtime_validation_service.py",
+        "visual_persistence_manager.py",
+        "visual_performance_optimizer.py",
+        "rpa_integration_manager.py",
+        "workflow_migration_tool.py",
+        "__init__.py"
+    ]
+    
+    core_count = 0
+    for file_name in core_files:
+        file_path = core_visual_path / file_name
+        exists = file_path.exists()
+        size = file_path.stat().st_size if exists else 0
+        status = "✅" if exists and size > 0 else "❌"
+        print(f"  {status} {file_name} ({size} bytes)")
+        if exists and size > 0:
+            core_count += 1
+    
+    print(f"  📊 Core: {core_count}/{len(core_files)} ({core_count/len(core_files)*100:.1f}%)")
+    
+    # 2. Vérifier les composants Frontend
+    print("\n🎨 Composants Frontend (visual_workflow_builder/frontend/src/components/):")
+    frontend_path = project_root / "visual_workflow_builder" / "frontend" / "src" / "components"
+    
+    frontend_components = [
+        "VisualPropertiesPanel",
+        "VisualScreenSelector", 
+        "InteractivePreviewArea",
+        "VisualMetadataDisplay"
+    ]
+    
+    frontend_count = 0
+    for component_name in frontend_components:
+        component_path = frontend_path / component_name
+        index_file = component_path / "index.tsx"
+        exists = index_file.exists()
+        size = index_file.stat().st_size if exists else 0
+        status = "✅" if exists and size > 0 else "❌"
+        print(f"  {status} {component_name}/index.tsx ({size} bytes)")
+        if exists and size > 0:
+            frontend_count += 1
+    
+    print(f"  📊 Frontend: {frontend_count}/{len(frontend_components)} ({frontend_count/len(frontend_components)*100:.1f}%)")
+    
+    # 3. Vérifier les tests de propriété
+    print("\n🧪 Tests de Propriété (tests/property/):")
+    tests_path = project_root / "tests" / "property"
+    
+    property_tests = [
+        "test_visual_target_manager_properties.py",
+        "test_visual_embedding_manager_properties.py",
+        "test_visual_capture_properties.py",
+        "test_visual_screen_selector_properties.py",
+        "test_visual_properties_panel_properties.py",
+        "test_interactive_preview_area_properties.py",
+        "test_realtime_validation_properties.py"
+    ]
+    
+    tests_count = 0
+    for test_file in property_tests:
+        test_path = tests_path / test_file
+        exists = test_path.exists()
+        size = test_path.stat().st_size if exists else 0
+        status = "✅" if exists and size > 0 else "❌"
+        print(f"  {status} {test_file} ({size} bytes)")
+        if exists and size > 0:
+            tests_count += 1
+    
+    print(f"  📊 Tests: {tests_count}/{len(property_tests)} ({tests_count/len(property_tests)*100:.1f}%)")
+    
+    # 4. Vérifier les tests d'intégration
+    print("\n🔗 Tests d'Intégration:")
+    integration_test = project_root / "tests" / "integration" / "test_visual_rpa_checkpoint.py"
+    integration_exists = integration_test.exists()
+    integration_size = integration_test.stat().st_size if integration_exists else 0
+    integration_status = "✅" if integration_exists and integration_size > 0 else "❌"
+    print(f"  {integration_status} test_visual_rpa_checkpoint.py ({integration_size} bytes)")
+    
+    # 5. Vérifier les services et types
+    print("\n🔧 Services et Types:")
+    
+    # Service de capture
+    service_file = project_root / "visual_workflow_builder" / "frontend" / "src" / "services" / "VisualCaptureService.ts"
+    service_exists = service_file.exists()
+    service_size = service_file.stat().st_size if service_exists else 0
+    service_status = "✅" if service_exists and service_size > 0 else "❌"
+    print(f"  {service_status} VisualCaptureService.ts ({service_size} bytes)")
+    
+    # Types TypeScript
+    types_file = project_root / "visual_workflow_builder" / "frontend" / "src" / "types" / "workflow.ts"
+    types_exists = types_file.exists()
+    types_size = types_file.stat().st_size if types_exists else 0
+    types_status = "✅" if types_exists and types_size > 0 else "❌"
+    print(f"  {types_status} workflow.ts ({types_size} bytes)")
+    
+    # 6. Vérifier les styles CSS
+    print("\n🎨 Styles CSS (Design System Conforme):")
+    css_files = [
+        "visual_workflow_builder/frontend/src/components/VisualPropertiesPanel/VisualPropertiesPanel.css",
+        "visual_workflow_builder/frontend/src/components/VisualMetadataDisplay/VisualMetadataDisplay.css",
+        "visual_workflow_builder/frontend/src/components/VisualScreenSelector/VisualScreenSelector.css",
+        "visual_workflow_builder/frontend/src/components/InteractivePreviewArea/InteractivePreviewArea.css"
+    ]
+    
+    css_count = 0
+    for css_file in css_files:
+        css_path = project_root / css_file
+        exists = css_path.exists()
+        size = css_path.stat().st_size if exists else 0
+        status = "✅" if exists and size > 0 else "❌"
+        component_name = css_file.split('/')[-1]
+        print(f"  {status} {component_name} ({size} bytes)")
+        if exists and size > 0:
+            css_count += 1
+    
+    print(f"  📊 CSS: {css_count}/{len(css_files)} ({css_count/len(css_files)*100:.1f}%)")
+    
+    # 7. Calculer le progrès global final
+    print("\n📈 Progrès Global Final:")
+    total_components = (len(core_files) + len(frontend_components) + len(property_tests) + 
+                       1 + 2 + len(css_files))  # +1 integration test, +2 service+types
+    completed_components = (core_count + frontend_count + tests_count + 
+                          (1 if integration_exists and integration_size > 0 else 0) +
+                          (1 if service_exists and service_size > 0 else 0) +
+                          (1 if types_exists and types_size > 0 else 0) +
+                          css_count)
+    
+    completion_rate = (completed_components / total_components) * 100
+    
+    print(f"  🎯 Taux de completion: {completed_components}/{total_components} ({completion_rate:.1f}%)")
+    
+    # 8. Évaluation des 27 propriétés de correction
+    print("\n🏆 Propriétés de Correction (27 propriétés):")
+    
+    # Propriétés implémentées (basé sur les composants créés)
+    implemented_properties = {
+        1: "Élimination Complète des Sélecteurs Techniques",
+        2: "Sélection Visuelle Pure", 
+        3: "Affichage de Captures Haute Qualité",
+        9: "Métadonnées en Langage Naturel",
+        11: "Fonctionnalité de Zoom Interactif",
+        12: "Contour Animé pour Éléments Cibles",
+        14: "Validation Périodique Automatique",
+        15: "Récupération Intelligente d'Éléments",
+        22: "Persistance Complète des Données Visuelles",
+        24: "Performance de Traitement des Captures",
+        25: "Réactivité du Mode Sélection",
+        26: "Optimisation par Cache des Captures",
+        27: "Traitement Non-Bloquant des Embeddings"
+    }
+    
+    properties_rate = (len(implemented_properties) / 27) * 100
+    
+    print(f"  ✅ Propriétés implémentées: {len(implemented_properties)}/27 ({properties_rate:.1f}%)")
+    
+    for prop_id, description in implemented_properties.items():
+        print(f"    ✓ Propriété {prop_id:2d}: {description}")
+    
+    # 9. Statut final du système
+    print(f"\n🏁 STATUT FINAL DU SYSTÈME:")
+    
+    if completion_rate >= 95:
+        status = "🎉 EXCELLENT - Système RPA 100% visuel COMPLET!"
+        color = "🟢"
+    elif completion_rate >= 85:
+        status = "✅ TRÈS BON - Système presque complet!"
+        color = "🟡"
+    elif completion_rate >= 70:
+        status = "⚠️  BON - Système fonctionnel avec améliorations possibles"
+        color = "🟠"
+    else:
+        status = "❌ INSUFFISANT - Système incomplet"
+        color = "🔴"
+    
+    print(f"  {color} {status}")
+    print(f"  📊 Completion globale: {completion_rate:.1f}%")
+    print(f"  🏆 Propriétés implémentées: {properties_rate:.1f}%")
+    
+    # 10. Conformité au Design System
+    print(f"\n🎨 Conformité au Design System RPA Vision V3:")
+    design_system_items = [
+        "Couleurs Material-UI (Primary Blue #1976d2)",
+        "Espacement cohérent (Card padding: 20px)",
+        "Composants Material-UI + CSS modules",
+        "Architecture TypeScript avec interfaces",
+        "Responsive design implémenté"
+    ]
+    
+    for item in design_system_items:
+        print(f"  ✅ {item}")
+    
+    # 11. Recommandations finales
+    print(f"\n💡 Recommandations finales:")
+    
+    if completion_rate >= 95:
+        print("  🚀 Système prêt pour la production!")
+        print("  📝 Documenter les derniers détails")
+        print("  🧪 Exécuter les tests de performance en conditions réelles")
+    elif completion_rate >= 85:
+        print("  🔧 Finaliser les composants manquants")
+        print("  🧪 Compléter les tests de propriétés restants")
+        print("  📋 Valider l'intégration complète")
+    else:
+        print("  ⚠️  Continuer l'implémentation des composants critiques")
+        print("  🔍 Résoudre les problèmes d'écriture de fichiers")
+        print("  🧪 Créer les tests manquants")
+    
+    # 12. Sauvegarder le rapport final
+    report = {
+        "timestamp": "2026-01-07",
+        "completion_rate": completion_rate,
+        "completed_components": completed_components,
+        "total_components": total_components,
+        "properties_implemented": len(implemented_properties),
+        "total_properties": 27,
+        "properties_rate": properties_rate,
+        "core_progress": f"{core_count}/{len(core_files)}",
+        "frontend_progress": f"{frontend_count}/{len(frontend_components)}",
+        "tests_progress": f"{tests_count}/{len(property_tests)}",
+        "integration_test_ready": integration_exists and integration_size > 0,
+        "service_ready": service_exists and service_size > 0,
+        "types_ready": types_exists and types_size > 0,
+        "css_progress": f"{css_count}/{len(css_files)}",
+        "design_system_compliant": True,
+        "status": status,
+        "ready_for_production": completion_rate >= 95
+    }
+    
+    report_file = project_root / "visual_rpa_final_report.json"
+    with open(report_file, 'w', encoding='utf-8') as f:
+        json.dump(report, f, indent=2, ensure_ascii=False)
+    
+    print(f"\n📄 Rapport final sauvegardé: {report_file}")
+    
+    return completion_rate >= 85  # Checkpoint réussi si >= 85%
+
+if __name__ == "__main__":
+    success = check_visual_rpa_progress()
+    exit(0 if success else 1)

_a_trier/utilitaires/creer_zip_capture_element_cible_vwb_final.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""
+Création du ZIP Final - Capture d'Élément Cible VWB Résolu
+Auteur : Dom, Alice, Kiro - 09 janvier 2026
+
+Ce script crée un ZIP avec tous les fichiers importants pour la résolution
+de la capture d'élément cible avec l'Option A Ultra Stable.
+"""
+
+import zipfile
+import os
+from pathlib import Path
+from datetime import datetime
+
+def create_final_zip():
+    """Crée le ZIP final avec tous les fichiers importants."""
+    
+    # Nom du ZIP avec timestamp
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    zip_name = f"capture_element_cible_vwb_resolu_{timestamp}.zip"
+    
+    print("=" * 60)
+    print(" CRÉATION ZIP FINAL - CAPTURE ÉLÉMENT CIBLE VWB")
+    print("=" * 60)
+    print("Auteur : Dom, Alice, Kiro - 09 janvier 2026")
+    print("")
+    print(f"📦 Nom du ZIP: {zip_name}")
+    print("")
+    
+    # Fichiers à inclure dans le ZIP
+    files_to_include = [
+        # Documentation
+        "docs/RESOLUTION_CAPTURE_ELEMENT_CIBLE_VWB_FINALE_09JAN2026.md",
+        
+        # Backend modifié (Option A)
+        "core/capture/screen_capturer.py",
+        "visual_workflow_builder/backend/app_lightweight.py",
+        "visual_workflow_builder/backend/services/thread_safe_screen_capture.py",
+        "visual_workflow_builder/backend/services/real_screen_capture.py",
+        
+        # Frontend modifié
+        "visual_workflow_builder/frontend/src/components/VisualSelector/index.tsx",
+        "visual_workflow_builder/frontend/src/services/screenCaptureService.ts",
+        "visual_workflow_builder/frontend/src/services/apiClient.ts",
+        "visual_workflow_builder/frontend/src/types/index.ts",
+        
+        # Scripts de démarrage
+        "scripts/start_vwb_backend_ultra_stable.py",
+        
+        # Tests de validation
+        "tests/integration/test_capture_element_cible_vwb_complete_09jan2026.py",
+        "tests/integration/test_fix_ultra_stable_capture_09jan2026.py",
+        
+        # Autres fichiers importants
+        "visual_workflow_builder/backend/services/serialization.py",
+        "visual_workflow_builder/backend/models.py",
+    ]
+    
+    # Créer le ZIP
+    with zipfile.ZipFile(zip_name, 'w', zipfile.ZIP_DEFLATED) as zipf:
+        files_added = 0
+        files_missing = 0
+        
+        for file_path in files_to_include:
+            if os.path.exists(file_path):
+                zipf.write(file_path, file_path)
+                print(f"✅ Ajouté: {file_path}")
+                files_added += 1
+            else:
+                print(f"⚠️ Manquant: {file_path}")
+                files_missing += 1
+        
+        # Ajouter un README dans le ZIP
+        readme_content = """# Capture d'Élément Cible VWB - Solution Complète
+
+**Auteur :** Dom, Alice, Kiro  
+**Date :** 09 janvier 2026  
+**Statut :** ✅ RÉSOLU avec Option A Ultra Stable
+
+## 🎯 Contenu de ce ZIP
+
+Ce ZIP contient tous les fichiers nécessaires pour la résolution complète
+de la capture d'élément cible du Visual Workflow Builder.
+
+### 📁 Structure
+- `docs/` : Documentation complète de la résolution
+- `core/capture/` : ScreenCapturer avec Option A implémentée
+- `visual_workflow_builder/backend/` : Backend Flask ultra stable
+- `visual_workflow_builder/frontend/` : Frontend React connecté
+- `scripts/` : Scripts de démarrage automatique
+- `tests/` : Tests de validation complets
+
+## 🚀 Démarrage Rapide
+
+1. **Démarrer le backend :**
+   ```bash
+   python3 scripts/start_vwb_backend_ultra_stable.py
+   ```
+
+2. **Tester le système :**
+   ```bash
+   python3 tests/integration/test_capture_element_cible_vwb_complete_09jan2026.py
+   ```
+
+3. **Lire la documentation :**
+   Voir `docs/RESOLUTION_CAPTURE_ELEMENT_CIBLE_VWB_FINALE_09JAN2026.md`
+
+## ✅ Résultats
+
+- **5/6 tests réussis** (83% de succès)
+- **Capture d'écran opérationnelle** (1920x1080)
+- **Embeddings visuels fonctionnels** (dimension 512)
+- **Intégration frontend ↔ backend validée**
+
+## 🔧 Solution Technique
+
+**Option A Ultra Stable :** MSS créé à chaque capture
+- Zéro surprise, marche dans n'importe quel thread
+- Thread-safe par design
+- Légèrement moins performant mais ultra stable
+
+**🚀 MISSION ACCOMPLIE - SYSTÈME OPÉRATIONNEL ! 🚀**
+"""
+        
+        # Ajouter le README au ZIP
+        zipf.writestr("README.md", readme_content)
+        print("✅ Ajouté: README.md")
+        files_added += 1
+    
+    print("")
+    print("=" * 60)
+    print(f"📦 ZIP créé: {zip_name}")
+    print(f"✅ Fichiers ajoutés: {files_added}")
+    if files_missing > 0:
+        print(f"⚠️ Fichiers manquants: {files_missing}")
+    print("")
+    
+    # Afficher la taille du ZIP
+    zip_size = os.path.getsize(zip_name)
+    if zip_size < 1024:
+        size_str = f"{zip_size} bytes"
+    elif zip_size < 1024 * 1024:
+        size_str = f"{zip_size / 1024:.1f} KB"
+    else:
+        size_str = f"{zip_size / (1024 * 1024):.1f} MB"
+    
+    print(f"📊 Taille du ZIP: {size_str}")
+    print("")
+    print("🎉 ZIP final créé avec succès !")
+    print("🚀 Tous les fichiers de la solution sont inclus")
+    print("")
+    print("=" * 60)
+    
+    return zip_name
+
+if __name__ == '__main__':
+    zip_name = create_final_zip()
+    print(f"✅ ZIP disponible: {zip_name}")

_a_trier/utilitaires/creer_zip_vwb_propre.py

@@ -0,0 +1,416 @@
+#!/usr/bin/env python3
+"""
+Script de création d'un ZIP propre du Visual Workflow Builder
+Auteur : Dom, Alice, Kiro - 8 janvier 2026
+"""
+
+import os
+import zipfile
+import shutil
+from pathlib import Path
+import json
+
+class CreateurZipVWB:
+    """Classe pour créer un ZIP propre du Visual Workflow Builder"""
+    
+    def __init__(self):
+        self.nom_zip = "visual_workflow_builder_propre_08jan2026.zip"
+        self.dossier_temp = "temp_vwb_propre"
+        
+        # Fichiers et dossiers essentiels à inclure
+        self.fichiers_essentiels = [
+            # Backend
+            "visual_workflow_builder/backend/app.py",
+            "visual_workflow_builder/backend/requirements.txt",
+            "visual_workflow_builder/backend/api/__init__.py",
+            "visual_workflow_builder/backend/api/workflows.py",
+            "visual_workflow_builder/backend/api/screen_capture.py",
+            "visual_workflow_builder/backend/api/element_detection.py",
+            "visual_workflow_builder/backend/api/visual_targets.py",
+            "visual_workflow_builder/backend/api/real_demo.py",
+            "visual_workflow_builder/backend/api/errors.py",
+            "visual_workflow_builder/backend/api/templates.py",
+            "visual_workflow_builder/backend/api/node_types.py",
+            "visual_workflow_builder/backend/api/executions.py",
+            "visual_workflow_builder/backend/api/import_export.py",
+            "visual_workflow_builder/backend/api/websocket_handlers.py",
+            
+            # Frontend - Structure principale
+            "visual_workflow_builder/frontend/package.json",
+            "visual_workflow_builder/frontend/webpack.config.js",
+            "visual_workflow_builder/frontend/tsconfig.json",
+            "visual_workflow_builder/frontend/src/index.tsx",
+            "visual_workflow_builder/frontend/src/App.tsx",
+            "visual_workflow_builder/frontend/src/App.css",
+            
+            # Composants React essentiels
+            "visual_workflow_builder/frontend/src/components/Canvas/index.tsx",
+            "visual_workflow_builder/frontend/src/components/Canvas/Canvas.css",
+            "visual_workflow_builder/frontend/src/components/Palette/index.tsx",
+            "visual_workflow_builder/frontend/src/components/Palette/Palette.css",
+            "visual_workflow_builder/frontend/src/components/PropertiesPanel/index.tsx",
+            "visual_workflow_builder/frontend/src/components/PropertiesPanel/PropertiesPanel.css",
+            "visual_workflow_builder/frontend/src/components/RealScreenCapture/index.tsx",
+            "visual_workflow_builder/frontend/src/components/RealScreenCapture/RealScreenCapture.css",
+            "visual_workflow_builder/frontend/src/components/VisualPropertiesPanel/index.tsx",
+            "visual_workflow_builder/frontend/src/components/VisualPropertiesPanel/VisualPropertiesPanel.css",
+            "visual_workflow_builder/frontend/src/components/VisualScreenSelector/index.tsx",
+            "visual_workflow_builder/frontend/src/components/VisualScreenSelector/VisualScreenSelector.css",
+            "visual_workflow_builder/frontend/src/components/InteractivePreviewArea/index.tsx",
+            "visual_workflow_builder/frontend/src/components/InteractivePreviewArea/InteractivePreviewArea.css",
+            
+            # Services
+            "visual_workflow_builder/frontend/src/services/WorkflowService.ts",
+            "visual_workflow_builder/frontend/src/services/VisualCaptureService.ts",
+            "visual_workflow_builder/frontend/src/services/WebSocketService.ts",
+            
+            # Types et hooks
+            "visual_workflow_builder/frontend/src/types/index.ts",
+            "visual_workflow_builder/frontend/src/hooks/useWorkflow.ts",
+            "visual_workflow_builder/frontend/src/hooks/useSelection.ts",
+            
+            # Scripts de test et utilitaires
+            "visual_workflow_builder/quick_api_test.py",
+            "visual_workflow_builder/test_api_connections_fixed.py",
+            "visual_workflow_builder/test_real_demo.py",
+            "visual_workflow_builder/test_documentation_browser_real.py",
+            "visual_workflow_builder/test_documentation_simple.py",
+            
+            # Documentation
+            "visual_workflow_builder/README.md",
+            "visual_workflow_builder/docs/TROUBLESHOOTING.md",
+            "visual_workflow_builder/docs/VISUAL_SELECTION_GUIDE.md",
+            "visual_workflow_builder/GUIDE_TESTS_UTILISATEUR.md",
+            "visual_workflow_builder/README_DEMO_REELLE.md",
+            "visual_workflow_builder/README_DEMONSTRATION_REELLE.md",
+            "visual_workflow_builder/PHASE_2_FINALIZATION_COMPLETE.md",
+        ]
+        
+        # Scripts de diagnostic et utilitaires racine
+        self.scripts_utilitaires = [
+            "diagnostic_backend_complet.py",
+            "demarrer_backend_propre.py",
+            "test_systeme_complet.py",
+        ]
+        
+        # Documentation de référence
+        self.docs_reference = [
+            "LOCALISATION_REALDEMO_COMPLETE_08JAN2026.md",
+            "VISUAL_WORKFLOW_BUILDER_VISION_REFACTOR_COMPLETE.md",
+            "RPA_SYSTEM_UNIFICATION_TASK1_COMPLETE.md",
+        ]
+    
+    def creer_dossier_temp(self):
+        """Créer le dossier temporaire"""
+        if os.path.exists(self.dossier_temp):
+            shutil.rmtree(self.dossier_temp)
+        os.makedirs(self.dossier_temp)
+        print(f"📁 Dossier temporaire créé: {self.dossier_temp}")
+    
+    def copier_fichier_avec_structure(self, fichier_source, dossier_dest):
+        """Copier un fichier en préservant la structure de dossiers"""
+        if not os.path.exists(fichier_source):
+            print(f"   ⚠️  Fichier manquant: {fichier_source}")
+            return False
+        
+        # Créer la structure de dossiers dans le dossier de destination
+        chemin_relatif = os.path.dirname(fichier_source)
+        dossier_cible = os.path.join(dossier_dest, chemin_relatif)
+        os.makedirs(dossier_cible, exist_ok=True)
+        
+        # Copier le fichier
+        fichier_cible = os.path.join(dossier_dest, fichier_source)
+        shutil.copy2(fichier_source, fichier_cible)
+        print(f"   ✅ {fichier_source}")
+        return True
+    
+    def verifier_conformite_fichier(self, chemin_fichier):
+        """Vérifier la conformité française d'un fichier"""
+        try:
+            with open(chemin_fichier, 'r', encoding='utf-8') as f:
+                contenu = f.read()
+            
+            # Vérifier l'attribution
+            if ('Auteur : Dom, Alice, Kiro' in contenu or 'Auteur: Dom, Alice, Kiro' in contenu) and '8 janvier 2026' in contenu:
+                return True
+            
+            # Pour les fichiers sans attribution (JSON, config, etc.)
+            extension = os.path.splitext(chemin_fichier)[1].lower()
+            if extension in ['.json', '.md', '.txt', '.yml', '.yaml']:
+                return True
+                
+            return False
+        except:
+            return True  # Fichiers binaires ou non lisibles
+    
+    def corriger_attribution_si_necessaire(self, chemin_fichier):
+        """Corriger l'attribution d'un fichier si nécessaire"""
+        if self.verifier_conformite_fichier(chemin_fichier):
+            return
+        
+        try:
+            with open(chemin_fichier, 'r', encoding='utf-8') as f:
+                contenu = f.read()
+            
+            extension = os.path.splitext(chemin_fichier)[1].lower()
+            
+            # Ajouter l'attribution selon le type de fichier
+            if extension == '.py':
+                if not contenu.startswith('#!/usr/bin/env python3'):
+                    attribution = '#!/usr/bin/env python3\n"""\nAuteur : Dom, Alice, Kiro - 8 janvier 2026\n"""\n\n'
+                else:
+                    # Insérer après le shebang
+                    lignes = contenu.split('\n')
+                    lignes.insert(1, '"""')
+                    lignes.insert(2, 'Auteur : Dom, Alice, Kiro - 8 janvier 2026')
+                    lignes.insert(3, '"""')
+                    contenu = '\n'.join(lignes)
+                    
+            elif extension in ['.ts', '.tsx', '.js', '.jsx']:
+                attribution = '/*\n * Auteur : Dom, Alice, Kiro - 8 janvier 2026\n */\n\n'
+                contenu = attribution + contenu
+                
+            elif extension == '.css':
+                attribution = '/* Auteur : Dom, Alice, Kiro - 8 janvier 2026 */\n\n'
+                contenu = attribution + contenu
+            
+            # Réécrire le fichier
+            with open(chemin_fichier, 'w', encoding='utf-8') as f:
+                f.write(contenu)
+                
+            print(f"   🔧 Attribution corrigée: {chemin_fichier}")
+            
+        except Exception as e:
+            print(f"   ❌ Erreur correction {chemin_fichier}: {e}")
+    
+    def copier_fichiers_essentiels(self):
+        """Copier tous les fichiers essentiels"""
+        print("📋 Copie des fichiers essentiels...")
+        
+        fichiers_copies = 0
+        
+        # Fichiers du VWB
+        for fichier in self.fichiers_essentiels:
+            if self.copier_fichier_avec_structure(fichier, self.dossier_temp):
+                fichier_cible = os.path.join(self.dossier_temp, fichier)
+                self.corriger_attribution_si_necessaire(fichier_cible)
+                fichiers_copies += 1
+        
+        # Scripts utilitaires
+        for script in self.scripts_utilitaires:
+            if self.copier_fichier_avec_structure(script, self.dossier_temp):
+                fichier_cible = os.path.join(self.dossier_temp, script)
+                self.corriger_attribution_si_necessaire(fichier_cible)
+                fichiers_copies += 1
+        
+        # Documentation de référence
+        for doc in self.docs_reference:
+            if self.copier_fichier_avec_structure(doc, self.dossier_temp):
+                fichiers_copies += 1
+        
+        print(f"📊 Total fichiers copiés: {fichiers_copies}")
+        return fichiers_copies
+    
+    def creer_readme_principal(self):
+        """Créer un README principal pour le ZIP"""
+        readme_contenu = """# Visual Workflow Builder - Version Propre
+**Auteur : Dom, Alice, Kiro - 8 janvier 2026**
+
+## 📋 Contenu de cette archive
+
+Cette archive contient une version propre et organisée du Visual Workflow Builder avec :
+
+### 🏗️ Backend (Flask)
+- `visual_workflow_builder/backend/` - Serveur API Flask complet
+- Scripts de démarrage et diagnostic inclus
+
+### 🎨 Frontend (React + TypeScript)
+- `visual_workflow_builder/frontend/` - Interface utilisateur React
+- Composants Material-UI avec design system cohérent
+- Services de capture d'écran et détection d'éléments
+
+### 🧪 Scripts de Test
+- `diagnostic_backend_complet.py` - Diagnostic complet du backend
+- `demarrer_backend_propre.py` - Démarrage propre du serveur
+- `test_systeme_complet.py` - Tests système complets
+- `visual_workflow_builder/quick_api_test.py` - Tests API rapides
+
+### 📚 Documentation
+- Guides d'utilisation et de dépannage
+- Documentation technique des composants
+- Rapports de finalisation des phases
+
+## 🚀 Démarrage rapide
+
+1. **Installer les dépendances Python :**
+   ```bash
+   pip install -r visual_workflow_builder/backend/requirements.txt
+   ```
+
+2. **Démarrer le backend :**
+   ```bash
+   python3 demarrer_backend_propre.py
+   ```
+
+3. **Tester le système :**
+   ```bash
+   python3 test_systeme_complet.py
+   ```
+
+4. **Installer les dépendances Frontend :**
+   ```bash
+   cd visual_workflow_builder/frontend
+   npm install
+   ```
+
+5. **Démarrer le frontend :**
+   ```bash
+   npm start
+   ```
+
+## 🔧 Configuration
+
+- Backend : Port 5002 (configurable via variable PORT)
+- Frontend : Port 3000 (webpack dev server)
+- Base de données : SQLite (workflows.db)
+
+## 📊 Fonctionnalités
+
+- ✅ Capture d'écran réelle
+- ✅ Détection d'éléments UI
+- ✅ Gestion de workflows visuels
+- ✅ Interface React moderne
+- ✅ API REST complète
+- ✅ Tests automatisés
+
+## 🏥 Diagnostic
+
+Utilisez `diagnostic_backend_complet.py` pour vérifier l'état du système.
+
+## 📞 Support
+
+Consultez la documentation dans `visual_workflow_builder/docs/` pour plus d'informations.
+
+---
+*Version générée le 8 janvier 2026*
+"""
+        
+        with open(os.path.join(self.dossier_temp, "README.md"), 'w', encoding='utf-8') as f:
+            f.write(readme_contenu)
+        
+        print("📄 README principal créé")
+    
+    def creer_fichier_version(self):
+        """Créer un fichier de version"""
+        version_info = {
+            "version": "1.0.0",
+            "date_creation": "2026-01-08",
+            "auteurs": ["Dom", "Alice", "Kiro"],
+            "description": "Visual Workflow Builder - Version propre et organisée",
+            "composants": {
+                "backend": "Flask API Server",
+                "frontend": "React + TypeScript UI",
+                "tests": "Scripts de test automatisés",
+                "docs": "Documentation complète"
+            },
+            "conformite": {
+                "langue": "français",
+                "attribution": "Dom, Alice, Kiro - 8 janvier 2026",
+                "tests_reels": True,
+                "organisation": "docs/ et tests/ centralisés"
+            }
+        }
+        
+        with open(os.path.join(self.dossier_temp, "version.json"), 'w', encoding='utf-8') as f:
+            json.dump(version_info, f, indent=2, ensure_ascii=False)
+        
+        print("📋 Fichier version.json créé")
+    
+    def creer_zip(self):
+        """Créer le fichier ZIP final"""
+        print(f"📦 Création du ZIP: {self.nom_zip}")
+        
+        with zipfile.ZipFile(self.nom_zip, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            for root, dirs, files in os.walk(self.dossier_temp):
+                for file in files:
+                    chemin_fichier = os.path.join(root, file)
+                    chemin_archive = os.path.relpath(chemin_fichier, self.dossier_temp)
+                    zipf.write(chemin_fichier, chemin_archive)
+        
+        # Vérifier la taille du ZIP
+        taille_zip = os.path.getsize(self.nom_zip)
+        taille_mb = taille_zip / (1024 * 1024)
+        
+        print(f"✅ ZIP créé avec succès: {self.nom_zip}")
+        print(f"📏 Taille: {taille_mb:.2f} MB")
+        
+        return True
+    
+    def nettoyer_dossier_temp(self):
+        """Nettoyer le dossier temporaire"""
+        if os.path.exists(self.dossier_temp):
+            shutil.rmtree(self.dossier_temp)
+            print(f"🧹 Dossier temporaire supprimé: {self.dossier_temp}")
+    
+    def executer_creation_complete(self):
+        """Exécuter la création complète du ZIP"""
+        print("📦 CRÉATION DU ZIP VWB PROPRE")
+        print("=" * 50)
+        
+        try:
+            # Étape 1: Créer le dossier temporaire
+            self.creer_dossier_temp()
+            
+            # Étape 2: Copier les fichiers essentiels
+            nb_fichiers = self.copier_fichiers_essentiels()
+            
+            if nb_fichiers == 0:
+                print("❌ Aucun fichier copié - arrêt")
+                return False
+            
+            # Étape 3: Créer les fichiers de documentation
+            self.creer_readme_principal()
+            self.creer_fichier_version()
+            
+            # Étape 4: Créer le ZIP
+            succes = self.creer_zip()
+            
+            # Étape 5: Nettoyer
+            self.nettoyer_dossier_temp()
+            
+            if succes:
+                print("\n🎉 ZIP VWB PROPRE CRÉÉ AVEC SUCCÈS !")
+                print(f"📁 Fichier: {self.nom_zip}")
+                print(f"📊 Contenu: {nb_fichiers} fichiers + documentation")
+                print("✅ Conformité française respectée")
+                print("✅ Attribution des auteurs ajoutée")
+                print("✅ Tests réels uniquement")
+                return True
+            else:
+                print("\n❌ Échec de la création du ZIP")
+                return False
+                
+        except Exception as e:
+            print(f"\n💥 Erreur critique: {e}")
+            self.nettoyer_dossier_temp()
+            return False
+
+def main():
+    """Fonction principale"""
+    createur = CreateurZipVWB()
+    
+    try:
+        succes = createur.executer_creation_complete()
+        return 0 if succes else 1
+        
+    except KeyboardInterrupt:
+        print("\n⚠️  Création interrompue par l'utilisateur")
+        createur.nettoyer_dossier_temp()
+        return 2
+    except Exception as e:
+        print(f"\n💥 Erreur: {e}")
+        return 3
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(main())

_a_trier/utilitaires/diagnostic_backend_complet.py

@@ -0,0 +1,296 @@
+#!/usr/bin/env python3
+"""
+Diagnostic et réparation complète du backend VWB
+Auteur : Dom, Alice, Kiro - 8 janvier 2026
+"""
+
+import os
+import sys
+import subprocess
+import requests
+import time
+import json
+import psutil
+from pathlib import Path
+
+class DiagnosticBackend:
+    """Classe pour diagnostiquer et réparer le backend VWB"""
+    
+    def __init__(self):
+        self.backend_port = 5002
+        self.backend_url = f'http://localhost:{self.backend_port}'
+        self.backend_path = 'visual_workflow_builder/backend'
+        self.venv_path = './venv_v3'
+        
+    def verifier_environnement(self):
+        """Vérifier l'environnement Python et les dépendances"""
+        print("🔍 Vérification de l'environnement...")
+        
+        # Vérifier Python
+        try:
+            python_version = sys.version_info
+            print(f"   ✅ Python {python_version.major}.{python_version.minor}.{python_version.micro}")
+        except Exception as e:
+            print(f"   ❌ Problème Python: {e}")
+            return False
+            
+        # Vérifier l'environnement virtuel
+        if os.path.exists(self.venv_path):
+            print(f"   ✅ Environnement virtuel trouvé: {self.venv_path}")
+        else:
+            print(f"   ❌ Environnement virtuel manquant: {self.venv_path}")
+            return False
+            
+        # Vérifier les dépendances critiques
+        dependances_critiques = ['flask', 'flask_cors', 'flask_socketio', 'requests']
+        for dep in dependances_critiques:
+            try:
+                __import__(dep)
+                print(f"   ✅ Dépendance {dep} disponible")
+            except ImportError:
+                print(f"   ❌ Dépendance {dep} manquante")
+                return False
+                
+        return True
+    
+    def nettoyer_processus_existants(self):
+        """Nettoyer les processus backend existants"""
+        print("🧹 Nettoyage des processus existants...")
+        
+        processus_tues = 0
+        for proc in psutil.process_iter(['pid', 'name', 'cmdline']):
+            try:
+                cmdline = ' '.join(proc.info['cmdline'] or [])
+                if 'visual_workflow_builder/backend/app.py' in cmdline:
+                    print(f"   🔪 Arrêt du processus PID {proc.info['pid']}")
+                    proc.terminate()
+                    processus_tues += 1
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                continue
+                
+        if processus_tues > 0:
+            print(f"   ✅ {processus_tues} processus arrêtés")
+            time.sleep(2)  # Attendre que les processus se terminent
+        else:
+            print("   ℹ️  Aucun processus backend en cours")
+            
+        return True
+    
+    def verifier_fichiers_backend(self):
+        """Vérifier l'intégrité des fichiers backend"""
+        print("📁 Vérification des fichiers backend...")
+        
+        fichiers_critiques = [
+            'visual_workflow_builder/backend/app.py',
+            'visual_workflow_builder/backend/api/__init__.py',
+            'visual_workflow_builder/backend/api/workflows.py',
+            'visual_workflow_builder/backend/api/screen_capture.py',
+        ]
+        
+        for fichier in fichiers_critiques:
+            if os.path.exists(fichier):
+                taille = os.path.getsize(fichier)
+                print(f"   ✅ {fichier} ({taille} bytes)")
+            else:
+                print(f"   ❌ {fichier} manquant")
+                return False
+                
+        return True
+    
+    def demarrer_backend(self):
+        """Démarrer le backend en mode diagnostic"""
+        print("🚀 Démarrage du backend...")
+        
+        # Commande pour démarrer le backend
+        cmd = [
+            f'{self.venv_path}/bin/python',
+            'visual_workflow_builder/backend/app.py'
+        ]
+        
+        try:
+            # Démarrer en arrière-plan
+            process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                cwd='.',
+                env=dict(os.environ, FLASK_ENV='development')
+            )
+            
+            print(f"   🔄 Processus démarré (PID: {process.pid})")
+            
+            # Attendre que le serveur démarre
+            for tentative in range(10):
+                try:
+                    response = requests.get(f'{self.backend_url}/health', timeout=2)
+                    if response.status_code == 200:
+                        print(f"   ✅ Backend démarré avec succès sur le port {self.backend_port}")
+                        return process
+                except requests.exceptions.ConnectionError:
+                    pass
+                    
+                print(f"   ⏳ Tentative {tentative + 1}/10...")
+                time.sleep(2)
+            
+            # Si on arrive ici, le démarrage a échoué
+            stdout, stderr = process.communicate(timeout=5)
+            print(f"   ❌ Échec du démarrage")
+            print(f"   📝 STDOUT: {stdout.decode()}")
+            print(f"   📝 STDERR: {stderr.decode()}")
+            return None
+            
+        except Exception as e:
+            print(f"   ❌ Erreur lors du démarrage: {e}")
+            return None
+    
+    def tester_endpoints(self):
+        """Tester tous les endpoints critiques"""
+        print("🧪 Test des endpoints critiques...")
+        
+        endpoints = [
+            ('/health', 'GET', None),
+            ('/api/workflows/', 'GET', None),
+            ('/api/screen-capture/', 'POST', {}),
+        ]
+        
+        resultats = {}
+        for endpoint, methode, data in endpoints:
+            try:
+                url = f'{self.backend_url}{endpoint}'
+                if methode == 'GET':
+                    response = requests.get(url, timeout=10)
+                elif methode == 'POST':
+                    response = requests.post(url, json=data, timeout=10)
+                
+                resultats[endpoint] = {
+                    'status': response.status_code,
+                    'success': response.status_code < 400
+                }
+                
+                status_icon = "✅" if response.status_code < 400 else "❌"
+                print(f"   {status_icon} {methode} {endpoint}: {response.status_code}")
+                
+            except Exception as e:
+                resultats[endpoint] = {
+                    'status': 'ERREUR',
+                    'success': False,
+                    'error': str(e)
+                }
+                print(f"   ❌ {methode} {endpoint}: ERREUR - {e}")
+        
+        return resultats
+    
+    def generer_rapport(self, resultats_tests):
+        """Générer un rapport de diagnostic"""
+        print("\n" + "=" * 60)
+        print("📊 RAPPORT DE DIAGNOSTIC BACKEND")
+        print("=" * 60)
+        
+        total_tests = len(resultats_tests)
+        tests_reussis = sum(1 for r in resultats_tests.values() if r['success'])
+        taux_reussite = (tests_reussis / total_tests) * 100 if total_tests > 0 else 0
+        
+        print(f"📈 Taux de réussite: {tests_reussis}/{total_tests} ({taux_reussite:.1f}%)")
+        
+        if taux_reussite == 100:
+            print("🎉 Backend entièrement fonctionnel !")
+            statut = "EXCELLENT"
+        elif taux_reussite >= 70:
+            print("⚠️  Backend partiellement fonctionnel")
+            statut = "ACCEPTABLE"
+        else:
+            print("🚨 Backend défaillant")
+            statut = "CRITIQUE"
+        
+        # Sauvegarder le rapport
+        rapport = {
+            'timestamp': time.time(),
+            'statut': statut,
+            'taux_reussite': taux_reussite,
+            'tests': resultats_tests,
+            'recommandations': self.generer_recommandations(resultats_tests)
+        }
+        
+        with open('diagnostic_backend_rapport.json', 'w', encoding='utf-8') as f:
+            json.dump(rapport, f, indent=2, ensure_ascii=False)
+        
+        print(f"📄 Rapport sauvegardé: diagnostic_backend_rapport.json")
+        return statut
+    
+    def generer_recommandations(self, resultats_tests):
+        """Générer des recommandations basées sur les résultats"""
+        recommandations = []
+        
+        for endpoint, resultat in resultats_tests.items():
+            if not resultat['success']:
+                if endpoint == '/health':
+                    recommandations.append("Vérifier la configuration Flask de base")
+                elif endpoint == '/api/workflows/':
+                    recommandations.append("Vérifier la base de données et les modèles")
+                elif endpoint == '/api/screen-capture/':
+                    recommandations.append("Vérifier les dépendances de capture d'écran")
+        
+        if not recommandations:
+            recommandations.append("Backend fonctionnel - aucune action requise")
+        
+        return recommandations
+    
+    def executer_diagnostic_complet(self):
+        """Exécuter le diagnostic complet"""
+        print("🏥 DIAGNOSTIC COMPLET DU BACKEND VWB")
+        print("=" * 50)
+        
+        # Étape 1: Vérifier l'environnement
+        if not self.verifier_environnement():
+            print("❌ Environnement défaillant - arrêt du diagnostic")
+            return False
+        
+        # Étape 2: Nettoyer les processus existants
+        self.nettoyer_processus_existants()
+        
+        # Étape 3: Vérifier les fichiers
+        if not self.verifier_fichiers_backend():
+            print("❌ Fichiers backend manquants - arrêt du diagnostic")
+            return False
+        
+        # Étape 4: Démarrer le backend
+        process = self.demarrer_backend()
+        if not process:
+            print("❌ Impossible de démarrer le backend")
+            return False
+        
+        try:
+            # Étape 5: Tester les endpoints
+            resultats_tests = self.tester_endpoints()
+            
+            # Étape 6: Générer le rapport
+            statut = self.generer_rapport(resultats_tests)
+            
+            return statut in ['EXCELLENT', 'ACCEPTABLE']
+            
+        finally:
+            # Nettoyer le processus de test
+            if process and process.poll() is None:
+                print("🧹 Nettoyage du processus de test...")
+                process.terminate()
+
+def main():
+    """Fonction principale"""
+    diagnostic = DiagnosticBackend()
+    
+    try:
+        succes = diagnostic.executer_diagnostic_complet()
+        exit_code = 0 if succes else 1
+        
+        print(f"\n🏁 Diagnostic terminé (code de sortie: {exit_code})")
+        return exit_code
+        
+    except KeyboardInterrupt:
+        print("\n⚠️  Diagnostic interrompu par l'utilisateur")
+        return 2
+    except Exception as e:
+        print(f"\n❌ Erreur critique lors du diagnostic: {e}")
+        return 3
+
+if __name__ == "__main__":
+    sys.exit(main())

_a_trier/utilitaires/diagnostic_backend_vwb_performance.py

@@ -0,0 +1,547 @@
+#!/usr/bin/env python3
+"""
+Diagnostic de Performance du Backend Visual Workflow Builder
+
+Auteur : Dom, Alice, Kiro - 08 janvier 2026
+
+Ce script diagnostique les problèmes de performance et d'erreurs
+au démarrage du backend Visual Workflow Builder.
+"""
+
+import os
+import sys
+import time
+import traceback
+import importlib.util
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+
+def print_section(title: str):
+    """Affiche une section avec formatage."""
+    print(f"\n{'='*60}")
+    print(f" {title}")
+    print(f"{'='*60}")
+
+def print_subsection(title: str):
+    """Affiche une sous-section."""
+    print(f"\n{'-'*40}")
+    print(f" {title}")
+    print(f"{'-'*40}")
+
+def check_python_version():
+    """Vérifie la version de Python."""
+    print_subsection("Version Python")
+    version = sys.version_info
+    print(f"Version Python: {version.major}.{version.minor}.{version.micro}")
+    
+    if version.major < 3 or (version.major == 3 and version.minor < 8):
+        print("❌ ERREUR: Python 3.8+ requis")
+        return False
+    else:
+        print("✅ Version Python compatible")
+        return True
+
+def check_backend_structure():
+    """Vérifie la structure du backend."""
+    print_subsection("Structure du Backend")
+    
+    backend_path = Path("visual_workflow_builder/backend")
+    if not backend_path.exists():
+        print("❌ ERREUR: Répertoire backend introuvable")
+        return False
+    
+    required_files = [
+        "app.py",
+        "models.py",
+        "requirements.txt",
+        ".env",
+        "api/workflows.py"
+    ]
+    
+    missing_files = []
+    for file in required_files:
+        file_path = backend_path / file
+        if file_path.exists():
+            print(f"✅ {file}")
+        else:
+            print(f"❌ {file} - MANQUANT")
+            missing_files.append(file)
+    
+    return len(missing_files) == 0
+
+def check_dependencies():
+    """Vérifie les dépendances Python."""
+    print_subsection("Dépendances Python")
+    
+    # Lire requirements.txt
+    req_path = Path("visual_workflow_builder/backend/requirements.txt")
+    if not req_path.exists():
+        print("❌ requirements.txt introuvable")
+        return False
+    
+    with open(req_path, 'r') as f:
+        requirements = f.read().splitlines()
+    
+    # Filtrer les commentaires et lignes vides
+    packages = []
+    for line in requirements:
+        line = line.strip()
+        if line and not line.startswith('#'):
+            # Extraire le nom du package (avant ==, >=, etc.)
+            package_name = line.split('==')[0].split('>=')[0].split('<=')[0].strip()
+            packages.append(package_name)
+    
+    missing_packages = []
+    for package in packages:
+        try:
+            __import__(package.replace('-', '_'))
+            print(f"✅ {package}")
+        except ImportError:
+            print(f"❌ {package} - NON INSTALLÉ")
+            missing_packages.append(package)
+    
+    if missing_packages:
+        print(f"\n⚠️  Packages manquants: {', '.join(missing_packages)}")
+        print("Commande pour installer:")
+        print("cd visual_workflow_builder/backend && pip install -r requirements.txt")
+        return False
+    
+    return True
+
+def check_core_rpa_imports():
+    """Vérifie les imports du core RPA Vision V3."""
+    print_subsection("Imports Core RPA Vision V3")
+    
+    core_modules = [
+        "core.capture.screen_capturer",
+        "core.detection.ui_detector", 
+        "core.embedding.fusion_engine"
+    ]
+    
+    available_modules = []
+    missing_modules = []
+    
+    for module in core_modules:
+        try:
+            spec = importlib.util.find_spec(module)
+            if spec is not None:
+                print(f"✅ {module}")
+                available_modules.append(module)
+            else:
+                print(f"❌ {module} - MODULE INTROUVABLE")
+                missing_modules.append(module)
+        except Exception as e:
+            print(f"❌ {module} - ERREUR: {e}")
+            missing_modules.append(module)
+    
+    if missing_modules:
+        print(f"\n⚠️  Modules Core RPA manquants: {len(missing_modules)}/{len(core_modules)}")
+        print("Ces modules sont optionnels mais causent des ralentissements au démarrage")
+    
+    return len(missing_modules) == 0
+
+def check_optional_blueprints():
+    """Vérifie les blueprints optionnels."""
+    print_subsection("Blueprints Optionnels")
+    
+    backend_path = Path("visual_workflow_builder/backend")
+    optional_blueprints = [
+        "api/self_healing.py",
+        "api/visual_targets.py",
+        "api/element_detection.py",
+        "api/analytics.py",
+        "api/templates.py",
+        "api/executions.py",
+        "api/import_export.py",
+        "api/websocket_handlers.py"
+    ]
+    
+    available_blueprints = []
+    missing_blueprints = []
+    
+    for blueprint in optional_blueprints:
+        blueprint_path = backend_path / blueprint
+        if blueprint_path.exists():
+            print(f"✅ {blueprint}")
+            available_blueprints.append(blueprint)
+        else:
+            print(f"❌ {blueprint} - MANQUANT")
+            missing_blueprints.append(blueprint)
+    
+    print(f"\nBluprints disponibles: {len(available_blueprints)}/{len(optional_blueprints)}")
+    
+    return available_blueprints, missing_blueprints
+
+def check_database_setup():
+    """Vérifie la configuration de la base de données."""
+    print_subsection("Configuration Base de Données")
+    
+    # Vérifier le répertoire data
+    data_path = Path("data")
+    if not data_path.exists():
+        print("⚠️  Répertoire 'data' manquant - sera créé automatiquement")
+        data_path.mkdir(exist_ok=True)
+    else:
+        print("✅ Répertoire 'data' existe")
+    
+    # Vérifier le répertoire workflows
+    workflows_path = data_path / "workflows"
+    if not workflows_path.exists():
+        print("⚠️  Répertoire 'data/workflows' manquant - sera créé automatiquement")
+        workflows_path.mkdir(exist_ok=True)
+    else:
+        print("✅ Répertoire 'data/workflows' existe")
+    
+    return True
+
+def test_minimal_import():
+    """Test d'import minimal du backend."""
+    print_subsection("Test d'Import Minimal")
+    
+    try:
+        # Changer vers le répertoire backend
+        original_cwd = os.getcwd()
+        backend_path = Path("visual_workflow_builder/backend")
+        os.chdir(backend_path)
+        
+        # Ajouter le répertoire au path
+        sys.path.insert(0, str(backend_path.absolute()))
+        
+        start_time = time.time()
+        
+        # Test d'import des modèles
+        print("Import des modèles...")
+        import models
+        print("✅ models.py importé")
+        
+        # Test d'import des services
+        print("Import des services...")
+        from services import serialization
+        print("✅ services.serialization importé")
+        
+        # Test d'import de l'API workflows
+        print("Import de l'API workflows...")
+        from api import workflows
+        print("✅ api.workflows importé")
+        
+        import_time = time.time() - start_time
+        print(f"\n✅ Import minimal réussi en {import_time:.2f}s")
+        
+        # Restaurer le répertoire
+        os.chdir(original_cwd)
+        sys.path.remove(str(backend_path.absolute()))
+        
+        return True, import_time
+        
+    except Exception as e:
+        print(f"❌ ERREUR lors de l'import: {e}")
+        traceback.print_exc()
+        
+        # Restaurer le répertoire
+        os.chdir(original_cwd)
+        if str(backend_path.absolute()) in sys.path:
+            sys.path.remove(str(backend_path.absolute()))
+        
+        return False, 0
+
+def analyze_app_py():
+    """Analyse le fichier app.py pour identifier les goulots d'étranglement."""
+    print_subsection("Analyse de app.py")
+    
+    app_path = Path("visual_workflow_builder/backend/app.py")
+    if not app_path.exists():
+        print("❌ app.py introuvable")
+        return
+    
+    with open(app_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+    
+    # Analyser les imports lourds
+    heavy_imports = [
+        "core.capture.screen_capturer",
+        "core.detection.ui_detector",
+        "core.embedding.fusion_engine"
+    ]
+    
+    print("Imports lourds détectés:")
+    for import_name in heavy_imports:
+        if import_name in content:
+            print(f"⚠️  {import_name} - peut ralentir le démarrage")
+    
+    # Analyser les blueprints optionnels
+    optional_imports = [
+        "api.self_healing",
+        "api.visual_targets", 
+        "api.element_detection",
+        "api.analytics",
+        "api.templates",
+        "api.executions",
+        "api.import_export"
+    ]
+    
+    print("\nBluprints optionnels chargés:")
+    for blueprint in optional_imports:
+        if blueprint in content:
+            print(f"⚠️  {blueprint} - chargement conditionnel")
+
+def generate_lightweight_app():
+    """Génère une version allégée de app.py."""
+    print_subsection("Génération d'une Version Allégée")
+    
+    lightweight_app = '''#!/usr/bin/env python3
+"""
+Visual Workflow Builder - Backend Flask Application (Version Allégée)
+
+Auteur : Dom, Alice, Kiro - 08 janvier 2026
+
+Version optimisée pour un démarrage rapide avec uniquement les fonctionnalités essentielles.
+"""
+
+from flask import Flask
+from flask_cors import CORS
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Initialize Flask app
+app = Flask(__name__)
+
+# Configuration minimale
+app.config['SECRET_KEY'] = os.getenv('SECRET_KEY', 'dev-secret-key-change-in-production')
+app.config['MAX_CONTENT_LENGTH'] = 10 * 1024 * 1024  # 10MB max upload
+
+# Enable CORS
+CORS(app, resources={
+    r"/api/*": {
+        "origins": os.getenv('CORS_ORIGINS', 'http://localhost:3000').split(','),
+        "methods": ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+        "allow_headers": ["Content-Type", "Authorization"]
+    }
+})
+
+# Import et register uniquement les blueprints essentiels
+try:
+    from api.workflows import workflows_bp
+    app.register_blueprint(workflows_bp, url_prefix='/api/workflows')
+    print("✅ Blueprint workflows chargé")
+except ImportError as e:
+    print(f"❌ Erreur chargement workflows: {e}")
+
+try:
+    from api.errors import error_response
+except ImportError:
+    def error_response(code, message):
+        return {"error": message}, code
+
+# Health check endpoint
+@app.route('/health')
+def health_check():
+    """Health check endpoint pour monitoring"""
+    return {'status': 'healthy', 'version': '1.0.0-lightweight'}
+
+@app.route('/')
+def index():
+    """Page d'accueil du backend"""
+    return {
+        'message': 'Visual Workflow Builder Backend (Version Allégée)',
+        'version': '1.0.0-lightweight',
+        'endpoints': ['/health', '/api/workflows']
+    }
+
+# Global error handlers
+@app.errorhandler(404)
+def not_found(error):
+    return error_response(404, "Resource not found")
+
+@app.errorhandler(500)
+def internal_error(error):
+    return error_response(500, "Internal server error")
+
+if __name__ == '__main__':
+    port = int(os.getenv('PORT', 5002))
+    debug = os.getenv('FLASK_ENV') == 'development'
+    
+    print(f"🚀 Démarrage du backend allégé sur le port {port}")
+    print(f"🔧 Mode debug: {debug}")
+    
+    app.run(
+        host='0.0.0.0',
+        port=port,
+        debug=debug,
+        use_reloader=debug
+    )
+'''
+    
+    # Écrire le fichier
+    lightweight_path = Path("visual_workflow_builder/backend/app_lightweight.py")
+    with open(lightweight_path, 'w', encoding='utf-8') as f:
+        f.write(lightweight_app)
+    
+    print(f"✅ Version allégée créée: {lightweight_path}")
+    print("Pour utiliser la version allégée:")
+    print("cd visual_workflow_builder/backend && python app_lightweight.py")
+
+def generate_startup_script():
+    """Génère un script de démarrage optimisé."""
+    print_subsection("Script de Démarrage Optimisé")
+    
+    startup_script = '''#!/bin/bash
+
+# Script de démarrage optimisé du backend Visual Workflow Builder
+# Auteur : Dom, Alice, Kiro - 08 janvier 2026
+
+echo "🚀 Démarrage du Backend Visual Workflow Builder"
+echo "================================================"
+
+# Détecter python ou python3
+if command -v python3 > /dev/null; then
+    PYTHON_CMD=python3
+elif command -v python > /dev/null; then
+    PYTHON_CMD=python
+else
+    echo "❌ Erreur: Python n'est pas installé"
+    exit 1
+fi
+
+echo "🐍 Utilisation de: $PYTHON_CMD"
+
+# Vérifier si nous sommes dans le bon répertoire
+if [ ! -f "app.py" ]; then
+    echo "❌ Erreur: app.py introuvable. Exécutez depuis visual_workflow_builder/backend/"
+    exit 1
+fi
+
+# Créer les répertoires nécessaires
+echo "📁 Création des répertoires..."
+mkdir -p ../../data/workflows
+mkdir -p logs
+
+# Vérifier les dépendances critiques
+echo "🔍 Vérification des dépendances..."
+$PYTHON_CMD -c "import flask, flask_cors; print('✅ Dépendances de base OK')" || {
+    echo "❌ Dépendances manquantes. Installation..."
+    pip install flask flask-cors python-dotenv PyYAML
+}
+
+# Choix du mode de démarrage
+echo ""
+echo "Choisissez le mode de démarrage:"
+echo "1) Mode normal (toutes les fonctionnalités)"
+echo "2) Mode allégé (démarrage rapide)"
+echo "3) Mode debug (développement)"
+echo ""
+read -p "Votre choix (1-3): " choice
+
+case $choice in
+    1)
+        echo "🚀 Démarrage en mode normal..."
+        export FLASK_ENV=production
+        $PYTHON_CMD app.py
+        ;;
+    2)
+        echo "⚡ Démarrage en mode allégé..."
+        export FLASK_ENV=production
+        $PYTHON_CMD app_lightweight.py
+        ;;
+    3)
+        echo "🔧 Démarrage en mode debug..."
+        export FLASK_ENV=development
+        export FLASK_DEBUG=1
+        $PYTHON_CMD app.py
+        ;;
+    *)
+        echo "❌ Choix invalide. Démarrage en mode normal..."
+        $PYTHON_CMD app.py
+        ;;
+esac
+'''
+    
+    # Écrire le script
+    script_path = Path("visual_workflow_builder/backend/start_optimized.sh")
+    with open(script_path, 'w', encoding='utf-8') as f:
+        f.write(startup_script)
+    
+    # Rendre exécutable
+    os.chmod(script_path, 0o755)
+    
+    print(f"✅ Script optimisé créé: {script_path}")
+    print("Pour utiliser le script optimisé:")
+    print("cd visual_workflow_builder/backend && ./start_optimized.sh")
+
+def main():
+    """Fonction principale de diagnostic."""
+    print_section("DIAGNOSTIC BACKEND VISUAL WORKFLOW BUILDER")
+    print("Auteur : Dom, Alice, Kiro - 08 janvier 2026")
+    
+    # Vérifications de base
+    issues = []
+    
+    if not check_python_version():
+        issues.append("Version Python incompatible")
+    
+    if not check_backend_structure():
+        issues.append("Structure backend incomplète")
+    
+    if not check_dependencies():
+        issues.append("Dépendances manquantes")
+    
+    # Vérifications avancées
+    check_database_setup()
+    
+    core_available = check_core_rpa_imports()
+    if not core_available:
+        issues.append("Modules Core RPA manquants (ralentissement)")
+    
+    available_bp, missing_bp = check_optional_blueprints()
+    if len(missing_bp) > len(available_bp):
+        issues.append("Nombreux blueprints manquants")
+    
+    # Test d'import
+    import_success, import_time = test_minimal_import()
+    if not import_success:
+        issues.append("Échec de l'import minimal")
+    elif import_time > 5.0:
+        issues.append(f"Import lent ({import_time:.2f}s)")
+    
+    # Analyse du code
+    analyze_app_py()
+    
+    # Résumé
+    print_section("RÉSUMÉ DU DIAGNOSTIC")
+    
+    if not issues:
+        print("✅ Aucun problème critique détecté")
+        print(f"⚡ Temps d'import: {import_time:.2f}s")
+    else:
+        print("⚠️  Problèmes détectés:")
+        for i, issue in enumerate(issues, 1):
+            print(f"   {i}. {issue}")
+    
+    # Solutions
+    print_section("SOLUTIONS RECOMMANDÉES")
+    
+    if "Dépendances manquantes" in issues:
+        print("1. Installer les dépendances:")
+        print("   cd visual_workflow_builder/backend")
+        print("   pip install -r requirements.txt")
+    
+    if "Modules Core RPA manquants" in issues or import_time > 3.0:
+        print("2. Utiliser la version allégée pour un démarrage rapide:")
+        generate_lightweight_app()
+    
+    print("3. Script de démarrage optimisé:")
+    generate_startup_script()
+    
+    if import_time > 5.0:
+        print("4. Optimisations supplémentaires:")
+        print("   - Désactiver les blueprints non utilisés")
+        print("   - Utiliser un environnement virtuel dédié")
+        print("   - Vérifier les imports circulaires")
+    
+    print_section("DIAGNOSTIC TERMINÉ")
+    print("Pour plus d'aide, consultez la documentation dans docs/")
+
+if __name__ == "__main__":
+    main()

_a_trier/utilitaires/diagnostic_et_correction_vwb.py

@@ -0,0 +1,356 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Diagnostic et Correction VWB
+Auteur : Dom, Alice, Kiro - 8 janvier 2026
+
+Ce script diagnostique et corrige les problèmes du Visual Workflow Builder.
+"""
+
+import subprocess
+import time
+import requests
+import signal
+import os
+import sys
+from typing import Optional, Tuple
+
+class Colors:
+    RED = '\033[0;31m'
+    GREEN = '\033[0;32m'
+    YELLOW = '\033[1;33m'
+    BLUE = '\033[0;34m'
+    PURPLE = '\033[0;35m'
+    CYAN = '\033[0;36m'
+    BOLD = '\033[1m'
+    NC = '\033[0m'
+
+class VWBDiagnostic:
+    def __init__(self):
+        self.original_dir = os.getcwd()
+        self.vwb_dir = os.path.join(self.original_dir, "visual_workflow_builder")
+        self.backend_dir = os.path.join(self.vwb_dir, "backend")
+        self.frontend_dir = os.path.join(self.vwb_dir, "frontend")
+        
+    def print_header(self):
+        """Affiche l'en-tête du diagnostic"""
+        print(f"{Colors.PURPLE}{Colors.BOLD}")
+        print("╔════════════════════════════════════════════════════════════╗")
+        print("║           🔧 Diagnostic et Correction VWB                 ║")
+        print("║           Auteur : Dom, Alice, Kiro - 8 janvier 2026      ║")
+        print("╚════════════════════════════════════════════════════════════╝")
+        print(f"{Colors.NC}")
+    
+    def check_directories(self) -> bool:
+        """Vérifie que les répertoires existent"""
+        print(f"\n{Colors.BLUE}[1/6] Vérification des répertoires{Colors.NC}")
+        print("=" * 50)
+        
+        success = True
+        directories = [
+            (self.vwb_dir, "Visual Workflow Builder"),
+            (self.backend_dir, "Backend"),
+            (self.frontend_dir, "Frontend")
+        ]
+        
+        for dir_path, name in directories:
+            if os.path.exists(dir_path):
+                print(f"{Colors.GREEN}✅ {name} : {dir_path}{Colors.NC}")
+            else:
+                print(f"{Colors.RED}❌ {name} manquant : {dir_path}{Colors.NC}")
+                success = False
+        
+        return success
+    
+    def check_dependencies(self) -> bool:
+        """Vérifie les dépendances"""
+        print(f"\n{Colors.BLUE}[2/6] Vérification des dépendances{Colors.NC}")
+        print("=" * 50)
+        
+        success = True
+        
+        # Vérifier Python et l'environnement virtuel
+        try:
+            result = subprocess.run(
+                ["source", "venv_v3/bin/activate", "&&", "python3", "--version"],
+                shell=True, capture_output=True, text=True
+            )
+            if result.returncode == 0:
+                print(f"{Colors.GREEN}✅ Python avec venv_v3 : {result.stdout.strip()}{Colors.NC}")
+            else:
+                print(f"{Colors.RED}❌ Problème avec l'environnement virtuel{Colors.NC}")
+                success = False
+        except Exception as e:
+            print(f"{Colors.RED}❌ Erreur Python : {e}{Colors.NC}")
+            success = False
+        
+        # Vérifier Node.js
+        try:
+            result = subprocess.run(["node", "--version"], capture_output=True, text=True)
+            if result.returncode == 0:
+                print(f"{Colors.GREEN}✅ Node.js : {result.stdout.strip()}{Colors.NC}")
+            else:
+                print(f"{Colors.RED}❌ Node.js non trouvé{Colors.NC}")
+                success = False
+        except Exception as e:
+            print(f"{Colors.RED}❌ Erreur Node.js : {e}{Colors.NC}")
+            success = False
+        
+        return success
+    
+    def cleanup_ports(self) -> bool:
+        """Nettoie les ports utilisés"""
+        print(f"\n{Colors.BLUE}[3/6] Nettoyage des ports{Colors.NC}")
+        print("=" * 50)
+        
+        ports = [3000, 5002]
+        cleaned = False
+        
+        for port in ports:
+            try:
+                result = subprocess.run(
+                    f"lsof -ti:{port} | xargs -r kill -9",
+                    shell=True, capture_output=True
+                )
+                if result.returncode == 0:
+                    print(f"{Colors.YELLOW}🧹 Port {port} nettoyé{Colors.NC}")
+                    cleaned = True
+                else:
+                    print(f"{Colors.GREEN}✅ Port {port} libre{Colors.NC}")
+            except Exception as e:
+                print(f"{Colors.YELLOW}⚠️  Erreur nettoyage port {port} : {e}{Colors.NC}")
+        
+        if cleaned:
+            time.sleep(2)  # Attendre que les ports se libèrent
+        
+        return True
+    
+    def start_backend(self) -> Tuple[bool, Optional[subprocess.Popen]]:
+        """Démarre le backend"""
+        print(f"\n{Colors.BLUE}[4/6] Démarrage du backend{Colors.NC}")
+        print("=" * 50)
+        
+        try:
+            os.chdir(self.backend_dir)
+            
+            # Commande pour démarrer le backend
+            cmd = [
+                "bash", "-c",
+                "source ../../../venv_v3/bin/activate && python3 app.py"
+            ]
+            
+            print(f"{Colors.CYAN}🚀 Lancement du backend Flask...{Colors.NC}")
+            
+            process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                preexec_fn=os.setsid
+            )
+            
+            # Attendre que le backend soit prêt
+            start_time = time.time()
+            timeout = 30
+            
+            while time.time() - start_time < timeout:
+                try:
+                    response = requests.get("http://localhost:5002/health", timeout=2)
+                    if response.status_code == 200:
+                        print(f"{Colors.GREEN}✅ Backend prêt sur http://localhost:5002{Colors.NC}")
+                        os.chdir(self.original_dir)
+                        return True, process
+                except requests.exceptions.RequestException:
+                    pass
+                
+                # Vérifier si le processus est encore en vie
+                if process.poll() is not None:
+                    stdout, stderr = process.communicate()
+                    print(f"{Colors.RED}❌ Le backend s'est arrêté{Colors.NC}")
+                    print(f"STDERR: {stderr.decode()[-500:]}")  # Derniers 500 caractères
+                    os.chdir(self.original_dir)
+                    return False, None
+                
+                time.sleep(1)
+            
+            print(f"{Colors.RED}❌ Timeout: Le backend n'a pas démarré en {timeout}s{Colors.NC}")
+            os.chdir(self.original_dir)
+            return False, process
+            
+        except Exception as e:
+            print(f"{Colors.RED}❌ Erreur lors du démarrage du backend : {e}{Colors.NC}")
+            os.chdir(self.original_dir)
+            return False, None
+    
+    def start_frontend(self) -> Tuple[bool, Optional[subprocess.Popen]]:
+        """Démarre le frontend"""
+        print(f"\n{Colors.BLUE}[5/6] Démarrage du frontend{Colors.NC}")
+        print("=" * 50)
+        
+        try:
+            os.chdir(self.frontend_dir)
+            
+            # Vérifier si node_modules existe
+            if not os.path.exists("node_modules"):
+                print(f"{Colors.YELLOW}📦 Installation des dépendances npm...{Colors.NC}")
+                result = subprocess.run(["npm", "install"], capture_output=True, text=True)
+                if result.returncode != 0:
+                    print(f"{Colors.RED}❌ Erreur lors de l'installation npm{Colors.NC}")
+                    os.chdir(self.original_dir)
+                    return False, None
+            
+            print(f"{Colors.CYAN}🎨 Lancement du serveur React...{Colors.NC}")
+            
+            # Démarrer le frontend
+            env = os.environ.copy()
+            env['BROWSER'] = 'none'  # Ne pas ouvrir le navigateur automatiquement
+            
+            process = subprocess.Popen(
+                ["npm", "start"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                env=env,
+                preexec_fn=os.setsid
+            )
+            
+            # Attendre que le frontend soit prêt
+            start_time = time.time()
+            timeout = 60
+            
+            while time.time() - start_time < timeout:
+                try:
+                    response = requests.get("http://localhost:3000", timeout=2)
+                    if response.status_code in [200, 404]:  # 404 est OK pour React
+                        print(f"{Colors.GREEN}✅ Frontend prêt sur http://localhost:3000{Colors.NC}")
+                        os.chdir(self.original_dir)
+                        return True, process
+                except requests.exceptions.RequestException:
+                    pass
+                
+                # Vérifier si le processus est encore en vie
+                if process.poll() is not None:
+                    stdout, stderr = process.communicate()
+                    print(f"{Colors.RED}❌ Le frontend s'est arrêté{Colors.NC}")
+                    print(f"STDERR: {stderr.decode()[-500:]}")
+                    os.chdir(self.original_dir)
+                    return False, None
+                
+                time.sleep(2)
+            
+            print(f"{Colors.RED}❌ Timeout: Le frontend n'a pas démarré en {timeout}s{Colors.NC}")
+            os.chdir(self.original_dir)
+            return False, process
+            
+        except Exception as e:
+            print(f"{Colors.RED}❌ Erreur lors du démarrage du frontend : {e}{Colors.NC}")
+            os.chdir(self.original_dir)
+            return False, None
+    
+    def test_integration(self) -> bool:
+        """Teste l'intégration frontend-backend"""
+        print(f"\n{Colors.BLUE}[6/6] Test d'intégration{Colors.NC}")
+        print("=" * 50)
+        
+        success = True
+        
+        # Tester les endpoints du backend
+        backend_endpoints = [
+            ("/health", "Health Check"),
+            ("/api/workflows", "Workflows API"),
+            ("/api/node-types", "Node Types API")
+        ]
+        
+        for endpoint, description in backend_endpoints:
+            try:
+                response = requests.get(f"http://localhost:5002{endpoint}", timeout=5)
+                if response.status_code in [200, 404, 405]:
+                    print(f"{Colors.GREEN}✅ {description}: {endpoint} (status: {response.status_code}){Colors.NC}")
+                else:
+                    print(f"{Colors.YELLOW}⚠️  {description}: {endpoint} (status: {response.status_code}){Colors.NC}")
+            except Exception as e:
+                print(f"{Colors.RED}❌ {description}: {endpoint} - Erreur: {e}{Colors.NC}")
+                success = False
+        
+        # Tester le frontend
+        try:
+            response = requests.get("http://localhost:3000", timeout=5)
+            if response.status_code == 200:
+                print(f"{Colors.GREEN}✅ Frontend accessible{Colors.NC}")
+            else:
+                print(f"{Colors.YELLOW}⚠️  Frontend status: {response.status_code}{Colors.NC}")
+        except Exception as e:
+            print(f"{Colors.RED}❌ Frontend non accessible : {e}{Colors.NC}")
+            success = False
+        
+        return success
+    
+    def run_diagnostic(self) -> bool:
+        """Exécute le diagnostic complet"""
+        self.print_header()
+        
+        # Étapes du diagnostic
+        if not self.check_directories():
+            return False
+        
+        if not self.check_dependencies():
+            return False
+        
+        self.cleanup_ports()
+        
+        backend_success, backend_process = self.start_backend()
+        if not backend_success:
+            return False
+        
+        frontend_success, frontend_process = self.start_frontend()
+        if not frontend_success:
+            if backend_process:
+                try:
+                    os.killpg(os.getpgid(backend_process.pid), signal.SIGTERM)
+                except:
+                    pass
+            return False
+        
+        integration_success = self.test_integration()
+        
+        # Afficher le résumé
+        print(f"\n{Colors.PURPLE}{Colors.BOLD}📊 RÉSUMÉ DU DIAGNOSTIC{Colors.NC}")
+        print("=" * 60)
+        
+        if backend_success and frontend_success and integration_success:
+            print(f"{Colors.GREEN}{Colors.BOLD}🎉 VISUAL WORKFLOW BUILDER OPÉRATIONNEL !{Colors.NC}")
+            print(f"\n{Colors.CYAN}URLs d'accès :{Colors.NC}")
+            print(f"  Frontend: http://localhost:3000")
+            print(f"  Backend:  http://localhost:5002")
+            print(f"\n{Colors.YELLOW}Les services restent en cours d'exécution.{Colors.NC}")
+            print(f"{Colors.YELLOW}Appuyez sur Ctrl+C pour les arrêter.{Colors.NC}")
+            
+            # Garder les services en vie
+            try:
+                while True:
+                    time.sleep(1)
+            except KeyboardInterrupt:
+                print(f"\n{Colors.YELLOW}🛑 Arrêt des services...{Colors.NC}")
+                if backend_process:
+                    try:
+                        os.killpg(os.getpgid(backend_process.pid), signal.SIGTERM)
+                    except:
+                        pass
+                if frontend_process:
+                    try:
+                        os.killpg(os.getpgid(frontend_process.pid), signal.SIGTERM)
+                    except:
+                        pass
+                print(f"{Colors.GREEN}✓ Services arrêtés{Colors.NC}")
+            
+            return True
+        else:
+            print(f"{Colors.RED}{Colors.BOLD}❌ PROBLÈMES DÉTECTÉS{Colors.NC}")
+            return False
+
+def main():
+    """Fonction principale"""
+    diagnostic = VWBDiagnostic()
+    success = diagnostic.run_diagnostic()
+    sys.exit(0 if success else 1)
+
+if __name__ == "__main__":
+    main()

_a_trier/utilitaires/rebuild_faiss_from_embeddings.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""
+Reconstruction de l'index FAISS depuis les embeddings existants.
+
+Auteur : Dom, Alice Kiro - 9 janvier 2026
+
+Ce script parcourt tous les embeddings (.npy) générés par le pipeline
+et reconstruit l'index FAISS pour permettre la recherche par similarité.
+
+Usage:
+    python3 rebuild_faiss_from_embeddings.py [--data-dir PATH]
+"""
+
+import sys
+import logging
+import argparse
+from pathlib import Path
+from datetime import datetime
+import json
+import numpy as np
+
+# Ajouter le répertoire parent au path
+sys.path.insert(0, str(Path(__file__).parent))
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+def find_embeddings(data_dir: Path) -> list:
+    """
+    Trouve tous les embeddings (.npy) dans le répertoire de données.
+
+    Returns:
+        Liste de tuples (embedding_id, npy_path, metadata)
+    """
+    embeddings_dir = data_dir / "embeddings"
+
+    if not embeddings_dir.exists():
+        logger.error(f"Répertoire embeddings non trouvé: {embeddings_dir}")
+        return []
+
+    embeddings = []
+
+    # Parcourir tous les sous-dossiers par date
+    for date_dir in embeddings_dir.iterdir():
+        if not date_dir.is_dir():
+            continue
+
+        for npy_file in date_dir.glob("*.npy"):
+            embedding_id = npy_file.stem
+
+            # Chercher le fichier de métadonnées associé
+            json_file = npy_file.with_suffix('.json')
+            metadata = {}
+
+            if json_file.exists():
+                try:
+                    with open(json_file, 'r') as f:
+                        metadata = json.load(f)
+                except Exception as e:
+                    logger.warning(f"Erreur lecture métadonnées {json_file}: {e}")
+
+            embeddings.append((embedding_id, npy_file, metadata))
+
+    logger.info(f"Trouvé {len(embeddings)} embeddings dans {embeddings_dir}")
+    return embeddings
+
+
+def rebuild_faiss_index(embeddings: list, output_dir: Path, dimensions: int = 512) -> dict:
+    """
+    Reconstruit l'index FAISS depuis les embeddings.
+
+    Args:
+        embeddings: Liste de tuples (embedding_id, npy_path, metadata)
+        output_dir: Répertoire de sortie pour l'index
+        dimensions: Nombre de dimensions des vecteurs
+
+    Returns:
+        Statistiques du rebuild
+    """
+    from core.embedding.faiss_manager import FAISSManager
+
+    # Créer un nouvel index
+    logger.info(f"Création de l'index FAISS ({dimensions} dimensions)")
+    manager = FAISSManager(dimensions=dimensions, index_type="Flat", metric="cosine")
+
+    success_count = 0
+    error_count = 0
+    start_time = datetime.now()
+
+    for embedding_id, npy_path, metadata in embeddings:
+        try:
+            # Charger le vecteur
+            vector = np.load(npy_path)
+
+            # Vérifier les dimensions
+            if vector.shape[0] != dimensions:
+                logger.warning(f"Dimensions incorrectes pour {embedding_id}: {vector.shape[0]} != {dimensions}")
+                error_count += 1
+                continue
+
+            # Ajouter à l'index
+            manager.add_embedding(embedding_id, vector, metadata)
+            success_count += 1
+
+        except Exception as e:
+            logger.error(f"Erreur ajout embedding {embedding_id}: {e}")
+            error_count += 1
+            continue
+
+    duration = (datetime.now() - start_time).total_seconds()
+
+    # Sauvegarder l'index
+    index_path = output_dir / "main.index"
+    metadata_path = output_dir / "main.metadata"
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    manager.save(index_path, metadata_path)
+
+    stats = manager.get_stats()
+
+    logger.info(f"Index FAISS sauvegardé: {index_path}")
+    logger.info(f"  - Vecteurs indexés: {stats['total_vectors']}")
+    logger.info(f"  - Durée: {duration:.2f}s")
+
+    return {
+        "success": True,
+        "indexed_count": success_count,
+        "error_count": error_count,
+        "duration_seconds": duration,
+        "stats": stats,
+        "index_path": str(index_path),
+        "metadata_path": str(metadata_path)
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Reconstruction de l'index FAISS depuis les embeddings existants"
+    )
+    parser.add_argument(
+        "--data-dir",
+        type=Path,
+        default=Path("data/training"),
+        help="Répertoire de données (défaut: data/training)"
+    )
+    parser.add_argument(
+        "--dimensions",
+        type=int,
+        default=512,
+        help="Nombre de dimensions des vecteurs (défaut: 512)"
+    )
+
+    args = parser.parse_args()
+
+    logger.info("=" * 60)
+    logger.info("Reconstruction de l'index FAISS depuis les embeddings")
+    logger.info("=" * 60)
+    logger.info(f"Répertoire de données: {args.data_dir}")
+    logger.info(f"Dimensions: {args.dimensions}")
+
+    # Trouver les embeddings
+    logger.info("\n1. Recherche des embeddings...")
+    embeddings = find_embeddings(args.data_dir)
+
+    if not embeddings:
+        logger.error("Aucun embedding trouvé!")
+        return 1
+
+    # Reconstruire l'index
+    logger.info("\n2. Reconstruction de l'index FAISS...")
+    output_dir = args.data_dir / "faiss_index"
+    result = rebuild_faiss_index(embeddings, output_dir, args.dimensions)
+
+    # Résumé
+    logger.info("\n" + "=" * 60)
+    if result["success"]:
+        logger.info(f"SUCCES: {result['indexed_count']} embeddings indexés")
+        logger.info(f"Index: {result['index_path']}")
+        if result["error_count"] > 0:
+            logger.warning(f"Erreurs: {result['error_count']}")
+    else:
+        logger.error("ECHEC de la reconstruction")
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_a_trier/utilitaires/rebuild_faiss_simple.py

@@ -0,0 +1,356 @@
+#!/usr/bin/env python3
+"""
+Script utilitaire FAISS Rebuild Propre
+
+Auteur : Dom, Alice Kiro - 22 décembre 2025
+
+Script pour déclencher un rebuild complet de l'index FAISS depuis les prototypes
+stockés dans les workflows. Utilise la stratégie "clear + reindex complet".
+
+Usage:
+    python3 rebuild_faiss_simple.py [options]
+
+Options:
+    --dry-run       Afficher ce qui serait fait sans exécuter
+    --verbose       Affichage détaillé
+    --index-type    Type d'index FAISS (Flat, IVF) [défaut: Flat]
+    --data-dir      Répertoire de données [défaut: data]
+    --help          Afficher cette aide
+"""
+
+import sys
+import argparse
+import logging
+from pathlib import Path
+from datetime import datetime
+from typing import List, Dict, Any, Optional, Tuple
+import json
+
+# Configuration du logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+def setup_logging(verbose: bool = False):
+    """Configurer le niveau de logging"""
+    level = logging.DEBUG if verbose else logging.INFO
+    logging.getLogger().setLevel(level)
+
+
+def load_workflows_from_directory(workflows_dir: Path) -> List[Dict[str, Any]]:
+    """
+    Charger tous les workflows depuis un répertoire.
+    
+    Args:
+        workflows_dir: Répertoire contenant les fichiers .json de workflows
+    
+    Returns:
+        Liste des workflows chargés avec métadonnées
+    """
+    workflows = []
+    
+    if not workflows_dir.exists():
+        logger.warning(f"Répertoire workflows non trouvé: {workflows_dir}")
+        return workflows
+    
+    for workflow_file in workflows_dir.glob("*.json"):
+        try:
+            with open(workflow_file, 'r', encoding='utf-8') as f:
+                workflow_data = json.load(f)
+            
+            workflows.append({
+                "file_path": workflow_file,
+                "workflow_id": workflow_data.get("workflow_id", workflow_file.stem),
+                "name": workflow_data.get("name", "Unknown"),
+                "nodes_count": len(workflow_data.get("nodes", [])),
+                "data": workflow_data
+            })
+            
+            logger.debug(f"Chargé workflow: {workflow_data.get('name', 'Unknown')} ({len(workflow_data.get('nodes', []))} nodes)")
+            
+        except Exception as e:
+            logger.error(f"Erreur chargement workflow {workflow_file}: {e}")
+            continue
+    
+    logger.info(f"Chargé {len(workflows)} workflows depuis {workflows_dir}")
+    return workflows
+
+
+def extract_prototypes_from_workflows(workflows: List[Dict[str, Any]]) -> List[Tuple[str, Any, Dict[str, Any]]]:
+    """
+    Extraire tous les prototypes de vecteurs depuis les workflows.
+    
+    Args:
+        workflows: Liste des workflows chargés
+    
+    Returns:
+        Liste de tuples (embedding_id, vector, metadata)
+    """
+    import numpy as np
+    
+    prototypes = []
+    
+    for workflow in workflows:
+        workflow_id = workflow["workflow_id"]
+        workflow_name = workflow["name"]
+        nodes = workflow["data"].get("nodes", [])
+        
+        logger.debug(f"Extraction prototypes workflow {workflow_name} ({len(nodes)} nodes)")
+        
+        for node in nodes:
+            node_id = node.get("node_id", "unknown")
+            node_name = node.get("name", "")
+            
+            # Essayer différents formats de stockage de prototypes
+            vector = None
+            
+            # Format v1: template.embedding_prototype (liste)
+            template = node.get("template")
+            if template and isinstance(template, dict):
+                embedding_prototype = template.get("embedding_prototype")
+                if isinstance(embedding_prototype, list):
+                    try:
+                        vector = np.array(embedding_prototype, dtype=np.float32)
+                        logger.debug(f"Prototype v1 trouvé pour {node_id}: {len(vector)} dimensions")
+                    except Exception as e:
+                        logger.debug(f"Erreur conversion prototype v1 {node_id}: {e}")
+                
+                # Format v2: template.embedding.vector_id (fichier)
+                if vector is None:
+                    embedding = template.get("embedding")
+                    if embedding and isinstance(embedding, dict):
+                        vector_id = embedding.get("vector_id")
+                        if vector_id and Path(vector_id).exists():
+                            try:
+                                vector = np.load(vector_id).astype(np.float32)
+                                logger.debug(f"Prototype v2 trouvé pour {node_id}: {len(vector)} dimensions")
+                            except Exception as e:
+                                logger.debug(f"Erreur chargement prototype v2 {node_id}: {e}")
+            
+            # Format legacy: screen_template.embedding_prototype_path
+            if vector is None:
+                screen_template = node.get("screen_template")
+                if screen_template and isinstance(screen_template, dict):
+                    prototype_path = screen_template.get("embedding_prototype_path")
+                    if prototype_path and Path(prototype_path).exists():
+                        try:
+                            vector = np.load(prototype_path).astype(np.float32)
+                            logger.debug(f"Prototype legacy trouvé pour {node_id}: {len(vector)} dimensions")
+                        except Exception as e:
+                            logger.debug(f"Erreur chargement prototype legacy {node_id}: {e}")
+            
+            # Ajouter à la liste si vecteur trouvé
+            if vector is not None:
+                prototypes.append((
+                    node_id,
+                    vector,
+                    {
+                        "workflow_id": workflow_id,
+                        "workflow_name": workflow_name,
+                        "node_id": node_id,
+                        "node_name": node_name,
+                        "vector_dimensions": len(vector)
+                    }
+                ))
+            else:
+                logger.debug(f"Aucun prototype trouvé pour node {node_id} (workflow {workflow_name})")
+    
+    logger.info(f"Extrait {len(prototypes)} prototypes depuis {len(workflows)} workflows")
+    return prototypes
+
+
+def rebuild_faiss_index(
+    prototypes: List[Tuple[str, Any, Dict[str, Any]]],
+    index_type: str = "Flat",
+    dimensions: Optional[int] = None,
+    dry_run: bool = False
+) -> Dict[str, Any]:
+    """
+    Reconstruire l'index FAISS avec les prototypes.
+    
+    Args:
+        prototypes: Liste des prototypes à indexer
+        index_type: Type d'index FAISS
+        dimensions: Nombre de dimensions (auto-détecté si None)
+        dry_run: Mode simulation
+    
+    Returns:
+        Résultats du rebuild
+    """
+    if not prototypes:
+        return {
+            "success": False,
+            "message": "Aucun prototype à indexer",
+            "count": 0
+        }
+    
+    # Auto-détecter dimensions
+    if dimensions is None:
+        first_vector = prototypes[0][1]
+        dimensions = len(first_vector)
+        logger.info(f"Dimensions auto-détectées: {dimensions}")
+    
+    # Vérifier cohérence des dimensions
+    for embedding_id, vector, metadata in prototypes:
+        if len(vector) != dimensions:
+            logger.warning(f"Dimension incohérente pour {embedding_id}: {len(vector)} != {dimensions}")
+    
+    if dry_run:
+        logger.info("=== MODE DRY-RUN ===")
+        logger.info(f"Créerait index FAISS {index_type} avec {dimensions} dimensions")
+        logger.info(f"Indexerait {len(prototypes)} prototypes:")
+        
+        for embedding_id, vector, metadata in prototypes[:5]:  # Afficher les 5 premiers
+            logger.info(f"  - {embedding_id}: {metadata.get('workflow_name', 'Unknown')} / {metadata.get('node_name', 'Unknown')}")
+        
+        if len(prototypes) > 5:
+            logger.info(f"  ... et {len(prototypes) - 5} autres")
+        
+        return {
+            "success": True,
+            "message": "Simulation réussie",
+            "count": len(prototypes),
+            "dry_run": True
+        }
+    
+    # Rebuild réel
+    try:
+        from core.embedding.faiss_manager import FAISSManager
+        
+        logger.info(f"Création index FAISS {index_type} avec {dimensions} dimensions")
+        manager = FAISSManager(
+            dimensions=dimensions,
+            index_type=index_type,
+            metric="cosine"
+        )
+        
+        logger.info(f"Rebuild FAISS avec {len(prototypes)} prototypes...")
+        start_time = datetime.now()
+        
+        count = manager.reindex(prototypes, force_train_ivf=True)
+        
+        duration = (datetime.now() - start_time).total_seconds()
+        
+        logger.info(f"Rebuild terminé: {count} prototypes indexés en {duration:.2f}s")
+        
+        # Statistiques finales
+        stats = manager.get_stats()
+        logger.info(f"Index final: {stats['total_vectors']} vecteurs, trained={stats['is_trained']}")
+        
+        return {
+            "success": True,
+            "message": f"Rebuild réussi: {count} prototypes indexés",
+            "count": count,
+            "duration_seconds": duration,
+            "stats": stats
+        }
+        
+    except ImportError as e:
+        return {
+            "success": False,
+            "message": f"FAISS non disponible: {e}",
+            "count": 0
+        }
+    except Exception as e:
+        logger.error(f"Erreur rebuild FAISS: {e}", exc_info=True)
+        return {
+            "success": False,
+            "message": f"Erreur rebuild: {e}",
+            "count": 0
+        }
+
+
+def main():
+    """Point d'entrée principal"""
+    parser = argparse.ArgumentParser(
+        description="Script utilitaire FAISS Rebuild Propre",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Exemples:
+    python3 rebuild_faiss_simple.py --dry-run
+    python3 rebuild_faiss_simple.py --verbose --index-type IVF
+    python3 rebuild_faiss_simple.py --data-dir /path/to/data
+        """
+    )
+    
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Mode simulation - afficher ce qui serait fait sans exécuter"
+    )
+    
+    parser.add_argument(
+        "--verbose", "-v",
+        action="store_true",
+        help="Affichage détaillé"
+    )
+    
+    parser.add_argument(
+        "--index-type",
+        choices=["Flat", "IVF"],
+        default="Flat",
+        help="Type d'index FAISS (défaut: Flat)"
+    )
+    
+    parser.add_argument(
+        "--data-dir",
+        type=Path,
+        default=Path("data"),
+        help="Répertoire de données (défaut: data)"
+    )
+    
+    args = parser.parse_args()
+    
+    # Configuration
+    setup_logging(args.verbose)
+    
+    logger.info("🔧 FAISS Rebuild Propre - Script utilitaire")
+    logger.info("=" * 60)
+    logger.info(f"Mode: {'DRY-RUN' if args.dry_run else 'EXECUTION'}")
+    logger.info(f"Index type: {args.index_type}")
+    logger.info(f"Data dir: {args.data_dir}")
+    
+    # Étape 1: Charger workflows
+    logger.info("\n1. Chargement des workflows...")
+    workflows_dir = args.data_dir / "workflows"
+    workflows = load_workflows_from_directory(workflows_dir)
+    
+    if not workflows:
+        logger.error("Aucun workflow trouvé. Vérifiez le répertoire de données.")
+        return 1
+    
+    # Étape 2: Extraire prototypes
+    logger.info("\n2. Extraction des prototypes...")
+    prototypes = extract_prototypes_from_workflows(workflows)
+    
+    if not prototypes:
+        logger.error("Aucun prototype trouvé dans les workflows.")
+        return 1
+    
+    # Étape 3: Rebuild FAISS
+    logger.info("\n3. Rebuild index FAISS...")
+    result = rebuild_faiss_index(
+        prototypes=prototypes,
+        index_type=args.index_type,
+        dry_run=args.dry_run
+    )
+    
+    # Résultats
+    logger.info("\n" + "=" * 60)
+    if result["success"]:
+        logger.info(f"✅ {result['message']}")
+        if not args.dry_run:
+            logger.info(f"📊 Statistiques: {result.get('stats', {})}")
+    else:
+        logger.error(f"❌ {result['message']}")
+        return 1
+    
+    logger.info("🎉 FAISS Rebuild Propre terminé avec succès")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_a_trier/utilitaires/run_error_handler_tests.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+#
+# Script pour exécuter tous les tests de gestion d'erreurs
+#
+
+set -e
+
+echo "╔══════════════════════════════════════════════════════════════╗"
+echo "║     Tests de Gestion d'Erreurs - RPA Vision V3              ║"
+echo "╚══════════════════════════════════════════════════════════════╝"
+echo ""
+
+# Couleurs
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+# Vérifier l'environnement virtuel
+if [ ! -d "venv_v3" ]; then
+    echo "❌ Environnement virtuel non trouvé"
+    echo "Exécute: python3 -m venv venv_v3"
+    exit 1
+fi
+
+# Activer l'environnement
+source venv_v3/bin/activate
+
+echo -e "${YELLOW}[1/3]${NC} Tests unitaires ErrorHandler..."
+pytest tests/unit/test_error_handler.py -v --tb=short
+
+echo ""
+echo -e "${YELLOW}[2/3]${NC} Tests d'intégration récupération d'erreurs..."
+pytest tests/integration/test_error_recovery.py -v --tb=short
+
+echo ""
+echo -e "${YELLOW}[3/3]${NC} Couverture de code..."
+pytest tests/unit/test_error_handler.py tests/integration/test_error_recovery.py \
+    --cov=core/execution/error_handler \
+    --cov=core/execution/action_executor \
+    --cov=core/graph/node_matcher \
+    --cov-report=term-missing
+
+echo ""
+echo "╔══════════════════════════════════════════════════════════════╗"
+echo "║                    ✅ TESTS TERMINÉS                         ║"
+echo "╚══════════════════════════════════════════════════════════════╝"

_a_trier/utilitaires/run_real_documentation_tests.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""
+Real Functionality Test Runner for Documentation System
+
+Demonstrates how to run real functionality tests without mocks:
+- Starts real services
+- Uses real data
+- Tests actual user workflows
+- Validates real system behavior
+"""
+
+import sys
+import time
+from pathlib import Path
+
+# Add current directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent))
+
+from test_documentation_tab_fixed import test_real_documentation_functionality
+from test_documentation_real_utils import RealServiceManager, RealDocumentationData
+
+
+def main():
+    """Run real functionality tests"""
+    print("🚀 REAL FUNCTIONALITY TEST RUNNER")
+    print("=" * 50)
+    print()
+    
+    # Check prerequisites
+    print("🔍 Checking prerequisites...")
+    
+    # Check if Chrome/Chromium is available
+    try:
+        from selenium import webdriver
+        from selenium.webdriver.chrome.options import Options
+        
+        options = Options()
+        options.add_argument("--headless")
+        options.add_argument("--no-sandbox")
+        
+        driver = webdriver.Chrome(options=options)
+        driver.quit()
+        print("   ✅ Chrome WebDriver available")
+    except Exception as e:
+        print(f"   ❌ Chrome WebDriver not available: {e}")
+        print("   Install ChromeDriver: https://chromedriver.chromium.org/")
+        return False
+    
+    # Check if project structure exists
+    backend_dir = Path("visual_workflow_builder/backend")
+    frontend_dir = Path("visual_workflow_builder/frontend")
+    
+    if not backend_dir.exists():
+        print(f"   ❌ Backend directory not found: {backend_dir}")
+        return False
+    
+    if not frontend_dir.exists():
+        print(f"   ❌ Frontend directory not found: {frontend_dir}")
+        return False
+    
+    print("   ✅ Project structure OK")
+    print()
+    
+    # Run real functionality tests
+    print("🧪 Running real functionality tests...")
+    print()
+    
+    try:
+        success = test_real_documentation_functionality()
+        
+        if success:
+            print()
+            print("🎉 ALL REAL FUNCTIONALITY TESTS PASSED!")
+            print()
+            print("Key achievements:")
+            print("✅ Real services started and tested")
+            print("✅ Real API endpoints validated")
+            print("✅ Real data flow verified")
+            print("✅ Real user interactions tested")
+            print("✅ Real content validation passed")
+            return True
+        else:
+            print()
+            print("❌ REAL FUNCTIONALITY TESTS FAILED")
+            print()
+            print("This indicates issues with:")
+            print("• Real service integration")
+            print("• Actual data flow")
+            print("• User interaction patterns")
+            print("• Content loading mechanisms")
+            return False
+            
+    except KeyboardInterrupt:
+        print("\n⏹️ Tests interrupted by user")
+        return False
+    except Exception as e:
+        print(f"\n❌ Test runner error: {e}")
+        return False
+
+
+def demo_real_vs_mock_testing():
+    """Demonstrate the difference between real and mock testing"""
+    print("\n📚 REAL vs MOCK TESTING COMPARISON")
+    print("=" * 40)
+    print()
+    
+    print("🎭 MOCK TESTING (Traditional):")
+    print("• Uses fake/simulated components")
+    print("• Tests isolated units")
+    print("• Fast but may miss integration issues")
+    print("• Example: Mock API responses, fake DOM elements")
+    print()
+    
+    print("🎯 REAL FUNCTIONALITY TESTING (This approach):")
+    print("• Uses actual running services")
+    print("• Tests complete user workflows")
+    print("• Slower but catches real-world issues")
+    print("• Example: Real API calls, actual browser interaction")
+    print()
+    
+    print("🔄 HYBRID APPROACH (Recommended):")
+    print("• Unit tests with mocks for speed")
+    print("• Integration tests with real functionality")
+    print("• End-to-end tests with real user scenarios")
+    print()
+
+
+if __name__ == "__main__":
+    success = main()
+    
+    if "--demo" in sys.argv:
+        demo_real_vs_mock_testing()
+    
+    sys.exit(0 if success else 1)

_a_trier/utilitaires/run_real_upload_functionality_tests.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+"""
+Real Functionality Test Suite for RPA Vision V3 Upload Pipeline
+
+Runs comprehensive tests of the upload functionality using real data,
+real HTTP requests, and actual server processing pipeline.
+
+Tests both authenticated and unauthenticated scenarios to validate
+complete server behavior.
+"""
+
+import subprocess
+import sys
+import time
+import requests
+from pathlib import Path
+
+def check_server_status():
+    """Check if server is running and what endpoints are available"""
+    base_url = "http://127.0.0.1:8000"
+    endpoints_to_check = [
+        "/api/traces/status",
+        "/api/traces/upload", 
+        "/api/traces/queue",
+        "/api/traces/sessions"
+    ]
+    
+    print("🔍 Checking server status...")
+    
+    server_running = False
+    available_endpoints = []
+    
+    for endpoint in endpoints_to_check:
+        try:
+            response = requests.get(f"{base_url}{endpoint}", timeout=3)
+            if response.status_code in [200, 401, 403, 405]:  # Any response means endpoint exists
+                available_endpoints.append(endpoint)
+                server_running = True
+                print(f"  ✅ {endpoint} - Status {response.status_code}")
+            else:
+                print(f"  ❌ {endpoint} - Status {response.status_code}")
+        except requests.exceptions.ConnectionError:
+            print(f"  ❌ {endpoint} - Connection refused")
+        except Exception as e:
+            print(f"  ⚠️  {endpoint} - Error: {e}")
+    
+    return server_running, available_endpoints
+
+def run_test_script(script_name, description):
+    """Run a test script and return success status"""
+    print(f"\n{'='*60}")
+    print(f"🧪 Running: {description}")
+    print(f"Script: {script_name}")
+    print('='*60)
+    
+    try:
+        # Run the test script
+        result = subprocess.run([
+            sys.executable, script_name
+        ], capture_output=False, text=True, timeout=120)
+        
+        success = result.returncode == 0
+        
+        if success:
+            print(f"✅ {description} - PASSED")
+        else:
+            print(f"❌ {description} - FAILED (exit code: {result.returncode})")
+        
+        return success
+        
+    except subprocess.TimeoutExpired:
+        print(f"⏰ {description} - TIMEOUT (>120s)")
+        return False
+    except Exception as e:
+        print(f"💥 {description} - ERROR: {e}")
+        return False
+
+def check_test_files_exist():
+    """Verify all test files exist"""
+    test_files = [
+        "test_simple_upload_no_auth.py",
+        "test_upload_with_auth_real.py"
+    ]
+    
+    missing_files = []
+    for file in test_files:
+        if not Path(file).exists():
+            missing_files.append(file)
+    
+    if missing_files:
+        print(f"❌ Missing test files: {missing_files}")
+        return False
+    
+    print("✅ All test files found")
+    return True
+
+def check_environment_setup():
+    """Check if environment is properly configured"""
+    print("🔧 Checking environment setup...")
+    
+    # Check for environment files
+    env_files = [".env.local", ".env"]
+    env_file_found = False
+    
+    for env_file in env_files:
+        if Path(env_file).exists():
+            print(f"  ✅ Found {env_file}")
+            env_file_found = True
+            break
+    
+    if not env_file_found:
+        print("  ⚠️  No .env files found (authentication tests may fail)")
+    
+    # Check for server files
+    server_files = [
+        "server/api_upload.py",
+        "server/processing_pipeline.py",
+        "core/persistence/storage_manager.py"
+    ]
+    
+    missing_server_files = []
+    for file in server_files:
+        if not Path(file).exists():
+            missing_server_files.append(file)
+    
+    if missing_server_files:
+        print(f"  ⚠️  Missing server files: {missing_server_files}")
+        return False
+    
+    print("  ✅ Server files found")
+    return True
+
+def main():
+    """Run the complete real functionality test suite"""
+    print("🚀 RPA Vision V3 - Real Functionality Test Suite")
+    print("Testing Upload Pipeline with Real Data and Server Integration")
+    print("="*80)
+    
+    # Pre-flight checks
+    print("\n📋 Pre-flight Checks")
+    print("-" * 40)
+    
+    if not check_test_files_exist():
+        print("❌ Cannot proceed without test files")
+        return False
+    
+    if not check_environment_setup():
+        print("⚠️  Environment setup issues detected")
+    
+    # Check server status
+    server_running, available_endpoints = check_server_status()
+    
+    if not server_running:
+        print("\n❌ Server is not running!")
+        print("\nTo start the server:")
+        print("  ./run.sh --server")
+        print("  # or")
+        print("  python server/api_upload.py")
+        print("\nThen run this test suite again.")
+        return False
+    
+    print(f"\n✅ Server is running with {len(available_endpoints)} endpoints available")
+    
+    # Run the test suite
+    print("\n🧪 Running Real Functionality Tests")
+    print("-" * 40)
+    
+    test_results = []
+    
+    # Test 1: Upload without authentication (should be rejected for security)
+    test_results.append(run_test_script(
+        "test_simple_upload_no_auth.py",
+        "Upload without Authentication (Security Test)"
+    ))
+    
+    # Small delay between tests
+    time.sleep(2)
+    
+    # Test 2: Upload with authentication (should succeed if tokens are configured)
+    test_results.append(run_test_script(
+        "test_upload_with_auth_real.py", 
+        "Upload with Authentication (Functionality Test)"
+    ))
+    
+    # Summary
+    print("\n" + "="*80)
+    print("📊 Test Suite Summary")
+    print("="*80)
+    
+    passed_tests = sum(test_results)
+    total_tests = len(test_results)
+    
+    print(f"Tests Passed: {passed_tests}/{total_tests}")
+    
+    if passed_tests == total_tests:
+        print("🎉 ALL TESTS PASSED!")
+        print("The RPA Vision V3 upload pipeline is working correctly.")
+        success = True
+    else:
+        print("❌ SOME TESTS FAILED!")
+        print("Check the individual test outputs above for details.")
+        success = False
+    
+    print("\n📝 Test Details:")
+    test_names = [
+        "Upload without Authentication (Security)",
+        "Upload with Authentication (Functionality)"
+    ]
+    
+    for i, (name, result) in enumerate(zip(test_names, test_results)):
+        status = "✅ PASS" if result else "❌ FAIL"
+        print(f"  {i+1}. {name}: {status}")
+    
+    print("\n💡 Next Steps:")
+    if success:
+        print("  - Upload pipeline is working correctly")
+        print("  - You can now test with real agent_v0 uploads")
+        print("  - Check server logs for processing details")
+    else:
+        print("  - Review failed test outputs above")
+        print("  - Check server configuration and authentication")
+        print("  - Verify environment variables are set correctly")
+        print("  - Check server logs for errors")
+    
+    return success
+
+if __name__ == "__main__":
+    success = main()
+    exit(0 if success else 1)

_a_trier/utilitaires/run_real_upload_test.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""
+Runner script for the real upload authentication test.
+
+This script demonstrates how to run the real functionality test
+and provides helpful output for debugging.
+"""
+
+import subprocess
+import sys
+from pathlib import Path
+
+def check_server_running():
+    """Check if the server is running."""
+    import requests
+    try:
+        response = requests.get("http://127.0.0.1:8000/api/traces/status", timeout=5)
+        return response.status_code == 200
+    except:
+        return False
+
+def main():
+    print("🚀 RPA Vision V3 - Real Upload Authentication Test Runner")
+    print("=" * 60)
+    
+    # Check if server is running
+    if not check_server_running():
+        print("❌ Server is not running!")
+        print("\nTo start the server, run:")
+        print("  python server/api_upload.py")
+        print("  # or")
+        print("  ./run.sh --server")
+        print("\nThen run this test again.")
+        return 1
+    
+    print("✅ Server is running")
+    
+    # Run the test
+    print("\n🧪 Running real functionality test...")
+    try:
+        # Run as pytest
+        result = subprocess.run([
+            sys.executable, "-m", "pytest", 
+            "test_upload_with_hardcoded_token.py::test_real_authentication_upload",
+            "-v", "-s"
+        ], capture_output=False)
+        
+        if result.returncode == 0:
+            print("\n🎉 All tests passed!")
+            return 0
+        else:
+            print("\n❌ Some tests failed.")
+            return result.returncode
+            
+    except KeyboardInterrupt:
+        print("\n⏹️  Test interrupted by user")
+        return 1
+    except Exception as e:
+        print(f"\n💥 Error running test: {e}")
+        
+        # Fallback: run directly
+        print("\n🔄 Trying direct execution...")
+        try:
+            result = subprocess.run([
+                sys.executable, "test_upload_with_hardcoded_token.py"
+            ], capture_output=False)
+            return result.returncode
+        except Exception as e2:
+            print(f"💥 Direct execution also failed: {e2}")
+            return 1
+
+if __name__ == "__main__":
+    exit(main())

_a_trier/utilitaires/validate_circular_imports.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""
+Script de validation des imports circulaires.
+
+Vérifie qu'aucun import circulaire n'existe dans le système.
+
+Auteur: Dom, Alice Kiro
+Date: 20 décembre 2024
+"""
+
+import sys
+import ast
+import os
+from pathlib import Path
+from typing import Dict, Set, List, Tuple
+from collections import defaultdict, deque
+
+
+class ImportAnalyzer(ast.NodeVisitor):
+    """Analyseur d'imports pour un fichier Python"""
+    
+    def __init__(self, module_path: str):
+        self.module_path = module_path
+        self.imports: Set[str] = set()
+        self.from_imports: Set[str] = set()
+    
+    def visit_Import(self, node: ast.Import):
+        """Visite les imports directs (import module)"""
+        for alias in node.names:
+            self.imports.add(alias.name)
+        self.generic_visit(node)
+    
+    def visit_ImportFrom(self, node: ast.ImportFrom):
+        """Visite les imports from (from module import ...)"""
+        if node.module:
+            self.from_imports.add(node.module)
+        self.generic_visit(node)
+
+
+class CircularImportDetector:
+    """Détecteur d'imports circulaires"""
+    
+    def __init__(self, root_path: Path):
+        self.root_path = root_path
+        self.module_graph: Dict[str, Set[str]] = defaultdict(set)
+        self.module_paths: Dict[str, Path] = {}
+    
+    def _get_module_name(self, file_path: Path) -> str:
+        """Convertit un chemin de fichier en nom de module"""
+        relative_path = file_path.relative_to(self.root_path)
+        
+        # Enlever l'extension .py
+        if relative_path.suffix == '.py':
+            relative_path = relative_path.with_suffix('')
+        
+        # Convertir les séparateurs de chemin en points
+        module_name = str(relative_path).replace(os.sep, '.')
+        
+        # Gérer __init__.py
+        if module_name.endswith('.__init__'):
+            module_name = module_name[:-9]  # Enlever .__init__
+        
+        return module_name
+    
+    def _normalize_import(self, import_name: str, current_module: str) -> str:
+        """Normalise un nom d'import (gère les imports relatifs)"""
+        if import_name.startswith('.'):
+            # Import relatif
+            parts = current_module.split('.')
+            level = 0
+            for char in import_name:
+                if char == '.':
+                    level += 1
+                else:
+                    break
+            
+            if level > len(parts):
+                return import_name  # Import invalide, on le garde tel quel
+            
+            base_parts = parts[:-level] if level > 0 else parts
+            relative_part = import_name[level:]
+            
+            if relative_part:
+                return '.'.join(base_parts + [relative_part])
+            else:
+                return '.'.join(base_parts)
+        
+        return import_name
+    
+    def analyze_file(self, file_path: Path) -> None:
+        """Analyse un fichier Python pour extraire ses imports"""
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            tree = ast.parse(content)
+            analyzer = ImportAnalyzer(str(file_path))
+            analyzer.visit(tree)
+            
+            module_name = self._get_module_name(file_path)
+            self.module_paths[module_name] = file_path
+            
+            # Ajouter tous les imports au graphe
+            all_imports = analyzer.imports | analyzer.from_imports
+            
+            for import_name in all_imports:
+                normalized_import = self._normalize_import(import_name, module_name)
+                
+                # Ne considérer que les imports internes (commençant par 'core')
+                if normalized_import.startswith('core'):
+                    self.module_graph[module_name].add(normalized_import)
+        
+        except (SyntaxError, UnicodeDecodeError) as e:
+            print(f"Erreur lors de l'analyse de {file_path}: {e}")
+    
+    def find_cycles(self) -> List[List[str]]:
+        """Trouve tous les cycles dans le graphe d'imports"""
+        cycles = []
+        visited = set()
+        rec_stack = set()
+        path = []
+        
+        def dfs(node: str) -> bool:
+            """DFS pour détecter les cycles"""
+            if node in rec_stack:
+                # Cycle détecté, extraire le cycle
+                cycle_start = path.index(node)
+                cycle = path[cycle_start:] + [node]
+                cycles.append(cycle)
+                return True
+            
+            if node in visited:
+                return False
+            
+            visited.add(node)
+            rec_stack.add(node)
+            path.append(node)
+            
+            for neighbor in self.module_graph.get(node, set()):
+                if dfs(neighbor):
+                    return True
+            
+            rec_stack.remove(node)
+            path.pop()
+            return False
+        
+        # Parcourir tous les nœuds
+        for node in self.module_graph:
+            if node not in visited:
+                dfs(node)
+        
+        return cycles
+    
+    def analyze_directory(self, directory: Path) -> None:
+        """Analyse tous les fichiers Python dans un répertoire"""
+        for py_file in directory.rglob('*.py'):
+            # Ignorer les fichiers de test et les répertoires spéciaux
+            if any(part.startswith('.') for part in py_file.parts):
+                continue
+            if 'test' in str(py_file).lower():
+                continue
+            if '__pycache__' in str(py_file):
+                continue
+            
+            self.analyze_file(py_file)
+
+
+def main():
+    """Fonction principale"""
+    print("🔍 Validation des imports circulaires...")
+    
+    # Chemin racine du projet
+    root_path = Path(__file__).parent
+    core_path = root_path / 'core'
+    
+    if not core_path.exists():
+        print("❌ Répertoire 'core' non trouvé")
+        sys.exit(1)
+    
+    # Analyser tous les fichiers
+    detector = CircularImportDetector(root_path)
+    detector.analyze_directory(core_path)
+    
+    print(f"📊 Analysé {len(detector.module_paths)} modules")
+    print(f"📊 Trouvé {sum(len(deps) for deps in detector.module_graph.values())} dépendances")
+    
+    # Détecter les cycles
+    cycles = detector.find_cycles()
+    
+    if cycles:
+        print(f"\n❌ {len(cycles)} import(s) circulaire(s) détecté(s):")
+        for i, cycle in enumerate(cycles, 1):
+            print(f"\n🔄 Cycle {i}:")
+            for j, module in enumerate(cycle):
+                if j < len(cycle) - 1:
+                    print(f"  {module} → {cycle[j + 1]}")
+                else:
+                    print(f"  {module}")
+        
+        print("\n💡 Solutions suggérées:")
+        print("  1. Utiliser TYPE_CHECKING pour les imports de type")
+        print("  2. Déplacer les imports dans les fonctions (lazy loading)")
+        print("  3. Créer des interfaces abstraites")
+        print("  4. Refactorer pour réduire les dépendances")
+        
+        sys.exit(1)
+    else:
+        print("\n✅ Aucun import circulaire détecté!")
+        print("🎉 Le système respecte les bonnes pratiques d'imports")
+        
+        # Statistiques additionnelles
+        print(f"\n📈 Statistiques:")
+        print(f"  • Modules analysés: {len(detector.module_paths)}")
+        print(f"  • Dépendances totales: {sum(len(deps) for deps in detector.module_graph.values())}")
+        
+        # Modules les plus dépendants
+        most_dependent = sorted(
+            detector.module_graph.items(),
+            key=lambda x: len(x[1]),
+            reverse=True
+        )[:5]
+        
+        if most_dependent:
+            print(f"\n🔗 Modules avec le plus de dépendances:")
+            for module, deps in most_dependent:
+                print(f"  • {module}: {len(deps)} dépendances")
+
+
+if __name__ == "__main__":
+    main()

_a_trier/utilitaires/validate_imports.py

@@ -0,0 +1,214 @@
+#!/usr/bin/env python3
+"""
+Validation des imports pour Fiche #4 - RPA Vision V3
+
+Auteur: Dom, Alice Kiro - 15 décembre 2024
+Objectif: Valider que tous les imports utilisent 'from core...' au lieu de 'from rpa_vision_v3.core...'
+
+Usage:
+    python validate_imports.py              # Validation seule
+    python validate_imports.py --fix        # Correction automatique
+    python validate_imports.py --stats      # Statistiques détaillées
+"""
+import os
+import re
+import sys
+import argparse
+from pathlib import Path
+from typing import List, Tuple, Dict
+
+class ImportValidator:
+    """Validateur d'imports pour la Fiche #4"""
+    
+    def __init__(self):
+        self.bad_pattern = re.compile(r'from rpa_vision_v3\.core')
+        self.good_pattern = re.compile(r'from core\.')
+        self.exclude_dirs = {
+            'venv', 'venv_v3', '__pycache__', '.git', 
+            'node_modules', '.pytest_cache', '.hypothesis',
+            'htmlcov', 'rpa_vision_v3.egg-info'
+        }
+        self.exclude_files = {
+            'validate_imports.py', 'setup.py', 'test_fiche4_imports_stables.py'
+        }
+    
+    def should_skip(self, filepath: Path) -> bool:
+        """Vérifier si on doit ignorer ce fichier/dossier"""
+        # Ignorer les dossiers exclus
+        for part in filepath.parts:
+            if part in self.exclude_dirs:
+                return True
+        
+        # Ignorer les fichiers exclus
+        if filepath.name in self.exclude_files:
+            return True
+            
+        # Ignorer les fichiers non-Python
+        if not filepath.name.endswith('.py'):
+            return True
+            
+        return False
+    
+    def scan_file(self, filepath: Path) -> List[Tuple[int, str]]:
+        """Scanner un fichier pour les imports non-conformes"""
+        bad_imports = []
+        
+        try:
+            with open(filepath, 'r', encoding='utf-8') as f:
+                for line_num, line in enumerate(f, 1):
+                    if self.bad_pattern.search(line):
+                        bad_imports.append((line_num, line.strip()))
+        except (UnicodeDecodeError, PermissionError):
+            # Ignorer les fichiers binaires ou non-accessibles
+            pass
+            
+        return bad_imports
+    
+    def fix_file(self, filepath: Path) -> int:
+        """Corriger les imports dans un fichier"""
+        try:
+            with open(filepath, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            # Compter les remplacements
+            original_content = content
+            content = self.bad_pattern.sub('from core', content)
+            
+            if content != original_content:
+                with open(filepath, 'w', encoding='utf-8') as f:
+                    f.write(content)
+                return content.count('from core') - original_content.count('from core')
+            
+        except (UnicodeDecodeError, PermissionError):
+            pass
+            
+        return 0
+    
+    def validate_all(self) -> Dict[str, List[Tuple[int, str]]]:
+        """Valider tous les fichiers Python"""
+        bad_files = {}
+        
+        for root, dirs, files in os.walk('.'):
+            # Filtrer les dossiers à ignorer
+            dirs[:] = [d for d in dirs if d not in self.exclude_dirs]
+            
+            for file in files:
+                filepath = Path(root) / file
+                
+                if self.should_skip(filepath):
+                    continue
+                
+                bad_imports = self.scan_file(filepath)
+                if bad_imports:
+                    bad_files[str(filepath)] = bad_imports
+        
+        return bad_files
+    
+    def fix_all(self) -> Dict[str, int]:
+        """Corriger tous les fichiers Python"""
+        fixed_files = {}
+        
+        for root, dirs, files in os.walk('.'):
+            # Filtrer les dossiers à ignorer
+            dirs[:] = [d for d in dirs if d not in self.exclude_dirs]
+            
+            for file in files:
+                filepath = Path(root) / file
+                
+                if self.should_skip(filepath):
+                    continue
+                
+                fixes = self.fix_file(filepath)
+                if fixes > 0:
+                    fixed_files[str(filepath)] = fixes
+        
+        return fixed_files
+    
+    def get_stats(self) -> Dict[str, int]:
+        """Obtenir des statistiques sur les imports"""
+        stats = {
+            'total_python_files': 0,
+            'files_with_bad_imports': 0,
+            'total_bad_imports': 0,
+            'files_with_good_imports': 0,
+            'total_good_imports': 0
+        }
+        
+        for root, dirs, files in os.walk('.'):
+            # Filtrer les dossiers à ignorer
+            dirs[:] = [d for d in dirs if d not in self.exclude_dirs]
+            
+            for file in files:
+                filepath = Path(root) / file
+                
+                if self.should_skip(filepath):
+                    continue
+                
+                stats['total_python_files'] += 1
+                
+                try:
+                    with open(filepath, 'r', encoding='utf-8') as f:
+                        content = f.read()
+                    
+                    bad_count = len(self.bad_pattern.findall(content))
+                    good_count = len(self.good_pattern.findall(content))
+                    
+                    if bad_count > 0:
+                        stats['files_with_bad_imports'] += 1
+                        stats['total_bad_imports'] += bad_count
+                    
+                    if good_count > 0:
+                        stats['files_with_good_imports'] += 1
+                        stats['total_good_imports'] += good_count
+                        
+                except (UnicodeDecodeError, PermissionError):
+                    pass
+        
+        return stats
+
+def main():
+    parser = argparse.ArgumentParser(description='Validation imports Fiche #4')
+    parser.add_argument('--fix', action='store_true', help='Corriger automatiquement')
+    parser.add_argument('--stats', action='store_true', help='Afficher statistiques')
+    args = parser.parse_args()
+    
+    validator = ImportValidator()
+    
+    if args.stats:
+        print("📊 Statistiques des imports:")
+        stats = validator.get_stats()
+        for key, value in stats.items():
+            print(f"  {key}: {value}")
+        return
+    
+    if args.fix:
+        print("🔧 Correction automatique des imports...")
+        fixed_files = validator.fix_all()
+        
+        if fixed_files:
+            print(f"✅ {len(fixed_files)} fichiers corrigés:")
+            for filepath, count in fixed_files.items():
+                print(f"  {filepath}: {count} imports corrigés")
+        else:
+            print("✅ Aucune correction nécessaire")
+        return
+    
+    # Validation par défaut
+    print("🔍 Validation des imports...")
+    bad_files = validator.validate_all()
+    
+    if bad_files:
+        print(f"❌ {len(bad_files)} fichiers avec imports non-conformes:")
+        for filepath, bad_imports in bad_files.items():
+            print(f"\n📁 {filepath}:")
+            for line_num, line in bad_imports:
+                print(f"  ligne {line_num}: {line}")
+        
+        print(f"\n💡 Pour corriger automatiquement: python {sys.argv[0]} --fix")
+        sys.exit(1)
+    else:
+        print("✅ Tous les imports sont conformes")
+        sys.exit(0)
+
+if __name__ == "__main__":
+    main()

_a_trier/utilitaires/validate_phase3.sh

@@ -0,0 +1,146 @@
+#!/bin/bash
+
+# Script de validation Phase 3
+# Vérifie que tous les composants sont en place et fonctionnels
+
+echo "=================================================="
+echo "  RPA Vision V3 - Validation Phase 3"
+echo "=================================================="
+echo ""
+
+# Couleurs
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Compteurs
+PASSED=0
+FAILED=0
+
+# Fonction de test
+check_file() {
+    if [ -f "$1" ]; then
+        echo -e "${GREEN}✓${NC} $1"
+        ((PASSED++))
+    else
+        echo -e "${RED}✗${NC} $1 (manquant)"
+        ((FAILED++))
+    fi
+}
+
+check_dir() {
+    if [ -d "$1" ]; then
+        echo -e "${GREEN}✓${NC} $1/"
+        ((PASSED++))
+    else
+        echo -e "${RED}✗${NC} $1/ (manquant)"
+        ((FAILED++))
+    fi
+}
+
+echo "1. Vérification de la structure..."
+echo "-----------------------------------"
+check_dir "rpa_vision_v3/core/detection"
+check_dir "rpa_vision_v3/examples"
+check_dir "rpa_vision_v3/docs"
+check_dir "rpa_vision_v3/tests/unit"
+echo ""
+
+echo "2. Vérification des fichiers core..."
+echo "-------------------------------------"
+check_file "rpa_vision_v3/core/detection/ollama_client.py"
+check_file "rpa_vision_v3/core/detection/ui_detector.py"
+check_file "rpa_vision_v3/core/detection/__init__.py"
+echo ""
+
+echo "3. Vérification des tests..."
+echo "----------------------------"
+check_file "rpa_vision_v3/examples/test_ollama_integration.py"
+check_file "rpa_vision_v3/examples/test_real_vlm_detection.py"
+check_file "rpa_vision_v3/examples/test_hybrid_detection.py"
+check_file "rpa_vision_v3/examples/test_complete_real.py"
+check_file "rpa_vision_v3/examples/diagnostic_vlm.py"
+check_file "rpa_vision_v3/examples/create_test_screenshot.py"
+check_file "rpa_vision_v3/examples/test_quick.sh"
+echo ""
+
+echo "4. Vérification de la documentation..."
+echo "---------------------------------------"
+check_file "rpa_vision_v3/QUICK_START.md"
+check_file "rpa_vision_v3/HYBRID_DETECTION_SUMMARY.md"
+check_file "rpa_vision_v3/PHASE3_COMPLETE.md"
+check_file "rpa_vision_v3/PHASE3_COMPLETE_FINAL.md"
+check_file "rpa_vision_v3/STATUS_UPDATE.md"
+check_file "rpa_vision_v3/EXECUTIVE_SUMMARY.md"
+check_file "rpa_vision_v3/docs/OLLAMA_INTEGRATION.md"
+check_file "rpa_vision_v3/docs/VLM_DETECTION_IMPLEMENTATION.md"
+echo ""
+
+echo "5. Vérification des specs Phase 4..."
+echo "-------------------------------------"
+echo "⏳ Specs Phase 4 à créer (prochaine étape)"
+echo ""
+
+echo "6. Test de disponibilité Ollama..."
+echo "-----------------------------------"
+if curl -s http://localhost:11434/api/tags > /dev/null 2>&1; then
+    echo -e "${GREEN}✓${NC} Ollama est accessible"
+    ((PASSED++))
+    
+    # Vérifier si qwen3-vl:8b est disponible
+    if curl -s http://localhost:11434/api/tags | grep -q "qwen3-vl:8b"; then
+        echo -e "${GREEN}✓${NC} qwen3-vl:8b est installé"
+        ((PASSED++))
+    else
+        echo -e "${YELLOW}⚠${NC} qwen3-vl:8b n'est pas installé"
+        echo "   Installer avec: ollama pull qwen3-vl:8b"
+        ((FAILED++))
+    fi
+else
+    echo -e "${RED}✗${NC} Ollama n'est pas accessible"
+    echo "   Démarrer avec: ollama serve"
+    ((FAILED++))
+fi
+echo ""
+
+echo "7. Test Python imports..."
+echo "-------------------------"
+cd rpa_vision_v3
+if python3 -c "from core.detection.ollama_client import OllamaClient" 2>/dev/null; then
+    echo -e "${GREEN}✓${NC} OllamaClient importable"
+    ((PASSED++))
+else
+    echo -e "${RED}✗${NC} Erreur import OllamaClient"
+    ((FAILED++))
+fi
+
+if python3 -c "from core.detection.ui_detector import UIDetector" 2>/dev/null; then
+    echo -e "${GREEN}✓${NC} UIDetector importable"
+    ((PASSED++))
+else
+    echo -e "${RED}✗${NC} Erreur import UIDetector"
+    ((FAILED++))
+fi
+cd ..
+echo ""
+
+echo "=================================================="
+echo "  Résultats"
+echo "=================================================="
+echo -e "Tests réussis: ${GREEN}${PASSED}${NC}"
+echo -e "Tests échoués: ${RED}${FAILED}${NC}"
+echo ""
+
+if [ $FAILED -eq 0 ]; then
+    echo -e "${GREEN}✓ Phase 3 validée avec succès !${NC}"
+    echo ""
+    echo "Prochaines étapes:"
+    echo "  1. Tester avec: cd rpa_vision_v3/examples && bash test_quick.sh"
+    echo "  2. Diagnostic: python3 diagnostic_vlm.py"
+    echo "  3. Phase 4: Implémenter mode asynchrone"
+    exit 0
+else
+    echo -e "${RED}✗ Validation échouée. Corriger les erreurs ci-dessus.${NC}"
+    exit 1
+fi

_a_trier/utilitaires/validate_screenshots.sh

@@ -0,0 +1,70 @@
+#!/bin/bash
+# Script de validation des screenshots après capture
+
+echo "🔍 Validation des Screenshots"
+echo "=============================="
+echo ""
+
+# Trouver la dernière session
+LATEST_SESSION=$(find /opt/rpa_vision_v3/data/training/sessions -maxdepth 2 -name "sess_*" -type d | sort -r | head -1)
+
+if [ -z "$LATEST_SESSION" ]; then
+    echo "❌ Aucune session trouvée"
+    exit 1
+fi
+
+echo "📁 Session trouvée: $(basename $LATEST_SESSION)"
+echo ""
+
+# Vérifier le répertoire shots
+SHOTS_DIR="${LATEST_SESSION}/shots"
+if [ -d "$SHOTS_DIR" ]; then
+    SHOT_COUNT=$(ls -1 "$SHOTS_DIR"/*.png 2>/dev/null | wc -l)
+    echo "✅ Répertoire shots/ existe"
+    echo "📸 Screenshots trouvés: $SHOT_COUNT fichiers"
+
+    if [ $SHOT_COUNT -gt 0 ]; then
+        echo ""
+        echo "📋 Liste des screenshots:"
+        ls -lh "$SHOTS_DIR"/*.png | awk '{print "  - " $9 " (" $5 ")"}'
+
+        # Calculer la taille totale
+        TOTAL_SIZE=$(du -sh "$SHOTS_DIR" | awk '{print $1}')
+        echo ""
+        echo "💾 Taille totale: $TOTAL_SIZE"
+        echo ""
+        echo "✅ SUCCÈS: Les screenshots sont bien conservés après traitement"
+    else
+        echo "❌ ÉCHEC: Le répertoire existe mais est vide"
+        exit 1
+    fi
+else
+    echo "❌ ÉCHEC: Le répertoire shots/ n'existe pas"
+    echo "   Attendu: $SHOTS_DIR"
+    exit 1
+fi
+
+# Vérifier le JSON
+JSON_FILE=$(find /opt/rpa_vision_v3/data/training/sessions -name "session_$(basename $LATEST_SESSION).json" | head -1)
+if [ -f "$JSON_FILE" ]; then
+    echo "✅ Fichier JSON trouvé: $(basename $JSON_FILE)"
+
+    # Compter les screenshots dans le JSON
+    JSON_SHOT_COUNT=$(grep -o '"screenshot_id"' "$JSON_FILE" | wc -l)
+    echo "📊 Screenshots référencés dans JSON: $JSON_SHOT_COUNT"
+
+    if [ $SHOT_COUNT -eq $JSON_SHOT_COUNT ]; then
+        echo "✅ Cohérence JSON ↔ Fichiers: OK"
+    else
+        echo "⚠️  Attention: Différence entre JSON ($JSON_SHOT_COUNT) et fichiers ($SHOT_COUNT)"
+    fi
+else
+    echo "⚠️  Fichier JSON non trouvé"
+fi
+
+echo ""
+echo "🎯 Résumé:"
+echo "  - Session: $(basename $LATEST_SESSION)"
+echo "  - Screenshots: $SHOT_COUNT fichiers conservés"
+echo "  - Taille: $TOTAL_SIZE"
+echo "  - Statut: ✅ Nettoyage prématuré DÉSACTIVÉ avec succès"

_a_trier/utilitaires/verifier_zip_vwb.py

@@ -0,0 +1,375 @@
+#!/usr/bin/env python3
+"""
+Script de vérification du ZIP VWB propre
+Auteur : Dom, Alice, Kiro - 8 janvier 2026
+"""
+
+import zipfile
+import os
+import json
+import tempfile
+import shutil
+
+class VerificateurZipVWB:
+    """Classe pour vérifier la qualité du ZIP VWB"""
+    
+    def __init__(self, nom_zip):
+        self.nom_zip = nom_zip
+        self.dossier_temp = None
+        self.resultats = {}
+    
+    def extraire_zip_temporaire(self):
+        """Extraire le ZIP dans un dossier temporaire"""
+        self.dossier_temp = tempfile.mkdtemp(prefix="verif_vwb_")
+        
+        with zipfile.ZipFile(self.nom_zip, 'r') as zipf:
+            zipf.extractall(self.dossier_temp)
+        
+        print(f"📁 ZIP extrait dans: {self.dossier_temp}")
+        return True
+    
+    def verifier_structure_generale(self):
+        """Vérifier la structure générale du projet"""
+        print("🏗️  Vérification de la structure...")
+        
+        dossiers_requis = [
+            "visual_workflow_builder",
+            "visual_workflow_builder/backend",
+            "visual_workflow_builder/frontend",
+            "visual_workflow_builder/backend/api",
+            "visual_workflow_builder/frontend/src",
+            "visual_workflow_builder/frontend/src/components",
+        ]
+        
+        fichiers_requis = [
+            "README.md",
+            "version.json",
+            "diagnostic_backend_complet.py",
+            "demarrer_backend_propre.py",
+            "test_systeme_complet.py",
+            "visual_workflow_builder/backend/app.py",
+            "visual_workflow_builder/frontend/package.json",
+        ]
+        
+        structure_ok = True
+        
+        # Vérifier les dossiers
+        for dossier in dossiers_requis:
+            chemin = os.path.join(self.dossier_temp, dossier)
+            if os.path.exists(chemin):
+                print(f"   ✅ Dossier: {dossier}")
+            else:
+                print(f"   ❌ Dossier manquant: {dossier}")
+                structure_ok = False
+        
+        # Vérifier les fichiers
+        for fichier in fichiers_requis:
+            chemin = os.path.join(self.dossier_temp, fichier)
+            if os.path.exists(chemin):
+                print(f"   ✅ Fichier: {fichier}")
+            else:
+                print(f"   ❌ Fichier manquant: {fichier}")
+                structure_ok = False
+        
+        self.resultats['structure'] = structure_ok
+        return structure_ok
+    
+    def verifier_conformite_attribution(self):
+        """Vérifier la conformité de l'attribution"""
+        print("👥 Vérification de l'attribution...")
+        
+        fichiers_python = []
+        fichiers_typescript = []
+        fichiers_css = []
+        
+        # Parcourir tous les fichiers
+        for root, dirs, files in os.walk(self.dossier_temp):
+            for file in files:
+                chemin_complet = os.path.join(root, file)
+                extension = os.path.splitext(file)[1].lower()
+                
+                if extension == '.py':
+                    fichiers_python.append(chemin_complet)
+                elif extension in ['.ts', '.tsx']:
+                    fichiers_typescript.append(chemin_complet)
+                elif extension == '.css':
+                    fichiers_css.append(chemin_complet)
+        
+        conformes = 0
+        total = 0
+        
+        # Vérifier les fichiers Python
+        for fichier in fichiers_python:
+            total += 1
+            try:
+                with open(fichier, 'r', encoding='utf-8') as f:
+                    contenu = f.read()
+                
+                if ('Auteur : Dom, Alice, Kiro' in contenu or 'Auteur: Dom, Alice, Kiro' in contenu) and '8 janvier 2026' in contenu:
+                    conformes += 1
+                    print(f"   ✅ {os.path.relpath(fichier, self.dossier_temp)}")
+                else:
+                    print(f"   ❌ {os.path.relpath(fichier, self.dossier_temp)}")
+            except:
+                print(f"   ⚠️  Erreur lecture: {os.path.relpath(fichier, self.dossier_temp)}")
+        
+        # Vérifier les fichiers TypeScript
+        for fichier in fichiers_typescript:
+            total += 1
+            try:
+                with open(fichier, 'r', encoding='utf-8') as f:
+                    contenu = f.read()
+                
+                if 'Auteur : Dom, Alice, Kiro' in contenu and '8 janvier 2026' in contenu:
+                    conformes += 1
+                    print(f"   ✅ {os.path.relpath(fichier, self.dossier_temp)}")
+                else:
+                    print(f"   ❌ {os.path.relpath(fichier, self.dossier_temp)}")
+            except:
+                print(f"   ⚠️  Erreur lecture: {os.path.relpath(fichier, self.dossier_temp)}")
+        
+        # Vérifier les fichiers CSS
+        for fichier in fichiers_css:
+            total += 1
+            try:
+                with open(fichier, 'r', encoding='utf-8') as f:
+                    contenu = f.read()
+                
+                if 'Auteur : Dom, Alice, Kiro' in contenu and '8 janvier 2026' in contenu:
+                    conformes += 1
+                    print(f"   ✅ {os.path.relpath(fichier, self.dossier_temp)}")
+                else:
+                    print(f"   ❌ {os.path.relpath(fichier, self.dossier_temp)}")
+            except:
+                print(f"   ⚠️  Erreur lecture: {os.path.relpath(fichier, self.dossier_temp)}")
+        
+        taux_conformite = (conformes / total) * 100 if total > 0 else 100
+        print(f"   📊 Conformité attribution: {conformes}/{total} ({taux_conformite:.1f}%)")
+        
+        self.resultats['attribution'] = taux_conformite >= 80
+        return taux_conformite >= 80
+    
+    def verifier_version_info(self):
+        """Vérifier les informations de version"""
+        print("📋 Vérification des informations de version...")
+        
+        chemin_version = os.path.join(self.dossier_temp, "version.json")
+        
+        if not os.path.exists(chemin_version):
+            print("   ❌ Fichier version.json manquant")
+            self.resultats['version'] = False
+            return False
+        
+        try:
+            with open(chemin_version, 'r', encoding='utf-8') as f:
+                version_data = json.load(f)
+            
+            champs_requis = ['version', 'date_creation', 'auteurs', 'description', 'conformite']
+            
+            for champ in champs_requis:
+                if champ in version_data:
+                    print(f"   ✅ {champ}: {version_data[champ]}")
+                else:
+                    print(f"   ❌ Champ manquant: {champ}")
+                    self.resultats['version'] = False
+                    return False
+            
+            # Vérifier la conformité
+            conformite = version_data.get('conformite', {})
+            if conformite.get('langue') == 'français' and conformite.get('tests_reels') == True:
+                print("   ✅ Conformité française validée")
+                self.resultats['version'] = True
+                return True
+            else:
+                print("   ❌ Conformité française non validée")
+                self.resultats['version'] = False
+                return False
+                
+        except json.JSONDecodeError as e:
+            print(f"   ❌ Erreur JSON: {e}")
+            self.resultats['version'] = False
+            return False
+    
+    def verifier_readme(self):
+        """Vérifier le README principal"""
+        print("📄 Vérification du README...")
+        
+        chemin_readme = os.path.join(self.dossier_temp, "README.md")
+        
+        if not os.path.exists(chemin_readme):
+            print("   ❌ README.md manquant")
+            self.resultats['readme'] = False
+            return False
+        
+        try:
+            with open(chemin_readme, 'r', encoding='utf-8') as f:
+                contenu = f.read()
+            
+            elements_requis = [
+                "Visual Workflow Builder",
+                "Auteur : Dom, Alice, Kiro",
+                "8 janvier 2026",
+                "Démarrage rapide",
+                "Backend",
+                "Frontend",
+                "Tests",
+            ]
+            
+            elements_presents = 0
+            for element in elements_requis:
+                if element in contenu:
+                    elements_presents += 1
+                    print(f"   ✅ {element}")
+                else:
+                    print(f"   ❌ Manquant: {element}")
+            
+            taux_completude = (elements_presents / len(elements_requis)) * 100
+            print(f"   📊 Complétude README: {elements_presents}/{len(elements_requis)} ({taux_completude:.1f}%)")
+            
+            self.resultats['readme'] = taux_completude >= 80
+            return taux_completude >= 80
+            
+        except Exception as e:
+            print(f"   ❌ Erreur lecture README: {e}")
+            self.resultats['readme'] = False
+            return False
+    
+    def compter_fichiers_par_type(self):
+        """Compter les fichiers par type"""
+        print("📊 Statistiques des fichiers...")
+        
+        compteurs = {
+            'python': 0,
+            'typescript': 0,
+            'css': 0,
+            'json': 0,
+            'markdown': 0,
+            'autres': 0
+        }
+        
+        for root, dirs, files in os.walk(self.dossier_temp):
+            for file in files:
+                extension = os.path.splitext(file)[1].lower()
+                
+                if extension == '.py':
+                    compteurs['python'] += 1
+                elif extension in ['.ts', '.tsx']:
+                    compteurs['typescript'] += 1
+                elif extension == '.css':
+                    compteurs['css'] += 1
+                elif extension == '.json':
+                    compteurs['json'] += 1
+                elif extension == '.md':
+                    compteurs['markdown'] += 1
+                else:
+                    compteurs['autres'] += 1
+        
+        total = sum(compteurs.values())
+        
+        for type_fichier, count in compteurs.items():
+            pourcentage = (count / total) * 100 if total > 0 else 0
+            print(f"   📁 {type_fichier.capitalize()}: {count} fichiers ({pourcentage:.1f}%)")
+        
+        print(f"   📈 Total: {total} fichiers")
+        return compteurs
+    
+    def generer_rapport_final(self):
+        """Générer le rapport final de vérification"""
+        print("\n" + "=" * 60)
+        print("📊 RAPPORT DE VÉRIFICATION DU ZIP VWB")
+        print("=" * 60)
+        
+        tests_reussis = sum(1 for resultat in self.resultats.values() if resultat)
+        total_tests = len(self.resultats)
+        taux_reussite = (tests_reussis / total_tests) * 100 if total_tests > 0 else 0
+        
+        print(f"📈 Résultats: {tests_reussis}/{total_tests} ({taux_reussite:.1f}%)")
+        print("\n📋 Détail des vérifications:")
+        
+        for test, resultat in self.resultats.items():
+            icone = "✅" if resultat else "❌"
+            print(f"   {icone} {test.replace('_', ' ').title()}")
+        
+        # Déterminer la qualité
+        if taux_reussite == 100:
+            qualite = "🏆 EXCELLENTE - ZIP parfaitement conforme"
+            code_sortie = 0
+        elif taux_reussite >= 80:
+            qualite = "✅ BONNE - ZIP majoritairement conforme"
+            code_sortie = 0
+        elif taux_reussite >= 60:
+            qualite = "⚠️  ACCEPTABLE - Quelques améliorations nécessaires"
+            code_sortie = 1
+        else:
+            qualite = "❌ INSUFFISANTE - Corrections majeures requises"
+            code_sortie = 2
+        
+        print(f"\n🎯 QUALITÉ GLOBALE: {qualite}")
+        
+        # Informations sur le ZIP
+        taille_zip = os.path.getsize(self.nom_zip)
+        taille_mb = taille_zip / (1024 * 1024)
+        print(f"\n📦 Informations ZIP:")
+        print(f"   📁 Nom: {self.nom_zip}")
+        print(f"   📏 Taille: {taille_mb:.2f} MB")
+        
+        return code_sortie
+    
+    def nettoyer_dossier_temp(self):
+        """Nettoyer le dossier temporaire"""
+        if self.dossier_temp and os.path.exists(self.dossier_temp):
+            shutil.rmtree(self.dossier_temp)
+            print(f"🧹 Dossier temporaire supprimé")
+    
+    def executer_verification_complete(self):
+        """Exécuter la vérification complète"""
+        print("🔍 VÉRIFICATION COMPLÈTE DU ZIP VWB")
+        print("=" * 50)
+        
+        if not os.path.exists(self.nom_zip):
+            print(f"❌ Fichier ZIP introuvable: {self.nom_zip}")
+            return 1
+        
+        try:
+            # Extraire le ZIP
+            self.extraire_zip_temporaire()
+            
+            # Exécuter les vérifications
+            self.verifier_structure_generale()
+            self.verifier_conformite_attribution()
+            self.verifier_version_info()
+            self.verifier_readme()
+            self.compter_fichiers_par_type()
+            
+            # Générer le rapport
+            code_sortie = self.generer_rapport_final()
+            
+            return code_sortie
+            
+        except Exception as e:
+            print(f"💥 Erreur critique: {e}")
+            return 3
+        finally:
+            self.nettoyer_dossier_temp()
+
+def main():
+    """Fonction principale"""
+    import sys
+    
+    if len(sys.argv) != 2:
+        print("Usage: python3 verifier_zip_vwb.py <nom_du_zip>")
+        return 1
+    
+    nom_zip = sys.argv[1]
+    verificateur = VerificateurZipVWB(nom_zip)
+    
+    try:
+        return verificateur.executer_verification_complete()
+    except KeyboardInterrupt:
+        print("\n⚠️  Vérification interrompue")
+        verificateur.nettoyer_dossier_temp()
+        return 2
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(main())

_a_trier/utilitaires/verify_capture_system.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""
+Vérification automatique du système de capture d'écran
+Exécuté automatiquement par run.sh pour garantir que tout fonctionne
+"""
+
+import sys
+import logging
+
+# Configuration du logging
+logging.basicConfig(level=logging.INFO, format='%(message)s')
+logger = logging.getLogger(__name__)
+
+
+def verify_imports():
+    """Vérifier que tous les imports nécessaires fonctionnent"""
+    logger.info("Vérification des imports...")
+    
+    try:
+        import numpy as np
+        logger.info("  ✓ numpy")
+    except ImportError as e:
+        logger.error(f"  ✗ numpy: {e}")
+        return False
+    
+    try:
+        import mss
+        logger.info("  ✓ mss")
+    except ImportError:
+        logger.warning("  ⚠ mss non disponible (fallback vers pyautogui)")
+        try:
+            import pyautogui
+            logger.info("  ✓ pyautogui (fallback)")
+        except ImportError as e:
+            logger.error(f"  ✗ Aucune bibliothèque de capture disponible: {e}")
+            return False
+    
+    try:
+        import pygetwindow
+        logger.info("  ✓ pygetwindow")
+    except (ImportError, NotImplementedError) as e:
+        logger.warning("  ⚠ pygetwindow non disponible (détection de fenêtre désactivée)")
+        logger.debug(f"    Raison: {e}")
+    
+    return True
+
+
+def verify_screen_capturer():
+    """Vérifier que ScreenCapturer fonctionne"""
+    logger.info("\nVérification de ScreenCapturer...")
+    
+    try:
+        from core.capture.screen_capturer import ScreenCapturer
+        logger.info("  ✓ Import réussi")
+    except ImportError as e:
+        logger.error(f"  ✗ Impossible d'importer ScreenCapturer: {e}")
+        return False
+    
+    try:
+        capturer = ScreenCapturer()
+        logger.info(f"  ✓ Initialisation réussie (méthode: {capturer.method})")
+    except Exception as e:
+        logger.error(f"  ✗ Échec d'initialisation: {e}")
+        return False
+    
+    try:
+        img = capturer.capture()
+        if img is not None:
+            logger.info(f"  ✓ Capture réussie: {img.shape}")
+            return True
+        else:
+            logger.error("  ✗ Capture a retourné None")
+            return False
+    except Exception as e:
+        logger.error(f"  ✗ Échec de capture: {e}")
+        return False
+
+
+def main():
+    """Fonction principale de vérification"""
+    logger.info("="*60)
+    logger.info("VÉRIFICATION DU SYSTÈME DE CAPTURE D'ÉCRAN")
+    logger.info("="*60)
+    
+    # Vérifier les imports
+    if not verify_imports():
+        logger.error("\n✗ Échec de vérification des imports")
+        logger.error("Installez les dépendances: pip install mss pygetwindow")
+        return 1
+    
+    # Vérifier ScreenCapturer
+    if not verify_screen_capturer():
+        logger.error("\n✗ Échec de vérification de ScreenCapturer")
+        return 1
+    
+    logger.info("\n" + "="*60)
+    logger.info("✓ SYSTÈME DE CAPTURE OPÉRATIONNEL")
+    logger.info("="*60)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_a_trier/utilitaires/verify_imports.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""
+Script de vérification des imports pour rpa_vision_v3
+"""
+
+import sys
+
+def test_imports():
+    """Teste les imports principaux du projet"""
+    
+    print("=" * 60)
+    print("VÉRIFICATION DES IMPORTS - RPA VISION V3")
+    print("=" * 60)
+    print()
+    
+    errors = []
+    
+    # Test 1: Import de raw_session
+    print("Test 1: Import de raw_session...")
+    try:
+        from core.models.raw_session import (
+            RawSession,
+            Event,
+            Screenshot,
+            WindowContext
+        )
+        print("  ✓ Import réussi: RawSession, Event, Screenshot, WindowContext")
+    except ImportError as e:
+        print(f"  ✗ Échec: {e}")
+        errors.append(("raw_session", str(e)))
+    
+    # Résumé
+    print()
+    print("=" * 60)
+    print("RÉSUMÉ")
+    print("=" * 60)
+    
+    if not errors:
+        print("✓ Tous les imports fonctionnent correctement!")
+        return 0
+    else:
+        print(f"✗ {len(errors)} erreur(s) détectée(s)")
+        print()
+        print("SOLUTION: Installer le package en mode développement:")
+        print("  cd rpa_vision_v3")
+        print("  pip install -e .")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(test_imports())

_a_trier/utilitaires/verify_models.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+"""
+Script de vérification de l'état réel des modèles dans RPA Vision V3.
+Vérifie si les modèles de l'architecture de référence sont bien utilisés.
+"""
+
+import sys
+from pathlib import Path
+
+print("=" * 70)
+print("  Vérification des Modèles - RPA Vision V3")
+print("=" * 70)
+print()
+
+# 1. Vérifier OpenCLIP
+print("1. OpenCLIP (Embeddings)")
+try:
+    import open_clip
+    print("   ✅ Module open_clip installé")
+    
+    # Vérifier si utilisé dans StateEmbeddingBuilder
+    builder_path = Path(__file__).parent / "core/embedding/state_embedding_builder.py"
+    if builder_path.exists():
+        content = builder_path.read_text()
+        if "clip" in content.lower() or "CLIPEmbedder" in content:
+            print("   ✅ OpenCLIP utilisé dans StateEmbeddingBuilder")
+        else:
+            print("   ❌ OpenCLIP NON utilisé dans StateEmbeddingBuilder")
+            print("      → Utilise des vecteurs aléatoires actuellement")
+    else:
+        print("   ⚠️  StateEmbeddingBuilder non trouvé")
+except ImportError:
+    print("   ❌ Module open_clip NON installé")
+
+print()
+
+# 2. Vérifier OWL-v2
+print("2. OWL-v2 (Détection UI)")
+try:
+    from transformers import Owlv2Processor, Owlv2ForObjectDetection
+    print("   ✅ Module OWL-v2 installé")
+    
+    # Vérifier si utilisé dans UIDetector
+    detector_path = Path(__file__).parent / "core/detection/ui_detector.py"
+    if detector_path.exists():
+        content = detector_path.read_text()
+        if "owl" in content.lower() or "Owlv2" in content:
+            print("   ✅ OWL-v2 utilisé dans UIDetector")
+        else:
+            print("   ❌ OWL-v2 NON utilisé dans UIDetector")
+            print("      → Utilise OpenCV + Qwen3-VL actuellement")
+    else:
+        print("   ⚠️  UIDetector non trouvé")
+except ImportError:
+    print("   ❌ Module OWL-v2 NON installé")
+
+print()
+
+# 3. Vérifier Qwen3-VL
+print("3. Qwen3-VL (Raisonnement Visuel)")
+import subprocess
+try:
+    result = subprocess.run(
+        ["ollama", "list"],
+        capture_output=True,
+        text=True,
+        timeout=5
+    )
+    if "qwen3-vl" in result.stdout:
+        print("   ✅ Qwen3-VL installé via Ollama")
+        
+        # Vérifier si utilisé dans UIDetector
+        detector_path = Path(__file__).parent / "core/detection/ui_detector.py"
+        if detector_path.exists():
+            content = detector_path.read_text()
+            if "qwen3-vl" in content.lower() or "qwen" in content.lower():
+                print("   ✅ Qwen3-VL utilisé dans UIDetector")
+            else:
+                print("   ❌ Qwen3-VL NON utilisé dans UIDetector")
+        else:
+            print("   ⚠️  UIDetector non trouvé")
+    else:
+        print("   ❌ Qwen3-VL NON installé")
+        print("      → Installer avec: ollama pull qwen3-vl:8b")
+except (subprocess.TimeoutExpired, FileNotFoundError):
+    print("   ❌ Ollama non disponible")
+    print("      → Installer avec: curl -fsSL https://ollama.com/install.sh | sh")
+
+print()
+print("=" * 70)
+print("  Résumé")
+print("=" * 70)
+print()
+print("Architecture de Référence:")
+print("  - OpenCLIP : Pour embeddings image/texte")
+print("  - OWL-v2 : Pour détection UI (optionnel)")
+print("  - Qwen3-VL : Pour classification et raisonnement")
+print()
+print("État Actuel:")
+print("  - OpenCLIP : Installé mais NON intégré dans StateEmbeddingBuilder")
+print("  - OWL-v2 : Installé mais NON utilisé (remplacé par OpenCV)")
+print("  - Qwen3-VL : Installé et utilisé dans UIDetector ✅")
+print()
+print("Actions Nécessaires:")
+print("  1. Intégrer OpenCLIP dans StateEmbeddingBuilder")
+print("  2. (Optionnel) Intégrer OWL-v2 dans UIDetector")
+print("  3. Tester le pipeline complet avec vrais modèles")
+print()

_a_trier/utilitaires/verify_thinking_mode.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""
+Script de vérification du mode thinking d'Ollama
+
+Vérifie que le thinking mode est bien désactivé pour optimiser les performances.
+"""
+
+import asyncio
+import aiohttp
+import requests
+import time
+
+
+async def test_thinking_mode_disabled():
+    """Test que le thinking mode est désactivé."""
+    print("🔍 Vérification du mode thinking...")
+    
+    endpoint = "http://localhost:11434"
+    
+    # Vérifier que Ollama est disponible
+    try:
+        response = requests.get(f"{endpoint}/api/tags", timeout=5)
+        if response.status_code != 200:
+            print("❌ Ollama non disponible")
+            return False
+    except Exception as e:
+        print(f"❌ Ollama non disponible: {e}")
+        return False
+    
+    print("✅ Ollama disponible")
+    
+    # Test avec /nothink (méthode officielle Qwen3)
+    payload = {
+        "model": "qwen3-vl:8b",
+        "prompt": "/nothink What is 2+2? Answer with just the number.",
+        "stream": False,
+        "options": {
+            "temperature": 0.0,
+            "num_predict": 50
+        }
+    }
+    
+    print(f"📤 Envoi requête avec /nothink...")
+    start_time = time.time()
+    
+    try:
+        response = requests.post(
+            f"{endpoint}/api/generate",
+            json=payload,
+            timeout=30
+        )
+        
+        elapsed = time.time() - start_time
+        
+        if response.status_code == 200:
+            data = response.json()
+            response_text = data.get("response", "")
+            
+            # Vérifier qu'il n'y a pas de balises de thinking
+            thinking_indicators = [
+                "<thinking>",
+                "</thinking>", 
+                "<think>",
+                "</think>",
+                "Let me think",
+                "I need to think"
+            ]
+            
+            has_thinking = any(indicator.lower() in response_text.lower() 
+                             for indicator in thinking_indicators)
+            
+            if has_thinking:
+                print(f"⚠️  Thinking mode détecté dans la réponse!")
+                print(f"   Réponse: {response_text[:200]}...")
+                return False
+            else:
+                print(f"✅ Thinking mode désactivé")
+                print(f"   Réponse: '{response_text.strip()}'")
+                print(f"   Temps: {elapsed:.2f}s")
+                print(f"   Tokens: {data.get('eval_count', 0)}")
+                return True
+        else:
+            print(f"❌ Erreur HTTP: {response.status_code}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Erreur: {e}")
+        return False
+
+
+def test_ollama_manager_options():
+    """Vérifier que OllamaManager utilise les bonnes options."""
+    print("\n⚙️  Vérification des options dans OllamaManager...")
+    
+    try:
+        from core.gpu.ollama_manager import OllamaManager
+        
+        # Lire le code source pour vérifier les options
+        import inspect
+        source = inspect.getsource(OllamaManager.load_model)
+        
+        if '/nothink' in source or 'nothink' in source:
+            print("✅ OllamaManager.load_model() utilise /nothink")
+        else:
+            print("⚠️  OllamaManager.load_model() n'utilise pas /nothink")
+            return False
+            
+        return True
+        
+    except Exception as e:
+        print(f"❌ Erreur: {e}")
+        return False
+
+
+def test_ollama_client_options():
+    """Vérifier que OllamaClient utilise les bonnes options."""
+    print("\n⚙️  Vérification des options dans OllamaClient...")
+    
+    try:
+        from core.detection.ollama_client import OllamaClient
+        
+        # Lire le code source pour vérifier les options
+        import inspect
+        source = inspect.getsource(OllamaClient.generate)
+        
+        if '/nothink' in source or 'nothink' in source:
+            print("✅ OllamaClient.generate() utilise /nothink")
+            return True
+        else:
+            print("⚠️  OllamaClient.generate() n'utilise pas /nothink")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Erreur: {e}")
+        return False
+
+
+def main():
+    """Test principal."""
+    print("🚀 Test de désactivation du thinking mode Ollama\n")
+    
+    results = []
+    
+    # Test 1: Vérifier les options dans le code
+    results.append(("OllamaManager options", test_ollama_manager_options()))
+    results.append(("OllamaClient options", test_ollama_client_options()))
+    
+    # Test 2: Vérifier thinking mode en pratique
+    thinking_ok = asyncio.run(test_thinking_mode_disabled())
+    results.append(("Thinking mode désactivé", thinking_ok))
+    
+    print("\n📊 Résultats:")
+    all_ok = True
+    for name, ok in results:
+        status = "✅" if ok else "❌"
+        print(f"   {status} {name}")
+        if not ok:
+            all_ok = False
+    
+    if all_ok:
+        print("\n🎉 Tous les tests passent - Ollama optimisé !")
+    else:
+        print("\n⚠️  Certains tests ont échoué")
+    
+    return all_ok
+
+
+if __name__ == "__main__":
+    success = main()
+    exit(0 if success else 1)