hedgequantx 2.6.126 → 2.6.128

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "2.6.126",
+  "version": "2.6.128",
   "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,32 +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 symbols (up to MAX_SYMBOLS)
-  const contracts = await selectSymbols(accountService, selectedAccount);
-  if (!contracts || contracts.length === 0) 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;
   
-  // Configure algo (shared config for all symbols)
-  const config = await configureAlgo(selectedAccount, contracts);
+  // Normalize to array
+  const contractList = Array.isArray(contracts) ? contracts : [contracts];
+  
+  // Configure algo
+  const config = await configureAlgo(selectedAccount, contractList);
   if (!config) return;
   
-  // Launch algo for all selected symbols
-  if (contracts.length === 1) {
-    // Single symbol - use original launchAlgo
-    await launchAlgo(accountService, selectedAccount, contracts[0], config);
+  // Launch appropriate algo
+  if (contractList.length === 1) {
+    await launchAlgo(accountService, selectedAccount, contractList[0], config);
   } else {
-    // Multiple symbols - launch parallel trading
-    await launchMultiAlgo(accountService, selectedAccount, contracts, config);
+    await launchMultiSymbolRithmic(accountService, selectedAccount, contractList, config);
   }
 };
 
-// Maximum number of symbols to trade simultaneously
-const MAX_SYMBOLS = 5;
+// Maximum symbols for multi-symbol trading
+const MAX_MULTI_SYMBOLS = 5;
 
 /**
  * Symbol selection - sorted with popular indices first
- * Allows selecting multiple symbols (up to MAX_SYMBOLS)
+ * 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 selectSymbols = async (service, account) => {
+const selectSymbol = async (service, account, allowMultiple = false) => {
   const spinner = ora({ text: 'LOADING SYMBOLS...', color: 'yellow' }).start();
   
   const contractsResult = await service.getContracts();
@@ -137,64 +164,71 @@ const selectSymbols = async (service, account) => {
   
   spinner.succeed(`FOUND ${contracts.length} CONTRACTS`);
   
-  // Multi-symbol selection loop
+  // Display sorted contracts from API (uniform format: NAME - DESCRIPTION)
+  const options = contracts.map(c => {
+    const name = c.name || c.symbol || c.baseSymbol;
+    const desc = c.description || '';
+    const label = desc ? `${name} - ${desc}` : name;
+    return { label, value: c };
+  });
+  
+  options.push({ label: chalk.gray('< BACK'), value: 'back' });
+  
+  // 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_SYMBOLS) {
+  while (selectedContracts.length < MAX_MULTI_SYMBOLS) {
     console.log();
+    
+    // Show already selected symbols
     if (selectedContracts.length > 0) {
-      console.log(chalk.cyan(`  SELECTED (${selectedContracts.length}/${MAX_SYMBOLS}):`));
+      console.log(chalk.cyan(`  SELECTED (${selectedContracts.length}/${MAX_MULTI_SYMBOLS}):`));
       selectedContracts.forEach((c, i) => {
-        const name = c.name || c.symbol || c.baseSymbol;
+        const name = c.name || c.symbol;
         console.log(chalk.green(`    ${i + 1}. ${name}`));
       });
       console.log();
     }
     
-    // Filter out already selected contracts
-    const availableContracts = contracts.filter(c => {
-      const cId = c.id || c.symbol || c.name;
-      return !selectedContracts.some(sc => (sc.id || sc.symbol || sc.name) === cId);
+    // 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);
     });
     
-    // Build options
-    const options = availableContracts.map(c => {
-      const name = c.name || c.symbol || c.baseSymbol;
-      const desc = c.description || '';
-      const label = desc ? `${name} - ${desc}` : name;
-      return { label, value: c };
-    });
-    
-    // Add done/back options
+    // Add DONE option if at least 1 selected
     if (selectedContracts.length > 0) {
-      options.unshift({ label: chalk.green(`✓ DONE (trade ${selectedContracts.length} symbol${selectedContracts.length > 1 ? 's' : ''})`), value: 'done' });
+      availableOptions.unshift({ 
+        label: chalk.green(`✓ DONE - Start trading ${selectedContracts.length} symbol${selectedContracts.length > 1 ? 's' : ''}`), 
+        value: 'done' 
+      });
     }
-    options.push({ label: chalk.gray('< BACK'), value: 'back' });
     
     const promptText = selectedContracts.length === 0 
-      ? chalk.yellow(`SELECT SYMBOL (1-${MAX_SYMBOLS}):`)
-      : chalk.yellow(`ADD SYMBOL (${selectedContracts.length + 1}/${MAX_SYMBOLS}) OR DONE:`);
+      ? 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, options);
+    const choice = await prompts.selectOption(promptText, availableOptions);
     
-    if (choice === 'back' || choice === null) {
-      if (selectedContracts.length === 0) {
-        return null; // Go back
-      }
-      // Remove last selected
-      selectedContracts.pop();
+    if (choice === null || choice === 'back') {
+      if (selectedContracts.length === 0) return null;
+      selectedContracts.pop(); // Remove last
       continue;
     }
     
-    if (choice === 'done') {
-      break; // Done selecting
-    }
+    if (choice === 'done') break;
     
-    // Add selected contract
     selectedContracts.push(choice);
     
-    if (selectedContracts.length >= MAX_SYMBOLS) {
-      console.log(chalk.yellow(`  MAX ${MAX_SYMBOLS} SYMBOLS REACHED`));
+    if (selectedContracts.length >= MAX_MULTI_SYMBOLS) {
+      console.log(chalk.yellow(`  Maximum ${MAX_MULTI_SYMBOLS} symbols reached`));
       break;
     }
   }
@@ -202,36 +236,25 @@ const selectSymbols = async (service, account) => {
   return selectedContracts.length > 0 ? selectedContracts : null;
 };
 
-/**
- * Legacy single symbol selection (kept for compatibility)
- */
-const selectSymbol = async (service, account) => {
-  const contracts = await selectSymbols(service, account);
-  return contracts && contracts.length > 0 ? contracts[0] : null;
-};
-
 /**
  * Configure algo
  * @param {Object} account - Trading account
- * @param {Array|Object} contractsOrContract - Single contract or array of contracts
+ * @param {Object|Array} contractOrContracts - Single contract or array of contracts
  */
