hedgequantx 2.7.86 → 2.7.88

package/package.json

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

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

@@ -1,6 +1,6 @@
 /**
- * @fileoverview Copy Trading Mode
- * @module pages/algo/copy-trading
+ * Copy Trading Mode - HQX Ultra Scalping
+ * Same as One Account but copies trades to multiple followers
  */
 
 const chalk = require('chalk');
@@ -9,18 +9,18 @@ const readline = require('readline');
 
 const { connections } = require('../../services');
 const { AlgoUI, renderSessionSummary } = require('./ui');
-const { logger, prompts } = require('../../utils');
+const { prompts } = require('../../utils');
 const { checkMarketHours } = require('../../services/rithmic/market');
 
-const log = logger.scope('CopyTrading');
+// Strategy & Market Data
+const { M1 } = require('../../lib/m/s1');
+const { MarketDataFeed } = require('../../lib/data');
 
 /**
  * Copy Trading Menu
  */
 const copyTradingMenu = async () => {
-  log.info('Copy Trading menu opened');
-
-  // Check market hours
+  // Check if market is open
   const market = checkMarketHours();
   if (!market.isOpen && !market.message.includes('early')) {
     console.log();
@@ -30,326 +30,372 @@ const copyTradingMenu = async () => {
     await prompts.waitForEnter();
     return;
   }
-
-  const allConns = connections.getAll();
-
-  if (allConns.length < 2) {
-    console.log();
-    console.log(chalk.yellow(`  Copy Trading requires 2 connected accounts (found: ${allConns.length})`));
+  
+  const spinner = ora({ text: 'Fetching active accounts...', color: 'yellow' }).start();
+  
+  const allAccounts = await connections.getAllAccounts();
+  
+  if (!allAccounts?.length) {
+    spinner.fail('No accounts found');
+    await prompts.waitForEnter();
+    return;
+  }
+  
+  const activeAccounts = allAccounts.filter(acc => acc.status === 0);
+  
+  if (activeAccounts.length < 2) {
+    spinner.fail(`Need at least 2 active accounts (found: ${activeAccounts.length})`);
     console.log(chalk.gray('  Connect to another PropFirm first'));
-    console.log();
     await prompts.waitForEnter();
     return;
   }
-
+  
+  spinner.succeed(`Found ${activeAccounts.length} active accounts`);
+  
+  // Step 1: Select LEAD Account
   console.log();
-  console.log(chalk.yellow.bold('  Copy Trading Setup'));
+  console.log(chalk.cyan.bold('  STEP 1: SELECT LEAD ACCOUNT'));
+  const leadOptions = activeAccounts.map(acc => {
+    const name = acc.accountName || acc.rithmicAccountId || acc.accountId;
+    const balance = acc.balance !== null && acc.balance !== undefined 
+      ? ` - $${acc.balance.toLocaleString()}` 
+      : '';
+    return {
+      label: `${name} (${acc.propfirm || acc.platform || 'Unknown'})${balance}`,
+      value: acc
+    };
+  });
+  leadOptions.push({ label: '< Back', value: 'back' });
+  
+  const leadAccount = await prompts.selectOption('Lead Account:', leadOptions);
+  if (!leadAccount || leadAccount === 'back') return;
+  
+  // Step 2: Select FOLLOWER Account(s)
   console.log();
-
-  // Fetch all accounts
-  const spinner = ora({ text: 'Fetching accounts...', color: 'yellow' }).start();
-  const allAccounts = await fetchAllAccounts(allConns);
-
-  if (allAccounts.length < 2) {
-    spinner.fail('Need at least 2 active accounts');
+  console.log(chalk.yellow.bold('  STEP 2: SELECT FOLLOWER ACCOUNT(S)'));
+  console.log(chalk.gray('  (Select accounts to copy trades to)'));
+  
+  const followers = [];
+  const availableFollowers = activeAccounts.filter(a => a.accountId !== leadAccount.accountId);
+  
+  while (availableFollowers.length > 0) {
+    const remaining = availableFollowers.filter(a => !followers.find(f => f.accountId === a.accountId));
+    if (remaining.length === 0) break;
+    
+    const followerOptions = remaining.map(acc => {
+      const name = acc.accountName || acc.rithmicAccountId || acc.accountId;
+      const balance = acc.balance !== null && acc.balance !== undefined 
+        ? ` - $${acc.balance.toLocaleString()}` 
+        : '';
+      return {
+        label: `${name} (${acc.propfirm || acc.platform || 'Unknown'})${balance}`,
+        value: acc
+      };
+    });
+    
+    if (followers.length > 0) {
+      followerOptions.push({ label: chalk.green('✓ Done selecting followers'), value: 'done' });
+    }
+    followerOptions.push({ label: '< Back', value: 'back' });
+    
+    const msg = followers.length === 0 ? 'Select Follower:' : `Add another follower (${followers.length} selected):`;
+    const selected = await prompts.selectOption(msg, followerOptions);
+    
+    if (!selected || selected === 'back') {
+      if (followers.length === 0) return;
+      break;
+    }
+    if (selected === 'done') break;
+    
+    followers.push(selected);
+    console.log(chalk.green(`  ✓ Added: ${selected.accountName || selected.accountId}`));
+  }
+  
+  if (followers.length === 0) {
+    console.log(chalk.red('  No followers selected'));
     await prompts.waitForEnter();
     return;
   }
-
-  spinner.succeed(`Found ${allAccounts.length} active accounts`);
-
-  // Step 1: Select Lead Account
-  console.log(chalk.cyan('  Step 1: Select LEAD Account'));
-  const leadIdx = await selectAccount('Lead Account:', allAccounts, -1);
-  if (leadIdx === null || leadIdx === -1) return;
-  const lead = allAccounts[leadIdx];
-
-  // Step 2: Select Follower Account
-  console.log();
-  console.log(chalk.cyan('  Step 2: Select FOLLOWER Account'));
-  const followerIdx = await selectAccount('Follower Account:', allAccounts, leadIdx);
-  if (followerIdx === null || followerIdx === -1) return;
-  const follower = allAccounts[followerIdx];
-
+  
   // Step 3: Select Symbol
   console.log();
-  console.log(chalk.cyan('  Step 3: Select Trading Symbol'));
-  const symbol = await selectSymbol(lead.service);
-  if (!symbol) return;
-
+  console.log(chalk.magenta.bold('  STEP 3: SELECT SYMBOL'));
+  const leadService = leadAccount.service || connections.getServiceForAccount(leadAccount.accountId);
+  const contract = await selectSymbol(leadService);
+  if (!contract) return;
+  
   // Step 4: Configure Parameters
   console.log();
-  console.log(chalk.cyan('  Step 4: Configure Parameters'));
-
+  console.log(chalk.cyan.bold('  STEP 4: CONFIGURE PARAMETERS'));
+  console.log();
+  
   const leadContracts = await prompts.numberInput('Lead contracts:', 1, 1, 10);
   if (leadContracts === null) return;
-
-  const followerContracts = await prompts.numberInput('Follower contracts:', leadContracts, 1, 10);
+  
+  const followerContracts = await prompts.numberInput('Follower contracts (each):', leadContracts, 1, 10);
   if (followerContracts === null) return;
-
+  
   const dailyTarget = await prompts.numberInput('Daily target ($):', 400, 1, 10000);
   if (dailyTarget === null) return;
-
+  
   const maxRisk = await prompts.numberInput('Max risk ($):', 200, 1, 5000);
   if (maxRisk === null) return;
-
-  // Step 5: Privacy
-  const showNames = await prompts.selectOption('Account names:', [
-    { label: 'Hide account names', value: false },
-    { label: 'Show account names', value: true },
-  ]);
+  
+  const showNames = await prompts.confirmPrompt('Show account names?', false);
   if (showNames === null) return;
-
-  // Confirm
+  
+  // Summary
   console.log();
-  console.log(chalk.white('  Summary:'));
-  console.log(chalk.cyan(`  Symbol: ${symbol.name}`));
-  console.log(chalk.cyan(`  Lead: ${lead.propfirm} x${leadContracts}`));
-  console.log(chalk.cyan(`  Follower: ${follower.propfirm} x${followerContracts}`));
+  console.log(chalk.white.bold('  SUMMARY:'));
+  console.log(chalk.cyan(`  Symbol: ${contract.name}`));
+  console.log(chalk.cyan(`  Lead: ${leadAccount.propfirm} x${leadContracts}`));
+  console.log(chalk.yellow(`  Followers (${followers.length}):`));
+  for (const f of followers) {
+    console.log(chalk.yellow(`    - ${f.propfirm} x${followerContracts}`));
+  }
   console.log(chalk.cyan(`  Target: $${dailyTarget} | Risk: $${maxRisk}`));
   console.log();
-
+  
   const confirm = await prompts.confirmPrompt('Start Copy Trading?', true);
   if (!confirm) return;
-
-  // Launch
+  
   await launchCopyTrading({
-    lead: { ...lead, symbol, contracts: leadContracts },
-    follower: { ...follower, symbol, contracts: followerContracts },
+    lead: { account: leadAccount, contracts: leadContracts },
+    followers: followers.map(f => ({ account: f, contracts: followerContracts })),
+    contract,
     dailyTarget,
     maxRisk,
-    showNames,
+    showNames
   });
 };
 
 /**
- * Fetch all active accounts from connections
- * @param {Array} allConns - All connections
- * @returns {Promise<Array>}
- */
-const fetchAllAccounts = async (allConns) => {
-  const allAccounts = [];
-
-  for (const conn of allConns) {
-    try {
-      const result = await conn.service.getTradingAccounts();
-      if (result.success && result.accounts) {
-        const active = result.accounts.filter(a => a.status === 0);
-        for (const acc of active) {
-          allAccounts.push({
-            account: acc,
-            service: conn.service,
-            propfirm: conn.propfirm,
-            type: conn.type,
-          });
-        }
-      }
-    } catch (err) {
-      log.warn('Failed to get accounts', { type: conn.type, error: err.message });
-    }
-  }
-
-  return allAccounts;
-};
-
-/**
- * Select account from list
- * @param {string} message - Prompt message
- * @param {Array} accounts - Available accounts
- * @param {number} excludeIdx - Index to exclude
- * @returns {Promise<number|null>}
- */
-const selectAccount = async (message, accounts, excludeIdx) => {
-  const options = accounts
-    .map((a, i) => ({ a, i }))
-    .filter(x => x.i !== excludeIdx)
-    .map(x => {
-      const acc = x.a.account;
-      const balance = acc.balance !== null ? ` ($${acc.balance.toLocaleString()})` : '';
-      return {
-        label: `${x.a.propfirm} - ${acc.accountName || acc.rithmicAccountId || acc.name || acc.accountId}${balance}`,
-        value: x.i,
-      };
-    });
-
-  options.push({ label: '< Cancel', value: -1 });
-  return prompts.selectOption(message, options);
-};
-
-/**
- * Select trading symbol
- * @param {Object} service - Service instance
- * @returns {Promise<Object|null>}
+ * Symbol selection - sorted with popular indices first
  */
 const selectSymbol = async (service) => {
   const spinner = ora({ text: 'Loading symbols...', color: 'yellow' }).start();
-
-  try {
-    // Try Rithmic API first for consistency
-    let contracts = await getContractsFromAPI();
-
-    // Fallback to service
-    if (!contracts && typeof service.getContracts === 'function') {
-      const result = await service.getContracts();
-      if (result.success && result.contracts?.length > 0) {
-        contracts = result.contracts;
-      }
-    }
-
-    if (!contracts || !contracts.length) {
-      spinner.fail('No contracts available');
-      await prompts.waitForEnter();
-      return null;
-    }
-
-    spinner.succeed(`Found ${contracts.length} contracts`);
-
-    // Build options from RAW API data - no static mapping
-    const options = [];
-    let currentGroup = null;
-
-    for (const c of contracts) {
-      // Use RAW API field: contractGroup
-      if (c.contractGroup && c.contractGroup !== currentGroup) {
-        currentGroup = c.contractGroup;
-        options.push({
-          label: chalk.cyan.bold(`── ${currentGroup} ──`),
-          value: null,
-          disabled: true,
-        });
-      }
-
-      // Use RAW API fields: symbol (trading symbol), name (product name), exchange
-      const label = `  ${c.symbol} - ${c.name} (${c.exchange})`;
-      options.push({ label, value: c });
-    }
-
-    options.push({ label: '', value: null, disabled: true });
-    options.push({ label: chalk.gray('< Cancel'), value: null });
-
-    return prompts.selectOption('Trading Symbol:', options);
-  } catch (err) {
-    spinner.fail(`Error loading contracts: ${err.message}`);
-    await prompts.waitForEnter();
+  
+  const contractsResult = await service.getContracts();
+  if (!contractsResult.success || !contractsResult.contracts?.length) {
+    spinner.fail('Failed to load contracts');
     return null;
   }
+  
+  let contracts = contractsResult.contracts;
+  
+  // Sort: Popular indices first
+  const popularPrefixes = ['ES', 'NQ', 'MES', 'MNQ', 'M2K', 'RTY', 'YM', 'MYM', 'NKD', 'GC', 'SI', 'CL'];
+  
+  contracts.sort((a, b) => {
+    const baseA = a.baseSymbol || a.symbol || '';
+    const baseB = b.baseSymbol || b.symbol || '';
+    const idxA = popularPrefixes.findIndex(p => baseA === p || baseA.startsWith(p));
+    const idxB = popularPrefixes.findIndex(p => baseB === p || baseB.startsWith(p));
+    if (idxA !== -1 && idxB !== -1) return idxA - idxB;
+    if (idxA !== -1) return -1;
+    if (idxB !== -1) return 1;
+    return baseA.localeCompare(baseB);
+  });
+  
+  spinner.succeed(`Found ${contracts.length} contracts`);
+  
+  const options = contracts.map(c => ({
+    label: `${c.symbol} - ${c.name} (${c.exchange})`,
+    value: c
+  }));
+  options.push({ label: chalk.gray('< Back'), value: 'back' });
+  
+  const selected = await prompts.selectOption(chalk.yellow('Select Symbol:'), options);
+  return selected === 'back' || selected === null ? null : selected;
 };
 
 /**
- * Get contracts from Rithmic API - RAW data only
- * @returns {Promise<Array|null>}
- */
-const getContractsFromAPI = async () => {
-  const allConns = connections.getAll();
-  const rithmicConn = allConns.find(c => c.type === 'rithmic');
-
-  if (rithmicConn && typeof rithmicConn.service.getContracts === 'function') {
-    const result = await rithmicConn.service.getContracts();
-    if (result.success && result.contracts?.length > 0) {
-      // Return RAW API data - no mapping
-      return result.contracts;
-    }
-  }
-
-  return null;
-};
-
-/**
- * Launch Copy Trading session
- * @param {Object} config - Session configuration
+ * Launch Copy Trading - HQX Ultra Scalping with trade copying
  */
 const launchCopyTrading = async (config) => {
-  const { lead, follower, dailyTarget, maxRisk, showNames } = config;
-
-  // Account names (masked for privacy)
-  const leadName = showNames ? lead.account.accountId : 'HQX Lead *****';
-  const followerName = showNames ? follower.account.accountId : 'HQX Follower *****';
-
+  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 = {
-    leadName,
-    followerName,
-    leadSymbol: lead.symbol.name,
-    followerSymbol: follower.symbol.name,
-    leadQty: lead.contracts,
-    followerQty: follower.contracts,
+    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,
-    platform: lead.account.platform || 'Rithmic',
+    startTime: Date.now(),
+    followersCount: followers.length
   };
-
+  
   let running = true;
   let stopReason = null;
+  let startingPnL = null;
+  let currentPosition = 0;
+  let pendingOrder = false;
+  let tickCount = 0;
   
-  // Measure API latency (CLI <-> API)
-  const measureLatency = async () => {
-    try {
-      const start = Date.now();
-      await lead.service.getPositions(lead.account.accountId);
-      stats.latency = Date.now() - start;
-    } catch (e) {
-      stats.latency = 0;
-    }
-  };
-
-  // Local copy trading - no external server needed
-  ui.addLog('info', `Starting copy trading on ${stats.platform}...`);
-  ui.addLog('info', `Lead: ${stats.leadName} -> Follower: ${stats.followerName}`);
-  ui.addLog('info', `Symbol: ${stats.symbol} | Target: $${dailyTarget} | Risk: $${maxRisk}`);
-  stats.connected = true;
+  // Initialize Strategy
+  const strategy = new M1({ tickSize });
+  strategy.initialize(contractId, tickSize);
   
-  // Track lead positions and copy to follower
-  let lastLeadPositions = [];
+  // Initialize Market Data Feed
+  const marketFeed = new MarketDataFeed({ propfirm: leadAccount.propfirm });
   
-  const pollAndCopy = async () => {
+  // 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 {
-      // Get lead positions
-      const leadResult = await lead.service.getPositions(lead.account.accountId);
-      if (!leadResult.success) return;
+      const orderSide = direction === 'long' ? 0 : 1;
       
-      const currentPositions = leadResult.positions || [];
+      // Place order on LEAD
+      const leadResult = await leadService.placeOrder({
+        accountId: leadAccount.accountId,
+        contractId: contractId,
+        type: 2,
+        side: orderSide,
+        size: lead.contracts
+      });
       
-      // Detect new positions on lead
-      for (const pos of currentPositions) {
-        const existing = lastLeadPositions.find(p => p.contractId === pos.contractId);
-        if (!existing && pos.quantity !== 0) {
-          // New position opened - copy to follower
-          ui.addLog('trade', `Lead opened: ${pos.quantity > 0 ? 'LONG' : 'SHORT'} ${Math.abs(pos.quantity)}x ${pos.symbol || pos.contractId}`);
-          // TODO: Place order on follower account
+      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}`);
+          }
         }
-      }
-      
-      // Detect closed positions
-      for (const oldPos of lastLeadPositions) {
-        const stillOpen = currentPositions.find(p => p.contractId === oldPos.contractId);
-        if (!stillOpen || stillOpen.quantity === 0) {
-          ui.addLog('info', `Lead closed: ${oldPos.symbol || oldPos.contractId}`);
-          // TODO: Close position on follower account
+        
+        // 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}`);
       }
-      
-      lastLeadPositions = currentPositions;
-      
-      // Update P&L from lead
-      const leadPnL = currentPositions.reduce((sum, p) => sum + (p.profitAndLoss || 0), 0);
-      if (leadPnL !== stats.pnl) {
-        const diff = leadPnL - stats.pnl;
-        if (Math.abs(diff) > 0.01 && stats.pnl !== 0) {
-          stats.trades++;
-          if (diff >= 0) stats.wins++;
-          else stats.losses++;
+    } 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;
         }
-        stats.pnl = leadPnL;
       }
       
-      // Check target/risk limits
+      // Check target/risk
       if (stats.pnl >= dailyTarget) {
         stopReason = 'target';
         running = false;
@@ -357,80 +403,66 @@ const launchCopyTrading = async (config) => {
       } else if (stats.pnl <= -maxRisk) {
         stopReason = 'risk';
         running = false;
-        ui.addLog('error', `MAX RISK HIT! -$${Math.abs(stats.pnl).toFixed(2)}`);
+        ui.addLog('error', `MAX RISK! -$${Math.abs(stats.pnl).toFixed(2)}`);
       }
-    } catch (e) {
-      // Silent fail - will retry
-    }
+    } catch (e) { /* silent */ }
   };
-
-  // UI refresh loop
-  const refreshInterval = setInterval(() => {
-    if (running) ui.render(stats);
-  }, 250);
-  
-  // Measure API latency every 5 seconds
-  measureLatency(); // Initial measurement
-  const latencyInterval = setInterval(() => { if (running) measureLatency(); }, 5000);
-  
-  // Poll and copy every 2 seconds
-  pollAndCopy(); // Initial poll
-  const copyInterval = setInterval(() => { if (running) pollAndCopy(); }, 2000);
-
-  // Keyboard handling
-  const cleanupKeys = setupKeyboardHandler(() => {
-    running = false;
-    stopReason = 'manual';
-  });
-
+  
+  // 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) => {
+  await new Promise(resolve => {
     const check = setInterval(() => {
-      if (!running) {
-        clearInterval(check);
-        resolve();
-      }
+      if (!running) { clearInterval(check); resolve(); }
     }, 100);
   });
-
+  
   // Cleanup
   clearInterval(refreshInterval);
-  clearInterval(latencyInterval);
-  clearInterval(copyInterval);
+  clearInterval(pnlInterval);
+  await marketFeed.disconnect();
   if (cleanupKeys) cleanupKeys();
   ui.cleanup();
-
-  // Show summary
-  renderSessionSummary(stats, stopReason);
-  await prompts.waitForEnter();
-};
-
-/**
- * Setup keyboard handler
- * @param {Function} onStop - Stop callback
- * @returns {Function|null} Cleanup function
- */
-const setupKeyboardHandler = (onStop) => {
-  if (!process.stdin.isTTY) return null;
-
-  readline.emitKeypressEvents(process.stdin);
-  process.stdin.setRawMode(true);
+  
+  if (process.stdin.isTTY) process.stdin.setRawMode(false);
   process.stdin.resume();
-
-  const handler = (str, key) => {
-    if (key && (key.name === 'x' || (key.ctrl && key.name === 'c'))) {
-      onStop();
-    }
-  };
-
-  process.stdin.on('keypress', handler);
-
-  return () => {
-    process.stdin.removeListener('keypress', handler);
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode(false);
-    }
-  };
+  
+  // 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 };

package/src/pages/algo/custom-strategy.js

@@ -0,0 +1,394 @@
+/**
+ * Custom Strategy - AI-powered modular strategy builder
+ * Each strategy is a folder with modular components
+ */
+
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const ora = require('ora');
+
+const { getLogoWidth, centerText, displayBanner } = require('../../ui');
+const { prompts } = require('../../utils');
+const { getActiveProvider } = require('../ai-agents');
+const cliproxy = require('../../services/cliproxy');
+
+// Base strategies directory
+const STRATEGIES_DIR = path.join(os.homedir(), '.hqx', 'strategies');
+
+/** Ensure strategies directory exists */
+const ensureStrategiesDir = () => {
+  if (!fs.existsSync(STRATEGIES_DIR)) fs.mkdirSync(STRATEGIES_DIR, { recursive: true });
+};
+
+/** Load all saved strategies (folders) */
+const loadStrategies = () => {
+  ensureStrategiesDir();
+  try {
+    const items = fs.readdirSync(STRATEGIES_DIR, { withFileTypes: true });
+    return items.filter(i => i.isDirectory()).map(dir => {
+      const configPath = path.join(STRATEGIES_DIR, dir.name, 'config.json');
+      if (fs.existsSync(configPath)) {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        return { folder: dir.name, path: path.join(STRATEGIES_DIR, dir.name), ...config };
+      }
+      return { folder: dir.name, path: path.join(STRATEGIES_DIR, dir.name), name: dir.name };
+    });
+  } catch (e) { return []; }
+};
+
+/** Create strategy folder structure */
+const createStrategyFolder = (name) => {
+  ensureStrategiesDir();
+  const folderName = name.toLowerCase().replace(/[^a-z0-9]/g, '-').replace(/-+/g, '-');
+  const strategyPath = path.join(STRATEGIES_DIR, folderName);
+  
+  if (fs.existsSync(strategyPath)) {
+    return { success: false, error: 'Strategy folder already exists', path: null };
+  }
+  
+  fs.mkdirSync(strategyPath, { recursive: true });
+  return { success: true, path: strategyPath, folder: folderName };
+};
+
+/** Save strategy module */
+const saveModule = (strategyPath, moduleName, content) => {
+  const filePath = path.join(strategyPath, moduleName);
+  fs.writeFileSync(filePath, typeof content === 'string' ? content : JSON.stringify(content, null, 2));
+  return filePath;
+};
+
+/** Delete strategy folder */
+const deleteStrategy = (strategyPath) => {
+  if (fs.existsSync(strategyPath)) {
+    fs.rmSync(strategyPath, { recursive: true, force: true });
+    return true;
+  }
+  return false;
+};
+
+/** Custom Strategy Menu */
+const customStrategyMenu = async (service) => {
+  while (true) {
+    console.clear();
+    displayBanner();
+    
+    const boxWidth = getLogoWidth();
+    const W = boxWidth - 2;
+    const aiProvider = getActiveProvider();
+    const strategies = loadStrategies();
+    
+    console.log(chalk.cyan('╔' + '═'.repeat(W) + '╗'));
+    console.log(chalk.cyan('║') + chalk.green.bold(centerText('CUSTOM STRATEGY BUILDER', W)) + chalk.cyan('║'));
+    console.log(chalk.cyan('╠' + '═'.repeat(W) + '╣'));
+    
+    // AI Status
+    if (aiProvider) {
+      const status = `AI: ${aiProvider.name} (${aiProvider.modelName || 'default'})`;
+      console.log(chalk.cyan('║') + chalk.green(centerText('● ' + status, W)) + chalk.cyan('║'));
+    } else {
+      console.log(chalk.cyan('║') + chalk.red(centerText('○ NO AI AGENT CONNECTED', W)) + chalk.cyan('║'));
+    }
+    
+    console.log(chalk.cyan('╠' + '═'.repeat(W) + '╣'));
+    
+    // Options
+    const col1 = '[1] CREATE NEW';
+    const col2 = `[2] MY STRATEGIES (${strategies.length})`;
+    const colWidth = Math.floor(W / 2);
+    const pad1 = Math.floor((colWidth - col1.length) / 2);
+    const pad2 = Math.floor((W - colWidth - col2.length) / 2);
+    console.log(chalk.cyan('║') + 
+      ' '.repeat(pad1) + chalk.yellow(col1) + ' '.repeat(colWidth - col1.length - pad1) +
+      ' '.repeat(pad2) + chalk.cyan(col2) + ' '.repeat(W - colWidth - col2.length - pad2) +
+      chalk.cyan('║'));
+    
+    console.log(chalk.cyan('╠' + '─'.repeat(W) + '╣'));
+    console.log(chalk.cyan('║') + chalk.red(centerText('[B] BACK', W)) + chalk.cyan('║'));
+    console.log(chalk.cyan('╚' + '═'.repeat(W) + '╝'));
+    
+    const input = await prompts.textInput(chalk.cyan('SELECT (1/2/B): '));
+    const choice = (input || '').toLowerCase().trim();
+    
+    if (choice === 'b' || choice === '') return;
+    
+    if (choice === '1') {
+      if (!aiProvider) {
+        console.log(chalk.red('\n  Connect an AI Agent first (AI Agents menu)'));
+        await prompts.waitForEnter();
+        continue;
+      }
+      await createStrategyWizard(aiProvider);
+    } else if (choice === '2') {
+      await myStrategiesMenu(strategies, service);
+    }
+  }
+};
+
+/** AI Wizard to create modular strategy */
+const createStrategyWizard = async (aiProvider) => {
+  console.clear();
+  displayBanner();
+  
+  const boxWidth = getLogoWidth();
+  const W = boxWidth - 2;
+  
+  console.log(chalk.cyan('╔' + '═'.repeat(W) + '╗'));
+  console.log(chalk.cyan('║') + chalk.green.bold(centerText('CREATE STRATEGY WITH AI', W)) + chalk.cyan('║'));
+  console.log(chalk.cyan('╚' + '═'.repeat(W) + '╝'));
+  console.log();
+  
+  // Step 1: Strategy name
+  console.log(chalk.yellow('  STEP 1: Name your strategy'));
+  const name = await prompts.textInput(chalk.cyan('  Strategy name: '));
+  if (!name || !name.trim()) {
+    console.log(chalk.red('  Cancelled'));
+    await prompts.waitForEnter();
+    return;
+  }
+  
+  // Create folder
+  const folder = createStrategyFolder(name.trim());
+  if (!folder.success) {
+    console.log(chalk.red(`  Error: ${folder.error}`));
+    await prompts.waitForEnter();
+    return;
+  }
+  
+  console.log(chalk.green(`  ✓ Created: ${folder.path}`));
+  console.log();
+  
+  // Step 2: Chat with AI to build strategy
+  console.log(chalk.yellow('  STEP 2: Describe your strategy to the AI'));
+  console.log(chalk.gray('  Type your strategy idea in plain English.'));
+  console.log(chalk.gray('  The AI will help you build each module.'));
+  console.log(chalk.gray('  Type "done" when finished, "cancel" to abort.'));
+  console.log();
+  
+  const systemPrompt = `You are an expert algo trading strategy builder for futures (ES, NQ, MES, MNQ, etc).
+Help the user create a modular trading strategy. Build these components:
+
+1. ENTRY CONDITIONS - When to open a position (long/short signals)
+2. EXIT CONDITIONS - Take profit, stop loss, trailing stops
+3. RISK MANAGEMENT - Position sizing, max loss, max positions
+4. FILTERS - Market conditions when NOT to trade
+
+Ask clarifying questions. Be concise. When ready, output each module.
+
+For each module, output JavaScript code in this format:
+\`\`\`javascript:entry.js
+module.exports = {
+  checkLongEntry: (data) => { /* return true/false */ },
+  checkShortEntry: (data) => { /* return true/false */ }
+};
+\`\`\`
+
+The 'data' object contains: { price, bid, ask, volume, atr, ema20, ema50, rsi, macd, vwap, high, low, open, close }`;
+
+  const messages = [{ role: 'system', content: systemPrompt }];
+  const modules = {};
+  
+  console.log(chalk.green('  AI: ') + 'What kind of trading strategy do you want to create?');
+  console.log(chalk.gray('      Example: "A mean reversion strategy that buys when RSI < 30"'));
+  console.log();
+  
+  while (true) {
+    const userInput = await prompts.textInput(chalk.yellow('  You: '));
+    
+    if (!userInput) continue;
+    
+    if (userInput.toLowerCase() === 'cancel') {
+      deleteStrategy(folder.path);
+      console.log(chalk.gray('\n  Strategy cancelled and folder deleted.'));
+      await prompts.waitForEnter();
+      return;
+    }
+    
+    if (userInput.toLowerCase() === 'done') {
+      // Save config
+      saveModule(folder.path, 'config.json', {
+        name: name.trim(),
+        description: modules.description || '',
+        createdAt: new Date().toISOString(),
+        modules: Object.keys(modules).filter(k => k !== 'description')
+      });
+      
+      console.log(chalk.green('\n  ✓ Strategy saved!'));
+      console.log(chalk.cyan(`  Location: ${folder.path}`));
+      console.log(chalk.gray('  Modules created:'));
+      for (const m of Object.keys(modules)) {
+        if (m !== 'description') console.log(chalk.gray(`    - ${m}`));
+      }
+      await prompts.waitForEnter();
+      return;
+    }
+    
+    messages.push({ role: 'user', content: userInput });
+    
+    const spinner = ora({ text: 'AI thinking...', color: 'yellow' }).start();
+    
+    try {
+      const modelId = aiProvider.modelId || getDefaultModel(aiProvider.id);
+      const result = await cliproxy.chatCompletion(modelId, messages);
+      
+      if (!result.success) {
+        spinner.fail(`AI Error: ${result.error}`);
+        messages.pop();
+        continue;
+      }
+      
+      const response = result.response?.choices?.[0]?.message?.content || '';
+      messages.push({ role: 'assistant', content: response });
+      
+      spinner.stop();
+      console.log();
+      
+      // Extract and save code modules
+      const codeBlocks = response.matchAll(/```javascript:(\w+\.js)\n([\s\S]*?)```/g);
+      for (const match of codeBlocks) {
+        const [, filename, code] = match;
+        saveModule(folder.path, filename, code.trim());
+        modules[filename] = true;
+        console.log(chalk.green(`  ✓ Saved module: ${filename}`));
+      }
+      
+      // Extract description if present
+      const descMatch = response.match(/description[:\s]*["']?([^"'\n]+)/i);
+      if (descMatch) modules.description = descMatch[1];
+      
+      // Print AI response (without code blocks for cleaner output)
+      const cleanResponse = response.replace(/```[\s\S]*?```/g, '[code saved]');
+      console.log(chalk.green('  AI: ') + formatResponse(cleanResponse));
+      console.log();
+      
+    } catch (e) {
+      spinner.fail(`Error: ${e.message}`);
+      messages.pop();
+    }
+  }
+};
+
+/** Get default model */
+const getDefaultModel = (providerId) => {
+  const defaults = {
+    anthropic: 'claude-sonnet-4-20250514',
+    google: 'gemini-2.5-pro',
+    openai: 'gpt-4o'
+  };
+  return defaults[providerId] || 'claude-sonnet-4-20250514';
+};
+
+/** Format response for terminal */
+const formatResponse = (text) => {
+  const lines = text.split('\n');
+  return lines.map((l, i) => i === 0 ? l : '      ' + l).join('\n');
+};
+
+/** My Strategies Menu */
+const myStrategiesMenu = async (strategies, service) => {
+  while (true) {
+    console.clear();
+    displayBanner();
+    
+    const boxWidth = getLogoWidth();
+    const W = boxWidth - 2;
+    
+    console.log(chalk.cyan('╔' + '═'.repeat(W) + '╗'));
+    console.log(chalk.cyan('║') + chalk.yellow.bold(centerText('MY STRATEGIES', W)) + chalk.cyan('║'));
+    console.log(chalk.cyan('╠' + '═'.repeat(W) + '╣'));
+    
+    if (strategies.length === 0) {
+      console.log(chalk.cyan('║') + chalk.gray(centerText('No strategies yet', W)) + chalk.cyan('║'));
+    } else {
+      for (let i = 0; i < strategies.length; i++) {
+        const s = strategies[i];
+        const num = `[${i + 1}]`.padEnd(4);
+        const sname = (s.name || s.folder).substring(0, 30).padEnd(32);
+        const modules = s.modules ? `${s.modules.length} modules` : '';
+        const line = `${num} ${sname} ${chalk.gray(modules)}`;
+        console.log(chalk.cyan('║') + '  ' + chalk.white(num) + chalk.cyan(sname) + chalk.gray(modules.padEnd(W - 38)) + chalk.cyan('║'));
+      }
+    }
+    
+    console.log(chalk.cyan('╠' + '─'.repeat(W) + '╣'));
+    console.log(chalk.cyan('║') + chalk.red(centerText('[B] BACK', W)) + chalk.cyan('║'));
+    console.log(chalk.cyan('╚' + '═'.repeat(W) + '╝'));
+    
+    if (strategies.length === 0) {
+      await prompts.waitForEnter();
+      return;
+    }
+    
+    const input = await prompts.textInput(chalk.cyan(`SELECT (1-${strategies.length}/B): `));
+    const choice = (input || '').toLowerCase().trim();
+    
+    if (choice === 'b' || choice === '') return;
+    
+    const num = parseInt(choice);
+    if (!isNaN(num) && num >= 1 && num <= strategies.length) {
+      await strategyDetailMenu(strategies[num - 1], service);
+      strategies.length = 0;
+      strategies.push(...loadStrategies());
+    }
+  }
+};
+
+/** Strategy Detail Menu */
+const strategyDetailMenu = async (strategy, service) => {
+  console.clear();
+  displayBanner();
+  
+  const boxWidth = getLogoWidth();
+  const W = boxWidth - 2;
+  
+  console.log(chalk.cyan('╔' + '═'.repeat(W) + '╗'));
+  console.log(chalk.cyan('║') + chalk.green.bold(centerText((strategy.name || strategy.folder).toUpperCase(), W)) + chalk.cyan('║'));
+  console.log(chalk.cyan('╠' + '═'.repeat(W) + '╣'));
+  
+  // Show modules
+  const files = fs.readdirSync(strategy.path);
+  console.log(chalk.cyan('║') + chalk.gray(centerText(`Path: ${strategy.path}`, W)) + chalk.cyan('║'));
+  console.log(chalk.cyan('╠' + '─'.repeat(W) + '╣'));
+  console.log(chalk.cyan('║') + chalk.white(centerText('MODULES:', W)) + chalk.cyan('║'));
+  
+  for (const f of files) {
+    const icon = f.endsWith('.js') ? '📄' : f.endsWith('.json') ? '⚙️' : '📁';
+    console.log(chalk.cyan('║') + centerText(`${icon} ${f}`, W) + chalk.cyan('║'));
+  }
+  
+  console.log(chalk.cyan('╠' + '═'.repeat(W) + '╣'));
+  
+  // Options: Run, Edit with AI, Delete
+  const opts = ['[1] RUN', '[2] EDIT WITH AI', '[3] DELETE'];
+  const optLine = opts.join('     ');
+  console.log(chalk.cyan('║') + centerText(
+    chalk.green(opts[0]) + '     ' + chalk.yellow(opts[1]) + '     ' + chalk.red(opts[2]), W
+  ) + chalk.cyan('║'));
+  
+  console.log(chalk.cyan('╠' + '─'.repeat(W) + '╣'));
+  console.log(chalk.cyan('║') + chalk.red(centerText('[B] BACK', W)) + chalk.cyan('║'));
+  console.log(chalk.cyan('╚' + '═'.repeat(W) + '╝'));
+  
+  const input = await prompts.textInput(chalk.cyan('SELECT (1/2/3/B): '));
+  const choice = (input || '').toLowerCase().trim();
+  
+  if (choice === '1') {
+    console.log(chalk.yellow('\n  Running custom strategy...'));
+    console.log(chalk.gray('  This will use your connected accounts and market data.'));
+    console.log(chalk.gray('  (Full execution coming soon)'));
+    await prompts.waitForEnter();
+  } else if (choice === '2') {
+    console.log(chalk.yellow('\n  Edit with AI coming soon...'));
+    await prompts.waitForEnter();
+  } else if (choice === '3') {
+    const confirm = await prompts.confirmPrompt(`Delete "${strategy.name || strategy.folder}"?`, false);
+    if (confirm) {
+      deleteStrategy(strategy.path);
+      console.log(chalk.green('\n  ✓ Strategy deleted'));
+      await prompts.waitForEnter();
+    }
+  }
+};
+
+module.exports = { customStrategyMenu, loadStrategies, createStrategyFolder, saveModule };

package/src/pages/algo/index.js

@@ -10,6 +10,7 @@ const log = logger.scope('AlgoMenu');
 
 const { oneAccountMenu } = require('./one-account');
 const { copyTradingMenu } = require('./copy-trading');
+const { customStrategyMenu } = require('./custom-strategy');
 
 /**
  * Algo Trading Menu
@@ -87,27 +88,4 @@ const algoTradingMenu = async (service) => {
   }
 };
 
-/**
- * Custom Strategy Menu - AI-powered strategy creation
- */
-const customStrategyMenu = async (service) => {
-  console.clear();
-  displayBanner();
-  
-  const boxWidth = getLogoWidth();
-  const W = boxWidth - 2;
-  
-  console.log(chalk.cyan('╔' + '═'.repeat(W) + '╗'));
-  console.log(chalk.cyan('║') + chalk.green.bold(centerText('CUSTOM STRATEGY', W)) + chalk.cyan('║'));
-  console.log(chalk.cyan('╠' + '═'.repeat(W) + '╣'));
-  console.log(chalk.cyan('║') + centerText('Create your own trading strategy with AI assistance', W) + chalk.cyan('║'));
-  console.log(chalk.cyan('╠' + '─'.repeat(W) + '╣'));
-  console.log(chalk.cyan('║') + chalk.gray(centerText('Coming soon...', W)) + chalk.cyan('║'));
-  console.log(chalk.cyan('╠' + '─'.repeat(W) + '╣'));
-  console.log(chalk.cyan('║') + chalk.red(centerText('[B] BACK', W)) + chalk.cyan('║'));
-  console.log(chalk.cyan('╚' + '═'.repeat(W) + '╝'));
-  
-  await prompts.waitForEnter();
-};
-
 module.exports = { algoTradingMenu };

package/src/ui/index.js

@@ -70,7 +70,7 @@ const displayBanner = () => {
   
   console.log(chalk.cyan('╠' + '═'.repeat(innerWidth) + '╣'));
   const tagline = isMobile ? `HQX V${version}` : `PROP FUTURES ALGO TRADING  V${version}`;
-  console.log(chalk.cyan('║') + chalk.white(centerText(tagline, innerWidth)) + chalk.cyan('║'));
+  console.log(chalk.cyan('║') + chalk.yellow(centerText(tagline, innerWidth)) + chalk.cyan('║'));
   
   // ALWAYS close the banner
   console.log(chalk.cyan('╚' + '═'.repeat(innerWidth) + '╝'));