diff --git a/back_tester/README.md b/back_tester/README.md
index 58a4d48..359f436 100644
--- a/back_tester/README.md
+++ b/back_tester/README.md
@@ -257,13 +257,168 @@ cd reports/examples
 9. **Track drawdowns carefully** - Maximum drawdown is often more important than returns
 10. **Test over multiple time periods** - Market conditions change over time
 
+### 10. Adaptive Learning System (`adaptive_learning.py`) ⭐ NEW
+
+Self-learning capabilities that automatically adjust signal weights based on performance:
+- **Signal Performance Tracking** - Track each signal with its contributing indicators
+- **Adaptive Weight Adjustment** - Automatically adjust weights based on what works
+- **Indicator Attribution** - Identify which indicators contribute to wins/losses
+- **Learning Analytics** - Detailed reports on indicator and regime performance
+
+```python
+from back_tester.adaptive_learning import SelfLearningBacktester
+
+# Create self-learning backtester
+learner = SelfLearningBacktester(
+    storage_path="./data/learning",
+    auto_adjust_weights=True,
+    adjustment_frequency=50  # Adjust weights every 50 signals
+)
+
+# Get adaptive weights (these improve over time)
+weights = learner.get_current_weights()
+
+# Run backtest with learning enabled
+final_balance, trades, _ = backtest_strategy(
+    symbol="BTCUSDT",
+    interval="1h",
+    candles=500,
+    enable_learning=True,
+    learner=learner,
+)
+
+# View performance analytics
+learner.print_status()
+
+# Get detailed indicator performance
+indicator_perf = learner.tracker.get_indicator_performance()
+print(indicator_perf)
+
+# Identify what works
+strong = learner.tracker.identify_strong_indicators()
+weak = learner.tracker.identify_weak_indicators()
+print(f"Strong indicators: {strong}")
+print(f"Weak indicators: {weak}")
+```
+
+
+### Architecture Overview
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                    BACKTESTING FLOW                             │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                 │
+│  ┌─────────────┐    ┌───────────────┐    ┌─────────────────┐    │
+│  │ Data Fetch  │───▶│Signal Generate│───▶│  Trade Execute  │    │
+│  └─────────────┘    └───────────────┘    └─────────────────┘    │
+│                            │                      │             │
+│                            ▼                      ▼             │
+│                   ┌──────────────┐    ┌─────────────────┐       │
+│                   │  Weights     │    │ Record Outcome  │       │
+│                   │  (18 total)  │    └─────────────────┘       │
+│                   └──────────────┘              │               │
+│                           ▲                     │               │
+│                           │                     ▼               │
+│                   ┌───────────────────────────────────┐         │
+│                   │     SELF-LEARNING SYSTEM          │         │
+│                   │  ┌─────────────────────────────┐  │         │
+│                   │  │ SignalPerformanceTracker    │  │         │
+│                   │  │ - Track indicator contrib   │  │         │
+│                   │  │ - Record signal outcomes    │  │         │
+│                   │  └─────────────────────────────┘  │         │
+│                   │               │                   │         │
+│                   │               ▼                   │         │
+│                   │  ┌─────────────────────────────┐  │         │
+│                   │  │ AdaptiveWeightAdjuster      │  │         │
+│                   │  │ - Calculate adjustments     │  │         │
+│                   │  │ - Apply momentum learning   │  │         │
+│                   │  └─────────────────────────────┘  │         │
+│                   └───────────────────────────────────┘         │
+│                                                                 │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+### 11. Enhanced Metrics (`enhanced_metrics.py`) ⭐ NEW
+
+Comprehensive, informative metrics with indicator-level breakdown:
+- **Trade Attribution** - Track which indicators contributed to each trade
+- **Regime Analysis** - Performance breakdown by market regime
+- **Exit Type Analysis** - Understand where trades close (TP1, TP2, TP3, SL)
+- **Actionable Insights** - Get recommendations for improvement
+
+```python
+from back_tester.enhanced_metrics import EnhancedMetricsCalculator
+
+# Create metrics calculator
+calc = EnhancedMetricsCalculator()
+
+# After running backtests, print detailed report
+calc.print_detailed_report(initial_balance=10000, final_balance=10500)
+
+# Get comprehensive metrics
+metrics = calc.calculate_comprehensive_metrics(10000, 10500)
+print(f"Indicator Performance: {metrics['indicator_performance']}")
+print(f"Regime Performance: {metrics['regime_performance']}")
+print(f"Recommendations: {metrics['insights']['recommendations']}")
+```
+
+## How the Self-Learning System Works
+
+The self-learning system creates a feedback loop that improves signal quality over time:
+
+1. **Signal Generation** - When a signal is generated, the system records which indicators contributed to it
+2. **Outcome Tracking** - When the trade closes (TP1, TP2, TP3, stop loss, or end of period), the outcome is recorded
+3. **Attribution Analysis** - The system analyzes which indicators are associated with winning vs losing trades
+4. **Weight Adjustment** - Weights for consistently underperforming indicators are reduced, while weights for strong performers are increased
+5. **Continuous Improvement** - Over many trades, the system converges on optimal weights for current market conditions
+
+### Key Components
+
+| Component | Description |
+|-----------|-------------|
+| `SignalPerformanceTracker` | Tracks all signals with their outcomes and indicator contributions |
+| `AdaptiveWeightAdjuster` | Calculates and applies weight adjustments based on performance |
+| `LearningMetricsAnalyzer` | Generates reports and recommendations |
+| `SelfLearningBacktester` | Integrates all components for easy use |
+
+### Example Workflow
+
+```python
+# Step 1: Initialize the learning system
+from back_tester import SelfLearningBacktester, backtest_strategy
+
+learner = SelfLearningBacktester(auto_adjust_weights=True)
+
+# Step 2: Run multiple backtests to build data
+for symbol in ["BTCUSDT", "ETHUSDT", "BNBUSDT"]:
+    backtest_strategy(
+        symbol=symbol,
+        interval="1h",
+        enable_learning=True,
+        learner=learner
+    )
+
+# Step 3: View what the system learned
+report = learner.get_performance_report()
+print(f"Win Rate: {report['summary']['recent_win_rate']:.1f}%")
+print(f"Strong Indicators: {report['indicator_analysis']['strong_indicators']}")
+print(f"Weak Indicators: {report['indicator_analysis']['weak_indicators']}")
+
+# Step 4: Get updated weights for future use
+new_weights = learner.get_current_weights()
+print(f"Optimized weights: {new_weights}")
+```
+
 ## Next Steps for Improvement
 
-1. Implement machine learning for signal enhancement
-2. Add cross-validation for more robust parameter testing
-3. Implement portfolio-level backtesting for multiple assets
-4. Add regime switching capabilities based on market conditions
-5. Develop adaptive strategy selection based on market regime
+1. ~~Implement machine learning for signal enhancement~~ ✅ Done
+2. ~~Add self-learning weight adjustment~~ ✅ Done  
+3. ~~Implement indicator performance tracking~~ ✅ Done
+4. Add cross-validation for more robust parameter testing
+5. Implement portfolio-level backtesting for multiple assets
+6. Add regime switching capabilities based on market conditions
+7. Develop adaptive strategy selection based on market regime
 
 ## Backtesting Launcher Script
 
diff --git a/back_tester/__init__.py b/back_tester/__init__.py
index 1d1038b..133b7c0 100644
--- a/back_tester/__init__.py
+++ b/back_tester/__init__.py
@@ -2,7 +2,50 @@
 Enhanced Backtesting System for Cryptocurrency Trading
 
 This package provides comprehensive tools for strategy development,
-testing, and optimization for cryptocurrency trading.
+testing, optimization, and self-learning for cryptocurrency trading.
+
+New in v1.1.0:
+- Adaptive Learning System: Automatically adjusts signal weights based on performance
+- Signal Performance Tracking: Tracks which indicators contribute to winning/losing trades
+- Enhanced Metrics: Detailed breakdown by indicator, market regime, and symbol
 """
 
-__version__ = "1.0.0"
+__version__ = "1.1.0"
+
+# Core modules
+from .strategy import backtest_strategy
+
+# Self-learning modules (optional — graceful fallback if dependencies missing)
+try:
+    from .adaptive_learning import (
+        SelfLearningBacktester,
+        SignalPerformanceTracker,
+        AdaptiveWeightAdjuster,
+        LearningMetricsAnalyzer,
+        SignalRecord,
+        SignalOutcome,
+        extract_indicator_contributions,
+    )
+    from .enhanced_metrics import (
+        EnhancedMetricsCalculator,
+        TradeMetrics,
+        create_trade_metrics,
+    )
+    LEARNING_AVAILABLE = True
+except ImportError:
+    LEARNING_AVAILABLE = False
+
+__all__ = [
+    # Core
+    "backtest_strategy",
+    "LEARNING_AVAILABLE",
+]
+
+if LEARNING_AVAILABLE:
+    __all__ += [
+        "SelfLearningBacktester",
+        "SignalPerformanceTracker",
+        "AdaptiveWeightAdjuster",
+        "LearningMetricsAnalyzer",
+        "EnhancedMetricsCalculator",
+    ]
diff --git a/back_tester/adaptive_learning.py b/back_tester/adaptive_learning.py
new file mode 100644
index 0000000..ec7b705
--- /dev/null
+++ b/back_tester/adaptive_learning.py
@@ -0,0 +1,844 @@
+"""
+Adaptive Learning Module for Backtesting System
+
+This module provides self-learning capabilities for the backtesting system:
+1. SignalPerformanceTracker - Tracks individual signal outcomes with indicator attribution
+2. AdaptiveWeightAdjuster - Adjusts weights based on signal performance
+3. IndicatorAttributor - Attributes success/failure to specific indicators
+4. LearningMetricsAnalyzer - Provides detailed analytics on what works and what doesn't
+
+The system learns from failures and automatically adjusts coefficients to improve future signals.
+"""
+
+import os
+import json
+import numpy as np
+import pandas as pd
+from typing import Dict, List, Any, Optional
+from dataclasses import dataclass, field, asdict
+from datetime import datetime
+from collections import defaultdict
+import logging
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+
+class SignalOutcome(Enum):
+    """Possible outcomes for a trading signal"""
+    TP1_HIT = "tp1_hit"
+    TP2_HIT = "tp2_hit"
+    TP3_HIT = "tp3_hit"
+    STOP_LOSS = "stop_loss"
+    TRAILING_STOP = "trailing_stop"
+    END_OF_PERIOD = "end_of_period"
+    BREAKEVEN = "breakeven"
+    PENDING = "pending"
+
+
+@dataclass
+class SignalRecord:
+    """Complete record of a signal with its contributing factors and outcome"""
+    signal_id: str
+    timestamp: datetime
+    symbol: str
+    interval: str
+    signal_type: str  # Bullish/Bearish
+    entry_price: float
+    stop_loss: float
+    take_profit_1: float
+    take_profit_2: float
+    take_profit_3: float
+    
+    # Contributing indicators and their scores
+    indicator_contributions: Dict[str, float] = field(default_factory=dict)
+    
+    # Reasons that triggered the signal
+    reasons: List[str] = field(default_factory=list)
+    
+    # Market context at signal time
+    market_regime: str = ""
+    volatility: float = 0.0
+    volume_ratio: float = 1.0
+    rsi: float = 50.0
+    trend: str = ""
+    
+    # Outcome tracking
+    outcome: SignalOutcome = SignalOutcome.PENDING
+    exit_price: float = 0.0
+    profit_loss: float = 0.0
+    profit_loss_percent: float = 0.0
+    duration_candles: int = 0
+    max_favorable_excursion: float = 0.0  # Max profit during trade
+    max_adverse_excursion: float = 0.0    # Max loss during trade
+    
+    # Weights used at signal time
+    weights_at_signal: List[float] = field(default_factory=list)
+    
+    def is_successful(self) -> bool:
+        """Determine if the signal was successful"""
+        return self.outcome in [SignalOutcome.TP1_HIT, SignalOutcome.TP2_HIT, 
+                                SignalOutcome.TP3_HIT, SignalOutcome.TRAILING_STOP]
+    
+    def to_dict(self) -> Dict:
+        """Convert to dictionary for storage"""
+        data = asdict(self)
+        data['outcome'] = self.outcome.value
+        data['timestamp'] = self.timestamp.isoformat()
+        return data
+    
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'SignalRecord':
+        """Create from dictionary"""
+        data = data.copy()
+        data['outcome'] = SignalOutcome(data['outcome'])
+        data['timestamp'] = datetime.fromisoformat(data['timestamp'])
+        return cls(**data)
+
+
+class SignalPerformanceTracker:
+    """
+    Tracks individual signal performance and attributes outcomes to specific indicators.
+    This enables learning from both successes and failures.
+    """
+    
+    # Weight names for attribution
+    WEIGHT_NAMES = [
+        "W_BULLISH_OB", "W_BEARISH_OB", "W_BULLISH_BREAKER", "W_BEARISH_BREAKER",
+        "W_ABOVE_SUPPORT", "W_BELOW_RESISTANCE", "W_FVG_ABOVE", "W_FVG_BELOW",
+        "W_TREND", "W_SWEEP_HIGHS", "W_SWEEP_LOWS", "W_STRUCTURE_BREAK",
+        "W_PIN_BAR", "W_ENGULFING", "W_LIQUIDITY_POOL_ABOVE", "W_LIQUIDITY_POOL_BELOW",
+        "W_LIQUIDITY_POOL_ROUND", "W_RSI_EXTREME"
+    ]
+    
+    def __init__(self, storage_path: str = "./data/signal_history"):
+        self.storage_path = storage_path
+        os.makedirs(storage_path, exist_ok=True)
+        
+        self.signals: List[SignalRecord] = []
+        self.performance_by_indicator: Dict[str, Dict] = defaultdict(
+            lambda: {"wins": 0, "losses": 0, "total_pnl": 0.0, "count": 0}
+        )
+        self.performance_by_market_regime: Dict[str, Dict] = defaultdict(
+            lambda: {"wins": 0, "losses": 0, "total_pnl": 0.0, "count": 0}
+        )
+        self.performance_by_symbol: Dict[str, Dict] = defaultdict(
+            lambda: {"wins": 0, "losses": 0, "total_pnl": 0.0, "count": 0}
+        )
+        
+        self._load_history()
+    
+    def _load_history(self):
+        """Load signal history from storage"""
+        history_file = os.path.join(self.storage_path, "signal_history.json")
+        if os.path.exists(history_file):
+            try:
+                with open(history_file, 'r') as f:
+                    data = json.load(f)
+                    self.signals = [SignalRecord.from_dict(s) for s in data.get('signals', [])]
+                    self._rebuild_performance_stats()
+                logger.info(f"Loaded {len(self.signals)} historical signals")
+            except Exception as e:
+                logger.warning(f"Failed to load signal history: {e}")
+    
+    def _save_history(self):
+        """Save signal history to storage"""
+        history_file = os.path.join(self.storage_path, "signal_history.json")
+        try:
+            with open(history_file, 'w') as f:
+                json.dump({
+                    'signals': [s.to_dict() for s in self.signals[-10000:]],  # Keep last 10k
+                    'last_updated': datetime.now().isoformat()
+                }, f, indent=2)
+        except Exception as e:
+            logger.error(f"Failed to save signal history: {e}")
+    
+    def _rebuild_performance_stats(self):
+        """Rebuild performance statistics from loaded signals"""
+        for signal in self.signals:
+            if signal.outcome != SignalOutcome.PENDING:
+                self._update_stats(signal)
+    
+    def _update_stats(self, signal: SignalRecord):
+        """Update performance statistics for a completed signal"""
+        is_win = signal.is_successful()
+        
+        # Update by indicator
+        for indicator, contribution in signal.indicator_contributions.items():
+            if contribution > 0:
+                stats = self.performance_by_indicator[indicator]
+                stats["count"] += 1
+                stats["total_pnl"] += signal.profit_loss
+                if is_win:
+                    stats["wins"] += 1
+                else:
+                    stats["losses"] += 1
+        
+        # Update by market regime
+        regime_stats = self.performance_by_market_regime[signal.market_regime]
+        regime_stats["count"] += 1
+        regime_stats["total_pnl"] += signal.profit_loss
+        if is_win:
+            regime_stats["wins"] += 1
+        else:
+            regime_stats["losses"] += 1
+        
+        # Update by symbol
+        symbol_stats = self.performance_by_symbol[signal.symbol]
+        symbol_stats["count"] += 1
+        symbol_stats["total_pnl"] += signal.profit_loss
+        if is_win:
+            symbol_stats["wins"] += 1
+        else:
+            symbol_stats["losses"] += 1
+    
+    def record_signal(self, 
+                      signal_id: str,
+                      symbol: str,
+                      interval: str,
+                      signal_type: str,
+                      entry_price: float,
+                      stop_loss: float,
+                      take_profit_1: float,
+                      take_profit_2: float,
+                      take_profit_3: float,
+                      indicator_contributions: Dict[str, float],
+                      reasons: List[str],
+                      market_context: Dict[str, Any],
+                      weights: List[float]) -> SignalRecord:
+        """Record a new signal with its contributing factors"""
+        
+        signal = SignalRecord(
+            signal_id=signal_id,
+            timestamp=datetime.now(),
+            symbol=symbol,
+            interval=interval,
+            signal_type=signal_type,
+            entry_price=entry_price,
+            stop_loss=stop_loss,
+            take_profit_1=take_profit_1,
+            take_profit_2=take_profit_2,
+            take_profit_3=take_profit_3,
+            indicator_contributions=indicator_contributions,
+            reasons=reasons,
+            market_regime=market_context.get("market_regime", "unknown"),
+            volatility=market_context.get("volatility", 0.0),
+            volume_ratio=market_context.get("volume_ratio", 1.0),
+            rsi=market_context.get("rsi", 50.0),
+            trend=market_context.get("trend", ""),
+            weights_at_signal=weights.copy() if weights else []
+        )
+        
+        self.signals.append(signal)
+        return signal
+    
+    def update_signal_outcome(self, 
+                              signal_id: str,
+                              outcome: SignalOutcome,
+                              exit_price: float,
+                              profit_loss: float,
+                              duration_candles: int,
+                              max_favorable: float = 0.0,
+                              max_adverse: float = 0.0):
+        """Update a signal with its outcome"""
+        
+        for signal in reversed(self.signals):  # Search from most recent
+            if signal.signal_id == signal_id:
+                signal.outcome = outcome
+                signal.exit_price = exit_price
+                signal.profit_loss = profit_loss
+                if signal.signal_type == "Bearish":
+                    signal.profit_loss_percent = (signal.entry_price - exit_price) / signal.entry_price * 100
+                else:
+                    signal.profit_loss_percent = (exit_price - signal.entry_price) / signal.entry_price * 100
+                signal.duration_candles = duration_candles
+                signal.max_favorable_excursion = max_favorable
+                signal.max_adverse_excursion = max_adverse
+                
+                self._update_stats(signal)
+                self._save_history()
+                
+                logger.info(f"Signal {signal_id} outcome: {outcome.value}, P/L: {profit_loss:.2f}")
+                return signal
+        
+        logger.warning(f"Signal {signal_id} not found for outcome update")
+        return None
+    
+    def get_indicator_performance(self) -> pd.DataFrame:
+        """Get performance breakdown by indicator"""
+        data = []
+        for indicator, stats in self.performance_by_indicator.items():
+            if stats["count"] > 0:
+                win_rate = stats["wins"] / stats["count"] * 100
+                avg_pnl = stats["total_pnl"] / stats["count"]
+                data.append({
+                    "indicator": indicator,
+                    "signals": stats["count"],
+                    "wins": stats["wins"],
+                    "losses": stats["losses"],
+                    "win_rate": win_rate,
+                    "total_pnl": stats["total_pnl"],
+                    "avg_pnl": avg_pnl,
+                    "score": win_rate * 0.4 + (avg_pnl / 100) * 0.6 if avg_pnl else win_rate
+                })
+        
+        df = pd.DataFrame(data)
+        if not df.empty:
+            df = df.sort_values("score", ascending=False)
+        return df
+    
+    def get_regime_performance(self) -> pd.DataFrame:
+        """Get performance breakdown by market regime"""
+        data = []
+        for regime, stats in self.performance_by_market_regime.items():
+            if stats["count"] > 0:
+                win_rate = stats["wins"] / stats["count"] * 100
+                data.append({
+                    "regime": regime,
+                    "signals": stats["count"],
+                    "win_rate": win_rate,
+                    "total_pnl": stats["total_pnl"],
+                    "avg_pnl": stats["total_pnl"] / stats["count"]
+                })
+        return pd.DataFrame(data)
+    
+    def get_recent_performance(self, n: int = 100) -> Dict[str, Any]:
+        """Get performance of recent N signals"""
+        recent = [s for s in self.signals[-n:] if s.outcome != SignalOutcome.PENDING]
+        
+        if not recent:
+            return {"signals": 0, "win_rate": 0, "avg_pnl": 0}
+        
+        wins = sum(1 for s in recent if s.is_successful())
+        total_pnl = sum(s.profit_loss for s in recent)
+        
+        return {
+            "signals": len(recent),
+            "wins": wins,
+            "losses": len(recent) - wins,
+            "win_rate": wins / len(recent) * 100,
+            "total_pnl": total_pnl,
+            "avg_pnl": total_pnl / len(recent),
+            "avg_duration": sum(s.duration_candles for s in recent) / len(recent)
+        }
+    
+    def identify_weak_indicators(self, min_signals: int = 10, 
+                                  win_rate_threshold: float = 40.0) -> List[str]:
+        """Identify indicators that consistently underperform"""
+        weak = []
+        for indicator, stats in self.performance_by_indicator.items():
+            if stats["count"] >= min_signals:
+                win_rate = stats["wins"] / stats["count"] * 100
+                if win_rate < win_rate_threshold:
+                    weak.append(indicator)
+        return weak
+    
+    def identify_strong_indicators(self, min_signals: int = 10,
+                                    win_rate_threshold: float = 60.0) -> List[str]:
+        """Identify indicators that consistently outperform"""
+        strong = []
+        for indicator, stats in self.performance_by_indicator.items():
+            if stats["count"] >= min_signals:
+                win_rate = stats["wins"] / stats["count"] * 100
+                if win_rate >= win_rate_threshold:
+                    strong.append(indicator)
+        return strong
+
+
+class AdaptiveWeightAdjuster:
+    """
+    Adjusts signal weights based on historical performance.
+    Uses online learning to continuously improve signal quality.
+    """
+    
+    def __init__(self, 
+                 performance_tracker: SignalPerformanceTracker,
+                 learning_rate: float = 0.05,
+                 momentum: float = 0.9,
+                 min_weight: float = 0.1,
+                 max_weight: float = 3.0,
+                 decay_factor: float = 0.95,
+                 storage_path: str = "./data/weights"):
+        
+        self.tracker = performance_tracker
+        self.learning_rate = learning_rate
+        self.momentum = momentum
+        self.min_weight = min_weight
+        self.max_weight = max_weight
+        self.decay_factor = decay_factor  # Decay old performance influence
+        self.storage_path = storage_path
+        os.makedirs(storage_path, exist_ok=True)
+        
+        # Weight velocity for momentum-based updates
+        self.velocity = defaultdict(float)
+        
+        # Historical weight adjustments
+        self.adjustment_history: List[Dict] = []
+        
+        # Load last known weights
+        self.current_weights = self._load_weights()
+    
+    def _load_weights(self) -> Dict[str, float]:
+        """Load current weights from storage"""
+        weights_file = os.path.join(self.storage_path, "adaptive_weights.json")
+        default_weights = {name: 1.0 for name in SignalPerformanceTracker.WEIGHT_NAMES}
+        
+        if os.path.exists(weights_file):
+            try:
+                with open(weights_file, 'r') as f:
+                    data = json.load(f)
+                    return data.get('weights', default_weights)
+            except Exception as e:
+                logger.warning(f"Failed to load weights from {weights_file}: {e}")
+        return default_weights
+    
+    def _save_weights(self):
+        """Save current weights to storage"""
+        weights_file = os.path.join(self.storage_path, "adaptive_weights.json")
+        with open(weights_file, 'w') as f:
+            json.dump({
+                'weights': self.current_weights,
+                'last_updated': datetime.now().isoformat(),
+                'learning_rate': self.learning_rate,
+                'adjustment_count': len(self.adjustment_history)
+            }, f, indent=2)
+    
+    def calculate_weight_adjustments(self, recent_window: int = 100) -> Dict[str, float]:
+        """
+        Calculate weight adjustments based on recent signal performance.
+        
+        For each indicator:
+        - If win rate > 60%: increase weight
+        - If win rate < 40%: decrease weight
+        - Scale adjustment by confidence (number of signals)
+        """
+        adjustments = {}
+        indicator_perf = self.tracker.get_indicator_performance()
+        
+        if indicator_perf.empty:
+            return adjustments
+        
+        for _, row in indicator_perf.iterrows():
+            indicator = row['indicator']
+            if indicator not in self.current_weights:
+                continue
+            
+            signals = row['signals']
+            win_rate = row['win_rate']
+            avg_pnl = row['avg_pnl']
+            
+            # Calculate confidence based on sample size
+            confidence = min(1.0, signals / 50)  # Full confidence at 50 signals
+            
+            # Calculate adjustment direction and magnitude
+            if win_rate > 60:
+                # Positive adjustment - increase weight
+                magnitude = (win_rate - 50) / 100 * confidence
+                adjustment = magnitude * self.learning_rate
+            elif win_rate < 40:
+                # Negative adjustment - decrease weight
+                magnitude = (50 - win_rate) / 100 * confidence
+                adjustment = -magnitude * self.learning_rate
+            else:
+                adjustment = 0
+            
+            # Factor in P/L performance
+            if avg_pnl != 0:
+                pnl_factor = np.clip(avg_pnl / 100, -0.5, 0.5)
+                adjustment += pnl_factor * 0.5 * self.learning_rate * confidence
+            
+            # Apply momentum
+            self.velocity[indicator] = (self.momentum * self.velocity[indicator] + 
+                                        (1 - self.momentum) * adjustment)
+            adjustments[indicator] = self.velocity[indicator]
+        
+        return adjustments
+    
+    def apply_adjustments(self, 
+                          adjustments: Optional[Dict[str, float]] = None,
+                          force: bool = False) -> Dict[str, float]:
+        """
+        Apply calculated adjustments to current weights.
+        
+        Args:
+            adjustments: Optional pre-calculated adjustments
+            force: If True, apply even small adjustments
+            
+        Returns:
+            Dictionary of new weights
+        """
+        if adjustments is None:
+            adjustments = self.calculate_weight_adjustments()
+        
+        if not adjustments:
+            return self.current_weights
+        
+        old_weights = self.current_weights.copy()
+        changes_made = False
+        
+        for indicator, adjustment in adjustments.items():
+            if indicator not in self.current_weights:
+                continue
+            
+            # Only apply significant adjustments unless forced
+            if not force and abs(adjustment) < 0.01:
+                continue
+            
+            old_weight = self.current_weights[indicator]
+            new_weight = old_weight + adjustment
+            
+            # Clamp to valid range
+            new_weight = max(self.min_weight, min(self.max_weight, new_weight))
+            
+            if new_weight != old_weight:
+                self.current_weights[indicator] = new_weight
+                changes_made = True
+                logger.info(f"Weight adjusted: {indicator} {old_weight:.3f} -> {new_weight:.3f}")
+        
+        if changes_made:
+            self.adjustment_history.append({
+                'timestamp': datetime.now().isoformat(),
+                'old_weights': old_weights,
+                'new_weights': self.current_weights.copy(),
+                'adjustments': adjustments
+            })
+            self._save_weights()
+        
+        return self.current_weights
+    
+    def get_weights_as_list(self) -> List[float]:
+        """Convert weights dictionary to list format for backtesting"""
+        return [self.current_weights.get(name, 1.0) 
+                for name in SignalPerformanceTracker.WEIGHT_NAMES]
+    
+    def reset_weights(self):
+        """Reset all weights to default values"""
+        self.current_weights = {name: 1.0 for name in SignalPerformanceTracker.WEIGHT_NAMES}
+        self.velocity = defaultdict(float)
+        self._save_weights()
+        logger.info("Weights reset to defaults")
+    
+    def get_adjustment_summary(self) -> Dict[str, Any]:
+        """Get summary of recent weight adjustments"""
+        if not self.adjustment_history:
+            return {"adjustments": 0, "last_adjustment": None}
+        
+        recent = self.adjustment_history[-10:]
+        return {
+            "total_adjustments": len(self.adjustment_history),
+            "recent_adjustments": len(recent),
+            "last_adjustment": recent[-1]['timestamp'] if recent else None,
+            "current_weights": self.current_weights
+        }
+
+
+class LearningMetricsAnalyzer:
+    """
+    Analyzes learning metrics and provides actionable insights
+    for improving signal quality.
+    """
+    
+    def __init__(self, 
+                 tracker: SignalPerformanceTracker,
+                 adjuster: AdaptiveWeightAdjuster):
+        self.tracker = tracker
+        self.adjuster = adjuster
+    
+    def generate_learning_report(self) -> Dict[str, Any]:
+        """Generate comprehensive learning report"""
+        report = {
+            "timestamp": datetime.now().isoformat(),
+            "summary": {},
+            "indicator_analysis": {},
+            "regime_analysis": {},
+            "recommendations": []
+        }
+        
+        # Overall summary
+        recent_perf = self.tracker.get_recent_performance(100)
+        report["summary"] = {
+            "total_signals_tracked": len(self.tracker.signals),
+            "recent_win_rate": recent_perf.get("win_rate", 0),
+            "recent_avg_pnl": recent_perf.get("avg_pnl", 0),
+            "weight_adjustments": len(self.adjuster.adjustment_history)
+        }
+        
+        # Indicator analysis
+        indicator_df = self.tracker.get_indicator_performance()
+        if not indicator_df.empty:
+            report["indicator_analysis"] = {
+                "best_performers": indicator_df.head(5).to_dict('records'),
+                "worst_performers": indicator_df.tail(5).to_dict('records'),
+                "weak_indicators": self.tracker.identify_weak_indicators(),
+                "strong_indicators": self.tracker.identify_strong_indicators()
+            }
+        
+        # Regime analysis
+        regime_df = self.tracker.get_regime_performance()
+        if not regime_df.empty:
+            report["regime_analysis"] = regime_df.to_dict('records')
+        
+        # Generate recommendations
+        report["recommendations"] = self._generate_recommendations()
+        
+        return report
+    
+    def _generate_recommendations(self) -> List[str]:
+        """Generate actionable recommendations based on performance data"""
+        recommendations = []
+        
+        # Check for weak indicators
+        weak = self.tracker.identify_weak_indicators()
+        if weak:
+            recommendations.append(
+                f"Consider reducing weights for underperforming indicators: {', '.join(weak)}"
+            )
+        
+        # Check for strong indicators
+        strong = self.tracker.identify_strong_indicators()
+        if strong:
+            recommendations.append(
+                f"High-performing indicators (consider increasing weight): {', '.join(strong)}"
+            )
+        
+        # Check recent performance trend
+        recent_perf = self.tracker.get_recent_performance(50)
+        older_perf = self.tracker.get_recent_performance(200)
+        
+        if recent_perf.get("win_rate", 0) < older_perf.get("win_rate", 0) - 10:
+            recommendations.append(
+                "Recent performance declining - consider resetting weights or retraining"
+            )
+        
+        # Regime-specific recommendations
+        regime_df = self.tracker.get_regime_performance()
+        if not regime_df.empty:
+            worst_regime = regime_df.loc[regime_df['win_rate'].idxmin()]
+            if worst_regime['win_rate'] < 40 and worst_regime['signals'] > 20:
+                recommendations.append(
+                    f"Poor performance in '{worst_regime['regime']}' regime "
+                    f"({worst_regime['win_rate']:.1f}% win rate) - consider filtering signals"
+                )
+        
+        return recommendations
+    
+    def print_report(self):
+        """Print formatted learning report to console"""
+        report = self.generate_learning_report()
+        
+        print("\n" + "="*70)
+        print("📊 ADAPTIVE LEARNING REPORT")
+        print("="*70)
+        
+        print(f"\n📈 Summary:")
+        print(f"   Total signals tracked: {report['summary']['total_signals_tracked']}")
+        print(f"   Recent win rate: {report['summary']['recent_win_rate']:.1f}%")
+        print(f"   Recent avg P/L: ${report['summary']['recent_avg_pnl']:.2f}")
+        print(f"   Weight adjustments made: {report['summary']['weight_adjustments']}")
+        
+        if report.get('indicator_analysis', {}).get('best_performers'):
+            print(f"\n🟢 Top Performing Indicators:")
+            for ind in report['indicator_analysis']['best_performers'][:3]:
+                print(f"   {ind['indicator']}: {ind['win_rate']:.1f}% win rate, "
+                      f"${ind['avg_pnl']:.2f} avg P/L ({ind['signals']} signals)")
+        
+        if report.get('indicator_analysis', {}).get('weak_indicators'):
+            print(f"\n🔴 Underperforming Indicators:")
+            for ind in report['indicator_analysis']['weak_indicators']:
+                print(f"   {ind}")
+        
+        if report.get('recommendations'):
+            print(f"\n💡 Recommendations:")
+            for rec in report['recommendations']:
+                print(f"   • {rec}")
+        
+        print("\n" + "="*70)
+
+
+class SelfLearningBacktester:
+    """
+    Enhanced backtester with self-learning capabilities.
+    Integrates signal tracking, weight adjustment, and performance analysis.
+    """
+    
+    def __init__(self, 
+                 storage_path: str = "./data/learning",
+                 auto_adjust_weights: bool = True,
+                 adjustment_frequency: int = 50):  # Adjust every N signals
+        
+        self.storage_path = storage_path
+        os.makedirs(storage_path, exist_ok=True)
+        
+        self.tracker = SignalPerformanceTracker(
+            storage_path=os.path.join(storage_path, "signals")
+        )
+        self.adjuster = AdaptiveWeightAdjuster(
+            performance_tracker=self.tracker,
+            storage_path=os.path.join(storage_path, "weights")
+        )
+        self.analyzer = LearningMetricsAnalyzer(self.tracker, self.adjuster)
+        
+        self.auto_adjust = auto_adjust_weights
+        self.adjustment_frequency = adjustment_frequency
+        self.signals_since_adjustment = 0
+    
+    def get_current_weights(self) -> List[float]:
+        """Get current adaptive weights as list"""
+        return self.adjuster.get_weights_as_list()
+    
+    def record_signal_entry(self,
+                            signal_id: str,
+                            symbol: str,
+                            interval: str,
+                            signal_type: str,
+                            entry_price: float,
+                            stop_loss: float,
+                            tp1: float, tp2: float, tp3: float,
+                            indicator_contributions: Dict[str, float],
+                            reasons: List[str],
+                            market_context: Dict[str, Any]) -> SignalRecord:
+        """Record a new signal entry"""
+        
+        signal = self.tracker.record_signal(
+            signal_id=signal_id,
+            symbol=symbol,
+            interval=interval,
+            signal_type=signal_type,
+            entry_price=entry_price,
+            stop_loss=stop_loss,
+            take_profit_1=tp1,
+            take_profit_2=tp2,
+            take_profit_3=tp3,
+            indicator_contributions=indicator_contributions,
+            reasons=reasons,
+            market_context=market_context,
+            weights=self.get_current_weights()
+        )
+        
+        return signal
+    
+    def record_signal_exit(self,
+                           signal_id: str,
+                           outcome: str,  # "tp1", "tp2", "tp3", "stop_loss", "trailing_stop", "end"
+                           exit_price: float,
+                           profit_loss: float,
+                           duration: int):
+        """Record signal exit and trigger learning if needed"""
+        
+        # Map outcome string to enum
+        outcome_map = {
+            "tp1": SignalOutcome.TP1_HIT,
+            "tp2": SignalOutcome.TP2_HIT,
+            "tp3": SignalOutcome.TP3_HIT,
+            "stop_loss": SignalOutcome.STOP_LOSS,
+            "trailing_stop": SignalOutcome.TRAILING_STOP,
+            "end": SignalOutcome.END_OF_PERIOD
+        }
+        outcome_enum = outcome_map.get(outcome, SignalOutcome.END_OF_PERIOD)
+        
+        self.tracker.update_signal_outcome(
+            signal_id=signal_id,
+            outcome=outcome_enum,
+            exit_price=exit_price,
+            profit_loss=profit_loss,
+            duration_candles=duration
+        )
+        
+        self.signals_since_adjustment += 1
+        
+        # Auto-adjust weights if enabled and threshold reached
+        if self.auto_adjust and self.signals_since_adjustment >= self.adjustment_frequency:
+            self._trigger_learning()
+            self.signals_since_adjustment = 0
+    
+    def _trigger_learning(self):
+        """Trigger weight adjustment based on recent performance"""
+        logger.info("Triggering adaptive weight adjustment...")
+        
+        adjustments = self.adjuster.calculate_weight_adjustments()
+        if adjustments:
+            self.adjuster.apply_adjustments(adjustments)
+            logger.info(f"Applied {len(adjustments)} weight adjustments")
+    
+    def force_learning(self):
+        """Force immediate weight adjustment"""
+        self._trigger_learning()
+        self.signals_since_adjustment = 0
+    
+    def get_performance_report(self) -> Dict[str, Any]:
+        """Get comprehensive performance report"""
+        return self.analyzer.generate_learning_report()
+    
+    def print_status(self):
+        """Print current learning status"""
+        self.analyzer.print_report()
+    
+    def save_state(self):
+        """Save all learning state"""
+        self.tracker._save_history()
+        self.adjuster._save_weights()
+        logger.info("Learning state saved")
+
+
+# Helper function to extract indicator contributions from signal generation
+def extract_indicator_contributions(
+    bullish_score: float,
+    bearish_score: float,
+    signal_type: str,
+    reasons: List[str]
+) -> Dict[str, float]:
+    """
+    Extract which indicators contributed to the signal.
+    This parses the reasons list to determine contributions.
+    """
+    contributions = {}
+    
+    # Parse reasons to identify contributing indicators
+    indicator_keywords = {
+        "order block": ("W_BULLISH_OB" if signal_type == "Bullish" else "W_BEARISH_OB"),
+        "breaker block": ("W_BULLISH_BREAKER" if signal_type == "Bullish" else "W_BEARISH_BREAKER"),
+        "support": "W_ABOVE_SUPPORT",
+        "resistance": "W_BELOW_RESISTANCE",
+        "FVG above": "W_FVG_ABOVE",
+        "FVG below": "W_FVG_BELOW",
+        "uptrend": "W_TREND",
+        "downtrend": "W_TREND",
+        "swept through previous highs": "W_SWEEP_HIGHS",
+        "swept through previous lows": "W_SWEEP_LOWS",
+        "broke structure": "W_STRUCTURE_BREAK",
+        "pin bar": "W_PIN_BAR",
+        "engulfing": "W_ENGULFING",
+        "liquidity pool": "W_LIQUIDITY_POOL_ABOVE",
+        "round number": "W_LIQUIDITY_POOL_ROUND",
+        "RSI oversold": "W_RSI_EXTREME",
+        "RSI overbought": "W_RSI_EXTREME"
+    }
+    
+    for reason in reasons:
+        reason_lower = reason.lower()
+        for keyword, indicator in indicator_keywords.items():
+            if keyword.lower() in reason_lower:
+                # Score is proportional to contribution to final signal
+                total_score = bullish_score + bearish_score if bullish_score + bearish_score > 0 else 1
+                score = bullish_score if signal_type == "Bullish" else bearish_score
+                contributions[indicator] = score / total_score
+    
+    return contributions
+
+
+# Usage example
+if __name__ == "__main__":
+    # Initialize self-learning backtester
+    learner = SelfLearningBacktester(
+        storage_path="./data/learning",
+        auto_adjust_weights=True,
+        adjustment_frequency=50
+    )
+    
+    # Get current adaptive weights for signal generation
+    weights = learner.get_current_weights()
+    print(f"Current weights: {weights}")
+    
+    # Print performance status
+    learner.print_status()
+
diff --git a/back_tester/bybit_sync.py b/back_tester/bybit_sync.py
new file mode 100644
index 0000000..8a7989e
--- /dev/null
+++ b/back_tester/bybit_sync.py
@@ -0,0 +1,1031 @@
+#!/usr/bin/env python3
+"""
+Bybit Live Trading Synchronization Module
+
+This module synchronizes the realtime test signals with actual Bybit trading.
+When a signal is generated, it executes the trade on your real Bybit account.
+
+WARNING: This module executes REAL trades with REAL money.
+Make sure you understand the risks before using it.
+
+Usage:
+    python bybit_sync.py [--testnet] [--balance AMOUNT] [--risk PERCENT]
+    
+Example:
+    # Paper trading with testnet
+    python bybit_sync.py --testnet --balance 1000
+    
+    # Live trading (use with caution!)
+    python bybit_sync.py --balance 5000 --risk 0.5
+"""
+
+import os
+import sys
+import json
+import time
+import signal
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Any, Tuple
+from dataclasses import dataclass, field
+from threading import Thread, Event, Lock
+import uuid
+
+# Add project root to path
+project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.insert(0, project_dir)
+
+import pandas as pd
+import numpy as np
+
+# Import trading client
+from src.trading.bybit_client import BybitClient, OrderSide, OrderType, OrderResult
+
+# Import from the project
+from src.analysis.utils.helpers import fetch_candles
+from src.telegram.signals.detection import (
+    analyze_data,
+    generate_price_prediction_signal_proba,
+    TradingSignal,
+    calculate_position_size,
+)
+from src.core.utils import create_true_preferences
+
+# Try to import indicator contribution tracking
+try:
+    from back_tester.adaptive_learning import extract_indicator_contributions
+    INDICATOR_TRACKING_AVAILABLE = True
+except ImportError:
+    INDICATOR_TRACKING_AVAILABLE = False
+    def extract_indicator_contributions(*args, **kwargs):
+        return {}
+
+# Import Telegram notifier for alerts
+try:
+    from src.telegram.notifier import TelegramNotifier
+    TELEGRAM_AVAILABLE = True
+except ImportError:
+    TELEGRAM_AVAILABLE = False
+    TelegramNotifier = None
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s | %(levelname)s | %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S'
+)
+logger = logging.getLogger(__name__)
+
+# Suppress noisy loggers
+logging.getLogger('urllib3').setLevel(logging.WARNING)
+logging.getLogger('requests').setLevel(logging.WARNING)
+
+
+@dataclass
+class LivePosition:
+    """Represents a live trading position"""
+    position_id: str
+    symbol: str
+    interval: str
+    entry_price: float
+    entry_time: datetime
+    quantity: float  # Actual quantity bought
+    invested_amount: float  # Amount in USDT invested
+    stop_loss: float
+    initial_stop_loss: float
+    take_profit_1: float
+    take_profit_2: float
+    take_profit_3: float
+    highest_price: float
+    trailing_stop_active: bool = False
+    trailing_stop_level: float = 0.0
+    tp1_hit: bool = False
+    tp2_hit: bool = False
+    tp3_hit: bool = False
+    initial_quantity: float = 0.0
+    risk_reward_ratio: float = 2.0
+    signal_reason: str = ""
+    current_price: float = 0.0
+    unrealized_pnl: float = 0.0
+    confidence: float = 0.0
+    order_id: str = ""  # Bybit order ID
+    indicator_contributions: Dict[str, float] = field(default_factory=dict)
+
+
+@dataclass
+class LiveTradeResult:
+    """Represents a completed live trade"""
+    position_id: str
+    symbol: str
+    interval: str
+    entry_price: float
+    exit_price: float
+    entry_time: datetime
+    exit_time: datetime
+    quantity: float
+    invested_amount: float
+    realized_pnl: float
+    profit_percent: float
+    exit_type: str  # stop_loss, trailing_stop, tp1, tp2, tp3
+    duration_minutes: float
+    entry_order_id: str = ""
+    exit_order_id: str = ""
+    confidence: float = 0.0
+    indicator_contributions: Dict[str, float] = field(default_factory=dict)
+
+
+class BybitLiveTrader:
+    """
+    Live trading synchronization with Bybit.
+    
+    This class monitors signals from the trading strategy and executes
+    real trades on your Bybit account.
+    """
+    
+    # Trading combinations to monitor
+    COMBINATIONS = [
+        {"symbol": "BTCUSDT", "interval": "1h", "priority": "SAFE"},
+        {"symbol": "ETHUSDT", "interval": "5m", "priority": "SAFE"},
+        {"symbol": "ETHUSDT", "interval": "15m", "priority": "SAFE"},
+        {"symbol": "BTCUSDT", "interval": "4h", "priority": "AGGRESSIVE"},
+        {"symbol": "ETHUSDT", "interval": "4h", "priority": "AGGRESSIVE"},
+    ]
+    
+    # Interval to seconds mapping
+    INTERVAL_SECONDS = {
+        "1m": 60,
+        "5m": 300,
+        "15m": 900,
+        "30m": 1800,
+        "1h": 3600,
+        "4h": 14400,
+        "1d": 86400,
+    }
+    
+    def __init__(
+        self,
+        bybit_client: BybitClient,
+        max_position_usdt: float = 100.0,  # Max USDT per trade
+        risk_percentage: float = 1.0,  # Risk per trade
+        use_trailing_stop: bool = True,
+        trailing_stop_distance: float = 0.5,
+        weights_file: str = None,
+        safe_only: bool = False,
+        candle_window: int = 500,
+        min_confidence: float = 0.3,
+        max_open_positions: int = 3,
+        position_check_interval: float = 10.0,  # Seconds between position checks
+        telegram_chat_id: int = 840355587,  # Your Telegram ID for notifications
+    ):
+        """
+        Initialize the live trader.
+        
+        Args:
+            bybit_client: Initialized BybitClient instance
+            max_position_usdt: Maximum USDT amount per trade
+            risk_percentage: Risk percentage per trade
+            use_trailing_stop: Enable trailing stop
+            trailing_stop_distance: Trailing stop distance in %
+            weights_file: Path to optimized weights file
+            safe_only: Only trade SAFE combinations
+            candle_window: Number of candles for analysis
+            min_confidence: Minimum signal confidence to trade
+            max_open_positions: Maximum concurrent open positions
+            position_check_interval: Seconds between position price checks
+            telegram_chat_id: Telegram user ID for notifications (your ID: 840355587)
+        """
+        self.client = bybit_client
+        self.max_position_usdt = max_position_usdt
+        self.risk_percentage = risk_percentage
+        self.use_trailing_stop = use_trailing_stop
+        self.trailing_stop_distance = trailing_stop_distance
+        self.safe_only = safe_only
+        self.candle_window = candle_window
+        self.min_confidence = min_confidence
+        self.max_open_positions = max_open_positions
+        self.position_check_interval = position_check_interval
+        
+        # Load optimized weights
+        self.weights = self._load_weights(weights_file)
+        
+        # Trading state
+        self.open_positions: Dict[str, LivePosition] = {}
+        self.completed_trades: List[LiveTradeResult] = []
+        self.position_lock = Lock()
+        
+        # Track total P/L
+        self.total_realized_pnl = 0.0
+        
+        # Control flags
+        self.running = False
+        self.stop_event = Event()
+        
+        # Preferences for signal generation
+        self.preferences = create_true_preferences()
+        
+        # Track last data fetch time per combination
+        self.last_fetch: Dict[str, datetime] = {}
+        
+        # Start time
+        self.start_time = None
+        
+        # Initial balance tracking
+        self.initial_balance = 0.0
+        
+        # Initialize Telegram notifier for alerts
+        self.notifier = None
+        if TELEGRAM_AVAILABLE and telegram_chat_id > 0:
+            try:
+                self.notifier = TelegramNotifier(chat_id=telegram_chat_id)
+                if self.notifier.enabled:
+                    logger.info(f"✓ Telegram alerts enabled → chat ID: {telegram_chat_id}")
+                else:
+                    logger.warning("Telegram alerts disabled (check API_TELEGRAM_KEY in .env)")
+                    self.notifier = None
+            except Exception as e:
+                logger.warning(f"Could not initialize Telegram notifier: {e}")
+                self.notifier = None
+        
+    def _load_weights(self, weights_file: str = None) -> list:
+        """Load optimized weights from file"""
+        if weights_file is None:
+            weights_file = os.path.join(
+                os.path.dirname(__file__),
+                "data/btc_eth_learning/final_weights.json"
+            )
+        
+        try:
+            with open(weights_file, 'r') as f:
+                data = json.load(f)
+                weights = data.get('weights', [])
+                logger.info(f"✓ Loaded {len(weights)} optimized weights")
+                return weights
+        except FileNotFoundError:
+            logger.warning(f"Weights file not found: {weights_file}")
+            return []
+        except Exception as e:
+            logger.error(f"Error loading weights: {e}")
+            return []
+    
+    def _get_candle_window(self, symbol: str, interval: str) -> Optional[pd.DataFrame]:
+        """Fetch the latest candles for analysis"""
+        try:
+            df = fetch_candles(symbol, self.candle_window, interval)
+            if df is None or df.empty:
+                return None
+            df.sort_index(inplace=True)
+            return df
+        except Exception as e:
+            logger.error(f"Error fetching candles for {symbol} {interval}: {e}")
+            return None
+    
+    def _should_fetch(self, combo_key: str, interval: str) -> bool:
+        """Check if enough time has passed to fetch new data"""
+        if combo_key not in self.last_fetch:
+            return True
+        
+        elapsed = (datetime.now() - self.last_fetch[combo_key]).total_seconds()
+        interval_seconds = self.INTERVAL_SECONDS.get(interval, 60)
+        
+        return elapsed >= (interval_seconds * 0.9)
+    
+    def _get_base_currency(self, symbol: str) -> str:
+        """Extract base currency from symbol (e.g., BTCUSDT -> BTC)"""
+        if symbol.endswith("USDT"):
+            return symbol[:-4]
+        elif symbol.endswith("USD"):
+            return symbol[:-3]
+        return symbol
+    
+    def _execute_buy(
+        self,
+        symbol: str,
+        usdt_amount: float,
+        current_price: float,
+    ) -> Tuple[bool, str, float, float]:
+        """
+        Execute a buy order on Bybit.
+        
+        Args:
+            symbol: Trading pair
+            usdt_amount: Amount in USDT to spend
+            current_price: Current market price
+            
+        Returns:
+            Tuple of (success, order_id, actual_qty, actual_price)
+        """
+        try:
+            # Calculate quantity to buy
+            quantity = usdt_amount / current_price
+            
+            # Get minimum order size
+            min_qty, max_qty, qty_step = self.client.get_lot_size_filter(symbol)
+            
+            # Round to valid quantity
+            if qty_step > 0:
+                quantity = round(quantity / qty_step) * qty_step
+            
+            if quantity < min_qty:
+                logger.warning(f"Quantity {quantity} below minimum {min_qty} for {symbol}")
+                return False, "", 0, 0
+            
+            # Place market buy order
+            result = self.client.place_market_buy(
+                symbol=symbol,
+                qty=quantity,
+                category="spot",
+            )
+            
+            if result.success:
+                logger.info(f"✅ Buy order executed: {quantity} {symbol} @ ~${current_price:.2f}")
+                return True, result.order_id, quantity, current_price
+            else:
+                logger.error(f"❌ Buy order failed: {result.message}")
+                return False, "", 0, 0
+                
+        except Exception as e:
+            logger.error(f"❌ Error executing buy: {e}")
+            return False, "", 0, 0
+    
+    def _execute_sell(
+        self,
+        symbol: str,
+        quantity: float,
+        current_price: float,
+    ) -> Tuple[bool, str, float]:
+        """
+        Execute a sell order on Bybit.
+        
+        Args:
+            symbol: Trading pair
+            quantity: Quantity to sell
+            current_price: Current market price
+            
+        Returns:
+            Tuple of (success, order_id, actual_price)
+        """
+        try:
+            # Get available balance
+            base_currency = self._get_base_currency(symbol)
+            available = self.client.get_spot_balance(base_currency)
+            
+            # Adjust quantity if we don't have enough
+            if quantity > available:
+                logger.warning(f"Adjusting sell quantity from {quantity} to {available}")
+                quantity = available
+            
+            if quantity <= 0:
+                logger.warning(f"No {base_currency} available to sell")
+                return False, "", 0
+            
+            # Place market sell order
+            result = self.client.place_market_sell(
+                symbol=symbol,
+                qty=quantity,
+                category="spot",
+            )
+            
+            if result.success:
+                logger.info(f"✅ Sell order executed: {quantity} {symbol} @ ~${current_price:.2f}")
+                return True, result.order_id, current_price
+            else:
+                logger.error(f"❌ Sell order failed: {result.message}")
+                return False, "", 0
+                
+        except Exception as e:
+            logger.error(f"❌ Error executing sell: {e}")
+            return False, "", 0
+    
+    def _check_position_updates(self, position: LivePosition) -> Optional[LiveTradeResult]:
+        """Check if position needs updating (stop-loss, take-profit, trailing stop)"""
+        now = datetime.now()
+        
+        # Get current price
+        current_price = self.client.get_current_price(position.symbol)
+        if current_price <= 0:
+            return None
+        
+        # Update position state
+        position.current_price = current_price
+        position.unrealized_pnl = position.quantity * (current_price - position.entry_price)
+        
+        # Update highest price for trailing stop
+        if current_price > position.highest_price:
+            position.highest_price = current_price
+            
+            # Activate trailing stop at TP1
+            if not position.trailing_stop_active and current_price >= position.take_profit_1:
+                position.trailing_stop_active = True
+                logger.info(f"🔄 [{position.symbol}] Trailing stop ACTIVATED at ${current_price:.2f}")
+            
+            # Update trailing stop level
+            if position.trailing_stop_active and self.use_trailing_stop:
+                new_stop = current_price * (1 - self.trailing_stop_distance / 100)
+                if new_stop > position.trailing_stop_level:
+                    position.trailing_stop_level = new_stop
+                    position.stop_loss = new_stop
+                    logger.info(f"📈 [{position.symbol}] Trailing stop updated to ${new_stop:.2f}")
+        
+        exit_type = None
+        exit_quantity = 0
+        
+        # Check take profit levels
+        if current_price >= position.take_profit_3 and not position.tp3_hit:
+            # Full target hit - close entire position
+            exit_type = "tp3_hit"
+            exit_quantity = position.quantity
+            logger.info(f"🎯 [{position.symbol}] TP3 HIT at ${current_price:.2f}")
+        
+        elif current_price >= position.take_profit_2 and not position.tp2_hit:
+            # TP2 hit - close 50% of remaining
+            exit_type = "tp2_partial"
+            exit_quantity = position.quantity / 2
+            position.tp2_hit = True
+            logger.info(f"🎯 [{position.symbol}] TP2 HIT - Selling 50%")
+        
+        elif current_price >= position.take_profit_1 and not position.tp1_hit:
+            # TP1 hit - close 33% of position
+            exit_type = "tp1_partial"
+            exit_quantity = position.initial_quantity / 3
+            position.tp1_hit = True
+            logger.info(f"🎯 [{position.symbol}] TP1 HIT - Selling 33%")
+        
+        # Check stop loss
+        elif current_price <= position.stop_loss:
+            stop_type = "trailing_stop" if position.trailing_stop_active else "stop_loss"
+            exit_type = stop_type
+            exit_quantity = position.quantity
+            emoji = "🛑" if position.unrealized_pnl < 0 else "✅"
+            logger.info(f"{emoji} [{position.symbol}] {stop_type.upper()} at ${current_price:.2f}")
+        
+        # Execute exit if needed
+        if exit_type and exit_quantity > 0:
+            success, order_id, actual_price = self._execute_sell(
+                position.symbol,
+                exit_quantity,
+                current_price
+            )
+            
+            if success:
+                realized_pnl = exit_quantity * (actual_price - position.entry_price)
+                
+                # Send Telegram notification for TP/SL
+                if self.notifier:
+                    try:
+                        if exit_type.startswith("tp"):
+                            # Extract TP level (tp1_partial -> 1, tp2_partial -> 2, tp3_hit -> 3)
+                            tp_level = int(exit_type[2]) if len(exit_type) > 2 and exit_type[2].isdigit() else 1
+                            self.notifier.send_tp_hit(
+                                symbol=position.symbol,
+                                tp_level=tp_level,
+                                exit_price=actual_price,
+                                entry_price=position.entry_price,
+                                quantity_sold=exit_quantity,
+                                realized_pnl=realized_pnl,
+                                remaining_quantity=position.quantity - exit_quantity,
+                            )
+                        elif exit_type in ["stop_loss", "trailing_stop"]:
+                            self.notifier.send_stop_loss(
+                                symbol=position.symbol,
+                                exit_price=actual_price,
+                                entry_price=position.entry_price,
+                                quantity=exit_quantity,
+                                realized_pnl=realized_pnl,
+                                is_trailing=(exit_type == "trailing_stop"),
+                            )
+                    except Exception as e:
+                        logger.error(f"Failed to send Telegram alert: {e}")
+                
+                # Update position quantity
+                position.quantity -= exit_quantity
+                
+                # If fully closed, create trade result
+                if position.quantity <= 0.0001 or exit_type in ["tp3_hit", "stop_loss", "trailing_stop"]:
+                    duration = (now - position.entry_time).total_seconds() / 60
+                    
+                    return LiveTradeResult(
+                        position_id=position.position_id,
+                        symbol=position.symbol,
+                        interval=position.interval,
+                        entry_price=position.entry_price,
+                        exit_price=actual_price,
+                        entry_time=position.entry_time,
+                        exit_time=now,
+                        quantity=position.initial_quantity,
+                        invested_amount=position.invested_amount,
+                        realized_pnl=realized_pnl,
+                        profit_percent=(actual_price - position.entry_price) / position.entry_price * 100,
+                        exit_type=exit_type,
+                        duration_minutes=duration,
+                        entry_order_id=position.order_id,
+                        exit_order_id=order_id,
+                        confidence=position.confidence,
+                        indicator_contributions=position.indicator_contributions,
+                    )
+        
+        return None
+    
+    def _process_combination(self, symbol: str, interval: str):
+        """Process a single symbol/interval combination"""
+        combo_key = f"{symbol}_{interval}"
+        
+        # Check if we should fetch new data
+        if not self._should_fetch(combo_key, interval):
+            return
+        
+        # Fetch candle data
+        df = self._get_candle_window(symbol, interval)
+        if df is None or len(df) < 100:
+            return
+        
+        self.last_fetch[combo_key] = datetime.now()
+        current_price = self.client.get_current_price(symbol)
+        
+        if current_price <= 0:
+            current_price = df["Close"].iloc[-1]
+        
+        # Check existing positions for this combination
+        with self.position_lock:
+            positions_to_close = []
+            for pos_id, position in list(self.open_positions.items()):
+                if position.symbol == symbol and position.interval == interval:
+                    result = self._check_position_updates(position)
+                    if result:
+                        positions_to_close.append((pos_id, result))
+            
+            # Remove closed positions
+            for pos_id, result in positions_to_close:
+                del self.open_positions[pos_id]
+                self.completed_trades.append(result)
+                self.total_realized_pnl += result.realized_pnl
+                
+                emoji = "💰" if result.realized_pnl > 0 else "💸"
+                logger.info(f"{emoji} Trade closed: ${result.realized_pnl:+.2f} ({result.profit_percent:+.2f}%)")
+        
+        # Check for new signal
+        with self.position_lock:
+            has_open_position = any(
+                p.symbol == symbol and p.interval == interval
+                for p in self.open_positions.values()
+            )
+            
+            # Check max positions limit
+            if len(self.open_positions) >= self.max_open_positions:
+                return
+        
+        if not has_open_position:
+            # Generate signal
+            indicators = analyze_data(df, self.preferences, 0.05)
+            signal, prob, confidence, reason, trading_signal = generate_price_prediction_signal_proba(
+                df, indicators, self.weights, 10000, self.risk_percentage
+            )
+            
+            # Get confidence threshold from weights
+            confidence_threshold = self.weights[18] if len(self.weights) > 18 else 0.3
+            confidence_threshold = max(0.1, min(0.9, confidence_threshold))
+            
+            if signal == "Bullish" and trading_signal and confidence > max(confidence_threshold, self.min_confidence):
+                # Check available balance
+                available_usdt = self.client.get_spot_balance("USDT")
+                
+                # Calculate position size (use smaller of max_position or available)
+                position_usdt = min(self.max_position_usdt, available_usdt * 0.95)  # Keep 5% buffer
+                
+                if position_usdt < 10:  # Minimum $10 trade
+                    logger.warning(f"Insufficient balance: ${available_usdt:.2f}")
+                    return
+                
+                # Execute buy order
+                success, order_id, quantity, actual_price = self._execute_buy(
+                    symbol, position_usdt, current_price
+                )
+                
+                if success and quantity > 0:
+                    # Extract indicator contributions
+                    reasons_list = reason.split('\n') if reason else []
+                    indicator_contribs = extract_indicator_contributions(
+                        bullish_score=prob,
+                        bearish_score=0,
+                        signal_type=signal,
+                        reasons=reasons_list
+                    )
+                    
+                    position = LivePosition(
+                        position_id=str(uuid.uuid4()),
+                        symbol=symbol,
+                        interval=interval,
+                        entry_price=actual_price,
+                        entry_time=datetime.now(),
+                        quantity=quantity,
+                        invested_amount=position_usdt,
+                        initial_quantity=quantity,
+                        stop_loss=float(trading_signal.stop_loss),
+                        initial_stop_loss=float(trading_signal.stop_loss),
+                        take_profit_1=float(trading_signal.take_profit_1),
+                        take_profit_2=float(trading_signal.take_profit_2),
+                        take_profit_3=float(trading_signal.take_profit_3),
+                        highest_price=actual_price,
+                        trailing_stop_level=float(trading_signal.stop_loss),
+                        risk_reward_ratio=float(trading_signal.risk_reward_ratio),
+                        signal_reason=reason.split('\n')[0] if reason else "",
+                        current_price=actual_price,
+                        confidence=confidence,
+                        order_id=order_id,
+                        indicator_contributions=indicator_contribs,
+                    )
+                    
+                    with self.position_lock:
+                        self.open_positions[position.position_id] = position
+                    
+                    logger.info(f"""
+{'='*60}
+🚀 LIVE TRADE OPENED: {symbol} {interval}
+{'='*60}
+   Order ID:     {order_id}
+   Entry Price:  ${actual_price:,.2f}
+   Quantity:     {quantity:.6f} ({position_usdt:.2f} USDT)
+   Stop Loss:    ${trading_signal.stop_loss:,.2f} ({(trading_signal.stop_loss/actual_price-1)*100:.2f}%)
+   TP1:          ${trading_signal.take_profit_1:,.2f} ({(trading_signal.take_profit_1/actual_price-1)*100:.2f}%)
+   TP2:          ${trading_signal.take_profit_2:,.2f} ({(trading_signal.take_profit_2/actual_price-1)*100:.2f}%)
+   TP3:          ${trading_signal.take_profit_3:,.2f} ({(trading_signal.take_profit_3/actual_price-1)*100:.2f}%)
+   Confidence:   {confidence:.1%}
+{'='*60}
+""")
+                    
+                    # Send Telegram notification for new trade
+                    if self.notifier:
+                        try:
+                            self.notifier.send_signal_alert(
+                                symbol=symbol,
+                                interval=interval,
+                                entry_price=actual_price,
+                                stop_loss=float(trading_signal.stop_loss),
+                                take_profit_1=float(trading_signal.take_profit_1),
+                                take_profit_2=float(trading_signal.take_profit_2),
+                                take_profit_3=float(trading_signal.take_profit_3),
+                                confidence=confidence,
+                                risk_reward=float(trading_signal.risk_reward_ratio),
+                                invested_amount=position_usdt,
+                                quantity=quantity,
+                                order_id=order_id,
+                            )
+                        except Exception as e:
+                            logger.error(f"Failed to send Telegram alert: {e}")
+    
+    def _position_monitor_loop(self):
+        """Background thread to monitor open positions"""
+        while self.running and not self.stop_event.is_set():
+            try:
+                with self.position_lock:
+                    positions_to_close = []
+                    
+                    for pos_id, position in list(self.open_positions.items()):
+                        result = self._check_position_updates(position)
+                        if result:
+                            positions_to_close.append((pos_id, result))
+                    
+                    for pos_id, result in positions_to_close:
+                        del self.open_positions[pos_id]
+                        self.completed_trades.append(result)
+                        self.total_realized_pnl += result.realized_pnl
+                        
+                        emoji = "💰" if result.realized_pnl > 0 else "💸"
+                        logger.info(f"{emoji} Trade closed: ${result.realized_pnl:+.2f}")
+                
+            except Exception as e:
+                logger.error(f"Error in position monitor: {e}")
+            
+            time.sleep(self.position_check_interval)
+    
+    def _print_status(self):
+        """Print current status summary"""
+        now = datetime.now()
+        runtime = (now - self.start_time).total_seconds() / 60 if self.start_time else 0
+        
+        # Get current balance
+        current_balance = self.client.get_spot_balance("USDT")
+        
+        # Calculate unrealized P/L
+        total_unrealized = sum(pos.unrealized_pnl for pos in self.open_positions.values())
+        
+        total_trades = len(self.completed_trades)
+        wins = sum(1 for t in self.completed_trades if t.realized_pnl > 0)
+        
+        print(f"""
+{'═'*70}
+📊 LIVE TRADING STATUS - {now.strftime('%Y-%m-%d %H:%M:%S')}
+{'═'*70}
+  Runtime:           {runtime:.1f} minutes
+  
+  💰 BALANCE:
+     USDT Available: ${current_balance:,.2f}
+     Initial:        ${self.initial_balance:,.2f}
+     Realized P/L:   ${self.total_realized_pnl:+,.2f}
+     Unrealized P/L: ${total_unrealized:+,.2f}
+  
+  📊 TRADING STATS:
+     Completed:      {total_trades} trades
+     Win Rate:       {wins/total_trades*100:.1f}% ({wins}/{total_trades}) {'' if total_trades == 0 else ''}
+     Open Positions: {len(self.open_positions)}
+{'─'*70}""")
+        
+        if self.open_positions:
+            print("  OPEN POSITIONS:")
+            for pos in self.open_positions.values():
+                duration = (now - pos.entry_time).total_seconds() / 60
+                pnl_pct = ((pos.current_price - pos.entry_price) / pos.entry_price * 100) if pos.current_price > 0 else 0
+                pnl_emoji = "📈" if pos.unrealized_pnl >= 0 else "📉"
+                print(f"    {pnl_emoji} {pos.symbol} {pos.interval}:")
+                print(f"       Entry: ${pos.entry_price:,.2f} → ${pos.current_price:,.2f} ({pnl_pct:+.2f}%)")
+                print(f"       Qty: {pos.quantity:.6f} | P/L: ${pos.unrealized_pnl:+,.2f}")
+                print(f"       SL: ${pos.stop_loss:,.2f} | Duration: {duration:.1f}m")
+        
+        print(f"{'═'*70}\n")
+    
+    def run(self, duration_hours: float = None):
+        """Run the live trading system"""
+        # Test connection
+        if not self.client.test_connection():
+            logger.error("❌ Failed to connect to Bybit. Check your API credentials.")
+            return
+        
+        # Get initial balance
+        self.initial_balance = self.client.get_spot_balance("USDT")
+        
+        self.running = True
+        self.start_time = datetime.now()
+        
+        # Determine which combinations to monitor
+        combinations = [
+            c for c in self.COMBINATIONS
+            if not self.safe_only or c["priority"] == "SAFE"
+        ]
+        
+        # Get confidence threshold
+        conf_threshold = self.weights[18] if len(self.weights) > 18 else 0.3
+        conf_threshold = max(0.1, min(0.9, conf_threshold))
+        
+        logger.info(f"""
+{'═'*70}
+🚀 STARTING LIVE TRADING {'(TESTNET)' if self.client.testnet else '(MAINNET)'}
+{'═'*70}
+  ⚠️  WARNING: This will execute REAL trades!
+  
+  Initial Balance: ${self.initial_balance:,.2f} USDT
+  Max per Trade:   ${self.max_position_usdt:,.2f} USDT
+  Risk per Trade:  {self.risk_percentage}%
+  Max Positions:   {self.max_open_positions}
+  Confidence:      >{max(conf_threshold, self.min_confidence):.0%}
+  Trailing Stop:   {'Enabled' if self.use_trailing_stop else 'Disabled'} ({self.trailing_stop_distance}%)
+  Mode:            {'SAFE ONLY' if self.safe_only else 'ALL COMBINATIONS'}
+  Duration:        {f'{duration_hours} hours' if duration_hours else 'Unlimited (Ctrl+C to stop)'}
+  
+  Monitoring {len(combinations)} combinations:
+""")
+        for c in combinations:
+            logger.info(f"    • {c['symbol']} {c['interval']} [{c['priority']}]")
+        
+        logger.info(f"{'═'*70}\n")
+        
+        # Send Telegram startup notification
+        if self.notifier:
+            try:
+                self.notifier.send_startup(
+                    testnet=self.client.testnet,
+                    initial_balance=self.initial_balance,
+                    max_position=self.max_position_usdt,
+                    max_positions=self.max_open_positions,
+                    combinations=combinations,
+                )
+            except Exception as e:
+                logger.error(f"Failed to send Telegram startup alert: {e}")
+        
+        # Start position monitor thread
+        monitor_thread = Thread(target=self._position_monitor_loop, daemon=True)
+        monitor_thread.start()
+        
+        end_time = datetime.now() + timedelta(hours=duration_hours) if duration_hours else None
+        last_status_print = datetime.now()
+        status_interval = 60
+        
+        try:
+            while self.running:
+                if end_time and datetime.now() >= end_time:
+                    logger.info("Duration reached. Stopping...")
+                    break
+                
+                if self.stop_event.is_set():
+                    break
+                
+                # Process each combination
+                for combo in combinations:
+                    if self.stop_event.is_set():
+                        break
+                    
+                    try:
+                        self._process_combination(combo["symbol"], combo["interval"])
+                    except Exception as e:
+                        logger.error(f"Error processing {combo['symbol']} {combo['interval']}: {e}")
+                
+                # Print status periodically
+                if (datetime.now() - last_status_print).total_seconds() >= status_interval:
+                    self._print_status()
+                    last_status_print = datetime.now()
+                
+                time.sleep(5)
+                
+        except KeyboardInterrupt:
+            logger.info("\n⚠️ Interrupted by user")
+        finally:
+            self.running = False
+            self._print_final_report()
+    
+    def _print_final_report(self):
+        """Print final trading report"""
+        runtime = (datetime.now() - self.start_time).total_seconds() / 60 if self.start_time else 0
+        final_balance = self.client.get_spot_balance("USDT")
+        
+        total_trades = len(self.completed_trades)
+        wins = sum(1 for t in self.completed_trades if t.realized_pnl > 0)
+        
+        print(f"""
+{'═'*70}
+📊 FINAL LIVE TRADING REPORT
+{'═'*70}
+
+  Duration:         {runtime:.1f} minutes ({runtime/60:.2f} hours)
+  Initial Balance:  ${self.initial_balance:,.2f}
+  Final Balance:    ${final_balance:,.2f}
+  
+  PERFORMANCE:
+  ─────────────────────────────────
+  Realized P/L:     ${self.total_realized_pnl:+,.2f}
+  ROI:              {(self.total_realized_pnl/self.initial_balance)*100 if self.initial_balance > 0 else 0:+.2f}%
+  Total Trades:     {total_trades}
+  Win Rate:         {wins/total_trades*100 if total_trades > 0 else 0:.1f}% ({wins}/{total_trades})
+  
+  Open Positions:   {len(self.open_positions)}
+  
+{'═'*70}
+""")
+        
+        # Warn about open positions
+        if self.open_positions:
+            logger.warning(f"⚠️ {len(self.open_positions)} positions still open!")
+            for pos in self.open_positions.values():
+                logger.warning(f"   • {pos.symbol}: {pos.quantity:.6f} @ ${pos.entry_price:.2f}")
+        
+        # Send Telegram shutdown notification
+        if self.notifier:
+            try:
+                self.notifier.send_shutdown(
+                    runtime_minutes=runtime,
+                    total_trades=total_trades,
+                    total_pnl=self.total_realized_pnl,
+                    open_positions=len(self.open_positions),
+                )
+            except Exception as e:
+                logger.error(f"Failed to send Telegram shutdown alert: {e}")
+        
+        # Save results
+        self._save_results()
+    
+    def _save_results(self):
+        """Save trading results to JSON file"""
+        results = {
+            "timestamp": datetime.now().isoformat(),
+            "runtime_minutes": (datetime.now() - self.start_time).total_seconds() / 60 if self.start_time else 0,
+            "initial_balance": self.initial_balance,
+            "final_balance": self.client.get_spot_balance("USDT"),
+            "total_realized_pnl": self.total_realized_pnl,
+            "total_trades": len(self.completed_trades),
+            "testnet": self.client.testnet,
+            
+            "completed_trades": [
+                {
+                    "position_id": t.position_id,
+                    "symbol": t.symbol,
+                    "interval": t.interval,
+                    "entry_price": t.entry_price,
+                    "exit_price": t.exit_price,
+                    "quantity": t.quantity,
+                    "invested_amount": t.invested_amount,
+                    "realized_pnl": t.realized_pnl,
+                    "profit_percent": t.profit_percent,
+                    "exit_type": t.exit_type,
+                    "duration_minutes": t.duration_minutes,
+                    "entry_time": t.entry_time.isoformat(),
+                    "exit_time": t.exit_time.isoformat(),
+                    "entry_order_id": t.entry_order_id,
+                    "exit_order_id": t.exit_order_id,
+                }
+                for t in self.completed_trades
+            ],
+            
+            "open_positions": [
+                {
+                    "position_id": pos.position_id,
+                    "symbol": pos.symbol,
+                    "interval": pos.interval,
+                    "entry_price": pos.entry_price,
+                    "quantity": pos.quantity,
+                    "invested_amount": pos.invested_amount,
+                    "stop_loss": pos.stop_loss,
+                    "current_price": pos.current_price,
+                    "unrealized_pnl": pos.unrealized_pnl,
+                    "order_id": pos.order_id,
+                }
+                for pos in self.open_positions.values()
+            ],
+        }
+        
+        output_file = os.path.join(
+            os.path.dirname(__file__),
+            f"data/live_trading_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        )
+        
+        os.makedirs(os.path.dirname(output_file), exist_ok=True)
+        
+        with open(output_file, 'w') as f:
+            json.dump(results, f, indent=2)
+        
+        logger.info(f"✓ Results saved to: {output_file}")
+
+
+def signal_handler(signum, frame):
+    """Handle interrupt signals"""
+    print("\n⚠️ Received interrupt signal. Shutting down gracefully...")
+    raise KeyboardInterrupt
+
+
+def main():
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Bybit Live Trading Synchronization")
+    parser.add_argument("--testnet", action="store_true", help="Use Bybit testnet")
+    parser.add_argument("--max-position", type=float, default=100.0, 
+                        help="Maximum USDT per trade (default: 100)")
+    parser.add_argument("--risk", type=float, default=1.0, 
+                        help="Risk percentage per trade (default: 1.0)")
+    parser.add_argument("--max-positions", type=int, default=3,
+                        help="Maximum concurrent open positions (default: 3)")
+    parser.add_argument("--duration", type=float, default=None, 
+                        help="Trading duration in hours (default: unlimited)")
+    parser.add_argument("--safe-only", action="store_true", 
+                        help="Only use safe combinations")
+    parser.add_argument("--min-confidence", type=float, default=0.3,
+                        help="Minimum signal confidence (default: 0.3)")
+    parser.add_argument("--no-trailing", action="store_true", 
+                        help="Disable trailing stop")
+    parser.add_argument("--confirm", action="store_true",
+                        help="Confirm live trading (required for mainnet)")
+    parser.add_argument("--telegram-id", type=int, default=840355587,
+                        help="Telegram chat ID for alerts (default: 840355587)")
+    parser.add_argument("--no-telegram", action="store_true",
+                        help="Disable Telegram notifications")
+    
+    args = parser.parse_args()
+    
+    # Safety check for mainnet
+    if not args.testnet and not args.confirm:
+        print("""
+⚠️  WARNING: You are about to start LIVE TRADING on MAINNET!
+    
+    This will execute REAL trades with REAL money.
+    
+    To confirm, add the --confirm flag:
+    
+    python bybit_sync.py --confirm [other options]
+    
+    Or use testnet for testing:
+    
+    python bybit_sync.py --testnet [other options]
+""")
+        return
+    
+    # Set up signal handlers
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+    
+    # Create Bybit client
+    client = BybitClient(testnet=args.testnet)
+    
+    # Create trader
+    trader = BybitLiveTrader(
+        bybit_client=client,
+        max_position_usdt=args.max_position,
+        risk_percentage=args.risk,
+        use_trailing_stop=not args.no_trailing,
+        safe_only=args.safe_only,
+        min_confidence=args.min_confidence,
+        max_open_positions=args.max_positions,
+        telegram_chat_id=0 if args.no_telegram else args.telegram_id,
+    )
+    
+    # Run trading
+    trader.run(duration_hours=args.duration)
+
+
+if __name__ == "__main__":
+    main()
+
diff --git a/back_tester/enhanced_metrics.py b/back_tester/enhanced_metrics.py
new file mode 100644
index 0000000..d37003b
--- /dev/null
+++ b/back_tester/enhanced_metrics.py
@@ -0,0 +1,669 @@
+"""
+Enhanced Metrics Module for Backtesting System
+
+Provides comprehensive, informative metrics including:
+1. Indicator-level performance breakdown
+2. Market regime analysis
+3. Signal quality scoring
+4. Trade attribution and root cause analysis
+5. Learning suggestions based on performance patterns
+"""
+
+import numpy as np
+import pandas as pd
+from typing import List, Dict, Any, Optional, Tuple
+from dataclasses import dataclass, field
+from datetime import datetime
+from collections import defaultdict
+import json
+import os
+
+
+@dataclass
+class TradeMetrics:
+    """Detailed metrics for a single trade"""
+    trade_id: str
+    symbol: str
+    interval: str
+    signal_type: str
+    entry_price: float
+    exit_price: float
+    stop_loss: float
+    take_profit_targets: List[float]
+    
+    # Outcome
+    outcome: str  # tp1, tp2, tp3, stop_loss, trailing_stop, end_of_period
+    profit_loss: float
+    profit_loss_percent: float
+    risk_reward_achieved: float
+    
+    # Duration
+    entry_index: int
+    exit_index: int
+    duration_candles: int
+    
+    # Market context
+    market_regime: str = ""
+    volatility: float = 0.0
+    volume_ratio: float = 1.0
+    trend: str = ""
+    
+    # Indicator contributions
+    contributing_indicators: List[str] = field(default_factory=list)
+    indicator_scores: Dict[str, float] = field(default_factory=dict)
+    
+    # Trade quality metrics
+    max_favorable_excursion: float = 0.0  # Best profit during trade
+    max_adverse_excursion: float = 0.0    # Worst drawdown during trade
+    r_multiple: float = 0.0               # Actual R achieved
+    
+    def is_winner(self) -> bool:
+        return self.outcome in ['tp1', 'tp2', 'tp3', 'trailing_stop'] or self.profit_loss > 0
+    
+    def is_full_target(self) -> bool:
+        return self.outcome == 'tp3'
+
+
+class EnhancedMetricsCalculator:
+    """
+    Calculates and aggregates enhanced trading metrics with 
+    detailed breakdowns for learning and optimization.
+    """
+    
+    def __init__(self):
+        self.trades: List[TradeMetrics] = []
+        self.indicator_performance: Dict[str, Dict] = defaultdict(
+            lambda: {
+                'wins': 0, 'losses': 0, 'total_pnl': 0.0, 
+                'avg_r': 0.0, 'r_values': [],
+                'tp1_hits': 0, 'tp2_hits': 0, 'tp3_hits': 0, 'stop_hits': 0
+            }
+        )
+        self.regime_performance: Dict[str, Dict] = defaultdict(
+            lambda: {'wins': 0, 'losses': 0, 'total_pnl': 0.0, 'trades': 0}
+        )
+        self.symbol_performance: Dict[str, Dict] = defaultdict(
+            lambda: {'wins': 0, 'losses': 0, 'total_pnl': 0.0, 'trades': 0}
+        )
+        self.interval_performance: Dict[str, Dict] = defaultdict(
+            lambda: {'wins': 0, 'losses': 0, 'total_pnl': 0.0, 'trades': 0}
+        )
+    
+    def add_trade(self, trade: TradeMetrics):
+        """Add a completed trade to metrics"""
+        self.trades.append(trade)
+        self._update_indicator_stats(trade)
+        self._update_regime_stats(trade)
+        self._update_symbol_stats(trade)
+        self._update_interval_stats(trade)
+    
+    def _update_indicator_stats(self, trade: TradeMetrics):
+        """Update indicator-level statistics"""
+        is_win = trade.is_winner()
+        
+        for indicator in trade.contributing_indicators:
+            stats = self.indicator_performance[indicator]
+            if is_win:
+                stats['wins'] += 1
+            else:
+                stats['losses'] += 1
+            
+            stats['total_pnl'] += trade.profit_loss
+            stats['r_values'].append(trade.r_multiple)
+            
+            # Track specific outcomes
+            if trade.outcome == 'tp1':
+                stats['tp1_hits'] += 1
+            elif trade.outcome == 'tp2':
+                stats['tp2_hits'] += 1
+            elif trade.outcome == 'tp3':
+                stats['tp3_hits'] += 1
+            elif trade.outcome in ['stop_loss', 'trailing_stop']:
+                stats['stop_hits'] += 1
+    
+    def _update_regime_stats(self, trade: TradeMetrics):
+        """Update market regime statistics"""
+        stats = self.regime_performance[trade.market_regime or 'unknown']
+        stats['trades'] += 1
+        stats['total_pnl'] += trade.profit_loss
+        if trade.is_winner():
+            stats['wins'] += 1
+        else:
+            stats['losses'] += 1
+    
+    def _update_symbol_stats(self, trade: TradeMetrics):
+        """Update symbol-level statistics"""
+        stats = self.symbol_performance[trade.symbol]
+        stats['trades'] += 1
+        stats['total_pnl'] += trade.profit_loss
+        if trade.is_winner():
+            stats['wins'] += 1
+        else:
+            stats['losses'] += 1
+    
+    def _update_interval_stats(self, trade: TradeMetrics):
+        """Update interval/timeframe statistics"""
+        stats = self.interval_performance[trade.interval]
+        stats['trades'] += 1
+        stats['total_pnl'] += trade.profit_loss
+        if trade.is_winner():
+            stats['wins'] += 1
+        else:
+            stats['losses'] += 1
+    
+    def calculate_comprehensive_metrics(self, 
+                                         initial_balance: float,
+                                         final_balance: float) -> Dict[str, Any]:
+        """Calculate comprehensive performance metrics with full breakdown"""
+        
+        if not self.trades:
+            return self._empty_metrics()
+        
+        # Basic metrics
+        total_trades = len(self.trades)
+        winners = [t for t in self.trades if t.is_winner()]
+        losers = [t for t in self.trades if not t.is_winner()]
+        
+        win_rate = len(winners) / total_trades * 100 if total_trades > 0 else 0
+        
+        # P/L calculations
+        total_profit = sum(t.profit_loss for t in winners)
+        total_loss = sum(t.profit_loss for t in losers)
+        net_profit = total_profit + total_loss
+        
+        # Profit factor
+        profit_factor = abs(total_profit / total_loss) if total_loss != 0 else float('inf')
+        
+        # R-multiple statistics
+        r_multiples = [t.r_multiple for t in self.trades if t.r_multiple != 0]
+        avg_r = np.mean(r_multiples) if r_multiples else 0
+        
+        # Drawdown calculation
+        equity_curve = self._calculate_equity_curve(initial_balance)
+        max_drawdown = self._calculate_max_drawdown(equity_curve)
+        
+        # Expectancy
+        avg_win = np.mean([t.profit_loss for t in winners]) if winners else 0
+        avg_loss = np.mean([t.profit_loss for t in losers]) if losers else 0
+        expectancy = (win_rate/100 * avg_win) + ((1 - win_rate/100) * avg_loss)
+        
+        # Exit type breakdown
+        exit_breakdown = self._calculate_exit_breakdown()
+        
+        # Indicator performance breakdown
+        indicator_breakdown = self._calculate_indicator_breakdown()
+        
+        # Regime performance breakdown
+        regime_breakdown = self._calculate_regime_breakdown()
+        
+        # Symbol performance breakdown
+        symbol_breakdown = self._calculate_symbol_breakdown()
+        
+        # Generate insights and recommendations
+        insights = self._generate_insights()
+        
+        return {
+            # Summary
+            'summary': {
+                'total_trades': total_trades,
+                'winners': len(winners),
+                'losers': len(losers),
+                'win_rate': win_rate,
+                'profit_factor': profit_factor,
+                'net_profit': net_profit,
+                'total_return_pct': (final_balance - initial_balance) / initial_balance * 100,
+                'max_drawdown_pct': max_drawdown,
+                'expectancy': expectancy,
+                'avg_r_multiple': avg_r
+            },
+            
+            # Detailed trade statistics
+            'trade_stats': {
+                'avg_winner': avg_win,
+                'avg_loser': avg_loss,
+                'largest_winner': max((t.profit_loss for t in winners), default=0),
+                'largest_loser': min((t.profit_loss for t in losers), default=0),
+                'avg_duration_candles': np.mean([t.duration_candles for t in self.trades]),
+                'avg_mfe': np.mean([t.max_favorable_excursion for t in self.trades]),
+                'avg_mae': np.mean([t.max_adverse_excursion for t in self.trades])
+            },
+            
+            # Exit type breakdown
+            'exit_breakdown': exit_breakdown,
+            
+            # Indicator performance
+            'indicator_performance': indicator_breakdown,
+            
+            # Market regime performance
+            'regime_performance': regime_breakdown,
+            
+            # Symbol performance
+            'symbol_performance': symbol_breakdown,
+            
+            # Timeframe performance
+            'interval_performance': self._calculate_interval_breakdown(),
+            
+            # Learning insights
+            'insights': insights,
+            
+            # Equity curve for visualization
+            'equity_curve': equity_curve
+        }
+    
+    def _empty_metrics(self) -> Dict[str, Any]:
+        """Return empty metrics structure"""
+        return {
+            'summary': {
+                'total_trades': 0, 'win_rate': 0, 'profit_factor': 0,
+                'net_profit': 0, 'max_drawdown_pct': 0, 'expectancy': 0
+            },
+            'trade_stats': {},
+            'exit_breakdown': {},
+            'indicator_performance': {},
+            'regime_performance': {},
+            'symbol_performance': {},
+            'interval_performance': {},
+            'insights': {'recommendations': ['Insufficient data for analysis']},
+            'equity_curve': []
+        }
+    
+    def _calculate_equity_curve(self, initial_balance: float) -> List[float]:
+        """Calculate cumulative equity curve"""
+        equity = [initial_balance]
+        for trade in self.trades:
+            equity.append(equity[-1] + trade.profit_loss)
+        return equity
+    
+    def _calculate_max_drawdown(self, equity_curve: List[float]) -> float:
+        """Calculate maximum drawdown percentage"""
+        if not equity_curve:
+            return 0
+        
+        peak = equity_curve[0]
+        max_dd = 0
+        
+        for equity in equity_curve:
+            if equity > peak:
+                peak = equity
+            dd = (peak - equity) / peak * 100 if peak > 0 else 0
+            max_dd = max(max_dd, dd)
+        
+        return max_dd
+    
+    def _calculate_exit_breakdown(self) -> Dict[str, Dict]:
+        """Calculate breakdown by exit type"""
+        breakdown = defaultdict(lambda: {'count': 0, 'total_pnl': 0.0, 'avg_pnl': 0.0})
+        
+        for trade in self.trades:
+            stats = breakdown[trade.outcome]
+            stats['count'] += 1
+            stats['total_pnl'] += trade.profit_loss
+        
+        for outcome, stats in breakdown.items():
+            if stats['count'] > 0:
+                stats['avg_pnl'] = stats['total_pnl'] / stats['count']
+                stats['percentage'] = stats['count'] / len(self.trades) * 100
+        
+        return dict(breakdown)
+    
+    def _calculate_indicator_breakdown(self) -> Dict[str, Dict]:
+        """Calculate detailed indicator performance breakdown"""
+        breakdown = {}
+        
+        for indicator, stats in self.indicator_performance.items():
+            total = stats['wins'] + stats['losses']
+            if total == 0:
+                continue
+            
+            win_rate = stats['wins'] / total * 100
+            avg_r = np.mean(stats['r_values']) if stats['r_values'] else 0
+            
+            # Calculate score for ranking
+            # Score = win_rate * 0.4 + normalized_pnl * 0.3 + avg_r * 0.3
+            pnl_score = min(1.0, max(-1.0, stats['total_pnl'] / 1000))  # Normalize to -1 to 1
+            r_score = min(1.0, max(-1.0, avg_r / 3))  # Normalize R to -1 to 1
+            score = win_rate / 100 * 0.4 + (pnl_score + 1) / 2 * 0.3 + (r_score + 1) / 2 * 0.3
+            
+            breakdown[indicator] = {
+                'total_signals': total,
+                'wins': stats['wins'],
+                'losses': stats['losses'],
+                'win_rate': win_rate,
+                'total_pnl': stats['total_pnl'],
+                'avg_pnl': stats['total_pnl'] / total,
+                'avg_r': avg_r,
+                'tp1_hits': stats['tp1_hits'],
+                'tp2_hits': stats['tp2_hits'],
+                'tp3_hits': stats['tp3_hits'],
+                'stop_hits': stats['stop_hits'],
+                'score': score,
+                'status': self._get_indicator_status(win_rate, stats['total_pnl'])
+            }
+        
+        # Sort by score
+        return dict(sorted(breakdown.items(), key=lambda x: x[1]['score'], reverse=True))
+    
+    def _get_indicator_status(self, win_rate: float, total_pnl: float) -> str:
+        """Get indicator health status"""
+        if win_rate >= 60 and total_pnl > 0:
+            return 'excellent'
+        elif win_rate >= 50 and total_pnl >= 0:
+            return 'good'
+        elif win_rate >= 40:
+            return 'average'
+        else:
+            return 'poor'
+    
+    def _calculate_regime_breakdown(self) -> Dict[str, Dict]:
+        """Calculate performance by market regime"""
+        breakdown = {}
+        
+        for regime, stats in self.regime_performance.items():
+            if stats['trades'] == 0:
+                continue
+            
+            win_rate = stats['wins'] / stats['trades'] * 100
+            breakdown[regime] = {
+                'trades': stats['trades'],
+                'wins': stats['wins'],
+                'losses': stats['losses'],
+                'win_rate': win_rate,
+                'total_pnl': stats['total_pnl'],
+                'avg_pnl': stats['total_pnl'] / stats['trades'],
+                'recommendation': self._get_regime_recommendation(regime, win_rate, stats['total_pnl'])
+            }
+        
+        return breakdown
+    
+    def _get_regime_recommendation(self, regime: str, win_rate: float, pnl: float) -> str:
+        """Get recommendation for trading in specific regime"""
+        if win_rate >= 55 and pnl > 0:
+            return f"Good performance in {regime} - continue trading"
+        elif win_rate < 40 or pnl < 0:
+            return f"Poor performance in {regime} - consider filtering signals or reducing position size"
+        else:
+            return f"Average performance in {regime} - monitor closely"
+    
+    def _calculate_symbol_breakdown(self) -> Dict[str, Dict]:
+        """Calculate performance by symbol"""
+        breakdown = {}
+        
+        for symbol, stats in self.symbol_performance.items():
+            if stats['trades'] == 0:
+                continue
+            
+            win_rate = stats['wins'] / stats['trades'] * 100
+            breakdown[symbol] = {
+                'trades': stats['trades'],
+                'wins': stats['wins'],
+                'losses': stats['losses'],
+                'win_rate': win_rate,
+                'total_pnl': stats['total_pnl'],
+                'avg_pnl': stats['total_pnl'] / stats['trades']
+            }
+        
+        return dict(sorted(breakdown.items(), key=lambda x: x[1]['total_pnl'], reverse=True))
+    
+    def _calculate_interval_breakdown(self) -> Dict[str, Dict]:
+        """Calculate performance by timeframe"""
+        breakdown = {}
+        
+        for interval, stats in self.interval_performance.items():
+            if stats['trades'] == 0:
+                continue
+            
+            win_rate = stats['wins'] / stats['trades'] * 100
+            breakdown[interval] = {
+                'trades': stats['trades'],
+                'wins': stats['wins'],
+                'losses': stats['losses'],
+                'win_rate': win_rate,
+                'total_pnl': stats['total_pnl'],
+                'avg_pnl': stats['total_pnl'] / stats['trades']
+            }
+        
+        return breakdown
+    
+    def _generate_insights(self) -> Dict[str, Any]:
+        """Generate actionable insights from performance data"""
+        insights = {
+            'strong_indicators': [],
+            'weak_indicators': [],
+            'best_regimes': [],
+            'worst_regimes': [],
+            'recommendations': []
+        }
+        
+        # Indicator insights
+        for indicator, stats in self._calculate_indicator_breakdown().items():
+            if stats['total_signals'] >= 10:  # Minimum sample size
+                if stats['status'] == 'excellent':
+                    insights['strong_indicators'].append({
+                        'name': indicator,
+                        'win_rate': stats['win_rate'],
+                        'avg_pnl': stats['avg_pnl']
+                    })
+                elif stats['status'] == 'poor':
+                    insights['weak_indicators'].append({
+                        'name': indicator,
+                        'win_rate': stats['win_rate'],
+                        'avg_pnl': stats['avg_pnl']
+                    })
+        
+        # Regime insights
+        regime_breakdown = self._calculate_regime_breakdown()
+        sorted_regimes = sorted(regime_breakdown.items(), 
+                                key=lambda x: x[1]['win_rate'], reverse=True)
+        
+        if sorted_regimes:
+            insights['best_regimes'] = [sorted_regimes[0][0]] if sorted_regimes else []
+            insights['worst_regimes'] = [sorted_regimes[-1][0]] if len(sorted_regimes) > 1 else []
+        
+        # Generate recommendations
+        if insights['weak_indicators']:
+            weak_names = [i['name'] for i in insights['weak_indicators'][:3]]
+            insights['recommendations'].append(
+                f"Consider reducing weights for: {', '.join(weak_names)}"
+            )
+        
+        if insights['strong_indicators']:
+            strong_names = [i['name'] for i in insights['strong_indicators'][:3]]
+            insights['recommendations'].append(
+                f"Consider increasing weights for: {', '.join(strong_names)}"
+            )
+        
+        if insights['worst_regimes']:
+            worst_regime = insights['worst_regimes'][0]
+            regime_stats = regime_breakdown.get(worst_regime, {})
+            if regime_stats.get('win_rate', 100) < 40:
+                insights['recommendations'].append(
+                    f"Consider avoiding signals in '{worst_regime}' market regime"
+                )
+        
+        # Check for recent performance decline
+        if len(self.trades) >= 50:
+            recent_trades = self.trades[-25:]
+            older_trades = self.trades[-50:-25]
+            
+            recent_win_rate = sum(1 for t in recent_trades if t.is_winner()) / len(recent_trades) * 100
+            older_win_rate = sum(1 for t in older_trades if t.is_winner()) / len(older_trades) * 100
+            
+            if recent_win_rate < older_win_rate - 10:
+                insights['recommendations'].append(
+                    f"Performance declining: Recent win rate {recent_win_rate:.1f}% vs "
+                    f"previous {older_win_rate:.1f}%. Consider retraining weights."
+                )
+        
+        return insights
+    
+    def print_detailed_report(self, initial_balance: float, final_balance: float):
+        """Print detailed performance report"""
+        metrics = self.calculate_comprehensive_metrics(initial_balance, final_balance)
+        
+        print("\n" + "="*80)
+        print("📊 ENHANCED PERFORMANCE REPORT")
+        print("="*80)
+        
+        # Summary
+        s = metrics['summary']
+        print(f"\n📈 SUMMARY")
+        print(f"   Total Trades: {s['total_trades']}")
+        print(f"   Win Rate: {s['win_rate']:.1f}% ({s['winners']}W / {s['losers']}L)")
+        print(f"   Profit Factor: {s['profit_factor']:.2f}")
+        print(f"   Net Profit: ${s['net_profit']:.2f}")
+        print(f"   Total Return: {s['total_return_pct']:.2f}%")
+        print(f"   Max Drawdown: {s['max_drawdown_pct']:.2f}%")
+        print(f"   Expectancy: ${s['expectancy']:.2f}")
+        print(f"   Avg R-Multiple: {s['avg_r_multiple']:.2f}R")
+        
+        # Exit breakdown
+        if metrics['exit_breakdown']:
+            print(f"\n📤 EXIT TYPE BREAKDOWN")
+            for exit_type, stats in metrics['exit_breakdown'].items():
+                print(f"   {exit_type}: {stats['count']} ({stats['percentage']:.1f}%) | "
+                      f"Avg P/L: ${stats['avg_pnl']:.2f}")
+        
+        # Indicator performance
+        if metrics['indicator_performance']:
+            print(f"\n🎯 INDICATOR PERFORMANCE (Top 5)")
+            for i, (indicator, stats) in enumerate(list(metrics['indicator_performance'].items())[:5]):
+                status_emoji = {'excellent': '🟢', 'good': '🟡', 'average': '🟠', 'poor': '🔴'}
+                emoji = status_emoji.get(stats['status'], '⚪')
+                print(f"   {emoji} {indicator}: {stats['win_rate']:.1f}% WR | "
+                      f"${stats['avg_pnl']:.2f} avg | {stats['avg_r']:.2f}R | "
+                      f"TP1:{stats['tp1_hits']} TP2:{stats['tp2_hits']} TP3:{stats['tp3_hits']} SL:{stats['stop_hits']}")
+        
+        # Weak indicators
+        weak_indicators = [ind for ind, stats in metrics['indicator_performance'].items() 
+                          if stats['status'] == 'poor']
+        if weak_indicators:
+            print(f"\n🔴 UNDERPERFORMING INDICATORS")
+            for ind in weak_indicators[:5]:
+                stats = metrics['indicator_performance'][ind]
+                print(f"   {ind}: {stats['win_rate']:.1f}% WR, ${stats['total_pnl']:.2f} total")
+        
+        # Regime performance
+        if metrics['regime_performance']:
+            print(f"\n🌍 MARKET REGIME PERFORMANCE")
+            for regime, stats in metrics['regime_performance'].items():
+                print(f"   {regime}: {stats['win_rate']:.1f}% WR ({stats['trades']} trades) | "
+                      f"${stats['total_pnl']:.2f}")
+        
+        # Recommendations
+        if metrics['insights']['recommendations']:
+            print(f"\n💡 RECOMMENDATIONS")
+            for rec in metrics['insights']['recommendations']:
+                print(f"   • {rec}")
+        
+        print("\n" + "="*80)
+        
+        return metrics
+
+
+def create_trade_metrics(
+    trade_log: List[Dict],
+    entry_trade: Dict,
+    exit_trades: List[Dict],
+    market_context: Dict[str, Any],
+    indicator_contributions: Dict[str, float]
+) -> TradeMetrics:
+    """
+    Helper to create TradeMetrics from trade log data.
+    
+    Args:
+        trade_log: Full trade log
+        entry_trade: Entry trade dictionary
+        exit_trades: List of exit trades for this entry
+        market_context: Market context at entry
+        indicator_contributions: Indicator contributions to signal
+    """
+    
+    # Calculate final outcome
+    if not exit_trades:
+        outcome = 'end_of_period'
+        exit_price = entry_trade['price']
+        profit_loss = 0
+    else:
+        last_exit = exit_trades[-1]
+        outcome = last_exit.get('type', 'end_of_period')
+        # Map trade types to outcome strings
+        outcome_map = {
+            'take_profit_1': 'tp1',
+            'take_profit_2': 'tp2',
+            'take_profit_3': 'tp3',
+            'stop_loss': 'stop_loss',
+            'trailing_stop': 'trailing_stop',
+            'exit_end_of_period': 'end_of_period'
+        }
+        outcome = outcome_map.get(outcome, outcome)
+        exit_price = last_exit.get('price', entry_trade['price'])
+        profit_loss = sum(t.get('profit', 0) for t in exit_trades)
+    
+    # Calculate R-multiple
+    risk = abs(entry_trade['price'] - entry_trade.get('stop_loss', entry_trade['price']))
+    r_multiple = profit_loss / risk if risk > 0 else 0
+    
+    return TradeMetrics(
+        trade_id=entry_trade.get('trade_id', str(entry_trade.get('index', 0))),
+        symbol=entry_trade.get('symbol', 'UNKNOWN'),
+        interval=entry_trade.get('interval', '1h'),
+        signal_type=entry_trade.get('signal', '').split()[0] if entry_trade.get('signal') else 'Unknown',
+        entry_price=entry_trade['price'],
+        exit_price=exit_price,
+        stop_loss=entry_trade.get('stop_loss', 0),
+        take_profit_targets=[
+            entry_trade.get('take_profit_1', 0),
+            entry_trade.get('take_profit_2', 0),
+            entry_trade.get('take_profit_3', 0)
+        ],
+        outcome=outcome,
+        profit_loss=profit_loss,
+        profit_loss_percent=(exit_price - entry_trade['price']) / entry_trade['price'] * 100 if entry_trade['price'] > 0 else 0,
+        risk_reward_achieved=abs(profit_loss / risk) if risk > 0 else 0,
+        entry_index=entry_trade.get('index', 0),
+        exit_index=exit_trades[-1].get('index', 0) if exit_trades else entry_trade.get('index', 0),
+        duration_candles=exit_trades[-1].get('index', 0) - entry_trade.get('index', 0) if exit_trades else 0,
+        market_regime=market_context.get('market_regime', ''),
+        volatility=market_context.get('volatility', 0),
+        volume_ratio=market_context.get('volume_ratio', 1),
+        trend=market_context.get('trend', ''),
+        contributing_indicators=list(indicator_contributions.keys()),
+        indicator_scores=indicator_contributions,
+        r_multiple=r_multiple
+    )
+
+
+# Usage example
+if __name__ == "__main__":
+    # Create calculator
+    calc = EnhancedMetricsCalculator()
+    
+    # Example trade (normally these would come from backtest)
+    example_trade = TradeMetrics(
+        trade_id="test_1",
+        symbol="BTCUSDT",
+        interval="1h",
+        signal_type="Bullish",
+        entry_price=50000,
+        exit_price=51500,
+        stop_loss=49000,
+        take_profit_targets=[51000, 52000, 53000],
+        outcome="tp2",
+        profit_loss=150,
+        profit_loss_percent=3.0,
+        risk_reward_achieved=1.5,
+        entry_index=100,
+        exit_index=115,
+        duration_candles=15,
+        market_regime="trending_up",
+        volatility=0.02,
+        volume_ratio=1.2,
+        trend="uptrend",
+        contributing_indicators=["W_BULLISH_OB", "W_TREND", "W_STRUCTURE_BREAK"],
+        indicator_scores={"W_BULLISH_OB": 1.2, "W_TREND": 0.8, "W_STRUCTURE_BREAK": 1.5},
+        r_multiple=1.5
+    )
+    
+    calc.add_trade(example_trade)
+    calc.print_detailed_report(10000, 10150)
+
diff --git a/back_tester/examples_self_learning.py b/back_tester/examples_self_learning.py
new file mode 100644
index 0000000..65790fc
--- /dev/null
+++ b/back_tester/examples_self_learning.py
@@ -0,0 +1,411 @@
+#!/usr/bin/env python3
+"""
+Self-Learning Backtesting Examples
+
+This script demonstrates how to use the new self-learning capabilities
+of the backtesting system:
+
+1. Basic self-learning backtest
+2. Running multiple backtests to train the system
+3. Viewing performance analytics
+4. Triggering weight adjustments manually
+5. Understanding which indicators work best
+"""
+
+import os
+import sys
+from datetime import datetime
+
+# Add project root to path
+project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(project_dir)
+
+from back_tester.strategy import backtest_strategy
+from back_tester.adaptive_learning import (
+    SelfLearningBacktester,
+    SignalPerformanceTracker,
+    AdaptiveWeightAdjuster,
+    LearningMetricsAnalyzer,
+)
+
+# Weight names for reference
+WEIGHT_NAMES = SignalPerformanceTracker.WEIGHT_NAMES
+
+try:
+    from back_tester.enhanced_metrics import EnhancedMetricsCalculator
+except ImportError:
+    EnhancedMetricsCalculator = None
+
+
+def example_1_basic_self_learning_backtest():
+    """
+    Example 1: Run a basic backtest with self-learning enabled.
+    
+    The system will:
+    - Track each signal and its contributing indicators
+    - Record whether signals were successful or not
+    - Automatically adjust weights based on performance
+    """
+    print("\n" + "="*70)
+    print("EXAMPLE 1: Basic Self-Learning Backtest")
+    print("="*70)
+    
+    # Create the self-learning backtester
+    learner = SelfLearningBacktester(
+        storage_path="./data/learning",
+        auto_adjust_weights=True,
+        adjustment_frequency=50  # Adjust weights every 50 signals
+    )
+    
+    # Get current adaptive weights
+    weights = learner.get_current_weights()
+    print(f"\nCurrent adaptive weights: {weights}")
+    
+    # Run backtest with learning enabled
+    final_balance, trades, _ = backtest_strategy(
+        symbol="BTCUSDT",
+        interval="1h",
+        candles=500,
+        window=200,
+        initial_balance=10000.0,
+        risk_percentage=1.0,
+        enable_learning=True,
+        learner=learner,
+    )
+    
+    print(f"\nBacktest Results:")
+    print(f"  Final Balance: ${final_balance:.2f}")
+    print(f"  Total Trades: {len([t for t in trades if t['type'] == 'entry'])}")
+    
+    # View learning status
+    learner.print_status()
+    
+    return learner
+
+
+def example_2_multiple_backtests_training():
+    """
+    Example 2: Run multiple backtests to train the system.
+    
+    The more backtests you run, the better the system learns
+    which indicators work in different market conditions.
+    """
+    print("\n" + "="*70)
+    print("EXAMPLE 2: Training with Multiple Backtests")
+    print("="*70)
+    
+    # Create the self-learning backtester
+    learner = SelfLearningBacktester(
+        storage_path="./data/learning_training",
+        auto_adjust_weights=True,
+        adjustment_frequency=20  # More aggressive adjustment
+    )
+    
+    symbols = ["BTCUSDT", "ETHUSDT", "BNBUSDT"]
+    intervals = ["1h", "4h"]
+    
+    total_trades = 0
+    total_profit = 0
+    
+    print("\nRunning multiple backtests for training...")
+    
+    for symbol in symbols:
+        for interval in intervals:
+            try:
+                final_balance, trades, _ = backtest_strategy(
+                    symbol=symbol,
+                    interval=interval,
+                    candles=400,
+                    window=150,
+                    initial_balance=10000.0,
+                    risk_percentage=1.0,
+                    enable_learning=True,
+                    learner=learner,
+                )
+                
+                entry_trades = [t for t in trades if t['type'] == 'entry']
+                profit = final_balance - 10000.0
+                
+                print(f"  {symbol} {interval}: {len(entry_trades)} trades, "
+                      f"${profit:.2f} profit")
+                
+                total_trades += len(entry_trades)
+                total_profit += profit
+                
+            except Exception as e:
+                print(f"  {symbol} {interval}: Error - {e}")
+    
+    print(f"\nTraining Summary:")
+    print(f"  Total Trades: {total_trades}")
+    print(f"  Total Profit: ${total_profit:.2f}")
+    
+    # Force learning update
+    learner.force_learning()
+    
+    # View updated weights
+    new_weights = learner.get_current_weights()
+    print(f"\nUpdated weights after training: {new_weights}")
+    
+    # View detailed report
+    learner.print_status()
+    
+    return learner
+
+
+def example_3_analyze_indicator_performance():
+    """
+    Example 3: Analyze which indicators perform best.
+    
+    After running backtests, you can see detailed analytics
+    on which indicators contribute to winning trades.
+    """
+    print("\n" + "="*70)
+    print("EXAMPLE 3: Indicator Performance Analysis")
+    print("="*70)
+    
+    # Create tracker with existing data
+    tracker = SignalPerformanceTracker(storage_path="./data/learning/signals")
+    
+    # Get indicator performance breakdown
+    indicator_perf = tracker.get_indicator_performance()
+    
+    if indicator_perf.empty:
+        print("\nNo signal data available yet. Run some backtests first!")
+        return
+    
+    print("\n📊 Indicator Performance Ranking:")
+    print("-" * 60)
+    print(f"{'Indicator':<25} {'Signals':>8} {'Win Rate':>10} {'Avg P/L':>10}")
+    print("-" * 60)
+    
+    for _, row in indicator_perf.iterrows():
+        print(f"{row['indicator']:<25} {row['signals']:>8} "
+              f"{row['win_rate']:>9.1f}% ${row['avg_pnl']:>9.2f}")
+    
+    # Identify weak and strong indicators
+    weak = tracker.identify_weak_indicators()
+    strong = tracker.identify_strong_indicators()
+    
+    if strong:
+        print(f"\n🟢 Strong Indicators (>60% win rate): {', '.join(strong)}")
+    
+    if weak:
+        print(f"🔴 Weak Indicators (<40% win rate): {', '.join(weak)}")
+    
+    # Get market regime analysis
+    regime_perf = tracker.get_regime_performance()
+    if not regime_perf.empty:
+        print("\n📈 Performance by Market Regime:")
+        print("-" * 40)
+        for _, row in regime_perf.iterrows():
+            print(f"  {row['regime']}: {row['win_rate']:.1f}% win rate, "
+                  f"${row['total_pnl']:.2f} total")
+    
+    return tracker
+
+
+def example_4_manual_weight_adjustment():
+    """
+    Example 4: Manually trigger weight adjustments.
+    
+    Sometimes you want to manually review and apply
+    weight adjustments instead of automatic updates.
+    """
+    print("\n" + "="*70)
+    print("EXAMPLE 4: Manual Weight Adjustment")
+    print("="*70)
+    
+    # Create tracker and adjuster
+    tracker = SignalPerformanceTracker(storage_path="./data/learning/signals")
+    adjuster = AdaptiveWeightAdjuster(
+        performance_tracker=tracker,
+        learning_rate=0.05,
+        storage_path="./data/learning/weights"
+    )
+    
+    # Get current weights
+    current_weights = adjuster.current_weights
+    print("\nCurrent Weights:")
+    for name, value in current_weights.items():
+        print(f"  {name}: {value:.3f}")
+    
+    # Calculate suggested adjustments
+    adjustments = adjuster.calculate_weight_adjustments()
+    
+    if adjustments:
+        print("\n📝 Suggested Adjustments:")
+        for indicator, adjustment in sorted(adjustments.items(), 
+                                            key=lambda x: abs(x[1]), reverse=True):
+            direction = "↑" if adjustment > 0 else "↓"
+            print(f"  {indicator}: {direction} {abs(adjustment):.4f}")
+        
+        # Apply adjustments
+        confirm = input("\nApply these adjustments? (y/n): ").lower()
+        if confirm == 'y':
+            new_weights = adjuster.apply_adjustments(adjustments)
+            print("\n✅ Weights updated!")
+            
+            # Show changes
+            print("\nWeight Changes:")
+            for name in new_weights:
+                old = current_weights.get(name, 1.0)
+                new = new_weights[name]
+                if old != new:
+                    print(f"  {name}: {old:.3f} → {new:.3f}")
+    else:
+        print("\nNo adjustments needed based on current data.")
+    
+    return adjuster
+
+
+def example_5_enhanced_backtest_with_metrics():
+    """
+    Example 5: Run enhanced backtest with detailed metrics.
+    
+    This example shows how to use the EnhancedMetricsCalculator
+    for detailed trade analysis.
+    """
+    print("\n" + "="*70)
+    print("EXAMPLE 5: Enhanced Metrics Analysis")
+    print("="*70)
+    
+    # Create metrics calculator
+    metrics_calc = EnhancedMetricsCalculator()
+    
+    # Create self-learning backtester
+    learner = SelfLearningBacktester(
+        storage_path="./data/learning_metrics",
+        auto_adjust_weights=True
+    )
+    
+    # Run backtest
+    final_balance, trades, _ = backtest_strategy(
+        symbol="BTCUSDT",
+        interval="1h",
+        candles=600,
+        window=250,
+        initial_balance=10000.0,
+        risk_percentage=1.0,
+        enable_learning=True,
+        learner=learner,
+        metrics_calculator=metrics_calc,
+    )
+    
+    # Print detailed metrics report
+    if trades:
+        metrics_calc.print_detailed_report(10000.0, final_balance)
+    else:
+        print("\nNo trades executed in this backtest.")
+    
+    return metrics_calc
+
+
+def example_6_continuous_learning_loop():
+    """
+    Example 6: Continuous learning loop.
+    
+    This example shows how to set up a continuous learning loop
+    that runs backtests, learns from results, and improves over time.
+    """
+    print("\n" + "="*70)
+    print("EXAMPLE 6: Continuous Learning Loop")
+    print("="*70)
+    
+    # Create the self-learning backtester
+    learner = SelfLearningBacktester(
+        storage_path="./data/learning_continuous",
+        auto_adjust_weights=True,
+        adjustment_frequency=30
+    )
+    
+    symbols = ["BTCUSDT", "ETHUSDT"]
+    iterations = 3
+    
+    print(f"\nRunning {iterations} learning iterations...")
+    
+    for iteration in range(1, iterations + 1):
+        print(f"\n--- Iteration {iteration} ---")
+        
+        # Get current weights (which adapt over time)
+        weights = learner.get_current_weights()
+        print(f"Using weights: {dict(zip(SignalPerformanceTracker.WEIGHT_NAMES[:5], weights[:5]))}...")
+        
+        iteration_profit = 0
+        iteration_trades = 0
+        
+        for symbol in symbols:
+            try:
+                final_balance, trades, _ = backtest_strategy(
+                    symbol=symbol,
+                    interval="1h",
+                    candles=300,
+                    window=100,
+                    initial_balance=10000.0,
+                    risk_percentage=1.0,
+                    enable_learning=True,
+                    learner=learner,
+                    weights=weights,
+                )
+                
+                entry_trades = [t for t in trades if t['type'] == 'entry']
+                profit = final_balance - 10000.0
+                
+                iteration_profit += profit
+                iteration_trades += len(entry_trades)
+                
+            except Exception as e:
+                print(f"  {symbol}: Error - {e}")
+        
+        print(f"  Iteration {iteration} results: {iteration_trades} trades, "
+              f"${iteration_profit:.2f} profit")
+        
+        # Get performance after each iteration
+        recent_perf = learner.tracker.get_recent_performance(50)
+        print(f"  Recent win rate: {recent_perf.get('win_rate', 0):.1f}%")
+    
+    # Final report
+    print("\n" + "="*50)
+    print("FINAL LEARNING REPORT")
+    print("="*50)
+    learner.print_status()
+    
+    return learner
+
+
+if __name__ == "__main__":
+    print("\n🔄 Self-Learning Backtesting System Examples")
+    print("=" * 70)
+    print("\nAvailable examples:")
+    print("  1. Basic self-learning backtest")
+    print("  2. Training with multiple backtests")
+    print("  3. Analyze indicator performance")
+    print("  4. Manual weight adjustment")
+    print("  5. Enhanced metrics analysis")
+    print("  6. Continuous learning loop")
+    print("  0. Run all examples")
+    
+    choice = input("\nSelect example (0-6): ").strip()
+    
+    if choice == "1":
+        example_1_basic_self_learning_backtest()
+    elif choice == "2":
+        example_2_multiple_backtests_training()
+    elif choice == "3":
+        example_3_analyze_indicator_performance()
+    elif choice == "4":
+        example_4_manual_weight_adjustment()
+    elif choice == "5":
+        example_5_enhanced_backtest_with_metrics()
+    elif choice == "6":
+        example_6_continuous_learning_loop()
+    elif choice == "0":
+        # Run all examples
+        example_1_basic_self_learning_backtest()
+        example_2_multiple_backtests_training()
+        example_3_analyze_indicator_performance()
+        example_5_enhanced_backtest_with_metrics()
+        example_6_continuous_learning_loop()
+    else:
+        print("Invalid choice. Running example 1...")
+        example_1_basic_self_learning_backtest()
+
diff --git a/back_tester/intensive_training.py b/back_tester/intensive_training.py
new file mode 100755
index 0000000..2d7570e
--- /dev/null
+++ b/back_tester/intensive_training.py
@@ -0,0 +1,660 @@
+#!/usr/bin/env python3
+"""
+INTENSIVE PARAMETER OPTIMIZATION
+
+This script performs aggressive optimization of ALL trading parameters:
+
+1. Signal Weights (18 weights for different indicators)
+2. Stop Loss Parameters (ATR multiplier, min distance)
+3. Take Profit Levels (TP1, TP2, TP3 R:R ratios)
+4. Trailing Stop Parameters (distance, activation level)
+5. Position Sizing (risk percentage)
+
+Uses evolutionary strategies with elitism to find optimal combinations.
+
+Usage:
+    python3 intensive_training.py --generations 50 --hours 4
+"""
+
+import os
+import sys
+import argparse
+import json
+import numpy as np
+from datetime import datetime, timedelta
+from typing import Dict, List, Tuple, Any, Optional
+from collections import defaultdict
+from dataclasses import dataclass, asdict
+import time
+import random
+import copy
+
+# Add project root to path
+project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+if project_dir not in sys.path:
+    sys.path.append(project_dir)
+
+from back_tester.strategy import backtest_strategy
+
+# Configuration
+SYMBOLS = ["BTCUSDT", "ETHUSDT"]
+INTERVALS = ["5m", "15m", "30m", "1h", "4h"]
+
+WEIGHT_NAMES = [
+    "W_BULLISH_OB", "W_BEARISH_OB", "W_BULLISH_BREAKER", "W_BEARISH_BREAKER",
+    "W_ABOVE_SUPPORT", "W_BELOW_RESISTANCE", "W_FVG_ABOVE", "W_FVG_BELOW",
+    "W_TREND", "W_SWEEP_HIGHS", "W_SWEEP_LOWS", "W_STRUCTURE_BREAK",
+    "W_PIN_BAR", "W_ENGULFING", "W_LIQUIDITY_POOL_ABOVE", "W_LIQUIDITY_POOL_BELOW",
+    "W_LIQUIDITY_POOL_ROUND", "W_RSI_EXTREME"
+]
+
+# Colors
+class Colors:
+    H = '\033[95m'
+    B = '\033[94m'
+    C = '\033[96m'
+    G = '\033[92m'
+    Y = '\033[93m'
+    R = '\033[91m'
+    E = '\033[0m'
+    BOLD = '\033[1m'
+
+
+@dataclass
+class TradingParameters:
+    """All optimizable trading parameters"""
+    
+    # Signal weights (18)
+    weights: List[float]
+    
+    # Stop Loss Parameters
+    atr_multiplier: float = 2.0        # ATR multiplier for stop loss distance
+    min_sl_percent: float = 0.5        # Minimum SL distance as % of entry
+    
+    # Take Profit R:R Ratios
+    tp1_ratio: float = 1.5             # Risk:Reward for TP1
+    tp2_ratio: float = 2.5             # Risk:Reward for TP2
+    tp3_ratio: float = 4.0             # Risk:Reward for TP3
+    
+    # Trailing Stop Parameters  
+    trailing_stop_distance: float = 0.5    # Trailing stop distance %
+    trailing_activation_tp: int = 1        # Activate trailing at TP1(1), TP2(2), or TP3(3)
+    
+    # Position Sizing
+    risk_percentage: float = 1.0       # Risk % per trade
+    
+    @classmethod
+    def default(cls) -> 'TradingParameters':
+        """Create with default values"""
+        return cls(
+            weights=[
+                1.2, 1.2, 1.0, 1.0,  # Order blocks, breakers
+                0.8, 0.8, 0.6, 0.6,  # Support/resistance, FVG
+                1.0, 1.3, 1.3, 1.5,  # Trend, sweeps, structure
+                0.7, 0.7, 1.0, 1.0,  # Patterns, liquidity
+                1.2, 0.5             # Round numbers, RSI
+            ]
+        )
+    
+    @classmethod
+    def random(cls) -> 'TradingParameters':
+        """Create with random values for exploration"""
+        return cls(
+            weights=[random.uniform(0.3, 2.0) for _ in range(18)],
+            atr_multiplier=random.uniform(1.0, 4.0),
+            min_sl_percent=random.uniform(0.3, 1.5),
+            tp1_ratio=random.uniform(1.0, 2.5),
+            tp2_ratio=random.uniform(2.0, 4.0),
+            tp3_ratio=random.uniform(3.0, 6.0),
+            trailing_stop_distance=random.uniform(0.3, 1.5),
+            trailing_activation_tp=random.choice([1, 2]),
+            risk_percentage=random.uniform(0.5, 2.0)
+        )
+    
+    def mutate(self, mutation_rate: float = 0.3, mutation_strength: float = 0.15) -> 'TradingParameters':
+        """Create mutated copy of parameters"""
+        new_params = copy.deepcopy(self)
+        
+        # Mutate weights
+        for i in range(len(new_params.weights)):
+            if random.random() < mutation_rate:
+                change = np.random.normal(0, mutation_strength)
+                new_params.weights[i] = max(0.1, min(3.0, new_params.weights[i] + change))
+        
+        # Mutate SL parameters
+        if random.random() < mutation_rate:
+            new_params.atr_multiplier = max(0.5, min(5.0, 
+                new_params.atr_multiplier + np.random.normal(0, 0.3)))
+        
+        if random.random() < mutation_rate:
+            new_params.min_sl_percent = max(0.2, min(2.0,
+                new_params.min_sl_percent + np.random.normal(0, 0.2)))
+        
+        # Mutate TP ratios (keep ordering: TP1 < TP2 < TP3)
+        if random.random() < mutation_rate:
+            new_params.tp1_ratio = max(0.8, min(3.0,
+                new_params.tp1_ratio + np.random.normal(0, 0.3)))
+        
+        if random.random() < mutation_rate:
+            new_params.tp2_ratio = max(new_params.tp1_ratio + 0.5, min(5.0,
+                new_params.tp2_ratio + np.random.normal(0, 0.4)))
+        
+        if random.random() < mutation_rate:
+            new_params.tp3_ratio = max(new_params.tp2_ratio + 0.5, min(8.0,
+                new_params.tp3_ratio + np.random.normal(0, 0.5)))
+        
+        # Mutate trailing stop
+        if random.random() < mutation_rate:
+            new_params.trailing_stop_distance = max(0.2, min(2.0,
+                new_params.trailing_stop_distance + np.random.normal(0, 0.2)))
+        
+        if random.random() < mutation_rate * 0.5:  # Less frequent
+            new_params.trailing_activation_tp = random.choice([1, 2])
+        
+        # Mutate risk
+        if random.random() < mutation_rate:
+            new_params.risk_percentage = max(0.25, min(3.0,
+                new_params.risk_percentage + np.random.normal(0, 0.2)))
+        
+        return new_params
+    
+    @staticmethod
+    def crossover(parent1: 'TradingParameters', parent2: 'TradingParameters') -> 'TradingParameters':
+        """Create child from two parents"""
+        child_weights = []
+        for i in range(len(parent1.weights)):
+            if random.random() < 0.5:
+                child_weights.append(parent1.weights[i])
+            else:
+                child_weights.append(parent2.weights[i])
+        
+        # Randomly inherit other parameters
+        return TradingParameters(
+            weights=child_weights,
+            atr_multiplier=random.choice([parent1.atr_multiplier, parent2.atr_multiplier]),
+            min_sl_percent=random.choice([parent1.min_sl_percent, parent2.min_sl_percent]),
+            tp1_ratio=random.choice([parent1.tp1_ratio, parent2.tp1_ratio]),
+            tp2_ratio=random.choice([parent1.tp2_ratio, parent2.tp2_ratio]),
+            tp3_ratio=random.choice([parent1.tp3_ratio, parent2.tp3_ratio]),
+            trailing_stop_distance=random.choice([parent1.trailing_stop_distance, parent2.trailing_stop_distance]),
+            trailing_activation_tp=random.choice([parent1.trailing_activation_tp, parent2.trailing_activation_tp]),
+            risk_percentage=random.choice([parent1.risk_percentage, parent2.risk_percentage]),
+        )
+    
+    def to_dict(self) -> Dict:
+        """Convert to dictionary for saving"""
+        return {
+            'weights': self.weights,
+            'weight_names': WEIGHT_NAMES,
+            'atr_multiplier': self.atr_multiplier,
+            'min_sl_percent': self.min_sl_percent,
+            'tp1_ratio': self.tp1_ratio,
+            'tp2_ratio': self.tp2_ratio,
+            'tp3_ratio': self.tp3_ratio,
+            'trailing_stop_distance': self.trailing_stop_distance,
+            'trailing_activation_tp': self.trailing_activation_tp,
+            'risk_percentage': self.risk_percentage,
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'TradingParameters':
+        """Load from dictionary"""
+        return cls(
+            weights=data.get('weights', cls.default().weights),
+            atr_multiplier=data.get('atr_multiplier', 2.0),
+            min_sl_percent=data.get('min_sl_percent', 0.5),
+            tp1_ratio=data.get('tp1_ratio', 1.5),
+            tp2_ratio=data.get('tp2_ratio', 2.5),
+            tp3_ratio=data.get('tp3_ratio', 4.0),
+            trailing_stop_distance=data.get('trailing_stop_distance', 0.5),
+            trailing_activation_tp=data.get('trailing_activation_tp', 1),
+            risk_percentage=data.get('risk_percentage', 1.0),
+        )
+
+
+class IntensiveParameterOptimizer:
+    """
+    Comprehensive parameter optimizer using evolutionary strategies.
+    Optimizes weights AND risk management parameters together.
+    """
+    
+    def __init__(
+        self,
+        storage_path: str = "./data/intensive_training",
+        initial_balance: float = 10000.0,
+        population_size: int = 8,
+        elite_count: int = 2,
+        tests_per_evaluation: int = 10,
+    ):
+        self.storage_path = storage_path
+        self.initial_balance = initial_balance
+        self.population_size = population_size
+        self.elite_count = elite_count
+        self.tests_per_evaluation = tests_per_evaluation
+        
+        os.makedirs(storage_path, exist_ok=True)
+        os.makedirs(os.path.join(storage_path, "checkpoints"), exist_ok=True)
+        
+        # Load or initialize parameters
+        self.best_params = self._load_params()
+        self.best_fitness = float('-inf')
+        
+        # Tracking
+        self.generation = 0
+        self.total_backtests = 0
+        self.total_trades = 0
+        self.start_time = None
+        
+        # History
+        self.fitness_history = []
+        self.param_history = []
+    
+    def _load_params(self) -> TradingParameters:
+        """Load parameters from file or use defaults"""
+        params_file = os.path.join(self.storage_path, "best_params.json")
+        
+        if os.path.exists(params_file):
+            try:
+                with open(params_file, 'r') as f:
+                    data = json.load(f)
+                    params = TradingParameters.from_dict(data)
+                    print(f"{Colors.G}✓ Loaded existing parameters from checkpoint{Colors.E}")
+                    return params
+            except Exception as e:
+                print(f"{Colors.Y}Warning: Could not load params: {e}{Colors.E}")
+        
+        return TradingParameters.default()
+    
+    def _save_params(self, params: TradingParameters, fitness: float, is_best: bool = False):
+        """Save parameters to file"""
+        data = params.to_dict()
+        data['fitness'] = fitness
+        data['generation'] = self.generation
+        data['total_backtests'] = self.total_backtests
+        data['timestamp'] = datetime.now().isoformat()
+        
+        filename = "best_params.json" if is_best else f"params_gen_{self.generation}.json"
+        filepath = os.path.join(self.storage_path, filename)
+        
+        with open(filepath, 'w') as f:
+            json.dump(data, f, indent=2)
+        
+        if is_best:
+            checkpoint_file = os.path.join(
+                self.storage_path, "checkpoints",
+                f"best_gen_{self.generation}_fit_{fitness:.1f}.json"
+            )
+            with open(checkpoint_file, 'w') as f:
+                json.dump(data, f, indent=2)
+    
+    def evaluate_params(self, params: TradingParameters) -> Tuple[float, Dict[str, Any]]:
+        """
+        Evaluate a parameter set by running multiple backtests.
+        """
+        total_profit = 0.0
+        total_trades = 0
+        wins = 0
+        losses = 0
+        tp1_hits = 0
+        tp2_hits = 0
+        tp3_hits = 0
+        sl_hits = 0
+        results = []
+        
+        # Generate test configurations
+        test_configs = []
+        for _ in range(self.tests_per_evaluation):
+            symbol = random.choice(SYMBOLS)
+            interval = random.choice(INTERVALS)
+            candles = random.randint(300, 600)
+            test_configs.append((symbol, interval, candles))
+        
+        for symbol, interval, candles in test_configs:
+            try:
+                window = int(candles * 0.5)
+                
+                # Run backtest with these parameters
+                # Note: We need to pass custom TP/SL params through the signal generation
+                # For now, we use the weights and trailing stop params that strategy.py accepts
+                final_balance, trades, _ = backtest_strategy(
+                    symbol=symbol,
+                    interval=interval,
+                    candles=candles,
+                    window=window,
+                    initial_balance=self.initial_balance,
+                    risk_percentage=params.risk_percentage,
+                    weights=params.weights,
+                    use_trailing_stop=True,
+                    trailing_stop_distance_percent=params.trailing_stop_distance,
+                )
+                
+                profit = final_balance - self.initial_balance
+                
+                # Analyze trades
+                for trade in trades:
+                    trade_type = trade.get('type', '')
+                    if trade_type == 'entry':
+                        total_trades += 1
+                    elif trade_type == 'take_profit_1':
+                        tp1_hits += 1
+                        if trade.get('profit', 0) > 0:
+                            wins += 1
+                    elif trade_type == 'take_profit_2':
+                        tp2_hits += 1
+                        if trade.get('profit', 0) > 0:
+                            wins += 1
+                    elif trade_type == 'take_profit_3':
+                        tp3_hits += 1
+                        if trade.get('profit', 0) > 0:
+                            wins += 1
+                    elif trade_type == 'stop_loss':
+                        sl_hits += 1
+                        losses += 1
+                    elif trade_type == 'exit_end_of_period':
+                        if trade.get('profit', 0) > 0:
+                            wins += 1
+                        else:
+                            losses += 1
+                
+                total_profit += profit
+                self.total_backtests += 1
+                
+                results.append({
+                    'symbol': symbol,
+                    'interval': interval,
+                    'profit': profit,
+                    'trades': len([t for t in trades if t.get('type') == 'entry'])
+                })
+                
+            except Exception as e:
+                total_profit -= 50  # Penalty for errors
+                results.append({'error': str(e)})
+        
+        self.total_trades += total_trades
+        
+        # Calculate fitness
+        if total_trades == 0:
+            return -1000, {'error': 'No trades'}
+        
+        total_exits = wins + losses
+        win_rate = wins / total_exits if total_exits > 0 else 0
+        avg_profit = total_profit / self.tests_per_evaluation
+        
+        # TP distribution score (prefer hitting higher TPs)
+        total_tp_hits = tp1_hits + tp2_hits + tp3_hits
+        if total_tp_hits > 0:
+            tp_quality = (tp1_hits * 1 + tp2_hits * 2 + tp3_hits * 3) / (total_tp_hits * 3)
+        else:
+            tp_quality = 0
+        
+        # Calculate risk-adjusted return
+        if sl_hits > 0:
+            reward_risk = (tp1_hits + tp2_hits * 1.5 + tp3_hits * 2) / sl_hits
+        else:
+            reward_risk = 2.0  # Default if no SL hits
+        
+        # Composite fitness function
+        fitness = (
+            avg_profit * 0.30 +                     # Profitability
+            win_rate * 100 * 0.25 +                 # Win rate (scaled to ~50)
+            tp_quality * 50 * 0.15 +                # TP quality (scaled to ~50)
+            min(reward_risk, 3) * 15 * 0.15 +       # Risk/reward (capped, scaled)
+            min(total_trades / 5, 20) * 0.15        # Trade frequency (capped)
+        )
+        
+        metrics = {
+            'total_profit': total_profit,
+            'avg_profit': avg_profit,
+            'total_trades': total_trades,
+            'wins': wins,
+            'losses': losses,
+            'win_rate': win_rate * 100,
+            'tp1_hits': tp1_hits,
+            'tp2_hits': tp2_hits,
+            'tp3_hits': tp3_hits,
+            'sl_hits': sl_hits,
+            'tp_quality': tp_quality,
+            'reward_risk': reward_risk,
+        }
+        
+        return fitness, metrics
+    
+    def train_generation(self) -> Tuple[TradingParameters, float]:
+        """Run one generation of evolutionary optimization"""
+        self.generation += 1
+        
+        print(f"\n{Colors.H}{'='*70}{Colors.E}")
+        print(f"{Colors.H} GENERATION {self.generation}{Colors.E}")
+        print(f"{Colors.H}{'='*70}{Colors.E}")
+        
+        # Create population
+        population = []
+        
+        # Keep elite (best from previous generation)
+        population.append(self.best_params)
+        
+        # Mutations of best
+        for _ in range(self.population_size - 3):
+            mutated = self.best_params.mutate(mutation_rate=0.4, mutation_strength=0.2)
+            population.append(mutated)
+        
+        # One random for exploration
+        population.append(TradingParameters.random())
+        
+        # One with aggressive settings
+        aggressive = TradingParameters(
+            weights=[w * random.uniform(0.8, 1.2) for w in self.best_params.weights],
+            atr_multiplier=1.5,  # Tighter SL
+            tp1_ratio=1.2,       # Quick TP1
+            tp2_ratio=2.0,
+            tp3_ratio=3.5,
+            trailing_stop_distance=0.4,
+            trailing_activation_tp=1,
+            risk_percentage=1.5,
+        )
+        population.append(aggressive)
+        
+        # Evaluate all
+        results = []
+        for i, params in enumerate(population):
+            label = "ELITE" if i == 0 else f"#{i+1}"
+            print(f"\n  Testing {label}... ", end="", flush=True)
+            
+            fitness, metrics = self.evaluate_params(params)
+            results.append((fitness, params, metrics))
+            
+            color = Colors.G if fitness > self.best_fitness else (Colors.Y if fitness > self.best_fitness - 20 else C.R)
+            print(f"{color}Fitness: {fitness:.1f} | "
+                  f"Profit: ${metrics.get('avg_profit', 0):.2f} | "
+                  f"WR: {metrics.get('win_rate', 0):.1f}% | "
+                  f"TP1:{metrics.get('tp1_hits',0)} TP2:{metrics.get('tp2_hits',0)} TP3:{metrics.get('tp3_hits',0)} SL:{metrics.get('sl_hits',0)}{Colors.E}")
+        
+        # Sort by fitness
+        results.sort(key=lambda x: x[0], reverse=True)
+        
+        # Get generation best
+        gen_best_fitness, gen_best_params, gen_best_metrics = results[0]
+        
+        # Track history
+        self.fitness_history.append(gen_best_fitness)
+        
+        # Update global best
+        if gen_best_fitness > self.best_fitness:
+            improvement = gen_best_fitness - self.best_fitness
+            self.best_fitness = gen_best_fitness
+            self.best_params = copy.deepcopy(gen_best_params)
+            
+            print(f"\n{Colors.G}{'★'*3} NEW BEST! Fitness: {gen_best_fitness:.1f} (+{improvement:.1f}) {'★'*3}{Colors.E}")
+            
+            # Show key parameters
+            print(f"\n{Colors.C}Key Parameters:{Colors.E}")
+            print(f"  ATR Multiplier: {gen_best_params.atr_multiplier:.2f}")
+            print(f"  TP Ratios: {gen_best_params.tp1_ratio:.1f} / {gen_best_params.tp2_ratio:.1f} / {gen_best_params.tp3_ratio:.1f}")
+            print(f"  Trailing Stop: {gen_best_params.trailing_stop_distance:.2f}% (activate at TP{gen_best_params.trailing_activation_tp})")
+            print(f"  Risk per Trade: {gen_best_params.risk_percentage:.2f}%")
+            
+            self._save_params(gen_best_params, gen_best_fitness, is_best=True)
+        else:
+            # Crossover top performers for next generation
+            if len(results) >= 2:
+                child = TradingParameters.crossover(results[0][1], results[1][1])
+                self.best_params = child.mutate(mutation_rate=0.2)
+        
+        return gen_best_params, gen_best_fitness
+    
+    def run(
+        self,
+        max_generations: int = 100,
+        max_hours: float = 4.0,
+        target_fitness: float = None
+    ) -> Tuple[TradingParameters, float]:
+        """Run full optimization"""
+        self.start_time = datetime.now()
+        end_time = self.start_time + timedelta(hours=max_hours)
+        
+        print(f"\n{Colors.H}{'='*70}{Colors.E}")
+        print(f"{Colors.H}{'INTENSIVE PARAMETER OPTIMIZATION':^70}{Colors.E}")
+        print(f"{Colors.H}{'='*70}{Colors.E}")
+        
+        print(f"\n{Colors.C}Configuration:{Colors.E}")
+        print(f"  Max Generations: {max_generations}")
+        print(f"  Max Time: {max_hours} hours")
+        print(f"  Population Size: {self.population_size}")
+        print(f"  Tests per Evaluation: {self.tests_per_evaluation}")
+        print(f"  Symbols: {SYMBOLS}")
+        print(f"  Intervals: {INTERVALS}")
+        
+        print(f"\n{Colors.C}Optimizing:{Colors.E}")
+        print(f"  • 18 Signal Weights")
+        print(f"  • Stop Loss (ATR multiplier, min distance)")
+        print(f"  • Take Profit Levels (TP1, TP2, TP3 R:R ratios)")
+        print(f"  • Trailing Stop (distance, activation)")
+        print(f"  • Risk Percentage")
+        
+        print(f"\n{Colors.Y}Starting optimization... (Ctrl+C to stop and save){Colors.E}")
+        
+        try:
+            for gen in range(max_generations):
+                if datetime.now() >= end_time:
+                    print(f"\n{Colors.Y}Time limit reached{Colors.E}")
+                    break
+                
+                best_params, best_fitness = self.train_generation()
+                
+                if target_fitness and best_fitness >= target_fitness:
+                    print(f"\n{Colors.G}Target fitness reached!{Colors.E}")
+                    break
+                
+                # Progress every 5 gens
+                if self.generation % 5 == 0:
+                    elapsed = (datetime.now() - self.start_time).total_seconds() / 60
+                    print(f"\n{Colors.B}═══ Progress: Gen {self.generation} | "
+                          f"Best: {self.best_fitness:.1f} | "
+                          f"Backtests: {self.total_backtests} | "
+                          f"Time: {elapsed:.1f}m ═══{Colors.E}")
+        
+        except KeyboardInterrupt:
+            print(f"\n{Colors.Y}Optimization interrupted{Colors.E}")
+        
+        self._print_final_report()
+        return self.best_params, self.best_fitness
+    
+    def _print_final_report(self):
+        """Print comprehensive final report"""
+        elapsed = (datetime.now() - self.start_time).total_seconds()
+        
+        print(f"\n{Colors.H}{'='*70}{Colors.E}")
+        print(f"{Colors.H}{'OPTIMIZATION COMPLETE':^70}{Colors.E}")
+        print(f"{Colors.H}{'='*70}{Colors.E}")
+        
+        print(f"\n{Colors.BOLD}Statistics:{Colors.E}")
+        print(f"  Generations: {self.generation}")
+        print(f"  Backtests: {self.total_backtests}")
+        print(f"  Trades: {self.total_trades}")
+        print(f"  Time: {elapsed/60:.1f} minutes")
+        print(f"  Best Fitness: {self.best_fitness:.1f}")
+        
+        p = self.best_params
+        
+        print(f"\n{Colors.BOLD}═══ OPTIMIZED PARAMETERS ═══{Colors.E}")
+        
+        print(f"\n{Colors.C}Stop Loss:{Colors.E}")
+        print(f"  ATR Multiplier: {p.atr_multiplier:.2f}")
+        print(f"  Min SL Distance: {p.min_sl_percent:.2f}%")
+        
+        print(f"\n{Colors.C}Take Profit Levels:{Colors.E}")
+        print(f"  TP1 R:R Ratio: {p.tp1_ratio:.2f}")
+        print(f"  TP2 R:R Ratio: {p.tp2_ratio:.2f}")
+        print(f"  TP3 R:R Ratio: {p.tp3_ratio:.2f}")
+        
+        print(f"\n{Colors.C}Trailing Stop:{Colors.E}")
+        print(f"  Distance: {p.trailing_stop_distance:.2f}%")
+        print(f"  Activation: TP{p.trailing_activation_tp}")
+        
+        print(f"\n{Colors.C}Position Sizing:{Colors.E}")
+        print(f"  Risk per Trade: {p.risk_percentage:.2f}%")
+        
+        print(f"\n{Colors.C}Signal Weights:{Colors.E}")
+        for name, weight in zip(WEIGHT_NAMES, p.weights):
+            bar_len = int(weight * 8)
+            bar = "█" * bar_len + "░" * (16 - bar_len)
+            
+            if weight > 1.5:
+                color, status = Colors.G, "STRONG"
+            elif weight < 0.6:
+                color, status = Colors.R, "WEAK"
+            else:
+                color, status = Colors.E, ""
+            
+            print(f"  {color}{name:<25} {weight:.3f} {bar} {status}{Colors.E}")
+        
+        # Save
+        self._save_params(self.best_params, self.best_fitness, is_best=True)
+        print(f"\n{Colors.G}✓ Parameters saved to: {self.storage_path}/best_params.json{Colors.E}")
+        
+        # Fitness trend
+        if len(self.fitness_history) > 1:
+            print(f"\n{Colors.BOLD}Fitness Trend:{Colors.E}")
+            start = self.fitness_history[0]
+            end = self.fitness_history[-1]
+            change = end - start
+            trend = "📈" if change > 0 else "📉"
+            print(f"  Start: {start:.1f} → End: {end:.1f} ({trend} {change:+.1f})")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Intensive trading parameter optimization")
+    parser.add_argument('--generations', type=int, default=50)
+    parser.add_argument('--hours', type=float, default=2.0)
+    parser.add_argument('--population', type=int, default=8)
+    parser.add_argument('--tests', type=int, default=10, help='Backtests per evaluation')
+    parser.add_argument('--balance', type=float, default=10000.0)
+    parser.add_argument('--storage', type=str, default='./data/intensive_training')
+    parser.add_argument('--target-fitness', type=float, default=None)
+    
+    args = parser.parse_args()
+    
+    optimizer = IntensiveParameterOptimizer(
+        storage_path=args.storage,
+        initial_balance=args.balance,
+        population_size=args.population,
+        tests_per_evaluation=args.tests,
+    )
+    
+    try:
+        best_params, best_fitness = optimizer.run(
+            max_generations=args.generations,
+            max_hours=args.hours,
+            target_fitness=args.target_fitness
+        )
+        print(f"\n{Colors.G}Optimization completed! Best fitness: {best_fitness:.1f}{Colors.E}")
+        
+    except Exception as e:
+        print(f"\n{Colors.R}Optimization failed: {e}{Colors.E}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/back_tester/realtime_test.py b/back_tester/realtime_test.py
new file mode 100644
index 0000000..bd27b99
--- /dev/null
+++ b/back_tester/realtime_test.py
@@ -0,0 +1,1226 @@
+#!/usr/bin/env python3
+"""
+Real-Time Trading Strategy Tester
+
+This script monitors multiple symbol/interval combinations in real-time,
+generates signals using the optimized weights from backtesting, and tracks
+open positions with stop-loss and take-profit management.
+
+Usage:
+    python realtime_test.py [--paper] [--duration HOURS]
+"""
+
+import os
+import sys
+import json
+import time
+import signal
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass, field
+from threading import Thread, Event
+import uuid
+
+# Add project root to path
+project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.insert(0, project_dir)
+
+import pandas as pd
+import numpy as np
+
+# Import from the project
+from src.analysis.utils.helpers import fetch_candles
+from src.telegram.signals.detection import (
+    analyze_data,
+    generate_price_prediction_signal_proba,
+    TradingSignal,
+    calculate_position_size,
+)
+from src.core.utils import create_true_preferences
+import requests
+
+# Try to import indicator contribution tracking
+try:
+    from back_tester.adaptive_learning import extract_indicator_contributions
+    INDICATOR_TRACKING_AVAILABLE = True
+except ImportError:
+    INDICATOR_TRACKING_AVAILABLE = False
+    def extract_indicator_contributions(*args, **kwargs):
+        return {}
+
+
+def fetch_current_price(symbol: str) -> float:
+    """Fetch real-time current price from Bybit ticker API"""
+    try:
+        url = f"https://api.bybit.com/v5/market/tickers?category=spot&symbol={symbol}"
+        response = requests.get(url, timeout=5)
+        if response.status_code == 200:
+            data = response.json()
+            if data.get("retCode") == 0:
+                result = data.get("result", {}).get("list", [])
+                if result:
+                    return float(result[0].get("lastPrice", 0))
+    except Exception as e:
+        logger.debug(f"Error fetching ticker for {symbol}: {e}")
+    return 0.0
+
+# Try to import charting libraries
+try:
+    import mplfinance as mpf
+    import matplotlib.pyplot as plt
+    import matplotlib.dates as mdates
+    CHARTING_AVAILABLE = True
+except ImportError:
+    CHARTING_AVAILABLE = False
+    logger.warning("mplfinance not available - trade charts will not be generated")
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s | %(levelname)s | %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S'
+)
+logger = logging.getLogger(__name__)
+
+# Suppress noisy loggers
+logging.getLogger('urllib3').setLevel(logging.WARNING)
+logging.getLogger('requests').setLevel(logging.WARNING)
+
+
+@dataclass
+class OpenPosition:
+    """Represents an open trading position"""
+    position_id: str
+    symbol: str
+    interval: str
+    entry_price: float
+    entry_time: datetime
+    position_size: float
+    stop_loss: float
+    initial_stop_loss: float
+    take_profit_1: float
+    take_profit_2: float
+    take_profit_3: float
+    highest_price: float
+    trailing_stop_active: bool = False
+    trailing_stop_level: float = 0.0
+    tp1_hit: bool = False
+    tp2_hit: bool = False
+    tp3_hit: bool = False
+    initial_position: float = 0.0
+    risk_reward_ratio: float = 2.0
+    signal_reason: str = ""
+    current_price: float = 0.0
+    unrealized_pnl: float = 0.0
+    confidence: float = 0.0  # Signal confidence level (0.0 - 1.0)
+    indicator_contributions: Dict[str, float] = field(default_factory=dict)  # Which indicators triggered signal
+
+
+@dataclass
+class TradeResult:
+    """Represents a completed trade"""
+    position_id: str
+    symbol: str
+    interval: str
+    entry_price: float
+    exit_price: float
+    entry_time: datetime
+    exit_time: datetime
+    profit_loss: float
+    profit_percent: float
+    exit_type: str  # stop_loss, trailing_stop, tp1, tp2, tp3
+    duration_minutes: float
+    chart_path: str = ""  # Path to the trade chart image
+    entry_index: int = 0
+    exit_index: int = 0
+    confidence: float = 0.0  # Signal confidence level at entry
+    indicator_contributions: Dict[str, float] = field(default_factory=dict)  # Which indicators triggered signal
+
+
+@dataclass
+class CombinationStats:
+    """Statistics for a symbol/interval combination"""
+    symbol: str
+    interval: str
+    trades: int = 0
+    wins: int = 0
+    losses: int = 0
+    total_profit: float = 0.0
+    signals_generated: int = 0
+    last_signal_time: Optional[datetime] = None
+
+
+class RealTimeTrader:
+    """Real-time trading strategy tester"""
+    
+    # Trading combinations to monitor (based on production recommendations)
+    COMBINATIONS = [
+        # Safe options (0% fail rate in backtesting)
+        {"symbol": "BTCUSDT", "interval": "1h", "priority": "SAFE"},
+        {"symbol": "ETHUSDT", "interval": "5m", "priority": "SAFE"},
+        {"symbol": "ETHUSDT", "interval": "15m", "priority": "SAFE"},
+        # Higher risk/reward options
+        {"symbol": "BTCUSDT", "interval": "4h", "priority": "AGGRESSIVE"},
+        {"symbol": "ETHUSDT", "interval": "4h", "priority": "AGGRESSIVE"},
+        # Additional intervals for completeness
+        {"symbol": "BTCUSDT", "interval": "5m", "priority": "EXTRA"},
+        {"symbol": "BTCUSDT", "interval": "15m", "priority": "EXTRA"},
+        {"symbol": "ETHUSDT", "interval": "1h", "priority": "EXTRA"},
+    ]
+    
+    # Interval to seconds mapping
+    INTERVAL_SECONDS = {
+        "1m": 60,
+        "5m": 300,
+        "15m": 900,
+        "30m": 1800,
+        "1h": 3600,
+        "4h": 14400,
+        "1d": 86400,
+    }
+    
+    # Maximum percentage of balance to use per trade (prevents all-in trades)
+    MAX_POSITION_PERCENT = 20.0  # Max 20% of balance per trade
+    
+    def __init__(
+        self,
+        initial_balance: float = 10000.0,
+        risk_percentage: float = 1.0,
+        use_trailing_stop: bool = True,
+        trailing_stop_distance: float = 0.5,
+        weights_file: str = None,
+        safe_only: bool = False,
+        max_position_percent: float = 20.0,  # Max % of balance per trade
+        candle_window: int = 500,  # Number of candles for analysis
+        disable_worst_patterns: bool = False,
+        worst_pattern_threshold: float = -100.0,
+    ):
+        self.initial_balance = initial_balance
+        self.balance = initial_balance
+        self.risk_percentage = risk_percentage
+        self.use_trailing_stop = use_trailing_stop
+        self.trailing_stop_distance = trailing_stop_distance
+        self.safe_only = safe_only
+        self.max_position_percent = max_position_percent
+        self.candle_window = candle_window
+        self.disable_worst_patterns = disable_worst_patterns
+        self.worst_pattern_threshold = worst_pattern_threshold
+        
+        # Load optimized weights
+        self.weights = self._load_weights(weights_file)
+        
+        # Load disabled patterns if enabled
+        self.disabled_patterns = set()
+        if disable_worst_patterns:
+            self._load_disabled_patterns(weights_file)
+        
+        # Trading state
+        self.open_positions: Dict[str, OpenPosition] = {}  # key = position_id
+        self.completed_trades: List[TradeResult] = []
+        self.combination_stats: Dict[str, CombinationStats] = {}
+        
+        # Initialize stats for each combination
+        for combo in self.COMBINATIONS:
+            if safe_only and combo["priority"] != "SAFE":
+                continue
+            key = f"{combo['symbol']}_{combo['interval']}"
+            self.combination_stats[key] = CombinationStats(
+                symbol=combo['symbol'],
+                interval=combo['interval']
+            )
+        
+        # Control flags
+        self.running = False
+        self.stop_event = Event()
+        
+        # Preferences for signal generation
+        self.preferences = create_true_preferences()
+        
+        # Track last data fetch time per combination
+        self.last_fetch: Dict[str, datetime] = {}
+        
+        # Start time
+        self.start_time = None
+        
+        # Track invested amount
+        self.invested_amount = 0.0
+        
+        # Track indicator performance
+        self.indicator_stats: Dict[str, Dict[str, Any]] = {}
+        # Initialize stats for each indicator
+        for indicator in [
+            "W_BULLISH_OB", "W_BEARISH_OB", "W_BULLISH_BREAKER", "W_BEARISH_BREAKER",
+            "W_ABOVE_SUPPORT", "W_BELOW_RESISTANCE", "W_FVG_ABOVE", "W_FVG_BELOW",
+            "W_TREND", "W_SWEEP_HIGHS", "W_SWEEP_LOWS", "W_STRUCTURE_BREAK",
+            "W_PIN_BAR", "W_ENGULFING", "W_LIQUIDITY_POOL_ABOVE", "W_LIQUIDITY_POOL_BELOW",
+            "W_LIQUIDITY_POOL_ROUND", "W_RSI_EXTREME"
+        ]:
+            self.indicator_stats[indicator] = {
+                "signals": 0,
+                "wins": 0,
+                "losses": 0,
+                "total_profit": 0.0,
+                "win_rate": 0.0
+            }
+    
+    def get_total_equity(self) -> float:
+        """Calculate total account equity (available + invested)"""
+        return self.balance + self.invested_amount
+    
+    def get_unrealized_pnl(self, current_prices: Dict[str, float] = None) -> float:
+        """Calculate unrealized P/L from open positions"""
+        if not current_prices:
+            return 0.0
+        unrealized = 0.0
+        for pos in self.open_positions.values():
+            current = current_prices.get(pos.symbol, pos.entry_price)
+            unrealized += pos.position_size * (current - pos.entry_price)
+        return unrealized
+    
+    def _generate_trade_chart(self, trade: TradeResult, df: pd.DataFrame) -> str:
+        """Generate a chart image for a completed trade"""
+        if not CHARTING_AVAILABLE:
+            return ""
+        
+        try:
+            # Create charts directory
+            charts_dir = os.path.join(os.path.dirname(__file__), "data", "trade_charts")
+            os.makedirs(charts_dir, exist_ok=True)
+            
+            # Generate filename
+            timestamp = trade.exit_time.strftime("%Y%m%d_%H%M%S")
+            result = "WIN" if trade.profit_loss > 0 else "LOSS"
+            filename = f"{trade.symbol}_{trade.interval}_{timestamp}_{result}.png"
+            filepath = os.path.join(charts_dir, filename)
+            
+            # Prepare data for mplfinance
+            # Make sure df has the right index and columns
+            plot_df = df.copy()
+            if not isinstance(plot_df.index, pd.DatetimeIndex):
+                plot_df.index = pd.to_datetime(plot_df.index)
+            
+            # Calculate RSI for the chart
+            delta = plot_df['Close'].diff()
+            gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
+            loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
+            rs = gain / loss.replace(0, 1e-10)
+            rsi = 100 - (100 / (1 + rs))
+            rsi = rsi.fillna(50)
+            
+            # Create entry/exit markers
+            entry_idx = None
+            exit_idx = None
+            
+            # Find closest indices to entry and exit times
+            for i, idx in enumerate(plot_df.index):
+                if entry_idx is None and idx >= trade.entry_time:
+                    entry_idx = i
+                if exit_idx is None and idx >= trade.exit_time:
+                    exit_idx = i
+                    break
+            
+            if entry_idx is None:
+                entry_idx = 0
+            if exit_idx is None:
+                exit_idx = len(plot_df) - 1
+            
+            # Create markers for entry and exit
+            entry_marker = [np.nan] * len(plot_df)
+            exit_marker = [np.nan] * len(plot_df)
+            entry_marker[entry_idx] = plot_df['Low'].iloc[entry_idx] * 0.998
+            exit_marker[exit_idx] = plot_df['High'].iloc[exit_idx] * 1.002
+            
+            # Create horizontal lines for SL and TP levels
+            sl_line = [trade.entry_price * (1 - 0.01)] * len(plot_df)  # Approximate SL
+            tp_line = [trade.entry_price * (1 + 0.02)] * len(plot_df)  # Approximate TP
+            
+            # Add plots
+            add_plots = [
+                mpf.make_addplot(entry_marker, type='scatter', markersize=200, marker='^', color='green'),
+                mpf.make_addplot(exit_marker, type='scatter', markersize=200, marker='v', 
+                               color='green' if trade.profit_loss > 0 else 'red'),
+                mpf.make_addplot(rsi, panel=1, color='purple', ylabel='RSI'),
+                mpf.make_addplot([30] * len(plot_df), panel=1, color='gray', linestyle='--'),
+                mpf.make_addplot([70] * len(plot_df), panel=1, color='gray', linestyle='--'),
+            ]
+            
+            # Style
+            mc = mpf.make_marketcolors(
+                up='#26a69a', down='#ef5350',
+                edge='inherit',
+                wick='inherit',
+                volume='in'
+            )
+            style = mpf.make_mpf_style(
+                marketcolors=mc,
+                gridstyle=':',
+                gridcolor='gray',
+                facecolor='#1e1e1e',
+                figcolor='#1e1e1e',
+                edgecolor='#333333'
+            )
+            
+            # Create the chart
+            fig, axes = mpf.plot(
+                plot_df,
+                type='candle',
+                style=style,
+                addplot=add_plots,
+                volume=True,
+                volume_panel=2,
+                title=f"\n{trade.symbol} {trade.interval} - {result}: ${trade.profit_loss:+,.2f} ({trade.profit_percent:+.2f}%)",
+                figsize=(14, 10),
+                panel_ratios=(3, 1, 1),
+                returnfig=True
+            )
+            
+            # Add annotations
+            axes[0].axhline(y=trade.entry_price, color='blue', linestyle='--', alpha=0.7, label='Entry')
+            axes[0].axhline(y=trade.exit_price, color='green' if trade.profit_loss > 0 else 'red', 
+                          linestyle='--', alpha=0.7, label='Exit')
+            
+            # Add text annotations
+            axes[0].text(0.02, 0.98, f"Entry: ${trade.entry_price:,.2f}", transform=axes[0].transAxes,
+                        fontsize=10, color='blue', verticalalignment='top')
+            axes[0].text(0.02, 0.94, f"Exit: ${trade.exit_price:,.2f}", transform=axes[0].transAxes,
+                        fontsize=10, color='green' if trade.profit_loss > 0 else 'red', verticalalignment='top')
+            axes[0].text(0.02, 0.90, f"Duration: {trade.duration_minutes:.1f} min", transform=axes[0].transAxes,
+                        fontsize=10, color='white', verticalalignment='top')
+            axes[0].text(0.02, 0.86, f"Exit Type: {trade.exit_type}", transform=axes[0].transAxes,
+                        fontsize=10, color='white', verticalalignment='top')
+            
+            # Save the figure
+            fig.savefig(filepath, dpi=100, bbox_inches='tight', facecolor='#1e1e1e')
+            plt.close(fig)
+            
+            logger.info(f"📊 Trade chart saved: {filepath}")
+            return filepath
+            
+        except Exception as e:
+            logger.error(f"Error generating trade chart: {e}")
+            return ""
+    
+    # Store candle data for chart generation
+    candle_cache: Dict[str, pd.DataFrame] = {}
+        
+    def _load_weights(self, weights_file: str = None) -> list:
+        """Load optimized weights from file"""
+        if weights_file is None:
+            weights_file = os.path.join(
+                os.path.dirname(__file__),
+                "data/btc_eth_learning/final_weights.json"
+            )
+        
+        try:
+            with open(weights_file, 'r') as f:
+                data = json.load(f)
+                weights = data.get('weights', [])
+                logger.info(f"✓ Loaded {len(weights)} optimized weights from {weights_file}")
+                return weights
+        except FileNotFoundError:
+            logger.warning(f"Weights file not found: {weights_file}. Using default weights.")
+            return []
+        except Exception as e:
+            logger.error(f"Error loading weights: {e}")
+            return []
+    
+    def _load_disabled_patterns(self, weights_file: str = None):
+        """Load worst-performing patterns from saved stats and disable them"""
+        if weights_file is None:
+            weights_file = os.path.join(
+                os.path.dirname(__file__),
+                "data/btc_eth_learning/final_weights.json"
+            )
+        
+        try:
+            with open(weights_file, 'r') as f:
+                data = json.load(f)
+                pattern_stats = data.get('pattern_stats', {})
+                
+                # Patterns that are ALWAYS present (not specific signals) should be excluded
+                always_present_patterns = {
+                    'Uptrend', 'Downtrend', 'Market Regime', 'Volume Analysis'
+                }
+                
+                for pattern, stats in pattern_stats.items():
+                    # Skip always-present patterns
+                    if pattern in always_present_patterns:
+                        continue
+                        
+                    total_profit = stats.get('total_profit', 0)
+                    trades = stats.get('detections', 0) or stats.get('trades', 0)
+                    
+                    # Only disable if we have enough data (>5 trades) and pattern is losing
+                    if trades >= 5 and total_profit < self.worst_pattern_threshold:
+                        self.disabled_patterns.add(pattern)
+                
+                if self.disabled_patterns:
+                    logger.warning(f"⚠️  Disabled worst-performing patterns:")
+                    for p in sorted(self.disabled_patterns):
+                        stats = pattern_stats.get(p, {})
+                        logger.warning(f"   ❌ {p}: ${stats.get('total_profit', 0):+.2f}")
+                else:
+                    logger.info(f"✓ No patterns disabled (all above threshold ${self.worst_pattern_threshold})")
+                    
+        except FileNotFoundError:
+            logger.warning(f"Pattern stats not found in {weights_file}")
+        except Exception as e:
+            logger.error(f"Error loading pattern stats: {e}")
+    
+    def _is_pattern_disabled(self, reason: str) -> tuple:
+        """Check if any disabled patterns are present in the signal reason"""
+        if not self.disabled_patterns:
+            return False, []
+        
+        reason_lower = reason.lower() if reason else ""
+        
+        # Pattern keywords mapping
+        pattern_keywords = {
+            "bullish order block": "Bullish Order Block",
+            "bearish order block": "Bearish Order Block", 
+            "bullish breaker block": "Bullish Breaker Block",
+            "bearish breaker block": "Bearish Breaker Block",
+            "breaker block": "Breaker Block",
+            "order block": "Order Block",
+            "fvg below": "FVG Below",
+            "fvg above": "FVG Above",
+            "unfilled fvg": "FVG",
+            "near support": "Support Level",
+            "near resistance": "Resistance Level",
+            "swept through previous highs": "Liquidity Sweep (Highs)",
+            "swept through previous lows": "Liquidity Sweep (Lows)",
+            "broke structure upward": "Structure Break (Bullish)",
+            "broke structure downward": "Structure Break (Bearish)",
+            "broke structure": "Structure Break",
+            "bullish pin bar": "Bullish Pin Bar",
+            "bearish engulfing": "Bearish Engulfing",
+            "pin bar": "Pin Bar",
+            "engulfing": "Engulfing Pattern",
+            "rsi oversold": "RSI Oversold",
+            "rsi overbought": "RSI Overbought",
+            "liquidity pool": "Liquidity Pool",
+        }
+        
+        # Detect patterns in reason
+        detected_patterns = []
+        for keyword, pattern_name in pattern_keywords.items():
+            if keyword in reason_lower and pattern_name not in detected_patterns:
+                detected_patterns.append(pattern_name)
+        
+        # Check if any disabled pattern is present
+        disabled_found = [p for p in detected_patterns if p in self.disabled_patterns]
+        
+        # Only block if majority of detected patterns are disabled
+        if disabled_found and len(disabled_found) >= len(detected_patterns) / 2:
+            return True, disabled_found
+        
+        return False, disabled_found
+    
+    def _get_candle_window(self, symbol: str, interval: str, window: int = None) -> Optional[pd.DataFrame]:
+        """Fetch the latest candles for analysis"""
+        if window is None:
+            window = self.candle_window
+        try:
+            df = fetch_candles(symbol, window, interval)
+            if df is None or df.empty:
+                return None
+            df.sort_index(inplace=True)
+            return df
+        except Exception as e:
+            logger.error(f"Error fetching candles for {symbol} {interval}: {e}")
+            return None
+    
+    def _should_fetch(self, combo_key: str, interval: str) -> bool:
+        """Check if enough time has passed to fetch new data"""
+        if combo_key not in self.last_fetch:
+            return True
+        
+        elapsed = (datetime.now() - self.last_fetch[combo_key]).total_seconds()
+        interval_seconds = self.INTERVAL_SECONDS.get(interval, 60)
+        
+        # Fetch slightly before the candle closes to be ready
+        return elapsed >= (interval_seconds * 0.9)
+    
+    def _check_position_updates(self, position: OpenPosition, current_price: float) -> Optional[TradeResult]:
+        """Check if position needs updating (stop-loss, take-profit, trailing stop)"""
+        now = datetime.now()
+        
+        # Update current price and unrealized P/L
+        position.current_price = current_price
+        position.unrealized_pnl = position.position_size * (current_price - position.entry_price)
+        
+        # Update highest price for trailing stop
+        if current_price > position.highest_price:
+            position.highest_price = current_price
+            
+            # Activate trailing stop at TP1
+            if not position.trailing_stop_active and current_price >= position.take_profit_1:
+                position.trailing_stop_active = True
+                logger.info(f"🔄 [{position.symbol} {position.interval}] Trailing stop ACTIVATED at {current_price:.2f}")
+            
+            # Update trailing stop level
+            if position.trailing_stop_active and self.use_trailing_stop:
+                new_stop = current_price * (1 - self.trailing_stop_distance / 100)
+                if new_stop > position.trailing_stop_level:
+                    old_stop = position.trailing_stop_level
+                    position.trailing_stop_level = new_stop
+                    position.stop_loss = new_stop
+                    logger.info(f"📈 [{position.symbol} {position.interval}] Trailing stop updated: {old_stop:.2f} → {new_stop:.2f}")
+        
+        # Check take profit levels
+        if current_price >= position.take_profit_3 and not position.tp3_hit:
+            # Full target hit - close position
+            profit = position.position_size * (current_price - position.entry_price)
+            duration = (now - position.entry_time).total_seconds() / 60
+            
+            close_value = position.position_size * current_price
+            self.balance += close_value
+            self.invested_amount -= (position.position_size * position.entry_price)
+            
+            logger.info(f"🎯 [{position.symbol} {position.interval}] TP3 HIT at {current_price:.2f} | Profit: ${profit:+.2f}")
+            
+            # Update indicator stats for this trade
+            is_win = profit > 0
+            for indicator in position.indicator_contributions:
+                if indicator in self.indicator_stats:
+                    if is_win:
+                        self.indicator_stats[indicator]["wins"] += 1
+                    else:
+                        self.indicator_stats[indicator]["losses"] += 1
+                    self.indicator_stats[indicator]["total_profit"] += profit
+            
+            return TradeResult(
+                position_id=position.position_id,
+                symbol=position.symbol,
+                interval=position.interval,
+                entry_price=position.entry_price,
+                exit_price=current_price,
+                entry_time=position.entry_time,
+                exit_time=now,
+                profit_loss=profit,
+                profit_percent=(current_price - position.entry_price) / position.entry_price * 100,
+                exit_type="tp3_hit",
+                duration_minutes=duration,
+                confidence=position.confidence,
+                indicator_contributions=position.indicator_contributions
+            )
+        
+        elif current_price >= position.take_profit_2 and not position.tp2_hit:
+            # TP2 hit - close 50% of remaining
+            close_amount = position.position_size / 2
+            profit = close_amount * (current_price - position.entry_price)
+            self.balance += close_amount * current_price
+            position.position_size -= close_amount
+            position.tp2_hit = True
+            
+            logger.info(f"🎯 [{position.symbol} {position.interval}] TP2 HIT at {current_price:.2f} | Partial profit: ${profit:+.2f}")
+        
+        elif current_price >= position.take_profit_1 and not position.tp1_hit:
+            # TP1 hit - close 33% of position
+            close_amount = position.initial_position / 3
+            profit = close_amount * (current_price - position.entry_price)
+            self.balance += close_amount * current_price
+            position.position_size -= close_amount
+            position.tp1_hit = True
+            
+            logger.info(f"🎯 [{position.symbol} {position.interval}] TP1 HIT at {current_price:.2f} | Partial profit: ${profit:+.2f}")
+        
+        # Check stop loss
+        elif current_price <= position.stop_loss:
+            profit = position.position_size * (current_price - position.entry_price)
+            duration = (now - position.entry_time).total_seconds() / 60
+            
+            close_value = position.position_size * current_price
+            self.balance += close_value
+            self.invested_amount -= (position.position_size * position.entry_price)
+            
+            stop_type = "trailing_stop" if position.trailing_stop_active else "stop_loss"
+            emoji = "🛑" if profit < 0 else "✅"
+            
+            logger.info(f"{emoji} [{position.symbol} {position.interval}] {stop_type.upper()} at {current_price:.2f} | P/L: ${profit:+.2f}")
+            
+            # Update indicator stats for this trade
+            is_win = profit > 0
+            for indicator in position.indicator_contributions:
+                if indicator in self.indicator_stats:
+                    if is_win:
+                        self.indicator_stats[indicator]["wins"] += 1
+                    else:
+                        self.indicator_stats[indicator]["losses"] += 1
+                    self.indicator_stats[indicator]["total_profit"] += profit
+            
+            return TradeResult(
+                position_id=position.position_id,
+                symbol=position.symbol,
+                interval=position.interval,
+                entry_price=position.entry_price,
+                exit_price=current_price,
+                entry_time=position.entry_time,
+                exit_time=now,
+                profit_loss=profit,
+                profit_percent=(current_price - position.entry_price) / position.entry_price * 100,
+                exit_type=stop_type,
+                duration_minutes=duration,
+                confidence=position.confidence,
+                indicator_contributions=position.indicator_contributions
+            )
+        
+        return None
+    
+    def _process_combination(self, symbol: str, interval: str):
+        """Process a single symbol/interval combination"""
+        combo_key = f"{symbol}_{interval}"
+        
+        # Check if we should fetch new data
+        if not self._should_fetch(combo_key, interval):
+            return
+        
+        # Fetch candle data
+        df = self._get_candle_window(symbol, interval)
+        if df is None or len(df) < 100:
+            return
+        
+        self.last_fetch[combo_key] = datetime.now()
+        current_price = df["Close"].iloc[-1]
+        
+        # Check existing positions for this combination
+        positions_to_close = []
+        for pos_id, position in self.open_positions.items():
+            if position.symbol == symbol and position.interval == interval:
+                result = self._check_position_updates(position, current_price)
+                if result:
+                    positions_to_close.append((pos_id, result))
+        
+        # Close completed positions
+        for pos_id, result in positions_to_close:
+            del self.open_positions[pos_id]
+            
+            # Generate trade chart
+            if df is not None and len(df) > 0:
+                chart_path = self._generate_trade_chart(result, df)
+                result.chart_path = chart_path
+            
+            self.completed_trades.append(result)
+            
+            # Update stats
+            stats = self.combination_stats[combo_key]
+            stats.trades += 1
+            stats.total_profit += result.profit_loss
+            if result.profit_loss > 0:
+                stats.wins += 1
+            else:
+                stats.losses += 1
+        
+        # Check for new signal (only if no open position for this combo)
+        has_open_position = any(
+            p.symbol == symbol and p.interval == interval 
+            for p in self.open_positions.values()
+        )
+        
+        if not has_open_position:
+            # Generate signal
+            indicators = analyze_data(df, self.preferences, 0.05)
+            signal, prob, confidence, reason, trading_signal = generate_price_prediction_signal_proba(
+                df, indicators, self.weights, self.balance, self.risk_percentage
+            )
+            
+            # Get confidence threshold from weights (index 18) or use default 0.3
+            confidence_threshold = self.weights[18] if len(self.weights) > 18 else 0.3
+            # Clamp to valid range [0.1, 0.9]
+            confidence_threshold = max(0.1, min(0.9, confidence_threshold))
+            
+            if signal == "Bullish" and trading_signal and confidence > confidence_threshold:
+                # Check for disabled patterns
+                if self.disable_worst_patterns and reason:
+                    is_disabled, disabled_list = self._is_pattern_disabled(reason)
+                    if is_disabled:
+                        logger.info(f"⏭️  {symbol} {interval}: Skipped - Disabled pattern(s): {', '.join(disabled_list)}")
+                        return
+                
+                # Calculate position size based on risk
+                position_sizing = calculate_position_size(
+                    self.balance, self.risk_percentage, current_price, trading_signal.stop_loss
+                )
+                
+                position_size = position_sizing["position_size"]
+                amount_to_invest = position_size * current_price
+                
+                # Cap at maximum position percentage of TOTAL balance (not just available)
+                max_position_value = self.initial_balance * (self.max_position_percent / 100)
+                if amount_to_invest > max_position_value:
+                    amount_to_invest = max_position_value
+                    position_size = amount_to_invest / current_price
+                    logger.info(f"⚠️ Position capped at {self.max_position_percent}% of balance (${max_position_value:,.2f})")
+                
+                # Also cap at available balance
+                if amount_to_invest > self.balance:
+                    amount_to_invest = self.balance
+                    position_size = self.balance / current_price
+                
+                if position_size > 0 and amount_to_invest >= 10:  # Minimum $10 trade
+                    self.balance -= amount_to_invest
+                    self.invested_amount += amount_to_invest
+                    
+                    # Extract indicator contributions from the signal
+                    reasons_list = reason.split('\n') if reason else []
+                    indicator_contribs = extract_indicator_contributions(
+                        bullish_score=prob if signal == "Bullish" else 0,
+                        bearish_score=0 if signal == "Bullish" else prob,
+                        signal_type=signal,
+                        reasons=reasons_list
+                    )
+                    
+                    # Update indicator stats for signal generation
+                    for indicator in indicator_contribs:
+                        if indicator in self.indicator_stats:
+                            self.indicator_stats[indicator]["signals"] += 1
+                    
+                    position = OpenPosition(
+                        position_id=str(uuid.uuid4()),
+                        symbol=symbol,
+                        interval=interval,
+                        entry_price=current_price,
+                        entry_time=datetime.now(),
+                        position_size=position_size,
+                        initial_position=position_size,
+                        stop_loss=float(trading_signal.stop_loss),
+                        initial_stop_loss=float(trading_signal.stop_loss),
+                        take_profit_1=float(trading_signal.take_profit_1),
+                        take_profit_2=float(trading_signal.take_profit_2),
+                        take_profit_3=float(trading_signal.take_profit_3),
+                        highest_price=current_price,
+                        trailing_stop_level=float(trading_signal.stop_loss),
+                        risk_reward_ratio=float(trading_signal.risk_reward_ratio),
+                        signal_reason=reason.split('\n')[0] if reason else "",
+                        current_price=current_price,
+                        unrealized_pnl=0.0,
+                        confidence=confidence,
+                        indicator_contributions=indicator_contribs
+                    )
+                    
+                    self.open_positions[position.position_id] = position
+                    self.combination_stats[combo_key].signals_generated += 1
+                    self.combination_stats[combo_key].last_signal_time = datetime.now()
+                    
+                    position_percent = (amount_to_invest / self.initial_balance) * 100
+                    logger.info(f"""
+{'='*60}
+🚀 NEW SIGNAL: {symbol} {interval}
+{'='*60}
+   Entry Price:  ${current_price:,.2f}
+   Stop Loss:    ${trading_signal.stop_loss:,.2f} ({(trading_signal.stop_loss/current_price-1)*100:.2f}%)
+   TP1:          ${trading_signal.take_profit_1:,.2f} ({(trading_signal.take_profit_1/current_price-1)*100:.2f}%)
+   TP2:          ${trading_signal.take_profit_2:,.2f} ({(trading_signal.take_profit_2/current_price-1)*100:.2f}%)
+   TP3:          ${trading_signal.take_profit_3:,.2f} ({(trading_signal.take_profit_3/current_price-1)*100:.2f}%)
+   Position:     {position_size:.6f} units (${amount_to_invest:,.2f} = {position_percent:.1f}% of balance)
+   R/R Ratio:    {trading_signal.risk_reward_ratio:.2f}
+   Confidence:   {confidence:.1%}
+{'='*60}
+""")
+    
+    def _print_status(self):
+        """Print current status summary"""
+        now = datetime.now()
+        runtime = (now - self.start_time).total_seconds() / 60 if self.start_time else 0
+        
+        total_profit = sum(t.profit_loss for t in self.completed_trades)
+        total_trades = len(self.completed_trades)
+        wins = sum(1 for t in self.completed_trades if t.profit_loss > 0)
+        
+        # Fetch real-time prices for open positions
+        if self.open_positions:
+            symbols = set(pos.symbol for pos in self.open_positions.values())
+            live_prices = {symbol: fetch_current_price(symbol) for symbol in symbols}
+            for pos in self.open_positions.values():
+                if pos.symbol in live_prices and live_prices[pos.symbol] > 0:
+                    pos.current_price = live_prices[pos.symbol]
+                    pos.unrealized_pnl = pos.position_size * (pos.current_price - pos.entry_price)
+        
+        # Calculate total equity and unrealized P/L
+        total_equity = self.get_total_equity()
+        total_unrealized = sum(pos.unrealized_pnl for pos in self.open_positions.values())
+        
+        print(f"""
+{'═'*70}
+📊 REAL-TIME TRADING STATUS - {now.strftime('%Y-%m-%d %H:%M:%S')}
+{'═'*70}
+  Runtime:           {runtime:.1f} minutes
+  
+  💰 BALANCE (Started: ${self.initial_balance:,.2f}):
+     Available:      ${self.balance:,.2f}
+     Invested:       ${self.invested_amount:,.2f}
+     Base Total:     ${self.balance + self.invested_amount:,.2f} {'✓' if abs(self.balance + self.invested_amount - self.initial_balance - total_profit) < 1 else '⚠️ MISMATCH!'}
+     Unrealized P/L: ${total_unrealized:+,.2f}
+     Total Equity:   ${total_equity + total_unrealized:,.2f}
+     
+  📊 REALIZED P/L:   ${total_profit:+,.2f} ({total_profit/self.initial_balance*100:+.2f}%)
+  
+  Completed:         {total_trades} trades ({wins} wins, {total_trades-wins} losses)
+  Win Rate:          {wins/total_trades*100:.1f}%
+  Open Positions:    {len(self.open_positions)}
+{'─'*70}
+  COMBINATION STATS:
+""" if total_trades > 0 else f"""
+{'═'*70}
+📊 REAL-TIME TRADING STATUS - {now.strftime('%Y-%m-%d %H:%M:%S')}
+{'═'*70}
+  Runtime:           {runtime:.1f} minutes
+  
+  💰 BALANCE (Started: ${self.initial_balance:,.2f}):
+     Available:      ${self.balance:,.2f}
+     Invested:       ${self.invested_amount:,.2f}
+     Base Total:     ${self.balance + self.invested_amount:,.2f} {'✓' if abs(self.balance + self.invested_amount - self.initial_balance) < 1 else '⚠️ MISMATCH!'}
+     Unrealized P/L: ${total_unrealized:+,.2f}
+     Total Equity:   ${total_equity + total_unrealized:,.2f}
+     
+  Open Positions:    {len(self.open_positions)}
+  Signals Generated: {sum(s.signals_generated for s in self.combination_stats.values())}
+{'─'*70}
+  COMBINATION STATS:
+""")
+        
+        for key, stats in sorted(self.combination_stats.items()):
+            wr = stats.wins / stats.trades * 100 if stats.trades > 0 else 0
+            status = "🟢" if stats.total_profit > 0 else "🔴" if stats.total_profit < 0 else "⚪"
+            print(f"    {status} {key:<15}: {stats.trades:>3} trades | ${stats.total_profit:>+10.2f} | {wr:>5.1f}% WR | {stats.signals_generated} signals")
+        
+        if self.open_positions:
+            # Prices already updated at the top of this method
+            # Calculate actual invested from positions (for verification)
+            actual_invested = sum(pos.position_size * pos.entry_price for pos in self.open_positions.values())
+            print(f"\n{'─'*70}\n  OPEN POSITIONS (Unrealized P/L: ${total_unrealized:+,.2f}):")
+            for pos in self.open_positions.values():
+                duration = (now - pos.entry_time).total_seconds() / 60
+                pnl_pct = ((pos.current_price - pos.entry_price) / pos.entry_price * 100) if pos.current_price > 0 else 0
+                pnl_emoji = "📈" if pos.unrealized_pnl >= 0 else "📉"
+                pos_value = pos.position_size * pos.entry_price
+                print(f"    {pnl_emoji} {pos.symbol} {pos.interval}:")
+                print(f"       Entry: ${pos.entry_price:,.2f} → Current: ${pos.current_price:,.2f} ({pnl_pct:+.2f}%)")
+                print(f"       Size: {pos.position_size:.6f} units (${pos_value:,.2f}) | P/L: ${pos.unrealized_pnl:+,.2f}")
+                print(f"       SL: ${pos.stop_loss:,.2f} | Duration: {duration:.1f}m")
+            
+            # Show verification
+            if abs(actual_invested - self.invested_amount) > 0.01:
+                print(f"\n    ⚠️ ACCOUNTING MISMATCH:")
+                print(f"       Tracked invested: ${self.invested_amount:,.2f}")
+                print(f"       Actual from positions: ${actual_invested:,.2f}")
+                print(f"       Difference: ${self.invested_amount - actual_invested:,.2f}")
+        
+        print(f"{'═'*70}\n")
+    
+    def run(self, duration_hours: float = None):
+        """Run the real-time trading test"""
+        self.running = True
+        self.start_time = datetime.now()
+        
+        # Determine which combinations to monitor
+        combinations = [
+            c for c in self.COMBINATIONS 
+            if not self.safe_only or c["priority"] == "SAFE"
+        ]
+        
+        # Get confidence threshold from weights
+        conf_threshold = self.weights[18] if len(self.weights) > 18 else 0.3
+        conf_threshold = max(0.1, min(0.9, conf_threshold))
+        
+        logger.info(f"""
+{'═'*70}
+🚀 STARTING REAL-TIME TRADING TEST
+{'═'*70}
+  Initial Balance: ${self.initial_balance:,.2f}
+  Risk per Trade:  {self.risk_percentage}%
+  Max Position:    {self.max_position_percent}% of balance (${self.initial_balance * self.max_position_percent / 100:,.2f} max per trade)
+  Candle Window:   {self.candle_window} candles
+  Confidence:      >{conf_threshold:.0%} (learned threshold)
+  Trailing Stop:   {'Enabled' if self.use_trailing_stop else 'Disabled'} ({self.trailing_stop_distance}%)
+  Mode:            {'SAFE ONLY' if self.safe_only else 'ALL COMBINATIONS'}
+  Duration:        {f'{duration_hours} hours' if duration_hours else 'Unlimited (Ctrl+C to stop)'}
+  
+  Monitoring {len(combinations)} combinations:
+""")
+        for c in combinations:
+            logger.info(f"    • {c['symbol']} {c['interval']} [{c['priority']}]")
+        
+        logger.info(f"{'═'*70}\n")
+        
+        end_time = datetime.now() + timedelta(hours=duration_hours) if duration_hours else None
+        last_status_print = datetime.now()
+        status_interval = 60  # Print status every 60 seconds
+        
+        try:
+            while self.running:
+                if end_time and datetime.now() >= end_time:
+                    logger.info("Duration reached. Stopping...")
+                    break
+                
+                if self.stop_event.is_set():
+                    break
+                
+                # Process each combination
+                for combo in combinations:
+                    if self.stop_event.is_set():
+                        break
+                    
+                    try:
+                        self._process_combination(combo["symbol"], combo["interval"])
+                    except Exception as e:
+                        logger.error(f"Error processing {combo['symbol']} {combo['interval']}: {e}")
+                
+                # Print status periodically
+                if (datetime.now() - last_status_print).total_seconds() >= status_interval:
+                    self._print_status()
+                    last_status_print = datetime.now()
+                
+                # Sleep briefly between cycles
+                time.sleep(5)
+                
+        except KeyboardInterrupt:
+            logger.info("\n⚠️ Interrupted by user")
+        finally:
+            self.running = False
+            self._print_final_report()
+    
+    def _print_final_report(self):
+        """Print final trading report"""
+        runtime = (datetime.now() - self.start_time).total_seconds() / 60 if self.start_time else 0
+        
+        total_profit = sum(t.profit_loss for t in self.completed_trades)
+        total_trades = len(self.completed_trades)
+        wins = sum(1 for t in self.completed_trades if t.profit_loss > 0)
+        
+        print(f"""
+{'═'*70}
+📊 FINAL REAL-TIME TRADING REPORT
+{'═'*70}
+
+  Duration:         {runtime:.1f} minutes ({runtime/60:.2f} hours)
+  Initial Balance:  ${self.initial_balance:,.2f}
+  Final Balance:    ${self.balance:,.2f}
+  
+  PERFORMANCE:
+  ─────────────────────────────────
+  Total Profit:     ${total_profit:+,.2f}
+  ROI:              {total_profit/self.initial_balance*100:+.2f}%
+  Total Trades:     {total_trades}
+  Win Rate:         {wins/total_trades*100:.1f}% ({wins}/{total_trades})
+  Avg Profit/Trade: ${total_profit/total_trades if total_trades else 0:.2f}
+  
+  BY COMBINATION:
+  ─────────────────────────────────
+""" if total_trades > 0 else f"""
+{'═'*70}
+📊 FINAL REAL-TIME TRADING REPORT
+{'═'*70}
+
+  Duration:         {runtime:.1f} minutes
+  Initial Balance:  ${self.initial_balance:,.2f}
+  Final Balance:    ${self.balance:,.2f}
+  
+  No completed trades during this session.
+  Open positions: {len(self.open_positions)}
+  Signals generated: {sum(s.signals_generated for s in self.combination_stats.values())}
+  
+{'═'*70}
+""")
+        
+        if total_trades > 0:
+            sorted_stats = sorted(
+                self.combination_stats.items(),
+                key=lambda x: x[1].total_profit,
+                reverse=True
+            )
+            
+            for key, stats in sorted_stats:
+                if stats.trades > 0:
+                    wr = stats.wins / stats.trades * 100
+                    emoji = "🟢" if stats.total_profit > 0 else "🔴"
+                    print(f"  {emoji} {key:<15}: {stats.trades:>3} trades | ${stats.total_profit:>+10.2f} | {wr:>5.1f}% WR")
+            
+            print(f"\n{'═'*70}")
+        
+        # Print indicator performance stats
+        active_indicators = {k: v for k, v in self.indicator_stats.items() if v["signals"] > 0}
+        if active_indicators:
+            print(f"""
+{'═'*70}
+📈 INDICATOR CONTRIBUTION ANALYSIS
+{'═'*70}
+  (Sorted by profit contribution - worst performing first)
+  
+""")
+            sorted_indicators = sorted(
+                active_indicators.items(),
+                key=lambda x: x[1]["total_profit"]
+            )
+            
+            for indicator, stats in sorted_indicators:
+                wr = (stats["wins"] / stats["signals"] * 100) if stats["signals"] > 0 else 0
+                emoji = "🟢" if stats["total_profit"] > 0 else "🔴" if stats["total_profit"] < 0 else "⚪"
+                print(f"  {emoji} {indicator:<25}: {stats['signals']:>3} signals | ${stats['total_profit']:>+10.2f} | {wr:>5.1f}% WR")
+            
+            print(f"\n{'═'*70}")
+        
+        # Save results to file
+        self._save_results()
+    
+    def _save_results(self):
+        """Save results to JSON file"""
+        # Calculate unrealized P/L for open positions
+        total_unrealized = sum(pos.unrealized_pnl for pos in self.open_positions.values())
+        
+        # Get confidence threshold from weights
+        confidence_threshold = self.weights[18] if len(self.weights) > 18 else 0.3
+        confidence_threshold = max(0.1, min(0.9, confidence_threshold))
+        
+        results = {
+            "timestamp": datetime.now().isoformat(),
+            "runtime_minutes": (datetime.now() - self.start_time).total_seconds() / 60 if self.start_time else 0,
+            "initial_balance": self.initial_balance,
+            "final_balance": self.balance,
+            "invested_amount": self.invested_amount,
+            "total_equity": self.balance + self.invested_amount + total_unrealized,
+            "realized_profit": sum(t.profit_loss for t in self.completed_trades),
+            "unrealized_profit": total_unrealized,
+            "total_completed_trades": len(self.completed_trades),
+            "total_open_positions": len(self.open_positions),
+            "confidence_threshold": confidence_threshold,
+            
+            # Completed trades
+            "completed_trades": [
+                {
+                    "position_id": t.position_id,
+                    "symbol": t.symbol,
+                    "interval": t.interval,
+                    "entry_price": t.entry_price,
+                    "exit_price": t.exit_price,
+                    "profit_loss": t.profit_loss,
+                    "profit_percent": t.profit_percent,
+                    "exit_type": t.exit_type,
+                    "duration_minutes": t.duration_minutes,
+                    "entry_time": t.entry_time.isoformat(),
+                    "exit_time": t.exit_time.isoformat(),
+                    "chart_path": getattr(t, 'chart_path', ''),
+                    "confidence": t.confidence,
+                    "indicator_contributions": t.indicator_contributions,
+                }
+                for t in self.completed_trades
+            ],
+            
+            # Open positions (for potential continuation)
+            "open_positions": [
+                {
+                    "position_id": pos.position_id,
+                    "symbol": pos.symbol,
+                    "interval": pos.interval,
+                    "entry_price": pos.entry_price,
+                    "entry_time": pos.entry_time.isoformat(),
+                    "position_size": pos.position_size,
+                    "position_value": pos.position_size * pos.entry_price,
+                    "stop_loss": pos.stop_loss,
+                    "initial_stop_loss": pos.initial_stop_loss,
+                    "take_profit_1": pos.take_profit_1,
+                    "take_profit_2": pos.take_profit_2,
+                    "take_profit_3": pos.take_profit_3,
+                    "highest_price": pos.highest_price,
+                    "trailing_stop_active": pos.trailing_stop_active,
+                    "trailing_stop_level": pos.trailing_stop_level,
+                    "tp1_hit": pos.tp1_hit,
+                    "tp2_hit": pos.tp2_hit,
+                    "tp3_hit": pos.tp3_hit,
+                    "current_price": pos.current_price,
+                    "unrealized_pnl": pos.unrealized_pnl,
+                    "duration_minutes": (datetime.now() - pos.entry_time).total_seconds() / 60,
+                    "signal_reason": pos.signal_reason,
+                    "confidence": pos.confidence,
+                    "indicator_contributions": pos.indicator_contributions,
+                }
+                for pos in self.open_positions.values()
+            ],
+            
+            # Indicator performance stats (sorted by profit, worst first)
+            "indicator_stats": {
+                indicator: {
+                    **stats,
+                    "win_rate": (stats["wins"] / stats["signals"] * 100) if stats["signals"] > 0 else 0.0
+                }
+                for indicator, stats in sorted(
+                    self.indicator_stats.items(),
+                    key=lambda x: x[1]["total_profit"]
+                )
+            },
+            
+            # Stats per combination
+            "combination_stats": {
+                key: {
+                    "trades": s.trades,
+                    "wins": s.wins,
+                    "losses": s.losses,
+                    "total_profit": s.total_profit,
+                    "signals_generated": s.signals_generated,
+                }
+                for key, s in self.combination_stats.items()
+            }
+        }
+        
+        output_file = os.path.join(
+            os.path.dirname(__file__),
+            f"data/realtime_test_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        )
+        
+        os.makedirs(os.path.dirname(output_file), exist_ok=True)
+        
+        with open(output_file, 'w') as f:
+            json.dump(results, f, indent=2)
+        
+        logger.info(f"✓ Results saved to: {output_file}")
+        
+        if self.open_positions:
+            logger.info(f"   📍 {len(self.open_positions)} open positions saved for reference")
+
+
+def signal_handler(signum, frame):
+    """Handle interrupt signals"""
+    print("\n⚠️ Received interrupt signal. Shutting down gracefully...")
+    raise KeyboardInterrupt
+
+
+def main():
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Real-Time Trading Strategy Tester")
+    parser.add_argument("--balance", type=float, default=10000.0, help="Initial balance (default: 10000)")
+    parser.add_argument("--risk", type=float, default=1.0, help="Risk percentage per trade (default: 1.0)")
+    parser.add_argument("--max-position", type=float, default=20.0, help="Max position size as %% of balance (default: 20)")
+    parser.add_argument("--candles", type=int, default=500, help="Number of candles for analysis window (default: 500)")
+    parser.add_argument("--duration", type=float, default=None, help="Test duration in hours (default: unlimited)")
+    parser.add_argument("--safe-only", action="store_true", help="Only use safe combinations (0%% fail rate)")
+    parser.add_argument("--no-trailing", action="store_true", help="Disable trailing stop")
+    parser.add_argument("--disable-worst-patterns", action="store_true", 
+                        help="Disable recognition of worst-performing patterns from backtest")
+    parser.add_argument("--pattern-threshold", type=float, default=-100.0,
+                        help="Profit threshold below which patterns are disabled (default: -100)")
+    
+    args = parser.parse_args()
+    
+    # Set up signal handlers
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+    
+    trader = RealTimeTrader(
+        initial_balance=args.balance,
+        risk_percentage=args.risk,
+        use_trailing_stop=not args.no_trailing,
+        safe_only=args.safe_only,
+        max_position_percent=args.max_position,
+        candle_window=args.candles,
+        disable_worst_patterns=args.disable_worst_patterns,
+        worst_pattern_threshold=args.pattern_threshold,
+    )
+    
+    trader.run(duration_hours=args.duration)
+
+
+if __name__ == "__main__":
+    main()
+
diff --git a/back_tester/run_learning_backtest.py b/back_tester/run_learning_backtest.py
new file mode 100755
index 0000000..697abcf
--- /dev/null
+++ b/back_tester/run_learning_backtest.py
@@ -0,0 +1,836 @@
+#!/usr/bin/env python3
+"""
+Self-Learning Backtesting Runner
+
+This script runs comprehensive backtests on BTCUSDT and ETHUSDT across all 
+time intervals with AGGRESSIVE self-learning. The system:
+- Learns from each trade outcome
+- Directly adjusts weights based on indicator performance
+- Runs many iterations to find optimal weights
+
+Usage:
+    python3 run_learning_backtest.py [options]
+
+Options:
+    --iterations N    Number of learning iterations (default: 20)
+    --candles N       Number of candles per backtest
+    --balance N       Initial balance (default: 10000)
+    --learning-rate   How fast weights change (default: 0.15)
+"""
+
+import os
+import sys
+import argparse
+import json
+from datetime import datetime
+from typing import Dict, List, Any, Tuple
+from collections import defaultdict
+import numpy as np
+import random
+
+# Add project root to path
+project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+if project_dir not in sys.path:
+    sys.path.append(project_dir)
+
+from back_tester.strategy import backtest_strategy
+
+# Configuration
+SYMBOLS = ["BTCUSDT", "ETHUSDT"]
+INTERVALS = ["5m", "15m", "30m", "1h", "4h"]  # Most useful intervals
+
+WEIGHT_NAMES = [
+    "W_BULLISH_OB", "W_BEARISH_OB", "W_BULLISH_BREAKER", "W_BEARISH_BREAKER",
+    "W_ABOVE_SUPPORT", "W_BELOW_RESISTANCE", "W_FVG_ABOVE", "W_FVG_BELOW",
+    "W_TREND", "W_SWEEP_HIGHS", "W_SWEEP_LOWS", "W_STRUCTURE_BREAK",
+    "W_PIN_BAR", "W_ENGULFING", "W_LIQUIDITY_POOL_ABOVE", "W_LIQUIDITY_POOL_BELOW",
+    "W_LIQUIDITY_POOL_ROUND", "W_RSI_EXTREME",
+    "W_CONFIDENCE_THRESHOLD"  # Minimum confidence level to approve trades (0.0 - 1.0)
+]
+
+# Candle settings per interval (increased for more trades)
+# Binance allows up to 1000 candles per request, but we can fetch more with pagination
+CANDLES_PER_INTERVAL = {
+    "5m": 2000,   # ~7 days of data
+    "15m": 1500,  # ~15 days of data
+    "30m": 1200,  # ~25 days of data
+    "1h": 1000,   # ~42 days of data
+    "4h": 800,    # ~133 days of data (~4.5 months)
+}
+
+class Colors:
+    H = '\033[95m'
+    B = '\033[94m'
+    C = '\033[96m'
+    G = '\033[92m'
+    Y = '\033[93m'
+    R = '\033[91m'
+    E = '\033[0m'
+    BOLD = '\033[1m'
+
+
+class AggressiveLearner:
+    """
+    Aggressive weight learning with direct performance-based updates.
+    Unlike conservative learners, this one makes BIG changes.
+    """
+    
+    def __init__(
+        self,
+        storage_path: str = "./data/btc_eth_learning",
+        initial_balance: float = 10000.0,
+        learning_rate: float = 0.15,  # Much higher than typical 0.05
+        lr_decay: float = 0.95,  # Decay rate per iteration (prevents overfitting)
+        disable_worst_patterns: bool = False,
+        worst_pattern_threshold: float = -100.0,  # Disable patterns with profit below this
+    ):
+        self.storage_path = storage_path
+        self.initial_balance = initial_balance
+        self.base_learning_rate = learning_rate
+        self.learning_rate = learning_rate
+        self.lr_decay = lr_decay
+        self.disable_worst_patterns = disable_worst_patterns
+        self.worst_pattern_threshold = worst_pattern_threshold
+        
+        os.makedirs(storage_path, exist_ok=True)
+        
+        # Load or initialize weights
+        self.weights = self._load_weights()
+        self.best_weights = self.weights.copy()
+        self.best_profit = float('-inf')
+        
+        # Track indicator performance across all trades
+        self.indicator_stats = defaultdict(lambda: {
+            'win_count': 0, 'loss_count': 0,
+            'win_profit': 0.0, 'loss_amount': 0.0,
+            'appearances': 0
+        })
+        
+        # Track detected patterns/structures performance
+        self.pattern_stats = defaultdict(lambda: {
+            'detections': 0,
+            'wins': 0,
+            'losses': 0,
+            'total_profit': 0.0,
+            'win_rate': 0.0
+        })
+        
+        # Load disabled patterns from previous runs
+        self.disabled_patterns = set()
+        if disable_worst_patterns:
+            self._load_disabled_patterns()
+        
+        # Pattern keywords to detect in reasons (matching actual signal detection output)
+        self.PATTERN_KEYWORDS = {
+            # Order Blocks (from detection.py: "Strong bullish order block found")
+            "bullish order block": "Bullish Order Block",
+            "bearish order block": "Bearish Order Block",
+            "order block": "Order Block",
+            
+            # Breaker Blocks (from detection.py: "Strong bullish breaker block found")
+            "bullish breaker block": "Bullish Breaker Block",
+            "bearish breaker block": "Bearish Breaker Block",
+            "breaker block": "Breaker Block",
+            
+            # FVG (from detection.py: "Unfilled FVG below current price")
+            "fvg below": "FVG Below",
+            "fvg above": "FVG Above",
+            "unfilled fvg": "FVG",
+            "fair value gap": "FVG",
+            
+            # Support/Resistance (from detection.py: "Price near support level at")
+            "near support": "Support Level",
+            "near resistance": "Resistance Level",
+            "support level": "Support Level",
+            "resistance level": "Resistance Level",
+            
+            # Liquidity Sweeps (from detection.py: "Price swept through previous highs")
+            "swept through previous highs": "Liquidity Sweep (Highs)",
+            "swept through previous lows": "Liquidity Sweep (Lows)",
+            "liquidity sweep": "Liquidity Sweep",
+            
+            # Structure Breaks (from detection.py: "Price broke structure upward")
+            "broke structure upward": "Structure Break (Bullish)",
+            "broke structure downward": "Structure Break (Bearish)",
+            "broke structure": "Structure Break",
+            "bos": "Break of Structure",
+            "choch": "Change of Character",
+            
+            # Candlestick Patterns
+            "bullish pin bar": "Bullish Pin Bar",
+            "bearish engulfing": "Bearish Engulfing",
+            "pin bar": "Pin Bar",
+            "engulfing": "Engulfing Pattern",
+            
+            # Liquidity Pools
+            "liquidity pool above": "Liquidity Pool Above",
+            "liquidity pool below": "Liquidity Pool Below",
+            "round number liquidity": "Round Number Liquidity",
+            "liquidity pool": "Liquidity Pool",
+            
+            # RSI (from detection.py: "RSI oversold at")
+            "rsi oversold": "RSI Oversold",
+            "rsi overbought": "RSI Overbought",
+            
+            # Trend (from detection.py: "Price is in an uptrend")
+            "in an uptrend": "Uptrend",
+            "in a downtrend": "Downtrend",
+            "uptrend": "Uptrend",
+            "downtrend": "Downtrend",
+            
+            # Other patterns
+            "mitigation": "Mitigation Block",
+            "imbalance": "Imbalance Zone",
+            "market regime": "Market Regime",
+            "volume ratio": "Volume Analysis"
+        }
+        
+        # Track overall performance
+        self.iteration = 0
+        self.total_trades = 0
+        self.total_profit = 0.0
+        self.profit_history = []
+        self.weight_history = []
+    
+    def _load_weights(self) -> List[float]:
+        """Load weights from file or use optimized defaults"""
+        weights_file = os.path.join(self.storage_path, "final_weights.json")
+        
+        if os.path.exists(weights_file):
+            try:
+                with open(weights_file, 'r') as f:
+                    data = json.load(f)
+                    if 'weights' in data:
+                        weights_data = data['weights']
+                        # Handle dict format (name -> value)
+                        if isinstance(weights_data, dict):
+                            if len(weights_data) == len(WEIGHT_NAMES):
+                                weights = [float(weights_data.get(name, 1.0)) for name in WEIGHT_NAMES]
+                                print(f"{Colors.G}✓ Loaded weights from previous session{Colors.E}")
+                                return weights
+                        # Handle list format
+                        elif isinstance(weights_data, list) and len(weights_data) == len(WEIGHT_NAMES):
+                            weights = [float(w) for w in weights_data]
+                            print(f"{Colors.G}✓ Loaded weights from previous session{Colors.E}")
+                            return weights
+            except Exception as e:
+                print(f"{Colors.Y}Warning: Could not load weights: {e}{Colors.E}")
+        
+        # Smart starting weights (not all 1.0)
+        return [
+            1.3,   # W_BULLISH_OB - Order blocks tend to work well
+            1.3,   # W_BEARISH_OB
+            1.1,   # W_BULLISH_BREAKER
+            1.1,   # W_BEARISH_BREAKER
+            0.8,   # W_ABOVE_SUPPORT
+            0.8,   # W_BELOW_RESISTANCE
+            0.6,   # W_FVG_ABOVE - FVGs less reliable alone
+            0.6,   # W_FVG_BELOW
+            1.0,   # W_TREND
+            1.4,   # W_SWEEP_HIGHS - Sweeps are key signals
+            1.4,   # W_SWEEP_LOWS
+            1.5,   # W_STRUCTURE_BREAK - Very important
+            0.7,   # W_PIN_BAR
+            0.7,   # W_ENGULFING
+            1.0,   # W_LIQUIDITY_POOL_ABOVE
+            1.0,   # W_LIQUIDITY_POOL_BELOW
+            1.2,   # W_LIQUIDITY_POOL_ROUND
+            0.5,   # W_RSI_EXTREME - Often unreliable
+            0.3,   # W_CONFIDENCE_THRESHOLD - Min confidence to approve trade (0.0-1.0)
+        ]
+    
+    def _load_disabled_patterns(self):
+        """Load worst-performing patterns from saved stats and disable them"""
+        weights_file = os.path.join(self.storage_path, "final_weights.json")
+        
+        if os.path.exists(weights_file):
+            try:
+                with open(weights_file, 'r') as f:
+                    data = json.load(f)
+                    pattern_stats = data.get('pattern_stats', {})
+                    
+                    # Patterns that are ALWAYS present (not specific signals) should be excluded
+                    always_present_patterns = {
+                        'Uptrend', 'Downtrend', 'Market Regime', 'Volume Analysis'
+                    }
+                    
+                    for pattern, stats in pattern_stats.items():
+                        # Skip always-present patterns
+                        if pattern in always_present_patterns:
+                            continue
+                            
+                        total_profit = stats.get('total_profit', 0)
+                        trades = stats.get('detections', 0) or stats.get('trades', 0)
+                        
+                        # Only disable if we have enough data (>5 trades) and pattern is losing
+                        if trades >= 5 and total_profit < self.worst_pattern_threshold:
+                            self.disabled_patterns.add(pattern)
+                    
+                    if self.disabled_patterns:
+                        print(f"{Colors.Y}⚠️  Disabled worst-performing patterns:{Colors.E}")
+                        for p in sorted(self.disabled_patterns):
+                            stats = pattern_stats.get(p, {})
+                            print(f"   ❌ {p}: ${stats.get('total_profit', 0):+.2f}")
+                        print()
+                    else:
+                        print(f"{Colors.G}✓ No patterns disabled (all above threshold ${self.worst_pattern_threshold}){Colors.E}\n")
+                        
+            except Exception as e:
+                print(f"{Colors.Y}Warning: Could not load pattern stats: {e}{Colors.E}")
+    
+    def _is_pattern_disabled(self, reason: str) -> Tuple[bool, List[str]]:
+        """Check if any disabled patterns are present in the signal reason"""
+        if not self.disabled_patterns:
+            return False, []
+        
+        detected = self._extract_patterns_from_reason(reason)
+        disabled_found = [p for p in detected if p in self.disabled_patterns]
+        
+        # Only block if the MAJORITY of detected patterns are disabled
+        # This prevents blocking signals that have both good and bad patterns
+        if len(disabled_found) > 0 and len(disabled_found) >= len(detected) / 2:
+            return True, disabled_found
+        
+        return False, disabled_found
+    
+    def _extract_patterns_from_reason(self, reason: str) -> List[str]:
+        """Extract detected patterns from the signal reason string"""
+        detected_patterns = []
+        reason_lower = reason.lower() if reason else ""
+        
+        for keyword, pattern_name in self.PATTERN_KEYWORDS.items():
+            if keyword in reason_lower:
+                if pattern_name not in detected_patterns:
+                    detected_patterns.append(pattern_name)
+        
+        return detected_patterns
+    
+    def _update_pattern_stats(self, patterns: List[str], is_win: bool, profit: float):
+        """Update pattern statistics after a trade"""
+        for pattern in patterns:
+            self.pattern_stats[pattern]['detections'] += 1
+            self.pattern_stats[pattern]['total_profit'] += profit
+            if is_win:
+                self.pattern_stats[pattern]['wins'] += 1
+            else:
+                self.pattern_stats[pattern]['losses'] += 1
+            
+            # Calculate win rate
+            total = self.pattern_stats[pattern]['wins'] + self.pattern_stats[pattern]['losses']
+            if total > 0:
+                self.pattern_stats[pattern]['win_rate'] = self.pattern_stats[pattern]['wins'] / total * 100
+    
+    def _save_weights(self):
+        """Save current weights"""
+        # Calculate pattern stats with win rates
+        pattern_stats_with_rates = {}
+        for pattern, stats in self.pattern_stats.items():
+            total = stats['wins'] + stats['losses']
+            pattern_stats_with_rates[pattern] = {
+                **stats,
+                'win_rate': (stats['wins'] / total * 100) if total > 0 else 0.0,
+                'avg_profit': stats['total_profit'] / total if total > 0 else 0.0
+            }
+        
+        # Sort patterns by profit (worst first for easy identification)
+        sorted_patterns = dict(sorted(
+            pattern_stats_with_rates.items(),
+            key=lambda x: x[1]['total_profit']
+        ))
+        
+        data = {
+            'weights': self.weights,
+            'weight_names': WEIGHT_NAMES,
+            'best_weights': self.best_weights,
+            'best_profit': self.best_profit,
+            'iteration': self.iteration,
+            'total_trades': self.total_trades,
+            'total_profit': self.total_profit,
+            'timestamp': datetime.now().isoformat(),
+            'indicator_stats': dict(self.indicator_stats),
+            'pattern_stats': sorted_patterns,  # NEW: Detected pattern performance
+        }
+        
+        with open(os.path.join(self.storage_path, "final_weights.json"), 'w') as f:
+            json.dump(data, f, indent=2)
+    
+    def run_backtest(self, symbol: str, interval: str, candles: int) -> Dict:
+        """Run a single backtest and return results"""
+        window = int(candles * 0.5)
+        
+        try:
+            final_balance, trades, _ = backtest_strategy(
+                symbol=symbol,
+                interval=interval,
+                candles=candles,
+                window=window,
+                initial_balance=self.initial_balance,
+                risk_percentage=1.0,
+                weights=self.weights,
+                use_trailing_stop=True,
+                trailing_stop_distance_percent=0.5,
+                disabled_patterns=self.disabled_patterns if self.disable_worst_patterns else None,
+            )
+            
+            profit = final_balance - self.initial_balance
+            entry_trades = [t for t in trades if t.get('type') == 'entry']
+            
+            # Track patterns for each trade
+            # Group trades by sequence - each entry is followed by its exits until next entry
+            trade_groups = []
+            current_group = None
+            
+            for t in trades:
+                if t.get('type') == 'entry':
+                    # Save previous group if exists
+                    if current_group:
+                        trade_groups.append(current_group)
+                    # Start new group
+                    current_group = {'entry': t, 'exits': []}
+                elif current_group:
+                    # Add exit to current group
+                    current_group['exits'].append(t)
+            
+            # Don't forget the last group
+            if current_group:
+                trade_groups.append(current_group)
+            
+            # Analyze each trade group and extract patterns
+            wins = 0
+            losses = 0
+            detected_patterns_list = []
+            
+            for group in trade_groups:
+                entry = group.get('entry')
+                exits = group.get('exits', [])
+                
+                if not entry:
+                    continue
+                
+                # Extract patterns from entry signal/reason
+                # Try 'reason' first (full reason), then 'signal' (first line only)
+                reason = entry.get('reason', '') or entry.get('signal', '')
+                patterns = self._extract_patterns_from_reason(reason)
+                
+                # Calculate total profit for this trade group
+                trade_profit = sum(e.get('profit', 0) for e in exits)
+                is_win = trade_profit > 0
+                
+                # Determine if win or loss based on exit types
+                for e in exits:
+                    exit_type = e.get('type', '')
+                    if exit_type in ['take_profit_1', 'take_profit_2', 'take_profit_3']:
+                        is_win = True
+                        break
+                    elif exit_type == 'stop_loss':
+                        is_win = False
+                        break
+                
+                if trade_profit > 0:
+                    wins += 1
+                elif trade_profit < 0:
+                    losses += 1
+                
+                # Update pattern stats
+                if patterns:
+                    self._update_pattern_stats(patterns, is_win, trade_profit)
+                    detected_patterns_list.append({
+                        'patterns': patterns,
+                        'profit': trade_profit,
+                        'is_win': is_win
+                    })
+            
+            return {
+                'success': True,
+                'profit': profit,
+                'trades': len(entry_trades),
+                'wins': wins,
+                'losses': losses,
+                'win_rate': (wins / (wins + losses) * 100) if (wins + losses) > 0 else 0,
+                'detected_patterns': detected_patterns_list,
+            }
+            
+        except Exception as e:
+            return {'success': False, 'error': str(e), 'profit': 0, 'trades': 0}
+    
+    def update_weights(self, iteration_profit: float, iteration_trades: int, win_rate: float):
+        """
+        Update weights based on iteration performance.
+        Uses multiple strategies for learning.
+        """
+        if iteration_trades == 0:
+            return
+        
+        # Index of confidence threshold weight
+        CONFIDENCE_IDX = 18
+        
+        # Strategy 1: Random perturbation with momentum
+        # If profit was good, keep direction. If bad, try opposite.
+        for i in range(len(self.weights)):
+            # Add random exploration
+            noise = np.random.normal(0, self.learning_rate * 0.5)
+            
+            # Bias based on performance
+            if iteration_profit > 0:
+                # Profitable - small random changes
+                self.weights[i] += noise * 0.5
+            else:
+                # Losing - try bigger changes
+                self.weights[i] += noise * 1.5
+            
+            # Keep within bounds (different for confidence threshold)
+            if i == CONFIDENCE_IDX:
+                # Confidence threshold: 0.1 to 0.9
+                self.weights[i] = max(0.1, min(0.9, self.weights[i]))
+            else:
+                # Regular indicator weights: 0.2 to 2.5
+                self.weights[i] = max(0.2, min(2.5, self.weights[i]))
+        
+        # Strategy 2: Win rate based adjustment
+        # If win rate is low, reduce all weights slightly (be more selective)
+        # If win rate is high, can afford to increase weights
+        if win_rate < 40:
+            for i in range(len(self.weights)):
+                if i != CONFIDENCE_IDX:
+                    self.weights[i] *= 0.95  # Reduce by 5%
+                else:
+                    # Low win rate -> increase confidence threshold (be more selective)
+                    self.weights[i] = min(0.9, self.weights[i] + 0.02)
+        elif win_rate > 60:
+            for i in range(len(self.weights)):
+                if i != CONFIDENCE_IDX:
+                    self.weights[i] *= 1.02  # Increase by 2%
+                else:
+                    # High win rate -> can lower confidence threshold (accept more trades)
+                    self.weights[i] = max(0.1, self.weights[i] - 0.01)
+        
+        # Re-clamp
+        for i in range(len(self.weights)):
+            if i == CONFIDENCE_IDX:
+                self.weights[i] = max(0.1, min(0.9, self.weights[i]))
+            else:
+                self.weights[i] = max(0.2, min(2.5, self.weights[i]))
+    
+    def run_iteration(self) -> Dict:
+        """Run one complete iteration over all symbols and intervals"""
+        self.iteration += 1
+        
+        print(f"\n{Colors.H}{'='*70}{Colors.E}")
+        print(f"{Colors.H} ITERATION {self.iteration}{Colors.E}")
+        print(f"{Colors.H}{'='*70}{Colors.E}")
+        
+        iteration_profit = 0.0
+        iteration_trades = 0
+        iteration_wins = 0
+        iteration_losses = 0
+        
+        for symbol in SYMBOLS:
+            print(f"\n{Colors.C}--- {symbol} ---{Colors.E}")
+            
+            for interval in INTERVALS:
+                candles = CANDLES_PER_INTERVAL.get(interval, 400)
+                print(f"  {interval:>3}: ", end="", flush=True)
+                
+                result = self.run_backtest(symbol, interval, candles)
+                
+                if result['success']:
+                    profit = result['profit']
+                    trades = result['trades']
+                    wr = result['win_rate']
+                    
+                    iteration_profit += profit
+                    iteration_trades += trades
+                    iteration_wins += result['wins']
+                    iteration_losses += result['losses']
+                    
+                    color = Colors.G if profit > 0 else Colors.R
+                    print(f"{color}${profit:+8.2f}{Colors.E} | {trades:2d} trades | {wr:5.1f}% WR")
+                else:
+                    print(f"{Colors.R}FAILED: {result.get('error', 'Unknown')[:30]}{Colors.E}")
+        
+        # Update totals
+        self.total_trades += iteration_trades
+        self.total_profit += iteration_profit
+        
+        # Calculate iteration win rate
+        iter_wr = (iteration_wins / (iteration_wins + iteration_losses) * 100 
+                   if (iteration_wins + iteration_losses) > 0 else 0)
+        
+        # Print summary
+        print(f"\n{Colors.BOLD}Iteration {self.iteration} Summary:{Colors.E}")
+        color = Colors.G if iteration_profit > 0 else Colors.R
+        print(f"  Profit: {color}${iteration_profit:+.2f}{Colors.E}")
+        print(f"  Trades: {iteration_trades}")
+        print(f"  Win Rate: {iter_wr:.1f}%")
+        
+        # Track best
+        if iteration_profit > self.best_profit:
+            self.best_profit = iteration_profit
+            self.best_weights = self.weights.copy()
+            print(f"  {Colors.G}★ NEW BEST!{Colors.E}")
+        
+        # Update weights AGGRESSIVELY based on performance
+        self.update_weights(iteration_profit, iteration_trades, iter_wr)
+        
+        # Apply learning rate decay (prevents overfitting in later iterations)
+        self.learning_rate = self.base_learning_rate * (self.lr_decay ** self.iteration)
+        
+        # Show weight changes
+        print(f"\n{Colors.Y}Weight adjustments:{Colors.E}")
+        changed = 0
+        for i, (name, weight) in enumerate(zip(WEIGHT_NAMES, self.weights)):
+            if i < len(self.weight_history) and len(self.weight_history) > 0:
+                old = self.weight_history[-1][i] if self.weight_history else 1.0
+                diff = weight - old
+                if abs(diff) > 0.01:
+                    direction = "↑" if diff > 0 else "↓"
+                    print(f"  {name}: {old:.3f} → {weight:.3f} ({direction}{abs(diff):.3f})")
+                    changed += 1
+        
+        if changed == 0:
+            print("  (First iteration - weights established)")
+        
+        self.weight_history.append(self.weights.copy())
+        self.profit_history.append(iteration_profit)
+        
+        # Save after each iteration
+        self._save_weights()
+        
+        return {
+            'iteration': self.iteration,
+            'profit': iteration_profit,
+            'trades': iteration_trades,
+            'win_rate': iter_wr,
+        }
+    
+    def run(self, iterations: int = 20) -> Dict:
+        """Run multiple iterations of learning"""
+        print(f"\n{Colors.H}{'='*70}{Colors.E}")
+        print(f"{Colors.H}{'AGGRESSIVE SELF-LEARNING BACKTEST':^70}{Colors.E}")
+        print(f"{Colors.H}{'='*70}{Colors.E}")
+        
+        print(f"\n{Colors.C}Configuration:{Colors.E}")
+        print(f"  Iterations: {iterations}")
+        print(f"  Symbols: {SYMBOLS}")
+        print(f"  Intervals: {INTERVALS}")
+        print(f"  Learning Rate: {self.learning_rate} (decay: {self.lr_decay}/iter)")
+        print(f"  Initial Balance: ${self.initial_balance:,.2f}")
+        
+        # Show candle counts per interval
+        total_candles = sum(CANDLES_PER_INTERVAL.values()) * len(SYMBOLS)
+        print(f"\n{Colors.C}Data per iteration:{Colors.E}")
+        for interval, candles in CANDLES_PER_INTERVAL.items():
+            print(f"  {interval:>3}: {candles:,} candles × {len(SYMBOLS)} symbols")
+        print(f"  Total: ~{total_candles:,} candles/iteration (expect 200-400+ trades)")
+        
+        print(f"\n{Colors.C}Starting weights:{Colors.E}")
+        for name, weight in zip(WEIGHT_NAMES, self.weights):
+            print(f"  {name}: {weight:.3f}")
+        
+        start_time = datetime.now()
+        
+        try:
+            for _ in range(iterations):
+                self.run_iteration()
+        except KeyboardInterrupt:
+            print(f"\n{Colors.Y}Interrupted - saving progress...{Colors.E}")
+        
+        # Final report
+        self._print_final_report(start_time)
+        
+        return {
+            'total_iterations': self.iteration,
+            'total_trades': self.total_trades,
+            'total_profit': self.total_profit,
+            'best_profit': self.best_profit,
+            'final_weights': self.weights,
+            'best_weights': self.best_weights,
+        }
+    
+    def _print_final_report(self, start_time: datetime):
+        """Print final report"""
+        elapsed = (datetime.now() - start_time).total_seconds()
+        
+        print(f"\n{Colors.H}{'='*70}{Colors.E}")
+        print(f"{Colors.H}{'FINAL REPORT':^70}{Colors.E}")
+        print(f"{Colors.H}{'='*70}{Colors.E}")
+        
+        print(f"\n{Colors.BOLD}Overall Statistics:{Colors.E}")
+        print(f"  Duration: {elapsed/60:.1f} minutes")
+        print(f"  Iterations: {self.iteration}")
+        print(f"  Total Trades: {self.total_trades}")
+        
+        color = Colors.G if self.total_profit > 0 else Colors.R
+        print(f"  Total Profit: {color}${self.total_profit:+.2f}{Colors.E}")
+        print(f"  Best Iteration: ${self.best_profit:+.2f}")
+        
+        # Profit trend
+        if len(self.profit_history) > 1:
+            first_half = sum(self.profit_history[:len(self.profit_history)//2])
+            second_half = sum(self.profit_history[len(self.profit_history)//2:])
+            trend = "📈 IMPROVING" if second_half > first_half else "📉 Declining"
+            print(f"  Trend: {trend}")
+        
+        print(f"\n{Colors.BOLD}Final Optimized Weights:{Colors.E}")
+        for name, weight in zip(WEIGHT_NAMES, self.weights):
+            # Visual bar
+            bar_len = int(weight * 10)
+            bar = "█" * min(bar_len, 25) + "░" * max(0, 25 - bar_len)
+            
+            if weight > 1.5:
+                status = f"{Colors.G}STRONG{Colors.E}"
+            elif weight < 0.6:
+                status = f"{Colors.R}WEAK{Colors.E}"
+            else:
+                status = ""
+            
+            print(f"  {name:<25} {weight:.4f} {bar} {status}")
+        
+        # Print detected pattern performance
+        if self.pattern_stats:
+            print(f"\n{Colors.BOLD}Detected Pattern Performance:{Colors.E}")
+            print(f"  (Sorted by total profit - worst performing first)")
+            print()
+            
+            # Sort patterns by profit
+            sorted_patterns = sorted(
+                self.pattern_stats.items(),
+                key=lambda x: x[1]['total_profit']
+            )
+            
+            for pattern, stats in sorted_patterns:
+                if stats['detections'] > 0:
+                    wr = stats['win_rate']
+                    total = stats['wins'] + stats['losses']
+                    
+                    if stats['total_profit'] < 0:
+                        color = Colors.R
+                        emoji = "🔴"
+                    elif stats['total_profit'] > 0:
+                        color = Colors.G
+                        emoji = "🟢"
+                    else:
+                        color = Colors.Y
+                        emoji = "⚪"
+                    
+                    print(f"  {emoji} {pattern:<25}: {total:>4} trades | {color}${stats['total_profit']:>+10.2f}{Colors.E} | {wr:>5.1f}% WR")
+            
+            print()
+            
+            # Highlight worst and best
+            if sorted_patterns:
+                worst = sorted_patterns[0]
+                best = sorted_patterns[-1]
+                
+                if worst[1]['total_profit'] < 0:
+                    print(f"  {Colors.R}⚠️  WORST PATTERN: {worst[0]} (${worst[1]['total_profit']:+.2f}){Colors.E}")
+                if best[1]['total_profit'] > 0:
+                    print(f"  {Colors.G}✓  BEST PATTERN:  {best[0]} (${best[1]['total_profit']:+.2f}){Colors.E}")
+        
+        # Save
+        self._save_weights()
+        
+        # Create reports directory if needed
+        reports_dir = os.path.join(self.storage_path, "reports")
+        os.makedirs(reports_dir, exist_ok=True)
+        
+        # Save report with timestamp
+        timestamp_str = datetime.now().strftime('%Y%m%d_%H%M%S')
+        report_path = os.path.join(reports_dir, f"backtest_report_{timestamp_str}.json")
+        
+        # Also save as "latest" for easy access
+        latest_path = os.path.join(self.storage_path, "backtest_report.json")
+        
+        # Prepare pattern stats for JSON (sorted by profit)
+        pattern_report = {}
+        for pattern, stats in sorted(self.pattern_stats.items(), key=lambda x: x[1]['total_profit']):
+            total = stats['wins'] + stats['losses']
+            pattern_report[pattern] = {
+                'trades': total,
+                'wins': stats['wins'],
+                'losses': stats['losses'],
+                'total_profit': round(stats['total_profit'], 2),
+                'win_rate': round(stats['win_rate'], 1),
+                'avg_profit': round(stats['total_profit'] / total, 2) if total > 0 else 0
+            }
+        
+        report_data = {
+                'timestamp': datetime.now().isoformat(),
+                'iterations': self.iteration,
+                'total_trades': self.total_trades,
+                'total_profit': self.total_profit,
+                'best_profit': self.best_profit,
+                'profit_history': self.profit_history,
+                'final_weights': dict(zip(WEIGHT_NAMES, self.weights)),
+                'best_weights': dict(zip(WEIGHT_NAMES, self.best_weights)),
+            'detected_patterns': pattern_report,
+        }
+        
+        # Save timestamped report
+        with open(report_path, 'w') as f:
+            json.dump(report_data, f, indent=2)
+        
+        # Save as "latest" for easy access
+        with open(latest_path, 'w') as f:
+            json.dump(report_data, f, indent=2)
+        
+        print(f"\n{Colors.G}✓ Report saved to: {report_path}{Colors.E}")
+        print(f"{Colors.G}✓ Latest report: {latest_path}{Colors.E}")
+        print(f"{Colors.G}✓ Weights saved to: {self.storage_path}/final_weights.json{Colors.E}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Aggressive self-learning backtest")
+    parser.add_argument('--iterations', type=int, default=20,
+                        help='Number of learning iterations (default: 20)')
+    parser.add_argument('--balance', type=float, default=10000.0)
+    parser.add_argument('--learning-rate', type=float, default=0.15,
+                        help='How aggressively to change weights (default: 0.15)')
+    parser.add_argument('--storage', type=str, default='./data/btc_eth_learning')
+    parser.add_argument('--report-only', action='store_true')
+    parser.add_argument('--disable-worst-patterns', action='store_true',
+                        help='Disable recognition of worst-performing patterns')
+    parser.add_argument('--pattern-threshold', type=float, default=-100.0,
+                        help='Profit threshold below which patterns are disabled (default: -100)')
+    
+    args = parser.parse_args()
+    
+    if args.report_only:
+        weights_file = os.path.join(args.storage, "final_weights.json")
+        if os.path.exists(weights_file):
+            with open(weights_file) as f:
+                data = json.load(f)
+            print(json.dumps(data, indent=2))
+        else:
+            print("No saved weights found")
+        return
+    
+    learner = AggressiveLearner(
+        storage_path=args.storage,
+        initial_balance=args.balance,
+        learning_rate=args.learning_rate,
+        disable_worst_patterns=args.disable_worst_patterns,
+        worst_pattern_threshold=args.pattern_threshold,
+    )
+    
+    try:
+        result = learner.run(iterations=args.iterations)
+        
+        print(f"\n{Colors.H}{'='*70}{Colors.E}")
+        print(f"{Colors.H}{'BACKTEST COMPLETE':^70}{Colors.E}")
+        print(f"{Colors.H}{'='*70}{Colors.E}")
+        
+        print(f"\n{Colors.G}✓ Completed {result['total_iterations']} iterations{Colors.E}")
+        color = Colors.G if result['total_profit'] > 0 else Colors.R
+        print(f"{Colors.G}✓ Total profit: {color}${result['total_profit']:+.2f}{Colors.E}")
+        print(f"{Colors.B}ℹ Learning data saved to: {args.storage}{Colors.E}")
+        
+    except Exception as e:
+        print(f"\n{Colors.R}Error: {e}{Colors.E}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/back_tester/start_intensive_training.sh b/back_tester/start_intensive_training.sh
new file mode 100755
index 0000000..3c5e2f3
--- /dev/null
+++ b/back_tester/start_intensive_training.sh
@@ -0,0 +1,278 @@
+#!/bin/bash
+#
+# Intensive Parameter Optimization Launcher
+#
+# Optimizes ALL trading parameters:
+# - 18 Signal Weights
+# - Stop Loss (ATR multiplier, min distance)
+# - Take Profit Levels (TP1, TP2, TP3 ratios)
+# - Trailing Stop (distance, activation)
+# - Risk Percentage
+#
+# Usage:
+#   ./start_intensive_training.sh                    # Default: 2 hours
+#   ./start_intensive_training.sh --hours 8          # Run for 8 hours
+#   ./start_intensive_training.sh --generations 100  # Run 100 generations
+#
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"
+CLICKHOUSE_DIR="${SCRIPT_DIR}/clickhouse"
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+MAGENTA='\033[0;35m'
+BOLD='\033[1m'
+NC='\033[0m'
+
+# Defaults
+GENERATIONS=100
+HOURS=4
+POPULATION=8
+TESTS=10
+BALANCE=10000
+STORAGE_PATH="${SCRIPT_DIR}/data/intensive_training"
+SKIP_CLICKHOUSE=false
+
+TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
+LOG_FILE="${SCRIPT_DIR}/logs/intensive_training_${TIMESTAMP}.log"
+
+print_banner() {
+    echo -e "${MAGENTA}"
+    echo "╔══════════════════════════════════════════════════════════════════╗"
+    echo "║                                                                  ║"
+    echo "║   🧬 INTENSIVE PARAMETER OPTIMIZATION                           ║"
+    echo "║                                                                  ║"
+    echo "║   Optimizing:                                                   ║"
+    echo "║   • 18 Signal Weights                                           ║"
+    echo "║   • Stop Loss Parameters (ATR, distance)                        ║"
+    echo "║   • Take Profit Ratios (TP1, TP2, TP3)                          ║"
+    echo "║   • Trailing Stop (distance, activation)                        ║"
+    echo "║   • Risk Percentage                                             ║"
+    echo "║                                                                  ║"
+    echo "╚══════════════════════════════════════════════════════════════════╝"
+    echo -e "${NC}"
+}
+
+show_help() {
+    echo "Usage: $0 [options]"
+    echo ""
+    echo "Intensive parameter optimization for trading strategy"
+    echo ""
+    echo "Options:"
+    echo "  --hours N         Maximum training time in hours (default: 4)"
+    echo "  --generations N   Maximum generations (default: 100)"
+    echo "  --population N    Population size per generation (default: 8)"
+    echo "  --tests N         Backtests per evaluation (default: 10)"
+    echo "  --balance N       Initial balance (default: 10000)"
+    echo "  --storage PATH    Storage path for results"
+    echo "  --no-clickhouse   Skip ClickHouse startup"
+    echo "  --help            Show this help"
+    echo ""
+    echo "Examples:"
+    echo "  $0 --hours 8                    # Run for 8 hours"
+    echo "  $0 --generations 200 --hours 12 # Long training run"
+    echo ""
+}
+
+is_clickhouse_running() {
+    nc -z localhost 9000 &> /dev/null
+    return $?
+}
+
+start_clickhouse() {
+    echo -e "${YELLOW}Starting ClickHouse...${NC}"
+    
+    if is_clickhouse_running; then
+        echo -e "${GREEN}✓ ClickHouse already running${NC}"
+        return 0
+    fi
+    
+    cd "${CLICKHOUSE_DIR}" 2>/dev/null || mkdir -p "${CLICKHOUSE_DIR}"
+    
+    if ! command -v clickhouse &> /dev/null; then
+        echo -e "${RED}✗ ClickHouse not found. Install: brew install clickhouse${NC}"
+        exit 1
+    fi
+    
+    if [ -f "config.xml" ]; then
+        clickhouse server --config-file=config.xml &> "${SCRIPT_DIR}/logs/clickhouse_${TIMESTAMP}.log" &
+    else
+        clickhouse server &> "${SCRIPT_DIR}/logs/clickhouse_${TIMESTAMP}.log" &
+    fi
+    
+    CLICKHOUSE_PID=$!
+    
+    for i in {1..15}; do
+        if is_clickhouse_running; then
+            echo -e "${GREEN}✓ ClickHouse started${NC}"
+            return 0
+        fi
+        sleep 1
+    done
+    
+    echo -e "${RED}✗ ClickHouse failed to start${NC}"
+    return 1
+}
+
+cleanup() {
+    if [ "$SKIP_CLICKHOUSE" = false ] && [ -n "$CLICKHOUSE_PID" ]; then
+        echo -e "${YELLOW}Stopping ClickHouse...${NC}"
+        kill $CLICKHOUSE_PID 2>/dev/null || true
+    fi
+}
+
+trap cleanup EXIT
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --hours)
+            HOURS="$2"
+            shift 2
+            ;;
+        --generations)
+            GENERATIONS="$2"
+            shift 2
+            ;;
+        --population)
+            POPULATION="$2"
+            shift 2
+            ;;
+        --tests)
+            TESTS="$2"
+            shift 2
+            ;;
+        --balance)
+            BALANCE="$2"
+            shift 2
+            ;;
+        --storage)
+            STORAGE_PATH="$2"
+            shift 2
+            ;;
+        --no-clickhouse)
+            SKIP_CLICKHOUSE=true
+            shift
+            ;;
+        --help)
+            show_help
+            exit 0
+            ;;
+        *)
+            echo -e "${RED}Unknown option: $1${NC}"
+            show_help
+            exit 1
+            ;;
+    esac
+done
+
+main() {
+    print_banner
+    
+    mkdir -p "${SCRIPT_DIR}/logs"
+    mkdir -p "${STORAGE_PATH}"
+    
+    echo -e "${CYAN}Configuration:${NC}"
+    echo "  Max Generations: ${GENERATIONS}"
+    echo "  Max Time: ${HOURS} hours"
+    echo "  Population Size: ${POPULATION}"
+    echo "  Tests per Eval: ${TESTS}"
+    echo "  Initial Balance: \$${BALANCE}"
+    echo "  Storage: ${STORAGE_PATH}"
+    echo "  Log: ${LOG_FILE}"
+    echo ""
+    
+    # Estimate time
+    ESTIMATED_BACKTESTS=$((GENERATIONS * POPULATION * TESTS))
+    echo -e "${YELLOW}Estimated backtests: ~${ESTIMATED_BACKTESTS}${NC}"
+    echo -e "${YELLOW}This may take several hours. Progress will be saved automatically.${NC}"
+    echo ""
+    
+    if [ "$SKIP_CLICKHOUSE" = false ]; then
+        start_clickhouse || exit 1
+        sleep 2
+    fi
+    
+    export PYTHONPATH="${PROJECT_DIR}:${PYTHONPATH}"
+    
+    # Find Python
+    PYTHON_CMD=""
+    for cmd in python3.11 python3 python; do
+        if command -v $cmd &> /dev/null; then
+            PYTHON_CMD="$cmd"
+            break
+        fi
+    done
+    
+    if [ -z "$PYTHON_CMD" ]; then
+        echo -e "${RED}✗ Python not found${NC}"
+        exit 1
+    fi
+    
+    echo -e "${GREEN}Using: $(${PYTHON_CMD} --version)${NC}"
+    echo ""
+    
+    CMD="${PYTHON_CMD} ${SCRIPT_DIR}/intensive_training.py"
+    CMD="${CMD} --generations ${GENERATIONS}"
+    CMD="${CMD} --hours ${HOURS}"
+    CMD="${CMD} --population ${POPULATION}"
+    CMD="${CMD} --tests ${TESTS}"
+    CMD="${CMD} --balance ${BALANCE}"
+    CMD="${CMD} --storage ${STORAGE_PATH}"
+    
+    echo -e "${CYAN}Command:${NC} ${CMD}"
+    echo ""
+    
+    echo -e "${YELLOW}Starting optimization... (Ctrl+C to stop safely)${NC}"
+    echo ""
+    
+    ${CMD} 2>&1 | tee "${LOG_FILE}"
+    EXIT_CODE=${PIPESTATUS[0]}
+    
+    echo ""
+    if [ $EXIT_CODE -eq 0 ]; then
+        echo -e "${GREEN}╔══════════════════════════════════════════════════════════════════╗${NC}"
+        echo -e "${GREEN}║  ✓ OPTIMIZATION COMPLETED                                        ║${NC}"
+        echo -e "${GREEN}╚══════════════════════════════════════════════════════════════════╝${NC}"
+        echo ""
+        echo -e "${CYAN}Results:${NC}"
+        echo "  Parameters: ${STORAGE_PATH}/best_params.json"
+        echo "  Log: ${LOG_FILE}"
+        
+        # Show best params if file exists
+        if [ -f "${STORAGE_PATH}/best_params.json" ]; then
+            echo ""
+            echo -e "${CYAN}Best Parameters Summary:${NC}"
+            ${PYTHON_CMD} -c "
+import json
+with open('${STORAGE_PATH}/best_params.json') as f:
+    p = json.load(f)
+print(f\"  Fitness: {p.get('fitness', 'N/A'):.1f}\")
+print(f\"  TP Ratios: {p.get('tp1_ratio', 1.5):.1f} / {p.get('tp2_ratio', 2.5):.1f} / {p.get('tp3_ratio', 4.0):.1f}\")
+print(f\"  ATR Mult: {p.get('atr_multiplier', 2.0):.2f}\")
+print(f\"  Trailing: {p.get('trailing_stop_distance', 0.5):.2f}% at TP{p.get('trailing_activation_tp', 1)}\")
+print(f\"  Risk: {p.get('risk_percentage', 1.0):.2f}%\")
+" 2>/dev/null || true
+        fi
+    else
+        echo -e "${RED}╔══════════════════════════════════════════════════════════════════╗${NC}"
+        echo -e "${RED}║  ✗ OPTIMIZATION FAILED (code: ${EXIT_CODE})                              ║${NC}"
+        echo -e "${RED}╚══════════════════════════════════════════════════════════════════╝${NC}"
+        echo "Check log: ${LOG_FILE}"
+    fi
+    
+    return $EXIT_CODE
+}
+
+main
+
+
+
+
diff --git a/back_tester/start_learning_backtest.sh b/back_tester/start_learning_backtest.sh
new file mode 100755
index 0000000..badd417
--- /dev/null
+++ b/back_tester/start_learning_backtest.sh
@@ -0,0 +1,283 @@
+#!/bin/bash
+#
+# Self-Learning Backtesting Launcher for BTC and ETH
+#
+# This script launches comprehensive backtesting with self-learning
+# on BTCUSDT and ETHUSDT across all time intervals.
+#
+# Usage:
+#   ./start_learning_backtest.sh [options]
+#
+# Options:
+#   --iterations N    Number of learning iterations (default: 3)
+#   --candles N       Override candle count for all intervals
+#   --balance N       Initial balance (default: 10000)
+#   --risk N          Risk percentage per trade (default: 1.0)
+#   --no-clickhouse   Skip ClickHouse startup (if already running)
+#   --help            Show this help message
+#
+
+set -e
+
+# Script directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"
+CLICKHOUSE_DIR="${SCRIPT_DIR}/clickhouse"
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+MAGENTA='\033[0;35m'
+BOLD='\033[1m'
+NC='\033[0m'
+
+# Default parameters - AGGRESSIVE LEARNING (20 iterations, not 3!)
+ITERATIONS=20
+LEARNING_RATE=0.15
+BALANCE=10000
+SKIP_CLICKHOUSE=false
+STORAGE_PATH="${SCRIPT_DIR}/data/btc_eth_learning"
+
+# Timestamp for logs
+TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
+LOG_FILE="${SCRIPT_DIR}/logs/learning_backtest_${TIMESTAMP}.log"
+
+# Banner
+print_banner() {
+    echo -e "${MAGENTA}"
+    echo "╔══════════════════════════════════════════════════════════════════╗"
+    echo "║                                                                  ║"
+    echo "║   🤖 SELF-LEARNING BACKTESTING SYSTEM                            ║"
+    echo "║                                                                  ║"
+    echo "║   Symbols: BTCUSDT, ETHUSDT                                      ║"
+    echo "║   Intervals: 1m, 5m, 15m, 30m, 1h, 4h, 1d                        ║"
+    echo "║                                                                  ║"
+    echo "╚══════════════════════════════════════════════════════════════════╝"
+    echo -e "${NC}"
+}
+
+# Help message
+show_help() {
+    echo "Usage: $0 [options]"
+    echo ""
+    echo "Self-Learning Backtesting for BTCUSDT and ETHUSDT"
+    echo ""
+    echo "Options:"
+    echo "  --iterations N     Number of learning iterations (default: 20)"
+    echo "  --learning-rate N  How fast weights change (default: 0.15)"
+    echo "  --balance N        Initial balance in USD (default: 10000)"
+    echo "  --storage PATH     Path to store learning data"
+    echo "  --no-clickhouse    Skip ClickHouse startup"
+    echo "  --help             Show this help message"
+    echo ""
+    echo "Examples:"
+    echo "  $0                              # Run 20 iterations (default)"
+    echo "  $0 --iterations 50              # Run 50 learning iterations"
+    echo "  $0 --learning-rate 0.25         # More aggressive learning"
+    echo ""
+}
+
+# Check if ClickHouse is running
+is_clickhouse_running() {
+    nc -z localhost 9000 &> /dev/null
+    return $?
+}
+
+# Start ClickHouse
+start_clickhouse() {
+    echo -e "${YELLOW}Starting ClickHouse server...${NC}"
+    
+    if is_clickhouse_running; then
+        echo -e "${GREEN}✓ ClickHouse is already running${NC}"
+        return 0
+    fi
+    
+    if [ ! -d "${CLICKHOUSE_DIR}" ]; then
+        echo -e "${RED}✗ ClickHouse directory not found: ${CLICKHOUSE_DIR}${NC}"
+        echo -e "${YELLOW}Creating minimal ClickHouse config...${NC}"
+        mkdir -p "${CLICKHOUSE_DIR}"
+    fi
+    
+    cd "${CLICKHOUSE_DIR}"
+    
+    if ! command -v clickhouse &> /dev/null; then
+        echo -e "${RED}✗ ClickHouse not found in PATH${NC}"
+        echo "Please install ClickHouse: brew install clickhouse"
+        exit 1
+    fi
+    
+    # Start ClickHouse in background
+    if [ -f "config.xml" ]; then
+        clickhouse server --config-file=config.xml &> "${SCRIPT_DIR}/logs/clickhouse_${TIMESTAMP}.log" &
+    else
+        clickhouse server &> "${SCRIPT_DIR}/logs/clickhouse_${TIMESTAMP}.log" &
+    fi
+    
+    CLICKHOUSE_PID=$!
+    
+    echo -e "${YELLOW}Waiting for ClickHouse to start (PID: ${CLICKHOUSE_PID})...${NC}"
+    
+    for i in {1..15}; do
+        if is_clickhouse_running; then
+            echo -e "${GREEN}✓ ClickHouse started successfully${NC}"
+            return 0
+        fi
+        sleep 1
+        echo -n "."
+    done
+    
+    echo ""
+    echo -e "${RED}✗ Failed to start ClickHouse within timeout${NC}"
+    return 1
+}
+
+# Stop ClickHouse on exit
+cleanup() {
+    if [ "$SKIP_CLICKHOUSE" = false ] && [ -n "$CLICKHOUSE_PID" ]; then
+        echo -e "${YELLOW}Stopping ClickHouse...${NC}"
+        kill $CLICKHOUSE_PID 2>/dev/null || true
+    fi
+}
+
+trap cleanup EXIT
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --iterations)
+            ITERATIONS="$2"
+            shift 2
+            ;;
+        --learning-rate)
+            LEARNING_RATE="$2"
+            shift 2
+            ;;
+        --balance)
+            BALANCE="$2"
+            shift 2
+            ;;
+        --storage)
+            STORAGE_PATH="$2"
+            shift 2
+            ;;
+        --no-clickhouse)
+            SKIP_CLICKHOUSE=true
+            shift
+            ;;
+        --help)
+            show_help
+            exit 0
+            ;;
+        *)
+            echo -e "${RED}Unknown option: $1${NC}"
+            show_help
+            exit 1
+            ;;
+    esac
+done
+
+# Main execution
+main() {
+    print_banner
+    
+    # Create logs directory
+    mkdir -p "${SCRIPT_DIR}/logs"
+    mkdir -p "${STORAGE_PATH}"
+    
+    echo -e "${CYAN}Configuration:${NC}"
+    echo "  Iterations: ${ITERATIONS}"
+    echo "  Learning Rate: ${LEARNING_RATE}"
+    echo "  Balance: \$${BALANCE}"
+    echo "  Storage: ${STORAGE_PATH}"
+    echo "  Log File: ${LOG_FILE}"
+    echo ""
+    
+    # Estimate time
+    ESTIMATED_TIME=$((ITERATIONS * 2))
+    echo -e "${YELLOW}Estimated time: ~${ESTIMATED_TIME} minutes${NC}"
+    echo ""
+    
+    # Start ClickHouse if needed
+    if [ "$SKIP_CLICKHOUSE" = false ]; then
+        start_clickhouse
+        if [ $? -ne 0 ]; then
+            echo -e "${RED}Failed to start ClickHouse. Exiting.${NC}"
+            exit 1
+        fi
+        echo ""
+        sleep 2
+    else
+        echo -e "${YELLOW}Skipping ClickHouse startup (--no-clickhouse)${NC}"
+        if ! is_clickhouse_running; then
+            echo -e "${RED}Warning: ClickHouse doesn't appear to be running!${NC}"
+        fi
+        echo ""
+    fi
+    
+    # Set Python path
+    export PYTHONPATH="${PROJECT_DIR}:${PYTHONPATH}"
+    
+    # Check Python
+    PYTHON_CMD=""
+    if command -v python3.11 &> /dev/null; then
+        PYTHON_CMD="python3.11"
+    elif command -v python3 &> /dev/null; then
+        PYTHON_CMD="python3"
+    elif command -v python &> /dev/null; then
+        PYTHON_CMD="python"
+    else
+        echo -e "${RED}✗ Python not found${NC}"
+        exit 1
+    fi
+    
+    echo -e "${GREEN}Using Python: $(${PYTHON_CMD} --version)${NC}"
+    echo ""
+    
+    # Build command
+    CMD="${PYTHON_CMD} ${SCRIPT_DIR}/run_learning_backtest.py"
+    CMD="${CMD} --iterations ${ITERATIONS}"
+    CMD="${CMD} --learning-rate ${LEARNING_RATE}"
+    CMD="${CMD} --balance ${BALANCE}"
+    CMD="${CMD} --storage ${STORAGE_PATH}"
+    
+    echo -e "${CYAN}Executing:${NC}"
+    echo "  ${CMD}"
+    echo ""
+    
+    # Run backtest
+    echo -e "${YELLOW}Starting backtests... (logging to ${LOG_FILE})${NC}"
+    echo ""
+    
+    # Run and tee to both console and log file
+    ${CMD} 2>&1 | tee "${LOG_FILE}"
+    
+    EXIT_CODE=${PIPESTATUS[0]}
+    
+    echo ""
+    if [ $EXIT_CODE -eq 0 ]; then
+        echo -e "${GREEN}╔══════════════════════════════════════════════════════════════════╗${NC}"
+        echo -e "${GREEN}║  ✓ BACKTESTING COMPLETED SUCCESSFULLY                            ║${NC}"
+        echo -e "${GREEN}╚══════════════════════════════════════════════════════════════════╝${NC}"
+        echo ""
+        echo -e "${CYAN}Results saved to:${NC}"
+        echo "  Learning Data: ${STORAGE_PATH}"
+        echo "  Weights: ${STORAGE_PATH}/final_weights.json"
+        echo "  Report: ${STORAGE_PATH}/backtest_report.json"
+        echo "  Log: ${LOG_FILE}"
+    else
+        echo -e "${RED}╔══════════════════════════════════════════════════════════════════╗${NC}"
+        echo -e "${RED}║  ✗ BACKTESTING FAILED (exit code: ${EXIT_CODE})                          ║${NC}"
+        echo -e "${RED}╚══════════════════════════════════════════════════════════════════╝${NC}"
+        echo ""
+        echo "Check log file for details: ${LOG_FILE}"
+    fi
+    
+    return $EXIT_CODE
+}
+
+# Run main
+main
+
diff --git a/back_tester/start_live_trading.sh b/back_tester/start_live_trading.sh
new file mode 100755
index 0000000..4bdc4e1
--- /dev/null
+++ b/back_tester/start_live_trading.sh
@@ -0,0 +1,80 @@
+#!/bin/bash
+#
+# Start Live Trading Synchronization with Bybit
+#
+# This script starts the live trading system that synchronizes
+# realtime test signals with your actual Bybit account.
+#
+# Usage:
+#   ./start_live_trading.sh [testnet|live] [options]
+#
+# Examples:
+#   ./start_live_trading.sh testnet                   # Start on testnet
+#   ./start_live_trading.sh live --safe-only          # Live trading, safe pairs only
+#   ./start_live_trading.sh testnet --no-telegram     # Disable Telegram alerts
+#   ./start_live_trading.sh testnet --telegram-id 123 # Custom Telegram ID
+#
+
+# Change to the script directory
+cd "$(dirname "$0")"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+echo ""
+echo "╔══════════════════════════════════════════════════════════════╗"
+echo "║           BYBIT LIVE TRADING SYNCHRONIZATION                 ║"
+echo "╚══════════════════════════════════════════════════════════════╝"
+echo ""
+
+# Check for .env file
+if [ ! -f "../.env" ]; then
+    echo -e "${YELLOW}Warning: .env file not found in project root${NC}"
+    echo "Make sure BYBIT_API_KEY and BYBIT_API_SECRET are set as environment variables"
+    echo ""
+fi
+
+# Default values
+MODE="testnet"
+EXTRA_ARGS=""
+
+# Parse first argument as mode
+if [ "$1" == "live" ] || [ "$1" == "mainnet" ]; then
+    MODE="live"
+    shift
+elif [ "$1" == "testnet" ] || [ "$1" == "test" ]; then
+    MODE="testnet"
+    shift
+fi
+
+# Collect remaining arguments
+EXTRA_ARGS="$@"
+
+# Build command
+if [ "$MODE" == "testnet" ]; then
+    echo -e "${GREEN}Starting in TESTNET mode${NC}"
+    echo ""
+    CMD="python bybit_sync.py --testnet $EXTRA_ARGS"
+else
+    echo -e "${RED}⚠️  WARNING: Starting in LIVE TRADING mode!${NC}"
+    echo -e "${RED}   This will execute REAL trades with REAL money!${NC}"
+    echo ""
+    read -p "Are you sure you want to continue? (yes/no): " confirm
+    if [ "$confirm" != "yes" ]; then
+        echo "Aborted."
+        exit 0
+    fi
+    CMD="python bybit_sync.py --confirm $EXTRA_ARGS"
+fi
+
+echo "Command: $CMD"
+echo ""
+echo "═════════════════════════════════════════════════════════════════"
+echo ""
+
+# Run the trading script
+$CMD
+
diff --git a/back_tester/start_realtime_test.sh b/back_tester/start_realtime_test.sh
new file mode 100755
index 0000000..1ae6bcf
--- /dev/null
+++ b/back_tester/start_realtime_test.sh
@@ -0,0 +1,119 @@
+#!/bin/bash
+
+# Real-Time Trading Strategy Tester
+# This script monitors multiple symbol/interval combinations using real-time data
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+echo -e "${BLUE}"
+echo "╔══════════════════════════════════════════════════════════════════╗"
+echo "║          REAL-TIME TRADING STRATEGY TESTER                       ║"
+echo "╚══════════════════════════════════════════════════════════════════╝"
+echo -e "${NC}"
+
+# Default values
+BALANCE=10000
+RISK=1.0
+DURATION=""
+SAFE_ONLY=""
+NO_TRAILING=""
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --balance)
+            BALANCE="$2"
+            shift 2
+            ;;
+        --risk)
+            RISK="$2"
+            shift 2
+            ;;
+        --duration)
+            DURATION="--duration $2"
+            shift 2
+            ;;
+        --safe-only)
+            SAFE_ONLY="--safe-only"
+            shift
+            ;;
+        --no-trailing)
+            NO_TRAILING="--no-trailing"
+            shift
+            ;;
+        --help|-h)
+            echo "Usage: $0 [OPTIONS]"
+            echo ""
+            echo "Options:"
+            echo "  --balance VALUE    Initial balance (default: 10000)"
+            echo "  --risk VALUE       Risk percentage per trade (default: 1.0)"
+            echo "  --duration HOURS   Test duration in hours (default: unlimited)"
+            echo "  --safe-only        Only use safe combinations (BTCUSDT 1h, ETHUSDT 5m/15m)"
+            echo "  --no-trailing      Disable trailing stop"
+            echo "  --help, -h         Show this help message"
+            echo ""
+            echo "Examples:"
+            echo "  $0                           # Run with defaults (all combinations)"
+            echo "  $0 --safe-only               # Only safe combinations"
+            echo "  $0 --duration 2              # Run for 2 hours"
+            echo "  $0 --balance 5000 --risk 2   # Custom balance and risk"
+            exit 0
+            ;;
+        *)
+            echo -e "${RED}Unknown option: $1${NC}"
+            exit 1
+            ;;
+    esac
+done
+
+# Print configuration
+echo -e "${YELLOW}Configuration:${NC}"
+echo "  Initial Balance: \$${BALANCE}"
+echo "  Risk per Trade:  ${RISK}%"
+echo "  Duration:        ${DURATION:-Unlimited (Ctrl+C to stop)}"
+echo "  Mode:            ${SAFE_ONLY:-All Combinations}"
+echo "  Trailing Stop:   ${NO_TRAILING:-Enabled}"
+echo ""
+
+# Change to project directory
+cd "$PROJECT_DIR"
+
+# Check if virtual environment exists and activate it
+if [ -d "venv" ]; then
+    source venv/bin/activate
+elif [ -d ".venv" ]; then
+    source .venv/bin/activate
+fi
+
+# Run the real-time tester
+echo -e "${GREEN}Starting real-time trading test...${NC}"
+echo "Press Ctrl+C to stop"
+echo ""
+
+python3 "$SCRIPT_DIR/realtime_test.py" \
+    --balance "$BALANCE" \
+    --risk "$RISK" \
+    $DURATION \
+    $SAFE_ONLY \
+    $NO_TRAILING
+
+echo ""
+echo -e "${GREEN}Test completed.${NC}"
+
+
+
+
+
+
+
+
diff --git a/back_tester/strategy.py b/back_tester/strategy.py
index 3f56272..43fa092 100644
--- a/back_tester/strategy.py
+++ b/back_tester/strategy.py
@@ -1,30 +1,39 @@
 import os
 import sys
-from typing import List, Tuple, Optional, Dict
+from typing import List, Tuple, Optional, Dict, Any, Set
 import random
 from datetime import datetime, timedelta
 import uuid
+import logging
 
 project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
-sys.path.append(project_dir)
+if project_dir not in sys.path:
+    sys.path.insert(0, project_dir)
 
 import pandas as pd  # type: ignore
 
-# These imports use the system path we added above
-from data_fetching_instruments import fetch_candles, analyze_data
-from signal_detection import (
+from src.analysis.utils.helpers import fetch_candles
+from src.telegram.signals.detection import (
+    analyze_data,
     generate_price_prediction_signal_proba,
     TradingSignal,
     calculate_position_size,
 )
-import sys
-import os
+from src.core.utils import create_true_preferences
+
+# Import self-learning modules (optional - graceful fallback if not available)
+try:
+    from .adaptive_learning import (
+        SelfLearningBacktester,
+        extract_indicator_contributions,
+        SignalOutcome
+    )
+    from .enhanced_metrics import EnhancedMetricsCalculator, TradeMetrics, create_trade_metrics
+    LEARNING_AVAILABLE = True
+except ImportError:
+    LEARNING_AVAILABLE = False
 
-project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
-if project_dir not in sys.path:
-    sys.path.append(project_dir)
-from utils import create_true_preferences
-from .db_operations import ClickHouseDB
+logger = logging.getLogger(__name__)
 
 
 def backtest_strategy(
@@ -39,14 +48,22 @@ def backtest_strategy(
     use_trailing_stop: bool = True,
     trailing_stop_distance_percent: float = 0.5,  # Distance to maintain from highest price
     iteration_id: Optional[str] = None,
-    db: Optional[ClickHouseDB] = None,
+    db: Optional[Any] = None,
+    # Self-learning parameters
+    enable_learning: bool = False,
+    learner: Optional[Any] = None,  # SelfLearningBacktester instance
+    metrics_calculator: Optional[Any] = None,  # EnhancedMetricsCalculator instance
+    track_indicator_contributions: bool = True,
+    # Pattern filtering
+    disabled_patterns: Optional[Set[str]] = None,  # Set of pattern names to skip
 ) -> Tuple[float, list, Optional[str]]:
     """
-    Backtest a strategy with risk management:
+    Backtest a strategy with risk management and optional self-learning:
       - At each step, generate a signal with risk management parameters
       - Use position sizing based on risk percentage
       - Implement multiple take profit levels
       - Use dynamic stop loss and trailing stop loss
+      - Optionally track signal performance for self-learning
 
     Parameters:
       symbol: The trading pair symbol (e.g. "BTCUSDT")
@@ -59,6 +76,10 @@ def backtest_strategy(
       weights: List of weights for signal generation
       use_trailing_stop: Whether to enable trailing stop loss functionality
       trailing_stop_distance_percent: Distance in percentage to maintain from highest price reached
+      enable_learning: Whether to enable self-learning feedback loop
+      learner: SelfLearningBacktester instance for tracking signals
+      metrics_calculator: EnhancedMetricsCalculator for detailed metrics
+      track_indicator_contributions: Whether to track which indicators contributed to each signal
 
     Returns:
       final_balance: The simulated portfolio balance at the end
@@ -97,6 +118,27 @@ def backtest_strategy(
     entry_signal = None
     current_trade = None  # Store current trade details
     parent_trade_id = None  # Track parent trade for TP/SL entries
+    
+    # Self-learning tracking variables
+    current_signal_id = None
+    current_indicator_contributions = {}
+    current_market_context = {}
+    max_favorable_excursion = 0.0
+    max_adverse_excursion = 0.0
+    
+    # Initialize learning components if enabled
+    if enable_learning and LEARNING_AVAILABLE and learner is None:
+        learner = SelfLearningBacktester(
+            storage_path="./data/learning",
+            auto_adjust_weights=True,
+            adjustment_frequency=50
+        )
+        # Use adaptive weights if available
+        if not weights:
+            weights = learner.get_current_weights()
+    
+    if enable_learning and LEARNING_AVAILABLE and metrics_calculator is None:
+        metrics_calculator = EnhancedMetricsCalculator()
 
     # Use all indicators enabled by default in backtesting
     preferences = create_true_preferences()
@@ -313,6 +355,17 @@ def backtest_strategy(
                     }
                     db.insert_trade(trade_data)
 
+                # Record outcome for self-learning (TP3 - full target hit)
+                if enable_learning and LEARNING_AVAILABLE and learner and current_signal_id:
+                    learner.record_signal_exit(
+                        signal_id=current_signal_id,
+                        outcome="tp3",
+                        exit_price=current_price,
+                        profit_loss=profit,
+                        duration=i - entry_index
+                    )
+                    current_signal_id = None
+
                 position = 0
                 entry_price = None
                 entry_time = None
@@ -397,6 +450,17 @@ def backtest_strategy(
                     }
                     db.insert_trade(trade_data)
 
+                # Record outcome for self-learning (stop loss)
+                if enable_learning and LEARNING_AVAILABLE and learner and current_signal_id:
+                    learner.record_signal_exit(
+                        signal_id=current_signal_id,
+                        outcome="trailing_stop" if current_trade.get("trailing_stop_active", False) else "stop_loss",
+                        exit_price=current_price,
+                        profit_loss=loss,
+                        duration=i - entry_index
+                    )
+                    current_signal_id = None
+                
                 position = 0
                 entry_price = None
                 entry_time = None
@@ -406,7 +470,56 @@ def backtest_strategy(
                 parent_trade_id = None
 
         # Handle new signal
-        if signal == "Bullish" and position == 0 and trading_signal:
+        # Get confidence threshold from weights (index 18) or use default 0.3
+        confidence_threshold = weights[18] if len(weights) > 18 else 0.3
+        # Clamp confidence threshold to valid range [0.1, 0.9]
+        confidence_threshold = max(0.1, min(0.9, confidence_threshold))
+        
+        if signal == "Bullish" and position == 0 and trading_signal and confidence >= confidence_threshold:
+            # Check for disabled patterns
+            if disabled_patterns and reason:
+                reason_lower = reason.lower()
+                # Pattern keywords mapping (subset for quick check)
+                pattern_keywords = {
+                    "bullish order block": "Bullish Order Block",
+                    "bearish order block": "Bearish Order Block", 
+                    "bullish breaker block": "Bullish Breaker Block",
+                    "bearish breaker block": "Bearish Breaker Block",
+                    "breaker block": "Breaker Block",
+                    "order block": "Order Block",
+                    "fvg below": "FVG Below",
+                    "fvg above": "FVG Above",
+                    "unfilled fvg": "FVG",
+                    "near support": "Support Level",
+                    "near resistance": "Resistance Level",
+                    "swept through previous highs": "Liquidity Sweep (Highs)",
+                    "swept through previous lows": "Liquidity Sweep (Lows)",
+                    "broke structure upward": "Structure Break (Bullish)",
+                    "broke structure downward": "Structure Break (Bearish)",
+                    "broke structure": "Structure Break",
+                    "bullish pin bar": "Bullish Pin Bar",
+                    "bearish engulfing": "Bearish Engulfing",
+                    "pin bar": "Pin Bar",
+                    "engulfing": "Engulfing Pattern",
+                    "rsi oversold": "RSI Oversold",
+                    "rsi overbought": "RSI Overbought",
+                    "liquidity pool": "Liquidity Pool",
+                }
+                
+                # Detect patterns in reason
+                detected_patterns = []
+                for keyword, pattern_name in pattern_keywords.items():
+                    if keyword in reason_lower and pattern_name not in detected_patterns:
+                        detected_patterns.append(pattern_name)
+                
+                # Check if any disabled pattern is present
+                disabled_found = [p for p in detected_patterns if p in disabled_patterns]
+                
+                # Skip if majority of detected patterns are disabled
+                if disabled_found and len(disabled_found) >= len(detected_patterns) / 2:
+                    print(f"[Index {i}] {symbol}: SKIPPED - Disabled pattern(s): {', '.join(disabled_found)}")
+                    continue
+            
             # Validate price is reasonable
             if current_price < 0.00000001:  # Skip if price is too small
                 continue
@@ -436,9 +549,11 @@ def backtest_strategy(
             entry_signal = signal
             parent_trade_id = str(uuid.uuid4())  # Generate parent trade ID
 
-            # Store trade details
+            # Store trade details with trailing stop initialization
+            trailing_activation_price = float(trading_signal.take_profit_1)  # Activate at TP1
             current_trade = {
                 "stop_loss": float(trading_signal.stop_loss),
+                "initial_stop_loss": float(trading_signal.stop_loss),  # Store initial stop for comparison
                 "take_profit_1": float(trading_signal.take_profit_1),
                 "take_profit_2": float(trading_signal.take_profit_2),
                 "take_profit_3": float(trading_signal.take_profit_3),
@@ -448,6 +563,11 @@ def backtest_strategy(
                 "tp1_hit": False,
                 "tp2_hit": False,
                 "tp3_hit": False,
+                # Trailing stop fields
+                "highest_price": float(current_price),  # Track highest price reached
+                "trailing_stop_active": False,  # Whether trailing stop is active
+                "trailing_activation_price": trailing_activation_price,  # Price at which trailing stop activates
+                "trailing_stop_level": float(trading_signal.stop_loss),  # Current trailing stop level
             }
 
             trade_log.append(
@@ -456,14 +576,70 @@ def backtest_strategy(
                     "price": float(entry_price),
                     "index": int(i),
                     "signal": f"{signal} - {reason.splitlines()[0]}",
+                    "reason": reason,  # Full reason for pattern detection
                     "timestamp": current_time,
                     "amount": float(position),
                     "stop_loss": float(trading_signal.stop_loss),
                     "take_profit_1": float(trading_signal.take_profit_1),
                     "take_profit_2": float(trading_signal.take_profit_2),
                     "take_profit_3": float(trading_signal.take_profit_3),
+                    "symbol": symbol,
+                    "interval": interval,
                 }
             )
+            
+            # Track signal for self-learning
+            if enable_learning and LEARNING_AVAILABLE and learner:
+                # Parse reasons to extract indicator contributions
+                reasons_list = reason.split("\n- ") if reason else []
+                reasons_list = [r.strip("- \n") for r in reasons_list if r.strip()]
+                
+                # Extract bullish/bearish scores from reason string
+                bullish_score = 0.0
+                bearish_score = 0.0
+                if "Bullish Score:" in reason:
+                    try:
+                        bullish_part = reason.split("Bullish Score:")[1].split("|")[0]
+                        bullish_score = float(bullish_part.strip())
+                    except:
+                        pass
+                if "Bearish Score:" in reason:
+                    try:
+                        bearish_part = reason.split("Bearish Score:")[1].split("\n")[0]
+                        bearish_score = float(bearish_part.strip())
+                    except:
+                        pass
+                
+                current_indicator_contributions = extract_indicator_contributions(
+                    bullish_score, bearish_score, signal, reasons_list
+                )
+                
+                current_market_context = {
+                    "market_regime": trading_signal.market_conditions.get("market_regime", ""),
+                    "volatility": trading_signal.market_conditions.get("volatility", 0),
+                    "volume_ratio": trading_signal.market_conditions.get("volume_ratio", 1),
+                    "rsi": trading_signal.market_conditions.get("rsi", 50),
+                    "trend": "uptrend" if signal == "Bullish" else "downtrend"
+                }
+                
+                current_signal_id = str(uuid.uuid4())
+                max_favorable_excursion = 0.0
+                max_adverse_excursion = 0.0
+                
+                learner.record_signal_entry(
+                    signal_id=current_signal_id,
+                    symbol=symbol,
+                    interval=interval,
+                    signal_type=signal,
+                    entry_price=entry_price,
+                    stop_loss=float(trading_signal.stop_loss),
+                    tp1=float(trading_signal.take_profit_1),
+                    tp2=float(trading_signal.take_profit_2),
+                    tp3=float(trading_signal.take_profit_3),
+                    indicator_contributions=current_indicator_contributions,
+                    reasons=reasons_list,
+                    market_context=current_market_context
+                )
 
             # Store entry trade in database
             if db:
@@ -551,6 +727,20 @@ def backtest_strategy(
                 "parent_trade_id": parent_trade_id,
             }
             db.insert_trade(trade_data)
+        
+        # Record outcome for self-learning (end of period)
+        if enable_learning and LEARNING_AVAILABLE and learner and current_signal_id:
+            learner.record_signal_exit(
+                signal_id=current_signal_id,
+                outcome="end",
+                exit_price=final_price,
+                profit_loss=profit,
+                duration=len(df) - 1 - entry_index if entry_index else 0
+            )
+    
+    # Save learning state if enabled
+    if enable_learning and LEARNING_AVAILABLE and learner:
+        learner.save_state()
 
     return balance, trade_log, sub_iteration_id
 
@@ -570,7 +760,7 @@ def backtest_strategy(
         use_trailing_stop=True,
         trailing_stop_distance_percent=0.5,  # Keep trailing stop 0.5% below highest price
     )
-    print(f"Final Balance: {final_balance:.2f}")
+    print(f"Final Balance: {final_balance_ts:.2f}")
     print("Trade Log:")
-    for trade in trades:
+    for trade in trades_ts:
         print(trade)
diff --git a/back_tester/trainer.py b/back_tester/trainer.py
index da66c47..1c051d7 100644
--- a/back_tester/trainer.py
+++ b/back_tester/trainer.py
@@ -45,22 +45,27 @@
 db = ClickHouseDB()
 
 # --- Initial Weight Configuration ---
-# Updated for new weights including risk management signals
+# Updated for all 18 weights matching signal_detection.py
 weights = [
-    1.0,  # W_BULLISH_OB
-    1.0,  # W_BEARISH_OB
-    1.0,  # W_BULLISH_BREAKER
-    1.0,  # W_BEARISH_BREAKER
-    0.7,  # W_ABOVE_SUPPORT
-    0.7,  # W_BELOW_RESISTANCE
-    0.5,  # W_FVG_ABOVE
-    0.5,  # W_FVG_BELOW
-    0.8,  # W_TREND
-    1.2,  # W_SWEEP_HIGHS
-    1.2,  # W_SWEEP_LOWS
-    1.5,  # W_STRUCTURE_BREAK
-    0.6,  # W_PIN_BAR
-]  # Updated for new weights
+    1.0,  # W_BULLISH_OB (0)
+    1.0,  # W_BEARISH_OB (1)
+    1.0,  # W_BULLISH_BREAKER (2)
+    1.0,  # W_BEARISH_BREAKER (3)
+    0.7,  # W_ABOVE_SUPPORT (4)
+    0.7,  # W_BELOW_RESISTANCE (5)
+    0.5,  # W_FVG_ABOVE (6)
+    0.5,  # W_FVG_BELOW (7)
+    0.8,  # W_TREND (8)
+    1.2,  # W_SWEEP_HIGHS (9)
+    1.2,  # W_SWEEP_LOWS (10)
+    1.5,  # W_STRUCTURE_BREAK (11)
+    0.6,  # W_PIN_BAR (12)
+    0.6,  # W_ENGULFING (13)
+    1.2,  # W_LIQUIDITY_POOL_ABOVE (14)
+    1.2,  # W_LIQUIDITY_POOL_BELOW (15)
+    1.5,  # W_LIQUIDITY_POOL_ROUND (16)
+    0.6,  # W_RSI_EXTREME (17)
+]
 
 learning_rate = 0.05
 iterations = 1000
@@ -77,6 +82,15 @@
 patience = 50
 history_size = 10
 
+# Weight names for tracking and logging
+WEIGHT_NAMES = [
+    "W_BULLISH_OB", "W_BEARISH_OB", "W_BULLISH_BREAKER", "W_BEARISH_BREAKER",
+    "W_ABOVE_SUPPORT", "W_BELOW_RESISTANCE", "W_FVG_ABOVE", "W_FVG_BELOW",
+    "W_TREND", "W_SWEEP_HIGHS", "W_SWEEP_LOWS", "W_STRUCTURE_BREAK",
+    "W_PIN_BAR", "W_ENGULFING", "W_LIQUIDITY_POOL_ABOVE", "W_LIQUIDITY_POOL_BELOW",
+    "W_LIQUIDITY_POOL_ROUND", "W_RSI_EXTREME"
+]
+
 
 class TrainingMetrics:
     def __init__(self):
@@ -353,7 +367,8 @@ def evaluate_weights(
 
 
 def optimize_weights(
-    weights: List[float], iterations: int, learning_rate: float
+    weights: List[float], iterations: int, learning_rate: float,
+    test_pairs: Optional[List[str]] = None,
 ) -> List[float]:
     """Optimize weights using gradient descent with momentum"""
     best_weights = weights.copy()
@@ -363,7 +378,7 @@ def optimize_weights(
     iteration_id = str(uuid.uuid4())
 
     # Initial evaluation
-    fitness, metrics = evaluate_weights(best_weights, iteration_id=iteration_id)
+    fitness, metrics = evaluate_weights(best_weights, test_pairs=test_pairs, iteration_id=iteration_id)
     if fitness > best_fitness:
         best_fitness = fitness
         logger.info(f"Initial fitness: {fitness:.2f}")
@@ -389,7 +404,7 @@ def optimize_weights(
         test_weights = [max(0, min(2.0, w + p)) for w, p in zip(weights, perturbations)]
 
         # Evaluate fitness
-        fitness, metrics = evaluate_weights(test_weights, iteration_id=iteration_id)
+        fitness, metrics = evaluate_weights(test_weights, test_pairs=test_pairs, iteration_id=iteration_id)
 
         if fitness > best_fitness:
             best_fitness = fitness
@@ -440,9 +455,38 @@ def optimize_weights(
 
 
 if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="Train signal weights for CryptoBot")
+    parser.add_argument(
+        "--symbol", type=str, default=None, help="Focus training on this trading pair (default: all pairs)"
+    )
+    parser.add_argument(
+        "--interval", type=str, default="1h", help="Primary candle interval"
+    )
+    parser.add_argument(
+        "--iterations", type=int, default=1000, help="Number of training iterations"
+    )
+    parser.add_argument(
+        "--risk", type=float, default=1.0, help="Risk percentage per trade"
+    )
+    parser.add_argument(
+        "--learning-rate", type=float, default=0.05, help="Learning rate for weight updates"
+    )
+    args = parser.parse_args()
+
+    # Update global parameters from args
+    iterations = args.iterations
+    risk_percentage = args.risk
+    learning_rate = args.learning_rate
+
     # Train the model
     try:
-        best_weights = optimize_weights(weights, iterations, learning_rate)
+        symbol_label = f"{args.symbol} {args.interval}" if args.symbol else "all pairs"
+        logger.info(f"Starting weight optimization for {symbol_label}")
+        logger.info(f"Iterations: {iterations}, Risk: {risk_percentage}%, Learning rate: {learning_rate}")
+        
+        test_pairs = [args.symbol] if args.symbol else None
+        best_weights = optimize_weights(weights, iterations, learning_rate, test_pairs=test_pairs)
         logger.info(f"Training completed successfully")
 
         # Evaluate final performance
@@ -454,17 +498,22 @@ def optimize_weights(
         weights_file = f"models/weights_{timestamp}.txt"
         os.makedirs("models", exist_ok=True)
 
+
         with open(weights_file, "w") as f:
             f.write(
-                f"# Optimized weights for {args.symbol} {args.interval} at {timestamp}\n"
+                f"# Optimized weights for {symbol_label} at {timestamp}\n"
             )
             f.write(f"# Fitness: {fitness:.4f}\n")
-            f.write(f"# Risk: {risk_percentage}\n\n")
+            f.write(f"# Risk: {risk_percentage}%\n")
+            f.write(f"# Iterations: {iterations}\n\n")
             for i, w in enumerate(best_weights):
-                f.write(f"W{i} = {w:.6f}\n")
+                name = WEIGHT_NAMES[i] if i < len(WEIGHT_NAMES) else f"W{i}"
+                f.write(f"{name} = {w:.6f}\n")
 
         logger.info(f"Weights saved to {weights_file}")
 
     except Exception as e:
         logger.error(f"Training failed: {str(e)}")
+        import traceback
+        traceback.print_exc()
         sys.exit(1)
diff --git a/back_tester/walk_forward_test.py b/back_tester/walk_forward_test.py
new file mode 100644
index 0000000..0e12e12
--- /dev/null
+++ b/back_tester/walk_forward_test.py
@@ -0,0 +1,628 @@
+#!/usr/bin/env python3
+"""
+Walk-Forward Validation Test
+
+This script performs proper out-of-sample testing by:
+1. Splitting historical data into TRAIN (70%) and TEST (30%) periods
+2. Training/optimizing weights ONLY on the training data
+3. Validating the learned weights on the test data (no further learning)
+
+This tells you if your strategy generalizes or if it's overfitted to historical data.
+
+Usage:
+    python walk_forward_test.py [options]
+"""
+
+import os
+import sys
+import argparse
+import json
+from datetime import datetime
+from typing import Dict, List, Tuple, Optional
+from collections import defaultdict
+import numpy as np
+
+# Add project root to path
+project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+if project_dir not in sys.path:
+    sys.path.append(project_dir)
+
+from src.analysis.utils.helpers import fetch_candles
+from src.telegram.signals.detection import (
+    generate_price_prediction_signal_proba,
+    analyze_data,
+    calculate_position_size,
+)
+from src.core.utils import create_true_preferences
+
+# Configuration
+SYMBOLS = ["BTCUSDT", "ETHUSDT"]
+INTERVALS = ["5m", "15m", "30m", "1h", "4h"]
+
+WEIGHT_NAMES = [
+    "W_BULLISH_OB", "W_BEARISH_OB", "W_BULLISH_BREAKER", "W_BEARISH_BREAKER",
+    "W_ABOVE_SUPPORT", "W_BELOW_RESISTANCE", "W_FVG_ABOVE", "W_FVG_BELOW",
+    "W_TREND", "W_SWEEP_HIGHS", "W_SWEEP_LOWS", "W_STRUCTURE_BREAK",
+    "W_PIN_BAR", "W_ENGULFING", "W_LIQUIDITY_POOL_ABOVE", "W_LIQUIDITY_POOL_BELOW",
+    "W_LIQUIDITY_POOL_ROUND", "W_RSI_EXTREME",
+    "W_CONFIDENCE_THRESHOLD"
+]
+
+# Candle counts per interval
+CANDLE_COUNTS = {
+    "5m": 3000,   # ~10 days
+    "15m": 2000,  # ~21 days  
+    "30m": 1500,  # ~31 days
+    "1h": 1200,   # ~50 days
+    "4h": 1000,   # ~167 days
+}
+
+class Colors:
+    H = '\033[95m'  # Header
+    B = '\033[94m'  # Blue
+    C = '\033[96m'  # Cyan
+    G = '\033[92m'  # Green
+    Y = '\033[93m'  # Yellow
+    R = '\033[91m'  # Red
+    E = '\033[0m'   # End
+    BOLD = '\033[1m'
+
+
+class WalkForwardValidator:
+    """Performs walk-forward validation on trading strategy"""
+    
+    def __init__(
+        self,
+        train_ratio: float = 0.7,
+        initial_balance: float = 10000.0,
+        risk_percentage: float = 1.0,
+        learning_iterations: int = 10,
+        learning_rate: float = 0.15,
+        weights_file: str = None,
+    ):
+        self.train_ratio = train_ratio
+        self.initial_balance = initial_balance
+        self.risk_percentage = risk_percentage
+        self.learning_iterations = learning_iterations
+        self.learning_rate = learning_rate
+        self.weights_file = weights_file
+        
+        self.preferences = create_true_preferences()
+        
+        # Results storage
+        self.train_results = {}
+        self.test_results = {}
+        
+        # Pattern tracking
+        self.train_patterns = defaultdict(lambda: {'wins': 0, 'losses': 0, 'profit': 0.0})
+        self.test_patterns = defaultdict(lambda: {'wins': 0, 'losses': 0, 'profit': 0.0})
+        
+        # Pattern keywords for detection
+        self.PATTERN_KEYWORDS = {
+            "bullish order block": "Bullish Order Block",
+            "bearish order block": "Bearish Order Block",
+            "order block": "Order Block",
+            "bullish breaker block": "Bullish Breaker Block",
+            "bearish breaker block": "Bearish Breaker Block",
+            "breaker block": "Breaker Block",
+            "fvg below": "FVG Below",
+            "fvg above": "FVG Above",
+            "unfilled fvg": "FVG",
+            "near support": "Support Level",
+            "near resistance": "Resistance Level",
+            "swept through previous highs": "Liquidity Sweep (Highs)",
+            "swept through previous lows": "Liquidity Sweep (Lows)",
+            "broke structure upward": "Structure Break (Bullish)",
+            "broke structure downward": "Structure Break (Bearish)",
+            "broke structure": "Structure Break",
+            "bullish pin bar": "Bullish Pin Bar",
+            "bearish engulfing": "Bearish Engulfing",
+            "pin bar": "Pin Bar",
+            "engulfing": "Engulfing Pattern",
+            "rsi oversold": "RSI Oversold",
+            "rsi overbought": "RSI Overbought",
+            "in an uptrend": "Uptrend",
+            "in a downtrend": "Downtrend",
+        }
+    
+    def _load_weights(self) -> List[float]:
+        """Load weights from file or use defaults"""
+        if self.weights_file and os.path.exists(self.weights_file):
+            try:
+                with open(self.weights_file, 'r') as f:
+                    data = json.load(f)
+                    weights = data.get('weights', [])
+                    if weights:
+                        print(f"{Colors.G}✓ Loaded weights from {self.weights_file}{Colors.E}")
+                        return weights
+            except Exception as e:
+                print(f"{Colors.Y}Warning: Could not load weights: {e}{Colors.E}")
+        
+        # Default starting weights
+        return [
+            1.3, 1.3, 1.1, 1.1,  # Order blocks, breakers
+            0.8, 0.8, 0.6, 0.6,  # Support/resistance, FVG
+            1.0, 1.4, 1.4, 1.5,  # Trend, sweeps, structure
+            0.7, 0.7, 1.0, 1.0,  # Pin bar, engulfing, liq pools
+            1.2, 0.5, 0.3        # Liq round, RSI, confidence
+        ]
+    
+    def _extract_patterns(self, reason: str) -> List[str]:
+        """Extract patterns from signal reason"""
+        patterns = []
+        reason_lower = reason.lower() if reason else ""
+        for keyword, pattern_name in self.PATTERN_KEYWORDS.items():
+            if keyword in reason_lower and pattern_name not in patterns:
+                patterns.append(pattern_name)
+        return patterns
+    
+    def _run_backtest_on_data(
+        self, 
+        df, 
+        symbol: str, 
+        interval: str,
+        weights: List[float],
+        is_training: bool = True
+    ) -> Dict:
+        """Run backtest on a specific dataframe"""
+        
+        balance = self.initial_balance
+        position = 0
+        entry_price = 0
+        entry_reason = ""
+        trades = []
+        current_trade = None
+        
+        window_size = min(300, len(df) // 3)
+        
+        confidence_threshold = weights[18] if len(weights) > 18 else 0.3
+        confidence_threshold = max(0.1, min(0.9, confidence_threshold))
+        
+        for i in range(window_size, len(df)):
+            current_window = df.iloc[i - window_size:i + 1].copy()
+            current_price = df["Close"].iloc[i]
+            current_time = df.index[i]
+            
+            # Get indicators and signal
+            try:
+                indicators = analyze_data(current_window, self.preferences, 0.05)
+                signal, prob, confidence, reason, trading_signal = (
+                    generate_price_prediction_signal_proba(
+                        current_window, indicators, weights, balance, self.risk_percentage
+                    )
+                )
+            except Exception:
+                continue
+            
+            # Check existing position
+            if position > 0 and current_trade:
+                # Check stop loss
+                if current_price <= current_trade["stop_loss"]:
+                    loss = position * (current_price - entry_price)
+                    balance += position * current_price
+                    
+                    patterns = self._extract_patterns(entry_reason)
+                    pattern_tracker = self.train_patterns if is_training else self.test_patterns
+                    for p in patterns:
+                        pattern_tracker[p]['losses'] += 1
+                        pattern_tracker[p]['profit'] += loss
+                    
+                    trades.append({
+                        "type": "stop_loss",
+                        "entry": entry_price,
+                        "exit": current_price,
+                        "profit": loss,
+                        "patterns": patterns
+                    })
+                    
+                    position = 0
+                    current_trade = None
+                    continue
+                
+                # Check take profits
+                if not current_trade.get("tp1_hit") and current_price >= current_trade["take_profit_1"]:
+                    close_amount = current_trade["initial_position"] / 3
+                    profit = close_amount * (current_price - entry_price)
+                    balance += close_amount * current_price
+                    position -= close_amount
+                    current_trade["tp1_hit"] = True
+                
+                if not current_trade.get("tp2_hit") and current_price >= current_trade["take_profit_2"]:
+                    close_amount = position / 2
+                    profit = close_amount * (current_price - entry_price)
+                    balance += close_amount * current_price
+                    position -= close_amount
+                    current_trade["tp2_hit"] = True
+                
+                if not current_trade.get("tp3_hit") and current_price >= current_trade["take_profit_3"]:
+                    profit = position * (current_price - entry_price)
+                    balance += position * current_price
+                    
+                    patterns = self._extract_patterns(entry_reason)
+                    pattern_tracker = self.train_patterns if is_training else self.test_patterns
+                    for p in patterns:
+                        pattern_tracker[p]['wins'] += 1
+                        pattern_tracker[p]['profit'] += profit
+                    
+                    trades.append({
+                        "type": "take_profit",
+                        "entry": entry_price,
+                        "exit": current_price,
+                        "profit": profit,
+                        "patterns": patterns
+                    })
+                    
+                    position = 0
+                    current_trade = None
+                    continue
+            
+            # New entry
+            if signal == "Bullish" and position == 0 and trading_signal and confidence >= confidence_threshold:
+                position_sizing = calculate_position_size(
+                    balance, self.risk_percentage, current_price, trading_signal.stop_loss
+                )
+                
+                position = position_sizing["position_size"]
+                amount_to_invest = position * current_price
+                
+                # Cap position
+                max_position = self.initial_balance * 0.2
+                if amount_to_invest > max_position:
+                    amount_to_invest = max_position
+                    position = amount_to_invest / current_price
+                
+                if amount_to_invest > balance:
+                    amount_to_invest = balance
+                    position = balance / current_price
+                
+                if position > 0 and amount_to_invest >= 10:
+                    balance -= amount_to_invest
+                    entry_price = current_price
+                    entry_reason = reason
+                    
+                    current_trade = {
+                        "stop_loss": float(trading_signal.stop_loss),
+                        "take_profit_1": float(trading_signal.take_profit_1),
+                        "take_profit_2": float(trading_signal.take_profit_2),
+                        "take_profit_3": float(trading_signal.take_profit_3),
+                        "initial_position": position,
+                        "tp1_hit": False,
+                        "tp2_hit": False,
+                        "tp3_hit": False,
+                    }
+        
+        # Close remaining position
+        if position > 0:
+            final_price = df["Close"].iloc[-1]
+            profit = position * (final_price - entry_price)
+            balance += position * final_price
+            trades.append({
+                "type": "end_close",
+                "entry": entry_price,
+                "exit": final_price,
+                "profit": profit,
+            })
+        
+        total_profit = balance - self.initial_balance
+        wins = len([t for t in trades if t.get("profit", 0) > 0])
+        losses = len([t for t in trades if t.get("profit", 0) < 0])
+        
+        return {
+            "profit": total_profit,
+            "trades": len(trades),
+            "wins": wins,
+            "losses": losses,
+            "win_rate": (wins / len(trades) * 100) if trades else 0,
+            "final_balance": balance
+        }
+    
+    def _optimize_weights(self, train_data: Dict[str, Dict]) -> List[float]:
+        """Run learning iterations on training data to optimize weights"""
+        
+        weights = self._load_weights()
+        best_weights = weights.copy()
+        best_profit = float('-inf')
+        
+        print(f"\n{Colors.C}Starting weight optimization ({self.learning_iterations} iterations)...{Colors.E}")
+        
+        for iteration in range(self.learning_iterations):
+            total_profit = 0
+            total_trades = 0
+            total_wins = 0
+            total_losses = 0
+            
+            for key, data in train_data.items():
+                symbol, interval = key.split("_")
+                result = self._run_backtest_on_data(
+                    data['df'], symbol, interval, weights, is_training=True
+                )
+                total_profit += result['profit']
+                total_trades += result['trades']
+                total_wins += result['wins']
+                total_losses += result['losses']
+            
+            win_rate = (total_wins / total_trades * 100) if total_trades > 0 else 0
+            
+            # Track best
+            if total_profit > best_profit:
+                best_profit = total_profit
+                best_weights = weights.copy()
+            
+            # Update weights based on performance
+            for i in range(len(weights) - 1):  # Exclude confidence threshold
+                noise = np.random.normal(0, self.learning_rate * 0.5)
+                if total_profit > 0:
+                    weights[i] += noise * 0.5
+                else:
+                    weights[i] += noise * 1.5
+                weights[i] = max(0.2, min(2.5, weights[i]))
+            
+            # Adjust confidence threshold
+            if win_rate < 40:
+                weights[-1] = min(0.9, weights[-1] + 0.02)
+            elif win_rate > 60:
+                weights[-1] = max(0.1, weights[-1] - 0.01)
+            weights[-1] = max(0.1, min(0.9, weights[-1]))
+            
+            color = Colors.G if total_profit > 0 else Colors.R
+            print(f"  Iteration {iteration + 1:>2}: {color}${total_profit:>+10.2f}{Colors.E} | "
+                  f"{total_trades} trades | {win_rate:.1f}% WR")
+        
+        print(f"\n{Colors.G}✓ Best training profit: ${best_profit:+.2f}{Colors.E}")
+        return best_weights
+    
+    def run(self):
+        """Run the complete walk-forward validation"""
+        
+        print(f"\n{Colors.H}{'='*70}{Colors.E}")
+        print(f"{Colors.H}{'WALK-FORWARD VALIDATION':^70}{Colors.E}")
+        print(f"{Colors.H}{'='*70}{Colors.E}")
+        
+        print(f"\n{Colors.C}Configuration:{Colors.E}")
+        print(f"  Train/Test Split: {self.train_ratio*100:.0f}% / {(1-self.train_ratio)*100:.0f}%")
+        print(f"  Learning Iterations: {self.learning_iterations}")
+        print(f"  Initial Balance: ${self.initial_balance:,.2f}")
+        print(f"  Symbols: {SYMBOLS}")
+        print(f"  Intervals: {INTERVALS}")
+        
+        # Phase 1: Fetch and split data
+        print(f"\n{Colors.H}{'='*70}{Colors.E}")
+        print(f"{Colors.H}{'PHASE 1: DATA COLLECTION & SPLITTING':^70}{Colors.E}")
+        print(f"{Colors.H}{'='*70}{Colors.E}")
+        
+        train_data = {}
+        test_data = {}
+        
+        for symbol in SYMBOLS:
+            for interval in INTERVALS:
+                candles = CANDLE_COUNTS.get(interval, 1000)
+                print(f"\n  Fetching {symbol} {interval} ({candles} candles)...", end=" ")
+                
+                try:
+                    df = fetch_candles(symbol, candles, interval)
+                    if df is None or df.empty:
+                        print(f"{Colors.R}FAILED{Colors.E}")
+                        continue
+                    
+                    df.sort_index(inplace=True)
+                    
+                    # Split data
+                    split_idx = int(len(df) * self.train_ratio)
+                    train_df = df.iloc[:split_idx].copy()
+                    test_df = df.iloc[split_idx:].copy()
+                    
+                    key = f"{symbol}_{interval}"
+                    train_data[key] = {
+                        'df': train_df,
+                        'start': train_df.index[0],
+                        'end': train_df.index[-1],
+                    }
+                    test_data[key] = {
+                        'df': test_df,
+                        'start': test_df.index[0],
+                        'end': test_df.index[-1],
+                    }
+                    
+                    print(f"{Colors.G}OK{Colors.E} (Train: {len(train_df)}, Test: {len(test_df)})")
+                    
+                except Exception as e:
+                    print(f"{Colors.R}ERROR: {e}{Colors.E}")
+        
+        if not train_data:
+            print(f"\n{Colors.R}No data fetched. Exiting.{Colors.E}")
+            return
+        
+        # Phase 2: Training
+        print(f"\n{Colors.H}{'='*70}{Colors.E}")
+        print(f"{Colors.H}{'PHASE 2: TRAINING (Weight Optimization)':^70}{Colors.E}")
+        print(f"{Colors.H}{'='*70}{Colors.E}")
+        
+        # Show training period
+        all_train_starts = [d['start'] for d in train_data.values()]
+        all_train_ends = [d['end'] for d in train_data.values()]
+        print(f"\n{Colors.C}Training Period:{Colors.E}")
+        print(f"  From: {min(all_train_starts)}")
+        print(f"  To:   {max(all_train_ends)}")
+        
+        optimized_weights = self._optimize_weights(train_data)
+        
+        # Calculate training results with optimized weights
+        print(f"\n{Colors.C}Training Results (with optimized weights):{Colors.E}")
+        train_total_profit = 0
+        train_total_trades = 0
+        train_total_wins = 0
+        train_total_losses = 0
+        
+        for key, data in train_data.items():
+            symbol, interval = key.split("_")
+            result = self._run_backtest_on_data(
+                data['df'], symbol, interval, optimized_weights, is_training=True
+            )
+            train_total_profit += result['profit']
+            train_total_trades += result['trades']
+            train_total_wins += result['wins']
+            train_total_losses += result['losses']
+            
+            color = Colors.G if result['profit'] > 0 else Colors.R
+            print(f"  {symbol} {interval}: {color}${result['profit']:>+10.2f}{Colors.E} | "
+                  f"{result['trades']} trades | {result['win_rate']:.1f}% WR")
+        
+        train_win_rate = (train_total_wins / train_total_trades * 100) if train_total_trades > 0 else 0
+        
+        # Phase 3: Testing (Out-of-Sample)
+        print(f"\n{Colors.H}{'='*70}{Colors.E}")
+        print(f"{Colors.H}{'PHASE 3: TESTING (Out-of-Sample Validation)':^70}{Colors.E}")
+        print(f"{Colors.H}{'='*70}{Colors.E}")
+        
+        all_test_starts = [d['start'] for d in test_data.values()]
+        all_test_ends = [d['end'] for d in test_data.values()]
+        print(f"\n{Colors.C}Test Period (UNSEEN DATA):{Colors.E}")
+        print(f"  From: {min(all_test_starts)}")
+        print(f"  To:   {max(all_test_ends)}")
+        
+        print(f"\n{Colors.C}Test Results:{Colors.E}")
+        test_total_profit = 0
+        test_total_trades = 0
+        test_total_wins = 0
+        test_total_losses = 0
+        
+        for key, data in test_data.items():
+            symbol, interval = key.split("_")
+            result = self._run_backtest_on_data(
+                data['df'], symbol, interval, optimized_weights, is_training=False
+            )
+            test_total_profit += result['profit']
+            test_total_trades += result['trades']
+            test_total_wins += result['wins']
+            test_total_losses += result['losses']
+            
+            color = Colors.G if result['profit'] > 0 else Colors.R
+            print(f"  {symbol} {interval}: {color}${result['profit']:>+10.2f}{Colors.E} | "
+                  f"{result['trades']} trades | {result['win_rate']:.1f}% WR")
+        
+        test_win_rate = (test_total_wins / test_total_trades * 100) if test_total_trades > 0 else 0
+        
+        # Final Report
+        print(f"\n{Colors.H}{'='*70}{Colors.E}")
+        print(f"{Colors.H}{'WALK-FORWARD VALIDATION RESULTS':^70}{Colors.E}")
+        print(f"{Colors.H}{'='*70}{Colors.E}")
+        
+        print(f"\n{Colors.BOLD}Comparison:{Colors.E}")
+        print(f"{'':20} {'TRAINING':>15} {'TESTING':>15} {'DIFF':>15}")
+        print(f"{'-'*65}")
+        
+        train_color = Colors.G if train_total_profit > 0 else Colors.R
+        test_color = Colors.G if test_total_profit > 0 else Colors.R
+        diff_color = Colors.G if test_total_profit > train_total_profit * 0.5 else Colors.Y if test_total_profit > 0 else Colors.R
+        
+        print(f"{'Total Profit':20} {train_color}${train_total_profit:>+14,.2f}{Colors.E} "
+              f"{test_color}${test_total_profit:>+14,.2f}{Colors.E} "
+              f"{diff_color}{(test_total_profit/train_total_profit*100 if train_total_profit else 0):>+14.1f}%{Colors.E}")
+        
+        print(f"{'Total Trades':20} {train_total_trades:>15,} {test_total_trades:>15,} "
+              f"{test_total_trades/train_total_trades*100 if train_total_trades else 0:>14.1f}%")
+        
+        print(f"{'Win Rate':20} {train_win_rate:>14.1f}% {test_win_rate:>14.1f}% "
+              f"{test_win_rate - train_win_rate:>+14.1f}%")
+        
+        if train_total_trades > 0 and test_total_trades > 0:
+            train_avg = train_total_profit / train_total_trades
+            test_avg = test_total_profit / test_total_trades
+            print(f"{'Avg Profit/Trade':20} ${train_avg:>14.2f} ${test_avg:>14.2f} "
+                  f"${test_avg - train_avg:>+14.2f}")
+        
+        # Verdict
+        print(f"\n{Colors.BOLD}Verdict:{Colors.E}")
+        
+        if test_total_profit > 0 and test_total_profit >= train_total_profit * 0.3:
+            print(f"  {Colors.G}✅ STRATEGY GENERALIZES WELL{Colors.E}")
+            print(f"  The strategy maintained {test_total_profit/train_total_profit*100:.1f}% of training profit on unseen data.")
+            print(f"  This suggests the edge is REAL, not overfitted.")
+        elif test_total_profit > 0:
+            print(f"  {Colors.Y}⚠️  MODERATE GENERALIZATION{Colors.E}")
+            print(f"  The strategy is profitable on test data but with reduced performance.")
+            print(f"  Some overfitting may be present.")
+        else:
+            print(f"  {Colors.R}❌ POOR GENERALIZATION - LIKELY OVERFITTED{Colors.E}")
+            print(f"  The strategy lost money on unseen data.")
+            print(f"  The backtest profits were likely due to overfitting, not a real edge.")
+        
+        # Pattern analysis
+        print(f"\n{Colors.BOLD}Pattern Performance (Test Data Only):{Colors.E}")
+        if self.test_patterns:
+            sorted_patterns = sorted(
+                self.test_patterns.items(),
+                key=lambda x: x[1]['profit']
+            )
+            for pattern, stats in sorted_patterns:
+                total = stats['wins'] + stats['losses']
+                if total > 0:
+                    wr = stats['wins'] / total * 100
+                    emoji = "🟢" if stats['profit'] > 0 else "🔴"
+                    print(f"  {emoji} {pattern:<25}: {total:>3} trades | ${stats['profit']:>+10.2f} | {wr:>5.1f}% WR")
+        
+        # Save results
+        results = {
+            "timestamp": datetime.now().isoformat(),
+            "train_ratio": self.train_ratio,
+            "training": {
+                "profit": train_total_profit,
+                "trades": train_total_trades,
+                "wins": train_total_wins,
+                "losses": train_total_losses,
+                "win_rate": train_win_rate,
+            },
+            "testing": {
+                "profit": test_total_profit,
+                "trades": test_total_trades,
+                "wins": test_total_wins,
+                "losses": test_total_losses,
+                "win_rate": test_win_rate,
+            },
+            "optimized_weights": dict(zip(WEIGHT_NAMES, optimized_weights)),
+            "generalization_ratio": test_total_profit / train_total_profit if train_total_profit else 0,
+        }
+        
+        output_path = os.path.join(
+            os.path.dirname(__file__),
+            f"data/walk_forward_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        )
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+        with open(output_path, 'w') as f:
+            json.dump(results, f, indent=2)
+        
+        print(f"\n{Colors.G}✓ Results saved to: {output_path}{Colors.E}")
+        print(f"{Colors.H}{'='*70}{Colors.E}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Walk-Forward Validation Test")
+    parser.add_argument("--train-ratio", type=float, default=0.7,
+                        help="Ratio of data to use for training (default: 0.7)")
+    parser.add_argument("--balance", type=float, default=10000.0,
+                        help="Initial balance (default: 10000)")
+    parser.add_argument("--iterations", type=int, default=10,
+                        help="Learning iterations for training phase (default: 10)")
+    parser.add_argument("--learning-rate", type=float, default=0.15,
+                        help="Learning rate for weight optimization (default: 0.15)")
+    parser.add_argument("--weights", type=str, default=None,
+                        help="Path to starting weights file (optional)")
+    
+    args = parser.parse_args()
+    
+    validator = WalkForwardValidator(
+        train_ratio=args.train_ratio,
+        initial_balance=args.balance,
+        learning_iterations=args.iterations,
+        learning_rate=args.learning_rate,
+        weights_file=args.weights,
+    )
+    
+    validator.run()
+
+
+if __name__ == "__main__":
+    main()
+
+
+
diff --git a/dashboard/README.md b/dashboard/README.md
new file mode 100644
index 0000000..97d8232
--- /dev/null
+++ b/dashboard/README.md
@@ -0,0 +1,121 @@
+# CryptoBot Adaptive Learning Dashboard
+
+A web-based dashboard for visualizing and analyzing the adaptive learning trading system's performance.
+
+## Features
+
+- **Interactive Candlestick Charts**: View price action with TradingView's Lightweight Charts
+- **Signal Visualization**: See all trading signals with entry/exit markers
+- **Indicator Overlays**: Toggle visibility of:
+  - Order Blocks (bullish/bearish)
+  - Breaker Blocks
+  - Support/Resistance levels
+  - Fair Value Gaps (FVG)
+  - Trade levels (Entry, SL, TP1-3)
+- **Trade History**: Browse and filter all historical signals
+- **Performance Metrics**: View aggregate statistics and P/L
+- **Flexible Candle Loading**: Request more candles before a trade to see context
+
+## Quick Start
+
+### Option 1: Using the startup script
+
+```bash
+cd dashboard
+./start_dashboard.sh
+```
+
+### Option 2: Manual start
+
+```bash
+# Activate virtual environment
+source ../venv/bin/activate
+
+# Install dependencies (if needed)
+pip install flask flask-cors
+
+# Start the server
+python app.py
+```
+
+Then open http://localhost:5050 in your browser.
+
+## API Endpoints
+
+| Endpoint | Description |
+|----------|-------------|
+| `GET /api/signals` | List all signals with pagination |
+| `GET /api/signals/<id>` | Get a specific signal by ID |
+| `GET /api/candles` | Fetch candlestick data with indicators |
+| `GET /api/candles/for-signal/<id>` | Fetch candles around a specific signal |
+| `GET /api/stats` | Get aggregate statistics |
+| `GET /api/realtime-tests` | List all realtime test results |
+| `GET /api/weights` | Get current optimized weights |
+| `GET /api/symbols` | List available symbols |
+| `GET /api/intervals` | List available intervals |
+
+### Query Parameters
+
+**GET /api/signals**
+- `page` - Page number (default: 1)
+- `per_page` - Items per page (default: 50)
+- `symbol` - Filter by symbol (e.g., BTCUSDT)
+- `interval` - Filter by interval (e.g., 1h)
+- `outcome` - Filter by outcome (tp1_hit, tp2_hit, tp3_hit, stop_loss, etc.)
+
+**GET /api/candles**
+- `symbol` - Trading pair (default: BTCUSDT)
+- `interval` - Candle interval (default: 1h)
+- `limit` - Number of candles (default: 200)
+- `end_time` - Optional end timestamp for historical data
+
+**GET /api/candles/for-signal/<id>**
+- `before` - Candles before entry (default: 50)
+- `after` - Candles after exit (default: 20)
+
+## Usage Tips
+
+1. **Select a Signal**: Click on any signal in the left sidebar to load its chart
+2. **Load More Context**: Use "Candles Before Trade" to see more price action before the entry
+3. **Toggle Indicators**: Click indicator chips to show/hide different overlays
+4. **Zoom & Pan**: Use mouse scroll to zoom, drag to pan the chart
+5. **Fit Chart**: Click "Fit" button to auto-fit the chart to all data
+
+## Data Sources
+
+The dashboard reads from:
+- `back_tester/data/btc_eth_learning/signals/signal_history.json` - Signal history
+- `back_tester/data/btc_eth_learning/final_weights.json` - Optimized weights
+- `back_tester/data/realtime_test_*.json` - Realtime test results
+
+Live candle data is fetched from the Bybit API.
+
+## Architecture
+
+```
+dashboard/
+├── app.py           # Flask backend API
+├── static/
+│   └── index.html   # Frontend (single-page app)
+├── requirements.txt # Python dependencies
+├── start_dashboard.sh # Startup script
+└── README.md        # This file
+```
+
+## Troubleshooting
+
+**Dashboard won't start**
+- Make sure you're in the project's virtual environment
+- Check that Flask is installed: `pip install flask flask-cors`
+
+**No signals showing**
+- Verify signal_history.json exists in the correct path
+- Check the Flask console for any errors
+
+**Chart not loading**
+- Check browser console for JavaScript errors
+- Ensure you have internet access (for fetching live candle data)
+
+
+
+
diff --git a/dashboard/app.py b/dashboard/app.py
new file mode 100644
index 0000000..ed184dd
--- /dev/null
+++ b/dashboard/app.py
@@ -0,0 +1,667 @@
+#!/usr/bin/env python3
+"""
+Adaptive Learning Dashboard - Flask API Backend
+
+Provides endpoints for:
+- Fetching trade history and signal data from ALL sources
+- Fetching candlestick data with indicators
+- Real-time data updates
+"""
+
+import os
+import sys
+import json
+import csv
+import glob
+import uuid
+from datetime import datetime, timedelta, timezone
+from flask import Flask, jsonify, request, send_from_directory
+from flask_cors import CORS
+
+# Add project root to path
+project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.insert(0, project_dir)
+
+from src.api.data_fetcher import fetch_candles, analyze_data
+from src.telegram.signals.detection import (
+    calculate_rsi,
+    calculate_atr,
+    detect_support_resistance,
+    detect_market_regime,
+    analyze_order_blocks,
+    analyze_breaker_blocks,
+)
+from utils import create_true_preferences
+
+app = Flask(__name__, static_folder='static')
+CORS(app)
+
+# Data paths
+SIGNAL_HISTORY_PATH = os.path.join(project_dir, "back_tester/data/btc_eth_learning/signals/signal_history.json")
+REALTIME_DATA_DIR = os.path.join(project_dir, "back_tester/data")
+REPORTS_DIRS = [
+    os.path.join(project_dir, "reports"),
+    os.path.join(project_dir, "back_tester/reports"),
+]
+WEIGHTS_PATH = os.path.join(project_dir, "back_tester/data/btc_eth_learning/final_weights.json")
+
+# Cache for all trades (loaded once and refreshed on demand)
+_all_trades_cache = None
+_cache_timestamp = None
+
+
+def load_signal_history():
+    """Load signal history from JSON file"""
+    signals = []
+    try:
+        with open(SIGNAL_HISTORY_PATH, 'r') as f:
+            data = json.load(f)
+            for s in data.get('signals', []):
+                s['source'] = 'adaptive_learning'
+                s['source_file'] = 'signal_history.json'
+                signals.append(s)
+    except Exception as e:
+        print(f"Error loading signal history: {e}")
+    return signals
+
+
+def load_realtime_tests():
+    """Load all realtime test result files"""
+    tests = []
+    try:
+        for filename in os.listdir(REALTIME_DATA_DIR):
+            if filename.startswith('realtime_test_') and filename.endswith('.json'):
+                filepath = os.path.join(REALTIME_DATA_DIR, filename)
+                with open(filepath, 'r') as f:
+                    data = json.load(f)
+                    data['filename'] = filename
+                    tests.append(data)
+    except Exception as e:
+        print(f"Error loading realtime tests: {e}")
+    return sorted(tests, key=lambda x: x.get('timestamp', ''), reverse=True)
+
+
+def load_realtime_trades():
+    """Load trades from all realtime test files"""
+    trades = []
+    try:
+        for filename in os.listdir(REALTIME_DATA_DIR):
+            if filename.startswith('realtime_test_') and filename.endswith('.json'):
+                filepath = os.path.join(REALTIME_DATA_DIR, filename)
+                with open(filepath, 'r') as f:
+                    data = json.load(f)
+                    for trade in data.get('trades', []):
+                        # Convert realtime trade format to signal format
+                        signal = {
+                            'signal_id': str(uuid.uuid4()),
+                            'timestamp': trade.get('entry_time', data.get('timestamp')),
+                            'symbol': trade.get('symbol', 'UNKNOWN'),
+                            'interval': trade.get('interval', '1h'),
+                            'signal_type': 'Bullish',  # Realtime only does long trades
+                            'entry_price': trade.get('entry_price', 0),
+                            'exit_price': trade.get('exit_price', 0),
+                            'stop_loss': trade.get('entry_price', 0) * 0.99,  # Approximate
+                            'take_profit_1': trade.get('entry_price', 0) * 1.01,
+                            'take_profit_2': trade.get('entry_price', 0) * 1.02,
+                            'take_profit_3': trade.get('entry_price', 0) * 1.03,
+                            'profit_loss': trade.get('profit_loss', 0),
+                            'profit_loss_percent': trade.get('profit_percent', 0),
+                            'duration_candles': int(trade.get('duration_minutes', 0) / 60),
+                            'outcome': trade.get('exit_type', 'unknown'),
+                            'source': 'realtime_test',
+                            'source_file': filename,
+                            'indicator_contributions': {},
+                            'reasons': [],
+                        }
+                        trades.append(signal)
+    except Exception as e:
+        print(f"Error loading realtime trades: {e}")
+    return trades
+
+
+def load_backtest_trades():
+    """Load trades from all backtesting report CSV files"""
+    trades = []
+    try:
+        # Find all trades.csv files in all reports directories
+        all_csv_files = []
+        for reports_dir in REPORTS_DIRS:
+            pattern = os.path.join(reports_dir, "**/*_trades.csv")
+            all_csv_files.extend(glob.glob(pattern, recursive=True))
+        
+        print(f"Found {len(all_csv_files)} trade CSV files")
+        
+        for csv_path in all_csv_files:
+            try:
+                # Extract symbol and interval from path
+                folder_name = os.path.basename(os.path.dirname(os.path.dirname(csv_path)))
+                parts = folder_name.split('_')
+                if len(parts) >= 2:
+                    symbol = parts[0]
+                    interval = parts[1]
+                else:
+                    symbol = 'UNKNOWN'
+                    interval = '1h'
+                
+                with open(csv_path, 'r') as f:
+                    reader = csv.DictReader(f)
+                    current_entry = None
+                    
+                    for row in reader:
+                        trade_type = row.get('type', '')
+                        
+                        if trade_type == 'entry':
+                            # Start a new trade - convert timestamp to ISO format
+                            raw_ts = row.get('timestamp', '')
+                            # Convert "2023-11-26 07:00:00" to "2023-11-26T07:00:00"
+                            iso_ts = raw_ts.replace(' ', 'T') if raw_ts else ''
+                            
+                            current_entry = {
+                                'signal_id': str(uuid.uuid4()),
+                                'timestamp': iso_ts,
+                                'symbol': symbol,
+                                'interval': interval,
+                                'signal_type': 'Bullish' if 'Bullish' in row.get('signal', '') else 'Bearish',
+                                'entry_price': float(row.get('price', 0) or 0),
+                                'stop_loss': float(row.get('stop_loss', 0) or 0),
+                                'take_profit_1': float(row.get('take_profit_1', 0) or 0),
+                                'take_profit_2': float(row.get('take_profit_2', 0) or 0),
+                                'take_profit_3': float(row.get('take_profit_3', 0) or 0),
+                                'source': 'backtest',
+                                'source_file': os.path.basename(csv_path),
+                                'indicator_contributions': {},
+                                'reasons': [row.get('signal', '')],
+                            }
+                        elif trade_type in ['stop_loss', 'take_profit_1', 'take_profit_2', 'take_profit_3', 'trailing_stop'] and current_entry:
+                            # Complete the trade
+                            exit_price = float(row.get('price', 0) or 0)
+                            profit = float(row.get('profit', 0) or 0)
+                            
+                            current_entry['exit_price'] = exit_price
+                            current_entry['profit_loss'] = profit
+                            current_entry['profit_loss_percent'] = (exit_price - current_entry['entry_price']) / current_entry['entry_price'] * 100 if current_entry['entry_price'] > 0 else 0
+                            current_entry['outcome'] = trade_type
+                            # Convert exit timestamp to ISO format
+                            exit_ts = row.get('timestamp', '')
+                            current_entry['exit_time'] = exit_ts.replace(' ', 'T') if exit_ts else ''
+                            
+                            # Calculate duration in candles (approximate)
+                            try:
+                                entry_idx = int(current_entry.get('entry_index', 0) or 0)
+                                exit_idx = int(row.get('index', 0) or 0)
+                                current_entry['duration_candles'] = exit_idx - entry_idx
+                            except:
+                                current_entry['duration_candles'] = 0
+                            
+                            trades.append(current_entry)
+                            current_entry = None
+                            
+            except Exception as e:
+                print(f"Error loading {csv_path}: {e}")
+                
+    except Exception as e:
+        print(f"Error loading backtest trades: {e}")
+    
+    return trades
+
+
+def load_all_trades(force_refresh=False):
+    """Load and combine trades from all sources"""
+    global _all_trades_cache, _cache_timestamp
+    
+    # Use cache if available and less than 5 minutes old
+    if not force_refresh and _all_trades_cache is not None and _cache_timestamp is not None:
+        if (datetime.now() - _cache_timestamp).total_seconds() < 300:
+            return _all_trades_cache
+    
+    all_trades = []
+    
+    # Load from each source
+    print("Loading trades from all sources...")
+    
+    # 1. Signal history (adaptive learning)
+    signal_trades = load_signal_history()
+    print(f"  - Adaptive learning signals: {len(signal_trades)}")
+    all_trades.extend(signal_trades)
+    
+    # 2. Realtime tests
+    realtime_trades = load_realtime_trades()
+    print(f"  - Realtime test trades: {len(realtime_trades)}")
+    all_trades.extend(realtime_trades)
+    
+    # 3. Backtest reports
+    backtest_trades = load_backtest_trades()
+    print(f"  - Backtest trades: {len(backtest_trades)}")
+    all_trades.extend(backtest_trades)
+    
+    print(f"Total trades loaded: {len(all_trades)}")
+    
+    # Update cache
+    _all_trades_cache = all_trades
+    _cache_timestamp = datetime.now()
+    
+    return all_trades
+
+
+def load_weights():
+    """Load current weights"""
+    try:
+        with open(WEIGHTS_PATH, 'r') as f:
+            return json.load(f)
+    except Exception as e:
+        print(f"Error loading weights: {e}")
+        return {}
+
+
+@app.route('/')
+def index():
+    """Serve the main dashboard page"""
+    return send_from_directory('static', 'index.html')
+
+
+@app.route('/api/signals')
+def get_signals():
+    """Get all signals with pagination from all data sources"""
+    page = request.args.get('page', 1, type=int)
+    per_page = request.args.get('per_page', 50, type=int)
+    symbol = request.args.get('symbol', None)
+    interval = request.args.get('interval', None)
+    outcome = request.args.get('outcome', None)
+    source = request.args.get('source', None)  # New: filter by data source
+    refresh = request.args.get('refresh', 'false').lower() == 'true'
+    
+    # Load all trades from all sources
+    signals = load_all_trades(force_refresh=refresh)
+    
+    # Filter signals
+    if symbol:
+        signals = [s for s in signals if s.get('symbol') == symbol]
+    if interval:
+        signals = [s for s in signals if s.get('interval') == interval]
+    if outcome:
+        signals = [s for s in signals if s.get('outcome') == outcome]
+    if source:
+        signals = [s for s in signals if s.get('source') == source]
+    
+    # Sort by timestamp (most recent first)
+    signals = sorted(signals, key=lambda x: x.get('timestamp', ''), reverse=True)
+    
+    # Paginate
+    total = len(signals)
+    start = (page - 1) * per_page
+    end = start + per_page
+    paginated_signals = signals[start:end]
+    
+    return jsonify({
+        'signals': paginated_signals,
+        'total': total,
+        'page': page,
+        'per_page': per_page,
+        'total_pages': (total + per_page - 1) // per_page
+    })
+
+
+@app.route('/api/signals/<signal_id>')
+def get_signal(signal_id):
+    """Get a specific signal by ID from all sources"""
+    signals = load_all_trades()
+    signal = next((s for s in signals if s.get('signal_id') == signal_id), None)
+    
+    if signal:
+        return jsonify(signal)
+    return jsonify({'error': 'Signal not found'}), 404
+
+
+@app.route('/api/candles')
+def get_candles():
+    """
+    Fetch candlestick data with indicators
+    
+    Query params:
+    - symbol: Trading pair (e.g., BTCUSDT)
+    - interval: Candle interval (e.g., 1h, 15m)
+    - limit: Number of candles (default 200)
+    - end_time: Optional end timestamp (for fetching historical data)
+    """
+    symbol = request.args.get('symbol', 'BTCUSDT')
+    interval = request.args.get('interval', '1h')
+    limit = request.args.get('limit', 200, type=int)
+    end_time = request.args.get('end_time', None)
+    
+    try:
+        if end_time:
+            timestamp = datetime.fromisoformat(end_time.replace('Z', '+00:00')).timestamp()
+        else:
+            timestamp = datetime.now(timezone.utc).timestamp()
+        
+        # Fetch candles
+        df = fetch_candles(symbol, limit, interval, timestamp)
+        
+        if df is None or df.empty:
+            return jsonify({'error': 'Failed to fetch candles'}), 500
+        
+        # Calculate indicators
+        preferences = create_true_preferences()
+        indicators = analyze_data(df, preferences, 0.05)
+        
+        # Calculate additional indicators for the chart
+        rsi = calculate_rsi(df['Close']).fillna(50).tolist()
+        atr = calculate_atr(df).fillna(0).tolist()
+        
+        # Detect support/resistance levels
+        support_levels, resistance_levels = detect_support_resistance(df)
+        
+        # Detect order blocks and breaker blocks
+        order_blocks = analyze_order_blocks(df)
+        breaker_blocks = analyze_breaker_blocks(df)
+        
+        # Market regime
+        market_regime = detect_market_regime(df)
+        
+        # Format candles for response
+        candles = []
+        for i, (idx, row) in enumerate(df.iterrows()):
+            candle = {
+                'time': idx.isoformat() if hasattr(idx, 'isoformat') else str(idx),
+                'timestamp': int(idx.timestamp() * 1000) if hasattr(idx, 'timestamp') else 0,
+                'open': float(row['Open']),
+                'high': float(row['High']),
+                'low': float(row['Low']),
+                'close': float(row['Close']),
+                'volume': float(row['Volume']),
+                'rsi': rsi[i] if i < len(rsi) else 50,
+                'atr': atr[i] if i < len(atr) else 0,
+            }
+            candles.append(candle)
+        
+        # Format indicators
+        indicator_data = {
+            'order_blocks': [],
+            'breaker_blocks': [],
+            'fvgs': [],
+            'liquidity_levels': [],
+            'liquidity_pools': [],
+            'support_levels': support_levels,
+            'resistance_levels': resistance_levels,
+            'market_regime': market_regime.value if hasattr(market_regime, 'value') else str(market_regime),
+        }
+        
+        # Add order blocks
+        for ob in order_blocks:
+            indicator_data['order_blocks'].append({
+                'type': ob['type'],
+                'index': ob['index'],
+                'price': ob['price'],
+                'strength': ob.get('strength', 1.0),
+            })
+        
+        # Add breaker blocks
+        for bb in breaker_blocks:
+            indicator_data['breaker_blocks'].append({
+                'type': bb['type'],
+                'index': bb['index'],
+                'price': bb['price'],
+                'strength': bb.get('strength', 1.0),
+            })
+        
+        # Add FVGs if available
+        if indicators and hasattr(indicators, 'fvgs') and indicators.fvgs and hasattr(indicators.fvgs, 'list'):
+            for fvg in indicators.fvgs.list:
+                indicator_data['fvgs'].append({
+                    'start_index': getattr(fvg, 'start_index', 0),
+                    'end_index': getattr(fvg, 'end_index', 0),
+                    'start_price': getattr(fvg, 'start_price', 0),
+                    'end_price': getattr(fvg, 'end_price', 0),
+                    'type': getattr(fvg, 'type', 'unknown'),
+                })
+        
+        # Add liquidity levels
+        if indicators and hasattr(indicators, 'liquidity_levels') and indicators.liquidity_levels and hasattr(indicators.liquidity_levels, 'list'):
+            for ll in indicators.liquidity_levels.list:
+                indicator_data['liquidity_levels'].append({
+                    'price': getattr(ll, 'price', 0),
+                    'strength': getattr(ll, 'strength', 1.0),
+                    'type': getattr(ll, 'type', 'unknown'),
+                })
+        
+        # Add liquidity pools
+        if indicators and hasattr(indicators, 'liquidity_pools') and indicators.liquidity_pools and hasattr(indicators.liquidity_pools, 'list'):
+            for lp in indicators.liquidity_pools.list:
+                indicator_data['liquidity_pools'].append({
+                    'price': getattr(lp, 'price', 0),
+                    'volume': getattr(lp, 'volume', 0),
+                    'strength': getattr(lp, 'strength', 1.0),
+                })
+        
+        return jsonify({
+            'symbol': symbol,
+            'interval': interval,
+            'candles': candles,
+            'indicators': indicator_data,
+        })
+        
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({'error': str(e)}), 500
+
+
+@app.route('/api/candles/for-signal/<signal_id>')
+def get_candles_for_signal(signal_id):
+    """
+    Fetch candles for displaying a signal's trade.
+    
+    Since backtesting signals don't have actual historical timestamps,
+    we fetch recent candles to visualize the trade pattern.
+    
+    Query params:
+    - before: Number of candles before entry (default 150)
+    - after: Number of candles after exit (default 20)
+    """
+    before = request.args.get('before', 150, type=int)
+    after = request.args.get('after', 20, type=int)
+    
+    # Search in all trades (not just signal_history)
+    all_signals = load_all_trades()
+    signal = next((s for s in all_signals if s.get('signal_id') == signal_id), None)
+    
+    if not signal:
+        return jsonify({'error': 'Signal not found'}), 404
+    
+    symbol = signal.get('symbol', 'BTCUSDT')
+    interval = signal.get('interval', '1h')
+    duration = signal.get('duration_candles', 10) or 10
+    
+    # Calculate total candles needed
+    total_candles = before + duration + after
+    
+    try:
+        # Fetch recent candles (we can't match historical backtesting data,
+        # so we just show recent market data with trade markers)
+        df = fetch_candles(symbol, total_candles, interval)
+        
+        if df is None or df.empty:
+            return jsonify({'error': 'Failed to fetch candles'}), 500
+        
+        # Calculate indicators
+        preferences = create_true_preferences()
+        indicators = analyze_data(df, preferences, 0.05)
+        
+        # Calculate additional indicators
+        rsi = calculate_rsi(df['Close']).fillna(50).tolist()
+        atr = calculate_atr(df).fillna(0).tolist()
+        support_levels, resistance_levels = detect_support_resistance(df)
+        order_blocks = analyze_order_blocks(df)
+        breaker_blocks = analyze_breaker_blocks(df)
+        market_regime = detect_market_regime(df)
+        
+        # Format candles
+        candles = []
+        for i, (idx, row) in enumerate(df.iterrows()):
+            candle = {
+                'time': idx.isoformat() if hasattr(idx, 'isoformat') else str(idx),
+                'timestamp': int(idx.timestamp() * 1000) if hasattr(idx, 'timestamp') else 0,
+                'open': float(row['Open']),
+                'high': float(row['High']),
+                'low': float(row['Low']),
+                'close': float(row['Close']),
+                'volume': float(row['Volume']),
+                'rsi': rsi[i] if i < len(rsi) else 50,
+                'atr': atr[i] if i < len(atr) else 0,
+            }
+            candles.append(candle)
+        
+        # Format indicators
+        indicator_data = {
+            'order_blocks': [{'type': ob['type'], 'index': ob['index'], 'price': ob['price'], 'strength': ob.get('strength', 1.0)} for ob in order_blocks],
+            'breaker_blocks': [{'type': bb['type'], 'index': bb['index'], 'price': bb['price'], 'strength': bb.get('strength', 1.0)} for bb in breaker_blocks],
+            'fvgs': [],
+            'liquidity_levels': [],
+            'liquidity_pools': [],
+            'support_levels': support_levels,
+            'resistance_levels': resistance_levels,
+            'market_regime': market_regime.value if hasattr(market_regime, 'value') else str(market_regime),
+        }
+        
+        # Add FVGs if available
+        if indicators and hasattr(indicators, 'fvgs') and indicators.fvgs and hasattr(indicators.fvgs, 'list'):
+            for fvg in indicators.fvgs.list:
+                indicator_data['fvgs'].append({
+                    'start_index': getattr(fvg, 'start_index', 0),
+                    'end_index': getattr(fvg, 'end_index', 0),
+                    'start_price': getattr(fvg, 'start_price', 0),
+                    'end_price': getattr(fvg, 'end_price', 0),
+                    'type': getattr(fvg, 'type', 'unknown'),
+                })
+        
+        return jsonify({
+            'symbol': symbol,
+            'interval': interval,
+            'candles': candles,
+            'indicators': indicator_data,
+            'signal': signal,
+        })
+        
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({'error': str(e)}), 500
+
+
+@app.route('/api/realtime-tests')
+def get_realtime_tests():
+    """Get all realtime test results"""
+    tests = load_realtime_tests()
+    return jsonify({'tests': tests})
+
+
+@app.route('/api/weights')
+def get_weights():
+    """Get current weights and their names"""
+    weights_data = load_weights()
+    return jsonify(weights_data)
+
+
+@app.route('/api/stats')
+def get_stats():
+    """Get aggregate statistics from all data sources"""
+    signals = load_all_trades()
+    
+    # Calculate stats
+    total_signals = len(signals)
+    outcomes = {}
+    symbols = {}
+    intervals = {}
+    sources = {}
+    total_pnl = 0
+    
+    for s in signals:
+        # Count outcomes
+        outcome = s.get('outcome', 'unknown')
+        outcomes[outcome] = outcomes.get(outcome, 0) + 1
+        
+        # Count by symbol
+        symbol = s.get('symbol', 'unknown')
+        if symbol not in symbols:
+            symbols[symbol] = {'count': 0, 'pnl': 0, 'wins': 0, 'losses': 0}
+        symbols[symbol]['count'] += 1
+        symbols[symbol]['pnl'] += s.get('profit_loss', 0)
+        if s.get('profit_loss', 0) > 0:
+            symbols[symbol]['wins'] += 1
+        elif s.get('profit_loss', 0) < 0:
+            symbols[symbol]['losses'] += 1
+        
+        # Count by interval
+        interval = s.get('interval', 'unknown')
+        if interval not in intervals:
+            intervals[interval] = {'count': 0, 'pnl': 0, 'wins': 0, 'losses': 0}
+        intervals[interval]['count'] += 1
+        intervals[interval]['pnl'] += s.get('profit_loss', 0)
+        if s.get('profit_loss', 0) > 0:
+            intervals[interval]['wins'] += 1
+        elif s.get('profit_loss', 0) < 0:
+            intervals[interval]['losses'] += 1
+        
+        # Count by source
+        source = s.get('source', 'unknown')
+        if source not in sources:
+            sources[source] = {'count': 0, 'pnl': 0, 'wins': 0, 'losses': 0}
+        sources[source]['count'] += 1
+        sources[source]['pnl'] += s.get('profit_loss', 0)
+        if s.get('profit_loss', 0) > 0:
+            sources[source]['wins'] += 1
+        elif s.get('profit_loss', 0) < 0:
+            sources[source]['losses'] += 1
+        
+        total_pnl += s.get('profit_loss', 0)
+    
+    return jsonify({
+        'total_signals': total_signals,
+        'total_pnl': total_pnl,
+        'outcomes': outcomes,
+        'by_symbol': symbols,
+        'by_interval': intervals,
+        'by_source': sources,
+    })
+
+
+@app.route('/api/symbols')
+def get_symbols():
+    """Get list of available symbols from all sources"""
+    signals = load_all_trades()
+    symbols = list(set(s.get('symbol', 'BTCUSDT') for s in signals if s.get('symbol')))
+    return jsonify({'symbols': sorted(symbols)})
+
+
+@app.route('/api/intervals')
+def get_intervals():
+    """Get list of available intervals from all sources"""
+    signals = load_all_trades()
+    intervals = list(set(s.get('interval', '1h') for s in signals if s.get('interval')))
+    # Sort intervals by duration
+    interval_order = ['1m', '5m', '15m', '30m', '1h', '4h', '1d']
+    intervals = sorted(intervals, key=lambda x: interval_order.index(x) if x in interval_order else 999)
+    return jsonify({'intervals': intervals})
+
+
+@app.route('/api/sources')
+def get_sources():
+    """Get list of available data sources"""
+    signals = load_all_trades()
+    sources = list(set(s.get('source', 'unknown') for s in signals if s.get('source')))
+    source_info = {
+        'adaptive_learning': 'Adaptive Learning Signals',
+        'realtime_test': 'Realtime Test Trades',
+        'backtest': 'Backtesting Reports'
+    }
+    return jsonify({
+        'sources': [{'id': s, 'name': source_info.get(s, s)} for s in sorted(sources)]
+    })
+
+
+if __name__ == '__main__':
+    print("Starting Adaptive Learning Dashboard...")
+    print(f"Signal history path: {SIGNAL_HISTORY_PATH}")
+    print(f"Realtime data dir: {REALTIME_DATA_DIR}")
+    app.run(host='0.0.0.0', port=5050, debug=True)
+
diff --git a/dashboard/requirements.txt b/dashboard/requirements.txt
new file mode 100644
index 0000000..48d59f7
--- /dev/null
+++ b/dashboard/requirements.txt
@@ -0,0 +1,7 @@
+# Dashboard dependencies
+flask>=2.3.0
+flask-cors>=4.0.0
+
+
+
+
diff --git a/dashboard/start_dashboard.sh b/dashboard/start_dashboard.sh
new file mode 100755
index 0000000..87e9e6d
--- /dev/null
+++ b/dashboard/start_dashboard.sh
@@ -0,0 +1,26 @@
+#!/bin/bash
+# Start the Adaptive Learning Dashboard
+
+# Get the directory where this script is located
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+PROJECT_DIR="$( cd "$SCRIPT_DIR/.." && pwd )"
+
+# Activate virtual environment if it exists
+if [ -d "$PROJECT_DIR/venv" ]; then
+    source "$PROJECT_DIR/venv/bin/activate"
+fi
+
+# Install requirements if needed
+pip install -q flask flask-cors
+
+# Start the dashboard
+echo "🚀 Starting CryptoBot Adaptive Learning Dashboard..."
+echo "📊 Open http://localhost:5050 in your browser"
+echo ""
+
+cd "$SCRIPT_DIR"
+python app.py
+
+
+
+
diff --git a/dashboard/static/index.html b/dashboard/static/index.html
new file mode 100644
index 0000000..05874a8
--- /dev/null
+++ b/dashboard/static/index.html
@@ -0,0 +1,1570 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>CryptoBot Adaptive Learning Dashboard</title>
+    
+    <!-- Lightweight Charts by TradingView -->
+    <script src="https://unpkg.com/lightweight-charts@4.1.0/dist/lightweight-charts.standalone.production.js"></script>
+    
+    <!-- Google Fonts - JetBrains Mono & Space Grotesk alternative: Outfit -->
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Outfit:wght@300;400;500;600;700&family=JetBrains+Mono:wght@400;500;600&display=swap" rel="stylesheet">
+    
+    <style>
+        :root {
+            --bg-primary: #0a0e17;
+            --bg-secondary: #111827;
+            --bg-tertiary: #1a2234;
+            --bg-card: #151c2c;
+            --accent-primary: #00d4aa;
+            --accent-secondary: #00a8ff;
+            --accent-warning: #ffd93d;
+            --accent-danger: #ff4757;
+            --accent-success: #26de81;
+            --text-primary: #f0f4f8;
+            --text-secondary: #8b9dc3;
+            --text-muted: #5a6a8a;
+            --border-color: #2a3650;
+            --chart-bullish: #26de81;
+            --chart-bearish: #ff4757;
+        }
+
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Outfit', sans-serif;
+            background: var(--bg-primary);
+            color: var(--text-primary);
+            min-height: 100vh;
+            overflow-x: hidden;
+        }
+
+        /* Animated gradient background */
+        body::before {
+            content: '';
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background: 
+                radial-gradient(ellipse at 20% 20%, rgba(0, 212, 170, 0.08) 0%, transparent 50%),
+                radial-gradient(ellipse at 80% 80%, rgba(0, 168, 255, 0.08) 0%, transparent 50%),
+                radial-gradient(ellipse at 50% 50%, rgba(0, 0, 0, 0.3) 0%, transparent 100%);
+            pointer-events: none;
+            z-index: 0;
+        }
+
+        .app-container {
+            position: relative;
+            z-index: 1;
+            display: grid;
+            grid-template-columns: 320px 1fr;
+            grid-template-rows: 70px 1fr;
+            min-height: 100vh;
+            gap: 0;
+        }
+
+        /* Header */
+        .header {
+            grid-column: 1 / -1;
+            background: rgba(17, 24, 39, 0.95);
+            backdrop-filter: blur(20px);
+            border-bottom: 1px solid var(--border-color);
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            padding: 0 24px;
+        }
+
+        .logo {
+            display: flex;
+            align-items: center;
+            gap: 12px;
+        }
+
+        .logo-icon {
+            width: 40px;
+            height: 40px;
+            background: linear-gradient(135deg, var(--accent-primary), var(--accent-secondary));
+            border-radius: 10px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 20px;
+        }
+
+        .logo-text {
+            font-size: 1.4rem;
+            font-weight: 600;
+            background: linear-gradient(135deg, var(--accent-primary), var(--accent-secondary));
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            background-clip: text;
+        }
+
+        .header-stats {
+            display: flex;
+            gap: 32px;
+        }
+
+        .stat-item {
+            text-align: center;
+        }
+
+        .stat-label {
+            font-size: 0.75rem;
+            color: var(--text-muted);
+            text-transform: uppercase;
+            letter-spacing: 1px;
+            margin-bottom: 4px;
+        }
+
+        .stat-value {
+            font-family: 'JetBrains Mono', monospace;
+            font-size: 1.1rem;
+            font-weight: 600;
+        }
+
+        .stat-value.positive { color: var(--accent-success); }
+        .stat-value.negative { color: var(--accent-danger); }
+
+        /* Sidebar */
+        .sidebar {
+            background: rgba(17, 24, 39, 0.85);
+            backdrop-filter: blur(20px);
+            border-right: 1px solid var(--border-color);
+            overflow-y: auto;
+            display: flex;
+            flex-direction: column;
+        }
+
+        .sidebar-section {
+            padding: 20px;
+            border-bottom: 1px solid var(--border-color);
+        }
+
+        .sidebar-section:last-child {
+            border-bottom: none;
+            flex: 1;
+            display: flex;
+            flex-direction: column;
+        }
+
+        .section-title {
+            font-size: 0.8rem;
+            color: var(--text-muted);
+            text-transform: uppercase;
+            letter-spacing: 1.5px;
+            margin-bottom: 16px;
+            display: flex;
+            align-items: center;
+            gap: 8px;
+        }
+
+        .section-title::before {
+            content: '';
+            width: 3px;
+            height: 16px;
+            background: linear-gradient(135deg, var(--accent-primary), var(--accent-secondary));
+            border-radius: 2px;
+        }
+
+        /* Controls */
+        .control-group {
+            margin-bottom: 16px;
+        }
+
+        .control-label {
+            display: block;
+            font-size: 0.85rem;
+            color: var(--text-secondary);
+            margin-bottom: 8px;
+        }
+
+        select, input[type="number"] {
+            width: 100%;
+            padding: 10px 14px;
+            background: var(--bg-tertiary);
+            border: 1px solid var(--border-color);
+            border-radius: 8px;
+            color: var(--text-primary);
+            font-family: 'Outfit', sans-serif;
+            font-size: 0.9rem;
+            transition: all 0.2s ease;
+        }
+
+        select:hover, input[type="number"]:hover {
+            border-color: var(--accent-primary);
+        }
+
+        select:focus, input[type="number"]:focus {
+            outline: none;
+            border-color: var(--accent-primary);
+            box-shadow: 0 0 0 3px rgba(0, 212, 170, 0.1);
+        }
+
+        option {
+            background: var(--bg-secondary);
+            color: var(--text-primary);
+        }
+
+        .btn {
+            width: 100%;
+            padding: 12px 20px;
+            border: none;
+            border-radius: 8px;
+            font-family: 'Outfit', sans-serif;
+            font-size: 0.9rem;
+            font-weight: 500;
+            cursor: pointer;
+            transition: all 0.2s ease;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            gap: 8px;
+        }
+
+        .btn-primary {
+            background: linear-gradient(135deg, var(--accent-primary), var(--accent-secondary));
+            color: var(--bg-primary);
+        }
+
+        .btn-primary:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 8px 20px rgba(0, 212, 170, 0.3);
+        }
+
+        .btn-secondary {
+            background: var(--bg-tertiary);
+            border: 1px solid var(--border-color);
+            color: var(--text-primary);
+        }
+
+        .btn-secondary:hover {
+            border-color: var(--accent-primary);
+            background: rgba(0, 212, 170, 0.1);
+        }
+
+        /* Trade List */
+        .trade-list {
+            flex: 1;
+            overflow-y: auto;
+            margin-top: 12px;
+        }
+
+        .trade-item {
+            padding: 14px;
+            background: var(--bg-tertiary);
+            border-radius: 10px;
+            margin-bottom: 10px;
+            cursor: pointer;
+            border: 1px solid transparent;
+            transition: all 0.2s ease;
+        }
+
+        .trade-item:hover {
+            border-color: var(--accent-primary);
+            background: rgba(0, 212, 170, 0.05);
+        }
+
+        .trade-item.active {
+            border-color: var(--accent-primary);
+            background: rgba(0, 212, 170, 0.1);
+        }
+
+        .trade-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 8px;
+        }
+
+        .trade-symbol {
+            font-weight: 600;
+            font-size: 0.95rem;
+        }
+
+        .trade-interval {
+            font-size: 0.75rem;
+            color: var(--text-muted);
+            background: var(--bg-secondary);
+            padding: 3px 8px;
+            border-radius: 4px;
+        }
+
+        .trade-pnl {
+            font-family: 'JetBrains Mono', monospace;
+            font-weight: 600;
+        }
+
+        .trade-pnl.positive { color: var(--accent-success); }
+        .trade-pnl.negative { color: var(--accent-danger); }
+
+        .trade-meta {
+            display: flex;
+            justify-content: space-between;
+            font-size: 0.8rem;
+            color: var(--text-muted);
+        }
+
+        .trade-outcome {
+            display: inline-flex;
+            align-items: center;
+            gap: 4px;
+            padding: 2px 6px;
+            border-radius: 4px;
+            font-size: 0.7rem;
+            text-transform: uppercase;
+            letter-spacing: 0.5px;
+        }
+
+        .trade-outcome.tp1_hit, .trade-outcome.tp2_hit, .trade-outcome.tp3_hit, .trade-outcome.trailing_stop {
+            background: rgba(38, 222, 129, 0.15);
+            color: var(--accent-success);
+        }
+
+        .trade-outcome.stop_loss {
+            background: rgba(255, 71, 87, 0.15);
+            color: var(--accent-danger);
+        }
+
+        .trade-outcome.pending {
+            background: rgba(255, 217, 61, 0.15);
+            color: var(--accent-warning);
+        }
+
+        /* Main Content */
+        .main-content {
+            display: flex;
+            flex-direction: column;
+            overflow: hidden;
+        }
+
+        /* Chart Container */
+        .chart-container {
+            flex: 1;
+            position: relative;
+            background: var(--bg-secondary);
+            min-height: 500px;
+        }
+
+        #main-chart {
+            width: 100%;
+            height: 100%;
+        }
+
+        .chart-toolbar {
+            position: absolute;
+            top: 16px;
+            right: 16px;
+            display: flex;
+            gap: 8px;
+            z-index: 10;
+        }
+
+        .chart-btn {
+            padding: 8px 14px;
+            background: rgba(26, 34, 52, 0.9);
+            backdrop-filter: blur(10px);
+            border: 1px solid var(--border-color);
+            border-radius: 6px;
+            color: var(--text-secondary);
+            font-size: 0.8rem;
+            cursor: pointer;
+            transition: all 0.2s ease;
+        }
+
+        .chart-btn:hover {
+            border-color: var(--accent-primary);
+            color: var(--accent-primary);
+        }
+
+        .chart-btn.active {
+            background: rgba(0, 212, 170, 0.15);
+            border-color: var(--accent-primary);
+            color: var(--accent-primary);
+        }
+
+        /* Info Panel */
+        .info-panel {
+            background: rgba(17, 24, 39, 0.95);
+            backdrop-filter: blur(20px);
+            border-top: 1px solid var(--border-color);
+            padding: 20px 24px;
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 20px;
+        }
+
+        .info-card {
+            background: var(--bg-tertiary);
+            border-radius: 10px;
+            padding: 16px;
+            border: 1px solid var(--border-color);
+        }
+
+        .info-card-title {
+            font-size: 0.75rem;
+            color: var(--text-muted);
+            text-transform: uppercase;
+            letter-spacing: 1px;
+            margin-bottom: 12px;
+        }
+
+        .info-card-content {
+            font-family: 'JetBrains Mono', monospace;
+        }
+
+        .info-row {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            padding: 6px 0;
+            border-bottom: 1px solid var(--border-color);
+        }
+
+        .info-row:last-child {
+            border-bottom: none;
+        }
+
+        .info-label {
+            color: var(--text-secondary);
+            font-size: 0.85rem;
+        }
+
+        .info-value {
+            font-weight: 500;
+            font-size: 0.9rem;
+        }
+
+        /* Legend */
+        .legend {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 16px;
+            margin-top: 8px;
+        }
+
+        .legend-item {
+            display: flex;
+            align-items: center;
+            gap: 6px;
+            font-size: 0.8rem;
+            color: var(--text-secondary);
+        }
+
+        .legend-marker {
+            width: 12px;
+            height: 12px;
+            border-radius: 3px;
+        }
+
+        .legend-marker.entry { background: var(--accent-primary); }
+        .legend-marker.exit { background: var(--accent-danger); }
+        .legend-marker.sl { background: #ff4757; border: 2px dashed #ff4757; background: none; }
+        .legend-marker.tp { background: var(--accent-success); }
+        .legend-marker.ob-bullish { background: rgba(0, 212, 170, 0.4); }
+        .legend-marker.ob-bearish { background: rgba(255, 71, 87, 0.4); }
+        .legend-marker.support { background: #3498db; }
+        .legend-marker.resistance { background: #e74c3c; }
+
+        /* Pagination */
+        .pagination {
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            gap: 8px;
+            padding: 12px;
+            background: var(--bg-tertiary);
+            border-radius: 8px;
+            margin-top: 12px;
+        }
+
+        .pagination-btn {
+            padding: 6px 12px;
+            background: var(--bg-secondary);
+            border: 1px solid var(--border-color);
+            border-radius: 6px;
+            color: var(--text-secondary);
+            font-size: 0.8rem;
+            cursor: pointer;
+            transition: all 0.2s ease;
+        }
+
+        .pagination-btn:hover:not(:disabled) {
+            border-color: var(--accent-primary);
+            color: var(--accent-primary);
+        }
+
+        .pagination-btn:disabled {
+            opacity: 0.5;
+            cursor: not-allowed;
+        }
+
+        .pagination-info {
+            font-size: 0.8rem;
+            color: var(--text-muted);
+        }
+
+        /* Loading indicator */
+        .loading {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            height: 100%;
+            color: var(--text-muted);
+        }
+
+        .spinner {
+            width: 40px;
+            height: 40px;
+            border: 3px solid var(--border-color);
+            border-top-color: var(--accent-primary);
+            border-radius: 50%;
+            animation: spin 1s linear infinite;
+        }
+
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+
+        /* Scrollbar */
+        ::-webkit-scrollbar {
+            width: 8px;
+        }
+
+        ::-webkit-scrollbar-track {
+            background: var(--bg-tertiary);
+        }
+
+        ::-webkit-scrollbar-thumb {
+            background: var(--border-color);
+            border-radius: 4px;
+        }
+
+        ::-webkit-scrollbar-thumb:hover {
+            background: var(--text-muted);
+        }
+
+        /* Indicator toggles */
+        .indicator-toggles {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 8px;
+        }
+
+        .toggle-chip {
+            padding: 6px 12px;
+            background: var(--bg-tertiary);
+            border: 1px solid var(--border-color);
+            border-radius: 20px;
+            font-size: 0.75rem;
+            cursor: pointer;
+            transition: all 0.2s ease;
+            color: var(--text-secondary);
+        }
+
+        .toggle-chip:hover {
+            border-color: var(--accent-primary);
+        }
+
+        .toggle-chip.active {
+            background: rgba(0, 212, 170, 0.15);
+            border-color: var(--accent-primary);
+            color: var(--accent-primary);
+        }
+
+        /* Toast notification */
+        .toast {
+            position: fixed;
+            bottom: 24px;
+            right: 24px;
+            padding: 14px 24px;
+            background: var(--bg-tertiary);
+            border: 1px solid var(--border-color);
+            border-radius: 10px;
+            color: var(--text-primary);
+            font-size: 0.9rem;
+            z-index: 1000;
+            transform: translateY(100px);
+            opacity: 0;
+            transition: all 0.3s ease;
+        }
+
+        .toast.show {
+            transform: translateY(0);
+            opacity: 1;
+        }
+
+        .toast.success {
+            border-color: var(--accent-success);
+        }
+
+        .toast.error {
+            border-color: var(--accent-danger);
+        }
+    </style>
+</head>
+<body>
+    <div class="app-container">
+        <!-- Header -->
+        <header class="header">
+            <div class="logo">
+                <div class="logo-icon">📈</div>
+                <span class="logo-text">CryptoBot Dashboard</span>
+            </div>
+            <div class="header-stats">
+                <div class="stat-item">
+                    <div class="stat-label">Total Signals</div>
+                    <div class="stat-value" id="total-signals">-</div>
+                </div>
+                <div class="stat-item">
+                    <div class="stat-label">Win Rate</div>
+                    <div class="stat-value" id="win-rate">-</div>
+                </div>
+                <div class="stat-item">
+                    <div class="stat-label">Total P/L</div>
+                    <div class="stat-value" id="total-pnl">-</div>
+                </div>
+                <div class="stat-item">
+                    <div class="stat-label">Market Regime</div>
+                    <div class="stat-value" id="market-regime">-</div>
+                </div>
+            </div>
+        </header>
+
+        <!-- Sidebar -->
+        <aside class="sidebar">
+            <!-- Filters -->
+            <div class="sidebar-section">
+                <div class="section-title">Filters</div>
+                <div class="control-group">
+                    <label class="control-label">Data Source</label>
+                    <select id="source-filter">
+                        <option value="">All Sources</option>
+                    </select>
+                </div>
+                <div class="control-group">
+                    <label class="control-label">Symbol</label>
+                    <select id="symbol-filter">
+                        <option value="">All Symbols</option>
+                    </select>
+                </div>
+                <div class="control-group">
+                    <label class="control-label">Interval</label>
+                    <select id="interval-filter">
+                        <option value="">All Intervals</option>
+                    </select>
+                </div>
+                <div class="control-group">
+                    <label class="control-label">Outcome</label>
+                    <select id="outcome-filter">
+                        <option value="">All Outcomes</option>
+                        <option value="tp1_hit">TP1 Hit</option>
+                        <option value="tp2_hit">TP2 Hit</option>
+                        <option value="tp3_hit">TP3 Hit</option>
+                        <option value="take_profit_1">Take Profit 1</option>
+                        <option value="take_profit_2">Take Profit 2</option>
+                        <option value="take_profit_3">Take Profit 3</option>
+                        <option value="trailing_stop">Trailing Stop</option>
+                        <option value="stop_loss">Stop Loss</option>
+                        <option value="end_of_period">End of Period</option>
+                        <option value="pending">Pending</option>
+                    </select>
+                </div>
+                <button class="btn btn-secondary" onclick="applyFilters()">Apply Filters</button>
+                <button class="btn btn-secondary" style="margin-top: 8px;" onclick="refreshData()">🔄 Refresh Data</button>
+            </div>
+
+            <!-- Chart Settings -->
+            <div class="sidebar-section">
+                <div class="section-title">Chart Settings</div>
+                <div class="control-group">
+                    <label class="control-label">Candles Before Trade</label>
+                    <input type="number" id="candles-before" value="150" min="10" max="500">
+                </div>
+                <div class="control-group">
+                    <label class="control-label">Candles After Trade</label>
+                    <input type="number" id="candles-after" value="20" min="5" max="100">
+                </div>
+                <button class="btn btn-primary" onclick="refreshChart()">Refresh Chart</button>
+            </div>
+
+            <!-- Indicators -->
+            <div class="sidebar-section">
+                <div class="section-title">Indicators</div>
+                <div class="indicator-toggles">
+                    <span class="toggle-chip active" data-indicator="orderBlocks" onclick="toggleIndicator(this)">Order Blocks</span>
+                    <span class="toggle-chip active" data-indicator="breakerBlocks" onclick="toggleIndicator(this)">Breakers</span>
+                    <span class="toggle-chip active" data-indicator="support" onclick="toggleIndicator(this)">Support</span>
+                    <span class="toggle-chip active" data-indicator="resistance" onclick="toggleIndicator(this)">Resistance</span>
+                    <span class="toggle-chip active" data-indicator="fvg" onclick="toggleIndicator(this)">FVG</span>
+                    <span class="toggle-chip active" data-indicator="levels" onclick="toggleIndicator(this)">Trade Levels</span>
+                </div>
+            </div>
+
+            <!-- Trade List -->
+            <div class="sidebar-section">
+                <div class="section-title">Signals</div>
+                <div class="trade-list" id="trade-list">
+                    <div class="loading">
+                        <div class="spinner"></div>
+                    </div>
+                </div>
+                <div class="pagination">
+                    <button class="pagination-btn" id="prev-page" onclick="changePage(-1)" disabled>Prev</button>
+                    <span class="pagination-info" id="pagination-info">Page 1</span>
+                    <button class="pagination-btn" id="next-page" onclick="changePage(1)">Next</button>
+                </div>
+            </div>
+        </aside>
+
+        <!-- Main Content -->
+        <main class="main-content">
+            <!-- Chart -->
+            <div class="chart-container">
+                <div id="main-chart"></div>
+                <div class="chart-toolbar">
+                    <button class="chart-btn" onclick="chart.timeScale().fitContent()">Fit</button>
+                    <button class="chart-btn" onclick="loadMoreCandles()">+ Before</button>
+                    <button class="chart-btn" onclick="loadMoreCandlesAfter()">+ After</button>
+                    <button class="chart-btn" onclick="refreshChart()">Refresh</button>
+                </div>
+            </div>
+
+            <!-- Info Panel -->
+            <div class="info-panel" id="info-panel">
+                <div class="info-card">
+                    <div class="info-card-title">Signal Details</div>
+                    <div class="info-card-content" id="signal-details">
+                        <div class="info-row">
+                            <span class="info-label">Select a signal to view details</span>
+                        </div>
+                    </div>
+                </div>
+                <div class="info-card">
+                    <div class="info-card-title">Price Levels</div>
+                    <div class="info-card-content" id="price-levels">
+                        <div class="info-row">
+                            <span class="info-label">Entry</span>
+                            <span class="info-value" id="entry-price">-</span>
+                        </div>
+                        <div class="info-row">
+                            <span class="info-label">Stop Loss</span>
+                            <span class="info-value" style="color: var(--accent-danger)" id="stop-loss">-</span>
+                        </div>
+                        <div class="info-row">
+                            <span class="info-label">TP1</span>
+                            <span class="info-value" style="color: var(--accent-success)" id="tp1">-</span>
+                        </div>
+                        <div class="info-row">
+                            <span class="info-label">TP2</span>
+                            <span class="info-value" style="color: var(--accent-success)" id="tp2">-</span>
+                        </div>
+                        <div class="info-row">
+                            <span class="info-label">TP3</span>
+                            <span class="info-value" style="color: var(--accent-success)" id="tp3">-</span>
+                        </div>
+                    </div>
+                </div>
+                <div class="info-card">
+                    <div class="info-card-title">Performance</div>
+                    <div class="info-card-content" id="performance-details">
+                        <div class="info-row">
+                            <span class="info-label">P/L</span>
+                            <span class="info-value" id="pnl-value">-</span>
+                        </div>
+                        <div class="info-row">
+                            <span class="info-label">P/L %</span>
+                            <span class="info-value" id="pnl-percent">-</span>
+                        </div>
+                        <div class="info-row">
+                            <span class="info-label">Duration</span>
+                            <span class="info-value" id="duration">-</span>
+                        </div>
+                        <div class="info-row">
+                            <span class="info-label">Outcome</span>
+                            <span class="info-value" id="outcome">-</span>
+                        </div>
+                    </div>
+                </div>
+                <div class="info-card">
+                    <div class="info-card-title">Legend</div>
+                    <div class="legend">
+                        <div class="legend-item"><span class="legend-marker" style="background: linear-gradient(to bottom, rgba(38,222,129,0.4), rgba(38,222,129,0.1));"></span> Trade Zone (Win)</div>
+                        <div class="legend-item"><span class="legend-marker" style="background: linear-gradient(to bottom, rgba(255,71,87,0.4), rgba(255,71,87,0.1));"></span> Trade Zone (Loss)</div>
+                        <div class="legend-item"><span class="legend-marker entry"></span> Entry Price</div>
+                        <div class="legend-item"><span class="legend-marker exit"></span> Exit Price</div>
+                        <div class="legend-item"><span class="legend-marker sl"></span> Stop Loss</div>
+                        <div class="legend-item"><span class="legend-marker tp"></span> Take Profit</div>
+                        <div class="legend-item"><span class="legend-marker ob-bullish"></span> Bullish OB</div>
+                        <div class="legend-item"><span class="legend-marker ob-bearish"></span> Bearish OB</div>
+                    </div>
+                </div>
+            </div>
+        </main>
+    </div>
+
+    <!-- Toast -->
+    <div class="toast" id="toast"></div>
+
+    <script>
+        // API Base URL
+        const API_URL = '';
+
+        // State
+        let chart = null;
+        let candleSeries = null;
+        let volumeSeries = null;
+        let tradeZoneSeries = null;  // For highlighting trade duration
+        let entryLineSeries = null;  // Vertical line at entry
+        let exitLineSeries = null;   // Vertical line at exit
+        let signals = [];
+        let currentSignal = null;
+        let currentPage = 1;
+        let totalPages = 1;
+        let markers = [];
+        let priceLines = [];
+        
+        // Indicator visibility
+        let indicatorVisibility = {
+            orderBlocks: true,
+            breakerBlocks: true,
+            support: true,
+            resistance: true,
+            fvg: true,
+            levels: true
+        };
+
+        // Initialize chart
+        function initChart() {
+            const container = document.getElementById('main-chart');
+            
+            chart = LightweightCharts.createChart(container, {
+                layout: {
+                    background: { type: 'solid', color: '#111827' },
+                    textColor: '#8b9dc3',
+                },
+                grid: {
+                    vertLines: { color: 'rgba(42, 54, 80, 0.5)' },
+                    horzLines: { color: 'rgba(42, 54, 80, 0.5)' },
+                },
+                crosshair: {
+                    mode: LightweightCharts.CrosshairMode.Normal,
+                    vertLine: {
+                        color: 'rgba(0, 212, 170, 0.4)',
+                        width: 1,
+                        style: LightweightCharts.LineStyle.Dashed,
+                    },
+                    horzLine: {
+                        color: 'rgba(0, 212, 170, 0.4)',
+                        width: 1,
+                        style: LightweightCharts.LineStyle.Dashed,
+                    },
+                },
+                timeScale: {
+                    borderColor: '#2a3650',
+                    timeVisible: true,
+                    secondsVisible: false,
+                },
+                rightPriceScale: {
+                    borderColor: '#2a3650',
+                },
+                handleScale: {
+                    mouseWheel: true,
+                    pinch: true,
+                },
+                handleScroll: {
+                    mouseWheel: true,
+                    pressedMouseMove: true,
+                    horzTouchDrag: true,
+                    vertTouchDrag: false,
+                },
+            });
+
+            // Create candlestick series
+            candleSeries = chart.addCandlestickSeries({
+                upColor: '#26de81',
+                downColor: '#ff4757',
+                borderUpColor: '#26de81',
+                borderDownColor: '#ff4757',
+                wickUpColor: '#26de81',
+                wickDownColor: '#ff4757',
+            });
+
+            // Create volume series
+            volumeSeries = chart.addHistogramSeries({
+                color: '#26a69a',
+                priceFormat: {
+                    type: 'volume',
+                },
+                priceScaleId: '',
+                scaleMargins: {
+                    top: 0.85,
+                    bottom: 0,
+                },
+            });
+            
+            // Create area series for trade zone (shows shaded region during trade)
+            tradeZoneSeries = chart.addAreaSeries({
+                topColor: 'rgba(0, 212, 170, 0.4)',
+                bottomColor: 'rgba(0, 212, 170, 0.0)',
+                lineColor: 'rgba(0, 212, 170, 0.6)',
+                lineWidth: 2,
+                priceScaleId: 'right',
+                lastValueVisible: false,
+                priceLineVisible: false,
+                crosshairMarkerVisible: false,
+            });
+            
+            // Create line series for entry marker
+            entryLineSeries = chart.addLineSeries({
+                color: '#00d4aa',
+                lineWidth: 3,
+                lineStyle: LightweightCharts.LineStyle.Solid,
+                priceScaleId: 'right',
+                lastValueVisible: false,
+                priceLineVisible: false,
+                crosshairMarkerVisible: false,
+            });
+            
+            // Create line series for exit marker
+            exitLineSeries = chart.addLineSeries({
+                color: '#ff4757',
+                lineWidth: 3,
+                lineStyle: LightweightCharts.LineStyle.Solid,
+                priceScaleId: 'right',
+                lastValueVisible: false,
+                priceLineVisible: false,
+                crosshairMarkerVisible: false,
+            });
+
+            // Resize handler
+            window.addEventListener('resize', () => {
+                chart.applyOptions({
+                    width: container.clientWidth,
+                    height: container.clientHeight,
+                });
+            });
+
+            // Initial resize
+            chart.applyOptions({
+                width: container.clientWidth,
+                height: container.clientHeight,
+            });
+        }
+
+        // Load signals
+        async function loadSignals(page = 1, refresh = false) {
+            const symbol = document.getElementById('symbol-filter').value;
+            const interval = document.getElementById('interval-filter').value;
+            const outcome = document.getElementById('outcome-filter').value;
+            const source = document.getElementById('source-filter').value;
+
+            let url = `${API_URL}/api/signals?page=${page}&per_page=20`;
+            if (symbol) url += `&symbol=${symbol}`;
+            if (interval) url += `&interval=${interval}`;
+            if (outcome) url += `&outcome=${outcome}`;
+            if (source) url += `&source=${source}`;
+            if (refresh) url += `&refresh=true`;
+
+            try {
+                const response = await fetch(url);
+                const data = await response.json();
+                
+                signals = data.signals;
+                currentPage = data.page;
+                totalPages = data.total_pages;
+                
+                renderTradeList();
+                updatePagination();
+                
+                if (refresh) {
+                    showToast(`Loaded ${data.total} signals`, 'success');
+                }
+            } catch (error) {
+                showToast('Error loading signals: ' + error.message, 'error');
+            }
+        }
+        
+        // Refresh all data from sources
+        async function refreshData() {
+            showToast('Refreshing data from all sources...', 'info');
+            await loadFilterOptions();
+            await loadStats();
+            await loadSignals(1, true);
+        }
+
+        // Render trade list
+        function renderTradeList() {
+            const container = document.getElementById('trade-list');
+            
+            if (signals.length === 0) {
+                container.innerHTML = '<div class="loading">No signals found</div>';
+                return;
+            }
+
+            const sourceLabels = {
+                'adaptive_learning': '🧠 AL',
+                'realtime_test': '⚡ RT',
+                'backtest': '📊 BT'
+            };
+
+            container.innerHTML = signals.map((signal, index) => {
+                const pnl = signal.profit_loss || 0;
+                const pnlPct = signal.profit_loss_percent || 0;
+                const pnlClass = pnl >= 0 ? 'positive' : 'negative';
+                const isActive = currentSignal && currentSignal.signal_id === signal.signal_id;
+                const signalEmoji = signal.signal_type === 'Bullish' ? '🟢' : signal.signal_type === 'Bearish' ? '🔴' : '⚪';
+                const entryPrice = signal.entry_price ? `$${signal.entry_price.toFixed(2)}` : '-';
+                // Handle various timestamp formats (ISO with T, or space-separated)
+                const tsString = signal.timestamp ? signal.timestamp.replace(' ', 'T') : '';
+                const timestamp = tsString ? new Date(tsString) : new Date();
+                const dateStr = !isNaN(timestamp) ? timestamp.toLocaleDateString() : 'Unknown';
+                const timeStr = !isNaN(timestamp) ? timestamp.toLocaleTimeString([], {hour: '2-digit', minute:'2-digit'}) : '';
+                const sourceLabel = sourceLabels[signal.source] || signal.source || '?';
+                
+                return `
+                    <div class="trade-item ${isActive ? 'active' : ''}" onclick="selectSignal('${signal.signal_id}')" data-signal-id="${signal.signal_id}">
+                        <div class="trade-header">
+                            <div>
+                                <span class="trade-symbol">${signalEmoji} ${signal.symbol}</span>
+                                <span class="trade-interval">${signal.interval}</span>
+                                <span class="trade-interval" style="margin-left: 4px;">${sourceLabel}</span>
+                            </div>
+                            <span class="trade-pnl ${pnlClass}">${pnlPct >= 0 ? '+' : ''}${pnlPct.toFixed(2)}%</span>
+                        </div>
+                        <div class="trade-meta">
+                            <span>Entry: ${entryPrice}</span>
+                            <span class="trade-outcome ${signal.outcome}">${formatOutcome(signal.outcome)}</span>
+                        </div>
+                        <div class="trade-meta" style="margin-top: 4px; font-size: 0.7rem;">
+                            <span>${dateStr} ${timeStr}</span>
+                            <span style="color: var(--text-muted);">#${(currentPage - 1) * 20 + index + 1}</span>
+                        </div>
+                    </div>
+                `;
+            }).join('');
+        }
+
+        // Format outcome for display
+        function formatOutcome(outcome) {
+            const map = {
+                'tp1_hit': 'TP1',
+                'tp2_hit': 'TP2',
+                'tp3_hit': 'TP3',
+                'trailing_stop': 'Trail',
+                'stop_loss': 'SL',
+                'pending': 'Pending',
+                'end_of_period': 'End',
+                'breakeven': 'BE'
+            };
+            return map[outcome] || outcome;
+        }
+
+        // Select a signal
+        async function selectSignal(signalId) {
+            console.log('Selecting signal:', signalId);
+            
+            // Find the signal in the current page's signals
+            let signal = signals.find(s => s.signal_id === signalId);
+            
+            // If not found in current signals, fetch it from the API
+            if (!signal) {
+                console.log('Signal not in current page, fetching from API...');
+                try {
+                    const response = await fetch(`${API_URL}/api/signals/${signalId}`);
+                    if (response.ok) {
+                        signal = await response.json();
+                    }
+                } catch (error) {
+                    console.error('Error fetching signal:', error);
+                    showToast('Error loading signal', 'error');
+                    return;
+                }
+            }
+            
+            if (!signal) {
+                console.error('Signal not found:', signalId);
+                showToast('Signal not found', 'error');
+                return;
+            }
+
+            currentSignal = signal;
+            console.log('Current signal set to:', signal.symbol, signal.interval, signal.timestamp);
+            
+            // Update UI
+            renderTradeList();
+            updateSignalDetails(signal);
+            
+            // Load chart data
+            await loadChartForSignal(signalId);
+        }
+
+        // Update signal details panel
+        function updateSignalDetails(signal) {
+            document.getElementById('entry-price').textContent = '$' + signal.entry_price.toFixed(2);
+            document.getElementById('stop-loss').textContent = '$' + signal.stop_loss.toFixed(2);
+            document.getElementById('tp1').textContent = '$' + signal.take_profit_1.toFixed(2);
+            document.getElementById('tp2').textContent = '$' + signal.take_profit_2.toFixed(2);
+            document.getElementById('tp3').textContent = '$' + signal.take_profit_3.toFixed(2);
+            
+            const pnl = signal.profit_loss || 0;
+            const pnlElement = document.getElementById('pnl-value');
+            pnlElement.textContent = '$' + pnl.toFixed(2);
+            pnlElement.style.color = pnl >= 0 ? 'var(--accent-success)' : 'var(--accent-danger)';
+            
+            const pnlPct = signal.profit_loss_percent || 0;
+            const pnlPctElement = document.getElementById('pnl-percent');
+            pnlPctElement.textContent = pnlPct.toFixed(2) + '%';
+            pnlPctElement.style.color = pnlPct >= 0 ? 'var(--accent-success)' : 'var(--accent-danger)';
+            
+            document.getElementById('duration').textContent = (signal.duration_candles || 0) + ' candles';
+            document.getElementById('outcome').textContent = formatOutcome(signal.outcome);
+            
+            // Update signal reasons
+            const reasonsHtml = (signal.reasons || []).slice(1, 6).map(r => 
+                `<div class="info-row"><span class="info-label">${r}</span></div>`
+            ).join('');
+            
+            document.getElementById('signal-details').innerHTML = reasonsHtml || 
+                '<div class="info-row"><span class="info-label">No details available</span></div>';
+        }
+
+        // Load chart data for a signal
+        async function loadChartForSignal(signalId) {
+            const before = parseInt(document.getElementById('candles-before').value) || 150;
+            const after = parseInt(document.getElementById('candles-after').value) || 20;
+
+            console.log(`Loading chart for signal ${signalId} with ${before} candles before and ${after} after`);
+
+            try {
+                const url = `${API_URL}/api/candles/for-signal/${signalId}?before=${before}&after=${after}`;
+                console.log('Fetching:', url);
+                
+                const response = await fetch(url);
+                const data = await response.json();
+                
+                if (data.error) {
+                    console.error('API error:', data.error);
+                    showToast('Error loading chart: ' + data.error, 'error');
+                    return;
+                }
+                
+                console.log(`Loaded ${data.candles?.length || 0} candles for ${data.symbol} ${data.interval}`);
+                
+                renderChart(data);
+                
+                // Update market regime
+                document.getElementById('market-regime').textContent = data.indicators?.market_regime || '-';
+                
+                showToast(`Loaded chart for ${data.symbol} ${data.interval}`, 'success');
+                
+            } catch (error) {
+                console.error('Error loading chart:', error);
+                showToast('Error loading chart: ' + error.message, 'error');
+            }
+        }
+
+        // Render chart with data
+        function renderChart(data) {
+            const candles = data.candles || [];
+            const signal = data.signal || currentSignal;
+            const indicators = data.indicators || {};
+            
+            // Format candles for chart
+            const candleData = candles.map(c => ({
+                time: c.timestamp / 1000,
+                open: c.open,
+                high: c.high,
+                low: c.low,
+                close: c.close,
+            }));
+            
+            const volumeData = candles.map(c => ({
+                time: c.timestamp / 1000,
+                value: c.volume,
+                color: c.close >= c.open ? 'rgba(38, 222, 129, 0.3)' : 'rgba(255, 71, 87, 0.3)',
+            }));
+            
+            // Set data
+            candleSeries.setData(candleData);
+            volumeSeries.setData(volumeData);
+            
+            // Clear old price lines
+            priceLines.forEach(line => candleSeries.removePriceLine(line));
+            priceLines = [];
+            
+            // Add trade levels if visible
+            if (signal && indicatorVisibility.levels) {
+                // Stop loss line
+                priceLines.push(candleSeries.createPriceLine({
+                    price: signal.stop_loss,
+                    color: '#ff4757',
+                    lineWidth: 2,
+                    lineStyle: LightweightCharts.LineStyle.Dashed,
+                    axisLabelVisible: true,
+                    title: 'SL',
+                }));
+                
+                // Take profit lines
+                priceLines.push(candleSeries.createPriceLine({
+                    price: signal.take_profit_1,
+                    color: '#26de81',
+                    lineWidth: 1,
+                    lineStyle: LightweightCharts.LineStyle.Dotted,
+                    axisLabelVisible: true,
+                    title: 'TP1',
+                }));
+                
+                priceLines.push(candleSeries.createPriceLine({
+                    price: signal.take_profit_2,
+                    color: '#26de81',
+                    lineWidth: 1,
+                    lineStyle: LightweightCharts.LineStyle.Dotted,
+                    axisLabelVisible: true,
+                    title: 'TP2',
+                }));
+                
+                priceLines.push(candleSeries.createPriceLine({
+                    price: signal.take_profit_3,
+                    color: '#26de81',
+                    lineWidth: 1,
+                    lineStyle: LightweightCharts.LineStyle.Dotted,
+                    axisLabelVisible: true,
+                    title: 'TP3',
+                }));
+                
+                // Use the calculated entry/exit indices from marker creation
+                const candlesBefore = parseInt(document.getElementById('candles-before').value) || 150;
+                const duration = signal.duration_candles || 10;
+                const entryIdx = Math.min(candlesBefore, candleData.length - duration - 1);
+                const exitIdx = Math.min(entryIdx + duration, candleData.length - 1);
+                
+                // Calculate price range for visualization
+                const minPrice = Math.min(...candleData.map(c => c.low));
+                const maxPrice = Math.max(...candleData.map(c => c.high));
+                const priceRange = maxPrice - minPrice;
+                
+                // Build trade zone data - shaded area during trade
+                const isProfit = signal.profit_loss >= 0;
+                tradeZoneSeries.applyOptions({
+                    topColor: isProfit ? 'rgba(38, 222, 129, 0.3)' : 'rgba(255, 71, 87, 0.3)',
+                    bottomColor: isProfit ? 'rgba(38, 222, 129, 0.05)' : 'rgba(255, 71, 87, 0.05)',
+                    lineColor: isProfit ? 'rgba(38, 222, 129, 0.6)' : 'rgba(255, 71, 87, 0.6)',
+                });
+                
+                const tradeZoneData = [];
+                if (entryIdx >= 0 && exitIdx >= 0 && entryIdx < candleData.length) {
+                    // Only show area during trade
+                    for (let i = entryIdx; i <= exitIdx && i < candleData.length; i++) {
+                        tradeZoneData.push({
+                            time: candleData[i].time,
+                            value: maxPrice + priceRange * 0.02,  // Top of chart area
+                        });
+                    }
+                }
+                tradeZoneSeries.setData(tradeZoneData);
+                
+                // Entry horizontal line (show entry price level extending through trade)
+                const entryLineData = [];
+                if (entryIdx >= 0 && entryIdx < candleData.length && signal.entry_price) {
+                    entryLineData.push({ time: candleData[entryIdx].time, value: signal.entry_price });
+                    if (exitIdx > entryIdx && exitIdx < candleData.length) {
+                        entryLineData.push({ time: candleData[exitIdx].time, value: signal.entry_price });
+                    }
+                }
+                entryLineSeries.setData(entryLineData);
+                
+                // Exit horizontal line at exit price
+                const exitLineData = [];
+                if (exitIdx >= 0 && exitIdx < candleData.length && signal.exit_price) {
+                    exitLineSeries.applyOptions({
+                        color: isProfit ? '#26de81' : '#ff4757',
+                    });
+                    exitLineData.push({ time: candleData[entryIdx].time, value: signal.exit_price });
+                    exitLineData.push({ time: candleData[exitIdx].time, value: signal.exit_price });
+                }
+                exitLineSeries.setData(exitLineData);
+                
+            } else {
+                // Clear trade zone if not showing levels
+                tradeZoneSeries.setData([]);
+                entryLineSeries.setData([]);
+                exitLineSeries.setData([]);
+            }
+            
+            // Add support levels
+            if (indicatorVisibility.support && indicators.support_levels) {
+                indicators.support_levels.forEach(level => {
+                    priceLines.push(candleSeries.createPriceLine({
+                        price: level,
+                        color: 'rgba(52, 152, 219, 0.6)',
+                        lineWidth: 1,
+                        lineStyle: LightweightCharts.LineStyle.Dashed,
+                        axisLabelVisible: false,
+                    }));
+                });
+            }
+            
+            // Add resistance levels
+            if (indicatorVisibility.resistance && indicators.resistance_levels) {
+                indicators.resistance_levels.forEach(level => {
+                    priceLines.push(candleSeries.createPriceLine({
+                        price: level,
+                        color: 'rgba(231, 76, 60, 0.6)',
+                        lineWidth: 1,
+                        lineStyle: LightweightCharts.LineStyle.Dashed,
+                        axisLabelVisible: false,
+                    }));
+                });
+            }
+            
+            // Create markers for entry and exit
+            markers = [];
+            
+            if (signal) {
+                // Get the configured number of candles before trade
+                const candlesBefore = parseInt(document.getElementById('candles-before').value) || 150;
+                const duration = signal.duration_candles || 10;
+                
+                // Entry is at the position after "candles before" 
+                // (adjusted for available data)
+                const entryIdx = Math.min(candlesBefore, candleData.length - duration - 1);
+                const exitIdx = Math.min(entryIdx + duration, candleData.length - 1);
+                
+                const entryCandle = candleData[entryIdx];
+                const exitCandle = candleData[exitIdx];
+                
+                if (entryCandle) {
+                    const entryPriceStr = signal.entry_price ? `$${signal.entry_price.toFixed(2)}` : '';
+                    markers.push({
+                        time: entryCandle.time,
+                        position: 'belowBar',
+                        color: '#00d4aa',
+                        shape: 'arrowUp',
+                        text: `▶ ENTRY ${entryPriceStr}`,
+                        size: 2,
+                    });
+                }
+                
+                // Exit marker
+                if (exitCandle && duration > 0) {
+                    const exitPriceStr = signal.exit_price ? `$${signal.exit_price.toFixed(2)}` : '';
+                    const pnlStr = signal.profit_loss ? ` (${signal.profit_loss >= 0 ? '+' : ''}$${signal.profit_loss.toFixed(2)})` : '';
+                    markers.push({
+                        time: exitCandle.time,
+                        position: 'aboveBar',
+                        color: signal.profit_loss >= 0 ? '#26de81' : '#ff4757',
+                        shape: 'arrowDown',
+                        text: `◀ ${formatOutcome(signal.outcome)} ${exitPriceStr}${pnlStr}`,
+                        size: 2,
+                    });
+                }
+                
+                // Store indices for use by trade zone
+                signal._entryIdx = entryIdx;
+                signal._exitIdx = exitIdx;
+            }
+            
+            // Add order block markers
+            if (indicatorVisibility.orderBlocks && indicators.order_blocks) {
+                indicators.order_blocks.forEach(ob => {
+                    if (ob.index < candleData.length) {
+                        markers.push({
+                            time: candleData[ob.index]?.time,
+                            position: ob.type === 'bullish' ? 'belowBar' : 'aboveBar',
+                            color: ob.type === 'bullish' ? 'rgba(0, 212, 170, 0.8)' : 'rgba(255, 71, 87, 0.8)',
+                            shape: 'square',
+                            text: 'OB',
+                        });
+                    }
+                });
+            }
+            
+            // Add breaker block markers
+            if (indicatorVisibility.breakerBlocks && indicators.breaker_blocks) {
+                indicators.breaker_blocks.forEach(bb => {
+                    if (bb.index < candleData.length) {
+                        markers.push({
+                            time: candleData[bb.index]?.time,
+                            position: bb.type === 'bullish' ? 'belowBar' : 'aboveBar',
+                            color: bb.type === 'bullish' ? 'rgba(0, 168, 255, 0.8)' : 'rgba(255, 140, 0, 0.8)',
+                            shape: 'circle',
+                            text: 'BB',
+                        });
+                    }
+                });
+            }
+            
+            // Set markers
+            candleSeries.setMarkers(markers.filter(m => m.time));
+            
+            // Fit content
+            chart.timeScale().fitContent();
+        }
+
+        // Load more candles before the trade
+        async function loadMoreCandles() {
+            if (!currentSignal) {
+                showToast('Select a signal first', 'error');
+                return;
+            }
+            
+            const beforeInput = document.getElementById('candles-before');
+            beforeInput.value = parseInt(beforeInput.value) + 50;
+            await loadChartForSignal(currentSignal.signal_id);
+            showToast('Loaded 50 more candles before', 'success');
+        }
+        
+        // Load more candles after the trade
+        async function loadMoreCandlesAfter() {
+            if (!currentSignal) {
+                showToast('Select a signal first', 'error');
+                return;
+            }
+            
+            const afterInput = document.getElementById('candles-after');
+            afterInput.value = parseInt(afterInput.value) + 20;
+            await loadChartForSignal(currentSignal.signal_id);
+            showToast('Loaded 20 more candles after', 'success');
+        }
+
+        // Toggle indicator visibility
+        function toggleIndicator(element) {
+            const indicator = element.dataset.indicator;
+            indicatorVisibility[indicator] = !indicatorVisibility[indicator];
+            element.classList.toggle('active');
+            
+            // Re-render chart if we have data
+            if (currentSignal) {
+                loadChartForSignal(currentSignal.signal_id);
+            }
+        }
+
+        // Refresh chart
+        async function refreshChart() {
+            if (currentSignal) {
+                await loadChartForSignal(currentSignal.signal_id);
+                showToast('Chart refreshed', 'success');
+            }
+        }
+
+        // Apply filters
+        function applyFilters() {
+            currentPage = 1;
+            loadSignals(1);
+        }
+
+        // Change page
+        function changePage(delta) {
+            const newPage = currentPage + delta;
+            if (newPage >= 1 && newPage <= totalPages) {
+                loadSignals(newPage);
+            }
+        }
+
+        // Update pagination controls
+        function updatePagination() {
+            document.getElementById('prev-page').disabled = currentPage <= 1;
+            document.getElementById('next-page').disabled = currentPage >= totalPages;
+            document.getElementById('pagination-info').textContent = `Page ${currentPage} of ${totalPages}`;
+        }
+
+        // Load filter options
+        async function loadFilterOptions() {
+            try {
+                // Load sources
+                const sourcesRes = await fetch(`${API_URL}/api/sources`);
+                const sourcesData = await sourcesRes.json();
+                const sourceSelect = document.getElementById('source-filter');
+                sourceSelect.innerHTML = '<option value="">All Sources</option>';
+                sourcesData.sources.forEach(s => {
+                    sourceSelect.innerHTML += `<option value="${s.id}">${s.name}</option>`;
+                });
+                
+                // Load symbols
+                const symbolsRes = await fetch(`${API_URL}/api/symbols`);
+                const symbolsData = await symbolsRes.json();
+                const symbolSelect = document.getElementById('symbol-filter');
+                symbolSelect.innerHTML = '<option value="">All Symbols</option>';
+                symbolsData.symbols.forEach(s => {
+                    symbolSelect.innerHTML += `<option value="${s}">${s}</option>`;
+                });
+                
+                // Load intervals
+                const intervalsRes = await fetch(`${API_URL}/api/intervals`);
+                const intervalsData = await intervalsRes.json();
+                const intervalSelect = document.getElementById('interval-filter');
+                intervalSelect.innerHTML = '<option value="">All Intervals</option>';
+                intervalsData.intervals.forEach(i => {
+                    intervalSelect.innerHTML += `<option value="${i}">${i}</option>`;
+                });
+            } catch (error) {
+                console.error('Error loading filter options:', error);
+            }
+        }
+
+        // Load stats
+        async function loadStats() {
+            try {
+                const response = await fetch(`${API_URL}/api/stats`);
+                const stats = await response.json();
+                
+                document.getElementById('total-signals').textContent = stats.total_signals.toLocaleString();
+                
+                // Calculate win rate
+                const wins = (stats.outcomes?.tp1_hit || 0) + 
+                            (stats.outcomes?.tp2_hit || 0) + 
+                            (stats.outcomes?.tp3_hit || 0) + 
+                            (stats.outcomes?.trailing_stop || 0);
+                const losses = stats.outcomes?.stop_loss || 0;
+                const winRate = (wins + losses) > 0 ? (wins / (wins + losses) * 100).toFixed(1) : 0;
+                document.getElementById('win-rate').textContent = winRate + '%';
+                
+                // Total P/L
+                const pnl = stats.total_pnl || 0;
+                const pnlElement = document.getElementById('total-pnl');
+                pnlElement.textContent = '$' + pnl.toFixed(2);
+                pnlElement.className = 'stat-value ' + (pnl >= 0 ? 'positive' : 'negative');
+                
+            } catch (error) {
+                console.error('Error loading stats:', error);
+            }
+        }
+
+        // Show toast notification
+        function showToast(message, type = 'info') {
+            const toast = document.getElementById('toast');
+            toast.textContent = message;
+            toast.className = 'toast show ' + type;
+            
+            setTimeout(() => {
+                toast.className = 'toast';
+            }, 3000);
+        }
+
+        // Initialize
+        document.addEventListener('DOMContentLoaded', async () => {
+            initChart();
+            await loadFilterOptions();
+            await loadStats();
+            await loadSignals();
+            
+            // Select first signal if available
+            if (signals.length > 0) {
+                selectSignal(signals[0].signal_id);
+            }
+        });
+    </script>
+</body>
+</html>
+
diff --git a/requirements.txt b/requirements.txt
index 3685001..61446be 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -8,7 +8,6 @@ mplfinance==0.12.10b0
 numpy==1.26.4
 oauthlib==3.2.2
 pandas==2.1.1
-pandas-ta==0.3.14b0
 pytest==8.3.4
 pytest-asyncio==0.25.0
 pytest-mock==3.14.0
diff --git a/src/telegram/__init__.py b/src/telegram/__init__.py
index e69de29..ac189cd 100644
--- a/src/telegram/__init__.py
+++ b/src/telegram/__init__.py
@@ -0,0 +1,11 @@
+"""
+Telegram module for CryptoBot.
+
+This module provides Telegram bot functionality and notifications.
+"""
+
+try:
+    from src.telegram.notifier import TelegramNotifier, create_notifier
+    __all__ = ["TelegramNotifier", "create_notifier"]
+except ImportError:
+    pass
diff --git a/src/telegram/notifier.py b/src/telegram/notifier.py
new file mode 100644
index 0000000..bda687b
--- /dev/null
+++ b/src/telegram/notifier.py
@@ -0,0 +1,506 @@
+"""
+Telegram Notifier for Live Trading Alerts
+
+This module provides simple notification functionality for trading events.
+It sends messages directly to a specified Telegram chat/user ID.
+
+Usage:
+    notifier = TelegramNotifier(chat_id=840355587)
+    notifier.send_signal_alert(symbol, entry, sl, tp1, tp2, tp3, confidence)
+    notifier.send_trade_closed(symbol, entry, exit, pnl, exit_type)
+"""
+
+import os
+import logging
+from typing import Optional, Dict, Any
+from datetime import datetime
+from enum import Enum
+import requests
+from dotenv import load_dotenv
+
+load_dotenv()
+
+logger = logging.getLogger(__name__)
+
+
+class TradeEventType(Enum):
+    """Types of trade events for notifications"""
+    NEW_SIGNAL = "new_signal"
+    TRADE_OPENED = "trade_opened"
+    TP1_HIT = "tp1_hit"
+    TP2_HIT = "tp2_hit"
+    TP3_HIT = "tp3_hit"
+    STOP_LOSS = "stop_loss"
+    TRAILING_STOP = "trailing_stop"
+    TRADE_CLOSED = "trade_closed"
+    ERROR = "error"
+
+
+class TelegramNotifier:
+    """
+    Simple Telegram notifier for trading alerts.
+    
+    Sends notifications about:
+    - New trading signals
+    - Trade entries
+    - Take-profit hits (TP1, TP2, TP3)
+    - Stop-loss hits
+    - Trade closures with P/L summary
+    """
+    
+    def __init__(
+        self,
+        chat_id: int = None,
+        bot_token: str = None,
+        enabled: bool = True,
+    ):
+        """
+        Initialize the notifier.
+        
+        Args:
+            chat_id: Telegram chat/user ID to send notifications to
+            bot_token: Telegram bot token (or from env API_TELEGRAM_KEY)
+            enabled: Whether notifications are enabled
+        """
+        self.chat_id = chat_id or int(os.getenv("TELEGRAM_CHAT_ID", "0"))
+        self.bot_token = bot_token or os.getenv("API_TELEGRAM_KEY", "")
+        self.enabled = enabled and bool(self.bot_token) and self.chat_id > 0
+        
+        if not self.enabled:
+            if not self.bot_token:
+                logger.warning("Telegram notifier disabled: No bot token configured")
+            elif self.chat_id <= 0:
+                logger.warning("Telegram notifier disabled: No chat ID configured")
+        else:
+            logger.info(f"✓ Telegram notifier enabled for chat ID: {self.chat_id}")
+    
+    @property
+    def api_url(self) -> str:
+        """Get Telegram API URL"""
+        return f"https://api.telegram.org/bot{self.bot_token}"
+    
+    def send_message(
+        self,
+        text: str,
+        parse_mode: str = "HTML",
+        disable_notification: bool = False,
+    ) -> bool:
+        """
+        Send a message to the configured chat.
+        
+        Args:
+            text: Message text (supports HTML formatting)
+            parse_mode: Parse mode (HTML or Markdown)
+            disable_notification: Send silently
+            
+        Returns:
+            True if message sent successfully
+        """
+        if not self.enabled:
+            return False
+        
+        try:
+            url = f"{self.api_url}/sendMessage"
+            payload = {
+                "chat_id": self.chat_id,
+                "text": text,
+                "parse_mode": parse_mode,
+                "disable_notification": disable_notification,
+            }
+            
+            response = requests.post(url, json=payload, timeout=10)
+            result = response.json()
+            
+            if result.get("ok"):
+                return True
+            else:
+                logger.error(f"Telegram API error: {result.get('description')}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Failed to send Telegram message: {e}")
+            return False
+    
+    def send_signal_alert(
+        self,
+        symbol: str,
+        interval: str,
+        entry_price: float,
+        stop_loss: float,
+        take_profit_1: float,
+        take_profit_2: float,
+        take_profit_3: float,
+        confidence: float,
+        risk_reward: float = 0,
+        invested_amount: float = 0,
+        quantity: float = 0,
+        order_id: str = "",
+        reasons: str = "",
+    ) -> bool:
+        """
+        Send notification for a new trading signal/trade entry.
+        
+        Args:
+            symbol: Trading pair
+            interval: Timeframe
+            entry_price: Entry price
+            stop_loss: Stop loss price
+            take_profit_1: First take profit level
+            take_profit_2: Second take profit level
+            take_profit_3: Third take profit level
+            confidence: Signal confidence (0-1)
+            risk_reward: Risk/reward ratio
+            invested_amount: Amount invested in USDT
+            quantity: Quantity bought
+            order_id: Bybit order ID
+            reasons: Signal reasons (optional)
+        """
+        sl_pct = ((stop_loss / entry_price) - 1) * 100
+        tp1_pct = ((take_profit_1 / entry_price) - 1) * 100
+        tp2_pct = ((take_profit_2 / entry_price) - 1) * 100
+        tp3_pct = ((take_profit_3 / entry_price) - 1) * 100
+        
+        message = f"""
+🚀 <b>NEW TRADE OPENED</b>
+
+<b>Symbol:</b> {symbol} ({interval})
+<b>Entry:</b> ${entry_price:,.2f}
+<b>Confidence:</b> {confidence:.0%}
+
+📊 <b>Targets:</b>
+├ SL: ${stop_loss:,.2f} ({sl_pct:+.2f}%)
+├ TP1: ${take_profit_1:,.2f} ({tp1_pct:+.2f}%)
+├ TP2: ${take_profit_2:,.2f} ({tp2_pct:+.2f}%)
+└ TP3: ${take_profit_3:,.2f} ({tp3_pct:+.2f}%)
+"""
+        
+        if invested_amount > 0:
+            message += f"""
+💰 <b>Position:</b>
+├ Invested: ${invested_amount:,.2f}
+├ Quantity: {quantity:.6f}
+└ R/R: {risk_reward:.2f}
+"""
+        
+        if order_id:
+            message += f"\n🆔 Order: <code>{order_id}</code>"
+        
+        message += f"\n\n⏰ {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
+        
+        return self.send_message(message)
+    
+    def send_tp_hit(
+        self,
+        symbol: str,
+        tp_level: int,
+        exit_price: float,
+        entry_price: float,
+        quantity_sold: float,
+        realized_pnl: float,
+        remaining_quantity: float = 0,
+    ) -> bool:
+        """
+        Send notification for take-profit hit.
+        
+        Args:
+            symbol: Trading pair
+            tp_level: Take profit level (1, 2, or 3)
+            exit_price: Exit price
+            entry_price: Original entry price
+            quantity_sold: Quantity sold at this TP
+            realized_pnl: Realized P/L from this sale
+            remaining_quantity: Remaining position quantity
+        """
+        profit_pct = ((exit_price / entry_price) - 1) * 100
+        
+        if tp_level == 3:
+            emoji = "🎯🎯🎯"
+            action = "FULL EXIT"
+        else:
+            emoji = "🎯" * tp_level
+            action = f"PARTIAL EXIT ({33 if tp_level == 1 else 50}%)"
+        
+        message = f"""
+{emoji} <b>TP{tp_level} HIT - {action}</b>
+
+<b>Symbol:</b> {symbol}
+<b>Entry:</b> ${entry_price:,.2f}
+<b>Exit:</b> ${exit_price:,.2f} ({profit_pct:+.2f}%)
+
+💰 <b>Result:</b>
+├ Sold: {quantity_sold:.6f}
+├ P/L: ${realized_pnl:+,.2f}
+"""
+        
+        if remaining_quantity > 0 and tp_level < 3:
+            message += f"└ Remaining: {remaining_quantity:.6f}"
+        else:
+            message += "└ Position closed"
+        
+        message += f"\n\n⏰ {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
+        
+        return self.send_message(message)
+    
+    def send_stop_loss(
+        self,
+        symbol: str,
+        exit_price: float,
+        entry_price: float,
+        quantity: float,
+        realized_pnl: float,
+        is_trailing: bool = False,
+    ) -> bool:
+        """
+        Send notification for stop-loss hit.
+        
+        Args:
+            symbol: Trading pair
+            exit_price: Exit price
+            entry_price: Original entry price
+            quantity: Position quantity
+            realized_pnl: Realized P/L
+            is_trailing: Whether this was a trailing stop
+        """
+        loss_pct = ((exit_price / entry_price) - 1) * 100
+        
+        if is_trailing:
+            emoji = "📉" if realized_pnl < 0 else "✅"
+            title = "TRAILING STOP HIT"
+        else:
+            emoji = "🛑"
+            title = "STOP LOSS HIT"
+        
+        result_emoji = "💸" if realized_pnl < 0 else "💰"
+        
+        message = f"""
+{emoji} <b>{title}</b>
+
+<b>Symbol:</b> {symbol}
+<b>Entry:</b> ${entry_price:,.2f}
+<b>Exit:</b> ${exit_price:,.2f} ({loss_pct:+.2f}%)
+
+{result_emoji} <b>Result:</b>
+├ Quantity: {quantity:.6f}
+└ P/L: ${realized_pnl:+,.2f}
+
+⏰ {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+"""
+        
+        return self.send_message(message)
+    
+    def send_trade_summary(
+        self,
+        symbol: str,
+        interval: str,
+        entry_price: float,
+        exit_price: float,
+        quantity: float,
+        invested_amount: float,
+        realized_pnl: float,
+        exit_type: str,
+        duration_minutes: float,
+        entry_order_id: str = "",
+        exit_order_id: str = "",
+    ) -> bool:
+        """
+        Send trade closure summary.
+        
+        Args:
+            symbol: Trading pair
+            interval: Timeframe
+            entry_price: Entry price
+            exit_price: Final exit price
+            quantity: Position quantity
+            invested_amount: Amount invested
+            realized_pnl: Total realized P/L
+            exit_type: How the trade was closed
+            duration_minutes: Trade duration
+            entry_order_id: Entry order ID
+            exit_order_id: Exit order ID
+        """
+        profit_pct = ((exit_price / entry_price) - 1) * 100
+        roi = (realized_pnl / invested_amount) * 100 if invested_amount > 0 else 0
+        
+        is_profit = realized_pnl > 0
+        emoji = "💰" if is_profit else "💸"
+        result = "PROFIT" if is_profit else "LOSS"
+        
+        # Format duration
+        if duration_minutes < 60:
+            duration_str = f"{duration_minutes:.0f}m"
+        else:
+            hours = int(duration_minutes // 60)
+            mins = int(duration_minutes % 60)
+            duration_str = f"{hours}h {mins}m"
+        
+        message = f"""
+{emoji} <b>TRADE CLOSED - {result}</b>
+
+<b>Symbol:</b> {symbol} ({interval})
+<b>Duration:</b> {duration_str}
+<b>Exit Type:</b> {exit_type.replace('_', ' ').title()}
+
+📊 <b>Price Action:</b>
+├ Entry: ${entry_price:,.2f}
+└ Exit: ${exit_price:,.2f} ({profit_pct:+.2f}%)
+
+💵 <b>Financial Result:</b>
+├ Invested: ${invested_amount:,.2f}
+├ P/L: ${realized_pnl:+,.2f}
+└ ROI: {roi:+.2f}%
+
+⏰ {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+"""
+        
+        return self.send_message(message)
+    
+    def send_daily_summary(
+        self,
+        total_trades: int,
+        wins: int,
+        losses: int,
+        total_pnl: float,
+        best_trade: float,
+        worst_trade: float,
+        current_balance: float,
+        initial_balance: float,
+    ) -> bool:
+        """
+        Send daily trading summary.
+        """
+        win_rate = (wins / total_trades * 100) if total_trades > 0 else 0
+        roi = ((current_balance - initial_balance) / initial_balance * 100) if initial_balance > 0 else 0
+        
+        emoji = "📈" if total_pnl > 0 else "📉"
+        
+        message = f"""
+{emoji} <b>DAILY TRADING SUMMARY</b>
+
+📊 <b>Trading Stats:</b>
+├ Total Trades: {total_trades}
+├ Wins: {wins} ✅
+├ Losses: {losses} ❌
+└ Win Rate: {win_rate:.1f}%
+
+💰 <b>P/L Summary:</b>
+├ Total P/L: ${total_pnl:+,.2f}
+├ Best Trade: ${best_trade:+,.2f}
+└ Worst Trade: ${worst_trade:+,.2f}
+
+💵 <b>Account:</b>
+├ Initial: ${initial_balance:,.2f}
+├ Current: ${current_balance:,.2f}
+└ ROI: {roi:+.2f}%
+
+⏰ {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+"""
+        
+        return self.send_message(message)
+    
+    def send_error(self, error_message: str, context: str = "") -> bool:
+        """
+        Send error notification.
+        
+        Args:
+            error_message: Error description
+            context: Additional context about the error
+        """
+        message = f"""
+⚠️ <b>TRADING ERROR</b>
+
+<b>Error:</b> {error_message}
+"""
+        
+        if context:
+            message += f"\n<b>Context:</b> {context}"
+        
+        message += f"\n\n⏰ {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
+        
+        return self.send_message(message)
+    
+    def send_startup(
+        self,
+        testnet: bool,
+        initial_balance: float,
+        max_position: float,
+        max_positions: int,
+        combinations: list,
+    ) -> bool:
+        """
+        Send notification when trading bot starts.
+        """
+        mode = "🧪 TESTNET" if testnet else "💵 LIVE"
+        
+        pairs = "\n".join([f"├ {c['symbol']} ({c['interval']})" for c in combinations[:-1]])
+        pairs += f"\n└ {combinations[-1]['symbol']} ({combinations[-1]['interval']})" if combinations else ""
+        
+        message = f"""
+🤖 <b>TRADING BOT STARTED</b>
+
+<b>Mode:</b> {mode}
+<b>Balance:</b> ${initial_balance:,.2f}
+<b>Max per Trade:</b> ${max_position:,.2f}
+<b>Max Positions:</b> {max_positions}
+
+📊 <b>Monitoring:</b>
+{pairs}
+
+⏰ {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+"""
+        
+        return self.send_message(message)
+    
+    def send_shutdown(
+        self,
+        runtime_minutes: float,
+        total_trades: int,
+        total_pnl: float,
+        open_positions: int,
+    ) -> bool:
+        """
+        Send notification when trading bot stops.
+        """
+        hours = int(runtime_minutes // 60)
+        mins = int(runtime_minutes % 60)
+        
+        emoji = "💰" if total_pnl > 0 else "💸" if total_pnl < 0 else "⚪"
+        
+        message = f"""
+🛑 <b>TRADING BOT STOPPED</b>
+
+<b>Runtime:</b> {hours}h {mins}m
+<b>Trades:</b> {total_trades}
+<b>P/L:</b> ${total_pnl:+,.2f} {emoji}
+<b>Open Positions:</b> {open_positions}
+
+⏰ {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+"""
+        
+        return self.send_message(message)
+    
+    def test_connection(self) -> bool:
+        """
+        Test Telegram bot connection by sending a test message.
+        
+        Returns:
+            True if test message sent successfully
+        """
+        return self.send_message(
+            "✅ <b>Connection Test</b>\n\nTelegram notifier is working!",
+            disable_notification=True
+        )
+
+
+# Default notifier instance (can be imported and used directly)
+def create_notifier(chat_id: int = None) -> TelegramNotifier:
+    """
+    Create a notifier instance with the specified chat ID.
+    
+    Args:
+        chat_id: Telegram chat/user ID (default from TELEGRAM_CHAT_ID env var)
+        
+    Returns:
+        Configured TelegramNotifier instance
+    """
+    return TelegramNotifier(chat_id=chat_id)
+
diff --git a/src/trading/__init__.py b/src/trading/__init__.py
new file mode 100644
index 0000000..23c2094
--- /dev/null
+++ b/src/trading/__init__.py
@@ -0,0 +1,10 @@
+"""
+Trading module for CryptoBot.
+
+This module provides real trading capabilities through exchange APIs.
+"""
+
+from src.trading.bybit_client import BybitClient, OrderSide, OrderType, PositionMode
+
+__all__ = ["BybitClient", "OrderSide", "OrderType", "PositionMode"]
+
diff --git a/src/trading/bybit_client.py b/src/trading/bybit_client.py
new file mode 100644
index 0000000..365be0e
--- /dev/null
+++ b/src/trading/bybit_client.py
@@ -0,0 +1,789 @@
+"""
+Bybit Trading Client for CryptoBot.
+
+This module provides a client for executing trades on Bybit exchange,
+including market orders, limit orders, and conditional orders (TP/SL).
+
+Uses Bybit V5 API: https://bybit-exchange.github.io/docs/v5/intro
+"""
+
+import os
+import time
+import hmac
+import hashlib
+import json
+import logging
+from enum import Enum
+from typing import Dict, List, Optional, Any, Tuple
+from dataclasses import dataclass
+from datetime import datetime
+import requests
+from dotenv import load_dotenv
+
+load_dotenv()
+
+logger = logging.getLogger(__name__)
+
+# API Endpoints
+MAINNET_URL = "https://api.bybit.com"
+TESTNET_URL = "https://api-testnet.bybit.com"
+
+
+class OrderSide(Enum):
+    """Order side (buy/sell)"""
+    BUY = "Buy"
+    SELL = "Sell"
+
+
+class OrderType(Enum):
+    """Order types supported by Bybit"""
+    MARKET = "Market"
+    LIMIT = "Limit"
+
+
+class PositionMode(Enum):
+    """Position mode for trading"""
+    ONE_WAY = 0  # Merge long and short positions
+    HEDGE = 3   # Separate long and short positions
+
+
+class TriggerBy(Enum):
+    """Trigger price type for conditional orders"""
+    LAST_PRICE = "LastPrice"
+    INDEX_PRICE = "IndexPrice"
+    MARK_PRICE = "MarkPrice"
+
+
+@dataclass
+class OrderResult:
+    """Result of an order execution"""
+    success: bool
+    order_id: str
+    order_link_id: str
+    symbol: str
+    side: str
+    order_type: str
+    price: float
+    qty: float
+    status: str
+    message: str
+    raw_response: Dict[str, Any]
+
+
+@dataclass
+class Position:
+    """Represents an open position"""
+    symbol: str
+    side: str
+    size: float
+    entry_price: float
+    leverage: float
+    unrealized_pnl: float
+    realized_pnl: float
+    position_value: float
+    liq_price: float
+    tp_sl_mode: str
+    take_profit: float
+    stop_loss: float
+    created_time: datetime
+
+
+class BybitClient:
+    """
+    Bybit exchange client for executing trades.
+    
+    Supports:
+    - Spot trading
+    - Market and limit orders
+    - Take-profit and stop-loss orders
+    - Position management
+    """
+    
+    def __init__(
+        self,
+        api_key: str = None,
+        api_secret: str = None,
+        testnet: bool = False,
+        recv_window: int = 5000,
+    ):
+        """
+        Initialize the Bybit client.
+        
+        Args:
+            api_key: Bybit API key (or from env BYBIT_API_KEY)
+            api_secret: Bybit API secret (or from env BYBIT_API_SECRET)
+            testnet: Use testnet instead of mainnet
+            recv_window: Request timeout window in milliseconds
+        """
+        self.api_key = api_key or os.getenv("BYBIT_API_KEY", "")
+        self.api_secret = api_secret or os.getenv("BYBIT_API_SECRET", "")
+        self.base_url = TESTNET_URL if testnet else MAINNET_URL
+        self.recv_window = recv_window
+        self.testnet = testnet
+        
+        if not self.api_key or not self.api_secret:
+            logger.warning("Bybit API credentials not configured. Trading will fail.")
+    
+    def _get_timestamp(self) -> str:
+        """Get current timestamp in milliseconds"""
+        return str(int(time.time() * 1000))
+    
+    def _generate_signature(self, timestamp: str, params: Dict[str, Any]) -> str:
+        """
+        Generate HMAC SHA256 signature for API authentication.
+        
+        Args:
+            timestamp: Current timestamp
+            params: Request parameters
+            
+        Returns:
+            Hex-encoded signature
+        """
+        param_str = timestamp + self.api_key + str(self.recv_window) + json.dumps(params, separators=(',', ':'))
+        return hmac.new(
+            self.api_secret.encode('utf-8'),
+            param_str.encode('utf-8'),
+            hashlib.sha256
+        ).hexdigest()
+    
+    def _generate_get_signature(self, timestamp: str, query_string: str) -> str:
+        """
+        Generate signature for GET requests.
+        
+        Args:
+            timestamp: Current timestamp
+            query_string: URL query string
+            
+        Returns:
+            Hex-encoded signature
+        """
+        param_str = timestamp + self.api_key + str(self.recv_window) + query_string
+        return hmac.new(
+            self.api_secret.encode('utf-8'),
+            param_str.encode('utf-8'),
+            hashlib.sha256
+        ).hexdigest()
+    
+    def _request(
+        self,
+        method: str,
+        endpoint: str,
+        params: Dict[str, Any] = None,
+        signed: bool = True,
+    ) -> Dict[str, Any]:
+        """
+        Make an API request to Bybit.
+        
+        Args:
+            method: HTTP method (GET, POST)
+            endpoint: API endpoint
+            params: Request parameters
+            signed: Whether to sign the request
+            
+        Returns:
+            API response as dictionary
+        """
+        url = f"{self.base_url}{endpoint}"
+        headers = {"Content-Type": "application/json"}
+        
+        if signed:
+            timestamp = self._get_timestamp()
+            headers["X-BAPI-API-KEY"] = self.api_key
+            headers["X-BAPI-TIMESTAMP"] = timestamp
+            headers["X-BAPI-RECV-WINDOW"] = str(self.recv_window)
+            
+            if method == "GET":
+                query_string = "&".join([f"{k}={v}" for k, v in (params or {}).items()])
+                headers["X-BAPI-SIGN"] = self._generate_get_signature(timestamp, query_string)
+                response = requests.get(url, params=params, headers=headers, timeout=10)
+            else:
+                headers["X-BAPI-SIGN"] = self._generate_signature(timestamp, params or {})
+                response = requests.post(url, json=params, headers=headers, timeout=10)
+        else:
+            if method == "GET":
+                response = requests.get(url, params=params, headers=headers, timeout=10)
+            else:
+                response = requests.post(url, json=params, headers=headers, timeout=10)
+        
+        try:
+            data = response.json()
+            if data.get("retCode") != 0:
+                logger.error(f"Bybit API error: {data.get('retMsg')} (code: {data.get('retCode')})")
+            return data
+        except Exception as e:
+            logger.error(f"Error parsing Bybit response: {e}")
+            return {"retCode": -1, "retMsg": str(e)}
+    
+    # ========== Account Methods ==========
+    
+    def get_wallet_balance(self, account_type: str = "UNIFIED", coin: str = None) -> Dict[str, Any]:
+        """
+        Get wallet balance.
+        
+        Args:
+            account_type: Account type (UNIFIED, SPOT, etc.)
+            coin: Optional specific coin to query
+            
+        Returns:
+            Wallet balance information
+        """
+        params = {"accountType": account_type}
+        if coin:
+            params["coin"] = coin
+        
+        return self._request("GET", "/v5/account/wallet-balance", params)
+    
+    def get_available_balance(self, coin: str = "USDT") -> float:
+        """
+        Get available balance for a specific coin.
+        
+        Args:
+            coin: Coin symbol (default: USDT)
+            
+        Returns:
+            Available balance as float
+        """
+        result = self.get_wallet_balance(coin=coin)
+        
+        try:
+            if result.get("retCode") == 0:
+                accounts = result.get("result", {}).get("list", [])
+                for account in accounts:
+                    coins = account.get("coin", [])
+                    for c in coins:
+                        if c.get("coin") == coin:
+                            return float(c.get("availableToWithdraw", 0))
+        except Exception as e:
+            logger.error(f"Error getting balance: {e}")
+        
+        return 0.0
+    
+    # ========== Market Data Methods ==========
+    
+    def get_ticker(self, symbol: str, category: str = "spot") -> Dict[str, Any]:
+        """
+        Get current ticker information.
+        
+        Args:
+            symbol: Trading pair symbol
+            category: Category (spot, linear, inverse)
+            
+        Returns:
+            Ticker information
+        """
+        params = {"category": category, "symbol": symbol}
+        return self._request("GET", "/v5/market/tickers", params, signed=False)
+    
+    def get_current_price(self, symbol: str) -> float:
+        """
+        Get current market price for a symbol.
+        
+        Args:
+            symbol: Trading pair symbol
+            
+        Returns:
+            Current price as float
+        """
+        result = self.get_ticker(symbol)
+        
+        try:
+            if result.get("retCode") == 0:
+                tickers = result.get("result", {}).get("list", [])
+                if tickers:
+                    return float(tickers[0].get("lastPrice", 0))
+        except Exception as e:
+            logger.error(f"Error getting price for {symbol}: {e}")
+        
+        return 0.0
+    
+    def get_instrument_info(self, symbol: str, category: str = "spot") -> Dict[str, Any]:
+        """
+        Get trading instrument information (min qty, tick size, etc.)
+        
+        Args:
+            symbol: Trading pair symbol
+            category: Category (spot, linear, inverse)
+            
+        Returns:
+            Instrument information
+        """
+        params = {"category": category, "symbol": symbol}
+        return self._request("GET", "/v5/market/instruments-info", params, signed=False)
+    
+    def get_lot_size_filter(self, symbol: str) -> Tuple[float, float, float]:
+        """
+        Get lot size constraints for a symbol.
+        
+        Args:
+            symbol: Trading pair symbol
+            
+        Returns:
+            Tuple of (min_qty, max_qty, qty_step)
+        """
+        result = self.get_instrument_info(symbol)
+        
+        try:
+            if result.get("retCode") == 0:
+                instruments = result.get("result", {}).get("list", [])
+                if instruments:
+                    lot_size = instruments[0].get("lotSizeFilter", {})
+                    return (
+                        float(lot_size.get("minOrderQty", 0)),
+                        float(lot_size.get("maxOrderQty", 0)),
+                        float(lot_size.get("basePrecision", 0.001)),
+                    )
+        except Exception as e:
+            logger.error(f"Error getting lot size for {symbol}: {e}")
+        
+        return (0.0, 0.0, 0.001)
+    
+    # ========== Order Methods ==========
+    
+    def place_order(
+        self,
+        symbol: str,
+        side: OrderSide,
+        order_type: OrderType,
+        qty: float,
+        price: float = None,
+        category: str = "spot",
+        time_in_force: str = "GTC",
+        order_link_id: str = None,
+        reduce_only: bool = False,
+        take_profit: float = None,
+        stop_loss: float = None,
+    ) -> OrderResult:
+        """
+        Place a trading order.
+        
+        Args:
+            symbol: Trading pair symbol
+            side: Order side (Buy/Sell)
+            order_type: Order type (Market/Limit)
+            qty: Order quantity
+            price: Limit price (required for limit orders)
+            category: Category (spot, linear, inverse)
+            time_in_force: Time in force (GTC, IOC, FOK)
+            order_link_id: Custom order ID
+            reduce_only: Reduce only order (for derivatives)
+            take_profit: Take profit price
+            stop_loss: Stop loss price
+            
+        Returns:
+            OrderResult with execution details
+        """
+        # Round quantity to valid precision
+        min_qty, max_qty, qty_step = self.get_lot_size_filter(symbol)
+        
+        # Adjust quantity to valid step
+        if qty_step > 0:
+            qty = round(qty / qty_step) * qty_step
+        
+        # Validate quantity
+        if qty < min_qty:
+            return OrderResult(
+                success=False,
+                order_id="",
+                order_link_id=order_link_id or "",
+                symbol=symbol,
+                side=side.value,
+                order_type=order_type.value,
+                price=price or 0,
+                qty=qty,
+                status="REJECTED",
+                message=f"Quantity {qty} below minimum {min_qty}",
+                raw_response={}
+            )
+        
+        params = {
+            "category": category,
+            "symbol": symbol,
+            "side": side.value,
+            "orderType": order_type.value,
+            "qty": str(qty),
+            "timeInForce": time_in_force,
+        }
+        
+        if order_link_id:
+            params["orderLinkId"] = order_link_id
+        
+        if order_type == OrderType.LIMIT and price:
+            params["price"] = str(price)
+        
+        if category != "spot":
+            if reduce_only:
+                params["reduceOnly"] = True
+            if take_profit:
+                params["takeProfit"] = str(take_profit)
+            if stop_loss:
+                params["stopLoss"] = str(stop_loss)
+        
+        result = self._request("POST", "/v5/order/create", params)
+        
+        if result.get("retCode") == 0:
+            order_result = result.get("result", {})
+            return OrderResult(
+                success=True,
+                order_id=order_result.get("orderId", ""),
+                order_link_id=order_result.get("orderLinkId", ""),
+                symbol=symbol,
+                side=side.value,
+                order_type=order_type.value,
+                price=price or 0,
+                qty=qty,
+                status="CREATED",
+                message="Order placed successfully",
+                raw_response=result
+            )
+        else:
+            return OrderResult(
+                success=False,
+                order_id="",
+                order_link_id=order_link_id or "",
+                symbol=symbol,
+                side=side.value,
+                order_type=order_type.value,
+                price=price or 0,
+                qty=qty,
+                status="FAILED",
+                message=result.get("retMsg", "Unknown error"),
+                raw_response=result
+            )
+    
+    def place_market_buy(
+        self,
+        symbol: str,
+        qty: float,
+        category: str = "spot",
+        order_link_id: str = None,
+    ) -> OrderResult:
+        """
+        Place a market buy order.
+        
+        Args:
+            symbol: Trading pair symbol
+            qty: Order quantity (in base currency)
+            category: Category (spot, linear, inverse)
+            order_link_id: Custom order ID
+            
+        Returns:
+            OrderResult with execution details
+        """
+        return self.place_order(
+            symbol=symbol,
+            side=OrderSide.BUY,
+            order_type=OrderType.MARKET,
+            qty=qty,
+            category=category,
+            order_link_id=order_link_id,
+        )
+    
+    def place_market_sell(
+        self,
+        symbol: str,
+        qty: float,
+        category: str = "spot",
+        order_link_id: str = None,
+    ) -> OrderResult:
+        """
+        Place a market sell order.
+        
+        Args:
+            symbol: Trading pair symbol
+            qty: Order quantity (in base currency)
+            category: Category (spot, linear, inverse)
+            order_link_id: Custom order ID
+            
+        Returns:
+            OrderResult with execution details
+        """
+        return self.place_order(
+            symbol=symbol,
+            side=OrderSide.SELL,
+            order_type=OrderType.MARKET,
+            qty=qty,
+            category=category,
+            order_link_id=order_link_id,
+        )
+    
+    def cancel_order(
+        self,
+        symbol: str,
+        order_id: str = None,
+        order_link_id: str = None,
+        category: str = "spot",
+    ) -> Dict[str, Any]:
+        """
+        Cancel an existing order.
+        
+        Args:
+            symbol: Trading pair symbol
+            order_id: Order ID to cancel
+            order_link_id: Custom order ID to cancel
+            category: Category (spot, linear, inverse)
+            
+        Returns:
+            Cancellation result
+        """
+        params = {"category": category, "symbol": symbol}
+        
+        if order_id:
+            params["orderId"] = order_id
+        elif order_link_id:
+            params["orderLinkId"] = order_link_id
+        else:
+            return {"retCode": -1, "retMsg": "Either orderId or orderLinkId required"}
+        
+        return self._request("POST", "/v5/order/cancel", params)
+    
+    def cancel_all_orders(self, symbol: str = None, category: str = "spot") -> Dict[str, Any]:
+        """
+        Cancel all open orders.
+        
+        Args:
+            symbol: Optional specific symbol to cancel
+            category: Category (spot, linear, inverse)
+            
+        Returns:
+            Cancellation result
+        """
+        params = {"category": category}
+        if symbol:
+            params["symbol"] = symbol
+        
+        return self._request("POST", "/v5/order/cancel-all", params)
+    
+    def get_open_orders(
+        self,
+        symbol: str = None,
+        category: str = "spot",
+        limit: int = 50,
+    ) -> List[Dict[str, Any]]:
+        """
+        Get list of open orders.
+        
+        Args:
+            symbol: Optional specific symbol
+            category: Category (spot, linear, inverse)
+            limit: Maximum number of orders to return
+            
+        Returns:
+            List of open orders
+        """
+        params = {"category": category, "limit": limit}
+        if symbol:
+            params["symbol"] = symbol
+        
+        result = self._request("GET", "/v5/order/realtime", params)
+        
+        if result.get("retCode") == 0:
+            return result.get("result", {}).get("list", [])
+        return []
+    
+    def get_order_history(
+        self,
+        symbol: str = None,
+        category: str = "spot",
+        limit: int = 50,
+    ) -> List[Dict[str, Any]]:
+        """
+        Get order history.
+        
+        Args:
+            symbol: Optional specific symbol
+            category: Category (spot, linear, inverse)
+            limit: Maximum number of orders to return
+            
+        Returns:
+            List of historical orders
+        """
+        params = {"category": category, "limit": limit}
+        if symbol:
+            params["symbol"] = symbol
+        
+        result = self._request("GET", "/v5/order/history", params)
+        
+        if result.get("retCode") == 0:
+            return result.get("result", {}).get("list", [])
+        return []
+    
+    # ========== Spot Trading with TP/SL ==========
+    
+    def place_spot_order_with_tp_sl(
+        self,
+        symbol: str,
+        side: OrderSide,
+        qty: float,
+        take_profit: float = None,
+        stop_loss: float = None,
+        entry_price: float = None,
+    ) -> Tuple[OrderResult, Optional[str], Optional[str]]:
+        """
+        Place a spot market order and set up monitoring for TP/SL.
+        
+        Since spot trading doesn't support native TP/SL orders,
+        this returns the necessary information for manual monitoring.
+        
+        Args:
+            symbol: Trading pair symbol
+            side: Order side (Buy/Sell)
+            qty: Order quantity
+            take_profit: Take profit price
+            stop_loss: Stop loss price
+            entry_price: Expected entry price (for logging)
+            
+        Returns:
+            Tuple of (OrderResult, tp_order_id, sl_order_id)
+            Note: For spot, tp_order_id and sl_order_id will be None
+        """
+        # Place the market order
+        order_result = self.place_order(
+            symbol=symbol,
+            side=side,
+            order_type=OrderType.MARKET,
+            qty=qty,
+            category="spot",
+        )
+        
+        if order_result.success:
+            logger.info(
+                f"✅ Spot order placed: {side.value} {qty} {symbol} "
+                f"(TP: {take_profit}, SL: {stop_loss})"
+            )
+        
+        # For spot trading, we can't set native TP/SL
+        # The caller needs to monitor and manage exits manually
+        return order_result, None, None
+    
+    # ========== Position Management ==========
+    
+    def get_positions(
+        self,
+        symbol: str = None,
+        category: str = "linear",
+    ) -> List[Position]:
+        """
+        Get open positions (for derivatives).
+        
+        Args:
+            symbol: Optional specific symbol
+            category: Category (linear, inverse)
+            
+        Returns:
+            List of Position objects
+        """
+        params = {"category": category, "settleCoin": "USDT"}
+        if symbol:
+            params["symbol"] = symbol
+        
+        result = self._request("GET", "/v5/position/list", params)
+        positions = []
+        
+        if result.get("retCode") == 0:
+            for pos in result.get("result", {}).get("list", []):
+                if float(pos.get("size", 0)) > 0:
+                    positions.append(Position(
+                        symbol=pos.get("symbol"),
+                        side=pos.get("side"),
+                        size=float(pos.get("size", 0)),
+                        entry_price=float(pos.get("avgPrice", 0)),
+                        leverage=float(pos.get("leverage", 1)),
+                        unrealized_pnl=float(pos.get("unrealisedPnl", 0)),
+                        realized_pnl=float(pos.get("cumRealisedPnl", 0)),
+                        position_value=float(pos.get("positionValue", 0)),
+                        liq_price=float(pos.get("liqPrice", 0)),
+                        tp_sl_mode=pos.get("tpSlMode", ""),
+                        take_profit=float(pos.get("takeProfit", 0)),
+                        stop_loss=float(pos.get("stopLoss", 0)),
+                        created_time=datetime.fromtimestamp(
+                            int(pos.get("createdTime", 0)) / 1000
+                        ) if pos.get("createdTime") else datetime.now(),
+                    ))
+        
+        return positions
+    
+    # ========== Spot Balance Methods ==========
+    
+    def get_spot_balance(self, coin: str) -> float:
+        """
+        Get available spot balance for a specific coin.
+        
+        Args:
+            coin: Coin symbol (e.g., "BTC", "ETH", "USDT")
+            
+        Returns:
+            Available balance as float
+        """
+        result = self.get_wallet_balance(account_type="UNIFIED", coin=coin)
+        
+        try:
+            if result.get("retCode") == 0:
+                accounts = result.get("result", {}).get("list", [])
+                for account in accounts:
+                    coins = account.get("coin", [])
+                    for c in coins:
+                        if c.get("coin") == coin:
+                            return float(c.get("walletBalance", 0))
+        except Exception as e:
+            logger.error(f"Error getting spot balance for {coin}: {e}")
+        
+        return 0.0
+    
+    def get_all_spot_balances(self) -> Dict[str, float]:
+        """
+        Get all non-zero spot balances.
+        
+        Returns:
+            Dictionary of coin -> balance
+        """
+        result = self.get_wallet_balance(account_type="UNIFIED")
+        balances = {}
+        
+        try:
+            if result.get("retCode") == 0:
+                accounts = result.get("result", {}).get("list", [])
+                for account in accounts:
+                    coins = account.get("coin", [])
+                    for c in coins:
+                        balance = float(c.get("walletBalance", 0))
+                        if balance > 0:
+                            balances[c.get("coin")] = balance
+        except Exception as e:
+            logger.error(f"Error getting spot balances: {e}")
+        
+        return balances
+    
+    # ========== Utility Methods ==========
+    
+    def test_connection(self) -> bool:
+        """
+        Test API connection and authentication.
+        
+        Returns:
+            True if connection successful
+        """
+        try:
+            result = self.get_wallet_balance()
+            if result.get("retCode") == 0:
+                logger.info("✅ Bybit API connection successful")
+                return True
+            else:
+                logger.error(f"❌ Bybit API error: {result.get('retMsg')}")
+                return False
+        except Exception as e:
+            logger.error(f"❌ Bybit API connection failed: {e}")
+            return False
+    
+    def get_server_time(self) -> int:
+        """
+        Get Bybit server time.
+        
+        Returns:
+            Server timestamp in milliseconds
+        """
+        result = self._request("GET", "/v5/market/time", signed=False)
+        
+        if result.get("retCode") == 0:
+            return int(result.get("result", {}).get("timeSecond", 0)) * 1000
+        return 0
+