Update learning_hub/reflector.py

learning_hub/reflector.py

@@ -1,12 +1,11 @@
 # learning_hub/reflector.py
-# (محدث بالكامل - V2 - تمرير الأخبار للتعلم السريع)
+# (V12.3 Full - Hybrid Aware)
 import json
 import traceback
 from typing import Dict, Any, TYPE_CHECKING
 from .schemas import TraceLog, ReflectorOutput
 from .memory_store import MemoryStore
 
-# (استخدام TYPE_CHECKING لتجنب الاستيراد الدائري الفعلي)
 if TYPE_CHECKING:
     from LLM import LLMService
 
@@ -14,170 +13,99 @@ class Reflector:
     def __init__(self, llm_service: 'LLMService', memory_store: MemoryStore):
         self.llm_service = llm_service
         self.memory_store = memory_store
-        print("✅ Learning Hub Module: Reflector (Fast-Learner) loaded")
+        print("✅ Learning Hub: Reflector (Hybrid Aware) loaded")
 
     async def analyze_trade_outcome(self, trade_object: Dict[str, Any], close_reason: str):
-        """
-        Analyzes the trade outcome using LLM to generate a learning 'Delta' (rule).
-        (Implements Point 2 & 4 of the 16-point plan)
-        """
         try:
-            # 1. Create the TraceLog
-            # (Note: We assume TradeManager now saves 'market_context_at_decision',
-            # 'indicators_at_decision', 'news_text', and 'news_score'
-            # inside 'decision_data' when opening the trade)
-            
             decision_data = trade_object.get('decision_data', {})
             
             trace_log = TraceLog(
                 decision_context=decision_data,
                 market_context_at_decision=decision_data.get('market_context_at_decision', {}),
                 indicators_at_decision=decision_data.get('indicators_at_decision', {}),
+                # تمرير الأوزان التي استخدمت فعلياً
+                hybrid_weights_used=decision_data.get('hybrid_weights_at_entry', {}),
                 closed_trade_object=trade_object,
                 actual_outcome_reason=close_reason
             )
             
-            # 2. Create the Reflector Prompt (Now in English)
-            # 🔴 --- START OF CHANGE (V2 - News Learning) --- 🔴
-            # (تمرير بيانات الأخبار (التي يفترض أنها في decision_data) إلى الـ prompt)
-            news_text_at_decision = decision_data.get('news_text', 'No news data available at decision time.')
-            news_score_at_decision = decision_data.get('news_score', 0.0) # (VADER raw score)
-            
-            prompt = self._create_reflector_prompt(
-                trace_log, 
-                news_text_at_decision, 
-                news_score_at_decision
-            )
-            # 🔴 --- END OF CHANGE --- 🔴
-            
-            # 3. Call the LLM
+            prompt = self._create_reflector_prompt(trace_log, decision_data)
             response_text = await self.llm_service._call_llm(prompt)
             
-            if not response_text:
-                raise ValueError("Reflector LLM call returned no response.")
+            if not response_text: raise ValueError("LLM returned no response.")
 
-            # 4. Parse the response
-            # (We use the enhanced parser from LLM.py which handles JSON)
             reflector_json = self.llm_service._parse_llm_response_enhanced(
-                response_text, 
-                fallback_strategy="reflection", 
-                symbol=trade_object.get('symbol', 'N/A')
+                response_text, fallback_strategy="reflection", symbol=trade_object.get('symbol', 'N/A')
             )
             
-            if not reflector_json:
-                raise ValueError(f"Failed to parse Reflector LLM response: {response_text}")
+            if not reflector_json: raise ValueError("Failed to parse LLM response")
 
-            # (Validate against the strict schema from schemas.py)
             reflector_output = ReflectorOutput(**reflector_json)
+            domain = self._determine_domain(trade_object.get('strategy', 'general'), reflector_output.error_mode)
             
