hedgequantx 2.6.128 → 2.6.129

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "2.6.128",
+  "version": "2.6.129",
   "description": "HedgeQuantX - Prop Futures Trading CLI",
   "main": "src/app.js",
   "bin": {

package/src/pages/algo/one-account.js

@@ -1385,6 +1385,8 @@ const launchAlgo = async (service, account, contract, config) => {
  * Uses single market feed connection with multiple subscriptions
  * Each symbol has its own PositionManager and strategy instance
  * 
+ * Same logic as launchAlgo but for multiple symbols
+ * 
  * @param {Object} service - Rithmic trading service
  * @param {Object} account - Trading account
  * @param {Array} contracts - Array of contracts to trade
@@ -1407,7 +1409,7 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
     mode: 'one-account' 
   });
   
-  // Shared stats
+  // Shared stats (same structure as launchAlgo)
   const stats = {
     accountName,
     symbol: symbolsDisplay,
@@ -1420,7 +1422,12 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
     openPnl: null,
     closedPnl: null,
     balance: null,
+    buyingPower: null,
+    margin: null,
+    netLiquidation: null,
     position: 0,
+    entryPrice: 0,
+    lastPrice: 0,
     trades: 0,
     wins: 0,
     losses: 0,
@@ -1429,7 +1436,12 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
     connected: false,
     startTime: Date.now(),
     aiSupervision: enableAI || false,
+    aiMode: null,
+    agentCount: 0,
     fastPath: true,
+    avgEntryLatency: 0,
+    avgFillLatency: 0,
+    entryLatencies: [],
     // Per-symbol tracking
     symbolStats: {},
   };
@@ -1437,23 +1449,42 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
   // Initialize per-symbol stats
   contracts.forEach(c => {
     const name = c.name || c.symbol;
-    stats.symbolStats[name] = { position: 0, trades: 0, wins: 0, losses: 0, pnl: 0 };
+    stats.symbolStats[name] = { 
+      position: 0, 
+      trades: 0, 
+      wins: 0, 
+      losses: 0, 
+      pnl: 0,
+      tickCount: 0,
+    };
   });
   
   let running = true;
   let stopReason = null;
+  let tickCount = 0;
+  
+  // Store contract info for later use
+  const contractInfoMap = {};
+  contracts.forEach(c => {
+    const name = c.name || c.symbol;
+    contractInfoMap[name] = {
+      tickSize: c.tickSize ?? null,
+      tickValue: c.tickValue ?? null,
+      contractId: c.id || c.symbol || c.name,
+      exchange: c.exchange || 'CME',
+    };
+  });
   
   // ═══════════════════════════════════════════════════════════════════════════
-  // POSITION MANAGERS - One per symbol
+  // POSITION MANAGERS & STRATEGIES - One per symbol
   // ═══════════════════════════════════════════════════════════════════════════
   const positionManagers = {};
   const strategies = {};
