hedgequantx 2.6.127 → 2.6.129

package/package.json

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

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

@@ -34,6 +34,17 @@ const StrategySupervisor = require('../../services/ai/strategy-supervisor');
 
 
 
+/**
+ * Check if service supports fast path (Rithmic direct)
+ * @param {Object} service - Trading service
+ * @returns {boolean}
+ */
+const isRithmicFastPath = (service) => {
+  return typeof service.fastEntry === 'function' && 
+         typeof service.fastExit === 'function' &&
+         service.orderConn?.isConnected;
+};
+
 /**
  * One Account Menu
  */
@@ -78,21 +89,48 @@ const oneAccountMenu = async (service) => {
   // Use the service attached to the account (from getAllAccounts), fallback to getServiceForAccount
   const accountService = selectedAccount.service || connections.getServiceForAccount(selectedAccount.accountId) || service;
   
-  // Select symbol
-  const contract = await selectSymbol(accountService, selectedAccount);
-  if (!contract) return;
+  // Check if Rithmic (supports multi-symbol)
+  const isRithmicAccount = isRithmicFastPath(accountService);
+  
+  // Ask for multi-symbol mode (Rithmic only)
+  let useMultiSymbol = false;
+  if (isRithmicAccount) {
+    console.log();
+    useMultiSymbol = await prompts.confirmPrompt(chalk.cyan(`MULTI-SYMBOL MODE? (up to ${MAX_MULTI_SYMBOLS} symbols)`), false);
+    if (useMultiSymbol === null) return;
+  }
+  
+  // Select symbol(s)
+  const contracts = await selectSymbol(accountService, selectedAccount, useMultiSymbol);
+  if (!contracts) return;
+  
+  // Normalize to array
+  const contractList = Array.isArray(contracts) ? contracts : [contracts];
   
   // Configure algo
-  const config = await configureAlgo(selectedAccount, contract);
+  const config = await configureAlgo(selectedAccount, contractList);
   if (!config) return;
   
-  await launchAlgo(accountService, selectedAccount, contract, config);
+  // Launch appropriate algo
+  if (contractList.length === 1) {
+    await launchAlgo(accountService, selectedAccount, contractList[0], config);
+  } else {
+    await launchMultiSymbolRithmic(accountService, selectedAccount, contractList, config);
+  }
 };
 
+// Maximum symbols for multi-symbol trading
+const MAX_MULTI_SYMBOLS = 5;
+
 /**
  * Symbol selection - sorted with popular indices first
+ * Supports selecting multiple symbols (up to MAX_MULTI_SYMBOLS)
+ * @param {Object} service - Trading service
+ * @param {Object} account - Trading account  
+ * @param {boolean} allowMultiple - Allow selecting multiple symbols
+ * @returns {Object|Array|null} Single contract or array of contracts
  */
