Upload 37 files

.gitattributes

@@ -33,3 +33,10 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+mBA-GMP.v3/generate_profiles.py_output/fig_cmp_vs_gmp.png filter=lfs diff=lfs merge=lfs -text
+mBA-GMP.v3/generate_profiles.py_output/fig_combined_3panel.png filter=lfs diff=lfs merge=lfs -text
+mBA-GMP.v3/generate_profiles.py_output/fig_price_scatter.png filter=lfs diff=lfs merge=lfs -text
+mBA-GMP.v3/generate_profiles.py_output/fig_updown_footprint.png filter=lfs diff=lfs merge=lfs -text
+mBA-GMP.v3/generate_profiles.py_output/raw_draft_of_concept.png filter=lfs diff=lfs merge=lfs -text
+SUM3API/MQL5/Libraries/libsodium.dll filter=lfs diff=lfs merge=lfs -text
+SUM3API/MQL5/Libraries/libzmq.dll filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rembrant Oyangoren Albeos
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,7 @@
+
+Simply go to [SUM3API](https://github.com/Continual-Quasars/SUM3API) if you want basics (Complete End-to-End System Architecture, MQL5-ZMQ Wrapper library, and RUST-ZMQ Wrapper library), and [guide](https://github.com/Continual-Quasars/SUM3API/blob/main/A%20GUIDE%20to%20open%20SUM3API%20software%20(trading%20terminal).pdf) how to lunch the app.<br>
+
+You may also read the research paper [here](https://ssrn.com/abstract=6143486)<br><br>
+
+https://github.com/user-attachments/assets/e227421a-b43e-49c1-85f0-4f9352189788
+

STRUCTURE.md

@@ -0,0 +1,54 @@
+## Project Structure
+
+```text
+SUM3-Trading-Terminal/
+├── gmp-terminal/
+│   ├── src/
+│   │   ├── app.rs
+│   │   ├── gmp_engine.rs
+│   │   ├── main.rs
+│   │   ├── tab_time.rs
+│   │   ├── tab_trade.rs
+│   │   ├── timeframe.rs
+│   │   ├── trading_panel.rs
+│   │   └── zmq_bridge.rs
+│   ├── Cargo.lock
+│   └── Cargo.toml
+├── mBA-GMP.v3/
+│   ├── generate_profiles.py_output/
+│   │   ├── cmp_profile.csv
+│   │   ├── datapoints.csv
+│   │   ├── fig_cmp_profile.png
+│   │   ├── fig_cmp_vs_gmp.png
+│   │   ├── fig_combined_3panel.png
+│   │   ├── fig_gmp_profile.png
+│   │   ├── fig_price_scatter.png
+│   │   ├── fig_updown_footprint.png
+│   │   ├── gmp_profile.csv
+│   │   ├── raw_draft_of_concept.png
+│   │   └── updown_profile.csv
+│   └── generate_profiles.py
+├── SUM3API/
+│   ├── MQL5/
+│   │   ├── Experts/
+│   │   │   └── ZmqPublisher.mq5
+│   │   ├── Include/
+│   │   │   └── Zmq/
+│   │   │       └── Zmq.mqh
+│   │   └── Libraries/
+│   │       ├── libsodium.dll
+│   │       └── libzmq.dll
+│   ├── Rustmt5-chart/
+│   │   ├── output/
+│   │   │   ├── History_XAUUSDc_H1_OHLC_ID0002_20260126_135823.csv
+│   │   │   ├── History_XAUUSDc_H1_TICKS_ID0001_20260126_140825.csv
+│   │   │   └── Live_XAUUSDc_ID0001_20260126_135811.csv
+│   │   ├── src/
+│   │   │   └── main.rs
+│   │   ├── Cargo.lock
+│   │   └── Cargo.toml
+│   └── LICENSE
+├── LICENSE
+├── README.md
+└── TECHSTACK.md
+```

SUM3API/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Algorembrant
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

SUM3API/MQL5/Experts/ZmqPublisher.mq5

@@ -0,0 +1,450 @@
+//+------------------------------------------------------------------+
+//|                                                 ZmqPublisher.mq5 |
+//|                                    Copyright 2024, Antigravity   |
+//|                                                                  |
+//+------------------------------------------------------------------+
+#property copyright "Antigravity"
+#property link      ""
+#property version   "2.00"
+
+// Include our ZMQ wrapper
+#include <Zmq/Zmq.mqh>
+
+// Include trading functions
+#include <Trade/Trade.mqh>
+
+// Input parameters
+input string InpPubAddress = "tcp://0.0.0.0:5555"; // Tick Publisher Address
+input string InpRepAddress = "tcp://0.0.0.0:5556"; // Order Handler Address
+input double InpDefaultSlippage = 10;              // Default Slippage (points)
+
+CZmq *g_publisher;  // PUB socket for tick data
+CZmq *g_responder;  // REP socket for order handling
+CTrade g_trade;     // Trading helper
+
+//+------------------------------------------------------------------+
+//| Expert initialization function                                   |
+//+------------------------------------------------------------------+
+int OnInit()
+  {
+   Print("Initializing ZmqPublisher v2.0 with Order Support...");
+   
+   // Initialize tick publisher (PUB socket)
+   g_publisher = new CZmq();
+   if(!g_publisher.Init(ZMQ_PUB)) {
+      Print("Failed to initialize ZMQ Publisher");
+      return(INIT_FAILED);
+   }
+   if(!g_publisher.Bind(InpPubAddress)) {
+      Print("Failed to bind publisher to ", InpPubAddress);
+      return(INIT_FAILED);
+   }
+   Print("Tick Publisher bound to ", InpPubAddress);
+   
+   // Initialize order responder (REP socket)
+   g_responder = new CZmq();
+   if(!g_responder.Init(ZMQ_REP)) {
+      Print("Failed to initialize ZMQ Responder");
+      return(INIT_FAILED);
+   }
+   if(!g_responder.Bind(InpRepAddress)) {
+      Print("Failed to bind responder to ", InpRepAddress);
+      return(INIT_FAILED);
+   }
+   Print("Order Responder bound to ", InpRepAddress);
+   
+   // Configure trade settings
+   g_trade.SetDeviationInPoints((ulong)InpDefaultSlippage);
+   g_trade.SetTypeFilling(ORDER_FILLING_IOC);
+   
+   return(INIT_SUCCEEDED);
+  }
+
+//+------------------------------------------------------------------+
+//| Expert deinitialization function                                 |
+//+------------------------------------------------------------------+
+void OnDeinit(const int reason)
+  {
+   Print("Deinitializing ZmqPublisher...");
+   if(g_publisher != NULL) {
+      g_publisher.Shutdown();
+      delete g_publisher;
+      g_publisher = NULL;
+   }
+   if(g_responder != NULL) {
+      g_responder.Shutdown();
+      delete g_responder;
+      g_responder = NULL;
+   }
+  }
+
+//+------------------------------------------------------------------+
+//| Process incoming order request                                   |
+//+------------------------------------------------------------------+
+//+------------------------------------------------------------------+
+//| Process incoming order request                                   |
+//+------------------------------------------------------------------+
+string ProcessOrderRequest(string request)
+  {
+   // Expected JSON format:
+   // {"type":"market_buy"|"close_position"|"cancel_order"|..., 
+   //  "symbol":"XAUUSDc", "volume":0.01, "price":2000.0, "ticket":12345}
+   
+   string orderType = ExtractJsonString(request, "type");
+   string symbol = ExtractJsonString(request, "symbol");
+   double volume = ExtractJsonDouble(request, "volume");
+   double price = ExtractJsonDouble(request, "price");
+   ulong ticket = (ulong)ExtractJsonDouble(request, "ticket"); // Simple extraction
+   
+   if(symbol == "") symbol = _Symbol;
+   if(volume <= 0) volume = 0.01;
+   
+   Print("Order request: type=", orderType, " symbol=", symbol, " vol=", volume, " price=", price, " ticket=", ticket);
+   
+   bool success = false;
+   ulong resultTicket = 0;
+   string errorMsg = "";
+   
+   // Execute order based on type
+   if(orderType == "market_buy") {
+      double askPrice = SymbolInfoDouble(symbol, SYMBOL_ASK);
+      success = g_trade.Buy(volume, symbol, askPrice, 0, 0, "Rust GUI Order");
+      if(success) resultTicket = g_trade.ResultOrder();
+      else errorMsg = GetLastErrorDescription();
+   }
+   else if(orderType == "market_sell") {
+      double bidPrice = SymbolInfoDouble(symbol, SYMBOL_BID);
+      success = g_trade.Sell(volume, symbol, bidPrice, 0, 0, "Rust GUI Order");
+      if(success) resultTicket = g_trade.ResultOrder();
+      else errorMsg = GetLastErrorDescription();
+   }
+   else if(orderType == "limit_buy") {
+      success = g_trade.BuyLimit(volume, price, symbol, 0, 0, ORDER_TIME_GTC, 0, "Rust GUI Limit");
+      if(success) resultTicket = g_trade.ResultOrder();
+      else errorMsg = GetLastErrorDescription();
+   }
+   else if(orderType == "limit_sell") {
+      success = g_trade.SellLimit(volume, price, symbol, 0, 0, ORDER_TIME_GTC, 0, "Rust GUI Limit");
+      if(success) resultTicket = g_trade.ResultOrder();
+      else errorMsg = GetLastErrorDescription();
+   }
+   else if(orderType == "stop_buy") {
+      success = g_trade.BuyStop(volume, price, symbol, 0, 0, ORDER_TIME_GTC, 0, "Rust GUI Stop");
+      if(success) resultTicket = g_trade.ResultOrder();
+      else errorMsg = GetLastErrorDescription();
+   }
+   else if(orderType == "stop_sell") {
+      success = g_trade.SellStop(volume, price, symbol, 0, 0, ORDER_TIME_GTC, 0, "Rust GUI Stop");
+      if(success) resultTicket = g_trade.ResultOrder();
+      else errorMsg = GetLastErrorDescription();
+   }
+   else if(orderType == "close_position") {
+      if(ticket > 0) {
+         success = g_trade.PositionClose(ticket);
+         if(success) errorMsg = "Position closed";
+         else errorMsg = GetLastErrorDescription();
+      } else {
+         errorMsg = "Invalid ticket for close_position";
+      }
+   }
+   else if(orderType == "cancel_order") {
+      if(ticket > 0) {
+         success = g_trade.OrderDelete(ticket);
+         if(success) errorMsg = "Order deleted";
+         else errorMsg = GetLastErrorDescription();
+      } else {
+         errorMsg = "Invalid ticket for cancel_order";
+      }
+   }
+   else if(orderType == "download_history") {
+       // Format: {type: "download_history", symbol: "XAUUSD", timeframe: "M1", start: "2024.01.01", end: "2024.01.02", mode: "OHLC"|"TICKS"}
+       string tfStr = ExtractJsonString(request, "timeframe");
+       string startStr = ExtractJsonString(request, "start");
+       string endStr = ExtractJsonString(request, "end");
+       string mode = ExtractJsonString(request, "mode");
+       
+       if(mode == "") mode = "OHLC";
+       
+       success = DownloadHistory(symbol, tfStr, startStr, endStr, mode, errorMsg);
+   }
+   else {
+      errorMsg = "Unknown order type: " + orderType;
+   }
+   
+   // Build response JSON
+   string response;
+   if(success) {
+      if(orderType == "download_history") {
+          // ensure errorMsg contains the filename if success
+          StringConcatenate(response, "{\"success\":true,\"message\":\"", errorMsg, "\"}");
+      } else {
+          StringConcatenate(response, "{\"success\":true,\"ticket\":", IntegerToString(resultTicket), "}");
+      }
+   } else {
+      StringConcatenate(response, "{\"success\":false,\"error\":\"", errorMsg, "\"}");
+   }
+   
+   return response;
+  }
+
+//+------------------------------------------------------------------+
+//| Download History - Returns CSV content via ZMQ                   |
+//+------------------------------------------------------------------+
+bool DownloadHistory(string symbol, string tfStr, string startStr, string endStr, string mode, string &resultMsg)
+  {
+   datetime start = StringToTime(startStr);
+   datetime end = StringToTime(endStr);
+   if(start == 0) start = D'2024.01.01 00:00'; // Default fallback
+   if(end == 0) end = TimeCurrent();
+   
+   ENUM_TIMEFRAMES tf = PERIOD_M1;
+   if(tfStr == "M5") tf = PERIOD_M5;
+   else if(tfStr == "M15") tf = PERIOD_M15;
+   else if(tfStr == "H1") tf = PERIOD_H1;
+   else if(tfStr == "H4") tf = PERIOD_H4;
+   else if(tfStr == "D1") tf = PERIOD_D1;
+   
+   string csvContent = "";
+   int count = 0;
+   
+   // Use |NL| as line separator (JSON-safe, Rust will convert to real newlines)
+   string NL = "|NL|";
+   
+   if(mode == "TICKS") {
+      MqlTick ticks[];
+      int received = CopyTicksRange(symbol, ticks, COPY_TICKS_ALL, start * 1000, end * 1000);
+      
+      if(received > 0) {
+         csvContent = "Time,Bid,Ask,Volume" + NL;
+         for(int i=0; i<received && i<50000; i++) {  // Limit to 50k rows
+            csvContent += TimeToString(ticks[i].time, TIME_DATE|TIME_SECONDS) + "," +
+                         DoubleToString(ticks[i].bid, _Digits) + "," +
+                         DoubleToString(ticks[i].ask, _Digits) + "," +
+                         IntegerToString(ticks[i].volume) + NL;
+         }
+         count = MathMin(received, 50000);
+      }
+   } 
+   else {
+      // OHLC
+      MqlRates rates[];
+      ArraySetAsSeries(rates, false);
+      int received = CopyRates(symbol, tf, start, end, rates);
+      
+      if(received > 0) {
+         csvContent = "Time,Open,High,Low,Close,TickVol,Spread" + NL;
+         for(int i=0; i<received && i<100000; i++) {  // Limit to 100k rows
+            csvContent += TimeToString(rates[i].time, TIME_DATE|TIME_MINUTES) + "," +
+                         DoubleToString(rates[i].open, _Digits) + "," +
+                         DoubleToString(rates[i].high, _Digits) + "," +
+                         DoubleToString(rates[i].low, _Digits) + "," +
+                         DoubleToString(rates[i].close, _Digits) + "," +
+                         IntegerToString(rates[i].tick_volume) + "," +
+                         IntegerToString(rates[i].spread) + NL;
+         }
+         count = MathMin(received, 100000);
+      }
+   }
+   
+   if(count > 0) {
+      // Return CSV content in a special format that Rust can parse
+      // We use ||CSV_DATA|| as delimiter to separate count info from actual data
+      resultMsg = IntegerToString(count) + " records||CSV_DATA||" + csvContent;
+      return true;
+   } else {
+      resultMsg = "No data found for period";
+      return false;
+   }
+  }
+
+//+------------------------------------------------------------------+
+//| Extract string value from JSON                                   |
+//+------------------------------------------------------------------+
+string ExtractJsonString(string json, string key)
+  {
+   string searchKey = "\"" + key + "\":\"";
+   int startPos = StringFind(json, searchKey);
+   if(startPos < 0) return "";
+   
+   startPos += StringLen(searchKey);
+   int endPos = StringFind(json, "\"", startPos);
+   if(endPos < 0) return "";
+   
+   return StringSubstr(json, startPos, endPos - startPos);
+  }
+
+//+------------------------------------------------------------------+
+//| Extract double value from JSON                                   |
+//+------------------------------------------------------------------+
+double ExtractJsonDouble(string json, string key)
+  {
+   string searchKey = "\"" + key + "\":";
+   int startPos = StringFind(json, searchKey);
+   if(startPos < 0) return 0.0;
+   
+   startPos += StringLen(searchKey);
+   
+   // Find end of number (comma, }, or end of string)
+   int endPos = startPos;
+   int len = StringLen(json);
+   while(endPos < len) {
+      ushort ch = StringGetCharacter(json, endPos);
+      if(ch == ',' || ch == '}' || ch == ' ') break;
+      endPos++;
+   }
+   
+   string valueStr = StringSubstr(json, startPos, endPos - startPos);
+   return StringToDouble(valueStr);
+  }
+
+//+------------------------------------------------------------------+
+//| Get human-readable error description                             |
+//+------------------------------------------------------------------+
+string GetLastErrorDescription()
+  {
+   int err = GetLastError();
+   return "Error " + IntegerToString(err) + ": " + ErrorDescription(err);
+  }
+
+//+------------------------------------------------------------------+
+//| Error description helper                                         |
+//+------------------------------------------------------------------+
+string ErrorDescription(int error)
+  {
+   switch(error) {
+      case 0: return "No error";
+      case 10004: return "Requote";
+      case 10006: return "Request rejected";
+      case 10007: return "Request canceled by trader";
+      case 10010: return "Request rejected - only part of the request was fulfilled";
+      case 10011: return "Request error";
+      case 10012: return "Request canceled due to timeout";
+      case 10013: return "Invalid request";
+      case 10014: return "Invalid volume";
+      case 10015: return "Invalid price";
+      case 10016: return "Invalid stops";
+      case 10017: return "Trade disabled";
+      case 10018: return "Market is closed";
+      case 10019: return "Not enough money";
+      case 10020: return "Prices changed";
+      case 10021: return "No quotes to process request";
+      case 10022: return "Invalid order expiration date";
+      case 10023: return "Order state changed";
+      case 10024: return "Too many requests";
+      case 10025: return "No changes in request";
+      case 10026: return "Autotrading disabled by server";
+      case 10027: return "Autotrading disabled by client terminal";
+      case 10028: return "Request locked for processing";
+      case 10029: return "Long positions only allowed";
+      case 10030: return "Maximum position volume exceeded";
+      default: return "Unknown error";
+   }
+  }
+
+//+------------------------------------------------------------------+
+//| Expert tick function                                             |
+//+------------------------------------------------------------------+
+void OnTick()
+  {
+   // Handle order requests (non-blocking)
+   if(g_responder != NULL) {
+      string request = g_responder.Receive(true);
+      if(request != "") {
+         Print("Received order request: ", request);
+         string response = ProcessOrderRequest(request);
+         g_responder.Send(response, false);  // Blocking send for REP pattern
+         Print("Sent response: ", response);
+      }
+   }
+   
+   // Publish tick data with account info
+   if(g_publisher == NULL) return;
+   
+   MqlTick tick;
+   if(SymbolInfoTick(_Symbol, tick)) {
+      // Get account info
+      double balance = AccountInfoDouble(ACCOUNT_BALANCE);
+      double equity = AccountInfoDouble(ACCOUNT_EQUITY);
+      double margin = AccountInfoDouble(ACCOUNT_MARGIN);
+      double freeMargin = AccountInfoDouble(ACCOUNT_MARGIN_FREE);
+      
+      // Get symbol trading constraints
+      double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
+      double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
+      double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
+      
+      // Get Active Positions (Only for current symbol to simplify)
+      string positionsJson = "[";
+      int posCount = PositionsTotal();
+      bool firstPos = true;
+      for(int i = 0; i < posCount; i++) {
+         ulong ticket = PositionGetTicket(i);
+         if(PositionSelectByTicket(ticket)) {
+            if(PositionGetString(POSITION_SYMBOL) == _Symbol) {
+               if(!firstPos) StringAdd(positionsJson, ",");
+               
+               string posType = (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) ? "BUY" : "SELL";
+               StringAdd(positionsJson, "{\"ticket\":" + IntegerToString(ticket) + 
+                         ",\"type\":\"" + posType + "\"" +
+                         ",\"volume\":" + DoubleToString(PositionGetDouble(POSITION_VOLUME), 2) +
+                         ",\"price\":" + DoubleToString(PositionGetDouble(POSITION_PRICE_OPEN), _Digits) +
+                         ",\"profit\":" + DoubleToString(PositionGetDouble(POSITION_PROFIT), 2) + 
+                         "}");
+               firstPos = false;
+            }
+         }
+      }
+      StringAdd(positionsJson, "]");
+      
+      // Get Pending Orders (Only for current symbol)
+      string ordersJson = "[";
+      int orderCount = OrdersTotal();
+      bool firstOrder = true;
+      for(int i = 0; i < orderCount; i++) {
+         ulong ticket = OrderGetTicket(i);
+         if(OrderSelect(ticket)) {
+            if(OrderGetString(ORDER_SYMBOL) == _Symbol) {
+               if(!firstOrder) StringAdd(ordersJson, ",");
+               
+               ENUM_ORDER_TYPE type = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);
+               string orderTypeStr = "UNKNOWN";
+               if(type == ORDER_TYPE_BUY_LIMIT) orderTypeStr = "BUY LIMIT";
+               else if(type == ORDER_TYPE_SELL_LIMIT) orderTypeStr = "SELL LIMIT";
+               else if(type == ORDER_TYPE_BUY_STOP) orderTypeStr = "BUY STOP";
+               else if(type == ORDER_TYPE_SELL_STOP) orderTypeStr = "SELL STOP";
+               
+               StringAdd(ordersJson, "{\"ticket\":" + IntegerToString(ticket) + 
+                         ",\"type\":\"" + orderTypeStr + "\"" +
+                         ",\"volume\":" + DoubleToString(OrderGetDouble(ORDER_VOLUME_INITIAL), 2) +
+                         ",\"price\":" + DoubleToString(OrderGetDouble(ORDER_PRICE_OPEN), _Digits) +
+                         "}");
+               firstOrder = false;
+            }
+         }
+      }
+      StringAdd(ordersJson, "]");
+      
+      // Create JSON with tick data + account info + positions + orders
+      string json;
+      StringConcatenate(json, "{\"symbol\":\"", _Symbol, 
+                        "\",\"bid\":", DoubleToString(tick.bid, _Digits),
+                        ",\"ask\":", DoubleToString(tick.ask, _Digits),
+                        ",\"time\":", IntegerToString(tick.time),
+                        ",\"volume\":", IntegerToString(tick.volume),
+                        ",\"balance\":", DoubleToString(balance, 2),
+                        ",\"equity\":", DoubleToString(equity, 2),
+                        ",\"margin\":", DoubleToString(margin, 2),
+                        ",\"free_margin\":", DoubleToString(freeMargin, 2),
+                        ",\"min_lot\":", DoubleToString(minLot, 2),
+                        ",\"max_lot\":", DoubleToString(maxLot, 2),
+                        ",\"lot_step\":", DoubleToString(lotStep, 2),
+                        ",\"positions\":", positionsJson,
+                        ",\"orders\":", ordersJson,
+                        "}");
+                        
+      g_publisher.Send(json);
+      // Print("Published: ", json); // Uncomment for debugging (spammy)
+   }
+  }
+  
+//+------------------------------------------------------------------+

SUM3API/MQL5/Include/Zmq/Zmq.mqh

@@ -0,0 +1,144 @@
+//+------------------------------------------------------------------+
+//|                                                          Zmq.mqh |
+//|                                    Copyright 2026, Algorembrant  |
+//|                                                                  |
+//+------------------------------------------------------------------+
+#property copyright "Algorembrant"
+#property link      "https://github.com/ContinualQuasars/SUM3API"
+#property version   "2.00"
+#property strict
+
+// Define ZMQ constants
+#define ZMQ_PUB 1
+#define ZMQ_SUB 2
+#define ZMQ_REQ 3
+#define ZMQ_REP 4
+
+#define ZMQ_NOBLOCK 1
+
+// Import functions from libzmq.dll
+// NOTE: Make sure libzmq.dll is in your MQL5/Libraries folder
+// Handles are void* (64-bit on x64), so using 'long' works for both 32 (too big but safe) and 64 bit
+#import "libzmq.dll"
+   long zmq_ctx_new();
+   int zmq_ctx_term(long context);
+   long zmq_socket(long context, int type);
+   int zmq_close(long socket);
+   int zmq_bind(long socket, uchar &endpoint[]);
+   int zmq_connect(long socket, uchar &endpoint[]);
+   int zmq_send(long socket, uchar &buf[], int len, int flags);
+   int zmq_recv(long socket, uchar &buf[], int len, int flags);
+   int zmq_errno();
+#import
+
+class CZmq {
+private:
+   long m_context;
+   long m_socket;
+   bool m_initialized;
+
+public:
+   CZmq() {
+      m_context = 0;
+      m_socket = 0;
+      m_initialized = false;
+   }
+
+   ~CZmq() {
+      Shutdown();
+   }
+
+   bool Init(int type) {
+      if(m_initialized) return true;
+      
+      m_context = zmq_ctx_new();
+      if(m_context == 0) {
+         Print("ZMQ Init failed: Context creation error");
+         return false;
+      }
+      
+      m_socket = zmq_socket(m_context, type);
+      if(m_socket == 0) {
+         Print("ZMQ Init failed: Socket creation error");
+         return false;
+      }
+      
+      m_initialized = true;
+      return true;
+   }
+
+   bool Bind(string endpoint) {
+      if(!m_initialized) return false;
+      
+      uchar data[];
+      StringToCharArray(endpoint, data, 0, WHOLE_ARRAY, CP_UTF8);
+      
+      int rc = zmq_bind(m_socket, data);
+      if(rc != 0) {
+         Print("ZMQ Bind failed. Error: ", zmq_errno());
+         return false;
+      }
+      return true;
+   }
+
+   bool Connect(string endpoint) {
+      if(!m_initialized) return false;
+      
+      uchar data[];
+      StringToCharArray(endpoint, data, 0, WHOLE_ARRAY, CP_UTF8);
+      
+      int rc = zmq_connect(m_socket, data);
+      if(rc != 0) {
+         Print("ZMQ Connect failed. Error: ", zmq_errno());
+         return false;
+      }
+      return true;
+   }
+
+   int Send(string message, bool nonBlocking = true) {
+      if(!m_initialized) return -1;
+      
+      uchar data[];
+      StringToCharArray(message, data, 0, WHOLE_ARRAY, CP_UTF8);
+      // StringToCharArray includes null terminator, we might not want to send it
+      // ZMQ messages are just bytes.
+      // -1 because array size includes null char, usually we check ArraySize(data)
+      int len = ArraySize(data) - 1; 
+      if (len < 0) len = 0;
+
+      int flags = 0;
+      if(nonBlocking) flags = ZMQ_NOBLOCK;
+      
+      int bytesSent = zmq_send(m_socket, data, len, flags);
+      return bytesSent;
+   }
+
+   // Non-blocking receive - returns empty string if no message available
+   string Receive(bool nonBlocking = true) {
+      if(!m_initialized) return "";
+      
+      uchar buffer[4096];
+      ArrayInitialize(buffer, 0);
+      
+      int flags = 0;
+      if(nonBlocking) flags = ZMQ_NOBLOCK;
+      
+      int bytesReceived = zmq_recv(m_socket, buffer, ArraySize(buffer) - 1, flags);
+      
+      if(bytesReceived <= 0) return "";
+      
+      return CharArrayToString(buffer, 0, bytesReceived, CP_UTF8);
+   }
+
+   void Shutdown() {
+      if(m_socket != 0) {
+         zmq_close(m_socket);
+         m_socket = 0;
+      }
+      if(m_context != 0) {
+         zmq_ctx_term(m_context);
+         m_context = 0;
+      }
+      m_initialized = false;
+   }
+};

SUM3API/MQL5/Libraries/libsodium.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7745aad20b9578c70b0fff48b3ee5f982c840e0f17b3dc7239a23d4fb36b0717
+size 302592

SUM3API/MQL5/Libraries/libzmq.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:19567709cb7ef4664249d46a796f23c06abbe6ba91db3c650aeaa372b4fbf989
+size 451072

SUM3API/Rustmt5-chart/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "Rustmt5-chart"
+version = "0.1.0"
+edition = "2026"
+
+[dependencies]
+eframe = "0.27.1"
+egui = "0.27.1"
+egui_plot = "0.27.1"
+zeromq = "0.5.0-pre"
+serde = { version = "1.0.197", features = ["derive"] }
+serde_json = "1.0.114"
+tokio = { version = "1.36.0", features = ["full"] }
+futures = "0.3.30"
+chrono = "0.4.43"

SUM3API/Rustmt5-chart/output/History_XAUUSDc_H1_OHLC_ID0002_20260126_135823.csv

@@ -0,0 +1,3 @@
+Time,Open,High,Low,Close,TickVol,Spread
+2026.01.25 23:00,5019.847,5040.296,5003.575,5039.789,30600,160
+2026.01.26 00:00,5039.821,5052.099,5030.537,5041.830,25016,160

SUM3API/Rustmt5-chart/output/Live_XAUUSDc_ID0001_20260126_135811.csv

@@ -0,0 +1,14 @@
+Time,Bid,Ask,Volume
+1769407092,5073.44,5073.6,0
+1769407092,5073.412,5073.572,0
+1769407092,5073.463,5073.623,0
+1769407092,5073.619,5073.779,0
+1769407092,5073.69,5073.85,0
+1769407092,5073.738,5073.898,0
+1769407092,5073.828,5073.988,0
+1769407093,5073.716,5073.876,0
+1769407093,5073.626,5073.786,0
+1769407093,5073.737,5073.897,0
+1769407093,5073.607,5073.767,0
+1769407093,5073.705,5073.865,0
+1769407093,5073.744,5073.904,0

SUM3API/Rustmt5-chart/src/main.rs

@@ -0,0 +1,852 @@
+//+------------------------------------------------------------------+
+//|                                                          main.rs |
+//|                                    Copyright 2026, Algorembrant  |
+//|                                                                  |
+//+------------------------------------------------------------------+
+//property copyright "Algorembrant"
+//property link      "https://github.com/ContinualQuasars/SUM3API"
+//property version   "2.00"
+//property strict
+
+use eframe::egui;
+use egui_plot::{Line, Plot, PlotPoints};
+use serde::{Deserialize, Serialize};
+use tokio::sync::mpsc;
+use zeromq::{Socket, SocketRecv, SocketSend};
+use std::fs::{self, OpenOptions};
+use std::io::Write;
+use std::path::PathBuf;
+
+// ============================================================================
+// Data Structures
+// ============================================================================
+
+#[derive(Clone, Debug, Deserialize)]
+#[allow(dead_code)]
+struct PositionData {
+    ticket: u64,
+    #[serde(rename = "type")]
+    pos_type: String, // "BUY" or "SELL"
+    volume: f64,
+    price: f64,
+    profit: f64,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[allow(dead_code)]
+struct PendingOrderData {
+    ticket: u64,
+    #[serde(rename = "type")]
+    order_type: String, // "BUY LIMIT", "SELL STOP", etc.
+    volume: f64,
+    price: f64,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+struct TickData {
+    symbol: String,
+    bid: f64,
+    ask: f64,
+    time: i64,
+    #[serde(default)]
+    volume: u64,
+    // Account info
+    #[serde(default)]
+    balance: f64,
+    #[serde(default)]
+    equity: f64,
+    #[serde(default)]
+    margin: f64,
+    #[serde(default)]
+    free_margin: f64,
+    // Trading constraints
+    #[serde(default)]
+    min_lot: f64,
+    #[serde(default)]
+    max_lot: f64,
+    #[serde(default)]
+    lot_step: f64,
+    
+    // Active trades
+    #[serde(default)]
+    positions: Vec<PositionData>,
+    #[serde(default)]
+    orders: Vec<PendingOrderData>,
+}
+
+#[derive(Clone, Debug, Serialize)]
+struct OrderRequest {
+    #[serde(rename = "type")]
+    order_type: String,
+    symbol: String,
+    volume: f64,
+    price: f64,
+    #[serde(default)]
+    ticket: u64, // For close/cancel
+    // History params
+    #[serde(skip_serializing_if = "Option::is_none")]
+    timeframe: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    start: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    end: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    mode: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    request_id: Option<u64>,  // Unique ID for history downloads
+}
+
+#[derive(Clone, Debug, Deserialize)]
+struct OrderResponse {
+    success: bool,
+    ticket: Option<i64>,
+    error: Option<String>,
+    message: Option<String>,
+}
+
+// Struct for tracking order execution breaklines on chart
+#[derive(Clone, Debug)]
+struct OrderBreakline {
+    index: usize,        // Data index where order was executed
+    order_type: String,  // "BUY" or "SELL" variant
+    ticket: i64,         // Order ticket number
+}
+
+// ============================================================================
+// Application State
+// ============================================================================
+
+struct Mt5ChartApp {
+    // Tick data
+    tick_receiver: mpsc::Receiver<TickData>,
+    data: Vec<TickData>,
+    symbol: String,
+    
+    // Latest account info
+    balance: f64,
+    equity: f64,
+    margin: f64,
+    free_margin: f64,
+    min_lot: f64,
+    max_lot: f64,
+    lot_step: f64,
+    
+    // Order handling
+    order_sender: mpsc::Sender<OrderRequest>,
+    response_receiver: mpsc::Receiver<OrderResponse>,
+    
+    // UI state for order panel
+    lot_size: f64,
+    lot_size_str: String,
+    limit_price: String,
+    #[allow(dead_code)]
+    stop_price: String,
+    last_order_result: Option<String>,
+    
+    // History Download UI
+    history_start_date: String,
+    history_end_date: String,
+    history_tf: String,
+    history_mode: String,
+    
+    // Live Recording
+    is_recording: bool,
+    live_record_file: Option<std::fs::File>,
+    
+    // Live Trade Data
+    positions: Vec<PositionData>,
+    pending_orders: Vec<PendingOrderData>,
+    
+    // CSV Output Management
+    output_dir: PathBuf,
+    request_counter: u64,
+    
+    // Order Breaklines for Chart
+    order_breaklines: Vec<OrderBreakline>,
+    pending_order_type: Option<String>,  // Track what type of order is pending
+    
+    // Pending history request info for CSV naming
+    pending_history_request: Option<(u64, String, String, String)>, // (id, symbol, tf, mode)
+}
+
+impl Mt5ChartApp {
+    fn new(
+        tick_receiver: mpsc::Receiver<TickData>,
+        order_sender: mpsc::Sender<OrderRequest>,
+        response_receiver: mpsc::Receiver<OrderResponse>,
+    ) -> Self {
+        // Defaults dates to "yyyy.mm.dd"
+        let now = chrono::Local::now();
+        let today_str = now.format("%Y.%m.%d").to_string();
+        
+        // Ensure output directory exists
+        let output_dir = PathBuf::from("output");
+        fs::create_dir_all(&output_dir).ok();
+        
+        Self {
+            tick_receiver,
+            data: Vec::new(),
+            symbol: "Waiting for data...".to_string(),
+            balance: 0.0,
+            equity: 0.0,
+            margin: 0.0,
+            free_margin: 0.0,
+            min_lot: 0.01,
+            max_lot: 100.0,
+            lot_step: 0.01,
+            order_sender,
+            response_receiver,
+            lot_size: 0.01,
+            lot_size_str: "0.01".to_string(),
+            limit_price: "0.0".to_string(),
+            stop_price: "0.0".to_string(),
+            last_order_result: None,
+            
+            history_start_date: today_str.clone(),
+            history_end_date: today_str,
+            history_tf: "M1".to_string(),
+            history_mode: "OHLC".to_string(),
+            
+            is_recording: false,
+            live_record_file: None,
+            
+            positions: Vec::new(),
+            pending_orders: Vec::new(),
+            
+            // Initialize new fields
+            output_dir,
+            request_counter: 0,
+            order_breaklines: Vec::new(),
+            pending_order_type: None,
+            pending_history_request: None,
+        }
+    }
+    
+    fn send_order(&mut self, order_type: &str, price: Option<f64>, ticket: Option<u64>) {
+        let price_val = price.unwrap_or(0.0);
+        let ticket_val = ticket.unwrap_or(0);
+        
+        // Track order type for breakline visualization (only for market orders)
+        if order_type.contains("market") {
+            self.pending_order_type = Some(order_type.to_string());
+        }
+        
+        let request = OrderRequest {
+            order_type: order_type.to_string(),
+            symbol: self.symbol.clone(),
+            volume: self.lot_size,
+            price: price_val,
+            ticket: ticket_val,
+            timeframe: None,
+            start: None,
+            end: None,
+            mode: None,
+            request_id: None,
+        };
+        
+        self.send_request_impl(request);
+    }
+    
+    fn send_download_request(&mut self) {
+        // Increment counter for unique history download ID
+        self.request_counter += 1;
+        
+        // Store request info for CSV filename generation when response arrives
+        self.pending_history_request = Some((
+            self.request_counter,
+            self.symbol.replace("/", "-"),
+            self.history_tf.clone(),
+            self.history_mode.clone(),
+        ));
+        
+        let request = OrderRequest {
+            order_type: "download_history".to_string(),
+            symbol: self.symbol.clone(),
+            volume: 0.0,
+            price: 0.0,
+            ticket: 0,
+            timeframe: Some(self.history_tf.clone()),
+            start: Some(self.history_start_date.clone()),
+            end: Some(self.history_end_date.clone()),
+            mode: Some(self.history_mode.clone()),
+            request_id: Some(self.request_counter),
+        };
+        
+        self.send_request_impl(request);
+    }
+    
+    fn send_request_impl(&mut self, request: OrderRequest) {
+        if let Err(e) = self.order_sender.try_send(request) {
+            self.last_order_result = Some(format!("Failed to send: {}", e));
+        } else {
+            self.last_order_result = Some("Request sent...".to_string());
+        }
+    }
+    
+    fn adjust_lot_size(&mut self, delta: f64) {
+        let new_lot = self.lot_size + delta;
+        // Round to lot_step
+        let steps = (new_lot / self.lot_step).round();
+        self.lot_size = (steps * self.lot_step).max(self.min_lot).min(self.max_lot);
+        self.lot_size_str = format!("{:.2}", self.lot_size);
+    }
+    
+    fn toggle_recording(&mut self) {
+        self.is_recording = !self.is_recording;
+        if self.is_recording {
+            // Increment counter for unique ID
+            self.request_counter += 1;
+            let filename = format!(
+                "{}/Live_{}_ID{:04}_{}.csv",
+                self.output_dir.display(),
+                self.symbol.replace("/", "-"),
+                self.request_counter,
+                chrono::Local::now().format("%Y%m%d_%H%M%S")
+            );
+            match OpenOptions::new().create(true).append(true).open(&filename) {
+                Ok(mut file) => {
+                    let _ = writeln!(file, "Time,Bid,Ask,Volume");
+                    self.live_record_file = Some(file);
+                    self.last_order_result = Some(format!("Recording to {}", filename));
+                }
+                Err(e) => {
+                    self.is_recording = false;
+                    self.last_order_result = Some(format!("Rec Error: {}", e));
+                }
+            }
+        } else {
+            self.live_record_file = None;
+            self.last_order_result = Some("Recording Stopped".to_string());
+        }
+    }
+}
+
+impl eframe::App for Mt5ChartApp {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        // Receive all available tick data from the channel without blocking
+        while let Ok(tick) = self.tick_receiver.try_recv() {
+            self.symbol = tick.symbol.clone();
+            
+            // Record if active
+            if self.is_recording {
+                if let Some(mut file) = self.live_record_file.as_ref() {
+                     let _ = writeln!(file, "{},{},{},{}", tick.time, tick.bid, tick.ask, tick.volume);
+                }
+            }
+            
+            // Update account info from latest tick
+            if tick.balance > 0.0 {
+                self.balance = tick.balance;
+                self.equity = tick.equity;
+                self.margin = tick.margin;
+                self.free_margin = tick.free_margin;
+                self.min_lot = tick.min_lot;
+                self.max_lot = tick.max_lot;
+                if tick.lot_step > 0.0 {
+                    self.lot_step = tick.lot_step;
+                }
+            }
+            
+            // Update active trades
+            self.positions = tick.positions.clone();
+            self.pending_orders = tick.orders.clone();
+            
+            self.data.push(tick);
+            // Keep only last 2000 points
+            if self.data.len() > 2000 {
+                self.data.remove(0);
+            }
+        }
+        
+        // Check for order responses
+        while let Ok(response) = self.response_receiver.try_recv() {
+            if response.success {
+                // Check if this is a history download with CSV data
+                if let Some(ref msg) = response.message {
+                    if msg.contains("||CSV_DATA||") {
+                        // Parse CSV data from response
+                        let parts: Vec<&str> = msg.splitn(2, "||CSV_DATA||").collect();
+                        if parts.len() == 2 {
+                            let info_part = parts[0];
+                            let csv_content = parts[1];
+                            
+                            // Generate filename using pending request info
+                            if let Some((id, symbol, tf, mode)) = self.pending_history_request.take() {
+                                let timestamp = chrono::Local::now().format("%Y%m%d_%H%M%S");
+                                let filename = format!(
+                                    "{}/History_{}_{}_{}_ID{:04}_{}.csv",
+                                    self.output_dir.display(),
+                                    symbol, tf, mode, id, timestamp
+                                );
+                                
+                                // Convert |NL| placeholders back to real newlines
+                                let csv_with_newlines = csv_content.replace("|NL|", "\n");
+                                
+                                // Save CSV to output folder
+                                match std::fs::write(&filename, csv_with_newlines) {
+                                    Ok(_) => {
+                                        self.last_order_result = Some(format!(
+                                            "✓ {} → Saved to {}",
+                                            info_part, filename
+                                        ));
+                                    }
+                                    Err(e) => {
+                                        self.last_order_result = Some(format!(
+                                            "✗ Failed to save CSV: {}",
+                                            e
+                                        ));
+                                    }
+                                }
+                            } else {
+                                self.last_order_result = Some(format!("✓ {}", info_part));
+                            }
+                        } else {
+                            self.last_order_result = Some(format!("✓ {}", msg));
+                        }
+                    } else {
+                        self.last_order_result = Some(format!("✓ {}", msg));
+                    }
+                } else {
+                    // Add breakline for successful market orders
+                    if let Some(ref order_type) = self.pending_order_type.take() {
+                        let breakline = OrderBreakline {
+                            index: self.data.len().saturating_sub(1),
+                            order_type: order_type.clone(),
+                            ticket: response.ticket.unwrap_or(0),
+                        };
+                        self.order_breaklines.push(breakline);
+                        // Keep only last 50 breaklines
+                        if self.order_breaklines.len() > 50 {
+                            self.order_breaklines.remove(0);
+                        }
+                    }
+                    
+                    self.last_order_result = Some(format!(
+                        "✓ Order executed! Ticket: {}",
+                        response.ticket.unwrap_or(0)
+                    ));
+                }
+            } else {
+                self.pending_order_type = None; // Clear pending on failure
+                self.pending_history_request = None; // Clear pending history request
+                self.last_order_result = Some(format!(
+                    "✗ Failed: {}",
+                    response.error.unwrap_or_else(|| "Unknown error".to_string())
+                ));
+            }
+        }
+
+        // ====================================================================
+        // Side Panel - Trading Controls
+        // ====================================================================
+        egui::SidePanel::left("trading_panel")
+            .min_width(280.0) // Widen slightly
+            .show(ctx, |ui| {
+                ui.heading("📊 Trading Panel");
+                ui.separator();
+                
+                // Account Info
+                ui.collapsing("💰 Account Info", |ui| {
+                    egui::Grid::new("account_grid")
+                        .num_columns(2)
+                        .spacing([10.0, 4.0])
+                        .show(ui, |ui| {
+                            ui.label("Balance:");
+                            ui.colored_label(egui::Color32::from_rgb(100, 200, 100), format!("${:.2}", self.balance));
+                            ui.end_row();
+                            ui.label("Equity:");
+                            ui.colored_label(egui::Color32::from_rgb(100, 180, 255), format!("${:.2}", self.equity));
+                            ui.end_row();
+                            ui.label("Margin Used:");
+                            ui.colored_label(egui::Color32::from_rgb(255, 200, 100), format!("${:.2}", self.margin));
+                            ui.end_row();
+                            ui.label("Free Margin:");
+                            ui.colored_label(egui::Color32::from_rgb(100, 255, 200), format!("${:.2}", self.free_margin));
+                            ui.end_row();
+                        });
+                });
+                
+                ui.separator();
+                
+                // Historical Data Section
+                ui.heading("📂 Historical Data");
+                ui.add_space(5.0);
+                
+                egui::Grid::new("history_grid").num_columns(2).spacing([10.0, 5.0]).show(ui, |ui| {
+                    ui.label("Start (yyyy.mm.dd):");
+                    ui.add(egui::TextEdit::singleline(&mut self.history_start_date).desired_width(100.0));
+                    ui.end_row();
+                    
+                    ui.label("End (yyyy.mm.dd):");
+                    ui.add(egui::TextEdit::singleline(&mut self.history_end_date).desired_width(100.0));
+                    ui.end_row();
+                    
+                    ui.label("Timeframe:");
+                    egui::ComboBox::from_id_source("tf_combo")
+                        .selected_text(&self.history_tf)
+                        .show_ui(ui, |ui| {
+                            ui.selectable_value(&mut self.history_tf, "M1".to_string(), "M1");
+                            ui.selectable_value(&mut self.history_tf, "M5".to_string(), "M5");
+                            ui.selectable_value(&mut self.history_tf, "M15".to_string(), "M15");
+                            ui.selectable_value(&mut self.history_tf, "H1".to_string(), "H1");
+                            ui.selectable_value(&mut self.history_tf, "D1".to_string(), "D1");
+                        });
+                    ui.end_row();
+                    
+                    ui.label("Mode:");
+                    egui::ComboBox::from_id_source("mode_combo")
+                        .selected_text(&self.history_mode)
+                        .show_ui(ui, |ui| {
+                             ui.selectable_value(&mut self.history_mode, "OHLC".to_string(), "OHLC");
+                             ui.selectable_value(&mut self.history_mode, "TICKS".to_string(), "TICKS");
+                        });
+                    ui.end_row();
+                });
+                
+                ui.add_space(5.0);
+                if ui.button("⬇ Download History (CSV)").clicked() {
+                    self.send_download_request();
+                }
+                
+                ui.separator();
+                
+                // Live Recording
+                ui.heading("🔴 Live Recording");
+                ui.horizontal(|ui| {
+                   ui.label(if self.is_recording { "Recording..." } else { "Idle" });
+                   if ui.button(if self.is_recording { "Stop" } else { "Start Recording" }).clicked() {
+                       self.toggle_recording();
+                   }
+                });
+                
+                ui.separator();
+
+                // Order Controls
+                ui.heading("📦 Trade Controls");
+                
+                // Lot Size
+                ui.horizontal(|ui| {
+                    if ui.button("−").clicked() { self.adjust_lot_size(-self.lot_step); }
+                    let response = ui.add(egui::TextEdit::singleline(&mut self.lot_size_str).desired_width(60.0));
+                    if response.lost_focus() {
+                        if let Ok(parsed) = self.lot_size_str.parse::<f64>() {
+                            self.lot_size = parsed.max(self.min_lot).min(self.max_lot);
+                            self.lot_size_str = format!("{:.2}", self.lot_size);
+                        }
+                    }
+                    if ui.button("+").clicked() { self.adjust_lot_size(self.lot_step); }
+                    
+                    ui.label(format!("Lots (Max: {:.1})", self.max_lot));
+                });
+                
+                ui.add_space(5.0);
+                ui.label("Market Orders:");
+                ui.horizontal(|ui| {
+                    if ui.button("BUY").clicked() { self.send_order("market_buy", None, None); }
+                    if ui.button("SELL").clicked() { self.send_order("market_sell", None, None); }
+                });
+                
+                ui.add_space(5.0);
+                ui.label("Pending Orders:");
+                 ui.horizontal(|ui| {
+                    ui.label("@ Price:");
+                    ui.add(egui::TextEdit::singleline(&mut self.limit_price).desired_width(70.0));
+                });
+                ui.horizontal(|ui| {
+                    let p = self.limit_price.parse().unwrap_or(0.0);
+                    if ui.small_button("Buy Limit").clicked() { self.send_order("limit_buy", Some(p), None); }
+                    if ui.small_button("Sell Limit").clicked() { self.send_order("limit_sell", Some(p), None); }
+                    if ui.small_button("Buy Stop").clicked() { self.send_order("stop_buy", Some(p), None); }
+                    if ui.small_button("Sell Stop").clicked() { self.send_order("stop_sell", Some(p), None); }
+                });
+
+                ui.separator();
+
+                // Order result feedback
+                if let Some(ref result) = self.last_order_result {
+                    ui.heading("📨 Last Message");
+                    ui.label(result); // Allow wrapping
+                }
+                
+                ui.separator();
+                
+                // Active Positions - Close Management
+                ui.collapsing("💼 Active Positions", |ui| {
+                    if self.positions.is_empty() {
+                        ui.label("No active positions");
+                    } else {
+                        let positions_clone = self.positions.clone();
+                        for pos in positions_clone {
+                            ui.horizontal(|ui| {
+                                let color = if pos.pos_type == "BUY" {
+                                    egui::Color32::from_rgb(100, 200, 100)
+                                } else {
+                                    egui::Color32::from_rgb(255, 100, 100)
+                                };
+                                ui.colored_label(color, format!(
+                                    "#{} {} {:.2}@{:.5} P:{:.2}",
+                                    pos.ticket, pos.pos_type, pos.volume, pos.price, pos.profit
+                                ));
+                                if ui.small_button("Close").clicked() {
+                                    self.send_order("close_position", Some(pos.price), Some(pos.ticket));
+                                }
+                            });
+                        }
+                    }
+                });
+                
+                // Pending Orders - Cancel Management
+                ui.collapsing("⏳ Pending Orders", |ui| {
+                    if self.pending_orders.is_empty() {
+                        ui.label("No pending orders");
+                    } else {
+                        let orders_clone = self.pending_orders.clone();
+                        for order in orders_clone {
+                            ui.horizontal(|ui| {
+                                let color = if order.order_type.contains("BUY") {
+                                    egui::Color32::from_rgb(100, 150, 255)
+                                } else {
+                                    egui::Color32::from_rgb(255, 150, 100)
+                                };
+                                ui.colored_label(color, format!(
+                                    "#{} {} {:.2}@{:.5}",
+                                    order.ticket, order.order_type, order.volume, order.price
+                                ));
+                                if ui.small_button("Cancel").clicked() {
+                                    self.send_order("cancel_order", Some(order.price), Some(order.ticket));
+                                }
+                            });
+                        }
+                    }
+                });
+            });
+
+        // ====================================================================
+        // Central Panel - Chart
+        // ====================================================================
+        egui::CentralPanel::default().show(ctx, |ui| {
+            ui.heading(format!("📈 {}", self.symbol));
+            
+            // Header Info
+            if let Some(last_tick) = self.data.last() {
+                ui.horizontal(|ui| {
+                    ui.label(format!("{:.5} / {:.5}", last_tick.bid, last_tick.ask));
+                });
+            }
+            
+            ui.separator();
+
+            // Price chart - Index-based X Axis
+            let time_map: Vec<i64> = self.data.iter().map(|t| t.time).collect();
+            
+            let plot = Plot::new("mt5_price_plot")
+                .legend(egui_plot::Legend::default())
+                .allow_boxed_zoom(true)
+                .allow_drag(true)
+                .allow_scroll(true)
+                .allow_zoom(true)
+                .x_axis_formatter(move |x, _range, _width| {
+                    let idx = x.value.round() as isize;
+                    if idx >= 0 && (idx as usize) < time_map.len() {
+                        let timestamp = time_map[idx as usize];
+                        let seconds = timestamp % 60;
+                        let minutes = (timestamp / 60) % 60;
+                        let hours = (timestamp / 3600) % 24;
+                        return format!("{:02}:{:02}:{:02}", hours, minutes, seconds);
+                    }
+                    "".to_string()
+                });
+
+            plot.show(ui, |plot_ui| {
+                let bid_points: PlotPoints = self.data
+                    .iter()
+                    .enumerate()
+                    .map(|(i, t)| [i as f64, t.bid])
+                    .collect();
+                
+                let ask_points: PlotPoints = self.data
+                    .iter()
+                    .enumerate()
+                    .map(|(i, t)| [i as f64, t.ask])
+                    .collect();
+
+                plot_ui.line(Line::new(bid_points).name("Bid").color(egui::Color32::from_rgb(100, 200, 100)));
+                plot_ui.line(Line::new(ask_points).name("Ask").color(egui::Color32::from_rgb(200, 100, 100)));
+                
+                // Draw Active Positions (horizontal lines)
+                for pos in &self.positions {
+                    let color = if pos.pos_type == "BUY" {
+                        egui::Color32::from_rgb(50, 100, 255) 
+                    } else {
+                        egui::Color32::from_rgb(255, 50, 50) 
+                    };
+                    
+                    plot_ui.hline(
+                        egui_plot::HLine::new(pos.price)
+                            .color(color)
+                            .name(format!("{} #{}", pos.pos_type, pos.ticket))
+                            .style(egui_plot::LineStyle::Dashed { length: 10.0 })
+                    );
+                }
+                
+                // Draw Order Breaklines (vertical lines at execution points)
+                for breakline in &self.order_breaklines {
+                    let color = if breakline.order_type.contains("buy") {
+                        egui::Color32::from_rgb(0, 200, 100) // Bright green for BUY
+                    } else {
+                        egui::Color32::from_rgb(255, 80, 80) // Bright red for SELL
+                    };
+                    
+                    plot_ui.vline(
+                        egui_plot::VLine::new(breakline.index as f64)
+                            .color(color)
+                            .name(format!("Order #{}", breakline.ticket))
+                            .width(2.0)
+                    );
+                }
+            });
+        });
+
+        // Request a repaint to update the chart continuously
+        ctx.request_repaint();
+    }
+}
+
+// ============================================================================
+// Main Entry Point
+// ============================================================================
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Channels for tick data
+    let (tick_tx, tick_rx) = mpsc::channel(100);
+    
+    // Channels for order requests and responses
+    let (order_tx, mut order_rx) = mpsc::channel::<OrderRequest>(10);
+    let (response_tx, response_rx) = mpsc::channel::<OrderResponse>(10);
+
+    // ========================================================================
+    // Spawn ZMQ Tick Subscriber task
+    // ========================================================================
+    tokio::spawn(async move {
+        let mut socket = zeromq::SubSocket::new();
+        match socket.connect("tcp://127.0.0.1:5555").await {
+            Ok(_) => println!("Connected to ZMQ Tick Publisher on port 5555"),
+            Err(e) => eprintln!("Failed to connect to ZMQ tick publisher: {}", e),
+        }
+        
+        let _ = socket.subscribe("").await;
+
+        loop {
+            match socket.recv().await {
+                Ok(msg) => {
+                    if let Some(payload_bytes) = msg.get(0) {
+                        if let Ok(json_str) = std::str::from_utf8(payload_bytes) {
+                            match serde_json::from_str::<TickData>(json_str) {
+                                Ok(tick) => {
+                                    if let Err(e) = tick_tx.send(tick).await {
+                                        eprintln!("Tick channel error: {}", e);
+                                        break;
+                                    }
+                                }
+                                Err(e) => eprintln!("JSON Parse Error: {}. Msg: {}", e, json_str),
+                            }
+                        }
+                    }
+                }
+                Err(e) => {
+                    eprintln!("ZMQ Tick Recv Error: {}", e);
+                    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+                }
+            }
+        }
+    });
+
+    // ========================================================================
+    // Spawn ZMQ Order Request/Response task
+    // ========================================================================
+    tokio::spawn(async move {
+        let mut socket = zeromq::ReqSocket::new();
+        match socket.connect("tcp://127.0.0.1:5556").await {
+            Ok(_) => println!("Connected to ZMQ Order Handler on port 5556"),
+            Err(e) => {
+                eprintln!("Failed to connect to ZMQ order handler: {}", e);
+                return;
+            }
+        }
+
+        while let Some(order_request) = order_rx.recv().await {
+            // Serialize order request to JSON
+            let json_request = match serde_json::to_string(&order_request) {
+                Ok(json) => json,
+                Err(e) => {
+                    eprintln!("Failed to serialize order request: {}", e);
+                    continue;
+                }
+            };
+            
+            println!("Sending request: {}", json_request);
+            
+            // Send request
+            if let Err(e) = socket.send(json_request.into()).await {
+                eprintln!("Failed to send: {}", e);
+                let _ = response_tx.send(OrderResponse {
+                    success: false,
+                    ticket: None,
+                    error: Some(format!("Send failed: {}", e)),
+                    message: None,
+                }).await;
+                continue;
+            }
+            
+            // Wait for response
+            match socket.recv().await {
+                Ok(msg) => {
+                    if let Some(payload_bytes) = msg.get(0) {
+                        if let Ok(json_str) = std::str::from_utf8(payload_bytes) {
+                            println!("Received response: {}", json_str);
+                            match serde_json::from_str::<OrderResponse>(json_str) {
+                                Ok(response) => {
+                                    let _ = response_tx.send(response).await;
+                                }
+                                Err(e) => {
+                                    let _ = response_tx.send(OrderResponse {
+                                        success: false,
+                                        ticket: None,
+                                        error: Some(format!("Parse error: {}", e)),
+                                        message: None,
+                                    }).await;
+                                }
+                            }
+                        }
+                    }
+                }
+                Err(e) => {
+                    eprintln!("Response recv error: {}", e);
+                    let _ = response_tx.send(OrderResponse {
+                        success: false,
+                        ticket: None,
+                        error: Some(format!("Recv failed: {}", e)),
+                        message: None,
+                    }).await;
+                }
+            }
+        }
+    });
+
+    // ========================================================================
+    // Run the egui application
+    // ========================================================================
+    let options = eframe::NativeOptions {
+        viewport: egui::ViewportBuilder::default()
+            .with_inner_size([1200.0, 800.0])
+            .with_title("Rust + ZMQ + MT5 Trading Chart"),
+        ..Default::default()
+    };
+    
+    eframe::run_native(
+        "Rust + ZMQ + MT5 Trading Chart",
+        options,
+        Box::new(|_cc| Box::new(Mt5ChartApp::new(tick_rx, order_tx, response_rx))),
+    ).map_err(|e| e.into())
+}

TECHSTACK.md

@@ -0,0 +1,18 @@
+## Techstack
+
+Audit of **SUM3-Trading-Terminal** project files (excluding environment and cache):
+
+| File Type | Count | Size (KB) |
+| :--- | :--- | :--- |
+| Rust (.rs) | 9 | 95.8 |
+| CSV (.csv) | 7 | 1,226.9 |
+| PNG Image (.png) | 7 | 998.7 |
+| (no extension) | 2 | 2.1 |
+| DLL Library (.dll) | 2 | 736.0 |
+| Lock File (.lock) | 2 | 235.3 |
+| TOML (.toml) | 2 | 0.7 |
+| Markdown (.md) | 1 | 0.5 |
+| MQL Header (.mqh) | 1 | 4.0 |
+| MQL5 Source (.mq5) | 1 | 18.6 |
+| Python (.py) | 1 | 26.5 |
+| **Total** | **35** | **3,345.2** |

gmp-terminal/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "gmp-terminal"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+eframe = "0.27.1"
+egui = "0.27.1"
+egui_plot = "0.27.1"
+zeromq = "0.5.0-pre"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+tokio = { version = "1.36", features = ["full"] }
+chrono = "0.4"
+
+[profile.release]
+opt-level = 3
+lto = true
+codegen-units = 1

gmp-terminal/src/app.rs

@@ -0,0 +1,340 @@
+// ============================================================================
+// app.rs -- Application State & eframe::App Implementation
+// ============================================================================
+// Central state struct shared across all UI modules.
+// Tab switching pauses inactive tab computation.
+// ============================================================================
+
+use crate::gmp_engine::{IntervalProfile, RawTick};
+use crate::zmq_bridge::{OrderRequest, OrderResponse, PositionData, PendingOrderData, TickData};
+use crate::tab_time;
+use crate::tab_trade;
+use crate::trading_panel;
+use std::io::Write;
+use std::path::PathBuf;
+use tokio::sync::mpsc;
+
+// ─── Tab Enum ────────────────────────────────────────────────────────────────
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum TabMode {
+    TimeBased,
+    TradeBased,
+}
+
+// ─── Application State ──────────────────────────────────────────────────────
+
+pub struct AppState {
+    // ZMQ channels
+    pub tick_rx:     mpsc::Receiver<TickData>,
+    pub order_tx:    mpsc::Sender<OrderRequest>,
+    pub response_rx: mpsc::Receiver<OrderResponse>,
+
+    // Raw tick buffer (rolling)
+    pub raw_ticks: Vec<RawTick>,
+    pub symbol:    String,
+
+    // Account
+    pub balance:     f64,
+    pub equity:      f64,
+    pub margin:      f64,
+    pub free_margin: f64,
+    pub min_lot:     f64,
+    pub max_lot:     f64,
+    pub lot_step:    f64,
+
+    // Positions & orders (from latest tick)
+    pub positions:      Vec<PositionData>,
+    pub pending_orders: Vec<PendingOrderData>,
+
+    // Trading UI
+    pub lot_size:         f64,
+    pub lot_size_str:     String,
+    pub limit_price_str:  String,
+    pub last_status:      Option<String>,
+
+    // Chart config
+    pub bin_size:     f64,
+    pub bin_size_str: String,
+    pub active_tab:   TabMode,
+
+    // Time-based tab
+    pub time_interval_secs: u64,
+    pub time_input_str:     String,
+    pub time_parse_err:     Option<String>,
+    pub time_profiles:      Vec<IntervalProfile>,
+    pub profiles_dirty:     bool,
+    pub show_footprint:     bool,
+
+    // Trade-based tab
+    pub trade_interval:       usize,
+    pub trade_input_str:      String,
+    pub trade_profiles:       Vec<IntervalProfile>,
+    pub profiles_dirty_trade: bool,
+    pub show_footprint_trade: bool,
+
+    // History download
+    pub history_start: String,
+    pub history_end:   String,
+    pub history_tf:    String,
+    pub history_mode:  String,
+
+    // Live recording
+    pub is_recording:    bool,
+    pub live_record_file: Option<std::fs::File>,
+
+    // Output
+    pub output_dir:      PathBuf,
+    pub request_counter: u64,
+    pub pending_history: Option<(u64, String, String, String)>,
+
+    // Max ticks to keep in memory
+    max_ticks: usize,
+}
+
+impl AppState {
+    pub fn new(
+        tick_rx: mpsc::Receiver<TickData>,
+        order_tx: mpsc::Sender<OrderRequest>,
+        response_rx: mpsc::Receiver<OrderResponse>,
+    ) -> Self {
+        let now = chrono::Local::now();
+        let today = now.format("%Y.%m.%d").to_string();
+        let output_dir = PathBuf::from("output");
+        std::fs::create_dir_all(&output_dir).ok();
+
+        Self {
+            tick_rx,
+            order_tx,
+            response_rx,
+            raw_ticks: Vec::new(),
+            symbol: "Waiting...".to_string(),
+            balance: 0.0,
+            equity: 0.0,
+            margin: 0.0,
+            free_margin: 0.0,
+            min_lot: 0.01,
+            max_lot: 100.0,
+            lot_step: 0.01,
+            positions: Vec::new(),
+            pending_orders: Vec::new(),
+            lot_size: 0.01,
+            lot_size_str: "0.01".to_string(),
+            limit_price_str: "0.0".to_string(),
+            last_status: None,
+            bin_size: 1.0,
+            bin_size_str: "1".to_string(),
+            active_tab: TabMode::TimeBased,
+            time_interval_secs: 60,
+            time_input_str: "1m".to_string(),
+            time_parse_err: None,
+            time_profiles: Vec::new(),
+            profiles_dirty: true,
+            show_footprint: false,
+            trade_interval: 50,
+            trade_input_str: "50".to_string(),
+            trade_profiles: Vec::new(),
+            profiles_dirty_trade: true,
+            show_footprint_trade: false,
+            history_start: today.clone(),
+            history_end: today,
+            history_tf: "M1".to_string(),
+            history_mode: "TICKS".to_string(),
+            is_recording: false,
+            live_record_file: None,
+            output_dir,
+            request_counter: 0,
+            pending_history: None,
+            max_ticks: 50_000,
+        }
+    }
+}
+
+// ─── eframe::App ─────────────────────────────────────────────────────────────
+
+pub struct GmpTerminalApp {
+    pub state: AppState,
+}
+
+impl GmpTerminalApp {
+    pub fn new(
+        tick_rx: mpsc::Receiver<TickData>,
+        order_tx: mpsc::Sender<OrderRequest>,
+        response_rx: mpsc::Receiver<OrderResponse>,
+    ) -> Self {
+        Self {
+            state: AppState::new(tick_rx, order_tx, response_rx),
+        }
+    }
+}
+
+impl eframe::App for GmpTerminalApp {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        let state = &mut self.state;
+
+        // ── Drain tick channel ──
+        let mut new_ticks = false;
+        while let Ok(tick) = state.tick_rx.try_recv() {
+            state.symbol = tick.symbol.clone();
+
+            // Record if active
+            if state.is_recording {
+                if let Some(ref mut file) = state.live_record_file {
+                    let _ = writeln!(
+                        file, "{},{},{},{}",
+                        tick.time, tick.bid, tick.ask, tick.volume
+                    );
+                }
+            }
+
+            // Update account info
+            if tick.balance > 0.0 {
+                state.balance = tick.balance;
+                state.equity = tick.equity;
+                state.margin = tick.margin;
+                state.free_margin = tick.free_margin;
+                state.min_lot = tick.min_lot;
+                state.max_lot = tick.max_lot;
+                if tick.lot_step > 0.0 {
+                    state.lot_step = tick.lot_step;
+                }
+            }
+
+            // Update positions/orders
+            state.positions = tick.positions.clone();
+            state.pending_orders = tick.orders.clone();
+
+            // Use mid-price (avg of bid/ask) for GMP computation
+            let mid = (tick.bid + tick.ask) * 0.5;
+            let idx = state.raw_ticks.len();
+            state.raw_ticks.push(RawTick {
+                price: mid,
+                time: tick.time,
+                index: idx,
+            });
+
+            new_ticks = true;
+        }
+
+        // Trim buffer
+        if state.raw_ticks.len() > state.max_ticks {
+            let excess = state.raw_ticks.len() - state.max_ticks;
+            state.raw_ticks.drain(..excess);
+        }
+
+        // Mark profiles dirty if new ticks arrived
+        if new_ticks {
+            match state.active_tab {
+                TabMode::TimeBased  => state.profiles_dirty = true,
+                TabMode::TradeBased => state.profiles_dirty_trade = true,
+            }
+        }
+
+        // ── Drain order responses ──
+        while let Ok(resp) = state.response_rx.try_recv() {
+            if resp.success {
+                if let Some(ref msg) = resp.message {
+                    if msg.contains("||CSV_DATA||") {
+                        handle_csv_response(state, msg);
+                    } else {
+                        state.last_status = Some(format!("OK: {}", msg));
+                    }
+                } else {
+                    state.last_status = Some(format!(
+                        "OK: ticket {}",
+                        resp.ticket.unwrap_or(0)
+                    ));
+                }
+            } else {
+                state.pending_history = None;
+                state.last_status = Some(format!(
+                    "FAIL: {}",
+                    resp.error.unwrap_or_else(|| "Unknown".to_string())
+                ));
+            }
+        }
+
+        // ── Side Panel ──
+        egui::SidePanel::left("trading_panel")
+            .min_width(260.0)
+            .max_width(300.0)
+            .show(ctx, |ui| {
+                egui::ScrollArea::vertical().show(ui, |ui| {
+                    trading_panel::render_trading_panel(ui, state);
+                });
+            });
+
+        // ── Central Panel ──
+        egui::CentralPanel::default().show(ctx, |ui| {
+            // Header
+            ui.horizontal(|ui| {
+                ui.heading(&state.symbol);
+                if let Some(last) = state.raw_ticks.last() {
+                    let price = last.price;
+                    ui.label(format!("{:.5}", price));
+                }
+            });
+
+            // Tab bar
+            ui.horizontal(|ui| {
+                if ui
+                    .selectable_label(state.active_tab == TabMode::TimeBased, "Time-Based")
+                    .clicked()
+                {
+                    state.active_tab = TabMode::TimeBased;
+                    state.profiles_dirty = true;
+                }
+                if ui
+                    .selectable_label(state.active_tab == TabMode::TradeBased, "Trade-Based")
+                    .clicked()
+                {
+                    state.active_tab = TabMode::TradeBased;
+                    state.profiles_dirty_trade = true;
+                }
+            });
+
+            ui.separator();
+
+            // Active tab content -- only the selected tab computes
+            match state.active_tab {
+                TabMode::TimeBased  => tab_time::render(ui, state),
+                TabMode::TradeBased => tab_trade::render(ui, state),
+            }
+        });
+
+        // Continuous repaint
+        ctx.request_repaint();
+    }
+}
+
+// ─── CSV Response Handler ────────────────────────────────────────────────────
+
+fn handle_csv_response(state: &mut AppState, msg: &str) {
+    let parts: Vec<&str> = msg.splitn(2, "||CSV_DATA||").collect();
+    if parts.len() == 2 {
+        let info = parts[0];
+        let csv = parts[1];
+
+        if let Some((id, sym, tf, mode)) = state.pending_history.take() {
+            let ts = chrono::Local::now().format("%Y%m%d_%H%M%S");
+            let filename = format!(
+                "{}/History_{}_{}_{}_ID{:04}_{}.csv",
+                state.output_dir.display(),
+                sym, tf, mode, id, ts
+            );
+            let csv_clean = csv.replace("|NL|", "\n");
+            match std::fs::write(&filename, csv_clean) {
+                Ok(_) => {
+                    state.last_status = Some(format!("Saved: {} ({})", filename, info));
+                }
+                Err(e) => {
+                    state.last_status = Some(format!("Save error: {}", e));
+                }
+            }
+        } else {
+            state.last_status = Some(format!("OK: {}", info));
+        }
+    } else {
+        state.last_status = Some(format!("OK: {}", msg));
+    }
+}

