forex-scalping.com

Code: Select all

//@version=5
strategy("BOJ Risk Engine v3.0 - Institutional", overlay=true, calc_on_every_tick=true, initial_capital=100000)

// =========================================================================
// 1. INPUTS & DESK PARAMETERS
// =========================================================================
grp_anomaly = "1. Macro Anomaly & Cross-Asset"
lookback    = input.int(100, title="Volatility Baseline (Bars)", group=grp_anomaly)
zThreshold  = input.float(4.0, title="Primary Z-Score Trigger", group=grp_anomaly)
symCross    = input.symbol("OANDA:GBPJPY", title="Correlated JPY Cross", group=grp_anomaly, tooltip="Monitored in background. If both pairs spike, it's a confirmed BOJ event.")
crossThresh = input.float(2.5, title="Cross-Asset Z-Score Minimum", group=grp_anomaly)

grp_timer   = "2. Dynamic Cooldown & Reclaim"
maxCooldown = input.int(15, title="Initial Stand-Aside (Bars)", group=grp_timer)
dripThresh  = input.float(2.0, title="Drip Reset Z-Score", group=grp_timer, tooltip="If Z-score hits this during cooldown, timer resets (Headline Drip defense).")

grp_eom     = "3. Month-End & Session Tactics"
eomDayStart = input.int(26, title="Month-End Lockout Day", group=grp_eom, minval=1, maxval=31)
eomActive   = input.bool(true, title="Enable Month-End Filter", group=grp_eom)
asianSess   = input.session("0000-0900", title="BOJ Danger Zone (UTC)", group=grp_eom)

// =========================================================================
// 2. PRIMARY SYMBOL VOLATILITY (Z-SCORE)
// =========================================================================
trPrimary       = ta.tr
meanPrimary     = ta.sma(trPrimary, lookback)
stdDevPrimary   = ta.stdev(trPrimary, lookback)
zPrimary        = stdDevPrimary > 0 ? (trPrimary - meanPrimary) / stdDevPrimary : 0

// =========================================================================
// 3. CROSS-ASSET CORRELATION ENGINE
// =========================================================================
// Fetch the True Range of the secondary JPY cross in the background
trCross = request.security(symCross, timeframe.period, ta.tr)
meanCross = request.security(symCross, timeframe.period, ta.sma(ta.tr, lookback))
stdDevCross = request.security(symCross, timeframe.period, ta.stdev(ta.tr, lookback))
zCross = stdDevCross > 0 ? (trCross - meanCross) / stdDevCross : 0

// =========================================================================
// 4. THRESHOLD LOGIC & CONTEXT
// =========================================================================
inDangerZone    = time(timeframe.period, asianSess, "UTC")
isMonthEnd      = (dayofmonth >= eomDayStart) and eomActive

// Hyper-sensitivity during high-risk windows
activeZThresh   = (inDangerZone and isMonthEnd) ? (zThreshold * 0.75) : zThreshold

// MACRO EVENT TRIGGER: Main symbol spikes AND secondary symbol confirms it.
isMacroSpike    = (zPrimary > activeZThresh) and (zCross > crossThresh)

// =========================================================================
// 5. STATE MACHINE: DRIP-RESETS & RECLAIM STRUCTURE
// =========================================================================
var int cooldownCounter = 0

if isMacroSpike
    cooldownCounter := maxCooldown  // Initial Tape Bomb hits: Max Lockout
else if cooldownCounter > 0 and (zPrimary > dripThresh)
    cooldownCounter := maxCooldown  // Drip Headline hits: RESET timer to max
else if cooldownCounter > 0
    cooldownCounter -= 1            // Tape is quiet: Count down

inCooldown = cooldownCounter > 0

// STRUCTURAL RECLAIM: Is the current ATR back below the 50-period average ATR?
shortAtr = ta.atr(14)
baselineAtr = ta.sma(shortAtr, 50)
hasReclaimed = shortAtr < baselineAtr

// =========================================================================
// 6. DYNAMIC SIZING ENGINE (Outputs to your strategy)
// =========================================================================
float riskMultiplier = 1.0
string regimeState = "NORMAL"

if isMonthEnd
    riskMultiplier := 0.0
    regimeState := "MONTH-END LOCK"
else if inCooldown or isMacroSpike
    riskMultiplier := 0.0
    regimeState := "STAND-ASIDE TIMER"
else if not inCooldown and not hasReclaimed
    // Timer is done, but tape hasn't structurally compressed yet. Reduced size.
    riskMultiplier := 0.5 
    regimeState := "RECLAIM / HALF-SIZE"
