Geniusia_v2/geniusia2/core/ORCHESTRATOR_README.md

Orchestrateur - Boucle Cognitive RPA Vision V2

Vue d'ensemble

L'orchestrateur est le composant central de RPA Vision V2 qui implémente la boucle cognitive principale suivant le paradigme Observer → Réfléchir → Agir → Apprendre.

Architecture

┌─────────────────────────────────────────────────┐
│           BOUCLE COGNITIVE PRINCIPALE           │
│                                                 │
│  1. OBSERVER                                    │
│     ├─ Capturer l'écran (capture_screen)       │
│     └─ Détecter fenêtre active                 │
│                                                 │
│  2. RÉFLÉCHIR                                   │
│     ├─ Détecter éléments UI (VisionUtils)      │
│     └─ Raisonner sur l'action (LLMManager)     │
│                                                 │
│  3. AGIR                                        │
│     ├─ Mode Shadow: Observer uniquement        │
│     ├─ Mode Assisté: Suggérer + Valider        │
│     └─ Mode Autopilot: Exécuter                │
│                                                 │
│  4. APPRENDRE                                   │
│     └─ Mettre à jour LearningManager           │
└─────────────────────────────────────────────────┘

Composants Intégrés

• LearningManager: Gestion de l'apprentissage et transitions de mode
• VisionUtils: Détection d'éléments UI avec OWL-v2/DINO/YOLO
• LLMManager: Raisonnement visuel avec Qwen 2.5-VL
• Logger: Journalisation chiffrée de toutes les actions
• GUI: Interface utilisateur (optionnel)

Modes Opérationnels

Mode Shadow (👀)

• Observe les actions utilisateur sans exécuter
• Enregistre les observations pour apprentissage
• Construit la mémoire visuelle

Mode Assisté (🤝)

• Suggère des actions basées sur l'apprentissage
• Attend validation utilisateur (Entrée/Échap/Alt+C)
• Apprend des corrections

Mode Autopilot (🤖)

• Exécute automatiquement les actions
• Vérifie la liste blanche avant exécution
• Rétrograde si confiance < 90%

Sécurité

Liste Blanche

• Vérifie que la fenêtre est autorisée avant toute action
• Bloque et journalise les violations
• Configurable dynamiquement

Arrêt d'Urgence

• Ctrl+Pause (ou Ctrl+C) arrête immédiatement
• Journalise l'événement de sécurité
• Retour au mode Assisté

Journalisation

• Toutes les actions sont loggées avec chiffrement AES-256
• Inclut: fenêtre, action, confiance, résultat
• Traçabilité complète pour audit

Métriques de Performance

L'orchestrateur suit:

• total_cycles: Nombre de cycles de la boucle cognitive
• avg_latency_ms: Latence moyenne (cible: <400ms)
• detections_count: Nombre d'éléments détectés
• actions_executed: Actions exécutées en mode Autopilot
• actions_suggested: Actions suggérées en mode Assisté

Utilisation

Initialisation

from geniusia2.core.orchestrator import Orchestrator
from geniusia2.core.learning_manager import LearningManager
from geniusia2.core.utils.vision_utils import VisionUtils
from geniusia2.core.llm_manager import LLMManager
from geniusia2.core.logger import Logger
from geniusia2.core.embeddings_manager import EmbeddingsManager
from geniusia2.core.config import get_config

# Initialiser les composants
config = get_config()
logger = Logger()
embeddings_manager = EmbeddingsManager()
learning_manager = LearningManager(embeddings_manager, logger, config)
vision_utils = VisionUtils(config)
llm_manager = LLMManager(logger=logger)

# Créer l'orchestrateur
orchestrator = Orchestrator(
    learning_manager=learning_manager,
    vision_utils=vision_utils,
    llm_manager=llm_manager,
    logger=logger,
    gui=None  # Ou votre instance GUI
)

Démarrage

# Configurer la liste blanche
orchestrator.add_to_whitelist("Dolibarr*")
orchestrator.add_to_whitelist("Firefox*")

# Définir l'intention actuelle
learning_manager.set_current_context({"intent": "cliquer sur valider"})

# Démarrer la boucle cognitive (dans un thread séparé)
import threading
cognitive_thread = threading.Thread(target=orchestrator.run)
cognitive_thread.start()

# Arrêter proprement
orchestrator.stop()
cognitive_thread.join()

Gestion de la Liste Blanche

# Ajouter une fenêtre
orchestrator.add_to_whitelist("MonApplication*")

# Retirer une fenêtre
orchestrator.remove_from_whitelist("MonApplication*")

# Obtenir la liste
whitelist = orchestrator.get_whitelist()

# Activer/désactiver l'application
orchestrator.set_whitelist_enforcement(True)

Contrôle de la Boucle

# Mettre en pause
orchestrator.pause()

# Reprendre
orchestrator.resume()

# Arrêter
orchestrator.stop()

Consultation des Métriques

# Obtenir les métriques
metrics = orchestrator.get_metrics()
print(f"Cycles: {metrics['total_cycles']}")
print(f"Latence moyenne: {metrics['avg_latency_ms']:.2f}ms")

# Obtenir le statut complet
status = orchestrator.get_status()
print(f"Mode: {status['mode']}")
print(f"Fenêtre actuelle: {status['current_window']}")

Flux de Décision

Capture Contexte
      ↓
Détection UI (Vision)
      ↓
Raisonnement (LLM)
      ↓
Calcul Confiance
      ↓
┌─────────────────┐
│  Mode actuel?   │
└─────────────────┘
      ↓
   ┌──┴──┬──────┬──────┐
   │     │      │      │
Shadow Assist Auto  │
   │     │      │      │
   ↓     ↓      ↓      ↓
Observer Suggérer Vérifier Exécuter
         +        Liste
      Valider   Blanche
         ↓         ↓
    Apprendre  Apprendre

Gestion des Erreurs

Échec de Capture

• Log l'erreur
• Continue la boucle
• Réessaie au cycle suivant

Échec de Détection

• Essaie les modèles de fallback (OWL-v2 → DINO → YOLO)
• Si tous échouent, log et continue

Échec LLM

• Fallback vers sélection basée vision pure
• Continue avec confiance réduite

Violation Liste Blanche

• Bloque l'action immédiatement
• Log événement de sécurité
• Notifie l'utilisateur

Exigences Satisfaites

✓ 1.1, 1.2 - Capture d'écran et détection fenêtre
✓ 2.1, 2.2, 2.3, 2.4, 2.5 - Modes et suggestions
✓ 3.2, 3.3 - Exécution automatique et arrêt d'urgence
✓ 5.3, 5.4 - Liste blanche et sécurité
✓ 6.2, 6.3 - Notifications et alertes

Tests

Exécuter les tests basiques:

python3 test_orchestrator_simple.py

Pour tester avec tous les composants (nécessite PyTorch, etc.):

python3 -m geniusia2.core.orchestrator

Notes d'Implémentation

• La boucle cognitive s'exécute dans un thread séparé
• Latence cible: <400ms par cycle
• Utilise des événements threading pour arrêt/pause propre
• Toutes les actions sont journalisées avec chiffrement
• Support multi-plateforme (Linux, Windows, macOS)

Prochaines Étapes

1. Implémenter input_utils.py pour exécution réelle des actions
2. Implémenter replay_async.py pour rollback
3. Intégrer avec la GUI PyQt5
4. Ajouter le système de détection de changements UI
5. Implémenter les métriques avancées