forex-scalping.com

Code: Select all

//@version=5
strategy("Kelly + Cap + Circuit Breaker", overlay=true, initial_capital=10000, default_qty_type=strategy.cash)

// =========================================================================
// 1. BOOTSTRAP INPUTS 
// =========================================================================
i_initialWinRate = input.float(50.0, title="Bootstrap Win Rate (%)", minval=1.0, maxval=99.0, group="Kelly Parameters") / 100.0
i_initialRR      = input.float(2.0, title="Bootstrap Reward/Risk", minval=0.1, group="Kelly Parameters")
i_fraction       = input.float(0.5, title="Kelly Fraction (0.5 = Half Kelly)", minval=0.1, maxval=1.0, step=0.1, group="Kelly Parameters")
i_lookback       = input.int(100, title="Rolling Trade Window", minval=10, maxval=500, group="Kelly Parameters")

// =========================================================================
// 2. RISK MANAGEMENT INPUTS (Hard Cap & Circuit Breaker)
// =========================================================================
i_atrLen     = input.int(14, title="ATR Length for Stop", group="Risk Management")
i_atrMult    = input.float(1.5, title="ATR Multiplier for Stop Distance", group="Risk Management")
i_maxRisk    = input.float(5.0, title="Absolute Max Risk Cap (%)", minval=0.1, maxval=20.0, step=0.5, group="Risk Management") / 100.0
i_maxDailyDD = input.float(3.0, title="Max Daily Drawdown (%)", minval=0.5, maxval=10.0, step=0.5, group="Risk Management") / 100.0

// =========================================================================
// 3. DAILY DRAWDOWN CIRCUIT BREAKER LOGIC
// =========================================================================
var float startOfDayEquity = strategy.initial_capital
var bool  circuitBreakerTripped = false

// Detect the start of a new trading day (resets at 00:00 exchange time)
isNewDay = ta.change(time("D"))
if isNewDay
    startOfDayEquity := strategy.equity
    circuitBreakerTripped := false // Reset the breaker for the new day

// Calculate the current daily P&L percentage relative to the day's open
currentDailyDD = (strategy.equity - startOfDayEquity) / startOfDayEquity

// Trip the breaker if equity drops below the threshold
if currentDailyDD <= -i_maxDailyDD
    circuitBreakerTripped := true

// =========================================================================
// 4. DYNAMIC EDGE CALCULATION
// =========================================================================
var float dynWinRate = i_initialWinRate
var float dynRR      = i_initialRR

int totalTrades = strategy.closedtrades

if totalTrades > 0
    int wins = 0
    float grossProfit = 0.0
    float grossLoss = 0.0
    int winCount = 0
    int lossCount = 0

    int startIdx = math.max(0, totalTrades - i_lookback)
    int tradesToAnalyze = totalTrades - startIdx

    if tradesToAnalyze > 0
        for i = startIdx to totalTrades - 1
            float profit = strategy.closedtrades.profit(i)
            if profit > 0
                wins += 1
                grossProfit += profit
                winCount += 1
            else if profit < 0
                grossLoss += math.abs(profit)
                lossCount += 1

        dynWinRate := wins / tradesToAnalyze
        float avgWin = winCount > 0 ? grossProfit / winCount : 0.0
        float avgLoss = lossCount > 0 ? grossLoss / lossCount : 0.0
        dynRR := avgLoss > 0 ? avgWin / avgLoss : i_initialRR

// =========================================================================
// 5. THE KELLY MATH + HARD CAP
// =========================================================================
fullKelly       = dynWinRate - ((1.0 - dynWinRate) / dynRR)
fractionalKelly = math.max(0, fullKelly * i_fraction)
appliedRisk     = math.min(i_maxRisk, fractionalKelly)

riskAmount      = strategy.equity * appliedRisk
atr             = ta.atr(i_atrLen)
stopDist        = atr * i_atrMult

