sk profile if deployed in a portfolio. 2. Broker-Agnostic Normalization: Lot size calculation queries SYMBOL_VOLUME_MIN, SYMBOL_VOLUME_MAX, and SYMBOL_VOLUME_STEP at runtime. Hardcoding these values causes INVALID_VOLUME errors when switching symbols or brokers. 3. Session Boundary Detection: Instead of floating-point day division, the system caches the current trading day using TimeDay(TimeCurrent()). This avoids edge-case failures during daylight saving transitions or server time shifts. 4. Execution Decoupling: The risk module computes volume and validates constraints, but delegates order placement to CTrade. This separation allows the same risk engine to wrap market orders, pending orders, or strategy signals without modification.

Implementation Code

//+------------------------------------------------------------------+
//|                                  CapitalGuardianEngine.mq5       |
//|                  Dynamic Risk & Circuit Breaker Module           |
//+------------------------------------------------------------------+
#property copyright "Codcompass Technical Division"
#property link      ""
#property version   "2.00"
#property strict

#include <Trade\Trade.mqh>

//--- Risk Configuration Inputs
input double   RiskFraction      = 0.01;    // Risk per trade (0.01 = 1%)
input int      StopDistancePts   = 450;     // Stop loss distance in points
input double   DailyLossLimit    = 0.04;    // Max daily drawdown (0.04 = 4%)
input ulong    ExecutionMagic    = 884102;  // Unique identifier for risk-managed orders

//--- Internal State Tracking
struct RiskState
{
   double   sessionStartEquity;
   int      cachedTradingDay;
   bool     isTradingHalted;
};

RiskState g_riskState;
CTrade    g_executor;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   g_executor.SetExpertMagicNumber(ExecutionMagic);
   g_executor.SetDeviationInPoints(30);
   g_executor.SetTypeFilling(ORDER_FILLING_FOK);
   
   g_riskState.sessionStartEquity = AccountInfoDouble(ACCOUNT_EQUITY);
   g_riskState.cachedTradingDay   = TimeDay(TimeCurrent());
   g_riskState.isTradingHalted    = false;
   
   PrintFormat("Risk Engine Initialized | Risk: %.2f%% | Daily Limit: %.2f%%", 
               RiskFraction * 100.0, DailyLossLimit * 100.0);
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   // 1. Detect session boundary and reset baseline
   int currentDay = TimeDay(TimeCurrent());
   if (currentDay != g_riskState.cachedTradingDay)
   {
      g_riskState.sessionStartEquity = AccountInfoDouble(ACCOUNT_EQUITY);
      g_riskState.cachedTradingDay   = currentDay;
      g_riskState.isTradingHalted    = false;
      Print("New trading session detected. Risk baseline reset.");
   }

   // 2. Evaluate daily drawdown threshold
   double currentEquity = AccountInfoDouble(ACCOUNT_EQUITY);
   double sessionDrawdown = (g_riskState.sessionStartEquity - currentEquity) / g_riskState.sessionStartEquity;
   
   if (sessionDrawdown >= DailyLossLimit)
   {
      if (!g_riskState.isTradingHalted)
      {
         g_riskState.isTradingHalted = true;
         PrintFormat("Circuit breaker triggered. Daily loss limit reached (%.2f%%). Execution suspended.", 
                     DailyLossLimit * 100.0);
      }
      return;
   }

   // 3. Calculate safe volume and execute (replace condition with your signal logic)
   if (PositionsTotal() == 0 && !g_riskState.isTradingHalted)
   {
      double safeVolume = ComputeProtectedVolume(StopDistancePts);
      if (safeVolume > 0.0)
      {
         double slPrice = SymbolInfoDouble(_Symbol, SYMBOL_ASK) - (StopDistancePts * _Point);
         if (g_executor.Buy(safeVolume, _Symbol, 0, slPrice, 0, "Risk-Protected Entry"))
         {
            PrintFormat("Order executed | Volume: %.2f | SL: %.5f", safeVolume, slPrice);
         }
      }
   }
}

//+------------------------------------------------------------------+
//| Compute position volume based on risk fraction & SL distance     |
//+------------------------------------------------------------------+
double ComputeProtectedVolume(int slPoints)
{
   if (slPoints <= 0) return 0.0;
   
   double accountBalance = AccountInfoDouble(ACCOUNT_BALANCE);
   double monetaryRisk   = accountBalance * RiskFraction;
   
   double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
   double tickSize  = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
   double pointSize = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   
   // Calculate monetary value of the stop loss distance
   double slMonetaryValue = (slPoints * pointSize / tickSize) * tickValue;
   if (slMonetaryValue <= 0.0) return 0.0;
   
   double rawVolume = monetaryRisk / slMonetaryValue;
   
   // Normalize against broker constraints
   double minVol = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   double maxVol = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
   double volStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
   
   double normalizedVol = MathFloor(rawVolume / volStep) * volStep;
   normalizedVol = MathMax(minVol, MathMin(maxVol, normalizedVol));
   
   return NormalizeDouble(normalizedVol, 2);
}

Why This Architecture Works

• Monetary Risk Calculation: The system converts percentage risk into a fixed monetary amount, then divides by the stop loss's monetary value. This ensures that a 1% risk on a volatile index results in a smaller position than a 1% risk on a low-volatility currency pair, maintaining consistent exposure across instruments.
• Broker Normalization Pipeline: Volume calculation explicitly queries SYMBOL_VOLUME_STEP and applies MathFloor rounding. This prevents INVALID_VOLUME rejections that occur when brokers require specific lot increments (e.g., 0.01 vs 0.10).
• Circuit Breaker State Machine: The isTradingHalted flag prevents repeated logging and unnecessary computations once the daily threshold is breached. The system only resumes when the session boundary resets the state, eliminating the need for manual intervention.

