hedgequantx 2.7.88 → 2.7.90

package/package.json

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

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 modular strategy builder
- * Each strategy is a folder with modular components
+ * Custom Strategy - AI-powered strategy builder
+ * Config flow + AI chat to create strategy, then execute with AI supervision
  */
 
 const chalk = require('chalk');
@@ -11,384 +11,278 @@ const ora = require('ora');
 
 const { getLogoWidth, centerText, displayBanner } = require('../../ui');
 const { prompts } = require('../../utils');
+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');
 
-// 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'));
+  const aiProvider = getActiveProvider();
+  if (!aiProvider) {
+    console.log(chalk.red('\n  No AI Agent connected. Go to AI Agents menu first.'));
     await prompts.waitForEnter();
     return;
   }
   
-  // Create folder
-  const folder = createStrategyFolder(name.trim());
-  if (!folder.success) {
-    console.log(chalk.red(`  Error: ${folder.error}`));
+  const market = checkMarketHours();
+  if (!market.isOpen && !market.message.includes('early')) {
+    console.log(chalk.red(`\n  ${market.message}`));
+    console.log(chalk.gray('  Custom strategy requires market to be open\n'));
     await prompts.waitForEnter();
     return;
   }
   
-  console.log(chalk.green(`  ✓ Created: ${folder.path}`));
-  console.log();
+  const spinner = ora({ text: 'Fetching active accounts...', color: 'yellow' }).start();
+  const allAccounts = await connections.getAllAccounts();
   
-  // 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();
+  if (!allAccounts?.length) { spinner.fail('No accounts found'); await prompts.waitForEnter(); return; }
   
-  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.
+  const activeAccounts = allAccounts.filter(acc => acc.status === 0);
+  if (!activeAccounts.length) { spinner.fail('No active accounts'); await prompts.waitForEnter(); return; }
+  
+  spinner.succeed(`Found ${activeAccounts.length} active account(s)`);
+  
+  // 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 };
+  });
+  accountOptions.push({ label: '< Back', value: 'back' });
+  
+  const selectedAccount = await prompts.selectOption('Select Account:', accountOptions);
+  if (!selectedAccount || selectedAccount === 'back') return;
+  
+  const accountService = selectedAccount.service || connections.getServiceForAccount(selectedAccount.accountId) || service;
+  
+  // Step 2: Select symbol
+  console.log(chalk.cyan.bold('\n  STEP 2: SELECT SYMBOL'));
+  const contract = await selectSymbol(accountService);
+  if (!contract) return;
+  
+  // 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;
+  
+  const dailyTarget = await prompts.numberInput('Daily target ($):', 200, 1, 10000);
+  if (dailyTarget === null) return;
+  
+  const maxRisk = await prompts.numberInput('Max risk ($):', 100, 1, 5000);
+  if (maxRisk === null) return;
+  
+  const showName = await prompts.confirmPrompt('Show account name?', false);
+  if (showName === null) return;
+  
+  // 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 };
+  
+  // 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);
+};
 
