//+------------------------------------------------------------------+
//|                                                      LiveEA.mq5 |
//|                    DualEA Live Trading Expert - Reconstructed   |
//+------------------------------------------------------------------+
#property copyright "DualEA"
#property version   "2.0"
#property strict

//+------------------------------------------------------------------+
//| INCLUDES                                                         |
//+------------------------------------------------------------------+
// New Architecture: Auto-learning gate system (unified with PaperEA)
#include "..\Include\GateSystemAutoLearning.mqh"

#include "..\Include\IStrategy.mqh"
#include "..\Include\CPositionManager.mqh"
#include "..\Include\TradeManager.mqh"
#include "..\Include\Telemetry.mqh"
#include "..\Include\TelemetryStandard.mqh"
#include "..\Include\SessionManager.mqh"
#include "..\Include\CorrelationManager.mqh"
#include "..\Include\VolatilitySizer.mqh"
#include "..\Include\InsightsLoader.mqh"
#include "..\Include\IncrementalInsightEngine.mqh"   // Real-time O(1) statistics engine
#include "LiveEA_StrategyBridge.mqh"

// Undefine logging macros from included headers to avoid clashes with LogLevel enum
#ifdef LOG_DEBUG
 #undef LOG_DEBUG
#endif
#ifdef LOG_INFO
 #undef LOG_INFO
#endif
#ifdef LOG_WARNING
 #undef LOG_WARNING
#endif
#ifdef LOG_ERROR
 #undef LOG_ERROR
#endif

//+------------------------------------------------------------------+
//| ENUMS AND CONSTANTS                                              |
//+------------------------------------------------------------------+
enum LogLevel { LOG_ERROR=0, LOG_WARN=1, LOG_INFO=2, LOG_DEBUG=3 };

//+------------------------------------------------------------------+
//| INPUT PARAMETERS - CORE SETTINGS                                |
//+------------------------------------------------------------------+
input long  MagicNumber           = 123456;
input int   Verbosity             = 1;        // 0=errors,1=warn,2=info,3=debug
input bool  TelemetryEnabled      = false;    // enable telemetry emission
input bool  NoConstraintsMode     = false;    // shadow-gate only, do not block
//+------------------------------------------------------------------+
//| INPUT PARAMETERS - TELEMETRY                                    |
//+------------------------------------------------------------------+
input string TelemetryExperiment  = "live";
input int    TelemetryBufferMax   = 1000;

//+------------------------------------------------------------------+
//| INPUT PARAMETERS - RISK MANAGEMENT                              |
//+------------------------------------------------------------------+
input double SpreadMaxPoints      = 0.0;   // 0=disabled
input int    SessionStartHour     = 0;     // 0..23
input int    SessionMaxTrades     = 0;     // 0=disabled
input double MaxDailyLossPct      = 0.0;   // 0=disabled
input double MaxDrawdownPct       = 0.0;   // 0=disabled
input double MinMarginLevel       = 0.0;   // 0=disabled, e.g. 100.0
input int    ConsecutiveLossLimit = 0;     // 0=disabled
input bool   P5_PersistLossCounters = false; // persist counters (minimal in-memory here)

//+------------------------------------------------------------------+
//| INPUT PARAMETERS - INSIGHTS GATING                              |
//+------------------------------------------------------------------+
input bool   UseInsightsGating    = true;
input int    GateMinTrades        = 0;        // loosened for bootstrap
input double GateMinWinRate       = 0.00;     // loosened for bootstrap
input double GateMinExpectancyR   = -10.0;    // loosened for bootstrap
input double GateMaxDrawdownR     = 1000000.0;// loosened for bootstrap
input double GateMinProfitFactor  = 0.00;     // loosened for bootstrap

//+------------------------------------------------------------------+
//| INPUT PARAMETERS - EXPLORATION MODE                             |
//+------------------------------------------------------------------+
input bool   ExploreOnNoSlice     = true;    // allow limited trades when slice has no data
input int    ExploreMaxPerSlice   = 100;     // loosened for bootstrap
input int    ExploreMaxPerSlicePerDay = 100; // loosened for bootstrap

//+------------------------------------------------------------------+
//| INPUT PARAMETERS - POLICY GATING                                |
//+------------------------------------------------------------------+
input bool   UsePolicyGating       = true;
input bool   DefaultPolicyFallback = true;   // allow neutral trading when policy slice is missing
input bool   FallbackDemoOnly      = true;   // restrict fallback to demo accounts
input bool   FallbackWhenNoPolicy  = true;   // allow fallback when policy file is not loaded

//+------------------------------------------------------------------+
//| INPUT PARAMETERS - CORRELATION MANAGEMENT                       |
//+------------------------------------------------------------------+
input double P5_CorrMax           = 1.0;   // 1.0=no pruning by default
input int    P5_CorrLookbackDays  = 5;     // used if PositionManager is not available
input bool   UsePositionManager    = false; // optional PositionManager usage

// News / Promotion / Regime / Cooldown inputs
input bool   UseNewsFilter       = false;   // block around defined news windows
input int    NewsBufferBeforeMin = 30;      // minutes before an event
input int    NewsBufferAfterMin  = 30;      // minutes after an event
input int    NewsImpactMin       = 2;       // 1=low, 2=medium, 3=high
input bool   NewsUseFile         = true;    // read blackouts from CSV in Common files
input string NewsFileRelPath     = "DualEA\\news_blackouts.csv";

// --- Insights live auto-reload controls
input bool   InsightsAutoReload        = true;  // if stale/missing, request rebuild and auto-reload when ready
input int    InsightsLiveFreshMinutes  = 10;    // consider insights fresh if modified within N minutes
input int    InsightsReadyPollSec      = 5;     // poll frequency for ready signal

input bool   UsePromotionGate    = false;   // allow only during configured windows
input bool   PromoLiveOnly       = false;   // apply only on live accounts
input int    PromoStartHour      = 0;       // inclusive, server time
input int    PromoEndHour        = 24;      // exclusive, supports wrap if less than start

input bool   UseRegimeGate       = false;   // filter by volatility regimes
input int    RegimeATRPeriod     = 14;
input double RegimeMinATRPct     = 0.0;     // 0=disabled
input double RegimeMaxATRPct     = 1000.0;  // 1000=disabled

input int    CircuitCooldownSec  = 0;       // 0=disabled

// --- FR-02 Session Manager inputs
input bool   UseSessionManager     = true;
input int    SessionEndHour        = 20;
input int    MaxTradesPerSession   = 10;

// --- FR-05 Correlation Manager inputs
input bool   UseCorrelationManager = true;
input double MaxCorrelationLimit   = 0.7;
input int    CorrLookbackDays      = 30;

// --- FR-04 Position Manager inputs
input int    PMMaxOpenPositions    = 10;     // 0=disabled; cap total open positions before PM gate blocks

// --- FR-06 Volatility Sizer inputs
input bool   UseVolatilitySizer    = false;
input int    VolSizerATRPeriod     = 14;
input double VolSizerBaseATRPct    = 1.0;
input double VolSizerMinMult       = 0.1;
input double VolSizerMaxMult       = 3.0;
input double VolSizerTargetRisk    = 1.0;
input double BaseLotSize           = 0.01;   // base lot size used when sizing via VolatilitySizer

//+------------------------------------------------------------------+
//| GLOBAL VARIABLES                                                 |
//+------------------------------------------------------------------+
CEfficientGateManagerEnhanced* g_gate_manager = NULL;  // New unified gate system
CTelemetry       *g_telemetry        = NULL;
CTelemetryStandard* g_tel_standard = NULL;
CSessionManager* g_session_manager = NULL;
CCorrelationManager* g_correlation_manager = NULL;
CVolatilitySizer* g_volatility_sizer = NULL;
// g_position_manager and g_insight_engine are defined in their respective modules
// CPositionManager* g_position_manager;
// CIncrementalInsightEngine* g_insight_engine;
bool              g_eval_busy        = false;
datetime          g_last_trade_placed= 0;

// --- Insights gating cache (loaded from insights.json via InsightsLoader)
string g_gate_strat[];
string g_gate_sym[];
int    g_gate_tf[];
int    g_gate_cnt[];
double g_gate_wr[];
double g_gate_avgR[];
double g_gate_pf[];
double g_gate_dd[];

// --- Policy gating cache (loaded from policy.json)
bool   g_policy_loaded  = false;
double g_policy_min_conf= 0.0;
string g_pol_strat[];
string g_pol_sym[];
int    g_pol_tf[];
double g_pol_p[];
double g_pol_sl[];
double g_pol_tp[];
double g_pol_trail[];

// Live insights reload state
bool    g_waiting_insights = false; // set after we request reload; reset when ready is consumed

// --- Exploration Mode tracking (weekly + daily persistent)
string g_exp_keys[];    // slice key: strategy|symbol|timeframe
int    g_exp_weeks[];   // week bucket id (Monday yyyymmdd)
int    g_exp_counts[];  // count within week
string g_explore_pending_key = ""; // set by Insights_Allow when allowing explore
// Daily exploration tracking (persistent)
string g_exp_day_keys[];
int    g_exp_day_days[];
int    g_exp_day_counts[];

// --- News blackout cache (from CSV)
string   g_news_key[];
datetime g_news_from[];
datetime g_news_to[];
int      g_news_impact[];

//+------------------------------------------------------------------+
//| UTILITY FUNCTIONS                                                |
//+------------------------------------------------------------------+
bool ShouldLog(const int level) { return (Verbosity >= level); }

void LogMessage(const int level, const string message)
{
    if (!ShouldLog(level)) return;
    
    string prefix = "";
    switch(level)
    {
        case LOG_ERROR: prefix = "[ERROR] "; break;
        case LOG_WARN:  prefix = "[WARN] ";  break;
        case LOG_INFO:  prefix = "[INFO] ";  break;
        case LOG_DEBUG: prefix = "[DEBUG] "; break;
    }
    
    Print(prefix + message);
}

//+------------------------------------------------------------------+
//| SERVICE INITIALIZATION FUNCTIONS                                 |
//+------------------------------------------------------------------+
void EnsureTelemetry()
  {
   if(!TelemetryEnabled) return;
   if(CheckPointer(g_telemetry)==POINTER_INVALID)
     {
      g_telemetry = new CTelemetry(_Symbol, TelemetryExperiment, TelemetryBufferMax, (int)_Period);
      if(CheckPointer(g_telemetry)==POINTER_INVALID)
        {
         Print("Failed to create telemetry instance");
         return;
        }
      g_tel_standard = new CTelemetryStandard(g_telemetry);
     }
  }

void EnsurePM()
  {
   if(!UsePositionManager) return;
   if(CheckPointer(g_position_manager)==POINTER_INVALID)
     {
      g_position_manager = new CPositionManager();
      if(CheckPointer(g_position_manager)!=POINTER_INVALID)
        (*g_position_manager).SetMagicNumber((int)MagicNumber);
     }
  }

void EnsureSessionManager()
  {
   if(!UseSessionManager) return;
   if(CheckPointer(g_session_manager)==POINTER_INVALID)
     {
      g_session_manager = new CSessionManager(_Symbol, _Period);
      g_session_manager.SetEnabled(true);
      g_session_manager.SetSessionHours(SessionStartHour, SessionEndHour);
      g_session_manager.SetMaxTradesPerSession(MaxTradesPerSession);
      g_session_manager.SetMaxDailyLossPct(MaxDailyLossPct);
     }
  }

