Update ml_engine/oracle_engine.py

ml_engine/oracle_engine.py

@@ -1,299 +1,258 @@
 import os
+import joblib
 import numpy as np
 import pandas as pd
 import pandas_ta as ta
 import lightgbm as lgb
-from scipy.signal import find_peaks
 import warnings
 from typing import Dict, Any, List, Optional
 
-# --- [ 0. إعدادات ] ---
+# --- [ إعدادات النظام ] ---
 warnings.filterwarnings('ignore', category=FutureWarning)
 
-PIPELINE_SETTINGS = {
-    'SWING_PROMINENCE_PCT': 0.02, # 2%
-}
-
-DECISION_CONFIDENCE_THRESHOLD = 0.30
-N_STRATEGY_MODELS = 11
-
-STRATEGY_MAP = {
-    0: 'WAIT',
-    1: 'SWING_LONG',
-    2: 'SCALP_LONG',
-    3: 'SWING_SHORT',
-    4: 'SCALP_SHORT'
-}
-
-# (الأطر الزمنية التي تم تدريب النماذج عليها)
-TIMEBYTES_TO_PROCESS = ['15m', '1h', '4h']
-
+# العتبة الذهبية المستخرجة من اختباراتك (عند 0.65 الدقة ~77%)
+CONFIDENCE_THRESHOLD = 0.65 
 
 class OracleEngine:
     def __init__(self, model_dir: str = "ml_models/Unified_Models_V1"):
         """
-        تهيئة "العقل" الاحتمالي (L3 Oracle).
+        Oracle V3.0: The Strategic Brain
+        يدمج نماذج: Direction (Binary), Target (Multiclass), Strength (Regression)
         """
         self.model_dir = model_dir
-        self.strategy_boosters: List[lgb.Booster] = []
-        self.quantile_boosters: Dict[str, lgb.Booster] = {}
+        self.model_direction = None
+        self.model_target = None
+        self.model_strength = None
         
-        self.feature_names: List[str] = []
+        self.feature_cols = []
         self.initialized = False
-        # (تحديث الإصدار)
-        print("🧠 [OracleEngine V2.3] تم الإنشاء (Spot/Long-Only Mode). جاهز للتهيئة.")
+        print("🧠 [Oracle V3] Engine Instance Created.")
 
     async def initialize(self):
-        """
-        تحميل جميع النماذج الـ 15 (11 استراتيجية + 4 أهداف) إلى الذاكرة.
-        """
-        if self.initialized:
-            return True
+        """تحميل النماذج وخريطة الميزات"""
+        if self.initialized: return True
             
-        print(f"🧠 [OracleEngine V2.3] جاري تحميل 15 نموذجاً من {self.model_dir}...")
+        print(f"🧠 [Oracle V3] Loading artifacts from {self.model_dir}...")
         try:
-            # 1. تحميل نماذج "لجنة القرار" (Strategy Ensemble)
-            for i in range(N_STRATEGY_MODELS):
-                model_file = os.path.join(self.model_dir, f"lgbm_strategy_fold_{i}.txt")
-                if not os.path.exists(model_file):
-                    print(f"❌ [Oracle Error] ملف نموذج مفقود: {model_file}")
-                    return False
-                booster = lgb.Booster(model_file=model_file)
-                self.strategy_boosters.append(booster)
-            
-            print(f"   ✅ تم تحميل {len(self.strategy_boosters)} نماذج استراتيجية.")
+            # 1. تحميل خريطة الميزات (لضمان ترتيب الأعمدة)
+            feat_path = os.path.join(self.model_dir, "feature_columns.pkl")
+            if not os.path.exists(feat_path):
+                print(f"❌ [Oracle] Feature map missing: {feat_path}")
+                return False
+            self.feature_cols = joblib.load(feat_path)
+
+            # 2. تحميل النماذج
+            # ملاحظة: تأكد من نقل ملفات .txt من Drive إلى مجلد المشروع المحلي
+            dir_path = os.path.join(self.model_dir, "lgbm_direction.txt")
+            tgt_path = os.path.join(self.model_dir, "lgbm_target_class.txt")
+            str_path = os.path.join(self.model_dir, "lgbm_strength.txt")
+
+            if os.path.exists(dir_path):
+                self.model_direction = lgb.Booster(model_file=dir_path)
+            else:
+                print("❌ [Oracle] Direction Model missing!")
+                return False
 