-const configureAlgo = async (account, contractsOrContract) => {
-  // Normalize to array
-  const contractList = Array.isArray(contractsOrContract) ? contractsOrContract : [contractsOrContract];
+const configureAlgo = async (account, contractOrContracts) => {
+  const contractList = Array.isArray(contractOrContracts) ? contractOrContracts : [contractOrContracts];
   
   console.log();
   console.log(chalk.cyan('  CONFIGURE ALGO PARAMETERS'));
-  console.log();
   
   // Show selected symbols
   if (contractList.length > 1) {
-    console.log(chalk.white(`  TRADING ${contractList.length} SYMBOLS:`));
+    console.log(chalk.white(`  Trading ${contractList.length} symbols:`));
     contractList.forEach((c, i) => {
-      const name = c.name || c.symbol || c.baseSymbol;
-      console.log(chalk.yellow(`    ${i + 1}. ${name}`));
+      console.log(chalk.yellow(`    ${i + 1}. ${c.name || c.symbol}`));
     });
-    console.log();
   }
+  console.log();
   
   const contracts = await prompts.numberInput('NUMBER OF CONTRACTS:', 1, 1, 10);
   if (contracts === null) return null;
@@ -282,17 +305,6 @@ const configureAlgo = async (account, contractsOrContract) => {
   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
@@ -1369,51 +1381,46 @@ const launchAlgo = async (service, account, contract, config) => {
 };
 
 /**
- * Launch multi-symbol algo trading
- * Runs multiple symbols in parallel on the same account
+ * Launch multi-symbol algo trading (Rithmic only)
+ * Uses single market feed connection with multiple subscriptions
+ * Each symbol has its own PositionManager and strategy instance
  * 
- * @param {Object} service - Trading service
+ * @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 launchMultiAlgo = async (service, account, contracts, config) => {
-  const { contracts: qty, dailyTarget, maxRisk, showName } = config;
+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 connectionType = account.platform || 'ProjectX';
-  const useFastPath = isRithmicFastPath(service);
+  const rithmicAccountId = account.rithmicAccountId || account.accountId;
   
-  // Build symbol list string
-  const symbolNames = contracts.map(c => c.name || c.symbol || c.baseSymbol);
-  const symbolsStr = symbolNames.join(', ');
+  // 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 across all symbols
+  // Shared stats
   const stats = {
     accountName,
-    symbol: symbolsStr,
+    symbol: symbolsDisplay,
     qty,
     target: dailyTarget,
     risk: maxRisk,
     propfirm: account.propfirm || 'Unknown',
-    platform: connectionType,
+    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,
@@ -1421,140 +1428,217 @@ const launchMultiAlgo = async (service, account, contracts, config) => {
     latency: 0,
     connected: false,
     startTime: Date.now(),
-    aiSupervision: config.enableAI || false,
-    aiMode: null,
-    agentCount: 0,
-    fastPath: useFastPath,
-    avgEntryLatency: 0,
-    avgFillLatency: 0,
-    entryLatencies: [],
-    // Multi-symbol specific
-    activeSymbols: contracts.length,
-    symbolStats: {}, // Per-symbol stats
+    aiSupervision: enableAI || false,
+    fastPath: true,
+    // 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,
-    };
+    stats.symbolStats[name] = { position: 0, trades: 0, wins: 0, losses: 0, pnl: 0 };
   });
   
   let running = true;
   let stopReason = null;
   
-  // Track market feeds and position managers for cleanup
-  const marketFeeds = [];
-  const positionManagers = [];
-  
-  ui.render(stats);
-  ui.addLog('info', `MULTI-SYMBOL MODE: ${contracts.length} symbols`);
-  symbolNames.forEach(name => ui.addLog('info', `  → ${name}`));
+  // ═══════════════════════════════════════════════════════════════════════════
+  // POSITION MANAGERS - One per symbol
+  // ═══════════════════════════════════════════════════════════════════════════
+  const positionManagers = {};
+  const strategies = {};
   
-  // Launch trading for each symbol
-  const symbolPromises = contracts.map(async (contract, index) => {
+  contracts.forEach(contract => {
     const symbolName = contract.name || contract.symbol;
     const contractId = contract.id || contract.symbol || contract.name;
     const tickSize = contract.tickSize ?? null;
     const tickValue = contract.tickValue ?? null;
     
-    // Initialize strategy for this symbol
-    const strategy = (USE_HFT_STRATEGY && useFastPath) ? hftStrategy : M1;
+    // Create strategy instance for this symbol
+    const strategy = Object.create(hftStrategy);
     if (tickSize !== null && tickValue !== null) {
       strategy.initialize(contractId, tickSize, tickValue);
     }
+    strategies[symbolName] = strategy;
     
-    // Initialize Position Manager for fast path
-    let positionManager = null;
-    if (useFastPath) {
-      positionManager = new PositionManager(service, strategy);
-      if (tickSize !== null && tickValue !== null) {
-        positionManager.setContractInfo(symbolName, { tickSize, tickValue, contractId });
-      }
-      positionManager.start();
-      positionManagers.push(positionManager);
-      
-      // Position manager events
-      positionManager.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`);
-      });
-      
-      positionManager.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;
-          
-          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`);
-          }
-          stats.trades++;
-          stats.symbolStats[symbolName].trades++;
-        }
-        ui.render(stats);
-      });
+    // 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;
     
-    // Connect market feed for this symbol
-    const MarketFeedClass = useFastPath ? RithmicMarketDataFeed : MarketDataFeed;
-    const marketFeed = new MarketFeedClass(service);
-    marketFeeds.push(marketFeed);
+    // Position manager events
+    pm.on('entryFilled', ({ position, fillLatencyMs }) => {
+      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;
+    });
     
-    try {
-      await marketFeed.connect(contractId, account.accountId);
-      ui.addLog('success', `[${symbolName}] Market feed connected`);
-      stats.connected = true;
-      
-      // Handle market data ticks
-      marketFeed.on('tick', (tick) => {
-        if (!running) return;
-        
-        stats.latency = tick.latency || 0;
-        stats.lastPrice = tick.price || tick.last || 0;
-        
-        // Get strategy signal
-        const signal = strategy.onTick ? strategy.onTick(tick) : strategy.analyze?.(tick);
+    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++;
         
-        if (signal && signal.action && signal.action !== 'hold') {
-          if (useFastPath && positionManager) {
-            // Fast path execution
-            if (signal.action === 'buy' || signal.action === 'long') {
-              positionManager.openPosition(symbolName, contract.exchange || 'CME', 0, qty, account.accountId);
-            } else if (signal.action === 'sell' || signal.action === 'short') {
-              positionManager.openPosition(symbolName, contract.exchange || 'CME', 1, qty, account.accountId);
-            } else if (signal.action === 'close' || signal.action === 'exit') {
-              positionManager.closePosition(symbolName);
-            }
-          }
+        if (pnlDollars >= 0) {
+          stats.wins++;
+          stats.symbolStats[symbolName].wins++;
+          ui.addLog('win', `[${symbolName}] +$${pnlDollars.toFixed(2)} | ${holdSec}s`);
+        } else {
+          stats.losses++;
+          stats.symbolStats[symbolName].losses++;
+          ui.addLog('loss', `[${symbolName}] -$${Math.abs(pnlDollars).toFixed(2)} | ${holdSec}s`);
         }
-        
-        ui.render(stats);
-      });
+      }
+      stats.symbolStats[symbolName].position = 0;
+      ui.render(stats);
+    });
+    
+    // Strategy signals
+    strategy.on('signal', async (signal) => {
+      if (!running) return;
+      if (!pm.canEnter(symbolName)) return;
+      
+      const { direction } = signal;
+      const orderSide = direction === 'long' ? 0 : 1;
+      const sideStr = direction === 'long' ? 'LONG' : 'SHORT';
+      
+      ui.addLog('entry', `[${symbolName}] ${sideStr} signal`);
+      
+      const orderData = {
+        accountId: rithmicAccountId,
+        symbol: symbolName,
+        exchange: contract.exchange || 'CME',
+        size: qty,
+        side: orderSide,
+      };
       
-    } catch (err) {
-      ui.addLog('error', `[${symbolName}] Failed to connect: ${err.message}`);
+      const entryResult = service.fastEntry(orderData);
+      if (entryResult.success) {
+        pm.registerEntry(entryResult, orderData, { tickSize, tickValue, contractId });
+      } else {
+        ui.addLog('error', `[${symbolName}] Entry failed: ${entryResult.error}`);
+      }
+    });
+  });
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // MARKET DATA FEED - Single connection, multiple subscriptions
+  // ═══════════════════════════════════════════════════════════════════════════
+  const marketFeed = new RithmicMarketDataFeed(service);
+  
+  marketFeed.on('connected', () => {
+    stats.connected = true;
+    ui.addLog('success', 'Market feed connected');
+    ui.render(stats);
+  });
+  
+  marketFeed.on('tick', (tick) => {
+    if (!running) return;
+    
+    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)) {
+        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,
+          timestamp: tick.timestamp || Date.now()
+        };
+        strategy.processTick(tickData);
+        
+        // Update price for position manager
+        service.emit('priceUpdate', {
+          symbol: symbolName,
+          price: tickData.price,
+          timestamp: tickData.timestamp,
+        });
+        break;
+      }
     }
+    
+    ui.render(stats);
+  });
+  
+  marketFeed.on('error', (err) => {
+    ui.addLog('error', `Feed error: ${err.message}`);
   });
   
-  // Wait for all symbols to initialize
-  await Promise.all(symbolPromises);
+  // Connect and subscribe
+  ui.render(stats);
+  ui.addLog('info', `MULTI-SYMBOL: ${contracts.length} symbols`);
+  
+  try {
+    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);
+        ui.addLog('success', `[${symbolName}] Subscribed`);
+      }
+    } else {
+      ui.addLog('error', 'Failed to connect market feed');
+    }
+  } catch (e) {
+    ui.addLog('error', `Connection error: ${e.message}`);
+  }
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // P&L UPDATES VIA WEBSOCKET
+  // ═══════════════════════════════════════════════════════════════════════════
+  if (typeof service.on === 'function') {
+    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);
+      }
+      stats.pnl = (stats.openPnl || 0) + (stats.closedPnl || 0);
+    });
+  }
   
-  // Keyboard handler for emergency stop
+  // ═══════════════════════════════════════════════════════════════════════════
+  // 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 = () => {
@@ -1569,18 +1653,7 @@ const launchMultiAlgo = async (service, account, contracts, config) => {
         emergencyStopInProgress = true;
         running = false;
         stopReason = 'manual';
-        
-        ui.addLog('warning', '████ EMERGENCY STOP - CLOSING ALL POSITIONS ████');
-        
-        // Close all positions on all symbols
-        for (const pm of positionManagers) {
-          try {
-            pm.closeAllPositions();
-          } catch (e) {}
-        }
-        
-        ui.addLog('info', 'All positions closed');
-        ui.render(stats);
+        await emergencyStopAll();
       }
     };
     process.stdin.on('keypress', onKey);
@@ -1592,6 +1665,11 @@ const launchMultiAlgo = async (service, account, contracts, config) => {
   
   const cleanupKeys = setupKeyHandler();
   
+  // UI refresh
+  const refreshInterval = setInterval(() => {
+    if (running) ui.render(stats);
+  }, 1000);
+  
   // Wait for stop
   await new Promise(resolve => {
     const check = setInterval(() => {
@@ -1602,40 +1680,44 @@ const launchMultiAlgo = async (service, account, contracts, config) => {
     }, 100);
   });
   
-  // Cleanup
-  for (const pm of positionManagers) {
+  // ═══════════════════════════════════════════════════════════════════════════
+  // CLEANUP
+  // ═══════════════════════════════════════════════════════════════════════════
+  clearInterval(refreshInterval);
+  
+  // Stop all position managers
+  for (const pm of Object.values(positionManagers)) {
     try { pm.stop(); } catch {}
   }
   
-  for (const feed of marketFeeds) {
-    try { await feed.disconnect(); } 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);
-    }
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
     process.stdin.resume();
   } catch {}
   
-  // Duration
+  // ═══════════════════════════════════════════════════════════════════════════
+  // 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);
-  stats.duration = hours > 0 
+  const duration = hours > 0 
     ? `${hours}h ${minutes}m ${seconds}s`
     : minutes > 0 
       ? `${minutes}m ${seconds}s`
       : `${seconds}s`;
   
-  // Summary with per-symbol breakdown
   console.log();
   console.log(chalk.cyan('═══════════════════════════════════════════════════════════════'));
-  console.log(chalk.cyan('                    MULTI-SYMBOL SESSION SUMMARY'));
+  console.log(chalk.cyan('                 MULTI-SYMBOL SESSION SUMMARY'));
   console.log(chalk.cyan('═══════════════════════════════════════════════════════════════'));
   console.log();
   
@@ -1647,8 +1729,10 @@ const launchMultiAlgo = async (service, account, contracts, config) => {
   }
   
   console.log();
-  console.log(chalk.white(`  TOTAL: ${stats.trades} trades | ${stats.wins}W/${stats.losses}L | Session P&L: ${stats.sessionPnl >= 0 ? chalk.green('$' + stats.sessionPnl.toFixed(2)) : chalk.red('$' + stats.sessionPnl.toFixed(2))}`));
-  console.log(chalk.white(`  Duration: ${stats.duration}`));
+  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('═══════════════════════════════════════════════════════════════'));