hedgequantx 2.6.49 → 2.6.51

package/package.json

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

package/src/pages/algo/copy-trading.js

@@ -64,6 +64,8 @@ class CopyEngine {
     this.pollCount = 0;
     this.orderCount = 0;
     this.failedOrders = 0;
+    this.lastLogTime = 0;
+    this.positionEntryTime = null;
     
     // Retry configuration
     this.maxRetries = 3;
@@ -212,6 +214,9 @@ class CopyEngine {
     const size = Math.abs(position.quantity);
     const entry = position.averagePrice || 0;
     
+    // Track entry time for smart logs
+    this.positionEntryTime = Date.now();
+    
     algoLogger.positionOpened(this.ui, displaySymbol, side, size, entry);
     
     // Feed to AI supervisor
@@ -282,6 +287,9 @@ class CopyEngine {
     const displaySymbol = position.symbol || this.symbol.name;
     const size = Math.abs(position.quantity);
     
+    // Reset entry time
+    this.positionEntryTime = null;
+    
     algoLogger.positionClosed(this.ui, displaySymbol, side, size, exitPrice, pnl);
     
     // Feed to AI supervisor
@@ -432,6 +440,28 @@ class CopyEngine {
       
       this.pollCount++;
       
+      // Smart logs every second - non-repetitive status updates
+      const now = Date.now();
+      if (now - this.lastLogTime > 1000) {
+        const smartLogs = require('./smart-logs');
+        
+        if (this.leadPositions.size > 0) {
+          // In position - show position status
+          for (const [key, pos] of this.leadPositions) {
+            const side = pos.quantity > 0 ? 'LONG' : 'SHORT';
+            const unrealizedPnl = pos.profitAndLoss || 0;
+            const holdTime = Math.floor((now - (this.positionEntryTime || now)) / 1000);
+            const posLog = smartLogs.getPositionUpdateLog(side, Math.abs(pos.quantity), unrealizedPnl, pos.averagePrice || 0, pos.averagePrice || 0, holdTime);
+            algoLogger.trade(this.ui, posLog.message, posLog.details);
+          }
+        } else {
+          // No position - show scanning status
+          const scanLog = smartLogs.getScanningLog(true);
+          algoLogger.info(this.ui, scanLog.message, `poll #${this.pollCount} | ${pollTime}ms`);
+        }
+        this.lastLogTime = now;
+      }
+      
     } catch (err) {
       log.warn('Poll error', { error: err.message });
     }

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

@@ -430,10 +430,18 @@ const launchAlgo = async (service, account, contract, config) => {
     if (pos.symbol !== symbolName && !pos.symbol?.includes(symbolName.replace(/[A-Z]\d+$/, ''))) return;
     
     // Update position info (like R Trader Positions panel)
+    const wasFlat = stats.position === 0;
     stats.position = pos.quantity || 0;
     stats.entryPrice = pos.averagePrice || 0;
     currentPosition = pos.quantity || 0;
     
+    // Track entry time when opening a new position
+    if (wasFlat && stats.position !== 0) {
+      stats.entryTime = Date.now();
+    } else if (stats.position === 0) {
+      stats.entryTime = null;
+    }
+    
     // CRITICAL: Update Open P&L from instrument-level data (real-time, same as R Trader)
     // pos.openPnl comes from INSTRUMENT_PNL_UPDATE (450) - this is the unrealized P&L
     if (pos.openPnl !== undefined && pos.openPnl !== null) {
@@ -716,25 +724,43 @@ const launchAlgo = async (service, account, contract, config) => {
     
     stats.latency = Date.now() - latencyStart;
     
-    // Heartbeat every 15 seconds - show strategy model values
-    if (Date.now() - lastHeartbeat > 15000) {
-      // Try to get model values from strategy
+    // Smart logs every 1 second - non-repetitive, varied messages
+    const now = Date.now();
+    if (now - lastHeartbeat > 1000) {
       const modelValues = strategy.getModelValues?.() || strategy.getModelValues?.(contractId) || null;
       
       if (modelValues && modelValues.ofi !== undefined) {
-        // HFT Strategy - pure tick values
-        const ofi = (modelValues.ofi || 0).toFixed(2);
+        const ofi = modelValues.ofi || 0;
         const delta = modelValues.delta || 0;
-        const zscore = (modelValues.zscore || 0).toFixed(2);
-        const mom = (modelValues.momentum || 0).toFixed(1);
-        const signals = modelValues.signalCount || 0;
-        const deltaStr = delta >= 0 ? `+${delta}` : `${delta}`;
-        algoLogger.info(ui, strategyName, `OFI=${ofi} Z=${zscore} Mom=${mom} Δ=${deltaStr} | ${tps} t/15s | ${tickCount} total`);
+        const zscore = modelValues.zscore || 0;
+        const mom = modelValues.momentum || 0;
+        
+        // Get smart varied log based on market state
+        const smartLogs = require('./smart-logs');
+        const stateLog = smartLogs.getMarketStateLog(ofi, zscore, mom, delta);
+        
+        if (currentPosition !== 0) {
+          // In position - show position status with varied messages
+          const side = currentPosition > 0 ? 'LONG' : 'SHORT';
+          const unrealizedPnl = stats.openPnl || 0;
+          const holdTime = Math.floor((now - (stats.entryTime || now)) / 1000);
+          const posLog = smartLogs.getPositionUpdateLog(side, Math.abs(currentPosition), unrealizedPnl, stats.entryPrice, tickData.price, holdTime);
+          ui.addLog('trade', `${posLog.message} - ${posLog.details}`);
+        } else {
+          // Not in position - show market state with varied messages
+          if (stateLog.details) {
+            ui.addLog('analysis', `${stateLog.message} - ${stateLog.details}`);
+          } else {
+            ui.addLog('info', stateLog.message);
+          }
+        }
       } else {
-        // Fallback
-        algoLogger.info(ui, 'SCANNING', `${tps} ticks/15s | ${tickCount} total | price=${tickData.price}`);
+        // Waiting for data
+        const smartLogs = require('./smart-logs');
+        const scanLog = smartLogs.getScanningLog(true);
+        ui.addLog('info', `${scanLog.message} ${tps} ticks/s`);
       }
-      lastHeartbeat = Date.now();
+      lastHeartbeat = now;
       tps = 0;
     }
   });

package/src/pages/algo/smart-logs.js

@@ -0,0 +1,394 @@
+/**
+ * =============================================================================
+ * Smart Logging System - Non-repetitive, contextual, varied messages
+ * =============================================================================
+ * Copied from HQX-TG smart-logs.ts
+ * - Uses message pools to avoid repetition
+ * - Tracks recent messages to ensure variety
+ * - Provides market-context-aware messages
+ */
+
+'use strict';
+
+// Track recently used messages to avoid repetition
+const recentMessages = new Map();
+const MAX_RECENT = 5;
+
+/**
+ * Get a message from a pool, avoiding recent ones
+ */
+function getVariedMessage(category, pool, defaultMsg) {
+  const recent = recentMessages.get(category) || [];
+
+  // Filter out recently used messages
+  const available = pool.filter(msg => !recent.includes(msg));
+
+  // If all messages were recently used, reset
+  if (available.length === 0) {
+    recentMessages.set(category, []);
+    return pool[Math.floor(Math.random() * pool.length)] || defaultMsg;
+  }
+
+  // Pick a random available message
+  const chosen = available[Math.floor(Math.random() * available.length)] || defaultMsg;
+
+  // Track it
+  recent.push(chosen);
+  if (recent.length > MAX_RECENT) recent.shift();
+  recentMessages.set(category, recent);
+
+  return chosen;
+}
+
+// =============================================================================
+// MESSAGE POOLS - Market Flow
+// =============================================================================
+
+const LONG_BIAS_MESSAGES = [
+  'Bullish bias detected',
+  'Buyers in control',
+  'Long-side pressure',
+  'Bid accumulation',
+  'Buy programs active',
+];
+
+const SHORT_BIAS_MESSAGES = [
+  'Bearish bias detected',
+  'Sellers in control',
+  'Short-side pressure',
+  'Offer distribution',
+  'Sell programs active',
+];
+
+const FLAT_BIAS_MESSAGES = [
+  'Market balanced',
+  'Two-way flow',
+  'Consolidation mode',
+  'No clear direction',
+  'Mixed signals',
+];
+
+// =============================================================================
+// MESSAGE POOLS - Trading Events
+// =============================================================================
+
+const SIGNAL_LONG_MESSAGES = [
+  'Buy signal generated',
+  'Long opportunity detected',
+  'Bullish setup confirmed',
+  'Entry signal: LONG',
+  'Buy zone activated',
+];
+
+const SIGNAL_SHORT_MESSAGES = [
+  'Sell signal generated',
+  'Short opportunity detected',
+  'Bearish setup confirmed',
+  'Entry signal: SHORT',
+  'Sell zone activated',
+];
+
+const ENTRY_LONG_MESSAGES = [
+  'Long position opened',
+  'Buy order filled',
+  'Entered long',
+  'Long initiated',
+  'Position: LONG',
+];
+
+const ENTRY_SHORT_MESSAGES = [
+  'Short position opened',
+  'Sell order filled',
+  'Entered short',
+  'Short initiated',
+  'Position: SHORT',
+];
+
+const EXIT_PROFIT_MESSAGES = [
+  'Target reached',
+  'Profit taken',
+  'Winner closed',
+  'TP hit',
+  'Profit locked',
+];
+
+const EXIT_LOSS_MESSAGES = [
+  'Stop triggered',
+  'Loss taken',
+  'Loser closed',
+  'SL hit',
+  'Risk contained',
+];
+
+// =============================================================================
+// MESSAGE POOLS - Analysis
+// =============================================================================
+
+const MOMENTUM_UP_MESSAGES = [
+  'Momentum building up',
+  'Price accelerating',
+  'Bullish momentum',
+  'Upward thrust',
+  'Buying momentum',
+];
+
+const MOMENTUM_DOWN_MESSAGES = [
+  'Momentum building down',
+  'Price declining',
+  'Bearish momentum',
+  'Downward thrust',
+  'Selling momentum',
+];
+
+const OVERBOUGHT_MESSAGES = [
+  'Overbought condition',
+  'Extended to upside',
+  'Mean reversion setup (short)',
+  'Exhaustion detected',
+  'Stretched high',
+];
+
+const OVERSOLD_MESSAGES = [
+  'Oversold condition',
+  'Extended to downside',
+  'Mean reversion setup (long)',
+  'Capitulation detected',
+  'Stretched low',
+];
+
+const HIGH_VOLATILITY_MESSAGES = [
+  'Volatility elevated',
+  'High ATR detected',
+  'Wide swings',
+  'Market volatile',
+  'Increased range',
+];
+
+const LOW_VOLATILITY_MESSAGES = [
+  'Low volatility',
+  'Tight range',
+  'Compressed action',
+  'Market quiet',
+  'Narrow swings',
+];
+
+// =============================================================================
+// MESSAGE POOLS - Status
+// =============================================================================
+
+const SCANNING_MESSAGES = [
+  'Scanning market...',
+  'Analyzing flow...',
+  'Monitoring price action...',
+  'Watching for setups...',
+  'Evaluating conditions...',
+];
+
+const WAITING_MESSAGES = [
+  'Waiting for confirmation...',
+  'Pending trigger...',
+  'Standby mode...',
+  'Awaiting signal...',
+  'Ready to act...',
+];
+
+const IN_POSITION_PROFIT_MESSAGES = [
+  'Running profit',
+  'In the money',
+  'Trade working',
+  'Position profitable',
+  'Gains accumulating',
+];
+
+const IN_POSITION_LOSS_MESSAGES = [
+  'Managing drawdown',
+  'Underwater',
+  'Holding through',
+  'Defending position',
+  'Monitoring risk',
+];
+
+// =============================================================================
+// SMART LOG GENERATORS
+// =============================================================================
+
+/**
+ * Get a market bias log
+ */
+function getMarketBiasLog(direction, delta, ofi) {
+  let pool;
+  switch (direction) {
+    case 'LONG':
+      pool = LONG_BIAS_MESSAGES;
+      break;
+    case 'SHORT':
+      pool = SHORT_BIAS_MESSAGES;
+      break;
+    default:
+      pool = FLAT_BIAS_MESSAGES;
+  }
+
+  const message = getVariedMessage(`bias_${direction}`, pool, `${direction} bias`);
+  const arrow = direction === 'LONG' ? '▲' : direction === 'SHORT' ? '▼' : '=';
+
+  let details;
+  if (delta !== undefined && ofi !== undefined) {
+    const deltaStr = delta >= 0 ? `+${delta}` : `${delta}`;
+    details = `${arrow} Δ=${deltaStr} | OFI=${ofi.toFixed(2)}`;
+  }
+
+  return { message, details };
+}
+
+/**
+ * Get a momentum log
+ */
+function getMomentumLog(momentum, zscore) {
+  const isUp = momentum > 0;
+  const pool = isUp ? MOMENTUM_UP_MESSAGES : MOMENTUM_DOWN_MESSAGES;
+  const category = isUp ? 'mom_up' : 'mom_down';
+  const message = getVariedMessage(category, pool, isUp ? 'Momentum up' : 'Momentum down');
+  const arrow = isUp ? '▲' : '▼';
+
+  return {
+    message: `${arrow} ${message}`,
+    details: `Mom=${momentum.toFixed(1)} | Z=${zscore.toFixed(2)}`,
+  };
+}
+
+/**
+ * Get a mean reversion log
+ */
+function getMeanReversionLog(zscore) {
+  const isOverbought = zscore > 0;
+  const pool = isOverbought ? OVERBOUGHT_MESSAGES : OVERSOLD_MESSAGES;
+  const category = isOverbought ? 'mr_overbought' : 'mr_oversold';
+  const message = getVariedMessage(category, pool, isOverbought ? 'Overbought' : 'Oversold');
+  const arrow = isOverbought ? '▼' : '▲'; // Opposite - looking for reversal
+
+  return {
+    message: `${arrow} ${message}`,
+    details: `Z-Score: ${zscore.toFixed(2)} | Looking for ${isOverbought ? 'SHORT' : 'LONG'}`,
+  };
+}
+
+/**
+ * Get a signal log
+ */
+function getSignalLog(direction, symbol, confidence, strategy) {
+  const pool = direction === 'LONG' ? SIGNAL_LONG_MESSAGES : SIGNAL_SHORT_MESSAGES;
+  const message = getVariedMessage(`signal_${direction}`, pool, `${direction} signal`);
+  const arrow = direction === 'LONG' ? '▲' : '▼';
+
+  return {
+    message: `${arrow} ${message}`,
+    details: `${symbol} | ${confidence.toFixed(0)}% | ${strategy}`,
+  };
+}
+
+/**
+ * Get an entry log
+ */
+function getEntryLog(direction, symbol, size, price) {
+  const pool = direction === 'LONG' ? ENTRY_LONG_MESSAGES : ENTRY_SHORT_MESSAGES;
+  const message = getVariedMessage(`entry_${direction}`, pool, `${direction} entry`);
+  const arrow = direction === 'LONG' ? '▲' : '▼';
+
+  return {
+    message: `${arrow} ${message}`,
+    details: `${size}x ${symbol} @ ${price.toFixed(2)}`,
+  };
+}
+
+/**
+ * Get an exit log
+ */
+function getExitLog(isProfit, symbol, size, price, pnl) {
+  const pool = isProfit ? EXIT_PROFIT_MESSAGES : EXIT_LOSS_MESSAGES;
+  const category = isProfit ? 'exit_profit' : 'exit_loss';
+  const message = getVariedMessage(category, pool, isProfit ? 'Profit taken' : 'Loss taken');
+  const pnlStr = pnl >= 0 ? `+$${pnl.toFixed(2)}` : `-$${Math.abs(pnl).toFixed(2)}`;
+
+  return {
+    message,
+    details: `${size}x ${symbol} @ ${price.toFixed(2)} | ${pnlStr}`,
+  };
+}
+
+/**
+ * Get a volatility log
+ */
+function getVolatilityLog(isHigh, atr) {
+  const pool = isHigh ? HIGH_VOLATILITY_MESSAGES : LOW_VOLATILITY_MESSAGES;
+  const category = isHigh ? 'vol_high' : 'vol_low';
+  const message = getVariedMessage(category, pool, isHigh ? 'High volatility' : 'Low volatility');
+
+  return {
+    message,
+    details: atr ? `ATR: ${atr.toFixed(2)}` : undefined,
+  };
+}
+
+/**
+ * Get a scanning/waiting log
+ */
+function getScanningLog(isScanning) {
+  const pool = isScanning ? SCANNING_MESSAGES : WAITING_MESSAGES;
+  const category = isScanning ? 'scanning' : 'waiting';
+  const message = getVariedMessage(category, pool, isScanning ? 'Scanning...' : 'Waiting...');
+
+  return { message, details: undefined };
+}
+
+/**
+ * Get position update log with varied messaging
+ */
+function getPositionUpdateLog(side, size, unrealizedPnL, entryPrice, currentPrice, holdTime) {
+  const arrow = side === 'LONG' ? '▲' : '▼';
+  const pnlStr = unrealizedPnL >= 0 ? `+$${unrealizedPnL.toFixed(2)}` : `-$${Math.abs(unrealizedPnL).toFixed(2)}`;
+  const isProfit = unrealizedPnL >= 0;
+  
+  const pool = isProfit ? IN_POSITION_PROFIT_MESSAGES : IN_POSITION_LOSS_MESSAGES;
+  const category = isProfit ? 'pos_profit' : 'pos_loss';
+  const prefix = getVariedMessage(category, pool, isProfit ? 'In profit' : 'Managing');
+
+  return {
+    message: `${arrow} ${side} ${size}x`,
+    details: `${prefix} ${pnlStr} @ ${currentPrice.toFixed(2)} | ${holdTime}s`,
+  };
+}
+
+/**
+ * Get market state log based on model values
+ */
+function getMarketStateLog(ofi, zscore, momentum, delta) {
+  // Determine primary market state
+  const absZ = Math.abs(zscore);
+  const absOfi = Math.abs(ofi);
+  const absMom = Math.abs(momentum);
+  
+  // Priority: Mean reversion > OFI pressure > Momentum
+  if (absZ > 1.5) {
+    return getMeanReversionLog(zscore);
+  } else if (absOfi > 0.3) {
+    const direction = ofi > 0 ? 'LONG' : 'SHORT';
+    return getMarketBiasLog(direction, delta, ofi);
+  } else if (absMom > 2) {
+    return getMomentumLog(momentum, zscore);
+  } else {
+    return getScanningLog(true);
+  }
+}
+
+module.exports = {
+  getMarketBiasLog,
+  getMomentumLog,
+  getMeanReversionLog,
+  getSignalLog,
+  getEntryLog,
+  getExitLog,
+  getVolatilityLog,
+  getScanningLog,
+  getPositionUpdateLog,
+  getMarketStateLog,
+};

package/src/pages/algo/ui.js

@@ -102,11 +102,7 @@ class AlgoUI {
     this.config = config;
     this.W = 96; // Fixed width
     this.logs = [];
-    // Calculate maxLogs based on terminal height
-    // Header (logo + titles): ~12 lines, Stats: ~12 lines, Log header: 2 lines, Bottom: 1 line = 27 fixed
-    const terminalHeight = process.stdout.rows || 50;
-    const fixedLines = 27;
-    this.maxLogs = Math.max(10, terminalHeight - fixedLines); // Min 10 logs
+    this.maxLogs = 40; // Fixed at 40 logs for one-account and copy-trading
     this.spinnerFrame = 0;
     this.firstDraw = true;
     this.isDrawing = false;
@@ -186,83 +182,21 @@ class AlgoUI {
     
     this._line(chalk.cyan(GM));
     
-    // Row 2: Position | P&L (like R Trader)
-    const posQty = stats.position || 0;
-    const posStr = posQty === 0 ? 'FLAT' : (posQty > 0 ? `+${posQty} LONG` : `${posQty} SHORT`);
-    const posColor = posQty === 0 ? chalk.gray : (posQty > 0 ? chalk.green : chalk.red);
-    const r2c1 = buildCell('POSITION', posStr, posColor, colL);
-    const r2c2 = buildCell('P&L', pnlStr, pnlColor, colR);
-    row(r2c1.padded, r2c2.padded);
-    
-    this._line(chalk.cyan(GM));
-    
-    // Row 3: Open P&L | Closed P&L (R Trader style breakdown)
-    // Data from Rithmic PNL_PLANT WebSocket - show '--' if null (no data from API)
-    const openPnl = stats.openPnl;
-    const closedPnl = stats.closedPnl;
-    const openPnlStr = openPnl === null || openPnl === undefined 
-      ? '--' 
-      : (openPnl >= 0 ? `+$${openPnl.toFixed(2)}` : `-$${Math.abs(openPnl).toFixed(2)}`);
-    const closedPnlStr = closedPnl === null || closedPnl === undefined 
-      ? '--' 
-      : (closedPnl >= 0 ? `+$${closedPnl.toFixed(2)}` : `-$${Math.abs(closedPnl).toFixed(2)}`);
-    const openPnlColor = (openPnl || 0) >= 0 ? chalk.green : chalk.red;
-    const closedPnlColor = (closedPnl || 0) >= 0 ? chalk.green : chalk.red;
-    const r3c1 = buildCell('OPEN P&L', openPnlStr, openPnlColor, colL);
-    const r3c2 = buildCell('CLOSED P&L', closedPnlStr, closedPnlColor, colR);
-    row(r3c1.padded, r3c2.padded);
-    
-    this._line(chalk.cyan(GM));
-    
-    // Row 4: Balance | Net Liquidation (R Trader style)
-    const balanceStr = stats.balance !== null && stats.balance !== undefined 
-      ? '$' + stats.balance.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })
-      : '--';
-    const netLiqStr = stats.netLiquidation !== null && stats.netLiquidation !== undefined
-      ? '$' + stats.netLiquidation.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })
-      : '--';
-    const r4c1 = buildCell('BALANCE', balanceStr, chalk.white, colL);
-    const r4c2 = buildCell('NET LIQ', netLiqStr, chalk.cyan, colR);
-    row(r4c1.padded, r4c2.padded);
-    
-    this._line(chalk.cyan(GM));
-    
-    // Row 5: Buying Power | Margin (R Trader style)
-    const bpStr = stats.buyingPower !== null && stats.buyingPower !== undefined
-      ? '$' + stats.buyingPower.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })
-      : '--';
-    const marginStr = stats.margin !== null && stats.margin !== undefined
-      ? '$' + stats.margin.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })
-      : '--';
-    const r5c1 = buildCell('BUYING PWR', bpStr, chalk.green, colL);
-    const r5c2 = buildCell('MARGIN', marginStr, chalk.yellow, colR);
-    row(r5c1.padded, r5c2.padded);
-    
-    this._line(chalk.cyan(GM));
-    
-    // Row 6: Target | Risk
+    // Row 2: Target | Risk
     const targetStr = stats.target !== null && stats.target !== undefined ? '$' + stats.target.toFixed(2) : '--';
     const riskStr = stats.risk !== null && stats.risk !== undefined ? '$' + stats.risk.toFixed(2) : '--';