-const selectSymbol = async (service, account) => {
+const selectSymbol = async (service, account, allowMultiple = false) => {
   const spinner = ora({ text: 'LOADING SYMBOLS...', color: 'yellow' }).start();
   
   const contractsResult = await service.getContracts();
@@ -136,16 +174,86 @@ const selectSymbol = async (service, account) => {
   
   options.push({ label: chalk.gray('< BACK'), value: 'back' });
   
-  const contract = await prompts.selectOption(chalk.yellow('SELECT SYMBOL:'), options);
-  return contract === 'back' || contract === null ? null : contract;
+  // Single symbol mode
+  if (!allowMultiple) {
+    const contract = await prompts.selectOption(chalk.yellow('SELECT SYMBOL:'), options);
+    return contract === 'back' || contract === null ? null : contract;
+  }
+  
+  // Multi-symbol selection mode
+  const selectedContracts = [];
+  
+  while (selectedContracts.length < MAX_MULTI_SYMBOLS) {
+    console.log();
+    
+    // Show already selected symbols
+    if (selectedContracts.length > 0) {
+      console.log(chalk.cyan(`  SELECTED (${selectedContracts.length}/${MAX_MULTI_SYMBOLS}):`));
+      selectedContracts.forEach((c, i) => {
+        const name = c.name || c.symbol;
+        console.log(chalk.green(`    ${i + 1}. ${name}`));
+      });
+      console.log();
+    }
+    
+    // Filter out already selected
+    const availableOptions = options.filter(opt => {
+      if (opt.value === 'back') return true;
+      const optId = opt.value.id || opt.value.symbol || opt.value.name;
+      return !selectedContracts.some(sc => (sc.id || sc.symbol || sc.name) === optId);
+    });
+    
+    // Add DONE option if at least 1 selected
+    if (selectedContracts.length > 0) {
+      availableOptions.unshift({ 
+        label: chalk.green(`✓ DONE - Start trading ${selectedContracts.length} symbol${selectedContracts.length > 1 ? 's' : ''}`), 
+        value: 'done' 
+      });
+    }
+    
+    const promptText = selectedContracts.length === 0 
+      ? chalk.yellow(`SELECT SYMBOL (1/${MAX_MULTI_SYMBOLS}):`)
+      : chalk.yellow(`ADD SYMBOL (${selectedContracts.length + 1}/${MAX_MULTI_SYMBOLS}) OR DONE:`);
+    
+    const choice = await prompts.selectOption(promptText, availableOptions);
+    
+    if (choice === null || choice === 'back') {
+      if (selectedContracts.length === 0) return null;
+      selectedContracts.pop(); // Remove last
+      continue;
+    }
+    
+    if (choice === 'done') break;
+    
+    selectedContracts.push(choice);
+    
+    if (selectedContracts.length >= MAX_MULTI_SYMBOLS) {
+      console.log(chalk.yellow(`  Maximum ${MAX_MULTI_SYMBOLS} symbols reached`));
+      break;
+    }
+  }
+  
+  return selectedContracts.length > 0 ? selectedContracts : null;
 };
 
 /**
  * Configure algo
+ * @param {Object} account - Trading account
+ * @param {Object|Array} contractOrContracts - Single contract or array of contracts
  */
-const configureAlgo = async (account, contract) => {
+const configureAlgo = async (account, contractOrContracts) => {
+  const contractList = Array.isArray(contractOrContracts) ? contractOrContracts : [contractOrContracts];
+  
   console.log();
   console.log(chalk.cyan('  CONFIGURE ALGO PARAMETERS'));
+  
+  // Show selected symbols
+  if (contractList.length > 1) {
+    console.log(chalk.white(`  Trading ${contractList.length} symbols:`));
+    contractList.forEach((c, i) => {
+      console.log(chalk.yellow(`    ${i + 1}. ${c.name || c.symbol}`));
+    });
+  }
   console.log();
   
   const contracts = await prompts.numberInput('NUMBER OF CONTRACTS:', 1, 1, 10);
@@ -197,17 +305,6 @@ const configureAlgo = async (account, contract) => {
   return { contracts, dailyTarget, maxRisk, showName, enableAI };
 };
 
-/**
- * Check if service supports fast path (Rithmic direct)
- * @param {Object} service - Trading service
- * @returns {boolean}
- */
-const isRithmicFastPath = (service) => {
-  return typeof service.fastEntry === 'function' && 
-         typeof service.fastExit === 'function' &&
-         service.orderConn?.isConnected;
-};
-
 /**
  * Launch algo trading - HQX Ultra Scalping Strategy
  * Real-time market data + Strategy signals + Auto order execution
@@ -1283,4 +1380,550 @@ const launchAlgo = async (service, account, contract, config) => {
   await prompts.waitForEnter();
 };
 
+/**
+ * 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
+ */
+const launchMultiSymbolRithmic = async (service, account, contracts, config) => {
+  const { contracts: qty, 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
+  const symbolNames = contracts.map(c => c.name || c.symbol);
+  const symbolsDisplay = symbolNames.join(', ');
+  
+  const ui = new AlgoUI({ 
+    subtitle: `MULTI-SYMBOL (${contracts.length})`, 
+    mode: 'one-account' 
+  });
+  
+  // Shared stats (same structure as launchAlgo)
+  const stats = {
+    accountName,
+    symbol: symbolsDisplay,
+    qty,
+    target: dailyTarget,
+    risk: maxRisk,
+    propfirm: account.propfirm || 'Unknown',
+    platform: 'RITHMIC',
+    pnl: null,
+    openPnl: null,
+    closedPnl: null,
+    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,
+      tickCount: 0,
+    };
+  });
+  
+  let running = true;
+  let stopReason = null;
+  let tickCount = 0;
+  
+  // Store contract info for later use
+  const contractInfoMap = {};
+  contracts.forEach(c => {
+    const name = c.name || c.symbol;
+    contractInfoMap[name] = {
+      tickSize: c.tickSize ?? null,
+      tickValue: c.tickValue ?? null,
+      contractId: c.id || c.symbol || c.name,
+      exchange: c.exchange || 'CME',
+    };
+  });
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // POSITION MANAGERS & STRATEGIES - One per symbol
+  // ═══════════════════════════════════════════════════════════════════════════
+  const positionManagers = {};
+  const strategies = {};
+  const pendingOrders = {}; // Track pending orders per symbol
+  
+  contracts.forEach(contract => {
+    const symbolName = contract.name || contract.symbol;
+    const { tickSize, tickValue, contractId } = contractInfoMap[symbolName];
+    
+    // Create strategy instance for this symbol
+    const 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';
+      ui.addLog('filled', `[${symbolName}] ${side} ${position.size}x @ ${position.entryPrice} | ${fillLatencyMs}ms`);
+      stats.symbolStats[symbolName].position = position.side === 0 ? position.size : -position.size;
+      ui.render(stats);
+    });
+    
+    pm.on('exitFilled', ({ exitPrice, pnlTicks, holdDurationMs }) => {
+      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++;
+          ui.addLog('win', `[${symbolName}] +$${pnlDollars.toFixed(2)} @ ${exitPrice} | ${holdSec}s`);
+        } else {
+          stats.losses++;
+          stats.symbolStats[symbolName].losses++;
+          ui.addLog('loss', `[${symbolName}] -$${Math.abs(pnlDollars).toFixed(2)} @ ${exitPrice} | ${holdSec}s`);
+        }
+      } else if (pnlTicks !== null) {
+        // Log with ticks only
+        stats.trades++;
+        stats.symbolStats[symbolName].trades++;
+        if (pnlTicks >= 0) {
+          stats.wins++;
+          stats.symbolStats[symbolName].wins++;
+          ui.addLog('win', `[${symbolName}] +${pnlTicks} ticks | ${holdSec}s`);
+        } else {
+          stats.losses++;
+          stats.symbolStats[symbolName].losses++;
+          ui.addLog('loss', `[${symbolName}] ${pnlTicks} ticks | ${holdSec}s`);
+        }
+      }
+      stats.symbolStats[symbolName].position = 0;
+      pendingOrders[symbolName] = false;
+      ui.render(stats);
+    });
+    
+    pm.on('holdComplete', () => {
+      ui.addLog('ready', `[${symbolName}] Hold complete - monitoring exit`);
+    });
+    
+    pm.on('breakevenActivated', ({ breakevenPrice, pnlTicks }) => {
+      ui.addLog('be', `[${symbolName}] BE @ ${breakevenPrice} | +${pnlTicks} ticks`);
+    });
+    
+    // ═══════════════════════════════════════════════════════════════════════
+    // STRATEGY SIGNALS
+    // ═══════════════════════════════════════════════════════════════════════
+    strategy.on('signal', async (signal) => {
+      if (!running) return;
+      if (pendingOrders[symbolName]) return;
+      if (!pm.canEnter(symbolName)) return;
+      
+      const { direction, confidence } = signal;
+      const orderSide = direction === 'long' ? 0 : 1;
+      const sideStr = direction === 'long' ? 'LONG' : 'SHORT';
+      
+      // Calculate risk amount
+      const kelly = Math.min(0.25, confidence || 0.15);
+      const riskAmount = Math.round(maxRisk * kelly);
+      const riskPct = Math.round((riskAmount / maxRisk) * 100);
+      
+      pendingOrders[symbolName] = true;
+      ui.addLog('entry', `[${symbolName}] ${sideStr} ${qty}x | risk: $${riskAmount} (${riskPct}%)`);
+      
+      const orderData = {
+        accountId: rithmicAccountId,
+        symbol: symbolName,
+        exchange: contractInfoMap[symbolName].exchange,
+        size: qty,
+        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;
+      }
+    });
+  });
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // 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');
+  });
+  
+  marketFeed.on('tick', (tick) => {
+    if (!running) return;
+    
+    tickCount++;
+    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=${tick.price} bid=${tick.bid} ask=${tick.ask}`);
+        } else if (stats.symbolStats[symbolName].tickCount === 100) {
+          algoLogger.info(ui, 'DATA FLOWING', `[${symbolName}] 100 ticks received`);
+        }
+        
+        const tickData = {
+          contractId: tick.contractId || symbolName,
+          price: tick.price || tick.lastPrice || tick.bid,
+          bid: tick.bid,
+          ask: tick.ask,
+          volume: tick.volume || tick.size || 1,
+          side: tick.lastTradeSide || tick.side || 'unknown',
+          timestamp: tick.timestamp || Date.now()
+        };
+        
+        // Update last price
+        stats.lastPrice = tickData.price;
+        
+        // Feed tick to strategy
+        strategy.processTick(tickData);
+        
+        // Update price for position manager
+        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;
+      }
+    }
+    
+    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);
+  }
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // REAL-TIME P&L VIA WEBSOCKET (same as launchAlgo)
+  // ═══════════════════════════════════════════════════════════════════════════
+  if (typeof service.on === 'function') {
+    // Account-level P&L updates
+    service.on('pnlUpdate', (pnlData) => {
+      if (pnlData.accountId !== rithmicAccountId) return;
+      
+      if (pnlData.closedPositionPnl !== undefined) {
+        stats.closedPnl = parseFloat(pnlData.closedPositionPnl);
+      }
+      if (pnlData.accountBalance !== undefined) {
+        stats.balance = parseFloat(pnlData.accountBalance);
+      }
+      if (pnlData.availableBuyingPower !== undefined) {
+        stats.buyingPower = parseFloat(pnlData.availableBuyingPower);
+      }
+      if (pnlData.marginBalance !== undefined) {
+        stats.margin = parseFloat(pnlData.marginBalance);
+      }
+      if (pnlData.netLiquidation !== undefined) {
+        stats.netLiquidation = parseFloat(pnlData.netLiquidation);
+      } else if (stats.balance !== null) {
+        stats.netLiquidation = stats.balance + (stats.openPnl || 0);
+      }
+      
+      stats.pnl = (stats.openPnl || 0) + (stats.closedPnl || 0);
+      ui.render(stats);
+    });
+    
+    // Position-level updates (for Open P&L)
+    service.on('positionUpdate', (pos) => {
+      if (!pos || pos.accountId !== rithmicAccountId) return;
+      
+      const posSymbol = pos.symbol;
+      for (const symbolName of Object.keys(stats.symbolStats)) {
+        const baseSymbol = symbolName.replace(/[A-Z]\d+$/, '');
+        if (posSymbol === baseSymbol || posSymbol === symbolName || symbolName.startsWith(posSymbol)) {
+          stats.symbolStats[symbolName].position = pos.quantity || 0;
+          
+          // Update Open P&L from position
+          if (pos.openPnl !== undefined && pos.openPnl !== null) {
+            stats.openPnl = pos.openPnl;
+            stats.pnl = (stats.openPnl || 0) + (stats.closedPnl || 0);
+            
+            if (stats.balance !== null) {
+              stats.netLiquidation = stats.balance + stats.openPnl;
+            }
+          }
+          break;
+        }
+      }
+      ui.render(stats);
+    });
+  }
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // EMERGENCY STOP
+  // ═══════════════════════════════════════════════════════════════════════════
+  const emergencyStopAll = async () => {
+    ui.addLog('warning', '████ EMERGENCY STOP ████');
+    
+    // Close all positions
+    for (const [symbolName, pm] of Object.entries(positionManagers)) {
+      try {
+        if (pm.hasPosition(symbolName)) {
+          pm.closePosition(symbolName);
+          ui.addLog('info', `[${symbolName}] Closing position...`);
+        }
+      } catch (e) {
+        ui.addLog('error', `[${symbolName}] Close failed: ${e.message}`);
+      }
+    }
+    
+    ui.addLog('info', 'All close orders sent');
+    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
+  try { await marketFeed.disconnect(); } catch {}
+  
+  // Cleanup keyboard
+  try { if (cleanupKeys) cleanupKeys(); } catch {}
+  try { ui.cleanup(); } catch {}
+  
+  try {
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+    process.stdin.resume();
+  } catch {}
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // SESSION SUMMARY
+  // ═══════════════════════════════════════════════════════════════════════════
+  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);
+  const duration = hours > 0 
+    ? `${hours}h ${minutes}m ${seconds}s`
+    : minutes > 0 
+      ? `${minutes}m ${seconds}s`
+      : `${seconds}s`;
+  
+  console.log();
+  console.log(chalk.cyan('═══════════════════════════════════════════════════════════════'));
+  console.log(chalk.cyan('                 MULTI-SYMBOL SESSION SUMMARY'));
+  console.log(chalk.cyan('═══════════════════════════════════════════════════════════════'));
+  console.log();
+  
+  for (const [symbol, symStats] of Object.entries(stats.symbolStats)) {
+    const winRate = symStats.trades > 0 ? ((symStats.wins / symStats.trades) * 100).toFixed(0) : 0;
+    const pnlColor = symStats.pnl >= 0 ? chalk.green : chalk.red;
+    console.log(chalk.white(`  ${symbol}:`));
+    console.log(`    Trades: ${symStats.trades} | WR: ${winRate}% | P&L: ${pnlColor('$' + symStats.pnl.toFixed(2))}`);
+  }
+  
+  console.log();
+  const totalPnlColor = stats.sessionPnl >= 0 ? chalk.green : chalk.red;
+  console.log(chalk.white(`  TOTAL: ${stats.trades} trades | ${stats.wins}W/${stats.losses}L`));
+  console.log(chalk.white(`  Session P&L: ${totalPnlColor('$' + stats.sessionPnl.toFixed(2))}`));
+  console.log(chalk.white(`  Duration: ${duration}`));
+  console.log();
+  console.log(chalk.cyan('═══════════════════════════════════════════════════════════════'));
+  
+  await prompts.waitForEnter();
+};
+
 module.exports = { oneAccountMenu };