Ajoute le suivi des echecs et la boucle de correction pompiste

- quality.py : verifie luminosite avant flou (evite les faux "floue" sur
photos sombres mais nettes)
- monitoring/ : feedback.py (collecte + conversion vers annotations.json)
et metrics.py (agregation logs/api.log, dont liste des echecs)
- API : GET /failures, GET /photos/{ref}, stockage optionnel sur
YELY_DATA_DIR (stockage persistant HF Spaces)
- web/stats.html : section requetes echouees avec photo + lien de
correction ; web/feedback.html : formulaire de correction premployi
- tests/test_monitoring.py (19 tests)

.gitignore

@@ -3,4 +3,6 @@ photos/
 logs/
 __pycache__/
 *.pyc
-*.tmp
+*.tmp
+monitoring/feedback.jsonl
+monitoring/feedback_crops/

app/main.py

@@ -19,7 +19,7 @@ from pathlib import Path
 import cv2
 from fastapi import FastAPI, File, UploadFile, Form, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
+from fastapi.responses import JSONResponse, FileResponse
 
 from .config import load_config
 from .preprocessing import detect_screen_region
@@ -27,13 +27,28 @@ from .quality import estimate_image_quality
 from .recognizer import get_device, load_model, recognize_screen
 from .postprocess import process as postprocess_results
 from .rules import evaluate as evaluate_rules
+from monitoring.feedback import record_feedback, CORRECTABLE_FIELDS
+from monitoring.metrics import compute_metrics, list_failed_requests
 
 MODULE_ROOT = Path(__file__).resolve().parent.parent
-LOG_DIR = MODULE_ROOT / "logs"
+
+# YELY_DATA_DIR : répertoire persistant optionnel (ex. stockage persistant
+# d'un Hugging Face Space, monté sur /data). Sans stockage persistant, un
+# Space Docker gratuit repart de zéro à chaque redémarrage/veille — photos,
+# logs et feedback.jsonl sont alors perdus. Voir docs/MONITORING.md pour la
+# marche à suivre côté Space. Doit rester identique à `DATA_DIR` dans
+# `monitoring/metrics.py` et `monitoring/feedback.py`.
+DATA_DIR = Path(os.environ.get("YELY_DATA_DIR", str(MODULE_ROOT)))
+LOG_DIR = DATA_DIR / "logs"
 LOG_DIR.mkdir(parents=True, exist_ok=True)
-PHOTOS_DIR = MODULE_ROOT / "photos"
+PHOTOS_DIR = DATA_DIR / "photos"
 PHOTOS_DIR.mkdir(parents=True, exist_ok=True)
 
+# Identifiant du modèle actif, à faire varier entre deux versions ré-entraînées
+# (voir docs/MONITORING.md) — permet de comparer les métriques d'une version
+# à l'autre a posteriori dans les logs, sans changer le contrat de réponse.
+MODEL_VERSION = os.environ.get("MODEL_VERSION", "crnn_v2_70.2pct")
+
 logger = logging.getLogger("yely_ai_module")
 logger.setLevel(logging.INFO)
 _file_handler = logging.FileHandler(LOG_DIR / "api.log", encoding="utf-8")
@@ -46,12 +61,12 @@ app = FastAPI(title="YELY — Module IA pompiste (CRNN)")
 # différents : sans CORS, le navigateur bloquerait la lecture de la réponse
 # même si la requête aboutit côté serveur. ALLOWED_ORIGINS est une liste
 # d'origines séparées par des virgules (ex. "https://yely-demo.vercel.app").
-_allowed_origins = os.environ.get("ALLOWED_ORIGINS", "https://yely-demo.netlify.app/")
+_allowed_origins = os.environ.get("ALLOWED_ORIGINS", "*")
 
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"] if _allowed_origins == "*" else _allowed_origins.split(","),
-    allow_methods=["POST"],
+    allow_methods=["GET", "POST"],
     allow_headers=["*"],
 )
 
@@ -63,6 +78,17 @@ _model = None
 _device = None
 
 
+def _safe_photo_path(photo_reference: str) -> Path | None:
+    """Résout `photo_reference` sous `PHOTOS_DIR`, sans jamais sortir de ce
+    dossier (`Path.name` élimine tout `../`/séparateur). Retourne `None` si
+    le fichier n'existe pas — les appelants renvoient alors un 404.
+    """
+    candidate = PHOTOS_DIR / Path(photo_reference).name
+    if candidate.exists() and candidate.parent == PHOTOS_DIR:
+        return candidate
+    return None
+
+
 def _get_model():
     global _model, _device
     if _model is None:
