Initial commit

.kiro/specs/faiss-learning-fix/design.md

@@ -0,0 +1,495 @@
+# Design Document - Correction Système d'Apprentissage FAISS
+
+## Overview
+
+Ce document décrit l'architecture de correction pour résoudre les problèmes critiques du système d'apprentissage RPA Vision V2. Après 3 jours de tests, le système ne génère aucune suggestion car l'index FAISS n'est jamais construit à partir des tâches sauvegardées. De plus, des processus zombies consomment 3GB+ RAM et l'application ne s'arrête pas proprement.
+
+### Problèmes Identifiés
+
+1. **Index FAISS vide** : L'index n'est jamais chargé au démarrage ni reconstruit à partir des tâches existantes
+2. **Pas de chargement des tâches** : Les 19+ tâches sauvegardées ne sont jamais chargées dans l'index
+3. **Processus zombies** : Les listeners pynput ne sont pas arrêtés proprement
+4. **Fuite mémoire** : Boucles infinies et tensors GPU non libérés
+5. **Pas de diagnostic** : Aucun outil pour comprendre l'état du système
+
+### Solution Proposée
+
+1. **Chargement automatique au démarrage** : Scanner et indexer toutes les tâches existantes
+2. **Reconstruction d'index** : Commande pour reconstruire l'index à partir des tâches
+3. **Arrêt propre** : Gestion correcte des threads et listeners
+4. **Gestion mémoire** : Libération des ressources et circuit breakers
+5. **Diagnostic complet** : Outil d'analyse de l'état du système
+
+## Architecture
+
+### Composants Modifiés
+
+1. **EmbeddingsManager** : Ajout de méthodes de reconstruction et chargement
+2. **LearningManager** : Chargement automatique des tâches au démarrage
+3. **Orchestrator** : Arrêt propre des threads et listeners
+4. **main.py** : Initialisation avec chargement des tâches existantes
+
+### Nouveaux Composants
+
+1. **FAISSIndexBuilder** : Construction et reconstruction de l'index
+2. **SystemDiagnostic** : Diagnostic complet du système d'apprentissage
+3. **MemoryMonitor** : Surveillance et gestion de la mémoire
+4. **CircuitBreaker** : Protection contre les boucles infinies
+
+## Components and Interfaces
+
+### FAISSIndexBuilder
+
+```python
+class FAISSIndexBuilder:
+    """Construit et reconstruit l'index FAISS à partir des tâches."""
+    
+    def __init__(self, embeddings_manager, learning_manager, logger):
+        pass
+    
+    def scan_tasks(self) -> List[TaskProfile]:
+        """Scanne tous les dossiers de tâches."""
+        pass
+    
+    def load_task_embeddings(self, task: TaskProfile) -> List[np.ndarray]:
+        """Charge les embeddings d'une tâche."""
+        pass
+    
+    def rebuild_index(self) -> Dict[str, Any]:
+        """Reconstruit l'index complet."""
+        pass
+    
+    def verify_index_integrity(self) -> bool:
+        """Vérifie la cohérence de l'index."""
+        pass
+```
+
+### SystemDiagnostic
+
+```python
+class SystemDiagnostic:
+    """Diagnostic complet du système d'apprentissage."""
+    
+    def check_faiss_index(self) -> Dict[str, Any]:
+        """Vérifie l'état de l'index FAISS."""
+        pass
+    
+    def count_tasks(self) -> int:
+        """Compte les tâches sauvegardées."""
+        pass
+    
+    def check_consistency(self) -> Dict[str, Any]:
+        """Vérifie la cohérence tâches/embeddings."""
+        pass
+    
+    def generate_report(self) -> Dict[str, Any]:
+        """Génère un rapport JSON complet."""
+        pass
+```
+
+
+### MemoryMonitor
+
+```python
+class MemoryMonitor:
+    """Surveille et gère la consommation mémoire."""
+    
+    def get_current_memory(self) -> float:
+        """Retourne la mémoire utilisée en GB."""
+        pass
+    
+    def check_threshold(self, max_memory_gb: float) -> bool:
+        """Vérifie si le seuil est dépassé."""
+        pass
+    
+    def cleanup_caches(self):
+        """Nettoie les caches pour libérer de la mémoire."""
+        pass
+    
+    def free_gpu_memory(self):
+        """Libère la mémoire GPU."""
+        pass
+```
+
+### CircuitBreaker
+
+```python
+class CircuitBreaker:
+    """Protection contre les boucles infinies."""
+    
+    def __init__(self, threshold: int = 100, window: float = 1.0):
+        pass
+    
+    def record_call(self, function_name: str):
+        """Enregistre un appel de fonction."""
+        pass
+    
+    def should_break(self, function_name: str) -> bool:
+        """Vérifie si le circuit doit s'ouvrir."""
+        pass
+    
+    def reset(self, function_name: str):
+        """Réinitialise le circuit breaker."""
+        pass
+```
+
+## Data Models
+
+### TaskEmbedding
+
+```python
+@dataclass
+class TaskEmbedding:
+    """Représente un embedding de tâche."""
+    task_id: str
+    embedding: np.ndarray
+    metadata: Dict[str, Any]
+    timestamp: datetime
+```
+
+### DiagnosticReport
+
+```python
+@dataclass
+class DiagnosticReport:
+    """Rapport de diagnostic du système."""
+    timestamp: datetime
+    faiss_index_exists: bool
+    faiss_index_size: int
+    tasks_count: int
+    embeddings_count: int
+    consistency_ok: bool
+    inconsistencies: List[str]
+    memory_usage_gb: float
+    recommendations: List[str]
+```
+
+### MemoryStats
+
+```python
+@dataclass
+class MemoryStats:
+    """Statistiques mémoire."""
+    total_mb: float
+    used_mb: float
+    available_mb: float
+    percent: float
+    gpu_used_mb: Optional[float]
+```
+
+## Correctness Properties
+
+*A property is a characteristic or behavior that should hold true across all valid executions of a system-essentially, a formal statement about what the system should do. Properties serve as the bridge between human-readable specifications and machine-verifiable correctness guarantees.*
+
+### Property 1: Index chargé au démarrage
+
+*For any* système qui démarre avec des tâches existantes, l'index FAISS doit contenir tous les embeddings de ces tâches après l'initialisation.
+
+**Validates: Requirements 1.1**
+
+### Property 2: Ajout immédiat à l'index
+
+*For any* nouvelle tâche sauvegardée, ses embeddings doivent être immédiatement présents dans l'index FAISS.
+
+**Validates: Requirements 1.2**
+
+### Property 3: Persistance immédiate
+
+*For any* modification de l'index FAISS, les fichiers sur disque doivent être mis à jour dans les 5 secondes.
+
+**Validates: Requirements 1.3**
+
+### Property 4: Reconstruction automatique
+
+*For any* système qui détecte des tâches sans embeddings dans l'index, la reconstruction doit être déclenchée automatiquement.
+
+**Validates: Requirements 1.4**
+
+### Property 5: Suggestions avec index non-vide
+
+*For any* action similaire à une tâche existante, si l'index contient des embeddings, une suggestion doit être retournée.
+
+**Validates: Requirements 1.5**
+
+### Property 6: Arrêt rapide
+
+*For any* signal d'arrêt (Ctrl+C), tous les threads doivent être arrêtés en moins de 5 secondes.
+
+**Validates: Requirements 2.1**
+
+### Property 7: Libération mémoire
+
+*For any* arrêt de l'application, la consommation mémoire du processus doit diminuer de plus de 90% dans les 10 secondes.
+
+**Validates: Requirements 2.2**
+
+### Property 8: Arrêt synchrone des threads
+
+*For any* arrêt demandé, aucun thread de capture ne doit rester actif après la fin de la méthode shutdown().
+
+**Validates: Requirements 2.3**
+
+### Property 9: Stop explicite des listeners
+
+*For any* listener pynput actif, sa méthode stop() doit être appelée avant la fin du programme.
+
+**Validates: Requirements 2.4**
+
+### Property 10: Threads daemon ou arrêt garanti
+
+*For any* thread d'orchestrateur, il doit être soit daemon, soit avoir un mécanisme d'arrêt vérifié.
+
+**Validates: Requirements 2.5**
+
+
+### Property 11: Détection de patterns répétitifs
+
+*For any* séquence de 3 actions identiques, un pattern doit être détecté et enregistré.
+
+**Validates: Requirements 3.1**
+
+### Property 12: Création de tâche après pattern
+
+*For any* pattern détecté, une tâche avec signatures doit être créée dans les 2 secondes.
+
+**Validates: Requirements 3.2**
+
+### Property 13: Indexation des embeddings
+
+*For any* tâche créée, ses embeddings multimodaux doivent être présents dans l'index FAISS.
+
+**Validates: Requirements 3.3**
+
+### Property 14: Suggestions avec confiance élevée
+
+*For any* action similaire (similarité > 0.8) à une tâche existante, une suggestion avec confiance > 0.7 doit être proposée.
+
+**Validates: Requirements 3.4**
+
+### Property 15: Contenu des suggestions
+
+*For any* suggestion affichée, elle doit contenir le nom de la tâche et la liste des actions à effectuer.
+
+**Validates: Requirements 3.5**
+
+### Property 16: Limite mémoire mode shadow
+
+*For any* exécution en mode shadow pendant plus de 5 minutes, la consommation mémoire doit rester sous 1GB.
+
+**Validates: Requirements 4.1**
+
+### Property 17: Limite mémoire mode assist
+
+*For any* exécution en mode assist pendant plus de 5 minutes, la consommation mémoire doit rester sous 2GB.
+
+**Validates: Requirements 4.2**
+
+### Property 18: Libération GPU
+
+*For any* génération d'embedding, la mémoire GPU utilisée doit être libérée dans les 2 secondes.
+
+**Validates: Requirements 4.3**
+
+### Property 19: Buffer limité
+
+*For any* moment de l'exécution, le buffer de screenshots ne doit jamais contenir plus de 10 images.
+
+**Validates: Requirements 4.4**
+
+### Property 20: Alerte mémoire
+
+*For any* dépassement du seuil de 2GB, un avertissement doit être loggé et les caches nettoyés.
+
+**Validates: Requirements 4.5**
+
+### Property 21: Comptage des tâches
+
+*For any* exécution du diagnostic, le nombre de tâches retourné doit correspondre au nombre de dossiers dans user_profiles.
+
+**Validates: Requirements 5.2**
+
+### Property 22: Vérification de cohérence
+
+*For any* exécution du diagnostic, toutes les tâches avec embeddings doivent avoir leurs embeddings dans l'index.
+
+**Validates: Requirements 5.3**
+
+### Property 23: Proposition de reconstruction
+
+*For any* incohérence détectée (tâche sans embedding dans l'index), le diagnostic doit proposer une reconstruction.
+
+**Validates: Requirements 5.4**
+
+### Property 24: Rapport JSON complet
+
+*For any* diagnostic terminé, un fichier JSON doit être généré avec toutes les métriques requises.
+
+**Validates: Requirements 5.5**
+
+### Property 25: Scan complet des tâches
+
+*For any* reconstruction lancée, tous les dossiers de tâches existants doivent être scannés.
+
+**Validates: Requirements 6.1**
+
+### Property 26: Génération d'embeddings manquants
+
+*For any* tâche trouvée sans embeddings dans l'index, les embeddings doivent être générés et ajoutés.
+
+**Validates: Requirements 6.2**
+
+### Property 27: Construction d'index optimisé
+
+*For any* reconstruction terminée, un nouvel index FAISS doit être créé avec tous les embeddings.
+
+**Validates: Requirements 6.3**
+
+### Property 28: Sauvegarde après reconstruction
+
+*For any* reconstruction réussie, les fichiers d'index et métadonnées doivent être sauvegardés sur disque.
+
+**Validates: Requirements 6.4**
+
+### Property 29: Résilience aux erreurs
+
+*For any* erreur lors du traitement d'une tâche, la reconstruction doit continuer avec les tâches suivantes.
+
+**Validates: Requirements 6.5**
+
+### Property 30: Validation norme non-nulle
+
+*For any* embedding généré, sa norme L2 doit être strictement positive.
+
+**Validates: Requirements 7.1**
+
+### Property 31: Validation NaN/Inf
+
+*For any* embedding généré, il ne doit contenir ni NaN ni Inf.
+
+**Validates: Requirements 7.2**
+
+### Property 32: Cohérence embeddings identiques
+
+*For any* paire de screenshots identiques, leurs embeddings doivent avoir une similarité cosinus > 0.95.
+
+**Validates: Requirements 7.3**
+
+### Property 33: Discrimination embeddings différents
+
+*For any* paire de screenshots visuellement différents, leurs embeddings doivent avoir une similarité cosinus < 0.8.
+
+**Validates: Requirements 7.4**
+
+### Property 34: Régénération sur invalide
+
+*For any* embedding invalide détecté, une erreur doit être loggée et l'embedding régénéré.
+
+**Validates: Requirements 7.5**
+
+### Property 35: Activation circuit breaker
+
+*For any* fonction appelée plus de 100 fois en 1 seconde, le circuit breaker doit s'activer.
+
+**Validates: Requirements 8.1**
+
+### Property 36: Log circuit breaker
+
+*For any* activation de circuit breaker, un log avec stack trace doit être créé.
+
+**Validates: Requirements 8.2**
+
+### Property 37: Blocage temporaire
+
+*For any* circuit breaker activé, la fonction doit être bloquée pendant 60 secondes.
+
+**Validates: Requirements 8.3**
+
+### Property 38: Reprise progressive
+
+*For any* réinitialisation de circuit breaker, un rate limit doit être appliqué à la reprise.
+
+**Validates: Requirements 8.4**
+
+### Property 39: Mode dégradé
+
+*For any* situation avec 3 circuit breakers actifs simultanément, le système doit passer en mode dégradé.
+
+**Validates: Requirements 8.5**
+
+## Error Handling
+
+### Stratégie Générale
+
+1. **Erreurs de chargement** : Logger et continuer avec les tâches suivantes
+2. **Erreurs d'embedding** : Régénérer jusqu'à 3 tentatives
+3. **Erreurs FAISS** : Reconstruire l'index si corrompu
+4. **Erreurs mémoire** : Nettoyer les caches et alerter
+5. **Erreurs de thread** : Forcer l'arrêt après timeout
+
+### Gestion des Erreurs Critiques
+
+```python
+try:
+    # Opération critique
+    pass
+except MemoryError:
+    memory_monitor.cleanup_caches()
+    logger.log_critical("memory_exhausted")
+except FAISSError:
+    index_builder.rebuild_index()
+    logger.log_critical("faiss_corrupted")
+except ThreadError:
+    force_shutdown_threads()
+    logger.log_critical("thread_deadlock")
+```
+
+## Testing Strategy
+
+### Unit Tests
+
+- Test de chargement des tâches individuelles
+- Test de génération d'embeddings
+- Test d'ajout à l'index FAISS
+- Test de recherche de similarité
+- Test d'arrêt des threads
+- Test de libération mémoire
+
+### Property-Based Tests
+
+Nous utiliserons **Hypothesis** pour Python comme bibliothèque de property-based testing. Chaque test sera configuré pour exécuter au minimum 100 itérations.
+
+Chaque property-based test doit être tagué avec un commentaire référençant explicitement la correctness property du design document au format : `**Feature: faiss-learning-fix, Property {number}: {property_text}**`
+
+Les tests doivent couvrir :
+- Génération aléatoire de tâches et vérification de l'indexation
+- Génération aléatoire d'embeddings et validation
+- Simulation d'arrêts à différents moments
+- Simulation de charges mémoire variables
+- Simulation d'appels répétitifs pour circuit breakers
+
+### Integration Tests
+
+- Test du flux complet : création tâche → indexation → suggestion
+- Test de reconstruction d'index avec tâches existantes
+- Test d'arrêt propre avec tous les composants actifs
+- Test de diagnostic sur système réel
+- Test de gestion mémoire sous charge
+
+## Implementation Notes
+
+### Ordre d'Implémentation
+
+1. **FAISSIndexBuilder** : Fondation pour tout le reste
+2. **Chargement au démarrage** : Correction immédiate du problème principal
+3. **Arrêt propre** : Correction des processus zombies
+4. **MemoryMonitor** : Protection contre les fuites
+5. **CircuitBreaker** : Protection contre les boucles
+6. **SystemDiagnostic** : Outil de débogage
+
+### Points d'Attention
+
+1. **Compatibilité** : Ne pas casser le code existant
+2. **Performance** : Chargement rapide au démarrage (<10s)
+3. **Robustesse** : Gérer les tâches corrompues
+4. **Logs** : Tracer toutes les opérations critiques
+5. **Tests** : Valider chaque property avant de continuer

.kiro/specs/faiss-learning-fix/requirements.md

@@ -0,0 +1,115 @@
+# Requirements Document - Correction Système d'Apprentissage FAISS
+
+## Introduction
+
+Le système RPA Vision V2 présente des défaillances critiques dans son système d'apprentissage. Après 3 jours de tests répétitifs (calculatrice, OnlyOffice), aucune suggestion n'est générée malgré la présence de 19+ tâches sauvegardées. L'index FAISS reste vide, les processus zombies consomment 3GB+ RAM, et le système ne peut pas être arrêté proprement.
+
+## Glossaire
+
+- **FAISS**: Facebook AI Similarity Search - Bibliothèque pour la recherche de similarité vectorielle
+- **Index FAISS**: Structure de données contenant les embeddings pour la recherche rapide
+- **Embedding**: Représentation vectorielle d'une capture d'écran ou action
+- **Tâche**: Séquence d'actions utilisateur sauvegardée avec ses signatures
+- **Signature**: Représentation unique d'une action (screenshot + embedding + métadonnées)
+- **LearningManager**: Composant responsable de la détection et sauvegarde des patterns
+- **EmbeddingsManager**: Composant responsable de la gestion de l'index FAISS
+- **Processus zombie**: Processus qui continue de s'exécuter après l'arrêt demandé
+- **Circuit breaker**: Mécanisme de protection contre les boucles infinies
+
+## Requirements
+
+### Requirement 1
+
+**User Story:** En tant qu'utilisateur, je veux que le système construise automatiquement l'index FAISS à partir des tâches sauvegardées, afin que les suggestions fonctionnent après mes tests répétitifs.
+
+#### Acceptance Criteria
+
+1. WHEN le système démarre THEN le système SHALL charger toutes les tâches existantes dans l'index FAISS
+2. WHEN une nouvelle tâche est sauvegardée THEN le système SHALL ajouter immédiatement ses embeddings à l'index FAISS
+3. WHEN l'index FAISS est modifié THEN le système SHALL persister l'index sur disque immédiatement
+4. WHEN le système détecte des tâches sans embeddings dans l'index THEN le système SHALL reconstruire l'index complet
+5. WHEN l'index FAISS contient des embeddings THEN le système SHALL retourner des suggestions pour des actions similaires
+
+### Requirement 2
+
+**User Story:** En tant qu'utilisateur, je veux que l'application s'arrête proprement sans laisser de processus zombies, afin de ne pas avoir à tuer manuellement des processus consommant 3GB+ RAM.
+
+#### Acceptance Criteria
+
+1. WHEN l'utilisateur appuie sur Ctrl+C THEN le système SHALL arrêter tous les threads en moins de 5 secondes
+2. WHEN l'application s'arrête THEN le système SHALL libérer toute la mémoire allouée
+3. WHEN des threads de capture sont actifs THEN le système SHALL les arrêter de manière synchrone avant de quitter
+4. WHEN pynput listeners sont actifs THEN le système SHALL appeler explicitement leur méthode stop()
+5. WHEN l'orchestrateur tourne en arrière-plan THEN le système SHALL utiliser des threads daemon ou un mécanisme d'arrêt garanti
+
+### Requirement 3
+
+**User Story:** En tant qu'utilisateur, je veux voir des suggestions après avoir effectué des actions répétitives, afin que le système apprenne réellement de mes comportements.
+
+#### Acceptance Criteria
+
+1. WHEN l'utilisateur effectue la même action 3 fois THEN le système SHALL détecter le pattern répétitif
+2. WHEN un pattern est détecté THEN le système SHALL créer une tâche avec ses signatures
+3. WHEN une tâche est créée THEN le système SHALL générer et indexer les embeddings multimodaux
+4. WHEN l'utilisateur effectue une action similaire à une tâche existante THEN le système SHALL proposer une suggestion avec confiance > 0.7
+5. WHEN une suggestion est affichée THEN le système SHALL inclure le nom de la tâche et les actions à effectuer
+
+### Requirement 4
+
+**User Story:** En tant qu'utilisateur, je veux que le système ne consomme pas plus de 2GB de RAM en fonctionnement normal, afin d'éviter les fuites mémoire.
+
+#### Acceptance Criteria
+
+1. WHEN le système fonctionne en mode shadow THEN la consommation mémoire SHALL rester sous 1GB
+2. WHEN le système fonctionne en mode assist THEN la consommation mémoire SHALL rester sous 2GB
+3. WHEN des embeddings sont générés THEN le système SHALL libérer les tensors GPU après utilisation
+4. WHEN des screenshots sont capturés THEN le système SHALL limiter la taille du buffer à 10 images maximum
+5. WHEN la mémoire dépasse 2GB THEN le système SHALL logger un avertissement et nettoyer les caches
+
+### Requirement 5
+
+**User Story:** En tant qu'utilisateur, je veux un diagnostic complet du système d'apprentissage, afin de comprendre pourquoi aucune suggestion n'apparaît après 3 jours de tests.
+
+#### Acceptance Criteria
+
+1. WHEN l'utilisateur lance le diagnostic THEN le système SHALL vérifier l'existence et la taille de l'index FAISS
+2. WHEN le diagnostic s'exécute THEN le système SHALL compter le nombre de tâches sauvegardées
+3. WHEN le diagnostic s'exécute THEN le système SHALL vérifier la cohérence entre tâches et embeddings indexés
+4. WHEN des incohérences sont détectées THEN le système SHALL proposer une reconstruction automatique
+5. WHEN le diagnostic se termine THEN le système SHALL générer un rapport JSON avec toutes les métriques
+
+### Requirement 6
+
+**User Story:** En tant qu'utilisateur, je veux une commande de reconstruction de l'index FAISS, afin de réparer le système sans perdre mes 3 jours de tests.
+
+#### Acceptance Criteria
+
+1. WHEN l'utilisateur lance la reconstruction THEN le système SHALL scanner tous les dossiers de tâches
+2. WHEN une tâche est trouvée THEN le système SHALL charger ses signatures et générer les embeddings manquants
+3. WHEN tous les embeddings sont générés THEN le système SHALL construire un nouvel index FAISS optimisé
+4. WHEN la reconstruction est terminée THEN le système SHALL sauvegarder l'index et les métadonnées
+5. WHEN la reconstruction échoue THEN le système SHALL logger l'erreur et continuer avec les tâches suivantes
+
+### Requirement 7
+
+**User Story:** En tant qu'utilisateur, je veux que le système valide la qualité des embeddings générés, afin de garantir que les suggestions seront pertinentes.
+
+#### Acceptance Criteria
+
+1. WHEN un embedding est généré THEN le système SHALL vérifier que sa norme est non-nulle
+2. WHEN un embedding est généré THEN le système SHALL vérifier qu'il ne contient pas de NaN ou Inf
+3. WHEN deux screenshots identiques sont traités THEN leurs embeddings SHALL avoir une similarité > 0.95
+4. WHEN deux screenshots différents sont traités THEN leurs embeddings SHALL avoir une similarité < 0.8
+5. WHEN un embedding invalide est détecté THEN le système SHALL logger l'erreur et régénérer l'embedding
+
+### Requirement 8
+
+**User Story:** En tant qu'utilisateur, je veux que le système détecte et corrige automatiquement les boucles infinies, afin d'éviter les fuites mémoire de 3GB+.
+
+#### Acceptance Criteria
+
+1. WHEN une fonction est appelée plus de 100 fois par seconde THEN le système SHALL activer un circuit breaker
+2. WHEN un circuit breaker est activé THEN le système SHALL logger l'événement avec la stack trace
+3. WHEN un circuit breaker est activé THEN le système SHALL arrêter temporairement la fonction pendant 60 secondes
+4. WHEN le circuit breaker se réinitialise THEN le système SHALL reprendre progressivement avec un rate limit
+5. WHEN 3 circuit breakers sont activés simultanément THEN le système SHALL passer en mode dégradé et alerter l'utilisateur

.kiro/specs/faiss-learning-fix/tasks.md

@@ -0,0 +1,190 @@
+# Implementation Plan - Correction Système d'Apprentissage FAISS
+
+## Objectif
+
+Corriger les problèmes critiques du système d'apprentissage : index FAISS vide malgré 19+ tâches sauvegardées, processus zombies consommant 3GB+ RAM, et absence de suggestions après 3 jours de tests.
+
+## Tasks
+
+- [x] 1. Créer le FAISSIndexBuilder pour reconstruction d'index ✅ TERMINÉ
+  - Créer `geniusia2/core/faiss_index_builder.py`
+  - Implémenter `scan_tasks()` pour scanner tous les dossiers de tâches
+  - Implémenter `load_task_embeddings()` pour charger les embeddings depuis les signatures.pkl
+  - Implémenter `rebuild_index()` pour reconstruire l'index complet
+  - Implémenter `verify_index_integrity()` pour vérifier la cohérence
+  - _Requirements: 1.4, 6.1, 6.2, 6.3, 6.4, 6.5_
+  - **Résultat: 40 tâches scannées, 122 embeddings indexés**
+
+- [ ]* 1.1 Écrire les property tests pour FAISSIndexBuilder
+  - **Property 25: Scan complet des tâches**
+  - **Property 26: Génération d'embeddings manquants**
+  - **Property 27: Construction d'index optimisé**
+  - **Property 28: Sauvegarde après reconstruction**
+  - **Property 29: Résilience aux erreurs**
+  - **Validates: Requirements 6.1, 6.2, 6.3, 6.4, 6.5**
+
+- [x] 2. Implémenter le chargement automatique au démarrage ✅ TERMINÉ
+  - Modifier `geniusia2/core/learning_manager.py` pour charger les tâches existantes dans `__init__`
+  - Utiliser FAISSIndexBuilder pour reconstruire l'index si vide
+  - Ajouter logs pour tracer le chargement
+  - Gérer les erreurs de chargement (tâches corrompues)
+  - _Requirements: 1.1, 1.2, 1.3_
+  - **Résultat: 40 tâches chargées, 672 workflows détectés**
+
+- [ ]* 2.1 Écrire les property tests pour chargement automatique
+  - **Property 1: Index chargé au démarrage**
+  - **Property 2: Ajout immédiat à l'index**
+  - **Property 3: Persistance immédiate**
+  - **Property 4: Reconstruction automatique**
+  - **Validates: Requirements 1.1, 1.2, 1.3, 1.4**
+
+- [x] 3. Corriger l'arrêt propre des processus ✅ TERMINÉ
+  - Modifier `geniusia2/main.py` méthode `shutdown()` pour arrêter explicitement les listeners pynput
+  - Ajouter timeout de 5 secondes pour l'arrêt des threads
+  - Implémenter arrêt synchrone des threads de capture
+  - Forcer l'arrêt si timeout dépassé
+  - Vérifier que tous les threads sont bien arrêtés
+  - _Requirements: 2.1, 2.3, 2.4, 2.5_
+  - **Résultat: Arrêt propre en <5s, aucun processus zombie**
+
+- [ ]* 3.1 Écrire les property tests pour arrêt propre
+  - **Property 6: Arrêt rapide**
+  - **Property 8: Arrêt synchrone des threads**
+  - **Property 9: Stop explicite des listeners**
+  - **Property 10: Threads daemon ou arrêt garanti**
+  - **Validates: Requirements 2.1, 2.3, 2.4, 2.5**
+
+- [x] 4. Checkpoint - Vérifier que le système charge les tâches et s'arrête proprement ✅ VALIDÉ
+  - Lancer le système avec les 40 tâches existantes
+  - Vérifier que l'index FAISS contient les embeddings
+  - Tester l'arrêt avec Ctrl+C
+  - Vérifier qu'aucun processus zombie ne reste
+  - Mesurer la consommation mémoire
+  - **Résultat: Tous les tests passés, système stable et fonctionnel**
+
+- [ ] 5. Créer le MemoryMonitor pour gestion mémoire
+  - Créer `geniusia2/core/memory_monitor.py`
+  - Implémenter `get_current_memory()` pour mesurer la RAM utilisée
+  - Implémenter `check_threshold()` pour vérifier les seuils
+  - Implémenter `cleanup_caches()` pour libérer la mémoire
+  - Implémenter `free_gpu_memory()` pour libérer la mémoire GPU
+  - Intégrer dans l'orchestrateur avec vérification périodique
+  - _Requirements: 4.1, 4.2, 4.3, 4.4, 4.5_
+
+- [ ]* 5.1 Écrire les property tests pour MemoryMonitor
+  - **Property 16: Limite mémoire mode shadow**
+  - **Property 17: Limite mémoire mode assist**
+  - **Property 18: Libération GPU**
+  - **Property 19: Buffer limité**
+  - **Property 20: Alerte mémoire**
+  - **Validates: Requirements 4.1, 4.2, 4.3, 4.4, 4.5**
+
+- [ ] 6. Créer le CircuitBreaker pour protection contre boucles infinies
+  - Créer `geniusia2/core/circuit_breaker.py`
+  - Implémenter détection d'appels répétitifs (>100/s)
+  - Implémenter blocage temporaire (60s)
+  - Implémenter reprise progressive avec rate limit
+  - Implémenter mode dégradé si 3 breakers actifs
+  - Intégrer dans les fonctions critiques (check_for_suggestions, etc.)
+  - _Requirements: 8.1, 8.2, 8.3, 8.4, 8.5_
+
+- [ ]* 6.1 Écrire les property tests pour CircuitBreaker
+  - **Property 35: Activation circuit breaker**
+  - **Property 36: Log circuit breaker**
+  - **Property 37: Blocage temporaire**
+  - **Property 38: Reprise progressive**
+  - **Property 39: Mode dégradé**
+  - **Validates: Requirements 8.1, 8.2, 8.3, 8.4, 8.5**
+
+- [ ] 7. Créer le SystemDiagnostic pour analyse du système
+  - Créer `geniusia2/core/system_diagnostic.py`
+  - Implémenter `check_faiss_index()` pour vérifier l'index
+  - Implémenter `count_tasks()` pour compter les tâches
+  - Implémenter `check_consistency()` pour vérifier cohérence tâches/embeddings
+  - Implémenter `generate_report()` pour créer un rapport JSON
+  - Créer script CLI `diagnostic_systeme.py` à la racine
+  - _Requirements: 5.1, 5.2, 5.3, 5.4, 5.5_
+
+- [ ]* 7.1 Écrire les property tests pour SystemDiagnostic
+  - **Property 21: Comptage des tâches**
+  - **Property 22: Vérification de cohérence**
+  - **Property 23: Proposition de reconstruction**
+  - **Property 24: Rapport JSON complet**
+  - **Validates: Requirements 5.2, 5.3, 5.4, 5.5**
+
+- [ ] 8. Améliorer la validation des embeddings
+  - Modifier `geniusia2/core/embeddings_manager.py` méthode `encode_image()`
+  - Ajouter validation de la norme (doit être > 0)
+  - Ajouter validation NaN/Inf
+  - Ajouter régénération automatique si invalide
+  - Ajouter tests de cohérence (screenshots identiques → similarité > 0.95)
+  - _Requirements: 7.1, 7.2, 7.3, 7.4, 7.5_
+
+- [ ]* 8.1 Écrire les property tests pour validation embeddings
+  - **Property 30: Validation norme non-nulle**
+  - **Property 31: Validation NaN/Inf**
+  - **Property 32: Cohérence embeddings identiques**
+  - **Property 33: Discrimination embeddings différents**
+  - **Property 34: Régénération sur invalide**
+  - **Validates: Requirements 7.1, 7.2, 7.3, 7.4, 7.5**
+
+- [ ] 9. Améliorer le système de suggestions
+  - Modifier `geniusia2/core/suggestion_manager.py`
+  - Vérifier que l'index n'est pas vide avant recherche
+  - S'assurer que les suggestions incluent nom de tâche et actions
+  - Ajouter seuil de confiance minimum (0.7)
+  - Ajouter logs pour tracer les suggestions
+  - _Requirements: 1.5, 3.4, 3.5_
+
+- [ ]* 9.1 Écrire les property tests pour suggestions
+  - **Property 5: Suggestions avec index non-vide**
+  - **Property 14: Suggestions avec confiance élevée**
+  - **Property 15: Contenu des suggestions**
+  - **Validates: Requirements 1.5, 3.4, 3.5**
+
+- [ ] 10. Améliorer la détection de patterns
+  - Modifier `geniusia2/core/learning_manager.py`
+  - Implémenter détection de 3 actions identiques
+  - Créer automatiquement une tâche après détection
+  - Indexer immédiatement les embeddings
+  - Ajouter logs pour tracer la détection
+  - _Requirements: 3.1, 3.2, 3.3_
+
+- [ ]* 10.1 Écrire les property tests pour détection patterns
+  - **Property 11: Détection de patterns répétitifs**
+  - **Property 12: Création de tâche après pattern**
+  - **Property 13: Indexation des embeddings**
+  - **Validates: Requirements 3.1, 3.2, 3.3**
+
+- [ ] 11. Créer un script de reconstruction manuelle
+  - Créer `rebuild_faiss_index.py` à la racine
+  - Utiliser FAISSIndexBuilder pour reconstruire
+  - Afficher la progression (tâches traitées)
+  - Générer un rapport de reconstruction
+  - Sauvegarder l'index et métadonnées
+  - _Requirements: 6.1, 6.2, 6.3, 6.4, 6.5_
+
+- [ ] 12. Créer un script de test de mémoire
+  - Créer `test_memory_limits.py` à la racine
+  - Tester mode shadow pendant 10 minutes
+  - Tester mode assist pendant 10 minutes
+  - Mesurer la consommation mémoire toutes les 30 secondes
+  - Vérifier les seuils (1GB shadow, 2GB assist)
+  - Générer un rapport de consommation
+  - _Requirements: 4.1, 4.2_
+
+- [ ] 13. Checkpoint final - Validation complète
+  - Exécuter le diagnostic complet
+  - Reconstruire l'index avec les 19+ tâches
+  - Tester les suggestions avec actions répétitives
+  - Vérifier l'arrêt propre (pas de zombies)
+  - Vérifier la consommation mémoire (<2GB)
+  - Vérifier les circuit breakers
+  - Ensure all tests pass, ask the user if questions arise.
+
+- [ ] 14. Documentation et nettoyage
+  - Créer `GUIDE_CORRECTION_FAISS.md` expliquant les corrections
+  - Documenter l'utilisation du diagnostic
+  - Documenter l'utilisation de la reconstruction
+  - Mettre à jour le README avec les nouvelles commandes
+  - Nettoyer les anciens scripts de diagnostic