hedgequantx 2.9.19 → 2.9.20

package/src/pages/algo/index.js

@@ -3,15 +3,13 @@
  */
 
 const chalk = require('chalk');
-const { getLogoWidth, centerText, displayBanner , clearScreen } = require('../../ui');
+const { getSeparator } = require('../../ui');
 const { logger, prompts } = require('../../utils');
-const { getActiveProvider } = require('../ai-agents');
 
 const log = logger.scope('AlgoMenu');
 
 const { oneAccountMenu } = require('./one-account');
 const { copyTradingMenu } = require('./copy-trading');
-const { customStrategyMenu } = require('./custom-strategy');
 
 /**
  * Algo Trading Menu
@@ -20,94 +18,39 @@ const algoTradingMenu = async (service) => {
   log.info('Algo Trading menu opened');
   
   try {
-    // Clear screen and show banner
-    clearScreen();
-    displayBanner();
-    
-    const boxWidth = getLogoWidth();
-    const W = boxWidth - 2;
-    
-    // Check if AI agent is connected
-    const aiProvider = getActiveProvider();
-    const hasAI = !!aiProvider;
-    
-    // Draw menu rectangle
-    console.log(chalk.cyan('╔' + '═'.repeat(W) + '╗'));
-    console.log(chalk.cyan('║') + chalk.magenta.bold(centerText('ALGO-TRADING', W)) + chalk.cyan('║'));
-    console.log(chalk.cyan('╠' + '═'.repeat(W) + '╣'));
-    
-    // 2 or 3 columns layout based on AI availability
-    const col1 = '[1] ONE ACCOUNT';
-    const col2 = '[2] COPY TRADING';
-    const col3 = hasAI ? '[3] CUSTOM STRATEGY' : '';
-    
-    if (hasAI) {
-      // 3 columns
-      const colWidth = Math.floor(W / 3);
-      const lastColWidth = W - 2 * colWidth;
-      
-      const pad1 = Math.floor((colWidth - col1.length) / 2);
-      const pad2 = Math.floor((colWidth - col2.length) / 2);
-      const pad3 = Math.floor((lastColWidth - col3.length) / 2);
-      
-      const col1Str = ' '.repeat(pad1) + chalk.cyan(col1) + ' '.repeat(colWidth - col1.length - pad1);
-      const col2Str = ' '.repeat(pad2) + chalk.yellow(col2) + ' '.repeat(colWidth - col2.length - pad2);
-      const col3Str = ' '.repeat(pad3) + chalk.green(col3) + ' '.repeat(lastColWidth - col3.length - pad3);
-      
-      console.log(chalk.cyan('║') + col1Str + col2Str + col3Str + chalk.cyan('║'));
-    } else {
-      // 2 columns only (no AI connected)
-      const colWidth = Math.floor(W / 2);
-      const pad1 = Math.floor((colWidth - col1.length) / 2);
-      const pad2 = Math.floor((W - colWidth - col2.length) / 2);
-      
-      const col1Str = ' '.repeat(pad1) + chalk.cyan(col1) + ' '.repeat(colWidth - col1.length - pad1);
-      const col2Str = ' '.repeat(pad2) + chalk.yellow(col2) + ' '.repeat(W - colWidth - col2.length - pad2);
-      
-      console.log(chalk.cyan('║') + col1Str + col2Str + chalk.cyan('║'));
-    }
-    
-    console.log(chalk.cyan('╠' + '─'.repeat(W) + '╣'));
-    console.log(chalk.cyan('║') + chalk.red(centerText('[B] BACK', W)) + chalk.cyan('║'));
-    console.log(chalk.cyan('╚' + '═'.repeat(W) + '╝'));
+    console.log();
+    console.log(chalk.gray(getSeparator()));
+    console.log(chalk.yellow.bold('  Algo-Trading'));
+    console.log(chalk.gray(getSeparator()));
+    console.log();
 
-    const promptText = hasAI ? 'SELECT (1/2/3/B): ' : 'SELECT (1/2/B): ';
-    const input = await prompts.textInput(chalk.cyan(promptText));
-    const choice = (input || '').toLowerCase().trim();
+    const action = await prompts.selectOption(chalk.yellow('Select Mode:'), [
+      { value: 'one_account', label: 'One Account' },
+      { value: 'copy_trading', label: 'Copy Trading' },
+      { value: 'back', label: '< Back' }
+    ]);
 
-    log.debug('Algo mode selected', { choice });
+    log.debug('Algo mode selected', { action });
 
-    if (choice === 'b' || choice === '') {
+    if (!action || action === 'back') {
       return 'back';
     }
 
-    switch (choice) {
-      case '1':
+    switch (action) {
+      case 'one_account':
         log.info('Starting One Account mode');
         await oneAccountMenu(service);
         break;
-      case '2':
+      case 'copy_trading':
         log.info('Starting Copy Trading mode');
         await copyTradingMenu();
         break;
-      case '3':
-        if (hasAI) {
-          log.info('Starting Custom Strategy mode');
-          await customStrategyMenu(service);
-        } else {
-          console.log(chalk.red('  INVALID OPTION'));
-          await new Promise(r => setTimeout(r, 1000));
-        }
-        break;
-      default:
-        console.log(chalk.red('  INVALID OPTION'));
-        await new Promise(r => setTimeout(r, 1000));
     }
     
-    return choice;
+    return action;
   } catch (err) {
     log.error('Algo menu error:', err.message);
-    console.log(chalk.red(`  ERROR: ${err.message.toUpperCase()}`));
+    console.log(chalk.red(`  Error: ${err.message}`));
     await prompts.waitForEnter();
     return 'back';
   }

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

@@ -1,18 +1,37 @@
 /**
- * One Account Mode - HQX Ultra Scalping
- * Supports multi-agent AI supervision
+ * One Account Mode - HQX Algo Trading with Strategy Selection
  */
 
 const chalk = require('chalk');
 const ora = require('ora');