-            # 5. Determine the 'Domain' for the Delta
-            strategy = trade_object.get('strategy', 'general')
-            domain = self._determine_domain(strategy, reflector_output.error_mode)
-            
-            # 6. Save the suggested 'Delta' to the Memory Store
-            # (MemoryStore will use PolicyEngine to decide on auto-approval)
-            await self.memory_store.save_new_delta(
-                reflector_output=reflector_output,
-                trade_object=trade_object,
-                domain=domain
-            )
-            
-            print(f"✅ [Reflector] Successfully analyzed {trade_object.get('symbol')}. New Delta created.")
+            await self.memory_store.save_new_delta(reflector_output, trade_object, domain)
+            print(f"✅ [Reflector] Analyzed {trade_object.get('symbol')}. New Delta created.")
             
         except Exception as e:
-            print(f"❌ [Reflector] Failed to analyze trade outcome for {trade_object.get('symbol')}: {e}")
+            print(f"❌ [Reflector] Analysis failed: {e}")
             traceback.print_exc()
 
     def _determine_domain(self, strategy: str, error_mode: str) -> str:
-        """Determines the domain the suggested Delta belongs to."""
-        error_mode = error_mode.lower()
-        if "pattern" in error_mode or "triangle" in error_mode or "flag" in error_mode:
-            return "pattern"
-        if "indicator" in error_mode or "rsi" in error_mode or "macd" in error_mode:
-            return "indicator"
-        if "monte_carlo" in error_mode or "garch" in error_mode or "simulation" in error_mode:
-            return "monte_carlo"
-        
-        # 🔴 --- START OF CHANGE (V2 - News Learning) --- 🔴
-        if "news" in error_mode or "sentiment" in error_mode or "sec" in error_mode:
-            return "general" # (أو يمكننا إنشاء مجال "news" جديد)
-        # 🔴 --- END OF CHANGE --- 🔴
-        
-        if "strategy" in error_mode or "exit" in error_mode or "entry" in error_mode:
-            return "strategy"
-        
-        # Default to the strategy's domain
-        if strategy in ["trend_following", "mean_reversion", "breakout_momentum"]:
-             return "strategy"
-             
-        return "general"
+        em = error_mode.lower()
+        if "pattern" in em: return "pattern"
+        if "indicator" in em or "rsi" in em: return "indicator"
+        if "monte_carlo" in em: return "monte_carlo"
+        if "titan" in em or "model" in em: return "strategy" # تصنيف أخطاء تيتان ضمن الاستراتيجية
+        if "news" in em: return "general"
+        return "strategy"
 
-    # 🔴 --- START OF CHANGE (V2 - News Learning) --- 🔴
-    def _create_reflector_prompt(
-        self, 
-        trace_log: TraceLog, 
-        news_text: str, 
-        news_score: float
-    ) -> str:
-    # 🔴 --- END OF CHANGE --- 🔴
-        """
-        Creates the (English-only) prompt for the LLM to act as a Reflector.
-        (Implements Point 4 - Reflector prompt)
-        """
-        
+    def _create_reflector_prompt(self, trace_log: TraceLog, decision_data: Dict) -> str:
         trade = trace_log.closed_trade_object
-        pnl_percent = trade.get('pnl_percent', 0)
-        
-        # Determine initial success
-        is_success = pnl_percent > 0.1 # (Consider any small profit a success)
+        pnl = trade.get('pnl_percent', 0)
+        is_success = pnl > 0.1
         
