Update app.py

app.py

@@ -1,3 +1,4 @@
+
 import os
 
 import gradio as gr
@@ -26,102 +27,93 @@ except:
 
 
 
-# 🔁 Strategy Presets
-
-strategy_presets = {
-
-    "Aggressive Prop Trader": {
+# === STRATEGY PRESETS ===
 
-        "starting_balance": 2500, "trades_min": 5, "trades_max": 10, "weeks": 12,
+def get_strategy_presets():
 
-        "tp1_prob": 0.25, "tp2_prob": 0.4, "tp1_r": 1.2, "tp2_r": 2.4,
+    return {
 
-        "base_risk_pct": 0.015, "profit_target": None,
+        "Aggressive Prop Trader": {
 
-        "fatigue": 0.0, "trump_vol": 0.0,
+            "starting_balance": 2500, "trades_min": 5, "trades_max": 10, "weeks": 12,
 
-        "description": "High-frequency, high-risk with strong upside potential."
+            "tp1_prob": 0.25, "tp2_prob": 0.4, "tp1_r": 1.2, "tp2_r": 2.4,
 
-    },
+            "base_risk_pct": 0.015, "profit_target": None,
 
-    "Conservative Swing Trader": {
+            "fatigue": 0.0, "trump_vol": 0.0,
 
-        "starting_balance": 2500, "trades_min": 2, "trades_max": 5, "weeks": 12,
+            "description": "High-frequency, high-risk with strong upside potential."
 
-        "tp1_prob": 0.35, "tp2_prob": 0.25, "tp1_r": 0.9, "tp2_r": 1.8,
+        },
 
-        "base_risk_pct": 0.01, "profit_target": None,
+        "Conservative Swing Trader": {
 
-        "fatigue": 0.0, "trump_vol": 0.0,
+            "starting_balance": 2500, "trades_min": 2, "trades_max": 5, "weeks": 12,
 
-        "description": "Lower frequency, prioritizes preservation and steady returns."
+            "tp1_prob": 0.35, "tp2_prob": 0.25, "tp1_r": 0.9, "tp2_r": 1.8,
 
-    },
+            "base_risk_pct": 0.01, "profit_target": None,
 
-    "Momentum Scalper": {
+            "fatigue": 0.0, "trump_vol": 0.0,
 
-        "starting_balance": 2500, "trades_min": 4, "trades_max": 8, "weeks": 12,
+            "description": "Lower frequency, prioritizes preservation and steady returns."
 
-        "tp1_prob": 0.3, "tp2_prob": 0.35, "tp1_r": 1.0, "tp2_r": 2.2,
+        },
 
-        "base_risk_pct": 0.012, "profit_target": None,
+        "Momentum Scalper": {
 
-        "fatigue": 0.0, "trump_vol": 0.0,
+            "starting_balance": 2500, "trades_min": 4, "trades_max": 8, "weeks": 12,
 
-        "description": "Intraday momentum strategy for fast-paced trading windows."
+            "tp1_prob": 0.3, "tp2_prob": 0.35, "tp1_r": 1.0, "tp2_r": 2.2,
 
-    },
+            "base_risk_pct": 0.012, "profit_target": None,
 
-    "Swing Sniper": {
+            "fatigue": 0.0, "trump_vol": 0.0,
 
-        "starting_balance": 2500, "trades_min": 2, "trades_max": 4, "weeks": 12,
+            "description": "Intraday momentum strategy for fast-paced trading windows."
 
-        "tp1_prob": 0.2, "tp2_prob": 0.5, "tp1_r": 1.1, "tp2_r": 3.0,
+        },
 
-        "base_risk_pct": 0.008, "profit_target": None,
+        "Swing Sniper": {
 
-        "fatigue": 0.0, "trump_vol": 0.0,
+            "starting_balance": 2500, "trades_min": 2, "trades_max": 4, "weeks": 12,
 
-        "description": "Selective entries with high RR setups. Less frequent."
+            "tp1_prob": 0.2, "tp2_prob": 0.5, "tp1_r": 1.1, "tp2_r": 3.0,
 
-    },
+            "base_risk_pct": 0.008, "profit_target": None,
 
-    "Intraday Prop Mode": {
+            "fatigue": 0.0, "trump_vol": 0.0,
 
-        "starting_balance": 2500, "trades_min": 3, "trades_max": 7, "weeks": 12,
+            "description": "Selective entries with high RR setups. Less frequent."
 
-        "tp1_prob": 0.3, "tp2_prob": 0.3, "tp1_r": 1.0, "tp2_r": 2.0,
+        },
 
-        "base_risk_pct": 0.02, "profit_target": None,
+        "Intraday Prop Mode": {
 
-        "fatigue": 0.0, "trump_vol": 0.0,
+            "starting_balance": 2500, "trades_min": 3, "trades_max": 7, "weeks": 12,
 
-        "description": "Intraday consistency with a balanced reward profile."
+            "tp1_prob": 0.3, "tp2_prob": 0.3, "tp1_r": 1.0, "tp2_r": 2.0,
 
-    }
-
-}
+            "base_risk_pct": 0.02, "profit_target": None,
 
-def get_scaled_risk_pct(balance, base_risk_pct):
+            "fatigue": 0.0, "trump_vol": 0.0,
 
-    if balance < 5000:
+            "description": "Intraday consistency with a balanced reward profile."
 
-        return base_risk_pct
+        }
 
-    elif balance < 10000:
+    }
 
