Update app.py

app.py

@@ -501,33 +501,53 @@ def mutate_agent(symbol, timeframe, regime, success=True):
         backup_db_to_hf()
     except Exception as e: print(f"🧬 Erreur Mutation: {e}")
 
-# --- 🌙 DREAM LOOP ---
+# --- 🌙 DREAM LOOP V31 (CORRIGÉE) ---
 async def dream_simulation_loop():
     while True:
         if DREAM_MODE_ACTIVE:
-            print("GO ALLER A LA SALLE🥊")
+            print("🌙 [DREAM MODE] Le bot rêve et s'entraîne à la salle... 🥊")
             for symbol in AUTO_SYMBOLS:
                 for tf in AUTO_TIMEFRAMES: 
                     try:
                         df = prepare_features_sync(symbol, timeframe=tf, limit_bars=200)
                         if df.empty or len(df) < 50: continue
                         
+                        # 1. On voyage dans le temps (une bougie au hasard)
                         idx = random.randint(10, len(df) - 30)
-                        pred = await predict_signal(symbol, timeframe=tf)
-                        if pred.get("status") == "success":
-                            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 row['high'] >= pred['tp']: win = True; break
-                                    if row['low'] <= pred['sl']: win = False; break
-                                else:
-                                    if row['low'] <= pred['tp']: win = True; break
-                                    if row['high'] >= pred['sl']: win = False; break
-                            mutate_agent(symbol, tf, current_scenario, success=win)
-                        await asyncio.sleep(3) 
-                    except: pass
+                        row_actuelle = df.iloc[idx]
+                        prix = float(row_actuelle['close'])
+                        atr = float(row_actuelle['ATR'])
+                        
+                        # 2. On récupère le régime de marché (Scénario)
+                        # Pour le Dream Mode rapide, on utilise une valeur par défaut ou on pourrait la calculer.
+                        current_scenario = 3 
+                        
+                        # 3. On extrait l'ADN actuel (les multiplicateurs)
+                        with sqlite3.connect(DB_NAME) as conn:
+                            res = conn.execute("SELECT tp_mult, sl_mult FROM agent_logic WHERE symbol = ? AND timeframe = ? AND regime = ?", (symbol, tf, current_scenario)).fetchone()
+                            tp_m, sl_m = res if res else (1.5, 1.0)
+                        
+                        # 4. Simulation de combat (Long ou Short) depuis CETTE époque
+                        is_long = random.choice([True, False])
+                        tp = prix + (atr * tp_m) if is_long else prix - (atr * tp_m)
+                        sl = prix - (atr * sl_m) if is_long else prix + (atr * sl_m)
+                        
+                        # 5. On regarde les 24 bougies suivantes pour voir qui gagne
+                        future_data = df.iloc[idx+1 : idx+25]
+                        win = False
+                        for _, row in future_data.iterrows():
+                            if is_long:
+                                if row['high'] >= tp: win = True; break
+                                if row['low'] <= sl: win = False; break
+                            else:
+                                if row['low'] <= tp: win = True; break
+                                if row['high'] >= sl: win = False; break
+                                
+                        # 6. 🧬 ÉVOLUTION : On récompense ou on punit l'ADN !
+                        mutate_agent(symbol, tf, current_scenario, success=win)
+                        await asyncio.sleep(2) 
+                    except Exception as e: 
+                        pass # On reste silencieux pendant le sommeil
         await asyncio.sleep(60)
 
 def should_send_signal(symbol, timeframe, proba):