Update app.py

app.py

@@ -109,6 +109,7 @@ def backup_db_to_hf():
 def init_db():
     try:
         with sqlite3.connect(DB_NAME) as conn:
+            # 1. Table des Signaux (Historique)
             conn.execute('''CREATE TABLE IF NOT EXISTS signals (
                 id INTEGER PRIMARY KEY AUTOINCREMENT, 
                 date TEXT, symbol TEXT, timeframe TEXT, direction TEXT, 
@@ -117,25 +118,53 @@ def init_db():
                 peak_price REAL, confirmed INTEGER DEFAULT 0)''')
             
             cursor = conn.cursor()
-            cursor.execute("PRAGMA table_info(agent_logic)")
-            if not [col[1] for col in cursor.fetchall()]:
-                conn.execute('''CREATE TABLE IF NOT EXISTS agent_logic (
-                    symbol TEXT, timeframe TEXT, tp_mult REAL, sl_mult REAL,
-                    score REAL, last_pnl REAL, min_prob REAL, min_tp_dist REAL,
-                    generation INTEGER DEFAULT 1, best_tp REAL, best_sl REAL,
-                    PRIMARY KEY (symbol, timeframe))''')
-
-            cursor.execute("SELECT COUNT(*) FROM agent_logic")
-            if cursor.fetchone()[0] == 0:
+            
+            # 2. Table de l'ADN (Logique des Agents)
+            # On vérifie si la table existe déjà pour éviter les conflits de structure
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='agent_logic'")
+            table_exists = cursor.fetchone()
+
+            if not table_exists:
+                conn.execute('''CREATE TABLE agent_logic (
+                    symbol TEXT, 
+                    timeframe TEXT, 
+                    regime INTEGER, -- ⬅️ Ajouté ici
+                    tp_mult REAL, 
+                    sl_mult REAL,
+                    score REAL, 
+                    last_pnl REAL, 
+                    min_prob REAL, 
+                    min_tp_dist REAL,
+                    generation INTEGER DEFAULT 1, 
+                    best_tp REAL, 
+                    best_sl REAL,
+                    PRIMARY KEY (symbol, timeframe, regime))''') # ⬅️ CLÉ PRIMAIRE TRIPLE
+                
+                # 3. Insertion des réglages par défaut
+                # On initialise les réglages sur le régime 3 (RANGE/CHAOS) par défaut
                 defaults = [
-                    ('ALL', '1m', 1.0, 0.8, 0, 0, 0.65, 0.001, 1, 0, 0), 
-                    ('ALL', '5m', 1.2, 0.9, 0, 0, 0.62, 0.002, 1, 0, 0), 
-                    ('ALL', '15m', 1.5, 1.0, 0, 0, 0.60, 0.003, 1, 0, 0), 
-                    ('ALL', '1h', 2.0, 1.5, 0, 0, 0.55, 0.005, 1, 0, 0),
-                    ('ALL', '4h', 3.0, 2.0, 0, 0, 0.50, 0.008, 1, 0, 0)
+                    # Symbol, TF, Regime, TP, SL, Score, PNL, Prob, Dist, Gen, B_TP, B_SL
+                    ('ALL', '1m', 3, 1.0, 0.8, 0, 0, 0.65, 0.001, 1, 0, 0), 
+                    ('ALL', '5m', 3, 1.2, 0.9, 0, 0, 0.62, 0.002, 1, 0, 0), 
+                    ('ALL', '15m', 3, 1.5, 1.0, 0, 0, 0.60, 0.003, 1, 0, 0), 
+                    ('ALL', '1h', 3, 2.0, 1.5, 0, 0, 0.55, 0.005, 1, 0, 0),
+                    ('ALL', '4h', 3, 3.0, 2.0, 0, 0, 0.50, 0.008, 1, 0, 0)
                 ]
-                conn.executemany("INSERT INTO agent_logic VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", defaults)
-    except Exception as e: print(f"❌ Erreur DB: {e}")
+                # On utilise 12 points d'interrogation pour les 12 colonnes
+                conn.executemany("INSERT INTO agent_logic VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", defaults)
+                conn.commit()
+                print("✅ [DB] Table agent_logic initialisée avec Scénarios.")
+            else:
+                # Optionnel : Vérifier si la colonne regime existe déjà (pour les mises à jour sans tout supprimer)
+                cursor.execute("PRAGMA table_info(agent_logic)")
+                columns = [col[1] for col in cursor.fetchall()]
+                if 'regime' not in columns:
+                    print("⚠️ [DB] Ancienne structure détectée. Suppression pour mise à jour...")
+                    conn.execute("DROP TABLE agent_logic")
+                    init_db() # On relance pour recréer proprement
+                    
+    except Exception as e: 
+        print(f"❌ Erreur DB: {e}")
 
 async def save_to_db(data):
     try:
