Update app.py

app.py

@@ -19,16 +19,16 @@ from huggingface_hub import HfApi, hf_hub_download
 import gradio as gr
 import ccxt
 import time
-import sys
 from types import ModuleType
-import pandas as pd
 import yfinance as yf
+
 try:
     import MetaTrader5 as mt5
     MT5_AVAILABLE = True
 except ImportError:
     MT5_AVAILABLE = False
     print("🌐 [CLOUD MODE] MetaTrader5 non détecté. Bascule sur l'antenne de secours (CCXT).")
+
 # --- 🥷 NINJA HACK : MOCK PANDAS_TA ---
 if "pandas_ta" not in sys.modules:
     mock_ta = ModuleType("pandas_ta")
@@ -86,7 +86,7 @@ except:
 
 # --- DB & SYNC ---
 REPO_ID = "Nexo-S/AlphaV15-Quant-Engine"
-DB_NAME = "alphatrade_v22_scalp.db" # 🎮 NOUVEAU MONDE - NIVEAU 0
+DB_NAME = "alphatrade_v24_gemini.db" # 🎮 NOUVEAU MONDE V24 GEMINI
 HF_TOKEN = os.environ.get("HF_TOKEN")
 
 def init_db():
@@ -121,17 +121,7 @@ def init_db():
             cursor.execute("PRAGMA table_info(agent_logic)")
             al_cols = [col[1] for col in cursor.fetchall()]
             
-            if al_cols and 'symbol' not in al_cols:
-                print("⚠️ Migration BDD : Mise à jour de agent_logic...")
-                conn.execute("ALTER TABLE agent_logic RENAME TO agent_logic_old")
-                conn.execute('''CREATE TABLE agent_logic (
-                    symbol TEXT, timeframe TEXT, tp_mult REAL, sl_mult REAL,
-                    score REAL, last_pnl REAL, min_prob REAL, min_tp_dist REAL,
-                    PRIMARY KEY (symbol, timeframe))''')
-                conn.execute("INSERT INTO agent_logic (symbol, timeframe, tp_mult, sl_mult, score, last_pnl, min_prob, min_tp_dist) SELECT 'ALL', timeframe, tp_mult, sl_mult, score, last_pnl, min_prob, min_tp_dist FROM agent_logic_old")
-                conn.execute("DROP TABLE agent_logic_old")
-                conn.commit()
-            elif not al_cols:
+            if not al_cols:
                 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,
@@ -139,18 +129,16 @@ def init_db():
 
             cursor.execute("SELECT COUNT(*) FROM agent_logic")
             if cursor.fetchone()[0] == 0:
-                # ⚡ NOUVEAU: Defaults ultra-agressifs pour le Scalping
-                defaults = [('ALL', '1m', 1.0, 0.8, 0, 0, 0.60, 0.001), 
-                            ('ALL', '5m', 1.2, 0.9, 0, 0, 0.57, 0.002), 
-                            ('ALL', '15m', 1.5, 1.0, 0, 0, 0.55, 0.003), 
-                            ('ALL', '1h', 2.0, 1.5, 0, 0, 0.53, 0.005),
-                            ('ALL', '4h', 3.0, 2.0, 0, 0, 0.50, 0.008)]
+                defaults = [('ALL', '1m', 3.0, 1.5, 0, 0, 0.65, 0.0005), 
+                            ('ALL', '5m', 3.5, 2.0, 0, 0, 0.62, 0.0010), 
+                            ('ALL', '15m', 4.0, 2.0, 0, 0, 0.60, 0.0020), 
+                            ('ALL', '1h', 5.0, 2.5, 0, 0, 0.55, 0.0040),
+                            ('ALL', '4h', 6.0, 3.0, 0, 0, 0.50, 0.0080)]
                 conn.executemany("INSERT INTO agent_logic VALUES (?, ?, ?, ?, ?, ?, ?, ?)", defaults)
-        print("✅ Base de données Scalping (MT5 Exness) opérationnelle.")
+        print("✅ Base de données V24 GEMINI (MT5 Exness) opérationnelle.")
     except Exception as e:
         print(f"❌ Erreur critique création DB: {e}")
 
-
 async def save_to_db(data):
     try:
         with sqlite3.connect(DB_NAME) as conn:
