hedgequantx 2.9.136 → 2.9.138

package/package.json

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

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

@@ -0,0 +1,374 @@
+/**
+ * Multi-Symbol Executor - Trade up to 5 symbols in parallel
+ * Single TICKER_PLANT connection, multiple strategy instances
+ */
+const readline = require('readline');
+const { AlgoUI } = require('./ui');
+const { loadStrategy } = require('../../lib/m');
+const { MarketDataFeed } = require('../../lib/data');
+const smartLogs = require('../../lib/smart-logs');
+const { sessionLogger } = require('../../services/session-logger');
+
+/**
+ * Execute algo strategy on multiple symbols
+ * @param {Object} params - Execution parameters
+ * @param {Object} params.service - Rithmic trading service
+ * @param {Object} params.account - Account object
+ * @param {Array} params.contracts - Array of contract objects (max 5)
+ * @param {Object} params.config - Algo config (contracts, target, risk, showName)
+ * @param {Object} params.strategy - Strategy info object with id, name
+ * @param {Object} params.options - Optional: supervisionConfig, startSpinner
+ */
+const executeMultiSymbol = async ({ service, account, contracts, config, strategy: strategyInfo, options = {} }) => {
+  const { contractsPerSymbol, dailyTarget, maxRisk, showName } = config;
+  const { startSpinner } = options;
+  
+  const strategyId = strategyInfo?.id || 'hqx-2b';
+  const strategyName = strategyInfo?.name || 'HQX-2B';
+  const strategyModule = loadStrategy(strategyId);
+  const StrategyClass = strategyModule.M1;
+  
+  const accountName = showName 
+    ? (account.accountName || account.rithmicAccountId || account.accountId) 
+    : 'HQX *****';
+  
+  // Create strategy instance and stats for each symbol
+  const symbolData = new Map();
+  
+  for (const contract of contracts) {
+    const symbolCode = contract.symbol || contract.baseSymbol || contract.id;
+    const tickSize = contract.tickSize || 0.25;
+    
+    const strategy = new StrategyClass({ tickSize });
+    strategy.initialize(symbolCode, tickSize);
+    
+    symbolData.set(symbolCode, {
+      contract,
+      strategy,
+      tickSize,
+      symbolCode,
+      symbolName: contract.name || contract.baseSymbol || symbolCode,
+      stats: {
+        pnl: 0,
+        trades: 0,
+        wins: 0,
+        losses: 0,
+        tickCount: 0,
+        lastPrice: null,
+        position: 0
+      },
+      pendingOrder: false,
+      startingPnL: null
+    });
+    
+    // Forward signals
+    strategy.on('signal', async (signal) => {
+      await handleSignal(symbolCode, signal);
+    });
+    
+    strategy.on('log', (log) => {
+      const prefix = `[${symbolCode}] `;
+      ui.addLog(log.type === 'debug' ? 'debug' : 'analysis', prefix + log.message);
+    });
+  }
+  
+  // Aggregated stats
+  const globalStats = {
+    accountName,
+    symbols: contracts.map(c => c.baseSymbol || c.symbol).join(', '),
+    symbolCount: contracts.length,
+    qty: contractsPerSymbol,
+    target: dailyTarget,
+    risk: maxRisk,
+    pnl: 0,
+    trades: 0,
+    wins: 0,
+    losses: 0,
+    latency: 0,
+    connected: false,
+    startTime: Date.now()
+  };
+  
+  let running = true;
+  let stopReason = null;
+  
+  // UI setup
+  const ui = new AlgoUI({ 
+    subtitle: `${strategyName} - ${contracts.length} Symbols`, 
+    mode: 'multi-symbol' 
+  });
+  
+  smartLogs.setStrategy(strategyId);
+  
+  // Start session logger
+  const logFile = sessionLogger.start({
+    strategy: strategyId,
+    account: accountName,
+    symbol: globalStats.symbols,
+    contracts: contractsPerSymbol,
+    target: dailyTarget,
+    risk: maxRisk,
+    multiSymbol: true,
+    symbolCount: contracts.length
+  });
+  
+  sessionLogger.log('CONFIG', `Multi-symbol mode: ${contracts.length} symbols`);
+  for (const contract of contracts) {
+    sessionLogger.log('CONFIG', `Symbol: ${contract.symbol} exchange=${contract.exchange} tickSize=${contract.tickSize}`);
+  }
+  
+  if (startSpinner) startSpinner.succeed('Multi-symbol algo initialized');
+  
+  ui.addLog('system', `Strategy: ${strategyName} | Symbols: ${contracts.length}`);
+  ui.addLog('system', `Account: ${accountName}`);
+  for (const contract of contracts) {
+    ui.addLog('system', `  ${contract.symbol} - ${contract.name || contract.baseSymbol}`);
+  }
+  ui.addLog('risk', `Target: $${dailyTarget} | Risk: $${maxRisk} | Qty: ${contractsPerSymbol}/symbol`);
+  ui.addLog('system', 'Connecting to market data...');
+  
+  // Signal handler
+  const handleSignal = async (symbolCode, signal) => {
+    const data = symbolData.get(symbolCode);
+    if (!data) return;
+    
+    const dir = signal.direction?.toUpperCase() || 'UNKNOWN';
+    ui.addLog('signal', `[${symbolCode}] ${dir} @ ${signal.entry?.toFixed(2)} | Conf: ${((signal.confidence || 0) * 100).toFixed(0)}%`);
+    sessionLogger.signal(dir, signal.entry, signal.confidence, `[${symbolCode}]`);
+    
+    if (!running || data.pendingOrder || data.stats.position !== 0) {
+      ui.addLog('risk', `[${symbolCode}] Signal blocked - ${!running ? 'stopped' : data.pendingOrder ? 'order pending' : 'position open'}`);
+      return;
+    }
+    
+    // Place order
+    data.pendingOrder = true;
+    try {
+      const orderSide = signal.direction === 'long' ? 0 : 1;
+      const orderResult = await service.placeOrder({
+        accountId: account.rithmicAccountId || account.accountId,
+        symbol: symbolCode,
+        exchange: data.contract.exchange || 'CME',
+        type: 2,
+        side: orderSide,
+        size: contractsPerSymbol
+      });
+      
+      if (orderResult.success) {
+        data.stats.position = signal.direction === 'long' ? contractsPerSymbol : -contractsPerSymbol;
+        data.stats.trades++;
+        globalStats.trades++;
+        
+        ui.addLog('fill_' + (signal.direction === 'long' ? 'buy' : 'sell'), 
+          `[${symbolCode}] ${dir} ${contractsPerSymbol}x @ ${signal.entry?.toFixed(2)}`);
+        sessionLogger.trade('ENTRY', dir, signal.entry, contractsPerSymbol, `[${symbolCode}]`);
+        
+        // Bracket orders
+        if (signal.stopLoss && signal.takeProfit) {
+          await service.placeOrder({
+            accountId: account.rithmicAccountId || account.accountId,
+            symbol: symbolCode, exchange: data.contract.exchange || 'CME',
+            type: 4, side: signal.direction === 'long' ? 1 : 0,
+            size: contractsPerSymbol, price: signal.stopLoss
+          });
+          await service.placeOrder({
+            accountId: account.rithmicAccountId || account.accountId,
+            symbol: symbolCode, exchange: data.contract.exchange || 'CME',
+            type: 1, side: signal.direction === 'long' ? 1 : 0,
+            size: contractsPerSymbol, price: signal.takeProfit
+          });
+          ui.addLog('trade', `[${symbolCode}] SL: ${signal.stopLoss.toFixed(2)} | TP: ${signal.takeProfit.toFixed(2)}`);
+        }
+      } else {
+        ui.addLog('error', `[${symbolCode}] Order failed: ${orderResult.error}`);
+        sessionLogger.error(`[${symbolCode}] Order failed`, orderResult.error);
+      }
+    } catch (e) {
+      ui.addLog('error', `[${symbolCode}] Order error: ${e.message}`);
+    }
+    data.pendingOrder = false;
+  };
+  
+  // Market data feed (single connection for all symbols)
+  const marketFeed = new MarketDataFeed();
+  
+  let lastLogSecond = 0;
+  
+  marketFeed.on('tick', (tick) => {
+    const symbolCode = tick.symbol || tick.contractId;
+    const data = symbolData.get(symbolCode);
+    if (!data) return;
+    
+    data.stats.tickCount++;
+    const price = Number(tick.price) || Number(tick.tradePrice) || null;
+    const volume = Number(tick.volume) || Number(tick.size) || 1;
+    
+    if (data.stats.tickCount === 1) {
+      ui.addLog('connected', `[${symbolCode}] First tick @ ${price?.toFixed(2) || 'N/A'}`);
+    }
+    
+    data.stats.lastPrice = price;
+    
+    // Process tick through strategy
+    if (price && price > 0) {
+      data.strategy.processTick({
+        contractId: symbolCode,
+        price,
+        bid: Number(tick.bid) || null,
+        ask: Number(tick.ask) || null,
+        volume,
+        side: tick.side || 'unknown',
+        timestamp: tick.timestamp || Date.now()
+      });
+    }
+    
+    // Latency
+    if (tick.ssboe && tick.usecs !== undefined) {
+      const tickTimeMs = (tick.ssboe * 1000) + Math.floor(tick.usecs / 1000);
+      const latency = Date.now() - tickTimeMs;
+      if (latency >= 0 && latency < 5000) globalStats.latency = latency;
+    }
+  });
+  
+  // Log aggregated stats periodically
+  const logInterval = setInterval(() => {
+    const now = Math.floor(Date.now() / 1000);
+    if (now - lastLogSecond >= 60) {
+      lastLogSecond = now;
+      let totalTicks = 0;
+      let totalBars = 0;
+      for (const [sym, data] of symbolData) {
+        totalTicks += data.stats.tickCount;
+        const state = data.strategy.getAnalysisState?.(sym, data.stats.lastPrice);
+        totalBars += state?.barsProcessed || 0;
+      }
+      ui.addLog('debug', `Total: ${totalTicks} ticks | ${totalBars} bars | ${contracts.length} symbols`);
+      
+      // Log per-symbol state
+      for (const [sym, data] of symbolData) {
+        const state = data.strategy.getAnalysisState?.(sym, data.stats.lastPrice);
+        if (state?.ready) {
+          ui.addLog('analysis', `[${sym}] Zones: ${state.activeZones} | Swings: ${state.swingsDetected}`);
+        }
+      }
+    }
+  }, 5000);
+  
+  marketFeed.on('connected', () => { globalStats.connected = true; ui.addLog('connected', 'Market data connected'); });
+  marketFeed.on('error', (err) => ui.addLog('error', `Market: ${err.message}`));
+  marketFeed.on('disconnected', () => { globalStats.connected = false; ui.addLog('error', 'Market disconnected'); });
+  
+  // Connect and subscribe to all symbols
+  try {
+    const rithmicCredentials = service.getRithmicCredentials?.();
+    if (!rithmicCredentials) throw new Error('Rithmic credentials not available');
+    
+    if (service.disconnectTicker) await service.disconnectTicker();
+    await marketFeed.connect(rithmicCredentials);
+    
+    for (const contract of contracts) {
+      const symbolCode = contract.symbol || contract.baseSymbol;
+      await marketFeed.subscribe(symbolCode, contract.exchange || 'CME');
+      ui.addLog('system', `Subscribed: ${symbolCode}`);
+    }
+  } catch (e) {
+    ui.addLog('error', `Failed to connect: ${e.message}`);
+  }
+  
+  // P&L polling
+  const pollPnL = async () => {
+    try {
+      const accountResult = await service.getTradingAccounts();
+      if (accountResult.success && accountResult.accounts) {
+        const acc = accountResult.accounts.find(a => a.accountId === account.accountId);
+        if (acc && acc.profitAndLoss !== undefined) {
+          // For multi-symbol, we track total P&L
+          globalStats.pnl = acc.profitAndLoss;
+        }
+      }
+      
+      // Check positions per symbol
+      const posResult = await service.getPositions(account.accountId);
+      if (posResult.success && posResult.positions) {
+        for (const [sym, data] of symbolData) {
+          const pos = posResult.positions.find(p => (p.contractId || p.symbol || '').includes(sym));
+          data.stats.position = pos?.quantity || 0;
+        }
+      }
+      
+      // Risk checks
+      if (globalStats.pnl >= dailyTarget) {
+        stopReason = 'target'; running = false;
+        ui.addLog('fill_win', `TARGET REACHED! +$${globalStats.pnl.toFixed(2)}`);
+      } else if (globalStats.pnl <= -maxRisk) {
+        stopReason = 'risk'; running = false;
+        ui.addLog('fill_loss', `MAX RISK! -$${Math.abs(globalStats.pnl).toFixed(2)}`);
+      }
+    } catch (e) { /* silent */ }
+  };
+  
+  const refreshInterval = setInterval(() => { if (running) ui.render(globalStats); }, 100);
+  const pnlInterval = setInterval(() => { if (running) pollPnL(); }, 2000);
+  pollPnL();
+  
+  // Key handler
+  const setupKeyHandler = () => {
+    if (!process.stdin.isTTY) return null;
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    const onKey = (str, key) => {
+      const keyName = key?.name?.toLowerCase();
+      if (keyName === 'x' || (key?.ctrl && keyName === 'c')) {
+        running = false;
+        stopReason = 'manual';
+      }
+    };
+    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
+  clearInterval(refreshInterval);
+  clearInterval(pnlInterval);
+  clearInterval(logInterval);
+  await marketFeed.disconnect();
+  if (cleanupKeys) cleanupKeys();
+  ui.cleanup();
+  if (process.stdin.isTTY) process.stdin.setRawMode(false);
+  process.stdin.resume();
+  
+  // Summary
+  const durationMs = Date.now() - globalStats.startTime;
+  const h = Math.floor(durationMs / 3600000);
+  const m = Math.floor((durationMs % 3600000) / 60000);
+  const s = Math.floor((durationMs % 60000) / 1000);
+  globalStats.duration = h > 0 ? `${h}h ${m}m ${s}s` : m > 0 ? `${m}m ${s}s` : `${s}s`;
+  
+  sessionLogger.end(globalStats, stopReason?.toUpperCase() || 'MANUAL');
+  
+  console.log('\n');
+  console.log('  Multi-Symbol Session Summary');
+  console.log('  ────────────────────────────');
+  console.log(`  Symbols: ${globalStats.symbols}`);
+  console.log(`  Duration: ${globalStats.duration}`);
+  console.log(`  Trades: ${globalStats.trades} | P&L: $${globalStats.pnl.toFixed(2)}`);
+  console.log(`  Stop: ${stopReason || 'manual'}`);
+  console.log();
+  
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  await new Promise(resolve => {
+    rl.question('  Press Enter to return to menu...', () => { rl.close(); resolve(); });
+  });
+};
+
+module.exports = { executeMultiSymbol };

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

@@ -11,12 +11,27 @@ const { prompts } = require('../../utils');
 const { getContractDescription } = require('../../config');
 const { checkMarketHours } = require('../../services/rithmic/market');
 const { executeAlgo } = require('./algo-executor');
+const { executeMultiSymbol } = require('./multi-symbol-executor');
 const { getActiveAgentCount, getSupervisionConfig, getActiveAgents } = require('../ai-agents');
 const { runPreflightCheck, formatPreflightResults, getPreflightSummary } = require('../../services/ai-supervision');
 const { getAvailableStrategies } = require('../../lib/m');
 const { getLastOneAccountConfig, saveOneAccountConfig } = require('../../services/algo-config');
 
+// Popular symbols for sorting
+const POPULAR_PREFIXES = ['ES', 'NQ', 'MES', 'MNQ', 'M2K', 'RTY', 'YM', 'MYM', 'NKD', 'GC', 'SI', 'CL'];
 
+const sortContracts = (contracts) => {
+  return contracts.sort((a, b) => {
+    const baseA = a.baseSymbol || a.symbol || '';
+    const baseB = b.baseSymbol || b.symbol || '';
+    const idxA = POPULAR_PREFIXES.findIndex(p => baseA === p || baseA.startsWith(p));
+    const idxB = POPULAR_PREFIXES.findIndex(p => baseB === p || baseB.startsWith(p));
+    if (idxA !== -1 && idxB !== -1) return idxA - idxB;
+    if (idxA !== -1) return -1;
+    if (idxB !== -1) return 1;
+    return baseA.localeCompare(baseB);
+  });
+};
 
 /**
  * One Account Menu
@@ -135,6 +150,9 @@ const oneAccountMenu = async (service) => {
   }
   
   // If no saved config used, go through normal selection
+  let isMultiSymbol = false;
+  let multiContracts = [];
+  
   if (!selectedAccount) {
     // Select account - display RAW API fields
     const options = activeAccounts.map(acc => {
@@ -156,32 +174,52 @@ const oneAccountMenu = async (service) => {
     // Use the service attached to the account (from getAllAccounts), fallback to getServiceForAccount
     accountService = selectedAccount.service || connections.getServiceForAccount(selectedAccount.accountId) || service;
     
-    // Select symbol
-    contract = await selectSymbol(accountService, selectedAccount);
-    if (!contract) return;
+    // Ask for trading mode
+    const modeOptions = [
+      { label: 'Single Symbol', value: 'single' },
+      { label: 'Multi-Symbol (up to 5)', value: 'multi' },
+      { label: chalk.gray('< Back'), value: 'back' }
+    ];
+    const mode = await prompts.selectOption('Trading Mode:', modeOptions);
+    if (mode === 'back' || !mode) return;
+    
+    isMultiSymbol = mode === 'multi';
+    
+    if (isMultiSymbol) {
+      // Multi-symbol selection
+      multiContracts = await selectMultipleSymbols(accountService, selectedAccount);
+      if (!multiContracts || multiContracts.length === 0) return;
+      contract = multiContracts[0]; // For strategy selection display
+    } else {
+      // Single symbol selection
+      contract = await selectSymbol(accountService, selectedAccount);
+      if (!contract) return;
+    }
     
     // Select strategy
     strategy = await selectStrategy();
     if (!strategy) return;
     
     // Configure algo
-    config = await configureAlgo(selectedAccount, contract, strategy);
+    config = await configureAlgo(selectedAccount, contract, strategy, isMultiSymbol);
     if (!config) return;
     
-    // Save config for next time (include baseSymbol for stable matching across contract rolls)
-    saveOneAccountConfig({
-      accountId: selectedAccount.accountId || selectedAccount.rithmicAccountId,
-      accountName: selectedAccount.accountName || selectedAccount.rithmicAccountId || selectedAccount.accountId,
-      propfirm: selectedAccount.propfirm || selectedAccount.platform || 'Unknown',
-      symbol: contract.symbol,
-      baseSymbol: contract.baseSymbol,
-      strategyId: strategy.id,
-      strategyName: strategy.name,
-      contracts: config.contracts,
-      dailyTarget: config.dailyTarget,
-      maxRisk: config.maxRisk,
-      showName: config.showName
-    });
+    // Save config for next time (only for single symbol mode)
+    if (!isMultiSymbol) {
+      saveOneAccountConfig({
+        accountId: selectedAccount.accountId || selectedAccount.rithmicAccountId,
+        accountName: selectedAccount.accountName || selectedAccount.rithmicAccountId || selectedAccount.accountId,
+        propfirm: selectedAccount.propfirm || selectedAccount.platform || 'Unknown',
+        symbol: contract.symbol,
+        baseSymbol: contract.baseSymbol,
+        strategyId: strategy.id,
+        strategyName: strategy.name,
+        contracts: config.contracts,
+        dailyTarget: config.dailyTarget,
+        maxRisk: config.maxRisk,
+        showName: config.showName
+      });
+    }
   }
   
   // Check for AI Supervision BEFORE asking to start
@@ -235,20 +273,33 @@ const oneAccountMenu = async (service) => {
   
   const startSpinner = ora({ text: 'Initializing algo trading...', color: 'cyan' }).start();
   
-  await executeAlgo({
-    service: accountService,
-    account: selectedAccount,
-    contract,
-    config,
-    strategy,
-    options: { supervisionConfig, startSpinner }
-  });
+  if (isMultiSymbol && multiContracts.length > 0) {
+    // Multi-symbol execution
+    await executeMultiSymbol({
+      service: accountService,
+      account: selectedAccount,
+      contracts: multiContracts,
+      config,
+      strategy,
+      options: { supervisionConfig, startSpinner }
+    });
+  } else {
+    // Single symbol execution
+    await executeAlgo({
+      service: accountService,
+      account: selectedAccount,
+      contract,
+      config,
+      strategy,
+      options: { supervisionConfig, startSpinner }
+    });
+  }
 };
 
 /**
- * Symbol selection - sorted with popular indices first
+ * Multi-symbol selection - select up to 5 symbols
  */
-const selectSymbol = async (service, account) => {
+const selectMultipleSymbols = async (service, account) => {
   const spinner = ora({ text: 'Loading symbols...', color: 'yellow' }).start();
   
   // Ensure we have a logged-in service
@@ -267,29 +318,94 @@ const selectSymbol = async (service, account) => {
     return null;
   }
   
-  let contracts = contractsResult.contracts;
+  const contracts = sortContracts(contractsResult.contracts);
+  spinner.succeed(`Found ${contracts.length} contracts`);
   
-  // Sort: Popular indices first (ES, NQ, MES, MNQ, RTY, YM, etc.)
-  const popularPrefixes = ['ES', 'NQ', 'MES', 'MNQ', 'M2K', 'RTY', 'YM', 'MYM', 'NKD', 'GC', 'SI', 'CL'];
+  console.log();
+  console.log(chalk.cyan('  Select up to 5 symbols (one at a time)'));
+  console.log(chalk.gray('  Select "Done" when finished'));
+  console.log();
   
-  contracts.sort((a, b) => {
-    const baseA = a.baseSymbol || a.symbol || '';
-    const baseB = b.baseSymbol || b.symbol || '';
+  const selectedContracts = [];
+  const maxSymbols = 5;
+  
+  while (selectedContracts.length < maxSymbols) {
+    const remaining = maxSymbols - selectedContracts.length;
+    const selectedSymbols = selectedContracts.map(c => c.symbol);
     
-    // Check if baseSymbol matches popular prefixes
-    const idxA = popularPrefixes.findIndex(p => baseA === p || baseA.startsWith(p));
-    const idxB = popularPrefixes.findIndex(p => baseB === p || baseB.startsWith(p));
+    // Filter out already selected
+    const availableContracts = contracts.filter(c => !selectedSymbols.includes(c.symbol));
     
-    // Both are popular - sort by popularity order
-    if (idxA !== -1 && idxB !== -1) return idxA - idxB;
-    // Only A is popular - A first
-    if (idxA !== -1) return -1;
-    // Only B is popular - B first
-    if (idxB !== -1) return 1;
-    // Neither - alphabetical by baseSymbol
-    return baseA.localeCompare(baseB);
-  });
+    const options = availableContracts.map(c => {
+      const desc = getContractDescription(c.baseSymbol || c.name);
+      const isMicro = desc.toLowerCase().includes('micro');
+      const label = isMicro 
+        ? `${c.symbol} - ${chalk.cyan(desc)} (${c.exchange})`
+        : `${c.symbol} - ${desc} (${c.exchange})`;
+      return { label, value: c };
+    });
+    
+    // Add done/back options
+    if (selectedContracts.length > 0) {
+      options.unshift({ label: chalk.green(`✓ Done (${selectedContracts.length} selected)`), value: 'done' });
+    }
+    options.push({ label: chalk.gray('< Cancel'), value: 'back' });
+    
+    const promptText = selectedContracts.length === 0 
+      ? `Select Symbol 1/${maxSymbols}:` 
+      : `Select Symbol ${selectedContracts.length + 1}/${maxSymbols} (${remaining} remaining):`;
+    
+    const selection = await prompts.selectOption(chalk.yellow(promptText), options);
+    
+    if (selection === 'back' || selection === null) {
+      return null;
+    }
+    if (selection === 'done') {
+      break;
+    }
+    
+    selectedContracts.push(selection);
+    console.log(chalk.green(`  ✓ Added: ${selection.symbol}`));
+  }
+  
+  if (selectedContracts.length === 0) {
+    return null;
+  }
+  
+  // Display summary
+  console.log();
+  console.log(chalk.cyan(`  Selected ${selectedContracts.length} symbol(s):`));
+  for (const c of selectedContracts) {
+    console.log(chalk.white(`    - ${c.symbol} (${c.baseSymbol || c.name})`));
+  }
+  console.log();
+  
+  return selectedContracts;
+};
+
+/**
+ * Symbol selection - sorted with popular indices first
+ */
+const selectSymbol = async (service, account) => {
+  const spinner = ora({ text: 'Loading symbols...', color: 'yellow' }).start();
   
+  // Ensure we have a logged-in service
+  if (!service.loginInfo && service.credentials) {
+    spinner.text = 'Reconnecting to broker...';
+    const loginResult = await service.login(service.credentials.username, service.credentials.password);
+    if (!loginResult.success) {
+      spinner.fail(`Login failed: ${loginResult.error}`);
+      return null;
+    }
+  }
+  
+  const contractsResult = await service.getContracts();
+  if (!contractsResult.success || !contractsResult.contracts?.length) {
+    spinner.fail(`Failed to load contracts: ${contractsResult.error || 'No contracts'}`);
+    return null;
+  }
+  
+  const contracts = sortContracts(contractsResult.contracts);
   spinner.succeed(`Found ${contracts.length} contracts`);
   
   // Display sorted contracts with full description
@@ -339,13 +455,17 @@ const selectStrategy = async () => {
 /**
  * Configure algo
  */
-const configureAlgo = async (account, contract, strategy) => {
+const configureAlgo = async (account, contract, strategy, isMultiSymbol = false) => {
   console.log();
   console.log(chalk.cyan('  Configure Algo Parameters'));
   console.log(chalk.gray(`  Strategy: ${strategy.name}`));
+  if (isMultiSymbol) {
+    console.log(chalk.gray(`  Mode: Multi-Symbol`));
+  }
   console.log();
   
-  const contracts = await prompts.numberInput('Number of contracts:', 1, 1, 10);
+  const contractsLabel = isMultiSymbol ? 'Contracts per symbol:' : 'Number of contracts:';
+  const contracts = await prompts.numberInput(contractsLabel, 1, 1, 10);
   if (contracts === null) return null;
   
   const dailyTarget = await prompts.numberInput('Daily target ($):', 1000, 1, 10000);
@@ -357,6 +477,11 @@ const configureAlgo = async (account, contract, strategy) => {
   const showName = await prompts.confirmPrompt('Show account name?', false);
   if (showName === null) return null;
   
+  // Return different config shape for multi-symbol
+  if (isMultiSymbol) {
+    return { contractsPerSymbol: contracts, dailyTarget, maxRisk, showName };
+  }
+  
   return { contracts, dailyTarget, maxRisk, showName };
 };
 

package/src/pages/algo/ui.js

@@ -185,17 +185,21 @@ class AlgoUI {
     
     this._line(chalk.cyan(GT));
     
-    // Row 1: Account | Symbol
+    // Row 1: Account | Symbol(s)
     const accountName = String(stats.accountName || 'N/A').substring(0, 40);
-    const symbol = String(stats.symbol || 'N/A').substring(0, 35);
+    const isMultiSymbol = stats.symbolCount && stats.symbolCount > 1;
+    const symbolDisplay = isMultiSymbol 
+      ? `${stats.symbolCount} symbols` 
+      : String(stats.symbol || stats.symbols || 'N/A').substring(0, 35);
     const r1c1 = buildCell('Account', accountName, chalk.cyan, colL);
-    const r1c2 = buildCell('Symbol', symbol, chalk.yellow, colR);
+    const r1c2 = buildCell(isMultiSymbol ? 'Symbols' : 'Symbol', symbolDisplay, chalk.yellow, colR);
     row(r1c1.padded, r1c2.padded);
     
     this._line(chalk.cyan(GM));
     
     // Row 2: Qty | P&L
-    const r2c1 = buildCell('Qty', (stats.qty || '1').toString(), chalk.cyan, colL);
+    const qtyLabel = isMultiSymbol ? 'Qty/Symbol' : 'Qty';
+    const r2c1 = buildCell(qtyLabel, (stats.qty || '1').toString(), chalk.cyan, colL);
     const r2c2 = buildCell('P&L', pnlStr, pnlColor, colR);
     row(r2c1.padded, r2c2.padded);