Geniusia_v2/docs/implementation/MODE_ASSISTE_CONCEPTION.md

# 🤝 Mode Assisté - Conception

## 🎯 Objectif

Intégrer le système de rejeu dans l'Orchestrator pour fournir des **suggestions en temps réel** basées sur les tâches apprises.

## 🔄 Flux du Mode Assisté

```
1. Utilisateur effectue une action
   ↓
2. EventCapture détecte l'action
   ↓
3. Orchestrator capture le contexte (screenshot, fenêtre)
   ↓
4. Recherche de tâches similaires dans FAISS
   ↓
5. Si correspondance trouvée (similarité > 0.75)
   ↓
6. Afficher suggestion visuelle
   ↓
7. Attendre validation utilisateur
   ├─ Entrée → Exécuter l'action suggérée
   ├─ Échap → Ignorer
   └─ Alt+C → Corriger
   ↓
8. Mettre à jour les scores de confiance
```

## 🏗️ Architecture

### Composants à Modifier

1. **Orchestrator** (`orchestrator.py`)
   - Ajouter `TaskReplayEngine`
   - Ajouter méthode `_suggest_next_action()`
   - Ajouter méthode `_handle_suggestion_response()`

2. **GUI** (`minimal_gui.py`)
   - Ajouter overlay de suggestion
   - Ajouter gestion des touches (Entrée/Échap/Alt+C)

3. **LearningManager** (`learning_manager.py`)
   - Ajouter méthode `find_similar_tasks()`
   - Améliorer `suggest_action()`

### Nouveaux Composants

1. **SuggestionManager** (nouveau)
   - Gère les suggestions en temps réel
   - Calcule les scores de confiance
   - Gère les timeouts

## 📝 Implémentation

### Étape 1 : Intégrer TaskReplayEngine dans Orchestrator

```python
from .task_replay import TaskReplayEngine

class Orchestrator:
    def __init__(self, ...):
        # ... code existant ...
        
        # Moteur de rejeu pour suggestions
        self.replay_engine = TaskReplayEngine(
            learning_manager,
            embeddings_manager,
            vision_utils,
            input_utils,
            logger,
            config
        )
```

### Étape 2 : Ajouter la Détection de Contexte

```python
def _capture_context(self) -> Dict[str, Any]:
    """Capture le contexte actuel pour suggestions."""
    screenshot = capture_screen()
    window = get_active_window()
    
    # Générer embedding du contexte
    embedding = self.vision_analyzer.generate_embedding(screenshot)
    
    return {
        "screenshot": screenshot,
        "window": window,
        "embedding": embedding,
        "timestamp": datetime.now()
    }
```

### Étape 3 : Recherche de Tâches Similaires

```python
def _find_similar_tasks(self, context: Dict[str, Any]) -> List[Dict]:
    """Recherche les tâches similaires au contexte actuel."""
    embedding = context["embedding"]
    
    # Rechercher dans FAISS
    results = self.learning_manager.embeddings_manager.search_similar(
        embedding,
        k=3
    )
    
    # Filtrer par seuil de similarité
    similar_tasks = [
        r for r in results 
        if r["similarity"] >= 0.75
    ]
    
    return similar_tasks
```

### Étape 4 : Générer et Afficher Suggestion

```python
def _suggest_next_action(self, context: Dict[str, Any]):
    """Génère et affiche une suggestion d'action."""
    # Rechercher tâches similaires
    similar_tasks = self._find_similar_tasks(context)
    
    if not similar_tasks:
        return
    
    # Prendre la meilleure correspondance
    best_match = similar_tasks[0]
    task_id = best_match["metadata"]["task_id"]
    
    # Charger la tâche
    task = self.learning_manager.load_task(task_id)
    
    if not task:
        return
    
    # Obtenir la prochaine action suggérée
    suggestion = self.learning_manager.suggest_action(context)
    
    if suggestion and suggestion["confidence"] >= 0.75:
        # Afficher dans la GUI
        if self.gui:
            self.gui.show_suggestion(suggestion)
```

### Étape 5 : Gestion des Réponses

```python
def _handle_suggestion_response(self, response: str, suggestion: Dict):
    """Gère la réponse de l'utilisateur à une suggestion."""
    if response == "accept":
        # Exécuter l'action suggérée
        self._execute_suggested_action(suggestion)
        
        # Mettre à jour la confiance (positif)
        self.learning_manager.confirm_action({
            "type": "accept",
            "task_id": suggestion["task_id"]
        })
    
    elif response == "reject":
        # Ne rien faire
        
        # Mettre à jour la confiance (négatif)
        self.learning_manager.confirm_action({
            "type": "reject",
            "task_id": suggestion["task_id"]
        })
    
    elif response == "correct":
        # Ouvrir dialogue de correction
        if self.gui:
            self.gui.show_correction_dialog(suggestion)
```

## 🎨 Interface Utilisateur

### Overlay de Suggestion

```
┌─────────────────────────────────────┐
│  💡 Suggestion                      │
│                                     │
│  Action : Clic sur "Enregistrer"   │
│  Confiance : 89%                    │
│                                     │
│  [Entrée] Accepter                  │
│  [Échap] Refuser                    │
│  [Alt+C] Corriger                   │
└─────────────────────────────────────┘
```

### Touches Clavier

| Touche | Action |
|--------|--------|
| **Entrée** | Accepter et exécuter |
| **Échap** | Refuser |
| **Alt+C** | Ouvrir dialogue de correction |

## 📊 Métriques

### Scores de Confiance

```python
confidence = (
    0.6 * vision_similarity +  # Similarité visuelle CLIP
    0.3 * llm_score +          # Score LLM
    0.1 * historical_success   # Taux de succès historique
)
```

### Seuils

- **Afficher suggestion** : confidence >= 0.75
- **Exécution auto** : confidence >= 0.95 (Mode Autopilot)
- **Rollback** : confidence < 0.85 (retour en Mode Assisté)

## 🔄 Transitions de Mode

```
Shadow (observation)
  ↓ (5+ observations)
Assisté (suggestions)
  ↓ (20+ obs + 95% concordance)
Autopilot (automatique)
  ↓ (confiance < 85%)
Assisté (retour)
```

## 🧪 Tests

### Test 1 : Suggestion Simple

1. Apprendre une tâche (3x clic sur "Enregistrer")
2. Refaire l'action une fois
3. Vérifier qu'une suggestion apparaît

### Test 2 : Acceptation

1. Suggestion affichée
2. Appuyer sur Entrée
3. Vérifier que l'action est exécutée

### Test 3 : Refus

1. Suggestion affichée
2. Appuyer sur Échap
3. Vérifier que rien n'est exécuté

## 📝 Prochaines Étapes

1. ✅ Créer `SuggestionManager`
2. ✅ Modifier `Orchestrator`
3. ✅ Ajouter overlay dans GUI
4. ✅ Implémenter gestion des touches
5. ✅ Tester le flux complet

## 🎯 Résultat Attendu

Un système qui :
- Observe tes actions
- Reconnaît les patterns
- Suggère l'action suivante
- Apprend de tes choix
- S'améliore avec le temps

**Le Mode Assisté sera fonctionnel ! 🚀**