hedgequantx 2.7.89 → 2.7.91

package/package.json

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

package/src/app.js

@@ -133,7 +133,7 @@ const banner = async () => {
   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) + '╝'));

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

@@ -0,0 +1,265 @@
+/**
+ * Algo Executor - Shared execution engine for all algo modes
+ * Handles market data, signals, orders, and P&L tracking
+ */
+
+const readline = require('readline');
+const { AlgoUI, renderSessionSummary } = require('./ui');
+const { M1 } = require('../../lib/m/s1');
+const { MarketDataFeed } = require('../../lib/data');
+
+/**
+ * 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: aiSupervision, aiProvider, askAI function
+ */
+const executeAlgo = async ({ service, account, contract, config, options = {} }) => {
+  const { contracts, dailyTarget, maxRisk, showName } = config;
+  const { aiSupervision, aiProvider, askAI, subtitle } = options;
+  
+  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 || (aiSupervision ? 'CUSTOM STRATEGY + AI' : '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;
+  
+  // AI context for supervision
+  const aiContext = { recentTicks: [], recentSignals: [], 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: ${aiSupervision ? 'CUSTOM + AI' : 'HQX Ultra Scalping'}`);
+  ui.addLog('info', `Account: ${accountName}`);
+  ui.addLog('info', `Symbol: ${symbolName} | Qty: ${contracts}`);
+  ui.addLog('info', `Target: $${dailyTarget} | Risk: $${maxRisk}`);
+  if (aiSupervision && aiProvider) ui.addLog('info', `AI: ${aiProvider.name} supervision`);
+  ui.addLog('info', 'Connecting to market data...');
+  
+  // Handle strategy signals
+  strategy.on('signal', async (signal) => {
+    if (!running || pendingOrder || currentPosition !== 0) return;
+    
+    const { direction, entry, stopLoss, takeProfit, confidence } = signal;
+    
+    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)}%)`);
+    
+    // AI Supervision check
+    if (aiSupervision && askAI) {
+      const aiDecision = await askAI(aiContext, signal, { symbolName, currentPosition, stats, dailyTarget, maxRisk });
+      if (!aiDecision.approve) {
+        ui.addLog('info', `AI rejected: ${aiDecision.reason || 'No reason'}`);
+        return;
+      }
+      ui.addLog('info', `AI approved: ${aiDecision.reason || 'OK'}`);
+    }
+    
+    // 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: contracts
+      });
+      
+      if (orderResult.success) {
+        currentPosition = direction === 'long' ? contracts : -contracts;
+        stats.trades++;
+        ui.addLog('fill_' + (direction === 'long' ? 'buy' : 'sell'), 
+          `OPENED ${direction.toUpperCase()} ${contracts}x @ market`);
+        
+        // Bracket orders
+        if (stopLoss && takeProfit) {
+          await service.placeOrder({
+            accountId: account.accountId, contractId, type: 4,
+            side: direction === 'long' ? 1 : 0, size: contracts, stopPrice: stopLoss
+          });
+          await service.placeOrder({
+            accountId: account.accountId, contractId, type: 1,
+            side: direction === 'long' ? 1 : 0, size: contracts, 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 };

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

@@ -1,6 +1,6 @@
 /**
  * Custom Strategy - AI-powered strategy builder
- * Same config flow as One Account, then AI chat to create strategy
+ * Config flow + AI chat to create strategy, then execute with AI supervision
  */
 
 const chalk = require('chalk');
@@ -8,7 +8,6 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const ora = require('ora');
-const readline = require('readline');
 
 const { getLogoWidth, centerText, displayBanner } = require('../../ui');
 const { prompts } = require('../../utils');
@@ -16,18 +15,16 @@ const { connections } = require('../../services');
 const { getActiveProvider } = require('../ai-agents');
 const cliproxy = require('../../services/cliproxy');
 const { checkMarketHours } = require('../../services/rithmic/market');
+const { executeAlgo } = require('./algo-executor');
 
-// 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 });
 };
 
 /** Custom Strategy Menu */
 const customStrategyMenu = async (service) => {
-  // Check AI provider first
   const aiProvider = getActiveProvider();
   if (!aiProvider) {
     console.log(chalk.red('\n  No AI Agent connected. Go to AI Agents menu first.'));
@@ -35,47 +32,30 @@ const customStrategyMenu = async (service) => {
     return;
   }
   
-  // Check market hours
   const market = checkMarketHours();
   if (!market.isOpen && !market.message.includes('early')) {
-    console.log();
-    console.log(chalk.red(`  ${market.message}`));
-    console.log(chalk.gray('  Custom strategy requires market to be open'));
-    console.log();
+    console.log(chalk.red(`\n  ${market.message}`));
+    console.log(chalk.gray('  Custom strategy requires market to be open\n'));
     await prompts.waitForEnter();
     return;
   }
   
-  // Step 1: Fetch accounts
   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;
-  }
+  if (!allAccounts?.length) { spinner.fail('No accounts found'); await prompts.waitForEnter(); return; }
   
   const activeAccounts = allAccounts.filter(acc => acc.status === 0);
-  if (!activeAccounts.length) {
-    spinner.fail('No active accounts');
-    await prompts.waitForEnter();
-    return;
-  }
+  if (!activeAccounts.length) { spinner.fail('No active accounts'); await prompts.waitForEnter(); return; }
   
   spinner.succeed(`Found ${activeAccounts.length} active account(s)`);
   
-  // Step 2: Select account
-  console.log();
-  console.log(chalk.cyan.bold('  STEP 1: SELECT ACCOUNT'));
+  // Step 1: Select account
+  console.log(chalk.cyan.bold('\n  STEP 1: SELECT ACCOUNT'));
   const accountOptions = 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
-    };
+    const balance = acc.balance !== null && acc.balance !== undefined ? ` - $${acc.balance.toLocaleString()}` : '';
+    return { label: `${name} (${acc.propfirm || acc.platform || 'Unknown'})${balance}`, value: acc };
   });
   accountOptions.push({ label: '< Back', value: 'back' });
   