-        return base_risk_pct * 0.75
 
-    elif balance < 20000:
 
-        return base_risk_pct * 0.5
 
-    else:
+strategy_presets = get_strategy_presets()
 
-        return base_risk_pct * 0.25
 
 
 
+# === CORE SIMULATION ===
 
 def simulate_tp_strategy_full(starting_balance, trades_min, trades_max, weeks,
 
@@ -133,31 +125,21 @@ def simulate_tp_strategy_full(starting_balance, trades_min, trades_max, weeks,
 
         return pd.DataFrame(), {"Error": "Invalid probability config. TP1 + TP2 must be < 1.0"}
 
-
-
+    
 
     sl_prob = 1.0 - tp1_prob - tp2_prob
 
-    balance = starting_balance
-
-    peak = balance
-
-    drawdown = 0
+    balance, peak, drawdown = starting_balance, starting_balance, 0
 
     tp1_hits = tp2_hits = sl_hits = 0
 
-    max_win_streak = max_loss_streak = 0
+    max_win_streak = max_loss_streak = cur_win_streak = cur_loss_streak = 0
 
-    cur_win_streak = cur_loss_streak = 0
+    fatigue_multiplier = 1.0 - fatigue * 0.4
 
-    log = []
-
-
-
-
-    fatigue_multiplier = 1.0 - fatigue * 0.4  # Reduce reward at high fatigue
+    trump_vol_factor = np.random.normal(1.0, 0.2 * trump_vol)
 
-    trump_vol_factor = np.random.normal(1.0, 0.2 * trump_vol)  # Adds chaos
+    log = []
 
 
 
@@ -170,18 +152,14 @@ def simulate_tp_strategy_full(starting_balance, trades_min, trades_max, weeks,
 
         num_trades = np.random.randint(trades_min, trades_max + 1)
 
-        for _ in range(num_trades):
-
-            risk_pct = get_scaled_risk_pct(balance, base_risk_pct)
 
-            risk_amount = balance * risk_pct * np.random.uniform(0.9, 1.1)  # Risk % w/ some variability
-
-            risk_amount *= trump_vol_factor  # 🟠 Vol boost
 
 
+        for _ in range(num_trades):
 
+            risk_amount = balance * base_risk_pct * np.random.uniform(0.9, 1.1)
 
-            # Fatigue loss streak logic
+            risk_amount *= trump_vol_factor
 
             if fatigue > 0.6 and cur_loss_streak >= 3 and np.random.rand() < fatigue * 0.25:
 
@@ -238,15 +216,13 @@ def simulate_tp_strategy_full(starting_balance, trades_min, trades_max, weeks,
 
 
 
-        weekly_return = (balance - week_start) / week_start * 100
-
         log.append({
 
             "Week": week, "Start Balance": round(week_start, 2),
 
             "End Balance": round(balance, 2),
 
-            "Weekly Return (%)": round(weekly_return, 2)
+            "Weekly Return (%)": round((balance - week_start) / week_start * 100, 2)
 
         })
 
@@ -257,15 +233,10 @@ def simulate_tp_strategy_full(starting_balance, trades_min, trades_max, weeks,
 
     returns = df["End Balance"].pct_change().dropna()
 
-    volatility = returns.std() * np.sqrt(52)
-
-    sharpe_ratio = returns.mean() / returns.std() * np.sqrt(52) if returns.std() > 0 else 0
+    sharpe = returns.mean() / returns.std() * np.sqrt(52) if returns.std() > 0 else 0
 
     score = balance / (1 + drawdown)
 
-
-
-
     summary = {
 
         "Final Balance": round(balance, 2),
@@ -282,7 +253,7 @@ def simulate_tp_strategy_full(starting_balance, trades_min, trades_max, weeks,
 
         "Max Loss Streak": max_loss_streak,
 
-        "Sharpe Ratio": round(sharpe_ratio, 2),
+        "Sharpe Ratio": round(sharpe, 2),
 
         "EdgeCast Score": round(score, 2)
 
@@ -290,131 +261,114 @@ def simulate_tp_strategy_full(starting_balance, trades_min, trades_max, weeks,
 
     return df, summary
 
-# 📈 Plot
 
-def equity_curve_plot(df, label="Equity Curve"):
 
-    fig = go.Figure()
-
-    fig.add_trace(go.Scatter(x=df["Week"], y=df["End Balance"], mode='lines+markers', name=label))
-
-    fig.update_layout(title=f'📈 {label}', xaxis_title='Week', yaxis_title='Balance ($)', height=400)
-
-    return fig
 
+# === VISUALIZATION ===
 
+def equity_curve_plot(df, label="Equity Curve"):
 
+    fig = go.Figure()
 
-# 🎯 Preset Tab
-
-def run_preset_strategy(style, fatigue=0.0, trump_vol=0.0):
-
-    if style not in strategy_presets:
-
-        return pd.DataFrame(), {}, go.Figure(), "Please select a strategy to begin."
-
-    config = strategy_presets[style]
+    fig.add_trace(go.Scatter(x=df["Week"], y=df["End Balance"], mode="lines+markers", name=label))
 
-    df, summary = simulate_tp_strategy_full(
+    fig.update_layout(title=f"📈 {label}", xaxis_title="Week", yaxis_title="Balance ($)", height=400)
 
-        config["starting_balance"], config["trades_min"], config["trades_max"], config["weeks"],
+    return fig
 
-        config["tp1_prob"], config["tp2_prob"], config["tp1_r"], config["tp2_r"],
 
-        config["base_risk_pct"], config["profit_target"],
 
-        fatigue=fatigue, trump_vol=trump_vol
 
-    )
+def generate_histogram(metric="EdgeCast Score", runs=100):
 
-    return df, summary, equity_curve_plot(df, style), config["description"]
+    all_metrics = []
 
+    for name, config in strategy_presets.items():
 
+        for _ in range(runs):
 
+            _, summary = simulate_tp_strategy_full(
 
-# 🛠️ Manual Tab
+                config["starting_balance"], config["trades_min"], config["trades_max"], config["weeks"],
 
-def run_manual_sim(starting_balance, trades_min, trades_max, weeks,
+                config["tp1_prob"], config["tp2_prob"], config["tp1_r"], config["tp2_r"],
 
-                   tp1_prob, tp2_prob, tp1_r, tp2_r, base_risk_pct, profit_target,
+                config["base_risk_pct"], config["profit_target"], config["fatigue"], config["trump_vol"]
 
-                   fatigue, trump_vol):
+            )
 
-    df, summary = simulate_tp_strategy_full(starting_balance, trades_min, trades_max, weeks,
+            if metric in summary:
 
-                                            tp1_prob, tp2_prob, tp1_r, tp2_r, base_risk_pct,
+                all_metrics.append({
 
-                                            profit_target, fatigue, trump_vol)
+                    "Strategy": name,
 
-    chart = equity_curve_plot(df, "Manual Config")
+                    metric: summary[metric]
 
-    return df, summary, chart
+                })
 
 
 
 
-# ⚔️ Manual Battle Mode (Dual Sim)
+    df = pd.DataFrame(all_metrics)
 
-def dual_manual_battle(
 
-    sb1, tmin1, tmax1, w1, tp1a, tp2a, r1a, r2a, risk1, pt1, fat1, trump1,
 
-    sb2, tmin2, tmax2, w2, tp1b, tp2b, r1b, r2b, risk2, pt2, fat2, trump2
 
-):
+    fig = px.histogram(
 
-    df1, s1 = simulate_tp_strategy_full(sb1, tmin1, tmax1, w1, tp1a, tp2a, r1a, r2a, risk1, pt1, fat1, trump1)
+        df,
 
-    df2, s2 = simulate_tp_strategy_full(sb2, tmin2, tmax2, w2, tp1b, tp2b, r1b, r2b, risk2, pt2, fat2, trump2)
+        x=metric,
 
+        color="Strategy",
 
+        marginal="box",
 
+        opacity=0.75,
 
-    s1["Strategy"] = "Manual A"
+        barmode="overlay",
 
-    s2["Strategy"] = "Manual B"
+        nbins=30,
 
+        title=f"📊 Distribution of {metric} Across Strategies"
 
+    )
 
 
-    comparison_df = pd.DataFrame([s1, s2])
 
-    comparison_df = comparison_df[["Strategy", "Final Balance", "Sharpe Ratio", "EdgeCast Score", "Max Drawdown %"]]
 
+    fig.update_layout(
 
+        xaxis_title=metric,
 
+        yaxis_title="Count",
 
-    # 🏆 Winners
+        bargap=0.1,
 
-    for col in ["Final Balance", "Sharpe Ratio", "EdgeCast Score"]:
+        height=500
 
-        best_val = comparison_df[col].astype(float).max()
+    )
 
-        comparison_df[col] = [
 
-            f"{val} 🏆" if float(val) == best_val else f"{val}" for val in comparison_df[col]
 
-        ]
 
+    return fig
 
 
 
-    # Chart
 
-    fig = go.Figure()
 
-    fig.add_trace(go.Scatter(x=df1["Week"], y=df1["End Balance"], name="Manual A"))
 
-    fig.add_trace(go.Scatter(x=df2["Week"], y=df2["End Balance"], name="Manual B"))
 
-    fig.update_layout(title="⚔️ Manual Strategy Battle", xaxis_title="Week", yaxis_title="Balance")
+def histogram_viewer_ui(metric):
 
+    return generate_histogram(metric)
 
 
 
-    return comparison_df, fig
 
-# 📊 Leaderboard Tab
+# === ANALYSIS TOOLS ===
 
 def analytics_dashboard(rank_by="EdgeCast Score"):
 
@@ -428,16 +382,8 @@ def analytics_dashboard(rank_by="EdgeCast Score"):
 
         results.append(summary)
 
-
-
-
     df = pd.DataFrame(results)
 
-
-
-
-    # Get numeric winners before formatting
-
     winner_vals = {
 
         "Final Balance": df["Final Balance"].max(),
@@ -450,369 +396,277 @@ def analytics_dashboard(rank_by="EdgeCast Score"):
 
     }
 
-
-
-
-    # Sort leaderboard by selected metric
-
-    ascending = rank_by == "Max Drawdown %"
-
-    df = df.sort_values(rank_by, ascending=ascending).reset_index(drop=True)
-
-
-
-
-    # Rank column
+    df = df.sort_values(rank_by, ascending=(rank_by == "Max Drawdown %")).reset_index(drop=True)
 
     df.insert(0, "🏅 Rank", [f"#{i+1}" for i in df.index])
 
-
-
-
-    # 🏆 Emoji highlights
-
     for col in winner_vals:
 
-        df[col] = df[col].apply(lambda x: f"{round(x, 2)} 🏆" if x == winner_vals[col] else f"{round(x, 2)}")
-
-
-
+        df[col] = df[col].apply(lambda x: f"{round(x,2)} 🏆" if x == winner_vals[col] else f"{round(x,2)}")
 
     return df[["🏅 Rank", "Strategy", "Final Balance", "Sharpe Ratio", "EdgeCast Score", "Max Drawdown %"]]
 
 
 
 
-
-
-
-# 📘 Description Tab
-
 def show_descriptions():
 
-    return pd.DataFrame([
-
-        {"Strategy": name, "Description": config["description"]}
-
-        for name, config in strategy_presets.items()
-
-    ])
-
+    return pd.DataFrame([{"Strategy": name, "Description": cfg["description"]} for name, cfg in strategy_presets.items()])
 
 
 
 
-
-
-# 🔬 Risk Matrix Heatmap
-
 def generate_risk_matrix():
 
     names = list(strategy_presets.keys())
 
-    scores = {
-
-        name: simulate_tp_strategy_full(**{k: v for k, v in cfg.items() if k != "description"})[1]["EdgeCast Score"]
-
-        for name, cfg in strategy_presets.items()
-
-    }
-
-    matrix = np.zeros((len(names), len(names)))
-
-    for i, a in enumerate(names):
-
-        for j, b in enumerate(names):
+    scores = {n: simulate_tp_strategy_full(**{k: v for k, v in cfg.items() if k != "description"})[1]["EdgeCast Score"] for n, cfg in strategy_presets.items()}
 
-            matrix[i, j] = abs(scores[a] - scores[b])
+    matrix = np.array([[abs(scores[a] - scores[b]) for b in names] for a in names])
 
+    fig = px.imshow(matrix, x=names, y=names, text_auto=".2f", color_continuous_scale="RdYlGn_r", labels={"color": "Δ Score"})
 
-
-
-    fig = px.imshow(
-
-        matrix,
-
-        x=names,
-
-        y=names,
-
-        text_auto=".2f",
-
-        color_continuous_scale="RdYlGn_r",
-
-        labels={"color": "Score Δ"},
-
-        title="🧠 Risk Matrix (Δ Score Heatmap)"
-
-    )
-
-    fig.update_traces(
-
-        hovertemplate="<b>%{y}</b> vs <b>%{x}</b><br>Δ Score: %{z:.2f}<extra></extra>"
-
-    )
+    fig.update_layout(title="🧠 Risk Matrix (Score Δ)", height=600)
 
     return fig
 
 
 
 
+# === STRATEGY RUNNERS ===
 
+def run_preset_strategy(style, fatigue=0.0, trump_vol=0.0):
 
+    config = strategy_presets[style]
 
-# 🥊 Battle Strategies (Preset vs Preset)
-
-def battle_strategies(style1, style2):
-
-    if style1 == "None" or style2 == "None":
-
-        return pd.DataFrame([{"⚠️ Error": "Please select two valid strategies."}]), go.Figure()
-
-
-
-
-    if style1 == style2:
-
-        return pd.DataFrame([{"⚠️ Error": "Please select two different strategies."}]), go.Figure()
-
-
-
-
-    try:
-
-        df1, s1 = simulate_tp_strategy_full(**{k: v for k, v in strategy_presets[style1].items() if k != "description"})
-
-        df2, s2 = simulate_tp_strategy_full(**{k: v for k, v in strategy_presets[style2].items() if k != "description"})
-
-
-
+    df, summary = simulate_tp_strategy_full(
 
-        s1["Strategy"] = style1
+        config["starting_balance"], config["trades_min"], config["trades_max"], config["weeks"],
 
-        s2["Strategy"] = style2
+        config["tp1_prob"], config["tp2_prob"], config["tp1_r"], config["tp2_r"],
 
+        config["base_risk_pct"], config["profit_target"], fatigue, trump_vol
 
+    )
 
+    return df, summary, equity_curve_plot(df, style), config["description"]
 
-        comparison_df = pd.DataFrame([s1, s2])
 
-        comparison_df = comparison_df[["Strategy", "Final Balance", "Sharpe Ratio", "EdgeCast Score", "Max Drawdown %"]]
 
 
+def run_manual_sim(starting_balance, trades_min, trades_max, weeks,
 
+                   tp1_prob, tp2_prob, tp1_r, tp2_r, base_risk_pct, profit_target,
 
-        for col in ["Final Balance", "Sharpe Ratio", "EdgeCast Score"]:
+                   fatigue, trump_vol):
 
-            best_val = comparison_df[col].astype(float).max()
+    df, summary = simulate_tp_strategy_full(
 
-            comparison_df[col] = [
+        starting_balance, trades_min, trades_max, weeks,
 
-                f"{val} 🏆" if float(val) == best_val else val for val in comparison_df[col]
+        tp1_prob, tp2_prob, tp1_r, tp2_r, base_risk_pct,
 
-            ]
+        profit_target, fatigue, trump_vol
 
+    )
 
+    return df, summary, equity_curve_plot(df, "Manual Config")
 
 
-        fig = go.Figure()
 
-        fig.add_trace(go.Scatter(x=df1["Week"], y=df1["End Balance"], name=style1))
 
-        fig.add_trace(go.Scatter(x=df2["Week"], y=df2["End Balance"], name=style2))
+def dual_manual_battle(
 
-        fig.update_layout(title=f"🥊 {style1} vs {style2}", xaxis_title="Week", yaxis_title="Balance")
+    sb1, tmin1, tmax1, w1, tp1a, tp2a, r1a, r2a, risk1, pt1, fat1, trump1,
 
+    sb2, tmin2, tmax2, w2, tp1b, tp2b, r1b, r2b, risk2, pt2, fat2, trump2
 
+):
 
+    df1, s1 = simulate_tp_strategy_full(sb1, tmin1, tmax1, w1, tp1a, tp2a, r1a, r2a, risk1, pt1, fat1, trump1)
 
-        return comparison_df, fig
+    df2, s2 = simulate_tp_strategy_full(sb2, tmin2, tmax2, w2, tp1b, tp2b, r1b, r2b, risk2, pt2, fat2, trump2)
 
+    s1["Strategy"], s2["Strategy"] = "Manual A", "Manual B"
 
+    df_summary = pd.DataFrame([s1, s2])[["Strategy", "Final Balance", "Sharpe Ratio", "EdgeCast Score", "Max Drawdown %"]]
 
+    for col in ["Final Balance", "Sharpe Ratio", "EdgeCast Score"]:
 
-    except Exception as e:
+        best = df_summary[col].astype(float).max()
 
-        return pd.DataFrame([{"Error": str(e)}]), go.Figure()
+        df_summary[col] = [f"{val} 🏆" if float(val) == best else val for val in df_summary[col]]
 
-    
+    fig = go.Figure()
 
-# 🚀 App UI Launch
+    fig.add_trace(go.Scatter(x=df1["Week"], y=df1["End Balance"], name="Manual A"))
 
-app = gr.TabbedInterface(
+    fig.add_trace(go.Scatter(x=df2["Week"], y=df2["End Balance"], name="Manual B"))
 
-    interface_list=[
+    fig.update_layout(title="⚔️ Manual Strategy Battle", xaxis_title="Week", yaxis_title="Balance")
 
-        # 🎯 Preset Mode
+    return df_summary, fig
 
-        gr.Interface(
 
-            fn=run_preset_strategy,
 
-            inputs=gr.Dropdown(
 
-                choices=["None"] + list(strategy_presets.keys()),
+def get_manual_battle_interface():
 
-                value="None",
+    return gr.Interface(
 
-                label="Select Strategy"
+        fn=dual_manual_battle,
 
-            ),
+        inputs=[
 
-            outputs=["dataframe", "json", gr.Plot(), "text"],
+            # A Config
 
-            title="🎯 Preset Mode"
+            gr.Slider(100, 20000, 2500, label="A: Start Balance"),
 
-        ),
+            gr.Slider(1, 10, 3, label="A: Trades Min"),
 
+            gr.Slider(1, 15, 7, label="A: Trades Max"),
 
+            gr.Slider(1, 52, 12, label="A: Weeks"),
 
+            gr.Slider(0, 1, 0.3, step=0.05, label="A: TP1 %"),
 
-        # 🛠️ Manual Config
+            gr.Slider(0, 1, 0.3, step=0.05, label="A: TP2 %"),
 
-        gr.Interface(
+            gr.Slider(0.1, 5.0, 1.0, step=0.1, label="A: TP1 R"),
 
-            fn=run_manual_sim,
+            gr.Slider(0.1, 20.0, 2.0, step=0.1, label="A: TP2 R"),
 
-            inputs=[
+            gr.Slider(0.001, 0.05, 0.01, step=0.001, label="A: Risk %"),
 
-                gr.Slider(100, 20000, 2500, label="Start Balance"),
+            gr.Slider(0, 100000, 0, step=500, label="A: Profit Target"),
 
-                gr.Slider(1, 10, 3, label="Trades Min"),
+            gr.Slider(0, 1, 0.0, step=0.1, label="A: Fatigue"),
 
-                gr.Slider(1, 15, 7, label="Trades Max"),
+            gr.Slider(0, 1, 0.0, step=0.1, label="A: Trump Volatility"),
 
-                gr.Slider(1, 52, 12, label="Weeks"),
+            # B Config
 
-                gr.Slider(0, 1, 0.3, step=0.05, label="TP1 %"),
+            gr.Slider(100, 20000, 2500, label="B: Start Balance"),
 
-                gr.Slider(0, 1, 0.3, step=0.05, label="TP2 %"),
+            gr.Slider(1, 10, 3, label="B: Trades Min"),
 
-                gr.Slider(0.1, 5.0, 1.0, step=0.1, label="TP1 R"),
+            gr.Slider(1, 15, 7, label="B: Trades Max"),
 
-                gr.Slider(0.1, 20.0, 2.0, step=0.1, label="TP2 R"),
+            gr.Slider(1, 52, 12, label="B: Weeks"),
 
-                gr.Slider(0.001, 0.05, 0.01, step=0.001, label="Risk %"),
+            gr.Slider(0, 1, 0.3, step=0.05, label="B: TP1 %"),
 
-                gr.Slider(0, 100000, 0, step=500, label="Profit Target 💰"),
+            gr.Slider(0, 1, 0.3, step=0.05, label="B: TP2 %"),
 
-                gr.Slider(0, 1, 0.0, step=0.1, label="Fatigue Level"),
+            gr.Slider(0.1, 5.0, 1.0, step=0.1, label="B: TP1 R"),
 
-                gr.Slider(0, 1, 0.0, step=0.1, label="Trump Volatility Index")
+            gr.Slider(0.1, 20.0, 2.0, step=0.1, label="B: TP2 R"),
 
-            ],
+            gr.Slider(0.001, 0.05, 0.01, step=0.001, label="B: Risk %"),
 
-            outputs=["dataframe", "json", gr.Plot()],
+            gr.Slider(0, 100000, 0, step=500, label="B: Profit Target"),
 
-            title="🛠️ Manual Config"
+            gr.Slider(0, 1, 0.0, step=0.1, label="B: Fatigue"),
 
-        ),
+            gr.Slider(0, 1, 0.0, step=0.1, label="B: Trump Volatility")
 
+        ],
 
+        outputs=["dataframe", gr.Plot()],
 
+        title="🧪 Manual Strategy Battle"
 
-        # 🥊 Battle Mode – Preset
+    )
 
-        gr.Interface(
 
-            fn=battle_strategies,
 
-            inputs=[
 
-                gr.Dropdown(choices=["None"] + list(strategy_presets.keys()), value="None", label="Strategy 1"),
+# === LAUNCH INTERFACE ===
 
-                gr.Dropdown(choices=["None"] + list(strategy_presets.keys()), value="None", label="Strategy 2")
+app = gr.TabbedInterface(
 
-            ],
+    interface_list=[
 
-            outputs=["dataframe", gr.Plot()],
+        gr.Interface(fn=run_preset_strategy, inputs=[
 
-            title="🥊 Battle Mode"
+            gr.Dropdown(choices=list(strategy_presets.keys()), label="Select Strategy"),
 
-        ),
+            gr.Slider(0, 1, 0.0, step=0.1, label="Fatigue Level"),
 
+            gr.Slider(0, 1, 0.0, step=0.1, label="Trump Volatility Index")
 
+        ], outputs=["dataframe", "json", gr.Plot(), "text"], title="🎯 Preset Mode"),
 
 
-        # 🧪 Manual Battle Mode
 
-        gr.Interface(
 
-            fn=dual_manual_battle,
+        gr.Interface(fn=run_manual_sim, inputs=[
 
-            inputs=[
+            gr.Slider(100, 20000, 2500, label="Start Balance"),
 
-                gr.Textbox(label="Manual Config A (JSON format)"),
+            gr.Slider(1, 10, 3, label="Trades Min"),
 
-                gr.Textbox(label="Manual Config B (JSON format)")
+            gr.Slider(1, 15, 7, label="Trades Max"),
 
-            ],
+            gr.Slider(1, 52, 12, label="Weeks"),
 
-            outputs=["dataframe", gr.Plot()],
+            gr.Slider(0, 1, 0.3, step=0.05, label="TP1 %"),
 
-            title="🧪 Manual Battle Mode"
+            gr.Slider(0, 1, 0.3, step=0.05, label="TP2 %"),
 
-        ),
+            gr.Slider(0.1, 5.0, 1.0, step=0.1, label="TP1 R"),
 
+            gr.Slider(0.1, 20.0, 2.0, step=0.1, label="TP2 R"),
 
+            gr.Slider(0.001, 0.05, 0.01, step=0.001, label="Risk %"),
 
+            gr.Slider(0, 100000, 0, step=500, label="Profit Target 💰"),
 
-        # 📊 Analytics Leaderboard
+            gr.Slider(0, 1, 0.0, step=0.1, label="Fatigue Level"),
 
-        gr.Interface(
+            gr.Slider(0, 1, 0.0, step=0.1, label="Trump Volatility Index")
 
-            fn=analytics_dashboard,
+        ], outputs=["dataframe", "json", gr.Plot()], title="🛠️ Manual Config"),
 
-            inputs=gr.Dropdown(
 
-                choices=["EdgeCast Score", "Final Balance", "Sharpe Ratio", "Max Drawdown %"],
 
-                value="EdgeCast Score",
 
-                label="Sort leaderboard by:"
+        get_manual_battle_interface(),
 
-            ),
 
-            outputs="dataframe",
 
-            title="📊 Analytics Leaderboard"
 
-        ),
+        gr.Interface(fn=histogram_viewer_ui, inputs=gr.Dropdown(
 
+            choices=["Final Balance", "Sharpe Ratio", "EdgeCast Score", "Max Drawdown %"],
 
+            label="Select Metric"
 
+        ), outputs=gr.Plot(), title="📊 Histogram Viewer"),
 
-        # 📘 Strategy Descriptions
 
-        gr.Interface(
 
-            fn=show_descriptions,
 
-            inputs=[], outputs="dataframe",
+        gr.Interface(fn=analytics_dashboard, inputs=gr.Dropdown(
 
-            title="📘 Strategy Descriptions"
+            choices=["EdgeCast Score", "Final Balance", "Sharpe Ratio", "Max Drawdown %"],
 
-        ),
+            label="Sort leaderboard by:"
 
+        ), outputs="dataframe", title="🏅 Leaderboard"),
 
 
 
-        # 🔬 Risk Matrix Heatmap
 
-        gr.Interface(
+        gr.Interface(fn=show_descriptions, inputs=[], outputs="dataframe", title="📘 Descriptions"),
 
-            fn=generate_risk_matrix,
 
-            inputs=[], outputs=gr.Plot(),
 
-            title="🔬 Risk Matrix"
 
-        )
+        gr.Interface(fn=generate_risk_matrix, inputs=[], outputs=gr.Plot(), title="🔬 Risk Matrix")
 
     ],
 
-    tab_names=["Preset", "Manual", "Battle", "Manual Battle", "Analytics", "Descriptions", "Risk Matrix"],
-
     title="EdgeCast – Strategy Simulation Suite"
 
 )
@@ -821,3 +675,4 @@ app = gr.TabbedInterface(
 
 
 app.launch()
+