gmp-terminal/src/gmp_engine.rs

@@ -0,0 +1,406 @@
+// ============================================================================
+// gmp_engine.rs -- Core GMP & Footprint GMP Algorithms
+// ============================================================================
+// Direct port of generate_profiles.py (mBA-GMP.v3).
+// All computation is pure; no GUI or IO dependencies.
+// ============================================================================
+
+use std::collections::BTreeMap;
+
+// ─── Data Structures ─────────────────────────────────────────────────────────
+
+/// A single raw tick used as input to the profile builders.
+#[derive(Clone, Debug)]
+pub struct RawTick {
+    pub price: f64,
+    pub time:  i64,   // unix timestamp (seconds)
+    pub index: usize, // sequential trade index
+}
+
+/// One bin in a GMP profile.
+#[derive(Clone, Debug, Default)]
+pub struct GmpBin {
+    pub count: u32,
+}
+
+/// One bin in a Footprint profile (GMP + directional classification).
+#[derive(Clone, Debug, Default)]
+pub struct FootprintBin {
+    pub count: u32,
+    pub up:    u32,
+    pub down:  u32,
+}
+
+impl FootprintBin {
+    #[inline]
+    pub fn delta(&self) -> i32 {
+        self.up as i32 - self.down as i32
+    }
+}
+
+/// A complete GMP profile for one interval.
+#[derive(Clone, Debug)]
+pub struct GmpProfile {
+    pub bins:     BTreeMap<i64, GmpBin>,
+    pub beta:     f64,
+    pub min_bin:  i64,
+    pub max_bin:  i64,
+}
+
+/// A complete Footprint profile for one interval.
+#[derive(Clone, Debug)]
+pub struct FootprintProfile {
+    pub bins:     BTreeMap<i64, FootprintBin>,
+    pub beta:     f64,
+    pub min_bin:  i64,
+    pub max_bin:  i64,
+}
+
+// ─── Core Helpers ────────────────────────────────────────────────────────────
+
+/// Compute bin index: floor(price / beta).
+/// Matches the Python: `int(math.floor(price / beta))`.
+#[inline]
+pub fn bin_index(price: f64, beta: f64) -> i64 {
+    (price / beta).floor() as i64
+}
+
+/// Price range for a given bin: [b*beta, (b+1)*beta).
+#[inline]
+pub fn bin_price_range(b: i64, beta: f64) -> (f64, f64) {
+    (b as f64 * beta, (b + 1) as f64 * beta)
+}
+
+// ─── GMP Builder ─────────────────────────────────────────────────────────────
+
+/// Build a Gap-filled Market Profile from a slice of ticks.
+///
+/// Algorithm (from main.tex Section IV):
+///   1. CMP placement: each tick fills its own bin.
+///   2. Gap-fill: for each consecutive pair, fill every bin strictly
+///      between the two endpoints.
+pub fn build_gmp(ticks: &[RawTick], beta: f64) -> GmpProfile {
+    let mut bins: BTreeMap<i64, GmpBin> = BTreeMap::new();
+
+    if ticks.is_empty() {
+        return GmpProfile { bins, beta, min_bin: 0, max_bin: 0 };
+    }
+
+    // Phase 1 -- CMP placement
+    for t in ticks {
+        let b = bin_index(t.price, beta);
+        bins.entry(b).or_default().count += 1;
+    }
+
+    // Phase 2 -- Gap-fill intermediate bins
+    for pair in ticks.windows(2) {
+        let b_from = bin_index(pair[0].price, beta);
+        let b_to   = bin_index(pair[1].price, beta);
+
+        if (b_to - b_from).abs() <= 1 {
+            continue; // adjacent or same bin
+        }
+
+        let dir: i64 = if b_to > b_from { 1 } else { -1 };
+        let mut b = b_from + dir;
+        while b != b_to {
+            bins.entry(b).or_default().count += 1;
+            b += dir;
+        }
+    }
+
+    let min_bin = *bins.keys().next().unwrap_or(&0);
+    let max_bin = *bins.keys().next_back().unwrap_or(&0);
+
+    GmpProfile { bins, beta, min_bin, max_bin }
+}
+
+// ─── Footprint Builder ───────────────────────────────────────────────────────
+
+/// Build a Footprint (Up/Down-Bin) Profile from a slice of ticks.
+///
+/// Algorithm (from main.tex Section IV, "Up/Down-Bin Footprint Profile"):
+///   1. Compute GMP group labels (same logic as build_gmp).
+///   2. For each consecutive pair, classify bins on the path as up or down.
+pub fn build_footprint(ticks: &[RawTick], beta: f64) -> FootprintProfile {
+    let mut bins: BTreeMap<i64, FootprintBin> = BTreeMap::new();
+
+    if ticks.is_empty() {
+        return FootprintProfile { bins, beta, min_bin: 0, max_bin: 0 };
+    }
+
+    // Phase 1 + 2 -- GMP placement (CMP + gap-fill) for the count field
+    for t in ticks {
+        let b = bin_index(t.price, beta);
+        bins.entry(b).or_default().count += 1;
+    }
+    for pair in ticks.windows(2) {
+        let b_from = bin_index(pair[0].price, beta);
+        let b_to   = bin_index(pair[1].price, beta);
+        if (b_to - b_from).abs() <= 1 { continue; }
+        let dir: i64 = if b_to > b_from { 1 } else { -1 };
+        let mut b = b_from + dir;
+        while b != b_to {
+            bins.entry(b).or_default().count += 1;
+            b += dir;
+        }
+    }
+
+    // Phase 3 -- Directional classification
+    for pair in ticks.windows(2) {
+        let src_price = pair[0].price;
+        let dst_price = pair[1].price;
+        let b_from = bin_index(src_price, beta);
+        let b_to   = bin_index(dst_price, beta);
+
+        if b_from == b_to {
+            // Same bin -- classify by micro price movement
+            let entry = bins.entry(b_from).or_default();
+            if dst_price > src_price {
+                entry.up += 1;
+            } else if dst_price < src_price {
+                entry.down += 1;
+            }
+            continue;
+        }
+
+        let is_up = b_to > b_from;
+        let dir: i64 = if is_up { 1 } else { -1 };
+
+        // Every bin on the path AFTER source (exclusive), up to and
+        // including destination, gets a directional count.
+        let mut b = b_from + dir;
+        loop {
+            let entry = bins.entry(b).or_default();
+            if is_up { entry.up += 1; } else { entry.down += 1; }
+            if b == b_to { break; }
+            b += dir;
+        }
+    }
+
+    let min_bin = *bins.keys().next().unwrap_or(&0);
+    let max_bin = *bins.keys().next_back().unwrap_or(&0);
+
+    FootprintProfile { bins, beta, min_bin, max_bin }
+}
+
+// ─── Interval Aggregator ─────────────────────────────────────────────────────
+
+/// A computed interval containing both profile types and metadata.
+#[derive(Clone, Debug)]
+pub struct IntervalProfile {
+    pub gmp:        GmpProfile,
+    pub footprint:  FootprintProfile,
+    /// Label for the x-axis (time string or trade range).
+    pub label:      String,
+    /// Midpoint price of this interval (for alignment).
+    pub mid_price:  f64,
+    /// Start index in the original tick buffer (for scrolling).
+    pub start_idx:  usize,
+}
+
+/// Aggregate ticks into time-based intervals and compute profiles.
+///
+/// `interval_secs` -- duration of each interval in seconds.
+pub fn aggregate_by_time(
+    ticks: &[RawTick],
+    interval_secs: u64,
+    beta: f64,
+) -> Vec<IntervalProfile> {
+    if ticks.is_empty() || interval_secs == 0 {
+        return Vec::new();
+    }
+
+    let mut profiles = Vec::new();
+    let mut start = 0usize;
+    let base_time = ticks[0].time;
+
+    while start < ticks.len() {
+        let bucket = ((ticks[start].time - base_time) as u64) / interval_secs;
+        let bucket_end_time = base_time + ((bucket + 1) * interval_secs) as i64;
+
+        // Find the end of this bucket
+        let mut end = start;
+        while end < ticks.len() && ticks[end].time < bucket_end_time {
+            end += 1;
+        }
+
+        let slice = &ticks[start..end];
+        if !slice.is_empty() {
+            let gmp = build_gmp(slice, beta);
+            let footprint = build_footprint(slice, beta);
+
+            // Label: time range
+            let t0 = slice.first().unwrap().time;
+            let t1 = slice.last().unwrap().time;
+            let label = format_time_range(t0, t1);
+
+            // Midpoint price
+            let sum: f64 = slice.iter().map(|t| t.price).sum();
+            let mid_price = sum / slice.len() as f64;
+
+            profiles.push(IntervalProfile {
+                gmp,
+                footprint,
+                label,
+                mid_price,
+                start_idx: start,
+            });
+        }
+
+        start = end;
+    }
+
+    profiles
+}
+
+/// Aggregate ticks into trade-count-based intervals and compute profiles.
+///
+/// `trade_interval` -- number of ticks per group.
+pub fn aggregate_by_trades(
+    ticks: &[RawTick],
+    trade_interval: usize,
+    beta: f64,
+) -> Vec<IntervalProfile> {
+    if ticks.is_empty() || trade_interval == 0 {
+        return Vec::new();
+    }
+
+    let mut profiles = Vec::new();
+
+    for (chunk_idx, chunk) in ticks.chunks(trade_interval).enumerate() {
+        let gmp = build_gmp(chunk, beta);
+        let footprint = build_footprint(chunk, beta);
+
+        let first_idx = chunk_idx * trade_interval;
+        let last_idx  = first_idx + chunk.len() - 1;
+        let label = format!("T{}-T{}", first_idx + 1, last_idx + 1);
+
+        let sum: f64 = chunk.iter().map(|t| t.price).sum();
+        let mid_price = sum / chunk.len() as f64;
+
+        profiles.push(IntervalProfile {
+            gmp,
+            footprint,
+            label,
+            mid_price,
+            start_idx: first_idx,
+        });
+    }
+
+    profiles
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+fn format_time_range(t0: i64, t1: i64) -> String {
+    let fmt = |t: i64| -> String {
+        let h = (t / 3600) % 24;
+        let m = (t / 60) % 60;
+        let s = t % 60;
+        format!("{:02}:{:02}:{:02}", h, m, s)
+    };
+    if t0 == t1 {
+        fmt(t0)
+    } else {
+        format!("{}-{}", fmt(t0), fmt(t1))
+    }
+}
+
+// ─── Tests (parity with generate_profiles.py) ────────────────────────────────
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// The exact 10 datapoints from generate_profiles.py.
+    fn reference_datapoints() -> Vec<RawTick> {
+        vec![
+            RawTick { price: 3000.914, time: 1, index: 0 },
+            RawTick { price: 3003.837, time: 2, index: 1 },
+            RawTick { price: 3002.432, time: 3, index: 2 },
+            RawTick { price: 3009.892, time: 4, index: 3 },
+            RawTick { price: 3007.698, time: 5, index: 4 },
+            RawTick { price: 3009.176, time: 6, index: 5 },
+            RawTick { price: 3003.381, time: 7, index: 6 },
+            RawTick { price: 3004.283, time: 8, index: 7 },
+            RawTick { price: 3003.512, time: 9, index: 8 },
+            RawTick { price: 3003.012, time: 10, index: 9 },
+        ]
+    }
+
+    #[test]
+    fn test_bin_index() {
+        // beta = 1: floor(3000.914 / 1) = 3000
+        assert_eq!(bin_index(3000.914, 1.0), 3000);
+        assert_eq!(bin_index(3003.837, 1.0), 3003);
+        assert_eq!(bin_index(3009.892, 1.0), 3009);
+    }
+
+    #[test]
+    fn test_gmp_parity_with_python() {
+        // From generate_profiles.py with beta=1, the GMP for the 10
+        // datapoints should produce stacks at bins 3000..=3009, and the
+        // total stack count should be 25 (10 CMP + 15 gap-fills).
+        let ticks = reference_datapoints();
+        let profile = build_gmp(&ticks, 1.0);
+
+        // All 10 bins from 3000 to 3009 should be populated
+        for b in 3000..=3009 {
+            assert!(
+                profile.bins.contains_key(&b),
+                "GMP missing bin {}",
+                b
+            );
+        }
+
+        // Total stacks = 25 (verified against Python output)
+        let total: u32 = profile.bins.values().map(|b| b.count).sum();
+        assert_eq!(total, 25, "GMP total stacks mismatch");
+    }
+
+    #[test]
+    fn test_footprint_parity_with_python() {
+        // The footprint for the same 10 datapoints should have up/down
+        // counts that match the Python build_updown_profile output.
+        let ticks = reference_datapoints();
+        let fp = build_footprint(&ticks, 1.0);
+
+        // All 10 bins should exist
+        for b in 3000..=3009 {
+            assert!(
+                fp.bins.contains_key(&b),
+                "Footprint missing bin {}",
+                b
+            );
+        }
+
+        // Total stacks should also be 25
+        let total: u32 = fp.bins.values().map(|b| b.count).sum();
+        assert_eq!(total, 25, "Footprint total stacks mismatch");
+
+        // The sum of (up + down) across all bins should be > 0
+        let total_up: u32 = fp.bins.values().map(|b| b.up).sum();
+        let total_down: u32 = fp.bins.values().map(|b| b.down).sum();
+        assert!(total_up > 0, "Expected some up counts");
+        assert!(total_down > 0, "Expected some down counts");
+    }
+
+    #[test]
+    fn test_aggregate_by_trades() {
+        let ticks = reference_datapoints();
+        // Group by 5 trades => 2 intervals
+        let intervals = aggregate_by_trades(&ticks, 5, 1.0);
+        assert_eq!(intervals.len(), 2);
+        assert_eq!(intervals[0].label, "T1-T5");
+        assert_eq!(intervals[1].label, "T6-T10");
+    }
+
+    #[test]
+    fn test_aggregate_by_time() {
+        let ticks = reference_datapoints();
+        // 5-second intervals, ticks at time 1..10 => 2 intervals
+        let intervals = aggregate_by_time(&ticks, 5, 1.0);
+        assert_eq!(intervals.len(), 2);
+    }
+}

