Update src/module/AIP.py

src/module/AIP.py

@@ -1,9 +1,9 @@
 """
-MODULE JASMINE AGENT - VERSION ULTIME (FULL STACK + EMPATHIE)
-=============================================================
-Responsabilité : Agent IA centralisé.
-Capacités : ETL, Dashboard, Data Lab, DQ, Features, Forecasting.
-Ton : Professionnel, Proactif et Humain.
+MODULE JASMINE AGENT - EXECUTIVE EDITION
+========================================
+Responsabilité : Cerveau central. Analyse stratégique et recommandations de direction.
+Niveau : C-Level (Directeur Général).
+Capacités : Connexion profonde aux moteurs de calcul (Forecasting, Dashboard, DQ).
 """
 
 import google.generativeai as genai
@@ -16,18 +16,20 @@ import pandas as pd
 import numpy as np
 import traceback
 
-# --- IMPORT DES 6 MODULES CIBLES ---
+# --- IMPORTATION ROBUSTE DES MODULES ---
+# Jasmine s'adapte aux modules disponibles pour éviter les crashs
 try:
     from module.Validation_Contract import ETL_Engine
-    from module.Dashboard import HospitalDashboard
+    # MISE A JOUR: Import des nouveaux moteurs du Dashboard
+    from module.Dashboard import RealtimeMonitor, CrisisSimulator
     from module.Data_Exploration import HospitalAdvancedAnalyzer
     from module.Indicateurs_DQ import HospitalDataQualityAnalyzer, load_from_google_sheets
     from module.Features import FeatureEngineer
     from module.Forecasting import HospitalForecaster
 except ImportError as e:
-    st.error(f"❌ Erreur critique d'importation : {str(e)}")
+    st.error(f"Erreur critique d'importation des modules : {str(e)}")
 
-# --- STYLE GOTHAM ---
+# --- STYLE ---
 def apply_custom_styles():
     st.markdown("""
     <style>
@@ -47,26 +49,15 @@ def apply_custom_styles():
         color: #8b949e; background: #0d1117; padding: 10px; 
         border: 1px solid #30363d; border-radius: 0px; margin: 5px 0 10px 0;
     }
-    .streamlit-expanderHeader { border-radius: 0px !important; background-color: #161b22 !important; border: 1px solid #30363d !important; }
-    .streamlit-expanderContent { border-radius: 0px !important; border: 1px solid #30363d !important; border-top: none !important; background-color: #0d1117 !important; }
-    h2 { font-family: 'Inter', sans-serif; font-weight: 600; border-bottom: 1px solid #333; padding-bottom: 10px; }
     </style>
     """, unsafe_allow_html=True)
 
 class JasmineAgent:
     def __init__(self, gspread_client):
         self.gspread_client = gspread_client
-        self.google_key = os.environ.get("GOOGLE_API_KEY")
-        self.groq_key = os.environ.get("GROQ_API_KEY")
+        self.google_key = os.environ.get("GOOGLE_API_KEY") or st.secrets.get("GOOGLE_API_KEY")
+        self.groq_key = os.environ.get("GROQ_API_KEY") or st.secrets.get("GROQ_API_KEY")
         
-        # Fallbacks
-        if not self.google_key:
-            try: self.google_key = st.secrets.get("GOOGLE_API_KEY")
-            except: pass
-        if not self.groq_key:
-            try: self.groq_key = st.secrets.get("GROQ_API_KEY")
-            except: pass
-
         self.groq_client = Groq(api_key=self.groq_key) if self.groq_key else None
         if self.google_key: genai.configure(api_key=self.google_key)
 