@@ -266,6 +295,8 @@ def prepare_features_sync(symbol, timeframe='1h', limit_bars=600):
         return df.dropna().copy()
     except Exception as e: print(f"❌ Error Stats: {e}"); return pd.DataFrame()
 
+import numpy as np
+
 async def predict_signal(symbol, timeframe="1h"): 
     try:
         memory_guard()
@@ -279,14 +310,26 @@ async def predict_signal(symbol, timeframe="1h"):
         vol_spike = float(last_row['Vol_Spike'].iloc[0]) 
         rsi_9 = float(last_row['RSI_9'].iloc[0])         
         
+        # 🌊 1. COLLECTE DES DONNÉES (Flux, Sentiment, OI)
         futures_data = await fetch_kucoin_futures_data(symbol)
         oi, cvd = futures_data["oi"], futures_data["cvd"]
+        p_sent = await get_crypto_sentiment(symbol)
 
+        # 🧠 2. DÉTECTION DU SCÉNARIO (L'œil + L'IA)
+        # On calcule le régime via le modèle ML
         regime_scaled = regime_scaler.transform(last_row[["ATR_pct", "EMA200_slope", "Drawdown", "RSI_Macro"]])
-        regime_pred = int(regime_model.predict(regime_scaled)[0])
+        regime_ml = int(regime_model.predict(regime_scaled)[0])
         
+        # On calcule le pattern via ton nouveau détecteur (Continuation/Reversal)
+        pattern_id = detect_chart_scenario(df)
+        
+        # Priorité : Si un pattern fort (Squeeze/Reversal) est vu, il devient le Maître
+        final_scenario = pattern_id if pattern_id in [4, 5] else regime_ml
+
+        # 🧠 3. CALCUL DES PROBABILITÉS IA
         ml_cols = ["RSI", "Dist_High_24h", "Dist_Low_24h", "EMA_dist", "EMA_slope", "ATR_ratio", "VOL_ratio"]
         ml_prob = float(ml_model.predict_proba(last_row[ml_cols])[0][1])
+        
         time_cols = ['return_1h', 'return_3h', 'return_12h', 'RSI_lag1', 'RSI_lag2', 'vol_lag1', 'VOL_RATIO']
         time_prob = float(time_model.predict_proba(last_row[time_cols])[0][1])
         
@@ -294,85 +337,229 @@ async def predict_signal(symbol, timeframe="1h"):
         if dino_brain:
             try: dino_prob = float(dino_brain.predict(last_row[ml_cols].values)[0])
             except: dino_prob = 0.5
-        
-        p_sent = await get_crypto_sentiment(symbol)
 
-        # ⚡ ENSEMBLE V30
-        final_p, wt, wm, wl, ws = combine_scores(symbol, timeframe, time_prob, ml_prob, dino_prob, p_sent, regime_pred)
+        # ⚡ 4. ENSEMBLE V30 (Poids dynamiques basés sur le scénario final)
+        final_p, wt, wm, wl, ws = combine_scores(symbol, timeframe, time_prob, ml_prob, dino_prob, p_sent, final_scenario)
 
+        # 🐋 5. BOOSTS (Smart Money & Scalping)
         smc_status = "AUCUN"
+        # Boost Smart Money (CVD + Sweep)
         if int(last_row["Sweep_Low"].iloc[0]) == 1 and cvd > 0:
-            final_p = min(0.95, final_p + 0.20)
-            smc_status = "LONG SWEEP + CVD 🐋"
+            final_p = min(0.95, final_p + 0.20); smc_status = "LONG SWEEP + CVD 🐋"
         elif int(last_row["Sweep_High"].iloc[0]) == 1 and cvd < 0:
-            final_p = max(0.05, final_p - 0.20)
-            smc_status = "SHORT SWEEP + CVD 🐋"
+            final_p = max(0.05, final_p - 0.20); smc_status = "SHORT SWEEP + CVD 🐋"
             
