Upload 3 files

app.py

@@ -55,12 +55,13 @@ def load_settings():
         "primary_driver": "Bollinger Bands",
         
         "exit_logic_type": "Intelligent (ADX/MACD/ATR)", 
-        "exit_confidence_threshold": 50, 
-        "smart_trailing_stop_pct": 5.0, 
+        "exit_confidence_threshold": 40, 
         "smart_exit_atr_period": 14,
         "smart_exit_atr_multiplier": 3.0,
-        "intelligent_tsl_pct": 0.4,
-        "use_ma_floor_filter": False,
+        "intelligent_tsl_pct": 0.2,
+        "norm_lookback_years": 1,
+        "benchmark_rank": 99,
+        "use_ma_floor_filter": True,
         
         "use_vol": False, "vol_w": 0.5,
         "use_trend": False, "trend_w": 2.0,
@@ -579,10 +580,12 @@ def run_backtest(data, params,
                  smart_trailing_stop_pct=0.05,
                  long_score_95_percentile=None,
                  short_score_95_percentile=None,
+                 benchmark_rank=0.95,
                  smart_exit_atr_period=14,
                  smart_exit_atr_multiplier=3.0,
                  intelligent_tsl_pct=1.0,
-                 analysis_start_date=None):
+                 analysis_start_date=None,
+                 analysis_end_date=None):
 
     df = data.copy()
     required_cols = ['Close']
