fix(ui): dropdown reflete blown SUR LA CLE COURANTE (per-key, pas per-pool)

L'utilisateur clarifie : il veut que le dropdown montre l'etat de la
cle ACTUELLEMENT utilisee, pas une vue agregee du pool. Quand un
modele autre que 3.1 hit PerDay sur la cle courante, il devient
'epuise sur cette cle' immediatement (et la prochaine invocation
prendra une autre cle, mais pas pour 3.5/2.5 sans switch).

Avant : is_model_fully_blown(model) = True ssi toutes les cles du
pool blown pour ce modele → trop conservateur, dropdown ne changeait
jamais en pratique.

Maintenant :
- _CURRENT_GEMINI_KEY : variable module-level qui track la cle active.
- set_current_gemini_key(key) : appelee a chaque init et chaque switch.
Bumpe le registry version pour rafraichir le dropdown.
- is_model_blown_on_current_key(model) : True si le modele est blown
sur la cle courante (PerDay aujourd'hui OU cle invalide).
- build_model_choices() utilise ce check au lieu de is_model_fully_blown.
- Label : '❌ X — epuise sur cette cle' (au lieu de 'sur tout le pool').

Sites de set_current_gemini_key :
- chat_with_agent : init + apres switch.
- run_jarvis_flow : init + apres switch invalide + apres switch PerDay 3.1.

Comportement final :
- Sur 3.1 : un PerDay declenche switch auto → dropdown se rafraichit
immediatement avec les statuts connus de la NOUVELLE cle (qui peut
encore avoir 3.5/2.5 dispo, ou pas).
- Sur 3.5/2.5 : un PerDay marque blown → dropdown affiche immediatement
'❌ epuise sur cette cle' (puisque c'est la verite pour la cle qu'on
utilise actuellement). L'utilisateur sait qu'il doit basculer
manuellement de modele.

183 tests verts.

app.py

@@ -407,17 +407,35 @@ def mark_gemini_key_blown(key: str, model: str) -> None:
             _bump_registry_version()
 
 
-def is_model_fully_blown(model: str) -> bool:
-    """True si TOUTES les clés du pool sont blown ou invalides pour ce
-    modèle aujourd'hui. Utilisé pour griser dans le dropdown UI."""
-    keys = _parse_google_keys()
-    if not keys:
+# Clé Gemini ACTIVE dans la session courante (= celle dans laquelle
+# tournent les requêtes en ce moment). Mise à jour quand on pick une
+# nouvelle clé (init) ou quand on bascule (PerDay/invalid sur 3.1).
+# Le dropdown affiche le status « épuisé » selon ce qui est blown
+# POUR CETTE CLÉ — pas pour tout le pool.
+_CURRENT_GEMINI_KEY: Optional[str] = None
+
+
+def set_current_gemini_key(key: Optional[str]) -> None:
+    """Déclare la clé Gemini active. Bumpe le registry version pour
+    que le dropdown se rafraîchisse au prochain yield (le label
+    « ✅/❌ épuisé sur cette clé » dépend de la clé courante)."""
+    global _CURRENT_GEMINI_KEY
+    if _CURRENT_GEMINI_KEY != key:
+        _CURRENT_GEMINI_KEY = key
+        _bump_registry_version()
+
+
+def is_model_blown_on_current_key(model: str) -> bool:
+    """True si le modèle est épuisé SUR LA CLÉ COURANTE (blown today
+    ou invalide). C'est ça qui détermine si le dropdown affiche
+    « ❌ épuisé ». Si on n'a pas encore de clé active, on retourne
+    False (état neutre)."""
+    key = _CURRENT_GEMINI_KEY
+    if not key:
         return False
-    today = _today_utc_str()
-    return all(
-        (k in _INVALID_KEYS) or _BLOWN_TODAY.get((k, model, today), False)
-        for k in keys
-    )
+    if key in _INVALID_KEYS:
+        return True
+    return _BLOWN_TODAY.get((key, model, _today_utc_str()), False)
 
 
 def _refresh_dropdown_wrap(fn):
@@ -447,19 +465,22 @@ def _refresh_dropdown_wrap(fn):
 
 def build_model_choices() -> list[tuple[str, str]]:
     """Construit la liste de (label, value) du dropdown des modèles,
-    avec marquage visuel :
-      - ✅ pour les modèles disponibles (label complet conservé)
-      - ❌ pour les Gemini natifs dont TOUTES les clés du pool sont
-        blown aujourd'hui : on remplace le suffixe `(X req/jour)`
-        par `— épuisé aujourd'hui`.
+    avec marquage visuel BASÉ SUR LA CLÉ COURANTE :
+      - ✅ pour les modèles disponibles sur la clé active
+      - ❌ pour les Gemini natifs blown sur la clé active (PerDay
+        sur cette clé OU clé invalide). On remplace le suffixe
+        `(X req/jour)` par `— épuisé sur cette clé`.
+
+    Quand on bascule de clé (3.1 hit PerDay → switch), set_current_
+    gemini_key est appelée et le dropdown se re-rendre avec les
+    statuts connus de la NOUVELLE clé (qui peuvent être différents).
     """
     import re as _re
     out: list[tuple[str, str]] = []
     for key, label in ALL_MODELS.items():
-        if key in GEMINI_NATIVE_REQUIRED and is_model_fully_blown(key):
-            # Strip un suffixe parenthésé en fin de label (« (500 req/jour) »)
+        if key in GEMINI_NATIVE_REQUIRED and is_model_blown_on_current_key(key):
             base = _re.sub(r"\s*\(.*?\)\s*$", "", label).strip()
-            decorated = f"❌ {base} — épuisé aujourd'hui"
+            decorated = f"❌ {base} — épuisé sur cette clé"
         else:
             decorated = f"✅ {label}"
         out.append((decorated, key))
@@ -802,6 +823,9 @@ def chat_with_agent(message: str, history: list[dict], api_key: str, model: str,
     current_gemini_key: Optional[str] = (
         pick_unblown_gemini_key(model) if model in GEMINI_NATIVE_REQUIRED else None
     )
+    # Annonce au registry quelle clé est active → le dropdown
+    # reflètera ce qui est blown SUR CETTE CLÉ.
+    set_current_gemini_key(current_gemini_key)
     try:
         llm = _build_llm(model, api_key, use_thinking=use_thinking,
                           gemini_key_override=current_gemini_key)
@@ -950,6 +974,7 @@ def chat_with_agent(message: str, history: list[dict], api_key: str, model: str,
                         if next_key:
                             pool_n = gemini_pool_size()
                             current_gemini_key = next_key
+                            set_current_gemini_key(current_gemini_key)
                             llm = _build_llm(
                                 model, api_key,
                                 use_thinking=use_thinking,
@@ -1018,6 +1043,7 @@ def chat_with_agent(message: str, history: list[dict], api_key: str, model: str,
                         if next_key:
                             pool_n = gemini_pool_size()
                             current_gemini_key = next_key
+                            set_current_gemini_key(current_gemini_key)
                             llm = _build_llm(
                                 model, api_key,
                                 use_thinking=use_thinking,

jarvis.py

@@ -1096,9 +1096,13 @@ def run_jarvis_flow(
             # Si modèle Gemini natif, on pick une clé du pool en explicite
             # pour pouvoir la marquer "blown" plus tard si nécessaire.
             try:
-                from app import GEMINI_NATIVE_REQUIRED, pick_unblown_gemini_key
+                from app import (
+                    GEMINI_NATIVE_REQUIRED, pick_unblown_gemini_key,
+                    set_current_gemini_key as _set_current_key,
+                )
                 if model in GEMINI_NATIVE_REQUIRED:
                     current_gemini_key = pick_unblown_gemini_key(model)
+                    _set_current_key(current_gemini_key)
             except Exception:
                 pass  # app pas importable (test mode) → comportement standard
             llm = build_llm_fn(model, api_key, use_thinking=use_thinking,
@@ -1345,6 +1349,11 @@ def run_jarvis_flow(
                                 if next_key:
                                     pool_n = gemini_pool_size()
                                     current_gemini_key = next_key
+                                    try:
+                                        from app import set_current_gemini_key as _set_cur
+                                        _set_cur(current_gemini_key)
+                                    except Exception:
+                                        pass
                                     llm = build_llm_fn(
                                         model, api_key,
                                         use_thinking=use_thinking,
@@ -1453,6 +1462,11 @@ def run_jarvis_flow(
                                     # langgraph reprend là où il en était.
                                     pool_n = gemini_pool_size()
                                     current_gemini_key = next_key
+                                    try:
+                                        from app import set_current_gemini_key as _set_cur
+                                        _set_cur(current_gemini_key)
+                                    except Exception:
+                                        pass
                                     llm = build_llm_fn(
                                         model, api_key,
                                         use_thinking=use_thinking,