+const readline = require('readline');
 
 const { connections } = require('../../services');
+const { AlgoUI, renderSessionSummary } = require('./ui');
 const { prompts } = require('../../utils');
 const { checkMarketHours } = require('../../services/rithmic/market');
-const { executeAlgo } = require('./algo-executor');
-const { getActiveAgentCount, getSupervisionConfig, getActiveAgents } = require('../ai-agents');
-const { runPreflightCheck, formatPreflightResults, getPreflightSummary } = require('../../services/ai-supervision');
 
+// Strategy Registry & Market Data
+const { getAvailableStrategies, loadStrategy, getStrategy } = require('../../lib/m');
+const { MarketDataFeed } = require('../../lib/data');
+
+
+/**
+ * Strategy Selection
+ * @returns {Promise<string|null>} Selected strategy ID or null
+ */
+const selectStrategy = async () => {
+  const strategies = getAvailableStrategies();
+  
+  const options = strategies.map(s => ({
+    label: s.id === 'ultra-scalping' ? 'HQX Scalping' : 'HQX Sweep',
+    value: s.id
+  }));
+  options.push({ label: chalk.gray('< Back'), value: 'back' });
+  
+  const selected = await prompts.selectOption('Select Strategy:', options);
+  return selected === 'back' ? null : selected;
+};
 
 
 /**
@@ -74,60 +93,15 @@ const oneAccountMenu = async (service) => {
   const contract = await selectSymbol(accountService, selectedAccount);
   if (!contract) return;
   
+  // Select strategy
+  const strategyId = await selectStrategy();
+  if (!strategyId) return;
+  
   // Configure algo
-  const config = await configureAlgo(selectedAccount, contract);
+  const config = await configureAlgo(selectedAccount, contract, strategyId);
   if (!config) return;
   
-  // Check for AI Supervision
-  const agentCount = getActiveAgentCount();
-  let supervisionConfig = null;
-  
-  if (agentCount > 0) {
-    console.log();
-    console.log(chalk.cyan(`  ${agentCount} AI Agent(s) available for supervision`));
-    const enableAI = await prompts.confirmPrompt('Enable AI Supervision?', true);
-    
-    if (enableAI) {
-      // Run pre-flight check - ALL agents must pass
-      console.log();
-      console.log(chalk.yellow('  Running AI pre-flight check...'));
-      console.log();
-      
-      const agents = getActiveAgents();
-      const preflightResults = await runPreflightCheck(agents);
-      
-      // Display results
-      const lines = formatPreflightResults(preflightResults, 60);
-      for (const line of lines) {
-        console.log(line);
-      }
-      
-      const summary = getPreflightSummary(preflightResults);
-      console.log();
-      console.log(`  ${summary.text}`);
-      console.log();
-      
-      if (!preflightResults.success) {
-        console.log(chalk.red('  Cannot start algo - fix agent connections first.'));
-        await prompts.waitForEnter();
-        return;
-      }
-      
-      supervisionConfig = getSupervisionConfig();
-      console.log(chalk.green(`  ✓ AI Supervision ready with ${agentCount} agent(s)`));
-      
-      const proceedWithAI = await prompts.confirmPrompt('Start algo with AI supervision?', true);
-      if (!proceedWithAI) return;
-    }
-  }
-  
-  await executeAlgo({
-    service: accountService,
-    account: selectedAccount,
-    contract,
-    config,
-    options: { supervisionConfig }
-  });
+  await launchAlgo(accountService, selectedAccount, contract, config, strategyId);
 };
 
 /**
@@ -182,9 +156,12 @@ const selectSymbol = async (service, account) => {
 /**
  * Configure algo
  */