positionSize    = stopDist > 0 ? (riskAmount / stopDist) : 0

// =========================================================================
// 6. DUMMY ENTRY LOGIC
// =========================================================================
fastSma      = ta.sma(close, 10)
slowSma      = ta.sma(close, 20)
longTrigger  = ta.crossover(fastSma, slowSma)
shortTrigger = ta.crossunder(fastSma, slowSma)

// =========================================================================
// 7. EXECUTION (Blocked by Circuit Breaker)
// =========================================================================
// Added "and not circuitBreakerTripped" to the entry conditions
if longTrigger and strategy.opentrades == 0 and appliedRisk > 0 and not circuitBreakerTripped
    strategy.entry("Long", strategy.long, qty=positionSize)
    strategy.exit("Exit Long", "Long", stop=close - stopDist, limit=close + (stopDist * dynRR))

if shortTrigger and strategy.opentrades == 0 and appliedRisk > 0 and not circuitBreakerTripped
    strategy.entry("Short", strategy.short, qty=positionSize)
    strategy.exit("Exit Short", "Short", stop=close + stopDist, limit=close - (stopDist * dynRR))

// =========================================================================
// 8. DASHBOARD UI
// =========================================================================
var table infoTable = table.new(position.top_right, 2, 6, border_width=1, border_color=color.gray, frame_color=color.black, frame_width=1)
if barstate.islast
    table.cell(infoTable, 0, 0, "Rolling Win Rate", text_color=color.white, bgcolor=color.new(color.purple, 20))
    table.cell(infoTable, 1, 0, str.tostring(dynWinRate * 100, "#.##") + "%", text_color=color.white, bgcolor=color.new(color.purple, 20))
    
    table.cell(infoTable, 0, 1, "Rolling R/R", text_color=color.white, bgcolor=color.new(color.purple, 20))
    table.cell(infoTable, 1, 1, str.tostring(dynRR, "#.##"), text_color=color.white, bgcolor=color.new(color.purple, 20))
    
    table.cell(infoTable, 0, 2, "Fractional Kelly %", text_color=color.white, bgcolor=color.new(color.blue, 20))
    table.cell(infoTable, 1, 2, str.tostring(fractionalKelly * 100, "#.##") + "%", text_color=color.white, bgcolor=color.new(color.blue, 20))
    
    isCapped = fractionalKelly > i_maxRisk
    capColor = isCapped ? color.new(color.red, 0) : color.new(color.teal, 20)
    table.cell(infoTable, 0, 3, isCapped ? "RISK CAPPED AT MAX" : "Applied Risk", text_color=color.white, bgcolor=capColor)
    table.cell(infoTable, 1, 3, str.tostring(appliedRisk * 100, "#.##") + "%", text_color=color.white, bgcolor=capColor)
    
    // Circuit Breaker UI Logic
    ddColor = circuitBreakerTripped ? color.new(color.red, 0) : color.new(color.gray, 20)
    table.cell(infoTable, 0, 4, circuitBreakerTripped ? "CIRCUIT BREAKER ACTIVE" : "Daily Drawdown", text_color=color.white, bgcolor=ddColor)
    table.cell(infoTable, 1, 4, str.tostring(currentDailyDD * 100, "#.##") + "%", text_color=color.white, bgcolor=ddColor)

    table.cell(infoTable, 0, 5, "Current Risk ($)", text_color=color.white, bgcolor=color.new(color.gray, 20))
    table.cell(infoTable, 1, 5, "$" + str.tostring(riskAmount, "#.##"), text_color=color.white, bgcolor=color.new(color.gray, 20))

Code: Select all

//@version=5
// Native commission & slippage deduction added to strategy header for accurate Net Edge calculations
strategy("Inst. Kelly Algorithmic Engine", overlay=true, initial_capital=10000, default_qty_type=strategy.cash, commission_type=strategy.commission.percent, commission_value=0.03, slippage=2)