else
    riskMultiplier := 1.0
    regimeState := "ARMED / FULL SIZE"

// =========================================================================
// 7. EXECUTION & KILL-SWITCH
// =========================================================================
if isMacroSpike
    strategy.close_all(comment="🚨 MACRO SHOCK: Z1=" + str.tostring(math.round(zPrimary,1)) + " Z2=" + str.tostring(math.round(zCross,1)))
    alert("CLOSE_ALL", alert.freq_once_per_bar_close)

// Visuals
bgcolor(isMacroSpike ? color.new(color.red, 70) : na, title="Macro Spike")
bgcolor(inCooldown and not isMacroSpike ? color.new(color.orange, 85) : na, title="Cooldown/Drip")
bgcolor(riskMultiplier == 0.5 and not inCooldown ? color.new(color.blue, 90) : na, title="Reclaim Structure")
bgcolor(isMonthEnd and riskMultiplier == 0 ? color.new(color.yellow, 90) : na, title="Month End")

// =========================================================================
// 8. INSTITUTIONAL HUD (HEADS UP DISPLAY)
// =========================================================================
var table hud = table.new(position.top_right, 2, 6, border_width=1, border_color=color.gray)
if barstate.islast
    table.cell(hud, 0, 0, "RISK DESK v3.0", text_color=color.white, bgcolor=color.black)
    table.cell(hud, 1, 0, "METRICS", text_color=color.white, bgcolor=color.black)
    
    // Z-Scores
    table.cell(hud, 0, 1, "Primary Z-Score", text_color=color.white, bgcolor=color.gray)
    table.cell(hud, 1, 1, str.tostring(math.round(zPrimary, 2)) + "σ", text_color=color.white, bgcolor=zPrimary > dripThresh ? color.orange : color.gray)
    
    table.cell(hud, 0, 2, "Cross-Asset Z-Score", text_color=color.white, bgcolor=color.gray)
    table.cell(hud, 1, 2, str.tostring(math.round(zCross, 2)) + "σ", text_color=color.white, bgcolor=zCross > crossThresh ? color.orange : color.gray)
    
    // Timer Status
    table.cell(hud, 0, 3, "Stand-Aside Timer", text_color=color.white, bgcolor=color.gray)
    table.cell(hud, 1, 3, inCooldown ? "WAIT " + str.tostring(cooldownCounter) + " BARS" : "CLEAR", text_color=color.white, bgcolor=inCooldown ? color.red : color.green)
    
    // Volatility Structure
    table.cell(hud, 0, 4, "Tape Structure", text_color=color.white, bgcolor=color.gray)
    table.cell(hud, 1, 4, hasReclaimed ? "COMPRESSED" : "EXPANDED", text_color=color.white, bgcolor=hasReclaimed ? color.green : color.orange)

    // Sizing Output
    color riskColor = riskMultiplier == 0 ? color.red : (riskMultiplier == 0.5 ? color.blue : color.green)
    table.cell(hud, 0, 5, "Trade Regime", text_color=color.white, bgcolor=color.gray)
    table.cell(hud, 1, 5, regimeState, text_color=color.white, bgcolor=riskColor)

// =========================================================================
// 9. EXAMPLE ENTRY LOGIC (Applying the Risk Multiplier)
// =========================================================================
// Standard moving average cross just for demonstration
emaFast = ta.ema(close, 9)
emaSlow = ta.ema(close, 21)
longCondition = ta.crossover(emaFast, emaSlow)
shortCondition = ta.crossunder(emaFast, emaSlow)

// Base position size is 2% of equity. We multiply this by the Risk Multiplier.
baseRiskPercentage = 2.0
adjustedRisk = baseRiskPercentage * riskMultiplier

// ONLY execute if riskMultiplier is greater than 0
if longCondition and riskMultiplier > 0
    strategy.entry("Long", strategy.long, qty=(strategy.equity * (adjustedRisk/100)) / close)

if shortCondition and riskMultiplier > 0
    strategy.entry("Short", strategy.short, qty=(strategy.equity * (adjustedRisk/100)) / close)

Code: Select all

