hedgequantx 2.6.160 → 2.6.162

package/src/pages/stats-calculations.js

@@ -0,0 +1,191 @@
+/**
+ * @fileoverview Stats Calculations
+ * Calculate trading statistics from API data
+ * 
+ * STRICT RULE: Calculate ONLY from values returned by API
+ * - NO estimation, NO simulation, NO mock data
+ */
+
+/**
+ * Calculate trade statistics from completed trades
+ * @param {Array} completedTrades - Trades with P&L != 0
+ * @returns {Object} Statistics object
+ */
+const calculateTradeStats = (completedTrades) => {
+  const stats = {
+    totalTrades: 0, winningTrades: 0, losingTrades: 0,
+    totalWinAmount: 0, totalLossAmount: 0,
+    bestTrade: 0, worstTrade: 0, totalVolume: 0,
+    maxConsecutiveWins: 0, maxConsecutiveLosses: 0,
+    longTrades: 0, shortTrades: 0, longWins: 0, shortWins: 0
+  };
+  
+  if (!completedTrades || completedTrades.length === 0) {
+    return stats;
+  }
+  
+  stats.totalTrades = completedTrades.length;
+  let consecutiveWins = 0, consecutiveLosses = 0;
+  
+  // Sort by time for consecutive win/loss calculation
+  const sortedTrades = [...completedTrades].sort((a, b) => {
+    const timeA = new Date(a.creationTimestamp || a.timestamp || 0).getTime();
+    const timeB = new Date(b.creationTimestamp || b.timestamp || 0).getTime();
+    return timeA - timeB;
+  });
+  
+  for (const trade of sortedTrades) {
+    const grossPnl = trade.profitAndLoss || trade.pnl || 0;
+    const fees = Math.abs(trade.fees || trade.commission || 0);
+    const netPnl = grossPnl - fees;
+    const size = trade.size || trade.quantity || 1;
+    const exitSide = trade.side;
+    
+    stats.totalVolume += Math.abs(size);
+    
+    // Determine original trade direction from exit side
+    if (exitSide === 1) {
+      stats.longTrades++;
+      if (netPnl > 0) stats.longWins++;
+    } else if (exitSide === 0) {
+      stats.shortTrades++;
+      if (netPnl > 0) stats.shortWins++;
+    }
+    
+    if (netPnl > 0) {
+      stats.winningTrades++;
+      stats.totalWinAmount += netPnl;
+      consecutiveWins++;
+      consecutiveLosses = 0;
+      if (consecutiveWins > stats.maxConsecutiveWins) stats.maxConsecutiveWins = consecutiveWins;
+      if (netPnl > stats.bestTrade) stats.bestTrade = netPnl;
+    } else if (netPnl < 0) {
+      stats.losingTrades++;
+      stats.totalLossAmount += Math.abs(netPnl);
+      consecutiveLosses++;
+      consecutiveWins = 0;
+      if (consecutiveLosses > stats.maxConsecutiveLosses) stats.maxConsecutiveLosses = consecutiveLosses;
+      if (netPnl < stats.worstTrade) stats.worstTrade = netPnl;
+    }
+  }
+  
+  return stats;
+};
+
+/**
+ * Calculate quantitative metrics from trade P&Ls
+ * @param {Array} completedTrades - Completed trades
+ * @param {number} totalStartingBalance - Starting balance
+ * @returns {Object} Quantitative metrics
+ */
+const calculateQuantMetrics = (completedTrades, totalStartingBalance) => {
+  const tradePnLs = completedTrades.map(t => {
+    const grossPnl = t.profitAndLoss || t.pnl || 0;
+    const fees = Math.abs(t.fees || t.commission || 0);
+    return grossPnl - fees;
+  });
+  
+  const avgReturn = tradePnLs.length > 0 ? tradePnLs.reduce((a, b) => a + b, 0) / tradePnLs.length : 0;
+  
+  // Standard deviation
+  const variance = tradePnLs.length > 0 
+    ? tradePnLs.reduce((sum, pnl) => sum + Math.pow(pnl - avgReturn, 2), 0) / tradePnLs.length 
+    : 0;
+  const stdDev = Math.sqrt(variance);
+  
+  // Downside deviation
+  const downsideReturns = tradePnLs.filter(pnl => pnl < 0);
+  const downsideVariance = downsideReturns.length > 0 
+    ? downsideReturns.reduce((sum, pnl) => sum + Math.pow(pnl, 2), 0) / downsideReturns.length 
+    : 0;
+  const downsideDev = Math.sqrt(downsideVariance);
+  
+  // Ratios
+  const sharpeRatio = stdDev > 0 ? (avgReturn / stdDev).toFixed(2) : 'N/A';
+  const sortinoRatio = downsideDev > 0 ? (avgReturn / downsideDev).toFixed(2) : 'N/A';
+  
+  // Max Drawdown
+  let maxDrawdown = 0;
+  let peak = totalStartingBalance || 0;
+  let equity = peak;
+  if (peak > 0 && tradePnLs.length > 0) {
+    tradePnLs.forEach(pnl => {
+      equity += pnl;
+      if (equity > peak) peak = equity;
+      const drawdown = peak > 0 ? (peak - equity) / peak * 100 : 0;
+      if (drawdown > maxDrawdown) maxDrawdown = drawdown;
+    });
+  }
+  
+  return {
+    avgReturn,
+    stdDev,
+    sharpeRatio,
+    sortinoRatio,
+    maxDrawdown,
+    tradePnLs,
+  };
+};
+
+/**
+ * Calculate HQX Score from stats
+ * @param {Object} stats - Trade statistics
+ * @param {number} totalStartingBalance - Starting balance
+ * @param {string} returnPercent - Return percentage string
+ * @param {string} profitFactor - Profit factor string
+ * @param {string} winRate - Win rate string
+ * @returns {Object} HQX Score components
+ */
+const calculateHQXScore = (stats, totalStartingBalance, returnPercent, profitFactor, winRate) => {
+  const winRateNum = winRate !== 'N/A' ? parseFloat(winRate) : 0;
+  const winRateScore = Math.min(100, winRateNum * 1.5);
+  const profitFactorScore = profitFactor === '∞' ? 100 : profitFactor === 'N/A' ? 0 : Math.min(100, parseFloat(profitFactor) * 40);
+  const consistencyScore = stats.maxConsecutiveLosses > 0 ? Math.max(0, 100 - (stats.maxConsecutiveLosses * 15)) : 100;
+  const riskScore = stats.worstTrade !== 0 && totalStartingBalance > 0 
+    ? Math.max(0, 100 - (Math.abs(stats.worstTrade) / totalStartingBalance * 1000)) 
+    : 50;
+  const volumeScore = Math.min(100, stats.totalTrades * 2);
+  const returnNum = returnPercent !== 'N/A' ? parseFloat(returnPercent) : 0;
+  const returnScore = Math.min(100, Math.max(0, returnNum * 10 + 50));
+  
+  const hqxScore = Math.round((winRateScore + profitFactorScore + consistencyScore + riskScore + volumeScore + returnScore) / 6);
+  const scoreGrade = hqxScore >= 90 ? 'S' : hqxScore >= 80 ? 'A' : hqxScore >= 70 ? 'B' : hqxScore >= 60 ? 'C' : hqxScore >= 50 ? 'D' : 'F';
+  
+  return {
+    hqxScore,
+    scoreGrade,
+    metrics: [
+      { name: 'WIN RATE', score: winRateScore },
+      { name: 'PROFIT FACTOR', score: profitFactorScore },
+      { name: 'CONSISTENCY', score: consistencyScore },
+      { name: 'RISK MANAGEMENT', score: riskScore },
+      { name: 'VOLUME', score: volumeScore },
+      { name: 'RETURNS', score: returnScore }
+    ]
+  };
+};
+
+/**
+ * Extract symbol from contractId
+ * @param {string} contractId - Contract ID (e.g., "CON.F.US.EP.H25")
+ * @returns {string} Symbol (e.g., "ES H25")
+ */
+const extractSymbol = (contractId) => {
+  if (!contractId) return 'N/A';
+  const parts = contractId.split('.');
+  if (parts.length >= 5) {
+    const sym = parts[3];
+    const month = parts[4];
+    const symbolMap = { 'EP': 'ES', 'ENQ': 'NQ', 'MES': 'MES', 'MNQ': 'MNQ', 'YM': 'YM', 'NKD': 'NKD', 'RTY': 'RTY' };
+    return (symbolMap[sym] || sym) + ' ' + month;
+  }
+  if (contractId.length <= 10) return contractId;
+  return contractId.substring(0, 10);
+};
+
+module.exports = {
+  calculateTradeStats,
+  calculateQuantMetrics,
+  calculateHQXScore,
+  extractSymbol,
+};

