hedgequantx 2.6.163 → 2.7.0

package/src/pages/algo/algo-multi.js

@@ -1,801 +0,0 @@
-/**
- * Multi-Symbol Algo Trading (Rithmic)
- * Handles trading multiple symbols simultaneously
- */
-
-'use strict';
-
-const chalk = require('chalk');
-const readline = require('readline');
-
-const { AlgoUI, renderMultiSymbolSummary } = require('./ui');
-const { prompts } = require('../../utils');
-const { FAST_SCALPING } = require('../../config/settings');
-const { PositionManager } = require('../../services/position-manager');
-const { hftStrategy } = require('../../services/strategy/hft-tick');
-const { RithmicMarketDataFeed } = require('../../services/rithmic/market-data');
-const { algoLogger } = require('./logger');
-const { recoveryMath } = require('../../services/strategy/recovery-math');
-const aiService = require('../../services/ai');
-const StrategySupervisor = require('../../services/ai/strategy-supervisor');
-const { formatPrice } = require('./algo-utils');
-
-/**
- * Launch multi-symbol algo trading (Rithmic only)
- * 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
- * @param {Object} config - Algo configuration
- * @param {Function} [CustomStrategyClass] - Optional custom strategy class (if not provided, uses hftStrategy)
- */
-const launchMultiSymbolRithmic = async (service, account, contracts, config, CustomStrategyClass = null) => {
-  const { dailyTarget, maxRisk, showName, enableAI } = config;
-  
-  const accountName = showName 
-    ? (account.accountName || account.rithmicAccountId || account.accountId) 
-    : 'HQX *****';
-  const rithmicAccountId = account.rithmicAccountId || account.accountId;
-  
-  // Build symbols string for UI (clean names without X1 suffix, symbol only)
-  const symbolsDisplay = contracts.map(c => {
-    let name = c.name || c.symbol;
-    // Remove X1, X2 suffix (Rithmic internal suffixes)
-    name = name.replace(/X\d+$/, '');
-    return name;
-  }).join(', ');
-  
-  const ui = new AlgoUI({ 
-    subtitle: `MULTI-SYMBOL (${contracts.length})`, 
-    mode: 'one-account' 
-  });
-  
-  // Calculate total qty across all symbols
-  const totalQty = contracts.reduce((sum, c) => sum + (c.qty || 1), 0);
-  
-  // Baseline P&L captured at session start (to show only THIS session's P&L)
-  let baselineClosedPnl = null; // Will be set on first pnlUpdate
-  
-  // Shared stats (same structure as launchAlgo)
-  const stats = {
-    accountName,
-    symbol: symbolsDisplay,
-    qty: totalQty,
-    target: dailyTarget,
-    risk: maxRisk,
-    propfirm: account.propfirm || 'Unknown',
-    platform: 'RITHMIC',
-    pnl: null,
-    openPnl: 0,      // Start at 0 for session
-    closedPnl: 0,    // Start at 0 for session (will show delta from baseline)
-    balance: null,
-    buyingPower: null,
-    margin: null,
-    netLiquidation: null,
-    position: 0,
-    entryPrice: 0,
-    lastPrice: 0,
-    trades: 0,
-    wins: 0,
-    losses: 0,
-    sessionPnl: 0,
-    latency: 0,
-    connected: false,
-    startTime: Date.now(),
-    aiSupervision: enableAI || false,
-    aiMode: null,
-    agentCount: 0,
-    fastPath: true,
-    avgEntryLatency: 0,
-    avgFillLatency: 0,
-    entryLatencies: [],
-    // Per-symbol tracking
-    symbolStats: {},
-  };
-  
-  // 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,
-      openPnl: 0, // Per-symbol unrealized P&L
-      tickCount: 0,
-    };
-  });
-  
-  let running = true;
-  let stopReason = null;
-  let tickCount = 0;
-  
-  // Store contract info for later use (including qty per symbol)
-  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',
-      qty: c.qty || 1, // Per-symbol quantity
-    };
-  });
-  
-  // ═══════════════════════════════════════════════════════════════════════════
-  // AI SUPERVISOR INITIALIZATION (same as single-symbol)
-  // ═══════════════════════════════════════════════════════════════════════════
-  let aiAgentCount = 0;
-  if (enableAI) {
-    const aiAgents = aiService.getAgents();
-    aiAgentCount = aiAgents.length;
-    stats.agentCount = aiAgentCount;
-    if (aiAgents.length > 0) {
-      // Use first symbol's strategy for AI supervisor
-      const firstContract = contracts[0];
-      const firstSymbolName = firstContract.name || firstContract.symbol;
-      // Strategy will be created below, so we init supervisor after strategies
-    }
-  }
-  
-  // ═══════════════════════════════════════════════════════════════════════════
-  // POSITION MANAGERS & STRATEGIES - One per symbol
-  // ═══════════════════════════════════════════════════════════════════════════
-  const positionManagers = {};
-  const strategies = {};
-  const pendingOrders = {}; // Track pending orders per symbol
-  // No disabled symbols - all symbols can trade until Target/Risk reached
-  
-  contracts.forEach(contract => {
-    const symbolName = contract.name || contract.symbol;
-    const { tickSize, tickValue, contractId } = contractInfoMap[symbolName];
-    
-    // Create strategy instance for this symbol
-    // Use custom strategy class if provided, otherwise use default hftStrategy
-    let strategy;
-    if (CustomStrategyClass) {
-      strategy = new CustomStrategyClass();
-    } else {
-      strategy = Object.create(hftStrategy);
-    }
-    if (tickSize !== null && tickValue !== null) {
-      strategy.initialize(contractId, tickSize, tickValue);
-    }
-    strategies[symbolName] = strategy;
-    pendingOrders[symbolName] = false;
-    
-    // Create position manager for this symbol
-    const pm = new PositionManager(service, strategy);
-    if (tickSize !== null && tickValue !== null) {
-      pm.setContractInfo(symbolName, { tickSize, tickValue, contractId });
-    }
-    pm.start();
-    positionManagers[symbolName] = pm;
-    
-    // ═══════════════════════════════════════════════════════════════════════
-    // 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';
-      const priceStr = formatPrice(position.entryPrice, tickSize || 0.25);
-      ui.addLog('filled', `[${symbolName}] ${side} ${position.size}x @ ${priceStr} | ${fillLatencyMs}ms`);
-      stats.symbolStats[symbolName].position = position.side === 0 ? position.size : -position.size;
-      ui.render(stats);
-    });
-    
-    pm.on('exitFilled', ({ exitPrice, pnlTicks, holdDurationMs }) => {
-      const holdSec = (holdDurationMs / 1000).toFixed(1);
-      if (pnlTicks !== null && tickValue !== null) {
-        const pnlDollars = pnlTicks * tickValue;
-        stats.sessionPnl += pnlDollars;
-        stats.symbolStats[symbolName].pnl += pnlDollars;
-        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++;
-          const priceStr = formatPrice(exitPrice, tickSize || 0.25);
-          ui.addLog('win', `[${symbolName}] +$${pnlDollars.toFixed(2)} @ ${priceStr} | ${holdSec}s`);
-        } else {
-          stats.losses++;
-          stats.symbolStats[symbolName].losses++;
-          const priceStr = formatPrice(exitPrice, tickSize || 0.25);
-          ui.addLog('loss', `[${symbolName}] -$${Math.abs(pnlDollars).toFixed(2)} @ ${priceStr} | ${holdSec}s`);
-          // Symbol can trade again - no disable, continue until Target/Risk reached
-        }
-      } 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}] ${pnlTicks} ticks | ${holdSec}s`);
-          // Symbol can trade again - no disable, continue until Target/Risk reached
-        }
-      }
-      stats.symbolStats[symbolName].position = 0;
-      stats.symbolStats[symbolName].openPnl = 0; // Reset open P&L when position closed
-      // Recalculate total Open P&L
-      stats.openPnl = Object.values(stats.symbolStats).reduce((sum, s) => sum + (s.openPnl || 0), 0);
-      pendingOrders[symbolName] = false;
-      ui.render(stats);
-    });
-    
-    pm.on('holdComplete', () => {
-      ui.addLog('ready', `[${symbolName}] Hold complete - monitoring exit`);
-    });
-    
-    pm.on('breakevenActivated', ({ breakevenPrice, pnlTicks }) => {
-      const priceStr = formatPrice(breakevenPrice, tickSize || 0.25);
-      ui.addLog('be', `[${symbolName}] BE @ ${priceStr} | +${pnlTicks} ticks`);
-    });
-    
-    // ═══════════════════════════════════════════════════════════════════════
-    // STRATEGY SIGNALS
-    // ═══════════════════════════════════════════════════════════════════════
-    strategy.on('signal', async (signal) => {
-      if (!running) return;
-      if (pendingOrders[symbolName]) return;
-      if (!pm.canEnter(symbolName)) return;
-      
-      const { direction, confidence } = signal;
-      const orderSide = direction === 'long' ? 0 : 1;
-      const sideStr = direction === 'long' ? 'LONG' : 'SHORT';
-      
-      // Use per-symbol quantity
-      const symbolQty = contractInfoMap[symbolName].qty;
-      
-      // 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} ${symbolQty}x | risk: $${riskAmount} (${riskPct}%)`);
-      
-      const orderData = {
-        accountId: rithmicAccountId,
-        symbol: symbolName,
-        exchange: contractInfoMap[symbolName].exchange,
-        size: symbolQty,
-        side: orderSide,
-      };
-      
-      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;
-      }
-    });
-  });
-  
-  // ═══════════════════════════════════════════════════════════════════════════
-  // AI SUPERVISOR - Initialize after strategies are created
-  // ═══════════════════════════════════════════════════════════════════════════
-  if (enableAI && aiAgentCount > 0) {
-    const aiAgents = aiService.getAgents();
-    const firstSymbol = Object.keys(strategies)[0];
-    const firstStrategy = strategies[firstSymbol];
-    const supervisorResult = StrategySupervisor.initialize(firstStrategy, aiAgents, service, rithmicAccountId);
-    stats.aiSupervision = supervisorResult.success;
-    stats.aiMode = supervisorResult.mode;
-    
-    if (stats.aiSupervision) {
-      algoLogger.info(ui, 'AI SUPERVISION', `${aiAgentCount} agent(s) - ${stats.aiMode} mode - LEARNING ACTIVE`);
-    }
-  }
-  
-  // ═══════════════════════════════════════════════════════════════════════════
-  // MARKET DATA FEED - Single connection, multiple subscriptions
-  // ═══════════════════════════════════════════════════════════════════════════
-  const marketFeed = new RithmicMarketDataFeed(service);
-  
-  marketFeed.on('connected', () => {
-    stats.connected = true;
-    algoLogger.dataConnected(ui, 'RTC');
-    algoLogger.algoOperational(ui, 'RITHMIC');
-  });
-  
-  // Smart logs state tracking
-  let lastHeartbeat = Date.now();
-  let tps = 0;
-  
-  marketFeed.on('tick', (tick) => {
-    if (!running) return;
-    
-    tickCount++;
-    tps++;
-    stats.latency = tick.latency || 0;
-    
-    // Route tick to correct strategy based on symbol
-    const tickSymbol = tick.symbol;
-    
-    // Find matching strategy (ES matches ESH6, NQ matches NQH6, etc.)
-    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=${parseFloat(Number(tick.price).toFixed(6))} bid=${parseFloat(Number(tick.bid).toFixed(6))} ask=${parseFloat(Number(tick.ask).toFixed(6))}`);
-        } 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
-        service.emit('priceUpdate', {
-          symbol: symbolName,
-          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;
-      }
-    }
-    
-    // ═══════════════════════════════════════════════════════════════════════════
-    // SMART LOGS - Same as single-symbol mode
-    // ═══════════════════════════════════════════════════════════════════════════
-    const now = Date.now();
-    if (now - lastHeartbeat > 1000) {
-      // Get model values from first active symbol's strategy
-      const firstSymbol = Object.keys(strategies)[0];
-      const firstStrategy = strategies[firstSymbol];
-      const modelValues = firstStrategy?.getModelValues?.() || firstStrategy?.getModelValues?.(firstSymbol) || null;
-      
-      if (modelValues && modelValues.ofi !== undefined) {
-        const ofi = modelValues.ofi || 0;
-        const delta = modelValues.delta || 0;
-        const zscore = modelValues.zscore || 0;
-        const mom = modelValues.momentum || 0;
-        
-        // Check if any symbol has an open position
-        const totalPosition = Object.values(stats.symbolStats).reduce((sum, s) => sum + Math.abs(s.position || 0), 0);
-        
-        if (totalPosition === 0) {
-          // Not in position - show market analysis (varied messages)
-          const smartLogs = require('./smart-logs');
-          const stateLog = smartLogs.getMarketStateLog(ofi, zscore, mom, delta);
-          if (stateLog.details) {
-            ui.addLog('analysis', `${stateLog.message} - ${stateLog.details}`);
-          } else {
-            ui.addLog('info', stateLog.message);
-          }
-        }
-        // When IN POSITION: Don't spam logs every second
-      } else {
-        // Waiting for data - log every 5 seconds only
-        if (now - lastHeartbeat > 5000) {
-          const smartLogs = require('./smart-logs');
-          const scanLog = smartLogs.getScanningLog(true);
-          ui.addLog('info', `${scanLog.message} ${tps} ticks/s`);
-        }
-      }
-      lastHeartbeat = now;
-      tps = 0;
-    }
-    
-    ui.render(stats);
-  });
-  
-  marketFeed.on('error', (err) => {
-    algoLogger.error(ui, 'MARKET ERROR', err.message);
-  });
-  
-  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);
-  
-  // Connect and subscribe
-  try {
-    algoLogger.info(ui, 'CONNECTING', `RITHMIC TICKER | ${contracts.length} symbols`);
-    await marketFeed.connect();
-    await new Promise(r => setTimeout(r, 1000));
-    
-    if (marketFeed.isConnected()) {
-      for (const contract of contracts) {
-        const symbolName = contract.name || contract.symbol;
-        const exchange = contract.exchange || 'CME';
-        marketFeed.subscribe(symbolName, exchange);
-        algoLogger.info(ui, 'SUBSCRIBED', `${symbolName} (${exchange})`);
-      }
-    } else {
-      algoLogger.error(ui, 'CONNECTION', 'Failed to connect market feed');
-    }
-  } catch (e) {
-    algoLogger.error(ui, 'CONNECTION ERROR', e.message);
-  }
-  
-  // ═══════════════════════════════════════════════════════════════════════════
-  // TARGET/RISK CHECK - Stop algo when limits reached
-  // Uses SESSION P&L (trades from this HQX session only) + Open P&L
-  // Risk triggers if: closedPnl hits risk OR openPnl hits risk OR total hits risk
-  // ═══════════════════════════════════════════════════════════════════════════
-  const checkTargetRisk = () => {
-    if (!running) return;
-    
-    const closedPnl = stats.closedPnl || 0;  // Session closed P&L
-    const openPnl = stats.openPnl || 0;      // Current open P&L
-    const totalPnl = closedPnl + openPnl;    // Total session P&L
-    
-    // Daily target reached - STOP with profit
-    if (totalPnl >= dailyTarget) {
-      stopReason = 'target';
-      running = false;
-      algoLogger.info(ui, 'TARGET REACHED', `+$${totalPnl.toFixed(2)} >= $${dailyTarget}`);
-      ui.addLog('success', `████ DAILY TARGET REACHED: +$${totalPnl.toFixed(2)} ████`);
-      emergencyStopAll();
-      return;
-    }
-    
-    // Max risk reached - STOP to protect capital
-    // Trigger if: closed P&L hits risk OR open P&L hits risk OR total hits risk
-    if (closedPnl <= -maxRisk) {
-      stopReason = 'risk';
-      running = false;
-      algoLogger.info(ui, 'CLOSED P&L RISK', `Closed: -$${Math.abs(closedPnl).toFixed(2)} <= -$${maxRisk}`);
-      ui.addLog('error', `████ MAX RISK (CLOSED): -$${Math.abs(closedPnl).toFixed(2)} ████`);
-      emergencyStopAll();
-    } else if (openPnl <= -maxRisk) {
-      stopReason = 'risk';
-      running = false;
-      algoLogger.info(ui, 'OPEN P&L RISK', `Open: -$${Math.abs(openPnl).toFixed(2)} <= -$${maxRisk}`);
-      ui.addLog('error', `████ MAX RISK (OPEN): -$${Math.abs(openPnl).toFixed(2)} ████`);
-      emergencyStopAll();
-    } else if (totalPnl <= -maxRisk) {
-      stopReason = 'risk';
-      running = false;
-      algoLogger.info(ui, 'TOTAL P&L RISK', `Total: -$${Math.abs(totalPnl).toFixed(2)} <= -$${maxRisk}`);
-      ui.addLog('error', `████ MAX RISK (TOTAL): -$${Math.abs(totalPnl).toFixed(2)} ████`);
-      emergencyStopAll();
-    }
-  };
-  
-  // ═══════════════════════════════════════════════════════════════════════════
-  // 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) {
-        const accountClosedPnl = parseFloat(pnlData.closedPositionPnl);
-        
-        // Capture baseline on first update (P&L at session start)
-        if (baselineClosedPnl === null) {
-          baselineClosedPnl = accountClosedPnl;
-          // Baseline captured silently - no need to show to user
-        }
-        
-        // stats.closedPnl shows ONLY this session's closed P&L (delta from baseline)
-        stats.closedPnl = accountClosedPnl - baselineClosedPnl;
-      }
-      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);
-      
-      // Check target/risk on every P&L update
-      checkTargetRisk();
-      
-      ui.render(stats);
-    });
-    
-    // Position-level updates (for Open P&L per symbol)
-    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 for this symbol
-          if (pos.openPnl !== undefined && pos.openPnl !== null) {
-            stats.symbolStats[symbolName].openPnl = pos.openPnl;
-            
-            // Calculate total Open P&L from all symbols
-            stats.openPnl = Object.values(stats.symbolStats).reduce((sum, s) => sum + (s.openPnl || 0), 0);
-            stats.pnl = (stats.openPnl || 0) + (stats.closedPnl || 0);
-            
-            if (stats.balance !== null) {
-              stats.netLiquidation = stats.balance + stats.openPnl;
-            }
-            
-            // Check target/risk on Open P&L changes too
-            checkTargetRisk();
-          }
-          break;
-        }
-      }
-      ui.render(stats);
-    });
-  }
-  
-  // ═══════════════════════════════════════════════════════════════════════════
-  // EMERGENCY STOP - Force close ALL positions
-  // ═══════════════════════════════════════════════════════════════════════════
-  const emergencyStopAll = async () => {
-    ui.addLog('warning', '████ EMERGENCY STOP INITIATED ████');
-    ui.render(stats);
-    
-    const TIMEOUT_MS = 5000;
-    const withTimeout = (promise, ms) => Promise.race([
-      promise,
-      new Promise((_, reject) => setTimeout(() => reject(new Error('TIMEOUT')), ms))
-    ]);
-    
-    try {
-      // CRITICAL: Use ONLY Rithmic API to get REAL positions from exchange
-      // DO NOT use local stats which can be corrupted
-      
-      // Step 1: Cancel all pending orders first
-      ui.addLog('info', 'Cancelling all orders...');
-      ui.render(stats);
-      try {
-        if (service && typeof service.cancelAllOrders === 'function') {
-          await withTimeout(service.cancelAllOrders(rithmicAccountId), TIMEOUT_MS);
-          ui.addLog('success', 'All orders cancelled');
-        }
-      } catch (e) {
-        ui.addLog('warning', `Cancel orders: ${e.message}`);
-      }
-      
-      // Step 2: Use Rithmic flattenAll - reads REAL positions from exchange
-      ui.addLog('info', 'Flattening all positions via Rithmic API...');
-      ui.render(stats);
-      
-      try {
-        if (service && typeof service.flattenAll === 'function') {
-          const result = await withTimeout(service.flattenAll(rithmicAccountId), TIMEOUT_MS);
-          if (result && result.results) {
-            for (const r of result.results) {
-              if (r.success) {
-                ui.addLog('success', `[${r.symbol}] FLATTENED`);
-              } else {
-                ui.addLog('error', `[${r.symbol}] ${r.error || 'Failed'}`);
-              }
-            }
-          }
-          ui.addLog('success', 'Flatten all complete');
-        } else if (service && typeof service.emergencyStop === 'function') {
-          // Fallback to emergencyStop
-          await withTimeout(service.emergencyStop(rithmicAccountId), TIMEOUT_MS);
-          ui.addLog('success', 'Emergency stop complete');
-        }
-      } catch (e) {
-        ui.addLog('warning', `Flatten: ${e.message}`);
-      }
-      
-      // Step 3: Reset local state
-      for (const [symbolName, symStats] of Object.entries(stats.symbolStats)) {
-        symStats.position = 0;
-        symStats.openPnl = 0;
-        // Also reset position manager
-        const pm = positionManagers[symbolName];
-        if (pm) {
-          try { pm.reset?.(); } catch {}
-        }
-      }
-      stats.openPnl = 0;
-      
-      ui.addLog('success', '████ EMERGENCY STOP COMPLETE ████');
-      
-    } catch (e) {
-      ui.addLog('error', `Emergency stop error: ${e.message}`);
-    }
-    
-    ui.render(stats);
-  };
-  
-  // Keyboard handler
-  let emergencyStopInProgress = false;
-  
-  const setupKeyHandler = () => {
-    if (!process.stdin.isTTY) return;
-    readline.emitKeypressEvents(process.stdin);
-    process.stdin.setRawMode(true);
-    process.stdin.resume();
-    
-    const onKey = async (str, key) => {
-      if (key && (key.name === 'x' || key.name === 'X' || (key.ctrl && key.name === 'c'))) {
-        if (emergencyStopInProgress) return;
-        emergencyStopInProgress = true;
-        running = false;
-        stopReason = 'manual';
-        await emergencyStopAll();
-      }
-    };
-    process.stdin.on('keypress', onKey);
-    return () => {
-      process.stdin.removeListener('keypress', onKey);
-      if (process.stdin.isTTY) process.stdin.setRawMode(false);
-    };
-  };
-  
-  const cleanupKeys = setupKeyHandler();
-  
-  // UI refresh
-  const refreshInterval = setInterval(() => {
-    if (running) ui.render(stats);
-  }, 1000);
-  
-  // Wait for stop
-  await new Promise(resolve => {
-    const check = setInterval(() => {
-      if (!running) {
-        clearInterval(check);
-        resolve();
-      }
-    }, 100);
-  });
-  
-  // ═══════════════════════════════════════════════════════════════════════════
-  // CLEANUP
-  // ═══════════════════════════════════════════════════════════════════════════
-  clearInterval(refreshInterval);
-  
-  // Stop all position managers
-  for (const pm of Object.values(positionManagers)) {
-    try { pm.stop(); } catch {}
-  }
-  
-  // Disconnect market feed with timeout
-  try { 
-    const disconnectPromise = marketFeed.disconnect();
-    const timeoutPromise = new Promise(resolve => setTimeout(resolve, 2000));
-    await Promise.race([disconnectPromise, timeoutPromise]);
-  } catch {}
-  
-  // Cleanup keyboard FIRST - restore stdin to normal mode
-  try { if (cleanupKeys) cleanupKeys(); } catch {}
-  
-  // Force stdin back to normal mode (critical for waitForEnter to work)
-  try {
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode(false);
-    }
-    // Remove all listeners to prevent interference
-    process.stdin.removeAllListeners('keypress');
-    process.stdin.resume();
-  } catch {}
-  
-  // Small delay to let stdin settle
-  await new Promise(r => setTimeout(r, 100));
-  
-  // Calculate duration before closeLog
-  const durationMs = Date.now() - stats.startTime;
-  const hours = Math.floor(durationMs / 3600000);
-  const minutes = Math.floor((durationMs % 3600000) / 60000);
-  const seconds = Math.floor((durationMs % 60000) / 1000);
-  stats.duration = hours > 0 
-    ? `${hours}h ${minutes}m ${seconds}s`
-    : minutes > 0 
-      ? `${minutes}m ${seconds}s`
-      : `${seconds}s`;
-  
-  // Close log file with session summary
-  try { ui.closeLog(stats); } catch {}
-  
-  // ═══════════════════════════════════════════════════════════════════════════
-  // SESSION SUMMARY (duration already calculated above)
-  // ═══════════════════════════════════════════════════════════════════════════
-  // Clear screen, show cursor, and render summary
-  process.stdout.write('\x1B[?25h'); // Show cursor
-  console.clear();
-  
-  // Render multi-symbol summary with same style as single-symbol
-  renderMultiSymbolSummary(stats, stopReason, stats.symbolStats);
-  
-  // Wait for user to press Enter before returning to menu
-  await prompts.waitForEnter();
-};
-
-
-module.exports = { launchMultiSymbolRithmic };