ivolatility-backtesting 1.4.0__py3-none-any.whl → 1.6.0__py3-none-any.whl

ivolatility_backtesting/ivolatility_backtesting.py

@@ -1,59 +1,48 @@
-"""
-ivolatility_backtesting.py - UNIVERSAL BACKTEST FRAMEWORK
-Version 4.1 - Dual RAM Display (Process + Container)
-
-Key Features:
-- ResourceMonitor: CPU/RAM tracking (cgroups v2 + psutil fallback)
-- Enhanced progress bar with ETA, CPU%, RAM
-- Shows BOTH Python process RAM AND container total RAM
-- api_call(): Auto-normalization for dict/DataFrame responses
-- 30+ metrics, charts, exports
-- One-command: run_backtest()
-
-Usage:
-    from ivolatility_backtesting import *
-    
-    init_api(os.getenv("API_KEY"))
-    
-    data = api_call('/equities/eod/stock-prices', 
-                   symbol='AAPL', 
-                   from_='2024-01-01',
-                   to='2024-12-31',
-                   debug=True)
-    
-    analyzer = run_backtest(my_strategy, CONFIG)
-
-Resource Monitoring:
-    - CPU: Process CPU % (smoothed over 5 readings)
-    - RAM: Shows BOTH metrics when in container:
-      * Green: Python process memory (your strategy)
-      * Blue: Total container memory (includes Jupyter, cache, etc.)
-    
-Progress Display Example:
-    Processing 2024-07-30 (144/252)
-    ETA: 5m 23s | CPU: 46.8% | RAM: 856MB (42%) Python | 1280MB (64%) Container
-    Container: 1.0 cores, 2.0GB limit
-"""
+# ============================================================
+# ivolatility_backtesting.py - ENHANCED VERSION
+# 
+# NEW FEATURES:
+# 1. Combined stop-loss (requires BOTH conditions)
+# 2. Parameter optimization framework
+# 3. Optimization results visualization
+# ============================================================
 
 import pandas as pd
 import numpy as np
 import matplotlib.pyplot as plt
 import seaborn as sns
-from datetime import datetime, timedelta
+from datetime import datetime
 import ivolatility as ivol
 import os
 import time
 import psutil
+import warnings
+from itertools import product
+warnings.filterwarnings('ignore', category=pd.errors.SettingWithCopyWarning)
+warnings.filterwarnings('ignore', message='.*SettingWithCopyWarning.*')
+warnings.filterwarnings('ignore', category=FutureWarning)
+warnings.filterwarnings('ignore', category=DeprecationWarning)
 
 sns.set_style('darkgrid')
 plt.rcParams['figure.figsize'] = (15, 8)
 
+def create_optimization_folder(base_dir='optimization_results'):
+    """
+    Create timestamped folder for optimization run
+    Returns: folder path (e.g., 'optimization_results/20250122_143025')
+    """
+    from pathlib import Path
+    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+    folder_path = Path(base_dir) / timestamp
+    folder_path.mkdir(parents=True, exist_ok=True)
+    print(f"\n📁 Created optimization folder: {folder_path}")
+    return str(folder_path)
 
 # ============================================================
 # RESOURCE MONITOR
 # ============================================================
 class ResourceMonitor:
-    """Monitor CPU and RAM - shows PROCESS resources (Python), not full container"""
+    """Monitor CPU and RAM with container support"""
     
     def __init__(self, show_container_total=False):
         self.process = psutil.Process()
@@ -61,38 +50,33 @@ class ResourceMonitor:
         self.last_cpu_time = None
         self.last_check_time = None
         self.use_cgroups = self._check_cgroups_v2()
-        self.show_container_total = show_container_total  # False = process RAM, True = container RAM
-        
-        # CPU smoothing for more stable readings
+        self.show_container_total = show_container_total
         self.cpu_history = []
-        self.cpu_history_max = 5  # Average over last 5 readings
+        self.cpu_history_max = 5
         
-        # Determine actual CPU quota for containers
         if self.use_cgroups:
             quota = self._read_cpu_quota()
             if quota and quota > 0:
-                self.cpu_count = quota  # Override with container quota
+                self.cpu_count = quota
         
         self.context = "Container" if self.use_cgroups else "Host"
         
     def _read_cpu_quota(self):
-        """Read CPU quota from cgroups v2 (returns cores, e.g., 1.5)"""
         try:
             with open('/sys/fs/cgroup/cpu.max', 'r') as f:
                 line = f.read().strip()
                 if line == 'max':
-                    return None  # No limit
+                    return None
                 parts = line.split()
                 if len(parts) == 2:
-                    quota = int(parts[0])  # microseconds
-                    period = int(parts[1])  # microseconds
-                    return quota / period  # cores (e.g., 100000/100000 = 1.0)
+                    quota = int(parts[0])
+                    period = int(parts[1])
+                    return quota / period
         except:
             pass
         return None
         
     def get_context_info(self):
-        """Returns monitoring context and resource limits"""
         if self.use_cgroups:
             current, max_mem = self._read_cgroup_memory()
             ram_info = ""
@@ -139,7 +123,6 @@ class ResourceMonitor:
         return None, None
     
     def get_cpu_percent(self):
-        """Get CPU% with smoothing - shows container limits if in container, host if not"""
         if self.use_cgroups:
             current_time = time.time()
             current_cpu = self._read_cgroup_cpu()
@@ -149,13 +132,9 @@ class ResourceMonitor:
                 cpu_delta = current_cpu - self.last_cpu_time
                 
                 if time_delta > 0:
-                    # Calculate based on container CPU quota
                     cpu_percent = (cpu_delta / (time_delta * 1_000_000)) * 100
-                    
-                    # Clamp to container limits
                     cpu_percent = min(cpu_percent, 100 * self.cpu_count)
                     
-                    # Add to history for smoothing
                     self.cpu_history.append(cpu_percent)
                     if len(self.cpu_history) > self.cpu_history_max:
                         self.cpu_history.pop(0)
@@ -163,13 +142,11 @@ class ResourceMonitor:
                     self.last_cpu_time = current_cpu
                     self.last_check_time = current_time
                     
-                    # Return smoothed average
                     return round(sum(self.cpu_history) / len(self.cpu_history), 1)
             
             self.last_cpu_time = current_cpu
             self.last_check_time = current_time
         
-        # Fallback: host resources with smoothing
         try:
             cpu = self.process.cpu_percent(interval=0.1)
             if cpu == 0:
@@ -184,20 +161,11 @@ class ResourceMonitor:
             return 0.0
     
     def get_memory_info(self):
-        """
-        Get memory usage - returns BOTH process and container/host
-        
-        Returns:
-            tuple: (process_mb, process_pct, container_mb, container_pct)
-                   If no container, container values = process values
-        """
         try:
-            # Get process memory (Python only)
             mem = self.process.memory_info()
             process_mb = mem.rss / (1024 * 1024)
             
             if self.use_cgroups:
-                # Get container total and limit
                 current, max_mem = self._read_cgroup_memory()
                 if max_mem:
                     process_percent = (mem.rss / max_mem) * 100
@@ -212,7 +180,6 @@ class ResourceMonitor:
                             round(container_percent, 1)
                         )
                     
-                    # No container data, return process only
                     return (
                         round(process_mb, 1), 
                         round(process_percent, 1),
@@ -220,11 +187,9 @@ class ResourceMonitor:
                         round(process_percent, 1)
                     )
             
-            # Host: calculate % of total RAM
             total = psutil.virtual_memory().total
             percent = (mem.rss / total) * 100
             