void EnsureCorrelationManager()
  {
   if(!UseCorrelationManager) return;
   if(CheckPointer(g_correlation_manager)==POINTER_INVALID)
     {
      g_correlation_manager = new CCorrelationManager(_Symbol, _Period);
      g_correlation_manager.SetEnabled(true);
      g_correlation_manager.SetMaxCorrelation(MaxCorrelationLimit);
      g_correlation_manager.SetLookbackDays(CorrLookbackDays);
     }
  }

void EnsureVolatilitySizer()
  {
   if(!UseVolatilitySizer) return;
   if(CheckPointer(g_volatility_sizer)==POINTER_INVALID)
     {
      g_volatility_sizer = new CVolatilitySizer(_Symbol, _Period);
      g_volatility_sizer.SetEnabled(true);
      g_volatility_sizer.SetATRPeriod(VolSizerATRPeriod);
      g_volatility_sizer.SetBaseATRPercent(VolSizerBaseATRPct);
      g_volatility_sizer.SetMultiplierRange(VolSizerMinMult, VolSizerMaxMult);
      g_volatility_sizer.SetTargetRiskPercent(VolSizerTargetRisk);
     }
  }

// --- Spread/Session/Risk gating helpers and session tracking
datetime g_session_start = 0;
int      g_session_day   = 0;
double   g_session_equity_start = 0.0;
double   g_equity_highwater     = 0.0;

double CurrentSpreadPoints()
  {
   double bid=0.0, ask=0.0;
   SymbolInfoDouble(_Symbol, SYMBOL_BID, bid);
   SymbolInfoDouble(_Symbol, SYMBOL_ASK, ask);
   if(ask>0.0 && bid>0.0 && _Point>0.0) return (ask - bid)/_Point;
   return 0.0;
  }

 datetime ComputeSessionBoundary(datetime now)
   {
    MqlDateTime dt; TimeToStruct(now, dt);
    dt.hour = SessionStartHour;
    dt.min  = 0;
    dt.sec  = 0;
    datetime today_boundary = StructToTime(dt);
    if(now < today_boundary) return today_boundary - 86400;
    return today_boundary;
   }

 void EnsureSessionRollover()
   {
    datetime b = ComputeSessionBoundary(TimeCurrent());
    MqlDateTime dts; TimeToStruct(b, dts);
    int day = dts.year*10000 + dts.mon*100 + dts.day;
    if(g_session_start==0 || g_session_day!=day)
      {
       g_session_start = b;
       g_session_day   = day;
       g_session_equity_start = AccountInfoDouble(ACCOUNT_EQUITY);
       g_equity_highwater     = g_session_equity_start;
       if(ShouldLog(LOG_INFO)) PrintFormat("Session rollover: start=%s equity=%.2f",
         TimeToString(g_session_start, TIME_DATE|TIME_MINUTES), g_session_equity_start);
      }
   }

 int CountNewTradesSince(const datetime t0)
   {
    int count=0;
    if(!HistorySelect(t0, TimeCurrent())) return 0;
    int total = (int)HistoryDealsTotal();
    for(int i=0;i<total;++i)
      {
       ulong ticket = HistoryDealGetTicket(i);
       if(HistoryDealGetString(ticket, DEAL_SYMBOL)!=_Symbol) continue;
       long  mag = (long)HistoryDealGetInteger(ticket, DEAL_MAGIC);
       if(mag != MagicNumber) continue;
       int entry = (int)HistoryDealGetInteger(ticket, DEAL_ENTRY);
       if(entry==DEAL_ENTRY_IN) count++;
      }
    return count;
   }

 int CountConsecutiveLosses()
   {
    int consec=0;
    datetime t0 = TimeCurrent() - 120*86400;
    if(!HistorySelect(t0, TimeCurrent())) return 0;
    for(int i=HistoryDealsTotal()-1; i>=0; --i)
      {
       ulong ticket = HistoryDealGetTicket(i);
       if((int)HistoryDealGetInteger(ticket, DEAL_ENTRY)!=DEAL_ENTRY_OUT) continue;
       long mag = (long)HistoryDealGetInteger(ticket, DEAL_MAGIC);
       if(mag != MagicNumber) continue;
       double profit = HistoryDealGetDouble(ticket, DEAL_PROFIT);
       if(profit < 0.0) consec++;
       else break;
      }
    return consec;
   }

 // --- Minimal persistent consecutive loss counters (in-memory)
 string g_loss_sym[];
 long   g_loss_mag[];
 int    g_loss_cnt[];

 int GetConsecLossPersist(const string sym, const long mag)
   {
    for(int i=0;i<ArraySize(g_loss_sym);++i)
      if(g_loss_sym[i]==sym && g_loss_mag[i]==mag) return g_loss_cnt[i];
    return 0;
   }

 void SetConsecLossPersist(const string sym, const long mag, const int val)
   {
    for(int i=0;i<ArraySize(g_loss_sym);++i)
      if(g_loss_sym[i]==sym && g_loss_mag[i]==mag) { g_loss_cnt[i]=(val<0?0:val); return; }
    int n=ArraySize(g_loss_sym);
    ArrayResize(g_loss_sym,n+1); ArrayResize(g_loss_mag,n+1); ArrayResize(g_loss_cnt,n+1);
    g_loss_sym[n]=sym; g_loss_mag[n]=mag; g_loss_cnt[n]=(val<0?0:val);
   }

 void IncConsecLossPersist(const string sym, const long mag)
   {
    for(int i=0;i<ArraySize(g_loss_sym);++i)
      if(g_loss_sym[i]==sym && g_loss_mag[i]==mag) { g_loss_cnt[i]=g_loss_cnt[i]+1; return; }
    int n=ArraySize(g_loss_sym);
    ArrayResize(g_loss_sym,n+1); ArrayResize(g_loss_mag,n+1); ArrayResize(g_loss_cnt,n+1);
    g_loss_sym[n]=sym; g_loss_mag[n]=mag; g_loss_cnt[n]=1;
   }

 bool SpreadAllowed(string &reason)
   {
    reason = "ok";
    if(SpreadMaxPoints<=0.0) return true;
    double spr = CurrentSpreadPoints();
    if(spr <= SpreadMaxPoints) return true;
    reason = "spread_cap";
    return false;
   }

 bool SessionAllowed(string &reason)
   {
    reason = "ok";
    if(SessionMaxTrades<=0) return true;
    int used = CountNewTradesSince(g_session_start);
    if(used < SessionMaxTrades) return true;
    reason = "session_cap";
    return false;
   }

 bool RiskAllowed(string &reason)
  {
   reason = "ok";
   double eq = AccountInfoDouble(ACCOUNT_EQUITY);
   if(eq>g_equity_highwater) g_equity_highwater = eq;
    if(MaxDailyLossPct>0.0 && g_session_equity_start>0.0)
      {
       double dd = 100.0*(g_session_equity_start - eq)/g_session_equity_start;
       if(dd >= MaxDailyLossPct) { reason="max_daily_loss"; return false; }
      }
    if(MaxDrawdownPct>0.0 && g_equity_highwater>0.0)
      {
       double ddh = 100.0*(g_equity_highwater - eq)/g_equity_highwater;
       if(ddh >= MaxDrawdownPct) { reason="max_drawdown"; return false; }
      }
    if(MinMarginLevel>0.0)
      {
       double ml = AccountInfoDouble(ACCOUNT_MARGIN_LEVEL);
       if(ml>0.0 && ml < MinMarginLevel) { reason="margin_level"; return false; }
      }
    if(ConsecutiveLossLimit>0)
      {
       int cl = (P5_PersistLossCounters ? GetConsecLossPersist(_Symbol, (long)MagicNumber)
                                        : CountConsecutiveLosses());
       if(cl >= ConsecutiveLossLimit) { reason="consec_losses"; return false; }
      }
    return true;
   }

 // Helper: append unique key to a dynamic string array
 void AddUniqueKey(string &arr[], const string k)
   {
    for(int i=0;i<ArraySize(arr);++i)
      if(arr[i]==k) return;
    int n=ArraySize(arr);
    ArrayResize(arr, n+1);
    arr[n]=k;
   }

 bool NewsAllowed(string &reason)
   {
    reason = "ok";
    if(!UseNewsFilter)
      return true;

    // Derive keys to match against news file entries
    string keys[];
    string sU = _Symbol; StringToUpper(sU);
    // Add full symbol and wildcard
    AddUniqueKey(keys, sU);
    AddUniqueKey(keys, "*");
    // Try to extract currency codes
    string ccy[] = { "USD","EUR","GBP","JPY","CHF","AUD","NZD","CAD","SEK","NOK","DKK","SGD","HKD","CNY","CNH","ZAR","MXN","TRY" };
    for(int i=0;i<ArraySize(ccy);++i) if(StringFind(sU, ccy[i])>=0) AddUniqueKey(keys, ccy[i]);
    // Index heuristics -> base currency
    if(StringFind(sU, "US30")>=0 || StringFind(sU, "US500")>=0 || StringFind(sU, "NAS")>=0 || StringFind(sU, "DJ")>=0 || StringFind(sU, "SPX")>=0)
      AddUniqueKey(keys, "USD");
    if(StringFind(sU, "GER")>=0 || StringFind(sU, "DAX")>=0 || StringFind(sU, "FRA40")>=0 || StringFind(sU, "CAC")>=0)
      AddUniqueKey(keys, "EUR");
    if(StringFind(sU, "UK100")>=0 || StringFind(sU, "FTSE")>=0)
      AddUniqueKey(keys, "GBP");
    if(StringFind(sU, "JPN")>=0 || StringFind(sU, "JP")>=0 || StringFind(sU, "NIK")>=0)
      AddUniqueKey(keys, "JPY");
    if(StringFind(sU, "HK50")>=0 || StringFind(sU, "HSI")>=0)
      AddUniqueKey(keys, "HKD");
    if(StringFind(sU, "AUS")>=0)
      AddUniqueKey(keys, "AUD");

    datetime now = TimeCurrent();
    // Scan loaded blackout windows
    for(int i=0;i<ArraySize(g_news_key);++i)
      {
        // impact threshold
        if(g_news_impact[i] < NewsImpactMin) continue;
        // key match
        bool match=false;
        for(int j=0;j<ArraySize(keys) && !match;++j)
          if(g_news_key[i]==keys[j]) match=true;
        if(!match) continue;
        // window with buffers
        datetime from = g_news_from[i] - (NewsBufferBeforeMin*60);
        datetime to   = g_news_to[i]   + (NewsBufferAfterMin*60);
        if(now>=from && now<=to)
          {
            reason = "news_window";
            return false;
          }
      }
    return true;
   }

 bool PromotionAllowed(string &reason)
   {
    reason = "ok";
    if(!UsePromotionGate)
      return true;
    // Apply only on live accounts if configured
    if(PromoLiveOnly && AccountInfoInteger(ACCOUNT_TRADE_MODE)!=ACCOUNT_TRADE_MODE_REAL)
      return true;
    MqlDateTime dt; TimeToStruct(TimeCurrent(), dt);
    int h = dt.hour;
    // handle windows possibly spanning midnight
    bool in_window = false;
    if(PromoStartHour<=PromoEndHour)
      in_window = (h>=PromoStartHour && h<PromoEndHour);
    else
      in_window = (h>=PromoStartHour || h<PromoEndHour);
    if(!in_window)
      { reason = "promo_window"; return false; }
    return true;
   }

 bool RegimeAllowed(string &reason)
   {
    reason = "ok";
    if(!UseRegimeGate)
      return true;
    int atr_handle = iATR(_Symbol, _Period, RegimeATRPeriod);
    if(atr_handle==INVALID_HANDLE)
      return true;
    double atr_buf[]; ArrayResize(atr_buf,1);
    int copied = CopyBuffer(atr_handle, 0, 0, 1, atr_buf);
    IndicatorRelease(atr_handle);
    if(copied!=1)
      return true;
    double atr = atr_buf[0];
    double px  = SymbolInfoDouble(_Symbol, SYMBOL_BID);
    if(atr<=0.0 || px<=0.0)
      return true; // cannot assess -> allow
    double atr_pct = 100.0 * atr / px;
    if(RegimeMinATRPct>0.0 && atr_pct < RegimeMinATRPct)
      { reason = "regime_low_atr"; return false; }
    if(RegimeMaxATRPct>0.0 && atr_pct > RegimeMaxATRPct)
      { reason = "regime_high_atr"; return false; }
    return true;
   }

 bool CircuitCooldownAllowed(string &reason)
   {
    reason = "ok";
    if(CircuitCooldownSec<=0)
      return true;
    if(g_last_trade_placed<=0)
      return true;
    datetime now = TimeCurrent();
    if((now - g_last_trade_placed) < CircuitCooldownSec)
      { reason = "circuit_cooldown"; return false; }
    return true;
   }

  bool P5_CorrPruneAllow(const TradeOrder &order, string &reason)
    {
     reason = "ok";
     // No open positions -> nothing to prune
     int npos = PositionsTotal();
     if(npos<=0)
       return true;

    // Prefer PositionManager's portfolio correlation if available
    double avg_abs_corr = 0.0;
    bool corr_from_pm = (CheckPointer(g_position_manager)!=POINTER_INVALID);
    if(corr_from_pm)
      {
       avg_abs_corr = (*g_position_manager).GetPortfolioCorrelation(_Symbol);
      }
    else
      {
       // Manual weighted average absolute correlation to each open symbol
        int ps = PeriodSeconds(_Period);
        if(ps<=0) ps = 60;
        int approx_bars = (int)MathMax(50, MathMin(2000, (P5_CorrLookbackDays*86400)/ps));
        double sum=0.0, wsum=0.0;
        for(int i=0;i<npos;++i)
         {
          ulong t = PositionGetTicket(i);
          if(t==0) continue;
          if(!PositionSelectByTicket(t)) continue;
          string osym = PositionGetString(POSITION_SYMBOL);
          if(osym=="" || osym==_Symbol) continue;
          double vol = PositionGetDouble(POSITION_VOLUME);
          // Compute Pearson correlation between closes of _Symbol and osym
           double a[]; double b[];
           int ca = CopyClose(_Symbol, _Period, 0, approx_bars, a);
           int cb = CopyClose(osym,   _Period, 0, approx_bars, b);
           int m = MathMin(ca, cb);
           if(m<10) continue;
           double ma=0.0, mb=0.0; for(int k=0;k<m;++k){ ma+=a[k]; mb+=b[k]; }
           ma/=m; mb/=m;
           double cov=0.0, va=0.0, vb=0.0;
           for(int k=0;k<m;++k)
             {
              double da=a[k]-ma; double db=b[k]-mb;
              cov+=da*db; va+=da*da; vb+=db*db;
             }
           if(va<=0.0 || vb<=0.0) continue;
           double c = cov / MathSqrt(va*vb);
           if(c>1.0) c=1.0; if(c<-1.0) c=-1.0;
           sum += MathAbs(c) * vol;
           wsum += vol;
          }
        avg_abs_corr = (wsum>0.0? sum/wsum : 0.0);
      }

    if(avg_abs_corr > P5_CorrMax)
      {
       reason = StringFormat("corr=%.2f>max=%.2f", avg_abs_corr, P5_CorrMax);
       return false;
      }
    return true;
   }