+        # Boost Scalping (Vol Spike)
         if timeframe in ["1m", "5m"]:
             if final_p > 0.5 and vol_spike > 1.5 and rsi_9 < 70: final_p = min(0.95, final_p + 0.10)
             elif final_p < 0.5 and vol_spike > 1.5 and rsi_9 > 30: final_p = max(0.05, final_p - 0.10)
 
+        # 🛡️ 6. RÉCUPÉRATION ADN (Multi-Scénarios)
         with sqlite3.connect(DB_NAME) as conn:
-            res = conn.execute("SELECT tp_mult, sl_mult, min_prob, min_tp_dist FROM agent_logic WHERE symbol = ? AND timeframe = ?", (symbol, timeframe)).fetchone()
-            if res: tp_m, sl_m, agent_min_prob, agent_min_tp_dist = res
-            else:
-                res_fallback = conn.execute("SELECT tp_mult, sl_mult, min_prob, min_tp_dist FROM agent_logic WHERE symbol = 'ALL' AND timeframe = ?", (timeframe,)).fetchone()
-                tp_m, sl_m, agent_min_prob, agent_min_tp_dist = res_fallback if res_fallback else (1.5, 1.0, 0.55, 0.002)
-                conn.execute("INSERT OR IGNORE INTO agent_logic (symbol, timeframe, tp_mult, sl_mult, score, last_pnl, min_prob, min_tp_dist, generation, best_tp, best_sl) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", (symbol, timeframe, tp_m, sl_m, 0, 0, agent_min_prob, agent_min_tp_dist, 1, 0, 0))
+            res = conn.execute("SELECT tp_mult, sl_mult, min_prob, min_tp_dist FROM agent_logic WHERE symbol = ? AND timeframe = ? AND regime = ?", (symbol, timeframe, final_scenario)).fetchone()
+            if not res:
+                # Fallback sur l'ADN 'ALL' par défaut
+                res_def = conn.execute("SELECT tp_mult, sl_mult, min_prob, min_tp_dist FROM agent_logic WHERE symbol = 'ALL' AND timeframe = ?", (timeframe,)).fetchone()
+                tp_m, sl_m, agent_min_prob, agent_min_tp_dist = res_def if res_def else (1.5, 1.0, 0.55, 0.002)
+                # On initialise l'ADN pour ce nouveau scénario
+                conn.execute("INSERT OR IGNORE INTO agent_logic (symbol, timeframe, regime, tp_mult, sl_mult, min_prob, min_tp_dist, generation) VALUES (?, ?, ?, ?, ?, ?, ?, 1)", (symbol, timeframe, final_scenario, tp_m, sl_m, agent_min_prob, agent_min_tp_dist))
                 conn.commit()
+            else: tp_m, sl_m, agent_min_prob, agent_min_tp_dist = res
 
+        # 📐 7. CALCUL DES NIVEAUX (TP/SL)
         tp = prix + (atr * tp_m) if final_p > 0.5 else prix - (atr * tp_m)
         sl = prix - (atr * sl_m) if final_p > 0.5 else prix + (atr * sl_m)
 
+        # 📊 Stats de confiance pour le dashboard
         strength = abs(final_p - 0.5) * 2
         conf_val = max(0, min(1, 1 - np.std([time_prob, ml_prob, dino_prob, p_sent])))
-        composite_score = max(0, min(100, (strength * 45) + (conf_val * 40) + (15 if regime_pred in [0, 1] else 5)))
+        composite_score = max(0, min(100, (strength * 45) + (conf_val * 40) + (15 if final_scenario in [0, 1] else 5)))
 
-        veto, veto_reason = False, ""
+        # 🛑 8. SYSTÈME DE VÉTO (Sécurité Maximale)
         dist_tp_pct = abs(tp - prix) / prix
-        dist_fib = float(last_row["Dist_Fib_618"].iloc[0])
-        mkt_trend = float(last_row["Market_Trend"].iloc[0])
         ema200_val = float(last_row["EMA200"].iloc[0]) 
-
+        mkt_trend = float(last_row["Market_Trend"].iloc[0])
+        dist_fib = float(last_row["Dist_Fib_618"].iloc[0])
+        
+        veto, veto_reason = False, ""
         if final_p < agent_min_prob and final_p > (1 - agent_min_prob): veto, veto_reason = True, f"Confiance ({round(final_p, 2)}) < {round(agent_min_prob, 2)}"
