forex-scalping.com

Code: Select all

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using cAlgo.API;
using cAlgo.API.Internals;
using cAlgo.API.Requests;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.FileSystem)]
    public class ExecutionJournalBot : Robot
    {
        [Parameter("Max Rejects (Threshold)", DefaultValue = 3, MinValue = 1)]
        public int MaxRejects { get; set; }

        [Parameter("Cluster Window (Minutes)", DefaultValue = 5)]
        public int ClusterWindowMin { get; set; }

        [Parameter("Hard Filter Pause (Minutes)", DefaultValue = 15)]
        public int FilterPauseMin { get; set; }

        [Parameter("Spam Click Threshold (ms)", DefaultValue = 1500)]
        public int SpamThresholdMs { get; set; }

        [Parameter("Default Volume", DefaultValue = 100000)]
        public double DefaultVolume { get; set; }

        private string _logFilePath;
        private List<DateTime> _rejectTimestamps = new List<DateTime>();
        private DateTime _lastClickTime = DateTime.MinValue;
        private DateTime _hardFilterExpiration = DateTime.MinValue;

        protected override void OnStart()
        {
            // Initialize CSV Log
            string documentsFolder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
            _logFilePath = Path.Combine(documentsFolder, "cTrader_Execution_Journal.csv");

            if (!File.Exists(_logFilePath))
            {
                File.WriteAllText(_logFilePath, "Timestamp,MinuteOfSession,Symbol,OrderType,Size,SpamClicked,Status,LatencyMS,ErrorReason\n");
            }

            DrawTradingPanel();
        }

        private void DrawTradingPanel()
        {
            var stackPanel = new StackPanel
            {
                HorizontalAlignment = HorizontalAlignment.Left,
                VerticalAlignment = VerticalAlignment.Top,
                BackgroundColor = Color.FromArgb(200, 30, 30, 30),
                Margin = new Thickness(10)
            };

            var btnBuy = new Button { Text = "BUY MKT", Margin = new Thickness(5), ForegroundColor = Color.LightGreen };
            btnBuy.Click += args => ExecuteTrackedOrder(TradeType.Buy);

            var btnSell = new Button { Text = "SELL MKT", Margin = new Thickness(5), ForegroundColor = Color.IndianRed };
            btnSell.Click += args => ExecuteTrackedOrder(TradeType.Sell);

            stackPanel.AddChild(btnBuy);
            stackPanel.AddChild(btnSell);
            Chart.AddControl(stackPanel);
        }

        private void ExecuteTrackedOrder(TradeType tradeType)
        {
            DateTime currentTime = Server.Time;

            // 1. Check Hard Filter
            if (currentTime < _hardFilterExpiration)
            {
                Print($"Hard Filter Active. Execution blocked until {_hardFilterExpiration:HH:mm:ss}");
                return;
            }

            // 2. Spam Detection
            bool isSpam = false;
            if ((currentTime - _lastClickTime).TotalMilliseconds < SpamThresholdMs)
            {
                isSpam = true;
                Print("Spam click detected. Tagging order.");
            }
            _lastClickTime = currentTime;

            // 3. Execution & Latency Tracking
            var stopwatch = new System.Diagnostics.Stopwatch();
            stopwatch.Start();
            
            TradeResult result = ExecuteMarketOrder(tradeType, SymbolName, DefaultVolume, "JournalBot");
            
            stopwatch.Stop();
            long latency = stopwatch.ElapsedMilliseconds;

            // 4. Result Processing
            string status = result.IsSuccessful ? "Filled" : "Rejected";
            string errorReason = result.IsSuccessful ? "None" : result.Error.ToString();

            if (!result.IsSuccessful)
            {
                ProcessReject(currentTime);
            }

            // 5. Write to Journal
            WriteToJournal(currentTime, tradeType, isSpam, status, latency, errorReason);
        }

        private void ProcessReject(DateTime currentTime)
        {
            _rejectTimestamps.Add(currentTime);

            // Clean up old rejects outside the rolling window
            _rejectTimestamps.RemoveAll(t => (currentTime - t).TotalMinutes > ClusterWindowMin);

            // Trigger Hard Filter if threshold met
            if (_rejectTimestamps.Count >= MaxRejects)
            {
                _hardFilterExpiration = currentTime.AddMinutes(FilterPauseMin);
                _rejectTimestamps.Clear(); // Reset cluster counter
                Print($"REJECT CLUSTER DETECTED. Hard filter engaged for {FilterPauseMin} minutes.");
            }
        }

        private void WriteToJournal(DateTime time, TradeType type, bool isSpam, string status, long latency, string error)
        {
            // Session Minute (Total minutes since midnight to spot specific open/close behaviors)
            int sessionMinute = (time.Hour * 60) + time.Minute;
            
            string logLine = $"{time:yyyy-MM-dd HH:mm:ss.fff},{sessionMinute},{SymbolName},{type},{DefaultVolume},{isSpam},{status},{latency},{error}\n";
            
            try
            {
                File.AppendAllText(_logFilePath, logLine);
            }
            catch (Exception ex)
            {
                Print("Failed to write to log: " + ex.Message);
            }
        }
    }
}

