v1.0 - Version stable: multi-PC, détection UI-DETR-1, 3 modes exécution

- Frontend v4 accessible sur réseau local (192.168.1.40) - Ports ouverts: 3002 (frontend), 5001 (backend), 5004 (dashboard) - Ollama GPU fonctionnel - Self-healing interactif - Dashboard confiance Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-29 11:23:51 +01:00
parent 21bfa3b337
commit a27b74cf22
1595 changed files with 412691 additions and 400 deletions
--- a/docs/fiches/FICHE_11_TACHES_5_6_COMPLETE.md
+++ b/docs/fiches/FICHE_11_TACHES_5_6_COMPLETE.md
@@ -0,0 +1,141 @@
+# Fiche #11 - Tâches 5 & 6 Complétées
+
+**Auteur :** Dom, Alice Kiro  
+**Date :** 15 décembre 2024
+
+## Résumé
+
+Les tâches 5 et 6 de la Fiche #11 (Multi-Anchor Constraints) ont été implémentées avec succès :
+
+- **Tâche 5** : Système de scoring pondéré
+- **Tâche 6** : Système de tie-break stable
+
+## Tâche 5 : Système de Scoring Pondéré
+
+### 5.1 Amélioration de `_score_candidate_sniper`
+
+**Fichier modifié :** `core/execution/target_resolver.py`
+
+**Fonctionnalités implémentées :**
+- Extraction des poids depuis `target_spec.weights` avec valeurs par défaut
+- Calcul des 4 composants de scoring :
+  - **proximity** : Distance à l'ancre (défaut: 0.35)
+  - **alignment** : Alignement avec l'ancre (défaut: 0.25)
+  - **container** : Préférence pour containment (défaut: 0.15)
+  - **roi_iou** : Intersection avec ROI (défaut: 0.25)
+- Normalisation automatique des poids pour sommer à 1.0
+- Application des pondérations configurables
+
+**Exemple d'utilisation :**
+```python
+target_spec = TargetSpec(
+    by_role="button",
+    context_hints={"right_of_text": "Submit"},
+    weights={"proximity": 0.1, "alignment": 0.7, "container": 0.1, "roi_iou": 0.1}
+)
+```
+
+### 5.2 Scoring Composite avec Pondération Légère
+
+**Approche :**
+- Multiplication du score de base par un facteur pondéré
+- Évite de réécrire complètement le système existant
+- Bonus jusqu'à +40% basé sur les composants pondérés
+- Préserve la compatibilité avec le code existant
+
+## Tâche 6 : Système de Tie-Break Stable
+
+### 6.1 Fonction de Clé de Tri Stable
+
+**Méthode ajoutée :** `_create_stable_sort_key()`
+
+**Critères de tri (ordre de priorité) :**
+1. **Score composite** (décroissant)
+2. **Confiance de l'élément** (décroissant)
+3. **Aire de l'élément** (décroissant - plus grand = plus visible)
+4. **ID de l'élément** (croissant - pour déterminisme)
+
+### 6.2 Sélection avec Tie-Breaking
+
+**Méthode ajoutée :** `_select_best_candidate_with_tiebreak()`
+
+**Fonctionnalités :**
+- Tri stable de tous les candidats
+- Détection automatique du critère de tie-break utilisé
+- Logging des critères pour audit
+- Gestion des cas spéciaux (aucun candidat, candidat unique)
+
+**Critères de tie-break détectés :**
+- `"score"` : Départage par score uniquement
+- `"confidence"` : Égalité sur score, départage par confiance
+- `"area"` : Égalité sur score et confiance, départage par aire
+- `"element_id"` : Égalité sur tous critères, départage par ID
+
+## Intégration dans `_resolve_composite`
+
+**Modifications apportées :**
+- Utilisation du nouveau scoring pondéré
+- Application du tie-breaking stable
+- Métadonnées enrichies avec informations de pondération et tie-break
+- Correction de la génération du top3 des candidats
+
+## Tests Implémentés
+
+### Tests de Scoring Pondéré
+- `test_weighted_scoring_custom()` : Vérification que les poids influencent la sélection
+- Test avec poids favorisant l'alignement (0.7) vs proximité (0.1)
+
+### Tests de Tie-Breaking
+- `test_tie_breaking_determinism()` : Vérification de la stabilité sur 5 exécutions
+- `test_create_stable_sort_key()` : Test de la structure de clé de tri
+- `test_select_best_candidate_with_tiebreak_*()` : Tests des différents scénarios
+
+### Tests des Helpers
+- `test_as_text_list_various_inputs()` : Test de conversion en liste de textes
+- `test_container_bbox_from_text_*()` : Tests de résolution de containers
+- `test_apply_hard_constraints_*()` : Tests des contraintes strictes
+
+## Métadonnées de Résolution Enrichies
+
+**Nouvelles métadonnées dans `resolution_details` :**
+```python
+{
+    "weights_used": {"proximity": 0.1, "alignment": 0.7, ...},
+    "tie_break_criteria": "confidence",
+    "successful_anchor": "anchor_element_id",
+    "hard_constraints_applied": {...},
+    "candidates_filtered": 2
+}
+```
+
+## Compatibilité
+
+- **Backward compatible** : Fonctionne sans `weights` spécifiés (utilise les défauts)
+- **Graceful degradation** : Continue de fonctionner si certains composants échouent
+- **Préservation du comportement existant** : Le scoring de base reste inchangé
+
+## Validation
+
+✅ **13 tests passent** dans `test_fiche11_multi_anchor_constraints.py`  
+✅ **Scoring pondéré** fonctionne correctement  
+✅ **Tie-breaking stable** est déterministe  
+✅ **Métadonnées complètes** sont générées  
+✅ **Compatibilité préservée** avec le code existant  
+
+## Prochaines Étapes
+
+Les tâches suivantes de la Fiche #11 peuvent maintenant être abordées :
+- Tâche 7 : Sélection de la meilleure combinaison ancre-candidat
+- Tâche 8 : Optimisation des performances et caching
+- Tâche 9 : Tests spécifiques complémentaires
+- Tâche 10 : Intégration et tests de performance
+
+## Exigences Satisfaites
+
+**Tâche 5 :**
+- ✅ Exigences 3.1, 3.2, 3.3, 3.4 : Composants de scoring pondérés
+- ✅ Exigence 3.5 : Scoring composite léger
+
+**Tâche 6 :**
+- ✅ Exigences 5.1, 5.2, 5.3, 5.4 : Critères de tri stable
+- ✅ Exigence 5.5 : Déterminisme du tie-breaking
--- a/docs/fiches/FICHE_12_FORM_ROWS_COLUMNS_COMPLETE.md
+++ b/docs/fiches/FICHE_12_FORM_ROWS_COLUMNS_COMPLETE.md
@@ -0,0 +1,217 @@
+# Fiche #12 - Form Rows/Columns : Association Label→Champ ✅
+
+**Auteur :** Dom, Alice Kiro  
+**Date :** 19 décembre 2024  
+**Statut :** ✅ TERMINÉ  
+**Objectif :** Implémentation du grouping lignes/colonnes et association intelligente label→champ
+
+## 🎯 Objectif de la Fiche
+
+Implémenter la **Fiche #12 : "Form Rows / Columns"** - le moment où le système arrête de voir des rectangles et commence à voir des lignes de formulaire avec association label → champ.
+
+### Ce que ça apporte
+
+- **"le champ pour Username"** = l'input sur la même ligne à droite (pattern #1 des UI)
+- **Désambiguïsation massive** quand il y a 10 inputs identiques
+- **Plus robuste** que "near_text" seul (qui peut se tromper si deux zones proches)
+
+## ✅ Fonctionnalités Implémentées
+
+### 🔧 1. Nouvelles Context Hints
+
+Réutilisation de `context_hints` en ajoutant des clés :
+- `field_for: "Username"` ou `["Username", "Identifiant"]` - Association directe label→champ
+- `same_row_as_text: "Username"` - Bonus de ranking pour même ligne
+- `same_column_as_text: "Password"` - Bonus de ranking pour même colonne
+
+### 🏗️ 2. Helpers Rows/Columns
+
+**Nouvelles méthodes dans `TargetResolver` :**
+
+```python
+def _y_center(self, bbox) -> float:
+    """Centre Y d'une bbox (x, y, w, h)"""
+
+def _x_center(self, bbox) -> float:
+    """Centre X d'une bbox (x, y, w, h)"""
+
+def _is_inputish(self, elem: UIElement) -> bool:
+    """Vérifie si un élément est un champ de saisie"""
+
+def _is_labelish(self, elem: UIElement) -> bool:
+    """Vérifie si un élément est un label"""
+
+def _build_rows(self, elements: List[UIElement], y_tol: float = 18.0):
+    """Groupe les éléments en lignes selon la proximité du centre Y"""
+```
+
+### 🎯 3. Résolution Directe "field_for"
+
+**Méthode `_resolve_field_for()` :**
+- **Stratégie 1** : Cherche label sur la même ligne à droite (pattern #1 des UI)
+- **Stratégie 2** : Fallback input sous le label, même colonne
+- **Multi-anchor** : Support `["Username", "Identifiant"]`
+- **Hard constraints** : Respect des contraintes strictes
+
+**Logique d'association :**
+1. Trouve les anchors label possibles
+2. Pour chaque anchor, cherche inputs sur la même ligne à droite
+3. Si pas trouvé, fallback : inputs en dessous avec overlap X > 25%
+4. Choisit le meilleur candidat avec scoring
+
+### 🚀 4. Intégration Prioritaire
+
+**Shortcut dans `resolve_target()` :**
+- `field_for` a la **priorité absolue** (avant toutes autres stratégies)
+- Mise en cache automatique des résultats
+- Fallback gracieux vers autres stratégies si échec
+
+### 📊 5. Bonus Ranking Row/Column
+
+**Intégration dans `_score_candidate_sniper()` :**
+- `same_row_as_text` : Bonus x1.15 si même ligne que l'ancre
+- `same_column_as_text` : Bonus x1.10 si overlap X > 35% avec l'ancre
+- Utilise `_build_rows()` pour détection de lignes
+- Utilise overlap X pour détection de colonnes
+
+## 🧪 Tests Complets
+
+### Tests Principaux (8 tests)
+
+**Fichier 1 : `test_field_for_row_pairing.py`**
+- ✅ field_for choisit l'input de la même ligne (pas celui du bas)
+- ✅ field_for avec multi-anchor support
+- ✅ field_for avec contraintes strictes
+
+**Fichier 2 : `test_field_for_fallback_below.py`**
+- ✅ field_for fallback "sous le label" si pas d'input à droite
+- ✅ field_for préfère même ligne plutôt que en dessous
+- ✅ field_for fallback exige un alignement de colonne minimum
+- ✅ field_for choisit le plus proche en dessous quand plusieurs candidats
+- ✅ Comparaison field_for succès vs échec
+
+### Résultats des Tests
+
+```bash
+python3 -m pytest tests/unit/test_field_for_row_pairing.py tests/unit/test_field_for_fallback_below.py -v
+# Résultat : 8 passés, 0 échecs
+```
+
+## 📋 Exemples d'Utilisation
+
+### Exemple 1 : Association Label→Champ Basique
+
+```python
+# Chercher le champ pour "Username"
+target_spec = TargetSpec(
+    by_role="input",
+    context_hints={"field_for": "Username"}
+)
+
+# Le système trouvera l'input sur la même ligne à droite du label "Username"
+result = resolver.resolve_target(target_spec, screen_state)
+```
+
+### Exemple 2 : Multi-Anchor avec Fallback
+
+```python
+# Support multi-langue
+target_spec = TargetSpec(
+    by_role="input",
+    context_hints={"field_for": ["Username", "Identifiant", "Nom d'utilisateur"]}
+)
+
+# Trouvera le champ associé au premier label trouvé
+result = resolver.resolve_target(target_spec, screen_state)
+```
+
+### Exemple 3 : Bonus Ranking Row/Column
+
+```python
+# Bonus pour éléments sur la même ligne
+target_spec = TargetSpec(
+    by_role="button",
+    by_text="Submit",
+    context_hints={"same_row_as_text": "Cancel"}  # Bonus si sur même ligne que "Cancel"
+)
+
+# Le scoring sera amélioré pour les boutons sur la même ligne
+result = resolver.resolve_target(target_spec, screen_state)
+```
+
+### Exemple 4 : Avec Contraintes Strictes
+
+```python
+# Association dans un conteneur spécifique
+target_spec = TargetSpec(
+    by_role="input",
+    context_hints={"field_for": "Password"},
+    hard_constraints={"within_container_text": "Login"}
+)
+
+# Trouvera le champ Password dans le panel Login uniquement
+result = resolver.resolve_target(target_spec, screen_state)
+```
+
+## 🔧 Détails Techniques
+
+### Algorithme de Grouping en Lignes
+
+```python
+def _build_rows(self, elements, y_tol=18.0):
+    # 1. Trier par centre Y
+    # 2. Grouper par proximité Y (tolérance 18px)
+    # 3. Trier chaque ligne par X (gauche à droite)
+    # 4. Retourner rows + mapping element_id -> row_index
+```
+
+### Scoring field_for
+
+- **Même ligne à droite** : Score 0.95 (priorité haute)
+- **Fallback en dessous** : Score 0.85 (priorité moyenne)
+- **Tri par proximité** : Distance horizontale puis aire puis ID
+
+### Intégration avec Système Existant
+
+- **Compatibilité** : Aucun impact sur fonctionnalités existantes
+- **Performance** : Shortcut prioritaire évite calculs inutiles
+- **Robustesse** : Fallback gracieux vers autres stratégies
+- **Healing** : Utilise le healing profile pour tolérance
+
+## 🎯 Impact Système
+
+### Améliorations Apportées
+
+- **Précision formulaires** : Association intelligente label→champ
+- **Désambiguïsation** : Résout les cas avec multiples inputs identiques
+- **Robustesse UI** : Comprend la structure des formulaires
+- **Performance** : Résolution directe plus rapide
+- **Flexibilité** : Support multi-anchor et contraintes
+
+### Cas d'Usage Résolus
+
+1. **Formulaires de connexion** : Username/Password avec labels
+2. **Formulaires d'inscription** : Multiples champs similaires
+3. **Interfaces multilingues** : Labels en différentes langues
+4. **Formulaires complexes** : Grouping par sections/panels
+5. **Applications web** : Patterns UI standards
+
+## 📊 Métriques de Qualité
+
+- **Tests** : 8 tests unitaires, 100% de réussite
+- **Couverture** : Toutes les fonctionnalités testées
+- **Performance** : Shortcut prioritaire pour cas fréquents
+- **Robustesse** : Fallback gracieux en cas d'échec
+- **Compatibilité** : Aucune régression sur fonctionnalités existantes
+
+## 🚀 Prochaines Étapes
+
+La Fiche #12 est **complètement terminée** et prête pour utilisation en production. Les prochaines améliorations possibles :
+
+1. **Fiche #13** : Optimisation performances avec caching avancé
+2. **Fiche #14** : Support des formulaires dynamiques (AJAX)
+3. **Fiche #15** : Intégration avec système de learning automatique
+
+---
+
+**Fiche #12 implémentée avec succès ! Le système comprend maintenant la structure des formulaires et peut associer intelligemment les labels aux champs de saisie.** 🎉
--- a/docs/fiches/FICHE_24_OBSERVABILITY.md
+++ b/docs/fiches/FICHE_24_OBSERVABILITY.md
@@ -0,0 +1,59 @@
+# FICHE 24 — Observabilité (metrics + request id)
+
+## Ce que ça ajoute
+
+1) **/metrics** sur l'API FastAPI (`server/api_upload.py`) — en plus du dashboard qui l'avait déjà.
+2) **Métriques HTTP** (req/s, statuts, latence, in-flight) **y compris** pour les requêtes bloquées par la sécu.
+3) **Métriques "sécurité"** : compteur des blocages (`auth_fail`, `rate_limit`, `demo_safe`, `killswitch`, `ip_block`).
+4) **Header `X-Request-Id`** sur toutes les réponses (pratique pour corréler logs ↔ requêtes ↔ incidents).
+
+## Endpoints utiles
+
+- Dashboard (Flask):
+  - `GET /metrics` (déjà présent)
+  - `GET /health` / `GET /api/status` (selon ta config)
+
+- API Upload (FastAPI):
+  - `GET /healthz`
+  - `GET /metrics` ✅ (nouveau)
+  - `GET /api/traces/status`
+
+## Nouvelles métriques
+
+- `http_requests_total{service,method,path,status}`
+- `http_request_duration_seconds{service,method,path}`
+- `http_requests_in_flight{service}`
+- `rpa_security_blocks_total{service,reason}`
+
+### Labels
+- `service` vient de `RPA_SERVICE_NAME` (en prod: posé par les unités systemd).
+- `path` utilise le **template** de route quand disponible (évite la cardinalité).
+
+## Test rapide (sans Prometheus)
+
+### 1) Vérifier l'API
+```bash
+curl -s http://127.0.0.1:8000/metrics | head
+curl -i http://127.0.0.1:8000/api/traces/status | head
+```
+Tu dois voir `X-Request-Id:` dans la réponse.
+
+### 2) Provoquer un blocage et voir le compteur monter
+```bash
+# Sans token -> 401 (si RPA_AUTH_REQUIRED)
+curl -i http://127.0.0.1:8000/api/traces/sessions | head
+
+# Re-scrape metrics
+curl -s http://127.0.0.1:8000/metrics | grep -E "rpa_security_blocks_total|http_requests_total" | head
+```
+
+## Prometheus (optionnel)
+
+Un exemple de config (si tu veux monter un Prometheus plus tard) :
+- `deploy/prometheus/prometheus.yml` (si tu l'ajoutes) qui scrape :
+  - `127.0.0.1:8000/metrics` (API)
+  - `127.0.0.1:5001/metrics` (Dashboard)
+
+## Bonus
+
+Ce patch corrige aussi **un bug de syntaxe Python** dans `core/healing/strategies/format_transformation.py` (f-string + regex) qui empêchait un `py_compile` complet.
--- a/docs/fiches/SESSION_15DEC_FICHE11_TACHES_5_6_COMPLETE.md
+++ b/docs/fiches/SESSION_15DEC_FICHE11_TACHES_5_6_COMPLETE.md
@@ -0,0 +1,168 @@
+# Session 15 Décembre 2024 - Fiche #11 Tâches 5 & 6 Terminées ✅
+
+**Auteur :** Dom, Alice Kiro  
+**Date :** 15 décembre 2024  
+**Statut :** ✅ TERMINÉ  
+**Session :** Implémentation complète des tâches 5 et 6 de la Fiche #11 (Multi-Anchor Constraints)
+
+## 🎯 Objectif de la Session
+
+Implémenter les **Tâches 5 et 6** de la Fiche #11 avec succès :
+- **Tâche 5** : Système de Scoring Pondéré
+- **Tâche 6** : Système de Tie-Breaking Stable
+
+## ✅ Travail Accompli
+
+### 🎯 Tâche 5 : Système de Scoring Pondéré
+
+**✅ 5.1 Amélioration de `_score_candidate`**
+- Ajout du paramètre `weights` à la méthode `_sniper`
+- Extraction des poids depuis `target_spec.weights`
+- Calcul de 4 composants de scoring :
+  - `proximity` (0.35) : Distance à l'ancre
+  - `alignment` (0.25) : Alignement avec l'ancre  
+  - `container` (0.15) : Préférence pour conteneur
+  - `roi_iou` (0.25) : Intersection avec ROI
+- Application des poids configurables
+- Normalisation automatique des poids
+
+**✅ 5.2 Scoring Composite Pondéré**
+- Multiplication du score de base par facteur pondéré
+- Bonus jusqu'à +40% sur composants pondérés
+- Préservation du système de scoring existant
+- Compatibilité backward complète
+
+### 🎯 Tâche 6 : Système de Tie-Breaking Stable
+
+**✅ 6.1 Fonction de Clé de Tri Stable**
+- Nouvelle méthode `_create_stable_sort_key()`
+- Critères de tri hiérarchiques :
+  1. Score composite (décroissant)
+  2. Confiance (décroissant) 
+  3. Aire élément (décroissant)
+  4. ID élément (croissant - déterministe)
+
+**✅ 6.2 Système Tie-Breaking avec Logging**
+- Nouvelle méthode `_select_best_candidate_with_tiebreak()`
+- Détection automatique du critère utilisé
+- Logging des critères pour audit
+- Gestion des cas spéciaux
+
+## 🔧 Intégration dans `_resolve_composite`
+
+**Modifications apportées :**
+- Utilisation du nouveau scoring pondéré
+- Application du tie-breaking stable
+- Correction de la génération de métadonnées enrichies
+- Métadonnées avec informations de pondération
+
+## 🧪 Tests Complets
+
+**13 tests implémentés et validés :**
+- Tests de scoring avec différents poids
+- Tests de tie-breaking déterministe
+- Tests de méthodes helpers (containers, conversion, etc.)
+- Tests de différents scénarios de sélection stable
+
+### ✅ Tests Unitaires
+
+```bash
+python -m pytest tests/unit/test_fiche11_multi_anchor_constraints.py -v
+# Résultat : 13 passés, 1 warning
+```
+
+## ✅ Validation Technique
+
+### Code
+- Aucune erreur de syntaxe détectée
+- Code conforme aux standards du projet
+- Compatibilité préservée
+
+### Fonctionnalités
+- ✅ Fonctionnalités validées
+- ✅ Scoring pondéré correct
+- ✅ Tie-breaking déterministe
+- ✅ Métadonnées complètes sont générées
+- ✅ Backward compatibility maintenue
+
+## Exemple d'Utilisation
+
+```python
+# Utilisation du nouveau système pondéré
+target_spec = TargetSpec(
+    role="button",
+    text="Submit",
+    context_hints={"right_of": "input"},
+    weights={
+        "proximity": 0.4,    # Haute importance
+        "alignment": 0.3,    # Haute importance  
+        "container": 0.2,    # Moyenne importance
+        "roi_iou": 0.1       # Faible importance
+    }
+)
+
+# Le système sélectionnera l'élément le mieux aligné
+# même s'il est plus éloigné
+result = resolver.resolve_composite(target_spec, screen_state)
+
+# Métadonnées pondérées
+print(result.resolution_details["weights_used"])
+print(result.resolution_details["tie_break_criteria"])
+```
+
+## 📊 État d'Avancement Fiche #11
+
+**Tâches Terminées :** 6/11 (55%)
+- [x] 1. Étendre TargetSpec (PATCH #11.1)
+- [x] 2. Helpers de base (PATCH #11.2A) 
+- [x] 3. Contraintes strictes (PATCH #11.2B)
+- [x] 4. Système multi-anchor (PATCH #11.2C)
+- [x] 5. **Scoring pondéré (PATCH #11.2D)** ← Cette session
+- [x] 6. **Tie-breaking stable (PATCH #11.2E)** ← Cette session
+
+**Tâches Restantes :** 5/11 (45%)
+- [ ] 7. Sélection combinaison ancre-candidat optimale
+- [ ] 8. Optimisation performances et caching
+- [ ] 9. Tests spécifiques complémentaires (9.2, 9.3, 9.4)
+- [ ] 10. Intégration et tests de performance
+- [ ] 11. Point de contrôle final
+
+## # Prochaines Étapes Recommandées
+
+1. **Tâche 7** : Implémentation sélection optimale ancre-candidat
+2. **Tâche 8** : Ajout caching et optimisation performances  
+3. **Tâche 9.2-9.4** : Tests spécifiques complémentaires
+4. **Tests d'intégration** : Valider avec le système existant
+
+## # Impact Système
+
+### Améliorations Apportées
+- **Précision** : Scoring pondéré pour sélection plus précise
+- **Stabilité** : Tie-breaking déterministe élimine la variabilité
+- **Observabilité** : Métadonnées enrichies pour debugging
+- **Logging** : Messages appropriés de debug
+- **Gestion d'erreurs** : Fallbacks gracieux implémentés
+
+### Compatibilité
+- **Backward compatibility** : Fonctionne sans configuration additionnelle
+- **Graceful degradation** : Continue de fonctionner si composants échouent
+- **Impact minimal** : Performances normales sur cas existants
+
+### Flexibilité
+- **Poids configurables** : Contexte d'utilisation
+- **Logging** : Métadonnées enrichies pour debugging
+- **Observabilité** : Métadonnées complètes sont générées
+- **Stabilité** : Tie-breaking déterministe élimine la variabilité
+
+## ✅ Qualité du Code
+
+- **Documentation** : Docstrings complètes en français
+- **Attribution** : "Auteur : Dom, Alice Kiro - 15 décembre 2024"
+- **Standards** : Respect des conventions du projet
+- **Tests** : Couverture complète des nouvelles fonctionnalités
+- **Logging** : Messages appropriés de debug
+- **Gestion d'erreurs** : Fallbacks gracieux implémentés
+
+---
+
+**Session terminée avec succès. Tâches 5 & 6 de la Fiche #11 complètement implémentées.**