Update app.py

app.py

@@ -84,60 +84,45 @@ HF_TOKEN = os.environ.get("HF_TOKEN")
 
 def init_db():
     reset_needed = False
-    
     if os.path.exists(DB_NAME):
         try:
             conn = sqlite3.connect(DB_NAME)
             cursor = conn.execute("PRAGMA table_info(signals)")
             columns = [col[1] for col in cursor.fetchall()]
             conn.close()
-            if 'date' not in columns or 'timeframe' not in columns:
+            # On vérifie si 'peak_price' existe, sinon on reset pour la nouvelle structure
+            if 'date' not in columns or 'peak_price' not in columns:
                 reset_needed = True
         except Exception as e:
             print(f"⚠️ Erreur check DB: {e}")
             reset_needed = True
 
     if reset_needed:
-        print("⚠️ Structure obsolète détectée. Reset de la base de données...")
-        try:
-            if os.path.exists(DB_NAME):
-                os.remove(DB_NAME)
-            print("✅ Ancienne base supprimée.")
-        except Exception as e:
-            print(f"❌ Impossible de supprimer la DB: {e}")
+        print("⚠️ Structure obsolète. Reset de la base de données pour le Trailing Stop...")
+        if os.path.exists(DB_NAME): os.remove(DB_NAME)
 
     try:
         with sqlite3.connect(DB_NAME) as conn:
+            # Table des signaux avec 'peak_price' pour le Trailing Stop
             conn.execute('''CREATE TABLE IF NOT EXISTS signals (
                 id INTEGER PRIMARY KEY AUTOINCREMENT, 
                 date TEXT, symbol TEXT, timeframe TEXT, direction TEXT, 
                 prob REAL, price REAL, tp REAL, sl REAL, status TEXT, 
-                regime INTEGER, prob_time REAL, prob_ml REAL, prob_lstm REAL, prob_sent REAL)''')
+                regime INTEGER, prob_time REAL, prob_ml REAL, prob_lstm REAL, prob_sent REAL,
+                peak_price REAL)''') # <--- NOUVEAU
             
-            # 🎮 LA FICHE DE PERSONNAGE (STATS RPG)
             conn.execute('''CREATE TABLE IF NOT EXISTS agent_logic (
-                timeframe TEXT PRIMARY KEY,
-                tp_mult REAL,
-                sl_mult REAL,
-                score REAL,
-                last_pnl REAL,
-                min_prob REAL,         
-                min_tp_dist REAL)''')
+                timeframe TEXT PRIMARY KEY, tp_mult REAL, sl_mult REAL,
+                score REAL, last_pnl REAL, min_prob REAL, min_tp_dist REAL)''')
             
             cursor = conn.cursor()
             cursor.execute("SELECT COUNT(*) FROM agent_logic")
             if cursor.fetchone()[0] == 0:
-                # Stats de départ : (TF, Epée, Bouclier, Score, PNL, Peur, Radinerie)
-                defaults = [
-                    ('5m',  1.5, 1.0, 0, 0, 0.60, 0.003), 
-                    ('15m', 2.0, 1.2, 0, 0, 0.55, 0.004), 
-                    ('1h',  3.0, 1.5, 0, 0, 0.52, 0.005), 
-                    ('4h',  4.5, 2.0, 0, 0, 0.50, 0.008), 
-                    ('1d',  6.0, 2.5, 0, 0, 0.50, 0.01)
-                ]
+                defaults = [('5m', 1.5, 1.0, 0, 0, 0.60, 0.003), ('15m', 2.0, 1.2, 0, 0, 0.55, 0.004),
+                            ('1h', 3.0, 1.5, 0, 0, 0.52, 0.005), ('4h', 4.5, 2.0, 0, 0, 0.50, 0.008),
+                            ('1d', 6.0, 2.5, 0, 0, 0.50, 0.01)]
                 conn.executemany("INSERT INTO agent_logic VALUES (?, ?, ?, ?, ?, ?, ?)", defaults)
-                print("✅ Mémoire RPG initialisée (Niveau 0).")
-        print("✅ Base de données V10 Synchronisée.")
+        print("✅ Base de données V11 (Trailing Stop Ready) Synchronisée.")
     except Exception as e:
         print(f"❌ Erreur critique création DB: {e}")
     
@@ -184,35 +169,21 @@ try:
 except Exception as e: print(f"⚠️ Erreur IA : {e}")
 
 # --- 📊 FEATURES ENGINE ---
