feat: replay E2E fonctionnel — 25/25 actions, 0 retries, SomEngine via serveur

Validé sur PC Windows (DESKTOP-58D5CAC, 2560x1600) :
- 8 clics résolus visuellement (1 anchor_template, 1 som_text_match, 6 som_vlm)
- Score moyen 0.75, temps moyen 1.6s
- Texte tapé correctement (bonjour, test word, date, email)
- 0 retries, 2 actions non vérifiées (OK)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

.kiro/specs/agent-workflow-improvements/design.md

@@ -0,0 +1,385 @@
+# Document de Conception - Améliorations Agent V0
+
+## Vue d'Ensemble de l'Architecture
+
+Cette conception détaille les améliorations à apporter à l'Agent V0 pour résoudre les 5 problèmes identifiés : nommage des workflows, capture d'événements incomplète, captures d'écran limitées, visibilité du traitement, et découvrabilité des workflows.
+
+## Architecture Actuelle vs Proposée
+
+### Architecture Actuelle
+```
+Agent V0
+├── Capture basique (clics, scroll, hover)
+├── Screenshots plein écran uniquement
+├── Nommage générique des sessions
+├── Upload simple vers serveur
+└── Aucun feedback de traitement
+```
+
+### Architecture Proposée
+```
+Agent V0 Amélioré
+├── Capture enrichie (clavier + contexte)
+├── Screenshots intelligents (ciblés + plein écran)
+├── Nommage intelligent basé sur l'analyse UI
+├── Monitoring pipeline en temps réel
+├── Interface de découverte des workflows
+└── Intégration Visual Workflow Builder
+```
+
+## Composants de Conception
+
+### 1. Système de Nommage Intelligent
+
+#### 1.1 Analyseur d'Actions
+```python
+class ActionAnalyzer:
+    """Analyse les actions capturées pour générer des noms descriptifs"""
+    
+    def analyze_session(self, raw_session: RawSession) -> SessionAnalysis:
+        """Analyse une session pour extraire les patterns d'actions"""
+        
+    def extract_ui_elements(self, events: List[Event]) -> List[UIElement]:
+        """Extrait les éléments UI interagis"""
+        
+    def detect_workflow_type(self, analysis: SessionAnalysis) -> WorkflowType:
+        """Détecte le type de workflow (formulaire, navigation, etc.)"""
+```
+
+#### 1.2 Générateur de Noms
+```python
+class WorkflowNameGenerator:
+    """Génère des noms descriptifs pour les workflows"""
+    
+    def generate_name(self, analysis: SessionAnalysis) -> str:
+        """Génère un nom basé sur l'analyse de session"""
+        
+    def suggest_alternatives(self, base_name: str) -> List[str]:
+        """Propose des noms alternatifs"""
+        
+    def ensure_uniqueness(self, name: str, existing_names: List[str]) -> str:
+        """Assure l'unicité du nom généré"""
+```
+
+#### 1.3 Patterns de Nommage
+- **Formulaires**: "Saisie_[NomFormulaire]_[Date]"
+- **Navigation**: "Navigation_[Application]_vers_[Section]"
+- **Recherche**: "Recherche_[Terme]_dans_[Application]"
+- **Édition**: "Modification_[TypeDocument]_[Action]"
+- **Générique**: "Workflow_[Application]_[Timestamp]"
+
+### 2. Capture d'Événements Étendue
+
+#### 2.1 Capteur de Clavier Enrichi
+```python
+class EnhancedKeyCaptor:
+    """Capture enrichie des événements clavier"""
+    
+    def capture_text_input(self, text: str, target_element: UIElement):
+        """Capture la saisie de texte avec son contexte"""
+        
+    def capture_keyboard_shortcut(self, keys: List[str], context: AppContext):
+        """Capture les raccourcis clavier avec leur signification"""
+        
+    def capture_special_keys(self, key: str, target_element: UIElement):
+        """Capture les touches spéciales (Tab, Enter, etc.)"""
+```
+
+#### 2.2 Détecteur de Contexte UI
+```python
+class UIContextDetector:
+    """Détecte le contexte des éléments UI lors des interactions"""
+    
+    def get_element_context(self, position: Tuple[int, int]) -> UIElement:
+        """Identifie l'élément UI à une position donnée"""
+        
+    def detect_element_type(self, element: UIElement) -> ElementType:
+        """Détermine le type d'élément (input, button, etc.)"""
+        
+    def extract_element_properties(self, element: UIElement) -> Dict:
+        """Extrait les propriétés de l'élément (texte, attributs, etc.)"""
+```
+
+### 3. Système de Captures Intelligentes
+
+#### 3.1 Gestionnaire de Captures Ciblées
+```python
+class SmartScreenCapturer:
+    """Système de capture d'écran intelligent"""
+    
+    def capture_targeted_area(self, center: Tuple[int, int], context_size: int):
+        """Capture une zone ciblée autour d'un point"""
+        
+    def capture_element_context(self, element: UIElement):
+        """Capture le contexte visuel d'un élément UI"""
+        
+    def optimize_capture_quality(self, image: Image, importance: float):
+        """Optimise la qualité selon l'importance de la capture"""
+```
+
+#### 3.2 Stratégies de Capture
+- **Capture Ciblée**: Zone de 400x400px autour de l'interaction
+- **Capture Contextuelle**: Zone étendue incluant les éléments voisins
+- **Capture Plein Écran**: Maintenue pour le contexte global
+- **Capture Adaptative**: Taille ajustée selon le type d'élément
+
+### 4. Monitoring du Pipeline de Traitement
+
+#### 4.1 Client de Monitoring
+```python
+class PipelineMonitor:
+    """Monitore le traitement des sessions sur le serveur"""
+    
+    def track_session_processing(self, session_id: str) -> ProcessingStatus:
+        """Suit le traitement d'une session"""
+        
+    def get_processing_progress(self, session_id: str) -> ProgressInfo:
+        """Obtient le progrès de traitement"""
+        
+    def subscribe_to_updates(self, session_id: str, callback: Callable):
+        """S'abonne aux mises à jour de traitement"""
+```
+
+#### 4.2 Interface de Statut
+```python
+class StatusDisplay:
+    """Affiche le statut de traitement dans l'interface"""
+    
+    def show_processing_status(self, status: ProcessingStatus):
+        """Affiche le statut actuel"""
+        
+    def update_progress_bar(self, progress: float):
+        """Met à jour la barre de progression"""
+        
+    def show_completion_notification(self, workflow_info: WorkflowInfo):
+        """Notifie la completion du traitement"""
+```
+
+### 5. Interface de Découverte des Workflows
+
+#### 5.1 Navigateur de Workflows
+```python
+class WorkflowBrowser:
+    """Interface de navigation et recherche des workflows"""
+    
+    def list_workflows(self, filters: WorkflowFilters) -> List[WorkflowInfo]:
+        """Liste les workflows avec filtres"""
+        
+    def search_workflows(self, query: str) -> List[WorkflowInfo]:
+        """Recherche dans les workflows"""
+        
+    def get_workflow_preview(self, workflow_id: str) -> WorkflowPreview:
+        """Obtient un aperçu du workflow"""
+```
+
+#### 5.2 Système de Filtres
+- **Par Date**: Aujourd'hui, Cette semaine, Ce mois, Personnalisé
+- **Par Type**: Formulaire, Navigation, Recherche, Édition, Autre
+- **Par Application**: Groupement par application cible
+- **Par Statut**: Brouillon, Prêt, En cours d'utilisation, Archivé
+
+### 6. Intégration Visual Workflow Builder
+
+#### 6.1 Connecteur VWB
+```python
+class VWBConnector:
+    """Connecteur vers le Visual Workflow Builder"""
+    
+    def open_workflow_in_builder(self, workflow_id: str):
+        """Ouvre un workflow dans le builder"""
+        
+    def sync_workflow_changes(self, workflow_id: str, changes: Dict):
+        """Synchronise les modifications"""
+        
+    def test_workflow_from_agent(self, workflow_id: str) -> TestResult:
+        """Lance un test du workflow depuis l'agent"""
+```
+
+## Flux de Données
+
+### 1. Flux de Capture Amélioré
+```
+Interaction Utilisateur
+    ↓
+Capture Enrichie (position + contexte + métadonnées)
+    ↓
+Analyse UI en Temps Réel
+    ↓
+Capture Ciblée + Plein Écran
+    ↓
+Enrichissement Métadonnées
+    ↓
+Génération Nom Intelligent
+    ↓
+Packaging Session + Upload
+```
+
+### 2. Flux de Monitoring
+```
+Upload Session
+    ↓
+Serveur Démarre Traitement
+    ↓
+Agent Surveille Progression
+    ↓
+Mises à Jour Temps Réel
+    ↓
+Notification Completion
+    ↓
+Workflow Disponible
+```
+
+## Interfaces Utilisateur
+
+### 1. Interface Principale Améliorée
+```
+┌─────────────────────────────────────────┐
+│ Agent V0 - Capture Intelligente        │
+├─────────────────────────────────────────┤
+│ ● Enregistrement: [ACTIF]              │
+│ 📝 Nom: "Saisie_Commande_Client"       │
+│ 🎯 Actions: 12 | ⌨️ Saisies: 5         │
+│ 📸 Captures: 8 (6 ciblées, 2 globales) │
+├─────────────────────────────────────────┤
+│ [Arrêter] [Pause] [Paramètres]         │
+│ [Mes Workflows] [Aide]                  │
+└─────────────────────────────────────────┘
+```
+
+### 2. Interface de Découverte
+```
+┌─────────────────────────────────────────┐
+│ Mes Workflows                           │
+├─────────────────────────────────────────┤
+│ 🔍 [Rechercher...]  📅 [Filtres]       │
+├─────────────────────────────────────────┤
+│ 📋 Saisie_Commande_Client               │
+│    Créé: 22/12/2025 | Utilisé: 3 fois  │
+│    [Ouvrir] [Éditer] [Dupliquer]       │
+├─────────────────────────────────────────┤
+│ 🌐 Navigation_CRM_Contacts              │
+│    Créé: 21/12/2025 | Utilisé: 1 fois  │
+│    [Ouvrir] [Éditer] [Dupliquer]       │
+└─────────────────────────────────────────┘
+```
+
+### 3. Monitoring de Traitement
+```
+┌─────────────────────────────────────────┐
+│ Traitement en Cours                     │
+├─────────────────────────────────────────┤
+│ Session: Saisie_Commande_Client         │
+│ ████████████░░░░ 75%                    │
+│                                         │
+│ ✅ Analyse des captures                 │
+│ ✅ Détection des éléments UI            │
+│ 🔄 Génération du workflow               │
+│ ⏳ Optimisation des actions             │
+│                                         │
+│ Temps estimé: 30 secondes               │
+└─────────────────────────────────────────┘
+```
+
+## Modèles de Données
+
+### 1. Session Enrichie
+```python
+@dataclass
+class EnhancedRawSession(RawSession):
+    """Session avec métadonnées enrichies"""
+    workflow_name: str
+    workflow_type: WorkflowType
+    ui_elements_detected: List[UIElement]
+    text_inputs: List[TextInput]
+    keyboard_shortcuts: List[KeyboardShortcut]
+    targeted_captures: List[TargetedCapture]
+    quality_score: float
+    processing_hints: Dict[str, Any]
+```
+
+### 2. Élément UI Enrichi
+```python
+@dataclass
+class EnhancedUIElement:
+    """Élément UI avec contexte enrichi"""
+    position: Tuple[int, int]
+    size: Tuple[int, int]
+    element_type: ElementType
+    text_content: Optional[str]
+    attributes: Dict[str, str]
+    parent_context: Optional['EnhancedUIElement']
+    interaction_type: InteractionType
+    confidence_score: float
+```
+
+### 3. Capture Ciblée
+```python
+@dataclass
+class TargetedCapture:
+    """Capture d'écran ciblée avec métadonnées"""
+    capture_id: str
+    center_position: Tuple[int, int]
+    capture_size: Tuple[int, int]
+    target_element: EnhancedUIElement
+    context_elements: List[EnhancedUIElement]
+    capture_reason: CaptureReason
+    quality_level: QualityLevel
+    file_path: str
+```
+
+## Stratégies d'Implémentation
+
+### Phase 1: Nommage Intelligent
+1. Implémenter l'analyseur d'actions
+2. Créer le générateur de noms
+3. Intégrer dans l'interface de capture
+4. Tests avec différents types de workflows
+
+### Phase 2: Capture Enrichie
+1. Étendre le capteur de clavier
+2. Implémenter la détection de contexte UI
+3. Intégrer les captures ciblées
+4. Optimiser les performances
+
+### Phase 3: Monitoring et Découverte
+1. Créer le client de monitoring
+2. Implémenter l'interface de statut
+3. Développer le navigateur de workflows
+4. Intégrer les filtres et recherche
+
+### Phase 4: Intégration VWB
+1. Développer le connecteur VWB
+2. Implémenter la synchronisation
+3. Créer l'interface d'édition
+4. Tests d'intégration complets
+
+## Considérations Techniques
+
+### Performance
+- Captures ciblées en arrière-plan pour éviter les ralentissements
+- Cache des analyses UI pour éviter les recalculs
+- Compression intelligente des captures selon leur importance
+
+### Sécurité
+- Chiffrement maintenu pour toutes les nouvelles données
+- Anonymisation optionnelle des captures sensibles
+- Validation des métadonnées avant stockage
+
+### Compatibilité
+- Support des 3 plateformes (Linux, macOS, Windows)
+- Rétrocompatibilité avec les sessions existantes
+- Migration progressive des fonctionnalités
+
+## Métriques de Succès
+
+### Métriques Quantitatives
+- Temps de génération de nom < 2 secondes
+- Taux de captures ciblées réussies > 95%
+- Temps de découverte de workflow < 10 secondes
+- Réduction de 50% des sessions incomplètes
+
+### Métriques Qualitatives
+- Satisfaction utilisateur > 4.5/5
+- Adoption des nouvelles fonctionnalités > 80%
+- Réduction des demandes de support
+- Amélioration de la qualité des workflows générés