// =========================================================================
// 1. DYNAMIC EDGE INPUTS (Net Kelly Parameters)
// =========================================================================
i_initialWinRate = input.float(50.0, "Bootstrap Win Rate (%)", minval=1.0, maxval=99.0, group="Kelly Parameters") / 100.0
i_initialRR      = input.float(2.0, "Bootstrap Reward/Risk", minval=0.1, group="Kelly Parameters")
i_fraction       = input.float(0.5, "Kelly Fraction (0.5 = Half Kelly)", minval=0.1, maxval=1.0, step=0.1, group="Kelly Parameters")
i_lookback       = input.int(100, "Rolling Trade Window", minval=10, maxval=500, group="Kelly Parameters")

// =========================================================================
// 2. RISK & EXECUTION LIMITS (Institutional Controls)
// =========================================================================
i_atrLen       = input.int(14, "ATR Length for Stop", group="Risk Limits")
i_atrMult      = input.float(1.5, "ATR Multiplier (Stop Distance)", group="Risk Limits")
i_maxRisk      = input.float(5.0, "Absolute Max Risk per Trade (%)", maxval=20.0, step=0.5, group="Risk Limits") / 100.0
i_maxLeverage  = input.float(10.0, "Max Broker Leverage Constraint (x)", minval=1.0, step=1.0, group="Risk Limits", tooltip="Caps position quantity to prevent margin rejections.")

// =========================================================================
// 3. CIRCUIT BREAKERS & REGIME FILTERS
// =========================================================================
i_maxDailyDD = input.float(3.0, "Max Daily Drawdown (%)", minval=0.5, maxval=10.0, step=0.5, group="Circuit Breakers") / 100.0
i_hwmDD      = input.float(15.0, "Max Peak-to-Trough Drawdown (%)", minval=5.0, maxval=50.0, step=1.0, group="Circuit Breakers") / 100.0
i_minVol     = input.float(0.1, "Min Volatility Filter (ATR %)", step=0.1, group="Regime Filters", tooltip="Blocks trades if market is too choppy/flat.")
i_maxVol     = input.float(3.0, "Max Volatility Filter (ATR %)", step=0.1, group="Regime Filters", tooltip="Blocks trades during extreme news/flash crashes.")

// =========================================================================
// 4. CIRCUIT BREAKER LOGIC (Daily & Peak-to-Trough)
// =========================================================================
var float hwmEquity = strategy.initial_capital
var float startOfDayEquity = strategy.initial_capital
var bool  dailyBreakerTripped = false
var bool  hwmBreakerTripped = false

// Update High-Water Mark
hwmEquity := math.max(hwmEquity, strategy.equity)

// Detect New Day for Daily Breaker
isNewDay = ta.change(time("D"))
if isNewDay
    startOfDayEquity := strategy.equity
    dailyBreakerTripped := false 

// Check Drawdown Status
currentDailyDD = (strategy.equity - startOfDayEquity) / startOfDayEquity
currentHwmDD   = (strategy.equity - hwmEquity) / hwmEquity

if currentDailyDD <= -i_maxDailyDD
    dailyBreakerTripped := true
if currentHwmDD <= -i_hwmDD
    hwmBreakerTripped := true

bool systemHalted = dailyBreakerTripped or hwmBreakerTripped

// =========================================================================
// 5. VOLATILITY REGIME CHECK
// =========================================================================
atrVal   = ta.atr(i_atrLen)
atrPct   = (atrVal / close) * 100
bool isVolatileEnough = atrPct >= i_minVol and atrPct <= i_maxVol

// =========================================================================
// 6. DYNAMIC NET EDGE CALCULATION (The Rolling Window)
// =========================================================================
var float dynWinRate = i_initialWinRate
var float dynRR      = i_initialRR
int totalTrades      = strategy.closedtrades