gmp-terminal/src/main.rs

@@ -0,0 +1,46 @@
+// ============================================================================
+// main.rs -- GMP Trading Terminal Entry Point
+// ============================================================================
+// Bootstraps the Tokio async runtime, spawns ZMQ tasks, and launches
+// the eframe GUI.
+// ============================================================================
+
+mod app;
+mod gmp_engine;
+mod tab_time;
+mod tab_trade;
+mod timeframe;
+mod trading_panel;
+mod zmq_bridge;
+
+use egui;
+use tokio::sync::mpsc;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Tick data channel
+    let (tick_tx, tick_rx) = mpsc::channel(200);
+
+    // Order request / response channels
+    let (order_tx, order_rx) = mpsc::channel::<zmq_bridge::OrderRequest>(10);
+    let (resp_tx, resp_rx) = mpsc::channel::<zmq_bridge::OrderResponse>(10);
+
+    // Spawn ZMQ tasks
+    zmq_bridge::spawn_tick_subscriber(tick_tx);
+    zmq_bridge::spawn_order_handler(order_rx, resp_tx);
+
+    // Launch GUI
+    let options = eframe::NativeOptions {
+        viewport: egui::ViewportBuilder::default()
+            .with_inner_size([1100.0, 700.0])
+            .with_title("GMP Trading Terminal"),
+        ..Default::default()
+    };
+
+    eframe::run_native(
+        "GMP Trading Terminal",
+        options,
+        Box::new(|_cc| Box::new(app::GmpTerminalApp::new(tick_rx, order_tx, resp_rx))),
+    )
+    .map_err(|e| e.into())
+}

