# 🗑️ Architecture de Nettoyage - Cycle de Vie des Données

**Date**: 7 janvier 2026
**Objectif**: Définir quand supprimer quoi dans le système RPA Vision V3

---

## 📊 Cycle de Vie Complet

```
┌─────────────────────────────────────────────────────────────────┐
│ 1. CAPTURE (Agent V0)                                            │
│    - Screenshots bruts (PNG)                                     │
│    - Events JSON                                                 │
│    - Chiffrement AES-256                                        │
└────────────────┬────────────────────────────────────────────────┘
                 │ ZIP chiffré (.enc)
                 ↓
┌─────────────────────────────────────────────────────────────────┐
│ 2. UPLOAD (Serveur)                                              │
│    - Réception ZIP chiffré → /data/training/uploads/            │
│    - Déchiffrement                                              │
│    - Extraction → /data/training/sessions/sess_*/               │
│      ├── sess_*.json                                            │
│      └── shots/shot_*.png                                       │
└────────────────┬────────────────────────────────────────────────┘
                 │ Données brutes disponibles
                 ↓
┌─────────────────────────────────────────────────────────────────┐
│ 3. TRAITEMENT (Worker)                                           │
│    Pour chaque screenshot:                                       │
│    - Détection UI (OpenCV + OWL-v2 + VLM)                       │
│    - Génération embeddings (CLIP) → /data/embeddings/           │
│    - Création ScreenState → /data/screen_states/                │
│    - OCR et extraction texte                                    │
│                                                                  │
│    Résultat: Données structurées sans besoin des PNG bruts     │
└────────────────┬────────────────────────────────────────────────┘
                 │ Embeddings + Screen States créés
                 ↓
┌─────────────────────────────────────────────────────────────────┐
│ 4. APPRENTISSAGE (Learning Manager)                             │
│    - Clustering DBSCAN sur embeddings                           │
│    - Détection patterns répétés                                 │
│    - Construction WorkflowGraph                                 │
│    - Indexation FAISS → /data/faiss_index/                     │
│    - Sauvegarde Workflows → /data/workflows/                   │
│                                                                  │
│    Résultat: Workflows exécutables créés                       │
└────────────────┬────────────────────────────────────────────────┘
                 │ Apprentissage TERMINÉ
                 ↓
┌─────────────────────────────────────────────────────────────────┐
│ 5. NETTOYAGE (Post-Learning Cleanup) ← TODO APRÈS POC          │
│    ❌ SUPPRIMER:                                                │
│       - Screenshots bruts (shots/*.png)                         │
│       - JSON session brut (sess_*.json)                         │
│       - ZIP chiffré (.enc)                                      │
│                                                                  │
│    ✅ CONSERVER:                                                │
│       - Embeddings (/data/embeddings/)                          │
│       - Screen States (/data/screen_states/)                    │
│       - Workflows (/data/workflows/)                            │
│       - Index FAISS (/data/faiss_index/)                        │
│                                                                  │
│    Gain: ~90% espace disque (PNG = gros fichiers)             │
└─────────────────────────────────────────────────────────────────┘
```

---

## 🎯 Statut Actuel (POC/MVP)

### ✅ Ce qui Fonctionne
- Upload et déchiffrement ✅
- Extraction screenshots ✅
- Traitement et création embeddings ✅
- Création screen states ✅

### ⚠️ Problème Identifié
**Le nettoyage se fait TROP TÔT** (ligne 164 de `processing_pipeline.py`)

```python
# Après traitement (étape 3), mais AVANT apprentissage (étape 4)
self._cleanup_raw_files(session_id, stats)  # ← TROP TÔT !
```

**Conséquence** :
- Screenshots supprimés avant l'apprentissage ❌
- Apprentissage ne peut pas accéder aux images ❌
- Impossible de valider visuellement les captures ❌

### 🔧 Solution Court Terme (POC)
**Désactiver complètement le nettoyage** jusqu'après le POC

```bash
sudo bash disable_premature_cleanup.sh
```

---

## 🚀 Architecture Cible (Post-POC)

### Option A : Nettoyage Automatique Post-Apprentissage

**Trigger** : Quand le workflow atteint l'état `AUTO_CONFIRMÉ`