-            # 2. تحميل نماذج "لجنة الأهداف" (Quantile Models)
-            quantile_names = ['tp_p20', 'tp_p50', 'tp_p80', 'sl_p80']
-            for name in quantile_names:
-                model_file = os.path.join(self.model_dir, f"lgbm_{name}.txt")
-                if not os.path.exists(model_file):
-                    print(f"❌ [Oracle Error] ملف نموذج مفقود: {model_file}")
-                    return False
-                booster = lgb.Booster(model_file=model_file)
-                self.quantile_boosters[name] = booster
+            if os.path.exists(tgt_path):
+                self.model_target = lgb.Booster(model_file=tgt_path)
             
-            print(f"   ✅ تم تحميل {len(self.quantile_boosters)} نماذج أهداف.")
+            if os.path.exists(str_path):
+                self.model_strength = lgb.Booster(model_file=str_path)
 
-            # 3. حفظ قائمة الميزات
-            self.feature_names = self.strategy_boosters[0].feature_name()
             self.initialized = True
-            
-            print(f"✅ [OracleEngine V2.3] جاهز. (Threshold: {DECISION_CONFIDENCE_THRESHOLD*100}%)")
-            print(f"   -> سيعمل على الأطر: {TIMEBYTES_TO_PROCESS}")
+            print(f"✅ [Oracle V3] Ready. Threshold: {CONFIDENCE_THRESHOLD}")
             return True
 
         except Exception as e:
-            print(f"❌ [OracleEngine V2.3] فشل فادح أثناء التهيئة: {e}")
-            self.initialized = False
+            print(f"❌ [Oracle] Init Error: {e}")
             return False
 
-    # --- [ دوال هندسة الميزات (مطابقة 100% للتدريب) ] ---
+    # ==========================================================================
+    # 🛠️ هندسة الميزات (يجب أن تطابق DataFactory حرفياً)
+    # ==========================================================================
     
-    def _calculate_base_ta(self, df: pd.DataFrame) -> pd.DataFrame:
-        df.ta.rsi(length=14, append=True)
-        df.ta.adx(length=14, append=True)
-        df.ta.macd(fast=12, slow=26, signal=9, append=True)
-        df.ta.bbands(length=20, std=2, append=True)
-        df.ta.atr(length=14, append=True)
-        for length in [9, 21, 50, 100, 200]:
-            df[f'EMA_{length}'] = ta.ema(df['close'], length=length)
-        return df
-
-    def _calculate_market_structure(self, df: pd.DataFrame, prominence_pct: float) -> pd.DataFrame:
-        prominence_value = df['close'].mean() * prominence_pct
-        high_peaks_idx, _ = find_peaks(df['high'], prominence=prominence_value)
-        low_peaks_idx, _ = find_peaks(-df['low'], prominence=prominence_value)
-        df['last_SH_price'] = df.iloc[high_peaks_idx]['high'].reindex(df.index).ffill().bfill()
-        df['last_SL_price'] = df.iloc[low_peaks_idx]['low'].reindex(df.index).ffill().bfill()
-        df['BOS_Long'] = np.where(df['close'] > df['last_SH_price'].shift(1), 1, 0)
-        df['BOS_Short'] = np.where(df['low'] < df['last_SL_price'].shift(1), 1, 0)
-        return df
-
-    def _calculate_fibonacci_matrix(self, df: pd.DataFrame) -> pd.DataFrame:
-        wave_range = df['last_SH_price'] - df['last_SL_price']
-        df['fibo_0.382'] = df['last_SH_price'] - (wave_range * 0.382)
-        df['fibo_0.500'] = df['last_SH_price'] - (wave_range * 0.500)
-        df['fibo_0.618'] = df['last_SL_price'] + (wave_range * 0.618)
-        df['fibo_ext_1.618'] = df['last_SH_price'] + (wave_range * 1.618)
-        df['dist_to_0.618_pct'] = (df['close'] - df['fibo_0.618']) / (df['close'] + 1e-9)
-        df['dist_to_1.618_pct'] = (df['fibo_ext_1.618'] - df['close']) / (df['close'] + 1e-9)
-        df['is_in_golden_pocket'] = np.where(
-            (df['close'] < df['fibo_0.500']) & (df['close'] > df['fibo_0.618']), 1, 0
-        )
-        df.replace([np.inf, -np.inf], np.nan, inplace=True)
-        return df
-
-    def _calculate_alpha_strategies(self, df: pd.DataFrame) -> pd.DataFrame:
-        df['volume_zscore'] = (df['volume'] - df['volume'].rolling(50).mean()) / (df['volume'].rolling(50).std() + 1e-9)
-        df['dist_from_EMA200_pct'] = (df['close'] - df['EMA_200']) / (df['EMA_200'] + 1e-9)
+    def _calculate_snapshot_features(self, df, tf_prefix):
+        """حساب المؤشرات الفنية المضغوطة"""
+        df = df.copy()
+        # تحويلات لضمان الدقة
+        df['close'] = df['close'].astype(float)
+        df['volume'] = df['volume'].astype(float)
         