+# --- 📊 FEATURES ENGINE (Fibonacci + FVG + BTC) ---
 def prepare_features_sync(symbol, timeframe='1h', limit_bars=600):
-    """Version Synchrone avec Bouclier Anti-Blocage Kucoin"""
     try:
         now = datetime.now().timestamp()
         cache_key = f"{symbol}_{timeframe}"
-
-        if cache_key in market_cache and cache_key in last_fetch_time and now - last_fetch_time[cache_key] < CACHE_DURATION:
+        if cache_key in market_cache and now - last_fetch_time.get(cache_key, 0) < CACHE_DURATION:
             df = market_cache[cache_key].copy()
         else:
-            bars = None
-            for attempt in range(3):
-                try:
-                    bars = exchange_sync.fetch_ohlcv(symbol, timeframe=timeframe, limit=limit_bars)
-                    break 
-                except Exception as e:
-                    print(f"⚠️ Kucoin bloque {symbol} (Essai {attempt+1}/3). Attente 2s...")
-                    time.sleep(2) 
-            
-            if not bars:
-                print(f"❌ Échec total de la récupération pour {symbol}.")
-                return pd.DataFrame()
-
+            bars = exchange_sync.fetch_ohlcv(symbol, timeframe, limit=limit_bars)
             df = pd.DataFrame(bars, columns=['ts', 'open', 'high', 'low', 'close', 'vol'])
-            market_cache[cache_key] = df.copy()
-            last_fetch_time[cache_key] = now
+            market_cache[cache_key], last_fetch_time[cache_key] = df.copy(), now
 
-        if len(df) < 250: 
-            return pd.DataFrame()
+        if len(df) < 250: return pd.DataFrame()
 
+        # Indicateurs Standard
         df["RSI"] = get_rsi(df["close"])
         df["EMA50"] = get_ema(df["close"], 50)
         df["EMA200"] = get_ema(df["close"], 200)
@@ -221,8 +192,8 @@ def prepare_features_sync(symbol, timeframe='1h', limit_bars=600):
         df["EMA200_slope"] = (df["EMA200"] / df["EMA200"].shift(10)) - 1
         df["Drawdown"] = (df["close"] / df["close"].rolling(14).max()) - 1
         
-        df["High_24h"] = df["high"].rolling(24).max()
-        df["Low_24h"] = df["low"].rolling(24).min()
+        # Market Structure
+        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"]
@@ -230,41 +201,53 @@ def prepare_features_sync(symbol, timeframe='1h', limit_bars=600):
         df["ATR_ratio"] = df["ATR"] / df["close"]
         df["VOL_ratio"] = df["vol"] / df["vol"].rolling(24).mean()
         
-        df['return_1h'] = df['close'].pct_change(1)
-        df['return_3h'] = df['close'].pct_change(3)
-        df['return_12h'] = df['close'].pct_change(12)
-        df['RSI_lag1'] = df["RSI"].shift(1)
-        df['RSI_lag2'] = df["RSI"].shift(2)
-        df['VOL_RATIO'] = df['vol'] / df['vol'].rolling(20).mean()
-        df['vol_lag1'] = df['vol'].shift(1)
-        df["RSI_Macro"] = df["RSI"]
+        # Fibonacci (24h Swing)
+        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"]
 
-        prev_low = df["low"].rolling(24).min().shift(1)
-        prev_high = df["high"].rolling(24).max().shift(1)
-        df["Sweep_Low"] = ((df["low"] < prev_low) & (df["close"] > prev_low)).astype(int)
-        df["Sweep_High"] = ((df["high"] > prev_high) & (df["close"] < prev_high)).astype(int)
+        # FVG (Fair Value Gap)
+        df['FVG_bull'] = (df['low'] > df['high'].shift(2)).astype(int)
+        df['FVG_bear'] = (df['high'] < df['low'].shift(2)).astype(int)
 