gmp-terminal/src/tab_time.rs

@@ -0,0 +1,207 @@
+// ============================================================================
+// tab_time.rs -- Time-Based Chart Tab
+// ============================================================================
+// Groups ticks by a custom time interval and renders GMP + Footprint
+// profiles as horizontal bar histograms along a time x-axis.
+// ============================================================================
+
+use crate::app::AppState;
+use crate::gmp_engine::{self, IntervalProfile};
+use crate::timeframe;
+use egui;
+use egui_plot::{self, Plot, PlotPoints, Line, PlotPoint, Text};
+
+/// Render the Time-Based tab UI and chart.
+pub fn render(ui: &mut egui::Ui, state: &mut AppState) {
+    // ── Interval Input ──
+    ui.horizontal(|ui| {
+        ui.label("Interval:");
+        let resp = ui.add(
+            egui::TextEdit::singleline(&mut state.time_input_str)
+                .desired_width(80.0)
+                .hint_text("e.g. 1:30, 4h30m"),
+        );
+        if resp.lost_focus() || resp.changed() {
+            match timeframe::parse_timeframe(&state.time_input_str) {
+                Ok(secs) => {
+                    state.time_interval_secs = secs;
+                    state.profiles_dirty = true;
+                    state.time_parse_err = None;
+                }
+                Err(e) => {
+                    state.time_parse_err = Some(e);
+                }
+            }
+        }
+        if state.time_interval_secs > 0 {
+            ui.label(format!(
+                "= {}",
+                timeframe::format_seconds(state.time_interval_secs)
+            ));
+        }
+        if let Some(ref e) = state.time_parse_err {
+            ui.colored_label(egui::Color32::from_rgb(255, 100, 100), e);
+        }
+    });
+
+    ui.separator();
+
+    // ── Recompute profiles if dirty ──
+    if state.profiles_dirty || state.time_profiles.is_empty() {
+        state.time_profiles = gmp_engine::aggregate_by_time(
+            &state.raw_ticks,
+            state.time_interval_secs,
+            state.bin_size,
+        );
+        state.profiles_dirty = false;
+    }
+
+    // ── Render Mode Toggle ──
+    ui.horizontal(|ui| {
+        ui.label("View:");
+        ui.selectable_value(&mut state.show_footprint, false, "GMP");
+        ui.selectable_value(&mut state.show_footprint, true, "Footprint");
+        ui.label(format!(
+            "| {} intervals | {} ticks",
+            state.time_profiles.len(),
+            state.raw_ticks.len()
+        ));
+    });
+
+    ui.separator();
+
+    // ── Chart ──
+    render_profile_chart(ui, &state.time_profiles, state.show_footprint, state.bin_size, "time_chart");
+}
+
+/// Render a series of interval profiles as a horizontal-bar chart.
+///
+/// Each interval occupies one column along the x-axis.
+/// Within each column, horizontal bars extend from the column center,
+/// with length proportional to the stack count.
+pub fn render_profile_chart(
+    ui: &mut egui::Ui,
+    profiles: &[IntervalProfile],
+    show_footprint: bool,
+    beta: f64,
+    plot_id: &str,
+) {
+    if profiles.is_empty() {
+        ui.label("No data to display");
+        return;
+    }
+
+    let plot = Plot::new(plot_id)
+        .legend(egui_plot::Legend::default())
+        .allow_boxed_zoom(true)
+        .allow_drag(true)
+        .allow_scroll(true)
+        .allow_zoom(true)
+        .y_axis_formatter(move |y, _range, _width| {
+            // Show price at bin boundaries
+            let bin = (y.value / beta).round() as i64;
+            format!("{:.2}", bin as f64 * beta)
+        });
+
+    plot.show(ui, |plot_ui| {
+        // Determine global min/max bin for y-axis range
+        let (global_min, global_max) = profiles.iter().fold(
+            (i64::MAX, i64::MIN),
+            |(gmin, gmax), p| {
+                let pmin = if show_footprint { p.footprint.min_bin } else { p.gmp.min_bin };
+                let pmax = if show_footprint { p.footprint.max_bin } else { p.gmp.max_bin };
+                (gmin.min(pmin), gmax.max(pmax))
+            },
+        );
+
+        // Find max count for normalization (bar width scaling)
+        let max_count = profiles.iter().flat_map(|p| {
+            if show_footprint {
+                p.footprint.bins.values().map(|b| b.count).collect::<Vec<_>>()
+            } else {
+                p.gmp.bins.values().map(|b| b.count).collect::<Vec<_>>()
+            }
+        }).max().unwrap_or(1).max(1) as f64;
+
+        // Column width in x-units
+        let col_width = 0.8;
+        let bar_scale = col_width / max_count;
+
+        for (col, profile) in profiles.iter().enumerate() {
+            let x_center = col as f64;
+
+            if show_footprint {
+                // Draw footprint bars: green (up) going right, red (down) going left
+                for (&bin_idx, bin) in &profile.footprint.bins {
+                    let y = bin_idx as f64 * beta + beta * 0.5; // mid-bin price
+
+                    if bin.up > 0 {
+                        let w = bin.up as f64 * bar_scale;
+                        let points = PlotPoints::new(vec![
+                            [x_center, y],
+                            [x_center + w, y],
+                        ]);
+                        plot_ui.line(
+                            Line::new(points)
+                                .color(egui::Color32::from_rgb(50, 200, 100))
+                                .width(2.0),
+                        );
+                    }
+                    if bin.down > 0 {
+                        let w = bin.down as f64 * bar_scale;
+                        let points = PlotPoints::new(vec![
+                            [x_center, y],
+                            [x_center - w, y],
+                        ]);
+                        plot_ui.line(
+                            Line::new(points)
+                                .color(egui::Color32::from_rgb(255, 80, 80))
+                                .width(2.0),
+                        );
+                    }
+
+                    // Delta annotation
+                    let delta = bin.delta();
+                    if delta != 0 {
+                        let label = if delta > 0 {
+                            format!("+{}", delta)
+                        } else {
+                            format!("{}", delta)
+                        };
+                        plot_ui.text(
+                            Text::new(PlotPoint::new(x_center + col_width * 0.5, y), label)
+                                .color(if delta > 0 {
+                                    egui::Color32::from_rgb(50, 200, 100)
+                                } else {
+                                    egui::Color32::from_rgb(255, 80, 80)
+                                }),
+                        );
+                    }
+                }
+            } else {
+                // Draw GMP bars: single color going right from center
+                for (&bin_idx, bin) in &profile.gmp.bins {
+                    let y = bin_idx as f64 * beta + beta * 0.5;
+                    let w = bin.count as f64 * bar_scale;
+
+                    let points = PlotPoints::new(vec![
+                        [x_center - w * 0.5, y],
+                        [x_center + w * 0.5, y],
+                    ]);
+                    plot_ui.line(
+                        Line::new(points)
+                            .color(egui::Color32::from_rgb(100, 150, 255))
+                            .width(2.5),
+                    );
+                }
+            }
+
+            // Column separator
+            plot_ui.vline(
+                egui_plot::VLine::new(x_center - 0.5)
+                    .color(egui::Color32::from_rgba_premultiplied(100, 100, 100, 40))
+                    .width(0.5),
+            );
+        }
+    });
+}