-    const r6c1 = buildCell('TARGET', targetStr, chalk.green, colL);
-    const r6c2 = buildCell('RISK', riskStr, chalk.red, colR);
-    row(r6c1.padded, r6c2.padded);
-    
-    this._line(chalk.cyan(GM));
-    
-    // Row 7: Trades W/L | Entry Price (if in position)
-    const r7c1t = ` ${chalk.bold('TRADES')}: ${chalk.cyan.bold(stats.trades || 0)}  ${chalk.bold('W/L')}: ${chalk.green.bold(stats.wins || 0)}/${chalk.red.bold(stats.losses || 0)}`;
-    const r7c1p = ` TRADES: ${stats.trades || 0}  W/L: ${stats.wins || 0}/${stats.losses || 0}`;
-    const entryStr = stats.entryPrice > 0 ? stats.entryPrice.toFixed(2) : '--';
-    const r7c2 = buildCell('ENTRY', entryStr, chalk.yellow, colR);
-    row(r7c1t + pad(colL - r7c1p.length), r7c2.padded);
+    const r2c1 = buildCell('TARGET', targetStr, chalk.green, colL);
+    const r2c2 = buildCell('RISK', riskStr, chalk.red, colR);
+    row(r2c1.padded, r2c2.padded);
     
     this._line(chalk.cyan(GM));
     
-    // Row 8: Connection | Propfirm
+    // Row 3: Trades W/L | Connection
+    const r3c1t = ` ${chalk.bold('TRADES')}: ${chalk.cyan.bold(stats.trades || 0)}  ${chalk.bold('W/L')}: ${chalk.green.bold(stats.wins || 0)}/${chalk.red.bold(stats.losses || 0)}`;
+    const r3c1p = ` TRADES: ${stats.trades || 0}  W/L: ${stats.wins || 0}/${stats.losses || 0}`;
     const connection = stats.platform || 'ProjectX';
-    const r8c1 = buildCell('CONNECTION', connection, chalk.cyan, colL);
-    const r8c2 = buildCell('PROPFIRM', stats.propfirm || 'N/A', chalk.cyan, colR);
-    row(r8c1.padded, r8c2.padded);
+    const r3c2 = buildCell('CONNECTION', connection, chalk.cyan, colR);
+    row(r3c1t + pad(colL - r3c1p.length), r3c2.padded);
     
     this._line(chalk.cyan(GB));
   }