-        return df.dropna().copy()
-        
-    except Exception as e:
-        print(f"❌ Erreur critique calculs ({symbol}): {e}")
-        return pd.DataFrame()
+        # BTC Correlation
+        if symbol != "BTC/USDT":
+            try:
+                b_bars = exchange_sync.fetch_ohlcv("BTC/USDT", timeframe, limit=50)
+                b_c = pd.Series([b[4] for b in b_bars])
+                df["BTC_slope"] = (b_c.ewm(50).mean().iloc[-1] / b_c.ewm(50).mean().iloc[-6]) - 1
+            except: df["BTC_slope"] = 0
+        else: df["BTC_slope"] = df["EMA200_slope"]
+
+        # SMC Sweeps
+        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)
+
+        # Lags pour XGBoost
+        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_lag1'], df['RSI_Macro'] = df['vol'].shift(1), df["RSI"]
 
+        return df.dropna().copy()
+    except Exception as e: print(f"❌ Error Stats: {e}"); return pd.DataFrame()
 
 
-# --- 🎯 API PRÉDICTION AVEC GAMEPLAY RPG ---
 async def predict_signal(symbol, timeframe="1h"): 
     try:
         memory_guard()
         symbol = str(symbol).strip().upper()
         if "/USDT" not in symbol: symbol += "/USDT"
         
+        # 1. Préparation des données (Contient FVG, Fib, BTC Slope)
         df = prepare_features_sync(symbol, timeframe)
         if df.empty: return {"status": "error", "message": f"Data insuffisante pour {timeframe}"}
         
         last_row = df.iloc[[-1]]
         prix, atr = float(last_row['close'].iloc[0]), float(last_row['ATR'].iloc[0])
         
+        # 2. Analyse des 3 cerveaux + Sentiment
         regime_scaled = regime_scaler.transform(last_row[["ATR_pct", "EMA200_slope", "Drawdown", "RSI_Macro"]])
         regime_pred = int(regime_model.predict(regime_scaled)[0])
         
@@ -280,12 +263,17 @@ async def predict_signal(symbol, timeframe="1h"):
         
         p_sent = await get_crypto_sentiment(symbol)
 
-        if timeframe in ["5m", "15m"]: wm, wt, wl, ws = 0.45, 0.35, 0.15, 0.05
-        elif timeframe in ["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
+        # 3. Pondération adaptative selon le Timeframe (Tes réglages d'origine)
+        if timeframe in ["5m", "15m"]: 
+            wm, wt, wl, ws = 0.45, 0.35, 0.15, 0.05
+        elif timeframe in ["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
 
         final_p = (time_prob * wt) + (ml_prob * wm) + (lstm_prob * wl) + (p_sent * ws)
 
+        # 4. Bonus Smart Money (SMC)
         sweep_low, sweep_high = int(last_row["Sweep_Low"].iloc[0]), int(last_row["Sweep_High"].iloc[0])
         smc_status = "AUCUN"
         if sweep_low == 1:
@@ -295,7 +283,7 @@ async def predict_signal(symbol, timeframe="1h"):
             final_p = max(0.05, final_p - 0.20)
             smc_status = "SHORT SWEEP 🐋"
 
-        # 🎮 LECTURE DES STATS DU JOUEUR EN DIRECT
+        # 5. Lecture des Stats RPG et calcul TP/SL
         with sqlite3.connect(DB_NAME) as conn:
             res = conn.execute("SELECT tp_mult, sl_mult, min_prob, min_tp_dist FROM agent_logic WHERE timeframe = ?", (timeframe,)).fetchone()
             tp_m, sl_m, agent_min_prob, agent_min_tp_dist = res if res else (3.0, 1.5, 0.55, 0.004)
@@ -303,66 +291,66 @@ async def predict_signal(symbol, timeframe="1h"):
         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)
 
+        # 6. Scores et Risk Management
         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))
 
         risk_pct = max(0.2, min(2.5, strength * 5.0))
-        CAPITAL_VIRTUEL = 1000 
-        risk_usd = CAPITAL_VIRTUEL * (risk_pct / 100)
+        risk_usd = 1000 * (risk_pct / 100) # Capital Virtuel 1000$
         gain_estime_usd = risk_usd * (tp_m / sl_m)
 
         # ==========================================
-        # 🛑 LE VETO DYNAMIQUE (L'IA décide avec ses stats)
+        # 🛑 LE VETO DYNAMIQUE (F1 à F9)
         # ==========================================
         veto = False
         veto_reason = ""