Pitfall Guide

Pitfall Name	Explanation	Production Fix
Ignoring Symbol Tick Value Variations	Forex pairs, indices, and metals have different tick values and contract sizes. Using a static multiplier causes volume miscalculations.	Always query SYMBOL_TRADE_TICK_VALUE and SYMBOL_TRADE_TICK_SIZE at runtime. Never hardcode pip-to-dollar conversions.
Hardcoding Lot Normalization Parameters	Brokers change volume steps, min/max lots, and margin requirements. Hardcoded values trigger INVALID_VOLUME errors during symbol switches.	Fetch SYMBOL_VOLUME_MIN, SYMBOL_VOLUME_MAX, and SYMBOL_VOLUME_STEP inside the volume calculation function. Apply MathFloor rounding against the step.
Mixing Balance vs Equity for Risk Calculations	Balance excludes floating P/L, while equity includes it. Using equity for risk sizing during drawdowns can artificially inflate position size.	Use ACCOUNT_BALANCE for risk fraction calculations. Reserve ACCOUNT_EQUITY exclusively for drawdown monitoring and circuit breaker thresholds.
Failing to Handle Zero or Negative SL Distances	Passing 0 or negative stop distances to the volume calculator causes division by zero or negative lot sizes.	Add explicit validation: if (slPoints <= 0) return 0.0;. Validate input parameters in OnInit() to fail fast during initialization.
Overlooking Swap & Commission Impact on Daily Drawdown	Swap charges and trading commissions accumulate silently, triggering false circuit breaker activations.	Adjust the daily loss threshold to account for expected swap/commission overhead, or subtract fixed costs from the drawdown calculation before evaluation.
Relying on OnTick for Time-Based Resets Without Caching	Checking TimeCurrent() against a static value on every tick causes unnecessary state resets and CPU overhead.	Cache the trading day in a global variable. Only re-evaluate when TimeDay(TimeCurrent()) differs from the cached value.
Not Accounting for Slippage in Stop Loss Execution	Market orders during high volatility may fill at prices worse than requested, effectively widening the stop loss and increasing risk.	Use ORDER_FILLING_FOK or ORDER_FILLING_IOC with explicit deviation limits. Monitor execution reports and adjust StopDistancePts dynamically during high-volatility sessions.

Production Bundle

Action Checklist

• Validate broker symbol specifications: Confirm tick value, volume step, and min/max lot constraints before deployment.
• Separate risk logic from signal generation: Wrap the risk engine as a reusable module that can be attached to multiple strategies.
• Implement session boundary caching: Use TimeDay() comparison to reset daily baselines without floating-point division.
• Add execution deviation limits: Configure SetDeviationInPoints() to prevent slippage-induced risk expansion.
• Monitor swap and commission overhead: Adjust daily drawdown thresholds to account for non-trading costs.
• Test across market regimes: Run Strategy Tester with tick data covering trending, ranging, and high-volatility periods.
• Log circuit breaker events: Ensure all halts and resets are recorded in the Experts tab for post-trade analysis.

Decision Matrix

Scenario	Recommended Approach	Why	Cost Impact
High Volatility Forex (e.g., GBP/JPY)	Tighter daily limit (2-3%) + wider SL distance	Prevents cascade liquidations during news spikes; wider SL reduces premature stop-outs	Higher swap costs, lower trade frequency
Low Capital Account (<$5k)	Strict volume normalization + 1% risk fraction	Prevents INVALID_VOLUME errors; ensures compounding scales safely	Minimal; relies on broker min lot constraints
Multi-Strategy Portfolio	Shared RiskState struct + unified circuit breaker	Prevents cross-strategy exposure accumulation; enforces portfolio-level drawdown limits	Requires architectural refactoring; higher initial dev time
Crypto/Indices Trading	Dynamic tick value querying + FOK execution	Handles non-standard contract sizes and 24/7 session boundaries	Slightly higher slippage tolerance needed

Configuration Template

//--- Risk Engine Configuration Block
input double   RiskFraction      = 0.01;    // 1% risk per trade
input int      StopDistancePts   = 400;     // 40 pips (5-digit)
input double   DailyLossLimit    = 0.03;    // 3% daily drawdown cap
input ulong    ExecutionMagic    = 992041;  // Unique magic number
input int      MaxSlippagePts    = 25;      // Allowed execution deviation

//--- Initialization Snippet (Place in OnInit)
g_executor.SetExpertMagicNumber(ExecutionMagic);
g_executor.SetDeviationInPoints(MaxSlippagePts);
g_executor.SetTypeFilling(ORDER_FILLING_FOK);

g_riskState.sessionStartEquity = AccountInfoDouble(ACCOUNT_EQUITY);
g_riskState.cachedTradingDay   = TimeDay(TimeCurrent());
g_riskState.isTradingHalted    = false;

Quick Start Guide

1. Create the module: Paste the implementation code into MetaEditor, compile with F7, and resolve any missing include directives.
2. Attach to a demo chart: Open MT5, navigate to the Strategy Tester or attach directly to a demo account chart. Select your target symbol.
3. Configure inputs: Adjust RiskFraction, StopDistancePts, and DailyLossLimit to match your risk tolerance. Leave ExecutionMagic unique to avoid order conflicts.
4. Run forward test: Enable the EA and monitor the Experts and Journal tabs. Verify that volume calculations align with your risk percentage and that the circuit breaker triggers correctly during simulated drawdowns.
5. Deploy to live: Once validated across multiple market conditions, switch to a live account with conservative parameters. Gradually scale risk exposure as the system demonstrates consistent capital preservation.