-            # On host, process = "container" (no container isolation)
             return (
                 round(process_mb, 1), 
                 round(percent, 1),
@@ -236,35 +201,47 @@ class ResourceMonitor:
             return 0.0, 0.0, 0.0, 0.0
 
 
-def create_progress_bar():
-    """Create enhanced progress bar with ETA, CPU%, RAM"""
-    from IPython.display import display
-    import ipywidgets as widgets
-    
-    progress_bar = widgets.FloatProgress(
-        value=0, min=0, max=100,
-        description='Progress:',
-        bar_style='info',
-        style={'bar_color': '#00ff00'},
-        layout=widgets.Layout(width='100%', height='30px')
-    )
-    
-    status_label = widgets.HTML(
-        value="<b style='color:#0066cc'>Starting...</b>"
-    )
-    
-    display(widgets.VBox([progress_bar, status_label]))
+def create_progress_bar(reuse_existing=None):
+    """Create or reuse enhanced progress bar"""
+    if reuse_existing is not None:
+        progress_bar, status_label, monitor, start_time = reuse_existing
+        progress_bar.value = 0
+        progress_bar.bar_style = 'info'
+        status_label.value = "<b style='color:#0066cc'>Starting...</b>"
+        return progress_bar, status_label, monitor, time.time()
     
-    monitor = ResourceMonitor()
-    start_time = time.time()
-    
-    return progress_bar, status_label, monitor, start_time
+    try:
+        from IPython.display import display
+        import ipywidgets as widgets
+        
+        progress_bar = widgets.FloatProgress(
+            value=0, min=0, max=100,
+            description='Progress:',
+            bar_style='info',
+            style={'bar_color': '#00ff00'},
+            layout=widgets.Layout(width='100%', height='30px')
+        )
+        
+        status_label = widgets.HTML(
+            value="<b style='color:#0066cc'>Starting...</b>"
+        )
+        
+        display(widgets.VBox([progress_bar, status_label]))
+        
+        monitor = ResourceMonitor()
+        start_time = time.time()
+        
+        return progress_bar, status_label, monitor, start_time
+    except ImportError:
+        print("Warning: ipywidgets not available. Progress bar disabled.")
+        return None, None, ResourceMonitor(), time.time()
 
 
 def update_progress(progress_bar, status_label, monitor, current, total, start_time, message="Processing"):
-    """
-    Update progress bar with ETA, CPU%, RAM (shows BOTH process and container)
-    """
+    """Update progress bar with ETA, CPU%, RAM"""
+    if progress_bar is None or status_label is None:
+        return
+    
     progress = (current / total) * 100
     progress_bar.value = progress
     
@@ -278,28 +255,23 @@ def update_progress(progress_bar, status_label, monitor, current, total, start_t
     cpu = monitor.get_cpu_percent()
     process_mb, process_pct, container_mb, container_pct = monitor.get_memory_info()
     
-    # Build RAM display - show both if different, otherwise just one
-    if abs(container_mb - process_mb) > 10:  # Significant difference (>10MB)
+    if abs(container_mb - process_mb) > 10:
         ram_display = (
             f"RAM: <span style='color:#4CAF50'>{process_mb}MB ({process_pct}%)</span> Python | "
             f"<span style='color:#2196F3'>{container_mb}MB ({container_pct}%)</span> Container"
         )
     else:
-        # Same values (on host or small difference)
         ram_display = f"RAM: {process_mb}MB ({process_pct}%)"
     
-    # Context info
-    if monitor.use_cgroups:
-        context_info = f"Container: {monitor.cpu_count:.1f} cores"
-        current, max_mem = monitor._read_cgroup_memory()
-        if max_mem:
-            context_info += f", {max_mem / (1024**3):.1f}GB limit"
-    else:
-        context_info = f"Host: {monitor.cpu_count} cores"
+    context_info = monitor.get_context_info()
+
+    elapsed_str = format_time(elapsed)
+    start_time_str = datetime.fromtimestamp(start_time).strftime('%H:%M:%S')
     
     status_label.value = (
         f"<b style='color:#0066cc'>{message} ({current}/{total})</b><br>"
-        f"<span style='color:#666'>ETA: {eta_str} | CPU: {cpu}% | {ram_display}</span><br>"
+        f"<span style='color:#666'>⏱️ Elapsed: {elapsed_str} | ETA: {eta_str} | Started: {start_time_str}</span><br>"
+        f"<span style='color:#666'>CPU: {cpu}% | {ram_display}</span><br>"
         f"<span style='color:#999;font-size:10px'>{context_info}</span>"
     )
 
@@ -317,10 +289,10 @@ def format_time(seconds):
 
 
 # ============================================================
-# API HELPER - AUTOMATIC NORMALIZATION
+# API HELPER
 # ============================================================
 class APIHelper:
-    """Normalizes API responses to consistent format"""
+    """Normalizes API responses"""
     
     @staticmethod
     def normalize_response(response, debug=False):
@@ -464,7 +436,572 @@ class BacktestResults:
 
 
 # ============================================================
-# BACKTEST ANALYZER (30+ METRICS)
+# STOP-LOSS MANAGER (ENHANCED VERSION WITH COMBINED STOP)
+# ============================================================
+class StopLossManager:
+    """
+    Enhanced stop-loss manager with COMBINED STOP support
+    
+    NEW STOP TYPE:
+    - combined: Requires BOTH pl_loss AND directional conditions (from code 2)
+    """
+    
+    def __init__(self):
+        self.positions = {}
+    
+    def add_position(self, position_id, entry_price, entry_date, stop_type='fixed_pct', 
+                    stop_value=0.05, atr=None, trailing_distance=None, use_pnl_pct=False,
+                    is_short_bias=False, **kwargs):
+        """
+        Add position with stop-loss
+        
+        NEW for combined stop:
+            stop_type='combined'
+            stop_value={'pl_loss': 0.05, 'directional': 0.03}
+        """
+        self.positions[position_id] = {
+            'entry_price': entry_price,
+            'entry_date': entry_date,
+            'stop_type': stop_type,
+            'stop_value': stop_value,
+            'atr': atr,
+            'trailing_distance': trailing_distance,
+            'highest_price': entry_price if not use_pnl_pct else 0,
+            'lowest_price': entry_price if not use_pnl_pct else 0,
+            'max_profit': 0,
+            'use_pnl_pct': use_pnl_pct,
+            'is_short_bias': is_short_bias,
+            **kwargs  # Store additional parameters for combined stop
+        }
+    
+    def check_stop(self, position_id, current_price, current_date, position_type='LONG', **kwargs):
+        """
+        Check if stop-loss triggered
+        
+        NEW: Supports 'combined' stop type
+        """
+        if position_id not in self.positions:
+            return False, None, None
+        
+        pos = self.positions[position_id]
+        stop_type = pos['stop_type']
+        use_pnl_pct = pos.get('use_pnl_pct', False)
+        
+        # Update tracking
+        if use_pnl_pct:
+            pnl_pct = current_price
+            pos['highest_price'] = max(pos['highest_price'], pnl_pct)
+            pos['lowest_price'] = min(pos['lowest_price'], pnl_pct)
+            pos['max_profit'] = max(pos['max_profit'], pnl_pct)
+        else:
+            if position_type == 'LONG':
+                pos['highest_price'] = max(pos['highest_price'], current_price)
+                current_profit = current_price - pos['entry_price']
+            else:
+                pos['lowest_price'] = min(pos['lowest_price'], current_price)
+                current_profit = pos['entry_price'] - current_price
+            
+            pos['max_profit'] = max(pos['max_profit'], current_profit)
+        
+        # Route to appropriate check method
+        if stop_type == 'fixed_pct':
+            if use_pnl_pct:
+                return self._check_fixed_pct_stop_pnl(pos, current_price)
+            else:
+                return self._check_fixed_pct_stop(pos, current_price, position_type)
+        
+        elif stop_type == 'trailing':
+            if use_pnl_pct:
+                return self._check_trailing_stop_pnl(pos, current_price)
+            else:
+                return self._check_trailing_stop(pos, current_price, position_type)
+        
+        elif stop_type == 'time_based':
+            return self._check_time_stop(pos, current_date)
+        
+        elif stop_type == 'volatility':
+            return self._check_volatility_stop(pos, current_price, position_type)
+        
+        elif stop_type == 'pl_loss':
+            return self._check_pl_loss_stop(pos, kwargs)
+        
+        elif stop_type == 'directional':
+            return self._check_directional_stop(pos, kwargs)
+        
+        # NEW: COMBINED STOP (requires BOTH conditions)
+        elif stop_type == 'combined':
+            return self._check_combined_stop(pos, kwargs)
+        
+        else:
+            return False, None, None
+    
+    # ========================================================
+    # EXISTING STOP METHODS (unchanged)
+    # ========================================================
+    
+    def _check_fixed_pct_stop(self, pos, current_price, position_type):
+        """Fixed percentage stop-loss (price-based)"""
+        entry = pos['entry_price']
+        stop_pct = pos['stop_value']
+        
+        if position_type == 'LONG':
+            stop_level = entry * (1 - stop_pct)
+            triggered = current_price <= stop_level
+        else:
+            stop_level = entry * (1 + stop_pct)
+            triggered = current_price >= stop_level
+        
+        return triggered, stop_level, 'fixed_pct'
+    
+    def _check_fixed_pct_stop_pnl(self, pos, pnl_pct):
+        """Fixed percentage stop-loss (P&L%-based for options)"""
+        stop_pct = pos['stop_value']
+        stop_level = -stop_pct * 100
+        
+        triggered = pnl_pct <= stop_level
+        
+        return triggered, stop_level, 'fixed_pct'
+    
+    def _check_trailing_stop(self, pos, current_price, position_type):
+        """Trailing stop-loss (price-based)"""
+        if pos['trailing_distance'] is None:
+            pos['trailing_distance'] = pos['stop_value']
+        
+        distance = pos['trailing_distance']
+        
+        if position_type == 'LONG':
+            stop_level = pos['highest_price'] * (1 - distance)
+            triggered = current_price <= stop_level
+        else:
+            stop_level = pos['lowest_price'] * (1 + distance)
+            triggered = current_price >= stop_level
+        
+        return triggered, stop_level, 'trailing'
+    
+    def _check_trailing_stop_pnl(self, pos, pnl_pct):
+        """Trailing stop-loss (P&L%-based for options)"""
+        if pos['trailing_distance'] is None:
+            pos['trailing_distance'] = pos['stop_value']
+        
+        distance = pos['trailing_distance'] * 100
+        
+        stop_level = pos['highest_price'] - distance
+        
+        triggered = pnl_pct <= stop_level
+        
+        return triggered, stop_level, 'trailing'
+    
+    def _check_time_stop(self, pos, current_date):
+        """Time-based stop"""
+        days_held = (current_date - pos['entry_date']).days
+        max_days = pos['stop_value']
+        
+        triggered = days_held >= max_days
+        return triggered, None, 'time_based'
+    
+    def _check_volatility_stop(self, pos, current_price, position_type):
+        """ATR-based stop"""
+        if pos['atr'] is None:
+            return False, None, None
+        
+        entry = pos['entry_price']
+        atr_multiplier = pos['stop_value']
+        stop_distance = pos['atr'] * atr_multiplier
+        
+        if position_type == 'LONG':
+            stop_level = entry - stop_distance
+            triggered = current_price <= stop_level
+        else:
+            stop_level = entry + stop_distance
+            triggered = current_price >= stop_level
+        
+        return triggered, stop_level, 'volatility'
+    
+    def _check_pl_loss_stop(self, pos, kwargs):
+        """Stop-loss based on actual P&L"""
+        pnl_pct = kwargs.get('pnl_pct')
+        
+        if pnl_pct is None:
+            current_pnl = kwargs.get('current_pnl', 0)
+            total_cost = kwargs.get('total_cost', pos.get('total_cost', 1))
+            
+            if total_cost > 0:
+                pnl_pct = (current_pnl / total_cost) * 100
+            else:
+                pnl_pct = 0
+        
+        stop_threshold = -pos['stop_value'] * 100
+        triggered = pnl_pct <= stop_threshold
+        
+        return triggered, stop_threshold, 'pl_loss'
+    
+    def _check_directional_stop(self, pos, kwargs):
+        """Stop-loss based on underlying price movement"""
+        underlying_change_pct = kwargs.get('underlying_change_pct')
+        
+        if underlying_change_pct is None:
+            current = kwargs.get('underlying_price')
+            entry = kwargs.get('underlying_entry_price', pos.get('underlying_entry_price'))
+            
+            if current is not None and entry is not None and entry != 0:
+                underlying_change_pct = ((current - entry) / entry) * 100
+            else:
+                underlying_change_pct = 0
+        
+        threshold = pos['stop_value'] * 100
+        is_short_bias = pos.get('is_short_bias', False)
+        
+        if is_short_bias:
+            triggered = underlying_change_pct >= threshold
+        else:
+            triggered = underlying_change_pct <= -threshold
+        
+        return triggered, threshold, 'directional'
+    
+    # ========================================================
+    # NEW: COMBINED STOP (REQUIRES BOTH CONDITIONS)
+    # ========================================================
+    
+    def _check_combined_stop(self, pos, kwargs):
+        """
+        Combined stop: Requires BOTH pl_loss AND directional conditions
+        
+        This is the key feature from code 2:
+        - Must have P&L loss > threshold
+        - AND underlying must move adversely > threshold
+        
+        Args:
+            pos: Position dict with stop_value = {'pl_loss': 0.05, 'directional': 0.03}
+            kwargs: Must contain pnl_pct and underlying_change_pct
+        
+        Returns:
+            tuple: (triggered, thresholds_dict, 'combined')
+        """
+        stop_config = pos['stop_value']
+        
+        if not isinstance(stop_config, dict):
+            # Fallback: treat as simple fixed stop
+            return False, None, 'combined'
+        
+        pl_threshold = stop_config.get('pl_loss', 0.05)
+        dir_threshold = stop_config.get('directional', 0.03)
+        
+        # Check P&L condition
+        pnl_pct = kwargs.get('pnl_pct', 0)
+        is_losing = pnl_pct <= (-pl_threshold * 100)
+        
+        # Check directional condition
+        underlying_change_pct = kwargs.get('underlying_change_pct')
+        
+        if underlying_change_pct is None:
+            current = kwargs.get('underlying_price')
+            entry = kwargs.get('underlying_entry_price', pos.get('underlying_entry_price'))
+            
+            if current is not None and entry is not None and entry != 0:
+                underlying_change_pct = ((current - entry) / entry) * 100
+            else:
+                underlying_change_pct = 0
+        
+        is_short_bias = pos.get('is_short_bias', False)
+        
+        if is_short_bias:
+            # Bearish position: adverse move is UP
+            adverse_move = underlying_change_pct >= (dir_threshold * 100)
+        else:
+            # Bullish position: adverse move is DOWN
+            adverse_move = underlying_change_pct <= (-dir_threshold * 100)
+        
+        # CRITICAL: Both conditions must be true
+        triggered = is_losing and adverse_move
+        
+        # Return detailed thresholds for reporting
+        thresholds = {
+            'pl_threshold': -pl_threshold * 100,
+            'dir_threshold': dir_threshold * 100,
+            'actual_pnl_pct': pnl_pct,
+            'actual_underlying_change': underlying_change_pct,
+            'pl_condition': is_losing,
+            'dir_condition': adverse_move
+        }
+        
+        return triggered, thresholds, 'combined'
+    
+    # ========================================================
+    # UTILITY METHODS
+    # ========================================================
+    
+    def remove_position(self, position_id):
+        """Remove position from tracking"""
+        if position_id in self.positions:
+            del self.positions[position_id]
+    
+    def get_position_info(self, position_id):
+        """Get position stop-loss info"""
+        if position_id not in self.positions:
+            return None
+        
+        pos = self.positions[position_id]
+        return {
+            'stop_type': pos['stop_type'],
+            'stop_value': pos['stop_value'],
+            'max_profit_before_stop': pos['max_profit']
+        }
+
+
+# ============================================================
+# POSITION MANAGER (unchanged but compatible with combined stop)
+# ============================================================
+class PositionManager:
+    """Universal Position Manager with automatic mode detection"""
+    
+    def __init__(self, config, debug=False):
+        self.positions = {}
+        self.closed_trades = []
+        self.config = config
+        self.debug = debug
+        
+        self.sl_enabled = config.get('stop_loss_enabled', False)
+        if self.sl_enabled:
+            self.sl_config = config.get('stop_loss_config', {})
+            self.sl_manager = StopLossManager()
+        else:
+            self.sl_config = None
+            self.sl_manager = None
+    
+    def open_position(self, position_id, symbol, entry_date, entry_price, 
+                      quantity, position_type='LONG', **kwargs):
+        """Open position with automatic stop-loss"""
+        
+        if entry_price == 0 and self.sl_enabled:
+            if 'total_cost' not in kwargs or kwargs['total_cost'] == 0:
+                raise ValueError(
+                    f"\n{'='*70}\n"
+                    f"ERROR: P&L% mode requires 'total_cost' parameter\n"
+                    f"{'='*70}\n"
+                )
+        
+        position = {
+            'id': position_id,
+            'symbol': symbol,
+            'entry_date': entry_date,
+            'entry_price': entry_price,
+            'quantity': quantity,
+            'type': position_type,
+            'highest_price': entry_price,
+            'lowest_price': entry_price,
+            **kwargs
+        }
+        
+        self.positions[position_id] = position
+        
+        if self.sl_enabled and self.sl_manager:
+            sl_type = self.sl_config.get('type', 'fixed_pct')
+            sl_value = self.sl_config.get('value', 0.05)
+            
+            use_pnl_pct = (entry_price == 0)
+            is_short_bias = kwargs.get('is_short_bias', False)
+            
+            # Pass underlying_entry_price for combined stop
+            self.sl_manager.add_position(
+                position_id=position_id,
+                entry_price=entry_price,
+                entry_date=entry_date,
+                stop_type=sl_type,
+                stop_value=sl_value,
+                atr=kwargs.get('atr', None),
+                trailing_distance=self.sl_config.get('trailing_distance', None),
+                use_pnl_pct=use_pnl_pct,
+                is_short_bias=is_short_bias,
+                underlying_entry_price=kwargs.get('entry_stock_price')  # For combined stop
+            )
+        
+        if self.debug:
+            mode = "P&L%" if entry_price == 0 else "Price"
+            bias = " (SHORT BIAS)" if kwargs.get('is_short_bias') else ""
+            print(f"[PositionManager] OPEN {position_id}: {symbol} @ {entry_price} (Mode: {mode}{bias})")
+        
+        return position
+    
+    def check_positions(self, current_date, price_data):
+        """Check all positions for stop-loss triggers"""
+        if not self.sl_enabled:
+            return []
+        
+        to_close = []
+        
+        for position_id, position in self.positions.items():
+            if position_id not in price_data:
+                continue
+            
+            if isinstance(price_data[position_id], dict):
+                data = price_data[position_id]
+                current_price = data.get('price', position['entry_price'])
+                current_pnl = data.get('pnl', 0)
+                current_pnl_pct = data.get('pnl_pct', 0)
+                
+                # NEW: Pass underlying data for combined stop
+                underlying_price = data.get('underlying_price')
+                underlying_entry_price = data.get('underlying_entry_price')
+                underlying_change_pct = data.get('underlying_change_pct')
+            else:
+                current_price = price_data[position_id]
+                current_pnl = (current_price - position['entry_price']) * position['quantity']
+                current_pnl_pct = (current_price - position['entry_price']) / position['entry_price'] if position['entry_price'] != 0 else 0
+                underlying_price = None
+                underlying_entry_price = None
+                underlying_change_pct = None
+            
+            position['highest_price'] = max(position['highest_price'], current_price)
+            position['lowest_price'] = min(position['lowest_price'], current_price)
+            
+            if position['entry_price'] == 0:
+                check_value = current_pnl_pct
+            else:
+                check_value = current_price
+            
+            # Pass all data to stop manager
+            stop_kwargs = {
+                'pnl_pct': current_pnl_pct,
+                'current_pnl': current_pnl,
+                'total_cost': position.get('total_cost', 1),
+                'underlying_price': underlying_price,
+                'underlying_entry_price': underlying_entry_price or position.get('entry_stock_price'),
+                'underlying_change_pct': underlying_change_pct
+            }
+            
+            triggered, stop_level, stop_type = self.sl_manager.check_stop(
+                position_id=position_id,
+                current_price=check_value,
+                current_date=current_date,
+                position_type=position['type'],
+                **stop_kwargs
+            )
+            
+            if triggered:
+                to_close.append({
+                    'position_id': position_id,
+                    'symbol': position['symbol'], 
+                    'stop_type': stop_type,
+                    'stop_level': stop_level,
+                    'current_price': current_price,
+                    'pnl': current_pnl,
+                    'pnl_pct': current_pnl_pct
+                })
+                
+                if self.debug:
+                    mode = "P&L%" if position['entry_price'] == 0 else "Price"
+                    print(f"[PositionManager] STOP-LOSS: {position_id} ({stop_type}, {mode}) @ {check_value:.2f}")
+        
+        return to_close
+    
+    def close_position(self, position_id, exit_date, exit_price, 
+                       close_reason='manual', pnl=None, **kwargs):
+        """Close position"""
+        if position_id not in self.positions:
+            if self.debug:
+                print(f"[PositionManager] WARNING: Position {position_id} not found")
+            return None
+        
+        position = self.positions.pop(position_id)
+        
+        if pnl is None:
+            pnl = (exit_price - position['entry_price']) * position['quantity']
+        
+        if position['entry_price'] != 0:
+            pnl_pct = (exit_price - position['entry_price']) / position['entry_price'] * 100
+        else:
+            if 'total_cost' in position and position['total_cost'] != 0:
+                pnl_pct = (pnl / position['total_cost']) * 100
+            elif 'total_cost' in kwargs and kwargs['total_cost'] != 0:
+                pnl_pct = (pnl / kwargs['total_cost']) * 100
+            else:
+                pnl_pct = 0.0        
+                
+        trade = {
+            'entry_date': position['entry_date'],
+            'exit_date': exit_date,
+            'symbol': position['symbol'],
+            'signal': position['type'],
+            'entry_price': position['entry_price'],
+            'exit_price': exit_price,
+            'quantity': position['quantity'],
+            'pnl': pnl,
+            'return_pct': pnl_pct,
+            'exit_reason': close_reason,
+            'stop_type': self.sl_config.get('type', 'none') if self.sl_enabled else 'none',
+            **kwargs
+        }
+        
+        for key in ['call_strike', 'put_strike', 'expiration', 'contracts', 
+                    'short_strike', 'long_strike', 'opt_type', 'spread_type',
+                    'entry_z_score', 'is_short_bias', 'entry_lean', 'exit_lean',
+                    'call_iv_entry', 'put_iv_entry', 'iv_lean_entry']:
+            if key in position:
+                trade[key] = position[key]
+        
+        for key in ['short_entry_bid', 'short_entry_ask', 'short_entry_mid',
+                    'long_entry_bid', 'long_entry_ask', 'long_entry_mid',
+                    'underlying_entry_price']:
+            if key in position:
+                trade[key] = position[key]
+        
+        for key in ['short_exit_bid', 'short_exit_ask',
+                    'long_exit_bid', 'long_exit_ask',
+                    'underlying_exit_price', 'underlying_change_pct',
+                    'stop_threshold', 'actual_value',
+                    'call_iv_exit', 'put_iv_exit', 'iv_lean_exit',
+                    'spy_intraday_high', 'spy_intraday_low', 'spy_intraday_close',
+                    'spy_stop_trigger_time', 'spy_stop_trigger_price',
+                    'spy_stop_trigger_bid', 'spy_stop_trigger_ask', 'spy_stop_trigger_last',
+                    'intraday_data_points', 'intraday_data_available', 'stop_triggered_by']:
+            if key in kwargs:
+                trade[key] = kwargs[key]
+        
+        self.closed_trades.append(trade)
+        
+        if self.sl_enabled and self.sl_manager:
+            self.sl_manager.remove_position(position_id)
+        
+        if self.debug:
+            print(f"[PositionManager] CLOSE {position_id}: P&L=${pnl:.2f} ({pnl_pct:.2f}%) - {close_reason}")
+        
+        return trade
+            
+    def get_open_positions(self):
+        return list(self.positions.values())
+    
+    def get_closed_trades(self):
+        return self.closed_trades
+    
+    def close_all_positions(self, final_date, price_data, reason='end_of_backtest'):
+        """Close all open positions at end of backtest"""
+        for position_id in list(self.positions.keys()):
+            if position_id in price_data:
+                position = self.positions[position_id]
+                
+                if isinstance(price_data[position_id], dict):
+                    data = price_data[position_id]
+                    exit_price = data.get('price', position['entry_price'])
+                    pnl = data.get('pnl', None)
+                else:
+                    exit_price = price_data[position_id]
+                    pnl = None
+                
+                if pnl is None and position['entry_price'] == 0:
+                    if isinstance(price_data[position_id], dict) and 'pnl' in price_data[position_id]:
+                        pnl = price_data[position_id]['pnl']
+                
+                self.close_position(
+                    position_id=position_id,
+                    exit_date=final_date,
+                    exit_price=exit_price,
+                    close_reason=reason,
+                    pnl=pnl
+                )
+
+
+# ============================================================
+# BACKTEST ANALYZER (unchanged)
 # ============================================================
 class BacktestAnalyzer:
     """Calculate all metrics from BacktestResults"""
@@ -476,11 +1013,12 @@ class BacktestAnalyzer:
     def calculate_all_metrics(self):
         r = self.results
         
-        # Profitability
+        self.metrics['initial_capital'] = r.initial_capital
+        self.metrics['final_equity'] = r.final_capital
+        
         self.metrics['total_pnl'] = r.final_capital - r.initial_capital
         self.metrics['total_return'] = (self.metrics['total_pnl'] / r.initial_capital) * 100
         
-        # CAGR
         if len(r.equity_dates) > 0:
             start_date = min(r.equity_dates)
             end_date = max(r.equity_dates)
@@ -501,7 +1039,6 @@ class BacktestAnalyzer:
             self.metrics['cagr'] = 0
             self.metrics['show_cagr'] = False
         
-        # Risk metrics
         self.metrics['sharpe'] = self._sharpe_ratio(r.daily_returns)
         self.metrics['sortino'] = self._sortino_ratio(r.daily_returns)
         self.metrics['max_drawdown'] = r.max_drawdown
@@ -510,7 +1047,6 @@ class BacktestAnalyzer:
         self.metrics['omega'] = self._omega_ratio(r.daily_returns)
         self.metrics['ulcer'] = self._ulcer_index(r.equity_curve)
         
-        # VaR
         self.metrics['var_95'], self.metrics['var_95_pct'] = self._calculate_var(r.daily_returns, 0.95)
         self.metrics['var_99'], self.metrics['var_99_pct'] = self._calculate_var(r.daily_returns, 0.99)
         self.metrics['cvar_95'], self.metrics['cvar_95_pct'] = self._calculate_cvar(r.daily_returns, 0.95)
@@ -520,25 +1056,20 @@ class BacktestAnalyzer:
         self.metrics['var_99_dollar'] = self.metrics['var_99'] * avg_equity
         self.metrics['cvar_95_dollar'] = self.metrics['cvar_95'] * avg_equity
         
-        # Distribution
         self.metrics['tail_ratio'] = self._tail_ratio(r.daily_returns)
         self.metrics['skewness'], self.metrics['kurtosis'] = self._skewness_kurtosis(r.daily_returns)
         
-        # Alpha/Beta
         self.metrics['alpha'], self.metrics['beta'], self.metrics['r_squared'] = self._alpha_beta(r)
         
-        # Trading stats
         if len(r.trades) > 0:
             self._calculate_trading_stats(r.trades)
         else:
             self._set_empty_trading_stats()
         
-        # Efficiency
         running_max = np.maximum.accumulate(r.equity_curve)
         max_dd_dollars = np.min(np.array(r.equity_curve) - running_max)
         self.metrics['recovery_factor'] = self.metrics['total_pnl'] / abs(max_dd_dollars) if max_dd_dollars != 0 else 0
         
-        # Exposure time
         if len(r.trades) > 0 and 'start_date' in r.config and 'end_date' in r.config:
             total_days = (pd.to_datetime(r.config['end_date']) - pd.to_datetime(r.config['start_date'])).days
             self.metrics['exposure_time'] = self._exposure_time(r.trades, total_days)
@@ -724,15 +1255,116 @@ class BacktestAnalyzer:
         days_with_positions = set()
         for trade in trades:
             entry = pd.to_datetime(trade['entry_date'])
-            exit = pd.to_datetime(trade['exit_date'])
-            date_range = pd.date_range(start=entry, end=exit, freq='D')
+            exit_ = pd.to_datetime(trade['exit_date'])
+            date_range = pd.date_range(start=entry, end=exit_, freq='D')
             days_with_positions.update(date_range.date)
         exposure_pct = (len(days_with_positions) / total_days) * 100
         return min(exposure_pct, 100.0)
 
 
 # ============================================================
-# RESULTS REPORTER
+# STOP-LOSS METRICS (unchanged)
+# ============================================================
+def calculate_stoploss_metrics(analyzer):
+    """Calculate stop-loss specific metrics"""
+    if len(analyzer.results.trades) == 0:
+        _set_empty_stoploss_metrics(analyzer)
+        return analyzer.metrics
+    
+    trades_df = pd.DataFrame(analyzer.results.trades)
+    
+    if 'exit_reason' not in trades_df.columns:
+        _set_empty_stoploss_metrics(analyzer)
+        return analyzer.metrics
+    
+    sl_trades = trades_df[trades_df['exit_reason'].str.contains('stop_loss', na=False)]
+    profit_target_trades = trades_df[trades_df['exit_reason'] == 'profit_target']
+    
+    analyzer.metrics['stoploss_count'] = len(sl_trades)
+    analyzer.metrics['stoploss_pct'] = (len(sl_trades) / len(trades_df)) * 100 if len(trades_df) > 0 else 0
+    analyzer.metrics['profit_target_count'] = len(profit_target_trades)
+    analyzer.metrics['profit_target_pct'] = (len(profit_target_trades) / len(trades_df)) * 100 if len(trades_df) > 0 else 0
+    
+    if len(sl_trades) > 0:
+        analyzer.metrics['avg_stoploss_pnl'] = sl_trades['pnl'].mean()
+        analyzer.metrics['total_stoploss_loss'] = sl_trades['pnl'].sum()
+        analyzer.metrics['worst_stoploss'] = sl_trades['pnl'].min()
+        
+        if 'return_pct' in sl_trades.columns:
+            analyzer.metrics['avg_stoploss_return_pct'] = sl_trades['return_pct'].mean()
+        else:
+            analyzer.metrics['avg_stoploss_return_pct'] = 0
+        
+        if 'entry_date' in sl_trades.columns and 'exit_date' in sl_trades.columns:
+            sl_trades_copy = sl_trades.copy()
+            sl_trades_copy['entry_date'] = pd.to_datetime(sl_trades_copy['entry_date'])
+            sl_trades_copy['exit_date'] = pd.to_datetime(sl_trades_copy['exit_date'])
+            sl_trades_copy['days_held'] = (sl_trades_copy['exit_date'] - sl_trades_copy['entry_date']).dt.days
+            analyzer.metrics['avg_days_to_stoploss'] = sl_trades_copy['days_held'].mean()
+            analyzer.metrics['min_days_to_stoploss'] = sl_trades_copy['days_held'].min()
+            analyzer.metrics['max_days_to_stoploss'] = sl_trades_copy['days_held'].max()
+        else:
+            analyzer.metrics['avg_days_to_stoploss'] = 0
+            analyzer.metrics['min_days_to_stoploss'] = 0
+            analyzer.metrics['max_days_to_stoploss'] = 0
+        
+        if 'stop_type' in sl_trades.columns:
+            stop_types = sl_trades['stop_type'].value_counts().to_dict()
+            analyzer.metrics['stoploss_by_type'] = stop_types
+        else:
+            analyzer.metrics['stoploss_by_type'] = {}
+    else:
+        analyzer.metrics['avg_stoploss_pnl'] = 0
+        analyzer.metrics['total_stoploss_loss'] = 0
+        analyzer.metrics['worst_stoploss'] = 0
+        analyzer.metrics['avg_stoploss_return_pct'] = 0
+        analyzer.metrics['avg_days_to_stoploss'] = 0
+        analyzer.metrics['min_days_to_stoploss'] = 0
+        analyzer.metrics['max_days_to_stoploss'] = 0
+        analyzer.metrics['stoploss_by_type'] = {}
+    
+    if len(profit_target_trades) > 0 and len(sl_trades) > 0:
+        avg_profit_target = profit_target_trades['pnl'].mean()
+        avg_stoploss = abs(sl_trades['pnl'].mean())
+        analyzer.metrics['profit_to_loss_ratio'] = avg_profit_target / avg_stoploss if avg_stoploss > 0 else 0
+    else:
+        analyzer.metrics['profit_to_loss_ratio'] = 0
+    
+    if 'max_profit_before_stop' in sl_trades.columns:
+        early_exits = sl_trades[sl_trades['max_profit_before_stop'] > 0]
+        analyzer.metrics['early_exit_count'] = len(early_exits)
+        analyzer.metrics['early_exit_pct'] = (len(early_exits) / len(sl_trades)) * 100 if len(sl_trades) > 0 else 0
+        if len(early_exits) > 0:
+            analyzer.metrics['avg_missed_profit'] = early_exits['max_profit_before_stop'].mean()
+        else:
+            analyzer.metrics['avg_missed_profit'] = 0
+    else:
+        analyzer.metrics['early_exit_count'] = 0
+        analyzer.metrics['early_exit_pct'] = 0
+        analyzer.metrics['avg_missed_profit'] = 0
+    
+    exit_reasons = trades_df['exit_reason'].value_counts().to_dict()
+    analyzer.metrics['exit_reasons'] = exit_reasons
+    
+    return analyzer.metrics
+
+
+def _set_empty_stoploss_metrics(analyzer):
+    analyzer.metrics.update({
+        'stoploss_count': 0, 'stoploss_pct': 0,
+        'profit_target_count': 0, 'profit_target_pct': 0,
+        'avg_stoploss_pnl': 0, 'total_stoploss_loss': 0,
+        'worst_stoploss': 0, 'avg_stoploss_return_pct': 0,
+        'avg_days_to_stoploss': 0, 'min_days_to_stoploss': 0,
+        'max_days_to_stoploss': 0, 'stoploss_by_type': {},
+        'profit_to_loss_ratio': 0, 'early_exit_count': 0,
+        'early_exit_pct': 0, 'avg_missed_profit': 0,
+        'exit_reasons': {}
+    })
+
+
+# ============================================================
+# RESULTS REPORTER (unchanged)
 # ============================================================
 class ResultsReporter:
     """Print comprehensive metrics report"""
@@ -747,15 +1379,6 @@ class ResultsReporter:
         print("="*80)
         print()
         
-        if hasattr(r, 'debug_info') and len(r.debug_info) > 0:
-            print("DEBUG INFORMATION")
-            print("-"*80)
-            for debug_msg in r.debug_info[:10]:
-                print(debug_msg)
-            if len(r.debug_info) > 10:
-                print(f"... and {len(r.debug_info) - 10} more messages")
-            print()
-        
         print("PROFITABILITY METRICS")
         print("-"*80)
         print(f"Initial Capital:        ${r.initial_capital:>15,.2f}")
@@ -775,7 +1398,7 @@ class ResultsReporter:
         print(f"Sortino Ratio:           {m['sortino']:>15.2f}  (downside risk, >2 good)")
         print(f"Calmar Ratio:            {m['calmar']:>15.2f}  (return/drawdown, >3 good)")
         if m['omega'] != 0:
-            omega_display = f"{m['omega']:.2f}" if m['omega'] < 999 else "inf"
+            omega_display = f"{m['omega']:.2f}" if m['omega'] < 999 else "∞"
             print(f"Omega Ratio:             {omega_display:>15s}  (gains/losses, >1 good)")
         print(f"Maximum Drawdown:        {m['max_drawdown']:>15.2f}%  (peak to trough)")
         if m['ulcer'] != 0:
@@ -797,16 +1420,16 @@ class ResultsReporter:
         if m['beta'] != 0 or m['alpha'] != 0:
             print(f"Alpha (vs {r.benchmark_symbol}):     {m['alpha']:>15.2f}%  (excess return)")
             print(f"Beta (vs {r.benchmark_symbol}):      {m['beta']:>15.2f}  (<1 defensive, >1 aggressive)")
-            print(f"R^2 (vs {r.benchmark_symbol}):        {m['r_squared']:>15.2f}  (market correlation 0-1)")
+            print(f"R² (vs {r.benchmark_symbol}):        {m['r_squared']:>15.2f}  (market correlation 0-1)")
         
         if abs(m['total_return']) > 200 or m['volatility'] > 150:
             print()
-            print("⚠️  UNREALISTIC RESULTS DETECTED:")
+            print("WARNING: UNREALISTIC RESULTS DETECTED")
             if abs(m['total_return']) > 200:
-                print(f"  • Total return {m['total_return']:.1f}% is extremely high")
+                print(f"  Total return {m['total_return']:.1f}% is extremely high")
             if m['volatility'] > 150:
-                print(f"  • Volatility {m['volatility']:.1f}% is higher than leveraged ETFs")
-            print("  → Review configuration before trusting results")
+                print(f"  Volatility {m['volatility']:.1f}% is higher than leveraged ETFs")
+            print("  Review configuration before trusting results")
         
         print()
         
@@ -838,14 +1461,60 @@ class ResultsReporter:
         print("="*80)
 
 
+def print_stoploss_section(analyzer):
+    """Print stop-loss analysis section"""
+    m = analyzer.metrics
+    
+    if m.get('stoploss_count', 0) == 0:
+        return
+    
+    print("STOP-LOSS ANALYSIS")
+    print("-"*80)
+    
+    print(f"Stop-Loss Trades:        {m['stoploss_count']:>15}  ({m['stoploss_pct']:.1f}% of total)")
+    print(f"Profit Target Trades:    {m['profit_target_count']:>15}  ({m['profit_target_pct']:.1f}% of total)")
+    
+    print(f"Avg Stop-Loss P&L:      ${m['avg_stoploss_pnl']:>15,.2f}")
+    print(f"Total Loss from SL:     ${m['total_stoploss_loss']:>15,.2f}")
+    print(f"Worst Stop-Loss:        ${m['worst_stoploss']:>15,.2f}")
+    print(f"Avg SL Return:           {m['avg_stoploss_return_pct']:>15.2f}%")
+    
+    if m['avg_days_to_stoploss'] > 0:
+        print(f"Avg Days to SL:          {m['avg_days_to_stoploss']:>15.1f}")
+        print(f"Min/Max Days to SL:      {m['min_days_to_stoploss']:>7} / {m['max_days_to_stoploss']:<7}")
+    
+    if m['profit_to_loss_ratio'] > 0:
+        print(f"Profit/Loss Ratio:       {m['profit_to_loss_ratio']:>15.2f}  (avg profit target / avg stop-loss)")
+    
+    if m['early_exit_count'] > 0:
+        print(f"Early Exits:             {m['early_exit_count']:>15}  ({m['early_exit_pct']:.1f}% of SL trades)")
+        print(f"Avg Missed Profit:      ${m['avg_missed_profit']:>15,.2f}  (profit before stop triggered)")
+    
+    if m['stoploss_by_type']:
+        print(f"\nStop-Loss Types:")
+        for stop_type, count in m['stoploss_by_type'].items():
+            pct = (count / m['stoploss_count']) * 100
+            print(f"  {stop_type:20s} {count:>5} trades ({pct:.1f}%)")
+    
+    if m.get('exit_reasons'):
+        print(f"\nExit Reasons Distribution:")
+        total_trades = sum(m['exit_reasons'].values())
+        for reason, count in sorted(m['exit_reasons'].items(), key=lambda x: x[1], reverse=True):
+            pct = (count / total_trades) * 100
+            print(f"  {reason:20s} {count:>5} trades ({pct:.1f}%)")
+    
+    print()
+    print("="*80)
+
+
 # ============================================================
-# CHART GENERATOR
+# CHART GENERATOR (only core charts, optimization charts separate)
 # ============================================================
 class ChartGenerator:
     """Generate 6 professional charts"""
     
     @staticmethod
-    def create_all_charts(analyzer, filename='backtest_results.png'):
+    def create_all_charts(analyzer, filename='backtest_results.png', show_plots=True):
         r = analyzer.results
         
         if len(r.trades) == 0:
@@ -859,7 +1528,6 @@ class ChartGenerator:
         dates = pd.to_datetime(r.equity_dates)
         equity_array = np.array(r.equity_curve)
         
-        # 1. Equity Curve
         ax1 = axes[0, 0]
         ax1.plot(dates, equity_array, linewidth=2.5, color='#2196F3')
         ax1.axhline(y=r.initial_capital, color='gray', linestyle='--', alpha=0.7)
@@ -873,7 +1541,6 @@ class ChartGenerator:
         ax1.set_ylabel('Equity ($)')
         ax1.grid(True, alpha=0.3)
         
-        # 2. Drawdown
         ax2 = axes[0, 1]
         running_max = np.maximum.accumulate(equity_array)
         drawdown = (equity_array - running_max) / running_max * 100
@@ -883,7 +1550,6 @@ class ChartGenerator:
         ax2.set_ylabel('Drawdown (%)')
         ax2.grid(True, alpha=0.3)
         
-        # 3. P&L Distribution
         ax3 = axes[1, 0]
         pnl_values = trades_df['pnl'].values
         ax3.hist(pnl_values, bins=40, color='#4CAF50', alpha=0.7, edgecolor='black')
@@ -892,37 +1558,34 @@ class ChartGenerator:
         ax3.set_xlabel('P&L ($)')
         ax3.grid(True, alpha=0.3, axis='y')
         
-        # 4. Signal Performance
         ax4 = axes[1, 1]
         if 'signal' in trades_df.columns:
             signal_pnl = trades_df.groupby('signal')['pnl'].sum()
             colors = ['#4CAF50' if x > 0 else '#f44336' for x in signal_pnl.values]
-            ax4.bar(signal_pnl.index, signal_pnl.values, color=colors, alpha=0.7, edgecolor='black')
+            ax4.bar(signal_pnl.index, signal_pnl.values, color=colors, alpha=0.7)
             ax4.set_title('P&L by Signal', fontsize=12, fontweight='bold')
         else:
             ax4.text(0.5, 0.5, 'No signal data', ha='center', va='center', transform=ax4.transAxes)
         ax4.axhline(y=0, color='black', linewidth=1)
         ax4.grid(True, alpha=0.3, axis='y')
         
-        # 5. Monthly Returns
         ax5 = axes[2, 0]
         trades_df['exit_date'] = pd.to_datetime(trades_df['exit_date'])
         trades_df['month'] = trades_df['exit_date'].dt.to_period('M')
         monthly_pnl = trades_df.groupby('month')['pnl'].sum()
         colors = ['#4CAF50' if x > 0 else '#f44336' for x in monthly_pnl.values]
-        ax5.bar(range(len(monthly_pnl)), monthly_pnl.values, color=colors, alpha=0.7, edgecolor='black')
+        ax5.bar(range(len(monthly_pnl)), monthly_pnl.values, color=colors, alpha=0.7)
         ax5.set_title('Monthly P&L', fontsize=12, fontweight='bold')
         ax5.set_xticks(range(len(monthly_pnl)))
         ax5.set_xticklabels([str(m) for m in monthly_pnl.index], rotation=45, ha='right')
         ax5.axhline(y=0, color='black', linewidth=1)
         ax5.grid(True, alpha=0.3, axis='y')
         
-        # 6. Top Symbols
         ax6 = axes[2, 1]
         if 'symbol' in trades_df.columns:
             symbol_pnl = trades_df.groupby('symbol')['pnl'].sum().sort_values(ascending=True).tail(10)
             colors = ['#4CAF50' if x > 0 else '#f44336' for x in symbol_pnl.values]
-            ax6.barh(range(len(symbol_pnl)), symbol_pnl.values, color=colors, alpha=0.7, edgecolor='black')
+            ax6.barh(range(len(symbol_pnl)), symbol_pnl.values, color=colors, alpha=0.7)
             ax6.set_yticks(range(len(symbol_pnl)))
             ax6.set_yticklabels(symbol_pnl.index, fontsize=9)
             ax6.set_title('Top Symbols', fontsize=12, fontweight='bold')
@@ -933,13 +1596,103 @@ class ChartGenerator:
         
         plt.tight_layout()
         plt.savefig(filename, dpi=300, bbox_inches='tight')
-        plt.show()
+        
+        if show_plots:
+            plt.show()
+        else:
+            plt.close()  # Закрываем без показа
         
         print(f"Chart saved: {filename}")
 
 
+def create_stoploss_charts(analyzer, filename='stoploss_analysis.png', show_plots=True):
+    """Create 4 stop-loss specific charts"""
+    r = analyzer.results
+    m = analyzer.metrics
+    
+    if m.get('stoploss_count', 0) == 0:
+        print("No stop-loss trades to visualize")
+        return
+    
+    trades_df = pd.DataFrame(r.trades)
+    
+    if 'exit_reason' not in trades_df.columns:
+        print("No exit_reason data available")
+        return
+    
+    fig, axes = plt.subplots(2, 2, figsize=(16, 12))
+    fig.suptitle('Stop-Loss Analysis', fontsize=16, fontweight='bold', y=0.995)
+    
+    ax1 = axes[0, 0]
+    if m.get('exit_reasons'):
+        reasons = pd.Series(m['exit_reasons']).sort_values(ascending=True)
+        colors = ['#f44336' if 'stop_loss' in str(r) else '#4CAF50' if r == 'profit_target' else '#2196F3' 
+                  for r in reasons.index]
+        ax1.barh(range(len(reasons)), reasons.values, color=colors, alpha=0.7, edgecolor='black')
+        ax1.set_yticks(range(len(reasons)))
+        ax1.set_yticklabels([r.replace('_', ' ').title() for r in reasons.index])
+        ax1.set_title('Exit Reasons Distribution', fontsize=12, fontweight='bold')
+        ax1.set_xlabel('Number of Trades')
+        ax1.grid(True, alpha=0.3, axis='x')
+        
+        total = sum(reasons.values)
+        for i, v in enumerate(reasons.values):
+            ax1.text(v, i, f' {(v/total)*100:.1f}%', va='center', fontweight='bold')
+    
+    ax2 = axes[0, 1]
+    sl_trades = trades_df[trades_df['exit_reason'].str.contains('stop_loss', na=False)]
+    if len(sl_trades) > 0:
+        ax2.hist(sl_trades['pnl'], bins=30, color='#f44336', alpha=0.7, edgecolor='black')
+        ax2.axvline(x=0, color='black', linestyle='--', linewidth=2)
+        ax2.axvline(x=sl_trades['pnl'].mean(), color='yellow', linestyle='--', linewidth=2, label='Mean')
+        ax2.set_title('Stop-Loss P&L Distribution', fontsize=12, fontweight='bold')
+        ax2.set_xlabel('P&L ($)')
+        ax2.set_ylabel('Frequency')
+        ax2.legend()
+        ax2.grid(True, alpha=0.3, axis='y')
+    
+    ax3 = axes[1, 0]
+    if len(sl_trades) > 0 and 'entry_date' in sl_trades.columns and 'exit_date' in sl_trades.columns:
+        sl_trades_copy = sl_trades.copy()
+        sl_trades_copy['entry_date'] = pd.to_datetime(sl_trades_copy['entry_date'])
+        sl_trades_copy['exit_date'] = pd.to_datetime(sl_trades_copy['exit_date'])
+        sl_trades_copy['days_held'] = (sl_trades_copy['exit_date'] - sl_trades_copy['entry_date']).dt.days
+        
+        ax3.hist(sl_trades_copy['days_held'], bins=30, color='#FF9800', alpha=0.7, edgecolor='black')
+        ax3.axvline(x=sl_trades_copy['days_held'].mean(), color='red', linestyle='--', linewidth=2, label='Mean')
+        ax3.set_title('Days Until Stop-Loss Triggered', fontsize=12, fontweight='bold')
+        ax3.set_xlabel('Days Held')
+        ax3.set_ylabel('Frequency')
+        ax3.legend()
+        ax3.grid(True, alpha=0.3, axis='y')
+    
+    ax4 = axes[1, 1]
+    if 'stop_type' in sl_trades.columns:
+        stop_types = sl_trades['stop_type'].value_counts()
+        colors_types = plt.cm.Set3(range(len(stop_types)))
+        wedges, texts, autotexts = ax4.pie(stop_types.values, labels=stop_types.index, 
+                                            autopct='%1.1f%%', colors=colors_types,
+                                            startangle=90)
+        for autotext in autotexts:
+            autotext.set_color('black')
+            autotext.set_fontweight('bold')
+        ax4.set_title('Stop-Loss Types', fontsize=12, fontweight='bold')
+    else:
+        ax4.text(0.5, 0.5, 'No stop_type data', ha='center', va='center', transform=ax4.transAxes)
+    
+    plt.tight_layout()
+    plt.savefig(filename, dpi=300, bbox_inches='tight')
+    
+    if show_plots:
+        plt.show()
+    else:
+        plt.close()
+    
+    print(f"Stop-loss charts saved: {filename}")
+
+
 # ============================================================
-# RESULTS EXPORTER
+# RESULTS EXPORTER (unchanged)
 # ============================================================
 class ResultsExporter:
     """Export results to CSV"""
@@ -954,15 +1707,81 @@ class ResultsExporter:
             return
         
         trades_df = pd.DataFrame(r.trades)
+        
         trades_df['entry_date'] = pd.to_datetime(trades_df['entry_date']).dt.strftime('%Y-%m-%d')
         trades_df['exit_date'] = pd.to_datetime(trades_df['exit_date']).dt.strftime('%Y-%m-%d')
+        
+        # Round numeric columns to 5 decimal places
+        numeric_columns = trades_df.select_dtypes(include=[np.number]).columns
+        for col in numeric_columns:
+            trades_df[col] = trades_df[col].round(5)
+        
+        core_columns = [
+            'entry_date', 'exit_date', 'symbol', 'signal',
+            'pnl', 'return_pct', 'exit_reason', 'stop_type'
+        ]
+        
+        options_columns = [
+            'short_strike', 'long_strike', 'expiration', 'opt_type', 
+            'spread_type', 'contracts'
+        ]
+        
+        bidask_columns = [
+            'short_entry_bid', 'short_entry_ask', 'short_entry_mid',
+            'long_entry_bid', 'long_entry_ask', 'long_entry_mid',
+            'short_exit_bid', 'short_exit_ask',
+            'long_exit_bid', 'long_exit_ask'
+        ]
+        
+        underlying_columns = [
+            'underlying_entry_price', 'underlying_exit_price', 
+            'underlying_change_pct'
+        ]
+        
+        stop_columns = [
+            'stop_threshold', 'actual_value'
+        ]
+        
+        strategy_columns = [
+            'entry_z_score', 'is_short_bias', 'entry_price', 
+            'exit_price', 'quantity', 'entry_lean', 'exit_lean',
+            # IV EOD fields
+            'call_iv_entry', 'put_iv_entry', 'call_iv_exit', 'put_iv_exit',
+            'iv_lean_entry', 'iv_lean_exit'
+        ]
+        
+        # NEW: Intraday stop-loss columns
+        intraday_columns = [
+            'spy_intraday_high', 'spy_intraday_low', 'spy_intraday_close',
+            'spy_stop_trigger_time', 'spy_stop_trigger_price', 
+            'spy_stop_trigger_bid', 'spy_stop_trigger_ask', 'spy_stop_trigger_last',
+            'intraday_data_points', 'intraday_data_available', 'stop_triggered_by'
+        ]
+        
+        ordered_columns = []
+        for col in (core_columns + options_columns + bidask_columns + 
+                    underlying_columns + stop_columns + strategy_columns + intraday_columns):
+            if col in trades_df.columns:
+                ordered_columns.append(col)
+        
+        remaining = [col for col in trades_df.columns if col not in ordered_columns]
+        ordered_columns.extend(remaining)
+        
+        trades_df = trades_df[ordered_columns]
+        
+        # Round numeric columns to 2 decimals
+        numeric_columns = trades_df.select_dtypes(include=['float64', 'float32', 'float']).columns
+        for col in numeric_columns:
+            trades_df[col] = trades_df[col].round(5)
+        
         trades_df.to_csv(f'{prefix}_trades.csv', index=False)
-        print(f"Exported: {prefix}_trades.csv")
+        print(f"Exported: {prefix}_trades.csv ({len(ordered_columns)} columns)")
         
         equity_df = pd.DataFrame({
             'date': pd.to_datetime(r.equity_dates).strftime('%Y-%m-%d'),
             'equity': r.equity_curve
         })
+        equity_df['equity'] = equity_df['equity'].round(5)
         equity_df.to_csv(f'{prefix}_equity.csv', index=False)
         print(f"Exported: {prefix}_equity.csv")
         
@@ -979,28 +1798,54 @@ class ResultsExporter:
             f.write(f"Trades: {m['total_trades']}\n")
         
         print(f"Exported: {prefix}_summary.txt")
+        
+        # Export metrics as JSON with rounded values
+        import json
+        metrics_rounded = {}
+        for key, value in m.items():
+            if isinstance(value, (int, float)):
+                metrics_rounded[key] = round(float(value), 5) if isinstance(value, float) else value
+            else:
+                metrics_rounded[key] = value
+        
+        with open(f'{prefix}_metrics.json', 'w') as f:
+            json.dump(metrics_rounded, f, indent=2)
+        
+        print(f"Exported: {prefix}_metrics.json")
 
 
 # ============================================================
-# RUN BACKTEST
+# RUN BACKTEST (unchanged)
 # ============================================================
 def run_backtest(strategy_function, config, print_report=True,
                  create_charts=True, export_results=True,
                  chart_filename='backtest_results.png',
-                 export_prefix='backtest'):
-    """Run complete backtest with one command"""
+                 export_prefix='backtest',
+                 progress_context=None):
+    """Run complete backtest"""
     
-    print("="*80)
-    print(" "*25 + "STARTING BACKTEST")
-    print("="*80)
-    print(f"Strategy: {config.get('strategy_name', 'Unknown')}")
-    print(f"Period: {config.get('start_date')} to {config.get('end_date')}")
-    print(f"Capital: ${config.get('initial_capital', 0):,.0f}")
-    print("="*80 + "\n")
+    # Check if running inside optimization
+    is_optimization = progress_context and progress_context.get('is_optimization', False)
+    
+    if not progress_context and not is_optimization:
+        print("="*80)
+        print(" "*25 + "STARTING BACKTEST")
+        print("="*80)
+        print(f"Strategy: {config.get('strategy_name', 'Unknown')}")
+        print(f"Period: {config.get('start_date')} to {config.get('end_date')}")
+        print(f"Capital: ${config.get('initial_capital', 0):,.0f}")
+        print("="*80 + "\n")
+    
+    if progress_context:
+        config['_progress_context'] = progress_context
     
     results = strategy_function(config)
     
-    print("\n[*] Calculating metrics...")
+    if '_progress_context' in config:
+        del config['_progress_context']
+    
+    if not is_optimization:
+        print("\n[*] Calculating metrics...")
     analyzer = BacktestAnalyzer(results)
     analyzer.calculate_all_metrics()
     
@@ -1008,26 +1853,1121 @@ def run_backtest(strategy_function, config, print_report=True,
         print("\n" + "="*80)
         ResultsReporter.print_full_report(analyzer)
     
+    # Export charts during optimization if requested
     if create_charts and len(results.trades) > 0:
-        print(f"\n[*] Creating charts: {chart_filename}")
+        if not is_optimization:
+            print(f"\n[*] Creating charts: {chart_filename}")
         try:
-            ChartGenerator.create_all_charts(analyzer, chart_filename)
+            # Don't show plots during optimization, just save them
+            ChartGenerator.create_all_charts(analyzer, chart_filename, show_plots=not is_optimization)
         except Exception as e:
-            print(f"[ERROR] Charts failed: {e}")
+            if not is_optimization:
+                print(f"[ERROR] Charts failed: {e}")
     
+    # Export results during optimization if requested
     if export_results and len(results.trades) > 0:
-        print(f"\n[*] Exporting: {export_prefix}_*")
+        if not is_optimization:
+            print(f"\n[*] Exporting: {export_prefix}_*")
         try:
             ResultsExporter.export_all(analyzer, export_prefix)
         except Exception as e:
-            print(f"[ERROR] Export failed: {e}")
+            if not is_optimization:
+                print(f"[ERROR] Export failed: {e}")
+    
+    return analyzer
+
+
+def run_backtest_with_stoploss(strategy_function, config, print_report=True,
+                               create_charts=True, export_results=True,
+                               chart_filename='backtest_results.png',
+                               export_prefix='backtest',
+                               create_stoploss_report=True,
+                               create_stoploss_charts=True,
+                               progress_context=None):
+    """Enhanced run_backtest with stop-loss analysis"""
+    
+    analyzer = run_backtest(
+        strategy_function, config,
+        print_report=False,
+        create_charts=create_charts,
+        export_results=export_results,
+        chart_filename=chart_filename,
+        export_prefix=export_prefix,
+        progress_context=progress_context
+    )
+    
+    calculate_stoploss_metrics(analyzer)
+    
+    if print_report:
+        print("\n" + "="*80)
+        ResultsReporter.print_full_report(analyzer)
+        
+        if create_stoploss_report and analyzer.metrics.get('stoploss_count', 0) > 0:
+            print_stoploss_section(analyzer)
+    
+    if create_stoploss_charts and analyzer.metrics.get('stoploss_count', 0) > 0:
+        print(f"\n[*] Creating stop-loss analysis charts...")
+        try:
+            stoploss_chart_name = chart_filename.replace('.png', '_stoploss.png') if chart_filename else 'stoploss_analysis.png'
+            create_stoploss_charts(analyzer, stoploss_chart_name)
+        except Exception as e:
+            print(f"[ERROR] Stop-loss charts failed: {e}")
     
     return analyzer
 
 
+# ============================================================
+# STOP-LOSS CONFIG (ENHANCED WITH COMBINED)
+# ============================================================
+class StopLossConfig:
+    """
+    Universal stop-loss configuration builder (ENHANCED)
+    
+    NEW METHOD:
+    - combined(): Requires BOTH pl_loss AND directional conditions
+    """
+    
+    @staticmethod
+    def _normalize_pct(value):
+        """Convert any number to decimal (0.30)"""
+        if value >= 1:
+            return value / 100
+        return value
+    
+    @staticmethod
+    def _format_pct(value):
+        """Format percentage for display"""
+        if value >= 1:
+            return f"{value:.0f}%"
+        return f"{value*100:.0f}%"
+    
+    @staticmethod
+    def none():
+        """No stop-loss"""
+        return {
+            'enabled': False,
+            'type': 'none',
+            'value': 0,
+            'name': 'No Stop-Loss',
+            'description': 'No stop-loss protection'
+        }
+    
+    @staticmethod
+    def fixed(pct):
+        """Fixed percentage stop-loss"""
+        decimal = StopLossConfig._normalize_pct(pct)
+        display = StopLossConfig._format_pct(pct)
+        
+        return {
+            'enabled': True,
+            'type': 'fixed_pct',
+            'value': decimal,
+            'name': f'Fixed {display}',
+            'description': f'Fixed stop at {display} loss'
+        }
+    
+    @staticmethod
+    def trailing(pct, trailing_distance=None):
+        """Trailing stop-loss"""
+        decimal = StopLossConfig._normalize_pct(pct)
+        display = StopLossConfig._format_pct(pct)
+        
+        config = {
+            'enabled': True,
+            'type': 'trailing',
+            'value': decimal,
+            'name': f'Trailing {display}',
+            'description': f'Trailing stop at {display} from peak'
+        }
+        
+        if trailing_distance is not None:
+            config['trailing_distance'] = StopLossConfig._normalize_pct(trailing_distance)
+        
+        return config
+    
+    @staticmethod
+    def time_based(days):
+        """Time-based stop"""
+        return {
+            'enabled': True,
+            'type': 'time_based',
+            'value': days,
+            'name': f'Time {days}d',
+            'description': f'Exit after {days} days'
+        }
+    
+    @staticmethod
+    def volatility(atr_multiplier):
+        """ATR-based stop"""
+        return {
+            'enabled': True,
+            'type': 'volatility',
+            'value': atr_multiplier,
+            'name': f'ATR {atr_multiplier:.1f}x',
+            'description': f'Stop at {atr_multiplier:.1f}× ATR',
+            'requires_atr': True
+        }
+    
+    @staticmethod
+    def pl_loss(pct):
+        """P&L-based stop using real bid/ask prices"""
+        decimal = StopLossConfig._normalize_pct(pct)
+        display = StopLossConfig._format_pct(pct)
+        
+        return {
+            'enabled': True,
+            'type': 'pl_loss',
+            'value': decimal,
+            'name': f'P&L Loss {display}',
+            'description': f'Stop when P&L drops to -{display}'
+        }
+    
+    @staticmethod
+    def directional(pct):
+        """Directional stop based on underlying movement"""
+        decimal = StopLossConfig._normalize_pct(pct)
+        display = StopLossConfig._format_pct(pct)
+        
+        return {
+            'enabled': True,
+            'type': 'directional',
+            'value': decimal,
+            'name': f'Directional {display}',
+            'description': f'Stop when underlying moves {display}'
+        }
+    
+    # ========================================================
+    # NEW: COMBINED STOP (REQUIRES BOTH CONDITIONS)
+    # ========================================================
+    
+    @staticmethod
+    def combined(pl_loss_pct, directional_pct):
+        """
+        Combined stop: Requires BOTH conditions (from code 2)
+        
+        Args:
+            pl_loss_pct: P&L loss threshold (e.g., 5 or 0.05 = -5%)
+            directional_pct: Underlying move threshold (e.g., 3 or 0.03 = 3%)
+        
+        Example:
+            StopLossConfig.combined(5, 3)
+            # Triggers only when BOTH:
+            # 1. P&L drops to -5%
+            # 2. Underlying moves 3% adversely
+        """
+        pl_decimal = StopLossConfig._normalize_pct(pl_loss_pct)
+        dir_decimal = StopLossConfig._normalize_pct(directional_pct)
+        
+        pl_display = StopLossConfig._format_pct(pl_loss_pct)
+        dir_display = StopLossConfig._format_pct(directional_pct)
+        
+        return {
+            'enabled': True,
+            'type': 'combined',
+            'value': {
+                'pl_loss': pl_decimal,
+                'directional': dir_decimal
+            },
+            'name': f'Combined (P&L {pl_display} + Dir {dir_display})',
+            'description': f'Stop when P&L<-{pl_display} AND underlying moves {dir_display}'
+        }
+    
+    # ========================================================
+    # BACKWARD COMPATIBILITY
+    # ========================================================
+    
+    @staticmethod
+    def time(days):
+        """Alias for time_based()"""
+        return StopLossConfig.time_based(days)
+    
+    @staticmethod
+    def atr(multiplier):
+        """Alias for volatility()"""
+        return StopLossConfig.volatility(multiplier)
+    
+    # ========================================================
+    # PRESETS (WITH COMBINED STOPS)
+    # ========================================================
+    
+    @staticmethod
+    def presets():
+        """Generate all standard stop-loss presets (UPDATED WITH COMBINED)"""
+        return {
+            'none': StopLossConfig.none(),
+            
+            'fixed_20': StopLossConfig.fixed(20),
+            'fixed_30': StopLossConfig.fixed(30),
+            'fixed_40': StopLossConfig.fixed(40),
+            'fixed_50': StopLossConfig.fixed(50),
+            'fixed_70': StopLossConfig.fixed(70),
+            
+            'trailing_20': StopLossConfig.trailing(20),
+            'trailing_30': StopLossConfig.trailing(30),
+            'trailing_50': StopLossConfig.trailing(50),
+            
+            'time_5d': StopLossConfig.time(5),
+            'time_10d': StopLossConfig.time(10),
+            'time_20d': StopLossConfig.time(20),
+            
+            'atr_2x': StopLossConfig.atr(2.0),
+            'atr_3x': StopLossConfig.atr(3.0),
+            
+            'pl_loss_5': StopLossConfig.pl_loss(5),
+            'pl_loss_10': StopLossConfig.pl_loss(10),
+            'pl_loss_15': StopLossConfig.pl_loss(15),
+            
+            'directional_3': StopLossConfig.directional(3),
+            'directional_5': StopLossConfig.directional(5),
+            'directional_7': StopLossConfig.directional(7),
+            
+            # NEW: COMBINED STOPS
+            'combined_5_3': StopLossConfig.combined(5, 3),
+            'combined_7_5': StopLossConfig.combined(7, 5),
+            'combined_10_3': StopLossConfig.combined(10, 3),
+        }
+    
+    @staticmethod
+    def apply(base_config, stop_config):
+        """Apply stop-loss configuration to base config"""
+        merged = base_config.copy()
+        
+        merged['stop_loss_enabled'] = stop_config.get('enabled', False)
+        
+        if merged['stop_loss_enabled']:
+            sl_config = {
+                'type': stop_config['type'],
+                'value': stop_config['value']
+            }
+            
+            if 'trailing_distance' in stop_config:
+                sl_config['trailing_distance'] = stop_config['trailing_distance']
+            
+            merged['stop_loss_config'] = sl_config
+        
+        return merged
+
+
+def create_stoploss_comparison_chart(results, filename='stoploss_comparison.png', show_plots=True):
+    """Create comparison chart"""
+    try:
+        fig, axes = plt.subplots(2, 2, figsize=(16, 12))
+        fig.suptitle('Stop-Loss Configuration Comparison', fontsize=16, fontweight='bold')
+        
+        names = [r['config']['name'] for r in results.values()]
+        returns = [r['total_return'] for r in results.values()]
+        sharpes = [r['sharpe'] for r in results.values()]
+        drawdowns = [r['max_drawdown'] for r in results.values()]
+        stop_counts = [r['stoploss_count'] for r in results.values()]
+        
+        ax1 = axes[0, 0]
+        colors = ['#4CAF50' if r > 0 else '#f44336' for r in returns]
+        ax1.barh(range(len(names)), returns, color=colors, alpha=0.7, edgecolor='black')
+        ax1.set_yticks(range(len(names)))
+        ax1.set_yticklabels(names, fontsize=9)
+        ax1.set_xlabel('Total Return (%)')
+        ax1.set_title('Total Return by Stop-Loss Type', fontsize=12, fontweight='bold')
+        ax1.axvline(x=0, color='black', linestyle='-', linewidth=1)
+        ax1.grid(True, alpha=0.3, axis='x')
+        
+        ax2 = axes[0, 1]
+        colors_sharpe = ['#4CAF50' if s > 1 else '#FF9800' if s > 0 else '#f44336' for s in sharpes]
+        ax2.barh(range(len(names)), sharpes, color=colors_sharpe, alpha=0.7, edgecolor='black')
+        ax2.set_yticks(range(len(names)))
+        ax2.set_yticklabels(names, fontsize=9)
+        ax2.set_xlabel('Sharpe Ratio')
+        ax2.set_title('Sharpe Ratio by Stop-Loss Type', fontsize=12, fontweight='bold')
+        ax2.axvline(x=1, color='green', linestyle='--', linewidth=1, label='Good (>1)')
+        ax2.axvline(x=0, color='black', linestyle='-', linewidth=1)
+        ax2.legend()
+        ax2.grid(True, alpha=0.3, axis='x')
+        
+        ax3 = axes[1, 0]
+        ax3.barh(range(len(names)), drawdowns, color='#f44336', alpha=0.7, edgecolor='black')
+        ax3.set_yticks(range(len(names)))
+        ax3.set_yticklabels(names, fontsize=9)
+        ax3.set_xlabel('Maximum Drawdown (%)')
+        ax3.set_title('Maximum Drawdown (Lower is Better)', fontsize=12, fontweight='bold')
+        ax3.grid(True, alpha=0.3, axis='x')
+        
+        ax4 = axes[1, 1]
+        ax4.barh(range(len(names)), stop_counts, color='#2196F3', alpha=0.7, edgecolor='black')
+        ax4.set_yticks(range(len(names)))
+        ax4.set_yticklabels(names, fontsize=9)
+        ax4.set_xlabel('Number of Stop-Loss Exits')
+        ax4.set_title('Stop-Loss Frequency', fontsize=12, fontweight='bold')
+        ax4.grid(True, alpha=0.3, axis='x')
+        
+        plt.tight_layout()
+        plt.savefig(filename, dpi=300, bbox_inches='tight')
+        
+        if show_plots:
+            plt.show()
+        else:
+            plt.close()
+        
+        print(f"Comparison chart saved: {filename}")
+        
+    except Exception as e:
+        print(f"Failed to create comparison chart: {e}")
+
+
+
+# ============================================================
+# DATA PRELOADING FUNCTION (FOR OPTIMIZATION)
+# ============================================================
+def preload_options_data(config, progress_widgets=None):
+    """
+    Предзагрузка опционных данных для оптимизации.
+    Загружает данные ОДИН РАЗ и возвращает кеш.
+    
+    Returns:
+        tuple: (lean_df, options_cache)
+            - lean_df: DataFrame с историей IV lean
+            - options_cache: dict {date: DataFrame} с опционными данными
+    """
+    if progress_widgets:
+        progress_bar, status_label, monitor, start_time = progress_widgets
+        status_label.value = "<b style='color:#0066cc'>🔄 Preloading options data (ONCE)...</b>"
+        progress_bar.value = 5
+    
+    # Extract config
+    from datetime import datetime, timedelta
+    import pandas as pd
+    import numpy as np
+    import gc
+    
+    start_date = datetime.strptime(config['start_date'], '%Y-%m-%d').date()
+    end_date = datetime.strptime(config['end_date'], '%Y-%m-%d').date()
+    symbol = config['symbol']
+    dte_target = config.get('dte_target', 30)
+    lookback_period = config.get('lookback_period', 60)
+    chunk_months = config.get('chunk_months', 3)
+    
+    # Calculate date chunks
+    data_start = start_date - timedelta(days=lookback_period + 60)
+    
+    date_chunks = []
+    current_chunk_start = data_start
+    while current_chunk_start <= end_date:
+        chunk_end = min(
+            current_chunk_start + timedelta(days=chunk_months * 31),
+            end_date
+        )
+        date_chunks.append((current_chunk_start, chunk_end))
+        current_chunk_start = chunk_end + timedelta(days=1)
+    
+    # Store lean calculations
+    lean_history = []
+    options_cache = {}  # {date: DataFrame with bid/ask data}
+    
+    # Track time for ETA
+    preload_start_time = time.time()
+    
+    try:
+        import ivolatility as ivol
+        getOptionsData = ivol.setMethod('/equities/eod/options-rawiv')
+        
+        # Process each chunk
+        for chunk_idx, (chunk_start, chunk_end) in enumerate(date_chunks):
+            if progress_widgets:
+                # Use update_progress for full display with ETA, CPU, RAM
+                update_progress(
+                    progress_bar, status_label, monitor,
+                    current=chunk_idx + 1,
+                    total=len(date_chunks),
+                    start_time=preload_start_time,
+                    message=f"🔄 Loading chunk {chunk_idx+1}/{len(date_chunks)}"
+                )
+            
+            raw_data = getOptionsData(
+                symbol=symbol,
+                from_=chunk_start.strftime('%Y-%m-%d'),
+                to=chunk_end.strftime('%Y-%m-%d')
+            )
+            
+            if raw_data is None:
+                continue
+            
+            df = pd.DataFrame(raw_data)
+            
+            if df.empty:
+                continue
+            
+            # Essential columns
+            essential_cols = ['date', 'expiration', 'strike', 'Call/Put', 'iv', 'Adjusted close']
+            if 'bid' in df.columns:
+                essential_cols.append('bid')
+            if 'ask' in df.columns:
+                essential_cols.append('ask')
+
+            df = df[essential_cols].copy()
+            
+            # Process bid/ask
+            if 'bid' in df.columns:
+                df['bid'] = pd.to_numeric(df['bid'], errors='coerce').astype('float32')
+            else:
+                df['bid'] = np.nan
+
+            if 'ask' in df.columns:
+                df['ask'] = pd.to_numeric(df['ask'], errors='coerce').astype('float32')
+            else:
+                df['ask'] = np.nan
+
+            # Calculate mid price
+            df['mid'] = (df['bid'] + df['ask']) / 2
+            df['mid'] = df['mid'].fillna(df['iv'])
+            
+            df['date'] = pd.to_datetime(df['date']).dt.date
+            df['expiration'] = pd.to_datetime(df['expiration']).dt.date
+            df['strike'] = pd.to_numeric(df['strike'], errors='coerce').astype('float32')
+            df['iv'] = pd.to_numeric(df['iv'], errors='coerce').astype('float32')
+            df['Adjusted close'] = pd.to_numeric(df['Adjusted close'], errors='coerce').astype('float32')
+            
+            df['dte'] = (pd.to_datetime(df['expiration']) - pd.to_datetime(df['date'])).dt.days
+            df['dte'] = df['dte'].astype('int16')
+            
+            df = df.dropna(subset=['strike', 'iv', 'Adjusted close'])
+            
+            if df.empty:
+                del df
+                gc.collect()
+                continue
+
+            # Cache options data for position tracking
+            for date_val in df['date'].unique():
+                if date_val not in options_cache:
+                    options_cache[date_val] = df[df['date'] == date_val].copy()
+            
+            # Calculate lean for this chunk
+            trading_dates = sorted(df['date'].unique())
+            
+            for current_date in trading_dates:
+                day_data = df[df['date'] == current_date]
+                
+                if day_data.empty:
+                    continue
+                
+                stock_price = float(day_data['Adjusted close'].iloc[0])
+                
+                dte_filtered = day_data[
+                    (day_data['dte'] >= dte_target - 7) & 
+                    (day_data['dte'] <= dte_target + 7)
+                ]
+                
+                if dte_filtered.empty:
+                    continue
+                
+                dte_filtered = dte_filtered.copy()
+                dte_filtered['strike_diff'] = abs(dte_filtered['strike'] - stock_price)
+                atm_idx = dte_filtered['strike_diff'].idxmin()
+                atm_strike = float(dte_filtered.loc[atm_idx, 'strike'])
+                
+                atm_options = dte_filtered[dte_filtered['strike'] == atm_strike]
+                atm_call = atm_options[atm_options['Call/Put'] == 'C']
+                atm_put = atm_options[atm_options['Call/Put'] == 'P']
+                
+                if not atm_call.empty and not atm_put.empty:
+                    call_iv = float(atm_call['iv'].iloc[0])
+                    put_iv = float(atm_put['iv'].iloc[0])
+                    
+                    if pd.notna(call_iv) and pd.notna(put_iv) and call_iv > 0 and put_iv > 0:
+                        iv_lean = call_iv - put_iv
+                        
+                        lean_history.append({
+                            'date': current_date,
+                            'stock_price': stock_price,
+                            'iv_lean': iv_lean
+                        })
+            
+            del df, raw_data
+            gc.collect()
+        
+        lean_df = pd.DataFrame(lean_history)
+        lean_df['stock_price'] = lean_df['stock_price'].astype('float32')
+        lean_df['iv_lean'] = lean_df['iv_lean'].astype('float32')
+        
+        del lean_history
+        gc.collect()
+        
+        if progress_widgets:
+            status_label.value = f"<b style='color:#00cc00'>✓ Data preloaded: {len(lean_df)} days, {len(options_cache)} cached dates</b>"
+            progress_bar.value = 35
+        
+        print(f"✓ Data preloaded: {len(lean_df)} days, {len(options_cache)} cached dates")
+        
+        return lean_df, options_cache
+        
+    except Exception as e:
+        print(f"Error preloading data: {e}")
+        return pd.DataFrame(), {}
+
+
+# ============================================================
+# NEW: OPTIMIZATION FRAMEWORK
+# ============================================================
+def optimize_parameters(base_config, param_grid, strategy_function,
+                       optimization_metric='sharpe', min_trades=5,
+                       max_drawdown_limit=None, parallel=False,
+                       export_each_combo=True # ← НОВЫЙ ПАРАМЕТР
+                       ):  
+    """
+    Optimize strategy parameters across multiple combinations
+    
+    Args:
+        base_config: Base configuration dict
+        param_grid: Dict of parameters to optimize
+            Example: {'z_score_entry': [1.0, 1.5, 2.0], 'z_score_exit': [0.1, 0.3, 0.5]}
+        strategy_function: Strategy function to run
+        optimization_metric: Metric to optimize ('sharpe', 'total_return', 'profit_factor', 'calmar')
+        min_trades: Minimum number of trades required
+        max_drawdown_limit: Maximum acceptable drawdown (e.g., 0.10 for 10%)
+        parallel: Use parallel processing (not implemented yet)
+        export_each_combo: If True, exports files for each combination  # ← 
+    
+    Returns:
+        tuple: (results_df, best_params, results_folder)
+    """
+    
+    # ═══ ДОБАВИТЬ В НАЧАЛО ФУНКЦИИ ═══
+    # Create results folder
+    results_folder = create_optimization_folder()
+    print(f"📊 Results will be saved to: {results_folder}\n")
+    
+    # Record start time
+    optimization_start_time = datetime.now()
+    start_time_str = optimization_start_time.strftime('%Y-%m-%d %H:%M:%S')
+    
+    print("\n" + "="*80)
+    print(" "*20 + "PARAMETER OPTIMIZATION")
+    print("="*80)
+    print(f"Strategy: {base_config.get('strategy_name', 'Unknown')}")
+    print(f"Period: {base_config.get('start_date')} to {base_config.get('end_date')}")
+    print(f"Optimization Metric: {optimization_metric}")
+    print(f"Min Trades: {min_trades}")
+    print(f"🕐 Started: {start_time_str}")
+    if max_drawdown_limit:
+        print(f"Max Drawdown Limit: {max_drawdown_limit*100:.0f}%")
+    print("="*80 + "\n")
+    
+    # Generate all combinations
+    param_names = list(param_grid.keys())
+    param_values = list(param_grid.values())
+    all_combinations = list(product(*param_values))
+    
+    total_combinations = len(all_combinations)
+    print(f"Testing {total_combinations} parameter combinations...")
+    print(f"Parameters: {param_names}")
+    print(f"Grid: {param_grid}\n")
+    
+    # Create SHARED progress context for all backtests
+    try:
+        from IPython.display import display
+        import ipywidgets as widgets
+        
+        progress_bar = widgets.FloatProgress(
+            value=0, min=0, max=100,
+            description='Optimizing:',
+            bar_style='info',
+            layout=widgets.Layout(width='100%', height='30px')
+        )
+        
+        status_label = widgets.HTML(value="<b>Starting optimization...</b>")
+        display(widgets.VBox([progress_bar, status_label]))
+        
+        monitor = ResourceMonitor()
+        opt_start_time = time.time()
+        
+        # Create shared progress context (will suppress individual backtest progress)
+        shared_progress = {
+            'progress_widgets': (progress_bar, status_label, monitor, opt_start_time),
+            'is_optimization': True
+        }
+        has_widgets = True
+    except:
+        shared_progress = None
+        has_widgets = False
+        print("Running optimization (no progress bar)...")
+    
+    # ═══════════════════════════════════════════════════════════════════════════
+    # PRELOAD DATA ONCE (FOR ALL OPTIMIZATION ITERATIONS)
+    # ═══════════════════════════════════════════════════════════════════════════
+    print("\n" + "="*80)
+    print("📥 PRELOADING OPTIONS DATA (loads ONCE, reused for all combinations)")
+    print("="*80)
+    
+    preloaded_lean_df, preloaded_options_cache = preload_options_data(
+        base_config, 
+        progress_widgets=shared_progress['progress_widgets'] if shared_progress else None
+    )
+    
+    if preloaded_lean_df.empty:
+        print("\n❌ ERROR: Failed to preload data. Cannot proceed with optimization.")
+        return pd.DataFrame(), None
+    
+    print(f"✓ Preloading complete! Data will be reused for all {total_combinations} combinations")
+    print("="*80 + "\n")
+    
+    # ═══════════════════════════════════════════════════════════════════════════
+    # RESET PROGRESS BAR FOR OPTIMIZATION LOOP
+    # ═══════════════════════════════════════════════════════════════════════════
+    if has_widgets:
+        progress_bar.value = 0
+        progress_bar.bar_style = 'info'
+        status_label.value = "<b style='color:#0066cc'>Starting optimization loop...</b>"
+    
+    # Run backtests
+    results = []
+    start_time = time.time()
+    
+    for idx, param_combo in enumerate(all_combinations, 1):
+        # Create test config
+        test_config = base_config.copy()
+        
+        # Update parameters
+        for param_name, param_value in zip(param_names, param_combo):
+            test_config[param_name] = param_value
+        
+        # Update name
+        param_str = "_".join([f"{k}={v}" for k, v in zip(param_names, param_combo)])
+        test_config['strategy_name'] = f"{base_config.get('strategy_name', 'Strategy')} [{param_str}]"
+        
+        # ═══ ADD PRELOADED DATA TO CONFIG ═══
+        test_config['_preloaded_lean_df'] = preloaded_lean_df
+        test_config['_preloaded_options_cache'] = preloaded_options_cache
+        
+        # Update progress
+        if has_widgets:
+            # Use update_progress for full display with ETA, CPU, RAM
+            update_progress(
+                progress_bar, status_label, monitor,
+                current=idx,
+                total=total_combinations,
+                start_time=start_time,
+                message=f"Testing: {param_str}"
+            )
+        else:
+            if idx % max(1, total_combinations // 10) == 0:
+                print(f"[{idx}/{total_combinations}] {param_str}")
+        
+        # ═══ ИЗМЕНИТЬ ВЫЗОВ run_backtest (строки ~2240-2248) ═══
+        try:
+            # Create compact parameter string (e.g., Z1.0_E0.1_PT20)
+            param_parts = []
+            for name, value in zip(param_names, param_combo):
+                if 'z_score_entry' in name:
+                    param_parts.append(f"Z{value}")
+                elif 'z_score_exit' in name:
+                    param_parts.append(f"E{value}")
+                elif 'profit_target' in name:
+                    if value is None:
+                        param_parts.append("PTNo")
+                    else:
+                        param_parts.append(f"PT{int(value*100)}")
+                elif 'min_days' in name:
+                    param_parts.append(f"D{value}")
+                else:
+                    # Generic short name for other params
+                    short_name = ''.join([c for c in name if c.isupper() or c.isdigit()])[:3]
+                    param_parts.append(f"{short_name}{value}")
+            
+            compact_params = "_".join(param_parts)
+            
+            # Create combo folder: c01_Z1.0_E0.1_PT20
+            combo_folder = os.path.join(results_folder, f'c{idx:02d}_{compact_params}')
+            os.makedirs(combo_folder, exist_ok=True)
+            
+            # File prefix: c01_Z1.0_E0.1_PT20
+            combo_prefix = f"c{idx:02d}_{compact_params}"
+            
+            # Run backtest WITH EXPORT AND CHARTS (saved but not displayed)
+            analyzer = run_backtest(
+                strategy_function,
+                test_config,
+                print_report=False,
+                create_charts=export_each_combo,  # ← СОЗДАЕМ ГРАФИКИ (сохраняются, но не показываются)
+                export_results=export_each_combo,  # ← ИЗМЕНЕНО
+                progress_context=shared_progress,
+                chart_filename=os.path.join(combo_folder, 'equity_curve.png') if export_each_combo else None,  # ← ГРАФИКИ СОХРАНЯЮТСЯ
+                export_prefix=os.path.join(combo_folder, combo_prefix) if export_each_combo else None  # ← ДОБАВЛЕНО
+            )
+            
+            # Check validity
+            is_valid = True
+            invalid_reason = ""
+            
+            if analyzer.metrics['total_trades'] < min_trades:
+                is_valid = False
+                invalid_reason = f"Too few trades ({analyzer.metrics['total_trades']})"
+            
+            if max_drawdown_limit and analyzer.metrics['max_drawdown'] > (max_drawdown_limit * 100):
+                is_valid = False
+                invalid_reason = f"Excessive drawdown ({analyzer.metrics['max_drawdown']:.1f}%)"
+            
+            # Print compact statistics for this combination
+            status_symbol = "✓" if is_valid else "✗"
+            status_color = "#00cc00" if is_valid else "#ff6666"
+            
+            print(f"\n[{idx}/{total_combinations}] {param_str}")
+            print("-" * 80)
+            if is_valid:
+                print(f"  {status_symbol} Return: {analyzer.metrics['total_return']:>7.2f}% | "
+                      f"Sharpe: {analyzer.metrics['sharpe']:>6.2f} | "
+                      f"Max DD: {analyzer.metrics['max_drawdown']:>6.2f}% | "
+                      f"Trades: {analyzer.metrics['total_trades']:>3} | "
+                      f"Win Rate: {analyzer.metrics['win_rate']:>5.1f}% | "
+                      f"PF: {analyzer.metrics['profit_factor']:>5.2f}")
+            else:
+                print(f"  {status_symbol} INVALID: {invalid_reason}")
+            
+            # Update widget status with last result
+            if has_widgets:
+                result_text = f"Return: {analyzer.metrics['total_return']:.1f}% | Sharpe: {analyzer.metrics['sharpe']:.2f}" if is_valid else invalid_reason
+                
+                # Get resource usage
+                cpu_pct = monitor.get_cpu_percent()
+                mem_info = monitor.get_memory_info()
+                ram_mb = mem_info[0]  # process_mb
+                resource_text = f"CPU: {cpu_pct:.0f}% | RAM: {ram_mb:.0f}MB"
+                
+                status_label.value = (
+                    f"<b style='color:{status_color}'>[{idx}/{total_combinations}] {param_str}</b><br>"
+                    f"<span style='color:#666'>{result_text}</span><br>"
+                    f"<span style='color:#999;font-size:10px'>{resource_text}</span>"
+                )
+            
+            # Store results
+            result = {
+                'combination_id': idx,
+                'is_valid': is_valid,
+                'invalid_reason': invalid_reason,
+                **{name: value for name, value in zip(param_names, param_combo)},
+                'total_return': analyzer.metrics['total_return'],
+                'sharpe': analyzer.metrics['sharpe'],
+                'sortino': analyzer.metrics['sortino'],
+                'calmar': analyzer.metrics['calmar'],
+                'max_drawdown': analyzer.metrics['max_drawdown'],
+                'win_rate': analyzer.metrics['win_rate'],
+                'profit_factor': analyzer.metrics['profit_factor'],
+                'total_trades': analyzer.metrics['total_trades'],
+                'avg_win': analyzer.metrics['avg_win'],
+                'avg_loss': analyzer.metrics['avg_loss'],
+                'volatility': analyzer.metrics['volatility'],
+            }
+            
+            results.append(result)
+            
+            # Show intermediate summary every 10 combinations (or at end)
+            if idx % 10 == 0 or idx == total_combinations:
+                valid_so_far = [r for r in results if r['is_valid']]
+                if valid_so_far:
+                    print("\n" + "="*80)
+                    print(f"INTERMEDIATE SUMMARY ({idx}/{total_combinations} tested)")
+                    print("="*80)
+                    
+                    # Sort by optimization metric
+                    if optimization_metric == 'sharpe':
+                        valid_so_far.sort(key=lambda x: x['sharpe'], reverse=True)
+                    elif optimization_metric == 'total_return':
+                        valid_so_far.sort(key=lambda x: x['total_return'], reverse=True)
+                    elif optimization_metric == 'profit_factor':
+                        valid_so_far.sort(key=lambda x: x['profit_factor'], reverse=True)
+                    elif optimization_metric == 'calmar':
+                        valid_so_far.sort(key=lambda x: x['calmar'], reverse=True)
+                    
+                    # Show top 3
+                    print(f"\n🏆 TOP 3 BY {optimization_metric.upper()}:")
+                    print("-"*80)
+                    for rank, res in enumerate(valid_so_far[:3], 1):
+                        params_display = ", ".join([f"{name}={res[name]}" for name in param_names])
+                        print(f"  {rank}. [{params_display}]")
+                        print(f"     Return: {res['total_return']:>7.2f}% | "
+                              f"Sharpe: {res['sharpe']:>6.2f} | "
+                              f"Max DD: {res['max_drawdown']:>6.2f}% | "
+                              f"Trades: {res['total_trades']:>3}")
+                    
+                    print(f"\nValid: {len(valid_so_far)}/{idx} | "
+                          f"Invalid: {idx - len(valid_so_far)}/{idx}")
+                    print("="*80 + "\n")
+        
+        except Exception as e:
+            print(f"\n[{idx}/{total_combinations}] {param_str}")
+            print("-" * 80)
+            print(f"  ✗ ERROR: {str(e)[:100]}")
+            
+            result = {
+                'combination_id': idx,
+                'is_valid': False,
+                'invalid_reason': f"Error: {str(e)[:50]}",
+                **{name: value for name, value in zip(param_names, param_combo)},
+                'total_return': 0, 'sharpe': 0, 'sortino': 0, 'calmar': 0,
+                'max_drawdown': 0, 'win_rate': 0, 'profit_factor': 0,
+                'total_trades': 0, 'avg_win': 0, 'avg_loss': 0, 'volatility': 0
+            }
+            results.append(result)
+    
+    elapsed = time.time() - start_time
+    
+    if has_widgets:
+        progress_bar.value = 100
+        progress_bar.bar_style = 'success'
+        status_label.value = f"<b style='color:#00cc00'>✓ Optimization complete in {int(elapsed)}s</b>"
+    
+    # Create results DataFrame
+    results_df = pd.DataFrame(results)
+    
+    # Round numeric columns to 2 decimals
+    numeric_columns = results_df.select_dtypes(include=['float64', 'float32', 'float']).columns
+    for col in numeric_columns:
+        results_df[col] = results_df[col].round(5)
+
+    # ═══ ДОБАВИТЬ СОХРАНЕНИЕ SUMMARY В ПАПКУ ═══
+    summary_path = os.path.join(results_folder, 'optimization_summary.csv')
+    results_df.to_csv(summary_path, index=False)
+    print(f"\n✓ Summary saved: {summary_path}")
+    
+    # Find best parameters
+    valid_results = results_df[results_df['is_valid'] == True].copy()
+    
+    if len(valid_results) == 0:
+        print("\n" + "="*80)
+        print("WARNING: No valid combinations found!")
+        print("Try relaxing constraints or checking parameter ranges")
+        print("="*80)
+        return results_df, None, results_folder
+    
+    # Select best based on metric
+    if optimization_metric == 'sharpe':
+        best_idx = valid_results['sharpe'].idxmax()
+    elif optimization_metric == 'total_return':
+        best_idx = valid_results['total_return'].idxmax()
+    elif optimization_metric == 'profit_factor':
+        best_idx = valid_results['profit_factor'].idxmax()
+    elif optimization_metric == 'calmar':
+        best_idx = valid_results['calmar'].idxmax()
+    else:
+        best_idx = valid_results['sharpe'].idxmax()
+    
+    best_result = valid_results.loc[best_idx]
+    
+    # Extract best parameters
+    best_params = {name: best_result[name] for name in param_names}
+    
+    # Calculate total time
+    optimization_end_time = datetime.now()
+    total_duration = optimization_end_time - optimization_start_time
+    end_time_str = optimization_end_time.strftime('%Y-%m-%d %H:%M:%S')
+    duration_str = format_time(total_duration.total_seconds())
+    
+    # Print summary
+    print("="*80)
+    print(" "*20 + "OPTIMIZATION COMPLETE")
+    print("="*80)
+    print(f"\nTotal Combinations Tested: {total_combinations}")
+    print(f"Valid Combinations: {len(valid_results)}")
+    print(f"Invalid Combinations: {len(results_df) - len(valid_results)}")
+    print(f"🕐 Started: {start_time_str}")
+    print(f"🕐 Finished: {end_time_str}")
+    print(f"⏱️ Total Duration: {duration_str}")
+    
+    print(f"\n{'='*80}")
+    print(" "*20 + "BEST PARAMETERS")
+    print("="*80)
+    for param_name, param_value in best_params.items():
+        print(f"{param_name:25s}: {param_value}")
+    
+    print(f"\n{'='*80}")
+    print(" "*20 + "BEST PERFORMANCE")
+    print("="*80)
+    print(f"Total Return:        {best_result['total_return']:>10.2f}%")
+    print(f"Sharpe Ratio:        {best_result['sharpe']:>10.2f}")
+    print(f"Sortino Ratio:       {best_result['sortino']:>10.2f}")
+    print(f"Calmar Ratio:        {best_result['calmar']:>10.2f}")
+    print(f"Max Drawdown:        {best_result['max_drawdown']:>10.2f}%")
+    print(f"Win Rate:            {best_result['win_rate']:>10.1f}%")
+    print(f"Profit Factor:       {best_result['profit_factor']:>10.2f}")
+    print(f"Total Trades:        {best_result['total_trades']:>10.0f}")
+    print(f"Avg Win:             ${best_result['avg_win']:>10.2f}")
+    print(f"Avg Loss:            ${best_result['avg_loss']:>10.2f}")
+    print("="*80)
+    
+    # ═══════════════════════════════════════════════════════════════════════════
+    # НОВОЕ! ПОЛНЫЙ БЭКТЕСТ ЛУЧШЕЙ КОМБИНАЦИИ СО ВСЕМИ ГРАФИКАМИ
+    # ═══════════════════════════════════════════════════════════════════════════
+    print("\n" + "="*80)
+    print(" "*15 + "RUNNING FULL BACKTEST FOR BEST COMBINATION")
+    print("="*80)
+    print("\n📊 Creating detailed report for best combination...")
+    print(f"Parameters: {', '.join([f'{k}={v}' for k, v in best_params.items()])}\n")
+    
+    # Create config for best combination
+    best_config = base_config.copy()
+    best_config.update(best_params)
+    best_config['_preloaded_lean_df'] = preloaded_lean_df
+    best_config['_preloaded_options_cache'] = preloaded_options_cache
+    
+    # Create folder for best combination
+    best_combo_folder = os.path.join(results_folder, 'best_combination')
+    os.makedirs(best_combo_folder, exist_ok=True)
+    
+    # Run FULL backtest with ALL charts and exports
+    # Note: progress_context=None, so plt.show() will be called but fail due to renderer
+    # We'll display charts explicitly afterwards using IPython.display.Image
+    best_analyzer = run_backtest(
+        strategy_function,
+        best_config,
+        print_report=True,  # ← ПОКАЗЫВАЕМ ПОЛНЫЙ ОТЧЕТ
+        create_charts=True,  # ← СОЗДАЕМ ВСЕ ГРАФИКИ
+        export_results=True,  # ← ЭКСПОРТИРУЕМ ВСЕ ФАЙЛЫ
+        progress_context=None,  # ← Обычный режим
+        chart_filename=os.path.join(best_combo_folder, 'equity_curve.png'),
+        export_prefix=os.path.join(best_combo_folder, 'best')
+    )
+    
+    # Save detailed metrics to optimization_metrics.csv
+    metrics_data = {
+        'metric': list(best_analyzer.metrics.keys()),
+        'value': list(best_analyzer.metrics.values())
+    }
+    metrics_df = pd.DataFrame(metrics_data)
+    metrics_path = os.path.join(results_folder, 'optimization_metrics.csv')
+    metrics_df.to_csv(metrics_path, index=False)
+    
+    print(f"\n✓ Detailed metrics saved: {metrics_path}")
+    print(f"✓ Best combination results saved to: {best_combo_folder}/")
+    
+    # ═══════════════════════════════════════════════════════════════════════════
+    # ОТОБРАЖЕНИЕ ГРАФИКОВ ЛУЧШЕЙ КОМБИНАЦИИ В NOTEBOOK
+    # ═══════════════════════════════════════════════════════════════════════════
+    try:
+        # Charts are displayed in the notebook, not here
+        chart_file = os.path.join(best_combo_folder, 'equity_curve.png')
+        if os.path.exists(chart_file):
+            print(f"\n📈 Best combination charts saved to: {chart_file}")
+    except Exception as e:
+        print(f"\n⚠ Could not display charts (saved to {best_combo_folder}/): {e}")
+    
+    print("="*80 + "\n")
+    
+    return results_df, best_params, results_folder
+
+
+def plot_optimization_results(results_df, param_names, filename='optimization_results.png'):
+    """
+    Create visualization of optimization results
+    
+    Args:
+        results_df: Results DataFrame from optimize_parameters()
+        param_names: List of parameter names
+        filename: Output filename
+    """
+    import matplotlib.pyplot as plt
+    import seaborn as sns
+    
+    valid_results = results_df[results_df['is_valid'] == True].copy()
+    
+    if valid_results.empty:
+        print("No valid results to plot")
+        return
+    
+    sns.set_style("whitegrid")
+    
+    fig = plt.figure(figsize=(18, 12))
+    
+    # 1. Sharpe vs Total Return scatter
+    ax1 = plt.subplot(2, 3, 1)
+    scatter = ax1.scatter(
+        valid_results['total_return'],
+        valid_results['sharpe'],
+        c=valid_results['max_drawdown'],
+        s=valid_results['total_trades']*10,
+        alpha=0.6,
+        cmap='RdYlGn_r'
+    )
+    ax1.set_xlabel('Total Return (%)', fontsize=10)
+    ax1.set_ylabel('Sharpe Ratio', fontsize=10)
+    ax1.set_title('Sharpe vs Return (size=trades, color=drawdown)', fontsize=11, fontweight='bold')
+    plt.colorbar(scatter, ax=ax1, label='Max Drawdown (%)')
+    ax1.grid(True, alpha=0.3)
+    
+    # 2. Parameter heatmap (if 2 parameters)
+    if len(param_names) == 2:
+        ax2 = plt.subplot(2, 3, 2)
+        pivot_data = valid_results.pivot_table(
+            values='sharpe',
+            index=param_names[0],
+            columns=param_names[1],
+            aggfunc='mean'
+        )
+        sns.heatmap(pivot_data, annot=True, fmt='.2f', cmap='RdYlGn', ax=ax2)
+        ax2.set_title(f'Sharpe Ratio Heatmap', fontsize=11, fontweight='bold')
+    else:
+        ax2 = plt.subplot(2, 3, 2)
+        ax2.text(0.5, 0.5, 'Heatmap requires\nexactly 2 parameters',
+                ha='center', va='center', fontsize=12)
+        ax2.axis('off')
+    
+    # 3. Win Rate vs Profit Factor
+    ax3 = plt.subplot(2, 3, 3)
+    scatter3 = ax3.scatter(
+        valid_results['win_rate'],
+        valid_results['profit_factor'],
+        c=valid_results['sharpe'],
+        s=100,
+        alpha=0.6,
+        cmap='viridis'
+    )
+    ax3.set_xlabel('Win Rate (%)', fontsize=10)
+    ax3.set_ylabel('Profit Factor', fontsize=10)
+    ax3.set_title('Win Rate vs Profit Factor (color=Sharpe)', fontsize=11, fontweight='bold')
+    plt.colorbar(scatter3, ax=ax3, label='Sharpe Ratio')
+    ax3.grid(True, alpha=0.3)
+    
+    # 4. Distribution of Sharpe Ratios
+    ax4 = plt.subplot(2, 3, 4)
+    ax4.hist(valid_results['sharpe'], bins=20, color='steelblue', alpha=0.7, edgecolor='black')
+    ax4.axvline(valid_results['sharpe'].mean(), color='red', linestyle='--', linewidth=2, label='Mean')
+    ax4.axvline(valid_results['sharpe'].median(), color='green', linestyle='--', linewidth=2, label='Median')
+    ax4.set_xlabel('Sharpe Ratio', fontsize=10)
+    ax4.set_ylabel('Frequency', fontsize=10)
+    ax4.set_title('Distribution of Sharpe Ratios', fontsize=11, fontweight='bold')
+    ax4.legend()
+    ax4.grid(True, alpha=0.3, axis='y')
+    
+    # 5. Total Trades distribution
+    ax5 = plt.subplot(2, 3, 5)
+    ax5.hist(valid_results['total_trades'], bins=15, color='coral', alpha=0.7, edgecolor='black')
+    ax5.set_xlabel('Total Trades', fontsize=10)
+    ax5.set_ylabel('Frequency', fontsize=10)
+    ax5.set_title('Distribution of Trade Counts', fontsize=11, fontweight='bold')
+    ax5.grid(True, alpha=0.3, axis='y')
+    
+    # 6. Top 10 combinations
+    ax6 = plt.subplot(2, 3, 6)
+    top_10 = valid_results.nlargest(10, 'sharpe')[['combination_id', 'sharpe']].sort_values('sharpe')
+    ax6.barh(range(len(top_10)), top_10['sharpe'], color='green', alpha=0.7)
+    ax6.set_yticks(range(len(top_10)))
+    ax6.set_yticklabels([f"#{int(x)}" for x in top_10['combination_id']])
+    ax6.set_xlabel('Sharpe Ratio', fontsize=10)
+    ax6.set_title('Top 10 Combinations by Sharpe', fontsize=11, fontweight='bold')
+    ax6.grid(True, alpha=0.3, axis='x')
+    
+    plt.tight_layout()
+    plt.savefig(filename, dpi=150, bbox_inches='tight')
+    print(f"\nVisualization saved: {filename}")
+    plt.close()  # Закрываем без показа, так как отображаем через display(Image)
+
+
+# Export all
 __all__ = [
     'BacktestResults', 'BacktestAnalyzer', 'ResultsReporter',
-    'ChartGenerator', 'ResultsExporter', 'run_backtest',
+    'ChartGenerator', 'ResultsExporter', 'run_backtest', 'run_backtest_with_stoploss',
     'init_api', 'api_call', 'APIHelper', 'APIManager',
-    'ResourceMonitor', 'create_progress_bar', 'update_progress', 'format_time'
+    'ResourceMonitor', 'create_progress_bar', 'update_progress', 'format_time',
+    'StopLossManager', 'PositionManager', 'StopLossConfig',
+    'calculate_stoploss_metrics', 'print_stoploss_section', 'create_stoploss_charts',
+    'create_stoploss_comparison_chart',
+    'optimize_parameters', 'plot_optimization_results',
+    'create_optimization_folder',
+    'preload_options_data'  # ← ДОБАВЛЕНО
 ]