// --- Insights/Policy helpers and loaders
// Trim helper
string TrimCopy(string s){ StringTrimLeft(s); StringTrimRight(s); return s; }

// Normalize broker-specific suffixes to base symbol (e.g., "AUDNZD_otc" -> "AUDNZD")
string NormalizeSymbol(string s)
  {
   string lowers = s; StringToLower(lowers);
   // Common suffixes/prefixes to strip
   string suf[] = { "_otc", "_pro", "_ecn", "_mini", "_micro", ".r", ".i", ".pro", ".ecn", ".m" };
   for(int i=0;i<ArraySize(suf);++i)
     {
      int p = StringFind(lowers, suf[i], StringLen(lowers)-StringLen(suf[i]));
      if(p>=0 && p==StringLen(lowers)-StringLen(suf[i]))
        {
         // Remove suffix of same length from original string
         s = StringSubstr(s, 0, StringLen(s)-StringLen(suf[i]));
         break;
        }
     }
   return s;
  }

// Load policy.json from Common Files and cache min_confidence and slice_probs
bool Policy_Load()
  {
   g_policy_loaded = false;
   g_policy_min_conf = 0.0;
   ArrayResize(g_pol_strat,0); ArrayResize(g_pol_sym,0); ArrayResize(g_pol_tf,0); ArrayResize(g_pol_p,0);
   ArrayResize(g_pol_sl,0); ArrayResize(g_pol_tp,0); ArrayResize(g_pol_trail,0);
   string path = "DualEA\\policy.json";
   int h = FileOpen(path, FILE_READ|FILE_TXT|FILE_COMMON|FILE_ANSI);
   if(h==INVALID_HANDLE)
     {
      if(ShouldLog(LOG_WARN)) PrintFormat("Policy gating: cannot open %s (Common). Err=%d", path, GetLastError());
      return false;
     }
   string cur_s="", cur_y=""; int cur_tf=-1; double cur_p=-1.0;
   double cur_sl=1.0, cur_tp=1.0, cur_tr=1.0; // optional scales default to 1.0
   while(!FileIsEnding(h))
     {
      string line = FileReadString(h);
      if(line=="" && FileIsEnding(h)) break;
      int p;
      // min_confidence
      p = StringFind(line, "\"min_confidence\"", 0);
      if(p>=0)
        {
         int c = StringFind(line, ":", p);
         if(c>=0){ string num = TrimCopy(StringSubstr(line, c+1)); double v = StringToDouble(num); if(v>0) g_policy_min_conf = v; }
        }
      // strategy
      p = StringFind(line, "\"strategy\"", 0);
      if(p>=0)
        {
         int q = StringFind(line, ",", p+1); string seg = (q>p? StringSubstr(line, p, q-p) : StringSubstr(line, p));
         int c3=StringFind(seg, "\"", 0); c3 = StringFind(seg, "\"", c3+1); int c4=StringFind(seg, "\"", c3+1); int c5=StringFind(seg, "\"", c4+1);
         if(c4>0 && c5>c4) cur_s = StringSubstr(seg, c4+1, c5-c4-1);
        }
      // symbol
      p = StringFind(line, "\"symbol\"", 0);
      if(p>=0)
        {
         int q = StringFind(line, ",", p+1); string seg = (q>p? StringSubstr(line, p, q-p) : StringSubstr(line, p));
         int c3=StringFind(seg, "\"", 0); c3 = StringFind(seg, "\"", c3+1); int c4=StringFind(seg, "\"", c3+1); int c5=StringFind(seg, "\"", c4+1);
         if(c4>0 && c5>c4) cur_y = StringSubstr(seg, c4+1, c5-c4-1);
        }
      // timeframe
      p = StringFind(line, "\"timeframe\"", 0);
      if(p>=0)
        {
         int c = StringFind(line, ":", p); if(c>=0){ string num = TrimCopy(StringSubstr(line, c+1)); cur_tf = (int)StringToInteger(num); }
        }
      // p_win
      p = StringFind(line, "\"p_win\"", 0);
      if(p>=0)
        {
         int c = StringFind(line, ":", p); if(c>=0){ string num = TrimCopy(StringSubstr(line, c+1)); cur_p = StringToDouble(num); }
        }
      // optional: sl_scale
      p = StringFind(line, "\"sl_scale\"", 0);
      if(p>=0)
        {
         int c = StringFind(line, ":", p); if(c>=0){ string num = TrimCopy(StringSubstr(line, c+1)); cur_sl = StringToDouble(num); }
        }
      // optional: tp_scale
      p = StringFind(line, "\"tp_scale\"", 0);
      if(p>=0)
        {
         int c = StringFind(line, ":", p); if(c>=0){ string num = TrimCopy(StringSubstr(line, c+1)); cur_tp = StringToDouble(num); }
        }
      // optional: trail_scale
      p = StringFind(line, "\"trail_scale\"", 0);
      if(p>=0)
        {
         int c = StringFind(line, ":", p); if(c>=0){ string num = TrimCopy(StringSubstr(line, c+1)); cur_tr = StringToDouble(num); }
        }
      // commit when we have strat+symbol (timeframe may be -1)
      if(cur_s!="" && cur_y!="" && cur_tf!=-2 && cur_p>=0.0)
        {
         int n = ArraySize(g_pol_strat);
         ArrayResize(g_pol_strat,n+1); ArrayResize(g_pol_sym,n+1); ArrayResize(g_pol_tf,n+1);
         ArrayResize(g_pol_p,n+1); ArrayResize(g_pol_sl,n+1); ArrayResize(g_pol_tp,n+1); ArrayResize(g_pol_trail,n+1);
         g_pol_strat[n]=cur_s; g_pol_sym[n]=cur_y; g_pol_tf[n]=cur_tf; g_pol_p[n]=cur_p; g_pol_sl[n]=cur_sl; g_pol_tp[n]=cur_tp; g_pol_trail[n]=cur_tr;
         // reset slice accumulators for next object
         cur_s=""; cur_y=""; cur_tf=-1; cur_p=-1.0; cur_sl=1.0; cur_tp=1.0; cur_tr=1.0;
        }
     }
   FileClose(h);
   g_policy_loaded = (ArraySize(g_pol_strat)>0);
   if(ShouldLog(LOG_INFO)) PrintFormat("Policy gating: min_conf=%.3f slices=%d", g_policy_min_conf, ArraySize(g_pol_strat));
   return g_policy_loaded;
  }

double GetPolicyProb(const string strategy, const string symbol, const int timeframe)
  {
   string symN = NormalizeSymbol(symbol);
   // 1) Exact slice: strat+symbol+timeframe
   for(int i=0;i<ArraySize(g_pol_strat);++i)
     if(g_pol_strat[i]==strategy && g_pol_sym[i]==symN && g_pol_tf[i]==timeframe)
       return g_pol_p[i];
   // 2) Symbol aggregate across TFs: strat+symbol, tf=-1
   for(int i=0;i<ArraySize(g_pol_strat);++i)
     if(g_pol_strat[i]==strategy && g_pol_sym[i]==symN && g_pol_tf[i]==-1)
       return g_pol_p[i];
   // 3) Strategy aggregate across symbols/TFs: strat only, symbol="*", tf=-1
   for(int i=0;i<ArraySize(g_pol_strat);++i)
     if(g_pol_strat[i]==strategy && g_pol_sym[i]=="*" && g_pol_tf[i]==-1)
       return g_pol_p[i];
   return -1.0;
  }