using System;
using System.Linq;
using cAlgo.API;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class BOJMonthEndProtectorV1 : Robot
    {
        // =========================================================================
        // 1. INPUTS & SETTINGS
        // =========================================================================
        [Parameter("ATR Baseline Length", Group = "Intervention Protection", DefaultValue = 14)]
        public int AtrLength { get; set; }

        [Parameter("Spike Multiplier (ATR)", Group = "Intervention Protection", DefaultValue = 5.0, 
            DefaultValue = "Ejects all positions if a single candle's range exceeds this multiple of normal ATR.")]
        public double SpikeMultiplier { get; set; }

        [Parameter("Month-End Start Day", Group = "Intervention Protection", DefaultValue = 27, MinValue = 1, MaxValue = 31, 
            DefaultValue = "Blocks new entries on or after this day of the month.")]
        public int EomDayStart { get; set; }

        [Parameter("Fast EMA", Group = "Example Trading Logic", DefaultValue = 10)]
        public int FastMaPeriod { get; set; }

        [Parameter("Slow EMA", Group = "Example Trading Logic", DefaultValue = 20)]
        public int SlowMaPeriod { get; set; }
        
        [Parameter("Trade Volume (Units)", Group = "Example Trading Logic", DefaultValue = 1000)]
        public double TradeVolume { get; set; }

        // Core Indicators
        private AverageTrueRange _atr;
        private ExponentialMovingAverage _fastEma;
        private ExponentialMovingAverage _slowEma;
        
        private string _botLabel = "BOJ_Protector_V1";

        protected override void OnStart()
        {
            // Initialize indicators
            _atr = Indicators.AverageTrueRange(Bars, AtrLength, MovingAverageType.Simple);
            _fastEma = Indicators.ExponentialMovingAverage(Bars.ClosePrices, FastMaPeriod);
            _slowEma = Indicators.ExponentialMovingAverage(Bars.ClosePrices, SlowMaPeriod);
        }

        // =========================================================================
        // 2. DEFENSE LOGIC & KILL-SWITCH (Evaluated every single tick)
        // =========================================================================
        protected override void OnTick()
        {
            // Measure the current candle's total excursion in real-time
            double currentRange = Bars.HighPrices.Last(0) - Bars.LowPrices.Last(0);
            
            // CRITICAL: We use Last(1) for the ATR so the current exploding candle 
            // doesn't instantly skew our baseline measurement.
            double baselineAtr = _atr.Result.Last(1);

            // Triggers
            bool isInterventionSpike = currentRange > (baselineAtr * SpikeMultiplier);
            bool isMonthEndDanger = Server.Time.Day >= EomDayStart;

            // KILL SWITCH EXECUTION
            if (isInterventionSpike)
            {
                // Find all open positions for THIS symbol opened by THIS bot
                var openPositions = Positions.FindAll(_botLabel, SymbolName);
                
                foreach (var position in openPositions)
                {
                    ClosePosition(position);
                }
                Print("🚨 BOJ SPIKE DETECTED: EJECTING POSITIONS 🚨");
            }

            // HUD / On-Chart Visuals
            if (isInterventionSpike)
                Chart.DrawStaticText("status_hud", "🚨 SPIKE DETECTED - EJECTING ALL", VerticalAlignment.Top, HorizontalAlignment.Right, Color.Red);
            else if (isMonthEndDanger)
                Chart.DrawStaticText("status_hud", "⚠️ MONTH-END LOCKOUT ACTIVE", VerticalAlignment.Top, HorizontalAlignment.Right, Color.Yellow);
            else
                Chart.DrawStaticText("status_hud", "✅ ENGINE GREEN / ARMED", VerticalAlignment.Top, HorizontalAlignment.Right, Color.LimeGreen);
        }

        // =========================================================================
        // 3. EXAMPLE ENTRY LOGIC (Evaluated on Bar Close for stability)
        // =========================================================================
        protected override void OnBar()
        {
            // Recalculate states for the bar close
            double currentRange = Bars.HighPrices.Last(0) - Bars.LowPrices.Last(0);
            double baselineAtr = _atr.Result.Last(1);
            
            bool isInterventionSpike = currentRange > (baselineAtr * SpikeMultiplier);
            bool isMonthEndDanger = Server.Time.Day >= EomDayStart;

            // Global permission switch
            bool canTrade = !isMonthEndDanger && !isInterventionSpike;

            if (canTrade)
            {
                // Simple Moving Average Crossover Logic
                // We use Last(1) and Last(2) to ensure the cross actually completed on the closed bar
                bool longCondition = _fastEma.Result.Last(1) > _slowEma.Result.Last(1) && 
                                     _fastEma.Result.Last(2) <= _slowEma.Result.Last(2);
                                     
                bool shortCondition = _fastEma.Result.Last(1) < _slowEma.Result.Last(1) && 
                                      _fastEma.Result.Last(2) >= _slowEma.Result.Last(2);

                if (longCondition)
                {
                    ClosePositions(TradeType.Sell); // Close opposite trades
                    ExecuteMarketOrder(TradeType.Buy, SymbolName, TradeVolume, _botLabel, null, null);
                }
                else if (shortCondition)
                {
                    ClosePositions(TradeType.Buy); // Close opposite trades
                    ExecuteMarketOrder(TradeType.Sell, SymbolName, TradeVolume, _botLabel, null, null);
                }
            }
        }

        // Helper method to close opposite positions before opening a new one
        private void ClosePositions(TradeType tradeType)
        {
            var positionsToClose = Positions.FindAll(_botLabel, SymbolName).Where(p => p.TradeType == tradeType);
            foreach (var position in positionsToClose)
            {
                ClosePosition(position);
            }
        }
    }
}