-        distance_tp_pct = abs(tp - prix) / prix
-        
-        # F1/F2: Niveau de Peur Dynamique
-        if final_p < agent_min_prob and final_p > (1 - agent_min_prob):
-            veto = True
-            veto_reason = f"Confiance ({round(final_p, 2)}). Requis: > {round(agent_min_prob, 2)}"
+        dist_tp_pct = abs(tp - prix) / prix
+        dist_fib = float(last_row["Dist_Fib_618"].iloc[0])
+        btc_slope = float(last_row["BTC_slope"].iloc[0])
+        ema200_slope_val = float(last_row["EMA200_slope"].iloc[0])
+        fvg_bull = int(last_row["FVG_bull"].iloc[0])
 
-        # F3: Filtre SMC (Anti-Bruit)
+        # F1/F2: Confiance
+        if final_p < agent_min_prob and final_p > (1 - agent_min_prob):
+            veto, veto_reason = True, f"Confiance ({round(final_p, 2)}). Requis: > {round(agent_min_prob, 2)}"
+        # F3: SMC (5m/15m)
         elif timeframe in ["5m", "15m"] and smc_status == "AUCUN":
-            veto = True
-            veto_reason = "Aucune manipulation (Sweep) détectée."
-
-        # F4: Esquive des Frais Dynamique
-        elif distance_tp_pct < agent_min_tp_dist:
-            veto = True
-            veto_reason = f"TP trop proche ({round(distance_tp_pct*100, 2)}%). Requis: > {round(agent_min_tp_dist*100, 2)}%"
-
-        # F5: Filtre Macro
+            veto, veto_reason = True, "Aucune manipulation (Sweep) détectée."
+        # F4: Frais
+        elif dist_tp_pct < agent_min_tp_dist:
+            veto, veto_reason = True, f"TP trop proche ({round(dist_tp_pct*100, 2)}%)."
+        # F5: Macro
         elif symbol != "BTC/USDT" and regime_pred == 2 and final_p > 0.5:
-            veto = True
-            veto_reason = "Tendance macro baissière (Risque Altcoins)."
-
-        # F6: Le Veto de Tendance (Anti-Kamikaze)
-        ema200_slope_val = float(last_row["EMA200_slope"].iloc[0])
-        if final_p < 0.5 and ema200_slope_val > 0.005: # Si on veut shorter mais que la tendance long terme monte fort
-            veto = True
-            veto_reason = "Tendance lourde haussière. Interdit de shorter un pump."
-        elif final_p > 0.5 and ema200_slope_val < -0.005: # L'inverse
-            veto = True
-            veto_reason = "Tendance lourde baissière. Interdit d'acheter un dump."
+            veto, veto_reason = True, "Tendance macro baissière."
+        # F6: Anti-Kamikaze
+        elif final_p < 0.5 and ema200_slope_val > 0.005:
+            veto, veto_reason = True, "Interdit de shorter un pump."
+        elif final_p > 0.5 and ema200_slope_val < -0.005:
+            veto, veto_reason = True, "Interdit d'acheter un dump."
+        # F7: Fibonacci 📏
+        elif final_p > 0.6 and dist_fib < -0.02:
+            veto, veto_reason = True, f"Support Fib trop loin ({round(dist_fib*100, 2)}%)."
+        # F8: Corrélation BTC 👑
+        elif symbol != "BTC/USDT":
+            if final_p < 0.5 and btc_slope > 0.002:
+                veto, veto_reason = True, "BTC Haussier (No Short)."
+            elif final_p > 0.5 and btc_slope < -0.002:
+                veto, veto_reason = True, "BTC Baissier (No Long)."
+        # F9: FVG Check (Facultatif mais enregistré)
+        if final_p > 0.7 and fvg_bull == 0:
+            print(f"⚠️ [FVG Warning] Pas de gap de liquidité pour l'entrée sur {symbol}")
 
         if veto:
-            print(f"🛑 [VETO IA] {symbol} [{timeframe}] refusé : {veto_reason}")
-            return {
-                "symbol": symbol, "timeframe": timeframe, "status": "veto",
-                "message": veto_reason, "price": prix, "final_score": round(final_p, 4)
-            }
+            print(f"🛑 [VETO] {symbol} [{timeframe}]: {veto_reason}")
+            return {"symbol": symbol, "timeframe": timeframe, "status": "veto", "message": veto_reason, "price": prix, "final_score": round(final_p, 4)}
 
-        # ==========================================
-        # 6. 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)
+        # 7. SAUVEGARDE DB (On ajoute peak_price à la fin)
+        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)
         
         print(f"✅ [VALIDÉ] {symbol} [{timeframe}] : Ordre envoyé au Juge.")