double GetPolicyScaleSL(const string strategy, const string symbol, const int timeframe)
  {
   string symN = NormalizeSymbol(symbol);
   for(int i=0;i<ArraySize(g_pol_strat);++i)
     if(g_pol_strat[i]==strategy && g_pol_sym[i]==symN && g_pol_tf[i]==timeframe)
       return (g_pol_sl[i]>0? g_pol_sl[i] : 1.0);
   for(int i=0;i<ArraySize(g_pol_strat);++i)
     if(g_pol_strat[i]==strategy && g_pol_sym[i]==symN && g_pol_tf[i]==-1)
       return (g_pol_sl[i]>0? g_pol_sl[i] : 1.0);
   for(int i=0;i<ArraySize(g_pol_strat);++i)
     if(g_pol_strat[i]==strategy && g_pol_sym[i]=="*" && g_pol_tf[i]==-1)
       return (g_pol_sl[i]>0? g_pol_sl[i] : 1.0);
   return 1.0;
  }

double GetPolicyScaleTP(const string strategy, const string symbol, const int timeframe)
  {
   string symN = NormalizeSymbol(symbol);
   for(int i=0;i<ArraySize(g_pol_strat);++i)
     if(g_pol_strat[i]==strategy && g_pol_sym[i]==symN && g_pol_tf[i]==timeframe)
       return (g_pol_tp[i]>0? g_pol_tp[i] : 1.0);
   for(int i=0;i<ArraySize(g_pol_strat);++i)
     if(g_pol_strat[i]==strategy && g_pol_sym[i]==symN && g_pol_tf[i]==-1)
       return (g_pol_tp[i]>0? g_pol_tp[i] : 1.0);
   for(int i=0;i<ArraySize(g_pol_strat);++i)
     if(g_pol_strat[i]==strategy && g_pol_sym[i]=="*" && g_pol_tf[i]==-1)
       return (g_pol_tp[i]>0? g_pol_tp[i] : 1.0);
   return 1.0;
  }

double GetPolicyScaleTrail(const string strategy, const string symbol, const int timeframe)
  {
   string symN = NormalizeSymbol(symbol);
   for(int i=0;i<ArraySize(g_pol_strat);++i)
     if(g_pol_strat[i]==strategy && g_pol_sym[i]==symN && g_pol_tf[i]==timeframe)
       return (g_pol_trail[i]>0? g_pol_trail[i] : 1.0);
   for(int i=0;i<ArraySize(g_pol_strat);++i)
     if(g_pol_strat[i]==strategy && g_pol_sym[i]==symN && g_pol_tf[i]==-1)
       return (g_pol_trail[i]>0? g_pol_trail[i] : 1.0);
   for(int i=0;i<ArraySize(g_pol_strat);++i)
     if(g_pol_strat[i]==strategy && g_pol_sym[i]=="*" && g_pol_tf[i]==-1)
       return (g_pol_trail[i]>0? g_pol_trail[i] : 1.0);
   return 1.0;
  }

// Apply policy-driven scaling to SL/TP/trailing of an order. Entry price approximated.
void ApplyPolicyScaling(TradeOrder &order, const string symbol, const int timeframe, const double ppol)
  {
   if(!UsePolicyGating || !g_policy_loaded) return;
   // fetch scales
   double sls = GetPolicyScaleSL(order.strategy_name, symbol, timeframe);
   double tps = GetPolicyScaleTP(order.strategy_name, symbol, timeframe);
   double trs = GetPolicyScaleTrail(order.strategy_name, symbol, timeframe);

   // determine entry reference
   double entry = 0.0;
   if(order.price>0.0)
     entry = order.price; // pending
   else
     entry = (order.action==ACTION_BUY? SymbolInfoDouble(symbol, SYMBOL_ASK) : SymbolInfoDouble(symbol, SYMBOL_BID));

   // Adjust SL
   if(order.stop_loss>0.0 && entry>0.0 && sls>0.0 && sls!=1.0)
     {
      double d = MathAbs(entry - order.stop_loss);
      double nd = d * sls;
      if(order.action==ACTION_BUY)
        order.stop_loss = entry - nd;
      else if(order.action==ACTION_SELL)
        order.stop_loss = entry + nd;
     }
   // Adjust TP
   if(order.take_profit>0.0 && entry>0.0 && tps>0.0 && tps!=1.0)
     {
      double d = MathAbs(order.take_profit - entry);
      double nd = d * tps;
      if(order.action==ACTION_BUY)
        order.take_profit = entry + nd;
      else if(order.action==ACTION_SELL)
        order.take_profit = entry - nd;
     }
   // Adjust trailing
   if(order.trailing_enabled && trs>0.0 && trs!=1.0)
     {
      if(order.trailing_type==TRAIL_ATR)
        order.atr_multiplier *= trs;
      else if(order.trailing_type==TRAIL_FIXED_POINTS)
        {
         order.trail_distance_points *= trs;
         order.trail_step_points *= trs;
        }
     }
   if(ShouldLog(LOG_DEBUG))
     PrintFormat("[POLICY] scales applied %s/%s tf=%d p=%.3f sl=%.2f tp=%.2f tr=%.2f",
                 order.strategy_name, symbol, timeframe, ppol, sls, tps, trs);
  }

// --- Exploration counters (weekly/daily) persistence
int WeekMondayId(datetime t)
  {
   MqlDateTime dt; TimeToStruct(t, dt);
   // MT5: day_of_week 0=Sunday, 1=Monday, ... 6=Saturday
   int dow = dt.day_of_week;
   int delta_days = (dow==0 ? 6 : (dow-1));
   datetime monday = t - (delta_days * 86400);
   MqlDateTime md; TimeToStruct(monday, md);
   return (md.year*10000 + md.mon*100 + md.day);
  }

// P0-3: Checksum calculation for exploration counters
uint CalculateExploreChecksum(string key, int week, int count)
{
   string data = key + "|" + IntegerToString(week) + "|" + IntegerToString(count);
   uint checksum = 0;
   for(int i = 0; i < StringLen(data); i++)
   {
      checksum = ((checksum << 5) + checksum) + (uchar)StringGetCharacter(data, i);
   }
   return checksum;
}

string ExploreCountsPath()
  {
   return "DualEA\\explore_counts.csv"; // FILE_COMMON
  }

void SaveExploreCounts()
  {
   string path = ExploreCountsPath();
   int h = FileOpen(path, FILE_WRITE|FILE_CSV|FILE_ANSI|FILE_COMMON, ',');
   if(h==INVALID_HANDLE){ PrintFormat("Explore persist: cannot open %s for write. Err=%d", path, GetLastError()); return; }
   // P0-3: Add checksum column to header
   FileWrite(h, "key", "week_monday_yyyymmdd", "count", "checksum");
   for(int i=0;i<ArraySize(g_exp_keys);++i)
     {
      // P0-3: Calculate and write checksum
      uint checksum = CalculateExploreChecksum(g_exp_keys[i], g_exp_weeks[i], g_exp_counts[i]);
      FileWrite(h, g_exp_keys[i], IntegerToString(g_exp_weeks[i]), IntegerToString(g_exp_counts[i]), IntegerToString((long)checksum));
     }
   FileClose(h);
   // P0-3: Verify file was written correctly
   if(!VerifyExploreCountsFile())
   {
      Print("[P0-3] WARNING: Explore counts file verification failed - data may be corrupted");
   }
 }

// P0-3: Verify the saved file by reading it back and checking consistency
bool VerifyExploreCountsFile()
{
   string path = ExploreCountsPath();
   int h = FileOpen(path, FILE_READ|FILE_CSV|FILE_ANSI|FILE_COMMON, ',');
   if(h==INVALID_HANDLE) return false;
   
   bool first = true;
   int row = 0;
   bool valid = true;
   
   while(!FileIsEnding(h) && valid)
   {
      string k = FileReadString(h);
      if(k=="" && FileIsEnding(h)) break;
      
      string wk_s = FileReadString(h);
      string cnt_s = FileReadString(h);
      string checksum_s = FileReadString(h);  // P0-3: Read checksum
      
      if(first) { first = false; continue; }  // Skip header
      
      // P0-3: Verify checksum
      if(StringLen(checksum_s) > 0)
      {
         uint expected = CalculateExploreChecksum(k, (int)StringToInteger(wk_s), (int)StringToInteger(cnt_s));
         uint actual = (uint)StringToInteger(checksum_s);
         if(expected != actual)
         {
            PrintFormat("[P0-3] Checksum mismatch at row %d: key=%s", row, k);
            valid = false;
         }
      }
      row++;
   }
   FileClose(h);
   return valid;
}

bool LoadExploreCounts()
  {
   ArrayResize(g_exp_keys,0); ArrayResize(g_exp_weeks,0); ArrayResize(g_exp_counts,0);
   string path = ExploreCountsPath();
   int h = FileOpen(path, FILE_READ|FILE_CSV|FILE_ANSI|FILE_COMMON, ',');
   if(h==INVALID_HANDLE) { if(ShouldLog(LOG_INFO)) PrintFormat("Explore persist: no prior %s (ok)", path); return true; }
   bool first=true;
   int corrupted_rows = 0;
   int total_rows = 0;
   
   while(!FileIsEnding(h))
     {
      string k = FileReadString(h); if(k=="" && FileIsEnding(h)) break;
      string wk_s = FileReadString(h);
      string cnt_s = FileReadString(h);
      string checksum_s = FileReadString(h);  // P0-3: Read checksum column
      
      // skip header if present
      if(first && (StringFind(k, "key", 0)==0)) { first=false; continue; }
      first=false;
      total_rows++;
      
      // P0-3: Validate checksum before loading
      bool valid = true;
      if(StringLen(checksum_s) > 0)
      {
         uint expected = CalculateExploreChecksum(k, (int)StringToInteger(wk_s), (int)StringToInteger(cnt_s));
         uint actual = (uint)StringToInteger(checksum_s);
         if(expected != actual)
         {
            PrintFormat("[P0-3] Corrupted row detected and skipped: key=%s (checksum mismatch)", k);
            corrupted_rows++;
            valid = false;
         }
      }
      
      if(valid)
      {
         int n = ArraySize(g_exp_keys);
         ArrayResize(g_exp_keys,n+1); ArrayResize(g_exp_weeks,n+1); ArrayResize(g_exp_counts,n+1);
         g_exp_keys[n]=k; g_exp_weeks[n]=(int)StringToInteger(wk_s); g_exp_counts[n]=(int)StringToInteger(cnt_s);
      }
     }
   FileClose(h);
   
   // P0-3: Log corruption statistics
   if(corrupted_rows > 0)
   {
      PrintFormat("[P0-3] LoadExploreCounts: Recovered from %d corrupted rows out of %d total", corrupted_rows, total_rows);
   }
   
   return true;
  }