Code: Select all

using System;
using System.Linq;
using cAlgo.API;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class BOJRiskEngineV2 : Robot
    {
        // =========================================================================
        // 1. INPUTS & RISK PARAMETERS
        // =========================================================================
        [Parameter("Rolling Window (Bars)", Group = "1. Anomaly Detection", DefaultValue = 100)]
        public int Lookback { get; set; }

        [Parameter("Z-Score Trigger (Sigma)", Group = "1. Anomaly Detection", DefaultValue = 4.5, 
            DefaultValue = "Fires if a candle's range is this many standard deviations above the mean.")]
        public double ZThreshold { get; set; }

        [Parameter("Cooldown Lockout (Bars)", Group = "2. The Stand-Aside Timer", DefaultValue = 12)]
        public int CooldownBars { get; set; }

        [Parameter("Month-End Start Day", Group = "3. Month-End Dynamics", DefaultValue = 26, MinValue = 1, MaxValue = 31)]
        public int EomDayStart { get; set; }

        [Parameter("Enable Month-End Filter", Group = "3. Month-End Dynamics", DefaultValue = true)]
        public bool EomActive { get; set; }

        [Parameter("Asian Session Start (UTC Hour)", Group = "4. Session Awareness", DefaultValue = 0)]
        public int AsianSessStart { get; set; }

        [Parameter("Asian Session End (UTC Hour)", Group = "4. Session Awareness", DefaultValue = 9)]
        public int AsianSessEnd { get; set; }

        [Parameter("Fast EMA", Group = "Example Strategy", DefaultValue = 9)]
        public int FastMaPeriod { get; set; }

        [Parameter("Slow EMA", Group = "Example Strategy", DefaultValue = 21)]
        public int SlowMaPeriod { get; set; }
        
        [Parameter("Trade Volume (Units)", Group = "Example Strategy", DefaultValue = 1000)]
        public double TradeVolume { get; set; }

        // =========================================================================
        // STATE VARIABLES
        // =========================================================================
        private double _baselineMean;
        private double _baselineStdDev;
        private int _cooldownBarsRemaining = 0;
        private string _botLabel = "BOJ_RiskEngine_V2";

        private ExponentialMovingAverage _fastEma;
        private ExponentialMovingAverage _slowEma;

        protected override void OnStart()
        {
            _fastEma = Indicators.ExponentialMovingAverage(Bars.ClosePrices, FastMaPeriod);
            _slowEma = Indicators.ExponentialMovingAverage(Bars.ClosePrices, SlowMaPeriod);
            
            // Calculate initial baseline on startup
            CalculateBaselineMath();
        }

        // =========================================================================
        // 2. TICK-BY-TICK EXECUTION & KILL-SWITCH
        // =========================================================================
        protected override void OnTick()
        {
            if (Bars.Count < Lookback + 2) return; // Wait for enough data

            // 1. Calculate live True Range of the current unclosed candle
            double currentHigh = Bars.HighPrices.Last(0);
            double currentLow = Bars.LowPrices.Last(0);
            double prevClose = Bars.ClosePrices.Last(1);
            
            double currentTR = Math.Max(currentHigh, prevClose) - Math.Min(currentLow, prevClose);

            // 2. Calculate live Z-Score against the static baseline
            double currentZScore = _baselineStdDev > 0 ? (currentTR - _baselineMean) / _baselineStdDev : 0;

            // 3. Contextual Awareness & Dynamic Thresholds
            TimeSpan timeOfDay = Server.TimeInUtc.TimeOfDay;
            bool inDangerZone = timeOfDay >= TimeSpan.FromHours(AsianSessStart) && timeOfDay <= TimeSpan.FromHours(AsianSessEnd);
            bool inMonthEndLockout = Server.TimeInUtc.Day >= EomDayStart && EomActive;

            // Hyper-sensitivity: Lower the Z-Score required to trigger if in Danger Zone AND Month End
            double activeTriggerLevel = (inDangerZone && inMonthEndLockout) ? (ZThreshold * 0.8) : ZThreshold;

            bool isInterventionSpike = currentZScore > activeTriggerLevel;
            bool inCooldown = _cooldownBarsRemaining > 0;

            // 4. EJECT MECHANISM
            if (isInterventionSpike)
            {
                CloseAllPositions();
                _cooldownBarsRemaining = CooldownBars; // Reset timer to max
            }

            // 5. UPDATE HUD (Heads-Up Display)
            UpdateHUD(currentZScore, activeTriggerLevel, isInterventionSpike, inCooldown, inMonthEndLockout);
        }

        // =========================================================================
        // 3. BAR CLOSE LOGIC (Timer Countdown & Entry Logic)
        // =========================================================================
        protected override void OnBar()
        {
            if (Bars.Count < Lookback + 2) return;

            // 1. Recalculate the baseline math for the next candle's ticks
            CalculateBaselineMath();

            // 2. State Machine: Countdown the stand-aside timer
            if (_cooldownBarsRemaining > 0)
            {
                _cooldownBarsRemaining--;
            }

            // 3. GLOBAL TRADE PERMISSION
            bool inMonthEndLockout = Server.TimeInUtc.Day >= EomDayStart && EomActive;
            bool engineGreenLight = _cooldownBarsRemaining == 0 && !inMonthEndLockout;

            // 4. EXAMPLE ENTRY LOGIC
            if (engineGreenLight)
            {
                bool longCondition = _fastEma.Result.Last(1) > _slowEma.Result.Last(1) && 
                                     _fastEma.Result.Last(2) <= _slowEma.Result.Last(2);
                                     
                bool shortCondition = _fastEma.Result.Last(1) < _slowEma.Result.Last(1) && 
                                      _fastEma.Result.Last(2) >= _slowEma.Result.Last(2);

                if (longCondition)
                {
                    ClosePositions(TradeType.Sell);
                    ExecuteMarketOrder(TradeType.Buy, SymbolName, TradeVolume, _botLabel);
                }
                else if (shortCondition)
                {
                    ClosePositions(TradeType.Buy);
                    ExecuteMarketOrder(TradeType.Sell, SymbolName, TradeVolume, _botLabel);
                }
            }
        }

        // =========================================================================
        // 4. MATHEMATICAL ENGINE & HELPERS
        // =========================================================================
        private void CalculateBaselineMath()
        {
            // Calculates the Mean and Standard Deviation of the True Range 
            // over the last N closed bars.
            double sumTR = 0;
            double[] trHistory = new double[Lookback];

            for (int i = 1; i <= Lookback; i++)
            {
                // i = 1 is the most recently closed bar
                double high = Bars.HighPrices.Last(i);
                double low = Bars.LowPrices.Last(i);
                double prevC = Bars.ClosePrices.Last(i + 1);

                double tr = Math.Max(high, prevC) - Math.Min(low, prevC);
                trHistory[i - 1] = tr;
                sumTR += tr;
            }

            _baselineMean = sumTR / Lookback;

            double sumVariance = 0;
            for (int i = 0; i < Lookback; i++)
            {
                sumVariance += Math.Pow(trHistory[i] - _baselineMean, 2);
            }

            _baselineStdDev = Math.Sqrt(sumVariance / Lookback);
        }

        private void CloseAllPositions()
        {
            var positionsToClose = Positions.FindAll(_botLabel, SymbolName);
            if (positionsToClose.Length > 0)
            {
                foreach (var position in positionsToClose)
                {
                    ClosePosition(position);
                }
                Print("🚨 BOJ SPIKE DETECTED: EJECTING POSITIONS 🚨");
            }
        }

        private void ClosePositions(TradeType tradeType)
        {
            var positionsToClose = Positions.FindAll(_botLabel, SymbolName).Where(p => p.TradeType == tradeType);
            foreach (var position in positionsToClose)
            {
                ClosePosition(position);
            }
        }

        private void UpdateHUD(double currentZScore, double triggerLevel, bool isSpike, bool inCooldown, bool inMonthEnd)
        {
            string status;
            Color hudColor;

            if (isSpike)
            {
                status = "🚨 EJECTING / TAPE BOMB";
                hudColor = Color.Red;
            }
            else if (inMonthEnd)
            {
                status = "⚠️ MONTH-END LOCKOUT";
                hudColor = Color.Yellow;
            }
            else if (inCooldown)
            {
                status = $"⏳ COOLDOWN ({_cooldownBarsRemaining} BARS LEFT)";
                hudColor = Color.DarkOrange;
            }
            else
            {
                status = "✅ SYSTEM ARMED (GREEN)";
                hudColor = Color.LimeGreen;
            }

            string hudText = $"=== RISK DESK v2.0 ===\n" +
                             $"Live Shock: {Math.Round(currentZScore, 2)}σ / {Math.Round(triggerLevel, 2)}σ\n" +
                             $"State: {status}";

            Chart.DrawStaticText("RiskHUD", hudText, VerticalAlignment.Top, HorizontalAlignment.Right, hudColor);
        }
    }
}