if totalTrades > 0
    int wins = 0
    float netProfit = 0.0
    float netLoss = 0.0
    int winCount = 0
    int lossCount = 0

    int startIdx = math.max(0, totalTrades - i_lookback)
    int tradesToAnalyze = totalTrades - startIdx

    if tradesToAnalyze > 0
        for i = startIdx to totalTrades - 1
            // This profit figure natively includes the slippage and commission defined in the strategy header
            float tradeProfit = strategy.closedtrades.profit(i)
            if tradeProfit > 0
                wins += 1
                netProfit += tradeProfit
                winCount += 1
            else if tradeProfit < 0
                netLoss += math.abs(tradeProfit)
                lossCount += 1

        dynWinRate := wins / tradesToAnalyze
        float avgWin = winCount > 0 ? netProfit / winCount : 0.0
        float avgLoss = lossCount > 0 ? netLoss / lossCount : 0.0
        dynRR := avgLoss > 0 ? avgWin / avgLoss : i_initialRR

// =========================================================================
// 7. MULTI-FACTOR POSITION SIZING MATH
// =========================================================================
// Calculate Edge Risk
fullKelly       = dynWinRate - ((1.0 - dynWinRate) / dynRR)
fractionalKelly = math.max(0, fullKelly * i_fraction)
appliedRisk     = math.min(i_maxRisk, fractionalKelly)

// Calculate Theoretical Quantity
riskAmount      = strategy.equity * appliedRisk
stopDist        = atrVal * i_atrMult
theoreticalQty  = stopDist > 0 ? (riskAmount / stopDist) : 0

// Apply Margin/Leverage Constraint Override
maxAllowedQty   = (strategy.equity * i_maxLeverage) / close
bool isMarginCapped = theoreticalQty > maxAllowedQty
finalQty        = math.min(theoreticalQty, maxAllowedQty)

// =========================================================================
// 8. DUMMY ENTRY LOGIC (Replace with your trigger)
// =========================================================================
longTrigger  = ta.crossover(ta.sma(close, 10), ta.sma(close, 20))
shortTrigger = ta.crossunder(ta.sma(close, 10), ta.sma(close, 20))

bool canTrade = not systemHalted and isVolatileEnough and appliedRisk > 0

// =========================================================================
// 9. EXECUTION
// =========================================================================
if longTrigger and strategy.opentrades == 0 and canTrade
    strategy.entry("Long", strategy.long, qty=finalQty)
    strategy.exit("Exit Long", "Long", stop=close - stopDist, limit=close + (stopDist * dynRR))

if shortTrigger and strategy.opentrades == 0 and canTrade
    strategy.entry("Short", strategy.short, qty=finalQty)
    strategy.exit("Exit Short", "Short", stop=close + stopDist, limit=close - (stopDist * dynRR))

