hedgequantx 2.7.98 → 2.8.0

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

@@ -0,0 +1,331 @@
+/**
+ * Copy Trading Executor - Execution engine for copy trading
+ * Handles signal processing, order placement, and AI supervision
+ */
+
+const readline = require('readline');
+const { connections } = require('../../services');
+const { AlgoUI, renderSessionSummary } = require('./ui');
+const { SupervisionEngine } = require('../../services/ai-supervision');
+const { M1 } = require('../../lib/m/s1');
+const { MarketDataFeed } = require('../../lib/data');
+
+/**
+ * Launch Copy Trading execution
+ */
+const launchCopyTrading = async (config) => {
+  const { lead, followers, contract, dailyTarget, maxRisk, showNames, supervisionConfig } = config;
+  
+  // Initialize AI Supervision if configured
+  const supervisionEnabled = supervisionConfig?.supervisionEnabled && supervisionConfig?.agents?.length > 0;
+  const supervisionEngine = supervisionEnabled ? new SupervisionEngine(supervisionConfig) : null;
+  const aiContext = { recentTicks: [], recentSignals: [], maxTicks: 100 };
+  
+  const leadAccount = lead.account;
+  const leadService = leadAccount.service || connections.getServiceForAccount(leadAccount.accountId);
+  const leadName = showNames 
+    ? (leadAccount.accountName || leadAccount.rithmicAccountId || leadAccount.accountId) 
+    : 'HQX Lead *****';
+  const symbolName = contract.name;
+  const contractId = contract.id;
+  const tickSize = contract.tickSize || 0.25;
+  
+  const followerNames = followers.map((f, i) => 
+    showNames ? (f.account.accountName || f.account.accountId) : `HQX Follower ${i + 1} *****`
+  );
+  
+  const ui = new AlgoUI({ 
+    subtitle: supervisionEnabled ? 'HQX Copy + AI' : 'HQX Copy Trading', 
+    mode: 'copy-trading' 
+  });
+  
+  const stats = {
+    accountName: leadName,
+    followerNames,
+    symbol: symbolName,
+    qty: lead.contracts,
+    followerQty: followers[0]?.contracts || lead.contracts,
+    target: dailyTarget,
+    risk: maxRisk,
+    propfirm: leadAccount.propfirm || 'Unknown',
+    platform: leadAccount.platform || 'Rithmic',
+    pnl: 0,
+    followerPnl: 0,
+    trades: 0,
+    wins: 0,
+    losses: 0,
+    latency: 0,
+    connected: false,
+    startTime: Date.now(),
+    followersCount: followers.length
+  };
+  
+  let running = true;
+  let stopReason = null;
+  let startingPnL = null;
+  let currentPosition = 0;
+  let pendingOrder = false;
+  let tickCount = 0;
+  
+  // Initialize Strategy
+  const strategy = new M1({ tickSize });
+  strategy.initialize(contractId, tickSize);
+  
+  // Initialize Market Data Feed
+  const marketFeed = new MarketDataFeed({ propfirm: leadAccount.propfirm });
+  
+  // Log startup
+  ui.addLog('info', `Lead: ${leadName} | Followers: ${followers.length}`);
+  ui.addLog('info', `Symbol: ${symbolName} | Qty: ${lead.contracts}/${followers[0]?.contracts}`);
+  ui.addLog('info', `Target: $${dailyTarget} | Risk: $${maxRisk}`);
+  if (supervisionEnabled) ui.addLog('info', `AI: ${supervisionEngine.getActiveCount()} agents`);
+  ui.addLog('info', 'Connecting...');
+  
+  // Handle strategy signals
+  strategy.on('signal', async (signal) => {
+    if (!running || pendingOrder || currentPosition !== 0) return;
+    
+    let { direction, entry, stopLoss, takeProfit, confidence } = signal;
+    
+    aiContext.recentSignals.push({ ...signal, timestamp: Date.now() });
+    if (aiContext.recentSignals.length > 10) aiContext.recentSignals.shift();
+    
+    ui.addLog('signal', `${direction.toUpperCase()} @ ${entry.toFixed(2)} (${(confidence * 100).toFixed(0)}%)`);
+    
+    // AI Supervision
+    if (supervisionEnabled && supervisionEngine) {
+      const result = await supervisionEngine.supervise({
+        symbolId: symbolName,
+        signal: { direction, entry, stopLoss, takeProfit, confidence },
+        recentTicks: aiContext.recentTicks,
+        recentSignals: aiContext.recentSignals,
+        stats,
+        config: { dailyTarget, maxRisk }
+      });
+      
+      if (result.decision === 'reject') {
+        ui.addLog('info', `AI rejected: ${result.reason}`);
+        return;
+      }
+      
+      // Apply optimizations
+      if (result.optimizedSignal?.aiOptimized) {
+        const opt = result.optimizedSignal;
+        if (opt.entry) entry = opt.entry;
+        if (opt.stopLoss) stopLoss = opt.stopLoss;
+        if (opt.takeProfit) takeProfit = opt.takeProfit;
+      }
+      ui.addLog('info', `AI ${result.decision} (${result.confidence}%)`);
+    }
+    
+    // Execute orders
+    pendingOrder = true;
+    try {
+      const orderSide = direction === 'long' ? 0 : 1;
+      
+      // Place order on LEAD
+      const leadResult = await leadService.placeOrder({
+        accountId: leadAccount.accountId,
+        contractId,
+        type: 2,
+        side: orderSide,
+        size: lead.contracts
+      });
+      
+      if (leadResult.success) {
+        currentPosition = direction === 'long' ? lead.contracts : -lead.contracts;
+        stats.trades++;
+        ui.addLog('trade', `LEAD: ${direction.toUpperCase()} ${lead.contracts}x`);
+        
+        // Place orders on FOLLOWERS
+        await placeFollowerOrders(followers, contractId, orderSide, direction, ui);
+        
+        // Bracket orders on lead
+        if (stopLoss && takeProfit) {
+          await placeBracketOrders(leadService, leadAccount, contractId, direction, lead.contracts, stopLoss, takeProfit);
+          ui.addLog('info', `SL: ${stopLoss.toFixed(2)} | TP: ${takeProfit.toFixed(2)}`);
+        }
+      } else {
+        ui.addLog('error', `Lead failed: ${leadResult.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();
+    
+    aiContext.recentTicks.push(tick);
+    if (aiContext.recentTicks.length > aiContext.maxTicks) aiContext.recentTicks.shift();
+    
+    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;
+    if (tickCount % 100 === 0) ui.addLog('info', `#${tickCount} @ ${tick.price?.toFixed(2) || 'N/A'}`);
+  });
+  
+  marketFeed.on('connected', () => { stats.connected = true; ui.addLog('success', 'Connected!'); });
+  marketFeed.on('error', (err) => ui.addLog('error', `Market: ${err.message}`));
+  marketFeed.on('disconnected', () => { stats.connected = false; ui.addLog('error', 'Disconnected'); });
+  
+  // Connect to market data
+  try {
+    const token = leadService.token || leadService.getToken?.();
+    const pk = (leadAccount.propfirm || 'topstep').toLowerCase().replace(/\s+/g, '_');
+    await marketFeed.connect(token, pk, contractId);
+    await marketFeed.subscribe(symbolName, contractId);
+  } catch (e) {
+    ui.addLog('error', `Connect failed: ${e.message}`);
+  }
+  
+  // Poll P&L
+  const pollPnL = async () => {
+    try {
+      const res = await leadService.getTradingAccounts();
+      if (res.success && res.accounts) {
+        const acc = res.accounts.find(a => a.accountId === leadAccount.accountId);
+        if (acc?.profitAndLoss !== undefined) {
+          if (startingPnL === null) startingPnL = acc.profitAndLoss;
+          stats.pnl = acc.profitAndLoss - startingPnL;
+        }
+      }
+      if (stats.pnl >= dailyTarget) {
+        stopReason = 'target';
+        running = false;
+        ui.addLog('success', `TARGET! +$${stats.pnl.toFixed(2)}`);
+      } else if (stats.pnl <= -maxRisk) {
+        stopReason = 'risk';
+        running = false;
+        ui.addLog('error', `RISK! -$${Math.abs(stats.pnl).toFixed(2)}`);
+      }
+    } catch (e) { /* silent */ }
+  };
+  
+  // Start intervals
+  const refreshInterval = setInterval(() => { if (running) ui.render(stats); }, 250);
+  const pnlInterval = setInterval(() => { if (running) pollPnL(); }, 2000);
+  pollPnL();
+  
+  // Keyboard handler
+  const cleanupKeys = setupKeyHandler(() => { running = false; stopReason = 'manual'; });
+  
+  // 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`;
+  
+  renderSessionSummary(stats, stopReason);
+  
+  console.log('\n  Returning to menu in 3 seconds...');
+  await new Promise(resolve => setTimeout(resolve, 3000));
+};
+
+/**
+ * Place orders on all follower accounts
+ */
+const placeFollowerOrders = async (followers, contractId, orderSide, direction, ui) => {
+  for (let i = 0; i < followers.length; i++) {
+    const f = followers[i];
+    const fService = f.account.service || connections.getServiceForAccount(f.account.accountId);
+    
+    try {
+      const fResult = await fService.placeOrder({
+        accountId: f.account.accountId,
+        contractId,
+        type: 2,
+        side: orderSide,
+        size: f.contracts
+      });
+      
+      if (fResult.success) {
+        ui.addLog('trade', `F${i + 1}: ${direction.toUpperCase()} ${f.contracts}x`);
+      } else {
+        ui.addLog('error', `F${i + 1}: Failed`);
+      }
+    } catch (e) {
+      ui.addLog('error', `F${i + 1}: ${e.message}`);
+    }
+  }
+};
+
+/**
+ * Place bracket orders (stop loss and take profit)
+ */
+const placeBracketOrders = async (service, account, contractId, direction, size, stopLoss, takeProfit) => {
+  const exitSide = direction === 'long' ? 1 : 0;
+  
+  await service.placeOrder({
+    accountId: account.accountId,
+    contractId,
+    type: 4,
+    side: exitSide,
+    size,
+    stopPrice: stopLoss
+  });
+  
+  await service.placeOrder({
+    accountId: account.accountId,
+    contractId,
+    type: 1,
+    side: exitSide,
+    size,
+    limitPrice: takeProfit
+  });
+};
+
+/**
+ * Setup keyboard handler for stopping
+ */
+const setupKeyHandler = (onStop) => {
+  if (!process.stdin.isTTY) return null;
+  
+  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'))) {
+      onStop();
+    }
+  };
+  
+  process.stdin.on('keypress', onKey);
+  
+  return () => {
+    process.stdin.removeListener('keypress', onKey);
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+  };
+};
+
+module.exports = { launchCopyTrading };

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

@@ -1,20 +1,18 @@
 /**
  * Copy Trading Mode - HQX Ultra Scalping
  * Same as One Account but copies trades to multiple followers
+ * Supports multi-agent AI supervision
  */
 
 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');
-
-// Strategy & Market Data
-const { M1 } = require('../../lib/m/s1');
-const { MarketDataFeed } = require('../../lib/data');
+const { getActiveAgentCount, getSupervisionConfig, getActiveAgents } = require('../ai-agents');
+const { launchCopyTrading } = require('./copy-executor');
+const { runPreflightCheck, formatPreflightResults, getPreflightSummary } = require('../../services/ai-supervision');
 
 /**
  * Copy Trading Menu
@@ -144,6 +142,43 @@ const copyTradingMenu = async () => {
   const showNames = await prompts.confirmPrompt('Show account names?', false);
   if (showNames === null) 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();
+    }
+  }
+  
   // Summary
   console.log();
   console.log(chalk.white.bold('  SUMMARY:'));
@@ -154,6 +189,7 @@ const copyTradingMenu = async () => {
     console.log(chalk.yellow(`    - ${f.propfirm} x${followerContracts}`));
   }
   console.log(chalk.cyan(`  Target: $${dailyTarget} | Risk: $${maxRisk}`));
+  if (supervisionConfig) console.log(chalk.green(`  AI Supervision: ${agentCount} agent(s)`));
   console.log();
   
   const confirm = await prompts.confirmPrompt('Start Copy Trading?', true);
@@ -165,7 +201,8 @@ const copyTradingMenu = async () => {
     contract,
     dailyTarget,
     maxRisk,
-    showNames
+    showNames,
+    supervisionConfig
   });
 };
 
@@ -209,260 +246,4 @@ const selectSymbol = async (service) => {
   return selected === 'back' || selected === null ? null : selected;
 };
 
-/**
- * Launch Copy Trading - HQX Ultra Scalping with trade copying
- */
-const launchCopyTrading = async (config) => {
-  const { lead, followers, contract, dailyTarget, maxRisk, showNames } = config;
-  
-  const leadAccount = lead.account;
-  const leadService = leadAccount.service || connections.getServiceForAccount(leadAccount.accountId);
-  const leadName = showNames 
-    ? (leadAccount.accountName || leadAccount.rithmicAccountId || leadAccount.accountId) 
-    : 'HQX Lead *****';
-  const symbolName = contract.name;
-  const contractId = contract.id;
-  const tickSize = contract.tickSize || 0.25;
-  
-  const followerNames = followers.map((f, i) => 
-    showNames ? (f.account.accountName || f.account.accountId) : `HQX Follower ${i + 1} *****`
-  );
-  
-  const ui = new AlgoUI({ subtitle: 'HQX Copy Trading', mode: 'copy-trading' });
-  
-  const stats = {
-    accountName: leadName,
-    followerNames,
-    symbol: symbolName,
-    qty: lead.contracts,
-    followerQty: followers[0]?.contracts || lead.contracts,
-    target: dailyTarget,
-    risk: maxRisk,
-    propfirm: leadAccount.propfirm || 'Unknown',
-    platform: leadAccount.platform || 'Rithmic',
-    pnl: 0,
-    followerPnl: 0,
-    trades: 0,
-    wins: 0,
-    losses: 0,
-    latency: 0,
-    connected: false,
-    startTime: Date.now(),
-    followersCount: followers.length
-  };
-  
-  let running = true;
-  let stopReason = null;
-  let startingPnL = null;
-  let currentPosition = 0;
-  let pendingOrder = false;
-  let tickCount = 0;
-  
-  // Initialize Strategy
-  const strategy = new M1({ tickSize });
-  strategy.initialize(contractId, tickSize);
-  
-  // Initialize Market Data Feed
-  const marketFeed = new MarketDataFeed({ propfirm: leadAccount.propfirm });
-  
-  // Log startup
-  ui.addLog('info', `Lead: ${leadName} | Followers: ${followers.length}`);
-  ui.addLog('info', `Symbol: ${symbolName} | Lead Qty: ${lead.contracts} | Follower Qty: ${followers[0]?.contracts}`);
-  ui.addLog('info', `Target: $${dailyTarget} | Max Risk: $${maxRisk}`);
-  ui.addLog('info', 'Connecting to market data...');
-  
-  // Handle strategy signals - place on lead AND all followers
-  strategy.on('signal', async (signal) => {
-    if (!running || pendingOrder || currentPosition !== 0) return;
-    
-    const { direction, entry, stopLoss, takeProfit, confidence } = signal;
-    
-    ui.addLog('signal', `${direction.toUpperCase()} signal @ ${entry.toFixed(2)} (${(confidence * 100).toFixed(0)}%)`);
-    
-    pendingOrder = true;
-    try {
-      const orderSide = direction === 'long' ? 0 : 1;
-      
-      // Place order on LEAD
-      const leadResult = await leadService.placeOrder({
-        accountId: leadAccount.accountId,
-        contractId: contractId,
-        type: 2,
-        side: orderSide,
-        size: lead.contracts
-      });
-      
-      if (leadResult.success) {
-        currentPosition = direction === 'long' ? lead.contracts : -lead.contracts;
-        stats.trades++;
-        ui.addLog('trade', `LEAD: ${direction.toUpperCase()} ${lead.contracts}x @ market`);
-        
-        // Place orders on ALL FOLLOWERS
-        for (let i = 0; i < followers.length; i++) {
-          const f = followers[i];
-          const fService = f.account.service || connections.getServiceForAccount(f.account.accountId);
-          
-          try {
-            const fResult = await fService.placeOrder({
-              accountId: f.account.accountId,
-              contractId: contractId,
-              type: 2,
-              side: orderSide,
-              size: f.contracts
-            });
-            
-            if (fResult.success) {
-              ui.addLog('trade', `FOLLOWER ${i + 1}: ${direction.toUpperCase()} ${f.contracts}x @ market`);
-            } else {
-              ui.addLog('error', `FOLLOWER ${i + 1}: Order failed`);
-            }
-          } catch (e) {
-            ui.addLog('error', `FOLLOWER ${i + 1}: ${e.message}`);
-          }
-        }
-        
-        // Place bracket orders on lead (SL/TP)
-        if (stopLoss && takeProfit) {
-          await leadService.placeOrder({
-            accountId: leadAccount.accountId, contractId, type: 4,
-            side: direction === 'long' ? 1 : 0, size: lead.contracts, stopPrice: stopLoss
-          });
-          await leadService.placeOrder({
-            accountId: leadAccount.accountId, contractId, type: 1,
-            side: direction === 'long' ? 1 : 0, size: lead.contracts, limitPrice: takeProfit
-          });
-          ui.addLog('info', `SL: ${stopLoss.toFixed(2)} | TP: ${takeProfit.toFixed(2)}`);
-        }
-      } else {
-        ui.addLog('error', `Lead order failed: ${leadResult.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();
-    
-    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;
-    
-    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 = leadService.token || leadService.getToken?.();
-    const propfirmKey = (leadAccount.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 P&L from lead and followers
-  const pollPnL = async () => {
-    try {
-      // Lead P&L
-      const leadResult = await leadService.getTradingAccounts();
-      if (leadResult.success && leadResult.accounts) {
-        const acc = leadResult.accounts.find(a => a.accountId === leadAccount.accountId);
-        if (acc && acc.profitAndLoss !== undefined) {
-          if (startingPnL === null) startingPnL = acc.profitAndLoss;
-          stats.pnl = acc.profitAndLoss - startingPnL;
-        }
-      }
-      
-      // 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) { /* silent */ }
-  };
-  
-  // Start intervals
-  const refreshInterval = setInterval(() => { if (running) ui.render(stats); }, 250);
-  const pnlInterval = setInterval(() => { if (running) pollPnL(); }, 2000);
-  pollPnL();
-  
-  // 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`;
-  
-  renderSessionSummary(stats, stopReason);
-  
-  console.log('\n  Returning to menu in 3 seconds...');
-  await new Promise(resolve => setTimeout(resolve, 3000));
-};
-
 module.exports = { copyTradingMenu };