gmp-terminal/src/tab_trade.rs

@@ -0,0 +1,68 @@
+// ============================================================================
+// tab_trade.rs -- Trade-Based Chart Tab
+// ============================================================================
+// Groups ticks by trade count and renders GMP + Footprint profiles.
+// X-axis = trade group index. Reuses the chart renderer from tab_time.
+// ============================================================================
+
+use crate::app::AppState;
+use crate::gmp_engine;
+use crate::tab_time;
+use egui;
+
+/// Render the Trade-Based tab UI and chart.
+pub fn render(ui: &mut egui::Ui, state: &mut AppState) {
+    // ── Interval Input ──
+    ui.horizontal(|ui| {
+        ui.label("Trades per group:");
+        let resp = ui.add(
+            egui::TextEdit::singleline(&mut state.trade_input_str)
+                .desired_width(60.0)
+                .hint_text("e.g. 50"),
+        );
+        if resp.lost_focus() || resp.changed() {
+            if let Ok(n) = state.trade_input_str.parse::<usize>() {
+                if n > 0 {
+                    state.trade_interval = n;
+                    state.profiles_dirty_trade = true;
+                }
+            }
+        }
+        ui.label(format!("= {} trades/group", state.trade_interval));
+    });
+
+    ui.separator();
+
+    // ── Recompute profiles if dirty ──
+    if state.profiles_dirty_trade || state.trade_profiles.is_empty() {
+        state.trade_profiles = gmp_engine::aggregate_by_trades(
+            &state.raw_ticks,
+            state.trade_interval,
+            state.bin_size,
+        );
+        state.profiles_dirty_trade = false;
+    }
+
+    // ── Render Mode Toggle ──
+    ui.horizontal(|ui| {
+        ui.label("View:");
+        ui.selectable_value(&mut state.show_footprint_trade, false, "GMP");
+        ui.selectable_value(&mut state.show_footprint_trade, true, "Footprint");
+        ui.label(format!(
+            "| {} groups | {} ticks",
+            state.trade_profiles.len(),
+            state.raw_ticks.len()
+        ));
+    });
+
+    ui.separator();
+
+    // ── Chart (reuse the renderer from tab_time) ──
+    tab_time::render_profile_chart(
+        ui,
+        &state.trade_profiles,
+        state.show_footprint_trade,
+        state.bin_size,
+        "trade_chart",
+    );
+}