int DayId(datetime t)
  {
   MqlDateTime dt; TimeToStruct(t, dt);
   return (dt.year*10000 + dt.mon*100 + dt.day);
  }

string ExploreDayCountsPath()
  {
   return "DualEA\\explore_counts_day.csv";
  }

void SaveExploreCountsDay()
  {
   string path = ExploreDayCountsPath();
   int h = FileOpen(path, FILE_WRITE|FILE_CSV|FILE_ANSI|FILE_COMMON, ',');
   if(h==INVALID_HANDLE){ PrintFormat("Explore persist(day): cannot open %s for write. Err=%d", path, GetLastError()); return; }
   FileWrite(h, "key,day_yyyymmdd,count");
   for(int i=0;i<ArraySize(g_exp_day_keys);++i)
     FileWrite(h, g_exp_day_keys[i], IntegerToString(g_exp_day_days[i]), IntegerToString(g_exp_day_counts[i]));
   FileClose(h);
  }

bool LoadExploreCountsDay()
  {
   ArrayResize(g_exp_day_keys,0); ArrayResize(g_exp_day_days,0); ArrayResize(g_exp_day_counts,0);
   string path = ExploreDayCountsPath();
   int h = FileOpen(path, FILE_READ|FILE_CSV|FILE_ANSI|FILE_COMMON, ',');
   if(h==INVALID_HANDLE) { if(ShouldLog(LOG_INFO)) PrintFormat("Explore persist(day): no prior %s (ok)", path); return true; }
   bool first=true;
   while(!FileIsEnding(h))
     {
      string k = FileReadString(h); if(k=="" && FileIsEnding(h)) break;
      string d = FileReadString(h);
      string c = FileReadString(h);
      if(first && (StringFind(k, "key", 0)==0)) { first=false; continue; }
      first=false;
      int n = ArraySize(g_exp_day_keys);
      ArrayResize(g_exp_day_keys,n+1); ArrayResize(g_exp_day_days,n+1); ArrayResize(g_exp_day_counts,n+1);
      g_exp_day_keys[n]=k; g_exp_day_days[n]=(int)StringToInteger(d); g_exp_day_counts[n]=(int)StringToInteger(c);
     }
   FileClose(h);
   return true;
  }

string SliceKey(const string strategy, const string symbol, const int timeframe)
  {
   return strategy + "|" + symbol + "|" + IntegerToString(timeframe);
  }

int GetExploreCount(const string key)
  {
   int wk = WeekMondayId(TimeCurrent());
   for(int i=0;i<ArraySize(g_exp_keys);++i)
     if(g_exp_keys[i]==key && g_exp_weeks[i]==wk) return g_exp_counts[i];
   return 0;
  }

int GetExploreCountDay(const string key)
  {
   int d = DayId(TimeCurrent());
   for(int i=0;i<ArraySize(g_exp_day_keys);++i)
     if(g_exp_day_keys[i]==key && g_exp_day_days[i]==d) return g_exp_day_counts[i];
   return 0;
  }

void IncExploreCount(const string key)
  {
   int wk = WeekMondayId(TimeCurrent());
   for(int i=0;i<ArraySize(g_exp_keys);++i)
     if(g_exp_keys[i]==key && g_exp_weeks[i]==wk)
       {
        g_exp_counts[i] = g_exp_counts[i] + 1;
        SaveExploreCounts();
        // also bump daily
        int dd = DayId(TimeCurrent()); bool day_found=false;
        for(int j=0;j<ArraySize(g_exp_day_keys);++j)
          if(g_exp_day_keys[j]==key && g_exp_day_days[j]==dd){ g_exp_day_counts[j]+=1; day_found=true; break; }
        if(!day_found)
          {
           int m = ArraySize(g_exp_day_keys);
           ArrayResize(g_exp_day_keys,m+1); ArrayResize(g_exp_day_days,m+1); ArrayResize(g_exp_day_counts,m+1);
           g_exp_day_keys[m]=key; g_exp_day_days[m]=dd; g_exp_day_counts[m]=1;
          }
        SaveExploreCountsDay();
        return;
       }
   int n = ArraySize(g_exp_keys);
   ArrayResize(g_exp_keys, n+1);
   ArrayResize(g_exp_weeks, n+1);
   ArrayResize(g_exp_counts, n+1);
   g_exp_keys[n] = key;
   g_exp_weeks[n] = wk;
   g_exp_counts[n] = 1;
   SaveExploreCounts();
   // init daily row
   int dd = DayId(TimeCurrent());
   int m = ArraySize(g_exp_day_keys);
   ArrayResize(g_exp_day_keys,m+1); ArrayResize(g_exp_day_days,m+1); ArrayResize(g_exp_day_counts,m+1);
   g_exp_day_keys[m]=key; g_exp_day_days[m]=dd; g_exp_day_counts[m]=1;
   SaveExploreCountsDay();
  }

// Check if insights has an existing slice for exact strategy/symbol/timeframe
bool HasSlice(const string strategy, const string symbol, const int timeframe)
  {
   for(int i=0;i<ArraySize(g_gate_strat);++i)
     if(g_gate_strat[i]==strategy && g_gate_sym[i]==symbol && g_gate_tf[i]==timeframe && g_gate_cnt[i]>0)
        return true;
   return false;
  }

bool Insights_Load()
  {
   int loaded = Insights_Load_Default(
      g_gate_strat,
      g_gate_sym,
      g_gate_tf,
      g_gate_cnt,
      g_gate_wr,
      g_gate_avgR,
      g_gate_pf,
      g_gate_dd
   );
   if(loaded<0)
      return false;
   if(ShouldLog(LOG_INFO)) PrintFormat("Insights gating: loaded %d slices", ArraySize(g_gate_strat));
   return ArraySize(g_gate_strat)>0;
  }

bool Insights_Allow(const string strategy, const string symbol, const int timeframe, string &reason, const bool shadow=false, const bool no_side_effects=false)
  {
    reason = "";
    // Global bypass for data collection
    if(NoConstraintsMode && !shadow)
      {
       reason = "no_constraints";
       return true;
      }
   // Default policy fallback when no policy is loaded
   if(DefaultPolicyFallback && UsePolicyGating && FallbackWhenNoPolicy && !g_policy_loaded)
     {
      bool demo_ok0 = (!FallbackDemoOnly) || (AccountInfoInteger(ACCOUNT_TRADE_MODE)==ACCOUNT_TRADE_MODE_DEMO);
      if(demo_ok0)
        {
         reason = "fallback_no_policy";
         return true;
        }
     }
   // Default policy fallback: allow neutral trading when policy slice is missing
   if(DefaultPolicyFallback && UsePolicyGating && g_policy_loaded)
     {
      double pchk = GetPolicyProb(strategy, symbol, timeframe);
      if(pchk < 0.0)
        {
         bool demo_ok = (!FallbackDemoOnly) || (AccountInfoInteger(ACCOUNT_TRADE_MODE)==ACCOUNT_TRADE_MODE_DEMO);
         if(demo_ok)
           {
            reason = "fallback_policy_miss";
            return true;
           }
        }
     }
   // Find matching slice
   for(int i=0;i<ArraySize(g_gate_strat);++i)
     if(g_gate_strat[i]==strategy && g_gate_sym[i]==symbol && g_gate_tf[i]==timeframe)
       {
        if(g_gate_cnt[i] < GateMinTrades)
          {
            reason = "min_trades"; return false;
          }
        if(g_gate_wr[i]  < GateMinWinRate)
          {
            reason = "win_rate"; return false;
          }
        if(g_gate_avgR[i]< GateMinExpectancyR)
          {
            reason = "expectancy"; return false;
          }
        if(g_gate_dd[i]  > GateMaxDrawdownR)
          {
            reason = "drawdown"; return false;
          }
        if(g_gate_pf[i]  < GateMinProfitFactor)
          {
            reason = "profit_factor"; return false;
          }
        // Policy check for exact slice
        if(UsePolicyGating && g_policy_loaded)
          {
           double ppol = GetPolicyProb(strategy, symbol, timeframe);
           if(ppol>=0.0 && ppol < g_policy_min_conf)
             { reason = "policy_min_conf"; return false; }
          }
        return true;
       }
   // If no slices loaded at all, allow cold-start to bootstrap data
   if(ArraySize(g_gate_strat)==0)
     { reason = "cold_start"; return true; }

   // Fallback 1: aggregate by strategy+symbol across all timeframes
   int total=0; double wins=0.0; double sumR=0.0; double pf_sum=0.0; int pf_cnt=0; double worst_dd=0.0;
   for(int j=0;j<ArraySize(g_gate_strat);++j)
     if(g_gate_strat[j]==strategy && g_gate_sym[j]==symbol)
       {
        total += g_gate_cnt[j];
        wins  += g_gate_wr[j]*g_gate_cnt[j];
        sumR  += g_gate_avgR[j]*g_gate_cnt[j];
        pf_sum+= g_gate_pf[j]; pf_cnt++;
        if(g_gate_dd[j]>worst_dd) worst_dd=g_gate_dd[j];
       }
   if(total>0)
     {
      double wr   = (total>0? wins/total : 0.0);
      double avgR = (total>0? sumR/total : 0.0);
      double pf   = (pf_cnt>0? pf_sum/pf_cnt : 0.0);
      double dd   = worst_dd;
      if(total < GateMinTrades)
        {
         reason = "min_trades_agg_sym"; return false;
        }
      if(wr    < GateMinWinRate)
        {
         reason = "win_rate_agg_sym"; return false;
        }
      if(avgR  < GateMinExpectancyR)
        {
         reason = "expectancy_agg_sym"; return false;
        }
      if(dd    > GateMaxDrawdownR)
        {
         reason = "drawdown_agg_sym"; return false;
        }
      if(pf    < GateMinProfitFactor)
        {
         reason = "profit_factor_agg_sym"; return false;
        }
      // Policy check for aggregated slice (if available)
      if(UsePolicyGating && g_policy_loaded)
        {
         double ppol = GetPolicyProb(strategy, symbol, timeframe);
         if(ppol>=0.0 && ppol < g_policy_min_conf)
           { reason = "policy_min_conf_agg_sym"; return false; }
        }
      reason = "agg_sym_ok"; return true;
     }

   // Fallback 2: aggregate by strategy across all symbols/timeframes
   total=0; wins=0.0; sumR=0.0; pf_sum=0.0; pf_cnt=0; worst_dd=0.0;
   for(int j=0;j<ArraySize(g_gate_strat);++j)
     if(g_gate_strat[j]==strategy)
       {
        total += g_gate_cnt[j];
        wins  += g_gate_wr[j]*g_gate_cnt[j];
        sumR  += g_gate_avgR[j]*g_gate_cnt[j];
        pf_sum+= g_gate_pf[j]; pf_cnt++;
        if(g_gate_dd[j]>worst_dd) worst_dd=g_gate_dd[j];
       }
   if(total>0)
     {
      double wr   = (total>0? wins/total : 0.0);
      double avgR = (total>0? sumR/total : 0.0);
      double pf   = (pf_cnt>0? pf_sum/pf_cnt : 0.0);
      double dd   = worst_dd;
      if(total < GateMinTrades)
        { reason = "min_trades_agg_strat"; return false; }
      if(wr    < GateMinWinRate)
        { reason = "win_rate_agg_strat"; return false; }
      if(avgR  < GateMinExpectancyR)
        { reason = "expectancy_agg_strat"; return false; }
      if(dd    > GateMaxDrawdownR)
        { reason = "drawdown_agg_strat"; return false; }
      if(pf    < GateMinProfitFactor)
        { reason = "profit_factor_agg_strat"; return false; }
      // Policy check for aggregated strategy (if available)
      if(UsePolicyGating && g_policy_loaded)
        {
         double ppol = GetPolicyProb(strategy, symbol, timeframe);
         if(ppol>=0.0 && ppol < g_policy_min_conf)
           { reason = "policy_min_conf_agg_strat"; return false; }
        }
      reason = "agg_strat_ok"; return true;
     }

   // If slice not found and gating disabled, allow
   if(!UseInsightsGating) return true;
   // Else, no exact slice exists. Exploration Mode: allow only when no slice, with day+week caps
   if(ExploreOnNoSlice)
     {
      // Strict policy: allow exploration ONLY when no slice exists
      bool has_slice = HasSlice(strategy, symbol, timeframe);
      if(has_slice)
        {
         reason = "slice_exists";
         return false;
        }
      string key = SliceKey(strategy, symbol, timeframe);
      int used_w = GetExploreCount(key);
      int used_d = GetExploreCountDay(key);
      if(ExploreMaxPerSlicePerDay > 0 && used_d >= ExploreMaxPerSlicePerDay)
        { reason = "explore_cap_day"; return false; }
      if(ExploreMaxPerSlice > 0 && used_w >= ExploreMaxPerSlice)
        { reason = "explore_cap_week"; return false; }
      if(!no_side_effects)
        g_explore_pending_key = key;
      reason = "explore_allow";
      return true;
     }
   reason = "no_slice";
   return false;
  }