// =========================================================================
// 10. INSTITUTIONAL DASHBOARD UI
// =========================================================================
var table t = table.new(position.top_right, 2, 7, border_width=1, border_color=color.gray, frame_color=color.black, frame_width=1)
if barstate.islast
    // System Status
    sysColor = hwmBreakerTripped ? color.red : dailyBreakerTripped ? color.orange : color.green
    sysText  = hwmBreakerTripped ? "HWM KILL SWITCH ACTIVE" : dailyBreakerTripped ? "DAILY BREAKER ACTIVE" : "SYSTEM ONLINE"
    table.cell(t, 0, 0, "Engine Status", text_color=color.white, bgcolor=sysColor)
    table.cell(t, 1, 0, sysText, text_color=color.white, bgcolor=sysColor)
    
    // Net Rolling Edge
    table.cell(t, 0, 1, "Net Rolling Win Rate", text_color=color.white, bgcolor=color.new(color.purple, 20))
    table.cell(t, 1, 1, str.tostring(dynWinRate * 100, "#.##") + "%", text_color=color.white, bgcolor=color.new(color.purple, 20))
    
    table.cell(t, 0, 2, "Net Rolling R/R", text_color=color.white, bgcolor=color.new(color.purple, 20))
    table.cell(t, 1, 2, str.tostring(dynRR, "#.##"), text_color=color.white, bgcolor=color.new(color.purple, 20))
    
    // Risk Metrics
    riskColor = (fractionalKelly > i_maxRisk) ? color.new(color.red, 0) : color.new(color.teal, 20)
    table.cell(t, 0, 3, "Target vs Max Risk", text_color=color.white, bgcolor=riskColor)
    table.cell(t, 1, 3, str.tostring(fractionalKelly*100, "#.##") + "% -> " + str.tostring(appliedRisk*100, "#.##") + "%", text_color=color.white, bgcolor=riskColor)
    
    // Margin Utilization
    marginColor = isMarginCapped ? color.new(color.orange, 0) : color.new(color.gray, 20)
    table.cell(t, 0, 4, isMarginCapped ? "MARGIN REJECTION CAPPED" : "Leverage Constraint", text_color=color.white, bgcolor=marginColor)
    table.cell(t, 1, 4, isMarginCapped ? "Capped to " + str.tostring(i_maxLeverage) + "x" : "Clear", text_color=color.white, bgcolor=marginColor)
    
    // Regime Filter
    volColor = isVolatileEnough ? color.new(color.gray, 20) : color.new(color.orange, 0)
    table.cell(t, 0, 5, isVolatileEnough ? "Volatility Filter" : "MARKET REGIME FILTERED", text_color=color.white, bgcolor=volColor)
    table.cell(t, 1, 5, str.tostring(atrPct, "#.##") + "%", text_color=color.white, bgcolor=volColor)

    // Capital
    table.cell(t, 0, 6, "Peak-to-Trough DD", text_color=color.white, bgcolor=color.new(color.gray, 20))
    table.cell(t, 1, 6, str.tostring(currentHwmDD * 100, "#.##") + "%", text_color=color.white, bgcolor=color.new(color.gray, 20))

Code: Select all

// =========================================================================
// 9. EXECUTION (With 50% Scale-Out)
// =========================================================================
if longTrigger and strategy.opentrades == 0 and canTrade
    strategy.entry("Long", strategy.long, qty=finalQty)
    
    // Calculate precise price levels
    float stopLevel = close - stopDist
    float tp1Level  = close + stopDist                // 1:1 Reward/Risk
    float tp2Level  = close + (stopDist * dynRR)      // Dynamic Target
    
    // Exit 1: Dump 50% of the position at 1:1 R/R
    strategy.exit("TP1 Long", "Long", qty=finalQty * 0.5, stop=stopLevel, limit=tp1Level)
    
    // Exit 2: Let the remaining balance run to the dynamic target
    // Omitting the 'qty' parameter here forces it to close 100% of whatever is left
    strategy.exit("TP2 Long", "Long", stop=stopLevel, limit=tp2Level)

if shortTrigger and strategy.opentrades == 0 and canTrade
    strategy.entry("Short", strategy.short, qty=finalQty)
    
    // Calculate precise price levels
    float stopLevel = close + stopDist
    float tp1Level  = close - stopDist                // 1:1 Reward/Risk
    float tp2Level  = close - (stopDist * dynRR)      // Dynamic Target
    
    // Exit 1: Dump 50% of the position at 1:1 R/R
    strategy.exit("TP1 Short", "Short", qty=finalQty * 0.5, stop=stopLevel, limit=tp1Level)
    
    // Exit 2: Let the remaining balance run to the dynamic target
    strategy.exit("TP2 Short", "Short", stop=stopLevel, limit=tp2Level)

Code: Select all

// =========================================================================
// 9. EXECUTION & DYNAMIC TRADE MANAGEMENT
// =========================================================================
// State tracking variables stored in memory across bars
var float entryPrice = na
var float stopLevel  = na
var float tp2Level   = na
var bool  tp1Hit     = false

