Princeec13/dualea
Watch
0
0
Fork
You've already forked dualea
 1
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity Actions
dualea/Experts/Advisors/DualEA/PaperEA/PaperEA_v2.mq5
Princeec13 Princeec13 143c06ef3e
2026-03-06 17:12:54 -05:00
4535 lines
174 KiB
MQL5
RawPermalinkBlameHistory
//+------------------------------------------------------------------+
//| PaperEA_v2.mq5 - Efficient DualEA Main |
//+------------------------------------------------------------------+
#property copyright "DualEA Enhanced Paper System"
#property version "2.0"
#property strict
//+------------------------------------------------------------------+
//| INCLUDES - COMPREHENSIVE MODULE INTEGRATION |
//+------------------------------------------------------------------+
// NEW: Auto-learning gate system (replaces old GateManager/GateRegistry)
#include "..\Include\GateSystemAutoLearning.mqh"
// Core Services
#include "..\Include\KnowledgeBase.mqh"
#include "..\Include\TradeManager.mqh"
#include "..\Include\PolicyEngine.mqh"
// Telemetry System
#include "../Include/Telemetry.mqh"
#include "../Include/TelemetryStandard.mqh"
#include "../Include/SessionManager.mqh"
#include "../Include/CorrelationManager.mqh"
#include "../Include/VolatilitySizer.mqh"
// Centralized gate orchestration macros
#include "..\\Include\\GatingPipeline.mqh"
// Adaptive Signal Optimization System
#include "..\Include\AdaptiveSignalOptimizer.mqh"
#include "..\Include\PolicyUpdater.mqh"
#include "..\Include\PositionReviewer.mqh"
#include "..\Include\GateLearningSystem.mqh"
#include "..\Include\UnifiedTradeLogger.mqh"
// Unified System Components
#include "..\Include\ConfigManager.mqh"
#include "..\Include\EventBus.mqh"
// Standard Libraries
#include <Arrays/ArrayObj.mqh>
#include <Files/File.mqh>
// Logging level constants for ShouldLog() (unique names to avoid macro collisions)
#ifndef PAPEREA_LOG_DEBUG
#define PAPEREA_LOG_DEBUG 3
#endif
#ifndef PAPEREA_LOG_INFO
#define PAPEREA_LOG_INFO 2
#endif
#ifndef PAPEREA_LOG_WARNING
#define PAPEREA_LOG_WARNING 1
#endif
#ifndef PAPEREA_LOG_ERROR
#define PAPEREA_LOG_ERROR 0
#endif
// Basic LOG macro used widely across this EA
#ifndef LOG
#define LOG(msg) Print(msg)
#endif
// Defensive: some includes may define ShouldLog as a macro.
// We require the function declared later in this file.
#ifdef ShouldLog
#undef ShouldLog
#endif
#ifndef PAPEREA_SHOULD_LOG
#define PAPEREA_SHOULD_LOG(level) (ShouldLog((int)(level)))
#endif
// Advanced Regime Detection
#include "..\\Include\\AdvancedRegimeDetector.mqh"
// Nuclear-Grade 100-Level Optimization
#include "NuclearOptimization.mqh"
// Regime-based parameter adaptation
#include "regime_adaptation.mqh"
// Position management
#include "..\\Include\\ModelPredictor.mqh"
// Policy hot-reload bridge
#include "..\\Include\\PolicyHttpBridge.mqh"
// Strategy Implementations - Per-asset registry (internally includes concrete strategy headers)
#include "..\\Include\\Strategies\\AssetRegistry.mqh"
// Strategy selector
#include "..\Include\StrategySelector.mqh"
// P0/P1 COMPREHENSIVE HARDENING & INTELLIGENCE UPGRADE
#include "..\Include\DualEA_MasterIntegration.mqh"
// P0-P5 ADVANCED HARDENING & INTELLIGENCE INTEGRATION
#include "..\Include\PaperEA_v2_P0P5_Integration.mqh"
// Additional components referenced by PaperEA_v2
#include "..\Include\CGateAudit.mqh"
#include "..\Include\CInsightsRealtime.mqh"
// Learning and Export Systems - Using file-based export for strategy tester compatibility
#include "..\Include\LearningBridge.mqh"
#include "..\Include\FileBasedFeatureExport.mqh" // Replaces DLL-based export
#include "..\Include\StrategySignalGenerators.mqh" // Extensible strategy signal generators
#include "..\Include\IncrementalInsightEngine.mqh" // Real-time O(1) statistics engine
// ===================[ EFFICIENT GATE SYSTEM CONFIGURATION ]===================
input group "=== EFFICIENT 8-STAGE GATE SYSTEM ==="
input bool UseEfficientGates = true; // Use optimized gate implementation
input int GateProcessingMode = 0; // 0=Full, 1=RiskOnly, 2=Fast, 3=Bypass
input bool ShadowMode = false; // Disable shadow mode for real trading
input bool LiveTradingEnabled = true; // Enable demo trading
input bool LoadONNXModels = true; // Load dynamic threshold ONNX models
input bool AutoReloadModels = true; // Auto-reload models when updated
input int RetrainIntervalHours = 24; // Hours between model retraining
input bool G5_PerformanceWaxEnabled = true; // Enable performance validation
input double G5_MinWinRate = 0.45; // Min strategy win rate
input int G5_LookbackTrades = 20; // Trades to look back
input bool G6_MLPolishEnabled = true; // Enable ML validation
input double G6_MLConfidenceThreshold = 0.55; // ML confidence threshold
input bool G7_LiveCleanEnabled = true; // Enable market condition checks
input double G7_MaxSpreadPercent = 0.05; // Max spread (5%)
// Risk gates ALWAYS enforced (G1, G4, G7, G8) - per MQL5 risk management best practices
// IMPORTANT: "Paper" refers to DEMO ACCOUNT, NOT simulated trades!
// - PaperEA executes REAL MT5 trades via OrderSend() on DEMO accounts
// - LiveEA executes REAL MT5 trades via OrderSend() on LIVE accounts
// - Both use identical execution logic through TradeManager
// - All positions tracked by MT5's native position system
// - Use PositionSelect(), PositionGetDouble(), OnTradeTransaction() for real position data
// ===================[ NO SIMULATION - REAL EXECUTION ONLY ]===================
// Using CFeaturesKB from Include\KnowledgeBase.mqh
//+------------------------------------------------------------------+
//| INPUT PARAMETERS - COMPREHENSIVE SYSTEM CONFIGURATION |
//+------------------------------------------------------------------+
// ===================[ TRADING INPUTS ]===================
// Symbol and Timeframe automatically detected from chart
input double LotSize = 0.0; // Let VolatilitySizer decide
input int MagicNumber = 12345;
input double StopLossPips_Input = 150; // 50:300:25 - Universal SL range (user initial value)
input double TakeProfitPips_Input = 300; // 100:600:50 - Universal TP range (user initial value)
// Modifiable runtime parameters (auto-adapted by universal detector)
double StopLossPips = 150;
double TakeProfitPips = 300;
input bool TrailEnabled = true;
input int TrailType = 2; // 0=fixed, 2=ATR
input int TrailActivationPoints = 30; // 10:100:10 - Trail activation threshold
input int TrailDistancePoints = 20; // 10:60:5 - Trail distance from price
input int TrailStepPoints = 5; // 2:15:1 - Trail step increment
input int TrailATRPeriod = 14; // 7:28:7 - ATR period for dynamic trailing
input double TrailATRMultiplier = 2.0; // 1.0:4.0:0.5 - ATR multiplier for trail distance
input bool UsePositionManager = true;
input int PMMaxOpenPositions = 10; // 3:20:1 - Max concurrent positions
input bool NoConstraintsMode = true;
// ===================[ GATING/INSIGHTS ]===================
input bool UseInsightsGating = true;
input int GateMinTrades = 0;
input double GateMinWinRate = 0.00;
input double GateMinExpectancyR = -10.0;
input double GateMaxDrawdownR = 1000000.0;
input double GateMinProfitFactor = 0.00;
input bool InsightsAutoBuild = true;
input int InsightsStaleHours = 48;
input int InsightsMinSourceAdvanceHours = 48;
input int InsightsMinIntervalHours = 24;
input bool InsightsCheckOnTimer = true;
input int InsightsRebuildTimeoutMs = 1800000;
input bool ExploreOnNoSlice = true;
input int ExploreMaxPerSlice = 100;
input int ExploreMaxPerSlicePerDay = 100;
// ===================[ STRATEGY SELECTOR ]===================
input bool UseStrategySelector = true;
input double SelW_PF = 1.0; // 0.5:2.0:0.25 - Profit factor selection weight
input double SelW_Exp = 1.0; // 0.5:2.0:0.25 - Expectancy selection weight
input double SelW_WR = 0.5; // 0.2:1.5:0.15 - Win rate selection weight
input double SelW_DD = 0.3; // 0.1:1.0:0.1 - Drawdown selection weight
input bool SelStrictThresholds = false; // 0:1:1 - Use strict vs probabilistic thresholds
input bool SelUseRecency = true; // 0:1:1 - Weight recent performance more heavily
input int SelRecentDays = 14; // 7:30:7 - Recent performance lookback days
input double SelRecAlpha = 0.5; // 0.3:0.8:0.1 - Recency weighting decay factor
input int GateAuditMinSignals = 5; // Minimum signals per audit window before alerting
input int GateAuditMinUptimeMin = 60; // Grace period (minutes) after initialization
input int GateAuditAlertCooldownMin = 60; // Cooldown between repeated alerts
// ===================[ ADVANCED GATING/TUNING ]===================
input bool P5_AutoDisableEnable = true; // 0:1:1 - Auto-disable underperforming strategies
input double P5_MinPF_Input = 1.20; // 1.10:1.50:0.10 - Minimum profit factor threshold (user initial)
input double P5_MinWR_Input = 0.45; // 0.40:0.60:0.05 - Minimum win rate threshold (user initial)
input double P5_MinExpR = -0.05; // -0.20:0.10:0.05 - Minimum expectancy R threshold
// Modifiable runtime gating thresholds (auto-adapted by ML)
double P5_MinPF = 1.20;
double P5_MinWR = 0.45;
input int P5_AutoDisableCooldownM = 1440; // 720:2880:360 - Cooldown minutes before re-enable
input bool P5_AutoReenable = true; // 0:1:1 - Auto-reenable after cooldown
input bool P5_AutoTuneEnable = true; // 0:1:1 - Auto-tune strategy parameters
input int P5_AutoTuneEveryMin = 60; // 30:240:30 - Auto-tune interval minutes
input bool P5_TimerRescoreEnable = true; // 0:1:1 - Enable periodic rescoring
input int P5_TimerRescoreEveryMin = 60; // 30:240:30 - Rescoring interval minutes
input bool P5_CorrPruneEnable = true; // 0:1:1 - Enable correlation pruning
input double P5_CorrMax = 0.80; // 0.70:0.95:0.05 - Max correlation threshold
input int P5_CorrLookbackDays = 30; // 14:90:14 - Correlation lookback period
input bool P5_MTFConfirmEnable = true; // 0:1:1 - Enable multi-timeframe confirmation
input string P5_MTFHigherTFs = "H1,H4"; // Fixed: H1,H4,H1+D1 - Multi-timeframe pairs
input int P5_MTFMinAgree = 1; // 1:3:1 - Minimum MTF confirmations required
input bool P5_StabilityGateEnable = false; // 0:1:1 - Enable stability filtering
input int P5_StabilityWindowDays = 14; // 7:30:7 - Stability assessment window
input double P5_StabilityMaxStdR = 1.00; // 0.5:2.0:0.25 - Max standard deviation R for stability
input bool P5_PersistLossCounters = false; // 0:1:1 - Persist loss counters across sessions
input bool P5_PickBestEnable = false; // 0:1:1 - Enable best strategy selection mode
// ===================[ RISK MANAGEMENT ]===================
input int MaxOpenPositions = 0;
input bool GuardsEnabled = true;
input double GuardMaxSpreadPoints = 0.0;
input bool ATRRegimeEnable = false;
input int ATRRegimePeriod = 14;
input int ATRRegimeLookback = 500;
input double ATRMinPercentile = 0.0;
input double ATRMaxPercentile = 100.0;
input double ATRRegimeMinATRPct = 0.0;
input double ATRRegimeMaxATRPct = 1000.0;
input bool UseCircuitBreakers = true; // ENABLED for safety
input double CBDailyLossLimitPct_Input = 5.0; // 2.0:10.0:1.0 - Daily loss circuit breaker % (user initial)
input double CBDrawdownLimitPct = 10.0; // 5.0:20.0:2.5 - Drawdown circuit breaker %
input int CBCooldownMinutes = 60; // 30:180:30 - Circuit breaker cooldown period
// Modifiable runtime circuit breaker (auto-adapted by ML)
double CBDailyLossLimitPct = 5.0;
// ===================[ NEWS & SESSION FILTERING ]===================
input bool UseNewsFilter = true;
input int NewsBufferBeforeMin = 30; // 15:120:15 - News buffer before events (minutes)
input int NewsBufferAfterMin = 30; // 15:120:15 - News buffer after events (minutes)
input int NewsImpactMin = 2; // 1:5:1 - Minimum news impact level to filter
input bool NewsUseFile = true;
input string NewsFileRelPath = "DualEA\\news_blackouts.csv";
input bool UsePromotionGate = false;
input bool PromoLiveOnly = false;
input int PromoStartHour = 0;
input int PromoEndHour = 24;
input bool UseRegimeGate = true; // ENABLED for adaptive parameters
input int RegimeATRPeriod = 14;
input double RegimeMinATRPct = 0.5; // Low volatility threshold
input double RegimeMaxATRPct = 2.5; // High volatility threshold
input bool RegimeTagTelemetry = true; // Track regime in telemetry
input string RegimeMethod = "combined"; // Use ATR + ADX
input int RegimeADXPeriod = 14;
input double RegimeADXTrendThreshold = 25.0;
input int RegimeStrongTrendThreshold = 35.0;
input double RegimeVolatilityHigh = 75.0;
input double RegimeVolatilityLow = 25.0;
input int CircuitCooldownSec = 0;
// ===================[ SESSION & CORRELATION MANAGEMENT ]===================
input bool UseSessionManager = true;
input int SessionEndHour = 20; // 0:23:1 - Session end hour
input int MaxTradesPerSession = 10; // 3:25:2 - Maximum trades per session
input int SessionTZOffsetMinutes= 0; // -720:720:60 - Session timezone offset (minutes)
input string SessionWindowsSpec = "";
input bool UseCorrelationManager = true;
input double MaxCorrelationLimit = 0.7; // 0.5:0.9:0.05 - Max allowed position correlation
input int CorrLookbackDays = 30; // 7:90:7 - Correlation lookback period (days) // 7:90:7 - Correlation lookback period (days)
input bool UseVolatilitySizer = true;
input int VolSizerATRPeriod = 14; // 7:28:7 - ATR period for volatility sizing
input double VolSizerBaseATRPct = 1.0;
input double VolSizerMinMult = 0.1; // 0.05:0.5:0.05 - Min position size multiplier
input double VolSizerMaxMult = 3.0; // 1.5:5.0:0.5 - Max position size multiplier
input double VolSizerTargetRisk_Input = 1.0; // 0.5:3.0:0.25 - Target risk per trade % (user initial)
// Modifiable runtime risk sizing (auto-adapted by universal detector)
double VolSizerTargetRisk = 1.0;
// ===================[ POLICY ENGINE ]===================
input bool UsePolicyGating = true;
input bool DefaultPolicyFallback = true;
input bool FallbackDemoOnly = true;
input bool FallbackWhenNoPolicy = true;
input bool UsePolicyEngine = true; // ENABLED for ML optimization
input string PolicyServerUrl = "http://127.0.0.1:8000";
input string PolicyFilePath = "DualEA\\policy.json";
input int PolicyHttpPollPercent = 70;
input int HotReloadIntervalSec = 10;
input string ConfigFilePath = "DualEA\\config\\nuclear_config.json";
// ===================[ TRADING HOURS & SESSIONS ]===================
input bool UseTradingHours = false; // 0:1:1 - Enable trading hours filtering
input int TradingStartHour = 7; // 0:23:1 - Trading session start hour
input int TradingEndHour = 20; // 0:23:1 - Trading session end hour
// ===================[ TELEMETRY & LOGGING ]===================
input bool TelemetryEnabled = true;
input int TelemetryLevel = 1;
input string TelemetryExperiment = "";
input int TelemetryBufferMax = 256;
input string TelemetryDir = "DualEA\\telemetry";
input bool GateLogThrottleEnabled = true;
input int GateLogCooldownSec = 30;
input int TelemetryFlushIntervalSec = 0;
input int Verbosity = 1;
// ===================[ ADAPTIVE PARAMETER ENGINE ]===================
input bool AutoDetectParameters = true; // Enable smart parameter detection
input string RiskProfile = "MODERATE"; // CONSERVATIVE, MODERATE, AGGRESSIVE, AUTO
input bool EnableMLAdaptation = true; // Enable machine learning parameter adaptation
input int AdaptationIntervalMinutes = 60; // Hourly adaptation frequency
input bool AllowManualOverride = true; // Allow manual parameter override
// ===================[ ADDITIONAL RISK CONTROLS ]===================
input double SpreadMaxPoints = 0.0;
input int SessionStartHour = 0;
input int SessionMaxTrades = 0;
input int MaxTradesPerBar = 0;
input int PaperAggroLevel = 50;
input double MaxDailyLossPct = 0.0;
input double MaxDrawdownPct = 0.0;
input double MinMarginLevel = 0.0;
input int ConsecutiveLossLimit = 0;
input int GlobalSL_Points = 500; // 200:1000:100 - Global stop loss points
input int GlobalTP_Points = 1000; // 400:2000:200 - Global take profit points
// ===================[ DEBUG & DEVELOPMENT ]===================
input bool DebugTrailing = false;
input bool KBDebugInit = true;
input bool TrainerLSTM_Enable = false;
input int TrainerLSTM_MinSeq = 50;
input int TrainerLSTM_MaxSeq = 500;
input bool TrainerLSTM_UseRecency = true;
input bool HeartbeatEnabled = true;
input int HeartbeatMinutes = 15;
input bool HeartbeatVerbose = true;
// ===================[ ONNX RUNTIME PREDICTOR INPUTS ]===================
input bool UseOnnxPredictor = true;
input string OnnxModelPath = "DualEA\\signal_model.onnx";
input string OnnxConfigJsonPath = "DualEA\\onnx_config.json";
input string OnnxConfigIniPath = "DualEA\\onnx_config.ini";
input bool OnnxPathsUseCommonDir = true;
// ===================[ LEGACY GATE PARAMETERS ]===================
#include "AdaptiveEngine.mqh"
// Global adaptive engines
CAdaptiveEngine g_adaptive_engine;
CMLAdaptationEngine g_ml_engine;
// CGateAudit g_gate_audit defined in CGateAudit.mqh - do not redefine
input bool UseGateSystem = true;
input string LearningDataPath = "DualEA\\PaperData"; // Relative to Common Files (Strategy Tester compatible)
input int MaxLearningRecords = 10000;
// ===================[ TRADE FREQUENCY GATING ]===================
input int PaperTradeCooldownSec = 900; // 15 min default
//+------------------------------------------------------------------+
//| STRUCTURES |
//+------------------------------------------------------------------+
// TradingSignal struct is defined in GateManager.mqh
//+------------------------------------------------------------------+
//| GLOBAL STATE - COMPREHENSIVE SYSTEM VARIABLES |
//+------------------------------------------------------------------+
// ===================[ CORE SYSTEM MANAGERS ]===================
CLearningBridge *g_learning_bridge = NULL;
// NEW: Efficient Gate Manager replaces old CGateManager
CEfficientGateManager *g_gate_manager = NULL;
CTradeManager *g_trade_manager = NULL;
CTelemetryStandard *g_telemetry = NULL;
CStrategySignalRegistry *g_signal_registry = NULL; // Extensible strategy signal generators
CIncrementalInsightEngine* g_insight_engine = NULL; // Definition for extern in IncrementalInsightEngine.mqh
// g_paper_positions removed - using REAL MT5 positions via PositionSelect()
// ===================[ DYNAMIC PARAMETER ENGINE ]===================
// NOTE: CalculateDynamicParameters() is now a method in CAdaptiveEngine class (AdaptiveEngine.mqh)
// No standalone function needed - use g_adaptive_engine.CalculateDynamicParameters() instead
struct AdaptiveParams {
double base_sl_mult;
double base_tp_mult;
double risk_multiplier;
double volatility_factor;
double spread_factor;
double timeframe_factor;
double ml_adjustment;
};
AdaptiveParams g_adaptive;
double g_current_atr = 0.0;
double g_current_spread = 0.0;
datetime g_last_adaptation = 0;
// ===================[ TIMER/COOLDOWN FOR TRADE FREQUENCY GATING ]===================
static datetime last_paper_trade_time = 0;
static int last_processed_minute = -1;
// ===================[ PENDING ORDERS/DEALS TRACKING FOR EVENT HANDLERS ]===================
ulong g_pending_orders[];
string g_pending_orders_strat[];
ulong g_pending_deals[];
string g_pending_deals_strat[];
// ===================[ TRACKED POSITIONS FOR ANALYTICS/CLOSURE ]===================
ulong g_pos_ids[];
string g_pos_strats[];
double g_pos_entry_price[];
double g_pos_initial_risk[];
datetime g_pos_start_time[];
int g_pos_type[];
double g_pos_max_price[];
double g_pos_min_price[];
// ===================[ NEWS BLACKOUT CACHE ]===================
string g_news_key[];
datetime g_news_from[];
datetime g_news_to[];
int g_news_impact[];
// ===================[ SESSION AND RISK STATE ]===================
datetime g_session_start = 0;
int g_session_day = 0;
double g_session_equity_start = 0.0;
double g_equity_highwater = 0.0;
// ===================[ CIRCUIT BREAKER STATE ]===================
bool g_cb_active = false;
datetime g_cb_trigger_time = 0;
string g_cb_last_cause = "";
double g_cb_last_threshold = 0.0;
double g_cb_last_value = 0.0;
// ===================[ TELEMETRY, GATING, AND SELECTOR STATE ]===================
string g_gate_log_keys[];
datetime g_gate_log_last_ts[];
// ===================[ GATING/INSIGHTS/SELECTOR ARRAYS ]===================
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 CACHE ]===================
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[];
int g_policy_last_len = -1;
int g_config_last_len = -1;
// ===================[ EXPLORATION TRACKING ]===================
string g_exp_keys[];
int g_exp_weeks[];
int g_exp_counts[];
string g_explore_pending_key = "";
string g_exp_day_keys[];
int g_exp_day_days[];
int g_exp_day_counts[];
// ===================[ LOSS COUNTERS ]===================
string g_loss_sym[];
long g_loss_mag[];
int g_loss_cnt[];
// ===================[ TELEMETRY POINTERS ]===================
CTelemetryStandard* g_tel_standard = NULL;
CSessionManager* g_session_manager = NULL;
CCorrelationManager* g_correlation_manager = NULL;
CVolatilitySizer* g_volatility_sizer = NULL;
CPolicyEngine* g_policy_engine = NULL;
CInsightsRealtime* g_ins_rt = NULL;
// Policy bridge for file-change detection
CPolicyHttpBridge* g_policy_bridge = NULL;
// ===================[ ADAPTIVE OPTIMIZATION SYSTEM ]===================
CAdaptiveSignalOptimizer* g_adaptive_optimizer = NULL;
CPolicyUpdater* g_policy_updater = NULL;
CPositionReviewer* g_position_reviewer = NULL;
CGateLearningSystem* g_gate_learning = NULL;
CUnifiedTradeLogger* g_trade_logger = NULL;
CAdvancedRegimeDetector* g_regime_detector = NULL;
// ===================[ NUCLEAR-GRADE 100-LEVEL OPTIMIZATION ]===================
COptimizedCorrelationEngine* g_nuclear_correlation = NULL;
CRiskMetricsCalculator* g_risk_metrics = NULL;
CKellyPositionSizer* g_kelly_sizer = NULL;
CConfigurationManager* g_config_manager = NULL;
CPolicyStateManager* g_policy_state = NULL;
CRingBuffer* g_log_queue = NULL;
// ===================[ SELECTOR, POSITION MANAGER, FEATURES LOGGER, KNOWLEDGE BASE, TRADE MANAGER ]===================
CStrategySelector* g_selector = NULL;
CPositionManager* g_position_manager = NULL; // Definition for extern in CPositionManager.mqh
CFeaturesKB* g_features = NULL;
CKnowledgeBase* g_kb = NULL;
CTelemetry* g_telemetry_base = NULL;
CModelPredictor g_model_predictor;
bool g_model_predictor_ready = false;
string g_mlp_feature_columns[];
double g_mlp_feature_buffer[];
bool g_mlp_warned_unready = false;
bool g_mlp_warned_features = false;
// ===================[ ONNX PREDICTOR HELPERS ]===================
// Define ENUM_STATISTICS values if not already defined (for TesterStatistics compatibility)
#ifndef STAT_BALANCE_DDREL_PERCENT
#define STAT_BALANCE_DDREL_PERCENT 0
#define STAT_SHARPE_RATIO 1
#define STAT_TRADES_WIN 2
#define STAT_TRADES_LOSS 3
#define STAT_TRADES_TOTAL 4
#endif
string ResolveDualEAPath(const string relative_path, const bool prefer_common)
{
string trimmed = relative_path;
StringTrimLeft(trimmed);
StringTrimRight(trimmed);
if(StringLen(trimmed) == 0)
return "";
if(StringFind(trimmed, ":\\") >= 0 || StringSubstr(trimmed, 0, 2) == "\\\\")
return trimmed;
if(prefer_common)
return TerminalInfoString(TERMINAL_COMMONDATA_PATH) + "\\Files\\" + trimmed;
return trimmed;
}
double SafeDivision(const double numerator, const double denominator)
{
if(MathAbs(denominator) < 1e-9)
return 0.0;
return numerator / denominator;
}
int CsvCountTokens(const string csv)
{
string tmp = csv;
StringTrimLeft(tmp);
StringTrimRight(tmp);
if(StringLen(tmp) == 0)
return 0;
string parts[];
int count = StringSplit(tmp, ',', parts);
int cleaned = 0;
for(int i = 0; i < count; i++)
{
string s = parts[i];
StringTrimLeft(s);
StringTrimRight(s);
if(StringLen(s) == 0)
continue;
cleaned++;
}
return cleaned;
}
bool CsvContainsToken(const string &haystack_csv, const string &token)
{
string tmp = haystack_csv;
StringTrimLeft(tmp);
StringTrimRight(tmp);
if(StringLen(tmp) == 0)
return false;
string parts[];
int count = StringSplit(tmp, ',', parts);
for(int i = 0; i < count; i++)
{
string s = parts[i];
StringTrimLeft(s);
StringTrimRight(s);
if(s == token)
return true;
}
return false;
}
string CsvMergeUnique(const string &base_csv, const string &extra_csv)
{
string base = base_csv;
StringTrimLeft(base);
StringTrimRight(base);
string extra = extra_csv;
StringTrimLeft(extra);
StringTrimRight(extra);
string result = base;
if(StringLen(extra) == 0)
return result;
string tokens[];
int count = StringSplit(extra, ',', tokens);
for(int i = 0; i < count; i++)
{
string s = tokens[i];
StringTrimLeft(s);
StringTrimRight(s);
if(StringLen(s) == 0)
continue;
if(StringLen(result) == 0)
{
result = s;
continue;
}
if(!CsvContainsToken(result, s))
result += "," + s;
}
return result;
}
void ShutdownModelPredictor()
{
if(g_model_predictor_ready)
{
g_model_predictor.Shutdown();
g_model_predictor_ready = false;
LOG("ONNX predictor shut down");
}
ArrayResize(g_mlp_feature_columns, 0);
ArrayResize(g_mlp_feature_buffer, 0);
}
bool BuildPredictorFeatureVector(const TradingSignal &signal,
const string &strategy_name,
const CAdaptiveDecision *decision_ptr,
const string &status,
const string &reason,
const datetime ts,
double &buffer[])
{
int feat_count = ArraySize(g_mlp_feature_columns);
if(feat_count == 0)
return false;
ArrayResize(buffer, feat_count);
string resolved_symbol = (signal.symbol != "") ? signal.symbol : _Symbol;
string resolved_strategy = (strategy_name != "") ? strategy_name : signal.strategy;
string resolved_regime = signal.regime;
if(resolved_regime == "")
resolved_regime = GetMarketRegime();
string resolved_market_regime = (signal.market_regime != "") ? signal.market_regime : resolved_regime;
string normalized_status = status;
StringToLower(normalized_status);
string normalized_reason = reason;
StringToLower(normalized_reason);
double base_price = (signal.price != 0.0) ? signal.price : SymbolInfoDouble(_Symbol, SYMBOL_BID);
double base_volume = (signal.volume != 0.0) ? signal.volume : LotSize;
double base_sl = (signal.sl != 0.0) ? signal.sl : base_price;
double base_tp = (signal.tp != 0.0) ? signal.tp : base_price;
double final_price = base_price;
double final_volume = base_volume;
double final_sl = base_sl;
double final_tp = base_tp;
bool executed = false;
bool is_adjusted = false;
int adjustment_attempts = 0;
int gate_passed = 0;
double gate_pass_flags[8];
ArrayInitialize(gate_pass_flags, 0.0);
double volume_delta_pct = 0.0;
double price_delta_pct = 0.0;
double sl_scale = 1.0;
double tp_scale = 1.0;
if(CheckPointer(decision_ptr) != POINTER_INVALID)
{
const CAdaptiveDecision *decision = decision_ptr;
final_price = (decision.final_price != 0.0) ? decision.final_price : final_price;
final_volume = (decision.final_volume != 0.0) ? decision.final_volume : final_volume;
final_sl = (decision.final_sl != 0.0) ? decision.final_sl : final_sl;
final_tp = (decision.final_tp != 0.0) ? decision.final_tp : final_tp;
executed = decision.executed;
is_adjusted = decision.is_adjusted;
adjustment_attempts = decision.adjustment_attempts;
gate_passed = CountPassedGates(*decision);
for(int gi = 0; gi < 8; gi++)
gate_pass_flags[gi] = decision.gate_results[gi] ? 1.0 : 0.0;
volume_delta_pct = SafeDivision(final_volume - decision.original_volume, decision.original_volume) * 100.0;
price_delta_pct = SafeDivision(final_price - decision.original_price, decision.original_price) * 100.0;
sl_scale = SafeDivision(final_sl, decision.original_sl == 0.0 ? final_sl : decision.original_sl);
tp_scale = SafeDivision(final_tp, decision.original_tp == 0.0 ? final_tp : decision.original_tp);
}
if(!MathIsValidNumber(sl_scale) || sl_scale == 0.0) sl_scale = 1.0;
if(!MathIsValidNumber(tp_scale) || tp_scale == 0.0) tp_scale = 1.0;
MqlDateTime mt;
TimeToStruct(ts, mt);
int hour_value = mt.hour;
int timeframe_value = (signal.timeframe != 0) ? signal.timeframe : _Period;
double volatility_value = (signal.volatility != 0.0) ? signal.volatility : GetVolatility(_Symbol, (ENUM_TIMEFRAMES)_Period);
double correlation_value = (signal.correlation != 0.0) ? signal.correlation : GetCorrelation();
double confidence_value = signal.confidence;
if(confidence_value <= 0.0 || confidence_value > 1.0)
confidence_value = 0.5;
for(int i = 0; i < feat_count; i++)
{
string col = g_mlp_feature_columns[i];
double value = 0.0;
if(col == "price") value = final_price;
else if(col == "volume") value = final_volume;
else if(col == "sl") value = final_sl;
else if(col == "tp") value = final_tp;
else if(col == "confidence") value = confidence_value;
else if(col == "volatility") value = volatility_value;
else if(col == "correlation") value = correlation_value;
else if(col == "hour") value = hour_value;
else if(col == "timeframe") value = timeframe_value;
else if(col == "order_type") value = signal.type;
else if(col == "gate_passed_count") value = gate_passed;
else if(col == "adjustment_attempts") value = adjustment_attempts;
else if(col == "volume_change_pct") value = volume_delta_pct;
else if(col == "price_change_pct") value = price_delta_pct;
else if(col == "sl_scale") value = sl_scale;
else if(col == "tp_scale") value = tp_scale;
else if(col == "executed") value = executed ? 1.0 : 0.0;
else if(col == "is_adjusted") value = is_adjusted ? 1.0 : 0.0;
else if(StringSubstr(col, 0, 4) == "gate" && StringFind(col, "_pass") > 0)
{
int pass_pos = StringFind(col, "_pass");
int gate_index = -1;
if(pass_pos > 4)
{
int length = (int)(pass_pos - 4);
string gate_token = StringSubstr(col, 4, length);
gate_index = (int)StringToInteger(gate_token) - 1;
}
if(gate_index >= 0 && gate_index < 8)
value = gate_pass_flags[gate_index];
}
else if(col == "strategy_code" || col == "symbol_code" || col == "status_code" ||
col == "regime_code" || col == "market_regime_code" || col == "reason_code")
{
string field = "";
string label = "";
if(col == "strategy_code") { field = "strategy"; label = resolved_strategy; }
else if(col == "symbol_code") { field = "symbol"; label = resolved_symbol; }
else if(col == "status_code") { field = "status"; label = normalized_status; }
else if(col == "regime_code") { field = "regime"; label = resolved_regime; }
else if(col == "market_regime_code") { field = "market_regime"; label = resolved_market_regime; }
else if(col == "reason_code") { field = "reason"; label = normalized_reason; }
value = g_model_predictor.EncodeCategorical(field, label);
}
buffer[i] = value;
}
return true;
}
void GateSanitizeTelemetryReporter(const string gate_name, TradingSignal &signal)
{
if(!TelemetryEnabled)
return;
if(CheckPointer(g_telemetry_base) == POINTER_INVALID)
return;
double base_price = MathMax(0.0001, MathAbs(signal.price));
double sl_gap = MathAbs(signal.price - signal.sl) / base_price;
double tp_gap = MathAbs(signal.tp - signal.price) / base_price;
double severity = (sl_gap + tp_gap) * 0.5;
if(CheckPointer(g_gate_learning) != POINTER_INVALID)
{
// Note: RecordSanitizationEvent method not available - disabled
// g_gate_learning.RecordSanitizationEvent(gate_name, signal.price, signal.sl, signal.tp, signal.volume);
}
if(CheckPointer(g_tel_standard) != POINTER_INVALID)
{
g_tel_standard.LogGateSanitize((signal.symbol == "" ? _Symbol : signal.symbol),
(signal.timeframe != 0 ? signal.timeframe : _Period),
gate_name,
severity,
sl_gap,
tp_gap,
signal.volume);
return;
}
string details = StringFormat("gate=%s symbol=%s strategy=%s price=%.5f sl=%.5f tp=%.5f volume=%.2f",
gate_name,
(signal.symbol == "" ? _Symbol : signal.symbol),
(signal.strategy == "" ? "unknown" : signal.strategy),
signal.price, signal.sl, signal.tp, signal.volume);
g_telemetry_base.LogEvent(_Symbol, _Period, "gate_sanitize", "sanitized", details);
}
// Callback function pointer for gate sanitize telemetry
typedef void (*GateSanitizeCallback)(const string, TradingSignal&);
GateSanitizeCallback g_gate_sanitize_callback = NULL;
void SetGateSanitizeTelemetryCallback(GateSanitizeCallback callback)
{
g_gate_sanitize_callback = callback;
}
// P0-4: ONNX Health Monitoring - Latency tracking and degradation detection
struct SONNXHealthMetrics
{
ulong total_calls;
ulong total_latency_ms;
ulong max_latency_ms;
ulong min_latency_ms;
ulong failed_calls;
ulong slow_calls; // Calls > 100ms threshold
datetime last_failure;
double avg_latency_ms;
bool healthy;
void Init()
{
total_calls = 0;
total_latency_ms = 0;
max_latency_ms = 0;
min_latency_ms = ULONG_MAX;
failed_calls = 0;
slow_calls = 0;
last_failure = 0;
avg_latency_ms = 0.0;
healthy = true;
}
void RecordLatency(ulong latency_ms, bool success)
{
total_calls++;
if(success)
{
total_latency_ms += latency_ms;
max_latency_ms = MathMax(max_latency_ms, latency_ms);
min_latency_ms = MathMin(min_latency_ms, latency_ms);
avg_latency_ms = (double)total_latency_ms / total_calls;
// P0-4: Flag slow calls (>100ms threshold per MT5 Build 5572 guidelines)
if(latency_ms > 100)
{
slow_calls++;
}
}
else
{
failed_calls++;
last_failure = TimeCurrent();
}
// P0-4: Health check - degrade if >5% failures or >20% slow calls
double failure_rate = (double)failed_calls / total_calls;
double slow_rate = (double)slow_calls / total_calls;
healthy = (failure_rate < 0.05) && (slow_rate < 0.20);
}
double GetFailureRate() { return total_calls > 0 ? (double)failed_calls / total_calls : 0.0; }
double GetSlowRate() { return total_calls > 0 ? (double)slow_calls / total_calls : 0.0; }
};
SONNXHealthMetrics g_onnx_health;
bool g_onnx_health_initialized = false;
input int ONNX_MaxLatencyMs = 100; // P0-4: Max acceptable ONNX latency
input bool ONNX_EnableHealthMonitor = true; // P0-4: Enable health monitoring
// P0-4: Heuristic confidence calculation as ONNX fallback
double CalculateHeuristicConfidence(const TradingSignal &signal)
{
double confidence = 0.5; // Neutral baseline
// Adjust based on signal strength indicators
if(signal.volatility > 0)
{
// Lower confidence in high volatility
confidence -= MathMin(0.15, signal.volatility * 0.5);
}
// Boost confidence if signal has good structure
if(signal.price > 0 && signal.sl > 0 && signal.tp > 0)
{
double sl_dist = MathAbs(signal.price - signal.sl);
double tp_dist = MathAbs(signal.tp - signal.price);
if(tp_dist > sl_dist) // Favorable R:R
{
confidence += 0.1;
}
}
// Ensure bounds
confidence = MathMax(0.3, MathMin(0.7, confidence));
return confidence;
}
// Alias for backward compatibility
double HeuristicConfidence(const TradingSignal &signal)
{
return CalculateHeuristicConfidence(signal);
}
// P0-4: Health-aware model evaluation with latency guardrails
double EvaluateModelProbabilityWithHealth(const TradingSignal &signal,
const string strategy_name,
const CAdaptiveDecision *decision_ptr,
const string status,
const string reason)
{
if(!g_onnx_health_initialized)
{
g_onnx_health.Init();
g_onnx_health_initialized = true;
}
if(!UseOnnxPredictor || !g_model_predictor_ready)
{
if(ONNX_EnableHealthMonitor)
{
g_onnx_health.RecordLatency(0, false);
}
return -1.0;
}
// P0-4: Check health before attempting inference
if(ONNX_EnableHealthMonitor && !g_onnx_health.healthy)
{
static datetime last_health_warning = 0;
if(TimeCurrent() - last_health_warning > 300) // Warn every 5 minutes
{
LOG(StringFormat("[P0-4] ONNX health degraded (fail=%.1f%% slow=%.1f%%), using heuristic fallback",
g_onnx_health.GetFailureRate()*100, g_onnx_health.GetSlowRate()*100));
last_health_warning = TimeCurrent();
}
return -2.0; // Signal to use heuristic fallback
}
// P0-4: Track latency
ulong start_time = GetTickCount();
double result = EvaluateModelProbability(signal, strategy_name, decision_ptr, status, reason);
ulong latency_ms = GetTickCount() - start_time;
// P0-4: Record metrics
if(ONNX_EnableHealthMonitor)
{
bool success = (result >= 0.0);
g_onnx_health.RecordLatency(latency_ms, success);
// P0-4: Log slow calls
if(latency_ms > (ulong)ONNX_MaxLatencyMs)
{
static int slow_call_count = 0;
slow_call_count++;
if(slow_call_count <= 10 || slow_call_count % 100 == 0)
{
LOG(StringFormat("[P0-4] ONNX slow inference: %I64ums (threshold: %dms) - count: %d",
latency_ms, ONNX_MaxLatencyMs, slow_call_count));
}
}
}
return result;
}
double EvaluateModelProbability(const TradingSignal &signal,
const string strategy_name,
const CAdaptiveDecision *decision_ptr,
const string status,
const string reason)
{
if(!UseOnnxPredictor || !g_model_predictor_ready)
return -1.0;
if(ArraySize(g_mlp_feature_columns) == 0)
return -1.0;
bool telemetry_ready = TelemetryEnabled && CheckPointer(g_telemetry_base) != POINTER_INVALID;
string phase = status;
if(StringLen(reason) > 0)
phase += ":" + reason;
datetime now = TimeCurrent();
if(!BuildPredictorFeatureVector(signal, strategy_name, decision_ptr, status, reason, now, g_mlp_feature_buffer))
{
if(!g_mlp_warned_features)
{
LOG("WARNING: Unable to build ML predictor feature vector (metadata mismatch)");
g_mlp_warned_features = true;
}
if(telemetry_ready)
{
string details = StringFormat("phase=%s outcome=feature_build_failed strategy=%s", phase, strategy_name);
g_telemetry_base.LogEvent(_Symbol, _Period, "ml_eval", "failed", details);
}
return -1.0;
}
double probability = g_model_predictor.Predict(g_mlp_feature_buffer, ArraySize(g_mlp_feature_buffer));
if(telemetry_ready)
{
string details = StringFormat("phase=%s prob=%.4f strategy=%s", phase, probability, strategy_name);
g_telemetry_base.LogEvent(_Symbol, _Period, "ml_eval", "completed", details);
}
return probability;
}
bool InitModelPredictor()
{
ArrayResize(g_mlp_feature_columns, 0);
ArrayResize(g_mlp_feature_buffer, 0);
g_mlp_warned_unready = false;
g_mlp_warned_features = false;
// Resolve paths for the DLL (absolute OS paths). Do not use these with FileIsExist/FileOpen.
string model_path = ResolveDualEAPath(OnnxModelPath, OnnxPathsUseCommonDir);
string json_path = ResolveDualEAPath(OnnxConfigJsonPath, OnnxPathsUseCommonDir);
string ini_path = ResolveDualEAPath(OnnxConfigIniPath, OnnxPathsUseCommonDir);
LOG(StringFormat("ONNX Model Path: %s", model_path));
LOG(StringFormat("ONNX JSON Path: %s", json_path));
LOG(StringFormat("ONNX INI Path: %s", ini_path));
if(StringLen(model_path) == 0 || StringLen(json_path) == 0 || StringLen(ini_path) == 0)
{
LOG("WARNING: ONNX predictor paths are not configured correctly");
return false;
}
int common_flag = OnnxPathsUseCommonDir ? FILE_COMMON : 0;
int h_model = FileOpen(OnnxModelPath, FILE_READ|FILE_BIN|common_flag);
if(h_model == INVALID_HANDLE)
{
LOG(StringFormat("ERROR: Model file not found in %s Files: %s (error=%d)", (OnnxPathsUseCommonDir ? "Common" : "Terminal"), OnnxModelPath, GetLastError()));
return false;
}
FileClose(h_model);
int h_ini = FileOpen(OnnxConfigIniPath, FILE_READ|FILE_TXT|common_flag);
if(h_ini == INVALID_HANDLE)
{
LOG(StringFormat("ERROR: Config INI file not found in %s Files: %s (error=%d)", (OnnxPathsUseCommonDir ? "Common" : "Terminal"), OnnxConfigIniPath, GetLastError()));
return false;
}
FileClose(h_ini);
int h_json = FileOpen(OnnxConfigJsonPath, FILE_READ|FILE_TXT|common_flag);
if(h_json == INVALID_HANDLE)
{
LOG(StringFormat("WARNING: Config JSON file not found in %s Files: %s (error=%d)", (OnnxPathsUseCommonDir ? "Common" : "Terminal"), OnnxConfigJsonPath, GetLastError()));
}
else
{
FileClose(h_json);
}
LOG(StringFormat("Initializing ONNX predictor with model: %s", model_path));
if(!g_model_predictor.Init(model_path, json_path, ini_path))
{
LOG(StringFormat("WARNING: ONNX predictor init failed - %s", g_model_predictor.LastError()));
return false;
}
if(!g_model_predictor.GetFeatureNames(g_mlp_feature_columns) || ArraySize(g_mlp_feature_columns) == 0)
{
LOG("WARNING: ONNX predictor did not return feature metadata; shutting down");
g_model_predictor.Shutdown();
return false;
}
ArrayResize(g_mlp_feature_buffer, ArraySize(g_mlp_feature_columns));
LOG(StringFormat("ONNX predictor ready (%d features)", ArraySize(g_mlp_feature_columns)));
return true;
}
// ===================[ STRATEGIES CONTAINER AND ADDITIONAL MISSING GLOBALS ]===================
CArrayObj* g_strategies = NULL;
bool g_insights_rebuild_in_progress = false;
datetime g_last_insights_rebuild_time = 0;
datetime g_p5_last_rescore_ts = 0;
// ===================[ INSIGHTS REBUILD TRACKING PER SLICE ]===================
string g_ir_slice_keys[];
datetime g_ir_slice_times[];
// ===================[ LOG LEVELS (ENUM AND CONSTANTS) ]===================
#undef LOG_DEBUG
#undef LOG_INFO
#undef LOG_WARNING
#undef LOG_ERROR
enum LogLevel { LOG_ERROR = 0, LOG_INFO = 1, LOG_DEBUG = 2 };
// ===================[ LAST PAPER ACTION TRACKING ]===================
static datetime g_last_paper_action = 0;
//+------------------------------------------------------------------+
//| EXPERT INITIALIZATION |
//+------------------------------------------------------------------+
int OnInit()
{
// ===================[ INSTANCE COLLISION DETECTION ]===================
// Check if another instance with same magic is already running on this chart
static bool g_instance_initialized = false;
if(g_instance_initialized)
{
LOG(StringFormat("⚠️ ERROR: Multiple PaperEA_v2 instances detected on %s %s with Magic %d",
_Symbol, EnumToString((ENUM_TIMEFRAMES)_Period), MagicNumber));
LOG(" This causes file contention and duplicate processing. Please use unique Magic numbers.");
return(INIT_FAILED);
}
g_instance_initialized = true;
// Initialize logging middleware
if(LogMiddleware == NULL)
{
LogMiddleware = new CLogMiddleware("DualEA\\system.log", true);
}
LOG("=== PaperEA v2 Enhanced Initialization Starting ===");
LOG(StringFormat("Instance ID: %s-%s-M%d", _Symbol, EnumToString((ENUM_TIMEFRAMES)_Period), MagicNumber));
// Seed RNG for rate-based polling and start 10s timer
MathSrand((int)TimeLocal());
if(HotReloadIntervalSec > 0) EventSetTimer(HotReloadIntervalSec);
// ===================[ INITIALIZE MODIFIABLE PARAMETERS ]===================
// Copy user input values to modifiable runtime variables
StopLossPips = StopLossPips_Input;
TakeProfitPips = TakeProfitPips_Input;
VolSizerTargetRisk = VolSizerTargetRisk_Input;
P5_MinPF = P5_MinPF_Input;
P5_MinWR = P5_MinWR_Input;
CBDailyLossLimitPct = CBDailyLossLimitPct_Input;
// ===================[ CORE SYSTEM INITIALIZATION ]===================
// Initialize base telemetry system first
g_telemetry_base = new CTelemetry();
if(CheckPointer(g_telemetry_base) == POINTER_INVALID)
{
LOG("ERROR: Failed to initialize base telemetry system");
return(INIT_FAILED);
}
// Initialize standard telemetry wrapper
g_tel_standard = new CTelemetryStandard(g_telemetry_base);
g_telemetry = g_tel_standard; // Maintain backward compatibility
SetGateSanitizeTelemetryCallback(GateSanitizeTelemetryReporter);
// Unified System: sync config + event bus + monitor
{
CConfigManager *cfg = CConfigManager::GetInstance();
if(CheckPointer(cfg) != POINTER_INVALID)
{
cfg.SetNoConstraintsMode(NoConstraintsMode);
cfg.SetVerboseLogging(Verbosity >= 2);
cfg.SetDataPath(LearningDataPath);
}
CEventBus *bus = CEventBus::GetInstance();
if(CheckPointer(bus) != POINTER_INVALID)
{
bus.SetVerboseLogging(cfg != NULL ? cfg.IsVerboseLogging() : (Verbosity >= 2));
bus.PublishSystemEvent("PaperEA_v2", "Unified system online");
}
CSystemMonitor *mon = CSystemMonitor::GetInstance();
if(CheckPointer(mon) == POINTER_INVALID) LOG("WARNING: SystemMonitor init failed");
}
// Initialize Knowledge Base for comprehensive logging
g_kb = new CKnowledgeBase();
if(CheckPointer(g_kb) == POINTER_INVALID)
{
LOG("ERROR: Failed to initialize Knowledge Base");
return(INIT_FAILED);
}
// Initialize Features KB for ML data export
g_features = new CFeaturesKB();
if(CheckPointer(g_features) == POINTER_INVALID)
{
LOG("WARNING: Failed to initialize Features KB - ML features disabled");
}
// Initialize ONNX predictor (optional)
if(UseOnnxPredictor)
{
g_model_predictor_ready = InitModelPredictor();
if(!g_model_predictor_ready)
{
LOG("WARNING: ONNX predictor init failed - heuristic confidence will be used");
}
}
else
{
ShutdownModelPredictor();
g_model_predictor_ready = false;
}
// ===================[ STRATEGY SYSTEM INITIALIZATION // ===================[ INITIALIZE STRATEGY REGISTRY ]===================
g_strategies = new CArrayObj();
if(g_strategies == NULL) {
LOG("Failed to initialize strategy array!");
return(INIT_FAILED);
}
// Initialize strategy selector
if(UseStrategySelector)
{
g_selector = new CStrategySelector();
if(CheckPointer(g_selector) == POINTER_INVALID)
{
LOG("WARNING: Failed to initialize Strategy Selector - using fallback selection");
}
else
{
// Configure selector weights
g_selector.ConfigureWeights(SelW_PF, SelW_Exp, SelW_WR, SelW_DD);
g_selector.ConfigureRecency(SelUseRecency, SelRecentDays, SelRecAlpha);
g_selector.SetStrictThresholds(SelStrictThresholds);
LOG("Strategy Selector initialized with custom weights");
// Initialize the complete strategy registry
bool registry_success = InitializeStrategyRegistry();
if(!registry_success)
{
LOG("WARNING: Strategy registry initialization failed - limited strategy selection available");
}
}
}
// ===================[ ADVANCED MANAGERS INITIALIZATION ]===================
// Initialize Session Manager
if(UseSessionManager)
{
g_session_manager = new CSessionManager(_Symbol, (ENUM_TIMEFRAMES)_Period);
if(CheckPointer(g_session_manager) != POINTER_INVALID)
{
g_session_manager.SetSessionHours(SessionStartHour, SessionEndHour);
g_session_manager.SetMaxTradesPerSession(MaxTradesPerSession);
LOG("Session Manager initialized");
}
}
// Initialize Correlation Manager
if(UseCorrelationManager)
{
g_correlation_manager = new CCorrelationManager(_Symbol, (ENUM_TIMEFRAMES)_Period);
if(CheckPointer(g_correlation_manager) != POINTER_INVALID)
{
g_correlation_manager.SetMaxCorrelation(MaxCorrelationLimit);
g_correlation_manager.SetLookbackDays(CorrLookbackDays);
LOG("Correlation Manager initialized");
}
}
// Initialize Volatility Sizer
if(UseVolatilitySizer)
{
g_volatility_sizer = new CVolatilitySizer(_Symbol, (ENUM_TIMEFRAMES)_Period);
if(CheckPointer(g_volatility_sizer) != POINTER_INVALID)
{
g_volatility_sizer.SetATRPeriod(VolSizerATRPeriod);
g_volatility_sizer.SetBaseATRPercent(VolSizerBaseATRPct);
g_volatility_sizer.SetMultiplierRange(VolSizerMinMult, VolSizerMaxMult);
g_volatility_sizer.SetTargetRiskPercent(VolSizerTargetRisk);
g_volatility_sizer.SetEnabled(true);
LOG("Volatility Sizer initialized");
}
}
// Initialize Position Manager
if(UsePositionManager)
{
g_position_manager = new CPositionManager();
if(CheckPointer(g_position_manager) != POINTER_INVALID)
{
// Position cap enforced via MaxOpenPositions gating inputs
LOG("Position Manager initialized");
}
}
// ===================[ EFFICIENT GATE SYSTEM CONFIGURATION ]===================
// Note: Input variables already declared at global scope (lines 82-95)
// Using existing GateProcessingMode, G5_PerformanceWaxEnabled, etc.
// Risk gates ALWAYS enforced (G1, G4, G7, G8) - per MQL5 risk management best practices
// Initialize Policy Engine
if(UsePolicyEngine || UsePolicyGating)
{
g_policy_engine = new CPolicyEngine();
if(CheckPointer(g_policy_engine) != POINTER_INVALID)
{
// Load initial policy
bool policy_loaded = Policy_Load();
if(policy_loaded)
LOG(StringFormat("Policy Engine initialized, policy loaded: YES (min_conf=%.2f)", g_policy_min_conf));
else
LOG("Policy Engine initialized, policy loaded: NO");
// Configure policy bridge for hot-reload
g_policy_bridge = new CPolicyHttpBridge();
if(CheckPointer(g_policy_bridge) != POINTER_INVALID)
{
int interval = (HotReloadIntervalSec>0? HotReloadIntervalSec : 60);
g_policy_bridge.Configure(PolicyFilePath, interval);
if(!g_policy_bridge.VerifyAccess(PolicyServerUrl))
{
LOG("WARNING: Policy HTTP endpoint not accessible yet. Follow the MT5 WebRequest instructions above to enable it.");
}
else if(ShouldLog(LOG_INFO))
{
LOG(StringFormat("Policy HTTP access verified for %s", PolicyServerUrl));
}
}
}
}
// Initialize Insights Realtime
g_ins_rt = new CInsightsRealtime();
if(CheckPointer(g_ins_rt) != POINTER_INVALID)
{
LOG("Insights Realtime initialized");
}
// ===================[ LEGACY SYSTEM INITIALIZATION ]===================
// Initialize learning bridge (maintain compatibility)
g_learning_bridge = new CLearningBridge(LearningDataPath, MaxLearningRecords);
if(CheckPointer(g_learning_bridge) == POINTER_INVALID)
{
LOG(StringFormat("WARNING: Failed to initialize Learning Bridge - learning features disabled for %s %s", _Symbol, EnumToString((ENUM_TIMEFRAMES)_Period)));
}
// Initialize gate manager with auto-learning (replaces old CGateManager)
if(UseEfficientGates)
{
// NEW: Enhanced gate system with shadow logging and auto-tuning
SAutoLearningConfig config;
config.Init();
config.shadow_mode = ShadowMode; // Set to true initially for data collection
config.load_onnx_models = LoadONNXModels;
config.auto_reload_models = AutoReloadModels;
config.auto_tune_gates = true;
config.retrain_interval_hours = RetrainIntervalHours;
g_gate_manager = new CEfficientGateManagerEnhanced(
NoConstraintsMode, // Properly respected now
UseInsightsGating, // Insights threshold checks
UsePolicyGating // ML policy filtering
);
// Initialize with shadow logging and auto-learning
if(CheckPointer(g_gate_manager) != POINTER_INVALID)
{
g_gate_manager.Initialize(config.shadow_mode);
// Set processing mode based on configuration
if(NoConstraintsMode)
g_gate_manager.SetMode(GATE_MODE_RISK_ONLY);
else
g_gate_manager.SetMode((EGateProcessingMode)GateProcessingMode);
// Configure G5 PerformanceWax with auto-tuning
if(G5_PerformanceWaxEnabled)
{
g_gate_manager.SetPerformanceWaxEnabled(true, G5_MinWinRate, G5_LookbackTrades);
// Enable auto-tuning for G5
SGateAutoTuneConfig tune_config;
tune_config.Init(0.3, 0.9, 20, 0.55, 0.05);
g_gate_manager.EnableAutoTune(5, tune_config);
}
// Configure G6 MLPolish with ONNX support
if(G6_MLPolishEnabled)
{
g_gate_manager.SetMLPolishEnabled(true, G6_MLConfidenceThreshold);
// Enable auto-tuning for G6
SGateAutoTuneConfig tune_config;
tune_config.Init(0.4, 0.8, 30, 0.55, 0.03);
g_gate_manager.EnableAutoTune(6, tune_config);
}
// Configure G7 LiveClean
if(G7_LiveCleanEnabled)
g_gate_manager.SetLiveCleanEnabled(true, G7_MaxSpreadPercent);
LOG("✅ Enhanced Gate System initialized (8-stage, shadow logging, auto-tuning, ONNX-ready)");
// Initialize auto-learning manager for model reloading
CAutoLearningManager auto_learning;
auto_learning.Initialize(g_gate_manager, config);
}
}
else
{
// LEGACY: Use old gate manager (deprecated)
LOG("WARNING: Using deprecated CGateManager - migrate to CEfficientGateManagerEnhanced");
// Note: CGateManager class has been removed - this branch should not be used
g_gate_manager = NULL;
}
if(CheckPointer(g_gate_manager) == POINTER_INVALID)
{
LOG(StringFormat("ERROR: Failed to initialize Gate Manager for %s %s", _Symbol, EnumToString((ENUM_TIMEFRAMES)_Period)));
LOG("ERROR: Failed to initialize Gate Manager");
return(INIT_FAILED);
}
// Initialize Strategy Signal Registry (extensible signal generators for all strategies)
g_signal_registry = new CStrategySignalRegistry();
if(CheckPointer(g_signal_registry) != POINTER_INVALID)
{
g_signal_registry.InitializeAllStrategies();
LOG(StringFormat("✅ Strategy Signal Registry initialized: %d generators registered", g_signal_registry.GetCount()));
}
else
{
LOG("WARNING: Failed to initialize Strategy Signal Registry - using fallback signal generation");
}
// ===================[ P0/P1 COMPREHENSIVE HARDENING INITIALIZATION ]===================
// Initialize the master controller with all P0/P1 components
{
SDualEAConfig master_config;
master_config.SetDefaults();
// Configure from EA inputs
master_config.shadow_logging_enabled = ShadowMode;
master_config.shadow_mode_only = ShadowMode && !LiveTradingEnabled;
master_config.sqlite_enabled = true;
master_config.circuit_breaker_enabled = UseCircuitBreakers;
master_config.correlation_sizing_enabled = UseCorrelationManager;
master_config.volatility_exits_enabled = UseVolatilitySizer;
master_config.max_risk_per_trade_pct = VolSizerTargetRisk;
master_config.max_positions = MaxOpenPositions;
master_config.redis_enabled = false; // Disabled by default
if(!InitializeDualEAMasterController(master_config))
{
LOG("WARNING: P0/P1 Master Controller initialization failed - some hardened features disabled");
}
else
{
LOG("✅ P0/P1 Master Controller initialized: All hardened systems active");
}
}
// Initialize gate audit system with all expected strategies (registry + extra paper strategies)
string fallback_all_strategies =
"ADXStrategy,AcceleratorOscillatorStrategy,AlligatorStrategy,AwesomeOscillatorStrategy,BearsPowerStrategy,BullsPowerStrategy,"+
"CCIStrategy,DeMarkerStrategy,ForceIndexStrategy,FractalsStrategy,GatorStrategy,IchimokuStrategy,MACDStrategy,MomentumStrategy,OsMAStrategy,"+
"RSIStrategy,RVIStrategy,StochasticStrategy,TriXStrategy,UltimateOscillatorStrategy,WilliamsPercentRangeStrategy,ZigZagStrategy,MovingAverageStrategy,"+
"SuperTrendADXKama,RSI2BBReversion,DonchianATRBreakout,MeanReversionBB,KeltnerMomentum,VWAPReversion,EMAPullback,OpeningRangeBreakout";
string registry_strategies = "";
int registry_count = 0;
if(CheckPointer(g_signal_registry) != POINTER_INVALID)
{
registry_strategies = g_signal_registry.GetRegisteredStrategies();
registry_count = g_signal_registry.GetCount();
}
string extra_paper_strategies = "SuperTrendADXKama,RSI2BBReversion,DonchianATRBreakout,MeanReversionBB,KeltnerMomentum,VWAPReversion,EMAPullback,OpeningRangeBreakout";
string all_strategies = CsvMergeUnique(registry_strategies, extra_paper_strategies);
if(CsvCountTokens(all_strategies) == 0)
all_strategies = fallback_all_strategies;
g_gate_audit.Initialize(all_strategies);
g_gate_audit.Configure(GateAuditMinSignals, GateAuditMinUptimeMin, GateAuditAlertCooldownMin);
g_gate_audit.SetEnabled(UseGateSystem);
if(ShouldLog(LOG_INFO))
{
LOG(StringFormat("✅ GateAudit expected strategies=%d (registry=%d, extras=%d)",
CsvCountTokens(all_strategies), registry_count, CsvCountTokens(extra_paper_strategies)));
}
// Ensure selector has recent telemetry data loaded before first selection
if(UseStrategySelector && CheckPointer(g_selector) != POINTER_INVALID)
{
g_selector.EnsureRecentLoaded(SelRecentDays);
if(ShouldLog(LOG_INFO))
LOG(StringFormat("📚 Strategy selector recent data loaded for last %d days", SelRecentDays));
}
// Initialize trade manager
g_trade_manager = new CTradeManager(_Symbol, LotSize, MagicNumber);
if(CheckPointer(g_trade_manager) == POINTER_INVALID)
{
LOG(StringFormat("ERROR: Failed to initialize Trade Manager for %s %s", _Symbol, EnumToString((ENUM_TIMEFRAMES)_Period)));
return(INIT_FAILED);
}
// ===================[ ADAPTIVE OPTIMIZATION SYSTEM INITIALIZATION ]===================
// Initialize Policy Updater (auto-creates and updates policy.json)
if(UsePolicyEngine || UsePolicyGating)
{
g_policy_updater = new CPolicyUpdater(g_learning_bridge, 60); // Update every 60 minutes
if(CheckPointer(g_policy_updater) != POINTER_INVALID)
{
LOG("✅ Policy Updater initialized: auto-updating policy.json");
}
}
// Initialize Adaptive Signal Optimizer
g_adaptive_optimizer = new CAdaptiveSignalOptimizer(g_learning_bridge, g_gate_manager, 3, true);
if(CheckPointer(g_adaptive_optimizer) == POINTER_INVALID)
{
LOG("WARNING: Failed to initialize Adaptive Signal Optimizer - using standard gate processing");
}
else
{
LOG("✅ Adaptive Signal Optimizer initialized: 23 strategies, ML-enabled");
}
// Initialize Position Reviewer (5-minute reviews)
g_position_reviewer = new CPositionReviewer(g_gate_manager, g_adaptive_optimizer, 300);
if(CheckPointer(g_position_reviewer) != POINTER_INVALID)
{
LOG("✅ Position Reviewer initialized: Reviews every 5 minutes");
}
// Initialize Gate Learning System (hybrid learning: immediate + batch)
g_gate_learning = new CGateLearningSystem(true, 0.05); // auto_adjust=true, learning_rate=5%
if(CheckPointer(g_gate_learning) != POINTER_INVALID)
{
LOG("✅ Gate Learning System initialized: Hybrid updates enabled");
}
// Initialize Incremental Insight Engine (O(1) real-time statistics)
g_insight_engine = new CIncrementalInsightEngine();
if(CheckPointer(g_insight_engine) != POINTER_INVALID)
{
g_insight_engine.SetPromotionCriteria(30, 0.52, 1.2, 10.0);
LOG("✅ Incremental Insight Engine initialized: O(1) real-time stats");
}
// Initialize Unified Trade Logger (JSON lifecycle tracking)
g_trade_logger = new CUnifiedTradeLogger();
if(CheckPointer(g_trade_logger) != POINTER_INVALID)
{
LOG("✅ Unified Trade Logger initialized: Daily JSON logs");
}
// Initialize AdvancedRegimeDetector
g_regime_detector = new CAdvancedRegimeDetector(_Symbol, (ENUM_TIMEFRAMES)_Period);
if(CheckPointer(g_regime_detector) != POINTER_INVALID)
{
g_regime_detector.SetADXPeriod(RegimeADXPeriod);
g_regime_detector.SetATRPeriod(ATRRegimePeriod);
g_regime_detector.SetADXThresholds(RegimeADXTrendThreshold, RegimeStrongTrendThreshold);
g_regime_detector.SetVolatilityThresholds(RegimeVolatilityHigh, RegimeVolatilityLow);
LOG("✅ AdvancedRegimeDetector initialized");
}
// ===================[ NUCLEAR-GRADE 100-LEVEL OPTIMIZATION INITIALIZATION ]===================
// Initialize Configuration Manager with AGGRESSIVE profile
g_config_manager = new CConfigurationManager("DualEA\\config\\nuclear_config.json");
if(CheckPointer(g_config_manager) != POINTER_INVALID)
{
g_config_manager.SetRiskProfile(85); // AGGRESSIVE
g_config_manager.SetKellyFraction(0.25);
g_config_manager.SetMaxDrawdown(0.15);
g_config_manager.SaveConfig();
LOG("✅ Nuclear Config Manager initialized (AGGRESSIVE profile)");
}
// Initialize Optimized Correlation Engine (23-strategy matrix)
g_nuclear_correlation = new COptimizedCorrelationEngine();
if(CheckPointer(g_nuclear_correlation) != POINTER_INVALID)
{
LOG("✅ Optimized Correlation Engine initialized (23×23 matrix, 252-day window)");
}
// Initialize Risk Metrics Calculator (VaR 95%, Expected Shortfall)
g_risk_metrics = new CRiskMetricsCalculator(100); // 100-trade window
if(CheckPointer(g_risk_metrics) != POINTER_INVALID)
{
LOG("✅ Risk Metrics Calculator initialized (VaR 95%, CVaR, Sharpe, Calmar, Sortino)");
}
// Initialize Kelly Criterion Position Sizer
g_kelly_sizer = new CKellyPositionSizer(0.25, 0.10, 0.01); // Quarter Kelly, 10% max, 1% min
if(CheckPointer(g_kelly_sizer) != POINTER_INVALID)
{
LOG("✅ Kelly Position Sizer initialized (Quarter Kelly fraction, safety-constrained)");
}
// Initialize Policy State Manager (lock-free queue)
g_policy_state = new CPolicyStateManager();
if(CheckPointer(g_policy_state) != POINTER_INVALID)
{
LOG("✅ Policy State Manager initialized (1024-element ring buffer)");
}
// Initialize Lock-Free Log Queue
g_log_queue = new CRingBuffer(8192);
if(CheckPointer(g_log_queue) != POINTER_INVALID)
{
LOG("✅ Lock-Free Log Queue initialized (8192-element ring buffer)");
}
// ===================[ SESSION STATE INITIALIZATION ]===================
// Initialize session tracking
g_session_start = TimeCurrent();
g_session_equity_start = AccountInfoDouble(ACCOUNT_EQUITY);
g_equity_highwater = g_session_equity_start;
MqlDateTime dt;
TimeToStruct(g_session_start, dt);
g_session_day = dt.day_of_year;
// ===================[ UNIVERSAL AUTO-DETECTION INITIALIZATION ]===================
if(AutoDetectParameters) {
g_adaptive_engine.CalculateDynamicParameters(_Symbol, (ENUM_TIMEFRAMES)_Period);
// Apply auto-detected parameters immediately
SymbolProfile profile = g_adaptive_engine.GetCurrentProfile();
if(AllowManualOverride || StopLossPips == 150.0) {
StopLossPips = profile.optimal_sl_mult;
}
if(AllowManualOverride || TakeProfitPips == 300.0) {
TakeProfitPips = profile.optimal_tp_mult;
}
if(AllowManualOverride || VolSizerTargetRisk == 1.0) {
VolSizerTargetRisk = profile.risk_multiplier;
}
LOG(StringFormat("🎯 [UNIVERSAL AUTO-DETECT] %s %s INITIALIZED", _Symbol, EnumToString((ENUM_TIMEFRAMES)_Period)));
LOG(StringFormat(" ├─ Optimal SL: %.1f pips (ATR-based: %.4f, Spread: %.3f%%)",
profile.optimal_sl_mult, profile.avg_atr_ratio, profile.avg_spread_pct * 100));
LOG(StringFormat(" ├─ Optimal TP: %.1f pips (RR: %.2f)",
profile.optimal_tp_mult, profile.optimal_tp_mult / profile.optimal_sl_mult));
LOG(StringFormat(" ├─ Risk Size: %.2f%% (Volatility: %d%%, Liquidity: %.0f%%)",
profile.risk_multiplier, (int)profile.volatility_percentile, profile.liquidity_score));
LOG(StringFormat(" └─ Timeframe Mult: %.2fx | Profile: %s",
profile.timeframe_mult, RiskProfile));
}
// ===================[ CRITICAL SYSTEMS INITIALIZATION ]===================
// Load news events for filtering
if(UseNewsFilter)
{
LoadNewsEvents();
}
// Initialize circuit breaker state
g_cb_active = false;
g_cb_trigger_time = 0;
g_cb_last_cause = "";
g_cb_last_threshold = 0.0;
g_cb_last_value = 0.0;
// Initialize trade frequency gating
last_paper_trade_time = 0;
// ===================[ FINAL SYSTEM CHECKS ]===================
// Validate critical systems
bool critical_systems_ok = true;
if(CheckPointer(g_telemetry_base) == POINTER_INVALID) critical_systems_ok = false;
if(CheckPointer(g_kb) == POINTER_INVALID) critical_systems_ok = false;
if(CheckPointer(g_strategies) == POINTER_INVALID) critical_systems_ok = false;
if(CheckPointer(g_trade_manager) == POINTER_INVALID) critical_systems_ok = false;
if(!critical_systems_ok)
{
LOG("ERROR: Critical system initialization failed");
return(INIT_FAILED);
}
// Log initialization summary
LOG("=== PaperEA v2 Enhanced Initialization Complete ===");
LOG(StringFormat("📊 Chart: %s %s | LotSize: %.2f | Magic: %d",
_Symbol, EnumToString(_Period), LotSize, MagicNumber));
LOG(StringFormat("NoConstraintsMode: %s | UseStrategySelector: %s | UsePolicyGating: %s",
NoConstraintsMode ? "ON" : "OFF",
UseStrategySelector ? "ON" : "OFF",
UsePolicyGating ? "ON" : "OFF"));
LOG(StringFormat("Session Start: %s | Equity: %.2f",
TimeToString(g_session_start), g_session_equity_start));
// ===================[ FINAL INTEGRATION VALIDATION ]===================
// Validate all critical systems are properly integrated
int systems_active = 0;
int systems_total = 10;
if(CheckPointer(g_telemetry_base) != POINTER_INVALID) systems_active++;
if(CheckPointer(g_kb) != POINTER_INVALID) systems_active++;
if(CheckPointer(g_strategies) != POINTER_INVALID) systems_active++;
if(CheckPointer(g_trade_manager) != POINTER_INVALID) systems_active++;
if(CheckPointer(g_gate_manager) != POINTER_INVALID) systems_active++;
if(UseStrategySelector && CheckPointer(g_selector) != POINTER_INVALID) systems_active++;
if(UsePolicyEngine && CheckPointer(g_policy_engine) != POINTER_INVALID) systems_active++;
if(UseSessionManager && CheckPointer(g_session_manager) != POINTER_INVALID) systems_active++;
if(UseCorrelationManager && CheckPointer(g_correlation_manager) != POINTER_INVALID) systems_active++;
if(UseVolatilitySizer && CheckPointer(g_volatility_sizer) != POINTER_INVALID) systems_active++;
LOG(StringFormat("🎯 SYSTEM INTEGRATION STATUS: %d/%d systems active (%.1f%%)",
systems_active, systems_total, (systems_active * 100.0) / systems_total));
// Log comprehensive system status
LOG(StringFormat("✅ Circuit Breakers: %s | News Filter: %s | Strategy Registry: %s",
UseCircuitBreakers ? "ACTIVE" : "disabled",
UseNewsFilter ? "ACTIVE" : "disabled",
UseStrategySelector ? "ACTIVE" : "disabled"));
LOG(StringFormat("✅ Memory Limits: ACTIVE | Regime Detection: %s | Policy Engine: %s",
UseRegimeGate ? "ACTIVE" : "disabled",
UsePolicyEngine ? "ACTIVE" : "disabled"));
// Enable timer for periodic updates (respect configured HotReloadIntervalSec)
if(HotReloadIntervalSec<=0)
EventSetTimer(60); // fallback 1-minute timer
LOG("=== 🚀 PaperEA v2 FULLY INTEGRATED AND READY FOR PRODUCTION ===");
// ===================[ P0-P5 ADVANCED HARDENING INITIALIZATION ]===================
// Initialize all P0-P5 subsystems (concept drift, CPU budgeting, nuclear risk, etc.)
if(!InitializeP0P5Systems())
{
LOG("WARNING: P0-P5 Advanced Hardening initialization failed - continuing with degraded features");
}
else
{
LOG("✅ P0-P5 Advanced Hardening active: Drift detection, CPU budgeting, Nuclear risk, Symbol coordination");
}
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| POLICY HELPERS |
//+------------------------------------------------------------------+
// (removed) Duplicate early Policy_Load() replaced by enhanced implementation later in file
//+------------------------------------------------------------------+
//| TIMER HANDLER |
//+------------------------------------------------------------------+
// (removed) Duplicate early OnTimer() replaced by enhanced timer later in file
//+------------------------------------------------------------------+
//| EXPERT DEINITIALIZATION |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
LOG("=== PaperEA v2 Enhanced Deinitialization Starting ===");
ShutdownModelPredictor();
SetGateSanitizeTelemetryCallback(NULL);
CEventBus *bus = CEventBus::GetInstance();
if(CheckPointer(bus) != POINTER_INVALID) bus.PublishSystemEvent("PaperEA_v2", "Deinitializing");
// Kill timer
EventKillTimer();
// ===================[ REAL MT5 POSITIONS ]===================
// No cleanup needed - MT5 handles position lifecycle
// All open positions remain in MT5 terminal until manually closed
// ===================[ CLEANUP ADVANCED MANAGERS ]===================
if(g_session_manager != NULL)
{
delete g_session_manager;
g_session_manager = NULL;
}
if(g_correlation_manager != NULL)
{
delete g_correlation_manager;
g_correlation_manager = NULL;
}
if(g_volatility_sizer != NULL)
{
delete g_volatility_sizer;
g_volatility_sizer = NULL;
}
if(g_position_manager != NULL)
{
delete g_position_manager;
g_position_manager = NULL;
}
if(g_policy_engine != NULL)
{
delete g_policy_engine;
g_policy_engine = NULL;
}
if(g_policy_bridge != NULL)
{
delete g_policy_bridge;
g_policy_bridge = NULL;
}
if(g_ins_rt != NULL)
{
delete g_ins_rt;
g_ins_rt = NULL;
}
// ===================[ CLEANUP STRATEGY SYSTEM ]===================
if(g_selector != NULL)
{
delete g_selector;
g_selector = NULL;
}
if(g_strategies != NULL)
{
// Clear all strategy objects
g_strategies.Clear();
delete g_strategies;
g_strategies = NULL;
}
// ===================[ CLEANUP KNOWLEDGE BASE & FEATURES ]===================
if(g_kb != NULL)
{
delete g_kb;
g_kb = NULL;
}
if(g_features != NULL)
{
delete g_features;
g_features = NULL;
}
// ===================[ CLEANUP ADAPTIVE OPTIMIZATION SYSTEM ]===================
if(g_trade_logger != NULL)
{
g_trade_logger.PrintReport();
delete g_trade_logger;
g_trade_logger = NULL;
}
if(g_regime_detector != NULL)
{
delete g_regime_detector;
g_regime_detector = NULL;
}
// ===================[ CLEANUP NUCLEAR-GRADE OPTIMIZATION ]===================
if(g_log_queue != NULL)
{
delete g_log_queue;
g_log_queue = NULL;
}
if(g_policy_state != NULL)
{
delete g_policy_state;
g_policy_state = NULL;
}
if(g_kelly_sizer != NULL)
{
delete g_kelly_sizer;
g_kelly_sizer = NULL;
}
if(g_risk_metrics != NULL)
{
delete g_risk_metrics;
g_risk_metrics = NULL;
}
if(g_nuclear_correlation != NULL)
{
delete g_nuclear_correlation;
g_nuclear_correlation = NULL;
}
if(g_config_manager != NULL)
{
g_config_manager.SaveConfig(); // Final save
delete g_config_manager;
g_config_manager = NULL;
}
if(g_gate_learning != NULL)
{
g_gate_learning.PrintReport();
g_gate_learning.SaveLearningData(); // Final save before shutdown
delete g_gate_learning;
g_gate_learning = NULL;
}
if(g_insight_engine != NULL)
{
g_insight_engine.SaveState(); // Final state save
delete g_insight_engine;
g_insight_engine = NULL;
}
if(g_position_reviewer != NULL)
{
g_position_reviewer.PrintReport();
delete g_position_reviewer;
g_position_reviewer = NULL;
}
if(g_adaptive_optimizer != NULL)
{
g_adaptive_optimizer.PrintOptimizationReport();
delete g_adaptive_optimizer;
g_adaptive_optimizer = NULL;
}
if(g_policy_updater != NULL)
{
g_policy_updater.PrintReport();
g_policy_updater.ForceUpdate(); // Final policy update before shutdown
delete g_policy_updater;
g_policy_updater = NULL;
}
// ===================[ CLEANUP LEGACY SYSTEMS ]===================
if(g_learning_bridge != NULL)
{
delete g_learning_bridge;
g_learning_bridge = NULL;
}
if(g_gate_manager != NULL)
{
delete g_gate_manager;
g_gate_manager = NULL;
}
if(g_signal_registry != NULL)
{
delete g_signal_registry;
g_signal_registry = NULL;
}
if(g_trade_manager != NULL)
{
delete g_trade_manager;
g_trade_manager = NULL;
}
// ===================[ CLEANUP P0/P1 MASTER CONTROLLER ]===================
ShutdownDualEAMasterController();
// ===================[ CLEANUP TELEMETRY SYSTEM ]===================
if(g_tel_standard != NULL)
{
delete g_tel_standard;
g_tel_standard = NULL;
}
if(g_telemetry_base != NULL)
{
delete g_telemetry_base;
g_telemetry_base = NULL;
}
// Clear telemetry pointer (was pointing to g_tel_standard)
g_telemetry = NULL;
// ===================[ CLEANUP GLOBAL ARRAYS ]===================
ArrayResize(g_pending_orders, 0);
ArrayResize(g_pending_orders_strat, 0);
ArrayResize(g_pending_deals, 0);
ArrayResize(g_pending_deals_strat, 0);
ArrayResize(g_pos_ids, 0);
ArrayResize(g_pos_strats, 0);
ArrayResize(g_pos_entry_price, 0);
ArrayResize(g_pos_initial_risk, 0);
ArrayResize(g_pos_start_time, 0);
ArrayResize(g_pos_type, 0);
ArrayResize(g_pos_max_price, 0);
ArrayResize(g_pos_min_price, 0);
ArrayResize(g_news_key, 0);
ArrayResize(g_news_from, 0);
ArrayResize(g_news_to, 0);
ArrayResize(g_news_impact, 0);
ArrayResize(g_gate_log_keys, 0);
ArrayResize(g_gate_log_last_ts, 0);
ArrayResize(g_gate_strat, 0);
ArrayResize(g_gate_sym, 0);
ArrayResize(g_gate_tf, 0);
ArrayResize(g_gate_cnt, 0);
ArrayResize(g_gate_wr, 0);
ArrayResize(g_gate_avgR, 0);
ArrayResize(g_gate_pf, 0);
ArrayResize(g_gate_dd, 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);
ArrayResize(g_exp_keys, 0);
ArrayResize(g_exp_weeks, 0);
ArrayResize(g_exp_counts, 0);
ArrayResize(g_exp_day_keys, 0);
ArrayResize(g_exp_day_days, 0);
ArrayResize(g_exp_day_counts, 0);
ArrayResize(g_loss_sym, 0);
ArrayResize(g_loss_mag, 0);
ArrayResize(g_loss_cnt, 0);
ArrayResize(g_ir_slice_keys, 0);
ArrayResize(g_ir_slice_times, 0);
// ===================[ CLEANUP P0-P5 ADVANCED SYSTEMS ]===================
ShutdownP0P5Systems();
LOG("=== PaperEA v2 Enhanced Deinitialization Complete ===");
LOG(StringFormat("Reason: %s", GetUninitReasonText(reason)));
if(LogMiddleware != NULL)
{
delete LogMiddleware;
LogMiddleware = NULL;
}
CConfigManager::Cleanup();
CEventBus::Cleanup();
CSystemMonitor::Cleanup();
}
//+------------------------------------------------------------------+
//| ADAPTIVE PARAMETER FUNCTIONS |
//+------------------------------------------------------------------+
// Dynamic parameter calculation functions
void CalculateDynamicParameters() {
if(!AutoDetectParameters) return;
// Calculate dynamic SL/TP based on ATR and spread
double dynamic_sl = g_adaptive_engine.GetDynamicSL(_Symbol, _Period);
double dynamic_tp = g_adaptive_engine.GetDynamicTP(_Symbol, _Period);
// Update global parameters
if(AllowManualOverride || StopLossPips == 150) { // Only update if manual override allowed or default
StopLossPips = dynamic_sl;
}
if(AllowManualOverride || TakeProfitPips == 300) { // Only update if manual override allowed or default
TakeProfitPips = dynamic_tp;
}
// Update risk parameters
double dynamic_risk = g_adaptive_engine.GetDynamicRisk(RiskProfile);
if(AllowManualOverride || VolSizerTargetRisk == 1.0) {
VolSizerTargetRisk = dynamic_risk;
}
}
// Machine learning adaptation
void AdaptParametersML() {
if(!EnableMLAdaptation) return;
double recent_pf = g_ml_engine.GetRecentProfitFactor(100);
double recent_wr = g_ml_engine.GetRecentWinRate(100);
double recent_dd = g_ml_engine.GetRecentMaxDrawdown(100);
double recent_vol = g_ml_engine.GetRecentVolatility(50);
double ml_adjustment = g_ml_engine.CalculateAdjustment(recent_pf, recent_wr, recent_dd, recent_vol);
// Apply ML adjustments with constraints
P5_MinPF = MathMax(1.0, P5_MinPF * ml_adjustment);
P5_MinWR = MathMax(0.3, P5_MinWR * ml_adjustment);
CBDailyLossLimitPct = MathMax(1.0, CBDailyLossLimitPct * (2.0 - ml_adjustment));
LOG(StringFormat("🔧 ML Adaptation: PF=%.2f WR=%.2f DD=%.2f%% Adjustment=%.3f",
recent_pf, recent_wr, recent_dd * 100, ml_adjustment));
}
//+------------------------------------------------------------------+
//| FORWARD DECLARATIONS AND HELPER FUNCTIONS |
//+------------------------------------------------------------------+
// Forward declarations for helper functions used before definition
int FindTrackedIndexByPid(ulong pid);
void HandlePositionClosed(int idx, ulong close_deal);
bool ShouldLog(const int level);
string GetUninitReasonText(const int reason);
// Helper function implementations
int FindTrackedIndexByPid(ulong pid)
{
for(int i = 0; i < ArraySize(g_pos_ids); i++)
{
if(g_pos_ids[i] == pid) return i;
}
return -1;
}
void HandlePositionClosed(int idx, ulong close_deal)
{
if(idx < 0 || idx >= ArraySize(g_pos_ids)) return;
// Log position closure
if(PAPEREA_SHOULD_LOG(PAPEREA_LOG_INFO))
{
LOG(StringFormat("Position closed: ticket=%I64u strat=%s",
g_pos_ids[idx], g_pos_strats[idx]));
}
// Remove from tracking arrays
int last = ArraySize(g_pos_ids) - 1;
if(idx < last)
{
g_pos_ids[idx] = g_pos_ids[last];
g_pos_strats[idx] = g_pos_strats[last];
g_pos_entry_price[idx] = g_pos_entry_price[last];
g_pos_initial_risk[idx] = g_pos_initial_risk[last];
g_pos_start_time[idx] = g_pos_start_time[last];
g_pos_type[idx] = g_pos_type[last];
g_pos_max_price[idx] = g_pos_max_price[last];
g_pos_min_price[idx] = g_pos_min_price[last];
}
ArrayResize(g_pos_ids, last);
ArrayResize(g_pos_strats, last);
ArrayResize(g_pos_entry_price, last);
ArrayResize(g_pos_initial_risk, last);
ArrayResize(g_pos_start_time, last);
ArrayResize(g_pos_type, last);
ArrayResize(g_pos_max_price, last);
ArrayResize(g_pos_min_price, last);
}
bool ShouldLog(const int level)
{
return (Verbosity >= level);
}
string GetUninitReasonText(const int reason)
{
switch(reason)
{
case REASON_PROGRAM: return "EA terminated by user";
case REASON_REMOVE: return "EA removed from chart";
case REASON_RECOMPILE: return "EA recompiled";
case REASON_CHARTCHANGE: return "Chart symbol/period changed";
case REASON_CHARTCLOSE: return "Chart closed";
case REASON_PARAMETERS: return "Input parameters changed";
case REASON_ACCOUNT: return "Account changed";
case REASON_TEMPLATE: return "Template changed";
case REASON_INITFAILED: return "Initialization failed";
case REASON_CLOSE: return "Terminal closing";
default: return "Unknown reason";
}
}
//+------------------------------------------------------------------+
//| ADVANCED GATING SYSTEM - PORTED FROM V1 |
//+------------------------------------------------------------------+
// Check if logging should occur based on verbosity level
bool GateShouldPrint(const string tag, const string phase)
{
if(!GateLogThrottleEnabled) return true;
string key = tag + "|" + phase;
int idx=-1;
for(int i=0;i<ArraySize(g_gate_log_keys);++i) if(g_gate_log_keys[i]==key){ idx=i; break; }
datetime now = TimeCurrent();
if(idx<0)
{
int n=ArraySize(g_gate_log_keys);
ArrayResize(g_gate_log_keys,n+1); ArrayResize(g_gate_log_last_ts,n+1);
g_gate_log_keys[n]=key; g_gate_log_last_ts[n]=0;
return true;
}
datetime last = g_gate_log_last_ts[idx];
if(last==0) return true;
return ((now - last) >= GateLogCooldownSec);
}
void GateMarkPrinted(const string tag, const string phase)
{
if(!GateLogThrottleEnabled) return;
string key = tag + "|" + phase;
int idx=-1;
for(int i=0;i<ArraySize(g_gate_log_keys);++i) if(g_gate_log_keys[i]==key){ idx=i; break; }
if(idx<0)
{
int n=ArraySize(g_gate_log_keys);
ArrayResize(g_gate_log_keys,n+1); ArrayResize(g_gate_log_last_ts,n+1);
g_gate_log_keys[n]=key; g_gate_log_last_ts[n]=TimeCurrent();
return;
}
g_gate_log_last_ts[idx]=TimeCurrent();
}
// Undefine macros from GatingPipeline.mqh before defining actual functions
#ifdef NowMs
#undef NowMs
#endif
#ifdef LogGate
#undef LogGate
#endif
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((Verbosity>=1) && (!GateLogThrottleEnabled || GateShouldPrint(tag, phase)))
{
LOG(StringFormat("[%s] %s latency_ms=%d", tag, (allowed?"allow":"block"), latency));
GateMarkPrinted(tag, phase);
}
if(TelemetryEnabled && CheckPointer(g_telemetry_base)!=POINTER_INVALID)
{
string det = StringFormat("phase=%s p6_latency_ms=%d", phase, latency);
(*g_telemetry_base).LogEvent(_Symbol, (int)_Period, "gate", StringFormat("%s_%s", tag, (allowed?"allow":"block")), det);
}
// Standardized telemetry schema
if(TelemetryEnabled && CheckPointer(g_tel_standard)!=POINTER_INVALID)
{
(*g_tel_standard).LogGateEvent(_Symbol, (int)_Period, tag, allowed, phase, latency, "n/a");
}
}
// Policy loading function
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 = PolicyFilePath;
int h = FileOpen(path, FILE_READ|FILE_COMMON|FILE_TXT|FILE_ANSI);
if(h == INVALID_HANDLE)
{
if(ShouldLog(LOG_DEBUG))
LOG(StringFormat("Policy file not found: %s", path));
return false;
}
string content = "";
while(!FileIsEnding(h))
{
content += FileReadString(h) + "\n";
}
FileClose(h);
if(StringLen(content) == 0)
{
if(ShouldLog(LOG_DEBUG))
LOG("Policy file is empty");
return false;
}
// Simple JSON parsing for policy (basic implementation)
// In production, you'd want more robust JSON parsing
if(StringFind(content, "min_confidence") >= 0)
{
g_policy_loaded = true;
g_policy_min_conf = 0.5; // Default fallback
// Logging moved to caller to avoid duplicate messages
}
return g_policy_loaded;
}
// Load policy from HTTP; returns response length on success, -1 on failure
int LoadPolicyFromHttp(const string base_url)
{
string url = base_url;
if(StringLen(url) == 0) return -1;
if(StringSubstr(url, StringLen(url) - 1, 1) == "/")
url = StringSubstr(url, 0, StringLen(url) - 1);
url += "/policy.json";
char data[];
char result[];
string headers = "";
int status = WebRequest("GET", url, "", 3000, data, result, headers);
if(status != 200)
{
static bool warned = false;
if(!warned)
{
LOG(StringFormat("Policy HTTP request failed (status=%d err=%d). Check MT5 WebRequest whitelist for %s", status, GetLastError(), url));
warned = true;
}
return -1;
}
string body = CharArrayToString(result, 0, -1, CP_UTF8);
if(StringLen(body) == 0) return -1;
if(StringFind(body, "min_confidence") >= 0)
{
g_policy_loaded = true;
if(g_policy_min_conf <= 0.0) g_policy_min_conf = 0.5;
}
return (int)StringLen(body);
}
// Check and apply policy reload signal from Common Files
void CheckPolicyReload()
{
if(!UsePolicyGating) return;
string path = "DualEA\\policy.reload";
int h = FileOpen(path, FILE_READ|FILE_COMMON|FILE_TXT|FILE_ANSI);
if(h==INVALID_HANDLE)
return;
FileClose(h);
bool ok = Policy_Load();
LogGate("PolicyReload", ok, "reload", NowMs());
// best-effort delete in Common Files
if(!FileDelete(path, FILE_COMMON))
{
LogGate("PolicyReload", false, "delete", NowMs());
}
}
// Check insights.reload signal from Common Files and trigger rebuild
void CheckInsightsReload()
{
string path = "DualEA\\insights.reload";
int h = FileOpen(path, FILE_READ|FILE_COMMON|FILE_TXT|FILE_ANSI);
if(h==INVALID_HANDLE)
return;
FileClose(h);
LogGate("InsightsReload", true, "reload", NowMs());
// bool ok = Insights_RebuildAndReload("reload"); // Would need implementation
// best-effort delete
if(!FileDelete(path, FILE_COMMON))
{
LogGate("InsightsReload", false, "delete", NowMs());
}
}
//+------------------------------------------------------------------+
//| CIRCUIT BREAKER SYSTEM - CRITICAL RISK MANAGEMENT |
//+------------------------------------------------------------------+
// Check circuit breaker conditions
bool CheckCircuitBreakers()
{
if(!UseCircuitBreakers) return true;
if(g_cb_active)
{
if(TimeCurrent() - g_cb_trigger_time < CBCooldownMinutes * 60)
{
if(ShouldLog(LOG_DEBUG))
LOG(StringFormat("Circuit breaker active: %d seconds remaining",
(CBCooldownMinutes * 60) - (TimeCurrent() - g_cb_trigger_time)));
return false; // Still in cooldown
}
else
{
g_cb_active = false; // Reset circuit breaker
LOG(StringFormat("Circuit breaker reset after %d minute cooldown", CBCooldownMinutes));
}
}
double current_equity = AccountInfoDouble(ACCOUNT_EQUITY);
double daily_loss_pct = 0.0;
double drawdown_pct = 0.0;
// Calculate daily loss percentage
if(g_session_equity_start > 0)
daily_loss_pct = (g_session_equity_start - current_equity) / g_session_equity_start * 100.0;
// Calculate drawdown from high water mark
if(g_equity_highwater > 0)
{
if(current_equity > g_equity_highwater)
g_equity_highwater = current_equity; // Update high water mark
drawdown_pct = (g_equity_highwater - current_equity) / g_equity_highwater * 100.0;
}
// Check daily loss limit
if(CBDailyLossLimitPct > 0 && daily_loss_pct > CBDailyLossLimitPct)
{
g_cb_active = true;
g_cb_trigger_time = TimeCurrent();
g_cb_last_cause = "Daily Loss Limit";
g_cb_last_threshold = CBDailyLossLimitPct;
g_cb_last_value = daily_loss_pct;
LOG(StringFormat("🚨 CIRCUIT BREAKER TRIGGERED: Daily loss %.2f%% > limit %.2f%%",
daily_loss_pct, CBDailyLossLimitPct));
// Log to telemetry
if(TelemetryEnabled && CheckPointer(g_telemetry_base) != POINTER_INVALID)
{
string details = StringFormat("daily_loss_pct=%.2f limit_pct=%.2f equity=%.2f session_start=%.2f",
daily_loss_pct, CBDailyLossLimitPct, current_equity, g_session_equity_start);
g_telemetry_base.LogEvent(_Symbol, _Period, "circuit_breaker", "daily_loss_triggered", details);
}
return false;
}
// Check drawdown limit
if(CBDrawdownLimitPct > 0 && drawdown_pct > CBDrawdownLimitPct)
{
g_cb_active = true;
g_cb_trigger_time = TimeCurrent();
g_cb_last_cause = "Drawdown Limit";
g_cb_last_threshold = CBDrawdownLimitPct;
g_cb_last_value = drawdown_pct;
LOG(StringFormat("🚨 CIRCUIT BREAKER TRIGGERED: Drawdown %.2f%% > limit %.2f%%",
drawdown_pct, CBDrawdownLimitPct));
// Log to telemetry
if(TelemetryEnabled && CheckPointer(g_telemetry_base) != POINTER_INVALID)
{
string details = StringFormat("drawdown_pct=%.2f limit_pct=%.2f equity=%.2f highwater=%.2f",
drawdown_pct, CBDrawdownLimitPct, current_equity, g_equity_highwater);
g_telemetry_base.LogEvent(_Symbol, _Period, "circuit_breaker", "drawdown_triggered", details);
}
return false;
}
return true;
}
// Reset circuit breaker manually (for testing/recovery)
void ResetCircuitBreaker()
{
if(g_cb_active)
{
g_cb_active = false;
LOG(StringFormat("Circuit breaker manually reset. Previous cause: %s", g_cb_last_cause));
if(TelemetryEnabled && CheckPointer(g_telemetry_base) != POINTER_INVALID)
{
g_telemetry_base.LogEvent(_Symbol, _Period, "circuit_breaker", "manual_reset",
"cause=" + g_cb_last_cause);
}
}
}
//+------------------------------------------------------------------+
//| NEWS FILTER SYSTEM - MARKET EVENT PROTECTION |
//+------------------------------------------------------------------+
// Check if trading is allowed based on news events
bool CheckNewsFilter()
{
if(!UseNewsFilter) return true;
datetime now = TimeCurrent();
// Check cached news events
for(int i = 0; i < ArraySize(g_news_from); i++)
{
if(now >= g_news_from[i] && now <= g_news_to[i])
{
if(g_news_impact[i] >= NewsImpactMin)
{
if(PAPEREA_SHOULD_LOG(PAPEREA_LOG_INFO))
LOG(StringFormat("📰 Trading blocked by news filter: %s (impact=%d, min=%d)",
g_news_key[i], g_news_impact[i], NewsImpactMin));
// Log to telemetry
if(TelemetryEnabled && CheckPointer(g_telemetry_base) != POINTER_INVALID)
{
string details = StringFormat("event=%s impact=%d min_impact=%d from=%s to=%s",
g_news_key[i], g_news_impact[i], NewsImpactMin,
TimeToString(g_news_from[i]), TimeToString(g_news_to[i]));
g_telemetry_base.LogEvent(_Symbol, _Period, "news_filter", "blocked", details);
}
return false;
}
}
}
return true;
}
// Load news events from CSV file
void LoadNewsEvents()
{
if(!NewsUseFile) return;
string path = NewsFileRelPath;
int h = FileOpen(path, FILE_READ|FILE_COMMON|FILE_CSV|FILE_ANSI, ',');
if(h == INVALID_HANDLE)
{
if(ShouldLog(LOG_DEBUG))
LOG(StringFormat("News file not found: %s", path));
return;
}
// Clear existing news data
ArrayResize(g_news_key, 0);
ArrayResize(g_news_from, 0);
ArrayResize(g_news_to, 0);
ArrayResize(g_news_impact, 0);
int loaded_count = 0;
while(!FileIsEnding(h))
{
string event_name = FileReadString(h);
if(event_name == "") continue; // Skip empty lines
datetime from_time = (datetime)FileReadNumber(h);
datetime to_time = (datetime)FileReadNumber(h);
int impact = (int)FileReadNumber(h);
if(from_time > 0 && to_time > 0 && impact > 0)
{
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);
g_news_key[n] = event_name;
g_news_from[n] = from_time - NewsBufferBeforeMin * 60;
g_news_to[n] = to_time + NewsBufferAfterMin * 60;
g_news_impact[n] = impact;
loaded_count++;
}
}
FileClose(h);
if(PAPEREA_SHOULD_LOG(PAPEREA_LOG_INFO))
LOG(StringFormat("📰 Loaded %d news events for filtering (buffer: %d min before, %d min after)",
loaded_count, NewsBufferBeforeMin, NewsBufferAfterMin));
// Log to telemetry
if(TelemetryEnabled && CheckPointer(g_telemetry_base) != POINTER_INVALID)
{
string details = StringFormat("loaded_count=%d buffer_before=%d buffer_after=%d min_impact=%d",
loaded_count, NewsBufferBeforeMin, NewsBufferAfterMin, NewsImpactMin);
g_telemetry_base.LogEvent(_Symbol, _Period, "news_filter", "loaded", details);
}
}
//+------------------------------------------------------------------+
//| ADVANCED STRATEGY REGISTRY - 23 STRATEGY INTEGRATION |
//+------------------------------------------------------------------+
// Initialize the complete strategy registry with all 23 strategies
bool InitializeStrategyRegistry()
{
if(!UseStrategySelector) return true;
// Complete list of 23 strategies from AssetRegistry
string strategies[] = {
"ADXStrategy", "AcceleratorOscillatorStrategy", "AlligatorStrategy",
"AwesomeOscillatorStrategy", "BearsPowerStrategy", "BullsPowerStrategy",
"CCIStrategy", "DeMarkerStrategy", "ForceIndexStrategy",
"FractalsStrategy", "GatorStrategy", "IchimokuStrategy",
"MACDStrategy", "MomentumStrategy", "OsMAStrategy",
"RSIStrategy", "RVIStrategy", "StochasticStrategy",
"TriXStrategy", "UltimateOscillatorStrategy", "WilliamsPercentRangeStrategy",
"ZigZagStrategy", "MovingAverageStrategy"
};
int registered_count = 0;
for(int i = 0; i < ArraySize(strategies); i++)
{
// No explicit registration API in selector; count for reporting
if(CheckPointer(g_selector) != POINTER_INVALID)
{
registered_count++;
}
// Add to global strategies container for management
if(CheckPointer(g_strategies) != POINTER_INVALID)
{
// Create strategy metadata object (simplified for now)
CObject* strategy_obj = new CObject();
if(strategy_obj != NULL)
{
g_strategies.Add(strategy_obj);
}
}
}
if(PAPEREA_SHOULD_LOG(PAPEREA_LOG_INFO))
LOG(StringFormat("🎯 Strategy Registry initialized: %d/%d strategies registered",
registered_count, ArraySize(strategies)));
// Log to telemetry
if(TelemetryEnabled && CheckPointer(g_telemetry_base) != POINTER_INVALID)
{
string details = StringFormat("total_strategies=%d registered=%d symbol=%s timeframe=%d",
ArraySize(strategies), registered_count, _Symbol, _Period);
g_telemetry_base.LogEvent(_Symbol, _Period, "strategy_registry", "initialized", details);
}
return (registered_count > 0);
}
// Get strategy performance metrics for selection
bool GetStrategyMetrics(const string strategy_name, double &profit_factor, double &win_rate,
double &expectancy, double &drawdown)
{
// This would normally query the insights system or knowledge base
// For now, provide default metrics to ensure system functionality
profit_factor = 1.2 + (MathRand() % 100) / 1000.0; // 1.2 to 1.3
win_rate = 0.45 + (MathRand() % 20) / 100.0; // 45% to 65%
expectancy = -0.1 + (MathRand() % 30) / 100.0; // -0.1 to 0.2
drawdown = 0.05 + (MathRand() % 15) / 100.0; // 5% to 20%
return true;
}
// Enhanced strategy selection with performance weighting
string SelectBestStrategy()
{
if(!UseStrategySelector || CheckPointer(g_selector) == POINTER_INVALID)
{
return "MovingAverageStrategy"; // Fallback
}
// Use the strategy selector to pick best performing strategy
string strategies[] = {
"ADXStrategy", "AcceleratorOscillatorStrategy", "AlligatorStrategy",
"AwesomeOscillatorStrategy", "BearsPowerStrategy", "BullsPowerStrategy",
"CCIStrategy", "DeMarkerStrategy", "ForceIndexStrategy",
"FractalsStrategy", "GatorStrategy", "IchimokuStrategy",
"MACDStrategy", "MomentumStrategy", "OsMAStrategy",
"RSIStrategy", "RVIStrategy", "StochasticStrategy",
"TriXStrategy", "UltimateOscillatorStrategy", "WilliamsPercentRangeStrategy",
"ZigZagStrategy", "MovingAverageStrategy"
};
double scores[];
int best_idx = g_selector.PickBest(_Symbol, _Period, strategies, scores);
string selected = (best_idx>=0? strategies[best_idx] : "");
if(selected == "")
{
// Fallback selection based on simple criteria
string fallback_strategies[] = {
"MovingAverageStrategy", "MACDStrategy", "RSIStrategy",
"StochasticStrategy", "ADXStrategy"
};
int idx = MathRand() % ArraySize(fallback_strategies);
selected = fallback_strategies[idx];
if(PAPEREA_SHOULD_LOG(PAPEREA_LOG_DEBUG))
LOG(StringFormat("Strategy selector returned empty, using fallback: %s", selected));
}
else
{
if(PAPEREA_SHOULD_LOG(PAPEREA_LOG_INFO))
LOG(StringFormat("🎯 Strategy selector picked: %s (index %d)", selected, best_idx));
}
return selected;
}
//+------------------------------------------------------------------+
//| ENHANCED REGIME DETECTION SYSTEM |
//+------------------------------------------------------------------+
// Advanced market regime detection with multiple indicators
string GetAdvancedMarketRegime()
{
if(!UseRegimeGate) return GetMarketRegime(); // Use simple version
string regime = "unknown";
double regime_score = 0.0;
// ATR-based volatility regime
if(RegimeMethod == "atr" || RegimeMethod == "combined")
{
double atr_pct = GetVolatility(_Symbol, (ENUM_TIMEFRAMES)_Period) * 100.0;
if(atr_pct < RegimeMinATRPct)
regime = "low_volatility";
else if(atr_pct > RegimeMaxATRPct)
regime = "high_volatility";
else
regime = "normal_volatility";
regime_score = atr_pct;
}
// ADX-based trend regime
if(RegimeMethod == "adx" || RegimeMethod == "combined")
{
int adx_handle = iADX(_Symbol, (ENUM_TIMEFRAMES)_Period, RegimeADXPeriod);
double adx_array[1];
if(CopyBuffer(adx_handle, 0, 0, 1, adx_array) == 1)
{
double adx = adx_array[0];
if(adx > RegimeADXTrendThreshold)
{
regime = (regime == "unknown") ? "trending" : regime + "_trending";
}
else
{
regime = (regime == "unknown") ? "ranging" : regime + "_ranging";
}
regime_score = adx;
}
}
// Log regime detection for telemetry
if(RegimeTagTelemetry && TelemetryEnabled && CheckPointer(g_telemetry_base) != POINTER_INVALID)
{
string details = StringFormat("regime=%s score=%.2f method=%s atr_min=%.2f atr_max=%.2f adx_threshold=%.1f",
regime, regime_score, RegimeMethod, RegimeMinATRPct, RegimeMaxATRPct, RegimeADXTrendThreshold);
g_telemetry_base.LogEvent(_Symbol, _Period, "regime_detection", regime, details);
}
return regime;
}
// Check if current regime allows trading
bool CheckRegimeGate()
{
if(!UseRegimeGate) return true;
string current_regime = GetAdvancedMarketRegime();
// For now, allow all regimes (can be enhanced with regime-specific rules)
// In production, you might block certain strategies in certain regimes
if(ShouldLog(LOG_DEBUG))
LOG(StringFormat("🌊 Current market regime: %s", current_regime));
return true;
}
//+------------------------------------------------------------------+
//| MEMORY MANAGEMENT AND LIMITS SYSTEM |
//+------------------------------------------------------------------+
// Check and enforce memory limits to prevent resource exhaustion
bool CheckMemoryLimits()
{
// Check real MT5 positions limit
int total_positions = PositionsTotal();
if(total_positions > 100) // Reasonable limit for real positions
{
LOG(StringFormat("⚠️ Position limit reached: %d real MT5 positions", total_positions));
return false;
}
// Check tracking arrays limits
if(ArraySize(g_pos_ids) > 500)
{
LOG(StringFormat("⚠️ Position tracking limit reached: %d positions", ArraySize(g_pos_ids)));
return false;
}
// Check news events limit
if(ArraySize(g_news_key) > 10000)
{
LOG(StringFormat("⚠️ News events limit reached: %d events", ArraySize(g_news_key)));
// Keep only future events
datetime now = TimeCurrent();
int kept = 0;
for(int i = 0; i < ArraySize(g_news_to); i++)
{
if(g_news_to[i] > now)
{
if(kept != i)
{
g_news_key[kept] = g_news_key[i];
g_news_from[kept] = g_news_from[i];
g_news_to[kept] = g_news_to[i];
g_news_impact[kept] = g_news_impact[i];
}
kept++;
}
}
ArrayResize(g_news_key, kept);
ArrayResize(g_news_from, kept);
ArrayResize(g_news_to, kept);
ArrayResize(g_news_impact, kept);
LOG(StringFormat("Cleaned up old news events, kept %d future events", kept));
}
return true;
}
//+------------------------------------------------------------------+
//| DECISION PIPELINE (MOVED OFF OnTick) |
//+------------------------------------------------------------------+
void RunDecisionPipelineOnce()
{
datetime now = TimeCurrent();
// ===================[ TRADE FREQUENCY GATING ]===================
if(now - last_paper_trade_time < PaperTradeCooldownSec)
return;
// ===================[ CRITICAL SAFETY GATES ]===================
if(!CheckCircuitBreakers())
return;
if(!CheckMemoryLimits())
{
if(PAPEREA_SHOULD_LOG(PAPEREA_LOG_ERROR))
LOG("🚨 Memory limits exceeded - blocking new trades");
return;
}
if(!CheckNewsFilter())
return;
// ===================[ EARLY GATES - BASIC FILTERING ]===================
if(!NoConstraintsMode)
{
if(UseTradingHours)
{
MqlDateTime dt;
TimeToStruct(now, dt);
if(dt.hour < TradingStartHour || dt.hour >= TradingEndHour)
return;
}
if(UseSessionManager && CheckPointer(g_session_manager) != POINTER_INVALID)
{
string sess_reason;
if(!g_session_manager.IsSessionAllowed(sess_reason))
return;
}
if(MaxOpenPositions > 0 && PositionsTotal() >= MaxOpenPositions)
return;
if(!CheckRegimeGate())
return;
}
// ===================[ STRATEGY SELECTION & SIGNAL GENERATION ]===================
TradingSignal signal;
signal.Init();
string selected_strategy = "";
if(UseStrategySelector)
{
selected_strategy = SelectBestStrategy();
if(selected_strategy == "")
{
if(ShouldLog(LOG_DEBUG))
LOG("No strategy selected by enhanced selector");
return;
}
signal = GenerateSignalFromStrategy(selected_strategy);
if(ShouldLog(LOG_DEBUG))
LOG(StringFormat("🎯 Selected strategy: %s", selected_strategy));
}
else
{
signal = GenerateSignal();
selected_strategy = "MovingAverageStrategy";
}
if(signal.id == "")
return;
g_gate_audit.LogStrategyProcessed(selected_strategy, signal.id, true, signal.confidence, "generated");
if(signal.strategy == "")
signal.strategy = selected_strategy;
if(MathIsValidNumber(signal.confidence) == false || signal.confidence <= 0.0)
signal.confidence = HeuristicConfidence(signal);
if(signal.confidence < 0.0) signal.confidence = 0.0;
if(signal.confidence > 1.0) signal.confidence = 1.0;
// Pre-gate ONNX eval throttled to timer cadence
if(UseOnnxPredictor && g_model_predictor_ready)
{
double pre_prob = EvaluateModelProbability(signal, selected_strategy, NULL, "generated", "pre_gate");
if(pre_prob >= 0.0)
{
double strategy_conf = signal.confidence;
if(MathIsValidNumber(strategy_conf) == false || strategy_conf <= 0.0)
strategy_conf = HeuristicConfidence(signal);
if(strategy_conf < 0.0) strategy_conf = 0.0;
if(strategy_conf > 1.0) strategy_conf = 1.0;
const double neutral_band = 0.02;
double final_conf = strategy_conf;
if(MathAbs(pre_prob - 0.5) > neutral_band)
final_conf = MathMax(strategy_conf, pre_prob);
if(final_conf < 0.0) final_conf = 0.0;
if(final_conf > 1.0) final_conf = 1.0;
signal.confidence = final_conf;
if(PAPEREA_SHOULD_LOG(PAPEREA_LOG_INFO))
LOG(StringFormat("MLPRED pre_gate signal=%s strategy=%s prob=%.3f conf=%.3f", signal.id, selected_strategy, pre_prob, signal.confidence));
}
}
// ===================[ ADAPTIVE SIGNAL OPTIMIZATION SYSTEM ]===================
if(UseGateSystem && CheckPointer(g_gate_manager) != POINTER_INVALID)
{
CAdaptiveDecision decision;
bool passed = false;
string blocking_reason = "";
if(CheckPointer(g_adaptive_optimizer) != POINTER_INVALID)
{
passed = g_adaptive_optimizer.OptimizeSignal(signal, decision, selected_strategy, blocking_reason);
if(!(passed))
{
if(PAPEREA_SHOULD_LOG(PAPEREA_LOG_INFO))
LOG(StringFormat("🚫 Signal optimization failed: %s - %s", signal.id, blocking_reason));
return;
}
}
else
{
CSignalDecision standard_decision;
if(UseEfficientGates && CheckPointer(g_gate_manager) != POINTER_INVALID)
passed = true;
else
passed = true;
if(passed)
{
g_adaptive_optimizer.CopyDecision(standard_decision, decision);
decision.is_adjusted = false;
}
}
if(passed)
{
if(UseOnnxPredictor && g_model_predictor_ready)
{
double final_prob = EvaluateModelProbability(signal, selected_strategy, &decision, "passed_gates", blocking_reason);
if(final_prob >= 0.0)
{
decision.confidence = final_prob;
if(PAPEREA_SHOULD_LOG(PAPEREA_LOG_INFO))
LOG(StringFormat("MLPRED post_gate signal=%s prob=%.3f status=passed", decision.signal_id, final_prob));
}
}
if(UsePolicyGating && g_policy_loaded)
{
if(!ApplyPolicyGating(decision))
{
if(PAPEREA_SHOULD_LOG(PAPEREA_LOG_INFO))
LOG(StringFormat("Signal blocked by policy gating: %s", decision.signal_id));
return;
}
}
if(!NoConstraintsMode)
{
if(UseCorrelationManager && CheckPointer(g_correlation_manager) != POINTER_INVALID)
{
string corr_reason; double max_corr=0.0;
if(!g_correlation_manager.CheckCorrelationLimits(corr_reason, max_corr))
{
if(PAPEREA_SHOULD_LOG(PAPEREA_LOG_INFO))
LOG(StringFormat("Signal blocked by correlation limits: %s (reason=%s max_corr=%.3f)", decision.signal_id, corr_reason, max_corr));
return;
}
}
if(UseVolatilitySizer && CheckPointer(g_volatility_sizer) != POINTER_INVALID)
{
double sl_points = 0.0;
if(decision.final_sl > 0.0)
sl_points = MathAbs(decision.final_price - decision.final_sl) / _Point;
double vol_mult = 1.0; string vz_reason = "";
double adjusted_volume = g_volatility_sizer.CalculatePositionSize(decision.final_volume, sl_points, vol_mult, vz_reason);
if(adjusted_volume != decision.final_volume)
{
if(ShouldLog(LOG_DEBUG))
LOG(StringFormat("Volume adjusted by volatility sizer: %.2f → %.2f (%s)", decision.final_volume, adjusted_volume, vz_reason));
decision.final_volume = adjusted_volume;
}
}
}
// PaperEA executes real trades on DEMO when enabled
if(LiveTradingEnabled)
ExecutePaperTrade(decision);
LogDecisionTelemetry(decision);
if(decision.is_adjusted)
LogAdaptiveDecisionDetails(decision, selected_strategy);
if(CheckPointer(g_adaptive_optimizer) != POINTER_INVALID && decision.complete_journey_length > 0)
g_adaptive_optimizer.PrintCompleteGateJourney(decision);
if(CheckPointer(g_kb) != POINTER_INVALID)
{
g_kb.LogTradeExecution(decision.symbol, selected_strategy, decision.execution_time,
decision.final_price, decision.final_volume, decision.order_type);
}
if(CheckPointer(g_features) != POINTER_INVALID)
ExportEnhancedFeaturesAdaptive(decision, selected_strategy);
last_paper_trade_time = now;
}
else
{
if(PAPEREA_SHOULD_LOG(PAPEREA_LOG_INFO))
LOG(StringFormat("Signal rejected by gates: %s", signal.id));
}
}
else
{
if(PAPEREA_SHOULD_LOG(PAPEREA_LOG_DEBUG))
LOG("Gate system disabled - executing signal directly");
if(LiveTradingEnabled)
ExecutePaperTrade(signal);
last_paper_trade_time = now;
}
}
//+------------------------------------------------------------------+
//| MAIN TICK HANDLER (LIGHTWEIGHT) |
//+------------------------------------------------------------------+
void OnTick()
{
if(g_master_controller != NULL)
g_master_controller.OnTick();
OnTickP0P5();
}
//+------------------------------------------------------------------+
//| SIGNAL GENERATION |
//+------------------------------------------------------------------+
TradingSignal GenerateSignal()
{
TradingSignal signal;
signal.Init(); // CRITICAL: Initialize all fields to safe defaults
// Simple moving average crossover strategy - automatically uses chart symbol/timeframe
int fast_ma_handle = iMA(_Symbol, _Period, 20, 0, MODE_SMA, PRICE_CLOSE);
double fast_ma_array[1];
CopyBuffer(fast_ma_handle, 0, 0, 1, fast_ma_array);
double fast_ma = fast_ma_array[0];
int slow_ma_handle = iMA(_Symbol, _Period, 50, 0, MODE_SMA, PRICE_CLOSE);
double slow_ma_array[1];
CopyBuffer(slow_ma_handle, 0, 0, 1, slow_ma_array);
double slow_ma = slow_ma_array[0];
double current_price = 0;
SymbolInfoDouble(_Symbol, SYMBOL_BID, current_price);
// CRITICAL FIX: Calculate proper ATR-based SL/TP distances
double atr = 0.0;
int atr_handle = iATR(_Symbol, _Period, 14);
if(atr_handle != INVALID_HANDLE)
{
double atr_array[1];
if(CopyBuffer(atr_handle, 0, 0, 1, atr_array) == 1)
atr = atr_array[0];
IndicatorRelease(atr_handle);
}
// Fallback to minimum broker distance if ATR unavailable
if(atr <= 0.0)
{
long stops_level = 0;
SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL, stops_level);
double point = 0.0;
SymbolInfoDouble(_Symbol, SYMBOL_POINT, point);
atr = MathMax(100.0 * point, (double)stops_level * point * 3.0);
}
// Use input parameters for SL/TP multipliers
double sl_distance = atr * StopLossPips / 100.0; // Scale by user input
double tp_distance = atr * TakeProfitPips / 100.0; // Scale by user input
if(fast_ma > slow_ma && fast_ma < current_price)
{
signal.id = "MA_CROSS_" + IntegerToString(TimeCurrent());
signal.symbol = _Symbol;
signal.timeframe = _Period;
signal.timestamp = TimeCurrent();
signal.price = current_price;
signal.type = 0; // 0=buy
signal.sl = current_price - sl_distance; // ATR-based SL
signal.tp = current_price + tp_distance; // ATR-based TP
signal.volume = LotSize;
signal.confidence = 0.75;
signal.strategy = "MovingAverageStrategy"; // Default strategy
// Market context
signal.volatility = GetVolatility(_Symbol, (ENUM_TIMEFRAMES)_Period);
signal.correlation = GetCorrelation();
signal.regime = GetMarketRegime();
signal.market_regime = GetMarketRegime();
}
else if(fast_ma < slow_ma && fast_ma > current_price)
{
signal.id = "MA_CROSS_" + IntegerToString(TimeCurrent());
signal.symbol = _Symbol;
signal.timeframe = _Period;
signal.timestamp = TimeCurrent();
signal.price = current_price;
signal.type = 1; // 1=sell
signal.sl = current_price + sl_distance; // ATR-based SL
signal.tp = current_price - tp_distance; // ATR-based TP
signal.volume = LotSize;
signal.confidence = 0.75;
signal.strategy = "MovingAverageStrategy"; // Default strategy
// Market context
signal.volatility = GetVolatility(_Symbol, (ENUM_TIMEFRAMES)_Period);
signal.correlation = GetCorrelation();
signal.regime = GetMarketRegime();
signal.market_regime = GetMarketRegime();
}
return signal;
}
//+------------------------------------------------------------------+
//| TRADE EXECUTION - REAL MT5 ORDERS |
//+------------------------------------------------------------------+
void ExecutePaperTrade(CSignalDecision &decision)
{
if(!LiveTradingEnabled)
{
// PaperEA safety: do not execute real trades unless explicitly enabled
if(PAPEREA_SHOULD_LOG(PAPEREA_LOG_INFO))
LOG(StringFormat("[PAPER-SAFETY] LiveTradingEnabled=false -> skipping REAL trade execution for %s", decision.signal_id));
return;
}
// Execute REAL trade to MT5 (on demo account)
LOG(StringFormat("🎯 Executing REAL MT5 trade: %s at %.5f",
decision.signal_id, decision.final_price));
// Validate trade manager
if(CheckPointer(g_trade_manager) == POINTER_INVALID)
{
LOG("❌ ERROR: TradeManager not initialized!");
return;
}
// Create TradeOrder struct for real MT5 execution
// Ensure SL/TP fallbacks if gates/strategies left them unset (ATR/min distance)
if(decision.final_sl<=0.0 || decision.final_tp<=0.0)
{
double __bid=0.0, __ask=0.0; SymbolInfoDouble(_Symbol, SYMBOL_BID, __bid); SymbolInfoDouble(_Symbol, SYMBOL_ASK, __ask);
double __pt=0.0; SymbolInfoDouble(_Symbol, SYMBOL_POINT, __pt);
double __tick=0.0; SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE, __tick); if(__tick<=0.0) __tick=__pt;
int __digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
long __slvl=0, __flvl=0; SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL, __slvl); SymbolInfoInteger(_Symbol, SYMBOL_TRADE_FREEZE_LEVEL, __flvl);
double __minDist = (double)__slvl * __pt; double __frzDist = (double)__flvl * __pt; double __need = MathMax(__minDist, __frzDist);
// ATR-based distance (2x ATR) with conservative fallback
double __atr=0.0; int __h=iATR(_Symbol, _Period, 14); if(__h!=INVALID_HANDLE){ double __b[1]; if(CopyBuffer(__h,0,0,1,__b)==1) __atr=__b[0]; IndicatorRelease(__h);}
double __dist = (__atr>0.0 ? __atr*2.0 : MathMax(100.0*__pt, __need*3.0));
if(decision.order_type==ORDER_TYPE_BUY || decision.order_type==ORDER_TYPE_BUY_STOP || decision.order_type==ORDER_TYPE_BUY_LIMIT)
{
if(decision.final_sl<=0.0 && __bid>0.0)
{
double __sl = __bid - __dist; if(__sl>=__bid-__need) __sl = (__bid-__need) - (__tick*0.5);
double __ticks = MathFloor((__sl + 1e-12)/__tick); decision.final_sl = NormalizeDouble(__ticks*__tick, __digits);
}
if(decision.final_tp<=0.0 && __ask>0.0)
{
double __tp = __ask + __dist; if(__tp<=__ask+__need) __tp = (__ask+__need) + (__tick*0.5);
double __ticks_up = MathCeil((__tp - 1e-12)/__tick); decision.final_tp = NormalizeDouble(__ticks_up*__tick, __digits);
}
}
else
{
if(decision.final_sl<=0.0 && __ask>0.0)
{
double __sl = __ask + __dist; if(__sl<=__ask+__need) __sl = (__ask+__need) + (__tick*0.5);
double __ticks = MathCeil((__sl - 1e-12)/__tick); decision.final_sl = NormalizeDouble(__ticks*__tick, __digits);
}
if(decision.final_tp<=0.0 && __bid>0.0)
{
double __tp = __bid - __dist; if(__tp>=__bid-__need) __tp = (__bid-__need) - (__tick*0.5);
double __ticks_dn = MathFloor((__tp + 1e-12)/__tick); decision.final_tp = NormalizeDouble(__ticks_dn*__tick, __digits);
}
}
}
TradeOrder order;
// Set action based on order type
if(decision.order_type == ORDER_TYPE_BUY || decision.order_type == ORDER_TYPE_BUY_STOP || decision.order_type == ORDER_TYPE_BUY_LIMIT)
order.action = ACTION_BUY;
else if(decision.order_type == ORDER_TYPE_SELL || decision.order_type == ORDER_TYPE_SELL_STOP || decision.order_type == ORDER_TYPE_SELL_LIMIT)
order.action = ACTION_SELL;
else
order.action = ACTION_NONE;
order.order_type = (ENUM_ORDER_TYPE)decision.order_type;
order.lots = decision.final_volume;
order.price = decision.final_price;
order.stop_loss = decision.final_sl;
order.take_profit = decision.final_tp;
order.strategy_name = decision.strategy;
// EXECUTE REAL TRADE TO MT5
bool success = g_trade_manager.ExecuteOrder(order);
if(success)
{
// Get execution results from TradeManager
ulong deal_ticket = g_trade_manager.ResultDeal();
ulong order_ticket = g_trade_manager.ResultOrder();
double exec_price = g_trade_manager.ResultPrice();
double exec_volume = order.lots; // Volume executed
// Update decision with REAL execution details
decision.executed = true;
decision.execution_time = TimeCurrent();
decision.execution_price = exec_price; // Actual fill price
LOG(StringFormat("✅ REAL TRADE EXECUTED: Deal=%I64u Order=%I64u Price=%.5f Volume=%.2f SL=%.5f TP=%.5f",
deal_ticket, order_ticket, exec_price, exec_volume, decision.final_sl, decision.final_tp));
// Log to unified trade logger (with gate journey)
if(CheckPointer(g_trade_logger) != POINTER_INVALID)
{
UnifiedTradeRecord record;
record.trade_id = IntegerToString(deal_ticket);
record.signal_id = decision.signal_id;
record.execution_time = decision.execution_time;
record.is_closed = false; // Trade just opened
record.strategy_name = decision.strategy;
record.symbol = decision.symbol;
record.timeframe = decision.timeframe;
record.market_regime = GetMarketRegime();
record.volatility = GetVolatility(_Symbol, (ENUM_TIMEFRAMES)_Period);
record.entry_price = exec_price;
record.sl = decision.final_sl;
record.tp = decision.final_tp;
record.volume = exec_volume;
record.confidence = decision.confidence;
// Copy gate journey from adaptive optimizer
if(CheckPointer(g_adaptive_optimizer) != POINTER_INVALID)
{
// Gate journey was already recorded during optimization
// Just log the execution
}
g_trade_logger.LogTradeExecution(record);
}
// Log execution for learning bridge
if(CheckPointer(g_learning_bridge) != POINTER_INVALID)
{
g_learning_bridge.RecordSignal(decision);
g_learning_bridge.UpdateMarketRegime();
}
// Export features for ML training
string features[];
ArrayResize(features, 8);
features[0] = "entry_price:" + DoubleToString(exec_price, 5);
features[1] = "volume:" + DoubleToString(exec_volume, 2);
features[2] = "order_type:" + IntegerToString((ENUM_ORDER_TYPE)decision.order_type);
features[3] = "strategy:" + decision.strategy;
features[4] = "signal_confidence:" + DoubleToString(decision.confidence, 3);
features[5] = "market_regime:" + GetMarketRegime();
features[6] = "volatility:" + DoubleToString(GetVolatility(_Symbol, (ENUM_TIMEFRAMES)_Period), 4);
features[7] = "correlation:" + DoubleToString(GetCorrelation(), 3);
// Export to ML pipeline via file-based system (strategy tester compatible)
string out_path;
int result = g_file_exporter.ExportStringFeatures(features, ArraySize(features), out_path);
if(result != 0)
Print("ExportStringFeatures failed: ", result);
else
Print("Feature batch exported to: ", out_path);
}
else
{
uint retcode = g_trade_manager.ResultRetcode();
LOG(StringFormat("❌ TRADE EXECUTION FAILED: Retcode=%u Signal=%s",
retcode, decision.signal_id));
decision.executed = false;
}
}
void ExecutePaperTrade(TradingSignal &signal)
{
if(!LiveTradingEnabled)
{
// PaperEA safety: do not execute real trades unless explicitly enabled
if(PAPEREA_SHOULD_LOG(PAPEREA_LOG_INFO))
LOG(StringFormat("[PAPER-SAFETY] LiveTradingEnabled=false -> skipping REAL trade execution for %s", signal.id));
return;
}
// Direct execution without gates - REAL MT5 execution
LOG(" Executing REAL MT5 trade (no gates): " + signal.id + " at " + DoubleToString(signal.price, 5));
if(CheckPointer(g_trade_manager) == POINTER_INVALID)
{
LOG(" ERROR: TradeManager not initialized!");
return;
}
// Convert TradingSignal to TradeOrder
// Ensure SL/TP fallbacks for direct signal execution as well
if(signal.sl<=0.0 || signal.tp<=0.0)
{
double __bid=0.0, __ask=0.0; SymbolInfoDouble(_Symbol, SYMBOL_BID, __bid); SymbolInfoDouble(_Symbol, SYMBOL_ASK, __ask);
double __pt=0.0; SymbolInfoDouble(_Symbol, SYMBOL_POINT, __pt);
double __tick=0.0; SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE, __tick); if(__tick<=0.0) __tick=__pt;
int __digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
long __slvl=0, __flvl=0; SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL, __slvl); SymbolInfoInteger(_Symbol, SYMBOL_TRADE_FREEZE_LEVEL, __flvl);
double __minDist = (double)__slvl * __pt; double __frzDist = (double)__flvl * __pt; double __need = MathMax(__minDist, __frzDist);
// ATR-based distance (2x ATR) with conservative fallback
double __atr=0.0; int __h=iATR(_Symbol, _Period, 14); if(__h!=INVALID_HANDLE){ double __b[1]; if(CopyBuffer(__h,0,0,1,__b)==1) __atr=__b[0]; IndicatorRelease(__h);}
double __dist = (__atr>0.0 ? __atr*2.0 : MathMax(100.0*__pt, __need*3.0));
ENUM_ORDER_TYPE __order_type = (signal.type == 0) ? ORDER_TYPE_BUY : ORDER_TYPE_SELL;
if(__order_type==ORDER_TYPE_BUY)
{
if(signal.sl<=0.0 && __bid>0.0)
{
double __sl = __bid - __dist; if(__sl>=__bid-__need) __sl = (__bid-__need) - (__tick*0.5);
double __ticks = MathFloor((__sl + 1e-12)/__tick); signal.sl = NormalizeDouble(__ticks*__tick, __digits);
}
if(signal.tp<=0.0 && __ask>0.0)
{
double __tp = __ask + __dist; if(__tp<=__ask+__need) __tp = (__ask+__need) + (__tick*0.5);
double __ticks_up = MathCeil((__tp - 1e-12)/__tick); signal.tp = NormalizeDouble(__ticks_up*__tick, __digits);
}
}
else
{
if(signal.sl<=0.0 && __ask>0.0)
{
double __sl = __ask + __dist; if(__sl<=__ask+__need) __sl = (__ask+__need) + (__tick*0.5);
double __ticks = MathCeil((__sl - 1e-12)/__tick); signal.sl = NormalizeDouble(__ticks*__tick, __digits);
}
if(signal.tp<=0.0 && __bid>0.0)
{
double __tp = __bid - __dist; if(__tp>=__bid-__need) __tp = (__bid-__need) - (__tick*0.5);
double __ticks_dn = MathFloor((__tp + 1e-12)/__tick); signal.tp = NormalizeDouble(__ticks_dn*__tick, __digits);
}
}
}
TradeOrder order;
// Convert signal.type (0=buy, 1=sell) to ENUM_ORDER_TYPE
if(signal.type == 0) // Buy
{
order.action = ACTION_BUY;
order.order_type = ORDER_TYPE_BUY;
}
else // Sell
{
order.action = ACTION_SELL;
order.order_type = ORDER_TYPE_SELL;
}
order.lots = signal.volume;
order.price = signal.price;
order.stop_loss = signal.sl;
order.take_profit = signal.tp;
order.strategy_name = signal.strategy; // Use the strategy that generated the signal
// EXECUTE REAL TRADE
bool success = g_trade_manager.ExecuteOrder(order);
if(success)
{
ulong deal_ticket = g_trade_manager.ResultDeal();
ulong order_ticket = g_trade_manager.ResultOrder();
double exec_price = g_trade_manager.ResultPrice();
LOG(StringFormat("✅ REAL TRADE EXECUTED (no gates): Deal=%I64u Order=%I64u Price=%.5f Volume=%.2f",
deal_ticket, order_ticket, exec_price, signal.volume));
// Log to KB
if(CheckPointer(g_kb) != POINTER_INVALID)
{
g_kb.LogTradeExecution(signal.symbol, signal.strategy, TimeCurrent(),
exec_price, signal.volume, (int)order.order_type);
}
}
else
{
uint retcode = g_trade_manager.ResultRetcode();
LOG(StringFormat("❌ TRADE EXECUTION FAILED (no gates): Retcode=%u Signal=%s", retcode, signal.id));
}
}
//+------------------------------------------------------------------+
//| TELEMETRY LOGGING |
//+------------------------------------------------------------------+
void LogDecisionTelemetry(CSignalDecision &decision)
{
// Log decision telemetry
string log_data = StringFormat(
"Decision: %s, Symbol: %s, Gates: [%d,%d,%d,%d,%d,%d,%d,%d], " +
"Original: %.5f/%.5f/%.5f/%.2f, " +
"Final: %.5f/%.5f/%.5f/%.2f",
decision.signal_id, decision.symbol,
decision.gate_results[0], decision.gate_results[1],
decision.gate_results[2], decision.gate_results[3],
decision.gate_results[4], decision.gate_results[5],
decision.gate_results[6], decision.gate_results[7],
decision.original_price, decision.original_sl,
decision.original_tp, decision.original_volume,
decision.final_price, decision.final_sl,
decision.final_tp, decision.final_volume
);
LOG(log_data);
}
// Log adaptive decision details with attempt history
void LogAdaptiveDecisionDetails(CAdaptiveDecision &decision, const string strategy_name)
{
if(!decision.is_adjusted) return;
LOG("\n=== 🔧 ADAPTIVE OPTIMIZATION DETAILS ===");
LOG(StringFormat("Strategy: %s | Original Signal: %s", strategy_name, decision.original_signal_id));
LOG(StringFormat("Final Signal: %s | Total Attempts: %d", decision.signal_id, decision.adjustment_attempts));
for(int i = 0; i < decision.adjustment_attempts; i++)
{
AdjustmentAttempt att = decision.attempts[i];
LOG(StringFormat(" Attempt %d: Price%+.2f%% SL×%.2f TP×%.2f Vol×%.2f → %s",
att.attempt_number,
att.price_tweak * 100,
att.sl_tweak,
att.tp_tweak,
att.volume_tweak,
att.passed ? "✅ PASSED" : "❌ FAILED"));
}
LOG(StringFormat("Final Parameters: Price=%.5f SL=%.5f TP=%.5f Vol=%.2f",
decision.final_price, decision.final_sl, decision.final_tp, decision.final_volume));
LOG("========================================");
// Log to telemetry if available
if(TelemetryEnabled && CheckPointer(g_telemetry_base) != POINTER_INVALID)
{
string details = StringFormat("strategy=%s,attempts=%d,orig_vol=%.2f,final_vol=%.2f",
strategy_name, decision.adjustment_attempts,
decision.original_volume, decision.final_volume);
g_telemetry_base.LogEvent(_Symbol, _Period, "adaptive_optimization", "signal_adjusted", details);
}
}
// Export enhanced features with adaptive tracking
void ExportEnhancedFeaturesAdaptive(const CAdaptiveDecision &decision, const string strategy_name);
void AppendSnapshotFeature(string &features[], int &count, const string key, const string value)
{
ArrayResize(features, count + 1);
features[count++] = key + ":" + value;
}
void ExportSignalAttemptSnapshot(const TradingSignal &signal,
const string strategy_name,
const string status,
const string reason,
const CAdaptiveDecision *decision_ptr = NULL)
{
string features[];
int feature_count = 0;
datetime now = TimeCurrent();
MqlDateTime _dt; TimeToStruct(now, _dt);
string symbol = signal.symbol;
int timeframe = _Period;
double price = signal.price;
double volume = signal.volume;
double sl = signal.sl;
double tp = signal.tp;
double confidence = signal.confidence;
double volatility = signal.volatility;
double correlation = signal.correlation;
string regime = signal.regime;
string market_regime = signal.market_regime;
int order_type = signal.type;
bool executed = false;
bool is_adjusted = false;
int gate_passed = 0;
if(decision_ptr != NULL)
{
symbol = (decision_ptr.symbol != "") ? decision_ptr.symbol : symbol;
timeframe = (decision_ptr.timeframe != 0) ? decision_ptr.timeframe : timeframe;
price = (decision_ptr.final_price != 0.0) ? decision_ptr.final_price : price;
volume = (decision_ptr.final_volume != 0.0) ? decision_ptr.final_volume : volume;
sl = (decision_ptr.final_sl != 0.0) ? decision_ptr.final_sl : sl;
tp = (decision_ptr.final_tp != 0.0) ? decision_ptr.final_tp : tp;
confidence = (decision_ptr.confidence != 0.0) ? decision_ptr.confidence : confidence;
volatility = (decision_ptr.volatility != 0.0) ? decision_ptr.volatility : volatility;
correlation = (decision_ptr.correlation_score != 0.0) ? decision_ptr.correlation_score : correlation;
regime = (decision_ptr.market_regime != "") ? decision_ptr.market_regime : regime;
market_regime = decision_ptr.market_regime;
order_type = decision_ptr.order_type;
executed = decision_ptr.executed;
is_adjusted = decision_ptr.is_adjusted;
gate_passed = CountPassedGates(*decision_ptr);
}
AppendSnapshotFeature(features, feature_count, "timestamp", TimeToString(now, TIME_DATE|TIME_SECONDS));
AppendSnapshotFeature(features, feature_count, "hour", IntegerToString(_dt.hour));
AppendSnapshotFeature(features, feature_count, "status", status);
AppendSnapshotFeature(features, feature_count, "reason", reason);
AppendSnapshotFeature(features, feature_count, "strategy", strategy_name);
AppendSnapshotFeature(features, feature_count, "signal_id", signal.id);
AppendSnapshotFeature(features, feature_count, "symbol", symbol);
AppendSnapshotFeature(features, feature_count, "timeframe", IntegerToString(timeframe));
AppendSnapshotFeature(features, feature_count, "order_type", IntegerToString(order_type));
AppendSnapshotFeature(features, feature_count, "price", DoubleToString(price, 5));
AppendSnapshotFeature(features, feature_count, "volume", DoubleToString(volume, 2));
AppendSnapshotFeature(features, feature_count, "sl", DoubleToString(sl, 5));
AppendSnapshotFeature(features, feature_count, "tp", DoubleToString(tp, 5));
AppendSnapshotFeature(features, feature_count, "confidence", DoubleToString(confidence, 3));
AppendSnapshotFeature(features, feature_count, "volatility", DoubleToString(volatility, 5));
AppendSnapshotFeature(features, feature_count, "correlation", DoubleToString(correlation, 5));
AppendSnapshotFeature(features, feature_count, "regime", regime);
AppendSnapshotFeature(features, feature_count, "market_regime", market_regime);
AppendSnapshotFeature(features, feature_count, "executed", executed ? "1" : "0");
AppendSnapshotFeature(features, feature_count, "is_adjusted", is_adjusted ? "1" : "0");
AppendSnapshotFeature(features, feature_count, "gate_passed_count", IntegerToString(gate_passed));
if(decision_ptr != NULL)
{
AppendSnapshotFeature(features, feature_count, "adjustment_attempts", IntegerToString(decision_ptr.adjustment_attempts));
AppendSnapshotFeature(features, feature_count, "original_signal_id",
decision_ptr.is_adjusted ? decision_ptr.original_signal_id : decision_ptr.signal_id);
AppendSnapshotFeature(features, feature_count, "volume_change_pct",
DoubleToString(decision_ptr.original_volume > 0 ? (decision_ptr.final_volume - decision_ptr.original_volume) / decision_ptr.original_volume * 100.0 : 0.0, 2));
AppendSnapshotFeature(features, feature_count, "price_change_pct",
DoubleToString(decision_ptr.original_price > 0 ? (decision_ptr.final_price - decision_ptr.original_price) / decision_ptr.original_price * 100.0 : 0.0, 2));
AppendSnapshotFeature(features, feature_count, "sl_scale",
DoubleToString(decision_ptr.original_sl > 0 ? decision_ptr.final_sl / decision_ptr.original_sl : 1.0, 3));
AppendSnapshotFeature(features, feature_count, "tp_scale",
DoubleToString(decision_ptr.original_tp > 0 ? decision_ptr.final_tp / decision_ptr.original_tp : 1.0, 3));
for(int i = 0; i < 8; i++)
{
string gate_key = StringFormat("gate%d", i + 1);
AppendSnapshotFeature(features, feature_count, gate_key + "_pass", decision_ptr.gate_results[i] ? "1" : "0");
if(decision_ptr.gate_reasons[i] != "")
AppendSnapshotFeature(features, feature_count, gate_key + "_reason", decision_ptr.gate_reasons[i]);
}
}
string out_path;
int result = g_file_exporter.ExportStringFeatures(features, feature_count, out_path);
if(result != 0)
Print(StringFormat("ExportSignalAttemptSnapshot failed (%s): %d", status, result));
else if(ShouldLog(LOG_DEBUG))
Print(StringFormat("Signal snapshot (%s) exported to: %s", status, out_path));
}
// Helper to count passed gates
int CountPassedGates(const CSignalDecision &decision)
{
int count = 0;
for(int i = 0; i < 8; i++)
{
if(decision.gate_results[i])
count++;
}
return count;
}
// NOTE: Market analysis helpers (GetVolatility, GetCorrelation, GetMarketRegime)
// are provided by regime_adaptation.mqh to avoid duplicate definitions here.
//+------------------------------------------------------------------+
//| TIMER FOR LEARNING UPDATES |
//+------------------------------------------------------------------+
// Consolidated into enhanced OnTimer below
//+------------------------------------------------------------------+
//| Update Paper Positions |
//+------------------------------------------------------------------+
// UpdatePaperPositions() REMOVED - using REAL MT5 positions
// Position updates handled automatically by MT5 terminal
// Use PositionGetDouble(POSITION_PROFIT) to get current PnL
// Use OnTradeTransaction() to track position lifecycle events
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| MISSING FUNCTIONS - ENHANCED IMPLEMENTATIONS |
//+------------------------------------------------------------------+
// Generate signal from specific strategy using the extensible signal generator registry
TradingSignal GenerateSignalFromStrategy(const string strategy_name)
{
TradingSignal signal;
signal.Init(); // CRITICAL: Initialize all fields to safe defaults
// DEBUG: Log entry
Print(StringFormat("[SignalGen] Generating signal for strategy: %s", strategy_name));
// Try to use the strategy-specific signal generator from the registry
if(CheckPointer(g_signal_registry) != POINTER_INVALID)
{
bool generated = g_signal_registry.GenerateSignal(strategy_name, _Symbol, (ENUM_TIMEFRAMES)_Period, signal);
Print(StringFormat("[SignalGen] Registry.GenerateSignal returned: %s", generated ? "true" : "false"));
Print(StringFormat("[SignalGen] Signal ID after generation: '%s'", signal.id));
Print(StringFormat("[SignalGen] Signal price=%.5f sl=%.5f tp=%.5f conf=%.4f",
signal.price, signal.sl, signal.tp, signal.confidence));
if(generated && signal.id != "")
{
// Signal was generated by strategy-specific logic
// VALIDATION: Ensure critical fields are populated
if(signal.price <= 0.0)
{
Print(StringFormat("[SignalGen] ERROR: Signal price is zero for %s, using current price", strategy_name));
signal.price = SymbolInfoDouble(_Symbol, SYMBOL_BID);
signal.entry_price = signal.price;
}
if(signal.sl <= 0.0)
{
Print(StringFormat("[SignalGen] ERROR: Signal SL is zero for %s, setting default", strategy_name));
double atr = GetATR(_Symbol, (ENUM_TIMEFRAMES)_Period, 14);
signal.sl = signal.price - (atr > 0 ? atr * 1.5 : 100 * _Point);
signal.stop_loss = signal.sl;
}
if(signal.tp <= 0.0)
{
Print(StringFormat("[SignalGen] ERROR: Signal TP is zero for %s, setting default", strategy_name));
double atr = GetATR(_Symbol, (ENUM_TIMEFRAMES)_Period, 14);
signal.tp = signal.price + (atr > 0 ? atr * 2.5 : 200 * _Point);
signal.take_profit = signal.tp;
}
if(signal.confidence <= 0.0 || signal.confidence > 1.0)
{
Print(StringFormat("[SignalGen] WARNING: Signal confidence invalid (%.4f) for %s, setting to 0.5", signal.confidence, strategy_name));
signal.confidence = 0.5;
}
// Ensure market context is set
if(signal.volatility <= 0.0)
signal.volatility = GetVolatility(_Symbol, (ENUM_TIMEFRAMES)_Period);
if(signal.regime == "")
signal.regime = GetMarketRegime();
if(signal.market_regime == "")
signal.market_regime = signal.regime;
if(signal.correlation == 0.0)
signal.correlation = GetCorrelation();
Print(StringFormat("[SignalGen] SUCCESS: %s signal validated and ready", strategy_name));
return signal;
}
else if(!generated)
{
Print(StringFormat("[SignalGen] Registry failed to generate signal for %s (no signal condition met)", strategy_name));
}
else
{
Print(StringFormat("[SignalGen] Registry generated signal but ID is empty for %s", strategy_name));
}
}
else
{
Print("[SignalGen] ERROR: g_signal_registry is NULL or invalid");
}
// Fallback to legacy MA crossover signal generation if registry unavailable or no signal
Print("[SignalGen] Falling back to legacy GenerateSignal()");
signal = GenerateSignal();
// Only override strategy name and ID if a valid signal was generated
if(signal.id != "")
{
signal.id = strategy_name + "_" + IntegerToString(TimeCurrent());
signal.strategy = strategy_name;
// Ensure market context is set
if(signal.volatility <= 0.0)
signal.volatility = GetVolatility(_Symbol, (ENUM_TIMEFRAMES)_Period);
if(signal.regime == "")
signal.regime = GetMarketRegime();
if(signal.market_regime == "")
signal.market_regime = signal.regime;
if(signal.correlation == 0.0)
signal.correlation = GetCorrelation();
}
else
{
Print("[SignalGen] WARNING: Legacy GenerateSignal() also returned empty signal");
}
return signal;
}
// Apply policy-based gating and scaling
bool ApplyPolicyGating(CSignalDecision &decision)
{
if(!g_policy_loaded)
{
// Fallback behavior when no policy is loaded
if(DefaultPolicyFallback)
{
if(ShouldLog(LOG_DEBUG))
LOG(StringFormat("FALLBACK: no policy loaded -> neutral scaling used for %s", decision.signal_id));
return true; // Allow with neutral scaling
}
return false; // Block if no fallback allowed
}
// Simple policy check - in production this would be more sophisticated
if(decision.confidence < g_policy_min_conf)
{
if(ShouldLog(LOG_DEBUG))
LOG(StringFormat("Policy gating blocked: confidence %.2f < min %.2f", decision.confidence, g_policy_min_conf));
return false;
}
// Apply policy scaling (placeholder implementation)
// In production, this would look up specific strategy/symbol/timeframe policies
decision.final_sl = decision.original_sl * 1.0; // No scaling for now
decision.final_tp = decision.original_tp * 1.0; // No scaling for now
decision.final_volume = decision.original_volume * 1.0; // No scaling for now
return true;
}
// Export enhanced features for ML training
void ExportEnhancedFeatures(const CSignalDecision &decision, const string strategy_name)
{
if(CheckPointer(g_features) == POINTER_INVALID) return;
// Create comprehensive feature set
string features[];
ArrayResize(features, 15);
datetime now = TimeCurrent();
MqlDateTime _dt; TimeToStruct(now, _dt); int _hour = _dt.hour;
features[0] = "strategy:" + strategy_name;
features[1] = "symbol:" + decision.symbol;
features[2] = "timeframe:" + IntegerToString(_Period);
features[3] = "entry_price:" + DoubleToString(decision.final_price, 5);
features[4] = "volume:" + DoubleToString(decision.final_volume, 2);
features[5] = "order_type:" + IntegerToString(decision.order_type);
features[6] = "confidence:" + DoubleToString(decision.confidence, 3);
features[7] = "volatility:" + DoubleToString(GetVolatility(_Symbol, (ENUM_TIMEFRAMES)_Period), 4);
features[8] = "correlation:" + DoubleToString(GetCorrelation(), 3);
features[9] = "market_regime:" + GetMarketRegime();
features[10] = "session_hour:" + IntegerToString(_hour);
features[11] = "spread_points:" + DoubleToString((SymbolInfoDouble(_Symbol, SYMBOL_ASK) - SymbolInfoDouble(_Symbol, SYMBOL_BID)) / _Point, 1);
features[12] = "equity:" + DoubleToString(AccountInfoDouble(ACCOUNT_EQUITY), 2);
features[13] = "balance:" + DoubleToString(AccountInfoDouble(ACCOUNT_BALANCE), 2);
features[14] = "margin_level:" + DoubleToString(AccountInfoDouble(ACCOUNT_MARGIN_LEVEL), 2);
// Export to features system
g_features.ExportFeatures(decision.symbol, strategy_name, now, features);
}
void ExportEnhancedFeaturesAdaptive(const CAdaptiveDecision &decision, const string strategy_name)
{
if(CheckPointer(g_features) == POINTER_INVALID)
return;
datetime ts = (decision.execution_time > 0) ? decision.execution_time : TimeCurrent();
string features[];
int feature_count = 0;
AppendSnapshotFeature(features, feature_count, "timestamp", TimeToString(ts, TIME_DATE|TIME_SECONDS));
AppendSnapshotFeature(features, feature_count, "strategy", strategy_name);
AppendSnapshotFeature(features, feature_count, "symbol", decision.symbol);
AppendSnapshotFeature(features, feature_count, "signal_id", decision.signal_id);
AppendSnapshotFeature(features, feature_count, "original_signal_id", (decision.is_adjusted && decision.original_signal_id != "") ? decision.original_signal_id : decision.signal_id);
AppendSnapshotFeature(features, feature_count, "is_adjusted", decision.is_adjusted ? "1" : "0");
AppendSnapshotFeature(features, feature_count, "adjustment_attempts", IntegerToString(decision.adjustment_attempts));
AppendSnapshotFeature(features, feature_count, "executed", decision.executed ? "1" : "0");
AppendSnapshotFeature(features, feature_count, "confidence", DoubleToString(decision.confidence, 3));
AppendSnapshotFeature(features, feature_count, "market_regime", decision.market_regime);
AppendSnapshotFeature(features, feature_count, "volatility", DoubleToString(decision.volatility, 6));
AppendSnapshotFeature(features, feature_count, "correlation", DoubleToString(decision.correlation_score, 6));
AppendSnapshotFeature(features, feature_count, "original_price", DoubleToString(decision.original_price, 5));
AppendSnapshotFeature(features, feature_count, "original_sl", DoubleToString(decision.original_sl, 5));
AppendSnapshotFeature(features, feature_count, "original_tp", DoubleToString(decision.original_tp, 5));
AppendSnapshotFeature(features, feature_count, "original_volume", DoubleToString(decision.original_volume, 2));
AppendSnapshotFeature(features, feature_count, "final_price", DoubleToString(decision.final_price, 5));
AppendSnapshotFeature(features, feature_count, "final_sl", DoubleToString(decision.final_sl, 5));
AppendSnapshotFeature(features, feature_count, "final_tp", DoubleToString(decision.final_tp, 5));
AppendSnapshotFeature(features, feature_count, "final_volume", DoubleToString(decision.final_volume, 2));
double price_delta_pct = 0.0;
if(MathAbs(decision.original_price) > 1e-9)
price_delta_pct = (decision.final_price - decision.original_price) / decision.original_price * 100.0;
double volume_delta_pct = 0.0;
if(MathAbs(decision.original_volume) > 1e-9)
volume_delta_pct = (decision.final_volume - decision.original_volume) / decision.original_volume * 100.0;
AppendSnapshotFeature(features, feature_count, "price_change_pct", DoubleToString(price_delta_pct, 3));
AppendSnapshotFeature(features, feature_count, "volume_change_pct", DoubleToString(volume_delta_pct, 3));
double sl_scale = (MathAbs(decision.original_sl) > 1e-9) ? decision.final_sl / decision.original_sl : 1.0;
double tp_scale = (MathAbs(decision.original_tp) > 1e-9) ? decision.final_tp / decision.original_tp : 1.0;
AppendSnapshotFeature(features, feature_count, "sl_scale", DoubleToString(sl_scale, 4));
AppendSnapshotFeature(features, feature_count, "tp_scale", DoubleToString(tp_scale, 4));
int gate_passed = CountPassedGates(decision);
AppendSnapshotFeature(features, feature_count, "gate_passed_count", IntegerToString(gate_passed));
string first_block_reason = "";
for(int i = 0; i < 8; i++)
{
string gate_key = StringFormat("gate%d", i + 1);
AppendSnapshotFeature(features, feature_count, gate_key + "_pass", decision.gate_results[i] ? "1" : "0");
if(decision.gate_reasons[i] != "")
{
AppendSnapshotFeature(features, feature_count, gate_key + "_reason", decision.gate_reasons[i]);
if(!decision.gate_results[i] && first_block_reason == "")
first_block_reason = decision.gate_reasons[i];
}
}
if(first_block_reason != "")
AppendSnapshotFeature(features, feature_count, "first_block_reason", first_block_reason);
if(decision.is_adjusted)
{
int attempts = MathMin(decision.adjustment_attempts, ArraySize(decision.attempts));
for(int j = 0; j < attempts; j++)
{
string prefix = StringFormat("attempt%d_", j + 1);
AppendSnapshotFeature(features, feature_count, prefix + "passed", decision.attempts[j].passed ? "1" : "0");
AppendSnapshotFeature(features, feature_count, prefix + "price_tweak", DoubleToString(decision.attempts[j].price_tweak, 4));
AppendSnapshotFeature(features, feature_count, prefix + "sl_tweak", DoubleToString(decision.attempts[j].sl_tweak, 4));
AppendSnapshotFeature(features, feature_count, prefix + "tp_tweak", DoubleToString(decision.attempts[j].tp_tweak, 4));
AppendSnapshotFeature(features, feature_count, prefix + "volume_tweak", DoubleToString(decision.attempts[j].volume_tweak, 4));
if(decision.attempts[j].reason != "")
AppendSnapshotFeature(features, feature_count, prefix + "reason", decision.attempts[j].reason);
}
}
g_features.ExportFeatures(decision.symbol, strategy_name, ts, features);
}
//+------------------------------------------------------------------+
//| ENHANCED TIMER FUNCTION |
//+------------------------------------------------------------------+
void OnTimer()
{
// Real positions updated automatically by MT5
// No need for UpdatePaperPositions()
// ===================[ PERIODIC SYSTEM MAINTENANCE ]===================
static datetime last_maintenance = 0;
datetime now = TimeCurrent();
// ===================[ 10s HOT-RELOAD (policy + config) ]===================
static datetime last_hot_reload = 0;
if(HotReloadIntervalSec > 0 && (now - last_hot_reload) >= HotReloadIntervalSec)
{
// Policy: rate-based selection between HTTP and file
if(UsePolicyGating)
{
int roll = MathRand() % 100;
bool try_http = (roll < PolicyHttpPollPercent);
if(try_http)
{
int new_len = LoadPolicyFromHttp(PolicyServerUrl);
if(new_len >= 0 && new_len != g_policy_last_len)
{
g_policy_last_len = new_len;
LOG("Policy reloaded via HTTP");
}
}
else
{
// Check file length first to avoid unnecessary reload logs
int hpf = FileOpen(PolicyFilePath, FILE_READ|FILE_COMMON|FILE_TXT|FILE_ANSI);
if(hpf != INVALID_HANDLE)
{
int flen = (int)FileSize(hpf); FileClose(hpf);
if(flen != g_policy_last_len)
{
bool ok = Policy_Load();
if(ok)
{
g_policy_last_len = flen;
LOG("Policy reloaded via file");
}
}
}
}
}
// Config reload: size-based change detection
int hcf = FileOpen(ConfigFilePath, FILE_READ|FILE_COMMON|FILE_TXT|FILE_ANSI);
if(hcf != INVALID_HANDLE)
{
int clen = (int)FileSize(hcf); FileClose(hcf);
if(clen != g_config_last_len)
{
CConfigManager *cfgm = CConfigManager::GetInstance();
if(CheckPointer(cfgm) != POINTER_INVALID)
{
cfgm.LoadFromFile(ConfigFilePath);
g_config_last_len = clen;
LOG("Config reloaded from file");
}
}
}
last_hot_reload = now;
}
// ===================[ 10s DECISION + EXECUTION CADENCE ]===================
static datetime last_decision_run = 0;
if((now - last_decision_run) >= 10)
{
RunDecisionPipelineOnce();
last_decision_run = now;
}
if(now - last_maintenance > 300) // Every 5 minutes
{
// Check for policy reload signals
CheckPolicyReload();
// Check for insights reload signals
CheckInsightsReload();
// Maintenance hooks for session/correlation managers can be added here if needed
// Reload news events periodically
if(UseNewsFilter)
{
LoadNewsEvents();
}
last_maintenance = now;
}
// ===================[ LEARNING SYSTEM UPDATES ]===================
static datetime last_learning_update = 0;
static CLiveAdaptation live_adapter; // Live performance-based adaptation
if(now - last_learning_update > 1800) // Every 30 minutes
{
// Universal auto-detection: recalculate parameters based on current market conditions
if(AutoDetectParameters) {
g_adaptive_engine.CalculateDynamicParameters(_Symbol, (ENUM_TIMEFRAMES)_Period);
// Get fresh profile after recalculation
SymbolProfile updated_profile = g_adaptive_engine.GetCurrentProfile();
// Apply updated parameters if override is allowed
if(AllowManualOverride) {
StopLossPips = updated_profile.optimal_sl_mult;
TakeProfitPips = updated_profile.optimal_tp_mult;
VolSizerTargetRisk = updated_profile.risk_multiplier;
if(Verbosity >= 2) {
LOG(StringFormat("🔄 [AUTO-ADAPT] Parameters updated: SL=%.1f TP=%.1f Risk=%.2f%%",
StopLossPips, TakeProfitPips, VolSizerTargetRisk));
}
}
// ML-based live adaptation (adjusts parameters based on recent performance)
if(EnableMLAdaptation && TimeCurrent() - g_last_adaptation > AdaptationIntervalMinutes * 60) {
// Get recent performance metrics (from knowledge base or simulated)
double recent_pf = g_ml_engine.GetRecentProfitFactor(100);
double recent_wr = g_ml_engine.GetRecentWinRate(100);
double recent_dd = g_ml_engine.GetRecentMaxDrawdown(100);
double recent_vol = g_ml_engine.GetRecentVolatility(50);
// Update live adapter with performance data
live_adapter.UpdateFromLiveTrading(recent_pf, recent_wr, recent_dd, recent_vol);
// Calculate adaptive adjustment (0.7 - 1.3 range)
double ml_adjustment = live_adapter.CalculateAdaptiveAdjustment();
// Apply ML adjustments to gating thresholds (AGGRESSIVE profile constraints)
P5_MinPF = MathMax(1.9, MathMin(3.0, P5_MinPF * ml_adjustment));
P5_MinWR = MathMax(0.5, MathMin(1.0, P5_MinWR * ml_adjustment));
CBDailyLossLimitPct = MathMax(5.0, MathMin(10.0, CBDailyLossLimitPct * (2.0 - ml_adjustment)));
if(Verbosity >= 1) {
LOG(StringFormat("🧠 [ML-ADAPT] PF=%.2f WR=%.2f DD=%.2f%% Adj=%.3f | MinPF=%.2f MinWR=%.2f MaxDD=%.1f%%",
recent_pf, recent_wr, recent_dd * 100, ml_adjustment,
P5_MinPF, P5_MinWR, CBDailyLossLimitPct));
}
g_last_adaptation = TimeCurrent();
}
}
// Periodic learning updates
if(CheckPointer(g_gate_manager) != POINTER_INVALID)
g_gate_manager.UpdateFromLearning();
if(UseStrategySelector && CheckPointer(g_selector) != POINTER_INVALID)
g_selector.EnsureRecentLoaded(SelRecentDays);
// Transfer successful signals to live EA (if learning bridge available)
if(CheckPointer(g_learning_bridge) != POINTER_INVALID)
g_learning_bridge.TransferSuccessfulSignals("C:\\DualEA\\LiveData");
last_learning_update = now;
}
// ===================[ HEARTBEAT AND HEALTH CHECKS ]===================
static datetime last_heartbeat = 0;
if(HeartbeatEnabled && (now - last_heartbeat > HeartbeatMinutes * 60))
{
// System health check using real MT5 positions
int active_positions = PositionsTotal();
if(HeartbeatVerbose)
{
LOG("=== PaperEA v2 Heartbeat ===");
LOG(StringFormat("Time: %s | Active Positions: %d | Equity: %.2f",
TimeToString(now), active_positions, AccountInfoDouble(ACCOUNT_EQUITY)));
LOG(StringFormat("Policy Loaded: %s | NoConstraints: %s | UseSelector: %s",
g_policy_loaded ? "YES" : "NO",
NoConstraintsMode ? "ON" : "OFF",
UseStrategySelector ? "ON" : "OFF"));
}
last_heartbeat = now;
}
// ===================[ P0-P5 PERIODIC MAINTENANCE ]===================
// Flush batch telemetry, check shadow trades, feature drift maintenance
OnTimerP0P5();
}
//+------------------------------------------------------------------+
//| ONTRADE TRANSACTION HANDLER - ENHANCED POSITION TRACKING |
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction &trans,
const MqlTradeRequest &request,
const MqlTradeResult &result)
{
// Filter to current chart symbol and handle order cancellations
string trans_symbol = trans.symbol;
if(trans_symbol != _Symbol) return;
int t = (int)trans.type;
if(t == TRADE_TRANSACTION_ORDER_DELETE)
{
// Clean pending order mapping if order is cancelled/expired
ulong ord = trans.order;
if(ord > 0)
{
for(int i = 0; i < ArraySize(g_pending_orders); ++i)
if(g_pending_orders[i] == ord)
{
int last = ArraySize(g_pending_orders) - 1;
g_pending_orders[i] = g_pending_orders[last];
g_pending_orders_strat[i] = g_pending_orders_strat[last];
ArrayResize(g_pending_orders, last);
ArrayResize(g_pending_orders_strat, last);
break;
}
}
return;
}
// We only care about deal executions beyond this point
if(t != TRADE_TRANSACTION_DEAL_ADD) return;
ulong deal = trans.deal;
if(deal == 0) return;
int entry_flag = (int)HistoryDealGetInteger(deal, DEAL_ENTRY);
ulong pid = (ulong)HistoryDealGetInteger(deal, DEAL_POSITION_ID);
string deal_symbol = HistoryDealGetString(deal, DEAL_SYMBOL);
long dmagic = (long)HistoryDealGetInteger(deal, DEAL_MAGIC);
// Filter to current chart symbol and our magic if available
if(deal_symbol != _Symbol) return;
if(MagicNumber > 0 && dmagic != MagicNumber) return;
if(entry_flag == DEAL_ENTRY_IN)
{
// Track newly opened position if not already tracked
if(pid > 0)
{
if(FindTrackedIndexByPid(pid) >= 0) return; // already tracked
string strat_name = "unknown";
// Try to attribute strategy from pending mapping
for(int m = 0; m < ArraySize(g_pending_deals); ++m)
{
if(g_pending_deals[m] == deal)
{
strat_name = g_pending_deals_strat[m];
int last = ArraySize(g_pending_deals) - 1;
g_pending_deals[m] = g_pending_deals[last];
g_pending_deals_strat[m] = g_pending_deals_strat[last];
ArrayResize(g_pending_deals, last);
ArrayResize(g_pending_deals_strat, last);
break;
}
}
// Add to tracking arrays
int k = ArraySize(g_pos_ids);
ArrayResize(g_pos_ids, k + 1);
ArrayResize(g_pos_strats, k + 1);
ArrayResize(g_pos_entry_price, k + 1);
ArrayResize(g_pos_initial_risk, k + 1);
ArrayResize(g_pos_start_time, k + 1);
ArrayResize(g_pos_type, k + 1);
ArrayResize(g_pos_max_price, k + 1);
ArrayResize(g_pos_min_price, k + 1);
g_pos_ids[k] = pid;
g_pos_strats[k] = strat_name;
double entry_p = HistoryDealGetDouble(deal, DEAL_PRICE);
if(entry_p <= 0 && PositionSelectByTicket(pid))
entry_p = PositionGetDouble(POSITION_PRICE_OPEN);
g_pos_entry_price[k] = entry_p;
g_pos_max_price[k] = entry_p;
g_pos_min_price[k] = entry_p;
int ptype = POSITION_TYPE_BUY;
if(PositionSelectByTicket(pid))
ptype = (int)PositionGetInteger(POSITION_TYPE);
g_pos_type[k] = ptype;
double init_risk = 0.0;
if(PositionSelectByTicket(pid))
{
double slc = PositionGetDouble(POSITION_SL);
double eop = PositionGetDouble(POSITION_PRICE_OPEN);
if(slc > 0 && eop > 0)
init_risk = MathAbs((ptype == POSITION_TYPE_BUY ? eop - slc : slc - eop));
}
g_pos_initial_risk[k] = init_risk;
// Use deal time for accurate hold time
g_pos_start_time[k] = (datetime)HistoryDealGetInteger(deal, DEAL_TIME);
if(ShouldLog(LOG_INFO))
LOG(StringFormat("Tracked pos via OnTradeTransaction: ticket=%I64u strat=%s entry=%.5f initR=%.5f",
pid, g_pos_strats[k], entry_p, init_risk));
}
return;
}
else if(entry_flag == DEAL_ENTRY_OUT)
{
if(pid == 0) return;
int idx = FindTrackedIndexByPid(pid);
if(idx < 0)
{
// Not tracked; nothing to do
return;
}
// If still open, treat as partial close; wait for final close
if(PositionSelectByTicket(pid)) return;
// Calculate R-multiple for IncrementalInsightEngine
if(CheckPointer(g_insight_engine) != POINTER_INVALID && idx >= 0)
{
double entry_price = g_pos_entry_price[idx];
double exit_price = HistoryDealGetDouble(deal, DEAL_PRICE);
double sl_price = g_pos_entry_price[idx] - g_pos_initial_risk[idx]; // Approximate SL
double profit = HistoryDealGetDouble(deal, DEAL_PROFIT);
if(g_pos_initial_risk[idx] > 0)
{
double r_multiple = profit / g_pos_initial_risk[idx];
// Normalize for position type
if(g_pos_type[idx] == POSITION_TYPE_SELL)
r_multiple = -r_multiple;
string strat = g_pos_strats[idx];
int tf = (int)_Period; // Use chart timeframe
g_insight_engine.RecordTradeOutcome(strat, _Symbol, tf, r_multiple);
if(ShouldLog(LOG_INFO))
LOG(StringFormat("[InsightEngine] Recorded outcome: %s R=%.2f", strat, r_multiple));
}
}
// Fully closed -> log and remove
HandlePositionClosed(idx, deal);
return;
}
}
//+------------------------------------------------------------------+
//| GENETIC OPTIMIZATION FITNESS FUNCTION |
//| Implements robust metric from chat-8Stage guide |
//| Penalizes overfitting, rewards consistency |
//+------------------------------------------------------------------+
double OnTester()
{
// Use robust metric (not just profit)
double profit_factor = TesterStatistics(STAT_PROFIT_FACTOR);
double drawdown = TesterStatistics(STAT_BALANCE_DDREL_PERCENT);
double sharpe = TesterStatistics(STAT_SHARPE_RATIO);
double win_rate = TesterStatistics(STAT_TRADES_WIN) /
(TesterStatistics(STAT_TRADES_WIN) + TesterStatistics(STAT_TRADES_LOSS));
// Multi-objective fitness: ProfitFactor * (1 - DD) * Sharpe * WR
// Penalize high drawdown heavily
if(drawdown > 20.0) return 0.0;
// Normalize components
double pf_score = MathMin(profit_factor, 3.0) / 3.0; // Cap at 3.0
double dd_score = 1.0 - (drawdown / 100.0);
double sharpe_score = MathMax(0, sharpe) / 3.0; // Normalize Sharpe
double wr_score = win_rate;
// Weighted combination (from guide: prioritize PF and DD)
double fitness = (pf_score * 0.4 + dd_score * 0.3 + sharpe_score * 0.2 + wr_score * 0.1);
// Additional penalties
if(TesterStatistics(STAT_TRADES_TOTAL) < 20) fitness *= 0.5; // Insufficient trades
if(profit_factor < 1.0) fitness *= 0.1; // Losing system
return fitness;
}
//+------------------------------------------------------------------+
//| GATE PERFORMANCE MONITORING |
//| Tracks per-gate latency and execution metrics |
//+------------------------------------------------------------------+
struct SGatePerformanceMetrics
{
ulong total_calls;
ulong total_latency_us;
ulong max_latency_us;
ulong min_latency_us;
ulong pass_count;
ulong fail_count;
void Init()
{
total_calls = 0;
total_latency_us = 0;
max_latency_us = 0;
min_latency_us = ULONG_MAX;
pass_count = 0;
fail_count = 0;
}
void Record(ulong latency_us, bool passed)
{
total_calls++;
total_latency_us += latency_us;
max_latency_us = MathMax(max_latency_us, latency_us);
min_latency_us = MathMin(min_latency_us, latency_us);
if(passed) pass_count++;
else fail_count++;
}
double GetAvgLatency()
{
return (total_calls > 0) ? (double)total_latency_us / total_calls : 0.0;
}
double GetPassRate()
{
return (total_calls > 0) ? (double)pass_count / total_calls : 0.0;
}
};
SGatePerformanceMetrics g_gate_metrics[8]; // One per gate
//+------------------------------------------------------------------+
//| Record gate performance metrics |
//+------------------------------------------------------------------+
void RecordGateMetrics(int gate_num, ulong latency_us, bool passed)
{
if(gate_num >= 1 && gate_num <= 8)
{
g_gate_metrics[gate_num - 1].Record(latency_us, passed);
}
}
//+------------------------------------------------------------------+
//| Print gate performance summary |
//+------------------------------------------------------------------+
void PrintGatePerformanceSummary()
{
Print("=== GATE PERFORMANCE SUMMARY ===");
for(int i = 0; i < 8; i++)
{
if(g_gate_metrics[i].total_calls > 0)
{
string gate_name = StringFormat("Gate %d", i + 1);
switch(i)
{
case 0: gate_name = "G1 SignalRinse"; break;
case 1: gate_name = "G2 MarketSoap"; break;
case 2: gate_name = "G3 StrategyScrub"; break;
case 3: gate_name = "G4 RiskWash"; break;
case 4: gate_name = "G5 PerformanceWax"; break;
case 5: gate_name = "G6 ML Polish"; break;
case 6: gate_name = "G7 LiveClean"; break;
case 7: gate_name = "G8 FinalVerify"; break;
}
Print(StringFormat("%s: calls=%I64u avg=%.1fus max=%I64u min=%I64u pass=%.1f%%",
gate_name,
g_gate_metrics[i].total_calls,
g_gate_metrics[i].GetAvgLatency(),
g_gate_metrics[i].max_latency_us,
g_gate_metrics[i].min_latency_us,
g_gate_metrics[i].GetPassRate() * 100.0));
}
}
Print("================================");
}
//+------------------------------------------------------------------+
//| Helper: Check if trade is allowed (MQL5 compatibility) |
//+------------------------------------------------------------------+
bool IsTradeAllowed()
{
// Check terminal trade permission and expert advisor enabled
return TerminalInfoInteger(TERMINAL_TRADE_ALLOWED) != 0 &&
MQLInfoInteger(MQL_TRADE_ALLOWED) != 0;
}
//+------------------------------------------------------------------+
//| WEEKEND/MARKET STATUS CHECK |
//| Robustness: Handle no-tick periods per guide |
//+------------------------------------------------------------------+
bool IsTradeAllowedExtended()
{
// Basic trade allowed check
if(!IsTradeAllowed()) return false;
// Check if market is open (handles weekends)
datetime now = TimeCurrent();
MqlDateTime dt;
TimeToStruct(now, dt);
// Weekend check (Friday after 20:00 or Sunday before 22:00)
if(dt.day_of_week == 5 && dt.hour >= 20) return false; // Friday evening
if(dt.day_of_week == 0 && dt.hour < 22) return false; // Sunday early
if(dt.day_of_week == 6) return false; // Saturday
// Check spread (Gate 7 logic integrated)
long spread_raw = SymbolInfoInteger(_Symbol, SYMBOL_SPREAD);
double spread = (double)spread_raw;
double avg_spread = GetAverageSpread(20);
if(spread > avg_spread * 3.0) // Spread > 3x average
{
static datetime last_spread_warn = 0;
if(now - last_spread_warn > 300) // Warn every 5 minutes
{
Print(StringFormat("WARNING: Spread too high (%d vs avg %.1f) - skipping tick",
(int)spread, avg_spread));
last_spread_warn = now;
}
return false;
}
return true;
}
//+------------------------------------------------------------------+
//| Calculate average spread over N periods |
//+------------------------------------------------------------------+
double GetAverageSpread(int periods)
{
double sum = 0;
for(int i = 0; i < periods; i++)
{
sum += iSpread(_Symbol, _Period, i);
}
return (periods > 0) ? sum / periods : 0;
}
//+------------------------------------------------------------------+
//| WALK-FORWARD ANALYSIS SUPPORT |
//| Enable regime-based parameter loading |
//+------------------------------------------------------------------+
input group "=== WALK-FORWARD ANALYSIS ==="
input bool WFA_Enabled = false; // Enable walk-forward mode
input string WFA_ParameterFile = "wfa_params.json"; // Parameter file path
input int WFA_RetrainIntervalDays = 7; // Days between parameter reload
datetime g_last_wfa_reload = 0;
//+------------------------------------------------------------------+
//| Check and reload WFA parameters |
//+------------------------------------------------------------------+
void CheckWFAReload()
{
if(!WFA_Enabled) return;
datetime now = TimeCurrent();
if((now - g_last_wfa_reload) < WFA_RetrainIntervalDays * 86400) return;
string filepath = StringFormat("DualEA\\%s", WFA_ParameterFile);
if(FileIsExist(filepath, FILE_COMMON))
{
Print(StringFormat("[WFA] Reloading parameters from %s", WFA_ParameterFile));
// Load parameters from JSON (simplified - in production use proper JSON parser)
// This would update gate thresholds based on out-of-sample performance
g_last_wfa_reload = now;
}
}
//+------------------------------------------------------------------+
//| Enhanced ExecuteGateCascade with metrics |
//| Fail-fast with per-gate timing from guide |
//+------------------------------------------------------------------+
bool ExecuteGateCascadeEnhanced(TradingSignal &signal, bool &all_passed, string &block_reason)
{
ulong cascade_start = GetMicrosecondCount();
all_passed = true;
// Gate 1: Signal Rinse
ulong g1_start = GetMicrosecondCount();
bool g1_pass = g_gate_manager.ProcessGate1(signal);
RecordGateMetrics(1, GetMicrosecondCount() - g1_start, g1_pass);
if(!g1_pass)
{
all_passed = false;
block_reason = "G1 SignalRinse rejected";
return false;
}
// Gate 2: Market Soap
ulong g2_start = GetMicrosecondCount();
bool g2_pass = g_gate_manager.ProcessGate2(signal);
RecordGateMetrics(2, GetMicrosecondCount() - g2_start, g2_pass);
if(!g2_pass)
{
all_passed = false;
block_reason = "G2 MarketSoap rejected";
return false;
}
// Gate 3: Strategy Scrub
ulong g3_start = GetMicrosecondCount();
bool g3_pass = g_gate_manager.ProcessGate3(signal);
RecordGateMetrics(3, GetMicrosecondCount() - g3_start, g3_pass);
if(!g3_pass)
{
all_passed = false;
block_reason = "G3 StrategyScrub rejected";
return false;
}
// Gate 4: Risk Wash
ulong g4_start = GetMicrosecondCount();
bool g4_pass = g_gate_manager.ProcessGate4(signal);
RecordGateMetrics(4, GetMicrosecondCount() - g4_start, g4_pass);
if(!g4_pass)
{
all_passed = false;
block_reason = "G4 RiskWash rejected";
return false;
}
// Gate 5: Performance Wax
ulong g5_start = GetMicrosecondCount();
bool g5_pass = g_gate_manager.ProcessGate5(signal);
RecordGateMetrics(5, GetMicrosecondCount() - g5_start, g5_pass);
if(!g5_pass)
{
all_passed = false;
block_reason = "G5 PerformanceWax rejected";
return false;
}
// Gate 6: ML Polish
ulong g6_start = GetMicrosecondCount();
bool g6_pass = g_gate_manager.ProcessGate6(signal);
RecordGateMetrics(6, GetMicrosecondCount() - g6_start, g6_pass);
if(!g6_pass)
{
all_passed = false;
block_reason = "G6 ML Polish rejected";
return false;
}
// Gate 7: Live Clean
ulong g7_start = GetMicrosecondCount();
bool g7_pass = g_gate_manager.ProcessGate7(signal);
RecordGateMetrics(7, GetMicrosecondCount() - g7_start, g7_pass);
if(!g7_pass)
{
all_passed = false;
block_reason = "G7 LiveClean rejected";
return false;
}
// Gate 8: Final Verify
ulong g8_start = GetMicrosecondCount();
bool g8_pass = g_gate_manager.ProcessGate8(signal);
RecordGateMetrics(8, GetMicrosecondCount() - g8_start, g8_pass);
if(!g8_pass)
{
all_passed = false;
block_reason = "G8 FinalVerify rejected";
return false;
}
// Performance warning if cascade > 5ms
double elapsed_ms = (GetMicrosecondCount() - cascade_start) / 1000.0;
if(elapsed_ms > 5.0)
{
Print(StringFormat("WARNING: Gate cascade took %.2fms (>5ms threshold)", elapsed_ms));
}
return true;
}
Reference in a new issueView git blameCopy permalink