+  const pendingOrders = {}; // Track pending orders per symbol
   
   contracts.forEach(contract => {
     const symbolName = contract.name || contract.symbol;
-    const contractId = contract.id || contract.symbol || contract.name;
-    const tickSize = contract.tickSize ?? null;
-    const tickValue = contract.tickValue ?? null;
+    const { tickSize, tickValue, contractId } = contractInfoMap[symbolName];
     
     // Create strategy instance for this symbol
     const strategy = Object.create(hftStrategy);
@@ -1461,6 +1492,7 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
       strategy.initialize(contractId, tickSize, tickValue);
     }
     strategies[symbolName] = strategy;
+    pendingOrders[symbolName] = false;
     
     // Create position manager for this symbol
     const pm = new PositionManager(service, strategy);
@@ -1470,11 +1502,16 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
     pm.start();
     positionManagers[symbolName] = pm;
     
-    // Position manager events
+    // ═══════════════════════════════════════════════════════════════════════
+    // POSITION MANAGER EVENTS (same as launchAlgo)
+    // ═══════════════════════════════════════════════════════════════════════
     pm.on('entryFilled', ({ position, fillLatencyMs }) => {
+      stats.entryLatencies.push(fillLatencyMs);
+      stats.avgFillLatency = stats.entryLatencies.reduce((a, b) => a + b, 0) / stats.entryLatencies.length;
       const side = position.side === 0 ? 'LONG' : 'SHORT';
       ui.addLog('filled', `[${symbolName}] ${side} ${position.size}x @ ${position.entryPrice} | ${fillLatencyMs}ms`);
       stats.symbolStats[symbolName].position = position.side === 0 ? position.size : -position.size;
+      ui.render(stats);
     });
     
     pm.on('exitFilled', ({ exitPrice, pnlTicks, holdDurationMs }) => {
@@ -1486,44 +1523,109 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
         stats.symbolStats[symbolName].trades++;
         stats.trades++;
         
+        // Record trade for Recovery Math
+        recoveryMath.recordTrade({
+          pnl: pnlDollars,
+          ticks: pnlTicks,
+          side: pnlTicks >= 0 ? 'win' : 'loss',
+          duration: holdDurationMs,
+        });
+        
+        // Update Recovery Mode state
+        const recovery = recoveryMath.updateSessionPnL(
+          stats.sessionPnl,
+          FAST_SCALPING.RECOVERY?.ACTIVATION_PNL || -300,
+          FAST_SCALPING.RECOVERY?.DEACTIVATION_PNL || -100
+        );
+        
+        if (recovery.justActivated) {
+          stats.recoveryMode = true;
+          ui.addLog('warning', `RECOVERY MODE ON - Kelly: ${(recoveryMath.calcKelly() * 100).toFixed(0)}%`);
+        } else if (recovery.justDeactivated) {
+          stats.recoveryMode = false;
+          ui.addLog('success', `RECOVERY MODE OFF - Session P&L: $${stats.sessionPnl.toFixed(2)}`);
+        }
+        
         if (pnlDollars >= 0) {
           stats.wins++;
           stats.symbolStats[symbolName].wins++;
-          ui.addLog('win', `[${symbolName}] +$${pnlDollars.toFixed(2)} | ${holdSec}s`);
+          ui.addLog('win', `[${symbolName}] +$${pnlDollars.toFixed(2)} @ ${exitPrice} | ${holdSec}s`);
+        } else {
+          stats.losses++;
+          stats.symbolStats[symbolName].losses++;
+          ui.addLog('loss', `[${symbolName}] -$${Math.abs(pnlDollars).toFixed(2)} @ ${exitPrice} | ${holdSec}s`);
+        }
+      } else if (pnlTicks !== null) {
+        // Log with ticks only
+        stats.trades++;
+        stats.symbolStats[symbolName].trades++;
+        if (pnlTicks >= 0) {
+          stats.wins++;
+          stats.symbolStats[symbolName].wins++;
+          ui.addLog('win', `[${symbolName}] +${pnlTicks} ticks | ${holdSec}s`);
         } else {
           stats.losses++;
           stats.symbolStats[symbolName].losses++;
-          ui.addLog('loss', `[${symbolName}] -$${Math.abs(pnlDollars).toFixed(2)} | ${holdSec}s`);
+          ui.addLog('loss', `[${symbolName}] ${pnlTicks} ticks | ${holdSec}s`);
         }
       }
       stats.symbolStats[symbolName].position = 0;
+      pendingOrders[symbolName] = false;
       ui.render(stats);
     });
     
-    // Strategy signals
+    pm.on('holdComplete', () => {
+      ui.addLog('ready', `[${symbolName}] Hold complete - monitoring exit`);
+    });
+    
+    pm.on('breakevenActivated', ({ breakevenPrice, pnlTicks }) => {
+      ui.addLog('be', `[${symbolName}] BE @ ${breakevenPrice} | +${pnlTicks} ticks`);
+    });
+    
+    // ═══════════════════════════════════════════════════════════════════════
+    // STRATEGY SIGNALS
+    // ═══════════════════════════════════════════════════════════════════════
     strategy.on('signal', async (signal) => {
       if (!running) return;
+      if (pendingOrders[symbolName]) return;
       if (!pm.canEnter(symbolName)) return;
       
-      const { direction } = signal;
+      const { direction, confidence } = signal;
       const orderSide = direction === 'long' ? 0 : 1;
       const sideStr = direction === 'long' ? 'LONG' : 'SHORT';
       
-      ui.addLog('entry', `[${symbolName}] ${sideStr} signal`);
+      // Calculate risk amount
+      const kelly = Math.min(0.25, confidence || 0.15);
+      const riskAmount = Math.round(maxRisk * kelly);
+      const riskPct = Math.round((riskAmount / maxRisk) * 100);
+      
+      pendingOrders[symbolName] = true;
+      ui.addLog('entry', `[${symbolName}] ${sideStr} ${qty}x | risk: $${riskAmount} (${riskPct}%)`);
       
       const orderData = {
         accountId: rithmicAccountId,
         symbol: symbolName,
-        exchange: contract.exchange || 'CME',
+        exchange: contractInfoMap[symbolName].exchange,
         size: qty,
         side: orderSide,
       };
       
-      const entryResult = service.fastEntry(orderData);
-      if (entryResult.success) {
-        pm.registerEntry(entryResult, orderData, { tickSize, tickValue, contractId });
-      } else {
-        ui.addLog('error', `[${symbolName}] Entry failed: ${entryResult.error}`);
+      try {
+        const entryResult = service.fastEntry(orderData);
+        if (entryResult.success) {
+          pm.registerEntry(entryResult, orderData, contractInfoMap[symbolName]);
+          
+          // Update avg entry latency
+          stats.avgEntryLatency = stats.entryLatencies.length > 0 
+            ? (stats.avgEntryLatency * stats.entryLatencies.length + entryResult.latencyMs) / (stats.entryLatencies.length + 1)
+            : entryResult.latencyMs;
+        } else {
+          ui.addLog('error', `[${symbolName}] Entry failed: ${entryResult.error}`);
+          pendingOrders[symbolName] = false;
+        }
+      } catch (e) {
+        ui.addLog('error', `[${symbolName}] Order error: ${e.message}`);
+        pendingOrders[symbolName] = false;
       }
     });
   });