@@ -79,16 +70,16 @@ class JasmineAgent:
         
         # --- CARTE DES OUTILS ---
         self.tools_map = {
-            "run_etl_pipeline": {"func": self._run_etl_wrapper, "desc": "1. ETL : Nettoyage et mise à jour des données."},
-            "run_feature_engineering": {"func": self._run_features_wrapper, "desc": "2. ML Prep : Transformation des données pour l'IA."},
-            "train_forecasting_models": {"func": self._train_models_wrapper, "desc": "3. Training : Entraînement des modèles prédictifs."},
-            "get_future_forecast": {"func": self._get_forecast_wrapper, "desc": "4. Prédiction : Obtenir les prévisions futures."},
-            "get_hospital_kpis": {"func": self._get_kpis_wrapper, "desc": "5. Dashboard : KPIs actuels (Lits, RH, Stocks)."},
-            "analyze_patient_stats": {"func": self._get_data_exploration_wrapper, "desc": "6. Data Lab : Stats patients passées."},
-            "get_data_quality_report": {"func": self._get_dq_stats_wrapper, "desc": "7. Audit : Qualité et fiabilité des données."}
+            "run_etl_pipeline": {"func": self._run_etl_wrapper, "desc": "ETL : Mise à jour des données brutes."},
+            "run_feature_engineering": {"func": self._run_features_wrapper, "desc": "Features : Transformation pour l'IA."},
+            "train_forecasting_models": {"func": self._train_models_wrapper, "desc": "Training : Entraînement des modèles IA."},
+            "get_future_forecast": {"func": self._get_forecast_wrapper, "desc": "Prédiction : Analyse du futur (3 mois)."},
+            "get_hospital_kpis": {"func": self._get_kpis_wrapper, "desc": "Cockpit : État actuel temps réel (Monitor)."},
+            "analyze_patient_stats": {"func": self._get_data_exploration_wrapper, "desc": "Data Lab : Analyse historique profonde."},
+            "get_data_quality_report": {"func": self._get_dq_stats_wrapper, "desc": "Audit : Fiabilité des données."}
         }
 
-    # --- WRAPPERS TECHNIQUES ---
+    # --- WRAPPERS INTELLIGENTS (Extraction de contexte riche) ---
 
     def _run_etl_wrapper(self, args=None):
         try:
@@ -96,18 +87,22 @@ class JasmineAgent:
             success, result = engine.run_etl()
             if success:
                 st.session_state.data_explorer = result
+                # On retourne le résumé complet pour analyse
                 return {"status": "succès", "details": result.get_summary()}
-            return {"status": "erreur", "message": "Échec ETL."}
+            return {"status": "erreur", "message": "Échec critique du pipeline ETL."}
         except Exception as e: return {"status": "crash", "message": str(e)}
 
     def _run_features_wrapper(self, args=None):
         try:
-            if 'data_explorer' not in st.session_state: return {"status": "erreur", "message": "Lancez l'ETL d'abord."}
+            if 'data_explorer' not in st.session_state: return {"status": "erreur", "message": "Données brutes manquantes. Lancez l'ETL."}
             engineer = FeatureEngineer(st.session_state.data_explorer)
             df_final, msg = engineer.build_full_dataset()
             if df_final is not None:
                 st.session_state['ml_features'] = df_final
-                return {"status": "succès", "details": {"lignes": len(df_final), "features": len(df_final.columns)}}
+                # Analyse rapide des features générées pour le contexte
+                cols = list(df_final.columns)
+                lags = [c for c in cols if 'lag' in c]
+                return {"status": "succès", "details": {"lignes": len(df_final), "total_features": len(cols), "lags_detectes": len(lags)}}
             return {"status": "erreur", "message": msg}
         except Exception as e: return {"status": "crash", "message": str(e)}
 
@@ -119,42 +114,68 @@ class JasmineAgent:
             metrics = forecaster.train_all_models()
             st.session_state['forecaster'] = forecaster
             st.session_state['metrics'] = metrics
-            best = forecaster.best_model_name
-            return {"status": "succès", "details": {"best_model": best, "r2": metrics[best]['R²'], "mae": metrics[best]['MAE']}}
+            
+            # On renvoie toutes les métriques pour comparaison
+            return {"status": "succès", "details": metrics}
         except Exception as e: return {"status": "crash", "message": str(e)}
 
     def _get_forecast_wrapper(self, args=None):
         try:
-            if 'forecaster' not in st.session_state: return {"status": "erreur", "message": "Modèles non entraînés."}
+            if 'forecaster' not in st.session_state: return {"status": "erreur", "message": "IA non entraînée."}
             forecaster = st.session_state['forecaster']
-            dates, values, _ = forecaster.generate_future_forecast_recursive(months=3)
+            # On demande 3 mois pour voir la tendance long terme
+            dates, values, conf = forecaster.generate_future_forecast_recursive(months=3)
             alerts = forecaster.detect_future_anomalies(values)