-        elif "BTC" not in symbol and "ETH" not in symbol:
-            if final_p < 0.5 and mkt_trend > 0.002: veto, veto_reason = True, "Marché Global Haussier"
-            elif final_p > 0.5 and mkt_trend < -0.002: veto, veto_reason = True, "Marché Global Baissier"
-        elif final_p > 0.5 and dist_fib < -0.03: veto, veto_reason = True, "Support Fib 61.8 trop loin"
-        elif final_p < 0.5 and dist_fib > 0.03: veto, veto_reason = True, "Résistance Fib 61.8 trop loin"
         elif dist_tp_pct < agent_min_tp_dist: veto, veto_reason = True, "Gain potentiel trop faible"
-        elif final_p < 0.5 and (prix > ema200_val or prix > vwap): veto, veto_reason = True, "Short Interdit 🚫"
-        elif final_p > 0.5 and (prix < ema200_val or prix < vwap): veto, veto_reason = True, "Long Interdit 🚫"
+        elif final_p < 0.5 and (prix > ema200_val or prix > vwap): veto, veto_reason = True, "Short Interdit (Prix > Bull Lines)"
+        elif final_p > 0.5 and (prix < ema200_val or prix < vwap): veto, veto_reason = True, "Long Interdit (Prix < Bull Lines)"
+        elif "BTC" not in symbol and "ETH" not in symbol:
+            if final_p < 0.5 and mkt_trend > 0.002: veto, veto_reason = True, "Trend Global Haussier"
+            elif final_p > 0.5 and mkt_trend < -0.002: veto, veto_reason = True, "Trend Global Baissier"
 
         if veto:
-            return {"symbol": symbol, "timeframe": timeframe, "status": "veto", "message": veto_reason, "price": prix, "final_score": round(final_p, 4)}
+            print(f"🛑 [VETO] {symbol} (Scénario {final_scenario}): {veto_reason}")
+            return {"symbol": symbol, "timeframe": timeframe, "status": "veto", "message": veto_reason, "scenario": final_scenario}
 
-        db_task = (datetime.now(timezone.utc).isoformat(), symbol, timeframe, 'HAUSSIER' if final_p > 0.5 else 'BAISSIER', final_p, prix, tp, sl, 'EN_COURS', regime_pred, time_prob, ml_prob, dino_prob, p_sent, prix)
+        # 💾 9. ENREGISTREMENT DB ET RÉPONSE
+        db_task = (datetime.now(timezone.utc).isoformat(), symbol, timeframe, 'HAUSSIER' if final_p > 0.5 else 'BAISSIER', final_p, prix, tp, sl, 'EN_COURS', final_scenario, time_prob, ml_prob, dino_prob, p_sent, prix)
         await save_to_db(db_task)
 
         return {
             "symbol": symbol, "timeframe": timeframe, "status": "success", "final_score": round(final_p, 4), "score": int(composite_score),
-            "smart_money": smc_status, "price": prix, "tp": round(tp, 6), "sl": round(sl, 6), "regime": regime_pred, "confluence": round(conf_val * 100, 1)
+            "smart_money": smc_status, "price": prix, "tp": round(tp, 6), "sl": round(sl, 6), "scenario": final_scenario, "confluence": round(conf_val * 100, 1)
         }
     except Exception as e: return {"status": "error", "message": str(e)}
 
 # --- 🧬 FONCTION D'ÉVOLUTION ---
-def mutate_agent(symbol, timeframe, success=True):
+def mutate_agent(symbol, timeframe, regime, success=True):
+    """Mutation chirurgicale : Le bot apprend spécifiquement pour CE scénario"""
     try:
         with sqlite3.connect(DB_NAME) as conn:
             conn.row_factory = sqlite3.Row
-            row = conn.execute("SELECT * FROM agent_logic WHERE symbol = ? AND timeframe = ?", (symbol, timeframe)).fetchone()
-            if not row: return
+            # On cherche l'ADN spécifique (Symbole + TF + Regime)
+            row = conn.execute("SELECT * FROM agent_logic WHERE symbol = ? AND timeframe = ? AND regime = ?", 
+                               (symbol, timeframe, regime)).fetchone()
             