```python
class LearningManager:
    def promote_workflow(self, workflow_id: str):
        workflow = self.get_workflow(workflow_id)

        if workflow.state == LearningState.AUTO_CONFIRMED:
            # Workflow validé → Plus besoin des données brutes
            self._cleanup_learned_session(workflow.source_session_ids)

    def _cleanup_learned_session(self, session_ids: List[str]):
        """Nettoie les données brutes des sessions apprises."""
        for session_id in session_ids:
            # Supprimer screenshots
            screenshots_dir = Path(f"data/training/sessions/{session_id}/shots")
            if screenshots_dir.exists():
                shutil.rmtree(screenshots_dir)

            # Supprimer JSON brut
            for json_file in Path("data/training/sessions").rglob(f"*{session_id}.json"):
                json_file.unlink()

            # Supprimer ZIP
            for zip_file in Path("data/training/uploads").glob(f"{session_id}.*"):
                zip_file.unlink()

            logger.info(f"Cleaned up learned session: {session_id}")
```

### Option B : Nettoyage Manuel Contrôlé

**Interface admin** : Bouton "Nettoyer sessions apprises"

**Avantage** : Contrôle total, utile pour debugging

### Option C : Nettoyage Par Rétention

**Règle** : Conserver X jours de données brutes, supprimer le reste

```python
# Nettoyer sessions > 30 jours avec workflow confirmé
retention_days = 30
cutoff_date = datetime.now() - timedelta(days=retention_days)

for session in get_all_sessions():
    if session.created_at < cutoff_date:
        if session.has_confirmed_workflow():
            cleanup_session(session.id)
```

---

## 📋 Recommandation

### Court Terme (POC/MVP) - MAINTENANT
✅ **Désactiver le nettoyage**
- Permet de valider le système complet
- Permet la démo avec screenshots visibles
- Réversible

### Moyen Terme (Production V1) - APRÈS POC
✅ **Option A** : Nettoyage automatique post-apprentissage
- Logique claire et automatique
- Pas d'intervention manuelle
- Gain d'espace progressif

### Long Terme (Production V2)
✅ **Option A + C** : Auto + Rétention
- Nettoyage immédiat post-apprentissage
- + Rétention de sécurité (30j)
- + Interface admin pour cas spéciaux

---

## 🔍 Données à Conserver TOUJOURS

**Pour l'exécution autonome** :
- ✅ **Embeddings** (vecteurs CLIP 512D) → Matching rapide
- ✅ **Screen States** (états analysés) → Context des écrans
- ✅ **Workflows** (graphes validés) → Exécution automatique
- ✅ **Index FAISS** (recherche vectorielle) → Performance

**Ces 4 éléments suffisent pour faire tourner le RPA !**

---

## 💾 Estimation Espace Disque

### Avant Nettoyage (Par Session)
```
- Screenshots (16 x 1920x1080 PNG) : ~15-20 MB
- JSON session brut               : ~50 KB
- ZIP chiffré                     : ~15-20 MB
TOTAL par session                 : ~35-40 MB
```

### Après Nettoyage (Par Session)
```
- Embeddings (16 x 512 floats)    : ~32 KB
- Screen States (16 x JSON)       : ~20 KB
- Workflow (1 x JSON)             : ~5 KB
TOTAL par session                 : ~60 KB
```

**Gain** : ~99% d'espace (35 MB → 60 KB par session)

---

## 🎯 Actions Immédiates

1. ✅ **Maintenant** : Désactiver nettoyage prématuré
   ```bash
   sudo bash disable_premature_cleanup.sh
   ```

2. ✅ **Test** : Capturer nouvelle session
   ```bash
   cd agent_v0 && ./run.sh
   ```

3. ✅ **Validation** : Vérifier screenshots conservés
   ```bash
   ls -lhR /opt/rpa_vision_v3/data/training/sessions/sess_*/shots/
   ```

4. ⏳ **Après POC** : Implémenter Option A (nettoyage post-apprentissage)

---

## 📞 Questions/Décisions

- [ ] Quelle option choisir pour la production ? (A, B, ou C)
- [ ] Durée de rétention souhaitée ? (30j, 90j ?)
- [ ] Interface admin nécessaire ?
- [ ] Logs audit des nettoyages ?

---

**Version** : 1.0 - POC/MVP
**Prochaine révision** : Après validation POC