@@ -84,16 +64,13 @@ const customStrategyMenu = async (service) => {
   
   const accountService = selectedAccount.service || connections.getServiceForAccount(selectedAccount.accountId) || service;
   
-  // Step 3: Select symbol
-  console.log();
-  console.log(chalk.cyan.bold('  STEP 2: SELECT SYMBOL'));
+  // Step 2: Select symbol
+  console.log(chalk.cyan.bold('\n  STEP 2: SELECT SYMBOL'));
   const contract = await selectSymbol(accountService);
   if (!contract) return;
   
-  // Step 4: Configure parameters
-  console.log();
-  console.log(chalk.cyan.bold('  STEP 3: CONFIGURE PARAMETERS'));
-  console.log();
+  // Step 3: Configure parameters
+  console.log(chalk.cyan.bold('\n  STEP 3: CONFIGURE PARAMETERS\n'));
   
   const contracts = await prompts.numberInput('Number of contracts:', 1, 1, 10);
   if (contracts === null) return;
@@ -107,50 +84,30 @@ const customStrategyMenu = async (service) => {
   const showName = await prompts.confirmPrompt('Show account name?', false);
   if (showName === null) return;
   
-  // Step 5: AI Supervision
-  console.log();
-  console.log(chalk.cyan.bold('  STEP 4: AI SUPERVISION'));
+  // Step 4: AI Supervision
+  console.log(chalk.cyan.bold('\n  STEP 4: AI SUPERVISION'));
   const aiSupervision = await prompts.confirmPrompt('Enable AI supervision during execution?', true);
   if (aiSupervision === null) return;
   
-  const config = {
-    account: selectedAccount,
-    contract,
-    contracts,
-    dailyTarget,
-    maxRisk,
-    showName,
-    aiSupervision,
-    aiProvider
-  };
+  const config = { account: selectedAccount, contract, contracts, dailyTarget, maxRisk, showName, aiSupervision, aiProvider };
   
-  // Step 6: AI Chat to create/configure strategy
-  console.log();
-  console.log(chalk.cyan.bold('  STEP 5: CREATE YOUR STRATEGY WITH AI'));
-  console.log(chalk.gray('  Describe your trading strategy in plain English.'));
-  console.log(chalk.gray('  The AI will help you build and validate it.'));
-  console.log();
+  // Step 5: AI Chat
+  console.log(chalk.cyan.bold('\n  STEP 5: CREATE YOUR STRATEGY WITH AI'));
+  console.log(chalk.gray('  Describe your trading strategy. AI will help build it.\n'));
   
   await strategyChat(config, accountService);
 };
 
-/** Select symbol - same as one-account */
+/** Select symbol */
 const selectSymbol = async (service) => {
   const spinner = ora({ text: 'Loading symbols...', color: 'yellow' }).start();
   
-  const contractsResult = await service.getContracts();
-  if (!contractsResult.success || !contractsResult.contracts?.length) {
-    spinner.fail('Failed to load contracts');
-    return null;
-  }
-  
-  let contracts = contractsResult.contracts;
+  const result = await service.getContracts();
+  if (!result.success || !result.contracts?.length) { spinner.fail('Failed to load contracts'); return null; }
   
-  // Sort popular indices first
   const popular = ['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 || '';
+  result.contracts.sort((a, b) => {
+    const baseA = a.baseSymbol || a.symbol || '', baseB = b.baseSymbol || b.symbol || '';
     const idxA = popular.findIndex(p => baseA === p || baseA.startsWith(p));
     const idxB = popular.findIndex(p => baseB === p || baseB.startsWith(p));
     if (idxA !== -1 && idxB !== -1) return idxA - idxB;
@@ -159,12 +116,9 @@ const selectSymbol = async (service) => {
     return baseA.localeCompare(baseB);
   });
   
-  spinner.succeed(`Found ${contracts.length} contracts`);
+  spinner.succeed(`Found ${result.contracts.length} contracts`);
   
-  const options = contracts.map(c => ({
-    label: `${c.symbol} - ${c.name} (${c.exchange})`,
-    value: c
-  }));
+  const options = result.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);
@@ -174,75 +128,45 @@ const selectSymbol = async (service) => {
 /** AI Chat for strategy creation */
 const strategyChat = async (config, service) => {
   const { account, contract, contracts, dailyTarget, maxRisk, showName, aiSupervision, aiProvider } = config;
-  
-  const accountName = showName 
-    ? (account.accountName || account.rithmicAccountId || account.accountId) 
-    : 'HQX *****';
+  const accountName = showName ? (account.accountName || account.rithmicAccountId || account.accountId) : 'HQX *****';
   
   console.clear();
   displayBanner();
   
-  const boxWidth = getLogoWidth();
-  const W = boxWidth - 2;
-  
+  const W = getLogoWidth() - 2;
   console.log(chalk.cyan('╔' + '═'.repeat(W) + '╗'));
   console.log(chalk.cyan('║') + chalk.green.bold(centerText('CUSTOM STRATEGY - AI CHAT', W)) + chalk.cyan('║'));
   console.log(chalk.cyan('╠' + '═'.repeat(W) + '╣'));
   console.log(chalk.cyan('║') + centerText(`Account: ${accountName} | Symbol: ${contract.name} | Qty: ${contracts}`, W) + chalk.cyan('║'));
-  console.log(chalk.cyan('║') + centerText(`Target: $${dailyTarget} | Risk: $${maxRisk} | AI Supervision: ${aiSupervision ? 'ON' : 'OFF'}`, W) + chalk.cyan('║'));
-  console.log(chalk.cyan('║') + chalk.gray(centerText(`AI: ${aiProvider.name} (${aiProvider.modelName || 'default'})`, W)) + chalk.cyan('║'));
+  console.log(chalk.cyan('║') + centerText(`Target: $${dailyTarget} | Risk: $${maxRisk} | AI: ${aiSupervision ? 'ON' : 'OFF'}`, W) + chalk.cyan('║'));
+  console.log(chalk.cyan('║') + chalk.gray(centerText(`Provider: ${aiProvider.name}`, W)) + chalk.cyan('║'));
   console.log(chalk.cyan('╠' + '─'.repeat(W) + '╣'));
-  console.log(chalk.cyan('║') + chalk.gray(centerText('Type your strategy. "run" to execute, "save" to save, "cancel" to abort', W)) + chalk.cyan('║'));
-  console.log(chalk.cyan('╚' + '═'.repeat(W) + '╝'));
-  console.log();
+  console.log(chalk.cyan('║') + chalk.gray(centerText('"run" to execute, "save" to save, "cancel" to abort', W)) + chalk.cyan('║'));
+  console.log(chalk.cyan('╚' + '═'.repeat(W) + '╝\n'));
   
-  const systemPrompt = `You are an expert algorithmic trading assistant for futures trading.
-
-Current setup:
-- Account: ${accountName}
-- Symbol: ${contract.name} (${contract.symbol})
-- Contracts: ${contracts}
-- Daily Target: $${dailyTarget}
-- Max Risk: $${maxRisk}
-- AI Supervision: ${aiSupervision ? 'Enabled' : 'Disabled'}
-
-Help the user create a trading strategy. When they describe what they want:
-1. Understand their entry/exit logic
-2. Validate the strategy makes sense
-3. Suggest improvements if needed
-4. When ready, confirm the strategy is valid
-
-Keep responses concise (2-3 sentences max unless explaining strategy details).
-When the user says "run", output: [STRATEGY_READY]
-Include the strategy parameters in JSON format when ready.`;
+  const systemPrompt = `You are an expert algorithmic trading assistant.
+Setup: ${accountName} | ${contract.name} | ${contracts} contracts | Target: $${dailyTarget} | Risk: $${maxRisk}
+Help create a trading strategy. Be concise (2-3 sentences). When ready, say [STRATEGY_READY] with JSON config.`;
 
   const messages = [{ role: 'system', content: systemPrompt }];
-  let strategyReady = false;
-  let strategyConfig = null;
+  let strategyReady = false, strategyConfig = null;
   
-  console.log(chalk.green('  AI: ') + `Hello! I'll help you create a custom strategy for ${contract.name}.`);
-  console.log(chalk.green('      ') + 'What kind of trading strategy do you want to build?');
+  console.log(chalk.green('  AI: ') + `I'll help you create a custom strategy for ${contract.name}. What kind of strategy?`);
   console.log();
   
   while (true) {
     const userInput = await prompts.textInput(chalk.yellow('  You: '));
-    
     if (!userInput) continue;
     
     const cmd = userInput.toLowerCase().trim();
     
     if (cmd === 'cancel' || cmd === 'exit' || cmd === 'quit') {
-      console.log(chalk.gray('\n  Strategy creation cancelled.'));
-      await prompts.waitForEnter();
-      return;
+      console.log(chalk.gray('\n  Cancelled.')); await prompts.waitForEnter(); return;
     }
     
     if (cmd === 'save') {
-      if (strategyConfig) {
-        await saveStrategy(strategyConfig, config);
-      } else {
-        console.log(chalk.yellow('\n  No strategy to save yet. Keep describing your strategy.'));
-      }
+      if (strategyConfig) await saveStrategy(strategyConfig, config);
+      else console.log(chalk.yellow('\n  No strategy to save yet.'));
       continue;
     }
     
@@ -251,114 +175,101 @@ Include the strategy parameters in JSON format when ready.`;
         console.log(chalk.green('\n  Launching strategy...'));
         await launchCustomStrategy(config, strategyConfig, service);
         return;
-      } else {
-        console.log(chalk.yellow('\n  Strategy not ready yet. Describe your entry/exit conditions first.'));
-        continue;
       }
+      console.log(chalk.yellow('\n  Strategy not ready. Describe your entry/exit conditions first.'));
+      continue;
     }
     
     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;
-      }
+      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();
-      console.log(chalk.green('  AI: ') + formatResponse(response));
-      console.log();
       
-      // Check if strategy is ready
+      console.log('\n' + chalk.green('  AI: ') + formatResponse(response) + '\n');
+      
       if (response.includes('[STRATEGY_READY]') || response.toLowerCase().includes('strategy is ready')) {
         strategyReady = true;
-        // Try to extract JSON config
         const jsonMatch = response.match(/\{[\s\S]*\}/);
-        if (jsonMatch) {
-          try { strategyConfig = JSON.parse(jsonMatch[0]); } catch (e) {}
-        }
-        if (!strategyConfig) {
-          strategyConfig = { description: userInput, messages: messages.slice(1) };
-        }
-        console.log(chalk.cyan('  [Strategy ready! Type "run" to execute or "save" to save for later]'));
-        console.log();
+        if (jsonMatch) try { strategyConfig = JSON.parse(jsonMatch[0]); } catch (e) {}
+        if (!strategyConfig) strategyConfig = { description: userInput, messages: messages.slice(1) };
+        console.log(chalk.cyan('  [Strategy ready! "run" to execute or "save" to save]\n'));
       }
-      
-    } catch (e) {
-      spinner.fail(`Error: ${e.message}`);
-      messages.pop();
-    }
+    } catch (e) { spinner.fail(`Error: ${e.message}`); messages.pop(); }
   }
 };
 
-/** Get default model for provider */
-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';
-};
+const getDefaultModel = (id) => ({ anthropic: 'claude-sonnet-4-20250514', google: 'gemini-2.5-pro', openai: 'gpt-4o' }[id] || 'claude-sonnet-4-20250514');
 
-/** Format AI response */
 const formatResponse = (text) => {
-  const clean = text.replace(/\[STRATEGY_READY\]/g, '').trim();
-  const lines = clean.split('\n');
+  const lines = text.replace(/\[STRATEGY_READY\]/g, '').trim().split('\n');
   return lines.map((l, i) => i === 0 ? l : '      ' + l).join('\n');
 };
 
-/** Save strategy to disk */
+/** Save strategy */
 const saveStrategy = async (strategyConfig, config) => {
   ensureStrategiesDir();
-  
   const name = await prompts.textInput(chalk.cyan('  Strategy name: '));
-  if (!name || !name.trim()) {
-    console.log(chalk.gray('  Save cancelled.'));
-    return;
-  }
+  if (!name?.trim()) { console.log(chalk.gray('  Save cancelled.')); return; }
   
   const folderName = name.trim().toLowerCase().replace(/[^a-z0-9]/g, '-');
   const strategyPath = path.join(STRATEGIES_DIR, folderName);
-  
   if (!fs.existsSync(strategyPath)) fs.mkdirSync(strategyPath, { recursive: true });
   
   const configFile = {
-    name: name.trim(),
-    symbol: config.contract.name,
-    contracts: config.contracts,
-    dailyTarget: config.dailyTarget,
-    maxRisk: config.maxRisk,
-    aiSupervision: config.aiSupervision,
-    strategy: strategyConfig,
-    createdAt: new Date().toISOString()
+    name: name.trim(), symbol: config.contract.name, contracts: config.contracts,
+    dailyTarget: config.dailyTarget, maxRisk: config.maxRisk, aiSupervision: config.aiSupervision,
+    strategy: strategyConfig, createdAt: new Date().toISOString()
   };
   
   fs.writeFileSync(path.join(strategyPath, 'config.json'), JSON.stringify(configFile, null, 2));
-  console.log(chalk.green(`\n  ✓ Strategy saved: ${strategyPath}`));
+  console.log(chalk.green(`\n  ✓ Saved: ${strategyPath}`));
 };
 
-/** Launch custom strategy execution */
+/** Launch custom strategy with AI supervision */
 const launchCustomStrategy = async (config, strategyConfig, service) => {
   const { account, contract, contracts, dailyTarget, maxRisk, showName, aiSupervision, aiProvider } = config;
   
-  console.log(chalk.yellow('\n  Custom strategy execution coming soon...'));
-  console.log(chalk.gray('  Your strategy will use the HQX engine with AI supervision.'));
-  console.log();
-  console.log(chalk.white('  Strategy Summary:'));
-  console.log(chalk.gray(`  - Symbol: ${contract.name}`));
-  console.log(chalk.gray(`  - Contracts: ${contracts}`));
-  console.log(chalk.gray(`  - Target: $${dailyTarget}`));
-  console.log(chalk.gray(`  - Risk: $${maxRisk}`));
-  console.log(chalk.gray(`  - AI Supervision: ${aiSupervision ? 'Enabled' : 'Disabled'}`));
-  
-  await prompts.waitForEnter();
+  // AI supervision function
+  const askAI = async (aiContext, signal, ctx) => {
+    if (!aiSupervision) return { approve: true };
+    
+    const prompt = `Trading supervisor check:
+Symbol: ${ctx.symbolName} | Position: ${ctx.currentPosition === 0 ? 'FLAT' : (ctx.currentPosition > 0 ? 'LONG' : 'SHORT')}
+P&L: $${ctx.stats.pnl.toFixed(2)} | Trades: ${ctx.stats.trades} (W:${ctx.stats.wins} L:${ctx.stats.losses})
+Strategy: ${JSON.stringify(strategyConfig.description || strategyConfig).substring(0, 200)}
+Signal: ${signal.direction.toUpperCase()} @ ${signal.entry.toFixed(2)} (${(signal.confidence * 100).toFixed(0)}%)
+Recent prices: ${aiContext.recentTicks.slice(-5).map(t => t.price?.toFixed(2)).join(', ') || 'N/A'}
+Reply JSON: {"approve": true/false, "reason": "brief"}`;
+
+    try {
+      const modelId = aiProvider.modelId || getDefaultModel(aiProvider.id);
+      const result = await cliproxy.chatCompletion(modelId, [
+        { role: 'system', content: 'Trading supervisor. JSON only.' },
+        { role: 'user', content: prompt }
+      ]);
+      
+      if (result.success) {
+        const content = result.response?.choices?.[0]?.message?.content || '';
+        const match = content.match(/\{[\s\S]*\}/);
+        if (match) return JSON.parse(match[0]);
+      }
+    } catch (e) { /* fallback */ }
+    return { approve: true, reason: 'AI unavailable' };
+  };
+  
+  await executeAlgo({
+    service, account, contract,
+    config: { contracts, dailyTarget, maxRisk, showName },
+    options: { aiSupervision, aiProvider, askAI, subtitle: 'CUSTOM STRATEGY + AI' }
+  });
 };
 
 /** Load saved strategies */
@@ -368,9 +279,7 @@ const loadStrategies = () => {
     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)) {
-        return { folder: dir.name, ...JSON.parse(fs.readFileSync(configPath, 'utf8')) };
-      }
+      if (fs.existsSync(configPath)) return { folder: dir.name, ...JSON.parse(fs.readFileSync(configPath, 'utf8')) };
       return { folder: dir.name, name: dir.name };
     });
   } catch (e) { return []; }

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

@@ -4,16 +4,11 @@
 
 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 { executeAlgo } = require('./algo-executor');
 
 
 
@@ -80,7 +75,12 @@ const oneAccountMenu = async (service) => {
   const config = await configureAlgo(selectedAccount, contract);
   if (!config) return;
   
-  await launchAlgo(accountService, selectedAccount, contract, config);
+  await executeAlgo({
+    service: accountService,
+    account: selectedAccount,
+    contract,
+    config
+  });
 };
 
 /**
@@ -158,286 +158,4 @@ const configureAlgo = async (account, contract) => {
   return { contracts, dailyTarget, maxRisk, showName };
 };
 
-/**
- * Launch algo trading - HQX Ultra Scalping Strategy
- * Real-time market data + Strategy signals + Auto order execution
- */
-const launchAlgo = async (service, account, contract, config) => {
-  const { contracts, dailyTarget, maxRisk, showName } = config;
-  
-  // Use RAW API fields
-  const accountName = showName 
-    ? (account.accountName || account.rithmicAccountId || account.accountId) 
-    : 'HQX *****';
-  const symbolName = contract.name;
-  const contractId = contract.id;
-  const connectionType = account.platform || 'Rithmic';
-  const tickSize = contract.tickSize || 0.25;
-  
-  const ui = new AlgoUI({ subtitle: 'HQX Ultra Scalping', mode: 'one-account' });
-  
-  const stats = {
-    accountName,
-    symbol: symbolName,
-    qty: contracts,
-    target: dailyTarget,
-    risk: maxRisk,
-    propfirm: account.propfirm || 'Unknown',
-    platform: connectionType,
-    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; // Current position qty (+ long, - short)
-  let pendingOrder = false; // Prevent duplicate orders
-  let tickCount = 0;
-  
-  // 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', `Connection: ${connectionType}`);
-  ui.addLog('info', `Account: ${accountName}`);
-  ui.addLog('info', `Symbol: ${symbolName} | Qty: ${contracts}`);
-  ui.addLog('info', `Target: $${dailyTarget} | Max Risk: $${maxRisk}`);
-  ui.addLog('info', 'Connecting to market data...');
-  
-  // Handle strategy signals
-  strategy.on('signal', async (signal) => {
-    if (!running || pendingOrder || currentPosition !== 0) return;
-    
-    const { side, direction, entry, stopLoss, takeProfit, confidence } = signal;
-    
-    ui.addLog('signal', `${direction.toUpperCase()} signal @ ${entry.toFixed(2)} (${(confidence * 100).toFixed(0)}%)`);
-    
-    // Place order via API
-    pendingOrder = true;
-    try {
-      const orderSide = direction === 'long' ? 0 : 1; // 0=Buy, 1=Sell
-      const orderResult = await service.placeOrder({
-        accountId: account.accountId,
-        contractId: contractId,
-        type: 2, // Market order
-        side: orderSide,
-        size: contracts
-      });
-      
-      if (orderResult.success) {
-        currentPosition = direction === 'long' ? contracts : -contracts;
-        stats.trades++;
-        ui.addLog('trade', `OPENED ${direction.toUpperCase()} ${contracts}x @ market`);
-        
-        // Place bracket orders (SL/TP)
-        if (stopLoss && takeProfit) {
-          // Stop Loss
-          await service.placeOrder({
-            accountId: account.accountId,
-            contractId: contractId,
-            type: 4, // Stop order
-            side: direction === 'long' ? 1 : 0, // Opposite side
-            size: contracts,
-            stopPrice: stopLoss
-          });
-          
-          // Take Profit
-          await service.placeOrder({
-            accountId: account.accountId,
-            contractId: contractId,
-            type: 1, // Limit order
-            side: direction === 'long' ? 1 : 0,
-            size: contracts,
-            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();
-    
-    // Feed tick to strategy
-    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;
-    
-    // Log every 100th tick to show activity
-    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 = 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 account P&L from API
-  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;
-          
-          // Record trade result in strategy
-          if (stats.pnl !== 0) {
-            strategy.recordTradeResult(stats.pnl);
-          }
-        }
-      }
-      
-      // Check positions
-      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 side = pos.quantity > 0 ? 'LONG' : 'SHORT';
-          const pnl = pos.profitAndLoss || 0;
-          
-          // Check if position closed (win/loss)
-          if (pnl > 0) stats.wins = Math.max(stats.wins, 1);
-          else if (pnl < 0) stats.losses = Math.max(stats.losses, 1);
-        } else {
-          currentPosition = 0;
-        }
-      }
-      
-      // 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) {
-      // Silently handle polling errors
-    }
-  };
-  
-  // Start polling and UI refresh
-  const refreshInterval = setInterval(() => { if (running) ui.render(stats); }, 250);
-  const pnlInterval = setInterval(() => { if (running) pollPnL(); }, 2000);
-  pollPnL(); // Initial poll
-  
-  // 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`;
-  
-  // Summary
-  renderSessionSummary(stats, stopReason);
-  
-  console.log('\n  Returning to menu in 3 seconds...');
-  await new Promise(resolve => setTimeout(resolve, 3000));
-};
-
 module.exports = { oneAccountMenu };

package/src/pages/algo/ui.js

@@ -127,7 +127,7 @@ class AlgoUI {
     
     // Separator + title
     this._line(chalk.cyan(BOX.ML + BOX.H.repeat(W) + BOX.MR));
-    this._line(chalk.cyan(BOX.V) + chalk.white(center(`PROP FUTURES ALGO TRADING  V${version}`, W)) + chalk.cyan(BOX.V));
+    this._line(chalk.cyan(BOX.V) + chalk.yellow(center(`PROP FUTURES ALGO TRADING  V${version}`, W)) + chalk.cyan(BOX.V));
     this._line(chalk.cyan(BOX.ML + BOX.H.repeat(W) + BOX.MR));
     this._line(chalk.cyan(BOX.V) + chalk.yellow(center((this.config.subtitle || 'HQX ALGO TRADING').toUpperCase(), W)) + chalk.cyan(BOX.V));
   }
@@ -387,7 +387,7 @@ const renderSessionSummary = (stats, stopReason) => {
   
   // Separator + title
   console.log(chalk.cyan(BOX.ML + BOX.H.repeat(W) + BOX.MR));
-  console.log(chalk.cyan(BOX.V) + chalk.white(center(`PROP FUTURES ALGO TRADING  V${version}`, W)) + chalk.cyan(BOX.V));
+  console.log(chalk.cyan(BOX.V) + chalk.yellow(center(`PROP FUTURES ALGO TRADING  V${version}`, W)) + chalk.cyan(BOX.V));
   console.log(chalk.cyan(BOX.ML + BOX.H.repeat(W) + BOX.MR));
   console.log(chalk.cyan(BOX.V) + chalk.yellow(center('SESSION SUMMARY', W)) + chalk.cyan(BOX.V));
   

package/src/ui/menu.js

@@ -48,7 +48,7 @@ const createBoxMenu = async (title, items, options = {}) => {
     });
     
     console.log(chalk.cyan('╠' + '═'.repeat(innerWidth) + '╣'));
-    console.log(chalk.cyan('║') + chalk.white(centerText(`PROP FUTURES ALGO TRADING  V${version}`, innerWidth)) + chalk.cyan('║'));
+    console.log(chalk.cyan('║') + chalk.yellow(centerText(`PROP FUTURES ALGO TRADING  V${version}`, innerWidth)) + chalk.cyan('║'));
     
     // Stats bar if provided
     if (options.statsLine) {