-        bbu_col = next((col for col in df.columns if 'BBU_20_2.0' in str(col)), None)
-        bbl_col = next((col for col in df.columns if 'BBL_20_2.0' in str(col)), None)
-        bbm_col = next((col for col in df.columns if 'BBM_20_2.0' in str(col)), None)
-
-        if all([bbu_col, bbl_col, bbm_col]):
-            df['BBW_pct'] = (df[bbu_col] - df[bbl_col]) / (df[bbm_col] + 1e-9)
-            df['is_squeeze'] = np.where(df['BBW_pct'] < df['BBW_pct'].rolling(100).min(), 1, 0)
-        else:
-            df['BBW_pct'] = np.nan
-            df['is_squeeze'] = 0
-
-        df['is_trending'] = np.where(df['ADX_14'] > 25, 1, 0)
-        df['ATR_pct'] = (df['ATRr_14'] / df['close']) * 100
-        return df
-
-    def _create_feature_vector(self, ohlcv_tf_data: List) -> Optional[pd.DataFrame]:
-        """
-        تشغيل خط أنابيب الميزات الكامل على بيانات إطار زمني واحد.
-        """
-        if ohlcv_tf_data is None or len(ohlcv_tf_data) < 200:
-             return None
+        # 1. Slope
+        df[f'{tf_prefix}_slope'] = ta.slope(df['close'], length=7)
+        # 2. RSI
+        df[f'{tf_prefix}_rsi'] = ta.rsi(df['close'], length=14)
+        # 3. ATR Ratio
+        atr = ta.atr(df['high'], df['low'], df['close'], length=14)
+        df[f'{tf_prefix}_atr_pct'] = atr / df['close']
+        # 4. Volume Z-Score
+        vol_mean = df['volume'].rolling(20).mean()
+        vol_std = df['volume'].rolling(20).std()
+        df[f'{tf_prefix}_vol_z'] = (df['volume'] - vol_mean) / (vol_std + 1e-9)
         