// --- ENTRY LOGIC ---
if longTrigger and strategy.opentrades == 0 and canTrade
    strategy.entry("Long", strategy.long, qty=finalQty)
    
    // Lock in the levels at the moment of execution
    entryPrice := close
    stopLevel  := close - stopDist
    float tp1Level = close + stopDist
    tp2Level   := close + (stopDist * dynRR)
    tp1Hit     := false
    
    // Issue the initial dual-exit orders
    strategy.exit("TP1 Long", "Long", qty=finalQty * 0.5, stop=stopLevel, limit=tp1Level)
    strategy.exit("TP2 Long", "Long", stop=stopLevel, limit=tp2Level)

if shortTrigger and strategy.opentrades == 0 and canTrade
    strategy.entry("Short", strategy.short, qty=finalQty)
    
    entryPrice := close
    stopLevel  := close + stopDist
    float tp1Level = close - stopDist
    tp2Level   := close - (stopDist * dynRR)
    tp1Hit     := false
    
    strategy.exit("TP1 Short", "Short", qty=finalQty * 0.5, stop=stopLevel, limit=tp1Level)
    strategy.exit("TP2 Short", "Short", stop=stopLevel, limit=tp2Level)

// --- BREAK-EVEN MANAGEMENT ---
// If our current position size is smaller than the previous bar's size (and > 0), 
// it confirms our TP1 partial limit order was successfully filled by the exchange engine.

// Long BE Trigger
if strategy.position_size > 0 and strategy.position_size < strategy.position_size[1]
    if not tp1Hit
        tp1Hit := true
        stopLevel := entryPrice // Move the variable to Break-Even
        
        // Re-issue the order with the identical ID to override the previous stop
        strategy.exit("TP2 Long", "Long", stop=stopLevel, limit=tp2Level)

// Short BE Trigger (Short sizes are negative, so we check if it became *greater*)
if strategy.position_size < 0 and strategy.position_size > strategy.position_size[1]
    if not tp1Hit
        tp1Hit := true
        stopLevel := entryPrice // Move the variable to Break-Even
        
        strategy.exit("TP2 Short", "Short", stop=stopLevel, limit=tp2Level)
        
// Reset the state machine when the trade fully closes
if strategy.position_size == 0
    tp1Hit := false

Code: Select all

//+------------------------------------------------------------------+
//|                                     Inst_Kelly_Engine_Scalper.mq5|
//+------------------------------------------------------------------+
#property strict
#include <Trade\Trade.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\SymbolInfo.mqh>

CTrade         trade;
CPositionInfo  position;
CSymbolInfo    symbolInfo;

// =========================================================================
// 1. INPUT PARAMETERS (Matching Pine Script)
// =========================================================================
sinput string  grp1 = "--- Dynamic Edge (Kelly) ---";
input double   InpBootstrapWinRate = 50.0;    // Bootstrap Win Rate (%)
input double   InpBootstrapRR      = 2.0;     // Bootstrap Reward/Risk
input double   InpKellyFraction    = 0.5;     // Kelly Fraction (0.5 = Half)
input int      InpLookback         = 100;     // Rolling Trade Window

sinput string  grp2 = "--- Risk & Execution Limits ---";
input int      InpAtrPeriod        = 14;      // ATR Period
input double   InpAtrMultiplier    = 1.5;     // ATR Stop Multiplier
input double   InpMaxRisk          = 5.0;     // Max Risk per Trade (%)
input double   InpMaxLeverage      = 10.0;    // Max Leverage (Margin Cap)

sinput string  grp3 = "--- Circuit Breakers ---";
input double   InpMaxDailyDD       = 3.0;     // Max Daily Drawdown (%)
input double   InpHwmDD            = 15.0;    // Max Peak-to-Trough DD (%)