@@ -1535,13 +1637,14 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
   
   marketFeed.on('connected', () => {
     stats.connected = true;
-    ui.addLog('success', 'Market feed connected');
-    ui.render(stats);
+    algoLogger.dataConnected(ui, 'RTC');
+    algoLogger.algoOperational(ui, 'RITHMIC');
   });
   
   marketFeed.on('tick', (tick) => {
     if (!running) return;
     
+    tickCount++;
     stats.latency = tick.latency || 0;
     
     // Route tick to correct strategy based on symbol
@@ -1551,14 +1654,29 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
     for (const [symbolName, strategy] of Object.entries(strategies)) {
       const baseSymbol = symbolName.replace(/[A-Z]\d+$/, '');
       if (tickSymbol === baseSymbol || tickSymbol === symbolName || symbolName.startsWith(tickSymbol)) {
+        stats.symbolStats[symbolName].tickCount++;
+        
+        // Log first tick per symbol
+        if (stats.symbolStats[symbolName].tickCount === 1) {
+          algoLogger.info(ui, 'FIRST TICK', `[${symbolName}] price=${tick.price} bid=${tick.bid} ask=${tick.ask}`);
+        } else if (stats.symbolStats[symbolName].tickCount === 100) {
+          algoLogger.info(ui, 'DATA FLOWING', `[${symbolName}] 100 ticks received`);
+        }
+        
         const tickData = {
           contractId: tick.contractId || symbolName,
           price: tick.price || tick.lastPrice || tick.bid,
           bid: tick.bid,
           ask: tick.ask,
           volume: tick.volume || tick.size || 1,
+          side: tick.lastTradeSide || tick.side || 'unknown',
           timestamp: tick.timestamp || Date.now()
         };
+        
+        // Update last price
+        stats.lastPrice = tickData.price;
+        
+        // Feed tick to strategy
         strategy.processTick(tickData);
         
         // Update price for position manager
@@ -1567,6 +1685,18 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
           price: tickData.price,
           timestamp: tickData.timestamp,
         });
+        
+        // Get momentum data from strategy for position manager
+        const modelValues = strategy.getModelValues?.() || strategy.getModelValues?.(symbolName);
+        if (modelValues && positionManagers[symbolName] && typeof positionManagers[symbolName].updateMomentum === 'function') {
+          positionManagers[symbolName].updateMomentum(symbolName, {
+            ofi: modelValues.ofi || 0,
+            zscore: modelValues.zscore || 0,
+            delta: modelValues.delta || 0,
+            timestamp: tickData.timestamp,
+          });
+        }
+        
         break;
       }
     }
@@ -1575,14 +1705,31 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
   });
   
   marketFeed.on('error', (err) => {
-    ui.addLog('error', `Feed error: ${err.message}`);
+    algoLogger.error(ui, 'MARKET ERROR', err.message);
   });
   