// --- Evaluation and execution orchestrator
 void EvaluateAndMaybeExecute(const TradeOrder &order)
   {
    if(g_eval_busy) return; // prevent reentry
    g_eval_busy = true;
    ulong t0 = GetTickCount();

    EnsureSessionRollover();
    EnsureTelemetry();
    EnsurePM();
    EnsureSessionManager();
    EnsureCorrelationManager();
    EnsureVolatilitySizer();

    // Shadow gates (diagnostic only)
    if(NoConstraintsMode && TelemetryEnabled && CheckPointer(g_telemetry)!=POINTER_INVALID)
      {
       int lat=0;
       string r;
       r=""; bool s_ok = SpreadAllowed(r); lat=(int)(GetTickCount()-t0);
       (*g_telemetry).LogGatingShadow(order.strategy_name, _Symbol, (int)_Period, "spread", s_ok, (s_ok?"ok":r)+";p6_latency="+IntegerToString(lat)+"ms", true);
       r=""; bool ses_ok = SessionAllowed(r); lat=(int)(GetTickCount()-t0);
       (*g_telemetry).LogGatingShadow(order.strategy_name, _Symbol, (int)_Period, "session", ses_ok, (ses_ok?"ok":r)+";p6_latency="+IntegerToString(lat)+"ms", true);
       r=""; bool r_ok = RiskAllowed(r); lat=(int)(GetTickCount()-t0);
       (*g_telemetry).LogGatingShadow(order.strategy_name, _Symbol, (int)_Period, "risk", r_ok, (r_ok?"ok":r)+";p6_latency="+IntegerToString(lat)+"ms", true);
       r=""; bool news_ok = NewsAllowed(r); lat=(int)(GetTickCount()-t0);
       (*g_telemetry).LogGatingShadow(order.strategy_name, _Symbol, (int)_Period, "news", news_ok, (news_ok?"ok":r)+";p6_latency="+IntegerToString(lat)+"ms", true);
       r=""; bool promo_ok = PromotionAllowed(r); lat=(int)(GetTickCount()-t0);
       (*g_telemetry).LogGatingShadow(order.strategy_name, _Symbol, (int)_Period, "promotion", promo_ok, (promo_ok?"ok":r)+";p6_latency="+IntegerToString(lat)+"ms", true);
       r=""; bool regime_ok = RegimeAllowed(r); lat=(int)(GetTickCount()-t0);
       (*g_telemetry).LogGatingShadow(order.strategy_name, _Symbol, (int)_Period, "regime", regime_ok, (regime_ok?"ok":r)+";p6_latency="+IntegerToString(lat)+"ms", true);
       r=""; bool cool_ok = CircuitCooldownAllowed(r); lat=(int)(GetTickCount()-t0);
       (*g_telemetry).LogGatingShadow(order.strategy_name, _Symbol, (int)_Period, "circuit_cooldown", cool_ok, (cool_ok?"ok":r)+";p6_latency="+IntegerToString(lat)+"ms", true);
       // Shadow insights gating (no side effects, ignore NoConstraints bypass)
       if(UseInsightsGating)
         {
          string rshadow=""; bool allow_shadow = Insights_Allow(order.strategy_name, _Symbol, (int)_Period, rshadow, true, true);
          (*g_telemetry).LogGatingShadow(order.strategy_name, _Symbol, (int)_Period, "insights", allow_shadow, rshadow, true);
         }
      }

    // Early gates (fail-closed unless NoConstraintsMode)
    if(!NoConstraintsMode)
      {
       // Spread gate
       string r_spread_early=""; if(!SpreadAllowed(r_spread_early))
         {
          if(ShouldLog(LOG_INFO)) PrintFormat("GATE: blocked %s on %s/%s reason=%s (spread)", order.strategy_name, _Symbol, EnumToString(_Period), r_spread_early);
          if(TelemetryEnabled && CheckPointer(g_telemetry)!=POINTER_INVALID)
            (*g_telemetry).LogGating(_Symbol, (int)_Period, order.strategy_name, "spread", false, r_spread_early+";p6_latency="+IntegerToString((int)(GetTickCount()-t0))+"ms");
          g_eval_busy = false; return;
         }
       // Session gate
       string r_sess_early=""; if(!SessionAllowed(r_sess_early))
         {
          if(ShouldLog(LOG_INFO)) PrintFormat("GATE: blocked %s on %s/%s reason=%s (session)", order.strategy_name, _Symbol, EnumToString(_Period), r_sess_early);
          if(TelemetryEnabled && CheckPointer(g_telemetry)!=POINTER_INVALID)
            (*g_telemetry).LogGating(_Symbol, (int)_Period, order.strategy_name, "session", false, r_sess_early+";p6_latency="+IntegerToString((int)(GetTickCount()-t0))+"ms");
          g_eval_busy = false; return;
         }
       string rr=""; if(!RiskAllowed(rr))
         {
          if(ShouldLog(LOG_INFO)) PrintFormat("GATE: blocked %s on %s/%s reason=%s (eq=%.2f base=%.2f high=%.2f ml=%.2f)", order.strategy_name, _Symbol, EnumToString(_Period), rr, AccountInfoDouble(ACCOUNT_EQUITY), g_session_equity_start, g_equity_highwater, AccountInfoDouble(ACCOUNT_MARGIN_LEVEL));
          if(TelemetryEnabled && CheckPointer(g_telemetry)!=POINTER_INVALID)
            (*g_telemetry).LogGating(_Symbol, (int)_Period, order.strategy_name, "risk", false, rr+";p6_latency="+IntegerToString((int)(GetTickCount()-t0))+"ms");
          g_eval_busy = false; return;
         }
       string r_news_early=""; if(!NewsAllowed(r_news_early))
         {
          if(ShouldLog(LOG_INFO)) PrintFormat("GATE: blocked %s on %s/%s reason=%s (news)", order.strategy_name, _Symbol, EnumToString(_Period), r_news_early);
          if(TelemetryEnabled && CheckPointer(g_telemetry)!=POINTER_INVALID)
            (*g_telemetry).LogGating(_Symbol, (int)_Period, order.strategy_name, "news", false, r_news_early+";p6_latency="+IntegerToString((int)(GetTickCount()-t0))+"ms");
          g_eval_busy = false; return;
         }
       string r_promo_early=""; if(!PromotionAllowed(r_promo_early))
         {
          if(ShouldLog(LOG_INFO)) PrintFormat("GATE: blocked %s on %s/%s reason=%s (promotion)", order.strategy_name, _Symbol, EnumToString(_Period), r_promo_early);
          if(TelemetryEnabled && CheckPointer(g_telemetry)!=POINTER_INVALID)
            (*g_telemetry).LogGating(_Symbol, (int)_Period, order.strategy_name, "promotion", false, r_promo_early+";p6_latency="+IntegerToString((int)(GetTickCount()-t0))+"ms");
          g_eval_busy = false; return;
         }
       string r_regime_early=""; if(!RegimeAllowed(r_regime_early))
         {
          if(ShouldLog(LOG_INFO)) PrintFormat("GATE: blocked %s on %s/%s reason=%s (regime)", order.strategy_name, _Symbol, EnumToString(_Period), r_regime_early);
          if(TelemetryEnabled && CheckPointer(g_telemetry)!=POINTER_INVALID)
            (*g_telemetry).LogGating(_Symbol, (int)_Period, order.strategy_name, "regime", false, r_regime_early+";p6_latency="+IntegerToString((int)(GetTickCount()-t0))+"ms");
          g_eval_busy = false; return;
         }
       string r_cool_early=""; if(!CircuitCooldownAllowed(r_cool_early))
         {
          if(ShouldLog(LOG_INFO)) PrintFormat("GATE: blocked %s on %s/%s reason=%s (circuit_cooldown)", order.strategy_name, _Symbol, EnumToString(_Period), r_cool_early);
          if(TelemetryEnabled && CheckPointer(g_telemetry)!=POINTER_INVALID)
            (*g_telemetry).LogGating(_Symbol, (int)_Period, order.strategy_name, "circuit_cooldown", false, r_cool_early+";p6_latency="+IntegerToString((int)(GetTickCount()-t0))+"ms");
          g_eval_busy = false; return;
         }
      }

    // Insights/Policy gate (fail-closed unless NoConstraintsMode)
    if(!NoConstraintsMode)
      {
       // Check IncrementalInsightEngine for auto-promoted strategies
       if(CheckPointer(g_insight_engine) != POINTER_INVALID)
       {
          if(!g_insight_engine.IsStrategyApproved(order.strategy_name, _Symbol, (int)_Period))
          {
             // Strategy not yet promoted - block trade
             if(ShouldLog(LOG_INFO)) PrintFormat("[INSIGHTS] blocked %s on %s/%s reason=not_approved", 
                                                  order.strategy_name, _Symbol, EnumToString(_Period));
             g_eval_busy=false; return;
          }
       }
       
       string gate_reason="";
       bool ins_ok = Insights_Allow(order.strategy_name, _Symbol, (int)_Period, gate_reason);
       if(TelemetryEnabled && CheckPointer(g_telemetry)!=POINTER_INVALID)
         (*g_telemetry).LogGating(_Symbol, (int)_Period, order.strategy_name, "insights", ins_ok, (ins_ok?"ok":gate_reason)+";p6_latency="+IntegerToString((int)(GetTickCount()-t0))+"ms");
       if(!ins_ok)
         {
          if(ShouldLog(LOG_INFO)) PrintFormat("[INSIGHTS] blocked %s on %s/%s reason=%s", order.strategy_name, _Symbol, EnumToString(_Period), gate_reason);
          g_eval_busy=false; return;
         }
      }

    // Correlation gate
    string r_corr=""; bool corr_ok = P5_CorrPruneAllow(order, r_corr);
    if(TelemetryEnabled && CheckPointer(g_telemetry)!=POINTER_INVALID)
      (*g_telemetry).LogGating(_Symbol, (int)_Period, order.strategy_name, "corr", corr_ok, (corr_ok?"ok":r_corr)+";p6_latency="+IntegerToString((int)(GetTickCount()-t0))+"ms");
    if(!corr_ok) { if(ShouldLog(LOG_INFO)) PrintFormat("[CORR] blocked %s on %s/%s reason=%s", order.strategy_name, _Symbol, EnumToString(_Period), r_corr); g_eval_busy=false; return; }

    // Final RISK4 gates just before execution
    string r_rk_exec="";
    if(!RiskAllowed(r_rk_exec))
      {
       if(ShouldLog(LOG_INFO)) PrintFormat("[RISK4] blocked %s on %s/%s reason=%s", order.strategy_name, _Symbol, EnumToString(_Period), r_rk_exec);
       if(TelemetryEnabled && CheckPointer(g_telemetry)!=POINTER_INVALID)
         (*g_telemetry).LogGating(_Symbol, (int)_Period, order.strategy_name, "risk4", false, r_rk_exec+";p6_latency="+IntegerToString((int)(GetTickCount()-t0))+"ms");
       g_eval_busy = false; return;
      }
    string r_spread_exec="";
    if(!SpreadAllowed(r_spread_exec))
      {
       if(ShouldLog(LOG_INFO)) PrintFormat("[RISK4] blocked %s on %s/%s reason=%s (spread)", order.strategy_name, _Symbol, EnumToString(_Period), r_spread_exec);
       if(TelemetryEnabled && CheckPointer(g_telemetry)!=POINTER_INVALID)
         (*g_telemetry).LogGating(_Symbol, (int)_Period, order.strategy_name, "risk4_spread", false, r_spread_exec+";p6_latency="+IntegerToString((int)(GetTickCount()-t0))+"ms");
       g_eval_busy = false; return;
      }
    string r_sess_exec="";
    if(!SessionAllowed(r_sess_exec))
      {
       if(ShouldLog(LOG_INFO)) PrintFormat("[RISK4] blocked %s on %s/%s reason=%s (session)", order.strategy_name, _Symbol, EnumToString(_Period), r_sess_exec);
        if(TelemetryEnabled && CheckPointer(g_telemetry)!=POINTER_INVALID)
         (*g_telemetry).LogGating(_Symbol, (int)_Period, order.strategy_name, "risk4_session", false, r_sess_exec+";p6_latency="+IntegerToString((int)(GetTickCount()-t0))+"ms");
       g_eval_busy = false; return;
      }
    string r_news_exec="";
    if(!NewsAllowed(r_news_exec))
      {
       if(ShouldLog(LOG_INFO)) PrintFormat("[RISK4] blocked %s on %s/%s reason=%s (news)", order.strategy_name, _Symbol, EnumToString(_Period), r_news_exec);
       if(TelemetryEnabled && CheckPointer(g_telemetry)!=POINTER_INVALID)
         (*g_telemetry).LogGating(_Symbol, (int)_Period, order.strategy_name, "risk4_news", false, r_news_exec+";p6_latency="+IntegerToString((int)(GetTickCount()-t0))+"ms");
       g_eval_busy = false; return;
      }
    string r_promo_exec="";
    if(!PromotionAllowed(r_promo_exec))
      {
       if(ShouldLog(LOG_INFO)) PrintFormat("[RISK4] blocked %s on %s/%s reason=%s (promotion)", order.strategy_name, _Symbol, EnumToString(_Period), r_promo_exec);
       if(TelemetryEnabled && CheckPointer(g_telemetry)!=POINTER_INVALID)
         (*g_telemetry).LogGating(_Symbol, (int)_Period, order.strategy_name, "risk4_promotion", false, r_promo_exec+";p6_latency="+IntegerToString((int)(GetTickCount()-t0))+"ms");
       g_eval_busy = false; return;
      }
    string r_regime_exec="";
    if(!RegimeAllowed(r_regime_exec))
      {
       if(ShouldLog(LOG_INFO)) PrintFormat("[RISK4] blocked %s on %s/%s reason=%s (regime)", order.strategy_name, _Symbol, EnumToString(_Period), r_regime_exec);
       if(TelemetryEnabled && CheckPointer(g_telemetry)!=POINTER_INVALID)
         (*g_telemetry).LogGating(_Symbol, (int)_Period, order.strategy_name, "risk4_regime", false, r_regime_exec+";p6_latency="+IntegerToString((int)(GetTickCount()-t0))+"ms");
       g_eval_busy = false; return;
      }
    string r_cool_exec="";
    if(!CircuitCooldownAllowed(r_cool_exec))
      {
       if(ShouldLog(LOG_INFO)) PrintFormat("[RISK4] blocked %s on %s/%s reason=%s (circuit_cooldown)", order.strategy_name, _Symbol, EnumToString(_Period), r_cool_exec);
       if(TelemetryEnabled && CheckPointer(g_telemetry)!=POINTER_INVALID)
         (*g_telemetry).LogGating(_Symbol, (int)_Period, order.strategy_name, "risk4_circuit_cooldown", false, r_cool_exec+";p6_latency="+IntegerToString((int)(GetTickCount()-t0))+"ms");
       g_eval_busy = false; return;
      }

    if(ShouldLog(LOG_INFO)) PrintFormat("[READY] %s on %s/%s passed gates", order.strategy_name, _Symbol, EnumToString(_Period));

   // Apply policy-driven scaling (if enabled and available) using a local copy of order
   TradeOrder req = order;
   double ppol_now = (UsePolicyGating && g_policy_loaded ? GetPolicyProb(req.strategy_name, _Symbol, (int)_Period) : -1.0);
   ApplyPolicyScaling(req, _Symbol, (int)_Period, ppol_now);

   // --- FR-06 Volatility Position Sizing (set req.lots) ---
  if(UseVolatilitySizer && CheckPointer(g_volatility_sizer)!=POINTER_INVALID)
    {
     double stop_pts = 0.0;
     double bid=0.0, ask=0.0; SymbolInfoDouble(_Symbol, SYMBOL_BID, bid); SymbolInfoDouble(_Symbol, SYMBOL_ASK, ask);
     if(req.stop_loss>0.0)
       {
        if(req.order_type==ORDER_TYPE_BUY || req.order_type==ORDER_TYPE_BUY_LIMIT || req.order_type==ORDER_TYPE_BUY_STOP)
          {
           double ref = (req.price>0.0? req.price : ask);
           stop_pts = MathMax(0.0, (ref - req.stop_loss)/_Point);
          }
        else
          {
           double ref = (req.price>0.0? req.price : bid);
           stop_pts = MathMax(0.0, (req.stop_loss - ref)/_Point);
          }
       }
     double atr_pct=0.0; string vs_r1=""; double mult_hint = (*g_volatility_sizer).CalculateSizeMultiplier(atr_pct, vs_r1);
     double mult_final=1.0; string vs_r2="";
     double sized = (*g_volatility_sizer).CalculatePositionSize(BaseLotSize, stop_pts, mult_final, vs_r2);
     if(sized>0.0) req.lots = sized;
     if(TelemetryEnabled && CheckPointer(g_tel_standard)!=POINTER_INVALID)
       (*g_tel_standard).LogVolatilitySizingEvent(_Symbol, (int)_Period, BaseLotSize, mult_final, (sized>0.0?sized:BaseLotSize), atr_pct);
    }

  // Execute the trade using TradeManager
  CTradeManager tm(_Symbol, 0.0 /* default to symbol min lot if order.lots==0 */, (int)MagicNumber);
   bool exec_ok = tm.ExecuteOrder(req);
   uint retcode = tm.ResultRetcode();
   ulong deal_id = tm.ResultDeal();
   ulong order_id = tm.ResultOrder();

   if(exec_ok)
     {
      g_last_trade_placed = TimeCurrent();
      if(TelemetryEnabled && CheckPointer(g_telemetry)!=POINTER_INVALID)
        (*g_telemetry).LogTradeExecuted(order.strategy_name, _Symbol, (int)_Period, (int)retcode, deal_id, order_id);
      // Exploration accounting: count only on successful execution
      if(g_explore_pending_key!="")
        {
         IncExploreCount(g_explore_pending_key);
         if(ShouldLog(LOG_INFO)) PrintFormat("Exploration used for %s -> %d/%d", g_explore_pending_key, GetExploreCount(g_explore_pending_key), ExploreMaxPerSlice);
         g_explore_pending_key = "";
        }
     }
   else
     {
      if(TelemetryEnabled && CheckPointer(g_telemetry)!=POINTER_INVALID)
        (*g_telemetry).LogTradeFailed(order.strategy_name, _Symbol, (int)_Period, (int)retcode);
      // Ensure exploration pending key does not leak across failed executions
      if(g_explore_pending_key!="")
        {
         if(ShouldLog(LOG_INFO)) PrintFormat("Exploration not used due to failed execution for %s", g_explore_pending_key);
         g_explore_pending_key = "";
        }
     }

   g_eval_busy = false;
  }