Code: Select all

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using cAlgo.API;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.FileSystem)]
    public class ExecutionTelemetryEngine : Robot
    {
        [Header("Circuit Breaker Dynamics")]
        [Parameter("Max Venue Rejects", DefaultValue = 3, MinValue = 1)]
        public int MaxRejects { get; set; }

        [Parameter("Rolling Window (Minutes)", DefaultValue = 5)]
        public int WindowMinutes { get; set; }

        [Parameter("Breaker Cooldown (Minutes)", DefaultValue = 15)]
        public int CooldownMinutes { get; set; }

        [Header("Order Flow Limits")]
        [Parameter("Order Size (Lots)", DefaultValue = 1.0)]
        public double OrderLots { get; set; }

        [Parameter("API Rate Limit / Debounce (ms)", DefaultValue = 500)]
        public int DebounceMs { get; set; }

        // State Management
        private enum SystemState { Operational, Warning, Halted }
        private SystemState _currentState = SystemState.Operational;
        private DateTime _breakerExpiration = DateTime.MinValue;
        private DateTime _lastClickTime = DateTime.MinValue;
        private readonly List<DateTime> _venueRejectTimestamps = new List<DateTime>();
        
        // I/O & Telemetry
        private string _logFilePath;
        private readonly ConcurrentQueue<string> _logQueue = new ConcurrentQueue<string>();
        private long _lastLatencyMs = 0;

        // UI Elements
        private TextBlock _uiStateText;
        private TextBlock _uiLatencyText;
        private TextBlock _uiRejectText;

        protected override void OnStart()
        {
            InitializeTelemetryStorage();
            DrawHUD();
            Timer.Start(1); // 1-second timer to flush logs and update HUD state
        }

        private void InitializeTelemetryStorage()
        {
            string dir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "QuantTelemetry");
            Directory.CreateDirectory(dir);
            _logFilePath = Path.Combine(dir, $"{SymbolName}_ExecutionLog_{Server.TimeInUtc:yyyyMMdd}.csv");

            if (!File.Exists(_logFilePath))
            {
                _logQueue.Enqueue("TimestampUTC,SessionMinute,Symbol,Type,Lots,LatencyMS,IsSpam,Status,ErrorCode,FaultOwner");
            }
        }

        private void DrawHUD()
        {
            var grid = new Grid(4, 2)
            {
                BackgroundColor = Color.FromArgb(220, 20, 20, 20),
                HorizontalAlignment = HorizontalAlignment.Left,
                VerticalAlignment = VerticalAlignment.Top,
                Margin = new Thickness(10)
            };

            // Styles
            var headerStyle = new Style(DefaultStyles.TextBlockStyle);
            headerStyle.Set(ControlProperty.ForegroundColor, Color.Gray);
            headerStyle.Set(ControlProperty.Margin, new Thickness(5));

            var valueStyle = new Style(DefaultStyles.TextBlockStyle);
            valueStyle.Set(ControlProperty.ForegroundColor, Color.White);
            valueStyle.Set(ControlProperty.Margin, new Thickness(5, 5, 15, 5));
            valueStyle.Set(ControlProperty.FontWeight, FontWeight.Bold);

            // HUD Labels
            grid.AddChild(new TextBlock { Text = "Engine State:", Style = headerStyle }, 0, 0);
            grid.AddChild(_uiStateText = new TextBlock { Text = "OPERATIONAL", ForegroundColor = Color.LimeGreen, Style = valueStyle }, 0, 1);

            grid.AddChild(new TextBlock { Text = "Last Latency:", Style = headerStyle }, 1, 0);
            grid.AddChild(_uiLatencyText = new TextBlock { Text = "0 ms", Style = valueStyle }, 1, 1);

            grid.AddChild(new TextBlock { Text = "Rolling Rejects:", Style = headerStyle }, 2, 0);
            grid.AddChild(_uiRejectText = new TextBlock { Text = "0", Style = valueStyle }, 2, 1);

            // Execution Buttons
            var btnBuy = new Button { Text = "BUY MKT", BackgroundColor = Color.SeaGreen, Margin = new Thickness(5) };
            btnBuy.Click += args => RequestExecution(TradeType.Buy);
            grid.AddChild(btnBuy, 3, 0);

            var btnSell = new Button { Text = "SELL MKT", BackgroundColor = Color.Firebrick, Margin = new Thickness(5) };
            btnSell.Click += args => RequestExecution(TradeType.Sell);
            grid.AddChild(btnSell, 3, 1);

            Chart.AddControl(grid);
        }

        private void RequestExecution(TradeType tradeType)
        {
            DateTime now = Server.TimeInUtc;

            // 1. Debounce (Protect API from hardware faults / extreme trader tilt)
            if ((now - _lastClickTime).TotalMilliseconds < DebounceMs)
            {
                QueueTelemetry(now, tradeType, 0, true, "Blocked", "RateLimit", "Trader");
                return;
            }
            _lastClickTime = now;

            // 2. Circuit Breaker Check
            if (now < _breakerExpiration)
            {
                QueueTelemetry(now, tradeType, 0, false, "Blocked", "CircuitBreakerActive", "System");
                return;
            }

            // 3. Dispatch Async Order
            double volume = Symbol.QuantityToVolumeInUnits(OrderLots);
            Stopwatch sw = Stopwatch.StartNew();

            ExecuteMarketOrderAsync(tradeType, SymbolName, volume, "ProJournal", result => 
            {
                sw.Stop();
                ProcessExecutionResult(result, now, sw.ElapsedMilliseconds, tradeType, volume);
            });
        }

        private void ProcessExecutionResult(TradeResult result, DateTime requestTime, long latency, TradeType type, double volume)
        {
            _lastLatencyMs = latency;
            string status = result.IsSuccessful ? "Filled" : "Rejected";
            string errorCode = result.IsSuccessful ? "None" : result.Error.ToString();
            string faultOwner = "None";

            if (!result.IsSuccessful)
            {
                // Categorize Fault
                if (IsTraderFault(result.Error))
                {
                    faultOwner = "Trader";
                }
                else
                {
                    faultOwner = "Venue";
                    UpdateBreakerLogic(requestTime);
                }
            }

            QueueTelemetry(requestTime, type, latency, false, status, errorCode, faultOwner);
            UpdateUI();
        }

        private bool IsTraderFault(ErrorCode? error)
        {
            // If margin is exhausted or position limit hit, venue health is fine. 
            // Do not trip the circuit breaker for user errors.
            return error == ErrorCode.NoMoney || error == ErrorCode.EntityNotFound || error == ErrorCode.InvalidRequest;
        }

        private void UpdateBreakerLogic(DateTime rejectTime)
        {
            _venueRejectTimestamps.Add(rejectTime);
            _venueRejectTimestamps.RemoveAll(t => (rejectTime - t).TotalMinutes > WindowMinutes);

            if (_venueRejectTimestamps.Count >= MaxRejects)
            {
                _breakerExpiration = Server.TimeInUtc.AddMinutes(CooldownMinutes);
                _currentState = SystemState.Halted;
                _venueRejectTimestamps.Clear();
                Print($"CIRCUIT BREAKER TRIPPED: Venue halted for {CooldownMinutes} minutes.");
            }
            else if (_venueRejectTimestamps.Count >= MaxRejects - 1)
            {
                _currentState = SystemState.Warning;
            }
        }

        private void QueueTelemetry(DateTime time, TradeType type, long latency, bool isSpam, string status, string error, string faultOwner)
        {
            int sessionMinute = (time.Hour * 60) + time.Minute;
            string logLine = $"{time:yyyy-MM-dd HH:mm:ss.fff},{sessionMinute},{SymbolName},{type},{OrderLots},{latency},{isSpam},{status},{error},{faultOwner}";
            _logQueue.Enqueue(logLine);
        }

        protected override void OnTimer()
        {
            // Background Log Flush
            if (!_logQueue.IsEmpty)
            {
                try
                {
                    using (StreamWriter sw = File.AppendText(_logFilePath))
                    {
                        while (_logQueue.TryDequeue(out string line))
                        {
                            sw.WriteLine(line);
                        }
                    }
                }
                catch (Exception ex)
                {
                    Print($"Telemetry I/O Error: {ex.Message}");
                }
            }

            // State Recovery
            if (_currentState == SystemState.Halted && Server.TimeInUtc >= _breakerExpiration)
            {
                _currentState = SystemState.Operational;
            }

            UpdateUI();
        }

        private void UpdateUI()
        {
            BeginInvokeOnMainThread(() =>
            {
                _uiLatencyText.Text = $"{_lastLatencyMs} ms";
                _uiRejectText.Text = _venueRejectTimestamps.Count.ToString();

                switch (_currentState)
                {
                    case SystemState.Operational:
                        _uiStateText.Text = "OPERATIONAL";
                        _uiStateText.ForegroundColor = Color.LimeGreen;
                        break;
                    case SystemState.Warning:
                        _uiStateText.Text = "WARNING (Elevated Rejects)";
                        _uiStateText.ForegroundColor = Color.Orange;
                        break;
                    case SystemState.Halted:
                        _uiStateText.Text = $"HALTED until {_breakerExpiration:HH:mm}";
                        _uiStateText.ForegroundColor = Color.Red;
                        break;
                }
            });
        }
    }
}