.kiro/specs/agent-workflow-improvements/requirements.md

@@ -0,0 +1,138 @@
+# Spécification des Exigences - Améliorations Agent V0
+
+## Introduction
+
+L'Agent V0 est un outil de capture cross-platform qui enregistre les interactions utilisateur pour créer des workflows automatisés. Bien que fonctionnel, plusieurs limitations ont été identifiées qui impactent l'expérience utilisateur et l'efficacité du système. Cette spécification vise à améliorer les workflows de l'Agent V0 pour une meilleure utilisabilité et une intégration optimisée avec RPA Vision V3.
+
+## Glossaire
+
+- **Agent_V0**: Agent de capture cross-platform qui enregistre les sessions utilisateur
+- **Workflow**: Séquence d'actions automatisées générée à partir d'une session capturée
+- **RawSession**: Format de données brutes capturées par l'agent
+- **Pipeline_Traitement**: Pipeline serveur qui traite les sessions uploadées
+- **Nommage_Intelligent**: Système de génération automatique de noms descriptifs
+- **Capture_Étendue**: Système de capture d'événements amélioré
+- **Monitoring_Pipeline**: Système de suivi du traitement des sessions
+
+## Exigences
+
+### Exigence 1: Nommage intelligent des workflows
+
+**User Story:** En tant qu'utilisateur de l'Agent V0, je veux que mes workflows aient des noms descriptifs et uniques, afin de pouvoir les identifier facilement dans la liste des workflows disponibles.
+
+#### Critères d'Acceptation
+
+1. WHEN une session est capturée, THE System SHALL générer automatiquement un nom descriptif basé sur les actions détectées
+2. THE Nommage_Intelligent SHALL analyser les éléments UI interagis pour créer un nom pertinent
+3. WHEN plusieurs workflows similaires existent, THE System SHALL ajouter un suffixe numérique ou temporel
+4. THE System SHALL permettre à l'utilisateur de modifier le nom généré avant la finalisation
+5. WHEN le nom est vide ou générique, THE System SHALL proposer des suggestions basées sur le contexte
+
+### Exigence 2: Capture d'événements complète
+
+**User Story:** En tant qu'utilisateur de l'Agent V0, je veux que toutes mes interactions soient capturées fidèlement, afin que les workflows générés soient complets et précis.
+
+#### Critères d'Acceptation
+
+1. THE Capture_Étendue SHALL enregistrer toutes les saisies clavier avec leur contexte
+2. WHEN l'utilisateur tape du texte, THE System SHALL capturer le contenu et l'élément cible
+3. THE System SHALL capturer les raccourcis clavier (Ctrl+C, Ctrl+V, etc.) avec leur signification
+4. WHEN l'utilisateur utilise des touches spéciales (Tab, Enter, Escape), THE System SHALL les enregistrer avec leur contexte
+5. THE System SHALL associer chaque saisie clavier à l'élément UI correspondant
+
+### Exigence 3: Captures d'écran ciblées
+
+**User Story:** En tant qu'utilisateur de l'Agent V0, je veux des captures d'écran optimisées et ciblées, afin d'améliorer la précision de la détection UI et réduire la taille des fichiers.
+
+#### Critères d'Acceptation
+
+1. THE System SHALL capturer des zones ciblées autour des éléments interagis
+2. WHEN un élément UI est cliqué, THE System SHALL capturer une zone étendue autour de cet élément
+3. THE System SHALL maintenir des captures plein écran pour le contexte global
+4. WHEN la zone ciblée est trop petite, THE System SHALL l'agrandir automatiquement
+5. THE System SHALL optimiser la qualité et la taille des captures selon leur importance
+
+### Exigence 4: Visibilité du traitement
+
+**User Story:** En tant qu'utilisateur de l'Agent V0, je veux voir le progrès du traitement de mes sessions, afin de savoir quand mes workflows seront disponibles.
+
+#### Critères d'Acceptation
+
+1. THE Monitoring_Pipeline SHALL afficher le statut de traitement en temps réel
+2. WHEN une session est uploadée, THE System SHALL montrer les étapes de traitement
+3. THE System SHALL indiquer le temps estimé de traitement restant
+4. WHEN le traitement échoue, THE System SHALL afficher l'erreur et les actions possibles
+5. THE System SHALL notifier l'utilisateur quand le workflow est prêt à utiliser
+
+### Exigence 5: Découvrabilité des workflows
+
+**User Story:** En tant qu'utilisateur de l'Agent V0, je veux pouvoir retrouver facilement mes workflows créés, afin de les utiliser, modifier ou partager.
+
+#### Critères d'Acceptation
+
+1. THE System SHALL fournir une interface de recherche et navigation des workflows
+2. WHEN l'utilisateur recherche un workflow, THE System SHALL proposer des filtres par date, nom, et type
+3. THE System SHALL afficher des aperçus visuels des workflows (première capture, description)
+4. WHEN un workflow est sélectionné, THE System SHALL montrer ses détails et statistiques d'usage
+5. THE System SHALL permettre l'organisation des workflows en catégories ou dossiers
+
+### Exigence 6: Métadonnées enrichies
+
+**User Story:** En tant qu'utilisateur de l'Agent V0, je veux que mes sessions contiennent des métadonnées riches, afin d'améliorer la qualité des workflows générés.
+
+#### Critères d'Acceptation
+
+1. THE System SHALL capturer les informations contextuelles de chaque action
+2. WHEN une action est effectuée, THE System SHALL enregistrer l'état de l'application cible
+3. THE System SHALL détecter et enregistrer les changements d'état de l'interface
+4. WHEN des éléments UI changent, THE System SHALL capturer les transitions
+5. THE System SHALL enrichir les métadonnées avec des informations sémantiques
+
+### Exigence 7: Validation et feedback
+
+**User Story:** En tant qu'utilisateur de l'Agent V0, je veux recevoir des retours sur la qualité de mes captures, afin d'améliorer mes prochaines sessions.
+
+#### Critères d'Acceptation
+
+1. THE System SHALL analyser la qualité de la session capturée
+2. WHEN la session est incomplète ou ambiguë, THE System SHALL alerter l'utilisateur
+3. THE System SHALL suggérer des améliorations pour les prochaines captures
+4. WHEN des actions critiques sont manquées, THE System SHALL proposer de les ajouter
+5. THE System SHALL fournir un score de qualité avec des recommandations d'amélioration
+
+### Exigence 8: Intégration workflow builder
+
+**User Story:** En tant qu'utilisateur de l'Agent V0, je veux pouvoir éditer mes workflows capturés, afin de les personnaliser et optimiser avant utilisation.
+
+#### Critères d'Acceptation
+
+1. THE System SHALL permettre l'ouverture directe des workflows dans le Visual Workflow Builder
+2. WHEN un workflow est généré, THE System SHALL proposer l'édition immédiate
+3. THE System SHALL synchroniser les modifications entre l'agent et le builder
+4. WHEN des améliorations sont apportées, THE System SHALL les sauvegarder automatiquement
+5. THE System SHALL permettre le test du workflow modifié depuis l'agent
+
+## Contraintes Techniques
+
+### Contrainte 1: Compatibilité
+- Les améliorations DOIVENT maintenir la compatibilité avec le format RawSession existant
+- Les nouvelles fonctionnalités DOIVENT fonctionner sur Linux, macOS et Windows
+- L'interface utilisateur DOIT rester simple et intuitive
+
+### Contrainte 2: Performance
+- Les captures ciblées NE DOIVENT PAS ralentir significativement l'enregistrement
+- Le nommage intelligent DOIT s'exécuter en moins de 2 secondes
+- Le monitoring pipeline NE DOIT PAS impacter les performances du serveur
+
+### Contrainte 3: Sécurité
+- Toutes les données capturées DOIVENT rester chiffrées
+- Les métadonnées enrichies NE DOIVENT PAS exposer d'informations sensibles
+- L'intégration workflow builder DOIT respecter les permissions utilisateur
+
+## Critères de Succès
+
+1. **Amélioration UX**: 90% des utilisateurs trouvent leurs workflows facilement
+2. **Qualité des captures**: Réduction de 50% des sessions incomplètes
+3. **Efficacité**: Temps de création de workflow réduit de 30%
+4. **Adoption**: 80% des utilisateurs utilisent les nouvelles fonctionnalités
+5. **Satisfaction**: Score de satisfaction utilisateur > 4.5/5

