Initial commit

2026-03-05 00:20:25 +01:00
commit dcd4de9945
1954 changed files with 669380 additions and 0 deletions
--- a/.kiro/specs/gui-logs-improvement/design.md
+++ b/.kiro/specs/gui-logs-improvement/design.md
@@ -0,0 +1,400 @@
+# Design - Amélioration GUI et Logs
+
+## Overview
+
+Ce document décrit l'architecture et le design de la nouvelle interface utilisateur minimaliste et du système de logs amélioré pour GeniusIA v2.
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────┐
+│                    Main Application                      │
+└────────────────┬────────────────────────────────────────┘
+                 │
+        ┌────────┴────────┐
+        ▼                 ▼
+┌──────────────┐  ┌──────────────────┐
+│ Orchestrator │  │  Improved GUI    │
+│              │  │                  │
+│ - Détecte    │──│ - System Tray   │
+│ - Apprend    │  │ - Logs Panel    │
+│ - Suggère    │  │ - Popups        │
+└──────┬───────┘  └──────────────────┘
+       │
+       ▼
+┌──────────────┐
+│ HumanLogger  │
+│              │
+│ - Messages   │
+│ - Formatting │
+└──────────────┘
+```
+
+## Components and Interfaces
+
+### 1. HumanLogger
+
+Classe pour générer des messages lisibles par l'utilisateur.
+
+```python
+class HumanLogger:
+    """
+    Logger qui génère des messages simples pour l'utilisateur.
+    """
+    
+    def log_observation(self, action_type: str, window: str):
+        """Log une action observée."""
+        return f"👀 Action dans {window}"
+    
+    def log_pattern_detected(self, repetitions: int, task_name: str):
+        """Log un pattern détecté."""
+        return f"🎯 Pattern détecté: {task_name} (répété {repetitions}x)"
+    
+    def log_workflow_learned(self, task_name: str, count: int):
+        """Log un workflow appris."""
+        return f"📚 Workflow appris: {task_name} ({count} observations)"
+    
+    def log_mode_change(self, old_mode: str, new_mode: str):
+        """Log un changement de mode."""
+        return f"✅ Mode {new_mode} activé"
+    
+    def log_finetuning_started(self, num_examples: int):
+        """Log le début du fine-tuning."""
+        return f"🧠 Amélioration du modèle ({num_examples} exemples)..."
+    
+    def log_finetuning_completed(self, duration: float):
+        """Log la fin du fine-tuning."""
+        return f"✅ Modèle amélioré (en {duration:.1f}s)"
+```
+
+### 2. ImprovedGUI
+
+Interface minimaliste avec system tray.
+
+#### Layout Principal
+
+```
+┌─────────────────────────────────────┐
+│  GeniusIA v2                  [_][X]│
+├─────────────────────────────────────┤
+│                                     │
+│  Mode: 👀 Observation               │
+│  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  │
+│                                     │
+│  📊 Activité:                       │
+│  • 12 actions observées             │
+│  • 2 patterns détectés              │
+│                                     │
+│  🧠 Fine-tuning:                    │
+│  • 8/10 exemples collectés          │
+│                                     │
+├─────────────────────────────────────┤
+│  📝 Journal:                        │
+│  ┌─────────────────────────────────┐│
+│  │14:23 👀 J'observe...            ││
+│  │14:24 🎯 Pattern: Calculer 9/9   ││
+│  │14:24 📚 J'apprends...           ││
+│  │14:25 💡 Prêt à suggérer         ││
+│  │14:26 ✅ Mode Suggestions activé ││
+│  └─────────────────────────────────┘│
+│                                     │
+│  [Pause] [Arrêter]                 │
+└─────────────────────────────────────┘
+```
+
+#### System Tray
+
+```
+Icône dans la barre: 🤖
+
+Menu clic droit:
+┌─────────────────────┐
+│ 🤖 GeniusIA v2      │
+├─────────────────────┤
+│ 👀 Mode: Shadow     │
+│ 📊 12 actions       │
+├─────────────────────┤
+│ Afficher            │
+│ Masquer             │
+│ ─────────────────   │
+│ Quitter             │
+└─────────────────────┘
+```
+
+#### Popup Interactif
+
+```
+┌─────────────────────────────────────────┐
+│  💡 J'ai une idée !                     │
+│                                         │
+│  J'ai remarqué que vous faites souvent: │
+│  "Calculer 9/9 dans la calculatrice"   │
+│                                         │
+│  Est-ce que je peux essayer de vous    │
+│  suggérer cette action la prochaine    │
+│  fois ?                                 │
+│                                         │
+│  [Oui, essaie !]  [Non, continue]     │
+│                                         │
+│  ⏱️ Fermeture auto dans 10s            │
+└─────────────────────────────────────────┘
+```
+
+### 3. LogsPanel
+
+Widget pour afficher les logs avec scroll.
+
+```python
+class LogsPanel(QWidget):
+    """
+    Panneau d'affichage des logs avec scroll.
+    
+    - Affiche 5 dernières actions
+    - Scrollable jusqu'à 30
+    - Auto-scroll si en bas
+    - Format: HH:MM emoji Message
+    """
+    
+    def add_log(self, message: str, emoji: str = "ℹ️"):
+        """Ajoute un log avec timestamp."""
+        pass
+    
+    def clear(self):
+        """Efface tous les logs."""
+        pass
+    
+    def get_logs(self) -> List[str]:
+        """Retourne l'historique."""
+        pass
+```
+
+### 4. InteractiveDialog
+
+Popup pour dialogues avec timeout.
+
+```python
+class InteractiveDialog(QDialog):
+    """
+    Dialogue interactif avec timeout automatique.
+    
+    - Non-bloquant (l'app continue)
+    - Timeout 10 secondes
+    - Callbacks pour réponses
+    """
+    
+    def __init__(
+        self,
+        title: str,
+        message: str,
+        on_accept: Callable,
+        on_reject: Callable,
+        timeout: int = 10
+    ):
+        pass
+```
+
+## Data Models
+
+### LogMessage
+
+```python
+@dataclass
+class LogMessage:
+    """Message de log pour affichage."""
+    timestamp: datetime
+    emoji: str
+    message: str
+    level: str  # 'info', 'success', 'warning', 'error'
+    technical_details: Optional[str] = None  # Pour logs techniques
+```
+
+### GUIState
+
+```python
+@dataclass
+class GUIState:
+    """État de la GUI."""
+    mode: str  # 'shadow', 'assist', 'auto'
+    is_running: bool
+    actions_count: int
+    patterns_count: int
+    workflows_count: int
+    finetuning_status: Optional[str]  # None, 'collecting', 'training', 'completed'
+    finetuning_progress: Optional[int]  # 0-100 ou None
+```
+
+## Error Handling
+
+### Erreurs GUI
+
+- **Erreur d'affichage** : Logger et continuer sans GUI
+- **Erreur system tray** : Fallback vers fenêtre normale
+- **Erreur popup** : Logger et utiliser notification simple
+
+### Erreurs Logs
+
+- **Fichier de log inaccessible** : Créer nouveau fichier avec timestamp
+- **Disque plein** : Nettoyer anciens logs automatiquement
+- **Permission refusée** : Logger dans /tmp en fallback
+
+## Testing Strategy
+
+### Unit Tests
+
+- Test HumanLogger : Vérifier format des messages
+- Test LogsPanel : Vérifier scroll et limite 30
+- Test InteractiveDialog : Vérifier timeout
+- Test GUIState : Vérifier mise à jour
+
+### Integration Tests
+
+- Test Orchestrator → GUI : Vérifier envoi de messages
+- Test Popup → Orchestrator : Vérifier callbacks
+- Test System Tray : Vérifier menu et actions
+
+### Manual Tests
+
+- Test sur Ubuntu : Vérifier system tray et thème
+- Test avec actions répétitives : Vérifier détection
+- Test timeout : Vérifier fermeture auto après 10s
+
+## Correctness Properties
+
+*A property is a characteristic or behavior that should hold true across all valid executions of a system.*
+
+### Property 1: Log History Bounds
+
+*For any* sequence of log messages, the visible history should never exceed 30 messages.
+
+**Validates: Requirements 3.3**
+
+### Property 2: Timeout Consistency
+
+*For any* interactive dialog, if no user response is received within 10 seconds, the dialog should close automatically.
+
+**Validates: Requirements 4.3**
+
+### Property 3: Mode Display Consistency
+
+*For any* mode change, the GUI should display the correct mode icon and label within 100ms.
+
+**Validates: Requirements 5.1**
+
+### Property 4: Message Ordering
+
+*For any* sequence of events, the logs should appear in chronological order.
+
+**Validates: Requirements 2.1, 2.2, 2.3, 2.4**
+
+### Property 5: Non-blocking Dialogs
+
+*For any* interactive dialog displayed, the Orchestrator should continue processing events.
+
+**Validates: Requirements 4.2**
+
+## Implementation Notes
+
+### PyQt5 Signals
+
+Utiliser des signaux Qt pour communication thread-safe :
+
+```python
+class GUISignals(QObject):
+    """Signaux pour communication Orchestrator → GUI."""
+    log_message = pyqtSignal(str, str)  # (emoji, message)
+    update_stats = pyqtSignal(dict)  # GUIState
+    show_dialog = pyqtSignal(str, str, object, object)  # (title, msg, on_accept, on_reject)
+    mode_changed = pyqtSignal(str)  # nouveau mode
+```
+
+### System Tray Ubuntu
+
+Utiliser `QSystemTrayIcon` avec fallback si non supporté :
+
+```python
+if QSystemTrayIcon.isSystemTrayAvailable():
+    self.tray_icon = QSystemTrayIcon(QIcon.fromTheme("robot"))
+    self.tray_icon.setToolTip("GeniusIA v2")
+else:
+    # Fallback: fenêtre normale
+    self.setWindowFlags(Qt.Window)
+```
+
+### Logs Techniques
+
+Format structuré pour parsing facile :
+
+```
+2024-11-20 14:23:45.123 [INFO] EventCapture: Mouse click at (450, 320) in "Calculator"
+2024-11-20 14:23:46.456 [DEBUG] SessionManager: Action added to session_001
+2024-11-20 14:24:12.789 [INFO] WorkflowDetector: Pattern detected (3 repetitions)
+```
+
+### Performance
+
+- Logs GUI : Max 30 messages en mémoire
+- Logs fichier : Rotation à 10MB
+- Mise à jour GUI : Max 10 fois/seconde
+- Popups : Timeout 10s pour éviter accumulation
+
+## UI/UX Considerations
+
+### Discrétion
+
+- Fenêtre petite (300x400px)
+- Minimisable
+- System tray toujours visible
+- Pas de sons
+
+### Clarté
+
+- Messages courts (max 50 caractères)
+- Emojis pour reconnaissance rapide
+- Couleurs pour niveaux (info/success/warning/error)
+- Timestamps relatifs ("il y a 2 min")
+
+### Réactivité
+
+- Mise à jour en temps réel
+- Pas de freeze
+- Feedback immédiat sur actions
+
+## Migration Plan
+
+### Phase 1: Créer nouveaux composants
+
+1. HumanLogger
+2. ImprovedGUI
+3. LogsPanel
+4. InteractiveDialog
+
+### Phase 2: Modifier Orchestrator
+
+1. Ajouter envoi de messages humains
+2. Connecter aux signaux GUI
+3. Déclencher dialogues interactifs
+
+### Phase 3: Remplacer ancienne GUI
+
+1. Renommer `minimal_gui.py` → `minimal_gui_old.py`
+2. Renommer `improved_gui.py` → `minimal_gui.py`
+3. Tester
+
+### Phase 4: Cleanup
+
+1. Supprimer anciens boutons (liste blanche, etc.)
+2. Supprimer code inutilisé
+3. Documentation
+
+## Security Considerations
+
+- Logs techniques : Ne pas logger de données sensibles
+- Popups : Timeout pour éviter DOS
+- System tray : Vérifier permissions Ubuntu
+
+## Accessibility
+
+- Contraste suffisant pour lisibilité
+- Taille de police ajustable
+- Support clavier complet
+- Screen reader compatible (ARIA labels)
--- a/.kiro/specs/gui-logs-improvement/requirements.md
+++ b/.kiro/specs/gui-logs-improvement/requirements.md
@@ -0,0 +1,137 @@
+# Requirements - Amélioration GUI et Logs
+
+## Introduction
+
+GeniusIA v2 nécessite une interface utilisateur claire et des logs lisibles pour permettre à l'utilisateur de comprendre ce qui se passe et faciliter le debugging. L'interface actuelle manque de visibilité et les logs sont trop techniques.
+
+## Glossary
+
+- **GUI**: Interface graphique utilisateur (Graphical User Interface)
+- **System Tray**: Zone de notification dans la barre des tâches (Ubuntu)
+- **Popup**: Fenêtre modale temporaire pour dialogues
+- **Human Logs**: Messages simples destinés à l'utilisateur
+- **Technical Logs**: Logs détaillés pour debugging
+- **Mode**: État opérationnel (Shadow/Suggestions/Copilote/Autonome)
+- **Fine-tuning**: Processus d'amélioration du modèle d'embeddings
+
+## Requirements
+
+### Requirement 1: Interface Minimaliste
+
+**User Story:** En tant qu'utilisateur, je veux une interface discrète qui ne me dérange pas, pour pouvoir travailler normalement tout en gardant un œil sur l'IA.
+
+#### Acceptance Criteria
+
+1. WHEN l'application démarre THEN la GUI SHALL créer une fenêtre de 300x400 pixels maximum
+2. WHEN l'utilisateur clique sur minimiser THEN la GUI SHALL se réduire dans la barre des tâches Ubuntu
+3. WHEN l'application tourne THEN la GUI SHALL afficher une icône dans le system tray
+4. WHEN l'utilisateur clique sur l'icône system tray THEN la GUI SHALL afficher un menu avec options (Afficher/Masquer/Quitter)
+5. WHEN la fenêtre est fermée THEN l'application SHALL continuer à tourner en arrière-plan
+
+### Requirement 2: Logs Humains Lisibles
+
+**User Story:** En tant qu'utilisateur, je veux voir ce que l'IA fait en langage simple, pour comprendre son comportement sans jargon technique.
+
+#### Acceptance Criteria
+
+1. WHEN une action est observée THEN la GUI SHALL afficher un message simple comme "👀 J'observe vos actions..."
+2. WHEN un pattern est détecté THEN la GUI SHALL afficher "🎯 Tiens ! Vous avez fait 3 fois la même chose"
+3. WHEN un workflow est appris THEN la GUI SHALL afficher "📚 J'apprends: [nom du workflow]"
+4. WHEN le mode change THEN la GUI SHALL afficher "✅ Mode [nouveau mode] activé"
+5. WHEN une erreur survient THEN la GUI SHALL afficher un message compréhensible sans stack trace
+
+### Requirement 3: Historique des Logs
+
+**User Story:** En tant qu'utilisateur, je veux voir les dernières actions pour comprendre ce qui s'est passé récemment.
+
+#### Acceptance Criteria
+
+1. WHEN des logs sont affichés THEN la GUI SHALL montrer les 5 dernières actions visibles
+2. WHEN l'utilisateur scrolle THEN la GUI SHALL permettre de voir jusqu'à 30 actions
+3. WHEN l'historique dépasse 30 actions THEN le système SHALL supprimer les plus anciennes
+4. WHEN un nouveau log arrive THEN la GUI SHALL auto-scroller vers le bas si déjà en bas
+5. WHEN l'utilisateur scrolle manuellement THEN la GUI SHALL ne pas auto-scroller
+
+### Requirement 4: Dialogues Interactifs
+
+**User Story:** En tant qu'utilisateur, je veux que l'IA me demande mon avis avant de changer de comportement, pour garder le contrôle.
+
+#### Acceptance Criteria
+
+1. WHEN un pattern est détecté THEN la GUI SHALL afficher un popup "Est-ce que je peux essayer ?"
+2. WHEN un popup est affiché THEN l'application SHALL continuer à fonctionner (non-bloquant)
+3. WHEN 10 secondes passent sans réponse THEN le popup SHALL se fermer automatiquement
+4. WHEN l'utilisateur clique "Oui" THEN le système SHALL basculer en mode Suggestions
+5. WHEN l'utilisateur clique "Non" THEN le système SHALL rester en mode Shadow
+
+### Requirement 5: Indicateurs de Statut
+
+**User Story:** En tant qu'utilisateur, je veux voir l'état actuel de l'IA en un coup d'œil, pour savoir ce qu'elle fait.
+
+#### Acceptance Criteria
+
+1. WHEN la GUI est affichée THEN elle SHALL montrer le mode actuel avec icône (👀/💡/🤖/⚡)
+2. WHEN des actions sont observées THEN la GUI SHALL afficher le compteur d'actions
+3. WHEN le fine-tuning est en cours THEN la GUI SHALL afficher "🧠 Apprentissage en cours..."
+4. WHEN le fine-tuning est terminé THEN la GUI SHALL afficher "✅ Modèle amélioré"
+5. WHEN aucune activité THEN la GUI SHALL afficher "💤 En attente..."
+
+### Requirement 6: Logs Techniques pour Debugging
+
+**User Story:** En tant que développeur, je veux des logs détaillés dans un fichier, pour pouvoir debugger les problèmes.
+
+#### Acceptance Criteria
+
+1. WHEN l'application tourne THEN le système SHALL écrire les logs techniques dans `geniusia2/logs/debug.log`
+2. WHEN un événement survient THEN le log SHALL inclure timestamp, niveau, composant et message
+3. WHEN une erreur survient THEN le log SHALL inclure la stack trace complète
+4. WHEN le fichier dépasse 10MB THEN le système SHALL créer un nouveau fichier avec rotation
+5. WHEN les logs sont écrits THEN ils SHALL être flushés immédiatement pour éviter les pertes
+
+### Requirement 7: Communication GUI-Orchestrator
+
+**User Story:** En tant que système, je dois pouvoir envoyer des messages de l'Orchestrator vers la GUI, pour tenir l'utilisateur informé.
+
+#### Acceptance Criteria
+
+1. WHEN l'Orchestrator détecte un événement THEN il SHALL envoyer un message à la GUI via signal Qt
+2. WHEN un message est envoyé THEN il SHALL inclure type, contenu et timestamp
+3. WHEN la GUI reçoit un message THEN elle SHALL l'afficher dans les 100ms
+4. WHEN un dialogue est nécessaire THEN l'Orchestrator SHALL déclencher un popup via la GUI
+5. WHEN l'utilisateur répond THEN la GUI SHALL notifier l'Orchestrator via callback
+
+### Requirement 8: Statistiques Visibles
+
+**User Story:** En tant qu'utilisateur, je veux voir ce que l'IA a appris, pour comprendre sa progression.
+
+#### Acceptance Criteria
+
+1. WHEN la GUI est affichée THEN elle SHALL montrer le nombre d'actions observées aujourd'hui
+2. WHEN des workflows sont détectés THEN la GUI SHALL afficher le nombre de workflows
+3. WHEN le fine-tuning collecte des exemples THEN la GUI SHALL afficher "X exemples collectés"
+4. WHEN le fine-tuning est déclenché THEN la GUI SHALL afficher une barre de progression
+5. WHEN les stats sont affichées THEN elles SHALL se mettre à jour en temps réel
+
+### Requirement 9: Compatibilité Ubuntu
+
+**User Story:** En tant qu'utilisateur Ubuntu, je veux que l'interface fonctionne nativement, sans problèmes d'affichage.
+
+#### Acceptance Criteria
+
+1. WHEN l'application démarre sur Ubuntu THEN la GUI SHALL utiliser le thème système
+2. WHEN l'icône system tray est créée THEN elle SHALL être visible dans la barre supérieure
+3. WHEN des popups sont affichés THEN ils SHALL respecter le window manager Ubuntu
+4. WHEN la fenêtre est redimensionnée THEN elle SHALL respecter les contraintes de taille
+5. WHEN l'application se ferme THEN elle SHALL libérer proprement les ressources système
+
+### Requirement 10: Messages Contextuels
+
+**User Story:** En tant qu'utilisateur, je veux que les messages soient adaptés au contexte, pour mieux comprendre ce qui se passe.
+
+#### Acceptance Criteria
+
+1. WHEN un workflow est détecté pour la première fois THEN le message SHALL expliquer ce qu'est un workflow
+2. WHEN le mode progressif propose de basculer THEN le message SHALL expliquer ce que ça change
+3. WHEN une erreur survient THEN le message SHALL suggérer une action corrective
+4. WHEN le fine-tuning démarre THEN le message SHALL expliquer pourquoi
+5. WHEN l'utilisateur n'a pas d'activité depuis 5 min THEN la GUI SHALL afficher un message d'encouragement
--- a/.kiro/specs/gui-logs-improvement/tasks.md
+++ b/.kiro/specs/gui-logs-improvement/tasks.md
@@ -0,0 +1,159 @@
+# Implementation Plan - Amélioration GUI et Logs
+
+- [x] 1. Créer le composant HumanLogger
+  - Implémenter la classe HumanLogger avec méthodes de formatage
+  - Créer des méthodes pour chaque type de message (observation, pattern, workflow, mode, fine-tuning)
+  - Ajouter support pour emojis et messages contextuels
+  - _Requirements: 2.1, 2.2, 2.3, 2.4, 10.1, 10.2, 10.3, 10.4_
+
+- [x] 1.1 Écrire des tests unitaires pour HumanLogger
+  - Tester le formatage des messages
+  - Vérifier les emojis corrects
+  - Tester les messages contextuels
+  - _Requirements: 2.1, 2.2, 2.3, 2.4_
+
+- [x] 2. Créer le composant LogsPanel
+  - Implémenter le widget Qt pour affichage des logs
+  - Ajouter système de scroll avec limite à 30 messages
+  - Implémenter auto-scroll conditionnel (seulement si déjà en bas)
+  - Ajouter formatage avec timestamp et emoji
+  - _Requirements: 3.1, 3.2, 3.3, 3.4, 3.5_
+
+- [ ]* 2.1 Écrire un test de propriété pour la limite de logs
+  - **Property 1: Log History Bounds**
+  - **Validates: Requirements 3.3**
+
+- [ ]* 2.2 Écrire des tests unitaires pour LogsPanel
+  - Tester l'ajout de logs
+  - Tester le scroll automatique
+  - Tester la limite de 30 messages
+  - _Requirements: 3.1, 3.2, 3.3, 3.4, 3.5_
+
+- [x] 3. Créer le composant InteractiveDialog
+  - Implémenter le dialogue Qt avec timeout de 10 secondes
+  - Ajouter callbacks pour réponses utilisateur (accept/reject)
+  - Implémenter fermeture automatique après timeout
+  - Rendre le dialogue non-bloquant
+  - _Requirements: 4.1, 4.2, 4.3, 4.4, 4.5_
+
+- [ ]* 3.1 Écrire un test de propriété pour le timeout
+  - **Property 2: Timeout Consistency**
+  - **Validates: Requirements 4.3**
+
+- [ ]* 3.2 Écrire des tests unitaires pour InteractiveDialog
+  - Tester le timeout automatique
+  - Tester les callbacks
+  - Tester le comportement non-bloquant
+  - _Requirements: 4.1, 4.2, 4.3, 4.4, 4.5_
+
+- [x] 4. Créer les modèles de données
+  - Implémenter LogMessage dataclass
+  - Implémenter GUIState dataclass
+  - Ajouter méthodes de sérialisation si nécessaire
+  - _Requirements: 5.1, 5.2, 5.3, 5.4, 5.5, 8.1, 8.2, 8.3, 8.4, 8.5_
+
+- [x] 5. Créer le système de signaux Qt
+  - Implémenter GUISignals avec pyqtSignal
+  - Ajouter signaux pour log_message, update_stats, show_dialog, mode_changed
+  - Documenter l'utilisation des signaux
+  - _Requirements: 7.1, 7.2, 7.3, 7.4, 7.5_
+
+- [x] 6. Créer la nouvelle ImprovedGUI
+  - Implémenter la fenêtre principale (300x400px)
+  - Ajouter le panneau de statut avec mode et icône
+  - Intégrer LogsPanel dans la fenêtre
+  - Ajouter les boutons Pause/Arrêter
+  - _Requirements: 1.1, 5.1, 5.2, 5.3, 5.4, 5.5_
+
+- [x] 7. Implémenter le System Tray
+  - Créer l'icône dans la barre des tâches Ubuntu
+  - Implémenter le menu contextuel (Afficher/Masquer/Quitter)
+  - Gérer la minimisation vers le tray
+  - Ajouter fallback si system tray non disponible
+  - _Requirements: 1.2, 1.3, 1.4, 1.5, 9.1, 9.2, 9.3_
+
+- [ ]* 7.1 Tester le system tray sur Ubuntu
+  - Vérifier l'icône dans la barre supérieure
+  - Tester le menu contextuel
+  - Tester la minimisation
+  - _Requirements: 1.3, 1.4, 9.2_
+
+- [ ] 8. Implémenter l'affichage des statistiques
+  - Ajouter widget pour afficher actions observées
+  - Ajouter widget pour patterns détectés
+  - Ajouter widget pour workflows appris
+  - Ajouter indicateur de fine-tuning avec progression
+  - Implémenter mise à jour en temps réel
+  - _Requirements: 8.1, 8.2, 8.3, 8.4, 8.5_
+
+- [ ]* 8.1 Écrire un test de propriété pour l'affichage du mode
+  - **Property 3: Mode Display Consistency**
+  - **Validates: Requirements 5.1**
+
+- [x] 9. Intégrer HumanLogger dans l'Orchestrator
+  - Ajouter instance de HumanLogger dans Orchestrator
+  - Remplacer les logs techniques par des messages humains pour la GUI
+  - Envoyer les messages via les signaux Qt
+  - Garder les logs techniques dans le fichier debug.log
+  - _Requirements: 2.1, 2.2, 2.3, 2.4, 7.1, 7.2, 7.3_
+
+- [ ]* 9.1 Écrire un test de propriété pour l'ordre des messages
+  - **Property 4: Message Ordering**
+  - **Validates: Requirements 2.1, 2.2, 2.3, 2.4**
+
+- [ ] 10. Connecter les dialogues interactifs
+  - Modifier Orchestrator pour déclencher des dialogues via signaux
+  - Implémenter callbacks pour réponses utilisateur
+  - Gérer le changement de mode basé sur les réponses
+  - _Requirements: 4.1, 4.4, 4.5, 7.4, 7.5, 10.2_
+
+- [ ]* 10.1 Écrire un test de propriété pour les dialogues non-bloquants
+  - **Property 5: Non-blocking Dialogs**
+  - **Validates: Requirements 4.2**
+
+- [ ] 11. Implémenter le système de logs techniques
+  - Créer le répertoire geniusia2/logs si nécessaire
+  - Implémenter l'écriture dans debug.log avec format structuré
+  - Ajouter rotation des logs à 10MB
+  - Implémenter flush immédiat pour éviter pertes
+  - Gérer les erreurs (disque plein, permissions)
+  - _Requirements: 6.1, 6.2, 6.3, 6.4, 6.5_
+
+- [ ]* 11.1 Écrire des tests unitaires pour le système de logs
+  - Tester l'écriture dans le fichier
+  - Tester la rotation à 10MB
+  - Tester le flush immédiat
+  - Tester les fallbacks en cas d'erreur
+  - _Requirements: 6.1, 6.2, 6.3, 6.4, 6.5_
+
+- [ ] 12. Implémenter les messages contextuels
+  - Ajouter logique pour détecter première fois (workflow, mode change)
+  - Créer messages explicatifs pour première utilisation
+  - Ajouter suggestions d'actions correctives pour erreurs
+  - Implémenter message d'encouragement après inactivité
+  - _Requirements: 10.1, 10.2, 10.3, 10.4, 10.5_
+
+- [ ] 13. Tester la compatibilité Ubuntu
+  - Vérifier le thème système
+  - Tester le system tray dans la barre supérieure
+  - Vérifier les popups avec le window manager
+  - Tester le redimensionnement de fenêtre
+  - Vérifier la libération des ressources à la fermeture
+  - _Requirements: 9.1, 9.2, 9.3, 9.4, 9.5_
+
+- [ ] 14. Migration et intégration finale
+  - Renommer minimal_gui.py → minimal_gui_old.py
+  - Renommer improved_gui.py → minimal_gui.py
+  - Mettre à jour main.py pour utiliser la nouvelle GUI
+  - Supprimer les anciens boutons (liste blanche, etc.)
+  - Nettoyer le code inutilisé
+  - _Requirements: 1.1, 1.2, 1.3, 1.4, 1.5_
+
+- [ ]* 14.1 Écrire des tests d'intégration
+  - Tester Orchestrator → GUI
+  - Tester Popup → Orchestrator
+  - Tester System Tray
+  - _Requirements: 7.1, 7.2, 7.3, 7.4, 7.5_
+
+- [ ] 15. Checkpoint final - Vérifier que tout fonctionne
+  - Ensure all tests pass, ask the user if questions arise.