-  // Connect and subscribe
+  marketFeed.on('disconnected', (err) => {
+    stats.connected = false;
+    algoLogger.dataDisconnected(ui, 'WEBSOCKET', err?.message);
+  });
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // STARTUP LOGS (same as launchAlgo)
+  // ═══════════════════════════════════════════════════════════════════════════
+  const market = checkMarketHours();
+  const sessionName = market.session || 'AMERICAN';
+  const etTime = new Date().toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', timeZone: 'America/New_York' });
+  
+  algoLogger.connectingToEngine(ui, account.accountId);
+  algoLogger.engineStarting(ui, 'RITHMIC', dailyTarget, maxRisk);
+  algoLogger.marketOpen(ui, sessionName.toUpperCase(), etTime);
+  algoLogger.info(ui, 'FAST PATH', `Rithmic direct | ${contracts.length} symbols | Target <${FAST_SCALPING.LATENCY_TARGET_MS}ms`);
+  
   ui.render(stats);
-  ui.addLog('info', `MULTI-SYMBOL: ${contracts.length} symbols`);
   
+  // Connect and subscribe
   try {
+    algoLogger.info(ui, 'CONNECTING', `RITHMIC TICKER | ${contracts.length} symbols`);
     await marketFeed.connect();
     await new Promise(r => setTimeout(r, 1000));
     
@@ -1591,28 +1738,68 @@ const launchMultiSymbolRithmic = async (service, account, contracts, config) =>
         const symbolName = contract.name || contract.symbol;
         const exchange = contract.exchange || 'CME';
         marketFeed.subscribe(symbolName, exchange);
-        ui.addLog('success', `[${symbolName}] Subscribed`);
+        algoLogger.info(ui, 'SUBSCRIBED', `${symbolName} (${exchange})`);
       }
     } else {
-      ui.addLog('error', 'Failed to connect market feed');
+      algoLogger.error(ui, 'CONNECTION', 'Failed to connect market feed');
     }
   } catch (e) {
-    ui.addLog('error', `Connection error: ${e.message}`);
+    algoLogger.error(ui, 'CONNECTION ERROR', e.message);
   }
   
   // ═══════════════════════════════════════════════════════════════════════════
-  // P&L UPDATES VIA WEBSOCKET
+  // REAL-TIME P&L VIA WEBSOCKET (same as launchAlgo)
   // ═══════════════════════════════════════════════════════════════════════════
   if (typeof service.on === 'function') {
+    // Account-level P&L updates
     service.on('pnlUpdate', (pnlData) => {
       if (pnlData.accountId !== rithmicAccountId) return;
+      
       if (pnlData.closedPositionPnl !== undefined) {
         stats.closedPnl = parseFloat(pnlData.closedPositionPnl);
       }
       if (pnlData.accountBalance !== undefined) {
         stats.balance = parseFloat(pnlData.accountBalance);
       }
+      if (pnlData.availableBuyingPower !== undefined) {
+        stats.buyingPower = parseFloat(pnlData.availableBuyingPower);
+      }
+      if (pnlData.marginBalance !== undefined) {
+        stats.margin = parseFloat(pnlData.marginBalance);
+      }
+      if (pnlData.netLiquidation !== undefined) {
+        stats.netLiquidation = parseFloat(pnlData.netLiquidation);
+      } else if (stats.balance !== null) {
+        stats.netLiquidation = stats.balance + (stats.openPnl || 0);
+      }
+      
       stats.pnl = (stats.openPnl || 0) + (stats.closedPnl || 0);
+      ui.render(stats);
+    });
+    
+    // Position-level updates (for Open P&L)
+    service.on('positionUpdate', (pos) => {
+      if (!pos || pos.accountId !== rithmicAccountId) return;
+      
+      const posSymbol = pos.symbol;
+      for (const symbolName of Object.keys(stats.symbolStats)) {
+        const baseSymbol = symbolName.replace(/[A-Z]\d+$/, '');
+        if (posSymbol === baseSymbol || posSymbol === symbolName || symbolName.startsWith(posSymbol)) {
+          stats.symbolStats[symbolName].position = pos.quantity || 0;
+          
+          // Update Open P&L from position
+          if (pos.openPnl !== undefined && pos.openPnl !== null) {
+            stats.openPnl = pos.openPnl;
+            stats.pnl = (stats.openPnl || 0) + (stats.closedPnl || 0);
+            
+            if (stats.balance !== null) {
+              stats.netLiquidation = stats.balance + stats.openPnl;
+            }
+          }
+          break;
+        }
+      }
+      ui.render(stats);
     });
   }