@@ -161,19 +149,17 @@ async def save_to_db(data):
                     prob_time, prob_ml, prob_lstm, prob_sent, peak_price
                 ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)''', data)
             conn.commit()
-            print(f"💾 [DB SUCCESS] {data[1]} enregistré avec Peak Price.")
     except Exception as e: 
-        print(f"❌ DB Error (Erreur de Sauvegarde) : {e}")
+        print(f"❌ DB Error : {e}")
 
 init_db()
 
-# --- 🛡️ RAM GUARD ---
 def memory_guard():
     if psutil.virtual_memory().percent > 80:
         K.clear_session()
         gc.collect()
 
-# --- 🛠️ MOTEUR MATHS ---
+# --- 🛠️ MOTEUR MATHS V24 (GEMINI QUANT) ---
 def get_ema(series, period): return series.ewm(span=period, adjust=False).mean()
 def get_rsi(series, period=14):
     delta = series.diff()
@@ -187,7 +173,16 @@ def get_atr(df, period=14):
     l_c = (df['low'] - df['close'].shift()).abs()
     return pd.concat([h_l, h_c, l_c], axis=1).max(axis=1).rolling(period).mean()
 
-# --- 🧠 CHARGEMENT IA ---
+def get_zscore(series, period=20):
+    mean = series.rolling(period).mean()
+    std = series.rolling(period).std()
+    return (series - mean) / (std + 1e-9)
+
+def get_vwap(df):
+    v = df['vol']
+    tp = (df['high'] + df['low'] + df['close']) / 3
+    return (tp * v).cumsum() / (v.cumsum() + 1e-9)
+
 try:
     ml_model = joblib.load("ml_model_v9.pkl")
     time_model = joblib.load("time_model.pkl")
@@ -197,104 +192,73 @@ try:
     print("✅ Cerveaux opérationnels.")
 except Exception as e: print(f"⚠️ Erreur IA : {e}")
 
-# --- 📊 FEATURES ENGINE ---
-def get_vwap(df):
-    """Calcul du Volume Weighted Average Price (Outil #1 du Scalpeur)"""
-    v = df['vol']
-    tp = (df['high'] + df['low'] + df['close']) / 3
-    return (tp * v).cumsum() / v.cumsum()
-
+# --- 📊 FEATURES ENGINE V24 ---
 def prepare_features_sync(symbol, timeframe='1h', limit_bars=600):
     try:
         now = datetime.now().timestamp()
         cache_key = f"{symbol}_{timeframe}"
         
-       # --- 🛡️ GESTION DU CACHE (BIEN ALIGNÉ ICI) ---
         if cache_key in market_cache and now - last_fetch_time.get(cache_key, 0) < CACHE_DURATION:
             df = market_cache[cache_key].copy()
         else:
-            # 🟡 MODE OR (XAU) - Uniquement si XAU est dans le nom
             if "XAU" in symbol.upper():
-                import yfinance as yf
                 ticker = "GC=F" 
                 yf_map = {"1m":"1m", "5m":"5m", "15m":"15m", "1h":"1h", "4h":"1h", "1d":"1d"}
                 interval = yf_map.get(timeframe, "1h")
-                
-                # On demande 5 jours pour avoir les données du vendredi (car on est samedi !)
                 data = yf.download(ticker, period="5d", interval=interval, progress=False)
-                
-                if data.empty:
-                    print(f"😴 [XAU] Marché fermé ou pas de data.")
-                    return pd.DataFrame()
-                
-                df = data.reset_index()
-                # On sélectionne les colonnes par index pour éviter les erreurs de noms
-                df = df.iloc[:, [0, 1, 2, 3, 4, 6]] 
+                if data.empty: return pd.DataFrame()
+                df = data.reset_index().iloc[:, [0, 1, 2, 3, 4, 6]] 
                 df.columns = ['ts', 'open', 'high', 'low', 'close', 'vol']
-                
             else:
-                # 🔵 MODE CRYPTO (KUCOIN)
                 fetch_symbol = symbol if "/USDT" in symbol else symbol.replace("/USD", "/USDT")
-                if "/USDT" not in fetch_symbol and "/" not in fetch_symbol: fetch_symbol += "/USDT"
-                
+                if "/" not in fetch_symbol: fetch_symbol += "/USDT"
                 bars = exchange_sync.fetch_ohlcv(fetch_symbol, timeframe, limit=limit_bars)
                 df = pd.DataFrame(bars, columns=['ts', 'open', 'high', 'low', 'close', 'vol'])
             
             market_cache[cache_key], last_fetch_time[cache_key] = df.copy(), now
 
-        if df.empty or len(df) < 50: 
-            return pd.DataFrame()
+        if df.empty or len(df) < 50: return pd.DataFrame()
 
-        # --- FONDATIONS TECHNIQUES ---
+        # ⚡ V24 : Microtrend Acceleration
+        df["EMA9"] = get_ema(df["close"], 9)
+        df["EMA21"] = get_ema(df["close"], 21)
+        df["EMA9_slope"] = df["EMA9"].diff()
+        df["Momentum_Acc"] = df["EMA9_slope"].diff() # Dérivée Seconde (Accélération)
+
+        df["ZScore"] = get_zscore(df["close"], 20)
         df["RSI"] = get_rsi(df["close"])
-        df["RSI_9"] = get_rsi(df["close"], 9) # ⚡ NOUVEAU: RSI Nerveux pour Scalping
+        df["RSI_9"] = get_rsi(df["close"], 9)
         df["EMA50"] = get_ema(df["close"], 50)
         df["EMA200"] = get_ema(df["close"], 200)
-        df["VWAP"] = get_vwap(df)             # ⚡ NOUVEAU: Le juge de paix
+        df["VWAP"] = get_vwap(df)
         df["ATR"] = get_atr(df)
         df["ATR_pct"] = (df["ATR"] / df["close"]) * 100
         df["EMA200_slope"] = (df["EMA200"] / df["EMA200"].shift(10)) - 1
         df["Drawdown"] = (df["close"] / df["close"].rolling(14).max()) - 1
         
-        # --- DISTANCES & SLOPES ---
+        df["High_50"] = df["high"].rolling(50).max().shift(2)
+        df["Low_50"] = df["low"].rolling(50).min().shift(2)
+        df["Liquidity_Trap_Long"] = ((df["close"] < df["Low_50"]) & (df["RSI_9"] < 30)).astype(int)
+        df["Liquidity_Trap_Short"] = ((df["close"] > df["High_50"]) & (df["RSI_9"] > 70)).astype(int)
+
         df["High_24h"], df["Low_24h"] = df["high"].rolling(24).max(), df["low"].rolling(24).min()
         df["Dist_High_24h"] = (df["High_24h"] - df["close"]) / df["close"]
         df["Dist_Low_24h"] = (df["close"] - df["Low_24h"]) / df["close"]
         df["EMA_dist"] = (df["close"] - df["EMA50"]) / df["EMA50"]
         df["EMA_slope"] = (df["EMA50"] / df["EMA50"].shift(5)) - 1
-        df["Price_vs_VWAP"] = (df["close"] - df["VWAP"]) / df["VWAP"] # ⚡ Distance au VWAP
+        df["Price_vs_VWAP"] = (df["close"] - df["VWAP"]) / df["VWAP"]
         df["ATR_ratio"] = df["ATR"] / df["close"]
-        df["VOL_ratio"] = df["vol"] / df["vol"].rolling(24).mean()
-        df["Vol_Spike"] = df["vol"] / df["vol"].rolling(5).mean()     # ⚡ NOUVEAU: Explosion de volume
+        df["VOL_ratio"] = df["vol"] / (df["vol"].rolling(24).mean() + 1e-9)
+        df["Vol_Spike"] = df["vol"] / (df["vol"].rolling(5).mean() + 1e-9)
         
-        # --- SMC & FIBO ---
         diff = df["High_24h"] - df["Low_24h"]
         df["Fib_618"] = df["Low_24h"] + (diff * 0.618)
         df["Dist_Fib_618"] = (df["close"] - df["Fib_618"]) / df["close"]
-        df["FVG_bull"] = (df['low'] > df['high'].shift(2)).astype(int)
-        df["FVG_bear"] = (df['high'] < df['low'].shift(2)).astype(int)
-
-        if "BTC" not in symbol and "ETH" not in symbol:
-            try:
-                b_bars = exchange_sync.fetch_ohlcv("BTC/USD", timeframe, limit=50)
-                e_bars = exchange_sync.fetch_ohlcv("ETH/USD", timeframe, limit=50)
-                b_c = pd.Series([b[4] for b in b_bars])
-                e_c = pd.Series([e[4] for e in e_bars])
-                b_slope = (b_c.ewm(span=50).mean().iloc[-1] / b_c.ewm(span=50).mean().iloc[-6]) - 1
-                e_slope = (e_c.ewm(span=50).mean().iloc[-1] / e_c.ewm(span=50).mean().iloc[-6]) - 1
-                df["Market_Trend"] = (b_slope * 0.6) + (e_slope * 0.4)
-            except: df["Market_Trend"] = 0
-        else:
-            df["Market_Trend"] = df["EMA200_slope"]
+        df["Market_Trend"] = df["EMA200_slope"]
 
-        p_low, p_high = df["low"].rolling(24).min().shift(1), df["high"].rolling(24).max().shift(1)
-        df["Sweep_Low"] = ((df["low"] < p_low) & (df["close"] > p_low)).astype(int)
-        df["Sweep_High"] = ((df["high"] > p_high) & (df["close"] < p_high)).astype(int)
-        
-        # --- FEATURES POUR LES MODELES ---
         df['return_1h'], df['return_3h'], df['return_12h'] = df['close'].pct_change(1), df['close'].pct_change(3), df['close'].pct_change(12)
         df['RSI_lag1'], df['RSI_lag2'] = df["RSI"].shift(1), df["RSI"].shift(2)
-        df['VOL_RATIO'] = df['vol'] / df['vol'].rolling(20).mean()
+        df['VOL_RATIO'] = df['vol'] / (df['vol'].rolling(20).mean() + 1e-9)
         df['vol_lag1'], df['RSI_Macro'] = df['vol'].shift(1), df["RSI"]
 
         return df.dropna().copy()
@@ -306,117 +270,157 @@ async def predict_signal(symbol, timeframe="1h"):
         symbol = str(symbol).strip().upper()
         
         df = prepare_features_sync(symbol, timeframe)
-        if df.empty: return {"status": "error", "message": f"Data insuffisante pour {timeframe}"}
+        if df.empty: return {"status": "error", "message": f"Data insuffisante"}
         
         last_row = df.iloc[[-1]]
         prix, atr = float(last_row['close'].iloc[0]), float(last_row['ATR'].iloc[0])
-        vwap = float(last_row['VWAP'].iloc[0])           # ⚡ Extraction VWAP
-        vol_spike = float(last_row['Vol_Spike'].iloc[0]) # ⚡ Extraction Spike
-        rsi_9 = float(last_row['RSI_9'].iloc[0])         # ⚡ Extraction RSI Rapide
+        vwap = float(last_row['VWAP'].iloc[0])           
+        vol_spike = float(last_row['Vol_Spike'].iloc[0]) 
+        rsi_9 = float(last_row['RSI_9'].iloc[0])         
         
-        # --- 🧠 CERVEAUX IA ---
+        z_score = float(last_row['ZScore'].iloc[0])
+        ema9, ema21 = float(last_row['EMA9'].iloc[0]), float(last_row['EMA21'].iloc[0])
+        micro_trend_acc = float(last_row['Momentum_Acc'].iloc[0]) # V24 Accélération
+        liq_trap_long = int(last_row['Liquidity_Trap_Long'].iloc[0])
+        liq_trap_short = int(last_row['Liquidity_Trap_Short'].iloc[0])
+        volatility_pct = float(last_row["ATR_pct"].iloc[0])
+
+        regime_state = "RANGE"
+        if volatility_pct > 0.8: regime_state = "CHAOS"
+        elif volatility_pct > 0.2: regime_state = "TREND"
+
+        micro_trend = 1 if ema9 > ema21 else -1
+
+        fetch_symbol = symbol if "/USDT" in symbol else symbol.replace("/USD", "/USDT")
+        if "/" not in fetch_symbol: fetch_symbol += "/USDT"
+        
+        # 🧱 V24: ORDERBOOK ENGINE (IMBALANCE)
+        imbalance = 1.0
+        try:
+            orderbook = exchange_sync.fetch_order_book(fetch_symbol, limit=20)
+            bids_vol = sum([b[1] for b in orderbook['bids']])
+            asks_vol = sum([a[1] for a in orderbook['asks']])
+            imbalance = bids_vol / (asks_vol + 1e-9)
+        except Exception as e: pass
+
+        # 🌊 V24: LIQUIDATION ENGINE (FUNDING RATE)
+        funding_rate = 0.0
+        try:
+            funding = exchange_sync.fetch_funding_rate(fetch_symbol)
+            if funding and 'fundingRate' in funding:
+                funding_rate = float(funding['fundingRate'])
+        except Exception as e: pass
+
+        # 🩸 LECTURE DU SPREAD RÉEL
+        try:
+            ticker = exchange_sync.fetch_ticker(fetch_symbol)
+            spread = (ticker['ask'] - ticker['bid']) if ticker.get('ask') and ticker.get('bid') else (prix * 0.0002)
+            if spread <= 0: spread = prix * 0.0002
+        except:
+            spread = prix * 0.0002 
+
+        # --- CERVEAUX IA ---
         regime_scaled = regime_scaler.transform(last_row[["ATR_pct", "EMA200_slope", "Drawdown", "RSI_Macro"]])
         regime_pred = int(regime_model.predict(regime_scaled)[0])
-        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])
+        ml_prob = float(ml_model.predict_proba(last_row[["RSI", "Dist_High_24h", "Dist_Low_24h", "EMA_dist", "EMA_slope", "ATR_ratio", "VOL_ratio"]])[0][1])
+        time_prob = float(time_model.predict_proba(last_row[['return_1h', 'return_3h', 'return_12h', 'RSI_lag1', 'RSI_lag2', 'vol_lag1', 'VOL_RATIO']])[0][1])
+        
         lstm_data = df[["close","RSI","EMA50","EMA200","ATR"]].iloc[-30:]
         lstm_data = (lstm_data - lstm_data.mean()) / (lstm_data.std() + 1e-9)
         lstm_prob = float(lstm_brain.predict(np.expand_dims(lstm_data.values, axis=0), verbose=0)[0][0])
         p_sent = await get_crypto_sentiment(symbol)
 
-        # --- ⚖️ PONDÉRATION ADAPTATIVE (FOCUS MOMENTUM SCALPING) ---
-        if timeframe in ["1m", "5m", "15m"]: 
-            wt, wm, wl, ws = 0.50, 0.25, 0.15, 0.10 # On fait confiance au TimeModel pour la vitesse
-        elif timeframe in ["1h", "4h", "1d"]: 
-            wl, wm, wt, ws = 0.60, 0.15, 0.15, 0.10
-        else: 
-            wt, wm, wl, ws = 0.25, 0.25, 0.25, 0.25
-
+        if timeframe in ["1m", "5m"]: wt, wm, wl, ws = 0.50, 0.25, 0.15, 0.10
+        else: wt, wm, wl, ws = 0.30, 0.30, 0.25, 0.15
         final_p = (time_prob * wt) + (ml_prob * wm) + (lstm_prob * wl) + (p_sent * ws)
 
-        # --- 🐋 BONUS SMART MONEY & SCALPING NITRO ---
-        sweep_low, sweep_high = int(last_row["Sweep_Low"].iloc[0]), int(last_row["Sweep_High"].iloc[0])
+        # --- 🐋 SMART MONEY, IMBALANCE & THANOS BOOSTS ---
         smc_status = "AUCUN"
-        if sweep_low == 1:
-            final_p = min(0.95, final_p + 0.20)
-            smc_status = "LONG SWEEP 🐋"
-        elif sweep_high == 1:
-            final_p = max(0.05, final_p - 0.20)
-            smc_status = "SHORT SWEEP 🐋"
-            
-        # ⚡ NITRO SCALPING : Si on a un pic de volume dans le sens de la tendance
-        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) # Coup de boost à l'achat
-            elif final_p < 0.5 and vol_spike > 1.5 and rsi_9 > 30:
-                final_p = max(0.05, final_p - 0.10) # Coup de boost à la vente
-
-        # --- 🛡️ CALCUL TP/SL (BASE DE DONNÉES ISOLÉE) ---
+        
+        if liq_trap_long == 1:
+            final_p = min(0.95, final_p + 0.25)
+            smc_status = "LIQUIDITY TRAP (LONG) 🐋"
+        elif liq_trap_short == 1:
+            final_p = max(0.05, final_p - 0.25)
+            smc_status = "LIQUIDITY TRAP (SHORT) 🐋"
+
+        if regime_state == "RANGE":
+            if z_score < -2.0 and prix < vwap: 
+                final_p = min(0.90, final_p + 0.15)
+                smc_status = "Z-SCORE REVERSION (LONG) 🎯"
+            elif z_score > 2.0 and prix > vwap:
+                final_p = max(0.10, final_p - 0.15)
+                smc_status = "Z-SCORE REVERSION (SHORT) 🎯"
+
+        # V24: Imbalance Boost
+        if imbalance > 2.0 and final_p > 0.5:
+            final_p = min(0.95, final_p + 0.15)
+            smc_status = "BID WALL (ACHAT) 🧱"
+        elif imbalance < 0.5 and final_p < 0.5:
+            final_p = max(0.05, final_p - 0.15)
+            smc_status = "ASK WALL (VENTE) 🧱"
+
+        # --- 🛡️ CALCUL TP/SL V24 (LE PÉAGE EXNESS) ---
+        commission_estimee = prix * 0.0001  # 0.01%
+        slippage_estime = prix * 0.00015    # 0.015%
+        cost_buffer = spread + commission_estimee + slippage_estime
+
         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
+            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) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", 
-                             (symbol, timeframe, tp_m, sl_m, 0, 0, agent_min_prob, agent_min_tp_dist))
-                conn.commit()
-
-        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)
-
-        # Scores et Regimes
-        strength = abs(final_p - 0.5) * 2
-        conf_val = max(0, min(1, 1 - np.std([time_prob, ml_prob, lstm_prob, p_sent])))
-        score_base = (strength * 45) + (conf_val * 40)
-        regime_bonus = 15 if regime_pred in [0, 1] else 5
-        composite_score = max(0, min(100, score_base + regime_bonus))
-
-        # ==========================================
-        # 🛑 LE VETO DYNAMIQUE (BOUCLIER EMA200 + VWAP)
-        # ==========================================
+                tp_m, sl_m, agent_min_prob, agent_min_tp_dist = res_fallback if res_fallback else (3.0, 1.5, 0.65, 0.0005)
+
+        tp_distance = max(cost_buffer * tp_m * 2, prix * 0.0005) 
+        sl_distance = max(cost_buffer * sl_m * 1.5, prix * 0.0003) 
+
+        tp = prix + tp_distance if final_p > 0.5 else prix - tp_distance
+        sl = prix - sl_distance if final_p > 0.5 else prix + sl_distance
+
+        # --- 🛑 LE VETO DYNAMIQUE V24 ---
         veto = False
         veto_reason = ""
         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]) 
 
         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 regime_state == "CHAOS":
+            veto, veto_reason = True, "Régime CHAOS (Risque Imprévisible)"
+        elif regime_state == "TREND" and ((final_p > 0.5 and micro_trend == -1) or (final_p < 0.5 and micro_trend == 1)):
+            veto, veto_reason = True, "Contre la Micro-Tendance (EMA9/21)"
         
-        # 🛡️ LE GARDE-FOU ABSOLU (Interdiction stricte de contrer le TGV institutionnel)
-        elif final_p < 0.5 and (prix > ema200_val or prix > vwap): 
-            veto, veto_reason = True, "Garde-Fou: Prix > EMA200/VWAP (Short Interdit 🚫)"
-        elif final_p > 0.5 and (prix < ema200_val or prix < vwap): 
-            veto, veto_reason = True, "Garde-Fou: Prix < EMA200/VWAP (Long Interdit 🚫)"
+        # V24: Veto Accélération
+        elif final_p > 0.5 and micro_trend_acc < 0:
+            veto, veto_reason = True, "Momentum Acheteur en décélération"
+        elif final_p < 0.5 and micro_trend_acc > 0:
+            veto, veto_reason = True, "Momentum Vendeur en décélération"
+
+        # V24: Veto Funding Rate (Anti-Liquidation)
+        elif final_p > 0.5 and funding_rate > 0.001:
+            veto, veto_reason = True, "Surchauffe Longs (Risque Liquidation)"
+        elif final_p < 0.5 and funding_rate < -0.001:
+            veto, veto_reason = True, "Surchauffe Shorts (Risque Squeeze)"
+
+        elif dist_tp_pct < agent_min_tp_dist: 
+            veto, veto_reason = True, f"Gain potentiel faible vs Péage Broker"
 
         if veto:
-            print(f"🛑 [VETO] {symbol}: {veto_reason}")
+            print(f"🛑 [VETO] {symbol} ({regime_state}): {veto_reason}")
             return {"symbol": symbol, "timeframe": timeframe, "status": "veto", "message": veto_reason, "price": prix, "final_score": round(final_p, 4)}
 
-        # 7. Sauvegarde DB
         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, lstm_prob, p_sent, prix)
         await save_to_db(db_task)
 
+        confidence_score = abs(final_p - 0.5) * 2
+
         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),
+            "final_score": round(final_p, 4), "confidence": round(confidence_score, 2),
+            "smart_money": smc_status, "regime_state": regime_state, "price": prix, 
+            "tp": round(tp, 6), "sl": round(sl, 6),
             "probs": {"xgb": round(time_prob, 3), "rf": round(ml_prob, 3), "lstm": round(lstm_prob, 3), "sent": round(p_sent, 3)}
         }
     except Exception as e:
@@ -427,36 +431,22 @@ def trigger_training(symbol="SOL/USD"):
     try:
         print(f"⚙️ Tentative d'entraînement pour {symbol}...")
         memory_guard()
-        
         bars = exchange_sync.fetch_ohlcv(symbol, timeframe='1h', limit=1500)
         df = pd.DataFrame(bars, columns=['ts', 'open', 'high', 'low', 'close', 'vol'])
-        
-        if len(df) < 500:
-            return f"❌ Erreur : Historique insuffisant pour {symbol} ({len(df)}/500 min)."
-
+        if len(df) < 500: return f"❌ Historique insuffisant."
         df_final = prepare_features_sync(symbol, '1h', limit_bars=1000)
         
-        if df_final.empty or len(df_final) < 100:
-            return f"❌ Erreur : Données vides après calcul des indicateurs techniques."
-
-        print("🔍 DIAGNOSTIC DES COLONNES VIDES (NaN) :")
-        print(df_final.isna().sum())
-
         from ml_model import train_model as train_ml
         from time_model import train_time_model as train_time
-        
         train_ml(df_final)
         train_time(df_final)
         
         global ml_model, time_model
         ml_model = joblib.load("ml_model_v9.pkl")
         time_model = joblib.load("time_model.pkl")
-        
         gc.collect()
-        return f"✅ IA ré-entraînée avec succès ({len(df_final)} échantillons)."
-
-    except Exception as e:
-        return f"❌ Erreur Training : {str(e)}"
+        return f"✅ IA ré-entraînée avec succès."
+    except Exception as e: return f"❌ Erreur Training : {str(e)}"
 
 # --- 🚀 MOTEUR AUTO-PILOTE ---
 AUTO_SYMBOLS = ["ETH/USD"]
@@ -465,247 +455,148 @@ AUTO_TIMEFRAMES = ["1m", "5m", "15m", "1h"]
 async def auto_predict_loop():
     while True:
         try:
-            print(f"🤖 [AUTO-PILOTE] Scan des marchés...")
             with sqlite3.connect(DB_NAME) as conn:
                 cursor = conn.cursor()
                 for symbol in AUTO_SYMBOLS:
                     for tf in AUTO_TIMEFRAMES:
-                        cursor.execute("""
-                            SELECT id FROM signals 
-                            WHERE symbol = ? AND timeframe = ? AND status = 'EN_COURS'
-                        """, (symbol, tf))
-                        
-                        if cursor.fetchone():
-                            continue 
-                        
+                        cursor.execute("SELECT id FROM signals WHERE symbol = ? AND timeframe = ? AND status = 'EN_COURS'", (symbol, tf))
+                        if cursor.fetchone(): continue 
                         print(f"🎯 [AUTO] Nouvelle analyse : {symbol} [{tf}]")
                         await predict_signal(symbol, timeframe=tf)
                         await asyncio.sleep(2) 
-                        
-            print("✅ [AUTO-PILOTE] Scan terminé. Repos...")
             await asyncio.sleep(60) 
-            
         except Exception as e:
-            print(f"⚠️ Erreur critique Auto-Pilote : {e}")
+            print(f"⚠️ Erreur Auto-Pilote : {e}")
             await asyncio.sleep(60)
 
 # --- ⚖️ TOOLS ---
-def keep_alive_ping():
-    return {"status": "awake", "time": datetime.now(timezone.utc).isoformat()}
+def keep_alive_ping(): return {"status": "awake", "time": datetime.now(timezone.utc).isoformat()}
 
 def confirm_trade_api(trade_id, real_price):
     try:
-        t_id = int(trade_id)
-        r_price = float(real_price)
-        
+        t_id, r_price = int(trade_id), float(real_price)
         with sqlite3.connect(DB_NAME) as conn:
             conn.row_factory = sqlite3.Row
             cursor = conn.cursor()
-            
-            # 1. On récupère les données Kucoin (théoriques)
             cursor.execute("SELECT price, tp, sl FROM signals WHERE id = ?", (t_id,))
             t = cursor.fetchone()
-            
-            if not t: return {"status": "error", "message": "Signal non trouvé"}
-
-            # 2. On calcule l'écart (ex: +10$)
+            if not t: return {"status": "error"}
             ecart = r_price - t['price']
-            
-            # 3. On décale le TP et le SL du même montant pour garder le même profit cible
-            nouveau_tp = t['tp'] + ecart
-            nouveau_sl = t['sl'] + ecart
-            
-            # 4. On met à jour la DB avec les chiffres RÉELS de Capital.com
-            cursor.execute("""
-                UPDATE signals 
-                SET confirmed = 1, price = ?, tp = ?, sl = ?, peak_price = ? 
-                WHERE id = ?
-            """, (r_price, nouveau_tp, nouveau_sl, r_price, t_id))
-            
+            cursor.execute("UPDATE signals SET confirmed = 1, price = ?, tp = ?, sl = ?, peak_price = ? WHERE id = ?", 
+                           (r_price, t['tp'] + ecart, t['sl'] + ecart, r_price, t_id))
             conn.commit()
-            
-        print(f"⚓ [SYNC-PRIX] Signal {t_id} aligné sur Capital.com : Entrée {r_price}")
-        return {"status": "success", "message": f"Prix aligné à {r_price}"}
-    except Exception as e:
-        return {"status": "error", "message": str(e)}
+        print(f"⚓ [SYNC-PRIX] Signal {t_id} aligné sur Exness : Entrée {r_price}")
+        return {"status": "success"}
+    except Exception as e: return {"status": "error", "message": str(e)}
 
 def cancel_trade_api(trade_id):
     try:
-        t_id = int(trade_id)
         with sqlite3.connect(DB_NAME) as conn:
-            cursor = conn.cursor()
-            # On passe le statut en ANNULÉ pour que le bot ne le retente plus jamais
-            cursor.execute("UPDATE signals SET status = 'ANNULÉ 🗑️', confirmed = 0 WHERE id = ?", (t_id,))
+            conn.execute("UPDATE signals SET status = 'ANNULÉ 🗑️', confirmed = 0 WHERE id = ?", (int(trade_id),))
             conn.commit()
-            
-        print(f"🧹 [CLEANUP] Signal {t_id} annulé suite à une erreur Broker (Sécurité anti-péremption).")
-        return {"status": "success", "message": f"Signal {t_id} détruit."}
-    except Exception as e:
-        return {"status": "error", "message": str(e)}
-        
-async def check_data_count(symbol):
-    try:
-        ex = ExchangeManager.get_instance()
-        bars = await ex.fetch_ohlcv(symbol, timeframe='1h', limit=1000)
-        count = len(bars)
-        needed = 250
-        percent = min(100, (count / needed) * 100)
-        return {"count": count, "percent": round(percent, 1), "needed": needed}
-    except Exception as e:
-        return {"status": "error", "message": str(e)}
+        return {"status": "success"}
+    except Exception: return {"status": "error"}
 
 def run_judge_api():
     try:
-        # ⚡ AJOUT DU TIMEOUT POUR ÉVITER LE VERROUILLAGE
         with sqlite3.connect(DB_NAME, timeout=10) as conn: 
             conn.row_factory = sqlite3.Row
             cursor = conn.cursor()
-            
             cursor.execute("SELECT * FROM signals WHERE status = 'EN_COURS' AND confirmed = 1")
             trades = cursor.fetchall()
-            
-            if not trades: 
-                return {"status": "waiting", "message": "⚖️ Observation du marché en cours..."}
+            if not trades: return {"status": "waiting"}
 
             closed_trades = []
             for t in trades:
                 try:
-                    # --- 🛰️ SYNC PRIX HYBRIDE (NOUVEAU) ---
-                    symbol_db = t['symbol']
                     current_price = None
-                    
-                    # 1. Tentative locale avec MT5 (Exness)
                     if MT5_AVAILABLE:
-                        epic = symbol_db.replace("/", "").replace("USDT", "USD")
+                        epic = t['symbol'].replace("/", "").replace("USDT", "USD")
                         if not epic.endswith("m"): epic += "m"
                         tick = mt5.symbol_info_tick(epic)
                         if tick: current_price = tick.last
                     
-                    # 2. Tentative Cloud avec CCXT (Kucoin) si MT5 échoue
                     if current_price is None:
-                        fetch_symbol = symbol_db if "/USDT" in symbol_db else symbol_db.replace("/USD", "/USDT")
+                        fetch_symbol = t['symbol'] if "/USDT" in t['symbol'] else t['symbol'].replace("/USD", "/USDT")
                         if "/" not in fetch_symbol: fetch_symbol += "/USDT"
-                        ticker = exchange_sync.fetch_ticker(fetch_symbol)
-                        current_price = ticker['last']
+                        current_price = exchange_sync.fetch_ticker(fetch_symbol)['last']
 
-                    # --- 📊 DASHBOARD LIVE PNL (CONSERVÉ) ---
                     lots = 0.1 
                     diff = (t['price'] - current_price) if t['direction'] == 'BAISSIER' else (current_price - t['price'])
                     pnl_live = diff * lots * 10 
-                    
-                    status_mode = "🏠 LOCAL" if MT5_AVAILABLE else "🌐 CLOUD"
                     color = "🟢" if pnl_live >= 0 else "🔴"
-                    print(f"{color} [{status_mode}] {symbol_db} | PnL: {round(pnl_live, 2)}$ | Prix: {current_price}")
+                    print(f"{color} [LIVE] {t['symbol']} | PnL: {round(pnl_live, 2)}$ | Prix: {current_price}")
 
-                    # --- 🚀 LOGIQUE TRAILING STOP (CONSERVÉE À 100%) ---
-                    sl_dynamique = t['sl']
-                    peak = t['peak_price']
+                    sl_dynamique, peak = t['sl'], t['peak_price']
                     new_peak = max(peak, current_price) if t['direction'] == 'HAUSSIER' else min(peak, current_price)
-                    
                     chemin_total = abs(t['tp'] - t['price'])
-                    chemin_parcouru = abs(current_price - t['price'])
-                    progression = chemin_parcouru / chemin_total if chemin_total > 0 else 0
+                    progression = abs(current_price - t['price']) / chemin_total if chemin_total > 0 else 0
                     
                     nouveau_sl = sl_dynamique
-                    
-                    # --- 🛡️ TA STRATÉGIE DE L'ÉTAU (CONSERVÉE À 100%) ---
                     if t['direction'] == 'HAUSSIER':
                         if progression >= 0.75: nouveau_sl = max(sl_dynamique, t['price'] + (chemin_total * 0.60))
                         elif progression >= 0.50: nouveau_sl = max(sl_dynamique, t['price'] + (chemin_total * 0.25))
                         elif progression >= 0.25: nouveau_sl = max(sl_dynamique, t['price'] + (chemin_total * 0.05))
-                    else: # BAISSIER (SELL)
+                    else:
                         if progression >= 0.75: nouveau_sl = min(sl_dynamique, t['price'] - (chemin_total * 0.60))
                         elif progression >= 0.50: nouveau_sl = min(sl_dynamique, t['price'] - (chemin_total * 0.25))
                         elif progression >= 0.25: nouveau_sl = min(sl_dynamique, t['price'] - (chemin_total * 0.05))
 
-                    sl_dynamique = nouveau_sl
-                    cursor.execute("UPDATE signals SET peak_price = ?, sl = ? WHERE id = ?", (new_peak, sl_dynamique, t['id']))
+                    cursor.execute("UPDATE signals SET peak_price = ?, sl = ? WHERE id = ?", (new_peak, nouveau_sl, t['id']))
 
-                    # --- 🏁 VÉRIFICATION DU RÉSULTAT (CONSERVÉE À 100%) ---
-                    outcome = None
-                    reward = 0
+                    outcome, reward = None, 0
                     if t['direction'] == 'HAUSSIER':
                         if current_price >= t['tp']: outcome, reward = "GAGNÉ ✅", 3
-                        elif current_price <= sl_dynamique: 
-                            outcome, reward = ("GAGNÉ (PARTIEL) 💸", 1) if sl_dynamique > t['price'] else ("PERDU ❌", -5)
-                    else: # BAISSIER
+                        elif current_price <= nouveau_sl: outcome, reward = ("GAGNÉ (PARTIEL) 💸", 1) if nouveau_sl > t['price'] else ("PERDU ❌", -5)
+                    else:
                         if current_price <= t['tp']: outcome, reward = "GAGNÉ ✅", 3
-                        elif current_price >= sl_dynamique: 
-                            outcome, reward = ("GAGNÉ (PARTIEL) 💸", 1) if sl_dynamique < t['price'] else ("PERDU ❌", -5)
+                        elif current_price >= nouveau_sl: outcome, reward = ("GAGNÉ (PARTIEL) 💸", 1) if nouveau_sl < t['price'] else ("PERDU ❌", -5)
 
                     if outcome:
-                        # --- 🪞 TA VÉRITÉ BRUTALE (CONSERVÉE À 100%) ---
-                        taille_position_virtuelle = 1000.0
-                        spread_commission_estimee = 0.25 
-                        pnl_brut = ((abs(current_price - t['price'])) / t['price']) * taille_position_virtuelle
-                        pnl_dollars = pnl_brut - spread_commission_estimee
-                        
+                        pnl_brut = ((abs(current_price - t['price'])) / t['price']) * 1000.0
+                        pnl_dollars = pnl_brut - 0.25 
                         if outcome == "SL TOUCHÉ 🛡️" and pnl_dollars < 0: outcome = "TUÉ PAR LE SPREAD/COMM 🩸"
                         elif outcome == "GAGNÉ (PARTIEL) 💸" and pnl_dollars <= 0: outcome = "FAUX GAIN (FRAIS EXNESS) 📉" 
 
-                        # --- 🎮 TA LOGIQUE ÉVOLUTION RPG (CONSERVÉE À 100%) ---
-                        cursor.execute("SELECT tp_mult, sl_mult, score, min_prob FROM agent_logic WHERE symbol = ? AND timeframe = ?", (t['symbol'], t['timeframe']))
-                        row = cursor.fetchone()
+                        row = cursor.execute("SELECT tp_mult, sl_mult, score, min_prob FROM agent_logic WHERE symbol = ? AND timeframe = ?", (t['symbol'], t['timeframe'])).fetchone()
                         tp_m, sl_m, score_ia, min_p = (row['tp_mult'], row['sl_mult'], row['score'], row['min_prob']) if row else (1.5, 1.0, 0, 0.55)
 
-                        if reward > 0:
-                            tp_m, min_p = min(4.0, tp_m * 1.01), max(0.50, min_p - 0.005) 
-                        elif reward < 0:
-                            sl_m, tp_m, min_p = max(0.8, sl_m * 0.985), max(1.1, tp_m * 0.985), min(0.65, min_p + 0.01) 
+                        if reward > 0: tp_m, min_p = min(4.0, tp_m * 1.01), max(0.50, min_p - 0.005) 
+                        elif reward < 0: sl_m, tp_m, min_p = max(0.8, sl_m * 0.985), max(1.1, tp_m * 0.985), min(0.65, min_p + 0.01) 
 
-                        cursor.execute("UPDATE agent_logic SET tp_mult=?, sl_mult=?, score=score+?, min_prob=? WHERE symbol=? AND timeframe=?",
-                                       (tp_m, sl_m, reward, min_p, t['symbol'], t['timeframe']))
+                        cursor.execute("UPDATE agent_logic SET tp_mult=?, sl_mult=?, score=score+?, min_prob=? WHERE symbol=? AND timeframe=?", (tp_m, sl_m, reward, min_p, t['symbol'], t['timeframe']))
                         cursor.execute("UPDATE signals SET status=? WHERE id=?", (outcome, t['id']))
-                        
-                        closed_trades.append({
-                            "symbol": t['symbol'], "timeframe": t['timeframe'], "direction": t['direction'],
-                            "outcome": outcome, "pnl": round(pnl_dollars, 2)
-                        })
-
-                except Exception as inner_e:
-                    print(f"⚠️ Erreur sur {t['symbol']} : {inner_e}")
-            
+                        closed_trades.append({"symbol": t['symbol'], "outcome": outcome, "pnl": round(pnl_dollars, 2), "id": t['id']})
+
+                except Exception as inner_e: print(f"⚠️ Erreur sur {t['symbol']} : {inner_e}")
             conn.commit()
             
         if closed_trades: return {"status": "updates", "data": closed_trades}
-        return {"status": "waiting", "message": "monitoring..."}
-        
-    except Exception as e:
-        return {"status": "error", "message": str(e)}
-        
-async def shutdown():
-    ex = ExchangeManager.get_instance()
-    await ex.close()
+        return {"status": "waiting"}
+    except Exception as e: return {"status": "error", "message": str(e)}
 
-# --- 🏗️ WRAPPER DE SÉCURITÉ ---
 def training_wrapper(symbol, *args):
-    if not isinstance(symbol, str) or len(str(symbol)) < 2:
-        symbol = "BTC/USD"
-    symbol = str(symbol).strip().upper()
-    return trigger_training(symbol)
+    if not isinstance(symbol, str) or len(str(symbol)) < 2: symbol = "BTC/USD"
+    return trigger_training(str(symbol).strip().upper())
 
-def get_rpg_stats():
-    """Récupère la fiche de personnage de l'IA pour Discord (Mise à jour V12)"""
+def get_bot_skills():
     try:
         with sqlite3.connect(DB_NAME) as conn:
             cursor = conn.cursor()
-            # On trie par Symbole pour que ce soit lisible sur Discord
-            cursor.execute("SELECT symbol, timeframe, tp_mult, sl_mult, min_prob, score FROM agent_logic ORDER BY symbol, timeframe")
-            rows = cursor.fetchall()
-            
-            if not rows: return "Aucune stat trouvée."
-            
-            report = []
-            for r in rows:
-                sym, tf, tp, sl, peur, score = r[0], r[1], round(r[2],2), round(r[3],2), round(r[4]*100), int(r[5])
-                report.append(f"[{sym} | {tf}] 🗡️ TP: x{tp} | 🛡️ SL: x{sl} | 😨 Peur: {peur}% | 🏆 Score: {score}")
-            return "\n".join(report)
-    except Exception as e:
-        return f"Erreur DB : {e}"
+            cursor.execute("SELECT symbol, timeframe, tp_mult, sl_mult, score, min_prob FROM agent_logic ORDER BY score DESC")
+            return [[r[0], r[1], f"x{round(r[2], 2)}", f"x{round(r[3], 2)}", f"{r[4]} XP", f"{round(r[5] * 100, 1)}%"] for r in cursor.fetchall()]
+    except Exception as e: return [[f"Erreur: {str(e)}", "-", "-", "-", "-", "-"]]
+
+def force_scalping_mode():
+    try:
+        with sqlite3.connect(DB_NAME) as conn:
+            conn.execute("UPDATE agent_logic SET tp_mult = 1.8")
+            conn.commit()
+        return get_bot_skills()
+    except Exception as e: return [[f"Erreur: {str(e)}", "-", "-", "-", "-", "-"]]
 
 def get_active_signals():
     try:
-        # ⚡ AJOUT DU TIMEOUT POUR ÉVITER LE VERROUILLAGE
         conn = sqlite3.connect(DB_NAME, timeout=10) 
         conn.row_factory = sqlite3.Row
         cursor = conn.cursor()
@@ -713,232 +604,57 @@ def get_active_signals():
         trades = [dict(row) for row in cursor.fetchall()]
         conn.close()
         return trades
-    except Exception as e:
-        print(f"❌ [API CRITIQUE] Erreur lecture BDD : {e}") # ⚡ ON AFFICHE L'ERREUR
-        return []
-
-# --- 📊 SYSTEME DE STATISTIQUES POUR DISCORD ---
-def get_db_stats(action, symbol=""):
-    try:
-        conn = sqlite3.connect(DB_NAME)
-        conn.row_factory = sqlite3.Row
-        cursor = conn.cursor()
-        
-        if action == "active":
-            cursor.execute("SELECT * FROM signals WHERE status = 'EN_COURS'")
-            return [dict(r) for r in cursor.fetchall()]
-            
-        elif action in ["global", "summary"]:
-            cursor.execute("SELECT status FROM signals WHERE status LIKE '%GAGNÉ%' OR status LIKE '%PERDU%'")
-            rows = cursor.fetchall()
-            total = len(rows)
-            wins = sum(1 for r in rows if "GAGNÉ" in r['status'])
-            wr = round((wins / total) * 100, 1) if total > 0 else 0
-            return {"total": total, "winrate": wr, "expectancy": "Calcul IA..."}
-            
-        elif action == "last":
-            cursor.execute("SELECT * FROM signals ORDER BY id DESC LIMIT 1")
-            row = cursor.fetchone()
-            return dict(row) if row else {"error": "Aucun trade enregistré"}
-            
-        elif action == "history":
-            cursor.execute("SELECT status, COUNT(*) as count FROM signals WHERE symbol = ? GROUP BY status", (symbol,))
-            return {r['status']: r['count'] for r in cursor.fetchall()}
-            
-        elif action == "top":
-            cursor.execute("SELECT symbol, COUNT(*) as count, SUM(CASE WHEN status LIKE '%GAGNÉ%' THEN 1 ELSE 0 END) as wins FROM signals WHERE status LIKE '%GAGNÉ%' OR status LIKE '%PERDU%' GROUP BY symbol HAVING count > 0")
-            rows = cursor.fetchall()
-            top = [{"symbol": r['symbol'], "status": (r['wins']/r['count'])*100, "count": r['count']} for r in rows]
-            top.sort(key=lambda x: x['status'], reverse=True)
-            return top[:5]
-            
-        elif action == "recent":
-            cursor.execute("SELECT * FROM signals ORDER BY id DESC LIMIT 5")
-            return [{"symbol": r['symbol'], "direction": r['direction'], "status": r['status']} for r in cursor.fetchall()]
-            
-        elif action == "edge":
-            cursor.execute("SELECT status FROM signals WHERE status LIKE '%GAGNÉ%' OR status LIKE '%PERDU%'")
-            rows = cursor.fetchall()
-            total = len(rows)
-            wins = sum(1 for r in rows if "GAGNÉ" in r['status'])
-            wr = round((wins / total) * 100, 1) if total > 0 else 0
-            return {"edge": round(wr - 50, 1) if total > 0 else 0}
-            
-    except Exception as e:
-        return {"error": str(e)}
-    finally:
-        if 'conn' in locals():
-            conn.close()
-
-def get_bot_skills():
-    import sqlite3
-    try:
-        with sqlite3.connect(DB_NAME) as conn:
-            conn.row_factory = sqlite3.Row
-            cursor = conn.cursor()
-            # On récupère les stats triées par Score (tes meilleurs timeframes en haut)
-            cursor.execute("SELECT symbol, timeframe, tp_mult, sl_mult, score, min_prob FROM agent_logic ORDER BY score DESC")
-            rows = cursor.fetchall()
-            
-            data = []
-            for r in rows:
-                # On transforme les données pour le tableau
-                data.append([
-                    r['symbol'], 
-                    r['timeframe'], 
-                    f"x{round(r['tp_mult'], 2)}", 
-                    f"x{round(r['sl_mult'], 2)}", 
-                    f"{r['score']} XP",
-                    f"{round(r['min_prob'] * 100, 1)}%"
-                ])
-            return data
-    except Exception as e:
-        return [[f"Erreur: {str(e)}", "-", "-", "-", "-", "-"]]
+    except Exception as e: return []
 
-def force_scalping_mode():
-    import sqlite3
-    try:
-        with sqlite3.connect(DB_NAME) as conn:
-            # On force tous les timeframes à x1.8 pour encaisser les profits rapidement
-            conn.execute("UPDATE agent_logic SET tp_mult = 1.8")
-            conn.commit()
-        # On renvoie les nouvelles stats pour mettre à jour le tableau
-        return get_bot_skills()
-    except Exception as e:
-        print(f"❌ Erreur Reset Scalping : {e}")
-        return [[f"Erreur: {str(e)}", "-", "-", "-", "-", "-"]]
-            
 # --- 🎨 INTERFACE GRADIO ---
 with gr.Blocks(theme=gr.themes.Monochrome()) as iface:
-    gr.Markdown("# 📡 Alpha V21.2 Master Engine RPG")
+    gr.Markdown("# 📡 Alpha V24 GEMINI Scalping Engine")
     
     with gr.Tab("Admin"):
-        admin_sym = gr.Textbox(label="Symbole à recalibrer", value="BTC/USDT")
-        train_btn = gr.Button("Forcer Entraînement Hebdomadaire", variant="stop")
+        admin_sym = gr.Textbox(label="Symbole", value="BTC/USDT")
         train_out = gr.Textbox(label="Résultat")
-        train_btn.click(fn=training_wrapper, inputs=admin_sym, outputs=train_out, api_name="trigger_training")
+        gr.Button("Forcer Entraînement", variant="stop").click(fn=training_wrapper, inputs=admin_sym, outputs=train_out, api_name="trigger_training")
 
     with gr.Tab("🎯 Prédictions"):
-        sym_input = gr.Textbox(label="Symbole (ex: BTC/USD)")
-        tf_input = gr.Dropdown(choices=["5m", "15m", "1h", "4h", "1d"], value="1h", label="Timeframe")
         btn_pred = gr.Button("Predict", variant="primary")
         out_json = gr.JSON()
-        btn_pred.click(fn=predict_signal, inputs=[sym_input, tf_input], outputs=out_json)
+        btn_pred.click(fn=predict_signal, inputs=[gr.Textbox(label="Symbole", value="ETH/USD"), gr.Dropdown(choices=["1m", "5m", "15m", "1h"], value="1m", label="TF")], outputs=out_json)
 
     with gr.Tab("⚖️ Système"):
-        btn_j = gr.Button("Judge")
-        out_j = gr.JSON()
-        btn_j.click(fn=run_judge_api, outputs=out_j, api_name="run_judge_api")
-        
-        btn_rpg = gr.Button("RPG Stats", visible=False)
-        out_rpg = gr.Textbox()
-        btn_rpg.click(fn=get_rpg_stats, outputs=out_rpg, api_name="get_rpg_stats")
-        
-        btn_active = gr.Button("Get Active", visible=False)
-        btn_active.click(fn=get_active_signals, outputs=out_json, api_name="get_active_signals")
-        
-        btn_stats = gr.Button("Get Stats", visible=False)
-        out_stats = gr.JSON()
-        btn_stats.click(
-            fn=get_db_stats, 
-            inputs=[gr.Textbox(visible=False), gr.Textbox(visible=False)], 
-            outputs=out_stats, 
-            api_name="get_db_stats"
-        )
-        
-        btn_ping = gr.Button("Ping", visible=False)
-        btn_ping.click(fn=keep_alive_ping, outputs=gr.JSON(), api_name="keep_alive_ping")
+        gr.Button("Judge").click(fn=run_judge_api, outputs=gr.JSON(), api_name="run_judge_api")
+        gr.Button("Get Active", visible=False).click(fn=get_active_signals, outputs=gr.JSON(), api_name="get_active_signals")
+        gr.Button("Ping", visible=False).click(fn=keep_alive_ping, outputs=gr.JSON(), api_name="keep_alive_ping")
 
-    # --- 📊 Onglet Stats du Cerveau ---
     with gr.Tab("📊 Stats du Cerveau"):
-        gr.Markdown("### 🧠 Compétences actuelles de l'IA (Auto-Learning)")
-        skills_table = gr.Dataframe(
-            headers=["Marché", "Timeframe", "Cible (TP)", "Risque (SL)", "Expérience", "Confiance Min."],
-            datatype=["str", "str", "str", "str", "str", "str"],
-            value=get_bot_skills(),
-            interactive=False
-        )
-        
+        skills_table = gr.Dataframe(headers=["Marché", "Timeframe", "Cible (TP)", "Risque (SL)", "Expérience", "Confiance Min."], value=get_bot_skills(), interactive=False)
         with gr.Row():
-            refresh_btn = gr.Button("🔄 Actualiser", variant="secondary")
-            scalp_btn = gr.Button("⚡ Mode Scalping Force", variant="primary")
-
-        # Logique des boutons
-        refresh_btn.click(get_bot_skills, outputs=skills_table)
-        scalp_btn.click(force_scalping_mode, outputs=skills_table)
-
-    # =========================================================
-    # --- ⚓ LE HANDSHAKE API (SECRET POUR PTERODACTYL) ---
-    # =========================================================
-    # Dans ton interface gr.Blocks :
-    api_inputs = [gr.Textbox(visible=False), gr.Textbox(visible=False)] # Deux entrées !
-    api_confirm_btn = gr.Button(visible=False)
-    api_confirm_btn.click(
-        fn=confirm_trade_api, 
-        inputs=api_inputs, # On lie les deux
-        outputs=gr.JSON(), 
-        api_name="confirm_trade_api"
-    )
-    # =========================================================
-    # =========================================================
-    # --- 🗑️ LE KILL SWITCH API (POUR ANNULER LES TRADES PÉRIMÉS) ---
-    # =========================================================
-    api_cancel_input = gr.Textbox(visible=False)
-    api_cancel_btn = gr.Button(visible=False)
-    api_cancel_btn.click(
-        fn=cancel_trade_api, 
-        inputs=api_cancel_input, 
-        outputs=gr.JSON(), 
-        api_name="cancel_trade_api"
-    )
-
-    # --- 🕒 SYSTÈME DE MISE À JOUR AUTOMATIQUE ---
-    iface.load(get_bot_skills, outputs=skills_table)
-    
-    try:
-        timer = gr.Timer(30)
-        timer.tick(get_bot_skills, outputs=skills_table)
-    except AttributeError:
-        print("⚠️ Gradio trop ancien pour gr.Timer. Rafraîchissement auto désactivé.")
-
-
+            gr.Button("🔄 Actualiser").click(get_bot_skills, outputs=skills_table)
+            gr.Button("⚡ Mode Scalping Force").click(force_scalping_mode, outputs=skills_table)
 
+    api_inputs = [gr.Textbox(visible=False), gr.Textbox(visible=False)]
+    gr.Button(visible=False).click(fn=confirm_trade_api, inputs=api_inputs, outputs=gr.JSON(), api_name="confirm_trade_api")
+    gr.Button(visible=False).click(fn=cancel_trade_api, inputs=gr.Textbox(visible=False), outputs=gr.JSON(), api_name="cancel_trade_api")
+    iface.load(get_bot_skills, outputs=skills_table)
 
-        
 import threading
-import asyncio
-
-# --- 🔒 LE CADENAS ANTI-CLONAGE ---
 _auto_pilot_started = False
 
 def run_auto_pilot():
     global _auto_pilot_started
-    
-    # Si le videur voit que c'est déjà lancé, il bloque le nouveau clone !
-    if _auto_pilot_started:
-        print("🛑 [ANTI-CLONAGE] Un Auto-Pilote tourne déjà en fond. Annulation du clone.")
-        return
-        
+    if _auto_pilot_started: return
     _auto_pilot_started = True
-    # -----------------------------------
-
     print("⏳ [SYSTEM] Auto-Pilote en pause pour laisser Gradio démarrer...")
-    time.sleep(30) # 🛡️ LE BOUCLIER ANTI-CRASH : On attend 30 secondes
-    print("🚀 [SYSTEM] Auto-Pilote RPG propulsé en arrière-plan.")
-    
+    time.sleep(10) 
+    print("🚀 [SYSTEM] Auto-Pilote V24 GEMINI propulsé en arrière-plan.")
     try:
         new_loop = asyncio.new_event_loop()
         asyncio.set_event_loop(new_loop)
         new_loop.run_until_complete(auto_predict_loop())
     except Exception as e:
-        print(f"⚠️ Erreur critique boucle Auto-Pilote : {e}")
-        _auto_pilot_started = False # On retire le cadenas en cas de crash pour pouvoir redémarrer
+        print(f"⚠️ Erreur critique : {e}")
+        _auto_pilot_started = False 
 
 if __name__ == "__main__":
-    try:
-        threading.Thread(target=run_auto_pilot, daemon=True).start()
-    except Exception as e:
-        print(f"⚠️ Erreur au lancement du thread Auto-Pilote : {e}")
-
-    # On lance Gradio immédiatement, l'Auto-pilote attendra son tour !
+    try: threading.Thread(target=run_auto_pilot, daemon=True).start()
+    except Exception as e: print(f"⚠️ Erreur lancement Thread : {e}")
     iface.launch(show_api=True)