-            return {"status": "succès", "details": {"tendance": "Hausse" if values[-1] > values[0] else "Baisse", "max_prevu": float(np.max(values)), "alerte_count": len(alerts), "prochaine_alerte": alerts[0] if alerts else None}}
+            
+            # Analyse statistique de la prédiction
+            trend_pct = ((values[-1] - values[0]) / values[0]) * 100
+            
+            return {
+                "status": "succès", 
+                "details": {
+                    "tendance_pct": trend_pct,
+                    "min_val": float(np.min(values)),
+                    "max_val": float(np.max(values)),
+                    "mean_val": float(np.mean(values)),
+                    "alertes": alerts, # Liste complète des alertes
+                    "confiance_spread": float(np.mean(conf['upper'] - conf['lower'])) # Indicateur d'incertitude
+                }
+            }
         except Exception as e: return {"status": "crash", "message": str(e)}
 
     def _get_kpis_wrapper(self, args=None):
         try:
-            dash = HospitalDashboard(self.gspread_client, "bdd_mvp_faker")
-            if not dash.load_data(): return {"status": "erreur", "message": "Données Dashboard indisponibles."}
-            return {"status": "succès", "details": dash._get_kpis()}
+            # CORRECTION MAJEURE : Utilisation du RealtimeMonitor
+            if 'ml_features' not in st.session_state or 'forecaster' not in st.session_state:
+                return {"status": "erreur", "message": "Le Cockpit nécessite les données ML et le modèle entraîné."}
+            
+            monitor = RealtimeMonitor(st.session_state['ml_features'], st.session_state['forecaster'])
+            state = monitor.current_state # Récupère tout l'état (KPIs + tendances + alertes)
+            
+            # On ajoute l'analyse par service
+            services_breakdown = monitor.get_service_breakdown()
+            top_tension_service = services_breakdown.iloc[0].name if services_breakdown is not None else "Inconnu"
+            
+            # On fusionne tout
+            state['top_tension_service'] = top_tension_service
+            
+            return {"status": "succès", "details": state}
         except Exception as e: return {"status": "crash", "message": str(e)}
 
     def _get_data_exploration_wrapper(self, args=None):
         try:
             analyzer = HospitalAdvancedAnalyzer(self.gspread_client, "bdd_mvp_faker")
-            if not analyzer.load_data(): return {"status": "erreur", "message": "Data Lab inaccessible."}
+            if not analyzer.load_data(): return {"status": "erreur", "message": "Données historiques inaccessibles."}
+            
             df_pat = analyzer.get_df('patients')
-            df_sej = analyzer.get_df('sejours')
             stats = {}
             if df_pat is not None:
                 df_pat['age'] = pd.to_numeric(df_pat['age'], errors='coerce')
-                stats['age_moyen'] = round(df_pat['age'].mean(), 1)
-                stats['total_patients'] = len(df_pat)
-                counts = df_pat['sexe'].value_counts(normalize=True)
-                stats['ratio_hommes'] = round(counts.get('M', 0) * 100, 1)
-                stats['ratio_femmes'] = round(counts.get('F', 0) * 100, 1)
-            if df_sej is not None:
-                stats['pathologie_top'] = df_sej['pathologie_code'].mode()[0]
+                stats['demographie'] = {
+                    'total': len(df_pat),
+                    'age_moyen': round(df_pat['age'].mean(), 1),
+                    'senior_ratio': round((df_pat['age'] > 65).mean() * 100, 1)
+                }
             return {"status": "succès", "details": stats}
         except Exception as e: return {"status": "crash", "message": str(e)}
 
@@ -163,71 +184,154 @@ class JasmineAgent:
             raw_data = load_from_google_sheets(self.gspread_client, "bdd_mvp_faker")
             dq = HospitalDataQualityAnalyzer(raw_data)
             scores = dq.compute_global_score()
-            return {"status": "succès", "details": {"score": scores['global'], "anomalies": dq.metrics['patients']['anomalies']}}
+            
+            # On veut savoir où sont les problèmes exactement
+            details_anomalies = {k: v['anomalies'] for k, v in dq.metrics.items() if 'anomalies' in v}
+            
+            return {
+                "status": "succès", 
+                "details": {
+                    "scores": scores,
+                    "anomalies_par_table": details_anomalies
+                }
+            }
         except Exception as e: return {"status": "crash", "message": str(e)}
 
-    # --- HUMANISATION (Le Moteur de Personnalité) ---
+    # --- CERVEAU ANALYTIQUE (Human Response Engine) ---
     def _generate_human_response(self, tool_name, d):
-        """Traduit les données JSON en langage naturel professionnel"""
+        """
+        Génère une analyse structurée : Constat -> Analyse -> Stratégie.
+        """
         
+        # 1. ANALYSE DU COCKPIT (Présent)
         if tool_name == "get_hospital_kpis":
-            taux = float(d.get('taux_global', 0))
-            rh = max(0, d.get('tension_rh', 0))
-            ruptures = int(d.get('nb_ruptures', 0))
+            taux = d.get('taux_occupation', 0) * 100
+            trend = d.get('trend_occupation', 0)
+            score = d.get('health_score', 100)
+            tension_rh = d.get('tension_personnel', 0)
+            service_top = d.get('top_tension_service', 'N/A')
             
-            msg = "Voici la situation actuelle de l'établissement :\n\n"
-            if taux > 95: msg += f"🔴 **URGENCE :** Saturation critique (**{taux:.1f}%**). Plan Blanc recommandé.\n"
-            elif taux > 85: msg += f"🟠 **Tension :** L'occupation est élevée (**{taux:.1f}%**).\n"
-            else: msg += f"🟢 **Lits :** Situation calme (**{taux:.1f}%** d'occupation).\n"
+            msg = "### 🚁 Rapport de Situation Temps Réel\n\n"
             
-            if rh > 20: msg += f"⚠️ **RH :** Tension forte sur le personnel (**{rh:.1f}%** manquant).\n"
-            else: msg += f"✅ **RH :** Effectifs stables.\n"
+            # Constat
+            msg += f"**État Global :** Le score de santé de l'hôpital est de **{score:.0f}/100**.\n"
+            msg += f"- Occupation : **{taux:.1f}%** ({trend:+.1f}% sur 72h)\n"
+            msg += f"- Tension RH : **{tension_rh:.2f}** (Normal = 1.0)\n\n"
             
-            if ruptures > 0: msg += f"📦 **Logistique :** {ruptures} rupture(s) de stock détectée(s)."
-            else: msg += "📦 **Logistique :** Stocks au vert."
+            # Analyse
+            msg += "**🧠 Analyse Profonde :**\n"
+            if taux > 90:
+                msg += "Nous sommes en zone de saturation critique. La tendance montre une inertie qui risque de bloquer les urgences d'ici 24h. "
+            elif taux > 80:
+                msg += "L'activité est dense mais fluide. Les capacités tampons sont entamées. "
+            else:
+                msg += "L'hôpital est en sous-régime, ce qui permet d'absorber un éventuel choc externe. "
+                
+            if tension_rh > 1.1:
+                msg += f"Le point de friction majeur est le service **{service_top}**, où le manque de personnel crée un goulot d'étranglement.\n\n"
+            else:
+                msg += "L'adéquation charge/ressource est optimale.\n\n"
+                
+            # Stratégie
+            msg += "**🎯 Recommandations Stratégiques :**\n"
+            if score < 60:
+                msg += "1. **PRIORITAIRE :** Déclencher le niveau 1 du Plan Blanc pour libérer des lits.\n"
+                msg += f"2. Redéployer immédiatement du personnel vers le service {service_top}.\n"
+                msg += "3. Suspendre les admissions programmées non-urgentes pour 48h."
+            elif score < 80:
+                msg += f"1. Surveiller spécifiquement le service {service_top}.\n"
+                msg += "2. Préparer l'ouverture de lits 'buffer' si la tendance hausse se confirme."
+            else:
+                msg += "1. Maintenir le dispositif actuel.\n2. Profiter de l'accalmie pour effectuer les maintenances logistiques."
+                
             return msg
 
+        # 2. ANALYSE PRÉDICTIVE (Futur)
         elif tool_name == "get_future_forecast":
-            tendance = d['tendance']
-            max_p = d['max_prevu']
-            alerts = d.get('alerte_count', 0)
-            msg = f"Selon mes modèles, la tendance à 3 mois est à la **{tendance}**.\n"
-            msg += f"Le pic d'admissions prévu est de **{max_p:.0f} patients/jour**.\n\n"
-            if alerts > 0:
-                next_alert = d['prochaine_alerte']
-                msg += f"⚠️ **Vigilance :** Un pic anormal est détecté autour de **J+{next_alert['day']}**."
-            else: msg += "✅ Aucune anomalie majeure prévue."
+            tendance = d['tendance_pct']
+            max_val = d['max_val']
+            alertes = d['alertes']
+            
+            msg = "### 🔮 Note de Prospective (3 Mois)\n\n"
+            
+            # Constat
+            direction = "HAUSSE" if tendance > 0 else "BAISSE"
+            msg += f"**Trajectoire :** Mes modèles anticipent une **{direction} globale de {abs(tendance):.1f}%** des admissions.\n"
+            msg += f"**Point Haut :** Nous attendons un pic à **{max_val:.0f} patients/jour**.\n\n"
+            
+            # Analyse
+            msg += "**🧠 Analyse des Risques :**\n"
+            if len(alertes) > 0:
+                nb_high = len([a for a in alertes if a['severity'] == 'HIGH'])
+                first_alert_day = alertes[0]['day']
+                msg += f"Je détecte **{len(alertes)} anomalies statistiques** dans la période à venir, dont **{nb_high} critiques**.\n"
+                msg += f"La première tension majeure apparaîtra dans **{first_alert_day} jours**. Cela correspond probablement à une saisonnalité forte (ex: épidémie) ou à un événement cyclique mal anticipé.\n\n"
+            else:
+                msg += "La courbe prévisionnelle reste dans le tunnel de normalité. La variance est faible, ce qui indique une période de stabilité opérationnelle.\n\n"
+            
+            # Stratégie
+            msg += "**🎯 Actions Préventives :**\n"
+            if tendance > 15 or len(alertes) > 2:
+                msg += "1. **Anticipation RH :** Valider les plannings de garde pour J+30 dès maintenant.\n"
+                msg += "2. **Logistique :** Augmenter les stocks de consommables de +20% en prévision du pic.\n"
+                msg += "3. **Flux :** Prévenir les services d'aval (SSR) qu'une vague d'entrée arrive."
+            else:
+                msg += "1. Optimiser le taux d'occupation des lits programmés.\n"
+                msg += "2. Aucune mesure d'urgence requise."
+                
             return msg
 
-        elif tool_name == "train_forecasting_models":
-            return f"Entraînement terminé. Le modèle **{d['best_model']}** est le plus performant (Fiabilité : **{d['r2']*100:.1f}%**)."
-
-        elif tool_name == "run_etl_pipeline":
-            return f"Mise à jour effectuée. La base contient maintenant **{d['total_rows_clean']:,}** lignes consolidées."
-
-        elif tool_name == "run_feature_engineering":
-            return f"Préparation ML terminée : **{d['lignes']:,} vecteurs** générés avec **{d['features']} variables** d'analyse."
-
-        elif tool_name == "analyze_patient_stats":
-            return f"Analyse sur **{d['total_patients']} patients**. Âge moyen : **{d['age_moyen']} ans**. Pathologie dominante : **{d['pathologie_top']}**."
-
+        # 3. QUALITÉ DES DONNÉES (Fondation)
         elif tool_name == "get_data_quality_report":
-            score = d['score']
-            if score > 85: return f"🛡️ Données fiables (**{score}/100**)."
-            return f"⚠️ **Attention Data :** Score de qualité faible (**{score}/100**) avec **{d['anomalies']} anomalies**."
+            scores = d['scores']
+            anomalies = d['anomalies_par_table']
+            total_anom = sum(anomalies.values())
+            
+            msg = "### 🛡️ Audit de Fiabilité des Données\n\n"
+            msg += f"**Score de Confiance : {scores['global']}/100**\n"
+            msg += f"(Complétude : {scores['completeness']:.1f}% | Exactitude : {scores['accuracy']:.1f}%)\n\n"
+            
+            msg += "**🧠 Diagnostic Technique :**\n"
+            if total_anomalies > 0:
+                msg += f"J'ai identifié un total de **{total_anom} lignes corrompues** qui 'bruitent' mes analyses.\n"
+                worst_table = max(anomalies, key=anomalies.get)
+                msg += f"Le point noir se situe dans la table **'{worst_table}'** ({anomalies[worst_table]} erreurs). "
+                msg += "Ces erreurs (dates inversées, âges négatifs, doublons) réduisent la précision de mes prévisions d'environ 5 à 10%.\n\n"
+            else:
+                msg += "Le Data Lake est propre. Les signaux faibles sont clairs.\n\n"
+                
+            msg += "**🎯 Plan de Remédiation :**\n"
+            if scores['global'] < 80:
+                msg += "1. **URGENT :** Demander au DSI de purger la table 'Patients' (doublons).\n"
+                msg += "2. Mettre en place des contraintes de saisie dans le logiciel métier (dates).\n"
+                msg += "3. Relancer l'ETL après correction manuelle."
+            else:
+                msg += "Maintenir la surveillance automatisée hebdomadaire."
+                
+            return msg
 
-        return "Opération réussie."
+        # Par défaut (autres outils)
+        return f"✅ **Exécution Validée :** L'outil {tool_name} a fonctionné correctement. Les données ont été mises à jour dans le système central."
 
-    # --- INTELLIGENCE PRINCIPALE ---
+    # --- CERVEAU PRINCIPAL ---
     def ask(self, user_message, chat_history=[]):
         system_prompt = f"""
-        ROLE: Tu es Jasmine, Directrice adjointe virtuelle.
-        TON: Professionnel, concis, proactif.
-        OUTILS:
+        ROLE: Tu es Jasmine, la Directrice des Opérations (COO) Virtuelle de l'hôpital.
+        TON: Autoritaire mais bienveillant, précis, orienté solution. Tu ne dis pas "je pense", tu dis "l'analyse montre".
+        
+        OUTILS DISPONIBLES:
         {chr(10).join([f"- {k}: {v['desc']}" for k, v in self.tools_map.items()])}
-        RÈGLES:
-        1. Utilise les outils pour répondre aux faits.
-        2. Réponds TOUJOURS en JSON : {{ "thought": "...", "tool": "...", "args": {{}}, "answer": "..." }}
+        
+        DIRECTIVE SUPRÊME:
+        Ne te contente jamais de donner un chiffre. Donne le CONTEXTE, la CAUSE PROBABLE, et l'ACTION REQUISE.
+        
+        FORMAT DE RÉPONSE JSON ATTENDU:
+        {{
+          "thought": "Analyse interne de la demande...",
+          "tool": "nom_de_l_outil_a_lancer",
+          "args": {{}},
+          "answer": "Texte si pas d'outil nécessaire"
+        }}
         """
 
         response_payload = None
@@ -248,7 +352,7 @@ class JasmineAgent:
                 break 
             except: continue
 
-        if not response_payload: return "❌ Erreur API.", None, None
+        if not response_payload: return "❌ **Erreur Critique :** Mes services cognitifs ne répondent pas. Vérifiez les clés API.", None, None
 
         try:
             decision = json.loads(re.sub(r'```json\s*|\s*```', '', response_payload).strip())
@@ -258,14 +362,14 @@ class JasmineAgent:
             if tool_name in self.tools_map:
                 res = self.tools_map[tool_name]["func"]({})
                 if res["status"] == "succès":
-                    # UTILISATION DE LA NOUVELLE MÉTHODE HUMAINE
+                    # C'est ici que la magie opère
                     final_response = self._generate_human_response(tool_name, res["details"])
                 else:
-                    final_response = f"⚠️ Problème technique : {res.get('message')}"
+                    final_response = f"⚠️ **Alerte Technique :** {res.get('message')}"
                 return final_response, thought, res
             
-            return decision.get("answer", "Je vous écoute."), thought, None
-        except Exception as e: return f"Erreur système : {str(e)}", None, None
+            return decision.get("answer", "Je reste en veille."), thought, None
+        except Exception as e: return f"Erreur système interne : {str(e)}", None, None
 
 def show_terminal(client, sheet_name="bdd_mvp_faker"):
     apply_custom_styles()
@@ -281,13 +385,13 @@ def show_terminal(client, sheet_name="bdd_mvp_faker"):
         if msg.get("data"):
             with st.expander("💾 SYSTEM PAYLOAD"): st.json(msg["data"])
     
-    user_input = st.chat_input("Ex: 'Analyse les stocks' ou 'Lance la prédiction'...")
+    user_input = st.chat_input("Ordre à l'IA (ex: 'Audit complet', 'Situation RH', 'Prévisions')...")
     if user_input:
         st.session_state.chat_history.append({"role": "user", "content": user_input})
         st.rerun()
 
     if st.session_state.chat_history and st.session_state.chat_history[-1]["role"] == "user":
-        with st.spinner("Jasmine analyse..."):
+        with st.spinner("Analyse stratégique en cours..."):
             response, thought, data = st.session_state.agent_instance.ask(st.session_state.chat_history[-1]["content"])
             st.session_state.chat_history.append({"role": "assistant", "content": response, "thought": thought, "data": data})
             st.rerun()