-            tp, sl, prob = row['tp_mult'], row['sl_mult'], row['min_prob']
-            if success: new_tp, new_sl, new_prob = tp * random.uniform(1.01, 1.05), sl * random.uniform(0.98, 1.00), max(0.60, prob - 0.01)
-            else: new_tp, new_sl, new_prob = tp * random.uniform(0.90, 0.98), sl * random.uniform(1.02, 1.10), min(0.85, prob + 0.02)
-                
-            conn.execute('''UPDATE agent_logic SET tp_mult = ?, sl_mult = ?, min_prob = ?, generation = generation + 1 WHERE symbol = ? AND timeframe = ?''', (new_tp, new_sl, new_prob, symbol, timeframe))
+            # Si le bot n'a jamais vu ce scénario, on crée une ligne à partir des défauts
+            if not row:
+                res_def = conn.execute("SELECT * FROM agent_logic WHERE symbol = 'ALL' AND timeframe = ?", (timeframe,)).fetchone()
+                tp, sl, prob = (res_def['tp_mult'], res_def['sl_mult'], res_def['min_prob']) if res_def else (1.5, 1.0, 0.60)
+            else:
+                tp, sl, prob = row['tp_mult'], row['sl_mult'], row['min_prob']
+            
+            # LOGIQUE DE MUTATION : Plus agressive si succès, plus prudente si échec
+            if success:
+                # On augmente le TP (On laisse courir les gains) et on réduit un peu le SL
+                new_tp, new_sl, new_prob = tp * random.uniform(1.02, 1.08), sl * random.uniform(0.97, 1.00), max(0.55, prob - 0.005)
+            else:
+                # On réduit le TP (Objectif plus proche) et on écarte le SL (Donner de l'air)
+                new_tp, new_sl, new_prob = tp * random.uniform(0.92, 0.98), sl * random.uniform(1.03, 1.12), min(0.85, prob + 0.01)
+            
+            # Mise à jour ou Insertion
+            conn.execute('''INSERT OR REPLACE INTO agent_logic 
+                            (symbol, timeframe, regime, tp_mult, sl_mult, min_prob, min_tp_dist, generation) 
+                            VALUES (?, ?, ?, ?, ?, ?, ?, COALESCE((SELECT generation FROM agent_logic WHERE symbol=? AND timeframe=? AND regime=?)+1, 1))''',
+                         (symbol, timeframe, regime, new_tp, new_sl, new_prob, 0.001, symbol, timeframe, regime))
+            conn.commit()
         
-        # ☁️ SAUVEGARDE HF APRÈS MUTATION
         backup_db_to_hf()
