hedgequantx 2.9.19 → 2.9.20

package/src/pages/ai-models.js

@@ -1,389 +0,0 @@
-/**
- * AI Models - Fetch from provider APIs
- * 
- * Models are fetched dynamically from each provider's API.
- * Exception: MiniMax (no /models API) - see RULES.md for details.
- */
-
-const https = require('https');
-
-/**
- * API endpoints for fetching models
- * null = provider doesn't have /models endpoint
- */
-const API_ENDPOINTS = {
-  anthropic: 'https://api.anthropic.com/v1/models',
-  openai: 'https://api.openai.com/v1/models',
-  google: 'https://generativelanguage.googleapis.com/v1beta/models',
-  minimax: null, // No /models API - uses MINIMAX_MODELS (see RULES.md exception)
-  deepseek: 'https://api.deepseek.com/v1/models',
-  mistral: 'https://api.mistral.ai/v1/models',
-  xai: 'https://api.x.ai/v1/models',
-  openrouter: 'https://openrouter.ai/api/v1/models',
-};
-
-/**
- * MiniMax Models - EXCEPTION to no-hardcode rule (see RULES.md)
- * 
- * MiniMax does not provide /models API endpoint.
- * Confirmed by: OpenCode, Cursor, LiteLLM - all use hardcoded models.
- * Source: https://platform.minimax.io/docs/api-reference/text-intro
- */
-const MINIMAX_MODELS = [
-  { id: 'MiniMax-M2.1', name: 'MiniMax-M2.1' },
-];
-
-/**
- * Make HTTPS request
- * @param {string} url - API URL
- * @param {Object} headers - Request headers
- * @param {number} timeout - Timeout in ms (default 60000 per RULES.md #15)
- * @returns {Promise<Object>} Response data
- */
-const fetchApi = (url, headers = {}, timeout = 60000) => {
-  return new Promise((resolve, reject) => {
-    const urlObj = new URL(url);
-    const options = {
-      hostname: urlObj.hostname,
-      path: urlObj.pathname + urlObj.search,
-      method: 'GET',
-      headers: {
-        'Content-Type': 'application/json',
-        ...headers
-      },
-      timeout
-    };
-
-    const req = https.request(options, (res) => {
-      let data = '';
-      res.on('data', chunk => data += chunk);
-      res.on('end', () => {
-        try {
-          if (res.statusCode >= 200 && res.statusCode < 300) {
-            resolve({ success: true, data: JSON.parse(data) });
-          } else {
-            resolve({ success: false, error: `HTTP ${res.statusCode}` });
-          }
-        } catch (error) {
-          resolve({ success: false, error: 'Invalid JSON response' });
-        }
-      });
-    });
-
-    req.on('error', (error) => {
-      resolve({ success: false, error: error.message });
-    });
-
-    req.on('timeout', () => {
-      req.destroy();
-      resolve({ success: false, error: 'Request timeout' });
-    });
-
-    req.end();
-  });
-};
-
-/**
- * Get auth headers for provider
- * @param {string} providerId - Provider ID
- * @param {string} apiKey - API key
- * @returns {Object} Headers object
- */
-const getAuthHeaders = (providerId, apiKey) => {
-  if (!apiKey) return {};
-  
-  switch (providerId) {
-    case 'anthropic':
-      return { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' };
-    case 'openai':
-    case 'deepseek':
-    case 'minimax':
-    case 'xai':
-    case 'openrouter':
-    case 'mistral':
-      return { 'Authorization': `Bearer ${apiKey}` };
-    case 'google':
-      return {}; // Google uses query param
-    default:
-      return { 'Authorization': `Bearer ${apiKey}` };
-  }
-};
-
-/**
- * Excluded patterns - models NOT suitable for algo trading
- * These are image, audio, embedding, moderation models
- */
-const EXCLUDED_PATTERNS = [
-  'whisper', 'tts', 'dall-e', 'embedding', 'embed', 'moderation',
-  'image', 'vision', 'audio', 'speech', 'realtime', 'transcription',
-  'aqa', 'gecko', 'bison', 'learnlm'
-];
-
-/**
- * Check if model should be excluded (not for algo trading)
- * @param {string} modelId - Model ID
- * @returns {boolean} True if should be excluded
- */
-const shouldExcludeModel = (modelId) => {
-  const id = modelId.toLowerCase();
-  return EXCLUDED_PATTERNS.some(pattern => id.includes(pattern));
-};
-
-/**
- * Extract version number from model ID for sorting
- * @param {string} modelId - Model ID
- * @returns {number} Version number (higher = newer)
- */
-const extractVersion = (modelId) => {
-  const id = modelId.toLowerCase();
-  
-  // Gemini: gemini-3 > gemini-2.5 > gemini-2.0
-  const geminiMatch = id.match(/gemini-(\d+\.?\d*)/);
-  if (geminiMatch) return parseFloat(geminiMatch[1]) * 100;
-  
-  // Claude: opus-4.5 > opus-4 > sonnet-4 > haiku
-  if (id.includes('opus-4.5') || id.includes('opus-4-5')) return 450;
-  if (id.includes('opus-4.1') || id.includes('opus-4-1')) return 410;
-  if (id.includes('opus-4')) return 400;
-  if (id.includes('sonnet-4.5') || id.includes('sonnet-4-5')) return 350;
-  if (id.includes('sonnet-4')) return 340;
-  if (id.includes('haiku-4.5') || id.includes('haiku-4-5')) return 250;
-  if (id.includes('sonnet-3.7') || id.includes('3-7-sonnet')) return 237;
-  if (id.includes('sonnet-3.5') || id.includes('3-5-sonnet')) return 235;
-  if (id.includes('haiku-3.5') || id.includes('3-5-haiku')) return 135;
-  if (id.includes('opus')) return 300;
-  if (id.includes('sonnet')) return 200;
-  if (id.includes('haiku')) return 100;
-  
-  // GPT: gpt-4o > gpt-4-turbo > gpt-4 > gpt-3.5
-  if (id.includes('gpt-4o')) return 450;
-  if (id.includes('gpt-4-turbo')) return 420;
-  if (id.includes('gpt-4')) return 400;
-  if (id.includes('gpt-3.5')) return 350;
-  if (id.includes('o1')) return 500; // o1 reasoning models
-  if (id.includes('o3')) return 530; // o3 reasoning models
-  
-  // Mistral: large > medium > small
-  if (id.includes('large')) return 300;
-  if (id.includes('medium')) return 200;
-  if (id.includes('small') || id.includes('tiny')) return 100;
-  
-  // Default
-  return 50;
-};
-
-/**
- * Get model tier for display (Pro/Flash/Lite)
- * @param {string} modelId - Model ID
- * @returns {number} Tier weight (higher = more powerful)
- */
-const getModelTier = (modelId) => {
-  const id = modelId.toLowerCase();
-  if (id.includes('pro') || id.includes('opus') || id.includes('large')) return 30;
-  if (id.includes('flash') || id.includes('sonnet') || id.includes('medium')) return 20;
-  if (id.includes('lite') || id.includes('haiku') || id.includes('small')) return 10;
-  return 15;
-};
-
-/**
- * Parse models response based on provider - filtered for algo trading
- * @param {string} providerId - Provider ID
- * @param {Object} data - API response data
- * @returns {Array} Parsed and filtered models list
- */
-const parseModelsResponse = (providerId, data) => {
-  if (!data) return [];
-  
-  try {
-    let models = [];
-    
-    switch (providerId) {
-      case 'anthropic':
-        // Anthropic returns { data: [{ id, display_name, ... }] }
-        models = (data.data || [])
-          .filter(m => m.id && !shouldExcludeModel(m.id))
-          .map(m => ({
-            id: m.id,
-            name: m.display_name || m.id
-          }));
-        break;
-      
-      case 'openai':
-        // OpenAI format: { data: [{ id, ... }] }
-        models = (data.data || [])
-          .filter(m => m.id && !shouldExcludeModel(m.id))
-          .filter(m => m.id.startsWith('gpt-') || m.id.startsWith('o1') || m.id.startsWith('o3'))
-          .map(m => ({
-            id: m.id,
-            name: m.id
-          }));
-        break;
-      
-      case 'google':
-        // Google format: { models: [{ name, displayName, supportedGenerationMethods }] }
-        models = (data.models || [])
-          .filter(m => {
-            const id = m.name?.replace('models/', '') || '';
-            // Only Gemini chat models
-            return id.startsWith('gemini-') && 
-                   !shouldExcludeModel(id) &&
-                   m.supportedGenerationMethods?.includes('generateContent');
-          })
-          .map(m => ({
-            id: m.name?.replace('models/', '') || m.name,
-            name: m.displayName || m.name
-          }));
-        break;
-      
-      case 'deepseek':
-        // DeepSeek format: { data: [{ id, ... }] } - OpenAI compatible
-        models = (data.data || [])
-          .filter(m => m.id && !shouldExcludeModel(m.id))
-          .filter(m => m.id.includes('deepseek'))
-          .map(m => ({
-            id: m.id,
-            name: m.id
-          }));
-        break;
-      
-      case 'minimax':
-        // MiniMax format: { data: [{ id, ... }] } or { models: [...] }
-        models = (data.data || data.models || [])
-          .filter(m => (m.id || m.model) && !shouldExcludeModel(m.id || m.model))
-          .map(m => ({
-            id: m.id || m.model,
-            name: m.id || m.model
-          }));
-        break;
-      
-      case 'xai':
-        // xAI format: { data: [{ id, ... }] }
-        models = (data.data || [])
-          .filter(m => m.id && !shouldExcludeModel(m.id))
-          .filter(m => m.id.includes('grok'))
-          .map(m => ({
-            id: m.id,
-            name: m.id
-          }));
-        break;
-      
-      case 'mistral':
-        // Mistral format: { data: [{ id, ... }] }
-        models = (data.data || [])
-          .filter(m => m.id && !shouldExcludeModel(m.id))
-          .map(m => ({
-            id: m.id,
-            name: m.id
-          }));
-        break;
-      
-      case 'perplexity':
-        // Perplexity format varies
-        models = (data.models || data.data || [])
-          .filter(m => (m.id || m.model) && !shouldExcludeModel(m.id || m.model))
-          .map(m => ({
-            id: m.id || m.model,
-            name: m.id || m.model
-          }));
-        break;
-      
-      case 'openrouter':
-        // OpenRouter format: { data: [{ id, name, ... }] }
-        // Filter to show only main providers' chat models
-        models = (data.data || [])
-          .filter(m => {
-            if (!m.id || shouldExcludeModel(m.id)) return false;
-            // Only keep major providers for trading
-            const validPrefixes = [
-              'anthropic/claude', 'openai/gpt', 'openai/o1', 'openai/o3',
-              'google/gemini', 'mistralai/', 'meta-llama/', 'x-ai/grok'
-            ];
-            return validPrefixes.some(p => m.id.startsWith(p));
-          })
-          .map(m => ({
-            id: m.id,
-            name: m.name || m.id
-          }));
-        break;
-      
-      default:
-        return [];
-    }
-    
-    // Sort by version (newest first), then by tier (most powerful first)
-    return models.sort((a, b) => {
-      const versionDiff = extractVersion(b.id) - extractVersion(a.id);
-      if (versionDiff !== 0) return versionDiff;
-      return getModelTier(b.id) - getModelTier(a.id);
-    });
-    
-  } catch (error) {
-    return [];
-  }
-};
-
-/**
- * Fetch models from provider API
- * @param {string} providerId - Provider ID
- * @param {string} apiKey - API key (required for most providers)
- * @returns {Promise<Object>} { success, models, error }
- */
-const fetchModelsFromApi = async (providerId, apiKey) => {
-  // MiniMax: no /models API, use hardcoded list (see RULES.md exception)
-  if (providerId === 'minimax') {
-    return { success: true, models: MINIMAX_MODELS, error: null };
-  }
-  
-  const endpoint = API_ENDPOINTS[providerId];
-  
-  if (!endpoint) {
-    return { success: false, models: [], error: 'Unknown provider' };
-  }
-  
-  // Build URL (Google needs API key in query)
-  let url = endpoint;
-  if (providerId === 'google' && apiKey) {
-    url += `?key=${apiKey}`;
-  }
-  
-  const headers = getAuthHeaders(providerId, apiKey);
-  const result = await fetchApi(url, headers);
-  
-  if (!result.success) {
-    return { success: false, models: [], error: result.error };
-  }
-  
-  const models = parseModelsResponse(providerId, result.data);
-  
-  if (models.length === 0) {
-    return { success: false, models: [], error: 'No models returned' };
-  }
-  
-  return { success: true, models, error: null };
-};
-
-/**
- * Get models for a provider - returns empty, use fetchModelsFromApi
- * @param {string} providerId - Provider ID
- * @returns {Array} Empty array
- */
-const getModelsForProvider = (providerId) => {
-  return [];
-};
-
-/**
- * Get model by ID - returns null, use API data
- * @param {string} providerId - Provider ID  
- * @param {string} modelId - Model ID
- * @returns {null} Always null
- */
-const getModelById = (providerId, modelId) => {
-  return null;
-};
-
-module.exports = {
-  fetchModelsFromApi,
-  getModelsForProvider,
-  getModelById,
-  API_ENDPOINTS
-};

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

@@ -1,307 +0,0 @@
-/**
- * Algo Executor - Shared execution engine for all algo modes
- * Handles market data, signals, orders, and P&L tracking
- * Supports multi-agent AI supervision for signal optimization
- */
-
-const readline = require('readline');
-const { AlgoUI, renderSessionSummary } = require('./ui');
-const { M1 } = require('../../lib/m/s1');
-const { MarketDataFeed } = require('../../lib/data');
-const { SupervisionEngine } = require('../../services/ai-supervision');
-
-/**
- * Execute algo strategy with market data
- * @param {Object} params - Execution parameters
- * @param {Object} params.service - Trading service (Rithmic/ProjectX)
- * @param {Object} params.account - Account object
- * @param {Object} params.contract - Contract object
- * @param {Object} params.config - Algo config (contracts, target, risk, showName)
- * @param {Object} params.options - Optional: supervisionConfig for multi-agent AI
- */
-const executeAlgo = async ({ service, account, contract, config, options = {} }) => {
-  const { contracts, dailyTarget, maxRisk, showName } = config;
-  const { supervisionConfig, subtitle } = options;
-  
-  // Initialize AI Supervision Engine if configured
-  const supervisionEnabled = supervisionConfig?.supervisionEnabled && supervisionConfig?.agents?.length > 0;
-  const supervisionEngine = supervisionEnabled ? new SupervisionEngine(supervisionConfig) : null;
-  
-  const accountName = showName 
-    ? (account.accountName || account.rithmicAccountId || account.accountId) 
-    : 'HQX *****';
-  const symbolName = contract.name;
-  const contractId = contract.id;
-  const tickSize = contract.tickSize || 0.25;
-  
-  const ui = new AlgoUI({ 
-    subtitle: subtitle || (supervisionEnabled ? 'HQX + AI SUPERVISION' : 'HQX Ultra Scalping'), 
-    mode: 'one-account' 
-  });
-  
-  const stats = {
-    accountName,
-    symbol: symbolName,
-    qty: contracts,
-    target: dailyTarget,
-    risk: maxRisk,
-    propfirm: account.propfirm || 'Unknown',
-    platform: account.platform || 'Rithmic',
-    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;
-  let pendingOrder = false;
-  let tickCount = 0;
-  
-  // Context for AI supervision
-  const aiContext = { recentTicks: [], recentSignals: [], recentTrades: [], maxTicks: 100 };
-  
-  // Initialize Strategy
-  const strategy = new M1({ tickSize });
-  strategy.initialize(contractId, tickSize);
-  
-  // Initialize Market Data Feed
-  const marketFeed = new MarketDataFeed({ propfirm: account.propfirm });
-  
-  // Log startup
-  ui.addLog('info', `Strategy: ${supervisionEnabled ? 'HQX + AI Supervision' : 'HQX Ultra Scalping'}`);
-  ui.addLog('info', `Account: ${accountName}`);
-  ui.addLog('info', `Symbol: ${symbolName} | Qty: ${contracts}`);
-  ui.addLog('info', `Target: $${dailyTarget} | Risk: $${maxRisk}`);
-  if (supervisionEnabled) {
-    const agentCount = supervisionEngine.getActiveCount();
-    ui.addLog('info', `AI Agents: ${agentCount} active`);
-  }
-  ui.addLog('info', 'Connecting to market data...');
-  
-  // Handle strategy signals
-  strategy.on('signal', async (signal) => {
-    if (!running || pendingOrder || currentPosition !== 0) return;
-    
-    let { direction, entry, stopLoss, takeProfit, confidence } = signal;
-    let orderSize = contracts;
-    
-    aiContext.recentSignals.push({ ...signal, timestamp: Date.now() });
-    if (aiContext.recentSignals.length > 10) aiContext.recentSignals.shift();
-    
-    ui.addLog('info', `Signal: ${direction.toUpperCase()} @ ${entry.toFixed(2)} (${(confidence * 100).toFixed(0)}%)`);
-    
-    // Multi-Agent AI Supervision
-    if (supervisionEnabled && supervisionEngine) {
-      ui.addLog('info', 'AI analyzing signal...');
-      
-      const supervisionResult = await supervisionEngine.supervise({
-        symbolId: symbolName,
-        signal: { direction, entry, stopLoss, takeProfit, confidence, size: contracts },
-        recentTicks: aiContext.recentTicks,
-        recentSignals: aiContext.recentSignals,
-        recentTrades: aiContext.recentTrades,
-        stats,
-        config: { dailyTarget, maxRisk }
-      });
-      
-      if (!supervisionResult.success) {
-        ui.addLog('info', `AI: ${supervisionResult.reason || 'Error'}`);
-      } else if (supervisionResult.decision === 'reject') {
-        ui.addLog('info', `AI rejected (${supervisionResult.confidence}%): ${supervisionResult.reason}`);
-        return;
-      } else {
-        // Apply optimizations
-        const opt = supervisionResult.optimizedSignal;
-        if (opt.aiOptimized) {
-          if (opt.entry !== entry) entry = opt.entry;
-          if (opt.stopLoss !== stopLoss) stopLoss = opt.stopLoss;
-          if (opt.takeProfit !== takeProfit) takeProfit = opt.takeProfit;
-          if (opt.size && opt.size !== contracts) orderSize = opt.size;
-        }
-        const action = supervisionResult.decision === 'modify' ? 'optimized' : 'approved';
-        ui.addLog('info', `AI ${action} (${supervisionResult.confidence}%): ${supervisionResult.reason}`);
-        
-        // Check timing
-        if (opt.aiTiming === 'wait') {
-          ui.addLog('info', 'AI: Wait for better entry');
-          return;
-        } else if (opt.aiTiming === 'cancel') {
-          ui.addLog('info', 'AI: Signal cancelled');
-          return;
-        }
-      }
-    }
-    
-    // Place order
-    pendingOrder = true;
-    try {
-      const orderSide = direction === 'long' ? 0 : 1;
-      const orderResult = await service.placeOrder({
-        accountId: account.accountId,
-        contractId: contractId,
-        type: 2,
-        side: orderSide,
-        size: orderSize
-      });
-      
-      if (orderResult.success) {
-        currentPosition = direction === 'long' ? orderSize : -orderSize;
-        stats.trades++;
-        ui.addLog('fill_' + (direction === 'long' ? 'buy' : 'sell'), 
-          `OPENED ${direction.toUpperCase()} ${orderSize}x @ market`);
-        
-        // Bracket orders
-        if (stopLoss && takeProfit) {
-          await service.placeOrder({
-            accountId: account.accountId, contractId, type: 4,
-            side: direction === 'long' ? 1 : 0, size: orderSize, stopPrice: stopLoss
-          });
-          await service.placeOrder({
-            accountId: account.accountId, contractId, type: 1,
-            side: direction === 'long' ? 1 : 0, size: orderSize, 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();
-    
-    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', `Tick #${tickCount} @ ${tick.price?.toFixed(2) || 'N/A'}`);
-  });
-  
-  marketFeed.on('connected', () => { stats.connected = true; ui.addLog('connected', 'Market data connected!'); });
-  marketFeed.on('error', (err) => ui.addLog('error', `Market: ${err.message}`));
-  marketFeed.on('disconnected', () => { stats.connected = false; ui.addLog('error', 'Market 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 P&L
-  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;
-          if (stats.pnl !== 0) strategy.recordTradeResult(stats.pnl);
-        }
-      }
-      
-      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 pnl = pos.profitAndLoss || 0;
-          if (pnl > 0) stats.wins = Math.max(stats.wins, 1);
-          else if (pnl < 0) stats.losses = Math.max(stats.losses, 1);
-        } else {
-          currentPosition = 0;
-        }
-      }
-      
-      if (stats.pnl >= dailyTarget) {
-        stopReason = 'target'; running = false;
-        ui.addLog('fill_win', `TARGET REACHED! +$${stats.pnl.toFixed(2)}`);
-      } else if (stats.pnl <= -maxRisk) {
-        stopReason = 'risk'; running = false;
-        ui.addLog('fill_loss', `MAX RISK! -$${Math.abs(stats.pnl).toFixed(2)}`);
-      }
-    } catch (e) { /* silent */ }
-  };
-  
-  // Start loops
-  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 = { executeAlgo };