-        df = pd.DataFrame(ohlcv_tf_data, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
-        df = df.astype(float)
-        df['datetime'] = pd.to_datetime(df['timestamp'], unit='ms')
-        df = df.set_index('datetime')
+        # إرجاع الأعمدة فقط (مع ملء الفراغات للحسابات اللحظية)
+        cols = [f'{tf_prefix}_slope', f'{tf_prefix}_rsi', f'{tf_prefix}_atr_pct', f'{tf_prefix}_vol_z']
+        return df[cols].ffill().bfill()
 
-        # تشغيل خط الأنابيب
-        df = self._calculate_base_ta(df)
-        df = self._calculate_market_structure(df, PIPELINE_SETTINGS['SWING_PROMINENCE_PCT'])
-        df = self._calculate_fibonacci_matrix(df)
-        df = self._calculate_alpha_strategies(df)
-        
-        # ملء أي قيم NaN أولية
-        df = df.ffill().bfill()
-        
-        # أخذ آخر صف فقط
-        latest_features = df.iloc[-1:]
-        
+    def _create_feature_vector(self, ohlcv_data: Dict[str, Any], titan_score: float, mc_score: float, pattern_score: float) -> Optional[pd.DataFrame]:
+        """تجميع متجه الميزات ومحاكاة مدخلات الطبقة الثانية"""
         try:
-            feature_vector = latest_features[self.feature_names]
+            # 1. التحقق من البيانات
+            raw_1h = ohlcv_data.get('1h')
+            if not raw_1h or len(raw_1h) < 30: return None
+            
+            # تحويل البيانات إلى DataFrame
+            df_1h = pd.DataFrame(raw_1h, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
+            df_15m = pd.DataFrame(ohlcv_data.get('15m', []), columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
+            df_4h = pd.DataFrame(ohlcv_data.get('4h', []), columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
+
+            # 2. حساب الميزات الفنية (Snapshot)
+            # نأخذ آخر صف فقط (State الحالية)
+            feats_1h = self._calculate_snapshot_features(df_1h, "1h").iloc[-1:].reset_index(drop=True)
+            
+            if len(df_15m) > 20:
+                feats_15m = self._calculate_snapshot_features(df_15m, "15m").iloc[-1:].reset_index(drop=True)
+            else:
+                feats_15m = pd.DataFrame(np.zeros((1, 4)), columns=[f'15m_{c}' for c in ['slope', 'rsi', 'atr_pct', 'vol_z']])
+
+            if len(df_4h) > 20:
+                feats_4h = self._calculate_snapshot_features(df_4h, "4h").iloc[-1:].reset_index(drop=True)
+            else:
+                feats_4h = pd.DataFrame(np.zeros((1, 4)), columns=[f'4h_{c}' for c in ['slope', 'rsi', 'atr_pct', 'vol_z']])
+
+            # 3. التجميع (Vector Assembly)
+            vector = pd.concat([feats_1h, feats_15m, feats_4h], axis=1)
+
+            # 4. حقن درجات الطبقة الثانية (Injection)
+            # هنا نربط الدرجات الحقيقية بالأعمدة التي تدرب عليها النموذج (sim_...)
+            vector['sim_titan_score'] = float(titan_score)
+            vector['sim_mc_score'] = float(mc_score)
+            vector['sim_pattern_score'] = float(pattern_score)
+
+            # 5. محاذاة الأعمدة (Column Alignment)
+            # يجب أن نرسل للنموذج نفس الأعمدة بنفس الترتيب
+            final_vector = pd.DataFrame(columns=self.feature_cols)
+            for col in self.feature_cols:
+                if col in vector.columns:
+                    final_vector.at[0, col] = vector[col].iloc[0]
+                else:
+                    final_vector.at[0, col] = 0.0 # Missing features default to 0
             
-            # --- [ إصلاح المشكلة: NaN Bug ] ---
-            feature_vector = feature_vector.fillna(0)
-            # --- [ نهاية الإصلاح ] ---
+            return final_vector.astype(float)
 
-            if feature_vector.isnull().values.any():
-                print("⚠️ [Oracle Warning] Feature vector still contains NaN after fill(0).")
-                return None
-            return feature_vector
         except Exception as e:
-            print(f"❌ [Oracle Error] عدم تطابق الميزات: {e}")
+            print(f"⚠️ [Oracle] Vector build failed: {e}")
             return None
 
+    # ==========================================================================
+    # 🔮 التنبؤ (Inference Logic)
+    # ==========================================================================
 
     async def predict(self, symbol_data: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        الدالة الرئيسية: تحليل إشارة مرشحة وإرجاع قرار كامل.
-        """
+        """تحليل الفرصة وإصدار التوصية"""
         if not self.initialized:
-            return {'action': 'WAIT', 'reason': 'Oracle Engine not initialized'}
-
-        ohlcv_data = symbol_data.get('ohlcv')
-        current_price = symbol_data.get('current_price')
-        if not ohlcv_data or not current_price:
-            return {'action': 'WAIT', 'reason': 'Missing OHLCV or price data'}
+            return {'action': 'WAIT', 'reason': 'Not initialized'}
 
         try:
-            all_tf_decisions = []
-
-            # --- [ الخطوة 1: تحليل كل إطار زمني على حدة ] ---
-            for tf in TIMEBYTES_TO_PROCESS:
-                feature_vector = self._create_feature_vector(ohlcv_data.get(tf))
-                
-                if feature_vector is None:
-                    print(f"   -> {symbol_data['symbol']} @ {tf}: Skipped (Insufficient data or NaN)")
-                    continue
-                
-                all_probs = [
-                    booster.predict(feature_vector, num_iteration=booster.best_iteration)
-                    for booster in self.strategy_boosters
-                ]
-                ensemble_probs = np.mean(all_probs, axis=0)[0] 
-                
-                # --- [ إصلاح المشكلة: منطق WAIT ] ---
-                actionable_probs = ensemble_probs.copy()
-                actionable_probs[0] = 0.0 # (تجاهل WAIT)
-                
-                predicted_strategy_idx = np.argmax(actionable_probs)
-                confidence = actionable_probs[predicted_strategy_idx] 
-                strategy_name = STRATEGY_MAP.get(predicted_strategy_idx, 'WAIT')
-                # --- [ نهاية الإصلاح ] ---
-
-                all_tf_decisions.append({
-                    'timeframe': tf,
-                    'strategy': strategy_name,
-                    'confidence': float(confidence),
-                    'feature_vector': feature_vector
-                })
-
-            if not all_tf_decisions:
-                return {'action': 'IGNORE', 'reason': 'Feature calculation failed for all TFs'}
-
-            # --- [ الخطوة 2: اختيار القرار الأفضل (أعلى ثقة) ] ---
-            best_decision = max(all_tf_decisions, key=lambda x: x['confidence'])
-
-            strategy_name = best_decision['strategy']
-            confidence = best_decision['confidence']
-            best_tf = best_decision['timeframe']
+            # استلام البيانات
+            ohlcv = symbol_data.get('ohlcv')
+            current_price = symbol_data.get('current_price', 0.0)
+            
+            # الدرجات القادمة من L2
+            titan = symbol_data.get('titan_score', 0.5)
+            mc = symbol_data.get('mc_score', 0.5)
+            patt = symbol_data.get('patterns_score', 0.5)
+
+            # 1. بناء المتجه
+            features = self._create_feature_vector(ohlcv, titan, mc, patt)
+            if features is None:
+                return {'action': 'WAIT', 'reason': 'Features failed'}
+
+            # 2. التنبؤ بالاتجاه (Direction)
+            # النموذج يعيد احتمالية لكل كلاس. بما أننا دربنا 1=Long, 2=Short
+            # LightGBM (Multi-class) يعيد array: [Prob_Wait(محذوف عملياً), Prob_Long, Prob_Short]
+            # أو إذا كان Binary (0=Long, 1=Short) يعيد احتمالية Short.
+            # *تذكير*: في كود التدريب الأخير استخدمنا: y - 1. إذن: 0=Long, 1=Short.
+            
+            dir_probs = self.model_direction.predict(features)[0] # Array [Prob_Long, Prob_Short]
+            
+            # التعامل مع نوع المخرجات (حسب نسخة LightGBM)
+            if isinstance(dir_probs, (np.ndarray, list)):
+                prob_long = dir_probs[0]
+                prob_short = dir_probs[1]
+            else:
+                # Binary objective case
+                prob_short = dir_probs
+                prob_long = 1.0 - dir_probs
+
+            # تحديد الاتجاه الأقوى
+            if prob_long > prob_short:
+                direction = "LONG"
+                confidence = prob_long
+            else:
+                direction = "SHORT"
+                confidence = prob_short
 
-            # --- [ 🛑 🛑 🛑 التعديل الجديد: فلتر Spot Only ] ---
-            # إذا كانت الاستراتيجية تحتوي على "SHORT"، يتم تجاهلها فوراً
-            if "SHORT" in strategy_name:
+            # 3. البوابة المنطقية (Threshold Check)
+            if confidence < CONFIDENCE_THRESHOLD:
                 return {
-                    'action': 'IGNORE',
-                    'reason': f"Spot Mode: Ignored {strategy_name} signal (Shorts disabled)",
-                    'confidence': confidence,
-                    'strategy': strategy_name
+                    'action': 'WAIT',
+                    'reason': f'Low Confidence ({confidence:.2f} < {CONFIDENCE_THRESHOLD})',
+                    'direction': direction
                 }
-            # --- [ نهاية التعديل ] ---
 
-            # --- [ الخطوة 3: تطبيق فلتر الثقة ] ---
-            if confidence < DECISION_CONFIDENCE_THRESHOLD:
-                return {
-                    'action': 'IGNORE',
-                    'reason': f"Best Actionable Signal ({strategy_name} @ {best_tf}) confidence ({confidence:.2f}) is below threshold ({DECISION_CONFIDENCE_THRESHOLD})",
-                    'confidence': confidence,
-                    'strategy': strategy_name
-                }
+            # 4. التنبؤ بالأهداف والقوة (فقط للفرص المؤكدة)
             
-            # --- [ الخطوة 4: (نجحت الثقة) - تشغيل "لجنة الأهداف" ] ---
-            winning_feature_vector = best_decision['feature_vector']
-            preds_quantile = {}
-            for name, booster in self.quantile_boosters.items():
-                preds_quantile[name] = booster.predict(winning_feature_vector, num_iteration=booster.best_iteration)[0]
-
-            # --- [ الخطوة 5: تحديد الأهداف النهائية ] ---
-            tp_pct = preds_quantile['tp_p50'] # (الهدف الواقعي)
-            sl_pct = preds_quantile['sl_p80'] # (وقف الخسارة الآمن)
+            # Strength (Regression: 0.0 - 1.0)
+            strength = 0.5
+            if self.model_strength:
+                strength = float(self.model_strength.predict(features)[0])
+                strength = max(0.0, min(1.0, strength)) # Clip
+
+            # Target Class (0=TP1, 1=TP2, 2=TP3, 3=TP4)
+            tp_class_idx = 1 # Default TP2
+            if self.model_target:
+                tgt_probs = self.model_target.predict(features)[0]
+                tp_class_idx = np.argmax(tgt_probs)
             
-            if tp_pct <= 0 or sl_pct <= 0:
-                return {'action': 'IGNORE', 'reason': f'Quantile model predicted negative TP/SL ({tp_pct=}, {sl_pct=})'}
+            tp_labels = ['TP1', 'TP2', 'TP3', 'TP4']
+            target_profile = tp_labels[tp_class_idx]
 
-            if "LONG" in strategy_name:
-                tp_price = current_price * (1 + tp_pct)
-                sl_price = current_price * (1 - sl_pct)
-                action_type = "BUY"
-            else:
-                # (لن نصل إلى هنا لأننا قمنا بتصفية SHORT مسبقاً)
-                return {'action': 'IGNORE', 'reason': 'Strategy not actionable (Unknown type)'}
+            # 5. حساب المستويات السعرية (ATR-Based)
+            # نحتاج قيمة ATR الحالية
+            atr_pct_val = features['1h_atr_pct'].iloc[0]
+            atr_abs = atr_pct_val * current_price
+            
+            dir_mult = 1 if direction == "LONG" else -1
+            
+            # خريطة الأهداف
+            tp_map = {
+                'TP1': current_price + (dir_mult * 0.8 * atr_abs),
+                'TP2': current_price + (dir_mult * 1.5 * atr_abs),
+                'TP3': current_price + (dir_mult * 2.5 * atr_abs),
+                'TP4': current_price + (dir_mult * 4.0 * atr_abs),
+            }
+            
+            # الهدف الأساسي الموصى به
+            primary_tp = tp_map[target_profile]
+            
+            # الوقف (Stop Loss) - دائماً 1.2 ATR كبداية
+            sl_price = current_price - (dir_mult * 1.2 * atr_abs)
 
-            # --- [ الخطوة 6: إرجاع القرار الكامل ] ---
             return {
-                'action': 'WATCH', 
-                'confidence': confidence,
-                'analysis_summary': f"Oracle Consensus @ {best_tf}: {strategy_name} (Conf: {confidence:.2%})",
-                'strategy': strategy_name,
-                'action_type': action_type, 
-                'tp_price': float(tp_price),
+                'action': 'WATCH',         # إشارة صالحة للمتابعة
+                'action_type': 'BUY' if direction == "LONG" else 'SELL',
+                'confidence': float(confidence),
+                'strength': float(strength),
+                'target_class': target_profile,
+                'primary_tp': float(primary_tp),
                 'sl_price': float(sl_price),
-                'quantile_tp_pct': float(tp_pct),
-                'quantile_sl_pct': float(sl_pct)
+                'tp_map': tp_map,
+                'analysis_summary': f"{direction} (Conf: {confidence:.0%}) | Strength: {strength:.2f} | Aiming: {target_profile}"
             }
 
         except Exception as e:
-            print(f"❌ [OracleEngine V2.3] فشل فادح أثناء التنبؤ: {e}")
+            print(f"❌ [Oracle] Prediction Error: {e}")
             import traceback
             traceback.print_exc()
-            return {'action': 'WAIT', 'reason': f'Exception: {e}'}
+            return {'action': 'WAIT', 'reason': 'Error'}