package/src/pages/stats-ui.js

@@ -0,0 +1,381 @@
+/**
+ * @fileoverview Stats UI Rendering
+ * UI rendering functions for stats page
+ */
+
+const chalk = require('chalk');
+const asciichart = require('asciichart');
+const { drawBoxHeader, drawBoxFooter, draw2ColHeader, fmtRow } = require('../ui');
+
+/**
+ * Render AI Supervision section
+ * @param {Array} aiAgents - Connected AI agents
+ * @param {Array} supervisionStatus - Status from AISupervisor
+ * @param {Object} AISupervisor - AISupervisor module
+ * @param {number} boxWidth - Box width
+ * @param {number} col1 - Column 1 width
+ * @param {number} col2 - Column 2 width
+ */
+const renderAISupervision = (aiAgents, supervisionStatus, AISupervisor, boxWidth, col1, col2) => {
+  drawBoxHeader('AI SUPERVISION', boxWidth);
+  draw2ColHeader('AGENTS', 'PERFORMANCE', boxWidth);
+  
+  const isConsensusMode = aiAgents.length >= 2;
+  const agentMode = isConsensusMode ? 'CONSENSUS' : 'INDIVIDUAL';
+  const modeColor = isConsensusMode ? chalk.magenta : chalk.cyan;
+  const consensusData = isConsensusMode ? AISupervisor.getConsensus() : null;
+  
+  let totalSessionTime = 0;
+  for (const status of supervisionStatus) {
+    if (status.active) {
+      totalSessionTime += status.duration || 0;
+    }
+  }
+  
+  const sessionTimeStr = totalSessionTime > 0 
+    ? Math.floor(totalSessionTime / 60000) + 'm ' + Math.floor((totalSessionTime % 60000) / 1000) + 's'
+    : 'INACTIVE';
+  
+  const supervisionData = AISupervisor.getAggregatedData();
+  const supervisedAccounts = supervisionData.totalAccounts;
+  const supervisedPnL = supervisionData.totalPnL;
+  const maxAgentNameLen = col1 - 20;
+  
+  const perfData = [
+    { label: 'SUPERVISED ACCOUNTS:', value: chalk.white(String(supervisedAccounts)) },
+    { label: 'SUPERVISED P&L:', value: supervisedPnL >= 0 ? chalk.green('$' + supervisedPnL.toFixed(2)) : chalk.red('$' + supervisedPnL.toFixed(2)) },
+    { label: 'POSITIONS:', value: chalk.white(String(supervisionData.totalPositions)) },
+    { label: 'OPEN ORDERS:', value: chalk.white(String(supervisionData.totalOrders)) },
+    { label: 'TRADES TODAY:', value: chalk.white(String(supervisionData.totalTrades)) }
+  ];
+  
+  const agentsData = [
+    { label: 'CONNECTED:', value: chalk.green(String(aiAgents.length) + ' AGENT' + (aiAgents.length > 1 ? 'S' : '')) },
+    { label: 'MODE:', value: modeColor(agentMode) },
+    { label: 'SESSION:', value: sessionTimeStr === 'INACTIVE' ? chalk.yellow(sessionTimeStr) : chalk.white(sessionTimeStr) }
+  ];
+  
+  if (isConsensusMode && consensusData) {
+    const isUnanimous = consensusData.isUnanimous;
+    const consensusAction = consensusData.action || 'PENDING';
+    const consensusDisplay = isUnanimous 
+      ? chalk.green(consensusAction + ' (UNANIMOUS)')
+      : chalk.yellow(consensusAction + ' (DISAGREEMENT)');
+    agentsData.push({ label: 'DECISION:', value: consensusDisplay });
+  } else if (isConsensusMode) {
+    agentsData.push({ label: 'DECISION:', value: chalk.white('WAITING...') });
+  }
+  
+  aiAgents.forEach((agent, idx) => {
+    const agentLabel = idx === 0 ? 'AGENTS:' : '';
+    const agentName = agent.name.length > maxAgentNameLen 
+      ? agent.name.substring(0, maxAgentNameLen - 4) + '..' 
+      : agent.name;
+    const agentDisplay = chalk.green('● ') + chalk.white(agentName);
+    agentsData.push({ label: agentLabel, value: agentDisplay });
+  });
+  
+  const maxRows = Math.max(agentsData.length, perfData.length);
+  for (let i = 0; i < maxRows; i++) {
+    const leftData = agentsData[i] || { label: '', value: '' };
+    const rightData = perfData[i] || { label: '', value: '' };
+    console.log(chalk.cyan('\u2551') + fmtRow(leftData.label, leftData.value, col1) + chalk.cyan('\u2502') + fmtRow(rightData.label, rightData.value, col2) + chalk.cyan('\u2551'));
+  }
+  
+  drawBoxFooter(boxWidth);
+};
+
+/**
+ * Render AI Behavior section
+ * @param {Object} StrategySupervisor - StrategySupervisor module
+ * @param {number} boxWidth - Box width
+ */
+const renderAIBehavior = (StrategySupervisor, boxWidth) => {
+  const behaviorData = StrategySupervisor.getBehaviorHistory(100);
+  const learningStats = StrategySupervisor.getLearningStats();
+  
+  console.log();
+  drawBoxHeader('AI AGENTS BEHAVIOR', boxWidth);
+  
+  const behaviorInnerWidth = boxWidth - 2;
+  const behaviorCounts = { AGGRESSIVE: 0, NORMAL: 0, CAUTIOUS: 0, PAUSE: 0 };
+  const valueToAction = { 3: 'AGGRESSIVE', 2: 'NORMAL', 1: 'CAUTIOUS', 0: 'PAUSE' };
+  
+  if (behaviorData.values.length > 0) {
+    for (const val of behaviorData.values) {
+      const action = valueToAction[Math.round(val)] || 'NORMAL';
+      behaviorCounts[action]++;
+    }
+  } else {
+    behaviorCounts.NORMAL = 1;
+  }
+  
+  const total = Object.values(behaviorCounts).reduce((a, b) => a + b, 0) || 1;
+  const percentages = {
+    AGGRESSIVE: Math.round((behaviorCounts.AGGRESSIVE / total) * 100),
+    NORMAL: Math.round((behaviorCounts.NORMAL / total) * 100),
+    CAUTIOUS: Math.round((behaviorCounts.CAUTIOUS / total) * 100),
+    PAUSE: Math.round((behaviorCounts.PAUSE / total) * 100)
+  };
+  
+  const currentValue = behaviorData.values.length > 0 ? behaviorData.values[behaviorData.values.length - 1] : 2;
+  const currentAction = valueToAction[Math.round(currentValue)] || 'NORMAL';
+  
+  const barColors = {
+    AGGRESSIVE: chalk.green,
+    NORMAL: chalk.cyan,
+    CAUTIOUS: chalk.yellow,
+    PAUSE: chalk.red
+  };
+  
+  const barLabels = ['AGGRESSIVE', 'NORMAL', 'CAUTIOUS', 'PAUSE'];
+  const shortLabels = ['AGR', 'NOR', 'CAU', 'PAU'];
+  const labelWidth = 6;
+  const pctWidth = 6;
+  const spacing = 4;
+  
+  const availableWidth = behaviorInnerWidth - (labelWidth * 4) - (pctWidth * 4) - (spacing * 3) - 4;
+  const maxBarWidth = Math.floor(availableWidth / 4);
+  
+  const barWidths = {
+    AGGRESSIVE: Math.round((percentages.AGGRESSIVE / 100) * maxBarWidth),
+    NORMAL: Math.round((percentages.NORMAL / 100) * maxBarWidth),
+    CAUTIOUS: Math.round((percentages.CAUTIOUS / 100) * maxBarWidth),
+    PAUSE: Math.round((percentages.PAUSE / 100) * maxBarWidth)
+  };
+  
+  for (let i = 0; i < 4; i++) {
+    const label = barLabels[i];
+    const shortLabel = shortLabels[i];
+    const pct = percentages[label];
+    const barWidth = barWidths[label];
+    const color = barColors[label];
+    const isCurrent = label === currentAction;
+    
+    const block = isCurrent ? '█' : '▓';
+    const bar = barWidth > 0 ? color(block.repeat(barWidth)) : '';
+    const emptySpace = ' '.repeat(Math.max(0, maxBarWidth - barWidth));
+    
+    const labelPart = '  ' + color(shortLabel.padEnd(labelWidth));
+    const barPart = bar + emptySpace;
+    const pctPart = chalk.white((pct + '%').padStart(pctWidth));
+    
+    let line = labelPart + barPart + pctPart;
+    const lineLen = line.replace(/\x1b\[[0-9;]*m/g, '').length;
+    line += ' '.repeat(Math.max(0, behaviorInnerWidth - lineLen));
+    console.log(chalk.cyan('\u2551') + line + chalk.cyan('\u2551'));
+  }
+  
+  console.log(chalk.cyan('\u2551') + ' '.repeat(behaviorInnerWidth) + chalk.cyan('\u2551'));
+  
+  const statsLine = `  CURRENT: ${barColors[currentAction](currentAction)} | SESSION PATTERNS: ${learningStats.patternsLearned.total} (${learningStats.patternsLearned.winning}W/${learningStats.patternsLearned.losing}L) | OPTIMIZATIONS: ${learningStats.optimizations}`;
+  const statsLen = statsLine.replace(/\x1b\[[0-9;]*m/g, '').length;
+  console.log(chalk.cyan('\u2551') + statsLine + ' '.repeat(Math.max(0, behaviorInnerWidth - statsLen)) + chalk.cyan('\u2551'));
+  
+  const lifetimeStats = StrategySupervisor.getLifetimeStats();
+  if (lifetimeStats.totalSessions > 0) {
+    const lifetimeLine = `  LIFETIME: ${lifetimeStats.totalSessions} sessions | ${lifetimeStats.totalTrades} trades | WR: ${lifetimeStats.lifetimeWinRate} | P&L: $${lifetimeStats.lifetimePnL.toFixed(2)} | ${lifetimeStats.patternsLearned.winning + lifetimeStats.patternsLearned.losing} patterns learned`;
+    const lifetimeLen = lifetimeLine.length;
+    console.log(chalk.cyan('\u2551') + chalk.magenta(lifetimeLine) + ' '.repeat(Math.max(0, behaviorInnerWidth - lifetimeLen)) + chalk.cyan('\u2551'));
+  }
+  
+  drawBoxFooter(boxWidth);
+};
+
+/**
+ * Render Equity Curve section
+ * @param {Array} allTrades - All trades
+ * @param {number} totalStartingBalance - Starting balance
+ * @param {Object} connectionTypes - Connection type counts
+ * @param {number} boxWidth - Box width
+ */
+const renderEquityCurve = (allTrades, totalStartingBalance, connectionTypes, boxWidth) => {
+  drawBoxHeader('EQUITY CURVE', boxWidth);
+  
+  const chartInnerWidth = boxWidth - 2;
+  
+  if (allTrades.length > 0) {
+    const yAxisWidth = 10;
+    const chartAreaWidth = chartInnerWidth - yAxisWidth - 4;
+    
+    let equityData = [totalStartingBalance || 100000];
+    let eqVal = equityData[0];
+    allTrades.forEach(trade => {
+      eqVal += (trade.profitAndLoss || trade.pnl || 0);
+      equityData.push(eqVal);
+    });
+    
+    const maxDataPoints = chartAreaWidth - 5;
+    if (equityData.length > maxDataPoints) {
+      const step = Math.ceil(equityData.length / maxDataPoints);
+      equityData = equityData.filter((_, i) => i % step === 0);
+    }
+    
+    const chartConfig = {
+      height: 10,
+      colors: [equityData[equityData.length - 1] < equityData[0] ? asciichart.red : asciichart.green],
+      format: (x) => ('$' + (x / 1000).toFixed(0) + 'K').padStart(yAxisWidth)
+    };
+    
+    const chart = asciichart.plot(equityData, chartConfig);
+    chart.split('\n').forEach(line => {
+      let chartLine = '  ' + line;
+      const len = chartLine.replace(/\x1b\[[0-9;]*m/g, '').length;
+      if (len < chartInnerWidth) chartLine += ' '.repeat(chartInnerWidth - len);
+      console.log(chalk.cyan('\u2551') + chartLine + chalk.cyan('\u2551'));
+    });
+  } else {
+    const msg = connectionTypes.rithmic > 0 
+      ? '  NO TRADE HISTORY (RITHMIC DOES NOT PROVIDE TRADE HISTORY API)'
+      : '  NO TRADE DATA AVAILABLE';
+    console.log(chalk.cyan('\u2551') + chalk.gray(msg) + ' '.repeat(Math.max(0, chartInnerWidth - msg.length)) + chalk.cyan('\u2551'));
+  }
+  
+  drawBoxFooter(boxWidth);
+};
+
+/**
+ * Render Trades History section
+ * @param {Array} completedTrades - Completed trades (P&L != 0)
+ * @param {Object} connectionTypes - Connection type counts
+ * @param {Function} extractSymbol - Symbol extraction function
+ * @param {number} boxWidth - Box width
+ */
+const renderTradesHistory = (completedTrades, connectionTypes, extractSymbol, boxWidth) => {
+  drawBoxHeader('TRADES HISTORY', boxWidth);
+  
+  const innerWidth = boxWidth - 2;
+  
+  if (completedTrades.length > 0) {
+    const colTime = 9;
+    const colSymbol = 10;
+    const colSide = 6;
+    const colPnl = 10;
+    const colFees = 8;
+    const colNet = 10;
+    const fixedCols = colTime + colSymbol + colSide + colPnl + colFees + colNet;
+    const separatorChars = 6 * 2;
+    const leadingSpace = 1;
+    const colAccount = innerWidth - fixedCols - separatorChars - leadingSpace;
+    
+    const headerParts = [
+      ' ' + 'TIME'.padEnd(colTime),
+      'SYMBOL'.padEnd(colSymbol),
+      'SIDE'.padEnd(colSide),
+      'P&L'.padEnd(colPnl),
+      'FEES'.padEnd(colFees),
+      'NET'.padEnd(colNet),
+      'ACCOUNT'.padEnd(colAccount)
+    ];
+    const header = headerParts.join('| ');
+    console.log(chalk.cyan('\u2551') + chalk.white(header) + chalk.cyan('\u2551'));
+    console.log(chalk.cyan('\u255F') + chalk.cyan('\u2500'.repeat(innerWidth)) + chalk.cyan('\u2562'));
+    
+    const sortedTrades = [...completedTrades].sort((a, b) => {
+      const timeA = new Date(a.creationTimestamp || a.timestamp || 0).getTime();
+      const timeB = new Date(b.creationTimestamp || b.timestamp || 0).getTime();
+      return timeB - timeA;
+    });
+    
+    for (const trade of sortedTrades) {
+      const timestamp = trade.creationTimestamp || trade.timestamp;
+      const time = timestamp ? new Date(timestamp).toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', hour12: true }) : '--:--';
+      const symbol = extractSymbol(trade.contractId || trade.symbol);
+      const pnl = trade.profitAndLoss || trade.pnl || 0;
+      const fees = trade.fees || trade.commission || 0;
+      const netPnl = pnl - Math.abs(fees);
+      
+      const pnlText = pnl >= 0 ? `+$${pnl.toFixed(0)}` : `-$${Math.abs(pnl).toFixed(0)}`;
+      const feesText = fees !== 0 ? `-$${Math.abs(fees).toFixed(2)}` : '$0';
+      const netText = netPnl >= 0 ? `+$${netPnl.toFixed(0)}` : `-$${Math.abs(netPnl).toFixed(0)}`;
+      
+      const exitSide = trade.side;
+      const tradeSide = exitSide === 0 ? 'SHORT' : 'LONG';
+      const accountName = (trade.accountName || 'N/A').substring(0, colAccount - 3);
+      
+      const timeStr = time.padEnd(colTime);
+      const symbolStr = symbol.padEnd(colSymbol);
+      const sideStr = tradeSide.padEnd(colSide);
+      const pnlStr = pnlText.padEnd(colPnl);
+      const feesStr = feesText.padEnd(colFees);
+      const netStr = netText.padEnd(colNet);
+      const accountStr = accountName.padEnd(colAccount);
+      
+      const pnlColored = pnl >= 0 ? chalk.green(pnlStr) : chalk.red(pnlStr);
+      const feesColored = chalk.yellow(feesStr);
+      const netColored = netPnl >= 0 ? chalk.green(netStr) : chalk.red(netStr);
+      const sideColored = tradeSide === 'LONG' ? chalk.green(sideStr) : chalk.red(sideStr);
+      
+      const rowParts = [
+        ' ' + timeStr,
+        symbolStr,
+        sideColored,
+        pnlColored,
+        feesColored,
+        netColored,
+        accountStr
+      ];
+      const row = rowParts.join('| ');
+      console.log(chalk.cyan('\u2551') + row + chalk.cyan('\u2551'));
+    }
+    
+    if (sortedTrades.length === 0) {
+      const msg = '  NO COMPLETED TRADES YET';
+      console.log(chalk.cyan('\u2551') + chalk.gray(msg.padEnd(innerWidth)) + chalk.cyan('\u2551'));
+    }
+  } else {
+    const msg = connectionTypes.rithmic > 0 
+      ? '  NO TRADE HISTORY (RITHMIC API LIMITATION)'
+      : '  NO TRADE HISTORY AVAILABLE';
+    console.log(chalk.cyan('\u2551') + chalk.gray(msg.padEnd(innerWidth)) + chalk.cyan('\u2551'));
+  }
+  
+  drawBoxFooter(boxWidth);
+};
+
+/**
+ * Render HQX Score section
+ * @param {Object} hqxData - HQX score data from calculateHQXScore
+ * @param {number} boxWidth - Box width
+ */
+const renderHQXScore = (hqxData, boxWidth) => {
+  drawBoxHeader('HQX SCORE', boxWidth);
+  
+  const innerWidth = boxWidth - 2;
+  const { hqxScore, scoreGrade, metrics: metricsDisplay } = hqxData;
+  const scoreColor = hqxScore >= 70 ? chalk.green : hqxScore >= 50 ? chalk.yellow : chalk.red;
+  
+  const makeBar = (score, width = 20) => {
+    const filled = Math.round((score / 100) * width);
+    const empty = width - filled;
+    const color = score >= 70 ? chalk.green : score >= 50 ? chalk.yellow : chalk.red;
+    return color('\u2588'.repeat(filled)) + chalk.gray('\u2591'.repeat(empty));
+  };
+  
+  const barWidth = 30;
+  const labelWidth = 18;
+  
+  const overallLine = `  OVERALL SCORE: ${scoreColor(String(hqxScore))} / 100  [GRADE: ${scoreColor(scoreGrade)}]`;
+  const overallVisLen = overallLine.replace(/\x1b\[[0-9;]*m/g, '').length;
+  console.log(chalk.cyan('\u2551') + overallLine + ' '.repeat(innerWidth - overallVisLen) + chalk.cyan('\u2551'));
+  console.log(chalk.cyan('\u2551') + chalk.gray('\u2500'.repeat(innerWidth)) + chalk.cyan('\u2551'));
+  
+  for (const metric of metricsDisplay) {
+    const label = ('  ' + metric.name + ':').padEnd(labelWidth);
+    const bar = makeBar(metric.score, barWidth);
+    const pct = (metric.score.toFixed(0) + '%').padStart(5);
+    const line = label + bar + ' ' + pct;
+    const visLen = line.replace(/\x1b\[[0-9;]*m/g, '').length;
+    console.log(chalk.cyan('\u2551') + chalk.white(label) + bar + ' ' + chalk.white(pct) + ' '.repeat(innerWidth - visLen) + chalk.cyan('\u2551'));
+  }
+  
+  drawBoxFooter(boxWidth);
+};
+
+module.exports = {
+  renderAISupervision,
+  renderAIBehavior,
+  renderEquityCurve,
+  renderTradesHistory,
+  renderHQXScore,
+};