// --- Terminal event handlers
int OnInit()
  {
   EnsureSessionRollover();
   EnsureTelemetry();
   EnsurePM();
   EnsureSessionManager();
   EnsureCorrelationManager();
   EnsureVolatilitySizer();
   
   // Initialize Incremental Insight Engine for real-time strategy approval
   g_insight_engine = new CIncrementalInsightEngine();
   if(CheckPointer(g_insight_engine) != POINTER_INVALID)
   {
      if(ShouldLog(LOG_INFO)) Print("[LiveEA] Incremental Insight Engine initialized");
   }
   // Load exploration counters and gating caches
   LoadExploreCounts();
   LoadExploreCountsDay();
   bool gate_loaded = Insights_Load();
   if(ShouldLog(LOG_INFO)) PrintFormat("Insights gating cache load: %s", (gate_loaded?"ok":"fail"));
   if(UsePolicyGating) { bool pol_ok = Policy_Load(); if(ShouldLog(LOG_INFO)) PrintFormat("Policy cache load: %s", (pol_ok?"ok":"fail")); }
   // Load news blackout windows
   if(UseNewsFilter && NewsUseFile)
     {
      // Reset and load
      ArrayResize(g_news_key,0); ArrayResize(g_news_from,0); ArrayResize(g_news_to,0); ArrayResize(g_news_impact,0);
      int h = FileOpen(NewsFileRelPath, FILE_READ|FILE_CSV|FILE_ANSI|FILE_COMMON, ',');
      if(h!=INVALID_HANDLE)
        {
         bool first=true;
         while(!FileIsEnding(h))
           {
            string k = FileReadString(h); if(k=="" && FileIsEnding(h)) break;
            string sfrom = FileReadString(h);
            string sto   = FileReadString(h);
            string simp  = FileReadString(h);
            if(first && (StringFind(k, "key", 0)==0)) { first=false; continue; }
            first=false;
            datetime tfrom = StringToTime(sfrom);
            datetime tto   = StringToTime(sto);
            int impact = (int)StringToInteger(simp);
            int n = ArraySize(g_news_key);
            ArrayResize(g_news_key,n+1); ArrayResize(g_news_from,n+1); ArrayResize(g_news_to,n+1); ArrayResize(g_news_impact,n+1);
            StringToUpper(k);
            g_news_key[n]=k; g_news_from[n]=tfrom; g_news_to[n]=tto; g_news_impact[n]=impact;
           }
         FileClose(h);
         if(ShouldLog(LOG_INFO)) PrintFormat("News blackout windows loaded: %d", ArraySize(g_news_key));
        }
      else
        {
         if(ShouldLog(LOG_WARN)) PrintFormat("News filter: cannot open %s (Common). Err=%d", NewsFileRelPath, GetLastError());
        }
     }
   // GATE summary
   string gsum = StringFormat("insights=%s policy=%s(min=%.3f) explore=%s caps(slice=%d/day=%d)",
      (UseInsightsGating?"on":"off"), (UsePolicyGating?"on":"off"), g_policy_min_conf,
      (ExploreOnNoSlice?"on":"off"), ExploreMaxPerSlice, ExploreMaxPerSlicePerDay);
   if(ShouldLog(LOG_INFO)) PrintFormat("[GATE] %s", gsum);
   if(ShouldLog(LOG_INFO)) Print("LiveEA initialized");
   // Start watcher timer for insights ready signal
   if(InsightsAutoReload && InsightsReadyPollSec>0)
      EventSetTimer(InsightsReadyPollSec);
   // Bootstrap: ensure insights are fresh or request a rebuild immediately
   MaybeEnsureInsights();
   return(INIT_SUCCEEDED);
  }