gmp-terminal/src/timeframe.rs

@@ -0,0 +1,150 @@
+// ============================================================================
+// timeframe.rs -- Custom Timeframe String Parser
+// ============================================================================
+// Parses human-readable timeframe strings into seconds.
+//   "1:30"   -> 90s
+//   "4h30m"  -> 16200s
+//   "2m"     -> 120s
+//   "45s"    -> 45s
+//   "90"     -> 90s (plain number = seconds)
+// ============================================================================
+
+/// Parse a timeframe string into total seconds.
+///
+/// Supported formats:
+///   - `"MM:SS"` or `"HH:MM:SS"` (colon-separated)
+///   - `"4h30m10s"` (unit suffixes: h, m, s)
+///   - `"90"` (plain integer = seconds)
+pub fn parse_timeframe(input: &str) -> Result<u64, String> {
+    let s = input.trim();
+    if s.is_empty() {
+        return Err("Empty timeframe string".to_string());
+    }
+
+    // Colon format: "MM:SS" or "HH:MM:SS"
+    if s.contains(':') {
+        return parse_colon_format(s);
+    }
+
+    // Unit-suffix format: "4h30m10s", "2m", "45s"
+    if s.chars().any(|c| matches!(c, 'h' | 'm' | 's')) {
+        return parse_unit_format(s);
+    }
+
+    // Plain number: treat as seconds
+    s.parse::<u64>()
+        .map_err(|_| format!("Invalid timeframe: '{}'", s))
+}
+
+fn parse_colon_format(s: &str) -> Result<u64, String> {
+    let parts: Vec<&str> = s.split(':').collect();
+    match parts.len() {
+        2 => {
+            // MM:SS
+            let mm: u64 = parts[0].parse().map_err(|_| format!("Invalid minutes: '{}'", parts[0]))?;
+            let ss: u64 = parts[1].parse().map_err(|_| format!("Invalid seconds: '{}'", parts[1]))?;
+            Ok(mm * 60 + ss)
+        }
+        3 => {
+            // HH:MM:SS
+            let hh: u64 = parts[0].parse().map_err(|_| format!("Invalid hours: '{}'", parts[0]))?;
+            let mm: u64 = parts[1].parse().map_err(|_| format!("Invalid minutes: '{}'", parts[1]))?;
+            let ss: u64 = parts[2].parse().map_err(|_| format!("Invalid seconds: '{}'", parts[2]))?;
+            Ok(hh * 3600 + mm * 60 + ss)
+        }
+        _ => Err(format!("Invalid colon format: '{}'", s)),
+    }
+}
+
+fn parse_unit_format(s: &str) -> Result<u64, String> {
+    let mut total: u64 = 0;
+    let mut current_num = String::new();
+
+    for ch in s.chars() {
+        if ch.is_ascii_digit() {
+            current_num.push(ch);
+        } else {
+            let n: u64 = if current_num.is_empty() {
+                return Err(format!("Missing number before '{}' in '{}'", ch, s));
+            } else {
+                current_num.parse().map_err(|_| format!("Invalid number in '{}'", s))?
+            };
+            current_num.clear();
+
+            match ch {
+                'h' | 'H' => total += n * 3600,
+                'm' | 'M' => total += n * 60,
+                's' | 'S' => total += n,
+                _ => return Err(format!("Unknown unit '{}' in '{}'", ch, s)),
+            }
+        }
+    }
+
+    // If there are trailing digits with no unit, treat as seconds
+    if !current_num.is_empty() {
+        let n: u64 = current_num.parse().map_err(|_| format!("Invalid number in '{}'", s))?;
+        total += n;
+    }
+
+    if total == 0 {
+        return Err(format!("Timeframe resolves to 0 seconds: '{}'", s));
+    }
+
+    Ok(total)
+}
+
+/// Format seconds back into a human-readable string for display.
+pub fn format_seconds(secs: u64) -> String {
+    if secs == 0 {
+        return "0s".to_string();
+    }
+    let h = secs / 3600;
+    let m = (secs % 3600) / 60;
+    let s = secs % 60;
+
+    let mut out = String::new();
+    if h > 0 { out.push_str(&format!("{}h", h)); }
+    if m > 0 { out.push_str(&format!("{}m", m)); }
+    if s > 0 { out.push_str(&format!("{}s", s)); }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_colon_mm_ss() {
+        assert_eq!(parse_timeframe("1:30").unwrap(), 90);
+        assert_eq!(parse_timeframe("0:45").unwrap(), 45);
+        assert_eq!(parse_timeframe("10:00").unwrap(), 600);
+    }
+
+    #[test]
+    fn test_colon_hh_mm_ss() {
+        assert_eq!(parse_timeframe("1:00:00").unwrap(), 3600);
+        assert_eq!(parse_timeframe("4:30:00").unwrap(), 16200);
+    }
+
+    #[test]
+    fn test_unit_format() {
+        assert_eq!(parse_timeframe("4h30m").unwrap(), 16200);
+        assert_eq!(parse_timeframe("2m").unwrap(), 120);
+        assert_eq!(parse_timeframe("45s").unwrap(), 45);
+        assert_eq!(parse_timeframe("1h2m3s").unwrap(), 3723);
+    }
+
+    #[test]
+    fn test_plain_number() {
+        assert_eq!(parse_timeframe("90").unwrap(), 90);
+        assert_eq!(parse_timeframe("3600").unwrap(), 3600);
+    }
+
+    #[test]
+    fn test_format_seconds() {
+        assert_eq!(format_seconds(90), "1m30s");
+        assert_eq!(format_seconds(16200), "4h30m");
+        assert_eq!(format_seconds(3600), "1h");
+        assert_eq!(format_seconds(45), "45s");
+    }
+}

gmp-terminal/src/trading_panel.rs