-        # 🔴 --- START OF CHANGE (V2 - News Learning) --- 🔴
-        # (إضافة قسم الأخبار إلى الـ prompt)
-        news_context_section = f"""
-4.  **News Context (at entry):**
-    * VADER Score (Raw): {news_score:.4f}
-    * News Text: {news_text}
+        # 🔴 إدراج تفاصيل المكونات الهجينة في الموجه
+        comps = decision_data.get('components', {})
+        hybrid_context = f"""
+    * Hybrid Score Breakdown (Total: {trade.get('score', 'N/A'):.4f}):
+        - Titan Model Score: {comps.get('titan_score', 'N/A'):.2f}
+        - Chart Patterns Score: {comps.get('patterns_score', 'N/A'):.2f}
+        - Monte Carlo Score: {comps.get('mc_score', 'N/A'):.2f}
+    * Weights Used at Entry: {json.dumps(trace_log.hybrid_weights_used)}
+"""
+        news_context = f"""
+    * News VADER Score: {decision_data.get('news_score', 0.0):.4f}
+    * News Text: {decision_data.get('news_text', 'N/A')}
 """
-        # 🔴 --- END OF CHANGE --- 🔴
-        
-        prompt = f"""
-SYSTEM: You are an expert trading analyst Reflector. Your task is to analyze a completed trade "Trace" and determine the cause of success or failure. You must suggest a concise "Rule" (Delta) (max 25 words) to improve future performance.
 
---- TRACE LOG START ---
+        return f"""
+SYSTEM: You are an expert trading analyst Reflector. Analyze this "Trace" of a hybrid AI trading decision.
+Did the primary model (Titan) mislead us, or did the secondary models (Patterns/MC) cause a false positive?
 
-1.  **Original Decision Context (What we decided):**
-    * Strategy Used: {trade.get('strategy', 'N/A')}
-    * Exit Profile: {trade.get('decision_data', {}).get('exit_profile', 'N/A')}
-    * Reasoning (at entry): {trade.get('decision_data', {}).get('reasoning', 'N/A')[:200]}...
-    * Entry Price: {trade.get('entry_price')}
-    * Initial Stop Loss: {trade.get('stop_loss')}
-    * Initial Take Profit: {trade.get('take_profit')}
+--- TRACE LOG START ---
+1. DECISION CONTEXT:
+    * Strategy: {trade.get('strategy', 'N/A')}
+    {hybrid_context}
+    * Entry Reasoning: {decision_data.get('reasoning', 'N/A')[:300]}...
 
-2.  **Environment Context (When we decided):**
-    * Market Context: {json.dumps(trace_log.market_context_at_decision)}
-    * Key Indicators: {json.dumps(trace_log.indicators_at_decision)}
+2. NEWS CONTEXT:
+    {news_context}
 
-3.  **Actual Outcome (What happened):**
-    * Close Price: {trade.get('close_price')}
-    * Final PnL: {pnl_percent:+.2f}%
+3. OUTCOME:
+    * Final PnL: {pnl:+.2f}%
     * Close Reason: {trace_log.actual_outcome_reason}
-    * Trade Duration: {trade.get('hold_duration_minutes', 'N/A')} minutes
 
-{news_context_section}
 --- TRACE LOG END ---
 
-TASK: Analyze the Trace above.
-1.  Compare the "Actual Outcome" with the "Original Decision Context".
-2.  **Crucially, review the "News Context".** Did the market react as the VADER score predicted? Did the news text contain critical information that was missed?
-3.  Identify the primary "Error Mode" (e.g., 'ignored_negative_news', 'premature_exit') or "Success Factor" (e.g., 'correct_pattern_identification').
-4.  Suggest ONE concise "Rule" (Delta) (max 25 words) to improve performance. If the news was the cause, the rule MUST mention news.
+TASK: Identify the root cause of success/failure. Focus on which hybrid component was most accurate/inaccurate.
+SUGGEST RULE (Delta): Max 25 words. E.g., "If Titan > 0.95 but Patterns < 0.60, reduce position size."
 
-OUTPUT FORMAT (JSON Only - Adhere strictly to this schema):
+OUTPUT JSON:
 {{
   "success": {str(is_success).lower()},
   "score": 0.0,
-  "error_mode": "Short description of the error mode (e.g., 'ignored_negative_news_SEC_investigation').",
-  "suggested_rule": "The concise 25-word rule (e.g., 'If news contains 'SEC' or 'investigation', do not BUY regardless of technicals.').",
+  "error_mode": "Short description (e.g., 'titan_false_positive_ignored_patterns')",
+  "suggested_rule": "Concise 25-word rule.",
   "confidence": 0.0 
 }}
 """