-For each module, output JavaScript code in this format:
-\`\`\`javascript:entry.js
-module.exports = {
-  checkLongEntry: (data) => { /* return true/false */ },
-  checkShortEntry: (data) => { /* return true/false */ }
+/** Select symbol */
+const selectSymbol = async (service) => {
+  const spinner = ora({ text: 'Loading symbols...', color: 'yellow' }).start();
+  
+  const result = await service.getContracts();
+  if (!result.success || !result.contracts?.length) { spinner.fail('Failed to load contracts'); return null; }
+  
+  const popular = ['ES', 'NQ', 'MES', 'MNQ', 'M2K', 'RTY', 'YM', 'MYM', 'NKD', 'GC', 'SI', 'CL'];
+  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;
+    if (idxA !== -1) return -1;
+    if (idxB !== -1) return 1;
+    return baseA.localeCompare(baseB);
+  });
+  
+  spinner.succeed(`Found ${result.contracts.length} contracts`);
+  
+  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);
+  return selected === 'back' || selected === null ? null : selected;
 };
-\`\`\`
 
-The 'data' object contains: { price, bid, ask, volume, atr, ema20, ema50, rsi, macd, vwap, high, low, open, close }`;
+/** 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 *****';
+  
+  console.clear();
+  displayBanner();
+  
+  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: ${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('"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.
+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 }];
-  const modules = {};
+  let strategyReady = false, strategyConfig = null;
   
-  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(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;
     
-    if (userInput.toLowerCase() === 'cancel') {
-      deleteStrategy(folder.path);
-      console.log(chalk.gray('\n  Strategy cancelled and folder deleted.'));
-      await prompts.waitForEnter();
-      return;
+    const cmd = userInput.toLowerCase().trim();
+    
+    if (cmd === 'cancel' || cmd === 'exit' || cmd === 'quit') {
+      console.log(chalk.gray('\n  Cancelled.')); 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}`));
+    if (cmd === 'save') {
+      if (strategyConfig) await saveStrategy(strategyConfig, config);
+      else console.log(chalk.yellow('\n  No strategy to save yet.'));
+      continue;
+    }
+    
+    if (cmd === 'run') {
+      if (strategyReady && strategyConfig) {
+        console.log(chalk.green('\n  Launching strategy...'));
+        await launchCustomStrategy(config, strategyConfig, service);
+        return;
       }
-      await prompts.waitForEnter();
-      return;
+      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();
-      
-      // 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();
+      console.log('\n' + chalk.green('  AI: ') + formatResponse(response) + '\n');
       
-    } catch (e) {
-      spinner.fail(`Error: ${e.message}`);
-      messages.pop();
-    }
+      if (response.includes('[STRATEGY_READY]') || response.toLowerCase().includes('strategy is ready')) {
+        strategyReady = true;
+        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! "run" to execute or "save" to save]\n'));
+      }
+    } 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';
-};
+const getDefaultModel = (id) => ({ anthropic: 'claude-sonnet-4-20250514', google: 'gemini-2.5-pro', openai: 'gpt-4o' }[id] || 'claude-sonnet-4-20250514');
 
-/** Format response for terminal */
 const formatResponse = (text) => {
-  const lines = text.split('\n');
+  const lines = text.replace(/\[STRATEGY_READY\]/g, '').trim().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('║'));
-  }
+/** Save strategy */
+const saveStrategy = async (strategyConfig, config) => {
+  ensureStrategiesDir();
+  const name = await prompts.textInput(chalk.cyan('  Strategy name: '));
+  if (!name?.trim()) { console.log(chalk.gray('  Save cancelled.')); return; }
   
-  console.log(chalk.cyan('╠' + '═'.repeat(W) + '╣'));
+  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 });
   
-  // 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('║'));
+  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()
+  };
   
-  console.log(chalk.cyan('╠' + '─'.repeat(W) + '╣'));
-  console.log(chalk.cyan('║') + chalk.red(centerText('[B] BACK', W)) + chalk.cyan('║'));
-  console.log(chalk.cyan('╚' + '═'.repeat(W) + '╝'));
+  fs.writeFileSync(path.join(strategyPath, 'config.json'), JSON.stringify(configFile, null, 2));
+  console.log(chalk.green(`\n  ✓ Saved: ${strategyPath}`));
+};
+
+/** Launch custom strategy with AI supervision */
+const launchCustomStrategy = async (config, strategyConfig, service) => {
+  const { account, contract, contracts, dailyTarget, maxRisk, showName, aiSupervision, aiProvider } = config;
   
-  const input = await prompts.textInput(chalk.cyan('SELECT (1/2/3/B): '));
-  const choice = (input || '').toLowerCase().trim();
+  // 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' };
+  };
   
-  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();
-    }
-  }
+  await executeAlgo({
+    service, account, contract,
+    config: { contracts, dailyTarget, maxRisk, showName },
+    options: { aiSupervision, aiProvider, askAI, subtitle: 'CUSTOM STRATEGY + AI' }
+  });
+};
+
+/** Load saved strategies */
+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)) return { folder: dir.name, ...JSON.parse(fs.readFileSync(configPath, 'utf8')) };
+      return { folder: dir.name, name: dir.name };
+    });
+  } catch (e) { return []; }
 };
 
-module.exports = { customStrategyMenu, loadStrategies, createStrategyFolder, saveModule };
+module.exports = { customStrategyMenu, loadStrategies };

package/src/pages/algo/index.js

@@ -5,6 +5,7 @@
 const chalk = require('chalk');
 const { getLogoWidth, centerText, displayBanner } = require('../../ui');
 const { logger, prompts } = require('../../utils');