void OnDeinit(const int reason)
  {
   if(CheckPointer(g_position_manager)!=POINTER_INVALID) { delete g_position_manager; g_position_manager=NULL; }
   if(CheckPointer(g_telemetry)!=POINTER_INVALID)        { delete g_telemetry;        g_telemetry=NULL; }
   if(CheckPointer(g_tel_standard)!=POINTER_INVALID)     { delete g_tel_standard;     g_tel_standard=NULL; }
   if(CheckPointer(g_session_manager)!=POINTER_INVALID)  { delete g_session_manager;  g_session_manager=NULL; }
   if(CheckPointer(g_correlation_manager)!=POINTER_INVALID) { delete g_correlation_manager; g_correlation_manager=NULL; }
   if(CheckPointer(g_volatility_sizer)!=POINTER_INVALID) { delete g_volatility_sizer; g_volatility_sizer=NULL; }
   if(CheckPointer(g_insight_engine)!=POINTER_INVALID)   { delete g_insight_engine;   g_insight_engine=NULL; }
   if(InsightsAutoReload && InsightsReadyPollSec>0)
      EventKillTimer();
  }

void OnTick()
  {
   // Strategy orchestration is external; gates are available via EvaluateAndMaybeExecute(order)
   // Early gating before any selection/insights logic
   if(!EvaluateAndMaybeExecute_PreSelector())
     {
      if(ShouldLog(LOG_INFO)) Print("[EARLY] gates blocked tick");
      return;
     }
   // If an external orchestrator performs selection and prepares orders, it should
   // call EvaluateAndMaybeExecute_PreExecute() just before execution. We call it here
   // as a placeholder to ensure telemetry is emitted even when no orders are placed.
   EvaluateAndMaybeExecute_PreExecute();
  }

// --- Phase 6: Gate orchestration with shadow telemetry
ulong NowMs(){ return (ulong)GetTickCount(); }

void LogGate(const string tag, const bool allowed, const string phase, const ulong t0)
  {
   int latency = (int)(NowMs() - t0);
   if(ShouldLog(LOG_INFO))
      PrintFormat("[%s] %s latency_ms=%d", tag, (allowed?"allow":"block"), latency);
   if(TelemetryEnabled && CheckPointer(g_telemetry)!=POINTER_INVALID)
     {
      string det = StringFormat("phase=%s p6_latency_ms=%d", phase, latency);
      (*g_telemetry).LogEvent(_Symbol, (int)_Period, "gate", StringFormat("%s_%s", tag, (allowed?"allow":"block")), det);
     }
   // Standardized telemetry
   if(TelemetryEnabled && CheckPointer(g_tel_standard)!=POINTER_INVALID)
     {
      (*g_tel_standard).LogGateEvent(_Symbol, (int)_Period, tag, allowed, phase, latency, "n/a");
     }
  }

// Early gates before selector/insights
bool EarlyGatesAllow()
  {
   string reason;
   ulong t0;
   // NEWS
   t0=NowMs(); bool news_ok = NewsAllowed(reason); LogGate("NEWS", news_ok, "early", t0);
   if(!news_ok && !NoConstraintsMode) return false;
   // PROMO
   t0=NowMs(); bool promo_ok = PromotionAllowed(reason); LogGate("PROMO", promo_ok, "early", t0);
   if(!promo_ok && !NoConstraintsMode) return false;
   // REGIME
   t0=NowMs(); bool reg_ok = RegimeAllowed(reason); LogGate("REGIME", reg_ok, "early", t0);
   if(!reg_ok && !NoConstraintsMode) return false;
   // CIRCUIT cooldown
   t0=NowMs(); bool circ_ok = CircuitCooldownAllowed(reason); LogGate("CIRCUIT", circ_ok, "early", t0);
   // SESSION (diagnostic in early; block only if NoConstraintsMode is false)
   EnsureSessionManager();
   if(UseSessionManager && CheckPointer(g_session_manager)!=POINTER_INVALID)
     {
      t0=NowMs(); bool sess_ok = g_session_manager.IsSessionAllowed(reason); LogGate("SESSION", sess_ok, "early", t0);
      if(!sess_ok && !NoConstraintsMode) return false;
     }
   // CORRELATION (diagnostic/block depending on NoConstraintsMode)
   EnsureCorrelationManager();
   if(UseCorrelationManager && CheckPointer(g_correlation_manager)!=POINTER_INVALID)
     {
      double max_corr;
      t0=NowMs(); bool corr_ok = g_correlation_manager.CheckCorrelationLimits(reason, max_corr); LogGate("CORR", corr_ok, "early", t0);
      if(!corr_ok && !NoConstraintsMode) return false;
     }
   return true;
  }

// Final risk4 gates just before execution
bool Risk4GatesAllow()
  {
   string reason;
   ulong t0;
   t0=NowMs(); bool news_ok = NewsAllowed(reason); LogGate("NEWS", news_ok, "risk4", t0); if(!news_ok) return false;
   t0=NowMs(); bool promo_ok= PromotionAllowed(reason); LogGate("PROMO", promo_ok,"risk4", t0); if(!promo_ok) return false;
   t0=NowMs(); bool reg_ok  = RegimeAllowed(reason); LogGate("REGIME", reg_ok, "risk4", t0); if(!reg_ok) return false;
   t0=NowMs(); bool circ_ok = CircuitCooldownAllowed(reason); LogGate("CIRCUIT", circ_ok,"risk4", t0); if(!circ_ok) return false;
   
   // FR-02 Session gate
   EnsureSessionManager();
   if(UseSessionManager && CheckPointer(g_session_manager)!=POINTER_INVALID)
     {
      t0=NowMs(); bool sess_ok = g_session_manager.IsSessionAllowed(reason); LogGate("SESSION", sess_ok, "risk4", t0); if(!sess_ok) return false;
     }
   
   // FR-05 Correlation gate
   EnsureCorrelationManager();
   if(UseCorrelationManager && CheckPointer(g_correlation_manager)!=POINTER_INVALID)
     {
      double max_corr;
      t0=NowMs(); bool corr_ok = g_correlation_manager.CheckCorrelationLimits(reason, max_corr); LogGate("CORR", corr_ok, "risk4", t0); if(!corr_ok) return false;
     }
   
   // FR-04 Position Manager gate
   EnsurePM();
   if(UsePositionManager && CheckPointer(g_position_manager)!=POINTER_INVALID)
     {
      int open_positions = PositionsTotal();
      bool pm_ok = (PMMaxOpenPositions<=0 ? true : (open_positions < PMMaxOpenPositions));
      t0=NowMs(); LogGate("PM", pm_ok, "risk4", t0); 
      if(!pm_ok) return false;
     }
   
   return true;
  }

// Public function to be called by orchestrator before/after selector/insights
bool EvaluateAndMaybeExecute_PreSelector()
  {
   return EarlyGatesAllow();
  }

bool EvaluateAndMaybeExecute_PreExecute()
  {
   return Risk4GatesAllow();
  }

// --- Insights ready/reload logic ---
bool IsInsightsFresh(const int fresh_minutes)
  {
   string ip = "DualEA\\insights.json";
   long ex_i = FileGetInteger(ip, FILE_EXISTS, true);
   if(ex_i==0) return false;
   datetime ti = (datetime)FileGetInteger(ip, FILE_MODIFY_DATE, true);
   if(fresh_minutes<=0) return true; // any existing is fine
   return ((TimeCurrent() - ti) <= (fresh_minutes*60));
  }

void RequestInsightsReload()
  {
   string path = "DualEA\\insights.reload";
   if(FileIsExist(path, FILE_COMMON)) FileDelete(path, FILE_COMMON);
   int h = FileOpen(path, FILE_WRITE|FILE_TXT|FILE_ANSI|FILE_COMMON);
   if(h!=INVALID_HANDLE)
     {
      FileWrite(h, IntegerToString((int)TimeCurrent()));
      FileClose(h);
      if(ShouldLog(LOG_INFO)) Print("Insights reload requested");
     }
   else
     {
      if(ShouldLog(LOG_WARN)) PrintFormat("Insights reload: cannot create %s (err=%d)", path, GetLastError());
     }
  }

void CheckInsightsReady()
  {
   string rdy = "DualEA\\insights.ready";
   int h = FileOpen(rdy, FILE_READ|FILE_TXT|FILE_ANSI|FILE_COMMON);
   if(h==INVALID_HANDLE) return;
   // Ready present -> consume and reload
   FileClose(h);
   if(!FileDelete(rdy, FILE_COMMON))
     {
      // still proceed, but log
      if(ShouldLog(LOG_WARN)) PrintFormat("Insights ready: cannot delete %s (err=%d)", rdy, GetLastError());
     }
   bool ok = Insights_Load();
   if(ShouldLog(LOG_INFO)) PrintFormat("Insights ready detected: reload %s", (ok?"ok":"fail"));
   g_waiting_insights = false;
  }

void MaybeEnsureInsights()
  {
   if(!InsightsAutoReload) return;
   if(IsInsightsFresh(InsightsLiveFreshMinutes)) return;
   if(!g_waiting_insights)
     {
      RequestInsightsReload();
      g_waiting_insights = true;
     }
  }

void OnTimer()
  {
   if(!InsightsAutoReload) return;
   MaybeEnsureInsights();
   CheckInsightsReady();
  }