@@ -0,0 +1,340 @@
+// ============================================================================
+// trading_panel.rs -- Trading Controls Side Panel
+// ============================================================================
+// Shared left-panel UI for both Time-Based and Trade-Based tabs.
+// Contains account info, order controls, position management, history
+// download, live recording, and bin-size configuration.
+// ============================================================================
+
+use crate::app::AppState;
+use crate::zmq_bridge::OrderRequest;
+use egui;
+use std::fs::OpenOptions;
+use std::io::Write;
+
+// ─── Trading Panel Rendering ─────────────────────────────────────────────────
+
+pub fn render_trading_panel(ui: &mut egui::Ui, state: &mut AppState) {
+    ui.heading("Trading Panel");
+    ui.separator();
+
+    // ── Account Info ──
+    ui.collapsing("Account Info", |ui| {
+        egui::Grid::new("account_grid")
+            .num_columns(2)
+            .spacing([10.0, 4.0])
+            .show(ui, |ui| {
+                ui.label("Balance:");
+                ui.colored_label(
+                    egui::Color32::from_rgb(100, 200, 100),
+                    format!("${:.2}", state.balance),
+                );
+                ui.end_row();
+                ui.label("Equity:");
+                ui.colored_label(
+                    egui::Color32::from_rgb(100, 180, 255),
+                    format!("${:.2}", state.equity),
+                );
+                ui.end_row();
+                ui.label("Margin:");
+                ui.colored_label(
+                    egui::Color32::from_rgb(255, 200, 100),
+                    format!("${:.2}", state.margin),
+                );
+                ui.end_row();
+                ui.label("Free Margin:");
+                ui.colored_label(
+                    egui::Color32::from_rgb(100, 255, 200),
+                    format!("${:.2}", state.free_margin),
+                );
+                ui.end_row();
+            });
+    });
+
+    ui.separator();
+
+    // ── Chart Settings ──
+    ui.heading("Chart Settings");
+    ui.horizontal(|ui| {
+        ui.label("Bin Size:");
+        let resp = ui.add(
+            egui::TextEdit::singleline(&mut state.bin_size_str).desired_width(60.0),
+        );
+        if resp.lost_focus() {
+            if let Ok(v) = state.bin_size_str.parse::<f64>() {
+                if v > 0.0 {
+                    state.bin_size = v;
+                    state.profiles_dirty = true;
+                }
+            }
+            state.bin_size_str = format!("{}", state.bin_size);
+        }
+    });
+
+    ui.separator();
+
+    // ── History Download ──
+    ui.heading("Historical Data");
+    ui.add_space(3.0);
+    egui::Grid::new("history_grid")
+        .num_columns(2)
+        .spacing([10.0, 4.0])
+        .show(ui, |ui| {
+            ui.label("Start:");
+            ui.add(
+                egui::TextEdit::singleline(&mut state.history_start).desired_width(100.0),
+            );
+            ui.end_row();
+            ui.label("End:");
+            ui.add(
+                egui::TextEdit::singleline(&mut state.history_end).desired_width(100.0),
+            );
+            ui.end_row();
+            ui.label("Timeframe:");
+            egui::ComboBox::from_id_source("dl_tf")
+                .selected_text(&state.history_tf)
+                .show_ui(ui, |ui| {
+                    for tf in &["M1", "M5", "M15", "H1", "H4", "D1"] {
+                        ui.selectable_value(&mut state.history_tf, tf.to_string(), *tf);
+                    }
+                });
+            ui.end_row();
+            ui.label("Mode:");
+            egui::ComboBox::from_id_source("dl_mode")
+                .selected_text(&state.history_mode)
+                .show_ui(ui, |ui| {
+                    ui.selectable_value(&mut state.history_mode, "OHLC".to_string(), "OHLC");
+                    ui.selectable_value(&mut state.history_mode, "TICKS".to_string(), "TICKS");
+                });
+            ui.end_row();
+        });
+
+    ui.add_space(3.0);
+    if ui.button("Download History (CSV)").clicked() {
+        send_download_request(state);
+    }
+
+    ui.separator();
+
+    // ── Live Recording ──
+    ui.heading("Live Recording");
+    ui.horizontal(|ui| {
+        ui.label(if state.is_recording { "REC" } else { "Idle" });
+        if ui
+            .button(if state.is_recording { "Stop" } else { "Start" })
+            .clicked()
+        {
+            toggle_recording(state);
+        }
+    });
+
+    ui.separator();
+
+    // ── Trade Controls ──
+    ui.heading("Trade Controls");
+
+    // Lot size
+    ui.horizontal(|ui| {
+        if ui.button("-").clicked() {
+            adjust_lot(state, -state.lot_step);
+        }
+        let resp = ui.add(
+            egui::TextEdit::singleline(&mut state.lot_size_str).desired_width(60.0),
+        );
+        if resp.lost_focus() {
+            if let Ok(v) = state.lot_size_str.parse::<f64>() {
+                state.lot_size = v.max(state.min_lot).min(state.max_lot);
+                state.lot_size_str = format!("{:.2}", state.lot_size);
+            }
+        }
+        if ui.button("+").clicked() {
+            adjust_lot(state, state.lot_step);
+        }
+        ui.label(format!("Lots (max {:.1})", state.max_lot));
+    });
+
+    ui.add_space(3.0);
+    ui.label("Market Orders:");
+    ui.horizontal(|ui| {
+        if ui.button("BUY").clicked() {
+            send_order(state, "market_buy", None, None);
+        }
+        if ui.button("SELL").clicked() {
+            send_order(state, "market_sell", None, None);
+        }
+    });
+
+    ui.add_space(3.0);
+    ui.label("Pending Orders:");
+    ui.horizontal(|ui| {
+        ui.label("@ Price:");
+        ui.add(
+            egui::TextEdit::singleline(&mut state.limit_price_str).desired_width(70.0),
+        );
+    });
+    ui.horizontal(|ui| {
+        let p: f64 = state.limit_price_str.parse().unwrap_or(0.0);
+        if ui.small_button("Buy Lmt").clicked() {
+            send_order(state, "limit_buy", Some(p), None);
+        }
+        if ui.small_button("Sell Lmt").clicked() {
+            send_order(state, "limit_sell", Some(p), None);
+        }
+        if ui.small_button("Buy Stp").clicked() {
+            send_order(state, "stop_buy", Some(p), None);
+        }
+        if ui.small_button("Sell Stp").clicked() {
+            send_order(state, "stop_sell", Some(p), None);
+        }
+    });
+
+    ui.separator();
+
+    // ── Status ──
+    if let Some(ref msg) = state.last_status {
+        ui.heading("Status");
+        ui.label(msg);
+    }
+
+    ui.separator();
+
+    // ── Active Positions ──
+    ui.collapsing("Active Positions", |ui| {
+        if state.positions.is_empty() {
+            ui.label("No active positions");
+        } else {
+            let positions = state.positions.clone();
+            for pos in positions {
+                ui.horizontal(|ui| {
+                    let color = if pos.pos_type == "BUY" {
+                        egui::Color32::from_rgb(100, 200, 100)
+                    } else {
+                        egui::Color32::from_rgb(255, 100, 100)
+                    };
+                    ui.colored_label(
+                        color,
+                        format!(
+                            "#{} {} {:.2}@{:.5} P:{:.2}",
+                            pos.ticket, pos.pos_type, pos.volume, pos.price, pos.profit
+                        ),
+                    );
+                    if ui.small_button("Close").clicked() {
+                        send_order(state, "close_position", Some(pos.price), Some(pos.ticket));
+                    }
+                });
+            }
+        }
+    });
+
+    // ── Pending Orders ──
+    ui.collapsing("Pending Orders", |ui| {
+        if state.pending_orders.is_empty() {
+            ui.label("No pending orders");
+        } else {
+            let orders = state.pending_orders.clone();
+            for ord in orders {
+                ui.horizontal(|ui| {
+                    let color = if ord.order_type.contains("BUY") {
+                        egui::Color32::from_rgb(100, 150, 255)
+                    } else {
+                        egui::Color32::from_rgb(255, 150, 100)
+                    };
+                    ui.colored_label(
+                        color,
+                        format!(
+                            "#{} {} {:.2}@{:.5}",
+                            ord.ticket, ord.order_type, ord.volume, ord.price
+                        ),
+                    );
+                    if ui.small_button("Cancel").clicked() {
+                        send_order(state, "cancel_order", Some(ord.price), Some(ord.ticket));
+                    }
+                });
+            }
+        }
+    });
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+fn adjust_lot(state: &mut AppState, delta: f64) {
+    let new = state.lot_size + delta;
+    let steps = (new / state.lot_step).round();
+    state.lot_size = (steps * state.lot_step).max(state.min_lot).min(state.max_lot);
+    state.lot_size_str = format!("{:.2}", state.lot_size);
+}
+
+fn send_order(state: &mut AppState, order_type: &str, price: Option<f64>, ticket: Option<u64>) {
+    let req = OrderRequest {
+        order_type: order_type.to_string(),
+        symbol:     state.symbol.clone(),
+        volume:     state.lot_size,
+        price:      price.unwrap_or(0.0),
+        ticket:     ticket.unwrap_or(0),
+        timeframe:  None,
+        start:      None,
+        end:        None,
+        mode:       None,
+        request_id: None,
+    };
+    if let Err(e) = state.order_tx.try_send(req) {
+        state.last_status = Some(format!("Send error: {}", e));
+    } else {
+        state.last_status = Some("Order sent...".to_string());
+    }
+}
+
+fn send_download_request(state: &mut AppState) {
+    state.request_counter += 1;
+    state.pending_history = Some((
+        state.request_counter,
+        state.symbol.replace("/", "-"),
+        state.history_tf.clone(),
+        state.history_mode.clone(),
+    ));
+    let req = OrderRequest {
+        order_type: "download_history".to_string(),
+        symbol:     state.symbol.clone(),
+        volume:     0.0,
+        price:      0.0,
+        ticket:     0,
+        timeframe:  Some(state.history_tf.clone()),
+        start:      Some(state.history_start.clone()),
+        end:        Some(state.history_end.clone()),
+        mode:       Some(state.history_mode.clone()),
+        request_id: Some(state.request_counter),
+    };
+    if let Err(e) = state.order_tx.try_send(req) {
+        state.last_status = Some(format!("Send error: {}", e));
+    } else {
+        state.last_status = Some("Download request sent...".to_string());
+    }
+}
+
+fn toggle_recording(state: &mut AppState) {
+    state.is_recording = !state.is_recording;
+    if state.is_recording {
+        state.request_counter += 1;
+        let filename = format!(
+            "{}/Live_{}_ID{:04}_{}.csv",
+            state.output_dir.display(),
+            state.symbol.replace("/", "-"),
+            state.request_counter,
+            chrono::Local::now().format("%Y%m%d_%H%M%S"),
+        );
+        match OpenOptions::new().create(true).append(true).open(&filename) {
+            Ok(mut file) => {
+                let _ = writeln!(file, "Time,Bid,Ask,Volume");
+                state.live_record_file = Some(file);
+                state.last_status = Some(format!("Recording to {}", filename));
+            }
+            Err(e) => {
+                state.is_recording = false;
+                state.last_status = Some(format!("Record error: {}", e));
+            }
+        }
+    } else {
+        state.live_record_file = None;
+        state.last_status = Some("Recording stopped".to_string());
+    }
+}

gmp-terminal/src/zmq_bridge.rs

@@ -0,0 +1,207 @@
+// ============================================================================
+// zmq_bridge.rs -- ZeroMQ Integration Layer
+// ============================================================================
+// Reuses the proven SUB/REQ patterns from SUM3API/Rustmt5-chart.
+// Provides two spawnable async tasks:
+//   1. Tick subscriber  (PUB/SUB on port 5555)
+//   2. Order handler    (REQ/REP on port 5556)
+// ============================================================================
+
+use serde::{Deserialize, Serialize};
+use tokio::sync::mpsc;
+use zeromq::{Socket, SocketRecv, SocketSend};
+
+// ─── Data Structures ─────────────────────────────────────────────────────────
+
+#[derive(Clone, Debug, Deserialize)]
+pub struct PositionData {
+    pub ticket:   u64,
+    #[serde(rename = "type")]
+    pub pos_type: String,
+    pub volume:   f64,
+    pub price:    f64,
+    pub profit:   f64,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+pub struct PendingOrderData {
+    pub ticket:     u64,
+    #[serde(rename = "type")]
+    pub order_type: String,
+    pub volume:     f64,
+    pub price:      f64,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+pub struct TickData {
+    pub symbol: String,
+    pub bid:    f64,
+    pub ask:    f64,
+    pub time:   i64,
+    #[serde(default)]
+    pub volume: u64,
+    // Account info
+    #[serde(default)]
+    pub balance:     f64,
+    #[serde(default)]
+    pub equity:      f64,
+    #[serde(default)]
+    pub margin:      f64,
+    #[serde(default)]
+    pub free_margin: f64,
+    // Trading constraints
+    #[serde(default)]
+    pub min_lot:  f64,
+    #[serde(default)]
+    pub max_lot:  f64,
+    #[serde(default)]
+    pub lot_step: f64,
+    // Active trades
+    #[serde(default)]
+    pub positions: Vec<PositionData>,
+    #[serde(default)]
+    pub orders:    Vec<PendingOrderData>,
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct OrderRequest {
+    #[serde(rename = "type")]
+    pub order_type: String,
+    pub symbol:     String,
+    pub volume:     f64,
+    pub price:      f64,
+    #[serde(default)]
+    pub ticket:     u64,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub timeframe:  Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub start:      Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub end:        Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mode:       Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub request_id: Option<u64>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+pub struct OrderResponse {
+    pub success: bool,
+    pub ticket:  Option<i64>,
+    pub error:   Option<String>,
+    pub message: Option<String>,
+}
+
+// ─── Tick Subscriber Task ────────────────────────────────────────────────────
+
+pub fn spawn_tick_subscriber(tx: mpsc::Sender<TickData>) {
+    tokio::spawn(async move {
+        let mut socket = zeromq::SubSocket::new();
+        match socket.connect("tcp://127.0.0.1:5555").await {
+            Ok(_) => println!("[ZMQ] Connected to Tick Publisher on port 5555"),
+            Err(e) => {
+                eprintln!("[ZMQ] Failed to connect to tick publisher: {}", e);
+                return;
+            }
+        }
+
+        let _ = socket.subscribe("").await;
+
+        loop {
+            match socket.recv().await {
+                Ok(msg) => {
+                    if let Some(bytes) = msg.get(0) {
+                        if let Ok(json_str) = std::str::from_utf8(bytes) {
+                            match serde_json::from_str::<TickData>(json_str) {
+                                Ok(tick) => {
+                                    if let Err(e) = tx.send(tick).await {
+                                        eprintln!("[ZMQ] Tick channel closed: {}", e);
+                                        break;
+                                    }
+                                }
+                                Err(e) => {
+                                    eprintln!("[ZMQ] Tick JSON parse error: {}", e);
+                                }
+                            }
+                        }
+                    }
+                }
+                Err(e) => {
+                    eprintln!("[ZMQ] Tick recv error: {}", e);
+                    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+                }
+            }
+        }
+    });
+}
+
+// ─── Order Handler Task ──────────────────────────────────────────────────────
+
+pub fn spawn_order_handler(
+    mut rx: mpsc::Receiver<OrderRequest>,
+    tx: mpsc::Sender<OrderResponse>,
+) {
+    tokio::spawn(async move {
+        let mut socket = zeromq::ReqSocket::new();
+        match socket.connect("tcp://127.0.0.1:5556").await {
+            Ok(_) => println!("[ZMQ] Connected to Order Handler on port 5556"),
+            Err(e) => {
+                eprintln!("[ZMQ] Failed to connect to order handler: {}", e);
+                return;
+            }
+        }
+
+        while let Some(order) = rx.recv().await {
+            let json_req = match serde_json::to_string(&order) {
+                Ok(j) => j,
+                Err(e) => {
+                    eprintln!("[ZMQ] Serialize error: {}", e);
+                    continue;
+                }
+            };
+
+            println!("[ZMQ] Sending: {}", json_req);
+
+            if let Err(e) = socket.send(json_req.into()).await {
+                eprintln!("[ZMQ] Send error: {}", e);
+                let _ = tx.send(OrderResponse {
+                    success: false,
+                    ticket: None,
+                    error: Some(format!("Send failed: {}", e)),
+                    message: None,
+                }).await;
+                continue;
+            }
+
+            match socket.recv().await {
+                Ok(msg) => {
+                    if let Some(bytes) = msg.get(0) {
+                        if let Ok(json_str) = std::str::from_utf8(bytes) {
+                            println!("[ZMQ] Response: {}", json_str);
+                            match serde_json::from_str::<OrderResponse>(json_str) {
+                                Ok(resp) => { let _ = tx.send(resp).await; }
+                                Err(e) => {
+                                    let _ = tx.send(OrderResponse {
+                                        success: false,
+                                        ticket: None,
+                                        error: Some(format!("Parse error: {}", e)),
+                                        message: None,
+                                    }).await;
+                                }
+                            }
+                        }
+                    }
+                }
+                Err(e) => {
+                    eprintln!("[ZMQ] Response recv error: {}", e);
+                    let _ = tx.send(OrderResponse {
+                        success: false,
+                        ticket: None,
+                        error: Some(format!("Recv failed: {}", e)),
+                        message: None,
+                    }).await;
+                }
+            }
+        }
+    });
+}

mBA-GMP.v3/generate_profiles.py

@@ -0,0 +1,620 @@
+#!/usr/bin/env python3
+"""
+generate_profiles.py — mBA-GMP.v3 Dataframe & Chart Generator
+==============================================================
+Produces CSV files and publication-quality PNG charts demonstrating the
+Conventional Market Profile (CMP), Gap-filled Market Profile (GMP),
+and Up/Down-Bin Footprint Profile using a 10-datapoint XAUUSD example.
+
+Outputs:
+  CSV:  datapoints.csv, cmp_profile.csv, gmp_profile.csv,
+        updown_profile.csv
+  PNG:  fig_price_scatter.png, fig_cmp_profile.png,
+        fig_gmp_profile.png, fig_cmp_vs_gmp.png,
+        fig_updown_footprint.png
+"""
+
+import math
+import csv
+import os
+
+# ── Try to import optional plotting libs ─────────────────────────────────────
+try:
+    import matplotlib
+    matplotlib.use("Agg")  # non-interactive backend
+    import matplotlib.pyplot as plt
+    import matplotlib.ticker as ticker
+    HAS_MPL = True
+except ImportError:
+    HAS_MPL = False
+    print("[WARN] matplotlib not found – CSV files will still be generated "
+          "but PNG charts will be skipped.")
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  1. RAW DATAPOINTS
+# ══════════════════════════════════════════════════════════════════════════════
+
+DATAPOINTS = [
+    ("A",  1, 3000.914),
+    ("B",  2, 3003.837),
+    ("C",  3, 3002.432),
+    ("D",  4, 3009.892),
+    ("E",  5, 3007.698),
+    ("F",  6, 3009.176),
+    ("G",  7, 3003.381),
+    ("H",  8, 3004.283),
+    ("I",  9, 3003.512),
+    ("J", 10, 3003.012),
+]
+
+BIN_SIZE = 1  # β = 1 symbol price unit
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  2. HELPER FUNCTIONS
+# ══════════════════════════════════════════════════════════════════════════════
+
+def bin_index(price: float, beta: float = BIN_SIZE) -> int:
+    """Return the bin index for a given price: floor(price / β)."""
+    return int(math.floor(price / beta))
+
+
+def bin_range(price: float, beta: float = BIN_SIZE):
+    """Return (price_from, price_until) for the bin containing *price*."""
+    b = bin_index(price, beta)
+    return b * beta, (b + 1) * beta
+
+
+def make_bin_key(b: int, beta: float = BIN_SIZE):
+    """Return (bin_number_1based, price_from, price_until) for bin index *b*."""
+    return (b * beta, (b + 1) * beta)
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  3. CMP CONSTRUCTION
+# ══════════════════════════════════════════════════════════════════════════════
+
+def build_cmp(datapoints, beta=BIN_SIZE):
+    """
+    Build CMP profile.
+    Returns dict: bin_index -> {"labels": [str], "count": int}
+    """
+    profile = {}
+    for label, _trade, price in datapoints:
+        b = bin_index(price, beta)
+        if b not in profile:
+            profile[b] = {"labels": [], "count": 0}
+        profile[b]["labels"].append(label)
+        profile[b]["count"] += 1
+    return profile
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  4. GMP CONSTRUCTION
+# ══════════════════════════════════════════════════════════════════════════════
+
+def build_gmp(datapoints, beta=BIN_SIZE):
+    """
+    Build GMP profile (gap-filled).
+
+    Convention (matches the dataframe approach):
+      1. Every datapoint fills its OWN bin with its own label (same as CMP).
+      2. For each consecutive pair (i, i+1), the intermediate bins BETWEEN
+         b(p_i) and b(p_{i+1}) — exclusive of both endpoints — are filled
+         with the SOURCE datapoint's label (datapoint i).
+
+    Returns dict: bin_index -> {"labels": [str], "count": int}
+    """
+    profile = {}
+
+    def add_to_bin(b, label):
+        if b not in profile:
+            profile[b] = {"labels": [], "count": 0}
+        profile[b]["labels"].append(label)
+        profile[b]["count"] += 1
+
+    # ── Step 1: CMP-style placement — each datapoint fills its own bin ──
+    for label, _trade, price in datapoints:
+        add_to_bin(bin_index(price, beta), label)
+
+    # ── Step 2: Gap-fill intermediate bins between consecutive pairs ─────
+    for idx in range(len(datapoints) - 1):
+        src_label, _, src_price = datapoints[idx]
+        _dst_label, _, dst_price = datapoints[idx + 1]
+
+        b_from = bin_index(src_price, beta)
+        b_to   = bin_index(dst_price, beta)
+
+        if abs(b_to - b_from) <= 1:
+            # Adjacent or same bin — no intermediate bins to fill
+            continue
+
+        direction = 1 if b_to > b_from else -1
+        # Fill bins strictly BETWEEN b_from and b_to (exclusive of both)
+        b = b_from + direction
+        while b != b_to:
+            add_to_bin(b, src_label)
+            b += direction
+
+    return profile
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  4b. UP/DOWN-BIN FOOTPRINT PROFILE CONSTRUCTION
+# ══════════════════════════════════════════════════════════════════════════════
+
+def build_updown_profile(datapoints, beta=BIN_SIZE):
+    """
+    Build the Up/Down-Bin Footprint Profile.
+
+    For each consecutive pair of datapoints, every bin on the gap-filled
+    path (excluding the source datapoint's own bin) is classified as an
+    up-bin or down-bin depending on the direction of the move.
+
+    The first datapoint (no prior movement) receives 0 up / 0 down.
+
+    Returns dict: bin_index -> {"labels": [str], "up": int, "down": int}
+    """
+    # ── Collect GMP group labels (reuse from GMP logic) ──────────────────
+    groups = {}  # bin_index -> list of labels
+
+    def add_label(b, label):
+        if b not in groups:
+            groups[b] = []
+        groups[b].append(label)
+
+    # CMP placement
+    for label, _trade, price in datapoints:
+        add_label(bin_index(price, beta), label)
+
+    # Gap-fill intermediate labels
+    for idx in range(len(datapoints) - 1):
+        src_label, _, src_price = datapoints[idx]
+        _, _, dst_price = datapoints[idx + 1]
+        b_from = bin_index(src_price, beta)
+        b_to   = bin_index(dst_price, beta)
+        if abs(b_to - b_from) <= 1:
+            continue
+        direction = 1 if b_to > b_from else -1
+        b = b_from + direction
+        while b != b_to:
+            add_label(b, src_label)
+            b += direction
+
+    # ── Now compute up/down counts per bin ────────────────────────────────
+    up_counts   = {}  # bin_index -> int
+    down_counts = {}  # bin_index -> int
+
+    for idx in range(len(datapoints) - 1):
+        _, _, src_price = datapoints[idx]
+        _, _, dst_price = datapoints[idx + 1]
+
+        b_from = bin_index(src_price, beta)
+        b_to   = bin_index(dst_price, beta)
+
+        if b_from == b_to:
+            # Same bin, but price might have moved
+            if dst_price > src_price:
+                up_counts[b_from] = up_counts.get(b_from, 0) + 1
+            elif dst_price < src_price:
+                down_counts[b_from] = down_counts.get(b_from, 0) + 1
+            continue
+
+        is_up = b_to > b_from
+        direction = 1 if is_up else -1
+
+        # Every bin on the path AFTER the source bin (exclusive of source,
+        # inclusive of destination) gets a directional count.
+        b = b_from + direction
+        while True:
+            if is_up:
+                up_counts[b] = up_counts.get(b, 0) + 1
+            else:
+                down_counts[b] = down_counts.get(b, 0) + 1
+            if b == b_to:
+                break
+            b += direction
+
+    # ── Merge into result dict ───────────────────────────────────────────
+    all_bins = set(groups.keys()) | set(up_counts.keys()) | set(down_counts.keys())
+    profile = {}
+    for b in all_bins:
+        profile[b] = {
+            "labels": sorted(groups.get(b, [])),
+            "up":     up_counts.get(b, 0),
+            "down":   down_counts.get(b, 0),
+        }
+    return profile
+
+# ══════════════════════════════════════════════════════════════���═══════════════
+#  5. CSV OUTPUT
+# ══════════════════════════════════════════════════════════════════════════════
+
+def write_datapoints_csv(datapoints, path="datapoints.csv"):
+    """Write the raw datapoints to CSV."""
+    with open(path, "w", newline="") as f:
+        w = csv.writer(f)
+        w.writerow(["datapoint", "x-axis trades (raw trades or time)", "y-axis Price"])
+        for label, trade, price in datapoints:
+            w.writerow([label, trade, f"{price:.3f}"])
+    print(f"[OK] {path}")
+
+
+def write_profile_csv(profile, beta, path):
+    """Write a profile (CMP or GMP) to CSV, bins numbered 1..N from lowest."""
+    if not profile:
+        print(f"[WARN] Empty profile, skipping {path}")
+        return
+
+    b_min = min(profile.keys())
+    b_max = max(profile.keys())
+
+    # Include ALL bins from b_min to b_max (even empty ones)
+    rows = []
+    bin_number = 1
+    for b in range(b_min, b_max + 1):
+        p_from = b * beta
+        p_until = (b + 1) * beta
+        info = profile.get(b, {"labels": [], "count": 0})
+        group = "".join(sorted(info["labels"]))
+        count = info["count"]
+        rows.append([bin_number, int(p_from), int(p_until), group, count])
+        bin_number += 1
+
+    with open(path, "w", newline="") as f:
+        w = csv.writer(f)
+        w.writerow([
+            f"bin (with binsize = {beta} symbol's price unit)",
+            "price from", "price until", "datapoint group",
+            "number of profile's stacks"
+        ])
+        for row in rows:
+            w.writerow(row)
+    print(f"[OK] {path}")
+
+
+def write_updown_profile_csv(updown_profile, gmp_groups, beta, path):
+    """Write the Up/Down-Bin Footprint Profile to CSV."""
+    if not updown_profile:
+        print(f"[WARN] Empty profile, skipping {path}")
+        return
+
+    b_min = min(updown_profile.keys())
+    b_max = max(updown_profile.keys())
+
+    rows = []
+    bin_number = 1
+    for b in range(b_min, b_max + 1):
+        p_from = b * beta
+        p_until = (b + 1) * beta
+        info = updown_profile.get(b, {"labels": [], "up": 0, "down": 0})
+        group = "".join(info["labels"])
+        up_val = info["up"]
+        down_val = info["down"]
+        delta_val = up_val - down_val
+        rows.append([bin_number, int(p_from), int(p_until), group,
+                     down_val, up_val, delta_val])
+        bin_number += 1
+
+    with open(path, "w", newline="") as f:
+        w = csv.writer(f)
+        w.writerow([
+            f"bin (with binsize = {beta} symbol's price unit)",
+            "price from", "price until", "datapoint group",
+            "down-bin profile's stacks", "up-bin profile's stacks",
+            "delta-bin profile's stacks"
+        ])
+        for row in rows:
+            w.writerow(row)
+    print(f"[OK] {path}")
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  6. CHART GENERATION
+# ══════════════════════════════════════════════════════════════════════════════
+
+# ── Color palette (white / light theme) ──────────────────────────────────────
+CLR_BG       = "#ffffff"
+CLR_FG       = "#1a1a1a"
+CLR_GRID     = "#d0d0d0"
+CLR_ACCENT1  = "#1565c0"   # deep blue   (scatter)
+CLR_ACCENT2  = "#e65100"   # deep orange (CMP)
+CLR_ACCENT3  = "#2e7d32"   # deep green  (GMP)
+CLR_MUTED    = "#607d8b"
+CLR_LABEL    = "#333333"   # label text
+
+CHART_DPI = 300
+
+
+def _apply_style(ax, title=""):
+    """Apply a consistent white/light theme to an axes object."""
+    ax.set_facecolor(CLR_BG)
+    ax.figure.set_facecolor(CLR_BG)
+    ax.tick_params(colors=CLR_FG, labelsize=8)
+    ax.xaxis.label.set_color(CLR_FG)
+    ax.yaxis.label.set_color(CLR_FG)
+    ax.title.set_color(CLR_FG)
+    for spine in ax.spines.values():
+        spine.set_color(CLR_GRID)
+    ax.grid(True, color=CLR_GRID, linewidth=0.5, alpha=0.4)
+    if title:
+        ax.set_title(title, fontsize=11, fontweight="bold", pad=10)
+
+
+def chart_price_scatter(datapoints, path="fig_price_scatter.png", ax=None):
+    """Scatter + line plot of price vs trade index, labeled A–J."""
+    labels = [d[0] for d in datapoints]
+    trades = [d[1] for d in datapoints]
+    prices = [d[2] for d in datapoints]
+
+    standalone = ax is None
+    if standalone:
+        fig, ax = plt.subplots(figsize=(7, 4))
+    _apply_style(ax, "Price vs. Trade Index (Datapoints A–J)")
+
+    ax.plot(trades, prices, color=CLR_ACCENT1, linewidth=1.2, alpha=0.45,
+            zorder=1)
+    ax.scatter(trades, prices, color=CLR_ACCENT1, s=52, zorder=2,
+               edgecolors="white", linewidths=0.6)
+
+    for lbl, x, y in zip(labels, trades, prices):
+        ax.annotate(lbl, (x, y), textcoords="offset points",
+                    xytext=(0, 10), ha="center", fontsize=8,
+                    fontweight="bold", color=CLR_LABEL)
+
+    ax.set_xlabel("Trade Index (raw trades)", fontsize=9)
+    ax.set_ylabel("Price (USD)", fontsize=9)
+    ax.yaxis.set_major_formatter(ticker.FormatStrFormatter("%.0f"))
+
+    if standalone:
+        fig.tight_layout()
+        fig.savefig(path, dpi=CHART_DPI, bbox_inches="tight")
+        plt.close(fig)
+        print(f"[OK] {path}")
+
+
+def _draw_profile(ax, profile, beta, title, bar_color):
+    """Draw a horizontal bar chart for a profile onto *ax*."""
+    b_min = min(profile.keys())
+    b_max = max(profile.keys())
+
+    bin_labels = []
+    stacks = []
+    groups = []
+    for b in range(b_min, b_max + 1):
+        p_from = b * beta
+        p_until = (b + 1) * beta
+        bin_labels.append(f"{int(p_from)}–{int(p_until)}")
+        info = profile.get(b, {"labels": [], "count": 0})
+        stacks.append(info["count"])
+        groups.append("".join(sorted(info["labels"])))
+
+    y_pos = range(len(bin_labels))
+    bars = ax.barh(y_pos, stacks, color=bar_color, edgecolor="white",
+                   linewidth=0.5, height=0.7, alpha=0.85)
+
+    ax.set_yticks(y_pos)
+    ax.set_yticklabels(bin_labels, fontsize=7)
+    ax.set_xlabel("Stacks", fontsize=9)
+    ax.set_ylabel("Price Bin (USD)", fontsize=9)
+
+    # Annotate bars with datapoint group letters
+    max_s = max(stacks) if stacks else 1
+    for i, (bar, grp) in enumerate(zip(bars, groups)):
+        if grp:
+            ax.text(bar.get_width() + 0.12, bar.get_y() + bar.get_height() / 2,
+                    grp, va="center", ha="left", fontsize=7, color=CLR_LABEL,
+                    fontweight="bold")
+
+    ax.set_xlim(0, max_s + 2)
+    _apply_style(ax, title)
+
+
+def chart_profile(profile, beta, path, title, bar_color):
+    """Standalone horizontal bar chart for a single profile (CMP or GMP)."""
+    if not profile:
+        return
+    fig, ax = plt.subplots(figsize=(6, 5))
+    _draw_profile(ax, profile, beta, title, bar_color)
+    fig.tight_layout()
+    fig.savefig(path, dpi=CHART_DPI, bbox_inches="tight")
+    plt.close(fig)
+    print(f"[OK] {path}")
+
+
+def chart_cmp_vs_gmp(cmp_profile, gmp_profile, beta,
+                     path="fig_cmp_vs_gmp.png"):
+    """Side-by-side comparison of CMP and GMP profiles (2-panel)."""
+    if not cmp_profile or not gmp_profile:
+        return
+
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(11, 5), sharey=True)
+
+    _draw_profile(ax1, cmp_profile, beta, "CMP Profile", CLR_ACCENT2)
+    _draw_profile(ax2, gmp_profile, beta, "GMP Profile", CLR_ACCENT3)
+    ax2.set_ylabel("")  # avoid duplicate y-label
+
+    fig.suptitle("CMP vs. GMP  —  10-Datapoint Example (β = 1)",
+                 fontsize=13, fontweight="bold", color=CLR_FG, y=1.01)
+    fig.tight_layout()
+    fig.savefig(path, dpi=CHART_DPI, bbox_inches="tight")
+    plt.close(fig)
+    print(f"[OK] {path}")
+
+
+def chart_combined_3panel(datapoints, cmp_profile, gmp_profile, beta,
+                          path="fig_combined_3panel.png"):
+    """Three-panel chart: Datapoints | CMP with letters | GMP with letters."""
+    if not cmp_profile or not gmp_profile:
+        return
+
+    fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(16, 5.5),
+                                         gridspec_kw={"width_ratios": [1.1, 1, 1]})
+
+    # ── Panel 1: Datapoints scatter with labels ──────────────────────────
+    labels = [d[0] for d in datapoints]
+    trades = [d[1] for d in datapoints]
+    prices = [d[2] for d in datapoints]
+
+    _apply_style(ax1, "Datapoints (A–J)")
+    ax1.plot(trades, prices, color=CLR_ACCENT1, linewidth=1.2, alpha=0.4,
+             zorder=1)
+    ax1.scatter(trades, prices, color=CLR_ACCENT1, s=52, zorder=2,
+                edgecolors="white", linewidths=0.6)
+    for lbl, x, y in zip(labels, trades, prices):
+        ax1.annotate(lbl, (x, y), textcoords="offset points",
+                     xytext=(0, 10), ha="center", fontsize=9,
+                     fontweight="bold", color=CLR_LABEL)
+    ax1.set_xlabel("Trade Index", fontsize=9)
+    ax1.set_ylabel("Price (USD)", fontsize=9)
+    ax1.yaxis.set_major_formatter(ticker.FormatStrFormatter("%.0f"))
+
+    # ── Panel 2: CMP with group letters ──────────────────────────────────
+    _draw_profile(ax2, cmp_profile, beta, "CMP with Letters", CLR_ACCENT2)
+
+    # ── Panel 3: GMP with group letters ──────────────────────────────────
+    _draw_profile(ax3, gmp_profile, beta, "GMP with Letters", CLR_ACCENT3)
+    ax3.set_ylabel("")  # avoid duplicate y-label
+
+    fig.suptitle("Datapoints → CMP → GMP  (β = 1)",
+                 fontsize=14, fontweight="bold", color=CLR_FG, y=1.02)
+    fig.tight_layout()
+    fig.savefig(path, dpi=CHART_DPI, bbox_inches="tight")
+    plt.close(fig)
+    print(f"[OK] {path}")
+
+
+def chart_updown_footprint(updown_profile, beta,
+                           path="fig_updown_footprint.png"):
+    """Dual horizontal bar chart: down-bins (left/red) vs up-bins (right/teal)."""
+    if not updown_profile:
+        return
+
+    CLR_UP   = "#00897b"   # teal
+    CLR_DOWN = "#e53935"   # red
+
+    b_min = min(updown_profile.keys())
+    b_max = max(updown_profile.keys())
+
+    bin_labels = []
+    up_vals = []
+    down_vals = []
+    delta_vals = []
+    for b in range(b_min, b_max + 1):
+        p_from = b * beta
+        p_until = (b + 1) * beta
+        bin_labels.append(f"{int(p_from)}-{int(p_until)}")
+        info = updown_profile.get(b, {"labels": [], "up": 0, "down": 0})
+        up_vals.append(info["up"])
+        down_vals.append(info["down"])
+        delta_vals.append(info["up"] - info["down"])
+
+    y_pos = list(range(len(bin_labels)))
+    max_val = max(max(up_vals, default=1), max(down_vals, default=1), 1)
+
+    fig, ax = plt.subplots(figsize=(8, 5.5))
+    _apply_style(ax, "Up/Down-Bin Footprint Profile (GMP-based)")
+
+    # Down bars extend to the LEFT (negative x)
+    bars_down = ax.barh(y_pos, [-d for d in down_vals], color=CLR_DOWN,
+                        edgecolor="white", linewidth=0.5, height=0.65,
+                        alpha=0.85, label="Down-bin")
+    # Up bars extend to the RIGHT (positive x)
+    bars_up = ax.barh(y_pos, up_vals, color=CLR_UP,
+                      edgecolor="white", linewidth=0.5, height=0.65,
+                      alpha=0.85, label="Up-bin")
+
+    # Annotate bars with counts
+    for i, (dv, uv, deltav) in enumerate(zip(down_vals, up_vals, delta_vals)):
+        if dv > 0:
+            ax.text(-dv - 0.15, i, str(dv), va="center", ha="right",
+                    fontsize=7, color=CLR_DOWN, fontweight="bold")
+        if uv > 0:
+            ax.text(uv + 0.15, i, str(uv), va="center", ha="left",
+                    fontsize=7, color=CLR_UP, fontweight="bold")
+        # Delta annotation at far right
+        delta_color = CLR_UP if deltav > 0 else (CLR_DOWN if deltav < 0 else CLR_MUTED)
+        delta_str = f"{deltav:+d}" if deltav != 0 else "0"
+        ax.text(max_val + 1.0, i, f"\u0394={delta_str}", va="center", ha="left",
+                fontsize=6.5, color=delta_color)
+
+    ax.set_yticks(y_pos)
+    ax.set_yticklabels(bin_labels, fontsize=7)
+    ax.set_xlabel("Stacks", fontsize=9)
+    ax.set_ylabel("Price Bin (USD)", fontsize=9)
+    ax.axvline(0, color=CLR_FG, linewidth=0.6)
+    ax.set_xlim(-max_val - 1.5, max_val + 2.5)
+    ax.legend(loc="lower right", fontsize=8)
+
+    fig.tight_layout()
+    fig.savefig(path, dpi=CHART_DPI, bbox_inches="tight")
+    plt.close(fig)
+    print(f"[OK] {path}")
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  7. MAIN
+# ══════════════════════════════════════════════════════════════════════════════
+
+def main():
+    out_dir = os.path.dirname(os.path.abspath(__file__))
+
+    # ── Build profiles ────────────────────────────────────────────────────
+    cmp = build_cmp(DATAPOINTS, BIN_SIZE)
+    gmp = build_gmp(DATAPOINTS, BIN_SIZE)
+    updown = build_updown_profile(DATAPOINTS, BIN_SIZE)
+
+    # ── Write CSVs ────────────────────────────────────────────────────────
+    write_datapoints_csv(DATAPOINTS, os.path.join(out_dir, "datapoints.csv"))
+    write_profile_csv(cmp, BIN_SIZE, os.path.join(out_dir, "cmp_profile.csv"))
+    write_profile_csv(gmp, BIN_SIZE, os.path.join(out_dir, "gmp_profile.csv"))
+    write_updown_profile_csv(updown, gmp, BIN_SIZE,
+                             os.path.join(out_dir, "updown_profile.csv"))
+
+    # ── Generate charts ───────────────────────────────────────────────────
+    if HAS_MPL:
+        chart_price_scatter(
+            DATAPOINTS, os.path.join(out_dir, "fig_price_scatter.png"))
+        chart_profile(
+            cmp, BIN_SIZE, os.path.join(out_dir, "fig_cmp_profile.png"),
+            "Conventional Market Profile (CMP)", CLR_ACCENT2)
+        chart_profile(
+            gmp, BIN_SIZE, os.path.join(out_dir, "fig_gmp_profile.png"),
+            "Gap-Filled Market Profile (GMP)", CLR_ACCENT3)
+        chart_cmp_vs_gmp(
+            cmp, gmp, BIN_SIZE,
+            os.path.join(out_dir, "fig_cmp_vs_gmp.png"))
+        chart_combined_3panel(
+            DATAPOINTS, cmp, gmp, BIN_SIZE,
+            os.path.join(out_dir, "fig_combined_3panel.png"))
+        chart_updown_footprint(
+            updown, BIN_SIZE,
+            os.path.join(out_dir, "fig_updown_footprint.png"))
+
+    # ── Print summary ─────────────────────────────────────────────────────
+    print("\n── CMP Profile ──")
+    b_min = min(cmp.keys())
+    b_max = max(cmp.keys())
+    for b in range(b_min, b_max + 1):
+        info = cmp.get(b, {"labels": [], "count": 0})
+        grp = "".join(sorted(info["labels"]))
+        print(f"  Bin {b - b_min + 1}: {int(b * BIN_SIZE)}–{int((b+1) * BIN_SIZE)}  "
+              f"group={grp or '—':6s}  stacks={info['count']}")
+
+    print("\n── GMP Profile ──")
+    b_min = min(gmp.keys())
+    b_max = max(gmp.keys())
+    for b in range(b_min, b_max + 1):
+        info = gmp.get(b, {"labels": [], "count": 0})
+        grp = "".join(sorted(info["labels"]))
+        print(f"  Bin {b - b_min + 1}: {int(b * BIN_SIZE)}–{int((b+1) * BIN_SIZE)}  "
+              f"group={grp or '—':6s}  stacks={info['count']}")
+
+    print("\n── Up/Down-Bin Footprint Profile ──")
+    b_min = min(updown.keys())
+    b_max = max(updown.keys())
+    for b in range(b_min, b_max + 1):
+        info = updown.get(b, {"labels": [], "up": 0, "down": 0})
+        grp = "".join(info["labels"])
+        delta = info["up"] - info["down"]
+        print(f"  Bin {b - b_min + 1}: {int(b * BIN_SIZE)}–{int((b+1) * BIN_SIZE)}  "
+              f"group={grp or '—':6s}  up={info['up']}  down={info['down']}  "
+              f"delta={delta:+d}")
+
+
+if __name__ == "__main__":
+    main()

mBA-GMP.v3/generate_profiles.py_output/cmp_profile.csv

@@ -0,0 +1,11 @@
+bin (with binsize = 1 symbol's price unit),price from,price until,datapoint group,number of profile's stacks
+1,3000,3001,A,1
+2,3001,3002,,0
+3,3002,3003,C,1
+4,3003,3004,BGIJ,4
+5,3004,3005,H,1
+6,3005,3006,,0
+7,3006,3007,,0
+8,3007,3008,E,1
+9,3008,3009,,0
+10,3009,3010,DF,2

mBA-GMP.v3/generate_profiles.py_output/datapoints.csv

@@ -0,0 +1,11 @@
+datapoint,x-axis trades (raw trades or time),y-axis Price
+A,1,3000.914
+B,2,3003.837
+C,3,3002.432
+D,4,3009.892
+E,5,3007.698
+F,6,3009.176
+G,7,3003.381
+H,8,3004.283
+I,9,3003.512
+J,10,3003.012

mBA-GMP.v3/generate_profiles.py_output/gmp_profile.csv

@@ -0,0 +1,11 @@
+bin (with binsize = 1 symbol's price unit),price from,price until,datapoint group,number of profile's stacks
+1,3000,3001,A,1
+2,3001,3002,A,1
+3,3002,3003,AC,2
+4,3003,3004,BCGIJ,5
+5,3004,3005,CFH,3
+6,3005,3006,CF,2
+7,3006,3007,CF,2
+8,3007,3008,CEF,3
+9,3008,3009,CDEF,4
+10,3009,3010,DF,2

mBA-GMP.v3/generate_profiles.py_output/updown_profile.csv

@@ -0,0 +1,11 @@
+bin (with binsize = 1 symbol's price unit),price from,price until,datapoint group,down-bin profile's stacks,up-bin profile's stacks,delta-bin profile's stacks
+1,3000,3001,A,0,0,0
+2,3001,3002,A,0,1,1
+3,3002,3003,AC,1,1,0
+4,3003,3004,BCGIJ,3,2,-1
+5,3004,3005,CFH,1,2,1
+6,3005,3006,CF,1,1,0
+7,3006,3007,CF,1,1,0
+8,3007,3008,CEF,2,1,-1
+9,3008,3009,CDEF,2,2,0
+10,3009,3010,DF,0,2,2