Initial commit

2026-03-05 00:20:25 +01:00
commit dcd4de9945
1954 changed files with 669380 additions and 0 deletions
--- a/docs/guides/COMMENT_TESTER_WORKFLOWS.md
+++ b/docs/guides/COMMENT_TESTER_WORKFLOWS.md
@@ -0,0 +1,172 @@
+# 🧪 Comment Tester la Détection de Workflows
+
+## 🎯 Objectif
+
+Tester le système de détection de workflows qui vient d'être implémenté.
+
+## ✅ Prérequis
+
+- ✅ SessionManager créé
+- ✅ WorkflowDetector créé
+- ✅ EventCapture modifié
+- ✅ Tout compile correctement
+
+## 🧪 Test 1 : Script Automatique
+
+### Lancer le Test
+
+```bash
+geniusia2/venv/bin/python test_workflow_suggestion.py
+```
+
+### Ce que fait le test
+
+1. **Crée 3 sessions similaires** :
+   - Session 1 : Clic → Type → Clic
+   - Session 2 : Clic → Type → Clic
+   - Session 3 : Clic → Type → Clic
+
+2. **Détecte automatiquement le workflow**
+   - Analyse les sessions
+   - Calcule la similarité
+   - Crée le workflow si >= 75%
+
+3. **Suggère le workflow**
+   - Commence une 4ème session
+   - Fait les 2 premières actions
+   - Vérifie si suggestion apparaît
+
+### Résultat Attendu
+
+```
+🎉 SUGGESTION CRÉÉE !
+   Type: workflow
+   Workflow: Click → Type → Click
+   Étape: 2/3
+   Prochaine action: Clic sur OnlyOffice
+   Confiance: 89%
+   Répétitions: 3x
+```
+
+## 🧪 Test 2 : Test Manuel
+
+### Lancer l'Application
+
+```bash
+cd geniusia2
+./run.sh
+```
+
+### Effectuer un Workflow Répété
+
+**Exemple : Ouvrir OnlyOffice**
+
+1. **Jour 1** (ou Session 1) :
+   - Clic sur le lanceur
+   - Tape "office"
+   - Clic sur OnlyOffice
+   - Clic "Nouveau document"
+
+2. **Attendre 5 minutes** (ou forcer la fin de session)
+
+3. **Jour 2** (ou Session 2) :
+   - Refaire exactement les mêmes actions
+
+4. **Attendre 5 minutes**
+
+5. **Jour 3** (ou Session 3) :
+   - Refaire exactement les mêmes actions
+
+### Vérifier la Détection
+
+Après la 3ème session, le système devrait :
+- ✅ Détecter le workflow
+- ✅ Logger "workflow_detected"
+- ✅ Créer un Workflow avec 4 étapes
+
+### Tester la Suggestion
+
+**Jour 4** (ou Session 4) :
+- Commence le workflow (2 premières actions)
+- Le système devrait suggérer de continuer
+
+## 📊 Vérifier les Logs
+
+```bash
+# Voir les logs du jour
+cat geniusia2/data/logs/logs_$(date +%Y-%m-%d).json | jq .
+
+# Filtrer les workflows
+cat geniusia2/data/logs/logs_$(date +%Y-%m-%d).json | jq 'select(.action=="workflow_detected")'
+
+# Filtrer les sessions
+cat geniusia2/data/logs/logs_$(date +%Y-%m-%d).json | jq 'select(.action=="session_completed")'
+```
+
+## 🔧 Ajuster les Seuils
+
+Si la détection ne fonctionne pas bien, ajuster dans `config.py` :
+
+```python
+"workflow": {
+    # Timeout de session (secondes)
+    "session_timeout": 300,  # Réduire à 60 pour tests rapides
+    
+    # Nombre minimum de répétitions
+    "min_repetitions": 3,  # Réduire à 2 pour tests
+    
+    # Seuil de similarité
+    "similarity_threshold": 0.75  # Réduire à 0.65 pour plus de détections
+}
+```
+
+## ⚠️ Problèmes Courants
+
+### Aucun Workflow Détecté
+
+**Causes** :
+- Pas assez de répétitions (< 3)
+- Actions trop différentes (similarité < 75%)
+- Sessions pas finalisées
+
+**Solutions** :
+1. Vérifier les logs : `cat geniusia2/data/logs/logs_*.json`
+2. Réduire `min_repetitions` à 2
+3. Réduire `similarity_threshold` à 0.65
+4. Forcer la fin de session : `event_capture.force_finalize_session()`
+
+### Workflow Détecté Mais Pas de Suggestion
+
+**Causes** :
+- Début de workflow pas reconnu
+- Seuil de confiance trop élevé
+
+**Solutions** :
+1. Vérifier que les 2 premières actions sont identiques
+2. Réduire `similarity_threshold` dans `assist`
+3. Vérifier les logs de suggestion
+
+## ✅ Checklist de Test
+
+- [ ] Test automatique lancé (`test_workflow_suggestion.py`)
+- [ ] Workflow détecté dans les logs
+- [ ] Suggestion créée
+- [ ] Test manuel effectué (3 sessions)
+- [ ] Workflow détecté manuellement
+- [ ] Suggestion apparaît au début de la 4ème session
+- [ ] Logs vérifiés
+- [ ] Seuils ajustés si nécessaire
+
+## 🎊 Résultat Attendu
+
+Après les tests, tu devrais avoir :
+- ✅ Workflows détectés automatiquement
+- ✅ Suggestions de workflows fonctionnelles
+- ✅ Logs complets
+- ✅ Système validé
+
+**Prêt pour l'intégration dans la GUI ! 🚀**
+
+---
+
+**Créé le 19 Novembre 2025**
--- a/docs/guides/DEBUG_GUIDE.md
+++ b/docs/guides/DEBUG_GUIDE.md
@@ -0,0 +1,218 @@
+# 🐛 Guide de Debug
+
+## Problème : Rien ne se passe
+
+### Vérifications à Faire
+
+#### 1. L'application est-elle lancée ?
+
+```bash
+ps aux | grep python | grep geniusia2
+```
+
+Si rien → L'app n'est pas lancée
+
+#### 2. La capture d'événements démarre-t-elle ?
+
+**Dans le terminal, tu devrais voir** :
+```
+✅ Capture d'événements démarrée
+```
+
+Si tu ne vois pas ce message → La capture ne démarre pas
+
+#### 3. Les événements sont-ils capturés ?
+
+**Teste avec le script simple** :
+```bash
+./geniusia2/venv/bin/python test_capture_simple.py
+```
+
+Puis clique 3 fois rapidement au même endroit.
+
+**Tu devrais voir** :
+```
+Événements capturés: 3
+[DEBUG] Événements simplifiés: 3
+[DEBUG] Derniers: [...]
+[DEBUG] seq_len=1, repetitions=3, threshold=3
+[DEBUG] ✅ Pattern trouvé !
+🎯 PATTERN DÉTECTÉ !
+```
+
+#### 4. Le callback est-il appelé ?
+
+**Dans l'app principale, tu devrais voir** :
+```
+🎯 Pattern détecté dans event_capture !
+   Répétitions: 3
+   Longueur: 1
+
+============================================================
+🎯 PATTERN DÉTECTÉ DANS ORCHESTRATOR !
+============================================================
+```
+
+---
+
+## Messages de Debug Ajoutés
+
+### Dans event_capture.py
+
+```
+[DEBUG] Événements simplifiés: X
+[DEBUG] Derniers: [...]
+[DEBUG] seq_len=1, repetitions=3, threshold=3
+[DEBUG] ✅ Pattern trouvé !
+🎯 Pattern détecté dans event_capture !
+```
+
+### Dans orchestrator.py
+
+```
+============================================================
+🎯 PATTERN DÉTECTÉ DANS ORCHESTRATOR !
+============================================================
+📸 Analyse de 3 actions...
+✅ Tâche créée : task_abc123
+```
+
+---
+
+## Si Rien ne S'affiche
+
+### Problème 1 : pynput ne fonctionne pas
+
+**Test** :
+```bash
+./geniusia2/venv/bin/python -c "from pynput import mouse; print('OK')"
+```
+
+Si erreur → Réinstaller pynput
+
+### Problème 2 : Les clics sont trop espacés
+
+**Solution** : Clique plus rapidement (< 2 secondes entre chaque clic)
+
+### Problème 3 : Les clics sont trop éloignés
+
+**Solution** : Clique au même endroit (tolérance 100px)
+
+### Problème 4 : Le seuil est trop élevé
+
+**Modifier** `event_capture.py` ligne 42 :
+```python
+pattern_threshold=2  # Au lieu de 3
+```
+
+---
+
+## Test Minimal
+
+### Script de Test
+
+```bash
+./geniusia2/venv/bin/python test_capture_simple.py
+```
+
+### Ce que tu dois faire
+
+1. Lance le script
+2. Attends "Capture démarrée"
+3. Clique 3 fois RAPIDEMENT au MÊME endroit
+4. Observe les messages
+
+### Résultat Attendu
+
+```
+✅ Capture démarrée
+
+Effectuez 3 clics rapides au même endroit...
+
+Événements capturés: 1  
+Événements capturés: 2  
+Événements capturés: 3  
+[DEBUG] Événements simplifiés: 3
+[DEBUG] Derniers: [{'type': 'click', 'x_zone': 10, 'y_zone': 5, 'window': 'Firefox'}]
+[DEBUG] seq_len=1, repetitions=3, threshold=3
+[DEBUG] ✅ Pattern trouvé !
+
+🎯 PATTERN DÉTECTÉ !
+   Répétitions: 3
+   Fenêtre: Firefox
+
+✅ Pattern détecté avec succès !
+```
+
+---
+
+## Si le Test Fonctionne mais pas l'App
+
+### Vérifier que l'orchestrateur démarre la capture
+
+**Dans** `orchestrator.py`, méthode `run()` :
+```python
+# Démarrer la capture d'événements
+self.event_capture.start()
+```
+
+### Vérifier que le callback est enregistré
+
+**Dans** `orchestrator.py`, `__init__()` :
+```python
+self.event_capture.register_pattern_callback(self._on_pattern_detected)
+```
+
+---
+
+## Logs à Vérifier
+
+```bash
+# Voir les derniers logs
+ls -lah geniusia2/data/logs/
+
+# Décrypter les logs (si nécessaire)
+# Les logs sont chiffrés, donc difficiles à lire
+```
+
+---
+
+## Solution Rapide
+
+Si rien ne fonctionne, **réduis le seuil** :
+
+```python
+# Dans event_capture.py, ligne 42
+pattern_threshold=2  # Au lieu de 3
+```
+
+Et **augmente la tolérance** :
+
+```python
+# Dans event_capture.py, ligne 260
+"x_zone": e["x"] // 200,  # Au lieu de 100
+"y_zone": e["y"] // 200,
+```
+
+---
+
+## Commandes Utiles
+
+```bash
+# Tester la capture seule
+./geniusia2/venv/bin/python test_capture_simple.py
+
+# Lancer l'app avec debug
+cd geniusia2
+./run.sh 2>&1 | tee debug.log
+
+# Voir les processus
+ps aux | grep python
+
+# Tuer l'app
+pkill -f geniusia2
+```
+
+---
+
+**Lance d'abord `test_capture_simple.py` et dis-moi ce que tu vois !**
--- a/docs/guides/DEMARRAGE_RAPIDE.md
+++ b/docs/guides/DEMARRAGE_RAPIDE.md
@@ -0,0 +1,80 @@
+# ⚡ Démarrage Rapide - RPA Vision V2
+
+## Installation (Une seule fois)
+
+```bash
+cd geniusia2
+./setup.sh
+```
+
+Attendez ~10 minutes (téléchargement de ~3.5 GB de dépendances).
+
+---
+
+## Lancement
+
+```bash
+./LANCER_APPLICATION.sh
+```
+
+C'est tout ! 🎉
+
+---
+
+## Utilisation Basique
+
+### 1️⃣ Mode Shadow (👀)
+- Lancez l'application
+- Cliquez sur **Start**
+- Effectuez vos tâches normalement
+- Le système observe et apprend
+
+### 2️⃣ Mode Assisté (🤝)
+- Après 5 observations, passage automatique
+- Le système suggère des actions
+- **Entrée** = Valider
+- **Échap** = Refuser
+- **Alt+C** = Corriger
+
+### 3️⃣ Mode Autopilot (🤖)
+- Après 20 validations avec 95% de concordance
+- Exécution automatique
+- Surveillance continue
+- Retour en Assisté si confiance < 90%
+
+---
+
+## Raccourcis Essentiels
+
+| Touche | Action |
+|--------|--------|
+| **Ctrl+Pause** | 🛑 Arrêt d'urgence |
+| **Entrée** | ✅ Valider |
+| **Échap** | ❌ Refuser |
+| **Alt+C** | ✏️ Corriger |
+
+---
+
+## Problème ?
+
+```bash
+# Réinstaller
+cd geniusia2
+rm -rf venv
+./setup.sh
+
+# Relancer
+./LANCER_APPLICATION.sh
+```
+
+---
+
+## Documentation Complète
+
+- **Guide détaillé** : `COMMENT_LANCER.md`
+- **README complet** : `geniusia2/README.md`
+- **Résolution problèmes** : `RESOLUTION_COMPLETE.md`
+
+---
+
+**C'est parti ! 🚀**
--- a/docs/guides/DEMARRAGE_RAPIDE_MVP.md
+++ b/docs/guides/DEMARRAGE_RAPIDE_MVP.md
@@ -0,0 +1,250 @@
+# 🚀 Démarrage Rapide - RPA Vision V2 MVP
+
+## 📋 Prérequis
+
+- Python 3.8+
+- Ollama installé et en cours d'exécution
+- 8 GB RAM minimum
+- Linux (testé sur Ubuntu)
+
+## ⚡ Installation Rapide
+
+### 1. Installation complète
+
+```bash
+cd geniusia2
+./setup.sh
+```
+
+Ce script va :
+- ✅ Créer l'environnement virtuel
+- ✅ Installer toutes les dépendances
+- ✅ Télécharger le modèle Gemma3 (via Ollama)
+- ✅ Créer les répertoires de données
+
+### 2. Installer FAISS (CRITIQUE)
+
+```bash
+cd geniusia2
+./install_faiss.sh
+```
+
+Ou manuellement :
+```bash
+source geniusia2/venv/bin/activate
+pip install faiss-cpu
+```
+
+### 3. Reconstruire l'index FAISS (si des tâches existent)
+
+```bash
+python3 rebuild_faiss_simple.py
+```
+
+Cela va créer l'index à partir des 105 tâches existantes.
+
+## 🎮 Utilisation
+
+### Lancer l'application
+
+```bash
+cd geniusia2
+./run.sh
+```
+
+Ou manuellement :
+```bash
+cd geniusia2
+source venv/bin/activate
+python3 main.py
+```
+
+### Workflow complet (Capture → Apprentissage → Rejeu)
+
+```bash
+python3 example_complete_workflow.py
+```
+
+### Tester le rejeu d'une tâche
+
+```bash
+python3 test_task_replay.py
+```
+
+## 🔧 Scripts Utilitaires
+
+### Diagnostic des données
+
+```bash
+python3 diagnostic_data.py
+```
+
+Affiche :
+- État de l'index FAISS
+- Nombre de tâches
+- État des logs
+
+### Lire une tâche (.pkl)
+
+```bash
+# Lister toutes les tâches
+python3 read_pkl.py --list
+
+# Lire une tâche spécifique
+python3 read_pkl.py task_fc1d3e52
+```
+
+### Reconstruire l'index FAISS
+
+```bash
+python3 rebuild_faiss_simple.py
+```
+
+## 📊 Structure des Données
+
+```
+geniusia2/data/
+├── faiss_index/
+│   ├── embeddings.index    # Index FAISS (créé automatiquement)
+│   └── metadata.pkl         # Métadonnées des embeddings
+├── user_profiles/
+│   └── task_XXXXX/
+│       ├── metadata.json    # Infos de la tâche
+│       └── signatures.pkl   # Actions + embeddings
+└── logs/
+    └── logs_YYYY-MM-DD.json # Logs en JSON simple (pas de chiffrement)
+```
+
+## 🎯 Modes d'Utilisation
+
+### Mode Shadow (Observation)
+
+1. Lancer l'application : `./run.sh`
+2. Cliquer sur "Start"
+3. Effectuer des actions répétitives (3x minimum)
+4. Le système détecte les patterns et crée des tâches
+
+### Mode Rejeu
+
+1. Lister les tâches : `python3 read_pkl.py --list`
+2. Rejouer une tâche : `python3 test_task_replay.py`
+3. Choisir la tâche à rejouer
+4. Le système localise visuellement les éléments et rejoue les actions
+
+## 🔍 Vérifications
+
+### Vérifier que FAISS est installé
+
+```bash
+cd geniusia2
+source venv/bin/activate
+python -c "import faiss; print(f'FAISS {faiss.__version__} OK')"
+```
+
+### Vérifier que l'index FAISS existe
+
+```bash
+ls -lh geniusia2/data/faiss_index/
+```
+
+Devrait afficher :
+- `embeddings.index` (quelques KB)
+- `metadata.pkl` (quelques KB)
+
+### Vérifier les tâches
+
+```bash
+python3 diagnostic_data.py
+```
+
+## ⚠️ Problèmes Courants
+
+### FAISS non installé
+
+**Symptôme** : `ModuleNotFoundError: No module named 'faiss'`
+
+**Solution** :
+```bash
+cd geniusia2
+./install_faiss.sh
+```
+
+### Index FAISS manquant
+
+**Symptôme** : Pas de fichiers dans `data/faiss_index/`
+
+**Solution** :
+```bash
+python3 rebuild_faiss_simple.py
+```
+
+### Ollama non démarré
+
+**Symptôme** : Erreurs de connexion au LLM
+
+**Solution** :
+```bash
+ollama serve
+```
+
+Dans un autre terminal :
+```bash
+ollama pull gemma2:2b
+```
+
+### Pas de tâches
+
+**Symptôme** : `Aucune tâche disponible`
+
+**Solution** :
+1. Lancer l'application : `cd geniusia2 && ./run.sh`
+2. Cliquer sur "Start"
+3. Effectuer des actions répétitives (3x minimum)
+4. Attendre la détection de pattern
+
+## 📝 Logs
+
+Les logs sont maintenant en **JSON simple** (pas de chiffrement pour MVP) :
+
+```bash
+# Voir les logs du jour
+cat geniusia2/data/logs/logs_$(date +%Y-%m-%d).json | jq .
+
+# Filtrer les actions
+cat geniusia2/data/logs/logs_$(date +%Y-%m-%d).json | jq 'select(.type=="action")'
+```
+
+## 🎯 Prochaines Étapes
+
+1. ✅ Installer FAISS : `./install_faiss.sh`
+2. ✅ Reconstruire l'index : `python3 rebuild_faiss_simple.py`
+3. ✅ Tester le rejeu : `python3 test_task_replay.py`
+4. ✅ Lancer l'application : `./run.sh`
+
+## 📚 Documentation
+
+- `README.md` : Documentation complète
+- `MODIFICATIONS_MVP.md` : Changements récents
+- `état_avancement_18_11.md` : État du projet
+- `MVP_COMPLET_REJEU.md` : Système de rejeu
+- `geniusia2/core/TASK_REPLAY_README.md` : API de rejeu
+
+## 🆘 Support
+
+En cas de problème :
+
+1. Vérifier les logs : `cat geniusia2/data/logs/logs_$(date +%Y-%m-%d).json`
+2. Diagnostic : `python3 diagnostic_data.py`
+3. Vérifier FAISS : `python -c "import faiss; print('OK')"`
+
+## ✅ Checklist de Démarrage
+
+- [ ] Python 3.8+ installé
+- [ ] Ollama installé et démarré (`ollama serve`)
+- [ ] Modèle Gemma3 téléchargé (`ollama pull gemma2:2b`)
+- [ ] Environnement virtuel créé (`./setup.sh`)
+- [ ] FAISS installé (`./install_faiss.sh`)
+- [ ] Index FAISS créé (`python3 rebuild_faiss_simple.py`)
+- [ ] Application testée (`./run.sh`)
+
+**Prêt à l'emploi ! 🎉**
--- a/docs/guides/GUIDE_INSTALLATION_UTILISATION.md
+++ b/docs/guides/GUIDE_INSTALLATION_UTILISATION.md
@@ -0,0 +1,229 @@
+# 📖 Guide d'Installation et d'Utilisation
+
+## 🎯 Deux Scripts Différents
+
+### `setup.sh` - Installation Complète (À faire UNE FOIS)
+
+**Ce qu'il fait** :
+- ✅ Crée l'environnement virtuel (`venv/`)
+- ✅ Installe toutes les dépendances (`requirements.txt`)
+- ✅ Vérifie Ollama
+- ✅ Télécharge les modèles
+- ✅ Crée les répertoires de données
+
+**Quand l'utiliser** :
+- Première installation
+- Après avoir cloné le repo
+- Après avoir supprimé le venv
+
+**Commande** :
+```bash
+cd geniusia2
+./setup.sh
+```
+
+### `run.sh` - Lancement de l'Application (À chaque utilisation)
+
+**Ce qu'il fait** :
+- ✅ Vérifie que le venv existe
+- ✅ Vérifie que FAISS est installé
+- ✅ Vérifie qu'Ollama tourne
+- ✅ Lance l'application
+
+**Ce qu'il NE fait PAS** :
+- ❌ Ne crée PAS le venv
+- ❌ N'installe PAS les dépendances
+- ❌ N'installe PAS FAISS automatiquement
+
+**Quand l'utiliser** :
+- Pour lancer l'application
+- Après avoir fait `setup.sh`
+
+**Commande** :
+```bash
+cd geniusia2
+./run.sh
+```
+
+## 📋 Workflow Complet
+
+### Première Installation
+
+```bash
+# 1. Installation complète
+cd geniusia2
+./setup.sh
+
+# 2. Installer FAISS (si pas fait par setup.sh)
+./install_faiss.sh
+
+# 3. Reconstruire l'index FAISS (si des tâches existent)
+cd ..
+./rebuild_index.sh
+
+# 4. Lancer l'application
+cd geniusia2
+./run.sh
+```
+
+### Utilisation Quotidienne
+
+```bash
+# 1. Démarrer Ollama (si pas déjà lancé)
+ollama serve &
+
+# 2. Lancer l'application
+cd geniusia2
+./run.sh
+```
+
+## 🔧 Scripts Disponibles
+
+### Dans `geniusia2/`
+
+| Script | Description | Quand l'utiliser |
+|--------|-------------|------------------|
+| `setup.sh` | Installation complète | Une fois au début |
+| `run.sh` | Lance l'application | À chaque utilisation |
+| `install_faiss.sh` | Installe FAISS | Si FAISS manque |
+
+### À la racine
+
+| Script | Description | Quand l'utiliser |
+|--------|-------------|------------------|
+| `rebuild_index.sh` | Reconstruit l'index FAISS | Si index manquant/corrompu |
+| `test_task_replay.py` | Test de rejeu | Pour tester |
+| `example_complete_workflow.py` | Workflow complet | Pour démo |
+| `diagnostic_data.py` | Diagnostic | Pour vérifier l'état |
+| `read_pkl.py` | Lecture des tâches | Pour explorer |
+
+## ⚠️ Problèmes Courants
+
+### "Environnement virtuel non trouvé"
+
+**Symptôme** : `./run.sh` dit que le venv n'existe pas
+
+**Solution** :
+```bash
+cd geniusia2
+./setup.sh
+```
+
+### "FAISS n'est pas installé"
+
+**Symptôme** : `./run.sh` propose d'installer FAISS
+
+**Solution 1** : Accepter l'installation (taper 'o')
+
+**Solution 2** : Installer manuellement
+```bash
+cd geniusia2
+./install_faiss.sh
+```
+
+### "Ollama ne semble pas être en cours d'exécution"
+
+**Symptôme** : Message d'avertissement au lancement
+
+**Solution** :
+```bash
+# Dans un terminal séparé
+ollama serve
+```
+
+### Scripts Python ne fonctionnent pas
+
+**Symptôme** : `ModuleNotFoundError` ou `ImportError`
+
+**Solution** : Utiliser le Python du venv
+```bash
+# ❌ Mauvais
+python3 test_task_replay.py
+
+# ✅ Bon
+geniusia2/venv/bin/python test_task_replay.py
+```
+
+## 📊 Vérification de l'Installation
+
+### Checklist
+
+```bash
+# 1. Vérifier que le venv existe
+ls geniusia2/venv/
+
+# 2. Vérifier que FAISS est installé
+geniusia2/venv/bin/python -c "import faiss; print('✅ FAISS OK')"
+
+# 3. Vérifier que l'index FAISS existe
+ls -lh geniusia2/data/faiss_index/
+
+# 4. Vérifier qu'Ollama tourne
+pgrep -x ollama && echo "✅ Ollama OK" || echo "❌ Ollama non lancé"
+
+# 5. Diagnostic complet
+geniusia2/venv/bin/python diagnostic_data.py
+```
+
+### Résultat Attendu
+
+```
+✅ FAISS OK
+✅ Ollama OK
+✅ Index FAISS : 595 KB
+✅ 99 tâches disponibles
+```
+
+## 🎯 Résumé
+
+### Pour Installer (Une fois)
+
+```bash
+cd geniusia2
+./setup.sh
+./install_faiss.sh
+```
+
+### Pour Utiliser (À chaque fois)
+
+```bash
+# Terminal 1 : Ollama
+ollama serve
+
+# Terminal 2 : Application
+cd geniusia2
+./run.sh
+```
+
+### Pour Tester
+
+```bash
+geniusia2/venv/bin/python test_task_replay.py
+```
+
+## 📝 Notes Importantes
+
+1. **`setup.sh` ne lance PAS l'application** - Il installe seulement
+2. **`run.sh` ne fait PAS l'installation** - Il lance seulement
+3. **Toujours utiliser le Python du venv** pour les scripts
+4. **Ollama doit tourner** avant de lancer l'application
+
+## 🆘 En Cas de Doute
+
+```bash
+# Tout réinstaller
+cd geniusia2
+rm -rf venv
+./setup.sh
+./install_faiss.sh
+
+# Vérifier
+cd ..
+geniusia2/venv/bin/python diagnostic_data.py
+
+# Lancer
+cd geniusia2
+./run.sh
+```
+
+**Tout devrait fonctionner ! 🚀**
--- a/docs/guides/GUIDE_TEST_MODE_ASSISTE.md
+++ b/docs/guides/GUIDE_TEST_MODE_ASSISTE.md
@@ -0,0 +1,364 @@
+# 🧪 Guide de Test - Mode Assisté
+
+## 🎯 Objectif
+
+Tester le Mode Assisté en conditions réelles pour valider son fonctionnement.
+
+## ✅ Prérequis
+
+1. Tous les tests unitaires passent :
+   ```bash
+   geniusia2/venv/bin/python test_mode_assiste_complet.py
+   ```
+   Résultat attendu : 4/4 tests réussis ✅
+
+2. L'application se lance :
+   ```bash
+   cd geniusia2
+   ./run.sh
+   ```
+
+## 📋 Scénarios de Test
+
+### Scénario 1 : Apprentissage Simple
+
+**Objectif** : Créer une tâche simple et vérifier qu'elle est apprise.
+
+**Étapes** :
+
+1. **Lancer l'application**
+   ```bash
+   cd geniusia2
+   ./run.sh
+   ```
+
+2. **Démarrer la capture**
+   - Cliquer sur "Start"
+   - Vérifier que le statut passe à "Running"
+
+3. **Effectuer une action répétitive (3x)**
+   - Exemple : Cliquer 3 fois sur le même bouton
+   - Attendre 1-2 secondes entre chaque clic
+   - Observer les logs
+
+4. **Vérifier la création de tâche**
+   - Regarder les logs : "Pattern détecté"
+   - Vérifier : "Tâche créée"
+   - Noter le nom de la tâche
+
+5. **Arrêter la capture**
+   - Cliquer sur "Stop"
+
+**Résultat attendu** :
+- ✅ Pattern détecté après 3 actions
+- ✅ Tâche créée avec un nom descriptif
+- ✅ Fichiers créés dans `data/user_profiles/`
+
+### Scénario 2 : Suggestion Simple
+
+**Objectif** : Vérifier qu'une suggestion apparaît pour une action similaire.
+
+**Étapes** :
+
+1. **Avoir une tâche apprise** (Scénario 1)
+
+2. **Redémarrer la capture**
+   - Cliquer sur "Start"
+
+3. **Effectuer une action similaire**
+   - Faire la même action qu'avant (1 fois)
+   - Attendre quelques secondes
+
+4. **Observer la suggestion**
+   - Un overlay devrait apparaître
+   - Vérifier le contenu :
+     - Nom de la tâche
+     - Confiance (%)
+     - Instructions (Entrée/Échap/Alt+C)
+
+**Résultat attendu** :
+- ✅ Overlay apparaît après l'action
+- ✅ Confiance >= 75%
+- ✅ Nom de tâche correct
+- ✅ Instructions visibles
+
+### Scénario 3 : Acceptation de Suggestion
+
+**Objectif** : Tester l'exécution automatique d'une suggestion.
+
+**Étapes** :
+
+1. **Avoir une suggestion affichée** (Scénario 2)
+
+2. **Accepter la suggestion**
+   - Appuyer sur **Entrée**
+
+3. **Observer l'exécution**
+   - Regarder les logs : "Suggestion acceptée"
+   - Observer l'exécution automatique
+   - Vérifier le résultat
+
+4. **Vérifier la notification**
+   - Message de succès/échec
+   - Nombre d'actions exécutées
+
+**Résultat attendu** :
+- ✅ Suggestion acceptée
+- ✅ Actions exécutées automatiquement
+- ✅ Notification de succès
+- ✅ Overlay disparaît
+
+### Scénario 4 : Refus de Suggestion
+
+**Objectif** : Tester le refus d'une suggestion.
+
+**Étapes** :
+
+1. **Avoir une suggestion affichée** (Scénario 2)
+
+2. **Refuser la suggestion**
+   - Appuyer sur **Échap**
+
+3. **Observer le comportement**
+   - Regarder les logs : "Suggestion rejetée"
+   - Vérifier que l'overlay disparaît
+   - Vérifier qu'aucune action n'est exécutée
+
+**Résultat attendu** :
+- ✅ Suggestion rejetée
+- ✅ Aucune action exécutée
+- ✅ Overlay disparaît
+- ✅ Notification de refus
+
+### Scénario 5 : Timeout de Suggestion
+
+**Objectif** : Vérifier que la suggestion expire après 10 secondes.
+
+**Étapes** :
+
+1. **Avoir une suggestion affichée** (Scénario 2)
+
+2. **Ne rien faire**
+   - Attendre 10 secondes
+   - Ne pas appuyer sur de touches
+
+3. **Observer le timeout**
+   - Regarder les logs : "Suggestion expirée"
+   - Vérifier que l'overlay disparaît
+
+**Résultat attendu** :
+- ✅ Suggestion expire après 10s
+- ✅ Overlay disparaît
+- ✅ Aucune action exécutée
+- ✅ Log de timeout
+
+### Scénario 6 : Actions Multiples
+
+**Objectif** : Tester une tâche avec plusieurs actions.
+
+**Étapes** :
+
+1. **Créer une tâche complexe**
+   - Effectuer une séquence : clic → type → clic
+   - Répéter 3 fois la même séquence
+
+2. **Vérifier la création**
+   - Tâche créée avec plusieurs actions
+   - Signatures pour chaque action
+
+3. **Tester la suggestion**
+   - Refaire la première action
+   - Accepter la suggestion
+
+4. **Observer l'exécution**
+   - Toutes les actions sont rejouées
+   - Dans le bon ordre
+   - Avec les bons délais
+
+**Résultat attendu** :
+- ✅ Tâche multi-actions créée
+- ✅ Suggestion apparaît
+- ✅ Toutes les actions rejouées
+- ✅ Ordre correct
+
+### Scénario 7 : Variations d'Interface
+
+**Objectif** : Vérifier l'adaptation aux changements d'interface.
+
+**Étapes** :
+
+1. **Créer une tâche** sur une fenêtre
+
+2. **Modifier légèrement l'interface**
+   - Déplacer la fenêtre
+   - Redimensionner
+   - Changer de thème (si possible)
+
+3. **Tester la suggestion**
+   - Refaire l'action
+   - Accepter la suggestion
+
+4. **Observer l'adaptation**
+   - Recherche visuelle fonctionne
+   - Élément trouvé malgré les changements
+   - Action exécutée correctement
+
+**Résultat attendu** :
+- ✅ Élément trouvé malgré les changements
+- ✅ Confiance >= 70%
+- ✅ Action exécutée correctement
+
+## 📊 Grille d'Évaluation
+
+### Fonctionnalités de Base
+
+| Fonctionnalité | Testé | Résultat | Notes |
+|----------------|-------|----------|-------|
+| Apprentissage simple | ☐ | ☐ Pass ☐ Fail | |
+| Suggestion apparaît | ☐ | ☐ Pass ☐ Fail | |
+| Acceptation (Entrée) | ☐ | ☐ Pass ☐ Fail | |
+| Refus (Échap) | ☐ | ☐ Pass ☐ Fail | |
+| Timeout (10s) | ☐ | ☐ Pass ☐ Fail | |
+
+### Fonctionnalités Avancées
+
+| Fonctionnalité | Testé | Résultat | Notes |
+|----------------|-------|----------|-------|
+| Actions multiples | ☐ | ☐ Pass ☐ Fail | |
+| Variations d'interface | ☐ | ☐ Pass ☐ Fail | |
+| Confiance >= 75% | ☐ | ☐ Pass ☐ Fail | |
+| Exécution correcte | ☐ | ☐ Pass ☐ Fail | |
+
+### Interface Utilisateur
+
+| Aspect | Testé | Résultat | Notes |
+|--------|-------|----------|-------|
+| Overlay visible | ☐ | ☐ Pass ☐ Fail | |
+| Informations claires | ☐ | ☐ Pass ☐ Fail | |
+| Réactivité | ☐ | ☐ Pass ☐ Fail | |
+| Notifications | ☐ | ☐ Pass ☐ Fail | |
+
+## 🐛 Problèmes Connus
+
+### Problème 1 : Pas de Suggestion
+
+**Symptôme** : Aucune suggestion n'apparaît après une action similaire.
+
+**Causes possibles** :
+- Confiance < 75%
+- Pas de tâche similaire dans l'index
+- Contexte trop différent
+
+**Solutions** :
+1. Vérifier les logs : "Similarité: X%"
+2. Baisser le seuil dans `config.yaml` : `similarity_threshold: 0.65`
+3. Recréer la tâche avec plus d'exemples
+
+### Problème 2 : Exécution Échoue
+
+**Symptôme** : La suggestion est acceptée mais l'exécution échoue.
+
+**Causes possibles** :
+- Élément non trouvé
+- Interface a trop changé
+- Permissions insuffisantes
+
+**Solutions** :
+1. Vérifier les logs : "Élément non trouvé"
+2. Refaire l'apprentissage
+3. Vérifier les permissions (X11, Wayland)
+
+### Problème 3 : Overlay ne Disparaît Pas
+
+**Symptôme** : L'overlay reste affiché après acceptation/refus.
+
+**Causes possibles** :
+- Bug dans la GUI
+- Callback non appelé
+
+**Solutions** :
+1. Appuyer sur Échap
+2. Redémarrer l'application
+3. Vérifier les logs
+
+## 📝 Rapport de Test
+
+### Informations Système
+
+- **OS** : Linux / Windows / macOS
+- **Version Python** : 3.12
+- **Date** : ___________
+- **Testeur** : ___________
+
+### Résultats Globaux
+
+- **Scénarios testés** : ___ / 7
+- **Scénarios réussis** : ___ / 7
+- **Taux de réussite** : ___%
+
+### Observations
+
+**Points positifs** :
+- 
+- 
+- 
+
+**Points à améliorer** :
+- 
+- 
+- 
+
+**Bugs trouvés** :
+- 
+- 
+- 
+
+### Recommandations
+
+**Priorité Haute** :
+- 
+- 
+
+**Priorité Moyenne** :
+- 
+- 
+
+**Priorité Basse** :
+- 
+- 
+
+## 🎯 Critères de Validation
+
+Le Mode Assisté est considéré comme **validé** si :
+
+✅ Au moins 5/7 scénarios passent  
+✅ Aucun bug bloquant  
+✅ Confiance >= 75% pour les suggestions  
+✅ Exécution réussie >= 80% du temps  
+✅ Interface utilisateur claire et réactive  
+
+## 🚀 Après les Tests
+
+### Si Validation OK
+
+1. Documenter les résultats
+2. Passer au Mode Autopilot
+3. Implémenter les transitions
+
+### Si Validation KO
+
+1. Identifier les problèmes
+2. Prioriser les corrections
+3. Corriger et re-tester
+
+## 📞 Support
+
+En cas de problème :
+
+1. Vérifier les logs : `geniusia2/data/logs/`
+2. Lancer les tests unitaires : `test_mode_assiste_complet.py`
+3. Consulter la documentation : `MODE_ASSISTE_FINAL.md`
+
+---
+
+**Bon test ! 🧪**
--- a/docs/guides/POUR_DEMARRER.md
+++ b/docs/guides/POUR_DEMARRER.md
@@ -0,0 +1,177 @@
+# 🚀 Pour Démarrer avec GeniusIA v2
+
+## 📖 Lis-moi d'abord !
+
+Bienvenue dans GeniusIA v2 ! Ce document te guide pour démarrer rapidement.
+
+## 🎯 C'est quoi ?
+
+Un assistant RPA qui :
+1. **Observe** tes actions (Mode Shadow)
+2. **Apprend** les patterns répétitifs
+3. **Suggère** les prochaines étapes (Mode Assisté)
+4. **Rejoue** les tâches automatiquement
+
+## ⚡ Démarrage ultra-rapide
+
+### 1. Installer
+```bash
+cd geniusia2
+./setup.sh
+```
+
+### 2. Lancer
+```bash
+./run.sh
+```
+
+C'est tout ! 🎉
+
+## 📚 Documentation
+
+### Tu veux...
+
+**Comprendre le projet** → Lis [README_SIMPLE.md](README_SIMPLE.md)
+
+**Installer proprement** → Lis [GUIDE_INSTALLATION_UTILISATION.md](GUIDE_INSTALLATION_UTILISATION.md)
+
+**Tester le Mode Assisté** → Lis [GUIDE_TEST_MODE_ASSISTE.md](GUIDE_TEST_MODE_ASSISTE.md)
+
+**Comprendre les workflows** → Lis [WORKFLOW_DETECTION_IMPLEMENTATION.md](WORKFLOW_DETECTION_IMPLEMENTATION.md)
+
+**Voir toute la doc** → Lis [INDEX_DOCUMENTATION_COMPLET.md](INDEX_DOCUMENTATION_COMPLET.md)
+
+## 🧪 Tests rapides
+
+```bash
+# Test basique
+python test_whitelist_simple.py
+
+# Test du Mode Assisté
+python test_mode_assiste_complet.py
+
+# Test du LLM
+python test_qwen3_vl.py
+```
+
+## 🔧 Commandes utiles
+
+```bash
+# Lancer l'app
+./LANCER_APPLICATION.sh
+
+# Vérifier l'installation
+./VERIFIER_INSTALLATION.sh
+
+# Voir toutes les commandes
+cat COMMANDES_RAPIDES.md
+```
+
+## 🏗️ Structure du code
+
+```
+geniusia2/
+├── core/                    # Logique métier
+│   ├── orchestrator.py      # Boucle principale
+│   ├── learning_manager.py  # Apprentissage
+│   ├── suggestion_manager.py # Suggestions
+│   ├── event_capture.py     # Capture d'événements
+│   ├── session_manager.py   # Gestion des sessions
+│   └── workflow_detector.py # Détection de workflows
+│
+├── gui/                     # Interface
+│   ├── minimal_gui.py       # GUI principale
+│   └── suggestion_overlay.py # Overlay
+│
+└── data/                    # Données
+    ├── user_profiles/       # Profils appris
+    └── logs/                # Logs
+```
+
+## 🎮 Modes
+
+### Mode Shadow (Observation)
+```python
+# Lance l'app, elle observe tes actions
+./run.sh
+# Fais des actions répétitives (3x minimum)
+# Le système détecte automatiquement les patterns
+```
+
+### Mode Assisté (Suggestions)
+```python
+# Lance l'app en mode assisté
+./run.sh --mode assist
+# Commence un workflow connu
+# L'overlay suggère la prochaine étape
+```
+
+## 🐛 Problèmes ?
+
+### Ollama ne démarre pas
+```bash
+systemctl --user start ollama
+ollama list  # Vérifier les modèles
+```
+
+### Modèles manquants
+```bash
+ollama pull gemma2:2b
+ollama pull nomic-embed-text
+```
+
+### Erreurs Python
+```bash
+cd geniusia2
+source venv/bin/activate
+pip install -r requirements.txt
+```
+
+## 📊 État actuel
+
+### ✅ Fonctionnel
+- Mode Shadow
+- Capture d'événements
+- Détection de patterns
+- Système de rejeu
+- Whitelist de sécurité
+
+### 🚧 En cours
+- Détection de workflows complets
+- Suggestions intelligentes
+- Interface améliorée
+
+## 🎯 Prochaines étapes
+
+1. **Tester** le Mode Shadow
+2. **Observer** la détection de patterns
+3. **Essayer** le Mode Assisté
+4. **Rejouer** une tâche apprise
+
+## 💡 Conseils
+
+- **Commence simple** : Fais 3x la même action
+- **Sois patient** : L'apprentissage prend du temps
+- **Teste souvent** : Utilise les scripts de test
+- **Lis les logs** : `geniusia2/data/logs/`
+
+## 🆘 Besoin d'aide ?
+
+1. Lis [DEBUG_GUIDE.md](DEBUG_GUIDE.md)
+2. Vérifie [ETAT_PROJET_PROPRE.md](ETAT_PROJET_PROPRE.md)
+3. Regarde les tests dans `test_*.py`
+
+## 🎉 C'est parti !
+
+```bash
+cd geniusia2
+./run.sh
+```
+
+Amuse-toi bien ! 🚀
+
+---
+
+**Version** : MVP 1.0
+**Date** : Novembre 2024
+**Statut** : Prêt à tester !
--- a/docs/guides/README_MVP.md
+++ b/docs/guides/README_MVP.md
@@ -0,0 +1,353 @@
+# 🤖 RPA Vision V2 - MVP
+
+Système d'automatisation robotique à apprentissage progressif utilisant la vision par ordinateur et l'IA.
+
+## 🎯 Vue d'Ensemble
+
+RPA Vision V2 **observe, apprend et rejoue** les interactions avec les interfaces utilisateur de manière intelligente.
+
+### Fonctionnalités MVP
+
+- ✅ **Capture d'événements** : Enregistre les actions clavier/souris avec screenshots
+- ✅ **Détection de patterns** : Identifie les séquences répétitives (3+ fois)
+- ✅ **Analyse visuelle** : Utilise CLIP, OWL-v2, DINO, YOLO pour comprendre l'interface
+- ✅ **Signatures visuelles** : Crée des embeddings pour chaque action
+- ✅ **Descriptions intelligentes** : Génère des descriptions avec Gemma3
+- ✅ **Rejeu intelligent** : Rejoue les tâches en localisant visuellement les éléments
+- ✅ **Adaptation automatique** : S'adapte aux variations d'interface
+
+## 🚀 Installation Rapide
+
+### 1. Prérequis
+
+- Python 3.8+
+- Ollama installé
+- 8 GB RAM minimum
+- Linux (testé sur Ubuntu)
+
+### 2. Installation
+
+```bash
+# Cloner le repo
+git clone <repo-url>
+cd Geniusia_v2
+
+# Installation complète
+cd geniusia2
+./setup.sh
+
+# Installer FAISS (CRITIQUE)
+./install_faiss.sh
+
+# Reconstruire l'index FAISS (si des tâches existent)
+cd ..
+python3 rebuild_faiss_simple.py
+```
+
+### 3. Lancement
+
+```bash
+cd geniusia2
+./run.sh
+```
+
+## 📖 Guide d'Utilisation
+
+### Workflow Complet
+
+```bash
+# Démonstration complète : Capture → Apprentissage → Rejeu
+python3 example_complete_workflow.py
+```
+
+### Mode Capture (Apprentissage)
+
+1. Lancer l'application : `cd geniusia2 && ./run.sh`
+2. Cliquer sur "Start"
+3. Effectuer des actions répétitives (3x minimum)
+4. Le système détecte les patterns et crée des tâches automatiquement
+
+### Mode Rejeu
+
+```bash
+# Lister les tâches disponibles
+python3 read_pkl.py --list
+
+# Rejouer une tâche
+python3 test_task_replay.py
+```
+
+Le système va :
+1. Charger la tâche
+2. Pour chaque action :
+   - Capturer l'écran actuel
+   - Rechercher l'élément visuellement (grille 4x4 + CLIP)
+   - Exécuter l'action à la position trouvée
+3. Afficher les résultats
+
+## 🏗️ Architecture
+
+```
+geniusia2/
+├── core/                      # Logique centrale
+│   ├── task_replay.py        # ✨ Moteur de rejeu intelligent
+│   ├── event_capture.py      # Capture d'événements
+│   ├── learning_manager.py   # Apprentissage de tâches
+│   ├── embeddings_manager.py # Gestion FAISS
+│   ├── logger.py             # Logs (JSON simple pour MVP)
+│   └── utils/
+│       ├── vision_utils.py   # Analyse visuelle (CLIP, OWL-v2, etc.)
+│       └── input_utils.py    # Contrôle souris/clavier
+├── gui/                       # Interface PyQt5
+├── data/
+│   ├── user_profiles/        # Tâches apprises
+│   │   └── task_XXXXX/
+│   │       ├── metadata.json # Infos de la tâche
+│   │       └── signatures.pkl # Actions + embeddings
+│   ├── faiss_index/          # Index de recherche
+│   │   ├── embeddings.index  # Index FAISS
+│   │   └── metadata.pkl      # Métadonnées
+│   └── logs/                 # Logs JSON
+└── main.py                    # Point d'entrée
+
+Scripts utilitaires (racine) :
+├── test_task_replay.py        # Test de rejeu
+├── example_complete_workflow.py # Workflow complet
+├── read_pkl.py                # Lecture des .pkl
+├── rebuild_faiss_simple.py    # Reconstruction index
+└── diagnostic_data.py         # Diagnostic
+```
+
+## 🔧 Scripts Utilitaires
+
+### Diagnostic
+
+```bash
+python3 diagnostic_data.py
+```
+
+Affiche :
+- État de l'index FAISS
+- Nombre de tâches
+- État des logs
+
+### Lecture de Tâches
+
+```bash
+# Lister toutes les tâches
+python3 read_pkl.py --list
+
+# Lire une tâche spécifique
+python3 read_pkl.py task_fc1d3e52
+```
+
+### Reconstruction de l'Index FAISS
+
+```bash
+python3 rebuild_faiss_simple.py
+```
+
+Extrait les embeddings de toutes les tâches et crée l'index FAISS.
+
+## 🎮 Modes Opérationnels
+
+### 👀 Mode Shadow (Actuel)
+
+**Fonctionnalités** :
+- Capture des événements utilisateur
+- Détection de patterns répétitifs
+- Création automatique de tâches
+- Génération de signatures visuelles
+
+**Utilisation** :
+1. Lancer l'app : `./run.sh`
+2. Cliquer "Start"
+3. Effectuer des actions répétitives
+4. Les tâches sont créées automatiquement
+
+### 🎮 Mode Rejeu (Nouveau !)
+
+**Fonctionnalités** :
+- Chargement de tâches apprises
+- Recherche visuelle d'éléments (CLIP)
+- Exécution adaptative d'actions
+- Monitoring en temps réel
+
+**Utilisation** :
+```bash
+python3 test_task_replay.py
+```
+
+### 🤝 Mode Assisté (À venir)
+
+- Suggestions d'actions
+- Validation utilisateur
+- Superposition visuelle
+
+### 🤖 Mode Autopilot (À venir)
+
+- Exécution automatique
+- Transitions de mode
+- Dashboard de métriques
+
+## 📊 Données
+
+### Structure d'une Tâche
+
+```
+data/user_profiles/task_fc1d3e52/
+├── metadata.json      # Infos générales
+└── signatures.pkl     # Actions + embeddings
+```
+
+**metadata.json** :
+```json
+{
+  "task_id": "task_fc1d3e52",
+  "task_name": "Défilement rapide",
+  "window_whitelist": ["Firefox"],
+  "observation_count": 3,
+  "mode": "shadow",
+  "confidence_score": 0.0
+}
+```
+
+**signatures.pkl** (binaire) :
+- Liste d'actions
+- Chaque action contient :
+  - `embedding` : numpy array (512,) float32
+  - `action_type` : "mouse_click", "scroll", etc.
+  - `position` : (x, y)
+  - `element_type` : "icon", "button", etc.
+  - `window` : Titre de la fenêtre
+
+### Logs
+
+Format JSON simple (pas de chiffrement pour MVP) :
+
+```bash
+cat geniusia2/data/logs/logs_$(date +%Y-%m-%d).json | jq .
+```
+
+## 🔍 Dépendances Critiques
+
+### FAISS (CRITIQUE)
+
+**Pourquoi** : Recherche de similarité pour localiser les éléments
+
+**Installation** :
+```bash
+cd geniusia2
+./install_faiss.sh
+```
+
+Ou manuellement :
+```bash
+pip install faiss-cpu
+```
+
+### Ollama + Gemma3
+
+**Pourquoi** : Génération de descriptions intelligentes
+
+**Installation** :
+```bash
+# Installer Ollama
+curl -fsSL https://ollama.com/install.sh | sh
+
+# Télécharger Gemma3
+ollama pull gemma2:2b
+
+# Démarrer Ollama
+ollama serve
+```
+
+## ⚠️ Problèmes Courants
+
+### FAISS non installé
+
+**Symptôme** : `ModuleNotFoundError: No module named 'faiss'`
+
+**Solution** :
+```bash
+cd geniusia2
+./install_faiss.sh
+```
+
+### Index FAISS manquant
+
+**Symptôme** : Pas de fichiers dans `data/faiss_index/`
+
+**Solution** :
+```bash
+python3 rebuild_faiss_simple.py
+```
+
+### Ollama non démarré
+
+**Symptôme** : Erreurs de connexion au LLM
+
+**Solution** :
+```bash
+ollama serve
+```
+
+## 📈 Avancement
+
+**Version actuelle** : MVP 0.6
+
+| Fonctionnalité | Avancement | Statut |
+|----------------|------------|--------|
+| Capture d'événements | 90% | ✅ Fonctionnel |
+| Analyse visuelle | 85% | ✅ Fonctionnel |
+| Mémoire FAISS | 80% | ✅ Opérationnel |
+| Apprentissage | 85% | ✅ Fonctionnel |
+| **Rejeu intelligent** | **90%** | **✅ Fonctionnel** |
+| Mode Assisté | 5% | ❌ À faire |
+| Mode Autopilot | 50% | ⚠️ Partiel |
+| Transitions | 10% | ❌ À faire |
+| Dashboard | 20% | ⚠️ Basique |
+
+**Avancement global** : ~60%
+
+## 📚 Documentation
+
+- **`DEMARRAGE_RAPIDE_MVP.md`** : Guide de démarrage complet
+- **`MODIFICATIONS_MVP.md`** : Changements récents
+- **`CHANGELOG_MVP.md`** : Historique des versions
+- **`état_avancement_18_11.md`** : État détaillé du projet
+- **`MVP_COMPLET_REJEU.md`** : Documentation du système de rejeu
+- **`geniusia2/core/TASK_REPLAY_README.md`** : API de rejeu
+
+## 🤝 Contribution
+
+Le projet est en phase MVP. Les contributions sont bienvenues pour :
+
+- Améliorer la recherche visuelle (multi-échelle)
+- Implémenter le mode Assisté
+- Ajouter des tests
+- Optimiser les performances
+
+## 📝 Licence
+
+[À définir]
+
+## 🆘 Support
+
+En cas de problème :
+
+1. Vérifier les logs : `cat geniusia2/data/logs/logs_$(date +%Y-%m-%d).json`
+2. Diagnostic : `python3 diagnostic_data.py`
+3. Vérifier FAISS : `python -c "import faiss; print('OK')"`
+
+## ✅ Checklist de Démarrage
+
+- [ ] Python 3.8+ installé
+- [ ] Ollama installé et démarré
+- [ ] Modèle Gemma3 téléchargé
+- [ ] Environnement virtuel créé (`./setup.sh`)
+- [ ] FAISS installé (`./install_faiss.sh`)
+- [ ] Index FAISS créé (`python3 rebuild_faiss_simple.py`)
+- [ ] Application testée (`./run.sh`)
+
+**Prêt à l'emploi ! 🎉**
--- a/docs/guides/README_SIMPLE.md
+++ b/docs/guides/README_SIMPLE.md
@@ -0,0 +1,185 @@
+# GeniusIA v2 - MVP
+
+## 🎯 Qu'est-ce que c'est ?
+Un assistant RPA (Robotic Process Automation) qui apprend vos actions et vous aide à les automatiser.
+
+## 🚀 Démarrage rapide
+
+### 1. Installation
+```bash
+cd geniusia2
+./setup.sh
+```
+
+### 2. Lancer l'application
+```bash
+./run.sh
+```
+
+### 3. Vérifier l'installation
+```bash
+../VERIFIER_INSTALLATION.sh
+```
+
+## 📚 Documentation essentielle
+
+### Guides de démarrage
+- **[README_MVP.md](README_MVP.md)** - Guide complet du MVP
+- **[DEMARRAGE_RAPIDE_MVP.md](DEMARRAGE_RAPIDE_MVP.md)** - Démarrage rapide
+- **[GUIDE_INSTALLATION_UTILISATION.md](GUIDE_INSTALLATION_UTILISATION.md)** - Installation détaillée
+
+### Fonctionnalités
+- **[FONCTIONNEMENT_MODE_SHADOW.md](FONCTIONNEMENT_MODE_SHADOW.md)** - Mode observation
+- **[MODE_ASSISTE_CONCEPTION.md](MODE_ASSISTE_CONCEPTION.md)** - Mode assisté
+- **[SYSTEME_REJEU_IMPLEMENTATION.md](SYSTEME_REJEU_IMPLEMENTATION.md)** - Système de rejeu
+
+### Tests
+- **[GUIDE_TEST_MODE_ASSISTE.md](GUIDE_TEST_MODE_ASSISTE.md)** - Tester le mode assisté
+- **[COMMENT_TESTER_WORKFLOWS.md](COMMENT_TESTER_WORKFLOWS.md)** - Tester les workflows
+
+### Configuration
+- **[QWEN3_VL_CONFIGURATION.md](QWEN3_VL_CONFIGURATION.md)** - Configuration du LLM
+- **[MODES_SECURITE.md](MODES_SECURITE.md)** - Sécurité et whitelist
+
+## 🏗️ Architecture
+
+```
+geniusia2/
+├── core/               # Logique métier
+│   ├── orchestrator.py       # Boucle cognitive principale
+│   ├── learning_manager.py   # Apprentissage
+│   ├── suggestion_manager.py # Suggestions (Mode Assisté)
+│   ├── event_capture.py      # Capture d'événements
+│   ├── session_manager.py    # Gestion des sessions
+│   └── workflow_detector.py  # Détection de workflows
+├── gui/                # Interface graphique
+│   ├── minimal_gui.py        # GUI principale
+│   └── suggestion_overlay.py # Overlay de suggestions
+└── data/               # Données utilisateur
+    ├── user_profiles/        # Profils et tâches apprises
+    └── logs/                 # Logs d'activité
+```
+
+## 🎮 Modes de fonctionnement
+
+### Mode Shadow (Observation)
+- Observe vos actions
+- Détecte les patterns répétitifs
+- Apprend automatiquement
+
+### Mode Assisté
+- Suggère des actions basées sur l'apprentissage
+- Détecte les workflows en cours
+- Propose la prochaine étape
+
+### Mode Autonome (Futur)
+- Exécute automatiquement les tâches apprises
+- Nécessite validation utilisateur
+
+## 🧪 Tests disponibles
+
+```bash
+# Tests unitaires
+python test_whitelist_simple.py
+python test_input_utils_simple.py
+python test_learning_manager_simple.py
+
+# Tests d'intégration
+python test_whitelist_integration.py
+python test_orchestrator_simple.py
+python test_mode_assiste_complet.py
+
+# Tests spécifiques
+python test_qwen3_vl.py          # Test du LLM
+python test_task_replay.py       # Test du rejeu
+python test_summary_dashboard.py # Test du dashboard
+```
+
+## 📝 Scripts utiles
+
+```bash
+# Lancer l'application
+./LANCER_APPLICATION.sh
+
+# Vérifier l'installation
+./VERIFIER_INSTALLATION.sh
+
+# Commandes rapides
+./COMMANDES_RAPIDES.sh
+
+# Nettoyer le projet
+./cleanup_project.sh
+
+# Rebuild FAISS index
+python rebuild_faiss_simple.py
+```
+
+## 🔧 Configuration
+
+Le fichier `geniusia2/core/config.py` contient toute la configuration :
+- Chemins des modèles
+- Seuils de confiance
+- Timeouts
+- Paramètres de sécurité
+
+## 📊 Statut du projet
+
+### ✅ Fonctionnel
+- Mode Shadow (observation)
+- Capture d'événements
+- Détection de patterns simples
+- Système de rejeu
+- Whitelist de sécurité
+
+### 🚧 En cours
+- Détection de workflows complets
+- Suggestions intelligentes (Mode Assisté)
+- Interface graphique améliorée
+
+### 📅 À venir
+- Mode Autonome
+- Dashboard de statistiques
+- Export/Import de workflows
+
+## 🐛 Dépannage
+
+### Problèmes courants
+
+**Ollama ne démarre pas**
+```bash
+systemctl --user start ollama
+```
+
+**Modèles manquants**
+```bash
+ollama pull gemma2:2b
+ollama pull nomic-embed-text
+```
+
+**Erreurs de permissions**
+```bash
+chmod +x geniusia2/run.sh
+chmod +x LANCER_APPLICATION.sh
+```
+
+## 📞 Support
+
+- **Documentation** : Voir [INDEX_DOCUMENTATION_COMPLET.md](INDEX_DOCUMENTATION_COMPLET.md)
+- **Changelog** : Voir [CHANGELOG_MVP.md](CHANGELOG_MVP.md)
+- **Implémentations** : Voir les fichiers `*_IMPLEMENTATION_SUMMARY.md`
+
+## 🎯 Objectif MVP
+
+Créer un assistant RPA simple qui :
+1. Observe vos actions (Mode Shadow)
+2. Détecte les workflows répétitifs
+3. Suggère les prochaines étapes (Mode Assisté)
+4. Permet de rejouer les tâches apprises
+
+**Focus** : Simplicité et fonctionnalité de base, pas de sur-ingénierie !
+
+---
+
+**Version** : MVP 1.0
+**Date** : Novembre 2024
+**Statut** : En développement actif