// =========================================================================
// 2. GLOBAL STATE VARIABLES
// =========================================================================
int            atrHandle, smaFastHandle, smaSlowHandle;
double         hwmEquity;
double         startOfDayEquity;
int            currentDay;
bool           systemHalted = false;

// Trade Management State
bool           tp1Hit = false;
double         initialVolume = 0.0;
double         entryPrice = 0.0;
double         tp1Level = 0.0;

// =========================================================================
// INITIALIZATION
// =========================================================================
int OnInit()
{
    symbolInfo.Name(_Symbol);
    trade.SetExpertMagicNumber(1337);
    
    atrHandle = iATR(_Symbol, PERIOD_CURRENT, InpAtrPeriod);
    smaFastHandle = iMA(_Symbol, PERIOD_CURRENT, 10, 0, MODE_SMA, PRICE_CLOSE);
    smaSlowHandle = iMA(_Symbol, PERIOD_CURRENT, 20, 0, MODE_SMA, PRICE_CLOSE);
    
    hwmEquity = AccountInfoDouble(ACCOUNT_EQUITY);
    startOfDayEquity = hwmEquity;
    currentDay = TimeDay(TimeCurrent());
    
    return(INIT_SUCCEEDED);
}

// =========================================================================
// CORE EVENT LOOP
// =========================================================================
void OnTick()
{
    if(!symbolInfo.RefreshRates()) return;

    // 1. Update Circuit Breakers & High-Water Mark
    CheckCircuitBreakers();
    if(systemHalted) return;

    // 2. Dynamic Trade Management (Scale-out & Break-even)
    ManageOpenPositions();

    // 3. Entry Logic (Only if no open positions)
    if(PositionsTotal() == 0)
    {
        // Reset state
        tp1Hit = false; 
        initialVolume = 0;

        double fastSMA[], slowSMA[], atrArr[];
        CopyBuffer(smaFastHandle, 0, 0, 2, fastSMA);
        CopyBuffer(smaSlowHandle, 0, 0, 2, slowSMA);
        CopyBuffer(atrHandle, 0, 0, 1, atrArr);
        
        bool longTrigger = (fastSMA[1] <= slowSMA[1] && fastSMA[0] > slowSMA[0]);
        bool shortTrigger = (fastSMA[1] >= slowSMA[1] && fastSMA[0] < slowSMA[0]);

        if(longTrigger || shortTrigger)
        {
            double stopDist = atrArr[0] * InpAtrMultiplier;
            double lotSize = CalculatePositionSize(stopDist);
            
            if(lotSize > 0)
            {
                if(longTrigger) ExecuteTrade(ORDER_TYPE_BUY, lotSize, stopDist);
                if(shortTrigger) ExecuteTrade(ORDER_TYPE_SELL, lotSize, stopDist);
            }
        }
    }
}