@@ -747,16 +750,19 @@ def run_backtest(data, params,
 
     if long_score_95_percentile is None:
         long_scores_gt_zero = raw_long_score[raw_long_score > 0]
-        long_95 = long_scores_gt_zero.quantile(0.95) if not long_scores_gt_zero.empty else 1.0
+        # [FIX] Use the variable 'benchmark_rank' instead of hardcoded 0.95
+        long_95 = long_scores_gt_zero.quantile(benchmark_rank) if not long_scores_gt_zero.empty else 1.0
     else:
         long_95 = long_score_95_percentile
 
     if short_score_95_percentile is None:
         short_scores_gt_zero = raw_short_score[raw_short_score > 0]
-        short_95 = short_scores_gt_zero.quantile(0.95) if not short_scores_gt_zero.empty else 1.0 
+        # [FIX] Use the variable 'benchmark_rank' instead of hardcoded 0.95
+        short_95 = short_scores_gt_zero.quantile(benchmark_rank) if not short_scores_gt_zero.empty else 1.0 
     else:
         short_95 = short_score_95_percentile
 
+
     df['long_confidence_score'] = (raw_long_score / long_95 * 100).clip(0, 100) if long_95 > 0 else 0.0
     df['short_confidence_score'] = (raw_short_score / short_95 * 100).clip(0, 100) if short_95 > 0 else 0.0
 
@@ -839,10 +845,16 @@ def run_backtest(data, params,
     short_entry_trigger = base_short_trigger & adx_allows_entry & ((df['short_confidence_score'] >= params['confidence_threshold']) | all_indicators_off) & ma_is_valid
     # [SURGICAL PATCH END] ----------------------------------------------------
 
+    # [FIX] Filter entries by BOTH Start and End date
     if analysis_start_date is not None:
-        date_mask = df.index >= pd.Timestamp(analysis_start_date)
-        long_entry_trigger &= date_mask
-        short_entry_trigger &= date_mask
+        start_mask = df.index >= pd.Timestamp(analysis_start_date)
+        long_entry_trigger &= start_mask
+        short_entry_trigger &= start_mask
+
+    if analysis_end_date is not None:
+        end_mask = df.index <= pd.Timestamp(analysis_end_date)
+        long_entry_trigger &= end_mask
+        short_entry_trigger &= end_mask
 
     if apply_veto:
         long_entry_trigger &= ~df['any_long_veto_trigger']
@@ -898,35 +910,57 @@ def run_backtest(data, params,
     standard_tsl_pct_long = params.get('long_trailing_stop_loss_pct', 0)
     standard_tsl_pct_short = params.get('short_trailing_stop_loss_pct', 0)
     
-    intelligent_tsl_pct_long = intelligent_tsl_pct * 0.60 if exit_logic_type == 'Intelligent (ADX/MACD/ATR)' else 0.0
-    intelligent_tsl_pct_short = intelligent_tsl_pct * 0.60 if exit_logic_type == 'Intelligent (ADX/MACD/ATR)' else 0.0
+    intelligent_tsl_pct_long = intelligent_tsl_pct if exit_logic_type == 'Intelligent (ADX/MACD/ATR)' else 0.0
+    intelligent_tsl_pct_short = intelligent_tsl_pct if exit_logic_type == 'Intelligent (ADX/MACD/ATR)' else 0.0
     
     long_tsl_exit = pd.Series(False, index=df.index); short_tsl_exit = pd.Series(False, index=df.index)
 
     if primary_driver != 'Markov State':
-        # LONG TSL
+        # --- LONG TSL ---
         has_hit_target = potential_long_price_exit
+        # Determine which TSL percentage to use (Standard vs Intelligent)
         tsl_to_use_long = np.where(has_hit_target, intelligent_tsl_pct_long, standard_tsl_pct_long) if use_ma_floor_filter else (intelligent_tsl_pct_long if exit_logic_type == 'Intelligent (ADX/MACD/ATR)' else standard_tsl_pct_long)
         if not isinstance(tsl_to_use_long, pd.Series): tsl_to_use_long = pd.Series(tsl_to_use_long, index=df.index)
 
+        # Only run calculation if TSL is active (> 0)
         if (tsl_to_use_long > 0).any():
             in_long_trade = (df['long_signal'].ffill().fillna(0) == 1)
             long_high_water_mark = df['High'].where(in_long_trade).groupby((~in_long_trade).cumsum()).cummax()
             tsl_from_hwm = long_high_water_mark * (1 - tsl_to_use_long)
-            long_tsl_price = np.maximum(tsl_from_hwm, long_breakeven_floor) if use_ma_floor_filter else tsl_from_hwm
+            
+            # [FIX] Apply Catcher floor ONLY if target has been hit (Persistent during trade)
+            if use_ma_floor_filter:
+                trade_groups = (~in_long_trade).cumsum()
+                # [FIX] Cast to float before cummax to avoid Object dtype error
+                target_hit_persistent = has_hit_target.where(in_long_trade).astype(float).groupby(trade_groups).cummax().fillna(0).astype(bool)
+                long_tsl_price = np.where(target_hit_persistent, np.maximum(tsl_from_hwm, long_breakeven_floor), tsl_from_hwm)
+            else:
+                long_tsl_price = tsl_from_hwm
+                
             long_tsl_exit = in_long_trade & (df['Close'] < long_tsl_price)
             df.loc[long_tsl_exit, 'long_signal'] = 0
 
-        # SHORT TSL
+        # --- SHORT TSL ---
         has_hit_target = potential_short_price_exit
+        # Determine which TSL percentage to use (Standard vs Intelligent)
         tsl_to_use_short = np.where(has_hit_target, intelligent_tsl_pct_short, standard_tsl_pct_short) if use_ma_floor_filter else (intelligent_tsl_pct_short if exit_logic_type == 'Intelligent (ADX/MACD/ATR)' else standard_tsl_pct_short)
         if not isinstance(tsl_to_use_short, pd.Series): tsl_to_use_short = pd.Series(tsl_to_use_short, index=df.index)
 
+        # Only run calculation if TSL is active (> 0)
         if (tsl_to_use_short > 0).any():
             in_short_trade = (df['short_signal'].ffill().fillna(0) == -1)
             short_low_water_mark = df['Low'].where(in_short_trade).groupby((~in_short_trade).cumsum()).cummin()
             tsl_from_lwm = short_low_water_mark * (1 + tsl_to_use_short)
-            short_tsl_price = np.minimum(tsl_from_lwm, short_breakeven_floor) if use_ma_floor_filter else tsl_from_lwm
+            
+            # [FIX] Apply Catcher floor ONLY if target has been hit (Persistent during trade)
+            if use_ma_floor_filter:
+                trade_groups = (~in_short_trade).cumsum()
+                # [FIX] Cast to float before cummax to avoid Object dtype error
+                target_hit_persistent = has_hit_target.where(in_short_trade).astype(float).groupby(trade_groups).cummax().fillna(0).astype(bool)
+                short_tsl_price = np.where(target_hit_persistent, np.minimum(tsl_from_lwm, short_breakeven_floor), tsl_from_lwm)
+            else:
+                short_tsl_price = tsl_from_lwm
+
             short_tsl_exit = in_short_trade & (df['Close'] > short_tsl_price)
             df.loc[short_tsl_exit, 'short_signal'] = 0
    
@@ -1300,36 +1334,50 @@ def display_summary_analytics(summary_df):
 def generate_profit_distribution_chart(summary_df):
     """
     Creates two histograms showing the distribution of Average Profit per Trade
-    for Long and Short strategies across all tickers.
+    for Long and Short strategies.
+    
+    [UPDATED] Now weighted by 'Num Trades' so the Y-axis shows Total Trades,
+    not just Total Tickers.
     """
     if summary_df is None or summary_df.empty: return None
 
     fig = go.Figure()
 
     # 1. Long Distribution
-    if 'Avg Long Profit per Trade' in summary_df.columns:
+    if 'Avg Long Profit per Trade' in summary_df.columns and 'Num Long Trades' in summary_df.columns:
         # Filter out tickers that didn't trade
-        long_data = summary_df[summary_df['Num Long Trades'] > 0]['Avg Long Profit per Trade']
+        mask = summary_df['Num Long Trades'] > 0
+        long_data = summary_df.loc[mask, 'Avg Long Profit per Trade']
+        long_weights = summary_df.loc[mask, 'Num Long Trades'] # Use trade count as weight
+        
         if not long_data.empty:
             fig.add_trace(go.Histogram(
                 x=long_data,
+                y=long_weights,    # [FIX] Weight by number of trades
+                histfunc='sum',    # [FIX] Sum the weights to get Total Trades per bin
                 name='Long Strategy',
                 marker_color='green',
                 opacity=0.7,
-                nbinsx=50, # Granularity
-                histnorm='' # Raw count
+                nbinsx=50, 
+                histnorm='' 
             ))
 
     # 2. Short Distribution
-    if 'Avg Short Profit per Trade' in summary_df.columns:
-        short_data = summary_df[summary_df['Num Short Trades'] > 0]['Avg Short Profit per Trade']
+    if 'Avg Short Profit per Trade' in summary_df.columns and 'Num Short Trades' in summary_df.columns:
+        mask = summary_df['Num Short Trades'] > 0
+        short_data = summary_df.loc[mask, 'Avg Short Profit per Trade']
+        short_weights = summary_df.loc[mask, 'Num Short Trades'] # Use trade count as weight
+        
         if not short_data.empty:
             fig.add_trace(go.Histogram(
                 x=short_data,
+                y=short_weights,   # [FIX] Weight by number of trades
+                histfunc='sum',    # [FIX] Sum the weights
                 name='Short Strategy',
                 marker_color='red',
                 opacity=0.7,
-                nbinsx=50
+                nbinsx=50,
+                visible='legendonly' 
             ))
 
     # 3. Add Zero Line
@@ -1337,10 +1385,10 @@ def generate_profit_distribution_chart(summary_df):
 
     # 4. Layout
     fig.update_layout(
-        title="Distribution of Average Profit per Trade (Per Ticker)",
+        title="Distribution of Average Profit per Trade (Weighted by Trade Count)",
         xaxis_title="Average Profit per Trade (decimal, e.g. 0.01 = 1%)",
-        yaxis_title="Number of Tickers",
-        barmode='overlay', # Overlap them slightly
+        yaxis_title="Number of Trades", # [FIX] Updated Label
+        barmode='overlay', 
         bargap=0.1,
         template="plotly_white",
         legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
@@ -2328,23 +2376,19 @@ def run_advisor_scan(main_df, setups_to_run, advisor_type="Advisor"):
 
             if not data_for_scan.empty and 'Close' in data_for_scan.columns and not data_for_scan['Close'].isna().all() and len(data_for_scan) >= current_lookback :
                 try:
-                    # --- FIX APPLIED HERE: Added the 11th underscore ---
+                    # Added missing MFI and SuperTrend arguments (set to False/1.0) ---
                     _, _, _, _, _, _, open_trades, _, _, _, _ = run_backtest(
                         data_for_scan, params_for_run,
-                        setup_use_rsi, setup_use_vol, setup_use_trend, setup_use_volume,
-                        setup_use_macd, setup_use_ma_slope, setup_use_markov, 
-                        scan_rsi_w, scan_vol_w, scan_trend_w, scan_volume_w,
-                        scan_macd_w, scan_ma_slope_w, scan_markov_w, 
-                        factor_settings['use_adx'], factor_settings['adx_thresh'],
-                        factor_settings['rsi_logic'],
-                        factor_settings['adx_period'],
+                        setup_use_rsi, setup_use_vol, setup_use_trend, setup_use_volume, setup_use_macd, setup_use_ma_slope, setup_use_markov,
+                        False, False, # use_mfi, use_supertrend (Default Off for Advisor scans)
+                        scan_rsi_w, scan_vol_w, scan_trend_w, scan_volume_w, scan_macd_w, scan_ma_slope_w, scan_markov_w,
+                        1.0, 1.0, # mfi_w, supertrend_w (Default 1.0)
+                        factor_settings['use_adx'], factor_settings['adx_thresh'], factor_settings['rsi_logic'], factor_settings['adx_period'],
                         veto_setups_list=None,
-                        primary_driver=factor_settings['primary_driver'], 
-                        markov_setup=factor_settings['markov_setup'],
-                        exit_logic_type=factor_settings['exit_logic'], 
-                        exit_confidence_threshold=factor_settings['exit_thresh'],
-                        smart_trailing_stop_pct=factor_settings['smart_trailing_stop'],
-                        smart_exit_atr_period=factor_settings['smart_exit_atr_period'],
+                        primary_driver=factor_settings['primary_driver'], markov_setup=factor_settings['markov_setup'], 
+                        exit_logic_type=factor_settings['exit_logic'], exit_confidence_threshold=factor_settings['exit_thresh'], 
+                        smart_trailing_stop_pct=factor_settings['smart_trailing_stop'], 
+                        smart_exit_atr_period=factor_settings['smart_exit_atr_period'], 
                         smart_exit_atr_multiplier=factor_settings['smart_exit_atr_multiplier'],
                         intelligent_tsl_pct=factor_settings['intelligent_tsl_pct']
                     )
@@ -3366,7 +3410,7 @@ def main():
                 if main_key in st.session_state:
                     st.session_state[main_key] = st.session_state[widget_key]
     
-    st.set_page_config(page_title="Dave's Quant System", page_icon="🔴", layout="wide")
+    st.set_page_config(page_title="Quant Trader", page_icon="🔴", layout="wide")
 
     # --- [FIX 1: Robust Initialization] ---
     # We check for 'run_mode' explicitly to fix the crash if session state is stale
@@ -3506,7 +3550,7 @@ def main():
     ticker_list = st.session_state.ticker_list
 
     # --- HEADER / GREETING ---
-    st.title("🔴 🚀 Dave's Quant system")
+    st.title("🔴 🚀 Quant Trader")
     
     current_hour = datetime.now().hour
     if 5 <= current_hour < 12: greeting = "Good morning!"
@@ -3551,6 +3595,29 @@ def main():
         div[data-testid="stSidebar"] div[data-testid="stButton"] button { width: 100%; }
         </style>""", unsafe_allow_html=True)
    
+    # --- [MOVED] RUN ANALYSIS BUTTON (PRODUCTION MODE) ---
+    if production_mode:
+        # Note: We do NOT use st.rerun() here. We let the script flow down.
+        if st.sidebar.button("Run Analysis", type="primary", key="run_analysis_prod_top", 
+                             help="Runs the test using the current settings below."):
+            
+            # 1. Force a sync of all widgets to session state
+            update_state()
+            
+            # 2. Set the flag to TRUE so the engine at the bottom runs
+            st.session_state.run_analysis_button = True
+            
+            # 3. Clear previous results to ensure a fresh report
+            st.session_state.run_advanced_advisor = False
+            st.session_state.run_user_advisor_setup = False
+            st.session_state.run_scan_user_setups = False
+            st.session_state.advisor_df = None; st.session_state.raw_df = None; st.session_state.deduped_df = None 
+            st.session_state.param_results_df = None; st.session_state.confidence_results_df = None
+            st.session_state.summary_df = None; st.session_state.single_ticker_results = None
+            st.session_state.open_trades_df = None; st.session_state.last_run_stats = None
+            st.session_state.markov_results_df = None
+        st.sidebar.markdown("---")
+   
 
     # --- SIDEBAR SECTION 1: Select Test Mode & Dates (Common to both) ---
     st.sidebar.header("1. Select Test Mode & Dates")
@@ -3594,6 +3661,39 @@ def main():
         on_change=update_state
     )
     
+    # [NEW] Benchmark Settings Sliders (With Tooltips)
+    st.sidebar.markdown("---")
+    st.sidebar.write("**Benchmark Settings**")
+    
+    # 1. Lookback Slider - VISIBLE IN ALL MODES
+    norm_lookback_years = st.sidebar.slider(
+        "Lookback (Yrs)",
+        min_value=1,
+        max_value=30,
+        value=st.session_state.get('norm_lookback_years', 1), # Load from Config
+        help=(
+                "How many years of history to use when calculating the 'Confidence Score' baseline.\n\n"
+                "• **30 Years (Recommended):** Stable, long-term benchmark. Ensures trades are judged against all-time history.\n"
+                "• **1-2 Years:** Adaptive. Judges trades only against recent market volatility (good for changing regimes)."
+                "• **Default is set to 1 year as we are usually most interested in the recent year.")
+    )
+
+    # 2. Grade Benchmark - HIDDEN IN PRODUCTION MODE
+    if not production_mode:
+        benchmark_percentile_setting = st.sidebar.slider(
+            "Grade Benchmark (%)",
+            min_value=50,
+            max_value=99,
+            value=st.session_state.get('benchmark_rank', 99), # Load from Config
+            help=(
+                "Sets the 'Bar' for the Strategy Score.\n\n"
+                "• **99% (Default):** The top 1% of historical trades set the standard for 'Perfection'.\n"
+                "• **80%:** Lowers the bar. Trades only need to be in the top 20% to get a high score (Useful for low volatility).")
+        )
+    else:
+        # In Production, keep the value but hide the slider
+        benchmark_percentile_setting = st.session_state.get('benchmark_rank', 99)
+      
     st.sidebar.markdown("---")
 
     # --- PRIMARY TRIGGER (Hidden in Production, Forced to BBands) ---
@@ -3615,23 +3715,9 @@ def main():
 
     if production_mode:
         # --- PRODUCTION BUTTONS ---
-        
-        # 1. Run Analysis Button
-        if st.sidebar.button("Run Analysis", type="primary", key="run_analysis_prod", 
-                             help="Runs the test using the manual settings currently visible in Sections 2 & 3 below."):
-            st.session_state.run_analysis_button = True
-            st.session_state.run_advanced_advisor = False
-            st.session_state.run_user_advisor_setup = False
-            st.session_state.run_scan_user_setups = False
-            st.session_state.advisor_df = None; st.session_state.raw_df = None; st.session_state.deduped_df = None 
-            st.session_state.param_results_df = None; st.session_state.confidence_results_df = None
-            st.session_state.summary_df = None; st.session_state.single_ticker_results = None
-            st.session_state.open_trades_df = None; st.session_state.last_run_stats = None
-            st.session_state.markov_results_df = None
-            st.rerun()
 
-        st.sidebar.markdown("---")
-        
+        # [REMOVED] Old "Run Analysis" button was here.
+   
         # 2. Dropdown for User Setups (With "Default" option)
         user_setups_raw = st.session_state.get("user_setups_data", [])
         valid_user_setups = [s for s in user_setups_raw if not is_row_blank(s)]
@@ -3649,12 +3735,11 @@ def main():
             label = f"Setup {i+1}{note_display}"
             setup_options[label] = i
         
-        selected_setup_label = st.sidebar.selectbox("Select User Setup:", list(setup_options.keys()))
-
-        # 3. Run User-Selected Option Button
-        if st.sidebar.button("Run User-Selected Option", type="primary", 
-                             help="Runs the specific setup selected in the dropdown above, overriding manual settings."):
-            idx = setup_options[selected_setup_label]
+        # --- CALLBACK: AUTO-POPULATE SETTINGS ON SELECTION ---
+        def on_user_setup_change():
+            """Callback to populate settings immediately when dropdown changes."""
+            selected_label = st.session_state.widget_user_setup_select_key
+            idx = setup_options[selected_label]
             
             def sync_param(main_key, value):
                 st.session_state[main_key] = value
@@ -3683,7 +3768,6 @@ def main():
                 # Reset ADX (With Clamping for Production Mode)
                 sync_param('use_adx_filter', defaults.get('use_adx_filter', True))
                 raw_adx = defaults.get('adx_threshold', 25.0)
-                # FIX: Clamp value to be within 20-30 range to prevent widget crash
                 clamped_adx = max(20.0, min(30.0, raw_adx)) 
                 sync_param('adx_threshold', clamped_adx)
 
@@ -3703,7 +3787,7 @@ def main():
                 sync_param('short_sl', defaults.get("short_trailing_stop_loss_pct", 8.0) * 100)
                 sync_param('short_delay', defaults.get("short_delay_days", 0))
                 
-                st.toast("Settings reset to Default. Running Analysis...", icon="🔄")
+                st.toast("Settings reset to Default.", icon="🔄")
 
             # --- CASE B: USER SETUP ---
             else:
@@ -3734,7 +3818,6 @@ def main():
                     sync_param('use_adx_filter', True)
                     try:
                         thresh = float(adx_val)
-                        # FIX: Clamp value here too, in case a User Setup has < 20
                         clamped_thresh = max(20.0, min(30.0, thresh))
                         sync_param('adx_threshold', clamped_thresh)
                     except:
@@ -3759,13 +3842,16 @@ def main():
                 sync_param('short_sl', get_num('Short Stop Loss (%)', st.session_state.short_sl, float))
                 sync_param('short_delay', get_num('Short Delay (Days)', st.session_state.short_delay, int))
 
-                st.toast(f"Loaded {selected_setup_label}. Running Analysis...", icon="✅")
+                st.toast(f"Populated settings for {selected_label}", icon="✅")
 
-            st.session_state.run_analysis_button = True
-            st.session_state.run_scan_user_setups = False
-            st.session_state.run_user_advisor_setup = False 
-            st.session_state.advisor_df = None
-            st.rerun()
+        # Selectbox with on_change callback
+        st.sidebar.selectbox(
+            "Select User Setup:", 
+            list(setup_options.keys()), 
+            key="widget_user_setup_select_key", 
+            on_change=on_user_setup_change,
+            help="Selecting a setup will immediately populate the sidebar settings below."
+        )
 
     else:
         # --- DEVELOPER BUTTONS (Original) ---
@@ -4162,7 +4248,9 @@ def main():
                 "smart_trailing_stop_pct": st.session_state.get('smart_trailing_stop_pct', 5.0),
                 "smart_exit_atr_period": st.session_state.get('smart_exit_atr_period', 14),
                 "smart_exit_atr_multiplier": st.session_state.get('smart_exit_atr_multiplier', 3.0),
-                "intelligent_tsl_pct": st.session_state.intelligent_tsl_pct / 100.0, 
+                "intelligent_tsl_pct": st.session_state.intelligent_tsl_pct / 100.0,
+                "norm_lookback_years": norm_lookback_years,
+                "benchmark_rank": benchmark_percentile_setting,
                 "use_vol": st.session_state.use_vol, "vol_w": st.session_state.vol_w,
                 "use_trend": st.session_state.use_trend, "trend_w": st.session_state.trend_w,
                 "use_volume": st.session_state.use_volume, "volume_w": st.session_state.volume_w,
@@ -4359,7 +4447,8 @@ def main():
                     if not selected_ticker:
                         st.error("No ticker selected.")
                         st.stop()
-            
+                    
+                    # Define Start Date for Single Ticker
                     user_start_date = pd.Timestamp(st.session_state.start_date)
 
                     cols_to_use = [selected_ticker]
@@ -4372,9 +4461,25 @@ def main():
                         st.error(f"Ticker '{selected_ticker}' not found.")
                         st.stop()
 
-                    # We use the full dataframe here (without date slicing) to allow run_backtest to handle warm-up
-                    data_for_backtest = master_df.loc[:, existing_cols].copy()
-            
+                    # [FIX] Smart Lookback Logic: Uses the wider of (User Range) or (Slider Lookback)
+                    user_start = pd.Timestamp(st.session_state.start_date)
+                    user_end = pd.Timestamp(st.session_state.end_date)
+                    
+                    # Calculate the slider-based start date
+                    slider_start = user_end - pd.DateOffset(years=norm_lookback_years)
+                    
+                    # 1. Logic: Start loading from the EARLIER of the two dates (Wider Window)
+                    effective_start = min(user_start, slider_start)
+                    
+                    # 2. Safety: Add 365 days EXTRA buffer so MA-200 is ready on Day 1
+                    buffer_start = effective_start - pd.DateOffset(days=365)
+                    
+                    # Ensure we don't go before available data
+                    if not master_df.empty:
+                        buffer_start = max(buffer_start, master_df.index[0])
+
+                    data_for_backtest = master_df.loc[buffer_start:user_end, existing_cols].copy()
+                    
                     rename_dict = {selected_ticker: 'Close', f'{selected_ticker}_High': 'High', f'{selected_ticker}_Low': 'Low', f'{selected_ticker}_Volume': 'Volume'}
                     rename_dict_filtered = {k: v for k, v in rename_dict.items() if k in existing_cols}
                     data_for_backtest = data_for_backtest.rename(columns=rename_dict_filtered)
@@ -4382,40 +4487,41 @@ def main():
                     if not data_for_backtest.empty and 'Close' in data_for_backtest.columns and not data_for_backtest['Close'].isna().all():
                         # --- [FIX END] ---
 
-                         # --- CORRECTED CALL (Matches Analyse Full List) ---
-                         long_pnl, short_pnl, avg_long_trade, avg_short_trade, results_df, trades, open_trades, trade_counts, durations, trade_dates, exit_breakdown = run_backtest(
-                         data_for_backtest, manual_params,
-                         # 1. Toggles (Added mfi and supertrend)
-                         st.session_state.use_rsi, st.session_state.use_vol, st.session_state.use_trend, st.session_state.use_volume,
-                         st.session_state.use_macd, st.session_state.use_ma_slope, st.session_state.use_markov, 
-                         st.session_state.use_mfi, st.session_state.use_supertrend, 
-                         # 2. Weights (Added mfi and supertrend)
-                         st.session_state.rsi_w, st.session_state.vol_w, st.session_state.trend_w, st.session_state.volume_w,
-                         st.session_state.macd_w, st.session_state.ma_slope_w, st.session_state.markov_w, 
-                         st.session_state.mfi_w, st.session_state.supertrend_w, 
-                         # 3. Settings
-                         st.session_state.use_adx_filter, st.session_state.adx_threshold,
-                         st.session_state.get('rsi_logic', 'Crossover'),
-                         st.session_state.adx_period,
-                         veto_setups_list=veto_list_to_use,
-                         primary_driver=st.session_state.primary_driver,
-                         markov_setup=markov_setup_to_use,
-                         exit_logic_type=exit_logic, 
-                         exit_confidence_threshold=exit_thresh,
-                         smart_trailing_stop_pct=smart_trailing_stop,
-                         smart_exit_atr_period=smart_atr_p,
-                         smart_exit_atr_multiplier=smart_atr_m,
-                         intelligent_tsl_pct=intelligent_tsl,
-                         # 4. Start Date Filter (Crucial for matching warmup logic)
-                         analysis_start_date=user_start_date 
-                     )
-                         st.session_state.single_ticker_results = {"long_pnl": long_pnl, "short_pnl": short_pnl, "avg_long_trade": avg_long_trade, "avg_short_trade": avg_short_trade, "results_df": results_df, "trades": trades}
-                         st.session_state.open_trades_df = pd.DataFrame(open_trades) if open_trades else pd.DataFrame()
-                         st.session_state.exit_breakdown_totals = {'long_profit_take_count': exit_breakdown[0], 'long_tsl_count': exit_breakdown[1], 'long_time_exit_count': exit_breakdown[2], 'short_profit_take_count': exit_breakdown[3], 'short_tsl_count': exit_breakdown[4], 'short_time_exit_count': exit_breakdown[5]}
+
+                        long_pnl, short_pnl, avg_long_trade, avg_short_trade, results_df, trades, open_trades, trade_counts, durations, trade_dates, exit_breakdown = run_backtest(
+                            data_for_backtest, manual_params,
+                            st.session_state.use_rsi, st.session_state.use_vol, st.session_state.use_trend, st.session_state.use_volume,
+                            st.session_state.use_macd, st.session_state.use_ma_slope, st.session_state.use_markov, 
+                            st.session_state.use_mfi, st.session_state.use_supertrend, 
+                            st.session_state.rsi_w, st.session_state.vol_w, st.session_state.trend_w, st.session_state.volume_w,
+                            st.session_state.macd_w, st.session_state.ma_slope_w, st.session_state.markov_w, 
+                            st.session_state.mfi_w, st.session_state.supertrend_w, 
+                            st.session_state.use_adx_filter, st.session_state.adx_threshold,
+                            st.session_state.get('rsi_logic', 'Crossover'),
+                            st.session_state.adx_period,
+                            veto_setups_list=veto_list_to_use,
+                            primary_driver=st.session_state.primary_driver,
+                            markov_setup=markov_setup_to_use,
+                            exit_logic_type=exit_logic, 
+                            exit_confidence_threshold=exit_thresh,
+                            smart_trailing_stop_pct=smart_trailing_stop,
+                            smart_exit_atr_period=smart_atr_p,
+                            smart_exit_atr_multiplier=smart_atr_m,
+                            intelligent_tsl_pct=intelligent_tsl,
+                            benchmark_rank=benchmark_percentile_setting / 100.0,
+                            analysis_start_date=user_start_date,
+                            analysis_end_date=end_date
+                        )
+                        st.session_state.single_ticker_results = {"long_pnl": long_pnl, "short_pnl": short_pnl, "avg_long_trade": avg_long_trade, "avg_short_trade": avg_short_trade, "results_df": results_df, "trades": trades}
+                        st.session_state.open_trades_df = pd.DataFrame(open_trades) if open_trades else pd.DataFrame()
+                        st.session_state.exit_breakdown_totals = {'long_profit_take_count': exit_breakdown[0], 'long_tsl_count': exit_breakdown[1], 'long_time_exit_count': exit_breakdown[2], 'short_profit_take_count': exit_breakdown[3], 'short_tsl_count': exit_breakdown[4], 'short_time_exit_count': exit_breakdown[5]}
                     else: st.warning("No data for ticker.")
 
                 # B) Full List Analysis
                 elif st.session_state.run_mode.startswith("Analyse Full List"):
+                    # [FIX] Define Start Date for Full List (Critical Fix)
+                    user_start_date = pd.Timestamp(st.session_state.start_date)
+
                     summary_results, all_open_trades = [], []
                     total_long_wins, total_long_losses, total_short_wins, total_short_losses = 0, 0, 0, 0
                     all_long_durations = []; all_short_durations = []
@@ -4433,27 +4539,44 @@ def main():
                         existing_cols = [col for col in cols_to_use if col in master_df.columns]
                         if ticker_symbol not in existing_cols: continue
                         
-                        # Load data with WARMUP
-                        ticker_data_series = master_df.loc[data_load_start:end_date, existing_cols]
+                        # [FIX] Smart Lookback Logic: Uses the wider of (User Range) or (Slider Lookback)
+                        user_start = pd.Timestamp(st.session_state.start_date)
+                        user_end = pd.Timestamp(st.session_state.end_date)
+                        
+                        slider_start = user_end - pd.DateOffset(years=norm_lookback_years)
+                        
+                        # 1. Logic: Start loading from the EARLIER of the two dates
+                        effective_start = min(user_start, slider_start)
+                        
+                        # 2. Safety: Add 365 days EXTRA buffer
+                        buffer_start = effective_start - pd.DateOffset(days=365)
+                        
+                        if not master_df.empty:
+                                buffer_start = max(buffer_start, master_df.index[0])
+
+                        ticker_data_series = master_df.loc[buffer_start:user_end, existing_cols]
                         
                         rename_dict = {ticker_symbol: 'Close', f'{ticker_symbol}_High': 'High', f'{ticker_symbol}_Low': 'Low', f'{ticker_symbol}_Volume': 'Volume'}
                         ticker_data_series = ticker_data_series.rename(columns={k:v for k,v in rename_dict.items() if k in existing_cols})
 
+
                         if not ticker_data_series.empty and 'Close' in ticker_data_series.columns and not ticker_data_series['Close'].isna().all():
                             long_pnl, short_pnl, avg_long_trade, avg_short_trade, results_df, trades, open_trades, trade_counts, durations, trade_dates, exit_breakdown = run_backtest(
-                                ticker_data_series, manual_params,  # <--- THIS WAS THE ERROR SOURCE
+                                ticker_data_series, manual_params,
                                 st.session_state.use_rsi, st.session_state.use_vol, st.session_state.use_trend, st.session_state.use_volume,
                                 st.session_state.use_macd, st.session_state.use_ma_slope, st.session_state.use_markov, 
-                                st.session_state.use_mfi, st.session_state.use_supertrend, # Added MFI/ST
+                                st.session_state.use_mfi, st.session_state.use_supertrend,
                                 st.session_state.rsi_w, st.session_state.vol_w, st.session_state.trend_w, st.session_state.volume_w,
                                 st.session_state.macd_w, st.session_state.ma_slope_w, st.session_state.markov_w, 
-                                st.session_state.mfi_w, st.session_state.supertrend_w, # Added MFI/ST weights
+                                st.session_state.mfi_w, st.session_state.supertrend_w,
                                 st.session_state.use_adx_filter, st.session_state.adx_threshold, st.session_state.get('rsi_logic', 'Crossover'), st.session_state.adx_period, 
                                 veto_setups_list=veto_list_to_use, primary_driver=st.session_state.primary_driver,
                                 markov_setup=markov_setup_to_use, exit_logic_type=exit_logic, exit_confidence_threshold=exit_thresh,
                                 smart_trailing_stop_pct=smart_trailing_stop, smart_exit_atr_period=smart_atr_p,
                                 smart_exit_atr_multiplier=smart_atr_m, intelligent_tsl_pct=intelligent_tsl,
-                                analysis_start_date=user_start_date
+                                benchmark_rank=benchmark_percentile_setting / 100.0,
+                                analysis_start_date=user_start_date,
+                                analysis_end_date=end_date
                             )
 
                             if abs(long_pnl) > PROFIT_THRESHOLD or abs(short_pnl) > PROFIT_THRESHOLD or \
@@ -4502,7 +4625,6 @@ def main():
                         st.session_state.exit_breakdown_totals = {}
 
                     st.session_state.open_trades_df = pd.DataFrame(all_open_trades) if all_open_trades else pd.DataFrame()
-            st.rerun()
 
         # 10. Display Advisor Scan Results (raw_df)
         elif 'raw_df' in st.session_state and st.session_state.raw_df is not None:
@@ -4619,7 +4741,8 @@ def main():
             display_open_df = full_df[mask_open | mask_recent].copy()
             # -------------------------------------------------------
 
-            display_open_df.sort_values(by=['Status', 'Date Open'], ascending=[True, False], inplace=True)
+            # [FIX] Sort strictly by Date Open (Newest First)
+            display_open_df.sort_values(by='Date Open', ascending=False, inplace=True)
             
             cols_order_manual = ['Ticker', 'Status', 'Final % P/L', 'Side', 'Date Open', 'Date Closed', 'Start Confidence']
             existing_cols_open = [col for col in cols_order_manual if col in display_open_df.columns]
@@ -4714,17 +4837,6 @@ def main():
             run_optimization()
             st.session_state.run_advanced_advisor = False
 
-    if st.session_state.run_user_advisor_setup:
-        with st.spinner("Running User Setup..."):
-            current_params = {k: st.session_state[k] for k in defaults.keys() if k in st.session_state}
-            current_params['use_mfi'] = st.session_state.use_mfi
-            current_params['mfi_w'] = st.session_state.mfi_w
-            current_params['use_supertrend'] = st.session_state.use_supertrend
-            current_params['supertrend_w'] = st.session_state.supertrend_w
-            
-            run_user_defined_setup(current_params)
-            st.session_state.run_user_advisor_setup = False
-
 # --- CHART FUNCTION (Must be outside main) ---
 def generate_trades_timeline_histogram(trades_df, start_date, end_date):
     """
@@ -4748,11 +4860,12 @@ def generate_trades_timeline_histogram(trades_df, start_date, end_date):
 
     fig = go.Figure()
     
-    # Add Stacked Traces
+    # Add Stacked Traces (Shorts hidden by default via visible='legendonly')
     fig.add_trace(go.Histogram(x=long_wins['Date Closed'], name='Long Winners', marker_color='green'))
     fig.add_trace(go.Histogram(x=long_loss['Date Closed'], name='Long Losers', marker_color='red'))
-    fig.add_trace(go.Histogram(x=short_wins['Date Closed'], name='Short Winners', marker_color='blue'))
-    fig.add_trace(go.Histogram(x=short_loss['Date Closed'], name='Short Losers', marker_color='orange'))
+    
+    fig.add_trace(go.Histogram(x=short_wins['Date Closed'], name='Short Winners', marker_color='blue', visible='legendonly'))
+    fig.add_trace(go.Histogram(x=short_loss['Date Closed'], name='Short Losers', marker_color='orange', visible='legendonly'))
 
     fig.update_layout(
         barmode='stack',
@@ -4761,7 +4874,9 @@ def generate_trades_timeline_histogram(trades_df, start_date, end_date):
         yaxis_title="Number of Trades",
         height=400,
         template="plotly_white",
-        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1)
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
+        # [FIX] Force the X-axis range to match the user's selected date settings
+        xaxis=dict(range=[start_date, end_date])
     )
     return fig
 

config.json

@@ -1,10 +1,10 @@
 {
     "large_ma_period": 70,
     "bband_period": 32,
-    "bband_std_dev": 1.399999999999999,
-    "confidence_threshold": 40,
+    "bband_std_dev": 1.4,
+    "confidence_threshold": 95,
     "long_entry_threshold_pct": 0.01,
-    "long_exit_ma_threshold_pct": 0.01,
+    "long_exit_ma_threshold_pct": 0.0,
     "long_trailing_stop_loss_pct": 0.2,
     "long_delay_days": 0,
     "short_entry_threshold_pct": 0.0,
@@ -12,29 +12,31 @@
     "short_trailing_stop_loss_pct": 0.2,
     "short_delay_days": 0,
     "use_rsi": true,
-    "rsi_w": 0.5000000000000001,
+    "rsi_w": 0.9999999999999997,
     "rsi_logic": "Level",
     "primary_driver": "Bollinger Bands",
     "exit_logic_type": "Intelligent (ADX/MACD/ATR)",
-    "use_ma_floor_filter": false,
-    "exit_confidence_threshold": 50,
+    "use_ma_floor_filter": true,
+    "exit_confidence_threshold": 40,
     "smart_trailing_stop_pct": 5.0,
     "smart_exit_atr_period": 14,
     "smart_exit_atr_multiplier": 3.0,
-    "intelligent_tsl_pct": 0.4,
+    "intelligent_tsl_pct": 0.2,
+    "norm_lookback_years": 1,
+    "benchmark_rank": 99,
     "use_vol": false,
     "vol_w": 0.5,
     "use_trend": false,
     "trend_w": 2.0,
     "use_volume": true,
-    "volume_w": 0.5,
+    "volume_w": 0.9999999999999999,
     "use_adx_filter": false,
-    "adx_threshold": 26.0,
+    "adx_threshold": 10.0,
     "adx_period": 14,
-    "use_macd": true,
+    "use_macd": false,
     "macd_w": 2.0,
     "use_ma_slope": false,
-    "ma_slope_w": 2.0,
+    "ma_slope_w": 0.5,
     "use_markov": false,
     "markov_w": 1.0,
     "max_trading_days": 60,