@@ -376,7 +364,6 @@ async def predict_signal(symbol, timeframe="1h"):
             "probs": {"xgb": round(time_prob, 3), "rf": round(ml_prob, 3), "lstm": round(lstm_prob, 3), "sent": round(p_sent, 3)},
             "weights": {"w_xgb": round(wt, 2), "w_rf": round(wm, 2), "w_lstm": round(wl, 2), "w_sent": round(ws, 2)}
         }
-        
     except Exception as e:
         return {"status": "error", "message": str(e)}
 
@@ -469,10 +456,13 @@ def run_judge_api():
         conn = sqlite3.connect(DB_NAME)
         conn.row_factory = sqlite3.Row
         cursor = conn.cursor()
+        
+        # On ne juge que les trades qui sont encore ouverts
         cursor.execute("SELECT * FROM signals WHERE status = 'EN_COURS'")
         trades = cursor.fetchall()
         
-        if not trades: return {"status": "waiting", "message": "⚖️ Observation du marché en cours..."}
+        if not trades: 
+            return {"status": "waiting", "message": "⚖️ Observation du marché en cours..."}
 
         closed_trades = []
         for t in trades:
@@ -480,53 +470,78 @@ def run_judge_api():
                 ticker = exchange_sync.fetch_ticker(t['symbol'])
                 current_price = ticker['last']
                 
+                # --- 🚀 LOGIQUE TRAILING STOP (SÉCURISATION) ---
+                sl_dynamique = t['sl']
+                peak = t['peak_price']
+                
+                # Mise à jour du point le plus haut (ou bas) atteint
+                new_peak = max(peak, current_price) if t['direction'] == 'HAUSSIER' else min(peak, current_price)
+                
+                # Ratio de progression vers le TP (0.5 = 50% du chemin fait)
+                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
+                
+                # 🛡️ PROTECTION BREAK-EVEN : Si on a fait 50% du chemin, on met le SL au prix d'entrée
+                if progression > 0.5:
+                    # Pour un LONG, on remonte le SL. Pour un SHORT, on le descend.
+                    if t['direction'] == 'HAUSSIER' and sl_dynamique < t['price']:
+                        sl_dynamique = t['price']
+                    elif t['direction'] == 'BAISSIER' and sl_dynamique > t['price']:
+                        sl_dynamique = t['price']
+                
+                # On met à jour la base de données avec le nouveau Peak et le nouveau SL
+                cursor.execute("UPDATE signals SET peak_price = ?, sl = ? WHERE id = ?", (new_peak, sl_dynamique, t['id']))
+
+                # --- 🏁 VÉRIFICATION DU RÉSULTAT ---
                 outcome = None
                 reward = 0
                 
                 if t['direction'] == 'HAUSSIER':
-                    if current_price >= t['tp']: outcome, reward = "GAGNÉ ✅", 3
-                    elif current_price <= t['sl']: outcome, reward = "PERDU ❌", -5
+                    if current_price >= t['tp']: 
+                        outcome, reward = "GAGNÉ ✅", 3
+                    elif current_price <= sl_dynamique: 
+                        # On distingue si c'est une perte ou une protection
+                        outcome = "SL TOUCHÉ 🛡️" if sl_dynamique == t['price'] else "PERDU ❌"
+                        reward = 0 if outcome == "SL TOUCHÉ 🛡️" else -5
                 else: 
-                    if current_price <= t['tp']: outcome, reward = "GAGNÉ ✅", 3
-                    elif current_price >= t['sl']: outcome, reward = "PERDU ❌", -5
+                    if current_price <= t['tp']: 
+                        outcome, reward = "GAGNÉ ✅", 3
+                    elif current_price >= sl_dynamique: 
+                        outcome = "SL TOUCHÉ 🛡️" if sl_dynamique == t['price'] else "PERDU ❌"
+                        reward = 0 if outcome == "SL TOUCHÉ 🛡️" else -5
 
                 if outcome:
-                    # ==========================================
-                    # 💰 CALCUL DU PNL (PROFIT & LOSS)
-                    # Capital: 10 000$ | Risque: 1% (100$)
-                    # ==========================================
+                    # --- 💰 CALCUL DU PNL ---
                     risque_usd = 100.0 