-const configureAlgo = async (account, contract) => {
+const configureAlgo = async (account, contract, strategyId) => {
+  const strategyInfo = getStrategy(strategyId);
+  
   console.log();
   console.log(chalk.cyan('  Configure Algo Parameters'));
+  console.log(chalk.gray(`  Strategy: ${strategyInfo.name}`));
   console.log();
   
   const contracts = await prompts.numberInput('Number of contracts:', 1, 1, 10);
@@ -205,4 +182,292 @@ const configureAlgo = async (account, contract) => {
   return { contracts, dailyTarget, maxRisk, showName };
 };
 
+/**
+ * Launch algo trading - Dynamic Strategy Loading
+ * Real-time market data + Strategy signals + Auto order execution
+ */
+const launchAlgo = async (service, account, contract, config, strategyId) => {
+  const { contracts, dailyTarget, maxRisk, showName } = config;
+  
+  // Load strategy dynamically
+  const strategyInfo = getStrategy(strategyId);
+  const strategyModule = loadStrategy(strategyId);
+  
+  // Use RAW API fields
+  const accountName = showName 
+    ? (account.accountName || account.rithmicAccountId || account.accountId) 
+    : 'HQX *****';
+  const symbolName = contract.name;
+  const contractId = contract.id;
+  const connectionType = account.platform || 'Rithmic';
+  const tickSize = contract.tickSize || 0.25;
+  
+  const ui = new AlgoUI({ subtitle: strategyInfo.name, mode: 'one-account' });
+  
+  const stats = {
+    accountName,
+    symbol: symbolName,
+    qty: contracts,
+    target: dailyTarget,
+    risk: maxRisk,
+    propfirm: account.propfirm || 'Unknown',
+    platform: connectionType,
+    pnl: 0,
+    trades: 0,
+    wins: 0,
+    losses: 0,
+    latency: 0,
+    connected: false,
+    startTime: Date.now()
+  };
+  
+  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;
+  
+  // Initialize Strategy dynamically
+  const strategy = new strategyModule.M1({ tickSize });
+  strategy.initialize(contractId, tickSize);
+  
+  // Initialize Market Data Feed
+  const marketFeed = new MarketDataFeed({ propfirm: account.propfirm });
+  
+  // Log startup
+  ui.addLog('info', `Strategy: ${strategyInfo.name}`);
+  ui.addLog('info', `Connection: ${connectionType}`);
+  ui.addLog('info', `Account: ${accountName}`);
+  ui.addLog('info', `Symbol: ${symbolName} | Qty: ${contracts}`);
+  ui.addLog('info', `Target: $${dailyTarget} | Max Risk: $${maxRisk}`);
+  ui.addLog('info', `Params: ${strategyInfo.params.stopTicks}t stop, ${strategyInfo.params.targetTicks}t target (${strategyInfo.params.riskReward})`);
+  ui.addLog('info', 'Connecting to market data...');
+  
+  // Handle strategy signals
+  strategy.on('signal', async (signal) => {
+    if (!running || pendingOrder || currentPosition !== 0) return;
+    
+    const { side, direction, entry, stopLoss, takeProfit, confidence } = signal;
+    
+    ui.addLog('signal', `${direction.toUpperCase()} signal @ ${entry.toFixed(2)} (${(confidence * 100).toFixed(0)}%)`);
+    
+    // Place order via API
+    pendingOrder = true;
+    try {
+      const orderSide = direction === 'long' ? 0 : 1; // 0=Buy, 1=Sell
+      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++;
+        ui.addLog('trade', `OPENED ${direction.toUpperCase()} ${contracts}x @ market`);
+        
+        // Place bracket orders (SL/TP)
+        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
+          });
+          
+          ui.addLog('info', `SL: ${stopLoss.toFixed(2)} | TP: ${takeProfit.toFixed(2)}`);
+        }
+      } else {
+        ui.addLog('error', `Order failed: ${orderResult.error}`);
+      }
+    } catch (e) {
+      ui.addLog('error', `Order error: ${e.message}`);
+    }
+    pendingOrder = false;
+  });
+  
+  // Handle market data ticks
+  marketFeed.on('tick', (tick) => {
+    tickCount++;
+    const latencyStart = Date.now();
+    
+    // Feed tick to strategy
+    strategy.processTick({
+      contractId: tick.contractId || contractId,
+      price: tick.price,
+      bid: tick.bid,
+      ask: tick.ask,
+      volume: tick.volume || 1,
+      side: tick.lastTradeSide || 'unknown',
+      timestamp: tick.timestamp || Date.now()
+    });
+    
+    stats.latency = Date.now() - latencyStart;
+    
+    // Log every 100th tick to show activity
+    if (tickCount % 100 === 0) {
+      ui.addLog('info', `Tick #${tickCount} @ ${tick.price?.toFixed(2) || 'N/A'}`);
+    }
+  });
+  
+  marketFeed.on('connected', () => {
+    stats.connected = true;
+    ui.addLog('success', 'Market data connected!');
+  });
+  
+  marketFeed.on('error', (err) => {
+    ui.addLog('error', `Market: ${err.message}`);
+  });
+  
+  marketFeed.on('disconnected', () => {
+    stats.connected = false;
+    ui.addLog('error', 'Market data disconnected');
+  });
+  
+  // Connect to market data
+  try {
+    const token = service.token || service.getToken?.();
+    const propfirmKey = (account.propfirm || 'topstep').toLowerCase().replace(/\s+/g, '_');
+    await marketFeed.connect(token, propfirmKey, contractId);
+    await marketFeed.subscribe(symbolName, contractId);
+  } catch (e) {
+    ui.addLog('error', `Failed to connect: ${e.message}`);
+  }
+  
+  // Poll account P&L from API
+  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) {
+          if (startingPnL === null) startingPnL = acc.profitAndLoss;
+          stats.pnl = acc.profitAndLoss - startingPnL;
+          
+          // Record trade result in strategy
+          if (stats.pnl !== 0) {
+            strategy.recordTradeResult(stats.pnl);
+          }
+        }
+      }
+      
+      // Check positions
+      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);
+        });
+        
+        if (pos && pos.quantity !== 0) {
+          currentPosition = pos.quantity;
+          const side = pos.quantity > 0 ? 'LONG' : 'SHORT';
+          const pnl = pos.profitAndLoss || 0;
+          
+          // Check if position closed (win/loss)
+          if (pnl > 0) stats.wins = Math.max(stats.wins, 1);
+          else if (pnl < 0) stats.losses = Math.max(stats.losses, 1);
+        } else {
+          currentPosition = 0;
+        }
+      }
+      
+      // Check target/risk
+      if (stats.pnl >= dailyTarget) {
+        stopReason = 'target';
+        running = false;
+        ui.addLog('success', `TARGET REACHED! +$${stats.pnl.toFixed(2)}`);
+      } else if (stats.pnl <= -maxRisk) {
+        stopReason = 'risk';
+        running = false;
+        ui.addLog('error', `MAX RISK! -$${Math.abs(stats.pnl).toFixed(2)}`);
+      }
+    } catch (e) {
+      // Silently handle polling errors
+    }
+  };
+  
+  // Start polling and UI refresh
+  const refreshInterval = setInterval(() => { if (running) ui.render(stats); }, 250);
+  const pnlInterval = setInterval(() => { if (running) pollPnL(); }, 2000);
+  pollPnL(); // Initial poll
+  
+  // Keyboard handler
+  const setupKeyHandler = () => {
+    if (!process.stdin.isTTY) return;
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    
+    const onKey = (str, key) => {
+      if (key && (key.name === 'x' || key.name === 'X' || (key.ctrl && key.name === '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);
+  await marketFeed.disconnect();
+  if (cleanupKeys) cleanupKeys();
+  ui.cleanup();
+  
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(false);
+  }
+  process.stdin.resume();
+  
+  // 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);
+  
+  console.log('\n  Returning to menu in 3 seconds...');
+  await new Promise(resolve => setTimeout(resolve, 3000));
+};
+
 module.exports = { oneAccountMenu };

package/src/pages/algo/ui.js

@@ -127,9 +127,9 @@ class AlgoUI {
     
     // Separator + title
     this._line(chalk.cyan(BOX.ML + BOX.H.repeat(W) + BOX.MR));
-    this._line(chalk.cyan(BOX.V) + chalk.yellow(center(`PROP FUTURES ALGO TRADING  V${version}`, W)) + chalk.cyan(BOX.V));
+    this._line(chalk.cyan(BOX.V) + chalk.white(center(`Prop Futures Algo Trading  v${version}`, W)) + chalk.cyan(BOX.V));
     this._line(chalk.cyan(BOX.ML + BOX.H.repeat(W) + BOX.MR));
-    this._line(chalk.cyan(BOX.V) + chalk.yellow(center((this.config.subtitle || 'HQX ALGO TRADING').toUpperCase(), W)) + chalk.cyan(BOX.V));
+    this._line(chalk.cyan(BOX.V) + chalk.yellow(center(this.config.subtitle || 'HQX Algo Trading', W)) + chalk.cyan(BOX.V));
   }
 
   _drawStats(stats) {
@@ -293,7 +293,7 @@ class AlgoUI {
     const visible = logs.slice(-maxLogs).reverse();
     
     if (visible.length === 0) {
-      this._line(chalk.cyan(BOX.V) + chalk.gray(fitToWidth(' AWAITING MARKET SIGNALS...', W)) + chalk.cyan(BOX.V));
+      this._line(chalk.cyan(BOX.V) + chalk.gray(fitToWidth(' Awaiting market signals...', W)) + chalk.cyan(BOX.V));
       for (let i = 0; i < maxLogs - 1; i++) {
         this._line(chalk.cyan(BOX.V) + ' '.repeat(W) + chalk.cyan(BOX.V));
       }
@@ -355,11 +355,11 @@ const checkMarketStatus = () => {
   const ctHour = (utcHour - ctOffset + 24) % 24;
   const ctDay = utcHour < ctOffset ? (utcDay + 6) % 7 : utcDay;
 
-  if (ctDay === 6) return { isOpen: false, message: 'MARKET CLOSED (SATURDAY)' };
-  if (ctDay === 0 && ctHour < 17) return { isOpen: false, message: 'MARKET OPENS SUNDAY 5:00 PM CT' };
-  if (ctDay === 5 && ctHour >= 16) return { isOpen: false, message: 'MARKET CLOSED (FRIDAY AFTER 4PM CT)' };
-  if (ctHour === 16 && ctDay >= 1 && ctDay <= 4) return { isOpen: false, message: 'DAILY MAINTENANCE' };
-  return { isOpen: true, message: 'MARKET OPEN' };
+  if (ctDay === 6) return { isOpen: false, message: 'Market closed (Saturday)' };
+  if (ctDay === 0 && ctHour < 17) return { isOpen: false, message: 'Market opens Sunday 5:00 PM CT' };
+  if (ctDay === 5 && ctHour >= 16) return { isOpen: false, message: 'Market closed (Friday after 4PM CT)' };
+  if (ctHour === 16 && ctDay >= 1 && ctDay <= 4) return { isOpen: false, message: 'Daily maintenance' };
+  return { isOpen: true, message: 'Market OPEN' };
 };
 
 /**
@@ -371,7 +371,7 @@ const renderSessionSummary = (stats, stopReason) => {
   const colR = W - colL - 1;
   const version = require('../../../package.json').version;
   
-  process.stdout.write('\x1B[2J\x1B[H');
+  console.clear();
   console.log();
   
   // Top border
@@ -387,9 +387,9 @@ const renderSessionSummary = (stats, stopReason) => {
   
   // Separator + title
   console.log(chalk.cyan(BOX.ML + BOX.H.repeat(W) + BOX.MR));
-  console.log(chalk.cyan(BOX.V) + chalk.yellow(center(`PROP FUTURES ALGO TRADING  V${version}`, W)) + chalk.cyan(BOX.V));
+  console.log(chalk.cyan(BOX.V) + chalk.white(center(`Prop Futures Algo Trading  v${version}`, W)) + chalk.cyan(BOX.V));
   console.log(chalk.cyan(BOX.ML + BOX.H.repeat(W) + BOX.MR));
-  console.log(chalk.cyan(BOX.V) + chalk.yellow(center('SESSION SUMMARY', W)) + chalk.cyan(BOX.V));
+  console.log(chalk.cyan(BOX.V) + chalk.yellow(center('Session Summary', W)) + chalk.cyan(BOX.V));
   
   // Grid separators
   const GT = BOX.ML + BOX.H.repeat(colL) + BOX.TM + BOX.H.repeat(colR) + BOX.MR;
@@ -410,18 +410,18 @@ const renderSessionSummary = (stats, stopReason) => {
   // Row 1: Stop Reason | Duration
   const duration = stats.duration || '--';
   const reasonColor = stopReason === 'target' ? chalk.green : stopReason === 'risk' ? chalk.red : chalk.yellow;
-  row('STOP REASON', (stopReason || 'MANUAL').toUpperCase(), reasonColor, 'DURATION', duration, chalk.white);
+  row('Stop Reason', (stopReason || 'manual').toUpperCase(), reasonColor, 'Duration', duration, chalk.white);
   
   console.log(chalk.cyan(GM));
   
   // Row 2: Trades | Win Rate
   const winRate = stats.trades > 0 ? ((stats.wins / stats.trades) * 100).toFixed(1) + '%' : '0%';
-  row('TRADES', String(stats.trades || 0), chalk.white, 'WIN RATE', winRate, stats.wins >= stats.losses ? chalk.green : chalk.red);
+  row('Trades', String(stats.trades || 0), chalk.white, 'Win Rate', winRate, stats.wins >= stats.losses ? chalk.green : chalk.red);
   
   console.log(chalk.cyan(GM));
   
   // Row 3: Wins | Losses
-  row('WINS', String(stats.wins || 0), chalk.green, 'LOSSES', String(stats.losses || 0), chalk.red);
+  row('Wins', String(stats.wins || 0), chalk.green, 'Losses', String(stats.losses || 0), chalk.red);
   
   console.log(chalk.cyan(GM));
   
@@ -430,7 +430,7 @@ const renderSessionSummary = (stats, stopReason) => {
   const pnlStr = `${pnl >= 0 ? '+' : ''}$${Math.abs(pnl).toFixed(2)}`;
   const pnlColor = pnl >= 0 ? chalk.green : chalk.red;
   const targetStr = `$${(stats.target || 0).toFixed(2)}`;
-  row('P&L', pnlStr, pnlColor, 'TARGET', targetStr, chalk.cyan);
+  row('P&L', pnlStr, pnlColor, 'Target', targetStr, chalk.cyan);
   
   // Bottom border
   console.log(chalk.cyan(BOX.BOT + BOX.H.repeat(W) + BOX.BR));