Code: Select all

using System;
using System.Linq;
using cAlgo.API;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class BOJRiskDesk_V3 : Robot
    {
        // =========================================================================
        // 1. INPUTS & DESK PARAMETERS
        // =========================================================================
        [Parameter("Volatility Baseline (Bars)", Group = "1. Macro Anomaly & Cross-Asset", DefaultValue = 100)]
        public int Lookback { get; set; }

        [Parameter("Primary Z-Score Trigger", Group = "1. Macro Anomaly & Cross-Asset", DefaultValue = 4.0)]
        public double ZThreshold { get; set; }

        [Parameter("Correlated JPY Cross", Group = "1. Macro Anomaly & Cross-Asset", DefaultValue = "GBPJPY")]
        public string SecondarySymbolName { get; set; }

        [Parameter("Cross-Asset Z-Score Min", Group = "1. Macro Anomaly & Cross-Asset", DefaultValue = 2.5)]
        public double CrossThreshold { get; set; }

        [Parameter("Initial Stand-Aside (Bars)", Group = "2. Dynamic Cooldown & Reclaim", DefaultValue = 15)]
        public int MaxCooldownBars { get; set; }

        [Parameter("Drip Reset Z-Score", Group = "2. Dynamic Cooldown & Reclaim", DefaultValue = 2.0, 
            DefaultValue = "Resets timer if secondary headlines drip during cooldown")]
        public double DripThreshold { get; set; }

        [Parameter("Month-End Lockout Day", Group = "3. Month-End & Session", DefaultValue = 26, MinValue = 1, MaxValue = 31)]
        public int EomDayStart { get; set; }

        [Parameter("Enable Month-End Filter", Group = "3. Month-End & Session", DefaultValue = true)]
        public bool EomActive { get; set; }

        [Parameter("Asian Session Start (UTC Hour)", Group = "3. Month-End & Session", DefaultValue = 0)]
        public int AsianSessStart { get; set; }

        [Parameter("Asian Session End (UTC Hour)", Group = "3. Month-End & Session", DefaultValue = 9)]
        public int AsianSessEnd { get; set; }

        [Parameter("Base Volume (Units)", Group = "4. Example Strategy", DefaultValue = 100000)]
        public double BaseVolume { get; set; }
        
        [Parameter("Fast EMA", Group = "4. Example Strategy", DefaultValue = 9)]
        public int FastMaPeriod { get; set; }

        [Parameter("Slow EMA", Group = "4. Example Strategy", DefaultValue = 21)]
        public int SlowMaPeriod { get; set; }

        // =========================================================================
        // STATE VARIABLES & COMPONENTS
        // =========================================================================
        private Bars _secondaryBars;
        private Symbol _secondarySymbol;

        private double _priMean, _priStdDev;
        private double _secMean, _secStdDev;
        
        private int _cooldownBarsRemaining = 0;
        private bool _hasReclaimed = true;
        private double _riskMultiplier = 1.0;
        private string _regimeState = "NORMAL";
        private string _botLabel = "RiskDesk_V3";

        // Indicators for Reclaim Structure & Entry Logic
        private AverageTrueRange _shortAtr;
        private SimpleMovingAverage _baselineAtr;
        private ExponentialMovingAverage _fastEma;
        private ExponentialMovingAverage _slowEma;

        protected override void OnStart()
        {
            // Initialize Background Cross-Asset Data
            _secondarySymbol = Symbols.GetSymbol(SecondarySymbolName);
            _secondaryBars = MarketData.GetBars(TimeFrame, SecondarySymbolName);

            // Initialize Reclaim Structure Indicators (ATR 14 vs 50 SMA of ATR)
            _shortAtr = Indicators.AverageTrueRange(Bars, 14, MovingAverageType.Simple);
            _baselineAtr = Indicators.SimpleMovingAverage(_shortAtr.Result, 50);

            // Entry Logic Indicators
            _fastEma = Indicators.ExponentialMovingAverage(Bars.ClosePrices, FastMaPeriod);
            _slowEma = Indicators.ExponentialMovingAverage(Bars.ClosePrices, SlowMaPeriod);

            CalculateBaselines();
        }

        // =========================================================================
        // 2. TICK-BY-TICK ALERTS & CROSS-ASSET MATH
        // =========================================================================
        protected override void OnTick()
        {
            if (Bars.Count < Lookback + 2 || _secondaryBars.Count < Lookback + 2) return;

            // --- 1. Primary Live Z-Score ---
            double priTR = GetLiveTrueRange(Bars);
            double priZScore = _priStdDev > 0 ? (priTR - _priMean) / _priStdDev : 0;

            // --- 2. Secondary Live Z-Score ---
            double secTR = GetLiveTrueRange(_secondaryBars);
            double secZScore = _secStdDev > 0 ? (secTR - _secMean) / _secStdDev : 0;

            // --- 3. Dynamic Context ---
            TimeSpan time = Server.TimeInUtc.TimeOfDay;
            bool inDangerZone = time >= TimeSpan.FromHours(AsianSessStart) && time <= TimeSpan.FromHours(AsianSessEnd);
            bool isMonthEnd = Server.TimeInUtc.Day >= EomDayStart && EomActive;

            double activePriThresh = (inDangerZone && isMonthEnd) ? (ZThreshold * 0.75) : ZThreshold;

            // --- 4. The Macro Trigger ---
            // Triggers ONLY if the main symbol AND the background symbol spike together.
            bool isMacroSpike = (priZScore > activePriThresh) && (secZScore > CrossThreshold);

            // --- 5. Eject & Drip Reset State Machine ---
            if (isMacroSpike)
            {
                CloseAllPositions(priZScore, secZScore);
                _cooldownBarsRemaining = MaxCooldownBars; // Tape bomb: Max Lockout
            }
            else if (_cooldownBarsRemaining > 0 && priZScore > DripThreshold)
            {
                _cooldownBarsRemaining = MaxCooldownBars; // Drip headline: Reset timer
            }

            // Update the HUD display continuously
            UpdateHUD(priZScore, secZScore, isMacroSpike);
        }

        // =========================================================================
        // 3. BAR CLOSE: RECLAIM STRUCTURE & SIZING
        // =========================================================================
        protected override void OnBar()
        {
            if (Bars.Count < Lookback + 50 || _secondaryBars.Count < Lookback + 2) return;

            // 1. Recalculate Heavy Math for the next candle
            CalculateBaselines();

            // 2. Decrement Cooldown Timer
            if (_cooldownBarsRemaining > 0) _cooldownBarsRemaining--;
            bool inCooldown = _cooldownBarsRemaining > 0;

            // 3. Evaluate Structural Reclaim
            // Is current 14-period ATR back below the 50-period average of the ATR?
            _hasReclaimed = _shortAtr.Result.Last(1) < _baselineAtr.Result.Last(1);
            bool isMonthEnd = Server.TimeInUtc.Day >= EomDayStart && EomActive;

            // 4. DYNAMIC RISK SIZING ENGINE
            if (isMonthEnd)
            {
                _riskMultiplier = 0.0;
                _regimeState = "MONTH-END LOCK";
            }
            else if (inCooldown)
            {
                _riskMultiplier = 0.0;
                _regimeState = "STAND-ASIDE TIMER";
            }
            else if (!inCooldown && !_hasReclaimed)
            {
                _riskMultiplier = 0.5; // Cooldown finished, but tape hasn't compressed
                _regimeState = "RECLAIM / HALF-SIZE";
            }
            else
            {
                _riskMultiplier = 1.0;
                _regimeState = "ARMED / FULL SIZE";
            }

            // 5. ENTRY EXECUTION (Using Risk Multiplier)
            if (_riskMultiplier > 0)
            {
                bool longCondition = _fastEma.Result.Last(1) > _slowEma.Result.Last(1) && 
                                     _fastEma.Result.Last(2) <= _slowEma.Result.Last(2);
                                     
                bool shortCondition = _fastEma.Result.Last(1) < _slowEma.Result.Last(1) && 
                                      _fastEma.Result.Last(2) >= _slowEma.Result.Last(2);

                // Calculate the final lot size based on multiplier and broker lot-steps
                double targetVolume = BaseVolume * _riskMultiplier;
                double normalizedVolume = Symbol.NormalizeVolumeInUnits(targetVolume, RoundingMode.Down);

                if (normalizedVolume >= Symbol.VolumeInUnitsMin)
                {
                    if (longCondition)
                    {
                        ClosePositions(TradeType.Sell);
                        ExecuteMarketOrder(TradeType.Buy, SymbolName, normalizedVolume, _botLabel);
                    }
                    else if (shortCondition)
                    {
                        ClosePositions(TradeType.Buy);
                        ExecuteMarketOrder(TradeType.Sell, SymbolName, normalizedVolume, _botLabel);
                    }
                }
            }
        }

        // =========================================================================
        // 4. MATH & HELPERS
        // =========================================================================
        private double GetLiveTrueRange(Bars bars)
        {
            double high = bars.HighPrices.Last(0);
            double low = bars.LowPrices.Last(0);
            double prevClose = bars.ClosePrices.Last(1);
            return Math.Max(high, prevClose) - Math.Min(low, prevClose);
        }

        private void CalculateBaselines()
        {
            // Primary Symbol Math
            double priSumTR = 0, secSumTR = 0;
            double[] priTrHist = new double[Lookback];
            double[] secTrHist = new double[Lookback];

            for (int i = 1; i <= Lookback; i++)
            {
                // Primary
                double pH = Bars.HighPrices.Last(i), pL = Bars.LowPrices.Last(i), pC = Bars.ClosePrices.Last(i + 1);
                double pTr = Math.Max(pH, pC) - Math.Min(pL, pC);
                priTrHist[i - 1] = pTr;
                priSumTR += pTr;

                // Secondary
                double sH = _secondaryBars.HighPrices.Last(i), sL = _secondaryBars.LowPrices.Last(i), sC = _secondaryBars.ClosePrices.Last(i + 1);
                double sTr = Math.Max(sH, sC) - Math.Min(sL, sC);
                secTrHist[i - 1] = sTr;
                secSumTR += sTr;
            }

            _priMean = priSumTR / Lookback;
            _secMean = secSumTR / Lookback;

            double priVarSum = 0, secVarSum = 0;
            for (int i = 0; i < Lookback; i++)
            {
                priVarSum += Math.Pow(priTrHist[i] - _priMean, 2);
                secVarSum += Math.Pow(secTrHist[i] - _secMean, 2);
            }

            _priStdDev = Math.Sqrt(priVarSum / Lookback);
            _secStdDev = Math.Sqrt(secVarSum / Lookback);
        }

        private void CloseAllPositions(double pZ, double sZ)
        {
            var positions = Positions.FindAll(_botLabel, SymbolName);
            foreach (var pos in positions) ClosePosition(pos);
            if (positions.Length > 0)
                Print($"🚨 MACRO SHOCK EJECT: Pri Z={Math.Round(pZ,1)} | Sec Z={Math.Round(sZ,1)}");
        }

        private void ClosePositions(TradeType tradeType)
        {
            var positions = Positions.FindAll(_botLabel, SymbolName).Where(p => p.TradeType == tradeType);
            foreach (var pos in positions) ClosePosition(pos);
        }

        private void UpdateHUD(double pZ, double sZ, bool isSpike)
        {
            Color stateColor = _riskMultiplier == 0 ? Color.Red : (_riskMultiplier == 0.5 ? Color.DeepSkyBlue : Color.LimeGreen);
            if (Server.TimeInUtc.Day >= EomDayStart && EomActive) stateColor = Color.Yellow;

            string hud = $"--- INSTITUTIONAL RISK DESK v3.0 ---\n" +
                         $"Primary Z-Score  : {Math.Round(pZ, 2)}σ\n" +
                         $"Cross Z-Score    : {Math.Round(sZ, 2)}σ\n" +
                         $"Timer Status     : {(_cooldownBarsRemaining > 0 ? "WAIT " + _cooldownBarsRemaining : "CLEAR")}\n" +
                         $"Tape Structure   : {(_hasReclaimed ? "COMPRESSED" : "EXPANDED")}\n" +
                         $"Trade Regime     : {_regimeState}";

            Chart.DrawStaticText("RiskHUD", hud, VerticalAlignment.Top, HorizontalAlignment.Right, stateColor);
        }
    }
}