+const { getActiveProvider } = require('../ai-agents');
 
 const log = logger.scope('AlgoMenu');
 
@@ -26,33 +27,52 @@ const algoTradingMenu = async (service) => {
     const boxWidth = getLogoWidth();
     const W = boxWidth - 2;
     
+    // Check if AI agent is connected
+    const aiProvider = getActiveProvider();
+    const hasAI = !!aiProvider;
+    
     // Draw menu rectangle
     console.log(chalk.cyan('╔' + '═'.repeat(W) + '╗'));
     console.log(chalk.cyan('║') + chalk.magenta.bold(centerText('ALGO-TRADING', W)) + chalk.cyan('║'));
     console.log(chalk.cyan('╠' + '═'.repeat(W) + '╣'));
     
-    // 3 columns layout
+    // 2 or 3 columns layout based on AI availability
     const col1 = '[1] ONE ACCOUNT';
     const col2 = '[2] COPY TRADING';
-    const col3 = '[3] CUSTOM STRATEGY';
-    const colWidth = Math.floor(W / 3);
-    const lastColWidth = W - 2 * colWidth;
-    
-    const pad1 = Math.floor((colWidth - col1.length) / 2);
-    const pad2 = Math.floor((colWidth - col2.length) / 2);
-    const pad3 = Math.floor((lastColWidth - col3.length) / 2);
+    const col3 = hasAI ? '[3] CUSTOM STRATEGY' : '';
     
-    const col1Str = ' '.repeat(pad1) + chalk.cyan(col1) + ' '.repeat(colWidth - col1.length - pad1);
-    const col2Str = ' '.repeat(pad2) + chalk.yellow(col2) + ' '.repeat(colWidth - col2.length - pad2);
-    const col3Str = ' '.repeat(pad3) + chalk.green(col3) + ' '.repeat(lastColWidth - col3.length - pad3);
-    
-    console.log(chalk.cyan('║') + col1Str + col2Str + col3Str + chalk.cyan('║'));
+    if (hasAI) {
+      // 3 columns
+      const colWidth = Math.floor(W / 3);
+      const lastColWidth = W - 2 * colWidth;
+      
+      const pad1 = Math.floor((colWidth - col1.length) / 2);
+      const pad2 = Math.floor((colWidth - col2.length) / 2);
+      const pad3 = Math.floor((lastColWidth - col3.length) / 2);
+      
+      const col1Str = ' '.repeat(pad1) + chalk.cyan(col1) + ' '.repeat(colWidth - col1.length - pad1);
+      const col2Str = ' '.repeat(pad2) + chalk.yellow(col2) + ' '.repeat(colWidth - col2.length - pad2);
+      const col3Str = ' '.repeat(pad3) + chalk.green(col3) + ' '.repeat(lastColWidth - col3.length - pad3);
+      
+      console.log(chalk.cyan('║') + col1Str + col2Str + col3Str + chalk.cyan('║'));
+    } else {
+      // 2 columns only (no AI connected)
+      const colWidth = Math.floor(W / 2);
+      const pad1 = Math.floor((colWidth - col1.length) / 2);
+      const pad2 = Math.floor((W - colWidth - col2.length) / 2);
+      
+      const col1Str = ' '.repeat(pad1) + chalk.cyan(col1) + ' '.repeat(colWidth - col1.length - pad1);
+      const col2Str = ' '.repeat(pad2) + chalk.yellow(col2) + ' '.repeat(W - colWidth - col2.length - pad2);
+      
+      console.log(chalk.cyan('║') + col1Str + col2Str + 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 promptText = hasAI ? 'SELECT (1/2/3/B): ' : 'SELECT (1/2/B): ';
+    const input = await prompts.textInput(chalk.cyan(promptText));
     const choice = (input || '').toLowerCase().trim();
 
     log.debug('Algo mode selected', { choice });
@@ -71,8 +91,13 @@ const algoTradingMenu = async (service) => {
         await copyTradingMenu();
         break;
       case '3':
-        log.info('Starting Custom Strategy mode');
-        await customStrategyMenu(service);
+        if (hasAI) {
+          log.info('Starting Custom Strategy mode');
+          await customStrategyMenu(service);
+        } else {
+          console.log(chalk.red('  INVALID OPTION'));
+          await new Promise(r => setTimeout(r, 1000));
+        }
         break;
       default:
         console.log(chalk.red('  INVALID OPTION'));

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 };