hedgequantx 2.6.159 → 2.6.161

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

@@ -7,30 +7,12 @@
 
 const chalk = require('chalk');
 const ora = require('ora');
-const readline = require('readline');
 
 const { connections } = require('../../services');
-const { AlgoUI, renderSessionSummary, renderMultiSymbolSummary } = require('./ui');
 const { prompts } = require('../../utils');
-const { checkMarketHours } = require('../../services/projectx/market');
-const { FAST_SCALPING } = require('../../config/settings');
-const { PositionManager } = require('../../services/position-manager');
-
-// Strategy & Market Data
-const { M1 } = require('../../../dist/lib/m/s1');
-const { hftStrategy } = require('../../services/strategy/hft-tick');
-const { MarketDataFeed } = require('../../../dist/lib/data');
-const { RithmicMarketDataFeed } = require('../../services/rithmic/market-data');
-const { algoLogger } = require('./logger');
-const { recoveryMath } = require('../../services/strategy/recovery-math');
-const { sessionHistory, SessionHistory } = require('../../services/session-history');
-
-// AI Strategy Supervisor - observes, learns, and optimizes the strategy
-const aiService = require('../../services/ai');
-const StrategySupervisor = require('../../services/ai/strategy-supervisor');
 
 // Shared utilities
-const { formatPrice, isRithmicFastPath, MAX_MULTI_SYMBOLS, USE_HFT_STRATEGY } = require('./algo-utils');
+const { isRithmicFastPath, MAX_MULTI_SYMBOLS } = require('./algo-utils');
 const { selectSymbol, configureAlgo } = require('./algo-config');
 
 /**
@@ -99,1871 +81,10 @@ const oneAccountMenu = async (service) => {
   const config = await configureAlgo(selectedAccount, contractList);
   if (!config) return;
   
-  // Launch appropriate algo
-  if (contractList.length === 1) {
-    await launchAlgo(accountService, selectedAccount, contractList[0], config);
-  } else {
-    await launchMultiSymbolRithmic(accountService, selectedAccount, contractList, config);
-  }
-};
-
-/**
- * Launch algo trading - HQX Ultra Scalping Strategy
- * Real-time market data + Strategy signals + Auto order execution
- * AI Supervision: All connected agents monitor and supervise trading
- * 
- * FAST PATH (Rithmic): Uses fastEntry() for ~10-50ms latency
- * SLOW PATH (ProjectX): Uses placeOrder() for ~50-150ms latency
- */
-const launchAlgo = async (service, account, contract, config) => {
-  const { contracts, dailyTarget, maxRisk, showName } = config;
-  
-  // Use RAW API fields only - NO hardcoded fallbacks
-  const accountName = showName 
-    ? (account.accountName || account.rithmicAccountId || account.accountId) 
-    : 'HQX *****';
-  const symbolName = contract.name || contract.symbol;
-  // contractId: use id for ProjectX, symbol for Rithmic
-  const contractId = contract.id || contract.symbol || contract.name;
-  const connectionType = account.platform || 'ProjectX';
-  
-  // Tick size/value from API - null if not available (RULES.md compliant)
-  const tickSize = contract.tickSize ?? null;
-  const tickValue = contract.tickValue ?? null;
-  
-
-  
-  // Determine execution path
-  const useFastPath = isRithmicFastPath(service);
-  
-  const ui = new AlgoUI({ subtitle: 'HQX ULTRA SCALPING', mode: 'one-account' });
-  
-  const stats = {
-    accountName,
-    symbol: symbolName,
-    qty: contracts,
-    target: dailyTarget,
-    risk: maxRisk,
-    propfirm: account.propfirm || 'Unknown',
-    platform: connectionType,
-    // ═══════════════════════════════════════════════════════════════════════════
-    // R TRADER METRICS - All from Rithmic API (ACCOUNT_PNL_UPDATE 451)
-    // ═══════════════════════════════════════════════════════════════════════════
-    pnl: null,             // Today's P&L (openPnl + closedPnl)
-    openPnl: null,         // Unrealized P&L (current position) - from INSTRUMENT_PNL_UPDATE 450
-    closedPnl: null,       // Realized P&L (closed trades today)
-    balance: null,         // Account Balance
-    buyingPower: null,     // Available Buying Power
-    margin: null,          // Margin Balance
-    netLiquidation: null,  // Net Liquidation Value (balance + openPnl)
-    // Position info (like R Trader Positions panel) - from INSTRUMENT_PNL_UPDATE 450
-    position: 0,           // Current position qty (+ long, - short)
-    entryPrice: 0,         // Average entry price
-    lastPrice: 0,          // Last market price (from ticker)
-    // Trading stats
-    trades: 0,
-    wins: 0,
-    losses: 0,
-    sessionPnl: 0,         // P&L from THIS session only (HQX trades)
-    latency: 0,
-    connected: false,
-    startTime: Date.now(),
-    aiSupervision: false,
-    aiMode: null,
-    agentCount: 0,         // Number of AI agents active
-    // Fast path stats
-    fastPath: useFastPath,
-    avgEntryLatency: 0,
-    avgFillLatency: 0,
-    entryLatencies: [],
-  };
-  
-  let running = true;
-  let stopReason = null;
-  let startingPnL = null;
-  let currentPosition = 0; // Current position qty (+ long, - short)
-  let pendingOrder = false; // Prevent duplicate orders
-  let tickCount = 0;
-  let lastTradeCount = 0; // Track number of trades from API
-  let lastPositionQty = 0; // Track position changes
-  let currentTradeId = null; // Track current trade for history
-  
-  // ═══════════════════════════════════════════════════════════════════════════
-  // SESSION HISTORY - Save all activity for AI learning
-  // ═══════════════════════════════════════════════════════════════════════════
-  sessionHistory.start(account.accountId, symbolName, account.propfirm || 'unknown', {
-    contracts,
-    dailyTarget,
-    maxRisk,
-    aiEnabled: config.enableAI,
-    agentCount: config.enableAI ? 2 : 0,
-  });
-  
-  // Load historical data for AI learning
-  const historicalData = SessionHistory.getAILearningData();
-  if (historicalData.totalSessions > 0) {
-    algoLogger.info(ui, 'HISTORY LOADED', 
-      `${historicalData.totalSessions} sessions | ${historicalData.totalTrades} trades | ` +
-      `WR: ${(historicalData.statistics?.winRate * 100 || 0).toFixed(0)}%`);
-  }
-  
-  // Initialize Strategy
-  // Use HFT tick-based strategy for Rithmic (fast path), M1 for ProjectX
-  const strategy = (USE_HFT_STRATEGY && useFastPath) ? hftStrategy : M1;
-  const strategyName = (USE_HFT_STRATEGY && useFastPath) ? 'HFT-TICK' : 'M1';
-  
-  // Initialize strategy with tick specs
-  if (tickSize !== null && tickValue !== null) {
-    strategy.initialize(contractId, tickSize, tickValue);
-    algoLogger.info(ui, 'STRATEGY', `${strategyName} initialized | tick=${tickSize} value=$${tickValue}`);
-  } else {
-    algoLogger.warning(ui, 'WARNING', 'Tick size/value not available from API');
-  }
-  
-  // Initialize Position Manager for fast path
-  let positionManager = null;
-  if (useFastPath) {
-    // Pass strategy reference so PositionManager can access math models
-    positionManager = new PositionManager(service, strategy);
-    
-    // Set contract info from API (NOT hardcoded)
-    if (tickSize !== null && tickValue !== null) {
-      positionManager.setContractInfo(symbolName, {
-        tickSize,
-        tickValue,
-        contractId,
-      });
-    }
-    
-    positionManager.start();
-    
-    // Listen for position manager events - CLEAN LOGS (no verbose order status)
-    positionManager.on('entryFilled', ({ orderTag, 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);
-      // Use 'filled' type for colored FILL icon
-      ui.addLog('filled', `${side} ${position.size}x ${symbolName} @ ${priceStr} | ${fillLatencyMs}ms`);
-    });
-    
-    positionManager.on('exitFilled', ({ orderTag, exitPrice, pnlTicks, holdDurationMs }) => {
-      const holdSec = (holdDurationMs / 1000).toFixed(1);
-      // Calculate PnL in dollars only if tickValue is available from API
-      if (pnlTicks !== null && tickValue !== null) {
-        const pnlDollars = pnlTicks * tickValue;
-        stats.sessionPnl += pnlDollars; // Track session P&L
-        
-        // 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
-        );
-        
-        // Log recovery mode changes
-        if (recovery.justActivated) {
-          stats.recoveryMode = true;
-          ui.addLog('warning', `RECOVERY MODE ON - Kelly: ${(recoveryMath.calcKelly() * 100).toFixed(0)}% | EV: $${recoveryMath.calcExpectedValue().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++;
-          const priceStr = formatPrice(exitPrice, tickSize || 0.25);
-          ui.addLog('win', `+$${pnlDollars.toFixed(2)} @ ${priceStr} | ${holdSec}s`);
-        } else {
-          stats.losses++;
-          const priceStr = formatPrice(exitPrice, tickSize || 0.25);
-          ui.addLog('loss', `-$${Math.abs(pnlDollars).toFixed(2)} @ ${priceStr} | ${holdSec}s`);
-        }
-      } else {
-        // Log with ticks only if tickValue unavailable
-        if (pnlTicks !== null && pnlTicks >= 0) {
-          stats.wins++;
-          ui.addLog('win', `+${pnlTicks} ticks | ${holdSec}s`);
-        } else if (pnlTicks !== null) {
-          stats.losses++;
-          ui.addLog('loss', `${pnlTicks} ticks | ${holdSec}s`);
-        }
-      }
-      stats.trades++;
-      currentPosition = 0;
-      stats.position = 0; // Reset UI position display
-      pendingOrder = false;
-    });
-    
-    positionManager.on('holdComplete', ({ orderTag, position }) => {
-      // Use 'ready' type for green READY icon
-      ui.addLog('ready', `Hold complete - monitoring exit`);
-    });
-    
-    positionManager.on('breakevenActivated', ({ orderTag, position, breakevenPrice, pnlTicks }) => {
-      // Use 'be' type for yellow BE icon
-      const priceStr = formatPrice(breakevenPrice, tickSize || 0.25);
-      ui.addLog('be', `Breakeven @ ${priceStr} | +${pnlTicks} ticks`)
-    });
-    
-    positionManager.on('exitOrderFired', ({ orderTag, exitReason, latencyMs }) => {
-      // Don't log here - exitFilled will log the result
-    });
-    
-    // NOTE: Removed verbose DEBUG logs (ORDER ACCEPTED, ORDER STATUS, ORDER FILL, FILL CONFIRMED)
-    // Entry/Exit fills are logged by positionManager events (entryFilled, exitFilled)
-  }
-  
-  // ═══════════════════════════════════════════════════════════════════════════
-  // REAL-TIME P&L VIA WEBSOCKET
-  // - Rithmic: Uses EventEmitter (service.on) for real-time updates
-  // - ProjectX: Uses HTTP polling (handled in pollPnL function below)
-  // ═══════════════════════════════════════════════════════════════════════════
-  const rithmicAccountId = account.rithmicAccountId || account.accountId;
-  const serviceHasEvents = typeof service.on === 'function';
-  
-  if (serviceHasEvents) {
-    // RITHMIC ONLY: Real-time P&L via WebSocket
-    service.on('pnlUpdate', (pnlData) => {
-      // Only update for our account
-      if (pnlData.accountId !== rithmicAccountId) return;
-      
-      // ACCOUNT_PNL_UPDATE (451) - All R Trader account-level metrics
-      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);
-      }
-      
-      // Total P&L = openPnl + closedPnl (same as R Trader)
-      stats.pnl = (stats.openPnl || 0) + (stats.closedPnl || 0);
-    });
-    
-    // RITHMIC ONLY: Real-time position updates
-    service.on('positionUpdate', (pos) => {
-      if (!pos || pos.accountId !== rithmicAccountId) return;
-      if (pos.symbol !== symbolName && !pos.symbol?.includes(symbolName.replace(/[A-Z]\d+$/, ''))) return;
-      
-      const wasFlat = stats.position === 0;
-      stats.position = pos.quantity || 0;
-      stats.entryPrice = pos.averagePrice || 0;
-      currentPosition = pos.quantity || 0;
-      
-      if (wasFlat && stats.position !== 0) {
-        stats.entryTime = Date.now();
-      } else if (stats.position === 0) {
-        stats.entryTime = null;
-      }
-      
-      // Update Open P&L from INSTRUMENT_PNL_UPDATE (450)
-      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;
-        }
-      }
-    });
-  }
-  
-  // Initialize AI Strategy Supervisor - agents observe, learn & optimize
-  // Only if user enabled AI in config
-  let aiAgentCount = 0;
-  if (config.enableAI) {
-    const aiAgents = aiService.getAgents();
-    aiAgentCount = aiAgents.length;
-    stats.agentCount = aiAgentCount;
-    if (aiAgents.length > 0) {
-      const supervisorResult = StrategySupervisor.initialize(strategy, aiAgents, service, account.accountId);
-      stats.aiSupervision = supervisorResult.success;
-      stats.aiMode = supervisorResult.mode;
-    }
-  }
-  
-  // Initialize Market Data Feed
-  // Use RithmicMarketDataFeed for Rithmic accounts (fast path), MarketDataFeed for ProjectX
-  const isRithmic = useFastPath && service.tickerConn;
-  const marketFeed = isRithmic 
-    ? new RithmicMarketDataFeed(service)
-    : new MarketDataFeed({ propfirm: account.propfirm });
-  
-  // Smart startup logs (same as HQX-TG)
-  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, connectionType, dailyTarget, maxRisk);
-  algoLogger.marketOpen(ui, sessionName.toUpperCase(), etTime);
-  
-  // Log AI supervision status
-  if (stats.aiSupervision) {
-    algoLogger.info(ui, 'AI SUPERVISION', `${aiAgentCount} agent(s) - ${stats.aiMode} mode - LEARNING ACTIVE`);
-  }
-  
-  // Log execution path
-  if (useFastPath) {
-    algoLogger.info(ui, 'FAST PATH', `Rithmic direct | Target <${FAST_SCALPING.LATENCY_TARGET_MS}ms | Hold ${FAST_SCALPING.MIN_HOLD_MS / 1000}s`);
-  } else {
-    algoLogger.info(ui, 'SLOW PATH', `HTTP REST | Bracket orders enabled`);
-  }
-  
-  // Handle strategy signals
-  strategy.on('signal', async (signal) => {
-    if (!running || pendingOrder || currentPosition !== 0) return;
-    
-    // Fast path: check if position manager allows new entry
-    if (useFastPath && positionManager && !positionManager.canEnter(symbolName)) {
-      algoLogger.info(ui, 'BLOCKED', 'Existing position in symbol');
-      return;
-    }
-    
-    const { side, direction, entry, stopLoss, takeProfit, confidence } = signal;
-    
-    // ═══════════════════════════════════════════════════════════════════════════
-    // RECOVERY MODE - Math-based adaptive trading
-    // Uses Kelly Criterion, Expected Value, and Volatility scaling
-    // ═══════════════════════════════════════════════════════════════════════════
-    if (FAST_SCALPING.RECOVERY?.ENABLED) {
-      const recoveryParams = recoveryMath.getRecoveryParams({
-        baseSize: contracts,
-        maxSize: contracts * 2,
-        atr: strategy.getATR?.() || 12,
-        confidence,
-        tickValue,
-      });
-      
-      // In recovery mode: only take positive EV trades
-      if (recoveryParams.recoveryActive && !recoveryParams.shouldTrade) {
-        ui.addLog('warning', `RECOVERY SKIP - EV: $${recoveryParams.expectedValue.toFixed(2)} (need $10+)`);
-        return;
-      }
-      
-      // Log recovery stats periodically
-      if (recoveryParams.recoveryActive && stats.trades % 3 === 0) {
-        ui.addLog('info', `RECOVERY - Kelly: ${(recoveryParams.kelly * 100).toFixed(0)}% | WR: ${(recoveryParams.winRate * 100).toFixed(0)}% | EV: $${recoveryParams.expectedValue.toFixed(0)}`);
-      }
-    }
-    
-    // Feed signal to AI supervisor (agents observe the signal)
-    if (stats.aiSupervision) {
-      StrategySupervisor.feedSignal({ direction, entry, stopLoss, takeProfit, confidence });
-      
-      // Check AI advice - agents may recommend caution based on learned patterns
-      const advice = StrategySupervisor.shouldTrade();
-      if (!advice.proceed) {
-        algoLogger.info(ui, 'AI HOLD', advice.reason);
-        return; // Skip - agents learned this pattern leads to losses
-      }
-    }
-    
-    // Calculate position size with Kelly (math-based)
-    let kelly;
-    if (FAST_SCALPING.RECOVERY?.ENABLED && recoveryMath.trades.length >= 5) {
-      // Use math-based Kelly from trade history
-      kelly = recoveryMath.calcDrawdownAdjustedKelly();
-    } else {
-      // Fallback to confidence-based Kelly
-      kelly = Math.min(0.25, confidence);
-    }
-    let riskAmount = Math.round(maxRisk * kelly);
-    
-    // AI may adjust size based on learning
-    if (stats.aiSupervision) {
-      const advice = StrategySupervisor.getCurrentAdvice();
-      if (advice.sizeMultiplier && advice.sizeMultiplier !== 1.0) {
-        kelly = kelly * advice.sizeMultiplier;
-        riskAmount = Math.round(riskAmount * advice.sizeMultiplier);
-        algoLogger.info(ui, 'AI ADJUST', `Size x${advice.sizeMultiplier.toFixed(2)} - ${advice.reason}`);
-      }
-    }
-    
-    const riskPct = Math.round((riskAmount / maxRisk) * 100);
-    
-    // Place order via API
-    pendingOrder = true;
-    const orderSide = direction === 'long' ? 0 : 1; // 0=Buy, 1=Sell
-    const sideStr = direction === 'long' ? 'LONG' : 'SHORT';
-    
-    try {
-      // ═══════════════════════════════════════════════════════════════
-      // FAST PATH: Rithmic direct execution (~10-50ms)
-      // ═══════════════════════════════════════════════════════════════
-      if (useFastPath && positionManager) {
-        const orderData = {
-          accountId: account.accountId,
-          symbol: symbolName,
-          exchange: contract.exchange || 'CME',
-          size: contracts,
-          side: orderSide,
-        };
-        
-        // CRITICAL: Use rithmicAccountId (original) not accountId (hash) for Rithmic orders
-        if (account.rithmicAccountId) {
-          orderData.accountId = account.rithmicAccountId;
-        }
-        
-        // Log entry attempt (single line) - use 'entry' type for cyan ENTRY icon
-        ui.addLog('entry', `${sideStr} ${contracts}x ${symbolName} | risk: $${riskAmount} (${riskPct}%)`);
-        
-        // Fire-and-forget entry (no await on fill)
-        const entryResult = service.fastEntry(orderData);
-        
-        if (entryResult.success) {
-          // Register with position manager for lifecycle tracking
-          const contractInfo = { tickSize, tickValue, contractId };
-          positionManager.registerEntry(entryResult, orderData, contractInfo);
-          
-          currentPosition = direction === 'long' ? contracts : -contracts;
-          
-          // Update avg entry latency
-          stats.avgEntryLatency = stats.entryLatencies.length > 0 
-            ? (stats.avgEntryLatency * stats.entryLatencies.length + entryResult.latencyMs) / (stats.entryLatencies.length + 1)
-            : entryResult.latencyMs;
-          
-          // Note: Fill confirmation logged by positionManager.on('entryFilled')
-          
-        } else {
-          algoLogger.orderRejected(ui, symbolName, entryResult.error || 'Fast entry failed');
-          pendingOrder = false;
-        }
-        
-      // ═══════════════════════════════════════════════════════════════
-      // SLOW PATH: ProjectX/Tradovate HTTP REST (~50-150ms)
-      // ═══════════════════════════════════════════════════════════════
-      } else {
-        const orderResult = await service.placeOrder({
-          accountId: account.accountId,
-          contractId: contractId,
-          type: 2, // Market order
-          side: orderSide,
-          size: contracts
-        });
-        
-        if (orderResult.success) {
-          currentPosition = direction === 'long' ? contracts : -contracts;
-          stats.trades++;
-          const sideStr = direction === 'long' ? 'BUY' : 'SELL';
-          const positionSide = direction === 'long' ? 'LONG' : 'SHORT';
-          
-          algoLogger.orderSubmitted(ui, symbolName, sideStr, contracts, entry);
-          algoLogger.orderFilled(ui, symbolName, sideStr, contracts, entry);
-          algoLogger.positionOpened(ui, symbolName, positionSide, contracts, entry);
-          algoLogger.entryConfirmed(ui, sideStr, contracts, symbolName, entry);
-          
-          // Record trade entry in session history
-          currentTradeId = sessionHistory.recordEntry({
-            direction,
-            symbol: symbolName,
-            quantity: contracts,
-            entryPrice: entry,
-            stopLoss,
-            takeProfit,
-            momentum: strategy.getMomentum?.() || 0,
-            zscore: strategy.getZScore?.() || 0,
-            ofi: strategy.getOFI?.() || 0,
-          });
-          
-          // Place bracket orders (SL/TP) - SLOW PATH ONLY
-          if (stopLoss && takeProfit) {
-            // Stop Loss
-            await service.placeOrder({
-              accountId: account.accountId,
-              contractId: contractId,
-              type: 4, // Stop order
-              side: direction === 'long' ? 1 : 0, // Opposite side
-              size: contracts,
-              stopPrice: stopLoss
-            });
-            
-            // Take Profit
-            await service.placeOrder({
-              accountId: account.accountId,
-              contractId: contractId,
-              type: 1, // Limit order
-              side: direction === 'long' ? 1 : 0,
-              size: contracts,
-              limitPrice: takeProfit
-            });
-            
-            algoLogger.stopsSet(ui, stopLoss, takeProfit);
-          }
-          pendingOrder = false;
-        } else {
-          algoLogger.orderRejected(ui, symbolName, orderResult.error || 'Unknown error');
-          pendingOrder = false;
-        }
-      }
-    } catch (e) {
-      algoLogger.error(ui, 'ORDER ERROR', e.message);
-      pendingOrder = false;
-    }
-  });
-  
-  // Handle market data ticks
-  let lastHeartbeat = Date.now();
-  let tps = 0;
-  
-  marketFeed.on('tick', (tick) => {
-    tickCount++;
-    tps++;
-    const latencyStart = Date.now();
-    
-    // Debug: log first tick and confirm data flow after 5s
-    if (tickCount === 1) {
-      algoLogger.info(ui, 'FIRST TICK', `price=${parseFloat(Number(tick.price).toFixed(6))} bid=${parseFloat(Number(tick.bid).toFixed(6))} ask=${parseFloat(Number(tick.ask).toFixed(6))} vol=${tick.volume || tick.size || 0}`);
-    } else if (tickCount === 100) {
-      algoLogger.info(ui, 'DATA FLOWING', `100 ticks received - market data OK`);
-    }
-    
-    // Feed tick to strategy
-    const tickData = {
-      contractId: tick.contractId || contractId,
-      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 for UI (like R Trader)
-    stats.lastPrice = tickData.price;
-    
-    // Feed tick to AI supervisor (agents observe same data as strategy)
-    if (stats.aiSupervision) {
-      StrategySupervisor.feedTick(tickData);
-    }
-    
-    strategy.processTick(tickData);
-    
-    // Feed price to Recovery Math for volatility calculation
-    if (FAST_SCALPING.RECOVERY?.ENABLED && tickData.price) {
-      recoveryMath.recordPriceReturn(tickData.price, stats.lastPrice || tickData.price);
-    }
-    
-    // Feed price to position manager for exit monitoring (fast path)
-    if (useFastPath && positionManager) {
-      // Update latest price for position monitoring
-      service.emit('priceUpdate', {
-        symbol: symbolName,
-        price: tickData.price,
-        timestamp: tickData.timestamp,
-      });
-      
-      // Get momentum data from strategy if available
-      const modelValues = strategy.getModelValues?.() || strategy.getModelValues?.(contractId);
-      if (modelValues && typeof positionManager.updateMomentum === 'function') {
-        positionManager.updateMomentum(symbolName, {
-          ofi: modelValues.ofi || 0,
-          zscore: modelValues.zscore || 0,
-          delta: modelValues.delta || 0,
-          timestamp: tickData.timestamp,
-        });
-      }
-    }
-    
-    stats.latency = Date.now() - latencyStart;
-    
-    // Smart logs - only on STATE CHANGES (not every second when in position)
-    const now = Date.now();
-    if (now - lastHeartbeat > 1000) {
-      const modelValues = strategy.getModelValues?.() || strategy.getModelValues?.(contractId) || 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;
-        
-        // Use stats.position from Rithmic API (real-time WebSocket)
-        const positionQty = stats.position || 0;
-        
-        if (positionQty === 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
-        // Position updates come from order fills and exit events
-      } 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;
-    }
-  });
-  
-  marketFeed.on('connected', () => {
-    stats.connected = true;
-    algoLogger.dataConnected(ui, 'RTC');
-    algoLogger.algoOperational(ui, connectionType);
-  });
-  
-  marketFeed.on('error', (err) => {
-    algoLogger.error(ui, 'MARKET ERROR', err.message);
-  });
-  
-  marketFeed.on('disconnected', (err) => {
-    stats.connected = false;
-    algoLogger.dataDisconnected(ui, 'WEBSOCKET', err?.message);
-  });
-  
-  // Connect to market data
-  try {
-    if (isRithmic) {
-      // Rithmic: Use existing tickerConn from RithmicService
-      algoLogger.info(ui, 'CONNECTING', `RITHMIC TICKER | ${symbolName}`);
-      
-      await marketFeed.connect();
-      
-      // Wait for connection to stabilize
-      await new Promise(r => setTimeout(r, 1000));
-      
-      if (marketFeed.isConnected()) {
-        // Use contract exchange or default to CME
-        const exchange = contract.exchange || 'CME';
-        marketFeed.subscribe(symbolName, exchange);
-        algoLogger.info(ui, 'SUBSCRIBED', `${symbolName} Rithmic real-time feed active`);
-      } else {
-        algoLogger.error(ui, 'CONNECTION LOST', 'Rithmic ticker not ready');
-      }
-    } else {
-      // ProjectX: Use HTTP token-based WebSocket
-      const propfirmKey = (account.propfirm || 'topstep').toLowerCase().replace(/\s+/g, '_');
-      
-      // CRITICAL: Get a fresh token for WebSocket connection
-      // TopStep invalidates WebSocket sessions for old tokens
-      algoLogger.info(ui, 'REFRESHING AUTH TOKEN...');
-      const token = await service.getFreshToken?.() || service.token || service.getToken?.();
-      
-      if (!token) {
-        algoLogger.error(ui, 'NO AUTH TOKEN', 'Please reconnect');
-      } else {
-        algoLogger.info(ui, 'TOKEN OK', `${token.length} chars`);
-        algoLogger.info(ui, 'CONNECTING', `${propfirmKey.toUpperCase()} | ${contractId}`);
-        
-        await marketFeed.connect(token, propfirmKey);
-        
-        // Wait for connection to stabilize
-        await new Promise(r => setTimeout(r, 2000));
-        
-        if (marketFeed.isConnected()) {
-          await marketFeed.subscribe(symbolName, contractId);
-          algoLogger.info(ui, 'SUBSCRIBED', `${symbolName} real-time feed active`);
-        } else {
-          algoLogger.error(ui, 'CONNECTION LOST', 'Before subscribe');
-        }
-      }
-    }
-  } catch (e) {
-    algoLogger.error(ui, 'CONNECTION ERROR', e.message.substring(0, 50));
-  }
-  
-  // Poll account P&L and sync with real trades from API
-  // For ProjectX: This is the PRIMARY source of P&L data (no WebSocket events)
-  // For Rithmic: This is a fallback (WebSocket events are primary)
-  const pollPnL = async () => {
-    try {
-      // Get account P&L
-      const accountResult = await service.getTradingAccounts();
-      if (accountResult.success && accountResult.accounts) {
-        const acc = accountResult.accounts.find(a => a.accountId === account.accountId);
-        if (acc) {
-          // Total day P&L
-          if (acc.profitAndLoss !== undefined && acc.profitAndLoss !== null) {
-            stats.pnl = acc.profitAndLoss;
-          }
-          // Closed P&L (realized)
-          if (acc.realizedPnl !== undefined) {
-            stats.closedPnl = acc.realizedPnl;
-          }
-          // Balance
-          if (acc.balance !== undefined) {
-            stats.balance = acc.balance;
-          }
-        }
-      }
-      
-      // Check positions - get Open P&L and detect when position closes
-      const posResult = await service.getPositions(account.accountId);
-      if (posResult.success && posResult.positions) {
-        const pos = posResult.positions.find(p => {
-          const sym = p.contractId || p.symbol || '';
-          return sym.includes(contract.name) || sym.includes(contractId);
-        });
-        
-        const newPositionQty = pos?.quantity || 0;
-        
-        // Update Open P&L from position (unrealized P&L)
-        if (pos && pos.unrealizedPnl !== undefined) {
-          stats.openPnl = pos.unrealizedPnl;
-        } else if (pos && pos.profitAndLoss !== undefined) {
-          stats.openPnl = pos.profitAndLoss;
-        } else if (newPositionQty === 0) {
-          stats.openPnl = 0; // Flat = no open P&L
-        }
-        
-        // Recalculate total P&L if we have components
-        if (stats.openPnl !== null && stats.closedPnl !== null) {
-          stats.pnl = stats.openPnl + stats.closedPnl;
-        }
-        
-        // Position just closed - cancel remaining orders and log result
-        if (lastPositionQty !== 0 && newPositionQty === 0) {
-          // Cancel all open orders to prevent new positions
-          try {
-            await service.cancelAllOrders(account.accountId);
-            algoLogger.info(ui, 'ORDERS CANCELLED', 'Position closed - brackets removed');
-          } catch (e) {
-            // Silent fail
-          }
-          
-          // Get real trade data from API
-          try {
-            const tradesResult = await service.getTrades(account.accountId);
-            if (tradesResult.success && tradesResult.trades?.length > 0) {
-              // Count completed trades (those with profitAndLoss not null)
-              const completedTrades = tradesResult.trades.filter(t => t.profitAndLoss !== null);
-              
-              // Update stats from real trades
-              let wins = 0, losses = 0;
-              for (const trade of completedTrades) {
-                if (trade.profitAndLoss > 0) wins++;
-                else if (trade.profitAndLoss < 0) losses++;
-              }
-              stats.trades = completedTrades.length;
-              stats.wins = wins;
-              stats.losses = losses;
-              
-              // Log the trade that just closed
-              const lastTrade = completedTrades[completedTrades.length - 1];
-              if (lastTrade) {
-                const pnl = lastTrade.profitAndLoss || 0;
-                const side = lastTrade.side === 0 ? 'LONG' : 'SHORT';
-                const exitPrice = lastTrade.price || 0;
-                
-                if (pnl >= 0) {
-                  algoLogger.targetHit(ui, symbolName, exitPrice, pnl);
-                } else {
-                  algoLogger.stopHit(ui, symbolName, exitPrice, Math.abs(pnl));
-                }
-                algoLogger.positionClosed(ui, symbolName, side, contracts, exitPrice, pnl);
-                
-                // Record in strategy for adaptation
-                strategy.recordTradeResult(pnl);
-                
-                // Record trade exit in session history
-                sessionHistory.recordExit(currentTradeId, {
-                  exitPrice,
-                  pnl,
-                  reason: pnl >= 0 ? 'takeProfit' : 'stopLoss',
-                });
-                currentTradeId = null;
-                
-                // Feed trade result to AI supervisor - THIS IS WHERE AGENTS LEARN
-                if (stats.aiSupervision) {
-                  StrategySupervisor.feedTradeResult({
-                    side,
-                    qty: contracts,
-                    price: exitPrice,
-                    pnl,
-                    symbol: symbolName,
-                    direction: side
-                  });
-                  
-                  // Log if AI learned something
-                  const status = StrategySupervisor.getStatus();
-                  if (status.patternsLearned.winning + status.patternsLearned.losing > 0) {
-                    algoLogger.info(ui, 'AI LEARNING', 
-                      `${status.patternsLearned.winning}W/${status.patternsLearned.losing}L patterns`);
-                  }
-                }
-              }
-            }
-          } catch (e) {
-            // Silent fail - trades API might not be available
-          }
-        }
-        
-        lastPositionQty = newPositionQty;
-        currentPosition = newPositionQty;
-      }
-      
-      // Check target/risk
-      if (stats.pnl >= dailyTarget) {
-        stopReason = 'target';
-        running = false;
-        algoLogger.info(ui, 'DAILY TARGET REACHED', `+$${stats.pnl.toFixed(2)}`);
-      } else if (stats.pnl <= -maxRisk) {
-        stopReason = 'risk';
-        running = false;
-        algoLogger.dailyLimitWarning(ui, stats.pnl, -maxRisk);
-      }
-    } catch (e) {
-      // Silently handle polling errors
-    }
-  };
-  
-  // Start polling and UI refresh
-  // UI refreshes every 8ms (120 fps - ProMotion display support), P&L polling every 10s
-  const refreshInterval = setInterval(() => { if (running) ui.render(stats); }, 8);
-  const pnlInterval = setInterval(() => { if (running) pollPnL(); }, 10000);
-  pollPnL(); // Initial poll
-  
-  // ═══════════════════════════════════════════════════════════════════════════
-  // ULTRA SOLID EMERGENCY STOP FUNCTION
-  // Called when X is pressed - MUST cancel all orders and flatten positions
-  // ═══════════════════════════════════════════════════════════════════════════
-  const emergencyStopAll = async () => {
-    const accountId = account.rithmicAccountId || account.accountId;
-    const MAX_RETRIES = 3;
-    const TIMEOUT_MS = 5000;
-    
-    ui.addLog('warning', '████ EMERGENCY STOP INITIATED ████');
-    ui.render(stats);
-    
-    // Helper: run with timeout
-    const withTimeout = (promise, ms) => Promise.race([
-      promise,
-      new Promise((_, reject) => setTimeout(() => reject(new Error('TIMEOUT')), ms))
-    ]);
-    
-    // ─────────────────────────────────────────────────────────────────────────
-    // STEP 1: CANCEL ALL ORDERS (with retries)
-    // ─────────────────────────────────────────────────────────────────────────
-    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-      try {
-        ui.addLog('info', `[${attempt}/${MAX_RETRIES}] Cancelling all orders...`);
-        ui.render(stats);
-        
-        if (typeof service.cancelAllOrders === 'function') {
-          await withTimeout(service.cancelAllOrders(accountId), TIMEOUT_MS);
-          ui.addLog('success', 'All orders cancelled');
-          ui.render(stats);
-          break;
-        } else {
-          ui.addLog('info', 'No cancelAllOrders function - skipping');
-          break;
-        }
-      } catch (e) {
-        ui.addLog('error', `Cancel orders attempt ${attempt} failed: ${e.message}`);
-        ui.render(stats);
-        if (attempt === MAX_RETRIES) {
-          ui.addLog('error', 'FAILED TO CANCEL ORDERS AFTER 3 ATTEMPTS');
-        }
-        await new Promise(r => setTimeout(r, 500)); // Wait before retry
-      }
-    }
-    
-    // ─────────────────────────────────────────────────────────────────────────
-    // STEP 2: FLATTEN POSITION (with retries)
-    // ─────────────────────────────────────────────────────────────────────────
-    const posQty = Math.abs(currentPosition || stats.position || 0);
-    
-    if (posQty > 0) {
-      const closeSide = (currentPosition || stats.position) > 0 ? 1 : 0;
-      const sideStr = closeSide === 1 ? 'SELL' : 'BUY';
-      
-      for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-        try {
-          ui.addLog('info', `[${attempt}/${MAX_RETRIES}] Flattening ${posQty}x position (${sideStr})...`);
-          ui.render(stats);
-          
-          // Method 1: Rithmic emergencyStop (best)
-          if (typeof service.emergencyStop === 'function') {
-            const result = await withTimeout(service.emergencyStop(accountId), TIMEOUT_MS);
-            if (result.success) {
-              ui.addLog('success', 'Position FLATTENED (Rithmic emergency stop)');
-              ui.render(stats);
-              break;
-            }
-          }
-          
-          // Method 2: Market order to close
-          if (typeof service.placeOrder === 'function') {
-            await withTimeout(service.placeOrder({
-              accountId: account.accountId,
-              contractId: contractId,
-              type: 2, // Market order
-              side: closeSide,
-              size: posQty
-            }), TIMEOUT_MS);
-            ui.addLog('success', `Position FLATTENED (market ${sideStr} ${posQty}x)`);
-            ui.render(stats);
-            break;
-          }
-          
-          // Method 3: Rithmic fastExit
-          if (typeof service.fastExit === 'function') {
-            await withTimeout(service.fastExit({
-              accountId: accountId,
-              symbol: symbolName,
-              exchange: contract.exchange || 'CME',
-              size: posQty,
-              side: closeSide
-            }), TIMEOUT_MS);
-            ui.addLog('success', `Position FLATTENED (fast exit ${sideStr} ${posQty}x)`);
-            ui.render(stats);
-            break;
-          }
-          
-        } catch (e) {
-          ui.addLog('error', `Flatten attempt ${attempt} failed: ${e.message}`);
-          ui.render(stats);
-          if (attempt === MAX_RETRIES) {
-            ui.addLog('error', '████ FAILED TO FLATTEN - CHECK MANUALLY! ████');
-          }
-          await new Promise(r => setTimeout(r, 500));
-        }
-      }
-    } else {
-      ui.addLog('success', 'No position to flatten - clean exit');
-      ui.render(stats);
-    }
-    
-    // ─────────────────────────────────────────────────────────────────────────
-    // STEP 3: VERIFY (optional - check position is actually flat)
-    // ─────────────────────────────────────────────────────────────────────────
-    try {
-      if (typeof service.getPositions === 'function') {
-        const posResult = await withTimeout(service.getPositions(account.accountId), 3000);
-        if (posResult.success && posResult.positions) {
-          const stillOpen = posResult.positions.find(p => {
-            const sym = p.contractId || p.symbol || '';
-            return (sym.includes(symbolName) || sym.includes(contractId)) && p.quantity !== 0;
-          });
-          if (stillOpen) {
-            ui.addLog('error', `████ POSITION STILL OPEN: ${stillOpen.quantity}x ████`);
-            ui.addLog('error', 'CLOSE MANUALLY IN R TRADER!');
-          } else {
-            ui.addLog('success', 'VERIFIED: Position is flat');
-          }
-        }
-      }
-    } catch (e) {
-      // Verification failed, but main stop was attempted
-      ui.addLog('warning', 'Could not verify position - check manually');
-    }
-    
-    ui.addLog('info', '════════════════════════════════════');
-    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; // Prevent double-trigger
-        emergencyStopInProgress = true;
-        running = false;
-        stopReason = 'manual';
-        
-        // Run emergency stop IMMEDIATELY on keypress (don't wait for main loop)
-        await emergencyStopAll();
-      }
-    };
-    process.stdin.on('keypress', onKey);
-    return () => {
-      process.stdin.removeListener('keypress', onKey);
-      if (process.stdin.isTTY) process.stdin.setRawMode(false);
-    };
-  };
-  
-  const cleanupKeys = setupKeyHandler();
-  
-  // Wait for stop
-  await new Promise(resolve => {
-    const check = setInterval(() => {
-      if (!running) {
-        clearInterval(check);
-        resolve();
-      }
-    }, 100);
-  });
-  
-  // Cleanup with timeout protection
-  clearInterval(refreshInterval);
-  clearInterval(pnlInterval);
-  
-  // Stop Position Manager (fast path)
-  if (positionManager) {
-    positionManager.stop();
-    positionManager = null;
-  }
-  
-  // Stop AI Supervisor and get learning summary
-  if (stats.aiSupervision) {
-    const aiSummary = StrategySupervisor.stop();
-    stats.aiLearning = {
-      optimizations: aiSummary.optimizationsApplied || 0,
-      patternsLearned: (aiSummary.winningPatterns || 0) + (aiSummary.losingPatterns || 0)
-    };
-  }
-  
-  // End session history and save to disk
-  sessionHistory.end({
-    totalTrades: stats.trades,
-    wins: stats.wins,
-    losses: stats.losses,
-    totalPnl: stats.pnl,
-    stopReason,
-  });
-  
-  // Disconnect market feed with timeout
-  try {
-    await Promise.race([
-      marketFeed.disconnect(),
-      new Promise(r => setTimeout(r, 3000))
-    ]);
-  } catch {}
-  
-  // Cleanup keyboard handler
-  try { if (cleanupKeys) cleanupKeys(); } catch {}
-  
-  // Close log file with session summary
-  try { ui.closeLog(stats); } catch {}
-  
-  // Cleanup UI
-  try { ui.cleanup(); } catch {}
-  
-  // Reset stdin
-  try {
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode(false);
-    }
-    process.stdin.resume();
-  } catch {}
-  
-  // Duration
-  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`;
-  
-  // Summary
-  renderSessionSummary(stats, stopReason);
-  
-  await prompts.waitForEnter();
+  // Launch algo (unified - works for 1 or multiple symbols)
+  await launchMultiSymbolRithmic(accountService, selectedAccount, contractList, config);
 };
 
-/**
- * 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();
-};
+const { launchMultiSymbolRithmic } = require('./algo-multi');
 
 module.exports = { oneAccountMenu, launchMultiSymbolRithmic, selectSymbol, configureAlgo };