-                    distance_sl = abs(t['price'] - t['sl'])
-                    distance_tp = abs(t['price'] - t['tp'])
-                    
-                    # Ratio Risk/Reward
-                    rr_ratio = distance_tp / distance_sl if distance_sl > 0 else 1
+                    dist_sl_initiale = abs(t['price'] - t['sl'])
+                    dist_tp_initiale = abs(t['tp'] - t['price'])
+                    rr_ratio = dist_tp_initiale / dist_sl_initiale if dist_sl_initiale > 0 else 1
                     
                     if "GAGNÉ" in outcome:
                         pnl_dollars = risque_usd * rr_ratio
+                    elif "SL TOUCHÉ" in outcome:
+                        pnl_dollars = 0.0 # On sort à 0, capital sauvé !
                     else:
                         pnl_dollars = -risque_usd
 
-                    # 🎮 LE SYSTÈME D'EXPÉRIENCE (L'IA Modifie ses Stats)
+                    # --- 🎮 ÉVOLUTION RPG ---
                     cursor.execute("SELECT tp_mult, sl_mult, score, min_prob, min_tp_dist FROM agent_logic WHERE timeframe = ?", (t['timeframe'],))
                     row = cursor.fetchone()
-                    tp_m, sl_m, score, min_p, min_tp_d = row if row else (2.0, 1.5, 0, 0.55, 0.004)
+                    tp_m, sl_m, score_ia, min_p, min_tp_d = row if row else (3.0, 1.5, 0, 0.55, 0.004)
 
-                    if reward > 0: # LEVEL UP !
+                    if reward > 0: # LEVEL UP
                         tp_m *= 1.05
-                        min_p = max(0.50, min_p - 0.01) # Baisse de la peur (Devient plus agressive)
-                        min_tp_d = max(0.002, min_tp_d * 0.95) # Tolère plus de frais
-                    else: # PUNITION !
-                        sl_m *= 0.90
+                        min_p = max(0.50, min_p - 0.01)
+                    elif reward < 0: # PUNITION
+                        sl_m = max(1.0, sl_m * 0.95) # On ne descend jamais sous 1.0 ATR
                         tp_m *= 0.95
-                        min_p = min(0.65, min_p + 0.02) # Augmente sa prudence (Devient difficile)
-                        min_tp_d = min(0.015, min_tp_d * 1.05) # Exige plus de marge de gain
+                        min_p = min(0.65, min_p + 0.02)
 
-                    cursor.execute("UPDATE agent_logic SET tp_mult=?, sl_mult=?, score=score+?, min_prob=?, min_tp_dist=? WHERE timeframe=?",
-                                   ((max(1.1, tp_m), max(1.0, sl_m), reward, min_p, min_tp_d, t['timeframe']))
+                    cursor.execute("UPDATE agent_logic SET tp_mult=?, sl_mult=?, score=score+?, min_prob=? WHERE timeframe=?",
+                                   (tp_m, sl_m, reward, min_p, t['timeframe']))
                     cursor.execute("UPDATE signals SET status=? WHERE id=?", (outcome, t['id']))
                     
-                    # 📦 ON PRÉPARE LE COLIS POUR DISCORD
                     closed_trades.append({
                         "symbol": t['symbol'],
                         "timeframe": t['timeframe'],
@@ -534,26 +549,24 @@ def run_judge_api():
                         "outcome": outcome,
                         "entry_price": t['price'],
                         "close_price": current_price,
-                        "tp": t['tp'],
-                        "sl": t['sl'],
-                        "pnl": round(pnl_dollars, 2), # <--- LE NOUVEAU PNL EST ICI
+                        "pnl": round(pnl_dollars, 2),
                         "new_peur": round(min_p * 100, 1),
                         "new_tp": round(tp_m, 2),
                         "new_sl": round(sl_m, 2)
                     })
+
             except Exception as inner_e:
                 print(f"⚠️ Erreur sur {t['symbol']} : {inner_e}")
 
         conn.commit()
         conn.close()
         
-        
         if closed_trades:
             return {"status": "updates", "data": closed_trades}
-        return {"status": "waiting", "message": "waiting..."} # <-- On a enlevé l'émoji ici pour éviter le crash orjson
+        return {"status": "waiting", "message": "waiting..."}
         
     except Exception as e:
-        return {"status": "error", "message": "error"}
+        return {"status": "error", "message": str(e)}
         
 async def shutdown():
     ex = ExchangeManager.get_instance()