626 lines
21 KiB
MQL5
626 lines
21 KiB
MQL5
 | //+------------------------------------------------------------------+
| ||
//| DualEA_MasterIntegration.mqh - Complete P0/P1 Integration |
| |||
//| Master include file that initializes all hardened components |
| |||
//| Version: 2.0 - Comprehensive EA Hardening & Intelligence Upgrade |
| |||
//+------------------------------------------------------------------+
| |||
#ifndef DUALEA_MASTERINTEGRATION_MQH
| |||
#define DUALEA_MASTERINTEGRATION_MQH
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| P0 Components - Critical Fixes |
| |||
//+------------------------------------------------------------------+
| |||
#include "CShadowLogger.mqh" // P0-1: Atomic CSV writes
| |||
#include "CGateFeatureCache.mqh" // P0-5: Feature caching
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| P1 Components - Architecture Upgrades |
| |||
//+------------------------------------------------------------------+
| |||
#include "CSQLiteKnowledgeBase.mqh" // P1-1: SQLite KB
| |||
#include "CInsightGateBridge.mqh" // P1-2: O(1) insights bridge
| |||
#include "CRegimeAwareStrategy.mqh" // P1-3: Regime adaptation
| |||
#include "CSystemMonitor.mqh" // P1-4: Health circuit breaker
| |||
// Replaced Redis with SQLite - zero external dependencies
| |||
#include "CSQLiteExplorationCounter.mqh"// P1-5: Redis counters
| |||
#include "CPositionManager.mqh" // P1-6: Correlation sizing
| |||
| |||
// Include existing components
| |||
#include "EnhancedEfficientGateSystem.mqh"
| |||
#include "CMLPolishGateONNX.mqh"
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Configuration Structure |
| |||
//+------------------------------------------------------------------+
| |||
struct SDualEAConfig
| |||
{
| |||
// P0-1: Shadow logging
| |||
bool shadow_logging_enabled;
| |||
bool shadow_mode_only;
| |||
string shadow_log_directory;
| |||
| |||
// P0-4: ONNX monitoring
| |||
bool onnx_health_monitor_enabled;
| |||
int onnx_max_latency_ms;
| |||
| |||
// P0-5: Feature cache
| |||
int feature_cache_max_age_seconds;
| |||
| |||
// P1-1: SQLite
| |||
bool sqlite_enabled;
| |||
string sqlite_db_name;
| |||
| |||
// P1-2: Insight bridge
| |||
int insight_cache_sync_seconds;
| |||
| |||
// P1-4: System monitor
| |||
bool circuit_breaker_enabled;
| |||
double max_tick_latency_ms;
| |||
double max_error_rate_per_hour;
| |||
int circuit_breaker_cooldown_minutes;
| |||
| |||
// P1-5: Redis
| |||
bool redis_enabled;
| |||
string redis_host;
| |||
int redis_port;
| |||
| |||
// P1-6: Position management
| |||
bool correlation_sizing_enabled;
| |||
bool volatility_exits_enabled;
| |||
double max_risk_per_trade_pct;
| |||
double max_total_risk_pct;
| |||
int max_positions;
| |||
| |||
void SetDefaults()
| |||
{
| |||
// P0 defaults
| |||
shadow_logging_enabled = true;
| |||
shadow_mode_only = false;
| |||
shadow_log_directory = "DualEA\\ShadowLogs";
| |||
| |||
// P0-4 defaults
| |||
onnx_health_monitor_enabled = true;
| |||
onnx_max_latency_ms = 100;
| |||
| |||
// P0-5 defaults
| |||
feature_cache_max_age_seconds = 5;
| |||
| |||
// P1-1 defaults
| |||
sqlite_enabled = true;
| |||
sqlite_db_name = "dualea_kb.db";
| |||
| |||
// P1-2 defaults
| |||
insight_cache_sync_seconds = 60;
| |||
| |||
// P1-4 defaults
| |||
circuit_breaker_enabled = true;
| |||
max_tick_latency_ms = 50.0;
| |||
max_error_rate_per_hour = 50.0;
| |||
circuit_breaker_cooldown_minutes = 15;
| |||
| |||
// P1-5 defaults
| |||
redis_enabled = false; // Disabled by default (requires Redis server)
| |||
redis_host = "127.0.0.1";
| |||
redis_port = 6379;
| |||
| |||
// P1-6 defaults
| |||
correlation_sizing_enabled = true;
| |||
volatility_exits_enabled = true;
| |||
max_risk_per_trade_pct = 1.0;
| |||
max_total_risk_pct = 5.0;
| |||
max_positions = 10;
| |||
}
| |||
};
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Dual EA Master Controller |
| |||
//+------------------------------------------------------------------+
| |||
class CDualEAMasterController
| |||
{
| |||
private:
| |||
SDualEAConfig m_config;
| |||
bool m_initialized;
| |||
datetime m_last_status_log;
| |||
| |||
// Component references
| |||
CShadowLogger* m_shadow_logger;
| |||
CGateFeatureCache* m_feature_cache;
| |||
CSQLiteKnowledgeBase* m_sqlite_kb;
| |||
CInsightGateBridge* m_insight_bridge;
| |||
CRegimeAwareStrategy* m_regime_strategy;
| |||
CSystemMonitor* m_system_monitor;
| |||
CSQLiteExplorationCounter* m_explore_counter;
| |||
CPositionManager* m_position_manager;
| |||
| |||
public:
| |||
// Constructor
| |||
CDualEAMasterController()
| |||
{
| |||
m_config.SetDefaults();
| |||
m_initialized = false;
| |||
m_last_status_log = 0;
| |||
m_shadow_logger = NULL;
| |||
m_feature_cache = NULL;
| |||
m_sqlite_kb = NULL;
| |||
m_insight_bridge = NULL;
| |||
m_regime_strategy = NULL;
| |||
m_system_monitor = NULL;
| |||
m_explore_counter = NULL;
| |||
m_position_manager = NULL;
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize all components |
| |||
//+------------------------------------------------------------------+
| |||
bool Initialize(const SDualEAConfig &config)
| |||
{
| |||
m_config = config;
| |||
| |||
Print("=== DualEA Master Controller v2.0 Initializing ===");
| |||
| |||
// P0-5: Initialize feature cache first (others depend on it)
| |||
if(!InitializeFeatureCache()) return false;
| |||
| |||
// P1-1: Initialize SQLite KB
| |||
if(m_config.sqlite_enabled)
| |||
{
| |||
if(!InitializeSQLiteKB()) return false;
| |||
}
| |||
| |||
// P1-3: Initialize regime strategy (depends on feature cache)
| |||
if(!InitializeRegimeStrategy()) return false;
| |||
| |||
// P1-2: Initialize insight bridge (depends on SQLite KB)
| |||
if(m_config.sqlite_enabled)
| |||
{
| |||
if(!InitializeInsightBridge()) return false;
| |||
}
| |||
| |||
// P1-4: Initialize system monitor
| |||
if(m_config.circuit_breaker_enabled)
| |||
{
| |||
if(!InitializeSystemMonitor()) return false;
| |||
}
| |||
| |||
// P1-5: Initialize exploration counter (SQLite-based)
| |||
if(!InitializeExploreCounter()) return false;
| |||
| |||
// P1-6: Initialize position manager (depends on feature cache and regime)
| |||
if(!InitializePositionManager()) return false;
| |||
| |||
// P0-1: Initialize shadow logger
| |||
if(m_config.shadow_logging_enabled)
| |||
{
| |||
if(!InitializeShadowLogger()) return false;
| |||
}
| |||
| |||
m_initialized = true;
| |||
Print("=== DualEA Master Controller v2.0 Ready ===");
| |||
| |||
return true;
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Component initializers |
| |||
//+------------------------------------------------------------------+
| |||
bool InitializeFeatureCache()
| |||
{
| |||
m_feature_cache = new CGateFeatureCache();
| |||
if(!m_feature_cache.Initialize())
| |||
{
| |||
Print("[MasterController] ERROR: Feature cache initialization failed");
| |||
return false;
| |||
}
| |||
| |||
// Set global reference for gates
| |||
g_gate_feature_cache = m_feature_cache;
| |||
| |||
Print("[MasterController] P0-5: Feature cache initialized");
| |||
return true;
| |||
}
| |||
| |||
bool InitializeSQLiteKB()
| |||
{
| |||
m_sqlite_kb = new CSQLiteKnowledgeBase(m_config.sqlite_db_name);
| |||
if(!m_sqlite_kb.Initialize())
| |||
{
| |||
Print("[MasterController] WARNING: SQLite KB init failed, continuing with reduced functionality");
| |||
// Don't fail completely - we can work without SQLite
| |||
delete m_sqlite_kb;
| |||
m_sqlite_kb = NULL;
| |||
m_config.sqlite_enabled = false;
| |||
return true;
| |||
}
| |||
| |||
g_sqlite_kb = m_sqlite_kb;
| |||
Print("[MasterController] P1-1: SQLite KB initialized");
| |||
return true;
| |||
}
| |||
| |||
bool InitializeInsightBridge()
| |||
{
| |||
m_insight_bridge = new CInsightGateBridge(m_sqlite_kb);
| |||
if(!m_insight_bridge.Initialize(m_sqlite_kb))
| |||
{
| |||
Print("[MasterController] WARNING: Insight bridge init failed");
| |||
delete m_insight_bridge;
| |||
m_insight_bridge = NULL;
| |||
return true; // Don't fail completely
| |||
}
| |||
| |||
// CRITICAL: Preload historical data to populate bridge stats immediately
| |||
m_insight_bridge.PreloadHotStrategies();
| |||
| |||
g_insight_gate_bridge = m_insight_bridge;
| |||
Print("[MasterController] P1-2: Insight-Gate bridge initialized with historical data");
| |||
return true;
| |||
}
| |||
| |||
bool InitializeRegimeStrategy()
| |||
{
| |||
m_regime_strategy = new CRegimeAwareStrategy(m_feature_cache);
| |||
| |||
g_regime_strategy = m_regime_strategy;
| |||
Print("[MasterController] P1-3: Regime-aware strategy initialized");
| |||
return true;
| |||
}
| |||
| |||
bool InitializeSystemMonitor()
| |||
{
| |||
m_system_monitor = new CSystemMonitor();
| |||
| |||
// Thresholds are configured internally via SHealthThresholds.SetDefaults()
| |||
// m_system_monitor.SetThresholds() is not available - using default thresholds
| |||
| |||
g_system_monitor = m_system_monitor;
| |||
Print("[MasterController] P1-4: System monitor with circuit breaker initialized");
| |||
return true;
| |||
}
| |||
| |||
bool InitializeExploreCounter()
| |||
{
| |||
m_explore_counter = new CSQLiteExplorationCounter();
| |||
if(!m_explore_counter.Initialize())
| |||
{
| |||
Print("[MasterController] WARNING: Exploration counter init failed, using fallback");
| |||
delete m_explore_counter;
| |||
m_explore_counter = NULL;
| |||
return true; // Don't fail - fallback is built-in
| |||
}
| |||
| |||
g_sqliteCounter = m_explore_counter;
| |||
Print("[MasterController] P1-5: SQLite exploration counter initialized");
| |||
return true;
| |||
}
| |||
| |||
bool InitializePositionManager()
| |||
{
| |||
m_position_manager = new CPositionManager(m_feature_cache, m_regime_strategy);
| |||
| |||
// Configure
| |||
m_position_manager.SetMaxPositions(m_config.max_positions);
| |||
m_position_manager.SetMaxRiskPerTrade(m_config.max_risk_per_trade_pct);
| |||
m_position_manager.SetMaxTotalRisk(m_config.max_total_risk_pct);
| |||
| |||
SVolatilityExitConfig vol_config;
| |||
vol_config.SetDefaults();
| |||
m_position_manager.SetVolatilityExitConfig(vol_config);
| |||
| |||
g_position_manager = m_position_manager;
| |||
Print("[MasterController] P1-6: Position manager with correlation sizing initialized");
| |||
return true;
| |||
}
| |||
| |||
bool InitializeShadowLogger()
| |||
{
| |||
m_shadow_logger = new CShadowLogger();
| |||
| |||
if(!m_shadow_logger.Initialize(m_config.shadow_mode_only, m_config.shadow_log_directory))
| |||
{
| |||
Print("[MasterController] WARNING: Shadow logger init failed");
| |||
delete m_shadow_logger;
| |||
m_shadow_logger = NULL;
| |||
return true; // Don't fail
| |||
}
| |||
| |||
Print("[MasterController] P0-1: Shadow logger with atomic CSV initialized");
| |||
return true;
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| OnTick processing - call from EA's OnTick() |
| |||
//+------------------------------------------------------------------+
| |||
void OnTick()
| |||
{
| |||
if(!m_initialized) return;
| |||
| |||
// P0-5: Update feature cache
| |||
if(m_feature_cache != NULL)
| |||
m_feature_cache.Update();
| |||
| |||
// P1-3: Update regime detection
| |||
if(m_regime_strategy != NULL)
| |||
m_regime_strategy.Update();
| |||
| |||
// P1-4: Update system monitor
| |||
if(m_system_monitor != NULL)
| |||
m_system_monitor.OnTickUpdate();
| |||
| |||
// P1-6: Check volatility exits
| |||
if(m_position_manager != NULL)
| |||
m_position_manager.CheckVolatilityExits();
| |||
| |||
// P1-2: Sync insight bridge periodically
| |||
if(m_insight_bridge != NULL && m_system_monitor != NULL)
| |||
{
| |||
static int tick_counter = 0;
| |||
tick_counter++;
| |||
if(tick_counter % 600 == 0) // Every ~10 seconds (assuming 60 ticks/sec)
| |||
{
| |||
m_insight_bridge.OnTickSync();
| |||
}
| |||
}
| |||
| |||
// Log status periodically
| |||
if(TimeCurrent() - m_last_status_log > 300) // Every 5 minutes
| |||
{
| |||
LogSystemStatus();
| |||
m_last_status_log = TimeCurrent();
| |||
}
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Check if trading is allowed (circuit breaker) |
| |||
//+------------------------------------------------------------------+
| |||
bool IsTradingAllowed(string &reason)
| |||
{
| |||
reason = "";
| |||
| |||
// P1-4: Check system monitor circuit breaker
| |||
if(m_system_monitor != NULL && m_system_monitor.IsCircuitBreakerActive())
| |||
{
| |||
reason = "Circuit breaker: " + m_system_monitor.GetCircuitBreakerReason();
| |||
return false;
| |||
}
| |||
| |||
// P1-3: Check regime allows trading
| |||
if(m_regime_strategy != NULL)
| |||
{
| |||
if(!m_regime_strategy.IsTradingAllowed(reason))
| |||
{
| |||
return false;
| |||
}
| |||
}
| |||
| |||
return true;
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Process trade signal through all gates |
| |||
//+------------------------------------------------------------------+
| |||
bool ProcessTradeSignal(TradingSignal &signal,
| |||
CEfficientGateManagerEnhanced &gate_manager,
| |||
string &block_reason)
| |||
{
| |||
// P1-3: Apply regime-adjusted parameters
| |||
if(m_regime_strategy != NULL)
| |||
{
| |||
double min_confidence = m_regime_strategy.GetMinConfidenceThreshold();
| |||
// Could adjust gate thresholds here
| |||
}
| |||
| |||
// P1-2: Fast gate decision using insights
| |||
if(m_insight_bridge != NULL)
| |||
{
| |||
double signal_confidence = m_insight_bridge.GetSignalConfidence(
| |||
signal.strategy, signal.symbol);
| |||
| |||
if(signal_confidence < 0.4)
| |||
{
| |||
// Adjust-only mode: do not block, but penalize confidence and annotate reason
| |||
signal.confidence = MathMax(0.05, MathMin(1.0, signal.confidence * signal_confidence));
| |||
block_reason = "Low insight confidence (soft): " + DoubleToString(signal_confidence, 2);
| |||
}
| |||
}
| |||
| |||
// P1-6: Check position limits
| |||
if(m_position_manager != NULL)
| |||
{
| |||
double risk_amount = 0; // Calculate based on signal
| |||
if(!m_position_manager.CanOpenPosition(signal.symbol, signal.type,
| |||
risk_amount, block_reason))
| |||
{
| |||
return false;
| |||
}
| |||
}
| |||
| |||
// Process through gate cascade
| |||
CSignalDecision decision;
| |||
return gate_manager.ProcessSignalEnhanced(signal, decision, block_reason);
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Log gate decision to shadow log |
| |||
//+------------------------------------------------------------------+
| |||
void LogGateDecision(const string &gate_name, const TradingSignal &signal,
| |||
bool passed, double confidence, double threshold)
| |||
{
| |||
if(m_shadow_logger != NULL)
| |||
{
| |||
SShadowLogEntry entry;
| |||
entry.Init(signal.symbol, signal.direction == 0 ? "BUY" : "SELL",
| |||
signal.price, signal.volume, signal.strategy);
| |||
| |||
// Convert gate_name to gate number for entry
| |||
int gate_num = 0;
| |||
if(gate_name == "G1") gate_num = 0;
| |||
else if(gate_name == "G2") gate_num = 1;
| |||
else if(gate_name == "G3") gate_num = 2;
| |||
else if(gate_name == "G4") gate_num = 3;
| |||
else if(gate_name == "G5") gate_num = 4;
| |||
else if(gate_name == "G6") gate_num = 5;
| |||
else if(gate_name == "G7") gate_num = 6;
| |||
else if(gate_name == "G8") gate_num = 7;
| |||
| |||
entry.gate_passed[gate_num] = passed;
| |||
entry.gate_confidence[gate_num] = confidence;
| |||
entry.gate_threshold[gate_num] = threshold;
| |||
entry.gate_block_reason[gate_num] = passed ? "" : "Below threshold";
| |||
| |||
m_shadow_logger.LogGateDecision(entry);
| |||
}
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Record completed trade |
| |||
//+------------------------------------------------------------------+
| |||
void RecordTrade(const STradeRecord &trade)
| |||
{
| |||
// P1-1: Log to SQLite
| |||
if(m_sqlite_kb != NULL)
| |||
{
| |||
m_sqlite_kb.LogTrade(trade);
| |||
}
| |||
| |||
// P1-2: Update insight bridge
| |||
if(m_insight_bridge != NULL)
| |||
{
| |||
m_insight_bridge.OnTradeCompleted(trade.strategy, trade.symbol,
| |||
trade.pnl, trade.r_multiple);
| |||
}
| |||
| |||
// P1-4: Update system monitor
| |||
if(m_system_monitor != NULL)
| |||
{
| |||
m_system_monitor.RecordTrade();
| |||
}
| |||
| |||
// P1-6: Remove from position tracking
| |||
if(m_position_manager != NULL && trade.id > 0)
| |||
{
| |||
// m_position_manager->RemovePosition((ulong)trade.id);
| |||
}
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Get position size with all adjustments |
| |||
//+------------------------------------------------------------------+
| |||
double CalculatePositionSize(const TradingSignal &signal, double risk_pct)
| |||
{
| |||
if(m_position_manager == NULL) return 0;
| |||
| |||
double account_balance = AccountInfoDouble(ACCOUNT_BALANCE);
| |||
| |||
return m_position_manager.CalculatePositionSize(
| |||
signal.symbol,
| |||
signal.type,
| |||
signal.price,
| |||
signal.sl,
| |||
risk_pct,
| |||
account_balance
| |||
);
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Log system status |
| |||
//+------------------------------------------------------------------+
| |||
void LogSystemStatus()
| |||
{
| |||
string status = "=== DualEA System Status ===\n";
| |||
| |||
// P1-4: System monitor status
| |||
if(m_system_monitor != NULL)
| |||
{
| |||
status += "Health: " + m_system_monitor.GetHealthReport() + "\n";
| |||
}
| |||
| |||
// P1-3: Regime status
| |||
if(m_regime_strategy != NULL)
| |||
{
| |||
status += "Regime: " + m_regime_strategy.RegimeToString(
| |||
m_regime_strategy.GetCurrentRegime()) + "\n";
| |||
}
| |||
| |||
// P1-6: Position status
| |||
if(m_position_manager != NULL)
| |||
{
| |||
status += "Positions: " + m_position_manager.GetRiskReport() + "\n";
| |||
}
| |||
| |||
// P1-2: Bridge status
| |||
if(m_insight_bridge != NULL)
| |||
{
| |||
double hit_rate, avg_lookup;
| |||
int cache_size;
| |||
m_insight_bridge.GetStats(hit_rate, avg_lookup, cache_size);
| |||
status += StringFormat("Insights: HitRate=%.1f%% Latency=%.2fus Cache=%d\n",
| |||
hit_rate * 100, avg_lookup, cache_size);
| |||
}
| |||
| |||
Print(status);
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Shutdown all components |
| |||
//+------------------------------------------------------------------+
| |||
void Shutdown()
| |||
{
| |||
Print("=== DualEA Master Controller v2.0 Shutting Down ===");
| |||
| |||
// Save all data
| |||
if(m_sqlite_kb != NULL) m_sqlite_kb.Close();
| |||
| |||
// Cleanup
| |||
if(m_shadow_logger != NULL) { delete m_shadow_logger; m_shadow_logger = NULL; }
| |||
if(m_position_manager != NULL) { delete m_position_manager; m_position_manager = NULL; }
| |||
if(m_system_monitor != NULL) { delete m_system_monitor; m_system_monitor = NULL; }
| |||
if(m_insight_bridge != NULL) { delete m_insight_bridge; m_insight_bridge = NULL; }
| |||
if(m_regime_strategy != NULL) { delete m_regime_strategy; m_regime_strategy = NULL; }
| |||
if(m_sqlite_kb != NULL) { delete m_sqlite_kb; m_sqlite_kb = NULL; }
| |||
if(m_feature_cache != NULL) { delete m_feature_cache; m_feature_cache = NULL; }
| |||
| |||
m_initialized = false;
| |||
Print("=== DualEA Master Controller v2.0 Shutdown Complete ===");
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Getters |
| |||
//+------------------------------------------------------------------+
| |||
CRegimeAwareStrategy* GetRegimeStrategy() { return m_regime_strategy; }
| |||
CPositionManager* GetPositionManager() { return m_position_manager; }
| |||
CSystemMonitor* GetSystemMonitor() { return m_system_monitor; }
| |||
CInsightGateBridge* GetInsightBridge() { return m_insight_bridge; }
| |||
CSQLiteKnowledgeBase* GetSQLiteKB() { return m_sqlite_kb; }
| |||
bool IsInitialized() { return m_initialized; }
| |||
};
| |||
| |||
// Global master controller instance
| |||
CDualEAMasterController* g_master_controller = NULL;
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize DualEA Master Controller |
| |||
//+------------------------------------------------------------------+
| |||
bool InitializeDualEAMasterController(const SDualEAConfig &config)
| |||
{
| |||
if(g_master_controller != NULL)
| |||
{
| |||
g_master_controller.Shutdown();
| |||
delete g_master_controller;
| |||
}
| |||
| |||
g_master_controller = new CDualEAMasterController();
| |||
return g_master_controller.Initialize(config);
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Shutdown DualEA Master Controller |
| |||
//+------------------------------------------------------------------+
| |||
void ShutdownDualEAMasterController()
| |||
{
| |||
if(g_master_controller != NULL)
| |||
{
| |||
g_master_controller.Shutdown();
| |||
delete g_master_controller;
| |||
g_master_controller = NULL;
| |||
}
| |||
}
| |||
| |||
#endif // DUALEA_MASTERINTEGRATION_MQH
|