// =========================================================================
// DYNAMIC KELLY & LOT SIZING
// =========================================================================
double CalculatePositionSize(double stopDistancePoints)
{
    double dynWinRate = InpBootstrapWinRate / 100.0;
    double dynRR = InpBootstrapRR;
    
    // Parse History for Net Edge Calculation
    HistorySelect(0, TimeCurrent());
    int totalDeals = HistoryDealsTotal();
    int analyzed = 0, wins = 0, losses = 0;
    double grossProfit = 0, grossLoss = 0;
    
    for(int i = totalDeals - 1; i >= 0 && analyzed < InpLookback; i--)
    {
        ulong ticket = HistoryDealGetTicket(i);
        if(HistoryDealGetInteger(ticket, DEAL_ENTRY) == DEAL_ENTRY_OUT)
        {
            double profit = HistoryDealGetDouble(ticket, DEAL_PROFIT) + 
                            HistoryDealGetDouble(ticket, DEAL_COMMISSION) + 
                            HistoryDealGetDouble(ticket, DEAL_SWAP); // Net Profit
            
            if(profit > 0) { wins++; grossProfit += profit; }
            else if(profit < 0) { losses++; grossLoss += MathAbs(profit); }
            analyzed++;
        }
    }
    
    if(analyzed > 0)
    {
        dynWinRate = (double)wins / analyzed;
        double avgWin = (wins > 0) ? grossProfit / wins : 0;
        double avgLoss = (losses > 0) ? grossLoss / losses : 0;
        if(avgLoss > 0) dynRR = avgWin / avgLoss;
    }
    
    // Kelly Math
    double fullKelly = dynWinRate - ((1.0 - dynWinRate) / dynRR);
    double fracKelly = MathMax(0.0, fullKelly * InpKellyFraction);
    double appliedRisk = MathMin(InpMaxRisk / 100.0, fracKelly);
    
    if(appliedRisk <= 0) return 0.0;

    // Convert Risk $ to Lot Size
    double riskAmount = AccountInfoDouble(ACCOUNT_EQUITY) * appliedRisk;
    double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
    double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
    
    if(tickValue == 0 || tickSize == 0) return 0.0;
    
    double pointsLoss = stopDistancePoints / tickSize;
    double calcLots = riskAmount / (pointsLoss * tickValue);
    
    // Normalize and apply constraints
    double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
    double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
    double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
    
    calcLots = MathFloor(calcLots / lotStep) * lotStep;
    calcLots = MathMax(minLot, MathMin(maxLot, calcLots));
    
    return calcLots;
}

// =========================================================================
// EXECUTION & DYNAMIC MANAGEMENT
// =========================================================================
void ExecuteTrade(ENUM_ORDER_TYPE type, double volume, double stopDist)
{
    double price = (type == ORDER_TYPE_BUY) ? symbolInfo.Ask() : symbolInfo.Bid();
    double sl = (type == ORDER_TYPE_BUY) ? price - stopDist : price + stopDist;
    
    if(trade.PositionOpen(_Symbol, type, volume, price, sl, 0))
    {
        entryPrice = price;
        initialVolume = volume;
        tp1Level = (type == ORDER_TYPE_BUY) ? price + stopDist : price - stopDist;
        tp1Hit = false;
    }
}

void ManageOpenPositions()
{
    if(PositionsTotal() > 0 && position.Select(_Symbol))
    {
        if(!tp1Hit)
        {
            double currentPrice = (position.PositionType() == POSITION_TYPE_BUY) ? symbolInfo.Bid() : symbolInfo.Ask();
            bool hitTarget = (position.PositionType() == POSITION_TYPE_BUY) ? (currentPrice >= tp1Level) : (currentPrice <= tp1Level);
            
            if(hitTarget)
            {
                // 1. Close 50%
                double partialVol = NormalizeDouble(position.Volume() / 2.0, 2);
                double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
                if(partialVol >= minLot)
                {
                    trade.PositionClosePartial(_Symbol, partialVol);
                }
                
                // 2. Move Stop to Break-Even (Entry Price)
                trade.PositionModify(_Symbol, entryPrice, 0);
                tp1Hit = true;
            }
        }
    }
}

// =========================================================================
// CIRCUIT BREAKER UTILITY
// =========================================================================
void CheckCircuitBreakers()
{
    double equity = AccountInfoDouble(ACCOUNT_EQUITY);
    hwmEquity = MathMax(hwmEquity, equity);
    
    int today = TimeDay(TimeCurrent());
    if(today != currentDay)
    {
        startOfDayEquity = equity;
        currentDay = today;
        systemHalted = false; // Reset daily
    }
    
    double dailyDD = (equity - startOfDayEquity) / startOfDayEquity;
    double peakDD = (equity - hwmEquity) / hwmEquity;
    
    if(dailyDD <= -(InpMaxDailyDD / 100.0) || peakDD <= -(InpHwmDD / 100.0))
    {
        systemHalted = true;
        if(PositionsTotal() > 0) trade.PositionClose(_Symbol); // Liquidate
    }
}