.kiro/specs/agent-workflow-improvements/tasks.md

@@ -0,0 +1,522 @@
+# Agent V0 - Workflow Improvements Tasks
+
+## Overview
+
+This document outlines the implementation tasks for the Agent V0 workflow improvements, organized by priority and dependencies. The tasks are structured to deliver value incrementally while maintaining system stability.
+
+## Task Organization
+
+### Priority Levels
+- **P0 (Critical)**: Must-have features that address core workflow issues
+- **P1 (Important)**: Significant improvements that enhance user experience
+- **P2 (Nice-to-have)**: Advanced features that provide additional value
+
+### Dependencies
+Tasks are organized to minimize dependencies and allow parallel development where possible.
+
+## Phase 1: Core Workflow Enhancements (P0)
+
+### TASK-1.1: Dynamic Workflow Naming System
+**Priority**: P0  
+**Estimated Effort**: 3 days  
+**Dependencies**: None
+
+**Objective**: Enable users to provide meaningful names for their captured workflows
+
+**Implementation Steps**:
+1. **Create WorkflowNamer Component**
+   - [ ] Implement `WorkflowNamer` class in `agent_v0/workflow_namer.py`
+   - [ ] Add name validation and sanitization methods
+   - [ ] Implement default name generation with timestamps
+   - [ ] Add configuration options for naming patterns
+
+2. **Create UI Dialog for Name Input**
+   - [ ] Implement `WorkflowNameDialog` in `agent_v0/ui_dialogs.py`
+   - [ ] Design user-friendly input interface
+   - [ ] Add validation feedback and error messages
+   - [ ] Implement cancel/default name handling
+
+3. **Integrate with RawSession**
+   - [ ] Modify `RawSession` to accept workflow names
+   - [ ] Update session ID generation to include workflow name
+   - [ ] Propagate workflow name through session metadata
+   - [ ] Update file naming conventions
+
+4. **Update TrayUI Integration**
+   - [ ] Modify `TrayUI` to prompt for workflow name on session start
+   - [ ] Handle user cancellation gracefully
+   - [ ] Update menu options to show current workflow name
+   - [ ] Add workflow name to status indicators
+
+**Acceptance Criteria**:
+- [ ] Users can input custom workflow names before starting capture
+- [ ] Default names are generated when no input is provided
+- [ ] Names are sanitized for filesystem compatibility
+- [ ] Workflow names appear in all generated files and metadata
+- [ ] UI provides clear feedback for invalid names
+
+**Testing Requirements**:
+- [ ] Unit tests for name validation and sanitization
+- [ ] UI tests for dialog interaction
+- [ ] Integration tests for end-to-end naming flow
+- [ ] Edge case testing (empty names, special characters, long names)
+
+---
+
+### TASK-1.2: Enhanced Event Capture System
+**Priority**: P0  
+**Estimated Effort**: 4 days  
+**Dependencies**: None
+
+**Objective**: Capture complete user interactions including keyboard events and text input
+
+**Implementation Steps**:
+1. **Extend EventCaptor for Keyboard Support**
+   - [ ] Create `EnhancedEventCaptor` extending existing `EventCaptor`
+   - [ ] Implement keyboard event listeners using pynput
+   - [ ] Add text buffer management for continuous text input
+   - [ ] Implement modifier key tracking (Ctrl, Alt, Shift)
+
+2. **Implement Key Combination Detection**
+   - [ ] Add detection for common key combinations (Ctrl+C, Ctrl+V, etc.)
+   - [ ] Implement special key handling (Enter, Tab, Escape)
+   - [ ] Add support for function keys and navigation keys
+   - [ ] Create configurable key combination mappings
+
+3. **Add Sensitive Field Protection**
+   - [ ] Implement automatic password field detection
+   - [ ] Add configurable sensitive field patterns
+   - [ ] Implement text masking for sensitive inputs
+   - [ ] Add user override options for sensitive field handling
+
+4. **Integrate Text Input with UI Elements**
+   - [ ] Associate text input with target UI elements
+   - [ ] Track focus changes and element transitions
+   - [ ] Implement text input validation and formatting
+   - [ ] Add support for multi-line text input
+
+**Acceptance Criteria**:
+- [ ] All keyboard events are captured and recorded
+- [ ] Key combinations are detected and logged correctly
+- [ ] Text input is associated with appropriate UI elements
+- [ ] Sensitive fields are automatically masked
+- [ ] No performance degradation during intensive typing
+
+**Testing Requirements**:
+- [ ] Unit tests for keyboard event handling
+- [ ] Tests for key combination detection
+- [ ] Sensitive field masking validation
+- [ ] Performance tests for high-frequency input
+- [ ] Cross-platform compatibility tests
+
+---
+
+### TASK-1.3: Processing Monitoring System
+**Priority**: P0  
+**Estimated Effort**: 3 days  
+**Dependencies**: TASK-1.1
+
+**Objective**: Provide real-time visibility into session processing pipeline
+
+**Implementation Steps**:
+1. **Create ProcessingMonitor Component**
+   - [ ] Implement `ProcessingMonitor` class in `agent_v0/processing_monitor.py`
+   - [ ] Add structured logging with different severity levels
+   - [ ] Implement progress tracking with percentage completion
+   - [ ] Add status file management for persistent state
+
+2. **Integrate with Processing Pipeline**
+   - [ ] Modify `server/processing_pipeline.py` to use monitor
+   - [ ] Add monitoring hooks at each processing stage
+   - [ ] Implement error handling and recovery logging
+   - [ ] Add performance metrics collection
+
+3. **Create User Notification System**
+   - [ ] Implement progress callbacks for UI updates
+   - [ ] Add system notifications for completion/errors
+   - [ ] Create status display in tray UI
+   - [ ] Implement log file access from UI
+
+4. **Add Status Persistence**
+   - [ ] Create JSON status files for each session
+   - [ ] Implement status file cleanup and rotation
+   - [ ] Add status history for troubleshooting
+   - [ ] Create status query API for external tools
+
+**Acceptance Criteria**:
+- [ ] Processing progress is visible to users in real-time
+- [ ] All processing steps are logged with timestamps
+- [ ] Errors are clearly communicated with actionable information
+- [ ] Processing logs are accessible for troubleshooting
+- [ ] Status information persists across application restarts
+
+**Testing Requirements**:
+- [ ] Unit tests for monitoring component
+- [ ] Integration tests with processing pipeline
+- [ ] Error handling and recovery tests
+- [ ] Performance impact assessment
+- [ ] UI notification testing
+
+---
+
+## Phase 2: Advanced Capture Features (P1)
+
+### TASK-2.1: Targeted Screenshot System
+**Priority**: P1  
+**Estimated Effort**: 4 days  
+**Dependencies**: TASK-1.2
+
+**Objective**: Capture element-focused screenshots for improved UI detection
+
+**Implementation Steps**:
+1. **Create TargetedScreenshotCaptor**
+   - [ ] Implement `TargetedScreenshotCaptor` class
+   - [ ] Add region calculation around click positions
+   - [ ] Implement dual capture (full-screen + targeted)
+   - [ ] Add click position indicators in targeted captures
+
+2. **Implement UI Element Detection**
+   - [ ] Add basic UI element boundary detection
+   - [ ] Implement element type classification (button, input, etc.)
+   - [ ] Add text extraction from UI elements
+   - [ ] Create element metadata structure
+
+3. **Optimize Image Processing**
+   - [ ] Implement image compression and optimization
+   - [ ] Add configurable quality settings
+   - [ ] Implement automatic image resizing
+   - [ ] Add support for different image formats
+
+4. **Integrate with Event System**
+   - [ ] Modify click event handling to use targeted capture
+   - [ ] Update event data structure for dual screenshots
+   - [ ] Add element information to event metadata
+   - [ ] Implement capture mode configuration
+
+**Acceptance Criteria**:
+- [ ] Each click generates both full-screen and targeted screenshots
+- [ ] Targeted captures include appropriate context margin
+- [ ] UI element information is extracted and stored
+- [ ] Image optimization maintains acceptable quality
+- [ ] Capture performance remains within acceptable limits
+
+**Testing Requirements**:
+- [ ] Unit tests for screenshot capture logic
+- [ ] Image quality and compression tests
+- [ ] UI element detection accuracy tests
+- [ ] Performance benchmarks for capture operations
+- [ ] Cross-platform screenshot compatibility
+
+---
+
+### TASK-2.2: Workflow Organization System
+**Priority**: P1  
+**Estimated Effort**: 3 days  
+**Dependencies**: TASK-1.1, TASK-1.3
+
+**Objective**: Organize and provide easy access to generated workflows
+
+**Implementation Steps**:
+1. **Create WorkflowLocator Component**
+   - [ ] Implement `WorkflowLocator` class in `agent_v0/workflow_locator.py`
+   - [ ] Create organized directory structure for workflows
+   - [ ] Implement workflow indexing system
+   - [ ] Add metadata management for workflows
+
+2. **Implement Workflow Storage Structure**
+   - [ ] Create `data/workflows/` directory hierarchy
+   - [ ] Implement per-workflow subdirectories
+   - [ ] Add screenshot organization (full/targeted)
+   - [ ] Create workflow metadata files
+
+3. **Add Search and Discovery Features**
+   - [ ] Implement workflow search by name and tags
+   - [ ] Add filtering by date, type, and status
+   - [ ] Create workflow listing and browsing
+   - [ ] Add workflow statistics and analytics
+
+4. **Integrate with UI**
+   - [ ] Add workflow folder access to tray menu
+   - [ ] Implement recent workflows display
+   - [ ] Add workflow browser dialog
+   - [ ] Create workflow export functionality
+
+**Acceptance Criteria**:
+- [ ] Workflows are organized in a clear directory structure
+- [ ] Workflow index enables fast search and filtering
+- [ ] Users can easily access and browse their workflows
+- [ ] Workflow metadata is comprehensive and useful
+- [ ] Export functionality supports multiple formats
+
+**Testing Requirements**:
+- [ ] Unit tests for workflow organization logic
+- [ ] Search and filtering functionality tests
+- [ ] Directory structure validation tests
+- [ ] UI integration tests
+- [ ] Performance tests for large workflow collections
+
+---
+
+## Phase 3: Integration and Polish (P2)
+
+### TASK-3.1: Visual Workflow Builder Integration
+**Priority**: P2  
+**Estimated Effort**: 3 days  
+**Dependencies**: TASK-2.2
+
+**Objective**: Integrate enhanced workflows with Visual Workflow Builder
+
+**Implementation Steps**:
+1. **Update Import/Export System**
+   - [ ] Modify `visual_workflow_builder/backend/api/import_export.py`
+   - [ ] Add support for enhanced workflow format
+   - [ ] Implement targeted screenshot import
+   - [ ] Update workflow validation for new format
+
+2. **Enhance Workflow Editor**
+   - [ ] Add support for displaying targeted screenshots
+   - [ ] Implement enhanced metadata display
+   - [ ] Add workflow name editing capabilities
+   - [ ] Create workflow organization browser
+
+3. **Add Direct Access Integration**
+   - [ ] Implement "Open in Builder" functionality from agent
+   - [ ] Add automatic workflow import on generation
+   - [ ] Create workflow synchronization system
+   - [ ] Add builder launch from agent UI
+
+4. **Update Documentation and Help**
+   - [ ] Update user documentation for new features
+   - [ ] Add tooltips and help text for enhanced features
+   - [ ] Create workflow organization guide
+   - [ ] Add troubleshooting documentation
+
+**Acceptance Criteria**:
+- [ ] Enhanced workflows can be imported into Visual Workflow Builder
+- [ ] Targeted screenshots are displayed and usable in editor
+- [ ] Direct access from agent to builder works seamlessly
+- [ ] Documentation is complete and accurate
+
+**Testing Requirements**:
+- [ ] Integration tests between agent and builder
+- [ ] Workflow import/export validation tests
+- [ ] UI functionality tests in builder
+- [ ] Documentation accuracy verification
+
+---
+
+### TASK-3.2: Performance Optimization
+**Priority**: P2  
+**Estimated Effort**: 2 days  
+**Dependencies**: TASK-2.1
+
+**Objective**: Optimize system performance with new features
+
+**Implementation Steps**:
+1. **Optimize Capture Performance**
+   - [ ] Implement asynchronous screenshot processing
+   - [ ] Add image processing thread pool
+   - [ ] Optimize memory usage during capture
+   - [ ] Implement capture queue management
+
+2. **Optimize Storage Performance**
+   - [ ] Implement incremental workflow indexing
+   - [ ] Add lazy loading for workflow metadata
+   - [ ] Optimize file I/O operations
+   - [ ] Implement storage cleanup routines
+
+3. **Add Performance Monitoring**
+   - [ ] Implement capture performance metrics
+   - [ ] Add memory usage monitoring
+   - [ ] Create performance benchmarking tools
+   - [ ] Add performance alerts and warnings
+
+4. **Optimize UI Responsiveness**
+   - [ ] Implement non-blocking UI operations
+   - [ ] Add progress indicators for long operations
+   - [ ] Optimize UI update frequency
+   - [ ] Implement UI caching where appropriate
+
+**Acceptance Criteria**:
+- [ ] Capture performance overhead is less than 20%
+- [ ] UI remains responsive during all operations
+- [ ] Memory usage is optimized and stable
+- [ ] Performance metrics are available for monitoring
+
+**Testing Requirements**:
+- [ ] Performance benchmark tests
+- [ ] Memory usage profiling
+- [ ] UI responsiveness tests
+- [ ] Long-running operation tests
+
+---
+
+## Phase 4: Testing and Documentation (P1)
+
+### TASK-4.1: Comprehensive Testing Suite
+**Priority**: P1  
+**Estimated Effort**: 4 days  
+**Dependencies**: All previous tasks
+
+**Objective**: Ensure system reliability and quality
+
+**Implementation Steps**:
+1. **Unit Test Coverage**
+   - [ ] Achieve >90% code coverage for new components
+   - [ ] Add tests for all public methods and functions
+   - [ ] Implement edge case and error condition tests
+   - [ ] Add performance regression tests
+
+2. **Integration Testing**
+   - [ ] Test complete workflow capture to generation flow
+   - [ ] Validate cross-component interactions
+   - [ ] Test error handling and recovery scenarios
+   - [ ] Validate backward compatibility
+
+3. **User Acceptance Testing**
+   - [ ] Create realistic user scenarios
+   - [ ] Test with different types of applications
+   - [ ] Validate workflow quality and usability
+   - [ ] Gather user feedback and iterate
+
+4. **Cross-Platform Testing**
+   - [ ] Test on Windows, macOS, and Linux
+   - [ ] Validate platform-specific features
+   - [ ] Test with different screen resolutions
+   - [ ] Validate file system compatibility
+
+**Acceptance Criteria**:
+- [ ] All tests pass consistently across platforms
+- [ ] Code coverage meets quality standards
+- [ ] User scenarios work as expected
+- [ ] No regressions in existing functionality
+
+**Testing Requirements**:
+- [ ] Automated test suite execution
+- [ ] Continuous integration setup
+- [ ] Performance regression detection
+- [ ] User acceptance criteria validation
+
+---
+
+### TASK-4.2: Documentation and User Guides
+**Priority**: P1  
+**Estimated Effort**: 3 days  
+**Dependencies**: TASK-4.1
+
+**Objective**: Provide comprehensive documentation for new features
+
+**Implementation Steps**:
+1. **Technical Documentation**
+   - [ ] Update API documentation for new components
+   - [ ] Document configuration options and settings
+   - [ ] Create architecture diagrams and explanations
+   - [ ] Add troubleshooting guides
+
+2. **User Documentation**
+   - [ ] Create user guide for workflow naming
+   - [ ] Document enhanced capture features
+   - [ ] Add workflow organization guide
+   - [ ] Create FAQ for common issues
+
+3. **Developer Documentation**
+   - [ ] Document extension points and APIs
+   - [ ] Create development setup guide
+   - [ ] Add code examples and best practices
+   - [ ] Document testing procedures
+
+4. **Migration Guide**
+   - [ ] Create migration guide for existing users
+   - [ ] Document backward compatibility features
+   - [ ] Add upgrade procedures and recommendations
+   - [ ] Create rollback procedures if needed
+
+**Acceptance Criteria**:
+- [ ] All new features are documented comprehensively
+- [ ] User guides are clear and actionable
+- [ ] Developer documentation enables contribution
+- [ ] Migration path is well-defined and tested
+
+**Testing Requirements**:
+- [ ] Documentation accuracy verification
+- [ ] User guide walkthrough testing
+- [ ] Developer setup validation
+- [ ] Migration procedure testing
+
+---
+
+## Implementation Timeline
+
+### Sprint 1 (Weeks 1-2): Foundation
+- TASK-1.1: Dynamic Workflow Naming System
+- TASK-1.2: Enhanced Event Capture System (start)
+
+### Sprint 2 (Weeks 3-4): Core Features
+- TASK-1.2: Enhanced Event Capture System (complete)
+- TASK-1.3: Processing Monitoring System
+
+### Sprint 3 (Weeks 5-6): Advanced Features
+- TASK-2.1: Targeted Screenshot System
+- TASK-2.2: Workflow Organization System
+
+### Sprint 4 (Weeks 7-8): Integration
+- TASK-3.1: Visual Workflow Builder Integration
+- TASK-3.2: Performance Optimization
+
+### Sprint 5 (Weeks 9-10): Quality Assurance
+- TASK-4.1: Comprehensive Testing Suite
+- TASK-4.2: Documentation and User Guides
+
+## Risk Management
+
+### Technical Risks
+- **Performance Impact**: Mitigate with incremental optimization and monitoring
+- **Cross-Platform Compatibility**: Address with comprehensive testing
+- **Integration Complexity**: Manage with clear interfaces and contracts
+
+### Project Risks
+- **Scope Creep**: Control with strict prioritization and change management
+- **Resource Constraints**: Address with flexible sprint planning
+- **User Adoption**: Mitigate with user feedback and iterative improvement
+
+## Success Metrics
+
+### Quantitative Metrics
+- **Feature Adoption**: >80% of users use workflow naming
+- **Capture Completeness**: >95% of events captured correctly
+- **Performance**: <20% overhead increase
+- **Quality**: >90% test coverage, <5% defect rate
+
+### Qualitative Metrics
+- **User Satisfaction**: >4/5 rating in user surveys
+- **Workflow Quality**: Improved workflow accuracy and usability
+- **Developer Experience**: Positive feedback from development team
+- **Documentation Quality**: Clear and comprehensive documentation
+
+## Definition of Done
+
+A task is considered complete when:
+- [ ] All implementation steps are finished
+- [ ] Code review is completed and approved
+- [ ] Unit tests are written and passing
+- [ ] Integration tests are passing
+- [ ] Documentation is updated
+- [ ] Performance impact is assessed and acceptable
+- [ ] User acceptance criteria are met
+- [ ] No regressions are introduced
+
+## Maintenance and Support
+
+### Ongoing Maintenance
+- Regular performance monitoring and optimization
+- Bug fixes and issue resolution
+- User feedback incorporation
+- Security updates and patches
+
+### Future Enhancements
+- AI-powered workflow optimization
+- Cloud synchronization capabilities
+- Advanced analytics and insights
+- Collaborative workflow development
+
+This task breakdown provides a comprehensive roadmap for implementing the Agent V0 workflow improvements while maintaining quality and system stability.