-    except Exception as e: print(f"🧬 Erreur Mutation : {e}")
+    except Exception as e: print(f"🧬 Erreur Mutation Scénario : {e}")
+
+
+def detect_chart_scenario(df):
+    try:
+        df = df.copy().dropna()
+
+        # ========================
+        # DATA
+        # ========================
+        last = df.tail(100)
+
+        c = last['close'].values
+        h = last['high'].values
+        l = last['low'].values
+        v = last['volume'].values
+
+        ema200 = df['EMA200']
+        ema50 = df['EMA50']
+
+        # ========================
+        # 1. VOLATILITY / SQUEEZE
+        # ========================
+        range_start = np.mean(h[:20] - l[:20])
+        range_end = np.mean(h[-20:] - l[-20:])
+
+        squeeze = range_end < range_start * 0.65
+
+        # ========================
+        # 2. TREND (EMA + STRUCTURE)
+        # ========================
+        slope_ema200 = (ema200.iloc[-1] / ema200.iloc[-50]) - 1
+        slope_ema50 = (ema50.iloc[-1] / ema50.iloc[-20]) - 1
+
+        trend_strength = abs(slope_ema200) + abs(slope_ema50)
+
+        trend_up = slope_ema200 > 0 and slope_ema50 > 0
+        trend_down = slope_ema200 < 0 and slope_ema50 < 0
+
+        # ========================
+        # 3. BREAK OF STRUCTURE (BOS)
+        # ========================
+        recent_high = np.max(h[-20:])
+        prev_high = np.max(h[-40:-20])
+
+        recent_low = np.min(l[-20:])
+        prev_low = np.min(l[-40:-20])
+
+        bos_up = recent_high > prev_high
+        bos_down = recent_low < prev_low
+
+        # ========================
+        # 4. DOUBLE TOP / BOTTOM
+        # ========================
+        top_1, top_2 = np.max(h[-30:-15]), np.max(h[-15:])
+        low_1, low_2 = np.min(l[-30:-15]), np.min(l[-15:])
+
+        double_top = abs(top_1 - top_2) / top_1 < 0.004
+        double_bottom = abs(low_1 - low_2) / low_1 < 0.004
+
+        # ========================
+        # 5. RSI (DIVERGENCE)
+        # ========================
+        if 'RSI' in df.columns:
+            rsi = df['RSI'].values
+
+            rsi_high_1 = np.max(rsi[-30:-15])
+            rsi_high_2 = np.max(rsi[-15:])
+
+            rsi_low_1 = np.min(rsi[-30:-15])
+            rsi_low_2 = np.min(rsi[-15:])
+
+            bearish_div = top_2 >= top_1 and rsi_high_2 < rsi_high_1
+            bullish_div = low_2 <= low_1 and rsi_low_2 > rsi_low_1
+        else:
+            bearish_div = bullish_div = False
+
+        # ========================
+        # 6. VOLUME ANALYSIS
+        # ========================
+        vol_recent = np.mean(v[-15:])
+        vol_past = np.mean(v[-40:-15])
+
+        volume_increasing = vol_recent > vol_past * 1.2
+        volume_dropping = vol_recent < vol_past * 0.8
+
+        # ========================
+        # 7. MOMENTUM (PRICE SPEED)
+        # ========================
+        momentum = (c[-1] / c[-10]) - 1
+
+        # ========================
+        # DECISION LOGIC
+        # ========================
+
+        # 🔥 CONTINUATION (SQUEEZE + TREND + VOLUME BUILDUP)
+        if squeeze and trend_strength > 0.004 and volume_dropping:
+            return 4
+
+        # 🔴 REVERSAL (STRUCTURE + DIVERGENCE)
+        if (double_top or bearish_div) and trend_up:
+            return 5
+
+        if (double_bottom or bullish_div) and trend_down:
+            return 5
+
+        # 🟢 STRONG TREND
+        if trend_strength > 0.006 and volume_increasing:
+            return 0 if trend_up else 1
+
+        # 🟡 BREAKOUT (BOS + VOLUME)
+        if bos_up and volume_increasing:
+            return 0
+
+        if bos_down and volume_increasing:
+            return 1
+
+        # ⚪ RANGE / CHAOS
+        return 3
+
+    except Exception as e:
+        print("Error:", e)
+        return 3
 
 # --- 🧠 TRAINING ENGINE ---
 def trigger_training(symbol="BTC/USD"):
@@ -440,21 +627,31 @@ async def dream_simulation_loop():
                         df = prepare_features_sync(symbol, timeframe=tf, limit_bars=200)
                         if df.empty or len(df) < 50: continue
                         
+                        # Simulation sur un point aléatoire du passé
                         idx = random.randint(10, len(df) - 30)
+                        # On récupère la prédiction (qui contient maintenant le 'scenario')
                         pred = await predict_signal(symbol, timeframe=tf)
+                        
                         if pred.get("status") == "success":
+                            # On récupère le scénario détecté pour la mutation
+                            current_scenario = pred.get("scenario", 3) 
+                            
                             future_data = df.iloc[idx+1 : idx+25]
                             win = False
                             for _, row in future_data.iterrows():
-                                if pred["final_score"] > 0.5:
+                                if pred["final_score"] > 0.5: # LONG
                                     if row['high'] >= pred['tp']: win = True; break
                                     if row['low'] <= pred['sl']: win = False; break
-                                else:
+                                else: # SHORT
                                     if row['low'] <= pred['tp']: win = True; break
                                     if row['high'] >= pred['sl']: win = False; break
-                            mutate_agent(symbol, tf, success=win)
+                            
+                            # ✅ CORRECTION ICI : On passe le scénario à la mutation
+                            mutate_agent(symbol, tf, current_scenario, success=win)
+                            
                         await asyncio.sleep(3) 
-                    except Exception: pass
+                    except Exception as e: 
+                        print(f"⚠️ Erreur Dream Loop: {e}")
         await asyncio.sleep(60)
 
 # --- ⚖️ TOOLS ---
@@ -482,29 +679,35 @@ def run_judge_api():
     try:
         with sqlite3.connect(DB_NAME, timeout=10) as conn: 
             conn.row_factory, cursor = sqlite3.Row, conn.cursor()