Code: Select all

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using cAlgo.API;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.FileSystem)]
    public class InstitutionalRiskEngine : Robot
    {
        [Header("Vector 1: Reject Limits")]
        [Parameter("Max Venue Rejects", DefaultValue = 3, MinValue = 1)]
        public int MaxRejects { get; set; }

        [Header("Vector 2: Latency Limits")]
        [Parameter("Max Latency (ms)", DefaultValue = 400)]
        public long MaxLatencyMs { get; set; }

        [Header("Vector 3: Slippage Limits")]
        [Parameter("Max Avg Slippage (Pips)", DefaultValue = 2.0)]
        public double MaxSlippagePips { get; set; }

        [Header("Circuit Breaker Settings")]
        [Parameter("Rolling Window (Minutes)", DefaultValue = 5)]
        public int WindowMinutes { get; set; }

        [Parameter("Breaker Cooldown (Minutes)", DefaultValue = 15)]
        public int CooldownMinutes { get; set; }

        [Header("Order Flow")]
        [Parameter("Order Size (Lots)", DefaultValue = 1.0)]
        public double OrderLots { get; set; }

        [Parameter("API Debounce (ms)", DefaultValue = 500)]
        public int DebounceMs { get; set; }

        // Architecture: State & Risk
        private enum State { Operational, Warning, Halted }
        private State _engineState = State.Operational;
        private string _haltReason = "N/A";
        private DateTime _breakerExpiration = DateTime.MinValue;
        private DateTime _lastClickTime = DateTime.MinValue;
        
        // Architecture: Metrics Buffers (Rolling Windows)
        private readonly List<DateTime> _rejectStamps = new List<DateTime>();
        private readonly List<Tuple<DateTime, long>> _latencyBuffer = new List<Tuple<DateTime, long>>();
        private readonly List<Tuple<DateTime, double>> _slippageBuffer = new List<Tuple<DateTime, double>>();

        // Architecture: I/O
        private string _logFilePath;
        private readonly ConcurrentQueue<string> _telemetryQueue = new ConcurrentQueue<string>();
        
        // Architecture: UI
        private TextBlock _uiStateText, _uiReasonText, _uiLatencyText, _uiSlippageText, _uiRejectText;

        protected override void OnStart()
        {
            InitializeDataLake();
            ConstructDashboard();
            Timer.Start(1); // Flush telemetry & evaluate risk decay every second
        }

        private void InitializeDataLake()
        {
            string dir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "QuantRiskDesk");
            Directory.CreateDirectory(dir);
            _logFilePath = Path.Combine(dir, $"{SymbolName}_ExecData_{Server.TimeInUtc:yyyyMMdd}.csv");

            if (!File.Exists(_logFilePath))
            {
                _telemetryQueue.Enqueue("TimestampUTC,Symbol,Side,RequestedPrice,FillPrice,SlippagePips,LatencyMS,Status,RiskVector,FaultOwner");
            }
        }

        private void ConstructDashboard()
        {
            var grid = new Grid(6, 2)
            {
                BackgroundColor = Color.FromArgb(230, 15, 15, 15),
                HorizontalAlignment = HorizontalAlignment.Left,
                VerticalAlignment = VerticalAlignment.Top,
                Margin = new Thickness(10)
            };

            var hdrStyle = new Style(DefaultStyles.TextBlockStyle);
            hdrStyle.Set(ControlProperty.ForegroundColor, Color.Gray);
            hdrStyle.Set(ControlProperty.Margin, new Thickness(8, 4, 8, 4));

            var valStyle = new Style(DefaultStyles.TextBlockStyle);
            valStyle.Set(ControlProperty.ForegroundColor, Color.White);
            valStyle.Set(ControlProperty.FontWeight, FontWeight.Bold);
            valStyle.Set(ControlProperty.Margin, new Thickness(8, 4, 15, 4));

            grid.AddChild(new TextBlock { Text = "ENGINE STATUS:", Style = hdrStyle }, 0, 0);
            grid.AddChild(_uiStateText = new TextBlock { Text = "OPERATIONAL", ForegroundColor = Color.LimeGreen, Style = valStyle }, 0, 1);

            grid.AddChild(new TextBlock { Text = "Halt Reason:", Style = hdrStyle }, 1, 0);
            grid.AddChild(_uiReasonText = new TextBlock { Text = "-", Style = valStyle }, 1, 1);

            grid.AddChild(new TextBlock { Text = "Avg Latency (5m):", Style = hdrStyle }, 2, 0);
            grid.AddChild(_uiLatencyText = new TextBlock { Text = "0 ms", Style = valStyle }, 2, 1);

            grid.AddChild(new TextBlock { Text = "Avg Slippage (5m):", Style = hdrStyle }, 3, 0);
            grid.AddChild(_uiSlippageText = new TextBlock { Text = "0.0 pips", Style = valStyle }, 3, 1);

            grid.AddChild(new TextBlock { Text = "Venue Rejects (5m):", Style = hdrStyle }, 4, 0);
            grid.AddChild(_uiRejectText = new TextBlock { Text = "0", Style = valStyle }, 4, 1);

            var btnPanel = new WrapPanel { Margin = new Thickness(0, 10, 0, 0) };
            var btnBuy = new Button { Text = " BUY MKT ", BackgroundColor = Color.SeaGreen, Margin = new Thickness(5) };
            var btnSell = new Button { Text = " SELL MKT ", BackgroundColor = Color.Firebrick, Margin = new Thickness(5) };
            
            btnBuy.Click += args => DispatchOrder(TradeType.Buy);
            btnSell.Click += args => DispatchOrder(TradeType.Sell);
            
            btnPanel.AddChild(btnBuy);
            btnPanel.AddChild(btnSell);
            grid.AddChild(btnPanel, 5, 0, 1, 2); // Span 2 columns

            Chart.AddControl(grid);
        }

        private void DispatchOrder(TradeType side)
        {
            DateTime now = Server.TimeInUtc;

            if ((now - _lastClickTime).TotalMilliseconds < DebounceMs) return; // Silent debounce
            _lastClickTime = now;

            if (now < _breakerExpiration)
            {
                LogTelemetry(now, side, 0, 0, 0, 0, "Blocked", "CircuitBreaker", "System");
                return;
            }

            // Capture exact expected price at moment of click
            double expectedPrice = side == TradeType.Buy ? Symbol.Ask : Symbol.Bid;
            double volume = Symbol.QuantityToVolumeInUnits(OrderLots);
            Stopwatch sw = Stopwatch.StartNew();

            ExecuteMarketOrderAsync(side, SymbolName, volume, "RiskEngine", result => 
            {
                sw.Stop();
                ProcessExecution(result, now, sw.ElapsedMilliseconds, side, expectedPrice);
            });
        }

        private void ProcessExecution(TradeResult result, DateTime requestTime, long latency, TradeType side, double expectedPrice)
        {
            double fillPrice = 0;
            double slippagePips = 0;
            string status = "Rejected";
            string faultOwner = "Venue";
            string riskVector = "None";

            if (result.IsSuccessful)
            {
                status = "Filled";
                faultOwner = "None";
                fillPrice = result.Position.EntryPrice;
                
                // Calculate directional slippage
                double rawSlippage = side == TradeType.Buy ? (fillPrice - expectedPrice) : (expectedPrice - fillPrice);
                slippagePips = Math.Round(rawSlippage / Symbol.PipSize, 2);

                _latencyBuffer.Add(new Tuple<DateTime, long>(requestTime, latency));
                _slippageBuffer.Add(new Tuple<DateTime, double>(requestTime, slippagePips));
            }
            else
            {
                if (result.Error == ErrorCode.NoMoney || result.Error == ErrorCode.EntityNotFound)
                {
                    faultOwner = "Trader";
                    riskVector = "Margin/Risk";
                }
                else
                {
                    _rejectStamps.Add(requestTime);
                    riskVector = "Reject";
                }
            }

            LogTelemetry(requestTime, side, expectedPrice, fillPrice, slippagePips, latency, status, riskVector, faultOwner);
            EvaluateRiskMetrics(requestTime);
        }

        private void EvaluateRiskMetrics(DateTime now)
        {
            // Clean old data from buffers
            DateTime cutoff = now.AddMinutes(-WindowMinutes);
            _rejectStamps.RemoveAll(t => t < cutoff);
            _latencyBuffer.RemoveAll(t => t.Item1 < cutoff);
            _slippageBuffer.RemoveAll(t => t.Item1 < cutoff);

            // Calculate rolling metrics
            int rejects = _rejectStamps.Count;
            double avgLatency = _latencyBuffer.Count > 0 ? _latencyBuffer.Average(x => x.Item2) : 0;
            double avgSlippage = _slippageBuffer.Count > 0 ? _slippageBuffer.Average(x => x.Item2) : 0;

            // Circuit Breaker Logic
            if (rejects >= MaxRejects)
            {
                TripBreaker(now, $"Venue Rejects ({rejects})");
            }
            else if (avgLatency > MaxLatencyMs)
            {
                TripBreaker(now, $"Latency Spike ({avgLatency:F0}ms)");
            }
            else if (avgSlippage > MaxSlippagePips)
            {
                TripBreaker(now, $"Toxic Slippage ({avgSlippage:F1} pips)");
            }
            else if (rejects >= MaxRejects - 1 || avgLatency > (MaxLatencyMs * 0.8))
            {
                _engineState = State.Warning;
            }

            UpdateUI(rejects, avgLatency, avgSlippage);
        }

        private void TripBreaker(DateTime now, string reason)
        {
            _breakerExpiration = now.AddMinutes(CooldownMinutes);
            _engineState = State.Halted;
            _haltReason = reason;
            
            // Clear buffers so it starts fresh after cooldown
            _rejectStamps.Clear();
            _latencyBuffer.Clear();
            _slippageBuffer.Clear();
            
            Print($"🛑 RISK ENGINE HALT: {reason}. Trading suspended for {CooldownMinutes}m.");
        }

        private void LogTelemetry(DateTime t, TradeType side, double reqPrice, double fillPrice, double slip, long lat, string stat, string vector, string fault)
        {
            // Thread-safe append to memory queue
            string logLine = $"{t:yyyy-MM-dd HH:mm:ss.fff},{SymbolName},{side},{reqPrice},{fillPrice},{slip},{lat},{stat},{vector},{fault}";
            _telemetryQueue.Enqueue(logLine);
        }

        protected override void OnTimer()
        {
            // I/O Offload: Write batch to disk once per second
            if (!_telemetryQueue.IsEmpty)
            {
                try
                {
                    var sb = new StringBuilder();
                    while (_telemetryQueue.TryDequeue(out string line))
                    {
                        sb.AppendLine(line);
                    }
                    File.AppendAllText(_logFilePath, sb.ToString());
                }
                catch (Exception ex) { Print($"I/O Error: {ex.Message}"); }
            }

            // State Recovery
            if (_engineState == State.Halted && Server.TimeInUtc >= _breakerExpiration)
            {
                _engineState = State.Operational;
                _haltReason = "-";
                UpdateUI(0, 0, 0); // Reset displays
            }
        }

        private void UpdateUI(int rejects, double avgLatency, double avgSlippage)
        {
            BeginInvokeOnMainThread(() =>
            {
                _uiRejectText.Text = rejects.ToString();
                _uiLatencyText.Text = $"{avgLatency:F0} ms";
                _uiSlippageText.Text = $"{avgSlippage:F1} pips";
                _uiReasonText.Text = _haltReason;

                switch (_engineState)
                {
                    case State.Operational:
                        _uiStateText.Text = "OPERATIONAL";
                        _uiStateText.ForegroundColor = Color.LimeGreen;
                        break;
                    case State.Warning:
                        _uiStateText.Text = "WARNING (Degraded)";
                        _uiStateText.ForegroundColor = Color.Orange;
                        break;
                    case State.Halted:
                        _uiStateText.Text = $"HALTED until {_breakerExpiration:HH:mm}";
                        _uiStateText.ForegroundColor = Color.Red;
                        break;
                }
            });
        }
    }
}