@@ -142,6 +168,7 @@ async def analyze(
         }
 
         logger.info(json.dumps({
+            "model_version": MODEL_VERSION,
             "request": {
                 "filename": image.filename,
                 "fuel_price": fuel_price,
@@ -158,3 +185,62 @@ async def analyze(
             os.remove(tmp_path)
         except Exception:
             pass
+
+
+@app.post("/feedback")
+async def feedback(
+    photo_reference: str = Form(...),
+    corrected_prix: float = Form(None),
+    corrected_volume: float = Form(None),
+    corrected_prix_litre: float = Form(None),
+    corrected_by: str = Form(None),
+):
+    """Corrections a posteriori (pompiste/station) sur une transaction déjà
+    traitée par `/analyze` — matière première de l'apprentissage continu.
+    Voir docs/MONITORING.md pour le fonctionnement complet de la boucle.
+    """
+    if _safe_photo_path(photo_reference) is None:
+        raise HTTPException(status_code=404, detail="photo_reference inconnue (transaction introuvable)")
+
+    corrected_fields = {}
+    if corrected_prix is not None:
+        corrected_fields["prix"] = corrected_prix
+    if corrected_volume is not None:
+        corrected_fields["volume"] = corrected_volume
+    if corrected_prix_litre is not None:
+        corrected_fields["prix_litre"] = corrected_prix_litre
+    if not corrected_fields:
+        raise HTTPException(status_code=400, detail="Aucune correction fournie (corrected_prix/corrected_volume/corrected_prix_litre)")
+
+    entry = record_feedback(photo_reference, corrected_fields, corrected_by=corrected_by)
+    logger.info(json.dumps({"feedback": entry}, ensure_ascii=False))
+    return JSONResponse(content={"success": True, "feedback_id": entry["feedback_id"]})
+
+
+@app.get("/metrics")
+async def metrics():
+    """Aperçu agrégé des performances observées en production (§3 de
+    docs/WORKFLOW.md) : taux de succès, confiance moyenne, causes de blocage.
+    Calculé à la volée à partir de `logs/api.log` — pas d'état en mémoire.
+    """
+    return JSONResponse(content=compute_metrics())
+
+
+@app.get("/failures")
+async def failures(limit: int = 20):
+    """Dernières transactions bloquées (`success=false`), pour la section
+    « Requêtes échouées » de `web/stats.html` — chaque entrée référence sa
+    photo via `photo_reference`, servie par `GET /photos/{photo_reference}`.
+    """
+    return JSONResponse(content=list_failed_requests(limit=limit))
+
+
+@app.get("/photos/{photo_reference}")
+async def get_photo(photo_reference: str):
+    """Ressert une photo déjà reçue par `/analyze`, pour l'affichage dans
+    le tableau de bord et le formulaire de correction (`web/feedback.html`).
+    """
+    photo_path = _safe_photo_path(photo_reference)
+    if photo_path is None:
+        raise HTTPException(status_code=404, detail="Photo introuvable")
+    return FileResponse(photo_path)

app/quality.py

@@ -25,16 +25,21 @@ def estimate_image_quality(img: np.ndarray,
     blur = cv2.Laplacian(gray, cv2.CV_64F).var()
     mean_brightness = float(np.mean(gray))
 
-    # Le flou/la luminosité sont des propriétés intrinsèques de l'image et
-    # doivent être vérifiés avant le repli "unclear" (nombre de résultats),
-    # sinon une image nette et bien éclairée mais avec peu de détections
-    # serait à tort classée "unclear" plutôt que diagnostiquée correctement.
-    if blur < cfg.blur_threshold:
-        label = "blurry"
-    elif mean_brightness < cfg.dark_threshold:
+    # La luminosité est vérifiée AVANT le flou. Raison (constatée sur des
+    # photos réelles sombres mais nettes) : la variance du Laplacien dépend
+    # elle-même du contraste, qui s'effondre dans une image sombre même
+    # quand les contours sont parfaitement nets. Tester le flou en premier
+    # classait donc à tort des photos sombres comme "blurry" au lieu de
+    # "dark" — deux causes qui appellent des messages/corrections différents
+    # côté utilisateur (reprendre la photo avec plus de lumière n'est pas le
+    # même geste que la stabiliser). Le flou n'est un diagnostic fiable que
+    # sur une image dont la luminosité est déjà normale.
+    if mean_brightness < cfg.dark_threshold:
         label = "dark"
     elif mean_brightness > cfg.bright_threshold:
         label = "bright"
+    elif blur < cfg.blur_threshold:
+        label = "blurry"
     elif ocr_results is not None and len(ocr_results) < 2:
         label = "unclear"
     else:

docs/API.md

@@ -59,3 +59,46 @@ et référencée dans la réponse (`photo_reference`) — nécessaire pour
 qu'un contrôle a posteriori (station, YELY) puisse revérifier une
 transaction contestée, et c'est aussi la matière première de la boucle
 d'apprentissage continu (`docs/MONITORING.md`).
+
+## `POST /feedback`
+
+Correction a posteriori d'une transaction déjà traitée par `/analyze` —
+voir `docs/MONITORING.md` pour le fonctionnement complet de la boucle
+d'apprentissage continu.
+
+| Champ | Type | Requis | Description |
+|---|---|---|---|
+| `photo_reference` | string | oui | valeur renvoyée par `/analyze` (doit exister dans `photos/`) |
+| `corrected_prix` | float | non* | montant réellement correct |
+| `corrected_volume` | float | non* | volume réellement correct |
+| `corrected_prix_litre` | float | non* | prix du litre réellement correct |
+| `corrected_by` | string | non | identifiant de qui corrige (pompiste/station) |
+
+\* au moins un des trois champs `corrected_*` est requis.
+
+Réponses : `200` (`{"success": true, "feedback_id": "..."}`), `404` si
+`photo_reference` ne correspond à aucune photo connue, `400` si aucune
+correction n'est fournie.
+
+## `GET /metrics`
+
+Aperçu agrégé des performances observées en production, calculé à la volée
+à partir de `logs/api.log` (pas de paramètre, pas d'état en mémoire) :
+`total_requests`, `success_rate`, `avg_confidence_score`, `blocking_causes`,
+`image_quality_distribution`. Voir `docs/MONITORING.md`.
+
+## `GET /failures`
+
+Les `limit` (défaut 20) dernières transactions bloquées (`success=false`),
+les plus récentes en premier — alimente la section « Requêtes échouées » de
+`web/stats.html`. Chaque élément : `photo_reference`, `message`,
+`image_quality`, `detected_liters`, `detected_amount`, `fuel_price`,
+`confidence_score`, `transaction_datetime`.
+
+## `GET /photos/{photo_reference}`
+
+Ressert l'image sauvegardée par `/analyze` sous ce `photo_reference` (sert
+l'affichage dans le tableau de bord et le formulaire de correction). `404`
+si la référence est inconnue. `photo_reference` est assaini côté serveur
+(`Path(...).name`) avant résolution sous `PHOTOS_DIR` — aucune traversée de
+répertoire possible même si la valeur contient `../`.

docs/LIMITATIONS.md

@@ -70,6 +70,19 @@ qui restent d'actualité.
 - Envisager de la **data augmentation** (légères rotations, variations de
   luminosité/contraste) pour compenser partiellement le manque de diversité.
 
+## Bug de classification qualité corrigé (flou vs sombre)
+
+`app/quality.py` vérifiait le flou (variance du Laplacien) avant la
+luminosité. Or la variance du Laplacien dépend elle-même du contraste, qui
+s'effondre dans une image sombre même quand les contours sont nets : une
+photo prise dans un environnement peu éclairé mais parfaitement stable
+pouvait donc être classée à tort `"blurry"` ("reprendre la photo, image
+floue") au lieu de `"dark"` ("reprendre la photo avec plus de lumière") —
+deux diagnostics qui appellent un geste correctif différent côté
+utilisateur. **Corrigé** : la luminosité (`dark`/`bright`) est maintenant
+vérifiée avant le flou, qui n'est un diagnostic fiable que sur une image
+déjà correctement exposée.
+
 ## Ce qui reste fiable indépendamment du modèle
 
 La détection d'écran, le contrôle qualité (flou/luminosité), le moteur de

docs/MONITORING.md

@@ -0,0 +1,263 @@
+# Monitoring et apprentissage continu (`monitoring/`)
+
+Deux besoins distincts couverts ici : **savoir comment le modèle se comporte
+en production** (suivi des performances), et **transformer les erreurs
+observées en nouvelles données d'entraînement** (apprentissage continu).
+Aucun des deux ne modifie le comportement de `/analyze` — ce sont des
+composants qui lisent/complètent les traces déjà produites par l'API.
+
+## 1. Suivi des performances
+
+Chaque appel à `POST /analyze` écrit déjà une ligne JSON dans `logs/api.log`
+(requête sans l'image + réponse complète + `model_version`). `monitoring/metrics.py`
+parse ce fichier et calcule, sans état en mémoire ni base de données :
+
+- `total_requests` : nombre d'appels journalisés.
+- `success_rate` : proportion de réponses `success=true`.
+- `avg_confidence_score` : moyenne des `confidence_score` renvoyés.
+- `blocking_causes` : histogramme des `message` pour les réponses bloquées
+  (utile pour voir si le facteur limitant en démo est le flou, l'incohérence,
+  ou la confiance — voir `docs/LIMITATIONS.md`).
+- `image_quality_distribution` : histogramme des `image_quality` observés.
+
+Deux façons de le lire :
+
+```bash
+# en ligne de commande, pour un rapport texte
+cd yely_ai_module
+python -m monitoring.metrics
+
+# via l'API elle-même, pendant la démo
+curl http://127.0.0.1:8000/metrics
+```
+
+`GET /metrics` renvoie le même dictionnaire que `compute_metrics()`, sans
+paramètre — il relit `logs/api.log` à chaque appel, donc reflète l'état
+courant sans redémarrer le serveur.
+
+`web/stats.html` est un tableau de bord minimal pour la soutenance : il
+appelle `GET /metrics` (URL de l'API dérivée de celle configurée dans
+`web/index.html`, stockée dans le même `localStorage`) et affiche requêtes
+totales, taux de succès, confiance moyenne, répartition qualité image et
+causes de blocage, avec auto-rafraîchissement toutes les 15s. Nécessite que
+`allow_methods` inclue `GET` dans le middleware CORS de `app/main.py`
+(sinon le navigateur bloque la lecture de la réponse, même si l'appel
+aboutit côté serveur — piège déjà rencontré avec `/analyze` en `POST`).
+
+`model_version` (variable d'environnement `MODEL_VERSION`, valeur par défaut
+`crnn_v2_70.2pct`) est ajouté à chaque entrée de log — pas à la réponse
+publique de `/analyze`, pour ne pas polluer le contrat API §13 avec un champ
+technique. Il permet de comparer `logs/api.log` avant/après un
+ré-entraînement en filtrant par version, une fois plusieurs modèles utilisés
+en séquence (voir §3).
+
+## 2. Boucle d'apprentissage continu (`monitoring/feedback.py`)
+
+### Principe
+
+Chaque photo reçue par `/analyze` est déjà sauvegardée dans
+`photos/<transaction_id>.jpg` et référencée dans la réponse
+(`photo_reference`). Cette boucle réutilise cette photo pour transformer une
+lecture erronée, corrigée a posteriori par un pompiste ou un contrôle YELY,
+en nouvelle donnée d'entraînement — sans jamais toucher au dataset pendant
+qu'un entraînement est en cours (leçon retenue d'un crash réel, voir
+`docs/TRAINING.md`).
+
+### Étape 1 — collecte : `POST /feedback`
+
+```bash
+curl -X POST http://127.0.0.1:8000/feedback \
+  -F "photo_reference=3f2a1c9e-....jpg" \
+  -F "corrected_prix=10000" \
+  -F "corrected_volume=14.28" \
+  -F "corrected_prix_litre=700" \
+  -F "corrected_by=pompiste-7"
+```
+
+- `photo_reference` (requis) : valeur renvoyée par `/analyze` dans la
+  réponse d'origine — l'API vérifie que la photo existe encore dans
+  `photos/` avant d'accepter la correction (`404` sinon).
+- Au moins un des trois champs `corrected_prix` / `corrected_volume` /
+  `corrected_prix_litre` est requis ; les champs non fournis restent
+  inconnus (pas déduits automatiquement).
+- Chaque correction est ajoutée en une ligne à `monitoring/feedback.jsonl`
+  (append-only, jamais réécrit sur cet endpoint) via
+  `monitoring.feedback.record_feedback`.
+
+**En pratique (démo/soutenance), pas besoin de `curl`** : `web/stats.html`
+liste les transactions bloquées (`GET /failures`, 20 dernières, avec la
+photo servie par `GET /photos/{photo_reference}`) avec un bouton
+« Corriger » par entrée, qui ouvre `web/feedback.html?ref=<photo_reference>`
+— la référence est déjà pré-remplie, la photo s'affiche automatiquement, il
+ne reste qu'à saisir les valeurs correctes et valider. Cette page reste
+aussi utilisable seule (référence saisie à la main) si besoin.
+
+### Étape 2 — conversion : `monitoring/feedback.py`
+
+```bash
+cd yely_ai_module
+python -m monitoring.feedback
+```
+
+Pour chaque entrée de `feedback.jsonl` pas encore convertie :
+
+1. Relit la photo dans `photos/`.
+2. Relance `detect_screen_region` (même fonction que l'API) pour localiser
+   l'écran et produire un crop, sauvegardé dans `monitoring/feedback_crops/`.
+3. Ajoute une entrée à `annotator/annotations/annotations.json`, **au même
+   format** que l'annotation manuelle (`lcd_bbox`, `lcd_crop`, `fields`), en
+   utilisant les valeurs corrigées comme champs.
+4. Marque l'entrée `converted=true` dans `feedback.jsonl` pour ne pas la
+   reconvertir au prochain passage.
+
+**Point important** : la détection d'écran automatique n'est pas fiable à
+100% (voir `docs/LIMITATIONS.md`, point 2 — 86% des images d'origine sont
+tombées sur un repli approximatif). Les entrées générées ici sont donc
+marquées `"status": "pending_review"` (pas `"annotated"`) : une relecture
+humaine rapide via l'outil `annotator/` (vérifier que `lcd_bbox` cadre bien
+l'écran) reste nécessaire avant de les inclure dans un ré-entraînement. Ce
+choix est délibéré — préférer une étape manuelle courte à l'injection
+silencieuse de crops mal cadrés dans le dataset, qui dégraderait la
+précision plutôt que de l'améliorer (cf. la cause n°2 de la limitation à
+70.2%).
+
+#### Relire les entrées `pending_review` (`annotator/annotate.py --review-pending`)
+
+`annotate.py` a un mode dédié qui ne parcourt pas un dossier d'images mais
+relit directement les entrées `status="pending_review"` d'`annotations.json`
+— une par une, avec le rectangle et les valeurs déjà pré-remplis (à
+confirmer ou corriger) au lieu de repartir de zéro :
+
+```bash
+cd annotator
+python annotate.py --review-pending
+```
+
+Marche à suivre pour chaque image affichée :
+
+1. Le rectangle vert affiché est le `lcd_bbox` détecté automatiquement au
+   moment de la conversion — regarde s'il cadre bien l'écran LCD.
+2. **S'il est correct** : appuie sur `S` ou `Entrée` directement, pas besoin
+   de redessiner.
+3. **S'il est mal cadré** (coupe un chiffre, déborde sur le boîtier...) :
+   appuie sur `R` pour l'effacer, puis dessine un nouveau rectangle
+   (clic + glisser) avant `S`/`Entrée`.
+4. Le terminal demande ensuite de confirmer les valeurs (prix, volume,
+   prix/litre...) — elles sont **déjà pré-remplies** avec la correction
+   envoyée par le pompiste (visibles entre crochets `[...]`) : appuie sur
+   `Entrée` pour chaque champ correct, ou retape la valeur si besoin de
+   l'ajuster.
+5. `N` pour ignorer une entrée douteuse (photo illisible, correction qui ne
+   semble pas fiable) — elle passe en `status="skipped"` et ne sera plus
+   proposée ni utilisée à l'entraînement.
+6. `Q`/`Esc` pour arrêter la session en cours ; la progression déjà validée
+   est sauvegardée, il suffit de relancer `--review-pending` plus tard pour
+   reprendre (seules les entrées encore `pending_review` sont reproposées).
+
+Chaque entrée confirmée passe automatiquement en `status="annotated"` — la
+suite (§3) la traite alors exactement comme une annotation manuelle
+classique. `python annotate.py --review` (sans `--review-pending`) affiche
+à tout moment un résumé indiquant combien d'entrées restent `[à relire]`.
+
+### Étape 3 — ré-entraînement périodique
+
+Une fois un nombre suffisant d'entrées `pending_review` relues et passées à
+`"annotated"` (ex. tous les 30-50 nouvelles corrections, à ajuster selon le
+volume réel observé en production) :
+
+```bash
+cd annotator
+python split_lines.py          # nettoie et régénère train/val (fix leak inclus)
+cd ../train
+python prepare_doctr_dataset.py
+python finetune_doctr.py --epochs 60
+```
+
+Voir `docs/TRAINING.md` pour le détail de chaque étape et les pièges déjà
+rencontrés (ne pas modifier le dataset pendant l'entraînement, toujours
+repartir d'un dossier de sortie nettoyé).
+
+### Étape 4 — versioning du modèle actif
+
+Chaque nouveau modèle entraîné est écrit dans son propre dossier
+(`train/models/v<N>/`), jamais en écrasant le précédent — l'incident de ce
+projet où un entraînement de test a écrasé le meilleur checkpoint (55.3%)
+avec un résultat plus faible (44.7%) a motivé ce choix. Pour déployer une
+nouvelle version :
+
+1. Copier le `.pt` retenu vers `yely_ai_module/models/crnn_fuel_pump_best.pt`
+   (écrase le fichier servi par l'API, mais l'ancien reste dans `train/models/v<N>/`
+   si un retour arrière est nécessaire).
+2. Mettre à jour `MODEL_VERSION` (variable d'environnement du déploiement,
+   ex. Hugging Face Spaces → Settings → Variables) pour que les nouvelles
+   entrées de `logs/api.log` soient distinguables des précédentes dans
+   `monitoring/metrics.py`.
+3. Redémarrer le Space (ou le processus `uvicorn`) — le modèle est chargé une
+   seule fois au démarrage (singleton `_get_model()`), un nouveau fichier sur
+   disque n'est pas repris à chaud.
+
+## 3. Stockage persistant (obligatoire pour que tout ceci survive en production)
+
+Par défaut, un Hugging Face Space Docker écrit sur le disque **éphémère**
+du conteneur : `photos/`, `logs/api.log` et `monitoring/feedback.jsonl`
+disparaissent à chaque redémarrage/veille du Space (les Spaces gratuits se
+mettent en veille après une période d'inactivité). Pour une démo tenue en
+une seule session continue ce n'est pas gênant, mais **la boucle de
+feedback et l'historique `/metrics`/`/failures` n'ont de sens que si ces
+fichiers survivent** �� c'est là qu'intervient le stockage persistant.
+
+### Ce que fait le code
+
+`app/main.py`, `monitoring/metrics.py` et `monitoring/feedback.py` lisent
+tous la même variable d'environnement `YELY_DATA_DIR` : si elle est
+définie, `photos/`, `logs/` et `monitoring/feedback.jsonl` sont placés sous
+ce répertoire au lieu du dossier de l'application. Par défaut (variable
+absente), tout reste sous `yely_ai_module/` comme avant — donc rien ne
+casse en local ou sur un Space sans stockage persistant.
+
+### Activer le stockage persistant sur le Space
+
+1. Ouvre ton Space → **Settings** → section **Persistent storage**. C'est
+   une option payante (facturée au mois, plusieurs tailles proposées) —
+   vérifie le tarif affiché à cet instant sur la page, il peut avoir changé.
+   Pour une démo, la plus petite taille suffit largement (quelques photos +
+   logs texte).
+2. Active-la et choisis une taille. Hugging Face monte un disque dans le
+   conteneur — le chemin de montage est indiqué dans l'interface au moment
+   de l'activation (généralement `/data`).
+3. Toujours dans **Settings** → **Variables and secrets** → **New variable**
+   (pas *secret*, cette valeur n'a rien de sensible) :
+   - Nom : `YELY_DATA_DIR`
+   - Valeur : le chemin de montage indiqué à l'étape 2 (ex. `/data`)
+4. Redémarre le Space (**Settings** → **Restart this Space**, ou un simple
+   push suffit à le redéployer) pour que la variable soit prise en compte.
+5. **Vérifier que ça persiste vraiment** : envoie une image via `/analyze`
+   (ou le formulaire `web/index.html`), consulte `GET /metrics`
+   (`total_requests` ≥ 1), puis redémarre le Space depuis Settings et
+   rappelle `GET /metrics` — si `total_requests` n'est pas retombé à 0,
+   c'est branché correctement.
+
+### Si tu ne veux pas payer pour la démo
+
+Pas bloquant : sans stockage persistant, tout fonctionne normalement tant
+que le Space ne redémarre pas pendant la session de démonstration
+(soutenance en continu). C'est seulement l'historique qui ne survit pas
+d'une session à l'autre — acceptable pour une démo ponctuelle, à mentionner
+comme limitation connue si le sujet est posé (`docs/LIMITATIONS.md`).
+
+## 4. Ce qui est réellement implémenté vs conçu
+
+Fonctionnel et testé (`tests/test_monitoring.py`) :
+`POST /feedback`, `GET /metrics`, `GET /failures`, `GET /photos/{photo_reference}`,
+`monitoring/metrics.py`,
+`monitoring/feedback.py::record_feedback` et `::convert_feedback_to_annotations`.
+Le mode `annotate.py --review-pending` n'a pas de test automatisé (outil
+interactif OpenCV, nécessite un affichage) — vérifié manuellement.
+
+Conçu mais volontairement manuel (pas automatisé, par choix — voir §2 ci-dessus) :
+la relecture des entrées `pending_review` et le déclenchement du
+ré-entraînement lui-même, qui restent des actions humaines délibérées plutôt
+qu'un cron — le volume de données actuel (quelques centaines d'images) ne
+justifie pas encore une automatisation complète, et une relecture humaine
+reste la meilleure garde-fou contre la dégradation du dataset tant que le
+découpage en lignes n'est pas plus robuste.

docs/WORKFLOW.md

@@ -15,25 +15,27 @@ yely_ai_module/
 │   ├── test_postprocess.py     # ✅ fait
 │   ├── test_rules.py           # ✅ fait
 │   ├── test_api.py              # ✅ fait (mocké)
-│   └── test_integration.py      # à faire : vrai modèle, vraies images
+│   ├── test_monitoring.py       # ✅ fait (feedback + métriques + endpoints)
+│   └── test_integration.py      # à lancer : vrai modèle, vraies images
 ├── tools/
 │   └── check_seen_image.py      # ✅ fait
-├── monitoring/                  # à créer — §2
-│   ├── logger.py                 # log structuré prédiction + vérité terrain
-│   ├── metrics.py                 # calcul accuracy glissante, drift
-│   └── feedback.py                 # collecte des corrections pompiste
-├── docs/                         # à créer — §4
+├── monitoring/                  # ✅ fait — §2
+│   ├── metrics.py                 # ✅ agrégation logs/api.log (succès, confiance, blocages)
+│   └── feedback.py                 # ✅ collecte + conversion des corrections pompiste
+├── docs/                         # ✅ fait — §4
 │   ├── WORKFLOW.md                # ce fichier
 │   ├── LIMITATIONS.md             # ✅ fait
-│   ├── ARCHITECTURE.md
-│   ├── PREPROCESSING.md
-│   ├── RECOGNIZER.md
-│   ├── POSTPROCESS_RULES.md
-│   ├── API.md
-│   └── MONITORING.md
-├── web/                           # à créer — §5, interface de démo
-│   ├── index.html / app Next.js
-│   └── vercel.json
+│   ├── ARCHITECTURE.md            # ✅ fait
+│   ├── PREPROCESSING.md           # ✅ fait
+│   ├── RECOGNIZER.md              # ✅ fait
+│   ├── POSTPROCESS_RULES.md       # ✅ fait
+│   ├── API.md                     # ✅ fait
+│   └── MONITORING.md              # ✅ fait
+├── web/                           # ✅ fait — §5, interface de démo
+│   ├── index.html                 # démo /analyze
+│   ├── stats.html                 # tableau de bord /metrics + /failures (soutenance)
+│   ├── feedback.html              # correction d'une lecture (préremplie depuis stats.html)
+│   └── config.js
 └── requirements.txt
 ```
 
@@ -164,6 +166,12 @@ d'exécution comme Vercel, `Dockerfile` déjà préparé (`yely_ai_module/Docker
    l'URL que le frontend Vercel appellera pour `/analyze`.
 5. Ajouter `CORSMiddleware` dans `app/main.py` pour autoriser le domaine
    Vercel du frontend (sinon le navigateur bloquera les réponses).
+6. (Optionnel, payant) Activer le **stockage persistant** du Space et
+   définir la variable d'environnement `YELY_DATA_DIR` sur son point de
+   montage — sans quoi `photos/`, `logs/` et `monitoring/feedback.jsonl`
+   sont perdus à chaque redémarrage/veille du Space. Voir
+   `docs/MONITORING.md` §3 pour la marche à suivre complète et l'impact si
+   on s'en passe pour la démo.
 
 ## 7. Ordre d'exécution recommandé (vu le délai serré)
 

monitoring/feedback.py

@@ -0,0 +1,165 @@
+"""Boucle de feedback : collecte des corrections pompiste et conversion en
+données d'entraînement (voir docs/MONITORING.md).
+
+Principe : chaque photo traitée par `/analyze` est déjà sauvegardée dans
+`photos/<transaction_id>.jpg` (voir `app/main.py`). Une correction envoyée
+via `POST /feedback` référence cette photo par son `photo_reference` et
+fournit les valeurs réellement correctes. `convert_feedback_to_annotations`
+transforme ensuite ces corrections en entrées au même format que
+`annotator/annotations/annotations.json`, réutilisables par le pipeline
+d'entraînement existant (`split_lines.py` -> `prepare_doctr_dataset.py` ->
+`finetune_doctr.py`).
+"""
+import json
+import os
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from app.preprocessing import detect_screen_region
+
+MODULE_ROOT = Path(__file__).resolve().parent.parent
+
+# Même variable YELY_DATA_DIR que `app/main.py`/`monitoring/metrics.py` : si
+# un stockage persistant est monté (ex. /data sur un Hugging Face Space),
+# feedback.jsonl et les crops doivent survivre aux redémarrages du Space
+# comme les photos et les logs, sinon la boucle de feedback perd tout à
+# chaque redéploiement. `DEFAULT_ANNOTATIONS_PATH` reste dans le dépôt
+# (`annotator/`) volontairement : la conversion en données d'entraînement
+# est un script lancé en local par un développeur, pas sur le Space (voir
+# docs/MONITORING.md — l'annotateur n'est de toute façon pas poussé sur HF).
+DATA_DIR = Path(os.environ.get("YELY_DATA_DIR", str(MODULE_ROOT)))
+DEFAULT_FEEDBACK_PATH = DATA_DIR / "monitoring" / "feedback.jsonl"
+DEFAULT_PHOTOS_DIR = DATA_DIR / "photos"
+DEFAULT_ANNOTATIONS_PATH = MODULE_ROOT.parent / "annotator" / "annotations" / "annotations.json"
+DEFAULT_CROPS_DIR = DATA_DIR / "monitoring" / "feedback_crops"
+
+CORRECTABLE_FIELDS = ("prix", "volume", "prix_litre")
+
+
+def record_feedback(photo_reference: str,
+                    corrected_fields: Dict[str, Any],
+                    corrected_by: Optional[str] = None,
+                    feedback_path: Optional[Path] = None) -> Dict[str, Any]:
+    """Ajoute une correction pompiste au journal `feedback.jsonl` (append-only).
+
+    `corrected_fields` : sous-ensemble de {"prix", "volume", "prix_litre"} ->
+    valeur correcte (les champs non fournis restent inconnus, pas déduits).
+    """
+    unknown = set(corrected_fields) - set(CORRECTABLE_FIELDS)
+    if unknown:
+        raise ValueError(f"Champs de correction inconnus : {sorted(unknown)}")
+    if not corrected_fields:
+        raise ValueError("Aucune correction fournie.")
+
+    feedback_path = feedback_path or DEFAULT_FEEDBACK_PATH
+    feedback_path.parent.mkdir(parents=True, exist_ok=True)
+
+    entry = {
+        "feedback_id": str(uuid.uuid4()),
+        "photo_reference": photo_reference,
+        "corrected_fields": corrected_fields,
+        "corrected_by": corrected_by,
+        "created_at": datetime.now(timezone.utc).isoformat(),
+        "converted": False,
+    }
+    with open(feedback_path, "a", encoding="utf-8") as f:
+        f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+    return entry
+
+
+def load_feedback_entries(feedback_path: Optional[Path] = None) -> List[Dict[str, Any]]:
+    feedback_path = feedback_path or DEFAULT_FEEDBACK_PATH
+    if not feedback_path.exists():
+        return []
+    entries = []
+    with open(feedback_path, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                entries.append(json.loads(line))
+            except json.JSONDecodeError:
+                continue
+    return entries
+
+
+def convert_feedback_to_annotations(photos_dir: Optional[Path] = None,
+                                    feedback_path: Optional[Path] = None,
+                                    annotations_path: Optional[Path] = None,
+                                    crops_dir: Optional[Path] = None) -> int:
+    """Convertit les corrections non encore traitées en entrées `annotations.json`.
+
+    La détection d'écran (`detect_screen_region`) est automatique, donc pas
+    fiable à 100% (voir docs/LIMITATIONS.md, point 2) : les entrées générées
+    sont marquées `status="pending_review"` plutôt que `"annotated"`, pour
+    qu'une relecture humaine (même rapide, via le visualiseur de l'annotateur)
+    précède leur utilisation dans un ré-entraînement.
+
+    Retourne le nombre d'entrées converties.
+    """
+    import cv2
+
+    photos_dir = photos_dir or DEFAULT_PHOTOS_DIR
+    feedback_path = feedback_path or DEFAULT_FEEDBACK_PATH
+    annotations_path = annotations_path or DEFAULT_ANNOTATIONS_PATH
+    crops_dir = crops_dir or DEFAULT_CROPS_DIR
+
+    entries = load_feedback_entries(feedback_path)
+    pending = [e for e in entries if not e.get("converted")]
+    if not pending:
+        return 0
+
+    annotations_path.parent.mkdir(parents=True, exist_ok=True)
+    if annotations_path.exists():
+        with open(annotations_path, "r", encoding="utf-8") as f:
+            annotations = json.load(f)
+    else:
+        annotations = {}
+
+    crops_dir.mkdir(parents=True, exist_ok=True)
+
+    converted_count = 0
+    for entry in pending:
+        photo_path = photos_dir / entry["photo_reference"]
+        if not photo_path.exists():
+            continue
+
+        img = cv2.imread(str(photo_path))
+        if img is None:
+            continue
+        crop, bbox = detect_screen_region(img)
+        crop_name = f"feedback_{entry['feedback_id']}_lcd.jpg"
+        cv2.imwrite(str(crops_dir / crop_name), crop)
+
+        fields = {name: "" for name in CORRECTABLE_FIELDS}
+        fields.update({"unite_prix": "", "unite_vol": "", "notes": "issu du feedback pompiste"})
+        for name, value in entry["corrected_fields"].items():
+            fields[name] = str(value)
+
+        annotations[entry["photo_reference"]] = {
+            "status": "pending_review",
+            "annotated_at": entry["created_at"],
+            "image_path": str(photo_path),
+            "lcd_bbox": list(bbox),
+            "lcd_crop": str(crops_dir / crop_name),
+            "fields": fields,
+        }
+        entry["converted"] = True
+        converted_count += 1
+
+    with open(annotations_path, "w", encoding="utf-8") as f:
+        json.dump(annotations, f, ensure_ascii=False, indent=2)
+
+    with open(feedback_path, "w", encoding="utf-8") as f:
+        for entry in entries:
+            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+
+    return converted_count
+
+
+if __name__ == "__main__":
+    n = convert_feedback_to_annotations()
+    print(f"{n} correction(s) converties en entrées à relire dans annotations.json")

monitoring/metrics.py

@@ -0,0 +1,134 @@
+"""Suivi des performances en production : parse `logs/api.log` (une ligne
+JSON par appel à `/analyze`, écrite par `app/main.py`) et calcule des
+métriques agrégées (taux de succès, confiance moyenne, causes de blocage).
+
+Ne dépend d'aucun état en mémoire : peut tourner en script séparé pendant
+que l'API tourne (lecture seule du fichier de log), ou être appelé depuis
+`GET /metrics` pour un aperçu rapide en démo.
+"""
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+from collections import Counter
+
+MODULE_ROOT = Path(__file__).resolve().parent.parent
+
+# YELY_DATA_DIR pointe vers un répertoire persistant (ex. le stockage
+# persistant d'un Hugging Face Space, monté sur /data) quand il est défini —
+# sinon on retombe sur le dossier du module (éphémère en conteneur Docker
+# sans stockage persistant). Doit rester cohérent avec DATA_DIR dans
+# `app/main.py` et `monitoring/feedback.py`, sinon /metrics et /failures
+# liraient un fichier différent de celui où l'API écrit réellement.
+DATA_DIR = Path(os.environ.get("YELY_DATA_DIR", str(MODULE_ROOT)))
+DEFAULT_LOG_PATH = DATA_DIR / "logs" / "api.log"
+
+
+def parse_log_entries(log_path: Optional[Path] = None) -> List[Dict[str, Any]]:
+    """Extrait les entrées `{"request": ..., "response": ...}` de `api.log`.
+
+    Le format de ligne est `"<timestamp> | <niveau> | <message>"` (voir le
+    `Formatter` dans `app/main.py`) ; seules les lignes INFO dont le message
+    est le JSON structuré loggé après chaque `/analyze` sont retenues — les
+    autres lignes (ex. "Modèle CRNN chargé sur cpu.") sont ignorées.
+    """
+    log_path = log_path or DEFAULT_LOG_PATH
+    if not log_path.exists():
+        return []
+
+    entries = []
+    with open(log_path, "r", encoding="utf-8") as f:
+        for line in f:
+            parts = line.rstrip("\n").split(" | ", 2)
+            if len(parts) != 3:
+                continue
+            _, _, message = parts
+            try:
+                data = json.loads(message)
+            except json.JSONDecodeError:
+                continue
+            if isinstance(data, dict) and "response" in data:
+                entries.append(data)
+    return entries
+
+
+def compute_metrics(log_path: Optional[Path] = None) -> Dict[str, Any]:
+    """Calcule les métriques agrégées sur l'ensemble des entrées loggées.
+
+    Retourne `total_requests=0` et des métriques à `None` si aucun appel n'a
+    encore été journalisé (démo pas encore lancée), plutôt qu'une erreur.
+    """
+    entries = parse_log_entries(log_path)
+    total = len(entries)
+    if total == 0:
+        return {
+            "total_requests": 0,
+            "success_rate": None,
+            "avg_confidence_score": None,
+            "blocking_causes": {},
+            "image_quality_distribution": {},
+        }
+
+    responses = [e["response"] for e in entries]
+    success_count = sum(1 for r in responses if r.get("success"))
+
+    confidences = [r["confidence_score"] for r in responses if r.get("confidence_score") is not None]
+    avg_confidence = sum(confidences) / len(confidences) if confidences else None
+
+    blocking_causes = Counter(r["message"] for r in responses if not r.get("success"))
+    quality_distribution = Counter(r.get("image_quality") for r in responses)
+
+    return {
+        "total_requests": total,
+        "success_rate": round(success_count / total, 3),
+        "avg_confidence_score": round(avg_confidence, 3) if avg_confidence is not None else None,
+        "blocking_causes": dict(blocking_causes.most_common()),
+        "image_quality_distribution": dict(quality_distribution.most_common()),
+    }
+
+
+def list_failed_requests(log_path: Optional[Path] = None, limit: int = 20) -> List[Dict[str, Any]]:
+    """Retourne les `limit` dernières réponses bloquées (`success=false`),
+    les plus récentes en premier — matière première de la revue manuelle
+    (voir `web/stats.html` -> `web/feedback.html` et docs/MONITORING.md).
+
+    Ne renvoie que les champs utiles à l'affichage/la correction, pas
+    l'entrée de log complète (pas de `request.filename`, `model_version`...).
+    """
+    entries = parse_log_entries(log_path)
+    failed = [e["response"] for e in entries if not e["response"].get("success")]
+    failed.reverse()
+    out = []
+    for r in failed[:limit]:
+        out.append({
+            "photo_reference": r.get("photo_reference"),
+            "message": r.get("message"),
+            "image_quality": r.get("image_quality"),
+            "detected_liters": r.get("detected_liters"),
+            "detected_amount": r.get("detected_amount"),
+            "fuel_price": r.get("fuel_price"),
+            "confidence_score": r.get("confidence_score"),
+            "transaction_datetime": r.get("transaction_datetime"),
+        })
+    return out
+
+
+def _print_report(metrics: Dict[str, Any]) -> None:
+    print("=== Suivi des performances YELY (logs/api.log) ===")
+    print(f"Requêtes totales      : {metrics['total_requests']}")
+    if metrics["total_requests"] == 0:
+        print("Aucun appel journalisé pour l'instant.")
+        return
+    print(f"Taux de succès        : {metrics['success_rate'] * 100:.1f}%")
+    conf = metrics["avg_confidence_score"]
+    print(f"Confiance moyenne      : {conf if conf is None else round(conf * 100, 1)}%")
+    print("Répartition qualité image :")
+    for label, count in metrics["image_quality_distribution"].items():
+        print(f"  - {label}: {count}")
+    print("Causes de blocage (hors succès) :")
+    for message, count in metrics["blocking_causes"].items():
+        print(f"  - {message}: {count}")
+
+
+if __name__ == "__main__":
+    _print_report(compute_metrics())

tests/test_monitoring.py

@@ -0,0 +1,258 @@
+import json
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+import numpy as np
+import cv2
+from fastapi.testclient import TestClient
+
+from app import main
+from monitoring import feedback as feedback_mod
+from monitoring import metrics as metrics_mod
+
+
+class TestFeedbackRecording(unittest.TestCase):
+    def setUp(self):
+        self._tmpdir = tempfile.TemporaryDirectory()
+        self.tmp_path = Path(self._tmpdir.name)
+        self.feedback_path = self.tmp_path / "feedback.jsonl"
+
+    def tearDown(self):
+        self._tmpdir.cleanup()
+
+    def test_record_feedback_appends_entry(self):
+        entry = feedback_mod.record_feedback(
+            "abc.jpg", {"prix": 10000, "volume": 14.28},
+            corrected_by="pompiste-7", feedback_path=self.feedback_path,
+        )
+        self.assertEqual(entry["photo_reference"], "abc.jpg")
+        self.assertFalse(entry["converted"])
+
+        entries = feedback_mod.load_feedback_entries(self.feedback_path)
+        self.assertEqual(len(entries), 1)
+        self.assertEqual(entries[0]["corrected_fields"]["prix"], 10000)
+
+    def test_record_feedback_rejects_unknown_field(self):
+        with self.assertRaises(ValueError):
+            feedback_mod.record_feedback(
+                "abc.jpg", {"montant_total": 10000}, feedback_path=self.feedback_path,
+            )
+
+    def test_record_feedback_rejects_empty_corrections(self):
+        with self.assertRaises(ValueError):
+            feedback_mod.record_feedback("abc.jpg", {}, feedback_path=self.feedback_path)
+
+    def test_load_feedback_entries_missing_file_returns_empty(self):
+        entries = feedback_mod.load_feedback_entries(self.tmp_path / "nope.jsonl")
+        self.assertEqual(entries, [])
+
+
+class TestFeedbackConversion(unittest.TestCase):
+    def setUp(self):
+        self._tmpdir = tempfile.TemporaryDirectory()
+        self.tmp_path = Path(self._tmpdir.name)
+        self.photos_dir = self.tmp_path / "photos"
+        self.photos_dir.mkdir()
+        self.feedback_path = self.tmp_path / "feedback.jsonl"
+        self.annotations_path = self.tmp_path / "annotations.json"
+        self.crops_dir = self.tmp_path / "crops"
+
+        img = np.full((200, 400, 3), 30, dtype=np.uint8)
+        cv2.imwrite(str(self.photos_dir / "photo1.jpg"), img)
+
+    def tearDown(self):
+        self._tmpdir.cleanup()
+
+    def test_convert_creates_pending_review_annotation(self):
+        feedback_mod.record_feedback(
+            "photo1.jpg", {"prix": 10000, "volume": 14.28, "prix_litre": 700},
+            corrected_by="pompiste-7", feedback_path=self.feedback_path,
+        )
+
+        count = feedback_mod.convert_feedback_to_annotations(
+            photos_dir=self.photos_dir, feedback_path=self.feedback_path,
+            annotations_path=self.annotations_path, crops_dir=self.crops_dir,
+        )
+        self.assertEqual(count, 1)
+
+        with open(self.annotations_path, "r", encoding="utf-8") as f:
+            annotations = json.load(f)
+        self.assertIn("photo1.jpg", annotations)
+        entry = annotations["photo1.jpg"]
+        self.assertEqual(entry["status"], "pending_review")
+        self.assertEqual(entry["fields"]["prix"], "10000")
+        self.assertEqual(entry["fields"]["volume"], "14.28")
+
+        entries = feedback_mod.load_feedback_entries(self.feedback_path)
+        self.assertTrue(entries[0]["converted"])
+
+    def test_convert_is_idempotent_for_already_converted_entries(self):
+        feedback_mod.record_feedback(
+            "photo1.jpg", {"prix": 10000}, feedback_path=self.feedback_path,
+        )
+        feedback_mod.convert_feedback_to_annotations(
+            photos_dir=self.photos_dir, feedback_path=self.feedback_path,
+            annotations_path=self.annotations_path, crops_dir=self.crops_dir,
+        )
+        second_count = feedback_mod.convert_feedback_to_annotations(
+            photos_dir=self.photos_dir, feedback_path=self.feedback_path,
+            annotations_path=self.annotations_path, crops_dir=self.crops_dir,
+        )
+        self.assertEqual(second_count, 0)
+
+    def test_convert_skips_missing_photo(self):
+        feedback_mod.record_feedback(
+            "ghost.jpg", {"prix": 10000}, feedback_path=self.feedback_path,
+        )
+        count = feedback_mod.convert_feedback_to_annotations(
+            photos_dir=self.photos_dir, feedback_path=self.feedback_path,
+            annotations_path=self.annotations_path, crops_dir=self.crops_dir,
+        )
+        self.assertEqual(count, 0)
+
+
+class TestMetrics(unittest.TestCase):
+    def setUp(self):
+        self._tmpdir = tempfile.TemporaryDirectory()
+        self.log_path = Path(self._tmpdir.name) / "api.log"
+
+    def tearDown(self):
+        self._tmpdir.cleanup()
+
+    def _write_log_line(self, payload):
+        with open(self.log_path, "a", encoding="utf-8") as f:
+            f.write(f"2026-07-07 10:00:00,000 | INFO | {json.dumps(payload, ensure_ascii=False)}\n")
+
+    def test_compute_metrics_on_missing_log_returns_zero(self):
+        m = metrics_mod.compute_metrics(self.log_path)
+        self.assertEqual(m["total_requests"], 0)
+        self.assertIsNone(m["success_rate"])
+
+    def test_compute_metrics_aggregates_success_and_blocking(self):
+        self._write_log_line({
+            "model_version": "v2",
+            "response": {"success": True, "confidence_score": 0.9, "image_quality": "valid", "message": "ok"},
+        })
+        self._write_log_line({
+            "model_version": "v2",
+            "response": {"success": False, "confidence_score": 0.2, "image_quality": "blurry", "message": "Photo floue, veuillez reprendre la photo."},
+        })
+        with open(self.log_path, "a", encoding="utf-8") as f:
+            f.write("2026-07-07 10:00:01,000 | INFO | Modèle CRNN chargé sur cpu.\n")
+
+        m = metrics_mod.compute_metrics(self.log_path)
+        self.assertEqual(m["total_requests"], 2)
+        self.assertEqual(m["success_rate"], 0.5)
+        self.assertAlmostEqual(m["avg_confidence_score"], 0.55)
+        self.assertEqual(m["blocking_causes"]["Photo floue, veuillez reprendre la photo."], 1)
+        self.assertEqual(m["image_quality_distribution"]["valid"], 1)
+
+    def test_list_failed_requests_returns_only_failures_most_recent_first(self):
+        self._write_log_line({
+            "response": {"success": True, "photo_reference": "ok.jpg", "message": "ok"},
+        })
+        self._write_log_line({
+            "response": {"success": False, "photo_reference": "first-fail.jpg",
+                        "message": "Photo floue, veuillez reprendre la photo.",
+                        "image_quality": "blurry", "confidence_score": 0.1},
+        })
+        self._write_log_line({
+            "response": {"success": False, "photo_reference": "second-fail.jpg",
+                        "message": "Incohérence détectée entre montant, litres et prix.",
+                        "image_quality": "valid", "confidence_score": 0.4},
+        })
+
+        failures = metrics_mod.list_failed_requests(self.log_path)
+        self.assertEqual(len(failures), 2)
+        self.assertEqual(failures[0]["photo_reference"], "second-fail.jpg")
+        self.assertEqual(failures[1]["photo_reference"], "first-fail.jpg")
+        self.assertNotIn("filename", failures[0])
+
+    def test_list_failed_requests_respects_limit(self):
+        for i in range(5):
+            self._write_log_line({
+                "response": {"success": False, "photo_reference": f"fail{i}.jpg", "message": "x"},
+            })
+        failures = metrics_mod.list_failed_requests(self.log_path, limit=2)
+        self.assertEqual(len(failures), 2)
+
+
+class TestFeedbackAndMetricsEndpoints(unittest.TestCase):
+    def setUp(self):
+        self.client = TestClient(main.app)
+        self._tmpdir = tempfile.TemporaryDirectory()
+        self.fake_photos_dir = Path(self._tmpdir.name)
+        (self.fake_photos_dir / "photo.jpg").write_bytes(b"fake")
+        self._patch_photos_dir = patch.object(main, "PHOTOS_DIR", self.fake_photos_dir)
+        self._patch_photos_dir.start()
+
+    def tearDown(self):
+        self._patch_photos_dir.stop()
+        self._tmpdir.cleanup()
+
+    def test_feedback_rejects_unknown_photo_reference(self):
+        resp = self.client.post(
+            "/feedback",
+            data={"photo_reference": "does-not-exist.jpg", "corrected_prix": "10000"},
+        )
+        self.assertEqual(resp.status_code, 404)
+
+    def test_feedback_rejects_no_corrections(self):
+        resp = self.client.post("/feedback", data={"photo_reference": "photo.jpg"})
+        self.assertEqual(resp.status_code, 400)
+
+    def test_feedback_success_records_entry(self):
+        fake_entry = {"feedback_id": "fake-id"}
+        with patch.object(main, "record_feedback", return_value=fake_entry) as mock_record:
+            resp = self.client.post(
+                "/feedback",
+                data={"photo_reference": "photo.jpg", "corrected_prix": "10000", "corrected_by": "pompiste-7"},
+            )
+        self.assertEqual(resp.status_code, 200)
+        body = resp.json()
+        self.assertTrue(body["success"])
+        self.assertEqual(body["feedback_id"], "fake-id")
+        mock_record.assert_called_once()
+        args, kwargs = mock_record.call_args
+        self.assertEqual(args[0], "photo.jpg")
+        self.assertEqual(args[1], {"prix": 10000.0})
+
+    def test_metrics_endpoint_returns_aggregate(self):
+        fake_metrics = {"total_requests": 0, "success_rate": None,
+                        "avg_confidence_score": None, "blocking_causes": {},
+                        "image_quality_distribution": {}}
+        with patch.object(main, "compute_metrics", return_value=fake_metrics):
+            resp = self.client.get("/metrics")
+        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(resp.json(), fake_metrics)
+
+    def test_failures_endpoint_returns_list(self):
+        fake_failures = [{"photo_reference": "photo.jpg", "message": "Photo floue."}]
+        with patch.object(main, "list_failed_requests", return_value=fake_failures):
+            resp = self.client.get("/failures")
+        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(resp.json(), fake_failures)
+
+    def test_get_photo_returns_file(self):
+        resp = self.client.get("/photos/photo.jpg")
+        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(resp.content, b"fake")
+
+    def test_get_photo_unknown_reference_returns_404(self):
+        resp = self.client.get("/photos/does-not-exist.jpg")
+        self.assertEqual(resp.status_code, 404)
+
+    def test_get_photo_rejects_path_traversal(self):
+        outside_file = Path(self._tmpdir.name).parent / "secret.txt"
+        outside_file.write_text("should not be servable")
+        try:
+            resp = self.client.get("/photos/..%2Fsecret.txt")
+            self.assertEqual(resp.status_code, 404)
+        finally:
+            outside_file.unlink(missing_ok=True)
+
+
+if __name__ == "__main__":
+    unittest.main()

web/feedback.html

@@ -0,0 +1,228 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>YELY | Corriger une lecture</title>
+  <style>
+    :root {
+      --bg: #0f172a;
+      --panel: #1e293b;
+      --panel-2: #273449;
+      --border: #334155;
+      --text: #e2e8f0;
+      --muted: #94a3b8;
+      --accent: #f59e0b;
+      --ok-bg: #052e1f;
+      --ok-border: #10b981;
+      --ok-text: #6ee7b7;
+      --ko-bg: #3b0d0d;
+      --ko-border: #ef4444;
+      --ko-text: #fca5a5;
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      min-height: 100vh;
+      font-family: -apple-system, "Segoe UI", Roboto, Arial, sans-serif;
+      background: var(--bg);
+      color: var(--text);
+      display: flex;
+      justify-content: center;
+      padding: 2rem 1rem;
+    }
+    .app { width: 100%; max-width: 480px; }
+    .brand { display: flex; align-items: center; justify-content: space-between; gap: 0.6rem; margin-bottom: 0.25rem; }
+    .brand-left { display: flex; align-items: center; gap: 0.6rem; }
+    .brand .dot { width: 10px; height: 10px; border-radius: 50%; background: var(--accent); }
+    .brand h1 { font-size: 1.2rem; margin: 0; }
+    .brand a { color: var(--muted); font-size: 0.85rem; text-decoration: none; border: 1px solid var(--border); padding: 0.4rem 0.7rem; border-radius: 8px; }
+    .brand a:hover { border-color: var(--accent); color: var(--text); }
+    .subtitle { color: var(--muted); font-size: 0.9rem; margin: 0 0 1.5rem; }
+
+    .card { background: var(--panel); border: 1px solid var(--border); border-radius: 14px; padding: 1.25rem; margin-bottom: 1rem; }
+
+    label { display: block; font-size: 0.85rem; color: var(--muted); margin: 0.9rem 0 0.3rem; }
+    label:first-child { margin-top: 0; }
+    input {
+      width: 100%;
+      padding: 0.65rem 0.75rem;
+      border-radius: 8px;
+      border: 1px solid var(--border);
+      background: var(--panel-2);
+      color: var(--text);
+      font-size: 1rem;
+    }
+
+    #photoPreview {
+      display: none;
+      width: 100%;
+      max-height: 280px;
+      object-fit: contain;
+      border-radius: 10px;
+      margin-top: 0.75rem;
+      border: 1px solid var(--border);
+      background: #000;
+    }
+    #photoMissing { display: none; color: var(--muted); font-size: 0.85rem; margin-top: 0.6rem; }
+
+    button {
+      width: 100%;
+      margin-top: 1.25rem;
+      padding: 0.85rem;
+      border: none;
+      border-radius: 10px;
+      background: var(--accent);
+      color: #1a1200;
+      font-size: 1.05rem;
+      font-weight: 700;
+      cursor: pointer;
+    }
+    button:disabled { background: #4b5563; color: #9ca3af; cursor: not-allowed; }
+
+    .status { font-size: 0.85rem; color: var(--muted); text-align: center; margin-top: 0.75rem; min-height: 1.2em; }
+
+    .banner { display: none; border-radius: 12px; padding: 1rem 1.1rem; font-weight: 700; font-size: 1.05rem; margin-bottom: 1rem; border: 1px solid; }
+    .banner.ok { display: block; background: var(--ok-bg); border-color: var(--ok-border); color: var(--ok-text); }
+    .banner.ko { display: block; background: var(--ko-bg); border-color: var(--ko-border); color: var(--ko-text); }
+
+    .hint { color: var(--muted); font-size: 0.78rem; margin-top: 0.4rem; }
+  </style>
+</head>
+<body>
+  <div class="app">
+    <div class="brand">
+      <div class="brand-left"><span class="dot"></span><h1>YELY | Corriger une lecture</h1></div>
+      <a href="stats.html">← Tableau de bord</a>
+    </div>
+    <p class="subtitle">Renseigne les valeurs réellement affichées sur l'écran, sert à améliorer le modèle (voir docs/MONITORING.md).</p>
+
+    <div id="banner" class="banner"></div>
+
+    <form id="form" class="card">
+      <label>Référence de la photo</label>
+      <input type="text" id="photoReference" placeholder="ex. 3f2a1c9e-....jpg" required />
+      <img id="photoPreview" alt="Photo de la transaction" />
+      <div id="photoMissing">Photo introuvable pour cette référence (vérifie l'URL de l'API ou la référence).</div>
+
+      <label>Montant réellement affiché (FCFA)</label>
+      <input type="number" id="correctedPrix" step="0.01" placeholder="ex. 10000" />
+
+      <label>Volume réellement affiché (litres)</label>
+      <input type="number" id="correctedVolume" step="0.01" placeholder="ex. 14.28" />
+
+      <label>Prix du litre réellement affiché (FCFA)</label>
+      <input type="number" id="correctedPrixLitre" step="0.01" placeholder="ex. 700" />
+
+      <label>Corrigé par (optionnel)</label>
+      <input type="text" id="correctedBy" placeholder="pompiste-7" />
+
+      <details style="margin-top: 0.9rem;">
+        <summary style="cursor:pointer; color: var(--muted); font-size: 0.8rem;">Configuration (URL de l'API)</summary>
+        <label>URL du service (base, sans /analyze)</label>
+        <input type="text" id="apiUrl" />
+      </details>
+
+      <button type="submit" id="submitBtn">Envoyer la correction</button>
+      <div class="status" id="status"></div>
+      <div class="hint">Au moins une valeur est requise ; laisse vide ce qui n'est pas lisible.</div>
+    </form>
+  </div>
+
+  <script src="config.js"></script>
+  <script>
+    const form = document.getElementById('form');
+    const submitBtn = document.getElementById('submitBtn');
+    const statusEl = document.getElementById('status');
+    const banner = document.getElementById('banner');
+    const photoRefInput = document.getElementById('photoReference');
+    const photoPreview = document.getElementById('photoPreview');
+    const photoMissing = document.getElementById('photoMissing');
+    const apiUrlInput = document.getElementById('apiUrl');
+
+    function defaultBaseUrl() {
+      const stored = localStorage.getItem('yely_stats_base_url')
+        || localStorage.getItem('yely_api_url')
+        || window.YELY_API_URL || '';
+      return stored.replace(/\/analyze\/?$/, '').replace(/\/+$/, '');
+    }
+    apiUrlInput.value = defaultBaseUrl();
+
+    const params = new URLSearchParams(window.location.search);
+    const prefillRef = params.get('ref') || params.get('photo_reference');
+    if (prefillRef) photoRefInput.value = prefillRef;
+
+    function loadPhotoPreview() {
+      const base = apiUrlInput.value.trim().replace(/\/+$/, '');
+      const ref = photoRefInput.value.trim();
+      photoPreview.style.display = 'none';
+      photoMissing.style.display = 'none';
+      if (!base || !ref) return;
+
+      const url = base + '/photos/' + encodeURIComponent(ref);
+      photoPreview.onload = () => { photoPreview.style.display = 'block'; };
+      photoPreview.onerror = () => { photoMissing.style.display = 'block'; };
+      photoPreview.src = url + '?t=' + Date.now();
+    }
+
+    photoRefInput.addEventListener('change', loadPhotoPreview);
+    apiUrlInput.addEventListener('change', loadPhotoPreview);
+    loadPhotoPreview();
+
+    form.addEventListener('submit', async (event) => {
+      event.preventDefault();
+
+      const base = apiUrlInput.value.trim().replace(/\/+$/, '');
+      localStorage.setItem('yely_stats_base_url', base);
+      const ref = photoRefInput.value.trim();
+      if (!base || !ref) {
+        statusEl.textContent = "Renseigne l'URL de l'API et la référence de la photo.";
+        return;
+      }
+
+      const prix = document.getElementById('correctedPrix').value;
+      const volume = document.getElementById('correctedVolume').value;
+      const prixLitre = document.getElementById('correctedPrixLitre').value;
+      if (!prix && !volume && !prixLitre) {
+        statusEl.textContent = "Renseigne au moins une valeur corrigée.";
+        return;
+      }
+
+      const formData = new FormData();
+      formData.append('photo_reference', ref);
+      if (prix) formData.append('corrected_prix', prix);
+      if (volume) formData.append('corrected_volume', volume);
+      if (prixLitre) formData.append('corrected_prix_litre', prixLitre);
+      const correctedBy = document.getElementById('correctedBy').value.trim();
+      if (correctedBy) formData.append('corrected_by', correctedBy);
+
+      submitBtn.disabled = true;
+      submitBtn.textContent = 'Envoi…';
+      banner.className = 'banner';
+      banner.textContent = '';
+      statusEl.textContent = 'Envoi de la correction…';
+
+      try {
+        const res = await fetch(base + '/feedback', { method: 'POST', body: formData });
+        const data = await res.json();
+        if (res.ok && data.success) {
+          banner.className = 'banner ok';
+          banner.textContent = '✅ Correction enregistrée, merci.';
+          statusEl.textContent = '';
+        } else {
+          banner.className = 'banner ko';
+          banner.textContent = '⛔ ' + (data.detail || 'Échec de l\'enregistrement.');
+          statusEl.textContent = '';
+        }
+      } catch (err) {
+        banner.className = 'banner ko';
+        banner.textContent = "⛔ Impossible de contacter l'API (" + err.message + ").";
+        statusEl.textContent = '';
+      } finally {
+        submitBtn.disabled = false;
+        submitBtn.textContent = 'Envoyer la correction';
+      }
+    });
+  </script>
+</body>
+</html>

web/stats.html

@@ -0,0 +1,277 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>YELY | Tableau de bord</title>
+  <style>
+    :root {
+      --bg: #0f172a;
+      --panel: #1e293b;
+      --panel-2: #273449;
+      --border: #334155;
+      --text: #e2e8f0;
+      --muted: #94a3b8;
+      --accent: #f59e0b;
+      --ok-text: #6ee7b7;
+      --ko-text: #fca5a5;
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      min-height: 100vh;
+      font-family: -apple-system, "Segoe UI", Roboto, Arial, sans-serif;
+      background: var(--bg);
+      color: var(--text);
+      display: flex;
+      justify-content: center;
+      padding: 2rem 1rem;
+    }
+    .app { width: 100%; max-width: 720px; }
+    .brand { display: flex; align-items: center; justify-content: space-between; gap: 0.6rem; margin-bottom: 0.25rem; }
+    .brand-left { display: flex; align-items: center; gap: 0.6rem; }
+    .brand .dot { width: 10px; height: 10px; border-radius: 50%; background: var(--accent); }
+    .brand h1 { font-size: 1.3rem; margin: 0; }
+    .brand a { color: var(--muted); font-size: 0.85rem; text-decoration: none; border: 1px solid var(--border); padding: 0.4rem 0.7rem; border-radius: 8px; }
+    .brand a:hover { border-color: var(--accent); color: var(--text); }
+    .subtitle { color: var(--muted); font-size: 0.9rem; margin: 0 0 1.5rem; }
+
+    .card {
+      background: var(--panel);
+      border: 1px solid var(--border);
+      border-radius: 14px;
+      padding: 1.25rem;
+      margin-bottom: 1rem;
+    }
+
+    label { display: block; font-size: 0.85rem; color: var(--muted); margin: 0 0 0.3rem; }
+    input {
+      width: 100%;
+      padding: 0.6rem 0.75rem;
+      border-radius: 8px;
+      border: 1px solid var(--border);
+      background: var(--panel-2);
+      color: var(--text);
+      font-size: 0.95rem;
+    }
+    .config-row { display: flex; gap: 0.6rem; align-items: flex-end; }
+    .config-row > div:first-child { flex: 1; }
+    button {
+      padding: 0.6rem 1rem;
+      border: none;
+      border-radius: 8px;
+      background: var(--accent);
+      color: #1a1200;
+      font-size: 0.9rem;
+      font-weight: 700;
+      cursor: pointer;
+      white-space: nowrap;
+    }
+    button:disabled { background: #4b5563; color: #9ca3af; cursor: not-allowed; }
+
+    .metrics-grid { display: grid; grid-template-columns: repeat(3, 1fr); gap: 0.8rem; }
+    .metric { background: var(--panel-2); border: 1px solid var(--border); border-radius: 10px; padding: 0.9rem; text-align: center; }
+    .metric .value { font-size: 1.8rem; font-weight: 700; }
+    .metric .label { color: var(--muted); font-size: 0.78rem; margin-top: 0.2rem; }
+
+    .section-title { font-size: 0.85rem; color: var(--muted); margin: 0 0 0.6rem; text-transform: uppercase; letter-spacing: 0.03em; }
+    .bar-row { display: flex; align-items: center; gap: 0.6rem; margin-bottom: 0.5rem; }
+    .bar-row .bar-label { width: 44%; font-size: 0.85rem; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+    .bar-row .bar-track { flex: 1; background: var(--panel-2); border-radius: 6px; height: 10px; overflow: hidden; }
+    .bar-row .bar-fill { height: 100%; background: var(--accent); }
+    .bar-row .bar-count { width: 2.5rem; text-align: right; font-size: 0.85rem; color: var(--muted); }
+    .bar-row.blocking .bar-fill { background: var(--ko-text); }
+
+    .empty { color: var(--muted); font-size: 0.85rem; text-align: center; padding: 1rem 0; }
+    .status { font-size: 0.8rem; color: var(--muted); text-align: center; margin-top: 0.5rem; }
+
+    .failure-list { display: flex; flex-direction: column; gap: 0.8rem; }
+    .failure-card { display: flex; gap: 0.8rem; background: var(--panel-2); border: 1px solid var(--border); border-radius: 10px; padding: 0.7rem; align-items: center; }
+    .failure-card img { width: 84px; height: 84px; object-fit: cover; border-radius: 8px; background: #000; flex-shrink: 0; }
+    .failure-card .no-photo { width: 84px; height: 84px; border-radius: 8px; background: #000; flex-shrink: 0; display: flex; align-items: center; justify-content: center; color: var(--muted); font-size: 0.7rem; text-align: center; }
+    .failure-info { flex: 1; min-width: 0; }
+    .failure-info .msg { font-size: 0.85rem; color: var(--ko-text); font-weight: 600; margin-bottom: 0.2rem; }
+    .failure-info .meta { font-size: 0.78rem; color: var(--muted); }
+    .failure-card a.fix-link {
+      flex-shrink: 0; text-decoration: none; background: var(--accent); color: #1a1200;
+      font-size: 0.82rem; font-weight: 700; padding: 0.5rem 0.8rem; border-radius: 8px;
+    }
+  </style>
+</head>
+<body>
+  <div class="app">
+    <div class="brand">
+      <div class="brand-left"><span class="dot"></span><h1>YELY |Tableau de bord</h1></div>
+      <a href="index.html">← Démo /analyze</a>
+    </div>
+    <p class="subtitle">Suivi des performances du module IA en production (voir docs/MONITORING.md).</p>
+
+    <div class="card">
+      <div class="config-row">
+        <div>
+          <label>URL de l'API (base, sans /analyze)</label>
+          <input type="text" id="apiUrl" placeholder="https://xxx.hf.space" />
+        </div>
+        <button id="refreshBtn">Actualiser</button>
+      </div>
+      <div class="status" id="status"></div>
+    </div>
+
+    <div class="card">
+      <div class="metrics-grid">
+        <div class="metric">
+          <div class="value" id="mTotal">—</div>
+          <div class="label">Requêtes totales</div>
+        </div>
+        <div class="metric">
+          <div class="value" id="mSuccess">—</div>
+          <div class="label">Taux de succès</div>
+        </div>
+        <div class="metric">
+          <div class="value" id="mConfidence">—</div>
+          <div class="label">Confiance moyenne</div>
+        </div>
+      </div>
+    </div>
+
+    <div class="card">
+      <div class="section-title">Répartition qualité image</div>
+      <div id="qualityBars"><div class="empty">Aucune donnée pour l'instant.</div></div>
+    </div>
+
+    <div class="card">
+      <div class="section-title">Causes de blocage</div>
+      <div id="blockingBars"><div class="empty">Aucune donnée pour l'instant.</div></div>
+    </div>
+
+    <div class="card">
+      <div class="section-title">Requêtes échouées (20 dernières)</div>
+      <div id="failureList" class="failure-list"><div class="empty">Aucune donnée pour l'instant.</div></div>
+    </div>
+  </div>
+
+  <script src="config.js"></script>
+  <script>
+    const apiUrlInput = document.getElementById('apiUrl');
+    const refreshBtn = document.getElementById('refreshBtn');
+    const statusEl = document.getElementById('status');
+    const mTotal = document.getElementById('mTotal');
+    const mSuccess = document.getElementById('mSuccess');
+    const mConfidence = document.getElementById('mConfidence');
+    const qualityBars = document.getElementById('qualityBars');
+    const blockingBars = document.getElementById('blockingBars');
+    const failureList = document.getElementById('failureList');
+
+    function defaultBaseUrl() {
+      const stored = localStorage.getItem('yely_api_url') || window.YELY_API_URL || '';
+      return stored.replace(/\/analyze\/?$/, '');
+    }
+    apiUrlInput.value = localStorage.getItem('yely_stats_base_url') || defaultBaseUrl();
+
+    function renderBars(container, data, variant) {
+      container.innerHTML = '';
+      const items = Object.entries(data || {});
+      if (items.length === 0) {
+        container.innerHTML = '<div class="empty">Aucune donnée pour l\'instant.</div>';
+        return;
+      }
+      const max = Math.max(...items.map(([, count]) => count));
+      for (const [label, count] of items) {
+        const row = document.createElement('div');
+        row.className = 'bar-row' + (variant ? ' ' + variant : '');
+        const pct = max > 0 ? Math.round((count / max) * 100) : 0;
+        row.innerHTML = `
+          <span class="bar-label" title="${label}">${label}</span>
+          <span class="bar-track"><span class="bar-fill" style="width:${pct}%"></span></span>
+          <span class="bar-count">${count}</span>`;
+        container.appendChild(row);
+      }
+    }
+
+    function fmtVal(v) {
+      return (v === null || v === undefined) ? '—' : v;
+    }
+
+    function renderFailures(base, items) {
+      failureList.innerHTML = '';
+      if (!items || items.length === 0) {
+        failureList.innerHTML = '<div class="empty">Aucune requête échouée pour l\'instant.</div>';
+        return;
+      }
+      for (const item of items) {
+        const card = document.createElement('div');
+        card.className = 'failure-card';
+
+        let photoHtml;
+        if (item.photo_reference) {
+          const photoUrl = base + '/photos/' + encodeURIComponent(item.photo_reference);
+          photoHtml = `<img src="${photoUrl}" alt="Photo" onerror="this.outerHTML='<div class=&quot;no-photo&quot;>Photo indisponible</div>'" />`;
+        } else {
+          photoHtml = '<div class="no-photo">Pas de photo</div>';
+        }
+
+        const fixHref = 'feedback.html?ref=' + encodeURIComponent(item.photo_reference || '');
+
+        card.innerHTML = `
+          ${photoHtml}
+          <div class="failure-info">
+            <div class="msg">${item.message || 'Échec non précisé'}</div>
+            <div class="meta">
+              qualité: ${fmtVal(item.image_quality)} · confiance: ${item.confidence_score != null ? Math.round(item.confidence_score * 100) + '%' : '—'}<br/>
+              montant: ${fmtVal(item.detected_amount)} · litres: ${fmtVal(item.detected_liters)} · prix/L: ${fmtVal(item.fuel_price)}
+            </div>
+          </div>
+          ${item.photo_reference ? `<a class="fix-link" href="${fixHref}">Corriger</a>` : ''}`;
+        failureList.appendChild(card);
+      }
+    }
+
+    async function loadMetrics() {
+      const base = apiUrlInput.value.trim().replace(/\/+$/, '');
+      localStorage.setItem('yely_stats_base_url', base);
+      if (!base) {
+        statusEl.textContent = "Renseigne l'URL de l'API.";
+        return;
+      }
+
+      refreshBtn.disabled = true;
+      refreshBtn.textContent = 'Chargement…';
+      statusEl.textContent = 'Récupération des métriques…';
+
+      try {
+        const [metricsRes, failuresRes] = await Promise.all([
+          fetch(base + '/metrics'),
+          fetch(base + '/failures'),
+        ]);
+        const data = await metricsRes.json();
+        if (!metricsRes.ok) throw new Error('HTTP ' + metricsRes.status);
+
+        mTotal.textContent = data.total_requests ?? 0;
+        mSuccess.textContent = data.success_rate === null || data.success_rate === undefined
+          ? '—' : Math.round(data.success_rate * 100) + '%';
+        mConfidence.textContent = data.avg_confidence_score === null || data.avg_confidence_score === undefined
+          ? '—' : Math.round(data.avg_confidence_score * 100) + '%';
+
+        renderBars(qualityBars, data.image_quality_distribution);
+        renderBars(blockingBars, data.blocking_causes, 'blocking');
+
+        if (failuresRes.ok) {
+          renderFailures(base, await failuresRes.json());
+        }
+
+        statusEl.textContent = 'Mis à jour à ' + new Date().toLocaleTimeString('fr-FR');
+      } catch (err) {
+        statusEl.textContent = "Impossible de contacter l'API (" + err.message + ").";
+      } finally {
+        refreshBtn.disabled = false;
+        refreshBtn.textContent = 'Actualiser';
+      }
+    }
+
+    refreshBtn.addEventListener('click', loadMetrics);
+    apiUrlInput.addEventListener('change', loadMetrics);
+    loadMetrics();
+    setInterval(loadMetrics, 15000);
+  </script>
+</body>
+</html>

web/vercel.json

@@ -1,3 +0,0 @@
-{
-  "cleanUrls": true
-}