+            # On récupère tout, y compris la colonne 'regime' enregistrée à l'ouverture
             cursor.execute("SELECT * FROM signals WHERE status = 'EN_COURS' AND confirmed = 1")
             trades = cursor.fetchall()
+            
             if not trades: return {"status": "waiting"}
             closed_trades = []
+            
             for t in trades:
                 try:
                     sym_db, current_price = t['symbol'], None
+                    # --- 1. RÉCUPÉRATION PRIX TEMPS RÉEL (MT5 ou KuCoin) ---
                     if MT5_AVAILABLE:
                         epic = sym_db.replace("/", "").replace("USDT", "USD")
                         if not epic.endswith("m"): epic += "m"
                         tick = mt5.symbol_info_tick(epic)
                         if tick: current_price = tick.last
+                    
                     if current_price is None:
                         f_sym = sym_db if "/USDT" in sym_db else sym_db.replace("/USD", "/USDT")
                         if "/" not in f_sym: f_sym += "/USDT"
                         current_price = exchange_sync.fetch_ticker(f_sym)['last']
 
-                    diff = (t['price'] - current_price) if t['direction'] == 'BAISSIER' else (current_price - t['price'])
+                    # --- 2. CALCUL TRAILING STOP DYNAMIQUE ---
                     sl_dyn, peak = t['sl'], t['peak_price']
                     new_peak = max(peak, current_price) if t['direction'] == 'HAUSSIER' else min(peak, current_price)
                     progression = abs(current_price - t['price']) / abs(t['tp'] - t['price']) if abs(t['tp'] - t['price']) > 0 else 0
                     
                     nouveau_sl = sl_dyn
+                    # On sécurise les profits selon l'avancement vers le TP
                     if t['direction'] == 'HAUSSIER':
                         if progression >= 0.75: nouveau_sl = max(sl_dyn, t['price'] + (abs(t['tp'] - t['price']) * 0.60))
                         elif progression >= 0.50: nouveau_sl = max(sl_dyn, t['price'] + (abs(t['tp'] - t['price']) * 0.25))
@@ -513,6 +716,8 @@ def run_judge_api():
                         elif progression >= 0.50: nouveau_sl = min(sl_dyn, t['price'] - (abs(t['tp'] - t['price']) * 0.25))
 
                     cursor.execute("UPDATE signals SET peak_price = ?, sl = ? WHERE id = ?", (new_peak, nouveau_sl, t['id']))
+                    
+                    # --- 3. VÉRIFICATION SORTIE (TP ou SL) ---
                     outcome, reward = None, 0
                     if t['direction'] == 'HAUSSIER':
                         if current_price >= t['tp']: outcome, reward = "GAGNÉ ✅", 3
@@ -521,15 +726,22 @@ def run_judge_api():
                         if current_price <= t['tp']: outcome, reward = "GAGNÉ ✅", 3
                         elif current_price >= nouveau_sl: outcome, reward = ("GAGNÉ (PARTIEL) 💸", 1) if nouveau_sl < t['price'] else ("PERDU ❌", -5)
 
+                    # --- 4. MUTATION CHIRURGICALE (Le moment clé) ---
                     if outcome:
-                        mutate_agent(t['symbol'], t['timeframe'], success=(reward>0))
+                        # ✅ ON PASSE LE RÉGIME SPÉCIFIQUE DU TRADE !
+                        # Ça permet de muter l'ADN 'Triangle' si le trade était un 'Triangle'
+                        mutate_agent(t['symbol'], t['timeframe'], t['regime'], success=(reward > 0))
+                        
                         cursor.execute("UPDATE signals SET status=? WHERE id=?", (outcome, t['id']))
-                        closed_trades.append({"symbol": t['symbol'], "id": t['id']})
-                except: pass
+                        closed_trades.append({"symbol": t['symbol'], "id": t['id'], "outcome": outcome})
+                        
+                except Exception as inner_e:
+                    print(f"⚠️ Erreur Juge sur {t['symbol']}: {inner_e}")
+            
             conn.commit()
         return {"status": "updates", "data": closed_trades} if closed_trades else {"status": "waiting"}
-    except Exception as e: return {"status": "error", "message": str(e)}
-
+    except Exception as e: 
+        return {"status": "error", "message": str(e)}
 def training_wrapper(symbol, *args): return trigger_training(str(symbol).strip().upper() if isinstance(symbol, str) else "BTC/USD")
 def get_bot_skills():
     try: